From 8362bf63dea22bbf6736609b0f49c152f975eb63 Mon Sep 17 00:00:00 2001 From: tpearson Date: Wed, 20 Jan 2010 01:29:50 +0000 Subject: Added old abandoned KDE3 version of koffice git-svn-id: svn://anonsvn.kde.org/home/kde/branches/trinity/applications/koffice@1077364 283d02a7-25f6-0310-bc7c-ecb5cbfe19da --- kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp | 1011 +++++++++++++++++++++++++ 1 file changed, 1011 insertions(+) create mode 100644 kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp (limited to 'kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp') diff --git a/kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp b/kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp new file mode 100644 index 00000000..9971f5f7 --- /dev/null +++ b/kivio/kiviopart/kiviosdk/kivio_1d_stencil.cpp @@ -0,0 +1,1011 @@ +/* + * Kivio - Visual Modelling and Flowcharting + * Copyright (C) 2000-2001 theKompany.com & Dave Marotti + * + * 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. + */ + +/* + * Implementing a connector involves deriving from this class. + * + * You need to implement the following routines: + * setStartPoint + * setEndPoint + * checkForCollision + * duplicate + * paint + * paintOutline + * saveXML + * loadXML + * + * Save and Load should call saveConnectors, loadConnectors, saveProperties, and + * loadProperties. These are helper functions which take care of the common + * acts of saving/loading connectors and colors/line-styles, etc... + * + */ + +#include "kivio_1d_stencil.h" +#include "kivio_arrowhead.h" +#include "kivio_common.h" +#include "kivio_connector_point.h" +#include "kivio_custom_drag_data.h" +#include "kivio_fill_style.h" +#include "kivio_intra_stencil_data.h" +#include "kivio_layer.h" +#include "kivio_line_style.h" +#include "kivio_page.h" +#include "kivio_painter.h" +#include "kivio_point.h" +#include "kivio_stencil.h" +#include "kivio_stencil_spawner.h" +#include "kivio_stencil_spawner_info.h" +#include "kivio_stencil_spawner_set.h" +#include "kivio_text_style.h" +#include "kivio_connector_target.h" + +#include +#include +#include + +#include +#include + +/** + * Default constructor. + * + * This will allocate a new fill style object, a list for + * connection points, and set some default values. + */ +Kivio1DStencil::Kivio1DStencil() + : KivioStencil() +{ + m_pFillStyle = new KivioFillStyle(); + m_pLineStyle = new KivioLineStyle(); + m_pTextStyle = new KivioTextStyle(); + + m_pConnectorPoints = new QPtrList; + m_pConnectorPoints->setAutoDelete(true); + + m_pStart = new KivioConnectorPoint(this, true); + m_pStart->setPosition(72.0f, 18.0f, false); + + m_pEnd = new KivioConnectorPoint(this, true); + m_pEnd->setPosition(0.0f, 18.0f, false); + + m_pLeft = new KivioConnectorPoint(this, false); + m_pLeft->setPosition(36.0f, 36.0f, false); + + m_pRight = new KivioConnectorPoint(this, false); + m_pRight->setPosition(36.0f, 0.0f, false); + + m_pTextConn = new KivioConnectorPoint(this, false); + m_pTextConn->setPosition(36.0f, 18.0f, false); + + m_connectorWidth = 36.0f; + m_needsWidth = true; + m_needsText = false; + + m_pConnectorPoints->append( m_pStart ); + m_pConnectorPoints->append( m_pEnd ); + m_pConnectorPoints->append( m_pLeft ); + m_pConnectorPoints->append( m_pRight ); + m_pConnectorPoints->append( m_pTextConn ); +} + + +/** + * Destructor + */ +Kivio1DStencil::~Kivio1DStencil() +{ + delete m_pFillStyle; + delete m_pLineStyle; + delete m_pTextStyle; + delete m_pConnectorPoints; +} + +void Kivio1DStencil::setFGColor( QColor c ) +{ + m_pLineStyle->setColor(c); +} + +QColor Kivio1DStencil::fgColor() +{ + return m_pLineStyle->color(); +} + +void Kivio1DStencil::setLineWidth( double f ) +{ + m_pLineStyle->setWidth(f); +} + +double Kivio1DStencil::lineWidth() +{ + return m_pLineStyle->width(); +} + +void Kivio1DStencil::setLinePattern(int p) +{ + m_pLineStyle->setStyle(p); +} + +int Kivio1DStencil::linePattern() +{ + return m_pLineStyle->style(); +} + +void Kivio1DStencil::setFillPattern(int p) +{ + m_pFillStyle->setBrushStyle(static_cast(p)); +} + +int Kivio1DStencil::fillPattern() +{ + return m_pFillStyle->brushStyle(); +} + +void Kivio1DStencil::setBGColor( QColor c ) +{ + m_pFillStyle->setColor(c); +} + +QColor Kivio1DStencil::bgColor() +{ + return m_pFillStyle->color(); +} + + +///////////////////////////////// +// Position functions +///////////////////////////////// +void Kivio1DStencil::setX( double x ) +{ + double dx = x - m_x; + KivioConnectorPoint *p = m_pConnectorPoints->first(); + + while( p ) + { + p->disconnect(); + p->setX( p->x() + dx, false ); + p = m_pConnectorPoints->next(); + } + + m_x = x; +} + +void Kivio1DStencil::setY( double y ) +{ + double dy = y - m_y; + KivioConnectorPoint *p = m_pConnectorPoints->first(); + + while( p ) + { + p->disconnect(); + p->setY( p->y() + dy, false ); + p = m_pConnectorPoints->next(); + } + + m_y = y; +} + +void Kivio1DStencil::setPosition( double x, double y ) +{ + double dx = x - m_x; + double dy = y - m_y; + + m_x += dx; + m_y += dy; + + KivioConnectorPoint *p = m_pConnectorPoints->first(); + while( p ) + { + p->setPosition( p->x()+dx, p->y()+dy, false ); + p->disconnect(); + + p = m_pConnectorPoints->next(); + } + + + m_x = x; + m_y = y; +} + + + +///////////////////////////// +// Connection tool functions +///////////////////////////// +void Kivio1DStencil::setStartPoint( double x, double y ) +{ + double oldX = m_pStart->x(); + double oldY = m_pStart->y(); + + m_pStart->setPosition(x, y, false); + m_pStart->disconnect(); + + updateConnectorPoints(m_pStart, oldX, oldY); +} + + +void Kivio1DStencil::setEndPoint( double x, double y ) +{ + double oldX = m_pEnd->x(); + double oldY = m_pEnd->y(); + + m_pEnd->setPosition(x, y, false); + m_pEnd->disconnect(); + + updateConnectorPoints(m_pEnd, oldX, oldY); +} + +void Kivio1DStencil::updateConnectorPoints( KivioConnectorPoint *p, double /*oldX*/, double /*oldY*/ ) +{ + // If p is the start or end, we need to adjust the width connectors + if( p == m_pStart || p == m_pEnd ) + { + double vx = m_pStart->x() - m_pEnd->x(); + double vy = m_pStart->y() - m_pEnd->y(); + double len = sqrt( vx*vx + vy*vy ); + double midX = (m_pStart->x() + m_pEnd->x())/2.0f; + double midY = (m_pStart->y() + m_pEnd->y())/2.0f; + + vx /= len; + vy /= len; + + double d = m_connectorWidth/2.0f; + + m_pLeft->setPosition( midX + d*vy, midY + d*(-vx), false ); + m_pRight->setPosition( midX + d*(-vy), midY + d*vx, false ); + } + + updateGeometry(); +} + + +void Kivio1DStencil::paint( KivioIntraStencilData * ) +{ + /* Derived class must implement this */ +} + +void Kivio1DStencil::paintOutline( KivioIntraStencilData *pData ) +{ + /* Derived class should implement this */ + paint( pData ); +} + +void Kivio1DStencil::paintConnectorTargets( KivioIntraStencilData * ) +{ +} + +void Kivio1DStencil::paintSelectionHandles( KivioIntraStencilData *pData ) +{ + KivioPainter *painter = pData->painter; + double x1, y1; + int flag; + + KoZoomHandler* zoomHandler = pData->zoomHandler; + + KivioConnectorPoint *p = m_pConnectorPoints->first(); + while( p ) + { + // If we don't need width connectors and we are on a width connector, + // ignore it. + x1 = zoomHandler->zoomItX(p->x()); + y1 = zoomHandler->zoomItY(p->y()); + + flag = (p->target()) ? KivioPainter::cpfConnected : 0; + + if( p==m_pTextConn ) + { + if( m_needsText==true ) + { + painter->drawHandle( x1, y1, 0 ); + } + } + else if( p==m_pLeft || p==m_pRight ) + { + if( m_needsWidth==true ) + { + painter->drawHandle( x1, y1, 0 ); + } + } + else if( p==m_pStart ) + { + painter->drawHandle( x1, y1, KivioPainter::cpfStart | flag ); + } + else if( p==m_pEnd ) + { + painter->drawHandle( x1, y1, KivioPainter::cpfEnd | flag ); + } + else + { + if( p->connectable() ) { + painter->drawHandle( x1, y1, KivioPainter::cpfConnectable | flag ); + } else { + painter->drawHandle( x1, y1, flag ); + } + } + + p = m_pConnectorPoints->next(); + } +} + + + +/////////////////////////////// +// Collision detection +/////////////////////////////// +KivioCollisionType Kivio1DStencil::checkForCollision( KoPoint *, double ) +{ + /* Derived class must implement this */ + + return kctNone; +} + + + + +///////////////////////////////// +// Custom dragging +///////////////////////////////// +/** + * Custom drag the connector points. + * + * The default action of this function is to locate the point + * in the connector list by the id and then drag it around. + * Then attempt to snap it to another stencil. Otherwise + * disconnect it. + */ +void Kivio1DStencil::customDrag( KivioCustomDragData *pData ) +{ + setCustomIDPoint(pData->id, KoPoint(pData->x, pData->y), pData->page); +} + + +/** + * Sets the position and dimensions of this stencil based on its connection points. + */ +void Kivio1DStencil::updateGeometry() +{ + double minX, minY, maxX, maxY; + + minX = 1000000000000.0f; + minY = minX; + maxX = -100000000000.0f; + maxY = maxX; + + + KivioConnectorPoint *p; + p = m_pConnectorPoints->first(); + while( p ) + { + if( p->x() < minX ) + minX = p->x(); + if( p->x() > maxX ) + maxX = p->x(); + if( p->y() < minY ) + minY = p->y(); + if( p->y() > maxY ) + maxY = p->y(); + + p = m_pConnectorPoints->next(); + } + + + m_x = minX; + m_y = minY; + m_w = maxX - minX + 1.0f; + m_h = maxY - minY + 1.0f; +} + + + +// file i/o routines +bool Kivio1DStencil::loadXML( const QDomElement &e ) +{ + QDomNode node; + QString name; + + node = e.firstChild(); + while( !node.isNull() ) + { + name = node.nodeName(); + + if( name == "KivioStencilProperties" ) + { + loadProperties(node.toElement() ); + } + + node = node.nextSibling(); + } + + updateGeometry(); + + return true; +} + + +QDomElement Kivio1DStencil::createRootElement( QDomDocument &doc ) +{ + QDomElement e = doc.createElement("KivioPluginStencil"); + + XmlWriteString( e, "id", m_pSpawner->info()->id() ); + XmlWriteString( e, "setId", m_pSpawner->set()->id() ); + + return e; +} + + +QDomElement Kivio1DStencil::saveXML( QDomDocument &doc ) +{ + QDomElement e = createRootElement(doc); + + e.appendChild( saveProperties(doc) ); + + return e; +} + + + +KivioStencil *Kivio1DStencil::duplicate() +{ + /* Derived class must implement this function */ + return NULL; +} + + +bool Kivio1DStencil::boolAllTrue( bool *boolArray, int count ) +{ + int i; + + for( i=0; icount()]; + unsigned int i; + + for(i = 0; i < m_pConnectorPoints->count(); i++) { + done[i] = false; + } + + KivioConnectorPoint *p; + i = 0; + p = m_pConnectorPoints->first(); + + while( p ) + { + if( p->targetId() == -1 ) { + done[i] = true; + } + + i++; + p = m_pConnectorPoints->next(); + } + + // No connections? BaiL! + if( boolAllTrue( done, m_pConnectorPoints->count() ) ) + { + delete [] done; + return; + } + + KivioLayer *pLayer = pPage->firstLayer(); + + while( pLayer && ( boolContainsFalse(done, m_pConnectorPoints->count()) ) ) + { + KivioStencil *pStencil = pLayer->firstStencil(); + + while( pStencil && ( boolContainsFalse(done, m_pConnectorPoints->count()) ) ) + { + // No connecting to ourself! + if((pStencil != this)) + { + + // Iterate through all connectors attempting to connect it to the stencil. + // If it connects, mark it as done + i=0; + p = m_pConnectorPoints->first(); + while( p ) + { + if( !done[i] && p->targetId() != -1 ) + { + if(pStencil->connectToTarget( p, p->targetId())) + { + done[i] = true; + } + } + + i++; + p = m_pConnectorPoints->next(); + } + + } + + pStencil = pLayer->nextStencil(); + } + + pLayer = pPage->nextLayer(); + } + + delete [] done; +} + +void Kivio1DStencil::searchForConnections( KivioPage *pPage, double threshold ) +{ + bool *done = new bool[ m_pConnectorPoints->count()]; + int i; + + for( i=0; i<(int)m_pConnectorPoints->count(); i++ ) { + done[i] = false; + } + + KivioConnectorPoint *p; + i = 0; + p = m_pConnectorPoints->first(); + + while( p ) + { + if(p->target() != 0L) { + done[i] = true; + } + + i++; + p = m_pConnectorPoints->next(); + } + + // No connections? BaiL! + if( boolAllTrue( done, m_pConnectorPoints->count() ) ) + { + delete [] done; + return; + } + + KivioLayer *pLayer = pPage->firstLayer(); + + while( pLayer && ( boolContainsFalse(done, m_pConnectorPoints->count()) ) ) + { + KivioStencil *pStencil = pLayer->firstStencil(); + + while( pStencil && ( boolContainsFalse(done, m_pConnectorPoints->count()) ) ) + { + // No connecting to ourself! + if( pStencil != this ) + { + + // Iterate through all connectors attempting to connect it to the stencil. + // If it connects, mark it as done + i = 0; + p = m_pConnectorPoints->first(); + + while( p ) + { + if( !done[i] && p->target() == 0 ) + { + if( pStencil->connectToTarget( p, threshold ) ) + { + done[i] = true; + } + } + + i++; + p = m_pConnectorPoints->next(); + } + + } + + pStencil = pLayer->nextStencil(); + } + + pLayer = pPage->nextLayer(); + } + + delete [] done; +} + +////////////////////// +// resize handles +////////////////////// +int Kivio1DStencil::resizeHandlePositions() +{ + return (int)krhpNone; +} + +QDomElement Kivio1DStencil::saveConnectors( QDomDocument &doc ) +{ + QDomElement eConns = doc.createElement("KivioConnectorList"); + + KivioConnectorPoint *p; + p = m_pConnectorPoints->first(); + while( p ) + { + eConns.appendChild( p->saveXML(doc) ); + + p = m_pConnectorPoints->next(); + } + + return eConns; +} + +bool Kivio1DStencil::loadConnectors( const QDomElement &e ) +{ + m_pConnectorPoints->clear(); + + KivioConnectorPoint *p; + + QDomNode node = e.firstChild(); + QDomElement e2; + QString name; + + while( !node.isNull() ) + { + e2 = node.toElement(); + name = e2.nodeName(); + + if( name == "KivioConnectorPoint" ) + { + p = new KivioConnectorPoint(); + p->setStencil(this); + p->loadXML( e2 ); + + m_pConnectorPoints->append( p ); + p = NULL; + } + + node = node.nextSibling(); + } + + // Set the pointers to the start,end,left,right points + m_pStart = m_pConnectorPoints->first(); + m_pEnd = m_pConnectorPoints->next(); + m_pLeft = m_pConnectorPoints->next(); + m_pRight = m_pConnectorPoints->next(); + m_pTextConn = m_pConnectorPoints->next(); + + // Hopefully this will help with backwards compatibility + if( m_pStart == NULL ) { + m_pStart = new KivioConnectorPoint(this, true); + } + if( m_pEnd == NULL ) { + m_pEnd = new KivioConnectorPoint(this, true); + } + if( m_pLeft == NULL ) { + m_pLeft = new KivioConnectorPoint(this, false); + } + if( m_pRight == NULL ) { + m_pRight = new KivioConnectorPoint(this, false); + } + if( m_pTextConn == NULL ) { + m_pTextConn = new KivioConnectorPoint(this, false); + } + + + return true; +} + +QDomElement Kivio1DStencil::saveProperties( QDomDocument &doc ) +{ + QDomElement propE = doc.createElement("KivioStencilProperties"); + + QDomElement connE = doc.createElement("Kivio1DProperties"); + XmlWriteFloat( connE, "connectorWidth", m_connectorWidth ); + XmlWriteInt( connE, "needsWidth", m_needsWidth ); + propE.appendChild( connE ); + + propE.appendChild( m_pLineStyle->saveXML( doc ) ); + + propE.appendChild( m_pFillStyle->saveXML( doc ) ); + + propE.appendChild( m_pTextStyle->saveXML( doc ) ); + + propE.appendChild( saveConnectors(doc) ); + + QDomElement customE = doc.createElement("CustomData"); + if( saveCustom( customE, doc )==true ) + { + propE.appendChild( customE ); + } + + return propE; +} + +bool Kivio1DStencil::loadProperties( const QDomElement &e ) +{ + QDomNode node; + QDomElement nodeE; + QString nodeName; + + node = e.firstChild(); + while( !node.isNull() ) + { + nodeE = node.toElement(); + nodeName = node.nodeName(); + + if( nodeName == "KivioFillStyle" ) + { + m_pFillStyle->loadXML( nodeE ); + } + else if( nodeName == "KivioLineStyle" ) + { + m_pLineStyle->loadXML( nodeE ); + } + else if( nodeName == "KivioTextStyle" ) + { + m_pTextStyle->loadXML( nodeE ); + } + else if( nodeName == "KivioConnectorList" ) + { + loadConnectors( nodeE ); + } + else if( nodeName == "Kivio1DProperties" ) + { + m_needsWidth = (bool)XmlReadInt( nodeE, "needsWidth", (int)true ); + m_connectorWidth = XmlReadFloat( nodeE, "connectorWidth", 36.0f ); + } + else if( nodeName == "CustomData" ) + { + loadCustom( nodeE ); + } + + node = node.nextSibling(); + } + + return true; +} + +bool Kivio1DStencil::loadCustom( const QDomElement & ) +{ + return true; +} + +bool Kivio1DStencil::saveCustom( QDomElement &, QDomDocument & ) +{ + return false; +} + +void Kivio1DStencil::copyBasicInto( Kivio1DStencil *pStencil ) +{ + KivioConnectorPoint *pSrc, *pTg; + + // Copy the spawner + pStencil->setSpawner( m_pSpawner ); + + // Copy the connector points + pSrc = m_pConnectorPoints->first(); + pTg = pStencil->m_pConnectorPoints->first(); + while( pSrc && pTg ) + { + pTg->setPosition( pSrc->x(), pSrc->y(), false ); + + pSrc = m_pConnectorPoints->next(); + pTg = pStencil->m_pConnectorPoints->next(); + } + + // Copy the dimensions + pStencil->m_x = m_x; + pStencil->m_y = m_y; + pStencil->m_w = m_w; + pStencil->m_h = m_h; + + // Copy over the width info + pStencil->m_connectorWidth = m_connectorWidth; + pStencil->m_needsWidth = m_needsWidth; + + // Copy over the styles + m_pFillStyle->copyInto( pStencil->m_pFillStyle ); + m_pLineStyle->copyInto( pStencil->m_pLineStyle ); + m_pTextStyle->copyInto( pStencil->m_pTextStyle ); + + // Copy over the protection + *(pStencil->m_pProtection) = *m_pProtection; + *(pStencil->m_pCanProtect) = *m_pCanProtect; +} + +void Kivio1DStencil::drawText( KivioIntraStencilData *pData ) +{ + if(m_pTextStyle->text().isEmpty()) { + return; + } + + KoZoomHandler* zoomHandler = pData->zoomHandler; + KivioPainter *painter = pData->painter; + + int _x, _y, _w, _h; + + _x = zoomHandler->zoomItX(m_pTextConn->x()); + _y = zoomHandler->zoomItY(m_pTextConn->y()); + _w = 10000000; + _h = 10000000; + + QFont f = m_pTextStyle->font(); + int tf = m_pTextStyle->hTextAlign() | m_pTextStyle->vTextAlign(); + + f.setPointSizeFloat(f.pointSizeFloat() * (((float)zoomHandler->zoom()) / 100.0)); + painter->setFont(f); + QRect boundRect = painter->boundingRect( _x, _y, _w, _h, tf, m_pTextStyle->text() ); + QPixmap pix(boundRect.width(), boundRect.height()); + pix.fill(); + QPainter p(&pix); + p.setPen(m_pTextStyle->color()); + p.setFont(f); + p.drawText( 0, 0, boundRect.width(), boundRect.height(), tf, m_pTextStyle->text() ); + QBitmap mask; + mask = pix; + pix.setMask(mask); + painter->drawPixmap(_x, _y, pix); +} + +bool Kivio1DStencil::connected() +{ + KivioConnectorPoint *p; + p = m_pConnectorPoints->first(); + + while( p ) + { + if(p->target() != 0) { + return true; + } + + p = m_pConnectorPoints->next(); + } + + return false; +} + +void Kivio1DStencil::disconnectFromTargets() +{ + KivioConnectorPoint *p; + p = m_pConnectorPoints->first(); + + while( p ) + { + p->disconnect(true); + p = m_pConnectorPoints->next(); + } +} + +KivioLineStyle Kivio1DStencil::lineStyle() +{ + return *m_pLineStyle; +} + +void Kivio1DStencil::setLineStyle(KivioLineStyle ls) +{ + ls.copyInto(m_pLineStyle); +} + +void Kivio1DStencil::setCustomIDPoint(int customID, const KoPoint& point, KivioPage* page) +{ + double oldX, oldY; + KivioConnectorPoint *p; + + // Locate the point specified by customID + p = m_pConnectorPoints->at( customID - (kctCustom+1)); + + if( !p ) + { + kdDebug(43000) << "Kivio1DStencil::customDrag() - KivioConnectorPoint customID: " << (customID - (kctCustom+1)) << " not found\n" << endl; + return; + } + + oldX = p->x(); + oldY = p->y(); + p->setPosition(point.x(),point.y(),true); + + if( p->connectable()==true ) + { + // Attempt a snap.... + KivioLayer *pCurLayer = page->curLayer(); + KivioLayer *pLayer = page->firstLayer(); //page->curLayer(); + bool foundConnection = false; + + while( pLayer && !foundConnection ) + { + // To be connected to, a layer must be visible and connectable + if( pLayer!=pCurLayer ) + { + if( pLayer->connectable()==false || pLayer->visible()==false ) + { + pLayer = page->nextLayer(); + continue; + } + } + + // Tell the layer to search for a target + if( pLayer->connectPointToTarget( p, 8.0f ) ) + { + foundConnection = true; + } + + pLayer = page->nextLayer(); + } + + if( foundConnection == false ) + { + p->disconnect(); + } + } + + // If it is a start/end point, then make a request to update the connectors (must be implemented by stencil developer) + if( customID == kctCustom+1 || customID == kctCustom+2 ) + { + // If it's the end connector, then update the text point + if( p==m_pEnd && m_needsText==true ) + { + m_pTextConn->setPosition( m_pTextConn->x() + (m_pEnd->x() - oldX), + m_pTextConn->y() + (m_pEnd->y() - oldY), false ); + } + + updateConnectorPoints(p, oldX, oldY); + } + // If it is one of the width handles, then fix the width and update the opposite point + // only if the stencils 'needs width' connectors + else if( (customID == kctCustom+3 || customID == kctCustom+4) && (m_needsWidth==true) ) + { + double vx = m_pStart->x() - m_pEnd->x(); + double vy = m_pStart->y() - m_pEnd->y(); + double len = sqrt( vx*vx + vy*vy ); + double midX = (m_pStart->x() + m_pEnd->x())/2.0f; + double midY = (m_pStart->y() + m_pEnd->y())/2.0f; + + vx /= len; + vy /= len; + + double d = shortestDistance( m_pStart, m_pEnd, (customID==kctCustom+3) ? m_pLeft : m_pRight ); + + m_pLeft->setPosition( midX + d*vy, midY + d*(-vx), false ); + m_pRight->setPosition( midX + d*(-vy), midY + d*vx, false ); + + m_connectorWidth = d*2.0f; + + updateConnectorPoints(p, oldX, oldY); + return; + } + // Text handle + else if( customID == kctCustom+5 ) + { + updateConnectorPoints(p, oldX, oldY); + } +} + +KoPoint Kivio1DStencil::customIDPoint(int customID) +{ + KivioConnectorPoint *p; + + // Locate the point specified by customID + p = m_pConnectorPoints->at( customID - (kctCustom+1)); + + return p->position(); +} -- cgit v1.2.1