summaryrefslogtreecommitdiffstats
path: root/toolkit/source/helper/formpdfexport.cxx
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-27 16:51:28 +0000
commit940b4d1848e8c70ab7642901a68594e8016caffc (patch)
treeeb72f344ee6c3d9b80a7ecc079ea79e9fba8676d /toolkit/source/helper/formpdfexport.cxx
parentInitial commit. (diff)
downloadlibreoffice-upstream.tar.xz
libreoffice-upstream.zip
Adding upstream version 1:7.0.4.upstream/1%7.0.4upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'toolkit/source/helper/formpdfexport.cxx')
-rw-r--r--toolkit/source/helper/formpdfexport.cxx648
1 files changed, 648 insertions, 0 deletions
diff --git a/toolkit/source/helper/formpdfexport.cxx b/toolkit/source/helper/formpdfexport.cxx
new file mode 100644
index 000000000..dc1f02f12
--- /dev/null
+++ b/toolkit/source/helper/formpdfexport.cxx
@@ -0,0 +1,648 @@
+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
+/*
+ * This file is part of the LibreOffice project.
+ *
+ * This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/.
+ *
+ * This file incorporates work covered by the following license notice:
+ *
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed
+ * with this work for additional information regarding copyright
+ * ownership. The ASF licenses this file to you under the Apache
+ * License, Version 2.0 (the "License"); you may not use this file
+ * except in compliance with the License. You may obtain a copy of
+ * the License at http://www.apache.org/licenses/LICENSE-2.0 .
+ */
+
+
+#include <memory>
+#include <toolkit/helper/formpdfexport.hxx>
+#include <tools/diagnose_ex.h>
+#include <tools/lineend.hxx>
+#include <unordered_map>
+#include <sal/log.hxx>
+
+#include <com/sun/star/container/XIndexAccess.hpp>
+#include <com/sun/star/form/XForm.hpp>
+#include <com/sun/star/container/XChild.hpp>
+#include <com/sun/star/lang/XServiceInfo.hpp>
+#include <com/sun/star/beans/XPropertySet.hpp>
+#include <com/sun/star/form/FormComponentType.hpp>
+#include <com/sun/star/awt/TextAlign.hpp>
+#include <com/sun/star/awt/XControl.hpp>
+#include <com/sun/star/style/VerticalAlignment.hpp>
+#include <com/sun/star/form/FormButtonType.hpp>
+#include <com/sun/star/form/FormSubmitMethod.hpp>
+
+#include <toolkit/helper/vclunohelper.hxx>
+#include <vcl/pdfextoutdevdata.hxx>
+#include <vcl/outdev.hxx>
+
+#include <algorithm>
+#include <iterator>
+
+
+namespace toolkitform
+{
+
+
+ using namespace ::com::sun::star;
+ using namespace ::com::sun::star::uno;
+ using namespace ::com::sun::star::awt;
+ using namespace ::com::sun::star::style;
+ using namespace ::com::sun::star::beans;
+ using namespace ::com::sun::star::form;
+ using namespace ::com::sun::star::lang;
+ using namespace ::com::sun::star::container;
+
+ static const char FM_PROP_NAME[] = "Name";
+
+ namespace
+ {
+
+ /** determines the FormComponentType of a form control
+ */
+ sal_Int16 classifyFormControl( const Reference< XPropertySet >& _rxModel )
+ {
+ static const char FM_PROP_CLASSID[] = "ClassId";
+ sal_Int16 nControlType = FormComponentType::CONTROL;
+
+ Reference< XPropertySetInfo > xPSI;
+ if ( _rxModel.is() )
+ xPSI = _rxModel->getPropertySetInfo();
+ if ( xPSI.is() && xPSI->hasPropertyByName( FM_PROP_CLASSID ) )
+ {
+ if( ! (_rxModel->getPropertyValue( FM_PROP_CLASSID ) >>= nControlType) ) {
+ SAL_WARN("toolkit.helper", "classifyFormControl: unable to get property " << FM_PROP_CLASSID);
+ }
+ }
+
+ return nControlType;
+ }
+
+
+ /** (default-)creates a PDF widget according to a given FormComponentType
+ */
+ std::unique_ptr<vcl::PDFWriter::AnyWidget> createDefaultWidget( sal_Int16 _nFormComponentType )
+ {
+ switch ( _nFormComponentType )
+ {
+ case FormComponentType::COMMANDBUTTON:
+ return std::make_unique<vcl::PDFWriter::PushButtonWidget>();
+ case FormComponentType::CHECKBOX:
+ return std::make_unique<vcl::PDFWriter::CheckBoxWidget>();
+ case FormComponentType::RADIOBUTTON:
+ return std::make_unique<vcl::PDFWriter::RadioButtonWidget>();
+ case FormComponentType::LISTBOX:
+ return std::make_unique<vcl::PDFWriter::ListBoxWidget>();
+ case FormComponentType::COMBOBOX:
+ return std::make_unique<vcl::PDFWriter::ComboBoxWidget>();
+
+ case FormComponentType::TEXTFIELD:
+ case FormComponentType::FILECONTROL:
+ case FormComponentType::DATEFIELD:
+ case FormComponentType::TIMEFIELD:
+ case FormComponentType::NUMERICFIELD:
+ case FormComponentType::CURRENCYFIELD:
+ case FormComponentType::PATTERNFIELD:
+ return std::make_unique<vcl::PDFWriter::EditWidget>();
+ }
+ return nullptr;
+ }
+
+
+ /** determines a unique number for the radio group which the given radio
+ button model belongs to
+
+ The number is guaranteed to be
+ <ul><li>unique within the document in which the button lives</li>
+ <li>the same for subsequent calls with other radio button models,
+ which live in the same document, and belong to the same group</li>
+ </ul>
+
+ @precond
+ the model must be part of the form component hierarchy in a document
+ */
+ sal_Int32 determineRadioGroupId( const Reference< XPropertySet >& _rxRadioModel )
+ {
+ OSL_ENSURE( classifyFormControl( _rxRadioModel ) == FormComponentType::RADIOBUTTON,
+ "determineRadioGroupId: this *is* no radio button model!" );
+ // The fact that radio button groups need to be unique within the complete
+ // host document makes it somewhat difficult ...
+ // Problem is that two form radio buttons belong to the same group if
+ // - they have the same parent
+ // - AND they have the same name or group name
+ // This implies that we need some knowledge about (potentially) *all* radio button
+ // groups in the document.
+
+ // get the root-level container
+ Reference< XChild > xChild( _rxRadioModel, UNO_QUERY );
+ Reference< XForm > xParentForm( xChild.is() ? xChild->getParent() : Reference< XInterface >(), UNO_QUERY );
+ OSL_ENSURE( xParentForm.is(), "determineRadioGroupId: no parent form -> group id!" );
+ if ( !xParentForm.is() )
+ return -1;
+
+ while ( xParentForm.is() )
+ {
+ xChild = xParentForm.get();
+ xParentForm.set(xChild->getParent(), css::uno::UNO_QUERY);
+ }
+ Reference< XIndexAccess > xRoot( xChild->getParent(), UNO_QUERY );
+ OSL_ENSURE( xRoot.is(), "determineRadioGroupId: unable to determine the root of the form component hierarchy!" );
+ if ( !xRoot.is() )
+ return -1;
+
+ // count the leafs in the hierarchy, until we encounter radio button
+ ::std::vector< Reference< XIndexAccess > > aAncestors;
+ ::std::vector< sal_Int32 > aPath;
+
+ Reference< XInterface > xNormalizedLookup( _rxRadioModel, UNO_QUERY );
+ Reference< XIndexAccess > xCurrentContainer( xRoot );
+ sal_Int32 nStartWithChild = 0;
+ sal_Int32 nGroupsEncountered = 0;
+ do
+ {
+ std::unordered_map<OUString,sal_Int32> GroupNameMap;
+ std::unordered_map<OUString,sal_Int32> SharedNameMap;
+ sal_Int32 nCount = xCurrentContainer->getCount();
+ sal_Int32 i;
+ for ( i = nStartWithChild; i < nCount; ++i )
+ {
+ Reference< XInterface > xElement( xCurrentContainer->getByIndex( i ), UNO_QUERY );
+ if ( !xElement.is() )
+ {
+ OSL_FAIL( "determineRadioGroupId: very suspicious!" );
+ continue;
+ }
+
+ Reference< XIndexAccess > xNewContainer( xElement, UNO_QUERY );
+ if ( xNewContainer.is() )
+ {
+ // step down the hierarchy
+ aAncestors.push_back( xCurrentContainer );
+ xCurrentContainer = xNewContainer;
+ aPath.push_back( i );
+ nStartWithChild = 0;
+ break;
+ // out of the inner loop, but continue with the outer loop
+ }
+
+ if ( xElement.get() == xNormalizedLookup.get() )
+ {
+ // Our radio button is in this container.
+ // Now take the time to ID this container's groups and return the button's groupId
+ for ( i = 0; i < nCount; ++i )
+ {
+ try
+ {
+ xElement.set( xCurrentContainer->getByIndex( i ), UNO_QUERY_THROW );
+ Reference< XServiceInfo > xModelSI( xElement, UNO_QUERY_THROW );
+ if ( xModelSI->supportsService("com.sun.star.awt.UnoControlRadioButtonModel") )
+ {
+ Reference< XPropertySet > aProps( xElement, UNO_QUERY_THROW );
+
+ OUString sGroupName;
+ aProps->getPropertyValue("GroupName") >>= sGroupName;
+ if ( !sGroupName.isEmpty() )
+ {
+ // map: unique key is the group name, so attempts to add a different ID value
+ // for an existing group are ignored - keeping the first ID - perfect for this scenario.
+ GroupNameMap.emplace( sGroupName, nGroupsEncountered + i );
+
+ if ( xElement.get() == xNormalizedLookup.get() )
+ return GroupNameMap[sGroupName];
+ }
+ else
+ {
+ // Old implementation didn't have a GroupName, just identical Control names.
+ aProps->getPropertyValue( FM_PROP_NAME ) >>= sGroupName;
+ SharedNameMap.emplace( sGroupName, nGroupsEncountered + i );
+
+ if ( xElement.get() == xNormalizedLookup.get() )
+ return SharedNameMap[sGroupName];
+ }
+
+ }
+ }
+ catch( uno::Exception& )
+ {
+ DBG_UNHANDLED_EXCEPTION("toolkit");
+ }
+ }
+ SAL_WARN("toolkit.helper","determineRadioGroupId: did not find the radios element's group!" );
+ }
+ }
+
+ // we encounter this container the first time. In particular, we did not just step up
+ if ( nStartWithChild == 0 )
+ {
+ // Our control wasn't in this container, so consider every item to be a possible unique group.
+ // This is way too much: Not all of the elements in the current container will form groups.
+ // But anyway, this number is sufficient for our purpose, since sequential group ids are not required.
+ // Ultimately, the container contains *at most* this many groups.
+ nGroupsEncountered += nCount;
+ }
+
+ if ( i >= nCount )
+ {
+ // the loop terminated because there were no more elements
+ // -> step up, if possible
+ if ( aAncestors.empty() )
+ break;
+
+ xCurrentContainer = aAncestors.back(); aAncestors.pop_back();
+ nStartWithChild = aPath.back() + 1; aPath.pop_back();
+ }
+ }
+ while ( true );
+ return -1;
+ }
+
+
+ /** copies a StringItemList to a PDF widget's list
+ */
+ void getStringItemVector( const Reference< XPropertySet >& _rxModel, ::std::vector< OUString >& _rVector )
+ {
+ Sequence< OUString > aListEntries;
+ if( ! (_rxModel->getPropertyValue( "StringItemList" ) >>= aListEntries) ) {
+ SAL_WARN("toolkit.helper", "getStringItemVector: unable to get property StringItemList");
+ }
+ ::std::copy( aListEntries.begin(), aListEntries.end(),
+ ::std::back_insert_iterator< ::std::vector< OUString > >( _rVector ) );
+ }
+ }
+
+
+ /** creates a PDF compatible control descriptor for the given control
+ */
+ std::unique_ptr<vcl::PDFWriter::AnyWidget> describePDFControl( const Reference< XControl >& _rxControl,
+ vcl::PDFExtOutDevData& i_pdfExportData )
+ {
+ std::unique_ptr<vcl::PDFWriter::AnyWidget> Descriptor;
+ OSL_ENSURE( _rxControl.is(), "describePDFControl: invalid (NULL) control!" );
+ if ( !_rxControl.is() )
+ return Descriptor;
+
+ try
+ {
+ Reference< XPropertySet > xModelProps( _rxControl->getModel(), UNO_QUERY );
+ sal_Int16 nControlType = classifyFormControl( xModelProps );
+ Descriptor = createDefaultWidget( nControlType );
+ if (!Descriptor)
+ // no PDF widget available for this
+ return Descriptor;
+
+ Reference< XPropertySetInfo > xPSI( xModelProps->getPropertySetInfo() );
+ Reference< XServiceInfo > xSI( xModelProps, UNO_QUERY );
+ OSL_ENSURE( xSI.is(), "describePDFControl: no service info!" );
+ // if we survived classifyFormControl, then it's a real form control, and they all have
+ // service infos
+
+
+ // set the common widget properties
+
+
+ // Name, Description, Text
+ if( ! (xModelProps->getPropertyValue( FM_PROP_NAME ) >>= Descriptor->Name) ) {
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_NAME);
+ }
+ if( ! (xModelProps->getPropertyValue( "HelpText" ) >>= Descriptor->Description) ) {
+ SAL_INFO("toolkit.helper", "describePDFControl: unable to get property HelpText");
+ }
+ Any aText;
+ static const char FM_PROP_TEXT[] = "Text";
+ static const char FM_PROP_LABEL[] = "Label";
+ if ( xPSI->hasPropertyByName( FM_PROP_TEXT ) )
+ aText = xModelProps->getPropertyValue( FM_PROP_TEXT );
+ else if ( xPSI->hasPropertyByName( FM_PROP_LABEL ) )
+ aText = xModelProps->getPropertyValue( FM_PROP_LABEL );
+ if ( aText.hasValue() ) {
+ if( ! (aText >>= Descriptor->Text) ) {
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to assign aText to Descriptor->Text");
+ }
+ }
+
+
+ // readonly
+ static const char FM_PROP_READONLY[] = "ReadOnly";
+ if ( xPSI->hasPropertyByName( FM_PROP_READONLY ) )
+ if( ! (xModelProps->getPropertyValue( FM_PROP_READONLY ) >>= Descriptor->ReadOnly) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_READONLY);
+
+
+ // border
+ {
+ static const char FM_PROP_BORDER[] = "Border";
+ if ( xPSI->hasPropertyByName( FM_PROP_BORDER ) )
+ {
+ sal_Int16 nBorderType = 0;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_BORDER ) >>= nBorderType) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_BORDER);
+ Descriptor->Border = ( nBorderType != 0 );
+
+ OUString sBorderColorPropertyName( "BorderColor" );
+ if ( xPSI->hasPropertyByName( sBorderColorPropertyName ) )
+ {
+ Color nBorderColor = COL_TRANSPARENT;
+ if ( xModelProps->getPropertyValue( sBorderColorPropertyName ) >>= nBorderColor )
+ Descriptor->BorderColor = nBorderColor;
+ else
+ Descriptor->BorderColor = COL_BLACK;
+ }
+ }
+ }
+
+
+ // background color
+ static const char FM_PROP_BACKGROUNDCOLOR[] = "BackgroundColor";
+ if ( xPSI->hasPropertyByName( FM_PROP_BACKGROUNDCOLOR ) )
+ {
+ Color nBackColor = COL_TRANSPARENT;
+ xModelProps->getPropertyValue( FM_PROP_BACKGROUNDCOLOR ) >>= nBackColor;
+ Descriptor->Background = true;
+ Descriptor->BackgroundColor = nBackColor;
+ }
+
+
+ // text color
+ static const char FM_PROP_TEXTCOLOR[] = "TextColor";
+ if ( xPSI->hasPropertyByName( FM_PROP_TEXTCOLOR ) )
+ {
+ Color nTextColor = COL_TRANSPARENT;
+ xModelProps->getPropertyValue( FM_PROP_TEXTCOLOR ) >>= nTextColor;
+ Descriptor->TextColor = nTextColor;
+ }
+
+
+ // text style
+ Descriptor->TextStyle = DrawTextFlags::NONE;
+
+ // multi line and word break
+ // The MultiLine property of the control is mapped to both the "MULTILINE" and
+ // "WORDBREAK" style flags
+ static const char FM_PROP_MULTILINE[] = "MultiLine";
+ if ( xPSI->hasPropertyByName( FM_PROP_MULTILINE ) )
+ {
+ bool bMultiLine = false;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_MULTILINE ) >>= bMultiLine) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_MULTILINE);
+ if ( bMultiLine )
+ Descriptor->TextStyle |= DrawTextFlags::MultiLine | DrawTextFlags::WordBreak;
+ }
+
+ // horizontal alignment
+ static const char FM_PROP_ALIGN[] = "Align";
+ if ( xPSI->hasPropertyByName( FM_PROP_ALIGN ) )
+ {
+ sal_Int16 nAlign = awt::TextAlign::LEFT;
+ xModelProps->getPropertyValue( FM_PROP_ALIGN ) >>= nAlign;
+ // TODO: when the property is VOID - are there situations/UIs where this
+ // means something else than LEFT?
+ switch ( nAlign )
+ {
+ case awt::TextAlign::LEFT: Descriptor->TextStyle |= DrawTextFlags::Left; break;
+ case awt::TextAlign::CENTER: Descriptor->TextStyle |= DrawTextFlags::Center; break;
+ case awt::TextAlign::RIGHT: Descriptor->TextStyle |= DrawTextFlags::Right; break;
+ default:
+ OSL_FAIL( "describePDFControl: invalid text align!" );
+ }
+ }
+
+ // vertical alignment
+ {
+ OUString sVertAlignPropertyName( "VerticalAlign" );
+ if ( xPSI->hasPropertyByName( sVertAlignPropertyName ) )
+ {
+ VerticalAlignment nAlign = VerticalAlignment_MIDDLE;
+ xModelProps->getPropertyValue( sVertAlignPropertyName ) >>= nAlign;
+ switch ( nAlign )
+ {
+ case VerticalAlignment_TOP: Descriptor->TextStyle |= DrawTextFlags::Top; break;
+ case VerticalAlignment_MIDDLE: Descriptor->TextStyle |= DrawTextFlags::VCenter; break;
+ case VerticalAlignment_BOTTOM: Descriptor->TextStyle |= DrawTextFlags::Bottom; break;
+ default:
+ OSL_FAIL( "describePDFControl: invalid vertical text align!" );
+ }
+ }
+ }
+
+ // font
+ static const char FM_PROP_FONT[] = "FontDescriptor";
+ if ( xPSI->hasPropertyByName( FM_PROP_FONT ) )
+ {
+ FontDescriptor aUNOFont;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_FONT ) >>= aUNOFont) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_FONT);
+ Descriptor->TextFont = VCLUnoHelper::CreateFont( aUNOFont, vcl::Font() );
+ }
+
+ // tab order
+ OUString aTabIndexString( "TabIndex" );
+ if ( xPSI->hasPropertyByName( aTabIndexString ) )
+ {
+ sal_Int16 nIndex = -1;
+ if( ! (xModelProps->getPropertyValue( aTabIndexString ) >>= nIndex) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << aTabIndexString);
+ Descriptor->TabOrder = nIndex;
+ }
+
+
+ // special widget properties
+
+ // edits
+ if ( Descriptor->getType() == vcl::PDFWriter::Edit )
+ {
+ vcl::PDFWriter::EditWidget* pEditWidget = static_cast< vcl::PDFWriter::EditWidget* >( Descriptor.get() );
+
+ // multiline (already flagged in the TextStyle)
+ pEditWidget->MultiLine = bool( Descriptor->TextStyle & DrawTextFlags::MultiLine );
+
+ // password input
+ OUString sEchoCharPropName( "EchoChar" );
+ if ( xPSI->hasPropertyByName( sEchoCharPropName ) )
+ {
+ sal_Int16 nEchoChar = 0;
+ if ( ( xModelProps->getPropertyValue( sEchoCharPropName ) >>= nEchoChar ) && ( nEchoChar != 0 ) )
+ pEditWidget->Password = true;
+ }
+
+ // file select
+ if ( xSI->supportsService( "com.sun.star.form.component.FileControl" ) )
+ pEditWidget->FileSelect = true;
+
+ // maximum text length
+ static const char FM_PROP_MAXTEXTLEN[] = "MaxTextLen";
+ if ( xPSI->hasPropertyByName( FM_PROP_MAXTEXTLEN ) )
+ {
+ sal_Int16 nMaxTextLength = 0;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_MAXTEXTLEN ) >>= nMaxTextLength) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_MAXTEXTLEN);
+ if ( nMaxTextLength <= 0 )
+ // "-1" has a special meaning for database-bound controls
+ nMaxTextLength = 0;
+ pEditWidget->MaxLen = nMaxTextLength;
+ }
+ }
+
+
+ // buttons
+ if ( Descriptor->getType() == vcl::PDFWriter::PushButton )
+ {
+ vcl::PDFWriter::PushButtonWidget* pButtonWidget = static_cast< vcl::PDFWriter::PushButtonWidget* >( Descriptor.get() );
+ FormButtonType eButtonType = FormButtonType_PUSH;
+ if( ! (xModelProps->getPropertyValue("ButtonType") >>= eButtonType) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property ButtonType");
+ static const char FM_PROP_TARGET_URL[] = "TargetURL";
+ if ( eButtonType == FormButtonType_SUBMIT )
+ {
+ // if a button is a submit button, then it uses the URL at its parent form
+ Reference< XChild > xChild( xModelProps, UNO_QUERY );
+ Reference < XPropertySet > xParentProps;
+ if ( xChild.is() )
+ xParentProps.set(xChild->getParent(), css::uno::UNO_QUERY);
+ if ( xParentProps.is() )
+ {
+ Reference< XServiceInfo > xParentSI( xParentProps, UNO_QUERY );
+ if ( xParentSI.is() && xParentSI->supportsService("com.sun.star.form.component.HTMLForm") )
+ {
+ if( ! (xParentProps->getPropertyValue( FM_PROP_TARGET_URL ) >>= pButtonWidget->URL) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_TARGET_URL);
+ pButtonWidget->Submit = true;
+ FormSubmitMethod eMethod = FormSubmitMethod_POST;
+ if( ! (xParentProps->getPropertyValue("SubmitMethod") >>= eMethod) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_TARGET_URL);
+ pButtonWidget->SubmitGet = (eMethod == FormSubmitMethod_GET);
+ }
+ }
+ }
+ else if ( eButtonType == FormButtonType_URL )
+ {
+ OUString sURL;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_TARGET_URL ) >>= sURL) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_TARGET_URL);
+ const bool bDocumentLocalTarget = sURL.startsWith("#");
+ if ( bDocumentLocalTarget )
+ {
+ // Register the destination for future handling ...
+ pButtonWidget->Dest = i_pdfExportData.RegisterDest();
+
+ // and put it into the bookmarks, to ensure the future handling really happens
+ ::std::vector< vcl::PDFExtOutDevBookmarkEntry >& rBookmarks( i_pdfExportData.GetBookmarks() );
+ vcl::PDFExtOutDevBookmarkEntry aBookmark;
+ aBookmark.nDestId = pButtonWidget->Dest;
+ aBookmark.aBookmark = sURL;
+ rBookmarks.push_back( aBookmark );
+ }
+ else
+ pButtonWidget->URL = sURL;
+
+ pButtonWidget->Submit = false;
+ }
+
+ // TODO:
+ // In PDF files, buttons are either reset, url or submit buttons. So if we have a simple PUSH button
+ // in a document, then this means that we do not export a SubmitToURL, which means that in PDF,
+ // the button is used as reset button.
+ // Is this desired? If no, we would have to reset Descriptor to NULL here, in case eButtonType
+ // != FormButtonType_SUBMIT && != FormButtonType_RESET
+
+ // the PDF exporter defaults the text style, if 0. To prevent this, we have to transfer the UNO
+ // defaults to the PDF widget
+ if ( pButtonWidget->TextStyle == DrawTextFlags::NONE )
+ pButtonWidget->TextStyle = DrawTextFlags::Center | DrawTextFlags::VCenter;
+ }
+
+
+ // check boxes
+ static const char FM_PROP_STATE[] = "State";
+ if ( Descriptor->getType() == vcl::PDFWriter::CheckBox )
+ {
+ vcl::PDFWriter::CheckBoxWidget* pCheckBoxWidget = static_cast< vcl::PDFWriter::CheckBoxWidget* >( Descriptor.get() );
+ sal_Int16 nState = 0;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_STATE ) >>= nState) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_STATE);
+ pCheckBoxWidget->Checked = ( nState != 0 );
+ }
+
+
+ // radio buttons
+ if ( Descriptor->getType() == vcl::PDFWriter::RadioButton )
+ {
+ vcl::PDFWriter::RadioButtonWidget* pRadioWidget = static_cast< vcl::PDFWriter::RadioButtonWidget* >( Descriptor.get() );
+ sal_Int16 nState = 0;
+ if( ! (xModelProps->getPropertyValue( FM_PROP_STATE ) >>= nState) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property " << FM_PROP_STATE);
+ pRadioWidget->Selected = ( nState != 0 );
+ pRadioWidget->RadioGroup = determineRadioGroupId( xModelProps );
+ try
+ {
+ xModelProps->getPropertyValue( "RefValue" ) >>= pRadioWidget->OnValue;
+ }
+ catch(...)
+ {
+ pRadioWidget->OnValue = "On";
+ }
+ }
+
+
+ // list boxes
+ if ( Descriptor->getType() == vcl::PDFWriter::ListBox )
+ {
+ vcl::PDFWriter::ListBoxWidget* pListWidget = static_cast< vcl::PDFWriter::ListBoxWidget* >( Descriptor.get() );
+
+ // drop down
+ if( ! (xModelProps->getPropertyValue( "Dropdown" ) >>= pListWidget->DropDown) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property Dropdown");
+
+ // multi selection
+ if( ! (xModelProps->getPropertyValue("MultiSelection") >>= pListWidget->MultiSelect) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property MultiSelection");
+
+ // entries
+ getStringItemVector( xModelProps, pListWidget->Entries );
+
+ // get selected items
+ Sequence< sal_Int16 > aSelectIndices;
+ if( ! (xModelProps->getPropertyValue("SelectedItems") >>= aSelectIndices) )
+ SAL_WARN("toolkit.helper", "describePDFControl: unable to get property SelectedItems");
+ if( aSelectIndices.hasElements() )
+ {
+ pListWidget->SelectedEntries.resize( 0 );
+ auto nEntriesSize = static_cast<sal_Int16>(pListWidget->Entries.size());
+ std::copy_if(aSelectIndices.begin(), aSelectIndices.end(), std::back_inserter(pListWidget->SelectedEntries),
+ [&nEntriesSize](const sal_Int16 nIndex) { return nIndex >= 0 && nIndex < nEntriesSize; });
+ }
+ }
+
+
+ // combo boxes
+ if ( Descriptor->getType() == vcl::PDFWriter::ComboBox )
+ {
+ vcl::PDFWriter::ComboBoxWidget* pComboWidget = static_cast< vcl::PDFWriter::ComboBoxWidget* >( Descriptor.get() );
+
+ // entries
+ getStringItemVector( xModelProps, pComboWidget->Entries );
+ }
+
+
+ // some post-processing
+
+ // text line ends
+ // some controls may (always or dependent on other settings) return UNIX line ends
+ Descriptor->Text = convertLineEnd(Descriptor->Text, LINEEND_CRLF);
+ }
+ catch( const Exception& )
+ {
+ TOOLS_WARN_EXCEPTION( "toolkit", "describePDFControl" );
+ }
+ return Descriptor;
+ }
+
+
+} // namespace toolkitform
+
+
+/* vim:set shiftwidth=4 softtabstop=4 expandtab: */