Line data Source code
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 : #include <sfx2/dispatch.hxx>
21 : #include <sfx2/module.hxx>
22 : #include <sfx2/viewfrm.hxx>
23 : #include <svl/eitem.hxx>
24 : #include <svtools/colrdlg.hxx>
25 : #include <vcl/msgbox.hxx>
26 : #include <sfx2/viewsh.hxx>
27 : #include <svx/xflclit.hxx>
28 : #include <svx/svdmodel.hxx>
29 : #include <svx/globl3d.hxx>
30 : #include <svx/view3d.hxx>
31 : #include <svx/obj3d.hxx>
32 : #include <svx/sphere3d.hxx>
33 : #include <svx/scene3d.hxx>
34 : #include <svx/camera3d.hxx>
35 : #include <svx/fmmodel.hxx>
36 : #include <svx/fmpage.hxx>
37 : #include <svx/polysc3d.hxx>
38 : #include <editeng/eeitem.hxx>
39 : #include <svl/style.hxx>
40 : #include <svx/dlgutil.hxx>
41 :
42 : #include <svx/dialmgr.hxx>
43 : #include <svx/viewpt3d.hxx>
44 :
45 : #include <svx/svxids.hrc>
46 : #include <svx/dialogs.hrc>
47 :
48 : #include <editeng/colritem.hxx>
49 : #include <svx/e3ditem.hxx>
50 : #include <svx/gallery.hxx>
51 : #include <svl/whiter.hxx>
52 :
53 : #include <svx/float3d.hxx>
54 : #include "float3d.hrc"
55 :
56 : using namespace com::sun::star;
57 :
58 468 : SFX_IMPL_DOCKINGWINDOW_WITHID( Svx3DChildWindow, SID_3D_WIN )
59 :
60 : struct Svx3DWinImpl
61 : {
62 : SfxItemPool* pPool;
63 : };
64 :
65 : namespace {
66 : /** Get the dispatcher from the current view frame, or, if that is not
67 : available, from the given bindings.
68 : @param pBindings
69 : May be NULL.
70 : @returns NULL when both the current view frame is NULL and the given
71 : bindings are NULL.
72 : */
73 0 : SfxDispatcher* LocalGetDispatcher (const SfxBindings* pBindings)
74 : {
75 0 : SfxDispatcher* pDispatcher = NULL;
76 :
77 0 : if (SfxViewFrame::Current() != NULL)
78 0 : pDispatcher = SfxViewFrame::Current()->GetDispatcher();
79 0 : else if (pBindings != NULL)
80 0 : pDispatcher = pBindings->GetDispatcher();
81 :
82 0 : return pDispatcher;
83 : }
84 : }
85 :
86 0 : Svx3DWin::Svx3DWin(SfxBindings* pInBindings, SfxChildWindow *pCW, vcl::Window* pParent)
87 : : SfxDockingWindow (pInBindings, pCW, pParent,
88 : "Docking3DEffects", "svx/ui/docking3deffects.ui")
89 0 : , aImgLightOn(SVX_RES(RID_SVXIMAGE_LIGHT_ON))
90 0 : , aImgLightOff(SVX_RES(RID_SVXIMAGE_LIGHT_OFF))
91 : , bUpdate(false)
92 : , eViewType(VIEWTYPE_GEO)
93 : , pModel(NULL)
94 : , pVDev(NULL)
95 : , p3DView(NULL)
96 : , pBindings(pInBindings)
97 : , pControllerItem(0)
98 : , pConvertTo3DItem(0)
99 : , pConvertTo3DLatheItem(0)
100 : , mpImpl(new Svx3DWinImpl())
101 : , ePoolUnit(SFX_MAPUNIT_MM)
102 : , mpRemember2DAttributes(NULL)
103 0 : , bOnly3DChanged(false)
104 : {
105 0 : get(m_pBtnGeo, "geometry");
106 0 : get(m_pBtnRepresentation, "representation");
107 0 : get(m_pBtnLight, "light");
108 0 : get(m_pBtnTexture, "texture");
109 0 : get(m_pBtnMaterial, "material");
110 0 : get(m_pBtnUpdate, "update");
111 0 : get(m_pBtnAssign, "assign");
112 :
113 0 : get(m_pFLGeometrie, "geoframe");
114 0 : get(m_pFtPercentDiagonal, "diagonalft");
115 0 : get(m_pMtrPercentDiagonal, "diagonal");
116 0 : get(m_pFtBackscale, "scaleddepthft");
117 0 : get(m_pMtrBackscale, "scaleddepth");
118 0 : get(m_pFtEndAngle, "angleft");
119 0 : get(m_pMtrEndAngle, "angle");
120 0 : get(m_pFtDepth, "depthft");
121 0 : get(m_pMtrDepth, "depth");
122 :
123 0 : get(m_pFLSegments, "segmentsframe");
124 0 : get(m_pNumHorizontal, "hori");
125 0 : get(m_pNumVertical, "veri");
126 :
127 0 : get(m_pFLNormals, "normals");
128 0 : get(m_pBtnNormalsObj, "objspecific");
129 0 : get(m_pBtnNormalsFlat, "flat");
130 0 : get(m_pBtnNormalsSphere, "spherical");
131 0 : get(m_pBtnNormalsInvert, "invertnormals");
132 0 : get(m_pBtnTwoSidedLighting, "doublesidedillum");
133 0 : get(m_pBtnDoubleSided, "doublesided");
134 :
135 0 : get(m_pFLRepresentation, "shadingframe");
136 0 : get(m_pLbShademode, "mode");
137 :
138 0 : get(m_pFLShadow, "shadowframe");
139 0 : get(m_pBtnShadow3d, "shadow");
140 0 : get(m_pFtSlant, "slantft");
141 0 : get(m_pMtrSlant, "slant");
142 :
143 0 : get(m_pFLCamera, "cameraframe");
144 0 : get(m_pMtrDistance, "distance");
145 0 : get(m_pMtrFocalLength, "focal");
146 :
147 0 : get(m_pFLLight, "illumframe");
148 0 : get(m_pBtnLight1, "light1");
149 0 : get(m_pBtnLight2, "light2");
150 0 : get(m_pBtnLight3, "light3");
151 0 : get(m_pBtnLight4, "light4");
152 0 : get(m_pBtnLight5, "light5");
153 0 : get(m_pBtnLight6, "light6");
154 0 : get(m_pBtnLight7, "light7");
155 0 : get(m_pBtnLight8, "light8");
156 0 : get(m_pLbLight1, "lightcolor1");
157 0 : get(m_pLbLight2, "lightcolor2");
158 0 : get(m_pLbLight3, "lightcolor3");
159 0 : get(m_pLbLight4, "lightcolor4");
160 0 : get(m_pLbLight5, "lightcolor5");
161 0 : get(m_pLbLight6, "lightcolor6");
162 0 : get(m_pLbLight7, "lightcolor7");
163 0 : get(m_pLbLight8, "lightcolor8");
164 0 : get(m_pBtnLightColor, "colorbutton1");
165 0 : get(m_pLbAmbientlight, "ambientcolor");
166 0 : get(m_pBtnAmbientColor, "colorbutton2");
167 :
168 0 : get(m_pFLTexture, "textureframe");
169 0 : get(m_pBtnTexLuminance, "textype");
170 0 : get(m_pBtnTexColor, "texcolor");
171 0 : get(m_pBtnTexReplace, "texreplace");
172 0 : get(m_pBtnTexModulate, "texmodulate");
173 0 : get(m_pBtnTexBlend, "texblend");
174 0 : get(m_pBtnTexObjectX, "texobjx");
175 0 : get(m_pBtnTexParallelX, "texparallelx");
176 0 : get(m_pBtnTexCircleX, "texcirclex");
177 0 : get(m_pBtnTexObjectY, "texobjy");
178 0 : get(m_pBtnTexParallelY, "texparallely");
179 0 : get(m_pBtnTexCircleY, "texcircley");
180 0 : get(m_pBtnTexFilter, "texfilter");
181 :
182 0 : get(m_pFLMaterial, "materialframe");
183 0 : get(m_pLbMatFavorites, "favorites");
184 0 : get(m_pLbMatColor, "objcolor");
185 0 : get(m_pBtnMatColor, "colorbutton3");
186 0 : get(m_pLbMatEmission, "illumcolor");
187 0 : get(m_pBtnEmissionColor, "colorbutton4");
188 :
189 0 : get(m_pFLMatSpecular, "specframe");
190 0 : get(m_pLbMatSpecular, "speccolor");
191 0 : get(m_pBtnSpecularColor, "colorbutton5");
192 0 : get(m_pMtrMatSpecularIntensity, "intensity");
193 :
194 0 : get(m_pCtlPreview, "preview");
195 0 : get(m_pCtlLightPreview, "lightpreview");
196 0 : Size aSize(LogicToPixel(Size(83, 76), MAP_APPFONT));
197 0 : m_pCtlPreview->set_width_request(aSize.Width());
198 0 : m_pCtlLightPreview->set_width_request(aSize.Width());
199 0 : m_pCtlPreview->set_height_request(aSize.Height());
200 0 : m_pCtlLightPreview->set_height_request(aSize.Height());
201 :
202 0 : get(m_pBtnConvertTo3D, "to3d");
203 0 : get(m_pBtnLatheObject, "tolathe");
204 0 : get(m_pBtnPerspective, "perspective");
205 :
206 0 : mpImpl->pPool = NULL;
207 :
208 : // Set Metric
209 0 : eFUnit = pInBindings->GetDispatcher()->GetModule()->GetFieldUnit();
210 :
211 0 : m_pMtrDepth->SetUnit( eFUnit );
212 0 : m_pMtrDistance->SetUnit( eFUnit );
213 0 : m_pMtrFocalLength->SetUnit( eFUnit );
214 :
215 0 : pControllerItem = new Svx3DCtrlItem(SID_3D_STATE, pBindings);
216 0 : pConvertTo3DItem = new SvxConvertTo3DItem(SID_CONVERT_TO_3D, pBindings);
217 0 : pConvertTo3DLatheItem = new SvxConvertTo3DItem(SID_CONVERT_TO_3D_LATHE_FAST, pBindings);
218 :
219 0 : m_pBtnAssign->SetClickHdl( LINK( this, Svx3DWin, ClickAssignHdl ) );
220 0 : m_pBtnUpdate->SetClickHdl( LINK( this, Svx3DWin, ClickUpdateHdl ) );
221 :
222 0 : Link<> aLink( LINK( this, Svx3DWin, ClickViewTypeHdl ) );
223 0 : m_pBtnGeo->SetClickHdl( aLink );
224 0 : m_pBtnRepresentation->SetClickHdl( aLink );
225 0 : m_pBtnLight->SetClickHdl( aLink );
226 0 : m_pBtnTexture->SetClickHdl( aLink );
227 0 : m_pBtnMaterial->SetClickHdl( aLink );
228 :
229 0 : aLink = LINK( this, Svx3DWin, ClickHdl );
230 0 : m_pBtnPerspective->SetClickHdl( aLink );
231 0 : m_pBtnConvertTo3D->SetClickHdl( aLink );
232 0 : m_pBtnLatheObject->SetClickHdl( aLink );
233 :
234 : // Geometry
235 0 : m_pBtnNormalsObj->SetClickHdl( aLink );
236 0 : m_pBtnNormalsFlat->SetClickHdl( aLink );
237 0 : m_pBtnNormalsSphere->SetClickHdl( aLink );
238 0 : m_pBtnTwoSidedLighting->SetClickHdl( aLink );
239 0 : m_pBtnNormalsInvert->SetClickHdl( aLink );
240 0 : m_pBtnDoubleSided->SetClickHdl( aLink );
241 :
242 : // Representation
243 0 : m_pBtnShadow3d->SetClickHdl( aLink );
244 :
245 : // Lighting
246 0 : m_pBtnLight1->SetClickHdl( aLink );
247 0 : m_pBtnLight2->SetClickHdl( aLink );
248 0 : m_pBtnLight3->SetClickHdl( aLink );
249 0 : m_pBtnLight4->SetClickHdl( aLink );
250 0 : m_pBtnLight5->SetClickHdl( aLink );
251 0 : m_pBtnLight6->SetClickHdl( aLink );
252 0 : m_pBtnLight7->SetClickHdl( aLink );
253 0 : m_pBtnLight8->SetClickHdl( aLink );
254 :
255 : // Textures
256 0 : m_pBtnTexLuminance->SetClickHdl( aLink );
257 0 : m_pBtnTexColor->SetClickHdl( aLink );
258 0 : m_pBtnTexReplace->SetClickHdl( aLink );
259 0 : m_pBtnTexModulate->SetClickHdl( aLink );
260 0 : m_pBtnTexParallelX->SetClickHdl( aLink );
261 0 : m_pBtnTexCircleX->SetClickHdl( aLink );
262 0 : m_pBtnTexObjectX->SetClickHdl( aLink );
263 0 : m_pBtnTexParallelY->SetClickHdl( aLink );
264 0 : m_pBtnTexCircleY->SetClickHdl( aLink );
265 0 : m_pBtnTexObjectY->SetClickHdl( aLink );
266 0 : m_pBtnTexFilter->SetClickHdl( aLink );
267 :
268 : // Material
269 0 : aLink = LINK( this, Svx3DWin, ClickColorHdl );
270 0 : m_pBtnLightColor->SetClickHdl( aLink );
271 0 : m_pBtnAmbientColor->SetClickHdl( aLink );
272 0 : m_pBtnMatColor->SetClickHdl( aLink );
273 0 : m_pBtnEmissionColor->SetClickHdl( aLink );
274 0 : m_pBtnSpecularColor->SetClickHdl( aLink );
275 :
276 :
277 0 : aLink = LINK( this, Svx3DWin, SelectHdl );
278 0 : m_pLbMatFavorites->SetSelectHdl( aLink );
279 0 : m_pLbMatColor->SetSelectHdl( aLink );
280 0 : m_pLbMatEmission->SetSelectHdl( aLink );
281 0 : m_pLbMatSpecular->SetSelectHdl( aLink );
282 0 : m_pLbLight1->SetSelectHdl( aLink );
283 0 : m_pLbLight2->SetSelectHdl( aLink );
284 0 : m_pLbLight3->SetSelectHdl( aLink );
285 0 : m_pLbLight4->SetSelectHdl( aLink );
286 0 : m_pLbLight5->SetSelectHdl( aLink );
287 0 : m_pLbLight6->SetSelectHdl( aLink );
288 0 : m_pLbLight7->SetSelectHdl( aLink );
289 0 : m_pLbLight8->SetSelectHdl( aLink );
290 0 : m_pLbAmbientlight->SetSelectHdl( aLink );
291 0 : m_pLbShademode->SetSelectHdl( aLink );
292 :
293 0 : aLink = LINK( this, Svx3DWin, ModifyHdl );
294 0 : m_pMtrMatSpecularIntensity->SetModifyHdl( aLink );
295 0 : m_pNumHorizontal->SetModifyHdl( aLink );
296 0 : m_pNumVertical->SetModifyHdl( aLink );
297 0 : m_pMtrSlant->SetModifyHdl( aLink );
298 :
299 : // Preview callback
300 0 : aLink = LINK( this, Svx3DWin, ChangeSelectionCallbackHdl );
301 0 : m_pCtlLightPreview->SetUserSelectionChangeCallback(aLink);
302 :
303 0 : aSize = GetOutputSizePixel();
304 0 : SetMinOutputSizePixel( aSize );
305 :
306 0 : Construct();
307 :
308 : // Initiation of the initialization of the ColorLBs
309 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings);
310 0 : if (pDispatcher != NULL)
311 : {
312 0 : SfxBoolItem aItem( SID_3D_INIT, true );
313 : pDispatcher->Execute(
314 0 : SID_3D_INIT, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
315 : }
316 :
317 0 : Reset();
318 :
319 : //lock down the size of the initial largest default mode as the permanent size
320 0 : aSize = get_preferred_size();
321 0 : set_width_request(aSize.Width());
322 0 : set_height_request(aSize.Height());
323 0 : }
324 :
325 0 : Svx3DWin::~Svx3DWin()
326 : {
327 0 : disposeOnce();
328 0 : }
329 :
330 0 : void Svx3DWin::dispose()
331 : {
332 0 : delete p3DView;
333 0 : pVDev.disposeAndClear();
334 0 : delete pModel;
335 :
336 0 : DELETEZ( pControllerItem );
337 0 : DELETEZ( pConvertTo3DItem );
338 0 : DELETEZ( pConvertTo3DLatheItem );
339 :
340 0 : delete mpRemember2DAttributes;
341 :
342 0 : delete mpImpl;
343 :
344 0 : m_pBtnGeo.clear();
345 0 : m_pBtnRepresentation.clear();
346 0 : m_pBtnLight.clear();
347 0 : m_pBtnTexture.clear();
348 0 : m_pBtnMaterial.clear();
349 0 : m_pBtnUpdate.clear();
350 0 : m_pBtnAssign.clear();
351 :
352 0 : SfxDockingWindow::dispose();
353 0 : }
354 :
355 :
356 0 : void Svx3DWin::Construct()
357 : {
358 0 : m_pBtnGeo->Check();
359 0 : Link<> aLink( LINK( this, Svx3DWin, ClickViewTypeHdl ) );
360 0 : aLink.Call(m_pBtnGeo);
361 0 : m_pCtlLightPreview->Hide();
362 0 : }
363 :
364 :
365 0 : void Svx3DWin::Reset()
366 : {
367 : // Various initializations, default is AllAttributes
368 0 : m_pLbShademode->SelectEntryPos( 0 );
369 0 : m_pMtrMatSpecularIntensity->SetValue( 50 );
370 :
371 0 : m_pBtnLight1->Check();
372 0 : ClickUpdateHdl( NULL );
373 :
374 : // Select nothing, to avoid errors when selecting the first
375 0 : m_pCtlLightPreview->GetSvx3DLightControl().SelectLight(0);
376 0 : m_pCtlLightPreview->CheckSelection();
377 0 : }
378 :
379 0 : bool Svx3DWin::GetUILightState(const PushButton& rBtn) const
380 : {
381 0 : return (rBtn.GetModeImage() == aImgLightOn);
382 : }
383 :
384 0 : void Svx3DWin::SetUILightState(PushButton& rBtn, bool bState)
385 : {
386 0 : rBtn.SetModeImage( bState ? aImgLightOn : aImgLightOff );
387 0 : }
388 :
389 0 : void Svx3DWin::Update( SfxItemSet& rAttrs )
390 : {
391 : // remember 2d attributes
392 0 : if(mpRemember2DAttributes)
393 0 : mpRemember2DAttributes->ClearItem();
394 : else
395 : mpRemember2DAttributes = new SfxItemSet(*rAttrs.GetPool(),
396 : SDRATTR_START, SDRATTR_SHADOW_LAST,
397 : SDRATTR_3D_FIRST, SDRATTR_3D_LAST,
398 0 : 0, 0);
399 :
400 0 : SfxWhichIter aIter(*mpRemember2DAttributes);
401 0 : sal_uInt16 nWhich(aIter.FirstWhich());
402 :
403 0 : while(nWhich)
404 : {
405 0 : SfxItemState eState = rAttrs.GetItemState(nWhich, false);
406 0 : if(SfxItemState::DONTCARE == eState)
407 0 : mpRemember2DAttributes->InvalidateItem(nWhich);
408 0 : else if(SfxItemState::SET == eState)
409 0 : mpRemember2DAttributes->Put(rAttrs.Get(nWhich, false));
410 :
411 0 : nWhich = aIter.NextWhich();
412 : }
413 :
414 : // construct field values
415 : const SfxPoolItem* pItem;
416 :
417 : // Possible determine PoolUnit
418 0 : if( !mpImpl->pPool )
419 : {
420 0 : mpImpl->pPool = rAttrs.GetPool();
421 : DBG_ASSERT( mpImpl->pPool, "Where is the Pool? ");
422 0 : ePoolUnit = mpImpl->pPool->GetMetric( SID_ATTR_LINE_WIDTH );
423 : }
424 0 : eFUnit = GetModuleFieldUnit( rAttrs );
425 :
426 :
427 : // Segment Number Can be changed? and other states
428 0 : SfxItemState eState = rAttrs.GetItemState( SID_ATTR_3D_INTERN, false, &pItem );
429 0 : if( SfxItemState::SET == eState )
430 : {
431 0 : sal_uInt32 nState = static_cast<const SfxUInt32Item*>(pItem)->GetValue();
432 0 : bool bExtrude = ( nState & 2 );
433 0 : bool bSphere = ( nState & 4 );
434 0 : bool bCube = ( nState & 8 );
435 :
436 0 : bool bChart = ( nState & 32 ); // Chart
437 :
438 0 : if( !bChart )
439 : {
440 : // For cube objects are no segments set
441 0 : m_pFLSegments->Enable(!bCube);
442 :
443 0 : m_pFtPercentDiagonal->Enable( !bCube && !bSphere );
444 0 : m_pMtrPercentDiagonal->Enable( !bCube && !bSphere );
445 0 : m_pFtBackscale->Enable( !bCube && !bSphere );
446 0 : m_pMtrBackscale->Enable( !bCube && !bSphere );
447 0 : m_pFtDepth->Enable( !bCube && !bSphere );
448 0 : m_pMtrDepth->Enable( !bCube && !bSphere );
449 0 : if( bCube )
450 : {
451 0 : m_pNumHorizontal->SetEmptyFieldValue();
452 0 : m_pNumVertical->SetEmptyFieldValue();
453 : }
454 0 : if( bCube || bSphere )
455 : {
456 0 : m_pMtrPercentDiagonal->SetEmptyFieldValue();
457 0 : m_pMtrBackscale->SetEmptyFieldValue();
458 0 : m_pMtrDepth->SetEmptyFieldValue();
459 : }
460 :
461 : // There is a final angle only for Lathe objects.
462 0 : m_pFtEndAngle->Enable( !bExtrude && !bCube && !bSphere );
463 0 : m_pMtrEndAngle->Enable( !bExtrude && !bCube && !bSphere );
464 0 : if( bExtrude || bCube || bSphere )
465 0 : m_pMtrEndAngle->SetEmptyFieldValue();
466 : }
467 : else
468 : {
469 : // Geometry
470 0 : m_pNumHorizontal->SetEmptyFieldValue();
471 0 : m_pNumVertical->SetEmptyFieldValue();
472 0 : m_pFLSegments->Enable( false );
473 0 : m_pFtEndAngle->Enable( false );
474 0 : m_pMtrEndAngle->Enable( false );
475 0 : m_pMtrEndAngle->SetEmptyFieldValue();
476 0 : m_pFtDepth->Enable( false );
477 0 : m_pMtrDepth->Enable( false );
478 0 : m_pMtrDepth->SetEmptyFieldValue();
479 :
480 : // Representation
481 0 : m_pFLShadow->Enable(false);
482 :
483 0 : m_pMtrDistance->SetEmptyFieldValue();
484 0 : m_pMtrFocalLength->SetEmptyFieldValue();
485 0 : m_pFLCamera->Enable( false );
486 :
487 : //Lower Range
488 0 : m_pBtnConvertTo3D->Enable( false );
489 0 : m_pBtnLatheObject->Enable( false );
490 : }
491 : }
492 : // Bitmap fill ? -> Status
493 0 : bool bBitmap(false);
494 0 : eState = rAttrs.GetItemState(XATTR_FILLSTYLE);
495 0 : if(eState != SfxItemState::DONTCARE)
496 : {
497 0 : drawing::FillStyle eXFS = (drawing::FillStyle)static_cast<const XFillStyleItem&>(rAttrs.Get(XATTR_FILLSTYLE)).GetValue();
498 0 : bBitmap = (eXFS == drawing::FillStyle_BITMAP || eXFS == drawing::FillStyle_GRADIENT || eXFS == drawing::FillStyle_HATCH);
499 : }
500 :
501 0 : m_pFLTexture->Enable(bBitmap);
502 :
503 : // Geometry
504 : // Number of segments (horizontal)
505 0 : if( m_pNumHorizontal->IsEnabled() )
506 : {
507 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_HORZ_SEGS);
508 0 : if(eState != SfxItemState::DONTCARE)
509 : {
510 0 : sal_uInt32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DOBJ_HORZ_SEGS)).GetValue();
511 0 : if(nValue != (sal_uInt32 )m_pNumHorizontal->GetValue())
512 : {
513 0 : m_pNumHorizontal->SetValue( nValue );
514 0 : bUpdate = true;
515 : }
516 0 : else if( m_pNumHorizontal->IsEmptyFieldValue() )
517 0 : m_pNumHorizontal->SetValue( nValue );
518 : }
519 : else
520 : {
521 0 : if( !m_pNumHorizontal->IsEmptyFieldValue() )
522 : {
523 0 : m_pNumHorizontal->SetEmptyFieldValue();
524 0 : bUpdate = true;
525 : }
526 : }
527 : }
528 :
529 : //Number of segments (vertical)
530 0 : if( m_pNumVertical->IsEnabled() )
531 : {
532 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_VERT_SEGS);
533 0 : if( eState != SfxItemState::DONTCARE )
534 : {
535 0 : sal_uInt32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DOBJ_VERT_SEGS)).GetValue();
536 0 : if( nValue != (sal_uInt32) m_pNumVertical->GetValue() )
537 : {
538 0 : m_pNumVertical->SetValue( nValue );
539 0 : bUpdate = true;
540 : }
541 0 : else if( m_pNumVertical->IsEmptyFieldValue() )
542 0 : m_pNumVertical->SetValue( nValue );
543 : }
544 : else
545 : {
546 0 : if( !m_pNumVertical->IsEmptyFieldValue() )
547 : {
548 0 : m_pNumVertical->SetEmptyFieldValue();
549 0 : bUpdate = true;
550 : }
551 : }
552 : }
553 :
554 : // Depth
555 0 : if( m_pMtrDepth->IsEnabled() )
556 : {
557 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_DEPTH);
558 0 : if( eState != SfxItemState::DONTCARE )
559 : {
560 0 : sal_uInt32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DOBJ_DEPTH)).GetValue();
561 0 : sal_uInt32 nValue2 = GetCoreValue(*m_pMtrDepth, ePoolUnit);
562 0 : if( nValue != nValue2 )
563 : {
564 0 : if( eFUnit != m_pMtrDepth->GetUnit() )
565 0 : SetFieldUnit(*m_pMtrDepth, eFUnit);
566 :
567 0 : SetMetricValue(*m_pMtrDepth, nValue, ePoolUnit);
568 0 : bUpdate = true;
569 : }
570 0 : else if( m_pMtrDepth->IsEmptyFieldValue() )
571 0 : m_pMtrDepth->SetValue( m_pMtrDepth->GetValue() );
572 : }
573 : else
574 : {
575 0 : if( !m_pMtrDepth->IsEmptyFieldValue() )
576 : {
577 0 : m_pMtrDepth->SetEmptyFieldValue();
578 0 : bUpdate = true;
579 : }
580 : }
581 : }
582 :
583 : // Double walled / Double sided
584 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_DOUBLE_SIDED);
585 0 : if( eState != SfxItemState::DONTCARE )
586 : {
587 0 : bool bValue = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DOBJ_DOUBLE_SIDED)).GetValue();
588 0 : if( bValue != m_pBtnDoubleSided->IsChecked() )
589 : {
590 0 : m_pBtnDoubleSided->Check( bValue );
591 0 : bUpdate = true;
592 : }
593 0 : else if( m_pBtnDoubleSided->GetState() == TRISTATE_INDET )
594 0 : m_pBtnDoubleSided->Check( bValue );
595 : }
596 : else
597 : {
598 0 : if( m_pBtnDoubleSided->GetState() != TRISTATE_INDET )
599 : {
600 0 : m_pBtnDoubleSided->SetState( TRISTATE_INDET );
601 0 : bUpdate = true;
602 : }
603 : }
604 :
605 : // Edge rounding
606 0 : if( m_pMtrPercentDiagonal->IsEnabled() )
607 : {
608 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_PERCENT_DIAGONAL);
609 0 : if( eState != SfxItemState::DONTCARE )
610 : {
611 0 : sal_uInt16 nValue = static_cast<const SfxUInt16Item&>(rAttrs.Get(SDRATTR_3DOBJ_PERCENT_DIAGONAL)).GetValue();
612 0 : if( nValue != m_pMtrPercentDiagonal->GetValue() )
613 : {
614 0 : m_pMtrPercentDiagonal->SetValue( nValue );
615 0 : bUpdate = true;
616 : }
617 0 : else if( m_pMtrPercentDiagonal->IsEmptyFieldValue() )
618 0 : m_pMtrPercentDiagonal->SetValue( nValue );
619 : }
620 : else
621 : {
622 0 : if( !m_pMtrPercentDiagonal->IsEmptyFieldValue() )
623 : {
624 0 : m_pMtrPercentDiagonal->SetEmptyFieldValue();
625 0 : bUpdate = true;
626 : }
627 : }
628 : }
629 :
630 : // Depth scaling
631 0 : if( m_pMtrBackscale->IsEnabled() )
632 : {
633 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_BACKSCALE);
634 0 : if( eState != SfxItemState::DONTCARE )
635 : {
636 0 : sal_uInt16 nValue = static_cast<const SfxUInt16Item&>(rAttrs.Get(SDRATTR_3DOBJ_BACKSCALE)).GetValue();
637 0 : if( nValue != m_pMtrBackscale->GetValue() )
638 : {
639 0 : m_pMtrBackscale->SetValue( nValue );
640 0 : bUpdate = true;
641 : }
642 0 : else if( m_pMtrBackscale->IsEmptyFieldValue() )
643 0 : m_pMtrBackscale->SetValue( nValue );
644 : }
645 : else
646 : {
647 0 : if( !m_pMtrBackscale->IsEmptyFieldValue() )
648 : {
649 0 : m_pMtrBackscale->SetEmptyFieldValue();
650 0 : bUpdate = true;
651 : }
652 : }
653 : }
654 :
655 : // End angle
656 0 : if( m_pMtrEndAngle->IsEnabled() )
657 : {
658 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_END_ANGLE);
659 0 : if( eState != SfxItemState::DONTCARE )
660 : {
661 0 : sal_Int32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DOBJ_END_ANGLE)).GetValue();
662 0 : if( nValue != m_pMtrEndAngle->GetValue() )
663 : {
664 0 : m_pMtrEndAngle->SetValue( nValue );
665 0 : bUpdate = true;
666 : }
667 : }
668 : else
669 : {
670 0 : if( !m_pMtrEndAngle->IsEmptyFieldValue() )
671 : {
672 0 : m_pMtrEndAngle->SetEmptyFieldValue();
673 0 : bUpdate = true;
674 : }
675 : }
676 : }
677 :
678 : // Normal type
679 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_NORMALS_KIND);
680 0 : if( eState != SfxItemState::DONTCARE )
681 : {
682 0 : sal_uInt16 nValue = static_cast<const Svx3DNormalsKindItem&>(rAttrs.Get(SDRATTR_3DOBJ_NORMALS_KIND)).GetValue();
683 :
684 0 : if( ( !m_pBtnNormalsObj->IsChecked() && nValue == 0 ) ||
685 0 : ( !m_pBtnNormalsFlat->IsChecked() && nValue == 1 ) ||
686 0 : ( !m_pBtnNormalsSphere->IsChecked() && nValue == 2 ) )
687 : {
688 0 : m_pBtnNormalsObj->Check( nValue == 0 );
689 0 : m_pBtnNormalsFlat->Check( nValue == 1 );
690 0 : m_pBtnNormalsSphere->Check( nValue == 2 );
691 0 : bUpdate = true;
692 : }
693 : }
694 : else
695 : {
696 0 : if( m_pBtnNormalsObj->IsChecked() ||
697 0 : m_pBtnNormalsFlat->IsChecked() ||
698 0 : m_pBtnNormalsSphere->IsChecked() )
699 : {
700 0 : m_pBtnNormalsObj->Check( false );
701 0 : m_pBtnNormalsFlat->Check( false );
702 0 : m_pBtnNormalsSphere->Check( false );
703 0 : bUpdate = true;
704 : }
705 : }
706 :
707 : // Normal inverted
708 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_NORMALS_INVERT);
709 0 : if( eState != SfxItemState::DONTCARE )
710 : {
711 0 : bool bValue = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DOBJ_NORMALS_INVERT)).GetValue();
712 0 : if( bValue != m_pBtnNormalsInvert->IsChecked() )
713 : {
714 0 : m_pBtnNormalsInvert->Check( bValue );
715 0 : bUpdate = true;
716 : }
717 0 : else if( m_pBtnNormalsInvert->GetState() == TRISTATE_INDET )
718 0 : m_pBtnNormalsInvert->Check( bValue );
719 : }
720 : else
721 : {
722 0 : if( m_pBtnNormalsInvert->GetState() != TRISTATE_INDET )
723 : {
724 0 : m_pBtnNormalsInvert->SetState( TRISTATE_INDET );
725 0 : bUpdate = true;
726 : }
727 : }
728 :
729 : // 2-sided lighting
730 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING);
731 0 : if( eState != SfxItemState::DONTCARE )
732 : {
733 0 : bool bValue = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING)).GetValue();
734 0 : if( bValue != m_pBtnTwoSidedLighting->IsChecked() )
735 : {
736 0 : m_pBtnTwoSidedLighting->Check( bValue );
737 0 : bUpdate = true;
738 : }
739 0 : else if( m_pBtnTwoSidedLighting->GetState() == TRISTATE_INDET )
740 0 : m_pBtnTwoSidedLighting->Check( bValue );
741 : }
742 : else
743 : {
744 0 : if( m_pBtnTwoSidedLighting->GetState() != TRISTATE_INDET )
745 : {
746 0 : m_pBtnTwoSidedLighting->SetState( TRISTATE_INDET );
747 0 : bUpdate = true;
748 : }
749 : }
750 :
751 : // Representation
752 : // Shademode
753 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_SHADE_MODE);
754 0 : if( eState != SfxItemState::DONTCARE )
755 : {
756 0 : sal_uInt16 nValue = static_cast<const Svx3DShadeModeItem&>(rAttrs.Get(SDRATTR_3DSCENE_SHADE_MODE)).GetValue();
757 0 : if( nValue != m_pLbShademode->GetSelectEntryPos() )
758 : {
759 0 : m_pLbShademode->SelectEntryPos( nValue );
760 0 : bUpdate = true;
761 : }
762 : }
763 : else
764 : {
765 0 : if( m_pLbShademode->GetSelectEntryCount() != 0 )
766 : {
767 0 : m_pLbShademode->SetNoSelection();
768 0 : bUpdate = true;
769 : }
770 : }
771 :
772 : // 3D-Shadow
773 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_SHADOW_3D);
774 0 : if( eState != SfxItemState::DONTCARE )
775 : {
776 0 : bool bValue = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DOBJ_SHADOW_3D)).GetValue();
777 0 : if( bValue != m_pBtnShadow3d->IsChecked() )
778 : {
779 0 : m_pBtnShadow3d->Check( bValue );
780 0 : m_pFtSlant->Enable( bValue );
781 0 : m_pMtrSlant->Enable( bValue );
782 0 : bUpdate = true;
783 : }
784 0 : else if( m_pBtnShadow3d->GetState() == TRISTATE_INDET )
785 0 : m_pBtnShadow3d->Check( bValue );
786 : }
787 : else
788 : {
789 0 : if( m_pBtnShadow3d->GetState() != TRISTATE_INDET )
790 : {
791 0 : m_pBtnShadow3d->SetState( TRISTATE_INDET );
792 0 : bUpdate = true;
793 : }
794 : }
795 :
796 : // Inclination (Shadow)
797 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_SHADOW_SLANT);
798 0 : if( eState != SfxItemState::DONTCARE )
799 : {
800 0 : sal_uInt16 nValue = static_cast<const SfxUInt16Item&>(rAttrs.Get(SDRATTR_3DSCENE_SHADOW_SLANT)).GetValue();
801 0 : if( nValue != m_pMtrSlant->GetValue() )
802 : {
803 0 : m_pMtrSlant->SetValue( nValue );
804 0 : bUpdate = true;
805 : }
806 : }
807 : else
808 : {
809 0 : if( !m_pMtrSlant->IsEmptyFieldValue() )
810 : {
811 0 : m_pMtrSlant->SetEmptyFieldValue();
812 0 : bUpdate = true;
813 : }
814 : }
815 :
816 : // Distance
817 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_DISTANCE);
818 0 : if( eState != SfxItemState::DONTCARE )
819 : {
820 0 : sal_uInt32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue();
821 0 : sal_uInt32 nValue2 = GetCoreValue(*m_pMtrDistance, ePoolUnit);
822 0 : if( nValue != nValue2 )
823 : {
824 0 : if( eFUnit != m_pMtrDistance->GetUnit() )
825 0 : SetFieldUnit(*m_pMtrDistance, eFUnit);
826 :
827 0 : SetMetricValue(*m_pMtrDistance, nValue, ePoolUnit);
828 0 : bUpdate = true;
829 : }
830 : }
831 : else
832 : {
833 0 : if( !m_pMtrDepth->IsEmptyFieldValue() )
834 : {
835 0 : m_pMtrDepth->SetEmptyFieldValue();
836 0 : bUpdate = true;
837 : }
838 : }
839 :
840 : // Focal length
841 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_FOCAL_LENGTH);
842 0 : if( eState != SfxItemState::DONTCARE )
843 : {
844 0 : sal_uInt32 nValue = static_cast<const SfxUInt32Item&>(rAttrs.Get(SDRATTR_3DSCENE_FOCAL_LENGTH)).GetValue();
845 0 : sal_uInt32 nValue2 = GetCoreValue(*m_pMtrFocalLength, ePoolUnit);
846 0 : if( nValue != nValue2 )
847 : {
848 0 : if( eFUnit != m_pMtrFocalLength->GetUnit() )
849 0 : SetFieldUnit(*m_pMtrFocalLength, eFUnit);
850 :
851 0 : SetMetricValue(*m_pMtrFocalLength, nValue, ePoolUnit);
852 0 : bUpdate = true;
853 : }
854 : }
855 : else
856 : {
857 0 : if( !m_pMtrFocalLength->IsEmptyFieldValue() )
858 : {
859 0 : m_pMtrFocalLength->SetEmptyFieldValue();
860 0 : bUpdate = true;
861 : }
862 : }
863 :
864 : // Lighting
865 0 : Color aColor;
866 0 : basegfx::B3DVector aVector;
867 : // Light 1 (Color)
868 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_1);
869 0 : if( eState != SfxItemState::DONTCARE )
870 : {
871 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue();
872 0 : ColorLB* pLb = m_pLbLight1;
873 0 : if( aColor != pLb->GetSelectEntryColor() )
874 : {
875 0 : LBSelectColor( pLb, aColor );
876 0 : bUpdate = true;
877 : }
878 : }
879 : else
880 : {
881 0 : if( m_pLbLight1->GetSelectEntryCount() != 0 )
882 : {
883 0 : m_pLbLight1->SetNoSelection();
884 0 : bUpdate = true;
885 : }
886 : }
887 : // Light 1 (on/off)
888 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_1);
889 0 : if( eState != SfxItemState::DONTCARE )
890 : {
891 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue();
892 0 : if( ( bOn && !GetUILightState(*m_pBtnLight1)) ||
893 0 : ( !bOn && GetUILightState(*m_pBtnLight1)) )
894 : {
895 0 : SetUILightState(*m_pBtnLight1, bOn);
896 0 : bUpdate = true;
897 : }
898 0 : if( m_pBtnLight1->GetState() == TRISTATE_INDET )
899 0 : m_pBtnLight1->Check( m_pBtnLight1->IsChecked() );
900 : }
901 : else
902 : {
903 0 : if( m_pBtnLight1->GetState() != TRISTATE_INDET )
904 : {
905 0 : m_pBtnLight1->SetState( TRISTATE_INDET );
906 0 : bUpdate = true;
907 : }
908 : }
909 : // Light 1 (direction)
910 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_1);
911 0 : if( eState != SfxItemState::DONTCARE )
912 : {
913 0 : bUpdate = true;
914 : }
915 :
916 : //Light 2 (color)
917 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_2);
918 0 : if( eState != SfxItemState::DONTCARE )
919 : {
920 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue();
921 0 : ColorLB* pLb = m_pLbLight2;
922 0 : if( aColor != pLb->GetSelectEntryColor() )
923 : {
924 0 : LBSelectColor( pLb, aColor );
925 0 : bUpdate = true;
926 : }
927 : }
928 : else
929 : {
930 0 : if( m_pLbLight2->GetSelectEntryCount() != 0 )
931 : {
932 0 : m_pLbLight2->SetNoSelection();
933 0 : bUpdate = true;
934 : }
935 : }
936 : // Light 2 (on/off)
937 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_2);
938 0 : if( eState != SfxItemState::DONTCARE )
939 : {
940 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue();
941 0 : if( ( bOn && !GetUILightState(*m_pBtnLight2)) ||
942 0 : ( !bOn && GetUILightState(*m_pBtnLight2)) )
943 : {
944 0 : SetUILightState(*m_pBtnLight2, bOn);
945 0 : bUpdate = true;
946 : }
947 0 : if( m_pBtnLight2->GetState() == TRISTATE_INDET )
948 0 : m_pBtnLight2->Check( m_pBtnLight2->IsChecked() );
949 : }
950 : else
951 : {
952 0 : if( m_pBtnLight2->GetState() != TRISTATE_INDET )
953 : {
954 0 : m_pBtnLight2->SetState( TRISTATE_INDET );
955 0 : bUpdate = true;
956 : }
957 : }
958 : //Light 2 (Direction)
959 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_2);
960 0 : if( eState != SfxItemState::DONTCARE )
961 : {
962 0 : bUpdate = true;
963 : }
964 :
965 : //Light 3 (color)
966 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_3);
967 0 : if( eState != SfxItemState::DONTCARE )
968 : {
969 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue();
970 0 : ColorLB* pLb = m_pLbLight3;
971 0 : if( aColor != pLb->GetSelectEntryColor() )
972 : {
973 0 : LBSelectColor( pLb, aColor );
974 0 : bUpdate = true;
975 : }
976 : }
977 : else
978 : {
979 0 : if( m_pLbLight3->GetSelectEntryCount() != 0 )
980 : {
981 0 : m_pLbLight3->SetNoSelection();
982 0 : bUpdate = true;
983 : }
984 : }
985 : // Ligh 3 (on/off)
986 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_3);
987 0 : if( eState != SfxItemState::DONTCARE )
988 : {
989 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue();
990 0 : if( ( bOn && !GetUILightState(*m_pBtnLight3)) ||
991 0 : ( !bOn && GetUILightState(*m_pBtnLight3)) )
992 : {
993 0 : SetUILightState(*m_pBtnLight3, bOn);
994 0 : bUpdate = true;
995 : }
996 0 : if( m_pBtnLight3->GetState() == TRISTATE_INDET )
997 0 : m_pBtnLight3->Check( m_pBtnLight3->IsChecked() );
998 : }
999 : else
1000 : {
1001 0 : if( m_pBtnLight3->GetState() != TRISTATE_INDET )
1002 : {
1003 0 : m_pBtnLight3->SetState( TRISTATE_INDET );
1004 0 : bUpdate = true;
1005 : }
1006 : }
1007 : // Light 3 (Direction)
1008 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_3);
1009 0 : if( eState != SfxItemState::DONTCARE )
1010 : {
1011 0 : bUpdate = true;
1012 : }
1013 :
1014 : // Light 4 (Color)
1015 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_4);
1016 0 : if( eState != SfxItemState::DONTCARE )
1017 : {
1018 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue();
1019 0 : ColorLB* pLb = m_pLbLight4;
1020 0 : if( aColor != pLb->GetSelectEntryColor() )
1021 : {
1022 0 : LBSelectColor( pLb, aColor );
1023 0 : bUpdate = true;
1024 : }
1025 : }
1026 : else
1027 : {
1028 0 : if( m_pLbLight4->GetSelectEntryCount() != 0 )
1029 : {
1030 0 : m_pLbLight4->SetNoSelection();
1031 0 : bUpdate = true;
1032 : }
1033 : }
1034 : // Light 4 (on/off)
1035 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_4);
1036 0 : if( eState != SfxItemState::DONTCARE )
1037 : {
1038 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue();
1039 0 : if( ( bOn && !GetUILightState(*m_pBtnLight4)) ||
1040 0 : ( !bOn && GetUILightState(*m_pBtnLight4)) )
1041 : {
1042 0 : SetUILightState(*m_pBtnLight4, bOn);
1043 0 : bUpdate = true;
1044 : }
1045 0 : if( m_pBtnLight4->GetState() == TRISTATE_INDET )
1046 0 : m_pBtnLight4->Check( m_pBtnLight4->IsChecked() );
1047 : }
1048 : else
1049 : {
1050 0 : if( m_pBtnLight4->GetState() != TRISTATE_INDET )
1051 : {
1052 0 : m_pBtnLight4->SetState( TRISTATE_INDET );
1053 0 : bUpdate = true;
1054 : }
1055 : }
1056 : // Light 4 (direction)
1057 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_4);
1058 0 : if( eState != SfxItemState::DONTCARE )
1059 : {
1060 0 : bUpdate = true;
1061 : }
1062 :
1063 : // Light 5 (color)
1064 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_5);
1065 0 : if( eState != SfxItemState::DONTCARE )
1066 : {
1067 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue();
1068 0 : ColorLB* pLb = m_pLbLight5;
1069 0 : if( aColor != pLb->GetSelectEntryColor() )
1070 : {
1071 0 : LBSelectColor( pLb, aColor );
1072 0 : bUpdate = true;
1073 : }
1074 : }
1075 : else
1076 : {
1077 0 : if( m_pLbLight5->GetSelectEntryCount() != 0 )
1078 : {
1079 0 : m_pLbLight5->SetNoSelection();
1080 0 : bUpdate = true;
1081 : }
1082 : }
1083 : // Light 5 (on/off)
1084 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_5);
1085 0 : if( eState != SfxItemState::DONTCARE )
1086 : {
1087 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue();
1088 0 : if( ( bOn && !GetUILightState(*m_pBtnLight5)) ||
1089 0 : ( !bOn && GetUILightState(*m_pBtnLight5)) )
1090 : {
1091 0 : SetUILightState(*m_pBtnLight5, bOn);
1092 0 : bUpdate = true;
1093 : }
1094 0 : if( m_pBtnLight5->GetState() == TRISTATE_INDET )
1095 0 : m_pBtnLight5->Check( m_pBtnLight5->IsChecked() );
1096 : }
1097 : else
1098 : {
1099 0 : if( m_pBtnLight5->GetState() != TRISTATE_INDET )
1100 : {
1101 0 : m_pBtnLight5->SetState( TRISTATE_INDET );
1102 0 : bUpdate = true;
1103 : }
1104 : }
1105 : // Light 5 (direction)
1106 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_5);
1107 0 : if( eState != SfxItemState::DONTCARE )
1108 : {
1109 0 : bUpdate = true;
1110 : }
1111 :
1112 : // Light 6 (color)
1113 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_6);
1114 0 : if( eState != SfxItemState::DONTCARE )
1115 : {
1116 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue();
1117 0 : ColorLB* pLb = m_pLbLight6;
1118 0 : if( aColor != pLb->GetSelectEntryColor() )
1119 : {
1120 0 : LBSelectColor( pLb, aColor );
1121 0 : bUpdate = true;
1122 : }
1123 : }
1124 : else
1125 : {
1126 0 : if( m_pLbLight6->GetSelectEntryCount() != 0 )
1127 : {
1128 0 : m_pLbLight6->SetNoSelection();
1129 0 : bUpdate = true;
1130 : }
1131 : }
1132 : // Light 6 (on/off)
1133 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_6);
1134 0 : if( eState != SfxItemState::DONTCARE )
1135 : {
1136 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue();
1137 0 : if( ( bOn && !GetUILightState(*m_pBtnLight6)) ||
1138 0 : ( !bOn && GetUILightState(*m_pBtnLight6)) )
1139 : {
1140 0 : SetUILightState(*m_pBtnLight6, bOn);
1141 0 : bUpdate = true;
1142 : }
1143 0 : if( m_pBtnLight6->GetState() == TRISTATE_INDET )
1144 0 : m_pBtnLight6->Check( m_pBtnLight6->IsChecked() );
1145 : }
1146 : else
1147 : {
1148 0 : if( m_pBtnLight6->GetState() != TRISTATE_INDET )
1149 : {
1150 0 : m_pBtnLight6->SetState( TRISTATE_INDET );
1151 0 : bUpdate = true;
1152 : }
1153 : }
1154 : // Light 6 (direction)
1155 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_6);
1156 0 : if( eState != SfxItemState::DONTCARE )
1157 : {
1158 0 : bUpdate = true;
1159 : }
1160 :
1161 : // Light 7 (color)
1162 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_7);
1163 0 : if( eState != SfxItemState::DONTCARE )
1164 : {
1165 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue();
1166 0 : ColorLB* pLb = m_pLbLight7;
1167 0 : if( aColor != pLb->GetSelectEntryColor() )
1168 : {
1169 0 : LBSelectColor( pLb, aColor );
1170 0 : bUpdate = true;
1171 : }
1172 : }
1173 : else
1174 : {
1175 0 : if( m_pLbLight7->GetSelectEntryCount() != 0 )
1176 : {
1177 0 : m_pLbLight7->SetNoSelection();
1178 0 : bUpdate = true;
1179 : }
1180 : }
1181 : // Light 7 (on/off)
1182 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_7);
1183 0 : if( eState != SfxItemState::DONTCARE )
1184 : {
1185 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue();
1186 0 : if( ( bOn && !GetUILightState(*m_pBtnLight7)) ||
1187 0 : ( !bOn && GetUILightState(*m_pBtnLight7)) )
1188 : {
1189 0 : SetUILightState(*m_pBtnLight7 , bOn);
1190 0 : bUpdate = true;
1191 : }
1192 0 : if( m_pBtnLight7->GetState() == TRISTATE_INDET )
1193 0 : m_pBtnLight7->Check( m_pBtnLight7->IsChecked() );
1194 : }
1195 : else
1196 : {
1197 0 : if( m_pBtnLight7->GetState() != TRISTATE_INDET )
1198 : {
1199 0 : m_pBtnLight7->SetState( TRISTATE_INDET );
1200 0 : bUpdate = true;
1201 : }
1202 : }
1203 : // Light 7 (direction)
1204 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_7);
1205 0 : if( eState != SfxItemState::DONTCARE )
1206 : {
1207 0 : bUpdate = true;
1208 : }
1209 :
1210 : // Light 8 (color)
1211 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_8);
1212 0 : if( eState != SfxItemState::DONTCARE )
1213 : {
1214 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue();
1215 0 : ColorLB* pLb = m_pLbLight8;
1216 0 : if( aColor != pLb->GetSelectEntryColor() )
1217 : {
1218 0 : LBSelectColor( pLb, aColor );
1219 0 : bUpdate = true;
1220 : }
1221 : }
1222 : else
1223 : {
1224 0 : if( m_pLbLight8->GetSelectEntryCount() != 0 )
1225 : {
1226 0 : m_pLbLight8->SetNoSelection();
1227 0 : bUpdate = true;
1228 : }
1229 : }
1230 : // Light 8 (on/off)
1231 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_8);
1232 0 : if( eState != SfxItemState::DONTCARE )
1233 : {
1234 0 : bool bOn = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue();
1235 0 : if( ( bOn && !GetUILightState(*m_pBtnLight8)) ||
1236 0 : ( !bOn && GetUILightState(*m_pBtnLight8)) )
1237 : {
1238 0 : SetUILightState(*m_pBtnLight8, bOn);
1239 0 : bUpdate = true;
1240 : }
1241 0 : if( m_pBtnLight8->GetState() == TRISTATE_INDET )
1242 0 : m_pBtnLight8->Check( m_pBtnLight8->IsChecked() );
1243 : }
1244 : else
1245 : {
1246 0 : if( m_pBtnLight8->GetState() != TRISTATE_INDET )
1247 : {
1248 0 : m_pBtnLight8->SetState( TRISTATE_INDET );
1249 0 : bUpdate = true;
1250 : }
1251 : }
1252 : // Light 8 (direction)
1253 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_8);
1254 0 : if( eState != SfxItemState::DONTCARE )
1255 : {
1256 0 : bUpdate = true;
1257 : }
1258 :
1259 : // Ambient light
1260 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_AMBIENTCOLOR);
1261 0 : if( eState != SfxItemState::DONTCARE )
1262 : {
1263 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DSCENE_AMBIENTCOLOR)).GetValue();
1264 0 : ColorLB* pLb = m_pLbAmbientlight;
1265 0 : if( aColor != pLb->GetSelectEntryColor() )
1266 : {
1267 0 : LBSelectColor( pLb, aColor );
1268 0 : bUpdate = true;
1269 : }
1270 : }
1271 : else
1272 : {
1273 0 : if( m_pLbAmbientlight->GetSelectEntryCount() != 0 )
1274 : {
1275 0 : m_pLbAmbientlight->SetNoSelection();
1276 0 : bUpdate = true;
1277 : }
1278 : }
1279 :
1280 :
1281 : // Textures
1282 : // Art
1283 0 : if( bBitmap )
1284 : {
1285 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_KIND);
1286 0 : if( eState != SfxItemState::DONTCARE )
1287 : {
1288 0 : sal_uInt16 nValue = static_cast<const Svx3DTextureKindItem&>(rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_KIND)).GetValue();
1289 :
1290 0 : if( ( !m_pBtnTexLuminance->IsChecked() && nValue == 1 ) ||
1291 0 : ( !m_pBtnTexColor->IsChecked() && nValue == 3 ) )
1292 : {
1293 0 : m_pBtnTexLuminance->Check( nValue == 1 );
1294 0 : m_pBtnTexColor->Check( nValue == 3 );
1295 0 : bUpdate = true;
1296 : }
1297 : }
1298 : else
1299 : {
1300 0 : if( m_pBtnTexLuminance->IsChecked() ||
1301 0 : m_pBtnTexColor->IsChecked() )
1302 : {
1303 0 : m_pBtnTexLuminance->Check( false );
1304 0 : m_pBtnTexColor->Check( false );
1305 0 : bUpdate = true;
1306 : }
1307 : }
1308 :
1309 : // Mode
1310 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_MODE);
1311 0 : if( eState != SfxItemState::DONTCARE )
1312 : {
1313 0 : sal_uInt16 nValue = static_cast<const Svx3DTextureModeItem&>(rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_MODE)).GetValue();
1314 :
1315 0 : if( ( !m_pBtnTexReplace->IsChecked() && nValue == 1 ) ||
1316 0 : ( !m_pBtnTexModulate->IsChecked() && nValue == 2 ) )
1317 : {
1318 0 : m_pBtnTexReplace->Check( nValue == 1 );
1319 0 : m_pBtnTexModulate->Check( nValue == 2 );
1320 0 : bUpdate = true;
1321 : }
1322 : }
1323 : else
1324 : {
1325 0 : if( m_pBtnTexReplace->IsChecked() ||
1326 0 : m_pBtnTexModulate->IsChecked() )
1327 : {
1328 0 : m_pBtnTexReplace->Check( false );
1329 0 : m_pBtnTexModulate->Check( false );
1330 0 : bUpdate = true;
1331 : }
1332 : }
1333 :
1334 : // Projection X
1335 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_PROJ_X);
1336 0 : if( eState != SfxItemState::DONTCARE )
1337 : {
1338 0 : sal_uInt16 nValue = static_cast<const Svx3DTextureProjectionXItem&>(rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_X)).GetValue();
1339 :
1340 0 : if( ( !m_pBtnTexObjectX->IsChecked() && nValue == 0 ) ||
1341 0 : ( !m_pBtnTexParallelX->IsChecked() && nValue == 1 ) ||
1342 0 : ( !m_pBtnTexCircleX->IsChecked() && nValue == 2 ) )
1343 : {
1344 0 : m_pBtnTexObjectX->Check( nValue == 0 );
1345 0 : m_pBtnTexParallelX->Check( nValue == 1 );
1346 0 : m_pBtnTexCircleX->Check( nValue == 2 );
1347 0 : bUpdate = true;
1348 : }
1349 : }
1350 : else
1351 : {
1352 0 : if( m_pBtnTexObjectX->IsChecked() ||
1353 0 : m_pBtnTexParallelX->IsChecked() ||
1354 0 : m_pBtnTexCircleX->IsChecked() )
1355 : {
1356 0 : m_pBtnTexObjectX->Check( false );
1357 0 : m_pBtnTexParallelX->Check( false );
1358 0 : m_pBtnTexCircleX->Check( false );
1359 0 : bUpdate = true;
1360 : }
1361 : }
1362 :
1363 : // Projection Y
1364 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_PROJ_Y);
1365 0 : if( eState != SfxItemState::DONTCARE )
1366 : {
1367 0 : sal_uInt16 nValue = static_cast<const Svx3DTextureProjectionYItem&>(rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_Y)).GetValue();
1368 :
1369 0 : if( ( !m_pBtnTexObjectY->IsChecked() && nValue == 0 ) ||
1370 0 : ( !m_pBtnTexParallelY->IsChecked() && nValue == 1 ) ||
1371 0 : ( !m_pBtnTexCircleY->IsChecked() && nValue == 2 ) )
1372 : {
1373 0 : m_pBtnTexObjectY->Check( nValue == 0 );
1374 0 : m_pBtnTexParallelY->Check( nValue == 1 );
1375 0 : m_pBtnTexCircleY->Check( nValue == 2 );
1376 0 : bUpdate = true;
1377 : }
1378 : }
1379 : else
1380 : {
1381 0 : if( m_pBtnTexObjectY->IsChecked() ||
1382 0 : m_pBtnTexParallelY->IsChecked() ||
1383 0 : m_pBtnTexCircleY->IsChecked() )
1384 : {
1385 0 : m_pBtnTexObjectY->Check( false );
1386 0 : m_pBtnTexParallelY->Check( false );
1387 0 : m_pBtnTexCircleY->Check( false );
1388 0 : bUpdate = true;
1389 : }
1390 : }
1391 :
1392 : // Filter
1393 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_FILTER);
1394 0 : if( eState != SfxItemState::DONTCARE )
1395 : {
1396 0 : bool bValue = static_cast<const SfxBoolItem&>(rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_FILTER)).GetValue();
1397 0 : if( bValue != m_pBtnTexFilter->IsChecked() )
1398 : {
1399 0 : m_pBtnTexFilter->Check( bValue );
1400 0 : bUpdate = true;
1401 : }
1402 0 : if( m_pBtnTexFilter->GetState() == TRISTATE_INDET )
1403 0 : m_pBtnTexFilter->Check( bValue );
1404 : }
1405 : else
1406 : {
1407 0 : if( m_pBtnTexFilter->GetState() != TRISTATE_INDET )
1408 : {
1409 0 : m_pBtnTexFilter->SetState( TRISTATE_INDET );
1410 0 : bUpdate = true;
1411 : }
1412 : }
1413 : }
1414 :
1415 :
1416 : // Material Favorites
1417 0 : m_pLbMatFavorites->SelectEntryPos( 0 );
1418 :
1419 : // Object color
1420 0 : eState = rAttrs.GetItemState(XATTR_FILLCOLOR);
1421 0 : if( eState != SfxItemState::DONTCARE )
1422 : {
1423 0 : aColor = static_cast<const XFillColorItem&>(rAttrs.Get(XATTR_FILLCOLOR)).GetColorValue();
1424 0 : ColorLB* pLb = m_pLbMatColor;
1425 0 : if( aColor != pLb->GetSelectEntryColor() )
1426 : {
1427 0 : LBSelectColor( pLb, aColor );
1428 0 : bUpdate = true;
1429 : }
1430 : }
1431 : else
1432 : {
1433 0 : if( m_pLbMatColor->GetSelectEntryCount() != 0 )
1434 : {
1435 0 : m_pLbMatColor->SetNoSelection();
1436 0 : bUpdate = true;
1437 : }
1438 : }
1439 :
1440 : // Self-luminous color
1441 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_EMISSION);
1442 0 : if( eState != SfxItemState::DONTCARE )
1443 : {
1444 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DOBJ_MAT_EMISSION)).GetValue();
1445 0 : ColorLB* pLb = m_pLbMatEmission;
1446 0 : if( aColor != pLb->GetSelectEntryColor() )
1447 : {
1448 0 : LBSelectColor( pLb, aColor );
1449 0 : bUpdate = true;
1450 : }
1451 : }
1452 : else
1453 : {
1454 0 : if( m_pLbMatEmission->GetSelectEntryCount() != 0 )
1455 : {
1456 0 : m_pLbMatEmission->SetNoSelection();
1457 0 : bUpdate = true;
1458 : }
1459 : }
1460 :
1461 : // Specular
1462 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_SPECULAR);
1463 0 : if( eState != SfxItemState::DONTCARE )
1464 : {
1465 0 : aColor = static_cast<const SvxColorItem&>(rAttrs.Get(SDRATTR_3DOBJ_MAT_SPECULAR)).GetValue();
1466 0 : ColorLB* pLb = m_pLbMatSpecular;
1467 0 : if( aColor != pLb->GetSelectEntryColor() )
1468 : {
1469 0 : LBSelectColor( pLb, aColor );
1470 0 : bUpdate = true;
1471 : }
1472 : }
1473 : else
1474 : {
1475 0 : if( m_pLbMatSpecular->GetSelectEntryCount() != 0 )
1476 : {
1477 0 : m_pLbMatSpecular->SetNoSelection();
1478 0 : bUpdate = true;
1479 : }
1480 : }
1481 :
1482 : // Specular Intensity
1483 0 : eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY);
1484 0 : if( eState != SfxItemState::DONTCARE )
1485 : {
1486 0 : sal_uInt16 nValue = static_cast<const SfxUInt16Item&>(rAttrs.Get(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY)).GetValue();
1487 0 : if( nValue != m_pMtrMatSpecularIntensity->GetValue() )
1488 : {
1489 0 : m_pMtrMatSpecularIntensity->SetValue( nValue );
1490 0 : bUpdate = true;
1491 : }
1492 : }
1493 : else
1494 : {
1495 0 : if( !m_pMtrMatSpecularIntensity->IsEmptyFieldValue() )
1496 : {
1497 0 : m_pMtrMatSpecularIntensity->SetEmptyFieldValue();
1498 0 : bUpdate = true;
1499 : }
1500 : }
1501 :
1502 :
1503 : // Other
1504 : // Perspective
1505 0 : eState = rAttrs.GetItemState(SDRATTR_3DSCENE_PERSPECTIVE);
1506 0 : if( eState != SfxItemState::DONTCARE )
1507 : {
1508 0 : ProjectionType ePT = (ProjectionType)static_cast<const Svx3DPerspectiveItem&>(rAttrs.Get(SDRATTR_3DSCENE_PERSPECTIVE)).GetValue();
1509 0 : if( ( !m_pBtnPerspective->IsChecked() && ePT == PR_PERSPECTIVE ) ||
1510 0 : ( m_pBtnPerspective->IsChecked() && ePT == PR_PARALLEL ) )
1511 : {
1512 0 : m_pBtnPerspective->Check( ePT == PR_PERSPECTIVE );
1513 0 : bUpdate = true;
1514 : }
1515 0 : if( m_pBtnPerspective->GetState() == TRISTATE_INDET )
1516 0 : m_pBtnPerspective->Check( ePT == PR_PERSPECTIVE );
1517 : }
1518 : else
1519 : {
1520 0 : if( m_pBtnPerspective->GetState() != TRISTATE_INDET )
1521 : {
1522 0 : m_pBtnPerspective->SetState( TRISTATE_INDET );
1523 0 : bUpdate = true;
1524 : }
1525 : }
1526 :
1527 0 : if( !bUpdate && !bOnly3DChanged )
1528 : {
1529 : // however the 2D attributes may be different. Compare these and decide
1530 :
1531 0 : bUpdate = true;
1532 : }
1533 :
1534 0 : if( bUpdate || bOnly3DChanged )
1535 : {
1536 : // Update preview
1537 0 : SfxItemSet aSet(rAttrs);
1538 :
1539 : // set LineStyle hard to drawing::LineStyle_NONE when it's not set so that
1540 : // the default (drawing::LineStyle_SOLID) is not used for 3d preview
1541 0 : if(SfxItemState::SET != aSet.GetItemState(XATTR_LINESTYLE, false))
1542 0 : aSet.Put(XLineStyleItem(drawing::LineStyle_NONE));
1543 :
1544 : // set FillColor hard to WHITE when it's SfxItemState::DONTCARE so that
1545 : // the default (Blue7) is not used for 3d preview
1546 0 : if(SfxItemState::DONTCARE == aSet.GetItemState(XATTR_FILLCOLOR, false))
1547 0 : aSet.Put(XFillColorItem(OUString(), Color(COL_WHITE)));
1548 :
1549 0 : m_pCtlPreview->Set3DAttributes(aSet);
1550 0 : m_pCtlLightPreview->GetSvx3DLightControl().Set3DAttributes(aSet);
1551 :
1552 : // try to select light corresponding to active button
1553 0 : sal_uInt32 nNumber(0xffffffff);
1554 :
1555 0 : if(m_pBtnLight1->IsChecked())
1556 0 : nNumber = 0;
1557 0 : else if(m_pBtnLight2->IsChecked())
1558 0 : nNumber = 1;
1559 0 : else if(m_pBtnLight3->IsChecked())
1560 0 : nNumber = 2;
1561 0 : else if(m_pBtnLight4->IsChecked())
1562 0 : nNumber = 3;
1563 0 : else if(m_pBtnLight5->IsChecked())
1564 0 : nNumber = 4;
1565 0 : else if(m_pBtnLight6->IsChecked())
1566 0 : nNumber = 5;
1567 0 : else if(m_pBtnLight7->IsChecked())
1568 0 : nNumber = 6;
1569 0 : else if(m_pBtnLight8->IsChecked())
1570 0 : nNumber = 7;
1571 :
1572 0 : if(nNumber != 0xffffffff)
1573 : {
1574 0 : m_pCtlLightPreview->GetSvx3DLightControl().SelectLight(nNumber);
1575 0 : }
1576 : }
1577 :
1578 : // handle state of converts possible
1579 0 : m_pBtnConvertTo3D->Enable(pConvertTo3DItem->GetState());
1580 0 : m_pBtnLatheObject->Enable(pConvertTo3DLatheItem->GetState());
1581 0 : }
1582 :
1583 :
1584 0 : void Svx3DWin::GetAttr( SfxItemSet& rAttrs )
1585 : {
1586 : // get remembered 2d attributes from the dialog
1587 0 : if(mpRemember2DAttributes)
1588 : {
1589 0 : SfxWhichIter aIter(*mpRemember2DAttributes);
1590 0 : sal_uInt16 nWhich(aIter.FirstWhich());
1591 :
1592 0 : while(nWhich)
1593 : {
1594 0 : SfxItemState eState = mpRemember2DAttributes->GetItemState(nWhich, false);
1595 0 : if(SfxItemState::DONTCARE == eState)
1596 0 : rAttrs.InvalidateItem(nWhich);
1597 0 : else if(SfxItemState::SET == eState)
1598 0 : rAttrs.Put(mpRemember2DAttributes->Get(nWhich, false));
1599 :
1600 0 : nWhich = aIter.NextWhich();
1601 0 : }
1602 : }
1603 :
1604 : //Others must stand as the front on all sides
1605 : // Perspective
1606 0 : if( m_pBtnPerspective->GetState() != TRISTATE_INDET )
1607 : {
1608 : sal_uInt16 nValue;
1609 0 : if( m_pBtnPerspective->IsChecked() )
1610 0 : nValue = PR_PERSPECTIVE;
1611 : else
1612 0 : nValue = PR_PARALLEL;
1613 0 : rAttrs.Put(Svx3DPerspectiveItem(nValue));
1614 : }
1615 : else
1616 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_PERSPECTIVE);
1617 :
1618 : // Geometry
1619 : // Possible determine PoolUnit (in this case this has not happened in Update() )
1620 0 : if( !mpImpl->pPool )
1621 : {
1622 : OSL_FAIL( "No Pool in GetAttr()! May be incompatible to drviewsi.cxx ?" );
1623 0 : mpImpl->pPool = rAttrs.GetPool();
1624 : DBG_ASSERT( mpImpl->pPool, "Where is the Pool?" );
1625 0 : ePoolUnit = mpImpl->pPool->GetMetric( SID_ATTR_LINE_WIDTH );
1626 :
1627 0 : eFUnit = GetModuleFieldUnit( rAttrs );
1628 : }
1629 :
1630 : // Number of segments (horizontal)
1631 0 : if( !m_pNumHorizontal->IsEmptyFieldValue() )
1632 : {
1633 0 : sal_uInt32 nValue = static_cast<sal_uInt32>(m_pNumHorizontal->GetValue());
1634 0 : rAttrs.Put(makeSvx3DHorizontalSegmentsItem(nValue));
1635 : }
1636 : else
1637 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_HORZ_SEGS);
1638 :
1639 : // Number of segments (vertical)
1640 0 : if( !m_pNumVertical->IsEmptyFieldValue() )
1641 : {
1642 0 : sal_uInt32 nValue = static_cast<sal_uInt32>(m_pNumVertical->GetValue());
1643 0 : rAttrs.Put(makeSvx3DVerticalSegmentsItem(nValue));
1644 : }
1645 : else
1646 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_VERT_SEGS);
1647 :
1648 : // Depth
1649 0 : if( !m_pMtrDepth->IsEmptyFieldValue() )
1650 : {
1651 0 : sal_uInt32 nValue = GetCoreValue(*m_pMtrDepth, ePoolUnit);
1652 0 : rAttrs.Put(makeSvx3DDepthItem(nValue));
1653 : }
1654 : else
1655 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_DEPTH);
1656 :
1657 : // Double-sided
1658 0 : TriState eState = m_pBtnDoubleSided->GetState();
1659 0 : if( eState != TRISTATE_INDET )
1660 : {
1661 0 : bool bValue = TRISTATE_TRUE == eState;
1662 0 : rAttrs.Put(makeSvx3DDoubleSidedItem(bValue));
1663 : }
1664 : else
1665 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_DOUBLE_SIDED);
1666 :
1667 : // Edge rounding
1668 0 : if( !m_pMtrPercentDiagonal->IsEmptyFieldValue() )
1669 : {
1670 0 : sal_uInt16 nValue = (sal_uInt16) m_pMtrPercentDiagonal->GetValue();
1671 0 : rAttrs.Put(makeSvx3DPercentDiagonalItem(nValue));
1672 : }
1673 : else
1674 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_PERCENT_DIAGONAL);
1675 :
1676 : // Depth scale
1677 0 : if( !m_pMtrBackscale->IsEmptyFieldValue() )
1678 : {
1679 0 : sal_uInt16 nValue = (sal_uInt16)m_pMtrBackscale->GetValue();
1680 0 : rAttrs.Put(makeSvx3DBackscaleItem(nValue));
1681 : }
1682 : else
1683 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_BACKSCALE);
1684 :
1685 : // End angle
1686 0 : if( !m_pMtrEndAngle->IsEmptyFieldValue() )
1687 : {
1688 0 : sal_uInt16 nValue = (sal_uInt16)m_pMtrEndAngle->GetValue();
1689 0 : rAttrs.Put(makeSvx3DEndAngleItem(nValue));
1690 : }
1691 : else
1692 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_END_ANGLE);
1693 :
1694 : // Normal type
1695 0 : sal_uInt16 nValue = 99;
1696 0 : if( m_pBtnNormalsObj->IsChecked() )
1697 0 : nValue = 0;
1698 0 : else if( m_pBtnNormalsFlat->IsChecked() )
1699 0 : nValue = 1;
1700 0 : else if( m_pBtnNormalsSphere->IsChecked() )
1701 0 : nValue = 2;
1702 :
1703 0 : if( nValue <= 2 )
1704 0 : rAttrs.Put(Svx3DNormalsKindItem(nValue));
1705 : else
1706 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_NORMALS_KIND);
1707 :
1708 : // Normal inverted
1709 0 : eState = m_pBtnNormalsInvert->GetState();
1710 0 : if( eState != TRISTATE_INDET )
1711 : {
1712 0 : bool bValue = TRISTATE_TRUE == eState;
1713 0 : rAttrs.Put(makeSvx3DNormalsInvertItem(bValue));
1714 : }
1715 : else
1716 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_NORMALS_INVERT);
1717 :
1718 : // 2-sided lighting
1719 0 : eState = m_pBtnTwoSidedLighting->GetState();
1720 0 : if( eState != TRISTATE_INDET )
1721 : {
1722 0 : bool bValue = TRISTATE_TRUE == eState;
1723 0 : rAttrs.Put(makeSvx3DTwoSidedLightingItem(bValue));
1724 : }
1725 : else
1726 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING);
1727 :
1728 : // Representation
1729 : // Shade mode
1730 0 : if( m_pLbShademode->GetSelectEntryCount() )
1731 : {
1732 0 : nValue = m_pLbShademode->GetSelectEntryPos();
1733 0 : rAttrs.Put(Svx3DShadeModeItem(nValue));
1734 : }
1735 : else
1736 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_SHADE_MODE);
1737 :
1738 : // 3D-Shadow
1739 0 : eState = m_pBtnShadow3d->GetState();
1740 0 : if( eState != TRISTATE_INDET )
1741 : {
1742 0 : bool bValue = TRISTATE_TRUE == eState;
1743 0 : rAttrs.Put(makeSvx3DShadow3DItem(bValue));
1744 0 : rAttrs.Put(makeSdrShadowItem(bValue));
1745 : }
1746 : else
1747 : {
1748 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_SHADOW_3D);
1749 0 : rAttrs.InvalidateItem(SDRATTR_SHADOW);
1750 : }
1751 :
1752 : // Slant (Shadow)
1753 0 : if( !m_pMtrSlant->IsEmptyFieldValue() )
1754 : {
1755 0 : sal_uInt16 nValue2 = (sal_uInt16) m_pMtrSlant->GetValue();
1756 0 : rAttrs.Put(makeSvx3DShadowSlantItem(nValue2));
1757 : }
1758 : else
1759 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_SHADOW_SLANT);
1760 :
1761 : // Distance
1762 0 : if( !m_pMtrDistance->IsEmptyFieldValue() )
1763 : {
1764 0 : sal_uInt32 nValue2 = GetCoreValue(*m_pMtrDistance, ePoolUnit);
1765 0 : rAttrs.Put(makeSvx3DDistanceItem(nValue2));
1766 : }
1767 : else
1768 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_DISTANCE);
1769 :
1770 : // Focal length
1771 0 : if( !m_pMtrFocalLength->IsEmptyFieldValue() )
1772 : {
1773 0 : sal_uInt32 nValue2 = GetCoreValue(*m_pMtrFocalLength, ePoolUnit);
1774 0 : rAttrs.Put(makeSvx3DFocalLengthItem(nValue2));
1775 : }
1776 : else
1777 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_FOCAL_LENGTH);
1778 :
1779 : // Lighting
1780 0 : Image aImg;
1781 0 : basegfx::B3DVector aVector;
1782 0 : Color aColor;
1783 0 : const SfxItemSet aLightItemSet(m_pCtlLightPreview->GetSvx3DLightControl().Get3DAttributes());
1784 :
1785 : // Light 1 color
1786 0 : if( m_pLbLight1->GetSelectEntryCount() )
1787 : {
1788 0 : aColor = m_pLbLight1->GetSelectEntryColor();
1789 0 : rAttrs.Put(makeSvx3DLightcolor1Item(aColor));
1790 : }
1791 : else
1792 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_1);
1793 : // Light 1 (on/off)
1794 0 : eState = m_pBtnLight1->GetState();
1795 0 : if( eState != TRISTATE_INDET )
1796 : {
1797 0 : bool bValue = GetUILightState(*m_pBtnLight1);
1798 0 : rAttrs.Put(makeSvx3DLightOnOff1Item(bValue));
1799 :
1800 : // Light 1 (direction)
1801 0 : if( bValue )
1802 : {
1803 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1));
1804 : }
1805 : }
1806 : else
1807 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_1);
1808 :
1809 :
1810 : // Light 2 color
1811 0 : if( m_pLbLight2->GetSelectEntryCount() )
1812 : {
1813 0 : aColor = m_pLbLight2->GetSelectEntryColor();
1814 0 : rAttrs.Put(makeSvx3DLightcolor2Item(aColor));
1815 : }
1816 : else
1817 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_2);
1818 : // Light 2 (on/off)
1819 0 : eState = m_pBtnLight2->GetState();
1820 0 : if( eState != TRISTATE_INDET )
1821 : {
1822 0 : bool bValue = GetUILightState(*m_pBtnLight2);
1823 0 : rAttrs.Put(makeSvx3DLightOnOff2Item(bValue));
1824 :
1825 : // Light 2 (direction)
1826 0 : if( bValue )
1827 : {
1828 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2));
1829 : }
1830 : }
1831 : else
1832 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_2);
1833 :
1834 : // Light 3 color
1835 0 : if( m_pLbLight3->GetSelectEntryCount() )
1836 : {
1837 0 : aColor = m_pLbLight3->GetSelectEntryColor();
1838 0 : rAttrs.Put(makeSvx3DLightcolor3Item(aColor));
1839 : }
1840 : else
1841 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_3);
1842 : // Light 3 (on/off)
1843 0 : eState = m_pBtnLight3->GetState();
1844 0 : if( eState != TRISTATE_INDET )
1845 : {
1846 0 : bool bValue = GetUILightState(*m_pBtnLight3);
1847 0 : rAttrs.Put(makeSvx3DLightOnOff3Item(bValue));
1848 :
1849 : // Light 3 (direction)
1850 0 : if( bValue )
1851 : {
1852 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3));
1853 : }
1854 : }
1855 : else
1856 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_3);
1857 :
1858 : // Light 4 color
1859 0 : if( m_pLbLight4->GetSelectEntryCount() )
1860 : {
1861 0 : aColor = m_pLbLight4->GetSelectEntryColor();
1862 0 : rAttrs.Put(makeSvx3DLightcolor4Item(aColor));
1863 : }
1864 : else
1865 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_4);
1866 : // Light 4 (on/off)
1867 0 : eState = m_pBtnLight4->GetState();
1868 0 : if( eState != TRISTATE_INDET )
1869 : {
1870 0 : bool bValue = GetUILightState(*m_pBtnLight4);
1871 0 : rAttrs.Put(makeSvx3DLightOnOff4Item(bValue));
1872 :
1873 : // Light 4 (direction)
1874 0 : if( bValue )
1875 : {
1876 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4));
1877 : }
1878 : }
1879 : else
1880 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_4);
1881 :
1882 : // Light 5 color
1883 0 : if( m_pLbLight5->GetSelectEntryCount() )
1884 : {
1885 0 : aColor = m_pLbLight5->GetSelectEntryColor();
1886 0 : rAttrs.Put(makeSvx3DLightcolor5Item(aColor));
1887 : }
1888 : else
1889 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_5);
1890 : // Light 5 (on/off)
1891 0 : eState = m_pBtnLight5->GetState();
1892 0 : if( eState != TRISTATE_INDET )
1893 : {
1894 0 : bool bValue = GetUILightState(*m_pBtnLight5);
1895 0 : rAttrs.Put(makeSvx3DLightOnOff5Item(bValue));
1896 :
1897 : // Light 5 (direction)
1898 0 : if( bValue )
1899 : {
1900 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5));
1901 : }
1902 : }
1903 : else
1904 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_5);
1905 :
1906 : // Light 6 color
1907 0 : if( m_pLbLight6->GetSelectEntryCount() )
1908 : {
1909 0 : aColor = m_pLbLight6->GetSelectEntryColor();
1910 0 : rAttrs.Put(makeSvx3DLightcolor6Item(aColor));
1911 : }
1912 : else
1913 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_6);
1914 : // Light 6 (on/off)
1915 0 : eState = m_pBtnLight6->GetState();
1916 0 : if( eState != TRISTATE_INDET )
1917 : {
1918 0 : bool bValue = GetUILightState(*m_pBtnLight6);
1919 0 : rAttrs.Put(makeSvx3DLightOnOff6Item(bValue));
1920 :
1921 : // Light 6 (direction)
1922 0 : if( bValue )
1923 : {
1924 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6));
1925 : }
1926 : }
1927 : else
1928 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_6);
1929 :
1930 : // Light 7 color
1931 0 : if( m_pLbLight7->GetSelectEntryCount() )
1932 : {
1933 0 : aColor = m_pLbLight7->GetSelectEntryColor();
1934 0 : rAttrs.Put(makeSvx3DLightcolor7Item(aColor));
1935 : }
1936 : else
1937 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_7);
1938 : // Light 7 (on/off)
1939 0 : eState = m_pBtnLight7->GetState();
1940 0 : if( eState != TRISTATE_INDET )
1941 : {
1942 0 : bool bValue = GetUILightState(*m_pBtnLight7);
1943 0 : rAttrs.Put(makeSvx3DLightOnOff7Item(bValue));
1944 :
1945 : // Light 7 (direction)
1946 0 : if( bValue )
1947 : {
1948 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7));
1949 : }
1950 : }
1951 : else
1952 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_7);
1953 :
1954 : // Light 8 color
1955 0 : if( m_pLbLight8->GetSelectEntryCount() )
1956 : {
1957 0 : aColor = m_pLbLight8->GetSelectEntryColor();
1958 0 : rAttrs.Put(makeSvx3DLightcolor8Item(aColor));
1959 : }
1960 : else
1961 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_8);
1962 : // Light 8 (on/off)
1963 0 : eState = m_pBtnLight8->GetState();
1964 0 : if( eState != TRISTATE_INDET )
1965 : {
1966 0 : bool bValue = GetUILightState(*m_pBtnLight8);
1967 0 : rAttrs.Put(makeSvx3DLightOnOff8Item(bValue));
1968 :
1969 : // Light 8 (direction)
1970 0 : if( bValue )
1971 : {
1972 0 : rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8));
1973 : }
1974 : }
1975 : else
1976 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_8);
1977 :
1978 : // Ambient light
1979 0 : if( m_pLbAmbientlight->GetSelectEntryCount() )
1980 : {
1981 0 : aColor = m_pLbAmbientlight->GetSelectEntryColor();
1982 0 : rAttrs.Put(makeSvx3DAmbientcolorItem(aColor));
1983 : }
1984 : else
1985 0 : rAttrs.InvalidateItem(SDRATTR_3DSCENE_AMBIENTCOLOR);
1986 :
1987 : // Textures
1988 : // Art
1989 0 : nValue = 99;
1990 0 : if( m_pBtnTexLuminance->IsChecked() )
1991 0 : nValue = 1;
1992 0 : else if( m_pBtnTexColor->IsChecked() )
1993 0 : nValue = 3;
1994 :
1995 0 : if( nValue == 1 || nValue == 3 )
1996 0 : rAttrs.Put(Svx3DTextureKindItem(nValue));
1997 : else
1998 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_KIND);
1999 :
2000 :
2001 : // Mode
2002 0 : nValue = 99;
2003 0 : if( m_pBtnTexReplace->IsChecked() )
2004 0 : nValue = 1;
2005 0 : else if( m_pBtnTexModulate->IsChecked() )
2006 0 : nValue = 2;
2007 :
2008 0 : if( nValue == 1 || nValue == 2 )
2009 0 : rAttrs.Put(Svx3DTextureModeItem(nValue));
2010 : else
2011 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_MODE);
2012 :
2013 : // X projection
2014 0 : nValue = 99;
2015 0 : if( m_pBtnTexObjectX->IsChecked() )
2016 0 : nValue = 0;
2017 0 : else if( m_pBtnTexParallelX->IsChecked() )
2018 0 : nValue = 1;
2019 0 : else if( m_pBtnTexCircleX->IsChecked() )
2020 0 : nValue = 2;
2021 :
2022 0 : if( nValue <= 2 )
2023 0 : rAttrs.Put(Svx3DTextureProjectionXItem(nValue));
2024 : else
2025 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_PROJ_X);
2026 :
2027 : // Y projection
2028 0 : nValue = 99;
2029 0 : if( m_pBtnTexObjectY->IsChecked() )
2030 0 : nValue = 0;
2031 0 : else if( m_pBtnTexParallelY->IsChecked() )
2032 0 : nValue = 1;
2033 0 : else if( m_pBtnTexCircleY->IsChecked() )
2034 0 : nValue = 2;
2035 :
2036 0 : if( nValue <= 2 )
2037 0 : rAttrs.Put(Svx3DTextureProjectionYItem(nValue));
2038 : else
2039 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_PROJ_Y);
2040 :
2041 :
2042 : // Filter
2043 0 : eState = m_pBtnTexFilter->GetState();
2044 0 : if( eState != TRISTATE_INDET )
2045 : {
2046 0 : bool bValue = TRISTATE_TRUE == eState;
2047 0 : rAttrs.Put(makeSvx3DTextureFilterItem(bValue));
2048 : }
2049 : else
2050 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_FILTER);
2051 :
2052 :
2053 : // Material
2054 : // Object color
2055 0 : if( m_pLbMatColor->GetSelectEntryCount() )
2056 : {
2057 0 : aColor = m_pLbMatColor->GetSelectEntryColor();
2058 0 : rAttrs.Put( XFillColorItem( "", aColor) );
2059 : }
2060 : else
2061 : {
2062 0 : rAttrs.InvalidateItem( XATTR_FILLCOLOR );
2063 : }
2064 :
2065 : // luminous color
2066 0 : if( m_pLbMatEmission->GetSelectEntryCount() )
2067 : {
2068 0 : aColor = m_pLbMatEmission->GetSelectEntryColor();
2069 0 : rAttrs.Put(makeSvx3DMaterialEmissionItem(aColor));
2070 : }
2071 : else
2072 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_EMISSION);
2073 :
2074 : // Specular
2075 0 : if( m_pLbMatSpecular->GetSelectEntryCount() )
2076 : {
2077 0 : aColor = m_pLbMatSpecular->GetSelectEntryColor();
2078 0 : rAttrs.Put(makeSvx3DMaterialSpecularItem(aColor));
2079 : }
2080 : else
2081 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_SPECULAR);
2082 :
2083 : // Specular intensity
2084 0 : if( !m_pMtrMatSpecularIntensity->IsEmptyFieldValue() )
2085 : {
2086 0 : sal_uInt16 nValue2 = (sal_uInt16) m_pMtrMatSpecularIntensity->GetValue();
2087 0 : rAttrs.Put(makeSvx3DMaterialSpecularIntensityItem(nValue2));
2088 : }
2089 : else
2090 0 : rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY);
2091 0 : }
2092 :
2093 0 : void Svx3DWin::Resize()
2094 : {
2095 0 : if ( !IsFloatingMode() ||
2096 0 : !GetFloatingWindow()->IsRollUp() )
2097 : {
2098 0 : Size aWinSize( GetOutputSizePixel() ); // why rSize in Resizing()?
2099 :
2100 0 : if( aWinSize.Height() >= GetMinOutputSizePixel().Height() &&
2101 0 : aWinSize.Width() >= GetMinOutputSizePixel().Width() )
2102 : {
2103 : // Hide
2104 0 : m_pBtnUpdate->Hide();
2105 0 : m_pBtnAssign->Hide();
2106 :
2107 0 : m_pBtnConvertTo3D->Hide();
2108 0 : m_pBtnLatheObject->Hide();
2109 0 : m_pBtnPerspective->Hide();
2110 :
2111 0 : m_pCtlPreview->Hide();
2112 0 : m_pCtlLightPreview->Hide();
2113 :
2114 0 : m_pFLGeometrie->Hide();
2115 0 : m_pFLRepresentation->Hide();
2116 0 : m_pFLLight->Hide();
2117 0 : m_pFLTexture->Hide();
2118 0 : m_pFLMaterial->Hide();
2119 :
2120 : // Show
2121 0 : m_pBtnUpdate->Show();
2122 0 : m_pBtnAssign->Show();
2123 :
2124 0 : m_pBtnConvertTo3D->Show();
2125 0 : m_pBtnLatheObject->Show();
2126 0 : m_pBtnPerspective->Show();
2127 :
2128 0 : if( m_pBtnGeo->IsChecked() )
2129 0 : ClickViewTypeHdl(m_pBtnGeo);
2130 0 : if( m_pBtnRepresentation->IsChecked() )
2131 0 : ClickViewTypeHdl(m_pBtnRepresentation);
2132 0 : if( m_pBtnLight->IsChecked() )
2133 0 : ClickViewTypeHdl(m_pBtnLight);
2134 0 : if( m_pBtnTexture->IsChecked() )
2135 0 : ClickViewTypeHdl(m_pBtnTexture);
2136 0 : if( m_pBtnMaterial->IsChecked() )
2137 0 : ClickViewTypeHdl(m_pBtnMaterial);
2138 : }
2139 : }
2140 :
2141 0 : SfxDockingWindow::Resize();
2142 0 : }
2143 :
2144 0 : IMPL_LINK_NOARG(Svx3DWin, ClickUpdateHdl)
2145 : {
2146 0 : bUpdate = !m_pBtnUpdate->IsChecked();
2147 0 : m_pBtnUpdate->Check( bUpdate );
2148 :
2149 0 : if( bUpdate )
2150 : {
2151 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings);
2152 0 : if (pDispatcher != NULL)
2153 : {
2154 0 : SfxBoolItem aItem( SID_3D_STATE, true );
2155 : pDispatcher->Execute(
2156 0 : SID_3D_STATE, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
2157 : }
2158 : }
2159 : else
2160 : {
2161 : // Controls can be disabled during certain circumstances
2162 : }
2163 :
2164 0 : return 0L;
2165 : }
2166 :
2167 :
2168 0 : IMPL_LINK_NOARG(Svx3DWin, ClickAssignHdl)
2169 : {
2170 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings);
2171 0 : if (pDispatcher != NULL)
2172 : {
2173 0 : SfxBoolItem aItem( SID_3D_ASSIGN, true );
2174 : pDispatcher->Execute(
2175 0 : SID_3D_ASSIGN, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
2176 : }
2177 :
2178 0 : return 0L;
2179 : }
2180 :
2181 :
2182 :
2183 0 : IMPL_LINK( Svx3DWin, ClickViewTypeHdl, void *, pBtn )
2184 : {
2185 :
2186 0 : if( pBtn )
2187 : {
2188 : // Since the permanent updating of the preview would be too expensive
2189 0 : bool bUpdatePreview = m_pBtnLight->IsChecked();
2190 :
2191 0 : m_pBtnGeo->Check(m_pBtnGeo == pBtn);
2192 0 : m_pBtnRepresentation->Check(m_pBtnRepresentation == pBtn);
2193 0 : m_pBtnLight->Check(m_pBtnLight == pBtn);
2194 0 : m_pBtnTexture->Check(m_pBtnTexture == pBtn);
2195 0 : m_pBtnMaterial->Check(m_pBtnMaterial == pBtn);
2196 :
2197 0 : if( m_pBtnGeo->IsChecked() )
2198 0 : eViewType = VIEWTYPE_GEO;
2199 0 : if( m_pBtnRepresentation->IsChecked() )
2200 0 : eViewType = VIEWTYPE_REPRESENTATION;
2201 0 : if( m_pBtnLight->IsChecked() )
2202 0 : eViewType = VIEWTYPE_LIGHT;
2203 0 : if( m_pBtnTexture->IsChecked() )
2204 0 : eViewType = VIEWTYPE_TEXTURE;
2205 0 : if( m_pBtnMaterial->IsChecked() )
2206 0 : eViewType = VIEWTYPE_MATERIAL;
2207 :
2208 : // Geometry
2209 0 : if( eViewType == VIEWTYPE_GEO )
2210 : {
2211 0 : m_pFLSegments->Show();
2212 0 : m_pFLGeometrie->Show();
2213 0 : m_pFLNormals->Show();
2214 : }
2215 : else
2216 : {
2217 0 : m_pFLSegments->Hide();
2218 0 : m_pFLGeometrie->Hide();
2219 0 : m_pFLNormals->Hide();
2220 : }
2221 :
2222 : // Representation
2223 0 : if( eViewType == VIEWTYPE_REPRESENTATION )
2224 : {
2225 0 : m_pFLShadow->Show();
2226 0 : m_pFLCamera->Show();
2227 0 : m_pFLRepresentation->Show();
2228 : }
2229 : else
2230 : {
2231 0 : m_pFLShadow->Hide();
2232 0 : m_pFLCamera->Hide();
2233 0 : m_pFLRepresentation->Hide();
2234 : }
2235 :
2236 : // Lighting
2237 0 : if( eViewType == VIEWTYPE_LIGHT )
2238 : {
2239 0 : m_pFLLight->Show();
2240 :
2241 0 : ColorLB* pLb = GetLbByButton();
2242 0 : if( pLb )
2243 0 : pLb->Show();
2244 :
2245 0 : m_pCtlLightPreview->Show();
2246 0 : m_pCtlPreview->Hide();
2247 : }
2248 : else
2249 : {
2250 0 : m_pFLLight->Hide();
2251 :
2252 0 : if( !m_pCtlPreview->IsVisible() )
2253 : {
2254 0 : m_pCtlPreview->Show();
2255 0 : m_pCtlLightPreview->Hide();
2256 : }
2257 : }
2258 :
2259 : // Textures
2260 0 : if (eViewType == VIEWTYPE_TEXTURE)
2261 0 : m_pFLTexture->Show();
2262 : else
2263 0 : m_pFLTexture->Hide();
2264 :
2265 : // Material
2266 0 : if( eViewType == VIEWTYPE_MATERIAL )
2267 : {
2268 0 : m_pFLMatSpecular->Show();
2269 0 : m_pFLMaterial->Show();
2270 : }
2271 : else
2272 : {
2273 0 : m_pFLMatSpecular->Hide();
2274 0 : m_pFLMaterial->Hide();
2275 : }
2276 0 : if( bUpdatePreview && !m_pBtnLight->IsChecked() )
2277 0 : UpdatePreview();
2278 :
2279 : }
2280 : else
2281 : {
2282 0 : m_pBtnGeo->Check( eViewType == VIEWTYPE_GEO );
2283 0 : m_pBtnRepresentation->Check( eViewType == VIEWTYPE_REPRESENTATION );
2284 0 : m_pBtnLight->Check( eViewType == VIEWTYPE_LIGHT );
2285 0 : m_pBtnTexture->Check( eViewType == VIEWTYPE_TEXTURE );
2286 0 : m_pBtnMaterial->Check( eViewType == VIEWTYPE_MATERIAL );
2287 : }
2288 0 : return 0L;
2289 : }
2290 :
2291 :
2292 0 : IMPL_LINK( Svx3DWin, ClickHdl, PushButton *, pBtn )
2293 : {
2294 0 : if( pBtn )
2295 : {
2296 0 : bool bUpdatePreview = false;
2297 0 : sal_uInt16 nSId = 0;
2298 :
2299 0 : if( pBtn == m_pBtnConvertTo3D )
2300 : {
2301 0 : nSId = SID_CONVERT_TO_3D;
2302 : }
2303 0 : else if( pBtn == m_pBtnLatheObject )
2304 : {
2305 0 : nSId = SID_CONVERT_TO_3D_LATHE_FAST;
2306 : }
2307 : // Geometry
2308 0 : else if( pBtn == m_pBtnNormalsObj ||
2309 0 : pBtn == m_pBtnNormalsFlat ||
2310 0 : pBtn == m_pBtnNormalsSphere )
2311 : {
2312 0 : m_pBtnNormalsObj->Check( pBtn == m_pBtnNormalsObj );
2313 0 : m_pBtnNormalsFlat->Check( pBtn == m_pBtnNormalsFlat );
2314 0 : m_pBtnNormalsSphere->Check( pBtn == m_pBtnNormalsSphere );
2315 0 : bUpdatePreview = true;
2316 : }
2317 0 : else if( pBtn == m_pBtnLight1 ||
2318 0 : pBtn == m_pBtnLight2 ||
2319 0 : pBtn == m_pBtnLight3 ||
2320 0 : pBtn == m_pBtnLight4 ||
2321 0 : pBtn == m_pBtnLight5 ||
2322 0 : pBtn == m_pBtnLight6 ||
2323 0 : pBtn == m_pBtnLight7 ||
2324 0 : pBtn == m_pBtnLight8 )
2325 : {
2326 : // Lighting
2327 0 : ColorLB* pLb = GetLbByButton( pBtn );
2328 0 : pLb->Show();
2329 :
2330 0 : if( pBtn->IsChecked() )
2331 : {
2332 0 : SetUILightState( *static_cast<ImageButton*>(pBtn), !GetUILightState( *static_cast<ImageButton*>(pBtn) ) );
2333 : }
2334 : else
2335 : {
2336 0 : pBtn->Check();
2337 :
2338 0 : if (pBtn != m_pBtnLight1 && m_pBtnLight1->IsChecked())
2339 : {
2340 0 : m_pBtnLight1->Check( false );
2341 0 : m_pLbLight1->Hide();
2342 : }
2343 0 : if (pBtn != m_pBtnLight2 && m_pBtnLight2->IsChecked())
2344 : {
2345 0 : m_pBtnLight2->Check( false );
2346 0 : m_pLbLight2->Hide();
2347 : }
2348 0 : if( pBtn != m_pBtnLight3 && m_pBtnLight3->IsChecked() )
2349 : {
2350 0 : m_pBtnLight3->Check( false );
2351 0 : m_pLbLight3->Hide();
2352 : }
2353 0 : if( pBtn != m_pBtnLight4 && m_pBtnLight4->IsChecked() )
2354 : {
2355 0 : m_pBtnLight4->Check( false );
2356 0 : m_pLbLight4->Hide();
2357 : }
2358 0 : if( pBtn != m_pBtnLight5 && m_pBtnLight5->IsChecked() )
2359 : {
2360 0 : m_pBtnLight5->Check( false );
2361 0 : m_pLbLight5->Hide();
2362 : }
2363 0 : if( pBtn != m_pBtnLight6 && m_pBtnLight6->IsChecked() )
2364 : {
2365 0 : m_pBtnLight6->Check( false );
2366 0 : m_pLbLight6->Hide();
2367 : }
2368 0 : if( pBtn != m_pBtnLight7 && m_pBtnLight7->IsChecked() )
2369 : {
2370 0 : m_pBtnLight7->Check( false );
2371 0 : m_pLbLight7->Hide();
2372 : }
2373 0 : if( pBtn != m_pBtnLight8 && m_pBtnLight8->IsChecked() )
2374 : {
2375 0 : m_pBtnLight8->Check( false );
2376 0 : m_pLbLight8->Hide();
2377 : }
2378 : }
2379 0 : bool bEnable = GetUILightState( *static_cast<ImageButton*>(pBtn) );
2380 0 : m_pBtnLightColor->Enable( bEnable );
2381 0 : pLb->Enable( bEnable );
2382 :
2383 0 : ClickLight(*pBtn);
2384 0 : bUpdatePreview = true;
2385 : }
2386 : // Textures
2387 0 : else if( pBtn == m_pBtnTexLuminance ||
2388 0 : pBtn == m_pBtnTexColor )
2389 : {
2390 0 : m_pBtnTexLuminance->Check( pBtn == m_pBtnTexLuminance );
2391 0 : m_pBtnTexColor->Check( pBtn == m_pBtnTexColor );
2392 0 : bUpdatePreview = true;
2393 : }
2394 0 : else if( pBtn == m_pBtnTexReplace ||
2395 0 : pBtn == m_pBtnTexModulate )
2396 : {
2397 0 : m_pBtnTexReplace->Check( pBtn == m_pBtnTexReplace );
2398 0 : m_pBtnTexModulate->Check( pBtn == m_pBtnTexModulate );
2399 0 : bUpdatePreview = true;
2400 : }
2401 0 : else if( pBtn == m_pBtnTexParallelX ||
2402 0 : pBtn == m_pBtnTexCircleX ||
2403 0 : pBtn == m_pBtnTexObjectX )
2404 : {
2405 0 : m_pBtnTexParallelX->Check( pBtn == m_pBtnTexParallelX );
2406 0 : m_pBtnTexCircleX->Check( pBtn == m_pBtnTexCircleX );
2407 0 : m_pBtnTexObjectX->Check( pBtn == m_pBtnTexObjectX );
2408 0 : bUpdatePreview = true;
2409 : }
2410 0 : else if( pBtn == m_pBtnTexParallelY ||
2411 0 : pBtn == m_pBtnTexCircleY ||
2412 0 : pBtn == m_pBtnTexObjectY )
2413 : {
2414 0 : m_pBtnTexParallelY->Check( pBtn == m_pBtnTexParallelY );
2415 0 : m_pBtnTexCircleY->Check( pBtn == m_pBtnTexCircleY );
2416 0 : m_pBtnTexObjectY->Check( pBtn == m_pBtnTexObjectY );
2417 0 : bUpdatePreview = true;
2418 : }
2419 0 : else if (pBtn == m_pBtnShadow3d)
2420 : {
2421 0 : pBtn->Check( !pBtn->IsChecked() );
2422 0 : m_pFtSlant->Enable( pBtn->IsChecked() );
2423 0 : m_pMtrSlant->Enable( pBtn->IsChecked() );
2424 0 : bUpdatePreview = true;
2425 : }
2426 : // Other (no groups)
2427 0 : else if( pBtn != NULL )
2428 : {
2429 0 : pBtn->Check( !pBtn->IsChecked() );
2430 0 : bUpdatePreview = true;
2431 : }
2432 :
2433 0 : if( nSId > 0 )
2434 : {
2435 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings);
2436 0 : if (pDispatcher != NULL)
2437 : {
2438 0 : SfxBoolItem aItem( nSId, true );
2439 : pDispatcher->Execute(
2440 0 : nSId, SfxCallMode::ASYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
2441 : }
2442 : }
2443 0 : else if( bUpdatePreview )
2444 0 : UpdatePreview();
2445 : }
2446 0 : return 0L;
2447 : }
2448 :
2449 :
2450 :
2451 0 : IMPL_LINK( Svx3DWin, ClickColorHdl, PushButton *, pBtn )
2452 : {
2453 0 : SvColorDialog aColorDlg( this );
2454 : ColorLB* pLb;
2455 :
2456 0 : if( pBtn == m_pBtnLightColor )
2457 0 : pLb = GetLbByButton();
2458 0 : else if( pBtn == m_pBtnAmbientColor )
2459 0 : pLb = m_pLbAmbientlight;
2460 0 : else if( pBtn == m_pBtnMatColor )
2461 0 : pLb = m_pLbMatColor;
2462 0 : else if( pBtn == m_pBtnEmissionColor )
2463 0 : pLb = m_pLbMatEmission;
2464 : else // if( pBtn == m_pBtnSpecularColor )
2465 0 : pLb = m_pLbMatSpecular;
2466 :
2467 0 : Color aColor = pLb->GetSelectEntryColor();
2468 :
2469 0 : aColorDlg.SetColor( aColor );
2470 0 : if( aColorDlg.Execute() == RET_OK )
2471 : {
2472 0 : aColor = aColorDlg.GetColor();
2473 0 : if( LBSelectColor( pLb, aColor ) )
2474 0 : SelectHdl( pLb );
2475 : }
2476 0 : return 0L;
2477 : }
2478 :
2479 :
2480 0 : IMPL_LINK( Svx3DWin, SelectHdl, void *, p )
2481 : {
2482 0 : if( p )
2483 : {
2484 0 : bool bUpdatePreview = false;
2485 :
2486 : // Material
2487 0 : if (p == m_pLbMatFavorites)
2488 : {
2489 0 : Color aColObj( COL_WHITE );
2490 0 : Color aColEmis( COL_BLACK );
2491 0 : Color aColSpec( COL_WHITE );
2492 0 : sal_uInt16 nSpecIntens = 20;
2493 :
2494 0 : sal_uInt16 nPos = m_pLbMatFavorites->GetSelectEntryPos();
2495 0 : switch( nPos )
2496 : {
2497 : case 1: // Metall
2498 : {
2499 0 : aColObj = Color(230,230,255);
2500 0 : aColEmis = Color(10,10,30);
2501 0 : aColSpec = Color(200,200,200);
2502 0 : nSpecIntens = 20;
2503 : }
2504 0 : break;
2505 :
2506 : case 2: // Gold
2507 : {
2508 0 : aColObj = Color(230,255,0);
2509 0 : aColEmis = Color(51,0,0);
2510 0 : aColSpec = Color(255,255,240);
2511 0 : nSpecIntens = 20;
2512 : }
2513 0 : break;
2514 :
2515 : case 3: // Chrome
2516 : {
2517 0 : aColObj = Color(36,117,153);
2518 0 : aColEmis = Color(18,30,51);
2519 0 : aColSpec = Color(230,230,255);
2520 0 : nSpecIntens = 2;
2521 : }
2522 0 : break;
2523 :
2524 : case 4: // Plastic
2525 : {
2526 0 : aColObj = Color(255,48,57);
2527 0 : aColEmis = Color(35,0,0);
2528 0 : aColSpec = Color(179,202,204);
2529 0 : nSpecIntens = 60;
2530 : }
2531 0 : break;
2532 :
2533 : case 5: // Wood
2534 : {
2535 0 : aColObj = Color(153,71,1);
2536 0 : aColEmis = Color(21,22,0);
2537 0 : aColSpec = Color(255,255,153);
2538 0 : nSpecIntens = 75;
2539 : }
2540 0 : break;
2541 : }
2542 0 : LBSelectColor( m_pLbMatColor, aColObj );
2543 0 : LBSelectColor( m_pLbMatEmission, aColEmis );
2544 0 : LBSelectColor( m_pLbMatSpecular, aColSpec );
2545 0 : m_pMtrMatSpecularIntensity->SetValue( nSpecIntens );
2546 :
2547 0 : bUpdatePreview = true;
2548 : }
2549 0 : else if( p == m_pLbMatColor ||
2550 0 : p == m_pLbMatEmission ||
2551 0 : p == m_pLbMatSpecular )
2552 : {
2553 0 : m_pLbMatFavorites->SelectEntryPos( 0 );
2554 0 : bUpdatePreview = true;
2555 : }
2556 : // Lighting
2557 0 : else if( p == m_pLbAmbientlight )
2558 : {
2559 0 : bUpdatePreview = true;
2560 : }
2561 0 : else if( p == m_pLbLight1 ||
2562 0 : p == m_pLbLight2 ||
2563 0 : p == m_pLbLight3 ||
2564 0 : p == m_pLbLight4 ||
2565 0 : p == m_pLbLight5 ||
2566 0 : p == m_pLbLight6 ||
2567 0 : p == m_pLbLight7 ||
2568 0 : p == m_pLbLight8 )
2569 : {
2570 0 : bUpdatePreview = true;
2571 : }
2572 0 : else if (p == m_pLbShademode)
2573 0 : bUpdatePreview = true;
2574 :
2575 0 : if( bUpdatePreview )
2576 0 : UpdatePreview();
2577 : }
2578 0 : return 0L;
2579 : }
2580 :
2581 :
2582 0 : IMPL_LINK( Svx3DWin, ModifyHdl, void*, pField )
2583 : {
2584 0 : if( pField )
2585 : {
2586 0 : bool bUpdatePreview = false;
2587 :
2588 : // Material
2589 0 : if( pField == m_pMtrMatSpecularIntensity )
2590 : {
2591 0 : bUpdatePreview = true;
2592 : }
2593 0 : else if (pField == m_pNumHorizontal)
2594 : {
2595 0 : bUpdatePreview = true;
2596 : }
2597 0 : else if (pField == m_pNumVertical)
2598 : {
2599 0 : bUpdatePreview = true;
2600 : }
2601 0 : else if (pField == m_pMtrSlant)
2602 : {
2603 0 : bUpdatePreview = true;
2604 : }
2605 :
2606 0 : if( bUpdatePreview )
2607 0 : UpdatePreview();
2608 : }
2609 0 : return 0L;
2610 : }
2611 :
2612 :
2613 :
2614 0 : void Svx3DWin::ClickLight(PushButton& rBtn)
2615 : {
2616 0 : sal_uInt16 nLightSource = GetLightSource( &rBtn );
2617 0 : ColorLB* pLb = GetLbByButton( &rBtn );
2618 0 : Color aColor( pLb->GetSelectEntryColor() );
2619 0 : SfxItemSet aLightItemSet(m_pCtlLightPreview->GetSvx3DLightControl().Get3DAttributes());
2620 0 : const bool bOnOff(GetUILightState( static_cast<const ImageButton&>(rBtn) ));
2621 :
2622 0 : switch(nLightSource)
2623 : {
2624 0 : case 0: aLightItemSet.Put(makeSvx3DLightcolor1Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff1Item(bOnOff)); break;
2625 0 : case 1: aLightItemSet.Put(makeSvx3DLightcolor2Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff2Item(bOnOff)); break;
2626 0 : case 2: aLightItemSet.Put(makeSvx3DLightcolor3Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff3Item(bOnOff)); break;
2627 0 : case 3: aLightItemSet.Put(makeSvx3DLightcolor4Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff4Item(bOnOff)); break;
2628 0 : case 4: aLightItemSet.Put(makeSvx3DLightcolor5Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff5Item(bOnOff)); break;
2629 0 : case 5: aLightItemSet.Put(makeSvx3DLightcolor6Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff6Item(bOnOff)); break;
2630 0 : case 6: aLightItemSet.Put(makeSvx3DLightcolor7Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff7Item(bOnOff)); break;
2631 : default:
2632 0 : case 7: aLightItemSet.Put(makeSvx3DLightcolor8Item(aColor)); aLightItemSet.Put(makeSvx3DLightOnOff8Item(bOnOff)); break;
2633 : }
2634 :
2635 0 : m_pCtlLightPreview->GetSvx3DLightControl().Set3DAttributes(aLightItemSet);
2636 0 : m_pCtlLightPreview->GetSvx3DLightControl().SelectLight(nLightSource);
2637 0 : m_pCtlLightPreview->CheckSelection();
2638 0 : }
2639 :
2640 :
2641 :
2642 0 : IMPL_LINK_NOARG(Svx3DWin, ChangeSelectionCallbackHdl)
2643 : {
2644 0 : const sal_uInt32 nLight(m_pCtlLightPreview->GetSvx3DLightControl().GetSelectedLight());
2645 0 : PushButton* pBtn = 0;
2646 :
2647 0 : switch( nLight )
2648 : {
2649 0 : case 0: pBtn = m_pBtnLight1; break;
2650 0 : case 1: pBtn = m_pBtnLight2; break;
2651 0 : case 2: pBtn = m_pBtnLight3; break;
2652 0 : case 3: pBtn = m_pBtnLight4; break;
2653 0 : case 4: pBtn = m_pBtnLight5; break;
2654 0 : case 5: pBtn = m_pBtnLight6; break;
2655 0 : case 6: pBtn = m_pBtnLight7; break;
2656 0 : case 7: pBtn = m_pBtnLight8; break;
2657 0 : default: break;
2658 : }
2659 :
2660 0 : if( pBtn )
2661 0 : ClickHdl( pBtn );
2662 : else
2663 : {
2664 : // Status: No lamp selected
2665 0 : if( m_pBtnLight1->IsChecked() )
2666 : {
2667 0 : m_pBtnLight1->Check( false );
2668 0 : m_pLbLight1->Enable( false );
2669 : }
2670 0 : else if( m_pBtnLight2->IsChecked() )
2671 : {
2672 0 : m_pBtnLight2->Check( false );
2673 0 : m_pLbLight2->Enable( false );
2674 : }
2675 0 : else if( m_pBtnLight3->IsChecked() )
2676 : {
2677 0 : m_pBtnLight3->Check( false );
2678 0 : m_pLbLight3->Enable( false );
2679 : }
2680 0 : else if( m_pBtnLight4->IsChecked() )
2681 : {
2682 0 : m_pBtnLight4->Check( false );
2683 0 : m_pLbLight4->Enable( false );
2684 : }
2685 0 : else if( m_pBtnLight5->IsChecked() )
2686 : {
2687 0 : m_pBtnLight5->Check( false );
2688 0 : m_pLbLight5->Enable( false );
2689 : }
2690 0 : else if( m_pBtnLight6->IsChecked() )
2691 : {
2692 0 : m_pBtnLight6->Check( false );
2693 0 : m_pLbLight6->Enable( false );
2694 : }
2695 0 : else if( m_pBtnLight7->IsChecked() )
2696 : {
2697 0 : m_pBtnLight7->Check( false );
2698 0 : m_pLbLight7->Enable( false );
2699 : }
2700 0 : else if( m_pBtnLight8->IsChecked() )
2701 : {
2702 0 : m_pBtnLight8->Check( false );
2703 0 : m_pLbLight8->Enable( false );
2704 : }
2705 0 : m_pBtnLightColor->Enable( false );
2706 : }
2707 :
2708 0 : return 0L;
2709 : }
2710 :
2711 :
2712 : // Method to ensure that the LB is also associated with a color
2713 : // returns true if color was added
2714 :
2715 0 : bool Svx3DWin::LBSelectColor( ColorLB* pLb, const Color& rColor )
2716 : {
2717 0 : bool bRet = false;
2718 :
2719 0 : pLb->SetNoSelection();
2720 0 : pLb->SelectEntry( rColor );
2721 0 : if( pLb->GetSelectEntryCount() == 0 )
2722 : {
2723 0 : OUString aStr(SVX_RESSTR(RID_SVXFLOAT3D_FIX_R));
2724 :
2725 0 : aStr += OUString::number((sal_Int32)rColor.GetRed());
2726 0 : aStr += " ";
2727 0 : aStr += SVX_RESSTR(RID_SVXFLOAT3D_FIX_G);
2728 0 : aStr += OUString::number((sal_Int32)rColor.GetGreen());
2729 0 : aStr += " ";
2730 0 : aStr += SVX_RESSTR(RID_SVXFLOAT3D_FIX_B);
2731 0 : aStr += OUString::number((sal_Int32)rColor.GetBlue());
2732 :
2733 0 : sal_uInt16 nPos = pLb->InsertEntry( rColor, aStr );
2734 0 : pLb->SelectEntryPos( nPos );
2735 0 : bRet = true;
2736 : }
2737 0 : return bRet;
2738 : }
2739 :
2740 :
2741 0 : void Svx3DWin::UpdatePreview()
2742 : {
2743 0 : if( pModel == NULL )
2744 0 : pModel = new FmFormModel();
2745 :
2746 0 : if(bOnly3DChanged)
2747 : {
2748 : // Execute slot
2749 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings);
2750 0 : if (pDispatcher != NULL)
2751 : {
2752 0 : SfxBoolItem aItem( SID_3D_STATE, true );
2753 : pDispatcher->Execute(
2754 0 : SID_3D_STATE, SfxCallMode::SYNCHRON | SfxCallMode::RECORD, &aItem, 0L );
2755 : }
2756 : // Reset Flag
2757 0 : bOnly3DChanged = false;
2758 : }
2759 :
2760 : // Get Itemset
2761 0 : SfxItemSet aSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END);
2762 :
2763 : // Get Attributes and set the preview
2764 0 : GetAttr( aSet );
2765 0 : m_pCtlPreview->Set3DAttributes( aSet );
2766 0 : m_pCtlLightPreview->GetSvx3DLightControl().Set3DAttributes( aSet );
2767 0 : }
2768 :
2769 :
2770 : // document is to be reloaded, destroy remembered ItemSet
2771 0 : void Svx3DWin::DocumentReload()
2772 : {
2773 0 : delete mpRemember2DAttributes;
2774 0 : mpRemember2DAttributes = 0L;
2775 0 : }
2776 :
2777 :
2778 0 : void Svx3DWin::InitColorLB( const SdrModel* pDoc )
2779 : {
2780 0 : m_pLbLight1->Fill( pDoc->GetColorList() );
2781 0 : m_pLbLight2->CopyEntries( *m_pLbLight1 );
2782 0 : m_pLbLight3->CopyEntries( *m_pLbLight1 );
2783 0 : m_pLbLight4->CopyEntries( *m_pLbLight1 );
2784 0 : m_pLbLight5->CopyEntries( *m_pLbLight1 );
2785 0 : m_pLbLight6->CopyEntries( *m_pLbLight1 );
2786 0 : m_pLbLight7->CopyEntries( *m_pLbLight1 );
2787 0 : m_pLbLight8->CopyEntries( *m_pLbLight1 );
2788 0 : m_pLbAmbientlight->CopyEntries( *m_pLbLight1 );
2789 0 : m_pLbMatColor->CopyEntries( *m_pLbLight1 );
2790 0 : m_pLbMatEmission->CopyEntries( *m_pLbLight1 );
2791 0 : m_pLbMatSpecular->CopyEntries( *m_pLbLight1 );
2792 :
2793 : // First...
2794 0 : Color aColWhite( COL_WHITE );
2795 0 : Color aColBlack( COL_BLACK );
2796 0 : m_pLbLight1->SelectEntry( aColWhite );
2797 0 : m_pLbLight2->SelectEntry( aColWhite );
2798 0 : m_pLbLight3->SelectEntry( aColWhite );
2799 0 : m_pLbLight4->SelectEntry( aColWhite );
2800 0 : m_pLbLight5->SelectEntry( aColWhite );
2801 0 : m_pLbLight6->SelectEntry( aColWhite );
2802 0 : m_pLbLight7->SelectEntry( aColWhite );
2803 0 : m_pLbLight8->SelectEntry( aColWhite );
2804 0 : m_pLbAmbientlight->SelectEntry( aColBlack );
2805 0 : m_pLbMatColor->SelectEntry( aColWhite );
2806 0 : m_pLbMatEmission->SelectEntry( aColBlack );
2807 0 : m_pLbMatSpecular->SelectEntry( aColWhite );
2808 0 : }
2809 :
2810 :
2811 0 : sal_uInt16 Svx3DWin::GetLightSource( const PushButton* pBtn )
2812 : {
2813 0 : sal_uInt16 nLight = 8;
2814 :
2815 0 : if( pBtn == NULL )
2816 : {
2817 0 : if( m_pBtnLight1->IsChecked() )
2818 0 : nLight = 0;
2819 0 : else if( m_pBtnLight2->IsChecked() )
2820 0 : nLight = 1;
2821 0 : else if( m_pBtnLight3->IsChecked() )
2822 0 : nLight = 2;
2823 0 : else if( m_pBtnLight4->IsChecked() )
2824 0 : nLight = 3;
2825 0 : else if( m_pBtnLight5->IsChecked() )
2826 0 : nLight = 4;
2827 0 : else if( m_pBtnLight6->IsChecked() )
2828 0 : nLight = 5;
2829 0 : else if( m_pBtnLight7->IsChecked() )
2830 0 : nLight = 6;
2831 0 : else if( m_pBtnLight8->IsChecked() )
2832 0 : nLight = 7;
2833 : }
2834 : else
2835 : {
2836 0 : if (pBtn == m_pBtnLight1)
2837 0 : nLight = 0;
2838 0 : else if (pBtn == m_pBtnLight2)
2839 0 : nLight = 1;
2840 0 : else if( pBtn == m_pBtnLight3 )
2841 0 : nLight = 2;
2842 0 : else if( pBtn == m_pBtnLight4 )
2843 0 : nLight = 3;
2844 0 : else if( pBtn == m_pBtnLight5 )
2845 0 : nLight = 4;
2846 0 : else if( pBtn == m_pBtnLight6 )
2847 0 : nLight = 5;
2848 0 : else if( pBtn == m_pBtnLight7 )
2849 0 : nLight = 6;
2850 0 : else if( pBtn == m_pBtnLight8 )
2851 0 : nLight = 7;
2852 : }
2853 0 : return nLight;
2854 : };
2855 :
2856 :
2857 0 : ColorLB* Svx3DWin::GetLbByButton( const PushButton* pBtn )
2858 : {
2859 0 : ColorLB* pLb = NULL;
2860 :
2861 0 : if( pBtn == NULL )
2862 : {
2863 0 : if( m_pBtnLight1->IsChecked() )
2864 0 : pLb = m_pLbLight1;
2865 0 : else if( m_pBtnLight2->IsChecked() )
2866 0 : pLb = m_pLbLight2;
2867 0 : else if( m_pBtnLight3->IsChecked() )
2868 0 : pLb = m_pLbLight3;
2869 0 : else if( m_pBtnLight4->IsChecked() )
2870 0 : pLb = m_pLbLight4;
2871 0 : else if( m_pBtnLight5->IsChecked() )
2872 0 : pLb = m_pLbLight5;
2873 0 : else if( m_pBtnLight6->IsChecked() )
2874 0 : pLb = m_pLbLight6;
2875 0 : else if( m_pBtnLight7->IsChecked() )
2876 0 : pLb = m_pLbLight7;
2877 0 : else if( m_pBtnLight8->IsChecked() )
2878 0 : pLb = m_pLbLight8;
2879 : }
2880 : else
2881 : {
2882 0 : if( pBtn == m_pBtnLight1 )
2883 0 : pLb = m_pLbLight1;
2884 0 : else if (pBtn == m_pBtnLight2)
2885 0 : pLb = m_pLbLight2;
2886 0 : else if( pBtn == m_pBtnLight3 )
2887 0 : pLb = m_pLbLight3;
2888 0 : else if( pBtn == m_pBtnLight4 )
2889 0 : pLb = m_pLbLight4;
2890 0 : else if( pBtn == m_pBtnLight5 )
2891 0 : pLb = m_pLbLight5;
2892 0 : else if( pBtn == m_pBtnLight6 )
2893 0 : pLb = m_pLbLight6;
2894 0 : else if( pBtn == m_pBtnLight7 )
2895 0 : pLb = m_pLbLight7;
2896 0 : else if( pBtn == m_pBtnLight8 )
2897 0 : pLb = m_pLbLight8;
2898 : }
2899 0 : return pLb;
2900 : };
2901 :
2902 : // Derivation from SfxChildWindow as "containers" for effects
2903 :
2904 0 : Svx3DChildWindow::Svx3DChildWindow( vcl::Window* _pParent,
2905 : sal_uInt16 nId,
2906 : SfxBindings* pBindings,
2907 : SfxChildWinInfo* pInfo ) :
2908 0 : SfxChildWindow( _pParent, nId )
2909 : {
2910 0 : VclPtr<Svx3DWin> pWin = VclPtr<Svx3DWin>::Create( pBindings, this, _pParent );
2911 0 : pWindow = pWin;
2912 :
2913 0 : eChildAlignment = SfxChildAlignment::NOALIGNMENT;
2914 :
2915 0 : pWin->Initialize( pInfo );
2916 0 : }
2917 :
2918 0 : Svx3DCtrlItem::Svx3DCtrlItem( sal_uInt16 _nId,
2919 : SfxBindings* _pBindings) :
2920 0 : SfxControllerItem( _nId, *_pBindings )
2921 : {
2922 0 : }
2923 :
2924 :
2925 0 : void Svx3DCtrlItem::StateChanged( sal_uInt16 /*nSId*/,
2926 : SfxItemState /*eState*/, const SfxPoolItem* /*pItem*/ )
2927 : {
2928 0 : }
2929 :
2930 : // ControllerItem for Status Slot SID_CONVERT_TO_3D
2931 :
2932 0 : SvxConvertTo3DItem::SvxConvertTo3DItem(sal_uInt16 _nId, SfxBindings* _pBindings)
2933 : : SfxControllerItem(_nId, *_pBindings),
2934 0 : bState(false)
2935 : {
2936 0 : }
2937 :
2938 0 : void SvxConvertTo3DItem::StateChanged(sal_uInt16 /*_nId*/, SfxItemState eState, const SfxPoolItem* /*pState*/)
2939 : {
2940 0 : bool bNewState = (eState != SfxItemState::DISABLED);
2941 0 : if(bNewState != bState)
2942 : {
2943 0 : bState = bNewState;
2944 0 : SfxDispatcher* pDispatcher = LocalGetDispatcher(&GetBindings());
2945 0 : if (pDispatcher != NULL)
2946 : {
2947 0 : SfxBoolItem aItem( SID_3D_STATE, true );
2948 : pDispatcher->Execute(
2949 0 : SID_3D_STATE, SfxCallMode::ASYNCHRON|SfxCallMode::RECORD, &aItem, 0L);
2950 : }
2951 : }
2952 390 : }
2953 :
2954 :
2955 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
