LCOV - code coverage report
Current view: top level - toolkit/source/helper - formpdfexport.cxx (source / functions) Hit Total Coverage
Test: commit c8344322a7af75b84dd3ca8f78b05543a976dfd5 Lines: 0 237 0.0 %
Date: 2015-06-13 12:38:46 Functions: 0 5 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : #include <toolkit/helper/formpdfexport.hxx>
      22             : 
      23             : #include <com/sun/star/container/XIndexAccess.hpp>
      24             : #include <com/sun/star/container/XNameAccess.hpp>
      25             : #include <com/sun/star/container/XNameContainer.hpp>
      26             : #include <com/sun/star/form/XForm.hpp>
      27             : #include <com/sun/star/container/XChild.hpp>
      28             : #include <com/sun/star/lang/XServiceInfo.hpp>
      29             : #include <com/sun/star/beans/XPropertySet.hpp>
      30             : #include <com/sun/star/form/FormComponentType.hpp>
      31             : #include <com/sun/star/awt/TextAlign.hpp>
      32             : #include <com/sun/star/style/VerticalAlignment.hpp>
      33             : #include <com/sun/star/form/FormButtonType.hpp>
      34             : #include <com/sun/star/form/FormSubmitMethod.hpp>
      35             : 
      36             : #include <toolkit/helper/vclunohelper.hxx>
      37             : #include <vcl/pdfextoutdevdata.hxx>
      38             : #include <vcl/outdev.hxx>
      39             : 
      40             : #include <functional>
      41             : #include <algorithm>
      42             : 
      43             : 
      44             : namespace toolkitform
      45             : {
      46             : 
      47             : 
      48             :     using namespace ::com::sun::star;
      49             :     using namespace ::com::sun::star::uno;
      50             :     using namespace ::com::sun::star::awt;
      51             :     using namespace ::com::sun::star::style;
      52             :     using namespace ::com::sun::star::beans;
      53             :     using namespace ::com::sun::star::form;
      54             :     using namespace ::com::sun::star::lang;
      55             :     using namespace ::com::sun::star::container;
      56             : 
      57             :     static const char FM_PROP_NAME[] = "Name";
      58             : 
      59             :     namespace
      60             :     {
      61             : 
      62             :         /** determines the FormComponentType of a form control
      63             :         */
      64           0 :         sal_Int16 classifyFormControl( const Reference< XPropertySet >& _rxModel )
      65             :         {
      66             :             static const char FM_PROP_CLASSID[] = "ClassId";
      67           0 :             sal_Int16 nControlType = FormComponentType::CONTROL;
      68             : 
      69           0 :             Reference< XPropertySetInfo > xPSI;
      70           0 :             if ( _rxModel.is() )
      71           0 :                 xPSI = _rxModel->getPropertySetInfo();
      72           0 :             if ( xPSI.is() && xPSI->hasPropertyByName( FM_PROP_CLASSID ) )
      73             :             {
      74           0 :                 OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_CLASSID ) >>= nControlType );
      75             :             }
      76             : 
      77           0 :             return nControlType;
      78             :         }
      79             : 
      80             : 
      81             :         /** (default-)creates a PDF widget according to a given FormComponentType
      82             :         */
      83           0 :         vcl::PDFWriter::AnyWidget* createDefaultWidget( sal_Int16 _nFormComponentType )
      84             :         {
      85           0 :             switch ( _nFormComponentType )
      86             :             {
      87             :             case FormComponentType::COMMANDBUTTON:
      88           0 :                 return new vcl::PDFWriter::PushButtonWidget;
      89             :             case FormComponentType::CHECKBOX:
      90           0 :                 return new vcl::PDFWriter::CheckBoxWidget;
      91             :             case FormComponentType::RADIOBUTTON:
      92           0 :                 return new vcl::PDFWriter::RadioButtonWidget;
      93             :             case FormComponentType::LISTBOX:
      94           0 :                 return new vcl::PDFWriter::ListBoxWidget;
      95             :             case FormComponentType::COMBOBOX:
      96           0 :                 return new vcl::PDFWriter::ComboBoxWidget;
      97             : 
      98             :             case FormComponentType::TEXTFIELD:
      99             :             case FormComponentType::FILECONTROL:
     100             :             case FormComponentType::DATEFIELD:
     101             :             case FormComponentType::TIMEFIELD:
     102             :             case FormComponentType::NUMERICFIELD:
     103             :             case FormComponentType::CURRENCYFIELD:
     104             :             case FormComponentType::PATTERNFIELD:
     105           0 :                 return new vcl::PDFWriter::EditWidget;
     106             :             }
     107           0 :             return NULL;
     108             :         }
     109             : 
     110             : 
     111             :         /** determines a unique number for the radio group which the given radio
     112             :             button model belongs to
     113             : 
     114             :             The number is guaranteed to be
     115             :             <ul><li>unique within the document in which the button lives</li>
     116             :                 <li>the same for subsequent calls with other radio button models,
     117             :                     which live in the same document, and belong to the same group</li>
     118             :             </ul>
     119             : 
     120             :             @precond
     121             :                 the model must be part of the form component hierarchy in a document
     122             :         */
     123           0 :         sal_Int32 determineRadioGroupId( const Reference< XPropertySet >& _rxRadioModel )
     124             :         {
     125             :             OSL_ENSURE( classifyFormControl( _rxRadioModel ) == FormComponentType::RADIOBUTTON,
     126             :                 "determineRadioGroupId: this *is* no radio button model!" );
     127             :             // The fact that radio button groups need to be unique within the complete
     128             :             // host document makes it somewhat difficult ...
     129             :             // Problem is that two form radio buttons belong to the same group if
     130             :             // - they have the same parent
     131             :             // - AND they have the same name
     132             :             // This implies that we need some knowledge about (potentially) *all* radio button
     133             :             // groups in the document.
     134             : 
     135             :             // get the root-level container
     136           0 :             Reference< XChild > xChild( _rxRadioModel, UNO_QUERY );
     137           0 :             Reference< XForm > xParentForm( xChild.is() ? xChild->getParent() : Reference< XInterface >(), UNO_QUERY );
     138             :             OSL_ENSURE( xParentForm.is(), "determineRadioGroupId: no parent form -> group id!" );
     139           0 :             if ( !xParentForm.is() )
     140           0 :                 return -1;
     141             : 
     142           0 :             while ( xParentForm.is() )
     143             :             {
     144           0 :                 xChild = xParentForm.get();
     145           0 :                 xParentForm.set(xChild->getParent(), css::uno::UNO_QUERY);
     146             :             }
     147           0 :             Reference< XIndexAccess > xRoot( xChild->getParent(), UNO_QUERY );
     148             :             OSL_ENSURE( xRoot.is(), "determineRadioGroupId: unable to determine the root of the form component hierarchy!" );
     149           0 :             if ( !xRoot.is() )
     150           0 :                 return -1;
     151             : 
     152             :             // count the leafs in the hierarchy, until we encounter radio button
     153           0 :             ::std::vector< Reference< XIndexAccess > > aAncestors;
     154           0 :             ::std::vector< sal_Int32 >                 aPath;
     155             : 
     156           0 :             Reference< XInterface > xNormalizedLookup( _rxRadioModel, UNO_QUERY );
     157           0 :             OUString sRadioGroupName;
     158           0 :             OSL_VERIFY( _rxRadioModel->getPropertyValue( OUString(FM_PROP_NAME) ) >>= sRadioGroupName );
     159             : 
     160           0 :             Reference< XIndexAccess > xCurrentContainer( xRoot );
     161           0 :             sal_Int32 nStartWithChild = 0;
     162           0 :             sal_Int32 nGroupsEncountered = 0;
     163             :             do
     164             :             {
     165           0 :                 Reference< XNameAccess > xElementNameAccess( xCurrentContainer, UNO_QUERY );
     166             :                 OSL_ENSURE( xElementNameAccess.is(), "determineRadioGroupId: no name container?" );
     167           0 :                 if ( !xElementNameAccess.is() )
     168           0 :                     return -1;
     169             : 
     170           0 :                 if ( nStartWithChild == 0 )
     171             :                 {   // we encounter this container the first time. In particular, we did not
     172             :                     // just step up
     173           0 :                     nGroupsEncountered += xElementNameAccess->getElementNames().getLength();
     174             :                         // this is way too much: Not all of the elements in the current container
     175             :                         // may form groups, especially if they're forms. But anyway, this number is
     176             :                         // sufficient for our purpose. Finally, the container contains *at most*
     177             :                         // that much groups
     178             :                 }
     179             : 
     180           0 :                 sal_Int32 nCount = xCurrentContainer->getCount();
     181             :                 sal_Int32 i;
     182           0 :                 for ( i = nStartWithChild; i < nCount; ++i )
     183             :                 {
     184           0 :                     Reference< XInterface > xElement( xCurrentContainer->getByIndex( i ), UNO_QUERY );
     185           0 :                     if ( !xElement.is() )
     186             :                     {
     187             :                         OSL_FAIL( "determineRadioGroupId: very suspicious!" );
     188           0 :                         continue;
     189             :                     }
     190             : 
     191           0 :                     Reference< XIndexAccess > xNewContainer( xElement, UNO_QUERY );
     192           0 :                     if ( xNewContainer.is() )
     193             :                     {
     194             :                         // step down the hierarchy
     195           0 :                         aAncestors.push_back( xCurrentContainer );
     196           0 :                         xCurrentContainer = xNewContainer;
     197           0 :                         aPath.push_back( i );
     198           0 :                         nStartWithChild = 0;
     199           0 :                         break;
     200             :                             // out of the inner loop, but continue with the outer loop
     201             :                     }
     202             : 
     203           0 :                     if ( xElement.get() == xNormalizedLookup.get() )
     204             :                     {
     205             :                         // look up the name of the radio group in the list of all element names
     206           0 :                         Sequence< OUString > aElementNames( xElementNameAccess->getElementNames() );
     207           0 :                         const OUString* pElementNames = aElementNames.getConstArray();
     208           0 :                         const OUString* pElementNamesEnd = pElementNames + aElementNames.getLength();
     209           0 :                         while ( pElementNames != pElementNamesEnd )
     210             :                         {
     211           0 :                             if ( *pElementNames == sRadioGroupName )
     212             :                             {
     213           0 :                                 sal_Int32 nLocalGroupIndex = pElementNames - aElementNames.getConstArray();
     214             :                                 OSL_ENSURE( nLocalGroupIndex < xElementNameAccess->getElementNames().getLength(),
     215             :                                     "determineRadioGroupId: inconsistency!" );
     216             : 
     217           0 :                                 sal_Int32 nGlobalGroupId = nGroupsEncountered - xElementNameAccess->getElementNames().getLength() + nLocalGroupIndex;
     218           0 :                                 return nGlobalGroupId;
     219             :                             }
     220           0 :                             ++pElementNames;
     221             :                         }
     222           0 :                         OSL_FAIL( "determineRadioGroupId: did not find the radios element name!" );
     223             :                     }
     224           0 :                 }
     225             : 
     226           0 :                 if ( !( i < nCount ) )
     227             :                 {
     228             :                     // the loop terminated because there were no more elements
     229             :                     // -> step up, if possible
     230           0 :                     if ( aAncestors.empty() )
     231           0 :                         break;
     232             : 
     233           0 :                     xCurrentContainer = aAncestors.back(); aAncestors.pop_back();
     234           0 :                     nStartWithChild = aPath.back() + 1; aPath.pop_back();
     235           0 :                 }
     236             :             }
     237             :             while ( true );
     238           0 :             return -1;
     239             :         }
     240             : 
     241             : 
     242             :         /** copies a StringItemList to a PDF widget's list
     243             :         */
     244           0 :         void getStringItemVector( const Reference< XPropertySet >& _rxModel, ::std::vector< OUString >& _rVector )
     245             :         {
     246             :             static const char FM_PROP_STRINGITEMLIST[] = "StringItemList";
     247           0 :             Sequence< OUString > aListEntries;
     248           0 :             OSL_VERIFY( _rxModel->getPropertyValue( FM_PROP_STRINGITEMLIST ) >>= aListEntries );
     249             :             ::std::copy( aListEntries.begin(), aListEntries.end(),
     250           0 :                          ::std::back_insert_iterator< ::std::vector< OUString > >( _rVector ) );
     251           0 :         }
     252             :     }
     253             : 
     254             : 
     255             :     /** creates a PDF compatible control descriptor for the given control
     256             :     */
     257           0 :     std::unique_ptr<vcl::PDFWriter::AnyWidget> describePDFControl( const Reference< XControl >& _rxControl,
     258             :         vcl::PDFExtOutDevData& i_pdfExportData )
     259             :     {
     260           0 :         std::unique_ptr<vcl::PDFWriter::AnyWidget> Descriptor;
     261             :         OSL_ENSURE( _rxControl.is(), "describePDFControl: invalid (NULL) control!" );
     262           0 :         if ( !_rxControl.is() )
     263           0 :             return Descriptor;
     264             : 
     265             :         try
     266             :         {
     267           0 :             Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY );
     268           0 :             sal_Int16 nControlType = classifyFormControl( xModelProps );
     269           0 :             Descriptor.reset( createDefaultWidget( nControlType ) );
     270           0 :             if ( !Descriptor.get() )
     271             :                 // no PDF widget available for this
     272           0 :                 return Descriptor;
     273             : 
     274           0 :             Reference< XPropertySetInfo > xPSI( xModelProps->getPropertySetInfo() );
     275           0 :             Reference< XServiceInfo > xSI( xModelProps, UNO_QUERY );
     276             :             OSL_ENSURE( xSI.is(), "describePDFControl: no service info!" );
     277             :                 // if we survived classifyFormControl, then it's a real form control, and they all have
     278             :                 // service infos
     279             : 
     280             : 
     281             :             // set the common widget properties
     282             : 
     283             : 
     284             :             // Name, Description, Text
     285           0 :             OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_NAME ) >>= Descriptor->Name );
     286             :             static const char FM_PROP_HELPTEXT[] = "HelpText";
     287           0 :             OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_HELPTEXT ) >>= Descriptor->Description );
     288           0 :             Any aText;
     289             :             static const char FM_PROP_TEXT[] = "Text";
     290             :             static const char FM_PROP_LABEL[] = "Label";
     291           0 :             if ( xPSI->hasPropertyByName( FM_PROP_TEXT ) )
     292           0 :                 aText = xModelProps->getPropertyValue( FM_PROP_TEXT );
     293           0 :             else if ( xPSI->hasPropertyByName( FM_PROP_LABEL ) )
     294           0 :                 aText = xModelProps->getPropertyValue( FM_PROP_LABEL );
     295           0 :             if ( aText.hasValue() )
     296           0 :                 OSL_VERIFY( aText >>= Descriptor->Text );
     297             : 
     298             : 
     299             :             // readonly
     300             :             static const char FM_PROP_READONLY[] = "ReadOnly";
     301           0 :             if ( xPSI->hasPropertyByName( FM_PROP_READONLY ) )
     302           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_READONLY ) >>= Descriptor->ReadOnly );
     303             : 
     304             : 
     305             :             // border
     306             :             {
     307             :                 static const char FM_PROP_BORDER[] = "Border";
     308           0 :                 if ( xPSI->hasPropertyByName( FM_PROP_BORDER ) )
     309             :                 {
     310           0 :                     sal_Int16 nBorderType = 0;
     311           0 :                     OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_BORDER ) >>= nBorderType );
     312           0 :                     Descriptor->Border = ( nBorderType != 0 );
     313             : 
     314           0 :                     OUString sBorderColorPropertyName( "BorderColor" );
     315           0 :                     if ( xPSI->hasPropertyByName( sBorderColorPropertyName ) )
     316             :                     {
     317           0 :                         sal_Int32 nBoderColor = COL_TRANSPARENT;
     318           0 :                         if ( xModelProps->getPropertyValue( sBorderColorPropertyName ) >>= nBoderColor )
     319           0 :                             Descriptor->BorderColor = Color( nBoderColor );
     320             :                         else
     321           0 :                             Descriptor->BorderColor = Color( COL_BLACK );
     322           0 :                     }
     323             :                 }
     324             :             }
     325             : 
     326             : 
     327             :             // background color
     328             :             static const char FM_PROP_BACKGROUNDCOLOR[] = "BackgroundColor";
     329           0 :             if ( xPSI->hasPropertyByName( FM_PROP_BACKGROUNDCOLOR ) )
     330             :             {
     331           0 :                 sal_Int32 nBackColor = COL_TRANSPARENT;
     332           0 :                 xModelProps->getPropertyValue( FM_PROP_BACKGROUNDCOLOR ) >>= nBackColor;
     333           0 :                 Descriptor->Background = true;
     334           0 :                 Descriptor->BackgroundColor = Color( nBackColor );
     335             :             }
     336             : 
     337             : 
     338             :             // text color
     339             :             static const char FM_PROP_TEXTCOLOR[] = "TextColor";
     340           0 :             if ( xPSI->hasPropertyByName( FM_PROP_TEXTCOLOR ) )
     341             :             {
     342           0 :                 sal_Int32 nTextColor = COL_TRANSPARENT;
     343           0 :                 xModelProps->getPropertyValue( FM_PROP_TEXTCOLOR ) >>= nTextColor;
     344           0 :                 Descriptor->TextColor = Color( nTextColor );
     345             :             }
     346             : 
     347             : 
     348             :             // text style
     349           0 :             Descriptor->TextStyle = DrawTextFlags::NONE;
     350             : 
     351             :             // multi line and word break
     352             :             // The MultiLine property of the control is mapped to both the "MULTILINE" and
     353             :             // "WORDBREAK" style flags
     354             :             static const char FM_PROP_MULTILINE[] = "MultiLine";
     355           0 :             if ( xPSI->hasPropertyByName( FM_PROP_MULTILINE ) )
     356             :             {
     357           0 :                 bool bMultiLine = false;
     358           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_MULTILINE ) >>= bMultiLine );
     359           0 :                 if ( bMultiLine )
     360           0 :                     Descriptor->TextStyle |= DrawTextFlags::MultiLine | DrawTextFlags::WordBreak;
     361             :             }
     362             : 
     363             :             // horizontal alignment
     364             :             static const char FM_PROP_ALIGN[] = "Align";
     365           0 :             if ( xPSI->hasPropertyByName( FM_PROP_ALIGN ) )
     366             :             {
     367           0 :                 sal_Int16 nAlign = awt::TextAlign::LEFT;
     368           0 :                 xModelProps->getPropertyValue( FM_PROP_ALIGN ) >>= nAlign;
     369             :                 // TODO: when the property is VOID - are there situations/UIs where this
     370             :                 // means something else than LEFT?
     371           0 :                 switch ( nAlign )
     372             :                 {
     373           0 :                 case awt::TextAlign::LEFT:  Descriptor->TextStyle |= DrawTextFlags::Left; break;
     374           0 :                 case awt::TextAlign::CENTER:  Descriptor->TextStyle |= DrawTextFlags::Center; break;
     375           0 :                 case awt::TextAlign::RIGHT:  Descriptor->TextStyle |= DrawTextFlags::Right; break;
     376             :                 default:
     377             :                     OSL_FAIL( "describePDFControl: invalid text align!" );
     378             :                 }
     379             :             }
     380             : 
     381             :             // vertical alignment
     382             :             {
     383           0 :                 OUString sVertAlignPropertyName( "VerticalAlign" );
     384           0 :                 if ( xPSI->hasPropertyByName( sVertAlignPropertyName ) )
     385             :                 {
     386           0 :                     sal_Int16 nAlign = VerticalAlignment_MIDDLE;
     387           0 :                     xModelProps->getPropertyValue( sVertAlignPropertyName ) >>= nAlign;
     388           0 :                     switch ( nAlign )
     389             :                     {
     390           0 :                     case VerticalAlignment_TOP:  Descriptor->TextStyle |= DrawTextFlags::Top; break;
     391           0 :                     case VerticalAlignment_MIDDLE:  Descriptor->TextStyle |= DrawTextFlags::VCenter; break;
     392           0 :                     case VerticalAlignment_BOTTOM:  Descriptor->TextStyle |= DrawTextFlags::Bottom; break;
     393             :                     default:
     394             :                         OSL_FAIL( "describePDFControl: invalid vertical text align!" );
     395             :                     }
     396           0 :                 }
     397             :             }
     398             : 
     399             :             // font
     400             :             static const char FM_PROP_FONT[] = "FontDescriptor";
     401           0 :             if ( xPSI->hasPropertyByName( FM_PROP_FONT ) )
     402             :             {
     403           0 :                 FontDescriptor aUNOFont;
     404           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_FONT ) >>= aUNOFont );
     405           0 :                 Descriptor->TextFont = VCLUnoHelper::CreateFont( aUNOFont, vcl::Font() );
     406             :             }
     407             : 
     408             :             // tab order
     409           0 :             OUString aTabIndexString( "TabIndex" );
     410           0 :             if ( xPSI->hasPropertyByName( aTabIndexString ) )
     411             :             {
     412           0 :                 sal_Int16 nIndex = -1;
     413           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( aTabIndexString ) >>= nIndex );
     414           0 :                 Descriptor->TabOrder = nIndex;
     415             :             }
     416             : 
     417             : 
     418             :             // special widget properties
     419             : 
     420             :             // edits
     421           0 :             if ( Descriptor->getType() == vcl::PDFWriter::Edit )
     422             :             {
     423           0 :                 vcl::PDFWriter::EditWidget* pEditWidget = static_cast< vcl::PDFWriter::EditWidget* >( Descriptor.get() );
     424             : 
     425             :                 // multiline (already flagged in the TextStyle)
     426           0 :                 pEditWidget->MultiLine = bool( Descriptor->TextStyle & DrawTextFlags::MultiLine );
     427             : 
     428             :                 // password input
     429           0 :                 OUString sEchoCharPropName( "EchoChar" );
     430           0 :                 if ( xPSI->hasPropertyByName( sEchoCharPropName ) )
     431             :                 {
     432           0 :                     sal_Int16 nEchoChar = 0;
     433           0 :                     if ( ( xModelProps->getPropertyValue( sEchoCharPropName ) >>= nEchoChar ) && ( nEchoChar != 0 ) )
     434           0 :                         pEditWidget->Password = true;
     435             :                 }
     436             : 
     437             :                 // file select
     438             :                 static const char FM_SUN_COMPONENT_FILECONTROL[] = "com.sun.star.form.component.FileControl";
     439           0 :                 if ( xSI->supportsService( FM_SUN_COMPONENT_FILECONTROL ) )
     440           0 :                     pEditWidget->FileSelect = true;
     441             : 
     442             :                 // maximum text length
     443             :                 static const char FM_PROP_MAXTEXTLEN[] = "MaxTextLen";
     444           0 :                 if ( xPSI->hasPropertyByName( FM_PROP_MAXTEXTLEN ) )
     445             :                 {
     446           0 :                     sal_Int16 nMaxTextLength = 0;
     447           0 :                     OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_MAXTEXTLEN ) >>= nMaxTextLength );
     448           0 :                     if ( nMaxTextLength <= 0 )
     449             :                         // "-1" has a special meaning for database-bound controls
     450           0 :                         nMaxTextLength = 0;
     451           0 :                     pEditWidget->MaxLen = nMaxTextLength;
     452           0 :                 }
     453             :             }
     454             : 
     455             : 
     456             :             // buttons
     457           0 :             if ( Descriptor->getType() == vcl::PDFWriter::PushButton )
     458             :             {
     459           0 :                 vcl::PDFWriter::PushButtonWidget* pButtonWidget = static_cast< vcl::PDFWriter::PushButtonWidget* >( Descriptor.get() );
     460           0 :                 FormButtonType eButtonType = FormButtonType_PUSH;
     461           0 :                 OSL_VERIFY( xModelProps->getPropertyValue("ButtonType") >>= eButtonType );
     462             :                 static const char FM_PROP_TARGET_URL[] = "TargetURL";
     463           0 :                 if ( eButtonType == FormButtonType_SUBMIT )
     464             :                 {
     465             :                     // if a button is a submit button, then it uses the URL at its parent form
     466           0 :                     Reference< XChild > xChild( xModelProps, UNO_QUERY );
     467           0 :                     Reference < XPropertySet > xParentProps;
     468           0 :                     if ( xChild.is() )
     469           0 :                         xParentProps.set(xChild->getParent(), css::uno::UNO_QUERY);
     470           0 :                     if ( xParentProps.is() )
     471             :                     {
     472           0 :                         Reference< XServiceInfo > xParentSI( xParentProps, UNO_QUERY );
     473           0 :                         if ( xParentSI.is() && xParentSI->supportsService("com.sun.star.form.component.HTMLForm") )
     474             :                         {
     475           0 :                             OSL_VERIFY( xParentProps->getPropertyValue( FM_PROP_TARGET_URL ) >>= pButtonWidget->URL );
     476           0 :                             pButtonWidget->Submit = true;
     477           0 :                             FormSubmitMethod eMethod = FormSubmitMethod_POST;
     478           0 :                             OSL_VERIFY( xParentProps->getPropertyValue("SubmitMethod") >>= eMethod );
     479           0 :                             pButtonWidget->SubmitGet = (eMethod == FormSubmitMethod_GET);
     480           0 :                         }
     481           0 :                     }
     482             :                 }
     483           0 :                 else if ( eButtonType == FormButtonType_URL )
     484             :                 {
     485           0 :                     OUString sURL;
     486           0 :                     OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_TARGET_URL ) >>= sURL );
     487           0 :                     const bool bDocumentLocalTarget = sURL.startsWith("#");
     488           0 :                     if ( bDocumentLocalTarget )
     489             :                     {
     490             :                         // Register the destination for future handling ...
     491           0 :                         pButtonWidget->Dest = i_pdfExportData.RegisterDest();
     492             : 
     493             :                         // and put it into the bookmarks, to ensure the future handling really happens
     494           0 :                         ::std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks( i_pdfExportData.GetBookmarks() );
     495           0 :                         vcl::PDFExtOutDevBookmarkEntry aBookmark;
     496           0 :                         aBookmark.nDestId = pButtonWidget->Dest;
     497           0 :                         aBookmark.aBookmark = sURL;
     498           0 :                         rBookmarks.push_back( aBookmark );
     499             :                     }
     500             :                     else
     501           0 :                         pButtonWidget->URL = sURL;
     502             : 
     503           0 :                     pButtonWidget->Submit = false;
     504             :                 }
     505             : 
     506             :                // TODO:
     507             :                 // In PDF files, buttons are either reset, url or submit buttons. So if we have a simple PUSH button
     508             :                 // in a document, then this means that we do not export a SubmitToURL, which means that in PDF,
     509             :                 // the button is used as reset button.
     510             :                 // Is this desired? If no, we would have to reset Descriptor to NULL here, in case eButtonType
     511             :                 // != FormButtonType_SUBMIT && != FormButtonType_RESET
     512             : 
     513             :                 // the PDF exporter defaults the text style, if 0. To prevent this, we have to transfer the UNO
     514             :                 // defaults to the PDF widget
     515           0 :                 if ( pButtonWidget->TextStyle == DrawTextFlags::NONE )
     516           0 :                     pButtonWidget->TextStyle = DrawTextFlags::Center | DrawTextFlags::VCenter;
     517             :             }
     518             : 
     519             : 
     520             :             // check boxes
     521             :             static const char FM_PROP_STATE[] = "State";
     522           0 :             if ( Descriptor->getType() == vcl::PDFWriter::CheckBox )
     523             :             {
     524           0 :                 vcl::PDFWriter::CheckBoxWidget* pCheckBoxWidget = static_cast< vcl::PDFWriter::CheckBoxWidget* >( Descriptor.get() );
     525           0 :                 sal_Int16 nState = 0;
     526           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_STATE ) >>= nState );
     527           0 :                 pCheckBoxWidget->Checked = ( nState != 0 );
     528             :             }
     529             : 
     530             : 
     531             :             // radio buttons
     532           0 :             if ( Descriptor->getType() == vcl::PDFWriter::RadioButton )
     533             :             {
     534           0 :                 vcl::PDFWriter::RadioButtonWidget* pRadioWidget = static_cast< vcl::PDFWriter::RadioButtonWidget* >( Descriptor.get() );
     535           0 :                 sal_Int16 nState = 0;
     536           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_STATE ) >>= nState );
     537           0 :                 pRadioWidget->Selected = ( nState != 0 );
     538           0 :                 pRadioWidget->RadioGroup = determineRadioGroupId( xModelProps );
     539             :                 try
     540             :                 {
     541             :                     static const char FM_PROP_REFVALUE[] = "RefValue";
     542           0 :                     xModelProps->getPropertyValue( FM_PROP_REFVALUE ) >>= pRadioWidget->OnValue;
     543             :                 }
     544           0 :                 catch(...)
     545             :                 {
     546           0 :                     pRadioWidget->OnValue = "On";
     547             :                 }
     548             :             }
     549             : 
     550             : 
     551             :             // list boxes
     552           0 :             if ( Descriptor->getType() == vcl::PDFWriter::ListBox )
     553             :             {
     554           0 :                 vcl::PDFWriter::ListBoxWidget* pListWidget = static_cast< vcl::PDFWriter::ListBoxWidget* >( Descriptor.get() );
     555             : 
     556             :                 // drop down
     557             :                 static const char FM_PROP_DROPDOWN[] = "Dropdown";
     558           0 :                 OSL_VERIFY( xModelProps->getPropertyValue( FM_PROP_DROPDOWN ) >>= pListWidget->DropDown );
     559             : 
     560             :                 // multi selection
     561           0 :                 OSL_VERIFY( xModelProps->getPropertyValue("MultiSelection") >>= pListWidget->MultiSelect );
     562             : 
     563             :                 // entries
     564           0 :                 getStringItemVector( xModelProps, pListWidget->Entries );
     565             :                 // since we explicitly list the entries in the order in which they appear, they should not be
     566             :                 // resorted by the PDF viewer
     567           0 :                 pListWidget->Sort = false;
     568             : 
     569             :                 // get selected items
     570           0 :                 Sequence< sal_Int16 > aSelectIndices;
     571           0 :                 OSL_VERIFY( xModelProps->getPropertyValue("SelectedItems") >>= aSelectIndices );
     572           0 :                 if( aSelectIndices.getLength() > 0 )
     573             :                 {
     574           0 :                     pListWidget->SelectedEntries.resize( 0 );
     575           0 :                     for( sal_Int32 i = 0; i < aSelectIndices.getLength(); i++ )
     576             :                     {
     577           0 :                         sal_Int16 nIndex = aSelectIndices.getConstArray()[i];
     578           0 :                         if( nIndex >= 0 && nIndex < (sal_Int16)pListWidget->Entries.size() )
     579           0 :                             pListWidget->SelectedEntries.push_back( nIndex );
     580             :                     }
     581           0 :                 }
     582             :             }
     583             : 
     584             : 
     585             :             // combo boxes
     586           0 :             if ( Descriptor->getType() == vcl::PDFWriter::ComboBox )
     587             :             {
     588           0 :                 vcl::PDFWriter::ComboBoxWidget* pComboWidget = static_cast< vcl::PDFWriter::ComboBoxWidget* >( Descriptor.get() );
     589             : 
     590             :                 // entries
     591           0 :                 getStringItemVector( xModelProps, pComboWidget->Entries );
     592             :                 // same reasoning as above
     593           0 :                 pComboWidget->Sort = false;
     594             :             }
     595             : 
     596             : 
     597             :             // some post-processing
     598             : 
     599             :             // text line ends
     600             :             // some controls may (always or dependent on other settings) return UNIX line ends
     601           0 :             Descriptor->Text = convertLineEnd(Descriptor->Text, LINEEND_CRLF);
     602             :         }
     603           0 :         catch( const Exception& )
     604             :         {
     605             :             OSL_FAIL( "describePDFControl: caught an exception!" );
     606             :         }
     607           0 :         return Descriptor;
     608             :     }
     609             : 
     610             : 
     611             : } // namespace toolkitform
     612             : 
     613             : 
     614             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.11