| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svx.hxx" |
| #include <sfx2/dispatch.hxx> |
| #include <sfx2/module.hxx> |
| #include <sfx2/viewfrm.hxx> |
| #include <svl/eitem.hxx> |
| #include <svtools/colrdlg.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <sfx2/viewsh.hxx> |
| #include <tools/shl.hxx> |
| #include <svx/xflclit.hxx> |
| #include <svx/svdmodel.hxx> |
| #include <svx/globl3d.hxx> |
| #include <svx/view3d.hxx> |
| #include <svx/obj3d.hxx> |
| #include <svx/sphere3d.hxx> |
| #include <svx/scene3d.hxx> |
| #include <svx/camera3d.hxx> |
| #include <svx/fmmodel.hxx> |
| #include <svx/fmpage.hxx> |
| #include <svx/polysc3d.hxx> |
| #include <editeng/eeitem.hxx> |
| #include <svl/style.hxx> |
| #include <svx/dlgutil.hxx> |
| |
| #include <svx/dlgutil.hxx> |
| #include <svx/dialmgr.hxx> |
| #include <svx/viewpt3d.hxx> // ProjectionType |
| |
| #include <svx/svxids.hrc> |
| #include <svx/dialogs.hrc> |
| |
| #include <editeng/colritem.hxx> |
| #include <svx/e3ditem.hxx> |
| |
| #include <svx/gallery.hxx> |
| #define GALLERY_THEME "3D" |
| #include <svl/whiter.hxx> |
| |
| #include <svx/float3d.hxx> |
| #include "float3d.hrc" |
| |
| SFX_IMPL_DOCKINGWINDOW( Svx3DChildWindow, SID_3D_WIN ) |
| |
| struct Svx3DWinImpl |
| { |
| SfxItemPool* pPool; |
| Image maImgLightOnH; |
| Image maImgLightOffH; |
| }; |
| |
| #define SETHCIMAGE(btn,res) \ |
| { \ |
| Bitmap aBmp( SVX_RES( res ) ); \ |
| Image aImage( aBmp, COL_LIGHTMAGENTA ); \ |
| btn.SetModeImage( aImage, BMP_COLOR_HIGHCONTRAST ); \ |
| } |
| |
| namespace { |
| /** Get the dispatcher from the current view frame, or, if that is not |
| available, from the given bindings. |
| @param pBindings |
| May be NULL. |
| @returns NULL when both the current view frame is NULL and the given |
| bindings are NULL. |
| */ |
| SfxDispatcher* LocalGetDispatcher (const SfxBindings* pBindings) |
| { |
| SfxDispatcher* pDispatcher = NULL; |
| |
| if (SfxViewFrame::Current() != NULL) |
| pDispatcher = SfxViewFrame::Current()->GetDispatcher(); |
| else if (pBindings != NULL) |
| pDispatcher = pBindings->GetDispatcher(); |
| |
| return pDispatcher; |
| } |
| } |
| |
| |
| /************************************************************************* |
| |* Svx3DWin - FloatingWindow |
| \************************************************************************/ |
| __EXPORT Svx3DWin::Svx3DWin( SfxBindings* pInBindings, |
| SfxChildWindow *pCW, Window* pParent ) : |
| SfxDockingWindow ( pInBindings, pCW, pParent, |
| SVX_RES( RID_SVXFLOAT_3D ) ), |
| aBtnGeo ( this, SVX_RES( BTN_GEO ) ), |
| aBtnRepresentation ( this, SVX_RES( BTN_REPRESENTATION ) ), |
| aBtnLight ( this, SVX_RES( BTN_LIGHT ) ), |
| aBtnTexture ( this, SVX_RES( BTN_TEXTURE ) ), |
| aBtnMaterial ( this, SVX_RES( BTN_MATERIAL ) ), |
| aBtnUpdate ( this, SVX_RES( BTN_UPDATE ) ), |
| aBtnAssign ( this, SVX_RES( BTN_ASSIGN ) ), |
| aFLGeometrie ( this, SVX_RES( FL_GEOMETRIE ) ), |
| |
| // Geometrie |
| aFtPercentDiagonal ( this, SVX_RES( FT_PERCENT_DIAGONAL ) ), |
| aMtrPercentDiagonal ( this, SVX_RES( MTR_PERCENT_DIAGONAL ) ), |
| aFtBackscale ( this, SVX_RES( FT_BACKSCALE ) ), |
| aMtrBackscale ( this, SVX_RES( MTR_BACKSCALE ) ), |
| aFtEndAngle ( this, SVX_RES( FT_END_ANGLE ) ), |
| aMtrEndAngle ( this, SVX_RES( MTR_END_ANGLE ) ), |
| aFtDepth ( this, SVX_RES( FT_DEPTH ) ), |
| aMtrDepth ( this, SVX_RES( MTR_DEPTH ) ), |
| aFLSegments ( this, SVX_RES( FL_SEGMENTS ) ), |
| |
| aFtHorizontal ( this, SVX_RES( FT_HORIZONTAL ) ), |
| aNumHorizontal ( this, SVX_RES( NUM_HORIZONTAL ) ), |
| aFtVertical ( this, SVX_RES( FT_VERTICAL ) ), |
| aNumVertical ( this, SVX_RES( NUM_VERTICAL ) ), |
| |
| aFLNormals ( this, SVX_RES( FL_NORMALS ) ), |
| aBtnNormalsObj ( this, SVX_RES( BTN_NORMALS_OBJ ) ), |
| aBtnNormalsFlat ( this, SVX_RES( BTN_NORMALS_FLAT ) ), |
| aBtnNormalsSphere ( this, SVX_RES( BTN_NORMALS_SPHERE ) ), |
| aBtnNormalsInvert ( this, SVX_RES( BTN_NORMALS_INVERT ) ), |
| aBtnTwoSidedLighting( this, SVX_RES( BTN_TWO_SIDED_LIGHTING ) ), |
| |
| aBtnDoubleSided ( this, SVX_RES( BTN_DOUBLE_SIDED ) ), |
| |
| // Darstellung |
| aFLRepresentation ( this, SVX_RES( FL_REPRESENTATION ) ), |
| aFtShademode ( this, SVX_RES( FT_SHADEMODE ) ), |
| aLbShademode ( this, SVX_RES( LB_SHADEMODE ) ), |
| aFLShadow ( this, SVX_RES( FL_SHADOW ) ), |
| aBtnShadow3d ( this, SVX_RES( BTN_SHADOW_3D ) ), |
| aFtSlant ( this, SVX_RES( FT_SLANT ) ), |
| aMtrSlant ( this, SVX_RES( MTR_SLANT ) ), |
| aFtDistance ( this, SVX_RES( FT_DISTANCE ) ), |
| aMtrDistance ( this, SVX_RES( MTR_DISTANCE ) ), |
| aFtFocalLeng ( this, SVX_RES( FT_FOCAL_LENGTH ) ), |
| aMtrFocalLength ( this, SVX_RES( MTR_FOCAL_LENGTH ) ), |
| aFLCamera ( this, SVX_RES( FL_CAMERA ) ), |
| aFLLight ( this, SVX_RES( FL_LIGHT ) ), |
| |
| // Beleuchtung |
| aBtnLight1 ( this, SVX_RES( BTN_LIGHT_1 ) ), |
| aBtnLight2 ( this, SVX_RES( BTN_LIGHT_2 ) ), |
| aBtnLight3 ( this, SVX_RES( BTN_LIGHT_3 ) ), |
| aBtnLight4 ( this, SVX_RES( BTN_LIGHT_4 ) ), |
| aBtnLight5 ( this, SVX_RES( BTN_LIGHT_5 ) ), |
| aBtnLight6 ( this, SVX_RES( BTN_LIGHT_6 ) ), |
| aBtnLight7 ( this, SVX_RES( BTN_LIGHT_7 ) ), |
| aBtnLight8 ( this, SVX_RES( BTN_LIGHT_8 ) ), |
| aFTLightsource ( this, SVX_RES( FT_LIGHTSOURCE ) ), |
| aLbLight1 ( this, SVX_RES( LB_LIGHT_1 ) ), |
| aLbLight2 ( this, SVX_RES( LB_LIGHT_2 ) ), |
| aLbLight3 ( this, SVX_RES( LB_LIGHT_3 ) ), |
| aLbLight4 ( this, SVX_RES( LB_LIGHT_4 ) ), |
| aLbLight5 ( this, SVX_RES( LB_LIGHT_5 ) ), |
| aLbLight6 ( this, SVX_RES( LB_LIGHT_6 ) ), |
| aLbLight7 ( this, SVX_RES( LB_LIGHT_7 ) ), |
| aLbLight8 ( this, SVX_RES( LB_LIGHT_8 ) ), |
| |
| aBtnLightColor ( this, SVX_RES( BTN_LIGHT_COLOR ) ), |
| |
| // #99694# Keyboard shortcuts activate the next control, so the |
| // order needed to be changed here |
| aFTAmbientlight ( this, SVX_RES( FT_AMBIENTLIGHT ) ), // Text label |
| aLbAmbientlight ( this, SVX_RES( LB_AMBIENTLIGHT ) ), // ListBox |
| aBtnAmbientColor ( this, SVX_RES( BTN_AMBIENT_COLOR ) ), // color button |
| aFLTexture ( this, SVX_RES( FL_TEXTURE ) ), |
| |
| // Texturen |
| aFtTexKind ( this, SVX_RES( FT_TEX_KIND ) ), |
| aBtnTexLuminance ( this, SVX_RES( BTN_TEX_LUMINANCE ) ), |
| aBtnTexColor ( this, SVX_RES( BTN_TEX_COLOR ) ), |
| aFtTexMode ( this, SVX_RES( FT_TEX_MODE ) ), |
| aBtnTexReplace ( this, SVX_RES( BTN_TEX_REPLACE ) ), |
| aBtnTexModulate ( this, SVX_RES( BTN_TEX_MODULATE ) ), |
| aBtnTexBlend ( this, SVX_RES( BTN_TEX_BLEND ) ), |
| aFtTexProjectionX ( this, SVX_RES( FT_TEX_PROJECTION_X ) ), |
| aBtnTexObjectX ( this, SVX_RES( BTN_TEX_OBJECT_X ) ), |
| aBtnTexParallelX ( this, SVX_RES( BTN_TEX_PARALLEL_X ) ), |
| aBtnTexCircleX ( this, SVX_RES( BTN_TEX_CIRCLE_X ) ), |
| aFtTexProjectionY ( this, SVX_RES( FT_TEX_PROJECTION_Y ) ), |
| aBtnTexObjectY ( this, SVX_RES( BTN_TEX_OBJECT_Y ) ), |
| aBtnTexParallelY ( this, SVX_RES( BTN_TEX_PARALLEL_Y ) ), |
| aBtnTexCircleY ( this, SVX_RES( BTN_TEX_CIRCLE_Y ) ), |
| aFtTexFilter ( this, SVX_RES( FT_TEX_FILTER ) ), |
| aBtnTexFilter ( this, SVX_RES( BTN_TEX_FILTER ) ), |
| aFLMaterial ( this, SVX_RES( FL_MATERIAL ) ), |
| |
| // Material |
| aFtMatFavorites ( this, SVX_RES( FT_MAT_FAVORITES ) ), |
| aLbMatFavorites ( this, SVX_RES( LB_MAT_FAVORITES ) ), |
| aFtMatColor ( this, SVX_RES( FT_MAT_COLOR ) ), |
| aLbMatColor ( this, SVX_RES( LB_MAT_COLOR ) ), |
| aBtnMatColor ( this, SVX_RES( BTN_MAT_COLOR ) ), |
| aFtMatEmission ( this, SVX_RES( FT_MAT_EMISSION ) ), |
| aLbMatEmission ( this, SVX_RES( LB_MAT_EMISSION ) ), |
| aBtnEmissionColor ( this, SVX_RES( BTN_EMISSION_COLOR ) ), |
| aFLMatSpecular ( this, SVX_RES( FL_MAT_SPECULAR ) ), |
| aFtMatSpecular ( this, SVX_RES( FT_MAT_SPECULAR ) ), |
| aLbMatSpecular ( this, SVX_RES( LB_MAT_SPECULAR ) ), |
| aBtnSpecularColor ( this, SVX_RES( BTN_SPECULAR_COLOR ) ), |
| aFtMatSpecularIntensity( this, SVX_RES( FT_MAT_SPECULAR_INTENSITY ) ), |
| aMtrMatSpecularIntensity( this, SVX_RES( MTR_MAT_SPECULAR_INTENSITY ) ), |
| aCtlPreview ( this, SVX_RES( CTL_PREVIEW ) ), |
| aCtlLightPreview ( this, SVX_RES( CTL_LIGHT_PREVIEW ) ), |
| |
| // Unterer Bereich |
| aBtnConvertTo3D ( this, SVX_RES( BTN_CHANGE_TO_3D ) ), |
| aBtnLatheObject ( this, SVX_RES( BTN_LATHE_OBJ ) ), |
| aBtnPerspective ( this, SVX_RES( BTN_PERSPECTIVE ) ), |
| |
| aImgLightOn ( SVX_RES( RID_SVXIMAGE_LIGHT_ON ) ), |
| aImgLightOff ( SVX_RES( RID_SVXIMAGE_LIGHT_OFF ) ), |
| |
| bUpdate ( sal_False ), |
| eViewType ( VIEWTYPE_GEO ), |
| |
| pModel ( NULL ), |
| pFmPage ( NULL ), |
| pVDev ( NULL ), |
| p3DView ( NULL ), |
| pFavorSetList ( NULL ), |
| pMatFavSetList ( NULL ), |
| |
| pBindings ( pInBindings ), |
| pControllerItem(0L), |
| pConvertTo3DItem(0L), |
| pConvertTo3DLatheItem(0L), |
| // pPool ( NULL ), |
| mpImpl ( new Svx3DWinImpl() ), |
| mpRemember2DAttributes(NULL), |
| bOnly3DChanged ( sal_False ) |
| { |
| String accname(SVX_RES(STR_COLOR_LIGHT_PRE)); |
| aCtlLightPreview.SetAccessibleName(accname); |
| aCtlPreview.SetAccessibleName(accname); |
| aLbAmbientlight.SetAccessibleName(aFTAmbientlight.GetDisplayText()); |
| |
| SETHCIMAGE( aBtnGeo, BMP_GEO_H ); |
| SETHCIMAGE( aBtnRepresentation, BMP_REPRESENTATION_H ); |
| SETHCIMAGE( aBtnLight, BMP_3DLIGHT_H ); |
| SETHCIMAGE( aBtnTexture, BMP_TEXTURE_H ); |
| SETHCIMAGE( aBtnMaterial, BMP_MATERIAL_H ); |
| SETHCIMAGE( aBtnUpdate, BMP_UPDATE_H ); |
| SETHCIMAGE( aBtnAssign, BMP_ASSIGN_H ); |
| SETHCIMAGE( aBtnNormalsObj, BMP_NORMALS_OBJ_H ); |
| SETHCIMAGE( aBtnNormalsFlat, BMP_NORMALS_FLAT_H ); |
| SETHCIMAGE( aBtnNormalsSphere, BMP_NORMALS_SPHERE_H ); |
| SETHCIMAGE( aBtnTwoSidedLighting, BMP_TWO_SIDED_LIGHTING_H ); |
| SETHCIMAGE( aBtnNormalsInvert, BMP_NORMALS_INVERT_H ); |
| SETHCIMAGE( aBtnDoubleSided, BMP_DOUBLE_SIDED_H ); |
| SETHCIMAGE( aBtnShadow3d, BMP_SHADOW_3D_H ); |
| SETHCIMAGE( aBtnLight1, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight2, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight3, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight4, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight5, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight6, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight7, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLight8, BMP_LIGHT_H ); |
| SETHCIMAGE( aBtnLightColor, BMP_LIGHT_COLOR_H ); |
| SETHCIMAGE( aBtnAmbientColor, BMP_AMBIENT_COLOR_H ); |
| SETHCIMAGE( aBtnTexLuminance, BMP_TEX_LUMINANCE_H ); |
| SETHCIMAGE( aBtnTexColor, BMP_TEX_COLOR_H ); |
| SETHCIMAGE( aBtnTexReplace, BMP_TEX_REPLACE_H ); |
| SETHCIMAGE( aBtnTexModulate, BMP_TEX_MODULATE_H ); |
| SETHCIMAGE( aBtnTexBlend, BMP_TEX_BLEND_H ); |
| SETHCIMAGE( aBtnTexParallelX, BMP_TEX_PARALLEL_H ); |
| SETHCIMAGE( aBtnTexCircleX, BMP_TEX_CIRCLE_H ); |
| SETHCIMAGE( aBtnTexObjectX, BMP_TEX_OBJECT_H ); |
| SETHCIMAGE( aBtnTexParallelY, BMP_TEX_PARALLEL_H ); |
| SETHCIMAGE( aBtnTexCircleY, BMP_TEX_CIRCLE_H ); |
| SETHCIMAGE( aBtnTexObjectY, BMP_TEX_OBJECT_H ); |
| SETHCIMAGE( aBtnTexFilter, BMP_TEX_FILTER_H ); |
| SETHCIMAGE( aBtnMatColor, BMP_COLORDLG_H ); |
| SETHCIMAGE( aBtnEmissionColor, BMP_COLORDLG_H ); |
| SETHCIMAGE( aBtnSpecularColor, BMP_COLORDLG_H ); |
| SETHCIMAGE( aBtnPerspective, BMP_PERSPECTIVE_H ); |
| SETHCIMAGE( aBtnConvertTo3D, BMP_CHANGE_TO_3D_H ); |
| SETHCIMAGE( aBtnLatheObject, BMP_LATHE_OBJ_H ); |
| |
| mpImpl->pPool = NULL; |
| mpImpl->maImgLightOnH = Image( SVX_RES( RID_SVXIMAGE_LIGHT_ON_H ) ); |
| mpImpl->maImgLightOffH = Image( SVX_RES( RID_SVXIMAGE_LIGHT_OFF_H ) ); |
| FreeResource(); |
| |
| // Metrik einstellen |
| eFUnit = pInBindings->GetDispatcher()->GetModule()->GetFieldUnit(); |
| |
| aMtrDepth.SetUnit( eFUnit ); |
| aMtrDistance.SetUnit( eFUnit ); |
| aMtrFocalLength.SetUnit( eFUnit ); |
| |
| pControllerItem = new Svx3DCtrlItem(SID_3D_STATE, this, pBindings); |
| pConvertTo3DItem = new SvxConvertTo3DItem(SID_CONVERT_TO_3D, pBindings); |
| pConvertTo3DLatheItem = new SvxConvertTo3DItem(SID_CONVERT_TO_3D_LATHE_FAST, pBindings); |
| |
| aBtnAssign.SetClickHdl( LINK( this, Svx3DWin, ClickAssignHdl ) ); |
| aBtnUpdate.SetClickHdl( LINK( this, Svx3DWin, ClickUpdateHdl ) ); |
| |
| Link aLink( LINK( this, Svx3DWin, ClickViewTypeHdl ) ); |
| aBtnGeo.SetClickHdl( aLink ); |
| aBtnRepresentation.SetClickHdl( aLink ); |
| aBtnLight.SetClickHdl( aLink ); |
| aBtnTexture.SetClickHdl( aLink ); |
| aBtnMaterial.SetClickHdl( aLink ); |
| |
| aLink = LINK( this, Svx3DWin, ClickHdl ); |
| aBtnPerspective.SetClickHdl( aLink ); |
| aBtnConvertTo3D.SetClickHdl( aLink ); |
| aBtnLatheObject.SetClickHdl( aLink ); |
| |
| // Geometrie |
| aBtnNormalsObj.SetClickHdl( aLink ); |
| aBtnNormalsFlat.SetClickHdl( aLink ); |
| aBtnNormalsSphere.SetClickHdl( aLink ); |
| aBtnTwoSidedLighting.SetClickHdl( aLink ); |
| aBtnNormalsInvert.SetClickHdl( aLink ); |
| aBtnDoubleSided.SetClickHdl( aLink ); |
| |
| // Darstellung |
| aBtnShadow3d.SetClickHdl( aLink ); |
| |
| // Beleuchtung |
| aBtnLight1.SetClickHdl( aLink ); |
| aBtnLight2.SetClickHdl( aLink ); |
| aBtnLight3.SetClickHdl( aLink ); |
| aBtnLight4.SetClickHdl( aLink ); |
| aBtnLight5.SetClickHdl( aLink ); |
| aBtnLight6.SetClickHdl( aLink ); |
| aBtnLight7.SetClickHdl( aLink ); |
| aBtnLight8.SetClickHdl( aLink ); |
| |
| // Texturen |
| aBtnTexLuminance.SetClickHdl( aLink ); |
| aBtnTexColor.SetClickHdl( aLink ); |
| aBtnTexReplace.SetClickHdl( aLink ); |
| aBtnTexModulate.SetClickHdl( aLink ); |
| //aBtnTexBlend.SetClickHdl( aLink ); |
| aBtnTexParallelX.SetClickHdl( aLink ); |
| aBtnTexCircleX.SetClickHdl( aLink ); |
| aBtnTexObjectX.SetClickHdl( aLink ); |
| aBtnTexParallelY.SetClickHdl( aLink ); |
| aBtnTexCircleY.SetClickHdl( aLink ); |
| aBtnTexObjectY.SetClickHdl( aLink ); |
| aBtnTexFilter.SetClickHdl( aLink ); |
| |
| // Material |
| aLink = LINK( this, Svx3DWin, ClickColorHdl ); |
| aBtnLightColor.SetClickHdl( aLink ); |
| aBtnAmbientColor.SetClickHdl( aLink ); |
| aBtnMatColor.SetClickHdl( aLink ); |
| aBtnEmissionColor.SetClickHdl( aLink ); |
| aBtnSpecularColor.SetClickHdl( aLink ); |
| |
| |
| aLink = LINK( this, Svx3DWin, SelectHdl ); |
| aLbMatFavorites.SetSelectHdl( aLink ); |
| aLbMatColor.SetSelectHdl( aLink ); |
| aLbMatEmission.SetSelectHdl( aLink ); |
| aLbMatSpecular.SetSelectHdl( aLink ); |
| aLbLight1.SetSelectHdl( aLink ); |
| aLbLight2.SetSelectHdl( aLink ); |
| aLbLight3.SetSelectHdl( aLink ); |
| aLbLight4.SetSelectHdl( aLink ); |
| aLbLight5.SetSelectHdl( aLink ); |
| aLbLight6.SetSelectHdl( aLink ); |
| aLbLight7.SetSelectHdl( aLink ); |
| aLbLight8.SetSelectHdl( aLink ); |
| aLbAmbientlight.SetSelectHdl( aLink ); |
| aLbShademode.SetSelectHdl( aLink ); |
| |
| aLink = LINK( this, Svx3DWin, ModifyHdl ); |
| aMtrMatSpecularIntensity.SetModifyHdl( aLink ); |
| aNumHorizontal.SetModifyHdl( aLink ); |
| aNumVertical.SetModifyHdl( aLink ); |
| aMtrSlant.SetModifyHdl( aLink ); |
| |
| // Preview-Callback |
| aLink = LINK( this, Svx3DWin, ChangeLightCallbackHdl ); |
| aCtlLightPreview.SetUserInteractiveChangeCallback(aLink); |
| aLink = LINK( this, Svx3DWin, ChangeSelectionCallbackHdl ); |
| aCtlLightPreview.SetUserSelectionChangeCallback(aLink); |
| |
| aSize = GetOutputSizePixel(); |
| SetMinOutputSizePixel( aSize ); |
| |
| Construct(); |
| |
| // Initiierung der Initialisierung der ColorLBs |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( SID_3D_INIT, sal_True ); |
| pDispatcher->Execute( |
| SID_3D_INIT, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); |
| } |
| |
| Reset(); |
| |
| aBtnNormalsObj.SetAccessibleRelationMemberOf( &aFLNormals ); |
| aBtnNormalsFlat.SetAccessibleRelationMemberOf( &aFLNormals ); |
| aBtnNormalsSphere.SetAccessibleRelationMemberOf( &aFLNormals ); |
| aBtnNormalsInvert.SetAccessibleRelationMemberOf( &aFLNormals ); |
| aBtnTwoSidedLighting.SetAccessibleRelationMemberOf( &aFLNormals ); |
| aBtnDoubleSided.SetAccessibleRelationMemberOf( &aFLNormals ); |
| |
| aBtnLight1.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight2.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight3.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight4.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight5.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight6.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight7.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLight8.SetAccessibleRelationMemberOf( &aFLLight ); |
| |
| aBtnLight1.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight2.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight3.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight4.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight5.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight6.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight7.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLight8.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnLightColor.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnLightColor.SetAccessibleRelationLabeledBy( &aFTLightsource ); |
| aBtnAmbientColor.SetAccessibleRelationMemberOf( &aFLLight ); |
| aBtnAmbientColor.SetAccessibleRelationLabeledBy( &aFTAmbientlight ); |
| |
| aBtnSpecularColor.SetAccessibleRelationLabeledBy( &aFtMatSpecular ); |
| aBtnMatColor.SetAccessibleRelationLabeledBy( &aFtMatColor ); |
| aBtnEmissionColor.SetAccessibleRelationLabeledBy( &aFtMatEmission ); |
| aBtnTexLuminance.SetAccessibleRelationLabeledBy( &aFtTexKind ); |
| aBtnTexColor.SetAccessibleRelationLabeledBy( &aFtTexKind ); |
| aBtnTexReplace.SetAccessibleRelationLabeledBy( &aFtTexMode ); |
| aBtnTexModulate.SetAccessibleRelationLabeledBy( &aFtTexMode ); |
| aBtnTexBlend.SetAccessibleRelationLabeledBy( &aFtTexMode ); |
| aBtnTexObjectX.SetAccessibleRelationLabeledBy( &aFtTexProjectionX ); |
| aBtnTexParallelX.SetAccessibleRelationLabeledBy( &aFtTexProjectionX ); |
| aBtnTexCircleX.SetAccessibleRelationLabeledBy( &aFtTexProjectionX ); |
| aBtnTexObjectY.SetAccessibleRelationLabeledBy( &aFtTexProjectionY ); |
| aBtnTexParallelY.SetAccessibleRelationLabeledBy( &aFtTexProjectionY ); |
| aBtnTexCircleY.SetAccessibleRelationLabeledBy( &aFtTexProjectionY ); |
| aBtnTexFilter.SetAccessibleRelationLabeledBy( &aFtTexFilter ); |
| aCtlLightPreview.SetAccessibleRelationLabeledBy( &aCtlLightPreview ); |
| aBtnNormalsObj.SetAccessibleRelationMemberOf(&aFLNormals); |
| aBtnNormalsFlat.SetAccessibleRelationMemberOf(&aFLNormals); |
| aBtnNormalsSphere.SetAccessibleRelationMemberOf(&aFLNormals); |
| aBtnNormalsInvert.SetAccessibleRelationMemberOf(&aFLNormals); |
| aBtnTwoSidedLighting.SetAccessibleRelationMemberOf(&aFLNormals); |
| |
| aBtnShadow3d.SetAccessibleRelationMemberOf(&aFLShadow); |
| |
| aBtnLight1.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight2.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight3.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight4.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight5.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight6.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight7.SetAccessibleRelationMemberOf(&aFLLight); |
| aBtnLight8.SetAccessibleRelationMemberOf(&aFLLight); |
| |
| aBtnTexLuminance.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexColor.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexReplace.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexModulate.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexBlend.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexObjectX.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexParallelX.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexCircleX.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexObjectY.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexParallelY.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexCircleY.SetAccessibleRelationMemberOf(&aFLTexture); |
| aBtnTexFilter.SetAccessibleRelationMemberOf(&aFLTexture); |
| |
| aBtnMatColor.SetAccessibleRelationMemberOf(&aFLMaterial); |
| aBtnEmissionColor.SetAccessibleRelationMemberOf(&aFLMaterial); |
| |
| aBtnSpecularColor.SetAccessibleRelationMemberOf(&aFLMatSpecular); |
| } |
| |
| // ----------------------------------------------------------------------- |
| __EXPORT Svx3DWin::~Svx3DWin() |
| { |
| //delete pMatFavSetList; |
| delete p3DView; |
| delete pVDev; |
| delete pModel; |
| |
| delete pControllerItem; |
| delete pConvertTo3DItem; |
| delete pConvertTo3DLatheItem; |
| |
| if(mpRemember2DAttributes) |
| delete mpRemember2DAttributes; |
| |
| delete mpImpl; |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::Construct() |
| { |
| aBtnGeo.Check(); |
| Link aLink( LINK( this, Svx3DWin, ClickViewTypeHdl ) ); |
| aLink.Call( &aBtnGeo ); |
| aCtlLightPreview.Hide(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::Reset() |
| { |
| // Diverse Initialisierungen, default ist AllAttributes |
| aLbShademode.SelectEntryPos( 0 ); |
| aMtrMatSpecularIntensity.SetValue( 50 ); |
| |
| aBtnLight1.Check(); |
| ClickUpdateHdl( NULL ); |
| |
| // Nichts selektieren, um Fehler beim erstselektieren zu vermeiden |
| aCtlLightPreview.GetSvx3DLightControl().SelectLight(0); |
| aCtlLightPreview.CheckSelection(); |
| } |
| |
| bool Svx3DWin::GetUILightState( ImageButton& aBtn ) const |
| { |
| return (aBtn.GetModeImage() == aImgLightOn) || (aBtn.GetModeImage() == mpImpl->maImgLightOnH); |
| } |
| |
| void Svx3DWin::SetUILightState( ImageButton& aBtn, bool bState ) |
| { |
| aBtn.SetModeImage( bState ? aImgLightOn : aImgLightOff ); |
| aBtn.SetModeImage( bState ? mpImpl->maImgLightOnH : mpImpl->maImgLightOffH, BMP_COLOR_HIGHCONTRAST ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::Update( SfxItemSet& rAttrs ) |
| { |
| // remember 2d attributes |
| if(mpRemember2DAttributes) |
| mpRemember2DAttributes->ClearItem(); |
| else |
| mpRemember2DAttributes = new SfxItemSet(*rAttrs.GetPool(), |
| SDRATTR_START, SDRATTR_SHADOW_LAST, |
| SDRATTR_3D_FIRST, SDRATTR_3D_LAST, |
| 0, 0); |
| |
| SfxWhichIter aIter(*mpRemember2DAttributes); |
| sal_uInt16 nWhich(aIter.FirstWhich()); |
| |
| while(nWhich) |
| { |
| SfxItemState eState = rAttrs.GetItemState(nWhich, sal_False); |
| if(SFX_ITEM_DONTCARE == eState) |
| mpRemember2DAttributes->InvalidateItem(nWhich); |
| else if(SFX_ITEM_SET == eState) |
| mpRemember2DAttributes->Put(rAttrs.Get(nWhich, sal_False)); |
| |
| nWhich = aIter.NextWhich(); |
| } |
| |
| // construct field values |
| const SfxPoolItem* pItem; |
| //sal_Bool bUpdate = sal_False; |
| |
| // evtl. PoolUnit ermitteln |
| if( !mpImpl->pPool ) |
| { |
| mpImpl->pPool = rAttrs.GetPool(); |
| DBG_ASSERT( mpImpl->pPool, "Wo ist der Pool?" ); |
| ePoolUnit = mpImpl->pPool->GetMetric( SID_ATTR_LINE_WIDTH ); |
| } |
| eFUnit = GetModuleFieldUnit( rAttrs ); |
| |
| |
| // Segmentanzahl aenderbar ? und andere Stati |
| SfxItemState eState = rAttrs.GetItemState( SID_ATTR_3D_INTERN, sal_False, &pItem ); |
| if( SFX_ITEM_SET == eState ) |
| { |
| sal_uInt32 nState = ( ( const SfxUInt32Item* )pItem )->GetValue(); |
| //sal_Bool bLathe = (sal_Bool) ( nState & 1 ); |
| sal_Bool bExtrude = (sal_Bool) ( nState & 2 ); |
| sal_Bool bSphere = (sal_Bool) ( nState & 4 ); |
| sal_Bool bCube = (sal_Bool) ( nState & 8 ); |
| |
| sal_Bool bChart = (sal_Bool) ( nState & 32 ); // Chart |
| |
| if( !bChart ) |
| { |
| // Bei Cube-Objekten werden keine Segmente eingestellt |
| aFtHorizontal.Enable( !bCube ); |
| aNumHorizontal.Enable( !bCube ); |
| aFtVertical.Enable( !bCube ); |
| aNumVertical.Enable( !bCube ); |
| aFLSegments.Enable( !bCube ); |
| |
| aFtPercentDiagonal.Enable( !bCube && !bSphere ); |
| aMtrPercentDiagonal.Enable( !bCube && !bSphere ); |
| aFtBackscale.Enable( !bCube && !bSphere ); |
| aMtrBackscale.Enable( !bCube && !bSphere ); |
| aFtDepth.Enable( !bCube && !bSphere ); |
| aMtrDepth.Enable( !bCube && !bSphere ); |
| if( bCube ) |
| { |
| aNumHorizontal.SetEmptyFieldValue(); |
| aNumVertical.SetEmptyFieldValue(); |
| } |
| if( bCube || bSphere ) |
| { |
| aMtrPercentDiagonal.SetEmptyFieldValue(); |
| aMtrBackscale.SetEmptyFieldValue(); |
| aMtrDepth.SetEmptyFieldValue(); |
| } |
| |
| // Nur bei Lathe-Objekten gibt es einen Endwinkel |
| aFtEndAngle.Enable( !bExtrude && !bCube && !bSphere ); |
| aMtrEndAngle.Enable( !bExtrude && !bCube && !bSphere ); |
| if( bExtrude || bCube || bSphere ) |
| aMtrEndAngle.SetEmptyFieldValue(); |
| } |
| else |
| { |
| // Geometrie |
| aFtHorizontal.Enable( sal_False ); |
| aNumHorizontal.Enable( sal_False ); |
| aNumHorizontal.SetEmptyFieldValue(); |
| aFtVertical.Enable( sal_False ); |
| aNumVertical.Enable( sal_False ); |
| aNumVertical.SetEmptyFieldValue(); |
| aFLSegments.Enable( sal_False ); |
| aFtEndAngle.Enable( sal_False ); |
| aMtrEndAngle.Enable( sal_False ); |
| aMtrEndAngle.SetEmptyFieldValue(); |
| aFtDepth.Enable( sal_False ); |
| aMtrDepth.Enable( sal_False ); |
| aMtrDepth.SetEmptyFieldValue(); |
| |
| // Darstellung |
| aBtnShadow3d.Enable( sal_False ); |
| aFtSlant.Enable( sal_False ); |
| aMtrSlant.Enable( sal_False ); |
| aFLShadow.Enable( sal_False ); |
| |
| aFtDistance.Enable( sal_False ); |
| aMtrDistance.Enable( sal_False ); |
| aMtrDistance.SetEmptyFieldValue(); |
| aFtFocalLeng.Enable( sal_False ); |
| aMtrFocalLength.Enable( sal_False ); |
| aMtrFocalLength.SetEmptyFieldValue(); |
| aFLCamera.Enable( sal_False ); |
| |
| // Unterer Bereich |
| aBtnConvertTo3D.Enable( sal_False ); |
| aBtnLatheObject.Enable( sal_False ); |
| } |
| } |
| // Bitmapfuellung ? -> Status |
| sal_Bool bBitmap(sal_False); |
| eState = rAttrs.GetItemState(XATTR_FILLSTYLE); |
| if(eState != SFX_ITEM_DONTCARE) |
| { |
| XFillStyle eXFS = (XFillStyle)((const XFillStyleItem&)rAttrs.Get(XATTR_FILLSTYLE)).GetValue(); |
| bBitmap = (eXFS == XFILL_BITMAP || eXFS == XFILL_GRADIENT || eXFS == XFILL_HATCH); |
| } |
| |
| aFtTexKind.Enable( bBitmap ); |
| aBtnTexLuminance.Enable( bBitmap ); |
| aBtnTexColor.Enable( bBitmap ); |
| aFtTexMode.Enable( bBitmap ); |
| aBtnTexReplace.Enable( bBitmap ); |
| aBtnTexModulate.Enable( bBitmap ); |
| aBtnTexBlend.Enable( bBitmap ); |
| aFtTexProjectionX.Enable( bBitmap ); |
| aBtnTexParallelX.Enable( bBitmap ); |
| aBtnTexCircleX.Enable( bBitmap ); |
| aBtnTexObjectX.Enable( bBitmap ); |
| aFtTexProjectionY.Enable( bBitmap ); |
| aBtnTexParallelY.Enable( bBitmap ); |
| aBtnTexCircleY.Enable( bBitmap ); |
| aBtnTexObjectY.Enable( bBitmap ); |
| aFtTexFilter.Enable( bBitmap ); |
| aBtnTexFilter.Enable( bBitmap ); |
| aFLTexture.Enable( bBitmap ); |
| |
| |
| // Geometrie |
| // Anzahl Segmente (horizontal) |
| if( aNumHorizontal.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_HORZ_SEGS); |
| if(eState != SFX_ITEM_DONTCARE) |
| { |
| sal_uInt32 nValue = ((const Svx3DHorizontalSegmentsItem&)rAttrs.Get(SDRATTR_3DOBJ_HORZ_SEGS)).GetValue(); |
| if(nValue != (sal_uInt32 )aNumHorizontal.GetValue()) |
| { |
| aNumHorizontal.SetValue( nValue ); |
| // evtl. am Ende... |
| // aCtlLightPreview.GetSvx3DLightControl().SetHorizontalSegments( (sal_uInt16)nValue ); |
| bUpdate = sal_True; |
| } |
| else if( aNumHorizontal.IsEmptyFieldValue() ) |
| aNumHorizontal.SetValue( nValue ); |
| } |
| else |
| { |
| if( !aNumHorizontal.IsEmptyFieldValue() ) |
| { |
| aNumHorizontal.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Anzahl Segmente (vertikal) |
| if( aNumVertical.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_VERT_SEGS); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt32 nValue = ((const Svx3DVerticalSegmentsItem&)rAttrs.Get(SDRATTR_3DOBJ_VERT_SEGS)).GetValue(); |
| if( nValue != (sal_uInt32) aNumVertical.GetValue() ) |
| { |
| aNumVertical.SetValue( nValue ); |
| // evtl. am Ende... |
| //aCtlLightPreview.GetSvx3DLightControl().SetVerticalSegments( (sal_uInt16)nValue ); |
| bUpdate = sal_True; |
| } |
| else if( aNumVertical.IsEmptyFieldValue() ) |
| aNumVertical.SetValue( nValue ); |
| } |
| else |
| { |
| if( !aNumVertical.IsEmptyFieldValue() ) |
| { |
| aNumVertical.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Tiefe |
| if( aMtrDepth.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_DEPTH); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt32 nValue = ((const Svx3DDepthItem&)rAttrs.Get(SDRATTR_3DOBJ_DEPTH)).GetValue(); |
| sal_uInt32 nValue2 = GetCoreValue( aMtrDepth, ePoolUnit ); |
| if( nValue != nValue2 ) |
| { |
| if( eFUnit != aMtrDepth.GetUnit() ) |
| SetFieldUnit( aMtrDepth, eFUnit ); |
| |
| SetMetricValue( aMtrDepth, nValue, ePoolUnit ); |
| bUpdate = sal_True; |
| } |
| else if( aMtrDepth.IsEmptyFieldValue() ) |
| aMtrDepth.SetValue( aMtrDepth.GetValue() ); |
| } |
| else |
| { |
| if( !aMtrDepth.IsEmptyFieldValue() ) |
| { |
| aMtrDepth.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Doppelwandig/-seitig |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_DOUBLE_SIDED); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Bool bValue = ((const Svx3DDoubleSidedItem&)rAttrs.Get(SDRATTR_3DOBJ_DOUBLE_SIDED)).GetValue(); |
| if( bValue != aBtnDoubleSided.IsChecked() ) |
| { |
| aBtnDoubleSided.Check( bValue ); |
| bUpdate = sal_True; |
| } |
| else if( aBtnDoubleSided.GetState() == STATE_DONTKNOW ) |
| aBtnDoubleSided.Check( bValue ); |
| } |
| else |
| { |
| if( aBtnDoubleSided.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnDoubleSided.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Kantenrundung |
| if( aMtrPercentDiagonal.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_PERCENT_DIAGONAL); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DPercentDiagonalItem&)rAttrs.Get(SDRATTR_3DOBJ_PERCENT_DIAGONAL)).GetValue(); |
| if( nValue != aMtrPercentDiagonal.GetValue() ) |
| { |
| aMtrPercentDiagonal.SetValue( nValue ); |
| bUpdate = sal_True; |
| } |
| else if( aMtrPercentDiagonal.IsEmptyFieldValue() ) |
| aMtrPercentDiagonal.SetValue( nValue ); |
| } |
| else |
| { |
| if( !aMtrPercentDiagonal.IsEmptyFieldValue() ) |
| { |
| aMtrPercentDiagonal.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Tiefenskalierung |
| if( aMtrBackscale.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_BACKSCALE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DBackscaleItem&)rAttrs.Get(SDRATTR_3DOBJ_BACKSCALE)).GetValue(); |
| if( nValue != aMtrBackscale.GetValue() ) |
| { |
| aMtrBackscale.SetValue( nValue ); |
| bUpdate = sal_True; |
| } |
| else if( aMtrBackscale.IsEmptyFieldValue() ) |
| aMtrBackscale.SetValue( nValue ); |
| } |
| else |
| { |
| if( !aMtrBackscale.IsEmptyFieldValue() ) |
| { |
| aMtrBackscale.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Endwinkel |
| if( aMtrEndAngle.IsEnabled() ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_END_ANGLE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Int32 nValue = ((const Svx3DEndAngleItem&)rAttrs.Get(SDRATTR_3DOBJ_END_ANGLE)).GetValue(); |
| if( nValue != aMtrEndAngle.GetValue() ) |
| { |
| aMtrEndAngle.SetValue( nValue ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( !aMtrEndAngle.IsEmptyFieldValue() ) |
| { |
| aMtrEndAngle.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| // Normalentyp |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_NORMALS_KIND); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DNormalsKindItem&)rAttrs.Get(SDRATTR_3DOBJ_NORMALS_KIND)).GetValue(); |
| |
| if( ( !aBtnNormalsObj.IsChecked() && nValue == 0 ) || |
| ( !aBtnNormalsFlat.IsChecked() && nValue == 1 ) || |
| ( !aBtnNormalsSphere.IsChecked() && nValue == 2 ) ) |
| { |
| aBtnNormalsObj.Check( nValue == 0 ); |
| aBtnNormalsFlat.Check( nValue == 1 ); |
| aBtnNormalsSphere.Check( nValue == 2 ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aBtnNormalsObj.IsChecked() || |
| aBtnNormalsFlat.IsChecked() || |
| aBtnNormalsSphere.IsChecked() ) |
| { |
| aBtnNormalsObj.Check( sal_False ); |
| aBtnNormalsFlat.Check( sal_False ); |
| aBtnNormalsSphere.Check( sal_False ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Normalen invertieren |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_NORMALS_INVERT); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Bool bValue = ((const Svx3DNormalsInvertItem&)rAttrs.Get(SDRATTR_3DOBJ_NORMALS_INVERT)).GetValue(); |
| if( bValue != aBtnNormalsInvert.IsChecked() ) |
| { |
| aBtnNormalsInvert.Check( bValue ); |
| bUpdate = sal_True; |
| } |
| else if( aBtnNormalsInvert.GetState() == STATE_DONTKNOW ) |
| aBtnNormalsInvert.Check( bValue ); |
| } |
| else |
| { |
| if( aBtnNormalsInvert.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnNormalsInvert.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // 2-seitige Beleuchtung |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Bool bValue = ((const Svx3DTwoSidedLightingItem&)rAttrs.Get(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING)).GetValue(); |
| if( bValue != aBtnTwoSidedLighting.IsChecked() ) |
| { |
| aBtnTwoSidedLighting.Check( bValue ); |
| bUpdate = sal_True; |
| } |
| else if( aBtnTwoSidedLighting.GetState() == STATE_DONTKNOW ) |
| aBtnTwoSidedLighting.Check( bValue ); |
| } |
| else |
| { |
| if( aBtnTwoSidedLighting.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnTwoSidedLighting.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Darstellung |
| // Shademode |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_SHADE_MODE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DShadeModeItem&)rAttrs.Get(SDRATTR_3DSCENE_SHADE_MODE)).GetValue(); |
| if( nValue != aLbShademode.GetSelectEntryPos() ) |
| { |
| aLbShademode.SelectEntryPos( nValue ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbShademode.GetSelectEntryCount() != 0 ) |
| { |
| aLbShademode.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // 3D-Shatten |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_SHADOW_3D); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Bool bValue = ((const Svx3DShadow3DItem&)rAttrs.Get(SDRATTR_3DOBJ_SHADOW_3D)).GetValue(); |
| if( bValue != aBtnShadow3d.IsChecked() ) |
| { |
| aBtnShadow3d.Check( bValue ); |
| aFtSlant.Enable( bValue ); |
| aMtrSlant.Enable( bValue ); |
| bUpdate = sal_True; |
| } |
| else if( aBtnShadow3d.GetState() == STATE_DONTKNOW ) |
| aBtnShadow3d.Check( bValue ); |
| } |
| else |
| { |
| if( aBtnShadow3d.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnShadow3d.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Neigung (Schatten) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_SHADOW_SLANT); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DShadowSlantItem&)rAttrs.Get(SDRATTR_3DSCENE_SHADOW_SLANT)).GetValue(); |
| if( nValue != aMtrSlant.GetValue() ) |
| { |
| aMtrSlant.SetValue( nValue ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( !aMtrSlant.IsEmptyFieldValue() ) |
| { |
| aMtrSlant.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Distanz |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_DISTANCE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt32 nValue = ((const Svx3DDistanceItem&)rAttrs.Get(SDRATTR_3DSCENE_DISTANCE)).GetValue(); |
| sal_uInt32 nValue2 = GetCoreValue( aMtrDistance, ePoolUnit ); |
| if( nValue != nValue2 ) |
| { |
| if( eFUnit != aMtrDistance.GetUnit() ) |
| SetFieldUnit( aMtrDistance, eFUnit ); |
| |
| SetMetricValue( aMtrDistance, nValue, ePoolUnit ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( !aMtrDepth.IsEmptyFieldValue() ) |
| { |
| aMtrDepth.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Brennweite |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_FOCAL_LENGTH); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt32 nValue = ((const Svx3DFocalLengthItem&)rAttrs.Get(SDRATTR_3DSCENE_FOCAL_LENGTH)).GetValue(); |
| sal_uInt32 nValue2 = GetCoreValue( aMtrFocalLength, ePoolUnit ); |
| if( nValue != nValue2 ) |
| { |
| if( eFUnit != aMtrFocalLength.GetUnit() ) |
| SetFieldUnit( aMtrFocalLength, eFUnit ); |
| |
| SetMetricValue( aMtrFocalLength, nValue, ePoolUnit ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( !aMtrFocalLength.IsEmptyFieldValue() ) |
| { |
| aMtrFocalLength.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Beleuchtung |
| Color aColor; |
| basegfx::B3DVector aVector; |
| // Licht 1 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_1); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor1Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_1)).GetValue(); |
| ColorLB* pLb = &aLbLight1; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight1.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight1.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 1 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_1); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff1Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_1)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight1 )) || |
| ( !bOn && GetUILightState( aBtnLight1 )) ) |
| { |
| SetUILightState( aBtnLight1, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight1.GetState() == STATE_DONTKNOW ) |
| aBtnLight1.Check( aBtnLight1.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight1.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight1.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 1 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_1); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 2 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_2); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor2Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_2)).GetValue(); |
| ColorLB* pLb = &aLbLight2; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight2.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight2.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 2 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_2); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff2Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_2)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight2 )) || |
| ( !bOn && GetUILightState( aBtnLight2 )) ) |
| { |
| SetUILightState( aBtnLight2, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight2.GetState() == STATE_DONTKNOW ) |
| aBtnLight2.Check( aBtnLight2.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight2.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight2.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 2 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_2); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 3 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_3); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor3Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_3)).GetValue(); |
| ColorLB* pLb = &aLbLight3; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight3.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight3.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 3 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_3); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff3Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_3)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight3)) || |
| ( !bOn && GetUILightState( aBtnLight3)) ) |
| { |
| SetUILightState( aBtnLight3, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight3.GetState() == STATE_DONTKNOW ) |
| aBtnLight3.Check( aBtnLight3.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight3.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight3.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 3 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_3); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 4 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_4); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor4Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_4)).GetValue(); |
| ColorLB* pLb = &aLbLight4; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight4.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight4.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 4 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_4); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff4Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_4)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight4 )) || |
| ( !bOn && GetUILightState( aBtnLight4 )) ) |
| { |
| SetUILightState( aBtnLight4, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight4.GetState() == STATE_DONTKNOW ) |
| aBtnLight4.Check( aBtnLight4.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight4.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight4.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 4 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_4); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 5 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_5); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor5Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_5)).GetValue(); |
| ColorLB* pLb = &aLbLight5; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight5.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight5.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 5 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_5); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff5Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_5)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight5 )) || |
| ( !bOn && GetUILightState( aBtnLight5 )) ) |
| { |
| SetUILightState( aBtnLight5, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight5.GetState() == STATE_DONTKNOW ) |
| aBtnLight5.Check( aBtnLight5.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight5.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight5.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 5 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_5); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 6 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_6); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor6Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_6)).GetValue(); |
| ColorLB* pLb = &aLbLight6; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight6.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight6.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 6 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_6); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff6Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_6)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight6 )) || |
| ( !bOn && GetUILightState( aBtnLight6 )) ) |
| { |
| SetUILightState( aBtnLight6, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight6.GetState() == STATE_DONTKNOW ) |
| aBtnLight6.Check( aBtnLight6.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight6.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight6.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 6 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_6); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 7 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_7); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor7Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_7)).GetValue(); |
| ColorLB* pLb = &aLbLight7; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight7.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight7.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 7 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_7); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff7Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_7)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight7 )) || |
| ( !bOn && GetUILightState( aBtnLight7 )) ) |
| { |
| SetUILightState( aBtnLight7 , bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight7.GetState() == STATE_DONTKNOW ) |
| aBtnLight7.Check( aBtnLight7.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight7.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight7.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 7 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_7); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Licht 8 (Farbe) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTCOLOR_8); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DLightcolor8Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTCOLOR_8)).GetValue(); |
| ColorLB* pLb = &aLbLight8; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbLight8.GetSelectEntryCount() != 0 ) |
| { |
| aLbLight8.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 8 (an/aus) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTON_8); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bool bOn = ((const Svx3DLightOnOff8Item&)rAttrs.Get(SDRATTR_3DSCENE_LIGHTON_8)).GetValue() != 0; |
| if( ( bOn && !GetUILightState( aBtnLight8 )) || |
| ( !bOn && GetUILightState( aBtnLight8 )) ) |
| { |
| SetUILightState( aBtnLight8, bOn ); |
| bUpdate = sal_True; |
| } |
| if( aBtnLight8.GetState() == STATE_DONTKNOW ) |
| aBtnLight8.Check( aBtnLight8.IsChecked() ); |
| } |
| else |
| { |
| if( aBtnLight8.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnLight8.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| // Licht 8 (Richtung) |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_LIGHTDIRECTION_8); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| bUpdate = sal_True; |
| } |
| |
| // Umgebungslicht |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_AMBIENTCOLOR); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DAmbientcolorItem&)rAttrs.Get(SDRATTR_3DSCENE_AMBIENTCOLOR)).GetValue(); |
| ColorLB* pLb = &aLbAmbientlight; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbAmbientlight.GetSelectEntryCount() != 0 ) |
| { |
| aLbAmbientlight.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| |
| // Texturen |
| // Art |
| if( bBitmap ) |
| { |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_KIND); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DTextureKindItem&)rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_KIND)).GetValue(); |
| |
| if( ( !aBtnTexLuminance.IsChecked() && nValue == 1 ) || |
| ( !aBtnTexColor.IsChecked() && nValue == 3 ) ) |
| { |
| aBtnTexLuminance.Check( nValue == 1 ); |
| aBtnTexColor.Check( nValue == 3 ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aBtnTexLuminance.IsChecked() || |
| aBtnTexColor.IsChecked() ) |
| { |
| aBtnTexLuminance.Check( sal_False ); |
| aBtnTexColor.Check( sal_False ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Modus |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_MODE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DTextureModeItem&)rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_MODE)).GetValue(); |
| |
| if( ( !aBtnTexReplace.IsChecked() && nValue == 1 ) || |
| ( !aBtnTexModulate.IsChecked() && nValue == 2 ) ) |
| { |
| aBtnTexReplace.Check( nValue == 1 ); |
| aBtnTexModulate.Check( nValue == 2 ); |
| //aBtnTexBlend.Check( nValue == 2 ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aBtnTexReplace.IsChecked() || |
| aBtnTexModulate.IsChecked() ) |
| { |
| aBtnTexReplace.Check( sal_False ); |
| aBtnTexModulate.Check( sal_False ); |
| //aBtnTexBlend.Check( sal_False ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Projektion X |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_PROJ_X); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DTextureProjectionXItem&)rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_X)).GetValue(); |
| |
| if( ( !aBtnTexObjectX.IsChecked() && nValue == 0 ) || |
| ( !aBtnTexParallelX.IsChecked() && nValue == 1 ) || |
| ( !aBtnTexCircleX.IsChecked() && nValue == 2 ) ) |
| { |
| aBtnTexObjectX.Check( nValue == 0 ); |
| aBtnTexParallelX.Check( nValue == 1 ); |
| aBtnTexCircleX.Check( nValue == 2 ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aBtnTexObjectX.IsChecked() || |
| aBtnTexParallelX.IsChecked() || |
| aBtnTexCircleX.IsChecked() ) |
| { |
| aBtnTexObjectX.Check( sal_False ); |
| aBtnTexParallelX.Check( sal_False ); |
| aBtnTexCircleX.Check( sal_False ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Projektion Y |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_PROJ_Y); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DTextureProjectionYItem&)rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_PROJ_Y)).GetValue(); |
| |
| if( ( !aBtnTexObjectY.IsChecked() && nValue == 0 ) || |
| ( !aBtnTexParallelY.IsChecked() && nValue == 1 ) || |
| ( !aBtnTexCircleY.IsChecked() && nValue == 2 ) ) |
| { |
| aBtnTexObjectY.Check( nValue == 0 ); |
| aBtnTexParallelY.Check( nValue == 1 ); |
| aBtnTexCircleY.Check( nValue == 2 ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aBtnTexObjectY.IsChecked() || |
| aBtnTexParallelY.IsChecked() || |
| aBtnTexCircleY.IsChecked() ) |
| { |
| aBtnTexObjectY.Check( sal_False ); |
| aBtnTexParallelY.Check( sal_False ); |
| aBtnTexCircleY.Check( sal_False ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Filter |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_TEXTURE_FILTER); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_Bool bValue = ((const Svx3DTextureFilterItem&)rAttrs.Get(SDRATTR_3DOBJ_TEXTURE_FILTER)).GetValue(); |
| if( bValue != aBtnTexFilter.IsChecked() ) |
| { |
| aBtnTexFilter.Check( bValue ); |
| bUpdate = sal_True; |
| } |
| if( aBtnTexFilter.GetState() == STATE_DONTKNOW ) |
| aBtnTexFilter.Check( bValue ); |
| } |
| else |
| { |
| if( aBtnTexFilter.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnTexFilter.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| } |
| |
| |
| // Material Favoriten |
| aLbMatFavorites.SelectEntryPos( 0 ); |
| |
| // Objektfarbe |
| eState = rAttrs.GetItemState(XATTR_FILLCOLOR); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const XFillColorItem&)rAttrs.Get(XATTR_FILLCOLOR)).GetColorValue(); |
| ColorLB* pLb = &aLbMatColor; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbMatColor.GetSelectEntryCount() != 0 ) |
| { |
| aLbMatColor.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Slebstleuchtfarbe |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_EMISSION); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DMaterialEmissionItem&)rAttrs.Get(SDRATTR_3DOBJ_MAT_EMISSION)).GetValue(); |
| ColorLB* pLb = &aLbMatEmission; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbMatEmission.GetSelectEntryCount() != 0 ) |
| { |
| aLbMatEmission.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Glanzpunkt |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_SPECULAR); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| aColor = ((const Svx3DMaterialSpecularItem&)rAttrs.Get(SDRATTR_3DOBJ_MAT_SPECULAR)).GetValue(); |
| ColorLB* pLb = &aLbMatSpecular; |
| if( aColor != pLb->GetSelectEntryColor() ) |
| { |
| LBSelectColor( pLb, aColor ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( aLbMatSpecular.GetSelectEntryCount() != 0 ) |
| { |
| aLbMatSpecular.SetNoSelection(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| // Glanzpunkt Intensitaet |
| eState = rAttrs.GetItemState(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| sal_uInt16 nValue = ((const Svx3DMaterialSpecularIntensityItem&)rAttrs.Get(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY)).GetValue(); |
| if( nValue != aMtrMatSpecularIntensity.GetValue() ) |
| { |
| aMtrMatSpecularIntensity.SetValue( nValue ); |
| bUpdate = sal_True; |
| } |
| } |
| else |
| { |
| if( !aMtrMatSpecularIntensity.IsEmptyFieldValue() ) |
| { |
| aMtrMatSpecularIntensity.SetEmptyFieldValue(); |
| bUpdate = sal_True; |
| } |
| } |
| |
| |
| // Sonstige |
| // Perspektive |
| eState = rAttrs.GetItemState(SDRATTR_3DSCENE_PERSPECTIVE); |
| if( eState != SFX_ITEM_DONTCARE ) |
| { |
| ProjectionType ePT = (ProjectionType)((const Svx3DPerspectiveItem&)rAttrs.Get(SDRATTR_3DSCENE_PERSPECTIVE)).GetValue(); |
| if( ( !aBtnPerspective.IsChecked() && ePT == PR_PERSPECTIVE ) || |
| ( aBtnPerspective.IsChecked() && ePT == PR_PARALLEL ) ) |
| { |
| aBtnPerspective.Check( ePT == PR_PERSPECTIVE ); |
| bUpdate = sal_True; |
| } |
| if( aBtnPerspective.GetState() == STATE_DONTKNOW ) |
| aBtnPerspective.Check( ePT == PR_PERSPECTIVE ); |
| } |
| else |
| { |
| if( aBtnPerspective.GetState() != STATE_DONTKNOW ) |
| { |
| aBtnPerspective.SetState( STATE_DONTKNOW ); |
| bUpdate = sal_True; |
| } |
| } |
| |
| if( !bUpdate && !bOnly3DChanged ) |
| { |
| // Eventuell sind aber die 2D-Attribute unterschiedlich. Vergleiche |
| // diese und entscheide |
| |
| |
| bUpdate = sal_True; |
| } |
| |
| if( bUpdate || bOnly3DChanged ) |
| { |
| // Preview updaten |
| SfxItemSet aSet(rAttrs); |
| |
| // set LineStyle hard to XLINE_NONE when it's not set so that |
| // the default (XLINE_SOLID) is not used for 3d preview |
| if(SFX_ITEM_SET != aSet.GetItemState(XATTR_LINESTYLE, sal_False)) |
| aSet.Put(XLineStyleItem(XLINE_NONE)); |
| |
| // set FillColor hard to WHITE when it's SFX_ITEM_DONTCARE so that |
| // the default (Blue7) is not used for 3d preview |
| if(SFX_ITEM_DONTCARE == aSet.GetItemState(XATTR_FILLCOLOR, sal_False)) |
| aSet.Put(XFillColorItem(String(), Color(COL_WHITE))); |
| |
| aCtlPreview.Set3DAttributes(aSet); |
| aCtlLightPreview.GetSvx3DLightControl().Set3DAttributes(aSet); |
| |
| // try to select light corresponding to active button |
| sal_uInt32 nNumber(0xffffffff); |
| |
| if(aBtnLight1.IsChecked()) |
| nNumber = 0; |
| else if(aBtnLight2.IsChecked()) |
| nNumber = 1; |
| else if(aBtnLight3.IsChecked()) |
| nNumber = 2; |
| else if(aBtnLight4.IsChecked()) |
| nNumber = 3; |
| else if(aBtnLight5.IsChecked()) |
| nNumber = 4; |
| else if(aBtnLight6.IsChecked()) |
| nNumber = 5; |
| else if(aBtnLight7.IsChecked()) |
| nNumber = 6; |
| else if(aBtnLight8.IsChecked()) |
| nNumber = 7; |
| |
| if(nNumber != 0xffffffff) |
| { |
| aCtlLightPreview.GetSvx3DLightControl().SelectLight(nNumber); |
| } |
| } |
| |
| // handle state of converts possible |
| aBtnConvertTo3D.Enable(pConvertTo3DItem->GetState()); |
| aBtnLatheObject.Enable(pConvertTo3DLatheItem->GetState()); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::GetAttr( SfxItemSet& rAttrs ) |
| { |
| // get remembered 2d attributes from the dialog |
| if(mpRemember2DAttributes) |
| { |
| SfxWhichIter aIter(*mpRemember2DAttributes); |
| sal_uInt16 nWhich(aIter.FirstWhich()); |
| |
| while(nWhich) |
| { |
| SfxItemState eState = mpRemember2DAttributes->GetItemState(nWhich, sal_False); |
| if(SFX_ITEM_DONTCARE == eState) |
| rAttrs.InvalidateItem(nWhich); |
| else if(SFX_ITEM_SET == eState) |
| rAttrs.Put(mpRemember2DAttributes->Get(nWhich, sal_False)); |
| |
| nWhich = aIter.NextWhich(); |
| } |
| } |
| |
| // Sonstige, muss vorne stehen da auf allen Seiten |
| // Perspektive |
| if( aBtnPerspective.GetState() != STATE_DONTKNOW ) |
| { |
| sal_uInt16 nValue; |
| if( aBtnPerspective.IsChecked() ) |
| nValue = PR_PERSPECTIVE; |
| else |
| nValue = PR_PARALLEL; |
| rAttrs.Put(Svx3DPerspectiveItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_PERSPECTIVE); |
| |
| // Geometrie |
| // evtl. PoolUnit ermitteln (Falls dies in Update() nicht passiert ist) |
| if( !mpImpl->pPool ) |
| { |
| DBG_ERROR( "Kein Pool in GetAttr()! Evtl. inkompatibel zu drviewsi.cxx ?" ); |
| mpImpl->pPool = rAttrs.GetPool(); |
| DBG_ASSERT( mpImpl->pPool, "Wo ist der Pool?" ); |
| ePoolUnit = mpImpl->pPool->GetMetric( SID_ATTR_LINE_WIDTH ); |
| |
| eFUnit = GetModuleFieldUnit( rAttrs ); |
| } |
| |
| // Anzahl Segmente (horizontal) |
| if( !aNumHorizontal.IsEmptyFieldValue() ) |
| { |
| sal_uInt32 nValue = static_cast<sal_uInt32>(aNumHorizontal.GetValue()); |
| rAttrs.Put(Svx3DHorizontalSegmentsItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_HORZ_SEGS); |
| |
| // Anzahl Segmente (vertikal) |
| if( !aNumVertical.IsEmptyFieldValue() ) |
| { |
| sal_uInt32 nValue = static_cast<sal_uInt32>(aNumVertical.GetValue()); |
| rAttrs.Put(Svx3DVerticalSegmentsItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_VERT_SEGS); |
| |
| // Tiefe |
| if( !aMtrDepth.IsEmptyFieldValue() ) |
| { |
| sal_uInt32 nValue = GetCoreValue( aMtrDepth, ePoolUnit ); |
| rAttrs.Put(Svx3DDepthItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_DEPTH); |
| |
| // Doppelseitig |
| TriState eState = aBtnDoubleSided.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = STATE_CHECK == eState; |
| rAttrs.Put(Svx3DDoubleSidedItem(bValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_DOUBLE_SIDED); |
| |
| // Kantenrundung |
| if( !aMtrPercentDiagonal.IsEmptyFieldValue() ) |
| { |
| sal_uInt16 nValue = (sal_uInt16) aMtrPercentDiagonal.GetValue(); |
| rAttrs.Put(Svx3DPercentDiagonalItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_PERCENT_DIAGONAL); |
| |
| // Tiefenskalierung |
| if( !aMtrBackscale.IsEmptyFieldValue() ) |
| { |
| sal_uInt16 nValue = (sal_uInt16)aMtrBackscale.GetValue(); |
| rAttrs.Put(Svx3DBackscaleItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_BACKSCALE); |
| |
| // Endwinkel |
| if( !aMtrEndAngle.IsEmptyFieldValue() ) |
| { |
| sal_uInt16 nValue = (sal_uInt16)aMtrEndAngle.GetValue(); |
| rAttrs.Put(Svx3DEndAngleItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_END_ANGLE); |
| |
| // Normalentyp |
| sal_uInt16 nValue = 99; |
| if( aBtnNormalsObj.IsChecked() ) |
| nValue = 0; |
| else if( aBtnNormalsFlat.IsChecked() ) |
| nValue = 1; |
| else if( aBtnNormalsSphere.IsChecked() ) |
| nValue = 2; |
| |
| if( nValue <= 2 ) |
| rAttrs.Put(Svx3DNormalsKindItem(nValue)); |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_NORMALS_KIND); |
| |
| // Normalen invertieren |
| eState = aBtnNormalsInvert.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = STATE_CHECK == eState; |
| rAttrs.Put(Svx3DNormalsInvertItem(bValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_NORMALS_INVERT); |
| |
| // 2-seitige Beleuchtung |
| eState = aBtnTwoSidedLighting.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = STATE_CHECK == eState; |
| rAttrs.Put(Svx3DTwoSidedLightingItem(bValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_TWO_SIDED_LIGHTING); |
| |
| // Darstellung |
| // Shademode |
| if( aLbShademode.GetSelectEntryCount() ) |
| { |
| nValue = aLbShademode.GetSelectEntryPos(); |
| rAttrs.Put(Svx3DShadeModeItem(nValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_SHADE_MODE); |
| |
| // 3D-Shatten |
| eState = aBtnShadow3d.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = STATE_CHECK == eState; |
| rAttrs.Put(Svx3DShadow3DItem(bValue)); |
| rAttrs.Put(SdrShadowItem(bValue)); |
| } |
| else |
| { |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_SHADOW_3D); |
| rAttrs.InvalidateItem(SDRATTR_SHADOW); |
| } |
| |
| // Neigung (Schatten) |
| if( !aMtrSlant.IsEmptyFieldValue() ) |
| { |
| sal_uInt16 nValue2 = (sal_uInt16) aMtrSlant.GetValue(); |
| rAttrs.Put(Svx3DShadowSlantItem(nValue2)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_SHADOW_SLANT); |
| |
| // Distanz |
| if( !aMtrDistance.IsEmptyFieldValue() ) |
| { |
| sal_uInt32 nValue2 = GetCoreValue( aMtrDistance, ePoolUnit ); |
| rAttrs.Put(Svx3DDistanceItem(nValue2)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_DISTANCE); |
| |
| // Brennweite |
| if( !aMtrFocalLength.IsEmptyFieldValue() ) |
| { |
| sal_uInt32 nValue2 = GetCoreValue( aMtrFocalLength, ePoolUnit ); |
| rAttrs.Put(Svx3DFocalLengthItem(nValue2)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_FOCAL_LENGTH); |
| |
| // Beleuchtung |
| Image aImg; |
| basegfx::B3DVector aVector; |
| Color aColor; |
| const SfxItemSet aLightItemSet(aCtlLightPreview.GetSvx3DLightControl().Get3DAttributes()); |
| |
| // Licht 1 Farbe |
| if( aLbLight1.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight1.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor1Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_1); |
| // Licht 1 (an/aus) |
| eState = aBtnLight1.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight1 ); |
| rAttrs.Put(Svx3DLightOnOff1Item(bValue)); |
| |
| // Licht 1 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_1)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_1); |
| |
| |
| // Licht 2 Farbe |
| if( aLbLight2.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight2.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor2Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_2); |
| // Licht 2 (an/aus) |
| eState = aBtnLight2.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight2 ); |
| rAttrs.Put(Svx3DLightOnOff2Item(bValue)); |
| |
| // Licht 2 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_2)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_2); |
| |
| // Licht 3 Farbe |
| if( aLbLight3.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight3.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor3Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_3); |
| // Licht 3 (an/aus) |
| eState = aBtnLight3.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight3 ); |
| rAttrs.Put(Svx3DLightOnOff3Item(bValue)); |
| |
| // Licht 3 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_3)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_3); |
| |
| // Licht 4 Farbe |
| if( aLbLight4.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight4.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor4Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_4); |
| // Licht 4 (an/aus) |
| eState = aBtnLight4.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight4 ); |
| rAttrs.Put(Svx3DLightOnOff4Item(bValue)); |
| |
| // Licht 4 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_4)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_4); |
| |
| // Licht 5 Farbe |
| if( aLbLight5.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight5.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor5Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_5); |
| // Licht 5 (an/aus) |
| eState = aBtnLight5.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight5 ); |
| rAttrs.Put(Svx3DLightOnOff5Item(bValue)); |
| |
| // Licht 5 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_5)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_5); |
| |
| // Licht 6 Farbe |
| if( aLbLight6.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight6.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor6Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_6); |
| // Licht 6 (an/aus) |
| eState = aBtnLight6.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight6 ); |
| rAttrs.Put(Svx3DLightOnOff6Item(bValue)); |
| |
| // Licht 6 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_6)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_6); |
| |
| // Licht 7 Farbe |
| if( aLbLight7.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight7.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor7Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_7); |
| // Licht 7 (an/aus) |
| eState = aBtnLight7.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight7 ); |
| rAttrs.Put(Svx3DLightOnOff7Item(bValue)); |
| |
| // Licht 7 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_7)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_7); |
| |
| // Licht 8 Farbe |
| if( aLbLight8.GetSelectEntryCount() ) |
| { |
| aColor = aLbLight8.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DLightcolor8Item(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTCOLOR_8); |
| // Licht 8 (an/aus) |
| eState = aBtnLight8.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = GetUILightState( aBtnLight8 ); |
| rAttrs.Put(Svx3DLightOnOff8Item(bValue)); |
| |
| // Licht 8 (Richtung) |
| if( bValue ) |
| { |
| rAttrs.Put(aLightItemSet.Get(SDRATTR_3DSCENE_LIGHTDIRECTION_8)); |
| } |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_LIGHTON_8); |
| |
| // Umgebungslicht |
| if( aLbAmbientlight.GetSelectEntryCount() ) |
| { |
| aColor = aLbAmbientlight.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DAmbientcolorItem(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DSCENE_AMBIENTCOLOR); |
| |
| // Texturen |
| // Art |
| nValue = 3; |
| if( aBtnTexLuminance.IsChecked() ) |
| nValue = 1; |
| else if( aBtnTexColor.IsChecked() ) |
| nValue = 3; |
| |
| if( nValue == 1 || nValue == 3 ) |
| rAttrs.Put(Svx3DTextureKindItem(nValue)); |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_KIND); |
| |
| |
| // Modus |
| nValue = 99; |
| if( aBtnTexReplace.IsChecked() ) |
| nValue = 1; |
| else if( aBtnTexModulate.IsChecked() ) |
| nValue = 2; |
| //else if( aBtnTexBlend.IsChecked() ) |
| // nValue = 2; |
| |
| if( nValue == 1 || nValue == 2 ) |
| rAttrs.Put(Svx3DTextureModeItem(nValue)); |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_MODE); |
| |
| // Projektion X |
| nValue = 99; |
| if( aBtnTexObjectX.IsChecked() ) |
| nValue = 0; |
| else if( aBtnTexParallelX.IsChecked() ) |
| nValue = 1; |
| else if( aBtnTexCircleX.IsChecked() ) |
| nValue = 2; |
| |
| if( nValue <= 2 ) |
| rAttrs.Put(Svx3DTextureProjectionXItem(nValue)); |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_PROJ_X); |
| |
| // Projektion Y |
| nValue = 99; |
| if( aBtnTexObjectY.IsChecked() ) |
| nValue = 0; |
| else if( aBtnTexParallelY.IsChecked() ) |
| nValue = 1; |
| else if( aBtnTexCircleY.IsChecked() ) |
| nValue = 2; |
| |
| if( nValue <= 2 ) |
| rAttrs.Put(Svx3DTextureProjectionYItem(nValue)); |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_PROJ_Y); |
| |
| |
| // Filter |
| eState = aBtnTexFilter.GetState(); |
| if( eState != STATE_DONTKNOW ) |
| { |
| sal_Bool bValue = STATE_CHECK == eState; |
| rAttrs.Put(Svx3DTextureFilterItem(bValue)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_TEXTURE_FILTER); |
| |
| |
| // Material |
| // Objektfarbe |
| if( aLbMatColor.GetSelectEntryCount() ) |
| { |
| aColor = aLbMatColor.GetSelectEntryColor(); |
| rAttrs.Put( XFillColorItem( String(), aColor) ); |
| } |
| else |
| { |
| rAttrs.InvalidateItem( XATTR_FILLCOLOR ); |
| } |
| |
| // Slebstleuchtfarbe |
| if( aLbMatEmission.GetSelectEntryCount() ) |
| { |
| aColor = aLbMatEmission.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DMaterialEmissionItem(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_EMISSION); |
| |
| // Glanzpunkt |
| if( aLbMatSpecular.GetSelectEntryCount() ) |
| { |
| aColor = aLbMatSpecular.GetSelectEntryColor(); |
| rAttrs.Put(Svx3DMaterialSpecularItem(aColor)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_SPECULAR); |
| |
| // Glanzpunkt Intensitaet |
| if( !aMtrMatSpecularIntensity.IsEmptyFieldValue() ) |
| { |
| sal_uInt16 nValue2 = (sal_uInt16) aMtrMatSpecularIntensity.GetValue(); |
| rAttrs.Put(Svx3DMaterialSpecularIntensityItem(nValue2)); |
| } |
| else |
| rAttrs.InvalidateItem(SDRATTR_3DOBJ_MAT_SPECULAR_INTENSITY); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void __EXPORT Svx3DWin::Resize() |
| { |
| if ( !IsFloatingMode() || |
| !GetFloatingWindow()->IsRollUp() ) |
| { |
| Size aWinSize( GetOutputSizePixel() ); // vorher rSize im Resizing() |
| |
| if( aWinSize.Height() >= GetMinOutputSizePixel().Height() && |
| aWinSize.Width() >= GetMinOutputSizePixel().Width() ) |
| { |
| Size aDiffSize; |
| aDiffSize.Width() = aWinSize.Width() - aSize.Width(); |
| aDiffSize.Height() = aWinSize.Height() - aSize.Height(); |
| |
| Point aXPt; |
| Point aYPt; |
| aXPt.X() = aDiffSize.Width(); |
| aYPt.Y() = aDiffSize.Height(); |
| |
| Size aObjSize; |
| |
| // Hide |
| aBtnUpdate.Hide(); |
| aBtnAssign.Hide(); |
| |
| aBtnConvertTo3D.Hide(); |
| aBtnLatheObject.Hide(); |
| aBtnPerspective.Hide(); |
| |
| aCtlPreview.Hide(); |
| aCtlLightPreview.Hide(); |
| |
| aFLGeometrie.Hide(); |
| aFLRepresentation.Hide(); |
| aFLLight.Hide(); |
| aFLTexture.Hide(); |
| aFLMaterial.Hide(); |
| |
| // Verschieben / Resizen |
| aBtnUpdate.SetPosPixel( aBtnUpdate.GetPosPixel() + aXPt ); |
| aBtnAssign.SetPosPixel( aBtnAssign.GetPosPixel() + aXPt ); |
| |
| // Preview-Controls |
| aObjSize = aCtlPreview.GetOutputSizePixel(); |
| aObjSize.Width() += aDiffSize.Width(); |
| aObjSize.Height() += aDiffSize.Height(); |
| aCtlPreview.SetOutputSizePixel( aObjSize ); |
| aCtlLightPreview.SetOutputSizePixel( aObjSize ); |
| |
| // Groups |
| aObjSize = aFLGeometrie.GetOutputSizePixel(); |
| aObjSize.Width() += aDiffSize.Width(); |
| aFLGeometrie.SetOutputSizePixel( aObjSize ); |
| aFLSegments.SetOutputSizePixel( aObjSize ); |
| aFLShadow.SetOutputSizePixel( aObjSize ); |
| aFLCamera.SetOutputSizePixel( aObjSize ); |
| aFLRepresentation.SetOutputSizePixel( aObjSize ); |
| aFLLight.SetOutputSizePixel( aObjSize ); |
| aFLTexture.SetOutputSizePixel( aObjSize ); |
| aFLMaterial.SetOutputSizePixel( aObjSize ); |
| |
| // Y-Position der unteren Buttons |
| aBtnConvertTo3D.SetPosPixel( aBtnConvertTo3D.GetPosPixel() + aYPt ); |
| aBtnLatheObject.SetPosPixel( aBtnLatheObject.GetPosPixel() + aYPt ); |
| aBtnPerspective.SetPosPixel( aBtnPerspective.GetPosPixel() + aYPt ); |
| |
| // Show |
| aBtnUpdate.Show(); |
| aBtnAssign.Show(); |
| |
| aBtnConvertTo3D.Show(); |
| aBtnLatheObject.Show(); |
| aBtnPerspective.Show(); |
| |
| if( aBtnGeo.IsChecked() ) |
| ClickViewTypeHdl( &aBtnGeo ); |
| if( aBtnRepresentation.IsChecked() ) |
| ClickViewTypeHdl( &aBtnRepresentation ); |
| if( aBtnLight.IsChecked() ) |
| ClickViewTypeHdl( &aBtnLight ); |
| if( aBtnTexture.IsChecked() ) |
| ClickViewTypeHdl( &aBtnTexture ); |
| if( aBtnMaterial.IsChecked() ) |
| ClickViewTypeHdl( &aBtnMaterial ); |
| |
| aSize = aWinSize; |
| } |
| } |
| |
| SfxDockingWindow::Resize(); |
| } |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, ClickUpdateHdl, void *, EMPTYARG ) |
| { |
| bUpdate = !aBtnUpdate.IsChecked(); |
| aBtnUpdate.Check( bUpdate ); |
| |
| if( bUpdate ) |
| { |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( SID_3D_STATE, sal_True ); |
| pDispatcher->Execute( |
| SID_3D_STATE, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); |
| } |
| } |
| else |
| { |
| // Controls koennen u.U. disabled sein |
| } |
| |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, ClickAssignHdl, void *, EMPTYARG ) |
| { |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( SID_3D_ASSIGN, sal_True ); |
| pDispatcher->Execute( |
| SID_3D_ASSIGN, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); |
| } |
| |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( Svx3DWin, ClickViewTypeHdl, void *, pBtn ) |
| { |
| |
| if( pBtn ) |
| { |
| // Da das permanente Updaten der Preview zu teuer waere |
| sal_Bool bUpdatePreview = aBtnLight.IsChecked(); |
| |
| aBtnGeo.Check( &aBtnGeo == pBtn ); |
| aBtnRepresentation.Check( &aBtnRepresentation == pBtn ); |
| aBtnLight.Check( &aBtnLight == pBtn ); |
| aBtnTexture.Check( &aBtnTexture == pBtn ); |
| aBtnMaterial.Check( &aBtnMaterial == pBtn ); |
| |
| if( aBtnGeo.IsChecked() ) |
| eViewType = VIEWTYPE_GEO; |
| if( aBtnRepresentation.IsChecked() ) |
| eViewType = VIEWTYPE_REPRESENTATION; |
| if( aBtnLight.IsChecked() ) |
| eViewType = VIEWTYPE_LIGHT; |
| if( aBtnTexture.IsChecked() ) |
| eViewType = VIEWTYPE_TEXTURE; |
| if( aBtnMaterial.IsChecked() ) |
| eViewType = VIEWTYPE_MATERIAL; |
| |
| // Geometrie |
| if( eViewType == VIEWTYPE_GEO ) |
| { |
| aFtHorizontal.Show(); |
| aNumHorizontal.Show(); |
| aFtVertical.Show(); |
| aNumVertical.Show(); |
| aFLSegments.Show(); |
| aFtPercentDiagonal.Show(); |
| aMtrPercentDiagonal.Show(); |
| aFtBackscale.Show(); |
| aMtrBackscale.Show(); |
| aFtEndAngle.Show(); |
| aMtrEndAngle.Show(); |
| aFtDepth.Show(); |
| aMtrDepth.Show(); |
| aFLGeometrie.Show(); |
| |
| aBtnNormalsObj.Show(); |
| aBtnNormalsFlat.Show(); |
| aBtnNormalsSphere.Show(); |
| aBtnTwoSidedLighting.Show(); |
| aBtnNormalsInvert.Show(); |
| aFLNormals.Show(); |
| aBtnDoubleSided.Show(); |
| } |
| else |
| { |
| aFtHorizontal.Hide(); |
| aNumHorizontal.Hide(); |
| aFtVertical.Hide(); |
| aNumVertical.Hide(); |
| aFLSegments.Hide(); |
| aFtPercentDiagonal.Hide(); |
| aMtrPercentDiagonal.Hide(); |
| aFtBackscale.Hide(); |
| aMtrBackscale.Hide(); |
| aFtEndAngle.Hide(); |
| aMtrEndAngle.Hide(); |
| aFtDepth.Hide(); |
| aMtrDepth.Hide(); |
| aFLGeometrie.Hide(); |
| |
| aBtnNormalsObj.Hide(); |
| aBtnNormalsFlat.Hide(); |
| aBtnNormalsSphere.Hide(); |
| aBtnTwoSidedLighting.Hide(); |
| aBtnNormalsInvert.Hide(); |
| aFLNormals.Hide(); |
| aBtnDoubleSided.Hide(); |
| } |
| |
| // Darstellung |
| if( eViewType == VIEWTYPE_REPRESENTATION ) |
| { |
| aFtShademode.Show(); |
| aLbShademode.Show(); |
| aBtnShadow3d.Show(); |
| aFtSlant.Show(); |
| aMtrSlant.Show(); |
| aFLShadow.Show(); |
| aFtDistance.Show(); |
| aMtrDistance.Show(); |
| aFtFocalLeng.Show(); |
| aMtrFocalLength.Show(); |
| aFLCamera.Show(); |
| aFLRepresentation.Show(); |
| } |
| else |
| { |
| aFtShademode.Hide(); |
| aLbShademode.Hide(); |
| aBtnShadow3d.Hide(); |
| aFtSlant.Hide(); |
| aMtrSlant.Hide(); |
| aFLShadow.Hide(); |
| aFtDistance.Hide(); |
| aMtrDistance.Hide(); |
| aFtFocalLeng.Hide(); |
| aMtrFocalLength.Hide(); |
| aFLCamera.Hide(); |
| aFLRepresentation.Hide(); |
| } |
| |
| // Beleuchtung |
| if( eViewType == VIEWTYPE_LIGHT ) |
| { |
| aBtnLight1.Show(); |
| aBtnLight2.Show(); |
| aBtnLight3.Show(); |
| aBtnLight4.Show(); |
| aBtnLight5.Show(); |
| aBtnLight6.Show(); |
| aBtnLight7.Show(); |
| aBtnLight8.Show(); |
| //aLbLight1.Show(); |
| aBtnLightColor.Show(); |
| aFTLightsource.Show(); |
| aLbAmbientlight.Show(); |
| aBtnAmbientColor.Show(); |
| aFTAmbientlight.Show(); |
| aFLLight.Show(); |
| //aFtLightX.Show(); |
| //aFtLightY.Show(); |
| //aFtLightZ.Show(); |
| //aGrpLightInfo.Show(); |
| |
| ColorLB* pLb = GetLbByButton(); |
| if( pLb ) |
| pLb->Show(); |
| |
| aCtlLightPreview.Show(); |
| aCtlPreview.Hide(); |
| } |
| else |
| { |
| aBtnLight1.Hide(); |
| aBtnLight2.Hide(); |
| aBtnLight3.Hide(); |
| aBtnLight4.Hide(); |
| aBtnLight5.Hide(); |
| aBtnLight6.Hide(); |
| aBtnLight7.Hide(); |
| aBtnLight8.Hide(); |
| aLbLight1.Hide(); |
| aLbLight2.Hide(); |
| aLbLight3.Hide(); |
| aLbLight4.Hide(); |
| aLbLight5.Hide(); |
| aLbLight6.Hide(); |
| aLbLight7.Hide(); |
| aLbLight8.Hide(); |
| aBtnLightColor.Hide(); |
| aFTLightsource.Hide(); |
| aLbAmbientlight.Hide(); |
| aBtnAmbientColor.Hide(); |
| aFTAmbientlight.Hide(); |
| aFLLight.Hide(); |
| |
| if( !aCtlPreview.IsVisible() ) |
| { |
| aCtlPreview.Show(); |
| aCtlLightPreview.Hide(); |
| } |
| } |
| |
| // Texturen |
| if( eViewType == VIEWTYPE_TEXTURE ) |
| { |
| aFtTexKind.Show(); |
| aBtnTexLuminance.Show(); |
| aBtnTexColor.Show(); |
| aFtTexMode.Show(); |
| aBtnTexReplace.Show(); |
| aBtnTexModulate.Show(); |
| //aBtnTexBlend.Show(); |
| aFtTexProjectionX.Show(); |
| aBtnTexParallelX.Show(); |
| aBtnTexCircleX.Show(); |
| aBtnTexObjectX.Show(); |
| aFtTexProjectionY.Show(); |
| aBtnTexParallelY.Show(); |
| aBtnTexCircleY.Show(); |
| aBtnTexObjectY.Show(); |
| aFtTexFilter.Show(); |
| aBtnTexFilter.Show(); |
| aFLTexture.Show(); |
| } |
| else |
| { |
| aFtTexKind.Hide(); |
| aBtnTexLuminance.Hide(); |
| aBtnTexColor.Hide(); |
| aFtTexMode.Hide(); |
| aBtnTexReplace.Hide(); |
| aBtnTexModulate.Hide(); |
| aBtnTexBlend.Hide(); |
| aFtTexProjectionX.Hide(); |
| aBtnTexParallelX.Hide(); |
| aBtnTexCircleX.Hide(); |
| aBtnTexObjectX.Hide(); |
| aFtTexProjectionY.Hide(); |
| aBtnTexParallelY.Hide(); |
| aBtnTexCircleY.Hide(); |
| aBtnTexObjectY.Hide(); |
| aFtTexFilter.Hide(); |
| aBtnTexFilter.Hide(); |
| aFLTexture.Hide(); |
| } |
| |
| // Material |
| if( eViewType == VIEWTYPE_MATERIAL ) |
| { |
| aFtMatFavorites.Show(); |
| aLbMatFavorites.Show(); |
| aFtMatColor.Show(); |
| aLbMatColor.Show(); |
| aBtnMatColor.Show(); |
| aFtMatEmission.Show(); |
| aLbMatEmission.Show(); |
| aBtnEmissionColor.Show(); |
| aFtMatSpecular.Show(); |
| aLbMatSpecular.Show(); |
| aBtnSpecularColor.Show(); |
| aFtMatSpecularIntensity.Show(); |
| aMtrMatSpecularIntensity.Show(); |
| aFLMatSpecular.Show(); |
| aFLMaterial.Show(); |
| } |
| else |
| { |
| aFtMatFavorites.Hide(); |
| aLbMatFavorites.Hide(); |
| aFtMatColor.Hide(); |
| aLbMatColor.Hide(); |
| aBtnMatColor.Hide(); |
| aFtMatEmission.Hide(); |
| aLbMatEmission.Hide(); |
| aBtnEmissionColor.Hide(); |
| aFtMatSpecular.Hide(); |
| aLbMatSpecular.Hide(); |
| aBtnSpecularColor.Hide(); |
| aFtMatSpecularIntensity.Hide(); |
| aMtrMatSpecularIntensity.Hide(); |
| aFLMatSpecular.Hide(); |
| aFLMaterial.Hide(); |
| } |
| if( bUpdatePreview && !aBtnLight.IsChecked() ) |
| UpdatePreview(); |
| |
| } |
| else |
| { |
| aBtnGeo.Check( eViewType == VIEWTYPE_GEO ); |
| aBtnRepresentation.Check( eViewType == VIEWTYPE_REPRESENTATION ); |
| aBtnLight.Check( eViewType == VIEWTYPE_LIGHT ); |
| aBtnTexture.Check( eViewType == VIEWTYPE_TEXTURE ); |
| aBtnMaterial.Check( eViewType == VIEWTYPE_MATERIAL ); |
| } |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, ClickHdl, PushButton *, pBtn ) |
| { |
| sal_Bool bUpdatePreview = sal_False; |
| |
| if( pBtn ) |
| { |
| sal_uInt16 nSId = 0; |
| |
| if( pBtn == &aBtnConvertTo3D ) |
| { |
| nSId = SID_CONVERT_TO_3D; |
| } |
| else if( pBtn == &aBtnLatheObject ) |
| { |
| nSId = SID_CONVERT_TO_3D_LATHE_FAST; |
| } |
| // Geometrie |
| else if( pBtn == &aBtnNormalsObj || |
| pBtn == &aBtnNormalsFlat || |
| pBtn == &aBtnNormalsSphere ) |
| { |
| aBtnNormalsObj.Check( pBtn == &aBtnNormalsObj ); |
| aBtnNormalsFlat.Check( pBtn == &aBtnNormalsFlat ); |
| aBtnNormalsSphere.Check( pBtn == &aBtnNormalsSphere ); |
| bUpdatePreview = sal_True; |
| } |
| else if( pBtn == &aBtnLight1 || |
| pBtn == &aBtnLight2 || |
| pBtn == &aBtnLight3 || |
| pBtn == &aBtnLight4 || |
| pBtn == &aBtnLight5 || |
| pBtn == &aBtnLight6 || |
| pBtn == &aBtnLight7 || |
| pBtn == &aBtnLight8 ) |
| { |
| // Beleuchtung |
| ColorLB* pLb = GetLbByButton( pBtn ); |
| pLb->Show(); |
| |
| if( pBtn->IsChecked() ) |
| { |
| SetUILightState( *(ImageButton*)pBtn, !GetUILightState( *(ImageButton*)pBtn ) ); |
| } |
| else |
| { |
| pBtn->Check(); |
| |
| if( pBtn != &aBtnLight1 && aBtnLight1.IsChecked() ) |
| { |
| aBtnLight1.Check( sal_False ); |
| aLbLight1.Hide(); |
| } |
| if( pBtn != &aBtnLight2 && aBtnLight2.IsChecked() ) |
| { |
| aBtnLight2.Check( sal_False ); |
| aLbLight2.Hide(); |
| } |
| if( pBtn != &aBtnLight3 && aBtnLight3.IsChecked() ) |
| { |
| aBtnLight3.Check( sal_False ); |
| aLbLight3.Hide(); |
| } |
| if( pBtn != &aBtnLight4 && aBtnLight4.IsChecked() ) |
| { |
| aBtnLight4.Check( sal_False ); |
| aLbLight4.Hide(); |
| } |
| if( pBtn != &aBtnLight5 && aBtnLight5.IsChecked() ) |
| { |
| aBtnLight5.Check( sal_False ); |
| aLbLight5.Hide(); |
| } |
| if( pBtn != &aBtnLight6 && aBtnLight6.IsChecked() ) |
| { |
| aBtnLight6.Check( sal_False ); |
| aLbLight6.Hide(); |
| } |
| if( pBtn != &aBtnLight7 && aBtnLight7.IsChecked() ) |
| { |
| aBtnLight7.Check( sal_False ); |
| aLbLight7.Hide(); |
| } |
| if( pBtn != &aBtnLight8 && aBtnLight8.IsChecked() ) |
| { |
| aBtnLight8.Check( sal_False ); |
| aLbLight8.Hide(); |
| } |
| } |
| sal_Bool bEnable = GetUILightState( *(ImageButton*)pBtn ); |
| aBtnLightColor.Enable( bEnable ); |
| pLb->Enable( bEnable ); |
| |
| ClickLightHdl( pBtn ); |
| bUpdatePreview = sal_True; |
| } |
| // Texturen |
| else if( pBtn == &aBtnTexLuminance || |
| pBtn == &aBtnTexColor ) |
| { |
| aBtnTexLuminance.Check( pBtn == &aBtnTexLuminance ); |
| aBtnTexColor.Check( pBtn == &aBtnTexColor ); |
| bUpdatePreview = sal_True; |
| } |
| else if( pBtn == &aBtnTexReplace || |
| pBtn == &aBtnTexModulate )// || |
| //pBtn == &aBtnTexBlend ) |
| { |
| aBtnTexReplace.Check( pBtn == &aBtnTexReplace ); |
| aBtnTexModulate.Check( pBtn == &aBtnTexModulate ); |
| //aBtnTexBlend.Check( pBtn == &aBtnTexBlend ); |
| bUpdatePreview = sal_True; |
| } |
| else if( pBtn == &aBtnTexParallelX || |
| pBtn == &aBtnTexCircleX || |
| pBtn == &aBtnTexObjectX ) |
| { |
| aBtnTexParallelX.Check( pBtn == &aBtnTexParallelX ); |
| aBtnTexCircleX.Check( pBtn == &aBtnTexCircleX ); |
| aBtnTexObjectX.Check( pBtn == &aBtnTexObjectX ); |
| bUpdatePreview = sal_True; |
| } |
| else if( pBtn == &aBtnTexParallelY || |
| pBtn == &aBtnTexCircleY || |
| pBtn == &aBtnTexObjectY ) |
| { |
| aBtnTexParallelY.Check( pBtn == &aBtnTexParallelY ); |
| aBtnTexCircleY.Check( pBtn == &aBtnTexCircleY ); |
| aBtnTexObjectY.Check( pBtn == &aBtnTexObjectY ); |
| bUpdatePreview = sal_True; |
| } |
| else if( pBtn == &aBtnShadow3d ) |
| { |
| pBtn->Check( !pBtn->IsChecked() ); |
| aFtSlant.Enable( pBtn->IsChecked() ); |
| aMtrSlant.Enable( pBtn->IsChecked() ); |
| bUpdatePreview = sal_True; |
| } |
| // Sonstige (keine Gruppen) |
| else if( pBtn != NULL ) |
| { |
| pBtn->Check( !pBtn->IsChecked() ); |
| bUpdatePreview = sal_True; |
| } |
| |
| if( nSId > 0 ) |
| { |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( nSId, sal_True ); |
| pDispatcher->Execute( |
| nSId, SFX_CALLMODE_ASYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); |
| } |
| } |
| else if( bUpdatePreview == sal_True ) |
| UpdatePreview(); |
| } |
| return( 0L ); |
| } |
| |
| //------------------------------------------------------------------------ |
| |
| IMPL_LINK( Svx3DWin, ClickColorHdl, PushButton *, pBtn ) |
| { |
| SvColorDialog aColorDlg( this ); |
| ColorLB* pLb; |
| |
| if( pBtn == &aBtnLightColor ) |
| pLb = GetLbByButton(); |
| else if( pBtn == &aBtnAmbientColor ) |
| pLb = &aLbAmbientlight; |
| else if( pBtn == &aBtnMatColor ) |
| pLb = &aLbMatColor; |
| else if( pBtn == &aBtnEmissionColor ) |
| pLb = &aLbMatEmission; |
| else // if( pBtn == &aBtnSpecularColor ) |
| pLb = &aLbMatSpecular; |
| |
| Color aColor = pLb->GetSelectEntryColor(); |
| |
| aColorDlg.SetColor( aColor ); |
| if( aColorDlg.Execute() == RET_OK ) |
| { |
| aColor = aColorDlg.GetColor(); |
| if( LBSelectColor( pLb, aColor ) ) |
| SelectHdl( pLb ); |
| } |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, SelectHdl, void *, p ) |
| { |
| if( p ) |
| { |
| Color aColor; |
| sal_Bool bUpdatePreview = sal_False; |
| |
| // Material |
| if( p == &aLbMatFavorites ) |
| { |
| Color aColObj( COL_WHITE ); |
| Color aColEmis( COL_BLACK ); |
| Color aColSpec( COL_WHITE ); |
| sal_uInt16 nSpecIntens = 20; |
| |
| sal_uInt16 nPos = aLbMatFavorites.GetSelectEntryPos(); |
| switch( nPos ) |
| { |
| case 1: // Metall |
| { |
| aColObj = Color(230,230,255); |
| aColEmis = Color(10,10,30); |
| aColSpec = Color(200,200,200); |
| nSpecIntens = 20; |
| } |
| break; |
| |
| case 2: // Gold |
| { |
| aColObj = Color(230,255,0); |
| aColEmis = Color(51,0,0); |
| aColSpec = Color(255,255,240); |
| nSpecIntens = 20; |
| } |
| break; |
| |
| case 3: // Chrom |
| { |
| aColObj = Color(36,117,153); |
| aColEmis = Color(18,30,51); |
| aColSpec = Color(230,230,255); |
| nSpecIntens = 2; |
| } |
| break; |
| |
| case 4: // Plastik |
| { |
| aColObj = Color(255,48,57); |
| aColEmis = Color(35,0,0); |
| aColSpec = Color(179,202,204); |
| nSpecIntens = 60; |
| } |
| break; |
| |
| case 5: // Holz |
| { |
| aColObj = Color(153,71,1); |
| aColEmis = Color(21,22,0); |
| aColSpec = Color(255,255,153); |
| nSpecIntens = 75; |
| } |
| break; |
| } |
| LBSelectColor( &aLbMatColor, aColObj ); |
| LBSelectColor( &aLbMatEmission, aColEmis ); |
| LBSelectColor( &aLbMatSpecular, aColSpec ); |
| aMtrMatSpecularIntensity.SetValue( nSpecIntens ); |
| |
| bUpdatePreview = sal_True; |
| } |
| else if( p == &aLbMatColor || |
| p == &aLbMatEmission || |
| p == &aLbMatSpecular ) |
| { |
| aLbMatFavorites.SelectEntryPos( 0 ); |
| bUpdatePreview = sal_True; |
| } |
| // Beleuchtung |
| else if( p == &aLbAmbientlight ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| else if( p == &aLbLight1 || |
| p == &aLbLight2 || |
| p == &aLbLight3 || |
| p == &aLbLight4 || |
| p == &aLbLight5 || |
| p == &aLbLight6 || |
| p == &aLbLight7 || |
| p == &aLbLight8 ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| else if( p == &aLbShademode ) |
| bUpdatePreview = sal_True; |
| |
| if( bUpdatePreview == sal_True ) |
| UpdatePreview(); |
| } |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, ModifyHdl, void*, pField ) |
| { |
| if( pField ) |
| { |
| sal_Bool bUpdatePreview = sal_False; |
| |
| // Material |
| if( pField == &aMtrMatSpecularIntensity ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| else if( pField == &aNumHorizontal ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| else if( pField == &aNumVertical ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| else if( pField == &aMtrSlant ) |
| { |
| bUpdatePreview = sal_True; |
| } |
| |
| if( bUpdatePreview == sal_True ) |
| UpdatePreview(); |
| } |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( Svx3DWin, ClickLightHdl, PushButton*, pBtn ) |
| { |
| |
| if( pBtn ) |
| { |
| sal_uInt16 nLightSource = GetLightSource( pBtn ); |
| ColorLB* pLb = GetLbByButton( pBtn ); |
| Color aColor( pLb->GetSelectEntryColor() ); |
| SfxItemSet aLightItemSet(aCtlLightPreview.GetSvx3DLightControl().Get3DAttributes()); |
| const bool bOnOff(GetUILightState( *(ImageButton*)pBtn )); |
| |
| switch(nLightSource) |
| { |
| case 0: aLightItemSet.Put(Svx3DLightcolor1Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff1Item(bOnOff)); break; |
| case 1: aLightItemSet.Put(Svx3DLightcolor2Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff2Item(bOnOff)); break; |
| case 2: aLightItemSet.Put(Svx3DLightcolor3Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff3Item(bOnOff)); break; |
| case 3: aLightItemSet.Put(Svx3DLightcolor4Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff4Item(bOnOff)); break; |
| case 4: aLightItemSet.Put(Svx3DLightcolor5Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff5Item(bOnOff)); break; |
| case 5: aLightItemSet.Put(Svx3DLightcolor6Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff6Item(bOnOff)); break; |
| case 6: aLightItemSet.Put(Svx3DLightcolor7Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff7Item(bOnOff)); break; |
| default: |
| case 7: aLightItemSet.Put(Svx3DLightcolor8Item(aColor)); aLightItemSet.Put(Svx3DLightOnOff8Item(bOnOff)); break; |
| } |
| |
| aCtlLightPreview.GetSvx3DLightControl().Set3DAttributes(aLightItemSet); |
| aCtlLightPreview.GetSvx3DLightControl().SelectLight(nLightSource); |
| aCtlLightPreview.CheckSelection(); |
| } |
| return( 0L ); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| IMPL_LINK( Svx3DWin, DoubleClickHdl, void*, EMPTYARG ) |
| { |
| //sal_uInt16 nItemId = aCtlFavorites.GetSelectItemId(); |
| |
| //SfxItemSet* pSet = (SfxItemSet*) pFavorSetList->GetObject( nItemId - 1 ); |
| //Update( *pSet ); |
| |
| // und zuweisen |
| ClickAssignHdl( NULL ); |
| |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( Svx3DWin, ChangeLightCallbackHdl, void*, EMPTYARG ) |
| { |
| return( 0L ); |
| } |
| |
| |
| // ----------------------------------------------------------------------- |
| |
| IMPL_LINK( Svx3DWin, ChangeSelectionCallbackHdl, void*, EMPTYARG ) |
| { |
| const sal_uInt32 nLight(aCtlLightPreview.GetSvx3DLightControl().GetSelectedLight()); |
| PushButton* pBtn = 0; |
| |
| switch( nLight ) |
| { |
| case 0: pBtn = &aBtnLight1; break; |
| case 1: pBtn = &aBtnLight2; break; |
| case 2: pBtn = &aBtnLight3; break; |
| case 3: pBtn = &aBtnLight4; break; |
| case 4: pBtn = &aBtnLight5; break; |
| case 5: pBtn = &aBtnLight6; break; |
| case 6: pBtn = &aBtnLight7; break; |
| case 7: pBtn = &aBtnLight8; break; |
| default: break; |
| } |
| |
| if( pBtn ) |
| ClickHdl( pBtn ); |
| else |
| { |
| // Zustand: Keine Lampe selektiert |
| if( aBtnLight1.IsChecked() ) |
| { |
| aBtnLight1.Check( sal_False ); |
| aLbLight1.Enable( sal_False ); |
| } |
| else if( aBtnLight2.IsChecked() ) |
| { |
| aBtnLight2.Check( sal_False ); |
| aLbLight2.Enable( sal_False ); |
| } |
| else if( aBtnLight3.IsChecked() ) |
| { |
| aBtnLight3.Check( sal_False ); |
| aLbLight3.Enable( sal_False ); |
| } |
| else if( aBtnLight4.IsChecked() ) |
| { |
| aBtnLight4.Check( sal_False ); |
| aLbLight4.Enable( sal_False ); |
| } |
| else if( aBtnLight5.IsChecked() ) |
| { |
| aBtnLight5.Check( sal_False ); |
| aLbLight5.Enable( sal_False ); |
| } |
| else if( aBtnLight6.IsChecked() ) |
| { |
| aBtnLight6.Check( sal_False ); |
| aLbLight6.Enable( sal_False ); |
| } |
| else if( aBtnLight7.IsChecked() ) |
| { |
| aBtnLight7.Check( sal_False ); |
| aLbLight7.Enable( sal_False ); |
| } |
| else if( aBtnLight8.IsChecked() ) |
| { |
| aBtnLight8.Check( sal_False ); |
| aLbLight8.Enable( sal_False ); |
| } |
| aBtnLightColor.Enable( sal_False ); |
| } |
| |
| return( 0L ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| // Methode um sicherzustellen, dass die LB auch mit einer Farbe gesetzt ist |
| // Liefert sal_True zurueck, falls Farbe hinzugefuegt wurde |
| // ----------------------------------------------------------------------- |
| sal_Bool Svx3DWin::LBSelectColor( ColorLB* pLb, const Color& rColor ) |
| { |
| sal_Bool bRet = sal_False; |
| |
| pLb->SetNoSelection(); |
| pLb->SelectEntry( rColor ); |
| if( pLb->GetSelectEntryCount() == 0 ) |
| { |
| String aStr(SVX_RES(RID_SVXFLOAT3D_FIX_R)); |
| |
| aStr += String::CreateFromInt32((sal_Int32)rColor.GetRed()); |
| aStr += sal_Unicode(' '); |
| aStr += String(SVX_RES(RID_SVXFLOAT3D_FIX_G)); |
| aStr += String::CreateFromInt32((sal_Int32)rColor.GetGreen()); |
| aStr += sal_Unicode(' '); |
| aStr += String(SVX_RES(RID_SVXFLOAT3D_FIX_B)); |
| aStr += String::CreateFromInt32((sal_Int32)rColor.GetBlue()); |
| |
| sal_uInt16 nPos = pLb->InsertEntry( rColor, aStr ); |
| pLb->SelectEntryPos( nPos ); |
| bRet = sal_True; |
| } |
| return( bRet ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::UpdatePreview() |
| { |
| if( pModel == NULL ) |
| pModel = new FmFormModel(); |
| |
| if(bOnly3DChanged) |
| { |
| // slot executen |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(pBindings); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( SID_3D_STATE, sal_True ); |
| pDispatcher->Execute( |
| SID_3D_STATE, SFX_CALLMODE_SYNCHRON | SFX_CALLMODE_RECORD, &aItem, 0L ); |
| } |
| // Flag zuruecksetzen |
| bOnly3DChanged = sal_False; |
| } |
| |
| // ItemSet besorgen |
| SfxItemSet aSet( pModel->GetItemPool(), SDRATTR_START, SDRATTR_END); |
| |
| // Attribute holen und im Preview setzen |
| GetAttr( aSet ); |
| aCtlPreview.Set3DAttributes( aSet ); |
| aCtlLightPreview.GetSvx3DLightControl().Set3DAttributes( aSet ); |
| } |
| |
| ////////////////////////////////////////////////////////////////////////////// |
| // document is to be reloaded, destroy remembered ItemSet (#83951#) |
| void Svx3DWin::DocumentReload() |
| { |
| if(mpRemember2DAttributes) |
| delete mpRemember2DAttributes; |
| mpRemember2DAttributes = 0L; |
| } |
| |
| // ----------------------------------------------------------------------- |
| void Svx3DWin::InitColorLB( const SdrModel* pDoc ) |
| { |
| aLbLight1.Fill( pDoc->GetColorTableFromSdrModel() ); |
| aLbLight2.CopyEntries( aLbLight1 ); |
| aLbLight3.CopyEntries( aLbLight1 ); |
| aLbLight4.CopyEntries( aLbLight1 ); |
| aLbLight5.CopyEntries( aLbLight1 ); |
| aLbLight6.CopyEntries( aLbLight1 ); |
| aLbLight7.CopyEntries( aLbLight1 ); |
| aLbLight8.CopyEntries( aLbLight1 ); |
| aLbAmbientlight.CopyEntries( aLbLight1 ); |
| aLbMatColor.CopyEntries( aLbLight1 ); |
| aLbMatEmission.CopyEntries( aLbLight1 ); |
| aLbMatSpecular.CopyEntries( aLbLight1 ); |
| |
| // Erstmal... |
| Color aColWhite( COL_WHITE ); |
| Color aColBlack( COL_BLACK ); |
| aLbLight1.SelectEntry( aColWhite ); |
| aLbLight2.SelectEntry( aColWhite ); |
| aLbLight3.SelectEntry( aColWhite ); |
| aLbLight4.SelectEntry( aColWhite ); |
| aLbLight5.SelectEntry( aColWhite ); |
| aLbLight6.SelectEntry( aColWhite ); |
| aLbLight7.SelectEntry( aColWhite ); |
| aLbLight8.SelectEntry( aColWhite ); |
| aLbAmbientlight.SelectEntry( aColBlack ); |
| aLbMatColor.SelectEntry( aColWhite ); |
| aLbMatEmission.SelectEntry( aColBlack ); |
| aLbMatSpecular.SelectEntry( aColWhite ); |
| } |
| |
| // ----------------------------------------------------------------------- |
| sal_uInt16 Svx3DWin::GetLightSource( const PushButton* pBtn ) |
| { |
| sal_uInt16 nLight = 8; |
| |
| if( pBtn == NULL ) |
| { |
| if( aBtnLight1.IsChecked() ) |
| nLight = 0; |
| else if( aBtnLight2.IsChecked() ) |
| nLight = 1; |
| else if( aBtnLight3.IsChecked() ) |
| nLight = 2; |
| else if( aBtnLight4.IsChecked() ) |
| nLight = 3; |
| else if( aBtnLight5.IsChecked() ) |
| nLight = 4; |
| else if( aBtnLight6.IsChecked() ) |
| nLight = 5; |
| else if( aBtnLight7.IsChecked() ) |
| nLight = 6; |
| else if( aBtnLight8.IsChecked() ) |
| nLight = 7; |
| } |
| else |
| { |
| if( pBtn == &aBtnLight1 ) |
| nLight = 0; |
| else if( pBtn == &aBtnLight2 ) |
| nLight = 1; |
| else if( pBtn == &aBtnLight3 ) |
| nLight = 2; |
| else if( pBtn == &aBtnLight4 ) |
| nLight = 3; |
| else if( pBtn == &aBtnLight5 ) |
| nLight = 4; |
| else if( pBtn == &aBtnLight6 ) |
| nLight = 5; |
| else if( pBtn == &aBtnLight7 ) |
| nLight = 6; |
| else if( pBtn == &aBtnLight8 ) |
| nLight = 7; |
| } |
| return( nLight ); |
| }; |
| |
| // ----------------------------------------------------------------------- |
| ColorLB* Svx3DWin::GetLbByButton( const PushButton* pBtn ) |
| { |
| ColorLB* pLb = NULL; |
| |
| if( pBtn == NULL ) |
| { |
| if( aBtnLight1.IsChecked() ) |
| pLb = &aLbLight1; |
| else if( aBtnLight2.IsChecked() ) |
| pLb = &aLbLight2; |
| else if( aBtnLight3.IsChecked() ) |
| pLb = &aLbLight3; |
| else if( aBtnLight4.IsChecked() ) |
| pLb = &aLbLight4; |
| else if( aBtnLight5.IsChecked() ) |
| pLb = &aLbLight5; |
| else if( aBtnLight6.IsChecked() ) |
| pLb = &aLbLight6; |
| else if( aBtnLight7.IsChecked() ) |
| pLb = &aLbLight7; |
| else if( aBtnLight8.IsChecked() ) |
| pLb = &aLbLight8; |
| } |
| else |
| { |
| if( pBtn == &aBtnLight1 ) |
| pLb = &aLbLight1; |
| else if( pBtn == &aBtnLight2 ) |
| pLb = &aLbLight2; |
| else if( pBtn == &aBtnLight3 ) |
| pLb = &aLbLight3; |
| else if( pBtn == &aBtnLight4 ) |
| pLb = &aLbLight4; |
| else if( pBtn == &aBtnLight5 ) |
| pLb = &aLbLight5; |
| else if( pBtn == &aBtnLight6 ) |
| pLb = &aLbLight6; |
| else if( pBtn == &aBtnLight7 ) |
| pLb = &aLbLight7; |
| else if( pBtn == &aBtnLight8 ) |
| pLb = &aLbLight8; |
| } |
| return( pLb ); |
| }; |
| |
| /************************************************************************* |
| |* |
| |* Ableitung vom SfxChildWindow als "Behaelter" fuer Effekte |
| |* |
| \************************************************************************/ |
| __EXPORT Svx3DChildWindow::Svx3DChildWindow( Window* _pParent, |
| sal_uInt16 nId, |
| SfxBindings* pBindings, |
| SfxChildWinInfo* pInfo ) : |
| SfxChildWindow( _pParent, nId ) |
| { |
| Svx3DWin* pWin = new Svx3DWin( pBindings, this, _pParent ); |
| pWindow = pWin; |
| |
| eChildAlignment = SFX_ALIGN_NOALIGNMENT; |
| |
| pWin->Initialize( pInfo ); |
| } |
| |
| /************************************************************************* |
| |* |
| |* ControllerItem fuer 3DStatus |
| |* |
| \************************************************************************/ |
| Svx3DCtrlItem::Svx3DCtrlItem( sal_uInt16 _nId, |
| Svx3DWin* pWin, |
| SfxBindings* _pBindings) : |
| SfxControllerItem( _nId, *_pBindings ), |
| p3DWin( pWin ) |
| { |
| } |
| |
| // ----------------------------------------------------------------------- |
| void __EXPORT Svx3DCtrlItem::StateChanged( sal_uInt16 /*nSId*/, |
| SfxItemState /*eState*/, const SfxPoolItem* /*pItem*/ ) |
| { |
| } |
| |
| /************************************************************************* |
| |* |
| |* ControllerItem fuer Status Slot SID_CONVERT_TO_3D |
| |* |
| \************************************************************************/ |
| |
| SvxConvertTo3DItem::SvxConvertTo3DItem(sal_uInt16 _nId, SfxBindings* _pBindings) |
| : SfxControllerItem(_nId, *_pBindings), |
| bState(sal_False) |
| { |
| } |
| |
| void SvxConvertTo3DItem::StateChanged(sal_uInt16 /*_nId*/, SfxItemState eState, const SfxPoolItem* /*pState*/) |
| { |
| sal_Bool bNewState = (eState != SFX_ITEM_DISABLED); |
| if(bNewState != bState) |
| { |
| bState = bNewState; |
| SfxDispatcher* pDispatcher = LocalGetDispatcher(&GetBindings()); |
| if (pDispatcher != NULL) |
| { |
| SfxBoolItem aItem( SID_3D_STATE, sal_True ); |
| pDispatcher->Execute( |
| SID_3D_STATE, SFX_CALLMODE_ASYNCHRON|SFX_CALLMODE_RECORD, &aItem, 0L); |
| } |
| } |
| } |
| |
| |