LibreOffice Module sw (master) 1
edtwin.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 <config_wasm_strip.h>
21
22#include <swtypes.hxx>
23#include <hintids.hxx>
24
25#include <com/sun/star/accessibility/XAccessible.hpp>
26#include <com/sun/star/awt/PopupMenuDirection.hpp>
27#include <com/sun/star/awt/XPopupMenu.hpp>
28#include <com/sun/star/i18n/XBreakIterator.hpp>
29#include <com/sun/star/i18n/ScriptType.hpp>
30#include <com/sun/star/i18n/InputSequenceCheckMode.hpp>
31#include <com/sun/star/i18n/UnicodeScript.hpp>
32#include <com/sun/star/i18n/XExtendedInputSequenceChecker.hpp>
33#include <com/sun/star/ui/ContextMenuExecuteEvent.hpp>
34
35#include <comphelper/scopeguard.hxx>
36#include <comphelper/string.hxx>
37
38#include <vcl/dialoghelper.hxx>
39#include <vcl/inputctx.hxx>
40#include <vcl/help.hxx>
41#include <vcl/weld.hxx>
42#include <vcl/ptrstyle.hxx>
43#include <svl/macitem.hxx>
44#include <unotools/securityoptions.hxx>
45#include <basic/sbxvar.hxx>
46#include <svl/ctloptions.hxx>
47#include <basic/sbx.hxx>
48#include <svl/eitem.hxx>
49#include <svl/stritem.hxx>
50#include <sfx2/ipclient.hxx>
51#include <sfx2/viewfrm.hxx>
52#include <sfx2/request.hxx>
53#include <sfx2/bindings.hxx>
54#include <sfx2/dispatch.hxx>
55#include <svl/ptitem.hxx>
56#include <editeng/sizeitem.hxx>
57#include <editeng/langitem.hxx>
58#include <svx/statusitem.hxx>
59#include <svx/svdview.hxx>
60#include <svx/svdhdl.hxx>
61#include <svx/svdoutl.hxx>
62#include <editeng/editeng.hxx>
63#include <editeng/editview.hxx>
64#include <editeng/svxacorr.hxx>
65#include <editeng/flditem.hxx>
66#include <editeng/colritem.hxx>
67#include <unotools/charclass.hxx>
68#include <unotools/datetime.hxx>
69
70#include <comphelper/lok.hxx>
71#include <sfx2/lokhelper.hxx>
72
73#include <editeng/acorrcfg.hxx>
74#include <bookmark.hxx>
75#include <SwSmartTagMgr.hxx>
76#include <edtdd.hxx>
77#include <edtwin.hxx>
78#include <view.hxx>
79#include <wrtsh.hxx>
80#include <IDocumentDrawModelAccess.hxx>
81#include <IDocumentUndoRedo.hxx>
82#include <textboxhelper.hxx>
83#include <dcontact.hxx>
84#include <fldbas.hxx>
85#include <swmodule.hxx>
86#include <docsh.hxx>
87#include <viewopt.hxx>
88#include <drawbase.hxx>
89#include <dselect.hxx>
90#include <textsh.hxx>
91#include <shdwcrsr.hxx>
92#include <txatbase.hxx>
93#include <fmtanchr.hxx>
94#include <fmtornt.hxx>
95#include <fmthdft.hxx>
96#include <frmfmt.hxx>
97#include <modcfg.hxx>
98#include <fmtcol.hxx>
99#include <wview.hxx>
100#include <gloslst.hxx>
101#include <inputwin.hxx>
102#include <gloshdl.hxx>
103#include <swundo.hxx>
104#include <drwtxtsh.hxx>
105#include <fchrfmt.hxx>
106#include "romenu.hxx"
107#include <initui.hxx>
108#include <frmatr.hxx>
109#include <extinput.hxx>
110#include <acmplwrd.hxx>
111#include <swcalwrp.hxx>
112#include <swdtflvr.hxx>
113#include <breakit.hxx>
114#include <checkit.hxx>
115#include <pagefrm.hxx>
116
117#include <helpids.h>
118#include <cmdid.h>
119#include <uitool.hxx>
120#include <fmtfollowtextflow.hxx>
121#include <toolkit/helper/vclunohelper.hxx>
122#include <charfmt.hxx>
123#include <numrule.hxx>
124#include <pagedesc.hxx>
125#include <svtools/ruler.hxx>
126#include <formatclipboard.hxx>
127#include <vcl/svapp.hxx>
128#include <wordcountdialog.hxx>
129#include <fmtfld.hxx>
130
131#include <IMark.hxx>
132#include <doc.hxx>
133#include <xmloff/odffields.hxx>
134
135#include <PostItMgr.hxx>
136#include <FrameControlsManager.hxx>
137#include <AnnotationWin.hxx>
138
139#include <algorithm>
140#include <vector>
141
142#include <rootfrm.hxx>
143
144#include <unotools/syslocaleoptions.hxx>
145#include <i18nlangtag/mslangid.hxx>
146#include <salhelper/singletonref.hxx>
147#include <sfx2/event.hxx>
148#include <memory>
149
150#include "../../core/crsr/callnk.hxx"
151#include <IDocumentOutlineNodes.hxx>
152#include <ndtxt.hxx>
153#include <cntfrm.hxx>
154#include <txtfrm.hxx>
155#include <strings.hrc>
156#include <textcontentcontrol.hxx>
157#include <contentcontrolbutton.hxx>
158
159using namespace sw::mark;
160using namespace ::com::sun::star;
161
165static bool g_bInputLanguageSwitched = false;
166
167// Usually in MouseButtonUp a selection is revoked when the selection is
168// not currently being pulled open. Unfortunately in MouseButtonDown there
169// is being selected at double/triple click. That selection is completely
170// finished in the Handler and thus can't be distinguished in the Up.
171// To resolve this g_bHoldSelection is set in Down and evaluated in Up.
172static bool g_bHoldSelection = false;
173
174bool g_bFrameDrag = false;
175static bool g_bValidCursorPos = false;
176bool g_bModePushed = false;
177bool g_bDDTimerStarted = false;
178bool g_bDDINetAttr = false;
179static SdrHdlKind g_eSdrMoveHdl = SdrHdlKind::User;
180
181QuickHelpData* SwEditWin::s_pQuickHlpData = nullptr;
182
183tools::Long SwEditWin::s_nDDStartPosY = 0;
184tools::Long SwEditWin::s_nDDStartPosX = 0;
185
186static SfxShell* lcl_GetTextShellFromDispatcher( SwView const & rView );
187
189static bool lcl_goIntoTextBox(SwEditWin& rEditWin, SwWrtShell& rSh)
190{
191 SdrMark* pMark = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0);
192 if (!pMark)
193 return false;
194
195 SdrObject* pSdrObject = pMark->GetMarkedSdrObj();
196 SwFrameFormat* pObjectFormat = ::FindFrameFormat(pSdrObject);
197 if (SwFrameFormat* pTextBoxFormat = SwTextBoxHelper::getOtherTextBoxFormat(pObjectFormat, RES_DRAWFRMFMT))
198 {
199 SdrObject* pTextBox = pTextBoxFormat->FindRealSdrObject();
200 SdrView* pSdrView = rSh.GetDrawView();
201 // Unmark the shape.
202 pSdrView->UnmarkAllObj();
203 // Mark the textbox.
204 rSh.SelectObj(Point(), SW_ALLOW_TEXTBOX, pTextBox);
205 // Clear the DrawFuncPtr.
206 rEditWin.StopInsFrame();
207 return true;
208 }
209 return false;
210}
211
212class SwAnchorMarker
213{
214 SdrHdl* m_pHdl;
215 Point m_aHdlPos;
216 Point m_aLastPos;
217 bool m_bTopRightHandle;
218public:
219 explicit SwAnchorMarker( SdrHdl* pH )
220 : m_pHdl( pH )
221 , m_aHdlPos( pH->GetPos() )
222 , m_aLastPos( pH->GetPos() )
223 , m_bTopRightHandle( pH->GetKind() == SdrHdlKind::Anchor_TR )
224 {}
225 const Point& GetLastPos() const { return m_aLastPos; }
226 void SetLastPos( const Point& rNew ) { m_aLastPos = rNew; }
227 void SetPos( const Point& rNew ) { m_pHdl->SetPos( rNew ); }
228 const Point& GetHdlPos() const { return m_aHdlPos; }
229 SdrHdl* GetHdl() const { return m_pHdl; }
230 void ChgHdl( SdrHdl* pNew )
231 {
232 m_pHdl = pNew;
233 if ( m_pHdl )
234 {
235 m_bTopRightHandle = (m_pHdl->GetKind() == SdrHdlKind::Anchor_TR);
236 }
237 }
238 Point GetPosForHitTest( const OutputDevice& rOut )
239 {
240 Point aHitTestPos( m_pHdl->GetPos() );
241 aHitTestPos = rOut.LogicToPixel( aHitTestPos );
242 if ( m_bTopRightHandle )
243 {
244 aHitTestPos += Point( -1, 1 );
245 }
246 else
247 {
248 aHitTestPos += Point( 1, 1 );
249 }
250 aHitTestPos = rOut.PixelToLogic( aHitTestPos );
251
252 return aHitTestPos;
253 }
254};
255
257struct QuickHelpData
258{
260 std::vector<std::pair<OUString, sal_uInt16>> m_aHelpStrings;
262 sal_uInt16 nCurArrPos;
263 static constexpr sal_uInt16 nNoPos = std::numeric_limits<sal_uInt16>::max();
264
266 bool m_bIsAutoText;
268 bool m_bIsTip;
270 void* nTipId;
272 bool m_bAppendSpace;
273
275 bool m_bIsDisplayed;
276
277 QuickHelpData() { ClearContent(); }
278
279 void Move( QuickHelpData& rCpy );
280 void ClearContent();
281 void Start(SwWrtShell& rSh, bool bRestart);
282 void Stop( SwWrtShell& rSh );
283
284 bool HasContent() const { return !m_aHelpStrings.empty() && nCurArrPos != nNoPos; }
285 const OUString& CurStr() const { return m_aHelpStrings[nCurArrPos].first; }
286 sal_uInt16 CurLen() const { return m_aHelpStrings[nCurArrPos].second; }
287
289 void Next( bool bEndLess )
290 {
291 if( ++nCurArrPos >= m_aHelpStrings.size() )
292 nCurArrPos = (bEndLess && !m_bIsAutoText ) ? 0 : nCurArrPos-1;
293 }
295 void Previous( bool bEndLess )
296 {
297 if( 0 == nCurArrPos-- )
298 nCurArrPos = (bEndLess && !m_bIsAutoText ) ? m_aHelpStrings.size()-1 : 0;
299 }
300
301 // Fills internal structures with hopefully helpful information.
302 void FillStrArr( SwWrtShell const & rSh, const OUString& rWord );
303 void SortAndFilter(const OUString &rOrigWord);
304};
305
309#define HIT_PIX 2 /* hit tolerance in pixel */
310#define MIN_MOVE 4
311
312static bool IsMinMove(const Point &rStartPos, const Point &rLPt)
313{
314 return std::abs(rStartPos.X() - rLPt.X()) > MIN_MOVE ||
315 std::abs(rStartPos.Y() - rLPt.Y()) > MIN_MOVE;
316}
317
324static bool IsDrawObjSelectable( const SwWrtShell& rSh, const Point& rPt )
325{
326 bool bRet = true;
327 SdrObject* pObj;
328 switch( rSh.GetObjCntType( rPt, pObj ))
329 {
330 case OBJCNT_NONE:
331 case OBJCNT_FLY:
332 case OBJCNT_GRF:
333 case OBJCNT_OLE:
334 bRet = false;
335 break;
336 default:; //prevent warning
337 }
338 return bRet;
339}
340
341/*
342 * Switch pointer
343 */
344void SwEditWin::UpdatePointer(const Point &rLPt, sal_uInt16 nModifier )
345{
346 SetQuickHelpText(OUString());
347 SwWrtShell &rSh = m_rView.GetWrtShell();
348 if( m_pApplyTempl )
349 {
350 PointerStyle eStyle = PointerStyle::Fill;
351 if ( rSh.IsOverReadOnlyPos( rLPt ) )
352 {
353 m_pUserMarker.reset();
354
355 eStyle = PointerStyle::NotAllowed;
356 }
357 else
358 {
359 SwRect aRect;
360 SwRect* pRect = &aRect;
361 const SwFrameFormat* pFormat = nullptr;
362
363 bool bFrameIsValidTarget = false;
364 if( m_pApplyTempl->m_pFormatClipboard )
365 bFrameIsValidTarget = m_pApplyTempl->m_pFormatClipboard->HasContentForThisType( SelectionType::Frame );
366 else if( !m_pApplyTempl->nColor )
367 bFrameIsValidTarget = ( m_pApplyTempl->eType == SfxStyleFamily::Frame );
368
369 if( bFrameIsValidTarget &&
370 nullptr !=(pFormat = rSh.GetFormatFromObj( rLPt, &pRect )) &&
371 dynamic_cast<const SwFlyFrameFormat*>( pFormat) )
372 {
373 //turn on highlight for frame
374 tools::Rectangle aTmp( pRect->SVRect() );
375
376 if ( !m_pUserMarker )
377 {
378 m_pUserMarker.reset(new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp ));
379 }
380 }
381 else
382 {
383 m_pUserMarker.reset();
384 }
385
386 rSh.SwCursorShell::SetVisibleCursor( rLPt );
387 }
388 SetPointer( eStyle );
389 return;
390 }
391
392 if( !rSh.VisArea().Width() )
393 return;
394
395 CurrShell aCurr(&rSh);
396
397 if ( IsChainMode() )
398 {
399 SwRect aRect;
400 SwChainRet nChainable = rSh.Chainable( aRect, *rSh.GetFlyFrameFormat(), rLPt );
401 PointerStyle eStyle = nChainable != SwChainRet::OK
402 ? PointerStyle::ChainNotAllowed : PointerStyle::Chain;
403 if ( nChainable == SwChainRet::OK )
404 {
405 tools::Rectangle aTmp( aRect.SVRect() );
406
407 if ( !m_pUserMarker )
408 {
409 m_pUserMarker.reset(new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp ));
410 }
411 }
412 else
413 {
414 m_pUserMarker.reset();
415 }
416
417 SetPointer( eStyle );
418 return;
419 }
420
421 bool bExecHyperlinks = m_rView.GetDocShell()->IsReadOnly();
422 if ( !bExecHyperlinks )
423 {
424 const bool bSecureOption = SvtSecurityOptions::IsOptionSet( SvtSecurityOptions::EOption::CtrlClickHyperlink );
425 if ( ( bSecureOption && nModifier == KEY_MOD1 ) ||
426 ( !bSecureOption && nModifier != KEY_MOD1 ) )
427 bExecHyperlinks = true;
428 }
429
430 const bool bExecSmarttags = nModifier == KEY_MOD1;
431
432 SdrView *pSdrView = rSh.GetDrawView();
433 bool bPrefSdrPointer = false;
434 bool bHitHandle = false;
435 bool bCntAtPos = false;
436 bool bIsDocReadOnly = m_rView.GetDocShell()->IsReadOnly() &&
437 rSh.IsCursorReadonly();
438 m_aActHitType = SdrHitKind::NONE;
439 PointerStyle eStyle = PointerStyle::Text;
440 if ( !pSdrView )
441 bCntAtPos = true;
442 else if ( (bHitHandle = (pSdrView->PickHandle(rLPt) != nullptr)) )
443 {
444 m_aActHitType = SdrHitKind::Object;
445 bPrefSdrPointer = true;
446 }
447 else
448 {
449 const bool bNotInSelObj = !rSh.IsInsideSelectedObj( rLPt );
450 if ( m_rView.GetDrawFuncPtr() && !m_bInsDraw && bNotInSelObj )
451 {
452 m_aActHitType = SdrHitKind::Object;
453 if (IsObjectSelect())
454 eStyle = PointerStyle::Arrow;
455 else
456 bPrefSdrPointer = true;
457 }
458 else
459 {
460 SdrPageView* pPV = nullptr;
461 pSdrView->SetHitTolerancePixel( HIT_PIX );
462 SdrObject* pObj = (bNotInSelObj && bExecHyperlinks) ?
463 pSdrView->PickObj(rLPt, pSdrView->getHitTolLog(), pPV, SdrSearchOptions::PICKMACRO) :
464 nullptr;
465 if (pObj)
466 {
467 SdrObjMacroHitRec aTmp;
468 aTmp.aPos = rLPt;
469 aTmp.pPageView = pPV;
470 SetPointer( pObj->GetMacroPointer( aTmp ) );
471 return;
472 }
473 else
474 {
475 // dvo: IsObjSelectable() eventually calls SdrView::PickObj, so
476 // apparently this is used to determine whether this is a
477 // drawling layer object or not.
478 if ( rSh.IsObjSelectable( rLPt ) )
479 {
480 if (pSdrView->IsTextEdit())
481 {
482 m_aActHitType = SdrHitKind::NONE;
483 bPrefSdrPointer = true;
484 }
485 else
486 {
487 SdrViewEvent aVEvt;
488 SdrHitKind eHit = pSdrView->PickAnything(rLPt, aVEvt);
489
490 if (eHit == SdrHitKind::UrlField && bExecHyperlinks)
491 {
492 m_aActHitType = SdrHitKind::Object;
493 bPrefSdrPointer = true;
494 }
495 else
496 {
497 // if we're over a selected object, we show an
498 // ARROW by default. We only show a MOVE if 1) the
499 // object is selected, and 2) it may be moved
500 // (i.e., position is not protected).
501 bool bMovable =
502 (!bNotInSelObj) &&
503 (rSh.IsObjSelected() || rSh.IsFrameSelected()) &&
504 (rSh.IsSelObjProtected(FlyProtectFlags::Pos) == FlyProtectFlags::NONE);
505
506 SdrObject* pSelectableObj = rSh.GetObjAt(rLPt);
507 // Don't update pointer if this is a background image only.
508 if (pSelectableObj->GetLayer() != rSh.GetDoc()->getIDocumentDrawModelAccess().GetHellId())
509 eStyle = bMovable ? PointerStyle::Move : PointerStyle::Arrow;
510 m_aActHitType = SdrHitKind::Object;
511 }
512 }
513 }
514 else
515 {
516 if ( rSh.IsFrameSelected() && !bNotInSelObj )
517 {
518 // dvo: this branch appears to be dead and should be
519 // removed in a future version. Reason: The condition
520 // !bNotInSelObj means that this branch will only be
521 // executed in the cursor points inside a selected
522 // object. However, if this is the case, the previous
523 // if( rSh.IsObjSelectable(rLPt) ) must always be true:
524 // rLPt is inside a selected object, then obviously
525 // rLPt is over a selectable object.
526 if (rSh.IsSelObjProtected(FlyProtectFlags::Size) != FlyProtectFlags::NONE)
527 eStyle = PointerStyle::NotAllowed;
528 else
529 eStyle = PointerStyle::Move;
530 m_aActHitType = SdrHitKind::Object;
531 }
532 else
533 {
534 if ( m_rView.GetDrawFuncPtr() )
535 bPrefSdrPointer = true;
536 else
537 bCntAtPos = true;
538 }
539 }
540 }
541 }
542 }
543 if ( bPrefSdrPointer )
544 {
545 if (bIsDocReadOnly || (rSh.IsObjSelected() && rSh.IsSelObjProtected(FlyProtectFlags::Content) != FlyProtectFlags::NONE))
546 SetPointer( PointerStyle::NotAllowed );
547 else
548 {
549 if (m_rView.GetDrawFuncPtr() && m_rView.GetDrawFuncPtr()->IsInsertForm() && !bHitHandle)
550 SetPointer( PointerStyle::DrawRect );
551 else
552 SetPointer( pSdrView->GetPreferredPointer( rLPt, rSh.GetOut() ) );
553 }
554 }
555 else
556 {
557 if( !rSh.IsPageAtPos( rLPt ) || m_pAnchorMarker )
558 eStyle = PointerStyle::Arrow;
559 else
560 {
561 // Even if we already have something, prefer URLs if possible.
562 SwContentAtPos aUrlPos(IsAttrAtPos::InetAttr);
563 if (bCntAtPos || rSh.GetContentAtPos(rLPt, aUrlPos))
564 {
565 SwContentAtPos aSwContentAtPos(
566 IsAttrAtPos::Field |
567 IsAttrAtPos::ClickField |
568 IsAttrAtPos::InetAttr |
569 IsAttrAtPos::Ftn |
570 IsAttrAtPos::SmartTag);
571 if( rSh.GetContentAtPos( rLPt, aSwContentAtPos) )
572 {
573 // Is edit inline input field
574 if (IsAttrAtPos::Field == aSwContentAtPos.eContentAtPos
575 && aSwContentAtPos.pFndTextAttr != nullptr
576 && aSwContentAtPos.pFndTextAttr->Which() == RES_TXTATR_INPUTFIELD)
577 {
578 const SwField *pCursorField = rSh.CursorInsideInputField() ? rSh.GetCurField( true ) : nullptr;
579 if (!(pCursorField && pCursorField == aSwContentAtPos.pFndTextAttr->GetFormatField().GetField()))
580 eStyle = PointerStyle::RefHand;
581 }
582 else
583 {
584 const bool bClickToFollow = IsAttrAtPos::InetAttr == aSwContentAtPos.eContentAtPos ||
585 IsAttrAtPos::SmartTag == aSwContentAtPos.eContentAtPos;
586 if( !bClickToFollow ||
587 (IsAttrAtPos::InetAttr == aSwContentAtPos.eContentAtPos && bExecHyperlinks) ||
588 (IsAttrAtPos::SmartTag == aSwContentAtPos.eContentAtPos && bExecSmarttags) )
589 eStyle = PointerStyle::RefHand;
590 }
591 }
592 else if (GetView().GetWrtShell().GetViewOptions()->IsShowOutlineContentVisibilityButton())
593 {
594 aSwContentAtPos.eContentAtPos = IsAttrAtPos::Outline;
595 if (rSh.GetContentAtPos(rLPt, aSwContentAtPos))
596 {
597 if (IsAttrAtPos::Outline == aSwContentAtPos.eContentAtPos)
598 {
599 if (nModifier == KEY_MOD1)
600 {
601 eStyle = PointerStyle::RefHand;
602 // set quick help
603 if(aSwContentAtPos.aFnd.pNode && aSwContentAtPos.aFnd.pNode->IsTextNode())
604 {
605 const SwNodes& rNds = GetView().GetWrtShell().GetDoc()->GetNodes();
606 SwOutlineNodes::size_type nPos;
607 rNds.GetOutLineNds().Seek_Entry(aSwContentAtPos.aFnd.pNode->GetTextNode(), &nPos);
608 SwOutlineNodes::size_type nOutlineNodesCount
609 = rSh.getIDocumentOutlineNodesAccess()->getOutlineNodesCount();
610 int nLevel = rSh.getIDocumentOutlineNodesAccess()->getOutlineLevel(nPos);
611 OUString sQuickHelp(SwResId(STR_CLICK_OUTLINE_CONTENT_TOGGLE_VISIBILITY));
612 if (!rSh.GetViewOptions()->IsTreatSubOutlineLevelsAsContent()
613 && nPos + 1 < nOutlineNodesCount
614 && rSh.getIDocumentOutlineNodesAccess()->getOutlineLevel(nPos + 1) > nLevel)
615 sQuickHelp += " (" + SwResId(STR_CLICK_OUTLINE_CONTENT_TOGGLE_VISIBILITY_EXT) + ")";
616 SetQuickHelpText(sQuickHelp);
617 }
618 }
619 }
620 }
621 }
622 }
623 }
624
625 // which kind of text pointer have we to show - horz / vert - ?
626 if( PointerStyle::Text == eStyle && rSh.IsInVerticalText( &rLPt ))
627 eStyle = PointerStyle::TextVertical;
628 else if (rSh.GetViewOptions()->CanHideWhitespace() &&
629 rSh.GetLayout()->IsBetweenPages(rLPt))
630 {
631 if (rSh.GetViewOptions()->IsHideWhitespaceMode())
632 eStyle = PointerStyle::ShowWhitespace;
633 else
634 eStyle = PointerStyle::HideWhitespace;
635 }
636
637 if( m_pShadCursor )
638 {
639 if( text::HoriOrientation::LEFT == m_eOrient ) // Arrow to the right
640 eStyle = PointerStyle::AutoScrollE;
641 else // Arrow to the left
642 eStyle = PointerStyle::AutoScrollW;
643 }
644
645 SetPointer( eStyle );
646 }
647}
648
652IMPL_LINK_NOARG(SwEditWin, TimerHandler, Timer *, void)
653{
654 SwWrtShell &rSh = m_rView.GetWrtShell();
655 Point aModPt( m_aMovePos );
656 const SwRect aOldVis( rSh.VisArea() );
657 bool bDone = false;
658
659 if ( !rSh.VisArea().Contains( aModPt ) )
660 {
661 if ( m_bInsDraw )
662 {
663 const int nMaxScroll = 40;
664 m_rView.Scroll( tools::Rectangle(aModPt,Size(1,1)), nMaxScroll, nMaxScroll);
665 bDone = true;
666 }
667 else if ( g_bFrameDrag )
668 {
669 rSh.Drag(&aModPt, false);
670 bDone = true;
671 }
672 if ( !bDone )
673 aModPt = rSh.GetContentPos( aModPt,aModPt.Y() > rSh.VisArea().Bottom() );
674 }
675 if ( !bDone && !(g_bFrameDrag || m_bInsDraw) )
676 {
677 if ( m_xRowColumnSelectionStart )
678 {
679 Point aPos( aModPt );
680 rSh.SelectTableRowCol( *m_xRowColumnSelectionStart, &aPos, m_bIsRowDrag );
681 }
682 else
683 rSh.CallSetCursor( &aModPt, false );
684
685 // It can be that a "jump" over a table cannot be accomplished like
686 // that. So we jump over the table by Up/Down here.
687 const SwRect& rVisArea = rSh.VisArea();
688 if( aOldVis == rVisArea && !rSh.IsStartOfDoc() && !rSh.IsEndOfDoc() )
689 {
690 // take the center point of VisArea to
691 // decide in which direction the user want.
692 if( aModPt.Y() < ( rVisArea.Top() + rVisArea.Height() / 2 ) )
693 rSh.Up( true );
694 else
695 rSh.Down( true );
696 }
697 }
698
699 m_aMovePos += rSh.VisArea().Pos() - aOldVis.Pos();
700 JustifyAreaTimer();
701}
702
703void SwEditWin::JustifyAreaTimer()
704{
705 const tools::Rectangle &rVisArea = GetView().GetVisArea();
706#ifdef UNX
707 const tools::Long coMinLen = 100;
708#else
709 const tools::Long coMinLen = 50;
710#endif
711 tools::Long const nTimeout = 800,
712 nDiff = std::max(
713 std::max( m_aMovePos.Y() - rVisArea.Bottom(), rVisArea.Top() - m_aMovePos.Y() ),
714 std::max( m_aMovePos.X() - rVisArea.Right(), rVisArea.Left() - m_aMovePos.X()));
715 m_aTimer.SetTimeout( std::max( coMinLen, nTimeout - nDiff*2L) );
716}
717
718void SwEditWin::LeaveArea(const Point &rPos)
719{
720 m_aMovePos = rPos;
721 JustifyAreaTimer();
722 if( !m_aTimer.IsActive() )
723 m_aTimer.Start();
724 m_pShadCursor.reset();
725}
726
727inline void SwEditWin::EnterArea()
728{
729 m_aTimer.Stop();
730}
731
735void SwEditWin::InsFrame(sal_uInt16 nCols)
736{
737 StdDrawMode(SdrObjKind::NewFrame, false);
738 m_bInsFrame = true;
739 m_nInsFrameColCount = nCols;
740}
741
742void SwEditWin::StdDrawMode( SdrObjKind eSdrObjectKind, bool bObjSelect )
743{
744 SetSdrDrawMode( eSdrObjectKind );
745
746 if (bObjSelect)
747 m_rView.SetDrawFuncPtr(std::make_unique<DrawSelection>( &m_rView.GetWrtShell(), this, &m_rView ));
748 else
749 m_rView.SetDrawFuncPtr(std::make_unique<SwDrawBase>( &m_rView.GetWrtShell(), this, &m_rView ));
750
751 m_rView.SetSelDrawSlot();
752 SetSdrDrawMode( eSdrObjectKind );
753 if (bObjSelect)
754 m_rView.GetDrawFuncPtr()->Activate( SID_OBJECT_SELECT );
755 else
756 m_rView.GetDrawFuncPtr()->Activate( sal::static_int_cast< sal_uInt16 >(eSdrObjectKind) );
757 m_bInsFrame = false;
758 m_nInsFrameColCount = 1;
759}
760
761void SwEditWin::StopInsFrame()
762{
763 if (m_rView.GetDrawFuncPtr())
764 {
765 m_rView.GetDrawFuncPtr()->Deactivate();
766 m_rView.SetDrawFuncPtr(nullptr);
767 }
768 m_rView.LeaveDrawCreate(); // leave construction mode
769 m_bInsFrame = false;
770 m_nInsFrameColCount = 1;
771}
772
773bool SwEditWin::IsInputSequenceCheckingRequired( const OUString &rText, const SwPaM& rCursor )
774{
775 if ( !SvtCTLOptions::IsCTLFontEnabled() ||
776 !SvtCTLOptions::IsCTLSequenceChecking() )
777 return false;
778
779 if ( 0 == rCursor.Start()->GetContentIndex() ) /* first char needs not to be checked */
780 return false;
781
782 SwBreakIt *pBreakIter = SwBreakIt::Get();
783 uno::Reference < i18n::XBreakIterator > xBI = pBreakIter->GetBreakIter();
784 assert(xBI.is());
785 tools::Long nCTLScriptPos = -1;
786
787 if (xBI->getScriptType( rText, 0 ) == i18n::ScriptType::COMPLEX)
788 nCTLScriptPos = 0;
789 else
790 nCTLScriptPos = xBI->nextScript( rText, 0, i18n::ScriptType::COMPLEX );
791
792 return (0 <= nCTLScriptPos && nCTLScriptPos <= rText.getLength());
793}
794
795//return INVALID_HINT if language should not be explicitly overridden, the correct
796//HintId to use for the eBufferLanguage otherwise
797static sal_uInt16 lcl_isNonDefaultLanguage(LanguageType eBufferLanguage, SwView const & rView,
798 const OUString &rInBuffer)
799{
800 sal_uInt16 nWhich = INVALID_HINT;
801
802 //If the option to IgnoreLanguageChange is set, short-circuit this method
803 //which results in the document/paragraph language remaining the same
804 //despite a change to the keyboard/input language
805 SvtSysLocaleOptions aSysLocaleOptions;
806 if(aSysLocaleOptions.IsIgnoreLanguageChange())
807 {
808 return INVALID_HINT;
809 }
810
811 bool bLang = true;
812 if(eBufferLanguage != LANGUAGE_DONTKNOW)
813 {
814 switch( SvtLanguageOptions::GetI18NScriptTypeOfLanguage( eBufferLanguage ))
815 {
816 case i18n::ScriptType::ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break;
817 case i18n::ScriptType::COMPLEX: nWhich = RES_CHRATR_CTL_LANGUAGE; break;
818 case i18n::ScriptType::LATIN: nWhich = RES_CHRATR_LANGUAGE; break;
819 default: bLang = false;
820 }
821 if(bLang)
822 {
823 SfxItemSet aLangSet(rView.GetPool(), nWhich, nWhich);
824 SwWrtShell& rSh = rView.GetWrtShell();
825 rSh.GetCurAttr(aLangSet);
826 if(SfxItemState::DEFAULT <= aLangSet.GetItemState(nWhich))
827 {
828 LanguageType eLang = static_cast<const SvxLanguageItem&>(aLangSet.Get(nWhich)).GetLanguage();
829 if ( eLang == eBufferLanguage )
830 {
831 // current language attribute equal to language reported from system
832 bLang = false;
833 }
834 else if ( !g_bInputLanguageSwitched && RES_CHRATR_LANGUAGE == nWhich )
835 {
836 // special case: switching between two "LATIN" languages
837 // In case the current keyboard setting might be suitable
838 // for both languages we can't safely assume that the user
839 // wants to use the language reported from the system,
840 // except if we knew that it was explicitly switched (thus
841 // the check for "bInputLangeSwitched").
842
843 // The language reported by the system could be just the
844 // system default language that the user is not even aware
845 // of, because no language selection tool is installed at
846 // all. In this case the OOo language should get preference
847 // as it might have been selected by the user explicitly.
848
849 // Usually this case happens if the OOo language is
850 // different to the system language but the system keyboard
851 // is still suitable for the OOo language (e.g. writing
852 // English texts with a German keyboard).
853
854 // For non-latin keyboards overwriting the attribute is
855 // still valid. We do this for cyrillic and greek ATM. In
856 // future versions of OOo this should be replaced by a
857 // configuration switch that allows to give the preference
858 // to the OOo setting or the system setting explicitly
859 // and/or a better handling of the script type.
860 i18n::UnicodeScript eType = !rInBuffer.isEmpty() ?
861 GetAppCharClass().getScript( rInBuffer, 0 ) :
862 i18n::UnicodeScript_kScriptCount;
863
864 bool bSystemIsNonLatin = false;
865 switch ( eType )
866 {
867 case i18n::UnicodeScript_kGreek:
868 case i18n::UnicodeScript_kCyrillic:
869 // in case other UnicodeScripts require special
870 // keyboards they can be added here
871 bSystemIsNonLatin = true;
872 break;
873 default:
874 break;
875 }
876
877 bool bOOoLangIsNonLatin = MsLangId::isNonLatinWestern( eLang);
878
879 bLang = (bSystemIsNonLatin != bOOoLangIsNonLatin);
880 }
881 }
882 }
883 }
884 return bLang ? nWhich : INVALID_HINT;
885}
886
890void SwEditWin::FlushInBuffer()
891{
892 if ( m_aKeyInputFlushTimer.IsActive())
893 m_aKeyInputFlushTimer.Stop();
894
895 if ( m_aInBuffer.isEmpty() )
896 return;
897
898 SwWrtShell& rSh = m_rView.GetWrtShell();
899
900 // generate new sequence input checker if not already done
901 if ( !pCheckIt )
902 pCheckIt = new SwCheckIt;
903
904 uno::Reference < i18n::XExtendedInputSequenceChecker > xISC = pCheckIt->xCheck;
905 if ( xISC.is() && IsInputSequenceCheckingRequired( m_aInBuffer, *rSh.GetCursor() ) )
906 {
907
908 // apply (Thai) input sequence checking/correction
909
910 rSh.Push(); // push current cursor to stack
911
912 // get text from the beginning (i.e left side) of current selection
913 // to the start of the paragraph
914 rSh.NormalizePam(); // make point be the first (left) one
915 if (!rSh.GetCursor()->HasMark())
916 rSh.GetCursor()->SetMark();
917 rSh.GetCursor()->GetMark()->SetContent(0);
918
919 const OUString aOldText( rSh.GetCursor()->GetText() );
920 const sal_Int32 nOldLen = aOldText.getLength();
921
922 sal_Int32 nExpandSelection = 0;
923 if (nOldLen > 0)
924 {
925 sal_Int32 nTmpPos = nOldLen;
926 sal_Int16 nCheckMode = SvtCTLOptions::IsCTLSequenceCheckingRestricted() ?
927 i18n::InputSequenceCheckMode::STRICT : i18n::InputSequenceCheckMode::BASIC;
928
929 OUString aNewText( aOldText );
930 if (SvtCTLOptions::IsCTLSequenceCheckingTypeAndReplace())
931 {
932 for( sal_Int32 k = 0; k < m_aInBuffer.getLength(); ++k)
933 {
934 const sal_Unicode cChar = m_aInBuffer[k];
935 const sal_Int32 nPrevPos =xISC->correctInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode );
936
937 // valid sequence or sequence could be corrected:
938 if (nPrevPos != aNewText.getLength())
939 nTmpPos = nPrevPos + 1;
940 }
941
942 // find position of first character that has changed
943 sal_Int32 nNewLen = aNewText.getLength();
944 const sal_Unicode *pOldText = aOldText.getStr();
945 const sal_Unicode *pNewText = aNewText.getStr();
946 sal_Int32 nChgPos = 0;
947 while ( nChgPos < nOldLen && nChgPos < nNewLen &&
948 pOldText[nChgPos] == pNewText[nChgPos] )
949 ++nChgPos;
950
951 const sal_Int32 nChgLen = nNewLen - nChgPos;
952 if (nChgLen)
953 {
954 m_aInBuffer = aNewText.copy( nChgPos, nChgLen );
955 nExpandSelection = nOldLen - nChgPos;
956 }
957 else
958 m_aInBuffer.clear();
959 }
960 else
961 {
962 for( sal_Int32 k = 0; k < m_aInBuffer.getLength(); ++k )
963 {
964 const sal_Unicode cChar = m_aInBuffer[k];
965 if (xISC->checkInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode ))
966 {
967 // character can be inserted:
968 aNewText += OUStringChar( cChar );
969 ++nTmpPos;
970 }
971 }
972 m_aInBuffer = aNewText.copy( aOldText.getLength() ); // copy new text to be inserted to buffer
973 }
974 }
975
976 // at this point now we will insert the buffer text 'normally' some lines below...
977
978 rSh.Pop(SwCursorShell::PopMode::DeleteCurrent);
979
980 if (m_aInBuffer.isEmpty())
981 return;
982
983 // if text prior to the original selection needs to be changed
984 // as well, we now expand the selection accordingly.
985 SwPaM &rCursor = *rSh.GetCursor();
986 const sal_Int32 nCursorStartPos = rCursor.Start()->GetContentIndex();
987 OSL_ENSURE( nCursorStartPos >= nExpandSelection, "cannot expand selection as specified!!" );
988 if (nExpandSelection && nCursorStartPos >= nExpandSelection)
989 {
990 if (!rCursor.HasMark())
991 rCursor.SetMark();
992 rCursor.Start()->AdjustContent( -nExpandSelection );
993 }
994 }
995
996 uno::Reference< frame::XDispatchRecorder > xRecorder =
997 m_rView.GetViewFrame().GetBindings().GetRecorder();
998 if ( xRecorder.is() )
999 {
1000 // determine shell
1001 SfxShell *pSfxShell = lcl_GetTextShellFromDispatcher( m_rView );
1002 // generate request and record
1003 if (pSfxShell)
1004 {
1005 SfxRequest aReq(m_rView.GetViewFrame(), FN_INSERT_STRING);
1006 aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, m_aInBuffer ) );
1007 aReq.Done();
1008 }
1009 }
1010
1011 sal_uInt16 nWhich = lcl_isNonDefaultLanguage(m_eBufferLanguage, m_rView, m_aInBuffer);
1012 if (nWhich != INVALID_HINT )
1013 {
1014 SvxLanguageItem aLangItem( m_eBufferLanguage, nWhich );
1015 rSh.SetAttrItem( aLangItem );
1016 }
1017
1018 rSh.Insert( m_aInBuffer );
1019 m_eBufferLanguage = LANGUAGE_DONTKNOW;
1020 m_aInBuffer.clear();
1021}
1022
1023#define MOVE_LEFT_SMALL 0
1024#define MOVE_UP_SMALL 1
1025#define MOVE_RIGHT_BIG 2
1026#define MOVE_DOWN_BIG 3
1027#define MOVE_LEFT_BIG 4
1028#define MOVE_UP_BIG 5
1029#define MOVE_RIGHT_SMALL 6
1030#define MOVE_DOWN_SMALL 7
1031
1032// #i121236# Support for shift key in writer
1033#define MOVE_LEFT_HUGE 8
1034#define MOVE_UP_HUGE 9
1035#define MOVE_RIGHT_HUGE 10
1036#define MOVE_DOWN_HUGE 11
1037
1038void SwEditWin::ChangeFly( sal_uInt8 nDir, bool bWeb )
1039{
1040 SwWrtShell &rSh = m_rView.GetWrtShell();
1041 SwRect aTmp = rSh.GetFlyRect();
1042 if( !aTmp.HasArea() ||
1043 rSh.IsSelObjProtected( FlyProtectFlags::Pos ) != FlyProtectFlags::NONE )
1044 return;
1045
1046 SfxItemSetFixed<
1047 RES_FRM_SIZE, RES_FRM_SIZE,
1048 RES_PROTECT, RES_PROTECT,
1049 RES_VERT_ORIENT, RES_ANCHOR,
1050 RES_COL, RES_COL,
1051 RES_FOLLOW_TEXT_FLOW, RES_FOLLOW_TEXT_FLOW>
1052 aSet( rSh.GetAttrPool() );
1053 rSh.GetFlyFrameAttr( aSet );
1054 RndStdIds eAnchorId = aSet.Get(RES_ANCHOR).GetAnchorId();
1055 Size aSnap;
1056 bool bHuge(MOVE_LEFT_HUGE == nDir ||
1057 MOVE_UP_HUGE == nDir ||
1058 MOVE_RIGHT_HUGE == nDir ||
1059 MOVE_DOWN_HUGE == nDir);
1060
1061 if(MOVE_LEFT_SMALL == nDir ||
1062 MOVE_UP_SMALL == nDir ||
1063 MOVE_RIGHT_SMALL == nDir ||
1064 MOVE_DOWN_SMALL == nDir )
1065 {
1066 aSnap = PixelToLogic(Size(1,1));
1067 }
1068 else
1069 {
1070 aSnap = rSh.GetViewOptions()->GetSnapSize();
1071 short nDiv = rSh.GetViewOptions()->GetDivisionX();
1072 if ( nDiv > 0 )
1073 aSnap.setWidth( std::max( sal_uLong(1), static_cast<sal_uLong>(aSnap.Width()) / nDiv ) );
1074 nDiv = rSh.GetViewOptions()->GetDivisionY();
1075 if ( nDiv > 0 )
1076 aSnap.setHeight( std::max( sal_uLong(1), static_cast<sal_uLong>(aSnap.Height()) / nDiv ) );
1077 }
1078
1079 if(bHuge)
1080 {
1081 // #i121236# 567twips == 1cm, but just take three times the normal snap
1082 aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
1083 }
1084
1085 SwRect aBoundRect;
1086 Point aRefPoint;
1087 // adjustment for allowing vertical position
1088 // aligned to page for fly frame anchored to paragraph or to character.
1089 {
1090 const SwFormatVertOrient& aVert( aSet.Get(RES_VERT_ORIENT) );
1091 const bool bFollowTextFlow =
1092 aSet.Get(RES_FOLLOW_TEXT_FLOW).GetValue();
1093 const SwFormatAnchor& rFormatAnchor = aSet.Get(RES_ANCHOR);
1094 rSh.CalcBoundRect( aBoundRect, eAnchorId,
1095 text::RelOrientation::FRAME, aVert.GetRelationOrient(),
1096 &rFormatAnchor, bFollowTextFlow,
1097 false, &aRefPoint );
1098 }
1099 tools::Long nLeft = std::min( aTmp.Left() - aBoundRect.Left(), aSnap.Width() );
1100 tools::Long nRight = std::min( aBoundRect.Right() - aTmp.Right(), aSnap.Width() );
1101 tools::Long nUp = std::min( aTmp.Top() - aBoundRect.Top(), aSnap.Height() );
1102 tools::Long nDown = std::min( aBoundRect.Bottom() - aTmp.Bottom(), aSnap.Height() );
1103
1104 switch ( nDir )
1105 {
1106 case MOVE_LEFT_BIG:
1107 case MOVE_LEFT_HUGE:
1108 case MOVE_LEFT_SMALL: aTmp.Left( aTmp.Left() - nLeft );
1109 break;
1110
1111 case MOVE_UP_BIG:
1112 case MOVE_UP_HUGE:
1113 case MOVE_UP_SMALL: aTmp.Top( aTmp.Top() - nUp );
1114 break;
1115
1116 case MOVE_RIGHT_SMALL:
1117 if( aTmp.Width() < aSnap.Width() + MINFLY )
1118 break;
1119 nRight = aSnap.Width();
1120 [[fallthrough]];
1121 case MOVE_RIGHT_HUGE:
1122 case MOVE_RIGHT_BIG: aTmp.Left( aTmp.Left() + nRight );
1123 break;
1124
1125 case MOVE_DOWN_SMALL:
1126 if( aTmp.Height() < aSnap.Height() + MINFLY )
1127 break;
1128 nDown = aSnap.Height();
1129 [[fallthrough]];
1130 case MOVE_DOWN_HUGE:
1131 case MOVE_DOWN_BIG: aTmp.Top( aTmp.Top() + nDown );
1132 break;
1133
1134 default: OSL_ENSURE(true, "ChangeFly: Unknown direction." );
1135 }
1136 bool bSet = false;
1137 if ((RndStdIds::FLY_AS_CHAR == eAnchorId) && ( nDir % 2 ))
1138 {
1139 tools::Long aDiff = aTmp.Top() - aRefPoint.Y();
1140 if( aDiff > 0 )
1141 aDiff = 0;
1142 else if ( aDiff < -aTmp.Height() )
1143 aDiff = -aTmp.Height();
1144 SwFormatVertOrient aVert( aSet.Get(RES_VERT_ORIENT) );
1145 sal_Int16 eNew;
1146 if( bWeb )
1147 {
1148 eNew = aVert.GetVertOrient();
1149 bool bDown = 0 != ( nDir & 0x02 );
1150 switch( eNew )
1151 {
1152 case text::VertOrientation::CHAR_TOP:
1153 if( bDown ) eNew = text::VertOrientation::CENTER;
1154 break;
1155 case text::VertOrientation::CENTER:
1156 eNew = bDown ? text::VertOrientation::TOP : text::VertOrientation::CHAR_TOP;
1157 break;
1158 case text::VertOrientation::TOP:
1159 if( !bDown ) eNew = text::VertOrientation::CENTER;
1160 break;
1161 case text::VertOrientation::LINE_TOP:
1162 if( bDown ) eNew = text::VertOrientation::LINE_CENTER;
1163 break;
1164 case text::VertOrientation::LINE_CENTER:
1165 eNew = bDown ? text::VertOrientation::LINE_BOTTOM : text::VertOrientation::LINE_TOP;
1166 break;
1167 case text::VertOrientation::LINE_BOTTOM:
1168 if( !bDown ) eNew = text::VertOrientation::LINE_CENTER;
1169 break;
1170 default:; //prevent warning
1171 }
1172 }
1173 else
1174 {
1175 aVert.SetPos( aDiff );
1176 eNew = text::VertOrientation::NONE;
1177 }
1178 aVert.SetVertOrient( eNew );
1179 aSet.Put( aVert );
1180 bSet = true;
1181 }
1182 if (bWeb && (RndStdIds::FLY_AT_PARA == eAnchorId)
1183 && ( nDir==MOVE_LEFT_SMALL || nDir==MOVE_RIGHT_BIG ))
1184 {
1185 SwFormatHoriOrient aHori( aSet.Get(RES_HORI_ORIENT) );
1186 sal_Int16 eNew;
1187 eNew = aHori.GetHoriOrient();
1188 switch( eNew )
1189 {
1190 case text::HoriOrientation::RIGHT:
1191 if( nDir==MOVE_LEFT_SMALL )
1192 eNew = text::HoriOrientation::LEFT;
1193 break;
1194 case text::HoriOrientation::LEFT:
1195 if( nDir==MOVE_RIGHT_BIG )
1196 eNew = text::HoriOrientation::RIGHT;
1197 break;
1198 default:; //prevent warning
1199 }
1200 if( eNew != aHori.GetHoriOrient() )
1201 {
1202 aHori.SetHoriOrient( eNew );
1203 aSet.Put( aHori );
1204 bSet = true;
1205 }
1206 }
1207 rSh.StartAllAction();
1208 if( bSet )
1209 rSh.SetFlyFrameAttr( aSet );
1210 bool bSetPos = (RndStdIds::FLY_AS_CHAR != eAnchorId);
1211 if(bSetPos && bWeb)
1212 {
1213 bSetPos = RndStdIds::FLY_AT_PAGE == eAnchorId;
1214 }
1215 if( bSetPos )
1216 rSh.SetFlyPos( aTmp.Pos() );
1217 rSh.EndAllAction();
1218
1219}
1220
1221void SwEditWin::ChangeDrawing( sal_uInt8 nDir )
1222{
1223 // start undo action in order to get only one
1224 // undo action for this change.
1225 SwWrtShell &rSh = m_rView.GetWrtShell();
1226 rSh.StartUndo();
1227
1228 tools::Long nX = 0;
1229 tools::Long nY = 0;
1230 const bool bOnePixel(
1231 MOVE_LEFT_SMALL == nDir ||
1232 MOVE_UP_SMALL == nDir ||
1233 MOVE_RIGHT_SMALL == nDir ||
1234 MOVE_DOWN_SMALL == nDir);
1235 const bool bHuge(
1236 MOVE_LEFT_HUGE == nDir ||
1237 MOVE_UP_HUGE == nDir ||
1238 MOVE_RIGHT_HUGE == nDir ||
1239 MOVE_DOWN_HUGE == nDir);
1240 SwMove nAnchorDir = SwMove::UP;
1241 switch(nDir)
1242 {
1243 case MOVE_LEFT_SMALL:
1244 case MOVE_LEFT_HUGE:
1245 case MOVE_LEFT_BIG:
1246 nX = -1;
1247 nAnchorDir = SwMove::LEFT;
1248 break;
1249 case MOVE_UP_SMALL:
1250 case MOVE_UP_HUGE:
1251 case MOVE_UP_BIG:
1252 nY = -1;
1253 break;
1254 case MOVE_RIGHT_SMALL:
1255 case MOVE_RIGHT_HUGE:
1256 case MOVE_RIGHT_BIG:
1257 nX = +1;
1258 nAnchorDir = SwMove::RIGHT;
1259 break;
1260 case MOVE_DOWN_SMALL:
1261 case MOVE_DOWN_HUGE:
1262 case MOVE_DOWN_BIG:
1263 nY = +1;
1264 nAnchorDir = SwMove::DOWN;
1265 break;
1266 }
1267
1268 if(0 != nX || 0 != nY)
1269 {
1270 FlyProtectFlags nProtect = rSh.IsSelObjProtected( FlyProtectFlags::Pos|FlyProtectFlags::Size );
1271 Size aSnap( rSh.GetViewOptions()->GetSnapSize() );
1272 short nDiv = rSh.GetViewOptions()->GetDivisionX();
1273 if ( nDiv > 0 )
1274 aSnap.setWidth( std::max( sal_uLong(1), static_cast<sal_uLong>(aSnap.Width()) / nDiv ) );
1275 nDiv = rSh.GetViewOptions()->GetDivisionY();
1276 if ( nDiv > 0 )
1277 aSnap.setHeight( std::max( sal_uLong(1), static_cast<sal_uLong>(aSnap.Height()) / nDiv ) );
1278
1279 if(bOnePixel)
1280 {
1281 aSnap = PixelToLogic(Size(1,1));
1282 }
1283 else if(bHuge)
1284 {
1285 // #i121236# 567twips == 1cm, but just take three times the normal snap
1286 aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
1287 }
1288
1289 nX *= aSnap.Width();
1290 nY *= aSnap.Height();
1291
1292 SdrView *pSdrView = rSh.GetDrawView();
1293 const SdrHdlList& rHdlList = pSdrView->GetHdlList();
1294 SdrHdl* pHdl = rHdlList.GetFocusHdl();
1295 rSh.StartAllAction();
1296 if(nullptr == pHdl)
1297 {
1298 // now move the selected draw objects
1299 // if the object's position is not protected
1300 if(!(nProtect&FlyProtectFlags::Pos))
1301 {
1302 // Check if object is anchored as character and move direction
1303 bool bDummy1, bDummy2;
1304 const bool bVertAnchor = rSh.IsFrameVertical( true, bDummy1, bDummy2 );
1305 bool bHoriMove = !bVertAnchor == !( nDir % 2 );
1306 bool bMoveAllowed =
1307 !bHoriMove || (rSh.GetAnchorId() != RndStdIds::FLY_AS_CHAR);
1308 if ( bMoveAllowed )
1309 {
1310 pSdrView->MoveAllMarked(Size(nX, nY));
1311 rSh.SetModified();
1312 }
1313 }
1314 }
1315 else
1316 {
1317 // move handle with index nHandleIndex
1318 if (nX || nY)
1319 {
1320 if( SdrHdlKind::Anchor == pHdl->GetKind() ||
1321 SdrHdlKind::Anchor_TR == pHdl->GetKind() )
1322 {
1323 // anchor move cannot be allowed when position is protected
1324 if(!(nProtect&FlyProtectFlags::Pos))
1325 rSh.MoveAnchor( nAnchorDir );
1326 }
1327 //now resize if size is protected
1328 else if(!(nProtect&FlyProtectFlags::Size))
1329 {
1330 // now move the Handle (nX, nY)
1331 Point aStartPoint(pHdl->GetPos());
1332 Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
1333 const SdrDragStat& rDragStat = pSdrView->GetDragStat();
1334
1335 // start dragging
1336 pSdrView->BegDragObj(aStartPoint, nullptr, pHdl, 0);
1337
1338 if(pSdrView->IsDragObj())
1339 {
1340 bool bWasNoSnap = rDragStat.IsNoSnap();
1341 bool bWasSnapEnabled = pSdrView->IsSnapEnabled();
1342
1343 // switch snapping off
1344 if(!bWasNoSnap)
1345 const_cast<SdrDragStat&>(rDragStat).SetNoSnap();
1346 if(bWasSnapEnabled)
1347 pSdrView->SetSnapEnabled(false);
1348
1349 pSdrView->MovAction(aEndPoint);
1350 pSdrView->EndDragObj();
1351 rSh.SetModified();
1352
1353 // restore snap
1354 if(!bWasNoSnap)
1355 const_cast<SdrDragStat&>(rDragStat).SetNoSnap(bWasNoSnap);
1356 if(bWasSnapEnabled)
1357 pSdrView->SetSnapEnabled(bWasSnapEnabled);
1358 }
1359 }
1360 }
1361 }
1362 rSh.EndAllAction();
1363 }
1364
1365 rSh.EndUndo();
1366}
1367
1371void SwEditWin::KeyInput(const KeyEvent &rKEvt)
1372{
1373 SwWrtShell &rSh = m_rView.GetWrtShell();
1374
1375 if (comphelper::LibreOfficeKit::isActive() && m_rView.GetPostItMgr())
1376 {
1377 if (vcl::Window* pWindow = m_rView.GetPostItMgr()->GetActiveSidebarWin())
1378 {
1379 pWindow->KeyInput(rKEvt);
1380 return;
1381 }
1382 }
1383
1384 if( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE &&
1385 m_pApplyTempl && m_pApplyTempl->m_pFormatClipboard )
1386 {
1387 m_pApplyTempl->m_pFormatClipboard->Erase();
1388 SetApplyTemplate(SwApplyTemplate());
1389 m_rView.GetViewFrame().GetBindings().Invalidate(SID_FORMATPAINTBRUSH);
1390 }
1391 else if ( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE &&
1392 rSh.IsHeaderFooterEdit( ) )
1393 {
1394 bool bHeader = bool(FrameTypeFlags::HEADER & rSh.GetFrameType(nullptr,false));
1395 if ( bHeader )
1396 rSh.SttPg();
1397 else
1398 rSh.EndPg();
1399 rSh.ToggleHeaderFooterEdit();
1400 }
1401
1402 SfxObjectShell *pObjSh = m_rView.GetViewFrame().GetObjectShell();
1403 if ( m_bLockInput || (pObjSh && pObjSh->GetProgress()) )
1404 // When the progress bar is active or a progress is
1405 // running on a document, no order is being taken
1406 return;
1407
1408 m_pShadCursor.reset();
1409 // Do not reset the timer here, otherwise when flooded with events it would never time out
1410 // if every key event stopped and started it again.
1411 comphelper::ScopeGuard keyInputFlushTimerStop([this]() { m_aKeyInputFlushTimer.Stop(); });
1412
1413 bool bIsDocReadOnly = m_rView.GetDocShell()->IsReadOnly() &&
1414 rSh.IsCursorReadonly();
1415
1416 //if the language changes the buffer must be flushed
1417 LanguageType eNewLanguage = GetInputLanguage();
1418 if(!bIsDocReadOnly && m_eBufferLanguage != eNewLanguage && !m_aInBuffer.isEmpty())
1419 {
1420 FlushInBuffer();
1421 }
1422 m_eBufferLanguage = eNewLanguage;
1423
1424 QuickHelpData aTmpQHD;
1425 if( s_pQuickHlpData->m_bIsDisplayed )
1426 {
1427 aTmpQHD.Move( *s_pQuickHlpData );
1428 s_pQuickHlpData->Stop( rSh );
1429 }
1430
1431 // OS:the DrawView also needs a readonly-Flag as well
1432 if ( !bIsDocReadOnly && rSh.GetDrawView() && rSh.GetDrawView()->KeyInput( rKEvt, this ) )
1433 {
1434 rSh.GetView().GetViewFrame().GetBindings().InvalidateAll( false );
1435 rSh.SetModified();
1436 return; // Event evaluated by SdrView
1437 }
1438
1439 if ( m_rView.GetDrawFuncPtr() && m_bInsFrame )
1440 {
1441 StopInsFrame();
1442 rSh.Edit();
1443 }
1444
1445 bool bFlushBuffer = false;
1446 bool bNormalChar = false;
1447 bool bAppendSpace = s_pQuickHlpData->m_bAppendSpace;
1448 s_pQuickHlpData->m_bAppendSpace = false;
1449
1450 if ( getenv("SW_DEBUG") && rKEvt.GetKeyCode().GetCode() == KEY_F12 )
1451 {
1452 if( rKEvt.GetKeyCode().IsShift())
1453 {
1454 GetView().GetDocShell()->GetDoc()->dumpAsXml();
1455 return;
1456 }
1457 else
1458 {
1459 SwRootFrame* pLayout = GetView().GetDocShell()->GetWrtShell()->GetLayout();
1460 pLayout->dumpAsXml( );
1461 return;
1462 }
1463 }
1464
1465 KeyEvent aKeyEvent( rKEvt );
1466 // look for vertical mappings
1467 if( !bIsDocReadOnly && !rSh.IsSelFrameMode() && !rSh.IsObjSelected() )
1468 {
1469 sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();
1470
1471 if( KEY_UP == nKey || KEY_DOWN == nKey ||
1472 KEY_LEFT == nKey || KEY_RIGHT == nKey )
1473 {
1474 // In general, we want to map the direction keys if we are inside
1475 // some vertical formatted text.
1476 // 1. Exception: For a table cursor in a horizontal table, the
1477 // directions should never be mapped.
1478 // 2. Exception: For a table cursor in a vertical table, the
1479 // directions should always be mapped.
1480 const bool bVertText = rSh.IsInVerticalText();
1481 const bool bTableCursor = rSh.GetTableCursor();
1482 const bool bVertTable = rSh.IsTableVertical();
1483 if( ( bVertText && ( !bTableCursor || bVertTable ) ) ||
1484 ( bTableCursor && bVertTable ) )
1485 {
1486 SvxFrameDirection eDirection = rSh.GetTextDirection();
1487 if (eDirection == SvxFrameDirection::Vertical_LR_BT)
1488 {
1489 // Map from physical to logical, so rotate clockwise.
1490 if (KEY_UP == nKey)
1491 nKey = KEY_RIGHT;
1492 else if (KEY_DOWN == nKey)
1493 nKey = KEY_LEFT;
1494 else if (KEY_LEFT == nKey)
1495 nKey = KEY_UP;
1496 else /* KEY_RIGHT == nKey */
1497 nKey = KEY_DOWN;
1498 }
1499 else
1500 {
1501 // Attempt to integrate cursor travelling for mongolian layout does not work.
1502 // Thus, back to previous mapping of cursor keys to direction keys.
1503 if( KEY_UP == nKey ) nKey = KEY_LEFT;
1504 else if( KEY_DOWN == nKey ) nKey = KEY_RIGHT;
1505 else if( KEY_LEFT == nKey ) nKey = KEY_DOWN;
1506 else /* KEY_RIGHT == nKey */ nKey = KEY_UP;
1507 }
1508 }
1509
1510 if ( rSh.IsInRightToLeftText() )
1511 {
1512 if( KEY_LEFT == nKey ) nKey = KEY_RIGHT;
1513 else if( KEY_RIGHT == nKey ) nKey = KEY_LEFT;
1514 }
1515
1516 aKeyEvent = KeyEvent( rKEvt.GetCharCode(),
1517 vcl::KeyCode( nKey, rKEvt.GetKeyCode().GetModifier() ),
1518 rKEvt.GetRepeat() );
1519 }
1520 }
1521
1522 const vcl::KeyCode& rKeyCode = aKeyEvent.GetKeyCode();
1523 sal_Unicode aCh = aKeyEvent.GetCharCode();
1524
1525 // enable switching to notes anchor with Ctrl - Alt - Page Up/Down
1526 // pressing this inside a note will switch to next/previous note
1527 if ((rKeyCode.IsMod1() && rKeyCode.IsMod2()) && ((rKeyCode.GetCode() == KEY_PAGEUP) || (rKeyCode.GetCode() == KEY_PAGEDOWN)))
1528 {
1529 const bool bNext = rKeyCode.GetCode()==KEY_PAGEDOWN;
1530 const SwFieldType* pFieldType = rSh.GetFieldType( 0, SwFieldIds::Postit );
1531 rSh.MoveFieldType( pFieldType, bNext );
1532 return;
1533 }
1534
1535 if (SwTextContentControl* pTextContentControl = rSh.CursorInsideContentControl())
1536 {
1537 // Check if this combination of rKeyCode and pTextContentControl should open a popup.
1538 const SwFormatContentControl& rFormatContentControl = pTextContentControl->GetContentControl();
1539 std::shared_ptr<SwContentControl> pContentControl = rFormatContentControl.GetContentControl();
1540 if (pContentControl->ShouldOpenPopup(rKeyCode))
1541 {
1542 SwShellCursor* pCursor = rSh.GetCursor_();
1543 if (pCursor)
1544 {
1545 VclPtr<SwContentControlButton> pContentControlButton = pCursor->GetContentControlButton();
1546 if (pContentControlButton)
1547 {
1548 pContentControlButton->StartPopup();
1549 return;
1550 }
1551 }
1552 }
1553 }
1554
1555 const SwFrameFormat* pFlyFormat = rSh.GetFlyFrameFormat();
1556
1557 if (pFlyFormat)
1558 {
1559 // See if the fly frame's anchor is in a content control. If so,
1560 // try to interact with it.
1561 const SwFormatAnchor& rFormatAnchor = pFlyFormat->GetAnchor();
1562 SwNode* pAnchorNode = rFormatAnchor.GetAnchorNode();
1563 if (pAnchorNode)
1564 {
1565 SwTextNode* pTextNode = pAnchorNode->GetTextNode();
1566 if (pTextNode)
1567 {
1568 sal_Int32 nContentIdx = rFormatAnchor.GetAnchorContentOffset();
1569 SwTextAttr* pAttr = pTextNode->GetTextAttrAt(
1570 nContentIdx, RES_TXTATR_CONTENTCONTROL, ::sw::GetTextAttrMode::Parent);
1571 if (pAttr)
1572 {
1573 SwTextContentControl* pTextContentControl
1574 = static_txtattr_cast<SwTextContentControl*>(pAttr);
1575 const SwFormatContentControl& rFormatContentControl
1576 = pTextContentControl->GetContentControl();
1577 std::shared_ptr<SwContentControl> pContentControl
1578 = rFormatContentControl.GetContentControl();
1579 if (pContentControl->IsInteractingCharacter(aCh))
1580 {
1581 rSh.GotoContentControl(rFormatContentControl);
1582 return;
1583 }
1584 }
1585 }
1586 }
1587 }
1588
1589 if( pFlyFormat )
1590 {
1591 SvMacroItemId nEvent;
1592
1593 if( 32 <= aCh &&
1594 0 == (( KEY_MOD1 | KEY_MOD2 ) & rKeyCode.GetModifier() ))
1595 nEvent = SvMacroItemId::SwFrmKeyInputAlpha;
1596 else
1597 nEvent = SvMacroItemId::SwFrmKeyInputNoAlpha;
1598
1599 const SvxMacro* pMacro = pFlyFormat->GetMacro().GetMacroTable().Get( nEvent );
1600 if( pMacro )
1601 {
1602 SbxArrayRef xArgs = new SbxArray;
1603 SbxVariableRef xVar = new SbxVariable;
1604 xVar->PutString( pFlyFormat->GetName() );
1605 xArgs->Put(xVar.get(), 1);
1606
1607 xVar = new SbxVariable;
1608 if( SvMacroItemId::SwFrmKeyInputAlpha == nEvent )
1609 xVar->PutChar( aCh );
1610 else
1611 xVar->PutUShort( rKeyCode.GetModifier() | rKeyCode.GetCode() );
1612 xArgs->Put(xVar.get(), 2);
1613
1614 OUString sRet;
1615 rSh.ExecMacro( *pMacro, &sRet, xArgs.get() );
1616 if( !sRet.isEmpty() && sRet.toInt32()!=0 )
1617 return ;
1618 }
1619 }
1620 SelectionType nLclSelectionType;
1621 //A is converted to 1
1622 if( rKeyCode.GetFullCode() == (KEY_A | KEY_MOD1 |KEY_SHIFT)
1623 && rSh.HasDrawView() &&
1624 (bool(nLclSelectionType = rSh.GetSelectionType()) &&
1625 ((nLclSelectionType & (SelectionType::Frame|SelectionType::Graphic)) ||
1626 ((nLclSelectionType & (SelectionType::DrawObject|SelectionType::DbForm)) &&
1627 rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1))))
1628 {
1629 SdrHdlList& rHdlList = const_cast<SdrHdlList&>(rSh.GetDrawView()->GetHdlList());
1630 SdrHdl* pAnchor = rHdlList.GetHdl(SdrHdlKind::Anchor);
1631 if ( ! pAnchor )
1632 pAnchor = rHdlList.GetHdl(SdrHdlKind::Anchor_TR);
1633 if(pAnchor)
1634 rHdlList.SetFocusHdl(pAnchor);
1635 return;
1636 }
1637
1638 SvxAutoCorrCfg* pACfg = nullptr;
1639 SvxAutoCorrect* pACorr = nullptr;
1640
1641 uno::Reference< frame::XDispatchRecorder > xRecorder =
1642 m_rView.GetViewFrame().GetBindings().GetRecorder();
1643 if ( !xRecorder.is() )
1644 {
1645 pACfg = &SvxAutoCorrCfg::Get();
1646 pACorr = pACfg->GetAutoCorrect();
1647 }
1648
1649 SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
1650
1651 OUString sFormulaEntry;
1652
1653 enum class SwKeyState { CheckKey, InsChar, InsTab,
1654 NoNum, NumOff, NumOrNoNum, NumDown, NumUp,
1655 NumIndentInc, NumIndentDec,
1656
1657 OutlineLvOff,
1658 NextCell, PrevCell, OutlineUp, OutlineDown,
1659 GlossaryExpand, NextPrevGlossary,
1660 AutoFormatByInput,
1661 NextObject, PrevObject,
1662 KeyToView,
1663 LaunchOLEObject, GoIntoFly, GoIntoDrawing,
1664 EnterDrawHandleMode,
1665 CheckDocReadOnlyKeys,
1666 CheckAutoCorrect, EditFormula,
1667 ColLeftBig, ColRightBig,
1668 ColLeftSmall, ColRightSmall,
1669 ColBottomBig,
1670 ColBottomSmall,
1671 CellLeftBig, CellRightBig,
1672 CellLeftSmall, CellRightSmall,
1673 CellTopBig, CellBottomBig,
1674 CellTopSmall, CellBottomSmall,
1675
1676 Fly_Change, Draw_Change,
1677 SpecialInsert,
1678 EnterCharCell,
1679 GotoNextFieldMark,
1680 GotoPrevFieldMark,
1681 End };
1682
1683 SwKeyState eKeyState = bIsDocReadOnly ? SwKeyState::CheckDocReadOnlyKeys : SwKeyState::CheckKey;
1684 SwKeyState eNextKeyState = SwKeyState::End;
1685 sal_uInt8 nDir = 0;
1686
1687 if (m_nKS_NUMDOWN_Count > 0)
1688 m_nKS_NUMDOWN_Count--;
1689
1690 if (m_nKS_NUMINDENTINC_Count > 0)
1691 m_nKS_NUMINDENTINC_Count--;
1692
1693 while( SwKeyState::End != eKeyState )
1694 {
1695 SwKeyState eFlyState = SwKeyState::KeyToView;
1696
1697 switch( eKeyState )
1698 {
1699 case SwKeyState::CheckKey:
1700 eKeyState = SwKeyState::KeyToView; // default forward to View
1701
1702 if (!comphelper::LibreOfficeKit::isActive() &&
1703 !rKeyCode.IsMod2() && '=' == aCh &&
1704 !rSh.IsTableMode() && rSh.GetTableFormat() &&
1705 rSh.IsSttPara() &&
1706 !rSh.HasReadonlySel())
1707 {
1708 // at the beginning of the table's cell a '=' ->
1709 // call EditRow (F2-functionality)
1710 // [Avoid this for LibreOfficeKit, as the separate input window
1711 // steals the focus & things go wrong - the user never gets
1712 // the focus back.]
1713 rSh.Push();
1714 if( !rSh.MoveSection( GoCurrSection, fnSectionStart) &&
1715 !rSh.IsTableBoxTextFormat() )
1716 {
1717 // is at the beginning of the box
1718 eKeyState = SwKeyState::EditFormula;
1719 if( rSh.HasMark() )
1720 rSh.SwapPam();
1721 else
1722 rSh.SttSelect();
1723 rSh.MoveSection( GoCurrSection, fnSectionEnd );
1724 rSh.Pop();
1725 rSh.EndSelect();
1726 sFormulaEntry = "=";
1727 }
1728 else
1729 rSh.Pop(SwCursorShell::PopMode::DeleteCurrent);
1730 }
1731 else
1732 {
1733 if( pACorr && aTmpQHD.HasContent() && !rSh.HasSelection() &&
1734 !rSh.HasReadonlySel() && !aTmpQHD.m_bIsAutoText &&
1735 pACorr->GetSwFlags().nAutoCmpltExpandKey ==
1736 (rKeyCode.GetModifier() | rKeyCode.GetCode()) )
1737 {
1738 eKeyState = SwKeyState::GlossaryExpand;
1739 break;
1740 }
1741
1742 switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
1743 {
1744 case KEY_RIGHT | KEY_MOD2:
1745 eKeyState = SwKeyState::ColRightBig;
1746 eFlyState = SwKeyState::Fly_Change;
1747 nDir = MOVE_RIGHT_SMALL;
1748 goto KEYINPUT_CHECKTABLE;
1749
1750 case KEY_LEFT | KEY_MOD2:
1751 eKeyState = SwKeyState::ColRightSmall;
1752 eFlyState = SwKeyState::Fly_Change;
1753 nDir = MOVE_LEFT_SMALL;
1754 goto KEYINPUT_CHECKTABLE;
1755
1756 case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT:
1757 eKeyState = SwKeyState::ColLeftSmall;
1758 goto KEYINPUT_CHECKTABLE;
1759
1760 case KEY_LEFT | KEY_MOD2 | KEY_SHIFT:
1761 eKeyState = SwKeyState::ColLeftBig;
1762 goto KEYINPUT_CHECKTABLE;
1763
1764 case KEY_RIGHT | KEY_MOD2 | KEY_MOD1:
1765 eKeyState = SwKeyState::CellRightBig;
1766 goto KEYINPUT_CHECKTABLE;
1767
1768 case KEY_LEFT | KEY_MOD2 | KEY_MOD1:
1769 eKeyState = SwKeyState::CellRightSmall;
1770 goto KEYINPUT_CHECKTABLE;
1771
1772 case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1773 eKeyState = SwKeyState::CellLeftSmall;
1774 goto KEYINPUT_CHECKTABLE;
1775
1776 case KEY_LEFT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1777 eKeyState = SwKeyState::CellLeftBig;
1778 goto KEYINPUT_CHECKTABLE;
1779
1780 case KEY_UP | KEY_MOD2:
1781 eKeyState = SwKeyState::ColBottomSmall;
1782 eFlyState = SwKeyState::Fly_Change;
1783 nDir = MOVE_UP_SMALL;
1784 goto KEYINPUT_CHECKTABLE;
1785
1786 case KEY_DOWN | KEY_MOD2:
1787 eKeyState = SwKeyState::ColBottomBig;
1788 eFlyState = SwKeyState::Fly_Change;
1789 nDir = MOVE_DOWN_SMALL;
1790 goto KEYINPUT_CHECKTABLE;
1791
1792 case KEY_UP | KEY_MOD2 | KEY_MOD1:
1793 eKeyState = SwKeyState::CellBottomSmall;
1794 goto KEYINPUT_CHECKTABLE;
1795
1796 case KEY_DOWN | KEY_MOD2 | KEY_MOD1:
1797 eKeyState = SwKeyState::CellBottomBig;
1798 goto KEYINPUT_CHECKTABLE;
1799
1800 case KEY_UP | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1801 eKeyState = SwKeyState::CellTopBig;
1802 goto KEYINPUT_CHECKTABLE;
1803
1804 case KEY_DOWN | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1805 eKeyState = SwKeyState::CellTopSmall;
1806 goto KEYINPUT_CHECKTABLE;
1807
1808KEYINPUT_CHECKTABLE:
1809 // Resolve bugs 49091, 53190, 93402 and
1810 // https://bz.apache.org/ooo/show_bug.cgi?id=113502
1811 // but provide an option for restoring interactive
1812 // table sizing functionality when needed.
1813 if (
1814 ! (Window::GetIndicatorState() & KeyIndicatorState::CAPSLOCK)
1815 && m_rView.KeyInput( aKeyEvent ) // Keystroke is customized
1816 )
1817 {
1818 bFlushBuffer = true;
1819 bNormalChar = false;
1820 eKeyState = SwKeyState::End;
1821 break ;
1822 }
1823
1824 if( rSh.IsTableMode() || !rSh.GetTableFormat() )
1825 {
1826 if(!pFlyFormat && SwKeyState::KeyToView != eFlyState &&
1827 (rSh.GetSelectionType() & (SelectionType::DrawObject|SelectionType::DbForm)) &&
1828 rSh.GetDrawView()->AreObjectsMarked())
1829 eKeyState = SwKeyState::Draw_Change;
1830
1831 if( pFlyFormat )
1832 eKeyState = eFlyState;
1833 else if( SwKeyState::Draw_Change != eKeyState)
1834 eKeyState = SwKeyState::EnterCharCell;
1835 }
1836 break;
1837
1838 // huge object move
1839 case KEY_RIGHT | KEY_SHIFT:
1840 case KEY_LEFT | KEY_SHIFT:
1841 case KEY_UP | KEY_SHIFT:
1842 case KEY_DOWN | KEY_SHIFT:
1843 {
1844 const SelectionType nSelectionType = rSh.GetSelectionType();
1845 if ( ( pFlyFormat
1846 && ( nSelectionType & (SelectionType::Frame|SelectionType::Ole|SelectionType::Graphic) ) )
1847 || ( ( nSelectionType & (SelectionType::DrawObject|SelectionType::DbForm) )
1848 && rSh.GetDrawView()->AreObjectsMarked() ) )
1849 {
1850 eKeyState = pFlyFormat ? SwKeyState::Fly_Change : SwKeyState::Draw_Change;
1851 if (nSelectionType & SelectionType::DrawObject)
1852 {
1853 // tdf#137964: always move the DrawObject if one is selected
1854 eKeyState = SwKeyState::Draw_Change;
1855 }
1856 switch ( rKeyCode.GetCode() )
1857 {
1858 case KEY_RIGHT: nDir = MOVE_RIGHT_HUGE; break;
1859 case KEY_LEFT: nDir = MOVE_LEFT_HUGE; break;
1860 case KEY_UP: nDir = MOVE_UP_HUGE; break;
1861 case KEY_DOWN: nDir = MOVE_DOWN_HUGE; break;
1862 }
1863 }
1864 break;
1865 }
1866
1867 case KEY_LEFT:
1868 case KEY_LEFT | KEY_MOD1:
1869 {
1870 bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1871 if(!bMod1)
1872 {
1873 eFlyState = SwKeyState::Fly_Change;
1874 nDir = MOVE_LEFT_BIG;
1875 }
1876 goto KEYINPUT_CHECKTABLE_INSDEL;
1877 }
1878 case KEY_RIGHT | KEY_MOD1:
1879 {
1880 goto KEYINPUT_CHECKTABLE_INSDEL;
1881 }
1882 case KEY_UP:
1883 case KEY_UP | KEY_MOD1:
1884 {
1885 bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1886 if(!bMod1)
1887 {
1888 eFlyState = SwKeyState::Fly_Change;
1889 nDir = MOVE_UP_BIG;
1890 }
1891 goto KEYINPUT_CHECKTABLE_INSDEL;
1892 }
1893 case KEY_DOWN:
1894 case KEY_DOWN | KEY_MOD1:
1895 {
1896 bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1897 if(!bMod1)
1898 {
1899 ::sw::mark::IFieldmark* pMark = rSh.GetCurrentFieldmark();
1900 if (auto pDropDown = dynamic_cast<FieldmarkWithDropDownButton*>(pMark))
1901 {
1902 pDropDown->LaunchPopup();
1903 eKeyState = SwKeyState::End;
1904 break;
1905 }
1906 eFlyState = SwKeyState::Fly_Change;
1907 nDir = MOVE_DOWN_BIG;
1908 }
1909 goto KEYINPUT_CHECKTABLE_INSDEL;
1910 }
1911
1912KEYINPUT_CHECKTABLE_INSDEL:
1913 if( rSh.IsTableMode() || !rSh.GetTableFormat() )
1914 {
1915 const SelectionType nSelectionType = rSh.GetSelectionType();
1916
1917 eKeyState = SwKeyState::KeyToView;
1918 if(SwKeyState::KeyToView != eFlyState)
1919 {
1920 if((nSelectionType & (SelectionType::DrawObject|SelectionType::DbForm)) &&
1921 rSh.GetDrawView()->AreObjectsMarked())
1922 eKeyState = SwKeyState::Draw_Change;
1923 else if(nSelectionType & (SelectionType::Frame|SelectionType::Ole|SelectionType::Graphic))
1924 eKeyState = SwKeyState::Fly_Change;
1925 }
1926 }
1927 break;
1928
1929
1930 case KEY_DELETE:
1931 if ( !rSh.HasReadonlySel() || rSh.CursorInsideInputField())
1932 {
1933 if (rSh.IsInFrontOfLabel() && rSh.NumOrNoNum())
1934 eKeyState = SwKeyState::NumOrNoNum;
1935 }
1936 else if (!rSh.IsCursorInParagraphMetadataField())
1937 {
1938 rSh.InfoReadOnlyDialog(false);
1939 eKeyState = SwKeyState::End;
1940 }
1941 break;
1942
1943 case KEY_RETURN:
1944 {
1945 if ( !rSh.HasReadonlySel()
1946 && !rSh.CursorInsideInputField()
1947 && !rSh.CursorInsideContentControl() )
1948 {
1949 const SelectionType nSelectionType = rSh.GetSelectionType();
1950 if(nSelectionType & SelectionType::Ole)
1951 eKeyState = SwKeyState::LaunchOLEObject;
1952 else if(nSelectionType & SelectionType::Frame)
1953 eKeyState = SwKeyState::GoIntoFly;
1954 else if((nSelectionType & SelectionType::DrawObject) &&
1955 !(nSelectionType & SelectionType::DrawObjectEditMode) &&
1956 rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)
1957 {
1958 eKeyState = SwKeyState::GoIntoDrawing;
1959 if (lcl_goIntoTextBox(*this, rSh))
1960 eKeyState = SwKeyState::GoIntoFly;
1961 }
1962 else if( aTmpQHD.HasContent() && !rSh.HasSelection() &&
1963 aTmpQHD.m_bIsAutoText )
1964 eKeyState = SwKeyState::GlossaryExpand;
1965
1966 //RETURN and empty paragraph in numbering -> end numbering
1967 else if( m_aInBuffer.isEmpty() &&
1968 rSh.GetNumRuleAtCurrCursorPos() &&
1969 !rSh.GetNumRuleAtCurrCursorPos()->IsOutlineRule() &&
1970 !rSh.HasSelection() &&
1971 rSh.IsSttPara() && rSh.IsEndPara() )
1972 {
1973 eKeyState = SwKeyState::NumOff;
1974 eNextKeyState = SwKeyState::OutlineLvOff;
1975 }
1976 //RETURN for new paragraph with AutoFormatting
1977 else if( pACfg && pACfg->IsAutoFormatByInput() &&
1978 !(nSelectionType & (SelectionType::Graphic |
1979 SelectionType::Ole | SelectionType::Frame |
1980 SelectionType::TableCell | SelectionType::DrawObject |
1981 SelectionType::DrawObjectEditMode)) )
1982 {
1983 eKeyState = SwKeyState::AutoFormatByInput;
1984 }
1985 else
1986 {
1987 eNextKeyState = eKeyState;
1988 eKeyState = SwKeyState::CheckAutoCorrect;
1989 }
1990 }
1991 }
1992 break;
1993 case KEY_RETURN | KEY_MOD2:
1994 {
1995 if ( !rSh.HasReadonlySel()
1996 && !rSh.IsSttPara()
1997 && rSh.GetNumRuleAtCurrCursorPos()
1998 && !rSh.CursorInsideInputField() )
1999 {
2000 eKeyState = SwKeyState::NoNum;
2001 }
2002 else if( rSh.CanSpecialInsert() )
2003 eKeyState = SwKeyState::SpecialInsert;
2004 }
2005 break;
2006 case KEY_BACKSPACE:
2007 case KEY_BACKSPACE | KEY_SHIFT:
2008 if ( !rSh.HasReadonlySel() || rSh.CursorInsideInputField())
2009 {
2010 bool bDone = false;
2011 // try to add comment for code snip:
2012 // Remove the paragraph indent, if the cursor is at the
2013 // beginning of a paragraph, there is no selection
2014 // and no numbering rule found at the current paragraph
2015 // Also try to remove indent, if current paragraph
2016 // has numbering rule, but isn't counted and only
2017 // key <backspace> is hit.
2018 const bool bOnlyBackspaceKey( KEY_BACKSPACE == rKeyCode.GetFullCode() );
2019 if ( rSh.IsSttPara()
2020 && !rSh.HasSelection()
2021 && ( rSh.GetNumRuleAtCurrCursorPos() == nullptr
2022 || ( rSh.IsNoNum() && bOnlyBackspaceKey ) ) )
2023 {
2024 bDone = rSh.TryRemoveIndent();
2025 }
2026
2027 if (bDone)
2028 eKeyState = SwKeyState::End;
2029 else
2030 {
2031 if ( rSh.IsSttPara() && !rSh.IsNoNum() )
2032 {
2033 if (m_nKS_NUMDOWN_Count > 0 &&
2034 0 < rSh.GetNumLevel())
2035 {
2036 eKeyState = SwKeyState::NumUp;
2037 m_nKS_NUMDOWN_Count = 2;
2038 bDone = true;
2039 }
2040 else if (m_nKS_NUMINDENTINC_Count > 0)
2041 {
2042 eKeyState = SwKeyState::NumIndentDec;
2043 m_nKS_NUMINDENTINC_Count = 2;
2044 bDone = true;
2045 }
2046 }
2047
2048 // If the cursor is in an empty paragraph, which has
2049 // a numbering, but not the outline numbering, and
2050 // there is no selection, the numbering has to be
2051 // deleted on key <Backspace>.
2052 // Otherwise method <SwEditShell::NumOrNoNum(..)>
2053 // should only change the <IsCounted()> state of
2054 // the current paragraph depending of the key.
2055 // On <backspace> it is set to <false>,
2056 // on <shift-backspace> it is set to <true>.
2057 // Thus, assure that method <SwEditShell::NumOrNum(..)>
2058 // is only called for the intended purpose.
2059 if ( !bDone && rSh.IsSttPara() )
2060 {
2061 bool bCallNumOrNoNum( false );
2062 if ( bOnlyBackspaceKey && !rSh.IsNoNum() )
2063 {
2064 bCallNumOrNoNum = true;
2065 }
2066 else if ( !bOnlyBackspaceKey && rSh.IsNoNum() )
2067 {
2068 bCallNumOrNoNum = true;
2069 }
2070 else if ( bOnlyBackspaceKey
2071 && rSh.IsSttPara()
2072 && rSh.IsEndPara()
2073 && !rSh.HasSelection() )
2074 {
2075 const SwNumRule* pCurrNumRule( rSh.GetNumRuleAtCurrCursorPos() );
2076 if ( pCurrNumRule != nullptr
2077 && pCurrNumRule != rSh.GetOutlineNumRule() )
2078 {
2079 bCallNumOrNoNum = true;
2080 }
2081 }
2082 if ( bCallNumOrNoNum
2083 && rSh.NumOrNoNum( !bOnlyBackspaceKey ) )
2084 {
2085 eKeyState = SwKeyState::NumOrNoNum;
2086 }
2087 }
2088 }
2089 }
2090 else if (!rSh.IsCursorInParagraphMetadataField())
2091 {
2092 rSh.InfoReadOnlyDialog(false);
2093 eKeyState = SwKeyState::End;
2094 }
2095 break;
2096
2097 case KEY_RIGHT:
2098 {
2099 eFlyState = SwKeyState::Fly_Change;
2100 nDir = MOVE_RIGHT_BIG;
2101 goto KEYINPUT_CHECKTABLE_INSDEL;
2102 }
2103 case KEY_TAB:
2104 {
2105 // Rich text contentControls accept tabs and fieldmarks and other rich text,
2106 // so first act on cases that are not a content control
2107 SwTextContentControl* pTextContentControl = rSh.CursorInsideContentControl();
2108 if ((rSh.IsFormProtected() && !pTextContentControl) ||
2109 rSh.GetCurrentFieldmark() || rSh.GetChar(false)==CH_TXT_ATR_FORMELEMENT)
2110 {
2111 eKeyState = SwKeyState::GotoNextFieldMark;
2112 }
2113 else if ( !rSh.IsMultiSelection() && rSh.CursorInsideInputField() )
2114 {
2115 GetView().GetViewFrame().GetDispatcher()->Execute( FN_GOTO_NEXT_INPUTFLD );
2116 eKeyState = SwKeyState::End;
2117 }
2118 else if( rSh.GetNumRuleAtCurrCursorPos()
2119 && rSh.IsSttOfPara()
2120 && !rSh.HasReadonlySel() )
2121 {
2122 if (numfunc::NumDownChangesIndent(rSh))
2123 {
2124 eKeyState = SwKeyState::NumDown;
2125 }
2126 else
2127 {
2128 eKeyState = SwKeyState::InsTab;
2129 }
2130 }
2131 else if (rSh.GetSelectionType() &
2132 (SelectionType::Graphic |
2133 SelectionType::Frame |
2134 SelectionType::Ole |
2135 SelectionType::DrawObject |
2136 SelectionType::DbForm))
2137 {
2138 eKeyState = SwKeyState::NextObject;
2139 }
2140 else if ( rSh.GetTableFormat() )
2141 {
2142 if( rSh.HasSelection() || rSh.HasReadonlySel() )
2143 eKeyState = SwKeyState::NextCell;
2144 else
2145 {
2146 eKeyState = SwKeyState::CheckAutoCorrect;
2147 eNextKeyState = SwKeyState::NextCell;
2148 }
2149 }
2150 else if (pTextContentControl)
2151 {
2152 auto pCC = pTextContentControl->GetContentControl().GetContentControl();
2153 if (pCC)
2154 {
2155 switch (pCC->GetType())
2156 {
2157 case SwContentControlType::RICH_TEXT:
2158 eKeyState = SwKeyState::InsTab;
2159 break;
2160 default:
2161 eKeyState = SwKeyState::GotoNextFieldMark;
2162 }
2163 }
2164 }
2165 else
2166 {
2167 eKeyState = SwKeyState::InsTab;
2168 if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
2169 {
2170 SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
2171 if( pColl &&
2172
2173 pColl->IsAssignedToListLevelOfOutlineStyle()
2174 && MAXLEVEL-1 > pColl->GetAssignedOutlineStyleLevel() )
2175 eKeyState = SwKeyState::OutlineDown;
2176 }
2177 }
2178 }
2179 break;
2180 case KEY_TAB | KEY_SHIFT:
2181 {
2182 SwTextContentControl* pTextContentControl = rSh.CursorInsideContentControl();
2183 if ((rSh.IsFormProtected() && !pTextContentControl) ||
2184 rSh.GetCurrentFieldmark()|| rSh.GetChar(false)==CH_TXT_ATR_FORMELEMENT)
2185 {
2186 eKeyState = SwKeyState::GotoPrevFieldMark;
2187 }
2188 else if ( !rSh.IsMultiSelection() && rSh.CursorInsideInputField() )
2189 {
2190 GetView().GetViewFrame().GetDispatcher()->Execute( FN_GOTO_PREV_INPUTFLD );
2191 eKeyState = SwKeyState::End;
2192 }
2193 else if( rSh.GetNumRuleAtCurrCursorPos()
2194 && rSh.IsSttOfPara()
2195 && !rSh.HasReadonlySel() )
2196 {
2197 eKeyState = SwKeyState::NumUp;
2198 }
2199 else if (rSh.GetSelectionType() &
2200 (SelectionType::Graphic |
2201 SelectionType::Frame |
2202 SelectionType::Ole |
2203 SelectionType::DrawObject |
2204 SelectionType::DbForm))
2205 {
2206 eKeyState = SwKeyState::PrevObject;
2207 }
2208 else if ( rSh.GetTableFormat() )
2209 {
2210 if( rSh.HasSelection() || rSh.HasReadonlySel() )
2211 eKeyState = SwKeyState::PrevCell;
2212 else
2213 {
2214 eKeyState = SwKeyState::CheckAutoCorrect;
2215 eNextKeyState = SwKeyState::PrevCell;
2216 }
2217 }
2218 else if (pTextContentControl)
2219 {
2220 eKeyState = SwKeyState::GotoPrevFieldMark;
2221 }
2222 else
2223 {
2224 eKeyState = SwKeyState::End;
2225 if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
2226 {
2227 SwTextFormatColl* pColl = rSh.GetCurTextFormatColl();
2228 if( pColl &&
2229 pColl->IsAssignedToListLevelOfOutlineStyle() &&
2230 0 < pColl->GetAssignedOutlineStyleLevel())
2231 eKeyState = SwKeyState::OutlineUp;
2232 }
2233 }
2234 }
2235 break;
2236 case KEY_TAB | KEY_MOD1:
2237 case KEY_TAB | KEY_MOD2:
2238 if( !rSh.HasReadonlySel() )
2239 {
2240 if( aTmpQHD.HasContent() && !rSh.HasSelection() )
2241 {
2242 // Next auto-complete suggestion
2243 aTmpQHD.Next( pACorr &&
2244 pACorr->GetSwFlags().bAutoCmpltEndless );
2245 eKeyState = SwKeyState::NextPrevGlossary;
2246 }
2247 else if( rSh.GetTableFormat() )
2248 eKeyState = SwKeyState::InsTab;
2249 else if((rSh.GetSelectionType() &
2250 (SelectionType::DrawObject|SelectionType::DbForm|
2251 SelectionType::Frame|SelectionType::Ole|SelectionType::Graphic)) &&
2252 rSh.GetDrawView()->AreObjectsMarked())
2253 eKeyState = SwKeyState::EnterDrawHandleMode;
2254 else
2255 {
2256 if ( !rSh.IsMultiSelection()
2257 && numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
2258 eKeyState = SwKeyState::NumIndentInc;
2259 }
2260 }
2261 break;
2262
2263 case KEY_TAB | KEY_MOD1 | KEY_SHIFT:
2264 {
2265 if( aTmpQHD.HasContent() && !rSh.HasSelection() &&
2266 !rSh.HasReadonlySel() )
2267 {
2268 // Previous auto-complete suggestion.
2269 aTmpQHD.Previous( pACorr &&
2270 pACorr->GetSwFlags().bAutoCmpltEndless );
2271 eKeyState = SwKeyState::NextPrevGlossary;
2272 }
2273 else if((rSh.GetSelectionType() & (SelectionType::DrawObject|SelectionType::DbForm|
2274 SelectionType::Frame|SelectionType::Ole|SelectionType::Graphic)) &&
2275 rSh.GetDrawView()->AreObjectsMarked())
2276 {
2277 eKeyState = SwKeyState::EnterDrawHandleMode;
2278 }
2279 else
2280 {
2281 if ( !rSh.IsMultiSelection()
2282 && numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
2283 eKeyState = SwKeyState::NumIndentDec;
2284 }
2285 }
2286 break;
2287 case KEY_F2 :
2288 if( !rSh.HasReadonlySel() )
2289 {
2290 const SelectionType nSelectionType = rSh.GetSelectionType();
2291 if(nSelectionType & SelectionType::Frame)
2292 eKeyState = SwKeyState::GoIntoFly;
2293 else if(nSelectionType & SelectionType::DrawObject)
2294 {
2295 eKeyState = SwKeyState::GoIntoDrawing;
2296 if (lcl_goIntoTextBox(*this, rSh))
2297 eKeyState = SwKeyState::GoIntoFly;
2298 }
2299 }
2300 break;
2301 }
2302 }
2303 break;
2304 case SwKeyState::CheckDocReadOnlyKeys:
2305 {
2306 eKeyState = SwKeyState::KeyToView;
2307 switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
2308 {
2309 case KEY_TAB:
2310 case KEY_TAB | KEY_SHIFT:
2311 bNormalChar = false;
2312 eKeyState = SwKeyState::End;
2313 if ( rSh.GetSelectionType() &
2314 (SelectionType::Graphic |
2315 SelectionType::Frame |
2316 SelectionType::Ole |
2317 SelectionType::DrawObject |
2318 SelectionType::DbForm))
2319
2320 {
2321 eKeyState = (rKeyCode.GetModifier() & KEY_SHIFT) ?
2322 SwKeyState::PrevObject : SwKeyState::NextObject;
2323 }
2324 else if ( !rSh.IsMultiSelection() && rSh.CursorInsideInputField() )
2325 {
2326 GetView().GetViewFrame().GetDispatcher()->Execute(
2327 KEY_SHIFT != rKeyCode.GetModifier() ? FN_GOTO_NEXT_INPUTFLD : FN_GOTO_PREV_INPUTFLD );
2328 }
2329 else
2330 {
2331 rSh.SelectNextPrevHyperlink( KEY_SHIFT != rKeyCode.GetModifier() );
2332 }
2333 break;
2334 case KEY_RETURN:
2335 {
2336 const SelectionType nSelectionType = rSh.GetSelectionType();
2337 if(nSelectionType & SelectionType::Frame)
2338 eKeyState = SwKeyState::GoIntoFly;
2339 else
2340 {
2341 SfxItemSetFixed<RES_TXTATR_INETFMT, RES_TXTATR_INETFMT> aSet(rSh.GetAttrPool());
2342 rSh.GetCurAttr(aSet);
2343 if(SfxItemState::SET == aSet.GetItemState(RES_TXTATR_INETFMT, false))
2344 {
2345 const SfxPoolItem& rItem = aSet.Get(RES_TXTATR_INETFMT);
2346 bNormalChar = false;
2347 eKeyState = SwKeyState::End;
2348 rSh.ClickToINetAttr(static_cast<const SwFormatINetFormat&>(rItem));
2349 }
2350 }
2351 }
2352 break;
2353 }
2354 }
2355 break;
2356
2357 case SwKeyState::EnterCharCell:
2358 {
2359 eKeyState = SwKeyState::KeyToView;
2360 switch ( rKeyCode.GetModifier() | rKeyCode.GetCode() )
2361 {
2362 case KEY_RIGHT | KEY_MOD2:
2363 rSh.Right( SwCursorSkipMode::Chars, false, 1, false );
2364 eKeyState = SwKeyState::End;
2365 FlushInBuffer();
2366 break;
2367 case KEY_LEFT | KEY_MOD2:
2368 rSh.Left( SwCursorSkipMode::Chars, false, 1, false );
2369 eKeyState = SwKeyState::End;
2370 FlushInBuffer();
2371 break;
2372 }
2373 }
2374 break;
2375
2376 case SwKeyState::KeyToView:
2377 {
2378 eKeyState = SwKeyState::End;
2379 bNormalChar =
2380 !rKeyCode.IsMod2() &&
2381 rKeyCode.GetModifier() != KEY_MOD1 &&
2382 rKeyCode.GetModifier() != (KEY_MOD1|KEY_SHIFT) &&
2383 SW_ISPRINTABLE( aCh );
2384
2385 if( bNormalChar && rSh.IsInFrontOfLabel() )
2386 {
2387 rSh.NumOrNoNum();
2388 }
2389
2390 if( !m_aInBuffer.isEmpty() && ( !bNormalChar || bIsDocReadOnly ))
2391 FlushInBuffer();
2392
2393 if (rSh.HasReadonlySel()
2394 && ( rKeyCode.GetFunction() == KeyFuncType::PASTE
2395 || rKeyCode.GetFunction() == KeyFuncType::CUT))
2396 {
2397 rSh.InfoReadOnlyDialog(true);
2398 eKeyState = SwKeyState::End;
2399 }
2400 else if( m_rView.KeyInput( aKeyEvent ) )
2401 {
2402 bFlushBuffer = true;
2403 bNormalChar = false;
2404 }
2405 else
2406 {
2407 // Because Sfx accelerators are only called when they were
2408 // enabled at the last status update, copy has to called
2409 // 'forcefully' by us if necessary.
2410 if( rKeyCode.GetFunction() == KeyFuncType::COPY )
2411 GetView().GetViewFrame().GetBindings().Execute(SID_COPY);
2412
2413 if( !bIsDocReadOnly && bNormalChar )
2414 {
2415 const SelectionType nSelectionType = rSh.GetSelectionType();
2416 const bool bDrawObject = (nSelectionType & SelectionType::DrawObject) &&
2417 !(nSelectionType & SelectionType::DrawObjectEditMode) &&
2418 rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1;
2419
2420 bool bTextBox = false;
2421 if (bDrawObject && lcl_goIntoTextBox(*this, rSh))
2422 // A draw shape was selected, but it has a TextBox,
2423 // start editing that instead when the normal
2424 // character is pressed.
2425 bTextBox = true;
2426
2427 if (bDrawObject && !bTextBox)
2428 {
2429 SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
2430 if(pObj)
2431 {
2432 EnterDrawTextMode(pObj->GetLogicRect().Center());
2433 if ( auto pSwDrawTextShell = dynamic_cast< SwDrawTextShell *>( m_rView.GetCurShell() ) )
2434 pSwDrawTextShell->Init();
2435 rSh.GetDrawView()->KeyInput( rKEvt, this );
2436 }
2437 }
2438 else if (nSelectionType & SelectionType::Frame || bTextBox)
2439 {
2440 rSh.UnSelectFrame();
2441 rSh.LeaveSelFrameMode();
2442 m_rView.AttrChangedNotify(nullptr);
2443 rSh.MoveSection( GoCurrSection, fnSectionEnd );
2444 }
2445 eKeyState = SwKeyState::InsChar;
2446 }
2447 else
2448 {
2449 bNormalChar = false;
2450 Window::KeyInput( aKeyEvent );
2451 }
2452 }
2453 }
2454 break;
2455 case SwKeyState::LaunchOLEObject:
2456 {
2457 rSh.LaunchOLEObj();
2458 eKeyState = SwKeyState::End;
2459 }
2460 break;
2461 case SwKeyState::GoIntoFly:
2462 {
2463 rSh.UnSelectFrame();
2464 rSh.LeaveSelFrameMode();
2465 m_rView.AttrChangedNotify(nullptr);
2466 rSh.MoveSection( GoCurrSection, fnSectionEnd );
2467 eKeyState = SwKeyState::End;
2468 }
2469 break;
2470 case SwKeyState::GoIntoDrawing:
2471 {
2472 if (SdrMark* pMark = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0))
2473 {
2474 SdrObject* pObj = pMark->GetMarkedSdrObj();
2475 if(pObj)
2476 {
2477 EnterDrawTextMode(pObj->GetLogicRect().Center());
2478 if (auto pSwDrawTextShell = dynamic_cast< SwDrawTextShell *>( m_rView.GetCurShell() ) )
2479 pSwDrawTextShell->Init();
2480 }
2481 }
2482 eKeyState = SwKeyState::End;
2483 }
2484 break;
2485 case SwKeyState::EnterDrawHandleMode:
2486 {
2487 const SdrHdlList& rHdlList = rSh.GetDrawView()->GetHdlList();
2488 bool bForward(!aKeyEvent.GetKeyCode().IsShift());
2489
2490 const_cast<SdrHdlList&>(rHdlList).TravelFocusHdl(bForward);
2491 eKeyState = SwKeyState::End;
2492 }
2493 break;
2494 case SwKeyState::InsTab:
2495 if( dynamic_cast<const SwWebView*>( &m_rView) != nullptr) // no Tab for WebView
2496 {
2497 // then it should be passed along
2498 Window::KeyInput( aKeyEvent );
2499 eKeyState = SwKeyState::End;
2500 break;
2501 }
2502 aCh = '\t';
2503 [[fallthrough]];
2504 case SwKeyState::InsChar:
2505 if (rSh.CursorInsideContentControl())
2506 {
2507 const SwPosition* pStart = rSh.GetCursor()->Start();
2508 SwTextNode* pTextNode = pStart->GetNode().GetTextNode();
2509 if (pTextNode)
2510 {
2511 sal_Int32 nIndex = pStart->GetContentIndex();
2512 SwTextAttr* pAttr = pTextNode->GetTextAttrAt(nIndex, RES_TXTATR_CONTENTCONTROL, ::sw::GetTextAttrMode::Parent);
2513 if (pAttr)
2514 {
2515 auto pTextContentControl = static_txtattr_cast<SwTextContentControl*>(pAttr);
2516 const SwFormatContentControl& rFormatContentControl = pTextContentControl->GetContentControl();
2517 std::shared_ptr<SwContentControl> pContentControl = rFormatContentControl.GetContentControl();
2518 if (pContentControl->IsInteractingCharacter(aCh))
2519 {
2520 rSh.GotoContentControl(rFormatContentControl);
2521 eKeyState = SwKeyState::End;
2522 break;
2523 }
2524 }
2525 }
2526 }
2527
2528 if (rSh.GetChar(false)==CH_TXT_ATR_FORMELEMENT)
2529 {
2530 ::sw::mark::ICheckboxFieldmark* pFieldmark =
2531 dynamic_cast< ::sw::mark::ICheckboxFieldmark* >
2532 (rSh.GetCurrentFieldmark());
2533 OSL_ENSURE(pFieldmark,
2534 "Where is my FieldMark??");
2535 if(pFieldmark)
2536 {
2537 pFieldmark->SetChecked(!pFieldmark->IsChecked());
2538 OSL_ENSURE(pFieldmark->IsExpanded(),
2539 "where is the otherpos?");
2540 if (pFieldmark->IsExpanded())
2541 {
2542 rSh.CalcLayout();
2543 }
2544 }
2545 eKeyState = SwKeyState::End;
2546 }
2547 else if ( !rSh.HasReadonlySel()
2548 || rSh.CursorInsideInputField() )
2549 {
2550 const bool bIsNormalChar =
2551 GetAppCharClass().isLetterNumeric( OUString( aCh ), 0 );
2552 if( bAppendSpace && bIsNormalChar &&
2553 (!m_aInBuffer.isEmpty() || !rSh.IsSttPara() || !rSh.IsEndPara() ))
2554 {
2555 // insert a blank ahead of the character. this ends up
2556 // between the expanded text and the new "non-word-separator".
2557 m_aInBuffer += " ";
2558 }
2559
2560 const bool bIsAutoCorrectChar = SvxAutoCorrect::IsAutoCorrectChar( aCh );
2561 if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || rSh.IsNbspRunNext() ) &&
2562 pACfg->IsAutoFormatByInput() &&
2563 (( pACorr->IsAutoCorrFlag( ACFlags::ChgWeightUnderl ) &&
2564 ( '*' == aCh || '_' == aCh ) ) ||
2565 ( pACorr->IsAutoCorrFlag( ACFlags::ChgQuotes ) && ('\"' == aCh ))||
2566 ( pACorr->IsAutoCorrFlag( ACFlags::ChgSglQuotes ) && ( '\'' == aCh))))
2567 {
2568 FlushInBuffer();
2569 rSh.AutoCorrect( *pACorr, aCh );
2570 if( '\"' != aCh && '\'' != aCh ) // only call when "*_"!
2571 rSh.UpdateAttr();
2572 }
2573 else if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || rSh.IsNbspRunNext() ) &&
2574 pACfg->IsAutoFormatByInput() &&
2575 pACorr->IsAutoCorrFlag( ACFlags::CapitalStartSentence | ACFlags::CapitalStartWord |
2576 ACFlags::ChgOrdinalNumber | ACFlags::AddNonBrkSpace |
2577 ACFlags::ChgToEnEmDash | ACFlags::SetINetAttr |
2578 ACFlags::Autocorrect | ACFlags::TransliterateRTL |
2579 ACFlags::SetDOIAttr ) &&
2580 '\"' != aCh && '\'' != aCh && '*' != aCh && '_' != aCh
2581 )
2582 {
2583 FlushInBuffer();
2584 rSh.AutoCorrect( *pACorr, aCh );
2585 }
2586 else
2587 {
2588 OUStringBuffer aBuf(m_aInBuffer);
2589 comphelper::string::padToLength(aBuf,
2590 m_aInBuffer.getLength() + aKeyEvent.GetRepeat() + 1, aCh);
2591 m_aInBuffer = aBuf.makeStringAndClear();
2592 bool delayFlush = Application::AnyInput( VclInputFlags::KEYBOARD );
2593 bFlushBuffer = !delayFlush;
2594 if( delayFlush )
2595 {
2596 // Start the timer, make sure to not restart it.
2597 keyInputFlushTimerStop.dismiss();
2598 if( !m_aKeyInputFlushTimer.IsActive())
2599 m_aKeyInputFlushTimer.Start();
2600 }
2601 }
2602 eKeyState = SwKeyState::End;
2603 }
2604 else
2605 {
2606 rSh.InfoReadOnlyDialog(true);
2607 eKeyState = SwKeyState::End;
2608 }
2609 break;
2610
2611 case SwKeyState::CheckAutoCorrect:
2612 {
2613 if( pACorr && pACfg->IsAutoFormatByInput() &&
2614 pACorr->IsAutoCorrFlag( ACFlags::CapitalStartSentence | ACFlags::CapitalStartWord |
2615 ACFlags::ChgOrdinalNumber | ACFlags::TransliterateRTL |
2616 ACFlags::ChgToEnEmDash | ACFlags::SetINetAttr |
2617 ACFlags::Autocorrect | ACFlags::SetDOIAttr ) &&
2618 !rSh.HasReadonlySel() )
2619 {
2620 FlushInBuffer();
2621 rSh.AutoCorrect( *pACorr, u'\0' );
2622 }
2623 eKeyState = eNextKeyState;
2624 }
2625 break;
2626
2627 default:
2628 {
2629 sal_uInt16 nSlotId = 0;
2630 FlushInBuffer();
2631 switch( eKeyState )
2632 {
2633 case SwKeyState::SpecialInsert:
2634 rSh.DoSpecialInsert();
2635 break;
2636
2637 case SwKeyState::NoNum:
2638 rSh.NoNum();
2639 break;
2640
2641 case SwKeyState::NumOff:
2642 // shell change - so record in advance
2643 rSh.DelNumRules();
2644 break;
2645 case SwKeyState::OutlineLvOff: // delete autofmt outlinelevel later
2646 break;
2647
2648 case SwKeyState::NumDown:
2649 rSh.NumUpDown();
2650 m_nKS_NUMDOWN_Count = 2;
2651 break;
2652 case SwKeyState::NumUp:
2653 rSh.NumUpDown( false );
2654 break;
2655
2656 case SwKeyState::NumIndentInc:
2657 rSh.ChangeIndentOfAllListLevels(360);
2658 m_nKS_NUMINDENTINC_Count = 2;
2659 break;
2660
2661 case SwKeyState::GotoNextFieldMark:
2662 {
2663 rSh.GotoFormControl(/*bNext=*/true);
2664 }
2665 break;
2666
2667 case SwKeyState::GotoPrevFieldMark:
2668 {
2669 rSh.GotoFormControl(/*bNext=*/false);
2670 }
2671 break;
2672
2673 case SwKeyState::NumIndentDec:
2674 rSh.ChangeIndentOfAllListLevels(-360);
2675 break;
2676
2677 case SwKeyState::OutlineDown:
2678 rSh.OutlineUpDown();
2679 break;
2680 case SwKeyState::OutlineUp:
2681 rSh.OutlineUpDown( -1 );
2682 break;
2683
2684 case SwKeyState::NextCell:
2685 // always 'flush' in tables
2686 rSh.GoNextCell(!rSh.HasReadonlySel());
2687 nSlotId = FN_GOTO_NEXT_CELL;
2688 break;
2689 case SwKeyState::PrevCell:
2690 rSh.GoPrevCell();
2691 nSlotId = FN_GOTO_PREV_CELL;
2692 break;
2693 case SwKeyState::AutoFormatByInput:
2694 rSh.SplitNode( true );
2695 break;
2696
2697 case SwKeyState::NextObject:
2698 case SwKeyState::PrevObject:
2699 if(rSh.GotoObj( SwKeyState::NextObject == eKeyState, GotoObjFlags::Any))
2700 {
2701 if( rSh.IsFrameSelected() &&
2702 m_rView.GetDrawFuncPtr() )
2703 {
2704 m_rView.GetDrawFuncPtr()->Deactivate();
2705 m_rView.SetDrawFuncPtr(nullptr);
2706 m_rView.LeaveDrawCreate();
2707 m_rView.AttrChangedNotify(nullptr);
2708 }
2709 rSh.HideCursor();
2710 rSh.EnterSelFrameMode();
2711 }
2712 break;
2713 case SwKeyState::GlossaryExpand:
2714 {
2715 // replace the word or abbreviation with the auto text
2716 rSh.StartUndo( SwUndoId::START );
2717
2718 OUString sFnd(aTmpQHD.CurStr());
2719 if( aTmpQHD.m_bIsAutoText )
2720 {
2721 SwGlossaryList* pList = ::GetGlossaryList();
2722 OUString sShrtNm;
2723 OUString sGroup;
2724 if(pList->GetShortName( sFnd, sShrtNm, sGroup))
2725 {
2726 rSh.SttSelect();
2727 rSh.ExtendSelection(false, aTmpQHD.CurLen());
2728 SwGlossaryHdl* pGlosHdl = GetView().GetGlosHdl();
2729 pGlosHdl->SetCurGroup(sGroup, true);
2730 pGlosHdl->InsertGlossary( sShrtNm);
2731 s_pQuickHlpData->m_bAppendSpace = true;
2732 }
2733 }
2734 else
2735 {
2736 sFnd = sFnd.copy(aTmpQHD.CurLen());
2737 rSh.Insert( sFnd );
2738 s_pQuickHlpData->m_bAppendSpace = !pACorr ||
2739 pACorr->GetSwFlags().bAutoCmpltAppendBlank;
2740 }
2741 rSh.EndUndo( SwUndoId::END );
2742 }
2743 break;
2744
2745 case SwKeyState::NextPrevGlossary:
2746 s_pQuickHlpData->Move( aTmpQHD );
2747 s_pQuickHlpData->Start(rSh, false);
2748 break;
2749
2750 case SwKeyState::EditFormula:
2751 {
2752 const sal_uInt16 nId = SwInputChild::GetChildWindowId();
2753
2754 SfxViewFrame& rVFrame = GetView().GetViewFrame();
2755 rVFrame.ToggleChildWindow( nId );
2756 SwInputChild* pChildWin = static_cast<SwInputChild*>(rVFrame.
2757 GetChildWindow( nId ));
2758 if( pChildWin )
2759 pChildWin->SetFormula( sFormulaEntry );
2760 }
2761 break;
2762
2763 case SwKeyState::ColLeftBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::ColLeft|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableHMove() ); break;
2764 case SwKeyState::ColRightBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::ColRight|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableHMove() ); break;
2765 case SwKeyState::ColLeftSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::ColLeft, pModOpt->GetTableHMove() ); break;
2766 case SwKeyState::ColRightSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::ColRight, pModOpt->GetTableHMove() ); break;
2767 case SwKeyState::ColBottomBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::RowBottom|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableVMove() ); break;
2768 case SwKeyState::ColBottomSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::RowBottom, pModOpt->GetTableVMove() ); break;
2769 case SwKeyState::CellLeftBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellLeft|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableHMove() ); break;
2770 case SwKeyState::CellRightBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellRight|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableHMove() ); break;
2771 case SwKeyState::CellLeftSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellLeft, pModOpt->GetTableHMove() ); break;
2772 case SwKeyState::CellRightSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellRight, pModOpt->GetTableHMove() ); break;
2773 case SwKeyState::CellTopBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellTop|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableVMove() ); break;
2774 case SwKeyState::CellBottomBig: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellBottom|TableChgWidthHeightType::BiggerMode, pModOpt->GetTableVMove() ); break;
2775 case SwKeyState::CellTopSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellTop, pModOpt->GetTableVMove() ); break;
2776 case SwKeyState::CellBottomSmall: rSh.SetColRowWidthHeight( TableChgWidthHeightType::CellBottom, pModOpt->GetTableVMove() ); break;
2777
2778 case SwKeyState::Fly_Change:
2779 {
2780 SdrView *pSdrView = rSh.GetDrawView();
2781 const SdrHdlList& rHdlList = pSdrView->GetHdlList();
2782 if(rHdlList.GetFocusHdl())
2783 ChangeDrawing( nDir );
2784 else
2785 ChangeFly( nDir, dynamic_cast<const SwWebView*>( &m_rView) != nullptr );
2786 }
2787 break;
2788 case SwKeyState::Draw_Change :
2789 ChangeDrawing( nDir );
2790 break;
2791 default:
2792 break;
2793 }
2794 if( nSlotId && m_rView.GetViewFrame().GetBindings().GetRecorder().is() )
2795 {
2796 SfxRequest aReq(m_rView.GetViewFrame(), nSlotId);
2797 aReq.Done();
2798 }
2799 eKeyState = SwKeyState::End;
2800 }
2801 }
2802 }
2803
2804 // update the page number in the statusbar
2805 sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();
2806 if( KEY_UP == nKey || KEY_DOWN == nKey || KEY_PAGEUP == nKey || KEY_PAGEDOWN == nKey )
2807 GetView().GetViewFrame().GetBindings().Update( FN_STAT_PAGE );
2808
2809 // in case the buffered characters are inserted
2810 if( bFlushBuffer && !m_aInBuffer.isEmpty() )
2811 {
2812 FlushInBuffer();
2813
2814 // maybe show Tip-Help
2815 if (bNormalChar)
2816 {
2817 const bool bAutoTextShown
2818 = pACfg && pACfg->IsAutoTextTip() && ShowAutoText(rSh.GetChunkForAutoText());
2819 if (!bAutoTextShown && pACorr && pACorr->GetSwFlags().bAutoCompleteWords)
2820 ShowAutoCorrectQuickHelp(rSh.GetPrevAutoCorrWord(*pACorr), *pACorr);
2821 }
2822 }
2823
2824 // get the word count dialog to update itself
2825 SwWordCountWrapper *pWrdCnt = static_cast<SwWordCountWrapper*>(GetView().GetViewFrame().GetChildWindow(SwWordCountWrapper::GetChildWindowId()));
2826 if( pWrdCnt )
2827 pWrdCnt->UpdateCounts();
2828
2829}
2830
2834void SwEditWin::ResetMouseButtonDownFlags()
2835{
2836 // Not on all systems a MouseButtonUp is used ahead
2837 // of the modal dialog (like on WINDOWS).
2838 // So reset the statuses here and release the mouse
2839 // for the dialog.
2840 m_bMBPressed = false;
2841 g_bNoInterrupt = false;
2842 EnterArea();
2843 ReleaseMouse();
2844}
2845
2850static bool lcl_urlOverBackground(SwWrtShell& rSh, const Point& rDocPos)
2851{
2852 SwContentAtPos aSwContentAtPos(IsAttrAtPos::InetAttr);
2853 SdrObject* pSelectableObj = rSh.GetObjAt(rDocPos);
2854
2855 return rSh.GetContentAtPos(rDocPos, aSwContentAtPos) && pSelectableObj->GetLayer() == rSh.GetDoc()->getIDocumentDrawModelAccess().GetHellId();
2856}
2857
2858void SwEditWin::MoveCursor( SwWrtShell &rSh, const Point& rDocPos,
2859 const bool bOnlyText, bool bLockView )
2860{
2861 const bool bTmpNoInterrupt = g_bNoInterrupt;
2862 g_bNoInterrupt = false;
2863
2864 int nTmpSetCursor = 0;
2865
2866 if( !rSh.IsViewLocked() && bLockView )
2867 rSh.LockView( true );
2868 else
2869 bLockView = false;
2870
2871 {
2872 // only temporary generate move context because otherwise
2873 // the query to the content form doesn't work!!!
2874 SwMvContext aMvContext( &rSh );
2875 nTmpSetCursor = rSh.CallSetCursor(&rDocPos, bOnlyText);
2876 g_bValidCursorPos = !(CRSR_POSCHG & nTmpSetCursor);
2877 }
2878
2879 // notify the edit window that from now on we do not use the input language
2880 if ( !(CRSR_POSOLD & nTmpSetCursor) )
2881 SetUseInputLanguage( false );
2882
2883 if( bLockView )
2884 rSh.LockView( false );
2885
2886 g_bNoInterrupt = bTmpNoInterrupt;
2887}
2888
2889void SwEditWin::MouseButtonDown(const MouseEvent& _rMEvt)
2890{
2891 SwWrtShell &rSh = m_rView.GetWrtShell();
2892 const SwField *pCursorField = rSh.CursorInsideInputField() ? rSh.GetCurField( true ) : nullptr;
2893
2894 // We have to check if a context menu is shown and we have an UI
2895 // active inplace client. In that case we have to ignore the mouse
2896 // button down event. Otherwise we would crash (context menu has been
2897 // opened by inplace client and we would deactivate the inplace client,
2898 // the context menu is closed by VCL asynchronously which in the end
2899 // would work on deleted objects or the context menu has no parent anymore)
2900 SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient();
2901 bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
2902
2903 if (bIsOleActive && vcl::IsInPopupMenuExecute())
2904 return;
2905
2906 MouseEvent aMEvt(_rMEvt);
2907
2908 if (m_rView.GetPostItMgr()->IsHit(aMEvt.GetPosPixel()))
2909 return;
2910
2911 if (comphelper::LibreOfficeKit::isActive())
2912 {
2913 if (vcl::Window* pWindow = m_rView.GetPostItMgr()->IsHitSidebarWindow(aMEvt.GetPosPixel()))
2914 {
2915 pWindow->MouseButtonDown(aMEvt);
2916 return;
2917 }
2918 }
2919
2920 m_rView.GetPostItMgr()->SetActiveSidebarWin(nullptr);
2921
2922 GrabFocus();
2923 rSh.addCurrentPosition();
2924
2925 //ignore key modifiers for format paintbrush
2926 {
2927 bool bExecFormatPaintbrush = m_pApplyTempl && m_pApplyTempl->m_pFormatClipboard
2928 && m_pApplyTempl->m_pFormatClipboard->HasContent();
2929 if( bExecFormatPaintbrush )
2930 aMEvt = MouseEvent(_rMEvt.GetPosPixel(), _rMEvt.GetClicks(), _rMEvt.GetMode(),
2931 _rMEvt.GetButtons());
2932 }
2933
2934 m_bWasShdwCursor = nullptr != m_pShadCursor;
2935 m_pShadCursor.reset();
2936
2937 const Point aDocPos(PixelToLogic(aMEvt.GetPosPixel()));
2938
2939 FrameControlType eControl;
2940 bool bOverFly = false;
2941 bool bPageAnchored = false;
2942 bool bOverHeaderFooterFly = IsOverHeaderFooterFly( aDocPos, eControl, bOverFly, bPageAnchored );
2943
2944 bool bIsDocReadOnly = m_rView.GetDocShell()->IsReadOnly();
2945 if (bOverHeaderFooterFly && (!bIsDocReadOnly && rSh.GetCurField()))
2946 // We have a field here, that should have priority over header/footer fly.
2947 bOverHeaderFooterFly = false;
2948
2949 // Are we clicking on a blank header/footer area?
2950 if ( IsInHeaderFooter( aDocPos, eControl ) || bOverHeaderFooterFly )
2951 {
2952 const SwPageFrame* pPageFrame = rSh.GetLayout()->GetPageAtPos( aDocPos );
2953
2954 if ( pPageFrame )
2955 {
2956 // Is it active?
2957 bool bActive = true;
2958 const SwPageDesc* pDesc = pPageFrame->GetPageDesc();
2959
2960 const SwFrameFormat* pFormat = pDesc->GetLeftFormat();
2961 if ( pPageFrame->OnRightPage() )
2962 pFormat = pDesc->GetRightFormat();
2963
2964 if ( pFormat )
2965 {
2966 if ( eControl == FrameControlType::Header )
2967 bActive = pFormat->GetHeader().IsActive();
2968 else
2969 bActive = pFormat->GetFooter().IsActive();
2970 }
2971
2972 if ( !bActive )
2973 {
2974 // HeaderFooter menu implies header/footer controls, so only do this with IsUseHeaderFooterMenu enabled.
2975 // But, additionally, when in Hide-Whitespace mode, we don't want those controls.
2976 if (rSh.GetViewOptions()->IsUseHeaderFooterMenu() && !rSh.GetViewOptions()->IsHideWhitespaceMode())
2977 {
2978 SwPaM aPam(*rSh.GetCurrentShellCursor().GetPoint());
2979 const bool bWasInHeader = aPam.GetPoint()->GetNode().FindHeaderStartNode() != nullptr;
2980 const bool bWasInFooter = aPam.GetPoint()->GetNode().FindFooterStartNode() != nullptr;
2981
2982 // Is the cursor in a part like similar to the one we clicked on? For example,
2983 // if the cursor is in a header and we click on an empty header... don't change anything to
2984 // keep consistent behaviour due to header edit mode (and the same for the footer as well).
2985
2986 // Otherwise, we hide the header/footer control if a separator is shown, and vice versa.
2987 if (!(bWasInHeader && eControl == FrameControlType::Header) &&
2988 !(bWasInFooter && eControl == FrameControlType::Footer))
2989 {
2990 const bool bSeparatorWasVisible = rSh.IsShowHeaderFooterSeparator(eControl);
2991 rSh.SetShowHeaderFooterSeparator(eControl, !bSeparatorWasVisible);
2992
2993 // Repaint everything
2994 Invalidate();
2995
2996 // tdf#84929. If the footer control had not been showing, do not change the cursor position,
2997 // because the user may have scrolled to turn on the separator control and
2998 // if the cursor cannot be positioned on-screen, then the user would need to scroll back again to use the control.
2999 // This should only be done for the footer. The cursor can always be re-positioned near the header. tdf#134023.
3000 if ( eControl == FrameControlType::Footer && !bSeparatorWasVisible
3001 && !Application::IsHeadlessModeEnabled() )
3002 return;
3003 }
3004 }
3005 }
3006 else
3007 {
3008 // Make sure we have the proper Header/Footer separators shown
3009 // as these may be changed if clicking on an empty Header/Footer
3010 rSh.SetShowHeaderFooterSeparator( FrameControlType::Header, eControl == FrameControlType::Header );
3011 rSh.SetShowHeaderFooterSeparator( FrameControlType::Footer, eControl == FrameControlType::Footer );
3012
3013 if ( !rSh.IsHeaderFooterEdit() )
3014 rSh.ToggleHeaderFooterEdit();
3015 }
3016 }
3017 }
3018 else
3019 {
3020 if ( rSh.IsHeaderFooterEdit( ) )
3021 rSh.ToggleHeaderFooterEdit( );
3022 else
3023 {
3024 // Make sure that the separators are hidden
3025 rSh.SetShowHeaderFooterSeparator( FrameControlType::Header, false );
3026 rSh.SetShowHeaderFooterSeparator( FrameControlType::Footer, false );
3027 }
3028
3029 // Toggle Hide-Whitespace if between pages.
3030 if (rSh.GetViewOptions()->CanHideWhitespace() &&
3031 rSh.GetLayout()->IsBetweenPages(aDocPos))
3032 {
3033 if (_rMEvt.GetClicks() >= 2)
3034 {
3035 SwViewOption aOpt(*rSh.GetViewOptions());
3036 aOpt.SetHideWhitespaceMode(!aOpt.IsHideWhitespaceMode());
3037 rSh.ApplyViewOptions(aOpt);
3038 }
3039
3040 return;
3041 }
3042 }
3043
3044 if ( IsChainMode() )
3045 {
3046 SetChainMode( false );
3047 SwRect aDummy;
3048 SwFlyFrameFormat *pFormat = static_cast<SwFlyFrameFormat*>(rSh.GetFlyFrameFormat());
3049 if ( rSh.Chainable( aDummy, *pFormat, aDocPos ) == SwChainRet::OK )
3050 rSh.Chain( *pFormat, aDocPos );
3051 UpdatePointer(aDocPos, aMEvt.GetModifier());
3052 return;
3053 }
3054
3055 // After GrabFocus a shell should be pushed. That should actually
3056 // work but in practice ...
3057 m_rView.SelectShellForDrop();
3058
3059 bool bCallBase = true;
3060
3061 if( s_pQuickHlpData->m_bIsDisplayed )
3062 s_pQuickHlpData->Stop( rSh );
3063 s_pQuickHlpData->m_bAppendSpace = false;
3064
3065 if( rSh.FinishOLEObj() )
3066 return; // end InPlace and the click doesn't count anymore
3067
3068 CurrShell aCurr( &rSh );
3069
3070 SdrView *pSdrView = rSh.GetDrawView();
3071 if ( pSdrView )
3072 {
3073 if (pSdrView->MouseButtonDown(aMEvt, GetOutDev()))
3074 {
3075 rSh.GetView().GetViewFrame().GetBindings().InvalidateAll(false);
3076 return; // SdrView's event evaluated
3077 }
3078 }
3079
3080 m_bIsInMove = false;
3081 m_aStartPos = aMEvt.GetPosPixel();
3082 m_aRszMvHdlPt.setX( 0 );
3083 m_aRszMvHdlPt.setY( 0 );
3084
3085 SwTab nMouseTabCol = SwTab::COL_NONE;
3086 const bool bTmp = !rSh.IsDrawCreate() && !m_pApplyTempl && !rSh.IsInSelect()
3087 && aMEvt.GetClicks() == 1 && MOUSE_LEFT == aMEvt.GetButtons();
3088 if ( bTmp &&
3089 SwTab::COL_NONE != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPos ) ) &&
3090 !rSh.IsObjSelectable( aDocPos ) )
3091 {
3092 // Enhanced table selection
3093 if ( SwTab::SEL_HORI <= nMouseTabCol && SwTab::COLSEL_VERT >= nMouseTabCol )
3094 {
3095 rSh.EnterStdMode();
3096 rSh.SelectTableRowCol( aDocPos );
3097 if( SwTab::SEL_HORI != nMouseTabCol && SwTab::SEL_HORI_RTL != nMouseTabCol)
3098 {
3099 m_xRowColumnSelectionStart = aDocPos;
3100 m_bIsRowDrag = SwTab::ROWSEL_HORI == nMouseTabCol||
3101 SwTab::ROWSEL_HORI_RTL == nMouseTabCol ||
3102 SwTab::COLSEL_VERT == nMouseTabCol;
3103 m_bMBPressed = true;
3104 CaptureMouse();
3105 }
3106 return;
3107 }
3108
3109 if ( !rSh.IsTableMode() )
3110 {
3111 // comes from table columns out of the document.
3112 if(SwTab::COL_VERT == nMouseTabCol || SwTab::COL_HORI == nMouseTabCol)
3113 m_rView.SetTabColFromDoc( true );
3114 else
3115 m_rView.SetTabRowFromDoc( true );
3116
3117 m_rView.SetTabColFromDocPos( aDocPos );
3118 m_rView.InvalidateRulerPos();
3119 SfxBindings& rBind = m_rView.GetViewFrame().GetBindings();
3120 rBind.Update();
3121 if (RulerColumnDrag(
3122 aMEvt, (SwTab::COL_VERT == nMouseTabCol || SwTab::ROW_HORI == nMouseTabCol)))
3123 {
3124 m_rView.SetTabColFromDoc( false );
3125 m_rView.SetTabRowFromDoc( false );
3126 m_rView.InvalidateRulerPos();
3127 rBind.Update();
3128 bCallBase = false;
3129 }
3130 else
3131 {
3132 return;
3133 }
3134 }
3135 }
3136 else if (bTmp &&
3137 rSh.IsNumLabel(aDocPos))
3138 {
3139 SwTextNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPos );
3140 m_rView.SetNumRuleNodeFromDoc( pNodeAtPos );
3141 m_rView.InvalidateRulerPos();
3142 SfxBindings& rBind = m_rView.GetViewFrame().GetBindings();
3143 rBind.Update();
3144
3145 if (RulerMarginDrag(aMEvt, SwFEShell::IsVerticalModeAtNdAndPos(*pNodeAtPos, aDocPos)))
3146 {
3147 m_rView.SetNumRuleNodeFromDoc( nullptr );
3148 m_rView.InvalidateRulerPos();
3149 rBind.Update();
3150 bCallBase = false;
3151 }
3152 else
3153 {
3154 // Make sure the pointer is set to 0, otherwise it may point to
3155 // nowhere after deleting the corresponding text node.
3156 m_rView.SetNumRuleNodeFromDoc( nullptr );
3157 return;
3158 }
3159 }
3160
3161 if ( rSh.IsInSelect() )
3162 rSh.EndSelect();
3163
3164 // query against LEFT because otherwise for example also a right
3165 // click releases the selection.
3166 if (MOUSE_LEFT == aMEvt.GetButtons())
3167 {
3168 bool bOnlyText = false;
3169 m_bMBPressed = true;
3170 g_bNoInterrupt = true;
3171 m_nKS_NUMDOWN_Count = 0;
3172
3173 CaptureMouse();
3174
3175 // reset cursor position if applicable
3176 rSh.ResetCursorStack();
3177
3178 switch (aMEvt.GetModifier() + aMEvt.GetButtons())
3179 {
3180 case MOUSE_LEFT:
3181 case MOUSE_LEFT + KEY_SHIFT:
3182 case MOUSE_LEFT + KEY_MOD2:
3183 if( rSh.IsObjSelected() )
3184 {
3185 SdrHdl* pHdl;
3186 if( !bIsDocReadOnly &&
3187 !m_pAnchorMarker &&
3188 pSdrView &&
3189 nullptr != ( pHdl = pSdrView->PickHandle(aDocPos) ) &&
3190 ( pHdl->GetKind() == SdrHdlKind::Anchor ||
3191 pHdl->GetKind() == SdrHdlKind::Anchor_TR ) )
3192 {
3193 // #i121463# Set selected during drag
3194 pHdl->SetSelected();
3195 m_pAnchorMarker.reset( new SwAnchorMarker( pHdl ) );
3196 UpdatePointer(aDocPos, aMEvt.GetModifier());
3197 return;
3198 }
3199 }
3200 if (EnterDrawMode(aMEvt, aDocPos))
3201 {
3202 g_bNoInterrupt = false;
3203 return;
3204 }
3205 else if ( m_rView.GetDrawFuncPtr() && m_bInsFrame )
3206 {
3207 StopInsFrame();
3208 rSh.Edit();
3209 }
3210
3211 // Without SHIFT because otherwise Toggle doesn't work at selection
3212 if (aMEvt.GetClicks() == 1)
3213 {
3214 if ( rSh.IsSelFrameMode())
3215 {
3216 SdrHdl* pHdl = rSh.GetDrawView()->PickHandle(aDocPos);
3217 bool bHitHandle = pHdl && pHdl->GetKind() != SdrHdlKind::Anchor &&
3218 pHdl->GetKind() != SdrHdlKind::Anchor_TR;
3219
3220 if ((rSh.IsInsideSelectedObj(aDocPos) || bHitHandle)
3221 && (aMEvt.GetModifier() != KEY_SHIFT || bHitHandle))
3222 {
3223 rSh.EnterSelFrameMode( &aDocPos );
3224 if ( !m_pApplyTempl )
3225 {
3226 // only if no position to size was hit.
3227 if (!bHitHandle)
3228 {
3229 StartDDTimer();
3230 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3231 SwEditWin::s_nDDStartPosX = aDocPos.X();
3232 }
3233 g_bFrameDrag = true;
3234 }
3235 g_bNoInterrupt = false;
3236 return;
3237 }
3238 }
3239 }
3240 }
3241
3242 bool bExecHyperlinks = m_rView.GetDocShell()->IsReadOnly();
3243 if ( !bExecHyperlinks )
3244 {
3245 const bool bSecureOption = SvtSecurityOptions::IsOptionSet( SvtSecurityOptions::EOption::CtrlClickHyperlink );
3246 if ((bSecureOption && aMEvt.GetModifier() == KEY_MOD1)
3247 || (!bSecureOption && aMEvt.GetModifier() != KEY_MOD1))
3248 bExecHyperlinks = true;
3249 }
3250
3251 // Enhanced selection
3252 sal_uInt8 nNumberOfClicks = static_cast<sal_uInt8>(aMEvt.GetClicks() % 4);
3253 if (0 == nNumberOfClicks && 0 < aMEvt.GetClicks())
3254 nNumberOfClicks = 4;
3255
3256 bool bExecDrawTextLink = false;
3257
3258 switch (aMEvt.GetModifier() + aMEvt.GetButtons())
3259 {
3260 case MOUSE_LEFT:
3261 case MOUSE_LEFT + KEY_MOD1:
3262 case MOUSE_LEFT + KEY_MOD2:
3263 {
3264
3265 // fdo#79604: first, check if a link has been clicked - do not
3266 // select fly in this case!
3267 if (1 == nNumberOfClicks)
3268 {
3269 UpdatePointer(aDocPos, aMEvt.GetModifier());
3270 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3271 SwEditWin::s_nDDStartPosX = aDocPos.X();
3272
3273 // hit a URL in DrawText object?
3274 if (bExecHyperlinks && pSdrView)
3275 {
3276 SdrViewEvent aVEvt;
3277 pSdrView->PickAnything(aMEvt, SdrMouseEventKind::BUTTONDOWN, aVEvt);
3278
3279 if (aVEvt.meEvent == SdrEventKind::ExecuteUrl)
3280 bExecDrawTextLink = true;
3281 }
3282 }
3283
3284 if (1 == nNumberOfClicks && !bExecDrawTextLink)
3285 {
3286 // only try to select frame, if pointer already was
3287 // switched accordingly
3288 if ( m_aActHitType != SdrHitKind::NONE && !rSh.IsSelFrameMode() &&
3289 !GetView().GetViewFrame().GetDispatcher()->IsLocked())
3290 {
3291 // Test if there is a draw object at that position and if it should be selected.
3292 bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
3293
3294 if(bShould)
3295 {
3296 m_rView.NoRotate();
3297 rSh.HideCursor();
3298
3299 bool bUnLockView = !rSh.IsViewLocked();
3300 rSh.LockView( true );
3301 bool bSelObj
3302 = rSh.SelectObj(aDocPos, aMEvt.IsMod1() ? SW_ENTER_GROUP : 0);
3303 if( bUnLockView )
3304 rSh.LockView( false );
3305
3306 if( bSelObj )
3307 {
3308 // if the frame was deselected in the macro
3309 // the cursor just has to be displayed again
3310 if( FrameTypeFlags::NONE == rSh.GetSelFrameType() )
3311 rSh.ShowCursor();
3312 else
3313 {
3314 if (rSh.IsFrameSelected() && m_rView.GetDrawFuncPtr())
3315 {
3316 m_rView.GetDrawFuncPtr()->Deactivate();
3317 m_rView.SetDrawFuncPtr(nullptr);
3318 m_rView.LeaveDrawCreate();
3319 m_rView.AttrChangedNotify(nullptr);
3320 }
3321
3322 rSh.EnterSelFrameMode( &aDocPos );
3323 g_bFrameDrag = true;
3324 UpdatePointer(aDocPos, aMEvt.GetModifier());
3325 }
3326 return;
3327 }
3328 else
3329 bOnlyText = rSh.IsObjSelectable( aDocPos );
3330
3331 if (!m_rView.GetDrawFuncPtr())
3332 rSh.ShowCursor();
3333 }
3334 else
3335 bOnlyText = KEY_MOD1 != aMEvt.GetModifier();
3336 }
3337 else if ( rSh.IsSelFrameMode() &&
3338 (m_aActHitType == SdrHitKind::NONE ||
3339 !rSh.IsInsideSelectedObj( aDocPos )))
3340 {
3341 m_rView.NoRotate();
3342 SdrHdl *pHdl;
3343 if( !bIsDocReadOnly && !m_pAnchorMarker && nullptr !=
3344 ( pHdl = pSdrView->PickHandle(aDocPos) ) &&
3345 ( pHdl->GetKind() == SdrHdlKind::Anchor ||
3346 pHdl->GetKind() == SdrHdlKind::Anchor_TR ) )
3347 {
3348 m_pAnchorMarker.reset( new SwAnchorMarker( pHdl ) );
3349 UpdatePointer(aDocPos, aMEvt.GetModifier());
3350 return;
3351 }
3352 else
3353 {
3354 bool bUnLockView = !rSh.IsViewLocked();
3355 rSh.LockView( true );
3356 sal_uInt8 nFlag = aMEvt.IsShift() ? SW_ADD_SELECT : 0;
3357 if (aMEvt.IsMod1())
3358 nFlag = nFlag | SW_ENTER_GROUP;
3359
3360 if ( rSh.IsSelFrameMode() )
3361 {
3362 rSh.UnSelectFrame();
3363 rSh.LeaveSelFrameMode();
3364 m_rView.AttrChangedNotify(nullptr);
3365 }
3366
3367 bool bSelObj = rSh.SelectObj( aDocPos, nFlag );
3368 if( bUnLockView )
3369 rSh.LockView( false );
3370
3371 if( !bSelObj )
3372 {
3373 // move cursor here so that it is not drawn in the
3374 // frame first; ShowCursor() happens in LeaveSelFrameMode()
3375 g_bValidCursorPos = !(CRSR_POSCHG & rSh.CallSetCursor(&aDocPos, false));
3376 rSh.LeaveSelFrameMode();
3377 m_rView.AttrChangedNotify(nullptr);
3378 bCallBase = false;
3379 }
3380 else
3381 {
3382 rSh.HideCursor();
3383 rSh.EnterSelFrameMode( &aDocPos );
3384 rSh.SelFlyGrabCursor();
3385 rSh.MakeSelVisible();
3386 g_bFrameDrag = true;
3387 if( rSh.IsFrameSelected() &&
3388 m_rView.GetDrawFuncPtr() )
3389 {
3390 m_rView.GetDrawFuncPtr()->Deactivate();
3391 m_rView.SetDrawFuncPtr(nullptr);
3392 m_rView.LeaveDrawCreate();
3393 m_rView.AttrChangedNotify(nullptr);
3394 }
3395 UpdatePointer(aDocPos, aMEvt.GetModifier());
3396 return;
3397 }
3398 }
3399 }
3400 }
3401
3402 switch ( nNumberOfClicks )
3403 {
3404 case 1:
3405 break;
3406 case 2:
3407 {
3408 g_bFrameDrag = false;
3409 if (!bIsDocReadOnly && rSh.IsInsideSelectedObj(aDocPos)
3410 && (FlyProtectFlags::NONE
3411 == rSh.IsSelObjProtected(FlyProtectFlags::Content
3412 | FlyProtectFlags::Parent)
3413 || rSh.GetSelectionType() == SelectionType::Ole))
3414 {
3415 /* This is no good: on the one hand GetSelectionType is used as flag field
3416 * (take a look into the GetSelectionType method) and on the other hand the
3417 * return value is used in a switch without proper masking (very nice), this must lead to trouble
3418 */
3419 switch ( rSh.GetSelectionType() & ~SelectionType( SelectionType::FontWork | SelectionType::ExtrudedCustomShape ) )
3420 {
3421 case SelectionType::Graphic:
3422 ResetMouseButtonDownFlags();
3423 if (!comphelper::LibreOfficeKit::isActive())
3424 {
3425 GetView().GetViewFrame().GetBindings().Execute(
3426 FN_FORMAT_GRAFIC_DLG, nullptr,
3427 SfxCallMode::RECORD|SfxCallMode::SLOT);
3428 }
3429 return;
3430
3431 // double click on OLE object --> OLE-InPlace
3432 case SelectionType::Ole:
3433 ResetMouseButtonDownFlags();
3434 rSh.LaunchOLEObj();
3435 return;
3436
3437 case SelectionType::Frame:
3438 ResetMouseButtonDownFlags();
3439 if (!comphelper::LibreOfficeKit::isActive())
3440 {
3441 GetView().GetViewFrame().GetBindings().Execute(
3442 FN_FORMAT_FRAME_DLG, nullptr,
3443 SfxCallMode::RECORD|SfxCallMode::SLOT);
3444 }
3445 return;
3446
3447 case SelectionType::DrawObject:
3448 ResetMouseButtonDownFlags();
3449 EnterDrawTextMode(aDocPos);
3450 if ( auto pSwDrawTextShell = dynamic_cast< SwDrawTextShell *>( m_rView.GetCurShell() ) )
3451 pSwDrawTextShell->Init();
3452 return;
3453
3454 default: break;
3455 }
3456 }
3457
3458 // if the cursor position was corrected or if a Fly
3459 // was selected in ReadOnlyMode, no word selection, except when tiled rendering.
3460 if ((!g_bValidCursorPos || rSh.IsFrameSelected()) && !comphelper::LibreOfficeKit::isActive())
3461 return;
3462
3463 SwField *pField;
3464 bool bFootnote = false;
3465
3466 if( !bIsDocReadOnly &&
3467 (nullptr != (pField = rSh.GetCurField(true)) ||
3468 ( bFootnote = rSh.GetCurFootnote() ) ) )
3469 {
3470 ResetMouseButtonDownFlags();
3471 if( bFootnote )
3472 GetView().GetViewFrame().GetBindings().Execute( FN_EDIT_FOOTNOTE );
3473 else
3474 {
3475 SwFieldTypesEnum nTypeId = pField->GetTypeId();
3476 SfxViewFrame& rVFrame = GetView().GetViewFrame();
3477 switch( nTypeId )
3478 {
3479 case SwFieldTypesEnum::Postit:
3480 case SwFieldTypesEnum::Script:
3481 {
3482 // if it's a Readonly region, status has to be enabled
3483 sal_uInt16 nSlot = SwFieldTypesEnum::Postit == nTypeId ? FN_POSTIT : FN_JAVAEDIT;
3484 SfxBoolItem aItem(nSlot, true);
3485 rVFrame.GetBindings().SetState(aItem);
3486 rVFrame.GetBindings().Execute(nSlot);
3487 break;
3488 }
3489 case SwFieldTypesEnum::Authority :
3490 rVFrame.GetBindings().Execute(FN_EDIT_AUTH_ENTRY_DLG);
3491 break;
3492 case SwFieldTypesEnum::Input:
3493 case SwFieldTypesEnum::Dropdown:
3494 case SwFieldTypesEnum::SetInput:
3495 rVFrame.GetBindings().Execute(FN_UPDATE_INPUTFIELDS);
3496 break;
3497 default:
3498 rVFrame.GetBindings().Execute(FN_EDIT_FIELD);
3499 }
3500 }
3501 return;
3502 }
3503 // in extended mode double and triple
3504 // click has no effect.
3505 if ( rSh.IsExtMode() || rSh.IsBlockMode() )
3506 return;
3507
3508 // select word, AdditionalMode if applicable
3509 if (KEY_MOD1 == aMEvt.GetModifier() && !rSh.IsAddMode())
3510 {
3511 rSh.EnterAddMode();
3512 rSh.SelWrd( &aDocPos );
3513 rSh.LeaveAddMode();
3514 }
3515 else
3516 {
3517 if (!rSh.SelWrd(&aDocPos) && comphelper::LibreOfficeKit::isActive())
3518 // Double click did not select any word: try to
3519 // select the current cell in case we are in a
3520 // table.
3521 rSh.SelTableBox();
3522 }
3523
3524 SwContentAtPos aContentAtPos(IsAttrAtPos::FormControl);
3525 if( rSh.GetContentAtPos( aDocPos, aContentAtPos ) &&
3526 aContentAtPos.aFnd.pFieldmark != nullptr)
3527 {
3528 IFieldmark *pFieldBM = const_cast< IFieldmark* > ( aContentAtPos.aFnd.pFieldmark );
3529 if ( pFieldBM->GetFieldname( ) == ODF_FORMDROPDOWN || pFieldBM->GetFieldname( ) == ODF_FORMDATE )
3530 {
3531 ResetMouseButtonDownFlags();
3532 rSh.getIDocumentMarkAccess()->ClearFieldActivation();
3533 GetView().GetViewFrame().GetBindings().Execute(SID_FM_CTL_PROPERTIES);
3534 return;
3535 }
3536 }
3537
3538 // tdf#143158 - handle alphabetical index entries
3539 SwContentAtPos aToxContentAtPos(IsAttrAtPos::ToxMark);
3540 if (rSh.GetContentAtPos(aDocPos, aToxContentAtPos))
3541 {
3542 const OUString sToxText = aToxContentAtPos.sStr;
3543 if (!sToxText.isEmpty() && aToxContentAtPos.pFndTextAttr)
3544 {
3545 const SwTOXType* pTType
3546 = aToxContentAtPos.pFndTextAttr->GetTOXMark().GetTOXType();
3547 if (pTType && pTType->GetType() == TOXTypes::TOX_INDEX)
3548 {
3549 ResetMouseButtonDownFlags();
3550 GetView().GetViewFrame().GetBindings().Execute(
3551 FN_EDIT_IDX_ENTRY_DLG);
3552 return;
3553 }
3554 }
3555 }
3556
3557 g_bHoldSelection = true;
3558 return;
3559 }
3560 case 3:
3561 case 4:
3562 {
3563 g_bFrameDrag = false;
3564 // in extended mode double and triple
3565 // click has no effect.
3566 if ( rSh.IsExtMode() )
3567 return;
3568
3569 // if the cursor position was corrected or if a Fly
3570 // was selected in ReadOnlyMode, no word selection.
3571 if ( !g_bValidCursorPos || rSh.IsFrameSelected() )
3572 return;
3573
3574 // select line, AdditionalMode if applicable
3575 const bool bMod = KEY_MOD1 == aMEvt.GetModifier() && !rSh.IsAddMode();
3576
3577 if ( bMod )
3578 rSh.EnterAddMode();
3579
3580 // Enhanced selection
3581 if ( 3 == nNumberOfClicks )
3582 rSh.SelSentence( &aDocPos );
3583 else
3584 rSh.SelPara( &aDocPos );
3585
3586 if ( bMod )
3587 rSh.LeaveAddMode();
3588
3589 g_bHoldSelection = true;
3590 return;
3591 }
3592
3593 default:
3594 return;
3595 }
3596
3597 [[fallthrough]];
3598 }
3599 case MOUSE_LEFT + KEY_SHIFT:
3600 case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
3601 {
3602 bool bLockView = m_bWasShdwCursor;
3603
3604 switch (aMEvt.GetModifier())
3605 {
3606 case KEY_MOD1 + KEY_SHIFT:
3607 {
3608 if ( !m_bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
3609 {
3610 m_rView.NoRotate();
3611 rSh.HideCursor();
3612 if ( rSh.IsSelFrameMode() )
3613 rSh.SelectObj(aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP);
3614 else
3615 { if ( rSh.SelectObj( aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP ) )
3616 {
3617 rSh.EnterSelFrameMode( &aDocPos );
3618 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3619 SwEditWin::s_nDDStartPosX = aDocPos.X();
3620 g_bFrameDrag = true;
3621 return;
3622 }
3623 }
3624 }
3625 else if( rSh.IsSelFrameMode() &&
3626 rSh.GetDrawView()->PickHandle( aDocPos ))
3627 {
3628 g_bFrameDrag = true;
3629 g_bNoInterrupt = false;
3630 return;
3631 }
3632 }
3633 break;
3634 case KEY_MOD1:
3635 if ( !bExecDrawTextLink )
3636 {
3637 if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())
3638 {
3639 // ctrl+left-click on outline node frame
3640 SwContentAtPos aContentAtPos(IsAttrAtPos::Outline);
3641 if(rSh.GetContentAtPos(aDocPos, aContentAtPos))
3642 {
3643 SwOutlineNodes::size_type nPos;
3644 if (rSh.GetNodes().GetOutLineNds().Seek_Entry(aContentAtPos.aFnd.pNode, &nPos))
3645 {
3646 ToggleOutlineContentVisibility(nPos, false);
3647 return;
3648 }
3649 }
3650 }
3651 if ( !m_bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) && !lcl_urlOverBackground( rSh, aDocPos ) )
3652 {
3653 m_rView.NoRotate();
3654 rSh.HideCursor();
3655 if ( rSh.IsSelFrameMode() )
3656 rSh.SelectObj(aDocPos, SW_ENTER_GROUP);
3657 else
3658 { if ( rSh.SelectObj( aDocPos, SW_ENTER_GROUP ) )
3659 {
3660 rSh.EnterSelFrameMode( &aDocPos );
3661 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3662 SwEditWin::s_nDDStartPosX = aDocPos.X();
3663 g_bFrameDrag = true;
3664 return;
3665 }
3666 }
3667 }
3668 else if( rSh.IsSelFrameMode() &&
3669 rSh.GetDrawView()->PickHandle( aDocPos ))
3670 {
3671 g_bFrameDrag = true;
3672 g_bNoInterrupt = false;
3673 return;
3674 }
3675 else
3676 {
3677 if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
3678 {
3679 rSh.PushMode();
3680 g_bModePushed = true;
3681
3682 bool bUnLockView = !rSh.IsViewLocked();
3683 rSh.LockView( true );
3684 rSh.EnterAddMode();
3685 if( bUnLockView )
3686 rSh.LockView( false );
3687 }
3688 bCallBase = false;
3689 }
3690 }
3691 break;
3692 case KEY_MOD2:
3693 {
3694 if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
3695 {
3696 rSh.PushMode();
3697 g_bModePushed = true;
3698 bool bUnLockView = !rSh.IsViewLocked();
3699 rSh.LockView( true );
3700 rSh.EnterBlockMode();
3701 if( bUnLockView )
3702 rSh.LockView( false );
3703 }
3704 bCallBase = false;
3705 }
3706 break;
3707 case KEY_SHIFT:
3708 {
3709 if (nNumberOfClicks == 2)
3710 {
3711 // Left mouse button, shift, double-click: see if we have a graphic and
3712 // dispatch its dialog in this case.
3713 if (rSh.GetSelectionType() == SelectionType::Graphic)
3714 {
3715 GetView().GetViewFrame().GetBindings().Execute(
3716 FN_FORMAT_GRAFIC_DLG, nullptr,
3717 SfxCallMode::RECORD | SfxCallMode::SLOT);
3718 return;
3719 }
3720 }
3721
3722 if ( !m_bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
3723 {
3724 m_rView.NoRotate();
3725 rSh.HideCursor();
3726 if ( rSh.IsSelFrameMode() )
3727 {
3728 rSh.SelectObj(aDocPos, SW_ADD_SELECT);
3729
3730 const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
3731 if (rMarkList.GetMark(0) == nullptr)
3732 {
3733 rSh.LeaveSelFrameMode();
3734 m_rView.AttrChangedNotify(nullptr);
3735 g_bFrameDrag = false;
3736 }
3737 }
3738 else
3739 { if ( rSh.SelectObj( aDocPos ) )
3740 {
3741 rSh.EnterSelFrameMode( &aDocPos );
3742 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3743 SwEditWin::s_nDDStartPosX = aDocPos.X();
3744 g_bFrameDrag = true;
3745 return;
3746 }
3747 }
3748 }
3749 else
3750 {
3751 bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
3752 if (bShould)
3753 {
3754 // Left mouse button, shift, non-double-click, not a draw object and
3755 // have an object to select: select it.
3756 rSh.HideCursor();
3757 bool bSelObj = rSh.SelectObj(aDocPos);
3758 if (bSelObj)
3759 {
3760 rSh.EnterSelFrameMode(&aDocPos);
3761 }
3762 return;
3763 }
3764
3765 if ( rSh.IsSelFrameMode() &&
3766 rSh.IsInsideSelectedObj( aDocPos ) )
3767 {
3768 rSh.EnterSelFrameMode( &aDocPos );
3769 SwEditWin::s_nDDStartPosY = aDocPos.Y();
3770 SwEditWin::s_nDDStartPosX = aDocPos.X();
3771 g_bFrameDrag = true;
3772 return;
3773 }
3774 if ( rSh.IsSelFrameMode() )
3775 {
3776 rSh.UnSelectFrame();
3777 rSh.LeaveSelFrameMode();
3778 m_rView.AttrChangedNotify(nullptr);
3779 g_bFrameDrag = false;
3780 }
3781 if ( !rSh.IsExtMode() )
3782 {
3783 // don't start a selection when an
3784 // URL field or a graphic is clicked
3785 bool bSttSelect = rSh.HasSelection() ||
3786 PointerStyle::RefHand != GetPointer();
3787
3788 if( !bSttSelect )
3789 {
3790 bSttSelect = true;
3791 if( bExecHyperlinks )
3792 {
3793 SwContentAtPos aContentAtPos(
3794 IsAttrAtPos::Ftn |
3795 IsAttrAtPos::InetAttr );
3796
3797 if( rSh.GetContentAtPos( aDocPos, aContentAtPos ) )
3798 {
3799 if( !rSh.IsViewLocked() &&
3800 !rSh.IsReadOnlyAvailable() &&
3801 aContentAtPos.IsInProtectSect() )
3802 bLockView = true;
3803
3804 bSttSelect = false;
3805 }
3806 else if( rSh.IsURLGrfAtPos( aDocPos ))
3807 bSttSelect = false;
3808 }
3809 }
3810
3811 if( bSttSelect )
3812 rSh.SttSelect();
3813 }
3814 }
3815 bCallBase = false;
3816 break;
3817 }
3818 default:
3819 if( !rSh.IsViewLocked() )
3820 {
3821 SwContentAtPos aContentAtPos( IsAttrAtPos::ClickField |
3822 IsAttrAtPos::InetAttr );
3823 if( rSh.GetContentAtPos( aDocPos, aContentAtPos ) &&
3824 !rSh.IsReadOnlyAvailable() &&
3825 aContentAtPos.IsInProtectSect() )
3826 bLockView = true;
3827 }
3828 }
3829
3830 if ( rSh.IsGCAttr() )
3831 {
3832 rSh.GCAttr();
3833 rSh.ClearGCAttr();
3834 }
3835
3836 SwContentAtPos aFieldAtPos(IsAttrAtPos::Field);
3837 bool bEditableFieldClicked = false;
3838
3839 // Are we clicking on a field?
3840 if (rSh.GetContentAtPos(aDocPos, aFieldAtPos))
3841 {
3842 bool bEditableField = (aFieldAtPos.pFndTextAttr != nullptr
3843 && aFieldAtPos.pFndTextAttr->Which() == RES_TXTATR_INPUTFIELD);
3844
3845 if (!bEditableField)
3846 {
3847 rSh.CallSetCursor(&aDocPos, bOnlyText);
3848 // Unfortunately the cursor may be on field
3849 // position or on position after field depending on which
3850 // half of the field was clicked on.
3851 SwTextAttr const*const pTextField(aFieldAtPos.pFndTextAttr);
3852 if (pTextField &&
3853 rSh.GetCurrentShellCursor().GetPoint()->GetContentIndex() != pTextField->GetStart())
3854 {
3855 assert(rSh.GetCurrentShellCursor().GetPoint()->GetContentIndex() == (pTextField->GetStart() + 1));
3856 rSh.Left( SwCursorSkipMode::Chars, false, 1, false );
3857 }
3858 // don't go into the !bOverSelect block below - it moves
3859 // the cursor
3860 break;
3861 }
3862 else
3863 {
3864 bEditableFieldClicked = true;
3865 }
3866 }
3867
3868 bool bOverSelect = rSh.TestCurrPam( aDocPos );
3869 bool bOverURLGrf = false;
3870 if( !bOverSelect )
3871 bOverURLGrf = bOverSelect = nullptr != rSh.IsURLGrfAtPos( aDocPos );
3872
3873 if ( !bOverSelect || rSh.IsInSelect() )
3874 {
3875 MoveCursor( rSh, aDocPos, bOnlyText, bLockView );
3876 bCallBase = false;
3877 }
3878 if (!bOverURLGrf && !bExecDrawTextLink && !bOnlyText)
3879 {
3880 const SelectionType nSelType = rSh.GetSelectionType();
3881 // Check in general, if an object is selectable at given position.
3882 // Thus, also text fly frames in background become selectable via Ctrl-Click.
3883 if ( ( nSelType & SelectionType::Ole ||
3884 nSelType & SelectionType::Graphic ||
3885 rSh.IsObjSelectable( aDocPos ) ) && !lcl_urlOverBackground( rSh, aDocPos ) )
3886 {
3887 SwMvContext aMvContext( &rSh );
3888 rSh.EnterSelFrameMode();
3889 bCallBase = false;
3890 }
3891 }
3892 if ( !bOverSelect && bEditableFieldClicked && (!pCursorField ||
3893 pCursorField != aFieldAtPos.pFndTextAttr->GetFormatField().GetField()))
3894 {
3895 // select content of Input Field, but exclude CH_TXT_ATR_INPUTFIELDSTART
3896 // and CH_TXT_ATR_INPUTFIELDEND
3897 rSh.SttSelect();
3898 rSh.SelectTextModel( aFieldAtPos.pFndTextAttr->GetStart() + 1,
3899 *(aFieldAtPos.pFndTextAttr->End()) - 1 );
3900 }
3901 // don't reset here any longer so that, in case through MouseMove
3902 // with pressed Ctrl key a multiple-selection should happen,
3903 // the previous selection is not released in Drag.
3904 break;
3905 }
3906 }
3907 }
3908 else if (MOUSE_RIGHT == aMEvt.GetButtons())
3909 {
3910 if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton()
3911 && aMEvt.GetModifier() == KEY_MOD1)
3912 {
3913 // ctrl+right-click on outline node frame
3914 SwContentAtPos aContentAtPos(IsAttrAtPos::Outline);
3915 if(rSh.GetContentAtPos(aDocPos, aContentAtPos))
3916 {
3917 SwOutlineNodes::size_type nPos;
3918 if (rSh.GetNodes().GetOutLineNds().Seek_Entry(aContentAtPos.aFnd.pNode, &nPos))
3919 {
3920 ToggleOutlineContentVisibility(nPos, !rSh.GetViewOptions()->IsTreatSubOutlineLevelsAsContent());
3921 return;
3922 }
3923 }
3924 }
3925 else if (!aMEvt.GetModifier() && static_cast<sal_uInt8>(aMEvt.GetClicks() % 4) == 1
3926 && !rSh.TestCurrPam(aDocPos))
3927 {
3928 SwContentAtPos aFieldAtPos(IsAttrAtPos::Field);
3929
3930 // Are we clicking on a field?
3931 if (g_bValidCursorPos
3932 && rSh.GetContentAtPos(aDocPos, aFieldAtPos)
3933 && aFieldAtPos.pFndTextAttr != nullptr
3934 && aFieldAtPos.pFndTextAttr->Which() == RES_TXTATR_INPUTFIELD
3935 && (!pCursorField || pCursorField != aFieldAtPos.pFndTextAttr->GetFormatField().GetField()))
3936 {
3937 // Move the cursor
3938 MoveCursor( rSh, aDocPos, rSh.IsObjSelectable( aDocPos ), m_bWasShdwCursor );
3939 bCallBase = false;
3940
3941 // select content of Input Field, but exclude CH_TXT_ATR_INPUTFIELDSTART
3942 // and CH_TXT_ATR_INPUTFIELDEND
3943 rSh.SttSelect();
3944 rSh.SelectTextModel( aFieldAtPos.pFndTextAttr->GetStart() + 1,
3945 *(aFieldAtPos.pFndTextAttr->End()) - 1 );
3946 }
3947 }
3948 }
3949
3950 if (bCallBase)
3951 Window::MouseButtonDown(aMEvt);
3952}
3953
3954bool SwEditWin::changeMousePointer(Point const & rDocPoint)
3955{
3956 SwWrtShell & rShell = m_rView.GetWrtShell();
3957
3958 SwTab nMouseTabCol;
3959 if ( SwTab::COL_NONE != (nMouseTabCol = rShell.WhichMouseTabCol( rDocPoint ) ) &&
3960 !rShell.IsObjSelectable( rDocPoint ) )
3961 {
3962 PointerStyle nPointer = PointerStyle::Null;
3963 bool bChkTableSel = false;
3964
3965 switch ( nMouseTabCol )
3966 {
3967 case SwTab::COL_VERT :
3968 case SwTab::ROW_HORI :
3969 nPointer = PointerStyle::VSizeBar;
3970 bChkTableSel = true;
3971 break;
3972 case SwTab::ROW_VERT :
3973 case SwTab::COL_HORI :
3974 nPointer = PointerStyle::HSizeBar;
3975 bChkTableSel = true;
3976 break;
3977 // Enhanced table selection
3978 case SwTab::SEL_HORI :
3979 nPointer = PointerStyle::TabSelectSE;
3980 break;
3981 case SwTab::SEL_HORI_RTL :
3982 case SwTab::SEL_VERT :
3983 nPointer = PointerStyle::TabSelectSW;
3984 break;
3985 case SwTab::COLSEL_HORI :
3986 case SwTab::ROWSEL_VERT :
3987 nPointer = PointerStyle::TabSelectS;
3988 break;
3989 case SwTab::ROWSEL_HORI :
3990 nPointer = PointerStyle::TabSelectE;
3991 break;
3992 case SwTab::ROWSEL_HORI_RTL :
3993 case SwTab::COLSEL_VERT :
3994 nPointer = PointerStyle::TabSelectW;
3995 break;
3996 default: break; // prevent compiler warning
3997 }
3998
3999 if ( PointerStyle::Null != nPointer &&
4000 // i#35543 - Enhanced table selection is explicitly allowed in table mode
4001 ( !bChkTableSel || !rShell.IsTableMode() ) &&
4002 !comphelper::LibreOfficeKit::isActive() )
4003 {
4004 SetPointer( nPointer );
4005 }
4006
4007 return true;
4008 }
4009 else if (rShell.IsNumLabel(rDocPoint, RULER_MOUSE_MARGINWIDTH))
4010 {
4011 // i#42921 - consider vertical mode
4012 SwTextNode* pNodeAtPos = rShell.GetNumRuleNodeAtPos( rDocPoint );
4013 const PointerStyle nPointer =
4014 SwFEShell::IsVerticalModeAtNdAndPos( *pNodeAtPos, rDocPoint )
4015 ? PointerStyle::VSizeBar
4016 : PointerStyle::HSizeBar;
4017 SetPointer( nPointer );
4018
4019 return true;
4020 }
4021 return false;
4022}
4023
4024void SwEditWin::MouseMove(const MouseEvent& _rMEvt)
4025{
4026 MouseEvent rMEvt(_rMEvt);
4027
4028 if (comphelper::LibreOfficeKit::isActive())
4029 {
4030 if (vcl::Window* pWindow = m_rView.GetPostItMgr()->IsHitSidebarWindow(rMEvt.GetPosPixel()))
4031 {
4032 pWindow->MouseMove(rMEvt);
4033 return;
4034 }
4035 }
4036
4037 //ignore key modifiers for format paintbrush
4038 {
4039 bool bExecFormatPaintbrush = m_pApplyTempl && m_pApplyTempl->m_pFormatClipboard
4040 && m_pApplyTempl->m_pFormatClipboard->HasContent();
4041 if( bExecFormatPaintbrush )
4042 rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(),
4043 _rMEvt.GetMode(), _rMEvt.GetButtons() );
4044 }
4045
4046 // as long as an action is running the MouseMove should be disconnected
4047 // otherwise bug 40102 occurs
4048 SwWrtShell &rSh = m_rView.GetWrtShell();
4049 if( rSh.ActionPend() )
4050 return ;
4051
4052 if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())
4053 {
4054 // add/remove outline content hide button
4055 const SwNodes& rNds = rSh.GetDoc()->GetNodes();
4056 SwOutlineNodes::size_type nPos;
4057 SwContentAtPos aSwContentAtPos(IsAttrAtPos::Outline);
4058 if (rSh.GetContentAtPos(PixelToLogic(rMEvt.GetPosPixel()), aSwContentAtPos))
4059 {
4060 // mouse pointer is on an outline paragraph node
4061 if(aSwContentAtPos.aFnd.pNode && aSwContentAtPos.aFnd.pNode->IsTextNode())
4062 {
4063 // Get the outline paragraph frame and compare it to the saved outline frame. If they
4064 // are not the same, remove the fold button from the saved outline frame, if not
4065 // already removed, and then add a fold button to the mouse over outline frame if
4066 // the content is not folded.
4067 SwContentFrame* pContentFrame =
4068 aSwContentAtPos.aFnd.pNode->GetTextNode()->getLayoutFrame(rSh.GetLayout());
4069 if (pContentFrame != m_pSavedOutlineFrame)
4070 {
4071 if (m_pSavedOutlineFrame)
4072 {
4073 if (m_pSavedOutlineFrame->isFrameAreaDefinitionValid())
4074 {
4075 SwTextNode* pTextNode = m_pSavedOutlineFrame->GetTextNodeFirst();
4076 if (pTextNode && rNds.GetOutLineNds().Seek_Entry(pTextNode, &nPos) &&
4077 rSh.GetAttrOutlineContentVisible(nPos))
4078 {
4079 GetFrameControlsManager().RemoveControlsByType(
4080 FrameControlType::Outline, m_pSavedOutlineFrame);
4081 }
4082 }
4083 }
4084 m_pSavedOutlineFrame = static_cast<SwTextFrame*>(pContentFrame);
4085 }
4086 // show fold button if outline content is visible
4087 if (rNds.GetOutLineNds().Seek_Entry(aSwContentAtPos.aFnd.pNode->GetTextNode(), &nPos) &&
4088 rSh.GetAttrOutlineContentVisible(nPos))
4089 GetFrameControlsManager().SetOutlineContentVisibilityButton(pContentFrame);
4090 }
4091 }
4092 else if (m_pSavedOutlineFrame)
4093 {
4094 // The saved frame may not still be in the document, e.g., when an outline paragraph
4095 // is deleted. This causes the call to GetTextNodeFirst to behave badly. Use
4096 // isFrameAreaDefinitionValid to check if the frame is still in the document.
4097 if (m_pSavedOutlineFrame->isFrameAreaDefinitionValid())
4098 {
4099 // current pointer pos is not over an outline frame
4100 // previous pointer pos was over an outline frame
4101 // remove outline content visibility button if showing
4102 SwTextNode* pTextNode = m_pSavedOutlineFrame->GetTextNodeFirst();
4103 if (pTextNode && rNds.GetOutLineNds().Seek_Entry(pTextNode, &nPos) &&
4104 rSh.GetAttrOutlineContentVisible(nPos))
4105 {
4106 GetFrameControlsManager().RemoveControlsByType(
4107 FrameControlType::Outline, m_pSavedOutlineFrame);
4108 }
4109 }
4110 m_pSavedOutlineFrame = nullptr;
4111 }
4112 }
4113
4114 if( m_pShadCursor && 0 != (rMEvt.GetModifier() + rMEvt.GetButtons() ) )
4115 {
4116 m_pShadCursor.reset();
4117 }
4118
4119 bool bIsDocReadOnly = m_rView.GetDocShell()->IsReadOnly();
4120
4121 CurrShell aCurr( &rSh );
4122
4123 //aPixPt == Point in Pixel, relative to ChildWin
4124 //aDocPt == Point in Twips, document coordinates
4125 const Point aPixPt( rMEvt.GetPosPixel() );
4126 const Point aDocPt( PixelToLogic( aPixPt ) );
4127
4128 if ( IsChainMode() )
4129 {
4130 UpdatePointer( aDocPt, rMEvt.GetModifier() );
4131 return;
4132 }
4133
4134 SdrView *pSdrView = rSh.GetDrawView();
4135
4136 const SwCallMouseEvent aLastCallEvent( m_aSaveCallEvent );
4137 m_aSaveCallEvent.Clear();
4138
4139 if ( !bIsDocReadOnly && pSdrView && pSdrView->MouseMove(rMEvt,GetOutDev()) )
4140 {
4141 SetPointer( PointerStyle::Text );
4142 return; // evaluate SdrView's event
4143 }
4144
4145 const Point aOldPt( rSh.VisArea().Pos() );
4146 const bool bInsWin = rSh.VisArea().Contains( aDocPt ) || comphelper::LibreOfficeKit::isActive();
4147
4148 if (rSh.GetViewOptions()->IsShowOutlineContentVisibilityButton())
4149 {
4150 if (m_pSavedOutlineFrame && !bInsWin)
4151 {
4152 // the mouse pointer has left the building (edit window)
4153 // remove the outline content visibility button if showing
4154 if (m_pSavedOutlineFrame->isFrameAreaDefinitionValid())
4155 {
4156 const SwNodes& rNds = rSh.GetDoc()->GetNodes();
4157 SwOutlineNodes::size_type nPos;
4158 SwTextNode* pTextNode = m_pSavedOutlineFrame->GetTextNodeFirst();
4159 if (pTextNode && rNds.GetOutLineNds().Seek_Entry(pTextNode, &nPos) &&
4160 rSh.GetAttrOutlineContentVisible(nPos))
4161 {
4162 GetFrameControlsManager().RemoveControlsByType(FrameControlType::Outline,
4163 m_pSavedOutlineFrame);
4164 }
4165 }
4166 m_pSavedOutlineFrame = nullptr;
4167 }
4168 }
4169
4170 if( m_pShadCursor && !bInsWin )
4171 {
4172 m_pShadCursor.reset();
4173 }
4174
4175 if( bInsWin && m_xRowColumnSelectionStart )
4176 {
4177 EnterArea();
4178 Point aPos( aDocPt );
4179 if( rSh.SelectTableRowCol( *m_xRowColumnSelectionStart, &aPos, m_bIsRowDrag ))
4180 return;
4181 }
4182
4183 // position is necessary for OS/2 because obviously after a MB-Down
4184 // a MB-Move is called immediately.
4185 if( g_bDDTimerStarted )
4186 {
4187 Point aDD( SwEditWin::s_nDDStartPosX, SwEditWin::s_nDDStartPosY );
4188 aDD = LogicToPixel( aDD );
4189 tools::Rectangle aRect( aDD.X()-3, aDD.Y()-3, aDD.X()+3, aDD.Y()+3 );
4190 if ( !aRect.Contains( aPixPt ) )
4191 StopDDTimer( &rSh, aDocPt );
4192 }
4193
4194 if(m_rView.GetDrawFuncPtr())
4195 {
4196 if( m_bInsDraw )
4197 {
4198 m_rView.GetDrawFuncPtr()->MouseMove( rMEvt );
4199 if ( !bInsWin )
4200 {
4201 Point aTmp( aDocPt );
4202 aTmp += rSh.VisArea().Pos() - aOldPt;
4203 LeaveArea( aTmp );
4204 }
4205 else
4206 EnterArea();
4207 return;
4208 }
4209 else if(!rSh.IsFrameSelected() && !rSh.IsObjSelected())
4210 {
4211 SfxBindings &rBnd = rSh.GetView().GetViewFrame().GetBindings();
4212 Point aRelPos = rSh.GetRelativePagePosition(aDocPt);
4213 if(aRelPos.X() >= 0)
4214 {
4215 FieldUnit eMetric = ::GetDfltMetric(dynamic_cast<SwWebView*>( &GetView()) != nullptr );
4216 SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, static_cast< sal_uInt16 >(eMetric)));
4217 const SfxPointItem aTmp1( SID_ATTR_POSITION, aRelPos );
4218 rBnd.SetState( aTmp1 );
4219 }
4220 else
4221 {
4222 rBnd.Invalidate(SID_ATTR_POSITION);
4223 }
4224 rBnd.Invalidate(SID_ATTR_SIZE);
4225 const SvxStatusItem aCell( SID_TABLE_CELL, OUString(), StatusCategory::NONE );
4226 rBnd.SetState( aCell );
4227 }
4228 }
4229
4230 // determine if we only change the mouse pointer and return
4231 if (!bIsDocReadOnly && bInsWin && !m_pApplyTempl && !rSh.IsInSelect() && changeMousePointer(aDocPt))
4232 {
4233 return;
4234 }
4235
4236 bool bDelShadCursor = true;
4237
4238 switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
4239 {
4240 case MOUSE_LEFT:
4241 if( m_pAnchorMarker )
4242 {
4243 // Now we need to refresh the SdrHdl pointer of m_pAnchorMarker.
4244 // This looks a little bit tricky, but it solves the following
4245 // problem: the m_pAnchorMarker contains a pointer to an SdrHdl,
4246 // if the FindAnchorPos-call cause a scrolling of the visible
4247 // area, it's possible that the SdrHdl will be destroyed and a
4248 // new one will initialized at the original position(GetHdlPos).
4249 // So the m_pAnchorMarker has to find the right SdrHdl, if it's
4250 // the old one, it will find it with position aOld, if this one
4251 // is destroyed, it will find a new one at position GetHdlPos().
4252
4253 const Point aOld = m_pAnchorMarker->GetPosForHitTest( *(rSh.GetOut()) );
4254 Point aNew = rSh.FindAnchorPos( aDocPt );
4255 SdrHdl* pHdl;
4256 if( pSdrView && (nullptr!=( pHdl = pSdrView->PickHandle( aOld ) )||
4257 nullptr !=(pHdl = pSdrView->PickHandle( m_pAnchorMarker->GetHdlPos()) ) ) &&
4258 ( pHdl->GetKind() == SdrHdlKind::Anchor ||
4259 pHdl->GetKind() == SdrHdlKind::Anchor_TR ) )
4260 {
4261 m_pAnchorMarker->ChgHdl( pHdl );
4262 if( aNew.X() || aNew.Y() )
4263 {
4264 m_pAnchorMarker->SetPos( aNew );
4265 m_pAnchorMarker->SetLastPos( aDocPt );
4266 }
4267 }
4268 else
4269 {
4270 m_pAnchorMarker.reset();
4271 }
4272 }
4273 if ( m_bInsDraw )
4274 {
4275 if ( !m_bMBPressed )
4276 break;
4277 if ( m_bIsInMove || IsMinMove( m_aStartPos, aPixPt ) )
4278 {
4279 if ( !bInsWin )
4280 LeaveArea( aDocPt );
4281 else
4282 EnterArea();
4283 if ( m_rView.GetDrawFuncPtr() )
4284 {
4285 pSdrView->SetOrtho(false);
4286 m_rView.GetDrawFuncPtr()->MouseMove( rMEvt );
4287 }
4288 m_bIsInMove = true;
4289 }
4290 return;
4291 }
4292
4293 {
4294 SwWordCountWrapper *pWrdCnt = static_cast<SwWordCountWrapper*>(GetView().GetViewFrame().GetChildWindow(SwWordCountWrapper::GetChildWindowId()));
4295 if (pWrdCnt)
4296 pWrdCnt->UpdateCounts();
4297 }
4298 [[fallthrough]];
4299
4300 case MOUSE_LEFT + KEY_SHIFT:
4301 case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
4302 if ( !m_bMBPressed )
4303 break;
4304 [[fallthrough]];
4305 case MOUSE_LEFT + KEY_MOD1:
4306 if ( g_bFrameDrag && rSh.IsSelFrameMode() )
4307 {
4308 if( !m_bMBPressed )
4309 break;
4310
4311 if ( m_bIsInMove || IsMinMove( m_aStartPos, aPixPt ) )
4312 {
4313 // event processing for resizing
4314 if (pSdrView && pSdrView->AreObjectsMarked())
4315 {
4316 const Point aSttPt( PixelToLogic( m_aStartPos ) );
4317
4318 // can we start?
4319 if( SdrHdlKind::User == g_eSdrMoveHdl )
4320 {
4321 SdrHdl* pHdl = pSdrView->PickHandle( aSttPt );
4322 g_eSdrMoveHdl = pHdl ? pHdl->GetKind() : SdrHdlKind::Move;
4323 }
4324
4325 const SwFrameFormat *const pFlyFormat(rSh.GetFlyFrameFormat());
4326 const SvxMacro* pMacro = nullptr;
4327
4328 SvMacroItemId nEvent = SdrHdlKind::Move == g_eSdrMoveHdl
4329 ? SvMacroItemId::SwFrmMove
4330 : SvMacroItemId::SwFrmResize;
4331
4332 if (nullptr != pFlyFormat)
4333 pMacro = pFlyFormat->GetMacro().GetMacroTable().Get(nEvent);
4334 if (nullptr != pMacro &&
4335 // or notify only e.g. every 20 Twip?
4336 m_aRszMvHdlPt != aDocPt )
4337 {
4338 m_aRszMvHdlPt = aDocPt;
4339 sal_uInt32 nPos = 0;
4340 SbxArrayRef xArgs = new SbxArray;
4341 SbxVariableRef xVar = new SbxVariable;
4342 xVar->PutString( pFlyFormat->GetName() );
4343 xArgs->Put(xVar.get(), ++nPos);
4344
4345 if( SvMacroItemId::SwFrmResize == nEvent )
4346 {
4347 xVar = new SbxVariable;
4348 xVar->PutUShort( static_cast< sal_uInt16 >(g_eSdrMoveHdl) );
4349 xArgs->Put(xVar.get(), ++nPos);
4350 }
4351
4352 xVar = new SbxVariable;
4353 xVar->PutLong( aDocPt.X() - aSttPt.X() );
4354 xArgs->Put(xVar.get(), ++nPos);
4355 xVar = new SbxVariable;
4356 xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
4357 xArgs->Put(xVar.get(), ++nPos);
4358
4359 OUString sRet;
4360
4361 ReleaseMouse();
4362
4363 rSh.ExecMacro( *pMacro, &sRet, xArgs.get() );
4364
4365 CaptureMouse();
4366
4367 if( !sRet.isEmpty() && sRet.toInt32()!=0 )
4368 return ;
4369 }
4370 }
4371 // event processing for resizing
4372
4373 if( bIsDocReadOnly )
4374 break;
4375
4376 bool bResizeKeepRatio = rSh.GetSelectionType() & SelectionType::Graphic ||
4377 rSh.GetSelectionType() & SelectionType::Media ||
4378 rSh.GetSelectionType() & SelectionType::Ole;
4379 bool bisResize = g_eSdrMoveHdl != SdrHdlKind::Move;
4380
4381 if (pSdrView)
4382 {
4383 // Resize proportionally when media is selected and the user drags on a corner
4384 const Point aSttPt(PixelToLogic(m_aStartPos));
4385 SdrHdl* pHdl = pSdrView->PickHandle(aSttPt);
4386 if (pHdl)
4387 bResizeKeepRatio = bResizeKeepRatio && pHdl->IsCornerHdl();
4388
4389 if (pSdrView->GetDragMode() == SdrDragMode::Crop)
4390 bisResize = false;
4391 if (rMEvt.IsShift())
4392 {
4393 pSdrView->SetAngleSnapEnabled(!bResizeKeepRatio);
4394 if (bisResize)
4395 pSdrView->SetOrtho(!bResizeKeepRatio);
4396 else
4397 pSdrView->SetOrtho(true);
4398 }
4399 else
4400 {
4401 pSdrView->SetAngleSnapEnabled(bResizeKeepRatio);
4402 if (bisResize)
4403 pSdrView->SetOrtho(bResizeKeepRatio);
4404 else
4405 pSdrView->SetOrtho(false);
4406 }
4407 }
4408
4409 rSh.Drag( &aDocPt, rMEvt.IsShift() );
4410 m_bIsInMove = true;
4411 }
4412 else if( bIsDocReadOnly )
4413 break;
4414
4415 if ( !bInsWin )
4416 {
4417 Point aTmp( aDocPt );
4418 aTmp += rSh.VisArea().Pos() - aOldPt;
4419 LeaveArea( aTmp );
4420 }
4421 else if(m_bIsInMove)
4422 EnterArea();
4423 return;
4424 }
4425 if ( !rSh.IsSelFrameMode() && !g_bDDINetAttr &&
4426 (IsMinMove( m_aStartPos,aPixPt ) || m_bIsInMove) &&
4427 (rSh.IsInSelect() || !rSh.TestCurrPam( aDocPt )) )
4428 {
4429 if ( pSdrView )
4430 {
4431 if ( rMEvt.IsShift() )
4432 pSdrView->SetOrtho(true);
4433 else
4434 pSdrView->SetOrtho(false);
4435 }
4436 if ( !bInsWin )
4437 {
4438 Point aTmp( aDocPt );
4439 aTmp += rSh.VisArea().Pos() - aOldPt;
4440 LeaveArea( aTmp );
4441 }
4442 else
4443 {
4444 if( !rMEvt.IsSynthetic() &&
4445 ( MOUSE_LEFT != rMEvt.GetButtons() ||
4446 KEY_MOD1 != rMEvt.GetModifier() ||
4447 !rSh.Is_FnDragEQBeginDrag() ||
4448 rSh.IsAddMode() ) )
4449 {
4450 rSh.Drag( &aDocPt, false );
4451
4452 g_bValidCursorPos = !(CRSR_POSCHG & rSh.CallSetCursor(&aDocPt, false));
4453 EnterArea();
4454 }
4455 }
4456 }
4457 g_bDDINetAttr = false;
4458 break;
4459 case 0:
4460 {
4461 if ( m_pApplyTempl )
4462 {
4463 UpdatePointer(aDocPt); // maybe a frame has to be marked here
4464 break;
4465 }
4466 // change ui if mouse is over SwPostItField
4467 // TODO: do the same thing for redlines IsAttrAtPos::Redline
4468 SwContentAtPos aContentAtPos( IsAttrAtPos::Field);
4469 if (rSh.GetContentAtPos(aDocPt, aContentAtPos, false))
4470 {
4471 const SwField* pField = aContentAtPos.aFnd.pField;
4472 if (pField->Which()== SwFieldIds::Postit)
4473 {
4474 m_rView.GetPostItMgr()->SetShadowState(reinterpret_cast<const SwPostItField*>(pField),false);
4475 }
4476 else
4477 m_rView.GetPostItMgr()->SetShadowState(nullptr,false);
4478 }
4479 else
4480 m_rView.GetPostItMgr()->SetShadowState(nullptr,false);
4481 [[fallthrough]];
4482 }
4483 case KEY_SHIFT:
4484 case KEY_MOD2:
4485 case KEY_MOD1:
4486 if ( !m_bInsDraw )
4487 {
4488 bool bTstShdwCursor = true;
4489
4490 UpdatePointer( aDocPt, rMEvt.GetModifier() );
4491
4492 const SwFrameFormat* pFormat = nullptr;
4493 const SwFormatINetFormat* pINet = nullptr;
4494 SwContentAtPos aContentAtPos( IsAttrAtPos::InetAttr );
4495 if( rSh.GetContentAtPos( aDocPt, aContentAtPos ) )
4496 pINet = static_cast<const SwFormatINetFormat*>(aContentAtPos.aFnd.pAttr);
4497
4498 const void* pTmp = pINet;
4499
4500 if( pINet ||
4501 nullptr != ( pTmp = pFormat = rSh.GetFormatFromAnyObj( aDocPt )))
4502 {
4503 bTstShdwCursor = false;
4504 if( pTmp == pINet )
4505 m_aSaveCallEvent.Set( pINet );
4506 else
4507 {
4508 IMapObject* pIMapObj = pFormat->GetIMapObject( aDocPt );
4509 if( pIMapObj )
4510 m_aSaveCallEvent.Set( pFormat, pIMapObj );
4511 else
4512 m_aSaveCallEvent.Set( EVENT_OBJECT_URLITEM, pFormat );
4513 }
4514
4515 // should be over an InternetField with an
4516 // embedded macro?
4517 if( m_aSaveCallEvent != aLastCallEvent )
4518 {
4519 if( aLastCallEvent.HasEvent() )
4520 rSh.CallEvent( SvMacroItemId::OnMouseOut,
4521 aLastCallEvent, true );
4522 // 0 says that the object doesn't have any table
4523 if( !rSh.CallEvent( SvMacroItemId::OnMouseOver,
4524 m_aSaveCallEvent ))
4525 m_aSaveCallEvent.Clear();
4526 }
4527 }
4528 else if( aLastCallEvent.HasEvent() )
4529 {
4530 // cursor was on an object
4531 rSh.CallEvent( SvMacroItemId::OnMouseOut,
4532 aLastCallEvent, true );
4533 }
4534
4535 if( bTstShdwCursor && bInsWin && !bIsDocReadOnly &&
4536 !m_bInsFrame &&
4537 !rSh.GetViewOptions()->getBrowseMode() &&
4538 rSh.GetViewOptions()->IsShadowCursor() &&
4539 !(rMEvt.GetModifier() + rMEvt.GetButtons()) &&
4540 !rSh.HasSelection() && !GetOutDev()->GetConnectMetaFile() )
4541 {
4542 SwRect aRect;
4543
4544 SwFillMode eMode = rSh.GetViewOptions()->GetShdwCursorFillMode();
4545 if( rSh.GetShadowCursorPos( aDocPt, eMode, aRect, m_eOrient ))
4546 {
4547 if( !m_pShadCursor )
4548 m_pShadCursor.reset( new SwShadowCursor( *this ) );
4549 if( text::HoriOrientation::RIGHT != m_eOrient && text::HoriOrientation::CENTER != m_eOrient )
4550 m_eOrient = text::HoriOrientation::LEFT;
4551 m_pShadCursor->SetPos( aRect.Pos(), aRect.Height(), static_cast< sal_uInt16 >(m_eOrient) );
4552 bDelShadCursor = false;
4553 }
4554 }
4555 }
4556 break;
4557 case MOUSE_LEFT + KEY_MOD2:
4558 if( rSh.IsBlockMode() && !rMEvt.IsSynthetic() )
4559 {
4560 rSh.Drag( &aDocPt, false );
4561 g_bValidCursorPos = !(CRSR_POSCHG & rSh.CallSetCursor(&aDocPt, false));
4562 EnterArea();
4563 }
4564 break;
4565 }
4566
4567 if( bDelShadCursor && m_pShadCursor )
4568 {
4569 m_pShadCursor.reset();
4570 }
4571 m_bWasShdwCursor = false;
4572}
4573
4577void SwEditWin::MouseButtonUp(const MouseEvent& rMEvt)
4578{
4579 if (comphelper::LibreOfficeKit::isActive())
4580 {
4581 if (vcl::Window* pWindow = m_rView.GetPostItMgr()->IsHitSidebarWindow(rMEvt.GetPosPixel()))
4582 {
4583 pWindow->MouseButtonUp(rMEvt);
4584 return;
4585 }
4586 }
4587
4588 bool bCallBase = true;
4589
4590 bool bCallShadowCursor = m_bWasShdwCursor;
4591 m_bWasShdwCursor = false;
4592 if( m_pShadCursor )
4593 {
4594 m_pShadCursor.reset();
4595 }
4596
4597 m_xRowColumnSelectionStart.reset();
4598
4599 SdrHdlKind eOldSdrMoveHdl = g_eSdrMoveHdl;
4600 g_eSdrMoveHdl = SdrHdlKind::User; // for MoveEvents - reset again
4601
4602 // preventively reset
4603 m_rView.SetTabColFromDoc( false );
4604 m_rView.SetNumRuleNodeFromDoc(nullptr);
4605
4606 SwWrtShell &rSh = m_rView.GetWrtShell();
4607 CurrShell aCurr( &rSh );
4608 SdrView *pSdrView = rSh.GetDrawView();
4609 if ( pSdrView )
4610 {
4611 // tdf34555: ortho was always reset before being used in EndSdrDrag
4612 // Now, it is reset only if not in Crop mode.
4613 if (pSdrView->GetDragMode() != SdrDragMode::Crop && !rMEvt.IsShift())
4614 pSdrView->SetOrtho(false);
4615
4616 if ( pSdrView->MouseButtonUp( rMEvt,GetOutDev() ) )
4617 {
4618 rSh.GetView().GetViewFrame().GetBindings().InvalidateAll(false);
4619 return; // SdrView's event evaluated
4620 }
4621 }
4622 // only process MouseButtonUp when the Down went to that windows as well.
4623 if ( !m_bMBPressed )
4624 {
4625 // Undo for the watering can is already in CommandHdl
4626 // that's the way it should be!
4627
4628 return;
4629 }
4630
4631 Point aDocPt( PixelToLogic( rMEvt.GetPosPixel() ) );
4632
4633 if ( g_bDDTimerStarted )
4634 {
4635 StopDDTimer( &rSh, aDocPt );
4636 m_bMBPressed = false;
4637 if ( rSh.IsSelFrameMode() )
4638 {
4639 rSh.EndDrag( &aDocPt, false );
4640 g_bFrameDrag = false;
4641 }
4642 g_bNoInterrupt = false;
4643 const Point aDocPos( PixelToLogic( rMEvt.GetPosPixel() ) );
4644 if ((PixelToLogic(m_aStartPos).Y() == (aDocPos.Y())) && (PixelToLogic(m_aStartPos).X() == (aDocPos.X())))//To make sure it was not moved
4645 {
4646 SdrPageView* pPV = nullptr;
4647 SdrObject* pObj = pSdrView ? pSdrView->PickObj(aDocPos, pSdrView->getHitTolLog(), pPV, SdrSearchOptions::ALSOONMASTER) : nullptr;
4648 if (pObj)
4649 {
4650 SwFrameFormat* pFormat = GetUserCall(pObj)->GetFormat();
4651 SwFrameFormat* pShapeFormat = SwTextBoxHelper::getOtherTextBoxFormat(pFormat, RES_FLYFRMFMT);
4652 if (!pShapeFormat)
4653 {
4654 pSdrView->UnmarkAllObj();
4655 pSdrView->MarkObj(pObj,pPV);
4656 }
4657 else
4658 {
4659 // If the fly frame is a textbox of a shape, then select the shape instead.
4660 SdrObject* pShape = pShapeFormat->FindSdrObject();
4661 pSdrView->UnmarkAllObj();
4662 pSdrView->MarkObj(pShape, pPV);
4663 }
4664 }
4665 }
4666 ReleaseMouse();
4667 return;
4668 }
4669
4670 if( m_pAnchorMarker )
4671 {
4672 if(m_pAnchorMarker->GetHdl())
4673 {
4674 // #i121463# delete selected after drag
4675 m_pAnchorMarker->GetHdl()->SetSelected(false);
4676 }
4677
4678 Point aPnt( m_pAnchorMarker->GetLastPos() );
4679 m_pAnchorMarker.reset();
4680 if( aPnt.X() || aPnt.Y() )
4681 rSh.FindAnchorPos( aPnt, true );
4682 }
4683 if ( m_bInsDraw && m_rView.GetDrawFuncPtr() )
4684 {
4685 if ( m_rView.GetDrawFuncPtr()->MouseButtonUp( rMEvt ) )
4686 {
4687 if (m_rView.GetDrawFuncPtr()) // could have been destroyed in MouseButtonUp
4688 {
4689 m_rView.GetDrawFuncPtr()->Deactivate();
4690
4691 if (!m_rView.IsDrawMode())
4692 {
4693 m_rView.SetDrawFuncPtr(nullptr);
4694 SfxBindings& rBind = m_rView.GetViewFrame().GetBindings();
4695 rBind.Invalidate( SID_ATTR_SIZE );
4696 rBind.Invalidate( SID_TABLE_CELL );
4697 }
4698 }
4699
4700 if ( rSh.IsObjSelected() )
4701 {
4702 rSh.EnterSelFrameMode();
4703 if (!m_rView.GetDrawFuncPtr())
4704 StdDrawMode( SdrObjKind::NONE, true );
4705 }
4706 else if ( rSh.IsFrameSelected() )
4707 {
4708 rSh.EnterSelFrameMode();
4709 StopInsFrame();
4710 }
4711 else
4712 {
4713 const Point aDocPos( PixelToLogic( m_aStartPos ) );
4714 g_bValidCursorPos = !(CRSR_POSCHG & rSh.CallSetCursor(&aDocPos, false));
4715 rSh.Edit();
4716 }
4717
4718 m_rView.AttrChangedNotify(nullptr);
4719 }
4720 else if (rMEvt.GetButtons() == MOUSE_RIGHT && rSh.IsDrawCreate())
4721 m_rView.GetDrawFuncPtr()->BreakCreate(); // abort drawing
4722
4723 g_bNoInterrupt = false;
4724 if (IsMouseCaptured())
4725 ReleaseMouse();
4726 return;
4727 }
4728 bool bPopMode = false;
4729 switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
4730 {
4731 case MOUSE_LEFT:
4732 if ( m_bInsDraw && rSh.IsDrawCreate() )
4733 {
4734 if ( m_rView.GetDrawFuncPtr() && m_rView.GetDrawFuncPtr()->MouseButtonUp(rMEvt) )
4735 {
4736 m_rView.GetDrawFuncPtr()->Deactivate();
4737 m_rView.AttrChangedNotify(nullptr);
4738 if ( rSh.IsObjSelected() )
4739 rSh.EnterSelFrameMode();
4740 if ( m_rView.GetDrawFuncPtr() && m_bInsFrame )
4741 StopInsFrame();
4742 }
4743 bCallBase = false;
4744 break;
4745 }
4746 [[fallthrough]];
4747 case MOUSE_LEFT + KEY_MOD1:
4748 case MOUSE_LEFT + KEY_MOD2:
4749 case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
4750 if ( g_bFrameDrag && rSh.IsSelFrameMode() )
4751 {
4752 if ( rMEvt.IsMod1() ) // copy and don't move.
4753 {
4754 // abort drag, use internal Copy instead
4755 tools::Rectangle aRect;
4756 rSh.GetDrawView()->TakeActionRect( aRect );
4757 if (!aRect.IsEmpty())
4758 {
4759 rSh.BreakDrag();
4760 Point aEndPt, aSttPt;
4761 if ( rSh.GetSelFrameType() & FrameTypeFlags::FLY_ATCNT )
4762 {
4763 aEndPt = aRect.TopLeft();
4764 aSttPt = rSh.GetDrawView()->GetAllMarkedRect().TopLeft();
4765 }
4766 else
4767 {
4768 aEndPt = aRect.Center();
4769 aSttPt = rSh.GetDrawView()->GetAllMarkedRect().Center();
4770 }
4771 if ( aSttPt != aEndPt )
4772 {
4773 rSh.StartUndo( SwUndoId::UI_DRAG_AND_COPY );
4774 rSh.Copy(rSh, aSttPt, aEndPt);
4775 rSh.EndUndo( SwUndoId::UI_DRAG_AND_COPY );
4776 }
4777 }
4778 else {
4779 rSh.EndDrag( &aDocPt, false );
4780 }
4781 }
4782 else
4783 {
4784 {
4785 const SwFrameFormat *const pFlyFormat(rSh.GetFlyFrameFormat());
4786 const SvxMacro* pMacro = nullptr;
4787
4788 SvMacroItemId nEvent = SdrHdlKind::Move == eOldSdrMoveHdl
4789 ? SvMacroItemId::SwFrmMove
4790 : SvMacroItemId::SwFrmResize;
4791
4792 if (nullptr != pFlyFormat)
4793 pMacro = pFlyFormat->GetMacro().GetMacroTable().Get(nEvent);
4794 if (nullptr != pMacro)
4795 {
4796 const Point aSttPt( PixelToLogic( m_aStartPos ) );
4797 m_aRszMvHdlPt = aDocPt;
4798 sal_uInt32 nPos = 0;
4799 SbxArrayRef xArgs = new SbxArray;
4800 SbxVariableRef xVar = new SbxVariable;
4801 xVar->PutString( pFlyFormat->GetName() );
4802 xArgs->Put(xVar.get(), ++nPos);
4803
4804 if( SvMacroItemId::SwFrmResize == nEvent )
4805 {
4806 xVar = new SbxVariable;
4807 xVar->PutUShort( static_cast< sal_uInt16 >(eOldSdrMoveHdl) );
4808 xArgs->Put(xVar.get(), ++nPos);
4809 }
4810
4811 xVar = new SbxVariable;
4812 xVar->PutLong( aDocPt.X() - aSttPt.X() );
4813 xArgs->Put(xVar.get(), ++nPos);
4814 xVar = new SbxVariable;
4815 xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
4816 xArgs->Put(xVar.get(), ++nPos);
4817
4818 xVar = new SbxVariable;
4819 xVar->PutUShort( 1 );
4820 xArgs->Put(xVar.get(), ++nPos);
4821
4822 ReleaseMouse();
4823
4824 rSh.ExecMacro( *pMacro, nullptr, xArgs.get() );
4825
4826 CaptureMouse();
4827 }
4828
4829 if (pFlyFormat)
4830 {
4831 // See if the fly frame's anchor is in a content control. If so,
4832 // interact with it.
4833 const SwFormatAnchor& rFormatAnchor = pFlyFormat->GetAnchor();
4834 SwNode* pAnchorNode = rFormatAnchor.GetAnchorNode();
4835 if (pAnchorNode)
4836 {
4837 SwTextNode* pTextNode = pAnchorNode->GetTextNode();
4838 if (pTextNode)
4839 {
4840 SwTextAttr* pAttr = pTextNode->GetTextAttrAt(
4841 rFormatAnchor.GetAnchorContentOffset(), RES_TXTATR_CONTENTCONTROL,
4842 ::sw::GetTextAttrMode::Parent);
4843 if (pAttr)
4844 {
4845 SwTextContentControl* pTextContentControl
4846 = static_txtattr_cast<SwTextContentControl*>(pAttr);
4847 const SwFormatContentControl& rFormatContentControl
4848 = pTextContentControl->GetContentControl();
4849 rSh.GotoContentControl(rFormatContentControl);
4850 }
4851 }
4852 }
4853 }
4854 }
4855 rSh.EndDrag( &aDocPt, false );
4856 }
4857 g_bFrameDrag = false;
4858 bCallBase = false;
4859 break;
4860 }
4861 bPopMode = true;
4862 [[fallthrough]];
4863 case MOUSE_LEFT + KEY_SHIFT:
4864 if (rSh.IsSelFrameMode())
4865 {
4866
4867 rSh.EndDrag( &aDocPt, false );
4868 g_bFrameDrag = false;
4869 bCallBase = false;
4870