kchart

KDXMLTools.cpp
1/*
2 KDChart - a multi-platform charting engine
3 */
4
5/****************************************************************************
6 ** Copyright (C) 2001-2003 Klarälvdalens Datakonsult AB. All rights reserved.
7 **
8 ** This file is part of the KDChart library.
9 **
10 ** This file may be distributed and/or modified under the terms of the
11 ** GNU General Public License version 2 as published by the Free Software
12 ** Foundation and appearing in the file LICENSE.GPL included in the
13 ** packaging of this file.
14 **
15 ** Licensees holding valid commercial KDChart licenses may use this file in
16 ** accordance with the KDChart Commercial License Agreement provided with
17 ** the Software.
18 **
19 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
20 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
21 **
22 ** See http://www.klaralvdalens-datakonsult.se/?page=products for
23 ** information about KDChart Commercial License Agreements.
24 **
25 ** Contact info@klaralvdalens-datakonsult.se if any conditions of this
26 ** licensing are not clear to you.
27 **
28 **********************************************************************/
29#include "KDXMLTools.h"
30#include <tqbuffer.h>
31#include <tqimage.h>
32#include <zlib.h>
33
34namespace KDXML {
35
36 void createBoolNode( TQDomDocument& doc, TQDomNode& parent,
37 const TQString& elementName, bool value )
38 {
39 TQDomElement newElement =
40 doc.createElement( elementName );
41 parent.appendChild( newElement );
42 TQDomText elementContent =
43 doc.createTextNode( value ? "true" : "false" );
44 newElement.appendChild( elementContent );
45 }
46
47
48 void createOrientationNode( TQDomDocument& doc, TQDomNode& parent,
49 const TQString& elementName, TQt::Orientation value )
50 {
51 TQDomElement newElement =
52 doc.createElement( elementName );
53 parent.appendChild( newElement );
54 TQDomText elementContent =
55 doc.createTextNode( (TQt::Vertical == value) ? "vertical" : "horizontal" );
56 newElement.appendChild( elementContent );
57 }
58
59
60
61 void createSizeNode( TQDomDocument& doc, TQDomNode& parent,
62 const TQString& elementName, const TQSize& value )
63 {
64 TQDomElement newElement =
65 doc.createElement( elementName );
66 parent.appendChild( newElement );
67 newElement.setAttribute( "Width", value.width() );
68 newElement.setAttribute( "Height", value.height() );
69 }
70
71
72 void createIntNode( TQDomDocument& doc, TQDomNode& parent,
73 const TQString& elementName, int value )
74 {
75 TQDomElement newElement =
76 doc.createElement( elementName );
77 parent.appendChild( newElement );
78 TQDomText elementContent =
79 doc.createTextNode( TQString::number( value ) );
80 newElement.appendChild( elementContent );
81 }
82
83
84 void createDoubleNode( TQDomDocument& doc, TQDomNode& parent,
85 const TQString& elementName, double value )
86 {
87 TQDomElement newElement =
88 doc.createElement( elementName );
89 parent.appendChild( newElement );
90 TQDomText elementContent =
91 doc.createTextNode( TQString::number( value ) );
92 newElement.appendChild( elementContent );
93 }
94
95
96 void createStringNode( TQDomDocument& doc, TQDomNode& parent,
97 const TQString& elementName,
98 const TQString& text )
99 {
100 TQDomElement newElement =
101 doc.createElement( elementName );
102 parent.appendChild( newElement );
103 TQDomText elementContent =
104 doc.createTextNode( text );
105 newElement.appendChild( elementContent );
106 }
107
108
109 void createColorNode( TQDomDocument& doc, TQDomNode& parent,
110 const TQString& elementName, const TQColor& color )
111 {
112 TQDomElement colorElement = doc.createElement( elementName );
113 parent.appendChild( colorElement );
114 colorElement.setAttribute( "Red",
115 TQString::number( color.red() ) );
116 colorElement.setAttribute( "Green",
117 TQString::number( color.green() ) );
118 colorElement.setAttribute( "Blue",
119 TQString::number( color.blue() ) );
120 }
121
122
123 void createBrushNode( TQDomDocument& doc, TQDomNode& parent,
124 const TQString& elementName, const TQBrush& brush )
125
126 {
127 TQDomElement brushElement = doc.createElement( elementName );
128 parent.appendChild( brushElement );
129 createColorNode( doc, brushElement, "Color", brush.color() );
130 createStringNode( doc, brushElement, "Style",
131 KDXML::brushStyleToString( brush.style() ) );
132 if( brush.style() == TQt::CustomPattern && brush.pixmap() )
133 createPixmapNode( doc, brushElement, "Pixmap", *brush.pixmap() );
134 }
135
136
137 void createPixmapNode( TQDomDocument& doc, TQDomNode& parent,
138 const TQString& elementName, const TQPixmap& pixmap )
139 {
140 TQDomElement pixmapElement = doc.createElement( elementName );
141 parent.appendChild( pixmapElement );
142
143 createStringNode( doc, pixmapElement, "Format", "XPM.GZ" );
144 if( pixmap.isNull() ){
145 // we store an empty image without any data
146 createIntNode( doc, pixmapElement, "Length", 0 );
147 }else{
148 // Convert the pixmap to an image, save that image to an in-memory
149 // XPM representation and compress this representation. This
150 // conforms to the file format TQt Designer uses.
151 TQByteArray ba;
152 TQBuffer buffer( ba );
153 buffer.open( IO_WriteOnly );
154 TQImageIO imgio( &buffer, "XPM" );
155 TQImage image = pixmap.convertToImage();
156 imgio.setImage( image );
157 imgio.write();
158 buffer.close();
159 ulong len = ba.size() * 2;
160 TQByteArray bazip( len );
161 ::compress( (uchar*) bazip.data(), &len, (uchar*) ba.data(), ba.size() );
162 TQString dataString;
163 static const char hexchars[] = "0123456789abcdef";
164 for ( int i = 0; i < (int)len; ++i ) {
165 uchar c = (uchar) bazip[i];
166 dataString += hexchars[c >> 4];
167 dataString += hexchars[c & 0x0f];
168 }
169 createIntNode( doc, pixmapElement, "Length", ba.size() );
170 createStringNode( doc, pixmapElement, "Data", dataString );
171 }
172 }
173
174
175 void createRectNode( TQDomDocument& doc, TQDomNode& parent,
176 const TQString& elementName, const TQRect& rect )
177 {
178 TQDomElement rectElement = doc.createElement( elementName );
179 parent.appendChild( rectElement );
180 TQDomElement xElement = doc.createElement( "X" );
181 rectElement.appendChild( xElement );
182 TQDomText xContent = doc.createTextNode( TQString::number( rect.x() ) );
183 xElement.appendChild( xContent );
184 TQDomElement yElement = doc.createElement( "Y" );
185 rectElement.appendChild( yElement );
186 TQDomText yContent = doc.createTextNode( TQString::number( rect.y() ) );
187 yElement.appendChild( yContent );
188 TQDomElement widthElement = doc.createElement( "Width" );
189 rectElement.appendChild( widthElement );
190 TQDomText widthContent = doc.createTextNode( TQString::number( rect.width() ) );
191 widthElement.appendChild( widthContent );
192 TQDomElement heightElement = doc.createElement( "Height" );
193 rectElement.appendChild( heightElement );
194 TQDomText heightContent = doc.createTextNode( TQString::number( rect.height() ) );
195 heightElement.appendChild( heightContent );
196 }
197
198
199 void createStringListNodes( TQDomDocument& doc, TQDomNode& parent,
200 const TQString& elementName,
201 const TQStringList* list )
202 {
203 if( !list )
204 return;
205
206 for( TQStringList::ConstIterator it = list->begin();
207 it != list->end(); ++it ) {
208 TQDomElement element = doc.createElement( elementName );
209 parent.appendChild( element );
210 TQDomText elementContent = doc.createTextNode( *it );
211 element.appendChild( elementContent );
212 }
213 }
214
215
216 void createFontNode( TQDomDocument& doc, TQDomNode& parent,
217 const TQString& elementName, const TQFont& font )
218 {
219 TQDomElement fontElement = doc.createElement( elementName );
220 parent.appendChild( fontElement );
221 createStringNode( doc, fontElement, "Family", font.family() );
222 createIntNode( doc, fontElement, "PointSize", font.pointSize() );
223 createIntNode( doc, fontElement, "Weight", font.weight() );
224 createBoolNode( doc, fontElement, "Italic", font.italic() );
225 }
226
227
228 void createPenNode( TQDomDocument& doc, TQDomNode& parent,
229 const TQString& elementName, const TQPen& pen )
230 {
231 TQDomElement penElement = doc.createElement( elementName );
232 parent.appendChild( penElement );
233 createIntNode( doc, penElement, "Width", pen.width() );
234 createColorNode( doc, penElement, "Color", pen.color() );
235 createStringNode( doc, penElement, "Style", penStyleToString( pen.style() ) );
236 }
237
238
239 void createDateTimeNode( TQDomDocument& doc, TQDomNode& parent,
240 const TQString& elementName,
241 const TQDateTime& datetime )
242 {
243 TQDomElement dateTimeElement = doc.createElement( elementName );
244 parent.appendChild( dateTimeElement );
245 createDateNode( doc, dateTimeElement, "Date", datetime.date() );
246 createTimeNode( doc, dateTimeElement, "Time", datetime.time() );
247 }
248
249
250 void createDateNode( TQDomDocument& doc, TQDomNode& parent,
251 const TQString& elementName, const TQDate& date )
252 {
253 TQDomElement dateElement = doc.createElement( elementName );
254 parent.appendChild( dateElement );
255 dateElement.setAttribute( "Year", TQString::number( date.year() ) );
256 dateElement.setAttribute( "Month", TQString::number( date.month() ) );
257 dateElement.setAttribute( "Day", TQString::number( date.day() ) );
258 }
259
260
261 void createTimeNode( TQDomDocument& doc, TQDomNode& parent,
262 const TQString& elementName, const TQTime& time )
263 {
264 TQDomElement timeElement = doc.createElement( elementName );
265 parent.appendChild( timeElement );
266 timeElement.setAttribute( "Hour",
267 TQString::number( time.hour() ) );
268 timeElement.setAttribute( "Minute",
269 TQString::number( time.minute() ) );
270 timeElement.setAttribute( "Second",
271 TQString::number( time.second() ) );
272 timeElement.setAttribute( "Millisecond",
273 TQString::number( time.msec() ) );
274 }
275
276
277 TQString penStyleToString( TQt::PenStyle style )
278 {
279 switch( style ) {
280 case TQt::NoPen:
281 return "NoPen";
282 case TQt::SolidLine:
283 return "SolidLine";
284 case TQt::DashLine:
285 return "DashLine";
286 case TQt::DotLine:
287 return "DotLine";
288 case TQt::DashDotLine:
289 return "DashDotLine";
290 case TQt::DashDotDotLine:
291 return "DashDotDotLine";
292 default: // should not happen
293 return "SolidLine";
294 }
295 }
296
297
298
299 TQString brushStyleToString( TQt::BrushStyle style )
300 {
301 // PENDING(kalle) Support custom patterns
302 switch( style ) {
303 case TQt::NoBrush:
304 return "NoBrush";
305 case TQt::SolidPattern:
306 return "SolidPattern";
307 case TQt::Dense1Pattern:
308 return "Dense1Pattern";
309 case TQt::Dense2Pattern:
310 return "Dense2Pattern";
311 case TQt::Dense3Pattern:
312 return "Dense3Pattern";
313 case TQt::Dense4Pattern:
314 return "Dense4Pattern";
315 case TQt::Dense5Pattern:
316 return "Dense5Pattern";
317 case TQt::Dense6Pattern:
318 return "Dense6Pattern";
319 case TQt::Dense7Pattern:
320 return "Dense7Pattern";
321 case TQt::HorPattern:
322 return "HorPattern";
323 case TQt::VerPattern:
324 return "VerPattern";
325 case TQt::CrossPattern:
326 return "CrossPattern";
327 case TQt::BDiagPattern:
328 return "BDiagPattern";
329 case TQt::FDiagPattern:
330 return "FDiagPattern";
331 case TQt::DiagCrossPattern:
332 return "DiagCrossPattern";
333 default: // should not happen (but can for a custom pattern)
334 return "SolidPattern";
335 }
336 }
337
338
339 bool readStringNode( const TQDomElement& element, TQString& value )
340 {
341 value = element.text();
342 return true;
343 }
344
345
346 bool readIntNode( const TQDomElement& element, int& value )
347 {
348 bool ok = false;
349 int temp = element.text().toInt( &ok );
350 if( ok )
351 value = temp;
352 return ok;
353 }
354
355
356 bool readDoubleNode( const TQDomElement& element, double& value )
357 {
358 bool ok = false;
359 double temp = element.text().toDouble( &ok );
360 if( ok )
361 value = temp;
362 return ok;
363 }
364
365
366 bool readBoolNode( const TQDomElement& element, bool& value )
367 {
368 if( element.text() == "true" ) {
369 value = true;
370 return true;
371 } else if( element.text() == "false" ) {
372 value = false;
373 return true;
374 } else
375 return false;
376 }
377
378
379 bool readOrientationNode( const TQDomElement& element, TQt::Orientation& value )
380 {
381 if( element.text() == "vertical" ) {
382 value = TQt::Vertical;
383 return true;
384 } else if( element.text() == "horizontal" ) {
385 value = TQt::Horizontal;
386 return true;
387 } else
388 return false;
389 }
390
391
392 bool readSizeNode( const TQDomElement& element, TQSize& value )
393 {
394 bool ok = false;
395 int width, height;
396 if( element.hasAttribute( "Width" ) ) {
397 width = element.attribute( "Width" ).toInt( &ok );
398 if( ok && element.hasAttribute( "Height" ) ) {
399 height = element.attribute( "Height" ).toInt( &ok );
400 if( ok ){
401 value.setWidth( width );
402 value.setHeight( height );
403 }
404 }
405 }
406 return ok;
407 }
408
409
410 bool readColorNode( const TQDomElement& element, TQColor& value )
411 {
412 bool ok = true;
413 int red=0, green=0, blue=0;
414 if( element.hasAttribute( "Red" ) ) {
415 bool redOk = false;
416 red = element.attribute( "Red" ).toInt( &redOk );
417 ok = ok & redOk;
418 }
419 if( element.hasAttribute( "Green" ) ) {
420 bool greenOk = false;
421 green = element.attribute( "Green" ).toInt( &greenOk );
422 ok = ok & greenOk;
423 }
424 if( element.hasAttribute( "Blue" ) ) {
425 bool blueOk = false;
426 blue = element.attribute( "Blue" ).toInt( &blueOk );
427 ok = ok & blueOk;
428 }
429
430 if( ok )
431 value.setRgb( red, green, blue );
432
433 return ok;
434 }
435
436
437 bool readBrushNode( const TQDomElement& element, TQBrush& brush )
438 {
439 bool ok = true;
440 TQColor tempColor;
441 TQt::BrushStyle tempStyle=TQt::SolidPattern;
442 TQPixmap tempPixmap;
443 TQDomNode node = element.firstChild();
444 while( !node.isNull() ) {
445 TQDomElement element = node.toElement();
446 if( !element.isNull() ) { // was really an element
447 TQString tagName = element.tagName();
448 if( tagName == "Color" ) {
449 ok = ok & readColorNode( element, tempColor );
450 } else if( tagName == "Style" ) {
451 TQString value;
452 ok = ok & readStringNode( element, value );
453 tempStyle = stringToBrushStyle( value );
454 } else if( tagName == "Pixmap" ) {
455 ok = ok & readPixmapNode( element, tempPixmap );
456 } else {
457 tqDebug( "Unknown tag in brush" );
458 }
459 }
460 node = node.nextSibling();
461 }
462
463 if( ok ) {
464 brush.setColor( tempColor );
465 brush.setStyle( tempStyle );
466 if( !tempPixmap.isNull() )
467 brush.setPixmap( tempPixmap );
468 }
469
470 return ok;
471 }
472
473
474 bool readPixmapNode( const TQDomElement& element, TQPixmap& pixmap )
475 {
476 bool ok = true;
477 unsigned long tempLength;
478 TQString tempData;
479 TQDomNode node = element.firstChild();
480 while( !node.isNull() ) {
481 TQDomElement element = node.toElement();
482 if( !element.isNull() ) { // was really an element
483 TQString tagName = element.tagName();
484 if( tagName == "Format" ) {
485 TQString formatName;
486 ok = ok & readStringNode( element, formatName );
487#ifndef NDEBUG
488 if( formatName != "XPM.GZ" )
489 tqDebug( "Unsupported pixmap format in XML file" );
490#endif
491 } else if( tagName == "Length" ) {
492 int itempLength;
493 ok = ok & readIntNode( element, itempLength );
494 tempLength = itempLength;
495 } else if( tagName == "Data" ) {
496 ok = ok & readStringNode( element, tempData );
497 } else {
498 tqDebug( "Unknown tag in Pixmap" );
499 }
500 }
501 node = node.nextSibling();
502 }
503
504 if( ok ) {
505 if( 0 < tempLength ) {
506 // Decode the image file format in the same way TQt Designer does.
507 char *ba = new char[ tempData.length() / 2 ];
508 for ( int i = 0; i < (int)tempData.length() / 2; ++i ) {
509 char h = tempData[ 2 * i ].latin1();
510 char l = tempData[ 2 * i + 1 ].latin1();
511 uchar r = 0;
512 if ( h <= '9' )
513 r += h - '0';
514 else
515 r += h - 'a' + 10;
516 r = r << 4;
517 if ( l <= '9' )
518 r += l - '0';
519 else
520 r += l - 'a' + 10;
521 ba[ i ] = r;
522 }
523
524 if( tempLength < tempData.length() * 5 )
525 tempLength = tempData.length() * 5;
526 TQByteArray baunzip( tempLength );
527 ::uncompress( (uchar*) baunzip.data(), &tempLength,
528 (uchar*) ba, tempData.length()/2 );
529 TQImage image;
530 image.loadFromData( (const uchar*)baunzip.data(), tempLength, "XPM" );
531
532 if( image.isNull() )
533 pixmap.resize( 0, 0 ); // This is _not_ an error, we just read a NULL pixmap!
534 else
535 ok = ok & pixmap.convertFromImage( image, 0 );
536 } else
537 pixmap.resize( 0, 0 ); // This is _not_ an error, we just read a empty pixmap!
538 }
539
540 return ok;
541 }
542
543
544 bool readPenNode( const TQDomElement& element, TQPen& pen )
545 {
546 bool ok = true;
547 int tempWidth;
548 TQColor tempColor;
549 TQt::PenStyle tempStyle=TQt::SolidLine;
550 TQDomNode node = element.firstChild();
551 while( !node.isNull() ) {
552 TQDomElement element = node.toElement();
553 if( !element.isNull() ) { // was really an element
554 TQString tagName = element.tagName();
555 if( tagName == "Width" ) {
556 ok = ok & readIntNode( element, tempWidth );
557 } else if( tagName == "Color" ) {
558 ok = ok & readColorNode( element, tempColor );
559 } else if( tagName == "Style" ) {
560 TQString value;
561 ok = ok & readStringNode( element, value );
562 tempStyle = stringToPenStyle( value );
563 } else {
564 tqDebug( "Unknown tag in brush" );
565 }
566 }
567 node = node.nextSibling();
568 }
569
570 if( ok ) {
571 pen.setWidth( tempWidth );
572 pen.setColor( tempColor );
573 pen.setStyle( tempStyle );
574 }
575
576 return ok;
577 }
578
579 bool readFontNode( const TQDomElement& element, TQFont& font )
580 {
581 bool ok = true;
582 TQString family;
583 int pointSize, weight;
584 bool italic;
585 int charSet;
586 TQDomNode node = element.firstChild();
587 while( !node.isNull() ) {
588 TQDomElement element = node.toElement();
589 if( !element.isNull() ) { // was really an element
590 TQString tagName = element.tagName();
591 if( tagName == "Family" ) {
592 ok = ok & readStringNode( element, family );
593 } else if( tagName == "PointSize" ) {
594 ok = ok & readIntNode( element, pointSize );
595 } else if( tagName == "Weight" ) {
596 ok = ok & readIntNode( element, weight );
597 } else if( tagName == "Italic" ) {
598 ok = ok & readBoolNode( element, italic );
599 } else if( tagName == "CharSet" ) {
600 ok = ok & readIntNode( element, charSet );
601 } else {
602 tqDebug( "Unknown tag in color map" );
603 }
604 }
605 node = node.nextSibling();
606 }
607
608 if( ok ) {
609 font.setFamily( family );
610 font.setPointSize( pointSize );
611 font.setWeight( weight );
612 font.setItalic( italic );
613 }
614
615 return ok;
616 }
617
618 bool readRectNode( const TQDomElement& element, TQRect& value )
619 {
620 bool ok = true;
621 int width, height, x, y;
622 TQDomNode node = element.firstChild();
623 while( !node.isNull() ) {
624 TQDomElement element = node.toElement();
625 if( !element.isNull() ) { // was really an element
626 TQString tagName = element.tagName();
627 if( tagName == "Width" ) {
628 ok = ok & readIntNode( element, width );
629 } else if( tagName == "Height" ) {
630 ok = ok & readIntNode( element, height );
631 } else if( tagName == "X" ) {
632 ok = ok & readIntNode( element, x );
633 } else if( tagName == "Y" ) {
634 ok = ok & readIntNode( element, y );
635 } else {
636 tqDebug( "Unknown tag in rect" );
637 }
638 }
639 node = node.nextSibling();
640 }
641
642 if( ok ) {
643 value.setX( x );
644 value.setY( y );
645 value.setWidth( width );
646 value.setHeight( height );
647 }
648
649 return ok;
650 }
651
652
653
654 bool readDateTimeNode( const TQDomElement& element, TQDateTime& datetime )
655 {
656 bool ok = true;
657 TQDate tempDate;
658 TQTime tempTime;
659 TQDomNode node = element.firstChild();
660 while( !node.isNull() ) {
661 TQDomElement element = node.toElement();
662 if( !element.isNull() ) { // was really an element
663 TQString tagName = element.tagName();
664 if( tagName == "Date" ) {
665 ok = ok & readDateNode( element, tempDate );
666 } else if( tagName == "Time" ) {
667 ok = ok & readTimeNode( element, tempTime );
668 } else {
669 tqDebug( "Unknown tag in datetime" );
670 }
671 }
672 node = node.nextSibling();
673 }
674
675 if( ok ) {
676 datetime.setDate( tempDate );
677 datetime.setTime( tempTime );
678 }
679
680 return ok;
681 }
682
683
684 bool readDateNode( const TQDomElement& element, TQDate& value )
685 {
686 bool ok = true;
687 int year=0, month=0, day=0;
688 if( element.hasAttribute( "Year" ) ) {
689 bool yearOk = false;
690 year = element.attribute( "Year" ).toInt( &yearOk );
691 ok = ok & yearOk;
692 }
693 if( element.hasAttribute( "Month" ) ) {
694 bool monthOk = false;
695 month = element.attribute( "Month" ).toInt( &monthOk );
696 ok = ok & monthOk;
697 }
698 if( element.hasAttribute( "Day" ) ) {
699 bool dayOk = false;
700 day = element.attribute( "Day" ).toInt( &dayOk );
701 ok = ok & dayOk;
702 }
703
704 if( ok )
705 value.setYMD( year, month, day );
706
707 return ok;
708 }
709
710
711
712 bool readTimeNode( const TQDomElement& element, TQTime& value )
713 {
714 bool ok = true;
715 int hour=0, minute=0, second=0, msec=0;
716 if( element.hasAttribute( "Hour" ) ) {
717 bool hourOk = false;
718 hour = element.attribute( "Hour" ).toInt( &hourOk );
719 ok = ok & hourOk;
720 }
721 if( element.hasAttribute( "Minute" ) ) {
722 bool minuteOk = false;
723 minute = element.attribute( "Minute" ).toInt( &minuteOk );
724 ok = ok & minuteOk;
725 }
726 if( element.hasAttribute( "Second" ) ) {
727 bool secondOk = false;
728 second = element.attribute( "Second" ).toInt( &secondOk );
729 ok = ok & secondOk;
730 }
731 if( element.hasAttribute( "Millisecond" ) ) {
732 bool msecOk = false;
733 msec = element.attribute( "Millisecond" ).toInt( &msecOk );
734 ok = ok & msecOk;
735 }
736
737 if( ok )
738 value.setHMS( hour, minute, second, msec );
739
740 return ok;
741 }
742
743
744
745 TQt::PenStyle stringToPenStyle( const TQString& style )
746 {
747 if( style == "NoPen" )
748 return TQt::NoPen;
749 else if( style == "SolidLine" )
750 return TQt::SolidLine;
751 else if( style == "DashLine" )
752 return TQt::DashLine;
753 else if( style == "DotLine" )
754 return TQt::DotLine;
755 else if( style == "DashDotLine" )
756 return TQt::DashDotLine;
757 else if( style == "DashDotDotLine" )
758 return TQt::DashDotDotLine;
759 else // should not happen
760 return TQt::SolidLine;
761 }
762
763
764 TQt::BrushStyle stringToBrushStyle( const TQString& style )
765 {
766 // PENDING(kalle) Support custom patterns
767 if( style == "NoBrush" )
768 return TQt::NoBrush;
769 else if( style == "SolidPattern" )
770 return TQt::SolidPattern;
771 else if( style == "Dense1Pattern" )
772 return TQt::Dense1Pattern;
773 else if( style == "Dense2Pattern" )
774 return TQt::Dense2Pattern;
775 else if( style == "Dense3Pattern" )
776 return TQt::Dense3Pattern;
777 else if( style == "Dense4Pattern" )
778 return TQt::Dense4Pattern;
779 else if( style == "Dense5Pattern" )
780 return TQt::Dense5Pattern;
781 else if( style == "Dense6Pattern" )
782 return TQt::Dense6Pattern;
783 else if( style == "Dense7Pattern" )
784 return TQt::Dense7Pattern;
785 else if( style == "HorPattern" )
786 return TQt::HorPattern;
787 else if( style == "VerPattern" )
788 return TQt::VerPattern;
789 else if( style == "CrossPattern" )
790 return TQt::CrossPattern;
791 else if( style == "BDiagPattern" )
792 return TQt::BDiagPattern;
793 else if( style == "FDiagPattern" )
794 return TQt::FDiagPattern;
795 else if( style == "DiagCrossPattern" )
796 return TQt::DiagCrossPattern;
797 else // should not happen (but can with custom patterns)
798 return TQt::SolidPattern;
799 }
800
801}