svx/source/tbxctrls/extrusioncontrols.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2008 by Sun Microsystems, Inc.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * $RCSfile: extrusioncontrols.cxx,v $
  10  * $Revision: 1.16 $
  11  *
  12  * This file is part of OpenOffice.org.
  13  *
  14  * OpenOffice.org is free software: you can redistribute it and/or modify
  15  * it under the terms of the GNU Lesser General Public License version 3
  16  * only, as published by the Free Software Foundation.
  17  *
  18  * OpenOffice.org is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU Lesser General Public License version 3 for more details
  22  * (a copy is included in the LICENSE file that accompanied this code).
  23  *
  24  * You should have received a copy of the GNU Lesser General Public License
  25  * version 3 along with OpenOffice.org.  If not, see
  26  * <http://www.openoffice.org/license.html>
  27  * for a copy of the LGPLv3 License.
  28  *
  29  ************************************************************************/
  30
  31 // MARKER(update_precomp.py): autogen include statement, do not remove
  32 #include "precompiled_svx.hxx"
  33
  34 // include ---------------------------------------------------------------
  35
  36 #include <string> // HACK: prevent conflict between STLPORT and Workshop headers
  37
  38 #ifndef _TOOLBOX_HXX //autogen
  39 #include <vcl/toolbox.hxx>
  40 #endif
  41 #include <sfx2/app.hxx>
  42 #include <sfx2/dispatch.hxx>
  43 #include <sfx2/objsh.hxx>
  44 #include <svtools/eitem.hxx>
  45 #include <vcl/settings.hxx>
  46 #include <svtools/intitem.hxx>
  47 #include <svx/colritem.hxx>
  48 #include "chrtitem.hxx"
  49 #include <tools/urlobj.hxx>
  50
  51 #include <svx/dialogs.hrc>
  52 #include "helpid.hrc"
  53
  54 #include <svx/svdtrans.hxx>
  55 #include <svx/dialmgr.hxx>
  56 #include "extrusioncontrols.hxx"
  57 #include "extrusioncontrols.hrc"
  58 #include <svx/sdasitm.hxx>
  59 #include "toolbarmenu.hxx"
  60 #include "colorwindow.hxx"
  61
  62 #include <svx/tbxcolorupdate.hxx>
  63
  64 ////////////
  65
  66 using namespace svx;
  67 using namespace ::com::sun::star::uno;
  68 using namespace ::com::sun::star::lang;
  69 using namespace ::com::sun::star::beans;
  70
  71 SFX_IMPL_TOOLBOX_CONTROL( ExtrusionDirectionControl, SfxBoolItem );
  72
  73 /*************************************************************************
  74 |*
  75 |* ExtrusionDirectionWindow
  76 |*
  77 \************************************************************************/
  78
  79 static sal_Int32 gSkewList[] = { 135, 90, 45, 180, 0, -360, -135, -90, -45 };
  80
  81 ExtrusionDirectionWindow::ExtrusionDirectionWindow(
  82     USHORT nId,
  83     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) :
  84     SfxPopupWindow( nId,
  85                     rFrame,
  86                     SVX_RES( RID_SVXFLOAT_EXTRUSION_DIRECTION )),
  87     mxFrame( rFrame ),
  88     maImgPerspective( SVX_RES( IMG_PERSPECTIVE ) ),
  89     maImgPerspectiveH( SVX_RES( IMG_PERSPECTIVE_H ) ),
  90     maImgParallel( SVX_RES( IMG_PARALLEL ) ),
  91     maImgParallelH( SVX_RES( IMG_PARALLEL_H ) ),
  92     mbPopupMode         ( TRUE )
  93 {
  94     implInit();
  95 }
  96
  97 ExtrusionDirectionWindow::ExtrusionDirectionWindow(
  98     USHORT nId,
  99     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
 100     Window* pParentWindow ) :
 101     SfxPopupWindow( nId,
 102                     rFrame,
 103                     pParentWindow,
 104                     SVX_RES( RID_SVXFLOAT_EXTRUSION_DIRECTION )),
 105     mxFrame( rFrame ),
 106     maImgPerspective( SVX_RES( IMG_PERSPECTIVE ) ),
 107     maImgPerspectiveH( SVX_RES( IMG_PERSPECTIVE_H ) ),
 108     maImgParallel( SVX_RES( IMG_PARALLEL ) ),
 109     maImgParallelH( SVX_RES( IMG_PARALLEL_H ) ),
 110     mbPopupMode         ( TRUE )
 111 {
 112     implInit();
 113 }
 114
 115 void ExtrusionDirectionWindow::implInit()
 116 {
 117     SetHelpId( HID_POPUP_EXTRUSION_DIRECTION );
 118
 119     USHORT i;
 120     for( i = DIRECTION_NW; i <= DIRECTION_SE; i++ )
 121     {
 122         maImgDirection[i] = Image( SVX_RES( IMG_DIRECTION + i ) );
 123         maImgDirectionH[i] = Image( SVX_RES( IMG_DIRECTION_H + i ) );
 124     }
 125
 126 //      mpDirectionForewarder = new SfxStatusForwarder( SID_EXTRUSION_DIRECTION, *this );
 127 //      mpProjectionForewarder = new SfxStatusForwarder( SID_EXTRUSION_PROJECTION, *this );
 128
 129     mpMenu = new ToolbarMenu( this, WB_CLIPCHILDREN );
 130     mpMenu->SetHelpId( HID_MENU_EXTRUSION_DIRECTION );
 131     mpMenu->SetSelectHdl( LINK( this, ExtrusionDirectionWindow, SelectHdl ) );
 132     mpDirectionSet = new ValueSet( mpMenu, WB_TABSTOP | WB_MENUSTYLEVALUESET | WB_FLATVALUESET | WB_NOBORDER | WB_NO_DIRECTSELECT );
 133     mpDirectionSet->SetHelpId( HID_VALUESET_EXTRUSION_DIRECTION );
 134
 135     mpDirectionSet->SetHelpId( HID_POPUP_LINEEND_CTRL );
 136     mpDirectionSet->SetSelectHdl( LINK( this, ExtrusionDirectionWindow, SelectHdl ) );
 137     mpDirectionSet->SetColCount( 3 );
 138     mpDirectionSet->EnableFullItemMode( FALSE );
 139
 140     bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 141
 142     for( i = DIRECTION_NW; i <= DIRECTION_SE; i++ )
 143     {
 144         String aText( SVX_RES( STR_DIRECTION + i ) );
 145         mpDirectionSet->InsertItem( i+1, bHighContrast ? maImgDirectionH[ i ] : maImgDirection[ i ], aText );
 146     }
 147
 148     mpDirectionSet->SetOutputSizePixel( Size( 72, 72 ) );
 149
 150     mpMenu->appendEntry( 2, mpDirectionSet );
 151     mpMenu->appendSeparator();
 152     mpMenu->appendEntry( 0, String( SVX_RES( STR_PERSPECTIVE ) ), bHighContrast ? maImgPerspectiveH : maImgPerspective );
 153     mpMenu->appendEntry( 1, String( SVX_RES( STR_PARALLEL ) ), bHighContrast ? maImgParallelH : maImgParallel );
 154
 155     SetOutputSizePixel( mpMenu->getMenuSize() );
 156     mpMenu->SetOutputSizePixel( GetOutputSizePixel() );
 157
 158     mpMenu->Show();
 159
 160     FreeResource();
 161
 162     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionDirection" )));
 163     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionProjection" )));
 164 }
 165
 166 SfxPopupWindow* ExtrusionDirectionWindow::Clone() const
 167 {
 168     return new ExtrusionDirectionWindow( GetId(), mxFrame );
 169 }
 170
 171 void ExtrusionDirectionWindow::DataChanged( const DataChangedEvent& rDCEvt )
 172 {
 173     SfxPopupWindow::DataChanged( rDCEvt );
 174
 175     if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
 176     {
 177         bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 178
 179         USHORT i;
 180         for( i = DIRECTION_NW; i <= DIRECTION_SE; i++ )
 181         {
 182             mpDirectionSet->SetItemImage( i+1, bHighContrast ? maImgDirectionH[ i ] : maImgDirection[ i ] );
 183         }
 184
 185         mpMenu->setEntryImage( 0, bHighContrast ? maImgPerspectiveH : maImgPerspective );
 186         mpMenu->setEntryImage( 1, bHighContrast ? maImgParallelH : maImgParallel );
 187     }
 188 }
 189
 190 // -----------------------------------------------------------------------
 191
 192 ExtrusionDirectionWindow::~ExtrusionDirectionWindow()
 193 {
 194     delete mpMenu;
 195 }
 196
 197 // -----------------------------------------------------------------------
 198
 199 void ExtrusionDirectionWindow::implSetDirection( sal_Int32 nSkew, bool bEnabled )
 200 {
 201     if( mpDirectionSet )
 202     {
 203         USHORT nItemId;
 204         for( nItemId = DIRECTION_NW; nItemId <= DIRECTION_SE; nItemId++ )
 205         {
 206             if( gSkewList[nItemId] == nSkew )
 207                 break;
 208         }
 209
 210         if( nItemId <= DIRECTION_SE )
 211         {
 212             mpDirectionSet->SelectItem( nItemId+1 );
 213         }
 214         else
 215         {
 216             mpDirectionSet->SetNoSelection();
 217         }
 218     }
 219     if( mpMenu )
 220     {
 221         mpMenu->enableEntry( 2, bEnabled );
 222     }
 223 }
 224
 225 // -----------------------------------------------------------------------
 226
 227 void ExtrusionDirectionWindow::implSetProjection( sal_Int32 nProjection, bool bEnabled )
 228 {
 229     if( mpMenu )
 230     {
 231         mpMenu->checkEntry( 0, (nProjection == 0) && bEnabled );
 232         mpMenu->checkEntry( 1, (nProjection == 1 ) && bEnabled );
 233         mpMenu->enableEntry( 0, bEnabled );
 234         mpMenu->enableEntry( 1, bEnabled );
 235     }
 236 }
 237
 238 // -----------------------------------------------------------------------
 239
 240 void ExtrusionDirectionWindow::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
 241 {
 242     switch( nSID )
 243     {
 244         case SID_EXTRUSION_DIRECTION:
 245         {
 246             if( eState == SFX_ITEM_DISABLED )
 247             {
 248                 implSetDirection( -1, false );
 249             }
 250             else
 251             {
 252                 const SfxInt32Item* pStateItem = PTR_CAST( SfxInt32Item, pState );
 253                 if( pStateItem )
 254                     implSetDirection( pStateItem->GetValue(), true );
 255             }
 256             break;
 257         }
 258         case SID_EXTRUSION_PROJECTION:
 259         {
 260             if( eState == SFX_ITEM_DISABLED )
 261             {
 262                 implSetProjection( -1, false );
 263             }
 264             else
 265             {
 266                 const SfxInt32Item* pStateItem = PTR_CAST( SfxInt32Item, pState );
 267                 if( pStateItem )
 268                     implSetProjection( pStateItem->GetValue(), true );
 269             }
 270             break;
 271         }
 272     }
 273 }
 274
 275 // -----------------------------------------------------------------------
 276
 277 IMPL_LINK( ExtrusionDirectionWindow, SelectHdl, void *, pControl )
 278 {
 279     if ( IsInPopupMode() )
 280         EndPopupMode();
 281
 282 //      SfxDispatcher* pDisp = GetBindings().GetDispatcher();
 283
 284     if( pControl == mpDirectionSet )
 285     {
 286         sal_Int32 nSkew = gSkewList[mpDirectionSet->GetSelectItemId()-1];
 287
 288         SfxInt32Item    aItem( SID_EXTRUSION_DIRECTION, nSkew );
 289         rtl::OUString   aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionDirection" ));
 290
 291         Any a;
 292         INetURLObject aObj( aCommand );
 293         Sequence< PropertyValue > aArgs( 1 );
 294         aArgs[0].Name = aObj.GetURLPath();
 295         aItem.QueryValue( a );
 296         aArgs[0].Value = a;
 297
 298         SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
 299                                      mxFrame->getController(), UNO_QUERY ),
 300                                      aCommand,
 301                                      aArgs );
 302
 303 //              pDisp->Execute( SID_EXTRUSION_DIRECTION, SFX_CALLMODE_RECORD, &aItem, 0L , 0L );
 304     }
 305     else
 306     {
 307         int nProjection = mpMenu->getSelectedEntryId();
 308         if( (nProjection >= 0) && (nProjection < 2 ) )
 309         {
 310             SfxInt32Item    aItem( SID_EXTRUSION_PROJECTION, nProjection );
 311             rtl::OUString   aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionProjection" ));
 312
 313             Any a;
 314             INetURLObject aObj( aCommand );
 315             Sequence< PropertyValue > aArgs( 1 );
 316             aArgs[0].Name = aObj.GetURLPath();
 317             aItem.QueryValue( a );
 318             aArgs[0].Value = a;
 319
 320             SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
 321                                         mxFrame->getController(), UNO_QUERY ),
 322                                         aCommand,
 323                                         aArgs );
 324             implSetProjection( nProjection, true );
 325         }
 326     }
 327
 328     return 0;
 329 }
 330
 331 // -----------------------------------------------------------------------
 332
 333 void ExtrusionDirectionWindow::FillValueSet()
 334 {
 335 }
 336
 337 // -----------------------------------------------------------------------
 338
 339 void ExtrusionDirectionWindow::StartSelection()
 340 {
 341     mpDirectionSet->StartSelection();
 342 }
 343
 344 // -----------------------------------------------------------------------
 345
 346 BOOL ExtrusionDirectionWindow::Close()
 347 {
 348     return SfxPopupWindow::Close();
 349 }
 350
 351 // -----------------------------------------------------------------------
 352
 353 void ExtrusionDirectionWindow::PopupModeEnd()
 354 {
 355     if ( IsVisible() )
 356     {
 357         mbPopupMode = FALSE;
 358     }
 359     SfxPopupWindow::PopupModeEnd();
 360 }
 361
 362 // -----------------------------------------------------------------------
 363
 364 void ExtrusionDirectionWindow::GetFocus (void)
 365 {
 366     SfxPopupWindow::GetFocus();
 367     // Grab the focus to the line ends value set so that it can be controlled
 368     // with the keyboard.
 369     if( mpDirectionSet )
 370         mpDirectionSet->GrabFocus();
 371 }
 372
 373 /*************************************************************************
 374 |*
 375 |* SvxLineEndToolBoxControl
 376 |*
 377 \************************************************************************/
 378
 379 ExtrusionDirectionControl::ExtrusionDirectionControl(
 380     USHORT nSlotId, USHORT  nId, ToolBox &rTbx )
 381 : SfxToolBoxControl( nSlotId, nId, rTbx )
 382 {
 383     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
 384 }
 385
 386 // -----------------------------------------------------------------------
 387
 388 ExtrusionDirectionControl::~ExtrusionDirectionControl()
 389 {
 390 }
 391
 392 // -----------------------------------------------------------------------
 393
 394 SfxPopupWindowType ExtrusionDirectionControl::GetPopupWindowType() const
 395 {
 396     return SFX_POPUPWINDOW_ONCLICK;
 397 }
 398
 399 // -----------------------------------------------------------------------
 400
 401 SfxPopupWindow* ExtrusionDirectionControl::CreatePopupWindow()
 402 {
 403     ExtrusionDirectionWindow* pWin = new ExtrusionDirectionWindow( GetId(), m_xFrame, &GetToolBox() );
 404     pWin->StartPopupMode( &GetToolBox(), TRUE );
 405     pWin->StartSelection();
 406     SetPopupWindow( pWin );
 407     return pWin;
 408 }
 409
 410 // -----------------------------------------------------------------------
 411
 412 void ExtrusionDirectionControl::StateChanged( USHORT, SfxItemState eState, const SfxPoolItem* )
 413 {
 414     USHORT nId = GetId();
 415     ToolBox& rTbx = GetToolBox();
 416
 417     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
 418     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
 419 }
 420
 421 // ####################################################################
 422
 423 ExtrusionDepthDialog::ExtrusionDepthDialog( Window* pParent, double fDepth, FieldUnit eDefaultUnit )
 424 :       ModalDialog( pParent, SVX_RES( RID_SVX_MDLG_EXTRUSION_DEPTH ) ),
 425     maFLDepth( this, SVX_RES( FL_DEPTH ) ),
 426     maMtrDepth( this, SVX_RES( MTR_DEPTH ) ),
 427     maOKButton( this, SVX_RES( BTN_OK ) ),
 428     maCancelButton( this, SVX_RES( BTN_CANCEL ) ),
 429     maHelpButton( this, SVX_RES( BTN_HELP ) )
 430 {
 431     bool bMetric = IsMetric( eDefaultUnit );
 432     maMtrDepth.SetUnit( bMetric ? FUNIT_CM : FUNIT_INCH );
 433     maMtrDepth.SetValue( (int) fDepth * 100, FUNIT_100TH_MM );
 434
 435     FreeResource();
 436 }
 437
 438 ExtrusionDepthDialog::~ExtrusionDepthDialog()
 439 {
 440 }
 441
 442 double ExtrusionDepthDialog::getDepth() const
 443 {
 444 //      bool bMetric = IsMetric( meDefaultUnit );
 445     return (double)( maMtrDepth.GetValue( FUNIT_100TH_MM ) ) / 100.0;
 446 }
 447
 448 // ####################################################################
 449
 450 SFX_IMPL_TOOLBOX_CONTROL( ExtrusionDepthControl, SfxBoolItem );
 451
 452 ExtrusionDepthWindow::ExtrusionDepthWindow(
 453     USHORT nId,
 454     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) :
 455     SfxPopupWindow( nId,
 456                     rFrame,
 457                     SVX_RES( RID_SVXFLOAT_EXTRUSION_DEPTH )),
 458     maImgDepth0( SVX_RES( IMG_DEPTH_0 ) ),
 459     maImgDepth1( SVX_RES( IMG_DEPTH_1 ) ),
 460     maImgDepth2( SVX_RES( IMG_DEPTH_2 ) ),
 461     maImgDepth3( SVX_RES( IMG_DEPTH_3 ) ),
 462     maImgDepth4( SVX_RES( IMG_DEPTH_4 ) ),
 463     maImgDepthInfinity( SVX_RES( IMG_DEPTH_INFINITY ) ),
 464     maImgDepth0h( SVX_RES( IMG_DEPTH_0_H ) ),
 465     maImgDepth1h( SVX_RES( IMG_DEPTH_1_H ) ),
 466     maImgDepth2h( SVX_RES( IMG_DEPTH_2_H ) ),
 467     maImgDepth3h( SVX_RES( IMG_DEPTH_3_H ) ),
 468     maImgDepth4h( SVX_RES( IMG_DEPTH_4_H ) ),
 469     maImgDepthInfinityh( SVX_RES( IMG_DEPTH_INFINITY_H ) ),
 470     mxFrame( rFrame ),
 471     mbPopupMode         ( true ),
 472     mfDepth( -1.0 ),
 473     mbEnabled( false )
 474 {
 475     implInit();
 476 }
 477
 478 ExtrusionDepthWindow::ExtrusionDepthWindow(     USHORT nId,
 479     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
 480     Window* pParentWindow ) :
 481     SfxPopupWindow( nId,
 482                     rFrame,
 483                     pParentWindow,
 484                     SVX_RES( RID_SVXFLOAT_EXTRUSION_DEPTH )),
 485     maImgDepth0( SVX_RES( IMG_DEPTH_0 ) ),
 486     maImgDepth1( SVX_RES( IMG_DEPTH_1 ) ),
 487     maImgDepth2( SVX_RES( IMG_DEPTH_2 ) ),
 488     maImgDepth3( SVX_RES( IMG_DEPTH_3 ) ),
 489     maImgDepth4( SVX_RES( IMG_DEPTH_4 ) ),
 490     maImgDepthInfinity( SVX_RES( IMG_DEPTH_INFINITY ) ),
 491     maImgDepth0h( SVX_RES( IMG_DEPTH_0_H ) ),
 492     maImgDepth1h( SVX_RES( IMG_DEPTH_1_H ) ),
 493     maImgDepth2h( SVX_RES( IMG_DEPTH_2_H ) ),
 494     maImgDepth3h( SVX_RES( IMG_DEPTH_3_H ) ),
 495     maImgDepth4h( SVX_RES( IMG_DEPTH_4_H ) ),
 496     maImgDepthInfinityh( SVX_RES( IMG_DEPTH_INFINITY_H ) ),
 497     mxFrame( rFrame ),
 498     mbPopupMode         ( true ),
 499     mfDepth( -1.0 ),
 500     mbEnabled( false )
 501 {
 502     implInit();
 503 }
 504
 505 void ExtrusionDepthWindow::implInit()
 506 {
 507     SetHelpId( HID_POPUP_EXTRUSION_DEPTH );
 508
 509 //      mpDepthForewarder = new SfxStatusForwarder( SID_EXTRUSION_DEPTH, *this );
 510 //      mpMetricForewarder = new SfxStatusForwarder( SID_ATTR_METRIC, *this );
 511
 512     mpMenu = new ToolbarMenu( this, WB_CLIPCHILDREN );
 513     mpMenu->SetHelpId( HID_MENU_EXTRUSION_DEPTH );
 514
 515     mpMenu->SetSelectHdl( LINK( this, ExtrusionDepthWindow, SelectHdl ) );
 516
 517     bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 518
 519     String aEmpty;
 520     mpMenu->appendEntry( 0, aEmpty, bHighContrast ? maImgDepth0h : maImgDepth0 );
 521     mpMenu->appendEntry( 1, aEmpty, bHighContrast ? maImgDepth1h : maImgDepth1 );
 522     mpMenu->appendEntry( 2, aEmpty, bHighContrast ? maImgDepth2h : maImgDepth2 );
 523     mpMenu->appendEntry( 3, aEmpty, bHighContrast ? maImgDepth3h : maImgDepth3 );
 524     mpMenu->appendEntry( 4, aEmpty, bHighContrast ? maImgDepth4h : maImgDepth4 );
 525     mpMenu->appendEntry( 5, String( SVX_RES( STR_INFINITY ) ), bHighContrast ? maImgDepthInfinityh : maImgDepthInfinity );
 526     mpMenu->appendEntry( 6, String( SVX_RES( STR_CUSTOM ) ) );
 527
 528     SetOutputSizePixel( mpMenu->getMenuSize() );
 529     mpMenu->SetOutputSizePixel( GetOutputSizePixel() );
 530
 531     mpMenu->Show();
 532
 533     FreeResource();
 534
 535     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionDepth" )));
 536     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:MetricUnit" )));
 537 //      rBindings.Update( SID_ATTR_METRIC );
 538 //      rBindings.Update( SID_EXTRUSION_DEPTH );
 539 }
 540
 541 SfxPopupWindow* ExtrusionDepthWindow::Clone() const
 542 {
 543     return new ExtrusionDepthWindow( GetId(), mxFrame );
 544 }
 545
 546 // -----------------------------------------------------------------------
 547
 548 ExtrusionDepthWindow::~ExtrusionDepthWindow()
 549 {
 550 //      delete mpDepthForewarder;
 551 //      delete mpMetricForewarder;
 552
 553     delete mpMenu;
 554 }
 555
 556 // -----------------------------------------------------------------------
 557
 558 double aDepthListInch[] = { 0, 1270,2540,5080,10160 };
 559 double aDepthListMM[] = { 0, 1000, 2500, 5000, 10000 };
 560
 561 void ExtrusionDepthWindow::implSetDepth( double fDepth, bool bEnabled )
 562 {
 563     mbEnabled = bEnabled;
 564     mfDepth = fDepth;
 565     if( mpMenu )
 566     {
 567         int i;
 568         for( i = 0; i < 7; i++ )
 569         {
 570             if( i == 5 )
 571             {
 572                 mpMenu->checkEntry( i, (fDepth >= 338666) && bEnabled );
 573             }
 574             else if( i != 6 )
 575             {
 576                 mpMenu->checkEntry( i, (fDepth == (IsMetric( meUnit ) ? aDepthListMM[i] : aDepthListInch[i]) && bEnabled ) );
 577             }
 578             mpMenu->enableEntry( i, bEnabled );
 579         }
 580     }
 581 }
 582
 583 // -----------------------------------------------------------------------
 584
 585 void ExtrusionDepthWindow::implFillStrings( FieldUnit eUnit )
 586 {
 587     meUnit = eUnit;
 588     USHORT nResource = IsMetric( eUnit ) ? RID_SVXSTR_DEPTH_0 : RID_SVXSTR_DEPTH_0_INCH;
 589
 590     for( int i = 0; i < 5; i++ )
 591     {
 592         String aStr( SVX_RES( nResource + i ) );
 593         mpMenu->setEntryText( i, aStr );
 594     };
 595 }
 596
 597 // -----------------------------------------------------------------------
 598
 599 void ExtrusionDepthWindow::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
 600 {
 601     switch( nSID )
 602     {
 603         case SID_EXTRUSION_DEPTH:
 604         {
 605             if( eState == SFX_ITEM_DISABLED )
 606             {
 607                 implSetDepth( 0, false );
 608             }
 609             else
 610             {
 611                 const SvxDoubleItem* pStateItem = PTR_CAST( SvxDoubleItem, pState );
 612                 if( pStateItem )
 613                     implSetDepth( pStateItem->GetValue(), true );
 614             }
 615             break;
 616         }
 617         case SID_ATTR_METRIC:
 618         {
 619             const SfxUInt16Item* pStateItem = PTR_CAST( SfxUInt16Item, pState );
 620             if( pStateItem )
 621             {
 622                 implFillStrings( (FieldUnit)pStateItem->GetValue() );
 623                 if( mfDepth >= 0.0 )
 624                     implSetDepth( mfDepth, mbEnabled );
 625             }
 626         }
 627     }
 628 }
 629
 630 // -----------------------------------------------------------------------
 631
 632 void ExtrusionDepthWindow::DataChanged( const DataChangedEvent& rDCEvt )
 633 {
 634     SfxPopupWindow::DataChanged( rDCEvt );
 635
 636     if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
 637     {
 638         bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 639
 640         mpMenu->setEntryImage( 0, bHighContrast ? maImgDepth0h : maImgDepth0 );
 641         mpMenu->setEntryImage( 1, bHighContrast ? maImgDepth1h : maImgDepth1 );
 642         mpMenu->setEntryImage( 2, bHighContrast ? maImgDepth2h : maImgDepth2 );
 643         mpMenu->setEntryImage( 3, bHighContrast ? maImgDepth3h : maImgDepth3 );
 644         mpMenu->setEntryImage( 4, bHighContrast ? maImgDepth4h : maImgDepth4 );
 645         mpMenu->setEntryImage( 5, bHighContrast ? maImgDepthInfinityh : maImgDepthInfinity );
 646     }
 647 }
 648
 649
 650 // -----------------------------------------------------------------------
 651
 652 IMPL_LINK( ExtrusionDepthWindow, SelectHdl, void *, EMPTYARG )
 653 {
 654 //      SfxDispatcher* pDisp = GetBindings().GetDispatcher();
 655
 656     int nSelected = mpMenu->getSelectedEntryId();
 657     if( nSelected != -1 )
 658     {
 659         if( nSelected == 6 )
 660         {
 661             if ( IsInPopupMode() )
 662                 EndPopupMode();
 663
 664             SvxDoubleItem aDepthItem( mfDepth, SID_EXTRUSION_DEPTH );
 665             SfxUInt16Item aMetricItem(
 666                 SID_ATTR_METRIC, sal::static_int_cast< UINT16 >( meUnit ) );
 667             rtl::OUString aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionDepthDialog" ));
 668
 669             Any a;
 670             Sequence< PropertyValue > aArgs( 2 );
 671             aArgs[0].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Depth" ));
 672             aDepthItem.QueryValue( a );
 673             aArgs[0].Value = a;
 674             aArgs[1].Name = rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Metric" ));
 675             aMetricItem.QueryValue( a );
 676             aArgs[1].Value = a;
 677
 678             SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
 679                                          mxFrame->getController(), UNO_QUERY ),
 680                                          aCommand,
 681                                          aArgs );
 682         }
 683         else
 684         {
 685             double fDepth;
 686
 687             if( nSelected == 5 )
 688             {
 689                 fDepth = 338666.6;
 690             }
 691             else
 692             {
 693                 fDepth = IsMetric( meUnit ) ? aDepthListMM[nSelected] : aDepthListInch[nSelected];
 694             }
 695
 696             SvxDoubleItem aItem( fDepth, SID_EXTRUSION_DEPTH );
 697             rtl::OUString aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionDepth" ));
 698
 699             Any a;
 700             INetURLObject aObj( aCommand );
 701             Sequence< PropertyValue > aArgs( 1 );
 702             aArgs[0].Name = aObj.GetURLPath();
 703             aItem.QueryValue( a );
 704             aArgs[0].Value = a;
 705
 706             SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
 707                                          mxFrame->getController(), UNO_QUERY ),
 708                                          aCommand,
 709                                          aArgs );
 710             implSetDepth( fDepth, true );
 711
 712             if ( IsInPopupMode() )
 713                 EndPopupMode();
 714         }
 715     }
 716     return 0;
 717 }
 718
 719 // -----------------------------------------------------------------------
 720
 721 void ExtrusionDepthWindow::StartSelection()
 722 {
 723 }
 724
 725 // -----------------------------------------------------------------------
 726
 727 BOOL ExtrusionDepthWindow::Close()
 728 {
 729     return SfxPopupWindow::Close();
 730 }
 731
 732 // -----------------------------------------------------------------------
 733
 734 void ExtrusionDepthWindow::PopupModeEnd()
 735 {
 736     if ( IsVisible() )
 737     {
 738         mbPopupMode = FALSE;
 739     }
 740     SfxPopupWindow::PopupModeEnd();
 741 }
 742
 743 // -----------------------------------------------------------------------
 744
 745 void ExtrusionDepthWindow::GetFocus (void)
 746 {
 747     SfxPopupWindow::GetFocus();
 748     // Grab the focus to the line ends value set so that it can be controlled
 749     // with the keyboard.
 750     if( mpMenu )
 751         mpMenu->GrabFocus();
 752 }
 753
 754 // ========================================================================
 755
 756 ExtrusionDepthControl::ExtrusionDepthControl(
 757     USHORT nSlotId, USHORT nId, ToolBox &rTbx )
 758 : SfxToolBoxControl( nSlotId, nId, rTbx )
 759 {
 760     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
 761 }
 762
 763 // -----------------------------------------------------------------------
 764
 765 ExtrusionDepthControl::~ExtrusionDepthControl()
 766 {
 767 }
 768
 769 // -----------------------------------------------------------------------
 770
 771 SfxPopupWindowType ExtrusionDepthControl::GetPopupWindowType() const
 772 {
 773     return SFX_POPUPWINDOW_ONCLICK;
 774 }
 775
 776 // -----------------------------------------------------------------------
 777
 778 SfxPopupWindow* ExtrusionDepthControl::CreatePopupWindow()
 779 {
 780     ExtrusionDepthWindow* pWin = new ExtrusionDepthWindow( GetId(), m_xFrame, &GetToolBox() );
 781     pWin->StartPopupMode( &GetToolBox(), TRUE );
 782     pWin->StartSelection();
 783     SetPopupWindow( pWin );
 784     return pWin;
 785 }
 786
 787 // -----------------------------------------------------------------------
 788
 789 void ExtrusionDepthControl::StateChanged( USHORT, SfxItemState eState, const SfxPoolItem* )
 790 {
 791     USHORT nId = GetId();
 792     ToolBox& rTbx = GetToolBox();
 793
 794     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
 795     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
 796 }
 797
 798 // ####################################################################
 799
 800 SFX_IMPL_TOOLBOX_CONTROL( ExtrusionLightingControl, SfxBoolItem );
 801
 802 ExtrusionLightingWindow::ExtrusionLightingWindow(
 803     USHORT nId,
 804     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) :
 805     SfxPopupWindow( nId,
 806                     rFrame,
 807                     SVX_RES( RID_SVXFLOAT_EXTRUSION_LIGHTING ) ),
 808     maImgBright( SVX_RES( IMG_LIGHTING_BRIGHT ) ),
 809     maImgNormal( SVX_RES( IMG_LIGHTING_NORMAL ) ),
 810     maImgDim( SVX_RES( IMG_LIGHTING_DIM ) ),
 811     maImgBrighth( SVX_RES( IMG_LIGHTING_BRIGHT_H ) ),
 812     maImgNormalh( SVX_RES( IMG_LIGHTING_NORMAL_H ) ),
 813     maImgDimh( SVX_RES( IMG_LIGHTING_DIM_H ) ),
 814     mxFrame( rFrame ),
 815     mbPopupMode( true ),
 816     mnLevel( 0 ),
 817     mbLevelEnabled( false ),
 818     mnDirection( FROM_FRONT ),
 819     mbDirectionEnabled( false )
 820 {
 821     implInit();
 822 }
 823
 824 // -----------------------------------------------------------------------
 825
 826 ExtrusionLightingWindow::ExtrusionLightingWindow(
 827     USHORT nId,
 828     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
 829     Window* pParentWindow ) :
 830     SfxPopupWindow( nId,
 831                     rFrame,
 832                     pParentWindow,
 833                     SVX_RES( RID_SVXFLOAT_EXTRUSION_LIGHTING ) ),
 834     maImgBright( SVX_RES( IMG_LIGHTING_BRIGHT ) ),
 835     maImgNormal( SVX_RES( IMG_LIGHTING_NORMAL ) ),
 836     maImgDim( SVX_RES( IMG_LIGHTING_DIM ) ),
 837     maImgBrighth( SVX_RES( IMG_LIGHTING_BRIGHT_H ) ),
 838     maImgNormalh( SVX_RES( IMG_LIGHTING_NORMAL_H ) ),
 839     maImgDimh( SVX_RES( IMG_LIGHTING_DIM_H ) ),
 840     mxFrame( rFrame ),
 841     mbPopupMode( true ),
 842     mnLevel( 0 ),
 843     mbLevelEnabled( false ),
 844     mnDirection( FROM_FRONT ),
 845     mbDirectionEnabled( false )
 846 {
 847     implInit();
 848 }
 849
 850 // -----------------------------------------------------------------------
 851
 852 void ExtrusionLightingWindow::implInit()
 853 {
 854     SetHelpId( HID_POPUP_EXTRUSION_LIGHTING );
 855
 856     USHORT i;
 857     for( i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; i++ )
 858     {
 859         if( i != FROM_FRONT )
 860         {
 861             maImgLightingOff[i] = Image( SVX_RES( IMG_LIGHT_OFF + i ) );
 862             maImgLightingOn[i] = Image( SVX_RES( IMG_LIGHT_ON + i ) );
 863             maImgLightingOffh[i] = Image( SVX_RES( IMG_LIGHT_OFF_H + i ) );
 864             maImgLightingOnh[i] = Image( SVX_RES( IMG_LIGHT_ON_H + i ) );
 865         }
 866         maImgLightingPreview[i] = Image( SVX_RES( IMG_LIGHT_PREVIEW + i ) );
 867         maImgLightingPreviewh[i] = Image( SVX_RES( IMG_LIGHT_PREVIEW_H + i ) );
 868     }
 869
 870 //      mpLightingDirectionForewarder = new SfxStatusForwarder( SID_EXTRUSION_LIGHTING_DIRECTION, *this );
 871 //      mpLightingIntensityForewarder = new SfxStatusForwarder( SID_EXTRUSION_LIGHTING_INTENSITY, *this );
 872
 873     mpMenu = new ToolbarMenu( this, WB_CLIPCHILDREN );
 874     mpMenu->SetHelpId( HID_MENU_EXTRUSION_LIGHTING );
 875     mpMenu->SetSelectHdl( LINK( this, ExtrusionLightingWindow, SelectHdl ) );
 876
 877     mpLightingSet = new ValueSet( mpMenu, WB_TABSTOP | WB_MENUSTYLEVALUESET | WB_FLATVALUESET | WB_NOBORDER | WB_NO_DIRECTSELECT );
 878     mpLightingSet->SetHelpId( HID_VALUESET_EXTRUSION_LIGHTING );
 879
 880     mpLightingSet->SetHelpId( HID_POPUP_LINEEND_CTRL );
 881     mpLightingSet->SetSelectHdl( LINK( this, ExtrusionLightingWindow, SelectHdl ) );
 882     mpLightingSet->SetColCount( 3 );
 883     mpLightingSet->EnableFullItemMode( FALSE );
 884
 885     bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 886
 887     for( i = FROM_TOP_LEFT; i <= FROM_BOTTOM_RIGHT; i++ )
 888     {
 889         if( i != FROM_FRONT )
 890         {
 891             mpLightingSet->InsertItem( i+1, bHighContrast ? maImgLightingOffh[i] : maImgLightingOff[i] );
 892         }
 893         else
 894         {
 895             mpLightingSet->InsertItem( 5, bHighContrast ? maImgLightingPreviewh[FROM_FRONT] : maImgLightingPreview[FROM_FRONT] );
 896         }
 897     }
 898     mpLightingSet->SetOutputSizePixel( Size( 72, 72 ) );
 899
 900     mpMenu->appendEntry( 3, mpLightingSet );
 901     mpMenu->appendSeparator();
 902     mpMenu->appendEntry( 0, String( SVX_RES( STR_BRIGHT ) ), bHighContrast ? maImgBrighth : maImgBright );
 903     mpMenu->appendEntry( 1, String( SVX_RES( STR_NORMAL ) ), bHighContrast ? maImgNormalh : maImgNormal );
 904     mpMenu->appendEntry( 2, String( SVX_RES( STR_DIM ) ), bHighContrast ? maImgDimh : maImgDim );
 905
 906     SetOutputSizePixel( mpMenu->getMenuSize() );
 907     mpMenu->SetOutputSizePixel( GetOutputSizePixel() );
 908
 909     mpMenu->Show();
 910
 911     FreeResource();
 912
 913     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionLightingDirection" )));
 914     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionLightingIntensity" )));
 915 }
 916
 917 // -----------------------------------------------------------------------
 918
 919 SfxPopupWindow* ExtrusionLightingWindow::Clone() const
 920 {
 921     return new ExtrusionLightingWindow( GetId(), mxFrame );
 922 }
 923
 924 // -----------------------------------------------------------------------
 925
 926 ExtrusionLightingWindow::~ExtrusionLightingWindow()
 927 {
 928     delete mpMenu;
 929 }
 930
 931 // -----------------------------------------------------------------------
 932
 933 void ExtrusionLightingWindow::implSetIntensity( int nLevel, bool bEnabled )
 934 {
 935     mnLevel = nLevel;
 936     mbLevelEnabled = bEnabled;
 937     int i = 0;
 938     for( i = 0; i < 3; i++ )
 939     {
 940         mpMenu->checkEntry( i, (i == nLevel) && bEnabled );
 941         mpMenu->enableEntry( i, bEnabled );
 942     }
 943 }
 944
 945 // -----------------------------------------------------------------------
 946
 947 void ExtrusionLightingWindow::implSetDirection( int nDirection, bool bEnabled )
 948 {
 949     mnDirection = nDirection;
 950     mbDirectionEnabled = bEnabled;
 951
 952     bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
 953
 954     if( !bEnabled )
 955         nDirection = FROM_FRONT;
 956
 957     USHORT nItemId;
 958     for( nItemId = FROM_TOP_LEFT; nItemId <= FROM_BOTTOM_RIGHT; nItemId++ )
 959     {
 960         if( nItemId == FROM_FRONT )
 961         {
 962             mpLightingSet->SetItemImage( nItemId + 1, bHighContrast ? maImgLightingPreviewh[ nDirection ] : maImgLightingPreview[ nDirection ] );
 963         }
 964         else
 965         {
 966             if( bHighContrast )
 967             {
 968                 mpLightingSet->SetItemImage( nItemId + 1, (USHORT)nDirection == nItemId ? maImgLightingOnh[nItemId] : maImgLightingOffh[nItemId] );
 969             }
 970             else
 971             {
 972                 mpLightingSet->SetItemImage( nItemId + 1, (USHORT)nDirection == nItemId ? maImgLightingOn[nItemId] : maImgLightingOff[nItemId] );
 973             }
 974         }
 975     }
 976
 977     mpMenu->enableEntry( 3, bEnabled );
 978 }
 979
 980 // -----------------------------------------------------------------------
 981
 982 void ExtrusionLightingWindow::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
 983 {
 984     switch( nSID )
 985     {
 986         case SID_EXTRUSION_LIGHTING_INTENSITY:
 987         {
 988             if( eState == SFX_ITEM_DISABLED )
 989             {
 990                 implSetIntensity( 0, false );
 991             }
 992             else
 993             {
 994                 const SfxInt32Item* pStateItem = PTR_CAST( SfxInt32Item, pState );
 995                 if( pStateItem )
 996                     implSetIntensity( pStateItem->GetValue(), true );
 997             }
 998             break;
 999         }
1000         case SID_EXTRUSION_LIGHTING_DIRECTION:
1001         {
1002             if( eState == SFX_ITEM_DISABLED )
1003             {
1004                 implSetDirection( 0, false );
1005             }
1006             else
1007             {
1008                 const SfxInt32Item* pStateItem = PTR_CAST( SfxInt32Item, pState );
1009                 if( pStateItem )
1010                     implSetDirection( pStateItem->GetValue(), true );
1011             }
1012             break;
1013         }
1014     }
1015 }
1016
1017 // -----------------------------------------------------------------------
1018
1019 void ExtrusionLightingWindow::DataChanged( const DataChangedEvent& rDCEvt )
1020 {
1021     SfxPopupWindow::DataChanged( rDCEvt );
1022
1023     if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
1024     {
1025         bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
1026
1027         implSetDirection( mnDirection, mbDirectionEnabled );
1028         mpMenu->setEntryImage( 0, bHighContrast ? maImgBrighth : maImgBright );
1029         mpMenu->setEntryImage( 1, bHighContrast ? maImgNormalh : maImgNormal );
1030         mpMenu->setEntryImage( 2, bHighContrast ? maImgDimh : maImgDim );
1031     }
1032 }
1033
1034 // -----------------------------------------------------------------------
1035
1036 IMPL_LINK( ExtrusionLightingWindow, SelectHdl, void *, pControl )
1037 {
1038     if ( IsInPopupMode() )
1039         EndPopupMode();
1040
1041 //      SfxDispatcher* pDisp = GetBindings().GetDispatcher();
1042
1043     if( pControl == mpMenu )
1044     {
1045         int nLevel = mpMenu->getSelectedEntryId();
1046         if( nLevel >= 0 )
1047         {
1048             if( nLevel != 3 )
1049             {
1050                 SfxInt32Item    aItem( SID_EXTRUSION_LIGHTING_INTENSITY, nLevel );
1051                 rtl::OUString   aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionLightingIntensity" ));
1052
1053                 Any a;
1054                 INetURLObject aObj( aCommand );
1055                 Sequence< PropertyValue > aArgs( 1 );
1056                 aArgs[0].Name = aObj.GetURLPath();
1057                 aItem.QueryValue( a );
1058                 aArgs[0].Value = a;
1059
1060                 SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
1061                                              mxFrame->getController(), UNO_QUERY ),
1062                                              aCommand,
1063                                              aArgs );
1064
1065 //                              pDisp->Execute( SID_EXTRUSION_LIGHTING_INTENSITY, SFX_CALLMODE_RECORD, &aItem, 0L , 0L );
1066                 implSetIntensity( nLevel, true );
1067             }
1068         }
1069     }
1070     else
1071     {
1072         sal_Int32 nDirection = mpLightingSet->GetSelectItemId();
1073
1074         if( (nDirection > 0) && (nDirection < 10) )
1075         {
1076             nDirection--;
1077
1078             SfxInt32Item    aItem( SID_EXTRUSION_LIGHTING_DIRECTION, nDirection );
1079             rtl::OUString   aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionLightingDirection" ));
1080
1081             Any a;
1082             INetURLObject aObj( aCommand );
1083             Sequence< PropertyValue > aArgs( 1 );
1084             aArgs[0].Name = aObj.GetURLPath();
1085             aItem.QueryValue( a );
1086             aArgs[0].Value = a;
1087
1088             SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
1089                                          mxFrame->getController(), UNO_QUERY ),
1090                                          aCommand,
1091                                          aArgs );
1092 //                      pDisp->Execute( SID_EXTRUSION_LIGHTING_DIRECTION, SFX_CALLMODE_RECORD, &aItem, 0L , 0L );
1093
1094             implSetDirection( nDirection, true );
1095         }
1096
1097     }
1098
1099     return 0;
1100 }
1101
1102 // -----------------------------------------------------------------------
1103
1104 void ExtrusionLightingWindow::StartSelection()
1105 {
1106 }
1107
1108 // -----------------------------------------------------------------------
1109
1110 BOOL ExtrusionLightingWindow::Close()
1111 {
1112     return SfxPopupWindow::Close();
1113 }
1114
1115 // -----------------------------------------------------------------------
1116
1117 void ExtrusionLightingWindow::PopupModeEnd()
1118 {
1119     if ( IsVisible() )
1120     {
1121         mbPopupMode = FALSE;
1122     }
1123     SfxPopupWindow::PopupModeEnd();
1124 }
1125
1126 // -----------------------------------------------------------------------
1127
1128 void ExtrusionLightingWindow::GetFocus (void)
1129 {
1130     SfxPopupWindow::GetFocus();
1131     // Grab the focus to the line ends value set so that it can be controlled
1132     // with the keyboard.
1133     if( mpMenu )
1134         mpMenu->GrabFocus();
1135 }
1136
1137 // ========================================================================
1138
1139 ExtrusionLightingControl::ExtrusionLightingControl(     USHORT nSlotId, USHORT nId, ToolBox &rTbx )
1140 : SfxToolBoxControl( nSlotId, nId, rTbx )
1141 {
1142     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
1143 }
1144
1145 // -----------------------------------------------------------------------
1146
1147 ExtrusionLightingControl::~ExtrusionLightingControl()
1148 {
1149 }
1150
1151 // -----------------------------------------------------------------------
1152
1153 SfxPopupWindowType ExtrusionLightingControl::GetPopupWindowType() const
1154 {
1155     return SFX_POPUPWINDOW_ONCLICK;
1156 }
1157
1158 // -----------------------------------------------------------------------
1159
1160 SfxPopupWindow* ExtrusionLightingControl::CreatePopupWindow()
1161 {
1162     ExtrusionLightingWindow* pWin = new ExtrusionLightingWindow( GetId(), m_xFrame, &GetToolBox() );
1163     pWin->StartPopupMode( &GetToolBox(), TRUE );
1164     pWin->StartSelection();
1165     SetPopupWindow( pWin );
1166     return pWin;
1167 }
1168
1169 // -----------------------------------------------------------------------
1170
1171 void ExtrusionLightingControl::StateChanged( USHORT, SfxItemState eState, const SfxPoolItem* )
1172 {
1173     USHORT nId = GetId();
1174     ToolBox& rTbx = GetToolBox();
1175
1176     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
1177     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
1178 }
1179
1180 // ####################################################################
1181
1182 SFX_IMPL_TOOLBOX_CONTROL( ExtrusionSurfaceControl, SfxBoolItem );
1183
1184 ExtrusionSurfaceWindow::ExtrusionSurfaceWindow(
1185     USHORT nId,
1186     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame ) :
1187
1188     SfxPopupWindow( nId,
1189                     rFrame,
1190                     SVX_RES( RID_SVXFLOAT_EXTRUSION_SURFACE )),
1191     maImgSurface1( SVX_RES( IMG_WIRE_FRAME ) ),
1192     maImgSurface2( SVX_RES( IMG_MATTE ) ),
1193     maImgSurface3( SVX_RES( IMG_PLASTIC ) ),
1194     maImgSurface4( SVX_RES( IMG_METAL ) ),
1195     maImgSurface1h( SVX_RES( IMG_WIRE_FRAME_H ) ),
1196     maImgSurface2h( SVX_RES( IMG_MATTE_H ) ),
1197     maImgSurface3h( SVX_RES( IMG_PLASTIC_H ) ),
1198     maImgSurface4h( SVX_RES( IMG_METAL_H ) ),
1199     mxFrame( rFrame ),
1200     mbPopupMode( true )
1201 {
1202     implInit();
1203 }
1204
1205 ExtrusionSurfaceWindow::ExtrusionSurfaceWindow(
1206     USHORT nId,
1207     const ::com::sun::star::uno::Reference< ::com::sun::star::frame::XFrame >& rFrame,
1208     Window* pParentWindow ) :
1209
1210     SfxPopupWindow( nId,
1211                     rFrame,
1212                     pParentWindow,
1213                     SVX_RES( RID_SVXFLOAT_EXTRUSION_SURFACE )),
1214     maImgSurface1( SVX_RES( IMG_WIRE_FRAME ) ),
1215     maImgSurface2( SVX_RES( IMG_MATTE ) ),
1216     maImgSurface3( SVX_RES( IMG_PLASTIC ) ),
1217     maImgSurface4( SVX_RES( IMG_METAL ) ),
1218     maImgSurface1h( SVX_RES( IMG_WIRE_FRAME_H ) ),
1219     maImgSurface2h( SVX_RES( IMG_MATTE_H ) ),
1220     maImgSurface3h( SVX_RES( IMG_PLASTIC_H ) ),
1221     maImgSurface4h( SVX_RES( IMG_METAL_H ) ),
1222     mxFrame( rFrame ),
1223     mbPopupMode( true )
1224 {
1225     implInit();
1226 }
1227
1228 // -----------------------------------------------------------------------
1229
1230 void ExtrusionSurfaceWindow::implInit()
1231 {
1232     SetHelpId( HID_POPUP_EXTRUSION_SURFACE );
1233
1234     bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
1235
1236 //      mpSurfaceForewarder = new SfxStatusForwarder( SID_EXTRUSION_SURFACE, *this );
1237
1238     mpMenu = new ToolbarMenu( this, WB_CLIPCHILDREN );
1239     mpMenu->SetHelpId( HID_MENU_EXTRUSION_SURFACE );
1240     mpMenu->SetSelectHdl( LINK( this, ExtrusionSurfaceWindow, SelectHdl ) );
1241
1242     mpMenu->appendEntry( 0, String( SVX_RES( STR_WIREFRAME ) ), bHighContrast ? maImgSurface1h : maImgSurface1 );
1243     mpMenu->appendEntry( 1, String( SVX_RES( STR_MATTE ) ), bHighContrast ? maImgSurface2h : maImgSurface2 );
1244     mpMenu->appendEntry( 2, String( SVX_RES( STR_PLASTIC ) ), bHighContrast ? maImgSurface3h : maImgSurface3 );
1245     mpMenu->appendEntry( 3, String( SVX_RES( STR_METAL ) ), bHighContrast ? maImgSurface4h : maImgSurface4 );
1246
1247     SetOutputSizePixel( mpMenu->getMenuSize() );
1248     mpMenu->SetOutputSizePixel( GetOutputSizePixel() );
1249
1250     mpMenu->Show();
1251
1252     FreeResource();
1253
1254     AddStatusListener( rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionSurface" )));
1255 //      rBindings.Update( SID_EXTRUSION_SURFACE );
1256 }
1257
1258 // -----------------------------------------------------------------------
1259
1260 SfxPopupWindow* ExtrusionSurfaceWindow::Clone() const
1261 {
1262     return new ExtrusionSurfaceWindow( GetId(), mxFrame );
1263 }
1264
1265 // -----------------------------------------------------------------------
1266
1267 ExtrusionSurfaceWindow::~ExtrusionSurfaceWindow()
1268 {
1269 //      delete mpSurfaceForewarder;
1270     delete mpMenu;
1271 }
1272
1273 // -----------------------------------------------------------------------
1274
1275 void ExtrusionSurfaceWindow::implSetSurface( int nSurface, bool bEnabled )
1276 {
1277     if( mpMenu )
1278     {
1279         int i;
1280         for( i = 0; i < 4; i++ )
1281         {
1282             mpMenu->checkEntry( i, (i == nSurface) && bEnabled );
1283             mpMenu->enableEntry( i, bEnabled );
1284         }
1285     }
1286 }
1287
1288 // -----------------------------------------------------------------------
1289
1290 void ExtrusionSurfaceWindow::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
1291 {
1292     switch( nSID )
1293     {
1294         case SID_EXTRUSION_SURFACE:
1295         {
1296             if( eState == SFX_ITEM_DISABLED )
1297             {
1298                 implSetSurface( 0, false );
1299             }
1300             else
1301             {
1302                 const SfxInt32Item* pStateItem = PTR_CAST( SfxInt32Item, pState );
1303                 if( pStateItem )
1304                     implSetSurface( pStateItem->GetValue(), true );
1305             }
1306             break;
1307         }
1308     }
1309 }
1310
1311 // -----------------------------------------------------------------------
1312
1313 void ExtrusionSurfaceWindow::DataChanged( const DataChangedEvent& rDCEvt )
1314 {
1315     SfxPopupWindow::DataChanged( rDCEvt );
1316
1317     if( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) && ( rDCEvt.GetFlags() & SETTINGS_STYLE ) )
1318     {
1319         bool bHighContrast = GetDisplayBackground().GetColor().IsDark();
1320
1321         mpMenu->appendEntry( 0, String( SVX_RES( STR_WIREFRAME ) ), bHighContrast ? maImgSurface1h : maImgSurface1 );
1322         mpMenu->appendEntry( 1, String( SVX_RES( STR_MATTE ) ), bHighContrast ? maImgSurface2h : maImgSurface2 );
1323         mpMenu->appendEntry( 2, String( SVX_RES( STR_PLASTIC ) ), bHighContrast ? maImgSurface3h : maImgSurface3 );
1324         mpMenu->appendEntry( 3, String( SVX_RES( STR_METAL ) ), bHighContrast ? maImgSurface4h : maImgSurface4 );
1325     }
1326 }
1327
1328 // -----------------------------------------------------------------------
1329
1330 IMPL_LINK( ExtrusionSurfaceWindow, SelectHdl, void *, EMPTYARG )
1331 {
1332     if ( IsInPopupMode() )
1333         EndPopupMode();
1334
1335 //      SfxDispatcher* pDisp = GetBindings().GetDispatcher();
1336
1337     sal_Int32 nSurface = mpMenu->getSelectedEntryId();
1338     if( nSurface >= 0 )
1339     {
1340         SfxInt32Item    aItem( SID_EXTRUSION_SURFACE, nSurface );
1341         rtl::OUString   aCommand( RTL_CONSTASCII_USTRINGPARAM( ".uno:ExtrusionSurface" ));
1342
1343         Any a;
1344         INetURLObject aObj( aCommand );
1345         Sequence< PropertyValue > aArgs( 1 );
1346         aArgs[0].Name = aObj.GetURLPath();
1347         aItem.QueryValue( a );
1348         aArgs[0].Value = a;
1349
1350         SfxToolBoxControl::Dispatch( Reference< ::com::sun::star::frame::XDispatchProvider >(
1351                                      mxFrame->getController(), UNO_QUERY ),
1352                                      aCommand,
1353                                      aArgs );
1354 //              pDisp->Execute( SID_EXTRUSION_SURFACE, SFX_CALLMODE_RECORD, &aItem, 0L , 0L );
1355
1356         implSetSurface( nSurface, true );
1357     }
1358
1359     return 0;
1360 }
1361
1362 // -----------------------------------------------------------------------
1363
1364 void ExtrusionSurfaceWindow::StartSelection()
1365 {
1366 }
1367
1368 // -----------------------------------------------------------------------
1369
1370 BOOL ExtrusionSurfaceWindow::Close()
1371 {
1372     return SfxPopupWindow::Close();
1373 }
1374
1375 // -----------------------------------------------------------------------
1376
1377 void ExtrusionSurfaceWindow::PopupModeEnd()
1378 {
1379     if ( IsVisible() )
1380     {
1381         mbPopupMode = FALSE;
1382     }
1383     SfxPopupWindow::PopupModeEnd();
1384 }
1385
1386 // -----------------------------------------------------------------------
1387
1388 void ExtrusionSurfaceWindow::GetFocus (void)
1389 {
1390     SfxPopupWindow::GetFocus();
1391     // Grab the focus to the line ends value set so that it can be controlled
1392     // with the keyboard.
1393     if( mpMenu )
1394         mpMenu->GrabFocus();
1395 }
1396
1397 // ========================================================================
1398
1399 ExtrusionSurfaceControl::ExtrusionSurfaceControl(
1400     USHORT nSlotId, USHORT nId, ToolBox &rTbx )
1401 : SfxToolBoxControl( nSlotId, nId, rTbx )
1402 {
1403     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
1404 }
1405
1406 // -----------------------------------------------------------------------
1407
1408 ExtrusionSurfaceControl::~ExtrusionSurfaceControl()
1409 {
1410 }
1411
1412 // -----------------------------------------------------------------------
1413
1414 SfxPopupWindowType ExtrusionSurfaceControl::GetPopupWindowType() const
1415 {
1416     return SFX_POPUPWINDOW_ONCLICK;
1417 }
1418
1419 // -----------------------------------------------------------------------
1420
1421 SfxPopupWindow* ExtrusionSurfaceControl::CreatePopupWindow()
1422 {
1423     ExtrusionSurfaceWindow* pWin = new ExtrusionSurfaceWindow( GetId(), m_xFrame, &GetToolBox() );
1424     pWin->StartPopupMode( &GetToolBox(), TRUE );
1425     pWin->StartSelection();
1426     SetPopupWindow( pWin );
1427     return pWin;
1428 }
1429
1430 // -----------------------------------------------------------------------
1431
1432 void ExtrusionSurfaceControl::StateChanged( USHORT, SfxItemState eState, const SfxPoolItem* )
1433 {
1434     USHORT nId = GetId();
1435     ToolBox& rTbx = GetToolBox();
1436
1437     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
1438     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
1439 }
1440
1441 //========================================================================
1442
1443 SFX_IMPL_TOOLBOX_CONTROL( ExtrusionColorControl, SvxColorItem );
1444
1445 ExtrusionColorControl::ExtrusionColorControl(
1446     USHORT nSlotId, USHORT nId, ToolBox& rTbx )
1447 : SfxToolBoxControl     ( nSlotId, nId, rTbx )
1448 {
1449     rTbx.SetItemBits( nId, TIB_DROPDOWNONLY | rTbx.GetItemBits( nId ) );
1450     mpBtnUpdater = new ToolboxButtonColorUpdater( nSlotId, nId, &GetToolBox(), TBX_UPDATER_MODE_CHAR_COLOR_NEW );
1451 }
1452
1453 // -----------------------------------------------------------------------
1454
1455 ExtrusionColorControl::~ExtrusionColorControl()
1456 {
1457     delete mpBtnUpdater;
1458 }
1459
1460 // -----------------------------------------------------------------------
1461
1462 SfxPopupWindowType ExtrusionColorControl::GetPopupWindowType() const
1463 {
1464     return SFX_POPUPWINDOW_ONCLICK;
1465 }
1466
1467 // -----------------------------------------------------------------------
1468
1469 SfxPopupWindow* ExtrusionColorControl::CreatePopupWindow()
1470 {
1471     SvxColorWindow_Impl* pColorWin = new SvxColorWindow_Impl(
1472         rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ".uno:Extrusion3DColor" )),
1473         SID_EXTRUSION_3D_COLOR,
1474         m_xFrame,
1475         SVX_RESSTR( RID_SVXSTR_EXTRUSION_COLOR ),
1476         &GetToolBox() );
1477     pColorWin->StartPopupMode( &GetToolBox(), FLOATWIN_POPUPMODE_GRABFOCUS|FLOATWIN_POPUPMODE_ALLOWTEAROFF );
1478     pColorWin->StartSelection();
1479     SetPopupWindow( pColorWin );
1480     return pColorWin;
1481 }
1482
1483 // -----------------------------------------------------------------------
1484
1485 void ExtrusionColorControl::StateChanged( USHORT nSID, SfxItemState eState, const SfxPoolItem* pState )
1486 {
1487     USHORT nId = GetId();
1488     ToolBox& rTbx = GetToolBox();
1489
1490     if( nSID == SID_EXTRUSION_3D_COLOR )
1491     {
1492         const SvxColorItem*     pItem = 0;
1493
1494         if( SFX_ITEM_DONTCARE != eState )
1495             pItem = PTR_CAST( SvxColorItem, pState );
1496
1497         if ( pItem )
1498             mpBtnUpdater->Update( pItem->GetValue());
1499     }
1500
1501     rTbx.EnableItem( nId, SFX_ITEM_DISABLED != eState );
1502     rTbx.SetItemState( nId, ( SFX_ITEM_DONTCARE == eState ) ? STATE_DONTKNOW : STATE_NOCHECK );
1503 }