framework/source/fwe/xml/toolboxdocumenthandler.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 <xml/toolboxdocumenthandler.hxx>
  21 #include <xml/toolboxconfigurationdefines.hxx>
  22
  23 #include <com/sun/star/xml/sax/SAXException.hpp>
  24 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  25 #include <com/sun/star/ui/ItemType.hpp>
  26 #include <com/sun/star/ui/ItemStyle.hpp>
  27 #include <com/sun/star/beans/XPropertySet.hpp>
  28 #include <com/sun/star/container/XIndexAccess.hpp>
  29 #include <com/sun/star/container/XIndexContainer.hpp>
  30
  31 #include <sal/config.h>
  32 #include <sal/macros.h>
  33 #include <vcl/settings.hxx>
  34 #include <rtl/ref.hxx>
  35 #include <rtl/ustrbuf.hxx>
  36
  37 #include <comphelper/propertysequence.hxx>
  38 #include <comphelper/propertyvalue.hxx>
  39
  40 using namespace ::com::sun::star::uno;
  41 using namespace ::com::sun::star::beans;
  42 using namespace ::com::sun::star::container;
  43 using namespace ::com::sun::star::xml::sax;
  44
  45 constexpr OUStringLiteral TOOLBAR_DOCTYPE = u"<!DOCTYPE toolbar:toolbar PUBLIC \"-//OpenOffice.org//DTD OfficeDocument 1.0//EN\" \"toolbar.dtd\">";
  46
  47 namespace framework
  48 {
  49
  50 // Property names of a menu/menu item ItemDescriptor
  51 constexpr OUString ITEM_DESCRIPTOR_COMMANDURL = u"CommandURL"_ustr;
  52 constexpr OUString ITEM_DESCRIPTOR_LABEL = u"Label"_ustr;
  53 constexpr OUString ITEM_DESCRIPTOR_TYPE = u"Type"_ustr;
  54 constexpr OUString ITEM_DESCRIPTOR_STYLE = u"Style"_ustr;
  55 constexpr OUString ITEM_DESCRIPTOR_VISIBLE = u"IsVisible"_ustr;
  56
  57 static void ExtractToolbarParameters( const Sequence< PropertyValue >& rProp,
  58                                       OUString&                        rCommandURL,
  59                                       OUString&                        rLabel,
  60                                       sal_Int16&                       rStyle,
  61                                       bool&                            rVisible,
  62                                       sal_Int16&                       rType )
  63 {
  64     for ( const PropertyValue& rEntry : rProp )
  65     {
  66         if ( rEntry.Name == ITEM_DESCRIPTOR_COMMANDURL )
  67             rEntry.Value >>= rCommandURL;
  68         else if ( rEntry.Name == ITEM_DESCRIPTOR_LABEL )
  69             rEntry.Value >>= rLabel;
  70         else if ( rEntry.Name == ITEM_DESCRIPTOR_TYPE )
  71             rEntry.Value >>= rType;
  72         else if ( rEntry.Name == ITEM_DESCRIPTOR_VISIBLE )
  73             rEntry.Value >>= rVisible;
  74         else if ( rEntry.Name == ITEM_DESCRIPTOR_STYLE )
  75             rEntry.Value >>= rStyle;
  76     }
  77 }
  78
  79 namespace {
  80
  81 struct ToolboxStyleItem
  82 {
  83     sal_Int16 nBit;
  84     OUString attrName;
  85 };
  86
  87 }
  88
  89 constexpr ToolboxStyleItem Styles[ ] = {
  90     { css::ui::ItemStyle::RADIO_CHECK,   ATTRIBUTE_ITEMSTYLE_RADIO },
  91     { css::ui::ItemStyle::ALIGN_LEFT,    ATTRIBUTE_ITEMSTYLE_LEFT },
  92     { css::ui::ItemStyle::AUTO_SIZE,     ATTRIBUTE_ITEMSTYLE_AUTO },
  93     { css::ui::ItemStyle::REPEAT,        ATTRIBUTE_ITEMSTYLE_REPEAT },
  94     { css::ui::ItemStyle::DROPDOWN_ONLY, ATTRIBUTE_ITEMSTYLE_DROPDOWNONLY },
  95     { css::ui::ItemStyle::DROP_DOWN,     ATTRIBUTE_ITEMSTYLE_DROPDOWN },
  96     { css::ui::ItemStyle::ICON,          ATTRIBUTE_ITEMSTYLE_IMAGE },
  97     { css::ui::ItemStyle::TEXT,          ATTRIBUTE_ITEMSTYLE_TEXT },
  98 };
  99
 100 sal_Int32 const nStyleItemEntries = SAL_N_ELEMENTS(Styles);
 101
 102 namespace {
 103
 104 struct ToolBarEntryProperty
 105 {
 106     OReadToolBoxDocumentHandler::ToolBox_XML_Namespace  nNamespace;
 107     OUString aEntryName;
 108 };
 109
 110 }
 111
 112 ToolBarEntryProperty constexpr ToolBoxEntries[OReadToolBoxDocumentHandler::TB_XML_ENTRY_COUNT] =
 113 {
 114     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   u"toolbar"_ustr             },
 115     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   u"toolbaritem"_ustr         },
 116     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   u"toolbarspace"_ustr        },
 117     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   u"toolbarbreak"_ustr        },
 118     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   u"toolbarseparator"_ustr    },
 119     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   ATTRIBUTE_TEXT              },
 120     { OReadToolBoxDocumentHandler::TB_NS_XLINK,     ATTRIBUTE_URL               },
 121     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   ATTRIBUTE_VISIBLE           },
 122     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   ATTRIBUTE_ITEMSTYLE         },
 123     { OReadToolBoxDocumentHandler::TB_NS_TOOLBAR,   ATTRIBUTE_UINAME            },
 124 };
 125
 126 OReadToolBoxDocumentHandler::OReadToolBoxDocumentHandler( const Reference< XIndexContainer >& rItemContainer ) :
 127     m_rItemContainer( rItemContainer ),
 128     m_aType( ITEM_DESCRIPTOR_TYPE ),
 129     m_aLabel( ITEM_DESCRIPTOR_LABEL ),
 130     m_aStyle( ITEM_DESCRIPTOR_STYLE ),
 131     m_aIsVisible( ITEM_DESCRIPTOR_VISIBLE ),
 132     m_aCommandURL( ITEM_DESCRIPTOR_COMMANDURL )
 133  {
 134     // create hash map
 135     for ( int i = 0; i < TB_XML_ENTRY_COUNT; i++ )
 136     {
 137         if ( ToolBoxEntries[i].nNamespace == TB_NS_TOOLBAR )
 138         {
 139             OUString temp = XMLNS_TOOLBAR XMLNS_FILTER_SEPARATOR +
 140                 ToolBoxEntries[i].aEntryName;
 141             m_aToolBoxMap.emplace( temp, static_cast<ToolBox_XML_Entry>(i) );
 142         }
 143         else
 144         {
 145             OUString temp = XMLNS_XLINK XMLNS_FILTER_SEPARATOR +
 146                 ToolBoxEntries[i].aEntryName;
 147             m_aToolBoxMap.emplace( temp, static_cast<ToolBox_XML_Entry>(i) );
 148         }
 149     }
 150
 151     m_bToolBarStartFound            = false;
 152     m_bToolBarItemStartFound        = false;
 153     m_bToolBarSpaceStartFound       = false;
 154     m_bToolBarBreakStartFound       = false;
 155     m_bToolBarSeparatorStartFound   = false;
 156 }
 157
 158 OReadToolBoxDocumentHandler::~OReadToolBoxDocumentHandler()
 159 {
 160 }
 161
 162 // XDocumentHandler
 163 void SAL_CALL OReadToolBoxDocumentHandler::startDocument()
 164 {
 165 }
 166
 167 void SAL_CALL OReadToolBoxDocumentHandler::endDocument()
 168 {
 169     if ( m_bToolBarStartFound )
 170     {
 171         OUString aErrorMessage = getErrorLineString() + "No matching start or end element 'toolbar' found!";
 172         throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 173     }
 174 }
 175
 176 void SAL_CALL OReadToolBoxDocumentHandler::startElement(
 177     const OUString& aName, const Reference< XAttributeList > &xAttribs )
 178 {
 179     ToolBoxHashMap::const_iterator pToolBoxEntry = m_aToolBoxMap.find( aName );
 180     if ( pToolBoxEntry == m_aToolBoxMap.end() )
 181         return;
 182
 183     switch ( pToolBoxEntry->second )
 184     {
 185         case TB_ELEMENT_TOOLBAR:
 186         {
 187             if ( m_bToolBarStartFound )
 188             {
 189                 OUString aErrorMessage = getErrorLineString() + "Element 'toolbar:toolbar' cannot be embedded into 'toolbar:toolbar'!";
 190                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 191             }
 192             else
 193             {
 194                 // Check if we have a UI name set in our XML file
 195                 OUString aUIName;
 196                 for ( sal_Int16 n = 0; n < xAttribs->getLength(); n++ )
 197                 {
 198                     pToolBoxEntry = m_aToolBoxMap.find( xAttribs->getNameByIndex( n ) );
 199                     if ( pToolBoxEntry != m_aToolBoxMap.end() )
 200                     {
 201                         switch ( pToolBoxEntry->second )
 202                         {
 203                             case TB_ATTRIBUTE_UINAME:
 204                                 aUIName = xAttribs->getValueByIndex( n );
 205                                 break;
 206                             default:
 207                                 break;
 208                         }
 209                     }
 210                 }
 211                 if ( !aUIName.isEmpty() )
 212                 {
 213                     // Try to set UI name as a container property
 214                     Reference< XPropertySet > xPropSet( m_rItemContainer, UNO_QUERY );
 215                     if ( xPropSet.is() )
 216                     {
 217                         try
 218                         {
 219                             xPropSet->setPropertyValue(u"UIName"_ustr, Any( aUIName ) );
 220                         }
 221                         catch ( const UnknownPropertyException& )
 222                         {
 223                         }
 224                     }
 225
 226                 }
 227             }
 228             m_bToolBarStartFound = true;
 229         }
 230         break;
 231
 232         case TB_ELEMENT_TOOLBARITEM:
 233         {
 234             if ( !m_bToolBarStartFound )
 235             {
 236                 OUString aErrorMessage = getErrorLineString() + "Element 'toolbar:toolbaritem' must be embedded into element 'toolbar:toolbar'!";
 237                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 238             }
 239
 240             if ( m_bToolBarSeparatorStartFound ||
 241                  m_bToolBarBreakStartFound ||
 242                  m_bToolBarSpaceStartFound ||
 243                  m_bToolBarItemStartFound )
 244             {
 245                 OUString aErrorMessage = getErrorLineString() + "Element toolbar:toolbaritem is not a container!";
 246                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 247             }
 248
 249             bool bAttributeURL  = false;
 250
 251             m_bToolBarItemStartFound = true;
 252             OUString        aLabel;
 253             OUString        aCommandURL;
 254             sal_uInt16      nItemBits( 0 );
 255             bool            bVisible( true );
 256
 257             for ( sal_Int16 n = 0; n < xAttribs->getLength(); n++ )
 258             {
 259                 pToolBoxEntry = m_aToolBoxMap.find( xAttribs->getNameByIndex( n ) );
 260                 if ( pToolBoxEntry != m_aToolBoxMap.end() )
 261                 {
 262                     switch ( pToolBoxEntry->second )
 263                     {
 264                         case TB_ATTRIBUTE_TEXT:
 265                         {
 266                             aLabel = xAttribs->getValueByIndex( n );
 267                         }
 268                         break;
 269
 270                         case TB_ATTRIBUTE_URL:
 271                         {
 272                             bAttributeURL   = true;
 273                             aCommandURL     = xAttribs->getValueByIndex( n );
 274                         }
 275                         break;
 276
 277                         case TB_ATTRIBUTE_VISIBLE:
 278                         {
 279                             if ( xAttribs->getValueByIndex( n ) == ATTRIBUTE_BOOLEAN_TRUE )
 280                                 bVisible = true;
 281                             else if ( xAttribs->getValueByIndex( n ) == ATTRIBUTE_BOOLEAN_FALSE )
 282                                 bVisible = false;
 283                             else
 284                             {
 285                                 OUString aErrorMessage = getErrorLineString() + "Attribute toolbar:visible must have value 'true' or 'false'!";
 286                                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 287                             }
 288                         }
 289                         break;
 290
 291                         case TB_ATTRIBUTE_STYLE:
 292                         {
 293                             // read space separated item style list
 294                             OUString aTemp = xAttribs->getValueByIndex( n );
 295                             sal_Int32 nIndex = 0;
 296
 297                             do
 298                             {
 299                                 OUString aToken  = aTemp.getToken( 0, ' ', nIndex );
 300                                 if ( !aToken.isEmpty() )
 301                                 {
 302                                     if ( aToken == ATTRIBUTE_ITEMSTYLE_RADIO )
 303                                         nItemBits |= css::ui::ItemStyle::RADIO_CHECK;
 304                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_LEFT )
 305                                         nItemBits |= css::ui::ItemStyle::ALIGN_LEFT;
 306                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_AUTOSIZE )
 307                                         nItemBits |= css::ui::ItemStyle::AUTO_SIZE;
 308                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_REPEAT )
 309                                         nItemBits |= css::ui::ItemStyle::REPEAT;
 310                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_DROPDOWNONLY )
 311                                         nItemBits |= css::ui::ItemStyle::DROPDOWN_ONLY;
 312                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_DROPDOWN )
 313                                         nItemBits |= css::ui::ItemStyle::DROP_DOWN;
 314                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_TEXT )
 315                                         nItemBits |= css::ui::ItemStyle::TEXT;
 316                                     else if ( aToken == ATTRIBUTE_ITEMSTYLE_IMAGE )
 317                                         nItemBits |= css::ui::ItemStyle::ICON;
 318                                 }
 319                             }
 320                             while ( nIndex >= 0 );
 321                         }
 322                         break;
 323
 324                         default:
 325                         break;
 326                     }
 327                 }
 328             } // for
 329
 330             if ( !bAttributeURL )
 331             {
 332                 OUString aErrorMessage = getErrorLineString() + "Required attribute toolbar:url must have a value!";
 333                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 334             }
 335
 336             if ( !aCommandURL.isEmpty() )
 337             {
 338                 //fix for fdo#39370
 339                 /// check whether RTL interface or not
 340                 if(AllSettings::GetLayoutRTL()){
 341                     if (aCommandURL == ".uno:ParaLeftToRight")
 342                         aCommandURL = ".uno:ParaRightToLeft";
 343                     else if (aCommandURL == ".uno:ParaRightToLeft")
 344                         aCommandURL = ".uno:ParaLeftToRight";
 345                     else if (aCommandURL == ".uno:LeftPara")
 346                         aCommandURL = ".uno:RightPara";
 347                     else if (aCommandURL == ".uno:RightPara")
 348                         aCommandURL = ".uno:LeftPara";
 349                     else if (aCommandURL == ".uno:AlignLeft")
 350                         aCommandURL = ".uno:AlignRight";
 351                     else if (aCommandURL == ".uno:AlignRight")
 352                         aCommandURL = ".uno:AlignLeft";
 353                     else if (aCommandURL == ".uno:WrapLeft")
 354                         aCommandURL = ".uno:WrapRight";
 355                     else if (aCommandURL == ".uno:WrapRight")
 356                         aCommandURL = ".uno:WrapLeft";
 357                 }
 358
 359                 auto aToolbarItemProp( comphelper::InitPropertySequence( {
 360                     { m_aCommandURL, css::uno::Any( aCommandURL ) },
 361                     { m_aLabel, css::uno::Any( aLabel ) },
 362                     { m_aType, css::uno::Any( css::ui::ItemType::DEFAULT ) },
 363                     { m_aStyle, css::uno::Any( nItemBits ) },
 364                     { m_aIsVisible, css::uno::Any( bVisible ) },
 365                 } ) );
 366
 367                 m_rItemContainer->insertByIndex( m_rItemContainer->getCount(), Any( aToolbarItemProp ) );
 368             }
 369         }
 370         break;
 371
 372         case TB_ELEMENT_TOOLBARSPACE:
 373         {
 374             if ( m_bToolBarSeparatorStartFound ||
 375                  m_bToolBarBreakStartFound ||
 376                  m_bToolBarSpaceStartFound ||
 377                  m_bToolBarItemStartFound )
 378             {
 379                 OUString aErrorMessage = getErrorLineString() + "Element toolbar:toolbarspace is not a container!";
 380                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 381             }
 382
 383             m_bToolBarSpaceStartFound = true;
 384
 385             Sequence< PropertyValue > aToolbarItemProp{
 386                 comphelper::makePropertyValue(m_aCommandURL, OUString()),
 387                 comphelper::makePropertyValue(m_aType, css::ui::ItemType::SEPARATOR_SPACE)
 388             };
 389
 390             m_rItemContainer->insertByIndex( m_rItemContainer->getCount(), Any( aToolbarItemProp ) );
 391         }
 392         break;
 393
 394         case TB_ELEMENT_TOOLBARBREAK:
 395         {
 396             if ( m_bToolBarSeparatorStartFound ||
 397                  m_bToolBarBreakStartFound ||
 398                  m_bToolBarSpaceStartFound ||
 399                  m_bToolBarItemStartFound )
 400             {
 401                 OUString aErrorMessage = getErrorLineString() + "Element toolbar:toolbarbreak is not a container!";
 402                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 403             }
 404
 405             m_bToolBarBreakStartFound = true;
 406
 407             Sequence< PropertyValue > aToolbarItemProp{
 408                 comphelper::makePropertyValue(m_aCommandURL, OUString()),
 409                 comphelper::makePropertyValue(m_aType, css::ui::ItemType::SEPARATOR_LINEBREAK)
 410             };
 411
 412             m_rItemContainer->insertByIndex( m_rItemContainer->getCount(), Any( aToolbarItemProp ) );
 413         }
 414         break;
 415
 416         case TB_ELEMENT_TOOLBARSEPARATOR:
 417         {
 418             if ( m_bToolBarSeparatorStartFound ||
 419                  m_bToolBarBreakStartFound ||
 420                  m_bToolBarSpaceStartFound ||
 421                  m_bToolBarItemStartFound )
 422             {
 423                 OUString aErrorMessage = getErrorLineString() + "Element toolbar:toolbarseparator is not a container!";
 424                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 425             }
 426
 427             m_bToolBarSeparatorStartFound = true;
 428
 429             Sequence< PropertyValue > aToolbarItemProp{
 430                 comphelper::makePropertyValue(m_aCommandURL, OUString()),
 431                 comphelper::makePropertyValue(m_aType, css::ui::ItemType::SEPARATOR_LINE)
 432             };
 433
 434             m_rItemContainer->insertByIndex( m_rItemContainer->getCount(), Any( aToolbarItemProp ) );
 435         }
 436         break;
 437
 438               default:
 439                   break;
 440     }
 441 }
 442
 443 void SAL_CALL OReadToolBoxDocumentHandler::endElement(const OUString& aName)
 444 {
 445     ToolBoxHashMap::const_iterator pToolBoxEntry = m_aToolBoxMap.find( aName );
 446     if ( pToolBoxEntry == m_aToolBoxMap.end() )
 447         return;
 448
 449     switch ( pToolBoxEntry->second )
 450     {
 451         case TB_ELEMENT_TOOLBAR:
 452         {
 453             if ( !m_bToolBarStartFound )
 454             {
 455                 OUString aErrorMessage = getErrorLineString() + "End element 'toolbar' found, but no start element 'toolbar'";
 456                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 457             }
 458
 459             m_bToolBarStartFound = false;
 460         }
 461         break;
 462
 463         case TB_ELEMENT_TOOLBARITEM:
 464         {
 465             if ( !m_bToolBarItemStartFound )
 466             {
 467                 OUString aErrorMessage = getErrorLineString() + "End element 'toolbar:toolbaritem' found, but no start element 'toolbar:toolbaritem'";
 468                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 469             }
 470
 471             m_bToolBarItemStartFound = false;
 472         }
 473         break;
 474
 475         case TB_ELEMENT_TOOLBARBREAK:
 476         {
 477             if ( !m_bToolBarBreakStartFound )
 478             {
 479                 OUString aErrorMessage = getErrorLineString() + "End element 'toolbar:toolbarbreak' found, but no start element 'toolbar:toolbarbreak'";
 480                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 481             }
 482
 483             m_bToolBarBreakStartFound = false;
 484         }
 485         break;
 486
 487         case TB_ELEMENT_TOOLBARSPACE:
 488         {
 489             if ( !m_bToolBarSpaceStartFound )
 490             {
 491                 OUString aErrorMessage = getErrorLineString() + "End element 'toolbar:toolbarspace' found, but no start element 'toolbar:toolbarspace'";
 492                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 493             }
 494
 495             m_bToolBarSpaceStartFound = false;
 496         }
 497         break;
 498
 499         case TB_ELEMENT_TOOLBARSEPARATOR:
 500         {
 501             if ( !m_bToolBarSeparatorStartFound )
 502             {
 503                 OUString aErrorMessage = getErrorLineString() + "End element 'toolbar:toolbarseparator' found, but no start element 'toolbar:toolbarseparator'";
 504                 throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 505             }
 506
 507             m_bToolBarSeparatorStartFound = false;
 508         }
 509         break;
 510
 511         default: break;
 512     }
 513 }
 514
 515 void SAL_CALL OReadToolBoxDocumentHandler::characters(const OUString&)
 516 {
 517 }
 518
 519 void SAL_CALL OReadToolBoxDocumentHandler::ignorableWhitespace(const OUString&)
 520 {
 521 }
 522
 523 void SAL_CALL OReadToolBoxDocumentHandler::processingInstruction(
 524     const OUString& /*aTarget*/, const OUString& /*aData*/ )
 525 {
 526 }
 527
 528 void SAL_CALL OReadToolBoxDocumentHandler::setDocumentLocator(
 529     const Reference< XLocator > &xLocator)
 530 {
 531     m_xLocator = xLocator;
 532 }
 533
 534 OUString OReadToolBoxDocumentHandler::getErrorLineString()
 535 {
 536     if ( m_xLocator.is() )
 537         return "Line: " + OUString::number( m_xLocator->getLineNumber() ) + " - ";
 538     else
 539         return OUString();
 540 }
 541
 542 //  OWriteToolBoxDocumentHandler
 543
 544 OWriteToolBoxDocumentHandler::OWriteToolBoxDocumentHandler(
 545     const Reference< XIndexAccess >& rItemAccess,
 546     Reference< XDocumentHandler > const & rWriteDocumentHandler ) :
 547     m_xWriteDocumentHandler( rWriteDocumentHandler ),
 548     m_rItemAccess( rItemAccess )
 549 {
 550     m_xEmptyList = new ::comphelper::AttributeList;
 551     m_aXMLXlinkNS       = XMLNS_XLINK_PREFIX;
 552     m_aXMLToolbarNS     = XMLNS_TOOLBAR_PREFIX;
 553 }
 554
 555 OWriteToolBoxDocumentHandler::~OWriteToolBoxDocumentHandler()
 556 {
 557 }
 558
 559 void OWriteToolBoxDocumentHandler::WriteToolBoxDocument()
 560 {
 561     m_xWriteDocumentHandler->startDocument();
 562
 563     // write DOCTYPE line!
 564     Reference< XExtendedDocumentHandler > xExtendedDocHandler( m_xWriteDocumentHandler, UNO_QUERY );
 565     if ( xExtendedDocHandler.is() )
 566     {
 567         xExtendedDocHandler->unknown( TOOLBAR_DOCTYPE );
 568         m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 569     }
 570
 571     OUString aUIName;
 572     Reference< XPropertySet > xPropSet( m_rItemAccess, UNO_QUERY );
 573     if ( xPropSet.is() )
 574     {
 575         try
 576         {
 577             xPropSet->getPropertyValue(u"UIName"_ustr) >>= aUIName;
 578         }
 579         catch ( const UnknownPropertyException& )
 580         {
 581         }
 582     }
 583
 584     rtl::Reference<::comphelper::AttributeList> pList = new ::comphelper::AttributeList;
 585
 586     pList->AddAttribute( ATTRIBUTE_XMLNS_TOOLBAR,
 587                          u"" XMLNS_TOOLBAR ""_ustr );
 588
 589     pList->AddAttribute( ATTRIBUTE_XMLNS_XLINK,
 590                          u"" XMLNS_XLINK ""_ustr );
 591
 592     if ( !aUIName.isEmpty() )
 593         pList->AddAttribute( m_aXMLToolbarNS + ATTRIBUTE_UINAME,
 594                              aUIName );
 595
 596     m_xWriteDocumentHandler->startElement( ELEMENT_NS_TOOLBAR, pList );
 597     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 598
 599     sal_Int32  nItemCount = m_rItemAccess->getCount();
 600     Any        aAny;
 601
 602     for ( sal_Int32 nItemPos = 0; nItemPos < nItemCount; nItemPos++ )
 603     {
 604         Sequence< PropertyValue > aProps;
 605         aAny = m_rItemAccess->getByIndex( nItemPos );
 606         if ( aAny >>= aProps )
 607         {
 608             OUString    aCommandURL;
 609             OUString    aLabel;
 610             bool    bVisible( true );
 611             sal_Int16   nType( css::ui::ItemType::DEFAULT );
 612             sal_Int16   nStyle( 0 );
 613
 614             ExtractToolbarParameters( aProps, aCommandURL, aLabel, nStyle, bVisible, nType );
 615             if ( nType == css::ui::ItemType::DEFAULT )
 616                 WriteToolBoxItem( aCommandURL, aLabel, nStyle, bVisible );
 617             else if ( nType == css::ui::ItemType::SEPARATOR_SPACE )
 618                 WriteToolBoxSpace();
 619             else if ( nType == css::ui::ItemType::SEPARATOR_LINE )
 620                 WriteToolBoxSeparator();
 621             else if ( nType == css::ui::ItemType::SEPARATOR_LINEBREAK )
 622                 WriteToolBoxBreak();
 623         }
 624     }
 625
 626     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 627     m_xWriteDocumentHandler->endElement( ELEMENT_NS_TOOLBAR );
 628     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 629     m_xWriteDocumentHandler->endDocument();
 630 }
 631
 632 //  protected member functions
 633
 634 void OWriteToolBoxDocumentHandler::WriteToolBoxItem(
 635     const OUString& rCommandURL,
 636     const OUString& rLabel,
 637     sal_Int16       nStyle,
 638     bool        bVisible )
 639 {
 640     rtl::Reference<::comphelper::AttributeList> pList = new ::comphelper::AttributeList;
 641
 642     if ( m_aAttributeURL.isEmpty() )
 643     {
 644         m_aAttributeURL = m_aXMLXlinkNS + ATTRIBUTE_URL;
 645     }
 646
 647     // save required attribute (URL)
 648     pList->AddAttribute( m_aAttributeURL, rCommandURL );
 649
 650     if ( !rLabel.isEmpty() )
 651     {
 652         pList->AddAttribute( m_aXMLToolbarNS + ATTRIBUTE_TEXT,
 653                              rLabel );
 654     }
 655
 656     if ( !bVisible )
 657     {
 658         pList->AddAttribute( m_aXMLToolbarNS + ATTRIBUTE_VISIBLE,
 659                              ATTRIBUTE_BOOLEAN_FALSE );
 660     }
 661
 662     if ( nStyle > 0 )
 663     {
 664         OUStringBuffer aValue;
 665         const ToolboxStyleItem* pStyle = Styles;
 666
 667         for ( sal_Int32 nIndex = 0; nIndex < nStyleItemEntries; ++nIndex, ++pStyle )
 668         {
 669             if ( nStyle & pStyle->nBit )
 670             {
 671                 if ( !aValue.isEmpty() )
 672                     aValue.append(" ");
 673                 aValue.append( pStyle->attrName );
 674             }
 675         }
 676         pList->AddAttribute( m_aXMLToolbarNS + ATTRIBUTE_ITEMSTYLE,
 677                              aValue.makeStringAndClear() );
 678     }
 679
 680     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 681     m_xWriteDocumentHandler->startElement( ELEMENT_NS_TOOLBARITEM, pList );
 682     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 683     m_xWriteDocumentHandler->endElement( ELEMENT_NS_TOOLBARITEM );
 684 }
 685
 686 void OWriteToolBoxDocumentHandler::WriteToolBoxSpace()
 687 {
 688     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 689     m_xWriteDocumentHandler->startElement( ELEMENT_NS_TOOLBARSPACE, m_xEmptyList );
 690     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 691     m_xWriteDocumentHandler->endElement( ELEMENT_NS_TOOLBARSPACE );
 692 }
 693
 694 void OWriteToolBoxDocumentHandler::WriteToolBoxBreak()
 695 {
 696     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 697     m_xWriteDocumentHandler->startElement( ELEMENT_NS_TOOLBARBREAK, m_xEmptyList );
 698     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 699     m_xWriteDocumentHandler->endElement( ELEMENT_NS_TOOLBARBREAK );
 700 }
 701
 702 void OWriteToolBoxDocumentHandler::WriteToolBoxSeparator()
 703 {
 704     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 705     m_xWriteDocumentHandler->startElement( ELEMENT_NS_TOOLBARSEPARATOR, m_xEmptyList );
 706     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 707     m_xWriteDocumentHandler->endElement( ELEMENT_NS_TOOLBARSEPARATOR );
 708 }
 709
 710 } // namespace framework
 711
 712 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */