svx/source/xoutdev/xattrbmp.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 <com/sun/star/awt/XBitmap.hpp>
  21 #include <com/sun/star/graphic/XGraphic.hpp>
  22 #include <tools/stream.hxx>
  23 #include <vcl/window.hxx>
  24 #include <vcl/virdev.hxx>
  25 #include <vcl/bitmapex.hxx>
  26 #include <toolkit/unohlp.hxx>
  27 #include <svl/style.hxx>
  28 #include <editeng/memberids.hrc>
  29 #include <svx/dialogs.hrc>
  30 #include "svx/xattr.hxx"
  31 #include <svx/xtable.hxx>
  32 #include <svx/xdef.hxx>
  33 #include <svx/unomid.hxx>
  34 #include <editeng/unoprnms.hxx>
  35 #include <svx/unoapi.hxx>
  36 #include <svx/svdmodel.hxx>
  37 #include <svx/xbitmap.hxx>
  38 #include <com/sun/star/beans/PropertyValue.hpp>
  39 #include <vcl/salbtype.hxx>
  40 #include <vcl/bmpacc.hxx>
  41
  42 using namespace ::com::sun::star;
  43
  44 /*************************************************************************
  45 |*
  46 |*    XOBitmap::XOBitmap( Bitmap aBitmap )
  47 |*
  48 *************************************************************************/
  49
  50 XOBitmap::XOBitmap( const Bitmap& rBmp ) :
  51     eType           ( XBITMAP_IMPORT ),
  52     aGraphicObject  ( rBmp ),
  53     pPixelArray     ( NULL ),
  54     bGraphicDirty   ( sal_False )
  55 {
  56 }
  57
  58 /*************************************************************************
  59 |*
  60 |*    XOBitmap::XOBitmap( const XOBitmap& rXBmp )
  61 |*
  62 *************************************************************************/
  63
  64 XOBitmap::XOBitmap( const XOBitmap& rXBmp ) :
  65     pPixelArray ( NULL )
  66 {
  67     eType = rXBmp.eType;
  68     aGraphicObject = rXBmp.aGraphicObject;
  69     aArraySize = rXBmp.aArraySize;
  70     aPixelColor = rXBmp.aPixelColor;
  71     aBckgrColor = rXBmp.aBckgrColor;
  72     bGraphicDirty = rXBmp.bGraphicDirty;
  73
  74     if( rXBmp.pPixelArray )
  75     {
  76         if( eType == XBITMAP_8X8 )
  77         {
  78             pPixelArray = new sal_uInt16[ 64 ];
  79
  80             for( sal_uInt16 i = 0; i < 64; i++ )
  81                 *( pPixelArray + i ) = *( rXBmp.pPixelArray + i );
  82         }
  83     }
  84 }
  85
  86 /*************************************************************************
  87 |*
  88 |*    XOBitmap::XOBitmap( Bitmap aBitmap )
  89 |*
  90 *************************************************************************/
  91
  92 XOBitmap::~XOBitmap()
  93 {
  94     delete [] pPixelArray;
  95 }
  96
  97 /*************************************************************************
  98 |*
  99 |*    XOBitmap& XOBitmap::operator=( const XOBitmap& rXBmp )
 100 |*
 101 *************************************************************************/
 102
 103 XOBitmap& XOBitmap::operator=( const XOBitmap& rXBmp )
 104 {
 105     eType = rXBmp.eType;
 106     aGraphicObject = rXBmp.aGraphicObject;
 107     aArraySize = rXBmp.aArraySize;
 108     aPixelColor = rXBmp.aPixelColor;
 109     aBckgrColor = rXBmp.aBckgrColor;
 110     bGraphicDirty = rXBmp.bGraphicDirty;
 111
 112     if( rXBmp.pPixelArray )
 113     {
 114         if( eType == XBITMAP_8X8 )
 115         {
 116             pPixelArray = new sal_uInt16[ 64 ];
 117
 118             for( sal_uInt16 i = 0; i < 64; i++ )
 119                 *( pPixelArray + i ) = *( rXBmp.pPixelArray + i );
 120         }
 121     }
 122     return( *this );
 123 }
 124
 125 /*************************************************************************
 126 |*
 127 |*    int XOBitmap::operator==( const XOBitmap& rXOBitmap ) const
 128 |*
 129 *************************************************************************/
 130
 131 int XOBitmap::operator==( const XOBitmap& rXOBitmap ) const
 132 {
 133     if( eType != rXOBitmap.eType      ||
 134         aGraphicObject != rXOBitmap.aGraphicObject ||
 135         aArraySize != rXOBitmap.aArraySize     ||
 136         aPixelColor != rXOBitmap.aPixelColor ||
 137         aBckgrColor != rXOBitmap.aBckgrColor ||
 138         bGraphicDirty != rXOBitmap.bGraphicDirty )
 139     {
 140         return( sal_False );
 141     }
 142
 143     if( pPixelArray && rXOBitmap.pPixelArray )
 144     {
 145         sal_uInt16 nCount = (sal_uInt16) ( aArraySize.Width() * aArraySize.Height() );
 146         for( sal_uInt16 i = 0; i < nCount; i++ )
 147         {
 148             if( *( pPixelArray + i ) != *( rXOBitmap.pPixelArray + i ) )
 149                 return( sal_False );
 150         }
 151     }
 152     return( sal_True );
 153 }
 154
 155 /*************************************************************************
 156 |*
 157 |*    Bitmap XOBitmap::GetBitmap()
 158 |*
 159 *************************************************************************/
 160
 161 Bitmap XOBitmap::GetBitmap() const
 162 {
 163     return GetGraphicObject().GetGraphic().GetBitmap();
 164 }
 165
 166 /*************************************************************************
 167 |*
 168 |*    Bitmap XOBitmap::GetGraphicObject()
 169 |*
 170 *************************************************************************/
 171
 172 const GraphicObject& XOBitmap::GetGraphicObject() const
 173 {
 174     if( bGraphicDirty )
 175         ( (XOBitmap*) this )->Array2Bitmap();
 176
 177     return aGraphicObject;
 178 }
 179
 180 /*************************************************************************
 181 |*
 182 |*    void XOBitmap::Bitmap2Array()
 183 |*
 184 |*    Beschreibung      Umwandlung der Bitmap in Array, Hinter- u.
 185 |*                      Vordergrundfarbe
 186 |*
 187 *************************************************************************/
 188
 189 void XOBitmap::Bitmap2Array()
 190 {
 191     VirtualDevice   aVD;
 192     bool            bPixelColor = false;
 193     const Bitmap    aBitmap( GetBitmap() );
 194     const sal_uInt16    nLines = 8; // von Type abhaengig
 195
 196     if( !pPixelArray )
 197         pPixelArray = new sal_uInt16[ nLines * nLines ];
 198
 199     aVD.SetOutputSizePixel( aBitmap.GetSizePixel() );
 200     aVD.DrawBitmap( Point(), aBitmap );
 201     aPixelColor = aBckgrColor = aVD.GetPixel( Point() );
 202
 203     // Aufbau des Arrays und Ermittlung der Vorder-, bzw.
 204     // Hintergrundfarbe
 205     for( sal_uInt16 i = 0; i < nLines; i++ )
 206     {
 207         for( sal_uInt16 j = 0; j < nLines; j++ )
 208         {
 209             if ( aVD.GetPixel( Point( j, i ) ) == aBckgrColor )
 210                 *( pPixelArray + j + i * nLines ) = 0;
 211             else
 212             {
 213                 *( pPixelArray + j + i * nLines ) = 1;
 214                 if( !bPixelColor )
 215                 {
 216                     aPixelColor = aVD.GetPixel( Point( j, i ) );
 217                     bPixelColor = true;
 218                 }
 219             }
 220         }
 221     }
 222 }
 223
 224 /*************************************************************************
 225 |*
 226 |*    void XOBitmap::Array2Bitmap()
 227 |*
 228 |*    Beschreibung      Umwandlung des Arrays, Hinter- u.
 229 |*                      Vordergrundfarbe in eine Bitmap
 230 |*
 231 *************************************************************************/
 232
 233 void XOBitmap::Array2Bitmap()
 234 {
 235     VirtualDevice   aVD;
 236     sal_uInt16          nLines = 8; // von Type abhaengig
 237
 238     if( !pPixelArray )
 239         return;
 240
 241     aVD.SetOutputSizePixel( Size( nLines, nLines ) );
 242
 243     // Aufbau der Bitmap
 244     for( sal_uInt16 i = 0; i < nLines; i++ )
 245     {
 246         for( sal_uInt16 j = 0; j < nLines; j++ )
 247         {
 248             if( *( pPixelArray + j + i * nLines ) == 0 )
 249                 aVD.DrawPixel( Point( j, i ), aBckgrColor );
 250             else
 251                 aVD.DrawPixel( Point( j, i ), aPixelColor );
 252         }
 253     }
 254
 255     aGraphicObject = GraphicObject( aVD.GetBitmap( Point(), Size( nLines, nLines ) ) );
 256     bGraphicDirty = sal_False;
 257 }
 258
 259 // -----------------------
 260 // class XFillBitmapItem
 261 // -----------------------
 262 TYPEINIT1_AUTOFACTORY(XFillBitmapItem, NameOrIndex);
 263
 264 //////////////////////////////////////////////////////////////////////////////
 265
 266 XFillBitmapItem::XFillBitmapItem(const XubString& rName, const GraphicObject& rGraphicObject)
 267 :   NameOrIndex(XATTR_FILLBITMAP, rName),
 268     maGraphicObject(rGraphicObject)
 269 {
 270 }
 271
 272 //////////////////////////////////////////////////////////////////////////////
 273
 274 XFillBitmapItem::XFillBitmapItem(const XFillBitmapItem& rItem)
 275 :   NameOrIndex(rItem),
 276     maGraphicObject(rItem.maGraphicObject)
 277 {
 278 }
 279
 280 //////////////////////////////////////////////////////////////////////////////
 281
 282 Bitmap createHistorical8x8FromArray(const sal_uInt16* pArray, Color aColorPix, Color aColorBack)
 283 {
 284     BitmapPalette aPalette(2);
 285
 286     aPalette[0] = BitmapColor(aColorBack);
 287     aPalette[1] = BitmapColor(aColorPix);
 288
 289     Bitmap aBitmap(Size(8, 8), 1, &aPalette);
 290     BitmapWriteAccess* pContent = aBitmap.AcquireWriteAccess();
 291
 292     if(pContent)
 293     {
 294         for(sal_uInt16 a(0); a < 8; a++)
 295         {
 296             for(sal_uInt16 b(0); b < 8; b++)
 297             {
 298                 if(pArray[(a * 8) + b])
 299                 {
 300                     pContent->SetPixelIndex(b, a, 1);
 301                 }
 302                 else
 303                 {
 304                     pContent->SetPixelIndex(b, a, 0);
 305                 }
 306             }
 307         }
 308
 309         aBitmap.ReleaseAccess(pContent);
 310     }
 311
 312     return aBitmap;
 313 }
 314
 315 //////////////////////////////////////////////////////////////////////////////
 316
 317 bool SVX_DLLPUBLIC isHistorical8x8(const BitmapEx& rBitmapEx, BitmapColor& o_rBack, BitmapColor& o_rFront)
 318 {
 319     if(!rBitmapEx.IsTransparent())
 320     {
 321         Bitmap aBitmap(rBitmapEx.GetBitmap());
 322
 323         if(8 == aBitmap.GetSizePixel().Width() && 8 == aBitmap.GetSizePixel().Height())
 324         {
 325             if(2 == aBitmap.GetColorCount())
 326             {
 327                 BitmapReadAccess* pRead = aBitmap.AcquireReadAccess();
 328
 329                 if(pRead)
 330                 {
 331                     if(pRead->HasPalette() && 2 == pRead->GetPaletteEntryCount())
 332                     {
 333                         const BitmapPalette& rPalette = pRead->GetPalette();
 334
 335                         o_rBack = rPalette[1];
 336                         o_rFront = rPalette[0];
 337
 338                         return true;
 339                     }
 340                 }
 341             }
 342         }
 343     }
 344
 345     return false;
 346 }
 347
 348 //////////////////////////////////////////////////////////////////////////////
 349
 350 XFillBitmapItem::XFillBitmapItem(SvStream& rIn, sal_uInt16 nVer)
 351 :   NameOrIndex(XATTR_FILLBITMAP, rIn)
 352 {
 353     if (!IsIndex())
 354     {
 355         if(0 == nVer)
 356         {
 357             // Behandlung der alten Bitmaps
 358             Bitmap aBmp;
 359
 360             rIn >> aBmp;
 361             maGraphicObject = Graphic(aBmp);
 362         }
 363         else if(1 == nVer)
 364         {
 365             sal_Int16 iTmp;
 366
 367             rIn >> iTmp; // former XBitmapStyle
 368             rIn >> iTmp; // former XBitmapType
 369
 370             if(XBITMAP_IMPORT == iTmp)
 371             {
 372                 Bitmap aBmp;
 373
 374                 rIn >> aBmp;
 375                 maGraphicObject = Graphic(aBmp);
 376             }
 377             else if(XBITMAP_8X8 == iTmp)
 378             {
 379                 sal_uInt16 aArray[64];
 380
 381                 for(sal_uInt16 i(0); i < 64; i++)
 382                 {
 383                     rIn >> aArray[i];
 384                 }
 385
 386                 Color aColorPix;
 387                 Color aColorBack;
 388
 389                 rIn >> aColorPix;
 390                 rIn >> aColorBack;
 391
 392                 const Bitmap aBitmap(createHistorical8x8FromArray(aArray, aColorPix, aColorBack));
 393
 394                 maGraphicObject = Graphic(aBitmap);
 395             }
 396         }
 397         else if(2 == nVer)
 398         {
 399             BitmapEx aBmpEx;
 400
 401             rIn >> aBmpEx;
 402             maGraphicObject = Graphic(aBmpEx);
 403         }
 404     }
 405 }
 406
 407 //////////////////////////////////////////////////////////////////////////////
 408
 409 XFillBitmapItem::XFillBitmapItem(SfxItemPool* /*pPool*/, const GraphicObject& rGraphicObject)
 410 :   NameOrIndex( XATTR_FILLBITMAP, -1),
 411     maGraphicObject(rGraphicObject)
 412 {
 413 }
 414
 415 //////////////////////////////////////////////////////////////////////////////
 416
 417 SfxPoolItem* XFillBitmapItem::Clone(SfxItemPool* /*pPool*/) const
 418 {
 419     return new XFillBitmapItem(*this);
 420 }
 421
 422 //////////////////////////////////////////////////////////////////////////////
 423
 424 int XFillBitmapItem::operator==(const SfxPoolItem& rItem) const
 425 {
 426     return (NameOrIndex::operator==(rItem)
 427         && maGraphicObject == ((const XFillBitmapItem&)rItem).maGraphicObject);
 428 }
 429
 430 //////////////////////////////////////////////////////////////////////////////
 431
 432 SfxPoolItem* XFillBitmapItem::Create(SvStream& rIn, sal_uInt16 nVer) const
 433 {
 434     return new XFillBitmapItem( rIn, nVer );
 435 }
 436
 437 //////////////////////////////////////////////////////////////////////////////
 438
 439 SvStream& XFillBitmapItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
 440 {
 441     NameOrIndex::Store(rOut, nItemVersion);
 442
 443     if(!IsIndex())
 444     {
 445         rOut << maGraphicObject.GetGraphic().GetBitmapEx();
 446     }
 447
 448     return rOut;
 449 }
 450
 451 //////////////////////////////////////////////////////////////////////////////
 452
 453 const GraphicObject& XFillBitmapItem::GetGraphicObject() const
 454 {
 455     return maGraphicObject;
 456 }
 457
 458 //////////////////////////////////////////////////////////////////////////////
 459
 460 void XFillBitmapItem::SetGraphicObject(const GraphicObject& rGraphicObject)
 461 {
 462     maGraphicObject = rGraphicObject;
 463 }
 464
 465 //////////////////////////////////////////////////////////////////////////////
 466
 467 sal_uInt16 XFillBitmapItem::GetVersion(sal_uInt16 /*nFileFormatVersion*/) const
 468 {
 469     // version three
 470     return(2);
 471 }
 472
 473 //////////////////////////////////////////////////////////////////////////////
 474
 475 SfxItemPresentation XFillBitmapItem::GetPresentation(
 476     SfxItemPresentation ePres,
 477     SfxMapUnit /*eCoreUnit*/,
 478     SfxMapUnit /*ePresUnit*/,
 479     OUString& rText,
 480     const IntlWrapper*) const
 481 {
 482     switch (ePres)
 483     {
 484         case SFX_ITEM_PRESENTATION_NONE:
 485             rText = OUString();
 486             return ePres;
 487         case SFX_ITEM_PRESENTATION_NAMELESS:
 488         case SFX_ITEM_PRESENTATION_COMPLETE:
 489             rText += GetName();
 490             return ePres;
 491         default:
 492             return SFX_ITEM_PRESENTATION_NONE;
 493     }
 494 }
 495
 496 //////////////////////////////////////////////////////////////////////////////
 497
 498 bool XFillBitmapItem::QueryValue(::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId) const
 499 {
 500     nMemberId &= ~CONVERT_TWIPS;
 501
 502     // needed for MID_NAME
 503     OUString aApiName;
 504     // needed for complete item (MID 0)
 505     OUString aInternalName;
 506
 507     OUString aURL;
 508     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XBitmap > xBmp;
 509
 510     if( nMemberId == MID_NAME )
 511     {
 512          aApiName = SvxUnogetApiNameForItem(Which(), GetName());
 513     }
 514     else if( nMemberId == 0  )
 515     {
 516         aInternalName = GetName();
 517     }
 518
 519     if( nMemberId == MID_GRAFURL ||
 520         nMemberId == 0 )
 521     {
 522         aURL = OUString(
 523             UNO_NAME_GRAPHOBJ_URLPREFIX);
 524         aURL += OStringToOUString(
 525             GetGraphicObject().GetUniqueID(),
 526             RTL_TEXTENCODING_ASCII_US);
 527     }
 528     if( nMemberId == MID_BITMAP ||
 529         nMemberId == 0  )
 530     {
 531         xBmp.set(VCLUnoHelper::CreateBitmap(GetGraphicObject().GetGraphic().GetBitmapEx()));
 532     }
 533
 534     if( nMemberId == MID_NAME )
 535         rVal <<= aApiName;
 536     else if( nMemberId == MID_GRAFURL )
 537         rVal <<= aURL;
 538     else if( nMemberId == MID_BITMAP )
 539         rVal <<= xBmp;
 540     else
 541     {
 542         // member-id 0 => complete item (e.g. for toolbars)
 543         DBG_ASSERT( nMemberId == 0, "invalid member-id" );
 544         uno::Sequence< beans::PropertyValue > aPropSeq( 3 );
 545
 546         aPropSeq[0].Name  = OUString( "Name" );
 547         aPropSeq[0].Value = uno::makeAny( aInternalName );
 548         aPropSeq[1].Name  = OUString( "FillBitmapURL" );
 549         aPropSeq[1].Value = uno::makeAny( aURL );
 550         aPropSeq[2].Name  = OUString( "Bitmap" );
 551         aPropSeq[2].Value = uno::makeAny( xBmp );
 552
 553         rVal <<= aPropSeq;
 554     }
 555
 556     return true;
 557 }
 558
 559 //////////////////////////////////////////////////////////////////////////////
 560
 561 bool XFillBitmapItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
 562 {
 563     nMemberId &= ~CONVERT_TWIPS;
 564
 565     OUString aName;
 566     OUString aURL;
 567     ::com::sun::star::uno::Reference< ::com::sun::star::awt::XBitmap > xBmp;
 568     ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic > xGraphic;
 569
 570     bool bSetName   = false;
 571     bool bSetURL    = false;
 572     bool bSetBitmap = false;
 573
 574     if( nMemberId == MID_NAME )
 575         bSetName = (rVal >>= aName);
 576     else if( nMemberId == MID_GRAFURL )
 577         bSetURL = (rVal >>= aURL);
 578     else if( nMemberId == MID_BITMAP )
 579     {
 580         bSetBitmap = (rVal >>= xBmp);
 581         if ( !bSetBitmap )
 582             bSetBitmap = (rVal >>= xGraphic );
 583     }
 584     else
 585     {
 586         DBG_ASSERT( nMemberId == 0, "invalid member-id" );
 587         uno::Sequence< beans::PropertyValue >   aPropSeq;
 588         if( rVal >>= aPropSeq )
 589         {
 590             for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
 591             {
 592                 if ( aPropSeq[n].Name == "Name" )
 593                     bSetName = (aPropSeq[n].Value >>= aName);
 594                 else if ( aPropSeq[n].Name == "FillBitmapURL" )
 595                     bSetURL = (aPropSeq[n].Value >>= aURL);
 596                 else if ( aPropSeq[n].Name == "Bitmap" )
 597                     bSetBitmap = (aPropSeq[n].Value >>= xBmp);
 598             }
 599         }
 600     }
 601
 602     if( bSetName )
 603     {
 604         SetName( aName );
 605     }
 606     if( bSetURL )
 607     {
 608         GraphicObject aGraphicObject  = GraphicObject::CreateGraphicObjectFromURL(aURL);
 609         if( aGraphicObject.GetType() != GRAPHIC_NONE )
 610             maGraphicObject = aGraphicObject;
 611     }
 612     if( bSetBitmap )
 613     {
 614         if(xBmp.is())
 615         {
 616             maGraphicObject = Graphic(VCLUnoHelper::GetBitmap(xBmp));
 617         }
 618         else if(xGraphic.is())
 619         {
 620             maGraphicObject = Graphic(xGraphic);
 621         }
 622     }
 623
 624     return (bSetName || bSetURL || bSetBitmap);
 625 }
 626
 627 //////////////////////////////////////////////////////////////////////////////
 628
 629 sal_Bool XFillBitmapItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
 630 {
 631     const GraphicObject& aGraphicObjectA(((XFillBitmapItem*)p1)->GetGraphicObject());
 632     const GraphicObject& aGraphicObjectB(((XFillBitmapItem*)p2)->GetGraphicObject());
 633
 634     return aGraphicObjectA == aGraphicObjectB;
 635 }
 636
 637 //////////////////////////////////////////////////////////////////////////////
 638
 639 XFillBitmapItem* XFillBitmapItem::checkForUniqueItem( SdrModel* pModel ) const
 640 {
 641     if( pModel )
 642     {
 643         const String aUniqueName = NameOrIndex::CheckNamedItem(
 644                 this, XATTR_FILLBITMAP, &pModel->GetItemPool(),
 645                 pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
 646                 XFillBitmapItem::CompareValueFunc, RID_SVXSTR_BMP21,
 647                 pModel->GetPropertyList( XBITMAP_LIST ) );
 648
 649         // if the given name is not valid, replace it!
 650         if( aUniqueName != GetName() )
 651         {
 652             return new XFillBitmapItem(aUniqueName, maGraphicObject);
 653         }
 654     }
 655
 656     return (XFillBitmapItem*)this;
 657 }
 658
 659 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */