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
  21 #include <string>
  22
  23 #include <osl/mutex.hxx>
  24
  25 #include <svtools/toolbarmenu.hxx>
  26 #include <vcl/toolbox.hxx>
  27 #include <sfx2/app.hxx>
  28 #include <sfx2/dispatch.hxx>
  29 #include <sfx2/objsh.hxx>
  30 #include <svl/eitem.hxx>
  31 #include <vcl/settings.hxx>
  32 #include <svl/intitem.hxx>
  33 #include <editeng/colritem.hxx>
  34
  35 #include <svx/dialogs.hrc>
  36 #include <svx/svdtrans.hxx>
  37 #include <svx/sdasitm.hxx>
  38 #include <svx/dialmgr.hxx>
  39
  40 #include "coreservices.hxx"
  41 #include "helpid.hrc"
  42 #include "extrusioncontrols.hxx"
  43 #include "extrusioncontrols.hrc"
  44 #include "colorwindow.hxx"
  45 #include "extrusiondepthdialog.hxx"
  46
  47
  48
  49 //using ::svtools::ToolbarMenu;
  50
  51 using namespace ::com::sun::star;
  52 using namespace ::com::sun::star::uno;
  53 using namespace ::com::sun::star::lang;
  54 using namespace ::com::sun::star::beans;
  55 using namespace ::com::sun::star::util;
  56 using namespace ::com::sun::star::graphic;
  57
  58 namespace svx
  59 {
  60
  61 static const sal_Int32 gSkewList[] = { 135, 90, 45, 180, 0, -360, -135, -90, -45 };
  62
  63 ExtrusionDirectionWindow::ExtrusionDirectionWindow(
  64     svt::ToolboxController& rController,
  65     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
  66     vcl::Window* pParentWindow
  67 )
  68     : ToolbarMenu(rFrame, pParentWindow,
  69                   WB_MOVEABLE|WB_CLOSEABLE|WB_HIDE|WB_3DLOOK)
  70     , mrController(rController)
  71     , maImgPerspective(SVX_RES(RID_SVXIMG_PERSPECTIVE))
  72     , maImgParallel(SVX_RES(RID_SVXIMG_PARALLEL))
  73     , msExtrusionDirection(".uno:ExtrusionDirection")
  74     , msExtrusionProjection(".uno:ExtrusionProjection")
  75 {
  76     for(sal_uInt16 i = DIRECTION_NW; i <= DIRECTION_SE; ++i)
  77     {
  78         maImgDirection[i] = Image( SVX_RES( RID_SVXIMG_DIRECTION + i ) );
  79     }
  80
  81     SetSelectHdl( LINK( this, ExtrusionDirectionWindow, SelectHdl ) );
  82     mpDirectionSet = createEmptyValueSetControl();
  83
  84     mpDirectionSet->SetSelectHdl( LINK( this, ExtrusionDirectionWindow, SelectHdl ) );
  85     mpDirectionSet->SetColCount( 3 );
  86     mpDirectionSet->EnableFullItemMode( false );
  87
  88     for (sal_uInt16 i = DIRECTION_NW; i <= DIRECTION_SE; ++i)
  89     {
  90         OUString aText(SVX_RESSTR(RID_SVXSTR_DIRECTION + i));
  91         mpDirectionSet->InsertItem(i + 1, maImgDirection[i], aText);
  92     }
  93
  94     mpDirectionSet->SetOutputSizePixel(Size(72, 72));
  95
  96     appendEntry(2, mpDirectionSet );
  97     appendSeparator();
  98     appendEntry(0, SVX_RESSTR(RID_SVXSTR_PERSPECTIVE), maImgPerspective);
  99     appendEntry(1, SVX_RESSTR(RID_SVXSTR_PARALLEL), maImgParallel);
 100
 101     SetOutputSizePixel( getMenuSize() );
 102
 103     AddStatusListener( msExtrusionDirection );
 104     AddStatusListener( msExtrusionProjection );
 105 }
 106
 107 ExtrusionDirectionWindow::~ExtrusionDirectionWindow()
 108 {
 109     disposeOnce();
 110 }
 111
 112 void ExtrusionDirectionWindow::dispose()
 113 {
 114     mpDirectionSet.clear();
 115     ToolbarMenu::dispose();
 116 }
 117
 118 void ExtrusionDirectionWindow::DataChanged( const DataChangedEvent& rDCEvt )
 119 {
 120     ToolbarMenu::DataChanged( rDCEvt );
 121
 122     if( ( rDCEvt.GetType() == DataChangedEventType::SETTINGS ) && ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE ) )
 123     {
 124         for( sal_uInt16 i = DIRECTION_NW; i <= DIRECTION_SE; i++ )
 125         {
 126             mpDirectionSet->SetItemImage( i+1, maImgDirection[ i ] );
 127         }
 128
 129         setEntryImage( 0, maImgPerspective );
 130         setEntryImage( 1, maImgParallel );
 131     }
 132 }
 133
 134
 135
 136 void ExtrusionDirectionWindow::implSetDirection( sal_Int32 nSkew, bool bEnabled )
 137 {
 138     if( mpDirectionSet )
 139     {
 140         sal_uInt16 nItemId;
 141         for( nItemId = DIRECTION_NW; nItemId <= DIRECTION_SE; nItemId++ )
 142         {
 143             if( gSkewList[nItemId] == nSkew )
 144                 break;
 145         }
 146
 147         if( nItemId <= DIRECTION_SE )
 148         {
 149             mpDirectionSet->SelectItem( nItemId+1 );
 150         }
 151         else
 152         {
 153             mpDirectionSet->SetNoSelection();
 154         }
 155     }
 156     enableEntry( 2, bEnabled );
 157 }
 158
 159
 160
 161 void ExtrusionDirectionWindow::implSetProjection( sal_Int32 nProjection, bool bEnabled )
 162 {
 163     checkEntry( 0, (nProjection == 0) && bEnabled );
 164     checkEntry( 1, (nProjection == 1 ) && bEnabled );
 165     enableEntry( 0, bEnabled );
 166     enableEntry( 1, bEnabled );
 167 }
 168
 169
 170
 171 void ExtrusionDirectionWindow::statusChanged(
 172     const ::com::sun::star::frame::FeatureStateEvent& Event
 173 )   throw ( ::com::sun::star::uno::RuntimeException )
 174 {
 175     if( Event.FeatureURL.Main.equals( msExtrusionDirection ) )
 176     {
 177         if( !Event.IsEnabled )
 178         {
 179             implSetDirection( -1, false );
 180         }
 181         else
 182         {
 183             sal_Int32 nValue = 0;
 184             if( Event.State >>= nValue )
 185                 implSetDirection( nValue, true );
 186         }
 187     }
 188     else if( Event.FeatureURL.Main.equals( msExtrusionProjection ) )
 189     {
 190         if( !Event.IsEnabled )
 191         {
 192             implSetProjection( -1, false );
 193         }
 194         else
 195         {
 196             sal_Int32 nValue = 0;
 197             if( Event.State >>= nValue )
 198                 implSetProjection( nValue, true );
 199         }
 200     }
 201 }
 202
 203
 204
 205 IMPL_LINK( ExtrusionDirectionWindow, SelectHdl, void *, pControl )
 206 {
 207     if ( IsInPopupMode() )
 208         EndPopupMode();
 209
 210     if( pControl == mpDirectionSet )
 211     {
 212         Sequence< PropertyValue > aArgs( 1 );
 213         aArgs[0].Name = msExtrusionDirection.copy(5);
 214         aArgs[0].Value <<= (sal_Int32)gSkewList[mpDirectionSet->GetSelectItemId()-1];
 215
 216         mrController.dispatchCommand( msExtrusionDirection, aArgs );
 217     }
 218     else
 219     {
 220         int nProjection = getSelectedEntryId();
 221         if( (nProjection >= 0) && (nProjection < 2 ) )
 222         {
 223             Sequence< PropertyValue > aArgs( 1 );
 224             aArgs[0].Name = msExtrusionProjection.copy(5);
 225             aArgs[0].Value <<= (sal_Int32)nProjection;
 226
 227             mrController.dispatchCommand( msExtrusionProjection, aArgs );
 228             implSetProjection( nProjection, true );
 229         }
 230     }
 231
 232     return 0;
 233 }
 234
 235 ExtrusionDirectionControl::ExtrusionDirectionControl(
 236     const Reference< XComponentContext >& rxContext
 237 )   : svt::PopupWindowController(
 238         rxContext,
 239         Reference< frame::XFrame >(),
 240         OUString( ".uno:ExtrusionDirectionFloater" )
 241     )
 242 {
 243 }
 244
 245
 246
 247 VclPtr<vcl::Window> ExtrusionDirectionControl::createPopupWindow( vcl::Window* pParent )
 248 {
 249     return VclPtr<ExtrusionDirectionWindow>::Create( *this, m_xFrame, pParent );
 250 }
 251
 252 // XInitialization
 253 void SAL_CALL ExtrusionDirectionControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 254     throw ( css::uno::Exception, css::uno::RuntimeException, std::exception )
 255 {
 256     svt::PopupWindowController::initialize( aArguments );
 257
 258     ToolBox* pToolBox = 0;
 259     sal_uInt16 nId = 0;
 260     if ( getToolboxId( nId, &pToolBox ) )
 261         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 262 }
 263
 264 // XServiceInfo
 265
 266
 267 OUString SAL_CALL ExtrusionDirectionControl_getImplementationName()
 268 {
 269     return OUString( "com.sun.star.comp.svx.ExtrusionDirectionController" );
 270 }
 271
 272
 273
 274 Sequence< OUString > SAL_CALL ExtrusionDirectionControl_getSupportedServiceNames() throw( RuntimeException )
 275 {
 276     Sequence< OUString > aSNS( 1 );
 277     aSNS.getArray()[0] = "com.sun.star.frame.ToolbarController";
 278     return aSNS;
 279 }
 280
 281
 282
 283 Reference< XInterface > SAL_CALL SAL_CALL ExtrusionDirectionControl_createInstance(
 284     const Reference< XMultiServiceFactory >& rSMgr
 285 )   throw( RuntimeException )
 286 {
 287     return *new ExtrusionDirectionControl( comphelper::getComponentContext(rSMgr) );
 288 }
 289
 290
 291
 292 OUString SAL_CALL ExtrusionDirectionControl::getImplementationName(  ) throw (RuntimeException, std::exception)
 293 {
 294     return ExtrusionDirectionControl_getImplementationName();
 295 }
 296
 297
 298
 299 Sequence< OUString > SAL_CALL ExtrusionDirectionControl::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 300 {
 301     return ExtrusionDirectionControl_getSupportedServiceNames();
 302 }
 303
 304 ExtrusionDepthDialog::ExtrusionDepthDialog( vcl::Window* pParent, double fDepth, FieldUnit eDefaultUnit )
 305     : ModalDialog( pParent, "ExtrustionDepthDialog", "svx/ui/extrustiondepthdialog.ui" )
 306 {
 307     get(m_pMtrDepth, "depth");
 308     m_pMtrDepth->SetUnit( eDefaultUnit );
 309     m_pMtrDepth->SetValue( (int) fDepth * 100, FUNIT_100TH_MM );
 310 }
 311
 312 ExtrusionDepthDialog::~ExtrusionDepthDialog()
 313 {
 314     disposeOnce();
 315 }
 316
 317 void ExtrusionDepthDialog::dispose()
 318 {
 319     m_pMtrDepth.clear();
 320     ModalDialog::dispose();
 321 }
 322
 323 double ExtrusionDepthDialog::getDepth() const
 324 {
 325     return (double)( m_pMtrDepth->GetValue( FUNIT_100TH_MM ) ) / 100.0;
 326 }
 327
 328 double aDepthListInch[] = { 0, 1270,2540,5080,10160 };
 329 double aDepthListMM[] = { 0, 1000, 2500, 5000, 10000 };
 330
 331 ExtrusionDepthWindow::ExtrusionDepthWindow(
 332     svt::ToolboxController& rController,
 333     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
 334     vcl::Window* pParentWindow
 335 )   : ToolbarMenu( rFrame, pParentWindow, WB_MOVEABLE|WB_CLOSEABLE|WB_HIDE|WB_3DLOOK)
 336     , mrController( rController )
 337     , maImgDepth0(SVX_RES(RID_SVXIMG_DEPTH_0))
 338     , maImgDepth1(SVX_RES(RID_SVXIMG_DEPTH_1))
 339     , maImgDepth2(SVX_RES(RID_SVXIMG_DEPTH_2))
 340     , maImgDepth3(SVX_RES(RID_SVXIMG_DEPTH_3))
 341     , maImgDepth4(SVX_RES(RID_SVXIMG_DEPTH_4))
 342     , maImgDepthInfinity(SVX_RES(RID_SVXIMG_DEPTH_INFINITY))
 343     , meUnit(FUNIT_NONE)
 344     , mfDepth( -1.0 )
 345     , msExtrusionDepth( ".uno:ExtrusionDepth" )
 346     , msMetricUnit(     ".uno:MetricUnit"     )
 347 {
 348     SetSelectHdl( LINK( this, ExtrusionDepthWindow, SelectHdl ) );
 349
 350     OUString aEmpty;
 351     appendEntry(0, aEmpty, maImgDepth0);
 352     appendEntry(1, aEmpty, maImgDepth1);
 353     appendEntry(2, aEmpty, maImgDepth2);
 354     appendEntry(3, aEmpty, maImgDepth3);
 355     appendEntry(4, aEmpty, maImgDepth4);
 356     appendEntry(5, SVX_RESSTR(RID_SVXSTR_INFINITY), maImgDepthInfinity);
 357     appendEntry(6, SVX_RESSTR(RID_SVXSTR_CUSTOM));
 358
 359     SetOutputSizePixel( getMenuSize() );
 360
 361     AddStatusListener( msExtrusionDepth );
 362     AddStatusListener( msMetricUnit );
 363 }
 364
 365 void ExtrusionDepthWindow::implSetDepth( double fDepth )
 366 {
 367     mfDepth = fDepth;
 368     int i;
 369     for( i = 0; i < 7; i++ )
 370     {
 371         if( i == 5 )
 372         {
 373             checkEntry( i, fDepth >= 338666 );
 374         }
 375         else if( i != 6 )
 376         {
 377             checkEntry( i, (fDepth == (IsMetric( meUnit ) ? aDepthListMM[i] : aDepthListInch[i]) ) );
 378         }
 379     }
 380 }
 381
 382
 383
 384 void ExtrusionDepthWindow::implFillStrings( FieldUnit eUnit )
 385 {
 386     meUnit = eUnit;
 387     sal_uInt16 nResource = IsMetric( eUnit ) ? RID_SVXSTR_DEPTH_0 : RID_SVXSTR_DEPTH_0_INCH;
 388
 389     for( int i = 0; i < 5; i++ )
 390     {
 391         OUString aStr( SVX_RESSTR( nResource + i ) );
 392         setEntryText( i, aStr );
 393     }
 394 }
 395
 396
 397
 398 void ExtrusionDepthWindow::statusChanged(
 399     const ::com::sun::star::frame::FeatureStateEvent& Event
 400 )   throw ( ::com::sun::star::uno::RuntimeException )
 401 {
 402     if( Event.FeatureURL.Main.equals( msExtrusionDepth ) )
 403     {
 404         if( !Event.IsEnabled )
 405         {
 406             implSetDepth( 0 );
 407         }
 408         else
 409         {
 410             double fValue = 0.0;
 411             if( Event.State >>= fValue )
 412                 implSetDepth( fValue );
 413         }
 414     }
 415     else if( Event.FeatureURL.Main.equals( msMetricUnit ) )
 416     {
 417         if( Event.IsEnabled )
 418         {
 419             sal_Int32 nValue = 0;
 420             if( Event.State >>= nValue )
 421             {
 422                 implFillStrings( static_cast<FieldUnit>(nValue) );
 423                 if( mfDepth >= 0.0 )
 424                     implSetDepth( mfDepth );
 425             }
 426         }
 427     }
 428 }
 429
 430 IMPL_LINK_NOARG(ExtrusionDepthWindow, SelectHdl)
 431 {
 432     int nSelected = getSelectedEntryId();
 433     if( nSelected != -1 )
 434     {
 435         if( nSelected == 6 )
 436         {
 437             if ( IsInPopupMode() )
 438                 EndPopupMode();
 439
 440             const OUString aCommand( ".uno:ExtrusionDepthDialog" );
 441
 442             Sequence< PropertyValue > aArgs( 2 );
 443             aArgs[0].Name = "Depth";
 444             aArgs[0].Value <<= mfDepth;
 445             aArgs[1].Name = "Metric";
 446             aArgs[1].Value <<= static_cast<sal_Int32>( meUnit );
 447
 448             mrController.dispatchCommand( aCommand, aArgs );
 449         }
 450         else
 451         {
 452             double fDepth;
 453
 454             if( nSelected == 5 )
 455             {
 456                 fDepth = 338666.6;
 457             }
 458             else
 459             {
 460                 fDepth = IsMetric( meUnit ) ? aDepthListMM[nSelected] : aDepthListInch[nSelected];
 461             }
 462
 463             Sequence< PropertyValue > aArgs( 1 );
 464             aArgs[0].Name = msExtrusionDepth.copy(5);
 465             aArgs[0].Value <<= fDepth;
 466
 467             mrController.dispatchCommand( msExtrusionDepth,  aArgs );
 468             implSetDepth( fDepth );
 469
 470             if ( IsInPopupMode() )
 471                 EndPopupMode();
 472         }
 473     }
 474     return 0;
 475 }
 476
 477
 478 // ExtrusionDirectionControl
 479
 480
 481 ExtrusionDepthController::ExtrusionDepthController(
 482     const Reference< XComponentContext >& rxContext
 483 )   : svt::PopupWindowController(
 484         rxContext,
 485         Reference< frame::XFrame >(),
 486         OUString( ".uno:ExtrusionDepthFloater" )
 487     )
 488 {
 489 }
 490
 491
 492
 493 VclPtr<vcl::Window> ExtrusionDepthController::createPopupWindow( vcl::Window* pParent )
 494 {
 495     return VclPtr<ExtrusionDepthWindow>::Create( *this, m_xFrame, pParent );
 496 }
 497
 498 // XInitialization
 499 void SAL_CALL ExtrusionDepthController::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 500     throw ( css::uno::Exception, css::uno::RuntimeException, std::exception )
 501 {
 502     svt::PopupWindowController::initialize( aArguments );
 503
 504     ToolBox* pToolBox = 0;
 505     sal_uInt16 nId = 0;
 506     if ( getToolboxId( nId, &pToolBox ) )
 507         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 508 }
 509
 510 // XServiceInfo
 511
 512
 513 OUString SAL_CALL ExtrusionDepthController_getImplementationName()
 514 {
 515     return OUString( "com.sun.star.comp.svx.ExtrusionDepthController" );
 516 }
 517
 518
 519
 520 Sequence< OUString > SAL_CALL ExtrusionDepthController_getSupportedServiceNames() throw( RuntimeException )
 521 {
 522     Sequence< OUString > aSNS( 1 );
 523     aSNS.getArray()[0] = "com.sun.star.frame.ToolbarController";
 524     return aSNS;
 525 }
 526
 527
 528
 529 Reference< XInterface > SAL_CALL SAL_CALL ExtrusionDepthController_createInstance( const Reference< XMultiServiceFactory >& rSMgr ) throw( RuntimeException )
 530 {
 531     return *new ExtrusionDepthController( comphelper::getComponentContext(rSMgr) );
 532 }
 533
 534 OUString SAL_CALL ExtrusionDepthController::getImplementationName(  ) throw (RuntimeException, std::exception)
 535 {
 536     return ExtrusionDepthController_getImplementationName();
 537 }
 538
 539 Sequence< OUString > SAL_CALL ExtrusionDepthController::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 540 {
 541     return ExtrusionDepthController_getSupportedServiceNames();
 542 }
 543
 544 ExtrusionLightingWindow::ExtrusionLightingWindow(svt::ToolboxController& rController,
 545                                                  const css::uno::Reference<css::frame::XFrame >& rFrame,
 546                                                  vcl::Window* pParentWindow)
 547     : ToolbarMenu(rFrame, pParentWindow, WB_MOVEABLE|WB_CLOSEABLE|WB_HIDE|WB_3DLOOK)
 548     , mrController(rController)
 549     , maImgBright(SVX_RES(RID_SVXIMG_LIGHTING_BRIGHT))
 550     , maImgNormal(SVX_RES(RID_SVXIMG_LIGHTING_NORMAL))
 551     , maImgDim(SVX_RES(RID_SVXIMG_LIGHTING_DIM))
 552     , mnLevel(0)
 553     , mbLevelEnabled(false)
 554     , mnDirection(FROM_FRONT)
 555     , mbDirectionEnabled(false)
 556     , msExtrusionLightingDirection(".uno:ExtrusionLightingDirection")
 557     , msExtrusionLightingIntensity(".uno:ExtrusionLightingIntensity")
 558 {
 559     for (sal_uInt16 i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; ++i)
 560     {
 561         if( i != FROM_FRONT )
 562         {
 563             maImgLightingOff[i] = Image(SVX_RES(RID_SVXIMG_LIGHT_OFF + i));
 564             maImgLightingOn[i] = Image(SVX_RES(RID_SVXIMG_LIGHT_ON + i));
 565         }
 566         maImgLightingPreview[i] = Image(SVX_RES(RID_SVXIMG_LIGHT_PREVIEW + i));
 567     }
 568
 569     SetSelectHdl( LINK( this, ExtrusionLightingWindow, SelectHdl ) );
 570
 571     mpLightingSet = createEmptyValueSetControl();
 572     mpLightingSet->SetHelpId( HID_VALUESET_EXTRUSION_LIGHTING );
 573
 574     mpLightingSet->SetSelectHdl( LINK( this, ExtrusionLightingWindow, SelectHdl ) );
 575     mpLightingSet->SetColCount( 3 );
 576     mpLightingSet->EnableFullItemMode( false );
 577
 578     for (sal_uInt16 i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; ++i)
 579     {
 580         if( i != FROM_FRONT )
 581         {
 582             mpLightingSet->InsertItem( i+1, maImgLightingOff[i] );
 583         }
 584         else
 585         {
 586             mpLightingSet->InsertItem( 5, maImgLightingPreview[FROM_FRONT] );
 587         }
 588     }
 589     mpLightingSet->SetOutputSizePixel( Size( 72, 72 ) );
 590
 591     appendEntry(3, mpLightingSet);
 592     appendSeparator();
 593     appendEntry(0, SVX_RESSTR(RID_SVXSTR_BRIGHT), maImgBright);
 594     appendEntry(1, SVX_RESSTR(RID_SVXSTR_NORMAL), maImgNormal);
 595     appendEntry(2, SVX_RESSTR(RID_SVXSTR_DIM), maImgDim);
 596
 597     SetOutputSizePixel( getMenuSize() );
 598
 599     AddStatusListener( msExtrusionLightingDirection );
 600     AddStatusListener( msExtrusionLightingIntensity );
 601 }
 602
 603 ExtrusionLightingWindow::~ExtrusionLightingWindow()
 604 {
 605     disposeOnce();
 606 }
 607
 608 void ExtrusionLightingWindow::dispose()
 609 {
 610     mpLightingSet.clear();
 611     ToolbarMenu::dispose();
 612 }
 613
 614 void ExtrusionLightingWindow::implSetIntensity( int nLevel, bool bEnabled )
 615 {
 616     mnLevel = nLevel;
 617     mbLevelEnabled = bEnabled;
 618     for (int i = 0; i < 3; ++i)
 619     {
 620         checkEntry( i, (i == nLevel) && bEnabled );
 621         enableEntry( i, bEnabled );
 622     }
 623 }
 624
 625 void ExtrusionLightingWindow::implSetDirection( int nDirection, bool bEnabled )
 626 {
 627     mnDirection = nDirection;
 628     mbDirectionEnabled = bEnabled;
 629
 630     if( !bEnabled )
 631         nDirection = FROM_FRONT;
 632
 633     sal_uInt16 nItemId;
 634     for( nItemId = FROM_TOP_LEFT; nItemId <= FROM_BOTTOM_RIGHT; nItemId++ )
 635     {
 636         if( nItemId == FROM_FRONT )
 637         {
 638             mpLightingSet->SetItemImage( nItemId + 1, maImgLightingPreview[ nDirection ] );
 639         }
 640         else
 641         {
 642             mpLightingSet->SetItemImage(
 643                 nItemId + 1,
 644                 (sal_uInt16)nDirection == nItemId ? maImgLightingOn[nItemId] : maImgLightingOff[nItemId]
 645             );
 646         }
 647     }
 648
 649     enableEntry( 3, bEnabled );
 650 }
 651
 652
 653
 654 void ExtrusionLightingWindow::statusChanged(
 655     const ::com::sun::star::frame::FeatureStateEvent& Event
 656 )   throw ( ::com::sun::star::uno::RuntimeException )
 657 {
 658     if( Event.FeatureURL.Main.equals( msExtrusionLightingIntensity ) )
 659     {
 660         if( !Event.IsEnabled )
 661         {
 662             implSetIntensity( 0, false );
 663         }
 664         else
 665         {
 666             sal_Int32 nValue = 0;
 667             if( Event.State >>= nValue )
 668                 implSetIntensity( nValue, true );
 669         }
 670     }
 671     else if( Event.FeatureURL.Main.equals( msExtrusionLightingDirection ) )
 672     {
 673         if( !Event.IsEnabled )
 674         {
 675             implSetDirection( 0, false );
 676         }
 677         else
 678         {
 679             sal_Int32 nValue = 0;
 680             if( Event.State >>= nValue )
 681                 implSetDirection( nValue, true );
 682         }
 683     }
 684 }
 685
 686
 687
 688 void ExtrusionLightingWindow::DataChanged( const DataChangedEvent& rDCEvt )
 689 {
 690     ToolbarMenu::DataChanged( rDCEvt );
 691
 692     if( ( rDCEvt.GetType() == DataChangedEventType::SETTINGS ) && ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE ) )
 693     {
 694         implSetDirection( mnDirection, mbDirectionEnabled );
 695         setEntryImage( 0, maImgBright );
 696         setEntryImage( 1, maImgNormal );
 697         setEntryImage( 2, maImgDim    );
 698     }
 699 }
 700
 701
 702
 703 IMPL_LINK( ExtrusionLightingWindow, SelectHdl, void *, pControl )
 704 {
 705     if ( IsInPopupMode() )
 706         EndPopupMode();
 707
 708     if( pControl == this )
 709     {
 710         int nLevel = getSelectedEntryId();
 711         if( nLevel >= 0 )
 712         {
 713             if( nLevel != 3 )
 714             {
 715                 Sequence< PropertyValue > aArgs( 1 );
 716                 aArgs[0].Name = msExtrusionLightingIntensity.copy(5);
 717                 aArgs[0].Value <<= (sal_Int32)nLevel;
 718
 719                 mrController.dispatchCommand( msExtrusionLightingIntensity, aArgs );
 720
 721                 implSetIntensity( nLevel, true );
 722             }
 723         }
 724     }
 725     else
 726     {
 727         sal_Int32 nDirection = mpLightingSet->GetSelectItemId();
 728
 729         if( (nDirection > 0) && (nDirection < 10) )
 730         {
 731             nDirection--;
 732
 733             Sequence< PropertyValue > aArgs( 1 );
 734             aArgs[0].Name = msExtrusionLightingDirection.copy(5);
 735             aArgs[0].Value <<= (sal_Int32)nDirection;
 736
 737             mrController.dispatchCommand( msExtrusionLightingDirection, aArgs );
 738
 739             implSetDirection( nDirection, true );
 740         }
 741
 742     }
 743
 744     return 0;
 745 }
 746
 747
 748
 749 ExtrusionLightingControl::ExtrusionLightingControl(
 750     const Reference< XComponentContext >& rxContext
 751 )   : svt::PopupWindowController( rxContext,
 752                 Reference< frame::XFrame >(),
 753                 OUString( ".uno:ExtrusionDirectionFloater" )
 754     )
 755 {
 756 }
 757
 758
 759
 760 VclPtr<vcl::Window> ExtrusionLightingControl::createPopupWindow( vcl::Window* pParent )
 761 {
 762     return VclPtr<ExtrusionLightingWindow>::Create( *this, m_xFrame, pParent );
 763 }
 764
 765 // XInitialization
 766 void SAL_CALL ExtrusionLightingControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 767     throw ( css::uno::Exception, css::uno::RuntimeException, std::exception )
 768 {
 769     svt::PopupWindowController::initialize( aArguments );
 770
 771     ToolBox* pToolBox = 0;
 772     sal_uInt16 nId = 0;
 773     if ( getToolboxId( nId, &pToolBox ) )
 774         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 775 }
 776
 777 // XServiceInfo
 778
 779
 780 OUString SAL_CALL ExtrusionLightingControl_getImplementationName()
 781 {
 782     return OUString( "com.sun.star.comp.svx.ExtrusionLightingController" );
 783 }
 784
 785
 786
 787 Sequence< OUString > SAL_CALL ExtrusionLightingControl_getSupportedServiceNames() throw( RuntimeException )
 788 {
 789     Sequence< OUString > aSNS( 1 );
 790     aSNS.getArray()[0] = "com.sun.star.frame.ToolbarController";
 791     return aSNS;
 792 }
 793
 794
 795
 796 Reference< XInterface > SAL_CALL SAL_CALL ExtrusionLightingControl_createInstance(
 797     const Reference< XMultiServiceFactory >& rSMgr
 798 )   throw( RuntimeException )
 799 {
 800     return *new ExtrusionLightingControl( comphelper::getComponentContext(rSMgr) );
 801 }
 802
 803
 804
 805 OUString SAL_CALL ExtrusionLightingControl::getImplementationName(  ) throw (RuntimeException, std::exception)
 806 {
 807     return ExtrusionLightingControl_getImplementationName();
 808 }
 809
 810
 811
 812 Sequence< OUString > SAL_CALL ExtrusionLightingControl::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 813 {
 814     return ExtrusionLightingControl_getSupportedServiceNames();
 815 }
 816
 817 ExtrusionSurfaceWindow::ExtrusionSurfaceWindow(
 818     svt::ToolboxController& rController,
 819     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
 820     vcl::Window* pParentWindow)
 821     : ToolbarMenu(rFrame, pParentWindow, WB_MOVEABLE|WB_CLOSEABLE|WB_HIDE|WB_3DLOOK)
 822     , mrController(rController)
 823     , maImgSurface1(SVX_RES(RID_SVXIMG_WIRE_FRAME))
 824     , maImgSurface2(SVX_RES(RID_SVXIMG_MATTE))
 825     , maImgSurface3(SVX_RES(RID_SVXIMG_PLASTIC))
 826     , maImgSurface4(SVX_RES(RID_SVXIMG_METAL))
 827     , msExtrusionSurface(".uno:ExtrusionSurface")
 828 {
 829     SetSelectHdl( LINK( this, ExtrusionSurfaceWindow, SelectHdl ) );
 830
 831     appendEntry(0, SVX_RESSTR(RID_SVXSTR_WIREFRAME), maImgSurface1);
 832     appendEntry(1, SVX_RESSTR(RID_SVXSTR_MATTE), maImgSurface2);
 833     appendEntry(2, SVX_RESSTR(RID_SVXSTR_PLASTIC), maImgSurface3);
 834     appendEntry(3, SVX_RESSTR(RID_SVXSTR_METAL), maImgSurface4);
 835
 836     SetOutputSizePixel( getMenuSize() );
 837
 838     AddStatusListener( msExtrusionSurface );
 839 }
 840
 841 void ExtrusionSurfaceWindow::implSetSurface( int nSurface, bool bEnabled )
 842 {
 843     for(int i = 0; i < 4; ++i)
 844     {
 845         checkEntry( i, (i == nSurface) && bEnabled );
 846         enableEntry( i, bEnabled );
 847     }
 848 }
 849
 850 void ExtrusionSurfaceWindow::statusChanged(
 851     const ::com::sun::star::frame::FeatureStateEvent& Event
 852 )   throw ( ::com::sun::star::uno::RuntimeException )
 853 {
 854     if( Event.FeatureURL.Main.equals( msExtrusionSurface ) )
 855     {
 856         if( !Event.IsEnabled )
 857         {
 858             implSetSurface( 0, false );
 859         }
 860         else
 861         {
 862             sal_Int32 nValue = 0;
 863             if( Event.State >>= nValue )
 864                 implSetSurface( nValue, true );
 865         }
 866     }
 867 }
 868
 869
 870
 871 IMPL_LINK_NOARG(ExtrusionSurfaceWindow, SelectHdl)
 872 {
 873     if ( IsInPopupMode() )
 874         EndPopupMode();
 875
 876     sal_Int32 nSurface = getSelectedEntryId();
 877     if( nSurface >= 0 )
 878     {
 879         Sequence< PropertyValue > aArgs( 1 );
 880         aArgs[0].Name = msExtrusionSurface.copy(5);
 881         aArgs[0].Value <<= (sal_Int32)nSurface;
 882
 883         mrController.dispatchCommand( msExtrusionSurface, aArgs );
 884
 885         implSetSurface( nSurface, true );
 886     }
 887
 888     return 0;
 889 }
 890
 891
 892
 893 ExtrusionSurfaceControl::ExtrusionSurfaceControl(
 894     const Reference< XComponentContext >& rxContext
 895 )
 896 :   svt::PopupWindowController(
 897         rxContext,
 898         Reference< frame::XFrame >(),
 899         OUString( ".uno:ExtrusionSurfaceFloater" )
 900     )
 901 {
 902 }
 903
 904
 905
 906 VclPtr<vcl::Window> ExtrusionSurfaceControl::createPopupWindow( vcl::Window* pParent )
 907 {
 908     return VclPtr<ExtrusionSurfaceWindow>::Create( *this, m_xFrame, pParent );
 909 }
 910
 911 // XInitialization
 912 void SAL_CALL ExtrusionSurfaceControl::initialize( const css::uno::Sequence< css::uno::Any >& aArguments )
 913     throw ( css::uno::Exception, css::uno::RuntimeException, std::exception )
 914 {
 915     svt::PopupWindowController::initialize( aArguments );
 916
 917     ToolBox* pToolBox = 0;
 918     sal_uInt16 nId = 0;
 919     if ( getToolboxId( nId, &pToolBox ) )
 920         pToolBox->SetItemBits( nId, pToolBox->GetItemBits( nId ) | ToolBoxItemBits::DROPDOWNONLY );
 921 }
 922
 923 // XServiceInfo
 924
 925
 926 OUString SAL_CALL ExtrusionSurfaceControl_getImplementationName()
 927 {
 928     return OUString( "com.sun.star.comp.svx.ExtrusionSurfaceController" );
 929 }
 930
 931
 932
 933 Sequence< OUString > SAL_CALL ExtrusionSurfaceControl_getSupportedServiceNames() throw( RuntimeException )
 934 {
 935     Sequence< OUString > aSNS( 1 );
 936     aSNS.getArray()[0] = "com.sun.star.frame.ToolbarController";
 937     return aSNS;
 938 }
 939
 940
 941
 942 Reference< XInterface > SAL_CALL SAL_CALL ExtrusionSurfaceControl_createInstance(
 943     const Reference< XMultiServiceFactory >& rSMgr
 944 )   throw( RuntimeException )
 945 {
 946     return *new ExtrusionSurfaceControl( comphelper::getComponentContext(rSMgr) );
 947 }
 948
 949
 950
 951 OUString SAL_CALL ExtrusionSurfaceControl::getImplementationName(  ) throw (RuntimeException, std::exception)
 952 {
 953     return ExtrusionSurfaceControl_getImplementationName();
 954 }
 955
 956
 957
 958 Sequence< OUString > SAL_CALL ExtrusionSurfaceControl::getSupportedServiceNames(  ) throw (RuntimeException, std::exception)
 959 {
 960     return ExtrusionSurfaceControl_getSupportedServiceNames();
 961 }
 962
 963 }
 964
 965 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */