kivio

kivio_arrowhead.cpp

00001 /*
00002  * Kivio - Visual Modelling and Flowcharting
00003  * Copyright (C) 2000-2001 theKompany.com & Dave Marotti
00004  *
00005  * This program is free software; you can redistribute it and/or
00006  * modify it under the terms of the GNU General Public License
00007  * as published by the Free Software Foundation; either version 2
00008  * of the License, or (at your option) any later version.
00009  *
00010  * This program is distributed in the hope that it will be useful,
00011  * but WITHOUT ANY WARRANTY; without even the implied warranty of
00012  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013  * GNU General Public License for more details.
00014  *
00015  * You should have received a copy of the GNU General Public License
00016  * along with this program; if not, write to the Free Software
00017  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
00018  */
00019 #include "kivio_arrowhead.h"
00020 #include "kivio_common.h"
00021 #include "kivio_painter.h"
00022 #include "kivio_point.h"
00023 #include "kivio_fill_style.h"
00024 
00025 #include <math.h>
00026 #include <kdebug.h>
00027 #include <KoZoomHandler.h>
00028 
00029 KivioArrowHead::KivioArrowHead()
00030 {
00031     // Both of these values are in pixels
00032     m_cut = 0.0f;
00033     m_w = m_l = 10.0f;
00034 
00035     m_type = kahtNone;
00036 }
00037 
00038 KivioArrowHead::~KivioArrowHead()
00039 {
00040 }
00041 
00042 QDomElement KivioArrowHead::saveXML( QDomDocument &doc )
00043 {
00044     QDomElement e = doc.createElement("KivioArrowHead");
00045 
00046     XmlWriteFloat( e, "cut", m_cut );
00047     XmlWriteFloat( e, "w", m_w );
00048     XmlWriteFloat( e, "l", m_l );
00049     XmlWriteInt( e, "type", m_type );
00050 
00051     return e;
00052 }
00053 
00054 bool KivioArrowHead::loadXML( const QDomElement &e )
00055 {
00056     m_cut   = XmlReadFloat( e, "cut", 0.0f );
00057     m_w     = XmlReadFloat( e, "w", 10.0f );
00058     m_l     = XmlReadFloat( e, "l", 10.0f );
00059     m_type  = XmlReadInt( e, "type", m_type );
00060 
00061     return true;
00062 }
00063 
00064 void KivioArrowHead::setType(int t)
00065 {
00066     m_type = t;
00067 
00068     switch( t )
00069     {
00070         case kahtNone:
00071             m_cut = 0.0f;
00072             break;
00073 
00074         case kahtArrowLine:
00075         case kahtForwardSlash:
00076         case kahtBackSlash:
00077         case kahtPipe:
00078         case kahtCrowFoot:
00079         case kahtFork:
00080         case kahtCrowFootPipe:
00081         case kahtMidForwardSlash:
00082         case kahtMidBackSlash:
00083         case kahtMidPipe:
00084             m_cut = 0.0f;
00085             break;
00086 
00087         case kahtArrowTriangleSolid:
00088         case kahtArrowTriangleHollow:
00089         case kahtDoubleTriangleSolid:
00090         case kahtDoubleTriangleHollow:
00091         case kahtDiamondSolid:
00092         case kahtDiamondHollow:
00093 //        case kahtCircleSolid:
00094 //        case kahtCircleHollow:
00095             m_cut = KIVIO_CUT_LENGTH;
00096             break;
00097 
00098         default:
00099             m_type = kahtNone;
00100             m_cut = 0.0f;
00101             break;
00102     }
00103 }
00104 
00105 float KivioArrowHead::cut()
00106 {
00107     if( m_cut == KIVIO_CUT_LENGTH )
00108         return m_l;
00109 
00110     else if( m_cut == KIVIO_CUT_HALF_LENGTH )
00111         return m_l / 2.0f;
00112 
00113     return m_cut;
00114 }
00115 
00130 void KivioArrowHead::paint( KivioPainter *painter, float x, float y, float vecX, float vecY, KoZoomHandler* zoomHandler )
00131 {
00132     KivioArrowHeadData d;
00133 
00134     d.painter = painter;
00135     d.x = x;
00136     d.y = y;
00137     d.vecX = vecX;
00138     d.vecY = vecY;
00139     d.zoomHandler = zoomHandler;
00140 
00141     // One big-ass switch statement
00142     switch( m_type )
00143     {
00144         case kahtNone:
00145             return;
00146 
00147         case kahtArrowLine:
00148             paintArrowLine( &d );
00149             break;
00150 
00151         case kahtArrowTriangleSolid:
00152             paintArrowTriangle( &d, true );
00153             break;
00154 
00155         case kahtArrowTriangleHollow:
00156             paintArrowTriangle( &d, false );
00157             break;
00158 
00159         case kahtDoubleTriangleSolid:
00160             paintDoubleTriangle( &d, true );
00161             break;
00162 
00163         case kahtDoubleTriangleHollow:
00164             paintDoubleTriangle( &d, false );
00165             break;
00166 
00167         case kahtForwardSlash:
00168             paintForwardSlash( &d );
00169             break;
00170 
00171         case kahtBackSlash:
00172             paintBackSlash( &d );
00173             break;
00174 
00175         case kahtPipe:
00176             paintPipe( &d );
00177             break;
00178 
00179         case kahtMidForwardSlash:
00180             paintMidForwardSlash( &d );
00181             break;
00182 
00183         case kahtMidBackSlash:
00184             paintMidBackSlash( &d );
00185             break;
00186 
00187         case kahtMidPipe:
00188             paintMidPipe( &d );
00189             break;
00190 
00191         case kahtDiamondSolid:
00192             paintDiamond( &d, true );
00193             break;
00194 
00195         case kahtDiamondHollow:
00196             paintDiamond( &d, false );
00197             break;
00198 
00199         case kahtCrowFoot:
00200             paintCrowFoot( &d );
00201             break;
00202 
00203         case kahtFork:
00204             paintFork( &d );
00205             break;
00206 
00207         case kahtCrowFootPipe:
00208             paintCrowFootPipe( &d );
00209             break;
00210 /*
00211         case kahtCircleSolid:
00212             paintCircle( &d, true );
00213             break;
00214 
00215         case kahtCircleHollow:
00216             paintCircle( &d, false );
00217             break;
00218 */
00219         default:
00220             break;
00221     }
00222 }
00223 
00224 void KivioArrowHead::paintArrowLine( KivioArrowHeadData *d )
00225 {
00226     KivioPainter *painter = d->painter;
00227 
00228     float vecX = d->vecX;
00229     float vecY = d->vecY;
00230 
00231     float length;
00232 
00233     KoZoomHandler* zoomHandler = d->zoomHandler;
00234 
00235     float nvecX, nvecY; // normalized vectors
00236     float pvecX, pvecY; // normal perpendicular vector
00237 
00238     length = sqrt( vecX*vecX + vecY*vecY );
00239 
00240     nvecX = - vecX / length;
00241     nvecY = - vecY / length;
00242 
00243     pvecX = nvecY;
00244     pvecY = -nvecX;
00245 
00246     QPtrList<KivioPoint>l;
00247     l.setAutoDelete(true);
00248 
00249     float _x;
00250     float _y;
00251 
00252     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00253     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00254 
00255     l.append( new KivioPoint( _x, _y ) );
00256 
00257     _x = zoomHandler->zoomItX(d->x);
00258     _y = zoomHandler->zoomItY(d->y);
00259 
00260     l.append( new KivioPoint( _x, _y ) );       // point
00261 
00262 
00263     pvecX *= -1.0f;
00264     pvecY *= -1.0f;
00265 
00266     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00267     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00268 
00269     l.append( new KivioPoint( _x, _y ) );
00270 
00271 
00272     painter->drawPolyline( &l );
00273 }
00274 
00275 void KivioArrowHead::paintArrowTriangle( KivioArrowHeadData *d, bool solid )
00276 {
00277     KivioPainter *painter = d->painter;
00278     QColor cbg = painter->bgColor();
00279 
00280     if(solid) {
00281       painter->setBGColor(painter->fgColor());
00282     }
00283 
00284     float vecX = d->vecX;
00285     float vecY = d->vecY;
00286 
00287     float length;
00288 
00289     KoZoomHandler* zoomHandler = d->zoomHandler;
00290 
00291     float nvecX, nvecY; // normalized vectors
00292     float pvecX, pvecY; // normal perpendicular vector
00293 
00294     length = sqrt( vecX*vecX + vecY*vecY );
00295 
00296     nvecX = - vecX / length;
00297     nvecY = - vecY / length;
00298 
00299     pvecX = nvecY;
00300     pvecY = -nvecX;
00301 
00302     QPtrList<KivioPoint>l;
00303     l.setAutoDelete(true);
00304 
00305     float _x = zoomHandler->zoomItX(d->x);
00306     float _y = zoomHandler->zoomItY(d->y);
00307 
00308     l.append( new KivioPoint( _x, _y ) );
00309 
00310     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00311     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00312 
00313     l.append( new KivioPoint( _x, _y ) );
00314 
00315     pvecX *= -1.0f;
00316     pvecY *= -1.0f;
00317 
00318     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00319     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00320 
00321     l.append( new KivioPoint( _x, _y ) );
00322 
00323     l.append( new KivioPoint( zoomHandler->zoomItX(d->x), zoomHandler->zoomItY(d->y) ) );
00324 
00325     painter->drawPolygon( &l );
00326     painter->setBGColor(cbg);
00327 }
00328 
00329 void KivioArrowHead::paintDoubleTriangle( KivioArrowHeadData *d, bool solid )
00330 {
00331     KivioPainter *painter = d->painter;
00332     QColor cbg = painter->bgColor();
00333 
00334     if(solid) {
00335       painter->setBGColor(painter->fgColor());
00336     }
00337 
00338     float vecX = d->vecX;
00339     float vecY = d->vecY;
00340 
00341     float length;
00342 
00343     KoZoomHandler* zoomHandler = d->zoomHandler;
00344 
00345     float nvecX, nvecY; // normalized vectors
00346     float pvecX, pvecY; // normal perpendicular vector
00347 
00348     length = sqrt( vecX*vecX + vecY*vecY );
00349 
00350     nvecX = - vecX / length;
00351     nvecY = - vecY / length;
00352 
00353     pvecX = nvecY;
00354     pvecY = -nvecX;
00355 
00356     QPtrList<KivioPoint> l1;
00357     l1.setAutoDelete(true);
00358     QPtrList<KivioPoint> l2;
00359     l2.setAutoDelete(true);
00360 
00361     float _x = zoomHandler->zoomItX(d->x);
00362     float _y = zoomHandler->zoomItY(d->y);
00363     l1.append( new KivioPoint( _x, _y ) );
00364 
00365     _x = zoomHandler->zoomItX(d->x + nvecX * (m_l / 2.0f));
00366     _y = zoomHandler->zoomItY(d->y + nvecY * (m_l / 2.0f));
00367     l2.append( new KivioPoint( _x, _y ) );
00368 
00369     _x = zoomHandler->zoomItX((d->x + nvecX * (m_l / 2.0f)) + pvecX*(m_w/2.0f));
00370     _y = zoomHandler->zoomItY((d->y + nvecY * (m_l / 2.0f)) + pvecY*(m_w/2.0f));
00371     l1.append( new KivioPoint( _x, _y ) );
00372 
00373     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00374     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00375     l2.append( new KivioPoint( _x, _y ) );
00376 
00377     pvecX *= -1.0f;
00378     pvecY *= -1.0f;
00379 
00380     _x = zoomHandler->zoomItX((d->x + nvecX * (m_l / 2.0f)) + pvecX*(m_w/2.0f));
00381     _y = zoomHandler->zoomItY((d->y + nvecY * (m_l / 2.0f)) + pvecY*(m_w/2.0f));
00382     l1.append( new KivioPoint( _x, _y ) );
00383 
00384     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00385     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00386     l2.append( new KivioPoint( _x, _y ) );
00387 
00388     l1.append( new KivioPoint( zoomHandler->zoomItX(d->x), zoomHandler->zoomItY(d->y) ) );
00389 
00390     _x = zoomHandler->zoomItX(d->x + nvecX * (m_l / 2.0f));
00391     _y = zoomHandler->zoomItY(d->y + nvecY * (m_l / 2.0f));
00392     l2.append( new KivioPoint( _x, _y ) );
00393 
00394     painter->drawPolygon( &l1 );
00395     painter->drawPolygon( &l2 );
00396     painter->setBGColor(cbg);
00397 }
00398 
00399 void KivioArrowHead::paintForwardSlash( KivioArrowHeadData *d )
00400 {
00401     KivioPainter *painter = d->painter;
00402 
00403     float vecX = d->vecX;
00404     float vecY = d->vecY;
00405 
00406     KoZoomHandler* zoomHandler = d->zoomHandler;
00407 
00408     float nvecX, nvecY; // normalized vectors
00409     float pvecX, pvecY; // normal perpendicular vector
00410 
00411     float length = sqrt( vecX*vecX + vecY*vecY );
00412 
00413     nvecX = - vecX / length;
00414     nvecY = - vecY / length;
00415 
00416     pvecX = nvecY;
00417     pvecY = -nvecX;
00418 
00419     int x1 = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) + pvecX*(m_w/2.0f));
00420     int y1 = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) + pvecY*(m_w/2.0f));
00421     int x2 = zoomHandler->zoomItX((d->x - nvecX * (m_l/2.0f)) - pvecX*(m_w/2.0f));
00422     int y2 = zoomHandler->zoomItY((d->y - nvecY * (m_l/2.0f)) - pvecY*(m_w/2.0f));
00423 
00424     painter->drawLine(x1, y1, x2, y2);
00425 }
00426 
00427 void KivioArrowHead::paintBackSlash( KivioArrowHeadData *d )
00428 {
00429     KivioPainter *painter = d->painter;
00430 
00431     float vecX = d->vecX;
00432     float vecY = d->vecY;
00433 
00434     KoZoomHandler* zoomHandler = d->zoomHandler;
00435 
00436     float nvecX, nvecY; // normalized vectors
00437     float pvecX, pvecY; // normal perpendicular vector
00438 
00439     float length = sqrt( vecX*vecX + vecY*vecY );
00440 
00441     nvecX = - vecX / length;
00442     nvecY = - vecY / length;
00443 
00444     pvecX = nvecY;
00445     pvecY = -nvecX;
00446 
00447     int x1 = zoomHandler->zoomItX((d->x - nvecX * (m_l/2.0f)) + pvecX*(m_w/2.0f));
00448     int y1 = zoomHandler->zoomItY((d->y - nvecY * (m_l/2.0f)) + pvecY*(m_w/2.0f));
00449     int x2 = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) - pvecX*(m_w/2.0f));
00450     int y2 = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) - pvecY*(m_w/2.0f));
00451 
00452     painter->drawLine(x1, y1, x2, y2);
00453 }
00454 
00455 void KivioArrowHead::paintPipe( KivioArrowHeadData *d )
00456 {
00457     KivioPainter *painter = d->painter;
00458 
00459     float vecX = d->vecX;
00460     float vecY = d->vecY;
00461 
00462     KoZoomHandler* zoomHandler = d->zoomHandler;
00463 
00464     float nvecX, nvecY; // normalized vectors
00465     float pvecX, pvecY; // normal perpendicular vector
00466 
00467     float length = sqrt( vecX*vecX + vecY*vecY );
00468 
00469     nvecX = - vecX / length;
00470     nvecY = - vecY / length;
00471 
00472     pvecX = nvecY;
00473     pvecY = -nvecX;
00474 
00475     int x1 = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00476     int y1 = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00477     int x2 = zoomHandler->zoomItX(d->x - pvecX*(m_w/2.0f));
00478     int y2 = zoomHandler->zoomItY(d->y - pvecY*(m_w/2.0f));
00479 
00480     painter->drawLine(x1, y1, x2, y2);
00481 }
00482 
00483 void KivioArrowHead::paintDiamond( KivioArrowHeadData *d, bool solid )
00484 {
00485     KivioPainter *painter = d->painter;
00486     QColor cbg = painter->bgColor();
00487 
00488     if(solid) {
00489       painter->setBGColor(painter->fgColor());
00490     }
00491 
00492     float vecX = d->vecX;
00493     float vecY = d->vecY;
00494 
00495     KoZoomHandler* zoomHandler = d->zoomHandler;
00496 
00497     float nvecX, nvecY; // normalized vectors
00498     float pvecX, pvecY; // normal perpendicular vector
00499 
00500     float length = sqrt( vecX*vecX + vecY*vecY );
00501 
00502     nvecX = - vecX / length;
00503     nvecY = - vecY / length;
00504 
00505     pvecX = nvecY;
00506     pvecY = -nvecX;
00507 
00508     QPtrList<KivioPoint> l;
00509     l.setAutoDelete(true);
00510 
00511     float _x = zoomHandler->zoomItX(d->x);
00512     float _y = zoomHandler->zoomItY(d->y);
00513     l.append( new KivioPoint( _x, _y ) );
00514 
00515     _x = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) - pvecX*(m_w/2.0f));
00516     _y = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) - pvecY*(m_w/2.0f));
00517     l.append( new KivioPoint( _x, _y ) );
00518 
00519     _x = zoomHandler->zoomItX((d->x + nvecX * m_l));
00520     _y = zoomHandler->zoomItY((d->y + nvecY * m_l));
00521     l.append( new KivioPoint( _x, _y ) );
00522 
00523     _x = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) + pvecX*(m_w/2.0f));
00524     _y = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) + pvecY*(m_w/2.0f));
00525     l.append( new KivioPoint( _x, _y ) );
00526 
00527     _x = zoomHandler->zoomItX(d->x);
00528     _y = zoomHandler->zoomItY(d->y);
00529     l.append( new KivioPoint( _x, _y ) );
00530 
00531     painter->drawPolygon( &l );
00532     painter->setBGColor(cbg);
00533 }
00534 
00535 void KivioArrowHead::paintCircle( KivioArrowHeadData *d, bool solid )
00536 {
00537     KivioPainter *painter = d->painter;
00538     QColor cbg = painter->bgColor();
00539 
00540     if(solid) {
00541       painter->setBGColor(painter->fgColor());
00542     }
00543 
00544     float vecX = d->vecX;
00545     float vecY = d->vecY;
00546 
00547     KoZoomHandler* zoomHandler = d->zoomHandler;
00548 
00549     float nvecX, nvecY; // normalized vectors
00550     float pvecX, pvecY; // normal perpendicular vector
00551 
00552     float length = sqrt( vecX*vecX + vecY*vecY );
00553 
00554     nvecX = - vecX / length;
00555     nvecY = - vecY / length;
00556 
00557     pvecX = nvecY;
00558     pvecY = -nvecX;
00559 
00560     int x = zoomHandler->zoomItX(d->x + nvecX * (m_l / 2.0f));
00561     int y = zoomHandler->zoomItY(d->y + nvecY * (m_l / 2.0f));
00562     int w = zoomHandler->zoomItY(m_w);
00563     int h = zoomHandler->zoomItX(m_l);
00564 
00565     painter->drawEllipse(x, y, w, h);
00566     painter->setBGColor(cbg);
00567 }
00568 
00569 void KivioArrowHead::paintCrowFoot( KivioArrowHeadData *d )
00570 {
00571     KivioPainter *painter = d->painter;
00572 
00573     float vecX = d->vecX;
00574     float vecY = d->vecY;
00575 
00576     float length;
00577 
00578     KoZoomHandler* zoomHandler = d->zoomHandler;
00579 
00580     float nvecX, nvecY; // normalized vectors
00581     float pvecX, pvecY; // normal perpendicular vector
00582 
00583     length = sqrt( vecX*vecX + vecY*vecY );
00584 
00585     nvecX = - vecX / length;
00586     nvecY = - vecY / length;
00587 
00588     pvecX = nvecY;
00589     pvecY = -nvecX;
00590 
00591     QPtrList<KivioPoint>l;
00592     l.setAutoDelete(true);
00593 
00594     float _x;
00595     float _y;
00596 
00597     _x = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00598     _y = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00599 
00600     l.append( new KivioPoint( _x, _y ) );
00601 
00602     _x = zoomHandler->zoomItX(d->x + nvecX * m_l);
00603     _y = zoomHandler->zoomItY(d->y + nvecY * m_l);
00604 
00605     l.append( new KivioPoint( _x, _y ) );       // point
00606 
00607 
00608     pvecX *= -1.0f;
00609     pvecY *= -1.0f;
00610 
00611     _x = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00612     _y = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00613 
00614     l.append( new KivioPoint( _x, _y ) );
00615 
00616 
00617     painter->drawPolyline( &l );
00618 }
00619 
00620 void KivioArrowHead::paintFork( KivioArrowHeadData *d )
00621 {
00622     KivioPainter *painter = d->painter;
00623 
00624     float vecX = d->vecX;
00625     float vecY = d->vecY;
00626 
00627     float length;
00628 
00629     KoZoomHandler* zoomHandler = d->zoomHandler;
00630 
00631     float nvecX, nvecY; // normalized vectors
00632     float pvecX, pvecY; // normal perpendicular vector
00633 
00634     length = sqrt( vecX*vecX + vecY*vecY );
00635 
00636     nvecX = - vecX / length;
00637     nvecY = - vecY / length;
00638 
00639     pvecX = nvecY;
00640     pvecY = -nvecX;
00641 
00642     QPtrList<KivioPoint>l;
00643     l.setAutoDelete(true);
00644 
00645     float _x;
00646     float _y;
00647 
00648     _x = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00649     _y = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00650 
00651     l.append( new KivioPoint( _x, _y ) );
00652 
00653     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00654     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00655 
00656     l.append( new KivioPoint( _x, _y ) );
00657 
00658     pvecX *= -1.0f;
00659     pvecY *= -1.0f;
00660 
00661     _x = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00662     _y = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00663 
00664     l.append( new KivioPoint( _x, _y ) );
00665 
00666     _x = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00667     _y = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00668 
00669     l.append( new KivioPoint( _x, _y ) );
00670 
00671 
00672     painter->drawPolyline( &l );
00673 }
00674 
00675 void KivioArrowHead::paintCrowFootPipe( KivioArrowHeadData *d )
00676 {
00677     KivioPainter *painter = d->painter;
00678 
00679     float vecX = d->vecX;
00680     float vecY = d->vecY;
00681 
00682     KoZoomHandler* zoomHandler = d->zoomHandler;
00683 
00684     float nvecX, nvecY; // normalized vectors
00685     float pvecX, pvecY; // normal perpendicular vector
00686 
00687     float length = sqrt( vecX*vecX + vecY*vecY );
00688 
00689     nvecX = - vecX / length;
00690     nvecY = - vecY / length;
00691 
00692     pvecX = nvecY;
00693     pvecY = -nvecX;
00694 
00695     int x1 = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00696     int y1 = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00697     int x2 = zoomHandler->zoomItX((d->x + nvecX * m_l) - pvecX*(m_w/2.0f));
00698     int y2 = zoomHandler->zoomItY((d->y + nvecY * m_l) - pvecY*(m_w/2.0f));
00699 
00700     painter->drawLine(x1, y1, x2, y2);
00701     paintCrowFoot( d );
00702 }
00703 
00704 void KivioArrowHead::paintMidForwardSlash( KivioArrowHeadData *d )
00705 {
00706     KivioPainter *painter = d->painter;
00707 
00708     float vecX = d->vecX;
00709     float vecY = d->vecY;
00710 
00711     KoZoomHandler* zoomHandler = d->zoomHandler;
00712 
00713     float nvecX, nvecY; // normalized vectors
00714     float pvecX, pvecY; // normal perpendicular vector
00715 
00716     float length = sqrt( vecX*vecX + vecY*vecY );
00717 
00718     nvecX = - vecX / length;
00719     nvecY = - vecY / length;
00720 
00721     pvecX = nvecY;
00722     pvecY = -nvecX;
00723 
00724     int x1 = zoomHandler->zoomItX(d->x + pvecX*(m_w/2.0f));
00725     int y1 = zoomHandler->zoomItY(d->y + pvecY*(m_w/2.0f));
00726     int x2 = zoomHandler->zoomItX((d->x + nvecX * m_l) - pvecX*(m_w/2.0f));
00727     int y2 = zoomHandler->zoomItY((d->y + nvecY * m_l) - pvecY*(m_w/2.0f));
00728 
00729     painter->drawLine(x1, y1, x2, y2);
00730 }
00731 
00732 void KivioArrowHead::paintMidBackSlash( KivioArrowHeadData *d )
00733 {
00734     KivioPainter *painter = d->painter;
00735 
00736     float vecX = d->vecX;
00737     float vecY = d->vecY;
00738 
00739     KoZoomHandler* zoomHandler = d->zoomHandler;
00740 
00741     float nvecX, nvecY; // normalized vectors
00742     float pvecX, pvecY; // normal perpendicular vector
00743 
00744     float length = sqrt( vecX*vecX + vecY*vecY );
00745 
00746     nvecX = - vecX / length;
00747     nvecY = - vecY / length;
00748 
00749     pvecX = nvecY;
00750     pvecY = -nvecX;
00751 
00752     int x1 = zoomHandler->zoomItX((d->x + nvecX * m_l) + pvecX*(m_w/2.0f));
00753     int y1 = zoomHandler->zoomItY((d->y + nvecY * m_l) + pvecY*(m_w/2.0f));
00754     int x2 = zoomHandler->zoomItX(d->x - pvecX*(m_w/2.0f));
00755     int y2 = zoomHandler->zoomItY(d->y - pvecY*(m_w/2.0f));
00756 
00757     painter->drawLine(x1, y1, x2, y2);
00758 }
00759 
00760 void KivioArrowHead::paintMidPipe( KivioArrowHeadData *d )
00761 {
00762     KivioPainter *painter = d->painter;
00763 
00764     float vecX = d->vecX;
00765     float vecY = d->vecY;
00766 
00767     KoZoomHandler* zoomHandler = d->zoomHandler;
00768 
00769     float nvecX, nvecY; // normalized vectors
00770     float pvecX, pvecY; // normal perpendicular vector
00771 
00772     float length = sqrt( vecX*vecX + vecY*vecY );
00773 
00774     nvecX = - vecX / length;
00775     nvecY = - vecY / length;
00776 
00777     pvecX = nvecY;
00778     pvecY = -nvecX;
00779 
00780     int x1 = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) + pvecX*(m_w/2.0f));
00781     int y1 = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) + pvecY*(m_w/2.0f));
00782     int x2 = zoomHandler->zoomItX((d->x + nvecX * (m_l/2.0f)) - pvecX*(m_w/2.0f));
00783     int y2 = zoomHandler->zoomItY((d->y + nvecY * (m_l/2.0f)) - pvecY*(m_w/2.0f));
00784 
00785     painter->drawLine(x1, y1, x2, y2);
00786 }
KDE Home | KDE Accessibility Home | Description of Access Keys