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 <optpage.hxx>
21 : #include <doc.hxx>
22 : #include <hintids.hxx>
23 : #include <cmdid.h>
24 : #include <fmtcol.hxx>
25 : #include <charatr.hxx>
26 : #include <swtypes.hxx>
27 : #include <view.hxx>
28 : #include <docsh.hxx>
29 : #include <IDocumentDeviceAccess.hxx>
30 : #include <IDocumentSettingAccess.hxx>
31 : #include <swmodule.hxx>
32 : #include <wrtsh.hxx>
33 : #include <uitool.hxx>
34 : #include <cfgitems.hxx>
35 : #include <poolfmt.hxx>
36 : #include <uiitems.hxx>
37 : #include <initui.hxx>
38 : #include <printdata.hxx>
39 : #include <modcfg.hxx>
40 : #include <srcview.hxx>
41 : #include <crstate.hxx>
42 : #include <viewopt.hxx>
43 : #include <globals.hrc>
44 : #include <config.hrc>
45 : #include <swwrtshitem.hxx>
46 : #include <unomid.h>
47 :
48 : #include <editeng/fhgtitem.hxx>
49 : #include <editeng/fontitem.hxx>
50 : #include <editeng/langitem.hxx>
51 : #include <editeng/svxenum.hxx>
52 : #include <sal/macros.h>
53 : #include <sfx2/dialoghelper.hxx>
54 : #include <sfx2/request.hxx>
55 : #include <sfx2/printer.hxx>
56 : #include <sfx2/bindings.hxx>
57 : #include <svl/slstitm.hxx>
58 : #include <svl/ctloptions.hxx>
59 : #include <svl/eitem.hxx>
60 : #include <svl/cjkoptions.hxx>
61 : #include <svtools/ctrltool.hxx>
62 : #include <sfx2/htmlmode.hxx>
63 : #include <svx/xtable.hxx>
64 : #include <svx/dlgutil.hxx>
65 : #include <svx/strarray.hxx>
66 :
67 : #include <vcl/settings.hxx>
68 : #include <vcl/builderfactory.hxx>
69 : #include <vcl/svapp.hxx>
70 :
71 : using namespace ::com::sun::star;
72 :
73 : namespace {
74 :
75 0 : void drawRect(vcl::RenderContext& rRenderContext, const Rectangle &rRect, const Color &rFillColor, const Color &rLineColor)
76 : {
77 0 : rRenderContext.SetFillColor(rFillColor);
78 0 : rRenderContext.SetLineColor(rLineColor);
79 0 : rRenderContext.DrawRect(rRect);
80 0 : }
81 :
82 : }
83 :
84 : // Tools->Options->Writer->View
85 : // Tools->Options->Writer/Web->View
86 0 : SwContentOptPage::SwContentOptPage( vcl::Window* pParent,
87 : const SfxItemSet& rCoreSet ) :
88 : SfxTabPage(pParent, "ViewOptionsPage",
89 0 : "modules/swriter/ui/viewoptionspage.ui", &rCoreSet)
90 : {
91 0 : get (m_pCrossCB, "helplines");
92 :
93 0 : get (m_pHScrollBox, "hscrollbar");
94 0 : get (m_pVScrollBox, "vscrollbar");
95 0 : get (m_pAnyRulerCB, "ruler");
96 0 : get (m_pHRulerCBox, "hruler");
97 0 : get (m_pHMetric, "hrulercombobox");
98 0 : get (m_pVRulerCBox, "vruler");
99 0 : get (m_pVRulerRightCBox, "vrulerright");
100 0 : get (m_pVMetric, "vrulercombobox");
101 0 : get (m_pSmoothCBox, "smoothscroll");
102 :
103 0 : get (m_pGrfCB, "graphics");
104 0 : get (m_pTableCB, "tables");
105 0 : get (m_pDrwCB, "drawings");
106 0 : get (m_pFieldNameCB, "fieldcodes");
107 0 : get (m_pPostItCB, "comments");
108 :
109 0 : get (m_pSettingsFrame, "settingsframe");
110 0 : get (m_pSettingsLabel, "settingslabel");
111 0 : get (m_pMetricLabel, "measureunitlabel");
112 0 : get (m_pMetricLB, "measureunit");
113 :
114 : /* This part is visible only with Writer/Web->View dialogue. */
115 : const SfxPoolItem* pItem;
116 0 : if (! (SfxItemState::SET == rCoreSet.GetItemState(SID_HTML_MODE, false, &pItem )
117 0 : && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON))
118 : {
119 0 : m_pSettingsFrame->Hide();
120 0 : m_pSettingsLabel->Hide();
121 0 : m_pMetricLabel->Hide();
122 0 : m_pMetricLB->Hide();
123 : }
124 :
125 0 : SvtCJKOptions aCJKOptions;
126 0 : if(!aCJKOptions.IsVerticalTextEnabled() )
127 0 : m_pVRulerRightCBox->Hide();
128 0 : m_pVRulerCBox->SetClickHdl(LINK(this, SwContentOptPage, VertRulerHdl ));
129 0 : m_pAnyRulerCB->SetClickHdl(LINK(this, SwContentOptPage, AnyRulerHdl));
130 :
131 0 : SvxStringArray aMetricArr( SW_RES( STR_ARR_METRIC ) );
132 0 : for ( size_t i = 0; i < aMetricArr.Count(); ++i )
133 : {
134 0 : const OUString sMetric = aMetricArr.GetStringByPos( i );
135 0 : FieldUnit eFUnit = (FieldUnit)aMetricArr.GetValue( i );
136 :
137 0 : switch ( eFUnit )
138 : {
139 : case FUNIT_MM:
140 : case FUNIT_CM:
141 : case FUNIT_POINT:
142 : case FUNIT_PICA:
143 : case FUNIT_INCH:
144 : case FUNIT_CHAR: // add two units , 'character' and 'line' , their ticks are not fixed
145 : case FUNIT_LINE:
146 : {
147 : // only use these metrics
148 : // a horizontal ruler has not the 'line' unit
149 : // there isn't 'line' unit in HTML format
150 0 : if ( eFUnit != FUNIT_LINE )
151 : {
152 0 : sal_Int32 nPos = m_pMetricLB->InsertEntry( sMetric );
153 0 : m_pMetricLB->SetEntryData( nPos, reinterpret_cast<void*>((sal_IntPtr)eFUnit) );
154 0 : m_pHMetric->InsertEntry( sMetric );
155 0 : m_pHMetric->SetEntryData( nPos, reinterpret_cast<void*>((sal_IntPtr)eFUnit) );
156 : }
157 : // a vertical ruler has not the 'character' unit
158 0 : if ( eFUnit != FUNIT_CHAR )
159 : {
160 0 : sal_Int32 nPos = m_pVMetric->InsertEntry( sMetric );
161 0 : m_pVMetric->SetEntryData( nPos, reinterpret_cast<void*>((sal_IntPtr)eFUnit) );
162 : }
163 : }
164 : default:;//prevent warning
165 : }
166 0 : }
167 0 : }
168 :
169 0 : SwContentOptPage::~SwContentOptPage()
170 : {
171 0 : disposeOnce();
172 0 : }
173 :
174 0 : void SwContentOptPage::dispose()
175 : {
176 0 : m_pCrossCB.clear();
177 0 : m_pHScrollBox.clear();
178 0 : m_pVScrollBox.clear();
179 0 : m_pAnyRulerCB.clear();
180 0 : m_pHRulerCBox.clear();
181 0 : m_pHMetric.clear();
182 0 : m_pVRulerCBox.clear();
183 0 : m_pVRulerRightCBox.clear();
184 0 : m_pVMetric.clear();
185 0 : m_pSmoothCBox.clear();
186 0 : m_pGrfCB.clear();
187 0 : m_pTableCB.clear();
188 0 : m_pDrwCB.clear();
189 0 : m_pFieldNameCB.clear();
190 0 : m_pPostItCB.clear();
191 0 : m_pSettingsFrame.clear();
192 0 : m_pSettingsLabel.clear();
193 0 : m_pMetricLabel.clear();
194 0 : m_pMetricLB.clear();
195 0 : SfxTabPage::dispose();
196 0 : }
197 :
198 :
199 0 : VclPtr<SfxTabPage> SwContentOptPage::Create( vcl::Window* pParent,
200 : const SfxItemSet* rAttrSet)
201 : {
202 0 : return VclPtr<SwContentOptPage>::Create(pParent, *rAttrSet);
203 : }
204 :
205 0 : static void lcl_SelectMetricLB(ListBox* rMetric, sal_uInt16 nSID, const SfxItemSet& rSet)
206 : {
207 : const SfxPoolItem* pItem;
208 0 : if( rSet.GetItemState( nSID, false, &pItem ) >= SfxItemState::DEFAULT )
209 : {
210 0 : FieldUnit eFieldUnit = (FieldUnit)static_cast<const SfxUInt16Item*>(pItem)->GetValue();
211 0 : for ( sal_Int32 i = 0; i < rMetric->GetEntryCount(); ++i )
212 : {
213 0 : if ( (int)reinterpret_cast<sal_IntPtr>(rMetric->GetEntryData( i )) == (int)eFieldUnit )
214 : {
215 0 : rMetric->SelectEntryPos( i );
216 0 : break;
217 : }
218 : }
219 : }
220 0 : rMetric->SaveValue();
221 0 : }
222 :
223 0 : void SwContentOptPage::Reset(const SfxItemSet* rSet)
224 : {
225 0 : const SwElemItem* pElemAttr = 0;
226 :
227 : rSet->GetItemState( FN_PARAM_ELEM , false,
228 0 : reinterpret_cast<const SfxPoolItem**>(&pElemAttr) );
229 0 : if(pElemAttr)
230 : {
231 0 : m_pTableCB->Check (pElemAttr->bTable);
232 0 : m_pGrfCB->Check (pElemAttr->bGraphic);
233 0 : m_pDrwCB->Check (pElemAttr->bDrawing);
234 0 : m_pFieldNameCB->Check (pElemAttr->bFieldName);
235 0 : m_pPostItCB->Check (pElemAttr->bNotes);
236 0 : m_pCrossCB->Check (pElemAttr->bCrosshair);
237 0 : m_pHScrollBox->Check (pElemAttr->bHorzScrollbar);
238 0 : m_pVScrollBox->Check (pElemAttr->bVertScrollbar);
239 0 : m_pAnyRulerCB->Check (pElemAttr->bAnyRuler);
240 0 : m_pHRulerCBox->Check (pElemAttr->bHorzRuler);
241 0 : m_pVRulerCBox->Check (pElemAttr->bVertRuler);
242 0 : m_pVRulerRightCBox->Check (pElemAttr->bVertRulerRight);
243 0 : m_pSmoothCBox->Check (pElemAttr->bSmoothScroll);
244 : }
245 0 : m_pMetricLB->SetNoSelection();
246 0 : lcl_SelectMetricLB(m_pMetricLB, SID_ATTR_METRIC, *rSet);
247 0 : lcl_SelectMetricLB(m_pHMetric, FN_HSCROLL_METRIC, *rSet);
248 0 : lcl_SelectMetricLB(m_pVMetric, FN_VSCROLL_METRIC, *rSet);
249 0 : AnyRulerHdl(m_pAnyRulerCB);
250 0 : }
251 :
252 0 : bool SwContentOptPage::FillItemSet(SfxItemSet* rSet)
253 : {
254 : const SwElemItem* pOldAttr = static_cast<const SwElemItem*>(
255 0 : GetOldItem(GetItemSet(), FN_PARAM_ELEM));
256 :
257 0 : SwElemItem aElem;
258 0 : if(pOldAttr)
259 0 : aElem = *pOldAttr;
260 0 : aElem.bTable = m_pTableCB->IsChecked();
261 0 : aElem.bGraphic = m_pGrfCB->IsChecked();
262 0 : aElem.bDrawing = m_pDrwCB->IsChecked();
263 0 : aElem.bFieldName = m_pFieldNameCB->IsChecked();
264 0 : aElem.bNotes = m_pPostItCB->IsChecked();
265 0 : aElem.bCrosshair = m_pCrossCB->IsChecked();
266 0 : aElem.bHorzScrollbar = m_pHScrollBox->IsChecked();
267 0 : aElem.bVertScrollbar = m_pVScrollBox->IsChecked();
268 0 : aElem.bAnyRuler = m_pAnyRulerCB->IsChecked();
269 0 : aElem.bHorzRuler = m_pHRulerCBox->IsChecked();
270 0 : aElem.bVertRuler = m_pVRulerCBox->IsChecked();
271 0 : aElem.bVertRulerRight = m_pVRulerRightCBox->IsChecked();
272 0 : aElem.bSmoothScroll = m_pSmoothCBox->IsChecked();
273 :
274 0 : bool bRet = !pOldAttr || aElem != *pOldAttr;
275 0 : if(bRet)
276 0 : bRet = 0 != rSet->Put(aElem);
277 :
278 0 : sal_Int32 nMPos = m_pMetricLB->GetSelectEntryPos();
279 0 : sal_Int32 nGlobalMetricPos = nMPos;
280 0 : if ( m_pMetricLB->IsValueChangedFromSaved() )
281 : {
282 : // Double-Cast for VA3.0
283 0 : const sal_uInt16 nFieldUnit = (sal_uInt16)reinterpret_cast<sal_IntPtr>(m_pMetricLB->GetEntryData( nMPos ));
284 0 : rSet->Put( SfxUInt16Item( SID_ATTR_METRIC, nFieldUnit ) );
285 0 : bRet = true;
286 : }
287 :
288 0 : nMPos = m_pHMetric->GetSelectEntryPos();
289 0 : if ( m_pHMetric->IsValueChangedFromSaved() || nMPos != nGlobalMetricPos )
290 : {
291 : // Double-Cast for VA3.0
292 0 : const sal_uInt16 nFieldUnit = (sal_uInt16)reinterpret_cast<sal_IntPtr>(m_pHMetric->GetEntryData( nMPos ));
293 0 : rSet->Put( SfxUInt16Item( FN_HSCROLL_METRIC, nFieldUnit ) );
294 0 : bRet = true;
295 : }
296 0 : nMPos = m_pVMetric->GetSelectEntryPos();
297 0 : if ( m_pVMetric->IsValueChangedFromSaved() || nMPos != nGlobalMetricPos )
298 : {
299 : // Double-Cast for VA3.0
300 0 : const sal_uInt16 nFieldUnit = (sal_uInt16)reinterpret_cast<sal_IntPtr>(m_pVMetric->GetEntryData( nMPos ));
301 0 : rSet->Put( SfxUInt16Item( FN_VSCROLL_METRIC, nFieldUnit ) );
302 0 : bRet = true;
303 : }
304 0 : return bRet;
305 : }
306 :
307 0 : IMPL_LINK(SwContentOptPage, VertRulerHdl, CheckBox*, pBox)
308 : {
309 0 : m_pVRulerRightCBox->Enable(pBox->IsEnabled() && pBox->IsChecked());
310 0 : return 0;
311 : }
312 :
313 0 : IMPL_LINK( SwContentOptPage, AnyRulerHdl, CheckBox*, pBox)
314 : {
315 0 : bool bChecked = pBox->IsChecked();
316 0 : m_pHRulerCBox->Enable(bChecked);
317 0 : m_pHMetric->Enable(bChecked);
318 0 : m_pVRulerCBox->Enable(bChecked);
319 0 : m_pVMetric->Enable(bChecked);
320 0 : VertRulerHdl(m_pVRulerCBox);
321 0 : return 0;
322 : }
323 :
324 : // TabPage Printer additional settings
325 0 : SwAddPrinterTabPage::SwAddPrinterTabPage(vcl::Window* pParent,
326 : const SfxItemSet& rCoreSet)
327 : : SfxTabPage(pParent, "PrintOptionsPage",
328 : "modules/swriter/ui/printoptionspage.ui", &rCoreSet)
329 : , sNone(SW_RESSTR(SW_STR_NONE))
330 : , bAttrModified(false)
331 0 : , bPreview(false)
332 : {
333 0 : get(m_pGrfCB, "graphics");
334 0 : get(m_pCtrlFieldCB, "formcontrols");
335 0 : get(m_pBackgroundCB, "background");
336 0 : get(m_pBlackFontCB, "inblack");
337 0 : get(m_pPrintHiddenTextCB, "hiddentext");
338 0 : get(m_pPrintTextPlaceholderCB, "textplaceholder");
339 :
340 0 : get(m_pPagesFrame, "pagesframe");
341 0 : get(m_pLeftPageCB, "leftpages");
342 0 : get(m_pRightPageCB, "rightpages");
343 0 : get(m_pProspectCB, "brochure");
344 0 : get(m_pProspectCB_RTL, "rtl");
345 :
346 0 : get(m_pCommentsFrame, "commentsframe");
347 0 : get(m_pNoRB, "none");
348 0 : get(m_pOnlyRB, "only");
349 0 : get(m_pEndRB, "end");
350 0 : get(m_pEndPageRB, "endpage");
351 0 : get(m_pInMarginsRB, "inmargins");
352 0 : get(m_pPrintEmptyPagesCB, "blankpages");
353 0 : get(m_pPaperFromSetupCB, "papertray");
354 0 : get(m_pFaxLB, "fax");
355 :
356 0 : Link<> aLk = LINK( this, SwAddPrinterTabPage, AutoClickHdl);
357 0 : m_pGrfCB->SetClickHdl( aLk );
358 0 : m_pRightPageCB->SetClickHdl( aLk );
359 0 : m_pLeftPageCB->SetClickHdl( aLk );
360 0 : m_pCtrlFieldCB->SetClickHdl( aLk );
361 0 : m_pBackgroundCB->SetClickHdl( aLk );
362 0 : m_pBlackFontCB->SetClickHdl( aLk );
363 0 : m_pPrintHiddenTextCB->SetClickHdl( aLk );
364 0 : m_pPrintTextPlaceholderCB->SetClickHdl( aLk );
365 0 : m_pProspectCB->SetClickHdl( aLk );
366 0 : m_pProspectCB_RTL->SetClickHdl( aLk );
367 0 : m_pPaperFromSetupCB->SetClickHdl( aLk );
368 0 : m_pPrintEmptyPagesCB->SetClickHdl( aLk );
369 0 : m_pEndPageRB->SetClickHdl( aLk );
370 0 : m_pInMarginsRB->SetClickHdl( aLk );
371 0 : m_pEndRB->SetClickHdl( aLk );
372 0 : m_pOnlyRB->SetClickHdl( aLk );
373 0 : m_pNoRB->SetClickHdl( aLk );
374 0 : m_pFaxLB->SetSelectHdl( LINK( this, SwAddPrinterTabPage, SelectHdl ) );
375 :
376 : const SfxPoolItem* pItem;
377 0 : if(SfxItemState::SET == rCoreSet.GetItemState(SID_HTML_MODE, false, &pItem )
378 0 : && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON)
379 : {
380 0 : m_pLeftPageCB->Hide();
381 0 : m_pRightPageCB->Hide();
382 0 : m_pPrintHiddenTextCB->Hide();
383 0 : m_pPrintTextPlaceholderCB->Hide();
384 :
385 : // hide m_pPrintEmptyPagesCB
386 0 : m_pPrintEmptyPagesCB->Hide();
387 : }
388 0 : m_pProspectCB_RTL->Disable();
389 0 : SvtCTLOptions aCTLOptions;
390 0 : m_pProspectCB_RTL->Show(aCTLOptions.IsCTLFontEnabled());
391 0 : }
392 :
393 0 : SwAddPrinterTabPage::~SwAddPrinterTabPage()
394 : {
395 0 : disposeOnce();
396 0 : }
397 :
398 0 : void SwAddPrinterTabPage::dispose()
399 : {
400 0 : m_pGrfCB.clear();
401 0 : m_pCtrlFieldCB.clear();
402 0 : m_pBackgroundCB.clear();
403 0 : m_pBlackFontCB.clear();
404 0 : m_pPrintHiddenTextCB.clear();
405 0 : m_pPrintTextPlaceholderCB.clear();
406 0 : m_pPagesFrame.clear();
407 0 : m_pLeftPageCB.clear();
408 0 : m_pRightPageCB.clear();
409 0 : m_pProspectCB.clear();
410 0 : m_pProspectCB_RTL.clear();
411 0 : m_pCommentsFrame.clear();
412 0 : m_pNoRB.clear();
413 0 : m_pOnlyRB.clear();
414 0 : m_pEndRB.clear();
415 0 : m_pEndPageRB.clear();
416 0 : m_pInMarginsRB.clear();
417 0 : m_pPrintEmptyPagesCB.clear();
418 0 : m_pPaperFromSetupCB.clear();
419 0 : m_pFaxLB.clear();
420 0 : SfxTabPage::dispose();
421 0 : }
422 :
423 0 : void SwAddPrinterTabPage::SetPreview(bool bPrev)
424 : {
425 0 : bPreview = bPrev;
426 0 : m_pCommentsFrame->Enable(!bPreview);
427 0 : m_pPagesFrame->Enable(!bPreview);
428 0 : }
429 :
430 0 : VclPtr<SfxTabPage> SwAddPrinterTabPage::Create( vcl::Window* pParent,
431 : const SfxItemSet* rAttrSet )
432 : {
433 0 : return VclPtr<SwAddPrinterTabPage>::Create( pParent, *rAttrSet );
434 : }
435 :
436 0 : bool SwAddPrinterTabPage::FillItemSet( SfxItemSet* rCoreSet )
437 : {
438 0 : if ( bAttrModified )
439 : {
440 0 : SwAddPrinterItem aAddPrinterAttr (FN_PARAM_ADDPRINTER);
441 0 : aAddPrinterAttr.bPrintGraphic = m_pGrfCB->IsChecked();
442 0 : aAddPrinterAttr.bPrintTable = true; // always enabled since CWS printerpullgpages /*aTabCB.IsChecked();*/
443 0 : aAddPrinterAttr.bPrintDraw = m_pGrfCB->IsChecked(); // UI merged with m_pGrfCB in CWS printerpullgpages
444 0 : aAddPrinterAttr.bPrintControl = m_pCtrlFieldCB->IsChecked();
445 0 : aAddPrinterAttr.bPrintPageBackground = m_pBackgroundCB->IsChecked();
446 0 : aAddPrinterAttr.bPrintBlackFont = m_pBlackFontCB->IsChecked();
447 0 : aAddPrinterAttr.bPrintHiddenText = m_pPrintHiddenTextCB->IsChecked();
448 0 : aAddPrinterAttr.bPrintTextPlaceholder = m_pPrintTextPlaceholderCB->IsChecked();
449 :
450 0 : aAddPrinterAttr.bPrintLeftPages = m_pLeftPageCB->IsChecked();
451 0 : aAddPrinterAttr.bPrintRightPages = m_pRightPageCB->IsChecked();
452 0 : aAddPrinterAttr.bPrintReverse = false; // handled by vcl itself since CWS printerpullpages /*aReverseCB.IsChecked()*/;
453 0 : aAddPrinterAttr.bPrintProspect = m_pProspectCB->IsChecked();
454 0 : aAddPrinterAttr.bPrintProspectRTL = m_pProspectCB_RTL->IsChecked();
455 0 : aAddPrinterAttr.bPaperFromSetup = m_pPaperFromSetupCB->IsChecked();
456 0 : aAddPrinterAttr.bPrintEmptyPages = m_pPrintEmptyPagesCB->IsChecked();
457 0 : aAddPrinterAttr.bPrintSingleJobs = true; // handled by vcl in new print dialog since CWS printerpullpages /*aSingleJobsCB.IsChecked()*/;
458 :
459 0 : if (m_pNoRB->IsChecked()) aAddPrinterAttr.nPrintPostIts =
460 0 : POSTITS_NONE;
461 0 : if (m_pOnlyRB->IsChecked()) aAddPrinterAttr.nPrintPostIts =
462 0 : POSTITS_ONLY;
463 0 : if (m_pEndRB->IsChecked()) aAddPrinterAttr.nPrintPostIts =
464 0 : POSTITS_ENDDOC;
465 0 : if (m_pEndPageRB->IsChecked()) aAddPrinterAttr.nPrintPostIts =
466 0 : POSTITS_ENDPAGE;
467 0 : if (m_pInMarginsRB->IsChecked()) aAddPrinterAttr.nPrintPostIts =
468 0 : POSTITS_INMARGINS;
469 :
470 0 : const OUString sFax = m_pFaxLB->GetSelectEntry();
471 0 : aAddPrinterAttr.sFaxName = sNone == sFax ? aEmptyOUStr : sFax;
472 0 : rCoreSet->Put(aAddPrinterAttr);
473 : }
474 0 : return bAttrModified;
475 : }
476 :
477 0 : void SwAddPrinterTabPage::Reset( const SfxItemSet* )
478 : {
479 0 : const SfxItemSet& rSet = GetItemSet();
480 0 : const SwAddPrinterItem* pAddPrinterAttr = 0;
481 :
482 0 : if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_ADDPRINTER , false,
483 0 : reinterpret_cast<const SfxPoolItem**>(&pAddPrinterAttr) ))
484 : {
485 0 : m_pGrfCB->Check(pAddPrinterAttr->bPrintGraphic || pAddPrinterAttr->bPrintDraw);
486 0 : m_pCtrlFieldCB->Check( pAddPrinterAttr->bPrintControl);
487 0 : m_pBackgroundCB->Check( pAddPrinterAttr->bPrintPageBackground);
488 0 : m_pBlackFontCB->Check( pAddPrinterAttr->bPrintBlackFont);
489 0 : m_pPrintHiddenTextCB->Check( pAddPrinterAttr->bPrintHiddenText);
490 0 : m_pPrintTextPlaceholderCB->Check(pAddPrinterAttr->bPrintTextPlaceholder);
491 0 : m_pLeftPageCB->Check( pAddPrinterAttr->bPrintLeftPages);
492 0 : m_pRightPageCB->Check( pAddPrinterAttr->bPrintRightPages);
493 0 : m_pPaperFromSetupCB->Check(pAddPrinterAttr->bPaperFromSetup);
494 0 : m_pPrintEmptyPagesCB->Check(pAddPrinterAttr->bPrintEmptyPages);
495 0 : m_pProspectCB->Check( pAddPrinterAttr->bPrintProspect);
496 0 : m_pProspectCB_RTL->Check( pAddPrinterAttr->bPrintProspectRTL);
497 :
498 0 : m_pNoRB->Check (pAddPrinterAttr->nPrintPostIts== POSTITS_NONE ) ;
499 0 : m_pOnlyRB->Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ONLY ) ;
500 0 : m_pEndRB->Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ENDDOC ) ;
501 0 : m_pEndPageRB->Check (pAddPrinterAttr->nPrintPostIts== POSTITS_ENDPAGE ) ;
502 0 : m_pInMarginsRB->Check (pAddPrinterAttr->nPrintPostIts== POSTITS_INMARGINS ) ;
503 0 : m_pFaxLB->SelectEntry( pAddPrinterAttr->sFaxName );
504 : }
505 0 : if (m_pProspectCB->IsChecked())
506 : {
507 0 : m_pProspectCB_RTL->Enable(true);
508 0 : m_pNoRB->Enable( false );
509 0 : m_pOnlyRB->Enable( false );
510 0 : m_pEndRB->Enable( false );
511 0 : m_pEndPageRB->Enable( false );
512 : }
513 : else
514 0 : m_pProspectCB_RTL->Enable( false );
515 0 : }
516 :
517 0 : IMPL_LINK_NOARG(SwAddPrinterTabPage, AutoClickHdl)
518 : {
519 0 : bAttrModified = true;
520 0 : bool bIsProspect = m_pProspectCB->IsChecked();
521 0 : if (!bIsProspect)
522 0 : m_pProspectCB_RTL->Check( false );
523 0 : m_pProspectCB_RTL->Enable( bIsProspect );
524 0 : m_pNoRB->Enable( !bIsProspect );
525 0 : m_pOnlyRB->Enable( !bIsProspect );
526 0 : m_pEndRB->Enable( !bIsProspect );
527 0 : m_pEndPageRB->Enable( !bIsProspect );
528 0 : m_pInMarginsRB->Enable( !bIsProspect );
529 0 : return 0;
530 : }
531 :
532 0 : void SwAddPrinterTabPage::SetFax( const std::vector<OUString>& rFaxLst )
533 : {
534 0 : m_pFaxLB->InsertEntry(sNone);
535 0 : for(size_t i = 0; i < rFaxLst.size(); ++i)
536 : {
537 0 : m_pFaxLB->InsertEntry(rFaxLst[i]);
538 : }
539 0 : m_pFaxLB->SelectEntryPos(0);
540 0 : }
541 :
542 0 : IMPL_LINK_NOARG(SwAddPrinterTabPage, SelectHdl)
543 : {
544 0 : bAttrModified=true;
545 0 : return 0;
546 : }
547 :
548 0 : void SwAddPrinterTabPage::PageCreated( const SfxAllItemSet& aSet)
549 : {
550 0 : SFX_ITEMSET_ARG (&aSet,pListItem,SfxBoolItem,SID_FAX_LIST,false);
551 0 : SFX_ITEMSET_ARG (&aSet,pPreviewItem,SfxBoolItem,SID_PREVIEWFLAG_TYPE,false);
552 0 : if (pPreviewItem)
553 : {
554 0 : SetPreview(pPreviewItem->GetValue());
555 0 : Reset(&aSet);
556 : }
557 0 : if (pListItem && pListItem->GetValue())
558 : {
559 0 : std::vector<OUString> aFaxList;
560 0 : const std::vector<OUString>& rPrinters = Printer::GetPrinterQueues();
561 0 : for (size_t i = 0; i < rPrinters.size(); ++i)
562 0 : aFaxList.insert(aFaxList.begin(), rPrinters[i]);
563 0 : SetFax( aFaxList );
564 : }
565 0 : }
566 :
567 : // Tabpage Standardfonts
568 0 : SwStdFontTabPage::SwStdFontTabPage( vcl::Window* pParent,
569 : const SfxItemSet& rSet ) :
570 : SfxTabPage( pParent, "OptFontTabPage" , "modules/swriter/ui/optfonttabpage.ui" , &rSet),
571 : pPrt(0),
572 : pFontList(0),
573 : pFontConfig(0),
574 : pWrtShell(0),
575 0 : eLanguage( GetAppLanguage() ),
576 :
577 : bListDefault(false),
578 : bSetListDefault(true),
579 : bLabelDefault(false),
580 : bSetLabelDefault(true),
581 : bIdxDefault(false),
582 : bSetIdxDefault(true),
583 : bDeletePrinter(false),
584 :
585 : bListHeightDefault (false),
586 : bSetListHeightDefault (false),
587 : bLabelHeightDefault (false),
588 : bSetLabelHeightDefault(false),
589 : bIndexHeightDefault (false),
590 : bSetIndexHeightDefault (false),
591 :
592 : nFontGroup(FONT_GROUP_DEFAULT),
593 :
594 : sScriptWestern(SW_RES(ST_SCRIPT_WESTERN)),
595 : sScriptAsian(SW_RES(ST_SCRIPT_ASIAN)),
596 0 : sScriptComplex(SW_RES(ST_SCRIPT_CTL))
597 : {
598 0 : get(pLabelFT,"label1");
599 0 : get(pStandardBox,"standardbox");
600 0 : pStandardBox->SetStyle(pStandardBox->GetStyle() | WB_SORT);
601 0 : get(pStandardHeightLB,"standardheight");
602 0 : get(pTitleBox,"titlebox");
603 0 : pTitleBox->SetStyle(pTitleBox->GetStyle() | WB_SORT);
604 0 : get(pTitleHeightLB,"titleheight");
605 0 : get(pListBox,"listbox");
606 0 : pListBox->SetStyle(pListBox->GetStyle() | WB_SORT);
607 0 : get(pListHeightLB,"listheight");
608 0 : get(pLabelBox,"labelbox");
609 0 : pLabelBox->SetStyle(pLabelBox->GetStyle() | WB_SORT);
610 0 : get(pLabelHeightLB,"labelheight");
611 0 : get(pIdxBox,"idxbox");
612 0 : pIdxBox->SetStyle(pIdxBox->GetStyle() | WB_SORT);
613 0 : get(pIndexHeightLB,"indexheight");
614 :
615 0 : get(pDocOnlyCB,"doconly");
616 0 : get(pStandardPB,"standard");
617 :
618 0 : pStandardPB->SetClickHdl(LINK(this, SwStdFontTabPage, StandardHdl));
619 0 : pStandardBox->SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
620 0 : pListBox ->SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
621 0 : pLabelBox ->SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
622 0 : pIdxBox ->SetModifyHdl( LINK(this, SwStdFontTabPage, ModifyHdl));
623 0 : Link<> aFocusLink = LINK( this, SwStdFontTabPage, LoseFocusHdl);
624 0 : pStandardBox->SetLoseFocusHdl( aFocusLink );
625 0 : pTitleBox ->SetLoseFocusHdl( aFocusLink );
626 0 : pListBox ->SetLoseFocusHdl( aFocusLink );
627 0 : pLabelBox ->SetLoseFocusHdl( aFocusLink );
628 0 : pIdxBox ->SetLoseFocusHdl( aFocusLink );
629 :
630 0 : Link<> aModifyHeightLink( LINK( this, SwStdFontTabPage, ModifyHeightHdl));
631 0 : pStandardHeightLB->SetModifyHdl( aModifyHeightLink );
632 0 : pTitleHeightLB-> SetModifyHdl( aModifyHeightLink );
633 0 : pListHeightLB-> SetModifyHdl( aModifyHeightLink );
634 0 : pLabelHeightLB-> SetModifyHdl( aModifyHeightLink );
635 0 : pIndexHeightLB-> SetModifyHdl( aModifyHeightLink );
636 :
637 0 : pDocOnlyCB->Check(SW_MOD()->GetModuleConfig()->IsDefaultFontInCurrDocOnly());
638 0 : }
639 :
640 0 : SwStdFontTabPage::~SwStdFontTabPage()
641 : {
642 0 : disposeOnce();
643 0 : }
644 :
645 0 : void SwStdFontTabPage::dispose()
646 : {
647 0 : delete pFontList;
648 0 : if (bDeletePrinter)
649 0 : pPrt.disposeAndClear();
650 0 : pLabelFT.clear();
651 0 : pStandardBox.clear();
652 0 : pStandardHeightLB.clear();
653 0 : pTitleBox.clear();
654 0 : pTitleHeightLB.clear();
655 0 : pListBox.clear();
656 0 : pListHeightLB.clear();
657 0 : pLabelBox.clear();
658 0 : pLabelHeightLB.clear();
659 0 : pIdxBox.clear();
660 0 : pIndexHeightLB.clear();
661 0 : pDocOnlyCB.clear();
662 0 : pStandardPB.clear();
663 0 : SfxTabPage::dispose();
664 0 : }
665 :
666 0 : VclPtr<SfxTabPage> SwStdFontTabPage::Create( vcl::Window* pParent,
667 : const SfxItemSet* rAttrSet )
668 : {
669 0 : return VclPtr<SwStdFontTabPage>::Create(pParent, *rAttrSet);
670 : }
671 :
672 0 : static void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
673 : SfxPrinter* pPrt, const OUString& rStyle,
674 : sal_uInt16 nFontWhich)
675 : {
676 0 : vcl::Font aFont( rStyle, Size( 0, 10 ) );
677 0 : if( pPrt )
678 0 : aFont = pPrt->GetFontMetric( aFont );
679 0 : SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(nType);
680 0 : pColl->SetFormatAttr(SvxFontItem(aFont.GetFamily(), aFont.GetName(),
681 0 : aEmptyOUStr, aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
682 0 : }
683 :
684 0 : static void lcl_SetColl(SwWrtShell* pWrtShell, sal_uInt16 nType,
685 : sal_Int32 nHeight, sal_uInt16 nFontHeightWhich)
686 : {
687 0 : float fSize = (float)nHeight / 10;
688 0 : nHeight = CalcToUnit( fSize, SFX_MAPUNIT_TWIP );
689 0 : SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(nType);
690 0 : pColl->SetFormatAttr(SvxFontHeightItem(nHeight, 100, nFontHeightWhich));
691 0 : }
692 :
693 0 : bool SwStdFontTabPage::FillItemSet( SfxItemSet* )
694 : {
695 0 : bool bNotDocOnly = !pDocOnlyCB->IsChecked();
696 0 : SW_MOD()->GetModuleConfig()->SetDefaultFontInCurrDocOnly(!bNotDocOnly);
697 :
698 0 : const OUString sStandard = pStandardBox->GetText();
699 0 : const OUString sTitle = pTitleBox->GetText();
700 0 : const OUString sList = pListBox->GetText();
701 0 : const OUString sLabel = pLabelBox->GetText();
702 0 : const OUString sIdx = pIdxBox->GetText();
703 :
704 0 : bool bStandardHeightChanged = pStandardHeightLB->IsValueChangedFromSaved();
705 0 : bool bTitleHeightChanged = pTitleHeightLB->IsValueChangedFromSaved();
706 0 : bool bListHeightChanged = pListHeightLB->IsValueChangedFromSaved() && (!bListHeightDefault || !bSetListHeightDefault );
707 0 : bool bLabelHeightChanged = pLabelHeightLB->IsValueChangedFromSaved() && (!bLabelHeightDefault || !bSetLabelHeightDefault );
708 0 : bool bIndexHeightChanged = pIndexHeightLB->IsValueChangedFromSaved() && (!bIndexHeightDefault || !bSetIndexHeightDefault );
709 0 : if(bNotDocOnly)
710 : {
711 0 : pFontConfig->SetFontStandard(sStandard, nFontGroup);
712 0 : pFontConfig->SetFontOutline(sTitle, nFontGroup);
713 0 : pFontConfig->SetFontList(sList, nFontGroup);
714 0 : pFontConfig->SetFontCaption(sLabel, nFontGroup);
715 0 : pFontConfig->SetFontIndex(sIdx, nFontGroup);
716 0 : if(bStandardHeightChanged)
717 : {
718 0 : float fSize = (float)pStandardHeightLB->GetValue() / 10;
719 0 : pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_STANDARD, nFontGroup );
720 : }
721 0 : if(bTitleHeightChanged)
722 : {
723 0 : float fSize = (float)pTitleHeightLB->GetValue() / 10;
724 0 : pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_OUTLINE, nFontGroup );
725 : }
726 0 : if(bListHeightChanged)
727 : {
728 0 : float fSize = (float)pListHeightLB->GetValue() / 10;
729 0 : pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_LIST, nFontGroup );
730 : }
731 0 : if(bLabelHeightChanged)
732 : {
733 0 : float fSize = (float)pLabelHeightLB->GetValue() / 10;
734 0 : pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_CAPTION, nFontGroup );
735 : }
736 0 : if(bIndexHeightChanged)
737 : {
738 0 : float fSize = (float)pIndexHeightLB->GetValue() / 10;
739 0 : pFontConfig->SetFontHeight( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), FONT_INDEX, nFontGroup );
740 : }
741 : }
742 0 : if(pWrtShell)
743 : {
744 0 : pWrtShell->StartAllAction();
745 0 : SfxPrinter* pPrinter = pWrtShell->getIDocumentDeviceAccess()->getPrinter( false );
746 0 : bool bMod = false;
747 : const sal_uInt16 nFontWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
748 0 : nFontGroup == FONT_GROUP_DEFAULT ? RES_CHRATR_FONT :
749 0 : FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT);
750 : const sal_uInt16 nFontHeightWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
751 0 : nFontGroup == FONT_GROUP_DEFAULT ? RES_CHRATR_FONTSIZE :
752 0 : FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE);
753 0 : if(sStandard != sShellStd)
754 : {
755 0 : vcl::Font aFont( sStandard, Size( 0, 10 ) );
756 0 : if( pPrinter )
757 0 : aFont = pPrinter->GetFontMetric( aFont );
758 0 : pWrtShell->SetDefault(SvxFontItem(aFont.GetFamily(), aFont.GetName(),
759 0 : aEmptyOUStr, aFont.GetPitch(), aFont.GetCharSet(), nFontWhich));
760 0 : SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
761 0 : pColl->ResetFormatAttr(nFontWhich);
762 0 : bMod = true;
763 : }
764 0 : if(bStandardHeightChanged)
765 : {
766 0 : float fSize = (float)pStandardHeightLB->GetValue() / 10;
767 0 : pWrtShell->SetDefault(SvxFontHeightItem( CalcToUnit( fSize, SFX_MAPUNIT_TWIP ), 100, nFontHeightWhich ) );
768 0 : SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
769 0 : pColl->ResetFormatAttr(nFontHeightWhich);
770 0 : bMod = true;
771 : }
772 :
773 0 : if(sTitle != sShellTitle )
774 : {
775 0 : lcl_SetColl(pWrtShell, RES_POOLCOLL_HEADLINE_BASE, pPrinter, sTitle, nFontWhich);
776 0 : bMod = true;
777 : }
778 0 : if(bTitleHeightChanged)
779 : {
780 : lcl_SetColl(pWrtShell, RES_POOLCOLL_HEADLINE_BASE,
781 0 : sal::static_int_cast< sal_uInt16, sal_Int64 >(pTitleHeightLB->GetValue()), nFontHeightWhich);
782 0 : bMod = true;
783 : }
784 0 : if(sList != sShellList && (!bListDefault || !bSetListDefault ))
785 : {
786 0 : lcl_SetColl(pWrtShell, RES_POOLCOLL_NUMBUL_BASE, pPrinter, sList, nFontWhich);
787 0 : bMod = true;
788 : }
789 0 : if(bListHeightChanged)
790 : {
791 : lcl_SetColl(pWrtShell, RES_POOLCOLL_NUMBUL_BASE,
792 0 : sal::static_int_cast< sal_uInt16, sal_Int64 >(pListHeightLB->GetValue()), nFontHeightWhich);
793 0 : bMod = true;
794 : }
795 0 : if(sLabel != sShellLabel && (!bLabelDefault || !bSetLabelDefault))
796 : {
797 0 : lcl_SetColl(pWrtShell, RES_POOLCOLL_LABEL, pPrinter, sLabel, nFontWhich);
798 0 : bMod = true;
799 : }
800 0 : if(bLabelHeightChanged)
801 : {
802 : lcl_SetColl(pWrtShell, RES_POOLCOLL_LABEL,
803 0 : sal::static_int_cast< sal_uInt16, sal_Int64 >(pLabelHeightLB->GetValue()), nFontHeightWhich);
804 0 : bMod = true;
805 : }
806 0 : if(sIdx != sShellIndex && (!bIdxDefault || !bSetIdxDefault))
807 : {
808 0 : lcl_SetColl(pWrtShell, RES_POOLCOLL_REGISTER_BASE, pPrinter, sIdx, nFontWhich);
809 0 : bMod = true;
810 : }
811 0 : if(bIndexHeightChanged)
812 : {
813 : lcl_SetColl(pWrtShell, RES_POOLCOLL_REGISTER_BASE,
814 0 : sal::static_int_cast< sal_uInt16, sal_Int64 >(pIndexHeightLB->GetValue()), nFontHeightWhich);
815 0 : bMod = true;
816 : }
817 0 : if ( bMod )
818 0 : pWrtShell->SetModified();
819 0 : pWrtShell->EndAllAction();
820 : }
821 0 : return false;
822 : }
823 :
824 0 : void SwStdFontTabPage::Reset( const SfxItemSet* rSet)
825 : {
826 : const SfxPoolItem* pLang;
827 0 : const sal_uInt16 nLangSlot = nFontGroup == FONT_GROUP_DEFAULT ? SID_ATTR_LANGUAGE :
828 0 : FONT_GROUP_CJK == nFontGroup ? SID_ATTR_CHAR_CJK_LANGUAGE : SID_ATTR_CHAR_CTL_LANGUAGE;
829 :
830 0 : if( SfxItemState::SET == rSet->GetItemState(nLangSlot, false, &pLang))
831 0 : eLanguage = static_cast<const SvxLanguageItem*>(pLang)->GetValue();
832 :
833 0 : OUString sToReplace = sScriptWestern;
834 0 : if(FONT_GROUP_CJK == nFontGroup )
835 0 : sToReplace = sScriptAsian;
836 0 : else if(FONT_GROUP_CTL == nFontGroup )
837 0 : sToReplace = sScriptComplex;
838 0 : pLabelFT->SetText(pLabelFT->GetText().replaceFirst("%1", sToReplace));
839 :
840 : const SfxPoolItem* pItem;
841 :
842 0 : if (bDeletePrinter)
843 : {
844 0 : pPrt.disposeAndClear();
845 : }
846 :
847 0 : if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_PRINTER, false, &pItem))
848 : {
849 0 : pPrt = static_cast<SfxPrinter*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
850 : }
851 : else
852 : {
853 : SfxItemSet* pPrinterSet = new SfxItemSet( *rSet->GetPool(),
854 : SID_PRINTER_NOTFOUND_WARN, SID_PRINTER_NOTFOUND_WARN,
855 : SID_PRINTER_CHANGESTODOC, SID_PRINTER_CHANGESTODOC,
856 0 : 0 );
857 0 : pPrt = VclPtr<SfxPrinter>::Create(pPrinterSet);
858 : }
859 0 : delete pFontList;
860 0 : pFontList = new FontList( pPrt );
861 : // #i94536# prevent duplication of font entries when 'reset' button is pressed
862 0 : if( !pStandardBox->GetEntryCount() )
863 : {
864 : // get the set of disctinct available family names
865 0 : std::set< OUString > aFontNames;
866 0 : int nFontNames = pPrt->GetDevFontCount();
867 0 : for( int i = 0; i < nFontNames; i++ )
868 : {
869 0 : vcl::FontInfo aInf( pPrt->GetDevFont( i ) );
870 0 : aFontNames.insert( aInf.GetName() );
871 0 : }
872 :
873 : // insert to listboxes
874 0 : for( std::set< OUString >::const_iterator it = aFontNames.begin();
875 0 : it != aFontNames.end(); ++it )
876 : {
877 0 : pStandardBox->InsertEntry( *it );
878 0 : pTitleBox->InsertEntry( *it );
879 0 : pListBox->InsertEntry( *it );
880 0 : pLabelBox->InsertEntry( *it );
881 0 : pIdxBox->InsertEntry( *it );
882 0 : }
883 : }
884 0 : if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_STDFONTS, false, &pItem))
885 : {
886 0 : pFontConfig = static_cast<SwStdFontConfig*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
887 : }
888 :
889 0 : if(SfxItemState::SET == rSet->GetItemState(FN_PARAM_WRTSHELL, false, &pItem))
890 : {
891 0 : pWrtShell = static_cast<SwWrtShell*>(static_cast<const SwPtrItem*>(pItem)->GetValue());
892 : }
893 0 : OUString sStdBackup;
894 0 : OUString sOutBackup;
895 0 : OUString sListBackup;
896 0 : OUString sCapBackup;
897 0 : OUString sIdxBackup;
898 0 : sal_Int32 nStandardHeight = -1;
899 0 : sal_Int32 nTitleHeight = -1;
900 0 : sal_Int32 nListHeight = -1;
901 0 : sal_Int32 nLabelHeight = -1;
902 0 : sal_Int32 nIndexHeight = -1;
903 :
904 0 : if(!pWrtShell)
905 : {
906 0 : sStdBackup = pFontConfig->GetFontStandard(nFontGroup);
907 0 : sOutBackup = pFontConfig->GetFontOutline(nFontGroup);
908 0 : sListBackup= pFontConfig->GetFontList(nFontGroup);
909 0 : sCapBackup = pFontConfig->GetFontCaption(nFontGroup);
910 0 : sIdxBackup = pFontConfig->GetFontIndex(nFontGroup);
911 0 : nStandardHeight = pFontConfig->GetFontHeight( FONT_STANDARD, nFontGroup, eLanguage );
912 0 : nTitleHeight = pFontConfig->GetFontHeight( FONT_OUTLINE , nFontGroup, eLanguage );
913 0 : nListHeight = pFontConfig->GetFontHeight( FONT_LIST , nFontGroup, eLanguage );
914 0 : nLabelHeight = pFontConfig->GetFontHeight( FONT_CAPTION , nFontGroup, eLanguage );
915 0 : nIndexHeight = pFontConfig->GetFontHeight( FONT_INDEX , nFontGroup, eLanguage );
916 0 : if( nStandardHeight <= 0)
917 0 : nStandardHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_STANDARD + nFontGroup * FONT_PER_GROUP, eLanguage);
918 0 : if( nTitleHeight <= 0)
919 0 : nTitleHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_OUTLINE + nFontGroup * FONT_PER_GROUP, eLanguage);
920 0 : if( nListHeight <= 0)
921 0 : nListHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_LIST + nFontGroup * FONT_PER_GROUP, eLanguage);
922 0 : if( nLabelHeight <= 0)
923 0 : nLabelHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_CAPTION + nFontGroup * FONT_PER_GROUP, eLanguage);
924 0 : if( nIndexHeight <= 0)
925 0 : nIndexHeight = SwStdFontConfig::GetDefaultHeightFor( FONT_INDEX + nFontGroup * FONT_PER_GROUP, eLanguage);
926 :
927 0 : pDocOnlyCB->Enable(false);
928 : }
929 : else
930 : {
931 0 : SwTextFormatColl *pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_STANDARD);
932 0 : const SvxFontItem& rFont = !nFontGroup ? pColl->GetFont() :
933 0 : FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
934 0 : sShellStd = sStdBackup = rFont.GetFamilyName();
935 :
936 : const sal_uInt16 nFontHeightWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
937 0 : nFontGroup == FONT_GROUP_DEFAULT ? RES_CHRATR_FONTSIZE :
938 0 : FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONTSIZE : RES_CHRATR_CTL_FONTSIZE );
939 0 : const SvxFontHeightItem& rFontHeightStandard = static_cast<const SvxFontHeightItem& >(pColl->GetFormatAttr(nFontHeightWhich));
940 0 : nStandardHeight = (sal_Int32)rFontHeightStandard.GetHeight();
941 :
942 0 : pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_HEADLINE_BASE);
943 0 : const SvxFontItem& rFontHL = !nFontGroup ? pColl->GetFont() :
944 0 : FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
945 0 : sShellTitle = sOutBackup = rFontHL.GetFamilyName();
946 :
947 0 : const SvxFontHeightItem& rFontHeightTitle = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr( nFontHeightWhich, true ));
948 0 : nTitleHeight = (sal_Int32)rFontHeightTitle.GetHeight();
949 :
950 : const sal_uInt16 nFontWhich = sal::static_int_cast< sal_uInt16, RES_CHRATR >(
951 0 : nFontGroup == FONT_GROUP_DEFAULT ? RES_CHRATR_FONT :
952 0 : FONT_GROUP_CJK == nFontGroup ? RES_CHRATR_CJK_FONT : RES_CHRATR_CTL_FONT);
953 0 : pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_NUMBUL_BASE);
954 0 : const SvxFontItem& rFontLS = !nFontGroup ? pColl->GetFont() :
955 0 : FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
956 0 : bListDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
957 0 : sShellList = sListBackup = rFontLS.GetFamilyName();
958 :
959 0 : const SvxFontHeightItem& rFontHeightList = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich, true));
960 0 : nListHeight = (sal_Int32)rFontHeightList.GetHeight();
961 0 : bListHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
962 :
963 0 : pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_LABEL);
964 0 : bLabelDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
965 0 : const SvxFontItem& rFontCP = !nFontGroup ? pColl->GetFont() :
966 0 : FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
967 0 : sShellLabel = sCapBackup = rFontCP.GetFamilyName();
968 0 : const SvxFontHeightItem& rFontHeightLabel = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich, true));
969 0 : nLabelHeight = (sal_Int32)rFontHeightLabel.GetHeight();
970 0 : bLabelHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
971 :
972 0 : pColl = pWrtShell->GetTextCollFromPool(RES_POOLCOLL_REGISTER_BASE);
973 0 : bIdxDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
974 0 : const SvxFontItem& rFontIDX = !nFontGroup ? pColl->GetFont() :
975 0 : FONT_GROUP_CJK == nFontGroup ? pColl->GetCJKFont() : pColl->GetCTLFont();
976 0 : sShellIndex = sIdxBackup = rFontIDX.GetFamilyName();
977 0 : const SvxFontHeightItem& rFontHeightIndex = static_cast<const SvxFontHeightItem&>(pColl->GetFormatAttr(nFontHeightWhich, true));
978 0 : nIndexHeight = (sal_Int32)rFontHeightIndex.GetHeight();
979 0 : bIndexHeightDefault = SfxItemState::DEFAULT == pColl->GetAttrSet().GetItemState(nFontWhich, false);
980 : }
981 0 : pStandardBox->SetText(sStdBackup );
982 0 : pTitleBox->SetText(sOutBackup );
983 0 : pListBox->SetText(sListBackup);
984 0 : pLabelBox->SetText(sCapBackup );
985 0 : pIdxBox->SetText(sIdxBackup );
986 :
987 0 : vcl::FontInfo aFontInfo( pFontList->Get(sStdBackup, sStdBackup) );
988 0 : pStandardHeightLB->Fill( &aFontInfo, pFontList );
989 0 : aFontInfo = pFontList->Get(sOutBackup, sOutBackup );
990 0 : pTitleHeightLB->Fill( &aFontInfo, pFontList );
991 0 : aFontInfo = pFontList->Get(sListBackup,sListBackup);
992 0 : pListHeightLB->Fill( &aFontInfo, pFontList );
993 0 : aFontInfo = pFontList->Get(sCapBackup, sCapBackup );
994 0 : pLabelHeightLB->Fill( &aFontInfo, pFontList );
995 0 : aFontInfo = pFontList->Get(sIdxBackup, sIdxBackup );
996 0 : pIndexHeightLB->Fill( &aFontInfo, pFontList );
997 :
998 0 : pStandardHeightLB->SetValue( CalcToPoint( nStandardHeight, SFX_MAPUNIT_TWIP, 10 ) );
999 0 : pTitleHeightLB-> SetValue( CalcToPoint( nTitleHeight , SFX_MAPUNIT_TWIP, 10 ) );
1000 0 : pListHeightLB-> SetValue( CalcToPoint( nListHeight , SFX_MAPUNIT_TWIP, 10 ) );
1001 0 : pLabelHeightLB-> SetValue( CalcToPoint( nLabelHeight , SFX_MAPUNIT_TWIP, 10 ));
1002 0 : pIndexHeightLB-> SetValue( CalcToPoint( nIndexHeight , SFX_MAPUNIT_TWIP, 10 ));
1003 :
1004 0 : pStandardBox->SaveValue();
1005 0 : pTitleBox->SaveValue();
1006 0 : pListBox->SaveValue();
1007 0 : pLabelBox->SaveValue();
1008 0 : pIdxBox->SaveValue();
1009 :
1010 0 : pStandardHeightLB->SaveValue();
1011 0 : pTitleHeightLB->SaveValue();
1012 0 : pListHeightLB->SaveValue();
1013 0 : pLabelHeightLB->SaveValue();
1014 0 : pIndexHeightLB->SaveValue();
1015 0 : }
1016 :
1017 0 : IMPL_LINK_NOARG(SwStdFontTabPage, StandardHdl)
1018 : {
1019 0 : sal_uInt8 nFontOffset = nFontGroup * FONT_PER_GROUP;
1020 0 : pStandardBox->SetText(SwStdFontConfig::GetDefaultFor(FONT_STANDARD + nFontOffset, eLanguage));
1021 0 : pTitleBox ->SetText(SwStdFontConfig::GetDefaultFor(FONT_OUTLINE + nFontOffset, eLanguage));
1022 0 : pListBox ->SetText(SwStdFontConfig::GetDefaultFor(FONT_LIST + nFontOffset, eLanguage));
1023 0 : pLabelBox ->SetText(SwStdFontConfig::GetDefaultFor(FONT_CAPTION + nFontOffset, eLanguage));
1024 0 : pIdxBox ->SetText(SwStdFontConfig::GetDefaultFor(FONT_INDEX + nFontOffset, eLanguage));
1025 :
1026 0 : pStandardBox->SaveValue();
1027 0 : pTitleBox->SaveValue();
1028 0 : pListBox->SaveValue();
1029 0 : pLabelBox->SaveValue();
1030 0 : pIdxBox->SaveValue();
1031 :
1032 0 : pStandardHeightLB->SetValue( CalcToPoint(
1033 0 : SwStdFontConfig::GetDefaultHeightFor(FONT_STANDARD + nFontOffset, eLanguage),
1034 0 : SFX_MAPUNIT_TWIP, 10 ) );
1035 0 : pTitleHeightLB ->SetValue(CalcToPoint(
1036 : SwStdFontConfig::GetDefaultHeightFor(FONT_OUTLINE +
1037 0 : nFontOffset, eLanguage), SFX_MAPUNIT_TWIP, 10 ));
1038 0 : pListHeightLB ->SetValue(CalcToPoint(
1039 0 : SwStdFontConfig::GetDefaultHeightFor(FONT_LIST + nFontOffset, eLanguage),
1040 0 : SFX_MAPUNIT_TWIP, 10 ));
1041 0 : pLabelHeightLB ->SetValue(CalcToPoint(
1042 0 : SwStdFontConfig::GetDefaultHeightFor(FONT_CAPTION + nFontOffset, eLanguage),
1043 0 : SFX_MAPUNIT_TWIP, 10 ));
1044 0 : pIndexHeightLB ->SetValue(CalcToPoint(
1045 0 : SwStdFontConfig::GetDefaultHeightFor(FONT_INDEX + nFontOffset, eLanguage),
1046 0 : SFX_MAPUNIT_TWIP, 10 ));
1047 0 : return 0;
1048 : }
1049 :
1050 0 : IMPL_LINK( SwStdFontTabPage, ModifyHdl, ComboBox*, pBox )
1051 : {
1052 0 : if(pBox == pStandardBox)
1053 : {
1054 0 : const OUString sEntry = pBox->GetText();
1055 0 : if(bSetListDefault && bListDefault)
1056 0 : pListBox->SetText(sEntry);
1057 0 : if(bSetLabelDefault && bLabelDefault)
1058 0 : pLabelBox->SetText(sEntry);
1059 0 : if(bSetIdxDefault && bIdxDefault)
1060 0 : pIdxBox->SetText(sEntry);
1061 : }
1062 0 : else if(pBox == pListBox)
1063 : {
1064 0 : bSetListDefault = false;
1065 : }
1066 0 : else if(pBox == pLabelBox)
1067 : {
1068 0 : bSetLabelDefault = false;
1069 : }
1070 0 : else if(pBox == pIdxBox)
1071 : {
1072 0 : bSetIdxDefault = false;
1073 : }
1074 0 : return 0;
1075 : }
1076 :
1077 0 : IMPL_LINK( SwStdFontTabPage, ModifyHeightHdl, FontSizeBox*, pBox )
1078 : {
1079 0 : if(pBox == pStandardHeightLB)
1080 : {
1081 0 : sal_Int64 nValue = pBox->GetValue(FUNIT_TWIP);
1082 0 : if(bSetListHeightDefault && bListHeightDefault)
1083 0 : pListHeightLB->SetValue(nValue, FUNIT_TWIP);
1084 0 : if(bSetLabelHeightDefault && bLabelHeightDefault)
1085 0 : pLabelHeightLB->SetValue(nValue, FUNIT_TWIP);
1086 0 : if(bSetIndexHeightDefault && bIndexHeightDefault)
1087 0 : pIndexHeightLB->SetValue(nValue, FUNIT_TWIP);
1088 : }
1089 0 : else if(pBox == pListHeightLB)
1090 : {
1091 0 : bSetListHeightDefault = false;
1092 : }
1093 0 : else if(pBox == pLabelHeightLB)
1094 : {
1095 0 : bSetLabelHeightDefault = false;
1096 : }
1097 0 : else if(pBox == pIndexHeightLB)
1098 : {
1099 0 : bSetIndexHeightDefault = false;
1100 : }
1101 0 : return 0;
1102 : }
1103 :
1104 0 : IMPL_LINK( SwStdFontTabPage, LoseFocusHdl, ComboBox*, pBox )
1105 : {
1106 0 : FontSizeBox* pHeightLB = 0;
1107 0 : const OUString sEntry = pBox->GetText();
1108 0 : if(pBox == pStandardBox)
1109 : {
1110 0 : pHeightLB = pStandardHeightLB;
1111 : }
1112 0 : else if(pBox == pTitleBox)
1113 : {
1114 0 : pHeightLB = pTitleHeightLB;
1115 : }
1116 0 : else if(pBox == pListBox)
1117 : {
1118 0 : pHeightLB = pListHeightLB;
1119 : }
1120 0 : else if(pBox == pLabelBox)
1121 : {
1122 0 : pHeightLB = pLabelHeightLB;
1123 : }
1124 : else /*if(pBox == pIdxBox)*/
1125 : {
1126 0 : pHeightLB = pIndexHeightLB;
1127 : }
1128 0 : vcl::FontInfo aFontInfo( pFontList->Get(sEntry, sEntry) );
1129 0 : pHeightLB->Fill( &aFontInfo, pFontList );
1130 0 : return 0;
1131 : }
1132 :
1133 0 : void SwStdFontTabPage::PageCreated( const SfxAllItemSet& aSet)
1134 : {
1135 0 : SFX_ITEMSET_ARG (&aSet,pFlagItem,SfxUInt16Item, SID_FONTMODE_TYPE, false);
1136 0 : if (pFlagItem)
1137 0 : SetFontMode(sal::static_int_cast< sal_uInt8, sal_uInt16>( pFlagItem->GetValue()));
1138 0 : }
1139 :
1140 0 : SwTableOptionsTabPage::SwTableOptionsTabPage( vcl::Window* pParent, const SfxItemSet& rSet ) :
1141 : SfxTabPage(pParent, "OptTablePage", "modules/swriter/ui/opttablepage.ui", &rSet),
1142 : pWrtShell(0),
1143 0 : bHTMLMode(false)
1144 : {
1145 0 : get(pHeaderCB,"header");
1146 0 : get(pRepeatHeaderCB,"repeatheader");
1147 0 : get(pDontSplitCB,"dontsplit");
1148 0 : get(pBorderCB,"border");
1149 0 : get(pNumFormattingCB,"numformatting");
1150 0 : get(pNumFormatFormattingCB,"numfmtformatting");
1151 0 : get(pNumAlignmentCB,"numalignment");
1152 0 : get(pRowMoveMF,"rowmove");
1153 0 : get(pColMoveMF,"colmove");
1154 0 : get(pRowInsertMF,"rowinsert");
1155 0 : get(pColInsertMF,"colinsert");
1156 0 : get(pFixRB,"fix");
1157 0 : get(pFixPropRB,"fixprop");
1158 0 : get(pVarRB,"var");
1159 :
1160 0 : Link<> aLnk(LINK(this, SwTableOptionsTabPage, CheckBoxHdl));
1161 0 : pNumFormattingCB->SetClickHdl(aLnk);
1162 0 : pNumFormatFormattingCB->SetClickHdl(aLnk);
1163 0 : pHeaderCB->SetClickHdl(aLnk);
1164 0 : }
1165 :
1166 0 : SwTableOptionsTabPage::~SwTableOptionsTabPage()
1167 : {
1168 0 : disposeOnce();
1169 0 : }
1170 :
1171 0 : void SwTableOptionsTabPage::dispose()
1172 : {
1173 0 : pHeaderCB.clear();
1174 0 : pRepeatHeaderCB.clear();
1175 0 : pDontSplitCB.clear();
1176 0 : pBorderCB.clear();
1177 0 : pNumFormattingCB.clear();
1178 0 : pNumFormatFormattingCB.clear();
1179 0 : pNumAlignmentCB.clear();
1180 0 : pRowMoveMF.clear();
1181 0 : pColMoveMF.clear();
1182 0 : pRowInsertMF.clear();
1183 0 : pColInsertMF.clear();
1184 0 : pFixRB.clear();
1185 0 : pFixPropRB.clear();
1186 0 : pVarRB.clear();
1187 0 : SfxTabPage::dispose();
1188 0 : }
1189 :
1190 0 : VclPtr<SfxTabPage> SwTableOptionsTabPage::Create( vcl::Window* pParent,
1191 : const SfxItemSet* rAttrSet )
1192 : {
1193 0 : return VclPtr<SwTableOptionsTabPage>::Create(pParent, *rAttrSet);
1194 : }
1195 :
1196 0 : bool SwTableOptionsTabPage::FillItemSet( SfxItemSet* )
1197 : {
1198 0 : bool bRet = false;
1199 0 : SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
1200 :
1201 0 : if(pRowMoveMF->IsModified())
1202 0 : pModOpt->SetTableHMove( (sal_uInt16)pRowMoveMF->Denormalize( pRowMoveMF->GetValue(FUNIT_TWIP)));
1203 :
1204 0 : if(pColMoveMF->IsModified())
1205 0 : pModOpt->SetTableVMove( (sal_uInt16)pColMoveMF->Denormalize( pColMoveMF->GetValue(FUNIT_TWIP)));
1206 :
1207 0 : if(pRowInsertMF->IsModified())
1208 0 : pModOpt->SetTableHInsert((sal_uInt16)pRowInsertMF->Denormalize( pRowInsertMF->GetValue(FUNIT_TWIP)));
1209 :
1210 0 : if(pColInsertMF->IsModified())
1211 0 : pModOpt->SetTableVInsert((sal_uInt16)pColInsertMF->Denormalize( pColInsertMF->GetValue(FUNIT_TWIP)));
1212 :
1213 : TableChgMode eMode;
1214 0 : if(pFixRB->IsChecked())
1215 0 : eMode = TBLFIX_CHGABS;
1216 0 : else if(pFixPropRB->IsChecked())
1217 0 : eMode = TBLFIX_CHGPROP;
1218 : else
1219 0 : eMode = TBLVAR_CHGABS;
1220 0 : if(eMode != pModOpt->GetTableMode())
1221 : {
1222 0 : pModOpt->SetTableMode(eMode);
1223 : // the table-keyboard-mode has changed, now the current
1224 : // table should know about that too.
1225 0 : if(pWrtShell && nsSelectionType::SEL_TBL & pWrtShell->GetSelectionType())
1226 : {
1227 0 : pWrtShell->SetTableChgMode(eMode);
1228 : static sal_uInt16 aInva[] =
1229 : { FN_TABLE_MODE_FIX,
1230 : FN_TABLE_MODE_FIX_PROP,
1231 : FN_TABLE_MODE_VARIABLE,
1232 : 0
1233 : };
1234 0 : pWrtShell->GetView().GetViewFrame()->GetBindings().Invalidate( aInva );
1235 : }
1236 :
1237 0 : bRet = true;
1238 : }
1239 :
1240 0 : SwInsertTableOptions aInsOpts( 0, 0 );
1241 :
1242 0 : if (pHeaderCB->IsChecked())
1243 0 : aInsOpts.mnInsMode |= tabopts::HEADLINE;
1244 :
1245 0 : if (pRepeatHeaderCB->IsEnabled() )
1246 0 : aInsOpts.mnRowsToRepeat = pRepeatHeaderCB->IsChecked()? 1 : 0;
1247 :
1248 0 : if (!pDontSplitCB->IsChecked())
1249 0 : aInsOpts.mnInsMode |= tabopts::SPLIT_LAYOUT;
1250 :
1251 0 : if (pBorderCB->IsChecked())
1252 0 : aInsOpts.mnInsMode |= tabopts::DEFAULT_BORDER;
1253 :
1254 0 : if (pHeaderCB->IsValueChangedFromSaved() ||
1255 0 : pRepeatHeaderCB->IsValueChangedFromSaved() ||
1256 0 : pDontSplitCB->IsValueChangedFromSaved() ||
1257 0 : pBorderCB->IsValueChangedFromSaved())
1258 : {
1259 0 : pModOpt->SetInsTableFlags(bHTMLMode, aInsOpts);
1260 : }
1261 :
1262 0 : if (pNumFormattingCB->IsValueChangedFromSaved())
1263 : {
1264 0 : pModOpt->SetInsTableFormatNum(bHTMLMode, pNumFormattingCB->IsChecked());
1265 0 : bRet = true;
1266 : }
1267 :
1268 0 : if (pNumFormatFormattingCB->IsValueChangedFromSaved())
1269 : {
1270 0 : pModOpt->SetInsTableChangeNumFormat(bHTMLMode, pNumFormatFormattingCB->IsChecked());
1271 0 : bRet = true;
1272 : }
1273 :
1274 0 : if (pNumAlignmentCB->IsValueChangedFromSaved())
1275 : {
1276 0 : pModOpt->SetInsTableAlignNum(bHTMLMode, pNumAlignmentCB->IsChecked());
1277 0 : bRet = true;
1278 : }
1279 :
1280 0 : return bRet;
1281 : }
1282 :
1283 0 : void SwTableOptionsTabPage::Reset( const SfxItemSet* rSet)
1284 : {
1285 0 : const SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
1286 0 : if ( rSet->GetItemState( SID_ATTR_METRIC ) >= SfxItemState::DEFAULT )
1287 : {
1288 0 : const SfxUInt16Item& rItem = static_cast<const SfxUInt16Item&>(rSet->Get( SID_ATTR_METRIC ));
1289 0 : FieldUnit eFieldUnit = (FieldUnit)rItem.GetValue();
1290 0 : ::SetFieldUnit( *pRowMoveMF, eFieldUnit );
1291 0 : ::SetFieldUnit( *pColMoveMF, eFieldUnit );
1292 0 : ::SetFieldUnit( *pRowInsertMF, eFieldUnit );
1293 0 : ::SetFieldUnit( *pColInsertMF, eFieldUnit );
1294 : }
1295 :
1296 0 : pRowMoveMF->SetValue(pRowMoveMF->Normalize(pModOpt->GetTableHMove()), FUNIT_TWIP);
1297 0 : pColMoveMF->SetValue(pColMoveMF->Normalize(pModOpt->GetTableVMove()), FUNIT_TWIP);
1298 0 : pRowInsertMF->SetValue(pRowInsertMF->Normalize(pModOpt->GetTableHInsert()), FUNIT_TWIP);
1299 0 : pColInsertMF->SetValue(pColInsertMF->Normalize(pModOpt->GetTableVInsert()), FUNIT_TWIP);
1300 :
1301 0 : switch(pModOpt->GetTableMode())
1302 : {
1303 0 : case TBLFIX_CHGABS: pFixRB->Check(); break;
1304 0 : case TBLFIX_CHGPROP: pFixPropRB->Check(); break;
1305 0 : case TBLVAR_CHGABS: pVarRB->Check(); break;
1306 : }
1307 : const SfxPoolItem* pItem;
1308 0 : if(SfxItemState::SET == rSet->GetItemState(SID_HTML_MODE, false, &pItem))
1309 : {
1310 0 : bHTMLMode = 0 != (static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON);
1311 : }
1312 :
1313 : // hide certain controls for html
1314 0 : if(bHTMLMode)
1315 : {
1316 0 : pRepeatHeaderCB->Hide();
1317 0 : pDontSplitCB->Hide();
1318 : }
1319 :
1320 0 : SwInsertTableOptions aInsOpts = pModOpt->GetInsTableFlags(bHTMLMode);
1321 0 : const sal_uInt16 nInsTableFlags = aInsOpts.mnInsMode;
1322 :
1323 0 : pHeaderCB->Check(0 != (nInsTableFlags & tabopts::HEADLINE));
1324 0 : pRepeatHeaderCB->Check((!bHTMLMode) && (aInsOpts.mnRowsToRepeat > 0));
1325 0 : pDontSplitCB->Check(!(nInsTableFlags & tabopts::SPLIT_LAYOUT));
1326 0 : pBorderCB->Check(0 != (nInsTableFlags & tabopts::DEFAULT_BORDER));
1327 :
1328 0 : pNumFormattingCB->Check(pModOpt->IsInsTableFormatNum(bHTMLMode));
1329 0 : pNumFormatFormattingCB->Check(pModOpt->IsInsTableChangeNumFormat(bHTMLMode));
1330 0 : pNumAlignmentCB->Check(pModOpt->IsInsTableAlignNum(bHTMLMode));
1331 :
1332 0 : pHeaderCB->SaveValue();
1333 0 : pRepeatHeaderCB->SaveValue();
1334 0 : pDontSplitCB->SaveValue();
1335 0 : pBorderCB->SaveValue();
1336 0 : pNumFormattingCB->SaveValue();
1337 0 : pNumFormatFormattingCB->SaveValue();
1338 0 : pNumAlignmentCB->SaveValue();
1339 :
1340 0 : CheckBoxHdl(0);
1341 0 : }
1342 :
1343 0 : IMPL_LINK_NOARG(SwTableOptionsTabPage, CheckBoxHdl)
1344 : {
1345 0 : pNumFormatFormattingCB->Enable(pNumFormattingCB->IsChecked());
1346 0 : pNumAlignmentCB->Enable(pNumFormattingCB->IsChecked());
1347 0 : pRepeatHeaderCB->Enable(pHeaderCB->IsChecked());
1348 0 : return 0;
1349 : }
1350 :
1351 0 : void SwTableOptionsTabPage::PageCreated( const SfxAllItemSet& aSet)
1352 : {
1353 0 : SFX_ITEMSET_ARG (&aSet,pWrtSh,SwWrtShellItem,SID_WRT_SHELL,false);
1354 0 : if (pWrtSh)
1355 0 : SetWrtShell(pWrtSh->GetValue());
1356 0 : }
1357 :
1358 0 : SwShdwCrsrOptionsTabPage::SwShdwCrsrOptionsTabPage( vcl::Window* pParent,
1359 : const SfxItemSet& rSet )
1360 : : SfxTabPage(pParent, "OptFormatAidsPage",
1361 : "modules/swriter/ui/optformataidspage.ui", &rSet),
1362 0 : m_pWrtShell( NULL )
1363 : {
1364 0 : get(m_pParaCB, "paragraph");
1365 0 : get(m_pSHyphCB, "hyphens");
1366 0 : get(m_pSpacesCB, "spaces");
1367 0 : get(m_pHSpacesCB, "nonbreak");
1368 0 : get(m_pTabCB, "tabs");
1369 0 : get(m_pBreakCB, "break");
1370 0 : get(m_pCharHiddenCB, "hiddentext");
1371 0 : get(m_pFieldHiddenCB, "hiddentextfield");
1372 0 : get(m_pFieldHiddenParaCB, "hiddenparafield");
1373 :
1374 0 : get(m_pDirectCursorFrame, "directcrsrframe");
1375 0 : get(m_pOnOffCB, "cursoronoff");
1376 :
1377 0 : get(m_pFillMarginRB, "fillmargin");
1378 0 : get(m_pFillIndentRB, "fillindent");
1379 0 : get(m_pFillTabRB, "filltab");
1380 0 : get(m_pFillSpaceRB, "fillspace");
1381 :
1382 0 : get(m_pCursorProtFrame, "crsrprotframe");
1383 0 : get(m_pCrsrInProtCB, "cursorinprot");
1384 0 : get(m_pIgnoreProtCB, "ignoreprot");
1385 :
1386 0 : get(m_pMathBaselineAlignmentCB, "mathbaseline");
1387 :
1388 0 : const SfxPoolItem* pItem = 0;
1389 :
1390 0 : SwShadowCursorItem aOpt;
1391 0 : if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_SHADOWCURSOR, false, &pItem ))
1392 0 : aOpt = *static_cast<const SwShadowCursorItem*>(pItem);
1393 0 : m_pOnOffCB->Check( aOpt.IsOn() );
1394 :
1395 0 : sal_uInt8 eMode = aOpt.GetMode();
1396 0 : m_pFillIndentRB->Check( FILL_INDENT == eMode );
1397 0 : m_pFillMarginRB->Check( FILL_MARGIN == eMode );
1398 0 : m_pFillTabRB->Check( FILL_TAB == eMode );
1399 0 : m_pFillSpaceRB->Check( FILL_SPACE == eMode );
1400 :
1401 0 : if(SfxItemState::SET == rSet.GetItemState(SID_HTML_MODE, false, &pItem )
1402 0 : && static_cast<const SfxUInt16Item*>(pItem)->GetValue() & HTMLMODE_ON)
1403 : {
1404 0 : m_pTabCB->Hide();
1405 0 : m_pCharHiddenCB->Hide();
1406 0 : m_pFieldHiddenCB->Hide();
1407 0 : m_pFieldHiddenParaCB->Hide();
1408 :
1409 0 : m_pDirectCursorFrame->Hide();
1410 0 : m_pOnOffCB->Hide();
1411 0 : m_pFillMarginRB->Hide();
1412 0 : m_pFillIndentRB->Hide();
1413 0 : m_pFillTabRB->Hide();
1414 0 : m_pFillSpaceRB->Hide();
1415 :
1416 0 : m_pCursorProtFrame->Hide();
1417 0 : m_pCrsrInProtCB->Hide();
1418 0 : m_pIgnoreProtCB->Hide();
1419 0 : }
1420 0 : }
1421 :
1422 0 : SwShdwCrsrOptionsTabPage::~SwShdwCrsrOptionsTabPage()
1423 : {
1424 0 : disposeOnce();
1425 0 : }
1426 :
1427 0 : void SwShdwCrsrOptionsTabPage::dispose()
1428 : {
1429 0 : m_pParaCB.clear();
1430 0 : m_pSHyphCB.clear();
1431 0 : m_pSpacesCB.clear();
1432 0 : m_pHSpacesCB.clear();
1433 0 : m_pTabCB.clear();
1434 0 : m_pBreakCB.clear();
1435 0 : m_pCharHiddenCB.clear();
1436 0 : m_pFieldHiddenCB.clear();
1437 0 : m_pFieldHiddenParaCB.clear();
1438 0 : m_pDirectCursorFrame.clear();
1439 0 : m_pOnOffCB.clear();
1440 0 : m_pFillMarginRB.clear();
1441 0 : m_pFillIndentRB.clear();
1442 0 : m_pFillTabRB.clear();
1443 0 : m_pFillSpaceRB.clear();
1444 0 : m_pCursorProtFrame.clear();
1445 0 : m_pCrsrInProtCB.clear();
1446 0 : m_pIgnoreProtCB.clear();
1447 0 : m_pMathBaselineAlignmentCB.clear();
1448 0 : SfxTabPage::dispose();
1449 0 : }
1450 :
1451 0 : VclPtr<SfxTabPage> SwShdwCrsrOptionsTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet )
1452 : {
1453 0 : return VclPtr<SwShdwCrsrOptionsTabPage>::Create( pParent, *rSet );
1454 : }
1455 :
1456 0 : void SwShdwCrsrOptionsTabPage::PageCreated( const SfxAllItemSet& aSet )
1457 : {
1458 0 : SFX_ITEMSET_ARG (&aSet,pWrtSh,SwWrtShellItem,SID_WRT_SHELL,false);
1459 0 : if (pWrtSh)
1460 0 : SetWrtShell(pWrtSh->GetValue());
1461 0 : }
1462 :
1463 0 : bool SwShdwCrsrOptionsTabPage::FillItemSet( SfxItemSet* rSet )
1464 : {
1465 0 : SwShadowCursorItem aOpt;
1466 0 : aOpt.SetOn( m_pOnOffCB->IsChecked() );
1467 :
1468 : sal_uInt8 eMode;
1469 0 : if( m_pFillIndentRB->IsChecked() )
1470 0 : eMode= FILL_INDENT;
1471 0 : else if( m_pFillMarginRB->IsChecked() )
1472 0 : eMode = FILL_MARGIN;
1473 0 : else if( m_pFillTabRB->IsChecked() )
1474 0 : eMode = FILL_TAB;
1475 : else
1476 0 : eMode = FILL_SPACE;
1477 0 : aOpt.SetMode( eMode );
1478 :
1479 0 : bool bRet = false;
1480 0 : const SfxPoolItem* pItem = 0;
1481 0 : if( SfxItemState::SET != rSet->GetItemState( FN_PARAM_SHADOWCURSOR, false, &pItem )
1482 0 : || static_cast<const SwShadowCursorItem&>(*pItem) != aOpt )
1483 : {
1484 0 : rSet->Put( aOpt );
1485 0 : bRet = true;
1486 : }
1487 :
1488 0 : if (m_pWrtShell) {
1489 0 : m_pWrtShell->GetDoc()->getIDocumentSettingAccess().set( DocumentSettingId::MATH_BASELINE_ALIGNMENT,
1490 0 : m_pMathBaselineAlignmentCB->IsChecked() );
1491 0 : bRet |= m_pMathBaselineAlignmentCB->IsValueChangedFromSaved();
1492 : }
1493 :
1494 0 : if( m_pCrsrInProtCB->IsValueChangedFromSaved())
1495 : {
1496 0 : rSet->Put(SfxBoolItem(FN_PARAM_CRSR_IN_PROTECTED, m_pCrsrInProtCB->IsChecked()));
1497 0 : bRet = true;
1498 : }
1499 :
1500 0 : if (m_pIgnoreProtCB->IsValueChangedFromSaved())
1501 : {
1502 0 : rSet->Put(SfxBoolItem(FN_PARAM_IGNORE_PROTECTED, m_pIgnoreProtCB->IsChecked()));
1503 0 : bRet = true;
1504 : }
1505 :
1506 : const SwDocDisplayItem* pOldAttr = static_cast<const SwDocDisplayItem*>(
1507 0 : GetOldItem(GetItemSet(), FN_PARAM_DOCDISP));
1508 :
1509 0 : SwDocDisplayItem aDisp;
1510 0 : if(pOldAttr)
1511 0 : aDisp = *pOldAttr;
1512 :
1513 0 : aDisp.bParagraphEnd = m_pParaCB->IsChecked();
1514 0 : aDisp.bTab = m_pTabCB->IsChecked();
1515 0 : aDisp.bSpace = m_pSpacesCB->IsChecked();
1516 0 : aDisp.bNonbreakingSpace = m_pHSpacesCB->IsChecked();
1517 0 : aDisp.bSoftHyphen = m_pSHyphCB->IsChecked();
1518 0 : aDisp.bFieldHiddenText = m_pFieldHiddenCB->IsChecked();
1519 0 : aDisp.bCharHiddenText = m_pCharHiddenCB->IsChecked();
1520 0 : aDisp.bShowHiddenPara = m_pFieldHiddenParaCB->IsChecked();
1521 0 : aDisp.bManualBreak = m_pBreakCB->IsChecked();
1522 :
1523 0 : bRet |= (!pOldAttr || aDisp != *pOldAttr);
1524 0 : if(bRet)
1525 0 : bRet = 0 != rSet->Put(aDisp);
1526 :
1527 0 : return bRet;
1528 : }
1529 :
1530 0 : void SwShdwCrsrOptionsTabPage::Reset( const SfxItemSet* rSet )
1531 : {
1532 0 : const SfxPoolItem* pItem = 0;
1533 :
1534 0 : SwShadowCursorItem aOpt;
1535 0 : if( SfxItemState::SET == rSet->GetItemState( FN_PARAM_SHADOWCURSOR, false, &pItem ))
1536 0 : aOpt = *static_cast<const SwShadowCursorItem*>(pItem);
1537 0 : m_pOnOffCB->Check( aOpt.IsOn() );
1538 :
1539 0 : sal_uInt8 eMode = aOpt.GetMode();
1540 0 : m_pFillIndentRB->Check( FILL_INDENT == eMode );
1541 0 : m_pFillMarginRB->Check( FILL_MARGIN == eMode );
1542 0 : m_pFillTabRB->Check( FILL_TAB == eMode );
1543 0 : m_pFillSpaceRB->Check( FILL_SPACE == eMode );
1544 :
1545 0 : if (m_pWrtShell) {
1546 0 : m_pMathBaselineAlignmentCB->Check( m_pWrtShell->GetDoc()->getIDocumentSettingAccess().get( DocumentSettingId::MATH_BASELINE_ALIGNMENT ) );
1547 0 : m_pMathBaselineAlignmentCB->SaveValue();
1548 : } else {
1549 0 : m_pMathBaselineAlignmentCB->Hide();
1550 : }
1551 :
1552 0 : if( SfxItemState::SET == rSet->GetItemState( FN_PARAM_CRSR_IN_PROTECTED, false, &pItem ))
1553 0 : m_pCrsrInProtCB->Check(static_cast<const SfxBoolItem*>(pItem)->GetValue());
1554 0 : m_pCrsrInProtCB->SaveValue();
1555 :
1556 0 : if (rSet->GetItemState(FN_PARAM_IGNORE_PROTECTED, false, &pItem) == SfxItemState::SET)
1557 0 : m_pIgnoreProtCB->Check(static_cast<const SfxBoolItem*>(pItem)->GetValue());
1558 0 : m_pIgnoreProtCB->SaveValue();
1559 :
1560 0 : const SwDocDisplayItem* pDocDisplayAttr = 0;
1561 :
1562 : rSet->GetItemState( FN_PARAM_DOCDISP, false,
1563 0 : reinterpret_cast<const SfxPoolItem**>(&pDocDisplayAttr) );
1564 0 : if(pDocDisplayAttr)
1565 : {
1566 0 : m_pParaCB->Check ( pDocDisplayAttr->bParagraphEnd );
1567 0 : m_pTabCB->Check ( pDocDisplayAttr->bTab );
1568 0 : m_pSpacesCB->Check ( pDocDisplayAttr->bSpace );
1569 0 : m_pHSpacesCB->Check ( pDocDisplayAttr->bNonbreakingSpace );
1570 0 : m_pSHyphCB->Check ( pDocDisplayAttr->bSoftHyphen );
1571 0 : m_pCharHiddenCB->Check ( pDocDisplayAttr->bCharHiddenText );
1572 0 : m_pFieldHiddenCB->Check ( pDocDisplayAttr->bFieldHiddenText );
1573 0 : m_pFieldHiddenParaCB->Check ( pDocDisplayAttr->bShowHiddenPara );
1574 0 : m_pBreakCB->Check ( pDocDisplayAttr->bManualBreak );
1575 0 : }
1576 0 : }
1577 :
1578 : // TabPage for Redlining
1579 : struct CharAttr
1580 : {
1581 : sal_uInt16 nItemId;
1582 : sal_uInt16 nAttr;
1583 : };
1584 :
1585 : // Edit corresponds to Paste-attributes
1586 : static CharAttr aRedlineAttr[] =
1587 : {
1588 : { SID_ATTR_CHAR_CASEMAP, SVX_CASEMAP_NOT_MAPPED },
1589 : { SID_ATTR_CHAR_WEIGHT, WEIGHT_BOLD },
1590 : { SID_ATTR_CHAR_POSTURE, ITALIC_NORMAL },
1591 : { SID_ATTR_CHAR_UNDERLINE, UNDERLINE_SINGLE },
1592 : { SID_ATTR_CHAR_UNDERLINE, UNDERLINE_DOUBLE },
1593 : { SID_ATTR_CHAR_STRIKEOUT, STRIKEOUT_SINGLE },
1594 : { SID_ATTR_CHAR_CASEMAP, SVX_CASEMAP_VERSALIEN },
1595 : { SID_ATTR_CHAR_CASEMAP, SVX_CASEMAP_GEMEINE },
1596 : { SID_ATTR_CHAR_CASEMAP, SVX_CASEMAP_KAPITAELCHEN },
1597 : { SID_ATTR_CHAR_CASEMAP, SVX_CASEMAP_TITEL },
1598 : { SID_ATTR_BRUSH, 0 }
1599 : };
1600 : // Items from aRedlineAttr relevant for InsertAttr: strikethrough is
1601 : // not used
1602 : static sal_uInt16 aInsertAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };
1603 :
1604 : // Items from aRedlineAttr relevant for DeleteAttr: underline and
1605 : // double underline is not used
1606 : static sal_uInt16 aDeletedAttrMap[] = { 0, 1, 2, 5, 6, 7, 8, 9, 10 };
1607 :
1608 : // Items from aRedlineAttr relevant for ChangeAttr: strikethrough is
1609 : // not used
1610 : static sal_uInt16 aChangedAttrMap[] = { 0, 1, 2, 3, 4, 6, 7, 8, 9, 10 };
1611 :
1612 : // Preview of selection
1613 0 : SwMarkPreview::SwMarkPreview( vcl::Window *pParent, WinBits nWinBits ) :
1614 :
1615 : Window(pParent, nWinBits),
1616 : m_aTransCol( COL_TRANSPARENT ),
1617 : m_aMarkCol( COL_LIGHTRED ),
1618 0 : nMarkPos(0)
1619 :
1620 : {
1621 0 : m_aInitialSize = getPreviewOptionsSize(this);
1622 0 : InitColors();
1623 0 : SetMapMode(MAP_PIXEL);
1624 0 : }
1625 :
1626 0 : VCL_BUILDER_FACTORY_ARGS(SwMarkPreview, 0)
1627 :
1628 0 : SwMarkPreview::~SwMarkPreview()
1629 : {
1630 0 : }
1631 :
1632 0 : void SwMarkPreview::InitColors()
1633 : {
1634 : // m_aTransCol and m_aMarkCol are _not_ changed because they are set from outside!
1635 :
1636 0 : const StyleSettings& rSettings = GetSettings().GetStyleSettings();
1637 0 : m_aBgCol = Color( rSettings.GetWindowColor() );
1638 :
1639 0 : bool bHC = rSettings.GetHighContrastMode();
1640 0 : m_aLineCol = bHC? SwViewOption::GetFontColor() : Color( COL_BLACK );
1641 0 : m_aShadowCol = bHC? m_aBgCol : rSettings.GetShadowColor();
1642 0 : m_aTextCol = bHC? SwViewOption::GetFontColor() : Color( COL_GRAY );
1643 0 : m_aPrintAreaCol = m_aTextCol;
1644 0 : }
1645 :
1646 0 : void SwMarkPreview::DataChanged( const DataChangedEvent& rDCEvt )
1647 : {
1648 0 : Window::DataChanged( rDCEvt );
1649 :
1650 0 : if( rDCEvt.GetType() == DataChangedEventType::SETTINGS && ( rDCEvt.GetFlags() & AllSettingsFlags::STYLE ) )
1651 0 : InitColors();
1652 0 : }
1653 :
1654 0 : void SwMarkPreview::Paint(vcl::RenderContext& rRenderContext, const Rectangle &/*rRect*/)
1655 : {
1656 0 : const Size aSz(rRenderContext.GetOutputSizePixel());
1657 :
1658 : // Page
1659 0 : aPage.SetSize(Size(aSz.Width() - 3, aSz.Height() - 3));
1660 :
1661 0 : const long nOutWPix = aPage.GetWidth();
1662 0 : const long nOutHPix = aPage.GetHeight();
1663 :
1664 : // PrintArea
1665 0 : const long nLBorder = 8;
1666 0 : const long nRBorder = 8;
1667 0 : const long nTBorder = 4;
1668 0 : const long nBBorder = 4;
1669 :
1670 0 : aLeftPagePrtArea = Rectangle(Point(nLBorder, nTBorder), Point((nOutWPix - 1) - nRBorder, (nOutHPix - 1) - nBBorder));
1671 0 : const long nWidth = aLeftPagePrtArea.GetWidth();
1672 0 : const long nKorr = (nWidth & 1) != 0 ? 0 : 1;
1673 0 : aLeftPagePrtArea.SetSize(Size(nWidth / 2 - (nLBorder + nRBorder) / 2 + nKorr, aLeftPagePrtArea.GetHeight()));
1674 :
1675 0 : aRightPagePrtArea = aLeftPagePrtArea;
1676 0 : aRightPagePrtArea.Move(aLeftPagePrtArea.GetWidth() + nLBorder + nRBorder + 1, 0);
1677 :
1678 : // draw shadow
1679 0 : Rectangle aShadow(aPage);
1680 0 : aShadow += Point(3, 3);
1681 0 : drawRect(rRenderContext, aShadow, m_aShadowCol, m_aTransCol);
1682 :
1683 : // draw page
1684 0 : drawRect(rRenderContext, aPage, m_aBgCol, m_aLineCol);
1685 :
1686 : // draw separator
1687 0 : Rectangle aPageSeparator(aPage);
1688 0 : aPageSeparator.SetSize(Size(2, aPageSeparator.GetHeight()));
1689 0 : aPageSeparator.Move(aPage.GetWidth() / 2 - 1, 0);
1690 0 : drawRect(rRenderContext, aPageSeparator, m_aLineCol, m_aTransCol);
1691 :
1692 0 : PaintPage(rRenderContext, aLeftPagePrtArea);
1693 0 : PaintPage(rRenderContext, aRightPagePrtArea);
1694 :
1695 0 : Rectangle aLeftMark(Point(aPage.Left() + 2, aLeftPagePrtArea.Top() + 4), Size(aLeftPagePrtArea.Left() - 4, 2));
1696 0 : Rectangle aRightMark(Point(aRightPagePrtArea.Right() + 2, aRightPagePrtArea.Bottom() - 6), Size(aLeftPagePrtArea.Left() - 4, 2));
1697 :
1698 0 : switch (nMarkPos)
1699 : {
1700 : case 1: // left
1701 0 : aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
1702 0 : break;
1703 :
1704 : case 2: // right
1705 0 : aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
1706 0 : break;
1707 :
1708 : case 3: // outside
1709 0 : break;
1710 :
1711 : case 4: // inside
1712 0 : aLeftMark.SetPos(Point(aLeftPagePrtArea.Right() + 2, aLeftMark.Top()));
1713 0 : aRightMark.SetPos(Point(aRightPagePrtArea.Left() - 2 - aRightMark.GetWidth(), aRightMark.Top()));
1714 0 : break;
1715 :
1716 : case 0: // none
1717 : default:
1718 0 : return;
1719 : }
1720 0 : drawRect(rRenderContext, aLeftMark, m_aMarkCol, m_aTransCol);
1721 0 : drawRect(rRenderContext, aRightMark, m_aMarkCol, m_aTransCol);
1722 : }
1723 :
1724 0 : void SwMarkPreview::PaintPage(vcl::RenderContext& rRenderContext, const Rectangle &rRect)
1725 : {
1726 : // draw PrintArea
1727 0 : drawRect(rRenderContext, rRect, m_aTransCol, m_aPrintAreaCol);
1728 :
1729 : // draw Testparagraph
1730 0 : sal_uLong nLTextBorder = 4;
1731 0 : sal_uLong nRTextBorder = 4;
1732 0 : sal_uLong nTTextBorder = 4;
1733 :
1734 0 : Rectangle aTextLine = rRect;
1735 0 : aTextLine.SetSize(Size(aTextLine.GetWidth(), 2));
1736 0 : aTextLine.Left() += nLTextBorder;
1737 0 : aTextLine.Right() -= nRTextBorder;
1738 0 : aTextLine.Move(0, nTTextBorder);
1739 :
1740 0 : const long nStep = aTextLine.GetHeight() + 2;
1741 0 : const long nLines = rRect.GetHeight() / (aTextLine.GetHeight() + 2) - 1;
1742 :
1743 : // simulate text
1744 0 : for (long i = 0; i < nLines; ++i)
1745 : {
1746 0 : if (i == (nLines - 1))
1747 0 : aTextLine.SetSize(Size(aTextLine.GetWidth() / 2, aTextLine.GetHeight()));
1748 :
1749 0 : if (aPage.IsInside(aTextLine))
1750 0 : drawRect(rRenderContext, aTextLine, m_aTextCol, m_aTransCol);
1751 :
1752 0 : aTextLine.Move(0, nStep);
1753 : }
1754 0 : aTextLine.Move(0, -nStep);
1755 0 : }
1756 :
1757 0 : Size SwMarkPreview::GetOptimalSize() const
1758 : {
1759 0 : return m_aInitialSize;
1760 : }
1761 :
1762 : namespace
1763 : {
1764 0 : void lcl_FillRedlineAttrListBox(
1765 : ListBox& rLB, const AuthorCharAttr& rAttrToSelect,
1766 : const sal_uInt16* pAttrMap, const size_t nAttrMapSize)
1767 : {
1768 0 : for (size_t i = 0; i != nAttrMapSize; ++i)
1769 : {
1770 0 : CharAttr& rAttr(aRedlineAttr[pAttrMap[i]]);
1771 0 : rLB.SetEntryData(i, &rAttr);
1772 0 : if (rAttr.nItemId == rAttrToSelect.nItemId &&
1773 0 : rAttr.nAttr == rAttrToSelect.nAttr)
1774 0 : rLB.SelectEntryPos(i);
1775 : }
1776 0 : }
1777 : }
1778 :
1779 0 : SwRedlineOptionsTabPage::SwRedlineOptionsTabPage( vcl::Window* pParent,
1780 : const SfxItemSet& rSet )
1781 : : SfxTabPage(pParent, "OptRedLinePage",
1782 : "modules/swriter/ui/optredlinepage.ui" , &rSet)
1783 0 : , sNone(SW_RESSTR(SW_STR_NONE))
1784 : {
1785 0 : Size aPreviewSize(getPreviewOptionsSize(this));
1786 :
1787 0 : get(pInsertLB,"insert");
1788 0 : get(pInsertColorLB,"insertcolor");
1789 0 : get(pInsertedPreviewWN,"insertedpreview");
1790 :
1791 0 : get(pDeletedLB,"deleted");
1792 0 : get(pDeletedColorLB,"deletedcolor");
1793 0 : get(pDeletedPreviewWN,"deletedpreview");
1794 :
1795 0 : get(pChangedLB,"changed");
1796 0 : get(pChangedColorLB,"changedcolor");
1797 0 : get(pChangedPreviewWN,"changedpreview");
1798 :
1799 0 : get(pMarkPosLB,"markpos");
1800 0 : get(pMarkColorLB,"markcolor");
1801 0 : get(pMarkPreviewWN,"markpreview");
1802 :
1803 0 : pInsertedPreviewWN->set_height_request(aPreviewSize.Height());
1804 0 : pDeletedPreviewWN->set_height_request(aPreviewSize.Height());
1805 0 : pChangedPreviewWN->set_height_request(aPreviewSize.Height());
1806 0 : pMarkPreviewWN->set_height_request(aPreviewSize.Height());
1807 :
1808 0 : pInsertedPreviewWN->set_width_request(aPreviewSize.Width());
1809 0 : pDeletedPreviewWN->set_width_request(aPreviewSize.Width());
1810 0 : pChangedPreviewWN->set_width_request(aPreviewSize.Width());
1811 0 : pMarkPreviewWN->set_width_request(aPreviewSize.Width());
1812 :
1813 0 : sAuthor = get<vcl::Window>("byauthor")->GetText();
1814 :
1815 0 : for (sal_Int32 i = 0; i < pInsertLB->GetEntryCount(); ++i)
1816 : {
1817 0 : const OUString sEntry(pInsertLB->GetEntry(i));
1818 0 : pDeletedLB->InsertEntry(sEntry);
1819 0 : pChangedLB->InsertEntry(sEntry);
1820 0 : };
1821 :
1822 : // remove strikethrough from insert and change and underline + double
1823 : // underline from delete
1824 0 : pInsertLB->RemoveEntry(5);
1825 0 : pChangedLB->RemoveEntry(5);
1826 0 : pDeletedLB->RemoveEntry(4);
1827 0 : pDeletedLB->RemoveEntry(3);
1828 :
1829 0 : Link<> aLk = LINK(this, SwRedlineOptionsTabPage, AttribHdl);
1830 0 : pInsertLB->SetSelectHdl( aLk );
1831 0 : pDeletedLB->SetSelectHdl( aLk );
1832 0 : pChangedLB->SetSelectHdl( aLk );
1833 :
1834 0 : aLk = LINK(this, SwRedlineOptionsTabPage, ColorHdl);
1835 0 : pInsertColorLB->SetSelectHdl( aLk );
1836 0 : pDeletedColorLB->SetSelectHdl( aLk );
1837 0 : pChangedColorLB->SetSelectHdl( aLk );
1838 :
1839 0 : aLk = LINK(this, SwRedlineOptionsTabPage, ChangedMaskPrevHdl);
1840 0 : pMarkPosLB->SetSelectHdl( aLk );
1841 0 : pMarkColorLB->SetSelectHdl( aLk );
1842 : /*
1843 : //solution: set different accessible name of four color box
1844 : pInsertColorLB->SetAccessibleName(OUString( aInsertFT.GetDisplayText()) + OUString(aInsertColorFT.GetDisplayText()));
1845 : pDeletedColorLB->SetAccessibleName(OUString( aDeletedFT.GetDisplayText()) + OUString( aDeletedColorFT.GetDisplayText()));
1846 : pChangedColorLB->SetAccessibleName(OUString( aChangedFT.GetDisplayText()) + OUString( aChangedColorFT.GetDisplayText()));
1847 : pMarkColorLB->SetAccessibleName(OUString( aMarkPosFT.GetDisplayText()) + OUString( aMarkColorFT.GetDisplayText()));*/
1848 0 : }
1849 :
1850 0 : SwRedlineOptionsTabPage::~SwRedlineOptionsTabPage()
1851 : {
1852 0 : disposeOnce();
1853 0 : }
1854 :
1855 0 : void SwRedlineOptionsTabPage::dispose()
1856 : {
1857 0 : pInsertLB.clear();
1858 0 : pInsertColorLB.clear();
1859 0 : pInsertedPreviewWN.clear();
1860 0 : pDeletedLB.clear();
1861 0 : pDeletedColorLB.clear();
1862 0 : pDeletedPreviewWN.clear();
1863 0 : pChangedLB.clear();
1864 0 : pChangedColorLB.clear();
1865 0 : pChangedPreviewWN.clear();
1866 0 : pMarkPosLB.clear();
1867 0 : pMarkColorLB.clear();
1868 0 : pMarkPreviewWN.clear();
1869 0 : SfxTabPage::dispose();
1870 0 : }
1871 :
1872 0 : VclPtr<SfxTabPage> SwRedlineOptionsTabPage::Create( vcl::Window* pParent, const SfxItemSet* rSet)
1873 : {
1874 0 : return VclPtr<SwRedlineOptionsTabPage>::Create( pParent, *rSet );
1875 : }
1876 :
1877 0 : bool SwRedlineOptionsTabPage::FillItemSet( SfxItemSet* )
1878 : {
1879 : CharAttr *pAttr;
1880 0 : SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();
1881 :
1882 0 : AuthorCharAttr aInsertedAttr;
1883 0 : AuthorCharAttr aDeletedAttr;
1884 0 : AuthorCharAttr aChangedAttr;
1885 :
1886 0 : AuthorCharAttr aOldInsertAttr(pOpt->GetInsertAuthorAttr());
1887 0 : AuthorCharAttr aOldDeletedAttr(pOpt->GetDeletedAuthorAttr());
1888 0 : AuthorCharAttr aOldChangedAttr(pOpt->GetFormatAuthorAttr());
1889 :
1890 0 : ColorData nOldMarkColor = pOpt->GetMarkAlignColor().GetColor();
1891 0 : sal_uInt16 nOldMarkMode = pOpt->GetMarkAlignMode();
1892 :
1893 0 : sal_Int32 nPos = pInsertLB->GetSelectEntryPos();
1894 0 : if (nPos != LISTBOX_ENTRY_NOTFOUND)
1895 : {
1896 0 : pAttr = static_cast<CharAttr *>(pInsertLB->GetEntryData(nPos));
1897 0 : aInsertedAttr.nItemId = pAttr->nItemId;
1898 0 : aInsertedAttr.nAttr = pAttr->nAttr;
1899 :
1900 0 : nPos = pInsertColorLB->GetSelectEntryPos();
1901 :
1902 0 : switch (nPos)
1903 : {
1904 : case 0:
1905 0 : aInsertedAttr.nColor = COL_NONE_COLOR;
1906 0 : break;
1907 : case 1:
1908 : case LISTBOX_ENTRY_NOTFOUND:
1909 0 : aInsertedAttr.nColor = COL_TRANSPARENT;
1910 0 : break;
1911 : default:
1912 0 : aInsertedAttr.nColor = pInsertColorLB->GetEntryColor(nPos).GetColor();
1913 0 : break;
1914 : }
1915 :
1916 0 : pOpt->SetInsertAuthorAttr(aInsertedAttr);
1917 : }
1918 :
1919 0 : nPos = pDeletedLB->GetSelectEntryPos();
1920 0 : if (nPos != LISTBOX_ENTRY_NOTFOUND)
1921 : {
1922 0 : pAttr = static_cast<CharAttr *>(pDeletedLB->GetEntryData(nPos));
1923 0 : aDeletedAttr.nItemId = pAttr->nItemId;
1924 0 : aDeletedAttr.nAttr = pAttr->nAttr;
1925 :
1926 0 : nPos = pDeletedColorLB->GetSelectEntryPos();
1927 :
1928 0 : switch (nPos)
1929 : {
1930 : case 0:
1931 0 : aDeletedAttr.nColor = COL_NONE_COLOR;
1932 0 : break;
1933 : case 1:
1934 : case LISTBOX_ENTRY_NOTFOUND:
1935 0 : aDeletedAttr.nColor = COL_TRANSPARENT;
1936 0 : break;
1937 : default:
1938 0 : aDeletedAttr.nColor = pDeletedColorLB->GetEntryColor(nPos).GetColor();
1939 0 : break;
1940 : }
1941 :
1942 0 : pOpt->SetDeletedAuthorAttr(aDeletedAttr);
1943 : }
1944 :
1945 0 : nPos = pChangedLB->GetSelectEntryPos();
1946 0 : if (nPos != LISTBOX_ENTRY_NOTFOUND)
1947 : {
1948 0 : pAttr = static_cast<CharAttr *>(pChangedLB->GetEntryData(nPos));
1949 0 : aChangedAttr.nItemId = pAttr->nItemId;
1950 0 : aChangedAttr.nAttr = pAttr->nAttr;
1951 :
1952 0 : nPos = pChangedColorLB->GetSelectEntryPos();
1953 :
1954 0 : switch (nPos)
1955 : {
1956 : case 0:
1957 0 : aChangedAttr.nColor = COL_NONE_COLOR;
1958 0 : break;
1959 : case 1:
1960 : case LISTBOX_ENTRY_NOTFOUND:
1961 0 : aChangedAttr.nColor = COL_TRANSPARENT;
1962 0 : break;
1963 : default:
1964 0 : aChangedAttr.nColor = pChangedColorLB->GetEntryColor(nPos).GetColor();
1965 0 : break;
1966 : }
1967 :
1968 0 : pOpt->SetFormatAuthorAttr(aChangedAttr);
1969 : }
1970 :
1971 0 : nPos = 0;
1972 0 : switch (pMarkPosLB->GetSelectEntryPos())
1973 : {
1974 0 : case 0: nPos = text::HoriOrientation::NONE; break;
1975 0 : case 1: nPos = text::HoriOrientation::LEFT; break;
1976 0 : case 2: nPos = text::HoriOrientation::RIGHT; break;
1977 0 : case 3: nPos = text::HoriOrientation::OUTSIDE; break;
1978 0 : case 4: nPos = text::HoriOrientation::INSIDE; break;
1979 : }
1980 0 : pOpt->SetMarkAlignMode(nPos);
1981 :
1982 0 : pOpt->SetMarkAlignColor(pMarkColorLB->GetSelectEntryColor());
1983 :
1984 0 : if (!(aInsertedAttr == aOldInsertAttr) ||
1985 0 : !(aDeletedAttr == aOldDeletedAttr) ||
1986 0 : !(aChangedAttr == aOldChangedAttr) ||
1987 0 : nOldMarkColor != pOpt->GetMarkAlignColor().GetColor() ||
1988 0 : nOldMarkMode != pOpt->GetMarkAlignMode())
1989 : {
1990 : // update all documents
1991 0 : TypeId aType(TYPE(SwDocShell));
1992 0 : SwDocShell* pDocShell = static_cast<SwDocShell*>(SfxObjectShell::GetFirst(&aType));
1993 :
1994 0 : while( pDocShell )
1995 : {
1996 0 : pDocShell->GetWrtShell()->UpdateRedlineAttr();
1997 0 : pDocShell = static_cast<SwDocShell*>(SfxObjectShell::GetNext(*pDocShell, &aType));
1998 : }
1999 : }
2000 :
2001 0 : return false;
2002 : }
2003 :
2004 0 : void SwRedlineOptionsTabPage::Reset( const SfxItemSet* )
2005 : {
2006 0 : const SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();
2007 :
2008 0 : const AuthorCharAttr &rInsertAttr = pOpt->GetInsertAuthorAttr();
2009 0 : const AuthorCharAttr &rDeletedAttr = pOpt->GetDeletedAuthorAttr();
2010 0 : const AuthorCharAttr &rChangedAttr = pOpt->GetFormatAuthorAttr();
2011 :
2012 : // initialise preview
2013 0 : InitFontStyle(*pInsertedPreviewWN);
2014 0 : InitFontStyle(*pDeletedPreviewWN);
2015 0 : InitFontStyle(*pChangedPreviewWN);
2016 :
2017 : // initialise colour list box
2018 0 : pInsertColorLB->SetUpdateMode(false);
2019 0 : pDeletedColorLB->SetUpdateMode(false);
2020 0 : pChangedColorLB->SetUpdateMode(false);
2021 0 : pMarkColorLB->SetUpdateMode(false);
2022 0 : pInsertColorLB->InsertEntry(sNone);
2023 0 : pDeletedColorLB->InsertEntry(sNone);
2024 0 : pChangedColorLB->InsertEntry(sNone);
2025 :
2026 0 : pInsertColorLB->InsertEntry(sAuthor);
2027 0 : pDeletedColorLB->InsertEntry(sAuthor);
2028 0 : pChangedColorLB->InsertEntry(sAuthor);
2029 :
2030 0 : XColorListRef pColorLst = XColorList::GetStdColorList();
2031 0 : for( long i = 0; i < pColorLst->Count(); ++i )
2032 : {
2033 0 : XColorEntry* pEntry = pColorLst->GetColor( i );
2034 0 : Color aColor = pEntry->GetColor();
2035 0 : const OUString sName = pEntry->GetName();
2036 :
2037 0 : pInsertColorLB->InsertEntry( aColor, sName );
2038 0 : pDeletedColorLB->InsertEntry( aColor, sName );
2039 0 : pChangedColorLB->InsertEntry( aColor, sName );
2040 0 : pMarkColorLB->InsertEntry( aColor, sName );
2041 0 : }
2042 0 : pInsertColorLB->SetUpdateMode( true );
2043 0 : pDeletedColorLB->SetUpdateMode( true );
2044 0 : pChangedColorLB->SetUpdateMode( true );
2045 0 : pMarkColorLB->SetUpdateMode( true );
2046 :
2047 0 : ColorData nColor = rInsertAttr.nColor;
2048 :
2049 0 : switch (nColor)
2050 : {
2051 : case COL_TRANSPARENT:
2052 0 : pInsertColorLB->SelectEntryPos(1);
2053 0 : break;
2054 : case COL_NONE_COLOR:
2055 0 : pInsertColorLB->SelectEntryPos(0);
2056 0 : break;
2057 : default:
2058 0 : pInsertColorLB->SelectEntry(Color(nColor));
2059 : }
2060 :
2061 0 : nColor = rDeletedAttr.nColor;
2062 :
2063 0 : switch (nColor)
2064 : {
2065 : case COL_TRANSPARENT:
2066 0 : pDeletedColorLB->SelectEntryPos(1);
2067 0 : break;
2068 : case COL_NONE_COLOR:
2069 0 : pDeletedColorLB->SelectEntryPos(0);
2070 0 : break;
2071 : default:
2072 0 : pDeletedColorLB->SelectEntry(Color(nColor));
2073 : }
2074 :
2075 0 : nColor = rChangedAttr.nColor;
2076 :
2077 0 : switch (nColor)
2078 : {
2079 : case COL_TRANSPARENT:
2080 0 : pChangedColorLB->SelectEntryPos(1);
2081 0 : break;
2082 : case COL_NONE_COLOR:
2083 0 : pChangedColorLB->SelectEntryPos(0);
2084 0 : break;
2085 : default:
2086 0 : pChangedColorLB->SelectEntry(Color(nColor));
2087 : }
2088 :
2089 0 : pMarkColorLB->SelectEntry(pOpt->GetMarkAlignColor());
2090 :
2091 0 : pInsertLB->SelectEntryPos(0);
2092 0 : pDeletedLB->SelectEntryPos(0);
2093 0 : pChangedLB->SelectEntryPos(0);
2094 :
2095 0 : lcl_FillRedlineAttrListBox(*pInsertLB, rInsertAttr, aInsertAttrMap, SAL_N_ELEMENTS(aInsertAttrMap));
2096 0 : lcl_FillRedlineAttrListBox(*pDeletedLB, rDeletedAttr, aDeletedAttrMap, SAL_N_ELEMENTS(aDeletedAttrMap));
2097 0 : lcl_FillRedlineAttrListBox(*pChangedLB, rChangedAttr, aChangedAttrMap, SAL_N_ELEMENTS(aChangedAttrMap));
2098 :
2099 0 : sal_Int32 nPos = 0;
2100 0 : switch (pOpt->GetMarkAlignMode())
2101 : {
2102 0 : case text::HoriOrientation::NONE: nPos = 0; break;
2103 0 : case text::HoriOrientation::LEFT: nPos = 1; break;
2104 0 : case text::HoriOrientation::RIGHT: nPos = 2; break;
2105 0 : case text::HoriOrientation::OUTSIDE: nPos = 3; break;
2106 0 : case text::HoriOrientation::INSIDE: nPos = 4; break;
2107 : }
2108 0 : pMarkPosLB->SelectEntryPos(nPos);
2109 :
2110 : // show settings in preview
2111 0 : AttribHdl(pInsertLB);
2112 0 : ColorHdl(pInsertColorLB);
2113 0 : AttribHdl(pDeletedLB);
2114 0 : ColorHdl(pInsertColorLB);
2115 0 : AttribHdl(pChangedLB);
2116 0 : ColorHdl(pChangedColorLB);
2117 :
2118 0 : ChangedMaskPrevHdl();
2119 0 : }
2120 :
2121 0 : IMPL_LINK( SwRedlineOptionsTabPage, AttribHdl, ListBox *, pLB )
2122 : {
2123 0 : SvxFontPrevWindow *pPrev = 0;
2124 : ColorListBox *pColorLB;
2125 :
2126 0 : if (pLB == pInsertLB)
2127 : {
2128 0 : pColorLB = pInsertColorLB;
2129 0 : pPrev = pInsertedPreviewWN;
2130 : }
2131 0 : else if (pLB == pDeletedLB)
2132 : {
2133 0 : pColorLB = pDeletedColorLB;
2134 0 : pPrev = pDeletedPreviewWN;
2135 : }
2136 : else
2137 : {
2138 0 : pColorLB = pChangedColorLB;
2139 0 : pPrev = pChangedPreviewWN;
2140 : }
2141 :
2142 0 : SvxFont& rFont = pPrev->GetFont();
2143 0 : SvxFont& rCJKFont = pPrev->GetCJKFont();
2144 :
2145 0 : rFont.SetWeight(WEIGHT_NORMAL);
2146 0 : rCJKFont.SetWeight(WEIGHT_NORMAL);
2147 0 : rFont.SetItalic(ITALIC_NONE);
2148 0 : rCJKFont.SetItalic(ITALIC_NONE);
2149 0 : rFont.SetUnderline(UNDERLINE_NONE);
2150 0 : rCJKFont.SetUnderline(UNDERLINE_NONE);
2151 0 : rFont.SetStrikeout(STRIKEOUT_NONE);
2152 0 : rCJKFont.SetStrikeout(STRIKEOUT_NONE);
2153 0 : rFont.SetCaseMap(SVX_CASEMAP_NOT_MAPPED);
2154 0 : rCJKFont.SetCaseMap(SVX_CASEMAP_NOT_MAPPED);
2155 :
2156 0 : sal_Int32 nPos = pColorLB->GetSelectEntryPos();
2157 :
2158 0 : switch( nPos )
2159 : {
2160 : case 0:
2161 0 : rFont.SetColor( Color( COL_BLACK ) );
2162 0 : rCJKFont.SetColor( Color( COL_BLACK ) );
2163 0 : break;
2164 : case 1:
2165 : case LISTBOX_ENTRY_NOTFOUND:
2166 0 : rFont.SetColor( Color( COL_RED ) );
2167 0 : rCJKFont.SetColor( Color( COL_RED ) );
2168 0 : break;
2169 : default:
2170 0 : rFont.SetColor( pColorLB->GetEntryColor( nPos ) );
2171 0 : rCJKFont.SetColor( pColorLB->GetEntryColor( nPos ) );
2172 0 : break;
2173 : }
2174 :
2175 0 : nPos = pLB->GetSelectEntryPos();
2176 0 : if( nPos == LISTBOX_ENTRY_NOTFOUND )
2177 0 : nPos = 0;
2178 :
2179 0 : CharAttr* pAttr = static_cast<CharAttr*>(pLB->GetEntryData( nPos ));
2180 : //switch off preview background color
2181 0 : pPrev->ResetColor();
2182 0 : switch (pAttr->nItemId)
2183 : {
2184 : case SID_ATTR_CHAR_WEIGHT:
2185 0 : rFont.SetWeight( ( FontWeight ) pAttr->nAttr );
2186 0 : rCJKFont.SetWeight( ( FontWeight ) pAttr->nAttr );
2187 0 : break;
2188 :
2189 : case SID_ATTR_CHAR_POSTURE:
2190 0 : rFont.SetItalic( ( FontItalic ) pAttr->nAttr );
2191 0 : rCJKFont.SetItalic( ( FontItalic ) pAttr->nAttr );
2192 0 : break;
2193 :
2194 : case SID_ATTR_CHAR_UNDERLINE:
2195 0 : rFont.SetUnderline( ( FontUnderline ) pAttr->nAttr );
2196 0 : rCJKFont.SetUnderline( ( FontUnderline ) pAttr->nAttr );
2197 0 : break;
2198 :
2199 : case SID_ATTR_CHAR_STRIKEOUT:
2200 0 : rFont.SetStrikeout( ( FontStrikeout ) pAttr->nAttr );
2201 0 : rCJKFont.SetStrikeout( ( FontStrikeout ) pAttr->nAttr );
2202 0 : break;
2203 :
2204 : case SID_ATTR_CHAR_CASEMAP:
2205 0 : rFont.SetCaseMap( ( SvxCaseMap ) pAttr->nAttr );
2206 0 : rCJKFont.SetCaseMap( ( SvxCaseMap ) pAttr->nAttr );
2207 0 : break;
2208 :
2209 : case SID_ATTR_BRUSH:
2210 : {
2211 0 : nPos = pColorLB->GetSelectEntryPos();
2212 0 : if( nPos )
2213 0 : pPrev->SetColor( pColorLB->GetSelectEntryColor() );
2214 : else
2215 0 : pPrev->SetColor( Color( COL_LIGHTGRAY ) );
2216 :
2217 0 : rFont.SetColor( Color( COL_BLACK ) );
2218 0 : rCJKFont.SetColor( Color( COL_BLACK ) );
2219 : }
2220 0 : break;
2221 : }
2222 :
2223 0 : pPrev->Invalidate();
2224 :
2225 0 : return 0;
2226 : }
2227 :
2228 0 : IMPL_LINK( SwRedlineOptionsTabPage, ColorHdl, ColorListBox *, pColorLB )
2229 : {
2230 0 : SvxFontPrevWindow *pPrev = 0;
2231 : ListBox* pLB;
2232 :
2233 0 : if (pColorLB == pInsertColorLB)
2234 : {
2235 0 : pLB = pInsertLB;
2236 0 : pPrev = pInsertedPreviewWN;
2237 : }
2238 0 : else if (pColorLB == pDeletedColorLB)
2239 : {
2240 0 : pLB = pDeletedLB;
2241 0 : pPrev = pDeletedPreviewWN;
2242 : }
2243 : else
2244 : {
2245 0 : pLB = pChangedLB;
2246 0 : pPrev = pChangedPreviewWN;
2247 : }
2248 :
2249 0 : SvxFont& rFont = pPrev->GetFont();
2250 0 : SvxFont& rCJKFont = pPrev->GetCJKFont();
2251 0 : sal_Int32 nPos = pLB->GetSelectEntryPos();
2252 0 : if( nPos == LISTBOX_ENTRY_NOTFOUND )
2253 0 : nPos = 0;
2254 :
2255 0 : CharAttr* pAttr = static_cast<CharAttr*>(pLB->GetEntryData( nPos ));
2256 :
2257 0 : if( pAttr->nItemId == SID_ATTR_BRUSH )
2258 : {
2259 0 : rFont.SetColor( Color( COL_BLACK ) );
2260 0 : rCJKFont.SetColor( Color( COL_BLACK ) );
2261 0 : nPos = pColorLB->GetSelectEntryPos();
2262 0 : if( nPos && nPos != LISTBOX_ENTRY_NOTFOUND )
2263 0 : pPrev->SetColor( pColorLB->GetSelectEntryColor() );
2264 : else
2265 0 : pPrev->SetColor( Color( COL_LIGHTGRAY ) );
2266 : }
2267 : else
2268 : {
2269 0 : nPos = pColorLB->GetSelectEntryPos();
2270 :
2271 0 : switch( nPos )
2272 : {
2273 : case 0:
2274 0 : rFont.SetColor( Color( COL_BLACK ) );
2275 0 : rCJKFont.SetColor( Color( COL_BLACK ) );
2276 0 : break;
2277 : case 1:
2278 : case LISTBOX_ENTRY_NOTFOUND:
2279 0 : rFont.SetColor( Color( COL_RED ) );
2280 0 : rCJKFont.SetColor( Color( COL_RED ) );
2281 0 : break;
2282 : default:
2283 0 : rFont.SetColor( pColorLB->GetEntryColor( nPos ) );
2284 0 : rCJKFont.SetColor( pColorLB->GetEntryColor( nPos ) );
2285 0 : break;
2286 : }
2287 : }
2288 :
2289 0 : pPrev->Invalidate();
2290 :
2291 0 : return 0;
2292 : }
2293 :
2294 0 : IMPL_LINK_NOARG(SwRedlineOptionsTabPage, ChangedMaskPrevHdl)
2295 : {
2296 0 : pMarkPreviewWN->SetMarkPos(pMarkPosLB->GetSelectEntryPos());
2297 0 : pMarkPreviewWN->SetColor(pMarkColorLB->GetSelectEntryColor().GetColor());
2298 :
2299 0 : pMarkPreviewWN->Invalidate();
2300 :
2301 0 : return 0;
2302 : }
2303 :
2304 0 : void SwRedlineOptionsTabPage::InitFontStyle(SvxFontPrevWindow& rExampleWin)
2305 : {
2306 0 : const AllSettings& rAllSettings = Application::GetSettings();
2307 0 : LanguageType eLangType = rAllSettings.GetUILanguageTag().getLanguageType();
2308 0 : Color aBackCol( rAllSettings.GetStyleSettings().GetWindowColor() );
2309 0 : SvxFont& rFont = rExampleWin.GetFont();
2310 0 : SvxFont& rCJKFont = rExampleWin.GetCJKFont();
2311 0 : SvxFont& rCTLFont = rExampleWin.GetCTLFont();
2312 :
2313 : vcl::Font aFont( OutputDevice::GetDefaultFont( DefaultFontType::SERIF, eLangType,
2314 0 : GetDefaultFontFlags::OnlyOne, &rExampleWin ) );
2315 : vcl::Font aCJKFont( OutputDevice::GetDefaultFont( DefaultFontType::CJK_TEXT, eLangType,
2316 0 : GetDefaultFontFlags::OnlyOne, &rExampleWin ) );
2317 : vcl::Font aCTLFont( OutputDevice::GetDefaultFont( DefaultFontType::CTL_TEXT, eLangType,
2318 0 : GetDefaultFontFlags::OnlyOne, &rExampleWin ) );
2319 0 : const Size aDefSize( 0, 12 );
2320 0 : aFont.SetSize( aDefSize );
2321 0 : aCJKFont.SetSize( aDefSize );
2322 0 : aCTLFont.SetSize( aDefSize );
2323 :
2324 0 : aFont.SetFillColor( aBackCol );
2325 0 : aCJKFont.SetFillColor( aBackCol );
2326 0 : aCTLFont.SetFillColor( aBackCol );
2327 :
2328 0 : aFont.SetWeight( WEIGHT_NORMAL );
2329 0 : aCJKFont.SetWeight( WEIGHT_NORMAL );
2330 0 : aCTLFont.SetWeight( WEIGHT_NORMAL );
2331 :
2332 0 : rFont = aFont;
2333 0 : rCJKFont = aCJKFont;
2334 0 : rCTLFont = aCTLFont;
2335 :
2336 0 : const Size aNewSize( 0, rExampleWin.GetOutputSize().Height() * 2 / 3 );
2337 0 : rFont.SetSize( aNewSize );
2338 0 : rCJKFont.SetSize( aNewSize );
2339 :
2340 0 : rExampleWin.SetFont( rFont, rCJKFont,rCTLFont );
2341 :
2342 0 : rExampleWin.UseResourceText();
2343 :
2344 0 : Wallpaper aWall( aBackCol );
2345 0 : rExampleWin.SetBackground( aWall );
2346 0 : rExampleWin.Invalidate();
2347 0 : }
2348 :
2349 0 : SwCompareOptionsTabPage::SwCompareOptionsTabPage( vcl::Window* pParent, const SfxItemSet& rSet )
2350 0 : : SfxTabPage( pParent,"OptComparison","modules/swriter/ui/optcomparison.ui", &rSet )
2351 : {
2352 0 : get(m_pAutoRB,"auto");
2353 0 : get(m_pWordRB, "byword");
2354 0 : get(m_pCharRB, "bycharacter");
2355 :
2356 0 : get(m_pRsidCB, "useRSID");
2357 0 : get(m_pIgnoreCB, "ignore");
2358 0 : get(m_pLenNF, "ignorelen");
2359 0 : get(m_pStoreRsidCB, "storeRSID");
2360 :
2361 0 : Link<> aLnk( LINK( this, SwCompareOptionsTabPage, ComparisonHdl ) );
2362 0 : m_pAutoRB->SetClickHdl( aLnk );
2363 0 : m_pWordRB->SetClickHdl( aLnk );
2364 0 : m_pCharRB->SetClickHdl( aLnk );
2365 :
2366 0 : m_pIgnoreCB->SetClickHdl( LINK( this, SwCompareOptionsTabPage, IgnoreHdl) );
2367 0 : }
2368 :
2369 0 : SwCompareOptionsTabPage::~SwCompareOptionsTabPage()
2370 : {
2371 0 : disposeOnce();
2372 0 : }
2373 :
2374 0 : void SwCompareOptionsTabPage::dispose()
2375 : {
2376 0 : m_pAutoRB.clear();
2377 0 : m_pWordRB.clear();
2378 0 : m_pCharRB.clear();
2379 0 : m_pRsidCB.clear();
2380 0 : m_pIgnoreCB.clear();
2381 0 : m_pLenNF.clear();
2382 0 : m_pStoreRsidCB.clear();
2383 0 : SfxTabPage::dispose();
2384 0 : }
2385 :
2386 0 : VclPtr<SfxTabPage> SwCompareOptionsTabPage::Create( vcl::Window* pParent, const SfxItemSet* rAttrSet )
2387 : {
2388 0 : return VclPtr<SwCompareOptionsTabPage>::Create( pParent, *rAttrSet );
2389 : }
2390 :
2391 0 : bool SwCompareOptionsTabPage::FillItemSet( SfxItemSet* )
2392 : {
2393 0 : bool bRet = false;
2394 0 : SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();
2395 :
2396 0 : if( m_pAutoRB->IsValueChangedFromSaved() ||
2397 0 : m_pWordRB->IsValueChangedFromSaved() ||
2398 0 : m_pCharRB->IsValueChangedFromSaved() )
2399 : {
2400 0 : SvxCompareMode eCmpMode = SVX_CMP_AUTO;
2401 :
2402 0 : if ( m_pAutoRB->IsChecked() ) eCmpMode = SVX_CMP_AUTO;
2403 0 : if ( m_pWordRB->IsChecked() ) eCmpMode = SVX_CMP_BY_WORD;
2404 0 : if ( m_pCharRB->IsChecked() ) eCmpMode = SVX_CMP_BY_CHAR;
2405 :
2406 0 : pOpt->SetCompareMode( eCmpMode );
2407 0 : bRet = true;
2408 : }
2409 :
2410 0 : if( m_pRsidCB->IsValueChangedFromSaved() )
2411 : {
2412 0 : pOpt->SetUseRsid( m_pRsidCB->IsChecked() );
2413 0 : bRet = true;
2414 : }
2415 :
2416 0 : if( m_pIgnoreCB->IsValueChangedFromSaved() )
2417 : {
2418 0 : pOpt->SetIgnorePieces( m_pIgnoreCB->IsChecked() );
2419 0 : bRet = true;
2420 : }
2421 :
2422 0 : if( m_pLenNF->IsModified() )
2423 : {
2424 0 : pOpt->SetPieceLen( m_pLenNF->GetValue() );
2425 0 : bRet = true;
2426 : }
2427 :
2428 0 : if (m_pStoreRsidCB->IsValueChangedFromSaved())
2429 : {
2430 0 : pOpt->SetStoreRsid(m_pStoreRsidCB->IsChecked());
2431 0 : bRet = true;
2432 : }
2433 :
2434 0 : return bRet;
2435 : }
2436 :
2437 0 : void SwCompareOptionsTabPage::Reset( const SfxItemSet* )
2438 : {
2439 0 : SwModuleOptions *pOpt = SW_MOD()->GetModuleConfig();
2440 :
2441 0 : SvxCompareMode eCmpMode = pOpt->GetCompareMode();
2442 0 : if( eCmpMode == SVX_CMP_AUTO )
2443 : {
2444 0 : m_pAutoRB->Check();
2445 0 : m_pRsidCB->Disable();
2446 0 : m_pIgnoreCB->Disable();
2447 0 : m_pLenNF->Disable();
2448 : }
2449 0 : else if( eCmpMode == SVX_CMP_BY_WORD )
2450 : {
2451 0 : m_pWordRB->Check();
2452 0 : m_pRsidCB->Enable();
2453 0 : m_pIgnoreCB->Enable();
2454 0 : m_pLenNF->Enable();
2455 : }
2456 0 : else if( eCmpMode == SVX_CMP_BY_CHAR)
2457 : {
2458 0 : m_pCharRB->Check();
2459 0 : m_pRsidCB->Enable();
2460 0 : m_pIgnoreCB->Enable();
2461 0 : m_pLenNF->Enable();
2462 : }
2463 0 : m_pAutoRB->SaveValue();
2464 0 : m_pWordRB->SaveValue();
2465 0 : m_pCharRB->SaveValue();
2466 :
2467 0 : m_pRsidCB->Check( pOpt->IsUseRsid() );
2468 0 : m_pRsidCB->SaveValue();
2469 :
2470 0 : m_pIgnoreCB->Check( pOpt->IsIgnorePieces() );
2471 0 : m_pIgnoreCB->SaveValue();
2472 :
2473 0 : m_pLenNF->Enable( m_pIgnoreCB->IsChecked() && eCmpMode );
2474 :
2475 0 : m_pLenNF->SetValue( pOpt->GetPieceLen() );
2476 0 : m_pLenNF->SaveValue();
2477 :
2478 0 : m_pStoreRsidCB->Check(pOpt->IsStoreRsid());
2479 0 : m_pStoreRsidCB->SaveValue();
2480 0 : }
2481 :
2482 0 : IMPL_LINK_NOARG(SwCompareOptionsTabPage, ComparisonHdl)
2483 : {
2484 0 : bool bChecked = !m_pAutoRB->IsChecked();
2485 0 : m_pRsidCB->Enable( bChecked );
2486 0 : m_pIgnoreCB->Enable( bChecked );
2487 0 : m_pLenNF->Enable( bChecked && m_pIgnoreCB->IsChecked() );
2488 :
2489 0 : return 0;
2490 : }
2491 :
2492 0 : IMPL_LINK_NOARG(SwCompareOptionsTabPage, IgnoreHdl)
2493 : {
2494 0 : m_pLenNF->Enable( m_pIgnoreCB->IsChecked() );
2495 0 : return 0;
2496 0 : }
2497 :
2498 : #ifdef DBG_UTIL
2499 :
2500 : SwTestTabPage::SwTestTabPage(vcl::Window* pParent, const SfxItemSet& rCoreSet)
2501 : : SfxTabPage( pParent, "OptTestPage", "modules/swriter/ui/opttestpage.ui", &rCoreSet)
2502 : , bAttrModified( false )
2503 : {
2504 : get(m_pTest1CBox, "unused");
2505 : get(m_pTest2CBox, "dynamic");
2506 : get(m_pTest3CBox, "nocalm");
2507 : get(m_pTest4CBox, "wysiwygdbg");
2508 : get(m_pTest5CBox, "noidle");
2509 : get(m_pTest6CBox, "noscreenadj");
2510 : get(m_pTest7CBox, "winformat");
2511 : get(m_pTest8CBox, "noscroll");
2512 : get(m_pTest9CBox, "DrawingLayerNotLoading");
2513 : get(m_pTest10CBox, "AutoFormatByInput");
2514 :
2515 : Init();
2516 :
2517 : }
2518 :
2519 : SwTestTabPage::~SwTestTabPage()
2520 : {
2521 : disposeOnce();
2522 : }
2523 :
2524 : void SwTestTabPage::dispose()
2525 : {
2526 : m_pTest1CBox.clear();
2527 : m_pTest2CBox.clear();
2528 : m_pTest3CBox.clear();
2529 : m_pTest4CBox.clear();
2530 : m_pTest5CBox.clear();
2531 : m_pTest6CBox.clear();
2532 : m_pTest7CBox.clear();
2533 : m_pTest8CBox.clear();
2534 : m_pTest9CBox.clear();
2535 : m_pTest10CBox.clear();
2536 : SfxTabPage::dispose();
2537 : }
2538 :
2539 : VclPtr<SfxTabPage> SwTestTabPage::Create( vcl::Window* pParent,
2540 : const SfxItemSet* rAttrSet )
2541 : {
2542 : return VclPtr<SwTestTabPage>::Create(pParent, *rAttrSet);
2543 : }
2544 :
2545 : bool SwTestTabPage::FillItemSet( SfxItemSet* rCoreSet )
2546 : {
2547 :
2548 : if ( bAttrModified )
2549 : {
2550 : SwTestItem aTestItem(FN_PARAM_SWTEST);
2551 : aTestItem.bTest1=m_pTest1CBox->IsChecked();
2552 : aTestItem.bTest2=m_pTest2CBox->IsChecked();
2553 : aTestItem.bTest3=m_pTest3CBox->IsChecked();
2554 : aTestItem.bTest4=m_pTest4CBox->IsChecked();
2555 : aTestItem.bTest5=m_pTest5CBox->IsChecked();
2556 : aTestItem.bTest6=m_pTest6CBox->IsChecked();
2557 : aTestItem.bTest7=m_pTest7CBox->IsChecked();
2558 : aTestItem.bTest8=m_pTest8CBox->IsChecked();
2559 : aTestItem.bTest9=m_pTest9CBox->IsChecked();
2560 : aTestItem.bTest10=m_pTest10CBox->IsChecked();
2561 : rCoreSet->Put(aTestItem);
2562 : }
2563 : return bAttrModified;
2564 : }
2565 :
2566 : void SwTestTabPage::Reset( const SfxItemSet* )
2567 : {
2568 : const SfxItemSet& rSet = GetItemSet();
2569 : const SwTestItem* pTestAttr = 0;
2570 :
2571 : if( SfxItemState::SET == rSet.GetItemState( FN_PARAM_SWTEST , false,
2572 : reinterpret_cast<const SfxPoolItem**>(&pTestAttr) ))
2573 : {
2574 : m_pTest1CBox->Check(pTestAttr->bTest1);
2575 : m_pTest2CBox->Check(pTestAttr->bTest2);
2576 : m_pTest3CBox->Check(pTestAttr->bTest3);
2577 : m_pTest4CBox->Check(pTestAttr->bTest4);
2578 : m_pTest5CBox->Check(pTestAttr->bTest5);
2579 : m_pTest6CBox->Check(pTestAttr->bTest6);
2580 : m_pTest7CBox->Check(pTestAttr->bTest7);
2581 : m_pTest8CBox->Check(pTestAttr->bTest8);
2582 : m_pTest9CBox->Check(pTestAttr->bTest9);
2583 : m_pTest10CBox->Check(pTestAttr->bTest10);
2584 : }
2585 : }
2586 :
2587 : void SwTestTabPage::Init()
2588 : {
2589 : // handler
2590 : Link<> aLk = LINK( this, SwTestTabPage, AutoClickHdl );
2591 : m_pTest1CBox->SetClickHdl( aLk );
2592 : m_pTest2CBox->SetClickHdl( aLk );
2593 : m_pTest3CBox->SetClickHdl( aLk );
2594 : m_pTest4CBox->SetClickHdl( aLk );
2595 : m_pTest5CBox->SetClickHdl( aLk );
2596 : m_pTest6CBox->SetClickHdl( aLk );
2597 : m_pTest7CBox->SetClickHdl( aLk );
2598 : m_pTest8CBox->SetClickHdl( aLk );
2599 : m_pTest9CBox->SetClickHdl( aLk );
2600 : m_pTest10CBox->SetClickHdl( aLk );
2601 : }
2602 :
2603 : IMPL_LINK_NOARG(SwTestTabPage, AutoClickHdl)
2604 : {
2605 : bAttrModified = true;
2606 : return 0;
2607 : }
2608 :
2609 : #endif
2610 :
2611 : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
|
