You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
tdegraphics/kpovmodeler/pmobject.h

512 lines
15 KiB

//-*-C++-*-
/*
**************************************************************************
description
--------------------
copyright : (C) 2000-2003 by Andreas Zehender
email : zehender@kde.org
**************************************************************************
**************************************************************************
* *
* 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. *
* *
**************************************************************************/
#ifndef PMOBJECT_H
#define PMOBJECT_H
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <tqvaluelist.h>
#include <tqptrlist.h>
#include <tqstring.h>
#include <tqstringlist.h>
#include <kdebug.h>
#include <tqdom.h>
#include "pmmatrix.h"
#include "pmcontrolpoint.h"
#include "pmmetaobject.h"
#include "pmdebug.h"
class PMDialogEditBase;
class PMMemento;
class PMViewStructure;
class PMXMLHelper;
class PMDeclare;
class PMObjectAction;
class PMPart;
class PMObject;
typedef TQPtrList<PMObject> PMObjectList;
typedef TQPtrListIterator<PMObject> PMObjectListIterator;
/**
* Base class for all povray objects
*
* Used pattern: Composite
*
* All list/child functionality is disabled in this class. Objects that
* can have tqchildren has to be inherited from @ref PMCompositeObject.
*/
class PMObject
{
friend class PMCompositeObject;
public:
/**
* Creates an empty PMObject without parent.
*/
PMObject( PMPart* part );
/**
* Copy constructor. All object pointers (parent, siblings) are set to 0!
*/
PMObject( const PMObject& o );
/**
* Deletes the object and all tqchildren.
*/
virtual ~PMObject( );
/**
* Returns a new object of that type
*/
PMObject* newObject( ) const;
/**
* Returns a deep copy of the object
*/
virtual PMObject* copy( ) const = 0;
/**
* Returns the meta object for the class
*/
virtual PMMetaObject* metaObject( ) const;
/**
* Returns true if the object is of type t or inherits the object
* class with type t
*/
bool isA( const TQString& className ) const;
/**
* Returns the class name (not i18n'ed, without the PM prefix)
*/
TQString type( ) const;
/**
* same as @ref type( )
*/
TQString className( ) const { return type( ); }
/**
* Returns the class name of the object (povray name).
* This is the name that is showed in dialogs and menus.
*/
virtual TQString description( ) const = 0;
/**
* Returns the name of the object. This is the name that helps
* the user to identify a object (like "south wall", "floor" ...)
*/
virtual TQString name( ) const { return TQString(); }
/**
* Returns true if the object can have a name
*/
virtual bool canHaveName( ) const { return false; }
/**
* Returns true if the object should be exported for rendering
*/
virtual bool exportPovray( ) const { return true; }
/**
* Returns a pointer to the parent object.
*/
PMObject* parent( ) const { return m_pParent; }
/**
* Returns a pointer to the corresponding part
*/
PMPart* part( ) const { return m_pPart; }
/**
* Returns true if an object with type className can be inserted
* as child after the object after.
*
* The parser uses the third parameter for top level objects. These objects
* have to be treated as if they are inserted after the object after.
*/
bool canInsert( const TQString& className, const PMObject* after,
const PMObjectList* objectsBetween = 0 ) const;
/**
* Returns true if the object o can be inserted as child after the object
* after.
*
* The parser uses the third parameter for top level objects. These objects
* have to be treated as if they are inserted after the object after.
*/
bool canInsert( const PMObject* o, const PMObject* after,
const PMObjectList* objectsBetween = 0 ) const;
/**
* Returns the number of objects that can be inserted at that position
*/
int canInsert( const PMObjectList& list, const PMObject* after ) const;
/**
* Returns the number of objects that can be inserted at that position
*/
int canInsert( const TQStringList& classes, const PMObject* after ) const;
/**
* Returns true if an insert or remove operation of tqchildren will
* change data inside this class
*/
virtual bool dataChangeOnInsertRemove( ) const { return false; }
/**
* Returns a pointer to the first child. Null for this class
*/
virtual PMObject* firstChild( ) const { return 0; }
/**
* Returns a pointer to the last child. Null for this class
*/
virtual PMObject* lastChild( ) const { return 0; }
/**
* Returns a pointer to the child object at position index,
* or null if the index is out of range.
*/
virtual PMObject* childAt( uint ) const { return 0; }
/**
* Returns the next sibling of that item
*/
PMObject* nextSibling( ) const { return m_pNextSibling; }
/**
* Returns the previous sibling of that item
*/
PMObject* prevSibling( ) const { return m_pPrevSibling; }
/**
* Returns true if the object contains the child object o
*/
virtual bool containsChild( PMObject* ) const { return false; }
/**
* Returns the index of the child or -1 if not found
*/
virtual int findChild( PMObject* ) { return -1; }
/**
* Inserts the object as child at index index.
* If i is -1, the object is appended.
* Returns true if successful
*/
virtual bool insertChild( PMObject*, int )
{
kdError( PMArea ) << "Tried to insert object into a non composite object" << "\n";
return false;
}
/**
* Inserts the object as child after the child object after
*/
virtual bool insertChildAfter( PMObject* object, PMObject* after );
/**
* Inserts the object as child before the child object before
*/
virtual bool insertChildBefore( PMObject* object, PMObject* before );
/**
* Appends the object as last child. Returns true if successful
*/
virtual bool appendChild( PMObject* )
{
kdError( PMArea ) << "Tried to insert object into a non composite object" << "\n";
return false;
}
/**
* Returns the number of tqchildren. 0 in this class
*/
virtual int countChildren( ) const { return 0; }
/**
* Removes a child object. Does not delete it!
* Returns true if successful
*/
virtual bool takeChild( PMObject* );
/**
* Removes a child object at index i. Does not delete it!
* Returns true if successful
*/
virtual bool takeChild( uint );
/**
* Called when a child was removed. For classes that have to be informed
* when tqchildren are removed
*/
virtual void childRemoved( PMObject* ) { };
/**
* Called when a child was added. For classes that have to be informed
* when tqchildren are added
*/
virtual void childAdded( PMObject* ) { };
/**
* Returns true if the object needs auxiliary files.
*/
virtual bool needsAuxiliaryFiles( ) const { return false; }
/**
* Returns a list of auxiliary files
*/
virtual TQStringList auxiliaryFiles( ) const { return TQStringList( ); }
/**
* Returns true if the object has a (povray) transformation matrix.
* True for transformation objects.
*/
virtual bool hasTransformationMatrix( ) const { return false; }
/**
* Returns the (povray) transformation of the object, if it has one,
* otherwise an identity matrix
*/
virtual PMMatrix transformationMatrix( ) const
{
kdError( PMArea ) << "This object has no transformation matrix" << "\n";
return PMMatrix::identity( );
}
/**
* Returns the matrix, the object is transformed with
*/
PMMatrix transformedWith( ) const;
/**
* Returns the view structure ( see @ref PMViewStructure ) of the object
* or 0, if it has none.
*
* The view structure will be created or updated if necessary.
*/
virtual PMViewStructure* viewStructure( ) { return 0; }
/**
* Creates the control points and appends them to the list.
*
* The caller becomes the owner of the control points and has
* to delete them.
*
* Control points are the interface between the graphical views and the
* PMObject for graphical changes.
*/
virtual void controlPoints( PMControlPointList& ) { }
/**
* Tells the object that the control points have changed
*/
virtual void controlPointsChanged( PMControlPointList& ) { }
/**
* Tells the object that the control points have changed
*
* The object can add objects to the second parameter, if
* additional objects were changed during the graphical change,
* not only this object.
*
* If you leave the list empty, only this object was changed.
* If you add tqchildren or other objects to the list, add this object
* to the list, too, if it was changed!
*
* IMPORTANT: When you change additional objects, make sure that
* a memento is created for these objects (@ref mementoCreated,
* @ref createMemento) before changing data.
*
* Calls @ref controlPointsChanged by default.
*/
virtual void controlPointsChangedList( PMControlPointList& list,
PMObjectList& /*changedObjects*/ )
{
controlPointsChanged( list );
}
/**
* Returns true if multiple control points can be selected
*/
virtual bool multipleSelectControlPoints( ) const { return false; }
/**
* Each object can add actions to the context menu of the @ref PMGLView.
*
* Each time the user opens the context menu, this function is called.
* Add all supported actions to this list and call the base class.
*
* The default implementation adds no action.
*
* @see PMObjectAction
*/
virtual void addObjectActions( const PMControlPointList&,
TQPtrList<PMObjectAction>& ) { }
/**
* This member is called when the user selects an object action
* in the context menu.
*
* The arguments are the selected action, the list of control points,
* the 3D (!) positions of the control points (screen-x, screen-y and depth)
* in the active opengl view and the 2D mouse position.
*/
virtual void objectActionCalled( const PMObjectAction*,
const PMControlPointList&,
const TQPtrList<PMVector>&,
const PMVector& ) { };
/**
* Saves the object as kpovmodeler xml code.
*/
TQDomElement serialize( TQDomDocument& doc ) const;
/**
* Adds the objects attributes and child objects to the element
*/
virtual void serialize( TQDomElement& e, TQDomDocument& doc ) const = 0;
/**
* Reads the attributes from the TQDomElement
*/
virtual void readAttributes( const PMXMLHelper& h );
/**
* Returns the list of known properties
*/
TQStringList properties( ) const;
/**
* Sets a property and returns true if successful
*/
bool setProperty( const TQString&, const PMVariant& v );
/**
* Returns a property
*/
PMVariant property( const TQString& ) const;
/**
* Returns true if the object is selected
*/
bool isSelected( ) { return m_selected; }
/**
* Sets this object to be selected if s is true and to not be selected
if s is false
*/
void setSelected( bool s );
/**
* Returns true if this item can be selected. An item cannot be selected
* if a parent object is selected
*/
bool isSelectable( );
/**
* Returns the number of selected child items. All selected items in
* any depth are counted
*/
virtual int selectedChildren( ) const { return 0; }
/**
* Deselects recursively all child objects
*/
virtual void deselectChildren( ) { };
/**
* Returns true if this object is read only
*/
bool isReadOnly( ) const;
/**
* Makes this object read only, if yes == true. All tqchildren will
* be read only, too
*/
void setReadOnly( bool yes = true ) { m_readOnly = yes; }
/**
* Creates a new edit widget that can display this object and
* returns a pointer to it.
*
* The widget will be created as a child of parent.
*/
virtual PMDialogEditBase* editWidget( TQWidget* parent ) const;
/**
* Returns the name of the pixmap that is displayed in the tree view
* and dialog view
*/
virtual TQString pixmap( ) const = 0;
/**
* Returns a pointer to the @ref PMDeclare object, that is linked to
* that object, or 0, if this object contains no link
*/
virtual PMDeclare* linkedObject( ) const { return 0; }
/**
* Tells the object to create a memento object.
*
* By default a simple @ref PMMemento will be created.
* If the memento doesn't provide enough functionality, subclass the memento
* and reimplement this function.
*
* NOTE: The new memento has to inherit the memento used in the base class!
*
* If a memento was created, the object saves all changes its
* state. The memento is then used for undo/redo.
*
* First call this function, change attributes and then take the mementos
* with @ref takeMemento
*
* If you want to restore the old state, call @ref restoreMemento with
* the memento.
*/
virtual void createMemento( );
/**
* Returns true if a memento was created
*/
bool mementoCreated( ) const { return m_pMemento != 0; }
/**
* Takes the memento. The caller is responsible to delete the memento
*/
PMMemento* takeMemento( );
/**
* Restores the state s
*/
virtual void restoreMemento( PMMemento* s );
/**
* This function is called before the part is unloaded.
*
* Delete static pointer variables to clean up the memory.
*
* This method can be called multiple times when there are subclasses.
* Set the pointer to 0 after deleting an object!
*/
virtual void cleanUp( ) const;
protected:
/**
* Adds num to the number of selected objects in this object and all
* parent objects. num can be negative.
*/
virtual void adjustSelectedChildren( int /*num*/ ) { };
/**
* The memento where the old status of the object should be stored
*/
PMMemento* m_pMemento;
private:
/**
* Pointer to the parent object. 0 if the object has no parent.
*/
PMObject* m_pParent;
/**
* Pointer to the prev sibling. 0 if the object has no prev sibling.
*/
PMObject* m_pPrevSibling;
/**
* Pointer to the next sibling. 0 if the object has no next sibling.
*/
PMObject* m_pNextSibling;
/**
* true if this object is selected
*/
bool m_selected;
/**
* true if this object is read only. All tqchildren will be read only, too
*/
bool m_readOnly;
/**
* The meta object
*/
static PMMetaObject* s_pMetaObject;
/**
* The corresponding part
*/
PMPart* m_pPart;
};
#endif