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