xmlscript/source/xmldlg_imexp/xmldlg_export.cxx

   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 #include "common.hxx"
  21 #include "exp_share.hxx"
  22 #include <xmlscript/xmlns.h>
  23
  24 #include <o3tl/any.hxx>
  25 #include <sal/log.hxx>
  26 #include <comphelper/diagnose_ex.hxx>
  27
  28 #include <com/sun/star/awt/CharSet.hpp>
  29 #include <com/sun/star/awt/FontFamily.hpp>
  30 #include <com/sun/star/awt/FontPitch.hpp>
  31 #include <com/sun/star/awt/FontSlant.hpp>
  32 #include <com/sun/star/awt/FontStrikeout.hpp>
  33 #include <com/sun/star/awt/FontType.hpp>
  34 #include <com/sun/star/awt/FontUnderline.hpp>
  35 #include <com/sun/star/awt/ImagePosition.hpp>
  36 #include <com/sun/star/awt/ImageScaleMode.hpp>
  37 #include <com/sun/star/awt/LineEndFormat.hpp>
  38 #include <com/sun/star/awt/PushButtonType.hpp>
  39 #include <com/sun/star/awt/VisualEffect.hpp>
  40 #include <com/sun/star/frame/XModel.hpp>
  41 #include <com/sun/star/util/Date.hpp>
  42 #include <com/sun/star/util/Time.hpp>
  43 #include <tools/date.hxx>
  44 #include <tools/time.hxx>
  45
  46 #include <com/sun/star/io/XPersistObject.hpp>
  47
  48 #include <com/sun/star/script/XScriptEventsSupplier.hpp>
  49 #include <com/sun/star/script/ScriptEventDescriptor.hpp>
  50
  51 #include <com/sun/star/style/VerticalAlignment.hpp>
  52
  53 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  54 #include <com/sun/star/lang/XServiceInfo.hpp>
  55 #include <com/sun/star/lang/Locale.hpp>
  56
  57 #include <com/sun/star/view/SelectionType.hpp>
  58
  59 #include <com/sun/star/form/binding/XListEntrySink.hpp>
  60 #include <com/sun/star/form/binding/XBindableValue.hpp>
  61 #include <com/sun/star/table/CellAddress.hpp>
  62 #include <com/sun/star/table/CellRangeAddress.hpp>
  63 #include <com/sun/star/document/XStorageBasedDocument.hpp>
  64 #include <com/sun/star/document/GraphicStorageHandler.hpp>
  65 #include <com/sun/star/document/XGraphicStorageHandler.hpp>
  66 #include <com/sun/star/graphic/XGraphic.hpp>
  67 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  68
  69 #include <comphelper/processfactory.hxx>
  70 #include <i18nlangtag/languagetag.hxx>
  71 #include <rtl/ref.hxx>
  72
  73 using namespace ::com::sun::star;
  74 using namespace ::com::sun::star::uno;
  75
  76 namespace xmlscript
  77 {
  78
  79 Reference< xml::sax::XAttributeList > Style::createElement()
  80 {
  81     rtl::Reference<ElementDescriptor> pStyle = new ElementDescriptor( XMLNS_DIALOGS_PREFIX ":style" );
  82
  83     // style-id
  84     pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":style-id", _id );
  85
  86     // background-color
  87     if (_set & 0x1)
  88     {
  89         pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":background-color", "0x" + OUString::number(_backgroundColor,16));
  90     }
  91
  92     // text-color
  93     if (_set & 0x2)
  94     {
  95         pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":text-color", "0x" + OUString::number(_textColor,16));
  96     }
  97
  98     // textline-color
  99     if (_set & 0x20)
 100     {
 101         pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":textline-color", "0x" + OUString::number(_textLineColor,16));
 102     }
 103
 104     // fill-color
 105     if (_set & 0x10)
 106     {
 107         pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":fill-color", "0x" + OUString::number(_fillColor,16));
 108     }
 109
 110     // border
 111     if (_set & 0x4)
 112     {
 113         switch (_border)
 114         {
 115         case BORDER_NONE:
 116             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":border", "none" );
 117             break;
 118         case BORDER_3D:
 119             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":border", "3d" );
 120             break;
 121         case BORDER_SIMPLE:
 122             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":border", "simple" );
 123             break;
 124         case BORDER_SIMPLE_COLOR: {
 125             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":border", "0x" + OUString::number(_borderColor,16));
 126             break;
 127         }
 128         default:
 129             SAL_WARN( "xmlscript.xmldlg", "### unexpected border value!" );
 130             break;
 131         }
 132     }
 133
 134     // visual effect (look)
 135     if (_set & 0x40)
 136     {
 137         switch (_visualEffect)
 138         {
 139         case awt::VisualEffect::NONE:
 140             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":look", "none" );
 141             break;
 142         case awt::VisualEffect::LOOK3D:
 143             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":look", "3d" );
 144             break;
 145         case awt::VisualEffect::FLAT:
 146             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":look", "simple" );
 147             break;
 148         default:
 149             SAL_WARN( "xmlscript.xmldlg", "### unexpected visual effect value!" );
 150             break;
 151         }
 152     }
 153
 154     // font-
 155     if (_set & 0x8)
 156     {
 157         awt::FontDescriptor def_descr;
 158
 159         // dialog:font-name CDATA #IMPLIED
 160         if (def_descr.Name != _descr.Name)
 161         {
 162             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-name", _descr.Name );
 163         }
 164         // dialog:font-height %numeric; #IMPLIED
 165         if (def_descr.Height != _descr.Height)
 166         {
 167             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-height", OUString::number( _descr.Height ) );
 168         }
 169         // dialog:font-width %numeric; #IMPLIED
 170         if (def_descr.Width != _descr.Width)
 171         {
 172             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-width", OUString::number( _descr.Width ) );
 173         }
 174         // dialog:font-stylename CDATA #IMPLIED
 175         if (def_descr.StyleName != _descr.StyleName)
 176         {
 177             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-stylename", _descr.StyleName );
 178         }
 179         // dialog:font-family "(decorative|modern|roman|script|swiss|system)" #IMPLIED
 180         if (def_descr.Family != _descr.Family)
 181         {
 182             switch (_descr.Family)
 183             {
 184             case awt::FontFamily::DECORATIVE:
 185                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "decorative" );
 186                 break;
 187             case awt::FontFamily::MODERN:
 188                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "modern" );
 189                 break;
 190             case awt::FontFamily::ROMAN:
 191                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "roman" );
 192                 break;
 193             case awt::FontFamily::SCRIPT:
 194                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "script" );
 195                 break;
 196             case awt::FontFamily::SWISS:
 197                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "swiss" );
 198                 break;
 199             case awt::FontFamily::SYSTEM:
 200                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-family", "system" );
 201                 break;
 202             default:
 203                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-family!" );
 204                 break;
 205             }
 206         }
 207         // dialog:font-charset "(ansi|mac|ibmpc_437|ibmpc_850|ibmpc_860|ibmpc_861|ibmpc_863|ibmpc_865|system|symbol)" #IMPLIED
 208         if (def_descr.CharSet != _descr.CharSet)
 209         {
 210             switch (_descr.CharSet)
 211             {
 212             case awt::CharSet::ANSI:
 213                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ansi" );
 214                 break;
 215             case awt::CharSet::MAC:
 216                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "mac" );
 217                 break;
 218             case awt::CharSet::IBMPC_437:
 219                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_437" );
 220                 break;
 221             case awt::CharSet::IBMPC_850:
 222                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_850" );
 223                 break;
 224             case awt::CharSet::IBMPC_860:
 225                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_860" );
 226                 break;
 227             case awt::CharSet::IBMPC_861:
 228                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_861" );
 229                 break;
 230             case awt::CharSet::IBMPC_863:
 231                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_863" );
 232                 break;
 233             case awt::CharSet::IBMPC_865:
 234                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "ibmpc_865" );
 235                 break;
 236             case awt::CharSet::SYSTEM:
 237                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "system" );
 238                 break;
 239             case awt::CharSet::SYMBOL:
 240                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charset", "symbol" );
 241                 break;
 242             default:
 243                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-charset!" );
 244                 break;
 245             }
 246         }
 247         // dialog:font-pitch "(fixed|variable)" #IMPLIED
 248         if (def_descr.Pitch != _descr.Pitch)
 249         {
 250             switch (_descr.Pitch)
 251             {
 252             case awt::FontPitch::FIXED:
 253                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-pitch", "fixed" );
 254                 break;
 255             case awt::FontPitch::VARIABLE:
 256                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-pitch", "variable" );
 257                 break;
 258             default:
 259                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-pitch!" );
 260                 break;
 261             }
 262         }
 263         // dialog:font-charwidth CDATA #IMPLIED
 264         if (def_descr.CharacterWidth != _descr.CharacterWidth)
 265         {
 266             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-charwidth", OUString::number( _descr.CharacterWidth ) );
 267         }
 268         // dialog:font-weight CDATA #IMPLIED
 269         if (def_descr.Weight != _descr.Weight)
 270         {
 271             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-weight", OUString::number( _descr.Weight ) );
 272         }
 273         // dialog:font-slant "(oblique|italic|reverse_oblique|reverse_italic)" #IMPLIED
 274         if (def_descr.Slant != _descr.Slant)
 275         {
 276             switch (_descr.Slant)
 277             {
 278             case awt::FontSlant_OBLIQUE:
 279                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-slant", "oblique" );
 280                 break;
 281             case awt::FontSlant_ITALIC:
 282                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-slant", "italic" );
 283                 break;
 284             case awt::FontSlant_REVERSE_OBLIQUE:
 285                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-slant", "reverse_oblique" );
 286                 break;
 287             case awt::FontSlant_REVERSE_ITALIC:
 288                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-slant", "reverse_italic" );
 289                 break;
 290             default:
 291                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-slant!" );
 292                 break;
 293             }
 294         }
 295         // dialog:font-underline "(single|double|dotted|dash|longdash|dashdot|dashdotdot|smallwave|wave|doublewave|bold|bolddotted|bolddash|boldlongdash|bolddashdot|bolddashdotdot|boldwave)" #IMPLIED
 296         if (def_descr.Underline != _descr.Underline)
 297         {
 298             switch (_descr.Underline)
 299             {
 300             case awt::FontUnderline::SINGLE:
 301                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "single" );
 302                 break;
 303             case awt::FontUnderline::DOUBLE:
 304                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "double" );
 305                 break;
 306             case awt::FontUnderline::DOTTED:
 307                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "dotted" );
 308                 break;
 309             case awt::FontUnderline::DASH:
 310                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "dash" );
 311                 break;
 312             case awt::FontUnderline::LONGDASH:
 313                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "longdash" );
 314                 break;
 315             case awt::FontUnderline::DASHDOT:
 316                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "dashdot" );
 317                 break;
 318             case awt::FontUnderline::DASHDOTDOT:
 319                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "dashdotdot" );
 320                 break;
 321             case awt::FontUnderline::SMALLWAVE:
 322                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "smallwave" );
 323                 break;
 324             case awt::FontUnderline::WAVE:
 325                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "wave" );
 326                 break;
 327             case awt::FontUnderline::DOUBLEWAVE:
 328                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "doublewave" );
 329                 break;
 330             case awt::FontUnderline::BOLD:
 331                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "bold" );
 332                 break;
 333             case awt::FontUnderline::BOLDDOTTED:
 334                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "bolddotted" );
 335                 break;
 336             case awt::FontUnderline::BOLDDASH:
 337                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "bolddash" );
 338                 break;
 339             case awt::FontUnderline::BOLDLONGDASH:
 340                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "boldlongdash" );
 341                 break;
 342             case awt::FontUnderline::BOLDDASHDOT:
 343                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "bolddashdot" );
 344                 break;
 345             case awt::FontUnderline::BOLDDASHDOTDOT:
 346                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "bolddashdotdot" );
 347                 break;
 348             case awt::FontUnderline::BOLDWAVE:
 349                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-underline", "boldwave" );
 350                 break;
 351             default:
 352                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-underline!" );
 353                 break;
 354             }
 355         }
 356         // dialog:font-strikeout "(single|double|bold|slash|x)" #IMPLIED
 357         if (def_descr.Strikeout != _descr.Strikeout)
 358         {
 359             switch (_descr.Strikeout)
 360             {
 361             case awt::FontStrikeout::SINGLE:
 362                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-strikeout", "single" );
 363                 break;
 364             case awt::FontStrikeout::DOUBLE:
 365                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-strikeout", "double" );
 366                 break;
 367             case awt::FontStrikeout::BOLD:
 368                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-strikeout", "bold" );
 369                 break;
 370             case awt::FontStrikeout::SLASH:
 371                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-strikeout", "slash" );
 372                 break;
 373             case awt::FontStrikeout::X:
 374                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-strikeout", "x" );
 375                 break;
 376             default:
 377                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-strikeout!" );
 378                 break;
 379             }
 380         }
 381         // dialog:font-orientation CDATA #IMPLIED
 382         if (def_descr.Orientation != _descr.Orientation)
 383         {
 384             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-orientation", OUString::number( _descr.Orientation ) );
 385         }
 386         // dialog:font-kerning %boolean; #IMPLIED
 387         if (bool(def_descr.Kerning) != bool(_descr.Kerning))
 388         {
 389             pStyle->addBoolAttr( XMLNS_DIALOGS_PREFIX ":font-kerning", _descr.Kerning );
 390         }
 391         // dialog:font-wordlinemode %boolean; #IMPLIED
 392         if (bool(def_descr.WordLineMode) != bool(_descr.WordLineMode))
 393         {
 394             pStyle->addBoolAttr( XMLNS_DIALOGS_PREFIX ":font-wordlinemode", _descr.WordLineMode );
 395         }
 396         // dialog:font-type "(raster|device|scalable)" #IMPLIED
 397         if (def_descr.Type != _descr.Type)
 398         {
 399             switch (_descr.Type)
 400             {
 401             case awt::FontType::RASTER:
 402                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-type", "raster" );
 403                 break;
 404             case awt::FontType::DEVICE:
 405                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-type", "device" );
 406                 break;
 407             case awt::FontType::SCALABLE:
 408                 pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-type", "scalable" );
 409                 break;
 410             default:
 411                 SAL_WARN( "xmlscript.xmldlg", "### unexpected font-type!" );
 412                 break;
 413             }
 414         }
 415
 416         // additional attributes not in FontDescriptor struct
 417         // dialog:font-relief (none|embossed|engraved) #IMPLIED
 418         switch (_fontRelief)
 419         {
 420         case awt::FontRelief::NONE: // don't export default
 421             break;
 422         case awt::FontRelief::EMBOSSED:
 423             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-relief", "embossed" );
 424             break;
 425         case awt::FontRelief::ENGRAVED:
 426             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-relief", "engraved" );
 427             break;
 428         default:
 429             SAL_WARN( "xmlscript.xmldlg", "### unexpected font-relief!" );
 430             break;
 431         }
 432         // dialog:font-emphasismark (none|dot|circle|disc|accent|above|below) #IMPLIED
 433         switch (_fontEmphasisMark)
 434         {
 435         case awt::FontEmphasisMark::NONE: // don't export default
 436             break;
 437         case awt::FontEmphasisMark::DOT:
 438             pStyle->addAttribute(XMLNS_DIALOGS_PREFIX ":font-emphasismark", "dot" );
 439             break;
 440         case awt::FontEmphasisMark::CIRCLE:
 441             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-emphasismark", "circle" );
 442             break;
 443         case awt::FontEmphasisMark::DISC:
 444             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-emphasismark", "disc" );
 445             break;
 446         case awt::FontEmphasisMark::ACCENT:
 447             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-emphasismark", "accent" );
 448             break;
 449         case awt::FontEmphasisMark::ABOVE:
 450             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-emphasismark", "above" );
 451             break;
 452         case awt::FontEmphasisMark::BELOW:
 453             pStyle->addAttribute( XMLNS_DIALOGS_PREFIX ":font-emphasismark", "below" );
 454             break;
 455         default:
 456             SAL_WARN( "xmlscript.xmldlg", "### unexpected font-emphasismark!" );
 457             break;
 458         }
 459     }
 460
 461     return pStyle;
 462 }
 463
 464 void ElementDescriptor::addNumberFormatAttr(
 465     Reference< beans::XPropertySet > const & xFormatProperties )
 466 {
 467     OUString sFormat;
 468     lang::Locale locale;
 469     OSL_VERIFY( xFormatProperties->getPropertyValue( "FormatString" ) >>= sFormat );
 470     OSL_VERIFY( xFormatProperties->getPropertyValue( "Locale" ) >>= locale );
 471
 472     addAttribute(XMLNS_DIALOGS_PREFIX ":format-code", sFormat );
 473
 474     // format-locale
 475     LanguageTag aLanguageTag( locale);
 476     OUString aStr;
 477     if (aLanguageTag.isIsoLocale())
 478     {
 479         // Old style "lll;CC" for compatibility, I really don't know what may
 480         // consume this.
 481         if (aLanguageTag.getCountry().isEmpty())
 482             aStr = aLanguageTag.getLanguage();
 483         else
 484             aStr = aLanguageTag.getLanguage() + ";" + aLanguageTag.getCountry();
 485     }
 486     else
 487     {
 488         aStr = aLanguageTag.getBcp47( false);
 489     }
 490     addAttribute( XMLNS_DIALOGS_PREFIX ":format-locale", aStr );
 491 }
 492
 493 Any ElementDescriptor::readProp( OUString const & rPropName )
 494 {
 495     if (beans::PropertyState_DEFAULT_VALUE != _xPropState->getPropertyState( rPropName ))
 496     {
 497         return _xProps->getPropertyValue( rPropName );
 498     }
 499     return Any();
 500 }
 501
 502 void ElementDescriptor::readStringAttr(
 503     OUString const & rPropName, OUString const & rAttrName )
 504 {
 505     if (beans::PropertyState_DEFAULT_VALUE !=
 506         _xPropState->getPropertyState( rPropName ))
 507     {
 508         Any a( _xProps->getPropertyValue( rPropName ) );
 509         OUString v;
 510         if (a >>= v)
 511             addAttribute( rAttrName, v );
 512         else
 513             SAL_WARN( "xmlscript.xmldlg", "### unexpected property type!" );
 514     }
 515 }
 516
 517 void ElementDescriptor::readHexLongAttr( OUString const & rPropName, OUString const & rAttrName )
 518 {
 519     if (beans::PropertyState_DEFAULT_VALUE != _xPropState->getPropertyState( rPropName ))
 520     {
 521         Any a( _xProps->getPropertyValue( rPropName ) );
 522         if (auto n = o3tl::tryAccess<sal_uInt32>(a))
 523         {
 524             addAttribute( rAttrName, "0x" + OUString::number(*n, 16)  );
 525         }
 526     }
 527 }
 528
 529 void ElementDescriptor::readDateFormatAttr( OUString const & rPropName, OUString const & rAttrName )
 530 {
 531     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 532         return;
 533
 534     Any a( _xProps->getPropertyValue( rPropName ) );
 535     if (auto n = o3tl::tryAccess<sal_Int16>(a))
 536     {
 537         switch (*n)
 538         {
 539         case 0:
 540             addAttribute( rAttrName, "system_short" );
 541             break;
 542         case 1:
 543             addAttribute( rAttrName, "system_short_YY" );
 544             break;
 545         case 2:
 546             addAttribute( rAttrName, "system_short_YYYY" );
 547             break;
 548         case 3:
 549             addAttribute( rAttrName, "system_long" );
 550             break;
 551         case 4:
 552             addAttribute( rAttrName, "short_DDMMYY" );
 553             break;
 554         case 5:
 555             addAttribute( rAttrName, "short_MMDDYY" );
 556             break;
 557         case 6:
 558             addAttribute( rAttrName, "short_YYMMDD" );
 559             break;
 560         case 7:
 561             addAttribute( rAttrName, "short_DDMMYYYY" );
 562             break;
 563         case 8:
 564             addAttribute( rAttrName, "short_MMDDYYYY" );
 565             break;
 566         case 9:
 567             addAttribute( rAttrName, "short_YYYYMMDD" );
 568             break;
 569         case 10:
 570             addAttribute( rAttrName, "short_YYMMDD_DIN5008" );
 571             break;
 572         case 11:
 573             addAttribute( rAttrName, "short_YYYYMMDD_DIN5008" );
 574             break;
 575         default:
 576             SAL_WARN( "xmlscript.xmldlg", "### unexpected date format!" );
 577             break;
 578         }
 579     }
 580     else
 581         OSL_FAIL( "### unexpected property type!" );
 582 }
 583
 584 void ElementDescriptor::readDateAttr( OUString const & rPropName, OUString const & rAttrName )
 585 {
 586     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 587         return;
 588
 589     Any a( _xProps->getPropertyValue( rPropName ) );
 590     if (a.getValueTypeClass() == TypeClass_STRUCT && a.getValueType() == cppu::UnoType<util::Date>::get())
 591     {
 592         util::Date aUDate;
 593         if (a >>= aUDate)
 594         {
 595             ::Date aTDate(aUDate);
 596             addAttribute( rAttrName, OUString::number( aTDate.GetDate() ) );
 597         }
 598         else
 599             OSL_FAIL( "### internal error" );
 600     }
 601     else
 602         OSL_FAIL( "### unexpected property type!" );
 603 }
 604
 605 void ElementDescriptor::readTimeAttr( OUString const & rPropName, OUString const & rAttrName )
 606 {
 607     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 608         return;
 609
 610     Any a( _xProps->getPropertyValue( rPropName ) );
 611     if (a.getValueTypeClass() == TypeClass_STRUCT && a.getValueType() == cppu::UnoType<util::Time>::get())
 612     {
 613         util::Time aUTime;
 614         if (a >>= aUTime)
 615         {
 616             ::tools::Time aTTime(aUTime);
 617             addAttribute( rAttrName, OUString::number( aTTime.GetTime() / ::tools::Time::nanoPerCenti ) );
 618         }
 619         else
 620             OSL_FAIL( "### internal error" );
 621     }
 622     else
 623         OSL_FAIL( "### unexpected property type!" );
 624 }
 625
 626 void ElementDescriptor::readTimeFormatAttr( OUString const & rPropName, OUString const & rAttrName )
 627 {
 628     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 629         return;
 630
 631     Any a( _xProps->getPropertyValue( rPropName ) );
 632     if (auto n = o3tl::tryAccess<sal_Int16>(a))
 633     {
 634         switch (*n)
 635         {
 636         case 0:
 637             addAttribute( rAttrName, "24h_short" );
 638             break;
 639         case 1:
 640             addAttribute( rAttrName, "24h_long" );
 641             break;
 642         case 2:
 643             addAttribute( rAttrName, "12h_short" );
 644             break;
 645         case 3:
 646             addAttribute( rAttrName, "12h_long" );
 647             break;
 648         case 4:
 649             addAttribute( rAttrName, "Duration_short" );
 650             break;
 651         case 5:
 652             addAttribute( rAttrName, "Duration_long" );
 653             break;
 654         default:
 655             SAL_WARN( "xmlscript.xmldlg", "### unexpected time format!" );
 656             break;
 657         }
 658     }
 659     else
 660         OSL_FAIL( "### unexpected property type!" );
 661 }
 662
 663 void ElementDescriptor::readAlignAttr( OUString const & rPropName, OUString const & rAttrName )
 664 {
 665     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 666         return;
 667
 668     Any a( _xProps->getPropertyValue( rPropName ) );
 669     if (auto n = o3tl::tryAccess<sal_Int16>(a))
 670     {
 671         switch (*n)
 672         {
 673         case 0:
 674             addAttribute( rAttrName, "left" );
 675             break;
 676         case 1:
 677             addAttribute( rAttrName, "center" );
 678             break;
 679         case 2:
 680             addAttribute( rAttrName, "right" );
 681             break;
 682         default:
 683             SAL_WARN( "xmlscript.xmldlg", "### illegal alignment value!" );
 684             break;
 685         }
 686     }
 687     else
 688         OSL_FAIL( "### unexpected property type!" );
 689 }
 690
 691 void ElementDescriptor::readVerticalAlignAttr( OUString const & rPropName, OUString const & rAttrName )
 692 {
 693     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 694         return;
 695
 696     Any a( _xProps->getPropertyValue( rPropName ) );
 697     if (a.getValueTypeClass() == TypeClass_ENUM && a.getValueType() == cppu::UnoType<style::VerticalAlignment>::get())
 698     {
 699         style::VerticalAlignment eAlign;
 700         a >>= eAlign;
 701         switch (eAlign)
 702         {
 703         case style::VerticalAlignment_TOP:
 704             addAttribute( rAttrName, "top" );
 705             break;
 706         case style::VerticalAlignment_MIDDLE:
 707             addAttribute( rAttrName, "center" );
 708             break;
 709         case style::VerticalAlignment_BOTTOM:
 710             addAttribute( rAttrName, "bottom" );
 711             break;
 712         default:
 713             SAL_WARN( "xmlscript.xmldlg", "### illegal vertical alignment value!" );
 714             break;
 715         }
 716     }
 717     else
 718         OSL_FAIL( "### unexpected property type!" );
 719 }
 720
 721 void ElementDescriptor::readImageOrGraphicAttr(OUString const & rAttrName)
 722 {
 723     OUString sURL;
 724     if (beans::PropertyState_DEFAULT_VALUE != _xPropState->getPropertyState("Graphic"))
 725     {
 726         uno::Reference<graphic::XGraphic> xGraphic;
 727         _xProps->getPropertyValue("Graphic") >>= xGraphic;
 728         if (xGraphic.is())
 729         {
 730             Reference< document::XStorageBasedDocument > xDocStorage( _xDocument, UNO_QUERY );
 731             if ( xDocStorage.is() )
 732             {
 733                 Reference<XComponentContext> xContext = ::comphelper::getProcessComponentContext();
 734                 uno::Reference<document::XGraphicStorageHandler> xGraphicStorageHandler;
 735                 xGraphicStorageHandler.set(document::GraphicStorageHandler::createWithStorage(xContext, xDocStorage->getDocumentStorage()));
 736                 if (xGraphicStorageHandler.is())
 737                 {
 738                     sURL = xGraphicStorageHandler->saveGraphic(xGraphic);
 739                 }
 740             }
 741         }
 742     }
 743     // tdf#130793 Above fails if the dialog is not part of a document. Export the ImageURL then.
 744     if (sURL.isEmpty()
 745         && beans::PropertyState_DEFAULT_VALUE != _xPropState->getPropertyState("ImageURL"))
 746     {
 747         _xProps->getPropertyValue("ImageURL") >>= sURL;
 748     }
 749     if (!sURL.isEmpty())
 750         addAttribute(rAttrName, sURL);
 751 }
 752
 753 void ElementDescriptor::readImageAlignAttr( OUString const & rPropName, OUString const & rAttrName )
 754 {
 755     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 756         return;
 757
 758     Any a( _xProps->getPropertyValue( rPropName ) );
 759     if (auto n = o3tl::tryAccess<sal_Int16>(a))
 760     {
 761         switch (*n)
 762         {
 763         case 0:
 764             addAttribute( rAttrName, "left" );
 765             break;
 766         case 1:
 767             addAttribute( rAttrName, "top" );
 768             break;
 769         case 2:
 770             addAttribute( rAttrName, "right" );
 771             break;
 772         case 3:
 773             addAttribute( rAttrName, "bottom" );
 774             break;
 775         default:
 776             SAL_WARN( "xmlscript.xmldlg", "### illegal image alignment value!" );
 777             break;
 778         }
 779     }
 780     else
 781         OSL_FAIL( "### unexpected property type!" );
 782 }
 783
 784 void ElementDescriptor::readImagePositionAttr( OUString const & rPropName, OUString const & rAttrName )
 785 {
 786     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 787         return;
 788
 789     Any a( _xProps->getPropertyValue( rPropName ) );
 790     auto n = o3tl::tryAccess<sal_Int16>(a);
 791     if (!n)
 792         return;
 793
 794     switch (*n)
 795     {
 796     case awt::ImagePosition::LeftTop:
 797         addAttribute( rAttrName, "left-top" );
 798         break;
 799     case awt::ImagePosition::LeftCenter:
 800         addAttribute( rAttrName, "left-center" );
 801         break;
 802     case awt::ImagePosition::LeftBottom:
 803         addAttribute( rAttrName, "left-bottom" );
 804         break;
 805     case awt::ImagePosition::RightTop:
 806         addAttribute( rAttrName, "right-top" );
 807         break;
 808     case awt::ImagePosition::RightCenter:
 809         addAttribute( rAttrName, "right-center" );
 810         break;
 811     case awt::ImagePosition::RightBottom:
 812         addAttribute( rAttrName, "right-bottom" );
 813         break;
 814     case awt::ImagePosition::AboveLeft:
 815         addAttribute( rAttrName, "top-left" );
 816         break;
 817     case awt::ImagePosition::AboveCenter:
 818         addAttribute( rAttrName, "top-center" );
 819         break;
 820     case awt::ImagePosition::AboveRight:
 821         addAttribute( rAttrName, "top-right" );
 822         break;
 823     case awt::ImagePosition::BelowLeft:
 824         addAttribute( rAttrName, "bottom-left" );
 825         break;
 826     case awt::ImagePosition::BelowCenter:
 827         addAttribute( rAttrName, "bottom-center" );
 828         break;
 829     case awt::ImagePosition::BelowRight:
 830         addAttribute( rAttrName, "bottom-right" );
 831         break;
 832     case awt::ImagePosition::Centered:
 833         addAttribute( rAttrName, "center" );
 834         break;
 835     default:
 836         SAL_WARN( "xmlscript.xmldlg", "### illegal image position value!" );
 837         break;
 838     }
 839 }
 840
 841 void ElementDescriptor::readButtonTypeAttr( OUString const & rPropName, OUString const & rAttrName )
 842 {
 843     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 844         return;
 845
 846     Any a( _xProps->getPropertyValue( rPropName ) );
 847     auto n = o3tl::tryAccess<sal_Int16>(a);
 848     if (!n)
 849         return;
 850
 851     switch (static_cast<awt::PushButtonType>(*n))
 852     {
 853     case awt::PushButtonType_STANDARD:
 854         addAttribute( rAttrName, "standard" );
 855         break;
 856     case awt::PushButtonType_OK:
 857         addAttribute( rAttrName, "ok" );
 858         break;
 859     case awt::PushButtonType_CANCEL:
 860         addAttribute( rAttrName, "cancel" );
 861         break;
 862     case awt::PushButtonType_HELP:
 863         addAttribute( rAttrName, "help" );
 864         break;
 865     default:
 866         SAL_WARN( "xmlscript.xmldlg", "### illegal button-type value!" );
 867         break;
 868     }
 869 }
 870
 871 void ElementDescriptor::readOrientationAttr( OUString const & rPropName, OUString const & rAttrName )
 872 {
 873     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 874         return;
 875
 876     Any a( _xProps->getPropertyValue( rPropName ) );
 877     auto n = o3tl::tryAccess<sal_Int32>(a);
 878     if (!n)
 879         return;
 880
 881     switch (*n)
 882     {
 883     case 0:
 884         addAttribute( rAttrName, "horizontal" );
 885         break;
 886     case 1:
 887         addAttribute( rAttrName, "vertical" );
 888         break;
 889     default:
 890         SAL_WARN( "xmlscript.xmldlg", "### illegal orientation value!" );
 891         break;
 892     }
 893 }
 894
 895 void ElementDescriptor::readLineEndFormatAttr( OUString const & rPropName, OUString const & rAttrName )
 896 {
 897     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 898         return;
 899
 900     Any a( _xProps->getPropertyValue( rPropName ) );
 901     auto n = o3tl::tryAccess<sal_Int16>(a);
 902     if (!n)
 903         return;
 904
 905     switch (*n)
 906     {
 907     case awt::LineEndFormat::CARRIAGE_RETURN:
 908         addAttribute( rAttrName, "carriage-return" );
 909         break;
 910     case awt::LineEndFormat::LINE_FEED:
 911         addAttribute( rAttrName, "line-feed" );
 912         break;
 913     case awt::LineEndFormat::CARRIAGE_RETURN_LINE_FEED:
 914         addAttribute( rAttrName, "carriage-return-line-feed" );
 915         break;
 916     default:
 917         SAL_WARN( "xmlscript.xmldlg", "### illegal line end format value!" );
 918         break;
 919     }
 920 }
 921
 922 void ElementDescriptor::readDataAwareAttr( OUString const & rAttrName )
 923 {
 924     Reference< lang::XMultiServiceFactory > xFac;
 925     if ( _xDocument.is() )
 926         xFac.set( _xDocument, uno::UNO_QUERY );
 927
 928     Reference< form::binding::XBindableValue > xBinding( _xProps, UNO_QUERY );
 929
 930     if ( xFac.is() && xBinding.is() && rAttrName == XMLNS_DIALOGS_PREFIX ":linked-cell" )
 931     {
 932         try
 933         {
 934             Reference< beans::XPropertySet > xConvertor( xFac->createInstance( "com.sun.star.table.CellAddressConversion" ), uno::UNO_QUERY );
 935             Reference< beans::XPropertySet > xBindable( xBinding->getValueBinding(), UNO_QUERY );
 936             if ( xBindable.is() )
 937             {
 938                 table::CellAddress aAddress;
 939                 xBindable->getPropertyValue( "BoundCell" ) >>= aAddress;
 940                 xConvertor->setPropertyValue( "Address", Any( aAddress ) );
 941                 OUString sAddress;
 942                 xConvertor->getPropertyValue( "PersistentRepresentation" ) >>= sAddress;
 943                 if ( !sAddress.isEmpty() )
 944                     addAttribute( rAttrName, sAddress );
 945
 946                 SAL_INFO("xmlscript.xmldlg", "*** Bindable value " << sAddress );
 947
 948             }
 949         }
 950         catch( uno::Exception& )
 951         {
 952         }
 953     }
 954     Reference< form::binding::XListEntrySink > xEntrySink( _xProps, UNO_QUERY );
 955     if ( !(xEntrySink.is() && rAttrName == XMLNS_DIALOGS_PREFIX ":source-cell-range") )
 956         return;
 957
 958     Reference< beans::XPropertySet > xListSource( xEntrySink->getListEntrySource(), UNO_QUERY );
 959     if ( !xListSource.is() )
 960         return;
 961
 962     try
 963     {
 964         Reference< beans::XPropertySet > xConvertor( xFac->createInstance( "com.sun.star.table.CellRangeAddressConversion" ), uno::UNO_QUERY );
 965
 966         table::CellRangeAddress aAddress;
 967         xListSource->getPropertyValue( "CellRange" ) >>= aAddress;
 968
 969         OUString sAddress;
 970         xConvertor->setPropertyValue( "Address", Any( aAddress ) );
 971         xConvertor->getPropertyValue( "PersistentRepresentation" ) >>= sAddress;
 972         SAL_INFO("xmlscript.xmldlg","**** cell range source list " << sAddress );
 973         if ( !sAddress.isEmpty() )
 974             addAttribute( rAttrName, sAddress );
 975     }
 976     catch( uno::Exception& )
 977     {
 978     }
 979 }
 980
 981 void ElementDescriptor::readSelectionTypeAttr( OUString const & rPropName, OUString const & rAttrName )
 982 {
 983     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
 984         return;
 985
 986     Any aSelectionType ( _xProps->getPropertyValue( rPropName ) );
 987
 988     if (aSelectionType.getValueTypeClass() != TypeClass_ENUM ||
 989         aSelectionType.getValueType() != cppu::UnoType<view::SelectionType>::get())
 990         return;
 991
 992     ::view::SelectionType eSelectionType;
 993     aSelectionType >>= eSelectionType;
 994
 995     switch (eSelectionType)
 996     {
 997         case ::view::SelectionType_NONE:
 998             addAttribute( rAttrName, "none" );
 999             break;
1000         case ::view::SelectionType_SINGLE:
1001             addAttribute( rAttrName, "single" );
1002             break;
1003         case ::view::SelectionType_MULTI:
1004             addAttribute( rAttrName, "multi" );
1005             break;
1006         case ::view::SelectionType_RANGE:
1007             addAttribute( rAttrName, "range" );
1008             break;
1009         default:
1010             SAL_WARN( "xmlscript.xmldlg", "### illegal selection type value!" );
1011             break;
1012     }
1013 }
1014
1015 void ElementDescriptor::readScrollableSettings()
1016 {
1017     readLongAttr( "ScrollHeight",
1018                   XMLNS_DIALOGS_PREFIX ":scrollheight" );
1019     readLongAttr( "ScrollWidth",
1020                   XMLNS_DIALOGS_PREFIX ":scrollwidth" );
1021     readLongAttr( "ScrollTop",
1022                   XMLNS_DIALOGS_PREFIX ":scrolltop" );
1023     readLongAttr( "ScrollLeft",
1024                   XMLNS_DIALOGS_PREFIX ":scrollleft" );
1025     readBoolAttr( "HScroll",
1026                   XMLNS_DIALOGS_PREFIX ":hscroll" );
1027     readBoolAttr( "VScroll",
1028                   XMLNS_DIALOGS_PREFIX ":vscroll" );
1029 }
1030
1031 void ElementDescriptor::readImageScaleModeAttr( OUString const & rPropName, OUString const & rAttrName )
1032 {
1033     if (beans::PropertyState_DEFAULT_VALUE == _xPropState->getPropertyState( rPropName ))
1034         return;
1035
1036     Any aImageScaleMode( _xProps->getPropertyValue( rPropName ) );
1037
1038     if (aImageScaleMode.getValueTypeClass() != TypeClass_SHORT)
1039         return;
1040
1041     sal_Int16 nImageScaleMode = 0;
1042     aImageScaleMode >>= nImageScaleMode;
1043
1044     switch(nImageScaleMode)
1045     {
1046         case ::awt::ImageScaleMode::NONE:
1047             addAttribute( rAttrName, "none" );
1048             break;
1049         case ::awt::ImageScaleMode::ISOTROPIC:
1050             addAttribute( rAttrName, "isotropic" );
1051             break;
1052         case ::awt::ImageScaleMode::ANISOTROPIC:
1053             addAttribute( rAttrName, "anisotropic" );
1054             break;
1055         default:
1056             OSL_ENSURE( false, "### illegal image scale mode value.");
1057             break;
1058     }
1059 }
1060
1061 void ElementDescriptor::readDefaults( bool supportPrintable, bool supportVisible )
1062 {
1063     Any a( _xProps->getPropertyValue( "Name" ) );
1064
1065     // The following is a hack to allow 'form' controls to override the default
1066     // control supported by dialogs. This should work well for both VBA support and
1067     // normal LibreOffice (when normal 'Dialogs' decide to support form control models)
1068     // In the future VBA support might require custom models ( and not the just the form
1069     // variant of a control that we currently use ) In this case the door is still open,
1070     // we just need to define a new way for the 'ServiceName' to be extracted from the
1071     // incoming model. E.g. the use of supporting service
1072     // "com.sun.star.form.FormComponent", 'ServiceName' and XPersistObject
1073     // is only an implementation detail here, in the future some other
1074     // method (perhaps a custom prop) could be used instead.
1075     Reference< lang::XServiceInfo > xSrvInfo( _xProps, UNO_QUERY );
1076     if ( xSrvInfo.is() && xSrvInfo->supportsService( "com.sun.star.form.FormComponent" ) )
1077     {
1078         Reference< io::XPersistObject > xPersist( _xProps, UNO_QUERY );
1079         if ( xPersist.is() )
1080         {
1081             OUString sCtrlName = xPersist->getServiceName();
1082             if ( !sCtrlName.isEmpty() )
1083                     addAttribute( XMLNS_DIALOGS_PREFIX ":control-implementation", sCtrlName );
1084         }
1085     }
1086     addAttribute( XMLNS_DIALOGS_PREFIX ":id", *o3tl::doAccess<OUString>(a) );
1087     readShortAttr( "TabIndex", XMLNS_DIALOGS_PREFIX ":tab-index" );
1088
1089     bool bEnabled = false;
1090     if (_xProps->getPropertyValue( "Enabled" ) >>= bEnabled)
1091     {
1092         if (! bEnabled)
1093         {
1094             addAttribute( XMLNS_DIALOGS_PREFIX ":disabled", "true" );
1095         }
1096     }
1097     else
1098     {
1099         SAL_WARN( "xmlscript.xmldlg", "unexpected property type for \"Enabled\": not bool!" );
1100     }
1101
1102     if (supportVisible) try
1103     {
1104         bool bVisible = true;
1105         if (_xProps->getPropertyValue("EnableVisible" ) >>= bVisible)
1106         {
1107
1108             // only write out the non default case
1109             if (! bVisible)
1110             {
1111                 addAttribute( XMLNS_DIALOGS_PREFIX ":visible", "false" );
1112             }
1113         }
1114     }
1115     catch( Exception& )
1116     {
1117         DBG_UNHANDLED_EXCEPTION("xmlscript.xmldlg");
1118     }
1119     // force writing of pos/size
1120     a = _xProps->getPropertyValue( "PositionX" );
1121     if (auto n = o3tl::tryAccess<sal_Int32>(a))
1122     {
1123         addAttribute( XMLNS_DIALOGS_PREFIX ":left", OUString::number(*n) );
1124     }
1125     a = _xProps->getPropertyValue( "PositionY" );
1126     if (auto n = o3tl::tryAccess<sal_Int32>(a))
1127     {
1128         addAttribute( XMLNS_DIALOGS_PREFIX ":top", OUString::number(*n) );
1129     }
1130     a = _xProps->getPropertyValue( "Width" );
1131     if (auto n = o3tl::tryAccess<sal_Int32>(a))
1132     {
1133         addAttribute( XMLNS_DIALOGS_PREFIX ":width", OUString::number(*n) );
1134     }
1135     a = _xProps->getPropertyValue( "Height" );
1136     if (auto n = o3tl::tryAccess<sal_Int32>(a))
1137     {
1138         addAttribute( XMLNS_DIALOGS_PREFIX ":height", OUString::number(*n) );
1139     }
1140
1141     if (supportPrintable)
1142     {
1143         readBoolAttr( "Printable", XMLNS_DIALOGS_PREFIX ":printable" );
1144     }
1145     readLongAttr( "Step", XMLNS_DIALOGS_PREFIX ":page" );
1146     readStringAttr( "Tag", XMLNS_DIALOGS_PREFIX ":tag" );
1147     readStringAttr( "HelpText", XMLNS_DIALOGS_PREFIX ":help-text" );
1148     readStringAttr( "HelpURL", XMLNS_DIALOGS_PREFIX ":help-url" );
1149 }
1150
1151 void ElementDescriptor::readEvents()
1152 {
1153     Reference< script::XScriptEventsSupplier > xSupplier( _xProps, UNO_QUERY );
1154     if (!xSupplier.is())
1155         return;
1156
1157     Reference< container::XNameContainer > xEvents( xSupplier->getEvents() );
1158     if (!xEvents.is())
1159         return;
1160
1161     const Sequence< OUString > aNames( xEvents->getElementNames() );
1162     for ( const auto& rName : aNames )
1163     {
1164         script::ScriptEventDescriptor descr;
1165         if (xEvents->getByName( rName ) >>= descr)
1166         {
1167             SAL_WARN_IF( descr.ListenerType.isEmpty() ||
1168                         descr.EventMethod.isEmpty() ||
1169                         descr.ScriptCode.isEmpty() ||
1170                         descr.ScriptType.isEmpty() , "xmlscript.xmldlg", "### invalid event descr!" );
1171
1172             OUString aEventName;
1173
1174             if (descr.AddListenerParam.isEmpty())
1175             {
1176                 // detection of event-name
1177                 StringTriple const * p = g_pEventTranslations;
1178                 while (p->first)
1179                 {
1180                     if (descr.EventMethod.equalsAscii(p->second) &&
1181                         descr.ListenerType.equalsAscii(p->first))
1182                     {
1183                         aEventName = OStringToOUString( p->third, RTL_TEXTENCODING_ASCII_US );
1184                         break;
1185                     }
1186                     ++p;
1187                 }
1188             }
1189
1190             rtl::Reference<ElementDescriptor> pElem;
1191
1192             if (!aEventName.isEmpty()) // script:event
1193             {
1194                 pElem = new ElementDescriptor( XMLNS_SCRIPT_PREFIX ":event" );
1195                 pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":event-name", aEventName );
1196             }
1197             else // script:listener-event
1198             {
1199                 pElem = new ElementDescriptor( XMLNS_SCRIPT_PREFIX ":listener-event" );
1200                 pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":listener-type", descr.ListenerType );
1201                 pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":listener-method", descr.EventMethod );
1202
1203                 if (!descr.AddListenerParam.isEmpty())
1204                 {
1205                     pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":listener-param", descr.AddListenerParam );
1206                 }
1207             }
1208             if ( descr.ScriptType == "StarBasic" )
1209             {
1210                 // separate optional location
1211                 sal_Int32 nIndex = descr.ScriptCode.indexOf( ':' );
1212                 if (nIndex >= 0)
1213                 {
1214                     pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":location", descr.ScriptCode.copy( 0, nIndex ) );
1215                     pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":macro-name", descr.ScriptCode.copy( nIndex +1 ) );
1216                 }
1217                 else
1218                 {
1219                     pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":macro-name", descr.ScriptCode );
1220                 }
1221             }
1222             else
1223             {
1224                 pElem->addAttribute(XMLNS_SCRIPT_PREFIX ":macro-name", descr.ScriptCode );
1225             }
1226
1227             // language
1228             pElem->addAttribute( XMLNS_SCRIPT_PREFIX ":language", descr.ScriptType );
1229
1230             addSubElement( pElem );
1231         }
1232         else
1233         {
1234             SAL_WARN( "xmlscript.xmldlg", "### unexpected event type in container!" );
1235         }
1236     }
1237 }
1238
1239 static bool equalFont( Style const & style1, Style const & style2 )
1240 {
1241     awt::FontDescriptor const & f1 = style1._descr;
1242     awt::FontDescriptor const & f2 = style2._descr;
1243     return (
1244         f1.Name == f2.Name &&
1245         f1.Height == f2.Height &&
1246         f1.Width == f2.Width &&
1247         f1.StyleName == f2.StyleName &&
1248         f1.Family == f2.Family &&
1249         f1.CharSet == f2.CharSet &&
1250         f1.Pitch == f2.Pitch &&
1251         f1.CharacterWidth == f2.CharacterWidth &&
1252         f1.Weight == f2.Weight &&
1253         f1.Slant == f2.Slant &&
1254         f1.Underline == f2.Underline &&
1255         f1.Strikeout == f2.Strikeout &&
1256         f1.Orientation == f2.Orientation &&
1257         bool(f1.Kerning) == bool(f2.Kerning) &&
1258         bool(f1.WordLineMode) == bool(f2.WordLineMode) &&
1259         f1.Type == f2.Type &&
1260         style1._fontRelief == style2._fontRelief &&
1261         style1._fontEmphasisMark == style2._fontEmphasisMark
1262         );
1263 }
1264
1265 OUString StyleBag::getStyleId( Style const & rStyle )
1266 {
1267     if (! rStyle._set) // nothing set
1268     {
1269         return OUString(); // everything default: no need to export a specific style
1270     }
1271
1272     // lookup existing style
1273     for (auto & rExistingStyle : _styles)
1274     {
1275         short demanded_defaults = ~rStyle._set & rStyle._all;
1276         // test, if defaults are not set
1277         if ((~rExistingStyle._set & demanded_defaults) == demanded_defaults &&
1278             (rStyle._set & (rExistingStyle._all & ~rExistingStyle._set)) == 0)
1279         {
1280             short bset = rStyle._set & rExistingStyle._set;
1281             if ((bset & 0x1) &&
1282                 rStyle._backgroundColor != rExistingStyle._backgroundColor)
1283                 continue;
1284             if ((bset & 0x2) &&
1285                 rStyle._textColor != rExistingStyle._textColor)
1286                 continue;
1287             if ((bset & 0x20) &&
1288                 rStyle._textLineColor != rExistingStyle._textLineColor)
1289                 continue;
1290             if ((bset & 0x10) &&
1291                 rStyle._fillColor != rExistingStyle._fillColor)
1292                 continue;
1293             if ((bset & 0x4) &&
1294                 (rStyle._border != rExistingStyle._border ||
1295                  (rStyle._border == BORDER_SIMPLE_COLOR &&
1296                   rStyle._borderColor != rExistingStyle._borderColor)))
1297                 continue;
1298             if ((bset & 0x8) &&
1299                 !equalFont( rStyle, rExistingStyle ))
1300                 continue;
1301             if ((bset & 0x40) &&
1302                 rStyle._visualEffect != rExistingStyle._visualEffect)
1303                 continue;
1304
1305             // merge in
1306             short bnset = rStyle._set & ~rExistingStyle._set;
1307             if (bnset & 0x1)
1308                 rExistingStyle._backgroundColor = rStyle._backgroundColor;
1309             if (bnset & 0x2)
1310                 rExistingStyle._textColor = rStyle._textColor;
1311             if (bnset & 0x20)
1312                 rExistingStyle._textLineColor = rStyle._textLineColor;
1313             if (bnset & 0x10)
1314                 rExistingStyle._fillColor = rStyle._fillColor;
1315             if (bnset & 0x4) {
1316                 rExistingStyle._border = rStyle._border;
1317                 rExistingStyle._borderColor = rStyle._borderColor;
1318             }
1319             if (bnset & 0x8) {
1320                 rExistingStyle._descr = rStyle._descr;
1321                 rExistingStyle._fontRelief = rStyle._fontRelief;
1322                 rExistingStyle._fontEmphasisMark = rStyle._fontEmphasisMark;
1323             }
1324             if (bnset & 0x40)
1325                 rExistingStyle._visualEffect = rStyle._visualEffect;
1326
1327             rExistingStyle._all |= rStyle._all;
1328             rExistingStyle._set |= rStyle._set;
1329
1330             return rExistingStyle._id;
1331         }
1332     }
1333
1334     // no appr style found, append new
1335     Style aNewStyle( rStyle );
1336     aNewStyle._id = OUString::number( _styles.size() );
1337     _styles.push_back( aNewStyle );
1338     return _styles.back()._id;
1339 }
1340
1341 StyleBag::~StyleBag()
1342 {
1343 }
1344
1345 void StyleBag::dump( Reference< xml::sax::XExtendedDocumentHandler > const & xOut )
1346 {
1347     if ( _styles.empty())
1348         return;
1349
1350     OUString aStylesName( XMLNS_DIALOGS_PREFIX ":styles" );
1351     xOut->ignorableWhitespace( OUString() );
1352     xOut->startElement( aStylesName, Reference< xml::sax::XAttributeList >() );
1353     // export styles
1354     for (auto & _style : _styles)
1355     {
1356         Reference< xml::sax::XAttributeList > xAttr( _style.createElement() );
1357         static_cast< ElementDescriptor * >( xAttr.get() )->dump( xOut );
1358     }
1359     xOut->ignorableWhitespace( OUString() );
1360     xOut->endElement( aStylesName );
1361 }
1362
1363 void exportDialogModel(
1364     Reference< xml::sax::XExtendedDocumentHandler > const & xOut,
1365     Reference< container::XNameContainer > const & xDialogModel,
1366     Reference< frame::XModel > const & xDocument )
1367 {
1368     StyleBag all_styles;
1369     // window
1370     Reference< beans::XPropertySet > xProps( xDialogModel, UNO_QUERY );
1371     OSL_ASSERT( xProps.is() );
1372     Reference< beans::XPropertyState > xPropState( xProps, UNO_QUERY );
1373     OSL_ASSERT( xPropState.is() );
1374
1375     rtl::Reference<ElementDescriptor> pElem = new ElementDescriptor( xProps, xPropState, XMLNS_DIALOGS_PREFIX ":bulletinboard", xDocument );
1376     pElem->readBullitinBoard( &all_styles );
1377
1378     xOut->startDocument();
1379
1380     xOut->unknown(
1381         "<!DOCTYPE dlg:window PUBLIC \"-//OpenOffice.org//DTD OfficeDocument 1.0//EN\""
1382         " \"dialog.dtd\">" );
1383     xOut->ignorableWhitespace( OUString() );
1384
1385     OUString aWindowName( XMLNS_DIALOGS_PREFIX ":window" );
1386     rtl::Reference<ElementDescriptor> pWindow = new ElementDescriptor( xProps, xPropState, aWindowName, xDocument );
1387     pWindow->readDialogModel( &all_styles );
1388     xOut->ignorableWhitespace( OUString() );
1389     xOut->startElement( aWindowName, pWindow );
1390      // dump out events
1391     pWindow->dumpSubElements( xOut );
1392     // dump out stylebag
1393     all_styles.dump( xOut );
1394
1395     if ( xDialogModel->getElementNames().hasElements() )
1396     {
1397         // open up bulletinboard
1398         OUString aBBoardName( XMLNS_DIALOGS_PREFIX ":bulletinboard" );
1399         xOut->ignorableWhitespace( OUString() );
1400         xOut->startElement( aBBoardName, pElem );
1401
1402         pElem->dumpSubElements( xOut );
1403         // end bulletinboard
1404         xOut->ignorableWhitespace( OUString() );
1405         xOut->endElement( aBBoardName );
1406     }
1407
1408     // end window
1409     xOut->ignorableWhitespace( OUString() );
1410     xOut->endElement( aWindowName );
1411
1412     xOut->endDocument();
1413 }
1414
1415 }
1416
1417 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */