svx/source/toolbars/extrusionbar.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 <com/sun/star/drawing/EnhancedCustomShapeParameterPair.hpp>
  22 #include <com/sun/star/drawing/EnhancedCustomShapeParameterType.hpp>
  23 #include <com/sun/star/drawing/ShadeMode.hpp>
  24 #include <com/sun/star/drawing/Position3D.hpp>
  25 #include <com/sun/star/drawing/Direction3D.hpp>
  26 #include <com/sun/star/drawing/ProjectionMode.hpp>
  27 #include <svx/svdundo.hxx>
  28 #include <sfx2/app.hxx>
  29 #include <sfx2/request.hxx>
  30 #include <sfx2/objface.hxx>
  31 #include <sfx2/viewsh.hxx>
  32 #include <sfx2/bindings.hxx>
  33 #include <svx/xsflclit.hxx>
  34 #include <svx/dialmgr.hxx>
  35 #include <svx/svdoashp.hxx>
  36 #include <svx/dialogs.hrc>
  37 #include <svx/svdview.hxx>
  38 #include <editeng/colritem.hxx>
  39 #include "svx/chrtitem.hxx"
  40
  41 #include <svx/extrusionbar.hxx>
  42 #include "extrusiondepthdialog.hxx"
  43
  44 using namespace ::svx;
  45 using namespace ::cppu;
  46 using namespace ::com::sun::star::beans;
  47 using namespace ::com::sun::star::drawing;
  48 using namespace ::com::sun::star::uno;
  49
  50 // Standardinterface deklarieren (Die Slotmap darf nicht leer sein, also
  51 // tragen wir etwas ein, was hier (hoffentlich) nie vorkommt).
  52 static SfxSlot aExtrusionBarSlots_Impl[] =
  53 {
  54     { 0, 0, 0, SfxSlotMode::NONE, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
  55 };
  56
  57 SFX_IMPL_INTERFACE(ExtrusionBar, SfxShell)
  58
  59 void ExtrusionBar::InitInterface_Impl()
  60 {
  61     GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, RID_SVX_EXTRUSION_BAR);
  62 }
  63
  64 TYPEINIT1( ExtrusionBar, SfxShell );
  65
  66 ExtrusionBar::ExtrusionBar(SfxViewShell* pViewShell )
  67 : SfxShell(pViewShell)
  68 {
  69     DBG_ASSERT( pViewShell, "svx::ExtrusionBar::ExtrusionBar(), I need a viewshell!" );
  70     if( pViewShell )
  71         SetPool(&pViewShell->GetPool());
  72
  73     SetHelpId( SVX_INTERFACE_EXTRUSION_BAR );
  74     SetName(SVX_RESSTR(RID_SVX_EXTRUSION_BAR));
  75 }
  76
  77 ExtrusionBar::~ExtrusionBar()
  78 {
  79     SetRepeatTarget(NULL);
  80 }
  81
  82 void getLightingDirectionDefaults( const Direction3D **pLighting1Defaults, const Direction3D **pLighting2Defaults )
  83 {
  84
  85     static const Direction3D aLighting1Defaults[9] =
  86     {
  87         Direction3D( -50000, -50000, 10000 ),
  88         Direction3D( 0, -50000, 10000 ),
  89         Direction3D( 50000, -50000, 10000 ),
  90         Direction3D( -50000, 0, 10000 ),
  91         Direction3D( 0, 0, 10000 ),
  92         Direction3D( 50000, 0, 10000 ),
  93         Direction3D( -50000, 50000, 10000 ),
  94         Direction3D( 0, 50000, 10000 ),
  95         Direction3D( 50000, 50000, 10000 )
  96     };
  97
  98     static const Direction3D aLighting2Defaults[9] =
  99     {
 100         Direction3D( 50000,0, 10000 ),
 101         Direction3D( 0, 50000, 10000 ),
 102         Direction3D( -50000, 0, 10000 ),
 103         Direction3D( 50000, 0, 10000 ),
 104         Direction3D( 0, 0, 10000 ),
 105         Direction3D( -50000, 0, 10000 ),
 106         Direction3D( 50000, 0, 10000 ),
 107         Direction3D( 0, -50000, 10000 ),
 108         Direction3D( -50000, 0, 10000 )
 109     };
 110
 111     *pLighting1Defaults = (const Direction3D *)aLighting1Defaults;
 112     *pLighting2Defaults = (const Direction3D *)aLighting2Defaults;
 113 };
 114
 115 static void impl_execute( SdrView*, SfxRequest& rReq, SdrCustomShapeGeometryItem& rGeometryItem, SdrObject* pObj )
 116 {
 117     static const char sExtrusion[] = "Extrusion";
 118     static const char sProjectionMode[] = "ProjectionMode";
 119     static const char sRotateAngle[] = "RotateAngle";
 120     static const char sViewPoint[] = "ViewPoint";
 121     static const char sOrigin[] = "Origin";
 122     static const char sSkew[] = "Skew";
 123     static const char sDepth[] = "Depth";
 124
 125     sal_uInt16 nSID = rReq.GetSlot();
 126     switch( nSID )
 127     {
 128     case SID_EXTRUSION_TOOGLE:
 129     {
 130         com::sun::star::uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
 131
 132         if( pAny )
 133         {
 134             bool bOn(false);
 135             (*pAny) >>= bOn;
 136             bOn = !bOn;
 137             (*pAny) <<= bOn;
 138         }
 139         else
 140         {
 141             com::sun::star::beans::PropertyValue aPropValue;
 142             aPropValue.Name = sExtrusion;
 143             aPropValue.Value <<= sal_True;
 144             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 145         }
 146     }
 147     break;
 148
 149     case SID_EXTRUSION_TILT_DOWN:
 150     case SID_EXTRUSION_TILT_UP:
 151     case SID_EXTRUSION_TILT_LEFT:
 152     case SID_EXTRUSION_TILT_RIGHT:
 153     {
 154         bool bHorizontal = ( nSID == SID_EXTRUSION_TILT_DOWN ) || ( nSID == SID_EXTRUSION_TILT_UP );
 155         sal_Int32 nDiff = ( nSID == SID_EXTRUSION_TILT_LEFT ) || ( nSID == SID_EXTRUSION_TILT_UP ) ? 5 : -5;
 156         EnhancedCustomShapeParameterPair aRotateAnglePropPair;
 157         double fX = 0.0;
 158         double fY = 0.0;
 159         aRotateAnglePropPair.First.Value <<= fX;
 160         aRotateAnglePropPair.First.Type = EnhancedCustomShapeParameterType::NORMAL;
 161         aRotateAnglePropPair.Second.Value <<= fY;
 162         aRotateAnglePropPair.Second.Type = EnhancedCustomShapeParameterType::NORMAL;
 163         com::sun::star::uno::Any* pAny = rGeometryItem.GetPropertyValueByName( sExtrusion, sRotateAngle );
 164         if( pAny && ( *pAny >>= aRotateAnglePropPair ) )
 165         {
 166             aRotateAnglePropPair.First.Value >>= fX;
 167             aRotateAnglePropPair.Second.Value >>= fY;
 168         }
 169         if ( bHorizontal )
 170             fX += nDiff;
 171         else
 172             fY += nDiff;
 173         aRotateAnglePropPair.First.Value <<= fX;
 174         aRotateAnglePropPair.Second.Value <<= fY;
 175         com::sun::star::beans::PropertyValue aPropValue;
 176         aPropValue.Name = sRotateAngle;
 177         aPropValue.Value <<= aRotateAnglePropPair;
 178         rGeometryItem.SetPropertyValue( sExtrusion, aPropValue );
 179     }
 180     break;
 181
 182     case SID_EXTRUSION_DIRECTION:
 183     {
 184         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_DIRECTION ) == SfxItemState::SET )
 185         {
 186             sal_Int32 nSkew = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_DIRECTION))->GetValue();
 187
 188             Position3D  aViewPoint( 3472, -3472, 25000 );
 189             double      fOriginX = 0.50;
 190             double      fOriginY = -0.50;
 191             double      fSkewAngle = nSkew;
 192             double      fSkew = 50.0;
 193
 194             switch( nSkew )
 195             {
 196             case 135:
 197                 aViewPoint.PositionY = 3472;
 198                 fOriginY = 0.50;
 199                 break;
 200             case 90:
 201                 aViewPoint.PositionX = 0;
 202                 aViewPoint.PositionY = 3472;
 203                 fOriginX = 0;
 204                 fOriginY = -0.50;
 205                 break;
 206             case 45:
 207                 aViewPoint.PositionX = -3472;
 208                 aViewPoint.PositionY = 3472;
 209                 fOriginX = -0.50;
 210                 fOriginY = 0.50;
 211                 break;
 212             case 180:
 213                 aViewPoint.PositionY = 0;
 214                 fOriginY = 0;
 215                 break;
 216             case 0:
 217                 aViewPoint.PositionX = 0;
 218                 aViewPoint.PositionY = 0;
 219                 fOriginX = 0;
 220                 fOriginY = 0;
 221                 fSkew = 0.0;
 222                 break;
 223             case -360:
 224                 aViewPoint.PositionX = -3472;
 225                 aViewPoint.PositionY = 0;
 226                 fOriginX = -0.50;
 227                 fOriginY = 0;
 228                 break;
 229             case -90:
 230                 aViewPoint.PositionX = 0;
 231                 fOriginX = 0;
 232                 break;
 233             case -45:
 234                 aViewPoint.PositionX = -3472;
 235                 fOriginX = -0.50;
 236                 break;
 237             }
 238
 239             com::sun::star::beans::PropertyValue aPropValue;
 240
 241             aPropValue.Name = sViewPoint;
 242             aPropValue.Value <<= aViewPoint;
 243             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 244
 245
 246             EnhancedCustomShapeParameterPair aOriginPropPair;
 247             aOriginPropPair.First.Value <<= fOriginX;
 248             aOriginPropPair.First.Type = EnhancedCustomShapeParameterType::NORMAL;
 249             aOriginPropPair.Second.Value <<= fOriginY;
 250             aOriginPropPair.Second.Type = EnhancedCustomShapeParameterType::NORMAL;
 251             aPropValue.Name = sOrigin;
 252             aPropValue.Value <<= aOriginPropPair;
 253             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 254
 255             EnhancedCustomShapeParameterPair aSkewPropPair;
 256             aSkewPropPair.First.Value <<= fSkew;
 257             aSkewPropPair.First.Type = EnhancedCustomShapeParameterType::NORMAL;
 258             aSkewPropPair.Second.Value <<= fSkewAngle;
 259             aSkewPropPair.Second.Type = EnhancedCustomShapeParameterType::NORMAL;
 260             aPropValue.Name = sSkew;
 261             aPropValue.Value <<= aSkewPropPair;
 262             rGeometryItem.SetPropertyValue( sExtrusion, aPropValue );
 263         }
 264     }
 265     break;
 266     case SID_EXTRUSION_PROJECTION:
 267     {
 268         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_PROJECTION ) == SfxItemState::SET )
 269         {
 270             sal_Int32 nProjection = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_PROJECTION))->GetValue();
 271             ProjectionMode eProjectionMode = nProjection == 1 ? ProjectionMode_PARALLEL : ProjectionMode_PERSPECTIVE;
 272             com::sun::star::beans::PropertyValue aPropValue;
 273             aPropValue.Name = sProjectionMode;
 274             aPropValue.Value <<= eProjectionMode;
 275             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 276         }
 277     }
 278     break;
 279     case SID_EXTRUSION_DEPTH:
 280     {
 281         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_DEPTH ) == SfxItemState::SET)
 282         {
 283             double fDepth = static_cast<const SvxDoubleItem*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_DEPTH))->GetValue();
 284             double fFraction = 0.0;
 285             EnhancedCustomShapeParameterPair aDepthPropPair;
 286             aDepthPropPair.First.Value <<= fDepth;
 287             aDepthPropPair.First.Type = EnhancedCustomShapeParameterType::NORMAL;
 288             aDepthPropPair.Second.Value <<= fFraction;
 289             aDepthPropPair.Second.Type = EnhancedCustomShapeParameterType::NORMAL;
 290
 291             com::sun::star::beans::PropertyValue aPropValue;
 292             aPropValue.Name = sDepth;
 293             aPropValue.Value <<= aDepthPropPair;
 294             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 295         }
 296     }
 297     break;
 298     case SID_EXTRUSION_3D_COLOR:
 299     {
 300         static const char sExtrusionColor[] = "Color";
 301
 302         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_3D_COLOR ) == SfxItemState::SET)
 303         {
 304             Color aColor( static_cast<const SvxColorItem&>(rReq.GetArgs()->Get(SID_EXTRUSION_3D_COLOR)).GetValue() );
 305
 306             const bool bAuto = aColor == COL_AUTO;
 307
 308             com::sun::star::beans::PropertyValue aPropValue;
 309             aPropValue.Name = sExtrusionColor;
 310             aPropValue.Value <<= bAuto ? sal_False : sal_True;
 311             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 312
 313             if( bAuto )
 314             {
 315                 pObj->ClearMergedItem( XATTR_SECONDARYFILLCOLOR );
 316             }
 317             else
 318             {
 319                 pObj->SetMergedItem( XSecondaryFillColorItem( "", aColor ) );
 320             }
 321             pObj->BroadcastObjectChange();
 322         }
 323     }
 324     break;
 325     case SID_EXTRUSION_SURFACE:
 326     {
 327         static const char sShadeMode[] = "ShadeMode";
 328         static const char sSpecularity[] = "Specularity";
 329         static const char sDiffusion[] = "Diffusion";
 330         static const char sMetal[] = "Metal";
 331
 332         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_SURFACE ) == SfxItemState::SET)
 333         {
 334             sal_Int32 nSurface = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_SURFACE))->GetValue();
 335
 336             ShadeMode eShadeMode( ShadeMode_FLAT );
 337             bool bMetal = false;
 338             double fSpecularity = 0;
 339             double fDiffusion = 0;
 340
 341             switch( nSurface )
 342             {
 343             case 0: // wireframe
 344                 eShadeMode = ShadeMode_DRAFT;
 345                 break;
 346             case 1: // matte
 347                 break;
 348             case 2: // plastic
 349                 fSpecularity = 122.0;
 350                 break;
 351             case 3: // metal
 352                 bMetal = true;
 353                 fSpecularity = 122.0;
 354                 fDiffusion = 122.0;
 355                 break;
 356             }
 357
 358             com::sun::star::beans::PropertyValue aPropValue;
 359             aPropValue.Name = sShadeMode;
 360             aPropValue.Value <<= eShadeMode;
 361             rGeometryItem.SetPropertyValue( sExtrusion, aPropValue );
 362
 363             aPropValue.Name = sMetal;
 364             aPropValue.Value <<= bMetal;
 365             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 366
 367             aPropValue.Name = sSpecularity;
 368             aPropValue.Value <<= fSpecularity;
 369             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 370
 371             aPropValue.Name = sDiffusion;
 372             aPropValue.Value <<= fDiffusion;
 373             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 374         }
 375     }
 376     break;
 377     case SID_EXTRUSION_LIGHTING_INTENSITY:
 378     {
 379         static const char sBrightness[] = "Brightness";
 380         static const char sLightFace[] = "LightFace";
 381         static const char sFirstLightHarsh[] = "FirstLightHarsh";
 382         static const char sSecondLightHarsh[] = "SecondLightHarsh";
 383         static const char sFirstLightLevel[] = "FirstLightLevel";
 384         static const char sSecondLightLevel[] = "SecondLightLevel";
 385
 386         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_LIGHTING_INTENSITY ) == SfxItemState::SET)
 387         {
 388             sal_Int32 nLevel = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_LIGHTING_INTENSITY))->GetValue();
 389
 390             double fBrightness;
 391             bool bHarsh2 = false;
 392             double fLevel1;
 393             double fLevel2;
 394
 395             switch( nLevel )
 396             {
 397             case 0: // bright
 398                 fBrightness = 34.0;
 399                 bHarsh2 = false;
 400                 fLevel1 = 66.0;
 401                 fLevel2 = 66.0;
 402                 break;
 403             case 1: // normal
 404                 fBrightness = 15.0;
 405                 bHarsh2 = false;
 406                 fLevel1 = 67.0;
 407                 fLevel2 = 37.0;
 408                 break;
 409             case 2: // dim
 410                 fBrightness = 6.0;
 411                 bHarsh2 = true;
 412                 fLevel1 = 79.0;
 413                 fLevel2 = 21.0;
 414                 break;
 415             }
 416
 417             com::sun::star::beans::PropertyValue aPropValue;
 418             aPropValue.Name = sBrightness;
 419             aPropValue.Value <<= fBrightness;
 420             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 421
 422             aPropValue.Name = sLightFace;
 423             aPropValue.Value <<= sal_True;
 424             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 425
 426             aPropValue.Name = sFirstLightHarsh;
 427             aPropValue.Value <<= sal_True;
 428             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 429
 430             aPropValue.Name = sSecondLightHarsh;
 431             aPropValue.Value <<= bHarsh2;
 432             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 433
 434             aPropValue.Name = sFirstLightLevel;
 435             aPropValue.Value <<= fLevel1;
 436             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 437
 438             aPropValue.Name = sSecondLightLevel;
 439             aPropValue.Value <<= fLevel2;
 440             rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 441         }
 442     }
 443     break;
 444     case SID_EXTRUSION_LIGHTING_DIRECTION:
 445     {
 446         if( rReq.GetArgs() && rReq.GetArgs()->GetItemState( SID_EXTRUSION_LIGHTING_DIRECTION ) == SfxItemState::SET)
 447         {
 448             sal_Int32 nDirection = static_cast<const SfxInt32Item*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_LIGHTING_DIRECTION))->GetValue();
 449
 450             if((nDirection >= 0) && (nDirection < 9))
 451             {
 452                 const OUString sFirstLightDirection( "FirstLightDirection" );
 453                 const OUString sSecondLightDirection( "SecondLightDirection" );
 454
 455                 const Direction3D * pLighting1Defaults;
 456                 const Direction3D * pLighting2Defaults;
 457
 458                 getLightingDirectionDefaults( &pLighting1Defaults, &pLighting2Defaults );
 459
 460                 com::sun::star::beans::PropertyValue aPropValue;
 461                 aPropValue.Name = sFirstLightDirection;
 462                 aPropValue.Value <<= pLighting1Defaults[nDirection];
 463                 rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 464
 465                 aPropValue.Name = sSecondLightDirection;
 466                 aPropValue.Value <<= pLighting2Defaults[nDirection];
 467                 rGeometryItem.SetPropertyValue( sExtrusion,  aPropValue );
 468             }
 469         }
 470     }
 471     break;
 472
 473     }
 474 }
 475
 476 void ExtrusionBar::execute( SdrView* pSdrView, SfxRequest& rReq, SfxBindings& rBindings )
 477 {
 478     sal_uInt16 nSID = rReq.GetSlot();
 479     sal_uInt16 nStrResId = 0;
 480
 481     const bool bUndo = pSdrView && pSdrView->IsUndoEnabled();
 482
 483     switch( nSID )
 484     {
 485         case SID_EXTRUSION_TOOGLE:
 486         {
 487             if ( !nStrResId )
 488                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ON_OFF;
 489         }   // PASSTROUGH
 490         case SID_EXTRUSION_TILT_DOWN:
 491         {
 492             if ( !nStrResId )
 493                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ROTATE_DOWN;
 494         }   // PASSTROUGH
 495         case SID_EXTRUSION_TILT_UP:
 496         {
 497             if ( !nStrResId )
 498                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ROTATE_UP;
 499         }   // PASSTROUGH
 500         case SID_EXTRUSION_TILT_LEFT:
 501         {
 502             if ( !nStrResId )
 503                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ROTATE_LEFT;
 504         }   // PASSTROUGH
 505         case SID_EXTRUSION_TILT_RIGHT:
 506         {
 507             if ( !nStrResId )
 508                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ROTATE_RIGHT;
 509         }   // PASSTROUGH
 510         case SID_EXTRUSION_DIRECTION:
 511         {
 512             if ( !nStrResId )
 513                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_ORIENTATION;
 514         }   // PASSTROUGH
 515         case SID_EXTRUSION_PROJECTION:
 516         {
 517             if ( !nStrResId )
 518                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_PROJECTION;
 519         }   // PASSTROUGH
 520         case SID_EXTRUSION_DEPTH:
 521         {
 522             if ( !nStrResId )
 523                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_DEPTH;
 524         }   // PASSTROUGH
 525         case SID_EXTRUSION_3D_COLOR:
 526         {
 527             if ( !nStrResId )
 528                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_COLOR;
 529         }   // PASSTROUGH
 530         case SID_EXTRUSION_SURFACE:
 531         {
 532             if ( !nStrResId )
 533                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_SURFACE;
 534         }   // PASSTROUGH
 535         case SID_EXTRUSION_LIGHTING_INTENSITY:
 536         {
 537             if ( !nStrResId )
 538                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_BRIGHTNESS;
 539         }   // PASSTROUGH
 540         case SID_EXTRUSION_LIGHTING_DIRECTION:
 541         {
 542             if ( !nStrResId )
 543                 nStrResId = RID_SVXSTR_UNDO_APPLY_EXTRUSION_LIGHTING;
 544
 545             if (pSdrView)
 546             {
 547                 const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 548                 const size_t nCount = rMarkList.GetMarkCount();
 549
 550                 for(size_t i=0; i<nCount; ++i)
 551                 {
 552                     SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 553                     if( pObj->ISA(SdrObjCustomShape) )
 554                     {
 555                         if( bUndo )
 556                         {
 557                             OUString aStr( SVX_RESSTR( nStrResId ) );
 558                             pSdrView->BegUndo( aStr );
 559                             pSdrView->AddUndo( pSdrView->GetModel()->GetSdrUndoFactory().CreateUndoAttrObject( *pObj ) );
 560                         }
 561                         SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )));
 562                         impl_execute( pSdrView, rReq, aGeometryItem, pObj );
 563                         pObj->SetMergedItem( aGeometryItem );
 564                         pObj->BroadcastObjectChange();
 565                         if( bUndo )
 566                             pSdrView->EndUndo();
 567
 568                         // simulate a context change:
 569                         // force SelectionHasChanged() being called
 570                         // so that extrusion bar will be visible/hidden
 571                         pSdrView->MarkListHasChanged();
 572                     }
 573                 }
 574             }
 575         }
 576         break;
 577
 578         case SID_EXTRUSION_DEPTH_DIALOG:
 579             if( rReq.GetArgs() &&
 580                 (rReq.GetArgs()->GetItemState( SID_EXTRUSION_DEPTH ) == SfxItemState::SET) &&
 581                 (rReq.GetArgs()->GetItemState( SID_ATTR_METRIC ) == SfxItemState::SET))
 582             {
 583                 double fDepth = static_cast<const SvxDoubleItem*>(rReq.GetArgs()->GetItem(SID_EXTRUSION_DEPTH))->GetValue();
 584                 FieldUnit eUnit = (FieldUnit)static_cast<const SfxUInt16Item*>(rReq.GetArgs()->GetItem(SID_ATTR_METRIC))->GetValue();
 585
 586                 ScopedVclPtrInstance< ExtrusionDepthDialog > aDlg(nullptr, fDepth, eUnit);
 587                 sal_uInt16 nRet = aDlg->Execute();
 588                 if( nRet != 0 )
 589                 {
 590                     fDepth = aDlg->getDepth();
 591
 592                     SvxDoubleItem aItem( fDepth, SID_EXTRUSION_DEPTH );
 593                     SfxPoolItem* aItems[] = { &aItem, 0 };
 594                     rBindings.Execute( SID_EXTRUSION_DEPTH, (const SfxPoolItem**)aItems );
 595                 }
 596             }
 597             break;
 598     }
 599
 600     if( nSID == SID_EXTRUSION_TOOGLE )
 601     {
 602             static sal_uInt16 SidArray[] = {
 603                 SID_EXTRUSION_TILT_DOWN,
 604                 SID_EXTRUSION_TILT_UP,
 605                 SID_EXTRUSION_TILT_LEFT,
 606                 SID_EXTRUSION_TILT_RIGHT,
 607                 SID_EXTRUSION_DEPTH_FLOATER,
 608                 SID_EXTRUSION_DIRECTION_FLOATER,
 609                 SID_EXTRUSION_LIGHTING_FLOATER,
 610                 SID_EXTRUSION_SURFACE_FLOATER,
 611                 SID_EXTRUSION_3D_COLOR,
 612                 SID_EXTRUSION_DEPTH,
 613                 SID_EXTRUSION_DIRECTION,
 614                 SID_EXTRUSION_PROJECTION,
 615                 SID_EXTRUSION_LIGHTING_DIRECTION,
 616                 SID_EXTRUSION_LIGHTING_INTENSITY,
 617                 SID_EXTRUSION_SURFACE,
 618                 0 };
 619
 620         rBindings.Invalidate( SidArray );
 621     }
 622 }
 623
 624 void getExtrusionDirectionState( SdrView* pSdrView, SfxItemSet& rSet )
 625 {
 626     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 627     const size_t nCount = rMarkList.GetMarkCount();
 628
 629     static const char  sExtrusion[] = "Extrusion";
 630     static const char  sViewPoint[] = "ViewPoint";
 631     static const char  sOrigin[] = "Origin";
 632     static const char  sSkew[] = "Skew";
 633     static const char  sProjectionMode[] = "ProjectionMode";
 634
 635     const com::sun::star::uno::Any* pAny;
 636
 637     double fFinalSkewAngle = -1;
 638     bool bHasCustomShape = false;
 639
 640     for(size_t i=0; i<nCount; ++i)
 641     {
 642         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 643         if( pObj->ISA(SdrObjCustomShape) )
 644         {
 645             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
 646
 647             // see if this is an extruded customshape
 648             if( !bHasCustomShape )
 649             {
 650                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
 651                 if( pAny_ )
 652                     *pAny_ >>= bHasCustomShape;
 653
 654                 if( !bHasCustomShape )
 655                     continue;
 656             }
 657
 658             bool        bParallel = true;
 659             Position3D  aViewPoint( 3472, -3472, 25000 );
 660             double      fSkewAngle = -135;
 661
 662             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sProjectionMode );
 663             sal_Int16 nProjectionMode = sal_Int16();
 664             if( pAny && ( *pAny >>= nProjectionMode ) )
 665                 bParallel = nProjectionMode == ProjectionMode_PARALLEL;
 666
 667             if( bParallel )
 668             {
 669                 double      fSkew = 50.0;
 670                 EnhancedCustomShapeParameterPair aSkewPropPair;
 671                 pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sSkew );
 672                 if( pAny && ( *pAny >>= aSkewPropPair ) )
 673                 {
 674                     aSkewPropPair.First.Value >>= fSkew;
 675                     aSkewPropPair.Second.Value >>= fSkewAngle;
 676                 }
 677                 if ( fSkew == 0.0 )
 678                     fSkewAngle = 0.0;
 679                 else if ( fSkewAngle == 0.0 )
 680                     fSkewAngle = -360.0;
 681             }
 682             else
 683             {
 684                 double      fOriginX = 0.50;
 685                 double      fOriginY = -0.50;
 686                 pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sViewPoint );
 687                 if( pAny )
 688                     *pAny >>= aViewPoint;
 689
 690                 EnhancedCustomShapeParameterPair aOriginPropPair;
 691                 pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sOrigin );
 692                 if( pAny && ( *pAny >>= aOriginPropPair ) )
 693                 {
 694                     aOriginPropPair.First.Value >>= fOriginX;
 695                     aOriginPropPair.Second.Value >>= fOriginY;
 696                 }
 697                 fSkewAngle = -1;
 698                 const double e = 0.0001;
 699                 if( aViewPoint.PositionX > e )
 700                 {
 701                     if( aViewPoint.PositionY > e )
 702                     {
 703                         if( (fOriginX > e ) && ( fOriginY > e ) )
 704                             fSkewAngle = 135.0;
 705                     }
 706                     else if( aViewPoint.PositionY < -e )
 707                     {
 708                         if( ( fOriginX > e ) && ( fOriginY < -e ) )
 709                             fSkewAngle = -135.0;
 710                     }
 711                     else
 712                     {
 713                         if( ( fOriginX > e ) && ( fOriginY > -e ) && ( fOriginY < e ) )
 714                             fSkewAngle = 180.0;
 715                     }
 716                 }
 717                 else if( aViewPoint.PositionX < -e )
 718                 {
 719                     if( aViewPoint.PositionY < -e )
 720                     {
 721                         if( ( fOriginX < -e ) && ( fOriginY < -e ) )
 722                             fSkewAngle = -45.0;
 723                     }
 724                     else if( aViewPoint.PositionY > e )
 725                     {
 726                         if( ( fOriginX < -e ) && ( fOriginY > e ) )
 727                             fSkewAngle = 45.0;
 728                     }
 729                     else
 730                     {
 731                         if( ( fOriginX < e ) && ( fOriginY > -e ) && ( fOriginY < e ) )
 732                             fSkewAngle = -360.0;
 733                     }
 734                 }
 735                 else
 736                 {
 737                     if( aViewPoint.PositionY < -e )
 738                     {
 739                         if( ( fOriginX > -e ) && ( fOriginX < e ) && ( fOriginY < -e ) )
 740                             fSkewAngle = -90.0;
 741                     }
 742                     else if( aViewPoint.PositionY > e )
 743                     {
 744                         if( ( fOriginX > -e ) && ( fOriginX < e ) && ( fOriginY > e ) )
 745                             fSkewAngle = 90.0;
 746                     }
 747                     else
 748                     {
 749                         if( ( fOriginX > -e ) && ( fOriginX < e ) && ( fOriginY > -e ) && ( fOriginY < e ) )
 750                             fSkewAngle = 0.0;
 751                     }
 752                 }
 753             }
 754
 755             if( fFinalSkewAngle == -1.0 )
 756             {
 757                 fFinalSkewAngle = fSkewAngle;
 758             }
 759             else if( fSkewAngle != fFinalSkewAngle )
 760             {
 761                 fFinalSkewAngle = -1.0;
 762             }
 763
 764             if( fFinalSkewAngle == -1.0 )
 765                 break;
 766         }
 767     }
 768
 769     if( bHasCustomShape )
 770         rSet.Put( SfxInt32Item( SID_EXTRUSION_DIRECTION, (sal_Int32)fFinalSkewAngle ) );
 771     else
 772         rSet.DisableItem( SID_EXTRUSION_DIRECTION );
 773 }
 774
 775 void getExtrusionProjectionState( SdrView* pSdrView, SfxItemSet& rSet )
 776 {
 777     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 778     const size_t nCount = rMarkList.GetMarkCount();
 779
 780     static const char  sExtrusion[] = "Extrusion";
 781     static const char  sProjectionMode[] = "ProjectionMode";
 782
 783     const com::sun::star::uno::Any* pAny;
 784
 785     sal_Int32 nFinalProjection = -1;
 786     bool bHasCustomShape = false;
 787
 788     for(size_t i=0; i<nCount; ++i)
 789     {
 790         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 791         if( pObj->ISA(SdrObjCustomShape) )
 792         {
 793             // see if this is an extruded customshape
 794             if( !bHasCustomShape )
 795             {
 796                 const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
 797                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
 798                 if( pAny_ )
 799                     *pAny_ >>= bHasCustomShape;
 800
 801                 if( !bHasCustomShape )
 802                     continue;
 803             }
 804
 805             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
 806
 807             bool    bParallel = true;
 808             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sProjectionMode );
 809             ProjectionMode eProjectionMode;
 810             if( pAny && ( *pAny >>= eProjectionMode ) )
 811                 bParallel = eProjectionMode == ProjectionMode_PARALLEL;
 812
 813             if( nFinalProjection == -1 )
 814             {
 815                 nFinalProjection = bParallel ? 1 : 0;
 816             }
 817             else if( nFinalProjection != (bParallel ? 1 : 0) )
 818             {
 819                 nFinalProjection = -1;
 820                 break;
 821             }
 822         }
 823     }
 824
 825     if( bHasCustomShape )
 826         rSet.Put( SfxInt32Item( SID_EXTRUSION_PROJECTION, nFinalProjection ) );
 827     else
 828         rSet.DisableItem( SID_EXTRUSION_PROJECTION );
 829 }
 830
 831 void getExtrusionSurfaceState( SdrView* pSdrView, SfxItemSet& rSet )
 832 {
 833     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 834     const size_t nCount = rMarkList.GetMarkCount();
 835
 836     static const char  sExtrusion[] = "Extrusion";
 837     static const char  sShadeMode[] = "ShadeMode";
 838     static const char  sSpecularity[] = "Specularity";
 839     static const char  sMetal[] = "Metal";
 840
 841     const com::sun::star::uno::Any* pAny;
 842
 843     sal_Int32 nFinalSurface = -1;
 844     bool bHasCustomShape = false;
 845
 846     for(size_t i=0; i<nCount; ++i)
 847     {
 848         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 849         if( pObj->ISA(SdrObjCustomShape) )
 850         {
 851             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
 852
 853             // see if this is an extruded customshape
 854             if( !bHasCustomShape )
 855             {
 856                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
 857                 if( pAny_ )
 858                     *pAny_ >>= bHasCustomShape;
 859
 860                 if( !bHasCustomShape )
 861                     continue;
 862             }
 863
 864             sal_Int32 nSurface = 0; // wire frame
 865
 866             ShadeMode eShadeMode( ShadeMode_FLAT );
 867             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sShadeMode );
 868             if( pAny )
 869                 *pAny >>= eShadeMode;
 870
 871             if( eShadeMode == ShadeMode_FLAT )
 872             {
 873                 bool bMetal = false;
 874                 pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sMetal );
 875                 if( pAny )
 876                     *pAny >>= bMetal;
 877
 878                 if( bMetal )
 879                 {
 880                     nSurface = 3; // metal
 881                 }
 882                 else
 883                 {
 884                     double fSpecularity = 0;
 885                     pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sSpecularity );
 886                     if( pAny )
 887                         *pAny >>= fSpecularity;
 888
 889                     const double e = 0.0001;
 890                     if( (fSpecularity > -e) && (fSpecularity < e) )
 891                     {
 892                         nSurface = 1; // matte
 893                     }
 894                     else
 895                     {
 896                         nSurface = 2; // plastic
 897                     }
 898                 }
 899             }
 900
 901             if( nFinalSurface == -1 )
 902             {
 903                 nFinalSurface = nSurface;
 904             }
 905             else if( nFinalSurface != nSurface )
 906             {
 907                 nFinalSurface = -1;
 908                 break;
 909             }
 910         }
 911     }
 912
 913     if( bHasCustomShape )
 914         rSet.Put( SfxInt32Item( SID_EXTRUSION_SURFACE, nFinalSurface ) );
 915     else
 916         rSet.DisableItem( SID_EXTRUSION_SURFACE );
 917 }
 918
 919 void getExtrusionDepthState( SdrView* pSdrView, SfxItemSet& rSet )
 920 {
 921     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
 922     const size_t nCount = rMarkList.GetMarkCount();
 923
 924     static const char  sExtrusion[] = "Extrusion";
 925     static const char  sDepth[] = "Depth";
 926
 927     const com::sun::star::uno::Any* pAny;
 928
 929     double fFinalDepth = -1;
 930     bool bHasCustomShape = false;
 931
 932     for(size_t i=0; i<nCount; ++i)
 933     {
 934         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
 935         if( pObj->ISA(SdrObjCustomShape) )
 936         {
 937             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
 938
 939             // see if this is an extruded customshape
 940             if( !bHasCustomShape )
 941             {
 942                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
 943                 if( pAny_ )
 944                     *pAny_ >>= bHasCustomShape;
 945
 946                 if( !bHasCustomShape )
 947                     continue;
 948             }
 949
 950             double fDepth = 1270.0;
 951             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sDepth );
 952             if( pAny )
 953             {
 954                 EnhancedCustomShapeParameterPair aDepthPropPair;
 955                 if ( *pAny >>= aDepthPropPair )
 956                     aDepthPropPair.First.Value >>= fDepth;
 957             }
 958
 959             if( fFinalDepth == -1 )
 960             {
 961                 fFinalDepth = fDepth;
 962             }
 963             else if( fFinalDepth != fDepth )
 964             {
 965                 fFinalDepth = -1;
 966                 break;
 967             }
 968         }
 969     }
 970
 971     if( pSdrView->GetModel() )
 972     {
 973         FieldUnit eUnit = pSdrView->GetModel()->GetUIUnit();
 974         rSet.Put( SfxUInt16Item( SID_ATTR_METRIC, (sal_uInt16)eUnit ) );
 975     }
 976
 977     if( bHasCustomShape )
 978         rSet.Put( SvxDoubleItem( fFinalDepth, SID_EXTRUSION_DEPTH ) );
 979     else
 980         rSet.DisableItem( SID_EXTRUSION_DEPTH );
 981 }
 982
 983 static bool compare_direction( const Direction3D& d1, const Direction3D& d2 )
 984 {
 985     if( ((d1.DirectionX < 0) && (d2.DirectionX < 0)) || ((d1.DirectionX == 0) && (d2.DirectionX == 0)) || ((d1.DirectionX > 0) && (d2.DirectionX > 0)) )
 986     {
 987         if( ((d1.DirectionY < 0) && (d2.DirectionY < 0)) || ((d1.DirectionY == 0) && (d2.DirectionY == 0)) || ((d1.DirectionY > 0) && (d2.DirectionY > 0)) )
 988         {
 989             if( ((d1.DirectionZ < 0) && (d2.DirectionZ < 0)) || ((d1.DirectionZ == 0) && (d2.DirectionZ == 0)) || ((d1.DirectionZ > 0) && (d2.DirectionZ > 0)) )
 990             {
 991                 return true;
 992             }
 993         }
 994     }
 995
 996     return false;
 997 }
 998
 999 void getExtrusionLightingDirectionState( SdrView* pSdrView, SfxItemSet& rSet )
