sfx2/source/view/classificationcontroller.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <cppuhelper/implbase.hxx>
  11 #include <svtools/toolboxcontroller.hxx>
  12 #include <com/sun/star/lang/XServiceInfo.hpp>
  13
  14 #include <com/sun/star/uno/XComponentContext.hpp>
  15 #include <com/sun/star/frame/XFrame.hpp>
  16
  17 #include <vcl/vclptr.hxx>
  18 #include <vcl/lstbox.hxx>
  19 #include <vcl/svapp.hxx>
  20 #include <toolkit/helper/vclunohelper.hxx>
  21 #include <vcl/toolbox.hxx>
  22 #include <vcl/fixed.hxx>
  23 #include <sfx2/viewfrm.hxx>
  24 #include <sfx2/classificationhelper.hxx>
  25 #include <sfx2/strings.hrc>
  26 #include <sfx2/sfxresid.hxx>
  27 #include <cppuhelper/supportsservice.hxx>
  28 #include <comphelper/propertysequence.hxx>
  29 #include <comphelper/dispatchcommand.hxx>
  30 #include <comphelper/configurationlistener.hxx>
  31
  32 using namespace com::sun::star;
  33
  34 namespace sfx2
  35 {
  36
  37 class ClassificationCategoriesController;
  38 using ClassificationPropertyListenerBase = comphelper::ConfigurationListenerProperty<OUString>;
  39
  40 /// Listens to configuration changes, so no restart is needed after setting the classification path.
  41 class ClassificationPropertyListener : public ClassificationPropertyListenerBase
  42 {
  43     ClassificationCategoriesController& m_rController;
  44
  45 public:
  46     ClassificationPropertyListener(const rtl::Reference<comphelper::ConfigurationListener>& xListener, ClassificationCategoriesController& rController);
  47     void setProperty(const uno::Any& rProperty) override;
  48 };
  49
  50 using ClassificationCategoriesControllerBase = cppu::ImplInheritanceHelper<svt::ToolboxController, lang::XServiceInfo>;
  51
  52 class ClassificationControl;
  53
  54 /// Controller for .uno:ClassificationApply.
  55 class ClassificationCategoriesController : public ClassificationCategoriesControllerBase
  56 {
  57     VclPtr<ClassificationControl> m_pClassification;
  58     rtl::Reference<comphelper::ConfigurationListener> m_xListener;
  59     ClassificationPropertyListener m_aPropertyListener;
  60
  61     DECL_LINK(SelectHdl, ListBox&, void);
  62
  63 public:
  64     explicit ClassificationCategoriesController(const uno::Reference<uno::XComponentContext>& rContext);
  65
  66     // XServiceInfo
  67     OUString SAL_CALL getImplementationName() override;
  68     sal_Bool SAL_CALL supportsService(const OUString& rServiceName) override;
  69     uno::Sequence<OUString> SAL_CALL getSupportedServiceNames() override;
  70
  71     // XComponent
  72     void SAL_CALL dispose() override;
  73
  74     // XToolbarController
  75     uno::Reference<awt::XWindow> SAL_CALL createItemWindow(const uno::Reference<awt::XWindow>& rParent) override;
  76
  77     // XStatusListener
  78     void SAL_CALL statusChanged(const frame::FeatureStateEvent& rEvent) override;
  79
  80     void removeEntries();
  81 };
  82
  83 /// Classification control is the parent of all widgets that belongs to ClassificationCategoriesController.
  84 class SAL_WARN_UNUSED ClassificationControl : public vcl::Window
  85 {
  86     VclPtr<FixedText> m_pLabel;
  87     VclPtr<ListBox> m_pCategory;
  88     void SetOptimalSize();
  89     void DataChanged(const DataChangedEvent& rEvent) override;
  90
  91 public:
  92     explicit ClassificationControl(vcl::Window* pParent);
  93     ~ClassificationControl() override;
  94     void dispose() override;
  95     void Resize() override;
  96     const VclPtr<ListBox>& getCategory()
  97     {
  98         return m_pCategory;
  99     }
 100     sfx::ClassificationCreationOrigin getExistingClassificationOrigin();
 101     void toggleInteractivityOnOrigin();
 102     void setCategoryStateFromPolicy(SfxClassificationHelper & rHelper);
 103 };
 104
 105 namespace
 106 {
 107
 108 OUString const & getCategoryType()
 109 {
 110     return SfxClassificationHelper::policyTypeToString(SfxClassificationHelper::getPolicyType());
 111 }
 112
 113 } // end anonymous namespace
 114
 115 ClassificationPropertyListener::ClassificationPropertyListener(const rtl::Reference<comphelper::ConfigurationListener>& xListener, ClassificationCategoriesController& rController)
 116     : ClassificationPropertyListenerBase(xListener, "WritePath")
 117     , m_rController(rController)
 118 {
 119 }
 120
 121 void ClassificationPropertyListener::setProperty(const uno::Any& /*rProperty*/)
 122 {
 123     // So that its gets re-filled with entries from the new policy.
 124     m_rController.removeEntries();
 125 }
 126
 127 ClassificationCategoriesController::ClassificationCategoriesController(const uno::Reference<uno::XComponentContext>& rContext)
 128     : ClassificationCategoriesControllerBase(rContext, uno::Reference<frame::XFrame>(), OUString(".uno:ClassificationApply"))
 129     , m_pClassification(nullptr)
 130     , m_xListener(new comphelper::ConfigurationListener("/org.openoffice.Office.Paths/Paths/Classification"))
 131     , m_aPropertyListener(m_xListener, *this)
 132 {
 133
 134 }
 135
 136 OUString ClassificationCategoriesController::getImplementationName()
 137 {
 138     return OUString("com.sun.star.comp.sfx2.ClassificationCategoriesController");
 139 }
 140
 141 sal_Bool ClassificationCategoriesController::supportsService(const OUString& rServiceName)
 142 {
 143     return cppu::supportsService(this, rServiceName);
 144 }
 145
 146 uno::Sequence<OUString> ClassificationCategoriesController::getSupportedServiceNames()
 147 {
 148     return { "com.sun.star.frame.ToolbarController" };
 149 }
 150
 151 void ClassificationCategoriesController::dispose()
 152 {
 153     SolarMutexGuard aSolarMutexGuard;
 154
 155     svt::ToolboxController::dispose();
 156     m_pClassification.disposeAndClear();
 157     m_aPropertyListener.dispose();
 158     m_xListener->dispose();
 159 }
 160
 161 uno::Reference<awt::XWindow> ClassificationCategoriesController::createItemWindow(const uno::Reference<awt::XWindow>& rParent)
 162 {
 163     VclPtr<vcl::Window> pParent = VCLUnoHelper::GetWindow(rParent);
 164     auto pToolbar = dynamic_cast<ToolBox*>(pParent.get());
 165     if (pToolbar)
 166     {
 167         m_pClassification = VclPtr<ClassificationControl>::Create(pToolbar);
 168         m_pClassification->getCategory()->SetSelectHdl(LINK(this, ClassificationCategoriesController, SelectHdl));
 169     }
 170
 171     return VCLUnoHelper::GetInterface(m_pClassification);
 172 }
 173
 174 IMPL_LINK(ClassificationCategoriesController, SelectHdl, ListBox&, rCategory, void)
 175 {
 176     m_pClassification->toggleInteractivityOnOrigin();
 177
 178     if (m_pClassification->getExistingClassificationOrigin() == sfx::ClassificationCreationOrigin::MANUAL)
 179     {
 180         SfxObjectShell* pObjectShell = SfxObjectShell::Current();
 181         if (!pObjectShell)
 182             return;
 183         SfxClassificationHelper aHelper(pObjectShell->getDocProperties());
 184         m_pClassification->setCategoryStateFromPolicy(aHelper);
 185     }
 186     else
 187     {
 188         OUString aEntry = rCategory.GetSelectedEntry();
 189
 190         OUString aType = getCategoryType();
 191         uno::Sequence<beans::PropertyValue> aPropertyValues(comphelper::InitPropertySequence({
 192             {"Name", uno::makeAny(aEntry)},
 193             {"Type", uno::makeAny(aType)},
 194         }));
 195         comphelper::dispatchCommand(".uno:ClassificationApply", aPropertyValues);
 196     }
 197 }
 198
 199 void ClassificationCategoriesController::statusChanged(const frame::FeatureStateEvent& /*rEvent*/)
 200 {
 201     if (!m_pClassification)
 202         return;
 203
 204     SfxObjectShell* pObjectShell = SfxObjectShell::Current();
 205     if (!pObjectShell)
 206         return;
 207
 208     SfxClassificationHelper aHelper(pObjectShell->getDocProperties());
 209
 210     //toggle if the pop-up is enabled/disabled
 211     m_pClassification->toggleInteractivityOnOrigin();
 212
 213     // check if classification was set via the advanced dialog
 214     if (m_pClassification->getExistingClassificationOrigin() != sfx::ClassificationCreationOrigin::MANUAL)
 215     {
 216         VclPtr<ListBox> pCategories = m_pClassification->getCategory();
 217         if (pCategories->GetEntryCount() == 0)
 218         {
 219             std::vector<OUString> aNames = aHelper.GetBACNames();
 220             for (const OUString& rName : aNames)
 221                 pCategories->InsertEntry(rName);
 222             // Normally VclBuilder::makeObject() does this.
 223             pCategories->EnableAutoSize(true);
 224         }
 225     }
 226
 227     // Restore state based on the doc. model.
 228     m_pClassification->setCategoryStateFromPolicy(aHelper);
 229
 230 }
 231
 232 void ClassificationCategoriesController::removeEntries()
 233 {
 234     m_pClassification->getCategory()->Clear();
 235 }
 236
 237 // WB_NOLABEL means here that the control won't be replaced with a label
 238 // when it wouldn't fit the available space.
 239 ClassificationControl::ClassificationControl(vcl::Window* pParent)
 240     : Window(pParent, WB_DIALOGCONTROL | WB_NOLABEL)
 241 {
 242     m_pLabel = VclPtr<FixedText>::Create(this, WB_CENTER);
 243     m_pCategory = VclPtr<ListBox>::Create(this, WB_CLIPCHILDREN|WB_LEFT|WB_VCENTER|WB_3DLOOK|WB_DROPDOWN|WB_SIMPLEMODE);
 244
 245     OUString aText;
 246     switch (SfxClassificationHelper::getPolicyType())
 247     {
 248     case SfxClassificationPolicyType::IntellectualProperty:
 249         aText = SfxResId(STR_CLASSIFIED_INTELLECTUAL_PROPERTY);
 250         break;
 251     case SfxClassificationPolicyType::NationalSecurity:
 252         aText = SfxResId(STR_CLASSIFIED_NATIONAL_SECURITY);
 253         break;
 254     case SfxClassificationPolicyType::ExportControl:
 255         aText = SfxResId(STR_CLASSIFIED_EXPORT_CONTROL);
 256         break;
 257     }
 258     Size aTextSize(m_pLabel->GetTextWidth(aText), m_pLabel->GetTextHeight());
 259
 260     // Padding.
 261     aTextSize.AdjustWidth(12 );
 262     m_pLabel->SetText(aText);
 263     m_pLabel->SetSizePixel(aTextSize);
 264     m_pLabel->Show();
 265
 266     m_pCategory->Show();
 267
 268     SetOptimalSize();
 269 }
 270
 271 ClassificationControl::~ClassificationControl()
 272 {
 273     disposeOnce();
 274 }
 275
 276 void ClassificationControl::dispose()
 277 {
 278     m_pLabel.disposeAndClear();
 279     m_pCategory.disposeAndClear();
 280     vcl::Window::dispose();
 281 }
 282
 283 void ClassificationControl::Resize()
 284 {
 285     // Give the label what it wants, and the remaining size to the listbox.
 286     Size aSize(GetOutputSizePixel());
 287
 288     long nWLabel = m_pLabel->GetOutputSizePixel().Width();
 289     long nW = aSize.Width();
 290     long nH = aSize.Height();
 291
 292     long nPrefHeight = m_pLabel->get_preferred_size().Height();
 293     long nOffset = (nH - nPrefHeight) / 2;
 294     m_pLabel->SetPosSizePixel(Point(0, nOffset), Size(nWLabel, nPrefHeight));
 295
 296     nPrefHeight = m_pCategory->get_preferred_size().Height();
 297     nOffset = (nH - nPrefHeight) / 2;
 298     m_pCategory->SetPosSizePixel(Point(0 + nWLabel, nOffset), Size(nW - nWLabel, nPrefHeight));
 299 }
 300
 301 void ClassificationControl::SetOptimalSize()
 302 {
 303     // Same as SvxColorDockingWindow.
 304     const Size aLogicalAttrSize(150, 0);
 305     Size aSize(LogicToPixel(aLogicalAttrSize, MapMode(MapUnit::MapAppFont)));
 306
 307     Point aPosition = m_pCategory->GetPosPixel();
 308
 309     aSize.setHeight( std::max(aSize.Height(), m_pLabel->get_preferred_size().Height()) );
 310     aSize.setHeight( std::max(aSize.Height(), m_pCategory->get_preferred_size().Height()) );
 311
 312     aSize.setWidth( aPosition.X() + aSize.Width() );
 313
 314     SetSizePixel(aSize);
 315 }
 316
 317 void ClassificationControl::DataChanged(const DataChangedEvent& rEvent)
 318 {
 319     if ((rEvent.GetType() == DataChangedEventType::SETTINGS) && (rEvent.GetFlags() & AllSettingsFlags::STYLE))
 320         SetOptimalSize();
 321
 322     toggleInteractivityOnOrigin();
 323
 324     Window::DataChanged(rEvent);
 325 }
 326
 327 sfx::ClassificationCreationOrigin ClassificationControl::getExistingClassificationOrigin()
 328 {
 329     SfxObjectShell* pObjectShell = SfxObjectShell::Current();
 330     if (!pObjectShell)
 331         return sfx::ClassificationCreationOrigin::NONE;
 332
 333     uno::Reference<document::XDocumentProperties> xDocumentProperties = pObjectShell->getDocProperties();
 334     uno::Reference<beans::XPropertyContainer> xPropertyContainer = xDocumentProperties->getUserDefinedProperties();
 335
 336     sfx::ClassificationKeyCreator aKeyCreator(SfxClassificationHelper::getPolicyType());
 337     return sfx::getCreationOriginProperty(xPropertyContainer, aKeyCreator);
 338 }
 339
 340 void ClassificationControl::toggleInteractivityOnOrigin()
 341 {
 342     if (getExistingClassificationOrigin() == sfx::ClassificationCreationOrigin::MANUAL)
 343     {
 344         Disable();
 345     }
 346     else
 347     {
 348         Enable();
 349     }
 350 }
 351
 352 void ClassificationControl::setCategoryStateFromPolicy(SfxClassificationHelper & rHelper)
 353 {
 354     const OUString& rCategoryName = rHelper.GetBACName(SfxClassificationHelper::getPolicyType());
 355     if (!rCategoryName.isEmpty())
 356     {
 357         getCategory()->SelectEntry(rCategoryName);
 358     }
 359 }
 360
 361 } // namespace sfx2
 362
 363 extern "C" SAL_DLLPUBLIC_EXPORT uno::XInterface* com_sun_star_sfx2_ClassificationCategoriesController_get_implementation(uno::XComponentContext* pContext, const uno::Sequence<uno::Any>&)
 364 {
 365     return cppu::acquire(new sfx2::ClassificationCategoriesController(pContext));
 366 }
 367
 368 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */