kivio_common.cpp

/*
 * 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.
 */
#include "kivio_common.h"
#include "kivio_connector_point.h"
#include <kdebug.h>
#include <tqstringlist.h>
#include <math.h>
#include <KoPoint.h>
#include <KoRect.h>

float XmlReadFloat( const TQDomElement &e, const TQString &att, const float &def)
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
    
    // Read the attribute
    TQString val = e.attribute( att );
    bool ok=false;
    
    // Make sure it is a floating point value.  If not, return the default
    float fVal = val.toFloat( &ok );
    if( !ok )
    {
    kdDebug(43000) << "Invalid XML-value read for " << att.ascii() << ", expected float\n" << endl;
    return 1.0;
    }
    
    // Return the value
    return fVal;
}
 

void XmlWriteFloat( TQDomElement &e, const TQString &att, const float &val )
{
    e.setAttribute( att, (double)val );
}
 

int XmlReadInt( const TQDomElement &e, const TQString &att, const int &def)
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
 
    // Read the attribute
    TQString val = e.attribute( att, "1" );
    bool ok=false;
 
    // Make sure it is a floating point value.  If not, return the default
    int iVal = val.toInt( &ok );
    if( !ok )
    {
       kdDebug(43000) << "Invalid XML-value read for " << att << " expected int\n" << endl;
      return 1;
    }
 
    // Return the value
    return iVal;
}
 

void XmlWriteInt( TQDomElement &e, const TQString &att, const int &val )
{
    e.setAttribute( att, (int)val );
}
 

uint XmlReadUInt( const TQDomElement &e, const TQString &att, const uint &def)
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
 
    // Read the attribute
    TQString val = e.attribute( att, "1" );
    bool ok=false;
 
    // Make sure it is a floating point value.  If not, return the default
    uint iVal = val.toUInt( &ok );
    if( !ok )
    {
       kdDebug(43000) << "Invalid XML-value read for " << att.ascii() << ", expected uint\n" << endl;
        return 1;
    }
 
    // Return the value
    return iVal;
}
 

void XmlWriteUInt( TQDomElement &e, const TQString &att, const uint &val )
{
    e.setAttribute( att, (uint)val );
}
 

TQString XmlReadString( const TQDomElement &e, const TQString &att, const TQString &def )
{
    // Check if the attribute exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return TQString(def);
    // Otherwise return the attribute
    else return e.attribute( att );
}
 

void XmlWriteString( TQDomElement &e,  const TQString &att,  const TQString &val )
{
    e.setAttribute( att, val );
}
 

TQColor XmlReadColor( const TQDomElement &e, const TQString &att, const TQColor &def)
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
 
    // Read the attribute
    TQString val = e.attribute( att, "1" );
    bool ok=false;
    TQColor newColor;
 
    if( val.contains("#") ) // Is it #RRGGBB format?
    {
        newColor.setNamedColor(val);
        return newColor;
    }
 
    // Otherwise it is a #xxxxxxxx color (rgb format)
    // Make sure it is a uint value.  If not, return the default
    uint iVal = val.toUInt( &ok );
    if( !ok )
    {
       kdDebug(43000) << "Invalid XML-value read for " << att.ascii() << ", expected TQColor" << endl;
        return 1;
    }
 
    // Return the value
    return TQColor(iVal);
}
 

void XmlWriteColor( TQDomElement &e, const TQString &att, const TQColor &val )
{
    // Write it out in #RRGGBB format
    e.setAttribute( att, val.name() );
}
 

double XmlReadDouble( const TQDomElement &e, const TQString &att, const double &def)
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
 
    // Read the attribute
    TQString val = e.attribute( att, "1.0" );
    bool ok=false;
 
    // Make sure it is a floating point value.  If not, return the default
    double dVal = val.toDouble( &ok );
    if( !ok )
    {
       kdDebug(43000) << "Invalid XML-value read for ," << att.ascii() << " expected double" << endl;
        return 1.0;
    }
 
    // Return the value
    return dVal;
}
 

