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