Line data Source code
1 : #include <QFile>
2 : #include <QMessageBox>
3 : #include <QDebug>
4 : #include "parserfromxml.hpp"
5 :
6 : namespace qtreports
7 : {
8 : namespace detail
9 : {
10 :
11 782 : ParserFromXML::ParseFunc bindParseFunc( ParserFromXML * obj, ParserFromXML::ParseMethodPtr method )
12 : {
13 : using namespace std::placeholders;
14 782 : auto func = std::bind( method, obj, _1, _2 );
15 782 : return func;
16 : }
17 :
18 : template < typename T1 >
19 782 : ParserFromXML::ParseFunc toParseFunc( ParserFromXML * obj, bool( ParserFromXML::*method )( QXmlStreamReader &, const T1 & ) )
20 : {
21 : //Cast second parameter to ObjectPtr type;
22 782 : auto parseMethodPtr = reinterpret_cast< ParserFromXML::ParseMethodPtr >( method );
23 782 : return bindParseFunc( obj, parseMethodPtr );
24 : }
25 :
26 164 : bool toBool( const QString & string )
27 : {
28 164 : return isEquals( string, "true" ) || isEquals( string, "1" );
29 : }
30 :
31 34 : ParserFromXML::ParserFromXML() : m_log( new QString() ) //MB Memory Leak
32 : {
33 34 : m_functions[ "report" ] = toParseFunc( this, &ParserFromXML::parseReport );
34 34 : m_functions[ "style" ] = toParseFunc( this, &ParserFromXML::parseStyle );
35 34 : m_functions[ "queryString" ] = toParseFunc( this, &ParserFromXML::parseQueryString );
36 34 : m_functions[ "field" ] = toParseFunc( this, &ParserFromXML::parseField );
37 34 : m_functions[ "group" ] = toParseFunc( this, &ParserFromXML::parseGroup );
38 34 : m_functions[ "groupExpression" ] = toParseFunc( this, &ParserFromXML::parseGroupExpression );
39 34 : m_functions[ "groupHeader" ] = toParseFunc( this, &ParserFromXML::parseGroupHeader );
40 34 : m_functions[ "groupFooter" ] = toParseFunc( this, &ParserFromXML::parseGroupFooter );
41 34 : m_functions[ "title" ] = toParseFunc( this, &ParserFromXML::parseTitle );
42 34 : m_functions[ "detail" ] = toParseFunc( this, &ParserFromXML::parseDetail );
43 34 : m_functions[ "band" ] = toParseFunc( this, &ParserFromXML::parseBand );
44 34 : m_functions[ "staticText" ] = toParseFunc( this, &ParserFromXML::parseStaticText );
45 34 : m_functions[ "textField" ] = toParseFunc( this, &ParserFromXML::parseTextField );
46 34 : m_functions[ "line" ] = toParseFunc( this, &ParserFromXML::parseLine );
47 34 : m_functions[ "rect" ] = toParseFunc( this, &ParserFromXML::parseRect );
48 34 : m_functions[ "ellipse" ] = toParseFunc( this, &ParserFromXML::parseEllipse );
49 34 : m_functions[ "image" ] = toParseFunc( this, &ParserFromXML::parseImage );
50 34 : m_functions[ "imageExpression" ] = toParseFunc( this, &ParserFromXML::parseImageExpression );
51 34 : m_functions[ "reportElement" ] = toParseFunc( this, &ParserFromXML::parseReportElement );
52 34 : m_functions[ "textElement" ] = toParseFunc( this, &ParserFromXML::parseTextElement );
53 34 : m_functions[ "font" ] = toParseFunc( this, &ParserFromXML::parseFont );
54 34 : m_functions[ "text" ] = toParseFunc( this, &ParserFromXML::parseText );
55 34 : m_functions[ "textFieldExpression" ] = toParseFunc( this, &ParserFromXML::parseTextFieldExpression );
56 34 : }
57 :
58 34 : ParserFromXML::~ParserFromXML() {}
59 :
60 35 : bool ParserFromXML::parse( const QString & path )
61 : {
62 35 : m_report.clear();
63 35 : m_lastError = "";
64 35 : m_log.setString( new QString() ); //MB Memory Leak
65 :
66 35 : if( !QFile::exists( path ) )
67 : {
68 3 : m_lastError = "The file not exists";
69 3 : return false;
70 : }
71 :
72 32 : QFile file( path );
73 32 : file.open( QIODevice::OpenModeFlag::ReadOnly | QIODevice::Text );
74 32 : if( !file.isOpen() )
75 : {
76 0 : m_lastError = "The file can not be opened";
77 0 : return false;
78 : }
79 :
80 32 : return parseDocument( file.readAll() );//.replace( " ", "" )
81 : }
82 :
83 166 : bool ParserFromXML::getValue( QXmlStreamReader & reader, QString & data )
84 : {
85 166 : m_log << "getValue():\tstart" << endl;
86 874 : while( !reader.atEnd() && !reader.isEndElement() )
87 : {
88 542 : data += reader.text().toString();
89 542 : reader.readNext();
90 : }
91 :
92 166 : if( reader.hasError() )
93 : {
94 0 : m_log << "getValue():\terror" << endl;
95 0 : m_lastError = reader.errorString();
96 0 : return false;
97 : }
98 :
99 166 : m_log << "getValue():\tend. data: " << data << endl;
100 :
101 166 : return true;
102 : }
103 :
104 2094 : bool ParserFromXML::getAttribute( QXmlStreamReader & reader, const QString & name, QString & data, AttributeOption option )
105 : {
106 2094 : m_log << "getAttribute():\tstart. name: " << name << endl;
107 2094 : auto && attributes = reader.attributes();
108 2094 : if( !attributes.hasAttribute( name ) )
109 : {
110 364 : m_log << "getAttribute():\tnot have attribute: " + name << endl;
111 364 : if( option == AttributeOption::Optional )
112 : {
113 364 : return true;
114 : }
115 0 : m_log << "getAttribute():\terror" << endl;
116 0 : auto elementName = reader.name().toString();
117 0 : m_lastError = "Element \"" + reader.name().toString() +
118 0 : "\" not have attribute: " + name;
119 0 : return false;
120 : }
121 1730 : data = attributes.value( name ).toString();
122 1730 : m_log << "getAttribute():\tend. name: " << name << ",\t data: " << data << endl;
123 1730 : return true;
124 : }
125 :
126 1218 : bool ParserFromXML::getRequiredAttribute( QXmlStreamReader & reader, const QString & name, QString & data )
127 : {
128 1218 : return getAttribute( reader, name, data, AttributeOption::Required );
129 : }
130 :
131 876 : bool ParserFromXML::getOptionalAttribute( QXmlStreamReader & reader, const QString & name, QString & data )
132 : {
133 876 : return getAttribute( reader, name, data, AttributeOption::Optional );
134 : }
135 :
136 263 : bool ParserFromXML::goToElementEnd( QXmlStreamReader & reader )
137 : {
138 263 : m_log << "goToEnd():\tstart" << endl;
139 263 : int level = 0;
140 530 : while( !reader.atEnd() )
141 : {
142 267 : reader.readNext();
143 267 : if( reader.isEndElement() )
144 : {
145 263 : if( level <= 0 )
146 : {
147 263 : break;
148 : }
149 0 : --level;
150 : }
151 4 : if( reader.isStartElement() )
152 : {
153 0 : ++level;
154 : }
155 : }
156 :
157 263 : if( reader.hasError() )
158 : {
159 0 : m_log << "goToEnd():\terror" << endl;
160 0 : m_lastError = reader.errorString();
161 0 : return false;
162 : }
163 263 : m_log << "goToEnd():\tend" << endl;
164 :
165 263 : return true;
166 : }
167 :
168 519 : bool ParserFromXML::parseChilds( QXmlStreamReader & reader, const ObjectPtr & object )
169 : {
170 519 : m_log << "parseChilds():\tstart" << endl;
171 519 : while( !reader.atEnd() )
172 : {
173 2779 : reader.readNext();
174 2779 : if( reader.isEndElement() )
175 : {
176 484 : break;
177 : }
178 2295 : if( !reader.isStartElement() )
179 : {
180 1351 : continue;
181 : }
182 :
183 944 : auto name = reader.name().toString();
184 944 : m_log << "parseChilds():\tcurrent tag: " << name << endl;
185 944 : if( m_functions.contains( name ) )
186 : {
187 940 : m_log << "parseChilds():\tuse func for: " << name << endl;
188 940 : auto func = m_functions[ name ];
189 940 : if( !func( reader, object ) )
190 : {
191 3 : return false;
192 937 : }
193 : }
194 : else
195 : {
196 4 : m_log << "parseChilds():\tgoToElementEnd: " << name << endl;
197 4 : if( !goToElementEnd( reader ) )
198 : {
199 0 : return false;
200 : }
201 : }
202 941 : }
203 :
204 516 : if( reader.hasError() )
205 : {
206 3 : m_log << "parseChilds():\terror" << endl;
207 3 : m_lastError = reader.errorString();
208 3 : return false;
209 : }
210 :
211 513 : m_log << "parseChilds():\tend" << endl;
212 513 : return true;
213 : }
214 :
215 32 : bool ParserFromXML::parseDocument( const QString & text )
216 : {
217 32 : QXmlStreamReader reader( text );
218 :
219 32 : m_report = ReportPtr( new Report() );
220 32 : if( !parseChilds( reader, m_report ) )
221 : {
222 3 : return false;
223 : }
224 :
225 29 : return !reader.hasError();
226 : }
227 :
228 32 : bool ParserFromXML::parseReport( QXmlStreamReader & reader, const ReportPtr & report )
229 : {
230 32 : QString name;
231 32 : if( !getRequiredAttribute( reader, "name", name ) )
232 : {
233 0 : return false;
234 : }
235 :
236 64 : QString leftMargin;
237 32 : if( !getOptionalAttribute( reader, "leftMargin", leftMargin ) )
238 : {
239 0 : return false;
240 : }
241 :
242 64 : QString rightMargin;
243 32 : if( !getOptionalAttribute( reader, "rightMargin", rightMargin ) )
244 : {
245 0 : return false;
246 : }
247 :
248 64 : QString topMargin;
249 32 : if( !getOptionalAttribute( reader, "topMargin", topMargin ) )
250 : {
251 0 : return false;
252 : }
253 :
254 64 : QString bottomMargin;
255 32 : if( !getOptionalAttribute( reader, "bottomMargin", bottomMargin ) )
256 : {
257 0 : return false;
258 : }
259 :
260 64 : QString orientationString;
261 32 : if( !getOptionalAttribute( reader, "orientation", orientationString ) )
262 : {
263 0 : return false;
264 : }
265 :
266 64 : QString pageWidthString;
267 32 : if( !getOptionalAttribute( reader, "pageWidth", pageWidthString ) )
268 : {
269 0 : return false;
270 : }
271 :
272 64 : QString pageHeightString;
273 32 : if( !getOptionalAttribute( reader, "pageHeight", pageHeightString ) )
274 : {
275 0 : return false;
276 : }
277 :
278 32 : if( !parseChilds( reader, report ) )
279 : {
280 3 : return false;
281 : }
282 :
283 29 : report->setTagName( "report" );
284 29 : report->setName( name );
285 :
286 29 : if( !leftMargin.isEmpty() )
287 : {
288 6 : report->setLeftMargin( leftMargin.toInt() );
289 : }
290 :
291 29 : if( !topMargin.isEmpty() )
292 : {
293 6 : report->setTopMargin( topMargin.toInt() );
294 : }
295 :
296 29 : if( !rightMargin.isEmpty() )
297 : {
298 6 : report->setRightMargin( rightMargin.toInt() );
299 : }
300 :
301 29 : if( !bottomMargin.isEmpty() )
302 : {
303 6 : report->setBottomMargin( bottomMargin.toInt() );
304 : }
305 :
306 29 : if( !orientationString.isEmpty() )
307 : {
308 12 : auto orientation = isEquals( orientationString, "portrait" ) ?
309 : QPrinter::Orientation::Portrait :
310 6 : QPrinter::Orientation::Landscape;
311 6 : report->setOrientation( orientation );
312 : }
313 :
314 29 : if( !pageWidthString.isEmpty() )
315 : {
316 7 : report->setWidth( pageWidthString.toInt() );
317 : }
318 :
319 29 : if( !pageHeightString.isEmpty() )
320 : {
321 7 : report->setHeight( pageHeightString.toInt() );
322 : }
323 :
324 61 : return !reader.hasError();
325 : }
326 :
327 :
328 28 : bool ParserFromXML::parseStyle( QXmlStreamReader & reader, const ReportPtr & report )
329 : {
330 28 : QString nameString;
331 28 : if( !getRequiredAttribute( reader, "name", nameString ) )
332 : {
333 0 : return false;
334 : }
335 :
336 56 : QString isDefaultString;
337 28 : if( !getOptionalAttribute( reader, "isDefault", isDefaultString ) )
338 : {
339 0 : return false;
340 : }
341 :
342 56 : QString fontNameString;
343 28 : if( !getOptionalAttribute( reader, "fontName", fontNameString ) )
344 : {
345 0 : return false;
346 : }
347 :
348 56 : QString fontSizeString;
349 28 : if( !getOptionalAttribute( reader, "fontSize", fontSizeString ) )
350 : {
351 0 : return false;
352 : }
353 :
354 56 : QString fontColorString;
355 28 : if( !getOptionalAttribute( reader, "fontColor", fontColorString ) )
356 : {
357 0 : return false;
358 : }
359 :
360 56 : QString isBoldString;
361 28 : if( !getOptionalAttribute( reader, "isBold", isBoldString ) )
362 : {
363 0 : return false;
364 : }
365 :
366 56 : QString isItalicString;
367 28 : if( !getOptionalAttribute( reader, "isItalic", isItalicString ) )
368 : {
369 0 : return false;
370 : }
371 :
372 56 : QString isUnderlineString;
373 28 : if( !getOptionalAttribute( reader, "isUnderline", isUnderlineString ) )
374 : {
375 0 : return false;
376 : }
377 :
378 56 : QString isStrikeThroughString;
379 28 : if( !getOptionalAttribute( reader, "isStrikeThrough", isStrikeThroughString ) )
380 : {
381 0 : return false;
382 : }
383 :
384 56 : QString pdfFontNameString;
385 28 : if( !getOptionalAttribute( reader, "pdfFontName", pdfFontNameString ) )
386 : {
387 0 : return false;
388 : }
389 :
390 56 : QString pdfEncodingString;
391 28 : if( !getOptionalAttribute( reader, "pdfEncoding", pdfEncodingString ) )
392 : {
393 0 : return false;
394 : }
395 :
396 56 : QString isPdfEmbeddedString;
397 28 : if( !getOptionalAttribute( reader, "isPdfEmbedded", isPdfEmbeddedString ) )
398 : {
399 0 : return false;
400 : }
401 :
402 84 : while( !reader.atEnd() && !reader.isEndElement() )
403 : {
404 28 : reader.readNext();
405 : }
406 :
407 28 : if( reader.hasError() )
408 : {
409 0 : m_lastError = reader.errorString();
410 0 : return false;
411 : }
412 :
413 : //isBold = "false" isItalic = "false" isUnderline = "false" isStrikeThrough = "false"
414 :
415 56 : StylePtr style( new Style() );
416 28 : style->setTagName( "style" );
417 28 : style->setName( nameString );
418 :
419 28 : if( !isDefaultString.isEmpty() )
420 : {
421 27 : bool isDefault = toBool( isDefaultString );
422 27 : style->setAsDefault( isDefault );
423 27 : if( isDefault )
424 : {
425 27 : report->setDefaultStyle( style );
426 : }
427 : }
428 :
429 28 : if( !fontNameString.isEmpty() )
430 : {
431 27 : style->setFontName( fontNameString );
432 : }
433 :
434 28 : if( !fontColorString.isEmpty() )
435 : {
436 7 : style->setFontColor( QColor( fontColorString ) );
437 : }
438 :
439 28 : if( !fontSizeString.isEmpty() )
440 : {
441 27 : style->setFontSize( fontSizeString.toInt() );
442 : }
443 :
444 28 : if( !isBoldString.isEmpty() )
445 : {
446 7 : style->setBold( toBool( isBoldString ) );
447 : }
448 :
449 28 : if( !isItalicString.isEmpty() )
450 : {
451 7 : style->setItalic( toBool( isItalicString ) );
452 : }
453 :
454 28 : if( !isUnderlineString.isEmpty() )
455 : {
456 6 : style->setUnderline( toBool( isUnderlineString ) );
457 : }
458 :
459 28 : if( !isStrikeThroughString.isEmpty() )
460 : {
461 6 : style->setStrikeThrough( toBool( isStrikeThroughString ) );
462 : }
463 :
464 28 : if( !pdfFontNameString.isEmpty() )
465 : {
466 27 : style->setPDFFontName( pdfFontNameString );
467 : }
468 :
469 28 : if( !pdfEncodingString.isEmpty() )
470 : {
471 27 : style->setPDFEncoding( pdfEncodingString );
472 : }
473 :
474 28 : if( !isPdfEmbeddedString.isEmpty() )
475 : {
476 27 : style->setPDFEmbedded( toBool( isPdfEmbeddedString ) );
477 : }
478 :
479 28 : report->addStyle( nameString, style );
480 :
481 56 : return !reader.hasError();
482 : }
483 :
484 115 : bool ParserFromXML::parseField( QXmlStreamReader & reader, const ReportPtr & report )
485 : {
486 115 : QString name;
487 115 : if( !getRequiredAttribute( reader, "name", name ) )
488 : {
489 0 : return false;
490 : }
491 :
492 230 : QString className;
493 115 : if( !getRequiredAttribute( reader, "class", className ) )
494 : {
495 0 : return false;
496 : }
497 : /*
498 : while( !reader.atEnd() && !reader.isEndElement() ) {
499 : reader.readNext();
500 : }
501 :
502 : if( reader.hasError() ) {
503 : m_lastError = reader.errorString();
504 : return false;
505 : }
506 : */
507 230 : FieldPtr field( new Field() );
508 115 : if( !parseChilds( reader, field ) )
509 : {
510 0 : return false;
511 : }
512 :
513 115 : field->setTagName( "field" );
514 115 : field->setName( name );
515 115 : field->setClassName( className );
516 115 : report->setField( name, field );
517 :
518 230 : return !reader.hasError();
519 : }
520 :
521 1 : bool ParserFromXML::parseGroup( QXmlStreamReader & reader, const ReportPtr & report )
522 : {
523 1 : QString nameString;
524 1 : if( !getRequiredAttribute( reader, "name", nameString ) )
525 : {
526 0 : return false;
527 : }
528 :
529 2 : GroupPtr group( new Group() );
530 1 : group->setTagName( "group" );
531 1 : group->setName( nameString );
532 :
533 1 : if( !parseChilds( reader, group ) )
534 : {
535 0 : return false;
536 : }
537 :
538 1 : report->addGroup( nameString, group );
539 :
540 2 : return !reader.hasError();
541 : }
542 :
543 1 : bool ParserFromXML::parseGroupExpression( QXmlStreamReader & reader, const GroupPtr & group )
544 : {
545 1 : QString text;
546 1 : if( !getValue( reader, text ) )
547 : {
548 0 : return false;
549 : }
550 :
551 1 : group->setExpression( text );
552 :
553 1 : return !reader.hasError();
554 : }
555 :
556 0 : bool ParserFromXML::parseGroupHeader( QXmlStreamReader & reader, const GroupPtr & group )
557 : {
558 0 : SectionPtr header( new Section() );
559 0 : header->setTagName( "groupHeader" );
560 :
561 0 : if( !parseChilds( reader, header ) )
562 : {
563 0 : return false;
564 : }
565 :
566 0 : group->setHeader( header );
567 :
568 0 : return !reader.hasError();
569 : }
570 :
571 0 : bool ParserFromXML::parseGroupFooter( QXmlStreamReader & reader, const GroupPtr & group )
572 : {
573 0 : SectionPtr footer( new Section() );
574 0 : footer->setTagName( "groupFooter" );
575 :
576 0 : if( !parseChilds( reader, footer ) )
577 : {
578 0 : return false;
579 : }
580 :
581 0 : group->setFooter( footer );
582 :
583 0 : return !reader.hasError();
584 : }
585 :
586 6 : bool ParserFromXML::parseTitle( QXmlStreamReader & reader, const ReportPtr & report )
587 : {
588 6 : TitlePtr title( new Title() );
589 6 : if( !parseChilds( reader, title ) )
590 : {
591 0 : return false;
592 : }
593 :
594 6 : title->setTagName( "title" );
595 : //title->setWidth( report->getWidth() );
596 6 : report->setTitle( title );
597 :
598 6 : return !reader.hasError();
599 : }
600 :
601 27 : bool ParserFromXML::parseDetail( QXmlStreamReader & reader, const ReportPtr & report )
602 : {
603 27 : DetailPtr detail( new Detail() );
604 27 : if( !parseChilds( reader, detail ) )
605 : {
606 0 : return false;
607 : }
608 :
609 27 : detail->setTagName( "detail" );
610 : //detail->setWidth( report->getWidth() );
611 27 : report->setDetail( detail );
612 :
613 27 : return !reader.hasError();
614 : }
615 :
616 46 : bool ParserFromXML::parseBand( QXmlStreamReader & reader, const SectionPtr & section )
617 : {
618 46 : QString height;
619 46 : if( !getRequiredAttribute( reader, "height", height ) )
620 : {
621 0 : return false;
622 : }
623 :
624 92 : BandPtr band( new Band() );
625 46 : if( !parseChilds( reader, band ) )
626 : {
627 0 : return false;
628 : }
629 :
630 46 : band->setTagName( "band" );
631 46 : band->setHeight( height.toInt() );
632 : //band->setWidth( section->getWidth() );
633 46 : section->addBand( band );
634 :
635 92 : return !reader.hasError();
636 : }
637 :
638 31 : bool ParserFromXML::parseStaticText( QXmlStreamReader & reader, const BandPtr & band )
639 : {
640 31 : StaticTextPtr staticText( new StaticText() );
641 31 : if( !parseChilds( reader, staticText ) )
642 : {
643 0 : return false;
644 : }
645 :
646 31 : staticText->setTagName( "staticText" );
647 31 : band->addStaticText( staticText );
648 :
649 31 : return !reader.hasError();
650 : }
651 :
652 96 : bool ParserFromXML::parseTextField( QXmlStreamReader & reader, const BandPtr & band )
653 : {
654 96 : TextFieldPtr textField( new TextField() );
655 96 : if( !parseChilds( reader, textField ) )
656 : {
657 0 : return false;
658 : }
659 :
660 96 : textField->setTagName( "textField" );
661 96 : band->addTextField( textField );
662 :
663 96 : return !reader.hasError();
664 : }
665 :
666 12 : bool ParserFromXML::parseLine( QXmlStreamReader & reader, const BandPtr & band )
667 : {
668 12 : LinePtr line( new Line() );
669 12 : if( !parseChilds( reader, line ) )
670 : {
671 0 : return false;
672 : }
673 :
674 12 : line->setTagName( "line" );
675 12 : band->addLine( line );
676 :
677 12 : return !reader.hasError();
678 : }
679 :
680 12 : bool ParserFromXML::parseRect( QXmlStreamReader & reader, const BandPtr & band )
681 : {
682 12 : RectPtr rect( new Rect() );
683 12 : if( !parseChilds( reader, rect ) )
684 : {
685 0 : return false;
686 : }
687 :
688 12 : rect->setTagName( "rect" );
689 12 : band->addRect( rect );
690 :
691 12 : return !reader.hasError();
692 : }
693 :
694 12 : bool ParserFromXML::parseEllipse( QXmlStreamReader & reader, const BandPtr & band )
695 : {
696 12 : EllipsePtr ellipse( new Ellipse() );
697 12 : if( !parseChilds( reader, ellipse ) )
698 : {
699 0 : return false;
700 : }
701 :
702 12 : ellipse->setTagName( "ellipse" );
703 12 : band->addEllipse( ellipse );
704 :
705 12 : return !reader.hasError();
706 : }
707 :
708 12 : bool ParserFromXML::parseImage( QXmlStreamReader & reader, const BandPtr & band )
709 : {
710 12 : ImagePtr image( new Image() );
711 12 : if( !parseChilds( reader, image ) )
712 : {
713 0 : return false;
714 : }
715 :
716 12 : image->setTagName( "image" );
717 12 : band->addImage( image );
718 :
719 12 : return !reader.hasError();
720 : }
721 :
722 175 : bool ParserFromXML::parseReportElement( QXmlStreamReader & reader, const WidgetPtr & widget )
723 : {
724 175 : QString xString;
725 175 : if( !getRequiredAttribute( reader, "x", xString ) )
726 : {
727 0 : return false;
728 : }
729 :
730 350 : QString yString;
731 175 : if( !getRequiredAttribute( reader, "y", yString ) )
732 : {
733 0 : return false;
734 : }
735 :
736 350 : QString widthString;
737 175 : if( !getRequiredAttribute( reader, "width", widthString ) )
738 : {
739 0 : return false;
740 : }
741 :
742 350 : QString heightString;
743 175 : if( !getRequiredAttribute( reader, "height", heightString ) )
744 : {
745 0 : return false;
746 : }
747 :
748 350 : QString styleString;
749 175 : if( !getOptionalAttribute( reader, "style", styleString ) )
750 : {
751 0 : return false;
752 : }
753 :
754 175 : if( !goToElementEnd( reader ) )
755 : {
756 0 : return false;
757 : }
758 :
759 175 : if( !xString.isEmpty() )
760 : {
761 175 : widget->setX( xString.toInt() );
762 : }
763 :
764 175 : if( !yString.isEmpty() )
765 : {
766 175 : widget->setY( yString.toInt() );
767 : }
768 :
769 175 : if( !widthString.isEmpty() )
770 : {
771 175 : auto width = widthString.toInt();
772 : //if( widthString.contains( "%" ) )
773 : //{
774 : //auto percentString = widthString.split( "%" ).at( 0 );
775 : //auto percent = 0.01 * std::max( 0, std::min( 100, percentString.toInt() ) );
776 : //width = static_cast< int >( percent * m_report->getWidth() );
777 : //}
778 175 : widget->setWidth( width );
779 : }
780 :
781 175 : if( !heightString.isEmpty() )
782 : {
783 175 : widget->setHeight( heightString.toInt() );
784 : }
785 :
786 175 : if( !styleString.isEmpty() )
787 : {
788 84 : widget->setStyle( styleString );
789 : }
790 :
791 : //widget->setRect( QRect( x, y, width, height ) );
792 :
793 350 : return !reader.hasError();
794 : }
795 :
796 85 : bool ParserFromXML::parseTextElement( QXmlStreamReader & reader, const WidgetPtr & widget )
797 : {
798 85 : QString textAlignment;
799 85 : if( !getRequiredAttribute( reader, "textAlignment", textAlignment ) )
800 : {
801 0 : return false;
802 : }
803 :
804 170 : QString textVAlignment;
805 85 : if( !getOptionalAttribute( reader, "textVAlignment", textVAlignment ) )
806 : {
807 0 : return false;
808 : }
809 :
810 85 : if( !parseChilds( reader, widget ) )
811 : {
812 0 : return false;
813 : }
814 :
815 85 : auto isCenter = isEquals( textAlignment, "Center" );
816 85 : auto isRight = isEquals( textAlignment, "Right" );
817 :
818 85 : auto isVTop = isEquals( textVAlignment, "Top" );
819 85 : auto isVBottom = isEquals( textVAlignment, "Bottom" );
820 :
821 85 : auto hFlag = isCenter ? Qt::AlignCenter : isRight ? Qt::AlignRight : Qt::AlignLeft;
822 85 : auto vFlag = isVTop ? Qt::AlignTop : isVBottom ? Qt::AlignBottom : Qt::AlignVCenter;
823 :
824 85 : widget->setAlignment( hFlag | vFlag );
825 :
826 170 : return !reader.hasError();
827 : }
828 :
829 84 : bool ParserFromXML::parseFont( QXmlStreamReader & reader, const WidgetPtr & widget )
830 : {
831 84 : QString isBold;
832 84 : if( !getOptionalAttribute( reader, "isBold", isBold ) )
833 : {
834 0 : return false;
835 : }
836 :
837 84 : if( !goToElementEnd( reader ) )
838 : {
839 0 : return false;
840 : }
841 :
842 84 : if( !isBold.isEmpty() )
843 : {
844 84 : widget->setBold( toBool( isBold ) );
845 : }
846 :
847 84 : return !reader.hasError();
848 : }
849 :
850 31 : bool ParserFromXML::parseText( QXmlStreamReader & reader, const StaticTextPtr & staticText )
851 : {
852 31 : QString text;
853 31 : if( !getValue( reader, text ) )
854 : {
855 0 : return false;
856 : }
857 :
858 31 : staticText->setOriginalText( text );
859 :
860 31 : return !reader.hasError();
861 : }
862 :
863 96 : bool ParserFromXML::parseTextFieldExpression( QXmlStreamReader & reader, const TextFieldPtr & textField )
864 : {
865 96 : QString className;
866 96 : if( !getRequiredAttribute( reader, "class", className ) )
867 : {
868 0 : return false;
869 : }
870 :
871 192 : QString text;
872 96 : if( !getValue( reader, text ) )
873 : {
874 0 : return false;
875 : }
876 :
877 96 : textField->setOriginalText( text );
878 96 : textField->setClassName( className );
879 :
880 192 : return !reader.hasError();
881 : }
882 :
883 12 : bool ParserFromXML::parseImageExpression( QXmlStreamReader & reader, const ImagePtr & image )
884 : {
885 : //QString className;
886 : //if( !getRequiredAttribute( reader, "class", className ) )
887 : //{
888 : // return false;
889 : //}
890 :
891 12 : QString text;
892 12 : if( !getValue( reader, text ) )
893 : {
894 0 : return false;
895 : }
896 :
897 12 : image->setOriginalText( text );
898 : //image->setClassName( className );
899 :
900 12 : return !reader.hasError();
901 : }
902 :
903 26 : bool ParserFromXML::parseQueryString( QXmlStreamReader & reader, const ReportPtr & report )
904 : {
905 26 : QString text;
906 26 : if( !getValue( reader, text ) )
907 : {
908 0 : return false;
909 : }
910 :
911 26 : report->setQuery( text );
912 26 : report->setTagName( "queryString" );
913 :
914 26 : return !reader.hasError();
915 : }
916 :
917 30 : const ReportPtr ParserFromXML::getReport() const
918 : {
919 30 : return m_report;
920 : }
921 :
922 14 : const QString ParserFromXML::getLastError() const
923 : {
924 14 : return m_lastError;
925 : }
926 :
927 3 : const QString ParserFromXML::getLog() const
928 : {
929 3 : return *m_log.string();
930 : }
931 :
932 : }
933 : }
|
