summaryrefslogtreecommitdiffstats
path: root/kpovmodeler/pmpart.cpp
diff options
context:
space:
mode:
authortoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
committertoma <toma@283d02a7-25f6-0310-bc7c-ecb5cbfe19da>2009-11-25 17:56:58 +0000
commit47d455dd55be855e4cc691c32f687f723d9247ee (patch)
tree52e236aaa2576bdb3840ebede26619692fed6d7d /kpovmodeler/pmpart.cpp
downloadtdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.tar.gz
tdegraphics-47d455dd55be855e4cc691c32f687f723d9247ee.zip
Copy the KDE 3.5 branch to branches/trinity for new KDE 3.5 features.
BUG:215923 git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/kdegraphics@1054174 283d02a7-25f6-0310-bc7c-ecb5cbfe19da
Diffstat (limited to 'kpovmodeler/pmpart.cpp')
-rw-r--r--kpovmodeler/pmpart.cpp2884
1 files changed, 2884 insertions, 0 deletions
diff --git a/kpovmodeler/pmpart.cpp b/kpovmodeler/pmpart.cpp
new file mode 100644
index 00000000..c87f4719
--- /dev/null
+++ b/kpovmodeler/pmpart.cpp
@@ -0,0 +1,2884 @@
+/*
+**************************************************************************
+ description
+ --------------------
+ copyright : (C) 2000-2003 by Andreas Zehender
+ email : [email protected]
+**************************************************************************
+
+**************************************************************************
+* *
+* This program is free software; you can redistribute it and/or modify *
+* it under the terms of the GNU General Public License as published by *
+* the Free Software Foundation; either version 2 of the License, or *
+* (at your option) any later version. *
+* *
+**************************************************************************/
+
+
+// include files for QT
+#include <qapplication.h>
+#include <qdir.h>
+#include <qstrlist.h>
+#include <qclipboard.h>
+#include <qfile.h>
+#include <qtextstream.h>
+#include <qmessagebox.h>
+#include <qcombobox.h>
+#include <qspinbox.h>
+#include <qlabel.h>
+#include <qdatetime.h>
+#include <qstringlist.h>
+
+// include files for KDE
+#include <kiconloader.h>
+#include <kconfig.h>
+#include <kstdaction.h>
+#include <kaction.h>
+#include <kmessagebox.h>
+#include <ktempfile.h>
+#include <kio/netaccess.h>
+#include <kstandarddirs.h>
+#include <kfilterdev.h>
+#include <kfiledialog.h>
+
+// application specific includes
+#include "pmpart.h"
+#include "pmshell.h"
+#include "pmview.h"
+#include "pmglview.h"
+#include "pmallcommands.h"
+#include "pmpovraywidget.h"
+#include "pmpovrayrenderwidget.h"
+
+#include "pmallobjects.h"
+#include "pmcommandmanager.h"
+#include "pmobjectdrag.h"
+#include "pmxmlparser.h"
+#include "pmpovrayparser.h"
+#include "pmerrordialog.h"
+#include "pmsettingsdialog.h"
+#include "pminserterrordialog.h"
+#include "pminsertpopup.h"
+
+#include "pmpovray35format.h"
+#include "pmserializer.h"
+
+#include "pmfactory.h"
+#include "pmdefaults.h"
+#include "pmsymboltable.h"
+
+#include "pmrendermodesdialog.h"
+#include "pmrendermode.h"
+#include "pmpovrayoutputwidget.h"
+#include "pmrendermanager.h"
+#include "pmdialogeditbase.h"
+#include "pmdocumentationmap.h"
+#include "pmlibrarymanager.h"
+#include "pmlibraryhandleedit.h"
+#include "pmlibraryobject.h"
+#include "pmlibrarybrowser.h"
+#include "pmlibraryobjectsearch.h"
+#include "pmscene.h"
+
+#include "pmpluginmanager.h"
+#include "pminsertrulesystem.h"
+#include "pmprototypemanager.h"
+#include "pmiomanager.h"
+
+#include "pmactions.h"
+#include "pmrecursiveobjectiterator.h"
+
+#include "pmerrorflags.h"
+
+#include "pmfiledialog.h"
+
+#ifdef PMEnableSimpleProfiling
+QTime PMDebugTime;
+#endif
+
+//#define KPM_WITH_OBJECT_LIBRARY
+
+PMPart::PMPart( QWidget* parentWidget, const char* widgetName,
+ QObject* parent, const char* name, bool readwrite,
+ PMShell* shell )
+ : DCOPObject( "PMPartIface" ),
+ KParts::ReadWritePart( parent, name ),
+ m_commandManager( this )
+{
+ setPluginLoadingMode( LoadPlugins );
+ setInstance( PMFactory::instance( ), false );
+ m_pExtension = new PMBrowserExtension( this );
+
+ m_pActiveObject = 0;
+ m_canDecode = false;
+ m_pScene = 0;
+ m_pNewSelection = 0;
+ m_sortedListUpToDate = false;
+ m_numAddedObjects = 0;
+ m_numInsertErrors = 0;
+ m_pSymbolTable = 0;
+ m_bCameraListUpToDate = true;
+ m_updateNewObjectActions = false;
+ m_pPovrayWidget = 0;
+ m_pView = 0;
+ m_pShell = shell;
+ m_controlPoints.setAutoDelete( true );
+ m_onlyCopyPaste = true;
+
+ // call inits to invoke all other construction parts
+ setReadWrite( readwrite );
+
+ if( isReadWrite( ) )
+ setXMLFile( "kpovmodelerui.rc" );
+ else
+ setXMLFile( "kpovmodelerbrowser.rc" );
+
+ m_pPrototypeManager = new PMPrototypeManager( this );
+ m_pInsertRuleSystem = new PMInsertRuleSystem( this );
+ m_pIOManager = new PMIOManager( this );
+ m_pInsertRuleSystem->loadRules( "baseinsertrules.xml" );
+
+ initActions( );
+ initDocument( );
+ initView( parentWidget, widgetName );
+
+ restoreConfig( instance( )->config( ) );
+
+ connect( qApp->clipboard( ), SIGNAL( dataChanged( ) ),
+ SLOT( slotClipboardDataChanged( ) ) );
+ slotClipboardDataChanged( );
+ connect( &m_commandManager, SIGNAL( updateUndoRedo( const QString&, const QString& ) ),
+ SLOT( slotUpdateUndoRedo( const QString&, const QString& ) ) );
+ connect( &m_commandManager, SIGNAL( objectChanged( PMObject*, const int, QObject* ) ),
+ SLOT( slotObjectChanged( PMObject*, const int, QObject* ) ) );
+ connect( &m_commandManager, SIGNAL( idChanged( PMObject*, const QString& ) ),
+ SLOT( slotIDChanged( PMObject*, const QString& ) ) );
+
+ PMPluginManager::theManager( )->registerPart( this );
+
+ emit refresh( );
+ slotObjectChanged( m_pScene, PMCNewSelection, this );
+}
+
+PMPart::PMPart( QWidget* /*parentWidget*/, const char* /*widgetName*/,
+ QObject* parent, const char* name, bool readwrite,
+ bool /*onlyCutPaste*/, PMShell* shell )
+ : DCOPObject( "LibraryBrowserIface" ),
+ KParts::ReadWritePart( parent, name ),
+ m_commandManager( this )
+{
+ setPluginLoadingMode( LoadPlugins );
+ setInstance( PMFactory::instance( ), false );
+
+ m_pActiveObject = 0;
+ m_canDecode = false;
+ m_pNewSelection = 0;
+ m_sortedListUpToDate = false;
+ m_numAddedObjects = 0;
+ m_numInsertErrors = 0;
+ m_pSymbolTable = 0;
+ m_bCameraListUpToDate = true;
+ m_updateNewObjectActions = false;
+ m_pPovrayWidget = 0;
+ m_pView = 0;
+ m_pShell = shell;
+ m_pScene = new PMScene( this );
+ m_onlyCopyPaste = true;
+
+ // call inits to invoke all other construction parts
+ setReadWrite( readwrite );
+
+ if( isReadWrite( ) )
+ setXMLFile( "kpovmodelerui.rc" );
+ else
+ setXMLFile( "kpovmodelerbrowser.rc" );
+
+ m_pPrototypeManager = new PMPrototypeManager( this );
+ m_pInsertRuleSystem = new PMInsertRuleSystem( this );
+ m_pIOManager = new PMIOManager( this );
+ m_pInsertRuleSystem->loadRules( "baseinsertrules.xml" );
+ m_pSymbolTable = new PMSymbolTable( );
+
+ initCopyPasteActions( );
+
+ connect( &m_commandManager, SIGNAL( objectChanged( PMObject*, const int, QObject* ) ),
+ SLOT( slotObjectChanged( PMObject*, const int, QObject* ) ) );
+
+ PMPluginManager::theManager( )->registerPart( this );
+
+ emit refresh( );
+}
+
+PMPart::~PMPart( )
+{
+ delete m_pExtension;
+ deleteContents( );
+ delete m_pSymbolTable;
+ delete m_pPovrayWidget;
+ PMPluginManager::theManager( )->removePart( this );
+}
+
+void PMPart::initCopyPasteActions( )
+{
+ // setup edit menu
+ m_pCutAction = KStdAction::cut( this, SLOT( slotEditCut( ) ), actionCollection( ) );
+ m_pCopyAction = KStdAction::copy( this, SLOT( slotEditCopy( ) ), actionCollection( ) );
+ m_pPasteAction = KStdAction::paste( this, SLOT( slotEditPaste( ) ), actionCollection( ) );
+
+ m_pDeleteAction =
+ new KAction( i18n( "Delete" ), "edittrash", Qt::Key_Delete,
+ this, SLOT( slotEditDelete( ) ),
+ actionCollection( ), "edit_delete" );
+
+ m_pCutAction->setEnabled( false );
+ m_pCopyAction->setEnabled( false );
+ m_pPasteAction->setEnabled( false );
+ m_pDeleteAction->setEnabled( false );
+
+}
+
+void PMPart::initActions( )
+{
+ // file menu
+ m_pImportAction = new KAction( i18n( "Import..." ), 0, this,
+ SLOT( slotFileImport( ) ), actionCollection( ),
+ "file_import" );
+ m_pExportAction = new KAction( i18n( "&Export..." ), 0, this,
+ SLOT( slotFileExport( ) ), actionCollection( ),
+ "file_export" );
+
+ initCopyPasteActions( );
+ m_onlyCopyPaste = false;
+
+ m_pRenderComboAction = new PMComboAction( i18n( "Render Modes" ), 0, this, SLOT( slotRenderMode( int ) ),
+ actionCollection( ), "view_render_combo" );
+ m_pRenderComboAction->setMinimumWidth( 250 );
+ connect( m_pRenderComboAction, SIGNAL( plugged( ) ),
+ SLOT( slotRenderModeActionPlugged( ) ) );
+ m_pRenderAction = new KAction( i18n( "Render" ), "pmrender", 0, this, SLOT( slotRender( ) ),
+ actionCollection( ), "view_render" );
+ m_pRenderSettingsAction = new KAction( i18n( "Render Modes..." ), "pmrendersettings", 0, this, SLOT( slotRenderSettings( ) ),
+ actionCollection( ), "view_render_settings" );
+ m_pViewRenderWindowAction = new KAction( i18n( "Render Window" ), 0, this, SLOT( slotViewRenderWindow( ) ),
+ actionCollection( ), "view_render_window" );
+ m_pVisibilityLabelAction = new PMLabelAction( i18n( "Visibility level:" ) + QString( " " ), actionCollection( ), "view_visibility_label" );
+ m_pVisibilityLevelAction = new PMSpinBoxAction( i18n( "Visibility Level" ),
+ 0, this, SLOT( slotVisibilityLevelChanged( int ) ),
+ actionCollection( ), "view_visibility_level" );
+ connect( m_pVisibilityLevelAction, SIGNAL( plugged( ) ),
+ SLOT( slotVisibilityActionPlugged( ) ) );
+
+ m_pGlobalDetailLabelAction = new PMLabelAction( i18n( "Global detail:" ) + QString( " " ), actionCollection( ), "global_detail_label" );
+ m_pGlobalDetailAction = new KSelectAction( i18n("Global Detail Level"), KShortcut(), actionCollection(), "global_detail_level" );
+ QStringList strList;
+ strList.append( i18n( "Very Low" ) );
+ strList.append( i18n( "Low" ) );
+ strList.append( i18n( "Medium" ) );
+ strList.append( i18n( "High" ) );
+ strList.append( i18n( "Very High" ) );
+ m_pGlobalDetailAction->setItems( strList );
+ connect( m_pGlobalDetailAction, SIGNAL( activated( int ) ), SLOT( slotGlobalDetailLevelChanged( int ) ) );
+
+ // new objects
+ if( isReadWrite( ) )
+ {
+ m_pNewGlobalSettingsAction = new KAction( i18n( "Global Settings" ), "pmglobalsettings", 0, this, SLOT( slotNewGlobalSettings( ) ),
+ actionCollection( ), "new_globalsettings" );
+ m_readWriteActions.append( m_pNewGlobalSettingsAction );
+ m_pNewSkySphereAction = new KAction( i18n( "Sky Sphere" ), "pmskysphere", 0, this, SLOT( slotNewSkySphere( ) ),
+ actionCollection( ), "new_skysphere" );
+ m_readWriteActions.append( m_pNewSkySphereAction );
+ m_pNewRainbowAction = new KAction( i18n( "Rainbow" ), "pmrainbow", 0, this, SLOT( slotNewRainbow( ) ),
+ actionCollection( ), "new_rainbow" );
+ m_readWriteActions.append( m_pNewRainbowAction );
+ m_pNewFogAction = new KAction( i18n( "Fog" ), "pmfog", 0, this, SLOT( slotNewFog( ) ),
+ actionCollection( ), "new_fog" );
+ m_readWriteActions.append( m_pNewFogAction );
+ m_pNewInteriorAction = new KAction( i18n( "Interior" ), "pminterior", 0, this, SLOT( slotNewInterior( ) ),
+ actionCollection( ), "new_interior" );
+ m_readWriteActions.append( m_pNewInteriorAction );
+ m_pNewMediaAction = new KAction( i18n( "Media" ), "pmmedia", 0, this, SLOT( slotNewMedia( ) ),
+ actionCollection( ), "new_media" );
+ m_readWriteActions.append( m_pNewMediaAction );
+ m_pNewDensityAction = new KAction( i18n( "Density" ), "pmdensity", 0, this, SLOT( slotNewDensity( ) ),
+ actionCollection( ), "new_density" );
+ m_readWriteActions.append( m_pNewDensityAction );
+ m_pNewMaterialAction = new KAction( i18n( "Material" ), "pmmaterial", 0, this, SLOT( slotNewMaterial( ) ),
+ actionCollection( ), "new_material" );
+ m_readWriteActions.append( m_pNewMaterialAction );
+ m_pNewBoxAction = new KAction( i18n( "Box" ), "pmbox", 0, this, SLOT( slotNewBox( ) ),
+ actionCollection( ), "new_box" );
+ m_readWriteActions.append( m_pNewBoxAction );
+ m_pNewSphereAction = new KAction( i18n( "Sphere" ), "pmsphere", 0, this, SLOT( slotNewSphere( ) ),
+ actionCollection( ), "new_sphere" );
+ m_readWriteActions.append( m_pNewSphereAction );
+ m_pNewCylinderAction = new KAction( i18n( "Cylinder" ), "pmcylinder", 0, this, SLOT( slotNewCylinder( ) ),
+ actionCollection( ), "new_cylinder" );
+ m_readWriteActions.append( m_pNewCylinderAction );
+ m_pNewConeAction = new KAction( i18n( "Cone" ), "pmcone", 0, this, SLOT( slotNewCone( ) ),
+ actionCollection( ), "new_cone" );
+ m_readWriteActions.append( m_pNewConeAction );
+ m_pNewTorusAction = new KAction( i18n( "Torus" ), "pmtorus", 0, this, SLOT( slotNewTorus( ) ),
+ actionCollection( ), "new_torus" );
+ m_readWriteActions.append( m_pNewTorusAction );
+
+ m_pNewLatheAction = new KAction( i18n( "Lathe" ), "pmlathe", 0, this, SLOT( slotNewLathe( ) ),
+ actionCollection( ), "new_lathe" );
+ m_readWriteActions.append( m_pNewLatheAction );
+ m_pNewPrismAction = new KAction( i18n( "Prism" ), "pmprism", 0, this, SLOT( slotNewPrism( ) ),
+ actionCollection( ), "new_prism" );
+ m_readWriteActions.append( m_pNewPrismAction );
+ m_pNewSurfaceOfRevolutionAction = new KAction( i18n( "Surface of Revolution" ), "pmsor", 0, this, SLOT( slotNewSurfaceOfRevolution( ) ),
+ actionCollection( ), "new_surfaceofrevolution" );
+ m_readWriteActions.append( m_pNewSurfaceOfRevolutionAction );
+ m_pNewSuperquadricEllipsoidAction = new KAction( i18n( "Superquadric Ellipsoid" ), "pmsqe", 0, this, SLOT( slotNewSuperquadricEllipsoid( ) ),
+ actionCollection( ), "new_superquadricellipsoid" );
+ m_readWriteActions.append( m_pNewSuperquadricEllipsoidAction );
+
+ m_pNewJuliaFractalAction = new KAction( i18n( "Julia Fractal" ), "pmjuliafractal", 0, this, SLOT( slotNewJuliaFractal( ) ),
+ actionCollection( ), "new_juliafractal" );
+ m_readWriteActions.append( m_pNewJuliaFractalAction );
+ m_pNewHeightFieldAction = new KAction( i18n( "Height Field" ), "pmheightfield", 0, this, SLOT( slotNewHeightField( ) ),
+ actionCollection( ), "new_heightfield" );
+ m_readWriteActions.append( m_pNewHeightFieldAction );
+ m_pNewTextAction = new KAction( i18n( "Text" ), "pmtext", 0, this, SLOT( slotNewText( ) ),
+ actionCollection( ), "new_text" );
+ m_readWriteActions.append( m_pNewTextAction );
+
+ m_pNewBlobAction = new KAction( i18n( "Blob" ), "pmblob", 0, this, SLOT( slotNewBlob( ) ),
+ actionCollection( ), "new_blob" );
+ m_readWriteActions.append( m_pNewBlobAction );
+ m_pNewBlobSphereAction = new KAction( i18n( "Blob Sphere" ), "pmblobsphere", 0, this, SLOT( slotNewBlobSphere( ) ),
+ actionCollection( ), "new_blobsphere" );
+ m_readWriteActions.append( m_pNewBlobSphereAction );
+ m_pNewBlobCylinderAction = new KAction( i18n( "Blob Cylinder" ), "pmblobcylinder", 0, this, SLOT( slotNewBlobCylinder( ) ),
+ actionCollection( ), "new_blobcylinder" );
+ m_readWriteActions.append( m_pNewBlobCylinderAction );
+
+ m_pNewPlaneAction = new KAction( i18n( "Plane" ), "pmplane", 0, this, SLOT( slotNewPlane( ) ),
+ actionCollection( ), "new_plane" );
+ m_readWriteActions.append( m_pNewPlaneAction );
+ m_pNewPolynomAction = new KAction( i18n( "Polynom" ), "pmpolynom", 0, this, SLOT( slotNewPolynom( ) ),
+ actionCollection( ), "new_polynom" );
+ m_readWriteActions.append( m_pNewPolynomAction );
+
+ m_pNewDeclareAction = new KAction( i18n( "Declaration" ), "pmdeclare", 0, this, SLOT( slotNewDeclare( ) ),
+ actionCollection( ), "new_declare" );
+ m_readWriteActions.append( m_pNewDeclareAction );
+ m_pNewObjectLinkAction = new KAction( i18n( "Object Link" ), "pmobjectlink", 0, this, SLOT( slotNewObjectLink( ) ),
+ actionCollection( ), "new_objectlink" );
+ m_readWriteActions.append( m_pNewObjectLinkAction );
+
+ m_pNewUnionAction = new KAction( i18n( "Union" ), "pmunion", 0, this, SLOT( slotNewUnion( ) ),
+ actionCollection( ), "new_union" );
+ m_readWriteActions.append( m_pNewUnionAction );
+ m_pNewIntersectionAction = new KAction( i18n( "Intersection" ), "pmintersection", 0, this, SLOT( slotNewIntersection( ) ),
+ actionCollection( ), "new_intersection" );
+ m_readWriteActions.append( m_pNewIntersectionAction );
+ m_pNewDifferenceAction = new KAction( i18n( "Difference" ), "pmdifference", 0, this, SLOT( slotNewDifference( ) ),
+ actionCollection( ), "new_difference" );
+ m_readWriteActions.append( m_pNewDifferenceAction );
+ m_pNewMergeAction = new KAction( i18n( "Merge" ), "pmmerge", 0, this, SLOT( slotNewMerge( ) ),
+ actionCollection( ), "new_merge" );
+ m_readWriteActions.append( m_pNewMergeAction );
+
+ m_pNewBoundedByAction = new KAction( i18n( "Bounded By" ), "pmboundedby", 0, this, SLOT( slotNewBoundedBy( ) ),
+ actionCollection( ), "new_boundedby" );
+ m_readWriteActions.append( m_pNewBoundedByAction );
+ m_pNewClippedByAction = new KAction( i18n( "Clipped By" ), "pmclippedby", 0, this, SLOT( slotNewClippedBy( ) ),
+ actionCollection( ), "new_clippedby" );
+ m_readWriteActions.append( m_pNewClippedByAction );
+
+ m_pNewLightAction = new KAction( i18n( "Light" ), "pmlight", 0, this, SLOT( slotNewLight( ) ),
+ actionCollection( ), "new_light" );
+ m_readWriteActions.append( m_pNewLightAction );
+ m_pNewLooksLikeAction = new KAction( i18n( "Looks Like" ), "pmlookslike", 0, this, SLOT( slotNewLooksLike( ) ),
+ actionCollection( ), "new_lookslike" );
+ m_readWriteActions.append( m_pNewLooksLikeAction );
+ m_pNewProjectedThroughAction = new KAction( i18n( "Projected Through" ), "pmprojectedthrough", 0, this, SLOT( slotNewProjectedThrough( ) ),
+ actionCollection( ), "new_projectedthrough" );
+ m_readWriteActions.append( m_pNewProjectedThroughAction );
+
+ m_pNewBicubicPatchAction = new KAction( i18n( "Bicubic Patch" ), "pmbicubicpatch", 0, this, SLOT( slotNewBicubicPatch( ) ),
+ actionCollection( ), "new_bicubicpatch" );
+ m_readWriteActions.append( m_pNewBicubicPatchAction );
+ m_pNewDiscAction = new KAction( i18n( "Disc" ), "pmdisc", 0, this, SLOT( slotNewDisc( ) ),
+ actionCollection( ), "new_disc" );
+ m_readWriteActions.append( m_pNewDiscAction );
+ m_pNewTriangleAction = new KAction( i18n( "Triangle" ), "pmtriangle", 0, this, SLOT( slotNewTriangle( ) ),
+ actionCollection( ), "new_triangle" );
+ m_readWriteActions.append( m_pNewTriangleAction );
+
+
+ m_pNewCameraAction = new KAction( i18n( "Camera" ), "pmcamera", 0, this, SLOT( slotNewCamera( ) ),
+ actionCollection( ), "new_camera" );
+ m_readWriteActions.append( m_pNewCameraAction );
+
+ m_pNewTextureAction = new KAction( i18n( "Texture" ), "pmtexture", 0, this, SLOT( slotNewTexture( ) ),
+ actionCollection( ), "new_texture" );
+ m_readWriteActions.append( m_pNewTextureAction );
+
+ m_pNewPigmentAction = new KAction( i18n( "Pigment" ), "pmpigment", 0, this, SLOT( slotNewPigment( ) ),
+ actionCollection( ), "new_pigment" );
+ m_readWriteActions.append( m_pNewPigmentAction );
+ m_pNewNormalAction = new KAction( i18n( "Normal" ), "pmnormal", 0, this, SLOT( slotNewNormal( ) ),
+ actionCollection( ), "new_normal" );
+ m_readWriteActions.append( m_pNewNormalAction );
+ m_pNewSolidColorAction = new KAction( i18n( "Solid Color" ), "pmsolidcolor", 0, this, SLOT( slotNewSolidColor( ) ),
+ actionCollection( ), "new_solidcolor" );
+ m_readWriteActions.append( m_pNewSolidColorAction );
+
+ m_pNewTextureListAction = new KAction( i18n( "Texture List" ), "pmtexturelist", 0, this, SLOT( slotNewTextureList( ) ),
+ actionCollection( ), "new_texturelist" );
+ m_readWriteActions.append( m_pNewTextureListAction );
+ m_pNewColorListAction = new KAction( i18n( "Color List" ), "pmcolorlist", 0, this, SLOT( slotNewColorList( ) ),
+ actionCollection( ), "new_colorlist" );
+ m_readWriteActions.append( m_pNewColorListAction );
+ m_pNewPigmentListAction = new KAction( i18n( "Pigment List" ), "pmpigmentlist", 0, this, SLOT( slotNewPigmentList( ) ),
+ actionCollection( ), "new_pigmentlist" );
+ m_readWriteActions.append( m_pNewPigmentListAction );
+ m_pNewNormalListAction = new KAction( i18n( "Normal List" ), "pmnormallist", 0, this, SLOT( slotNewNormalList( ) ),
+ actionCollection( ), "new_normallist" );
+ m_readWriteActions.append( m_pNewNormalListAction );
+ m_pNewDensityListAction = new KAction( i18n( "Density List" ), "pmdensitylist", 0, this, SLOT( slotNewDensityList( ) ),
+ actionCollection( ), "new_densitylist" );
+ m_readWriteActions.append( m_pNewDensityListAction );
+
+ m_pNewFinishAction = new KAction( i18n( "Finish" ), "pmfinish", 0, this, SLOT( slotNewFinish( ) ),
+ actionCollection( ), "new_finish" );
+ m_readWriteActions.append( m_pNewFinishAction );
+
+ m_pNewPatternAction = new KAction( i18n( "Pattern" ), "pmpattern", 0, this, SLOT( slotNewPattern( ) ),
+ actionCollection( ), "new_pattern" );
+ m_readWriteActions.append( m_pNewPatternAction );
+ m_pNewBlendMapModifiersAction = new KAction( i18n( "Blend Map Modifiers" ), "pmblendmapmodifiers", 0, this, SLOT( slotNewBlendMapModifiers( ) ),
+ actionCollection( ), "new_blendmapmodifiers" );
+ m_readWriteActions.append( m_pNewBlendMapModifiersAction );
+ m_pNewTextureMapAction = new KAction( i18n( "Texture Map" ), "pmtexturemap", 0, this, SLOT( slotNewTextureMap( ) ),
+ actionCollection( ), "new_texturemap" );
+ m_readWriteActions.append( m_pNewTextureMapAction );
+ m_pNewMaterialMapAction = new KAction( i18n( "Material Map" ), "pmmaterialmap", 0, this, SLOT( slotNewMaterialMap( ) ),
+ actionCollection( ), "new_materialmap" );
+ m_readWriteActions.append( m_pNewMaterialMapAction );
+ m_pNewPigmentMapAction = new KAction( i18n( "Pigment Map" ), "pmpigmentmap", 0, this, SLOT( slotNewPigmentMap( ) ),
+ actionCollection( ), "new_pigmentmap" );
+ m_readWriteActions.append( m_pNewPigmentMapAction );
+ m_pNewColorMapAction = new KAction( i18n( "Color Map" ), "pmcolormap", 0, this, SLOT( slotNewColorMap( ) ),
+ actionCollection( ), "new_colormap" );
+ m_readWriteActions.append( m_pNewColorMapAction );
+ m_pNewNormalMapAction = new KAction( i18n( "Normal Map" ), "pmnormalmap", 0, this, SLOT( slotNewNormalMap( ) ),
+ actionCollection( ), "new_normalmap" );
+ m_readWriteActions.append( m_pNewNormalMapAction );
+ m_pNewBumpMapAction = new KAction( i18n( "Bump Map" ), "pmbumpmap", 0, this, SLOT( slotNewBumpMap( ) ),
+ actionCollection( ), "new_bumpmap" );
+ m_readWriteActions.append( m_pNewBumpMapAction );
+ m_pNewSlopeMapAction = new KAction( i18n( "Slope Map" ), "pmslopemap", 0, this, SLOT( slotNewSlopeMap( ) ),
+ actionCollection( ), "new_slopemap" );
+ m_readWriteActions.append( m_pNewSlopeMapAction );
+ m_pNewDensityMapAction = new KAction( i18n( "Density Map" ), "pmdensitymap", 0, this, SLOT( slotNewDensityMap( ) ),
+ actionCollection( ), "new_densitymap" );
+ m_readWriteActions.append( m_pNewDensityMapAction );
+ m_pNewSlopeAction = new KAction( i18n( "Slope" ), "pmslope", 0, this, SLOT( slotNewSlope( ) ),
+ actionCollection( ), "new_slope" );
+ m_readWriteActions.append( m_pNewSlopeAction );
+
+ m_pNewWarpAction = new KAction( i18n( "Warp" ), "pmwarp", 0, this, SLOT( slotNewWarp( ) ),
+ actionCollection( ), "new_warp" );
+ m_readWriteActions.append( m_pNewWarpAction );
+ m_pNewImageMapAction = new KAction( i18n( "Image Map" ), "pmimagemap", 0, this, SLOT( slotNewImageMap( ) ),
+ actionCollection( ), "new_imagemap" );
+ m_readWriteActions.append( m_pNewImageMapAction );
+ m_pNewQuickColorAction = new KAction( i18n( "QuickColor" ), "pmquickcolor", 0, this, SLOT( slotNewQuickColor( ) ),
+ actionCollection( ), "new_quickcolor" );
+ m_readWriteActions.append( m_pNewQuickColorAction );
+
+ m_pNewTranslateAction = new KAction( i18n( "Translate" ), "pmtranslate", 0, this, SLOT( slotNewTranslate( ) ),
+ actionCollection( ), "new_translate" );
+ m_readWriteActions.append( m_pNewTranslateAction );
+ m_pNewScaleAction = new KAction( i18n( "Scale" ), "pmscale", 0, this, SLOT( slotNewScale( ) ),
+ actionCollection( ), "new_scale" );
+ m_readWriteActions.append( m_pNewScaleAction );
+ m_pNewRotateAction = new KAction( i18n( "Rotate" ), "pmrotate", 0, this, SLOT( slotNewRotate( ) ),
+ actionCollection( ), "new_rotate" );
+ m_readWriteActions.append( m_pNewRotateAction );
+ m_pNewMatrixAction = new KAction( i18n( "Matrix" ), "pmmatrix", 0, this, SLOT( slotNewMatrix( ) ),
+ actionCollection( ), "new_povraymatrix" );
+ m_readWriteActions.append( m_pNewMatrixAction );
+
+ m_pNewCommentAction = new KAction( i18n( "Comment" ), "pmcomment", 0, this, SLOT( slotNewComment( ) ),
+ actionCollection( ), "new_comment" );
+ m_readWriteActions.append( m_pNewCommentAction );
+ m_pNewRawAction = new KAction( i18n( "Raw Povray" ), "pmraw", 0, this, SLOT( slotNewRaw( ) ),
+ actionCollection( ), "new_raw" );
+ m_readWriteActions.append( m_pNewRawAction );
+
+ // POV-Ray 3.5 objects
+ m_pNewIsoSurfaceAction = new KAction( i18n( "Iso Surface" ), "pmisosurface", 0, this, SLOT( slotNewIsoSurface( ) ),
+ actionCollection( ), "new_isosurface" );
+ m_readWriteActions.append( m_pNewIsoSurfaceAction );
+ m_pNewRadiosityAction = new KAction( i18n( "Radiosity" ), "pmradiosity", 0, this, SLOT( slotNewRadiosity( ) ),
+ actionCollection( ), "new_radiosity" );
+ m_readWriteActions.append( m_pNewRadiosityAction );
+ m_pNewGlobalPhotonsAction = new KAction( i18n( "Global Photons" ), "pmglobalphotons", 0, this, SLOT( slotNewGlobalPhotons( ) ),
+ actionCollection( ), "new_globalphotons" );
+ m_readWriteActions.append( m_pNewGlobalPhotonsAction );
+ m_pNewPhotonsAction = new KAction( i18n( "Photons" ), "pmphotons", 0, this, SLOT( slotNewPhotons( ) ),
+ actionCollection( ), "new_photons" );
+ m_readWriteActions.append( m_pNewPhotonsAction );
+ m_pNewLightGroupAction = new KAction( i18n( "Light Group" ), "pmlightgroup", 0, this, SLOT( slotNewLightGroup( ) ),
+ actionCollection( ), "new_lightgroup" );
+ m_readWriteActions.append( m_pNewLightGroupAction );
+ m_pNewInteriorTextureAction = new KAction( i18n( "Interior Texture" ), "pminteriortexture", 0, this, SLOT( slotNewInteriorTexture( ) ),
+ actionCollection( ), "new_interiortexture" );
+ m_readWriteActions.append( m_pNewInteriorTextureAction );
+ m_pNewSphereSweepAction = new KAction( i18n( "Sphere Sweep" ), "pmspheresweep", 0, this, SLOT( slotNewSphereSweep( ) ),
+ actionCollection( ), "new_spheresweep" );
+ m_readWriteActions.append( m_pNewSphereSweepAction );
+ m_pNewMeshAction = new KAction( i18n( "Mesh" ), "pmmesh", 0, this, SLOT( slotNewMesh( ) ),
+ actionCollection( ), "new_mesh" );
+ m_readWriteActions.append( m_pNewMeshAction );
+
+#ifdef KPM_WITH_OBJECT_LIBRARY
+ m_pSearchLibraryObjectAction = new KAction( i18n( "Search Object" ), "pmsearchlibrary", 0, this, SLOT( slotSearchLibraryObject( ) ),
+ actionCollection( ), "search_library_object" );
+ m_readWriteActions.append( m_pSearchLibraryObjectAction );
+#endif
+
+ m_pUndoAction = KStdAction::undo( this, SLOT( slotEditUndo( ) ), actionCollection( ) );
+ m_pRedoAction = KStdAction::redo( this, SLOT( slotEditRedo( ) ), actionCollection( ) );
+ m_pUndoAction->setEnabled( false );
+ m_pRedoAction->setEnabled( false );
+ }
+ else
+ {
+ m_pNewGlobalSettingsAction = 0;
+ m_pNewSkySphereAction = 0;
+ m_pNewRainbowAction = 0;
+ m_pNewFogAction = 0;
+
+ m_pNewInteriorAction = 0;
+ m_pNewMediaAction = 0;
+ m_pNewDensityAction = 0;
+ m_pNewMaterialAction = 0;
+ m_pNewBoxAction = 0;
+ m_pNewSphereAction = 0;
+ m_pNewCylinderAction = 0;
+ m_pNewConeAction = 0;
+ m_pNewTorusAction = 0;
+ m_pNewLatheAction = 0;
+ m_pNewPrismAction = 0;
+ m_pNewSurfaceOfRevolutionAction = 0;
+ m_pNewSuperquadricEllipsoidAction = 0;
+ m_pNewJuliaFractalAction = 0;
+ m_pNewHeightFieldAction = 0;
+ m_pNewTextAction = 0;
+
+ m_pNewBlobAction = 0;
+ m_pNewBlobSphereAction = 0;
+ m_pNewBlobCylinderAction = 0;
+
+ m_pNewPlaneAction = 0;
+ m_pNewPolynomAction = 0;
+
+ m_pNewDeclareAction = 0;
+ m_pNewObjectLinkAction = 0;
+
+ m_pNewDiscAction = 0;
+ m_pNewBicubicPatchAction = 0;
+ m_pNewTriangleAction = 0;
+
+ m_pNewUnionAction = 0;
+ m_pNewDifferenceAction = 0;
+ m_pNewIntersectionAction = 0;
+ m_pNewMergeAction = 0;
+
+ m_pNewBoundedByAction = 0;
+ m_pNewClippedByAction = 0;
+
+ m_pNewLightAction = 0;
+ m_pNewLooksLikeAction = 0;
+ m_pNewProjectedThroughAction = 0;
+
+ m_pNewCameraAction = 0;
+
+ m_pNewTextureAction = 0;
+ m_pNewPigmentAction = 0;
+ m_pNewNormalAction = 0;
+ m_pNewSolidColorAction = 0;
+ m_pNewFinishAction = 0;
+ m_pNewTextureListAction = 0;
+ m_pNewColorListAction = 0;
+ m_pNewPigmentListAction = 0;
+ m_pNewNormalListAction = 0;
+ m_pNewDensityListAction = 0;
+
+ m_pNewPatternAction = 0;
+ m_pNewBlendMapModifiersAction = 0;
+ m_pNewTextureMapAction = 0;
+ m_pNewMaterialMapAction = 0;
+ m_pNewPigmentMapAction = 0;
+ m_pNewColorMapAction = 0;
+ m_pNewNormalMapAction = 0;
+ m_pNewBumpMapAction = 0;
+ m_pNewSlopeMapAction = 0;
+ m_pNewDensityMapAction = 0;
+
+ m_pNewWarpAction = 0;
+ m_pNewImageMapAction = 0;
+ m_pNewSlopeAction = 0;
+
+ m_pNewTranslateAction = 0;
+ m_pNewScaleAction = 0;
+ m_pNewRotateAction = 0;
+ m_pNewMatrixAction = 0;
+ m_pNewCommentAction = 0;
+ m_pNewRawAction = 0;
+
+ m_pNewIsoSurfaceAction = 0;
+ m_pNewRadiosityAction = 0;
+ m_pNewGlobalPhotonsAction = 0;
+ m_pNewPhotonsAction = 0;
+ m_pNewLightGroupAction = 0;
+ m_pNewInteriorTextureAction = 0;
+ m_pNewSphereSweepAction = 0;
+ m_pNewMeshAction = 0;
+
+ // POV-Ray
+
+ m_pUndoAction = 0;
+ m_pRedoAction = 0;
+ }
+}
+
+void PMPart::updateNewObjectActions( )
+{
+ if( isReadWrite( ) && !m_onlyCopyPaste )
+ {
+ QPtrListIterator<PMMetaObject> it =
+ m_pPrototypeManager->prototypeIterator( );
+ KAction* action;
+ bool enable;
+ bool readWriteParent = false;
+
+ if( m_pActiveObject )
+ if( m_pActiveObject->parent( ) )
+ if( !m_pActiveObject->parent( )->isReadOnly( ) )
+ readWriteParent = true;
+
+ for( ; it.current( ); ++it )
+ {
+ // get the action object for that type of PMObject
+ // action names are "new_" + povray name
+ // (like new_box, new_sphere ...)
+
+ QString actionName = "new_" + it.current( )->className( ).lower( );
+ action = actionCollection( )->action( actionName.latin1( ) );
+ if( action )
+ {
+ if( m_pActiveObject )
+ {
+ QString insertName = it.current( )->className( );
+ enable = m_pActiveObject->canInsert( insertName, 0 );
+ if( !enable )
+ if( m_pActiveObject->lastChild( ) )
+ enable = m_pActiveObject->canInsert( insertName, m_pActiveObject->lastChild( ) );
+ if( !enable )
+ if( readWriteParent )
+ enable |= m_pActiveObject->parent( )->canInsert( insertName, m_pActiveObject );
+ }
+ else
+ enable = false;
+ action->setEnabled( enable );
+ }
+ }
+ // special treatment for csg actions
+ if( m_pActiveObject )
+ {
+ enable = m_pActiveObject->canInsert( QString( "CSG" ), 0 );
+ if( !enable )
+ if( m_pActiveObject->lastChild( ) )
+ enable = m_pActiveObject->canInsert( QString( "CSG" ), m_pActiveObject->lastChild( ) );
+ if( !enable )
+ if( readWriteParent )
+ enable = m_pActiveObject->parent( )->canInsert( QString( "CSG" ), m_pActiveObject );
+ }
+ else
+ enable = false;
+ m_pNewUnionAction->setEnabled( enable );
+ m_pNewIntersectionAction->setEnabled( enable );
+ m_pNewDifferenceAction->setEnabled( enable );
+ m_pNewMergeAction->setEnabled( enable );
+ }
+ m_updateNewObjectActions = false;
+}
+
+void PMPart::disableReadWriteActions( )
+{
+ QPtrListIterator<KAction> it( m_readWriteActions);
+ for( ; it.current( ); ++it )
+ it.current( )->setEnabled( false );
+}
+
+void PMPart::initDocument( )
+{
+ newDocument( );
+}
+
+void PMPart::initView( QWidget* parent, const char* name )
+{
+ if( !m_pShell )
+ {
+ // a part inside konqueror
+ // simple layout
+ m_pView = new PMView( this, parent, name );
+ m_pView->show( );
+ setWidget( m_pView );
+ }
+ else
+ {
+ // inside a PMShell
+ // the shell will create the view
+ }
+}
+
+void PMPart::saveConfig( KConfig* cfg )
+{
+ if( m_pView )
+ m_pView->saveConfig( cfg );
+ PMErrorDialog::saveConfig( cfg );
+ PMRenderModesDialog::saveConfig( cfg );
+ PMRenderModeDialog::saveConfig( cfg );
+ PMPovrayOutputWidget::saveConfig( cfg );
+ PMRenderManager::theManager( )->saveConfig( cfg );
+ PMGLView::saveConfig( cfg );
+ PMDialogEditBase::saveConfig( cfg );
+ PMControlPoint::saveConfig( cfg );
+ PMPovrayRenderWidget::saveConfig( cfg );
+ PMSettingsDialog::saveConfig( cfg );
+ PMLibraryHandleEdit::saveConfig( cfg );
+ PMDocumentationMap::theMap( )->saveConfig( cfg );
+ PMLibraryManager::theManager( )->saveConfig(cfg );
+
+ cfg->setGroup( "Rendering" );
+ cfg->writeEntry( "SphereUSteps", PMSphere::uSteps( ) );
+ cfg->writeEntry( "SphereVSteps", PMSphere::vSteps( ) );
+ cfg->writeEntry( "CylinderSteps", PMCylinder::steps( ) );
+ cfg->writeEntry( "ConeSteps", PMCone::steps( ) );
+ cfg->writeEntry( "DiscSteps", PMDisc::steps( ) );
+ cfg->writeEntry( "BlobSphereUSteps", PMBlobSphere::uSteps( ) );
+ cfg->writeEntry( "BlobSphereVSteps", PMBlobSphere::vSteps( ) );
+ cfg->writeEntry( "BlobCylinderUSteps", PMBlobCylinder::uSteps( ) );
+ cfg->writeEntry( "BlobCylinderVSteps", PMBlobCylinder::vSteps( ) );
+ cfg->writeEntry( "TorusUSteps", PMTorus::uSteps( ) );
+ cfg->writeEntry( "TorusVSteps", PMTorus::vSteps( ) );
+ cfg->writeEntry( "LatheSSteps", PMLathe::sSteps( ) );
+ cfg->writeEntry( "LatheRSteps", PMLathe::rSteps( ) );
+ cfg->writeEntry( "SorSSteps", PMSurfaceOfRevolution::sSteps( ) );
+ cfg->writeEntry( "SorRSteps", PMSurfaceOfRevolution::rSteps( ) );
+ cfg->writeEntry( "PrismSSteps", PMPrism::sSteps( ) );
+ cfg->writeEntry( "PlaneSize", PMPlane::planeSize( ) );
+ cfg->writeEntry( "SqeUSteps", PMSuperquadricEllipsoid::uSteps( ) );
+ cfg->writeEntry( "SqeVSteps", PMSuperquadricEllipsoid::vSteps( ) );
+ cfg->writeEntry( "SphereSweepRSteps", PMSphereSweep::rSteps( ) );
+ cfg->writeEntry( "SphereSweepSSteps", PMSphereSweep::sSteps( ) );
+ cfg->writeEntry( "HeightFieldVariance", PMHeightField::variance( ) );
+ cfg->writeEntry( "GlobalDetailLevel", PMDetailObject::globalDetailLevel( ) );
+
+ cfg->writeEntry( "DirectRendering", PMGLView::isDirectRenderingEnabled( ) );
+}
+
+void PMPart::restoreConfig( KConfig* cfg )
+{
+ if( m_pView )
+ m_pView->restoreConfig( cfg );
+ PMErrorDialog::restoreConfig( cfg );
+ PMRenderModesDialog::restoreConfig( cfg );
+ PMRenderModeDialog::restoreConfig( cfg );
+ PMPovrayOutputWidget::restoreConfig( cfg );
+ PMRenderManager::theManager( )->restoreConfig( cfg );
+ PMGLView::restoreConfig( cfg );
+ PMDialogEditBase::restoreConfig( cfg );
+ PMControlPoint::restoreConfig( cfg );
+ PMPovrayRenderWidget::restoreConfig( cfg );
+ PMSettingsDialog::restoreConfig( cfg );
+ PMLibraryHandleEdit::restoreConfig( cfg );
+ PMDocumentationMap::theMap( )->restoreConfig( cfg );
+ PMLibraryManager::theManager( )->restoreConfig(cfg );
+
+ cfg->setGroup( "Rendering" );
+ PMSphere::setUSteps( cfg->readNumEntry( "SphereUSteps", c_defaultSphereUSteps ) );
+ PMSphere::setVSteps( cfg->readNumEntry( "SphereVSteps", c_defaultSphereVSteps ) );
+ PMCylinder::setSteps( cfg->readNumEntry( "CylinderSteps", c_defaultCylinderSteps ) );
+ PMCone::setSteps( cfg->readNumEntry( "ConeSteps", c_defaultConeSteps ) );
+ PMTorus::setUSteps( cfg->readNumEntry( "TorusUSteps", c_defaultTorusUSteps ) );
+ PMTorus::setVSteps( cfg->readNumEntry( "TorusVSteps", c_defaultTorusVSteps ) );
+ PMLathe::setSSteps( cfg->readNumEntry( "LatheSSteps", c_defaultLatheSSteps ) );
+ PMLathe::setRSteps( cfg->readNumEntry( "LatheRSteps", c_defaultLatheRSteps ) );
+ PMSurfaceOfRevolution::setSSteps( cfg->readNumEntry( "SorSSteps", c_defaultSurfaceOfRevolutionSSteps ) );
+ PMSurfaceOfRevolution::setRSteps( cfg->readNumEntry( "SorRSteps", c_defaultSurfaceOfRevolutionRSteps ) );
+ PMPrism::setSSteps( cfg->readNumEntry( "PrismSSteps", c_defaultPrismSSteps ) );
+ PMPlane::setPlaneSize( cfg->readDoubleNumEntry( "PlaneSize", c_defaultPlaneSize ) );
+ PMDisc::setSteps( cfg->readNumEntry( "DiscSteps", c_defaultDiscSteps ) );
+ PMBlobSphere::setUSteps( cfg->readNumEntry( "BlobSphereUSteps", c_defaultBlobSphereUSteps ) );
+ PMBlobSphere::setVSteps( cfg->readNumEntry( "BlobSphereVSteps", c_defaultBlobSphereVSteps ) );
+ PMBlobCylinder::setUSteps( cfg->readNumEntry( "BlobCylinderUSteps", c_defaultBlobCylinderUSteps ) );
+ PMBlobCylinder::setVSteps( cfg->readNumEntry( "BlobCylinderVSteps", c_defaultBlobCylinderVSteps ) );
+ PMSuperquadricEllipsoid::setUSteps( cfg->readNumEntry( "SqeUSteps", c_defaultSuperquadricEllipsoidUSteps ) );
+ PMSuperquadricEllipsoid::setVSteps( cfg->readNumEntry( "SqeVSteps", c_defaultSuperquadricEllipsoidVSteps ) );
+ PMSphereSweep::setRSteps( cfg->readNumEntry( "SphereSweepRSteps", c_defaultSphereSweepRSteps ) );
+ PMSphereSweep::setSSteps( cfg->readNumEntry( "SphereSweepSSteps", c_defaultSphereSweepSSteps ) );
+ PMHeightField::setVariance( cfg->readNumEntry( "HeightFieldVariance", c_defaultHeightFieldVariance ) );
+ PMDetailObject::setGlobalDetailLevel( cfg->readNumEntry( "GlobalDetailLevel", c_defaultDetailObjectGlobalDetailLevel ) );
+ m_pGlobalDetailAction->setCurrentItem( PMDetailObject::globalDetailLevel( ) - 1 );
+
+ if( PMGLView::isDirectRenderingEnabled( ) ) // otherwise it was disabled with a command line switch
+ PMGLView::enableDirectRendering( cfg->readBoolEntry( "DirectRendering", true ) );
+}
+
+bool PMPart::openFile( )
+{
+ QIODevice* dev = KFilterDev::deviceForFile( m_file, "application/x-gzip" );
+ bool success = true;
+ PMObjectList list;
+
+ deleteContents( );
+
+ setModified( false );
+
+ if( dev && dev->open( IO_ReadOnly ) )
+ {
+ PMXMLParser parser( this, dev );
+
+ parser.parse( &list, 0, 0 );
+
+ if( parser.errors( ) || parser.warnings( ) )
+ {
+ PMErrorDialog dlg( parser.messages( ), parser.errorFlags( ) );
+ // still try to insert the correct parsed objects?
+ success = ( dlg.exec( ) == QDialog::Accepted );
+ }
+ if( success )
+ {
+ PMObject* obj = list.first( );
+ if( obj )
+ {
+ if( obj->type( ) == "Scene" )
+ m_pScene = ( PMScene* ) obj;
+ else
+ success = false;
+ }
+ else
+ success = false;
+ }
+ }
+ else
+ success = false;
+
+ if( !success )
+ {
+ m_url = KURL( );
+ newDocument( );
+ }
+
+ m_pScene->setReadOnly( !isReadWrite( ) );
+ if( !isReadWrite( ) )
+ disableReadWriteActions( );
+ m_bCameraListUpToDate = false;
+
+ emit refresh( );
+ updateRenderModes( );
+ updateVisibilityLevel( );
+ slotObjectChanged( m_pScene, PMCNewSelection, this );
+
+ if( dev )
+ delete dev;
+
+ return success;
+}
+
+bool PMPart::saveFile( )
+{
+ bool success = false;
+
+ QIODevice* dev = KFilterDev::deviceForFile( m_file, "application/x-gzip" );
+ if( dev && dev->open( IO_WriteOnly ) )
+ {
+ QDomDocument doc( "KPOVMODELER" );
+ QDomElement e = ( ( PMObject* )m_pScene)->serialize( doc );
+ doc.appendChild( e );
+
+ QTextStream str( dev );
+ str << doc;
+ dev->close( );
+ setModified( false );
+ success = true;
+ }
+
+ if( dev )
+ delete dev;
+
+ return success;
+}
+
+bool PMPart::exportPovray( const KURL& url )
+{
+ KTempFile* tempFile = 0;
+ QFile* file = 0;
+ bool ok = true;
+
+ if( !url.isValid( ) )
+ return false;
+
+ if( url.isLocalFile( ) )
+ {
+ // Local file
+ file = new QFile( url.path( ) );
+ if( !file->open( IO_WriteOnly ) )
+ ok = false;
+ }
+ else
+ {
+ // Remote file
+ // provide a temp file
+ tempFile = new KTempFile( );
+ if( tempFile->status( ) != 0 )
+ ok = false;
+ else
+ file = tempFile->file( );
+ }
+
+ if( ok )
+ {
+ PMPovray35Format format;
+ PMSerializer* dev = format.newSerializer( file );
+ dev->serialize( m_pScene );
+ delete dev;
+
+ if( tempFile )
+ {
+ tempFile->close( );
+ ok = KIO::NetAccess::upload( tempFile->name( ), url, (QWidget*) 0 );
+ tempFile->unlink( );
+ file = 0;
+ }
+ else
+ file->close( );
+ }
+
+ delete file;
+ delete tempFile;
+
+ return ok;
+}
+
+QString PMPart::activeObjectName( )
+{
+ QString result = "";
+ PMObject* tmpObj;
+ PMObject* testSib;
+ int idx = 0;
+
+ tmpObj = activeObject( );
+ while( tmpObj != m_pScene && tmpObj )
+ {
+ // count previous siblings of the same type (for array like entries)
+ testSib = tmpObj;
+ while( ( testSib = testSib->prevSibling( ) ) )
+ if( testSib->type( ) == tmpObj->type( ) )
+ idx++;
+
+ // prepend to result
+ if( idx != 0 )
+ result = tmpObj->type( ) + "[" + QString::number( idx ) + "]/" + result;
+ else
+ result = tmpObj->type( ) + "/" + result;
+
+ // go up in the scene
+ tmpObj = tmpObj->parent( );
+ idx = 0;
+ }
+
+ // Make the object name an absolute name
+ result = "/" + result;
+
+ return result;
+}
+
+bool PMPart::setActiveObject( const QString& name )
+{
+ PMObject* tmpObj;
+ PMObject* tmpSibling;
+ int pos, siblingIndex, objIndex, firstBracket, lastBracket;
+ QString objPath;
+ QString pathElem;
+
+ // check if it's a absolute object name
+ if( name[0] == '/' )
+ {
+ tmpObj = m_pScene;
+ objPath = name.mid( 1 ); // clear that first character
+ }
+ else
+ tmpObj = activeObject( );
+
+ // get the first element
+ pos = objPath.find( '/' );
+ if( pos != -1 )
+ {
+ pathElem = objPath.mid( 0, pos );
+ objPath = objPath.mid( pos + 1 );
+ }
+ else
+ {
+ pathElem = objPath;
+ objPath = QString::null;
+ }
+
+ while( !pathElem.isNull( ) )
+ {
+ if( !pathElem.isEmpty( ) )
+ {
+ // Special treatment for brackets
+ firstBracket = pathElem.find( '[' );
+ if( firstBracket != -1 )
+ {
+ lastBracket = pathElem.findRev( ']' );
+ objIndex = pathElem.mid( firstBracket + 1, lastBracket - firstBracket - 1).toInt( );
+ pathElem = pathElem.left( firstBracket );
+ }
+ else
+ objIndex = 0;
+
+ // Iterate the children for this element. We stop when there are no more siblings
+ // or the object is of the correct type and it's index count is also correct
+ siblingIndex = 0;
+ tmpSibling = tmpObj->firstChild( );
+ for( ; tmpSibling && ( tmpSibling->type( ) != pathElem || siblingIndex != objIndex );
+ tmpSibling = tmpSibling->nextSibling( ) )
+ {
+ // Found an object of the type we are looking for
+ if( tmpSibling->type( ) == pathElem )
+ siblingIndex++;
+ }
+ if( tmpSibling )
+ tmpObj = tmpSibling;
+ else
+ // No correct sibling
+ return false;
+
+ }
+
+ // Get the next element
+ pos = objPath.find( '/' );
+ if( pos != -1 )
+ {
+ pathElem = objPath.mid( 0, pos );
+ objPath = objPath.mid( pos + 1 );
+ }
+ else
+ {
+ pathElem = objPath;
+ objPath = QString::null;
+ }
+ }
+ if( tmpObj )
+ {
+ slotObjectChanged( tmpObj, PMCNewSelection, this );
+ return true;
+ }
+ else
+ return false;
+}
+
+QStringList PMPart::getProperties( )
+{
+ PMObject* curObj = activeObject( );
+
+ // Ensure that there is an active object
+ if( !curObj )
+ return QStringList( );
+
+ return curObj->properties( );
+}
+
+bool PMPart::setProperty( const QString& name, const PMVariant& value )
+{
+ PMObject* curObj = activeObject( );
+
+ // Ensure that there is an active object
+ if( !curObj )
+ return false;
+
+ curObj->setProperty( name, value );
+ slotObjectChanged( curObj, PMCNewSelection, this );
+ return true;
+}
+
+bool PMPart::setProperty( const QString& name, const QString& value )
+{
+ PMObject* curObj = activeObject( );
+ PMVariant variant;
+
+ // Ensure that there is an active object
+ if( !curObj )
+ return false;
+
+ variant.fromString( curObj->property( name ).dataType( ), value );
+ curObj->setProperty( name, variant );
+ slotObjectChanged( curObj, PMCNewSelection, this );
+ return true;
+}
+
+const PMVariant PMPart::getProperty( const QString& name )
+{
+ PMObject* curObj = activeObject( );
+
+ // Ensure that there is an active object
+ if( !curObj )
+ return PMVariant( );
+
+ return curObj->property( name );
+}
+
+const QString PMPart::getPropertyStr( const QString& name )
+{
+ PMObject* curObj = activeObject( );
+
+ // Ensure that there is an active object
+ if( !curObj )
+ return PMVariant( ).asString( );
+
+ return curObj->property( name ).asString( );
+}
+
+const PMObjectList& PMPart::selectedObjects( )
+{
+ uint numObjects = m_selectedObjects.count( );
+ uint numOrdered = 0;
+ bool stop = false;
+
+ PMObject* tmp;
+ QPtrStack<PMObject> stack;
+
+ if( !m_sortedListUpToDate )
+ {
+ m_sortedSelectedObjects.clear( );
+
+ if( numObjects == 1 )
+ m_sortedSelectedObjects.append( m_selectedObjects.first( ) );
+ else if( numObjects > 1 )
+ {
+ tmp = m_pScene;
+ do
+ {
+ if( !tmp )
+ {
+ if( !stack.isEmpty( ) )
+ {
+ tmp = stack.pop( );
+ if( tmp == m_pScene )
+ stop = true;
+ else
+ tmp = tmp->nextSibling( );
+ }
+ else
+ stop = true;
+ }
+ else if( tmp->isSelected( ) )
+ {
+ m_sortedSelectedObjects.append( tmp );
+ numOrdered++;
+ tmp = tmp->nextSibling( );
+ }
+ else if( tmp->selectedChildren( ) > 0 )
+ {
+ stack.push( tmp );
+ tmp = tmp->firstChild( );
+ }
+ else
+ {
+ tmp = tmp->nextSibling( );
+ }
+ }
+ while( !stop && ( numOrdered < numObjects ) );
+ }
+ m_sortedListUpToDate = true;
+ }
+
+ return m_sortedSelectedObjects;
+}
+
+int PMPart::whereToInsert( PMObject* obj, const PMObjectList& list )
+{
+ // if you change this function, change
+ // whereToInsert( PMObject* obj, const QStringList& ), too
+
+ int canInsertAsFirstChild = 0;
+ int canInsertAsLastChild = 0;
+ int canInsertAsSibling = 0;
+
+ int insertAs = 0;
+ int insertPossibilities = 0;
+
+ if( !obj->isReadOnly( ) )
+ {
+ canInsertAsFirstChild = obj->canInsert( list, 0 );
+ if( obj->lastChild( ) )
+ canInsertAsLastChild = obj->canInsert( list, obj->lastChild( ) );
+
+ if( canInsertAsFirstChild > 0 )
+ {
+ // some objects can be inserted as child
+ insertAs |= PMInsertPopup::PMIFirstChild;
+ insertPossibilities++;
+ }
+ if( canInsertAsLastChild > 0 )
+ {
+ insertAs |= PMInsertPopup::PMILastChild;
+ insertPossibilities++;
+ }
+ }
+
+ if( obj->parent( ) )
+ {
+ PMObject* p = obj->parent( );
+ if( !p->isReadOnly( ) )
+ {
+ canInsertAsSibling = p->canInsert( list, obj );
+ if( canInsertAsSibling > 0 )
+ {
+ // some objects can be inserted as siblings
+ insertAs |= PMInsertPopup::PMISibling;
+ insertPossibilities++;
+ }
+ }
+ }
+
+ if( insertPossibilities > 1 )
+ {
+ int count = ( int ) list.count( );
+ // more than one possibilities, ask user
+ insertAs = PMInsertPopup::choosePlace(
+ widget( ), count > 1, insertAs,
+ canInsertAsFirstChild == count,
+ canInsertAsLastChild == count,
+ canInsertAsSibling == count );
+ }
+ else if( insertPossibilities == 0 )
+ insertAs = PMInsertPopup::PMIFirstChild;
+ return insertAs;
+}
+
+int PMPart::whereToInsert( PMObject* obj, const QStringList& list )
+{
+ // if you change this function, change
+ // whereToInsert( PMObject* obj, const PMObjectList ), too
+
+ int canInsertAsFirstChild = 0;
+ int canInsertAsLastChild = 0;
+ int canInsertAsSibling = 0;
+
+ int insertAs = 0;
+ int insertPossibilities = 0;
+
+ if( !obj->isReadOnly( ) )
+ {
+ canInsertAsFirstChild = obj->canInsert( list, 0 );
+ if( obj->lastChild( ) )
+ canInsertAsLastChild = obj->canInsert( list, obj->lastChild( ) );
+
+ if( canInsertAsFirstChild > 0 )
+ {
+ // some objects can be inserted as child
+ insertAs |= PMInsertPopup::PMIFirstChild;
+ insertPossibilities++;
+ }
+ if( canInsertAsLastChild > 0 )
+ {
+ insertAs |= PMInsertPopup::PMILastChild;
+ insertPossibilities++;
+ }
+ }
+
+ if( obj->parent( ) )
+ {
+ PMObject* p = obj->parent( );
+ if( !p->isReadOnly( ) )
+ {
+ canInsertAsSibling = p->canInsert( list, obj );
+ if( canInsertAsSibling > 0 )
+ {
+ // some objects can be inserted as siblings
+ insertAs |= PMInsertPopup::PMISibling;
+ insertPossibilities++;
+ }
+ }
+ }
+
+ if( insertPossibilities > 1 )
+ {
+ int count = ( int ) list.count( );
+ // more than one possibilities, ask user
+ insertAs = PMInsertPopup::choosePlace(
+ widget( ), count > 1, insertAs,
+ canInsertAsFirstChild == count,
+ canInsertAsLastChild == count,
+ canInsertAsSibling == count );
+ }
+ else if( insertPossibilities == 0 )
+ insertAs = PMInsertPopup::PMIFirstChild;
+ return insertAs;
+}
+
+int PMPart::whereToInsert( PMObject* obj )
+{
+ int insertAs = 0;
+ int insertPossibilities = 0;
+
+ if( obj->parent( ) )
+ {
+ insertAs |= PMInsertPopup::PMISibling;
+ insertPossibilities++;
+ }
+ if( obj->isA( "CompositeObject" ) )
+ {
+ insertAs |= PMInsertPopup::PMIFirstChild;
+ insertPossibilities++;
+ if( obj->firstChild( ) )
+ {
+ insertAs |= PMInsertPopup::PMILastChild;
+ insertPossibilities++;
+ }
+ }
+ if( insertAs && ( insertPossibilities > 1 ) )
+ insertAs = PMInsertPopup::choosePlace( widget( ), true, insertAs );
+
+ return insertAs;
+}
+
+void PMPart::slotFileImport( )
+{
+ QString fileName;
+ PMIOFormat* selectedFormat = 0;
+
+ fileName = PMFileDialog::getImportFileName( 0, this, selectedFormat );
+
+ if( !fileName.isEmpty( ) && selectedFormat )
+ {
+ QFile file( fileName );
+ if( file.open( IO_ReadOnly ) )
+ {
+ PMParser* newParser = selectedFormat->newParser( this, &file );
+ if( newParser )
+ {
+ if( m_pActiveObject )
+ insertFromParser( i18n( "Import %1" ).arg( selectedFormat->description( ) ),
+ newParser, m_pActiveObject );
+ else
+ insertFromParser( i18n( "Import %1" ).arg( selectedFormat->description( ) ),
+ newParser, m_pScene );
+ delete newParser;
+ }
+ }
+ else
+ {
+ KMessageBox::error( 0, tr( "Couldn't open the selected file\n"
+ "Permission denied!" ) );
+ }
+ }
+}
+
+void PMPart::slotFileExport( )
+{
+ emit aboutToSave( );
+
+ QString fileName, filter;
+ PMIOFormat* selectedFormat = 0;
+
+ fileName = PMFileDialog::getExportFileName( 0, this, selectedFormat, filter );
+
+ if( !fileName.isEmpty( ) && selectedFormat )
+ {
+ QByteArray baData;
+ QBuffer buffer( baData );
+ buffer.open( IO_WriteOnly );
+
+ PMSerializer* newSer = selectedFormat->newSerializer( &buffer );
+ if( newSer )
+ {
+ newSer->serialize( m_pScene );
+ newSer->close( );
+ bool success = !( newSer->warnings( ) || newSer->errors( ) );
+
+ if( !success )
+ {
+ // there were errors, display them
+ PMErrorDialog dlg( newSer->messages( ), newSer->errorFlags( ) );
+ // still try to export?
+ success = ( dlg.exec( ) == QDialog::Accepted );
+ }
+ if( success )
+ {
+ QFileInfo info( fileName );
+ if( info.extension( ).isEmpty( ) )
+ fileName += filter.right( filter.length( ) - 1 ); // remove '*'
+
+ QFile file( fileName );
+ if( file.open( IO_WriteOnly ) )
+ {
+ file.writeBlock( baData );
+ file.close( );
+ }
+ else
+ {
+ KMessageBox::error( 0, tr( "Couldn't export to the selected file\n"
+ "Permission denied!" ) );
+ }
+ }
+
+ delete newSer;
+ }
+ }
+}
+
+void PMPart::slotEditCut( )
+{
+ emit setStatusBarText( i18n( "Cutting selection..." ) );
+
+ const PMObjectList& sortedList = selectedObjects( );
+
+ if( sortedList.count( ) > 0 )
+ {
+ QApplication::clipboard( )->setData( new PMObjectDrag( this, sortedList ) );
+ removeSelection( i18n( "Cut" ) );
+ }
+
+ emit setStatusBarText( "" );
+}
+
+void PMPart::slotEditDelete( )
+{
+ emit setStatusBarText( i18n( "Deleting selection..." ) );
+
+ removeSelection( i18n( "Delete" ) );
+
+ emit setStatusBarText( "" );
+}
+
+void PMPart::slotEditCopy( )
+{
+ emit setStatusBarText( i18n( "Copying selection to clipboard..." ) );
+ const PMObjectList& sortedList = selectedObjects( );
+
+ if( sortedList.count( ) > 0 )
+ QApplication::clipboard( )->setData( new PMObjectDrag( this, sortedList ) );
+
+ emit setStatusBarText( "" );
+}
+
+bool PMPart::dragMoveSelectionTo( PMObject* obj )
+{
+ if( obj == 0 )
+ {
+ return removeSelection( i18n( "Drag" ) );
+ }
+ else
+ {
+ const PMObjectList& sortedList = selectedObjects( );
+ PMMoveCommand* command = 0;
+ int insertAs = whereToInsert( obj, sortedList );
+
+ if( insertAs > 0 )
+ {
+ PMObject* hlp;
+ bool stop;
+
+ switch( insertAs )
+ {
+ case PMInsertPopup::PMIFirstChild:
+ command = new PMMoveCommand( sortedList, obj, 0 );
+ break;
+ case PMInsertPopup::PMILastChild:
+ hlp = obj->lastChild( );
+ stop = false;
+
+ while( hlp && !stop )
+ {
+ if( hlp->isSelected( ) )
+ hlp = hlp->prevSibling( );
+ else
+ stop = true;
+ }
+ command = new PMMoveCommand( sortedList, obj, hlp );
+ break;
+ case PMInsertPopup::PMISibling:
+ command = new PMMoveCommand( sortedList, obj->parent( ), obj );
+ break;
+ }
+ }
+ if( command )
+ {
+ command->setText( i18n( "Drag" ) );
+ return executeCommand( command );
+ }
+ }
+ return false;
+}
+
+bool PMPart::removeSelection( const QString& type )
+{
+ PMDeleteCommand* cmd = 0;
+ const PMObjectList& sortedList = selectedObjects( );
+
+ if( sortedList.count( ) > 0 )
+ {
+ cmd = new PMDeleteCommand( sortedList );
+ cmd->setText( type );
+ return executeCommand( cmd );
+ }
+ return false;
+}
+
+bool PMPart::drop( PMObject* obj, QMimeSource* mime )
+{
+ return pasteOrDrop( i18n( "Drop" ), mime, obj );
+}
+
+void PMPart::slotEditPaste( )
+{
+ emit setStatusBarText( i18n( "Inserting clipboard contents..." ) );
+
+ pasteOrDrop( i18n( "Paste" ), qApp->clipboard( )->data( ),
+ m_pActiveObject );
+
+ emit setStatusBarText( "" );
+}
+
+bool PMPart::pasteOrDrop( const QString& type, QMimeSource* mime, PMObject* obj )
+{
+ bool success = false;
+
+ if( mime && obj)
+ {
+ PMParser* parser = PMObjectDrag::newParser( mime, this );
+
+ if( parser )
+ success = insertFromParser( type, parser, obj );
+ }
+ return success;
+}
+
+bool PMPart::insertFromParser( const QString& type, PMParser* parser,
+ PMObject* obj )
+{
+ PMObjectList list;
+ bool success = true;
+ int insertAs = 0;
+ PMAddCommand* command = 0;
+
+ // try to parse
+ if( parser->canQuickParse( ) )
+ {
+ QStringList types;
+ parser->quickParse( types );
+
+ success = !( parser->warnings( ) || parser->errors( ) );
+
+ if( !success )
+ {
+ // there were errors, display them
+ PMErrorDialog dlg( parser->messages( ), parser->errorFlags( ) );
+ // still try to insert the correct parsed objects?
+ success = ( dlg.exec( ) == QDialog::Accepted );
+ }
+ if( success && ( types.count( ) > 0 ) )
+ insertAs = whereToInsert( obj, types );
+ }
+ else
+ insertAs = whereToInsert( obj );
+
+ if( success && insertAs )
+ {
+ PMObject* parent = 0;
+ PMObject* after = 0;
+
+ switch( insertAs )
+ {
+ case PMInsertPopup::PMIFirstChild:
+ parent = obj;
+ after = 0;
+ break;
+ case PMInsertPopup::PMILastChild:
+ parent = obj;
+ after = obj->lastChild( );
+ break;
+ case PMInsertPopup::PMISibling:
+ parent = obj->parent( );
+ after = obj;
+ break;
+ default:
+ parent = obj;
+ after = 0;
+ break;
+ }
+
+ parser->parse( &list, parent, after );
+ success = !( parser->warnings( ) || parser->errors( ) );
+
+ if( !success )
+ {
+ // there were errors, display them
+ PMErrorDialog dlg( parser->messages( ), parser->errorFlags( ) );
+ // still try to insert the correct parsed objects?
+ success = ( dlg.exec( ) == QDialog::Accepted );
+ }
+
+ if( list.count( ) > 0 )
+ {
+ if( success )
+ {
+ // parsing was successful
+ command = new PMAddCommand( list, parent, after );
+
+ command->setText( type );
+ success = executeCommand( command );
+ }
+ else
+ {
+ // parsed objects will not be inserted
+ // remove all links
+ PMObjectListIterator it( list );
+ PMDeclare* decl = 0;
+
+ for( ; it.current( ); ++it )
+ {
+ PMRecursiveObjectIterator rit( it.current( ) );
+ for( ; rit.current( ); ++rit )
+ {
+ decl = rit.current( )->linkedObject( );
+ if( decl )
+ decl->removeLinkedObject( rit.current( ) );
+ }
+ }
+ }
+ }
+ }
+ if( !command )
+ {
+ // delete all parsed objects
+ list.setAutoDelete( true );
+ list.clear( );
+ }
+
+ return success && insertAs;
+}
+
+void PMPart::slotEditUndo( )
+{
+ emit setStatusBarText( i18n( "Undo last change..." ) );
+ m_pNewSelection = 0;
+ m_updateNewObjectActions = false;
+
+ m_commandManager.undo( );
+
+ if( m_pNewSelection )
+ slotObjectChanged( m_pNewSelection, PMCNewSelection, this );
+ if( !isModified( ) )
+ setModified( true );
+ if( m_updateNewObjectActions )
+ updateNewObjectActions( );
+
+ emit setStatusBarText( "" );
+}
+
+void PMPart::slotEditRedo( )
+{
+ emit setStatusBarText( i18n( "Redo last change..." ) );
+ m_pNewSelection = 0;
+ m_updateNewObjectActions = false;
+
+ m_commandManager.redo( );
+ if( m_pNewSelection )
+ slotObjectChanged( m_pNewSelection, PMCNewSelection, this );
+ if( !isModified( ) )
+ setModified( true );
+ if( m_updateNewObjectActions )
+ updateNewObjectActions( );
+
+ emit setStatusBarText( "" );
+}
+
+bool PMPart::executeCommand( PMCommand* cmd )
+{
+ m_pNewSelection = 0;
+ m_numAddedObjects = 0;
+ m_numInsertErrors = 0;
+ m_insertErrorDetails.clear( );
+ m_updateNewObjectActions = false;
+
+ if( isReadWrite( ) && cmd )
+ {
+ bool execute = true;
+ int flags = cmd->errorFlags( this );
+
+ if( flags )
+ {
+ PMErrorDialog dlg( cmd->messages( ), flags );
+ execute = ( dlg.exec( ) == QDialog::Accepted );
+ }
+
+ if( execute )
+ {
+ m_commandManager.execute( cmd );
+ if( m_pNewSelection )
+ slotObjectChanged( m_pNewSelection, PMCNewSelection, this );
+ if( !isModified( ) )
+ setModified( true );
+
+ if( m_numInsertErrors > 0 )
+ {
+ m_insertErrorDetails.sort( );
+ PMInsertErrorDialog dlg( m_numAddedObjects, m_numInsertErrors,
+ m_insertErrorDetails );
+ dlg.exec( );
+ }
+ if( m_updateNewObjectActions )
+ updateNewObjectActions( );
+
+ return true;
+ }
+ }
+
+ delete cmd;
+ return false;
+}
+
+void PMPart::slotObjectChanged( PMObject* obj, const int m,
+ QObject* sender )
+{
+ int mode = m;
+ bool selectionChanged = false;
+ bool changeControlPoints = false;
+ PMObject* oldActive = m_pActiveObject;
+
+ if( mode & PMCNewSelection )
+ {
+ if( !obj )
+ {
+ clearSelection( );
+ selectionChanged = true;
+ m_pActiveObject = 0;
+ }
+ else
+ {
+ clearSelection( );
+ obj->setSelected( true );
+ m_selectedObjects.append( obj );
+ selectionChanged = true;
+ m_pActiveObject = obj;
+ }
+ }
+ else if( ( mode & PMCSelected ) && !obj->isSelected( ) )
+ {
+ if( obj->isSelectable( ) )
+ {
+ if( obj->selectedChildren( ) > 0 )
+ {
+ QPtrStack<PMObject> stack;
+ PMObject* tmp = obj->firstChild( );
+ bool stop = false;
+
+ do
+ {
+ if( !tmp )
+ {
+ if( !stack.isEmpty( ) )
+ {
+ tmp = stack.pop( );
+ if( tmp == obj )
+ stop = true;
+ else
+ tmp = tmp->nextSibling( );
+ }
+ else
+ stop = true;
+ }
+ else if( tmp->isSelected( ) )
+ {
+ tmp->setSelected( false );
+ m_selectedObjects.removeRef( tmp );
+ emit objectChanged( tmp, PMCDeselected, this );
+ tmp = tmp->nextSibling( );
+ }
+ else if( tmp->selectedChildren( ) > 0 )
+ {
+ stack.push( tmp );
+ tmp = tmp->firstChild( );
+ }
+ else
+ {
+ tmp = tmp->nextSibling( );
+ }
+ }
+ while( !stop );
+ }
+
+ obj->setSelected( true );
+ m_selectedObjects.append( obj );
+ selectionChanged = true;
+ m_sortedListUpToDate = false;
+ m_sortedSelectedObjects.clear( );
+ m_pActiveObject = 0;
+ }
+ else
+ {
+ kdError( PMArea ) << "(PMPart::slotObjectChanged) object is not selectable!" << "\n";
+ mode = mode & ( ~( PMCSelected | PMCNewSelection ) );
+ }
+ }
+ else if( mode & PMCDeselected )
+ {
+ // no problems here
+ m_selectedObjects.removeRef( obj );
+ obj->setSelected( false );
+ m_sortedListUpToDate = false;
+ m_sortedSelectedObjects.clear( );
+ selectionChanged = true;
+ m_pActiveObject = 0;
+ }
+
+ if( mode & PMCRemove )
+ {
+ if( obj->parent( ) )
+ if( obj->parent( ) == m_pActiveObject )
+ m_updateNewObjectActions = true;
+ if( m_pNewSelection == obj )
+ {
+ if( obj->nextSibling( ) )
+ m_pNewSelection = obj->nextSibling( );
+ else if( obj->prevSibling( ) )
+ m_pNewSelection = obj->nextSibling( );
+ else if( obj->parent( ) )
+ m_pNewSelection = obj->parent( );
+ else
+ m_pNewSelection = 0;
+ }
+ if( m_selectedObjects.containsRef( obj ) )
+ {
+ m_selectedObjects.removeRef( obj );
+ if( m_selectedObjects.isEmpty( ) )
+ {
+ if( obj->nextSibling( ) )
+ m_pNewSelection = obj->nextSibling( );
+ else if( obj->prevSibling( ) )
+ m_pNewSelection = obj->prevSibling( );
+ else if( obj->parent( ) )
+ m_pNewSelection = obj->parent( );
+ else
+ m_pNewSelection = 0;
+ }
+ m_sortedListUpToDate = false;
+ m_sortedSelectedObjects.clear( );
+ selectionChanged = true;
+ }
+ if( m_pActiveObject == obj )
+ m_pActiveObject = 0;
+
+ if( obj->isA( "Declare" ) )
+ {
+ PMDeclare* decl = ( PMDeclare* ) obj;
+ m_pSymbolTable->remove( decl->id( ) );
+ }
+
+ if( obj->type( ) == "Camera" )
+ m_cameras.removeRef( ( PMCamera* ) obj );
+ }
+
+ if( mode & PMCAdd )
+ {
+ if( !( mode & PMCInsertError ) )
+ {
+ m_pNewSelection = obj;
+ if( obj->isA( "Declare" ) )
+ {
+ PMDeclare* decl = ( PMDeclare* ) obj;
+ PMSymbol* s = m_pSymbolTable->find( decl->id( ) );
+ if( !s )
+ m_pSymbolTable->insert( decl->id( ),
+ new PMSymbol( decl->id( ), decl ) );
+ }
+ if( obj->type( ) == "Camera" )
+ m_bCameraListUpToDate = false;
+ }
+ if( obj->parent( ) )
+ if( obj->parent( ) == m_pActiveObject )
+ m_updateNewObjectActions = true;
+ m_numAddedObjects++;
+ }
+
+ if( mode & PMCData )
+ {
+ m_updateNewObjectActions = true;
+ }
+
+ if( mode & PMCViewStructure )
+ {
+ changeControlPoints = true;
+ }
+
+ if( mode & PMCInsertError )
+ {
+ m_numInsertErrors++;
+ QString detail;
+ detail = obj->description( ) + QString( " " ) + obj->name( );
+ m_insertErrorDetails.append( detail );
+
+ if( obj->isA( "Declare" ) )
+ {
+ PMDeclare* decl = ( PMDeclare* ) obj;
+ m_pSymbolTable->remove( decl->id( ) );
+ }
+ }
+
+ if( selectionChanged )
+ {
+ m_sortedListUpToDate = false;
+ m_sortedSelectedObjects.clear( );
+
+ int c = m_selectedObjects.count( );
+
+ if( m_pScene->isSelected( ) )
+ c = m_pScene->countChildren( );
+
+ m_pCopyAction->setEnabled( c > 0 );
+
+ if( isReadWrite( ) )
+ {
+ m_pCutAction->setEnabled( c > 0 );
+ m_pDeleteAction->setEnabled( c > 0 );
+ m_pPasteAction->setEnabled( m_pActiveObject && m_canDecode );
+ updateNewObjectActions( );
+ }
+ }
+
+ if( ( oldActive != m_pActiveObject ) || changeControlPoints )
+ {
+ updateControlPoints( oldActive );
+ emit objectChanged( m_pActiveObject, PMCNewControlPoints, this );
+ mode |= ( PMCNewControlPoints | PMCControlPointSelection );
+ }
+
+ emit objectChanged( obj, mode, sender );
+}
+
+void PMPart::slotIDChanged( PMObject* obj, const QString& oldID )
+{
+ if( obj->isA( "Declare" ) )
+ {
+ PMDeclare* d = ( PMDeclare* ) obj;
+ PMSymbol* s = m_pSymbolTable->find( oldID );
+ if( s )
+ {
+ if( s->type( ) == PMSymbol::Object )
+ {
+ if( s->object( ) == obj )
+ {
+ m_pSymbolTable->take( oldID );
+ s->setId( d->id( ) );
+ m_pSymbolTable->insert( s->id( ), s );
+ }
+ else
+ kdError( PMArea ) << "PMPart::slotIDChanged: Symbol "
+ << oldID << " points to wrong object.\n";
+ }
+ else
+ kdError( PMArea ) << "PMPart::slotIDChanged: Symbol "
+ << oldID << " has wrong type.\n";
+ }
+ else
+ kdError( PMArea ) << "PMPart::slotIDChanged: Symbol "
+ << oldID << " not found.\n";
+ }
+}
+
+void PMPart::slotNewObject( PMObject* newObject, int insertAs )
+{
+ PMObjectList list;
+ list.append( newObject );
+ PMCommand* command = 0;
+
+ if( m_pActiveObject )
+ {
+ // If no position was specified ask the user
+ if( insertAs <= 0 )
+ insertAs = whereToInsert( m_pActiveObject, list );
+ // If either through a parameter or by user action a position was selected
+ if( insertAs > 0 )
+ {
+ // insert the object in the position indicated
+ switch( insertAs )
+ {
+ case PMInsertPopup::PMIFirstChild:
+ command = new PMAddCommand( list, m_pActiveObject, 0 );
+ break;
+ case PMInsertPopup::PMILastChild:
+ command = new PMAddCommand( list, m_pActiveObject,
+ m_pActiveObject->lastChild( ) );
+ break;
+ case PMInsertPopup::PMISibling:
+ command = new PMAddCommand( list,
+ m_pActiveObject->parent( ),
+ m_pActiveObject );
+ break;
+ default:
+ command = new PMAddCommand( list, m_pActiveObject, 0 );
+ break;
+ }
+ executeCommand( command );
+ }
+ else
+ {
+ list.clear( );
+ delete newObject;
+ }
+ }
+ else
+ {
+ list.clear( );
+ delete newObject;
+ }
+}
+
+void PMPart::slotNewObject( const QString& type )
+{
+ PMObject* newObject = m_pPrototypeManager->newObject( type );
+ if( newObject )
+ slotNewObject( newObject );
+}
+
+void PMPart::slotNewObject( const QString& type, const QString& pos )
+{
+ PMObject* newObject = m_pPrototypeManager->newObject( type );
+ if( newObject )
+ {
+ if( pos == "FirstChild" )
+ slotNewObject( newObject, PMInsertPopup::PMIFirstChild );
+ else if( pos == "LastChild" )
+ slotNewObject( newObject, PMInsertPopup::PMILastChild );
+ else if( pos == "Sibling" )
+ slotNewObject( newObject, PMInsertPopup::PMISibling );
+ else
+ slotNewObject( newObject );
+ }
+}
+
+QStringList PMPart::getObjectTypes( )
+{
+ QStringList result;
+ QPtrListIterator<PMMetaObject> it = m_pPrototypeManager->prototypeIterator( );
+
+ for( ; it.current( ); ++it )
+ {
+ result.append( it.current( )->className( ) );
+ }
+ return result;
+}
+
+void PMPart::slotNewTransformedObject( PMObject* o )
+{
+ if( o )
+ {
+ if( o->canInsert( QString( "Scale" ), o->lastChild( ) ) )
+ o->appendChild( new PMScale( this ) );
+ if( o->canInsert( QString( "Rotate" ), o->lastChild( ) ) )
+ o->appendChild( new PMRotate( this ) );
+ if( o->canInsert( QString( "Translate" ), o->lastChild( ) ) )
+ o->appendChild( new PMTranslate( this ) );
+ slotNewObject( o );
+ }
+}
+
+void PMPart::slotNewGlobalSettings( )
+{
+ slotNewObject( new PMGlobalSettings( this ) );
+}
+
+void PMPart::slotNewSkySphere( )
+{
+ slotNewObject( new PMSkySphere( this ) );
+}
+
+void PMPart::slotNewRainbow( )
+{
+ slotNewObject( new PMRainbow( this ) );
+}
+
+void PMPart::slotNewFog( )
+{
+ slotNewObject( new PMFog( this ) );
+}
+
+void PMPart::slotNewInterior( )
+{
+ slotNewObject( new PMInterior( this ) );
+}
+
+void PMPart::slotNewMedia( )
+{
+ slotNewObject( new PMMedia( this ) );
+}
+
+void PMPart::slotNewDensity( )
+{
+ slotNewObject( new PMDensity( this ) );
+}
+
+void PMPart::slotNewMaterial( )
+{
+ slotNewObject( new PMMaterial( this ) );
+}
+
+void PMPart::slotNewBox( )
+{
+ slotNewTransformedObject( new PMBox( this ) );
+}
+
+void PMPart::slotNewSphere( )
+{
+ slotNewTransformedObject( new PMSphere( this ) );
+}
+
+void PMPart::slotNewCylinder( )
+{
+ slotNewTransformedObject( new PMCylinder( this ) );
+}
+
+void PMPart::slotNewPlane( )
+{
+ slotNewTransformedObject( new PMPlane( this ) );
+}
+
+void PMPart::slotNewPolynom( )
+{
+ slotNewTransformedObject( new PMPolynom( this ) );
+}
+
+void PMPart::slotNewCone( )
+{
+ slotNewTransformedObject( new PMCone( this ) );
+}
+
+void PMPart::slotNewTorus( )
+{
+ slotNewTransformedObject( new PMTorus( this ) );
+}
+
+void PMPart::slotNewLathe( )
+{
+ slotNewTransformedObject( new PMLathe( this ) );
+}
+
+void PMPart::slotNewPrism( )
+{
+ slotNewTransformedObject( new PMPrism( this ) );
+}
+
+void PMPart::slotNewSurfaceOfRevolution( )
+{
+ slotNewTransformedObject( new PMSurfaceOfRevolution( this ) );
+}
+
+void PMPart::slotNewSuperquadricEllipsoid( )
+{
+ slotNewTransformedObject( new PMSuperquadricEllipsoid( this ) );
+}
+
+void PMPart::slotNewJuliaFractal( )
+{
+ slotNewTransformedObject( new PMJuliaFractal( this ) );
+}
+
+void PMPart::slotNewHeightField( )
+{
+ slotNewTransformedObject( new PMHeightField( this ) );
+}
+
+void PMPart::slotNewText( )
+{
+ slotNewTransformedObject( new PMText( this ) );
+}
+
+void PMPart::slotNewBlob( )
+{
+ slotNewTransformedObject( new PMBlob( this ) );
+}
+
+void PMPart::slotNewBlobSphere( )
+{
+ slotNewObject( new PMBlobSphere( this ) );
+}
+
+void PMPart::slotNewBlobCylinder( )
+{
+ slotNewObject( new PMBlobCylinder( this ) );
+}
+
+void PMPart::slotNewDeclare( )
+{
+ PMDeclare* obj = new PMDeclare( this );
+ m_pSymbolTable->findNewID( i18n( "Declare" ), obj );
+ slotNewObject( obj );
+}
+
+void PMPart::slotNewObjectLink( )
+{
+ slotNewTransformedObject( new PMObjectLink( this ) );
+}
+
+void PMPart::slotNewUnion( )
+{
+ slotNewObject( new PMCSG( this, PMCSG::CSGUnion ) );
+}
+
+void PMPart::slotNewDifference( )
+{
+ slotNewObject( new PMCSG( this, PMCSG::CSGDifference ) );
+}
+
+void PMPart::slotNewIntersection( )
+{
+ slotNewObject( new PMCSG( this, PMCSG::CSGIntersection ) );
+}
+
+void PMPart::slotNewMerge( )
+{
+ slotNewObject( new PMCSG( this, PMCSG::CSGMerge ) );
+}
+
+void PMPart::slotNewBoundedBy( )
+{
+ slotNewObject( new PMBoundedBy( this ) );
+}
+
+void PMPart::slotNewClippedBy( )
+{
+ slotNewObject( new PMClippedBy( this ) );
+}
+
+void PMPart::slotNewLight( )
+{
+ slotNewObject( new PMLight( this ) );
+}
+
+void PMPart::slotNewLooksLike( )
+{
+ slotNewObject( new PMLooksLike( this ) );
+}
+
+void PMPart::slotNewProjectedThrough( )
+{
+ slotNewObject( new PMProjectedThrough( this ) );
+}
+
+void PMPart::slotNewDisc( )
+{
+ slotNewTransformedObject( new PMDisc( this ) );
+}
+
+void PMPart::slotNewBicubicPatch( )
+{
+ slotNewTransformedObject( new PMBicubicPatch( this ) );
+}
+
+void PMPart::slotNewTriangle( )
+{
+ slotNewObject( new PMTriangle( this ) );
+}
+
+void PMPart::slotNewCamera( )
+{
+ PMCamera* c = new PMCamera( this );
+ c->setAngle( 45.0 );
+ c->setLocation( PMVector( 5.0, 5.0, -5.0 ) );
+ c->setLookAt( PMVector( 0.0, 0.0, 0.0 ) );
+
+ slotNewObject( c );
+}
+
+void PMPart::slotNewTexture( )
+{
+ slotNewObject( new PMTexture( this ) );
+}
+
+void PMPart::slotNewPigment( )
+{
+ slotNewObject( new PMPigment( this ) );
+}
+
+void PMPart::slotNewNormal( )
+{
+ slotNewObject( new PMNormal( this ) );
+}
+
+void PMPart::slotNewSolidColor( )
+{
+ slotNewObject( new PMSolidColor( this ) );
+}
+
+void PMPart::slotNewTextureList( )
+{
+ slotNewObject( new PMTextureList( this ) );
+}
+
+void PMPart::slotNewColorList( )
+{
+ slotNewObject( new PMColorList( this ) );
+}
+
+void PMPart::slotNewPigmentList( )
+{
+ slotNewObject( new PMPigmentList( this ) );
+}
+
+void PMPart::slotNewNormalList( )
+{
+ slotNewObject( new PMNormalList( this ) );
+}
+
+void PMPart::slotNewDensityList( )
+{
+ slotNewObject( new PMDensityList( this ) );
+}
+
+void PMPart::slotNewFinish( )
+{
+ slotNewObject( new PMFinish( this ) );
+}
+
+void PMPart::slotNewWarp( )
+{
+ slotNewObject( new PMWarp( this ) );
+}
+
+void PMPart::slotNewImageMap( )
+{
+ slotNewObject( new PMImageMap( this ) );
+}
+
+void PMPart::slotNewPattern( )
+{
+ slotNewObject( new PMPattern( this ) );
+}
+
+void PMPart::slotNewBlendMapModifiers( )
+{
+ slotNewObject( new PMBlendMapModifiers( this ) );
+}
+
+void PMPart::slotNewTextureMap( )
+{
+ slotNewObject( new PMTextureMap( this ) );
+}
+
+void PMPart::slotNewMaterialMap( )
+{
+ slotNewObject( new PMMaterialMap( this ) );
+}
+
+void PMPart::slotNewColorMap( )
+{
+ slotNewObject( new PMColorMap( this ) );
+}
+
+void PMPart::slotNewPigmentMap( )
+{
+ slotNewObject( new PMPigmentMap( this ) );
+}
+
+void PMPart::slotNewNormalMap( )
+{
+ slotNewObject( new PMNormalMap( this ) );
+}
+
+void PMPart::slotNewBumpMap( )
+{
+ slotNewObject( new PMBumpMap( this ) );
+}
+
+void PMPart::slotNewSlopeMap( )
+{
+ slotNewObject( new PMSlopeMap( this ) );
+}
+
+void PMPart::slotNewDensityMap( )
+{
+ slotNewObject( new PMDensityMap( this ) );
+}
+
+void PMPart::slotNewSlope( )
+{
+ slotNewObject( new PMSlope( this ) );
+}
+
+void PMPart::slotNewQuickColor( )
+{
+ slotNewObject( new PMQuickColor( this ) );
+}
+
+void PMPart::slotNewTranslate( )
+{
+ slotNewObject( new PMTranslate( this ) );
+}
+
+void PMPart::slotNewScale( )
+{
+ slotNewObject( new PMScale( this ) );
+}
+
+void PMPart::slotNewRotate( )
+{
+ slotNewObject( new PMRotate( this ) );
+}
+
+void PMPart::slotNewMatrix( )
+{
+ slotNewObject( new PMPovrayMatrix( this ) );
+}
+
+void PMPart::slotNewComment( )
+{
+ slotNewObject( new PMComment( this ) );
+}
+
+void PMPart::slotNewRaw( )
+{
+ slotNewObject( new PMRaw( this ) );
+}
+
+// POV-Ray 3.5 objects
+
+void PMPart::slotNewIsoSurface( )
+{
+ slotNewObject( new PMIsoSurface( this ) );
+}
+
+void PMPart::slotNewRadiosity( )
+{
+ slotNewObject( new PMRadiosity( this ) );
+}
+
+void PMPart::slotNewGlobalPhotons( )
+{
+ slotNewObject( new PMGlobalPhotons( this ) );
+}
+
+void PMPart::slotNewPhotons( )
+{
+ slotNewObject( new PMPhotons( this ) );
+}
+
+void PMPart::slotNewLightGroup( )
+{
+ slotNewObject( new PMLightGroup( this ) );
+}
+
+void PMPart::slotNewInteriorTexture( )
+{
+ slotNewObject( new PMInteriorTexture( this ) );
+}
+
+void PMPart::slotNewSphereSweep( )
+{
+ slotNewObject( new PMSphereSweep( this ) );
+}
+
+void PMPart::slotNewMesh( )
+{
+ slotNewObject( new PMMesh( this ) );
+}
+
+void PMPart::slotSearchLibraryObject( )
+{
+ PMLibraryObjectSearch* aux = new PMLibraryObjectSearch( NULL );
+ aux->show( );
+}
+
+void PMPart::slotClipboardDataChanged( )
+{
+ if( isReadWrite( ) )
+ {
+ m_canDecode = PMObjectDrag::canDecode( qApp->clipboard( )->data( ), this );
+ m_pPasteAction->setEnabled( m_canDecode && m_pActiveObject );
+ }
+ else
+ m_pPasteAction->setEnabled( false );
+}
+
+void PMPart::clearSelection( )
+{
+ PMObjectListIterator it( m_selectedObjects );
+
+ if( it.current( ) )
+ {
+ if( it.current( )->nextSibling( ) )
+ m_pNewSelection = it.current( )->nextSibling( );
+ else if( it.current( )->prevSibling( ) )
+ m_pNewSelection = it.current( )->prevSibling( );
+ else if( it.current( )->parent( ) )
+ m_pNewSelection = it.current( )->parent( );
+
+ for( ; it.current( ); ++it )
+ {
+ it.current( )->setSelected( false );
+ if( m_pNewSelection == it.current( ) )
+ {
+ if( it.current( )->nextSibling( ) )
+ m_pNewSelection = it.current( )->nextSibling( );
+ else if( it.current( )->prevSibling( ) )
+ m_pNewSelection = it.current( )->prevSibling( );
+ else if( it.current( )->parent( ) )
+ m_pNewSelection = it.current( )->parent( );
+ }
+ }
+ }
+
+ m_selectedObjects.clear( );
+ m_sortedListUpToDate = true;
+}
+
+bool PMPart::newDocument( )
+{
+ deleteContents( );
+ setModified( false );
+
+ m_pScene = new PMScene( this );
+
+ PMGlobalSettings* gs = new PMGlobalSettings( this );
+ gs->setAssumedGamma( 1.5 );
+ m_pScene->appendChild( gs );
+
+ PMBox* b = new PMBox( this );
+ m_pScene->appendChild( b );
+ PMPigment* p = new PMPigment( this );
+ b->appendChild( p );
+ PMSolidColor* c = new PMSolidColor( this );
+ c->setColor( PMColor( 0.3, 1.0, 0.3 ) );
+ p->appendChild( c );
+ PMScale* s = new PMScale( this );
+ b->appendChild( s );
+ PMRotate* r = new PMRotate( this );
+ b->appendChild( r );
+ PMTranslate* t = new PMTranslate( this );
+ t->setTranslation( PMVector( 0, 0.5, 0 ) );
+ b->appendChild( t );
+
+ PMLight* l = new PMLight( this );
+ l->setLocation( PMVector( 4.0, 5.0, -5.0 ) );
+ m_pScene->appendChild( l );
+ PMCamera* ca = new PMCamera( this );
+ ca->setAngle( 45.0 );
+ ca->setLocation( PMVector( 5.0, 5.0, -5.0 ) );
+ ca->setLookAt( PMVector( 0.0, 0.0, 0.0 ) );
+ m_pScene->appendChild( ca );
+ m_bCameraListUpToDate = false;
+
+ m_pScene->setReadOnly( !isReadWrite( ) );
+ PMRenderMode* mode = new PMRenderMode( );
+ mode->setDescription( i18n( "Default" ) );
+ m_pScene->renderModes( )->append( mode );
+
+ emit refresh( );
+ updateRenderModes( );
+ updateVisibilityLevel( );
+ slotObjectChanged( m_pScene, PMCNewSelection, this );
+
+ return true;
+}
+
+void PMPart::closeDocument( )
+{
+ m_url = KURL( );
+}
+
+void PMPart::deleteContents( )
+{
+ emit clear( );
+ if( isReadWrite( ) )
+ m_commandManager.clear( );
+ m_selectedObjects.clear( );
+ m_sortedSelectedObjects.clear( );
+ m_sortedListUpToDate = true;
+ m_pActiveObject = 0;
+ m_pNewSelection = 0;
+
+ if( m_pScene )
+ {
+ delete m_pScene;
+ m_pScene = 0;
+ }
+ if( m_pSymbolTable )
+ delete m_pSymbolTable;
+
+ m_pSymbolTable = new PMSymbolTable( );
+ m_cameras.clear( );
+ m_bCameraListUpToDate = true;
+}
+
+void PMPart::slotUpdateUndoRedo( const QString& undo, const QString& redo )
+{
+ if( isReadWrite( ) )
+ {
+ if( m_pUndoAction )
+ {
+ if( undo.isNull( ) )
+ {
+ m_pUndoAction->setText( i18n( "Undo" ) );
+ m_pUndoAction->setEnabled( false );
+ }
+ else
+ {
+ m_pUndoAction->setText( i18n( "Undo" ) + " " + undo );
+ m_pUndoAction->setEnabled( true );
+ }
+ }
+ if( m_pRedoAction )
+ {
+ if( redo.isNull( ) )
+ {
+ m_pRedoAction->setText( i18n( "Redo" ) );
+ m_pRedoAction->setEnabled( false );
+ }
+ else
+ {
+ m_pRedoAction->setText( i18n( "Redo" ) + " " + redo );
+ m_pRedoAction->setEnabled( true );
+ }
+ }
+ }
+}
+
+void PMPart::setScene( PMScene* scene )
+{
+ deleteContents( );
+ m_pScene = scene;
+ emit refresh( );
+ slotObjectChanged( m_pScene, PMCNewSelection, this );
+}
+
+void PMPart::setModified( )
+{
+ KParts::ReadWritePart::setModified( );
+ emit modified( );
+}
+
+void PMPart::setModified( bool m )
+{
+ KParts::ReadWritePart::setModified( m );
+ emit modified( );
+}
+
+PMCamera* PMPart::firstCamera( )
+{
+ if( !m_bCameraListUpToDate )
+ updateCameraList( );
+ return m_cameras.first( );
+}
+
+QPtrListIterator<PMCamera> PMPart::cameras( )
+{
+ if( !m_bCameraListUpToDate )
+ updateCameraList( );
+ return QPtrListIterator<PMCamera>( m_cameras );
+}
+
+void PMPart::updateCameraList( )
+{
+ m_cameras.clear( );
+ PMObject* obj;
+ for( obj = m_pScene->firstChild( ); obj; obj = obj->nextSibling( ) )
+ if( obj->type( ) == "Camera" )
+ m_cameras.append( ( PMCamera* ) obj );
+ m_bCameraListUpToDate = true;
+}
+
+void PMPart::slotRender( )
+{
+ PMRenderMode* m = m_pScene->renderModes( )->current( );
+ if( m )
+ {
+ emit aboutToRender( );
+
+ QByteArray a;
+ QBuffer buffer( a );
+ buffer.open( IO_WriteOnly );
+ PMPovray35Format format;
+ PMSerializer* dev = format.newSerializer( &buffer );
+ dev->serialize( m_pScene );
+ delete dev;
+
+ if( !m_pPovrayWidget )
+ m_pPovrayWidget = new PMPovrayWidget( );
+ if( m_pPovrayWidget->render( a, *m, url( ) ) )
+ {
+ m_pPovrayWidget->show( );
+ m_pPovrayWidget->raise( );
+ }
+ }
+}
+
+void PMPart::slotRenderSettings( )
+{
+ PMRenderModesDialog dlg( m_pScene->renderModes( ), widget( ) );
+ int result = dlg.exec( );
+
+ if( result == QDialog::Accepted )
+ {
+ if( isReadWrite( ) )
+ setModified( true );
+ updateRenderModes( );
+ }
+}
+
+void PMPart::slotViewRenderWindow( )
+{
+ if( !m_pPovrayWidget )
+ m_pPovrayWidget = new PMPovrayWidget( );
+ m_pPovrayWidget->show( );
+ m_pPovrayWidget->raise( );
+}
+
+void PMPart::slotRenderMode( int index )
+{
+ PMRenderModeList* list = m_pScene->renderModes( );
+ list->at( index );
+ emit activeRenderModeChanged( );
+}
+
+void PMPart::updateRenderModes( )
+{
+ if( m_pScene )
+ {
+ PMRenderModeList* list = m_pScene->renderModes( );
+ PMRenderModeListIterator it( *list );
+
+ QComboBox* box = m_pRenderComboAction->combo( );
+ if( box )
+ {
+ bool b = box->signalsBlocked( );
+ box->blockSignals( true );
+ box->clear( );
+
+ for( ; it.current( ); ++it )
+ box->insertItem( it.current( )->description( ) );
+ box->setCurrentItem( list->at( ) );
+ box->updateGeometry( );
+
+ box->blockSignals( b );
+ }
+ emit activeRenderModeChanged( );
+ }
+}
+
+void PMPart::slotRenderModeActionPlugged( )
+{
+ updateRenderModes( );
+// connect( m_pRenderComboAction->combo( ), SIGNAL( activated( int ) ),
+// SLOT( slotRenderMode( int ) ) );
+}
+
+void PMPart::slotVisibilityLevelChanged( int l )
+{
+ if( m_pScene->visibilityLevel( ) != l )
+ {
+ m_pScene->setVisibilityLevel( l );
+ if( isReadWrite( ) )
+ setModified( true );
+ emit objectChanged( m_pScene, PMCViewStructure, this );
+ }
+}
+
+void PMPart::slotVisibilityActionPlugged( )
+{
+ if( m_pVisibilityLevelAction )
+ {
+ QSpinBox* box = m_pVisibilityLevelAction->spinBox( );
+ if( box )
+ {
+ box->setMinValue( -1000 );
+ box->setMaxValue( 1000 );
+ updateVisibilityLevel( );
+ }
+ }
+}
+
+void PMPart::updateVisibilityLevel( )
+{
+ if( m_pVisibilityLevelAction )
+ {
+ QSpinBox* box = m_pVisibilityLevelAction->spinBox( );
+ if( box && m_pScene )
+ {
+ bool sb = box->signalsBlocked( );
+ box->blockSignals( true );
+ box->setValue( m_pScene->visibilityLevel( ) );
+ box->blockSignals( sb );
+ }
+ }
+}
+
+void PMPart::slotGlobalDetailLevelChanged( int level )
+{
+ PMDetailObject::setGlobalDetailLevel( level + 1 );
+ emit objectChanged( m_pScene, PMCViewStructure, this );
+}
+
+void PMPart::updateControlPoints( PMObject* oldActive )
+{
+ PMControlPointList newCPs;
+
+ if( m_pActiveObject )
+ {
+ m_pActiveObject->controlPoints( newCPs );
+
+ if( m_pActiveObject == oldActive )
+ {
+ // check if the control points are the same
+ bool same = true;
+ PMControlPointListIterator oit( m_controlPoints );
+ PMControlPointListIterator nit( newCPs );
+ while( same && oit.current( ) && nit.current( ) )
+ {
+ if( oit.current( )->id( ) != nit.current( )->id( ) )
+ same = false;
+ ++oit;
+ ++nit;
+ }
+ if( oit.current( ) || nit.current( ) )
+ same = false;
+ if( same )
+ {
+ // set the old selection
+ oit.toFirst( );
+ nit.toFirst( );
+ while( oit.current( ) && nit.current( ) )
+ {
+ nit.current( )->setSelected( oit.current( )->selected( ) );
+ ++oit;
+ ++nit;
+ }
+ }
+ }
+ }
+
+ m_controlPoints.clear( );
+ m_controlPoints = newCPs;
+
+}
+
+void PMPart::slotAboutToSave( )
+{
+ emit aboutToSave( );
+}
+
+#include "pmpart.moc"
generated by cgit v1.2.1 (git 2.18.0) at 2024-12-15 04:47:33 +0000