示例#1
0
int main( int argc, char** argv ) {
    QApplication app( argc, argv );

    KDReports::Report report;
    report.setDefaultFont( QFont( "Arial", 8 ) );

    report.setFirstPageNumber( 100 );

    KDReports::Header& header = report.header( KDReports::FirstPage );
    header.addElement( KDReports::TextElement( "This is a test for generating one section of a larger report." ) );

    KDReports::Footer& footer = report.footer();
    footer.addElement( KDReports::TextElement( "We are generating pages 100-109 out of 500." ) );
    footer.addElement( KDReports::TextElement( "Page" ), Qt::AlignRight );
    footer.addInlineElement( KDReports::TextElement( " " ) );
    footer.addVariable( KDReports::PageNumber );
    footer.addInlineElement( KDReports::TextElement( " / " ) );
    // As an example for combining reports together, we'll set the value of
    // the total page count later, when it's known.
    KDReports::TextElement pageCountElement;
    pageCountElement.setId( QLatin1String("id_page_count") );
    footer.addInlineElement( pageCountElement );

    QList<QTextOption::Tab> tabs;
    tabs.append( report.rightAlignedTab() );
    report.setTabPositions( tabs );

    KDReports::TextElement tocElement("<Table of Contents will go here>");
    tocElement.setId( QLatin1String("id_toc") );
    report.addElement( tocElement );

    report.addVerticalSpacing( 10 );

    report.setTabPositions( QList<QTextOption::Tab>() ); // for performance

    KDReports::TableElement largeTableElement = largeTable();
    report.addElement( largeTableElement );

    // Let's assume we know the total page count is 1000 now, let's set it.
    report.associateTextValue( QLatin1String("id_page_count"), QString::number(500) );

    // Fill in the table of contents
    QStringList tocList;
    tocList << QString::fromLatin1("Chapter one\tpage 1");
    tocList << QString::fromLatin1("Chapter two\tpage 3");
    tocList << QString::fromLatin1("Last chapter\tpage 6");
    QString tocText = tocList.join( QString::fromLatin1("\n") );
    report.associateTextValue( QLatin1String("id_toc"), tocText );

    KDReports::PreviewDialog preview( &report );
    return preview.exec();

    // For performance testing...
    //report.exportToFile( "testout.pdf" );
    //return 0;
}
bool TestXmlElementHandlerV1::textElement( KDReports::TextElement& textElement, QDomElement& xmlElement )
{
    Q_UNUSED( textElement );
    Q_UNUSED( xmlElement ); // unused in release mode
    Q_ASSERT( xmlElement.tagName() == "text" );
    cb << "textElement";
    if (textElement.id() == "testModification")
        textElement.setId("testModified");
    return true;
}
示例#3
0
bool KDReports::XmlParser::processNode( const QDomNode& node, KDReports::ReportBuilder* builder, bool inHeader, bool inFooter )
{
    // Loop over elements
    for ( QDomElement element = node.firstChildElement() ; !element.isNull();
          element = element.nextSiblingElement() ) {

        if ( testForErrorAndFillErrorDetails() )
            return false;

        const QString name = element.tagName();
        if( name == QLatin1String( "text" ) ) {
            // Handle <text> element
            KDReports::TextElement textElement;
            QString id;
            const QString text = extractText( element, &id, m_report->d->m_currentModel, m_report->d->m_currentRow );
            textElement.setText( text );
            textElement.setId( id );
            const QColor bgColor = KDReports::XmlHelper::readBackground( element );
            if( bgColor.isValid() )
                textElement.setBackground( bgColor );
            if( element.hasAttribute( QLatin1String( "pointsize" ) ) ) {
                const int pointSize = element.attribute( QLatin1String( "pointsize" ) ).toInt();
                if( pointSize )
                    textElement.setPointSize( pointSize );
            }
            if( element.hasAttribute( QLatin1String( "color" ) ) ) {
                const QString name = element.attribute( QLatin1String( "color" ) );
                textElement.setTextColor( QColor( name ) );
            }
            if( element.hasAttribute( QLatin1String( "font" ) ) ) {
                textElement.setFontFamily( element.attribute( QLatin1String( "font" ) ) );
            }
            if( element.hasAttribute( QLatin1String( "bold" ) ) ) {
                bool bold = false;
                if( element.attribute( QLatin1String( "bold" ) ) == QLatin1String( "true" ) )
                    bold = true;
                textElement.setBold( bold );
            }
            if( element.hasAttribute( QLatin1String( "italic" ) ) ) {
                bool italic = false;
                if( element.attribute( QLatin1String( "italic" ) ) == QLatin1String( "true" ) )
                    italic = true;
                textElement.setItalic( italic );
            }
            if( element.hasAttribute( QLatin1String( "strikeout" ) ) ) {
                bool strikeOut = false;
                if( element.attribute( QLatin1String( "strikeout" ) ) == QLatin1String( "true" ) )
                    strikeOut = true;
                textElement.setStrikeOut( strikeOut );
            }
            if( element.hasAttribute( QLatin1String( "underline" ) ) ) {
                bool underline = false;
                if( element.attribute( QLatin1String( "underline" ) ) == QLatin1String( "true" ) )
                    underline = true;
                textElement.setUnderline( underline );
            }

            const QString oldId = textElement.id();

            if ( m_xmlElementHandler && !m_xmlElementHandler->textElement( textElement, element ) )
                continue;

            if ( textElement.id() != oldId ) {
                // The handler modified the text element's id, look up the value again.
                const QHash<QString, QString>::const_iterator it = m_textValues.constFind( textElement.id() );
                if ( it != m_textValues.constEnd() ) {
                    textElement.setText( *it );
                }
            }

            if ( !builder ) {
                error( QObject::tr( "<text> is only supported in WordProcessing mode" ) );
            } else {
                if( element.hasAttribute( QLatin1String( "inline" ) ) ) {
                    builder->addInlineElementPublic( textElement );
                } else {
                    Qt::AlignmentFlag alignment = Qt::AlignLeft;
                    if( element.hasAttribute( QLatin1String( "alignment" ) ) )
                        alignment = KDReports::XmlHelper::stringToAlignment( element.attribute( QLatin1String( "alignment" ) ) );
                    const QColor bgColor = KDReports::XmlHelper::readColor( element, "paragraph-background" );
                    builder->addBlockElementPublic( textElement, alignment, bgColor );
                }
            }

        } else if( name == QLatin1String( "html" ) ) {
            // Handle <html> element
            KDReports::HtmlElement htmlElement;
            QString id;
            const QString text = extractText( element, &id );
            htmlElement.setHtml( text );
            htmlElement.setId( id );
            QColor bgColor = KDReports::XmlHelper::readBackground( element );
            if( bgColor.isValid() )
                htmlElement.setBackground( bgColor );

            const QString oldId = htmlElement.id();

            if ( m_xmlElementHandler && !m_xmlElementHandler->htmlElement( htmlElement, element ) )
                continue;

            if ( htmlElement.id() != oldId ) {
                // The handler modified the text element's id, look up the value again.
                const QHash<QString, QString>::const_iterator it = m_textValues.constFind( htmlElement.id() );
                if ( it != m_textValues.constEnd() ) {
                    htmlElement.setHtml( *it );
                }
            }

            addElement( htmlElement, builder, element );

        } else if ( name == QLatin1String( "tabs" ) ) {

            if ( !builder ) {
                error( QObject::tr( "<tabs> is only supported in WordProcessing mode" ) );
            } else {
                parseTabs( builder, element );
            }

        } else if ( name == QLatin1String( "paragraph-margins" ) ) {

            if ( !builder ) {
                error( QObject::tr( "<paragraph-margins> is only supported in WordProcessing mode" ) );
            } else {
                parseParagraphMargins( builder, element );
            }

        } else if( name == QLatin1String( "hr" ) ) {
            // Handle <hr> element
            KDReports::HtmlElement htmlElement;
            htmlElement.setHtml( QString::fromLatin1("<hr>") );
            if ( m_xmlElementHandler && !m_xmlElementHandler->htmlElement( htmlElement, element ) )
                continue;

            addElement( htmlElement, builder, element );

        } else if( name == QLatin1String( "vspace" ) ) {
            // Handle <vspace> element
            if( !element.hasAttribute( QLatin1String( "size" ) ) )
                continue; // size attribute is mandatory for VSpace
            int size = element.attribute( QLatin1String( "size" ) ).toInt();
            if ( !builder ) {
                error( QObject::tr( "<vspace> is only supported in WordProcessing mode" ) );
            } else {
                if( builder != m_report->d->builder() ) {
                    error( QObject::tr("<vspace> not allowed in headers, footers, or table cells") );
                    return false;
                }
            }
            XmlElementHandlerV2* v2 = dynamic_cast<XmlElementHandlerV2 *>(m_xmlElementHandler);
            if (v2 && !v2->vspace(size, element))
                continue;
            m_report->addVerticalSpacing( size );
        } else if( name == QLatin1String( "table" ) ) {
            // Handle <table> element
            const QString model = element.attribute( QLatin1String( "model" ) );
            if ( model.isEmpty() ) {
                if ( !builder ) {
                    error( QObject::tr( "<table> without a model is only supported in WordProcessing mode" ) );
                    continue;
                }
                KDReports::TableElement tableElement;
                const int headerRowCount = element.attribute( QLatin1String( "headerRowCount" ) ).toInt(); // default 0
                tableElement.setHeaderRowCount( headerRowCount );
                if ( element.hasAttribute( QLatin1String( "cellpadding" ) ) )
                    tableElement.setPadding( element.attribute( QLatin1String( "cellpadding" ) ).toInt() );
                parseCommonTableAttributes( tableElement, element );

                if ( m_xmlElementHandler && !m_xmlElementHandler->startTableElement( tableElement, element ) )
                    continue;

                if ( !parseTableContents( tableElement, element, *builder, inHeader, inFooter ) )
                    return false;

                if ( m_xmlElementHandler && !m_xmlElementHandler->endTableElement( tableElement, element ) )
                    continue;

                addElement( tableElement, builder, element );

            } else {
                KDReports::AutoTableElement tableElement( model );
                if( element.attribute( QLatin1String( "verticalHeaderVisible" ) ) == QLatin1String( "false" ) )
                    tableElement.setVerticalHeaderVisible(false);
                if( element.attribute( QLatin1String( "horizontalHeaderVisible" ) ) == QLatin1String( "false" ) )
                    tableElement.setHorizontalHeaderVisible(false);
                QColor headerBgColor = KDReports::XmlHelper::readColor( element, "header-background" );
                if ( headerBgColor.isValid() )
                    tableElement.setHeaderBackground( headerBgColor );
                parseCommonTableAttributes( tableElement, element );
                if ( m_xmlElementHandler && !m_xmlElementHandler->autoTableElement( tableElement, element ) )
                    continue;

                if ( m_report->reportMode() == Report::SpreadSheet ) {
                    m_report->mainTable()->setAutoTableElement( tableElement );
                } else {
                    addElement( tableElement, builder, element );
                }
            }
        } else if( name == QLatin1String( "chart" ) ) {
            // Handle <chart> element

            KDReports::ChartElement chartElement( element.attribute( QLatin1String( "model" ) ) );
            QColor bgColor = KDReports::XmlHelper::readBackground( element );
            if( bgColor.isValid() )
                chartElement.setBackground( bgColor );
            int width = 100, height = 100;
            Unit unit = Millimeters;
            if( element.hasAttribute( QLatin1String( "width" ) ) ) {
                QString str = element.attribute( QLatin1String( "width" ) );
                if ( str.endsWith( QLatin1Char('%') ) ) {
                    str.chop( 1 );
                    unit = Percent;
                }
                width = str.toInt();
            }
            if( element.hasAttribute( QLatin1String( "height" ) ) ) {
                QString str = element.attribute( QLatin1String( "height" ) );
                if ( str.endsWith( QLatin1Char('%') ) ) {
                    str.chop( 1 );
                    unit = Percent;
                }
                height = str.toInt();
            }
            chartElement.setSize( width, height, unit );

            if ( m_xmlElementHandler && !m_xmlElementHandler->chartElement( chartElement, element ) )
                continue;

            addElement( chartElement, builder, element );

        } else if( name == QLatin1String( "image" ) ) {
            // Handle <image> element

            QString id;
            QImage image = extractImage( element, &id );
            KDReports::ImageElement imageElement( image );
            imageElement.setId(id);
            if( element.hasAttribute( QLatin1String( "width" ) ) ) {
                QString widthStr = element.attribute( QLatin1String( "width" ) );
                if ( widthStr.endsWith( QLatin1Char('%') ) ) {
                    widthStr.truncate( widthStr.length() - 1 );
                    imageElement.setWidth( widthStr.toInt(), KDReports::Percent );
                } else {
                    imageElement.setWidth( widthStr.toInt() );
                }
            } else if( element.hasAttribute( QLatin1String( "height" ) ) ) { // mutually exclusive with "width"!
                QString heightStr = element.attribute( QLatin1String( "height" ) );
                if ( heightStr.endsWith( QLatin1Char('%') ) ) {
                    heightStr.truncate( heightStr.length() - 1 );
                    imageElement.setHeight( heightStr.toInt(), KDReports::Percent );
                } else {
                    imageElement.setHeight( heightStr.toInt() );
                }
            } else if ( element.hasAttribute( QLatin1String( "fitToPage" ) ) ) {
                imageElement.setFitToPage();
            }

            if ( m_xmlElementHandler && !m_xmlElementHandler->imageElement( imageElement, element ) )
                continue;

            addElement( imageElement, builder, element );

        } else if( name == QLatin1String( "header" ) ) {
            const KDReports::HeaderLocations loc = KDReports::XmlHelper::parseHeaderLocation( element.attribute( QLatin1String( "location" ) ) );
            KDReports::Header& header = m_report->header( loc );
            parseHeaderFooterAttribute( header, element );
            if ( m_xmlElementHandler && !m_xmlElementHandler->startHeader( header, element ) )
                continue;
            if( !processNode( element, &header.d->m_builder, true, false ) )
                return false;
            if ( m_xmlElementHandler )
                m_xmlElementHandler->endHeader( header, element );
        } else if( name == QLatin1String( "footer" ) ) {
            const KDReports::HeaderLocations loc = KDReports::XmlHelper::parseHeaderLocation( element.attribute( QLatin1String( "location" ) ) );
            KDReports::Footer& footer = m_report->footer( loc );
            parseHeaderFooterAttribute( footer, element );
            if ( m_xmlElementHandler && !m_xmlElementHandler->startFooter( footer, element ) )
                continue;
            if( !processNode( element, &footer.d->m_builder, false, true ) )
                return false;
            if ( m_xmlElementHandler )
                m_xmlElementHandler->endFooter( footer, element );
        } else if( name == QLatin1String( "variable" ) ) {
            if( !inHeader && !inFooter ) {
                error( QObject::tr("<variable> tags only allowed in headers and footers") );
                return false;
            }
            if( !element.hasAttribute( QLatin1String( "type" ) ) ) {
                error( QObject::tr("<variable> tags must have a 'type' attribute") );
                return false;
            }
            Q_ASSERT( builder );
            if ( builder ) {
                const QString type = element.attribute( QLatin1String( "type" ) );
                KDReports::VariableType vt = KDReports::XmlHelper::stringToVariableType( type );
                XmlElementHandlerV2* v2 = dynamic_cast<XmlElementHandlerV2 *>(m_xmlElementHandler);
                if (v2  && !v2->variable(vt, element))
                    continue;
                builder->addVariablePublic( vt );
            }
        } else if ( name == QLatin1String( "page-break" ) ) {
            if ( m_xmlElementHandler && !m_xmlElementHandler->pageBreak( element ) )
                continue;
            m_report->addPageBreak();
        } else if ( name == QLatin1String( "ifdef" ) ) {
            if ( element.hasAttribute( QLatin1String( "id" ) ) ) {
                const QString id = element.attribute( QLatin1String( "id" ) );
                const bool skip = m_textValues.value( id ).isEmpty();
                if( !skip ) {
                    if ( !processNode( element, builder, inHeader, inFooter ) )
                        return false;
                }
            }
        } else if ( name == QLatin1String( "custom" ) ) {
            if ( m_xmlElementHandler )
                m_xmlElementHandler->customElement( element );
        } else if ( name == QLatin1String( "hline" ) ) {
            KDReports::HLineElement hLineElement;

            if ( element.hasAttribute( QLatin1String( "thickness" ) ) ) {
                const double thickness = element.attribute( QLatin1String( "thickness" ) ).toDouble();
                hLineElement.setThickness( thickness );
            }

            if ( element.hasAttribute( QLatin1String( "color" ) ) ) {
                const QColor color = KDReports::XmlHelper::readColor( element, "color" );
                hLineElement.setColor( color );
            }

            if ( element.hasAttribute( QLatin1String( "margin" ) ) ) {
                const int margin = element.attribute( QLatin1String( "margin" ) ).toInt();
                hLineElement.setMargin( margin );
            }

#ifdef KDREPORTS_ALLOW_BINARY_INCOMPATIBILITY
            if ( m_xmlElementHandler && !m_xmlElementHandler->hLineElement( hLineElement, element ) )
               continue;
#else
            XmlElementHandlerV2* v2 = dynamic_cast<XmlElementHandlerV2 *>(m_xmlElementHandler);
            if (v2  && !v2->hLineElement(hLineElement, element))
                continue;
#endif

            addElement( hLineElement, builder, element );
        } else {
            error( QObject::tr( "KDReports::Report::loadFromXML(): Unknown element %1" ).arg( name ) );
        }
    }

    if ( testForErrorAndFillErrorDetails() )
        return false;

    return true;
}