void XmlWriteDouble( TQDomElement &e, const TQString &att, const double &val )
{
    e.setAttribute( att, (double)val );
}
 
 
#define WHICH_QUAD( vertex, hitPos ) \
    ( (vertex.x() > hitPos->x()) ? ((vertex.y() > hitPos->y()) ? 1 : 4 ) : ((vertex.y() > hitPos->y())?2:3))
 
#define X_INTERCEPT( point1, point2, hitY ) \
    (point2.x() - (((point2.y()-hitY)*(point1.x()-point2.x()))/(point1.y()-point2.y())))

bool PointInPoly( KoPoint *points, int numPoints, KoPoint *hitPos )
{
    int edge,  next;
    int quad, next_quad, delta, total;
 
    edge = 0;
 
    quad = WHICH_QUAD( points[ edge ], hitPos );
    total = 0; // count of absolute sectors crossed
 
    // Loop through all the vertices
    do {
        next = (edge + 1) % numPoints;
        next_quad = WHICH_QUAD( points[ next ], hitPos );
 
        // Calculate how many quads have been crossed
        delta = next_quad - quad;
 
        // Special case to handle crossings of more than one quad
        switch( delta )
        {
            case 2:     // If we crossed the middle, figure out if it was clockwise or counter clockwise
            case -2:    // Use the X-position at the hit point to determine which way around
                if( X_INTERCEPT( points[edge], points[next], hitPos->y() ) > hitPos->x() )
                    delta = -delta;
                break;
 
            case 3:     // Moving 3 quads is like moving back 1
                delta = -1;
                break;
 
            case -3:    // Moving back 3 is like moving forward 1
                delta = 1;
                break;
        }
 
        // Add in the delta
        total += delta;
        quad = next_quad;
        edge = next;
    } while( edge != 0 );
    
 
    // After everything, if the total is 4, then we are inside
    if((total==4) || (total==-4))
        return true;
    else
        return false;
}
 
KoRect XmlReadRect( const TQDomElement &e, const TQString &att, const KoRect &def )
{
    // Check if this value exists, if not, return the default
    if( e.hasAttribute( att )==false )
        return def;
 
    // Read the attribute
    TQString val = e.attribute( att );
 
    if (val.find("[") == 0 && val.find("]") == (int)val.length()-1) {
      val.remove(0,1);
      val.remove(val.length()-1,1);
      TQStringList vlist = TQStringList::split(",",val);
      if (vlist.count() == 4) {
        bool allOk = true;
        bool ok = false;
 
        double x = vlist[0].toDouble(&ok);
        allOk = allOk & ok;
 
        double y = vlist[1].toDouble(&ok);
        allOk = allOk & ok;
 
        double w = vlist[2].toDouble(&ok);
        allOk = allOk & ok;
 
        double h = vlist[3].toDouble(&ok);
        allOk = allOk & ok;
 
        if (allOk)
          return KoRect(x, y, w, h);
      }
    }
 
    return def;
}
 
void  XmlWriteRect( TQDomElement &e, const TQString &att, const KoRect &val )
{
    e.setAttribute( att, TQString("[%1,%2,%3,%4]").arg(val.x()).arg(val.y()).arg(val.width()).arg(val.height()) );
}
 
 
float shortestDistance( KivioConnectorPoint *pStart, KivioConnectorPoint *pEnd, KivioConnectorPoint *q )
{
   float uX, uY;
   float pqX, pqY;
 
   uX = pStart->x() - pEnd->x();
   uY = pStart->y() - pEnd->y();
 
   pqX = pStart->x() - q->x();
   pqY = pStart->y() - q->y();
 
   float magTop = fabs(pqX*uY - (pqY*uX));
 
   float magU = sqrt( uX*uX + uY*uY );
   
   if( magU == 0.0f )
   {
      kdDebug(43000) << "shortestDistance() - SERIOUS ERROR: magU is 0.0f!\n";
      return 10.0f;
   }
 
   return magTop / magU;
}