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