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