Line data Source code
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 :
30 : #include <svx/dialogs.hrc>
31 : #include "svx/xattr.hxx"
32 : #include <svx/xtable.hxx>
33 : #include <svx/xdef.hxx>
34 : #include <svx/unomid.hxx>
35 : #include <editeng/unoprnms.hxx>
36 :
37 : #include "svx/unoapi.hxx"
38 : #include <svx/svdmodel.hxx>
39 : #include <com/sun/star/beans/PropertyValue.hpp>
40 :
41 : using namespace ::com::sun::star;
42 :
43 : // ---------------
44 : // class XOBitmap
45 : // ---------------
46 :
47 : /*************************************************************************
48 : |*
49 : |* XOBitmap::XOBitmap()
50 : |*
51 : *************************************************************************/
52 :
53 0 : XOBitmap::XOBitmap() :
54 : eType ( XBITMAP_NONE ),
55 : eStyle ( XBITMAP_STRETCH ),
56 : pPixelArray ( NULL ),
57 0 : bGraphicDirty ( sal_False )
58 : {
59 0 : }
60 :
61 : /*************************************************************************
62 : |*
63 : |* XOBitmap::XOBitmap( Bitmap aBitmap, XBitmapStyle eStyle = XBITMAP_TILE )
64 : |*
65 : *************************************************************************/
66 :
67 421 : XOBitmap::XOBitmap( const Bitmap& rBmp, XBitmapStyle eInStyle ) :
68 : eType ( XBITMAP_IMPORT ),
69 : eStyle ( eInStyle ),
70 : aGraphicObject ( rBmp ),
71 : pPixelArray ( NULL ),
72 421 : bGraphicDirty ( sal_False )
73 : {
74 421 : }
75 :
76 : /*************************************************************************
77 : |*
78 : |* XOBitmap::XOBitmap( Bitmap aBitmap, XBitmapStyle eStyle = XBITMAP_TILE )
79 : |*
80 : *************************************************************************/
81 :
82 0 : XOBitmap::XOBitmap( const GraphicObject& rGraphicObject, XBitmapStyle eInStyle ) :
83 : eType ( XBITMAP_IMPORT ),
84 : eStyle ( eInStyle ),
85 : aGraphicObject ( rGraphicObject ),
86 : pPixelArray ( NULL ),
87 0 : bGraphicDirty ( sal_False )
88 : {
89 0 : }
90 :
91 : /*************************************************************************
92 : |*
93 : |* XOBitmap::XOBitmap( sal_uInt16* pArray, const Color& aPixelColor,
94 : |* const Color& aBckgrColor, const Size& rSize = Size( 8, 8 ),
95 : |* XBitmapStyle eStyle = XBITMAP_TILE )
96 : |*
97 : *************************************************************************/
98 :
99 0 : XOBitmap::XOBitmap( const sal_uInt16* pArray, const Color& rPixelColor,
100 : const Color& rBckgrColor, const Size& rSize,
101 : XBitmapStyle eInStyle ) :
102 : eStyle ( eInStyle ),
103 : pPixelArray ( NULL ),
104 : aArraySize ( rSize ),
105 : aPixelColor ( rPixelColor ),
106 : aBckgrColor ( rBckgrColor ),
107 0 : bGraphicDirty ( sal_True )
108 :
109 : {
110 0 : if( aArraySize.Width() == 8 && aArraySize.Height() == 8 )
111 : {
112 0 : eType = XBITMAP_8X8;
113 0 : pPixelArray = new sal_uInt16[ 64 ];
114 :
115 0 : for( sal_uInt16 i = 0; i < 64; i++ )
116 0 : *( pPixelArray + i ) = *( pArray + i );
117 : }
118 : else
119 : {
120 : DBG_ASSERT( 0, "Nicht unterstuetzte Bitmapgroesse" );
121 : }
122 0 : }
123 :
124 : /*************************************************************************
125 : |*
126 : |* XOBitmap::XOBitmap( const XOBitmap& rXBmp )
127 : |*
128 : *************************************************************************/
129 :
130 577 : XOBitmap::XOBitmap( const XOBitmap& rXBmp ) :
131 577 : pPixelArray ( NULL )
132 : {
133 577 : eType = rXBmp.eType;
134 577 : eStyle = rXBmp.eStyle;
135 577 : aGraphicObject = rXBmp.aGraphicObject;
136 577 : aArraySize = rXBmp.aArraySize;
137 577 : aPixelColor = rXBmp.aPixelColor;
138 577 : aBckgrColor = rXBmp.aBckgrColor;
139 577 : bGraphicDirty = rXBmp.bGraphicDirty;
140 :
141 577 : if( rXBmp.pPixelArray )
142 : {
143 0 : if( eType == XBITMAP_8X8 )
144 : {
145 0 : pPixelArray = new sal_uInt16[ 64 ];
146 :
147 0 : for( sal_uInt16 i = 0; i < 64; i++ )
148 0 : *( pPixelArray + i ) = *( rXBmp.pPixelArray + i );
149 : }
150 : }
151 577 : }
152 :
153 : /*************************************************************************
154 : |*
155 : |* XOBitmap::XOBitmap( Bitmap aBitmap, XBitmapStyle eStyle = XBITMAP_TILE )
156 : |*
157 : *************************************************************************/
158 :
159 1572 : XOBitmap::~XOBitmap()
160 : {
161 786 : if( pPixelArray )
162 0 : delete []pPixelArray;
163 786 : }
164 :
165 : /*************************************************************************
166 : |*
167 : |* XOBitmap& XOBitmap::operator=( const XOBitmap& rXBmp )
168 : |*
169 : *************************************************************************/
170 :
171 0 : XOBitmap& XOBitmap::operator=( const XOBitmap& rXBmp )
172 : {
173 0 : eType = rXBmp.eType;
174 0 : eStyle = rXBmp.eStyle;
175 0 : aGraphicObject = rXBmp.aGraphicObject;
176 0 : aArraySize = rXBmp.aArraySize;
177 0 : aPixelColor = rXBmp.aPixelColor;
178 0 : aBckgrColor = rXBmp.aBckgrColor;
179 0 : bGraphicDirty = rXBmp.bGraphicDirty;
180 :
181 0 : if( rXBmp.pPixelArray )
182 : {
183 0 : if( eType == XBITMAP_8X8 )
184 : {
185 0 : pPixelArray = new sal_uInt16[ 64 ];
186 :
187 0 : for( sal_uInt16 i = 0; i < 64; i++ )
188 0 : *( pPixelArray + i ) = *( rXBmp.pPixelArray + i );
189 : }
190 : }
191 0 : return( *this );
192 : }
193 :
194 : /*************************************************************************
195 : |*
196 : |* int XOBitmap::operator==( const XOBitmap& rXOBitmap ) const
197 : |*
198 : *************************************************************************/
199 :
200 1 : int XOBitmap::operator==( const XOBitmap& rXOBitmap ) const
201 : {
202 5 : if( eType != rXOBitmap.eType ||
203 : eStyle != rXOBitmap.eStyle ||
204 1 : aGraphicObject != rXOBitmap.aGraphicObject ||
205 1 : aArraySize != rXOBitmap.aArraySize ||
206 1 : aPixelColor != rXOBitmap.aPixelColor ||
207 1 : aBckgrColor != rXOBitmap.aBckgrColor ||
208 : bGraphicDirty != rXOBitmap.bGraphicDirty )
209 : {
210 0 : return( sal_False );
211 : }
212 :
213 1 : if( pPixelArray && rXOBitmap.pPixelArray )
214 : {
215 0 : sal_uInt16 nCount = (sal_uInt16) ( aArraySize.Width() * aArraySize.Height() );
216 0 : for( sal_uInt16 i = 0; i < nCount; i++ )
217 : {
218 0 : if( *( pPixelArray + i ) != *( rXOBitmap.pPixelArray + i ) )
219 0 : return( sal_False );
220 : }
221 : }
222 1 : return( sal_True );
223 : }
224 :
225 : /*************************************************************************
226 : |*
227 : |* void SetPixelArray( const sal_uInt16* pArray )
228 : |*
229 : *************************************************************************/
230 :
231 0 : void XOBitmap::SetPixelArray( const sal_uInt16* pArray )
232 : {
233 0 : if( eType == XBITMAP_8X8 )
234 : {
235 0 : if( pPixelArray )
236 0 : delete []pPixelArray;
237 :
238 0 : pPixelArray = new sal_uInt16[ 64 ];
239 :
240 0 : for( sal_uInt16 i = 0; i < 64; i++ )
241 0 : *( pPixelArray + i ) = *( pArray + i );
242 :
243 0 : bGraphicDirty = sal_True;
244 : }
245 : else
246 : {
247 : DBG_ASSERT( 0, "Nicht unterstuetzter Bitmaptyp" );
248 : }
249 0 : }
250 :
251 : /*************************************************************************
252 : |*
253 : |* Bitmap XOBitmap::GetBitmap()
254 : |*
255 : *************************************************************************/
256 :
257 72 : Bitmap XOBitmap::GetBitmap() const
258 : {
259 72 : return GetGraphicObject().GetGraphic().GetBitmap();
260 : }
261 :
262 : /*************************************************************************
263 : |*
264 : |* Bitmap XOBitmap::GetGraphicObject()
265 : |*
266 : *************************************************************************/
267 :
268 144 : const GraphicObject& XOBitmap::GetGraphicObject() const
269 : {
270 144 : if( bGraphicDirty )
271 0 : ( (XOBitmap*) this )->Array2Bitmap();
272 :
273 144 : return aGraphicObject;
274 : }
275 :
276 : /*************************************************************************
277 : |*
278 : |* void XOBitmap::Bitmap2Array()
279 : |*
280 : |* Beschreibung Umwandlung der Bitmap in Array, Hinter- u.
281 : |* Vordergrundfarbe
282 : |*
283 : *************************************************************************/
284 :
285 0 : void XOBitmap::Bitmap2Array()
286 : {
287 0 : VirtualDevice aVD;
288 0 : sal_Bool bPixelColor = sal_False;
289 0 : const Bitmap aBitmap( GetBitmap() );
290 0 : const sal_uInt16 nLines = 8; // von Type abhaengig
291 :
292 0 : if( !pPixelArray )
293 0 : pPixelArray = new sal_uInt16[ nLines * nLines ];
294 :
295 0 : aVD.SetOutputSizePixel( aBitmap.GetSizePixel() );
296 0 : aVD.DrawBitmap( Point(), aBitmap );
297 0 : aPixelColor = aBckgrColor = aVD.GetPixel( Point() );
298 :
299 : // Aufbau des Arrays und Ermittlung der Vorder-, bzw.
300 : // Hintergrundfarbe
301 0 : for( sal_uInt16 i = 0; i < nLines; i++ )
302 : {
303 0 : for( sal_uInt16 j = 0; j < nLines; j++ )
304 : {
305 0 : if ( aVD.GetPixel( Point( j, i ) ) == aBckgrColor )
306 0 : *( pPixelArray + j + i * nLines ) = 0;
307 : else
308 : {
309 0 : *( pPixelArray + j + i * nLines ) = 1;
310 0 : if( !bPixelColor )
311 : {
312 0 : aPixelColor = aVD.GetPixel( Point( j, i ) );
313 0 : bPixelColor = sal_True;
314 : }
315 : }
316 : }
317 0 : }
318 0 : }
319 :
320 : /*************************************************************************
321 : |*
322 : |* void XOBitmap::Array2Bitmap()
323 : |*
324 : |* Beschreibung Umwandlung des Arrays, Hinter- u.
325 : |* Vordergrundfarbe in eine Bitmap
326 : |*
327 : *************************************************************************/
328 :
329 0 : void XOBitmap::Array2Bitmap()
330 : {
331 0 : VirtualDevice aVD;
332 0 : sal_uInt16 nLines = 8; // von Type abhaengig
333 :
334 0 : if( !pPixelArray )
335 0 : return;
336 :
337 0 : aVD.SetOutputSizePixel( Size( nLines, nLines ) );
338 :
339 : // Aufbau der Bitmap
340 0 : for( sal_uInt16 i = 0; i < nLines; i++ )
341 : {
342 0 : for( sal_uInt16 j = 0; j < nLines; j++ )
343 : {
344 0 : if( *( pPixelArray + j + i * nLines ) == 0 )
345 0 : aVD.DrawPixel( Point( j, i ), aBckgrColor );
346 : else
347 0 : aVD.DrawPixel( Point( j, i ), aPixelColor );
348 : }
349 : }
350 :
351 0 : aGraphicObject = GraphicObject( aVD.GetBitmap( Point(), Size( nLines, nLines ) ) );
352 0 : bGraphicDirty = sal_False;
353 : }
354 :
355 : // -----------------------
356 : // class XFillBitmapItem
357 : // -----------------------
358 840 : TYPEINIT1_AUTOFACTORY(XFillBitmapItem, NameOrIndex);
359 :
360 : /*************************************************************************
361 : |*
362 : |* XFillBitmapItem::XFillBitmapItem(const XubString& rName,
363 : |* const Bitmap& rTheBitmap)
364 : |*
365 : *************************************************************************/
366 :
367 0 : XFillBitmapItem::XFillBitmapItem(const XubString& rName,
368 : const XOBitmap& rTheBitmap) :
369 : NameOrIndex( XATTR_FILLBITMAP, rName ),
370 0 : aXOBitmap( rTheBitmap )
371 : {
372 0 : }
373 :
374 : /*************************************************************************
375 : |*
376 : |* XFillBitmapItem::XFillBitmapItem(const XFillBitmapItem& rItem)
377 : |*
378 : *************************************************************************/
379 :
380 12 : XFillBitmapItem::XFillBitmapItem(const XFillBitmapItem& rItem) :
381 : NameOrIndex( rItem ),
382 12 : aXOBitmap( rItem.aXOBitmap )
383 : {
384 12 : }
385 :
386 : /*************************************************************************
387 : |*
388 : |* XFillBitmapItem::XFillBitmapItem(SvStream& rIn)
389 : |*
390 : *************************************************************************/
391 :
392 0 : XFillBitmapItem::XFillBitmapItem( SvStream& rIn, sal_uInt16 nVer ) :
393 0 : NameOrIndex( XATTR_FILLBITMAP, rIn )
394 : {
395 0 : if( nVer == 0 )
396 : {
397 0 : if (!IsIndex())
398 : {
399 : // Behandlung der alten Bitmaps
400 0 : Bitmap aBmp;
401 :
402 0 : rIn >> aBmp;
403 :
404 0 : aXOBitmap.SetBitmap( aBmp );
405 0 : aXOBitmap.SetBitmapStyle( XBITMAP_TILE );
406 :
407 0 : if( aBmp.GetSizePixel().Width() == 8 &&
408 0 : aBmp.GetSizePixel().Height() == 8 )
409 : {
410 0 : aXOBitmap.SetBitmapType( XBITMAP_8X8 );
411 0 : aXOBitmap.Bitmap2Array();
412 : }
413 : else
414 0 : aXOBitmap.SetBitmapType( XBITMAP_IMPORT );
415 : }
416 : }
417 0 : else if( nVer == 1 )
418 : {
419 0 : if (!IsIndex())
420 : {
421 : sal_Int16 iTmp;
422 0 : rIn >> iTmp;
423 0 : aXOBitmap.SetBitmapStyle( (XBitmapStyle) iTmp );
424 0 : rIn >> iTmp;
425 0 : aXOBitmap.SetBitmapType( (XBitmapType) iTmp );
426 :
427 0 : if( aXOBitmap.GetBitmapType() == XBITMAP_IMPORT )
428 : {
429 0 : Bitmap aBmp;
430 0 : rIn >> aBmp;
431 0 : aXOBitmap.SetBitmap( aBmp );
432 : }
433 0 : else if( aXOBitmap.GetBitmapType() == XBITMAP_8X8 )
434 : {
435 0 : sal_uInt16* pArray = new sal_uInt16[ 64 ];
436 0 : Color aColor;
437 :
438 0 : for( sal_uInt16 i = 0; i < 64; i++ )
439 0 : rIn >> *( pArray + i );
440 0 : aXOBitmap.SetPixelArray( pArray );
441 :
442 0 : rIn >> aColor;
443 0 : aXOBitmap.SetPixelColor( aColor );
444 0 : rIn >> aColor;
445 0 : aXOBitmap.SetBackgroundColor( aColor );
446 :
447 0 : delete []pArray;
448 : }
449 : }
450 : }
451 :
452 : // #81908# force bitmap to exist
453 0 : aXOBitmap.GetBitmap();
454 0 : }
455 :
456 : //*************************************************************************
457 :
458 421 : XFillBitmapItem::XFillBitmapItem( SfxItemPool* /*pPool*/, const XOBitmap& rTheBitmap )
459 : : NameOrIndex( XATTR_FILLBITMAP, -1 ),
460 421 : aXOBitmap( rTheBitmap )
461 : {
462 421 : }
463 :
464 : /*************************************************************************
465 : |*
466 : |* XFillBitmapItem::Clone(SfxItemPool* pPool) const
467 : |*
468 : *************************************************************************/
469 :
470 12 : SfxPoolItem* XFillBitmapItem::Clone(SfxItemPool* /*pPool*/) const
471 : {
472 12 : return new XFillBitmapItem(*this);
473 : }
474 :
475 : /*************************************************************************
476 : |*
477 : |* int XFillBitmapItem::operator==(const SfxPoolItem& rItem) const
478 : |*
479 : *************************************************************************/
480 :
481 1 : int XFillBitmapItem::operator==(const SfxPoolItem& rItem) const
482 : {
483 1 : return ( NameOrIndex::operator==(rItem) &&
484 1 : aXOBitmap == ((const XFillBitmapItem&) rItem).aXOBitmap );
485 : }
486 :
487 : /*************************************************************************
488 : |*
489 : |* SfxPoolItem* XFillBitmapItem::Create(SvStream& rIn, sal_uInt16 nVer) const
490 : |*
491 : *************************************************************************/
492 :
493 0 : SfxPoolItem* XFillBitmapItem::Create(SvStream& rIn, sal_uInt16 nVer) const
494 : {
495 0 : return new XFillBitmapItem( rIn, nVer );
496 : }
497 :
498 : /*************************************************************************
499 : |*
500 : |* SfxPoolItem* XFillBitmapItem::Store(SvStream& rOut) const
501 : |*
502 : *************************************************************************/
503 :
504 0 : SvStream& XFillBitmapItem::Store( SvStream& rOut, sal_uInt16 nItemVersion ) const
505 : {
506 0 : NameOrIndex::Store( rOut, nItemVersion );
507 :
508 0 : if (!IsIndex())
509 : {
510 0 : rOut << (sal_Int16) aXOBitmap.GetBitmapStyle();
511 0 : if( !aXOBitmap.GetBitmap() )
512 0 : rOut << (sal_Int16) XBITMAP_NONE;
513 : else
514 : {
515 0 : rOut << (sal_Int16) aXOBitmap.GetBitmapType();
516 0 : if( aXOBitmap.GetBitmapType() == XBITMAP_IMPORT )
517 : {
518 0 : const sal_uInt16 nOldComprMode = rOut.GetCompressMode();
519 0 : sal_uInt16 nNewComprMode = nOldComprMode;
520 :
521 0 : if( rOut.GetVersion() >= SOFFICE_FILEFORMAT_50 )
522 0 : nNewComprMode |= COMPRESSMODE_ZBITMAP;
523 : else
524 0 : nNewComprMode &= ~COMPRESSMODE_ZBITMAP;
525 :
526 0 : rOut.SetCompressMode( nNewComprMode );
527 0 : rOut << aXOBitmap.GetBitmap();
528 0 : rOut.SetCompressMode( nOldComprMode );
529 : }
530 0 : else if( aXOBitmap.GetBitmapType() == XBITMAP_8X8 )
531 : {
532 0 : sal_uInt16* pArray = aXOBitmap.GetPixelArray();
533 0 : for( sal_uInt16 i = 0; i < 64; i++ )
534 0 : rOut << (sal_uInt16) *( pArray + i );
535 :
536 0 : rOut << aXOBitmap.GetPixelColor();
537 0 : rOut << aXOBitmap.GetBackgroundColor();
538 : }
539 : }
540 : }
541 :
542 0 : return rOut;
543 : }
544 :
545 : /*************************************************************************
546 : |*
547 : |* const Bitmap& XFillBitmapItem::GetValue(const XBitmapTable* pTable) const
548 : |*
549 : *************************************************************************/
550 :
551 144 : const XOBitmap& XFillBitmapItem::GetBitmapValue(
552 : // const XBitmapTable* pTable
553 : ) const // GetValue -> GetBitmapValue
554 : {
555 : // Note: we never pass pTable to this method which means that it's NULL. Thus, this code would
556 : // fail if the Item was a list. I'm guessing that it can't be an Index or the caller makes sure
557 : // it's not an Index before calling. Either way, I'm just going to return the Bitmap to keep it
558 : // from failing. This could use some more research. (Joe P. 2011-08-24)
559 : // if (!IsIndex())
560 : // return aXOBitmap;
561 : // else
562 : // return pTable->GetBitmap(GetIndex())->GetXBitmap();
563 144 : return aXOBitmap;
564 : }
565 :
566 :
567 : /*************************************************************************
568 : |*
569 : |* sal_uInt16 XFillBitmapItem::GetVersion() const
570 : |*
571 : *************************************************************************/
572 :
573 0 : sal_uInt16 XFillBitmapItem::GetVersion( sal_uInt16 /*nFileFormatVersion*/) const
574 : {
575 : // 2. Version
576 0 : return( 1 );
577 : }
578 :
579 : //------------------------------------------------------------------------
580 :
581 0 : SfxItemPresentation XFillBitmapItem::GetPresentation
582 : (
583 : SfxItemPresentation ePres,
584 : SfxMapUnit /*eCoreUnit*/,
585 : SfxMapUnit /*ePresUnit*/,
586 : XubString& rText, const IntlWrapper *
587 : ) const
588 : {
589 0 : switch ( ePres )
590 : {
591 : case SFX_ITEM_PRESENTATION_NONE:
592 0 : rText.Erase();
593 0 : return ePres;
594 : case SFX_ITEM_PRESENTATION_NAMELESS:
595 : case SFX_ITEM_PRESENTATION_COMPLETE:
596 0 : rText += GetName();
597 0 : return ePres;
598 : default:
599 0 : return SFX_ITEM_PRESENTATION_NONE;
600 : }
601 : }
602 :
603 : //------------------------------------------------------------------------
604 :
605 216 : bool XFillBitmapItem::QueryValue( ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId ) const
606 : {
607 : // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
608 216 : nMemberId &= ~CONVERT_TWIPS;
609 :
610 : // needed for MID_NAME
611 216 : ::rtl::OUString aApiName;
612 : // needed for complete item (MID 0)
613 216 : ::rtl::OUString aInternalName;
614 :
615 216 : ::rtl::OUString aURL;
616 216 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XBitmap > xBmp;
617 :
618 216 : if( nMemberId == MID_NAME )
619 : {
620 72 : aApiName = SvxUnogetApiNameForItem(Which(), GetName());
621 : }
622 144 : else if( nMemberId == 0 )
623 : {
624 0 : aInternalName = GetName();
625 : }
626 :
627 216 : if( nMemberId == MID_GRAFURL ||
628 : nMemberId == 0 )
629 : {
630 72 : XOBitmap aLocalXOBitmap( GetBitmapValue() );
631 : aURL = ::rtl::OUString(RTL_CONSTASCII_USTRINGPARAM(
632 72 : UNO_NAME_GRAPHOBJ_URLPREFIX));
633 : aURL += ::rtl::OStringToOUString(
634 72 : aLocalXOBitmap.GetGraphicObject().GetUniqueID(),
635 72 : RTL_TEXTENCODING_ASCII_US);
636 : }
637 216 : if( nMemberId == MID_BITMAP ||
638 : nMemberId == 0 )
639 : {
640 72 : XOBitmap aLocalXOBitmap( GetBitmapValue() );
641 72 : Bitmap aBmp( aLocalXOBitmap.GetBitmap() );
642 72 : BitmapEx aBmpEx( aBmp );
643 :
644 72 : xBmp.set( VCLUnoHelper::CreateBitmap( aBmpEx ) );
645 : }
646 :
647 216 : if( nMemberId == MID_NAME )
648 72 : rVal <<= aApiName;
649 144 : else if( nMemberId == MID_GRAFURL )
650 72 : rVal <<= aURL;
651 72 : else if( nMemberId == MID_BITMAP )
652 72 : rVal <<= xBmp;
653 : else
654 : {
655 : // member-id 0 => complete item (e.g. for toolbars)
656 : DBG_ASSERT( nMemberId == 0, "invalid member-id" );
657 0 : uno::Sequence< beans::PropertyValue > aPropSeq( 3 );
658 :
659 0 : aPropSeq[0].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Name" ));
660 0 : aPropSeq[0].Value = uno::makeAny( aInternalName );
661 0 : aPropSeq[1].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "FillBitmapURL" ));
662 0 : aPropSeq[1].Value = uno::makeAny( aURL );
663 0 : aPropSeq[2].Name = ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "Bitmap" ));
664 0 : aPropSeq[2].Value = uno::makeAny( xBmp );
665 :
666 0 : rVal <<= aPropSeq;
667 : }
668 :
669 216 : return true;
670 : }
671 :
672 : //------------------------------------------------------------------------
673 :
674 0 : bool XFillBitmapItem::PutValue( const ::com::sun::star::uno::Any& rVal, sal_uInt8 nMemberId )
675 : {
676 : // sal_Bool bConvert = 0!=(nMemberId&CONVERT_TWIPS);
677 0 : nMemberId &= ~CONVERT_TWIPS;
678 :
679 0 : ::rtl::OUString aName;
680 0 : ::rtl::OUString aURL;
681 0 : ::com::sun::star::uno::Reference< ::com::sun::star::awt::XBitmap > xBmp;
682 0 : ::com::sun::star::uno::Reference< ::com::sun::star::graphic::XGraphic > xGraphic;
683 :
684 0 : bool bSetName = false;
685 0 : bool bSetURL = false;
686 0 : bool bSetBitmap = false;
687 :
688 0 : if( nMemberId == MID_NAME )
689 0 : bSetName = (rVal >>= aName);
690 0 : else if( nMemberId == MID_GRAFURL )
691 0 : bSetURL = (rVal >>= aURL);
692 0 : else if( nMemberId == MID_BITMAP )
693 : {
694 0 : bSetBitmap = (rVal >>= xBmp);
695 0 : if ( !bSetBitmap )
696 0 : bSetBitmap = (rVal >>= xGraphic );
697 : }
698 : else
699 : {
700 : DBG_ASSERT( nMemberId == 0, "invalid member-id" );
701 0 : uno::Sequence< beans::PropertyValue > aPropSeq;
702 0 : if( rVal >>= aPropSeq )
703 : {
704 0 : for ( sal_Int32 n = 0; n < aPropSeq.getLength(); n++ )
705 : {
706 0 : if ( aPropSeq[n].Name == "Name" )
707 0 : bSetName = (aPropSeq[n].Value >>= aName);
708 0 : else if ( aPropSeq[n].Name == "FillBitmapURL" )
709 0 : bSetURL = (aPropSeq[n].Value >>= aURL);
710 0 : else if ( aPropSeq[n].Name == "Bitmap" )
711 0 : bSetBitmap = (aPropSeq[n].Value >>= xBmp);
712 : }
713 0 : }
714 : }
715 :
716 0 : if( bSetName )
717 : {
718 0 : SetName( aName );
719 : }
720 0 : if( bSetURL )
721 : {
722 0 : GraphicObject aGrafObj( GraphicObject::CreateGraphicObjectFromURL( aURL ) );
723 0 : XOBitmap aBMP( aGrafObj );
724 0 : SetBitmapValue( aBMP );
725 : }
726 0 : if( bSetBitmap )
727 : {
728 0 : Bitmap aInput;
729 0 : if ( xBmp.is() )
730 : {
731 0 : BitmapEx aInputEx( VCLUnoHelper::GetBitmap( xBmp ) );
732 0 : aInput = aInputEx.GetBitmap();
733 : }
734 0 : else if ( xGraphic.is() )
735 : {
736 0 : Graphic aGraphic( xGraphic );
737 0 : aInput = aGraphic.GetBitmap();
738 : }
739 :
740 : // note: aXOBitmap is the member bitmap
741 0 : aXOBitmap.SetBitmap( aInput );
742 0 : aXOBitmap.SetBitmapType(XBITMAP_IMPORT);
743 :
744 0 : if(aInput.GetSizePixel().Width() == 8
745 0 : && aInput.GetSizePixel().Height() == 8
746 0 : && aInput.GetColorCount() == 2)
747 : {
748 0 : aXOBitmap.Bitmap2Array();
749 0 : aXOBitmap.SetBitmapType(XBITMAP_8X8);
750 0 : aXOBitmap.SetPixelSize(aInput.GetSizePixel());
751 0 : }
752 : }
753 :
754 0 : return (bSetName || bSetURL || bSetBitmap);
755 : }
756 :
757 0 : sal_Bool XFillBitmapItem::CompareValueFunc( const NameOrIndex* p1, const NameOrIndex* p2 )
758 : {
759 0 : return ((XFillBitmapItem*)p1)->GetBitmapValue().GetGraphicObject().GetUniqueID() ==
760 0 : ((XFillBitmapItem*)p2)->GetBitmapValue().GetGraphicObject().GetUniqueID();
761 : }
762 :
763 0 : XFillBitmapItem* XFillBitmapItem::checkForUniqueItem( SdrModel* pModel ) const
764 : {
765 0 : if( pModel )
766 : {
767 : const String aUniqueName = NameOrIndex::CheckNamedItem(
768 0 : this, XATTR_FILLBITMAP, &pModel->GetItemPool(),
769 0 : pModel->GetStyleSheetPool() ? &pModel->GetStyleSheetPool()->GetPool() : NULL,
770 : XFillBitmapItem::CompareValueFunc, RID_SVXSTR_BMP21,
771 0 : pModel->GetPropertyList( XBITMAP_LIST ) );
772 :
773 : // if the given name is not valid, replace it!
774 0 : if( aUniqueName != GetName() )
775 0 : return new XFillBitmapItem( aUniqueName, aXOBitmap );
776 : }
777 :
778 0 : return (XFillBitmapItem*)this;
779 : }
780 :
781 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
