?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
update credits
[LibreOffice.git] / cui / source / tabpages / paragrph.cxx
blobe82ffb3a62bb27395a0290d96870e2f6f007a213
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 <svl/style.hxx>
21 #include <sfx2/app.hxx>
22 #include <sfx2/objsh.hxx>
23 #include <sfx2/module.hxx>
24 #include <vcl/mnemonic.hxx>
25 #include <svx/dialogs.hrc>
26
27 #include <svl/languageoptions.hxx>
28 #include <svl/cjkoptions.hxx>
29 #include <editeng/pgrditem.hxx>
30 #include <cuires.hrc>
31 #include "paragrph.hrc"
32 #include "paragrph.hxx"
33 #include <editeng/frmdiritem.hxx>
34 #include <editeng/lspcitem.hxx>
35 #include <editeng/adjustitem.hxx>
36 #include <editeng/orphitem.hxx>
37 #include <editeng/widwitem.hxx>
38 #include <editeng/tstpitem.hxx>
39 #include <editeng/pmdlitem.hxx>
40 #include <editeng/spltitem.hxx>
41 #include <editeng/hyphenzoneitem.hxx>
42 #include <editeng/ulspitem.hxx>
43 #include <editeng/lrspitem.hxx>
44 #include <editeng/formatbreakitem.hxx>
45 #include <editeng/keepitem.hxx>
46 #include "svx/dlgutil.hxx"
47 #include <dialmgr.hxx>
48 #include <sfx2/htmlmode.hxx>
49 #include <editeng/paravertalignitem.hxx>
50 #include <svl/eitem.hxx>
51 #include <sfx2/request.hxx>
52 #include <svl/intitem.hxx>
53
54 // static ----------------------------------------------------------------
55
56 static sal_uInt16 pStdRanges[] =
57 {
58 SID_ATTR_PARA_LINESPACE, // 10033
59 SID_ATTR_PARA_LINESPACE,
60 SID_ATTR_LRSPACE, // 10048 -
61 SID_ATTR_ULSPACE, // 10049
62 SID_ATTR_PARA_REGISTER, // 10413
63 SID_ATTR_PARA_REGISTER,
64 0
65 };
66
67 static sal_uInt16 pAlignRanges[] =
68 {
69 SID_ATTR_PARA_ADJUST, // 10027
70 SID_ATTR_PARA_ADJUST,
71 0
72 };
73
74 static sal_uInt16 pExtRanges[] =
75 {
76 SID_ATTR_PARA_PAGEBREAK, // 10037 -
77 SID_ATTR_PARA_WIDOWS, // 10041
78 SID_ATTR_PARA_MODEL, // 10065 -
79 SID_ATTR_PARA_KEEP, // 10066
80 0
81 };
82
83 // define ----------------------------------------------------------------
84
85 #define MAX_DURCH 5670 // 10 cm makes sense as maximum interline lead
86 // according to BP
87 #define FIX_DIST_DEF 283 // standard fix distance 0,5 cm
88
89 // enum ------------------------------------------------------------------
90
91 enum LineSpaceList
92 {
93 LLINESPACE_1 = 0,
94 LLINESPACE_15 = 1,
95 LLINESPACE_2 = 2,
96 LLINESPACE_PROP = 3,
97 LLINESPACE_MIN = 4,
98 LLINESPACE_DURCH= 5,
99 LLINESPACE_FIX = 6,
100 LLINESPACE_END
101 };
102
103 // C-Function ------------------------------------------------------------
104
105 void SetLineSpace_Impl( SvxLineSpacingItem&, int, long lValue = 0 );
106
107 void SetLineSpace_Impl( SvxLineSpacingItem& rLineSpace,
108 int eSpace, long lValue )
109 {
110 switch ( eSpace )
111 {
112 case LLINESPACE_1:
113 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
114 rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
115 break;
116
117 case LLINESPACE_15:
118 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
119 rLineSpace.SetPropLineSpace( 150 );
120 break;
121
122 case LLINESPACE_2:
123 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
124 rLineSpace.SetPropLineSpace( 200 );
125 break;
126
127 case LLINESPACE_PROP:
128 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
129 rLineSpace.SetPropLineSpace( (sal_uInt8)lValue );
130 break;
131
132 case LLINESPACE_MIN:
133 rLineSpace.SetLineHeight( (sal_uInt16)lValue );
134 rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
135 break;
136
137 case LLINESPACE_DURCH:
138 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_AUTO;
139 rLineSpace.SetInterLineSpace( (sal_uInt16)lValue );
140 break;
141
142 case LLINESPACE_FIX:
143 rLineSpace.SetLineHeight((sal_uInt16)lValue);
144 rLineSpace.GetLineSpaceRule() = SVX_LINE_SPACE_FIX;
145 rLineSpace.GetInterLineSpaceRule() = SVX_INTER_LINE_SPACE_OFF;
146 break;
147 }
148 }
149
150
151 sal_uInt16 GetHtmlMode_Impl(const SfxItemSet& rSet)
152 {
153 sal_uInt16 nHtmlMode = 0;
154 const SfxPoolItem* pItem = 0;
155 SfxObjectShell* pShell;
156 if(SFX_ITEM_SET == rSet.GetItemState(SID_HTML_MODE, sal_False, &pItem) ||
157 ( 0 != (pShell = SfxObjectShell::Current()) &&
158 0 != (pItem = pShell->GetItem(SID_HTML_MODE))))
159 {
160 nHtmlMode = ((SfxUInt16Item*)pItem)->GetValue();
161 }
162 return nHtmlMode;
163
164 }
165
166 // class SvxStdParagraphTabPage ------------------------------------------
167
168 IMPL_LINK_NOARG(SvxStdParagraphTabPage, ELRLoseFocusHdl)
169 {
170 SfxItemPool* pPool = GetItemSet().GetPool();
171 DBG_ASSERT( pPool, "Wo ist der Pool" );
172 FieldUnit eUnit =
173 MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
174
175 sal_Int64 nL = aLeftIndent.Denormalize( aLeftIndent.GetValue( eUnit ) );
176 sal_Int64 nR = aRightIndent.Denormalize( aRightIndent.GetValue( eUnit ) );
177 String aTmp = aFLineIndent.GetText();
178
179 if( aLeftIndent.GetMin() < 0 )
180 aFLineIndent.SetMin( -99999, FUNIT_MM );
181 else
182 aFLineIndent.SetMin( aFLineIndent.Normalize( -nL ), eUnit );
183
184 // Check only for concrete width (Shell)
185 sal_Int64 nTmp = nWidth - nL - nR - MM50;
186 aFLineIndent.SetMax( aFLineIndent.Normalize( nTmp ), eUnit );
187
188 if ( !aTmp.Len() )
189 aFLineIndent.SetEmptyFieldValue();
190 // maximum left right
191 aTmp = aLeftIndent.GetText();
192 nTmp = nWidth - nR - MM50;
193 aLeftIndent.SetMax( aLeftIndent.Normalize( nTmp ), eUnit );
194
195 if ( !aTmp.Len() )
196 aLeftIndent.SetEmptyFieldValue();
197 aTmp = aRightIndent.GetText();
198 nTmp = nWidth - nL - MM50;
199 aRightIndent.SetMax( aRightIndent.Normalize( nTmp ), eUnit );
200
201 if ( !aTmp.Len() )
202 aRightIndent.SetEmptyFieldValue();
203 return 0;
204 }
205
206 // -----------------------------------------------------------------------
207
208 SfxTabPage* SvxStdParagraphTabPage::Create( Window* pParent,
209 const SfxItemSet& rSet)
210 {
211 return new SvxStdParagraphTabPage( pParent, rSet );
212 }
213
214 // -----------------------------------------------------------------------
215
216 sal_Bool SvxStdParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
217 {
218 SfxItemState eState = SFX_ITEM_UNKNOWN;
219 const SfxPoolItem* pOld = 0;
220 SfxItemPool* pPool = rOutSet.GetPool();
221 DBG_ASSERT( pPool, "Wo ist der Pool" );
222
223 sal_Bool bModified = sal_False;
224 sal_uInt16 nWhich;
225 sal_uInt16 nPos = aLineDist.GetSelectEntryPos();
226
227 if ( LISTBOX_ENTRY_NOTFOUND != nPos &&
228 ( nPos != aLineDist.GetSavedValue() ||
229 aLineDistAtPercentBox.IsValueModified() ||
230 aLineDistAtMetricBox.IsValueModified() ) )
231 {
232 nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
233 SfxMapUnit eUnit = pPool->GetMetric( nWhich );
234 SvxLineSpacingItem aSpacing(
235 (const SvxLineSpacingItem&)GetItemSet().Get( nWhich ) );
236
237 switch ( nPos )
238 {
239 case LLINESPACE_1:
240 case LLINESPACE_15:
241 case LLINESPACE_2:
242 SetLineSpace_Impl( aSpacing, nPos );
243 break;
244
245 case LLINESPACE_PROP:
246 SetLineSpace_Impl( aSpacing, nPos,
247 static_cast<long>(aLineDistAtPercentBox.Denormalize(
248 aLineDistAtPercentBox.GetValue() )) );
249 break;
250
251 case LLINESPACE_MIN:
252 case LLINESPACE_DURCH:
253 case LLINESPACE_FIX:
254 SetLineSpace_Impl( aSpacing, nPos,
255 GetCoreValue( aLineDistAtMetricBox, eUnit ) );
256 break;
257
258 default:
259 OSL_FAIL( "unbekannter Type fuer Zeilenabstand." );
260 break;
261 }
262 eState = GetItemSet().GetItemState( nWhich );
263 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_LINESPACE );
264
265 if ( !pOld || !( *(const SvxLineSpacingItem*)pOld == aSpacing ) ||
266 SFX_ITEM_DONTCARE == eState )
267 {
268 rOutSet.Put( aSpacing );
269 bModified = sal_True;
270 }
271 }
272
273 if ( aTopDist.IsValueModified() || aBottomDist.IsValueModified()
274 || aContextualCB.GetSavedValue() != aContextualCB.IsChecked())
275 {
276 nWhich = GetWhich( SID_ATTR_ULSPACE );
277 SfxMapUnit eUnit = pPool->GetMetric( nWhich );
278 pOld = GetOldItem( rOutSet, SID_ATTR_ULSPACE );
279 SvxULSpaceItem aMargin( nWhich );
280
281 if ( bRelativeMode )
282 {
283 DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
284
285 const SvxULSpaceItem& rOldItem =
286 (const SvxULSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
287
288 if ( aTopDist.IsRelative() )
289 aMargin.SetUpper( rOldItem.GetUpper(),
290 (sal_uInt16)aTopDist.GetValue() );
291 else
292 aMargin.SetUpper( (sal_uInt16)GetCoreValue( aTopDist, eUnit ) );
293
294 if ( aBottomDist.IsRelative() )
295 aMargin.SetLower( rOldItem.GetLower(),
296 (sal_uInt16)aBottomDist.GetValue() );
297 else
298 aMargin.SetLower( (sal_uInt16)GetCoreValue( aBottomDist, eUnit ) );
299
300 }
301 else
302 {
303 aMargin.SetUpper( (sal_uInt16)GetCoreValue( aTopDist, eUnit ) );
304 aMargin.SetLower( (sal_uInt16)GetCoreValue( aBottomDist, eUnit ) );
305 }
306 aMargin.SetContextValue(aContextualCB.IsChecked());
307 eState = GetItemSet().GetItemState( nWhich );
308
309 if ( !pOld || !( *(const SvxULSpaceItem*)pOld == aMargin ) ||
310 SFX_ITEM_DONTCARE == eState )
311 {
312 rOutSet.Put( aMargin );
313 bModified = sal_True;
314 }
315 }
316 bool bNullTab = false;
317
318 if ( aLeftIndent.IsValueModified() ||
319 aFLineIndent.IsValueModified() ||
320 aRightIndent.IsValueModified()
321 || aAutoCB.GetSavedValue() != aAutoCB.IsChecked() )
322 {
323 nWhich = GetWhich( SID_ATTR_LRSPACE );
324 SfxMapUnit eUnit = pPool->GetMetric( nWhich );
325 SvxLRSpaceItem aMargin( nWhich );
326 pOld = GetOldItem( rOutSet, SID_ATTR_LRSPACE );
327
328 if ( bRelativeMode )
329 {
330 DBG_ASSERT( GetItemSet().GetParent(), "No ParentSet" );
331
332 const SvxLRSpaceItem& rOldItem =
333 (const SvxLRSpaceItem&)GetItemSet().GetParent()->Get( nWhich );
334
335 if ( aLeftIndent.IsRelative() )
336 aMargin.SetTxtLeft( rOldItem.GetTxtLeft(),
337 (sal_uInt16)aLeftIndent.GetValue() );
338 else
339 aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );
340
341 if ( aRightIndent.IsRelative() )
342 aMargin.SetRight( rOldItem.GetRight(),
343 (sal_uInt16)aRightIndent.GetValue() );
344 else
345 aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );
346
347 if ( aFLineIndent.IsRelative() )
348 aMargin.SetTxtFirstLineOfst( rOldItem.GetTxtFirstLineOfst(),
349 (sal_uInt16)aFLineIndent.GetValue() );
350 else
351 aMargin.SetTxtFirstLineOfst(
352 (sal_uInt16)GetCoreValue( aFLineIndent, eUnit ) );
353 }
354 else
355 {
356 aMargin.SetTxtLeft( GetCoreValue( aLeftIndent, eUnit ) );
357 aMargin.SetRight( GetCoreValue( aRightIndent, eUnit ) );
358 aMargin.SetTxtFirstLineOfst(
359 (sal_uInt16)GetCoreValue( aFLineIndent, eUnit ) );
360 }
361 aMargin.SetAutoFirst(aAutoCB.IsChecked());
362 if ( aMargin.GetTxtFirstLineOfst() < 0 )
363 bNullTab = true;
364 eState = GetItemSet().GetItemState( nWhich );
365
366 if ( !pOld || !( *(const SvxLRSpaceItem*)pOld == aMargin ) ||
367 SFX_ITEM_DONTCARE == eState )
368 {
369 rOutSet.Put( aMargin );
370 bModified = sal_True;
371 }
372 }
373
374 if ( bNullTab )
375 {
376 MapUnit eUnit = (MapUnit)pPool->GetMetric( GetWhich( SID_ATTR_TABSTOP ) );
377 if ( MAP_100TH_MM != eUnit )
378 {
379
380 // negative first line indent -> set null default tabstob if applicable
381 sal_uInt16 _nWhich = GetWhich( SID_ATTR_TABSTOP );
382 const SfxItemSet& rInSet = GetItemSet();
383
384 if ( rInSet.GetItemState( _nWhich ) >= SFX_ITEM_AVAILABLE )
385 {
386 const SvxTabStopItem& rTabItem =
387 (const SvxTabStopItem&)rInSet.Get( _nWhich );
388 SvxTabStopItem aNullTab( rTabItem );
389 SvxTabStop aNull( 0, SVX_TAB_ADJUST_DEFAULT );
390 aNullTab.Insert( aNull );
391 rOutSet.Put( aNullTab );
392 }
393 }
394 }
395 if( aRegisterCB.IsVisible())
396 {
397 const SfxBoolItem* pBoolItem = (SfxBoolItem*)GetOldItem(
398 rOutSet, SID_ATTR_PARA_REGISTER);
399 SfxBoolItem* pRegItem = (SfxBoolItem*)pBoolItem->Clone();
400 sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
401 sal_Bool bSet = pRegItem->GetValue();
402
403 if(aRegisterCB.IsChecked() != bSet )
404 {
405 pRegItem->SetValue(!bSet);
406 rOutSet.Put(*pRegItem);
407 bModified = sal_True;
408 }
409 else if ( SFX_ITEM_DEFAULT == GetItemSet().GetItemState( _nWhich, sal_False ) )
410 rOutSet.ClearItem(_nWhich);
411 delete pRegItem;
412 }
413
414 return bModified;
415 }
416
417 // -----------------------------------------------------------------------
418
419 void SvxStdParagraphTabPage::Reset( const SfxItemSet& rSet )
420 {
421 SfxItemPool* pPool = rSet.GetPool();
422 DBG_ASSERT( pPool, "Wo ist der Pool?" );
423
424 // adjust metric
425 FieldUnit eFUnit = GetModuleFieldUnit( rSet );
426
427 bool bApplyCharUnit = GetApplyCharUnit( rSet );
428
429 SvtCJKOptions aCJKOptions;
430 if(aCJKOptions.IsAsianTypographyEnabled() && bApplyCharUnit )
431 eFUnit = FUNIT_CHAR;
432
433 SetFieldUnit( aLeftIndent, eFUnit );
434 SetFieldUnit( aRightIndent, eFUnit );
435 SetFieldUnit( aFLineIndent, eFUnit );
436 if ( eFUnit == FUNIT_CHAR )
437 {
438 SetFieldUnit( aTopDist, FUNIT_LINE );
439 SetFieldUnit( aBottomDist, FUNIT_LINE );
440 SetFieldUnit( aLineDistAtMetricBox, FUNIT_POINT );
441 }
442 else
443 {
444 SetFieldUnit( aTopDist, eFUnit );
445 SetFieldUnit( aBottomDist, eFUnit );
446 SetFieldUnit( aLineDistAtMetricBox, eFUnit );
447 }
448
449 sal_uInt16 _nWhich = GetWhich( SID_ATTR_LRSPACE );
450 SfxItemState eItemState = rSet.GetItemState( _nWhich );
451
452 if ( eItemState >= SFX_ITEM_AVAILABLE )
453 {
454 SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
455
456 if ( bRelativeMode )
457 {
458 const SvxLRSpaceItem& rOldItem =
459 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
460
461 if ( rOldItem.GetPropLeft() != 100 )
462 {
463 aLeftIndent.SetRelative( sal_True );
464 aLeftIndent.SetValue( rOldItem.GetPropLeft() );
465 }
466 else
467 {
468 aLeftIndent.SetRelative();
469 SetFieldUnit( aLeftIndent, eFUnit );
470 SetMetricValue( aLeftIndent, rOldItem.GetTxtLeft(), eUnit );
471 }
472
473 if ( rOldItem.GetPropRight() != 100 )
474 {
475 aRightIndent.SetRelative( sal_True );
476 aRightIndent.SetValue( rOldItem.GetPropRight() );
477 }
478 else
479 {
480 aRightIndent.SetRelative();
481 SetFieldUnit( aRightIndent, eFUnit );
482 SetMetricValue( aRightIndent, rOldItem.GetRight(), eUnit );
483 }
484
485 if ( rOldItem.GetPropTxtFirstLineOfst() != 100 )
486 {
487 aFLineIndent.SetRelative( sal_True );
488 aFLineIndent.SetValue( rOldItem.GetPropTxtFirstLineOfst() );
489 }
490 else
491 {
492 aFLineIndent.SetRelative();
493 aFLineIndent.SetMin(-9999);
494 SetFieldUnit( aFLineIndent, eFUnit );
495 SetMetricValue( aFLineIndent, rOldItem.GetTxtFirstLineOfst(),
496 eUnit );
497 }
498 aAutoCB.Check(rOldItem.IsAutoFirst());
499 }
500 else
501 {
502 const SvxLRSpaceItem& rSpace =
503 (const SvxLRSpaceItem&)rSet.Get( _nWhich );
504
505 SetMetricValue( aLeftIndent, rSpace.GetTxtLeft(), eUnit );
506 SetMetricValue( aRightIndent, rSpace.GetRight(), eUnit );
507 SetMetricValue( aFLineIndent, rSpace.GetTxtFirstLineOfst(), eUnit );
508 aAutoCB.Check(rSpace.IsAutoFirst());
509 }
510 AutoHdl_Impl(&aAutoCB);
511 }
512 else
513 {
514 aLeftIndent.SetEmptyFieldValue();
515 aRightIndent.SetEmptyFieldValue();
516 aFLineIndent.SetEmptyFieldValue();
517 }
518
519 _nWhich = GetWhich( SID_ATTR_ULSPACE );
520 eItemState = rSet.GetItemState( _nWhich );
521
522 if ( eItemState >= SFX_ITEM_AVAILABLE )
523 {
524 SfxMapUnit eUnit = pPool->GetMetric( _nWhich );
525
526 const SvxULSpaceItem& rOldItem =
527 (const SvxULSpaceItem&)rSet.Get( _nWhich );
528 if ( bRelativeMode )
529 {
530
531 if ( rOldItem.GetPropUpper() != 100 )
532 {
533 aTopDist.SetRelative( sal_True );
534 aTopDist.SetValue( rOldItem.GetPropUpper() );
535 }
536 else
537 {
538 aTopDist.SetRelative();
539 if ( eFUnit == FUNIT_CHAR )
540 SetFieldUnit( aTopDist, FUNIT_LINE );
541 else
542 SetFieldUnit( aTopDist, eFUnit );
543 SetMetricValue( aTopDist, rOldItem.GetUpper(), eUnit );
544 }
545
546 if ( rOldItem.GetPropLower() != 100 )
547 {
548 aBottomDist.SetRelative( sal_True );
549 aBottomDist.SetValue( rOldItem.GetPropLower() );
550 }
551 else
552 {
553 aBottomDist.SetRelative();
554 if ( eFUnit == FUNIT_CHAR )
555 SetFieldUnit( aBottomDist, FUNIT_LINE );
556 else
557 SetFieldUnit( aBottomDist, eFUnit );
558 SetMetricValue( aBottomDist, rOldItem.GetLower(), eUnit );
559 }
560 }
561 else
562 {
563 SetMetricValue( aTopDist, rOldItem.GetUpper(), eUnit );
564 SetMetricValue( aBottomDist, rOldItem.GetLower(), eUnit );
565 }
566 aContextualCB.Check(rOldItem.GetContext());
567 }
568 else
569 {
570 aTopDist.SetEmptyFieldValue();
571 aBottomDist.SetEmptyFieldValue();
572 }
573
574 _nWhich = GetWhich( SID_ATTR_PARA_LINESPACE );
575 eItemState = rSet.GetItemState( _nWhich );
576
577 if ( eItemState >= SFX_ITEM_AVAILABLE )
578 SetLineSpacing_Impl( (const SvxLineSpacingItem &)rSet.Get( _nWhich ) );
579 else
580 aLineDist.SetNoSelection();
581
582
583 _nWhich = GetWhich( SID_ATTR_PARA_REGISTER );
584 eItemState = rSet.GetItemState( _nWhich );
585
586 if ( eItemState >= SFX_ITEM_AVAILABLE )
587 aRegisterCB.Check( ((const SfxBoolItem &)rSet.Get( _nWhich )).GetValue());
588 aRegisterCB.SaveValue();
589 sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
590 if(nHtmlMode & HTMLMODE_ON)
591 {
592 aRegisterCB.Hide();
593 aRegisterFL.Hide();
594 aAutoCB.Hide();
595 if(!(nHtmlMode & HTMLMODE_SOME_STYLES)) // IE or SW
596 {
597 aRightLabel.Disable();
598 aRightIndent.Disable();
599 aTopDist.Disable(); //HTML3.2 and NS 3.0
600 aBottomDist.Disable();
601 aFLineIndent.Disable();
602 aFLineLabel.Disable();
603 }
604 }
605
606 ELRLoseFocusHdl( NULL );
607 aAutoCB.SaveValue();
608 aContextualCB.SaveValue();
609 aLineDist.SaveValue();
610 }
611
612 // -----------------------------------------------------------------------
613
614 void SvxStdParagraphTabPage::EnableRelativeMode()
615 {
616 DBG_ASSERT( GetItemSet().GetParent(), "RelativeMode, but no parent-set!" );
617
618 aLeftIndent.EnableRelativeMode( 0, 999 );
619 aFLineIndent.EnableRelativeMode( 0, 999 );
620 aRightIndent.EnableRelativeMode( 0, 999 );
621 aTopDist.EnableRelativeMode( 0, 999 );
622 aBottomDist.EnableRelativeMode( 0, 999 );
623 bRelativeMode = sal_True;
624 }
625
626 // -----------------------------------------------------------------------
627
628 int SvxStdParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
629 {
630 ELRLoseFocusHdl( NULL );
631
632 if ( _pSet )
633 FillItemSet( *_pSet );
634 return LEAVE_PAGE;
635 }
636
637 // -----------------------------------------------------------------------
638
639 SvxStdParagraphTabPage::SvxStdParagraphTabPage( Window* pParent,
640 const SfxItemSet& rAttr ) :
641
642 SfxTabPage( pParent, CUI_RES( RID_SVXPAGE_STD_PARAGRAPH ), rAttr ),
643
644 aIndentFrm ( this, CUI_RES( FL_INDENT ) ),
645 aLeftLabel ( this, CUI_RES( FT_LEFTINDENT ) ),
646 aLeftIndent ( this, CUI_RES( ED_LEFTINDENT ) ),
647 aRightLabel ( this, CUI_RES( FT_RIGHTINDENT ) ),
648 aRightIndent ( this, CUI_RES( ED_RIGHTINDENT ) ),
649
650 aFLineLabel ( this, CUI_RES( FT_FLINEINDENT ) ),
651 aFLineIndent ( this, CUI_RES( ED_FLINEINDENT ) ),
652 aAutoCB ( this, CUI_RES( CB_AUTO ) ),
653 aDistFrm ( this, CUI_RES( FL_DIST ) ),
654 aTopLabel ( this, CUI_RES( FT_TOPDIST ) ),
655 aTopDist ( this, CUI_RES( ED_TOPDIST ) ),
656 aBottomLabel ( this, CUI_RES( FT_BOTTOMDIST ) ),
657 aBottomDist ( this, CUI_RES( ED_BOTTOMDIST ) ),
658 aContextualCB ( this, CUI_RES( CB_CONTEXTUALSPACING ) ),
659
660 aLineDistFrm ( this, CUI_RES( FL_LINEDIST ) ),
661 aLineDist ( this, CUI_RES( LB_LINEDIST ) ),
662 aLineDistAtLabel ( this, CUI_RES( FT_LINEDIST ) ),
663 aLineDistAtPercentBox ( this, CUI_RES( ED_LINEDISTPERCENT ) ),
664 aLineDistAtMetricBox ( this, CUI_RES( ED_LINEDISTMETRIC ) ),
665 sAbsDist ( CUI_RES(ST_LINEDIST_ABS) ),
666 aExampleWin ( this, CUI_RES( WN_EXAMPLE ) ),
667 aRegisterFL ( this, CUI_RES( FL_REGISTER ) ),
668 aRegisterCB ( this, CUI_RES( CB_REGISTER ) ),
669 pActLineDistFld ( &aLineDistAtPercentBox ),
670 nAbst ( MAX_DURCH ),
671 nWidth ( 11905 /*567 * 50*/ ),
672 nMinFixDist(0L),
673
674 bRelativeMode ( sal_False ),
675 bNegativeIndents(sal_False)
676
677 {
678 // this page needs ExchangeSupport
679 SetExchangeSupport();
680
681 aLineDistAtMetricBox.Hide();
682 FreeResource();
683 Init_Impl();
684 aFLineIndent.SetMin(-9999); // is set to 0 on default
685
686 aExampleWin.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));
687
688 }
689
690
691 // -----------------------------------------------------------------------
692
693 void SvxStdParagraphTabPage::EnableNegativeMode()
694 {
695 aLeftIndent.SetMin(-9999);
696 aRightIndent.SetMin(-9999);
697 aRightIndent.EnableNegativeMode();
698 aLeftIndent.EnableNegativeMode();
699 bNegativeIndents = sal_True;
700 }
701
702 // -----------------------------------------------------------------------
703
704 sal_uInt16* SvxStdParagraphTabPage::GetRanges()
705 {
706 return pStdRanges;
707 }
708
709 // -----------------------------------------------------------------------
710
711 void SvxStdParagraphTabPage::SetLineSpacing_Impl
712 (
713 const SvxLineSpacingItem &rAttr
714 )
715 {
716 SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );
717
718 switch( rAttr.GetLineSpaceRule() )
719 {
720 case SVX_LINE_SPACE_AUTO:
721 {
722 SvxInterLineSpace eInter = rAttr.GetInterLineSpaceRule();
723
724 switch( eInter )
725 {
726 // Default single line spacing
727 case SVX_INTER_LINE_SPACE_OFF:
728 aLineDist.SelectEntryPos( LLINESPACE_1 );
729 break;
730
731 // Default single line spacing
732 case SVX_INTER_LINE_SPACE_PROP:
733 if ( 100 == rAttr.GetPropLineSpace() )
734 {
735 aLineDist.SelectEntryPos( LLINESPACE_1 );
736 break;
737 }
738 // 1.5 line spacing
739 if ( 150 == rAttr.GetPropLineSpace() )
740 {
741 aLineDist.SelectEntryPos( LLINESPACE_15 );
742 break;
743 }
744 // double line spacing
745 if ( 200 == rAttr.GetPropLineSpace() )
746 {
747 aLineDist.SelectEntryPos( LLINESPACE_2 );
748 break;
749 }
750 // the set per cent value
751 aLineDistAtPercentBox.
752 SetValue( aLineDistAtPercentBox.Normalize(
753 rAttr.GetPropLineSpace() ) );
754 aLineDist.SelectEntryPos( LLINESPACE_PROP );
755 break;
756
757 case SVX_INTER_LINE_SPACE_FIX:
758 SetMetricValue( aLineDistAtMetricBox,
759 rAttr.GetInterLineSpace(), eUnit );
760 aLineDist.SelectEntryPos( LLINESPACE_DURCH );
761 break;
762 default: ;//prevent warning
763 }
764 }
765 break;
766 case SVX_LINE_SPACE_FIX:
767 SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
768 aLineDist.SelectEntryPos( LLINESPACE_FIX );
769 break;
770
771 case SVX_LINE_SPACE_MIN:
772 SetMetricValue(aLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
773 aLineDist.SelectEntryPos( LLINESPACE_MIN );
774 break;
775 default: ;//prevent warning
776 }
777 LineDistHdl_Impl( &aLineDist );
778 }
779
780 // -----------------------------------------------------------------------
781
782 IMPL_LINK( SvxStdParagraphTabPage, LineDistHdl_Impl, ListBox *, pBox )
783 {
784 switch( pBox->GetSelectEntryPos() )
785 {
786 case LLINESPACE_1:
787 case LLINESPACE_15:
788 case LLINESPACE_2:
789 aLineDistAtLabel.Enable(sal_False);
790 pActLineDistFld->Enable(sal_False);
791 pActLineDistFld->SetText( String() );
792 break;
793
794 case LLINESPACE_DURCH:
795 // setting a sensible default?
796 // limit MS min(10, aPageSize)
797 aLineDistAtPercentBox.Hide();
798 pActLineDistFld = &aLineDistAtMetricBox;
799 aLineDistAtMetricBox.SetMin(0);
800
801
802 if ( aLineDistAtMetricBox.GetText().isEmpty() )
803 aLineDistAtMetricBox.SetValue(
804 aLineDistAtMetricBox.Normalize( 1 ) );
805 aLineDistAtPercentBox.Hide();
806 pActLineDistFld->Show();
807 pActLineDistFld->Enable();
808 aLineDistAtLabel.Enable();
809 break;
810
811 case LLINESPACE_MIN:
812 aLineDistAtPercentBox.Hide();
813 pActLineDistFld = &aLineDistAtMetricBox;
814 aLineDistAtMetricBox.SetMin(0);
815
816 if ( aLineDistAtMetricBox.GetText().isEmpty() )
817 aLineDistAtMetricBox.SetValue(
818 aLineDistAtMetricBox.Normalize( 10 ), FUNIT_TWIP );
819 aLineDistAtPercentBox.Hide();
820 pActLineDistFld->Show();
821 pActLineDistFld->Enable();
822 aLineDistAtLabel.Enable();
823 break;
824
825 case LLINESPACE_PROP:
826 aLineDistAtMetricBox.Hide();
827 pActLineDistFld = &aLineDistAtPercentBox;
828
829 if ( aLineDistAtPercentBox.GetText().isEmpty() )
830 aLineDistAtPercentBox.SetValue(
831 aLineDistAtPercentBox.Normalize( 100 ), FUNIT_TWIP );
832 aLineDistAtMetricBox.Hide();
833 pActLineDistFld->Show();
834 pActLineDistFld->Enable();
835 aLineDistAtLabel.Enable();
836 break;
837 case LLINESPACE_FIX:
838 {
839 aLineDistAtPercentBox.Hide();
840 pActLineDistFld = &aLineDistAtMetricBox;
841 sal_Int64 nTemp = aLineDistAtMetricBox.GetValue();
842 aLineDistAtMetricBox.SetMin(aLineDistAtMetricBox.Normalize(nMinFixDist), FUNIT_TWIP);
843
844 // if the value has been changed at SetMin,
845 // it is time for the default
846 if ( aLineDistAtMetricBox.GetValue() != nTemp )
847 SetMetricValue( aLineDistAtMetricBox,
848 FIX_DIST_DEF, SFX_MAPUNIT_TWIP ); // fix is only in Writer
849 aLineDistAtPercentBox.Hide();
850 pActLineDistFld->Show();
851 pActLineDistFld->Enable();
852 aLineDistAtLabel.Enable();
853 }
854 break;
855 }
856 UpdateExample_Impl( sal_True );
857 return 0;
858 }
859
860 // -----------------------------------------------------------------------
861
862 IMPL_LINK_NOARG_INLINE_START(SvxStdParagraphTabPage, ModifyHdl_Impl)
863 {
864 UpdateExample_Impl();
865 return 0;
866 }
867 IMPL_LINK_NOARG_INLINE_END(SvxStdParagraphTabPage, ModifyHdl_Impl)
868
869 // -----------------------------------------------------------------------
870
871 void SvxStdParagraphTabPage::Init_Impl()
872 {
873 aLineDist.SetSelectHdl(
874 LINK( this, SvxStdParagraphTabPage, LineDistHdl_Impl ) );
875
876 Link aLink = LINK( this, SvxStdParagraphTabPage, ELRLoseFocusHdl );
877 aFLineIndent.SetLoseFocusHdl( aLink );
878 aLeftIndent.SetLoseFocusHdl( aLink );
879 aRightIndent.SetLoseFocusHdl( aLink );
880
881 aLink = LINK( this, SvxStdParagraphTabPage, ModifyHdl_Impl );
882 aFLineIndent.SetModifyHdl( aLink );
883 aLeftIndent.SetModifyHdl( aLink );
884 aRightIndent.SetModifyHdl( aLink );
885 aTopDist.SetModifyHdl( aLink );
886 aBottomDist.SetModifyHdl( aLink );
887
888 aAutoCB.SetClickHdl( LINK( this, SvxStdParagraphTabPage, AutoHdl_Impl ));
889 SfxItemPool* pPool = GetItemSet().GetPool();
890 DBG_ASSERT( pPool, "Wo ist der Pool" );
891 FieldUnit eUnit =
892 MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
893
894 aTopDist.SetMax( aTopDist.Normalize( nAbst ), eUnit );
895 aBottomDist.SetMax( aBottomDist.Normalize( nAbst ), eUnit );
896 aLineDistAtMetricBox.SetMax(
897 aLineDistAtMetricBox.Normalize( nAbst ), eUnit );
898 }
899
900 // -----------------------------------------------------------------------
901
902 void SvxStdParagraphTabPage::UpdateExample_Impl( sal_Bool bAll )
903 {
904 aExampleWin.SetFirstLineOfst(
905 (short)aFLineIndent.Denormalize( aFLineIndent.GetValue( FUNIT_TWIP ) ) );
906 aExampleWin.SetLeftMargin(
907 static_cast<long>(aLeftIndent.Denormalize( aLeftIndent.GetValue( FUNIT_TWIP ) ) ) );
908 aExampleWin.SetRightMargin(
909 static_cast<long>(aRightIndent.Denormalize( aRightIndent.GetValue( FUNIT_TWIP ) ) ) );
910 aExampleWin.SetUpper(
911 (sal_uInt16)aTopDist.Denormalize( aTopDist.GetValue( FUNIT_TWIP ) ) );
912 aExampleWin.SetLower(
913 (sal_uInt16)aBottomDist.Denormalize( aBottomDist.GetValue( FUNIT_TWIP ) ) );
914
915
916
917 sal_uInt16 nPos = aLineDist.GetSelectEntryPos();
918
919 switch ( nPos )
920 {
921 case LLINESPACE_1:
922 case LLINESPACE_15:
923 case LLINESPACE_2:
924 aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos );
925 break;
926
927 case LLINESPACE_PROP:
928 aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
929 (sal_uInt16)aLineDistAtPercentBox.Denormalize(
930 aLineDistAtPercentBox.GetValue() ) );
931 break;
932
933 case LLINESPACE_MIN:
934 case LLINESPACE_DURCH:
935 case LLINESPACE_FIX:
936 aExampleWin.SetLineSpace( (SvxPrevLineSpace)nPos,
937 (sal_uInt16)GetCoreValue( aLineDistAtMetricBox, SFX_MAPUNIT_TWIP ) );
938 break;
939 }
940 aExampleWin.Draw( bAll );
941 }
942
943 // -----------------------------------------------------------------------
944
945 void SvxStdParagraphTabPage::EnableRegisterMode()
946 {
947 aRegisterCB.Show();
948 aRegisterFL.Show();
949 }
950
951 void SvxStdParagraphTabPage::EnableContextualMode()
952 {
953 aContextualCB.Show();
954 }
955
956 IMPL_LINK( SvxStdParagraphTabPage, AutoHdl_Impl, CheckBox*, pBox )
957 {
958 sal_Bool bEnable = !pBox->IsChecked();
959 aFLineLabel .Enable(bEnable);
960 aFLineIndent.Enable(bEnable);
961 return 0;
962 }
963
964 void SvxStdParagraphTabPage::SetPageWidth( sal_uInt16 nPageWidth )
965 {
966 nWidth = nPageWidth;
967 }
968
969
970 void SvxStdParagraphTabPage::EnableAutoFirstLine()
971 {
972 aAutoCB.Show();
973 }
974
975
976 void SvxStdParagraphTabPage::EnableAbsLineDist(long nMinTwip)
977 {
978 aLineDist.InsertEntry(sAbsDist);
979 nMinFixDist = nMinTwip;
980 }
981
982
983 void SvxStdParagraphTabPage::PageCreated(SfxAllItemSet aSet)
984 {
985
986 /* different bit represent call to different method of SvxStdParagraphTabPage
987 0x0001 --->EnableRelativeMode()
988 0x0002 --->EnableRegisterMode()
989 0x0004 --->EnableAutoFirstLine()
990 0x0008 --->EnableNegativeMode()
991 0x0010 --->EnableContextualMode()
992 */
993 SFX_ITEMSET_ARG (&aSet,pPageWidthItem,SfxUInt16Item,SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH,sal_False);
994 SFX_ITEMSET_ARG (&aSet,pFlagSetItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET,sal_False);
995 SFX_ITEMSET_ARG (&aSet,pLineDistItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST,sal_False);
996
997 if (pPageWidthItem)
998 SetPageWidth(pPageWidthItem->GetValue());
999
1000 if (pFlagSetItem )
1001 if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
1002 EnableRelativeMode();
1003
1004 if (pFlagSetItem)
1005 if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
1006 EnableRegisterMode();
1007
1008 if (pFlagSetItem)
1009 if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
1010 EnableAutoFirstLine();
1011
1012 if(pLineDistItem)
1013 EnableAbsLineDist(pLineDistItem->GetValue());
1014
1015 if (pFlagSetItem)
1016 if (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
1017 EnableNegativeMode();
1018
1019 if (pFlagSetItem)
1020 if (( 0x0010 & pFlagSetItem->GetValue()) == 0x0010 )
1021 EnableContextualMode();
1022 }
1023
1024
1025 #define LASTLINEPOS_DEFAULT 0
1026 #define LASTLINEPOS_LEFT 1
1027
1028 #define LASTLINECOUNT_OLD 3
1029 #define LASTLINECOUNT_NEW 4
1030
1031 // class SvxParaAlignTabPage ------------------------------------------------
1032
1033 SvxParaAlignTabPage::SvxParaAlignTabPage( Window* pParent, const SfxItemSet& rSet )
1034 : SfxTabPage(pParent, CUI_RES( RID_SVXPAGE_ALIGN_PARAGRAPH ),rSet),
1035 aAlignFrm ( this, CUI_RES( FL_ALIGN ) ),
1036 aLeft ( this, CUI_RES( BTN_LEFTALIGN ) ),
1037 aRight ( this, CUI_RES( BTN_RIGHTALIGN ) ),
1038 aCenter ( this, CUI_RES( BTN_CENTERALIGN ) ),
1039 aJustify ( this, CUI_RES( BTN_JUSTIFYALIGN ) ),
1040 aLastLineFT ( this, CUI_RES( FT_LASTLINE ) ),
1041 aLastLineLB ( this, CUI_RES( LB_LASTLINE ) ),
1042 aExpandCB ( this, CUI_RES( CB_EXPAND ) ),
1043 aSnapToGridCB ( this, CUI_RES( CB_SNAP ) ),
1044 aExampleWin ( this, CUI_RES( WN_EXAMPLE ) ),
1045
1046 aVertAlignFL ( this, CUI_RES( FL_VERTALIGN ) ),
1047 aVertAlignFT ( this, CUI_RES( FT_VERTALIGN ) ),
1048 aVertAlignLB ( this, CUI_RES( LB_VERTALIGN ) ),
1049
1050 aPropertiesFL ( this, CUI_RES( FL_PROPERTIES )),
1051 aTextDirectionFT ( this, CUI_RES( FT_TEXTDIRECTION )),
1052 aTextDirectionLB ( this, CUI_RES( LB_TEXTDIRECTION ))
1053 {
1054 SvtLanguageOptions aLangOptions;
1055 sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT;
1056
1057 if ( aLangOptions.IsAsianTypographyEnabled() )
1058 {
1059 String sLeft(CUI_RES(ST_LEFTALIGN_ASIAN));
1060 aLeft.SetText(sLeft);
1061 aRight.SetText(String(CUI_RES(ST_RIGHTALIGN_ASIAN)));
1062 sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );
1063
1064 if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_OLD )
1065 {
1066 aLastLineLB.RemoveEntry( 0 );
1067 aLastLineLB.InsertEntry( sLeft, 0 );
1068 }
1069 else
1070 nLastLinePos = LASTLINEPOS_LEFT;
1071 }
1072 // remove "Default" or "Left" entry, depends on CJKOptions
1073 if ( aLastLineLB.GetEntryCount() == LASTLINECOUNT_NEW )
1074 aLastLineLB.RemoveEntry( nLastLinePos );
1075
1076 FreeResource();
1077 Link aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
1078 aLeft.SetClickHdl( aLink );
1079 aRight.SetClickHdl( aLink );
1080 aCenter.SetClickHdl( aLink );
1081 aJustify.SetClickHdl( aLink );
1082 aLastLineLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, LastLineHdl_Impl ) );
1083 aTextDirectionLB.SetSelectHdl( LINK( this, SvxParaAlignTabPage, TextDirectionHdl_Impl ) );
1084
1085 sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
1086 if(!(nHtmlMode & HTMLMODE_ON) || (0 != (nHtmlMode & HTMLMODE_SOME_STYLES)) )
1087 {
1088 if( aLangOptions.IsCTLFontEnabled() )
1089 {
1090 aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_LTR ), FRMDIR_HORI_LEFT_TOP );
1091 aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_RTL ), FRMDIR_HORI_RIGHT_TOP );
1092 aTextDirectionLB.InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_SUPER ), FRMDIR_ENVIRONMENT );
1093
1094 aPropertiesFL.Show();
1095 aTextDirectionFT.Show();
1096 aTextDirectionLB.Show();
1097 }
1098 }
1099
1100 aExampleWin.SetAccessibleName(String(CUI_RES(STR_EXAMPLE)));
1101
1102 }
1103
1104 SvxParaAlignTabPage::~SvxParaAlignTabPage()
1105 {
1106 }
1107
1108 int SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
1109 {
1110 if ( _pSet )
1111 FillItemSet( *_pSet );
1112 return LEAVE_PAGE;
1113 }
1114
1115 SfxTabPage* SvxParaAlignTabPage::Create( Window* pParent, const SfxItemSet& rSet )
1116 {
1117 return new SvxParaAlignTabPage(pParent, rSet);
1118 }
1119
1120 sal_uInt16* SvxParaAlignTabPage::GetRanges()
1121 {
1122 return pAlignRanges;
1123
1124 }
1125
1126 sal_Bool SvxParaAlignTabPage::FillItemSet( SfxItemSet& rOutSet )
1127 {
1128 sal_Bool bModified = sal_False;
1129
1130 bool bAdj = false, bChecked = false;
1131 SvxAdjust eAdjust = SVX_ADJUST_LEFT;
1132
1133 if ( aLeft.IsChecked() )
1134 {
1135 eAdjust = SVX_ADJUST_LEFT;
1136 bAdj = !aLeft.GetSavedValue();
1137 bChecked = true;
1138 }
1139 else if ( aRight.IsChecked() )
1140 {
1141 eAdjust = SVX_ADJUST_RIGHT;
1142 bAdj = !aRight.GetSavedValue();
1143 bChecked = true;
1144 }
1145 else if ( aCenter.IsChecked() )
1146 {
1147 eAdjust = SVX_ADJUST_CENTER;
1148 bAdj = !aCenter.GetSavedValue();
1149 bChecked = true;
1150 }
1151 else if ( aJustify.IsChecked() )
1152 {
1153 eAdjust = SVX_ADJUST_BLOCK;
1154 bAdj = !aJustify.GetSavedValue() ||
1155 aExpandCB.IsChecked() != aExpandCB.GetSavedValue() ||
1156 aLastLineLB.GetSelectEntryPos() != aLastLineLB.GetSavedValue();
1157 bChecked = true;
1158 }
1159 sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1160
1161 if ( bAdj )
1162 {
1163 const SvxAdjustItem* pOld =
1164 (const SvxAdjustItem*)GetOldItem( rOutSet, SID_ATTR_PARA_ADJUST );
1165 SvxAdjust eOneWord = aExpandCB.IsChecked() ? SVX_ADJUST_BLOCK
1166 : SVX_ADJUST_LEFT;
1167 sal_uInt16 nLBPos = aLastLineLB.GetSelectEntryPos();
1168 SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1169
1170 if ( 1 == nLBPos )
1171 eLastBlock = SVX_ADJUST_CENTER;
1172 else if ( 2 == nLBPos )
1173 eLastBlock = SVX_ADJUST_BLOCK;
1174
1175 bool bNothingWasChecked =
1176 !aLeft.GetSavedValue() && !aRight.GetSavedValue() &&
1177 !aCenter.GetSavedValue() && !aJustify.GetSavedValue();
1178
1179 if ( !pOld || pOld->GetAdjust() != eAdjust ||
1180 pOld->GetOneWord() != eOneWord ||
1181 pOld->GetLastBlock() != eLastBlock ||
1182 ( bChecked && bNothingWasChecked ) )
1183 {
1184 bModified = sal_True;
1185 SvxAdjustItem aAdj(
1186 (const SvxAdjustItem&)GetItemSet().Get( _nWhich ) );
1187 aAdj.SetAdjust( eAdjust );
1188 aAdj.SetOneWord( eOneWord );
1189 aAdj.SetLastBlock( eLastBlock );
1190 rOutSet.Put( aAdj );
1191 }
1192 }
1193 if(aSnapToGridCB.IsChecked() != aSnapToGridCB.GetSavedValue())
1194 {
1195 rOutSet.Put(SvxParaGridItem(aSnapToGridCB.IsChecked(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
1196 bModified = sal_True;
1197 }
1198 if(aVertAlignLB.GetSavedValue() != aVertAlignLB.GetSelectEntryPos())
1199 {
1200 rOutSet.Put(SvxParaVertAlignItem(aVertAlignLB.GetSelectEntryPos(), GetWhich( SID_PARA_VERTALIGN )));
1201 bModified = sal_True;
1202 }
1203
1204 if( aTextDirectionLB.IsVisible() )
1205 {
1206 SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
1207 if( eDir != aTextDirectionLB.GetSavedValue() )
1208 {
1209 rOutSet.Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
1210 bModified = sal_True;
1211 }
1212 }
1213
1214 return bModified;
1215 }
1216
1217 void SvxParaAlignTabPage::Reset( const SfxItemSet& rSet )
1218 {
1219 sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1220 SfxItemState eItemState = rSet.GetItemState( _nWhich );
1221
1222 sal_uInt16 nLBSelect = 0;
1223 if ( eItemState >= SFX_ITEM_AVAILABLE )
1224 {
1225 const SvxAdjustItem& rAdj = (const SvxAdjustItem&)rSet.Get( _nWhich );
1226
1227 switch ( rAdj.GetAdjust() /*!!! ask VB rAdj.GetLastBlock()*/ )
1228 {
1229 case SVX_ADJUST_LEFT: aLeft.Check(); break;
1230
1231 case SVX_ADJUST_RIGHT: aRight.Check(); break;
1232
1233 case SVX_ADJUST_CENTER: aCenter.Check(); break;
1234
1235 case SVX_ADJUST_BLOCK: aJustify.Check(); break;
1236 default: ; //prevent warning
1237 }
1238 sal_Bool bEnable = aJustify.IsChecked();
1239 aLastLineFT.Enable(bEnable);
1240 aLastLineLB.Enable(bEnable);
1241 aExpandCB .Enable(bEnable);
1242
1243 aExpandCB.Check(SVX_ADJUST_BLOCK == rAdj.GetOneWord());
1244 switch(rAdj.GetLastBlock())
1245 {
1246 case SVX_ADJUST_LEFT: nLBSelect = 0; break;
1247
1248 case SVX_ADJUST_CENTER: nLBSelect = 1; break;
1249
1250 case SVX_ADJUST_BLOCK: nLBSelect = 2; break;
1251 default: ; //prevent warning
1252 }
1253 }
1254 else
1255 {
1256 aLeft.Check( sal_False );
1257 aRight.Check( sal_False );
1258 aCenter.Check( sal_False );
1259 aJustify.Check( sal_False );
1260 }
1261 aLastLineLB.SelectEntryPos(nLBSelect);
1262
1263 sal_uInt16 nHtmlMode = GetHtmlMode_Impl(rSet);
1264 if(nHtmlMode & HTMLMODE_ON)
1265 {
1266 aLastLineLB.Hide();
1267 aLastLineFT.Hide();
1268 aExpandCB.Hide();
1269 if(!(nHtmlMode & HTMLMODE_FULL_STYLES) )
1270 aJustify.Disable();
1271 aSnapToGridCB.Show(sal_False);
1272 }
1273 _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
1274 eItemState = rSet.GetItemState( _nWhich );
1275 if ( eItemState >= SFX_ITEM_AVAILABLE )
1276 {
1277 const SvxParaGridItem& rSnap = (const SvxParaGridItem&)rSet.Get( _nWhich );
1278 aSnapToGridCB.Check(rSnap.GetValue());
1279 }
1280
1281 _nWhich = GetWhich( SID_PARA_VERTALIGN );
1282 eItemState = rSet.GetItemState( _nWhich );
1283
1284 if ( eItemState >= SFX_ITEM_AVAILABLE )
1285 {
1286 aVertAlignLB.Show();
1287 aVertAlignFL.Show();
1288 aVertAlignFT.Show();
1289
1290 const SvxParaVertAlignItem& rAlign = (const SvxParaVertAlignItem&)rSet.Get( _nWhich );
1291 aVertAlignLB.SelectEntryPos(rAlign.GetValue());
1292 }
1293
1294 _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
1295 //text direction
1296 if( SFX_ITEM_AVAILABLE <= rSet.GetItemState( _nWhich ) )
1297 {
1298 const SvxFrameDirectionItem& rFrameDirItem = ( const SvxFrameDirectionItem& ) rSet.Get( _nWhich );
1299 aTextDirectionLB.SelectEntryValue( (SvxFrameDirection)rFrameDirItem.GetValue() );
1300 aTextDirectionLB.SaveValue();
1301 }
1302
1303 aSnapToGridCB.SaveValue();
1304 aVertAlignLB.SaveValue();
1305 aLeft.SaveValue();
1306 aRight.SaveValue();
1307 aCenter.SaveValue();
1308 aJustify.SaveValue();
1309 aLastLineLB.SaveValue();
1310 aExpandCB.SaveValue();
1311
1312 UpdateExample_Impl(sal_True);
1313 }
1314
1315 IMPL_LINK_NOARG(SvxParaAlignTabPage, AlignHdl_Impl)
1316 {
1317 sal_Bool bJustify = aJustify.IsChecked();
1318 aLastLineFT.Enable(bJustify);
1319 aLastLineLB.Enable(bJustify);
1320 aExpandCB.Enable(bJustify);
1321 UpdateExample_Impl(sal_False);
1322 return 0;
1323 }
1324
1325 IMPL_LINK_NOARG(SvxParaAlignTabPage, LastLineHdl_Impl)
1326 {
1327 UpdateExample_Impl(sal_False);
1328 return 0;
1329 }
1330
1331 IMPL_LINK_NOARG(SvxParaAlignTabPage, TextDirectionHdl_Impl)
1332 {
1333 SvxFrameDirection eDir = aTextDirectionLB.GetSelectEntryValue();
1334 switch ( eDir )
1335 {
1336 // check the default alignment for this text direction
1337 case FRMDIR_HORI_LEFT_TOP : aLeft.Check( sal_True ); break;
1338 case FRMDIR_HORI_RIGHT_TOP : aRight.Check( sal_True ); break;
1339 case FRMDIR_ENVIRONMENT : /* do nothing */ break;
1340 default:
1341 {
1342 SAL_WARN( "cui.tabpages", "SvxParaAlignTabPage::TextDirectionHdl_Impl(): other directions not supported" );
1343 }
1344 }
1345
1346 return 0;
1347 }
1348
1349 void SvxParaAlignTabPage::UpdateExample_Impl( sal_Bool bAll )
1350 {
1351 if ( aLeft.IsChecked() )
1352 aExampleWin.SetAdjust( SVX_ADJUST_LEFT );
1353 else if ( aRight.IsChecked() )
1354 aExampleWin.SetAdjust( SVX_ADJUST_RIGHT );
1355 else if ( aCenter.IsChecked() )
1356 aExampleWin.SetAdjust( SVX_ADJUST_CENTER );
1357 else if ( aJustify.IsChecked() )
1358 {
1359 aExampleWin.SetAdjust( SVX_ADJUST_BLOCK );
1360 SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1361 sal_uInt16 nLBPos = aLastLineLB.GetSelectEntryPos();
1362 if(nLBPos == 1)
1363 eLastBlock = SVX_ADJUST_CENTER;
1364 else if(nLBPos == 2)
1365 eLastBlock = SVX_ADJUST_BLOCK;
1366 aExampleWin.SetLastLine( eLastBlock );
1367 }
1368
1369 aExampleWin.Draw( bAll );
1370 }
1371
1372 void SvxParaAlignTabPage::EnableJustifyExt()
1373 {
1374 aLastLineFT.Show();
1375 aLastLineLB.Show();
1376 aExpandCB .Show();
1377 SvtLanguageOptions aCJKOptions;
1378 if(aCJKOptions.IsAsianTypographyEnabled())
1379 aSnapToGridCB.Show();
1380
1381 }
1382
1383 void SvxParaAlignTabPage::PageCreated (SfxAllItemSet aSet)
1384 {
1385 SFX_ITEMSET_ARG (&aSet,pBoolItem,SfxBoolItem,SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT,sal_False);
1386 if (pBoolItem)
1387 if(pBoolItem->GetValue())
1388 EnableJustifyExt();
1389 }
1390
1391 SfxTabPage* SvxExtParagraphTabPage::Create( Window* pParent,
1392 const SfxItemSet& rSet )
1393 {
1394 return new SvxExtParagraphTabPage( pParent, rSet );
1395 }
1396
1397 // -----------------------------------------------------------------------
1398
1399 sal_Bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet& rOutSet )
1400 {
1401 sal_Bool bModified = sal_False;
1402 sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1403 const TriState eHyphenState = m_pHyphenBox->GetState();
1404 const SfxPoolItem* pOld = GetOldItem( rOutSet, SID_ATTR_PARA_HYPHENZONE );
1405
1406 if ( eHyphenState != m_pHyphenBox->GetSavedValue() ||
1407 m_pExtHyphenBeforeBox->IsValueModified() ||
1408 m_pExtHyphenAfterBox->IsValueModified() ||
1409 m_pMaxHyphenEdit->IsValueModified() )
1410 {
1411 SvxHyphenZoneItem aHyphen(
1412 (const SvxHyphenZoneItem&)GetItemSet().Get( _nWhich ) );
1413 aHyphen.SetHyphen( eHyphenState == STATE_CHECK );
1414
1415 if ( eHyphenState == STATE_CHECK )
1416 {
1417 aHyphen.GetMinLead() = (sal_uInt8)m_pExtHyphenBeforeBox->GetValue();
1418 aHyphen.GetMinTrail() = (sal_uInt8)m_pExtHyphenAfterBox->GetValue();
1419 }
1420 aHyphen.GetMaxHyphens() = (sal_uInt8)m_pMaxHyphenEdit->GetValue();
1421
1422 if ( !pOld ||
1423 !( *(SvxHyphenZoneItem*)pOld == aHyphen ) ||
1424 eHyphenState != m_pHyphenBox->GetSavedValue())
1425 {
1426 rOutSet.Put( aHyphen );
1427 bModified = sal_True;
1428 }
1429 }
1430
1431 if (m_pPagenumEdit->IsEnabled() && m_pPagenumEdit->IsValueModified())
1432 {
1433 SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM,
1434 (sal_uInt16)m_pPagenumEdit->GetValue() );
1435
1436 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGENUM );
1437
1438 if ( !pOld || ( (const SfxUInt16Item*)pOld )->GetValue() != aPageNum.GetValue() )
1439 {
1440 rOutSet.Put( aPageNum );
1441 bModified = sal_True;
1442 }
1443 }
1444
1445 // pagebreak
1446
1447 TriState eState = m_pApplyCollBtn->GetState();
1448 bool bIsPageModel = false;
1449
1450 _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1451 String sPage;
1452 if ( eState != m_pApplyCollBtn->GetSavedValue() ||
1453 ( STATE_CHECK == eState &&
1454 m_pApplyCollBox->GetSelectEntryPos() != m_pApplyCollBox->GetSavedValue() ) )
1455 {
1456 if ( eState == STATE_CHECK )
1457 {
1458 sPage = m_pApplyCollBox->GetSelectEntry();
1459 bIsPageModel = 0 != sPage.Len();
1460 }
1461 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_MODEL );
1462
1463 if ( !pOld || ( (const SvxPageModelItem*)pOld )->GetValue() != sPage )
1464 {
1465 rOutSet.Put( SvxPageModelItem( sPage, sal_False, _nWhich ) );
1466 bModified = sal_True;
1467 }
1468 else
1469 bIsPageModel = false;
1470 }
1471 else if(STATE_CHECK == eState && m_pApplyCollBtn->IsEnabled())
1472 bIsPageModel = true;
1473 else
1474 rOutSet.Put( SvxPageModelItem( sPage, sal_False, _nWhich ) );
1475
1476 _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1477
1478 if ( bIsPageModel )
1479 // if PageModel is turned on, always turn off PageBreak
1480 rOutSet.Put( SvxFmtBreakItem( SVX_BREAK_NONE, _nWhich ) );
1481 else
1482 {
1483 eState = m_pPageBreakBox->GetState();
1484 SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, sal_False);
1485
1486 if ( (eModelState == SFX_ITEM_SET && STATE_CHECK == m_pPageBreakBox->GetState()) ||
1487 eState != m_pPageBreakBox->GetSavedValue() ||
1488 m_pBreakTypeLB->GetSelectEntryPos() != m_pBreakTypeLB->GetSavedValue() ||
1489 m_pBreakPositionLB->GetSelectEntryPos() != m_pBreakPositionLB->GetSavedValue() )
1490 {
1491 const SvxFmtBreakItem rOldBreak(
1492 (const SvxFmtBreakItem&)GetItemSet().Get( _nWhich ));
1493 SvxFmtBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());
1494
1495 switch ( eState )
1496 {
1497 case STATE_CHECK:
1498 {
1499 sal_Bool bBefore = m_pBreakPositionLB->GetSelectEntryPos() == 0;
1500
1501 if ( m_pBreakTypeLB->GetSelectEntryPos() == 0 )
1502 {
1503 if ( bBefore )
1504 aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
1505 else
1506 aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
1507 }
1508 else
1509 {
1510 if ( bBefore )
1511 aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
1512 else
1513 aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
1514 }
1515 break;
1516 }
1517
1518 case STATE_NOCHECK:
1519 aBreak.SetValue( SVX_BREAK_NONE );
1520 break;
1521 default: ; //prevent warning
1522 }
1523 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_PAGEBREAK );
1524
1525 if ( eState != m_pPageBreakBox->GetSavedValue() ||
1526 !pOld || !( *(const SvxFmtBreakItem*)pOld == aBreak ) )
1527 {
1528 bModified = sal_True;
1529 rOutSet.Put( aBreak );
1530 }
1531 }
1532 }
1533
1534
1535 // paragraph split
1536 _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1537 eState = m_pKeepTogetherBox->GetState();
1538
1539 if ( eState != m_pKeepTogetherBox->GetSavedValue() )
1540 {
1541 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_SPLIT );
1542
1543 if ( !pOld || ( (const SvxFmtSplitItem*)pOld )->GetValue() !=
1544 ( eState == STATE_NOCHECK ) )
1545 {
1546 rOutSet.Put( SvxFmtSplitItem( eState == STATE_NOCHECK, _nWhich ) );
1547 bModified = sal_True;
1548 }
1549 }
1550
1551 // keep paragraphs
1552 _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1553 eState = m_pKeepParaBox->GetState();
1554
1555 if ( eState != m_pKeepParaBox->GetSavedValue() )
1556 {
1557 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_KEEP );
1558
1559 // if the status has changed, putting is necessary
1560 rOutSet.Put( SvxFmtKeepItem( eState == STATE_CHECK, _nWhich ) );
1561 bModified = sal_True;
1562 }
1563
1564 // widows and orphans
1565 _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1566 eState = m_pWidowBox->GetState();
1567
1568 if ( eState != m_pWidowBox->GetSavedValue() ||
1569 m_pWidowRowNo->IsValueModified() )
1570 {
1571 SvxWidowsItem rItem( eState == STATE_CHECK ?
1572 (sal_uInt8)m_pWidowRowNo->GetValue() : 0, _nWhich );
1573 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_WIDOWS );
1574
1575 if ( eState != m_pWidowBox->GetSavedValue() || !pOld || !( *(const SvxWidowsItem*)pOld == rItem ) )
1576 {
1577 rOutSet.Put( rItem );
1578 bModified = sal_True;
1579 }
1580 }
1581
1582 _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1583 eState = m_pOrphanBox->GetState();
1584
1585 if ( eState != m_pOrphanBox->GetSavedValue() ||
1586 m_pOrphanRowNo->IsValueModified() )
1587 {
1588 SvxOrphansItem rItem( eState == STATE_CHECK ?
1589 (sal_uInt8)m_pOrphanRowNo->GetValue() : 0, _nWhich );
1590 pOld = GetOldItem( rOutSet, SID_ATTR_PARA_ORPHANS );
1591
1592 if ( eState != m_pOrphanBox->GetSavedValue() ||
1593 !pOld ||
1594 !( *(const SvxOrphansItem*)pOld == rItem ) )
1595 {
1596 rOutSet.Put( rItem );
1597 bModified = sal_True;
1598 }
1599 }
1600
1601 return bModified;
1602 }
1603
1604 // -----------------------------------------------------------------------
1605
1606 void SvxExtParagraphTabPage::Reset( const SfxItemSet& rSet )
1607 {
1608 sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1609 SfxItemState eItemState = rSet.GetItemState( _nWhich );
1610
1611 sal_Bool bItemAvailable = eItemState >= SFX_ITEM_AVAILABLE;
1612 sal_Bool bIsHyphen = sal_False;
1613 if( !bHtmlMode && bItemAvailable )
1614 {
1615 const SvxHyphenZoneItem& rHyphen =
1616 (const SvxHyphenZoneItem&)rSet.Get( _nWhich );
1617 m_pHyphenBox->EnableTriState( sal_False );
1618
1619 bIsHyphen = rHyphen.IsHyphen();
1620 m_pHyphenBox->SetState( bIsHyphen ? STATE_CHECK : STATE_NOCHECK );
1621
1622 m_pExtHyphenBeforeBox->SetValue( rHyphen.GetMinLead() );
1623 m_pExtHyphenAfterBox->SetValue( rHyphen.GetMinTrail() );
1624 m_pMaxHyphenEdit->SetValue( rHyphen.GetMaxHyphens() );
1625 }
1626 else
1627 {
1628 m_pHyphenBox->SetState( STATE_DONTKNOW );
1629 }
1630 sal_Bool bEnable = bItemAvailable && bIsHyphen;
1631 m_pExtHyphenBeforeBox->Enable(bEnable);
1632 m_pExtHyphenAfterBox->Enable(bEnable);
1633 m_pBeforeText->Enable(bEnable);
1634 m_pAfterText->Enable(bEnable);
1635 m_pMaxHyphenLabel->Enable(bEnable);
1636 m_pMaxHyphenEdit->Enable(bEnable);
1637
1638 _nWhich = GetWhich( SID_ATTR_PARA_PAGENUM );
1639
1640 if ( rSet.GetItemState(_nWhich) >= SFX_ITEM_AVAILABLE )
1641 {
1642 const sal_uInt16 nPageNum =
1643 ( (const SfxUInt16Item&)rSet.Get( _nWhich ) ).GetValue();
1644 m_pPagenumEdit->SetValue( nPageNum );
1645 }
1646
1647 if ( bPageBreak )
1648 {
1649 // first handle PageModel
1650 _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1651 sal_Bool bIsPageModel = sal_False;
1652 eItemState = rSet.GetItemState( _nWhich );
1653
1654 if ( eItemState >= SFX_ITEM_SET )
1655 {
1656 m_pApplyCollBtn->EnableTriState( sal_False );
1657
1658 const SvxPageModelItem& rModel =
1659 (const SvxPageModelItem&)rSet.Get( _nWhich );
1660 String aStr( rModel.GetValue() );
1661
1662 if ( aStr.Len() &&
1663 m_pApplyCollBox->GetEntryPos( aStr ) != LISTBOX_ENTRY_NOTFOUND )
1664 {
1665 m_pApplyCollBox->SelectEntry( aStr );
1666 m_pApplyCollBtn->SetState( STATE_CHECK );
1667 bIsPageModel = sal_True;
1668
1669 m_pPageBreakBox->Enable();
1670 m_pPageBreakBox->EnableTriState( sal_False );
1671 m_pBreakTypeFT->Enable();
1672 m_pBreakTypeLB->Enable();
1673 m_pBreakPositionFT->Enable();
1674 m_pBreakPositionLB->Enable();
1675 m_pApplyCollBtn->Enable();
1676 m_pPageBreakBox->SetState( STATE_CHECK );
1677
1678 //select page break
1679 m_pBreakTypeLB->SelectEntryPos(0);
1680 //select break before
1681 m_pBreakPositionLB->SelectEntryPos(0);
1682 }
1683 else
1684 {
1685 m_pApplyCollBox->SetNoSelection();
1686 m_pApplyCollBtn->SetState( STATE_NOCHECK );
1687 }
1688 }
1689 else if ( SFX_ITEM_DONTCARE == eItemState )
1690 {
1691 m_pApplyCollBtn->EnableTriState( sal_True );
1692 m_pApplyCollBtn->SetState( STATE_DONTKNOW );
1693 m_pApplyCollBox->SetNoSelection();
1694 }
1695 else
1696 {
1697 m_pApplyCollBtn->Enable(sal_False);
1698 m_pApplyCollBox->Enable(sal_False);
1699 m_pPagenumEdit->Enable(sal_False);
1700 m_pPagenumText->Enable(sal_False);
1701 }
1702
1703 if ( !bIsPageModel )
1704 {
1705 _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1706 eItemState = rSet.GetItemState( _nWhich );
1707
1708 if ( eItemState >= SFX_ITEM_AVAILABLE )
1709 {
1710 const SvxFmtBreakItem& rPageBreak =
1711 (const SvxFmtBreakItem&)rSet.Get( _nWhich );
1712
1713 SvxBreak eBreak = (SvxBreak)rPageBreak.GetValue();
1714
1715 // PageBreak not via CTRL-RETURN,
1716 // then CheckBox can be freed
1717 m_pPageBreakBox->Enable();
1718 m_pPageBreakBox->EnableTriState( sal_False );
1719 m_pBreakTypeFT->Enable();
1720 m_pBreakTypeLB->Enable();
1721 m_pBreakPositionFT->Enable();
1722 m_pBreakPositionLB->Enable();
1723
1724 m_pPageBreakBox->SetState( STATE_CHECK );
1725
1726 sal_Bool _bEnable = eBreak != SVX_BREAK_NONE &&
1727 eBreak != SVX_BREAK_COLUMN_BEFORE &&
1728 eBreak != SVX_BREAK_COLUMN_AFTER;
1729 m_pApplyCollBtn->Enable(_bEnable);
1730 if(!_bEnable)
1731 {
1732 m_pApplyCollBox->Enable(_bEnable);
1733 m_pPagenumEdit->Enable(_bEnable);
1734 }
1735
1736 if ( eBreak == SVX_BREAK_NONE )
1737 m_pPageBreakBox->SetState( STATE_NOCHECK );
1738
1739 sal_uInt16 nType = 0; // selection position in break type ListBox : Page
1740 sal_uInt16 nPosition = 0; // selection position in break position ListBox : Before
1741 switch ( eBreak )
1742 {
1743 case SVX_BREAK_PAGE_BEFORE:
1744 break;
1745 case SVX_BREAK_PAGE_AFTER:
1746 nPosition = 1;
1747 break;
1748 case SVX_BREAK_COLUMN_BEFORE:
1749 nType = 1;
1750 break;
1751 case SVX_BREAK_COLUMN_AFTER:
1752 nType = 1;
1753 nPosition = 1;
1754 break;
1755 default: ;//prevent warning
1756 }
1757 m_pBreakTypeLB->SelectEntryPos(nType);
1758 m_pBreakPositionLB->SelectEntryPos(nPosition);
1759 }
1760 else if ( SFX_ITEM_DONTCARE == eItemState )
1761 m_pPageBreakBox->SetState( STATE_DONTKNOW );
1762 else
1763 {
1764 m_pPageBreakBox->Enable(sal_False);
1765 m_pBreakTypeFT->Enable(sal_False);
1766 m_pBreakTypeLB->Enable(sal_False);
1767 m_pBreakPositionFT->Enable(sal_False);
1768 m_pBreakPositionLB->Enable(sal_False);
1769 }
1770 }
1771
1772 PageBreakPosHdl_Impl( m_pBreakPositionLB );
1773 PageBreakHdl_Impl( m_pPageBreakBox );
1774 }
1775
1776 _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1777 eItemState = rSet.GetItemState( _nWhich );
1778
1779 if ( eItemState >= SFX_ITEM_AVAILABLE )
1780 {
1781 m_pKeepParaBox->EnableTriState( sal_False );
1782 const SvxFmtKeepItem& rKeep =
1783 (const SvxFmtKeepItem&)rSet.Get( _nWhich );
1784
1785 if ( rKeep.GetValue() )
1786 m_pKeepParaBox->SetState( STATE_CHECK );
1787 else
1788 m_pKeepParaBox->SetState( STATE_NOCHECK );
1789 }
1790 else if ( SFX_ITEM_DONTCARE == eItemState )
1791 m_pKeepParaBox->SetState( STATE_DONTKNOW );
1792 else
1793 m_pKeepParaBox->Enable(sal_False);
1794
1795 _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1796 eItemState = rSet.GetItemState( _nWhich );
1797
1798 if ( eItemState >= SFX_ITEM_AVAILABLE )
1799 {
1800 const SvxFmtSplitItem& rSplit =
1801 (const SvxFmtSplitItem&)rSet.Get( _nWhich );
1802 m_pKeepTogetherBox->EnableTriState( sal_False );
1803
1804 if ( !rSplit.GetValue() )
1805 m_pKeepTogetherBox->SetState( STATE_CHECK );
1806 else
1807 {
1808 m_pKeepTogetherBox->SetState( STATE_NOCHECK );
1809
1810 // widows and orphans
1811 m_pWidowBox->Enable();
1812 _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1813 SfxItemState eTmpState = rSet.GetItemState( _nWhich );
1814
1815 if ( eTmpState >= SFX_ITEM_AVAILABLE )
1816 {
1817 const SvxWidowsItem& rWidow =
1818 (const SvxWidowsItem&)rSet.Get( _nWhich );
1819 m_pWidowBox->EnableTriState( sal_False );
1820 const sal_uInt16 nLines = rWidow.GetValue();
1821
1822 sal_Bool _bEnable = nLines > 0;
1823 m_pWidowRowNo->SetValue( m_pWidowRowNo->Normalize( nLines ) );
1824 m_pWidowBox->SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
1825 m_pWidowRowNo->Enable(_bEnable);
1826 //m_pWidowRowLabel->Enable(_bEnable);
1827
1828 }
1829 else if ( SFX_ITEM_DONTCARE == eTmpState )
1830 m_pWidowBox->SetState( STATE_DONTKNOW );
1831 else
1832 m_pWidowBox->Enable(sal_False);
1833
1834 m_pOrphanBox->Enable();
1835 _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1836 eTmpState = rSet.GetItemState( _nWhich );
1837
1838 if ( eTmpState >= SFX_ITEM_AVAILABLE )
1839 {
1840 const SvxOrphansItem& rOrphan =
1841 (const SvxOrphansItem&)rSet.Get( _nWhich );
1842 const sal_uInt16 nLines = rOrphan.GetValue();
1843 m_pOrphanBox->EnableTriState( sal_False );
1844
1845 sal_Bool _bEnable = nLines > 0;
1846 m_pOrphanBox->SetState( _bEnable ? STATE_CHECK : STATE_NOCHECK);
1847 m_pOrphanRowNo->SetValue( m_pOrphanRowNo->Normalize( nLines ) );
1848 m_pOrphanRowNo->Enable(_bEnable);
1849 m_pOrphanRowLabel->Enable(_bEnable);
1850
1851 }
1852 else if ( SFX_ITEM_DONTCARE == eTmpState )
1853 m_pOrphanBox->SetState( STATE_DONTKNOW );
1854 else
1855 m_pOrphanBox->Enable(sal_False);
1856 }
1857 }
1858 else if ( SFX_ITEM_DONTCARE == eItemState )
1859 m_pKeepTogetherBox->SetState( STATE_DONTKNOW );
1860 else
1861 m_pKeepTogetherBox->Enable(sal_False);
1862
1863 // so that everything is enabled correctly
1864 KeepTogetherHdl_Impl( 0 );
1865 WidowHdl_Impl( 0 );
1866 OrphanHdl_Impl( 0 );
1867
1868 m_pHyphenBox->SaveValue();
1869 m_pExtHyphenBeforeBox->SaveValue();
1870 m_pExtHyphenAfterBox->SaveValue();
1871 m_pMaxHyphenEdit->SaveValue();
1872 m_pPageBreakBox->SaveValue();
1873 m_pBreakPositionLB->SaveValue();
1874 m_pBreakTypeLB->SaveValue();
1875 m_pApplyCollBtn->SaveValue();
1876 m_pApplyCollBox->SaveValue();
1877 m_pPagenumEdit->SaveValue();
1878 m_pKeepTogetherBox->SaveValue();
1879 m_pKeepParaBox->SaveValue();
1880 m_pWidowBox->SaveValue();
1881 m_pOrphanBox->SaveValue();
1882 }
1883
1884 // -----------------------------------------------------------------------
1885
1886 int SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
1887 {
1888 if ( _pSet )
1889 FillItemSet( *_pSet );
1890 return LEAVE_PAGE;
1891 }
1892
1893 // -----------------------------------------------------------------------
1894
1895 void SvxExtParagraphTabPage::DisablePageBreak()
1896 {
1897 bPageBreak = sal_False;
1898 m_pPageBreakBox->Enable(sal_False);
1899 m_pBreakTypeLB->RemoveEntry(0);
1900 m_pBreakPositionFT->Enable(sal_False);
1901 m_pBreakPositionLB->Enable(sal_False);
1902 m_pApplyCollBtn->Enable(sal_False);
1903 m_pApplyCollBox->Enable(sal_False);
1904 m_pPagenumEdit->Enable(sal_False);
1905 }
1906
1907 // -----------------------------------------------------------------------
1908
1909 SvxExtParagraphTabPage::SvxExtParagraphTabPage( Window* pParent, const SfxItemSet& rAttr ) :
1910 SfxTabPage( pParent, "TextFlowPage","cui/ui/textflowpage.ui", rAttr ),
1911
1912 bPageBreak ( sal_True ),
1913 bHtmlMode ( sal_False ),
1914 nStdPos ( 0 )
1915 {
1916 // Hyphenation
1917 get(m_pHyphenBox,"checkAuto");
1918 get(m_pExtHyphenBeforeBox,"spinLineEnd");
1919 get(m_pExtHyphenAfterBox,"spinLineBegin");
1920 get(m_pMaxHyphenEdit,"spinMaxNum");
1921 get(m_pBeforeText,"labelLineBegin");
1922 get(m_pAfterText,"labelLineEnd");
1923 get(m_pMaxHyphenLabel,"labelMaxNum");
1924
1925 //Page break
1926 get(m_pPageBreakBox,"checkInsert");
1927 get(m_pBreakTypeLB,"comboBreakType");
1928 get(m_pBreakPositionLB,"comboBreakPosition");
1929 get(m_pApplyCollBtn,"checkPageStyle");
1930 get(m_pApplyCollBox,"comboPageStyle");
1931 get(m_pPagenumEdit,"spinPageNumber");
1932 get(m_pBreakTypeFT,"labelType");
1933 get(m_pBreakPositionFT,"labelPosition");
1934 get(m_pPagenumText,"labelPageNum");
1935
1936
1937 // Options
1938 get(m_pKeepTogetherBox,"checkSplitPara");
1939 get(m_pKeepParaBox,"checkKeepPara");
1940
1941 get(m_pOrphanBox,"checkOrphan");
1942 get(m_pOrphanRowNo,"spinOrphan");
1943 get(m_pOrphanRowLabel,"labelOrphan");
1944
1945 get(m_pWidowBox,"checkWidow");
1946 get(m_pWidowRowNo,"spinWidow");
1947 get(m_pWidowRowLabel,"labelWidow");
1948
1949 m_pApplyCollBox->SetAccessibleRelationLabeledBy(m_pApplyCollBtn);
1950 m_pApplyCollBox->SetAccessibleName(String(CUI_RES(STR_PAGE_STYLE)));
1951
1952 m_pOrphanRowNo->SetAccessibleRelationLabeledBy(m_pOrphanBox);
1953 m_pWidowRowNo->SetAccessibleRelationLabeledBy(m_pWidowBox);
1954
1955 // this page needs ExchangeSupport
1956 SetExchangeSupport();
1957
1958 m_pHyphenBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, HyphenClickHdl_Impl ) );
1959 m_pPageBreakBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, PageBreakHdl_Impl ) );
1960 m_pKeepTogetherBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl ) );
1961 m_pWidowBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, WidowHdl_Impl ) );
1962 m_pOrphanBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, OrphanHdl_Impl ) );
1963 m_pApplyCollBtn->SetClickHdl( LINK( this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl ) );
1964 m_pBreakTypeLB->SetSelectHdl( LINK( this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl ) );
1965 m_pBreakPositionLB->SetSelectHdl( LINK( this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl ) );
1966
1967 SfxObjectShell* pSh = SfxObjectShell::Current();
1968 if ( pSh )
1969 {
1970 SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
1971 pPool->SetSearchMask( SFX_STYLE_FAMILY_PAGE );
1972 SfxStyleSheetBase* pStyle = pPool->First();
1973 String aStdName;
1974
1975 while( pStyle )
1976 {
1977 if ( aStdName.Len() == 0 )
1978 // first style == standard style
1979 aStdName = pStyle->GetName();
1980 m_pApplyCollBox->InsertEntry( pStyle->GetName() );
1981 pStyle = pPool->Next();
1982 }
1983 nStdPos = m_pApplyCollBox->GetEntryPos( aStdName );
1984 }
1985
1986 sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr );
1987 if ( nHtmlMode & HTMLMODE_ON )
1988 {
1989 bHtmlMode = sal_True;
1990 m_pHyphenBox ->Enable(sal_False);
1991 m_pBeforeText ->Enable(sal_False);
1992 m_pExtHyphenBeforeBox ->Enable(sal_False);
1993 m_pAfterText ->Enable(sal_False);
1994 m_pExtHyphenAfterBox ->Enable(sal_False);
1995 m_pMaxHyphenLabel ->Enable(sal_False);
1996 m_pMaxHyphenEdit ->Enable(sal_False);
1997 m_pPagenumText ->Enable(sal_False);
1998 m_pPagenumEdit ->Enable(sal_False);
1999 // no column break in HTML
2000 m_pBreakTypeLB->RemoveEntry(1);
2001 }
2002 }
2003
2004 // -----------------------------------------------------------------------
2005
2006 SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
2007 {
2008 }
2009
2010 // -----------------------------------------------------------------------
2011
2012 sal_uInt16* SvxExtParagraphTabPage::GetRanges()
2013 {
2014 return pExtRanges;
2015 }
2016
2017 // -----------------------------------------------------------------------
2018
2019 IMPL_LINK_NOARG(SvxExtParagraphTabPage, PageBreakHdl_Impl)
2020 {
2021 switch ( m_pPageBreakBox->GetState() )
2022 {
2023 case STATE_CHECK:
2024 m_pBreakTypeFT->Enable();
2025 m_pBreakTypeLB->Enable();
2026 m_pBreakPositionFT->Enable();
2027 m_pBreakPositionLB->Enable();
2028
2029 if ( 0 == m_pBreakTypeLB->GetSelectEntryPos()&&
2030 0 == m_pBreakPositionLB->GetSelectEntryPos() )
2031 {
2032 m_pApplyCollBtn->Enable();
2033
2034 sal_Bool bEnable = STATE_CHECK == m_pApplyCollBtn->GetState() &&
2035 m_pApplyCollBox->GetEntryCount();
2036 m_pApplyCollBox->Enable(bEnable);
2037 if(!bHtmlMode)
2038 {
2039 m_pPagenumText->Enable(bEnable);
2040 m_pPagenumEdit->Enable(bEnable);
2041 }
2042 }
2043 break;
2044
2045 case STATE_NOCHECK:
2046 case STATE_DONTKNOW:
2047 m_pApplyCollBtn->SetState( STATE_NOCHECK );
2048 m_pApplyCollBtn->Enable(sal_False);
2049 m_pApplyCollBox->Enable(sal_False);
2050 m_pPagenumText->Enable(sal_False);
2051 m_pPagenumEdit->Enable(sal_False);
2052 m_pBreakTypeFT->Enable(sal_False);
2053 m_pBreakTypeLB->Enable(sal_False);
2054 m_pBreakPositionFT->Enable(sal_False);
2055 m_pBreakPositionLB->Enable(sal_False);
2056 break;
2057 }
2058 return 0;
2059 }
2060
2061 // -----------------------------------------------------------------------
2062
2063 IMPL_LINK_NOARG(SvxExtParagraphTabPage, KeepTogetherHdl_Impl)
2064 {
2065 sal_Bool bEnable = m_pKeepTogetherBox->GetState() == STATE_NOCHECK;
2066 m_pWidowBox->Enable(bEnable);
2067 m_pOrphanBox->Enable(bEnable);
2068
2069 return 0;
2070 }
2071
2072 // -----------------------------------------------------------------------
2073
2074 IMPL_LINK_NOARG(SvxExtParagraphTabPage, WidowHdl_Impl)
2075 {
2076 switch ( m_pWidowBox->GetState() )
2077 {
2078 case STATE_CHECK:
2079 m_pWidowRowNo->Enable();
2080 m_pWidowRowLabel->Enable();
2081 m_pKeepTogetherBox->Enable(sal_False);
2082 break;
2083
2084 case STATE_NOCHECK:
2085 if ( m_pOrphanBox->GetState() == STATE_NOCHECK )
2086 m_pKeepTogetherBox->Enable();
2087
2088 // no break
2089 case STATE_DONTKNOW:
2090 m_pWidowRowNo->Enable(sal_False);
2091 m_pWidowRowLabel->Enable(sal_False);
2092 break;
2093 }
2094 return 0;
2095 }
2096
2097 // -----------------------------------------------------------------------
2098
2099 IMPL_LINK_NOARG(SvxExtParagraphTabPage, OrphanHdl_Impl)
2100 {
2101 switch( m_pOrphanBox->GetState() )
2102 {
2103 case STATE_CHECK:
2104 m_pOrphanRowNo->Enable();
2105 m_pOrphanRowLabel->Enable();
2106 m_pKeepTogetherBox->Enable(sal_False);
2107 break;
2108
2109 case STATE_NOCHECK:
2110 if ( m_pWidowBox->GetState() == STATE_NOCHECK )
2111 m_pKeepTogetherBox->Enable();
2112
2113 // kein break
2114 case STATE_DONTKNOW:
2115 m_pOrphanRowNo->Enable(sal_False);
2116 m_pOrphanRowLabel->Enable(sal_False);
2117 break;
2118 }
2119 return 0;
2120 }
2121
2122 // -----------------------------------------------------------------------
2123
2124 IMPL_LINK_NOARG(SvxExtParagraphTabPage, HyphenClickHdl_Impl)
2125 {
2126
2127 sal_Bool bEnable = m_pHyphenBox->GetState() == STATE_CHECK;
2128 m_pBeforeText->Enable(bEnable);
2129 m_pExtHyphenBeforeBox->Enable(bEnable);
2130 m_pAfterText->Enable(bEnable);
2131 m_pExtHyphenAfterBox->Enable(bEnable);
2132 m_pMaxHyphenLabel->Enable(bEnable);
2133 m_pMaxHyphenEdit->Enable(bEnable);
2134 m_pHyphenBox->SetState( bEnable ? STATE_CHECK : STATE_NOCHECK);
2135
2136 return 0;
2137 }
2138
2139 // -----------------------------------------------------------------------
2140
2141 IMPL_LINK_NOARG(SvxExtParagraphTabPage, ApplyCollClickHdl_Impl)
2142 {
2143 sal_Bool bEnable = sal_False;
2144 if ( m_pApplyCollBtn->GetState() == STATE_CHECK &&
2145 m_pApplyCollBox->GetEntryCount() )
2146 {
2147 bEnable = sal_True;
2148 m_pApplyCollBox->SelectEntryPos( nStdPos );
2149 }
2150 else
2151 {
2152 m_pApplyCollBox->SetNoSelection();
2153 }
2154 m_pApplyCollBox->Enable(bEnable);
2155 if(!bHtmlMode)
2156 {
2157 m_pPagenumText->Enable(bEnable);
2158 m_pPagenumEdit->Enable(bEnable);
2159 }
2160 return 0;
2161 }
2162
2163 // -----------------------------------------------------------------------
2164
2165 IMPL_LINK( SvxExtParagraphTabPage, PageBreakPosHdl_Impl, ListBox *, pListBox )
2166 {
2167 if ( 0 == pListBox->GetSelectEntryPos() )
2168 {
2169 m_pApplyCollBtn->Enable();
2170
2171 sal_Bool bEnable = m_pApplyCollBtn->GetState() == STATE_CHECK &&
2172 m_pApplyCollBox->GetEntryCount();
2173
2174 m_pApplyCollBox->Enable(bEnable);
2175 if(!bHtmlMode)
2176 {
2177 m_pPagenumText->Enable(bEnable);
2178 m_pPagenumEdit->Enable(bEnable);
2179 }
2180 }
2181 else if ( 1 == pListBox->GetSelectEntryPos() )
2182 {
2183 m_pApplyCollBtn->SetState( STATE_NOCHECK );
2184 m_pApplyCollBtn->Enable(sal_False);
2185 m_pApplyCollBox->Enable(sal_False);
2186 m_pPagenumText->Enable(sal_False);
2187 m_pPagenumEdit->Enable(sal_False);
2188 }
2189 return 0;
2190 }
2191
2192 // -----------------------------------------------------------------------
2193
2194 IMPL_LINK( SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, ListBox *, pListBox )
2195 {
2196 //column break or break break after
2197 sal_uInt16 nBreakPos = m_pBreakPositionLB->GetSelectEntryPos();
2198 if ( pListBox->GetSelectEntryPos() == 1 || 1 == nBreakPos)
2199 {
2200 m_pApplyCollBtn->SetState( STATE_NOCHECK );
2201 m_pApplyCollBtn->Enable(sal_False);
2202 m_pApplyCollBox->Enable(sal_False);
2203 m_pPagenumText->Enable(sal_False);
2204 m_pPagenumEdit->Enable(sal_False);
2205 }
2206 else
2207 PageBreakPosHdl_Impl( m_pBreakPositionLB );
2208 return 0;
2209 }
2210
2211 void SvxExtParagraphTabPage::PageCreated(SfxAllItemSet aSet)
2212 {
2213
2214
2215 SFX_ITEMSET_ARG (&aSet,pDisablePageBreakItem,SfxBoolItem,SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK,sal_False);
2216
2217 if (pDisablePageBreakItem)
2218 if ( pDisablePageBreakItem->GetValue())
2219 DisablePageBreak();
2220
2221
2222 }
2223
2224 SvxAsianTabPage::SvxAsianTabPage( Window* pParent, const SfxItemSet& rSet ) :
2225 SfxTabPage(pParent, "AsianTypography","cui/ui/asiantypography.ui", rSet)
2226
2227 {
2228 get(m_pForbiddenRulesCB,"checkForbidList");
2229 get(m_pHangingPunctCB,"checkHangPunct");
2230 get(m_pScriptSpaceCB,"checkApplySpacing");
2231
2232 Link aLink = LINK( this, SvxAsianTabPage, ClickHdl_Impl );
2233 m_pHangingPunctCB->SetClickHdl( aLink );
2234 m_pScriptSpaceCB->SetClickHdl( aLink );
2235 m_pForbiddenRulesCB->SetClickHdl( aLink );
2236
2237 }
2238
2239 SvxAsianTabPage::~SvxAsianTabPage()
2240 {
2241 }
2242
2243 SfxTabPage* SvxAsianTabPage::Create( Window* pParent, const SfxItemSet& rSet )
2244 {
2245 return new SvxAsianTabPage(pParent, rSet);
2246 }
2247
2248 sal_uInt16* SvxAsianTabPage::GetRanges()
2249 {
2250 static sal_uInt16 pRanges[] =
2251 {
2252 SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES,
2253 0
2254 };
2255 return pRanges;
2256 }
2257
2258 sal_Bool SvxAsianTabPage::FillItemSet( SfxItemSet& rSet )
2259 {
2260 sal_Bool bRet = sal_False;
2261 SfxItemPool* pPool = rSet.GetPool();
2262 if (m_pScriptSpaceCB->IsEnabled() && m_pScriptSpaceCB->IsChecked() != m_pScriptSpaceCB->GetSavedValue())
2263 {
2264 SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2265 pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone();
2266 pNewItem->SetValue(m_pScriptSpaceCB->IsChecked());
2267 rSet.Put(*pNewItem);
2268 delete pNewItem;
2269 bRet = sal_True;
2270 }
2271 if (m_pHangingPunctCB->IsEnabled() && m_pHangingPunctCB->IsChecked() != m_pHangingPunctCB->GetSavedValue())
2272 {
2273 SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2274 pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone();
2275 pNewItem->SetValue(m_pHangingPunctCB->IsChecked());
2276 rSet.Put(*pNewItem);
2277 delete pNewItem;
2278 bRet = sal_True;
2279 }
2280 if (m_pForbiddenRulesCB->IsEnabled() && m_pForbiddenRulesCB->IsChecked() != m_pForbiddenRulesCB->GetSavedValue())
2281 {
2282 SfxBoolItem* pNewItem = (SfxBoolItem*)rSet.Get(
2283 pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone();
2284 pNewItem->SetValue(m_pForbiddenRulesCB->IsChecked());
2285 rSet.Put(*pNewItem);
2286 delete pNewItem;
2287 bRet = sal_True;
2288 }
2289 return bRet;
2290 }
2291
2292 static void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, CheckBox& rBox)
2293 {
2294 sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId);
2295 SfxItemState eState = rSet.GetItemState(_nWhich, sal_True);
2296 if(!eState || eState == SFX_ITEM_DISABLED )
2297 rBox.Enable(sal_False);
2298 else if(eState >= SFX_ITEM_AVAILABLE)
2299 {
2300 rBox.EnableTriState( sal_False );
2301 rBox.Check(((const SfxBoolItem&)rSet.Get(_nWhich)).GetValue());
2302 }
2303 else
2304 rBox.SetState( STATE_DONTKNOW );
2305 rBox.SaveValue();
2306 }
2307
2308
2309 void SvxAsianTabPage::Reset( const SfxItemSet& rSet )
2310 {
2311 lcl_SetBox(rSet, SID_ATTR_PARA_FORBIDDEN_RULES, *m_pForbiddenRulesCB );
2312 lcl_SetBox(rSet, SID_ATTR_PARA_HANGPUNCTUATION, *m_pHangingPunctCB );
2313
2314 //character distance not yet available
2315 lcl_SetBox(rSet, SID_ATTR_PARA_SCRIPTSPACE, *m_pScriptSpaceCB );
2316 }
2317
2318 IMPL_LINK( SvxAsianTabPage, ClickHdl_Impl, CheckBox*, pBox )
2319 {
2320 pBox->EnableTriState( sal_False );
2321 return 0;
2322 }
2323
2324 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE