LibreOffice Module sw (master)  1
annotsh.cxx
Go to the documentation of this file.
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 <hintids.hxx>
21 
22 #include <com/sun/star/i18n/TextConversionOption.hpp>
23 #include <com/sun/star/lang/XInitialization.hpp>
24 #include <com/sun/star/ui/dialogs/XExecutableDialog.hpp>
25 #include <com/sun/star/awt/XWindow.hpp>
26 #include <com/sun/star/uno/XComponentContext.hpp>
27 #include <com/sun/star/beans/XPropertySet.hpp>
28 #include <com/sun/star/linguistic2/XThesaurus.hpp>
29 
30 #include <i18nutil/transliteration.hxx>
31 #include <sfx2/objface.hxx>
32 #include <sfx2/viewfrm.hxx>
33 #include <sfx2/bindings.hxx>
34 #include <sfx2/request.hxx>
35 #include <editeng/eeitem.hxx>
36 #include <editeng/flstitem.hxx>
37 #include <editeng/spltitem.hxx>
38 #include <editeng/lrspitem.hxx>
39 #include <editeng/ulspitem.hxx>
40 #include <editeng/orphitem.hxx>
41 #include <editeng/formatbreakitem.hxx>
42 #include <editeng/widwitem.hxx>
43 #include <editeng/kernitem.hxx>
44 #include <editeng/escapementitem.hxx>
45 #include <editeng/lspcitem.hxx>
46 #include <editeng/adjustitem.hxx>
47 #include <editeng/crossedoutitem.hxx>
48 #include <editeng/shdditem.hxx>
49 #include <editeng/hyphenzoneitem.hxx>
50 #include <editeng/udlnitem.hxx>
51 #include <editeng/fontitem.hxx>
52 #include <svx/clipfmtitem.hxx>
53 #include <svl/stritem.hxx>
54 #include <svl/slstitm.hxx>
55 #include <editeng/colritem.hxx>
56 #include <editeng/contouritem.hxx>
57 #include <editeng/frmdiritem.hxx>
58 #include <svl/whiter.hxx>
59 #include <svl/cjkoptions.hxx>
60 #include <svl/ctloptions.hxx>
61 #include <unotools/useroptions.hxx>
62 #include <editeng/flditem.hxx>
63 #include <svx/hlnkitem.hxx>
64 #include <sfx2/htmlmode.hxx>
65 #include <editeng/langitem.hxx>
66 #include <editeng/scripttypeitem.hxx>
67 #include <swundo.hxx>
68 #include <doc.hxx>
69 #include <viewopt.hxx>
70 #include <wrtsh.hxx>
71 #include <chrdlgmodes.hxx>
72 #include <edtwin.hxx>
73 #include <SwRewriter.hxx>
74 
75 #include <cmdid.h>
76 #include <strings.hrc>
77 #include <breakit.hxx>
78 #include <annotsh.hxx>
79 #include <view.hxx>
80 #include <PostItMgr.hxx>
81 #include <AnnotationWin.hxx>
82 
83 #include <swtypes.hxx>
84 
85 #include <svx/svxdlg.hxx>
86 
87 #include <vcl/EnumContext.hxx>
88 #include <svl/itempool.hxx>
89 #include <editeng/outliner.hxx>
90 #include <editeng/editview.hxx>
91 
92 #include <svl/languageoptions.hxx>
93 
94 #include <svl/undo.hxx>
95 #include <swabstdlg.hxx>
96 
97 #include <comphelper/string.hxx>
98 #include <comphelper/propertysequence.hxx>
99 #include <cppuhelper/bootstrap.hxx>
100 
101 #include <langhelper.hxx>
102 
103 #include <memory>
104 
105 using namespace ::com::sun::star;
106 using namespace ::com::sun::star::uno;
107 using namespace ::com::sun::star::beans;
108 using namespace ::com::sun::star::i18n;
109 
110 #define ShellClass_SwAnnotationShell
111 
112 #include <sfx2/msg.hxx>
113 #include <swslots.hxx>
114 
115 SFX_IMPL_INTERFACE(SwAnnotationShell, SfxShell)
116 
117 void SwAnnotationShell::InitInterface_Impl()
118 {
119  GetStaticInterface()->RegisterObjectBar(SFX_OBJECTBAR_OBJECT, SfxVisibilityFlags::Invisible, ToolbarId::Text_Toolbox_Sw);
120 
121  GetStaticInterface()->RegisterPopupMenu("annotation");
122 }
123 
124 
125 SfxItemPool* SwAnnotationShell::GetAnnotationPool(SwView const & rV)
126 {
127  SwWrtShell &rSh = rV.GetWrtShell();
128  return rSh.GetAttrPool().GetSecondaryPool();
129 }
130 
131 SwAnnotationShell::SwAnnotationShell( SwView& r )
132  : rView(r)
133 {
134  SetPool(SwAnnotationShell::GetAnnotationPool(rView));
135  SfxShell::SetContextName(vcl::EnumContext::GetContextName(vcl::EnumContext::Context::Annotation));
136 }
137 
138 SwAnnotationShell::~SwAnnotationShell()
139 {
140 }
141 
142 SfxUndoManager* SwAnnotationShell::GetUndoManager()
143 {
144  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
145  if ( !pPostItMgr ||
146  !pPostItMgr->HasActiveSidebarWin() )
147  {
148  OSL_ENSURE(pPostItMgr,"PostItMgr::Layout(): We are looping forever");
149  return nullptr;
150  }
151  return &pPostItMgr->GetActiveSidebarWin()->GetOutlinerView()->GetOutliner()->GetUndoManager();
152 }
153 
154 void SwAnnotationShell::Exec( SfxRequest &rReq )
155 {
156  //TODO: clean this up!!!!
157  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
158  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
159  return;
160 
161  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
162  SfxItemSet aEditAttr(pOLV->GetAttribs());
163  SfxItemSet aNewAttr(*aEditAttr.GetPool(), aEditAttr.GetRanges());
164 
165  sal_uInt16 nSlot = rReq.GetSlot();
166  sal_uInt16 nWhich = GetPool().GetWhich(nSlot);
167  const SfxItemSet *pNewAttrs = rReq.GetArgs();
168  sal_uInt16 nEEWhich = 0;
169  switch (nSlot)
170  {
171  case SID_PARASPACE_INCREASE:
172  case SID_PARASPACE_DECREASE:
173  {
174  SvxULSpaceItem aULSpace( aEditAttr.Get( EE_PARA_ULSPACE ) );
175  sal_uInt16 nUpper = aULSpace.GetUpper();
176  sal_uInt16 nLower = aULSpace.GetLower();
177 
178  if ( nSlot == SID_PARASPACE_INCREASE )
179  {
180  nUpper = std::min< sal_uInt16 >( nUpper + 57, 5670 );
181  nLower = std::min< sal_uInt16 >( nLower + 57, 5670 );
182  }
183  else
184  {
185  nUpper = std::max< sal_Int16 >( nUpper - 57, 0 );
186  nLower = std::max< sal_Int16 >( nLower - 57, 0 );
187  }
188 
189  aULSpace.SetUpper( nUpper );
190  aULSpace.SetLower( nLower );
191  aNewAttr.Put( aULSpace );
192  rReq.Done();
193  }
194  break;
195  case SID_ATTR_PARA_LRSPACE:
196  {
197  SvxLRSpaceItem aParaMargin(static_cast<const SvxLRSpaceItem&>(rReq.
198  GetArgs()->Get(nSlot)));
199  aParaMargin.SetWhich( EE_PARA_LRSPACE );
200 
201  aNewAttr.Put(aParaMargin);
202  rReq.Done();
203  break;
204  }
205  case SID_ATTR_PARA_LINESPACE:
206  {
207  SvxLineSpacingItem aParaMargin = static_cast<const SvxLineSpacingItem&>(pNewAttrs->Get(
208  GetPool().GetWhich(nSlot)));
209  aParaMargin.SetWhich( EE_PARA_SBL );
210 
211  aNewAttr.Put(aParaMargin);
212  rReq.Done();
213  break;
214  }
215  case SID_ATTR_PARA_ULSPACE:
216  {
217  SvxULSpaceItem aULSpace = static_cast<const SvxULSpaceItem&>(pNewAttrs->Get(
218  GetPool().GetWhich(nSlot)));
219  aULSpace.SetWhich( EE_PARA_ULSPACE );
220  aNewAttr.Put( aULSpace );
221  rReq.Done();
222  }
223  break;
224  case FN_GROW_FONT_SIZE:
225  case FN_SHRINK_FONT_SIZE:
226  {
227  const SvxFontListItem* pFontListItem = static_cast< const SvxFontListItem* >
228  ( SfxObjectShell::Current()->GetItem( SID_ATTR_CHAR_FONTLIST ) );
229  const FontList* pFontList = pFontListItem ? pFontListItem->GetFontList() : nullptr;
230  pOLV->GetEditView().ChangeFontSize( nSlot == FN_GROW_FONT_SIZE, pFontList );
231  }
232  break;
233 
234  case SID_ATTR_CHAR_FONT:
235  case SID_ATTR_CHAR_FONTHEIGHT:
236  case SID_ATTR_CHAR_WEIGHT:
237  case SID_ATTR_CHAR_POSTURE:
238  {
239  SfxItemPool* pSecondPool = aEditAttr.GetPool()->GetSecondaryPool();
240  if( !pSecondPool )
241  pSecondPool = aEditAttr.GetPool();
242  SvxScriptSetItem aSetItem( nSlot, *pSecondPool );
243  aSetItem.PutItemForScriptType( pOLV->GetSelectedScriptType(), pNewAttrs->Get( nWhich ));
244  aNewAttr.Put( aSetItem.GetItemSet() );
245  rReq.Done();
246  break;
247  }
248  case SID_ATTR_CHAR_COLOR: nEEWhich = EE_CHAR_COLOR; break;
249  case SID_ATTR_CHAR_BACK_COLOR: nEEWhich = EE_CHAR_BKGCOLOR; break;
250  case SID_ATTR_CHAR_UNDERLINE:
251  {
252  if( rReq.GetArgs() )
253  {
254  const SvxUnderlineItem* pItem = rReq.GetArg<SvxUnderlineItem>(SID_ATTR_CHAR_UNDERLINE);
255  if (pItem)
256  {
257  aNewAttr.Put(*pItem);
258  }
259  else
260  {
261  FontLineStyle eFU = aEditAttr.Get( EE_CHAR_UNDERLINE ).GetLineStyle();
262  aNewAttr.Put( SvxUnderlineItem( eFU != LINESTYLE_NONE ?LINESTYLE_NONE : LINESTYLE_SINGLE, EE_CHAR_UNDERLINE ) );
263  }
264  }
265  break;
266  }
267  case SID_ATTR_CHAR_OVERLINE:
268  {
269  FontLineStyle eFO = aEditAttr.Get(EE_CHAR_OVERLINE).GetLineStyle();
270  aNewAttr.Put(SvxOverlineItem(eFO == LINESTYLE_SINGLE ? LINESTYLE_NONE : LINESTYLE_SINGLE, EE_CHAR_OVERLINE));
271  break;
272  }
273  case SID_ATTR_CHAR_CONTOUR: nEEWhich = EE_CHAR_OUTLINE; break;
274  case SID_ATTR_CHAR_SHADOWED: nEEWhich = EE_CHAR_SHADOW; break;
275  case SID_ATTR_CHAR_STRIKEOUT: nEEWhich = EE_CHAR_STRIKEOUT; break;
276  case SID_ATTR_CHAR_WORDLINEMODE: nEEWhich = EE_CHAR_WLM; break;
277  case SID_ATTR_CHAR_RELIEF : nEEWhich = EE_CHAR_RELIEF; break;
278  case SID_ATTR_CHAR_LANGUAGE : nEEWhich = EE_CHAR_LANGUAGE;break;
279  case SID_ATTR_CHAR_KERNING : nEEWhich = EE_CHAR_KERNING; break;
280  case SID_ATTR_CHAR_SCALEWIDTH: nEEWhich = EE_CHAR_FONTWIDTH; break;
281  case SID_ATTR_CHAR_AUTOKERN : nEEWhich = EE_CHAR_PAIRKERNING; break;
282  case SID_ATTR_CHAR_ESCAPEMENT: nEEWhich = EE_CHAR_ESCAPEMENT; break;
283  case SID_ATTR_PARA_ADJUST_LEFT:
284  aNewAttr.Put(SvxAdjustItem(SvxAdjust::Left, EE_PARA_JUST));
285  break;
286  case SID_ATTR_PARA_ADJUST_CENTER:
287  aNewAttr.Put(SvxAdjustItem(SvxAdjust::Center, EE_PARA_JUST));
288  break;
289  case SID_ATTR_PARA_ADJUST_RIGHT:
290  aNewAttr.Put(SvxAdjustItem(SvxAdjust::Right, EE_PARA_JUST));
291  break;
292  case SID_ATTR_PARA_ADJUST_BLOCK:
293  aNewAttr.Put(SvxAdjustItem(SvxAdjust::Block, EE_PARA_JUST));
294  break;
295 
296  case SID_ATTR_PARA_LINESPACE_10:
297  {
298  SvxLineSpacingItem aItem(LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL);
299  aItem.SetPropLineSpace(100);
300  aNewAttr.Put(aItem);
301  }
302  break;
303  case SID_ATTR_PARA_LINESPACE_15:
304  {
305  SvxLineSpacingItem aItem(LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL);
306  aItem.SetPropLineSpace(150);
307  aNewAttr.Put(aItem);
308  }
309  break;
310  case SID_ATTR_PARA_LINESPACE_20:
311  {
312  SvxLineSpacingItem aItem(LINE_SPACE_DEFAULT_HEIGHT, EE_PARA_SBL);
313  aItem.SetPropLineSpace(200);
314  aNewAttr.Put(aItem);
315  }
316  break;
317  case SID_SELECTALL:
318  {
319  Outliner * pOutliner = pOLV->GetOutliner();
320  if(pOutliner)
321  {
322  sal_Int32 nParaCount = pOutliner->GetParagraphCount();
323  if (nParaCount > 0)
324  pOLV->SelectRange(0, nParaCount );
325  }
326  break;
327  }
328  case FN_FORMAT_RESET:
329  {
330  pPostItMgr->GetActiveSidebarWin()->ResetAttributes();
331  rReq.Done();
332  break;
333  }
334  case FN_SET_SUPER_SCRIPT:
335  {
336  SvxEscapementItem aItem(EE_CHAR_ESCAPEMENT);
337  SvxEscapement eEsc = static_cast<SvxEscapement>(aEditAttr.Get( EE_CHAR_ESCAPEMENT ).GetEnumValue());
338 
339  if( eEsc == SvxEscapement::Superscript )
340  aItem.SetEscapement( SvxEscapement::Off );
341  else
342  aItem.SetEscapement( SvxEscapement::Superscript );
343  aNewAttr.Put( aItem );
344  }
345  break;
346  case FN_SET_SUB_SCRIPT:
347  {
348  SvxEscapementItem aItem(EE_CHAR_ESCAPEMENT);
349  SvxEscapement eEsc = static_cast<SvxEscapement>(aEditAttr.Get( EE_CHAR_ESCAPEMENT ).GetEnumValue());
350 
351  if( eEsc == SvxEscapement::Subscript )
352  aItem.SetEscapement( SvxEscapement::Off );
353  else
354  aItem.SetEscapement( SvxEscapement::Subscript );
355  aNewAttr.Put( aItem );
356  }
357  break;
358  case SID_HYPERLINK_SETLINK:
359  {
360  const SfxPoolItem* pItem = nullptr;
361  if(pNewAttrs)
362  pNewAttrs->GetItemState(nSlot, false, &pItem);
363 
364  if(pItem)
365  {
366  const SvxHyperlinkItem& rHLinkItem = *static_cast<const SvxHyperlinkItem *>(pItem);
367  SvxURLField aField(rHLinkItem.GetURL(), rHLinkItem.GetName(), SvxURLFormat::AppDefault);
368  aField.SetTargetFrame(rHLinkItem.GetTargetFrame());
369 
370  const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection();
371 
372  if (pFieldItem && dynamic_cast<const SvxURLField *>(pFieldItem->GetField()) != nullptr)
373  {
374  // Select the field so that it will be deleted during insert
375  ESelection aSel = pOLV->GetSelection();
376  aSel.nEndPos++;
377  pOLV->SetSelection(aSel);
378  }
379  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
380  pOLV->InsertField(SvxFieldItem(aField, EE_FEATURE_FIELD));
381  }
382  break;
383  }
384  case FN_INSERT_SOFT_HYPHEN:
385  case FN_INSERT_HARDHYPHEN:
386  case FN_INSERT_HARD_SPACE:
387  case FN_INSERT_NNBSP:
388  case SID_INSERT_RLM :
389  case SID_INSERT_LRM :
390  case SID_INSERT_ZWNBSP :
391  case SID_INSERT_ZWSP:
392  {
393  sal_Unicode cIns = 0;
394  switch(rReq.GetSlot())
395  {
396  case FN_INSERT_SOFT_HYPHEN: cIns = CHAR_SOFTHYPHEN; break;
397  case FN_INSERT_HARDHYPHEN: cIns = CHAR_HARDHYPHEN; break;
398  case FN_INSERT_HARD_SPACE: cIns = CHAR_HARDBLANK; break;
399  case FN_INSERT_NNBSP: cIns = CHAR_NNBSP; break;
400  case SID_INSERT_RLM : cIns = CHAR_RLM ; break;
401  case SID_INSERT_LRM : cIns = CHAR_LRM ; break;
402  case SID_INSERT_ZWSP : cIns = CHAR_ZWSP ; break;
403  case SID_INSERT_ZWNBSP: cIns = CHAR_ZWNBSP; break;
404  }
405  pOLV->InsertText( OUString(cIns));
406  rReq.Done();
407  break;
408  }
409  case SID_CHARMAP:
410  {
411  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
412  InsertSymbol(rReq);
413  break;
414  }
415  case FN_INSERT_STRING:
416  {
417  const SfxPoolItem* pItem = nullptr;
418  if (pNewAttrs)
419  pNewAttrs->GetItemState(nSlot, false, &pItem );
420  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
421  pOLV->InsertText(static_cast<const SfxStringItem *>(pItem)->GetValue());
422  break;
423  }
424  case FN_FORMAT_FOOTNOTE_DLG:
425  {
426  rView.ExecFormatFootnote();
427  break;
428  }
429  case FN_NUMBERING_OUTLINE_DLG:
430  {
431  rView.ExecNumberingOutline(GetPool());
432  rReq.Done();
433  }
434  break;
435  case SID_OPEN_XML_FILTERSETTINGS:
436  {
437  HandleOpenXmlFilterSettings(rReq);
438  }
439  break;
440  case FN_WORDCOUNT_DIALOG:
441  {
442  rView.UpdateWordCount(this, nSlot);
443  break;
444  }
445  case SID_CHAR_DLG_EFFECT:
446  case SID_CHAR_DLG:
447  {
448  const SfxItemSet* pArgs = rReq.GetArgs();
449  const SfxStringItem* pItem = rReq.GetArg<SfxStringItem>(FN_PARAM_1);
450 
451  if( !pArgs || pItem )
452  {
453  /* mod
454  SwView* pView = &GetView();
455  FieldUnit eMetric = ::GetDfltMetric(dynamic_cast<SwWebView*>( pView) != nullptr );
456  SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, eMetric));
457  */
458  SfxItemSet aDlgAttr(GetPool(), svl::Items<XATTR_FILLSTYLE, XATTR_FILLCOLOR, EE_ITEMS_START, EE_ITEMS_END>{});
459 
460  // util::Language does not exist in the EditEngine! Therefore not included in the set.
461 
462  aDlgAttr.Put( aEditAttr );
463  aDlgAttr.Put( SvxKerningItem(0, RES_CHRATR_KERNING) );
464 
465  SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
466  ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSwCharDlg(rView.GetFrameWeld(), rView, aDlgAttr, SwCharDlgMode::Ann));
467  if (nSlot == SID_CHAR_DLG_EFFECT)
468  {
469  pDlg->SetCurPageId("fonteffects");
470  }
471  else if (pItem)
472  {
473  pDlg->SetCurPageId(OUStringToOString(pItem->GetValue(), RTL_TEXTENCODING_UTF8));
474  }
475 
476  sal_uInt16 nRet = pDlg->Execute();
477  if(RET_OK == nRet )
478  {
479  rReq.Done( *( pDlg->GetOutputItemSet() ) );
480  aNewAttr.Put(*pDlg->GetOutputItemSet());
481  }
482  if(RET_OK != nRet)
483  return ;
484  }
485  else
486  aNewAttr.Put(*pArgs);
487  break;
488  }
489  case SID_PARA_DLG:
490  {
491  const SfxItemSet* pArgs = rReq.GetArgs();
492 
493  if (!pArgs)
494  {
495  /* mod todo ???
496  SwView* pView = &GetView();
497  FieldUnit eMetric = ::GetDfltMetric(dynamic_cast<SwWebView*>( pView) != nullptr );
498  SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, eMetric));
499  */
500  SfxItemSet aDlgAttr(
501  GetPool(),
502  svl::Items<
503  EE_ITEMS_START, EE_ITEMS_END,
504  SID_ATTR_PARA_HYPHENZONE, SID_ATTR_PARA_WIDOWS>{});
505 
506  aDlgAttr.Put(aEditAttr);
507 
508  aDlgAttr.Put( SvxHyphenZoneItem( false, RES_PARATR_HYPHENZONE) );
509  aDlgAttr.Put( SvxFormatBreakItem( SvxBreak::NONE, RES_BREAK ) );
510  aDlgAttr.Put( SvxFormatSplitItem( true, RES_PARATR_SPLIT ) );
511  aDlgAttr.Put( SvxWidowsItem( 0, RES_PARATR_WIDOWS ) );
512  aDlgAttr.Put( SvxOrphansItem( 0, RES_PARATR_ORPHANS ) );
513 
514  SwAbstractDialogFactory* pFact = SwAbstractDialogFactory::Create();
515  ScopedVclPtr<SfxAbstractTabDialog> pDlg(pFact->CreateSwParaDlg(rView.GetFrameWeld(), rView, aDlgAttr, true));
516  sal_uInt16 nRet = pDlg->Execute();
517  if(RET_OK == nRet)
518  {
519  rReq.Done( *( pDlg->GetOutputItemSet() ) );
520  aNewAttr.Put(*pDlg->GetOutputItemSet());
521  }
522  if(RET_OK != nRet)
523  return;
524  }
525  else
526  aNewAttr.Put(*pArgs);
527  break;
528  }
529 
530  case SID_AUTOSPELL_CHECK:
531  {
532  rView.ExecuteSlot(rReq);
533  break;
534  }
535  case SID_ATTR_PARA_LEFT_TO_RIGHT:
536  case SID_ATTR_PARA_RIGHT_TO_LEFT:
537  {
538  bool bLeftToRight = nSlot == SID_ATTR_PARA_LEFT_TO_RIGHT;
539 
540  const SfxPoolItem* pPoolItem;
541  if( pNewAttrs && SfxItemState::SET == pNewAttrs->GetItemState( nSlot, true, &pPoolItem ) )
542  {
543  if( !static_cast<const SfxBoolItem*>(pPoolItem)->GetValue() )
544  bLeftToRight = !bLeftToRight;
545  }
546  SfxItemSet aAttr(
547  *aNewAttr.GetPool(),
548  svl::Items<
549  EE_PARA_WRITINGDIR, EE_PARA_WRITINGDIR,
550  EE_PARA_JUST, EE_PARA_JUST>{});
551 
552  SvxAdjust nAdjust = SvxAdjust::Left;
553  if( SfxItemState::SET == aEditAttr.GetItemState(EE_PARA_JUST, true, &pPoolItem ) )
554  nAdjust = static_cast<const SvxAdjustItem*>(pPoolItem)->GetAdjust();
555 
556  if( bLeftToRight )
557  {
558  aAttr.Put( SvxFrameDirectionItem( SvxFrameDirection::Horizontal_LR_TB, EE_PARA_WRITINGDIR ) );
559  if( nAdjust == SvxAdjust::Right )
560  aAttr.Put( SvxAdjustItem( SvxAdjust::Left, EE_PARA_JUST ) );
561  }
562  else
563  {
564  aAttr.Put( SvxFrameDirectionItem( SvxFrameDirection::Horizontal_RL_TB, EE_PARA_WRITINGDIR ) );
565  if( nAdjust == SvxAdjust::Left )
566  aAttr.Put( SvxAdjustItem( SvxAdjust::Right, EE_PARA_JUST ) );
567  }
568  pOLV->SetAttribs(aAttr);
569  break;
570  }
571  }
572 
573  if(nEEWhich && pNewAttrs)
574  {
575  aNewAttr.Put(pNewAttrs->Get(nWhich).CloneSetWhich(nEEWhich));
576  }
577 
578  tools::Rectangle aOutRect = pOLV->GetOutputArea();
579  if (tools::Rectangle() != aOutRect)
580  pOLV->SetAttribs(aNewAttr);
581 
582  rView.GetViewFrame()->GetBindings().InvalidateAll(false);
583  if ( pOLV->GetOutliner()->IsModified() )
584  rView.GetWrtShell().SetModified();
585 
586 }
587 
588 void SwAnnotationShell::GetState(SfxItemSet& rSet)
589 {
590  //TODO: clean this up!!!
591  // FN_SET_SUPER_SCRIPT
592  //SID_ATTR_PARA_ADJUST
593  //SID_ATTR_PARA_ADJUST_BLOCK
594 
595  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
596  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
597  return;
598 
599  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
600  SfxItemSet aEditAttr(pOLV->GetAttribs());
601 
602  SfxWhichIter aIter(rSet);
603  sal_uInt16 nWhich = aIter.FirstWhich();
604  while(nWhich)
605  {
606  sal_uInt16 nEEWhich = 0;
607  sal_uInt16 nSlotId = GetPool().GetSlotId( nWhich );
608  switch( nSlotId )
609  {
610  case SID_ATTR_PARA_LRSPACE:
611  case SID_ATTR_PARA_LEFTSPACE:
612  case SID_ATTR_PARA_RIGHTSPACE:
613  case SID_ATTR_PARA_FIRSTLINESPACE:
614  {
615  SfxItemState eState = aEditAttr.GetItemState( EE_PARA_LRSPACE );
616  if( eState >= SfxItemState::DEFAULT )
617  {
618  SvxLRSpaceItem aLR = aEditAttr.Get( EE_PARA_LRSPACE );
619  aLR.SetWhich(nSlotId);
620  rSet.Put(aLR);
621  }
622  else
623  rSet.InvalidateItem(nSlotId);
624  }
625  break;
626  case SID_ATTR_PARA_LINESPACE:
627  {
628  SfxItemState eState = aEditAttr.GetItemState( EE_PARA_SBL );
629  if( eState >= SfxItemState::DEFAULT )
630  {
631  const SvxLineSpacingItem& aLR = aEditAttr.Get( EE_PARA_SBL );
632  rSet.Put(aLR);
633  }
634  else
635  rSet.InvalidateItem(nSlotId);
636  }
637  break;
638  case SID_ATTR_PARA_ULSPACE:
639  case SID_ATTR_PARA_ABOVESPACE:
640  case SID_ATTR_PARA_BELOWSPACE:
641  case SID_PARASPACE_INCREASE:
642  case SID_PARASPACE_DECREASE:
643  {
644  SfxItemState eState = aEditAttr.GetItemState( EE_PARA_ULSPACE );
645  if( eState >= SfxItemState::DEFAULT )
646  {
647  SvxULSpaceItem aULSpace = aEditAttr.Get( EE_PARA_ULSPACE );
648  if ( !aULSpace.GetUpper() && !aULSpace.GetLower() )
649  rSet.DisableItem( SID_PARASPACE_DECREASE );
650  else if ( aULSpace.GetUpper() >= 5670 && aULSpace.GetLower() >= 5670 )
651  rSet.DisableItem( SID_PARASPACE_INCREASE );
652  if ( nSlotId == SID_ATTR_PARA_ULSPACE
653  || nSlotId == SID_ATTR_PARA_BELOWSPACE
654  || nSlotId == SID_ATTR_PARA_ABOVESPACE
655  )
656  {
657  aULSpace.SetWhich(nSlotId);
658  rSet.Put(aULSpace);
659  }
660  }
661  else
662  {
663  rSet.DisableItem( SID_PARASPACE_INCREASE );
664  rSet.DisableItem( SID_PARASPACE_DECREASE );
665  rSet.InvalidateItem( SID_ATTR_PARA_ULSPACE );
666  rSet.InvalidateItem( SID_ATTR_PARA_ABOVESPACE );
667  rSet.InvalidateItem( SID_ATTR_PARA_BELOWSPACE );
668  }
669  }
670  break;
671  case SID_ATTR_CHAR_FONT:
672  case SID_ATTR_CHAR_FONTHEIGHT:
673  case SID_ATTR_CHAR_WEIGHT:
674  case SID_ATTR_CHAR_POSTURE:
675  {
676  SvtScriptType nScriptType = pOLV->GetSelectedScriptType();
677  SfxItemPool* pSecondPool = aEditAttr.GetPool()->GetSecondaryPool();
678  if( !pSecondPool )
679  pSecondPool = aEditAttr.GetPool();
680  SvxScriptSetItem aSetItem( nSlotId, *pSecondPool );
681  aSetItem.GetItemSet().Put( aEditAttr, false );
682  const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScriptType );
683  if( pI )
684  {
685  rSet.Put(pI->CloneSetWhich(nWhich));
686  }
687  else
688  rSet.InvalidateItem( nWhich );
689  }
690  break;
691  case SID_ATTR_CHAR_COLOR: nEEWhich = EE_CHAR_COLOR; break;
692  case SID_ATTR_CHAR_BACK_COLOR: nEEWhich = EE_CHAR_BKGCOLOR; break;
693  case SID_ATTR_CHAR_UNDERLINE: nEEWhich = EE_CHAR_UNDERLINE;break;
694  case SID_ATTR_CHAR_OVERLINE: nEEWhich = EE_CHAR_OVERLINE;break;
695  case SID_ATTR_CHAR_CONTOUR: nEEWhich = EE_CHAR_OUTLINE; break;
696  case SID_ATTR_CHAR_SHADOWED: nEEWhich = EE_CHAR_SHADOW;break;
697  case SID_ATTR_CHAR_STRIKEOUT: nEEWhich = EE_CHAR_STRIKEOUT;break;
698  case SID_ATTR_CHAR_LANGUAGE : nEEWhich = EE_CHAR_LANGUAGE;break;
699  case SID_ATTR_CHAR_ESCAPEMENT: nEEWhich = EE_CHAR_ESCAPEMENT;break;
700  case SID_ATTR_CHAR_KERNING: nEEWhich = EE_CHAR_KERNING;break;
701  case FN_SET_SUPER_SCRIPT:
702  case FN_SET_SUB_SCRIPT:
703  {
704  SvxEscapement nEsc;
705  if (nWhich==FN_SET_SUPER_SCRIPT)
706  nEsc = SvxEscapement::Superscript;
707  else
708  nEsc = SvxEscapement::Subscript;
709 
710  const SfxPoolItem *pEscItem = &aEditAttr.Get( EE_CHAR_ESCAPEMENT );
711  if( nEsc == static_cast<const SvxEscapementItem*>(pEscItem)->GetEscapement() )
712  rSet.Put( SfxBoolItem( nWhich, true ));
713  else
714  rSet.InvalidateItem( nWhich );
715  break;
716  }
717  case SID_ATTR_PARA_ADJUST_LEFT:
718  case SID_ATTR_PARA_ADJUST_RIGHT:
719  case SID_ATTR_PARA_ADJUST_CENTER:
720  case SID_ATTR_PARA_ADJUST_BLOCK:
721  {
722  SvxAdjust eAdjust = SvxAdjust::Left;
723  if (nWhich==SID_ATTR_PARA_ADJUST_LEFT)
724  eAdjust = SvxAdjust::Left;
725  else if (nWhich==SID_ATTR_PARA_ADJUST_RIGHT)
726  eAdjust = SvxAdjust::Right;
727  else if (nWhich==SID_ATTR_PARA_ADJUST_CENTER)
728  eAdjust = SvxAdjust::Center;
729  else if (nWhich==SID_ATTR_PARA_ADJUST_BLOCK)
730  eAdjust = SvxAdjust::Block;
731 
732  const SfxPoolItem *pAdjust = nullptr;
733  aEditAttr.GetItemState( EE_PARA_JUST, false, &pAdjust);
734 
735  if( !pAdjust || IsInvalidItem( pAdjust ))
736  {
737  rSet.InvalidateItem( nSlotId );
738  }
739  else
740  {
741  if ( eAdjust == static_cast<const SvxAdjustItem*>(pAdjust)->GetAdjust())
742  rSet.Put( SfxBoolItem( nWhich, true ));
743  else
744  rSet.InvalidateItem( nWhich );
745  }
746  break;
747  }
748  case SID_ATTR_PARA_LINESPACE_10:
749  case SID_ATTR_PARA_LINESPACE_15:
750  case SID_ATTR_PARA_LINESPACE_20:
751  {
752  int nLSpace = 0;
753  if (nWhich==SID_ATTR_PARA_LINESPACE_10)
754  nLSpace = 100;
755  else if (nWhich==SID_ATTR_PARA_LINESPACE_15)
756  nLSpace = 150;
757  else if (nWhich==SID_ATTR_PARA_LINESPACE_20)
758  nLSpace = 200;
759 
760  const SfxPoolItem *pLSpace = nullptr;
761  aEditAttr.GetItemState( EE_PARA_SBL, false, &pLSpace );
762 
763  if( !pLSpace || IsInvalidItem( pLSpace ))
764  {
765  rSet.InvalidateItem( nSlotId );
766  }
767  else
768  {
769  if( nLSpace == static_cast<const SvxLineSpacingItem*>(pLSpace)->GetPropLineSpace() )
770  rSet.Put( SfxBoolItem( nWhich, true ));
771  else
772  rSet.InvalidateItem( nWhich );
773  }
774  break;
775  }
776  case SID_AUTOSPELL_CHECK:
777  {
778  const SfxPoolItem* pState = rView.GetSlotState(nWhich);
779  if (pState)
780  rSet.Put(SfxBoolItem(nWhich, static_cast<const SfxBoolItem*>(pState)->GetValue()));
781  else
782  rSet.DisableItem( nWhich );
783  break;
784  }
785  case SID_ATTR_PARA_LEFT_TO_RIGHT:
786  case SID_ATTR_PARA_RIGHT_TO_LEFT:
787  {
788  if ( !SvtLanguageOptions().IsCTLFontEnabled() )
789  rSet.DisableItem( nWhich );
790  else
791  {
792  if(pOLV->GetOutliner() && pOLV->GetOutliner()->IsVertical())
793  rSet.DisableItem( nWhich );
794  else
795  {
796  bool bFlag = false;
797  switch( aEditAttr.Get( EE_PARA_WRITINGDIR ).GetValue() )
798  {
799  case SvxFrameDirection::Horizontal_LR_TB:
800  {
801  bFlag = nWhich == SID_ATTR_PARA_LEFT_TO_RIGHT;
802  rSet.Put( SfxBoolItem( nWhich, bFlag ));
803  break;
804  }
805  case SvxFrameDirection::Horizontal_RL_TB:
806  {
807  bFlag = nWhich != SID_ATTR_PARA_LEFT_TO_RIGHT;
808  rSet.Put( SfxBoolItem( nWhich, bFlag ));
809  break;
810  }
811  default:
812  break;
813  }
814  }
815  }
816  }
817  break;
818  case SID_INSERT_RLM :
819  case SID_INSERT_LRM :
820  {
821  SvtCTLOptions aCTLOptions;
822  bool bEnabled = aCTLOptions.IsCTLFontEnabled();
823  rView.GetViewFrame()->GetBindings().SetVisibleState( nWhich, bEnabled );
824  if(!bEnabled)
825  rSet.DisableItem(nWhich);
826  }
827  break;
828  default:
829  rSet.InvalidateItem( nWhich );
830  break;
831  }
832 
833  if(nEEWhich)
834  {
835  rSet.Put(aEditAttr.Get(nEEWhich).CloneSetWhich(nWhich));
836  if(nEEWhich == EE_CHAR_KERNING)
837  {
838  SfxItemState eState = aEditAttr.GetItemState( EE_CHAR_KERNING );
839  if ( eState == SfxItemState::DONTCARE )
840  {
841  rSet.InvalidateItem(EE_CHAR_KERNING);
842  }
843  }
844  }
845 
846  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()==SwPostItHelper::DELETED)
847  rSet.DisableItem( nWhich );
848 
849  nWhich = aIter.NextWhich();
850  }
851 }
852 
853 void SwAnnotationShell::ExecSearch(SfxRequest& rReq)
854 {
855  rView.ExecSearch(rReq);
856 }
857 
858 void SwAnnotationShell::StateSearch(SfxItemSet &rSet)
859 {
860  rView.StateSearch(rSet);
861 }
862 
863 void SwAnnotationShell::ExecClpbrd(SfxRequest const &rReq)
864 {
865  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
866  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
867  return;
868 
869  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
870 
871  long aOldHeight = pPostItMgr->GetActiveSidebarWin()->GetPostItTextHeight();
872  sal_uInt16 nSlot = rReq.GetSlot();
873  switch (nSlot)
874  {
875  case SID_CUT:
876  if ( (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED) && pOLV->HasSelection() )
877  pOLV->Cut();
878  break;
879  case SID_COPY:
880  if( pOLV->HasSelection() )
881  pOLV->Copy();
882  break;
883  case SID_PASTE:
884  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
885  pOLV->PasteSpecial();
886  break;
887  case SID_PASTE_UNFORMATTED:
888  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
889  pOLV->Paste();
890  break;
891  case SID_PASTE_SPECIAL:
892  {
893  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED)
894  {
895  SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
896  ScopedVclPtr<SfxAbstractPasteDialog> pDlg(pFact->CreatePasteDialog(rView.GetEditWin().GetFrameWeld()));
897 
898  pDlg->Insert( SotClipboardFormatId::STRING, OUString() );
899  pDlg->Insert( SotClipboardFormatId::RTF, OUString() );
900  pDlg->Insert( SotClipboardFormatId::RICHTEXT, OUString() );
901 
902  TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( &rView.GetEditWin() ) );
903 
904  SotClipboardFormatId nFormat = pDlg->GetFormat( aDataHelper.GetTransferable() );
905 
906  if (nFormat != SotClipboardFormatId::NONE)
907  {
908  if (nFormat == SotClipboardFormatId::STRING)
909  pOLV->Paste();
910  else
911  pOLV->PasteSpecial();
912  }
913  }
914  break;
915  }
916  case SID_CLIPBOARD_FORMAT_ITEMS:
917  {
918  SotClipboardFormatId nFormat = SotClipboardFormatId::NONE;
919  const SfxPoolItem* pItem;
920  if (rReq.GetArgs() && rReq.GetArgs()->GetItemState(nSlot, true, &pItem) == SfxItemState::SET)
921  {
922  if (const SfxUInt32Item* pUInt32Item = dynamic_cast<const SfxUInt32Item *>(pItem))
923  nFormat = static_cast<SotClipboardFormatId>(pUInt32Item->GetValue());
924  }
925 
926  if ( nFormat != SotClipboardFormatId::NONE )
927  {
928  if (SotClipboardFormatId::STRING == nFormat)
929  pOLV->Paste();
930  else
931  pOLV->PasteSpecial();
932  }
933  break;
934  }
935  }
936  pPostItMgr->GetActiveSidebarWin()->ResizeIfNecessary(aOldHeight,pPostItMgr->GetActiveSidebarWin()->GetPostItTextHeight());
937 }
938 
939 void SwAnnotationShell::StateClpbrd(SfxItemSet &rSet)
940 {
941  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
942  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
943  return;
944  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
945 
946  TransferableDataHelper aDataHelper( TransferableDataHelper::CreateFromSystemClipboard( &rView.GetEditWin() ) );
947  bool bPastePossible = ( aDataHelper.HasFormat( SotClipboardFormatId::STRING ) || aDataHelper.HasFormat( SotClipboardFormatId::RTF )
948  || aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ));
949  bPastePossible = bPastePossible && (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()!=SwPostItHelper::DELETED);
950 
951  SfxWhichIter aIter(rSet);
952  sal_uInt16 nWhich = aIter.FirstWhich();
953 
954  while(nWhich)
955  {
956  switch(nWhich)
957  {
958  case SID_CUT:
959  {
960  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus() == SwPostItHelper::DELETED)
961  rSet.DisableItem( nWhich );
962  [[fallthrough]];
963  }
964  case SID_COPY:
965  {
966  SfxObjectShell* pObjectShell = GetObjectShell();
967  if (!pOLV->HasSelection() || (pObjectShell && pObjectShell->isContentExtractionLocked()) )
968  rSet.DisableItem( nWhich );
969  break;
970  }
971  case SID_PASTE:
972  case SID_PASTE_UNFORMATTED:
973  case SID_PASTE_SPECIAL:
974  {
975  if( !bPastePossible )
976  rSet.DisableItem( nWhich );
977  break;
978  }
979  case SID_CLIPBOARD_FORMAT_ITEMS:
980  {
981  if ( bPastePossible )
982  {
983  SvxClipboardFormatItem aFormats( SID_CLIPBOARD_FORMAT_ITEMS );
984  if ( aDataHelper.HasFormat( SotClipboardFormatId::RTF ) )
985  aFormats.AddClipbrdFormat( SotClipboardFormatId::RTF );
986  if ( aDataHelper.HasFormat( SotClipboardFormatId::RICHTEXT ) )
987  aFormats.AddClipbrdFormat( SotClipboardFormatId::RICHTEXT );
988  aFormats.AddClipbrdFormat( SotClipboardFormatId::STRING );
989  rSet.Put( aFormats );
990  }
991  else
992  rSet.DisableItem( nWhich );
993  break;
994  }
995  }
996  nWhich = aIter.NextWhich();
997  }
998 }
999 
1000 void SwAnnotationShell::StateStatusLine(SfxItemSet &rSet)
1001 {
1002  SfxWhichIter aIter( rSet );
1003  sal_uInt16 nWhich = aIter.FirstWhich();
1004 
1005  while( nWhich )
1006  {
1007  switch( nWhich )
1008  {
1009  case FN_STAT_SELMODE:
1010  {
1011  rSet.Put(SfxUInt16Item(FN_STAT_SELMODE, 0));
1012  rSet.DisableItem( nWhich );
1013  break;
1014  }
1015  case FN_STAT_TEMPLATE:
1016  {
1017  rSet.DisableItem( nWhich );
1018  break;
1019  }
1020  }
1021  nWhich = aIter.NextWhich();
1022  }
1023 }
1024 
1025 void SwAnnotationShell::StateInsert(SfxItemSet &rSet)
1026 {
1027  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1028  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
1029  return;
1030 
1031  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1032  SfxWhichIter aIter(rSet);
1033  sal_uInt16 nWhich = aIter.FirstWhich();
1034 
1035  while(nWhich)
1036  {
1037  switch(nWhich)
1038  {
1039  case SID_HYPERLINK_GETLINK:
1040  {
1041  SvxHyperlinkItem aHLinkItem;
1042  aHLinkItem.SetInsertMode(HLINK_FIELD);
1043 
1044  const SvxFieldItem* pFieldItem = pOLV->GetFieldAtSelection();
1045 
1046  if (pFieldItem)
1047  {
1048  if (const SvxURLField* pURLField = dynamic_cast<const SvxURLField *>(pFieldItem->GetField()))
1049  {
1050  aHLinkItem.SetName(pURLField->GetRepresentation());
1051  aHLinkItem.SetURL(pURLField->GetURL());
1052  aHLinkItem.SetTargetFrame(pURLField->GetTargetFrame());
1053  }
1054  }
1055  else
1056  {
1057  OUString sSel(pOLV->GetSelected());
1058  sSel = sSel.copy(0, std::min<sal_Int32>(255, sSel.getLength()));
1059  aHLinkItem.SetName(comphelper::string::stripEnd(sSel, ' '));
1060  }
1061 
1062  sal_uInt16 nHtmlMode = ::GetHtmlMode(rView.GetDocShell());
1063  aHLinkItem.SetInsertMode(static_cast<SvxLinkInsertMode>(aHLinkItem.GetInsertMode() |
1064  ((nHtmlMode & HTMLMODE_ON) != 0 ? HLINK_HTMLMODE : 0)));
1065 
1066  rSet.Put(aHLinkItem);
1067  }
1068  break;
1069  }
1070 
1071  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()==SwPostItHelper::DELETED)
1072  rSet.DisableItem( nWhich );
1073 
1074  nWhich = aIter.NextWhich();
1075  }
1076 }
1077 
1078 void SwAnnotationShell::NoteExec(SfxRequest const &rReq)
1079 {
1080  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1081  if ( !pPostItMgr )
1082  return;
1083 
1084  sal_uInt16 nSlot = rReq.GetSlot();
1085  switch (nSlot)
1086  {
1087  case FN_REPLY:
1088  case FN_POSTIT:
1089  case FN_DELETE_COMMENT:
1090  case FN_RESOLVE_NOTE:
1091  if ( pPostItMgr->HasActiveSidebarWin() )
1092  pPostItMgr->GetActiveSidebarWin()->ExecuteCommand(nSlot);
1093  break;
1094  case FN_DELETE_ALL_NOTES:
1095  pPostItMgr->Delete();
1096  break;
1097  case FN_FORMAT_ALL_NOTES:
1098  pPostItMgr->ExecuteFormatAllDialog(rView);
1099  break;
1100  case FN_DELETE_NOTE_AUTHOR:
1101  {
1102  const SfxStringItem* pItem = rReq.GetArg<SfxStringItem>(nSlot);
1103  if ( pItem )
1104  pPostItMgr->Delete( pItem->GetValue() );
1105  else if ( pPostItMgr->HasActiveSidebarWin() )
1106  pPostItMgr->Delete( pPostItMgr->GetActiveSidebarWin()->GetAuthor() );
1107  break;
1108  }
1109  case FN_HIDE_NOTE:
1110  break;
1111  case FN_HIDE_ALL_NOTES:
1112  pPostItMgr->Hide();
1113  break;
1114  case FN_HIDE_NOTE_AUTHOR:
1115  {
1116  const SfxStringItem* pItem = rReq.GetArg<SfxStringItem>(nSlot);
1117  if ( pItem )
1118  pPostItMgr->Hide( pItem->GetValue() );
1119  else if ( pPostItMgr->HasActiveSidebarWin() )
1120  pPostItMgr->Hide( pPostItMgr->GetActiveSidebarWin()->GetAuthor() );
1121  }
1122  }
1123 }
1124 
1125 void SwAnnotationShell::GetNoteState(SfxItemSet &rSet)
1126 {
1127  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1128  SfxWhichIter aIter(rSet);
1129  sal_uInt16 nWhich = aIter.FirstWhich();
1130  while(nWhich)
1131  {
1132  sal_uInt16 nSlotId = GetPool().GetSlotId( nWhich );
1133  switch( nSlotId )
1134  {
1135  case FN_POSTIT:
1136  case FN_DELETE_ALL_NOTES:
1137  case FN_FORMAT_ALL_NOTES:
1138  case FN_HIDE_NOTE:
1139  case FN_HIDE_ALL_NOTES:
1140  case FN_DELETE_COMMENT:
1141  {
1142  if( !pPostItMgr
1143  || !pPostItMgr->HasActiveAnnotationWin() )
1144  {
1145  rSet.DisableItem(nWhich);
1146  }
1147  break;
1148  }
1149  case FN_RESOLVE_NOTE:
1150  {
1151  if( !pPostItMgr
1152  || !pPostItMgr->HasActiveAnnotationWin() )
1153  {
1154  rSet.DisableItem(nWhich);
1155  }
1156  else
1157  {
1158  SfxBoolItem aBool(nWhich, pPostItMgr->GetActiveSidebarWin()->IsResolved());
1159  rSet.Put( aBool );
1160  }
1161  break;
1162  }
1163  case FN_DELETE_NOTE_AUTHOR:
1164  case FN_HIDE_NOTE_AUTHOR:
1165  {
1166  if( !pPostItMgr
1167  || !pPostItMgr->HasActiveAnnotationWin() )
1168  {
1169  rSet.DisableItem(nWhich);
1170  }
1171  else
1172  {
1173  OUString aText( nSlotId == FN_DELETE_NOTE_AUTHOR ?
1174  SwResId( STR_DELETE_NOTE_AUTHOR ) : SwResId( STR_HIDE_NOTE_AUTHOR ) );
1175  SwRewriter aRewriter;
1176  aRewriter.AddRule( UndoArg1, pPostItMgr->GetActiveSidebarWin()->GetAuthor() );
1177  aText = aRewriter.Apply( aText );
1178  SfxStringItem aItem( nSlotId, aText );
1179  rSet.Put( aItem );
1180  }
1181  break;
1182  }
1183  case FN_REPLY:
1184  {
1185  if ( !pPostItMgr ||
1186  !pPostItMgr->HasActiveAnnotationWin() )
1187  {
1188  rSet.DisableItem(nWhich);
1189  }
1190  else
1191  {
1192  SvtUserOptions aUserOpt;
1193  OUString sAuthor;
1194  if( (sAuthor = aUserOpt.GetFullName()).isEmpty() &&
1195  (sAuthor = aUserOpt.GetID()).isEmpty() )
1196  sAuthor = SwResId( STR_REDLINE_UNKNOWN_AUTHOR );
1197  if (sAuthor == pPostItMgr->GetActiveSidebarWin()->GetAuthor())
1198  rSet.DisableItem(nWhich);
1199  }
1200  break;
1201  }
1202  default:
1203  rSet.InvalidateItem( nWhich );
1204  break;
1205  }
1206 
1207  if (pPostItMgr && pPostItMgr->HasActiveSidebarWin())
1208  {
1209  if ( (pPostItMgr->GetActiveSidebarWin()->IsProtected()) &&
1210  ( (nSlotId==FN_DELETE_COMMENT) || (nSlotId==FN_REPLY) ) )
1211  rSet.DisableItem( nWhich );
1212  }
1213  nWhich = aIter.NextWhich();
1214  }
1215 }
1216 
1217 void SwAnnotationShell::ExecLingu(SfxRequest &rReq)
1218 {
1219  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1220  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
1221  return;
1222 
1223  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1224  sal_uInt16 nSlot = rReq.GetSlot();
1225  SwWrtShell &rSh = rView.GetWrtShell();
1226  bool bRestoreSelection = false;
1227  ESelection aOldSelection;
1228 
1229  switch (nSlot)
1230  {
1231  case SID_LANGUAGE_STATUS:
1232  {
1233  aOldSelection = pOLV->GetSelection();
1234  if (!pOLV->GetEditView().HasSelection())
1235  {
1236  pOLV->GetEditView().SelectCurrentWord();
1237  }
1238 
1239  bRestoreSelection = SwLangHelper::SetLanguageStatus(pOLV,rReq,rView,rSh);
1240  break;
1241  }
1242  case SID_THES:
1243  {
1244  OUString aReplaceText;
1245  const SfxStringItem* pItem2 = rReq.GetArg<SfxStringItem>(SID_THES);
1246  if (pItem2)
1247  aReplaceText = pItem2->GetValue();
1248  if (!aReplaceText.isEmpty())
1249  ReplaceTextWithSynonym( pOLV->GetEditView(), aReplaceText );
1250  break;
1251  }
1252  case SID_THESAURUS:
1253  {
1254  pOLV->StartThesaurus();
1255  break;
1256  }
1257  case SID_HANGUL_HANJA_CONVERSION:
1258  pOLV->StartTextConversion( LANGUAGE_KOREAN, LANGUAGE_KOREAN, nullptr,
1259  i18n::TextConversionOption::CHARACTER_BY_CHARACTER, true, false );
1260  break;
1261 
1262  case SID_CHINESE_CONVERSION:
1263  {
1264  //open ChineseTranslationDialog
1265  Reference< XComponentContext > xContext(
1266  ::cppu::defaultBootstrap_InitialComponentContext() ); //@todo get context from calc if that has one
1267  if(xContext.is())
1268  {
1269  Reference< lang::XMultiComponentFactory > xMCF( xContext->getServiceManager() );
1270  if(xMCF.is())
1271  {
1272  Reference< ui::dialogs::XExecutableDialog > xDialog(
1273  xMCF->createInstanceWithContext(
1274  "com.sun.star.linguistic2.ChineseTranslationDialog", xContext),
1275  UNO_QUERY);
1276  Reference< lang::XInitialization > xInit( xDialog, UNO_QUERY );
1277  if( xInit.is() )
1278  {
1279  // initialize dialog
1280  uno::Sequence<uno::Any> aSeq(comphelper::InitAnyPropertySequence(
1281  {
1282  {"ParentWindow", uno::Any(Reference<awt::XWindow>())}
1283  }));
1284  xInit->initialize( aSeq );
1285 
1286  //execute dialog
1287  sal_Int16 nDialogRet = xDialog->execute();
1288  if( RET_OK == nDialogRet )
1289  {
1290  //get some parameters from the dialog
1291  bool bToSimplified = true;
1292  bool bUseVariants = true;
1293  bool bCommonTerms = true;
1294  Reference< beans::XPropertySet > xProp( xDialog, UNO_QUERY );
1295  if( xProp.is() )
1296  {
1297  try
1298  {
1299  xProp->getPropertyValue( "IsDirectionToSimplified" ) >>= bToSimplified;
1300  xProp->getPropertyValue( "IsUseCharacterVariants" ) >>= bUseVariants;
1301  xProp->getPropertyValue( "IsTranslateCommonTerms" ) >>= bCommonTerms;
1302  }
1303  catch (const Exception&)
1304  {
1305  }
1306  }
1307 
1308  //execute translation
1309  LanguageType nSourceLang = bToSimplified ? LANGUAGE_CHINESE_TRADITIONAL : LANGUAGE_CHINESE_SIMPLIFIED;
1310  LanguageType nTargetLang = bToSimplified ? LANGUAGE_CHINESE_SIMPLIFIED : LANGUAGE_CHINESE_TRADITIONAL;
1311  sal_Int32 nOptions = bUseVariants ? i18n::TextConversionOption::USE_CHARACTER_VARIANTS : 0;
1312  if( !bCommonTerms )
1313  nOptions = nOptions | i18n::TextConversionOption::CHARACTER_BY_CHARACTER;
1314 
1315  vcl::Font aTargetFont = OutputDevice::GetDefaultFont( DefaultFontType::CJK_TEXT,
1316  nTargetLang, GetDefaultFontFlags::OnlyOne );
1317 
1318  pOLV->StartTextConversion( nSourceLang, nTargetLang, &aTargetFont, nOptions, false, false );
1319  }
1320  }
1321  Reference< lang::XComponent > xComponent( xDialog, UNO_QUERY );
1322  if( xComponent.is() )
1323  xComponent->dispose();
1324  }
1325  }
1326  }
1327  break;
1328  }
1329 
1330  if (bRestoreSelection)
1331  {
1332  // restore selection
1333  pOLV->GetEditView().SetSelection( aOldSelection );
1334  }
1335 }
1336 
1337 void SwAnnotationShell::GetLinguState(SfxItemSet &rSet)
1338 {
1339  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1340  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
1341  return;
1342 
1343  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1344 
1345  SfxWhichIter aIter(rSet);
1346  sal_uInt16 nWhich = aIter.FirstWhich();
1347  while(nWhich)
1348  {
1349  switch (nWhich)
1350  {
1351  case SID_LANGUAGE_STATUS:
1352  {
1353  SwLangHelper::GetLanguageStatus(pOLV,rSet);
1354  break;
1355  }
1356 
1357  case SID_THES:
1358  {
1359  OUString aStatusVal;
1360  LanguageType nLang = LANGUAGE_NONE;
1361  bool bIsLookUpWord = GetStatusValueForThesaurusFromContext( aStatusVal, nLang, pOLV->GetEditView() );
1362  rSet.Put( SfxStringItem( SID_THES, aStatusVal ) );
1363 
1364  // disable "Thesaurus" context menu entry if there is nothing to look up
1365  uno::Reference< linguistic2::XThesaurus > xThes( ::GetThesaurus() );
1366  if (!bIsLookUpWord ||
1367  !xThes.is() || nLang == LANGUAGE_NONE || !xThes->hasLocale( LanguageTag::convertToLocale( nLang ) ))
1368  rSet.DisableItem( SID_THES );
1369  break;
1370  }
1371 
1372  // disable "Thesaurus" if the language is not supported
1373  case SID_THESAURUS:
1374  {
1375  const SfxPoolItem &rItem = rView.GetWrtShell().GetDoc()->GetDefault(
1376  GetWhichOfScript( RES_CHRATR_LANGUAGE,
1377  SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage())) );
1378  LanguageType nLang = static_cast<const SvxLanguageItem &>(
1379  rItem).GetLanguage();
1380  uno::Reference< linguistic2::XThesaurus > xThes( ::GetThesaurus() );
1381  if (!xThes.is() || nLang == LANGUAGE_NONE ||
1382  !xThes->hasLocale( LanguageTag::convertToLocale( nLang ) ))
1383  rSet.DisableItem( SID_THESAURUS );
1384  }
1385  break;
1386  case SID_HANGUL_HANJA_CONVERSION:
1387  case SID_CHINESE_CONVERSION:
1388  {
1389  if (!SvtCJKOptions().IsAnyEnabled())
1390  {
1391  rView.GetViewFrame()->GetBindings().SetVisibleState( nWhich, false );
1392  rSet.DisableItem(nWhich);
1393  }
1394  else
1395  rView.GetViewFrame()->GetBindings().SetVisibleState( nWhich, true );
1396  }
1397  break;
1398  }
1399 
1400  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()==SwPostItHelper::DELETED)
1401  rSet.DisableItem( nWhich );
1402 
1403  nWhich = aIter.NextWhich();
1404  }
1405 }
1406 
1407 void SwAnnotationShell::ExecTransliteration(SfxRequest const &rReq)
1408 {
1409  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1410  if (!pPostItMgr || !pPostItMgr->HasActiveSidebarWin())
1411  return;
1412 
1413  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1414 
1415  if (!pOLV)
1416  return;
1417 
1418  TransliterationFlags nMode = TransliterationFlags::NONE;
1419 
1420  switch( rReq.GetSlot() )
1421  {
1422  case SID_TRANSLITERATE_SENTENCE_CASE:
1423  nMode = TransliterationFlags::SENTENCE_CASE;
1424  break;
1425  case SID_TRANSLITERATE_TITLE_CASE:
1426  nMode = TransliterationFlags::TITLE_CASE;
1427  break;
1428  case SID_TRANSLITERATE_TOGGLE_CASE:
1429  nMode = TransliterationFlags::TOGGLE_CASE;
1430  break;
1431  case SID_TRANSLITERATE_UPPER:
1432  nMode = TransliterationFlags::LOWERCASE_UPPERCASE;
1433  break;
1434  case SID_TRANSLITERATE_LOWER:
1435  nMode = TransliterationFlags::UPPERCASE_LOWERCASE;
1436  break;
1437  case SID_TRANSLITERATE_HALFWIDTH:
1438  nMode = TransliterationFlags::FULLWIDTH_HALFWIDTH;
1439  break;
1440  case SID_TRANSLITERATE_FULLWIDTH:
1441  nMode = TransliterationFlags::HALFWIDTH_FULLWIDTH;
1442  break;
1443  case SID_TRANSLITERATE_HIRAGANA:
1444  nMode = TransliterationFlags::KATAKANA_HIRAGANA;
1445  break;
1446  case SID_TRANSLITERATE_KATAKANA:
1447  nMode = TransliterationFlags::HIRAGANA_KATAKANA;
1448  break;
1449 
1450  default:
1451  OSL_ENSURE(false, "wrong dispatcher");
1452  }
1453 
1454  if( nMode != TransliterationFlags::NONE )
1455  pOLV->TransliterateText( nMode );
1456 }
1457 
1458 void SwAnnotationShell::ExecRotateTransliteration( SfxRequest const & rReq )
1459 {
1460  if( rReq.GetSlot() == SID_TRANSLITERATE_ROTATE_CASE )
1461  {
1462  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1463  if (!pPostItMgr || !pPostItMgr->HasActiveSidebarWin())
1464  return;
1465 
1466  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1467 
1468  if (!pOLV)
1469  return;
1470 
1471  pOLV->TransliterateText(m_aRotateCase.getNextMode());
1472  }
1473 }
1474 
1475 void SwAnnotationShell::ExecUndo(SfxRequest &rReq)
1476 {
1477  const SfxItemSet* pArgs = rReq.GetArgs();
1478  SfxUndoManager* pUndoManager = GetUndoManager();
1479  SwWrtShell &rSh = rView.GetWrtShell();
1480  SwUndoId nUndoId(SwUndoId::EMPTY);
1481 
1482  long aOldHeight = rView.GetPostItMgr()->HasActiveSidebarWin()
1483  ? rView.GetPostItMgr()->GetActiveSidebarWin()->GetPostItTextHeight()
1484  : 0;
1485 
1486  sal_uInt16 nId = rReq.GetSlot();
1487  sal_uInt16 nCnt = 1;
1488  const SfxPoolItem* pItem=nullptr;
1489  if( pArgs && SfxItemState::SET == pArgs->GetItemState( nId, false, &pItem ) )
1490  nCnt = static_cast<const SfxUInt16Item*>(pItem)->GetValue();
1491  switch( nId )
1492  {
1493  case SID_UNDO:
1494  {
1495  rSh.GetLastUndoInfo(nullptr, &nUndoId);
1496  if (nUndoId == SwUndoId::CONFLICT)
1497  {
1498  rReq.SetReturnValue( SfxUInt32Item(nId, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
1499  break;
1500  }
1501 
1502  if ( pUndoManager )
1503  {
1504  sal_uInt16 nCount = pUndoManager->GetUndoActionCount();
1505  sal_uInt16 nSteps = nCnt;
1506  if ( nCount < nCnt )
1507  {
1508  nCnt = nCnt - nCount;
1509  nSteps = nCount;
1510  }
1511  else
1512  nCnt = 0;
1513 
1514  while( nSteps-- )
1515  pUndoManager->Undo();
1516  }
1517 
1518  if ( nCnt )
1519  rSh.Do( SwWrtShell::UNDO, nCnt );
1520 
1521  break;
1522  }
1523 
1524  case SID_REDO:
1525  {
1526  (void)rSh.GetFirstRedoInfo(nullptr, &nUndoId);
1527  if (nUndoId == SwUndoId::CONFLICT)
1528  {
1529  rReq.SetReturnValue( SfxUInt32Item(nId, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
1530  break;
1531  }
1532 
1533  if ( pUndoManager )
1534  {
1535  sal_uInt16 nCount = pUndoManager->GetRedoActionCount();
1536  sal_uInt16 nSteps = nCnt;
1537  if ( nCount < nCnt )
1538  {
1539  nCnt = nCnt - nCount;
1540  nSteps = nCount;
1541  }
1542  else
1543  nCnt = 0;
1544 
1545  while( nSteps-- )
1546  pUndoManager->Redo();
1547  }
1548 
1549  if ( nCnt )
1550  rSh.Do( SwWrtShell::REDO, nCnt );
1551 
1552  break;
1553  }
1554  }
1555 
1556  rView.GetViewFrame()->GetBindings().InvalidateAll(false);
1557 
1558  if (rView.GetPostItMgr()->HasActiveSidebarWin())
1559  rView.GetPostItMgr()->GetActiveSidebarWin()->ResizeIfNecessary(aOldHeight,rView.GetPostItMgr()->GetActiveSidebarWin()->GetPostItTextHeight());
1560 }
1561 
1562 void SwAnnotationShell::StateUndo(SfxItemSet &rSet)
1563 {
1564  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1565  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
1566  return;
1567 
1568  SfxWhichIter aIter(rSet);
1569  SwUndoId nUndoId(SwUndoId::EMPTY);
1570  sal_uInt16 nWhich = aIter.FirstWhich();
1571  SfxUndoManager* pUndoManager = GetUndoManager();
1572  SfxViewFrame *pSfxViewFrame = rView.GetViewFrame();
1573  SwWrtShell &rSh = rView.GetWrtShell();
1574 
1575  while( nWhich )
1576  {
1577  switch ( nWhich )
1578  {
1579  case SID_UNDO:
1580  {
1581  sal_uInt16 nCount = pUndoManager ? pUndoManager->GetUndoActionCount() : 0;
1582  if ( nCount )
1583  pSfxViewFrame->GetSlotState( nWhich, pSfxViewFrame->GetInterface(), &rSet );
1584  else if (rSh.GetLastUndoInfo(nullptr, &nUndoId))
1585  {
1586  rSet.Put( SfxStringItem( nWhich, rSh.GetDoString(SwWrtShell::UNDO)) );
1587  }
1588  else if (nUndoId == SwUndoId::CONFLICT)
1589  {
1590  rSet.Put( SfxUInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
1591  }
1592  else
1593  rSet.DisableItem(nWhich);
1594  break;
1595  }
1596  case SID_REDO:
1597  {
1598  sal_uInt16 nCount = pUndoManager ? pUndoManager->GetRedoActionCount() : 0;
1599  if ( nCount )
1600  pSfxViewFrame->GetSlotState( nWhich, pSfxViewFrame->GetInterface(), &rSet );
1601  else if (rSh.GetFirstRedoInfo(nullptr, &nUndoId))
1602  {
1603  rSet.Put(SfxStringItem( nWhich, rSh.GetDoString(SwWrtShell::REDO)) );
1604  }
1605  else if (nUndoId == SwUndoId::CONFLICT)
1606  {
1607  rSet.Put( SfxUInt32Item(nWhich, static_cast<sal_uInt32>(SID_REPAIRPACKAGE)) );
1608  }
1609  else
1610  rSet.DisableItem(nWhich);
1611  break;
1612  }
1613  case SID_GETUNDOSTRINGS:
1614  case SID_GETREDOSTRINGS:
1615  {
1616  if( pUndoManager )
1617  {
1618  OUString (SfxUndoManager:: *fnGetComment)( size_t, bool const ) const;
1619 
1620  sal_uInt16 nCount;
1621  if( SID_GETUNDOSTRINGS == nWhich )
1622  {
1623  nCount = pUndoManager->GetUndoActionCount();
1624  fnGetComment = &SfxUndoManager::GetUndoActionComment;
1625  }
1626  else
1627  {
1628  nCount = pUndoManager->GetRedoActionCount();
1629  fnGetComment = &SfxUndoManager::GetRedoActionComment;
1630  }
1631 
1632  OUStringBuffer sList;
1633  if( nCount )
1634  {
1635  for( sal_uInt16 n = 0; n < nCount; ++n )
1636  sList.append( (pUndoManager->*fnGetComment)( n, SfxUndoManager::TopLevel ) ).append("\n");
1637  }
1638 
1639  SfxStringListItem aItem( nWhich );
1640  if ((nWhich == SID_GETUNDOSTRINGS) &&
1641  rSh.GetLastUndoInfo(nullptr, nullptr))
1642  {
1643  rSh.GetDoStrings( SwWrtShell::UNDO, aItem );
1644  }
1645  else if ((nWhich == SID_GETREDOSTRINGS) &&
1646  (rSh.GetFirstRedoInfo(nullptr, nullptr)))
1647  {
1648  rSh.GetDoStrings( SwWrtShell::UNDO, aItem );
1649  }
1650 
1651  sList.append(aItem.GetString());
1652  aItem.SetString( sList.makeStringAndClear() );
1653  rSet.Put( aItem );
1654  }
1655  else
1656  rSet.DisableItem( nWhich );
1657  }
1658  break;
1659 
1660  default:
1661  {
1662  pSfxViewFrame->GetSlotState( nWhich, pSfxViewFrame->GetInterface(), &rSet );
1663  break;
1664  }
1665 
1666  }
1667 
1668  if (pPostItMgr->GetActiveSidebarWin()->GetLayoutStatus()==SwPostItHelper::DELETED)
1669  rSet.DisableItem( nWhich );
1670 
1671  nWhich = aIter.NextWhich();
1672  }
1673 }
1674 
1675 void SwAnnotationShell::StateDisableItems( SfxItemSet &rSet )
1676 {
1677  SfxWhichIter aIter(rSet);
1678  sal_uInt16 nWhich = aIter.FirstWhich();
1679  while (nWhich)
1680  {
1681  rSet.DisableItem( nWhich );
1682  nWhich = aIter.NextWhich();
1683  }
1684 }
1685 
1686 void SwAnnotationShell::InsertSymbol(SfxRequest& rReq)
1687 {
1688  SwPostItMgr* pPostItMgr = rView.GetPostItMgr();
1689  if ( !pPostItMgr || !pPostItMgr->HasActiveSidebarWin() )
1690  return;
1691 
1692  OutlinerView* pOLV = pPostItMgr->GetActiveSidebarWin()->GetOutlinerView();
1693 
1694  const SfxItemSet *pArgs = rReq.GetArgs();
1695  const SfxPoolItem* pItem = nullptr;
1696  if( pArgs )
1697  pArgs->GetItemState(GetPool().GetWhich(SID_CHARMAP), false, &pItem);
1698 
1699  OUString sSym;
1700  OUString sFontName;
1701  if ( pItem )
1702  {
1703  sSym = static_cast<const SfxStringItem*>(pItem)->GetValue();
1704  const SfxPoolItem* pFtItem = nullptr;
1705  pArgs->GetItemState( GetPool().GetWhich(SID_ATTR_SPECIALCHAR), false, &pFtItem);
1706 
1707  if (const SfxStringItem* pFontItem = dynamic_cast<const SfxStringItem*>(pFtItem))
1708  sFontName = pFontItem->GetValue();
1709  }
1710 
1711  SfxItemSet aSet(pOLV->GetAttribs());
1712  SvtScriptType nScript = pOLV->GetSelectedScriptType();
1713  std::shared_ptr<SvxFontItem> aSetDlgFont(std::make_shared<SvxFontItem>(RES_CHRATR_FONT));
1714  {
1715  SvxScriptSetItem aSetItem( SID_ATTR_CHAR_FONT, *aSet.GetPool() );
1716  aSetItem.GetItemSet().Put( aSet, false );
1717  const SfxPoolItem* pI = aSetItem.GetItemOfScript( nScript );
1718  if( pI )
1719  {
1720  aSetDlgFont.reset(static_cast<SvxFontItem*>(pI->Clone()));
1721  }
1722  else
1723  {
1724  aSetDlgFont.reset(static_cast<SvxFontItem*>(aSet.Get( GetWhichOfScript(
1725  SID_ATTR_CHAR_FONT,
1726  SvtLanguageOptions::GetI18NScriptTypeOfLanguage( GetAppLanguage() ) )).Clone()));
1727  }
1728 
1729  if (sFontName.isEmpty())
1730  sFontName = aSetDlgFont->GetFamilyName();
1731  }
1732 
1733  vcl::Font aFont(sFontName, Size(1,1));
1734  if( sSym.isEmpty() )
1735  {
1736  SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create();
1737 
1738  SfxAllItemSet aAllSet( GetPool() );
1739  aAllSet.Put( SfxBoolItem( FN_PARAM_1, false ) );
1740 
1741  SwViewOption aOpt(*rView.GetWrtShell().GetViewOptions());
1742  const OUString& sSymbolFont = aOpt.GetSymbolFont();
1743  if( !sSymbolFont.isEmpty() )
1744  aAllSet.Put( SfxStringItem( SID_FONT_NAME, sSymbolFont ) );
1745  else
1746  aAllSet.Put( SfxStringItem( SID_FONT_NAME, aSetDlgFont->GetFamilyName() ) );
1747 
1748  // If character is selected then it can be shown.
1749  auto xFrame = rView.GetViewFrame()->GetFrame().GetFrameInterface();
1750  ScopedVclPtr<SfxAbstractDialog> pDlg(pFact->CreateCharMapDialog(rView.GetFrameWeld(), aAllSet, xFrame));
1751  pDlg->Execute();
1752  return;
1753  }
1754 
1755  // do not flicker
1756  pOLV->HideCursor();
1757  Outliner * pOutliner = pOLV->GetOutliner();
1758  pOutliner->SetUpdateMode(false);
1759 
1760  SfxItemSet aOldSet( pOLV->GetAttribs() );
1761  SfxItemSet aFontSet(
1762  *aOldSet.GetPool(),
1763  svl::Items<
1764  EE_CHAR_FONTINFO, EE_CHAR_FONTINFO,
1765  EE_CHAR_FONTINFO_CJK, EE_CHAR_FONTINFO_CTL>{});
1766  aFontSet.Set( aOldSet );
1767 
1768  // Insert string
1769  pOLV->InsertText( sSym);
1770 
1771  // Attributing (set font)
1772  SfxItemSet aSetFont( *aFontSet.GetPool(), aFontSet.GetRanges() );
1773  SvxFontItem aFontItem (aFont.GetFamilyType(), aFont.GetFamilyName(),
1774  aFont.GetStyleName(), aFont.GetPitch(),
1775  aFont.GetCharSet(),
1776  EE_CHAR_FONTINFO );
1777  SvtScriptType nScriptBreak = g_pBreakIt->GetAllScriptsOfText( sSym );
1778  if( SvtScriptType::LATIN & nScriptBreak )
1779  aSetFont.Put( aFontItem );
1780  if( SvtScriptType::ASIAN & nScriptBreak )
1781  {
1782  aFontItem.SetWhich(EE_CHAR_FONTINFO_CJK);
1783  aSetFont.Put( aFontItem );
1784  }
1785  if( SvtScriptType::COMPLEX & nScriptBreak )
1786  {
1787  aFontItem.SetWhich(EE_CHAR_FONTINFO_CTL);
1788  aSetFont.Put( aFontItem );
1789  }
1790  pOLV->SetAttribs(aSetFont);
1791 
1792  // Erase selection
1793  ESelection aSel(pOLV->GetSelection());
1794  aSel.nStartPara = aSel.nEndPara;
1795  aSel.nStartPos = aSel.nEndPos;
1796  pOLV->SetSelection(aSel);
1797 
1798  // Restore old font
1799  pOLV->SetAttribs( aFontSet );
1800 
1801  // From now on show it again
1802  pOutliner->SetUpdateMode(true);
1803  pOLV->ShowCursor();
1804 
1805  rReq.AppendItem( SfxStringItem( GetPool().GetWhich(SID_CHARMAP), sSym ) );
1806  if(!aFont.GetFamilyName().isEmpty())
1807  rReq.AppendItem( SfxStringItem( SID_ATTR_SPECIALCHAR, aFont.GetFamilyName() ) );
1808  rReq.Done();
1809 
1810 }
1811 
1812 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FN_HIDE_ALL_NOTES
#define FN_HIDE_ALL_NOTES
Definition: cmdid.h:744
SfxShell::ExecuteSlot
const SfxPoolItem * ExecuteSlot(SfxRequest &rReq, const SfxInterface *pIF=nullptr)
comphelper::string::stripEnd
OString stripEnd(const OString &rIn, char c)
SvxHyperlinkItem::SetURL
void SetURL(const OUString &rURL)
SfxViewShell::GetViewFrame
SfxViewFrame * GetViewFrame() const
LANGUAGE_NONE
#define LANGUAGE_NONE
OutputDevice::GetDefaultFont
static vcl::Font GetDefaultFont(DefaultFontType nType, LanguageType eLang, GetDefaultFontFlags nFlags, const OutputDevice *pOutDev=nullptr)
EE_CHAR_FONTINFO_CJK
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO_CJK(EE_CHAR_START+17)
SvxURLField::SetTargetFrame
void SetTargetFrame(const OUString &rFrm)
ESelection::nStartPara
sal_Int32 nStartPara
OutlinerView::StartThesaurus
EESpellState StartThesaurus()
EE_CHAR_PAIRKERNING
constexpr TypedWhichId< SvxAutoKernItem > EE_CHAR_PAIRKERNING(EE_CHAR_START+11)
OutlinerView::PasteSpecial
void PasteSpecial()
EE_CHAR_KERNING
constexpr TypedWhichId< SvxKerningItem > EE_CHAR_KERNING(EE_CHAR_START+12)
vcl::Font::GetFamilyName
const OUString & GetFamilyName() const
SvxScriptSetItem::PutItemForScriptType
void PutItemForScriptType(SvtScriptType nScriptType, const SfxPoolItem &rItem)
SFX_IMPL_INTERFACE
#define SFX_IMPL_INTERFACE(Class, SuperClass)
SwAnnotationShell::GetUndoManager
virtual SfxUndoManager * GetUndoManager() override
Definition: annotsh.cxx:142
OutlinerView::InsertText
void InsertText(const OUString &rNew, bool bSelect=false)
SwAnnotationShell::rView
SwView & rView
Definition: annotsh.hxx:30
SvxULSpaceItem::GetLower
sal_uInt16 GetLower() const
LINE_SPACE_DEFAULT_HEIGHT
#define LINE_SPACE_DEFAULT_HEIGHT
SvxEscapementItem::SetEscapement
void SetEscapement(const SvxEscapement eNew)
FN_SET_SUPER_SCRIPT
#define FN_SET_SUPER_SCRIPT
Definition: cmdid.h:303
CHAR_NNBSP
#define CHAR_NNBSP
Definition: swtypes.hxx:179
sw::annotation::SwAnnotationWin::GetLayoutStatus
SwPostItHelper::SwLayoutStatus GetLayoutStatus() const
Definition: AnnotationWin.hxx:171
SwUndoId
SwUndoId
Definition: swundo.hxx:29
SfxAbstractDialog::GetOutputItemSet
virtual const SfxItemSet * GetOutputItemSet() const =0
GetValue
std::string GetValue
vcl::Font::GetStyleName
const OUString & GetStyleName() const
SfxPoolItem::Clone
virtual SfxPoolItem * Clone(SfxItemPool *pPool=nullptr) const =0
SvxHyperlinkItem::GetTargetFrame
const OUString & GetTargetFrame() const
SfxShell::HandleOpenXmlFilterSettings
static void HandleOpenXmlFilterSettings(SfxRequest &)
OutlinerView::GetOutputArea
tools::Rectangle const & GetOutputArea() const
OutlinerView::ShowCursor
void ShowCursor(bool bGotoCursor=true, bool bActivate=false)
SvxAbstractDialogFactory::Create
static SvxAbstractDialogFactory * Create()
RES_CHRATR_LANGUAGE
constexpr TypedWhichId< SvxLanguageItem > RES_CHRATR_LANGUAGE(10)
xFrame
Reference< XFrame > xFrame
SwEditShell::GetLastUndoInfo
bool GetLastUndoInfo(OUString *const o_pStr, SwUndoId *const o_pId, const SwView *pView=nullptr) const
Definition: edws.cxx:237
SwLangHelper::GetLanguage
LanguageType GetLanguage(SfxItemSet const &aSet, sal_uInt16 nLangWhichId)
Definition: langhelper.cxx:399
LANGUAGE_KOREAN
#define LANGUAGE_KOREAN
n
sal_Int64 n
SwAnnotationShell::GetState
void GetState(SfxItemSet &)
Definition: annotsh.cxx:588
SwAnnotationShell::StateUndo
void StateUndo(SfxItemSet &rSet)
Definition: annotsh.cxx:1562
EditView::HasSelection
bool HasSelection() const
SfxItemSet::InvalidateItem
void InvalidateItem(sal_uInt16 nWhich)
SwBreakIt::GetAllScriptsOfText
SvtScriptType GetAllScriptsOfText(const OUString &rText) const
Definition: breakit.cxx:127
nId
sal_Int16 nId
SfxWhichIter::FirstWhich
sal_uInt16 FirstWhich()
sw::annotation::SwAnnotationWin::ResizeIfNecessary
void ResizeIfNecessary(long aOldHeight, long aNewHeight)
Definition: AnnotationWin2.cxx:979
CHAR_HARDBLANK
#define CHAR_HARDBLANK
Definition: swtypes.hxx:172
OutlinerView::TransliterateText
void TransliterateText(TransliterationFlags nTransliterationMode)
EE_ITEMS_END
constexpr sal_uInt16 EE_ITEMS_END(EE_FEATURE_END)
RES_BREAK
constexpr TypedWhichId< SvxFormatBreakItem > RES_BREAK(94)
SwWrtShell::GetDoStrings
void GetDoStrings(DoType eDoType, SfxStringListItem &rStrLstItem) const
Definition: wrtundo.cxx:114
SwView::GetEditWin
SwEditWin & GetEditWin()
Definition: view.hxx:403
SfxRequest::Done
void Done(bool bRemove=false)
Outliner::GetParagraphCount
sal_Int32 GetParagraphCount() const
EditView::ChangeFontSize
void ChangeFontSize(bool bGrow, const FontList *pList)
EE_PARA_JUST
constexpr TypedWhichId< SvxAdjustItem > EE_PARA_JUST(EE_PARA_START+15)
SfxObjectShell::Current
static SfxObjectShell * Current()
SwPostItMgr::HasActiveAnnotationWin
bool HasActiveAnnotationWin() const
Definition: PostItMgr.cxx:2310
SwEditShell::SetModified
void SetModified()
Definition: edws.cxx:70
SwView::StateSearch
void StateSearch(SfxItemSet &)
Definition: viewsrch.cxx:858
SfxRequest::GetArgs
const SfxItemSet * GetArgs() const
EditView::SelectCurrentWord
void SelectCurrentWord(sal_Int16 nWordType=css::i18n::WordType::ANYWORD_IGNOREWHITESPACES)
SvtCTLOptions::IsCTLFontEnabled
bool IsCTLFontEnabled() const
TransferableDataHelper::HasFormat
bool HasFormat(SotClipboardFormatId nFormat) const
SwAnnotationShell::ExecLingu
void ExecLingu(SfxRequest &rReq)
Definition: annotsh.cxx:1217
RES_CHRATR_FONT
constexpr TypedWhichId< SvxFontItem > RES_CHRATR_FONT(7)
SfxUndoManager::Undo
virtual bool Undo()
EE_PARA_SBL
constexpr TypedWhichId< SvxLineSpacingItem > EE_PARA_SBL(EE_PARA_START+14)
CHAR_RLM
#define CHAR_RLM
Definition: swtypes.hxx:175
SwAnnotationShell::ExecSearch
void ExecSearch(SfxRequest &)
Definition: annotsh.cxx:853
EE_PARA_WRITINGDIR
constexpr TypedWhichId< SvxFrameDirectionItem > EE_PARA_WRITINGDIR(EE_PARA_START+0)
vcl::Font::GetFamilyType
FontFamily GetFamilyType()
SfxWhichIter::NextWhich
sal_uInt16 NextWhich()
SwView::GetWrtShell
SwWrtShell & GetWrtShell() const
Definition: view.hxx:400
nLang
static LanguageType nLang
Definition: srtdlg.cxx:51
CHAR_SOFTHYPHEN
#define CHAR_SOFTHYPHEN
Definition: swtypes.hxx:174
SfxUndoManager::Redo
virtual bool Redo()
SwAnnotationShell::ExecClpbrd
void ExecClpbrd(SfxRequest const &rReq)
Definition: annotsh.cxx:863
SwWrtShell
Used by the UI to modify the document model.
Definition: wrtsh.hxx:90
vcl::Window::GetFrameWeld
weld::Window * GetFrameWeld() const
SwAnnotationShell::StateSearch
void StateSearch(SfxItemSet &)
Definition: annotsh.cxx:858
sal_Unicode
sal_uInt16 sal_Unicode
SwView::UpdateWordCount
void UpdateWordCount(SfxShell *, sal_uInt16)
Definition: view1.cxx:203
SvxHyperlinkItem::SetTargetFrame
void SetTargetFrame(const OUString &rTarget)
Outliner::GetUndoManager
SfxUndoManager & GetUndoManager()
SvxLineSpacingItem::SetPropLineSpace
void SetPropLineSpace(const sal_uInt16 nProp)
FN_FORMAT_ALL_NOTES
#define FN_FORMAT_ALL_NOTES
Definition: cmdid.h:748
LINESTYLE_NONE
LINESTYLE_NONE
EE_PARA_LRSPACE
constexpr TypedWhichId< SvxLRSpaceItem > EE_PARA_LRSPACE(EE_PARA_START+12)
EE_PARA_ULSPACE
constexpr TypedWhichId< SvxULSpaceItem > EE_PARA_ULSPACE(EE_PARA_START+13)
EE_CHAR_FONTINFO_CTL
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO_CTL(EE_CHAR_START+18)
SwAnnotationShell::Exec
void Exec(SfxRequest &)
Definition: annotsh.cxx:154
g_pBreakIt
SwBreakIt * g_pBreakIt
Definition: breakit.cxx:33
SwDoc::GetDefault
const SfxPoolItem & GetDefault(sal_uInt16 nFormatHint) const
Get the default attribute in this document.
Definition: docfmt.cxx:653
SfxViewFrame::GetFrame
SfxFrame & GetFrame() const
nCount
int nCount
OutlinerView::SelectRange
void SelectRange(sal_Int32 nFirst, sal_Int32 nCount)
TransferableDataHelper::CreateFromSystemClipboard
static TransferableDataHelper CreateFromSystemClipboard(vcl::Window *pWindow)
sw::annotation::SwAnnotationWin::ExecuteCommand
void ExecuteCommand(sal_uInt16 nSlot)
Definition: AnnotationWin2.cxx:1228
HLINK_HTMLMODE
HLINK_HTMLMODE
FN_DELETE_COMMENT
#define FN_DELETE_COMMENT
Definition: cmdid.h:746
FN_STAT_SELMODE
#define FN_STAT_SELMODE
Definition: cmdid.h:824
o3tl::strong_int< sal_uInt16, struct LanguageTypeTag >
SwViewShell::GetDoc
SwDoc * GetDoc() const
Definition: viewsh.hxx:284
SwAnnotationShell::NoteExec
void NoteExec(SfxRequest const &)
Definition: annotsh.cxx:1078
SwAnnotationShell::ExecUndo
void ExecUndo(SfxRequest &rReq)
Definition: annotsh.cxx:1475
SwAnnotationShell::GetNoteState
void GetNoteState(SfxItemSet &)
Definition: annotsh.cxx:1125
SotClipboardFormatId
SotClipboardFormatId
ESelection::nEndPos
sal_Int32 nEndPos
OutlinerView::HasSelection
bool HasSelection() const
SfxUndoManager::GetRedoActionCount
virtual size_t GetRedoActionCount(bool const i_currentLevel=CurrentLevel) const
SwWrtShell::GetDoString
OUString GetDoString(DoType eDoType) const
Definition: wrtundo.cxx:94
SwLangHelper::SetLanguageStatus
bool SetLanguageStatus(OutlinerView *pOLV, SfxRequest &rReq, SwView const &rView, SwWrtShell &rSh)
Definition: langhelper.cxx:99
EE_CHAR_OUTLINE
constexpr TypedWhichId< SvxContourItem > EE_CHAR_OUTLINE(EE_CHAR_START+8)
TransliterationFlags
TransliterationFlags
OutlinerView::GetEditView
EditView & GetEditView() const
FN_SHRINK_FONT_SIZE
#define FN_SHRINK_FONT_SIZE
Definition: cmdid.h:301
xComponent
css::uno::Reference< css::lang::XComponent > xComponent
SfxShell::GetPool
SfxItemPool & GetPool() const
SwAnnotationShell::m_aRotateCase
RotateTransliteration m_aRotateCase
Definition: annotsh.hxx:31
RES_PARATR_HYPHENZONE
constexpr TypedWhichId< SvxHyphenZoneItem > RES_PARATR_HYPHENZONE(69)
SwAnnotationShell::StateClpbrd
void StateClpbrd(SfxItemSet &rSet)
Definition: annotsh.cxx:939
FN_RESOLVE_NOTE
#define FN_RESOLVE_NOTE
Definition: cmdid.h:749
EE_CHAR_SHADOW
constexpr TypedWhichId< SvxShadowedItem > EE_CHAR_SHADOW(EE_CHAR_START+9)
SwAnnotationShell::SwAnnotationShell
SwAnnotationShell(SwView &)
Definition: annotsh.cxx:131
SfxShell::GetItem
const SfxPoolItem * GetItem(sal_uInt16 nSlotId) const
FN_STAT_TEMPLATE
#define FN_STAT_TEMPLATE
Definition: cmdid.h:822
FN_REPLY
#define FN_REPLY
Definition: cmdid.h:747
SwViewShell::GetAttrPool
const SfxItemPool & GetAttrPool() const
Definition: viewsh.hxx:614
FN_SET_SUB_SCRIPT
#define FN_SET_SUB_SCRIPT
Definition: cmdid.h:304
SvtScriptType
SvtScriptType
FN_NUMBERING_OUTLINE_DLG
#define FN_NUMBERING_OUTLINE_DLG
Definition: cmdid.h:486
SvxHyperlinkItem::GetURL
const OUString & GetURL() const
vcl::Font::GetPitch
FontPitch GetPitch()
OutlinerView::SetAttribs
void SetAttribs(const SfxItemSet &)
SfxItemSet::GetItemState
SfxItemState GetItemState(sal_uInt16 nWhich, bool bSrchInParent=true, const SfxPoolItem **ppItem=nullptr) const
SvxAdjust
SvxAdjust
SfxShell::GetSlotState
const SfxPoolItem * GetSlotState(sal_uInt16 nSlotId, const SfxInterface *pIF=nullptr, SfxItemSet *pStateSet=nullptr)
OutlinerView::GetFieldAtSelection
const SvxFieldItem * GetFieldAtSelection() const
SwAnnotationShell::InsertSymbol
void InsertSymbol(SfxRequest &rReq)
Definition: annotsh.cxx:1686
comphelper::InitAnyPropertySequence
css::uno::Sequence< css::uno::Any > InitAnyPropertySequence(::std::initializer_list< ::std::pair< OUString, css::uno::Any > > vInit)
SwRewriter::Apply
OUString Apply(const OUString &rStr) const
Definition: SwRewriter.cxx:43
SwAnnotationShell::ExecTransliteration
void ExecTransliteration(SfxRequest const &)
Definition: annotsh.cxx:1407
FN_DELETE_NOTE_AUTHOR
#define FN_DELETE_NOTE_AUTHOR
Definition: cmdid.h:740
EE_CHAR_FONTWIDTH
constexpr TypedWhichId< SvxCharScaleWidthItem > EE_CHAR_FONTWIDTH(EE_CHAR_START+3)
EE_CHAR_RELIEF
constexpr TypedWhichId< SvxCharReliefItem > EE_CHAR_RELIEF(EE_CHAR_START+26)
SfxViewFrame::GetBindings
SfxBindings & GetBindings()
CntUnencodedStringItem::GetValue
const OUString & GetValue() const
HTMLMODE_ON
HTMLMODE_ON
GetHtmlMode
sal_uInt16 GetHtmlMode(const SwDocShell *pShell)
Definition: viewopt.cxx:337
SfxRequest::GetArg
const T * GetArg(sal_uInt16 nSlotId) const
FN_HIDE_NOTE_AUTHOR
#define FN_HIDE_NOTE_AUTHOR
Definition: cmdid.h:743
SfxShell::SetPool
void SetPool(SfxItemPool *pNewPool)
OutlinerView::GetSelected
OUString GetSelected() const
EE_ITEMS_START
constexpr sal_uInt16 EE_ITEMS_START(OWN_ATTR_VALUE_END+1)
SwView::ExecFormatFootnote
void ExecFormatFootnote()
Definition: view0.cxx:633
SvtLanguageOptions::GetI18NScriptTypeOfLanguage
static sal_Int16 GetI18NScriptTypeOfLanguage(LanguageType nLang)
LINESTYLE_SINGLE
LINESTYLE_SINGLE
OutlinerView::GetSelectedScriptType
SvtScriptType GetSelectedScriptType() const
SwRewriter::AddRule
void AddRule(SwUndoArg eWhat, const OUString &rWith)
Definition: SwRewriter.cxx:29
SfxAbstractTabDialog::SetCurPageId
virtual void SetCurPageId(const OString &rName)=0
SwLangHelper::GetLanguageStatus
void GetLanguageStatus(OutlinerView *pOLV, SfxItemSet &rSet)
Definition: langhelper.cxx:59
GetWhichOfScript
sal_uInt16 GetWhichOfScript(sal_uInt16 nWhich, sal_uInt16 nScript)
Definition: hints.cxx:195
Outliner::IsModified
bool IsModified() const
RotateTransliteration::getNextMode
TransliterationFlags getNextMode()
SfxAbstractPasteDialog::GetFormat
virtual SotClipboardFormatId GetFormat(const TransferableDataHelper &aHelper)=0
OutlinerView::Paste
void Paste(bool bUseSpecial=false)
EE_CHAR_BKGCOLOR
constexpr TypedWhichId< SvxBackgroundColorItem > EE_CHAR_BKGCOLOR(EE_CHAR_START+32)
LANGUAGE_CHINESE_SIMPLIFIED
#define LANGUAGE_CHINESE_SIMPLIFIED
HLINK_FIELD
HLINK_FIELD
cppu::defaultBootstrap_InitialComponentContext
CPPUHELPER_DLLPUBLIC css::uno::Reference< css::uno::XComponentContext > SAL_CALL defaultBootstrap_InitialComponentContext()
SfxStringListItem::SetString
void SetString(const OUString &)
CHAR_ZWSP
#define CHAR_ZWSP
Definition: swtypes.hxx:177
SwAbstractDialogFactory::Create
static SwAbstractDialogFactory * Create()
Definition: swabstdlg.cxx:36
OutlinerView::GetOutliner
Outliner * GetOutliner() const
SwPostItMgr::Hide
void Hide(const OUString &rAuthor)
Definition: PostItMgr.cxx:1679
FN_WORDCOUNT_DIALOG
#define FN_WORDCOUNT_DIALOG
Definition: cmdid.h:588
SvxAbstractDialogFactory::CreateCharMapDialog
virtual VclPtr< SfxAbstractDialog > CreateCharMapDialog(weld::Window *pParent, const SfxItemSet &rAttr, const css::uno::Reference< css::frame::XFrame > &rFrame)=0
SfxItemPool::GetSlotId
sal_uInt16 GetSlotId(sal_uInt16 nWhich) const
SwResId
OUString SwResId(const char *pId)
Definition: swmodule.cxx:178
SvtUserOptions::GetID
OUString GetID() const
SwAnnotationShell::StateInsert
void StateInsert(SfxItemSet &rSet)
Definition: annotsh.cxx:1025
SvxHyperlinkItem::SetName
void SetName(const OUString &rName)
OutlinerView::HideCursor
void HideCursor(bool bDeactivate=false)
SfxUndoManager::GetUndoActionCount
virtual size_t GetUndoActionCount(bool const i_currentLevel=CurrentLevel) const
OutlinerView::InsertField
void InsertField(const SvxFieldItem &rFld)
SfxPoolItem::CloneSetWhich
std::unique_ptr< SfxPoolItem > CloneSetWhich(sal_uInt16 nNewWhich) const
SwView::GetDocShell
SwDocShell * GetDocShell()
Definition: view.cxx:1107
SfxFrame::GetFrameInterface
const css::uno::Reference< css::frame::XFrame > & GetFrameInterface() const
SwViewOption::GetSymbolFont
const OUString & GetSymbolFont() const
Definition: viewopt.hxx:548
SFX_OBJECTBAR_OBJECT
#define SFX_OBJECTBAR_OBJECT
FN_INSERT_STRING
#define FN_INSERT_STRING
Definition: cmdid.h:212
SfxAbstractPasteDialog::Insert
virtual void Insert(SotClipboardFormatId nFormat, const OUString &rFormatName)=0
SwPostItMgr::HasActiveSidebarWin
SW_DLLPUBLIC bool HasActiveSidebarWin() const
Definition: PostItMgr.cxx:2305
OutlinerView::GetSelection
ESelection GetSelection() const
OUStringToOString
OString OUStringToOString(const OUString &str, ConnectionSettings const *settings)
SwPostItMgr::ExecuteFormatAllDialog
void ExecuteFormatAllDialog(SwView &rView)
Definition: PostItMgr.cxx:1606
SfxRequest::SetReturnValue
void SetReturnValue(const SfxPoolItem &)
SfxItemPool::GetSecondaryPool
SfxItemPool * GetSecondaryPool() const
SvxTextLineItem::GetLineStyle
FontLineStyle GetLineStyle() const
SwAnnotationShell::~SwAnnotationShell
virtual ~SwAnnotationShell() override
Definition: annotsh.cxx:138
CHAR_LRM
#define CHAR_LRM
Definition: swtypes.hxx:176
SfxItemSet::Put
const SfxPoolItem * Put(const SfxPoolItem &rItem, sal_uInt16 nWhich)
SfxUndoManager::GetUndoActionComment
OUString GetUndoActionComment(size_t nNo=0, bool const i_currentLevel=CurrentLevel) const
SfxRequest::GetSlot
sal_uInt16 GetSlot() const
vcl::EnumContext::GetContextName
static const OUString & GetContextName(const Context eContext)
EE_CHAR_STRIKEOUT
constexpr TypedWhichId< SvxCrossedOutItem > EE_CHAR_STRIKEOUT(EE_CHAR_START+6)
CHAR_HARDHYPHEN
#define CHAR_HARDHYPHEN
Definition: swtypes.hxx:173
OutlinerView::SetSelection
void SetSelection(const ESelection &)
GetStatusValueForThesaurusFromContext
bool EDITENG_DLLPUBLIC GetStatusValueForThesaurusFromContext(OUString &rStatusVal, LanguageType &rLang, const EditView &rEditView)
RES_PARATR_ORPHANS
constexpr TypedWhichId< SvxOrphansItem > RES_PARATR_ORPHANS(66)
SfxItemState
SfxItemState
SfxItemSet::DisableItem
void DisableItem(sal_uInt16 nWhich)
SfxViewShell::GetFrameWeld
weld::Window * GetFrameWeld() const
SfxUndoManager::GetRedoActionComment
OUString GetRedoActionComment(size_t nNo=0, bool const i_currentLevel=CurrentLevel) const
SfxItemSet::Get
const SfxPoolItem & Get(sal_uInt16 nWhich, bool bSrchInParent=true) const
SfxItemPool::GetWhich
sal_uInt16 GetWhich(sal_uInt16 nSlot, bool bDeep=true) const
RES_PARATR_SPLIT
constexpr TypedWhichId< SvxFormatSplitItem > RES_PARATR_SPLIT(65)
SwView::ExecNumberingOutline
void ExecNumberingOutline(SfxItemPool &)
Definition: view0.cxx:640
GetWhich
#define GetWhich(nSlot)
SwViewShell::GetViewOptions
const SwViewOption * GetViewOptions() const
Definition: viewsh.hxx:426
EE_CHAR_ESCAPEMENT
constexpr TypedWhichId< SvxEscapementItem > EE_CHAR_ESCAPEMENT(EE_CHAR_START+10)
SwWrtShell::Do
void Do(DoType eDoType, sal_uInt16 nCnt=1)
Definition: wrtundo.cxx:32
SwView::ExecSearch
void ExecSearch(SfxRequest &)
Definition: viewsrch.cxx:125
EE_CHAR_COLOR
constexpr TypedWhichId< SvxColorItem > EE_CHAR_COLOR(EE_CHAR_START+0)
GetThesaurus
uno::Reference< linguistic2::XThesaurus > GetThesaurus()
Definition: swtypes.cxx:55
GetAppLanguage
LanguageType GetAppLanguage()
Definition: init.cxx:729
RET_OK
RET_OK
EE_CHAR_WLM
constexpr TypedWhichId< SvxWordLineModeItem > EE_CHAR_WLM(EE_CHAR_START+13)
SwView::GetPostItMgr
SwPostItMgr * GetPostItMgr()
Definition: view.hxx:623
EE_CHAR_OVERLINE
constexpr TypedWhichId< SvxOverlineItem > EE_CHAR_OVERLINE(EE_CHAR_START+29)
aSeq
Sequence< sal_Int8 > aSeq
EE_CHAR_LANGUAGE
constexpr TypedWhichId< SvxLanguageItem > EE_CHAR_LANGUAGE(EE_CHAR_START+14)
EE_CHAR_FONTINFO
constexpr TypedWhichId< SvxFontItem > EE_CHAR_FONTINFO(EE_CHAR_START+1)
Outliner::SetUpdateMode
void SetUpdateMode(bool bUpdate)
SwEditShell::GetFirstRedoInfo
bool GetFirstRedoInfo(OUString *const o_pStr, SwUndoId *const o_pId, const SwView *pView=nullptr) const
Definition: edws.cxx:244
CHAR_ZWNBSP
#define CHAR_ZWNBSP
Definition: swtypes.hxx:178
FN_GROW_FONT_SIZE
#define FN_GROW_FONT_SIZE
Definition: cmdid.h:300
SvxHyperlinkItem::SetInsertMode
void SetInsertMode(SvxLinkInsertMode eNew)
SwPostItMgr::GetActiveSidebarWin
sw::annotation::SwAnnotationWin * GetActiveSidebarWin()
Definition: PostItMgr.hxx:236
Outliner::IsVertical
bool IsVertical() const
FN_FORMAT_FOOTNOTE_DLG
#define FN_FORMAT_FOOTNOTE_DLG
Definition: cmdid.h:320
EditView::SetSelection
void SetSelection(const ESelection &rNewSel)
SfxShell::GetInterface
virtual SfxInterface * GetInterface() const
SvxClipboardFormatItem::AddClipbrdFormat
void AddClipbrdFormat(SotClipboardFormatId nId)
SvxEscapement
SvxEscapement
OutlinerView::StartTextConversion
void StartTextConversion(LanguageType nSrcLang, LanguageType nDestLang, const vcl::Font *pDestFont, sal_Int32 nOptions, bool bIsInteractive, bool bMultipleDoc)
SfxBindings::SetVisibleState
void SetVisibleState(sal_uInt16 nId, bool bShow)
EE_CHAR_UNDERLINE
constexpr TypedWhichId< SvxUnderlineItem > EE_CHAR_UNDERLINE(EE_CHAR_START+5)
SvxHyperlinkItem::GetName
const OUString & GetName() const
SvxHyperlinkItem::GetInsertMode
SvxLinkInsertMode GetInsertMode() const
SfxBindings::InvalidateAll
void InvalidateAll(bool bWithMsg)
SfxRequest::AppendItem
void AppendItem(const SfxPoolItem &)
SvtUserOptions::GetFullName
OUString GetFullName() const
LANGUAGE_CHINESE_TRADITIONAL
#define LANGUAGE_CHINESE_TRADITIONAL
SwAnnotationShell::StateDisableItems
static void StateDisableItems(SfxItemSet &)
Definition: annotsh.cxx:1675
Get
SVXCORE_DLLPUBLIC MSO_SPT Get(const OUString &)
OutlinerView::GetAttribs
SfxItemSet GetAttribs()
EE_FEATURE_FIELD
constexpr sal_uInt16 EE_FEATURE_FIELD(EE_FEATURE_NOTCONV+1)
SfxObjectShell::isContentExtractionLocked
bool isContentExtractionLocked()
SwAnnotationShell::ExecRotateTransliteration
void ExecRotateTransliteration(SfxRequest const &)
Definition: annotsh.cxx:1458
SwAnnotationShell::StateStatusLine
static void StateStatusLine(SfxItemSet &rSet)
Definition: annotsh.cxx:1000
SvxFontListItem::GetFontList
const FontList * GetFontList() const
SwAbstractDialogFactory::CreateSwCharDlg
virtual VclPtr< SfxAbstractTabDialog > CreateSwCharDlg(weld::Window *pParent, SwView &pVw, const SfxItemSet &rCoreSet, SwCharDlgMode nDialogMode, const OUString *pFormatStr=nullptr)=0
IsInvalidItem
bool IsInvalidItem(const SfxPoolItem *pItem)
SfxStringListItem::GetString
OUString GetString()
FontLineStyle
FontLineStyle
SwAnnotationShell::GetLinguState
void GetLinguState(SfxItemSet &)
Definition: annotsh.cxx:1337
TransferableDataHelper::GetTransferable
const css::uno::Reference< css::datatransfer::XTransferable > & GetTransferable() const
SwAnnotationShell::GetAnnotationPool
static SfxItemPool * GetAnnotationPool(SwView const &rV)
Definition: annotsh.cxx:125
FN_HIDE_NOTE
#define FN_HIDE_NOTE
Definition: cmdid.h:742
SwAbstractDialogFactory::CreateSwParaDlg
virtual VclPtr< SfxAbstractTabDialog > CreateSwParaDlg(weld::Window *pParent, SwView &rVw, const SfxItemSet &rCoreSet, bool bDraw, const OString &sDefPage=OString())=0
RES_CHRATR_KERNING
constexpr TypedWhichId< SvxKerningItem > RES_CHRATR_KERNING(9)
SfxShell::SetContextName
void SetContextName(const OUString &rsContextName)
SvxScriptSetItem::GetItemOfScript
const SfxPoolItem * GetItemOfScript(SvtScriptType nScript) const
SfxShell::GetObjectShell
virtual SfxObjectShell * GetObjectShell()
ReplaceTextWithSynonym
void EDITENG_DLLPUBLIC ReplaceTextWithSynonym(EditView &rEditView, const OUString &rSynonmText)
FN_POSTIT
#define FN_POSTIT
Definition: cmdid.h:210
RES_PARATR_WIDOWS
constexpr TypedWhichId< SvxWidowsItem > RES_PARATR_WIDOWS(67)
vcl::Font::GetCharSet
rtl_TextEncoding GetCharSet() const
SwView
Definition: view.hxx:146
SwPostItMgr::Delete
void Delete(const OUString &aAuthor)
Definition: PostItMgr.cxx:1498
SvxULSpaceItem::GetUpper
sal_uInt16 GetUpper() const
SvxFieldItem::GetField
const SvxFieldData * GetField() const
LanguageTag::convertToLocale
static css::lang::Locale convertToLocale(LanguageType nLangID, bool bResolveSystem=true)
FN_DELETE_ALL_NOTES
#define FN_DELETE_ALL_NOTES
Definition: cmdid.h:741
SfxUndoManager::TopLevel
static bool const TopLevel
void
typedef void(CALLTYPE *GetFuncDataPtr)(sal_uInt16 &nNo
Generated on Fri May 8 2020 11:11:29 for LibreOffice Module sw (master) by   doxygen 1.8.10