TDE
/
koffice
mirror of https://mirror.git.trinitydesktop.org/gitea/TDE/koffice
0
0
Fork 0
Code Issues Releases Wiki Activity
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.
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '35ce85f8c4'
${ noResults }
koffice/kivio/kiviopart/kiviosdk/kivio_py_stencil.cpp

1031 lines
26 KiB
Raw Blame History

#include "kivio_py_stencil.h"
#include "kivio_view.h"
KivioPage *page;
KivioView *view;
#ifdef HAVE_PYTHON
#include "kivioglobal.h"
#include "kivio_common.h"
#include "kivio_connector_point.h"
#include "kivio_connector_target.h"
#include "kivio_fill_style.h"
#include "kivio_intra_stencil_data.h"
#include "kivio_line_style.h"
#include "kivio_painter.h"
#include "kivio_point.h"
#include "kivio_screen_painter.h"
#include "kivio_stencil_spawner.h"
#include "kivio_stencil_spawner_info.h"
#include "kivio_stencil_spawner_set.h"
#include "kivio_py_stencil_spawner.h"
#include "kivio_page.h"
#include <tqpainter.h>
#include <tqbrush.h>
#include <tqcolor.h>
#include <kdebug.h>
#include <math.h>
#include <KoZoomHandler.h>
#include "py_kivio.h"
extern "C" {
void initkivioc(void);
}
KivioPyStencil::KivioPyStencil()
: KivioStencil()
{
m_pConnectorTargets = new TQPtrList<KivioConnectorTarget>;
m_pConnectorTargets->setAutoDelete(true);
static bool first_time = true;
if ( first_time ) {
Py_Initialize(); // initialize python only once
//kdDebug(43000) << "init kivioc" << endl;
initkivioc();
first_time = false;
}
PyObject* mainmod = PyImport_AddModule("__main__");
globals = PyModule_GetDict(mainmod);
m_x = old_x = 0.0;
m_y = old_y = 0.0;
m_w = old_w = 72.0;
m_h = old_h = 72.0;
double x2 = m_x+m_w;
double y2 = m_y+m_h;
vars = Py_BuildValue( "{s:d,s:d,s:d,s:d,s:d,s:d,s:{},s:[],s:[],s:{}}",
"x", m_x, "y", m_y, "w", m_w, "h", m_h, "x2", x2, "y2", y2 , "style","connectors","connector_targets","shapes");
resizeCode = "";
}
KivioPyStencil::~KivioPyStencil()
{
}
int KivioPyStencil::init( TQString initCode )
{
runPython(kivio_module);
if ( !runPython( initCode ) )
return 1;
m_w = getDoubleFromDict( vars, "w");
m_h = getDoubleFromDict( vars, "h");
m_x = getDoubleFromDict( vars, "x");
m_y = getDoubleFromDict( vars, "y");
old_x = m_x;
old_y = m_y;
old_w = m_w;
old_h = m_h;
return 1;
}
bool KivioPyStencil::loadXML( const TQDomElement &e )
{
TQDomNode node;
TQDomElement ele;
node = e.firstChild();
while( !node.isNull() )
{
TQString nodeName = node.nodeName();
ele = node.toElement();
if( nodeName == "PyData" )
{
resizeCode = XmlReadString( ele, "resizeCode", "" );
TQString sVars = XmlReadString( ele, "vars", "" );
PyObject* mainmod = PyImport_AddModule("__main__");
PyObject* gdic = PyModule_GetDict(mainmod);
PyObject *ldic = Py_BuildValue("{s:s,s:{}}", "ldic", sVars.latin1() ,"res");
if ( !PyRun_String("import pickle\nres = pickle.loads(ldic)", Py_file_input, gdic, ldic) ) {
PyErr_Print();
return false;
}
vars = PyDict_GetItemString( ldic, "res" );
Py_INCREF(vars);
runPython(kivio_module);
m_w = getDoubleFromDict( vars, "w");
m_h = getDoubleFromDict( vars, "h");
m_x = getDoubleFromDict( vars, "x");
m_y = getDoubleFromDict( vars, "y");
old_x = m_x;
old_y = m_y;
old_w = m_w;
old_h = m_h;
}
else if( nodeName == "KivioConnectorTargetList" )
{
loadConnectorTargetListXML( ele );
}
node = node.nextSibling();
}
return true;
}
/**
* Help function for loading from an XML node.
*/
void KivioPyStencil::loadConnectorTargetListXML( const TQDomElement &e )
{
TQDomNode node;
TQDomElement ele;
TQString nodeName;
KivioConnectorTarget *pTarget;
pTarget = m_pConnectorTargets->first();
node = e.firstChild();
while( !node.isNull() && pTarget)
{
nodeName = node.nodeName();
ele = node.toElement();
if( nodeName == "KivioConnectorTarget" )
{
pTarget->loadXML( ele );
}
pTarget = m_pConnectorTargets->next();
node = node.nextSibling();
}
}
TQDomElement KivioPyStencil::saveXML( TQDomDocument &doc )
{
TQDomElement e = doc.createElement("KivioPyStencil");
XmlWriteString( e, "id", m_pSpawner->info()->id() );
XmlWriteString( e, "setId", m_pSpawner->set()->id() );
TQDomElement dE = doc.createElement("PyData");
// The python variables
PyObject* mainmod = PyImport_AddModule("__main__");
PyObject* gdic = PyModule_GetDict(mainmod);
PyObject *ldic = Py_BuildValue("{s:O,s:{}}", "ldic", vars ,"res");
const char *dump_code = "import copy\n"\
"import pickle\n"\
"cres = {}\n"\
"for key in ldic.keys():\n"\
" try:\n"\
" cres[key] = copy.deepcopy(ldic[key])\n"\
" except:\n"\
" ii=0\n"\
"res = pickle.dumps(cres)\n";
if ( !PyRun_String(dump_code, Py_file_input, gdic, ldic) )
PyErr_Print();
TQString sVars = PyBytes_AS_STRING( PyDict_GetItemString( ldic, "res") );
XmlWriteString( dE, "vars", sVars );
XmlWriteString( dE, "resizeCode", resizeCode );
e.appendChild( dE );
// Save the target list
TQDomElement clE = doc.createElement("KivioConnectorTargetList");
TQDomElement targetE;
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
targetE = pTarget->saveXML( doc );
clE.appendChild( targetE );
pTarget = m_pConnectorTargets->next();
}
e.appendChild( clE );
return e;
}
void KivioPyStencil::updateGeometry()
{
//rescale items :
rescaleShapes(vars);
old_x = m_x;
old_y = m_y;
old_w = m_w;
old_h = m_h;
if ( !resizeCode.isEmpty() )
runPython(resizeCode);
// stuff from KivioSMLStensil
KivioConnectorTarget *pTarget, *pOriginal;
TQPtrList<KivioConnectorTarget> *pOriginalTargets = ((KivioPyStencilSpawner*)m_pSpawner)->targets();
pTarget = m_pConnectorTargets->first();
pOriginal = pOriginalTargets->first();
PyObject *targets = PyDict_GetItemString(vars,"connector_targets");
int size = PyList_Size( targets );
int i=0;
while( pTarget && pOriginal && i<size )
{
PyObject *target = PyList_GetItem( targets, i );
double x = getDoubleFromDict( target,"x");
double y = getDoubleFromDict( target,"y");
pTarget ->setPosition( x, y );
pOriginal->setPosition( x, y );
pTarget = m_pConnectorTargets->next();
pOriginal = pOriginalTargets->next();
i++;
}
}
void KivioPyStencil::rescaleShapes( PyObject *o )
{
if ( PyDict_Check(o) ) {
PyObject *o_x = PyDict_GetItemString(o,"x");
if ( o_x ) {
double x = getDoubleFromDict(o,"x");
x = m_x+(x-old_x)*m_w/old_w;
PyDict_SetItemString( o, "x", Py_BuildValue( "d", x ) );
}
PyObject *o_y = PyDict_GetItemString(o,"y");
if ( o_y ) {
double y = getDoubleFromDict(o,"y");
y = m_y+(y-old_y)*m_h/old_h;
PyDict_SetItemString( o, "y", Py_BuildValue( "d", y ) );
}
PyObject *o_x2 = PyDict_GetItemString(o,"x2");
if ( o_x2 ) {
double x = getDoubleFromDict(o,"x2");
x = m_x+(x-old_x)*m_w/old_w;
PyDict_SetItemString( o, "x2", Py_BuildValue( "d", x ) );
}
//PyObject *o_y2 = PyDict_GetItemString(o,"y2");
if ( o_y ) {
double y = getDoubleFromDict(o,"y2");
y = m_y+(y-old_y)*m_h/old_h;
PyDict_SetItemString( o, "y2", Py_BuildValue( "d", y ) );
}
PyObject *o_w = PyDict_GetItemString(o,"w");
if ( o_w ) {
double w = getDoubleFromDict(o,"w");
w = w*m_w/old_w;
PyDict_SetItemString( o, "w", Py_BuildValue( "d", w ) );
}
PyObject *o_h = PyDict_GetItemString(o,"h");
if ( o_h ) {
double h = getDoubleFromDict(o,"h");
h = h*m_h/old_h;
PyDict_SetItemString( o, "h", Py_BuildValue( "d", h ) );
}
PyObject *childs = PyDict_Values( o );
int size = PyList_Size( childs );
for ( int i=0; i<size; i++ )
rescaleShapes(PyList_GetItem(childs,i) );
} else
if ( PyList_Check(o) ) {
int size = PyList_Size( o );
for ( int i=0; i<size; i++ )
rescaleShapes( PyList_GetItem(o,i) );
}
}
/**
* Duplicates this object.
*
* Duplicates all aspects of this object except for the
* stencil connected to the targets.
*/
KivioStencil *KivioPyStencil::duplicate()
{
KivioPyStencil *pNewStencil = new KivioPyStencil();
KivioStencil *pReturn;
pNewStencil->m_x = m_x;
pNewStencil->m_y = m_y;
pNewStencil->m_w = m_w;
pNewStencil->m_h = m_h;
pNewStencil->old_x = old_x;
pNewStencil->old_y = old_y;
pNewStencil->old_w = old_w;
pNewStencil->old_h = old_h;
pNewStencil->m_pSpawner = m_pSpawner;
pNewStencil->resizeCode = resizeCode;
//make deep copy of vars:
PyObject* mainmod = PyImport_AddModule("__main__");
PyObject* gdic = PyModule_GetDict(mainmod);
PyObject *ldic = Py_BuildValue("{s:O,s:{}}", "ldic", vars ,"res");
const char *copy_code = "import copy\n"\
"for key in ldic.keys():\n"\
" try:\n"\
" res[key] = copy.deepcopy(ldic[key])\n"\
" except:\n"\
" i=0\n";
if ( !PyRun_String(copy_code, Py_file_input, gdic, ldic) )
PyErr_Print();
pNewStencil->vars = PyDict_GetItemString( ldic, "res");
pNewStencil->runPython(kivio_module);
// Copy the Connector Targets
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
pNewStencil->m_pConnectorTargets->append( pTarget->duplicate() );
pTarget = m_pConnectorTargets->next();
}
*(pNewStencil->protection()) = *m_pProtection;
*(pNewStencil->canProtect()) = *m_pCanProtect;
pReturn = pNewStencil;
return pReturn;
}
void KivioPyStencil::paint( KivioIntraStencilData *d )
{
paint(d,false);
}
void KivioPyStencil::paintOutline( KivioIntraStencilData *d )
{
paint(d,true);
}
void KivioPyStencil::paint( KivioIntraStencilData *d, bool outlined )
{
KoZoomHandler* zoomHandler = d->zoomHandler;
PyObject *shapes = PyDict_Values( PyDict_GetItemString( vars, "shapes" ) );
if ( !shapes ) {
return;
}
int size = PyList_Size( shapes );
for ( int i=0; i<size; i++ ) {
PyObject *shape = PyList_GetItem( shapes, i );
if ( !PyDict_Check(shape) )
continue;
int fill = KivioFillStyle::kcsNone;
// if style dosn't defined for shape, applay default for stencil
setStyle( d, PyDict_GetItemString( vars, "style" ) , fill );
setStyle( d, shape, fill );
if ( isSelected() )
setStyle( d, PyDict_GetItemString( shape, "selected" ) , fill );
if ( outlined )
fill = KivioFillStyle::kcsNone;
TQString stype = getStringFromDict( shape, "type" );
stype = stype.lower();
double x = zoomHandler->zoomItX(getDoubleFromDict(shape,"x"));
double y = zoomHandler->zoomItY(getDoubleFromDict(shape,"y"));
double w = zoomHandler->zoomItX(getDoubleFromDict(shape,"w"));
double h = zoomHandler->zoomItY(getDoubleFromDict(shape,"h"));
//double x2 = zoomHandler->zoomItX(getDoubleFromDict(shape,"x2"));
//double y2 = zoomHandler->zoomItY(getDoubleFromDict(shape,"y2"));
// get points list
TQPtrList<KivioPoint> points;
points.setAutoDelete(true);
PyObject *pyPoints = PyDict_GetItemString( shape, "points" );
if ( pyPoints && PyList_Check(pyPoints) ) {
int size = PyList_Size(pyPoints);
for ( int i=0; i<size; i++ ) {
PyObject *pyPoint = PyList_GetItem(pyPoints,i);
double x = zoomHandler->zoomItX(getDoubleFromDict(pyPoint,"x"));
double y = zoomHandler->zoomItY(getDoubleFromDict(pyPoint,"y"));
points.append( new KivioPoint( x, y, KivioPoint::kptNormal ) );
}
}
if ( stype == "rectangle" ) {
if (fill)
d->painter->fillRect( x, y, w, h );
else
d->painter->drawRect( x, y, w, h );
}
if ( stype == "textbox" ) {
int tf = vTextAlign() | hTextAlign();
TQFont f = textFont();
f.setPointSizeFloat(f.pointSizeFloat() * (((float)zoomHandler->zoom()) / 100.0));
d->painter->setFont( f );
TQString text = getStringFromDict(shape,"text");
if ( !text.isEmpty() ) {
d->painter->drawText( int( x ), int( y ), int( w ), int( h ), tf | TQt::WordBreak, text );
}
}
if ( stype == "arc" ) {
double a1 = getDoubleFromDict(shape,"a1");
double a2 = getDoubleFromDict(shape,"a2");
d->painter->drawArc(x,y,w,h,a1,a2);
}
if ( stype == "roundrect" ) {
double rx = zoomHandler->zoomItX(getDoubleFromDict(shape,"rx"));
double ry = zoomHandler->zoomItY(getDoubleFromDict(shape,"ry"));
if (fill) {
d->painter->fillRoundRect( x, y, w, h, rx, ry );
} else {
d->painter->drawRoundRect( x, y, w, h, rx, ry );
}
}
if ( stype == "linearray" ) {
d->painter->drawLineArray(&points);
}
if ( stype == "ellipse" ) {
if (fill) {
d->painter->fillEllipse( x, y, w, h );
} else {
d->painter->drawEllipse( x, y, w, h );
}
}
if(stype == "polygon") {
d->painter->drawPolygon(&points);
}
if(stype == "polyline") {
d->painter->drawPolyline(&points);
}
}
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
pTarget->paintOutline( d );
pTarget = m_pConnectorTargets->next();
}
}
int KivioPyStencil::runPython(TQString code)
{
view = dynamic_cast<KivioView*>(KoDocument::documentList()->first()->views().getFirst());
if ( view ) {
page = view->activePage();
}
//const char *ccode = code.local8Bit().data();
const char *ccode = code.latin1();
//kdDebug(43000) << "code to run:" << endl << ccode << endl;
PyObject *v = PyRun_String( const_cast<char*>(ccode) , Py_file_input, globals, vars );
if (v == NULL) {
PyErr_Print();
return 0;
}
PyObject *f = PySys_GetObject("stdout");
int ret = 0;
if (f)
{
ret = PyFile_WriteString("\n", f);
}
if (ret)
PyErr_Clear();
Py_DECREF(v);
return 1;
}
double KivioPyStencil::getDoubleFromDict( PyObject *dict, const char *key )
{
if (!PyDict_Check(dict)) return 0.0;
PyObject *val = PyDict_GetItemString(dict,const_cast<char*>(key));
if ( val ) {
if ( PyFloat_Check(val) )
return PyFloat_AsDouble( val );
if ( PyLong_Check(val) )
return PyLong_AsLong( val );
if ( PyLong_Check(val) )
return PyLong_AsDouble( val );
}
return 0.0;
}
TQString KivioPyStencil::getStringFromDict( PyObject *dict, const char *key )
{
PyObject *val = PyDict_GetItemString(dict,const_cast<char*>(key));
if ( val && PyBytes_Check(val) )
return TQString( PyBytes_AS_STRING(val) );
return TQString("");
}
KivioCollisionType KivioPyStencil::checkForCollision( KoPoint *pPoint, double )
{
double px = pPoint->x();
double py = pPoint->y();
if( !(px < m_x + m_w &&
px >= m_x &&
py < m_y + m_h &&
py >= m_y ) )
{
return kctNone;
}
return kctBody;
}
/**
* Return a set of bits representing what resize handles are available.
*/
int KivioPyStencil::resizeHandlePositions()
{
// Calculate the resize handle positions
int mask = KIVIO_RESIZE_HANDLE_POSITION_ALL;
if( m_pProtection->at( kpWidth ) )
{
mask &= ~(krhpNE | krhpNW | krhpSW | krhpSE | krhpE | krhpW);
}
if( m_pProtection->at( kpHeight) )
{
mask &= ~(krhpNE | krhpNW | krhpSW | krhpSE | krhpN | krhpS);
}
return mask;
}
/**
* Paints the connector targets of this stencil.
*/
void KivioPyStencil::paintConnectorTargets( KivioIntraStencilData *pData )
{
TQPixmap targetPic;
KivioPainter *painter;
double x, y;
// We don't draw these if we are selected!!!
if( isSelected() )
return;
// Obtain the graphic used for KivioConnectorTargets
targetPic = Kivio::connectorTargetPixmap();
KoZoomHandler* zoomHandler = pData->zoomHandler;
painter = pData->painter;
KivioConnectorTarget *pTarget;
pTarget = m_pConnectorTargets->first();
while( pTarget )
{
x = zoomHandler->zoomItX(pTarget->x());
y = zoomHandler->zoomItY(pTarget->y());
painter->drawPixmap( x-3, y-3, targetPic );
pTarget = m_pConnectorTargets->next();
}
}
/**
* Attempts to connect a KivioConnectorPoint to this stencil.
*
* This function will attempt to locate a KivioConnectorTarget in this
* stencil with-in a given threshold. If it finds it, it will connect
* the point to it, and return the target of the connection.
*/
KivioConnectorTarget *KivioPyStencil::connectToTarget( KivioConnectorPoint *p, double threshHold )
{
double px = p->x();
double py = p->y();
double tx, ty;
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
tx = pTarget->x();
ty = pTarget->y();
if( px >= tx - threshHold &&
px <= tx + threshHold &&
py >= ty - threshHold &&
py <= ty + threshHold )
{
// setTarget calls pTarget->addConnectorPoint() and removes
// any previous connections from p
p->setTarget( pTarget );
return pTarget;
}
pTarget = m_pConnectorTargets->next();
}
return NULL;
}
KivioConnectorTarget *KivioPyStencil::connectToTarget( KivioConnectorPoint *p, int /*targetID*/ )
{
int id = p->targetId();
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
if( pTarget->id() == id )
{
p->setTarget(pTarget);
return pTarget;
}
pTarget = m_pConnectorTargets->next();
}
return NULL;
}
int KivioPyStencil::generateIds( int nextAvailable )
{
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
// Iterate through all the targets
while( pTarget )
{
// If this target has something connected to it
if( pTarget->hasConnections() )
{
// Set it's id to the next available id
pTarget->setId( nextAvailable );
// Increment the next available id
nextAvailable++;
}
else
{
// Otherwise mark it as unused (-1)
pTarget->setId( -1 );
}
pTarget = m_pConnectorTargets->next();
}
// Return the next availabe id
return nextAvailable;
}
void KivioPyStencil::setStyle( KivioIntraStencilData *d, PyObject *s, int &fillStyle )
{
if ( !s )
return;
if ( !PyDict_Check(s) )
return;
KivioPainter *p = d->painter;
KoZoomHandler* zoomHandler = d->zoomHandler;
PyObject *color = PyDict_GetItemString(s,"color");
if ( color ) {
TQColor c = readColor(color);
if ( c.isValid() ) {
p->setFGColor(c);
}
}
color = PyDict_GetItemString(s,"bgcolor");
if ( color ) {
TQColor c = readColor(color);
if ( c.isValid() ) {
p->setBGColor(c);
}
}
color = PyDict_GetItemString(s,"textcolor");
if ( color ) {
TQColor c = readColor(color);
if ( c.isValid() ) {
p->setTextColor(c);
}
}
PyObject *lineWidth = PyDict_GetItemString(s,"linewidth");
if ( lineWidth ) {
double lw = getDoubleFromDict(s,"linewidth");
p->setLineWidth( zoomHandler->zoomItY(lw) );
}
PyObject *o_fillStyle = PyDict_GetItemString(s,"fillstyle");
if ( o_fillStyle ) {
TQString sfill = getStringFromDict(s,"fillstyle");
if ( sfill == "solid" ) {
fillStyle = KivioFillStyle::kcsSolid;
}
if ( sfill == "none" ) {
fillStyle = KivioFillStyle::kcsNone;
}
}
TQString sfont = getStringFromDict(s,"font");
TQFont f;
int fontSize = (int)getDoubleFromDict(s,"fontsize");
if(!fontSize) {
fontSize = 12; // FIXME: Should use some kind of global setting!!!
}
f.setPointSize(fontSize);
f.setPointSizeFloat(f.pointSizeFloat() * (((float)zoomHandler->zoom()) / 100.0));
if ( !sfont.isEmpty() ) {
f.setFamily(sfont);
} else {
f.setFamily("times"); // FIXME: Should use some kind of global setting!!!
}
p->setFont(f);
}
TQColor KivioPyStencil::readColor( PyObject *color )
{
if ( !color )
return TQColor();
if ( PyBytes_Check(color) ) {
return TQColor( PyBytes_AsString(color) );
}
if ( PyList_Check(color) ) {
if ( PyList_Size(color) == 3 ) {
PyObject *ro = PyList_GetItem(color,0);
PyObject *go = PyList_GetItem(color,1);
PyObject *bo = PyList_GetItem(color,2);
int r=0, g=0, b=0;
if ( PyNumber_Check(ro) )
r = PyLong_AsLong( PyNumber_Long(ro));
if ( PyNumber_Check(go) )
g = PyLong_AsLong( PyNumber_Long(go));
if ( PyNumber_Check(bo) )
b = PyLong_AsLong( PyNumber_Long(bo));
return TQColor(r,g,b);
}
}
return TQColor();
}
void KivioPyStencil::PyDebug( PyObject * o )
{
kdDebug(43000) << "py_debug: " << PyBytes_AsString(PyObject_Str(o)) << endl;
}
TQColor KivioPyStencil::fgColor()
{
TQColor color = readColor( PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "color" ) );
if ( color.isValid() )
return color;
else
return TQColor(0,0,0);
}
void KivioPyStencil::setFGColor( TQColor c )
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "color" , Py_BuildValue("[i,i,i]", c.red(), c.green(), c.blue() ) ) ;
}
TQColor KivioPyStencil::bgColor()
{
TQColor color = readColor( PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "bgcolor" ) );
if ( color.isValid() )
return color;
else
return TQColor(0,0,0);
}
void KivioPyStencil::setBGColor( TQColor c )
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "bgcolor" , Py_BuildValue("[i,i,i]", c.red(), c.green(), c.blue() ) ) ;
}
TQColor KivioPyStencil::textColor()
{
TQColor color = readColor( PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "textcolor" ) );
if ( color.isValid() )
return color;
else
return TQColor(0,0,0);
}
void KivioPyStencil::setTextColor( TQColor c )
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "textcolor" , Py_BuildValue("[i,i,i]", c.red(), c.green(), c.blue() ) ) ;
}
double KivioPyStencil::lineWidth()
{
PyObject *lw = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "linewidth" );
if ( lw )
if ( PyNumber_Check(lw) )
return ( PyLong_AsLong( PyNumber_Long(lw)) );
return 1.0;
}
void KivioPyStencil::setLineWidth( double w )
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "linewidth" , Py_BuildValue("f",w ) ) ;
}
void KivioPyStencil::setText( const TQString &s )
{
PyObject *to = PyDict_GetItemString( PyDict_GetItemString(vars,"shapes"), "text" );
if ( to )
PyDict_SetItemString(to, "text", Py_BuildValue("s", s.latin1() ));
}
TQString KivioPyStencil::text()
{
PyObject *to = PyDict_GetItemString( PyDict_GetItemString(vars,"shapes"), "text" );
if ( to ) {
return getStringFromDict(to, "text");
}
return TQString("");
}
void KivioPyStencil::setTextFont( const TQFont &f )
{
double fs = f.pointSizeFloat();
TQString family = f.family();
int bold = f.bold();
int italic = f.italic();
int underline= f.underline();
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "fontsize" , Py_BuildValue("f",fs ) ) ;
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "font" , Py_BuildValue("s",family.latin1() ) ) ;
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "bold" , Py_BuildValue("i",bold ) ) ;
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "italic" , Py_BuildValue("i",italic ) ) ;
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "underline" , Py_BuildValue("i",underline ) ) ;
}
TQFont KivioPyStencil::textFont()
{
PyObject *fn = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "font" );
PyObject *fs = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "fontsize" );
PyObject *bd = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "bold" );
PyObject *it = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "italic" );
PyObject *ul = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "underline" );
TQFont f;
if ( fs )
if ( PyNumber_Check(fs))
f.setPointSize( PyLong_AsLong( PyNumber_Long(fs)));
if ( bd )
if ( PyNumber_Check(bd))
f.setBold( PyLong_AsLong( PyNumber_Long(bd)));
if ( it )
if ( PyNumber_Check(it))
f.setItalic( PyLong_AsLong( PyNumber_Long(it)));
if ( ul )
if ( PyNumber_Check(ul))
f.setUnderline( PyLong_AsLong( PyNumber_Long(ul)));
if ( fn )
if ( PyBytes_Check(fn))
f.setFamily( PyBytes_AsString(fn));
return f;
}
int KivioPyStencil::hTextAlign()
{
PyObject *hta = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "htextalign" );
if ( hta )
if ( PyNumber_Check(hta) )
return ( PyLong_AsLong( PyNumber_Long(hta)));
return TQt::AlignHCenter;
}
int KivioPyStencil::vTextAlign()
{
PyObject *vta = PyDict_GetItemString( PyDict_GetItemString(vars,"style"), "vtextalign" );
if ( vta )
if ( PyNumber_Check(vta) )
return ( PyLong_AsLong( PyNumber_Long(vta)));
return TQt::AlignVCenter;
}
void KivioPyStencil::setHTextAlign(int hta)
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "htextalign" , Py_BuildValue("i",hta));
}
void KivioPyStencil::setVTextAlign(int vta)
{
PyDict_SetItemString( PyDict_GetItemString(vars,"style") , "vtextalign" , Py_BuildValue("i",vta));
}
#endif // HAVE_PYTHON
View Git Blame Copy Permalink