xref: /trunk/main/svx/source/engine3d/float3d.cxx (revision cf6516809c57e1bb0a940545cca99cdad54d4ce2)

/**************************************************************
 *
 * 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);
        }
    }
}