summaryrefslogtreecommitdiffstats
path: root/kpovmodeler/pmrainbow.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/pmrainbow.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/pmrainbow.cpp')
-rw-r--r--kpovmodeler/pmrainbow.cpp422
1 files changed, 422 insertions, 0 deletions
diff --git a/kpovmodeler/pmrainbow.cpp b/kpovmodeler/pmrainbow.cpp
new file mode 100644
index 00000000..5a80e013
--- /dev/null
+++ b/kpovmodeler/pmrainbow.cpp
@@ -0,0 +1,422 @@
+/*
+**************************************************************************
+ description
+ --------------------
+ copyright : (C) 2001-2002 by Luis Carvalho
+ email : lpassos@mail.telepac.pt
+**************************************************************************
+
+**************************************************************************
+* *
+* 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 "pmrainbow.h"
+#include "pmxmlhelper.h"
+#include "pmmemento.h"
+#include "pmrainbowedit.h"
+#include "pmvector.h"
+
+#include <klocale.h>
+
+PMMetaObject* PMRainbow::s_pMetaObject = 0;
+PMObject* createNewRainbow( PMPart* part )
+{
+ return new PMRainbow( part );
+}
+
+const PMVector directionDefault = PMVector( 0.0, 0.0, 0.0 );
+const double angleDefault = 0.0;
+const double widthDefault = 0.0;
+const double distanceDefault = 0.0;
+const double jitterDefault = 0.0;
+const PMVector upDefault = PMVector( 0.0, 0.0, 0.0 );
+const double arcAngleDefault = 0.0;
+const double falloffAngleDefault = 0.0;
+
+PMDefinePropertyClass( PMRainbow, PMRainbowProperty );
+
+PMRainbow::PMRainbow( PMPart* part )
+ : Base( part )
+{
+ m_direction = directionDefault;
+ m_angle = angleDefault;
+ m_width = widthDefault;
+ m_distance = distanceDefault;
+ m_jitter = jitterDefault;
+ m_up = upDefault;
+ m_arcAngle = arcAngleDefault;
+ m_falloffAngle = falloffAngleDefault;
+ m_enableDirection = false;
+ m_enableAngle = false;
+ m_enableWidth = false;
+ m_enableDistance = false;
+ m_enableJitter = false;
+ m_enableUp = false;
+ m_enableArcAngle = false;
+ m_enableFalloffAngle = false;
+}
+
+PMRainbow::PMRainbow( const PMRainbow& r )
+ : Base( r )
+{
+ m_direction = r.m_direction;
+ m_angle = r.m_angle;
+ m_width = r.m_width;
+ m_distance = r.m_distance;
+ m_jitter = r.m_jitter;
+ m_up = r.m_up;
+ m_arcAngle = r.m_arcAngle;
+ m_falloffAngle = r.m_falloffAngle;
+ m_enableDirection = r.m_enableDirection;
+ m_enableAngle = r.m_enableAngle;
+ m_enableWidth = r.m_enableWidth;
+ m_enableDistance = r.m_enableDistance;
+ m_enableJitter = r.m_enableJitter;
+ m_enableUp = r.m_enableUp;
+ m_enableArcAngle = r.m_enableArcAngle;
+ m_enableFalloffAngle = r.m_enableFalloffAngle;
+}
+
+PMRainbow::~PMRainbow( )
+{
+}
+
+PMMetaObject* PMRainbow::metaObject( ) const
+{
+ if( !s_pMetaObject )
+ {
+ s_pMetaObject = new PMMetaObject( "Rainbow", Base::metaObject( ),
+ createNewRainbow );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "direction", &PMRainbow::setDirection, &PMRainbow::direction ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "angle", &PMRainbow::setAngle, &PMRainbow::angle ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "width", &PMRainbow::setWidth, &PMRainbow::width ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "distance", &PMRainbow::setDistance, &PMRainbow::distance ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "jitter", &PMRainbow::setJitter, &PMRainbow::jitter ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "up", &PMRainbow::setUp, &PMRainbow::up ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "arcAngle", &PMRainbow::setArcAngle, &PMRainbow::arcAngle ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "falloffAngle", &PMRainbow::setFalloffAngle, &PMRainbow::falloffAngle ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "directionEnabled", &PMRainbow::enableDirection, &PMRainbow::isDirectionEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "angleEnabled", &PMRainbow::enableAngle, &PMRainbow::isAngleEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "widthEnabled", &PMRainbow::enableWidth, &PMRainbow::isWidthEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "distanceEnabled", &PMRainbow::enableDistance, &PMRainbow::isDistanceEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "jitterEnabled", &PMRainbow::enableJitter, &PMRainbow::isJitterEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "upEnabled", &PMRainbow::enableUp, &PMRainbow::isUpEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "arcAngleEnabled", &PMRainbow::enableArcAngle, &PMRainbow::isArcAngleEnabled ) );
+ s_pMetaObject->addProperty(
+ new PMRainbowProperty( "falloffAngleEnabled", &PMRainbow::enableFalloffAngle, &PMRainbow::isFalloffAngleEnabled ) );
+ }
+ return s_pMetaObject;
+}
+
+void PMRainbow::cleanUp( ) const
+{
+ if( s_pMetaObject )
+ {
+ delete s_pMetaObject;
+ s_pMetaObject = 0;
+ }
+ Base::cleanUp( );
+}
+
+QString PMRainbow::description( ) const
+{
+ return i18n( "rainbow" );
+}
+
+void PMRainbow::serialize( QDomElement& e, QDomDocument& doc ) const
+{
+ Base::serialize( e, doc );
+ e.setAttribute( "enable_direction", m_enableDirection );
+ e.setAttribute( "enable_angle", m_enableAngle );
+ e.setAttribute( "enable_width", m_enableWidth );
+ e.setAttribute( "enable_distance", m_enableDistance );
+ e.setAttribute( "enable_jitter", m_enableJitter );
+ e.setAttribute( "enable_up", m_enableUp );
+ e.setAttribute( "enable_arc_angle", m_enableArcAngle );
+ e.setAttribute( "enable_falloff_angle", m_enableFalloffAngle );
+ e.setAttribute( "direction", m_direction.serializeXML( ) );
+ e.setAttribute( "angle", m_angle );
+ e.setAttribute( "width", m_width );
+ e.setAttribute( "distance", m_distance );
+ e.setAttribute( "jitter", m_jitter );
+ e.setAttribute( "up", m_up.serializeXML( ) );
+ e.setAttribute( "arc_angle", m_arcAngle );
+ e.setAttribute( "falloff_angle", m_falloffAngle );
+}
+
+void PMRainbow::readAttributes( const PMXMLHelper& h )
+{
+ Base::readAttributes( h );
+ m_enableDirection = h.boolAttribute( "enable_direction", false );
+ m_enableAngle = h.boolAttribute( "enable_angle", false );
+ m_enableWidth = h.boolAttribute( "enable_width", false );
+ m_enableDistance = h.boolAttribute( "enable_distance", false );
+ m_enableJitter = h.boolAttribute( "enable_jitter", false );
+ m_enableUp = h.boolAttribute( "enable_up", false );
+ m_enableArcAngle = h.boolAttribute( "enable_arc_angle", false );
+ m_enableFalloffAngle = h.boolAttribute( "enable_falloff_angle", false );
+ m_direction = h.vectorAttribute( "direction", directionDefault );
+ m_angle = h.doubleAttribute( "angle", angleDefault );
+ m_width = h.doubleAttribute( "width", widthDefault );
+ m_distance = h.doubleAttribute( "distance", distanceDefault );
+ m_jitter = h.doubleAttribute( "jitter", jitterDefault );
+ m_up = h.vectorAttribute( "up", upDefault );
+ m_arcAngle = h.doubleAttribute( "arc_angle", arcAngleDefault );
+ m_falloffAngle = h.doubleAttribute( "falloff_angle", falloffAngleDefault );
+}
+
+void PMRainbow::setDirection( const PMVector& c )
+{
+ if( c != m_direction )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDirectionID, m_direction );
+ m_direction = c;
+ }
+}
+
+void PMRainbow::setAngle( double c )
+{
+ if( c != m_angle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMAngleID, m_angle );
+ m_angle = c;
+ }
+}
+
+void PMRainbow::setWidth( double c )
+{
+ if( c != m_width )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMWidthID, m_width );
+ m_width = c;
+ }
+}
+
+void PMRainbow::setDistance( double c )
+{
+ if( c != m_distance )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMDistanceID, m_distance );
+ m_distance = c;
+ }
+}
+
+void PMRainbow::setJitter( double c )
+{
+ if( c != m_jitter )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMJitterID, m_jitter );
+ m_jitter = c;
+ }
+}
+
+void PMRainbow::setUp( const PMVector& c )
+{
+ if( c != m_up )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMUpID, m_up );
+ m_up = c;
+ }
+}
+
+void PMRainbow::setArcAngle( double c )
+{
+ if( c != m_arcAngle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMArcAngleID, m_arcAngle );
+ m_arcAngle = c;
+ }
+}
+
+void PMRainbow::setFalloffAngle( double c )
+{
+ if( c != m_falloffAngle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMFalloffAngleID, m_falloffAngle );
+ m_falloffAngle = c;
+ }
+}
+
+void PMRainbow::enableDirection( bool c )
+{
+ if( c != m_enableDirection )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableDirectionID, m_enableDirection );
+ m_enableDirection = c;
+ }
+}
+
+void PMRainbow::enableAngle( bool c )
+{
+ if( c != m_enableAngle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableAngleID, m_enableAngle );
+ m_enableAngle = c;
+ }
+}
+
+void PMRainbow::enableWidth( bool c )
+{
+ if( c != m_enableWidth )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableWidthID, m_enableWidth );
+ m_enableWidth = c;
+ }
+}
+
+void PMRainbow::enableDistance( bool c )
+{
+ if( c != m_enableDistance )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableDistanceID, m_enableDistance );
+ m_enableDistance = c;
+ }
+}
+
+void PMRainbow::enableJitter( bool c )
+{
+ if( c != m_enableJitter )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableJitterID, m_enableJitter );
+ m_enableJitter = c;
+ }
+}
+
+void PMRainbow::enableUp( bool c )
+{
+ if( c != m_enableUp )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableUpID, m_enableUp );
+ m_enableUp = c;
+ }
+}
+
+void PMRainbow::enableArcAngle( bool c )
+{
+ if( c != m_enableArcAngle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableArcAngleID, m_enableArcAngle );
+ m_enableArcAngle = c;
+ }
+}
+
+void PMRainbow::enableFalloffAngle( bool c )
+{
+ if( c != m_enableFalloffAngle )
+ {
+ if( m_pMemento )
+ m_pMemento->addData( s_pMetaObject, PMEnableFalloffAngleID,
+ m_enableFalloffAngle );
+ m_enableFalloffAngle = c;
+ }
+}
+
+PMDialogEditBase* PMRainbow::editWidget( QWidget* parent ) const
+{
+ return new PMRainbowEdit( parent );
+}
+
+void PMRainbow::restoreMemento( PMMemento* s )
+{
+ PMMementoDataIterator it( s );
+ PMMementoData* data;
+
+ for( ; it.current( ); ++it )
+ {
+ data = it.current( );
+ if( data->objectType( ) == s_pMetaObject )
+ {
+ switch( data->valueID( ) )
+ {
+ case PMDirectionID:
+ setDirection( data->vectorData( ) );
+ break;
+ case PMAngleID:
+ setAngle( data->doubleData( ) );
+ break;
+ case PMWidthID:
+ setWidth( data->doubleData( ) );
+ break;
+ case PMDistanceID:
+ setDistance( data->doubleData( ) );
+ break;
+ case PMJitterID:
+ setJitter( data->doubleData( ) );
+ break;
+ case PMUpID:
+ setUp( data->vectorData( ) );
+ break;
+ case PMArcAngleID:
+ setArcAngle( data->doubleData( ) );
+ break;
+ case PMFalloffAngleID:
+ setFalloffAngle( data->doubleData( ) );
+ break;
+ case PMEnableDirectionID:
+ enableDirection( data->boolData( ) );
+ break;
+ case PMEnableAngleID:
+ enableAngle( data->boolData( ) );
+ break;
+ case PMEnableWidthID:
+ enableWidth( data->boolData( ) );
+ break;
+ case PMEnableDistanceID:
+ enableDistance( data->boolData( ) );
+ break;
+ case PMEnableJitterID:
+ enableJitter( data->boolData( ) );
+ break;
+ case PMEnableUpID:
+ enableUp( data->boolData( ) );
+ break;
+ case PMEnableArcAngleID:
+ enableArcAngle( data->boolData( ) );
+ break;
+ case PMEnableFalloffAngleID:
+ enableFalloffAngle( data->boolData( ) );
+ break;
+ default:
+ kdError( PMArea ) << "Wrong ID in PMRainbow::restoreMemento\n";
+ break;
+ }
+ }
+ }
+ Base::restoreMemento( s );
+}