chart2/source/controller/sidebar/ChartTypePanel.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include "ChartTypePanel.hxx"
  21
  22 #include <bitmaps.hlst>
  23 #include <ChartController.hxx>
  24 #include <ChartModel.hxx>
  25 #include <ChartModelHelper.hxx>
  26 #include <ChartResourceGroupDlgs.hxx>
  27 #include <ChartResourceGroups.hxx>
  28 #include <ChartTypeDialogController.hxx>
  29 #include <ChartTypeHelper.hxx>
  30 #include <DiagramHelper.hxx>
  31 #include <ResId.hxx>
  32 #include <strings.hrc>
  33 #include <unonames.hxx>
  34
  35 #include <sfx2/bindings.hxx>
  36 #include <sfx2/dispatch.hxx>
  37 #include <sfx2/sidebar/ControlFactory.hxx>
  38
  39 #include <com/sun/star/chart2/DataPointGeometry3D.hpp>
  40 #include <com/sun/star/chart2/XChartTypeContainer.hpp>
  41 #include <com/sun/star/chart2/XCoordinateSystemContainer.hpp>
  42 #include <com/sun/star/chart2/XDiagram.hpp>
  43
  44 #include <vcl/field.hxx>
  45 #include <vcl/fixed.hxx>
  46 #include <vcl/lstbox.hxx>
  47 #include <vcl/toolbox.hxx>
  48 #include <vcl/button.hxx>
  49
  50 #include <svl/intitem.hxx>
  51 #include <svl/stritem.hxx>
  52
  53 #include <comphelper/processfactory.hxx>
  54 #include <svtools/valueset.hxx>
  55 #include <tools/diagnose_ex.h>
  56
  57 using namespace css;
  58 using namespace css::uno;
  59
  60 namespace chart
  61 {
  62 namespace sidebar
  63 {
  64 ChartTypePanel::ChartTypePanel(vcl::Window* pParent,
  65                                const css::uno::Reference<css::frame::XFrame>& rxFrame,
  66                                ::chart::ChartController* pController)
  67     : PanelLayout(pParent, "ChartTypePanel", "modules/schart/ui/sidebartype.ui", rxFrame, true)
  68     , maContext()
  69     , mxModel(pController->getModel())
  70     , mxListener(new ChartSidebarModifyListener(this))
  71     , mbModelValid(true)
  72     , m_pDim3DLookResourceGroup(new Dim3DLookResourceGroup(m_xBuilder.get()))
  73     , m_pStackingResourceGroup(new StackingResourceGroup(m_xBuilder.get()))
  74     , m_pSplineResourceGroup(
  75           new SplineResourceGroup(m_xBuilder.get(), pController->GetChartFrame()))
  76     , m_pGeometryResourceGroup(new GeometryResourceGroup(m_xBuilder.get()))
  77     , m_pSortByXValuesResourceGroup(new SortByXValuesResourceGroup(m_xBuilder.get()))
  78     , m_xChartModel(mxModel, css::uno::UNO_QUERY_THROW)
  79     , m_aChartTypeDialogControllerList(0)
  80     , m_pCurrentMainType(nullptr)
  81     , m_nChangingCalls(0)
  82     , m_aTimerTriggeredControllerLock(m_xChartModel)
  83     , m_xMainTypeList(m_xBuilder->weld_combo_box("cmb_chartType"))
  84     , m_xSubTypeList(new SvtValueSet(m_xBuilder->weld_scrolled_window("subtypewin")))
  85     , m_xSubTypeListWin(new weld::CustomWeld(*m_xBuilder, "subtype", *m_xSubTypeList))
  86 {
  87     Size aSize(m_xSubTypeList->GetDrawingArea()->get_ref_device().LogicToPixel(
  88         Size(120, 40), MapMode(MapUnit::MapAppFont)));
  89     m_xSubTypeListWin->set_size_request(aSize.Width(), aSize.Height());
  90
  91     m_xMainTypeList->connect_changed(LINK(this, ChartTypePanel, SelectMainTypeHdl));
  92     m_xSubTypeList->SetSelectHdl(LINK(this, ChartTypePanel, SelectSubTypeHdl));
  93
  94     m_xSubTypeList->SetStyle(m_xSubTypeList->GetStyle() | WB_ITEMBORDER | WB_DOUBLEBORDER
  95                              | WB_NAMEFIELD | WB_FLATVALUESET | WB_3DLOOK);
  96     m_xSubTypeList->SetColCount(4);
  97     m_xSubTypeList->SetLineCount(1);
  98
  99     bool bEnableComplexChartTypes = true;
 100     uno::Reference<beans::XPropertySet> xProps(m_xChartModel, uno::UNO_QUERY);
 101     if (xProps.is())
 102     {
 103         try
 104         {
 105             xProps->getPropertyValue("EnableComplexChartTypes") >>= bEnableComplexChartTypes;
 106         }
 107         catch (const uno::Exception&)
 108         {
 109             TOOLS_WARN_EXCEPTION("chart2", "");
 110         }
 111     }
 112
 113     m_aChartTypeDialogControllerList.push_back(std::make_unique<ColumnChartDialogController>());
 114     m_aChartTypeDialogControllerList.push_back(std::make_unique<BarChartDialogController>());
 115     m_aChartTypeDialogControllerList.push_back(std::make_unique<PieChartDialogController>());
 116     m_aChartTypeDialogControllerList.push_back(std::make_unique<AreaChartDialogController>());
 117     m_aChartTypeDialogControllerList.push_back(std::make_unique<LineChartDialogController>());
 118     if (bEnableComplexChartTypes)
 119     {
 120         m_aChartTypeDialogControllerList.push_back(std::make_unique<XYChartDialogController>());
 121         m_aChartTypeDialogControllerList.push_back(std::make_unique<BubbleChartDialogController>());
 122     }
 123     m_aChartTypeDialogControllerList.push_back(std::make_unique<NetChartDialogController>());
 124     if (bEnableComplexChartTypes)
 125     {
 126         m_aChartTypeDialogControllerList.push_back(std::make_unique<StockChartDialogController>());
 127     }
 128     m_aChartTypeDialogControllerList.push_back(
 129         std::make_unique<CombiColumnLineChartDialogController>());
 130
 131     for (auto const& elem : m_aChartTypeDialogControllerList)
 132     {
 133         m_xMainTypeList->append("", elem->getName(), elem->getImage());
 134         elem->setChangeListener(this);
 135     }
 136
 137     m_pDim3DLookResourceGroup->setChangeListener(this);
 138     m_pStackingResourceGroup->setChangeListener(this);
 139     m_pSplineResourceGroup->setChangeListener(this);
 140     m_pGeometryResourceGroup->setChangeListener(this);
 141     m_pSortByXValuesResourceGroup->setChangeListener(this);
 142
 143     Initialize();
 144 }
 145
 146 ChartTypePanel::~ChartTypePanel() { disposeOnce(); }
 147
 148 void ChartTypePanel::dispose()
 149 {
 150     css::uno::Reference<css::util::XModifyBroadcaster> xBroadcaster(mxModel,
 151                                                                     css::uno::UNO_QUERY_THROW);
 152     xBroadcaster->removeModifyListener(mxListener);
 153
 154     //delete all dialog controller
 155     m_aChartTypeDialogControllerList.clear();
 156
 157     //delete all resource helpers
 158     m_pDim3DLookResourceGroup.reset();
 159     m_pStackingResourceGroup.reset();
 160     m_pSplineResourceGroup.reset();
 161     m_pGeometryResourceGroup.reset();
 162     m_pSortByXValuesResourceGroup.reset();
 163     m_xSubTypeListWin.reset();
 164     m_xSubTypeList.reset();
 165
 166     PanelLayout::dispose();
 167 }
 168
 169 IMPL_LINK_NOARG(ChartTypePanel, SelectMainTypeHdl, weld::ComboBox&, void) { selectMainType(); }
 170
 171 IMPL_LINK_NOARG(ChartTypePanel, SelectSubTypeHdl, SvtValueSet*, void)
 172 {
 173     if (m_pCurrentMainType)
 174     {
 175         ChartTypeParameter aParameter(getCurrentParameter());
 176         m_pCurrentMainType->adjustParameterToSubType(aParameter);
 177         fillAllControls(aParameter, false);
 178         commitToModel(aParameter);
 179     }
 180 }
 181
 182 void ChartTypePanel::Initialize()
 183 {
 184     if (!m_xChartModel.is())
 185         return;
 186     uno::Reference<lang::XMultiServiceFactory> xTemplateManager(
 187         m_xChartModel->getChartTypeManager(), uno::UNO_QUERY);
 188     uno::Reference<css::chart2::XDiagram> xDiagram(ChartModelHelper::findDiagram(m_xChartModel));
 189     DiagramHelper::tTemplateWithServiceName aTemplate
 190         = DiagramHelper::getTemplateForDiagram(xDiagram, xTemplateManager);
 191     OUString aServiceName(aTemplate.second);
 192
 193     bool bFound = false;
 194
 195     sal_uInt16 nM = 0;
 196     for (auto const& elem : m_aChartTypeDialogControllerList)
 197     {
 198         if (elem->isSubType(aServiceName))
 199         {
 200             bFound = true;
 201
 202             m_xMainTypeList->set_active(nM);
 203             showAllControls(*elem);
 204             uno::Reference<beans::XPropertySet> xTemplateProps(aTemplate.first, uno::UNO_QUERY);
 205             ChartTypeParameter aParameter
 206                 = elem->getChartTypeParameterForService(aServiceName, xTemplateProps);
 207             m_pCurrentMainType = getSelectedMainType();
 208
 209             //set ThreeDLookScheme
 210             aParameter.eThreeDLookScheme = ThreeDHelper::detectScheme(xDiagram);
 211             if (!aParameter.b3DLook && aParameter.eThreeDLookScheme != ThreeDLookScheme_Realistic)
 212                 aParameter.eThreeDLookScheme = ThreeDLookScheme_Realistic;
 213
 214             try
 215             {
 216                 uno::Reference<beans::XPropertySet> xPropSet(xDiagram, uno::UNO_QUERY_THROW);
 217                 xPropSet->getPropertyValue(CHART_UNONAME_SORT_BY_XVALUES)
 218                     >>= aParameter.bSortByXValues;
 219             }
 220             catch (const uno::Exception&)
 221             {
 222                 DBG_UNHANDLED_EXCEPTION("chart2");
 223             }
 224
 225             fillAllControls(aParameter);
 226             if (m_pCurrentMainType)
 227                 m_pCurrentMainType->fillExtraControls(m_xChartModel, xTemplateProps);
 228             break;
 229         }
 230         ++nM;
 231     }
 232
 233     if (!bFound)
 234     {
 235         m_xSubTypeList->Hide();
 236         m_pDim3DLookResourceGroup->showControls(false);
 237         m_pStackingResourceGroup->showControls(false, false);
 238         m_pSplineResourceGroup->showControls(false);
 239         m_pGeometryResourceGroup->showControls(false);
 240         m_pSortByXValuesResourceGroup->showControls(false);
 241     }
 242 }
 243
 244 void ChartTypePanel::updateData()
 245 {
 246     // Chart Type related
 247     if (!m_xChartModel.is())
 248         return;
 249     uno::Reference<lang::XMultiServiceFactory> xTemplateManager(
 250         m_xChartModel->getChartTypeManager(), uno::UNO_QUERY);
 251     uno::Reference<frame::XModel> xModel(m_xChartModel);
 252     uno::Reference<css::chart2::XDiagram> xDiagram(ChartModelHelper::findDiagram(xModel));
 253     DiagramHelper::tTemplateWithServiceName aTemplate
 254         = DiagramHelper::getTemplateForDiagram(xDiagram, xTemplateManager);
 255     OUString aServiceName(aTemplate.second);
 256
 257     sal_uInt16 nM = 0;
 258     for (auto const& elem : m_aChartTypeDialogControllerList)
 259     {
 260         if (elem->isSubType(aServiceName))
 261         {
 262             //m_pMainTypeList->SelectEntryPos(nM);
 263             //m_pMainTypeList->select_entry_region(nM, nM);
 264             break;
 265         }
 266         ++nM;
 267     }
 268 }
 269
 270 VclPtr<vcl::Window> ChartTypePanel::Create(vcl::Window* pParent,
 271                                            const css::uno::Reference<css::frame::XFrame>& rxFrame,
 272                                            ChartController* pController)
 273 {
 274     if (pParent == nullptr)
 275         throw lang::IllegalArgumentException("no parent Window given to ChartTypePanel::Create",
 276                                              nullptr, 0);
 277     if (!rxFrame.is())
 278         throw lang::IllegalArgumentException("no XFrame given to ChartTypePanel::Create", nullptr,
 279                                              1);
 280     return VclPtr<ChartTypePanel>::Create(pParent, rxFrame, pController);
 281 }
 282
 283 void ChartTypePanel::DataChanged(const DataChangedEvent&) { updateData(); }
 284
 285 void ChartTypePanel::HandleContextChange(const vcl::EnumContext& rContext)
 286 {
 287     if (maContext == rContext)
 288     {
 289         // Nothing to do.
 290         return;
 291     }
 292
 293     maContext = rContext;
 294     updateData();
 295 }
 296
 297 void ChartTypePanel::modelInvalid() { mbModelValid = false; }
 298
 299 void ChartTypePanel::updateModel(css::uno::Reference<css::frame::XModel> xModel)
 300 {
 301     if (mbModelValid)
 302     {
 303         css::uno::Reference<css::util::XModifyBroadcaster> xBroadcaster(mxModel,
 304                                                                         css::uno::UNO_QUERY_THROW);
 305         xBroadcaster->removeModifyListener(mxListener);
 306     }
 307
 308     mxModel = xModel;
 309     mbModelValid = true;
 310
 311     css::uno::Reference<css::util::XModifyBroadcaster> xBroadcasterNew(mxModel,
 312                                                                        css::uno::UNO_QUERY_THROW);
 313     xBroadcasterNew->addModifyListener(mxListener);
 314 }
 315
 316 uno::Reference<css::chart2::XChartTypeTemplate> ChartTypePanel::getCurrentTemplate() const
 317 {
 318     if (m_pCurrentMainType && m_xChartModel.is())
 319     {
 320         ChartTypeParameter aParameter(getCurrentParameter());
 321         m_pCurrentMainType->adjustParameterToSubType(aParameter);
 322         uno::Reference<lang::XMultiServiceFactory> xTemplateManager(
 323             m_xChartModel->getChartTypeManager(), uno::UNO_QUERY);
 324         return m_pCurrentMainType->getCurrentTemplate(aParameter, xTemplateManager);
 325     }
 326     return nullptr;
 327 }
 328
 329 ChartTypeDialogController* ChartTypePanel::getSelectedMainType()
 330 {
 331     ChartTypeDialogController* pTypeController = nullptr;
 332     auto nM = static_cast<std::vector<ChartTypeDialogController*>::size_type>(
 333         m_xMainTypeList->get_active());
 334     if (nM < m_aChartTypeDialogControllerList.size())
 335         pTypeController = m_aChartTypeDialogControllerList[nM].get();
 336     return pTypeController;
 337 }
 338
 339 void ChartTypePanel::showAllControls(ChartTypeDialogController& rTypeController)
 340 {
 341     m_xMainTypeList->show();
 342     m_xSubTypeList->Show();
 343
 344     bool bShow = rTypeController.shouldShow_3DLookControl();
 345     m_pDim3DLookResourceGroup->showControls(bShow);
 346     bShow = rTypeController.shouldShow_StackingControl();
 347     m_pStackingResourceGroup->showControls(bShow, false);
 348     bShow = rTypeController.shouldShow_SplineControl();
 349     m_pSplineResourceGroup->showControls(bShow);
 350     bShow = rTypeController.shouldShow_GeometryControl();
 351     m_pGeometryResourceGroup->showControls(bShow);
 352     bShow = rTypeController.shouldShow_SortByXValuesResourceGroup();
 353     m_pSortByXValuesResourceGroup->showControls(bShow);
 354     rTypeController.showExtraControls(m_xBuilder.get());
 355 }
 356
 357 void ChartTypePanel::fillAllControls(const ChartTypeParameter& rParameter,
 358                                      bool bAlsoResetSubTypeList)
 359 {
 360     m_nChangingCalls++;
 361     if (m_pCurrentMainType && bAlsoResetSubTypeList)
 362     {
 363         m_pCurrentMainType->fillSubTypeList(*m_xSubTypeList, rParameter);
 364     }
 365     m_xSubTypeList->SelectItem(static_cast<sal_uInt16>(rParameter.nSubTypeIndex));
 366     m_pDim3DLookResourceGroup->fillControls(rParameter);
 367     m_pStackingResourceGroup->fillControls(rParameter);
 368     m_pSplineResourceGroup->fillControls(rParameter);
 369     m_pGeometryResourceGroup->fillControls(rParameter);
 370     m_pSortByXValuesResourceGroup->fillControls(rParameter);
 371     m_nChangingCalls--;
 372 }
 373
 374 ChartTypeParameter ChartTypePanel::getCurrentParameter() const
 375 {
 376     ChartTypeParameter aParameter;
 377     aParameter.nSubTypeIndex = static_cast<sal_Int32>(m_xSubTypeList->GetSelectedItemId());
 378     m_pDim3DLookResourceGroup->fillParameter(aParameter);
 379     m_pStackingResourceGroup->fillParameter(aParameter);
 380     m_pSplineResourceGroup->fillParameter(aParameter);
 381     m_pGeometryResourceGroup->fillParameter(aParameter);
 382     m_pSortByXValuesResourceGroup->fillParameter(aParameter);
 383     return aParameter;
 384 }
 385
 386 void ChartTypePanel::stateChanged()
 387 {
 388     if (m_nChangingCalls)
 389         return;
 390     m_nChangingCalls++;
 391
 392     ChartTypeParameter aParameter(getCurrentParameter());
 393     if (m_pCurrentMainType)
 394     {
 395         m_pCurrentMainType->adjustParameterToSubType(aParameter);
 396         m_pCurrentMainType->adjustSubTypeAndEnableControls(aParameter);
 397     }
 398     commitToModel(aParameter);
 399
 400     //detect the new ThreeDLookScheme
 401     uno::Reference<css::chart2::XDiagram> xDiagram = ChartModelHelper::findDiagram(m_xChartModel);
 402     aParameter.eThreeDLookScheme = ThreeDHelper::detectScheme(xDiagram);
 403     try
 404     {
 405         uno::Reference<beans::XPropertySet> xPropSet(xDiagram, uno::UNO_QUERY_THROW);
 406         xPropSet->getPropertyValue(CHART_UNONAME_SORT_BY_XVALUES) >>= aParameter.bSortByXValues;
 407     }
 408     catch (const uno::Exception&)
 409     {
 410         DBG_UNHANDLED_EXCEPTION("chart2");
 411     }
 412     //the controls have to be enabled/disabled accordingly
 413     fillAllControls(aParameter);
 414
 415     m_nChangingCalls--;
 416 }
 417
 418 void ChartTypePanel::commitToModel(const ChartTypeParameter& rParameter)
 419 {
 420     if (!m_pCurrentMainType)
 421         return;
 422
 423     m_aTimerTriggeredControllerLock.startTimer();
 424     m_pCurrentMainType->commitToModel(rParameter, m_xChartModel);
 425 }
 426
 427 void ChartTypePanel::selectMainType()
 428 {
 429     ChartTypeParameter aParameter(getCurrentParameter());
 430
 431     if (m_pCurrentMainType)
 432     {
 433         m_pCurrentMainType->adjustParameterToSubType(aParameter);
 434         m_pCurrentMainType->hideExtraControls();
 435     }
 436
 437     m_pCurrentMainType = getSelectedMainType();
 438     if (m_pCurrentMainType)
 439     {
 440         showAllControls(*m_pCurrentMainType);
 441
 442         m_pCurrentMainType->adjustParameterToMainType(aParameter);
 443         commitToModel(aParameter);
 444         //detect the new ThreeDLookScheme
 445         aParameter.eThreeDLookScheme
 446             = ThreeDHelper::detectScheme(ChartModelHelper::findDiagram(m_xChartModel));
 447         if (!aParameter.b3DLook && aParameter.eThreeDLookScheme != ThreeDLookScheme_Realistic)
 448             aParameter.eThreeDLookScheme = ThreeDLookScheme_Realistic;
 449
 450         uno::Reference<css::chart2::XDiagram> xDiagram
 451             = ChartModelHelper::findDiagram(m_xChartModel);
 452         try
 453         {
 454             uno::Reference<beans::XPropertySet> xPropSet(xDiagram, uno::UNO_QUERY_THROW);
 455             xPropSet->getPropertyValue(CHART_UNONAME_SORT_BY_XVALUES) >>= aParameter.bSortByXValues;
 456         }
 457         catch (const uno::Exception&)
 458         {
 459             DBG_UNHANDLED_EXCEPTION("chart2");
 460         }
 461
 462         fillAllControls(aParameter);
 463         uno::Reference<beans::XPropertySet> xTemplateProps(getCurrentTemplate(), uno::UNO_QUERY);
 464         m_pCurrentMainType->fillExtraControls(m_xChartModel, xTemplateProps);
 465     }
 466 }
 467 }
 468 } // end of namespace ::chart::sidebar
 469
 470 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */