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 'f0b641b9e1'
${ noResults }
koffice/kivio/kiviopart/kiviosdk/kivio_sml_stencil.cpp

2229 lines
54 KiB
Raw Blame History

/*
* Kivio - Visual Modelling and Flowcharting
* Copyright (C) 2000-2003 theKompany.com & Dave Marotti
* Peter Simonsson
*
* 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.
*
* This program 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 General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#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_screen_painter.h"
#include "kivio_shape.h"
#include "kivio_shape_data.h"
#include "kivio_sml_stencil.h"
#include "kivio_dia_stencil_spawner.h"
#include "kivio_sml_stencil_spawner.h"
#include "kivio_stencil_spawner.h"
#include "kivio_stencil_spawner_info.h"
#include "kivio_stencil_spawner_set.h"
#include <tqdom.h>
#include <tqpainter.h>
#include <tqbrush.h>
#include <tqcolor.h>
#include <tqpalette.h>
#include <tqrect.h>
#include <tqbitmap.h>
#include <kdebug.h>
#include <KoGlobal.h>
#include <math.h>
#include <KoZoomHandler.h>
/**
* Default constructor
*
* Allocates a new shape list, connector targets, and original connector targets.
*/
KivioSMLStencil::KivioSMLStencil()
: KivioStencil(),
m_pShapeList(NULL),
m_pSubSelection(NULL),
m_pConnectorTargets(NULL)
{
m_pShapeList = new TQPtrList<KivioShape>;
m_pShapeList->setAutoDelete(true);
m_pConnectorTargets = new TQPtrList<KivioConnectorTarget>;
m_pConnectorTargets->setAutoDelete(true);
}
/**
* Destructor
*
* Deletes the allocated objects.
*/
KivioSMLStencil::~KivioSMLStencil()
{
delete m_pShapeList;
m_pShapeList = 0;
delete m_pConnectorTargets;
m_pConnectorTargets = 0;
m_pSubSelection = 0;
}
/**
* Loads a KivioSMLStencil from an XML node.
*/
bool KivioSMLStencil::loadXML( const TQDomElement &e )
{
TQDomNode node;
TQDomElement ele;
node = e.firstChild();
while( !node.isNull() )
{
TQString nodeName = node.nodeName();
ele = node.toElement();
if( nodeName == "Position" )
{
m_x = XmlReadFloat( ele, "x", 0.0f );
m_y = XmlReadFloat( ele, "y", 0.0f );
}
else if( nodeName == "Dimension" )
{
m_w = XmlReadFloat( ele, "w", 0.0f );
m_h = XmlReadFloat( ele, "h", 0.0f );
}
else if( nodeName == "KivioShape" )
{
// Locate the shape we are supposed to load into
KivioShape *pShape = locateShape( XmlReadString( ele, "name", "" ) );
if(pShape) {
pShape->loadXML( ele );
}
}
else if( nodeName == "KivioConnectorTargetList" )
{
loadConnectorTargetListXML( ele );
}
node = node.nextSibling();
}
return true;
}
/**
* Help function for loading from an XML node.
*/
void KivioSMLStencil::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->setOffsets((pTarget->x() - x()) / w(), (pTarget->y() - y()) / h());
pTarget = m_pConnectorTargets->next();
}
node = node.nextSibling();
}
while(!node.isNull()) {
nodeName = node.nodeName();
ele = node.toElement();
if( nodeName == "KivioConnectorTarget" )
{
pTarget = new KivioConnectorTarget();
pTarget->loadXML( ele );
pTarget->setOffsets((pTarget->x() - x()) / w(), (pTarget->y() -y()) / h());
m_pConnectorTargets->append(pTarget);
}
node = node.nextSibling();
}
}
/**
* Locates a shape in the shape list by name.
*/
KivioShape *KivioSMLStencil::locateShape( const TQString &name )
{
KivioShape *pShape;
if( name.isEmpty() )
return NULL;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->name() == name )
{
return pShape;
}
pShape = m_pShapeList->next();
}
return NULL;
}
/**
* Saves this object to an XMLELement
*/
TQDomElement KivioSMLStencil::saveXML( TQDomDocument &doc )
{
TQDomElement e = doc.createElement("KivioSMLStencil");
XmlWriteString( e, "id", m_pSpawner->info()->id() );
XmlWriteString( e, "setId", m_pSpawner->set()->id() );
// The positions
TQDomElement posE = doc.createElement("Position");
XmlWriteFloat( posE, "x", m_x );
XmlWriteFloat( posE, "y", m_y );
e.appendChild( posE );
// The dimensions
TQDomElement dimE = doc.createElement("Dimension");
XmlWriteFloat( dimE, "w", m_w );
XmlWriteFloat( dimE, "h", m_h );
e.appendChild( dimE );
// 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 );
// The shape list
KivioShape *pShape = m_pShapeList->first();
while( pShape )
{
e.appendChild( pShape->saveXML(doc ) );
pShape = m_pShapeList->next();
}
return e;
}
/**
* Duplicates this object.
*
* Duplicates all aspects of this object except for the
* stencil connected to the targets.
*/
KivioStencil *KivioSMLStencil::duplicate()
{
KivioSMLStencil *pNewStencil = new KivioSMLStencil();
KivioStencil *pReturn;
KivioShape *pShape, *pNewShape;
pNewStencil->m_x = m_x;
pNewStencil->m_y = m_y;
pNewStencil->m_w = m_w;
pNewStencil->m_h = m_h;
pNewStencil->m_rotation = m_rotation;
pNewStencil->m_pSpawner = m_pSpawner;
// Copy the shape list
pShape = m_pShapeList->first();
while( pShape )
{
pNewShape = new KivioShape( *pShape );
pNewStencil->m_pShapeList->append( pNewShape );
pShape = m_pShapeList->next();
}
// Copy the Connector Targets
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget ) //&& pOriginal )
{
pNewStencil->m_pConnectorTargets->append( pTarget->duplicate() );
pTarget = m_pConnectorTargets->next();
}
*(pNewStencil->protection()) = *m_pProtection;
*(pNewStencil->canProtect()) = *m_pCanProtect;
pReturn = pNewStencil;
return pReturn;
}
/**
* Paint the outline of the stencil.
*/
void KivioSMLStencil::paintOutline( KivioIntraStencilData *pData )
{
KivioShape *pShape;
KivioShapeData *pShapeData;
m_zoomHandler = pData->zoomHandler;
pData->painter->saveState();
pData->painter->setTranslation(m_zoomHandler->zoomItX(m_x), m_zoomHandler->zoomItY(m_y));
rotatePainter(pData); // Rotate the painter if needed
pShape = m_pShapeList->first();
while( pShape )
{
pShapeData = pShape->shapeData();
switch( pShapeData->shapeType() )
{
case KivioShapeData::kstArc:
drawOutlineArc( pShape, pData );
break;
case KivioShapeData::kstPie:
drawOutlinePie( pShape, pData );
break;
case KivioShapeData::kstLineArray:
drawOutlineLineArray( pShape, pData );
break;
case KivioShapeData::kstPolyline:
drawOutlinePolyline( pShape, pData );
break;
case KivioShapeData::kstPolygon:
drawOutlinePolygon( pShape, pData );
break;
case KivioShapeData::kstBezier:
drawOutlineBezier( pShape, pData );
break;
case KivioShapeData::kstRectangle:
drawOutlineRectangle( pShape, pData );
break;
case KivioShapeData::kstRoundRectangle:
drawOutlineRoundRectangle( pShape, pData );
break;
case KivioShapeData::kstEllipse:
drawOutlineEllipse( pShape, pData );
break;
case KivioShapeData::kstOpenPath:
drawOutlineOpenPath( pShape, pData );
break;
case KivioShapeData::kstClosedPath:
drawOutlineClosedPath( pShape, pData );
break;
case KivioShapeData::kstTextBox:
drawOutlineTextBox( pShape, pData );
break;
case KivioShapeData::kstNone:
default:
kdDebug(43000) << "*** KivioShape::Paint AHHHHH!!! NO SHAPE!" << endl;
break;
}
pShape = m_pShapeList->next();
}
pData->painter->restoreState();
// Now iterate through anything connected to it drawing it as an outline
KivioConnectorTarget *pTarget;
pTarget = m_pConnectorTargets->first();
while( pTarget )
{
pTarget->paintOutline( pData );
pTarget = m_pConnectorTargets->next();
}
}
void KivioSMLStencil::drawOutlineArc( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _a, _l, _x, _y, _w, _h, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
KivioPoint *pPoint;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
pPoint = pShapeData->pointList()->first();
_a = m_zoomHandler->zoomItX(pPoint->x());
_l = m_zoomHandler->zoomItY(pPoint->y());
painter = pData->painter;
painter->drawArc( _x, _y, _w, _h, _a, _l );
}
void KivioSMLStencil::drawOutlineBezier( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
painter = pData->painter;
pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pPoint2, *pPoint3, *pPoint4;
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPointArray controlPoints( 4 );
pPoint = pPointList->first();
pPoint2 = pPointList->next();
pPoint3 = pPointList->next();
pPoint4 = pPointList->next();
controlPoints.setPoint( 0, m_zoomHandler->zoomItX((pPoint->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h) );
controlPoints.setPoint( 1, m_zoomHandler->zoomItX((pPoint2->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint2->y()/defHeight)*m_h));
controlPoints.setPoint( 2, m_zoomHandler->zoomItX((pPoint3->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint3->y()/defHeight)*m_h));
controlPoints.setPoint( 3, m_zoomHandler->zoomItX((pPoint4->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint4->y()/defHeight)*m_h));
painter = pData->painter;
painter->drawBezier( controlPoints );
}
void KivioSMLStencil::drawOutlineOpenPath( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pNewPoint;
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPtrList <KivioPoint> *pNewPoints = new TQPtrList<KivioPoint>;
pNewPoints->setAutoDelete(true);
pPoint = pPointList->first();
while( pPoint )
{
pNewPoint = new KivioPoint( m_zoomHandler->zoomItX((pPoint->x()/defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h),
pPoint->pointType() );
pNewPoints->append(pNewPoint);
pPoint = pPointList->next();
}
painter = pData->painter;
painter->drawOpenPath( pNewPoints );
delete pNewPoints;
}
void KivioSMLStencil::drawOutlineClosedPath( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pNewPoint;
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPtrList <KivioPoint> *pNewPoints = new TQPtrList<KivioPoint>;
pNewPoints->setAutoDelete(true);
pPoint = pPointList->first();
while( pPoint )
{
pNewPoint = new KivioPoint( m_zoomHandler->zoomItX((pPoint->x()/defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h),
pPoint->pointType() );
pNewPoints->append(pNewPoint);
pPoint = pPointList->next();
}
painter = pData->painter;
painter->drawOpenPath( pNewPoints );
delete pNewPoints;
}
void KivioSMLStencil::drawOutlineEllipse( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _x, _y, _w, _h, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
painter = pData->painter;
painter->setFGColor( TQColor(0, 0, 0) );
painter->drawEllipse( _x, _y, _w, _h );
}
void KivioSMLStencil::drawOutlineLineArray( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _x, _y, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, (int)_x, (int)_y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->drawLineArray( arr );
}
void KivioSMLStencil::drawOutlineRectangle( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _x, _y, _w, _h, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
painter = pData->painter;
painter->setFGColor( TQColor(0, 0, 0) );
painter->drawRect( _x, _y, _w, _h );
}
void KivioSMLStencil::drawOutlineRoundRectangle( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _rx, _ry, _x, _y, _w, _h, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
KivioPoint *pPoint;
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pPoint = pShapeData->pointList()->first();
_rx = m_zoomHandler->zoomItX(pPoint->x());
_ry = m_zoomHandler->zoomItY(pPoint->y());
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
painter = pData->painter;
painter->setFGColor( TQColor(0, 0, 0) );
painter->drawRoundRect( _x, _y, _w, _h, _rx, _ry );
}
void KivioSMLStencil::drawOutlinePie( KivioShape *, KivioIntraStencilData * )
{
}
void KivioSMLStencil::drawOutlinePolygon( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _x, _y, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, (int)_x, (int)_y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->drawPolyline( arr );
}
void KivioSMLStencil::drawOutlinePolyline( KivioShape *pShape, KivioIntraStencilData *pData )
{
double _x, _y, defWidth, defHeight;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, (int)_x, (int)_y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->drawPolyline( arr );
}
void KivioSMLStencil::drawOutlineTextBox( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
int _x, _y, _w, _h;
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPosition = pShapeData->position();
KivioPoint *pDimensions = pShapeData->dimensions();
KivioPainter *painter = pData->painter;
KoZoomHandler* zoomHandler = pData->zoomHandler;
if( pShapeData->text().length() <= 0 ) {
return;
}
_x = zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
TQPixmap pix(_w, _h);
pix.fill();
TQPainter p(&pix);
TQFont f = pShapeData->textFont();
f.setPointSizeFloat(f.pointSizeFloat() * (((float)zoomHandler->zoom()) / 100.0));
p.setFont( f );
p.setPen( TQColor(0, 0, 0) );
int tf = pShapeData->vTextAlign() | pShapeData->hTextAlign();
p.drawText( 0, 0, _w, _h, tf | TQt::WordBreak, pShapeData->text() );
TQBitmap mask;
mask = pix;
pix.setMask(mask);
painter->drawPixmap(_x, _y, pix);
}
/**
* Paints the stencil
*/
void KivioSMLStencil::paint( KivioIntraStencilData *pData )
{
KivioShape *pShape;
KivioShapeData *pShapeData;
m_zoomHandler = pData->zoomHandler;
pData->painter->saveState();
pData->painter->setTranslation(m_zoomHandler->zoomItX(m_x), m_zoomHandler->zoomItY(m_y));
rotatePainter(pData); // Rotate the painter if needed
pShape = m_pShapeList->first();
while( pShape )
{
pShapeData = pShape->shapeData();
switch( pShapeData->shapeType() )
{
case KivioShapeData::kstArc:
drawArc( pShape, pData );
break;
case KivioShapeData::kstPie:
drawPie( pShape, pData );
break;
case KivioShapeData::kstLineArray:
drawLineArray( pShape, pData );
break;
case KivioShapeData::kstPolyline:
drawPolyline( pShape, pData );
break;
case KivioShapeData::kstPolygon:
drawPolygon( pShape, pData );
break;
case KivioShapeData::kstBezier:
drawBezier( pShape, pData );
break;
case KivioShapeData::kstRectangle:
drawRectangle( pShape, pData );
break;
case KivioShapeData::kstRoundRectangle:
drawRoundRectangle( pShape, pData );
break;
case KivioShapeData::kstEllipse:
drawEllipse( pShape, pData );
break;
case KivioShapeData::kstOpenPath:
drawOpenPath( pShape, pData );
break;
case KivioShapeData::kstClosedPath:
drawClosedPath( pShape, pData );
break;
case KivioShapeData::kstTextBox:
drawTextBox( pShape, pData );
break;
case KivioShapeData::kstNone:
default:
break;
}
pShape = m_pShapeList->next();
}
pData->painter->restoreState();
}
/**
* Paints the connector targets of this stencil.
*/
void KivioSMLStencil::paintConnectorTargets( KivioIntraStencilData *pData )
{
// We don't draw these if we are selected!!!
//if( isSelected() == true ) {
// return;
//}
TQPixmap targetPic;
KivioPainter *painter;
int x, y;
// Obtain the graphic used for KivioConnectorTargets
targetPic = Kivio::connectorTargetPixmap();
m_zoomHandler = pData->zoomHandler;
painter = pData->painter;
KivioConnectorTarget *pTarget;
pTarget = m_pConnectorTargets->first();
while( pTarget )
{
x = m_zoomHandler->zoomItX(pTarget->x());
y = m_zoomHandler->zoomItY(pTarget->y());
painter->drawPixmap( x-3, y-3, targetPic );
pTarget = m_pConnectorTargets->next();
}
}
void KivioSMLStencil::drawArc( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _a, _l, _x, _y, _w, _h;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
KivioPoint *pPoint;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
pPoint = pShapeData->pointList()->first();
_a = m_zoomHandler->zoomItX(pPoint->x());
_l = m_zoomHandler->zoomItY(pPoint->y());
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawArc( _x, _y, _w, _h, _a, _l );
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->drawArc( _x, _y, _w, _h, _a, _l );
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
}
void KivioSMLStencil::drawBezier( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
painter = pData->painter;
pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pPoint2, *pPoint3, *pPoint4;
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPointArray controlPoints( 4 );
pPoint = pPointList->first();
pPoint2 = pPointList->next();
pPoint3 = pPointList->next();
pPoint4 = pPointList->next();
controlPoints.setPoint( 0, m_zoomHandler->zoomItX((pPoint->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h));
controlPoints.setPoint( 1, m_zoomHandler->zoomItX((pPoint2->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint2->y()/defHeight)*m_h));
controlPoints.setPoint( 2, m_zoomHandler->zoomItX((pPoint3->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint3->y()/defHeight)*m_h));
controlPoints.setPoint( 3, m_zoomHandler->zoomItX((pPoint4->x() / defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint4->y()/defHeight)*m_h));
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
painter->drawBezier( controlPoints );
}
void KivioSMLStencil::drawOpenPath( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pNewPoint;
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPtrList <KivioPoint> *pNewPoints = new TQPtrList<KivioPoint>;
pNewPoints->setAutoDelete(true);
pPoint = pPointList->first();
while( pPoint )
{
pNewPoint = new KivioPoint( m_zoomHandler->zoomItX((pPoint->x()/defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h),
pPoint->pointType() );
pNewPoints->append(pNewPoint);
pPoint = pPointList->next();
}
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
painter->drawOpenPath( pNewPoints );
delete pNewPoints;
}
void KivioSMLStencil::drawClosedPath( KivioShape *pShape, KivioIntraStencilData *pData )
{
KivioPainter *painter;
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPoint, *pNewPoint;
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
TQPtrList <KivioPoint> *pPointList = pShapeData->pointList();
TQPtrList <KivioPoint> *pNewPoints = new TQPtrList<KivioPoint>;
pNewPoints->setAutoDelete(true);
pPoint = pPointList->first();
while( pPoint )
{
pNewPoint = new KivioPoint( m_zoomHandler->zoomItX((pPoint->x()/defWidth)*m_w),
m_zoomHandler->zoomItY((pPoint->y()/defHeight)*m_h),
pPoint->pointType() );
pNewPoints->append(pNewPoint);
pPoint = pPointList->next();
}
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawOpenPath( pNewPoints );
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->drawClosedPath( pNewPoints );
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
delete pNewPoints;
}
void KivioSMLStencil::drawPie( KivioShape *, KivioIntraStencilData * )
{
}
void KivioSMLStencil::drawEllipse( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _x, _y, _w, _h;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawEllipse( _x, _y, _w, _h );
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->fillEllipse( _x, _y, _w, _h );
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
}
void KivioSMLStencil::drawLineArray( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _x, _y;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, _x, _y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
painter->drawLineArray( arr );
}
void KivioSMLStencil::drawRectangle( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _x, _y, _w, _h;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawRect( _x, _y, _w, _h );
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->fillRect( _x, _y, _w, _h );
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
}
void KivioSMLStencil::drawRoundRectangle( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _rx, _ry, _x, _y, _w, _h;
KivioPainter *painter;
KivioShapeData *pShapeData;
KivioPoint *pPosition, *pDimensions;
KivioPoint *pPoint;
pShapeData = pShape->shapeData();
pPosition = pShapeData->position();
pDimensions = pShapeData->dimensions();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
_x = m_zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
_w = m_zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
_h = m_zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
pPoint = pShapeData->pointList()->first();
_rx = m_zoomHandler->zoomItX(pPoint->x());
_ry = m_zoomHandler->zoomItY(pPoint->y());
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawRoundRect( _x, _y, _w, _h, _rx, _ry );
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->fillRoundRect( _x, _y, _w, _h, _rx, _ry );
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
}
void KivioSMLStencil::drawPolygon( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _x, _y;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, _x, _y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
switch( pShapeData->fillStyle()->colorStyle() )
{
case KivioFillStyle::kcsNone: // Hollow
painter->drawPolygon(arr);
break;
case KivioFillStyle::kcsSolid: // Solid fill
case KivioFillStyle::kcsGradient: // Gradient
painter->setFillStyle( pShapeData->fillStyle() );
painter->drawPolygon(arr);
break;
case KivioFillStyle::kcsPixmap:
default:
break;
}
}
void KivioSMLStencil::drawPolyline( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth, defHeight;
int _x, _y;
KivioPainter *painter;
KivioShapeData *pShapeData;
TQPtrList <KivioPoint> *pList;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
TQPointArray arr( pList->count() );
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
arr.setPoint( i, _x, _y );
i++;
pPoint = pList->next();
}
painter = pData->painter;
painter->setLineStyle(pShapeData->lineStyle());
double lineWidth = pShapeData->lineStyle()->width();
painter->setLineWidth(m_zoomHandler->zoomItY(lineWidth));
painter->drawPolyline(arr);
}
void KivioSMLStencil::drawTextBox( KivioShape *pShape, KivioIntraStencilData *pData )
{
double defWidth = m_pSpawner->defWidth();
double defHeight = m_pSpawner->defHeight();
KivioShapeData *pShapeData = pShape->shapeData();
KivioPoint *pPosition = pShapeData->position();
KivioPoint *pDimensions = pShapeData->dimensions();
KivioPainter *painter = pData->painter;
KoZoomHandler* zoomHandler = pData->zoomHandler;
if(pShapeData->text().isEmpty()) {
return;
}
int _x = zoomHandler->zoomItX((pPosition->x() / defWidth) * m_w);
int _y = zoomHandler->zoomItY((pPosition->y() / defHeight) * m_h);
int _w = zoomHandler->zoomItX((pDimensions->x() / defWidth) * m_w) + 1;
int _h = zoomHandler->zoomItY((pDimensions->y() / defHeight) * m_h) + 1;
TQFont f = pShapeData->textFont();
f.setPointSizeFloat(f.pointSizeFloat() * (((float)zoomHandler->zoom()) / 100.0));
painter->setFont( f );
painter->setTextColor( pShapeData->textColor() );
int tf = pShapeData->vTextAlign() | pShapeData->hTextAlign();
painter->drawText( _x, _y, _w, _h, tf | TQt::WordBreak, pShapeData->text() );
// TODO Implement richtext support
}
/**
* Set the fg color of this stencil.
*/
void KivioSMLStencil::setFGColor( TQColor c )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->lineStyle()->setColor( c );
pShape = m_pShapeList->next();
}
}
/**
* Set the bg color of this stencil.
*/
void KivioSMLStencil::setBGColor( TQColor c )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->fillStyle()->setColor( c );
pShape = m_pShapeList->next();
}
}
void KivioSMLStencil::setFillPattern(int p)
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->fillStyle()->setBrushStyle( static_cast<TQt::BrushStyle>(p) );
pShape = m_pShapeList->next();
}
}
/**
* Set the text color of this stencil.
*/
void KivioSMLStencil::setTextColor( TQColor c )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->setTextColor( c );
pShape = m_pShapeList->next();
}
}
/**
* Set the text font of this stencil
*/
void KivioSMLStencil::setTextFont( const TQFont &f )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->setTextFont( f );
pShape = m_pShapeList->next();
}
}
/**
* Set the line width of this stencil.
*/
void KivioSMLStencil::setLineWidth( double f )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->lineStyle()->setWidth( f );
pShape = m_pShapeList->next();
}
}
void KivioSMLStencil::setLinePattern(int p)
{
KivioShape *pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->lineStyle()->setStyle( p );
pShape = m_pShapeList->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 *KivioSMLStencil::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;
}
KoPoint KivioSMLStencil::snapToTarget( const KoPoint& p, double thresh, bool& hit )
{
KoPoint retVal = p;
double tx, ty;
hit = false;
KivioConnectorTarget *pTarget = m_pConnectorTargets->first();
while( pTarget )
{
tx = pTarget->x();
ty = pTarget->y();
if( retVal.x() >= tx - thresh &&
retVal.x() <= tx + thresh &&
retVal.y() >= ty - thresh &&
retVal.y() <= ty + thresh )
{
retVal.setX(tx);
retVal.setY(ty);
hit = true;
}
pTarget = m_pConnectorTargets->next();
}
return retVal;
}
/**
* Connects a KivioConnectorPoint to this stencil via targetID.
*
* This function is called during loads, *ONLY* loads.
*/
KivioConnectorTarget *KivioSMLStencil::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;
}
/**
* Updates the geometry of this stencil.
*
* This function rearranges the KivioConnectorTargets to reflect
* that of the width/height/position.
*/
void KivioSMLStencil::updateGeometry()
{
//kdDebug(43000) << "m_x = " << m_x << " m_y = " << m_y << endl;
TQWMatrix m;
m.translate(m_x, m_y);
m.translate(m_w / 2.0, m_h / 2.0);
m.rotate(m_rotation);
m.translate(-m_w / 2.0, -m_h / 2.0);
KivioConnectorTarget* pTarget = m_pConnectorTargets->first();
while( pTarget )
{
double _x = pTarget->xOffset() * m_w;
double _y = pTarget->yOffset() * m_h;
double newX = _x * m.m11() + _y * m.m21() + m.dx();
double newY = _x * m.m12() + _y * m.m22() + m.dy();
pTarget->setPosition( newX, newY );
pTarget = m_pConnectorTargets->next();
}
}
/**
* Gets the font of this stencil
*/
TQFont KivioSMLStencil::textFont()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
return pShape->shapeData()->textFont();
}
pShape = m_pShapeList->next();
}
//return TQFont("times",12);
return KoGlobal::defaultFont();
}
TQColor KivioSMLStencil::textColor()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
return pShape->shapeData()->textColor();
}
pShape = m_pShapeList->next();
}
return TQColor(0, 0, 0);
}
/**
* Sets the horizontal alignemnt of this stencil.
*/
void KivioSMLStencil::setHTextAlign(int i)
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
pShape->shapeData()->setHTextAlign( i );
pShape = m_pShapeList->next();
}
}
/**
* Set the vertical alignment of this stencil
*/
void KivioSMLStencil::setVTextAlign(int i)
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
pShape->shapeData()->setVTextAlign( i );
pShape = m_pShapeList->next();
}
}
/**
* Get the horizontal alignment of this stencil.
*/
int KivioSMLStencil::hTextAlign()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
return pShape->shapeData()->hTextAlign();
}
pShape = m_pShapeList->next();
}
return 1;
}
/**
* Get the vertical text alignment of this stencil.
*/
int KivioSMLStencil::vTextAlign()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
return pShape->shapeData()->vTextAlign();
}
pShape = m_pShapeList->next();
}
return 1;
}
/**
* Get the text of this stencil
*/
TQString KivioSMLStencil::text()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
return pShape->shapeData()->text();
}
pShape = m_pShapeList->next();
}
return TQString("");
}
/**
* Set the text of this stencil
*/
void KivioSMLStencil::setText( const TQString &t )
{
KivioShape *pShape;
pShape = m_pShapeList->first();
while( pShape )
{
if( pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox )
{
pShape->shapeData()->setText(t);
}
pShape = m_pShapeList->next();
}
}
/**
* Get the line width of this stencil
*/
double KivioSMLStencil::lineWidth()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
if( pShape )
return pShape->shapeData()->lineStyle()->width();
return 1.0f;
}
int KivioSMLStencil::linePattern()
{
KivioShape *pShape = m_pShapeList->first();
if( pShape )
return pShape->shapeData()->lineStyle()->style();
return 1;
}
/**
* Get the Fg color of a stencil
*/
TQColor KivioSMLStencil::fgColor()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
if( pShape )
return pShape->shapeData()->lineStyle()->color();
return TQColor(0,0,0);
}
/**
* Get the bg color of this stencil.
*/
TQColor KivioSMLStencil::bgColor()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
if( pShape )
return pShape->shapeData()->fillStyle()->color();
return TQColor(0,0,0);
}
int KivioSMLStencil::fillPattern()
{
KivioShape *pShape;
pShape = m_pShapeList->first();
if( pShape )
return pShape->shapeData()->fillStyle()->brushStyle();
return 1;
}
/**
* Generates the ids for anything needed by this stencil
*/
int KivioSMLStencil::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;
}
/**
* Check for a collision in this stencil.
*/
KivioCollisionType KivioSMLStencil::checkForCollision( KoPoint *pPoint, double )
{
KivioCollisionType type = kctNone;
TQWMatrix m;
m.translate(m_x, m_y);
m.translate(m_w / 2.0, m_h / 2.0);
m.rotate(m_rotation);
m.translate(-m_w / 2.0, -m_h / 2.0);
KoPoint pPoints[4];
pPoints[0].setX(0 * m.m11() + 0 * m.m21() + m.dx());
pPoints[0].setY(0 * m.m12() + 0 * m.m22() + m.dy());
pPoints[1].setX(m_w * m.m11() + 0 * m.m21() + m.dx());
pPoints[1].setY(m_w * m.m12() + 0 * m.m22() + m.dy());
pPoints[2].setX(m_w * m.m11() + m_h * m.m21() + m.dx());
pPoints[2].setY(m_w * m.m12() + m_h * m.m22() + m.dy());
pPoints[3].setX(0 * m.m11() + m_h * m.m21() + m.dx());
pPoints[3].setY(0 * m.m12() + m_h * m.m22() + m.dy());
if(PointInPoly(pPoints, 4, pPoint)) {
type = kctBody;
}
return type;
}
bool KivioSMLStencil::checkCollisionArc( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionBezier( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionOpenPath( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionClosedPath( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionPie( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionEllipse( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionLineArray( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionRectangle( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionRoundRectangle( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionPolygon( KivioShape *pShape, KoPoint *pCheckPoint )
{
double _x, _y, defWidth, defHeight;
KivioShapeData *pShapeData;
TQPtrList<KivioPoint> *pList;
KoPoint *pPoints;
pShapeData = pShape->shapeData();
defWidth = m_pSpawner->defWidth();
defHeight = m_pSpawner->defHeight();
pList = pShapeData->pointList();
pPoints = new KoPoint[pList->count()];
KivioPoint *pPoint;
int i=0;
pPoint = pList->first();
while( pPoint )
{
_x = m_zoomHandler->zoomItX((pPoint->x() / defWidth) * m_w);
_y = m_zoomHandler->zoomItY((pPoint->y() / defHeight) * m_h);
pPoints[i].setX(_x);
pPoints[i].setY(_y);
i++;
pPoint = pList->next();
}
if( PointInPoly( pPoints, i, pCheckPoint ) )
{
delete [] pPoints;
return true;
}
delete [] pPoints;
return false;
}
bool KivioSMLStencil::checkCollisionPolyline( KivioShape *, KoPoint * )
{
return false;
}
bool KivioSMLStencil::checkCollisionTextBox( KivioShape *, KoPoint * )
{
return false;
}
/**
* Return a set of bits representing what resize handles are available.
*/
int KivioSMLStencil::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);
}
if( m_pProtection->at( kpAspect ) )
{
mask = KIVIO_RESIZE_HANDLE_POSITION_CORNERS;
}
return mask;
}
KivioLineStyle KivioSMLStencil::lineStyle()
{
KivioShape *pShape = m_pShapeList->first();
if( pShape )
return *(pShape->shapeData()->lineStyle());
return KivioLineStyle();
}
void KivioSMLStencil::setLineStyle(KivioLineStyle ls)
{
KivioShape *pShape = m_pShapeList->first();
while( pShape )
{
pShape->shapeData()->setLineStyle(ls);;
pShape = m_pShapeList->next();
}
}
TQString KivioSMLStencil::getTextBoxName(const KoPoint& p)
{
KivioShape* pShape = m_pShapeList->first();
KivioShape* first = 0;
KoPoint pos = p;
// Calculate the rotation...
TQWMatrix m;
m.translate(m_x, m_y);
m.translate(m_w / 2.0, m_h / 2.0);
m.rotate(m_rotation);
m.translate(-m_w / 2.0, -m_h / 2.0);
while(pShape)
{
if(pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox)
{
double x = pShape->shapeData()->x();
double y = pShape->shapeData()->y();
double x2 = pShape->shapeData()->w() + x;
double y2 = pShape->shapeData()->h() + y;
// Create the rotated rectangle
KoPoint pPoints[4];
pPoints[0].setX(x * m.m11() + y * m.m21() + m.dx());
pPoints[0].setY(x * m.m12() + y * m.m22() + m.dy());
pPoints[1].setX(x2 * m.m11() + y * m.m21() + m.dx());
pPoints[1].setY(x2 * m.m12() + y * m.m22() + m.dy());
pPoints[2].setX(x2 * m.m11() + y2 * m.m21() + m.dx());
pPoints[2].setY(x2 * m.m12() + y2 * m.m22() + m.dy());
pPoints[3].setX(x * m.m11() + y2 * m.m21() + m.dx());
pPoints[3].setY(x * m.m12() + y2 * m.m22() + m.dy());
if(PointInPoly(pPoints, 4, &pos)) {
return pShape->shapeData()->name();
}
if(!first) {
first = pShape;
}
}
pShape = m_pShapeList->next();
}
if(first) {
return first->shapeData()->name();
}
return TQString();
}
void KivioSMLStencil::setText(const TQString& text, const TQString& name)
{
KivioShape* pShape = m_pShapeList->first();
while(pShape)
{
if(pShape->shapeData()->name() == name)
{
pShape->shapeData()->setText(text);
return;
}
pShape = m_pShapeList->next();
}
}
TQString KivioSMLStencil::text(const TQString& name)
{
KivioShape* pShape = m_pShapeList->first();
while(pShape)
{
if(pShape->shapeData()->name() == name)
{
return pShape->shapeData()->text();
}
pShape = m_pShapeList->next();
}
return TQString();
}
void KivioSMLStencil::addConnectorTarget(const KoPoint& p)
{
KivioConnectorTarget* target = new KivioConnectorTarget(p.x(), p.y(), (p.x() - x())/ w(), (p.y() - y())/ h());
m_pConnectorTargets->append(target);
}
void KivioSMLStencil::removeConnectorTarget(const KoPoint& pos)
{
KivioConnectorTarget* target = m_pConnectorTargets->first();
while(target)
{
if(target->position() == pos)
{
m_pConnectorTargets->remove(target);
return;
}
target = m_pConnectorTargets->next();
}
}
bool KivioSMLStencil::hasTextBox() const
{
KivioShape* pShape = m_pShapeList->first();
while(pShape) {
if(pShape->shapeData()->shapeType() == KivioShapeData::kstTextBox) {
return true;
}
pShape = m_pShapeList->next();
}
return false;
}
TQColor KivioSMLStencil::textColor(const TQString& textBoxName)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape)
return textColor();
return shape->shapeData()->textColor();
}
void KivioSMLStencil::setTextColor(const TQString& textBoxName, const TQColor& color)
{
KivioShape* shape = locateShape(textBoxName);
// If we didn't find the shape set the color stencil wide
if(!shape) {
setTextColor(color);
return;
}
shape->shapeData()->setTextColor(color);
}
TQFont KivioSMLStencil::textFont(const TQString& textBoxName)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape)
return textFont();
return shape->shapeData()->textFont();
}
void KivioSMLStencil::setTextFont(const TQString& textBoxName, const TQFont& font)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape) {
setTextFont(font);
return;
}
shape->shapeData()->setTextFont(font);
}
int KivioSMLStencil::hTextAlign(const TQString& textBoxName)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape)
return hTextAlign();
return shape->shapeData()->hTextAlign();
}
int KivioSMLStencil::vTextAlign(const TQString& textBoxName)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape)
return vTextAlign();
return shape->shapeData()->vTextAlign();
}
void KivioSMLStencil::setHTextAlign(const TQString& textBoxName, int align)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape) {
setHTextAlign(align);
return;
}
shape->shapeData()->setHTextAlign(align);
}
void KivioSMLStencil::setVTextAlign(const TQString& textBoxName, int align)
{
KivioShape* shape = locateShape(textBoxName);
if(!shape) {
setVTextAlign(align);
return;
}
shape->shapeData()->setVTextAlign(align);
}
View Git Blame Copy Permalink