svx/source/dialog/dlgctl3d.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 <svx/dlgctl3d.hxx>
  22 #include <svx/dialogs.hrc>
  23 #include <svx/view3d.hxx>
  24 #include <svx/fmmodel.hxx>
  25 #include <svl/itempool.hxx>
  26 #include <svx/fmpage.hxx>
  27 #include <svx/polysc3d.hxx>
  28 #include <svx/sphere3d.hxx>
  29 #include <svx/cube3d.hxx>
  30 #include <vcl/svapp.hxx>
  31 #include <vcl/builder.hxx>
  32 #include <svx/helperhittest3d.hxx>
  33 #include <basegfx/polygon/b2dpolygontools.hxx>
  34 #include <polygn3d.hxx>
  35 #include <svx/xlnclit.hxx>
  36 #include <svx/xlnwtit.hxx>
  37 #include "helpid.hrc"
  38 #include <algorithm>
  39 #include <svx/dialmgr.hxx>
  40 #include <vcl/settings.hxx>
  41
  42
  43
  44 Svx3DPreviewControl::Svx3DPreviewControl(Window* pParent, const ResId& rResId)
  45 :   Control(pParent, rResId),
  46     mpModel(0),
  47     mpFmPage(0),
  48     mp3DView(0),
  49     mpScene(0),
  50     mp3DObj(0),
  51     mnObjectType(PREVIEW_OBJECTTYPE_SPHERE)
  52 {
  53     Construct();
  54
  55     // do not paint background self, DrawingLayer paints this buffered and as page
  56     SetControlBackground();
  57     SetBackground();
  58 }
  59
  60 Svx3DPreviewControl::Svx3DPreviewControl(Window* pParent, WinBits nStyle)
  61 :   Control(pParent, nStyle),
  62     mpModel(0),
  63     mpFmPage(0),
  64     mp3DView(0),
  65     mpScene(0),
  66     mp3DObj(0),
  67     mnObjectType(PREVIEW_OBJECTTYPE_SPHERE)
  68 {
  69     Construct();
  70
  71     // do not paint background self, DrawingLayer paints this buffered and as page
  72     SetControlBackground();
  73     SetBackground();
  74 }
  75
  76 Svx3DPreviewControl::~Svx3DPreviewControl()
  77 {
  78     delete mp3DView;
  79     delete mpModel;
  80 }
  81
  82 void Svx3DPreviewControl::Construct()
  83 {
  84     // Do never mirror the preview window.  This explicitly includes right
  85     // to left writing environments.
  86     EnableRTL (false);
  87     SetMapMode( MAP_100TH_MM );
  88
  89     // Model
  90     mpModel = new FmFormModel();
  91     mpModel->GetItemPool().FreezeIdRanges();
  92
  93     // Page
  94     mpFmPage = new FmFormPage( *mpModel );
  95     mpModel->InsertPage( mpFmPage, 0 );
  96
  97     // 3D View
  98     mp3DView = new E3dView( mpModel, this );
  99     mp3DView->SetBufferedOutputAllowed(true);
 100     mp3DView->SetBufferedOverlayAllowed(true);
 101
 102     // 3D Scene
 103     mpScene = new E3dPolyScene(mp3DView->Get3DDefaultAttributes());
 104
 105     // initially create object
 106     SetObjectType(PREVIEW_OBJECTTYPE_SPHERE);
 107
 108     // camera and perspective
 109     Camera3D& rCamera  = (Camera3D&) mpScene->GetCamera();
 110     const basegfx::B3DRange& rVolume = mpScene->GetBoundVolume();
 111     double fW = rVolume.getWidth();
 112     double fH = rVolume.getHeight();
 113     double fCamZ = rVolume.getMaxZ() + ((fW + fH) / 2.0);
 114
 115     rCamera.SetAutoAdjustProjection(false);
 116     rCamera.SetViewWindow(- fW / 2, - fH / 2, fW, fH);
 117     basegfx::B3DPoint aLookAt;
 118     double fDefaultCamPosZ = mp3DView->GetDefaultCamPosZ();
 119     basegfx::B3DPoint aCamPos(0.0, 0.0, fCamZ < fDefaultCamPosZ ? fDefaultCamPosZ : fCamZ);
 120     rCamera.SetPosAndLookAt(aCamPos, aLookAt);
 121     double fDefaultCamFocal = mp3DView->GetDefaultCamFocal();
 122     rCamera.SetFocalLength(fDefaultCamFocal);
 123     rCamera.SetDefaults(basegfx::B3DPoint(0.0, 0.0, fDefaultCamPosZ), aLookAt, fDefaultCamFocal);
 124
 125     mpScene->SetCamera( rCamera );
 126     mpFmPage->InsertObject( mpScene );
 127
 128     basegfx::B3DHomMatrix aRotation;
 129     aRotation.rotate(DEG2RAD( 25 ), 0.0, 0.0);
 130     aRotation.rotate(0.0, DEG2RAD( 40 ), 0.0);
 131     mpScene->SetTransform(aRotation * mpScene->GetTransform());
 132
 133     // invalidate SnapRects of objects
 134     mpScene->SetRectsDirty();
 135
 136     SfxItemSet aSet( mpModel->GetItemPool(),
 137         XATTR_LINESTYLE, XATTR_LINESTYLE,
 138         XATTR_FILL_FIRST, XATTR_FILLBITMAP,
 139         0, 0 );
 140     aSet.Put( XLineStyleItem( XLINE_NONE ) );
 141     aSet.Put( XFillStyleItem( XFILL_SOLID ) );
 142     aSet.Put( XFillColorItem( "", Color( COL_WHITE ) ) );
 143
 144     mpScene->SetMergedItemSet(aSet);
 145
 146     // PageView
 147     SdrPageView* pPageView = mp3DView->ShowSdrPage( mpFmPage );
 148     mp3DView->hideMarkHandles();
 149
 150     // mark scene
 151     mp3DView->MarkObj( mpScene, pPageView );
 152 }
 153
 154 void Svx3DPreviewControl::Resize()
 155 {
 156     // size of page
 157     Size aSize( GetSizePixel() );
 158     aSize = PixelToLogic( aSize );
 159     mpFmPage->SetSize( aSize );
 160
 161     // set size
 162     Size aObjSize( aSize.Width()*5/6, aSize.Height()*5/6 );
 163     Point aObjPoint( (aSize.Width() - aObjSize.Width()) / 2,
 164         (aSize.Height() - aObjSize.Height()) / 2);
 165     Rectangle aRect( aObjPoint, aObjSize);
 166     mpScene->SetSnapRect( aRect );
 167 }
 168
 169 void Svx3DPreviewControl::Paint(const Rectangle& rRect)
 170 {
 171     mp3DView->CompleteRedraw(this, Region(rRect));
 172 }
 173
 174 void Svx3DPreviewControl::MouseButtonDown(const MouseEvent& rMEvt)
 175 {
 176     Control::MouseButtonDown(rMEvt);
 177
 178     if( rMEvt.IsShift() && rMEvt.IsMod1() )
 179     {
 180         if(PREVIEW_OBJECTTYPE_SPHERE == GetObjectType())
 181         {
 182             SetObjectType(PREVIEW_OBJECTTYPE_CUBE);
 183         }
 184         else
 185         {
 186             SetObjectType(PREVIEW_OBJECTTYPE_SPHERE);
 187         }
 188     }
 189 }
 190
 191 void Svx3DPreviewControl::SetObjectType(sal_uInt16 nType)
 192 {
 193     if( mnObjectType != nType || !mp3DObj)
 194     {
 195         SfxItemSet aSet(mpModel->GetItemPool(), SDRATTR_START, SDRATTR_END, 0, 0);
 196         mnObjectType = nType;
 197
 198         if( mp3DObj )
 199         {
 200             aSet.Put(mp3DObj->GetMergedItemSet());
 201             mpScene->Remove3DObj( mp3DObj );
 202             delete mp3DObj;
 203             mp3DObj = NULL;
 204         }
 205
 206         switch( nType )
 207         {
 208             case PREVIEW_OBJECTTYPE_SPHERE:
 209             {
 210                 mp3DObj = new E3dSphereObj(
 211                     mp3DView->Get3DDefaultAttributes(),
 212                     basegfx::B3DPoint( 0, 0, 0 ),
 213                     basegfx::B3DVector( 5000, 5000, 5000 ));
 214             }
 215             break;
 216
 217             case PREVIEW_OBJECTTYPE_CUBE:
 218             {
 219                 mp3DObj = new E3dCubeObj(
 220                     mp3DView->Get3DDefaultAttributes(),
 221                     basegfx::B3DPoint( -2500, -2500, -2500 ),
 222                     basegfx::B3DVector( 5000, 5000, 5000 ));
 223             }
 224             break;
 225         }
 226
 227         mpScene->Insert3DObj( mp3DObj );
 228         mp3DObj->SetMergedItemSet(aSet);
 229
 230         Resize();
 231     }
 232 }
 233
 234 SfxItemSet Svx3DPreviewControl::Get3DAttributes() const
 235 {
 236     return mp3DObj->GetMergedItemSet();
 237 }
 238
 239 void Svx3DPreviewControl::Set3DAttributes( const SfxItemSet& rAttr )
 240 {
 241     mp3DObj->SetMergedItemSet(rAttr, true);
 242     Resize();
 243 }
 244
 245
 246
 247 #define RADIUS_LAMP_PREVIEW_SIZE    (4500.0)
 248 #define RADIUS_LAMP_SMALL           (600.0)
 249 #define RADIUS_LAMP_BIG             (1000.0)
 250 #define NO_LIGHT_SELECTED           (0xffffffff)
 251 #define MAX_NUMBER_LIGHTS              (8)
 252
 253 Svx3DLightControl::Svx3DLightControl(Window* pParent, WinBits nStyle)
 254 :   Svx3DPreviewControl(pParent, nStyle),
 255     maUserInteractiveChangeCallback(),
 256     maUserSelectionChangeCallback(),
 257     maChangeCallback(),
 258     maSelectionChangeCallback(),
 259     maSelectedLight(NO_LIGHT_SELECTED),
 260     mpExpansionObject(0),
 261     mpLampBottomObject(0),
 262     mpLampShaftObject(0),
 263     maLightObjects(MAX_NUMBER_LIGHTS, (E3dObject*)0),
 264     mfRotateX(-20.0),
 265     mfRotateY(45.0),
 266     mfRotateZ(0.0),
 267     maActionStartPoint(),
 268     mnInteractionStartDistance(5 * 5 * 2),
 269     mfSaveActionStartHor(0.0),
 270     mfSaveActionStartVer(0.0),
 271     mfSaveActionStartRotZ(0.0),
 272     mbMouseMoved(false),
 273     mbGeometrySelected(false)
 274 {
 275     Construct2();
 276 }
 277
 278 Svx3DLightControl::~Svx3DLightControl()
 279 {
 280     // SdrObjects like mpExpansionObject and mpLampBottomObject/mpLampShaftObject get deleted
 281     // with deletion of the DrawingLayer and model
 282 }
 283
 284 void Svx3DLightControl::Construct2()
 285 {
 286     {
 287         // hide all page stuff, use control background (normally gray)
 288         const Color aDialogColor(Application::GetSettings().GetStyleSettings().GetDialogColor());
 289         mp3DView->SetPageVisible(false);
 290         mp3DView->SetApplicationBackgroundColor(aDialogColor);
 291         mp3DView->SetApplicationDocumentColor(aDialogColor);
 292     }
 293
 294     {
 295         // create invisible expansion object
 296         const double fMaxExpansion(RADIUS_LAMP_BIG + RADIUS_LAMP_PREVIEW_SIZE);
 297         mpExpansionObject = new E3dCubeObj(
 298             mp3DView->Get3DDefaultAttributes(),
 299             basegfx::B3DPoint(-fMaxExpansion, -fMaxExpansion, -fMaxExpansion),
 300             basegfx::B3DVector(2.0 * fMaxExpansion, 2.0 * fMaxExpansion, 2.0 * fMaxExpansion));
 301         mpScene->Insert3DObj( mpExpansionObject );
 302         SfxItemSet aSet(mpModel->GetItemPool());
 303         aSet.Put( XLineStyleItem( XLINE_NONE ) );
 304         aSet.Put( XFillStyleItem( XFILL_NONE ) );
 305         mpExpansionObject->SetMergedItemSet(aSet);
 306     }
 307
 308     {
 309         // create lamp control object (Yellow lined object)
 310         // base circle
 311         const basegfx::B2DPolygon a2DCircle(basegfx::tools::createPolygonFromCircle(basegfx::B2DPoint(0.0, 0.0), RADIUS_LAMP_PREVIEW_SIZE));
 312         basegfx::B3DPolygon a3DCircle(basegfx::tools::createB3DPolygonFromB2DPolygon(a2DCircle));
 313         basegfx::B3DHomMatrix aTransform;
 314
 315         aTransform.rotate(F_PI2, 0.0, 0.0);
 316         aTransform.translate(0.0, -RADIUS_LAMP_PREVIEW_SIZE, 0.0);
 317         a3DCircle.transform(aTransform);
 318
 319         // create object for it
 320         mpLampBottomObject = new E3dPolygonObj(
 321             mp3DView->Get3DDefaultAttributes(),
 322             basegfx::B3DPolyPolygon(a3DCircle),
 323             true);
 324         mpScene->Insert3DObj( mpLampBottomObject );
 325
 326         // half circle with stand
 327         basegfx::B2DPolygon a2DHalfCircle;
 328         a2DHalfCircle.append(basegfx::B2DPoint(RADIUS_LAMP_PREVIEW_SIZE, 0.0));
 329         a2DHalfCircle.append(basegfx::B2DPoint(RADIUS_LAMP_PREVIEW_SIZE, -RADIUS_LAMP_PREVIEW_SIZE));
 330         a2DHalfCircle.append(basegfx::tools::createPolygonFromEllipseSegment(
 331             basegfx::B2DPoint(0.0, 0.0), RADIUS_LAMP_PREVIEW_SIZE, RADIUS_LAMP_PREVIEW_SIZE, F_2PI - F_PI2, F_PI2));
 332         basegfx::B3DPolygon a3DHalfCircle(basegfx::tools::createB3DPolygonFromB2DPolygon(a2DHalfCircle));
 333
 334         // create object for it
 335         mpLampShaftObject = new E3dPolygonObj(
 336             mp3DView->Get3DDefaultAttributes(),
 337             basegfx::B3DPolyPolygon(a3DHalfCircle),
 338             true);
 339         mpScene->Insert3DObj( mpLampShaftObject );
 340
 341         // initially invisible
 342         SfxItemSet aSet(mpModel->GetItemPool());
 343         aSet.Put( XLineStyleItem( XLINE_NONE ) );
 344         aSet.Put( XFillStyleItem( XFILL_NONE ) );
 345
 346         mpLampBottomObject->SetMergedItemSet(aSet);
 347         mpLampShaftObject->SetMergedItemSet(aSet);
 348     }
 349
 350     {
 351         // change camera settings
 352         Camera3D& rCamera  = (Camera3D&) mpScene->GetCamera();
 353         const basegfx::B3DRange& rVolume = mpScene->GetBoundVolume();
 354         double fW = rVolume.getWidth();
 355         double fH = rVolume.getHeight();
 356         double fCamZ = rVolume.getMaxZ() + ((fW + fH) / 2.0);
 357
 358         rCamera.SetAutoAdjustProjection(false);
 359         rCamera.SetViewWindow(- fW / 2, - fH / 2, fW, fH);
 360         basegfx::B3DPoint aLookAt;
 361         double fDefaultCamPosZ = mp3DView->GetDefaultCamPosZ();
 362         basegfx::B3DPoint aCamPos(0.0, 0.0, fCamZ < fDefaultCamPosZ ? fDefaultCamPosZ : fCamZ);
 363         rCamera.SetPosAndLookAt(aCamPos, aLookAt);
 364         double fDefaultCamFocal = mp3DView->GetDefaultCamFocal();
 365         rCamera.SetFocalLength(fDefaultCamFocal);
 366         rCamera.SetDefaults(basegfx::B3DPoint(0.0, 0.0, fDefaultCamPosZ), aLookAt, fDefaultCamFocal);
 367
 368         mpScene->SetCamera( rCamera );
 369
 370         basegfx::B3DHomMatrix aNeutral;
 371         mpScene->SetTransform(aNeutral);
 372     }
 373
 374     // invalidate SnapRects of objects
 375     mpScene->SetRectsDirty();
 376 }
 377
 378 void Svx3DLightControl::ConstructLightObjects()
 379 {
 380     for(sal_uInt32 a(0); a < MAX_NUMBER_LIGHTS; a++)
 381     {
 382         // get rid of possible existing light object
 383         if(maLightObjects[a])
 384         {
 385             mpScene->Remove3DObj(maLightObjects[a]);
 386             delete maLightObjects[a];
 387             maLightObjects[a] = 0;
 388         }
 389
 390         if(GetLightOnOff(a))
 391         {
 392             const bool bIsSelectedLight(a == maSelectedLight);
 393             basegfx::B3DVector aDirection(GetLightDirection(a));
 394             aDirection.normalize();
 395             aDirection *= RADIUS_LAMP_PREVIEW_SIZE;
 396
 397             const double fLampSize(bIsSelectedLight ? RADIUS_LAMP_BIG : RADIUS_LAMP_SMALL);
 398             E3dObject* pNewLight = new E3dSphereObj(
 399                 mp3DView->Get3DDefaultAttributes(),
 400                 basegfx::B3DPoint( 0, 0, 0 ),
 401                 basegfx::B3DVector( fLampSize, fLampSize, fLampSize));
 402             mpScene->Insert3DObj(pNewLight);
 403
 404             basegfx::B3DHomMatrix aTransform;
 405             aTransform.translate(aDirection.getX(), aDirection.getY(), aDirection.getZ());
 406             pNewLight->SetTransform(aTransform);
 407
 408             SfxItemSet aSet(mpModel->GetItemPool());
 409             aSet.Put( XLineStyleItem( XLINE_NONE ) );
 410             aSet.Put( XFillStyleItem( XFILL_SOLID ) );
 411             aSet.Put( XFillColorItem(OUString(), GetLightColor(a)));
 412             pNewLight->SetMergedItemSet(aSet);
 413
 414             maLightObjects[a] = pNewLight;
 415         }
 416     }
 417 }
 418
 419 void Svx3DLightControl::AdaptToSelectedLight()
 420 {
 421     if(NO_LIGHT_SELECTED == maSelectedLight)
 422     {
 423         // make mpLampBottomObject/mpLampShaftObject invisible
 424         SfxItemSet aSet(mpModel->GetItemPool());
 425         aSet.Put( XLineStyleItem( XLINE_NONE ) );
 426         aSet.Put( XFillStyleItem( XFILL_NONE ) );
 427         mpLampBottomObject->SetMergedItemSet(aSet);
 428         mpLampShaftObject->SetMergedItemSet(aSet);
 429     }
 430     else
 431     {
 432         basegfx::B3DVector aDirection(GetLightDirection(maSelectedLight));
 433         aDirection.normalize();
 434
 435         // make mpLampBottomObject/mpLampShaftObject visible (yellow hairline)
 436         SfxItemSet aSet(mpModel->GetItemPool());
 437         aSet.Put( XLineStyleItem( XLINE_SOLID ) );
 438         aSet.Put( XLineColorItem(OUString(), COL_YELLOW));
 439         aSet.Put( XLineWidthItem(0));
 440         aSet.Put( XFillStyleItem( XFILL_NONE ) );
 441         mpLampBottomObject->SetMergedItemSet(aSet);
 442         mpLampShaftObject->SetMergedItemSet(aSet);
 443
 444         // adapt transformation of mpLampShaftObject
 445         basegfx::B3DHomMatrix aTransform;
 446         double fRotateY(0.0);
 447
 448         if(!basegfx::fTools::equalZero(aDirection.getZ()) || !basegfx::fTools::equalZero(aDirection.getX()))
 449         {
 450             fRotateY = atan2(-aDirection.getZ(), aDirection.getX());
 451         }
 452
 453         aTransform.rotate(0.0, fRotateY, 0.0);
 454         mpLampShaftObject->SetTransform(aTransform);
 455
 456         // adapt transformation of selected light
 457         E3dObject* pSelectedLight = maLightObjects[sal_Int32(maSelectedLight)];
 458
 459         if(pSelectedLight)
 460         {
 461             aTransform.identity();
 462             aTransform.translate(
 463                 aDirection.getX() * RADIUS_LAMP_PREVIEW_SIZE,
 464                 aDirection.getY() * RADIUS_LAMP_PREVIEW_SIZE,
 465                 aDirection.getZ() * RADIUS_LAMP_PREVIEW_SIZE);
 466             pSelectedLight->SetTransform(aTransform);
 467         }
 468     }
 469 }
 470
 471 void Svx3DLightControl::TrySelection(Point aPosPixel)
 472 {
 473     if(mpScene)
 474     {
 475         const Point aPosLogic(PixelToLogic(aPosPixel));
 476         const basegfx::B2DPoint aPoint(aPosLogic.X(), aPosLogic.Y());
 477         std::vector< const E3dCompoundObject* > aResult;
 478         getAllHit3DObjectsSortedFrontToBack(aPoint, *mpScene, aResult);
 479
 480         if(!aResult.empty())
 481         {
 482             // exclude expansion object which will be part of
 483             // the hits. It's invisible, but for HitTest, it's included
 484             const E3dCompoundObject* pResult = 0;
 485
 486             for(sal_uInt32 b(0); !pResult && b < aResult.size(); b++)
 487             {
 488                 if(aResult[b] && aResult[b] != mpExpansionObject)
 489                 {
 490                     pResult = aResult[b];
 491                 }
 492             }
 493
 494             if(pResult == mp3DObj)
 495             {
 496                 if(!mbGeometrySelected)
 497                 {
 498                     mbGeometrySelected = true;
 499                     maSelectedLight = NO_LIGHT_SELECTED;
 500                     ConstructLightObjects();
 501                     AdaptToSelectedLight();
 502                     Invalidate();
 503
 504                     if(maSelectionChangeCallback.IsSet())
 505                     {
 506                         maSelectionChangeCallback.Call(this);
 507                     }
 508                 }
 509             }
 510             else
 511             {
 512                 sal_uInt32 aNewSelectedLight(NO_LIGHT_SELECTED);
 513
 514                 for(sal_uInt32 a(0); a < MAX_NUMBER_LIGHTS; a++)
 515                 {
 516                     if(maLightObjects[a] && maLightObjects[a] == pResult)
 517                     {
 518                         aNewSelectedLight = a;
 519                     }
 520                 }
 521
 522                 if(aNewSelectedLight != maSelectedLight)
 523                 {
 524                     SelectLight(aNewSelectedLight);
 525
 526                     if(maSelectionChangeCallback.IsSet())
 527                     {
 528                         maSelectionChangeCallback.Call(this);
 529                     }
 530                 }
 531             }
 532         }
 533     }
 534 }
 535
 536 void Svx3DLightControl::Paint(const Rectangle& rRect)
 537 {
 538     Svx3DPreviewControl::Paint(rRect);
 539 }
 540
 541 void Svx3DLightControl::MouseButtonDown( const MouseEvent& rMEvt )
 542 {
 543     bool bCallParent(true);
 544
 545     // switch state
 546     if(rMEvt.IsLeft())
 547     {
 548         if(IsSelectionValid() || mbGeometrySelected)
 549         {
 550             mbMouseMoved = false;
 551             bCallParent = false;
 552             maActionStartPoint = rMEvt.GetPosPixel();
 553             StartTracking();
 554         }
 555         else
 556         {
 557             // Single click without moving much trying to do a selection
 558             TrySelection(rMEvt.GetPosPixel());
 559             bCallParent = false;
 560         }
 561     }
 562
 563     // call parent
 564     if(bCallParent)
 565     {
 566         Svx3DPreviewControl::MouseButtonDown(rMEvt);
 567     }
 568 }
 569
 570 void Svx3DLightControl::Tracking( const TrackingEvent& rTEvt )
 571 {
 572     if(rTEvt.IsTrackingEnded())
 573     {
 574         if(rTEvt.IsTrackingCanceled())
 575         {
 576             if(mbMouseMoved)
 577             {
 578                 // interrupt tracking
 579                 mbMouseMoved = false;
 580
 581                 if(mbGeometrySelected)
 582                 {
 583                     SetRotation(mfSaveActionStartVer, mfSaveActionStartHor, mfSaveActionStartRotZ);
 584                 }
 585                 else
 586                 {
 587                     SetPosition(mfSaveActionStartHor, mfSaveActionStartVer);
 588                 }
 589
 590                 if(maChangeCallback.IsSet())
 591                 {
 592                     maChangeCallback.Call(this);
 593                 }
 594             }
 595         }
 596         else
 597         {
 598             const MouseEvent& rMEvt = rTEvt.GetMouseEvent();
 599
 600             if(mbMouseMoved)
 601             {
 602                 // was change dinteractively
 603             }
 604             else
 605             {
 606                 // simple click without much movement, try selection
 607                 TrySelection(rMEvt.GetPosPixel());
 608             }
 609         }
 610     }
 611     else
 612     {
 613         const MouseEvent& rMEvt = rTEvt.GetMouseEvent();
 614         Point aDeltaPos = rMEvt.GetPosPixel() - maActionStartPoint;
 615
 616         if(!mbMouseMoved)
 617         {
 618             if(sal_Int32(aDeltaPos.X() * aDeltaPos.X() + aDeltaPos.Y() * aDeltaPos.Y()) > mnInteractionStartDistance)
 619             {
 620                 if(mbGeometrySelected)
 621                 {
 622                     GetRotation(mfSaveActionStartVer, mfSaveActionStartHor, mfSaveActionStartRotZ);
 623                 }
 624                 else
 625                 {
 626                     // intercation start, save values
 627                     GetPosition(mfSaveActionStartHor, mfSaveActionStartVer);
 628                 }
 629
 630                 mbMouseMoved = true;
 631             }
 632         }
 633
 634         if(mbMouseMoved)
 635         {
 636             if(mbGeometrySelected)
 637             {
 638                 double fNewRotX = mfSaveActionStartVer - ((double)aDeltaPos.Y() * F_PI180);
 639                 double fNewRotY = mfSaveActionStartHor + ((double)aDeltaPos.X() * F_PI180);
 640
 641                 // cut horizontal
 642                 while(fNewRotY < 0.0)
 643                 {
 644                     fNewRotY += F_2PI;
 645                 }
 646
 647                 while(fNewRotY >= F_2PI)
 648                 {
 649                     fNewRotY -= F_2PI;
 650                 }
 651
 652                 // cut vertical
 653                 if(fNewRotX < -F_PI2)
 654                 {
 655                     fNewRotX = -F_PI2;
 656                 }
 657
 658                 if(fNewRotX > F_PI2)
 659                 {
 660                     fNewRotX = F_PI2;
 661                 }
 662
 663                 SetRotation(fNewRotX, fNewRotY, mfSaveActionStartRotZ);
 664
 665                 if(maChangeCallback.IsSet())
 666                 {
 667                     maChangeCallback.Call(this);
 668                 }
 669             }
 670             else
 671             {
 672                 // interaction in progress
 673                 double fNewPosHor = mfSaveActionStartHor + ((double)aDeltaPos.X());
 674                 double fNewPosVer = mfSaveActionStartVer - ((double)aDeltaPos.Y());
 675
 676                 // cut horizontal
 677                 while(fNewPosHor < 0.0)
 678                 {
 679                     fNewPosHor += 360.0;
 680                 }
 681
 682                 while(fNewPosHor >= 360.0)
 683                 {
 684                     fNewPosHor -= 360.0;
 685                 }
 686
 687                 // cut vertical
 688                 if(fNewPosVer < -90.0)
 689                 {
 690                     fNewPosVer = -90.0;
 691                 }
 692
 693                 if(fNewPosVer > 90.0)
 694                 {
 695                     fNewPosVer = 90.0;
 696                 }
 697
 698                 SetPosition(fNewPosHor, fNewPosVer);
 699
 700                 if(maChangeCallback.IsSet())
 701                 {
 702                     maChangeCallback.Call(this);
 703                 }
 704             }
 705         }
 706     }
 707 }
 708
 709 void Svx3DLightControl::Resize()
 710 {
 711     // set size of page
 712     const Size aSize(PixelToLogic(GetSizePixel()));
 713     mpFmPage->SetSize(aSize);
 714
 715     // set position and size of scene
 716     mpScene->SetSnapRect(Rectangle(Point(0, 0), aSize));
 717 }
 718
 719 void Svx3DLightControl::SetObjectType(sal_uInt16 nType)
 720 {
 721     // call parent
 722     Svx3DPreviewControl::SetObjectType(nType);
 723
 724     // apply object rotation
 725     if(mp3DObj)
 726     {
 727         basegfx::B3DHomMatrix aObjectRotation;
 728         aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ);
 729         mp3DObj->SetTransform(aObjectRotation);
 730     }
 731 }
 732
 733 bool Svx3DLightControl::IsSelectionValid()
 734 {
 735     if((NO_LIGHT_SELECTED != maSelectedLight) && (GetLightOnOff(maSelectedLight)))
 736     {
 737         return true;
 738     }
 739
 740     return false;
 741 }
 742
 743 void Svx3DLightControl::GetPosition(double& rHor, double& rVer)
 744 {
 745     if(IsSelectionValid())
 746     {
 747         basegfx::B3DVector aDirection(GetLightDirection(maSelectedLight));
 748         aDirection.normalize();
 749         rHor = atan2(-aDirection.getX(), -aDirection.getZ()) + F_PI; // 0..2PI
 750         rVer = atan2(aDirection.getY(), aDirection.getXZLength()); // -PI2..PI2
 751         rHor /= F_PI180; // 0..360.0
 752         rVer /= F_PI180; // -90.0..90.0
 753     }
 754     if(IsGeometrySelected())
 755     {
 756         rHor = mfRotateY / F_PI180; // 0..360.0
 757         rVer = mfRotateX / F_PI180; // -90.0..90.0
 758     }
 759 }
 760
 761 void Svx3DLightControl::SetPosition(double fHor, double fVer)
 762 {
 763     if(IsSelectionValid())
 764     {
 765         // set selected light's direction
 766         fHor = (fHor * F_PI180) - F_PI; // -PI..PI
 767         fVer *= F_PI180; // -PI2..PI2
 768         basegfx::B3DVector aDirection(cos(fVer) * -sin(fHor), sin(fVer), cos(fVer) * -cos(fHor));
 769         aDirection.normalize();
 770
 771         if(!aDirection.equal(GetLightDirection(maSelectedLight)))
 772         {
 773             // set changed light direction at SdrScene
 774             SfxItemSet aSet(mpModel->GetItemPool());
 775
 776             switch(maSelectedLight)
 777             {
 778                 case 0: aSet.Put(Svx3DLightDirection1Item(aDirection)); break;
 779                 case 1: aSet.Put(Svx3DLightDirection2Item(aDirection)); break;
 780                 case 2: aSet.Put(Svx3DLightDirection3Item(aDirection)); break;
 781                 case 3: aSet.Put(Svx3DLightDirection4Item(aDirection)); break;
 782                 case 4: aSet.Put(Svx3DLightDirection5Item(aDirection)); break;
 783                 case 5: aSet.Put(Svx3DLightDirection6Item(aDirection)); break;
 784                 case 6: aSet.Put(Svx3DLightDirection7Item(aDirection)); break;
 785                 default:
 786                 case 7: aSet.Put(Svx3DLightDirection8Item(aDirection)); break;
 787             }
 788
 789             mpScene->SetMergedItemSet(aSet);
 790
 791             // correct 3D light's and LampFrame's geometries
 792             AdaptToSelectedLight();
 793             Invalidate();
 794         }
 795     }
 796     if(IsGeometrySelected())
 797     {
 798         if(mfRotateX != fVer || mfRotateY != fHor)
 799         {
 800             mfRotateX = fVer * F_PI180;
 801             mfRotateY = fHor * F_PI180;
 802
 803             if(mp3DObj)
 804             {
 805                 basegfx::B3DHomMatrix aObjectRotation;
 806                 aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ);
 807                 mp3DObj->SetTransform(aObjectRotation);
 808
 809                 Invalidate();
 810             }
 811         }
 812     }
 813 }
 814
 815 void Svx3DLightControl::SetRotation(double fRotX, double fRotY, double fRotZ)
 816 {
 817     if(IsGeometrySelected())
 818     {
 819         if(fRotX != mfRotateX || fRotY != mfRotateY || fRotZ != mfRotateZ)
 820         {
 821             mfRotateX = fRotX;
 822             mfRotateY = fRotY;
 823             mfRotateZ = fRotZ;
 824
 825             if(mp3DObj)
 826             {
 827                 basegfx::B3DHomMatrix aObjectRotation;
 828                 aObjectRotation.rotate(mfRotateX, mfRotateY, mfRotateZ);
 829                 mp3DObj->SetTransform(aObjectRotation);
 830
 831                 Invalidate();
 832             }
 833         }
 834     }
 835 }
 836
 837 void Svx3DLightControl::GetRotation(double& rRotX, double& rRotY, double& rRotZ)
 838 {
 839     rRotX = mfRotateX;
 840     rRotY = mfRotateY;
 841     rRotZ = mfRotateZ;
 842 }
 843
 844 void Svx3DLightControl::Set3DAttributes( const SfxItemSet& rAttr )
 845 {
 846     // call parent
 847     Svx3DPreviewControl::Set3DAttributes(rAttr);
 848
 849     if(maSelectedLight != NO_LIGHT_SELECTED && !GetLightOnOff(maSelectedLight))
 850     {
 851         // selected light is no more active, select new one
 852         maSelectedLight = NO_LIGHT_SELECTED;
 853     }
 854
 855     // local updates
 856     ConstructLightObjects();
 857     AdaptToSelectedLight();
 858     Invalidate();
 859 }
 860
 861 void Svx3DLightControl::SelectLight(sal_uInt32 nLightNumber)
 862 {
 863     if(nLightNumber > 7)
 864     {
 865         nLightNumber = NO_LIGHT_SELECTED;
 866     }
 867
 868     if(NO_LIGHT_SELECTED != nLightNumber)
 869     {
 870         if(!GetLightOnOff(nLightNumber))
 871         {
 872             nLightNumber = NO_LIGHT_SELECTED;
 873         }
 874     }
 875
 876     if(nLightNumber != maSelectedLight)
 877     {
 878         maSelectedLight = nLightNumber;
 879         mbGeometrySelected = false;
 880         ConstructLightObjects();
 881         AdaptToSelectedLight();
 882         Invalidate();
 883     }
 884 }
 885
 886 bool Svx3DLightControl::GetLightOnOff(sal_uInt32 nNum) const
 887 {
 888     if(nNum <= 7)
 889     {
 890         const SfxItemSet aLightItemSet(Get3DAttributes());
 891
 892         switch(nNum)
 893         {
 894             case 0 : return ((const Svx3DLightOnOff1Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue();
 895             case 1 : return ((const Svx3DLightOnOff2Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue();
 896             case 2 : return ((const Svx3DLightOnOff3Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue();
 897             case 3 : return ((const Svx3DLightOnOff4Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue();
 898             case 4 : return ((const Svx3DLightOnOff5Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue();
 899             case 5 : return ((const Svx3DLightOnOff6Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue();
 900             case 6 : return ((const Svx3DLightOnOff7Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue();
 901             case 7 : return ((const Svx3DLightOnOff8Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue();
 902         }
 903     }
 904
 905     return false;
 906 }
 907
 908 Color Svx3DLightControl::GetLightColor(sal_uInt32 nNum) const
 909 {
 910     if(nNum <= 7)
 911     {
 912         const SfxItemSet aLightItemSet(Get3DAttributes());
 913
 914         switch(nNum)
 915         {
 916             case 0 : return ((const Svx3DLightcolor1Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue();
 917             case 1 : return ((const Svx3DLightcolor2Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue();
 918             case 2 : return ((const Svx3DLightcolor3Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue();
 919             case 3 : return ((const Svx3DLightcolor4Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue();
 920             case 4 : return ((const Svx3DLightcolor5Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue();
 921             case 5 : return ((const Svx3DLightcolor6Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue();
 922             case 6 : return ((const Svx3DLightcolor7Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue();
 923             case 7 : return ((const Svx3DLightcolor8Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue();
 924         }
 925     }
 926
 927     return Color(COL_BLACK);
 928 }
 929
 930 basegfx::B3DVector Svx3DLightControl::GetLightDirection(sal_uInt32 nNum) const
 931 {
 932     if(nNum <= 7)
 933     {
 934         const SfxItemSet aLightItemSet(Get3DAttributes());
 935
 936         switch(nNum)
 937         {
 938             case 0 : return ((const Svx3DLightDirection1Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1)).GetValue();
 939             case 1 : return ((const Svx3DLightDirection2Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2)).GetValue();
 940             case 2 : return ((const Svx3DLightDirection3Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3)).GetValue();
 941             case 3 : return ((const Svx3DLightDirection4Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4)).GetValue();
 942             case 4 : return ((const Svx3DLightDirection5Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5)).GetValue();
 943             case 5 : return ((const Svx3DLightDirection6Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6)).GetValue();
 944             case 6 : return ((const Svx3DLightDirection7Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7)).GetValue();
 945             case 7 : return ((const Svx3DLightDirection8Item&)aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8)).GetValue();
 946         }
 947     }
 948
 949     return basegfx::B3DVector();
 950 }
 951
 952
 953
 954 SvxLightCtl3D::SvxLightCtl3D( Window* pParent, const ResId& rResId)
 955 :   Control(pParent, rResId),
 956     maLightControl(this, 0),
 957     maHorScroller(this, WB_HORZ | WB_DRAG),
 958     maVerScroller(this, WB_VERT | WB_DRAG),
 959     maSwitcher(this, 0)
 960 {
 961     // init members
 962     Init();
 963 }
 964
 965 SvxLightCtl3D::SvxLightCtl3D( Window* pParent)
 966 :   Control(pParent, WB_BORDER | WB_TABSTOP),
 967     maLightControl(this, 0),
 968     maHorScroller(this, WB_HORZ | WB_DRAG),
 969     maVerScroller(this, WB_VERT | WB_DRAG),
 970     maSwitcher(this, 0)
 971 {
 972     // init members
 973     Init();
 974 }
 975
 976 Size SvxLightCtl3D::GetOptimalSize() const
 977 {
 978     return LogicToPixel(Size(80, 100), MAP_APPFONT);
 979 }
 980
 981 extern "C" SAL_DLLPUBLIC_EXPORT Window* SAL_CALL makeSvxLightCtl3D(Window *pParent, VclBuilder::stringmap &)
 982 {
 983     return new SvxLightCtl3D(pParent);
 984 }
 985
 986
 987 void SvxLightCtl3D::Init()
 988 {
 989     // #i58240# set HelpIDs for scrollbars and switcher
 990     maHorScroller.SetHelpId(HID_CTRL3D_HSCROLL);
 991     maVerScroller.SetHelpId(HID_CTRL3D_VSCROLL);
 992     maSwitcher.SetHelpId(HID_CTRL3D_SWITCHER);
 993     maSwitcher.SetAccessibleName(SVX_RESSTR(STR_SWITCH));
 994
 995     // Light preview
 996     maLightControl.Show();
 997     maLightControl.SetChangeCallback( LINK(this, SvxLightCtl3D, InternalInteractiveChange) );
 998     maLightControl.SetSelectionChangeCallback( LINK(this, SvxLightCtl3D, InternalSelectionChange) );
 999
1000     // Horiz Scrollbar
1001     maHorScroller.Show();
1002     maHorScroller.SetRange(Range(0, 36000));
1003     maHorScroller.SetLineSize(100);
1004     maHorScroller.SetPageSize(1000);
1005     maHorScroller.SetScrollHdl( LINK(this, SvxLightCtl3D, ScrollBarMove) );
1006
1007     // Vert Scrollbar
1008     maVerScroller.Show();
1009     maVerScroller.SetRange(Range(0, 18000));
1010     maVerScroller.SetLineSize(100);
1011     maVerScroller.SetPageSize(1000);
1012     maVerScroller.SetScrollHdl( LINK(this, SvxLightCtl3D, ScrollBarMove) );
1013
1014     // Switch Button
1015     maSwitcher.Show();
1016     maSwitcher.SetClickHdl( LINK(this, SvxLightCtl3D, ButtonPress) );
1017
1018     // check selection
1019     CheckSelection();
1020
1021     // new layout
1022     NewLayout();
1023 }
1024
1025 SvxLightCtl3D::~SvxLightCtl3D()
1026 {
1027 }
1028
1029 void SvxLightCtl3D::Resize()
1030 {
1031     // call parent
1032     Control::Resize();
1033
1034     // new layout
1035     NewLayout();
1036 }
1037
1038 void SvxLightCtl3D::NewLayout()
1039 {
1040     // Layout members
1041     const Size aSize(GetOutputSizePixel());
1042     const sal_Int32 nScrollSize(maHorScroller.GetSizePixel().Height());
1043
1044     // Preview control
1045     Point aPoint(0, 0);
1046     Size aDestSize(aSize.Width() - nScrollSize, aSize.Height() - nScrollSize);
1047     maLightControl.SetPosSizePixel(aPoint, aDestSize);
1048
1049     // hor scrollbar
1050     aPoint.Y() = aSize.Height() - nScrollSize;
1051     aDestSize.Height() = nScrollSize;
1052     maHorScroller.SetPosSizePixel(aPoint, aDestSize);
1053
1054     // vert scrollbar
1055     aPoint.X() = aSize.Width() - nScrollSize;
1056     aPoint.Y() = 0;
1057     aDestSize.Width() = nScrollSize;
1058     aDestSize.Height() = aSize.Height() - nScrollSize;
1059     maVerScroller.SetPosSizePixel(aPoint, aDestSize);
1060
1061     // button
1062     aPoint.Y() = aSize.Height() - nScrollSize;
1063     aDestSize.Height() = nScrollSize;
1064     maSwitcher.SetPosSizePixel(aPoint, aDestSize);
1065 }
1066
1067 void SvxLightCtl3D::CheckSelection()
1068 {
1069     const bool bSelectionValid(maLightControl.IsSelectionValid() || maLightControl.IsGeometrySelected());
1070     maHorScroller.Enable(bSelectionValid);
1071     maVerScroller.Enable(bSelectionValid);
1072
1073     if(bSelectionValid)
1074     {
1075         double fHor, fVer;
1076         maLightControl.GetPosition(fHor, fVer);
1077         maHorScroller.SetThumbPos( sal_Int32(fHor * 100.0) );
1078         maVerScroller.SetThumbPos( 18000 - sal_Int32((fVer + 90.0) * 100.0) );
1079     }
1080 }
1081
1082 void SvxLightCtl3D::move( double fDeltaHor, double fDeltaVer )
1083 {
1084     double fHor, fVer;
1085
1086     maLightControl.GetPosition(fHor, fVer);
1087     fHor += fDeltaHor;
1088     fVer += fDeltaVer;
1089
1090     if( fVer > 90.0 )
1091         return;
1092
1093     if ( fVer < -90.0 )
1094         return;
1095
1096     maLightControl.SetPosition(fHor, fVer);
1097     maHorScroller.SetThumbPos( sal_Int32(fHor * 100.0) );
1098     maVerScroller.SetThumbPos( 18000 - sal_Int32((fVer + 90.0) * 100.0) );
1099
1100     if(maUserInteractiveChangeCallback.IsSet())
1101     {
1102         maUserInteractiveChangeCallback.Call(this);
1103     }
1104 }
1105
1106 void SvxLightCtl3D::KeyInput( const KeyEvent& rKEvt )
1107 {
1108     const KeyCode aCode(rKEvt.GetKeyCode());
1109
1110     if( aCode.GetModifier() )
1111     {
1112         Control::KeyInput( rKEvt );
1113         return;
1114     }
1115
1116     switch ( aCode.GetCode() )
1117     {
1118         case KEY_SPACE:
1119         {
1120             break;
1121         }
1122         case KEY_LEFT:
1123         {
1124             move(  -4.0,  0.0 ); // #i58242# changed move direction in X
1125             break;
1126         }
1127         case KEY_RIGHT:
1128         {
1129             move( 4.0,  0.0 ); // #i58242# changed move direction in X
1130             break;
1131         }
1132         case KEY_UP:
1133         {
1134             move(  0.0,  4.0 );
1135             break;
1136         }
1137         case KEY_DOWN:
1138         {
1139             move(  0.0, -4.0 );
1140             break;
1141         }
1142         case KEY_PAGEUP:
1143         {
1144             sal_Int32 nLight(maLightControl.GetSelectedLight() - 1);
1145
1146             while((nLight >= 0) && !maLightControl.GetLightOnOff(nLight))
1147             {
1148                 nLight--;
1149             }
1150
1151             if(nLight < 0)
1152             {
1153                 nLight = 7;
1154
1155                 while((nLight >= 0) && !maLightControl.GetLightOnOff(nLight))
1156                 {
1157                     nLight--;
1158                 }
1159             }
1160
1161             if(nLight >= 0)
1162             {
1163                 maLightControl.SelectLight(nLight);
1164                 CheckSelection();
1165
1166                 if(maUserSelectionChangeCallback.IsSet())
1167                 {
1168                     maUserSelectionChangeCallback.Call(this);
1169                 }
1170             }
1171
1172             break;
1173         }
1174         case KEY_PAGEDOWN:
1175         {
1176             sal_Int32 nLight(maLightControl.GetSelectedLight() - 1);
1177
1178             while(nLight <= 7 && !maLightControl.GetLightOnOff(nLight))
1179             {
1180                 nLight++;
1181             }
1182
1183             if(nLight > 7)
1184             {
1185                 nLight = 0;
1186
1187                 while(nLight <= 7 && !maLightControl.GetLightOnOff(nLight))
1188                 {
1189                     nLight++;
1190                 }
1191             }
1192
1193             if(nLight <= 7)
1194             {
1195                 maLightControl.SelectLight(nLight);
1196                 CheckSelection();
1197
1198                 if(maUserSelectionChangeCallback.IsSet())
1199                 {
1200                     maUserSelectionChangeCallback.Call(this);
1201                 }
1202             }
1203
1204             break;
1205         }
1206         default:
1207         {
1208             Control::KeyInput( rKEvt );
1209             break;
1210         }
1211     }
1212 }
1213
1214 void SvxLightCtl3D::GetFocus()
1215 {
1216     Control::GetFocus();
1217
1218     if(HasFocus() && IsEnabled())
1219     {
1220         CheckSelection();
1221
1222         Size aFocusSize = maLightControl.GetOutputSizePixel();
1223
1224         aFocusSize.Width() -= 4;
1225         aFocusSize.Height() -= 4;
1226
1227         Rectangle aFocusRect( Point( 2, 2 ), aFocusSize );
1228
1229         aFocusRect = maLightControl.PixelToLogic( aFocusRect );
1230
1231         maLightControl.ShowFocus( aFocusRect );
1232     }
1233 }
1234
1235 void SvxLightCtl3D::LoseFocus()
1236 {
1237     Control::LoseFocus();
1238
1239     maLightControl.HideFocus();
1240 }
1241
1242 IMPL_LINK_NOARG(SvxLightCtl3D, ScrollBarMove)
1243 {
1244     const sal_Int32 nHor(maHorScroller.GetThumbPos());
1245     const sal_Int32 nVer(maVerScroller.GetThumbPos());
1246
1247     maLightControl.SetPosition(
1248         ((double)nHor) / 100.0,
1249         ((double)((18000 - nVer) - 9000)) / 100.0);
1250
1251     if(maUserInteractiveChangeCallback.IsSet())
1252     {
1253         maUserInteractiveChangeCallback.Call(this);
1254     }
1255
1256     return 0;
1257 }
1258
1259 IMPL_LINK_NOARG(SvxLightCtl3D, ButtonPress)
1260 {
1261     if(PREVIEW_OBJECTTYPE_SPHERE == GetSvx3DLightControl().GetObjectType())
1262     {
1263         GetSvx3DLightControl().SetObjectType(PREVIEW_OBJECTTYPE_CUBE);
1264     }
1265     else
1266     {
1267         GetSvx3DLightControl().SetObjectType(PREVIEW_OBJECTTYPE_SPHERE);
1268     }
1269
1270     return 0;
1271 }
1272
1273 IMPL_LINK_NOARG(SvxLightCtl3D, InternalInteractiveChange)
1274 {
1275     double fHor, fVer;
1276
1277     maLightControl.GetPosition(fHor, fVer);
1278     maHorScroller.SetThumbPos( sal_Int32(fHor * 100.0) );
1279     maVerScroller.SetThumbPos( 18000 - sal_Int32((fVer + 90.0) * 100.0) );
1280
1281     if(maUserInteractiveChangeCallback.IsSet())
1282     {
1283         maUserInteractiveChangeCallback.Call(this);
1284     }
1285
1286     return 0;
1287 }
1288
1289 IMPL_LINK_NOARG(SvxLightCtl3D, InternalSelectionChange)
1290 {
1291     CheckSelection();
1292
1293     if(maUserSelectionChangeCallback.IsSet())
1294     {
1295         maUserSelectionChangeCallback.Call(this);
1296     }
1297
1298     return 0;
1299 }
1300
1301 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */