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.
523 lines
16 KiB
523 lines
16 KiB
/*
|
|
**************************************************************************
|
|
description
|
|
--------------------
|
|
copyright : (C) 2002 by Luis Passos 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 "pmimagemapedit.h"
|
|
#include "pmimagemap.h"
|
|
#include "pmpalettevalue.h"
|
|
#include "pmpalettevaluememento.h"
|
|
|
|
#include "pmxmlhelper.h"
|
|
#include "pmcompositeobject.h"
|
|
#include "pmmemento.h"
|
|
#include "pmenumproperty.h"
|
|
|
|
#include <tdelocale.h>
|
|
|
|
const PMImageMap::PMBitmapType bitmapTypeDefault = PMImageMap::BitmapSys;
|
|
const char *const bitmapFileDefault = 0;
|
|
const bool enableFilterAllDefault = false;
|
|
const bool enableTransmitAllDefault = false;
|
|
const double filterAllDefault = 0.0;
|
|
const double transmitAllDefault = 0.0;
|
|
const bool onceDefault = false;
|
|
const PMImageMap::PMMapType mapTypeDefault = PMImageMap::MapPlanar;
|
|
const PMImageMap::PMInterpolateType interpolateTypeDefault = PMImageMap::InterpolateNone;
|
|
|
|
PMDefinePropertyClass( PMImageMap, PMImageMapProperty );
|
|
PMDefineEnumPropertyClass( PMImageMap, PMImageMap::PMBitmapType,
|
|
PMBitmapTypeProperty );
|
|
PMDefineEnumPropertyClass( PMImageMap, PMImageMap::PMInterpolateType,
|
|
PMInterpolateTypeProperty );
|
|
PMDefineEnumPropertyClass( PMImageMap, PMImageMap::PMMapType,
|
|
PMMapTypeProperty );
|
|
|
|
PMMetaObject* PMImageMap::s_pMetaObject = 0;
|
|
PMObject* createNewImageMap( PMPart* part )
|
|
{
|
|
return new PMImageMap( part );
|
|
}
|
|
|
|
PMImageMap::PMImageMap( PMPart* part )
|
|
: Base( part )
|
|
{
|
|
m_bitmapType = bitmapTypeDefault;
|
|
m_bitmapFile = bitmapFileDefault;
|
|
m_enableFilterAll = enableFilterAllDefault;
|
|
m_filterAll = filterAllDefault;
|
|
m_enableTransmitAll = enableTransmitAllDefault;
|
|
m_transmitAll = transmitAllDefault;
|
|
m_once = onceDefault;
|
|
m_mapType = mapTypeDefault;
|
|
m_interpolateType = interpolateTypeDefault;
|
|
}
|
|
|
|
PMImageMap::PMImageMap( const PMImageMap& m )
|
|
: Base( m )
|
|
{
|
|
m_bitmapType = m.m_bitmapType;
|
|
m_bitmapFile = m.m_bitmapFile;
|
|
m_enableFilterAll = m.m_enableFilterAll;
|
|
m_filterAll = m.m_filterAll;
|
|
m_enableTransmitAll = m.m_enableTransmitAll;
|
|
m_transmitAll = m.m_transmitAll;
|
|
m_once = m.m_once;
|
|
m_mapType = m.m_mapType;
|
|
m_interpolateType = m.m_interpolateType;
|
|
m_filters = m.m_filters;
|
|
m_transmits = m.m_transmits;
|
|
}
|
|
|
|
PMImageMap::~PMImageMap( )
|
|
{
|
|
}
|
|
|
|
void PMImageMap::serialize( TQDomElement& e, TQDomDocument& doc ) const
|
|
{
|
|
switch( m_bitmapType )
|
|
{
|
|
case BitmapGif:
|
|
e.setAttribute( "bitmap_type", "gif" );
|
|
break;
|
|
case BitmapTga:
|
|
e.setAttribute( "bitmap_type", "tga" );
|
|
break;
|
|
case BitmapIff:
|
|
e.setAttribute( "bitmap_type", "iff" );
|
|
break;
|
|
case BitmapPpm:
|
|
e.setAttribute( "bitmap_type", "ppm" );
|
|
break;
|
|
case BitmapPgm:
|
|
e.setAttribute( "bitmap_type", "pgm" );
|
|
break;
|
|
case BitmapPng:
|
|
e.setAttribute( "bitmap_type", "png" );
|
|
break;
|
|
case BitmapJpeg:
|
|
e.setAttribute( "bitmap_type", "jpeg" );
|
|
break;
|
|
case BitmapTiff:
|
|
e.setAttribute( "bitmap_type", "tiff" );
|
|
break;
|
|
case BitmapSys:
|
|
e.setAttribute( "bitmap_type", "sys" );
|
|
break;
|
|
}
|
|
e.setAttribute( "file_name", m_bitmapFile );
|
|
e.setAttribute( "enable_filter_all", m_enableFilterAll );
|
|
e.setAttribute( "filter_all", m_filterAll );
|
|
e.setAttribute( "enable_transmit_all", m_enableTransmitAll );
|
|
e.setAttribute( "transmit_all", m_transmitAll );
|
|
e.setAttribute( "once", m_once );
|
|
|
|
TQDomElement extra_data = doc.createElement( "extra_data" );
|
|
|
|
TQDomElement data = doc.createElement( "indexed_filters" );
|
|
TQDomElement p;
|
|
|
|
TQValueList<PMPaletteValue>::ConstIterator it;
|
|
for( it = m_filters.begin( ); it != m_filters.end( ); ++it )
|
|
{
|
|
p = doc.createElement( "index_filter" );
|
|
( *it ).serialize( p, doc );
|
|
data.appendChild( p );
|
|
}
|
|
extra_data.appendChild( data );
|
|
|
|
data = doc.createElement( "indexed_transmits" );
|
|
for( it = m_transmits.begin( ); it != m_transmits.end( ); ++it )
|
|
{
|
|
p = doc.createElement( "index_transmit" );
|
|
( *it ).serialize( p, doc );
|
|
data.appendChild( p );
|
|
}
|
|
extra_data.appendChild( data );
|
|
|
|
e.appendChild( extra_data );
|
|
|
|
switch( m_mapType )
|
|
{
|
|
case MapPlanar:
|
|
e.setAttribute( "map_type", "planar" );
|
|
break;
|
|
case MapSpherical:
|
|
e.setAttribute( "map_type", "spherical" );
|
|
break;
|
|
case MapCylindrical:
|
|
e.setAttribute( "map_type", "cylindrical" );
|
|
break;
|
|
case MapToroidal:
|
|
e.setAttribute( "map_type", "toroidal" );
|
|
break;
|
|
}
|
|
switch( m_interpolateType )
|
|
{
|
|
case InterpolateNone:
|
|
e.setAttribute( "interpolate", "none" );
|
|
break;
|
|
case InterpolateBilinear:
|
|
e.setAttribute( "interpolate", "bilinear" );
|
|
break;
|
|
case InterpolateNormalized:
|
|
e.setAttribute( "interpolate", "normalized" );
|
|
break;
|
|
}
|
|
Base::serialize( e, doc );
|
|
}
|
|
|
|
void PMImageMap::readAttributes( const PMXMLHelper& h )
|
|
{
|
|
TQString str;
|
|
|
|
str = h.stringAttribute( "bitmap_type", "sys" );
|
|
if( str == "gif" )
|
|
m_bitmapType = BitmapGif;
|
|
else if( str == "tga" )
|
|
m_bitmapType = BitmapTga;
|
|
else if( str == "iff" )
|
|
m_bitmapType = BitmapIff;
|
|
else if( str == "ppm" )
|
|
m_bitmapType = BitmapPpm;
|
|
else if( str == "pgm" )
|
|
m_bitmapType = BitmapPgm;
|
|
else if( str == "png" )
|
|
m_bitmapType = BitmapPng;
|
|
else if( str == "jpeg" )
|
|
m_bitmapType = BitmapJpeg;
|
|
else if( str == "tiff" )
|
|
m_bitmapType = BitmapTiff;
|
|
else if( str == "sys" )
|
|
m_bitmapType = BitmapSys;
|
|
|
|
m_bitmapFile = h.stringAttribute( "file_name", bitmapFileDefault );
|
|
m_enableFilterAll = h.boolAttribute( "enable_filter_all", enableFilterAllDefault );
|
|
m_filterAll = h.doubleAttribute( "filter_all", filterAllDefault );
|
|
m_enableTransmitAll = h.boolAttribute( "enable_transmit_all", enableTransmitAllDefault );
|
|
m_transmitAll = h.doubleAttribute( "transmit_all", transmitAllDefault );
|
|
m_once = h.boolAttribute( "once", onceDefault );
|
|
|
|
TQDomElement e = h.extraData( );
|
|
if( !e.isNull( ) )
|
|
{
|
|
TQDomNode c = e.firstChild( );
|
|
while( !c.isNull( ) )
|
|
{
|
|
if( c.isElement( ) )
|
|
{
|
|
TQDomElement ce = c.toElement( );
|
|
if( ce.tagName( ) == "indexed_filters" )
|
|
{
|
|
m_filters.clear( );
|
|
TQDomNode cd = ce.firstChild( );
|
|
while( !cd.isNull( ) )
|
|
{
|
|
if( cd.isElement( ) )
|
|
{
|
|
PMPaletteValue pv;
|
|
pv.readAttributes( cd.toElement( ) );
|
|
m_filters.append( pv );
|
|
}
|
|
cd = cd.nextSibling( );
|
|
}
|
|
}
|
|
if( ce.tagName( ) == "indexed_transmits" )
|
|
{
|
|
m_transmits.clear( );
|
|
TQDomNode cd = ce.firstChild( );
|
|
while( !cd.isNull( ) )
|
|
{
|
|
if( cd.isElement( ) )
|
|
{
|
|
PMPaletteValue pv;
|
|
pv.readAttributes( cd.toElement( ) );
|
|
m_transmits.append( pv );
|
|
}
|
|
cd = cd.nextSibling( );
|
|
}
|
|
}
|
|
}
|
|
c = c.nextSibling( );
|
|
}
|
|
}
|
|
|
|
str = h.stringAttribute( "map_type", "planar" );
|
|
if( str == "planar" )
|
|
m_mapType = MapPlanar;
|
|
else if( str == "spherical" )
|
|
m_mapType = MapSpherical;
|
|
else if( str == "cylindrical" )
|
|
m_mapType = MapCylindrical;
|
|
else if( str == "toroidal" )
|
|
m_mapType = MapToroidal;
|
|
|
|
str = h.stringAttribute( "interpolate", "none" );
|
|
if( str == "none" )
|
|
m_interpolateType = InterpolateNone;
|
|
else if( str == "bilinear" )
|
|
m_interpolateType = InterpolateBilinear;
|
|
else if( str == "normalized" )
|
|
m_interpolateType = InterpolateNormalized;
|
|
Base::readAttributes( h );
|
|
}
|
|
|
|
PMMetaObject* PMImageMap::metaObject( ) const
|
|
{
|
|
if( !s_pMetaObject )
|
|
{
|
|
s_pMetaObject = new PMMetaObject( "ImageMap", Base::metaObject( ),
|
|
createNewImageMap );
|
|
|
|
PMBitmapTypeProperty* bp = new PMBitmapTypeProperty(
|
|
"bitmapType", &PMImageMap::setBitmapType, &PMImageMap::bitmapType );
|
|
bp->addEnumValue( "Gif", BitmapGif );
|
|
bp->addEnumValue( "Tga", BitmapTga );
|
|
bp->addEnumValue( "Iff", BitmapIff );
|
|
bp->addEnumValue( "Ppm", BitmapPpm );
|
|
bp->addEnumValue( "Pgm", BitmapPgm );
|
|
bp->addEnumValue( "Png", BitmapPng );
|
|
bp->addEnumValue( "Jpeg", BitmapJpeg );
|
|
bp->addEnumValue( "Tiff", BitmapTiff );
|
|
bp->addEnumValue( "Sys", BitmapSys );
|
|
s_pMetaObject->addProperty( bp );
|
|
|
|
PMInterpolateTypeProperty* ip = new PMInterpolateTypeProperty(
|
|
"interpolateType", &PMImageMap::setInterpolateType,
|
|
&PMImageMap::interpolateType );
|
|
ip->addEnumValue( "None", InterpolateNone );
|
|
ip->addEnumValue( "Bilinear", InterpolateBilinear );
|
|
ip->addEnumValue( "Normalized", InterpolateNormalized );
|
|
s_pMetaObject->addProperty( ip );
|
|
|
|
PMMapTypeProperty* mp = new PMMapTypeProperty(
|
|
"mapType", &PMImageMap::setMapType, &PMImageMap::mapType );
|
|
mp->addEnumValue( "Planar", MapPlanar );
|
|
mp->addEnumValue( "Spherical", MapSpherical );
|
|
mp->addEnumValue( "Cylindrical", MapCylindrical );
|
|
mp->addEnumValue( "Toroidal", MapToroidal );
|
|
s_pMetaObject->addProperty( mp );
|
|
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "bitmapFile", &PMImageMap::setBitmapFileName,
|
|
&PMImageMap::bitmapFile ) );
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "filterAllEnabled", &PMImageMap::enableFilterAll,
|
|
&PMImageMap::isFilterAllEnabled ) );
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "filterAll", &PMImageMap::setFilterAll,
|
|
&PMImageMap::filterAll ) );
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "transmitAllEnabled", &PMImageMap::enableTransmitAll,
|
|
&PMImageMap::isTransmitAllEnabled ) );
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "transmitAll", &PMImageMap::setTransmitAll,
|
|
&PMImageMap::transmitAll ) );
|
|
s_pMetaObject->addProperty(
|
|
new PMImageMapProperty( "once", &PMImageMap::enableOnce, &PMImageMap::isOnceEnabled ) );
|
|
|
|
// TODO: filters and transmits properties
|
|
}
|
|
return s_pMetaObject;
|
|
}
|
|
|
|
void PMImageMap::cleanUp( ) const
|
|
{
|
|
if( s_pMetaObject )
|
|
{
|
|
delete s_pMetaObject;
|
|
s_pMetaObject = 0;
|
|
}
|
|
Base::cleanUp( );
|
|
}
|
|
|
|
TQString PMImageMap::description( ) const
|
|
{
|
|
return i18n( "imagemap" );
|
|
}
|
|
|
|
void PMImageMap::setBitmapType( PMBitmapType c )
|
|
{
|
|
if( c != m_bitmapType )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMBitmapTypeID, m_bitmapType );
|
|
m_bitmapType = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setBitmapFileName( const TQString& c )
|
|
{
|
|
if( c != m_bitmapFile )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMBitmapFileID, m_bitmapFile );
|
|
m_bitmapFile = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::enableFilterAll( bool c )
|
|
{
|
|
if( c != m_enableFilterAll )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMEnableFilterAllID, m_enableFilterAll );
|
|
m_enableFilterAll = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::enableTransmitAll( bool c )
|
|
{
|
|
if( c != m_enableTransmitAll )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMEnableTransmitAllID, m_enableTransmitAll );
|
|
m_enableTransmitAll = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setFilterAll( double c )
|
|
{
|
|
if( c != m_filterAll )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMFilterAllID, m_filterAll );
|
|
m_filterAll = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setTransmitAll( double c )
|
|
{
|
|
if( c != m_transmitAll )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMFilterAllID, m_transmitAll );
|
|
m_transmitAll = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::enableOnce( bool c )
|
|
{
|
|
if( c != m_once )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMOnceID, m_once );
|
|
m_once = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setMapType( PMMapType c )
|
|
{
|
|
if( c != m_mapType )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMMapTypeID, m_mapType );
|
|
m_mapType = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setInterpolateType( PMInterpolateType c )
|
|
{
|
|
if( c != m_interpolateType )
|
|
{
|
|
if( m_pMemento )
|
|
m_pMemento->addData( s_pMetaObject, PMInterpolateID, m_interpolateType );
|
|
m_interpolateType = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setFilters( const TQValueList<PMPaletteValue>& c )
|
|
{
|
|
if( m_filters != c )
|
|
{
|
|
if( m_pMemento )
|
|
( ( PMPaletteValueMemento* ) m_pMemento )->setFilterPaletteValues( m_filters );
|
|
m_filters = c;
|
|
}
|
|
}
|
|
|
|
void PMImageMap::setTransmits( const TQValueList<PMPaletteValue>& c )
|
|
{
|
|
if( m_transmits != c )
|
|
{
|
|
if( m_pMemento )
|
|
( ( PMPaletteValueMemento* ) m_pMemento )->setTransmitPaletteValues( m_transmits );
|
|
m_transmits = c;
|
|
}
|
|
}
|
|
|
|
PMDialogEditBase* PMImageMap::editWidget( TQWidget* parent ) const
|
|
{
|
|
return new PMImageMapEdit( parent );
|
|
}
|
|
|
|
void PMImageMap::restoreMemento( PMMemento* s )
|
|
{
|
|
PMPaletteValueMemento* m = ( PMPaletteValueMemento* ) s;
|
|
PMMementoDataIterator it( s );
|
|
PMMementoData* data;
|
|
|
|
for( ; it.current( ); ++it )
|
|
{
|
|
data = it.current( );
|
|
if( data->objectType( ) == s_pMetaObject )
|
|
{
|
|
switch( data->valueID( ) )
|
|
{
|
|
case PMBitmapTypeID:
|
|
setBitmapType( ( PMBitmapType )data->intData( ) );
|
|
break;
|
|
case PMBitmapFileID:
|
|
setBitmapFileName( data->stringData( ) );
|
|
break;
|
|
case PMEnableFilterAllID:
|
|
enableFilterAll( data->boolData( ) );
|
|
break;
|
|
case PMEnableTransmitAllID:
|
|
enableTransmitAll( data->boolData( ) );
|
|
break;
|
|
case PMFilterAllID:
|
|
setFilterAll( data->doubleData( ) );
|
|
break;
|
|
case PMTransmitAllID:
|
|
setTransmitAll( data->doubleData( ) );
|
|
break;
|
|
case PMOnceID:
|
|
enableOnce( data->boolData( ) );
|
|
break;
|
|
case PMMapTypeID:
|
|
setMapType( ( PMMapType )data->intData( ) );
|
|
break;
|
|
case PMInterpolateID:
|
|
setInterpolateType( ( PMInterpolateType )data->intData( ) );
|
|
break;
|
|
default:
|
|
kdError( PMArea ) << "Wrong ID in PMImageMap::restoreMemento\n";
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if( m->filterPaletteValuesSaved( ) )
|
|
setFilters( m->filterPaletteValues( ) );
|
|
|
|
if( m->transmitPaletteValuesSaved( ) )
|
|
setTransmits( m->transmitPaletteValues( ) );
|
|
|
|
Base::restoreMemento( s );
|
|
}
|
|
|