?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Update ooo320-m1
[ooovba.git] / svx / source / cui / backgrnd.cxx
blobf297f052e864ba632ed45d97fee5252958c703df
1 /*************************************************************************
2 *
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * Copyright 2008 by Sun Microsystems, Inc.
6 *
7 * OpenOffice.org - a multi-platform office productivity suite
8 *
9 * $RCSfile: backgrnd.cxx,v $
10 * $Revision: 1.39 $
11 *
12 * This file is part of OpenOffice.org.
13 *
14 * OpenOffice.org is free software: you can redistribute it and/or modify
15 * it under the terms of the GNU Lesser General Public License version 3
16 * only, as published by the Free Software Foundation.
17 *
18 * OpenOffice.org is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU Lesser General Public License version 3 for more details
22 * (a copy is included in the LICENSE file that accompanied this code).
23 *
24 * You should have received a copy of the GNU Lesser General Public License
25 * version 3 along with OpenOffice.org. If not, see
26 * <http://www.openoffice.org/license.html>
27 * for a copy of the LGPLv3 License.
28 *
29 ************************************************************************/
30
31 // MARKER(update_precomp.py): autogen include statement, do not remove
32 #include "precompiled_svx.hxx"
33
34 #ifdef SVX_DLLIMPLEMENTATION
35 #undef SVX_DLLIMPLEMENTATION
36 #endif
37
38 // include ---------------------------------------------------------------
39 #include <svtools/pathoptions.hxx>
40 #include <svtools/intitem.hxx>
41 #include <vcl/msgbox.hxx>
42 #include <tools/urlobj.hxx>
43 #include <sfx2/objsh.hxx>
44 #include <sfx2/docfile.hxx>
45 #include <svtools/wallitem.hxx>
46 #include <svtools/cntwall.hxx>
47 #ifndef _CNTIDS_HRC
48 #include <sfx2/cntids.hrc>
49 #endif
50
51 #define _SVX_BACKGRND_CXX
52
53 #include <svx/dialogs.hrc>
54 #include "backgrnd.hrc"
55 #include <svx/svxitems.hrc>
56
57
58
59
60 // Tabellenhintergrund
61 #define TBL_DEST_CELL 0
62 #define TBL_DEST_ROW 1
63 #define TBL_DEST_TBL 2
64
65 #include <svx/brshitem.hxx>
66 #include "backgrnd.hxx"
67
68 #include <svx/xtable.hxx>
69 #include "opengrf.hxx"
70 #include "impgrf.hxx"
71 #include "svxerr.hxx"
72 #include "drawitem.hxx"
73 #include <svx/dialmgr.hxx>
74 #include "htmlmode.hxx"
75 #ifndef _SVT_CONTROLDIMS_HRC_
76 #include <svtools/controldims.hrc>
77 #endif
78 #include <svx/svxids.hrc> //CHINA001
79 #include "flagsdef.hxx" //CHINA001
80 #include <svtools/intitem.hxx> //CHINA001
81 #include <sfx2/request.hxx> //CHINA001
82 using namespace ::com::sun::star;
83 // static ----------------------------------------------------------------
84
85 static USHORT pRanges[] =
86 {
87 SID_VIEW_FLD_PIC, SID_VIEW_FLD_PIC,
88 SID_ATTR_BRUSH, SID_ATTR_BRUSH,
89 SID_ATTR_BRUSH_CHAR, SID_ATTR_BRUSH_CHAR,
90 0
91 };
92
93 struct SvxBackgroundTable_Impl
94 {
95 SvxBrushItem* pCellBrush;
96 SvxBrushItem* pRowBrush;
97 SvxBrushItem* pTableBrush;
98 USHORT nCellWhich;
99 USHORT nRowWhich;
100 USHORT nTableWhich;
101 USHORT nActPos;
102
103 SvxBackgroundTable_Impl() :
104 pCellBrush(NULL), pRowBrush(NULL), pTableBrush(NULL),
105 nCellWhich(0), nRowWhich(0), nTableWhich(0) {}
106 };
107
108 struct SvxBackgroundPara_Impl
109 {
110 SvxBrushItem* pParaBrush;
111 SvxBrushItem* pCharBrush;
112
113 USHORT nActPos;
114
115 SvxBackgroundPara_Impl() :
116 pParaBrush(NULL), pCharBrush(NULL) {}
117 };
118
119 struct SvxBackgroundPage_Impl
120 {
121 Timer* pLoadTimer;
122 BOOL bIsImportDlgInExecute;
123
124 SvxBackgroundPage_Impl() :
125 pLoadTimer(NULL), bIsImportDlgInExecute(FALSE) {}
126 };
127 /* -----------------------------15.08.2002 12:21------------------------------
128
129 ---------------------------------------------------------------------------*/
130 inline BYTE lcl_PercentToTransparency(long nPercent)
131 {
132 //0xff must not be returned!
133 return BYTE(nPercent ? (50 + 0xfe * nPercent) / 100 : 0);
134 }
135 inline BYTE lcl_TransparencyToPercent(BYTE nTrans)
136 {
137 return (nTrans * 100 + 127) / 254;
138 }
139 void lcl_SetTransparency(SvxBrushItem& rBrush, long nTransparency)
140 {
141 uno::Any aTransparency;
142 aTransparency <<= (sal_Int8)nTransparency;
143 rBrush.PutValue(aTransparency, MID_GRAPHIC_TRANSPARENCY);
144 }
145 //-------------------------------------------------------------------------
146
147 /* [Beschreibung]
148
149 */
150
151 USHORT GetItemId_Impl( ValueSet& rValueSet, const Color& rCol )
152 {
153 BOOL bFound = FALSE;
154 USHORT nCount = rValueSet.GetItemCount();
155 USHORT n = 1;
156
157 while ( !bFound && n <= nCount )
158 {
159 Color aValCol = rValueSet.GetItemColor(n);
160
161 bFound = ( aValCol.GetRed() == rCol.GetRed()
162 && aValCol.GetGreen() == rCol.GetGreen()
163 && aValCol.GetBlue() == rCol.GetBlue() );
164
165 if ( !bFound )
166 n++;
167 }
168 return bFound ? n : 0;
169 }
170
171 // class BackgroundPreview -----------------------------------------------
172
173 /* [Beschreibung]
174
175 Vorschaufenster f"ur Brush oder Bitmap
176 */
177
178 class BackgroundPreviewImpl : public Window
179 {
180 public:
181 BackgroundPreviewImpl( Window* pParent,
182 const ResId& rResId, BOOL bIsBmpPreview );
183 ~BackgroundPreviewImpl();
184
185 void NotifyChange( const Color& rColor );
186 void NotifyChange( const Bitmap* pBitmap );
187
188 protected:
189 virtual void Paint( const Rectangle& rRect );
190 virtual void DataChanged( const DataChangedEvent& rDCEvt );
191
192 private:
193 const BOOL bIsBmp;
194 Bitmap* pBitmap;
195 Point aDrawPos;
196 Size aDrawSize;
197 Rectangle aDrawRect;
198 BYTE nTransparency;
199 };
200
201 //-----------------------------------------------------------------------
202
203 BackgroundPreviewImpl::BackgroundPreviewImpl
204 (
205 Window* pParent,
206 const ResId& rResId,
207 BOOL bIsBmpPreview
208 ) :
209
210 /* [Beschreibung]
211
212 */
213
214 Window( pParent, rResId ),
215
216 bIsBmp ( bIsBmpPreview ),
217 pBitmap ( NULL ),
218 aDrawRect( Point(0,0), GetOutputSizePixel() ),
219 nTransparency(0)
220
221 {
222 SetBorderStyle(WINDOW_BORDER_MONO);
223 Paint( aDrawRect );
224 }
225
226 //-----------------------------------------------------------------------
227
228 BackgroundPreviewImpl::~BackgroundPreviewImpl()
229
230 /* [Beschreibung]
231
232 */
233
234 {
235 delete pBitmap;
236 }
237
238 //-----------------------------------------------------------------------
239 void BackgroundPreviewImpl::NotifyChange( const Color& rColor )
240 {
241 if ( !bIsBmp )
242 {
243 const static Color aTranspCol( COL_TRANSPARENT );
244
245 nTransparency = lcl_TransparencyToPercent( rColor.GetTransparency() );
246
247 SetFillColor( rColor == aTranspCol ? GetSettings().GetStyleSettings().GetFieldColor() : (Color) rColor.GetRGBColor() );
248 Paint( aDrawRect );
249 }
250 }
251
252 //-----------------------------------------------------------------------
253
254 void BackgroundPreviewImpl::NotifyChange( const Bitmap* pNewBitmap )
255 /* [Beschreibung]
256
257 */
258
259 {
260 if ( bIsBmp && (pNewBitmap || pBitmap) )
261 {
262 if ( pNewBitmap && pBitmap )
263 *pBitmap = *pNewBitmap;
264 else if ( pNewBitmap && !pBitmap )
265 pBitmap = new Bitmap( *pNewBitmap );
266 else if ( !pNewBitmap )
267 DELETEZ( pBitmap );
268
269 if ( pBitmap )
270 {
271 Size aSize = GetOutputSizePixel();
272 // InnerSize == Size without one pixel border
273 Size aInnerSize = aSize;
274 aInnerSize.Width() -= 2;
275 aInnerSize.Height() -= 2;
276 aDrawSize = pBitmap->GetSizePixel();
277
278 // bitmap bigger than preview window?
279 if ( aDrawSize.Width() > aInnerSize.Width() )
280 {
281 aDrawSize.Height() = aDrawSize.Height() * aInnerSize.Width() / aDrawSize.Width();
282 if ( aDrawSize.Height() > aInnerSize.Height() )
283 {
284 aDrawSize.Width() = aDrawSize.Height();
285 aDrawSize.Height() = aInnerSize.Height();
286 }
287 else
288 aDrawSize.Width() = aInnerSize.Width();
289 }
290 else if ( aDrawSize.Height() > aInnerSize.Height() )
291 {
292 aDrawSize.Width() = aDrawSize.Width() * aInnerSize.Height() / aDrawSize.Height();
293 if ( aDrawSize.Width() > aInnerSize.Width() )
294 {
295 aDrawSize.Height() = aDrawSize.Width();
296 aDrawSize.Width() = aInnerSize.Width();
297 }
298 else
299 aDrawSize.Height() = aInnerSize.Height();
300 }
301
302 aDrawPos.X() = (aSize.Width() - aDrawSize.Width()) / 2;
303 aDrawPos.Y() = (aSize.Height() - aDrawSize.Height()) / 2;
304 }
305 Invalidate( aDrawRect );
306 Update();
307 }
308 }
309
310 //-----------------------------------------------------------------------
311
312 void BackgroundPreviewImpl::Paint( const Rectangle& )
313 {
314 const StyleSettings& rStyleSettings = GetSettings().GetStyleSettings();
315 SetBackground(Wallpaper(rStyleSettings.GetWindowColor()));
316 SetLineColor();
317 if(bIsBmp)
318 SetFillColor( Color(COL_TRANSPARENT) );
319 DrawRect( aDrawRect );
320 if ( bIsBmp )
321 {
322 if ( pBitmap )
323 DrawBitmap( aDrawPos, aDrawSize, *pBitmap );
324 else
325 {
326 Size aSize = GetOutputSizePixel();
327 DrawLine( Point(0,0), Point(aSize.Width(),aSize.Height()) );
328 DrawLine( Point(0,aSize.Height()), Point(aSize.Width(),0) );
329 }
330 }
331 }
332 /* -----------------------------27.02.2002 11:07------------------------------
333
334 ---------------------------------------------------------------------------*/
335 void BackgroundPreviewImpl::DataChanged( const DataChangedEvent& rDCEvt )
336 {
337 if ( (rDCEvt.GetType() == DATACHANGED_SETTINGS) &&
338 (rDCEvt.GetFlags() & SETTINGS_STYLE) )
339 {
340 Invalidate();
341 }
342 Window::DataChanged( rDCEvt );
343 }
344
345 // class SvxBackgroundTabPage --------------------------------------------
346
347 #define HDL(hdl) LINK(this,SvxBackgroundTabPage,hdl)
348
349 SvxBackgroundTabPage::SvxBackgroundTabPage( Window* pParent,
350 const SfxItemSet& rCoreSet ) :
351
352 /* [Beschreibung]
353
354 */
355
356 SvxTabPage( pParent, SVX_RES( RID_SVXPAGE_BACKGROUND ), rCoreSet ),
357
358 aBorderWin ( this, SVX_RES(CT_BORDER) ),
359 aBackgroundColorSet ( &aBorderWin, SVX_RES( SET_BGDCOLOR ) ),
360 aBackgroundColorBox ( this, SVX_RES( GB_BGDCOLOR ) ),
361 pPreviewWin1 ( new BackgroundPreviewImpl(
362 this, SVX_RES( WIN_PREVIEW1 ), FALSE ) ),
363 aColTransFT ( this, SVX_RES( FT_COL_TRANS ) ),
364 aColTransMF ( this, SVX_RES( MF_COL_TRANS ) ),
365 aBtnBrowse ( this, SVX_RES( BTN_BROWSE ) ),
366 aBtnLink ( this, SVX_RES( BTN_LINK ) ),
367 aBtnPreview ( this, SVX_RES( BTN_PREVIEW ) ),
368 aFtFile ( this, SVX_RES( FT_FILE ) ),
369 aGbFile ( this, SVX_RES( GB_FILE ) ),
370 aBtnPosition ( this, SVX_RES( BTN_POSITION ) ),
371 aBtnArea ( this, SVX_RES( BTN_AREA ) ),
372 aBtnTile ( this, SVX_RES( BTN_TILE ) ),
373 aWndPosition ( this, SVX_RES( WND_POSITION ), RP_MM ),
374 aGbPosition ( this, SVX_RES( GB_POSITION ) ),
375 aGraphTransFL ( this, SVX_RES( FL_GRAPH_TRANS ) ),
376 aGraphTransMF ( this, SVX_RES( MF_GRAPH_TRANS ) ),
377 pPreviewWin2 ( new BackgroundPreviewImpl(
378 this, SVX_RES( WIN_PREVIEW2 ), TRUE ) ),
379 aSelectTxt ( this, SVX_RES( FT_SELECTOR ) ),
380 aLbSelect ( this, SVX_RES( LB_SELECTOR ) ),
381 aStrBrowse ( SVX_RES( STR_BROWSE ) ),
382 aStrUnlinked ( SVX_RES( STR_UNLINKED ) ),
383 aTblDesc ( this, SVX_RES( FT_TBL_DESC ) ),
384 aTblLBox ( this, SVX_RES( LB_TBL_BOX ) ),
385 aParaLBox ( this, SVX_RES( LB_PARA_BOX ) ),
386 nHtmlMode ( 0 ),
387 bAllowShowSelector ( TRUE ),
388 bIsGraphicValid ( FALSE ),
389 bLinkOnly ( FALSE ),
390 bResized ( FALSE ),
391 bColTransparency ( FALSE ),
392 bGraphTransparency ( FALSE ),
393
394 pPageImpl ( new SvxBackgroundPage_Impl ),
395 pImportDlg ( NULL ),
396 pTableBck_Impl ( NULL ),
397 pParaBck_Impl ( NULL )
398
399 {
400 // diese Page braucht ExchangeSupport
401 SetExchangeSupport();
402
403 const SfxPoolItem* pItem;
404 SfxObjectShell* pShell;
405
406 if ( SFX_ITEM_SET == rCoreSet.GetItemState( SID_HTML_MODE, FALSE, &pItem )
407 || ( 0 != ( pShell = SfxObjectShell::Current()) &&
408 0 != ( pItem = pShell->GetItem( SID_HTML_MODE ) ) ) )
409 {
410 nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
411 }
412
413 FillColorValueSets_Impl();
414
415 aBackgroundColorSet.SetSelectHdl( HDL(BackgroundColorHdl_Impl) );
416 FreeResource();
417 }
418
419 //------------------------------------------------------------------------
420
421 SvxBackgroundTabPage::~SvxBackgroundTabPage()
422
423 /* [Beschreibung]
424
425 */
426
427 {
428 delete pPreviewWin1;
429 delete pPreviewWin2;
430 delete pPageImpl->pLoadTimer;
431 delete pPageImpl;
432 delete pImportDlg;
433
434 if( pTableBck_Impl)
435 {
436 delete pTableBck_Impl->pCellBrush;
437 delete pTableBck_Impl->pRowBrush;
438 delete pTableBck_Impl->pTableBrush;
439 delete pTableBck_Impl;
440 }
441
442 if(pParaBck_Impl)
443 {
444 delete pParaBck_Impl->pParaBrush;
445 delete pParaBck_Impl->pCharBrush;
446 delete pParaBck_Impl;
447 }
448 }
449
450 //------------------------------------------------------------------------
451
452 USHORT* SvxBackgroundTabPage::GetRanges()
453
454 /* [Beschreibung]
455
456 gibt den Bereich der Which-Werte zur"uck
457 */
458
459 {
460 return pRanges;
461 }
462
463 //------------------------------------------------------------------------
464
465 SfxTabPage* SvxBackgroundTabPage::Create( Window* pParent,
466 const SfxItemSet& rAttrSet )
467
468 /* [Beschreibung]
469
470 Create-Methode f"ur den TabDialog
471 */
472
473 {
474 return ( new SvxBackgroundTabPage( pParent, rAttrSet ) );
475 }
476
477 //------------------------------------------------------------------------
478
479 void SvxBackgroundTabPage::Reset( const SfxItemSet& rSet )
480
481 /* [Beschreibung]
482
483 */
484
485 {
486 // os: So ein Unsinn! Irgendwo laesst sich so ein Item immer finden,
487 // es muss aber im rSet vorhanden sein!
488 // const SfxPoolItem* pX = GetOldItem( rSet, SID_VIEW_FLD_PIC );
489 // if( pX && pX->ISA(SfxWallpaperItem))
490 if(SFX_ITEM_AVAILABLE <= rSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), FALSE))
491 {
492 ResetFromWallpaperItem( rSet );
493 return;
494 }
495
496 // Zustand des Vorschau-Buttons durch UserData persistent
497 String aUserData = GetUserData();
498 aBtnPreview.Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) );
499
500 // nach Reset kein ShowSelector() mehr aufrufen d"urfen
501 bAllowShowSelector = FALSE;
502
503
504 // Input-BrushItem besorgen und auswerten
505 const SvxBrushItem* pBgdAttr = NULL;
506 USHORT nSlot = SID_ATTR_BRUSH;
507 const SfxPoolItem* pItem;
508 USHORT nDestValue = USHRT_MAX;
509
510 if ( SFX_ITEM_SET == rSet.GetItemState( SID_BACKGRND_DESTINATION,
511 FALSE, &pItem ) )
512 {
513 nDestValue = ((const SfxUInt16Item*)pItem)->GetValue();
514 aTblLBox.SelectEntryPos(nDestValue);
515
516 switch ( nDestValue )
517 {
518 case TBL_DEST_CELL:
519 nSlot = SID_ATTR_BRUSH;
520 break;
521 case TBL_DEST_ROW:
522 nSlot = SID_ATTR_BRUSH_ROW;
523 break;
524 case TBL_DEST_TBL:
525 nSlot = SID_ATTR_BRUSH_TABLE;
526 break;
527 }
528 }
529 else if( SFX_ITEM_SET == rSet.GetItemState(
530 SID_PARA_BACKGRND_DESTINATION, FALSE, &pItem ) )
531 {
532 nDestValue = ((const SfxUInt16Item*)pItem)->GetValue();
533 // ist gerade Zeichen aktiviert?
534 USHORT nParaSel = aParaLBox.GetSelectEntryPos();
535 if(1 == nParaSel)
536 {
537 // dann war das ein "Standard" - Aufruf
538 nDestValue = nParaSel;
539 }
540 aParaLBox.SelectEntryPos(nDestValue);
541
542 switch ( nDestValue )
543 {
544 case PARA_DEST_PARA:
545 nSlot = SID_ATTR_BRUSH;
546 break;
547 case PARA_DEST_CHAR:
548 nSlot = SID_ATTR_BRUSH_CHAR;
549 break;
550 }
551 }
552 //#111173# the destination item is missing when the parent style has been changed
553 if(USHRT_MAX == nDestValue && (aParaLBox.IsVisible()||aTblLBox.IsVisible()))
554 nDestValue = 0;
555 USHORT nWhich = GetWhich( nSlot );
556
557 if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
558 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
559
560 aBtnTile.Check();
561
562 if ( pBgdAttr )
563 {
564 FillControls_Impl(*pBgdAttr, aUserData);
565 aBgdColor = ( (SvxBrushItem*)pBgdAttr )->GetColor();
566 }
567 else
568 {
569 aSelectTxt.Hide();
570 aLbSelect.Hide();
571 aLbSelect.SelectEntryPos( 0 );
572 ShowColorUI_Impl();
573
574 const SfxPoolItem* pOld = GetOldItem( rSet, SID_ATTR_BRUSH );
575
576 if ( pOld )
577 aBgdColor = ( (SvxBrushItem*)pOld )->GetColor();
578 }
579
580 if ( nDestValue != USHRT_MAX )
581 {
582 if(aTblLBox.IsVisible())
583 {
584 USHORT nValue = aTblLBox.GetSelectEntryPos();
585
586 if ( pTableBck_Impl )
587 {
588 DELETEZ( pTableBck_Impl->pCellBrush);
589 DELETEZ( pTableBck_Impl->pRowBrush);
590 DELETEZ( pTableBck_Impl->pTableBrush);
591 }
592 else
593 pTableBck_Impl = new SvxBackgroundTable_Impl();
594
595 pTableBck_Impl->nActPos = nValue;
596
597 nWhich = GetWhich( SID_ATTR_BRUSH );
598 if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
599 {
600 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
601 pTableBck_Impl->pCellBrush = new SvxBrushItem(*pBgdAttr);
602 }
603 pTableBck_Impl->nCellWhich = nWhich;
604
605 if ( rSet.GetItemState( SID_ATTR_BRUSH_ROW, FALSE ) >= SFX_ITEM_AVAILABLE )
606 {
607 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_ROW ) );
608 pTableBck_Impl->pRowBrush = new SvxBrushItem(*pBgdAttr);
609 }
610 pTableBck_Impl->nRowWhich = SID_ATTR_BRUSH_ROW;
611
612 if ( rSet.GetItemState( SID_ATTR_BRUSH_TABLE, FALSE ) >= SFX_ITEM_AVAILABLE )
613 {
614 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( SID_ATTR_BRUSH_TABLE ) );
615 pTableBck_Impl->pTableBrush = new SvxBrushItem(*pBgdAttr);
616 }
617 pTableBck_Impl->nTableWhich = SID_ATTR_BRUSH_TABLE;
618
619 TblDestinationHdl_Impl(&aTblLBox);
620 aTblLBox.SaveValue();
621 }
622 else
623 {
624 USHORT nValue = aParaLBox.GetSelectEntryPos();
625
626 if ( pParaBck_Impl )
627 {
628 delete pParaBck_Impl->pParaBrush;
629 delete pParaBck_Impl->pCharBrush;
630 }
631 else
632 pParaBck_Impl = new SvxBackgroundPara_Impl();
633
634 pParaBck_Impl->nActPos = nValue;
635
636 nWhich = GetWhich( SID_ATTR_BRUSH );
637 if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
638 {
639 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
640 pParaBck_Impl->pParaBrush = new SvxBrushItem(*pBgdAttr);
641 }
642
643 nWhich = GetWhich( SID_ATTR_BRUSH_CHAR );
644 SfxItemState eState = rSet.GetItemState( nWhich, TRUE );
645 eState = rSet.GetItemState( nWhich, FALSE );
646 if ( rSet.GetItemState( nWhich, TRUE ) > SFX_ITEM_AVAILABLE )
647 {
648 pBgdAttr = (const SvxBrushItem*)&( rSet.Get( nWhich ) );
649 pParaBck_Impl->pCharBrush = new SvxBrushItem(*pBgdAttr);
650 }
651 else
652 pParaBck_Impl->pCharBrush = new SvxBrushItem(SID_ATTR_BRUSH_CHAR);
653
654 ParaDestinationHdl_Impl(&aParaLBox);
655 aParaLBox.SaveValue();
656 }
657 }
658 if(!bResized)
659 {
660 if(!aLbSelect.IsVisible() && !aTblLBox.IsVisible() && !aParaLBox.IsVisible())
661 {
662 long nY(LogicToPixel(Point(11,14), MAP_APPFONT).X());
663 long nX(LogicToPixel(Point(11,14), MAP_APPFONT).Y());
664 Point aPos(aBorderWin.GetPosPixel());
665 aPos.X() = nX;
666 aPos.Y() = nY;
667 aBorderWin.SetPosPixel(aPos);
668 aPos = pPreviewWin1->GetPosPixel();
669 aPos.Y() = nY;
670 pPreviewWin1->SetPosPixel(aPos);
671 aBackgroundColorBox.Hide();
672 }
673 }
674 }
675
676 void SvxBackgroundTabPage::ResetFromWallpaperItem( const SfxItemSet& rSet )
677 {
678 ShowSelector();
679
680 // Zustand des Vorschau-Buttons durch UserData persistent
681 String aUserData = GetUserData();
682 aBtnPreview.Check( aUserData.Len() && sal_Unicode('1') == aUserData.GetChar( 0 ) );
683
684 // Input-BrushItem besorgen und auswerten
685 const SvxBrushItem* pBgdAttr = NULL;
686 USHORT nSlot = SID_VIEW_FLD_PIC;
687 USHORT nWhich = GetWhich( nSlot );
688 SvxBrushItem* pTemp = 0;
689 const CntWallpaperItem* pItem = 0;
690
691 if ( rSet.GetItemState( nWhich, FALSE ) >= SFX_ITEM_AVAILABLE )
692 {
693 pItem = (const CntWallpaperItem*)&rSet.Get( nWhich );
694 pTemp = new SvxBrushItem( *pItem, nWhich );
695 pBgdAttr = pTemp;
696 }
697
698 aBtnTile.Check();
699
700 if ( pBgdAttr )
701 {
702 FillControls_Impl(*pBgdAttr, aUserData);
703 // Auch bei Anzeige der Grafik, soll die Brush erhalten bleiben
704 if( aBgdColor != pBgdAttr->GetColor() )
705 {
706 aBgdColor = pBgdAttr->GetColor();
707 USHORT nCol = GetItemId_Impl( aBackgroundColorSet, aBgdColor );
708 aBackgroundColorSet.SelectItem( nCol );
709 pPreviewWin1->NotifyChange( aBgdColor );
710 }
711 }
712 else
713 {
714 aLbSelect.SelectEntryPos( 0 );
715 ShowColorUI_Impl();
716
717 const SfxPoolItem* pOld = GetOldItem( rSet, SID_VIEW_FLD_PIC );
718 if ( pOld )
719 aBgdColor = Color( ((CntWallpaperItem*)pOld)->GetColor() );
720 }
721
722 // We now have always a link to the background
723 bLinkOnly = TRUE;
724 aBtnLink.Check( TRUE );
725 aBtnLink.Show( FALSE );
726 // if( !pItem || !pItem->GetWallpaper(FALSE).IsBitmap() )
727 // aBtnLink.Check();
728
729 delete pTemp;
730 }
731
732
733
734 //------------------------------------------------------------------------
735
736 void SvxBackgroundTabPage::FillUserData()
737
738 /* [Beschreibung]
739
740 Beim Destruieren einer SfxTabPage wird diese virtuelle Methode gerufen,
741 damit die TabPage interne Informationen sichern kann.
742
743 In diesem Fall wird der Zustand des Vorschau-Buttons gesichert.
744 */
745
746 {
747 SetUserData( String( aBtnPreview.IsChecked() ? sal_Unicode('1') : sal_Unicode('0') ) );
748 }
749
750 //------------------------------------------------------------------------
751
752 BOOL SvxBackgroundTabPage::FillItemSet( SfxItemSet& rCoreSet )
753
754 /* [Beschreibung]
755
756 */
757
758 {
759 if ( pPageImpl->pLoadTimer && pPageImpl->pLoadTimer->IsActive() )
760 {
761 pPageImpl->pLoadTimer->Stop();
762 LoadTimerHdl_Impl( pPageImpl->pLoadTimer );
763 }
764 // os: So ein Unsinn! Irgendwo laesst sich so ein Item immer finden,
765 // es muss aber im rSet vorhanden sein!
766
767 // const SfxPoolItem* pX = GetOldItem( rCoreSet, SID_VIEW_FLD_PIC );
768 // if( pX && pX->ISA(SfxWallpaperItem))
769 if(SFX_ITEM_AVAILABLE <= rCoreSet.GetItemState(GetWhich(SID_VIEW_FLD_PIC), FALSE))
770 return FillItemSetWithWallpaperItem( rCoreSet, SID_VIEW_FLD_PIC );
771
772 BOOL bModified = FALSE;
773 USHORT nSlot = SID_ATTR_BRUSH;
774
775 if ( aTblLBox.IsVisible() )
776 {
777 switch( aTblLBox.GetSelectEntryPos() )
778 {
779 case TBL_DEST_CELL:
780 nSlot = SID_ATTR_BRUSH;
781 break;
782 case TBL_DEST_ROW:
783 nSlot = SID_ATTR_BRUSH_ROW;
784 break;
785 case TBL_DEST_TBL:
786 nSlot = SID_ATTR_BRUSH_TABLE;
787 break;
788 }
789 }
790 else if(aParaLBox.GetData() == &aParaLBox)
791 {
792 switch(aParaLBox.GetSelectEntryPos())
793 {
794 case PARA_DEST_PARA:
795 nSlot = SID_ATTR_BRUSH;
796 break;
797 case PARA_DEST_CHAR:
798 nSlot = SID_ATTR_BRUSH_CHAR;
799 break;
800 }
801 }
802 USHORT nWhich = GetWhich( nSlot );
803
804 const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot );
805 SfxItemState eOldItemState = rCoreSet.GetItemState(nSlot, FALSE);
806 const SfxItemSet& rOldSet = GetItemSet();
807
808 BOOL bGraphTransparencyChanged = bGraphTransparency && (aGraphTransMF.GetText() != aGraphTransMF.GetSavedValue());
809 if ( pOld )
810 {
811 const SvxBrushItem& rOldItem = (const SvxBrushItem&)*pOld;
812 SvxGraphicPosition eOldPos = rOldItem.GetGraphicPos();
813 const BOOL bIsBrush = ( 0 == aLbSelect.GetSelectEntryPos() );
814
815 // transparency has to be set if enabled, the color not already set to "No fill" and
816 if( bColTransparency &&
817 aBgdColor.GetTransparency() < 0xff)
818 {
819 aBgdColor.SetTransparency(lcl_PercentToTransparency(static_cast<long>(aColTransMF.GetValue())));
820 }
821 if ( ( (GPOS_NONE == eOldPos) && bIsBrush )
822 || ( (GPOS_NONE != eOldPos) && !bIsBrush ) ) // Brush <-> Bitmap gewechselt?
823 {
824 // Hintergrund-Art wurde nicht gewechselt:
825
826 if ( (GPOS_NONE == eOldPos) || !aLbSelect.IsVisible() )
827 {
828 // Brush-Behandlung:
829 if ( rOldItem.GetColor() != aBgdColor ||
830 (SFX_ITEM_AVAILABLE >= eOldItemState && !aBackgroundColorSet.IsNoSelection()))
831 {
832 bModified = TRUE;
833 rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
834 }
835 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
836 rCoreSet.ClearItem( nWhich );
837 }
838 else
839 {
840 // Bitmap-Behandlung:
841
842 SvxGraphicPosition eNewPos = GetGraphicPosition_Impl();
843 const BOOL bIsLink = aBtnLink.IsChecked();
844 const BOOL bWasLink = (NULL != rOldItem.GetGraphicLink() );
845
846
847 if ( !bIsLink && !bIsGraphicValid )
848 bIsGraphicValid = LoadLinkedGraphic_Impl();
849
850 if ( bGraphTransparencyChanged ||
851 eNewPos != eOldPos
852 || bIsLink != bWasLink
853 || ( bWasLink && *rOldItem.GetGraphicLink()
854 != aBgdGraphicPath )
855 || ( !bWasLink && rOldItem.GetGraphic()->GetBitmap()
856 != aBgdGraphic.GetBitmap() )
857 )
858 {
859 bModified = TRUE;
860
861 SvxBrushItem aTmpBrush(nWhich);
862 if ( bIsLink )
863 {
864 aTmpBrush = SvxBrushItem( aBgdGraphicPath,
865 aBgdGraphicFilter,
866 eNewPos,
867 nWhich );
868 }
869 else
870 aTmpBrush = SvxBrushItem( aBgdGraphic,
871 eNewPos,
872 nWhich );
873 lcl_SetTransparency(aTmpBrush, static_cast<long>(aGraphTransMF.GetValue()));
874
875 rCoreSet.Put(aTmpBrush);
876 }
877 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
878 rCoreSet.ClearItem( nWhich );
879 }
880 }
881 else // Brush <-> Bitmap gewechselt!
882 {
883 if ( bIsBrush )
884 rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
885 else
886 {
887 SvxBrushItem* pTmpBrush = 0;
888 if ( aBtnLink.IsChecked() )
889 {
890 pTmpBrush = new SvxBrushItem( aBgdGraphicPath,
891 aBgdGraphicFilter,
892 GetGraphicPosition_Impl(),
893 nWhich );
894 }
895 else
896 {
897 if ( !bIsGraphicValid )
898 bIsGraphicValid = LoadLinkedGraphic_Impl();
899
900 if ( bIsGraphicValid )
901 pTmpBrush = new SvxBrushItem( aBgdGraphic,
902 GetGraphicPosition_Impl(),
903 nWhich );
904 }
905 if(pTmpBrush)
906 {
907 lcl_SetTransparency(*pTmpBrush, static_cast<long>(aGraphTransMF.GetValue()));
908 rCoreSet.Put(*pTmpBrush);
909 delete pTmpBrush;
910 }
911 }
912 bModified = ( bIsBrush || aBtnLink.IsChecked() || bIsGraphicValid );
913 }
914 }
915 else if ( SID_ATTR_BRUSH_CHAR == nSlot && aBgdColor != Color( COL_WHITE ) )
916 {
917 rCoreSet.Put( SvxBrushItem( aBgdColor, nWhich ) );
918 bModified = TRUE;
919 }
920
921 if( aTblLBox.IsVisible() )
922 {
923 // Der aktuelle Zustand wurde bereits geputtet
924 if( nSlot != SID_ATTR_BRUSH && pTableBck_Impl->pCellBrush)
925 {
926 const SfxPoolItem* pOldCell =
927 GetOldItem( rCoreSet, SID_ATTR_BRUSH );
928
929 if ( *pTableBck_Impl->pCellBrush != *pOldCell )
930 {
931 rCoreSet.Put( *pTableBck_Impl->pCellBrush );
932 bModified |= TRUE;
933 }
934 }
935
936 if( nSlot != SID_ATTR_BRUSH_ROW && pTableBck_Impl->pRowBrush)
937 {
938 const SfxPoolItem* pOldRow =
939 GetOldItem( rCoreSet, SID_ATTR_BRUSH_ROW );
940
941 if ( *pTableBck_Impl->pRowBrush != *pOldRow )
942 {
943 rCoreSet.Put( *pTableBck_Impl->pRowBrush );
944 bModified |= TRUE;
945 }
946 }
947
948 if( nSlot != SID_ATTR_BRUSH_TABLE && pTableBck_Impl->pTableBrush)
949 {
950 const SfxPoolItem* pOldTable =
951 GetOldItem( rCoreSet, SID_ATTR_BRUSH_TABLE );
952
953 if ( *pTableBck_Impl->pTableBrush != *pOldTable )
954 {
955 rCoreSet.Put( *pTableBck_Impl->pTableBrush );
956 bModified |= TRUE;
957 }
958 }
959
960 if( aTblLBox.GetSavedValue() != aTblLBox.GetSelectEntryPos() )
961 {
962 rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION,
963 aTblLBox.GetSelectEntryPos() ) );
964 bModified |= TRUE;
965 }
966 }
967 else if(aParaLBox.GetData() == &aParaLBox)
968 {
969 // Der aktuelle Zustand wurde bereits geputtet
970 if( nSlot != SID_ATTR_BRUSH && aParaLBox.IsVisible()) // nicht im Suchen-Format-Dialog
971 {
972 const SfxPoolItem* pOldPara =
973 GetOldItem( rCoreSet, SID_ATTR_BRUSH );
974
975 if ( *pParaBck_Impl->pParaBrush != *pOldPara )
976 {
977 rCoreSet.Put( *pParaBck_Impl->pParaBrush );
978 bModified |= TRUE;
979 }
980 }
981
982 if( nSlot != SID_ATTR_BRUSH_CHAR )
983 {
984 const SfxPoolItem* pOldChar =
985 GetOldItem( rCoreSet, SID_ATTR_BRUSH_CHAR );
986 DBG_ASSERT(pParaBck_Impl, "pParaBck_Impl == NULL ?");
987 if ( pOldChar &&
988 //#111173# crash report shows that pParaBck_Impl can be NULL, the cause is unknown
989 pParaBck_Impl &&
990 (*pParaBck_Impl->pCharBrush != *pOldChar ||
991 *pParaBck_Impl->pCharBrush != SvxBrushItem(SID_ATTR_BRUSH_CHAR)))
992 {
993 rCoreSet.Put( *pParaBck_Impl->pCharBrush );
994 bModified |= TRUE;
995 }
996 }
997
998 if( aParaLBox.GetSavedValue() != aParaLBox.GetSelectEntryPos() )
999 {
1000 rCoreSet.Put( SfxUInt16Item( SID_BACKGRND_DESTINATION,
1001 aParaLBox.GetSelectEntryPos() ) );
1002 bModified |= TRUE;
1003 }
1004 }
1005 return bModified;
1006 }
1007
1008 BOOL SvxBackgroundTabPage::FillItemSetWithWallpaperItem( SfxItemSet& rCoreSet, USHORT nSlot)
1009 {
1010 USHORT nWhich = GetWhich( nSlot );
1011 const SfxPoolItem* pOld = GetOldItem( rCoreSet, nSlot );
1012 const SfxItemSet& rOldSet = GetItemSet();
1013 DBG_ASSERT(pOld,"FillItemSetWithWallpaperItem: Item not found");
1014
1015 SvxBrushItem rOldItem( (const CntWallpaperItem&)*pOld, nWhich );
1016 SvxGraphicPosition eOldPos = rOldItem.GetGraphicPos();
1017 const BOOL bIsBrush = ( 0 == aLbSelect.GetSelectEntryPos() );
1018 BOOL bModified = FALSE;
1019
1020 if ( ( (GPOS_NONE == eOldPos) && bIsBrush )
1021 || ( (GPOS_NONE != eOldPos) && !bIsBrush ) ) // Brush <-> Bitmap gewechselt?
1022 {
1023 // Hintergrund-Art wurde nicht gewechselt:
1024
1025 if ( (GPOS_NONE == eOldPos) || !aLbSelect.IsVisible() )
1026 {
1027 // Brush-Behandlung:
1028 if ( rOldItem.GetColor() != aBgdColor )
1029 {
1030 bModified = TRUE;
1031 CntWallpaperItem aItem( nWhich );
1032 aItem.SetColor( aBgdColor );
1033 rCoreSet.Put( aItem );
1034 }
1035 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1036 rCoreSet.ClearItem( nWhich );
1037 }
1038 else
1039 {
1040 // Bitmap-Behandlung:
1041 SvxGraphicPosition eNewPos = GetGraphicPosition_Impl();
1042
1043 int bBitmapChanged = ( ( eNewPos != eOldPos ) ||
1044 ( *rOldItem.GetGraphicLink() != aBgdGraphicPath ) );
1045 int bBrushChanged = ( rOldItem.GetColor() != aBgdColor );
1046 if( bBitmapChanged || bBrushChanged )
1047 {
1048 bModified = TRUE;
1049
1050 CntWallpaperItem aItem( nWhich );
1051 WallpaperStyle eWallStyle = SvxBrushItem::GraphicPos2WallpaperStyle(eNewPos);
1052 aItem.SetStyle( sal::static_int_cast< USHORT >( eWallStyle ) );
1053 aItem.SetColor( aBgdColor );
1054 aItem.SetBitmapURL( aBgdGraphicPath );
1055 rCoreSet.Put( aItem );
1056 }
1057 else if ( SFX_ITEM_DEFAULT == rOldSet.GetItemState( nWhich, FALSE ) )
1058 rCoreSet.ClearItem( nWhich );
1059 }
1060 }
1061 else // Brush <-> Bitmap gewechselt!
1062 {
1063 CntWallpaperItem aItem( nWhich );
1064 if ( bIsBrush )
1065 {
1066 aItem.SetColor( aBgdColor );
1067 rCoreSet.Put( aItem );
1068 }
1069 else
1070 {
1071 WallpaperStyle eWallStyle =
1072 SvxBrushItem::GraphicPos2WallpaperStyle( GetGraphicPosition_Impl() );
1073 aItem.SetStyle( sal::static_int_cast< USHORT >( eWallStyle ) );
1074 aItem.SetColor( aBgdColor );
1075 aItem.SetBitmapURL( aBgdGraphicPath );
1076 rCoreSet.Put( aItem );
1077 }
1078
1079 bModified = TRUE;
1080 }
1081 return bModified;
1082 }
1083
1084 //-----------------------------------------------------------------------
1085
1086 int SvxBackgroundTabPage::DeactivatePage( SfxItemSet* _pSet )
1087
1088 /* [Beschreibung]
1089
1090 virtuelle Methode, wird beim Deaktivieren gerufen
1091 */
1092
1093 {
1094 if ( pPageImpl->bIsImportDlgInExecute )
1095 return KEEP_PAGE;
1096
1097 if ( _pSet )
1098 FillItemSet( *_pSet );
1099
1100 return LEAVE_PAGE;
1101 }
1102
1103 //-----------------------------------------------------------------------
1104
1105 void SvxBackgroundTabPage::PointChanged( Window* , RECT_POINT )
1106
1107 /* [Beschreibung]
1108
1109 */
1110
1111 {
1112 // muss implementiert werden, damit Position-Control funktioniert
1113 }
1114
1115 //-----------------------------------------------------------------------
1116
1117 void SvxBackgroundTabPage::ShowSelector()
1118
1119 /* [Beschreibung]
1120
1121 */
1122
1123 {
1124 if( bAllowShowSelector)
1125 {
1126 aSelectTxt.Show();
1127 aLbSelect.Show();
1128 aLbSelect.SetSelectHdl( HDL(SelectHdl_Impl) );
1129 aBtnLink.SetClickHdl( HDL(FileClickHdl_Impl) );
1130 aBtnPreview.SetClickHdl( HDL(FileClickHdl_Impl) );
1131 aBtnBrowse.SetClickHdl( HDL(BrowseHdl_Impl) );
1132 aBtnArea.SetClickHdl( HDL(RadioClickHdl_Impl) );
1133 aBtnTile.SetClickHdl( HDL(RadioClickHdl_Impl) );
1134 aBtnPosition.SetClickHdl( HDL(RadioClickHdl_Impl) );
1135
1136 // Verz"ogertes Laden "uber Timer (wg. UI-Update)
1137 pPageImpl->pLoadTimer = new Timer;
1138 pPageImpl->pLoadTimer->SetTimeout( 500 ); // 500ms verz"ogern
1139 pPageImpl->pLoadTimer->SetTimeoutHdl(
1140 LINK( this, SvxBackgroundTabPage, LoadTimerHdl_Impl ) );
1141
1142 bAllowShowSelector = FALSE;
1143
1144 if(nHtmlMode & HTMLMODE_ON)
1145 {
1146 if(!(nHtmlMode & HTMLMODE_GRAPH_POS))
1147 aBtnPosition.Enable(FALSE);
1148 aBtnArea.Enable(FALSE);
1149 }
1150 }
1151 }
1152
1153 //------------------------------------------------------------------------
1154
1155
1156 void SvxBackgroundTabPage::RaiseLoadError_Impl()
1157
1158 /* [Beschreibung]
1159
1160 */
1161
1162 {
1163 SfxErrorContext aContext( ERRCTX_SVX_BACKGROUND,
1164 String(),
1165 this,
1166 RID_SVXERRCTX,
1167 &DIALOG_MGR() );
1168
1169 ErrorHandler::HandleError(
1170 *new StringErrorInfo( ERRCODE_SVX_GRAPHIC_NOTREADABLE,
1171 aBgdGraphicPath ) );
1172 }
1173
1174 //------------------------------------------------------------------------
1175
1176 BOOL SvxBackgroundTabPage::LoadLinkedGraphic_Impl()
1177
1178 /* [Beschreibung]
1179
1180 */
1181
1182 {
1183 BOOL bResult = ( aBgdGraphicPath.Len() > 0 ) &&
1184 ( GRFILTER_OK == LoadGraphic( aBgdGraphicPath,
1185 aBgdGraphicFilter,
1186 aBgdGraphic ) );
1187 return bResult;
1188 }
1189
1190 //------------------------------------------------------------------------
1191
1192
1193 void SvxBackgroundTabPage::FillColorValueSets_Impl()
1194
1195 /* [Beschreibung]
1196
1197 F"ullen des Farb-Sets
1198 */
1199
1200 {
1201 SfxObjectShell* pDocSh = SfxObjectShell::Current();
1202 const SfxPoolItem* pItem = NULL;
1203 XColorTable* pColorTable = NULL;
1204 const Size aSize15x15 = Size( 15, 15 );
1205 FASTBOOL bOwn = FALSE;
1206
1207 if ( pDocSh && ( 0 != ( pItem = pDocSh->GetItem( SID_COLOR_TABLE ) ) ) )
1208 pColorTable = ( (SvxColorTableItem*)pItem )->GetColorTable();
1209
1210 if ( !pColorTable )
1211 {
1212 bOwn = TRUE;
1213 pColorTable = new XColorTable( SvtPathOptions().GetPalettePath() );
1214 }
1215
1216 if ( pColorTable )
1217 {
1218 short i = 0;
1219 long nCount = pColorTable->Count();
1220 XColorEntry* pEntry = NULL;
1221 Color aColWhite( COL_WHITE );
1222 String aStrWhite( SVX_RES( RID_SVXITEMS_COLOR_WHITE ) );
1223 WinBits nBits = ( aBackgroundColorSet.GetStyle() | WB_ITEMBORDER | WB_NAMEFIELD | WB_NONEFIELD );
1224 aBackgroundColorSet.SetText( String( SVX_RES( RID_SVXSTR_TRANSPARENT ) ) );
1225 aBackgroundColorSet.SetStyle( nBits );
1226 for ( i = 0; i < nCount; i++ )
1227 {
1228 pEntry = pColorTable->GetColor(i);
1229 aBackgroundColorSet.InsertItem( i + 1, pEntry->GetColor(), pEntry->GetName() );
1230 }
1231
1232 while ( i < 80 )
1233 {
1234 aBackgroundColorSet.InsertItem( i + 1, aColWhite, aStrWhite );
1235 i++;
1236 }
1237
1238 if ( nCount > 80 )
1239 {
1240 aBackgroundColorSet.SetStyle( nBits | WB_VSCROLL );
1241 }
1242 }
1243
1244 if ( bOwn )
1245 delete pColorTable;
1246
1247 aBackgroundColorSet.SetColCount( 10 );
1248 aBackgroundColorSet.SetLineCount( 10 );
1249 aBackgroundColorSet.CalcWindowSizePixel( aSize15x15 );
1250
1251 }
1252
1253 //------------------------------------------------------------------------
1254
1255
1256
1257 //------------------------------------------------------------------------
1258
1259 void SvxBackgroundTabPage::ShowColorUI_Impl()
1260
1261 /* [Beschreibung]
1262
1263 Die Controls f"ur das Einstellen der Grafik ausblenden und die
1264 Controls f"ur die Farbeinstellung einblenden.
1265 */
1266
1267 {
1268 if( !aBackgroundColorSet.IsVisible() )
1269 {
1270 aBackgroundColorSet.Show();
1271 aBackgroundColorBox.Show();
1272 aBorderWin.Show();
1273 pPreviewWin1->Show();
1274 aBtnBrowse.Hide();
1275 aFtFile.Hide();
1276 aBtnLink.Hide();
1277 aBtnPreview.Hide();
1278 aGbFile.Hide();
1279 aBtnPosition.Hide();
1280 aBtnArea.Hide();
1281 aBtnTile.Hide();
1282 aWndPosition.Hide();
1283 aGbPosition.Hide();
1284 pPreviewWin2->Hide();
1285 aGraphTransFL.Show(FALSE);
1286 aGraphTransMF.Show(FALSE);
1287 if(bColTransparency)
1288 {
1289 aColTransFT.Show();
1290 aColTransMF.Show();
1291 }
1292 }
1293 }
1294
1295 //------------------------------------------------------------------------
1296
1297 void SvxBackgroundTabPage::ShowBitmapUI_Impl()
1298
1299 /* [Beschreibung]
1300
1301 Die Controls f"ur die Farbeinstellung ausblenden und die
1302 Controls f"ur das Einstellen der Grafik einblenden.
1303 */
1304
1305 {
1306 if ( aLbSelect.IsVisible() &&
1307 (
1308 aBackgroundColorSet.IsVisible()
1309 || !aBtnBrowse.IsVisible() ) )
1310 {
1311 aBackgroundColorSet.Hide();
1312 aBackgroundColorBox.Hide();
1313 aBorderWin.Hide();
1314 pPreviewWin1->Hide();
1315 aBtnBrowse.Show();
1316 aFtFile.Show();
1317
1318 if ( !bLinkOnly && ! nHtmlMode & HTMLMODE_ON )
1319 aBtnLink.Show();
1320 aBtnPreview.Show();
1321 aGbFile.Show();
1322 aBtnPosition.Show();
1323 aBtnArea.Show();
1324 aBtnTile.Show();
1325 aWndPosition.Show();
1326 aGbPosition.Show();
1327 pPreviewWin2->Show();
1328 if(bGraphTransparency)
1329 {
1330 aGraphTransFL.Show();
1331 aGraphTransMF.Show();
1332 }
1333 aColTransFT.Show(FALSE);
1334 aColTransMF.Show(FALSE);
1335 }
1336 }
1337
1338 //------------------------------------------------------------------------
1339
1340 void SvxBackgroundTabPage::SetGraphicPosition_Impl( SvxGraphicPosition ePos )
1341
1342 /* [Beschreibung]
1343
1344 Die Controls f"ur die Grafikposition einstellen.
1345 */
1346
1347 {
1348 switch ( ePos )
1349 {
1350 case GPOS_AREA:
1351 {
1352 aBtnArea.Check();
1353 aWndPosition.Disable();
1354 }
1355 break;
1356
1357 case GPOS_TILED:
1358 {
1359 aBtnTile.Check();
1360 aWndPosition.Disable();
1361 }
1362 break;
1363
1364 default:
1365 {
1366 aBtnPosition.Check();
1367 aWndPosition.Enable();
1368 RECT_POINT eNewPos = RP_MM;
1369
1370 switch ( ePos )
1371 {
1372 case GPOS_MM: break;
1373 case GPOS_LT: eNewPos = RP_LT; break;
1374 case GPOS_MT: eNewPos = RP_MT; break;
1375 case GPOS_RT: eNewPos = RP_RT; break;
1376 case GPOS_LM: eNewPos = RP_LM; break;
1377 case GPOS_RM: eNewPos = RP_RM; break;
1378 case GPOS_LB: eNewPos = RP_LB; break;
1379 case GPOS_MB: eNewPos = RP_MB; break;
1380 case GPOS_RB: eNewPos = RP_RB; break;
1381 default: ;//prevent warning
1382 }
1383 aWndPosition.SetActualRP( eNewPos );
1384 }
1385 break;
1386 }
1387 aWndPosition.Invalidate();
1388 }
1389
1390 //------------------------------------------------------------------------
1391
1392 SvxGraphicPosition SvxBackgroundTabPage::GetGraphicPosition_Impl()
1393
1394 /* [Beschreibung]
1395
1396 Die Position der Grafik zur"uckgeben.
1397 */
1398
1399 {
1400 if ( aBtnTile.IsChecked() )
1401 return GPOS_TILED;
1402 else if ( aBtnArea.IsChecked() )
1403 return GPOS_AREA;
1404 else
1405 {
1406 switch ( aWndPosition.GetActualRP() )
1407 {
1408 case RP_LT: return GPOS_LT;
1409 case RP_MT: return GPOS_MT;
1410 case RP_RT: return GPOS_RT;
1411 case RP_LM: return GPOS_LM;
1412 case RP_MM: return GPOS_MM;
1413 case RP_RM: return GPOS_RM;
1414 case RP_LB: return GPOS_LB;
1415 case RP_MB: return GPOS_MB;
1416 case RP_RB: return GPOS_RB;
1417 }
1418 }
1419 return GPOS_MM;
1420 }
1421
1422 //-----------------------------------------------------------------------
1423 // Handler
1424 //-----------------------------------------------------------------------
1425
1426 IMPL_LINK( SvxBackgroundTabPage, BackgroundColorHdl_Impl, ValueSet*, EMPTYARG )
1427 /*
1428 Handler, called when color selection is changed
1429 */
1430 {
1431 USHORT nItemId = aBackgroundColorSet.GetSelectItemId();
1432 Color aColor = nItemId ? ( aBackgroundColorSet.GetItemColor( nItemId ) ) : Color( COL_TRANSPARENT );
1433 aBgdColor = aColor;
1434 pPreviewWin1->NotifyChange( aBgdColor );
1435 BOOL bEnableTransp = aBgdColor.GetTransparency() < 0xff;
1436 aColTransFT.Enable(bEnableTransp);
1437 aColTransMF.Enable(bEnableTransp);
1438 return 0;
1439 }
1440
1441 //------------------------------------------------------------------------
1442
1443 IMPL_LINK( SvxBackgroundTabPage, SelectHdl_Impl, ListBox*, EMPTYARG )
1444
1445 /* [Beschreibung]
1446
1447 */
1448
1449 {
1450 if ( 0 == aLbSelect.GetSelectEntryPos() )
1451 {
1452 ShowColorUI_Impl();
1453 aParaLBox.Enable(); // Zeichenhintergrund kann keine Bitmap sein
1454 }
1455 else
1456 {
1457 ShowBitmapUI_Impl();
1458 aParaLBox.Enable(FALSE);// Zeichenhintergrund kann keine Bitmap sein
1459 }
1460 return 0;
1461 }
1462
1463 //------------------------------------------------------------------------
1464
1465 IMPL_LINK( SvxBackgroundTabPage, FileClickHdl_Impl, CheckBox*, pBox )
1466
1467 /* [Beschreibung]
1468
1469 */
1470
1471 {
1472 if ( &aBtnLink == pBox )
1473 {
1474 if ( aBtnLink.IsChecked() )
1475 {
1476 INetURLObject aObj( aBgdGraphicPath );
1477 String aFilePath;
1478 if ( aObj.GetProtocol() == INET_PROT_FILE )
1479 aFilePath = aObj.getFSysPath( INetURLObject::FSYS_DETECT );
1480 else
1481 aFilePath = aBgdGraphicPath;
1482 aFtFile.SetText( aFilePath );
1483 }
1484 else
1485 aFtFile.SetText( aStrUnlinked );
1486 }
1487 else if ( &aBtnPreview == pBox )
1488 {
1489 if ( aBtnPreview.IsChecked() )
1490 {
1491 if ( !bIsGraphicValid )
1492 bIsGraphicValid = LoadLinkedGraphic_Impl();
1493
1494 if ( bIsGraphicValid )
1495 {
1496 Bitmap aBmp = aBgdGraphic.GetBitmap();
1497 pPreviewWin2->NotifyChange( &aBmp );
1498 }
1499 else
1500 {
1501 if ( aBgdGraphicPath.Len() > 0 ) // nur bei gelinkter Grafik
1502 RaiseLoadError_Impl(); // ein Fehler
1503 pPreviewWin2->NotifyChange( NULL );
1504 }
1505 }
1506 else
1507 pPreviewWin2->NotifyChange( NULL );
1508 }
1509 return 0;
1510 }
1511
1512 //------------------------------------------------------------------------
1513
1514 IMPL_LINK( SvxBackgroundTabPage, RadioClickHdl_Impl, RadioButton*, pBtn )
1515
1516 /* [Beschreibung]
1517
1518 */
1519
1520 {
1521 if ( pBtn == &aBtnPosition )
1522 {
1523 if ( !aWndPosition.IsEnabled() )
1524 {
1525 aWndPosition.Enable();
1526 aWndPosition.Invalidate();
1527 }
1528 }
1529 else if ( aWndPosition.IsEnabled() )
1530 {
1531 aWndPosition.Disable();
1532 aWndPosition.Invalidate();
1533 }
1534 return 0;
1535 }
1536
1537 //------------------------------------------------------------------------
1538
1539 IMPL_LINK( SvxBackgroundTabPage, BrowseHdl_Impl, PushButton* , EMPTYARG )
1540
1541 /* [Beschreibung]
1542
1543 Handler, gerufen durch das Dr"ucken des Durchsuchen-Buttons.
1544 Grafik/Einf"ugen-Dialog erzeugen, Pfad setzen und starten.
1545 */
1546
1547 {
1548 if ( pPageImpl->pLoadTimer->IsActive() )
1549 return 0;
1550 BOOL bHtml = 0 != ( nHtmlMode & HTMLMODE_ON );
1551
1552 pImportDlg = new SvxOpenGraphicDialog( aStrBrowse );
1553 if ( bHtml || bLinkOnly )
1554 pImportDlg->EnableLink(sal_False);
1555 pImportDlg->SetPath( aBgdGraphicPath, aBtnLink.IsChecked() );
1556
1557 pPageImpl->bIsImportDlgInExecute = TRUE;
1558 short nErr = pImportDlg->Execute();
1559 pPageImpl->bIsImportDlgInExecute = FALSE;
1560
1561 if( !nErr )
1562 {
1563 if ( bHtml )
1564 aBtnLink.Check();
1565 // wenn Verkn"upfen nicht gecheckt ist und die Vorschau auch nicht,
1566 // dann die Vorschau aktivieren, damit der Anwender sieht,
1567 // welche Grafik er ausgew"ahlt hat
1568 if ( !aBtnLink.IsChecked() && !aBtnPreview.IsChecked() )
1569 aBtnPreview.Check( TRUE );
1570 // timer-verz"ogertes Laden der Grafik
1571 pPageImpl->pLoadTimer->Start();
1572 }
1573 else
1574 DELETEZ( pImportDlg );
1575 return 0;
1576 }
1577
1578 //-----------------------------------------------------------------------
1579
1580 IMPL_LINK( SvxBackgroundTabPage, LoadTimerHdl_Impl, Timer* , pTimer )
1581
1582 /* [Beschreibung]
1583
1584 Verz"ogertes Laden der Grafik.
1585 Grafik wird nur dann geladen, wenn sie unterschiedlich zur
1586 aktuellen Grafik ist.
1587 */
1588
1589 {
1590 if ( pTimer == pPageImpl->pLoadTimer )
1591 {
1592 pPageImpl->pLoadTimer->Stop();
1593
1594 if ( pImportDlg )
1595 {
1596 INetURLObject aOld( aBgdGraphicPath );
1597 INetURLObject aNew( pImportDlg->GetPath() );
1598 if ( !aBgdGraphicPath.Len() || aNew != aOld )
1599 {
1600 // neue Datei gew"ahlt
1601 aBgdGraphicPath = pImportDlg->GetPath();
1602 aBgdGraphicFilter = pImportDlg->GetCurrentFilter();
1603 BOOL bLink = ( nHtmlMode & HTMLMODE_ON ) || bLinkOnly ? TRUE : pImportDlg->IsAsLink();
1604 aBtnLink.Check( bLink );
1605 aBtnLink.Enable();
1606
1607 if ( aBtnPreview.IsChecked() )
1608 {
1609 if( !pImportDlg->GetGraphic(aBgdGraphic) )
1610 {
1611 bIsGraphicValid = TRUE;
1612 }
1613 else
1614 {
1615 aBgdGraphicFilter.Erase();
1616 aBgdGraphicPath.Erase();
1617 bIsGraphicValid = FALSE;
1618 }
1619 }
1620 else
1621 bIsGraphicValid = FALSE; // Grafik erst beim Preview-Click laden
1622
1623 if ( aBtnPreview.IsChecked() && bIsGraphicValid )
1624 {
1625 Bitmap aBmp = aBgdGraphic.GetBitmap();
1626 pPreviewWin2->NotifyChange( &aBmp );
1627 }
1628 else
1629 pPreviewWin2->NotifyChange( NULL );
1630 }
1631
1632 FileClickHdl_Impl( &aBtnLink );
1633 DELETEZ( pImportDlg );
1634 }
1635 }
1636 return 0;
1637 }
1638
1639 //-----------------------------------------------------------------------
1640
1641 void SvxBackgroundTabPage::ShowTblControl()
1642
1643 /* [Beschreibung]
1644
1645 */
1646
1647 {
1648 aTblLBox .SetSelectHdl( HDL(TblDestinationHdl_Impl) );
1649 aTblLBox .SelectEntryPos(0);
1650 aTblDesc.Show();
1651 aTblLBox.Show();
1652 }
1653
1654 //-----------------------------------------------------------------------
1655
1656 void SvxBackgroundTabPage::ShowParaControl(BOOL bCharOnly)
1657 {
1658 aParaLBox.SetSelectHdl(HDL(ParaDestinationHdl_Impl));
1659 aParaLBox.SelectEntryPos(0);
1660 if(!bCharOnly)
1661 {
1662 aTblDesc.Show();
1663 aParaLBox.Show();
1664 }
1665 aParaLBox.SetData(&aParaLBox); // hier erkennt man, dass dieser Mode eingeschaltet ist
1666 }
1667 //-----------------------------------------------------------------------
1668
1669 IMPL_LINK( SvxBackgroundTabPage, TblDestinationHdl_Impl, ListBox*, pBox )
1670
1671 /* [Beschreibung]
1672
1673 */
1674
1675 {
1676 USHORT nSelPos = pBox->GetSelectEntryPos();
1677 if( pTableBck_Impl && pTableBck_Impl->nActPos != nSelPos)
1678 {
1679 SvxBrushItem** pActItem = new (SvxBrushItem*);
1680 USHORT nWhich = 0;
1681 switch(pTableBck_Impl->nActPos)
1682 {
1683 case TBL_DEST_CELL:
1684 *pActItem = pTableBck_Impl->pCellBrush;
1685 nWhich = pTableBck_Impl->nCellWhich;
1686 break;
1687 case TBL_DEST_ROW:
1688 *pActItem = pTableBck_Impl->pRowBrush;
1689 nWhich = pTableBck_Impl->nRowWhich;
1690 break;
1691 case TBL_DEST_TBL:
1692 *pActItem = pTableBck_Impl->pTableBrush;
1693 nWhich = pTableBck_Impl->nTableWhich;
1694 break;
1695 }
1696 pTableBck_Impl->nActPos = nSelPos;
1697 if(!*pActItem)
1698 *pActItem = new SvxBrushItem(nWhich);
1699 if(0 == aLbSelect.GetSelectEntryPos()) // Brush ausgewaehlt
1700 {
1701 **pActItem = SvxBrushItem( aBgdColor, nWhich );
1702 }
1703 else
1704 {
1705 SvxGraphicPosition eNewPos = GetGraphicPosition_Impl();
1706 const BOOL bIsLink = aBtnLink.IsChecked();
1707
1708 if ( !bIsLink && !bIsGraphicValid )
1709 bIsGraphicValid = LoadLinkedGraphic_Impl();
1710
1711 if ( bIsLink )
1712 **pActItem = SvxBrushItem( aBgdGraphicPath,
1713 aBgdGraphicFilter,
1714 eNewPos,
1715 (*pActItem)->Which() );
1716 else
1717 **pActItem = SvxBrushItem( aBgdGraphic,
1718 eNewPos,
1719 (*pActItem)->Which() );
1720 }
1721 switch(nSelPos)
1722 {
1723 case TBL_DEST_CELL:
1724 *pActItem = pTableBck_Impl->pCellBrush;
1725 aLbSelect.Enable();
1726 nWhich = pTableBck_Impl->nCellWhich;
1727 break;
1728 case TBL_DEST_ROW:
1729 {
1730 if((nHtmlMode & HTMLMODE_ON) && !(nHtmlMode & HTMLMODE_SOME_STYLES))
1731 aLbSelect.Disable();
1732 *pActItem = pTableBck_Impl->pRowBrush;
1733 nWhich = pTableBck_Impl->nRowWhich;
1734 }
1735 break;
1736 case TBL_DEST_TBL:
1737 *pActItem = pTableBck_Impl->pTableBrush;
1738 aLbSelect.Enable();
1739 nWhich = pTableBck_Impl->nTableWhich;
1740 break;
1741 }
1742 String aUserData = GetUserData();
1743 if(!*pActItem)
1744 *pActItem = new SvxBrushItem(nWhich);
1745 FillControls_Impl(**pActItem, aUserData);
1746 delete pActItem;
1747 }
1748 return 0;
1749 }
1750
1751 //-----------------------------------------------------------------------
1752
1753 IMPL_LINK( SvxBackgroundTabPage, ParaDestinationHdl_Impl, ListBox*, pBox )
1754 {
1755 USHORT nSelPos = pBox->GetSelectEntryPos();
1756 if( pParaBck_Impl && pParaBck_Impl->nActPos != nSelPos)
1757 {
1758 SvxBrushItem** pActItem = new (SvxBrushItem*);
1759 switch(pParaBck_Impl->nActPos)
1760 {
1761 case PARA_DEST_PARA:
1762 *pActItem = pParaBck_Impl->pParaBrush;
1763 break;
1764 case PARA_DEST_CHAR:
1765 *pActItem = pParaBck_Impl->pCharBrush;
1766 break;
1767 }
1768 pParaBck_Impl->nActPos = nSelPos;
1769 if(0 == aLbSelect.GetSelectEntryPos()) // Brush ausgewaehlt
1770 {
1771 USHORT nWhich = (*pActItem)->Which();
1772 **pActItem = SvxBrushItem( aBgdColor, nWhich );
1773 }
1774 else
1775 {
1776 SvxGraphicPosition eNewPos = GetGraphicPosition_Impl();
1777 const BOOL bIsLink = aBtnLink.IsChecked();
1778
1779 if ( !bIsLink && !bIsGraphicValid )
1780 bIsGraphicValid = LoadLinkedGraphic_Impl();
1781
1782 if ( bIsLink )
1783 **pActItem = SvxBrushItem( aBgdGraphicPath,
1784 aBgdGraphicFilter,
1785 eNewPos,
1786 (*pActItem)->Which() );
1787 else
1788 **pActItem = SvxBrushItem( aBgdGraphic,
1789 eNewPos,
1790 (*pActItem)->Which() );
1791 }
1792 switch(nSelPos)
1793 {
1794 case PARA_DEST_PARA:
1795 *pActItem = pParaBck_Impl->pParaBrush;
1796 aLbSelect.Enable();
1797 break;
1798 case PARA_DEST_CHAR:
1799 {
1800 *pActItem = pParaBck_Impl->pCharBrush;
1801 aLbSelect.Enable(FALSE);
1802 }
1803 break;
1804 }
1805 String aUserData = GetUserData();
1806 FillControls_Impl(**pActItem, aUserData);
1807 delete pActItem;
1808 }
1809 return 0;
1810 }
1811
1812 //-----------------------------------------------------------------------
1813
1814 void SvxBackgroundTabPage::FillControls_Impl( const SvxBrushItem& rBgdAttr,
1815 const String& rUserData )
1816
1817 /* [Beschreibung]
1818
1819 */
1820
1821 {
1822 SvxGraphicPosition ePos = rBgdAttr.GetGraphicPos();
1823 const Color& rColor = rBgdAttr.GetColor();
1824 if(bColTransparency)
1825 {
1826 aColTransMF.SetValue(lcl_TransparencyToPercent(rColor.GetTransparency()));
1827 aColTransMF.SaveValue();
1828 BOOL bEnableTransp = rColor.GetTransparency() < 0xff;
1829 aColTransFT.Enable(bEnableTransp);
1830 aColTransMF.Enable(bEnableTransp);
1831 //the default setting should be "no transparency"
1832 if(!bEnableTransp)
1833 aColTransMF.SetValue(0);
1834 }
1835
1836 if ( GPOS_NONE == ePos || !aLbSelect.IsVisible() )
1837 {
1838 aLbSelect.SelectEntryPos( 0 );
1839 ShowColorUI_Impl();
1840 Color aTrColor( COL_TRANSPARENT );
1841 aBgdColor = rColor;
1842
1843 USHORT nCol = ( aTrColor != aBgdColor ) ?
1844 GetItemId_Impl( aBackgroundColorSet, aBgdColor ) : 0;
1845
1846 if( aTrColor != aBgdColor && nCol == 0)
1847 {
1848 aBackgroundColorSet.SetNoSelection();
1849 }
1850 else
1851 {
1852 aBackgroundColorSet.SelectItem( nCol );
1853 }
1854
1855 pPreviewWin1->NotifyChange( aBgdColor );
1856 if ( aLbSelect.IsVisible() ) // Grafikteil initialisieren
1857 {
1858 aBgdGraphicFilter.Erase();
1859 aBgdGraphicPath.Erase();
1860
1861 if ( !rUserData.Len() )
1862 aBtnPreview.Check( FALSE );
1863 aBtnLink.Check( FALSE );
1864 aBtnLink.Disable();
1865 pPreviewWin2->NotifyChange( NULL );
1866 SetGraphicPosition_Impl( GPOS_TILED ); // Kacheln als Default
1867 }
1868 }
1869 else
1870 {
1871 const String* pStrLink = rBgdAttr.GetGraphicLink();
1872 const String* pStrFilter = rBgdAttr.GetGraphicFilter();
1873
1874 aLbSelect.SelectEntryPos( 1 );
1875 ShowBitmapUI_Impl();
1876
1877 if ( pStrLink )
1878 {
1879 #ifdef DBG_UTIL
1880 INetURLObject aObj( *pStrLink );
1881 DBG_ASSERT( aObj.GetProtocol() != INET_PROT_NOT_VALID, "Invalid URL!" );
1882 #endif
1883 aBgdGraphicPath = *pStrLink;
1884 aBtnLink.Check( TRUE );
1885 aBtnLink.Enable();
1886 }
1887 else
1888 {
1889 aBgdGraphicPath.Erase();
1890 aBtnLink.Check( FALSE );
1891 aBtnLink.Disable();
1892 }
1893
1894 if(bGraphTransparency)
1895 {
1896 const GraphicObject* pObject = rBgdAttr.GetGraphicObject(SfxObjectShell::Current());
1897 if(pObject)
1898 aGraphTransMF.SetValue(lcl_TransparencyToPercent(pObject->GetAttr().GetTransparency()));
1899 else
1900 aGraphTransMF.SetValue(0);
1901 aGraphTransMF.SaveValue();
1902 }
1903
1904 FileClickHdl_Impl( &aBtnLink );
1905
1906 if ( pStrFilter )
1907 aBgdGraphicFilter = *pStrFilter;
1908 else
1909 aBgdGraphicFilter.Erase();
1910
1911 if ( !pStrLink || aBtnPreview.IsChecked() )
1912 {
1913 // Grafik ist im Item vorhanden und muss nicht
1914 // geladen werden:
1915
1916 const Graphic* pGraphic =
1917 rBgdAttr.GetGraphic( SfxObjectShell::Current() );
1918
1919 if ( !pGraphic && aBtnPreview.IsChecked() )
1920 bIsGraphicValid = LoadLinkedGraphic_Impl();
1921 else if ( pGraphic )
1922 {
1923 aBgdGraphic = *pGraphic;
1924 bIsGraphicValid = TRUE;
1925
1926 if ( !rUserData.Len() )
1927 aBtnPreview.Check();
1928 }
1929 else
1930 {
1931 RaiseLoadError_Impl();
1932 bIsGraphicValid = FALSE;
1933
1934 if ( !rUserData.Len() )
1935 aBtnPreview.Check( FALSE );
1936 }
1937 }
1938
1939 if ( aBtnPreview.IsChecked() && bIsGraphicValid )
1940 {
1941 Bitmap aBmp = aBgdGraphic.GetBitmap();
1942 pPreviewWin2->NotifyChange( &aBmp );
1943 }
1944 else
1945 pPreviewWin2->NotifyChange( NULL );
1946
1947 SetGraphicPosition_Impl( ePos );
1948 }
1949 }
1950 /* -----------------------------09.08.2002 14:04------------------------------
1951
1952 ---------------------------------------------------------------------------*/
1953 void SvxBackgroundTabPage::EnableTransparency(BOOL bColor, BOOL bGraphic)
1954 {
1955 bColTransparency = bColor;
1956 bGraphTransparency = bGraphic;
1957 if(bColor)
1958 {
1959 aColTransFT.Show();
1960 aColTransMF.Show();
1961 }
1962 if(bGraphic)
1963 {
1964 Size aRectSize(aWndPosition.GetSizePixel());
1965 Point aRectPos(aWndPosition.GetPosPixel());
1966 Point aFLPos(aGraphTransFL.GetPosPixel());
1967 Size aTmp(LogicToPixel(Size(RSC_SP_FLGR_SPACE_Y, RSC_SP_FLGR_SPACE_Y), MAP_APPFONT));
1968 long nRectHeight = aFLPos.Y() - aRectPos.Y() - aTmp.Height();
1969 aRectSize.Height() = nRectHeight;
1970 aWndPosition.SetSizePixel(aRectSize);
1971 aWndPosition.Invalidate();
1972 }
1973 }
1974
1975 void SvxBackgroundTabPage::PageCreated (SfxAllItemSet aSet) //add CHINA001
1976 {
1977 SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt32Item,SID_FLAG_TYPE,sal_False);
1978 if (pFlagItem)
1979 {
1980 UINT32 nFlags=pFlagItem->GetValue();
1981 if ( ( nFlags & SVX_SHOW_TBLCTL ) == SVX_SHOW_TBLCTL )
1982 ShowTblControl();
1983 if ( ( nFlags & SVX_SHOW_PARACTL ) == SVX_SHOW_PARACTL )
1984 ShowParaControl();
1985 if ( ( nFlags & SVX_SHOW_SELECTOR ) == SVX_SHOW_SELECTOR )
1986 ShowSelector();
1987 if ( ( nFlags & SVX_ENABLE_TRANSPARENCY ) == SVX_ENABLE_TRANSPARENCY )
1988 EnableTransparency(TRUE, TRUE);
1989 }
1990 }
vba interoperability for OOo