sw/source/uibase/docvw/AnnotationWin2.cxx

   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 <config_wasm_strip.h>
  21
  22 #include <sal/config.h>
  23
  24 #include <cstddef>
  25
  26 #include "SidebarWinAcc.hxx"
  27 #include <PostItMgr.hxx>
  28 #include <AnnotationWin.hxx>
  29 #include <IDocumentUndoRedo.hxx>
  30 #include <basegfx/range/b2drange.hxx>
  31 #include "SidebarTxtControl.hxx"
  32 #include "AnchorOverlayObject.hxx"
  33 #include "ShadowOverlayObject.hxx"
  34 #include "OverlayRanges.hxx"
  35
  36 #include <strings.hrc>
  37
  38 #include <viewopt.hxx>
  39 #include <cmdid.h>
  40
  41 #include <editeng/fhgtitem.hxx>
  42 #include <editeng/langitem.hxx>
  43 #include <editeng/editview.hxx>
  44 #include <editeng/outliner.hxx>
  45 #include <editeng/editeng.hxx>
  46 #include <editeng/eeitem.hxx>
  47 #include <editeng/outlobj.hxx>
  48
  49 #include <svl/undo.hxx>
  50 #include <svl/stritem.hxx>
  51
  52 #include <sfx2/viewfrm.hxx>
  53 #include <sfx2/bindings.hxx>
  54 #include <sfx2/dispatch.hxx>
  55
  56 #include <vcl/decoview.hxx>
  57 #include <vcl/event.hxx>
  58 #include <vcl/gradient.hxx>
  59 #include <vcl/pdfextoutdevdata.hxx>
  60 #include <vcl/svapp.hxx>
  61 #include <vcl/settings.hxx>
  62 #include <vcl/ptrstyle.hxx>
  63 #include <vcl/uitest/logger.hxx>
  64 #include <vcl/uitest/eventdescription.hxx>
  65
  66 #include <edtwin.hxx>
  67 #include <view.hxx>
  68 #include <docsh.hxx>
  69 #include <wrtsh.hxx>
  70 #include <doc.hxx>
  71 #include <docufld.hxx>
  72 #include <swmodule.hxx>
  73
  74 #include <SwRewriter.hxx>
  75 #include <txtannotationfld.hxx>
  76 #include <ndtxt.hxx>
  77
  78 #include <drawinglayer/processor2d/baseprocessor2d.hxx>
  79 #include <drawinglayer/processor2d/processor2dtools.hxx>
  80 #include <osl/diagnose.h>
  81 #include <unotools/localedatawrapper.hxx>
  82 #include <unotools/syslocale.hxx>
  83 #include <memory>
  84 #include <comphelper/lok.hxx>
  85
  86 using namespace sw::sidebarwindows;
  87
  88 namespace
  89 {
  90
  91 void collectUIInformation( const OUString& aevent , const OUString& aID )
  92 {
  93     EventDescription aDescription;
  94     aDescription.aID =  aID;
  95     aDescription.aParameters = {{"" ,  ""}};
  96     aDescription.aAction = aevent;
  97     aDescription.aParent = "MainWindow";
  98     aDescription.aKeyWord = "SwEditWinUIObject";
  99     UITestLogger::getInstance().logEvent(aDescription);
 100 }
 101
 102 }
 103
 104 namespace sw::annotation {
 105
 106 #define METABUTTON_WIDTH        16
 107 #define METABUTTON_HEIGHT       18
 108 #define POSTIT_MINIMUMSIZE_WITHOUT_META     50
 109
 110 void SwAnnotationWin::PaintTile(vcl::RenderContext& rRenderContext, const tools::Rectangle& rRect)
 111 {
 112     bool bMenuButtonVisible = mxMenuButton->get_visible();
 113     // No point in showing this button till click on it are not handled.
 114     if (bMenuButtonVisible)
 115         mxMenuButton->hide();
 116
 117     // draw left over space
 118     if (Application::GetSettings().GetStyleSettings().GetHighContrastMode())
 119         rRenderContext.SetFillColor(COL_BLACK);
 120     else
 121         rRenderContext.SetFillColor(mColorDark);
 122     rRenderContext.SetLineColor();
 123     rRenderContext.DrawRect(rRect);
 124
 125     m_xContainer->draw(rRenderContext, rRect.TopLeft(), GetSizePixel());
 126
 127     const drawinglayer::geometry::ViewInformation2D aViewInformation;
 128     std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(drawinglayer::processor2d::createProcessor2DFromOutputDevice(rRenderContext, aViewInformation));
 129
 130     // drawinglayer sets the map mode to pixels, not needed here.
 131     rRenderContext.Pop();
 132     // Work in document-global twips.
 133     rRenderContext.Pop();
 134     if (mpAnchor)
 135         pProcessor->process(mpAnchor->getOverlayObjectPrimitive2DSequence());
 136     if (mpTextRangeOverlay)
 137         pProcessor->process(mpTextRangeOverlay->getOverlayObjectPrimitive2DSequence());
 138
 139     rRenderContext.Push(vcl::PushFlags::NONE);
 140     pProcessor.reset();
 141     rRenderContext.Push(vcl::PushFlags::NONE);
 142
 143     if (bMenuButtonVisible)
 144         mxMenuButton->show();
 145 }
 146
 147 bool SwAnnotationWin::IsHitWindow(const Point& rPointLogic)
 148 {
 149     tools::Rectangle aRectangleLogic(EditWin().PixelToLogic(GetPosPixel()), EditWin().PixelToLogic(GetSizePixel()));
 150     return aRectangleLogic.Contains(rPointLogic);
 151 }
 152
 153 void SwAnnotationWin::SetCursorLogicPosition(const Point& rPosition, bool bPoint, bool bClearMark)
 154 {
 155     mxSidebarTextControl->SetCursorLogicPosition(rPosition, bPoint, bClearMark);
 156 }
 157
 158 void SwAnnotationWin::DrawForPage(OutputDevice* pDev, const Point& rPt)
 159 {
 160     // tdf#143511 unclip SysObj so get_extents_relative_to of children
 161     // of the SysObj can provide meaningful results
 162     UnclipVisibleSysObj();
 163
 164     vcl::PDFExtOutDevData *const pPDFExtOutDevData(
 165         dynamic_cast<vcl::PDFExtOutDevData*>(pDev->GetExtOutDevData()));
 166     if (pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF())
 167     {
 168         pPDFExtOutDevData->WrapBeginStructureElement(vcl::PDFWriter::NonStructElement, OUString());
 169     }
 170
 171     pDev->Push();
 172
 173     pDev->SetFillColor(mColorDark);
 174     pDev->SetLineColor();
 175
 176     pDev->SetTextColor(mColorAnchor);
 177     vcl::Font aFont = maLabelFont;
 178     aFont.SetFontHeight(aFont.GetFontHeight() * 20);
 179     pDev->SetFont(aFont);
 180
 181     Size aSz = PixelToLogic(GetSizePixel());
 182
 183     pDev->DrawRect(tools::Rectangle(rPt, aSz));
 184
 185     if (mxMetadataAuthor->get_visible())
 186     {
 187         int x, y, width, height;
 188         mxMetadataAuthor->get_extents_relative_to(*m_xContainer, x, y, width, height);
 189         Point aPos(rPt + PixelToLogic(Point(x, y)));
 190         Size aSize(PixelToLogic(Size(width, height)));
 191
 192         pDev->Push(vcl::PushFlags::CLIPREGION);
 193         pDev->IntersectClipRegion(tools::Rectangle(aPos, aSize));
 194         pDev->DrawText(aPos, mxMetadataAuthor->get_label());
 195         pDev->Pop();
 196     }
 197
 198     if (mxMetadataDate->get_visible())
 199     {
 200         int x, y, width, height;
 201         mxMetadataDate->get_extents_relative_to(*m_xContainer, x, y, width, height);
 202         Point aPos(rPt + PixelToLogic(Point(x, y)));
 203         Size aSize(PixelToLogic(Size(width, height)));
 204
 205         pDev->Push(vcl::PushFlags::CLIPREGION);
 206         pDev->IntersectClipRegion(tools::Rectangle(aPos, aSize));
 207         pDev->DrawText(aPos, mxMetadataDate->get_label());
 208         pDev->Pop();
 209     }
 210
 211     if (mxMetadataResolved->get_visible())
 212     {
 213         int x, y, width, height;
 214         mxMetadataResolved->get_extents_relative_to(*m_xContainer, x, y, width, height);
 215         Point aPos(rPt + PixelToLogic(Point(x, y)));
 216         Size aSize(PixelToLogic(Size(width, height)));
 217
 218         pDev->Push(vcl::PushFlags::CLIPREGION);
 219         pDev->IntersectClipRegion(tools::Rectangle(aPos, aSize));
 220         pDev->DrawText(aPos, mxMetadataResolved->get_label());
 221         pDev->Pop();
 222     }
 223
 224     mxSidebarTextControl->DrawForPage(pDev, rPt);
 225
 226     const drawinglayer::geometry::ViewInformation2D aNewViewInfos;
 227     std::unique_ptr<drawinglayer::processor2d::BaseProcessor2D> pProcessor(
 228         drawinglayer::processor2d::createProcessor2DFromOutputDevice(
 229             *pDev, aNewViewInfos ));
 230
 231     if (mpAnchor)
 232         pProcessor->process(mpAnchor->getOverlayObjectPrimitive2DSequence());
 233     if (mpTextRangeOverlay)
 234         pProcessor->process(mpTextRangeOverlay->getOverlayObjectPrimitive2DSequence());
 235     pProcessor.reset();
 236
 237     if (mxVScrollbar->get_vpolicy() != VclPolicyType::NEVER)
 238     {
 239         // if there is a scrollbar shown, draw "..." to indicate the comment isn't
 240         // completely shown
 241         int x, y, width, height;
 242         mxMenuButton->get_extents_relative_to(*m_xContainer, x, y, width, height);
 243         Point aPos(rPt + PixelToLogic(Point(x, y)));
 244         pDev->DrawText(aPos, "...");
 245     }
 246
 247     pDev->Pop();
 248
 249     if (pPDFExtOutDevData && pPDFExtOutDevData->GetIsExportTaggedPDF())
 250     {
 251         pPDFExtOutDevData->EndStructureElement();
 252     }
 253 }
 254
 255 void SwAnnotationWin::SetPosSizePixelRect(tools::Long nX, tools::Long nY, tools::Long nWidth, tools::Long nHeight,
 256                                        const SwRect& aAnchorRect, const tools::Long aPageBorder)
 257 {
 258     mPosSize = tools::Rectangle(Point(nX,nY),Size(nWidth,nHeight));
 259     if (!mAnchorRect.IsEmpty() && mAnchorRect != aAnchorRect)
 260         mbAnchorRectChanged = true;
 261     mAnchorRect = aAnchorRect;
 262     mPageBorder = aPageBorder;
 263 }
 264
 265 void SwAnnotationWin::SetSize( const Size& rNewSize )
 266 {
 267     mPosSize.SetSize(rNewSize);
 268 }
 269
 270 void SwAnnotationWin::SetVirtualPosSize( const Point& aPoint, const Size& aSize)
 271 {
 272     mPosSize = tools::Rectangle(aPoint,aSize);
 273 }
 274
 275 void SwAnnotationWin::TranslateTopPosition(const tools::Long aAmount)
 276 {
 277     mPosSize.Move(0,aAmount);
 278 }
 279
 280 void SwAnnotationWin::ShowAnchorOnly(const Point &aPoint)
 281 {
 282     HideNote();
 283     SetPosAndSize();
 284     if (mpAnchor)
 285     {
 286         mpAnchor->SetSixthPosition(basegfx::B2DPoint(aPoint.X(),aPoint.Y()));
 287         mpAnchor->SetSeventhPosition(basegfx::B2DPoint(aPoint.X(),aPoint.Y()));
 288         mpAnchor->SetAnchorState(AnchorState::All);
 289         mpAnchor->setVisible(true);
 290     }
 291     if (mpShadow)
 292         mpShadow->setVisible(false);
 293 }
 294
 295 SfxItemSet SwAnnotationWin::DefaultItem()
 296 {
 297     SfxItemSet aItem( mrView.GetDocShell()->GetPool() );
 298     aItem.Put(SvxFontHeightItem(200,100,EE_CHAR_FONTHEIGHT));
 299     return aItem;
 300 }
 301
 302 void SwAnnotationWin::InitControls()
 303 {
 304     // window controls for author and date
 305     mxMetadataAuthor = m_xBuilder->weld_label("author");
 306     mxMetadataAuthor->set_accessible_name( SwResId( STR_ACCESS_ANNOTATION_AUTHOR_NAME ) );
 307     mxMetadataAuthor->set_direction(AllSettings::GetLayoutRTL());
 308
 309     maLabelFont = Application::GetSettings().GetStyleSettings().GetLabelFont();
 310     maLabelFont.SetFontHeight(8);
 311
 312     // we should leave this setting alone, but for this we need a better layout algo
 313     // with variable meta size height
 314     mxMetadataAuthor->set_font(maLabelFont);
 315
 316     mxMetadataDate = m_xBuilder->weld_label("date");
 317     mxMetadataDate->set_accessible_name( SwResId( STR_ACCESS_ANNOTATION_DATE_NAME ) );
 318     mxMetadataDate->set_direction(AllSettings::GetLayoutRTL());
 319     mxMetadataDate->connect_mouse_move(LINK(this, SwAnnotationWin, MouseMoveHdl));
 320
 321     // we should leave this setting alone, but for this we need a better layout algo
 322     // with variable meta size height
 323     mxMetadataDate->set_font(maLabelFont);
 324
 325     mxMetadataResolved = m_xBuilder->weld_label("resolved");
 326     mxMetadataResolved->set_accessible_name( SwResId( STR_ACCESS_ANNOTATION_RESOLVED_NAME ) );
 327     mxMetadataResolved->set_direction(AllSettings::GetLayoutRTL());
 328     mxMetadataResolved->connect_mouse_move(LINK(this, SwAnnotationWin, MouseMoveHdl));
 329
 330     // we should leave this setting alone, but for this we need a better layout algo
 331     // with variable meta size height
 332     mxMetadataResolved->set_font(maLabelFont);
 333     mxMetadataResolved->set_label(SwResId(STR_ACCESS_ANNOTATION_RESOLVED_NAME));
 334
 335     SwDocShell* aShell = mrView.GetDocShell();
 336     mpOutliner.reset(new Outliner(&aShell->GetPool(),OutlinerMode::TextObject));
 337     aShell->GetDoc()->SetCalcFieldValueHdl( mpOutliner.get() );
 338     mpOutliner->SetUpdateLayout( true );
 339
 340     mpOutlinerView.reset(new OutlinerView(mpOutliner.get(), nullptr));
 341     mpOutliner->InsertView(mpOutlinerView.get());
 342
 343     //create Scrollbars
 344     mxVScrollbar = m_xBuilder->weld_scrolled_window("scrolledwindow", true);
 345
 346     mxMenuButton = m_xBuilder->weld_menu_button("menubutton");
 347     mxMenuButton->set_size_request(METABUTTON_WIDTH, METABUTTON_HEIGHT);
 348
 349     // actual window which holds the user text
 350     mxSidebarTextControl.reset(new SidebarTextControl(*this, mrView, mrMgr));
 351     mxSidebarTextControlWin.reset(new weld::CustomWeld(*m_xBuilder, "editview", *mxSidebarTextControl));
 352     mxSidebarTextControl->SetPointer(PointerStyle::Text);
 353
 354     Rescale();
 355
 356     mpOutlinerView->SetBackgroundColor(COL_TRANSPARENT);
 357     mpOutlinerView->SetOutputArea( PixelToLogic( tools::Rectangle(0,0,1,1) ) );
 358
 359     mpOutlinerView->SetAttribs(DefaultItem());
 360
 361     mxVScrollbar->set_direction(false);
 362     mxVScrollbar->connect_vadjustment_changed(LINK(this, SwAnnotationWin, ScrollHdl));
 363     mxVScrollbar->connect_mouse_move(LINK(this, SwAnnotationWin, MouseMoveHdl));
 364
 365     EEControlBits nCntrl = mpOutliner->GetControlWord();
 366     // TODO: crash when AUTOCOMPLETE enabled
 367     nCntrl |= EEControlBits::MARKFIELDS | EEControlBits::PASTESPECIAL | EEControlBits::AUTOCORRECT | EEControlBits::USECHARATTRIBS; // | EEControlBits::AUTOCOMPLETE;
 368
 369     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
 370     {
 371         const SwViewOption* pVOpt = pWrtShell->GetViewOptions();
 372         if (pVOpt->IsFieldShadings())
 373             nCntrl |= EEControlBits::MARKFIELDS;
 374         else
 375             nCntrl &= ~EEControlBits::MARKFIELDS;
 376         if (pVOpt->IsOnlineSpell())
 377             nCntrl |= EEControlBits::ONLINESPELLING;
 378         else
 379             nCntrl &= ~EEControlBits::ONLINESPELLING;
 380     }
 381     mpOutliner->SetControlWord(nCntrl);
 382
 383     std::size_t aIndex = SW_MOD()->InsertRedlineAuthor(GetAuthor());
 384     SetColor( SwPostItMgr::GetColorDark(aIndex),
 385               SwPostItMgr::GetColorLight(aIndex),
 386               SwPostItMgr::GetColorAnchor(aIndex));
 387
 388     CheckMetaText();
 389
 390     // expand %1 "Author"
 391     OUString aText = mxMenuButton->get_item_label("deleteby");
 392     SwRewriter aRewriter;
 393     aRewriter.AddRule(UndoArg1, GetAuthor());
 394     aText = aRewriter.Apply(aText);
 395     mxMenuButton->set_item_label("deleteby", aText);
 396
 397     mxMenuButton->set_accessible_name(SwResId(STR_ACCESS_ANNOTATION_BUTTON_NAME));
 398     mxMenuButton->set_accessible_description(SwResId(STR_ACCESS_ANNOTATION_BUTTON_DESC));
 399     mxMenuButton->set_tooltip_text(SwResId(STR_ACCESS_ANNOTATION_BUTTON_DESC));
 400
 401     mxMenuButton->connect_toggled(LINK(this, SwAnnotationWin, ToggleHdl));
 402     mxMenuButton->connect_selected(LINK(this, SwAnnotationWin, SelectHdl));
 403     mxMenuButton->connect_key_press(LINK(this, SwAnnotationWin, KeyInputHdl));
 404     mxMenuButton->connect_mouse_move(LINK(this, SwAnnotationWin, MouseMoveHdl));
 405
 406     SetLanguage(GetLanguage());
 407     GetOutlinerView()->StartSpeller(mxSidebarTextControl->GetDrawingArea());
 408     SetPostItText();
 409     mpOutliner->CompleteOnlineSpelling();
 410
 411     mxSidebarTextControl->Show();
 412     mxMetadataAuthor->show();
 413     mxMetadataDate->show();
 414     mxMetadataResolved->set_visible(IsResolved());
 415     mxVScrollbar->set_vpolicy(VclPolicyType::ALWAYS);
 416 }
 417
 418 void SwAnnotationWin::CheckMetaText()
 419 {
 420     const SvtSysLocale aSysLocale;
 421     const LocaleDataWrapper& rLocalData = aSysLocale.GetLocaleData();
 422     OUString sMeta = GetAuthor();
 423     if (sMeta.isEmpty())
 424     {
 425         sMeta = SwResId(STR_NOAUTHOR);
 426     }
 427     else if (sMeta.getLength() > 23)
 428     {
 429         sMeta = OUString::Concat(sMeta.subView(0, 20)) + "...";
 430     }
 431     if ( mxMetadataAuthor->get_label() != sMeta )
 432     {
 433         mxMetadataAuthor->set_label(sMeta);
 434     }
 435
 436     Date aDate = GetDate();
 437     if (aDate.IsValidAndGregorian() )
 438     {
 439         sMeta = rLocalData.getDate(aDate);
 440     }
 441     else
 442     {
 443         sMeta = SwResId(STR_NODATE);
 444     }
 445     if (GetTime().GetTime()!=0)
 446     {
 447         sMeta += " " + rLocalData.getTime( GetTime(),false );
 448     }
 449     if ( mxMetadataDate->get_label() != sMeta )
 450     {
 451         mxMetadataDate->set_label(sMeta);
 452     }
 453
 454     std::size_t aIndex = SW_MOD()->InsertRedlineAuthor(GetAuthor());
 455     SetColor( SwPostItMgr::GetColorDark(aIndex),
 456               SwPostItMgr::GetColorLight(aIndex),
 457               SwPostItMgr::GetColorAnchor(aIndex));
 458 }
 459
 460 static Color ColorFromAlphaColor(const sal_uInt8 aTransparency, const Color& aFront, const Color& aBack)
 461 {
 462     return Color(sal_uInt8(aFront.GetRed()   * aTransparency / 255.0 + aBack.GetRed()   * (1 - aTransparency / 255.0)),
 463                  sal_uInt8(aFront.GetGreen() * aTransparency / 255.0 + aBack.GetGreen() * (1 - aTransparency / 255.0)),
 464                  sal_uInt8(aFront.GetBlue()  * aTransparency / 255.0 + aBack.GetBlue()  * (1 - aTransparency / 255.0)));
 465 }
 466
 467 void SwAnnotationWin::SetMenuButtonColors()
 468 {
 469     if (!mxMenuButton)
 470         return;
 471
 472     mxMenuButton->set_background(mColorDark);
 473
 474     SwWrtShell* pWrtShell = mrView.GetWrtShellPtr();
 475     if (!pWrtShell)
 476         return;
 477     const Fraction& rFraction = pWrtShell->GetOut()->GetMapMode().GetScaleY();
 478
 479     ScopedVclPtrInstance<VirtualDevice> xVirDev;
 480     Size aSize(tools::Long(METABUTTON_WIDTH * rFraction),
 481                tools::Long(METABUTTON_HEIGHT * rFraction));
 482     tools::Rectangle aRect(Point(0, 0), aSize);
 483     xVirDev->SetOutputSizePixel(aSize);
 484
 485     Gradient aGradient(css::awt::GradientStyle_LINEAR,
 486                              ColorFromAlphaColor(15, mColorAnchor, mColorDark),
 487                              ColorFromAlphaColor(80, mColorAnchor, mColorDark));
 488     xVirDev->DrawGradient(aRect, aGradient);
 489
 490     //draw rect around button
 491     xVirDev->SetFillColor();
 492     xVirDev->SetLineColor(ColorFromAlphaColor(90, mColorAnchor, mColorDark));
 493     xVirDev->DrawRect(aRect);
 494
 495     tools::Rectangle aSymbolRect(aRect);
 496     // 25% distance to the left and right button border
 497     const tools::Long nBorderDistanceLeftAndRight = ((aSymbolRect.GetWidth() * 250) + 500) / 1000;
 498     aSymbolRect.AdjustLeft(nBorderDistanceLeftAndRight );
 499     aSymbolRect.AdjustRight( -nBorderDistanceLeftAndRight );
 500     // 40% distance to the top button border
 501     const tools::Long nBorderDistanceTop = ((aSymbolRect.GetHeight() * 400) + 500) / 1000;
 502     aSymbolRect.AdjustTop(nBorderDistanceTop );
 503     // 15% distance to the bottom button border
 504     const tools::Long nBorderDistanceBottom = ((aSymbolRect.GetHeight() * 150) + 500) / 1000;
 505     aSymbolRect.AdjustBottom( -nBorderDistanceBottom );
 506     DecorationView aDecoView(xVirDev.get());
 507     aDecoView.DrawSymbol(aSymbolRect, SymbolType::SPIN_DOWN, GetTextColor(),
 508                          DrawSymbolFlags::NONE);
 509     mxMenuButton->set_image(xVirDev);
 510     mxMenuButton->set_size_request(aSize.Width() + 4, aSize.Height() + 4);
 511 }
 512
 513 void SwAnnotationWin::Rescale()
 514 {
 515     // On Android, this method leads to invoke ImpEditEngine::UpdateViews
 516     // which hides the text cursor. Moreover it causes sudden document scroll
 517     // when modifying a commented text. Not clear the root cause,
 518     // anyway skipping this method fixes the problem, and there should be
 519     // no side effect, since the client has disabled annotations rendering.
 520     if (comphelper::LibreOfficeKit::isActive() && !comphelper::LibreOfficeKit::isTiledAnnotations())
 521         return;
 522
 523     MapMode aMode = GetParent()->GetMapMode();
 524     aMode.SetOrigin( Point() );
 525     SetMapMode( aMode );
 526     mxSidebarTextControl->SetMapMode( aMode );
 527
 528     SwWrtShell* pWrtShell = mrView.GetWrtShellPtr();
 529     if (!pWrtShell)
 530         return;
 531     const Fraction& rFraction = pWrtShell->GetOut()->GetMapMode().GetScaleY();
 532
 533     vcl::Font aFont = maLabelFont;
 534     sal_Int32 nHeight = tools::Long(aFont.GetFontHeight() * rFraction);
 535     aFont.SetFontHeight( nHeight );
 536
 537     if (mxMetadataAuthor)
 538         mxMetadataAuthor->set_font(aFont);
 539     if (mxMetadataDate)
 540         mxMetadataDate->set_font(aFont);
 541     if (mxMetadataResolved)
 542         mxMetadataResolved->set_font(aFont);
 543     SetMenuButtonColors();
 544     if (mxVScrollbar)
 545         mxVScrollbar->set_scroll_thickness(GetPrefScrollbarWidth());
 546 }
 547
 548 void SwAnnotationWin::SetPosAndSize()
 549 {
 550     bool bChange = false;
 551
 552     if (GetSizePixel() != mPosSize.GetSize())
 553     {
 554         bChange = true;
 555         SetSizePixel(mPosSize.GetSize());
 556
 557         DoResize();
 558     }
 559
 560     if (GetPosPixel().X() != mPosSize.Left() || (std::abs(GetPosPixel().Y() - mPosSize.Top()) > 5) )
 561     {
 562         bChange = true;
 563         SetPosPixel(mPosSize.TopLeft());
 564
 565         Point aLineStart;
 566         Point aLineEnd ;
 567         switch ( meSidebarPosition )
 568         {
 569             case sw::sidebarwindows::SidebarPosition::LEFT:
 570             {
 571                 aLineStart = EditWin().PixelToLogic( Point(GetPosPixel().X()+GetSizePixel().Width(),GetPosPixel().Y()-1) );
 572                 aLineEnd = EditWin().PixelToLogic( Point(GetPosPixel().X(),GetPosPixel().Y()-1) );
 573             }
 574             break;
 575             case sw::sidebarwindows::SidebarPosition::RIGHT:
 576             {
 577                 aLineStart = EditWin().PixelToLogic( Point(GetPosPixel().X(),GetPosPixel().Y()-1) );
 578                 aLineEnd = EditWin().PixelToLogic( Point(GetPosPixel().X()+GetSizePixel().Width(),GetPosPixel().Y()-1) );
 579             }
 580             break;
 581             default:
 582                 OSL_FAIL( "<SwAnnotationWin::SetPosAndSize()> - unexpected position of sidebar" );
 583             break;
 584         }
 585
 586         // LOK has map mode disabled, and we still want to perform pixel ->
 587         // twips conversion for the size of the line above the note.
 588         if (comphelper::LibreOfficeKit::isActive() && !EditWin().IsMapModeEnabled())
 589         {
 590             EditWin().EnableMapMode();
 591             Size aSize(aLineEnd.getX() - aLineStart.getX(), aLineEnd.getY() - aLineStart.getY());
 592             aSize = EditWin().PixelToLogic(aSize);
 593             aLineEnd = aLineStart;
 594             aLineEnd.Move(aSize.getWidth(), aSize.getHeight());
 595             EditWin().EnableMapMode(false);
 596         }
 597
 598         if (mpAnchor)
 599         {
 600             mpAnchor->SetAllPosition( basegfx::B2DPoint( mAnchorRect.Left() , mAnchorRect.Bottom() - 5* 15),
 601                                       basegfx::B2DPoint( mAnchorRect.Left()-5*15 , mAnchorRect.Bottom()+5*15),
 602                                       basegfx::B2DPoint( mAnchorRect.Left()+5*15 , mAnchorRect.Bottom()+5*15),
 603                                       basegfx::B2DPoint( mAnchorRect.Left(), mAnchorRect.Bottom()+2*15),
 604                                       basegfx::B2DPoint( mPageBorder ,mAnchorRect.Bottom()+2*15),
 605                                       basegfx::B2DPoint( aLineStart.X(),aLineStart.Y()),
 606                                       basegfx::B2DPoint( aLineEnd.X(),aLineEnd.Y()));
 607         }
 608         else
 609         {
 610             mpAnchor = AnchorOverlayObject::CreateAnchorOverlayObject( mrView,
 611                                                                        mAnchorRect,
 612                                                                        mPageBorder,
 613                                                                        aLineStart,
 614                                                                        aLineEnd,
 615                                                                        mColorAnchor );
 616             if ( mpAnchor )
 617             {
 618                 mpAnchor->setVisible(true);
 619                 mpAnchor->SetAnchorState(AnchorState::Tri);
 620                 if (HasChildPathFocus())
 621                 {
 622                     mpAnchor->setLineSolid(true);
 623                 }
 624             }
 625         }
 626     }
 627     else
 628     {
 629         if ( mpAnchor &&
 630              ( mpAnchor->getBasePosition() != basegfx::B2DPoint( mAnchorRect.Left() , mAnchorRect.Bottom()-5*15) ) )
 631         {
 632             mpAnchor->SetTriPosition( basegfx::B2DPoint( mAnchorRect.Left() , mAnchorRect.Bottom() - 5* 15),
 633                                       basegfx::B2DPoint( mAnchorRect.Left()-5*15 , mAnchorRect.Bottom()+5*15),
 634                                       basegfx::B2DPoint( mAnchorRect.Left()+5*15 , mAnchorRect.Bottom()+5*15),
 635                                       basegfx::B2DPoint( mAnchorRect.Left(), mAnchorRect.Bottom()+2*15),
 636                                       basegfx::B2DPoint( mPageBorder , mAnchorRect.Bottom()+2*15));
 637         }
 638     }
 639
 640     if (mpShadow && bChange)
 641     {
 642         Point aStart = EditWin().PixelToLogic(GetPosPixel()+Point(0,GetSizePixel().Height()));
 643         Point aEnd = EditWin().PixelToLogic(GetPosPixel()+Point(GetSizePixel().Width()-1,GetSizePixel().Height()));
 644         mpShadow->SetPosition(basegfx::B2DPoint(aStart.X(),aStart.Y()), basegfx::B2DPoint(aEnd.X(),aEnd.Y()));
 645     }
 646
 647     if (mrMgr.ShowNotes())
 648     {
 649         if (IsFollow() && !HasChildPathFocus())
 650         {
 651             // #i111964#
 652             if ( mpAnchor )
 653             {
 654                 mpAnchor->SetAnchorState(AnchorState::End);
 655             }
 656         }
 657         else
 658         {
 659             // #i111964#
 660             if ( mpAnchor )
 661             {
 662                 mpAnchor->SetAnchorState(AnchorState::All);
 663             }
 664             SwAnnotationWin* pWin = GetTopReplyNote();
 665             // #i111964#
 666             if ( pWin != this && pWin->Anchor() )
 667             {
 668                 pWin->Anchor()->SetAnchorState(AnchorState::End);
 669             }
 670         }
 671     }
 672
 673
 674     // text range overlay
 675     maAnnotationTextRanges.clear();
 676     if ( mrSidebarItem.maLayoutInfo.mnStartNodeIdx != SwNodeOffset(0)
 677          && mrSidebarItem.maLayoutInfo.mnStartContent != -1 )
 678     {
 679         const SwTextAnnotationField* pTextAnnotationField =
 680             dynamic_cast< const SwTextAnnotationField* >( mrSidebarItem.GetFormatField().GetTextField() );
 681         SwTextNode* pTextNode = pTextAnnotationField ? pTextAnnotationField->GetpTextNode() : nullptr;
 682         SwContentNode* pContentNd = nullptr;
 683         if (pTextNode)
 684         {
 685             SwNodes& rNds = pTextNode->GetDoc().GetNodes();
 686             pContentNd = rNds[mrSidebarItem.maLayoutInfo.mnStartNodeIdx]->GetContentNode();
 687         }
 688         if (pContentNd)
 689         {
 690             SwPosition aStartPos( *pContentNd, mrSidebarItem.maLayoutInfo.mnStartContent );
 691             SwShellCursor* pTmpCursor = nullptr;
 692             const bool bTableCursorNeeded = pTextNode->FindTableBoxStartNode() != pContentNd->FindTableBoxStartNode();
 693             if ( bTableCursorNeeded )
 694             {
 695                 SwShellTableCursor* pTableCursor = new SwShellTableCursor( mrView.GetWrtShell(), aStartPos );
 696                 pTableCursor->SetMark();
 697                 pTableCursor->GetMark()->Assign( *pTextNode, pTextAnnotationField->GetStart()+1 );
 698                 pTableCursor->NewTableSelection();
 699                 pTmpCursor = pTableCursor;
 700             }
 701             else
 702             {
 703                 SwShellCursor* pCursor = new SwShellCursor( mrView.GetWrtShell(), aStartPos );
 704                 pCursor->SetMark();
 705                 pCursor->GetMark()->Assign(*pTextNode, pTextAnnotationField->GetStart()+1 );
 706                 pTmpCursor = pCursor;
 707             }
 708             std::unique_ptr<SwShellCursor> pTmpCursorForAnnotationTextRange( pTmpCursor );
 709
 710             // For annotation text range rectangles to be calculated correctly,
 711             // we need the map mode disabled
 712             bool bDisableMapMode = comphelper::LibreOfficeKit::isActive() && EditWin().IsMapModeEnabled();
 713             if (bDisableMapMode)
 714                 EditWin().EnableMapMode(false);
 715
 716             if (mrSidebarItem.maLayoutInfo.mPositionFromCommentAnchor)
 717                 pTmpCursorForAnnotationTextRange->FillRects();
 718
 719             if (bDisableMapMode)
 720                 EditWin().EnableMapMode();
 721
 722             SwRects* pRects(pTmpCursorForAnnotationTextRange.get());
 723             for(const SwRect & rNextRect : *pRects)
 724             {
 725                 const tools::Rectangle aPntRect(rNextRect.SVRect());
 726                 maAnnotationTextRanges.emplace_back(
 727                     aPntRect.Left(), aPntRect.Top(),
 728                     aPntRect.Right() + 1, aPntRect.Bottom() + 1);
 729             }
 730         }
 731     }
 732
 733     if (mrMgr.ShowNotes() && !maAnnotationTextRanges.empty())
 734     {
 735         if ( mpTextRangeOverlay != nullptr )
 736         {
 737             mpTextRangeOverlay->setRanges( std::vector(maAnnotationTextRanges) );
 738             if ( mpAnchor != nullptr && mpAnchor->getLineSolid() )
 739             {
 740                 mpTextRangeOverlay->ShowSolidBorder();
 741             }
 742             else
 743             {
 744                 mpTextRangeOverlay->HideSolidBorder();
 745             }
 746         }
 747         else if (!IsFollow())
 748         {
 749             // This window is not a reply, then draw its range overlay.
 750             mpTextRangeOverlay =
 751                 sw::overlay::OverlayRanges::CreateOverlayRange(
 752                     mrView,
 753                     mColorAnchor,
 754                     std::vector(maAnnotationTextRanges),
 755                     mpAnchor && mpAnchor->getLineSolid() );
 756         }
 757     }
 758     else
 759     {
 760         mpTextRangeOverlay.reset();
 761     }
 762 }
 763
 764 void SwAnnotationWin::DoResize()
 765 {
 766     tools::Long aHeight = GetSizePixel().Height();
 767     tools::ULong aWidth = GetSizePixel().Width();
 768
 769     aHeight -= GetMetaHeight();
 770
 771     mpOutliner->SetPaperSize( PixelToLogic( Size(aWidth, aHeight) ) ) ;
 772     tools::Long aTextHeight = LogicToPixel( mpOutliner->CalcTextSize()).Height();
 773
 774     mxMetadataAuthor->show();
 775     if(IsResolved()) { mxMetadataResolved->show(); }
 776     mxMetadataDate->show();
 777
 778     if (aTextHeight > aHeight)
 779     {
 780         const int nThickness = mxVScrollbar->get_scroll_thickness();
 781         if (nThickness)
 782         {
 783             // we need vertical scrollbars and have to reduce the width
 784             aWidth -= nThickness;
 785             mpOutliner->SetPaperSize(PixelToLogic(Size(aWidth, aHeight)));
 786         }
 787         mxVScrollbar->set_vpolicy(VclPolicyType::ALWAYS);
 788     }
 789     else
 790     {
 791         mxVScrollbar->set_vpolicy(VclPolicyType::NEVER);
 792     }
 793
 794     tools::Rectangle aOutputArea = PixelToLogic(tools::Rectangle(0, 0, aWidth, aHeight));
 795     if (mxVScrollbar->get_vpolicy() == VclPolicyType::NEVER)
 796     {
 797         // if we do not have a scrollbar anymore, we want to see the complete text
 798         mpOutlinerView->SetVisArea(aOutputArea);
 799     }
 800     mpOutlinerView->SetOutputArea(aOutputArea);
 801     mpOutlinerView->ShowCursor(true, true);
 802
 803     // Don't leave an empty area at the bottom if we can move the text down.
 804     tools::Long nMaxVisAreaTop = mpOutliner->GetTextHeight() - aOutputArea.GetHeight();
 805     if (mpOutlinerView->GetVisArea().Top() > nMaxVisAreaTop)
 806     {
 807         GetOutlinerView()->Scroll(0, mpOutlinerView->GetVisArea().Top() - nMaxVisAreaTop);
 808     }
 809
 810     int nUpper = mpOutliner->GetTextHeight();
 811     int nCurrentDocPos = mpOutlinerView->GetVisArea().Top();
 812     int nStepIncrement = mpOutliner->GetTextHeight() / 10;
 813     int nPageIncrement = PixelToLogic(Size(0,aHeight)).Height() * 8 / 10;
 814     int nPageSize = PixelToLogic(Size(0,aHeight)).Height();
 815
 816     /* limit the page size to below nUpper because gtk's gtk_scrolled_window_start_deceleration has
 817        effectively...
 818
 819        lower = gtk_adjustment_get_lower
 820        upper = gtk_adjustment_get_upper - gtk_adjustment_get_page_size
 821
 822        and requires that upper > lower or the deceleration animation never ends
 823     */
 824     nPageSize = std::min(nPageSize, nUpper);
 825
 826     mxVScrollbar->vadjustment_configure(nCurrentDocPos, 0, nUpper,
 827                                         nStepIncrement, nPageIncrement, nPageSize);
 828 }
 829
 830 void SwAnnotationWin::SetSizePixel( const Size& rNewSize )
 831 {
 832     if (comphelper::LibreOfficeKit::isActive())
 833         return;
 834
 835     InterimItemWindow::SetSizePixel(rNewSize);
 836
 837     if (mpShadow)
 838     {
 839         Point aStart = EditWin().PixelToLogic(GetPosPixel()+Point(0,GetSizePixel().Height()));
 840         Point aEnd = EditWin().PixelToLogic(GetPosPixel()+Point(GetSizePixel().Width()-1,GetSizePixel().Height()));
 841         mpShadow->SetPosition(basegfx::B2DPoint(aStart.X(),aStart.Y()), basegfx::B2DPoint(aEnd.X(),aEnd.Y()));
 842     }
 843 }
 844
 845 void SwAnnotationWin::SetScrollbar()
 846 {
 847     mxVScrollbar->vadjustment_set_value(mpOutlinerView->GetVisArea().Top());
 848 }
 849
 850 void SwAnnotationWin::ResizeIfNecessary(tools::Long aOldHeight, tools::Long aNewHeight)
 851 {
 852     if (aOldHeight != aNewHeight)
 853     {
 854         //check for lower border or next note
 855         tools::Long aBorder = mrMgr.GetNextBorder();
 856         if (aBorder != -1)
 857         {
 858             if (aNewHeight > GetMinimumSizeWithoutMeta())
 859             {
 860                 tools::Long aNewLowerValue = GetPosPixel().Y() + aNewHeight + GetMetaHeight();
 861                 if (aNewLowerValue < aBorder)
 862                     SetSizePixel(Size(GetSizePixel().Width(),aNewHeight+GetMetaHeight()));
 863                 else
 864                     SetSizePixel(Size(GetSizePixel().Width(),aBorder - GetPosPixel().Y()));
 865                 DoResize();
 866                 Invalidate();
 867             }
 868             else
 869             {
 870                 if (GetSizePixel().Height() != GetMinimumSizeWithoutMeta() + GetMetaHeight())
 871                     SetSizePixel(Size(GetSizePixel().Width(),GetMinimumSizeWithoutMeta() + GetMetaHeight()));
 872                 DoResize();
 873                 Invalidate();
 874             }
 875         }
 876         else
 877         {
 878             DoResize();
 879             Invalidate();
 880         }
 881     }
 882     else
 883     {
 884         SetScrollbar();
 885     }
 886 }
 887
 888 void SwAnnotationWin::SetColor(Color aColorDark,Color aColorLight, Color aColorAnchor)
 889 {
 890     mColorDark =  aColorDark;
 891     mColorLight = aColorLight;
 892     mColorAnchor = aColorAnchor;
 893
 894     if ( Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
 895         return;
 896
 897     m_xContainer->set_background(mColorDark);
 898     SetMenuButtonColors();
 899
 900     mxMetadataAuthor->set_font_color(aColorAnchor);
 901
 902     mxMetadataDate->set_font_color(aColorAnchor);
 903
 904     mxMetadataResolved->set_font_color(aColorAnchor);
 905
 906     mxVScrollbar->customize_scrollbars(mColorLight,
 907                                        mColorAnchor,
 908                                        mColorDark);
 909 }
 910
 911 void SwAnnotationWin::SetSidebarPosition(sw::sidebarwindows::SidebarPosition eSidebarPosition)
 912 {
 913     meSidebarPosition = eSidebarPosition;
 914 }
 915
 916 void SwAnnotationWin::SetReadonly(bool bSet)
 917 {
 918     mbReadonly = bSet;
 919     GetOutlinerView()->SetReadOnly(bSet);
 920 }
 921
 922 void SwAnnotationWin::SetLanguage(const SvxLanguageItem& rNewItem)
 923 {
 924     IDocumentUndoRedo& rUndoRedo(
 925         mrView.GetDocShell()->GetDoc()->GetIDocumentUndoRedo());
 926     const bool bDocUndoEnabled = rUndoRedo.DoesUndo();
 927     const bool bOutlinerUndoEnabled = mpOutliner->IsUndoEnabled();
 928     const bool bOutlinerModified = mpOutliner->IsModified();
 929     const bool bDisableAndRestoreUndoMode = !bDocUndoEnabled && bOutlinerUndoEnabled;
 930
 931     if (bDisableAndRestoreUndoMode)
 932     {
 933         // doc undo is disabled, but outliner was enabled, turn outliner undo off
 934         // for the duration of this function
 935         mpOutliner->EnableUndo(false);
 936     }
 937
 938     Link<LinkParamNone*,void> aLink = mpOutliner->GetModifyHdl();
 939     mpOutliner->SetModifyHdl( Link<LinkParamNone*,void>() );
 940     ESelection aOld = GetOutlinerView()->GetSelection();
 941
 942     ESelection aNewSelection( 0, 0, mpOutliner->GetParagraphCount()-1, EE_TEXTPOS_ALL );
 943     GetOutlinerView()->SetSelection( aNewSelection );
 944     SfxItemSet aEditAttr(GetOutlinerView()->GetAttribs());
 945     aEditAttr.Put(rNewItem);
 946     GetOutlinerView()->SetAttribs( aEditAttr );
 947
 948     if (!mpOutliner->IsUndoEnabled() && !bOutlinerModified)
 949     {
 950         // if undo was disabled (e.g. this is a redo action) and we were
 951         // originally 'unmodified' keep it that way
 952         mpOutliner->ClearModifyFlag();
 953     }
 954
 955     GetOutlinerView()->SetSelection(aOld);
 956     mpOutliner->SetModifyHdl( aLink );
 957
 958     EEControlBits nCntrl = mpOutliner->GetControlWord();
 959     // turn off
 960     nCntrl &= ~EEControlBits::ONLINESPELLING;
 961     mpOutliner->SetControlWord(nCntrl);
 962
 963     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
 964     {
 965         const SwViewOption* pVOpt = pWrtShell->GetViewOptions();
 966         //turn back on
 967         if (pVOpt->IsOnlineSpell())
 968             nCntrl |= EEControlBits::ONLINESPELLING;
 969         else
 970             nCntrl &= ~EEControlBits::ONLINESPELLING;
 971     }
 972     mpOutliner->SetControlWord(nCntrl);
 973
 974     mpOutliner->CompleteOnlineSpelling();
 975
 976     // restore original mode
 977     if (bDisableAndRestoreUndoMode)
 978         mpOutliner->EnableUndo(true);
 979
 980     Invalidate();
 981 }
 982
 983 void SwAnnotationWin::GetFocus()
 984 {
 985     if (mxSidebarTextControl)
 986         mxSidebarTextControl->GrabFocus();
 987 }
 988
 989 void SwAnnotationWin::LoseFocus()
 990 {
 991 }
 992
 993 void SwAnnotationWin::ShowNote()
 994 {
 995     SetPosAndSize();
 996     if (!IsVisible())
 997         Window::Show();
 998     if (mpShadow && !mpShadow->isVisible())
 999         mpShadow->setVisible(true);
1000     if (mpAnchor && !mpAnchor->isVisible())
1001         mpAnchor->setVisible(true);
1002     if (mpTextRangeOverlay && !mpTextRangeOverlay->isVisible())
1003         mpTextRangeOverlay->setVisible(true);
1004
1005     collectUIInformation("SHOW",get_id());
1006 }
1007
1008 void SwAnnotationWin::HideNote()
1009 {
1010     if (IsVisible())
1011         Window::Hide();
1012     if (mpAnchor)
1013     {
1014         if (mrMgr.IsShowAnchor())
1015             mpAnchor->SetAnchorState(AnchorState::Tri);
1016         else
1017             mpAnchor->setVisible(false);
1018     }
1019     if (mpShadow && mpShadow->isVisible())
1020         mpShadow->setVisible(false);
1021     if (mpTextRangeOverlay && mpTextRangeOverlay->isVisible())
1022         mpTextRangeOverlay->setVisible(false);
1023     collectUIInformation("HIDE",get_id());
1024 }
1025
1026 void SwAnnotationWin::ActivatePostIt()
1027 {
1028     mrMgr.AssureStdModeAtShell();
1029
1030     mpOutliner->ClearModifyFlag();
1031     mpOutliner->GetUndoManager().Clear();
1032
1033     CheckMetaText();
1034     SetViewState(ViewState::EDIT);
1035
1036     // prevent autoscroll to the old cursor location
1037     // when cursor out of visible area
1038     GetOutlinerView()->ShowCursor(false);
1039
1040     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
1041         mpOutlinerView->GetEditView().SetInsertMode(pWrtShell->IsInsMode());
1042
1043     if ( !Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
1044         GetOutlinerView()->SetBackgroundColor(mColorDark);
1045
1046     //tdf#119130 only have the active postit as a dialog control in which pressing
1047     //ctrl+tab cycles between text and button so we don't waste time searching
1048     //thousands of SwAnnotationWins
1049     SetStyle(GetStyle() | WB_DIALOGCONTROL);
1050 }
1051
1052 void SwAnnotationWin::DeactivatePostIt()
1053 {
1054     //tdf#119130 only have the active postit as a dialog control in which pressing
1055     //ctrl+tab cycles between text and button so we don't waste time searching
1056     //thousands of SwAnnotationWins
1057     SetStyle(GetStyle() & ~WB_DIALOGCONTROL);
1058
1059     // remove selection, #i87073#
1060     if (GetOutlinerView()->GetEditView().HasSelection())
1061     {
1062         ESelection aSelection = GetOutlinerView()->GetEditView().GetSelection();
1063         aSelection.nEndPara = aSelection.nStartPara;
1064         aSelection.nEndPos = aSelection.nStartPos;
1065         GetOutlinerView()->GetEditView().SetSelection(aSelection);
1066     }
1067
1068     mpOutliner->CompleteOnlineSpelling();
1069
1070     SetViewState(ViewState::NORMAL);
1071     // Make sure this view doesn't emit LOK callbacks during the update, as the
1072     // sidebar window's SidebarTextControl doesn't have a valid twip offset
1073     // (map mode origin) during that operation.
1074     bool bTiledPainting = comphelper::LibreOfficeKit::isTiledPainting();
1075     comphelper::LibreOfficeKit::setTiledPainting(true);
1076     // write the visible text back into the SwField
1077     UpdateData();
1078     comphelper::LibreOfficeKit::setTiledPainting(bTiledPainting);
1079
1080     if ( !Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
1081         GetOutlinerView()->SetBackgroundColor(COL_TRANSPARENT);
1082
1083     if (!mnDeleteEventId && !IsReadOnlyOrProtected() && mpOutliner->GetEditEngine().GetText().isEmpty())
1084     {
1085         mnDeleteEventId = Application::PostUserEvent( LINK( this, SwAnnotationWin, DeleteHdl), nullptr, true );
1086     }
1087 }
1088
1089 void SwAnnotationWin::ToggleInsMode()
1090 {
1091     if (!mrView.GetWrtShell().IsRedlineOn())
1092     {
1093         //change outliner
1094         mpOutlinerView->GetEditView().SetInsertMode(!mpOutlinerView->GetEditView().IsInsertMode());
1095         //change document
1096         mrView.GetWrtShell().ToggleInsMode();
1097         //update statusbar
1098         SfxBindings &rBnd = mrView.GetViewFrame().GetBindings();
1099         rBnd.Invalidate(SID_ATTR_INSERT);
1100         rBnd.Update(SID_ATTR_INSERT);
1101     }
1102 }
1103
1104 void SwAnnotationWin::ExecuteCommand(sal_uInt16 nSlot)
1105 {
1106     mrMgr.AssureStdModeAtShell();
1107
1108     switch (nSlot)
1109     {
1110         case FN_POSTIT:
1111         case FN_REPLY:
1112         {
1113             // if this note is empty, it will be deleted once losing the focus, so no reply, but only a new note
1114             // will be created
1115             if (!mpOutliner->GetEditEngine().GetText().isEmpty())
1116             {
1117                 OutlinerParaObject aPara(GetOutlinerView()->GetEditView().CreateTextObject());
1118                 mrMgr.RegisterAnswer(&aPara);
1119             }
1120             if (mrMgr.HasActiveSidebarWin())
1121                 mrMgr.SetActiveSidebarWin(nullptr);
1122             SwitchToFieldPos();
1123             mrView.GetViewFrame().GetDispatcher()->Execute(FN_POSTIT);
1124
1125             if (nSlot == FN_REPLY)
1126             {
1127                 // Get newly created SwPostItField and set its paraIdParent
1128                 auto pPostItField = mrMgr.GetLatestPostItField();
1129                 pPostItField->SetParentId(GetTopReplyNote()->GetParaId());
1130             }
1131             break;
1132         }
1133         case FN_DELETE_COMMENT:
1134             //Delete(); // do not kill the parent of our open popup menu
1135             mnDeleteEventId = Application::PostUserEvent( LINK( this, SwAnnotationWin, DeleteHdl), nullptr, true );
1136             break;
1137         case FN_DELETE_COMMENT_THREAD:
1138             DeleteThread();
1139             break;
1140         case FN_RESOLVE_NOTE:
1141             ToggleResolved();
1142             DoResize();
1143             Invalidate();
1144             mrMgr.LayoutPostIts();
1145             break;
1146         case FN_RESOLVE_NOTE_THREAD:
1147             GetTopReplyNote()->SetResolved(!IsThreadResolved());
1148             mrMgr.UpdateResolvedStatus(GetTopReplyNote());
1149             DoResize();
1150             Invalidate();
1151             mrMgr.LayoutPostIts();
1152             break;
1153         case FN_FORMAT_ALL_NOTES:
1154         case FN_DELETE_ALL_NOTES:
1155         case FN_HIDE_ALL_NOTES:
1156             // not possible as slot as this would require that "this" is the active postit
1157             mrView.GetViewFrame().GetBindings().Execute( nSlot, nullptr, SfxCallMode::ASYNCHRON );
1158             break;
1159         case FN_DELETE_NOTE_AUTHOR:
1160         case FN_HIDE_NOTE_AUTHOR:
1161         {
1162             // not possible as slot as this would require that "this" is the active postit
1163             SfxStringItem aItem( nSlot, GetAuthor() );
1164             const SfxPoolItem* aItems[2];
1165             aItems[0] = &aItem;
1166             aItems[1] = nullptr;
1167             mrView.GetViewFrame().GetBindings().Execute( nSlot, aItems, SfxCallMode::ASYNCHRON );
1168         }
1169             break;
1170         default:
1171             mrView.GetViewFrame().GetBindings().Execute( nSlot );
1172             break;
1173     }
1174 }
1175
1176 SwEditWin&  SwAnnotationWin::EditWin()
1177 {
1178     return mrView.GetEditWin();
1179 }
1180
1181 tools::Long SwAnnotationWin::GetPostItTextHeight()
1182 {
1183     return mpOutliner ? LogicToPixel(mpOutliner->CalcTextSize()).Height() : 0;
1184 }
1185
1186 void SwAnnotationWin::SwitchToPostIt(sal_uInt16 aDirection)
1187 {
1188     SwAnnotationWin* pPostIt = mrMgr.GetNextPostIt(aDirection, this);
1189     if (pPostIt)
1190         pPostIt->GrabFocus();
1191 }
1192
1193 IMPL_LINK(SwAnnotationWin, MouseMoveHdl, const MouseEvent&, rMEvt, bool)
1194 {
1195     if (rMEvt.IsEnterWindow())
1196     {
1197         mbMouseOver = true;
1198         if ( !HasFocus() )
1199         {
1200             SetViewState(ViewState::VIEW);
1201             Invalidate();
1202         }
1203     }
1204     else if (rMEvt.IsLeaveWindow())
1205     {
1206         mbMouseOver = false;
1207         if ( !HasFocus() )
1208         {
1209             SetViewState(ViewState::NORMAL);
1210             Invalidate();
1211         }
1212     }
1213     return false;
1214 }
1215
1216 bool SwAnnotationWin::SetActiveSidebarWin()
1217 {
1218     if (mrMgr.GetActiveSidebarWin() == this)
1219         return false;
1220     mrView.GetWrtShell().LockView( true );
1221     mrMgr.SetActiveSidebarWin(this);
1222     mrView.GetWrtShell().LockView( true );
1223
1224     return true;
1225 }
1226
1227 void SwAnnotationWin::UnsetActiveSidebarWin()
1228 {
1229     if (mrMgr.GetActiveSidebarWin() != this)
1230         return;
1231     mrView.GetWrtShell().LockView( true );
1232     mrMgr.SetActiveSidebarWin(nullptr);
1233     mrView.GetWrtShell().LockView( false );
1234 }
1235
1236 void SwAnnotationWin::LockView(bool bLock)
1237 {
1238     mrView.GetWrtShell().LockView( bLock );
1239 }
1240
1241 IMPL_LINK(SwAnnotationWin, ScrollHdl, weld::ScrolledWindow&, rScrolledWindow, void)
1242 {
1243     tools::Long nDiff = GetOutlinerView()->GetEditView().GetVisArea().Top() - rScrolledWindow.vadjustment_get_value();
1244     GetOutlinerView()->Scroll( 0, nDiff );
1245 }
1246
1247 IMPL_LINK_NOARG(SwAnnotationWin, ModifyHdl, LinkParamNone*, void)
1248 {
1249     mrView.GetDocShell()->SetModified();
1250 }
1251
1252 IMPL_LINK_NOARG(SwAnnotationWin, DeleteHdl, void*, void)
1253 {
1254     mnDeleteEventId = nullptr;
1255     Delete();
1256 }
1257
1258 void SwAnnotationWin::ResetAttributes()
1259 {
1260     mpOutlinerView->RemoveAttribsKeepLanguages(true);
1261     mpOutliner->RemoveFields();
1262     mpOutlinerView->SetAttribs(DefaultItem());
1263 }
1264
1265 int SwAnnotationWin::GetPrefScrollbarWidth() const
1266 {
1267     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
1268     {
1269         const Fraction& f(pWrtShell->GetOut()->GetMapMode().GetScaleY());
1270         return tools::Long(Application::GetSettings().GetStyleSettings().GetScrollBarSize() * f);
1271     }
1272     else
1273         return tools::Long(Application::GetSettings().GetStyleSettings().GetScrollBarSize());
1274 }
1275
1276 sal_Int32 SwAnnotationWin::GetMetaHeight() const
1277 {
1278     const int fields = GetNumFields();
1279
1280     sal_Int32 nRequiredHeight = 0;
1281     weld::Label* aLabels[3] = { mxMetadataAuthor.get(), mxMetadataDate.get(), mxMetadataResolved.get() };
1282     for (int i = 0; i < fields; ++i)
1283         nRequiredHeight += aLabels[i]->get_preferred_size().Height();
1284
1285     return nRequiredHeight;
1286 }
1287
1288 sal_Int32 SwAnnotationWin::GetNumFields() const
1289 {
1290     return IsResolved() ? 3 : 2;
1291 }
1292
1293 sal_Int32 SwAnnotationWin::GetMinimumSizeWithMeta() const
1294 {
1295     return mrMgr.GetMinimumSizeWithMeta();
1296 }
1297
1298 sal_Int32 SwAnnotationWin::GetMinimumSizeWithoutMeta() const
1299 {
1300     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
1301     {
1302         const Fraction& f(pWrtShell->GetOut()->GetMapMode().GetScaleY());
1303         return tools::Long(POSTIT_MINIMUMSIZE_WITHOUT_META * f);
1304     }
1305     else
1306         return tools::Long(POSTIT_MINIMUMSIZE_WITHOUT_META);
1307 }
1308
1309 void SwAnnotationWin::SetSpellChecking()
1310 {
1311     if (SwWrtShell* pWrtShell = mrView.GetWrtShellPtr())
1312     {
1313         const SwViewOption* pVOpt = pWrtShell->GetViewOptions();
1314         EEControlBits nCntrl = mpOutliner->GetControlWord();
1315         if (pVOpt->IsOnlineSpell())
1316             nCntrl |= EEControlBits::ONLINESPELLING;
1317         else
1318             nCntrl &= ~EEControlBits::ONLINESPELLING;
1319         mpOutliner->SetControlWord(nCntrl);
1320
1321         mpOutliner->CompleteOnlineSpelling();
1322         Invalidate();
1323     }
1324 }
1325
1326 void SwAnnotationWin::SetViewState(ViewState bViewState)
1327 {
1328     switch (bViewState)
1329     {
1330         case ViewState::EDIT:
1331         {
1332             if (mpAnchor)
1333             {
1334                 mpAnchor->SetAnchorState(AnchorState::All);
1335                 SwAnnotationWin* pWin = GetTopReplyNote();
1336                 // #i111964#
1337                 if ( pWin != this && pWin->Anchor() )
1338                 {
1339                     pWin->Anchor()->SetAnchorState(AnchorState::End);
1340                 }
1341                 mpAnchor->setLineSolid(true);
1342                 if ( mpTextRangeOverlay != nullptr )
1343                 {
1344                     mpTextRangeOverlay->ShowSolidBorder();
1345                 }
1346             }
1347             if (mpShadow)
1348                 mpShadow->SetShadowState(SS_EDIT);
1349             break;
1350         }
1351         case ViewState::VIEW:
1352         {
1353             if (mpAnchor)
1354             {
1355                 mpAnchor->setLineSolid(true);
1356                 if ( mpTextRangeOverlay != nullptr )
1357                 {
1358                     mpTextRangeOverlay->ShowSolidBorder();
1359                 }
1360             }
1361             if (mpShadow)
1362                 mpShadow->SetShadowState(SS_VIEW);
1363             break;
1364         }
1365         case ViewState::NORMAL:
1366         {
1367             if (mpAnchor)
1368             {
1369                 if (IsFollow())
1370                 {
1371                     // if there is no visible parent note, we want to see the complete anchor ??
1372                     //if (IsAnyStackParentVisible())
1373                     mpAnchor->SetAnchorState(AnchorState::End);
1374                     SwAnnotationWin* pTopWinSelf = GetTopReplyNote();
1375                     SwAnnotationWin* pTopWinActive = mrMgr.HasActiveSidebarWin()
1376                                                   ? mrMgr.GetActiveSidebarWin()->GetTopReplyNote()
1377                                                   : nullptr;
1378                     // #i111964#
1379                     if ( ( pTopWinSelf != this ) &&
1380                          ( pTopWinSelf != pTopWinActive ) &&
1381                          pTopWinSelf->Anchor() )
1382                     {
1383                         if ( pTopWinSelf != mrMgr.GetActiveSidebarWin() )
1384                         {
1385                             pTopWinSelf->Anchor()->setLineSolid(false);
1386                             if ( pTopWinSelf->TextRange() != nullptr )
1387                             {
1388                                 pTopWinSelf->TextRange()->HideSolidBorder();
1389                             }
1390                         }
1391                         pTopWinSelf->Anchor()->SetAnchorState(AnchorState::All);
1392                     }
1393                 }
1394                 mpAnchor->setLineSolid(false);
1395                 if ( mpTextRangeOverlay != nullptr )
1396                 {
1397                     mpTextRangeOverlay->HideSolidBorder();
1398                 }
1399             }
1400             if ( mpShadow )
1401             {
1402                 mpShadow->SetShadowState(SS_NORMAL);
1403             }
1404             break;
1405         }
1406     }
1407 }
1408
1409 SwAnnotationWin* SwAnnotationWin::GetTopReplyNote()
1410 {
1411     SwAnnotationWin* pTopNote = this;
1412     SwAnnotationWin* pSidebarWin = IsFollow() ? mrMgr.GetNextPostIt(KEY_PAGEUP, this) : nullptr;
1413     while (pSidebarWin)
1414     {
1415         pTopNote = pSidebarWin;
1416         pSidebarWin = pSidebarWin->IsFollow() ? mrMgr.GetNextPostIt(KEY_PAGEUP, pSidebarWin) : nullptr;
1417     }
1418     return pTopNote;
1419 }
1420
1421 void SwAnnotationWin::SwitchToFieldPos()
1422 {
1423     if ( mrMgr.GetActiveSidebarWin() == this )
1424             mrMgr.SetActiveSidebarWin(nullptr);
1425     GotoPos();
1426     sal_uInt32 aCount = MoveCaret();
1427     if (aCount)
1428         mrView.GetDocShell()->GetWrtShell()->SwCursorShell::Right(aCount, SwCursorSkipMode::Chars);
1429     GrabFocusToDocument();
1430     collectUIInformation("LEAVE",get_id());
1431 }
1432
1433 void SwAnnotationWin::SetChangeTracking( const SwPostItHelper::SwLayoutStatus aLayoutStatus,
1434                                       const Color& aChangeColor )
1435 {
1436     if ( (mLayoutStatus != aLayoutStatus) ||
1437          (mChangeColor != aChangeColor) )
1438     {
1439         mLayoutStatus = aLayoutStatus;
1440         mChangeColor = aChangeColor;
1441         Invalidate();
1442     }
1443 }
1444
1445 bool SwAnnotationWin::HasScrollbar() const
1446 {
1447     return static_cast<bool>(mxVScrollbar);
1448 }
1449
1450 bool SwAnnotationWin::IsScrollbarVisible() const
1451 {
1452     return HasScrollbar() && mxVScrollbar->get_vpolicy() == VclPolicyType::ALWAYS;
1453 }
1454
1455 void SwAnnotationWin::ChangeSidebarItem( SwSidebarItem const & rSidebarItem )
1456 {
1457 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1458     const bool bAnchorChanged = mpAnchorFrame != rSidebarItem.maLayoutInfo.mpAnchorFrame;
1459     if ( bAnchorChanged )
1460     {
1461         mrMgr.DisconnectSidebarWinFromFrame( *mpAnchorFrame, *this );
1462     }
1463 #endif
1464
1465     mrSidebarItem = rSidebarItem;
1466     mpAnchorFrame = mrSidebarItem.maLayoutInfo.mpAnchorFrame;
1467
1468 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1469     if (mxSidebarWinAccessible)
1470         mxSidebarWinAccessible->ChangeSidebarItem( mrSidebarItem );
1471
1472     if ( bAnchorChanged )
1473     {
1474         mrMgr.ConnectSidebarWinToFrame( *(mrSidebarItem.maLayoutInfo.mpAnchorFrame),
1475                                       mrSidebarItem.GetFormatField(),
1476                                       *this );
1477     }
1478 #endif
1479 }
1480
1481 css::uno::Reference< css::accessibility::XAccessible > SwAnnotationWin::CreateAccessible()
1482 {
1483 #if !ENABLE_WASM_STRIP_ACCESSIBILITY
1484     // This is rather dodgy code. Normally in CreateAccessible, if we want a custom
1485     // object, we return a custom object, but we do no override the default toolkit
1486     // window peer.
1487     if (!mxSidebarWinAccessible)
1488         mxSidebarWinAccessible = new SidebarWinAccessible( *this,
1489                                                           mrView.GetWrtShell(),
1490                                                           mrSidebarItem );
1491 #endif
1492     return mxSidebarWinAccessible;
1493 }
1494
1495 } // eof of namespace sw::sidebarwindows
1496
1497 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */