kchart

KDXMLTools.cpp

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