svx/source/tbxctrls/extrusioncontrols.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 <sal/config.h>
  21
  22 #include <comphelper/propertyvalue.hxx>
  23 #include <svtools/toolbarmenu.hxx>
  24 #include <vcl/toolbox.hxx>
  25
  26 #include <svx/strings.hrc>
  27 #include <svx/svdtrans.hxx>
  28 #include <svx/dialmgr.hxx>
  29
  30 #include <helpids.h>
  31 #include "extrusioncontrols.hxx"
  32 #include <extrusiondepthdialog.hxx>
  33
  34 #include <bitmaps.hlst>
  35
  36 using namespace ::com::sun::star::uno;
  37 using namespace ::com::sun::star::beans;
  38 using namespace ::com::sun::star::util;
  39 using namespace ::com::sun::star::graphic;
  40
  41 namespace svx
  42 {
  43
  44 const sal_Int32 gSkewList[] = { 135, 90, 45, 180, 0, -360, -135, -90, -45 };
  45 constexpr OUString g_sExtrusionDirection = u".uno:ExtrusionDirection"_ustr;
  46 constexpr OUString g_sExtrusionProjection = u".uno:ExtrusionProjection"_ustr;
  47 constexpr OUString EMPTY = u""_ustr;
  48
  49 constexpr OUString aLightOffBmps[] =
  50 {
  51     RID_SVXBMP_LIGHT_OFF_FROM_TOP_LEFT,
  52     RID_SVXBMP_LIGHT_OFF_FROM_TOP,
  53     RID_SVXBMP_LIGHT_OFF_FROM_TOP_RIGHT,
  54     RID_SVXBMP_LIGHT_OFF_FROM_LEFT,
  55     EMPTY,
  56     RID_SVXBMP_LIGHT_OFF_FROM_RIGHT,
  57     RID_SVXBMP_LIGHT_OFF_FROM_BOTTOM_LEFT,
  58     RID_SVXBMP_LIGHT_OFF_FROM_BOTTOM,
  59     RID_SVXBMP_LIGHT_OFF_FROM_BOTTOM_RIGHT
  60 };
  61
  62 constexpr OUString aLightOnBmps[] =
  63 {
  64     RID_SVXBMP_LIGHT_ON_FROM_TOP_LEFT,
  65     RID_SVXBMP_LIGHT_ON_FROM_TOP,
  66     RID_SVXBMP_LIGHT_ON_FROM_TOP_RIGHT,
  67     RID_SVXBMP_LIGHT_ON_FROM_LEFT,
  68     EMPTY,
  69     RID_SVXBMP_LIGHT_ON_FROM_RIGHT,
  70     RID_SVXBMP_LIGHT_ON_FROM_BOTTOM_LEFT,
  71     RID_SVXBMP_LIGHT_ON_FROM_BOTTOM,
  72     RID_SVXBMP_LIGHT_ON_FROM_BOTTOM_RIGHT
  73 };
  74
  75 constexpr OUString aLightPreviewBmps[] =
  76 {
  77     RID_SVXBMP_LIGHT_PREVIEW_FROM_TOP_LEFT,
  78     RID_SVXBMP_LIGHT_PREVIEW_FROM_TOP,
  79     RID_SVXBMP_LIGHT_PREVIEW_FROM_TOP_RIGHT,
  80     RID_SVXBMP_LIGHT_PREVIEW_FROM_LEFT,
  81     RID_SVXBMP_LIGHT_PREVIEW_FROM_FRONT,
  82     RID_SVXBMP_LIGHT_PREVIEW_FROM_RIGHT,
  83     RID_SVXBMP_LIGHT_PREVIEW_FROM_BOTTOM_LEFT,
  84     RID_SVXBMP_LIGHT_PREVIEW_FROM_BOTTOM,
  85     RID_SVXBMP_LIGHT_PREVIEW_FROM_BOTTOM_RIGHT
  86 };
  87
  88 constexpr OUString aDirectionBmps[] =
  89 {
  90     RID_SVXBMP_DIRECTION_DIRECTION_NW,
  91     RID_SVXBMP_DIRECTION_DIRECTION_N,
  92     RID_SVXBMP_DIRECTION_DIRECTION_NE,
  93     RID_SVXBMP_DIRECTION_DIRECTION_W,
  94     RID_SVXBMP_DIRECTION_DIRECTION_NONE,
  95     RID_SVXBMP_DIRECTION_DIRECTION_E,
  96     RID_SVXBMP_DIRECTION_DIRECTION_SW,
  97     RID_SVXBMP_DIRECTION_DIRECTION_S,
  98     RID_SVXBMP_DIRECTION_DIRECTION_SE
  99 };
 100
 101 static TranslateId aDirectionStrs[] =
 102 {
 103     RID_SVXSTR_DIRECTION_NW,
 104     RID_SVXSTR_DIRECTION_N,
 105     RID_SVXSTR_DIRECTION_NE,
 106     RID_SVXSTR_DIRECTION_W,
 107     RID_SVXSTR_DIRECTION_NONE,
 108     RID_SVXSTR_DIRECTION_E,
 109     RID_SVXSTR_DIRECTION_SW,
 110     RID_SVXSTR_DIRECTION_S,
 111     RID_SVXSTR_DIRECTION_SE
 112 };
 113
 114 ExtrusionDirectionWindow::ExtrusionDirectionWindow(
 115     svt::PopupWindowController* pControl,
 116     weld::Widget* pParent)
 117     : WeldToolbarPopup(pControl->getFrameInterface(), pParent, u"svx/ui/directionwindow.ui"_ustr, u"DirectionWindow"_ustr)
 118     , mxControl(pControl)
 119     , mxDirectionSet(new ValueSet(nullptr))
 120     , mxDirectionSetWin(new weld::CustomWeld(*m_xBuilder, u"valueset"_ustr, *mxDirectionSet))
 121     , mxPerspective(m_xBuilder->weld_radio_button(u"perspective"_ustr))
 122     , mxParallel(m_xBuilder->weld_radio_button(u"parallel"_ustr))
 123 {
 124     mxDirectionSet->SetStyle(WB_TABSTOP | WB_MENUSTYLEVALUESET | WB_FLATVALUESET | WB_NOBORDER | WB_NO_DIRECTSELECT);
 125
 126     for (sal_uInt16 i = DIRECTION_NW; i <= DIRECTION_SE; ++i)
 127     {
 128         maImgDirection[i] = Image(StockImage::Yes, aDirectionBmps[i]);
 129     }
 130
 131     mxDirectionSet->SetSelectHdl( LINK( this, ExtrusionDirectionWindow, SelectValueSetHdl ) );
 132     mxDirectionSet->SetColCount( 3 );
 133     mxDirectionSet->EnableFullItemMode( false );
 134
 135     for (sal_uInt16 i = DIRECTION_NW; i <= DIRECTION_SE; ++i)
 136     {
 137         mxDirectionSet->InsertItem(i + 1, maImgDirection[i], SvxResId(aDirectionStrs[i]));
 138     }
 139
 140     Size aSize(72, 72);
 141     mxDirectionSet->GetDrawingArea()->set_size_request(aSize.Width(), aSize.Height());
 142     mxDirectionSet->SetOutputSizePixel(aSize);
 143
 144     mxPerspective->connect_toggled(LINK(this, ExtrusionDirectionWindow, SelectToolbarMenuHdl));
 145
 146     AddStatusListener( g_sExtrusionDirection );
 147     AddStatusListener( g_sExtrusionProjection );
 148 }
 149
 150 void ExtrusionDirectionWindow::GrabFocus()
 151 {
 152     mxDirectionSet->GrabFocus();
 153 }
 154
 155 ExtrusionDirectionWindow::~ExtrusionDirectionWindow()
 156 {
 157 }
 158
 159 void ExtrusionDirectionWindow::implSetDirection( sal_Int32 nSkew, bool bEnabled )
 160 {
 161     sal_uInt16 nItemId;
 162     for( nItemId = DIRECTION_NW; nItemId <= DIRECTION_SE; nItemId++ )
 163     {
 164         if( gSkewList[nItemId] == nSkew )
 165             break;
 166     }
 167
 168     if( nItemId <= DIRECTION_SE )
 169     {
 170         mxDirectionSet->SelectItem( nItemId+1 );
 171     }
 172     else
 173     {
 174         mxDirectionSet->SetNoSelection();
 175     }
 176
 177     if (bEnabled)
 178         mxDirectionSet->Enable();
 179     else
 180         mxDirectionSet->Disable();
 181 }
 182
 183 void ExtrusionDirectionWindow::implSetProjection( sal_Int32 nProjection, bool bEnabled )
 184 {
 185     mxPerspective->set_active(nProjection == 0 && bEnabled);
 186     mxParallel->set_active(nProjection == 1 && bEnabled);
 187     mxPerspective->set_sensitive(bEnabled);
 188     mxParallel->set_sensitive(bEnabled);
 189 }
 190
 191 void ExtrusionDirectionWindow::statusChanged(
 192     const css::frame::FeatureStateEvent& Event
 193 )
 194 {
 195     if( Event.FeatureURL.Main == g_sExtrusionDirection )
 196     {
 197         if( !Event.IsEnabled )
 198         {
 199             implSetDirection( -1, false );
 200         }
 201         else
 202         {
 203             sal_Int32 nValue = 0;
 204             if( Event.State >>= nValue )
 205                 implSetDirection( nValue, true );
 206         }
 207     }
 208     else if( Event.FeatureURL.Main == g_sExtrusionProjection )
 209     {
 210         if( !Event.IsEnabled )
 211         {
 212             implSetProjection( -1, false );
 213         }
 214         else
 215         {
 216             sal_Int32 nValue = 0;
 217             if( Event.State >>= nValue )
 218                 implSetProjection( nValue, true );
 219         }
 220     }
 221 }
 222
 223 IMPL_LINK_NOARG(ExtrusionDirectionWindow, SelectValueSetHdl, ValueSet*, void)
 224 {
 225     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 226         g_sExtrusionDirection.copy(5),
 227         gSkewList[mxDirectionSet->GetSelectedItemId()-1]) };
 228
 229     mxControl->dispatchCommand( g_sExtrusionDirection, aArgs );
 230
 231     mxControl->EndPopupMode();
 232 }
 233
 234 IMPL_LINK_NOARG(ExtrusionDirectionWindow, SelectToolbarMenuHdl, weld::Toggleable&, void)
 235 {
 236     int nProjection = mxPerspective->get_active() ? 0 : 1;
 237
 238     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 239         g_sExtrusionProjection.copy(5), static_cast<sal_Int32>(nProjection)) };
 240
 241     mxControl->dispatchCommand( g_sExtrusionProjection, aArgs );
 242     implSetProjection( nProjection, true );
 243
 244     mxControl->EndPopupMode();
 245 }
 246
 247 ExtrusionDirectionControl::ExtrusionDirectionControl(
 248     const Reference< XComponentContext >& rxContext
 249 )   : svt::PopupWindowController(
 250         rxContext,
 251         Reference< css::frame::XFrame >(),
 252         u".uno:ExtrusionDirectionFloater"_ustr
 253     )
 254 {
 255 }
 256
 257 std::unique_ptr<WeldToolbarPopup> ExtrusionDirectionControl::weldPopupWindow()
 258 {
 259     return std::make_unique<ExtrusionDirectionWindow>(this, m_pToolbar);
 260 }
 261
 262 VclPtr<vcl::Window> ExtrusionDirectionControl::createVclPopupWindow( vcl::Window* pParent )
 263 {
 264     mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
 265         std::make_unique<ExtrusionDirectionWindow>(this, pParent->GetFrameWeld()));
 266
 267     mxInterimPopover->Show();
 268
 269     return mxInterimPopover;
 270 }
 271
 272 // XInitialization
 273 void SAL_CALL ExtrusionDirectionControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 274 {
 275     svt::PopupWindowController::initialize( aArguments );
 276
 277     ToolBox* pToolBox = nullptr;
 278     ToolBoxItemId nId;
 279     if ( getToolboxId( nId, &pToolBox ) )
 280         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 281 }
 282
 283 // XServiceInfo
 284
 285
 286 OUString ExtrusionDirectionControl::getImplementationName()
 287 {
 288     return u"com.sun.star.comp.svx.ExtrusionDirectionController"_ustr;
 289 }
 290
 291
 292 Sequence< OUString > ExtrusionDirectionControl::getSupportedServiceNames()
 293 {
 294     return { u"com.sun.star.frame.ToolbarController"_ustr };
 295 }
 296
 297
 298 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 299 com_sun_star_comp_svx_ExtrusionDirectionControl_get_implementation(
 300     css::uno::XComponentContext* xContext,
 301     css::uno::Sequence<css::uno::Any> const &)
 302 {
 303     return cppu::acquire(new ExtrusionDirectionControl(xContext));
 304 }
 305
 306
 307 ExtrusionDepthDialog::ExtrusionDepthDialog(weld::Window* pParent, double fDepth, FieldUnit eDefaultUnit)
 308     : GenericDialogController(pParent, u"svx/ui/extrustiondepthdialog.ui"_ustr, u"ExtrustionDepthDialog"_ustr)
 309     , m_xMtrDepth(m_xBuilder->weld_metric_spin_button(u"depth"_ustr, eDefaultUnit))
 310 {
 311     m_xMtrDepth->set_value(static_cast<int>(fDepth) * 100, FieldUnit::MM_100TH);
 312 }
 313
 314 ExtrusionDepthDialog::~ExtrusionDepthDialog()
 315 {
 316 }
 317
 318 double ExtrusionDepthDialog::getDepth() const
 319 {
 320     return static_cast<double>(m_xMtrDepth->get_value(FieldUnit::MM_100TH)) / 100.0;
 321 }
 322
 323 double const aDepthListInch[] = { 0, 1270,2540,5080,10160 };
 324 double const aDepthListMM[] = { 0, 1000, 2500, 5000, 10000 };
 325
 326 constexpr OUString gsExtrusionDepth( u".uno:ExtrusionDepth"_ustr );
 327 constexpr OUString gsMetricUnit(     u".uno:MetricUnit"_ustr     );
 328
 329 ExtrusionDepthWindow::ExtrusionDepthWindow(svt::PopupWindowController* pControl, weld::Widget* pParent)
 330     : WeldToolbarPopup(pControl->getFrameInterface(), pParent, u"svx/ui/depthwindow.ui"_ustr, u"DepthWindow"_ustr)
 331     , mxControl(pControl)
 332     , mxDepth0(m_xBuilder->weld_radio_button(u"depth0"_ustr))
 333     , mxDepth1(m_xBuilder->weld_radio_button(u"depth1"_ustr))
 334     , mxDepth2(m_xBuilder->weld_radio_button(u"depth2"_ustr))
 335     , mxDepth3(m_xBuilder->weld_radio_button(u"depth3"_ustr))
 336     , mxDepth4(m_xBuilder->weld_radio_button(u"depth4"_ustr))
 337     , mxInfinity(m_xBuilder->weld_radio_button(u"infinity"_ustr))
 338     , mxCustom(m_xBuilder->weld_radio_button(u"custom"_ustr))
 339     , meUnit(FieldUnit::NONE)
 340     , mfDepth( -1.0 )
 341     , mbSettingValue(false)
 342     , mbCommandDispatched(false)
 343 {
 344     mxDepth0->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 345     mxDepth1->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 346     mxDepth2->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 347     mxDepth3->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 348     mxDepth4->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 349     mxInfinity->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 350     mxCustom->connect_toggled(LINK(this, ExtrusionDepthWindow, SelectHdl));
 351     mxCustom->connect_mouse_release(LINK(this, ExtrusionDepthWindow, MouseReleaseHdl));
 352
 353     AddStatusListener( gsExtrusionDepth );
 354     AddStatusListener( gsMetricUnit );
 355 }
 356
 357 void ExtrusionDepthWindow::GrabFocus()
 358 {
 359     mxDepth0->grab_focus();
 360 }
 361
 362 void ExtrusionDepthWindow::implSetDepth( double fDepth )
 363 {
 364     mfDepth = fDepth;
 365
 366     bool bSettingValue = mbSettingValue;
 367     mbSettingValue = true;
 368
 369     mxCustom->set_active(true);
 370     bool bIsMetric = IsMetric(meUnit);
 371     mxDepth0->set_active(fDepth == (bIsMetric ? aDepthListMM[0] : aDepthListInch[0]));
 372     mxDepth1->set_active(fDepth == (bIsMetric ? aDepthListMM[1] : aDepthListInch[1]));
 373     mxDepth2->set_active(fDepth == (bIsMetric ? aDepthListMM[2] : aDepthListInch[2]));
 374     mxDepth3->set_active(fDepth == (bIsMetric ? aDepthListMM[3] : aDepthListInch[3]));
 375     mxDepth4->set_active(fDepth == (bIsMetric ? aDepthListMM[4] : aDepthListInch[4]));
 376     mxInfinity->set_active(fDepth >= 338666);
 377
 378     mbSettingValue = bSettingValue;
 379 }
 380
 381 void ExtrusionDepthWindow::implFillStrings( FieldUnit eUnit )
 382 {
 383     meUnit = eUnit;
 384
 385     const TranslateId aDepths[] =
 386     {
 387         RID_SVXSTR_DEPTH_0,
 388         RID_SVXSTR_DEPTH_1,
 389         RID_SVXSTR_DEPTH_2,
 390         RID_SVXSTR_DEPTH_3,
 391         RID_SVXSTR_DEPTH_4
 392     };
 393
 394     const TranslateId aDepthsInch[] =
 395     {
 396         RID_SVXSTR_DEPTH_0_INCH,
 397         RID_SVXSTR_DEPTH_1_INCH,
 398         RID_SVXSTR_DEPTH_2_INCH,
 399         RID_SVXSTR_DEPTH_3_INCH,
 400         RID_SVXSTR_DEPTH_4_INCH
 401     };
 402
 403     static_assert(SAL_N_ELEMENTS(aDepths) == SAL_N_ELEMENTS(aDepthsInch));
 404
 405     const TranslateId* pResource = IsMetric(eUnit) ? aDepths : aDepthsInch;
 406
 407     mxDepth0->set_label(SvxResId(pResource[0]));
 408     mxDepth1->set_label(SvxResId(pResource[1]));
 409     mxDepth2->set_label(SvxResId(pResource[2]));
 410     mxDepth3->set_label(SvxResId(pResource[3]));
 411     mxDepth4->set_label(SvxResId(pResource[4]));
 412 }
 413
 414 void ExtrusionDepthWindow::statusChanged(
 415     const css::frame::FeatureStateEvent& Event
 416 )
 417 {
 418     if( Event.FeatureURL.Main == gsExtrusionDepth )
 419     {
 420         if( !Event.IsEnabled )
 421         {
 422             implSetDepth( 0 );
 423         }
 424         else
 425         {
 426             double fValue = 0.0;
 427             if( Event.State >>= fValue )
 428                 implSetDepth( fValue );
 429         }
 430     }
 431     else if( Event.FeatureURL.Main == gsMetricUnit )
 432     {
 433         if( Event.IsEnabled )
 434         {
 435             sal_Int32 nValue = 0;
 436             if( Event.State >>= nValue )
 437             {
 438                 implFillStrings( static_cast<FieldUnit>(nValue) );
 439                 if( mfDepth >= 0.0 )
 440                     implSetDepth( mfDepth );
 441             }
 442         }
 443     }
 444 }
 445
 446 void ExtrusionDepthWindow::DispatchDepthDialog()
 447 {
 448     Sequence< PropertyValue > aArgs{
 449         comphelper::makePropertyValue(u"Depth"_ustr, mfDepth),
 450         comphelper::makePropertyValue(u"Metric"_ustr, static_cast<sal_Int32>( meUnit ))
 451     };
 452
 453     rtl::Reference<svt::PopupWindowController> xControl(mxControl);
 454     xControl->EndPopupMode();
 455     xControl->dispatchCommand(u".uno:ExtrusionDepthDialog"_ustr, aArgs);
 456     mbCommandDispatched = true;
 457 }
 458
 459 IMPL_LINK(ExtrusionDepthWindow, SelectHdl, weld::Toggleable&, rButton, void)
 460 {
 461     if (mbSettingValue || !rButton.get_active())
 462         return;
 463
 464     // see MouseReleaseHdl for mbCommandDispatched check, there's no guarantee
 465     // this toggle will happen before that mouse release though it does in
 466     // practice for vcl and gtk
 467     if (mbCommandDispatched)
 468         return;
 469
 470     if (mxCustom->get_active())
 471         DispatchDepthDialog();
 472     else
 473     {
 474         double fDepth;
 475
 476         if (mxInfinity->get_active())
 477         {
 478             fDepth = 338666.6;
 479         }
 480         else
 481         {
 482             int nSelected;
 483             if (mxDepth0->get_active())
 484                 nSelected = 0;
 485             else if (mxDepth1->get_active())
 486                 nSelected = 1;
 487             else if (mxDepth2->get_active())
 488                 nSelected = 2;
 489             else if (mxDepth3->get_active())
 490                 nSelected = 3;
 491             else
 492                 nSelected = 4;
 493
 494             fDepth = IsMetric( meUnit ) ? aDepthListMM[nSelected] : aDepthListInch[nSelected];
 495         }
 496
 497         Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 498             gsExtrusionDepth.copy(5), fDepth) };
 499
 500         mxControl->dispatchCommand( gsExtrusionDepth,  aArgs );
 501         mbCommandDispatched = true;
 502         implSetDepth( fDepth );
 503
 504         mxControl->EndPopupMode();
 505     }
 506 }
 507
 508 IMPL_LINK_NOARG(ExtrusionDepthWindow, MouseReleaseHdl, const MouseEvent&, bool)
 509 {
 510     /*
 511      tdf#145296 if the "custom" radiobutton was presented preselected as
 512      toggled on and the user clicked on it then there's no toggled signal sent
 513      because the item was already toggled on and didn't change state.
 514
 515      So if that happens launch the custom spacing dialog explicitly here on
 516      mouse release.
 517     */
 518     if (mxCustom->get_active() && !mbCommandDispatched)
 519     {
 520         DispatchDepthDialog();
 521         return true;
 522     }
 523     return false;
 524 }
 525
 526 // ExtrusionDirectionControl
 527 ExtrusionDepthController::ExtrusionDepthController(
 528     const Reference< XComponentContext >& rxContext
 529 )   : svt::PopupWindowController(
 530         rxContext,
 531         Reference< css::frame::XFrame >(),
 532         u".uno:ExtrusionDepthFloater"_ustr
 533     )
 534 {
 535 }
 536
 537 std::unique_ptr<WeldToolbarPopup> ExtrusionDepthController::weldPopupWindow()
 538 {
 539     return std::make_unique<ExtrusionDepthWindow>(this, m_pToolbar);
 540 }
 541
 542 VclPtr<vcl::Window> ExtrusionDepthController::createVclPopupWindow( vcl::Window* pParent )
 543 {
 544     mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
 545         std::make_unique<ExtrusionDepthWindow>(this, pParent->GetFrameWeld()));
 546
 547     mxInterimPopover->Show();
 548
 549     return mxInterimPopover;
 550 }
 551
 552 // XInitialization
 553 void SAL_CALL ExtrusionDepthController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 554 {
 555     svt::PopupWindowController::initialize( aArguments );
 556
 557     ToolBox* pToolBox = nullptr;
 558     ToolBoxItemId nId;
 559     if ( getToolboxId( nId, &pToolBox ) )
 560         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 561 }
 562
 563 // XServiceInfo
 564
 565
 566 OUString ExtrusionDepthController::getImplementationName()
 567 {
 568     return u"com.sun.star.comp.svx.ExtrusionDepthController"_ustr;
 569 }
 570
 571
 572 Sequence< OUString > ExtrusionDepthController::getSupportedServiceNames()
 573 {
 574     return { u"com.sun.star.frame.ToolbarController"_ustr };
 575 }
 576
 577
 578 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 579 com_sun_star_comp_svx_ExtrusionDepthController_get_implementation(
 580     css::uno::XComponentContext* xContext,
 581     css::uno::Sequence<css::uno::Any> const &)
 582 {
 583     return cppu::acquire(new ExtrusionDepthController(xContext));
 584 }
 585
 586
 587 constexpr OUString g_sExtrusionLightingDirection = u".uno:ExtrusionLightingDirection"_ustr;
 588 constexpr OUString g_sExtrusionLightingIntensity = u".uno:ExtrusionLightingIntensity"_ustr;
 589
 590 ExtrusionLightingWindow::ExtrusionLightingWindow(svt::PopupWindowController* pControl,
 591                                                  weld::Widget* pParent)
 592     : WeldToolbarPopup(pControl->getFrameInterface(), pParent, u"svx/ui/lightingwindow.ui"_ustr, u"LightingWindow"_ustr)
 593     , mxControl(pControl)
 594     , mxLightingSet(new ValueSet(nullptr))
 595     , mxLightingSetWin(new weld::CustomWeld(*m_xBuilder, u"valueset"_ustr, *mxLightingSet))
 596     , mxBright(m_xBuilder->weld_radio_button(u"bright"_ustr))
 597     , mxNormal(m_xBuilder->weld_radio_button(u"normal"_ustr))
 598     , mxDim(m_xBuilder->weld_radio_button(u"dim"_ustr))
 599 {
 600     mxLightingSet->SetStyle(WB_TABSTOP | WB_MENUSTYLEVALUESET | WB_FLATVALUESET | WB_NOBORDER | WB_NO_DIRECTSELECT);
 601
 602     for (sal_uInt16 i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; ++i)
 603     {
 604         if( i != FROM_FRONT )
 605         {
 606             maImgLightingOff[i] = Image(StockImage::Yes, aLightOffBmps[i]);
 607             maImgLightingOn[i] = Image(StockImage::Yes, aLightOnBmps[i]);
 608         }
 609         maImgLightingPreview[i] = Image(StockImage::Yes, aLightPreviewBmps[i]);
 610     }
 611
 612     mxLightingSet->SetHelpId( HID_VALUESET_EXTRUSION_LIGHTING );
 613
 614     mxLightingSet->SetSelectHdl( LINK( this, ExtrusionLightingWindow, SelectValueSetHdl ) );
 615     mxLightingSet->SetColCount( 3 );
 616     mxLightingSet->EnableFullItemMode( false );
 617
 618     for (sal_uInt16 i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; ++i)
 619     {
 620         if( i != FROM_FRONT )
 621         {
 622             mxLightingSet->InsertItem( i+1, maImgLightingOff[i] );
 623         }
 624         else
 625         {
 626             mxLightingSet->InsertItem( 5, maImgLightingPreview[FROM_FRONT] );
 627         }
 628     }
 629     Size aSize(72, 72);
 630     mxLightingSet->GetDrawingArea()->set_size_request(aSize.Width(), aSize.Height());
 631     mxLightingSet->SetOutputSizePixel(aSize);
 632
 633     mxBright->connect_toggled(LINK(this, ExtrusionLightingWindow, SelectToolbarMenuHdl));
 634     mxNormal->connect_toggled(LINK(this, ExtrusionLightingWindow, SelectToolbarMenuHdl));
 635     mxDim->connect_toggled(LINK(this, ExtrusionLightingWindow, SelectToolbarMenuHdl));
 636
 637     AddStatusListener( g_sExtrusionLightingDirection );
 638     AddStatusListener( g_sExtrusionLightingIntensity );
 639 }
 640
 641 void ExtrusionLightingWindow::GrabFocus()
 642 {
 643     mxLightingSet->GrabFocus();
 644 }
 645
 646 ExtrusionLightingWindow::~ExtrusionLightingWindow()
 647 {
 648 }
 649
 650 void ExtrusionLightingWindow::implSetIntensity( int nLevel, bool bEnabled )
 651 {
 652     mxBright->set_sensitive(bEnabled);
 653     mxBright->set_active(nLevel == 0 && bEnabled);
 654     mxNormal->set_sensitive(bEnabled);
 655     mxNormal->set_active(nLevel == 1 && bEnabled);
 656     mxDim->set_sensitive(bEnabled);
 657     mxDim->set_active(nLevel == 2 && bEnabled);
 658 }
 659
 660 void ExtrusionLightingWindow::implSetDirection( int nDirection, bool bEnabled )
 661 {
 662     if( !bEnabled )
 663         nDirection = FROM_FRONT;
 664
 665     sal_uInt16 nItemId;
 666     for( nItemId = FROM_TOP_LEFT; nItemId <= FROM_BOTTOM_RIGHT; nItemId++ )
 667     {
 668         if( nItemId == FROM_FRONT )
 669         {
 670             mxLightingSet->SetItemImage( nItemId + 1, maImgLightingPreview[ nDirection ] );
 671         }
 672         else
 673         {
 674             mxLightingSet->SetItemImage(
 675                 nItemId + 1,
 676                 static_cast<sal_uInt16>(nDirection) == nItemId ? maImgLightingOn[nItemId] : maImgLightingOff[nItemId]
 677             );
 678         }
 679     }
 680
 681     if (bEnabled)
 682         mxLightingSet->Enable();
 683     else
 684         mxLightingSet->Disable();
 685 }
 686
 687 void ExtrusionLightingWindow::statusChanged(
 688     const css::frame::FeatureStateEvent& Event
 689 )
 690 {
 691     if( Event.FeatureURL.Main == g_sExtrusionLightingIntensity )
 692     {
 693         if( !Event.IsEnabled )
 694         {
 695             implSetIntensity( 0, false );
 696         }
 697         else
 698         {
 699             sal_Int32 nValue = 0;
 700             if( Event.State >>= nValue )
 701                 implSetIntensity( nValue, true );
 702         }
 703     }
 704     else if( Event.FeatureURL.Main == g_sExtrusionLightingDirection )
 705     {
 706         if( !Event.IsEnabled )
 707         {
 708             implSetDirection( 0, false );
 709         }
 710         else
 711         {
 712             sal_Int32 nValue = 0;
 713             if( Event.State >>= nValue )
 714                 implSetDirection( nValue, true );
 715         }
 716     }
 717 }
 718
 719 IMPL_LINK_NOARG(ExtrusionLightingWindow, SelectValueSetHdl, ValueSet*, void)
 720 {
 721     sal_Int32 nDirection = mxLightingSet->GetSelectedItemId();
 722
 723     if( (nDirection > 0) && (nDirection < 10) )
 724     {
 725         nDirection--;
 726
 727         Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 728             g_sExtrusionLightingDirection.copy(5), nDirection) };
 729
 730         mxControl->dispatchCommand( g_sExtrusionLightingDirection, aArgs );
 731
 732         implSetDirection( nDirection, true );
 733     }
 734
 735     mxControl->EndPopupMode();
 736 }
 737
 738 IMPL_LINK(ExtrusionLightingWindow, SelectToolbarMenuHdl, weld::Toggleable&, rButton, void)
 739 {
 740     if (!rButton.get_active())
 741         return;
 742
 743     int nLevel;
 744     if (mxBright->get_active())
 745         nLevel = 0;
 746     else if (mxNormal->get_active())
 747         nLevel = 1;
 748     else
 749         nLevel = 2;
 750
 751     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 752         g_sExtrusionLightingIntensity.copy(5), static_cast<sal_Int32>(nLevel)) };
 753
 754     mxControl->dispatchCommand( g_sExtrusionLightingIntensity, aArgs );
 755
 756     implSetIntensity( nLevel, true );
 757
 758     mxControl->EndPopupMode();
 759 }
 760
 761 ExtrusionLightingControl::ExtrusionLightingControl(
 762     const Reference< XComponentContext >& rxContext
 763 )   : svt::PopupWindowController( rxContext,
 764                 Reference< css::frame::XFrame >(),
 765                 u".uno:ExtrusionDirectionFloater"_ustr
 766     )
 767 {
 768 }
 769
 770 std::unique_ptr<WeldToolbarPopup> ExtrusionLightingControl::weldPopupWindow()
 771 {
 772     return std::make_unique<ExtrusionLightingWindow>(this, m_pToolbar);
 773 }
 774
 775 VclPtr<vcl::Window> ExtrusionLightingControl::createVclPopupWindow( vcl::Window* pParent )
 776 {
 777     mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
 778         std::make_unique<ExtrusionLightingWindow>(this, pParent->GetFrameWeld()));
 779
 780     mxInterimPopover->Show();
 781
 782     return mxInterimPopover;
 783 }
 784
 785 // XInitialization
 786 void SAL_CALL ExtrusionLightingControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 787 {
 788     svt::PopupWindowController::initialize( aArguments );
 789
 790     ToolBox* pToolBox = nullptr;
 791     ToolBoxItemId nId;
 792     if ( getToolboxId( nId, &pToolBox ) )
 793         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 794 }
 795
 796 // XServiceInfo
 797
 798
 799 OUString ExtrusionLightingControl::getImplementationName()
 800 {
 801     return u"com.sun.star.comp.svx.ExtrusionLightingController"_ustr;
 802 }
 803
 804
 805 Sequence< OUString > ExtrusionLightingControl::getSupportedServiceNames()
 806 {
 807     return { u"com.sun.star.frame.ToolbarController"_ustr };
 808 }
 809
 810
 811 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 812 com_sun_star_comp_svx_ExtrusionLightingControl_get_implementation(
 813     css::uno::XComponentContext* xContext,
 814     css::uno::Sequence<css::uno::Any> const &)
 815 {
 816     return cppu::acquire(new ExtrusionLightingControl(xContext));
 817 }
 818
 819
 820 constexpr OUString g_sExtrusionSurface = u".uno:ExtrusionSurface"_ustr;
 821
 822 ExtrusionSurfaceWindow::ExtrusionSurfaceWindow(svt::PopupWindowController* pControl, weld::Widget* pParent)
 823     : WeldToolbarPopup(pControl->getFrameInterface(), pParent, u"svx/ui/surfacewindow.ui"_ustr, u"SurfaceWindow"_ustr)
 824     , mxControl(pControl)
 825     , mxWireFrame(m_xBuilder->weld_radio_button(u"wireframe"_ustr))
 826     , mxMatt(m_xBuilder->weld_radio_button(u"matt"_ustr))
 827     , mxPlastic(m_xBuilder->weld_radio_button(u"plastic"_ustr))
 828     , mxMetal(m_xBuilder->weld_radio_button(u"metal"_ustr))
 829     , mxMetalMSO(m_xBuilder->weld_radio_button(u"metalMSO"_ustr))
 830 {
 831     mxWireFrame->connect_toggled(LINK(this, ExtrusionSurfaceWindow, SelectHdl));
 832     mxMatt->connect_toggled(LINK(this, ExtrusionSurfaceWindow, SelectHdl));
 833     mxPlastic->connect_toggled(LINK(this, ExtrusionSurfaceWindow, SelectHdl));
 834     mxMetal->connect_toggled(LINK(this, ExtrusionSurfaceWindow, SelectHdl));
 835     mxMetalMSO->connect_toggled(LINK(this, ExtrusionSurfaceWindow, SelectHdl));
 836
 837     AddStatusListener( g_sExtrusionSurface );
 838 }
 839
 840 void ExtrusionSurfaceWindow::GrabFocus()
 841 {
 842     mxWireFrame->grab_focus();
 843 }
 844
 845 void ExtrusionSurfaceWindow::implSetSurface( int nSurface, bool bEnabled )
 846 {
 847     mxWireFrame->set_active(nSurface == 0 && bEnabled);
 848     mxWireFrame->set_sensitive(bEnabled);
 849     mxMatt->set_active(nSurface == 1 && bEnabled);
 850     mxMatt->set_sensitive(bEnabled);
 851     mxPlastic->set_active(nSurface == 2 && bEnabled);
 852     mxPlastic->set_sensitive(bEnabled);
 853     mxMetal->set_active(nSurface == 3 && bEnabled);
 854     mxMetal->set_sensitive(bEnabled);
 855     mxMetalMSO->set_active(nSurface == 4 && bEnabled);
 856     mxMetalMSO->set_sensitive(bEnabled);
 857 }
 858
 859 void ExtrusionSurfaceWindow::statusChanged(
 860     const css::frame::FeatureStateEvent& Event
 861 )
 862 {
 863     if( Event.FeatureURL.Main != g_sExtrusionSurface )
 864         return;
 865
 866     if( !Event.IsEnabled )
 867     {
 868         implSetSurface( 0, false );
 869     }
 870     else
 871     {
 872         sal_Int32 nValue = 0;
 873         if( Event.State >>= nValue )
 874             implSetSurface( nValue, true );
 875     }
 876 }
 877
 878 IMPL_LINK(ExtrusionSurfaceWindow, SelectHdl, weld::Toggleable&, rButton, void)
 879 {
 880     if (!rButton.get_active())
 881         return;
 882
 883     sal_Int32 nSurface;
 884     if (mxWireFrame->get_active())
 885         nSurface = 0;
 886     else if (mxMatt->get_active())
 887         nSurface = 1;
 888     else if (mxPlastic->get_active())
 889         nSurface = 2;
 890     else if (mxMetal->get_active())
 891         nSurface = 3;
 892     else
 893         nSurface = 4;
 894
 895     Sequence< PropertyValue > aArgs{ comphelper::makePropertyValue(
 896         g_sExtrusionSurface.copy(5), nSurface) };
 897
 898     mxControl->dispatchCommand( g_sExtrusionSurface, aArgs );
 899
 900     implSetSurface( nSurface, true );
 901
 902     mxControl->EndPopupMode();
 903 }
 904
 905 ExtrusionSurfaceControl::ExtrusionSurfaceControl(
 906     const Reference< XComponentContext >& rxContext
 907 )
 908 :   svt::PopupWindowController(
 909         rxContext,
 910         Reference< css::frame::XFrame >(),
 911         u".uno:ExtrusionSurfaceFloater"_ustr
 912     )
 913 {
 914 }
 915
 916 std::unique_ptr<WeldToolbarPopup> ExtrusionSurfaceControl::weldPopupWindow()
 917 {
 918     return std::make_unique<ExtrusionSurfaceWindow>(this, m_pToolbar);
 919 }
 920
 921 VclPtr<vcl::Window> ExtrusionSurfaceControl::createVclPopupWindow( vcl::Window* pParent )
 922 {
 923     mxInterimPopover = VclPtr<InterimToolbarPopup>::Create(getFrameInterface(), pParent,
 924         std::make_unique<ExtrusionSurfaceWindow>(this, pParent->GetFrameWeld()));
 925
 926     mxInterimPopover->Show();
 927
 928     return mxInterimPopover;
 929 }
 930
 931 // XInitialization
 932 void SAL_CALL ExtrusionSurfaceControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 933 {
 934     svt::PopupWindowController::initialize( aArguments );
 935
 936     ToolBox* pToolBox = nullptr;
 937     ToolBoxItemId nId;
 938     if ( getToolboxId( nId, &pToolBox ) )
 939         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 940 }
 941
 942 // XServiceInfo
 943
 944
 945 OUString ExtrusionSurfaceControl::getImplementationName()
 946 {
 947     return u"com.sun.star.comp.svx.ExtrusionSurfaceController"_ustr;
 948 }
 949
 950
 951 Sequence< OUString > ExtrusionSurfaceControl::getSupportedServiceNames()
 952 {
 953     return { u"com.sun.star.frame.ToolbarController"_ustr };
 954 }
 955
 956
 957 extern "C" SAL_DLLPUBLIC_EXPORT css::uno::XInterface*
 958 com_sun_star_comp_svx_ExtrusionSurfaceControl_get_implementation(
 959     css::uno::XComponentContext* xContext,
 960     css::uno::Sequence<css::uno::Any> const &)
 961 {
 962     return cppu::acquire(new ExtrusionSurfaceControl(xContext));
 963 }
 964
 965 }
 966
 967 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */