framework/source/xml/imagesdocumenthandler.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 <stdio.h>
  21
  22 #include <xml/imagesdocumenthandler.hxx>
  23
  24 #include <com/sun/star/xml/sax/XExtendedDocumentHandler.hpp>
  25
  26 #include <vcl/svapp.hxx>
  27 #include <vcl/toolbox.hxx>
  28 #include <rtl/ustrbuf.hxx>
  29
  30 #include <comphelper/attributelist.hxx>
  31
  32 using namespace ::com::sun::star::uno;
  33 using namespace ::com::sun::star::xml::sax;
  34
  35 #define ELEMENT_IMAGECONTAINER      "imagescontainer"
  36 #define ELEMENT_IMAGES              "images"
  37 #define ELEMENT_ENTRY               "entry"
  38 #define ELEMENT_EXTERNALIMAGES      "externalimages"
  39 #define ELEMENT_EXTERNALENTRY       "externalentry"
  40
  41 #define ELEMENT_NS_IMAGESCONTAINER  "image:imagescontainer"
  42 #define ELEMENT_NS_IMAGES           "image:images"
  43 #define ELEMENT_NS_ENTRY            "image:entry"
  44 #define ELEMENT_NS_EXTERNALIMAGES   "image:externalimages"
  45 #define ELEMENT_NS_EXTERNALENTRY    "image:externalentry"
  46
  47 #define ATTRIBUTE_HREF                  "href"
  48 #define ATTRIBUTE_MASKCOLOR             "maskcolor"
  49 #define ATTRIBUTE_COMMAND               "command"
  50 #define ATTRIBUTE_BITMAPINDEX           "bitmap-index"
  51 #define ATTRIBUTE_MASKURL               "maskurl"
  52 #define ATTRIBUTE_MASKMODE              "maskmode"
  53 #define ATTRIBUTE_HIGHCONTRASTURL       "highcontrasturl"
  54 #define ATTRIBUTE_HIGHCONTRASTMASKURL   "highcontrastmaskurl"
  55 #define ATTRIBUTE_TYPE_CDATA            "CDATA"
  56
  57 #define ATTRIBUTE_MASKMODE_BITMAP   "maskbitmap"
  58 #define ATTRIBUTE_MASKMODE_COLOR    "maskcolor"
  59
  60 #define ATTRIBUTE_XMLNS_IMAGE       "xmlns:image"
  61 #define ATTRIBUTE_XMLNS_XLINK       "xmlns:xlink"
  62
  63 #define ATTRIBUTE_XLINK_TYPE        "xlink:type"
  64 #define ATTRIBUTE_XLINK_TYPE_VALUE  "simple"
  65
  66 #define XMLNS_IMAGE                 "http://openoffice.org/2001/image"
  67 #define XMLNS_XLINK                 "http://www.w3.org/1999/xlink"
  68 #define XMLNS_IMAGE_PREFIX          "image:"
  69 #define XMLNS_XLINK_PREFIX          "xlink:"
  70
  71 #define XMLNS_FILTER_SEPARATOR      "^"
  72
  73 #define IMAGES_DOCTYPE  "<!DOCTYPE image:imagecontainer PUBLIC \"-//OpenOffice.org//DTD OfficeDocument 1.0//EN\" \"image.dtd\">"
  74
  75 namespace framework
  76 {
  77
  78 struct ImageXMLEntryProperty
  79 {
  80     OReadImagesDocumentHandler::Image_XML_Namespace nNamespace;
  81     char                                            aEntryName[20];
  82 };
  83
  84 ImageXMLEntryProperty ImagesEntries[OReadImagesDocumentHandler::IMG_XML_ENTRY_COUNT] =
  85 {
  86     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ELEMENT_IMAGECONTAINER          },
  87     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ELEMENT_IMAGES                  },
  88     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ELEMENT_ENTRY                   },
  89     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ELEMENT_EXTERNALIMAGES          },
  90     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ELEMENT_EXTERNALENTRY           },
  91     { OReadImagesDocumentHandler::IMG_NS_XLINK, ATTRIBUTE_HREF                  },
  92     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_MASKCOLOR             },
  93     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_COMMAND               },
  94     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_BITMAPINDEX           },
  95     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_MASKURL               },
  96     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_MASKMODE              },
  97     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_HIGHCONTRASTURL       },
  98     { OReadImagesDocumentHandler::IMG_NS_IMAGE, ATTRIBUTE_HIGHCONTRASTMASKURL   }
  99 };
 100
 101 OReadImagesDocumentHandler::OReadImagesDocumentHandler( ImageListsDescriptor& aItems ) :
 102     m_aImageList( aItems ),
 103     m_pImages( 0 ),
 104     m_pExternalImages( 0 )
 105 {
 106     m_aImageList.pImageList         = NULL;
 107     m_aImageList.pExternalImageList = NULL;
 108
 109     m_nHashMaskModeBitmap   = OUString( ATTRIBUTE_MASKMODE_BITMAP ).hashCode();
 110     m_nHashMaskModeColor    = OUString( ATTRIBUTE_MASKMODE_COLOR ).hashCode();
 111
 112     // create hash map to speed up lookup
 113     for ( int i = 0; i < (int)IMG_XML_ENTRY_COUNT; i++ )
 114     {
 115         OUStringBuffer temp( 20 );
 116
 117         if ( ImagesEntries[i].nNamespace == IMG_NS_IMAGE )
 118             temp.appendAscii( XMLNS_IMAGE );
 119         else
 120             temp.appendAscii( XMLNS_XLINK );
 121
 122         temp.appendAscii( XMLNS_FILTER_SEPARATOR );
 123         temp.appendAscii( ImagesEntries[i].aEntryName );
 124         m_aImageMap.insert( ImageHashMap::value_type( temp.makeStringAndClear(), (Image_XML_Entry)i ) );
 125     }
 126
 127     // reset states
 128     m_bImageContainerStartFound     = false;
 129     m_bImageContainerEndFound       = false;
 130     m_bImagesStartFound             = false;
 131     m_bImagesEndFound               = false;
 132     m_bImageStartFound              = false;
 133     m_bExternalImagesStartFound     = false;
 134     m_bExternalImagesEndFound       = false;
 135     m_bExternalImageStartFound      = false;
 136 }
 137
 138 OReadImagesDocumentHandler::~OReadImagesDocumentHandler()
 139 {
 140 }
 141
 142 // XDocumentHandler
 143 void SAL_CALL OReadImagesDocumentHandler::startDocument()
 144 throw ( SAXException, RuntimeException, std::exception )
 145 {
 146 }
 147
 148 void SAL_CALL OReadImagesDocumentHandler::endDocument()
 149 throw(  SAXException, RuntimeException, std::exception )
 150 {
 151     SolarMutexGuard g;
 152
 153     if (( m_bImageContainerStartFound && !m_bImageContainerEndFound ) ||
 154         ( !m_bImageContainerStartFound && m_bImageContainerEndFound )    )
 155     {
 156         OUString aErrorMessage = getErrorLineString();
 157         aErrorMessage += "No matching start or end element 'image:imagecontainer' found!";
 158         throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 159     }
 160 }
 161
 162 void SAL_CALL OReadImagesDocumentHandler::startElement(
 163     const OUString& aName, const Reference< XAttributeList > &xAttribs )
 164         throw(SAXException,
 165               RuntimeException,
 166               std::exception)
 167 {
 168     SolarMutexGuard g;
 169
 170     ImageHashMap::const_iterator pImageEntry = m_aImageMap.find( aName );
 171     if ( pImageEntry != m_aImageMap.end() )
 172     {
 173         switch ( pImageEntry->second )
 174         {
 175             case IMG_ELEMENT_IMAGECONTAINER:
 176             {
 177                 // image:imagecontainer element (container element for all further image elements)
 178                 if ( m_bImageContainerStartFound )
 179                 {
 180                     OUString aErrorMessage = getErrorLineString();
 181                     aErrorMessage += "Element 'image:imagecontainer' cannot be embedded into 'image:imagecontainer'!";
 182                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 183                 }
 184
 185                 m_bImageContainerStartFound = true;
 186             }
 187             break;
 188
 189             case IMG_ELEMENT_IMAGES:
 190             {
 191                 if ( !m_bImageContainerStartFound )
 192                 {
 193                     OUString aErrorMessage = getErrorLineString();
 194                     aErrorMessage += "Element 'image:images' must be embedded into element 'image:imagecontainer'!";
 195                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 196                 }
 197
 198                 if ( m_bImagesStartFound )
 199                 {
 200                     OUString aErrorMessage = getErrorLineString();
 201                     aErrorMessage += "Element 'image:images' cannot be embedded into 'image:images'!";
 202                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 203                 }
 204
 205                 if ( !m_aImageList.pImageList )
 206                     m_aImageList.pImageList = new ImageListDescriptor;
 207
 208                 m_bImagesStartFound = true;
 209                 m_pImages = new ImageListItemDescriptor;
 210
 211                 for ( sal_Int16 n = 0; n < xAttribs->getLength(); n++ )
 212                 {
 213                     pImageEntry = m_aImageMap.find( xAttribs->getNameByIndex( n ) );
 214                     if ( pImageEntry != m_aImageMap.end() )
 215                     {
 216                         switch ( pImageEntry->second )
 217                         {
 218                             case IMG_ATTRIBUTE_HREF:
 219                             {
 220                                 m_pImages->aURL = xAttribs->getValueByIndex( n );
 221                             }
 222                             break;
 223
 224                             case IMG_ATTRIBUTE_MASKCOLOR:
 225                             {
 226                                 OUString aColor = xAttribs->getValueByIndex( n );
 227
 228                                 if ( aColor.startsWith("#") )
 229                                 {
 230                                     // the color value is given as #rrggbb and used the hexadecimal system!!
 231                                     sal_uInt32 nColor = aColor.copy( 1 ).toUInt32( 16 );
 232
 233                                     m_pImages->aMaskColor = Color( COLORDATA_RGB( nColor ) );
 234                                 }
 235                             }
 236                             break;
 237
 238                             case IMG_ATTRIBUTE_MASKURL:
 239                             {
 240                                 m_pImages->aMaskURL = xAttribs->getValueByIndex( n );
 241                             }
 242                             break;
 243
 244                             case IMG_ATTRIBUTE_MASKMODE:
 245                             {
 246                                 sal_Int32 nHashCode = xAttribs->getValueByIndex( n ).hashCode();
 247                                 if ( nHashCode == m_nHashMaskModeBitmap )
 248                                     m_pImages->nMaskMode = ImageMaskMode_Bitmap;
 249                                 else if ( nHashCode == m_nHashMaskModeColor )
 250                                     m_pImages->nMaskMode = ImageMaskMode_Color;
 251                                 else
 252                                 {
 253                                     delete m_pImages;
 254                                     m_pImages = NULL;
 255
 256                                     OUString aErrorMessage = getErrorLineString();
 257                                     aErrorMessage += "Attribute image:maskmode must be 'maskcolor' or 'maskbitmap'!";
 258                                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 259                                 }
 260                             }
 261                             break;
 262
 263                             case IMG_ATTRIBUTE_HIGHCONTRASTURL:
 264                             {
 265                                 m_pImages->aHighContrastURL = xAttribs->getValueByIndex( n );
 266                             }
 267                             break;
 268
 269                             case IMG_ATTRIBUTE_HIGHCONTRASTMASKURL:
 270                             {
 271                                 m_pImages->aHighContrastMaskURL = xAttribs->getValueByIndex( n );
 272                             }
 273                             break;
 274
 275                                           default:
 276                                               break;
 277                         }
 278                     }
 279                 } // for
 280
 281                 if ( m_pImages->aURL.isEmpty() )
 282                 {
 283                     delete m_pImages;
 284                     m_pImages = NULL;
 285
 286                     OUString aErrorMessage = getErrorLineString();
 287                     aErrorMessage += "Required attribute xlink:href must have a value!";
 288                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 289                 }
 290             }
 291             break;
 292
 293             case IMG_ELEMENT_ENTRY:
 294             {
 295                 // Check that image:entry is embedded into image:images!
 296                 if ( !m_bImagesStartFound )
 297                 {
 298                     delete m_pImages;
 299                     m_pImages = NULL;
 300
 301                     OUString aErrorMessage = getErrorLineString();
 302                     aErrorMessage += "Element 'image:entry' must be embedded into element 'image:images'!";
 303                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 304                 }
 305
 306                 if ( !m_pImages->pImageItemList )
 307                     m_pImages->pImageItemList = new ImageItemListDescriptor;
 308
 309                 m_bImageStartFound = true;
 310
 311                 // Create new image item descriptor
 312                 ImageItemDescriptor* pItem = new ImageItemDescriptor;
 313                 pItem->nIndex = -1;
 314
 315                 // Read attributes for this image definition
 316                 for ( sal_Int16 n = 0; n < xAttribs->getLength(); n++ )
 317                 {
 318                     pImageEntry = m_aImageMap.find( xAttribs->getNameByIndex( n ) );
 319                     if ( pImageEntry != m_aImageMap.end() )
 320                     {
 321                         switch ( pImageEntry->second )
 322                         {
 323                             case IMG_ATTRIBUTE_COMMAND:
 324                             {
 325                                 pItem->aCommandURL  = xAttribs->getValueByIndex( n );
 326                             }
 327                             break;
 328
 329                             case IMG_ATTRIBUTE_BITMAPINDEX:
 330                             {
 331                                 pItem->nIndex       = xAttribs->getValueByIndex( n ).toInt32();
 332                             }
 333                             break;
 334
 335                                           default:
 336                                               break;
 337                         }
 338                     }
 339                 }
 340
 341                 // Check required attribute "bitmap-index"
 342                 if ( pItem->nIndex < 0 )
 343                 {
 344                     delete pItem;
 345                     delete m_pImages;
 346                     m_pImages = NULL;
 347
 348                     OUString aErrorMessage = getErrorLineString();
 349                     aErrorMessage += "Required attribute 'image:bitmap-index' must have a value >= 0!";
 350                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 351                 }
 352
 353                 // Check required attribute "command"
 354                 if ( pItem->aCommandURL.isEmpty() )
 355                 {
 356                     delete pItem;
 357                     delete m_pImages;
 358                     m_pImages = NULL;
 359
 360                     OUString aErrorMessage = getErrorLineString();
 361                     aErrorMessage += "Required attribute 'image:command' must have a value!";
 362                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 363                 }
 364
 365                 m_pImages->pImageItemList->push_back( pItem );
 366             }
 367             break;
 368
 369             case IMG_ELEMENT_EXTERNALIMAGES:
 370             {
 371                 // Check that image:externalimages is embedded into image:imagecontainer
 372                 if ( !m_bImageContainerStartFound )
 373                 {
 374                     delete m_pImages;
 375                     m_pImages = NULL;
 376
 377                     OUString aErrorMessage = getErrorLineString();
 378                     aErrorMessage += "Element 'image:externalimages' must be embedded into element 'image:imagecontainer'!";
 379                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 380                 }
 381
 382                 // Check that image:externalentry is NOT embedded into image:externalentry
 383                 if ( m_bExternalImagesStartFound )
 384                 {
 385                     delete m_pImages;
 386                     m_pImages = NULL;
 387
 388                     OUString aErrorMessage = getErrorLineString();
 389                     aErrorMessage += "Element 'image:externalimages' cannot be embedded into 'image:externalimages'!";
 390                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 391                 }
 392
 393                 // Create unique external image container
 394                 m_bExternalImagesStartFound = true;
 395                 m_pExternalImages = new ExternalImageItemListDescriptor;
 396             }
 397             break;
 398
 399             case IMG_ELEMENT_EXTERNALENTRY:
 400             {
 401                 if ( !m_bExternalImagesStartFound )
 402                 {
 403                     delete m_pImages;
 404                     delete m_pExternalImages;
 405                     m_pImages = NULL;
 406                     m_pExternalImages = NULL;
 407
 408                     OUString aErrorMessage = getErrorLineString();
 409                     aErrorMessage += "Element 'image:externalentry' must be embedded into 'image:externalimages'!";
 410                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 411                 }
 412
 413                 if ( m_bExternalImageStartFound )
 414                 {
 415                     delete m_pImages;
 416                     delete m_pExternalImages;
 417                     m_pImages = NULL;
 418                     m_pExternalImages = NULL;
 419
 420                     OUString aErrorMessage = getErrorLineString();
 421                     aErrorMessage += "Element 'image:externalentry' cannot be embedded into 'image:externalentry'!";
 422                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 423                 }
 424
 425                 m_bExternalImageStartFound = true;
 426
 427                 ExternalImageItemDescriptor* pItem = new ExternalImageItemDescriptor;
 428
 429                 // Read attributes for this external image definition
 430                 for ( sal_Int16 n = 0; n < xAttribs->getLength(); n++ )
 431                 {
 432                     pImageEntry = m_aImageMap.find( xAttribs->getNameByIndex( n ) );
 433                     if ( pImageEntry != m_aImageMap.end() )
 434                     {
 435                         switch ( pImageEntry->second )
 436                         {
 437                             case IMG_ATTRIBUTE_COMMAND:
 438                             {
 439                                 pItem->aCommandURL  = xAttribs->getValueByIndex( n );
 440                             }
 441                             break;
 442
 443                             case IMG_ATTRIBUTE_HREF:
 444                             {
 445                                 pItem->aURL         = xAttribs->getValueByIndex( n );
 446                             }
 447                             break;
 448
 449                                           default:
 450                                               break;
 451                         }
 452                     }
 453                 }
 454
 455                 // Check required attribute "command"
 456                 if ( pItem->aCommandURL.isEmpty() )
 457                 {
 458                     delete pItem;
 459                     delete m_pImages;
 460                     delete m_pExternalImages;
 461                     m_pImages = NULL;
 462                     m_pExternalImages = NULL;
 463
 464                     OUString aErrorMessage = getErrorLineString();
 465                     aErrorMessage += "Required attribute 'image:command' must have a value!";
 466                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 467                 }
 468
 469                 // Check required attribute "href"
 470                 if ( pItem->aURL.isEmpty() )
 471                 {
 472                     delete pItem;
 473                     delete m_pImages;
 474                     delete m_pExternalImages;
 475                     m_pImages = NULL;
 476                     m_pExternalImages = NULL;
 477
 478                     OUString aErrorMessage = getErrorLineString();
 479                     aErrorMessage += "Required attribute 'xlink:href' must have a value!";
 480                     throw SAXException( aErrorMessage, Reference< XInterface >(), Any() );
 481                 }
 482
 483                 if ( m_pExternalImages )
 484                     m_pExternalImages->push_back( pItem );
 485                 else
 486                     delete pItem;
 487             }
 488             break;
 489
 490                   default:
 491                       break;
 492         }
 493     }
 494 }
 495
 496 void SAL_CALL OReadImagesDocumentHandler::endElement(const OUString& aName)
 497     throw(SAXException,
 498           RuntimeException,
 499           std::exception)
 500 {
 501     SolarMutexGuard g;
 502
 503     ImageHashMap::const_iterator pImageEntry = m_aImageMap.find( aName );
 504     if ( pImageEntry != m_aImageMap.end() )
 505     {
 506         switch ( pImageEntry->second )
 507         {
 508             case IMG_ELEMENT_IMAGECONTAINER:
 509             {
 510                 m_bImageContainerEndFound = true;
 511             }
 512             break;
 513
 514             case IMG_ELEMENT_IMAGES:
 515             {
 516                 if ( m_pImages )
 517                 {
 518                     if ( m_aImageList.pImageList )
 519                         m_aImageList.pImageList->push_back( m_pImages );
 520                     m_pImages = NULL;
 521                 }
 522                 m_bImagesStartFound = false;
 523             }
 524             break;
 525
 526             case IMG_ELEMENT_ENTRY:
 527             {
 528                 m_bImageStartFound = false;
 529             }
 530             break;
 531
 532             case IMG_ELEMENT_EXTERNALIMAGES:
 533             {
 534                 if ( m_pExternalImages && !m_aImageList.pExternalImageList )
 535                 {
 536                     if ( !m_aImageList.pExternalImageList )
 537                         m_aImageList.pExternalImageList = m_pExternalImages;
 538                 }
 539
 540                 m_bExternalImagesStartFound = false;
 541                 m_pExternalImages = NULL;
 542             }
 543             break;
 544
 545             case IMG_ELEMENT_EXTERNALENTRY:
 546             {
 547                 m_bExternalImageStartFound = false;
 548             }
 549             break;
 550
 551                   default:
 552                       break;
 553         }
 554     }
 555 }
 556
 557 void SAL_CALL OReadImagesDocumentHandler::characters(const OUString&)
 558 throw(  SAXException, RuntimeException, std::exception )
 559 {
 560 }
 561
 562 void SAL_CALL OReadImagesDocumentHandler::ignorableWhitespace(const OUString&)
 563 throw(  SAXException, RuntimeException, std::exception )
 564 {
 565 }
 566
 567 void SAL_CALL OReadImagesDocumentHandler::processingInstruction(
 568     const OUString& /*aTarget*/, const OUString& /*aData*/ )
 569 throw(  SAXException, RuntimeException, std::exception )
 570 {
 571 }
 572
 573 void SAL_CALL OReadImagesDocumentHandler::setDocumentLocator(
 574     const Reference< XLocator > &xLocator)
 575 throw(  SAXException, RuntimeException, std::exception )
 576 {
 577     SolarMutexGuard g;
 578     m_xLocator = xLocator;
 579 }
 580
 581 OUString OReadImagesDocumentHandler::getErrorLineString()
 582 {
 583     SolarMutexGuard g;
 584     if ( m_xLocator.is() )
 585     {
 586         OUStringBuffer buffer("Line: ");
 587         buffer.append(m_xLocator->getLineNumber());
 588         buffer.append(" - ");
 589         return buffer.makeStringAndClear();
 590     }
 591     else
 592         return OUString();
 593 }
 594
 595 //  OWriteImagesDocumentHandler
 596
 597 OWriteImagesDocumentHandler::OWriteImagesDocumentHandler(
 598     const ImageListsDescriptor& aItems,
 599     Reference< XDocumentHandler > rWriteDocumentHandler ) :
 600     m_aImageListsItems( aItems ),
 601     m_xWriteDocumentHandler( rWriteDocumentHandler )
 602 {
 603     ::comphelper::AttributeList* pList = new ::comphelper::AttributeList;
 604     m_xEmptyList            = Reference< XAttributeList >( (XAttributeList *) pList, UNO_QUERY );
 605     m_aAttributeType        = ATTRIBUTE_TYPE_CDATA;
 606     m_aXMLImageNS           = XMLNS_IMAGE_PREFIX;
 607     m_aXMLXlinkNS           = XMLNS_XLINK_PREFIX;
 608     m_aAttributeXlinkType   = ATTRIBUTE_XLINK_TYPE;
 609     m_aAttributeValueSimple = ATTRIBUTE_XLINK_TYPE_VALUE;
 610 }
 611
 612 OWriteImagesDocumentHandler::~OWriteImagesDocumentHandler()
 613 {
 614 }
 615
 616 void OWriteImagesDocumentHandler::WriteImagesDocument() throw
 617 ( SAXException, RuntimeException )
 618 {
 619     SolarMutexGuard g;
 620
 621     m_xWriteDocumentHandler->startDocument();
 622
 623     // write DOCTYPE line!
 624     Reference< XExtendedDocumentHandler > xExtendedDocHandler( m_xWriteDocumentHandler, UNO_QUERY );
 625     if ( xExtendedDocHandler.is() )
 626     {
 627         xExtendedDocHandler->unknown( OUString( IMAGES_DOCTYPE ) );
 628         m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 629     }
 630
 631     ::comphelper::AttributeList* pList = new ::comphelper::AttributeList;
 632     Reference< XAttributeList > xList( (XAttributeList *) pList , UNO_QUERY );
 633
 634     pList->AddAttribute( OUString( ATTRIBUTE_XMLNS_IMAGE),
 635                          m_aAttributeType,
 636                          OUString( XMLNS_IMAGE ) );
 637
 638     pList->AddAttribute( OUString( ATTRIBUTE_XMLNS_XLINK ),
 639                          m_aAttributeType,
 640                          OUString( XMLNS_XLINK ) );
 641
 642     m_xWriteDocumentHandler->startElement( OUString( ELEMENT_NS_IMAGESCONTAINER ), pList );
 643     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 644
 645     if ( m_aImageListsItems.pImageList )
 646     {
 647         ImageListDescriptor* pImageList = m_aImageListsItems.pImageList;
 648
 649         for ( sal_uInt16 i = 0; i < m_aImageListsItems.pImageList->size(); i++ )
 650         {
 651             const ImageListItemDescriptor* pImageItems = &(*pImageList)[i];
 652             WriteImageList( pImageItems );
 653         }
 654     }
 655
 656     if ( m_aImageListsItems.pExternalImageList )
 657     {
 658         WriteExternalImageList( m_aImageListsItems.pExternalImageList );
 659     }
 660
 661     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 662     m_xWriteDocumentHandler->endElement( OUString( ELEMENT_NS_IMAGESCONTAINER ) );
 663     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 664     m_xWriteDocumentHandler->endDocument();
 665 }
 666
 667 //  protected member functions
 668
 669 void OWriteImagesDocumentHandler::WriteImageList( const ImageListItemDescriptor* pImageList ) throw
 670 ( SAXException, RuntimeException )
 671 {
 672     ::comphelper::AttributeList* pList = new ::comphelper::AttributeList;
 673     Reference< XAttributeList > xList( (XAttributeList *) pList , UNO_QUERY );
 674
 675     // save required attributes
 676     pList->AddAttribute( m_aAttributeXlinkType,
 677                          m_aAttributeType,
 678                          m_aAttributeValueSimple );
 679
 680     pList->AddAttribute( m_aXMLXlinkNS + ATTRIBUTE_HREF,
 681                          m_aAttributeType,
 682                          pImageList->aURL );
 683
 684     if ( pImageList->nMaskMode == ImageMaskMode_Bitmap )
 685     {
 686         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_MASKMODE,
 687                              m_aAttributeType,
 688                              OUString( ATTRIBUTE_MASKMODE_BITMAP ) );
 689
 690         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_MASKURL,
 691                              m_aAttributeType,
 692                              pImageList->aMaskURL );
 693
 694         if ( !pImageList->aHighContrastMaskURL.isEmpty() )
 695         {
 696             pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_HIGHCONTRASTMASKURL,
 697                                  m_aAttributeType,
 698                                  pImageList->aHighContrastMaskURL );
 699         }
 700     }
 701     else
 702     {
 703         OUStringBuffer   aColorStrBuffer( 8 );
 704         sal_Int64       nValue = pImageList->aMaskColor.GetRGBColor();
 705
 706         aColorStrBuffer.appendAscii( "#" );
 707         aColorStrBuffer.append( OUString::number( nValue, 16 ));
 708
 709         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_MASKCOLOR,
 710                              m_aAttributeType,
 711                              aColorStrBuffer.makeStringAndClear() );
 712
 713         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_MASKMODE,
 714                              m_aAttributeType,
 715                              OUString( ATTRIBUTE_MASKMODE_COLOR ) );
 716     }
 717
 718     if ( !pImageList->aHighContrastURL.isEmpty() )
 719     {
 720         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_HIGHCONTRASTURL,
 721                              m_aAttributeType,
 722                              pImageList->aHighContrastURL );
 723     }
 724
 725     m_xWriteDocumentHandler->startElement( OUString( ELEMENT_NS_IMAGES ), xList );
 726     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 727
 728     ImageItemListDescriptor* pImageItemList = pImageList->pImageItemList;
 729     if ( pImageItemList )
 730     {
 731         for ( sal_uInt16 i = 0; i < pImageItemList->size(); i++ )
 732             WriteImage( &(*pImageItemList)[i] );
 733     }
 734
 735     m_xWriteDocumentHandler->endElement( OUString( ELEMENT_NS_IMAGES ) );
 736     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 737 }
 738
 739 void OWriteImagesDocumentHandler::WriteImage( const ImageItemDescriptor* pImage ) throw
 740 ( SAXException, RuntimeException )
 741 {
 742     ::comphelper::AttributeList* pList = new ::comphelper::AttributeList;
 743     Reference< XAttributeList > xList( (XAttributeList *) pList , UNO_QUERY );
 744
 745     pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_BITMAPINDEX,
 746                          m_aAttributeType,
 747                          OUString::number( pImage->nIndex ) );
 748
 749     pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_COMMAND,
 750                          m_aAttributeType,
 751                          pImage->aCommandURL );
 752
 753     m_xWriteDocumentHandler->startElement( OUString( ELEMENT_NS_ENTRY ), xList );
 754     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 755
 756     m_xWriteDocumentHandler->endElement( OUString( ELEMENT_NS_ENTRY ) );
 757     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 758 }
 759
 760 void OWriteImagesDocumentHandler::WriteExternalImageList( const ExternalImageItemListDescriptor* pExternalImageList ) throw
 761 ( SAXException, RuntimeException )
 762 {
 763     m_xWriteDocumentHandler->startElement( OUString( ELEMENT_NS_EXTERNALIMAGES ), m_xEmptyList );
 764     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 765
 766     for ( sal_uInt16 i = 0; i < pExternalImageList->size(); i++ )
 767     {
 768         const ExternalImageItemDescriptor* pItem = &(*pExternalImageList)[i];
 769         WriteExternalImage( pItem );
 770     }
 771
 772     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 773     m_xWriteDocumentHandler->endElement( OUString( ELEMENT_NS_EXTERNALIMAGES ) );
 774     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 775 }
 776
 777 void OWriteImagesDocumentHandler::WriteExternalImage( const ExternalImageItemDescriptor* pExternalImage ) throw
 778 ( SAXException, RuntimeException )
 779 {
 780     ::comphelper::AttributeList* pList = new ::comphelper::AttributeList;
 781     Reference< XAttributeList > xList( (XAttributeList *) pList , UNO_QUERY );
 782
 783     // save required attributes
 784     pList->AddAttribute( m_aAttributeXlinkType,
 785                          m_aAttributeType,
 786                          m_aAttributeValueSimple );
 787
 788     if ( !pExternalImage->aURL.isEmpty() )
 789     {
 790         pList->AddAttribute( m_aXMLXlinkNS + ATTRIBUTE_HREF,
 791                              m_aAttributeType,
 792                              pExternalImage->aURL );
 793     }
 794
 795     if ( !pExternalImage->aCommandURL.isEmpty() )
 796     {
 797         pList->AddAttribute( m_aXMLImageNS + ATTRIBUTE_COMMAND,
 798                              m_aAttributeType,
 799                              pExternalImage->aCommandURL );
 800     }
 801
 802     m_xWriteDocumentHandler->startElement( OUString( ELEMENT_NS_EXTERNALENTRY ), xList );
 803     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 804
 805     m_xWriteDocumentHandler->endElement( OUString( ELEMENT_NS_EXTERNALENTRY ) );
 806     m_xWriteDocumentHandler->ignorableWhitespace( OUString() );
 807 }
 808
 809 } // namespace framework
 810
 811 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */