kivio_py_stencil.cpp

 
#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;
}
 
 
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) );
  }
}
 
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;
 
}
 
 
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;
}
 
 
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();
  }
}
 
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