kdgantt

KDGanttXMLTools.cpp
00001 /* -*- Mode: C++ -*-
00002    $Id$
00003    KDGantt - a multi-platform charting engine
00004 */
00005 
00006 /****************************************************************************
00007  ** Copyright (C)  2002-2004 Klarälvdalens Datakonsult AB.  All rights reserved.
00008  **
00009  ** This file is part of the KDGantt library.
00010  **
00011  ** This file may be distributed and/or modified under the terms of the
00012  ** GNU General Public License version 2 as published by the Free Software
00013  ** Foundation and appearing in the file LICENSE.GPL included in the
00014  ** packaging of this file.
00015  **
00016  ** Licensees holding valid commercial KDGantt licenses may use this file in
00017  ** accordance with the KDGantt Commercial License Agreement provided with
00018  ** the Software.
00019  **
00020  ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
00021  ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
00022  **
00023  ** See http://www.klaralvdalens-datakonsult.se/Public/products/ for
00024  **   information about KDGantt Commercial License Agreements.
00025  **
00026  ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
00027  ** licensing are not clear to you.
00028  **
00029  ** As a special exception, permission is given to link this program
00030  ** with any edition of TQt, and distribute the resulting executable,
00031  ** without including the source code for TQt in the source distribution.
00032  **
00033  **********************************************************************/
00034 
00035 #include "KDGanttXMLTools.h"
00036 #include <tqbrush.h>
00037 #include <tqbuffer.h>
00038 #include <tqimage.h>
00039 #include <zlib.h>
00040 
00041 namespace KDGanttXML {
00042 
00043 void createBoolNode( TQDomDocument& doc, TQDomNode& parent,
00044                      const TQString& elementName, bool value )
00045 {
00046     TQDomElement newElement =
00047         doc.createElement( elementName );
00048     parent.appendChild( newElement );
00049     TQDomText elementContent =
00050         doc.createTextNode( value ? "true" : "false" );
00051     newElement.appendChild( elementContent );
00052 }
00053 
00054 
00055 
00056 void createSizeNode( TQDomDocument& doc, TQDomNode& parent,
00057                      const TQString& elementName, const TQSize& value )
00058 {
00059     TQDomElement newElement =
00060         doc.createElement( elementName );
00061     parent.appendChild( newElement );
00062     newElement.setAttribute( "Width", value.width() );
00063     newElement.setAttribute( "Height", value.height() );
00064 }
00065 
00066 
00067 void createIntNode( TQDomDocument& doc, TQDomNode& parent,
00068                     const TQString& elementName, int value )
00069 {
00070     TQDomElement newElement =
00071         doc.createElement( elementName );
00072     parent.appendChild( newElement );
00073     TQDomText elementContent =
00074         doc.createTextNode( TQString::number( value ) );
00075     newElement.appendChild( elementContent );
00076 }
00077 
00078 
00079 void createDoubleNode( TQDomDocument& doc, TQDomNode& parent,
00080                        const TQString& elementName, double value )
00081 {
00082     TQDomElement newElement =
00083         doc.createElement( elementName );
00084     parent.appendChild( newElement );
00085     TQDomText elementContent =
00086         doc.createTextNode( TQString::number( value ) );
00087     newElement.appendChild( elementContent );
00088 }
00089 
00090 
00091 void createStringNode( TQDomDocument& doc, TQDomNode& parent,
00092                        const TQString& elementName,
00093                        const TQString& text )
00094 {
00095     TQDomElement newElement =
00096         doc.createElement( elementName );
00097     parent.appendChild( newElement );
00098     TQDomText elementContent =
00099         doc.createTextNode( text );
00100     newElement.appendChild( elementContent );
00101 }
00102 
00103 
00104 void createColorNode( TQDomDocument& doc, TQDomNode& parent,
00105                       const TQString& elementName, const TQColor& color )
00106 {
00107     TQDomElement colorElement = doc.createElement( elementName );
00108     parent.appendChild( colorElement );
00109     colorElement.setAttribute( "Red",
00110                                TQString::number( color.red() ) );
00111     colorElement.setAttribute( "Green",
00112                                TQString::number( color.green() ) );
00113     colorElement.setAttribute( "Blue",
00114                                TQString::number( color.blue() ) );
00115 }
00116 
00117 
00118 void createBrushNode( TQDomDocument& doc, TQDomNode& parent,
00119                       const TQString& elementName, const TQBrush& brush )
00120 
00121 {
00122     TQDomElement brushElement = doc.createElement( elementName );
00123     parent.appendChild( brushElement );
00124     createColorNode( doc, brushElement, "Color", brush.color() );
00125     createStringNode( doc, brushElement, "Style",
00126                       KDGanttXML::brushStyleToString( brush.style() ) );
00127     if( brush.style() == TQt::CustomPattern && brush.pixmap() )
00128         createPixmapNode( doc, brushElement, "Pixmap", *brush.pixmap() );
00129 }
00130 
00131 
00132 void createPixmapNode( TQDomDocument& doc, TQDomNode& parent,
00133                        const TQString& elementName, const TQPixmap& pixmap )
00134 {
00135     TQDomElement pixmapElement = doc.createElement( elementName );
00136     parent.appendChild( pixmapElement );
00137 
00138     // Convert the pixmap to an image, save that image to an in-memory
00139     // XPM representation and compress this representation. This
00140     // conforms to the file format TQt Designer uses.
00141     TQByteArray ba;
00142     TQBuffer buffer( ba );
00143     buffer.open( IO_WriteOnly );
00144     TQImageIO imgio( &buffer, "XPM" );
00145     TQImage image = pixmap.convertToImage();
00146     imgio.setImage( image );
00147     imgio.write();
00148     buffer.close();
00149     ulong len = ba.size() * 2;
00150     TQByteArray bazip( len );
00151     ::compress(  (uchar*) bazip.data(), &len, (uchar*) ba.data(), ba.size() );
00152     TQString dataString;
00153     static const char hexchars[] = "0123456789abcdef";
00154     for ( int i = 0; i < (int)len; ++i ) {
00155         uchar c = (uchar) bazip[i];
00156         dataString += hexchars[c >> 4];
00157         dataString += hexchars[c & 0x0f];
00158     }
00159 
00160     createStringNode( doc, pixmapElement, "Format", "XPM.GZ" );
00161     createIntNode( doc, pixmapElement, "Length", ba.size() );
00162     createStringNode( doc, pixmapElement, "Data", dataString );
00163 }
00164 
00165 
00166 void createRectNode( TQDomDocument& doc, TQDomNode& parent,
00167                      const TQString& elementName, const TQRect& rect )
00168 {
00169     TQDomElement rectElement = doc.createElement( elementName );
00170     parent.appendChild( rectElement );
00171     TQDomElement xElement = doc.createElement( "X" );
00172     rectElement.appendChild( xElement );
00173     TQDomText xContent = doc.createTextNode( TQString::number( rect.x() ) );
00174     xElement.appendChild( xContent );
00175     TQDomElement yElement = doc.createElement( "Y" );
00176     rectElement.appendChild( yElement );
00177     TQDomText yContent = doc.createTextNode( TQString::number( rect.y() ) );
00178     yElement.appendChild( yContent );
00179     TQDomElement widthElement = doc.createElement( "Width" );
00180     rectElement.appendChild( widthElement );
00181     TQDomText widthContent = doc.createTextNode( TQString::number( rect.width() ) );
00182     widthElement.appendChild( widthContent );
00183     TQDomElement heightElement = doc.createElement( "Height" );
00184     rectElement.appendChild( heightElement );
00185     TQDomText heightContent = doc.createTextNode( TQString::number( rect.height() ) );
00186     heightElement.appendChild( heightContent );
00187 }
00188 
00189 
00190 void createStringListNodes( TQDomDocument& doc, TQDomNode& parent,
00191                             const TQString& elementName,
00192                             const TQStringList* list )
00193 {
00194     if( !list )
00195         return;
00196 
00197     for( TQStringList::ConstIterator it = list->begin();
00198          it != list->end(); ++it ) {
00199         TQDomElement element = doc.createElement( elementName );
00200         parent.appendChild( element );
00201         TQDomText elementContent = doc.createTextNode( *it );
00202         element.appendChild( elementContent );
00203     }
00204 }
00205 
00206 
00207 void createFontNode( TQDomDocument& doc, TQDomNode& parent,
00208                      const TQString& elementName, const TQFont& font )
00209 {
00210     TQDomElement fontElement = doc.createElement( elementName );
00211     parent.appendChild( fontElement );
00212     createStringNode( doc, fontElement, "Family", font.family() );
00213     createIntNode( doc, fontElement, "PointSize", font.pointSize() );
00214     createIntNode( doc, fontElement, "PixelSize", font.pixelSize() );
00215     createIntNode( doc, fontElement, "Weight", font.weight() );
00216     createBoolNode( doc, fontElement, "Italic", font.italic() );
00217 }
00218 
00219 
00220 void createPenNode( TQDomDocument& doc, TQDomNode& parent,
00221                     const TQString& elementName, const TQPen& pen )
00222 {
00223     TQDomElement penElement = doc.createElement( elementName );
00224     parent.appendChild( penElement );
00225     createIntNode( doc, penElement, "Width", pen.width() );
00226     createColorNode( doc, penElement, "Color", pen.color() );
00227     createStringNode( doc, penElement, "Style", penStyleToString( pen.style() ) );
00228 }
00229 
00230 
00231 void createDateTimeNode( TQDomDocument& doc, TQDomNode& parent,
00232                          const TQString& elementName,
00233                          const TQDateTime& datetime )
00234 {
00235     TQDomElement dateTimeElement = doc.createElement( elementName );
00236     parent.appendChild( dateTimeElement );
00237     createDateNode( doc, dateTimeElement, "Date", datetime.date() );
00238     createTimeNode( doc, dateTimeElement, "Time", datetime.time() );
00239 }
00240 
00241 
00242 void createDateNode( TQDomDocument& doc, TQDomNode& parent,
00243                      const TQString& elementName, const TQDate& date )
00244 {
00245     TQDomElement dateElement = doc.createElement( elementName );
00246     parent.appendChild( dateElement );
00247     dateElement.setAttribute( "Year", TQString::number( date.year() ) );
00248     dateElement.setAttribute( "Month", TQString::number( date.month() ) );
00249     dateElement.setAttribute( "Day", TQString::number( date.day() ) );
00250 }
00251 
00252 
00253 void createTimeNode( TQDomDocument& doc, TQDomNode& parent,
00254                       const TQString& elementName, const TQTime& time )
00255 {
00256     TQDomElement timeElement = doc.createElement( elementName );
00257     parent.appendChild( timeElement );
00258     timeElement.setAttribute( "Hour",
00259                                TQString::number( time.hour() ) );
00260     timeElement.setAttribute( "Minute",
00261                                TQString::number( time.minute() ) );
00262     timeElement.setAttribute( "Second",
00263                                TQString::number( time.second() ) );
00264     timeElement.setAttribute( "Millisecond",
00265                                TQString::number( time.msec() ) );
00266 }
00267 
00268 
00269 TQString penStyleToString( Qt::PenStyle style )
00270 {
00271     switch( style ) {
00272     case Qt::NoPen:
00273         return "NoPen";
00274     case Qt::SolidLine:
00275         return "SolidLine";
00276     case Qt::DashLine:
00277         return "DashLine";
00278     case Qt::DotLine:
00279         return "DotLine";
00280     case Qt::DashDotLine:
00281         return "DashDotLine";
00282     case Qt::DashDotDotLine:
00283         return "DashDotDotLine";
00284     default: // should not happen
00285         return "SolidLine";
00286     }
00287 }
00288 
00289 
00290 
00291 TQString brushStyleToString( Qt::BrushStyle style )
00292 {
00293     // PENDING(kalle) Support custom patterns
00294     switch( style ) {
00295     case Qt::NoBrush:
00296         return "NoBrush";
00297     case Qt::SolidPattern:
00298         return "SolidPattern";
00299     case Qt::Dense1Pattern:
00300         return "Dense1Pattern";
00301     case Qt::Dense2Pattern:
00302         return "Dense2Pattern";
00303     case Qt::Dense3Pattern:
00304         return "Dense3Pattern";
00305     case Qt::Dense4Pattern:
00306         return "Dense4Pattern";
00307     case Qt::Dense5Pattern:
00308         return "Dense5Pattern";
00309     case Qt::Dense6Pattern:
00310         return "Dense6Pattern";
00311     case Qt::Dense7Pattern:
00312         return "Dense7Pattern";
00313     case Qt::HorPattern:
00314         return "HorPattern";
00315     case Qt::VerPattern:
00316         return "VerPattern";
00317     case Qt::CrossPattern:
00318         return "CrossPattern";
00319     case Qt::BDiagPattern:
00320         return "BDiagPattern";
00321     case Qt::FDiagPattern:
00322         return "FDiagPattern";
00323     case Qt::DiagCrossPattern:
00324         return "DiagCrossPattern";
00325     default: // should not happen (but can for a custom pattern)
00326         return "SolidPattern";
00327     }
00328 }
00329 
00330 
00331 bool readStringNode( const TQDomElement& element, TQString& value )
00332 {
00333     value = element.text();
00334     return true;
00335 }
00336 
00337 
00338 bool readIntNode( const TQDomElement& element, int& value )
00339 {
00340     bool ok = false;
00341     int temp = element.text().toInt( &ok );
00342     if( ok )
00343         value = temp;
00344     return ok;
00345 }
00346 
00347 
00348 bool readDoubleNode( const TQDomElement& element, double& value )
00349 {
00350     bool ok = false;
00351     double temp = element.text().toDouble( &ok );
00352     if( ok )
00353         value = temp;
00354     return ok;
00355 }
00356 
00357 
00358 bool readBoolNode( const TQDomElement& element, bool& value )
00359 {
00360     if( element.text() == "true" ) {
00361         value = true;
00362         return true;
00363     } else if( element.text() == "false" ) {
00364         value = false;
00365         return true;
00366     } else
00367         return false;
00368 }
00369 
00370 
00371 bool readColorNode( const TQDomElement& element, TQColor& value )
00372 {
00373     bool ok = true;
00374     int red, green, blue;
00375     if( element.hasAttribute( "Red" ) ) {
00376         bool redOk = false;
00377         red = element.attribute( "Red" ).toInt( &redOk );
00378         ok = ok & redOk;
00379     }
00380     if( element.hasAttribute( "Green" ) ) {
00381         bool greenOk = false;
00382         green = element.attribute( "Green" ).toInt( &greenOk );
00383         ok = ok & greenOk;
00384     }
00385     if( element.hasAttribute( "Blue" ) ) {
00386         bool blueOk = false;
00387         blue = element.attribute( "Blue" ).toInt( &blueOk );
00388         ok = ok & blueOk;
00389     }
00390 
00391     if( ok )
00392         value.setRgb( red, green, blue );
00393 
00394     return ok;
00395 }
00396 
00397 
00398 bool readBrushNode( const TQDomElement& element, TQBrush& brush )
00399 {
00400     bool ok = true;
00401     TQColor tempColor;
00402     Qt::BrushStyle tempStyle;
00403     TQPixmap tempPixmap;
00404     TQDomNode node = element.firstChild();
00405     while( !node.isNull() ) {
00406         TQDomElement element = node.toElement();
00407         if( !element.isNull() ) { // was really an element
00408             TQString tagName = element.tagName();
00409             if( tagName == "Color" ) {
00410                 ok = ok & readColorNode( element, tempColor );
00411             } else if( tagName == "Style" ) {
00412         TQString value;
00413                 ok = ok & readStringNode( element, value );
00414         tempStyle = stringToBrushStyle( value );
00415             } else if( tagName == "Pixmap" ) {
00416                 ok = ok & readPixmapNode( element, tempPixmap );
00417             } else {
00418                 tqDebug( "Unknown tag in brush" );
00419             }
00420         }
00421         node = node.nextSibling();
00422     }
00423 
00424     if( ok ) {
00425     brush.setColor( tempColor );
00426     brush.setStyle( tempStyle );
00427         if( !tempPixmap.isNull() )
00428             brush.setPixmap( tempPixmap );
00429     }
00430 
00431     return ok;
00432 }
00433 
00434 
00435 bool readPixmapNode( const TQDomElement& element, TQPixmap& pixmap )
00436 {
00437     bool ok = true;
00438     int tempLengthi;
00439     TQString tempData;
00440     TQDomNode node = element.firstChild();
00441     while( !node.isNull() ) {
00442         TQDomElement element = node.toElement();
00443         if( !element.isNull() ) { // was really an element
00444             TQString tagName = element.tagName();
00445             if( tagName == "Format" ) {
00446                 TQString formatName;
00447                 ok = ok & readStringNode( element, formatName );
00448 #ifndef NDEBUG
00449                 if( formatName != "XPM.GZ" )
00450                     tqDebug( "Unsupported pixmap format in XML file" );
00451 #endif
00452             } else if( tagName == "Length" ) {
00453                 ok = ok & readIntNode( element, tempLengthi );
00454             } else if( tagName == "Data" ) {
00455                 ok = ok & readStringNode( element, tempData );
00456             } else {
00457                 tqDebug( "Unknown tag in Pixmap" );
00458             }
00459         }
00460         node = node.nextSibling();
00461     }
00462 
00463     if( ok ) {
00464     if( 0 < tempLengthi ) {
00465             // Decode the image file format in the same way TQt Designer does.
00466             char *ba = new char[ tempData.length() / 2 ];
00467             for ( int i = 0; i < (int)tempData.length() / 2; ++i ) {
00468                 char h = tempData[ 2 * i ].latin1();
00469                 char l = tempData[ 2 * i  + 1 ].latin1();
00470                 uchar r = 0;
00471                 if ( h <= '9' )
00472                     r += h - '0';
00473                 else
00474                     r += h - 'a' + 10;
00475                 r = r << 4;
00476                 if ( l <= '9' )
00477                     r += l - '0';
00478                 else
00479                     r += l - 'a' + 10;
00480                 ba[ i ] = r;
00481             }
00482 
00483             if( tempLengthi < (int)tempData.length() * 5 )
00484                 tempLengthi = tempData.length() * 5;
00485             unsigned long tempLength = tempLengthi;
00486             TQByteArray baunzip( tempLength );
00487             ::uncompress( (uchar*) baunzip.data(), &tempLength,
00488                           (uchar*) ba, tempData.length()/2 );
00489             TQImage image;
00490             image.loadFromData( (const uchar*)baunzip.data(), tempLength, "XPM" );
00491 
00492             if( image.isNull() )
00493                 pixmap.resize( 0, 0 ); // This is _not_ an error, we just read a NULL pixmap!
00494             else
00495                 ok = ok & pixmap.convertFromImage( image, 0 );
00496         } else
00497             pixmap.resize( 0, 0 ); // This is _not_ an error, we just read a empty pixmap!
00498     }
00499 
00500     return ok;
00501 }
00502 
00503 
00504 bool readPenNode( const TQDomElement& element, TQPen& pen )
00505 {
00506     bool ok = true;
00507     int tempWidth;
00508     TQColor tempColor;
00509     Qt::PenStyle tempStyle;
00510     TQDomNode node = element.firstChild();
00511     while( !node.isNull() ) {
00512         TQDomElement element = node.toElement();
00513         if( !element.isNull() ) { // was really an element
00514             TQString tagName = element.tagName();
00515             if( tagName == "Width" ) {
00516                 ok = ok & readIntNode( element, tempWidth );
00517             } else if( tagName == "Color" ) {
00518                 ok = ok & readColorNode( element, tempColor );
00519             } else if( tagName == "Style" ) {
00520         TQString value;
00521                 ok = ok & readStringNode( element, value );
00522         tempStyle = stringToPenStyle( value );
00523             } else {
00524                 tqDebug( "Unknown tag in brush" );
00525             }
00526         }
00527         node = node.nextSibling();
00528     }
00529 
00530     if( ok ) {
00531         pen.setWidth( tempWidth );
00532     pen.setColor( tempColor );
00533     pen.setStyle( tempStyle );
00534     }
00535 
00536     return ok;
00537 }
00538 
00539 bool readFontNode( const TQDomElement& element, TQFont& font )
00540 {
00541     bool ok = true;
00542     TQString family;
00543     int pointSize, pixelSize, weight;
00544     bool italic;
00545     int charSet;
00546     TQDomNode node = element.firstChild();
00547     while( !node.isNull() ) {
00548         TQDomElement element = node.toElement();
00549         if( !element.isNull() ) { // was really an element
00550             TQString tagName = element.tagName();
00551             if( tagName == "Family" ) {
00552                 ok = ok & readStringNode( element, family );
00553             } else if( tagName == "PointSize" ) {
00554                 ok = ok & readIntNode( element, pointSize );
00555             } else if( tagName == "PixelSize" ) {
00556                 ok = ok & readIntNode( element, pixelSize );
00557             } else if( tagName == "Weight" ) {
00558                 ok = ok & readIntNode( element, weight );
00559             } else if( tagName == "Italic" ) {
00560                 ok = ok & readBoolNode( element, italic );
00561             } else if( tagName == "CharSet" ) {
00562                 ok = ok & readIntNode( element, charSet );
00563             } else {
00564                 tqDebug( "Unknown tag in color map" );
00565             }
00566         }
00567         node = node.nextSibling();
00568     }
00569 
00570     if( ok ) {
00571         font.setFamily( family );
00572     if ( pointSize > 0 ) font.setPointSize( pointSize );
00573     if ( pixelSize > 0 ) font.setPixelSize( pixelSize );
00574         font.setWeight( weight );
00575         font.setItalic( italic );
00576     }
00577 
00578     return ok;
00579 }
00580 
00581 bool readRectNode( const TQDomElement& element, TQRect& value )
00582 {
00583     bool ok = true;
00584     int width, height, x, y;
00585     TQDomNode node = element.firstChild();
00586     while( !node.isNull() ) {
00587         TQDomElement element = node.toElement();
00588         if( !element.isNull() ) { // was really an element
00589             TQString tagName = element.tagName();
00590             if( tagName == "Width" ) {
00591                 ok = ok & readIntNode( element, width );
00592             } else if( tagName == "Height" ) {
00593                 ok = ok & readIntNode( element, height );
00594             } else if( tagName == "X" ) {
00595                 ok = ok & readIntNode( element, x );
00596             } else if( tagName == "Y" ) {
00597                 ok = ok & readIntNode( element, y );
00598             } else {
00599                 tqDebug( "Unknown tag in rect" );
00600             }
00601         }
00602         node = node.nextSibling();
00603     }
00604 
00605     if( ok ) {
00606         value.setX( x );
00607         value.setY( y );
00608         value.setWidth( width );
00609         value.setHeight( height );
00610     }
00611 
00612     return ok;
00613 }
00614 
00615 
00616 
00617 bool readDateTimeNode( const TQDomElement& element, TQDateTime& datetime )
00618 {
00619     bool ok = true;
00620     TQDate tempDate;
00621     TQTime tempTime;
00622     TQDomNode node = element.firstChild();
00623     while( !node.isNull() ) {
00624         TQDomElement element = node.toElement();
00625         if( !element.isNull() ) { // was really an element
00626             TQString tagName = element.tagName();
00627             if( tagName == "Date" ) {
00628                 ok = ok & readDateNode( element, tempDate );
00629             } else if( tagName == "Time" ) {
00630                 ok = ok & readTimeNode( element, tempTime );
00631             } else {
00632                 tqDebug( "Unknown tag in datetime" );
00633             }
00634         }
00635         node = node.nextSibling();
00636     }
00637 
00638     if( ok ) {
00639         datetime.setDate( tempDate );
00640         datetime.setTime( tempTime );
00641     }
00642 
00643     return ok;
00644 }
00645 
00646 
00647 bool readDateNode( const TQDomElement& element, TQDate& value )
00648 {
00649     bool ok = true;
00650     int year, month, day;
00651     if( element.hasAttribute( "Year" ) ) {
00652         bool yearOk = false;
00653         year = element.attribute( "Year" ).toInt( &yearOk );
00654         ok = ok & yearOk;
00655     }
00656     if( element.hasAttribute( "Month" ) ) {
00657         bool monthOk = false;
00658         month = element.attribute( "Month" ).toInt( &monthOk );
00659         ok = ok & monthOk;
00660     }
00661     if( element.hasAttribute( "Day" ) ) {
00662         bool dayOk = false;
00663         day = element.attribute( "Day" ).toInt( &dayOk );
00664         ok = ok & dayOk;
00665     }
00666 
00667     if( ok )
00668         value.setYMD( year, month, day );
00669 
00670     return ok;
00671 }
00672 
00673 
00674 
00675 bool readTimeNode( const TQDomElement& element, TQTime& value )
00676 {
00677     bool ok = true;
00678     int hour, minute, second, msec;
00679     if( element.hasAttribute( "Hour" ) ) {
00680         bool hourOk = false;
00681         hour = element.attribute( "Hour" ).toInt( &hourOk );
00682         ok = ok & hourOk;
00683     }
00684     if( element.hasAttribute( "Minute" ) ) {
00685         bool minuteOk = false;
00686         minute = element.attribute( "Minute" ).toInt( &minuteOk );
00687         ok = ok & minuteOk;
00688     }
00689     if( element.hasAttribute( "Second" ) ) {
00690         bool secondOk = false;
00691         second = element.attribute( "Second" ).toInt( &secondOk );
00692         ok = ok & secondOk;
00693     }
00694     if( element.hasAttribute( "Millisecond" ) ) {
00695         bool msecOk = false;
00696         msec = element.attribute( "Millisecond" ).toInt( &msecOk );
00697         ok = ok & msecOk;
00698     }
00699 
00700     if( ok )
00701         value.setHMS( hour, minute, second, msec );
00702 
00703     return ok;
00704 }
00705 
00706 
00707 
00708 Qt::PenStyle stringToPenStyle( const TQString& style )
00709 {
00710     if( style == "NoPen" )
00711         return Qt::NoPen;
00712     else if( style == "SolidLine" )
00713         return Qt::SolidLine;
00714     else if( style == "DashLine" )
00715         return Qt::DashLine;
00716     else if( style == "DotLine" )
00717         return Qt::DotLine;
00718     else if( style == "DashDotLine" )
00719         return Qt::DashDotLine;
00720     else if( style == "DashDotDotLine" )
00721         return Qt::DashDotDotLine;
00722     else // should not happen
00723         return Qt::SolidLine;
00724 }
00725 
00726 
00727 Qt::BrushStyle stringToBrushStyle( const TQString& style )
00728 {
00729     // PENDING(kalle) Support custom patterns
00730     if( style == "NoBrush" )
00731         return Qt::NoBrush;
00732     else if( style == "SolidPattern" )
00733         return Qt::SolidPattern;
00734     else if( style == "Dense1Pattern" )
00735         return Qt::Dense1Pattern;
00736     else if( style == "Dense2Pattern" )
00737         return Qt::Dense2Pattern;
00738     else if( style == "Dense3Pattern" )
00739         return Qt::Dense3Pattern;
00740     else if( style == "Dense4Pattern" )
00741         return Qt::Dense4Pattern;
00742     else if( style == "Dense5Pattern" )
00743         return Qt::Dense5Pattern;
00744     else if( style == "Dense6Pattern" )
00745         return Qt::Dense6Pattern;
00746     else if( style == "Dense7Pattern" )
00747         return Qt::Dense7Pattern;
00748     else if( style == "HorPattern" )
00749         return Qt::HorPattern;
00750     else if( style == "VerPattern" )
00751         return Qt::VerPattern;
00752     else if( style == "CrossPattern" )
00753         return Qt::CrossPattern;
00754     else if( style == "BDiagPattern" )
00755         return Qt::BDiagPattern;
00756     else if( style == "FDiagPattern" )
00757         return Qt::FDiagPattern;
00758     else if( style == "DiagCrossPattern" )
00759         return Qt::DiagCrossPattern;
00760     else // should not happen (but can with custom patterns)
00761         return Qt::SolidPattern;
00762 }
00763 
00764 }