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.
427 lines
7.3 KiB
427 lines
7.3 KiB
/* libppt - library to read PowerPoint presentation
|
|
Copyright (C) 2005 Yolla Indria <yolla.indria@gmail.com>
|
|
|
|
This library is free software; you can redistribute it and/or
|
|
modify it under the terms of the GNU Library General Public
|
|
License as published by the Free Software Foundation; either
|
|
version 2 of the License, or (at your option) any later version.
|
|
|
|
This library is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Library General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Library General Public License
|
|
along with this library; see the file COPYING.LIB. If not, write to
|
|
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include "objects.h"
|
|
#include "ustring.h"
|
|
|
|
#include <string>
|
|
#include <map>
|
|
#include <vector>
|
|
#include <iostream>
|
|
|
|
using namespace Libppt;
|
|
|
|
class PropertyValue
|
|
{
|
|
public:
|
|
enum { InvalidType, IntType, DoubleType, StringType, BoolType, ColorType } type;
|
|
bool b;
|
|
int i;
|
|
double d;
|
|
std::string s;
|
|
Color c;
|
|
|
|
PropertyValue()
|
|
{
|
|
type = InvalidType;
|
|
b = false;
|
|
i = 0;
|
|
d = 0.0;
|
|
|
|
|
|
}
|
|
};
|
|
|
|
class Object::Private
|
|
{
|
|
public:
|
|
int id;
|
|
double top;
|
|
double left;
|
|
double width;
|
|
double height;
|
|
bool background;
|
|
std::map<std::string,PropertyValue> properties;
|
|
};
|
|
|
|
Object::Object()
|
|
{
|
|
d = new Private;
|
|
d->id = -1;
|
|
d->top = 0.0;
|
|
d->left = 0.0;
|
|
d->width = 10.0;
|
|
d->height = 3.0;
|
|
d->background = false;
|
|
}
|
|
|
|
Object::~Object()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
int Object::id() const
|
|
{
|
|
return d->id;
|
|
}
|
|
|
|
void Object::setId( int id )
|
|
{
|
|
d->id = id;
|
|
}
|
|
|
|
double Object::top() const
|
|
{
|
|
return d->top;
|
|
}
|
|
|
|
double Object::left() const
|
|
{
|
|
return d->left;
|
|
}
|
|
|
|
double Object::width() const
|
|
{
|
|
return d->width;
|
|
}
|
|
|
|
double Object::height() const
|
|
{
|
|
return d->height;
|
|
}
|
|
|
|
void Object::setTop( double top )
|
|
{
|
|
d->top = top;
|
|
}
|
|
|
|
void Object::setLeft( double left )
|
|
{
|
|
d->left = left;
|
|
}
|
|
|
|
void Object::setWidth( double width )
|
|
{
|
|
d->width = width;
|
|
}
|
|
|
|
void Object::setHeight( double height)
|
|
{
|
|
d->height = height;
|
|
}
|
|
|
|
bool Object::isBackground() const
|
|
{
|
|
return d->background;
|
|
}
|
|
|
|
void Object::setBackground( bool bg )
|
|
{
|
|
d->background = bg;
|
|
}
|
|
|
|
bool Object::hasProperty( std::string name )
|
|
{
|
|
std::map<std::string,PropertyValue>::const_iterator i;
|
|
i = d->properties.find( name );
|
|
if( i == d->properties.end() )
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
void Object::setProperty( std::string name, std::string value )
|
|
{
|
|
PropertyValue pv;
|
|
pv.type = PropertyValue::StringType;
|
|
pv.s = value;
|
|
d->properties[ name ] = pv;
|
|
}
|
|
|
|
void Object::setProperty( std::string name, int value )
|
|
{
|
|
PropertyValue pv;
|
|
pv.type = PropertyValue::IntType;
|
|
pv.i = value;
|
|
d->properties[ name ] = pv;
|
|
}
|
|
|
|
void Object::setProperty( std::string name, double value )
|
|
{
|
|
PropertyValue pv;
|
|
pv.type = PropertyValue::DoubleType;
|
|
pv.d = value;
|
|
d->properties[ name ] = pv;
|
|
}
|
|
|
|
void Object::setProperty( std::string name, bool value )
|
|
{
|
|
PropertyValue pv;
|
|
pv.type = PropertyValue::BoolType;
|
|
pv.b = value;
|
|
d->properties[ name ] = pv;
|
|
}
|
|
|
|
void Object::setProperty( std::string name, Color value )
|
|
{
|
|
PropertyValue pv;
|
|
pv.type = PropertyValue::ColorType;
|
|
pv.c = value;
|
|
d->properties[ name ] = pv;
|
|
}
|
|
|
|
int Object::getIntProperty( std::string name )
|
|
{
|
|
PropertyValue pv;
|
|
pv = d->properties[ name ];
|
|
if( pv.type == PropertyValue::IntType )
|
|
return pv.i;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
double Object::getDoubleProperty( std::string name )
|
|
{
|
|
PropertyValue pv;
|
|
pv = d->properties[ name ];
|
|
if( pv.type == PropertyValue::DoubleType )
|
|
return pv.d;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
bool Object::getBoolProperty( std::string name )
|
|
{
|
|
PropertyValue pv;
|
|
pv = d->properties[ name ];
|
|
if( pv.type == PropertyValue::BoolType )
|
|
return pv.b;
|
|
else
|
|
return false;
|
|
|
|
}
|
|
|
|
std::string Object::getStrProperty( std::string name )
|
|
{
|
|
PropertyValue pv;
|
|
pv = d->properties[ name ];
|
|
if( pv.type == PropertyValue::StringType )
|
|
return pv.s;
|
|
else
|
|
return "NoString";
|
|
}
|
|
|
|
Color Object::getColorProperty(std::string name)
|
|
{
|
|
PropertyValue pv;
|
|
pv = d->properties[ name ];
|
|
if( pv.type == PropertyValue::ColorType )
|
|
return pv.c;
|
|
else
|
|
return Color(153,204,255); // #99ccff
|
|
|
|
}
|
|
|
|
class TextObject::Private
|
|
{
|
|
public:
|
|
unsigned type;
|
|
std::vector<UString> text;
|
|
unsigned listSize;
|
|
std::vector<bool> bulletFlag;
|
|
};
|
|
|
|
TextObject::TextObject(): Object()
|
|
{
|
|
d = new Private;
|
|
}
|
|
|
|
TextObject::~TextObject()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
unsigned TextObject::type() const
|
|
{
|
|
return d->type;
|
|
}
|
|
|
|
unsigned TextObject::listSize() const
|
|
{
|
|
return d->text.size();
|
|
}
|
|
|
|
const char* TextObject::typeAsString() const
|
|
{
|
|
switch( d->type )
|
|
{
|
|
case Title : return "Title";
|
|
case Body : return "Body";
|
|
case Notes : return "Notes";
|
|
case NotUsed : return "NotUsed";
|
|
case Other : return "Other";
|
|
case CenterBody : return "CenterBody";
|
|
case CenterTitle : return "CenterTitle";
|
|
case HalfBody : return "HalfBody";
|
|
case QuarterBody : return "QuarterBody";
|
|
default: break;
|
|
}
|
|
|
|
return "Unknown";
|
|
}
|
|
|
|
bool TextObject::bulletFlag( unsigned index ) const
|
|
{
|
|
return d->bulletFlag[index];
|
|
}
|
|
|
|
void TextObject::setBulletFlag( bool flag )
|
|
{
|
|
d->bulletFlag.push_back( flag );
|
|
}
|
|
|
|
|
|
void TextObject::setType( unsigned type )
|
|
{
|
|
d->type = type;
|
|
}
|
|
|
|
UString TextObject::text( unsigned index) const
|
|
{
|
|
return d->text[index];
|
|
}
|
|
|
|
void TextObject::setText( const UString& text )
|
|
{
|
|
d->text.push_back( text );
|
|
}
|
|
|
|
void TextObject::convertFrom( Object* object )
|
|
{
|
|
setId( object->id() );
|
|
setLeft( object->left() );
|
|
setTop( object->top() );
|
|
setWidth( object->width() );
|
|
setHeight( object->height() );
|
|
|
|
if( object->isText() )
|
|
{
|
|
TextObject* textObj = static_cast<TextObject*>( object );
|
|
setType( textObj->type() );
|
|
// jgn lupa diganti : setText( textObj->text() );
|
|
}
|
|
}
|
|
|
|
class GroupObject::Private
|
|
{
|
|
public:
|
|
std::vector<Object*> objects;
|
|
};
|
|
|
|
GroupObject::GroupObject()
|
|
{
|
|
d = new Private;
|
|
}
|
|
|
|
GroupObject::~GroupObject()
|
|
{
|
|
for( unsigned i=0; i<d->objects.size(); i++ )
|
|
delete d->objects[i];
|
|
delete d;
|
|
}
|
|
|
|
unsigned GroupObject::objectCount() const
|
|
{
|
|
return d->objects.size();
|
|
}
|
|
|
|
Object* GroupObject::object( unsigned i )
|
|
{
|
|
return d->objects[i];
|
|
}
|
|
|
|
void GroupObject::addObject( Object* object )
|
|
{
|
|
d->objects.push_back( object );
|
|
}
|
|
|
|
void GroupObject::takeObject( Object* object )
|
|
{
|
|
std::vector<Object*> result;
|
|
for( unsigned i=0; i<d->objects.size(); i++ )
|
|
{
|
|
Object* obj = d->objects[i];
|
|
if( obj != object )
|
|
result.push_back( obj );
|
|
}
|
|
|
|
d->objects.clear();
|
|
for( unsigned j=0; j<result.size(); j++ )
|
|
d->objects.push_back( result[j] );
|
|
}
|
|
|
|
class DrawObject::Private
|
|
{
|
|
public:
|
|
unsigned tqshape;
|
|
bool isVerFlip;
|
|
bool isHorFlip;
|
|
};
|
|
|
|
DrawObject::DrawObject()
|
|
{
|
|
d = new Private;
|
|
d->tqshape = None;
|
|
}
|
|
|
|
DrawObject::~DrawObject()
|
|
{
|
|
delete d;
|
|
}
|
|
|
|
unsigned DrawObject::tqshape() const
|
|
{
|
|
return d->tqshape;
|
|
}
|
|
|
|
void DrawObject::setShape( unsigned s )
|
|
{
|
|
d->tqshape = s;
|
|
}
|
|
|
|
bool DrawObject::isVerFlip() const
|
|
{
|
|
return d->isVerFlip;
|
|
}
|
|
|
|
void DrawObject::setVerFlip( bool isVerFlip )
|
|
{
|
|
d->isVerFlip = isVerFlip;
|
|
}
|
|
|
|
bool DrawObject::isHorFlip() const
|
|
{
|
|
return d->isHorFlip;
|
|
}
|
|
|
|
void DrawObject::setHorFlip( bool isHorFlip )
|
|
{
|
|
d->isHorFlip = isHorFlip;
|
|
}
|