1000 {
1001     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
1002     const size_t nCount = rMarkList.GetMarkCount();
1003
1004     static const char  sExtrusion[] = "Extrusion";
1005     static const char  sFirstLightDirection[] = "FirstLightDirection";
1006     static const char  sSecondLightDirection[] = "SecondLightDirection";
1007
1008     const Direction3D * pLighting1Defaults;
1009     const Direction3D * pLighting2Defaults;
1010
1011     getLightingDirectionDefaults( &pLighting1Defaults, &pLighting2Defaults );
1012
1013     const com::sun::star::uno::Any* pAny;
1014
1015     int nFinalDirection = -1;
1016     bool bHasCustomShape = false;
1017
1018     for(size_t i=0; i<nCount; ++i)
1019     {
1020         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1021         if( pObj->ISA(SdrObjCustomShape) )
1022         {
1023             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
1024
1025             // see if this is an extruded customshape
1026             if( !bHasCustomShape )
1027             {
1028                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
1029                 if( pAny_ )
1030                     *pAny_ >>= bHasCustomShape;
1031
1032                 if( !bHasCustomShape )
1033                     continue;
1034             }
1035
1036             Direction3D aFirstLightDirection( 50000, 0, 10000 );
1037             Direction3D aSecondLightDirection( -50000, 0, 10000 );
1038
1039             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sFirstLightDirection );
1040             if( pAny )
1041                 *pAny >>= aFirstLightDirection;
1042
1043             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sSecondLightDirection );
1044             if( pAny )
1045                 *pAny >>= aSecondLightDirection;
1046
1047             int nDirection = -1;
1048
1049             int j;
1050             for( j = 0; j < 9; j++ )
1051             {
1052                 if( compare_direction( aFirstLightDirection, pLighting1Defaults[j] ) &&
1053                     compare_direction( aSecondLightDirection, pLighting2Defaults[j] ))
1054                 {
1055                     nDirection = j;
1056                     break;
1057                 }
1058             }
1059
1060             if( nFinalDirection == -1 )
1061             {
1062                 nFinalDirection = nDirection;
1063             }
1064             else if( nDirection != nFinalDirection )
1065             {
1066                 nFinalDirection = -1;
1067             }
1068
1069             if( nFinalDirection == -1 )
1070                 break;
1071         }
1072     }
1073
1074     if( bHasCustomShape )
1075         rSet.Put( SfxInt32Item( SID_EXTRUSION_LIGHTING_DIRECTION, (sal_Int32)nFinalDirection ) );
1076     else
1077         rSet.DisableItem( SID_EXTRUSION_LIGHTING_DIRECTION );
1078 }
1079
1080 void getExtrusionLightingIntensityState( SdrView* pSdrView, SfxItemSet& rSet )
1081 {
1082     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
1083     const size_t nCount = rMarkList.GetMarkCount();
1084
1085     static const char  sExtrusion[] = "Extrusion";
1086     static const char  sBrightness[] = "Brightness";
1087
1088     const com::sun::star::uno::Any* pAny;
1089
1090     int nFinalLevel = -1;
1091     bool bHasCustomShape = false;
1092
1093     for(size_t i=0; i<nCount; ++i)
1094     {
1095         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1096         if( pObj->ISA(SdrObjCustomShape) )
1097         {
1098             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
1099
1100             // see if this is an extruded customshape
1101             if( !bHasCustomShape )
1102             {
1103                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
1104                 if( pAny_ )
1105                     *pAny_ >>= bHasCustomShape;
1106
1107                 if( !bHasCustomShape )
1108                     continue;
1109             }
1110
1111             double fBrightness = 22178.0 / 655.36;
1112             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sBrightness );
1113             if( pAny )
1114                 *pAny >>= fBrightness;
1115
1116             int nLevel;
1117             if( fBrightness >= 30.0 )
1118             {
1119                 nLevel = 0; // Bright
1120             }
1121             else if( fBrightness >= 10.0 )
1122             {
1123                 nLevel = 1; // Noraml;
1124             }
1125             else
1126             {
1127                 nLevel = 2; // Dim
1128             }
1129
1130             if( nFinalLevel == -1 )
1131             {
1132                 nFinalLevel = nLevel;
1133             }
1134             else if( nFinalLevel != nLevel )
1135             {
1136                 nFinalLevel = -1;
1137                 break;
1138             }
1139         }
1140     }
1141
1142     if( bHasCustomShape )
1143         rSet.Put( SfxInt32Item( SID_EXTRUSION_LIGHTING_INTENSITY, nFinalLevel ) );
1144     else
1145         rSet.DisableItem( SID_EXTRUSION_LIGHTING_INTENSITY );
1146 }
1147
1148 void getExtrusionColorState( SdrView* pSdrView, SfxItemSet& rSet )
1149 {
1150     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
1151     const size_t nCount = rMarkList.GetMarkCount();
1152
1153     static const char  sExtrusion[] = "Extrusion";
1154     static const char  sExtrusionColor[] = "Color";
1155
1156     const com::sun::star::uno::Any* pAny;
1157
1158     bool bInit = false;
1159     bool bAmbigius = false;
1160     Color aFinalColor;
1161     bool bHasCustomShape = false;
1162
1163     for(size_t i=0; i<nCount; ++i)
1164     {
1165         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1166         if( pObj->ISA(SdrObjCustomShape) )
1167         {
1168             const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY )) );
1169
1170             // see if this is an extruded customshape
1171             if( !bHasCustomShape )
1172             {
1173                 const Any* pAny_ = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
1174                 if( pAny_ )
1175                     *pAny_ >>= bHasCustomShape;
1176
1177                 if( !bHasCustomShape )
1178                     continue;
1179             }
1180
1181             Color aColor;
1182
1183             bool bUseColor = false;
1184             pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusionColor );
1185             if( pAny )
1186                 *pAny >>= bUseColor;
1187
1188             if( bUseColor )
1189             {
1190                 const XSecondaryFillColorItem& rItem = *static_cast<const XSecondaryFillColorItem*>(&(pObj->GetMergedItem( XATTR_SECONDARYFILLCOLOR )));
1191                 aColor = rItem.GetColorValue();
1192             }
1193             else
1194             {
1195                 aColor = COL_AUTO;
1196             }
1197
1198             if( !bInit )
1199             {
1200                 aFinalColor = aColor;
1201                 bInit = true;
1202             }
1203             else if( aFinalColor != aColor )
1204             {
1205                 bAmbigius = true;
1206                 break;
1207             }
1208         }
1209     }
1210
1211     if( bAmbigius )
1212         aFinalColor = COL_AUTO;
1213
1214     if( bHasCustomShape )
1215         rSet.Put( SvxColorItem( aFinalColor, SID_EXTRUSION_3D_COLOR ) );
1216     else
1217         rSet.DisableItem( SID_EXTRUSION_3D_COLOR );
1218 }
1219
1220 namespace svx {
1221 bool checkForSelectedCustomShapes( SdrView* pSdrView, bool bOnlyExtruded )
1222 {
1223     static const char  sExtrusion[] = "Extrusion";
1224
1225     const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
1226     const size_t nCount = rMarkList.GetMarkCount();
1227     bool bFound = false;
1228
1229     for(size_t i=0;(i<nCount) && !bFound ; ++i)
1230     {
1231         SdrObject* pObj = rMarkList.GetMark(i)->GetMarkedSdrObj();
1232         if( pObj->ISA(SdrObjCustomShape) )
1233         {
1234             if( bOnlyExtruded )
1235             {
1236                 const SdrCustomShapeGeometryItem aGeometryItem( static_cast<const SdrCustomShapeGeometryItem&>(pObj->GetMergedItem( SDRATTR_CUSTOMSHAPE_GEOMETRY ) ));
1237                 const Any* pAny = aGeometryItem.GetPropertyValueByName( sExtrusion, sExtrusion );
1238                 if( pAny )
1239                     *pAny >>= bFound;
1240             }
1241             else
1242             {
1243                 bFound = true;
1244             }
1245         }
1246     }
1247
1248     return bFound;
1249 }
1250 }
1251
1252 void ExtrusionBar::getState( SdrView* pSdrView, SfxItemSet& rSet )
1253 {
1254     if (rSet.GetItemState(SID_EXTRUSION_DIRECTION) != SfxItemState::UNKNOWN)
1255     {
1256         getExtrusionDirectionState( pSdrView, rSet );
1257     }
1258     if (rSet.GetItemState(SID_EXTRUSION_PROJECTION) != SfxItemState::UNKNOWN)
1259     {
1260         getExtrusionProjectionState( pSdrView, rSet );
1261     }
1262     const bool bOnlyExtrudedCustomShapes =
1263         checkForSelectedCustomShapes( pSdrView, true );
1264     if (rSet.GetItemState(SID_EXTRUSION_TILT_DOWN) != SfxItemState::UNKNOWN)
1265     {
1266         if (! bOnlyExtrudedCustomShapes)
1267             rSet.DisableItem( SID_EXTRUSION_TILT_DOWN );
1268     }
1269     if (rSet.GetItemState(SID_EXTRUSION_TILT_DOWN) != SfxItemState::UNKNOWN)
1270     {
1271         if (! bOnlyExtrudedCustomShapes)
1272             rSet.DisableItem( SID_EXTRUSION_TILT_DOWN );
1273     }
1274     if (rSet.GetItemState(SID_EXTRUSION_TILT_UP) != SfxItemState::UNKNOWN)
1275     {
1276         if (! bOnlyExtrudedCustomShapes)
1277             rSet.DisableItem( SID_EXTRUSION_TILT_UP );
1278     }
1279     if (rSet.GetItemState(SID_EXTRUSION_TILT_LEFT) != SfxItemState::UNKNOWN)
1280     {
1281         if (! bOnlyExtrudedCustomShapes)
1282             rSet.DisableItem( SID_EXTRUSION_TILT_LEFT );
1283     }
1284     if (rSet.GetItemState(SID_EXTRUSION_TILT_RIGHT) != SfxItemState::UNKNOWN)
1285     {
1286         if (! bOnlyExtrudedCustomShapes)
1287             rSet.DisableItem( SID_EXTRUSION_TILT_RIGHT );
1288     }
1289     if (rSet.GetItemState(SID_EXTRUSION_3D_COLOR) != SfxItemState::UNKNOWN)
1290     {
1291         if (! bOnlyExtrudedCustomShapes)
1292             rSet.DisableItem( SID_EXTRUSION_3D_COLOR );
1293     }
1294     if (rSet.GetItemState(SID_EXTRUSION_DEPTH_FLOATER) != SfxItemState::UNKNOWN)
1295     {
1296         if (! bOnlyExtrudedCustomShapes)
1297             rSet.DisableItem( SID_EXTRUSION_DEPTH_FLOATER );
1298     }
1299     if (rSet.GetItemState(SID_EXTRUSION_DIRECTION_FLOATER) != SfxItemState::UNKNOWN)
1300     {
1301         if (! bOnlyExtrudedCustomShapes)
1302             rSet.DisableItem( SID_EXTRUSION_DIRECTION_FLOATER );
1303     }
1304     if (rSet.GetItemState(SID_EXTRUSION_LIGHTING_FLOATER) != SfxItemState::UNKNOWN)
1305     {
1306         if (! bOnlyExtrudedCustomShapes)
1307             rSet.DisableItem( SID_EXTRUSION_LIGHTING_FLOATER );
1308     }
1309     if (rSet.GetItemState(SID_EXTRUSION_SURFACE_FLOATER) != SfxItemState::UNKNOWN)
1310     {
1311         if(! bOnlyExtrudedCustomShapes)
1312             rSet.DisableItem( SID_EXTRUSION_SURFACE_FLOATER );
1313     }
1314     if (rSet.GetItemState(SID_EXTRUSION_TOOGLE) != SfxItemState::UNKNOWN)
1315     {
1316         if( !checkForSelectedCustomShapes( pSdrView, false ) )
1317             rSet.DisableItem( SID_EXTRUSION_TOOGLE );
1318     }
1319     if (rSet.GetItemState(SID_EXTRUSION_DEPTH) != SfxItemState::UNKNOWN)
1320     {
1321         getExtrusionDepthState( pSdrView, rSet );
1322     }
1323     if (rSet.GetItemState(SID_EXTRUSION_SURFACE) != SfxItemState::UNKNOWN)
1324     {
1325         getExtrusionSurfaceState( pSdrView, rSet );
1326     }
1327     if (rSet.GetItemState(SID_EXTRUSION_LIGHTING_INTENSITY) != SfxItemState::UNKNOWN)
1328     {
1329         getExtrusionLightingIntensityState( pSdrView, rSet );
1330     }
1331
1332     if (rSet.GetItemState(SID_EXTRUSION_LIGHTING_DIRECTION) != SfxItemState::UNKNOWN)
1333     {
1334         getExtrusionLightingDirectionState( pSdrView, rSet );
1335     }
1336
1337     if (rSet.GetItemState(SID_EXTRUSION_3D_COLOR) != SfxItemState::UNKNOWN)
1338     {
1339         getExtrusionColorState( pSdrView, rSet );
1340     }
1341 }
1342
1343 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */