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 : const sal_uInt16 SvxStdParagraphTabPage::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 : const sal_uInt16 SvxParaAlignTabPage::pAlignRanges[] =
68 : {
69 : SID_ATTR_PARA_ADJUST, // 10027
70 : SID_ATTR_PARA_ADJUST,
71 : 0
72 : };
73 :
74 : const sal_uInt16 SvxExtParagraphTabPage::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 : VclPtr<SfxTabPage> SvxStdParagraphTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet)
198 : {
199 0 : return VclPtr<SvxStdParagraphTabPage>::Create( 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 0 : 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.SetTextLeft( rOldItem.GetTextLeft(),
323 0 : (sal_uInt16)m_pLeftIndent->GetValue() );
324 : else
325 0 : aMargin.SetTextLeft( 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.SetTextFirstLineOfst( rOldItem.GetTextFirstLineOfst(),
335 0 : (sal_uInt16)m_pFLineIndent->GetValue() );
336 : else
337 : aMargin.SetTextFirstLineOfst(
338 0 : (sal_uInt16)GetCoreValue( *m_pFLineIndent, eUnit ) );
339 : }
340 : else
341 : {
342 0 : aMargin.SetTextLeft( GetCoreValue( *m_pLeftIndent, eUnit ) );
343 0 : aMargin.SetRight( GetCoreValue( *m_pRightIndent, eUnit ) );
344 : aMargin.SetTextFirstLineOfst(
345 0 : (sal_uInt16)GetCoreValue( *m_pFLineIndent, eUnit ) );
346 : }
347 0 : aMargin.SetAutoFirst(m_pAutoCB->IsChecked());
348 0 : if ( aMargin.GetTextFirstLineOfst() < 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.GetTextLeft(), 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.GetPropTextFirstLineOfst() != 100 )
471 : {
472 0 : m_pFLineIndent->SetRelative( true );
473 0 : m_pFLineIndent->SetValue( rOldItem.GetPropTextFirstLineOfst() );
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.GetTextFirstLineOfst(),
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.GetTextLeft(), eUnit );
491 0 : SetMetricValue( *m_pRightIndent, rSpace.GetRight(), eUnit );
492 0 : SetMetricValue( *m_pFLineIndent, rSpace.GetTextFirstLineOfst(), 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 : SfxTabPage::sfxpg 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 : disposeOnce();
660 0 : }
661 :
662 0 : void SvxStdParagraphTabPage::dispose()
663 : {
664 0 : m_pLeftIndent.clear();
665 0 : m_pRightLabel.clear();
666 0 : m_pRightIndent.clear();
667 0 : m_pFLineLabel.clear();
668 0 : m_pFLineIndent.clear();
669 0 : m_pAutoCB.clear();
670 0 : m_pTopDist.clear();
671 0 : m_pBottomDist.clear();
672 0 : m_pContextualCB.clear();
673 0 : m_pLineDist.clear();
674 0 : m_pLineDistAtLabel.clear();
675 0 : m_pLineDistAtPercentBox.clear();
676 0 : m_pLineDistAtMetricBox.clear();
677 0 : m_pAbsDist.clear();
678 0 : m_pExampleWin.clear();
679 0 : m_pRegisterFL.clear();
680 0 : m_pRegisterCB.clear();
681 0 : SfxTabPage::dispose();
682 0 : }
683 :
684 0 : void SvxStdParagraphTabPage::EnableNegativeMode()
685 : {
686 0 : m_pLeftIndent->SetMin(-9999);
687 0 : m_pRightIndent->SetMin(-9999);
688 0 : m_pRightIndent->EnableNegativeMode();
689 0 : m_pLeftIndent->EnableNegativeMode();
690 0 : bNegativeIndents = true;
691 0 : }
692 :
693 0 : void SvxStdParagraphTabPage::SetLineSpacing_Impl
694 : (
695 : const SvxLineSpacingItem &rAttr
696 : )
697 : {
698 0 : SfxMapUnit eUnit = GetItemSet().GetPool()->GetMetric( rAttr.Which() );
699 :
700 0 : switch( rAttr.GetLineSpaceRule() )
701 : {
702 : case SVX_LINE_SPACE_AUTO:
703 : {
704 0 : SvxInterLineSpace eInter = rAttr.GetInterLineSpaceRule();
705 :
706 0 : switch( eInter )
707 : {
708 : // Default single line spacing
709 : case SVX_INTER_LINE_SPACE_OFF:
710 0 : m_pLineDist->SelectEntryPos( LLINESPACE_1 );
711 0 : break;
712 :
713 : // Default single line spacing
714 : case SVX_INTER_LINE_SPACE_PROP:
715 0 : if ( 100 == rAttr.GetPropLineSpace() )
716 : {
717 0 : m_pLineDist->SelectEntryPos( LLINESPACE_1 );
718 0 : break;
719 : }
720 : // 1.5 line spacing
721 0 : if ( 150 == rAttr.GetPropLineSpace() )
722 : {
723 0 : m_pLineDist->SelectEntryPos( LLINESPACE_15 );
724 0 : break;
725 : }
726 : // double line spacing
727 0 : if ( 200 == rAttr.GetPropLineSpace() )
728 : {
729 0 : m_pLineDist->SelectEntryPos( LLINESPACE_2 );
730 0 : break;
731 : }
732 : // the set per cent value
733 0 : m_pLineDistAtPercentBox->SetValue( m_pLineDistAtPercentBox->Normalize(rAttr.GetPropLineSpace() ) );
734 0 : m_pLineDist->SelectEntryPos( LLINESPACE_PROP );
735 0 : break;
736 :
737 : case SVX_INTER_LINE_SPACE_FIX:
738 0 : SetMetricValue( *m_pLineDistAtMetricBox, rAttr.GetInterLineSpace(), eUnit );
739 0 : m_pLineDist->SelectEntryPos( LLINESPACE_DURCH );
740 0 : break;
741 : default: ;//prevent warning
742 : }
743 : }
744 0 : break;
745 : case SVX_LINE_SPACE_FIX:
746 0 : SetMetricValue(*m_pLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
747 0 : m_pLineDist->SelectEntryPos( LLINESPACE_FIX );
748 0 : break;
749 :
750 : case SVX_LINE_SPACE_MIN:
751 0 : SetMetricValue(*m_pLineDistAtMetricBox, rAttr.GetLineHeight(), eUnit);
752 0 : m_pLineDist->SelectEntryPos( LLINESPACE_MIN );
753 0 : break;
754 : default: ;//prevent warning
755 : }
756 0 : LineDistHdl_Impl( m_pLineDist );
757 0 : }
758 :
759 0 : IMPL_LINK( SvxStdParagraphTabPage, LineDistHdl_Impl, ListBox *, pBox )
760 : {
761 0 : switch( pBox->GetSelectEntryPos() )
762 : {
763 : case LLINESPACE_1:
764 : case LLINESPACE_15:
765 : case LLINESPACE_2:
766 0 : m_pLineDistAtLabel->Enable(false);
767 0 : m_pLineDistAtPercentBox->Enable(false);
768 0 : m_pLineDistAtPercentBox->SetText( OUString() );
769 0 : m_pLineDistAtMetricBox->Enable(false);
770 0 : m_pLineDistAtMetricBox->SetText( OUString() );
771 0 : break;
772 :
773 : case LLINESPACE_DURCH:
774 : // setting a sensible default?
775 : // limit MS min(10, aPageSize)
776 0 : m_pLineDistAtMetricBox->SetMin(0);
777 :
778 0 : if ( m_pLineDistAtMetricBox->GetText().isEmpty() )
779 0 : m_pLineDistAtMetricBox->SetValue( m_pLineDistAtMetricBox->Normalize( 1 ) );
780 0 : m_pLineDistAtPercentBox->Hide();
781 0 : m_pLineDistAtMetricBox->Show();
782 0 : m_pLineDistAtMetricBox->Enable();
783 0 : m_pLineDistAtLabel->Enable();
784 0 : break;
785 :
786 : case LLINESPACE_MIN:
787 0 : m_pLineDistAtMetricBox->SetMin(0);
788 :
789 0 : if ( m_pLineDistAtMetricBox->GetText().isEmpty() )
790 0 : m_pLineDistAtMetricBox->SetValue( m_pLineDistAtMetricBox->Normalize( 10 ), FUNIT_TWIP );
791 0 : m_pLineDistAtPercentBox->Hide();
792 0 : m_pLineDistAtMetricBox->Show();
793 0 : m_pLineDistAtMetricBox->Enable();
794 0 : m_pLineDistAtLabel->Enable();
795 0 : break;
796 :
797 : case LLINESPACE_PROP:
798 :
799 0 : if ( m_pLineDistAtPercentBox->GetText().isEmpty() )
800 0 : m_pLineDistAtPercentBox->SetValue( m_pLineDistAtPercentBox->Normalize( 100 ), FUNIT_TWIP );
801 0 : m_pLineDistAtMetricBox->Hide();
802 0 : m_pLineDistAtPercentBox->Show();
803 0 : m_pLineDistAtPercentBox->Enable();
804 0 : m_pLineDistAtLabel->Enable();
805 0 : break;
806 : case LLINESPACE_FIX:
807 : {
808 0 : sal_Int64 nTemp = m_pLineDistAtMetricBox->GetValue();
809 0 : m_pLineDistAtMetricBox->SetMin(m_pLineDistAtMetricBox->Normalize(nMinFixDist), FUNIT_TWIP);
810 :
811 : // if the value has been changed at SetMin,
812 : // it is time for the default
813 0 : if ( m_pLineDistAtMetricBox->GetValue() != nTemp )
814 0 : SetMetricValue( *m_pLineDistAtMetricBox, FIX_DIST_DEF, SFX_MAPUNIT_TWIP ); // fix is only in Writer
815 0 : m_pLineDistAtPercentBox->Hide();
816 0 : m_pLineDistAtMetricBox->Show();
817 0 : m_pLineDistAtMetricBox->Enable();
818 0 : m_pLineDistAtLabel->Enable();
819 : }
820 0 : break;
821 : }
822 0 : UpdateExample_Impl();
823 0 : return 0;
824 : }
825 :
826 0 : IMPL_LINK_NOARG(SvxStdParagraphTabPage, ModifyHdl_Impl)
827 : {
828 0 : UpdateExample_Impl();
829 0 : return 0;
830 : }
831 :
832 0 : void SvxStdParagraphTabPage::Init_Impl()
833 : {
834 : m_pLineDist->SetSelectHdl(
835 0 : LINK( this, SvxStdParagraphTabPage, LineDistHdl_Impl ) );
836 :
837 0 : Link<> aLink = LINK( this, SvxStdParagraphTabPage, ELRLoseFocusHdl );
838 0 : m_pFLineIndent->SetLoseFocusHdl( aLink );
839 0 : m_pLeftIndent->SetLoseFocusHdl( aLink );
840 0 : m_pRightIndent->SetLoseFocusHdl( aLink );
841 :
842 0 : aLink = LINK( this, SvxStdParagraphTabPage, ModifyHdl_Impl );
843 0 : m_pFLineIndent->SetModifyHdl( aLink );
844 0 : m_pLeftIndent->SetModifyHdl( aLink );
845 0 : m_pRightIndent->SetModifyHdl( aLink );
846 0 : m_pTopDist->SetModifyHdl( aLink );
847 0 : m_pBottomDist->SetModifyHdl( aLink );
848 :
849 0 : m_pAutoCB->SetClickHdl( LINK( this, SvxStdParagraphTabPage, AutoHdl_Impl ));
850 0 : SfxItemPool* pPool = GetItemSet().GetPool();
851 : DBG_ASSERT( pPool, "Wo ist der Pool" );
852 0 : FieldUnit eUnit = MapToFieldUnit( pPool->GetMetric( GetWhich( SID_ATTR_LRSPACE ) ) );
853 :
854 0 : m_pTopDist->SetMax( m_pTopDist->Normalize( nAbst ), eUnit );
855 0 : m_pBottomDist->SetMax( m_pBottomDist->Normalize( nAbst ), eUnit );
856 0 : m_pLineDistAtMetricBox->SetMax( m_pLineDistAtMetricBox->Normalize( nAbst ), eUnit );
857 0 : }
858 :
859 0 : void SvxStdParagraphTabPage::UpdateExample_Impl()
860 : {
861 0 : m_pExampleWin->SetFirstLineOfst( (short)m_pFLineIndent->Denormalize( m_pFLineIndent->GetValue( FUNIT_TWIP ) ) );
862 0 : m_pExampleWin->SetLeftMargin( static_cast<long>(m_pLeftIndent->Denormalize( m_pLeftIndent->GetValue( FUNIT_TWIP ) ) ) );
863 0 : m_pExampleWin->SetRightMargin( static_cast<long>(m_pRightIndent->Denormalize( m_pRightIndent->GetValue( FUNIT_TWIP ) ) ) );
864 0 : m_pExampleWin->SetUpper( (sal_uInt16)m_pTopDist->Denormalize( m_pTopDist->GetValue( FUNIT_TWIP ) ) );
865 0 : m_pExampleWin->SetLower( (sal_uInt16)m_pBottomDist->Denormalize( m_pBottomDist->GetValue( FUNIT_TWIP ) ) );
866 :
867 0 : sal_Int32 nPos = m_pLineDist->GetSelectEntryPos();
868 :
869 0 : switch ( nPos )
870 : {
871 : case LLINESPACE_1:
872 : case LLINESPACE_15:
873 : case LLINESPACE_2:
874 0 : m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos );
875 0 : break;
876 :
877 : case LLINESPACE_PROP:
878 : m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos,
879 0 : (sal_uInt16)m_pLineDistAtPercentBox->Denormalize( m_pLineDistAtPercentBox->GetValue() ) );
880 0 : break;
881 :
882 : case LLINESPACE_MIN:
883 : case LLINESPACE_DURCH:
884 : case LLINESPACE_FIX:
885 : m_pExampleWin->SetLineSpace( (SvxPrevLineSpace)nPos,
886 0 : (sal_uInt16)GetCoreValue( *m_pLineDistAtMetricBox, SFX_MAPUNIT_TWIP ) );
887 0 : break;
888 : }
889 0 : m_pExampleWin->Invalidate();
890 0 : }
891 :
892 0 : void SvxStdParagraphTabPage::EnableRegisterMode()
893 : {
894 0 : m_pRegisterCB->Show();
895 0 : m_pRegisterFL->Show();
896 0 : }
897 :
898 0 : void SvxStdParagraphTabPage::EnableContextualMode()
899 : {
900 0 : m_pContextualCB->Show();
901 0 : }
902 :
903 0 : IMPL_LINK( SvxStdParagraphTabPage, AutoHdl_Impl, CheckBox*, pBox )
904 : {
905 0 : bool bEnable = !pBox->IsChecked();
906 0 : m_pFLineLabel->Enable(bEnable);
907 0 : m_pFLineIndent->Enable(bEnable);
908 0 : return 0;
909 : }
910 :
911 0 : void SvxStdParagraphTabPage::SetPageWidth( sal_uInt16 nPageWidth )
912 : {
913 0 : nWidth = nPageWidth;
914 0 : }
915 :
916 0 : void SvxStdParagraphTabPage::EnableAutoFirstLine()
917 : {
918 0 : m_pAutoCB->Show();
919 0 : }
920 :
921 0 : void SvxStdParagraphTabPage::EnableAbsLineDist(long nMinTwip)
922 : {
923 0 : m_pLineDist->InsertEntry(sAbsDist);
924 0 : nMinFixDist = nMinTwip;
925 0 : }
926 :
927 0 : void SvxStdParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
928 : {
929 :
930 : /* different bit represent call to different method of SvxStdParagraphTabPage
931 : 0x0001 --->EnableRelativeMode()
932 : 0x0002 --->EnableRegisterMode()
933 : 0x0004 --->EnableAutoFirstLine()
934 : 0x0008 --->EnableNegativeMode()
935 : 0x0010 --->EnableContextualMode()
936 : */
937 0 : SFX_ITEMSET_ARG (&aSet,pPageWidthItem,SfxUInt16Item,SID_SVXSTDPARAGRAPHTABPAGE_PAGEWIDTH,false);
938 0 : SFX_ITEMSET_ARG (&aSet,pFlagSetItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_FLAGSET,false);
939 0 : SFX_ITEMSET_ARG (&aSet,pLineDistItem,SfxUInt32Item,SID_SVXSTDPARAGRAPHTABPAGE_ABSLINEDIST,false);
940 :
941 0 : if (pPageWidthItem)
942 0 : SetPageWidth(pPageWidthItem->GetValue());
943 :
944 0 : if (pFlagSetItem )
945 0 : if (( 0x0001 & pFlagSetItem->GetValue())== 0x0001 )
946 0 : EnableRelativeMode();
947 :
948 0 : if (pFlagSetItem)
949 0 : if (( 0x0002 & pFlagSetItem->GetValue())== 0x0002 )
950 0 : EnableRegisterMode();
951 :
952 0 : if (pFlagSetItem)
953 0 : if ( ( 0x0004 & pFlagSetItem->GetValue())== 0x0004 )
954 0 : EnableAutoFirstLine();
955 :
956 0 : if(pLineDistItem)
957 0 : EnableAbsLineDist(pLineDistItem->GetValue());
958 :
959 0 : if (pFlagSetItem)
960 0 : if (( 0x0008 & pFlagSetItem->GetValue()) == 0x0008 )
961 0 : EnableNegativeMode();
962 :
963 0 : if (pFlagSetItem)
964 0 : if (( 0x0010 & pFlagSetItem->GetValue()) == 0x0010 )
965 0 : EnableContextualMode();
966 0 : }
967 :
968 : #define LASTLINEPOS_DEFAULT 0
969 : #define LASTLINEPOS_LEFT 1
970 :
971 : #define LASTLINECOUNT_OLD 3
972 : #define LASTLINECOUNT_NEW 4
973 :
974 0 : SvxParaAlignTabPage::SvxParaAlignTabPage( vcl::Window* pParent, const SfxItemSet& rSet )
975 :
976 0 : : SfxTabPage(pParent, "ParaAlignPage", "cui/ui/paragalignpage.ui",&rSet)
977 : {
978 0 : get(m_pLeft,"radioBTN_LEFTALIGN");
979 0 : get(m_pRight,"radioBTN_RIGHTALIGN");
980 0 : get(m_pCenter,"radioBTN_CENTERALIGN");
981 0 : get(m_pJustify,"radioBTN_JUSTIFYALIGN");
982 0 : get(m_pLeftBottom,"labelST_LEFTALIGN_ASIAN");
983 0 : get(m_pRightTop,"labelST_RIGHTALIGN_ASIAN");
984 :
985 0 : get(m_pLastLineFT,"labelLB_LASTLINE");
986 0 : get(m_pLastLineLB,"comboLB_LASTLINE");
987 0 : get(m_pExpandCB,"checkCB_EXPAND");
988 0 : get(m_pSnapToGridCB,"checkCB_SNAP");
989 0 : get(m_pExampleWin,"drawingareaWN_EXAMPLE");
990 :
991 0 : get(m_pVertAlignLB,"comboLB_VERTALIGN");
992 0 : get(m_pVertAlignFL,"frameFL_VERTALIGN");
993 :
994 0 : get(m_pPropertiesFL,"framePROPERTIES");
995 0 : get(m_pTextDirectionLB,"comboLB_TEXTDIRECTION");
996 :
997 0 : SvtLanguageOptions aLangOptions;
998 0 : sal_uInt16 nLastLinePos = LASTLINEPOS_DEFAULT;
999 :
1000 0 : if ( aLangOptions.IsAsianTypographyEnabled() )
1001 : {
1002 0 : m_pLeft->SetText(m_pLeftBottom->GetText());
1003 0 : m_pRight->SetText(m_pRightTop->GetText());
1004 :
1005 0 : OUString sLeft(m_pLeft->GetText());
1006 0 : sLeft = MnemonicGenerator::EraseAllMnemonicChars( sLeft );
1007 :
1008 0 : if ( m_pLastLineLB->GetEntryCount() == LASTLINECOUNT_OLD )
1009 : {
1010 0 : m_pLastLineLB->RemoveEntry( 0 );
1011 0 : m_pLastLineLB->InsertEntry( sLeft, 0 );
1012 : }
1013 : else
1014 0 : nLastLinePos = LASTLINEPOS_LEFT;
1015 : }
1016 :
1017 : // remove "Default" or "Left" entry, depends on CJKOptions
1018 0 : if ( m_pLastLineLB->GetEntryCount() == LASTLINECOUNT_NEW )
1019 0 : m_pLastLineLB->RemoveEntry( nLastLinePos );
1020 :
1021 0 : Link<> aLink = LINK( this, SvxParaAlignTabPage, AlignHdl_Impl );
1022 0 : m_pLeft->SetClickHdl( aLink );
1023 0 : m_pRight->SetClickHdl( aLink );
1024 0 : m_pCenter->SetClickHdl( aLink );
1025 0 : m_pJustify->SetClickHdl( aLink );
1026 0 : m_pLastLineLB->SetSelectHdl( LINK( this, SvxParaAlignTabPage, LastLineHdl_Impl ) );
1027 0 : m_pTextDirectionLB->SetSelectHdl( LINK( this, SvxParaAlignTabPage, TextDirectionHdl_Impl ) );
1028 :
1029 0 : if( aLangOptions.IsCTLFontEnabled() )
1030 : {
1031 0 : m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_LTR ), FRMDIR_HORI_LEFT_TOP );
1032 0 : m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_RTL ), FRMDIR_HORI_RIGHT_TOP );
1033 0 : m_pTextDirectionLB->InsertEntryValue( CUI_RESSTR( RID_SVXSTR_FRAMEDIR_SUPER ), FRMDIR_ENVIRONMENT );
1034 :
1035 0 : m_pPropertiesFL->Show();
1036 : }
1037 :
1038 0 : setPreviewsToSamePlace(pParent, this);
1039 0 : }
1040 :
1041 0 : SvxParaAlignTabPage::~SvxParaAlignTabPage()
1042 : {
1043 0 : disposeOnce();
1044 0 : }
1045 :
1046 0 : void SvxParaAlignTabPage::dispose()
1047 : {
1048 0 : m_pLeft.clear();
1049 0 : m_pRight.clear();
1050 0 : m_pCenter.clear();
1051 0 : m_pJustify.clear();
1052 0 : m_pLeftBottom.clear();
1053 0 : m_pRightTop.clear();
1054 0 : m_pLastLineFT.clear();
1055 0 : m_pLastLineLB.clear();
1056 0 : m_pExpandCB.clear();
1057 0 : m_pSnapToGridCB.clear();
1058 0 : m_pExampleWin.clear();
1059 0 : m_pVertAlignFL.clear();
1060 0 : m_pVertAlignLB.clear();
1061 0 : m_pPropertiesFL.clear();
1062 0 : m_pTextDirectionLB.clear();
1063 0 : SfxTabPage::dispose();
1064 0 : }
1065 :
1066 0 : SfxTabPage::sfxpg SvxParaAlignTabPage::DeactivatePage( SfxItemSet* _pSet )
1067 : {
1068 0 : if ( _pSet )
1069 0 : FillItemSet( _pSet );
1070 0 : return LEAVE_PAGE;
1071 : }
1072 :
1073 0 : VclPtr<SfxTabPage> SvxParaAlignTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet )
1074 : {
1075 0 : return VclPtr<SvxParaAlignTabPage>::Create(pParent, *rSet);
1076 : }
1077 :
1078 0 : bool SvxParaAlignTabPage::FillItemSet( SfxItemSet* rOutSet )
1079 : {
1080 0 : bool bModified = false;
1081 :
1082 0 : bool bAdj = false, bChecked = false;
1083 0 : SvxAdjust eAdjust = SVX_ADJUST_LEFT;
1084 :
1085 0 : if ( m_pLeft->IsChecked() )
1086 : {
1087 0 : eAdjust = SVX_ADJUST_LEFT;
1088 0 : bAdj = !m_pLeft->GetSavedValue();
1089 0 : bChecked = true;
1090 : }
1091 0 : else if ( m_pRight->IsChecked() )
1092 : {
1093 0 : eAdjust = SVX_ADJUST_RIGHT;
1094 0 : bAdj = !m_pRight->GetSavedValue();
1095 0 : bChecked = true;
1096 : }
1097 0 : else if ( m_pCenter->IsChecked() )
1098 : {
1099 0 : eAdjust = SVX_ADJUST_CENTER;
1100 0 : bAdj = !m_pCenter->GetSavedValue();
1101 0 : bChecked = true;
1102 : }
1103 0 : else if ( m_pJustify->IsChecked() )
1104 : {
1105 0 : eAdjust = SVX_ADJUST_BLOCK;
1106 0 : bAdj = !m_pJustify->GetSavedValue() ||
1107 0 : m_pExpandCB->IsValueChangedFromSaved() ||
1108 0 : m_pLastLineLB->IsValueChangedFromSaved();
1109 0 : bChecked = true;
1110 : }
1111 0 : sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1112 :
1113 0 : if ( bAdj )
1114 : {
1115 0 : const SvxAdjustItem* pOld = static_cast<const SvxAdjustItem*>(GetOldItem( *rOutSet, SID_ATTR_PARA_ADJUST ));
1116 :
1117 0 : SvxAdjust eOneWord = m_pExpandCB->IsChecked() ? SVX_ADJUST_BLOCK : SVX_ADJUST_LEFT;
1118 :
1119 0 : sal_Int32 nLBPos = m_pLastLineLB->GetSelectEntryPos();
1120 0 : SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1121 :
1122 0 : if ( 1 == nLBPos )
1123 0 : eLastBlock = SVX_ADJUST_CENTER;
1124 0 : else if ( 2 == nLBPos )
1125 0 : eLastBlock = SVX_ADJUST_BLOCK;
1126 :
1127 : bool bNothingWasChecked =
1128 0 : !m_pLeft->GetSavedValue() && !m_pRight->GetSavedValue() &&
1129 0 : !m_pCenter->GetSavedValue() && !m_pJustify->GetSavedValue();
1130 :
1131 0 : if ( !pOld || pOld->GetAdjust() != eAdjust ||
1132 0 : pOld->GetOneWord() != eOneWord ||
1133 0 : pOld->GetLastBlock() != eLastBlock ||
1134 0 : ( bChecked && bNothingWasChecked ) )
1135 : {
1136 0 : bModified = true;
1137 : SvxAdjustItem aAdj(
1138 0 : static_cast<const SvxAdjustItem&>(GetItemSet().Get( _nWhich )) );
1139 0 : aAdj.SetAdjust( eAdjust );
1140 0 : aAdj.SetOneWord( eOneWord );
1141 0 : aAdj.SetLastBlock( eLastBlock );
1142 0 : rOutSet->Put( aAdj );
1143 : }
1144 : }
1145 0 : if(m_pSnapToGridCB->IsValueChangedFromSaved())
1146 : {
1147 0 : rOutSet->Put(SvxParaGridItem(m_pSnapToGridCB->IsChecked(), GetWhich( SID_ATTR_PARA_SNAPTOGRID )));
1148 0 : bModified = true;
1149 : }
1150 0 : if(m_pVertAlignLB->IsValueChangedFromSaved())
1151 : {
1152 0 : rOutSet->Put(SvxParaVertAlignItem(m_pVertAlignLB->GetSelectEntryPos(), GetWhich( SID_PARA_VERTALIGN )));
1153 0 : bModified = true;
1154 : }
1155 :
1156 0 : if( m_pTextDirectionLB->IsVisible() )
1157 : {
1158 0 : SvxFrameDirection eDir = m_pTextDirectionLB->GetSelectEntryValue();
1159 0 : if( m_pTextDirectionLB->IsValueChangedFromSaved() )
1160 : {
1161 0 : rOutSet->Put( SvxFrameDirectionItem( eDir, GetWhich( SID_ATTR_FRAMEDIRECTION ) ) );
1162 0 : bModified = true;
1163 : }
1164 : }
1165 :
1166 0 : return bModified;
1167 : }
1168 :
1169 0 : void SvxParaAlignTabPage::Reset( const SfxItemSet* rSet )
1170 : {
1171 0 : sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_ADJUST );
1172 0 : SfxItemState eItemState = rSet->GetItemState( _nWhich );
1173 :
1174 0 : sal_Int32 nLBSelect = 0;
1175 0 : if ( eItemState >= SfxItemState::DEFAULT )
1176 : {
1177 0 : const SvxAdjustItem& rAdj = static_cast<const SvxAdjustItem&>(rSet->Get( _nWhich ));
1178 :
1179 0 : switch ( rAdj.GetAdjust() /*!!! ask VB rAdj.GetLastBlock()*/ )
1180 : {
1181 0 : case SVX_ADJUST_LEFT: m_pLeft->Check(); break;
1182 :
1183 0 : case SVX_ADJUST_RIGHT: m_pRight->Check(); break;
1184 :
1185 0 : case SVX_ADJUST_CENTER: m_pCenter->Check(); break;
1186 :
1187 0 : case SVX_ADJUST_BLOCK: m_pJustify->Check(); break;
1188 : default: ; //prevent warning
1189 : }
1190 0 : bool bEnable = m_pJustify->IsChecked();
1191 0 : m_pLastLineFT->Enable(bEnable);
1192 0 : m_pLastLineLB->Enable(bEnable);
1193 :
1194 0 : switch(rAdj.GetLastBlock())
1195 : {
1196 0 : case SVX_ADJUST_LEFT: nLBSelect = 0; break;
1197 :
1198 0 : case SVX_ADJUST_CENTER: nLBSelect = 1; break;
1199 :
1200 0 : case SVX_ADJUST_BLOCK: nLBSelect = 2; break;
1201 : default: ; //prevent warning
1202 : }
1203 0 : m_pExpandCB->Enable(bEnable && nLBSelect == 2);
1204 0 : m_pExpandCB->Check(SVX_ADJUST_BLOCK == rAdj.GetOneWord());
1205 : }
1206 : else
1207 : {
1208 0 : m_pLeft->Check( false );
1209 0 : m_pRight->Check( false );
1210 0 : m_pCenter->Check( false );
1211 0 : m_pJustify->Check( false );
1212 : }
1213 0 : m_pLastLineLB->SelectEntryPos(nLBSelect);
1214 :
1215 0 : sal_uInt16 nHtmlMode = GetHtmlMode_Impl(*rSet);
1216 0 : if(nHtmlMode & HTMLMODE_ON)
1217 : {
1218 0 : m_pLastLineLB->Hide();
1219 0 : m_pLastLineFT->Hide();
1220 0 : m_pExpandCB->Hide();
1221 0 : if(!(nHtmlMode & HTMLMODE_FULL_STYLES) )
1222 0 : m_pJustify->Disable();
1223 0 : m_pSnapToGridCB->Show(false);
1224 : }
1225 0 : _nWhich = GetWhich(SID_ATTR_PARA_SNAPTOGRID);
1226 0 : eItemState = rSet->GetItemState( _nWhich );
1227 0 : if ( eItemState >= SfxItemState::DEFAULT )
1228 : {
1229 0 : const SvxParaGridItem& rSnap = static_cast<const SvxParaGridItem&>(rSet->Get( _nWhich ));
1230 0 : m_pSnapToGridCB->Check(rSnap.GetValue());
1231 : }
1232 :
1233 0 : _nWhich = GetWhich( SID_PARA_VERTALIGN );
1234 0 : eItemState = rSet->GetItemState( _nWhich );
1235 :
1236 0 : if ( eItemState >= SfxItemState::DEFAULT )
1237 : {
1238 0 : m_pVertAlignFL->Show();
1239 :
1240 0 : const SvxParaVertAlignItem& rAlign = static_cast<const SvxParaVertAlignItem&>(rSet->Get( _nWhich ));
1241 :
1242 0 : m_pVertAlignLB->SelectEntryPos(rAlign.GetValue());
1243 : }
1244 :
1245 0 : _nWhich = GetWhich( SID_ATTR_FRAMEDIRECTION );
1246 : //text direction
1247 0 : if( SfxItemState::DEFAULT <= rSet->GetItemState( _nWhich ) )
1248 : {
1249 0 : const SvxFrameDirectionItem& rFrameDirItem = static_cast<const SvxFrameDirectionItem&>( rSet->Get( _nWhich ) );
1250 0 : m_pTextDirectionLB->SelectEntryValue( (SvxFrameDirection)rFrameDirItem.GetValue() );
1251 0 : m_pTextDirectionLB->SaveValue();
1252 : }
1253 :
1254 0 : m_pSnapToGridCB->SaveValue();
1255 0 : m_pVertAlignLB->SaveValue();
1256 0 : m_pLeft->SaveValue();
1257 0 : m_pRight->SaveValue();
1258 0 : m_pCenter->SaveValue();
1259 0 : m_pJustify->SaveValue();
1260 0 : m_pLastLineLB->SaveValue();
1261 0 : m_pExpandCB->SaveValue();
1262 :
1263 0 : UpdateExample_Impl();
1264 0 : }
1265 :
1266 0 : IMPL_LINK_NOARG(SvxParaAlignTabPage, AlignHdl_Impl)
1267 : {
1268 0 : bool bJustify = m_pJustify->IsChecked();
1269 0 : m_pLastLineFT->Enable(bJustify);
1270 0 : m_pLastLineLB->Enable(bJustify);
1271 0 : bool bLastLineIsBlock = m_pLastLineLB->GetSelectEntryPos() == 2;
1272 0 : m_pExpandCB->Enable(bJustify && bLastLineIsBlock);
1273 0 : UpdateExample_Impl();
1274 0 : return 0;
1275 : }
1276 :
1277 0 : IMPL_LINK_NOARG(SvxParaAlignTabPage, LastLineHdl_Impl)
1278 : {
1279 : //fdo#41350 only enable 'Expand last word' if last line is also justified
1280 0 : bool bLastLineIsBlock = m_pLastLineLB->GetSelectEntryPos() == 2;
1281 0 : m_pExpandCB->Enable(bLastLineIsBlock);
1282 0 : UpdateExample_Impl();
1283 0 : return 0;
1284 : }
1285 :
1286 0 : IMPL_LINK_NOARG(SvxParaAlignTabPage, TextDirectionHdl_Impl)
1287 : {
1288 0 : SvxFrameDirection eDir = m_pTextDirectionLB->GetSelectEntryValue();
1289 0 : switch ( eDir )
1290 : {
1291 : // check the default alignment for this text direction
1292 0 : case FRMDIR_HORI_LEFT_TOP : m_pLeft->Check( true ); break;
1293 0 : case FRMDIR_HORI_RIGHT_TOP : m_pRight->Check( true ); break;
1294 0 : case FRMDIR_ENVIRONMENT : /* do nothing */ break;
1295 : default:
1296 : {
1297 : SAL_WARN( "cui.tabpages", "SvxParaAlignTabPage::TextDirectionHdl_Impl(): other directions not supported" );
1298 : }
1299 : }
1300 :
1301 0 : return 0;
1302 : }
1303 :
1304 0 : void SvxParaAlignTabPage::UpdateExample_Impl()
1305 : {
1306 0 : if ( m_pLeft->IsChecked() )
1307 0 : m_pExampleWin->SetAdjust( SVX_ADJUST_LEFT );
1308 0 : else if ( m_pRight->IsChecked() )
1309 0 : m_pExampleWin->SetAdjust( SVX_ADJUST_RIGHT );
1310 0 : else if ( m_pCenter->IsChecked() )
1311 0 : m_pExampleWin->SetAdjust( SVX_ADJUST_CENTER );
1312 0 : else if ( m_pJustify->IsChecked() )
1313 : {
1314 0 : m_pExampleWin->SetAdjust( SVX_ADJUST_BLOCK );
1315 0 : SvxAdjust eLastBlock = SVX_ADJUST_LEFT;
1316 0 : sal_Int32 nLBPos = m_pLastLineLB->GetSelectEntryPos();
1317 0 : if(nLBPos == 1)
1318 0 : eLastBlock = SVX_ADJUST_CENTER;
1319 0 : else if(nLBPos == 2)
1320 0 : eLastBlock = SVX_ADJUST_BLOCK;
1321 0 : m_pExampleWin->SetLastLine( eLastBlock );
1322 : }
1323 :
1324 0 : m_pExampleWin->Invalidate();
1325 0 : }
1326 :
1327 0 : void SvxParaAlignTabPage::EnableJustifyExt()
1328 : {
1329 0 : m_pLastLineFT->Show();
1330 0 : m_pLastLineLB->Show();
1331 0 : m_pExpandCB->Show();
1332 0 : SvtLanguageOptions aCJKOptions;
1333 0 : if(aCJKOptions.IsAsianTypographyEnabled())
1334 0 : m_pSnapToGridCB->Show();
1335 :
1336 0 : }
1337 :
1338 0 : void SvxParaAlignTabPage::PageCreated (const SfxAllItemSet& aSet)
1339 : {
1340 0 : SFX_ITEMSET_ARG (&aSet,pBoolItem,SfxBoolItem,SID_SVXPARAALIGNTABPAGE_ENABLEJUSTIFYEXT,false);
1341 0 : if (pBoolItem)
1342 0 : if(pBoolItem->GetValue())
1343 0 : EnableJustifyExt();
1344 0 : }
1345 :
1346 0 : VclPtr<SfxTabPage> SvxExtParagraphTabPage::Create( vcl::Window* pParent,
1347 : const SfxItemSet* rSet )
1348 : {
1349 0 : return VclPtr<SvxExtParagraphTabPage>::Create( pParent, *rSet );
1350 : }
1351 :
1352 0 : bool SvxExtParagraphTabPage::FillItemSet( SfxItemSet* rOutSet )
1353 : {
1354 0 : bool bModified = false;
1355 0 : sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1356 0 : const TriState eHyphenState = m_pHyphenBox->GetState();
1357 0 : const SfxPoolItem* pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_HYPHENZONE );
1358 :
1359 0 : if ( m_pHyphenBox->IsValueChangedFromSaved() ||
1360 0 : m_pExtHyphenBeforeBox->IsValueModified() ||
1361 0 : m_pExtHyphenAfterBox->IsValueModified() ||
1362 0 : m_pMaxHyphenEdit->IsValueModified() )
1363 : {
1364 : SvxHyphenZoneItem aHyphen(
1365 0 : static_cast<const SvxHyphenZoneItem&>(GetItemSet().Get( _nWhich )) );
1366 0 : aHyphen.SetHyphen( eHyphenState == TRISTATE_TRUE );
1367 :
1368 0 : if ( eHyphenState == TRISTATE_TRUE )
1369 : {
1370 0 : aHyphen.GetMinLead() = (sal_uInt8)m_pExtHyphenBeforeBox->GetValue();
1371 0 : aHyphen.GetMinTrail() = (sal_uInt8)m_pExtHyphenAfterBox->GetValue();
1372 : }
1373 0 : aHyphen.GetMaxHyphens() = (sal_uInt8)m_pMaxHyphenEdit->GetValue();
1374 :
1375 0 : if ( !pOld ||
1376 0 : !( *static_cast<const SvxHyphenZoneItem*>(pOld) == aHyphen ) ||
1377 0 : m_pHyphenBox->IsValueChangedFromSaved())
1378 : {
1379 0 : rOutSet->Put( aHyphen );
1380 0 : bModified = true;
1381 0 : }
1382 : }
1383 :
1384 0 : if (m_pPagenumEdit->IsEnabled() && m_pPagenumEdit->IsValueModified())
1385 : {
1386 : SfxUInt16Item aPageNum( SID_ATTR_PARA_PAGENUM,
1387 0 : (sal_uInt16)m_pPagenumEdit->GetValue() );
1388 :
1389 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGENUM );
1390 :
1391 0 : if ( !pOld || static_cast<const SfxUInt16Item*>(pOld)->GetValue() != aPageNum.GetValue() )
1392 : {
1393 0 : rOutSet->Put( aPageNum );
1394 0 : bModified = true;
1395 0 : }
1396 : }
1397 :
1398 : // pagebreak
1399 :
1400 0 : TriState eState = m_pApplyCollBtn->GetState();
1401 0 : bool bIsPageModel = false;
1402 :
1403 0 : _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1404 0 : OUString sPage;
1405 0 : if ( m_pApplyCollBtn->IsValueChangedFromSaved() ||
1406 0 : ( TRISTATE_TRUE == eState &&
1407 0 : m_pApplyCollBox->IsValueChangedFromSaved() ) )
1408 : {
1409 0 : if ( eState == TRISTATE_TRUE )
1410 : {
1411 0 : sPage = m_pApplyCollBox->GetSelectEntry();
1412 0 : bIsPageModel = !sPage.isEmpty();
1413 : }
1414 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_MODEL );
1415 :
1416 0 : if ( !pOld || static_cast<const SvxPageModelItem*>(pOld)->GetValue() != sPage )
1417 : {
1418 0 : rOutSet->Put( SvxPageModelItem( sPage, false, _nWhich ) );
1419 0 : bModified = true;
1420 : }
1421 : else
1422 0 : bIsPageModel = false;
1423 : }
1424 0 : else if(TRISTATE_TRUE == eState && m_pApplyCollBtn->IsEnabled())
1425 0 : bIsPageModel = true;
1426 : else
1427 0 : rOutSet->Put( SvxPageModelItem( sPage, false, _nWhich ) );
1428 :
1429 0 : _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1430 :
1431 0 : if ( bIsPageModel )
1432 : // if PageModel is turned on, always turn off PageBreak
1433 0 : rOutSet->Put( SvxFormatBreakItem( SVX_BREAK_NONE, _nWhich ) );
1434 : else
1435 : {
1436 0 : eState = m_pPageBreakBox->GetState();
1437 0 : SfxItemState eModelState = GetItemSet().GetItemState(SID_ATTR_PARA_MODEL, false);
1438 :
1439 0 : if ( (eModelState == SfxItemState::SET && TRISTATE_TRUE == m_pPageBreakBox->GetState()) ||
1440 0 : m_pPageBreakBox->IsValueChangedFromSaved() ||
1441 0 : m_pBreakTypeLB->IsValueChangedFromSaved() ||
1442 0 : m_pBreakPositionLB->IsValueChangedFromSaved() )
1443 : {
1444 : const SvxFormatBreakItem rOldBreak(
1445 0 : static_cast<const SvxFormatBreakItem&>(GetItemSet().Get( _nWhich )));
1446 0 : SvxFormatBreakItem aBreak(rOldBreak.GetBreak(), rOldBreak.Which());
1447 :
1448 0 : switch ( eState )
1449 : {
1450 : case TRISTATE_TRUE:
1451 : {
1452 0 : bool bBefore = m_pBreakPositionLB->GetSelectEntryPos() == 0;
1453 :
1454 0 : if ( m_pBreakTypeLB->GetSelectEntryPos() == 0 )
1455 : {
1456 0 : if ( bBefore )
1457 0 : aBreak.SetValue( SVX_BREAK_PAGE_BEFORE );
1458 : else
1459 0 : aBreak.SetValue( SVX_BREAK_PAGE_AFTER );
1460 : }
1461 : else
1462 : {
1463 0 : if ( bBefore )
1464 0 : aBreak.SetValue( SVX_BREAK_COLUMN_BEFORE );
1465 : else
1466 0 : aBreak.SetValue( SVX_BREAK_COLUMN_AFTER );
1467 : }
1468 0 : break;
1469 : }
1470 :
1471 : case TRISTATE_FALSE:
1472 0 : aBreak.SetValue( SVX_BREAK_NONE );
1473 0 : break;
1474 : default: ; //prevent warning
1475 : }
1476 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_PAGEBREAK );
1477 :
1478 0 : if ( eState != m_pPageBreakBox->GetSavedValue() ||
1479 0 : !pOld || !( *static_cast<const SvxFormatBreakItem*>(pOld) == aBreak ) )
1480 : {
1481 0 : bModified = true;
1482 0 : rOutSet->Put( aBreak );
1483 0 : }
1484 : }
1485 : }
1486 :
1487 : // paragraph split
1488 0 : _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1489 0 : eState = m_pKeepTogetherBox->GetState();
1490 :
1491 0 : if ( m_pKeepTogetherBox->IsValueChangedFromSaved() )
1492 : {
1493 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_SPLIT );
1494 :
1495 0 : if ( !pOld || static_cast<const SvxFormatSplitItem*>(pOld)->GetValue() !=
1496 0 : ( eState == TRISTATE_FALSE ) )
1497 : {
1498 0 : rOutSet->Put( SvxFormatSplitItem( eState == TRISTATE_FALSE, _nWhich ) );
1499 0 : bModified = true;
1500 : }
1501 : }
1502 :
1503 : // keep paragraphs
1504 0 : _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1505 0 : eState = m_pKeepParaBox->GetState();
1506 :
1507 0 : if ( m_pKeepParaBox->IsValueChangedFromSaved() )
1508 : {
1509 : // if the status has changed, putting is necessary
1510 0 : rOutSet->Put( SvxFormatKeepItem( eState == TRISTATE_TRUE, _nWhich ) );
1511 0 : bModified = true;
1512 : }
1513 :
1514 : // widows and orphans
1515 0 : _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1516 0 : eState = m_pWidowBox->GetState();
1517 :
1518 0 : if ( m_pWidowBox->IsValueChangedFromSaved() ||
1519 0 : m_pWidowRowNo->IsValueModified() )
1520 : {
1521 : SvxWidowsItem rItem( eState == TRISTATE_TRUE ?
1522 0 : (sal_uInt8)m_pWidowRowNo->GetValue() : 0, _nWhich );
1523 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_WIDOWS );
1524 :
1525 0 : if ( m_pWidowBox->IsValueChangedFromSaved() || !pOld || !( *static_cast<const SvxWidowsItem*>(pOld) == rItem ) )
1526 : {
1527 0 : rOutSet->Put( rItem );
1528 0 : bModified = true;
1529 0 : }
1530 : }
1531 :
1532 0 : _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1533 0 : eState = m_pOrphanBox->GetState();
1534 :
1535 0 : if ( m_pOrphanBox->IsValueChangedFromSaved() ||
1536 0 : m_pOrphanRowNo->IsValueModified() )
1537 : {
1538 : SvxOrphansItem rItem( eState == TRISTATE_TRUE ?
1539 0 : (sal_uInt8)m_pOrphanRowNo->GetValue() : 0, _nWhich );
1540 0 : pOld = GetOldItem( *rOutSet, SID_ATTR_PARA_ORPHANS );
1541 :
1542 0 : if ( m_pOrphanBox->IsValueChangedFromSaved() ||
1543 0 : !pOld ||
1544 0 : !( *static_cast<const SvxOrphansItem*>(pOld) == rItem ) )
1545 : {
1546 0 : rOutSet->Put( rItem );
1547 0 : bModified = true;
1548 0 : }
1549 : }
1550 :
1551 0 : return bModified;
1552 : }
1553 :
1554 0 : void SvxExtParagraphTabPage::Reset( const SfxItemSet* rSet )
1555 : {
1556 0 : sal_uInt16 _nWhich = GetWhich( SID_ATTR_PARA_HYPHENZONE );
1557 0 : SfxItemState eItemState = rSet->GetItemState( _nWhich );
1558 :
1559 0 : bool bItemAvailable = eItemState >= SfxItemState::DEFAULT;
1560 0 : bool bIsHyphen = false;
1561 0 : if( !bHtmlMode && bItemAvailable )
1562 : {
1563 : const SvxHyphenZoneItem& rHyphen =
1564 0 : static_cast<const SvxHyphenZoneItem&>(rSet->Get( _nWhich ));
1565 0 : m_pHyphenBox->EnableTriState( false );
1566 :
1567 0 : bIsHyphen = rHyphen.IsHyphen();
1568 0 : m_pHyphenBox->SetState( bIsHyphen ? TRISTATE_TRUE : TRISTATE_FALSE );
1569 :
1570 0 : m_pExtHyphenBeforeBox->SetValue( rHyphen.GetMinLead() );
1571 0 : m_pExtHyphenAfterBox->SetValue( rHyphen.GetMinTrail() );
1572 0 : m_pMaxHyphenEdit->SetValue( rHyphen.GetMaxHyphens() );
1573 : }
1574 : else
1575 : {
1576 0 : m_pHyphenBox->SetState( TRISTATE_INDET );
1577 : }
1578 0 : bool bEnable = bItemAvailable && bIsHyphen;
1579 0 : m_pExtHyphenBeforeBox->Enable(bEnable);
1580 0 : m_pExtHyphenAfterBox->Enable(bEnable);
1581 0 : m_pBeforeText->Enable(bEnable);
1582 0 : m_pAfterText->Enable(bEnable);
1583 0 : m_pMaxHyphenLabel->Enable(bEnable);
1584 0 : m_pMaxHyphenEdit->Enable(bEnable);
1585 :
1586 0 : _nWhich = GetWhich( SID_ATTR_PARA_PAGENUM );
1587 :
1588 0 : if (rSet->GetItemState(_nWhich) >= SfxItemState::SET)
1589 : {
1590 : const sal_uInt16 nPageNum =
1591 0 : static_cast<const SfxUInt16Item&>(rSet->Get( _nWhich ) ).GetValue();
1592 0 : m_pPagenumEdit->SetValue( nPageNum );
1593 : }
1594 :
1595 0 : if ( bPageBreak )
1596 : {
1597 : // first handle PageModel
1598 0 : _nWhich = GetWhich( SID_ATTR_PARA_MODEL );
1599 0 : bool bIsPageModel = false;
1600 0 : eItemState = rSet->GetItemState( _nWhich );
1601 :
1602 0 : if ( eItemState >= SfxItemState::SET )
1603 : {
1604 0 : m_pApplyCollBtn->EnableTriState( false );
1605 :
1606 : const SvxPageModelItem& rModel =
1607 0 : static_cast<const SvxPageModelItem&>(rSet->Get( _nWhich ));
1608 0 : OUString aStr( rModel.GetValue() );
1609 :
1610 0 : if ( !aStr.isEmpty() &&
1611 0 : m_pApplyCollBox->GetEntryPos( aStr ) != LISTBOX_ENTRY_NOTFOUND )
1612 : {
1613 0 : m_pApplyCollBox->SelectEntry( aStr );
1614 0 : m_pApplyCollBtn->SetState( TRISTATE_TRUE );
1615 0 : bIsPageModel = true;
1616 :
1617 0 : m_pPageBreakBox->Enable();
1618 0 : m_pPageBreakBox->EnableTriState( false );
1619 0 : m_pBreakTypeFT->Enable();
1620 0 : m_pBreakTypeLB->Enable();
1621 0 : m_pBreakPositionFT->Enable();
1622 0 : m_pBreakPositionLB->Enable();
1623 0 : m_pApplyCollBtn->Enable();
1624 0 : m_pPageBreakBox->SetState( TRISTATE_TRUE );
1625 :
1626 : //select page break
1627 0 : m_pBreakTypeLB->SelectEntryPos(0);
1628 : //select break before
1629 0 : m_pBreakPositionLB->SelectEntryPos(0);
1630 : }
1631 : else
1632 : {
1633 0 : m_pApplyCollBox->SetNoSelection();
1634 0 : m_pApplyCollBtn->SetState( TRISTATE_FALSE );
1635 0 : }
1636 : }
1637 0 : else if ( SfxItemState::DONTCARE == eItemState )
1638 : {
1639 0 : m_pApplyCollBtn->EnableTriState( true );
1640 0 : m_pApplyCollBtn->SetState( TRISTATE_INDET );
1641 0 : m_pApplyCollBox->SetNoSelection();
1642 : }
1643 : else
1644 : {
1645 0 : m_pApplyCollBtn->Enable(false);
1646 0 : m_pApplyCollBox->Enable(false);
1647 0 : m_pPagenumEdit->Enable(false);
1648 0 : m_pPagenumText->Enable(false);
1649 : }
1650 :
1651 0 : if ( !bIsPageModel )
1652 : {
1653 0 : _nWhich = GetWhich( SID_ATTR_PARA_PAGEBREAK );
1654 0 : eItemState = rSet->GetItemState( _nWhich );
1655 :
1656 0 : if ( eItemState >= SfxItemState::DEFAULT )
1657 : {
1658 : const SvxFormatBreakItem& rPageBreak =
1659 0 : static_cast<const SvxFormatBreakItem&>(rSet->Get( _nWhich ));
1660 :
1661 0 : SvxBreak eBreak = (SvxBreak)rPageBreak.GetValue();
1662 :
1663 : // PageBreak not via CTRL-RETURN,
1664 : // then CheckBox can be freed
1665 0 : m_pPageBreakBox->Enable();
1666 0 : m_pPageBreakBox->EnableTriState( false );
1667 0 : m_pBreakTypeFT->Enable();
1668 0 : m_pBreakTypeLB->Enable();
1669 0 : m_pBreakPositionFT->Enable();
1670 0 : m_pBreakPositionLB->Enable();
1671 :
1672 0 : m_pPageBreakBox->SetState( TRISTATE_TRUE );
1673 :
1674 0 : bool _bEnable = eBreak != SVX_BREAK_NONE &&
1675 0 : eBreak != SVX_BREAK_COLUMN_BEFORE &&
1676 0 : eBreak != SVX_BREAK_COLUMN_AFTER;
1677 0 : m_pApplyCollBtn->Enable(_bEnable);
1678 0 : if(!_bEnable)
1679 : {
1680 0 : m_pApplyCollBox->Enable(_bEnable);
1681 0 : m_pPagenumEdit->Enable(_bEnable);
1682 : }
1683 :
1684 0 : if ( eBreak == SVX_BREAK_NONE )
1685 0 : m_pPageBreakBox->SetState( TRISTATE_FALSE );
1686 :
1687 0 : sal_Int32 nType = 0; // selection position in break type ListBox : Page
1688 0 : sal_Int32 nPosition = 0; // selection position in break position ListBox : Before
1689 0 : switch ( eBreak )
1690 : {
1691 : case SVX_BREAK_PAGE_BEFORE:
1692 0 : break;
1693 : case SVX_BREAK_PAGE_AFTER:
1694 0 : nPosition = 1;
1695 0 : break;
1696 : case SVX_BREAK_COLUMN_BEFORE:
1697 0 : nType = 1;
1698 0 : break;
1699 : case SVX_BREAK_COLUMN_AFTER:
1700 0 : nType = 1;
1701 0 : nPosition = 1;
1702 0 : break;
1703 : default: ;//prevent warning
1704 : }
1705 0 : m_pBreakTypeLB->SelectEntryPos(nType);
1706 0 : m_pBreakPositionLB->SelectEntryPos(nPosition);
1707 : }
1708 0 : else if ( SfxItemState::DONTCARE == eItemState )
1709 0 : m_pPageBreakBox->SetState( TRISTATE_INDET );
1710 : else
1711 : {
1712 0 : m_pPageBreakBox->Enable(false);
1713 0 : m_pBreakTypeFT->Enable(false);
1714 0 : m_pBreakTypeLB->Enable(false);
1715 0 : m_pBreakPositionFT->Enable(false);
1716 0 : m_pBreakPositionLB->Enable(false);
1717 : }
1718 : }
1719 :
1720 0 : PageBreakPosHdl_Impl( m_pBreakPositionLB );
1721 0 : PageBreakHdl_Impl( m_pPageBreakBox );
1722 : }
1723 :
1724 0 : _nWhich = GetWhich( SID_ATTR_PARA_KEEP );
1725 0 : eItemState = rSet->GetItemState( _nWhich );
1726 :
1727 0 : if ( eItemState >= SfxItemState::DEFAULT )
1728 : {
1729 0 : m_pKeepParaBox->EnableTriState( false );
1730 : const SvxFormatKeepItem& rKeep =
1731 0 : static_cast<const SvxFormatKeepItem&>(rSet->Get( _nWhich ));
1732 :
1733 0 : if ( rKeep.GetValue() )
1734 0 : m_pKeepParaBox->SetState( TRISTATE_TRUE );
1735 : else
1736 0 : m_pKeepParaBox->SetState( TRISTATE_FALSE );
1737 : }
1738 0 : else if ( SfxItemState::DONTCARE == eItemState )
1739 0 : m_pKeepParaBox->SetState( TRISTATE_INDET );
1740 : else
1741 0 : m_pKeepParaBox->Enable(false);
1742 :
1743 0 : _nWhich = GetWhich( SID_ATTR_PARA_SPLIT );
1744 0 : eItemState = rSet->GetItemState( _nWhich );
1745 :
1746 0 : if ( eItemState >= SfxItemState::DEFAULT )
1747 : {
1748 : const SvxFormatSplitItem& rSplit =
1749 0 : static_cast<const SvxFormatSplitItem&>(rSet->Get( _nWhich ));
1750 0 : m_pKeepTogetherBox->EnableTriState( false );
1751 :
1752 0 : if ( !rSplit.GetValue() )
1753 0 : m_pKeepTogetherBox->SetState( TRISTATE_TRUE );
1754 : else
1755 : {
1756 0 : m_pKeepTogetherBox->SetState( TRISTATE_FALSE );
1757 :
1758 : // widows and orphans
1759 0 : m_pWidowBox->Enable();
1760 0 : _nWhich = GetWhich( SID_ATTR_PARA_WIDOWS );
1761 0 : SfxItemState eTmpState = rSet->GetItemState( _nWhich );
1762 :
1763 0 : if ( eTmpState >= SfxItemState::DEFAULT )
1764 : {
1765 : const SvxWidowsItem& rWidow =
1766 0 : static_cast<const SvxWidowsItem&>(rSet->Get( _nWhich ));
1767 0 : m_pWidowBox->EnableTriState( false );
1768 0 : const sal_uInt16 nLines = rWidow.GetValue();
1769 :
1770 0 : bool _bEnable = nLines > 0;
1771 0 : m_pWidowRowNo->SetValue( m_pWidowRowNo->Normalize( nLines ) );
1772 0 : m_pWidowBox->SetState( _bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
1773 0 : m_pWidowRowNo->Enable(_bEnable);
1774 : //m_pWidowRowLabel->Enable(_bEnable);
1775 :
1776 : }
1777 0 : else if ( SfxItemState::DONTCARE == eTmpState )
1778 0 : m_pWidowBox->SetState( TRISTATE_INDET );
1779 : else
1780 0 : m_pWidowBox->Enable(false);
1781 :
1782 0 : m_pOrphanBox->Enable();
1783 0 : _nWhich = GetWhich( SID_ATTR_PARA_ORPHANS );
1784 0 : eTmpState = rSet->GetItemState( _nWhich );
1785 :
1786 0 : if ( eTmpState >= SfxItemState::DEFAULT )
1787 : {
1788 : const SvxOrphansItem& rOrphan =
1789 0 : static_cast<const SvxOrphansItem&>(rSet->Get( _nWhich ));
1790 0 : const sal_uInt16 nLines = rOrphan.GetValue();
1791 0 : m_pOrphanBox->EnableTriState( false );
1792 :
1793 0 : bool _bEnable = nLines > 0;
1794 0 : m_pOrphanBox->SetState( _bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
1795 0 : m_pOrphanRowNo->SetValue( m_pOrphanRowNo->Normalize( nLines ) );
1796 0 : m_pOrphanRowNo->Enable(_bEnable);
1797 0 : m_pOrphanRowLabel->Enable(_bEnable);
1798 :
1799 : }
1800 0 : else if ( SfxItemState::DONTCARE == eTmpState )
1801 0 : m_pOrphanBox->SetState( TRISTATE_INDET );
1802 : else
1803 0 : m_pOrphanBox->Enable(false);
1804 : }
1805 : }
1806 0 : else if ( SfxItemState::DONTCARE == eItemState )
1807 0 : m_pKeepTogetherBox->SetState( TRISTATE_INDET );
1808 : else
1809 0 : m_pKeepTogetherBox->Enable(false);
1810 :
1811 : // so that everything is enabled correctly
1812 0 : KeepTogetherHdl_Impl( 0 );
1813 0 : WidowHdl_Impl( 0 );
1814 0 : OrphanHdl_Impl( 0 );
1815 :
1816 0 : m_pHyphenBox->SaveValue();
1817 0 : m_pExtHyphenBeforeBox->SaveValue();
1818 0 : m_pExtHyphenAfterBox->SaveValue();
1819 0 : m_pMaxHyphenEdit->SaveValue();
1820 0 : m_pPageBreakBox->SaveValue();
1821 0 : m_pBreakPositionLB->SaveValue();
1822 0 : m_pBreakTypeLB->SaveValue();
1823 0 : m_pApplyCollBtn->SaveValue();
1824 0 : m_pApplyCollBox->SaveValue();
1825 0 : m_pPagenumEdit->SaveValue();
1826 0 : m_pKeepTogetherBox->SaveValue();
1827 0 : m_pKeepParaBox->SaveValue();
1828 0 : m_pWidowBox->SaveValue();
1829 0 : m_pOrphanBox->SaveValue();
1830 0 : }
1831 :
1832 0 : SfxTabPage::sfxpg SvxExtParagraphTabPage::DeactivatePage( SfxItemSet* _pSet )
1833 : {
1834 0 : if ( _pSet )
1835 0 : FillItemSet( _pSet );
1836 0 : return LEAVE_PAGE;
1837 : }
1838 :
1839 0 : void SvxExtParagraphTabPage::DisablePageBreak()
1840 : {
1841 0 : bPageBreak = false;
1842 0 : m_pPageBreakBox->Enable(false);
1843 0 : m_pBreakTypeLB->RemoveEntry(0);
1844 0 : m_pBreakPositionFT->Enable(false);
1845 0 : m_pBreakPositionLB->Enable(false);
1846 0 : m_pApplyCollBtn->Enable(false);
1847 0 : m_pApplyCollBox->Enable(false);
1848 0 : m_pPagenumEdit->Enable(false);
1849 0 : }
1850 :
1851 0 : SvxExtParagraphTabPage::SvxExtParagraphTabPage( vcl::Window* pParent, const SfxItemSet& rAttr ) :
1852 : SfxTabPage( pParent, "TextFlowPage","cui/ui/textflowpage.ui", &rAttr ),
1853 :
1854 : bPageBreak ( true ),
1855 : bHtmlMode ( false ),
1856 0 : nStdPos ( 0 )
1857 : {
1858 : // Hyphenation
1859 0 : get(m_pHyphenBox,"checkAuto");
1860 0 : get(m_pExtHyphenBeforeBox,"spinLineEnd");
1861 0 : get(m_pExtHyphenAfterBox,"spinLineBegin");
1862 0 : get(m_pMaxHyphenEdit,"spinMaxNum");
1863 0 : get(m_pBeforeText,"labelLineBegin");
1864 0 : get(m_pAfterText,"labelLineEnd");
1865 0 : get(m_pMaxHyphenLabel,"labelMaxNum");
1866 :
1867 : //Page break
1868 0 : get(m_pPageBreakBox,"checkInsert");
1869 0 : get(m_pBreakTypeLB,"comboBreakType");
1870 0 : get(m_pBreakPositionLB,"comboBreakPosition");
1871 0 : get(m_pApplyCollBtn,"checkPageStyle");
1872 0 : get(m_pApplyCollBox,"comboPageStyle");
1873 0 : get(m_pPagenumEdit,"spinPageNumber");
1874 0 : get(m_pBreakTypeFT,"labelType");
1875 0 : get(m_pBreakPositionFT,"labelPosition");
1876 0 : get(m_pPagenumText,"labelPageNum");
1877 :
1878 : // Options
1879 0 : get(m_pKeepTogetherBox,"checkSplitPara");
1880 0 : get(m_pKeepParaBox,"checkKeepPara");
1881 :
1882 0 : get(m_pOrphanBox,"checkOrphan");
1883 0 : get(m_pOrphanRowNo,"spinOrphan");
1884 0 : get(m_pOrphanRowLabel,"labelOrphan");
1885 :
1886 0 : get(m_pWidowBox,"checkWidow");
1887 0 : get(m_pWidowRowNo,"spinWidow");
1888 0 : get(m_pWidowRowLabel,"labelWidow");
1889 :
1890 0 : m_pApplyCollBox->SetAccessibleRelationLabeledBy(m_pApplyCollBtn);
1891 0 : m_pApplyCollBox->SetAccessibleName(CUI_RES(STR_PAGE_STYLE));
1892 :
1893 0 : m_pOrphanRowNo->SetAccessibleRelationLabeledBy(m_pOrphanBox);
1894 0 : m_pWidowRowNo->SetAccessibleRelationLabeledBy(m_pWidowBox);
1895 :
1896 : // this page needs ExchangeSupport
1897 0 : SetExchangeSupport();
1898 :
1899 0 : m_pHyphenBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, HyphenClickHdl_Impl ) );
1900 0 : m_pPageBreakBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, PageBreakHdl_Impl ) );
1901 0 : m_pKeepTogetherBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, KeepTogetherHdl_Impl ) );
1902 0 : m_pWidowBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, WidowHdl_Impl ) );
1903 0 : m_pOrphanBox->SetClickHdl( LINK( this, SvxExtParagraphTabPage, OrphanHdl_Impl ) );
1904 0 : m_pApplyCollBtn->SetClickHdl( LINK( this, SvxExtParagraphTabPage, ApplyCollClickHdl_Impl ) );
1905 0 : m_pBreakTypeLB->SetSelectHdl( LINK( this, SvxExtParagraphTabPage, PageBreakTypeHdl_Impl ) );
1906 0 : m_pBreakPositionLB->SetSelectHdl( LINK( this, SvxExtParagraphTabPage, PageBreakPosHdl_Impl ) );
1907 :
1908 0 : SfxObjectShell* pSh = SfxObjectShell::Current();
1909 0 : if ( pSh )
1910 : {
1911 0 : SfxStyleSheetBasePool* pPool = pSh->GetStyleSheetPool();
1912 0 : pPool->SetSearchMask( SFX_STYLE_FAMILY_PAGE );
1913 0 : SfxStyleSheetBase* pStyle = pPool->First();
1914 0 : OUString aStdName;
1915 :
1916 0 : while( pStyle )
1917 : {
1918 0 : if ( aStdName.isEmpty() )
1919 : // first style == standard style
1920 0 : aStdName = pStyle->GetName();
1921 0 : m_pApplyCollBox->InsertEntry( pStyle->GetName() );
1922 0 : pStyle = pPool->Next();
1923 : }
1924 0 : nStdPos = m_pApplyCollBox->GetEntryPos( aStdName );
1925 : }
1926 :
1927 0 : sal_uInt16 nHtmlMode = GetHtmlMode_Impl( rAttr );
1928 0 : if ( nHtmlMode & HTMLMODE_ON )
1929 : {
1930 0 : bHtmlMode = true;
1931 0 : m_pHyphenBox ->Enable(false);
1932 0 : m_pBeforeText ->Enable(false);
1933 0 : m_pExtHyphenBeforeBox ->Enable(false);
1934 0 : m_pAfterText ->Enable(false);
1935 0 : m_pExtHyphenAfterBox ->Enable(false);
1936 0 : m_pMaxHyphenLabel ->Enable(false);
1937 0 : m_pMaxHyphenEdit ->Enable(false);
1938 0 : m_pPagenumText ->Enable(false);
1939 0 : m_pPagenumEdit ->Enable(false);
1940 : // no column break in HTML
1941 0 : m_pBreakTypeLB->RemoveEntry(1);
1942 : }
1943 0 : }
1944 :
1945 0 : SvxExtParagraphTabPage::~SvxExtParagraphTabPage()
1946 : {
1947 0 : disposeOnce();
1948 0 : }
1949 :
1950 0 : void SvxExtParagraphTabPage::dispose()
1951 : {
1952 0 : m_pHyphenBox.clear();
1953 0 : m_pBeforeText.clear();
1954 0 : m_pExtHyphenBeforeBox.clear();
1955 0 : m_pAfterText.clear();
1956 0 : m_pExtHyphenAfterBox.clear();
1957 0 : m_pMaxHyphenLabel.clear();
1958 0 : m_pMaxHyphenEdit.clear();
1959 0 : m_pPageBreakBox.clear();
1960 0 : m_pBreakTypeFT.clear();
1961 0 : m_pBreakTypeLB.clear();
1962 0 : m_pBreakPositionFT.clear();
1963 0 : m_pBreakPositionLB.clear();
1964 0 : m_pApplyCollBtn.clear();
1965 0 : m_pApplyCollBox.clear();
1966 0 : m_pPagenumText.clear();
1967 0 : m_pPagenumEdit.clear();
1968 0 : m_pKeepTogetherBox.clear();
1969 0 : m_pKeepParaBox.clear();
1970 0 : m_pOrphanBox.clear();
1971 0 : m_pOrphanRowNo.clear();
1972 0 : m_pOrphanRowLabel.clear();
1973 0 : m_pWidowBox.clear();
1974 0 : m_pWidowRowNo.clear();
1975 0 : m_pWidowRowLabel.clear();
1976 0 : SfxTabPage::dispose();
1977 0 : }
1978 :
1979 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, PageBreakHdl_Impl)
1980 : {
1981 0 : switch ( m_pPageBreakBox->GetState() )
1982 : {
1983 : case TRISTATE_TRUE:
1984 0 : m_pBreakTypeFT->Enable();
1985 0 : m_pBreakTypeLB->Enable();
1986 0 : m_pBreakPositionFT->Enable();
1987 0 : m_pBreakPositionLB->Enable();
1988 :
1989 0 : if ( 0 == m_pBreakTypeLB->GetSelectEntryPos()&&
1990 0 : 0 == m_pBreakPositionLB->GetSelectEntryPos() )
1991 : {
1992 0 : m_pApplyCollBtn->Enable();
1993 :
1994 0 : bool bEnable = TRISTATE_TRUE == m_pApplyCollBtn->GetState() &&
1995 0 : m_pApplyCollBox->GetEntryCount();
1996 0 : m_pApplyCollBox->Enable(bEnable);
1997 0 : if(!bHtmlMode)
1998 : {
1999 0 : m_pPagenumText->Enable(bEnable);
2000 0 : m_pPagenumEdit->Enable(bEnable);
2001 : }
2002 : }
2003 0 : break;
2004 :
2005 : case TRISTATE_FALSE:
2006 : case TRISTATE_INDET:
2007 0 : m_pApplyCollBtn->SetState( TRISTATE_FALSE );
2008 0 : m_pApplyCollBtn->Enable(false);
2009 0 : m_pApplyCollBox->Enable(false);
2010 0 : m_pPagenumText->Enable(false);
2011 0 : m_pPagenumEdit->Enable(false);
2012 0 : m_pBreakTypeFT->Enable(false);
2013 0 : m_pBreakTypeLB->Enable(false);
2014 0 : m_pBreakPositionFT->Enable(false);
2015 0 : m_pBreakPositionLB->Enable(false);
2016 0 : break;
2017 : }
2018 0 : return 0;
2019 : }
2020 :
2021 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, KeepTogetherHdl_Impl)
2022 : {
2023 0 : bool bEnable = m_pKeepTogetherBox->GetState() == TRISTATE_FALSE;
2024 0 : m_pWidowBox->Enable(bEnable);
2025 0 : m_pOrphanBox->Enable(bEnable);
2026 :
2027 0 : return 0;
2028 : }
2029 :
2030 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, WidowHdl_Impl)
2031 : {
2032 0 : switch ( m_pWidowBox->GetState() )
2033 : {
2034 : case TRISTATE_TRUE:
2035 0 : m_pWidowRowNo->Enable();
2036 0 : m_pWidowRowLabel->Enable();
2037 0 : m_pKeepTogetherBox->Enable(false);
2038 0 : break;
2039 :
2040 : case TRISTATE_FALSE:
2041 0 : if ( m_pOrphanBox->GetState() == TRISTATE_FALSE )
2042 0 : m_pKeepTogetherBox->Enable();
2043 :
2044 : // no break
2045 : case TRISTATE_INDET:
2046 0 : m_pWidowRowNo->Enable(false);
2047 0 : m_pWidowRowLabel->Enable(false);
2048 0 : break;
2049 : }
2050 0 : return 0;
2051 : }
2052 :
2053 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, OrphanHdl_Impl)
2054 : {
2055 0 : switch( m_pOrphanBox->GetState() )
2056 : {
2057 : case TRISTATE_TRUE:
2058 0 : m_pOrphanRowNo->Enable();
2059 0 : m_pOrphanRowLabel->Enable();
2060 0 : m_pKeepTogetherBox->Enable(false);
2061 0 : break;
2062 :
2063 : case TRISTATE_FALSE:
2064 0 : if ( m_pWidowBox->GetState() == TRISTATE_FALSE )
2065 0 : m_pKeepTogetherBox->Enable();
2066 :
2067 : // no break
2068 : case TRISTATE_INDET:
2069 0 : m_pOrphanRowNo->Enable(false);
2070 0 : m_pOrphanRowLabel->Enable(false);
2071 0 : break;
2072 : }
2073 0 : return 0;
2074 : }
2075 :
2076 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, HyphenClickHdl_Impl)
2077 : {
2078 :
2079 0 : bool bEnable = m_pHyphenBox->GetState() == TRISTATE_TRUE;
2080 0 : m_pBeforeText->Enable(bEnable);
2081 0 : m_pExtHyphenBeforeBox->Enable(bEnable);
2082 0 : m_pAfterText->Enable(bEnable);
2083 0 : m_pExtHyphenAfterBox->Enable(bEnable);
2084 0 : m_pMaxHyphenLabel->Enable(bEnable);
2085 0 : m_pMaxHyphenEdit->Enable(bEnable);
2086 0 : m_pHyphenBox->SetState( bEnable ? TRISTATE_TRUE : TRISTATE_FALSE);
2087 :
2088 0 : return 0;
2089 : }
2090 :
2091 0 : IMPL_LINK_NOARG(SvxExtParagraphTabPage, ApplyCollClickHdl_Impl)
2092 : {
2093 0 : bool bEnable = false;
2094 0 : if ( m_pApplyCollBtn->GetState() == TRISTATE_TRUE &&
2095 0 : m_pApplyCollBox->GetEntryCount() )
2096 : {
2097 0 : bEnable = true;
2098 0 : m_pApplyCollBox->SelectEntryPos( nStdPos );
2099 : }
2100 : else
2101 : {
2102 0 : m_pApplyCollBox->SetNoSelection();
2103 : }
2104 0 : m_pApplyCollBox->Enable(bEnable);
2105 0 : if(!bHtmlMode)
2106 : {
2107 0 : m_pPagenumText->Enable(bEnable);
2108 0 : m_pPagenumEdit->Enable(bEnable);
2109 : }
2110 0 : return 0;
2111 : }
2112 :
2113 0 : IMPL_LINK( SvxExtParagraphTabPage, PageBreakPosHdl_Impl, ListBox *, pListBox )
2114 : {
2115 0 : if ( 0 == pListBox->GetSelectEntryPos() )
2116 : {
2117 0 : m_pApplyCollBtn->Enable();
2118 :
2119 0 : bool bEnable = m_pApplyCollBtn->GetState() == TRISTATE_TRUE &&
2120 0 : m_pApplyCollBox->GetEntryCount();
2121 :
2122 0 : m_pApplyCollBox->Enable(bEnable);
2123 0 : if(!bHtmlMode)
2124 : {
2125 0 : m_pPagenumText->Enable(bEnable);
2126 0 : m_pPagenumEdit->Enable(bEnable);
2127 : }
2128 : }
2129 0 : else if ( 1 == pListBox->GetSelectEntryPos() )
2130 : {
2131 0 : m_pApplyCollBtn->SetState( TRISTATE_FALSE );
2132 0 : m_pApplyCollBtn->Enable(false);
2133 0 : m_pApplyCollBox->Enable(false);
2134 0 : m_pPagenumText->Enable(false);
2135 0 : m_pPagenumEdit->Enable(false);
2136 : }
2137 0 : return 0;
2138 : }
2139 :
2140 0 : IMPL_LINK( SvxExtParagraphTabPage, PageBreakTypeHdl_Impl, ListBox *, pListBox )
2141 : {
2142 : //column break or break break after
2143 0 : sal_Int32 nBreakPos = m_pBreakPositionLB->GetSelectEntryPos();
2144 0 : if ( pListBox->GetSelectEntryPos() == 1 || 1 == nBreakPos)
2145 : {
2146 0 : m_pApplyCollBtn->SetState( TRISTATE_FALSE );
2147 0 : m_pApplyCollBtn->Enable(false);
2148 0 : m_pApplyCollBox->Enable(false);
2149 0 : m_pPagenumText->Enable(false);
2150 0 : m_pPagenumEdit->Enable(false);
2151 : }
2152 : else
2153 0 : PageBreakPosHdl_Impl( m_pBreakPositionLB );
2154 0 : return 0;
2155 : }
2156 :
2157 0 : void SvxExtParagraphTabPage::PageCreated(const SfxAllItemSet& aSet)
2158 : {
2159 0 : SFX_ITEMSET_ARG (&aSet,pDisablePageBreakItem,SfxBoolItem,SID_DISABLE_SVXEXTPARAGRAPHTABPAGE_PAGEBREAK,false);
2160 :
2161 0 : if (pDisablePageBreakItem)
2162 0 : if ( pDisablePageBreakItem->GetValue())
2163 0 : DisablePageBreak();
2164 0 : }
2165 :
2166 0 : SvxAsianTabPage::SvxAsianTabPage( vcl::Window* pParent, const SfxItemSet& rSet ) :
2167 0 : SfxTabPage(pParent, "AsianTypography","cui/ui/asiantypography.ui", &rSet)
2168 :
2169 : {
2170 0 : get(m_pForbiddenRulesCB,"checkForbidList");
2171 0 : get(m_pHangingPunctCB,"checkHangPunct");
2172 0 : get(m_pScriptSpaceCB,"checkApplySpacing");
2173 :
2174 0 : Link<> aLink = LINK( this, SvxAsianTabPage, ClickHdl_Impl );
2175 0 : m_pHangingPunctCB->SetClickHdl( aLink );
2176 0 : m_pScriptSpaceCB->SetClickHdl( aLink );
2177 0 : m_pForbiddenRulesCB->SetClickHdl( aLink );
2178 :
2179 0 : }
2180 :
2181 0 : SvxAsianTabPage::~SvxAsianTabPage()
2182 : {
2183 0 : disposeOnce();
2184 0 : }
2185 :
2186 0 : void SvxAsianTabPage::dispose()
2187 : {
2188 0 : m_pForbiddenRulesCB.clear();
2189 0 : m_pHangingPunctCB.clear();
2190 0 : m_pScriptSpaceCB.clear();
2191 0 : SfxTabPage::dispose();
2192 0 : }
2193 :
2194 0 : VclPtr<SfxTabPage> SvxAsianTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet )
2195 : {
2196 0 : return VclPtr<SvxAsianTabPage>::Create(pParent, *rSet);
2197 : }
2198 :
2199 0 : const sal_uInt16* SvxAsianTabPage::GetRanges()
2200 : {
2201 : static const sal_uInt16 pRanges[] =
2202 : {
2203 : SID_ATTR_PARA_SCRIPTSPACE, SID_ATTR_PARA_FORBIDDEN_RULES,
2204 : 0
2205 : };
2206 0 : return pRanges;
2207 : }
2208 :
2209 0 : bool SvxAsianTabPage::FillItemSet( SfxItemSet* rSet )
2210 : {
2211 0 : bool bRet = false;
2212 0 : SfxItemPool* pPool = rSet->GetPool();
2213 0 : if (m_pScriptSpaceCB->IsEnabled() && m_pScriptSpaceCB->IsValueChangedFromSaved())
2214 : {
2215 : boost::scoped_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
2216 0 : pPool->GetWhich(SID_ATTR_PARA_SCRIPTSPACE)).Clone()));
2217 0 : pNewItem->SetValue(m_pScriptSpaceCB->IsChecked());
2218 0 : rSet->Put(*pNewItem);
2219 0 : bRet = true;
2220 : }
2221 0 : if (m_pHangingPunctCB->IsEnabled() && m_pHangingPunctCB->IsValueChangedFromSaved())
2222 : {
2223 : boost::scoped_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
2224 0 : pPool->GetWhich(SID_ATTR_PARA_HANGPUNCTUATION)).Clone()));
2225 0 : pNewItem->SetValue(m_pHangingPunctCB->IsChecked());
2226 0 : rSet->Put(*pNewItem);
2227 0 : bRet = true;
2228 : }
2229 0 : if (m_pForbiddenRulesCB->IsEnabled() && m_pForbiddenRulesCB->IsValueChangedFromSaved())
2230 : {
2231 : boost::scoped_ptr<SfxBoolItem> pNewItem(static_cast<SfxBoolItem*>(rSet->Get(
2232 0 : pPool->GetWhich(SID_ATTR_PARA_FORBIDDEN_RULES)).Clone()));
2233 0 : pNewItem->SetValue(m_pForbiddenRulesCB->IsChecked());
2234 0 : rSet->Put(*pNewItem);
2235 0 : bRet = true;
2236 : }
2237 0 : return bRet;
2238 : }
2239 :
2240 0 : static void lcl_SetBox(const SfxItemSet& rSet, sal_uInt16 nSlotId, CheckBox& rBox)
2241 : {
2242 0 : sal_uInt16 _nWhich = rSet.GetPool()->GetWhich(nSlotId);
2243 0 : SfxItemState eState = rSet.GetItemState(_nWhich, true);
2244 0 : if( eState == SfxItemState::UNKNOWN || eState == SfxItemState::DISABLED )
2245 0 : rBox.Enable(false);
2246 0 : else if(eState >= SfxItemState::DEFAULT)
2247 : {
2248 0 : rBox.EnableTriState( false );
2249 0 : rBox.Check(static_cast<const SfxBoolItem&>(rSet.Get(_nWhich)).GetValue());
2250 : }
2251 : else
2252 0 : rBox.SetState( TRISTATE_INDET );
2253 0 : rBox.SaveValue();
2254 0 : }
2255 :
2256 0 : void SvxAsianTabPage::Reset( const SfxItemSet* rSet )
2257 : {
2258 0 : lcl_SetBox(*rSet, SID_ATTR_PARA_FORBIDDEN_RULES, *m_pForbiddenRulesCB );
2259 0 : lcl_SetBox(*rSet, SID_ATTR_PARA_HANGPUNCTUATION, *m_pHangingPunctCB );
2260 :
2261 : //character distance not yet available
2262 0 : lcl_SetBox(*rSet, SID_ATTR_PARA_SCRIPTSPACE, *m_pScriptSpaceCB );
2263 0 : }
2264 :
2265 0 : IMPL_STATIC_LINK( SvxAsianTabPage, ClickHdl_Impl, CheckBox*, pBox )
2266 : {
2267 0 : pBox->EnableTriState( false );
2268 0 : return 0;
2269 0 : }
2270 :
2271 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
