1efeef26fSAndrew Rist /**************************************************************
2efeef26fSAndrew Rist *
3efeef26fSAndrew Rist * Licensed to the Apache Software Foundation (ASF) under one
4efeef26fSAndrew Rist * or more contributor license agreements. See the NOTICE file
5efeef26fSAndrew Rist * distributed with this work for additional information
6efeef26fSAndrew Rist * regarding copyright ownership. The ASF licenses this file
7efeef26fSAndrew Rist * to you under the Apache License, Version 2.0 (the
8efeef26fSAndrew Rist * "License"); you may not use this file except in compliance
9efeef26fSAndrew Rist * with the License. You may obtain a copy of the License at
10efeef26fSAndrew Rist *
11efeef26fSAndrew Rist * http://www.apache.org/licenses/LICENSE-2.0
12efeef26fSAndrew Rist *
13efeef26fSAndrew Rist * Unless required by applicable law or agreed to in writing,
14efeef26fSAndrew Rist * software distributed under the License is distributed on an
15efeef26fSAndrew Rist * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16efeef26fSAndrew Rist * KIND, either express or implied. See the License for the
17efeef26fSAndrew Rist * specific language governing permissions and limitations
18efeef26fSAndrew Rist * under the License.
19efeef26fSAndrew Rist *
20efeef26fSAndrew Rist *************************************************************/
21efeef26fSAndrew Rist
22efeef26fSAndrew Rist
23cdf0e10cSrcweir
24cdf0e10cSrcweir // MARKER(update_precomp.py): autogen include statement, do not remove
25cdf0e10cSrcweir #include "precompiled_sw.hxx"
26cdf0e10cSrcweir
27cdf0e10cSrcweir
28cdf0e10cSrcweir #include <tools/list.hxx>
29cdf0e10cSrcweir #include <swtypes.hxx>
30cdf0e10cSrcweir #include <hintids.hxx>
31cdf0e10cSrcweir #include <com/sun/star/accessibility/XAccessible.hpp>
32cdf0e10cSrcweir #include <comphelper/processfactory.hxx>
33cdf0e10cSrcweir #include <com/sun/star/i18n/XBreakIterator.hpp>
34cdf0e10cSrcweir #include <com/sun/star/i18n/ScriptType.hpp>
35cdf0e10cSrcweir #include <com/sun/star/i18n/InputSequenceCheckMode.hpp>
36cdf0e10cSrcweir
37cdf0e10cSrcweir #include <com/sun/star/i18n/UnicodeScript.hpp>
38cdf0e10cSrcweir
39cdf0e10cSrcweir #include <vcl/help.hxx>
40cdf0e10cSrcweir #include <vcl/graph.hxx>
41cdf0e10cSrcweir #include <vcl/msgbox.hxx>
42cdf0e10cSrcweir #include <vcl/cmdevt.h>
43cdf0e10cSrcweir #include <sot/storage.hxx>
44cdf0e10cSrcweir #include <svl/macitem.hxx>
45cdf0e10cSrcweir #include <unotools/securityoptions.hxx>
46cdf0e10cSrcweir #include <basic/sbxvar.hxx>
47cdf0e10cSrcweir #include <svl/ctloptions.hxx>
48cdf0e10cSrcweir #include <basic/sbx.hxx>
49cdf0e10cSrcweir #include <svl/eitem.hxx>
50cdf0e10cSrcweir #include <svl/stritem.hxx>
51cdf0e10cSrcweir #include <sfx2/ipclient.hxx>
52cdf0e10cSrcweir #include <sfx2/viewfrm.hxx>
53cdf0e10cSrcweir #include <sfx2/request.hxx>
54cdf0e10cSrcweir #include <sfx2/bindings.hxx>
55cdf0e10cSrcweir #include <sfx2/dispatch.hxx>
56cdf0e10cSrcweir #include <svl/ptitem.hxx>
57cdf0e10cSrcweir #include <editeng/sizeitem.hxx>
58cdf0e10cSrcweir #include <editeng/langitem.hxx>
59cdf0e10cSrcweir #include <svx/htmlmode.hxx>
60cdf0e10cSrcweir #include <svx/svdview.hxx>
61cdf0e10cSrcweir #include <svx/svdhdl.hxx>
62cdf0e10cSrcweir #include <svx/svdoutl.hxx>
63cdf0e10cSrcweir #include <editeng/editeng.hxx>
64cdf0e10cSrcweir #include <editeng/svxacorr.hxx>
65cdf0e10cSrcweir #include <editeng/scripttypeitem.hxx>
66cdf0e10cSrcweir #include <editeng/flditem.hxx>
67cdf0e10cSrcweir #include <editeng/colritem.hxx>
68cdf0e10cSrcweir #include <editeng/brshitem.hxx>
69cdf0e10cSrcweir #include <editeng/wghtitem.hxx>
70cdf0e10cSrcweir #include <editeng/udlnitem.hxx>
71cdf0e10cSrcweir #include <editeng/postitem.hxx>
72cdf0e10cSrcweir #include <editeng/protitem.hxx>
73cdf0e10cSrcweir #include <unotools/charclass.hxx>
74cdf0e10cSrcweir
75cdf0e10cSrcweir #include <editeng/acorrcfg.hxx>
76cdf0e10cSrcweir #include <SwSmartTagMgr.hxx>
77cdf0e10cSrcweir #include <edtwin.hxx>
78cdf0e10cSrcweir #include <view.hxx>
79cdf0e10cSrcweir #include <wrtsh.hxx>
80cdf0e10cSrcweir #include <IDocumentSettingAccess.hxx>
81cdf0e10cSrcweir #include <fldbas.hxx>
82cdf0e10cSrcweir #include <swmodule.hxx>
83cdf0e10cSrcweir #include <docsh.hxx>
84cdf0e10cSrcweir #include <viewopt.hxx>
85cdf0e10cSrcweir #include <drawbase.hxx>
86cdf0e10cSrcweir #include <dselect.hxx>
87cdf0e10cSrcweir #include <textsh.hxx>
88cdf0e10cSrcweir #include <shdwcrsr.hxx>
8969a74367SOliver-Rainer Wittmann #include <txatbase.hxx>
90cdf0e10cSrcweir #include <fmtanchr.hxx>
91cdf0e10cSrcweir #include <fmtornt.hxx>
92cdf0e10cSrcweir #include <fmtfsize.hxx>
93cdf0e10cSrcweir #include <fmtclds.hxx>
94cdf0e10cSrcweir #include <frmfmt.hxx>
95cdf0e10cSrcweir #include <modcfg.hxx>
96cdf0e10cSrcweir #include <fmtcol.hxx>
97cdf0e10cSrcweir #include <wview.hxx>
98cdf0e10cSrcweir #include <listsh.hxx>
99cdf0e10cSrcweir #include <gloslst.hxx>
100cdf0e10cSrcweir #include <inputwin.hxx>
101cdf0e10cSrcweir #include <gloshdl.hxx>
102cdf0e10cSrcweir #include <swundo.hxx>
103cdf0e10cSrcweir #include <drwtxtsh.hxx>
104cdf0e10cSrcweir #include <fchrfmt.hxx>
105cdf0e10cSrcweir #include <fmturl.hxx>
106cdf0e10cSrcweir #include <romenu.hxx>
107cdf0e10cSrcweir #include <initui.hxx>
108cdf0e10cSrcweir #include <frmatr.hxx>
109cdf0e10cSrcweir #include <extinput.hxx>
110cdf0e10cSrcweir #include <acmplwrd.hxx>
111cdf0e10cSrcweir #include <swcalwrp.hxx>
112cdf0e10cSrcweir #include <swdtflvr.hxx>
113cdf0e10cSrcweir #include <wdocsh.hxx>
114cdf0e10cSrcweir #include <crsskip.hxx>
115cdf0e10cSrcweir #include <breakit.hxx>
116cdf0e10cSrcweir #include <checkit.hxx>
117cdf0e10cSrcweir
118cdf0e10cSrcweir #include <helpid.h>
119cdf0e10cSrcweir #include <cmdid.h>
120cdf0e10cSrcweir #include <docvw.hrc>
121cdf0e10cSrcweir #include <uitool.hxx>
122cdf0e10cSrcweir #include <fmtfollowtextflow.hxx>
123cdf0e10cSrcweir #include <toolkit/helper/vclunohelper.hxx>
124cdf0e10cSrcweir #include <charfmt.hxx>
125cdf0e10cSrcweir #include <numrule.hxx>
126cdf0e10cSrcweir #include <pagedesc.hxx>
1275b40a975SOliver-Rainer Wittmann #include <svtools/ruler.hxx>
128cdf0e10cSrcweir #include "formatclipboard.hxx"
129cdf0e10cSrcweir #include <vos/mutex.hxx>
130cdf0e10cSrcweir #include <vcl/svapp.hxx>
131cdf0e10cSrcweir
132cdf0e10cSrcweir #include <IMark.hxx>
133cdf0e10cSrcweir #include <doc.hxx>
134cdf0e10cSrcweir #include <xmloff/odffields.hxx>
135cdf0e10cSrcweir
136cdf0e10cSrcweir #include <PostItMgr.hxx>
137cdf0e10cSrcweir
138cdf0e10cSrcweir using namespace sw::mark;
139cdf0e10cSrcweir using namespace ::com::sun::star;
140cdf0e10cSrcweir
141cdf0e10cSrcweir /*--------------------------------------------------------------------
142cdf0e10cSrcweir Beschreibung: Globals
143cdf0e10cSrcweir --------------------------------------------------------------------*/
144cdf0e10cSrcweir
145cdf0e10cSrcweir static bool bInputLanguageSwitched = false;
146cdf0e10cSrcweir extern sal_Bool bNoInterrupt; // in mainwn.cxx
147cdf0e10cSrcweir
148cdf0e10cSrcweir //Normalerweise wird im MouseButtonUp eine Selektion aufgehoben wenn die
149cdf0e10cSrcweir //Selektion nicht gerade aufgezogen wird. Leider wird im MouseButtonDown
150cdf0e10cSrcweir //bei doppel-/dreifach-Klick Selektiert, diese Selektion wird in dem Handler
151cdf0e10cSrcweir //komplett abgeschlossen und kann deshalb im Up nicht mehr unterschieden
152cdf0e10cSrcweir //werden. Um dies Aufzuloese wird bHoldSelection im Down gesetzt und im
153cdf0e10cSrcweir //Up ausgewertet.
154cdf0e10cSrcweir static sal_Bool bHoldSelection = sal_False;
155cdf0e10cSrcweir
156cdf0e10cSrcweir sal_Bool bFrmDrag = sal_False;
157cdf0e10cSrcweir sal_Bool bValidCrsrPos = sal_False;
158cdf0e10cSrcweir sal_Bool bModePushed = sal_False;
159cdf0e10cSrcweir sal_Bool bDDTimerStarted = sal_False;
160cdf0e10cSrcweir sal_Bool bFlushCharBuffer = sal_False;
161cdf0e10cSrcweir sal_Bool SwEditWin::bReplaceQuote = sal_False;
162cdf0e10cSrcweir sal_Bool bDDINetAttr = sal_False;
163cdf0e10cSrcweir SdrHdlKind eSdrMoveHdl = HDL_USER;
164cdf0e10cSrcweir
165cdf0e10cSrcweir QuickHelpData* SwEditWin::pQuickHlpData = 0;
166cdf0e10cSrcweir
167cdf0e10cSrcweir long SwEditWin::nDDStartPosY = 0;
168cdf0e10cSrcweir long SwEditWin::nDDStartPosX = 0;
169cdf0e10cSrcweir Color SwEditWin::aTextBackColor(COL_YELLOW);
170cdf0e10cSrcweir Color SwEditWin::aTextColor(COL_RED);
171cdf0e10cSrcweir sal_Bool SwEditWin::bTransparentBackColor = sal_False; // Hintergrund nicht transparent
172cdf0e10cSrcweir
173cdf0e10cSrcweir
174cdf0e10cSrcweir extern sal_Bool bExecuteDrag;
175cdf0e10cSrcweir
176cdf0e10cSrcweir SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType );
177cdf0e10cSrcweir
178cdf0e10cSrcweir DBG_NAME(edithdl)
179cdf0e10cSrcweir
180cdf0e10cSrcweir class SwAnchorMarker
181cdf0e10cSrcweir {
182cdf0e10cSrcweir SdrHdl* pHdl;
183cdf0e10cSrcweir Point aHdlPos;
184cdf0e10cSrcweir Point aLastPos;
185cdf0e10cSrcweir bool bTopRightHandle;
186cdf0e10cSrcweir public:
SwAnchorMarker(SdrHdl * pH)187cdf0e10cSrcweir SwAnchorMarker( SdrHdl* pH )
188cdf0e10cSrcweir : pHdl( pH )
189cdf0e10cSrcweir , aHdlPos( pH->GetPos() )
190cdf0e10cSrcweir , aLastPos( pH->GetPos() )
191cdf0e10cSrcweir , bTopRightHandle( pH->GetKind() == HDL_ANCHOR_TR )
192cdf0e10cSrcweir {}
GetLastPos() const193cdf0e10cSrcweir const Point& GetLastPos() const { return aLastPos; }
SetLastPos(const Point & rNew)194cdf0e10cSrcweir void SetLastPos( const Point& rNew ) { aLastPos = rNew; }
SetPos(const Point & rNew)195cdf0e10cSrcweir void SetPos( const Point& rNew ) { pHdl->SetPos( rNew ); }
GetPos()196cdf0e10cSrcweir const Point& GetPos() { return pHdl->GetPos(); }
GetHdlPos()197cdf0e10cSrcweir const Point& GetHdlPos() { return aHdlPos; }
GetHdl() const1984772d9afSArmin Le Grand SdrHdl* GetHdl() const { return pHdl; }
ChgHdl(SdrHdl * pNew)199cdf0e10cSrcweir void ChgHdl( SdrHdl* pNew )
200cdf0e10cSrcweir {
201cdf0e10cSrcweir pHdl = pNew;
202cdf0e10cSrcweir if ( pHdl )
203cdf0e10cSrcweir {
204cdf0e10cSrcweir bTopRightHandle = (pHdl->GetKind() == HDL_ANCHOR_TR);
205cdf0e10cSrcweir }
206cdf0e10cSrcweir }
GetPosForHitTest(const OutputDevice & rOut)207cdf0e10cSrcweir const Point GetPosForHitTest( const OutputDevice& rOut )
208cdf0e10cSrcweir {
209cdf0e10cSrcweir Point aHitTestPos( GetPos() );
210cdf0e10cSrcweir aHitTestPos = rOut.LogicToPixel( aHitTestPos );
211cdf0e10cSrcweir if ( bTopRightHandle )
212cdf0e10cSrcweir {
213cdf0e10cSrcweir aHitTestPos += Point( -1, 1 );
214cdf0e10cSrcweir }
215cdf0e10cSrcweir else
216cdf0e10cSrcweir {
217cdf0e10cSrcweir aHitTestPos += Point( 1, 1 );
218cdf0e10cSrcweir }
219cdf0e10cSrcweir aHitTestPos = rOut.PixelToLogic( aHitTestPos );
220cdf0e10cSrcweir
221cdf0e10cSrcweir return aHitTestPos;
222cdf0e10cSrcweir }
223cdf0e10cSrcweir };
224cdf0e10cSrcweir
225cdf0e10cSrcweir struct QuickHelpData
226cdf0e10cSrcweir {
227cdf0e10cSrcweir SvStringsISortDtor aArr;
228cdf0e10cSrcweir sal_uInt16* pAttrs;
229cdf0e10cSrcweir CommandExtTextInputData* pCETID;
230cdf0e10cSrcweir sal_uLong nTipId;
231cdf0e10cSrcweir sal_uInt16 nLen, nCurArrPos;
232cdf0e10cSrcweir sal_Bool bClear : 1, bChkInsBlank : 1, bIsTip : 1, bIsAutoText : 1;
233cdf0e10cSrcweir
QuickHelpDataQuickHelpData234cdf0e10cSrcweir QuickHelpData() : pAttrs( 0 ), pCETID( 0 ) { ClearCntnt(); }
235cdf0e10cSrcweir
236cdf0e10cSrcweir void Move( QuickHelpData& rCpy );
237cdf0e10cSrcweir void ClearCntnt();
238cdf0e10cSrcweir void Start( SwWrtShell& rSh, sal_uInt16 nWrdLen );
239cdf0e10cSrcweir void Stop( SwWrtShell& rSh );
240cdf0e10cSrcweir
HasCntntQuickHelpData241cdf0e10cSrcweir sal_Bool HasCntnt() const { return aArr.Count() && 0 != nLen; }
242cdf0e10cSrcweir
IncQuickHelpData243cdf0e10cSrcweir void Inc( sal_Bool bEndLess )
244cdf0e10cSrcweir {
245cdf0e10cSrcweir if( ++nCurArrPos >= aArr.Count() )
246cdf0e10cSrcweir nCurArrPos = (bEndLess && !bIsAutoText )? 0 : nCurArrPos-1;
247cdf0e10cSrcweir }
DecQuickHelpData248cdf0e10cSrcweir void Dec( sal_Bool bEndLess )
249cdf0e10cSrcweir {
250cdf0e10cSrcweir if( 0 == nCurArrPos-- )
251cdf0e10cSrcweir nCurArrPos = (bEndLess && !bIsAutoText ) ? aArr.Count()-1 : 0;
252cdf0e10cSrcweir }
253cdf0e10cSrcweir void FillStrArr( SwWrtShell& rSh, const String& rWord );
254cdf0e10cSrcweir };
255cdf0e10cSrcweir
256cdf0e10cSrcweir
257cdf0e10cSrcweir /*--------------------------------------------------------------------
258cdf0e10cSrcweir Beschreibung: Minimale Bewegung Zittern vermeiden
259cdf0e10cSrcweir --------------------------------------------------------------------*/
260cdf0e10cSrcweir
261cdf0e10cSrcweir #define HIT_PIX 2 /* Hit-Toleranz in Pixel */
262cdf0e10cSrcweir #define MIN_MOVE 4
263cdf0e10cSrcweir
IsMinMove(const Point & rStartPos,const Point & rLPt)264cdf0e10cSrcweir inline sal_Bool IsMinMove(const Point &rStartPos, const Point &rLPt)
265cdf0e10cSrcweir {
266cdf0e10cSrcweir return Abs(rStartPos.X() - rLPt.X()) > MIN_MOVE ||
267cdf0e10cSrcweir Abs(rStartPos.Y() - rLPt.Y()) > MIN_MOVE;
268cdf0e10cSrcweir }
269cdf0e10cSrcweir
270cdf0e10cSrcweir /*--------------------------------------------------------------------
271cdf0e10cSrcweir JP 30.07.98: fuer MouseButtonDown - feststellen, ob ein DrawObject
272cdf0e10cSrcweir und KEIN SwgFrame getroffen wurde! Shift/Ctrl sollen
273cdf0e10cSrcweir nur bei DrawObjecte zum Selektieren fuehren, bei SwgFlys
274cdf0e10cSrcweir ggfs zum ausloesen von Hyperlinks (DownLoad/NewWindow!)
275cdf0e10cSrcweir --------------------------------------------------------------------*/
IsDrawObjSelectable(const SwWrtShell & rSh,const Point & rPt)276cdf0e10cSrcweir inline sal_Bool IsDrawObjSelectable( const SwWrtShell& rSh, const Point& rPt )
277cdf0e10cSrcweir {
278cdf0e10cSrcweir sal_Bool bRet = sal_True;
279cdf0e10cSrcweir SdrObject* pObj;
280cdf0e10cSrcweir switch( rSh.GetObjCntType( rPt, pObj ))
281cdf0e10cSrcweir {
282cdf0e10cSrcweir case OBJCNT_NONE:
283cdf0e10cSrcweir case OBJCNT_FLY:
284cdf0e10cSrcweir case OBJCNT_GRF:
285cdf0e10cSrcweir case OBJCNT_OLE:
286cdf0e10cSrcweir bRet = sal_False;
287cdf0e10cSrcweir break;
288cdf0e10cSrcweir default:; //prevent warning
289cdf0e10cSrcweir }
290cdf0e10cSrcweir return bRet;
291cdf0e10cSrcweir }
292cdf0e10cSrcweir
293cdf0e10cSrcweir /*--------------------------------------------------------------------
294cdf0e10cSrcweir Beschreibung: Pointer umschalten
295cdf0e10cSrcweir --------------------------------------------------------------------*/
296cdf0e10cSrcweir
297cdf0e10cSrcweir
UpdatePointer(const Point & rLPt,sal_uInt16 nModifier)298cdf0e10cSrcweir void SwEditWin::UpdatePointer(const Point &rLPt, sal_uInt16 nModifier )
299cdf0e10cSrcweir {
300cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
301cdf0e10cSrcweir if( pApplyTempl )
302cdf0e10cSrcweir {
303cdf0e10cSrcweir PointerStyle eStyle = POINTER_FILL;
304*23d8f725SOliver-Rainer Wittmann if ( rSh.IsOverReadOnlyPos( rLPt ) )
305cdf0e10cSrcweir {
306cdf0e10cSrcweir if( pUserMarker )
307cdf0e10cSrcweir {
308cdf0e10cSrcweir delete pUserMarker;
309cdf0e10cSrcweir pUserMarker = 0L;
310cdf0e10cSrcweir }
311cdf0e10cSrcweir eStyle = POINTER_NOTALLOWED;
312cdf0e10cSrcweir }
313cdf0e10cSrcweir else
314cdf0e10cSrcweir {
315cdf0e10cSrcweir SwRect aRect;
316cdf0e10cSrcweir SwRect* pRect = &aRect;
317cdf0e10cSrcweir const SwFrmFmt* pFmt = 0;
318cdf0e10cSrcweir
319cdf0e10cSrcweir bool bFrameIsValidTarget = false;
320cdf0e10cSrcweir if( pApplyTempl->pFormatClipboard )
321cdf0e10cSrcweir bFrameIsValidTarget = pApplyTempl->pFormatClipboard->HasContentForThisType( nsSelectionType::SEL_FRM );
322cdf0e10cSrcweir else if( !pApplyTempl->nColor )
323cdf0e10cSrcweir bFrameIsValidTarget = ( pApplyTempl->eType == SFX_STYLE_FAMILY_FRAME );
324cdf0e10cSrcweir
325cdf0e10cSrcweir if( bFrameIsValidTarget &&
326cdf0e10cSrcweir 0 !=(pFmt = rSh.GetFmtFromObj( rLPt, &pRect )) &&
327cdf0e10cSrcweir PTR_CAST(SwFlyFrmFmt, pFmt))
328cdf0e10cSrcweir {
329cdf0e10cSrcweir //Highlight fuer Rahmen anwerfen
330cdf0e10cSrcweir Rectangle aTmp( pRect->SVRect() );
331cdf0e10cSrcweir
332cdf0e10cSrcweir if ( !pUserMarker )
333cdf0e10cSrcweir {
334cdf0e10cSrcweir pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp );
335cdf0e10cSrcweir }
336cdf0e10cSrcweir }
337cdf0e10cSrcweir else if(pUserMarker)
338cdf0e10cSrcweir {
339cdf0e10cSrcweir delete pUserMarker;
340cdf0e10cSrcweir pUserMarker = 0L;
341cdf0e10cSrcweir }
342cdf0e10cSrcweir
343cdf0e10cSrcweir rSh.SwCrsrShell::SetVisCrsr( rLPt );
344cdf0e10cSrcweir }
345cdf0e10cSrcweir SetPointer( eStyle );
346cdf0e10cSrcweir return;
347cdf0e10cSrcweir }
348cdf0e10cSrcweir
349cdf0e10cSrcweir if( !rSh.VisArea().Width() )
350cdf0e10cSrcweir return;
351cdf0e10cSrcweir
352cdf0e10cSrcweir SET_CURR_SHELL(&rSh);
353cdf0e10cSrcweir
354cdf0e10cSrcweir if ( IsChainMode() )
355cdf0e10cSrcweir {
356cdf0e10cSrcweir SwRect aRect;
357cdf0e10cSrcweir int nChainable = rSh.Chainable( aRect, *rSh.GetFlyFrmFmt(), rLPt );
358cdf0e10cSrcweir PointerStyle eStyle = nChainable
359cdf0e10cSrcweir ? POINTER_CHAIN_NOTALLOWED : POINTER_CHAIN;
360cdf0e10cSrcweir if ( !nChainable )
361cdf0e10cSrcweir {
362cdf0e10cSrcweir Rectangle aTmp( aRect.SVRect() );
363cdf0e10cSrcweir
364cdf0e10cSrcweir if ( !pUserMarker )
365cdf0e10cSrcweir {
366cdf0e10cSrcweir pUserMarker = new SdrDropMarkerOverlay( *rSh.GetDrawView(), aTmp );
367cdf0e10cSrcweir }
368cdf0e10cSrcweir }
369cdf0e10cSrcweir else
370cdf0e10cSrcweir {
371cdf0e10cSrcweir delete pUserMarker;
372cdf0e10cSrcweir pUserMarker = 0L;
373cdf0e10cSrcweir }
374cdf0e10cSrcweir
375cdf0e10cSrcweir rView.GetViewFrame()->ShowStatusText(
376cdf0e10cSrcweir SW_RESSTR(STR_CHAIN_OK+nChainable));
377cdf0e10cSrcweir SetPointer( eStyle );
378cdf0e10cSrcweir return;
379cdf0e10cSrcweir }
380cdf0e10cSrcweir
381cdf0e10cSrcweir // Removed ExecHyperlink option.
382cdf0e10cSrcweir //sal_Bool bExecHyperlinks = rSh.GetViewOptions()->IsExecHyperlinks() ^
383cdf0e10cSrcweir // (nModifier == KEY_MOD2 ? sal_True : sal_False);
384cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
385cdf0e10cSrcweir if ( !bExecHyperlinks )
386cdf0e10cSrcweir {
387cdf0e10cSrcweir SvtSecurityOptions aSecOpts;
388cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
389cdf0e10cSrcweir if ( ( bSecureOption && nModifier == KEY_MOD1 ) ||
390cdf0e10cSrcweir ( !bSecureOption && nModifier != KEY_MOD1 ) )
391cdf0e10cSrcweir bExecHyperlinks = sal_True;
392cdf0e10cSrcweir }
393cdf0e10cSrcweir
394cdf0e10cSrcweir const sal_Bool bExecSmarttags = nModifier == KEY_MOD1;
395cdf0e10cSrcweir
396cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
397cdf0e10cSrcweir sal_Bool bPrefSdrPointer = sal_False;
398cdf0e10cSrcweir sal_Bool bHitHandle = sal_False;
399cdf0e10cSrcweir sal_Bool bCntAtPos = sal_False;
400cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
401cdf0e10cSrcweir rSh.IsCrsrReadonly();
402cdf0e10cSrcweir aActHitType = SDRHIT_NONE;
403cdf0e10cSrcweir PointerStyle eStyle = POINTER_TEXT;
404cdf0e10cSrcweir if ( !pSdrView )
405cdf0e10cSrcweir bCntAtPos = sal_True;
406cdf0e10cSrcweir else if ( sal_True == (bHitHandle = pSdrView->PickHandle( rLPt ) != 0) )
407cdf0e10cSrcweir {
408cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT;
409cdf0e10cSrcweir bPrefSdrPointer = sal_True;
410cdf0e10cSrcweir }
411cdf0e10cSrcweir else
412cdf0e10cSrcweir {
413cdf0e10cSrcweir const sal_Bool bNotInSelObj = !rSh.IsInsideSelectedObj( rLPt );
414cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && !bInsDraw && bNotInSelObj )
415cdf0e10cSrcweir {
416cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT;
417cdf0e10cSrcweir if (IsObjectSelect())
418cdf0e10cSrcweir eStyle = POINTER_ARROW;
419cdf0e10cSrcweir else
420cdf0e10cSrcweir bPrefSdrPointer = sal_True;
421cdf0e10cSrcweir }
422cdf0e10cSrcweir else
423cdf0e10cSrcweir {
424cdf0e10cSrcweir SdrObject* pObj; SdrPageView* pPV;
425cdf0e10cSrcweir pSdrView->SetHitTolerancePixel( HIT_PIX );
426cdf0e10cSrcweir if ( bNotInSelObj && bExecHyperlinks &&
427cdf0e10cSrcweir pSdrView->PickObj( rLPt, pSdrView->getHitTolLog(), pObj, pPV, SDRSEARCH_PICKMACRO ))
428cdf0e10cSrcweir {
429cdf0e10cSrcweir SdrObjMacroHitRec aTmp;
430cdf0e10cSrcweir aTmp.aPos = rLPt;
431cdf0e10cSrcweir aTmp.pPageView = pPV;
432cdf0e10cSrcweir SetPointer( pObj->GetMacroPointer( aTmp ) );
433cdf0e10cSrcweir return;
434cdf0e10cSrcweir }
435cdf0e10cSrcweir else
436cdf0e10cSrcweir {
437cdf0e10cSrcweir // dvo: IsObjSelectable() eventually calls SdrView::PickObj, so
438cdf0e10cSrcweir // apparently this is used to determine whether this is a
439cdf0e10cSrcweir // drawling layer object or not.
440cdf0e10cSrcweir if ( rSh.IsObjSelectable( rLPt ) )
441cdf0e10cSrcweir {
442cdf0e10cSrcweir if (pSdrView->IsTextEdit())
443cdf0e10cSrcweir {
444cdf0e10cSrcweir aActHitType = SDRHIT_NONE;
445cdf0e10cSrcweir bPrefSdrPointer = sal_True;
446cdf0e10cSrcweir }
447cdf0e10cSrcweir else
448cdf0e10cSrcweir {
449cdf0e10cSrcweir SdrViewEvent aVEvt;
450cdf0e10cSrcweir SdrHitKind eHit = pSdrView->PickAnything(rLPt, aVEvt);
451cdf0e10cSrcweir
452cdf0e10cSrcweir if (eHit == SDRHIT_URLFIELD && bExecHyperlinks)
453cdf0e10cSrcweir {
454cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT;
455cdf0e10cSrcweir bPrefSdrPointer = sal_True;
456cdf0e10cSrcweir }
457cdf0e10cSrcweir else
458cdf0e10cSrcweir {
459cdf0e10cSrcweir // if we're over a selected object, we show an
460cdf0e10cSrcweir // ARROW by default. We only show a MOVE if 1) the
461cdf0e10cSrcweir // object is selected, and 2) it may be moved
462cdf0e10cSrcweir // (i.e., position is not protected).
463cdf0e10cSrcweir bool bMovable =
464cdf0e10cSrcweir (!bNotInSelObj) &&
465cdf0e10cSrcweir (rSh.IsObjSelected() || rSh.IsFrmSelected()) &&
466cdf0e10cSrcweir (!rSh.IsSelObjProtected(FLYPROTECT_POS));
467cdf0e10cSrcweir
468cdf0e10cSrcweir eStyle = bMovable ? POINTER_MOVE : POINTER_ARROW;
469cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT;
470cdf0e10cSrcweir }
471cdf0e10cSrcweir }
472cdf0e10cSrcweir }
473cdf0e10cSrcweir else
474cdf0e10cSrcweir {
475cdf0e10cSrcweir if ( rSh.IsFrmSelected() && !bNotInSelObj )
476cdf0e10cSrcweir {
477cdf0e10cSrcweir // dvo: this branch appears to be dead and should be
478cdf0e10cSrcweir // removed in a future version. Reason: The condition
479cdf0e10cSrcweir // !bNotInSelObj means that this branch will only be
480cdf0e10cSrcweir // executed in the cursor points inside a selected
481cdf0e10cSrcweir // object. However, if this is the case, the previous
482cdf0e10cSrcweir // if( rSh.IsObjSelectable(rLPt) ) must always be true:
483cdf0e10cSrcweir // rLPt is inside a selected object, then obviously
484cdf0e10cSrcweir // rLPt is over a selectable object.
485cdf0e10cSrcweir if (rSh.IsSelObjProtected(FLYPROTECT_SIZE))
486cdf0e10cSrcweir eStyle = POINTER_NOTALLOWED;
487cdf0e10cSrcweir else
488cdf0e10cSrcweir eStyle = POINTER_MOVE;
489cdf0e10cSrcweir aActHitType = SDRHIT_OBJECT;
490cdf0e10cSrcweir }
491cdf0e10cSrcweir else
492cdf0e10cSrcweir {
493cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() )
494cdf0e10cSrcweir bPrefSdrPointer = sal_True;
495cdf0e10cSrcweir else
496cdf0e10cSrcweir bCntAtPos = sal_True;
497cdf0e10cSrcweir }
498cdf0e10cSrcweir }
499cdf0e10cSrcweir }
500cdf0e10cSrcweir }
501cdf0e10cSrcweir }
502cdf0e10cSrcweir if ( bPrefSdrPointer )
503cdf0e10cSrcweir {
504cdf0e10cSrcweir if (bIsDocReadOnly || (rSh.IsObjSelected() && rSh.IsSelObjProtected(FLYPROTECT_CONTENT)))
505cdf0e10cSrcweir SetPointer( POINTER_NOTALLOWED );
506cdf0e10cSrcweir else
507cdf0e10cSrcweir {
508cdf0e10cSrcweir if (rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->IsInsertForm() && !bHitHandle)
509cdf0e10cSrcweir SetPointer( POINTER_DRAW_RECT );
510cdf0e10cSrcweir else
511cdf0e10cSrcweir SetPointer( pSdrView->GetPreferedPointer( rLPt, rSh.GetOut() ) );
512cdf0e10cSrcweir }
513cdf0e10cSrcweir }
514cdf0e10cSrcweir else
515cdf0e10cSrcweir {
516cdf0e10cSrcweir if( !rSh.IsPageAtPos( rLPt ) || pAnchorMarker )
517cdf0e10cSrcweir eStyle = POINTER_ARROW;
518cdf0e10cSrcweir else
519cdf0e10cSrcweir {
520cdf0e10cSrcweir if( bCntAtPos )
521cdf0e10cSrcweir {
522cdf0e10cSrcweir SwContentAtPos aSwContentAtPos(
523cdf0e10cSrcweir SwContentAtPos::SW_CLICKFIELD|
524cdf0e10cSrcweir SwContentAtPos::SW_INETATTR|
525cdf0e10cSrcweir SwContentAtPos::SW_FTN |
526cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG );
527cdf0e10cSrcweir if( rSh.GetContentAtPos( rLPt, aSwContentAtPos) )
528cdf0e10cSrcweir {
529cdf0e10cSrcweir const bool bClickToFollow = SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos ||
530cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos;
531cdf0e10cSrcweir
532cdf0e10cSrcweir if( !bClickToFollow ||
533cdf0e10cSrcweir (SwContentAtPos::SW_INETATTR == aSwContentAtPos.eCntntAtPos && bExecHyperlinks) ||
534cdf0e10cSrcweir (SwContentAtPos::SW_SMARTTAG == aSwContentAtPos.eCntntAtPos && bExecSmarttags) )
535cdf0e10cSrcweir eStyle = POINTER_REFHAND;
536cdf0e10cSrcweir }
537cdf0e10cSrcweir }
538cdf0e10cSrcweir }
539cdf0e10cSrcweir
540cdf0e10cSrcweir // which kind of text pointer have we to show - horz / vert - ?
541cdf0e10cSrcweir if( POINTER_TEXT == eStyle && rSh.IsInVerticalText( &rLPt ))
542cdf0e10cSrcweir eStyle = POINTER_TEXT_VERTICAL;
543cdf0e10cSrcweir
544cdf0e10cSrcweir SetPointer( eStyle );
545cdf0e10cSrcweir }
546cdf0e10cSrcweir }
547cdf0e10cSrcweir
548cdf0e10cSrcweir /*--------------------------------------------------------------------
549cdf0e10cSrcweir Beschreibung: Timer fuer Selektion vergroessern
550cdf0e10cSrcweir --------------------------------------------------------------------*/
551cdf0e10cSrcweir
552cdf0e10cSrcweir
IMPL_LINK(SwEditWin,TimerHandler,Timer *,EMPTYARG)553cdf0e10cSrcweir IMPL_LINK( SwEditWin, TimerHandler, Timer *, EMPTYARG )
554cdf0e10cSrcweir {
555cdf0e10cSrcweir DBG_PROFSTART(edithdl);
556cdf0e10cSrcweir
557cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
558cdf0e10cSrcweir Point aModPt( aMovePos );
559cdf0e10cSrcweir const SwRect aOldVis( rSh.VisArea() );
560cdf0e10cSrcweir sal_Bool bDone = sal_False;
561cdf0e10cSrcweir
562cdf0e10cSrcweir if ( !rSh.VisArea().IsInside( aModPt ) )
563cdf0e10cSrcweir {
564cdf0e10cSrcweir if ( bInsDraw )
565cdf0e10cSrcweir {
566cdf0e10cSrcweir const int nMaxScroll = 40;
567cdf0e10cSrcweir rView.Scroll( Rectangle(aModPt,Size(1,1)), nMaxScroll, nMaxScroll);
568cdf0e10cSrcweir bDone = sal_True;
569cdf0e10cSrcweir }
570cdf0e10cSrcweir else if ( bFrmDrag )
571cdf0e10cSrcweir {
572cdf0e10cSrcweir (rSh.*rSh.fnDrag)(&aModPt,sal_False);
573cdf0e10cSrcweir bDone = sal_True;
574cdf0e10cSrcweir }
575cdf0e10cSrcweir if ( !bDone )
576cdf0e10cSrcweir aModPt = rSh.GetCntntPos( aModPt,aModPt.Y() > rSh.VisArea().Bottom() );
577cdf0e10cSrcweir }
578cdf0e10cSrcweir if ( !bDone && !(bFrmDrag || bInsDraw) )
579cdf0e10cSrcweir {
580cdf0e10cSrcweir if ( pRowColumnSelectionStart )
581cdf0e10cSrcweir {
582cdf0e10cSrcweir Point aPos( aModPt );
583cdf0e10cSrcweir rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag );
584cdf0e10cSrcweir }
585cdf0e10cSrcweir else
586cdf0e10cSrcweir (rSh.*rSh.fnSetCrsr)( &aModPt, sal_False );
587cdf0e10cSrcweir
588cdf0e10cSrcweir //fix(24138): Es kann sein, dass der "Sprung" ueber eine Tabelle so
589cdf0e10cSrcweir //nicht geschafft wird. Deshalb wir hier eben per Up/Down ueber die
590cdf0e10cSrcweir //Tabelle gesprungen.
591cdf0e10cSrcweir const SwRect& rVisArea = rSh.VisArea();
592cdf0e10cSrcweir if( aOldVis == rVisArea && !rSh.IsStartOfDoc() && !rSh.IsEndOfDoc() )
593cdf0e10cSrcweir {
594cdf0e10cSrcweir //JP 11.10.2001 Bug 72294 - take the center point of VisArea to
595cdf0e10cSrcweir // decide in which direction the user want.
596cdf0e10cSrcweir if( aModPt.Y() < ( rVisArea.Top() + rVisArea.Height() / 2 ) )
597cdf0e10cSrcweir rSh.Up( sal_True, 1 );
598cdf0e10cSrcweir else
599cdf0e10cSrcweir rSh.Down( sal_True, 1 );
600cdf0e10cSrcweir }
601cdf0e10cSrcweir }
602cdf0e10cSrcweir
603cdf0e10cSrcweir aMovePos += rSh.VisArea().Pos() - aOldVis.Pos();
604cdf0e10cSrcweir JustifyAreaTimer();
605cdf0e10cSrcweir DBG_PROFSTOP(edithdl);
606cdf0e10cSrcweir return 0;
607cdf0e10cSrcweir }
608cdf0e10cSrcweir
609cdf0e10cSrcweir /*--------------------------------------------------------------------
610cdf0e10cSrcweir Beschreibung:
611cdf0e10cSrcweir --------------------------------------------------------------------*/
612cdf0e10cSrcweir
613cdf0e10cSrcweir
JustifyAreaTimer()614cdf0e10cSrcweir void SwEditWin::JustifyAreaTimer()
615cdf0e10cSrcweir {
616cdf0e10cSrcweir const Rectangle &rVisArea = GetView().GetVisArea();
617cdf0e10cSrcweir #ifdef UNX
618cdf0e10cSrcweir const long coMinLen = 100;
619cdf0e10cSrcweir #else
620cdf0e10cSrcweir const long coMinLen = 50;
621cdf0e10cSrcweir #endif
622cdf0e10cSrcweir long nTimeout = 800,
623cdf0e10cSrcweir nDiff = Max(
624cdf0e10cSrcweir Max( aMovePos.Y() - rVisArea.Bottom(), rVisArea.Top() - aMovePos.Y() ),
625cdf0e10cSrcweir Max( aMovePos.X() - rVisArea.Right(), rVisArea.Left() - aMovePos.X()));
626cdf0e10cSrcweir aTimer.SetTimeout( Max( coMinLen, nTimeout - nDiff) );
627cdf0e10cSrcweir }
628cdf0e10cSrcweir
LeaveArea(const Point & rPos)629cdf0e10cSrcweir void SwEditWin::LeaveArea(const Point &rPos)
630cdf0e10cSrcweir {
631cdf0e10cSrcweir aMovePos = rPos;
632cdf0e10cSrcweir JustifyAreaTimer();
633cdf0e10cSrcweir if( !aTimer.IsActive() )
634cdf0e10cSrcweir aTimer.Start();
635cdf0e10cSrcweir if( pShadCrsr )
636cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
637cdf0e10cSrcweir }
638cdf0e10cSrcweir
EnterArea()639cdf0e10cSrcweir inline void SwEditWin::EnterArea()
640cdf0e10cSrcweir {
641cdf0e10cSrcweir aTimer.Stop();
642cdf0e10cSrcweir }
643cdf0e10cSrcweir
644cdf0e10cSrcweir /*------------------------------------------------------------------------
645cdf0e10cSrcweir Beschreibung: Modus fuer Rahmen einfuegen
646cdf0e10cSrcweir ------------------------------------------------------------------------*/
647cdf0e10cSrcweir
648cdf0e10cSrcweir
InsFrm(sal_uInt16 nCols)649cdf0e10cSrcweir void SwEditWin::InsFrm(sal_uInt16 nCols)
650cdf0e10cSrcweir {
651cdf0e10cSrcweir StdDrawMode( OBJ_NONE, sal_False );
652cdf0e10cSrcweir bInsFrm = sal_True;
653cdf0e10cSrcweir nInsFrmColCount = nCols;
654cdf0e10cSrcweir }
655cdf0e10cSrcweir
656cdf0e10cSrcweir
657cdf0e10cSrcweir
StdDrawMode(SdrObjKind eSdrObjectKind,sal_Bool bObjSelect)658cdf0e10cSrcweir void SwEditWin::StdDrawMode( SdrObjKind eSdrObjectKind, sal_Bool bObjSelect )
659cdf0e10cSrcweir {
660cdf0e10cSrcweir SetSdrDrawMode( eSdrObjectKind );
661cdf0e10cSrcweir
662cdf0e10cSrcweir if (bObjSelect)
663cdf0e10cSrcweir rView.SetDrawFuncPtr(new DrawSelection( &rView.GetWrtShell(), this, &rView ));
664cdf0e10cSrcweir else
665cdf0e10cSrcweir rView.SetDrawFuncPtr(new SwDrawBase( &rView.GetWrtShell(), this, &rView ));
666cdf0e10cSrcweir
667cdf0e10cSrcweir rView.SetSelDrawSlot();
668cdf0e10cSrcweir SetSdrDrawMode( eSdrObjectKind );
669cdf0e10cSrcweir if (bObjSelect)
670cdf0e10cSrcweir rView.GetDrawFuncPtr()->Activate( SID_OBJECT_SELECT );
671cdf0e10cSrcweir else
672cdf0e10cSrcweir rView.GetDrawFuncPtr()->Activate( sal::static_int_cast< sal_uInt16 >(eSdrObjectKind) ); // don't know if this is useful at all; but it keeps functionality as it was...
673cdf0e10cSrcweir bInsFrm = sal_False;
674cdf0e10cSrcweir nInsFrmColCount = 1;
675cdf0e10cSrcweir }
676cdf0e10cSrcweir
677cdf0e10cSrcweir
678cdf0e10cSrcweir
StopInsFrm()679cdf0e10cSrcweir void SwEditWin::StopInsFrm()
680cdf0e10cSrcweir {
681cdf0e10cSrcweir if (rView.GetDrawFuncPtr())
682cdf0e10cSrcweir {
683cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
684cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
685cdf0e10cSrcweir }
686cdf0e10cSrcweir rView.LeaveDrawCreate(); // Konstruktionsmode verlassen
687cdf0e10cSrcweir bInsFrm = sal_False;
688cdf0e10cSrcweir nInsFrmColCount = 1;
689cdf0e10cSrcweir }
690cdf0e10cSrcweir
691cdf0e10cSrcweir /*--------------------------------------------------------------------
692cdf0e10cSrcweir --------------------------------------------------------------------*/
693cdf0e10cSrcweir
694cdf0e10cSrcweir
IsInputSequenceCheckingRequired(const String & rText,const SwPaM & rCrsr) const695cdf0e10cSrcweir sal_Bool SwEditWin::IsInputSequenceCheckingRequired( const String &rText, const SwPaM& rCrsr ) const
696cdf0e10cSrcweir {
697cdf0e10cSrcweir const SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions();
698cdf0e10cSrcweir if ( !rCTLOptions.IsCTLFontEnabled() ||
699cdf0e10cSrcweir !rCTLOptions.IsCTLSequenceChecking() )
700cdf0e10cSrcweir return sal_False;
701cdf0e10cSrcweir
702cdf0e10cSrcweir const xub_StrLen nFirstPos = rCrsr.Start()->nContent.GetIndex();
703cdf0e10cSrcweir if ( 0 == nFirstPos ) /* first char needs not to be checked */
704cdf0e10cSrcweir return sal_False;
705cdf0e10cSrcweir
706cdf0e10cSrcweir SwBreakIt *pBreakIter = SwBreakIt::Get();
707cdf0e10cSrcweir uno::Reference < i18n::XBreakIterator > xBI = pBreakIter->GetBreakIter();
708cdf0e10cSrcweir long nCTLScriptPos = -1;
709cdf0e10cSrcweir
710cdf0e10cSrcweir if (xBI.is())
711cdf0e10cSrcweir {
712cdf0e10cSrcweir if (xBI->getScriptType( rText, 0 ) == i18n::ScriptType::COMPLEX)
713cdf0e10cSrcweir nCTLScriptPos = 0;
714cdf0e10cSrcweir else
715cdf0e10cSrcweir nCTLScriptPos = xBI->nextScript( rText, 0, i18n::ScriptType::COMPLEX );
716cdf0e10cSrcweir }
717cdf0e10cSrcweir
718cdf0e10cSrcweir return (0 <= nCTLScriptPos && nCTLScriptPos <= rText.Len());
719cdf0e10cSrcweir }
720cdf0e10cSrcweir
721cdf0e10cSrcweir
722cdf0e10cSrcweir /*--------------------------------------------------------------------
723cdf0e10cSrcweir Beschreibung: Der Character Buffer wird in das Dokument eingefuegt
724cdf0e10cSrcweir --------------------------------------------------------------------*/
725cdf0e10cSrcweir
726cdf0e10cSrcweir
FlushInBuffer()727cdf0e10cSrcweir void SwEditWin::FlushInBuffer()
728cdf0e10cSrcweir {
729cdf0e10cSrcweir if ( aInBuffer.Len() )
730cdf0e10cSrcweir {
731cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell();
732cdf0e10cSrcweir
733cdf0e10cSrcweir // generate new sequence input checker if not already done
734cdf0e10cSrcweir if ( !pCheckIt )
735cdf0e10cSrcweir pCheckIt = new SwCheckIt;
736cdf0e10cSrcweir
737cdf0e10cSrcweir uno::Reference < i18n::XExtendedInputSequenceChecker > xISC = pCheckIt->xCheck;
738cdf0e10cSrcweir if ( xISC.is() && IsInputSequenceCheckingRequired( aInBuffer, *rSh.GetCrsr() ) )
739cdf0e10cSrcweir {
740cdf0e10cSrcweir //
741cdf0e10cSrcweir // apply (Thai) input sequence checking/correction
742cdf0e10cSrcweir //
743cdf0e10cSrcweir
744cdf0e10cSrcweir rSh.Push(); // push current cursor to stack
745cdf0e10cSrcweir
746cdf0e10cSrcweir // get text from the beginning (i.e left side) of current selection
747cdf0e10cSrcweir // to the start of the paragraph
748cdf0e10cSrcweir rSh.NormalizePam(); // make point be the first (left) one
749cdf0e10cSrcweir if (!rSh.GetCrsr()->HasMark())
750cdf0e10cSrcweir rSh.GetCrsr()->SetMark();
751cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = 0;
752cdf0e10cSrcweir String aLeftText( rSh.GetCrsr()->GetTxt() );
753cdf0e10cSrcweir
754cdf0e10cSrcweir SvtCTLOptions& rCTLOptions = SW_MOD()->GetCTLOptions();
755cdf0e10cSrcweir
756cdf0e10cSrcweir xub_StrLen nExpandSelection = 0;
757cdf0e10cSrcweir if (aLeftText.Len() > 0)
758cdf0e10cSrcweir {
759cdf0e10cSrcweir sal_Unicode cChar = '\0';
760cdf0e10cSrcweir
761cdf0e10cSrcweir xub_StrLen nTmpPos = aLeftText.Len();
762cdf0e10cSrcweir sal_Int16 nCheckMode = rCTLOptions.IsCTLSequenceCheckingRestricted() ?
763cdf0e10cSrcweir i18n::InputSequenceCheckMode::STRICT : i18n::InputSequenceCheckMode::BASIC;
764cdf0e10cSrcweir
765cdf0e10cSrcweir rtl::OUString aOldText( aLeftText );
766cdf0e10cSrcweir rtl::OUString aNewText( aOldText );
767cdf0e10cSrcweir if (rCTLOptions.IsCTLSequenceCheckingTypeAndReplace())
768cdf0e10cSrcweir {
769cdf0e10cSrcweir for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k)
770cdf0e10cSrcweir {
771cdf0e10cSrcweir cChar = aInBuffer.GetChar(k);
772cdf0e10cSrcweir const xub_StrLen nPrevPos = static_cast<xub_StrLen>(xISC->correctInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode ));
773cdf0e10cSrcweir
774cdf0e10cSrcweir // valid sequence or sequence could be corrected:
775cdf0e10cSrcweir if (nPrevPos != aNewText.getLength())
776cdf0e10cSrcweir nTmpPos = nPrevPos + 1;
777cdf0e10cSrcweir }
778cdf0e10cSrcweir
779cdf0e10cSrcweir // find position of first character that has changed
780cdf0e10cSrcweir sal_Int32 nOldLen = aOldText.getLength();
781cdf0e10cSrcweir sal_Int32 nNewLen = aNewText.getLength();
782cdf0e10cSrcweir const sal_Unicode *pOldTxt = aOldText.getStr();
783cdf0e10cSrcweir const sal_Unicode *pNewTxt = aNewText.getStr();
784cdf0e10cSrcweir sal_Int32 nChgPos = 0;
785cdf0e10cSrcweir while ( nChgPos < nOldLen && nChgPos < nNewLen &&
786cdf0e10cSrcweir pOldTxt[nChgPos] == pNewTxt[nChgPos] )
787cdf0e10cSrcweir ++nChgPos;
788cdf0e10cSrcweir
789cdf0e10cSrcweir xub_StrLen nChgLen = static_cast< xub_StrLen >(nNewLen - nChgPos);
790cdf0e10cSrcweir String aChgText( aNewText.copy( static_cast< xub_StrLen >(nChgPos), nChgLen ) );
791cdf0e10cSrcweir
792cdf0e10cSrcweir if (aChgText.Len())
793cdf0e10cSrcweir {
794cdf0e10cSrcweir aInBuffer = aChgText;
795cdf0e10cSrcweir nExpandSelection = aLeftText.Len() - static_cast< xub_StrLen >(nChgPos);
796cdf0e10cSrcweir }
797cdf0e10cSrcweir else
798cdf0e10cSrcweir aInBuffer.Erase();
799cdf0e10cSrcweir }
800cdf0e10cSrcweir else
801cdf0e10cSrcweir {
802cdf0e10cSrcweir for (xub_StrLen k = 0; k < aInBuffer.Len(); ++k)
803cdf0e10cSrcweir {
804cdf0e10cSrcweir cChar = aInBuffer.GetChar(k);
805cdf0e10cSrcweir if (xISC->checkInputSequence( aNewText, nTmpPos - 1, cChar, nCheckMode ))
806cdf0e10cSrcweir {
807cdf0e10cSrcweir // character can be inserted:
808cdf0e10cSrcweir aNewText += rtl::OUString( (sal_Unicode) cChar );
809cdf0e10cSrcweir ++nTmpPos;
810cdf0e10cSrcweir }
811cdf0e10cSrcweir }
812cdf0e10cSrcweir aInBuffer = aNewText.copy( aOldText.getLength() ); // copy new text to be inserted to buffer
813cdf0e10cSrcweir }
814cdf0e10cSrcweir }
815cdf0e10cSrcweir
816cdf0e10cSrcweir // at this point now we will insert the buffer text 'normally' some lines below...
817cdf0e10cSrcweir
818cdf0e10cSrcweir rSh.Pop( sal_False ); // pop old cursor from stack
819cdf0e10cSrcweir
820cdf0e10cSrcweir if (!aInBuffer.Len())
821cdf0e10cSrcweir return;
822cdf0e10cSrcweir
823cdf0e10cSrcweir // if text prior to the original selection needs to be changed
824cdf0e10cSrcweir // as well, we now expand the selection accordingly.
825cdf0e10cSrcweir SwPaM &rCrsr = *rSh.GetCrsr();
826cdf0e10cSrcweir xub_StrLen nCrsrStartPos = rCrsr.Start()->nContent.GetIndex();
827cdf0e10cSrcweir DBG_ASSERT( nCrsrStartPos >= nExpandSelection, "cannot expand selection as specified!!" );
828cdf0e10cSrcweir if (nExpandSelection && nCrsrStartPos >= nExpandSelection)
829cdf0e10cSrcweir {
830cdf0e10cSrcweir if (!rCrsr.HasMark())
831cdf0e10cSrcweir rCrsr.SetMark();
832cdf0e10cSrcweir rCrsr.Start()->nContent -= nExpandSelection;
833cdf0e10cSrcweir }
834cdf0e10cSrcweir }
835cdf0e10cSrcweir
836cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder =
837cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder();
838cdf0e10cSrcweir if ( xRecorder.is() )
839cdf0e10cSrcweir {
840cdf0e10cSrcweir //Shell ermitteln
841cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
842cdf0e10cSrcweir // Request generieren und recorden
843cdf0e10cSrcweir if (pSfxShell)
844cdf0e10cSrcweir {
845cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING );
846cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, aInBuffer ) );
847cdf0e10cSrcweir aReq.Done();
848cdf0e10cSrcweir }
849cdf0e10cSrcweir }
850cdf0e10cSrcweir //#21019# apply CTL and CJK language to the text input
851cdf0e10cSrcweir sal_Bool bLang = true;
852cdf0e10cSrcweir if(eBufferLanguage != LANGUAGE_DONTKNOW)
853cdf0e10cSrcweir {
854cdf0e10cSrcweir sal_uInt16 nWhich = 0;
855cdf0e10cSrcweir switch( GetI18NScriptTypeOfLanguage( eBufferLanguage ))
856cdf0e10cSrcweir {
857cdf0e10cSrcweir case i18n::ScriptType::ASIAN: nWhich = RES_CHRATR_CJK_LANGUAGE; break;
858cdf0e10cSrcweir case i18n::ScriptType::COMPLEX: nWhich = RES_CHRATR_CTL_LANGUAGE; break;
859cdf0e10cSrcweir case i18n::ScriptType::LATIN: nWhich = RES_CHRATR_LANGUAGE; break;
860cdf0e10cSrcweir default: bLang = sal_False;
861cdf0e10cSrcweir }
862cdf0e10cSrcweir if(bLang)
863cdf0e10cSrcweir {
864cdf0e10cSrcweir SfxItemSet aLangSet(rView.GetPool(), nWhich, nWhich);
865cdf0e10cSrcweir rSh.GetCurAttr(aLangSet);
866cdf0e10cSrcweir if(SFX_ITEM_DEFAULT <= aLangSet.GetItemState(nWhich, sal_True))
867cdf0e10cSrcweir {
868cdf0e10cSrcweir LanguageType eLang = static_cast<const SvxLanguageItem&>(aLangSet.Get(nWhich)).GetLanguage();
869cdf0e10cSrcweir if ( eLang == eBufferLanguage )
870cdf0e10cSrcweir // current language attribute equal to language reported from system
871cdf0e10cSrcweir bLang = sal_False;
872cdf0e10cSrcweir else if ( !bInputLanguageSwitched && RES_CHRATR_LANGUAGE == nWhich /* && (eLang&LANGUAGE_MASK_PRIMARY) == LANGUAGE_ENGLISH */ )
873cdf0e10cSrcweir {
874cdf0e10cSrcweir // special case: switching between two "LATIN" languages
875cdf0e10cSrcweir // In case the current keyboard setting might be suitable for both languages we can't safely assume that the user
876cdf0e10cSrcweir // wants to use the language reported from the system, except if we knew that it was explicitly switched (thus the check for "bInputLangeSwitched").
877cdf0e10cSrcweir // The language reported by the system could be just the system default language that the user is not even aware of,
878cdf0e10cSrcweir // because no language selection tool is installed at all. In this case the OOo language should get preference as
879cdf0e10cSrcweir // it might have been selected by the user explicitly.
880cdf0e10cSrcweir // Usually this case happens if the OOo language is different to the system language but the system keyboard is still suitable
881cdf0e10cSrcweir // for the OOo language (e.g. writing English texts with a German keyboard).
882cdf0e10cSrcweir // For non-latin keyboards overwriting the attribute is still valid. We do this for kyrillic and greek ATM.
883cdf0e10cSrcweir // In future versions of OOo this should be replaced by a configuration switch that allows to give the preference to
884cdf0e10cSrcweir // the OOo setting or the system setting explicitly and/or a better handling of the script type.
885cdf0e10cSrcweir sal_Int16 nScript = GetAppCharClass().getScript( aInBuffer, 0 );
886cdf0e10cSrcweir i18n::UnicodeScript eType = (i18n::UnicodeScript) nScript;
887cdf0e10cSrcweir
888cdf0e10cSrcweir bool bSystemIsNonLatin = false, bOOoLangIsNonLatin = false;
889cdf0e10cSrcweir switch ( eType )
890cdf0e10cSrcweir {
891cdf0e10cSrcweir case i18n::UnicodeScript_kGreek:
892cdf0e10cSrcweir case i18n::UnicodeScript_kCyrillic:
893cdf0e10cSrcweir // in case other UnicodeScripts require special keyboards they can be added here
894cdf0e10cSrcweir bSystemIsNonLatin = true;
895cdf0e10cSrcweir break;
896cdf0e10cSrcweir default:
897cdf0e10cSrcweir break;
898cdf0e10cSrcweir }
899cdf0e10cSrcweir
900cdf0e10cSrcweir switch ( eLang )
901cdf0e10cSrcweir {
902cdf0e10cSrcweir case LANGUAGE_AZERI_CYRILLIC:
903cdf0e10cSrcweir case LANGUAGE_BOSNIAN_CYRILLIC_BOSNIA_HERZEGOVINA:
904cdf0e10cSrcweir case LANGUAGE_BULGARIAN:
905cdf0e10cSrcweir case LANGUAGE_GREEK:
906cdf0e10cSrcweir case LANGUAGE_RUSSIAN:
907cdf0e10cSrcweir case LANGUAGE_RUSSIAN_MOLDOVA:
908cdf0e10cSrcweir case LANGUAGE_SERBIAN_CYRILLIC:
909cdf0e10cSrcweir case LANGUAGE_SERBIAN_CYRILLIC_BOSNIA_HERZEGOVINA:
910cdf0e10cSrcweir case LANGUAGE_UZBEK_CYRILLIC:
911cdf0e10cSrcweir case LANGUAGE_UKRAINIAN:
912cdf0e10cSrcweir case LANGUAGE_BELARUSIAN:
913cdf0e10cSrcweir bOOoLangIsNonLatin = true;
914cdf0e10cSrcweir break;
915cdf0e10cSrcweir default:
916cdf0e10cSrcweir break;
917cdf0e10cSrcweir }
918cdf0e10cSrcweir
919cdf0e10cSrcweir bLang = (bSystemIsNonLatin != bOOoLangIsNonLatin);
920cdf0e10cSrcweir }
921cdf0e10cSrcweir }
922cdf0e10cSrcweir if(bLang)
923cdf0e10cSrcweir {
924cdf0e10cSrcweir SvxLanguageItem aLangItem( eBufferLanguage, nWhich );
92569a74367SOliver-Rainer Wittmann rSh.SetAttrItem( aLangItem );
926cdf0e10cSrcweir }
927cdf0e10cSrcweir }
928cdf0e10cSrcweir }
929cdf0e10cSrcweir
930cdf0e10cSrcweir rSh.Insert( aInBuffer );
931cdf0e10cSrcweir eBufferLanguage = LANGUAGE_DONTKNOW;
932cdf0e10cSrcweir aInBuffer.Erase();
933cdf0e10cSrcweir bFlushCharBuffer = sal_False;
934cdf0e10cSrcweir }
935cdf0e10cSrcweir }
936cdf0e10cSrcweir
937cdf0e10cSrcweir #define MOVE_LEFT_SMALL 0
938cdf0e10cSrcweir #define MOVE_UP_SMALL 1
939cdf0e10cSrcweir #define MOVE_RIGHT_BIG 2
940cdf0e10cSrcweir #define MOVE_DOWN_BIG 3
941cdf0e10cSrcweir #define MOVE_LEFT_BIG 4
942cdf0e10cSrcweir #define MOVE_UP_BIG 5
943cdf0e10cSrcweir #define MOVE_RIGHT_SMALL 6
944cdf0e10cSrcweir #define MOVE_DOWN_SMALL 7
945cdf0e10cSrcweir
94693641701SArmin Le Grand // #121236# Support for shift key in writer
94793641701SArmin Le Grand #define MOVE_LEFT_HUGE 8
94893641701SArmin Le Grand #define MOVE_UP_HUGE 9
94993641701SArmin Le Grand #define MOVE_RIGHT_HUGE 10
95093641701SArmin Le Grand #define MOVE_DOWN_HUGE 11
95193641701SArmin Le Grand
ChangeFly(sal_uInt8 nDir,sal_Bool bWeb)952cdf0e10cSrcweir void SwEditWin::ChangeFly( sal_uInt8 nDir, sal_Bool bWeb )
953cdf0e10cSrcweir {
954cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
955cdf0e10cSrcweir SwRect aTmp = rSh.GetFlyRect();
956cdf0e10cSrcweir if( aTmp.HasArea() &&
957aa2af2f2SOliver-Rainer Wittmann !rSh.IsSelObjProtected( FLYPROTECT_POS ) )
958cdf0e10cSrcweir {
959cdf0e10cSrcweir SfxItemSet aSet(rSh.GetAttrPool(),
960cdf0e10cSrcweir RES_FRM_SIZE, RES_FRM_SIZE,
961cdf0e10cSrcweir RES_VERT_ORIENT, RES_ANCHOR,
962cdf0e10cSrcweir RES_COL, RES_COL,
963cdf0e10cSrcweir RES_PROTECT, RES_PROTECT,
964cdf0e10cSrcweir RES_FOLLOW_TEXT_FLOW, RES_FOLLOW_TEXT_FLOW, 0);
965cdf0e10cSrcweir rSh.GetFlyFrmAttr( aSet );
966cdf0e10cSrcweir RndStdIds eAnchorId = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetAnchorId();
967cdf0e10cSrcweir Size aSnap;
96893641701SArmin Le Grand bool bHuge(MOVE_LEFT_HUGE == nDir ||
96993641701SArmin Le Grand MOVE_UP_HUGE == nDir ||
97093641701SArmin Le Grand MOVE_RIGHT_HUGE == nDir ||
97193641701SArmin Le Grand MOVE_DOWN_HUGE == nDir);
97293641701SArmin Le Grand
973cdf0e10cSrcweir if(MOVE_LEFT_SMALL == nDir ||
974cdf0e10cSrcweir MOVE_UP_SMALL == nDir ||
975cdf0e10cSrcweir MOVE_RIGHT_SMALL == nDir ||
976cdf0e10cSrcweir MOVE_DOWN_SMALL == nDir )
97793641701SArmin Le Grand {
978cdf0e10cSrcweir aSnap = PixelToLogic(Size(1,1));
97993641701SArmin Le Grand }
980cdf0e10cSrcweir else
981cdf0e10cSrcweir {
982cdf0e10cSrcweir aSnap = rSh.GetViewOptions()->GetSnapSize();
983cdf0e10cSrcweir short nDiv = rSh.GetViewOptions()->GetDivisionX();
984cdf0e10cSrcweir if ( nDiv > 0 )
985cdf0e10cSrcweir aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv );
986cdf0e10cSrcweir nDiv = rSh.GetViewOptions()->GetDivisionY();
987cdf0e10cSrcweir if ( nDiv > 0 )
988cdf0e10cSrcweir aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv );
989cdf0e10cSrcweir }
990cdf0e10cSrcweir
99193641701SArmin Le Grand if(bHuge)
99293641701SArmin Le Grand {
99393641701SArmin Le Grand // #121236# 567twips == 1cm, but just take three times the normal snap
99493641701SArmin Le Grand aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
99593641701SArmin Le Grand }
99693641701SArmin Le Grand
997cdf0e10cSrcweir SwRect aBoundRect;
998cdf0e10cSrcweir Point aRefPoint;
999cdf0e10cSrcweir {
1000cdf0e10cSrcweir SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) );
1001cdf0e10cSrcweir const bool bFollowTextFlow =
1002cdf0e10cSrcweir static_cast<const SwFmtFollowTextFlow&>(aSet.Get(RES_FOLLOW_TEXT_FLOW)).GetValue();
1003cdf0e10cSrcweir const SwPosition* pToCharCntntPos = ((SwFmtAnchor&)aSet.Get(RES_ANCHOR)).GetCntntAnchor();
1004cdf0e10cSrcweir rSh.CalcBoundRect( aBoundRect, eAnchorId,
1005cdf0e10cSrcweir text::RelOrientation::FRAME, aVert.GetRelationOrient(),
1006cdf0e10cSrcweir pToCharCntntPos, bFollowTextFlow,
1007cdf0e10cSrcweir false, &aRefPoint );
1008cdf0e10cSrcweir }
1009cdf0e10cSrcweir long nLeft = Min( aTmp.Left() - aBoundRect.Left(), aSnap.Width() );
1010cdf0e10cSrcweir long nRight = Min( aBoundRect.Right() - aTmp.Right(), aSnap.Width() );
1011cdf0e10cSrcweir long nUp = Min( aTmp.Top() - aBoundRect.Top(), aSnap.Height() );
1012cdf0e10cSrcweir long nDown = Min( aBoundRect.Bottom() - aTmp.Bottom(), aSnap.Height() );
1013cdf0e10cSrcweir
1014cdf0e10cSrcweir switch ( nDir )
1015cdf0e10cSrcweir {
1016cdf0e10cSrcweir case MOVE_LEFT_BIG:
101793641701SArmin Le Grand case MOVE_LEFT_HUGE:
101893641701SArmin Le Grand case MOVE_LEFT_SMALL: aTmp.Left( aTmp.Left() - nLeft );
101993641701SArmin Le Grand break;
102093641701SArmin Le Grand
1021cdf0e10cSrcweir case MOVE_UP_BIG:
102293641701SArmin Le Grand case MOVE_UP_HUGE:
102393641701SArmin Le Grand case MOVE_UP_SMALL: aTmp.Top( aTmp.Top() - nUp );
102493641701SArmin Le Grand break;
102593641701SArmin Le Grand
102693641701SArmin Le Grand case MOVE_RIGHT_SMALL:
102793641701SArmin Le Grand if( aTmp.Width() < aSnap.Width() + MINFLY )
102893641701SArmin Le Grand break;
102993641701SArmin Le Grand nRight = aSnap.Width(); // kein break
103093641701SArmin Le Grand case MOVE_RIGHT_HUGE:
103193641701SArmin Le Grand case MOVE_RIGHT_BIG: aTmp.Left( aTmp.Left() + nRight );
103293641701SArmin Le Grand break;
103393641701SArmin Le Grand
103493641701SArmin Le Grand case MOVE_DOWN_SMALL:
103593641701SArmin Le Grand if( aTmp.Height() < aSnap.Height() + MINFLY )
103693641701SArmin Le Grand break;
103793641701SArmin Le Grand nDown = aSnap.Height(); // kein break
103893641701SArmin Le Grand case MOVE_DOWN_HUGE:
103993641701SArmin Le Grand case MOVE_DOWN_BIG: aTmp.Top( aTmp.Top() + nDown );
104093641701SArmin Le Grand break;
104193641701SArmin Le Grand
1042cdf0e10cSrcweir default: ASSERT( sal_True, "ChangeFly: Unknown direction." );
1043cdf0e10cSrcweir }
1044cdf0e10cSrcweir sal_Bool bSet = sal_False;
1045cdf0e10cSrcweir if ((FLY_AS_CHAR == eAnchorId) && ( nDir % 2 ))
1046cdf0e10cSrcweir {
1047cdf0e10cSrcweir long aDiff = aTmp.Top() - aRefPoint.Y();
1048cdf0e10cSrcweir if( aDiff > 0 )
1049cdf0e10cSrcweir aDiff = 0;
1050cdf0e10cSrcweir else if ( aDiff < -aTmp.Height() )
1051cdf0e10cSrcweir aDiff = -aTmp.Height();
1052cdf0e10cSrcweir SwFmtVertOrient aVert( (SwFmtVertOrient&)aSet.Get(RES_VERT_ORIENT) );
1053cdf0e10cSrcweir sal_Int16 eNew;
1054cdf0e10cSrcweir if( bWeb )
1055cdf0e10cSrcweir {
1056cdf0e10cSrcweir eNew = aVert.GetVertOrient();
1057cdf0e10cSrcweir sal_Bool bDown = 0 != ( nDir & 0x02 );
1058cdf0e10cSrcweir switch( eNew )
1059cdf0e10cSrcweir {
1060cdf0e10cSrcweir case text::VertOrientation::CHAR_TOP:
1061cdf0e10cSrcweir if( bDown ) eNew = text::VertOrientation::CENTER;
1062cdf0e10cSrcweir break;
1063cdf0e10cSrcweir case text::VertOrientation::CENTER:
1064cdf0e10cSrcweir eNew = bDown ? text::VertOrientation::TOP : text::VertOrientation::CHAR_TOP;
1065cdf0e10cSrcweir break;
1066cdf0e10cSrcweir case text::VertOrientation::TOP:
1067cdf0e10cSrcweir if( !bDown ) eNew = text::VertOrientation::CENTER;
1068cdf0e10cSrcweir break;
1069cdf0e10cSrcweir case text::VertOrientation::LINE_TOP:
1070cdf0e10cSrcweir if( bDown ) eNew = text::VertOrientation::LINE_CENTER;
1071cdf0e10cSrcweir break;
1072cdf0e10cSrcweir case text::VertOrientation::LINE_CENTER:
1073cdf0e10cSrcweir eNew = bDown ? text::VertOrientation::LINE_BOTTOM : text::VertOrientation::LINE_TOP;
1074cdf0e10cSrcweir break;
1075cdf0e10cSrcweir case text::VertOrientation::LINE_BOTTOM:
1076cdf0e10cSrcweir if( !bDown ) eNew = text::VertOrientation::LINE_CENTER;
1077cdf0e10cSrcweir break;
1078cdf0e10cSrcweir default:; //prevent warning
1079cdf0e10cSrcweir }
1080cdf0e10cSrcweir }
1081cdf0e10cSrcweir else
1082cdf0e10cSrcweir {
1083cdf0e10cSrcweir aVert.SetPos( aDiff );
1084cdf0e10cSrcweir eNew = text::VertOrientation::NONE;
1085cdf0e10cSrcweir }
1086cdf0e10cSrcweir aVert.SetVertOrient( eNew );
1087cdf0e10cSrcweir aSet.Put( aVert );
1088cdf0e10cSrcweir bSet = sal_True;
1089cdf0e10cSrcweir }
1090cdf0e10cSrcweir if (bWeb && (FLY_AT_PARA == eAnchorId)
1091cdf0e10cSrcweir && ( nDir==MOVE_LEFT_SMALL || nDir==MOVE_RIGHT_BIG ))
1092cdf0e10cSrcweir {
1093cdf0e10cSrcweir SwFmtHoriOrient aHori( (SwFmtHoriOrient&)aSet.Get(RES_HORI_ORIENT) );
1094cdf0e10cSrcweir sal_Int16 eNew;
1095cdf0e10cSrcweir eNew = aHori.GetHoriOrient();
1096cdf0e10cSrcweir switch( eNew )
1097cdf0e10cSrcweir {
1098cdf0e10cSrcweir case text::HoriOrientation::RIGHT:
1099cdf0e10cSrcweir if( nDir==MOVE_LEFT_SMALL )
1100cdf0e10cSrcweir eNew = text::HoriOrientation::LEFT;
1101cdf0e10cSrcweir break;
1102cdf0e10cSrcweir case text::HoriOrientation::LEFT:
1103cdf0e10cSrcweir if( nDir==MOVE_RIGHT_BIG )
1104cdf0e10cSrcweir eNew = text::HoriOrientation::RIGHT;
1105cdf0e10cSrcweir break;
1106cdf0e10cSrcweir default:; //prevent warning
1107cdf0e10cSrcweir }
1108cdf0e10cSrcweir if( eNew != aHori.GetHoriOrient() )
1109cdf0e10cSrcweir {
1110cdf0e10cSrcweir aHori.SetHoriOrient( eNew );
1111cdf0e10cSrcweir aSet.Put( aHori );
1112cdf0e10cSrcweir bSet = sal_True;
1113cdf0e10cSrcweir }
1114cdf0e10cSrcweir }
1115cdf0e10cSrcweir rSh.StartAllAction();
1116cdf0e10cSrcweir if( bSet )
1117cdf0e10cSrcweir rSh.SetFlyFrmAttr( aSet );
1118cdf0e10cSrcweir sal_Bool bSetPos = (FLY_AS_CHAR != eAnchorId);
1119cdf0e10cSrcweir if(bSetPos && bWeb)
1120cdf0e10cSrcweir {
1121cdf0e10cSrcweir if (FLY_AT_PAGE != eAnchorId)
1122cdf0e10cSrcweir {
1123cdf0e10cSrcweir bSetPos = sal_False;
1124cdf0e10cSrcweir }
1125cdf0e10cSrcweir else
1126cdf0e10cSrcweir {
1127cdf0e10cSrcweir bSetPos = (::GetHtmlMode(rView.GetDocShell()) & HTMLMODE_SOME_ABS_POS) ?
1128cdf0e10cSrcweir sal_True : sal_False;
1129cdf0e10cSrcweir }
1130cdf0e10cSrcweir }
1131cdf0e10cSrcweir if( bSetPos )
1132cdf0e10cSrcweir rSh.SetFlyPos( aTmp.Pos() );
1133cdf0e10cSrcweir rSh.EndAllAction();
1134cdf0e10cSrcweir }
1135cdf0e10cSrcweir }
1136cdf0e10cSrcweir /* -----------------------------23.05.2002 11:35------------------------------
1137cdf0e10cSrcweir
1138cdf0e10cSrcweir ---------------------------------------------------------------------------*/
ChangeDrawing(sal_uInt8 nDir)1139cdf0e10cSrcweir void SwEditWin::ChangeDrawing( sal_uInt8 nDir )
1140cdf0e10cSrcweir {
1141cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
1142cdf0e10cSrcweir rSh.StartUndo();
1143cdf0e10cSrcweir
1144cdf0e10cSrcweir long nX = 0;
1145cdf0e10cSrcweir long nY = 0;
114693641701SArmin Le Grand const sal_Bool bOnePixel(
114793641701SArmin Le Grand MOVE_LEFT_SMALL == nDir ||
114893641701SArmin Le Grand MOVE_UP_SMALL == nDir ||
114993641701SArmin Le Grand MOVE_RIGHT_SMALL == nDir ||
115093641701SArmin Le Grand MOVE_DOWN_SMALL == nDir);
115193641701SArmin Le Grand const sal_Bool bHuge(
115293641701SArmin Le Grand MOVE_LEFT_HUGE == nDir ||
115393641701SArmin Le Grand MOVE_UP_HUGE == nDir ||
115493641701SArmin Le Grand MOVE_RIGHT_HUGE == nDir ||
115593641701SArmin Le Grand MOVE_DOWN_HUGE == nDir);
1156cdf0e10cSrcweir sal_uInt16 nAnchorDir = SW_MOVE_UP;
1157cdf0e10cSrcweir switch(nDir)
1158cdf0e10cSrcweir {
1159cdf0e10cSrcweir case MOVE_LEFT_SMALL:
116093641701SArmin Le Grand case MOVE_LEFT_HUGE:
1161cdf0e10cSrcweir case MOVE_LEFT_BIG:
1162cdf0e10cSrcweir nX = -1;
1163cdf0e10cSrcweir nAnchorDir = SW_MOVE_LEFT;
1164cdf0e10cSrcweir break;
1165cdf0e10cSrcweir case MOVE_UP_SMALL:
116693641701SArmin Le Grand case MOVE_UP_HUGE:
1167cdf0e10cSrcweir case MOVE_UP_BIG:
1168cdf0e10cSrcweir nY = -1;
1169cdf0e10cSrcweir break;
1170cdf0e10cSrcweir case MOVE_RIGHT_SMALL:
117193641701SArmin Le Grand case MOVE_RIGHT_HUGE:
1172cdf0e10cSrcweir case MOVE_RIGHT_BIG:
1173cdf0e10cSrcweir nX = +1;
1174cdf0e10cSrcweir nAnchorDir = SW_MOVE_RIGHT;
1175cdf0e10cSrcweir break;
1176cdf0e10cSrcweir case MOVE_DOWN_SMALL:
117793641701SArmin Le Grand case MOVE_DOWN_HUGE:
1178cdf0e10cSrcweir case MOVE_DOWN_BIG:
1179cdf0e10cSrcweir nY = +1;
1180cdf0e10cSrcweir nAnchorDir = SW_MOVE_DOWN;
1181cdf0e10cSrcweir break;
1182cdf0e10cSrcweir }
1183cdf0e10cSrcweir
1184cdf0e10cSrcweir if(0 != nX || 0 != nY)
1185cdf0e10cSrcweir {
1186cdf0e10cSrcweir sal_uInt8 nProtect = rSh.IsSelObjProtected( FLYPROTECT_POS|FLYPROTECT_SIZE );
1187cdf0e10cSrcweir Size aSnap( rSh.GetViewOptions()->GetSnapSize() );
1188cdf0e10cSrcweir short nDiv = rSh.GetViewOptions()->GetDivisionX();
1189cdf0e10cSrcweir if ( nDiv > 0 )
1190cdf0e10cSrcweir aSnap.Width() = Max( (sal_uLong)1, (sal_uLong)aSnap.Width() / nDiv );
1191cdf0e10cSrcweir nDiv = rSh.GetViewOptions()->GetDivisionY();
1192cdf0e10cSrcweir if ( nDiv > 0 )
1193cdf0e10cSrcweir aSnap.Height() = Max( (sal_uLong)1, (sal_uLong)aSnap.Height() / nDiv );
1194cdf0e10cSrcweir
1195cdf0e10cSrcweir if(bOnePixel)
119693641701SArmin Le Grand {
1197cdf0e10cSrcweir aSnap = PixelToLogic(Size(1,1));
119893641701SArmin Le Grand }
119993641701SArmin Le Grand else if(bHuge)
120093641701SArmin Le Grand {
120193641701SArmin Le Grand // #121236# 567twips == 1cm, but just take three times the normal snap
120293641701SArmin Le Grand aSnap = Size(aSnap.Width() * 3, aSnap.Height() * 3);
120393641701SArmin Le Grand }
1204cdf0e10cSrcweir
1205cdf0e10cSrcweir nX *= aSnap.Width();
1206cdf0e10cSrcweir nY *= aSnap.Height();
1207cdf0e10cSrcweir
1208cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
1209cdf0e10cSrcweir const SdrHdlList& rHdlList = pSdrView->GetHdlList();
1210cdf0e10cSrcweir SdrHdl* pHdl = rHdlList.GetFocusHdl();
1211cdf0e10cSrcweir rSh.StartAllAction();
1212cdf0e10cSrcweir if(0L == pHdl)
1213cdf0e10cSrcweir {
1214cdf0e10cSrcweir // now move the selected draw objects
1215cdf0e10cSrcweir // if the object's position is not protected
1216cdf0e10cSrcweir if(0 == (nProtect&FLYPROTECT_POS))
1217cdf0e10cSrcweir {
1218cdf0e10cSrcweir sal_Bool bDummy1, bDummy2;
1219cdf0e10cSrcweir const bool bVertAnchor = rSh.IsFrmVertical( sal_True, bDummy1, bDummy2 );
1220cdf0e10cSrcweir const bool bHoriMove = !bVertAnchor == !( nDir % 2 );
1221cdf0e10cSrcweir const bool bMoveAllowed =
1222cdf0e10cSrcweir !bHoriMove || (rSh.GetAnchorId() != FLY_AS_CHAR);
1223cdf0e10cSrcweir if ( bMoveAllowed )
1224cdf0e10cSrcweir {
1225cdf0e10cSrcweir pSdrView->MoveAllMarked(Size(nX, nY));
1226cdf0e10cSrcweir rSh.SetModified();
1227cdf0e10cSrcweir }
1228cdf0e10cSrcweir }
1229cdf0e10cSrcweir }
1230cdf0e10cSrcweir else
1231cdf0e10cSrcweir {
1232cdf0e10cSrcweir // move handle with index nHandleIndex
1233cdf0e10cSrcweir if(pHdl && (nX || nY))
1234cdf0e10cSrcweir {
1235cdf0e10cSrcweir if( HDL_ANCHOR == pHdl->GetKind() ||
1236cdf0e10cSrcweir HDL_ANCHOR_TR == pHdl->GetKind() )
1237cdf0e10cSrcweir {
1238cdf0e10cSrcweir // anchor move cannot be allowed when position is protected
1239cdf0e10cSrcweir if(0 == (nProtect&FLYPROTECT_POS))
1240cdf0e10cSrcweir rSh.MoveAnchor( nAnchorDir );
1241cdf0e10cSrcweir }
1242cdf0e10cSrcweir //now resize if size is protected
1243cdf0e10cSrcweir else if(0 == (nProtect&FLYPROTECT_SIZE))
1244cdf0e10cSrcweir {
1245cdf0e10cSrcweir // now move the Handle (nX, nY)
1246cdf0e10cSrcweir Point aStartPoint(pHdl->GetPos());
1247cdf0e10cSrcweir Point aEndPoint(pHdl->GetPos() + Point(nX, nY));
1248cdf0e10cSrcweir const SdrDragStat& rDragStat = pSdrView->GetDragStat();
1249cdf0e10cSrcweir
1250cdf0e10cSrcweir // start dragging
1251cdf0e10cSrcweir pSdrView->BegDragObj(aStartPoint, 0, pHdl, 0);
1252cdf0e10cSrcweir
1253cdf0e10cSrcweir if(pSdrView->IsDragObj())
1254cdf0e10cSrcweir {
1255cdf0e10cSrcweir sal_Bool bWasNoSnap = static_cast< sal_Bool >(rDragStat.IsNoSnap());
1256cdf0e10cSrcweir sal_Bool bWasSnapEnabled = pSdrView->IsSnapEnabled();
1257cdf0e10cSrcweir
1258cdf0e10cSrcweir // switch snapping off
1259cdf0e10cSrcweir if(!bWasNoSnap)
1260cdf0e10cSrcweir ((SdrDragStat&)rDragStat).SetNoSnap(sal_True);
1261cdf0e10cSrcweir if(bWasSnapEnabled)
1262cdf0e10cSrcweir pSdrView->SetSnapEnabled(sal_False);
1263cdf0e10cSrcweir
1264cdf0e10cSrcweir pSdrView->MovAction(aEndPoint);
1265cdf0e10cSrcweir pSdrView->EndDragObj();
1266cdf0e10cSrcweir rSh.SetModified();
1267cdf0e10cSrcweir
1268cdf0e10cSrcweir // restore snap
1269cdf0e10cSrcweir if(!bWasNoSnap)
1270cdf0e10cSrcweir ((SdrDragStat&)rDragStat).SetNoSnap(bWasNoSnap);
1271cdf0e10cSrcweir if(bWasSnapEnabled)
1272cdf0e10cSrcweir pSdrView->SetSnapEnabled(bWasSnapEnabled);
1273cdf0e10cSrcweir }
1274cdf0e10cSrcweir }
1275cdf0e10cSrcweir }
1276cdf0e10cSrcweir }
1277cdf0e10cSrcweir rSh.EndAllAction();
1278cdf0e10cSrcweir }
1279cdf0e10cSrcweir
1280cdf0e10cSrcweir rSh.EndUndo();
1281cdf0e10cSrcweir }
1282cdf0e10cSrcweir
1283cdf0e10cSrcweir /*--------------------------------------------------------------------
1284cdf0e10cSrcweir Beschreibung: KeyEvents
1285cdf0e10cSrcweir --------------------------------------------------------------------*/
1286cdf0e10cSrcweir
1287cdf0e10cSrcweir
1288cdf0e10cSrcweir
KeyInput(const KeyEvent & rKEvt)1289cdf0e10cSrcweir void SwEditWin::KeyInput(const KeyEvent &rKEvt)
1290cdf0e10cSrcweir {
1291cdf0e10cSrcweir if( rKEvt.GetKeyCode().GetCode() == KEY_ESCAPE &&
1292cdf0e10cSrcweir pApplyTempl && pApplyTempl->pFormatClipboard )
1293cdf0e10cSrcweir {
1294cdf0e10cSrcweir pApplyTempl->pFormatClipboard->Erase();
1295cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate());
1296cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(SID_FORMATPAINTBRUSH);
1297cdf0e10cSrcweir }
1298cdf0e10cSrcweir
1299cdf0e10cSrcweir SfxObjectShell *pObjSh = (SfxObjectShell*)rView.GetViewFrame()->GetObjectShell();
1300cdf0e10cSrcweir if ( bLockInput || (pObjSh && pObjSh->GetProgress()) )
1301cdf0e10cSrcweir // Wenn die Rechenleiste aktiv ist oder
1302cdf0e10cSrcweir // auf dem Document ein Progress laeuft wird keine
1303cdf0e10cSrcweir // Bestellungen angenommen.
1304cdf0e10cSrcweir return;
1305cdf0e10cSrcweir
1306cdf0e10cSrcweir if( pShadCrsr )
1307cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
1308cdf0e10cSrcweir aKeyInputFlushTimer.Stop();
1309cdf0e10cSrcweir
1310cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
1311cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
1312cdf0e10cSrcweir rSh.IsCrsrReadonly();
1313cdf0e10cSrcweir
1314cdf0e10cSrcweir //if the language changes the buffer must be flushed
1315cdf0e10cSrcweir LanguageType eNewLanguage = GetInputLanguage();
1316cdf0e10cSrcweir if(!bIsDocReadOnly && eBufferLanguage != eNewLanguage && aInBuffer.Len())
1317cdf0e10cSrcweir {
1318cdf0e10cSrcweir FlushInBuffer();
1319cdf0e10cSrcweir }
1320cdf0e10cSrcweir eBufferLanguage = eNewLanguage;
1321cdf0e10cSrcweir
1322cdf0e10cSrcweir QuickHelpData aTmpQHD;
1323cdf0e10cSrcweir if( pQuickHlpData->bClear )
1324cdf0e10cSrcweir {
1325cdf0e10cSrcweir aTmpQHD.Move( *pQuickHlpData );
1326cdf0e10cSrcweir pQuickHlpData->Stop( rSh );
1327cdf0e10cSrcweir }
1328cdf0e10cSrcweir
1329cdf0e10cSrcweir // OS:auch die DrawView braucht noch ein readonly-Flag
1330cdf0e10cSrcweir if ( !bIsDocReadOnly && rSh.GetDrawView() && rSh.GetDrawView()->KeyInput( rKEvt, this ) )
1331cdf0e10cSrcweir {
1332cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll( sal_False );
1333cdf0e10cSrcweir rSh.SetModified();
1334cdf0e10cSrcweir return; // Event von der SdrView ausgewertet
1335cdf0e10cSrcweir }
1336cdf0e10cSrcweir
1337cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm )
1338cdf0e10cSrcweir {
1339cdf0e10cSrcweir StopInsFrm();
1340cdf0e10cSrcweir rSh.Edit();
1341cdf0e10cSrcweir }
1342cdf0e10cSrcweir
1343cdf0e10cSrcweir sal_Bool bFlushBuffer = sal_False;
1344cdf0e10cSrcweir sal_Bool bNormalChar = sal_False;
1345cdf0e10cSrcweir sal_Bool bChkInsBlank = pQuickHlpData->bChkInsBlank;
1346cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_False;
1347cdf0e10cSrcweir
1348cdf0e10cSrcweir KeyEvent aKeyEvent( rKEvt );
1349cdf0e10cSrcweir // look for vertical mappings
1350cdf0e10cSrcweir if( !bIsDocReadOnly && !rSh.IsSelFrmMode() && !rSh.IsObjSelected() )
1351cdf0e10cSrcweir {
1352cdf0e10cSrcweir //JP 21.2.2002: must changed from switch to if, because the Linux
1353cdf0e10cSrcweir // compiler has problem with the code. Has to remove if the new general
1354cdf0e10cSrcweir // handler exist.
1355cdf0e10cSrcweir sal_uInt16 nKey = rKEvt.GetKeyCode().GetCode();
1356cdf0e10cSrcweir
1357cdf0e10cSrcweir if( KEY_UP == nKey || KEY_DOWN == nKey ||
1358cdf0e10cSrcweir KEY_LEFT == nKey || KEY_RIGHT == nKey )
1359cdf0e10cSrcweir {
1360cdf0e10cSrcweir // In general, we want to map the direction keys if we are inside
1361cdf0e10cSrcweir // some vertical formatted text.
1362cdf0e10cSrcweir // 1. Exception: For a table cursor in a horizontal table, the
1363cdf0e10cSrcweir // directions should never be mapped.
1364cdf0e10cSrcweir // 2. Exception: For a table cursor in a vertical table, the
1365cdf0e10cSrcweir // directions should always be mapped.
1366cdf0e10cSrcweir const bool bVertText = rSh.IsInVerticalText();
1367cdf0e10cSrcweir const bool bTblCrsr = rSh.GetTableCrsr();
1368cdf0e10cSrcweir const bool bVertTable = rSh.IsTableVertical();
1369cdf0e10cSrcweir if( ( bVertText && ( !bTblCrsr || bVertTable ) ) ||
1370cdf0e10cSrcweir ( bTblCrsr && bVertTable ) )
1371cdf0e10cSrcweir {
1372cdf0e10cSrcweir // Attempt to integrate cursor travelling for mongolian layout does not work.
1373cdf0e10cSrcweir // Thus, back to previous mapping of cursor keys to direction keys.
1374cdf0e10cSrcweir if( KEY_UP == nKey ) nKey = KEY_LEFT;
1375cdf0e10cSrcweir else if( KEY_DOWN == nKey ) nKey = KEY_RIGHT;
1376cdf0e10cSrcweir else if( KEY_LEFT == nKey ) nKey = KEY_DOWN;
1377cdf0e10cSrcweir else if( KEY_RIGHT == nKey ) nKey = KEY_UP;
1378cdf0e10cSrcweir }
1379cdf0e10cSrcweir
1380cdf0e10cSrcweir if ( rSh.IsInRightToLeftText() )
1381cdf0e10cSrcweir {
1382cdf0e10cSrcweir if( KEY_LEFT == nKey ) nKey = KEY_RIGHT;
1383cdf0e10cSrcweir else if( KEY_RIGHT == nKey ) nKey = KEY_LEFT;
1384cdf0e10cSrcweir }
1385cdf0e10cSrcweir
1386cdf0e10cSrcweir aKeyEvent = KeyEvent( rKEvt.GetCharCode(),
1387cdf0e10cSrcweir KeyCode( nKey, rKEvt.GetKeyCode().GetModifier() ),
1388cdf0e10cSrcweir rKEvt.GetRepeat() );
1389cdf0e10cSrcweir }
1390cdf0e10cSrcweir }
1391cdf0e10cSrcweir
1392cdf0e10cSrcweir const KeyCode& rKeyCode = aKeyEvent.GetKeyCode();
1393cdf0e10cSrcweir sal_Unicode aCh = aKeyEvent.GetCharCode();
1394cdf0e10cSrcweir
1395cdf0e10cSrcweir // enable switching to notes ankor with Ctrl - Alt - Page Up/Down
1396cdf0e10cSrcweir // pressing this inside a note will switch to next/previous note
1397cdf0e10cSrcweir if ((rKeyCode.IsMod1() && rKeyCode.IsMod2()) && ((rKeyCode.GetCode() == KEY_PAGEUP) || (rKeyCode.GetCode() == KEY_PAGEDOWN)))
1398cdf0e10cSrcweir {
139969a74367SOliver-Rainer Wittmann const bool bNext = rKeyCode.GetCode()==KEY_PAGEDOWN ? true : false;
140069a74367SOliver-Rainer Wittmann const SwFieldType* pFldType = rSh.GetFldType( 0, RES_POSTITFLD );
1401cdf0e10cSrcweir rSh.MoveFldType( pFldType, bNext );
1402cdf0e10cSrcweir return;
1403cdf0e10cSrcweir }
1404cdf0e10cSrcweir
1405cdf0e10cSrcweir const SwFrmFmt* pFlyFmt = rSh.GetFlyFrmFmt();
1406cdf0e10cSrcweir if( pFlyFmt )
1407cdf0e10cSrcweir {
1408cdf0e10cSrcweir sal_uInt16 nEvent;
1409cdf0e10cSrcweir
1410cdf0e10cSrcweir if( 32 <= aCh &&
1411cdf0e10cSrcweir 0 == (( KEY_MOD1 | KEY_MOD2 ) & rKeyCode.GetModifier() ))
1412cdf0e10cSrcweir nEvent = SW_EVENT_FRM_KEYINPUT_ALPHA;
1413cdf0e10cSrcweir else
1414cdf0e10cSrcweir nEvent = SW_EVENT_FRM_KEYINPUT_NOALPHA;
1415cdf0e10cSrcweir
1416cdf0e10cSrcweir const SvxMacro* pMacro = pFlyFmt->GetMacro().GetMacroTable().Get( nEvent );
1417cdf0e10cSrcweir if( pMacro )
1418cdf0e10cSrcweir {
1419cdf0e10cSrcweir String sRet;
1420cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray;
1421cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable;
1422cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() );
1423cdf0e10cSrcweir xArgs->Put( &xVar, 1 );
1424cdf0e10cSrcweir
1425cdf0e10cSrcweir xVar = new SbxVariable;
1426cdf0e10cSrcweir if( SW_EVENT_FRM_KEYINPUT_ALPHA == nEvent )
1427cdf0e10cSrcweir xVar->PutChar( aCh );
1428cdf0e10cSrcweir else
1429cdf0e10cSrcweir xVar->PutUShort( rKeyCode.GetModifier() | rKeyCode.GetCode() );
1430cdf0e10cSrcweir xArgs->Put( &xVar, 2 );
1431cdf0e10cSrcweir
1432cdf0e10cSrcweir rSh.ExecMacro( *pMacro, &sRet, &xArgs );
1433cdf0e10cSrcweir if( sRet.Len() && 0 != sRet.ToInt32() )
1434cdf0e10cSrcweir return ;
1435cdf0e10cSrcweir }
1436cdf0e10cSrcweir }
1437cdf0e10cSrcweir int nLclSelectionType;
1438cdf0e10cSrcweir //A is converted to 1
1439cdf0e10cSrcweir if( rKeyCode.GetFullCode() == (KEY_A | KEY_MOD1 |KEY_SHIFT)
1440cdf0e10cSrcweir && rSh.HasDrawView() &&
1441cdf0e10cSrcweir (0 != (nLclSelectionType = rSh.GetSelectionType()) &&
1442cdf0e10cSrcweir ((nLclSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_GRF)) ||
1443cdf0e10cSrcweir ((nLclSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
1444cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1))))
1445cdf0e10cSrcweir {
1446cdf0e10cSrcweir SdrHdlList& rHdlList = (SdrHdlList&)rSh.GetDrawView()->GetHdlList();
1447cdf0e10cSrcweir SdrHdl* pAnchor = rHdlList.GetHdl(HDL_ANCHOR);
1448cdf0e10cSrcweir if ( ! pAnchor )
1449cdf0e10cSrcweir pAnchor = rHdlList.GetHdl(HDL_ANCHOR_TR);
1450cdf0e10cSrcweir if(pAnchor)
1451cdf0e10cSrcweir rHdlList.SetFocusHdl(pAnchor);
1452cdf0e10cSrcweir return;
1453cdf0e10cSrcweir }
1454cdf0e10cSrcweir
1455cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = 0;
1456cdf0e10cSrcweir SvxAutoCorrect* pACorr = 0;
1457cdf0e10cSrcweir
1458cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder =
1459cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder();
1460cdf0e10cSrcweir if ( !xRecorder.is() )
1461cdf0e10cSrcweir {
1462cdf0e10cSrcweir pACfg = SvxAutoCorrCfg::Get();
1463cdf0e10cSrcweir pACorr = pACfg->GetAutoCorrect();
1464cdf0e10cSrcweir }
1465cdf0e10cSrcweir
1466cdf0e10cSrcweir SwModuleOptions* pModOpt = SW_MOD()->GetModuleConfig();
1467cdf0e10cSrcweir
1468cdf0e10cSrcweir TblChgWidthHeightType eTblChgMode = nsTblChgWidthHeightType::WH_COL_LEFT; // initialization just for warning-free code
1469cdf0e10cSrcweir sal_uInt16 nTblChgSize = 0;
1470cdf0e10cSrcweir sal_Bool bStopKeyInputTimer = sal_True;
1471cdf0e10cSrcweir String sFmlEntry;
1472cdf0e10cSrcweir
1473cdf0e10cSrcweir enum SW_KeyState { KS_Start,
1474cdf0e10cSrcweir KS_CheckKey, KS_InsChar, KS_InsTab,
1475cdf0e10cSrcweir KS_NoNum, KS_NumOff, KS_NumOrNoNum, KS_NumDown, KS_NumUp,
1476cdf0e10cSrcweir // -> #i23725#
1477cdf0e10cSrcweir KS_NumIndentInc, KS_NumIndentDec,
1478cdf0e10cSrcweir // <- #i23725#
1479cdf0e10cSrcweir
1480cdf0e10cSrcweir KS_OutlineLvOff,
1481cdf0e10cSrcweir KS_NextCell, KS_PrevCell, KS_OutlineUp, KS_OutlineDown,
1482cdf0e10cSrcweir KS_GlossaryExpand, KS_NextPrevGlossary,
1483cdf0e10cSrcweir KS_AutoFmtByInput,
1484cdf0e10cSrcweir KS_NextObject, KS_PrevObject,
1485cdf0e10cSrcweir KS_KeyToView,
1486cdf0e10cSrcweir KS_LaunchOLEObject, KS_GoIntoFly, KS_GoIntoDrawing,
1487cdf0e10cSrcweir KS_EnterDrawHandleMode,
1488cdf0e10cSrcweir KS_CheckDocReadOnlyKeys,
1489cdf0e10cSrcweir KS_CheckAutoCorrect, KS_EditFormula,
1490cdf0e10cSrcweir KS_ColLeftBig, KS_ColRightBig,
1491cdf0e10cSrcweir KS_ColLeftSmall, KS_ColRightSmall,
1492cdf0e10cSrcweir KS_ColTopBig, KS_ColBottomBig,
1493cdf0e10cSrcweir KS_ColTopSmall, KS_ColBottomSmall,
1494cdf0e10cSrcweir KS_CellLeftBig, KS_CellRightBig,
1495cdf0e10cSrcweir KS_CellLeftSmall, KS_CellRightSmall,
1496cdf0e10cSrcweir KS_CellTopBig, KS_CellBottomBig,
1497cdf0e10cSrcweir KS_CellTopSmall, KS_CellBottomSmall,
1498cdf0e10cSrcweir
1499cdf0e10cSrcweir KS_InsDel_ColLeftBig, KS_InsDel_ColRightBig,
1500cdf0e10cSrcweir KS_InsDel_ColLeftSmall, KS_InsDel_ColRightSmall,
1501cdf0e10cSrcweir KS_InsDel_ColTopBig, KS_InsDel_ColBottomBig,
1502cdf0e10cSrcweir KS_InsDel_ColTopSmall, KS_InsDel_ColBottomSmall,
1503cdf0e10cSrcweir KS_InsDel_CellLeftBig, KS_InsDel_CellRightBig,
1504cdf0e10cSrcweir KS_InsDel_CellLeftSmall, KS_InsDel_CellRightSmall,
1505cdf0e10cSrcweir KS_InsDel_CellTopBig, KS_InsDel_CellBottomBig,
1506cdf0e10cSrcweir KS_InsDel_CellTopSmall, KS_InsDel_CellBottomSmall,
1507cdf0e10cSrcweir KS_TblColCellInsDel,
1508cdf0e10cSrcweir
1509cdf0e10cSrcweir KS_Fly_Change, KS_Draw_Change,
1510cdf0e10cSrcweir KS_SpecialInsert,
1511cdf0e10cSrcweir KS_EnterCharCell,
1512cdf0e10cSrcweir KS_GotoNextFieldMark,
1513cdf0e10cSrcweir KS_GotoPrevFieldMark,
1514cdf0e10cSrcweir KS_Ende };
1515cdf0e10cSrcweir
1516cdf0e10cSrcweir
1517cdf0e10cSrcweir
151869a74367SOliver-Rainer Wittmann SW_KeyState eKeyState = bIsDocReadOnly ? KS_CheckDocReadOnlyKeys : KS_CheckKey;
151969a74367SOliver-Rainer Wittmann SW_KeyState eNextKeyState = KS_Ende;
1520cdf0e10cSrcweir sal_uInt8 nDir = 0;
1521cdf0e10cSrcweir
1522cdf0e10cSrcweir if (nKS_NUMDOWN_Count > 0)
1523cdf0e10cSrcweir nKS_NUMDOWN_Count--;
1524cdf0e10cSrcweir
1525cdf0e10cSrcweir if (nKS_NUMINDENTINC_Count > 0)
1526cdf0e10cSrcweir nKS_NUMINDENTINC_Count--;
1527cdf0e10cSrcweir
1528cdf0e10cSrcweir while( KS_Ende != eKeyState )
1529cdf0e10cSrcweir {
1530cdf0e10cSrcweir SW_KeyState eFlyState = KS_KeyToView;
1531cdf0e10cSrcweir
1532cdf0e10cSrcweir switch( eKeyState )
1533cdf0e10cSrcweir {
1534cdf0e10cSrcweir case KS_CheckKey:
1535cdf0e10cSrcweir eKeyState = KS_KeyToView; // default weiter zur View
1536cdf0e10cSrcweir
1537cdf0e10cSrcweir #ifdef DBG_UTIL
1538cdf0e10cSrcweir //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1539cdf0e10cSrcweir // JP 19.01.99: zum Umschalten des Cursor Verhaltens in ReadOnly
1540cdf0e10cSrcweir // Bereichen
1541cdf0e10cSrcweir if( 0x7210 == rKeyCode.GetFullCode() )
1542cdf0e10cSrcweir rSh.SetReadOnlyAvailable( !rSh.IsReadOnlyAvailable() );
1543cdf0e10cSrcweir else
1544cdf0e10cSrcweir //!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
1545cdf0e10cSrcweir #endif
1546cdf0e10cSrcweir
1547cdf0e10cSrcweir if( !rKeyCode.IsMod2() && '=' == aCh &&
1548cdf0e10cSrcweir !rSh.IsTableMode() && rSh.GetTableFmt() &&
1549cdf0e10cSrcweir rSh.IsSttPara() /*&& rSh.IsEndPara()*/ &&
1550cdf0e10cSrcweir !rSh.HasReadonlySel() )
1551cdf0e10cSrcweir {
1552cdf0e10cSrcweir // in der Tabelle am Anfang der Zelle ein '=' ->
1553cdf0e10cSrcweir // EditZeile aufrufen (F2-Funktionalitaet)
1554cdf0e10cSrcweir rSh.Push();
1555cdf0e10cSrcweir if( !rSh.MoveSection( fnSectionCurr, fnSectionStart) &&
1556cdf0e10cSrcweir !rSh.IsTableBoxTextFormat() )
1557cdf0e10cSrcweir {
1558cdf0e10cSrcweir // steht also am Anfang der Box
1559cdf0e10cSrcweir eKeyState = KS_EditFormula;
1560cdf0e10cSrcweir if( rSh.HasMark() )
1561cdf0e10cSrcweir rSh.SwapPam();
1562cdf0e10cSrcweir else
1563cdf0e10cSrcweir rSh.SttSelect();
1564cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd );
1565cdf0e10cSrcweir rSh.Pop( sal_True );
1566cdf0e10cSrcweir rSh.EndSelect();
1567cdf0e10cSrcweir sFmlEntry = '=';
1568cdf0e10cSrcweir }
1569cdf0e10cSrcweir else
1570cdf0e10cSrcweir rSh.Pop( sal_False );
1571cdf0e10cSrcweir }
1572cdf0e10cSrcweir else
1573cdf0e10cSrcweir {
1574cdf0e10cSrcweir if( pACorr && aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
1575cdf0e10cSrcweir !rSh.HasReadonlySel() && !aTmpQHD.bIsAutoText &&
1576cdf0e10cSrcweir pACorr->GetSwFlags().nAutoCmpltExpandKey ==
1577cdf0e10cSrcweir (rKeyCode.GetModifier() | rKeyCode.GetCode()) )
1578cdf0e10cSrcweir {
1579cdf0e10cSrcweir eKeyState = KS_GlossaryExpand;
1580cdf0e10cSrcweir break;
1581cdf0e10cSrcweir }
1582cdf0e10cSrcweir
1583cdf0e10cSrcweir switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
1584cdf0e10cSrcweir {
1585cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2:
1586cdf0e10cSrcweir eKeyState = KS_ColRightBig;
1587cdf0e10cSrcweir eFlyState = KS_Fly_Change;
15884846d9baSOliver-Rainer Wittmann nDir = MOVE_RIGHT_SMALL;
1589cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
1590cdf0e10cSrcweir
1591cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2:
1592cdf0e10cSrcweir eKeyState = KS_ColRightSmall;
1593cdf0e10cSrcweir eFlyState = KS_Fly_Change;
15944846d9baSOliver-Rainer Wittmann nDir = MOVE_LEFT_SMALL;
1595cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
159693641701SArmin Le Grand
1597cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT:
1598cdf0e10cSrcweir eKeyState = KS_ColLeftSmall;
1599cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
160093641701SArmin Le Grand
1601cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_SHIFT:
1602cdf0e10cSrcweir eKeyState = KS_ColLeftBig;
1603cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
1604cdf0e10cSrcweir
1605cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_MOD1:
1606cdf0e10cSrcweir eKeyState = KS_CellRightBig;
1607cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
160893641701SArmin Le Grand
1609cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_MOD1:
1610cdf0e10cSrcweir eKeyState = KS_CellRightSmall;
1611cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
161293641701SArmin Le Grand
1613cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1614cdf0e10cSrcweir eKeyState = KS_CellLeftSmall;
1615cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
161693641701SArmin Le Grand
1617cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1618cdf0e10cSrcweir eKeyState = KS_CellLeftBig;
1619cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
1620cdf0e10cSrcweir
1621cdf0e10cSrcweir case KEY_UP | KEY_MOD2:
1622cdf0e10cSrcweir eKeyState = KS_ColBottomSmall;
1623cdf0e10cSrcweir eFlyState = KS_Fly_Change;
16244846d9baSOliver-Rainer Wittmann nDir = MOVE_UP_SMALL;
1625cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
162693641701SArmin Le Grand
1627cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2:
1628cdf0e10cSrcweir eKeyState = KS_ColBottomBig;
1629cdf0e10cSrcweir eFlyState = KS_Fly_Change;
16304846d9baSOliver-Rainer Wittmann nDir = MOVE_DOWN_SMALL;
1631cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
163293641701SArmin Le Grand
1633cdf0e10cSrcweir case KEY_UP | KEY_MOD2 | KEY_MOD1:
1634cdf0e10cSrcweir eKeyState = KS_CellBottomSmall;
1635cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
163693641701SArmin Le Grand
1637cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2 | KEY_MOD1:
1638cdf0e10cSrcweir eKeyState = KS_CellBottomBig;
1639cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
164093641701SArmin Le Grand
1641cdf0e10cSrcweir case KEY_UP | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1642cdf0e10cSrcweir eKeyState = KS_CellTopBig;
1643cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
164493641701SArmin Le Grand
1645cdf0e10cSrcweir case KEY_DOWN | KEY_MOD2 | KEY_SHIFT | KEY_MOD1:
1646cdf0e10cSrcweir eKeyState = KS_CellTopSmall;
1647cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE;
1648cdf0e10cSrcweir
1649cdf0e10cSrcweir KEYINPUT_CHECKTABLE:
1650cdf0e10cSrcweir if( rSh.IsTableMode() || !rSh.GetTableFmt() )
1651cdf0e10cSrcweir {
1652cdf0e10cSrcweir if(KS_KeyToView != eFlyState)
1653cdf0e10cSrcweir {
1654cdf0e10cSrcweir if(!pFlyFmt && KS_KeyToView != eFlyState &&
1655cdf0e10cSrcweir (rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
1656cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked())
1657cdf0e10cSrcweir eKeyState = KS_Draw_Change;
1658cdf0e10cSrcweir }
1659cdf0e10cSrcweir
1660cdf0e10cSrcweir if( pFlyFmt )
1661cdf0e10cSrcweir eKeyState = eFlyState;
1662cdf0e10cSrcweir else if( KS_Draw_Change != eKeyState)
1663cdf0e10cSrcweir eKeyState = KS_EnterCharCell;
1664cdf0e10cSrcweir }
1665cdf0e10cSrcweir break;
1666cdf0e10cSrcweir
16674846d9baSOliver-Rainer Wittmann // huge object move
16684846d9baSOliver-Rainer Wittmann case KEY_RIGHT | KEY_SHIFT:
16694846d9baSOliver-Rainer Wittmann case KEY_LEFT | KEY_SHIFT:
16704846d9baSOliver-Rainer Wittmann case KEY_UP | KEY_SHIFT:
16714846d9baSOliver-Rainer Wittmann case KEY_DOWN | KEY_SHIFT:
16724846d9baSOliver-Rainer Wittmann {
1673a1a40a94SOliver-Rainer Wittmann const int nSelectionType = rSh.GetSelectionType();
1674a1a40a94SOliver-Rainer Wittmann if ( ( pFlyFmt
1675a1a40a94SOliver-Rainer Wittmann && ( nSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF) ) )
1676a1a40a94SOliver-Rainer Wittmann || ( ( nSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM) )
16774846d9baSOliver-Rainer Wittmann && rSh.GetDrawView()->AreObjectsMarked() ) )
16784846d9baSOliver-Rainer Wittmann {
16794846d9baSOliver-Rainer Wittmann eKeyState = pFlyFmt ? KS_Fly_Change : KS_Draw_Change;
16804846d9baSOliver-Rainer Wittmann switch ( rKeyCode.GetCode() )
16814846d9baSOliver-Rainer Wittmann {
16824846d9baSOliver-Rainer Wittmann case KEY_RIGHT: nDir = MOVE_RIGHT_HUGE; break;
16834846d9baSOliver-Rainer Wittmann case KEY_LEFT: nDir = MOVE_LEFT_HUGE; break;
16844846d9baSOliver-Rainer Wittmann case KEY_UP: nDir = MOVE_UP_HUGE; break;
16854846d9baSOliver-Rainer Wittmann case KEY_DOWN: nDir = MOVE_DOWN_HUGE; break;
16864846d9baSOliver-Rainer Wittmann }
16874846d9baSOliver-Rainer Wittmann }
16884846d9baSOliver-Rainer Wittmann break;
16894846d9baSOliver-Rainer Wittmann }
16904846d9baSOliver-Rainer Wittmann
1691cdf0e10cSrcweir //-------
1692cdf0e10cSrcweir // Insert/Delete
1693cdf0e10cSrcweir case KEY_LEFT:
1694cdf0e10cSrcweir case KEY_LEFT | KEY_MOD1:
1695cdf0e10cSrcweir {
1696cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1697cdf0e10cSrcweir if(!bMod1)
1698cdf0e10cSrcweir {
1699cdf0e10cSrcweir eFlyState = KS_Fly_Change;
1700cdf0e10cSrcweir nDir = MOVE_LEFT_BIG;
1701cdf0e10cSrcweir }
1702cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
1703cdf0e10cSrcweir ( bMod1
1704cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_LEFT
1705cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_COL_LEFT );
1706cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert();
1707cdf0e10cSrcweir }
1708cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL;
1709cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD1:
1710cdf0e10cSrcweir {
1711cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_CELL_RIGHT;
1712cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert();
1713cdf0e10cSrcweir }
1714cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL;
1715cdf0e10cSrcweir case KEY_UP:
1716cdf0e10cSrcweir case KEY_UP | KEY_MOD1:
1717cdf0e10cSrcweir {
1718cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1719cdf0e10cSrcweir if(!bMod1)
1720cdf0e10cSrcweir {
1721cdf0e10cSrcweir eFlyState = KS_Fly_Change;
1722cdf0e10cSrcweir nDir = MOVE_UP_BIG;
1723cdf0e10cSrcweir }
1724cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
1725cdf0e10cSrcweir ( bMod1
1726cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_TOP
1727cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_ROW_TOP );
1728cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblHInsert();
1729cdf0e10cSrcweir }
1730cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL;
1731cdf0e10cSrcweir case KEY_DOWN:
1732cdf0e10cSrcweir case KEY_DOWN | KEY_MOD1:
1733cdf0e10cSrcweir {
1734cdf0e10cSrcweir sal_Bool bMod1 = 0 != (rKeyCode.GetModifier() & KEY_MOD1);
1735cdf0e10cSrcweir if(!bMod1)
1736cdf0e10cSrcweir {
1737cdf0e10cSrcweir eFlyState = KS_Fly_Change;
1738cdf0e10cSrcweir nDir = MOVE_DOWN_BIG;
1739cdf0e10cSrcweir }
1740cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL |
1741cdf0e10cSrcweir ( bMod1
1742cdf0e10cSrcweir ? nsTblChgWidthHeightType::WH_CELL_BOTTOM
1743cdf0e10cSrcweir : nsTblChgWidthHeightType::WH_ROW_BOTTOM );
1744cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblHInsert();
1745cdf0e10cSrcweir }
1746cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL;
1747cdf0e10cSrcweir
1748cdf0e10cSrcweir KEYINPUT_CHECKTABLE_INSDEL:
1749cdf0e10cSrcweir if( rSh.IsTableMode() || !rSh.GetTableFmt() ||
1750cdf0e10cSrcweir !bTblInsDelMode ||
1751cdf0e10cSrcweir sal_False /* Tabelle geschuetzt */
1752cdf0e10cSrcweir )
1753cdf0e10cSrcweir {
1754cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType();
1755cdf0e10cSrcweir
1756cdf0e10cSrcweir eKeyState = KS_KeyToView;
1757cdf0e10cSrcweir if(KS_KeyToView != eFlyState)
1758cdf0e10cSrcweir {
1759cdf0e10cSrcweir if((nSelectionType & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM)) &&
1760cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked())
1761cdf0e10cSrcweir eKeyState = KS_Draw_Change;
1762cdf0e10cSrcweir else if(nSelectionType & (nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF))
1763cdf0e10cSrcweir eKeyState = KS_Fly_Change;
1764cdf0e10cSrcweir }
1765cdf0e10cSrcweir }
1766cdf0e10cSrcweir else
1767cdf0e10cSrcweir {
1768cdf0e10cSrcweir if( !bTblIsInsMode )
1769cdf0e10cSrcweir eTblChgMode = eTblChgMode | nsTblChgWidthHeightType::WH_FLAG_BIGGER;
1770cdf0e10cSrcweir eKeyState = KS_TblColCellInsDel;
1771cdf0e10cSrcweir }
1772cdf0e10cSrcweir break;
1773cdf0e10cSrcweir
1774cdf0e10cSrcweir case KEY_DELETE:
1775cdf0e10cSrcweir if (rSh.IsInFrontOfLabel() &&
1776cdf0e10cSrcweir rSh.NumOrNoNum(sal_False))
1777cdf0e10cSrcweir eKeyState = KS_NumOrNoNum;
1778cdf0e10cSrcweir break;
1779cdf0e10cSrcweir
1780cdf0e10cSrcweir case KEY_DELETE | KEY_MOD2:
1781cdf0e10cSrcweir if( !rSh.IsTableMode() && rSh.GetTableFmt() )
1782cdf0e10cSrcweir {
1783cdf0e10cSrcweir eKeyState = KS_Ende;
1784cdf0e10cSrcweir bTblInsDelMode = sal_True;
1785cdf0e10cSrcweir bTblIsInsMode = sal_False;
1786cdf0e10cSrcweir bTblIsColMode = sal_True;
1787cdf0e10cSrcweir aKeyInputTimer.Start();
1788cdf0e10cSrcweir bStopKeyInputTimer = sal_False;
1789cdf0e10cSrcweir }
1790cdf0e10cSrcweir break;
1791cdf0e10cSrcweir case KEY_INSERT | KEY_MOD2:
1792cdf0e10cSrcweir if( !rSh.IsTableMode() && rSh.GetTableFmt() )
1793cdf0e10cSrcweir {
1794cdf0e10cSrcweir eKeyState = KS_Ende;
1795cdf0e10cSrcweir bTblInsDelMode = sal_True;
1796cdf0e10cSrcweir bTblIsInsMode = sal_True;
1797cdf0e10cSrcweir bTblIsColMode = sal_True;
1798cdf0e10cSrcweir aKeyInputTimer.Start();
1799cdf0e10cSrcweir bStopKeyInputTimer = sal_False;
1800cdf0e10cSrcweir }
1801cdf0e10cSrcweir break;
1802cdf0e10cSrcweir
1803cdf0e10cSrcweir case KEY_RETURN: // Return
180469a74367SOliver-Rainer Wittmann if ( !rSh.HasReadonlySel()
180569a74367SOliver-Rainer Wittmann && !rSh.CrsrInsideInputFld() )
1806cdf0e10cSrcweir {
1807cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType();
1808cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_OLE)
1809cdf0e10cSrcweir eKeyState = KS_LaunchOLEObject;
1810cdf0e10cSrcweir else if(nSelectionType & nsSelectionType::SEL_FRM)
1811cdf0e10cSrcweir eKeyState = KS_GoIntoFly;
1812cdf0e10cSrcweir else if((nSelectionType & nsSelectionType::SEL_DRW) &&
1813cdf0e10cSrcweir 0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) &&
1814cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)
1815cdf0e10cSrcweir eKeyState = KS_GoIntoDrawing;
1816cdf0e10cSrcweir else if( aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
1817cdf0e10cSrcweir aTmpQHD.bIsAutoText )
1818cdf0e10cSrcweir eKeyState = KS_GlossaryExpand;
1819cdf0e10cSrcweir
1820cdf0e10cSrcweir //RETURN und leerer Absatz in Numerierung -> Num. beenden
1821cdf0e10cSrcweir else if( !aInBuffer.Len() &&
1822cdf0e10cSrcweir rSh.GetCurNumRule() &&
1823cdf0e10cSrcweir !rSh.GetCurNumRule()->IsOutlineRule() &&
1824cdf0e10cSrcweir !rSh.HasSelection() &&
1825cdf0e10cSrcweir rSh.IsSttPara() && rSh.IsEndPara() )
1826cdf0e10cSrcweir eKeyState = KS_NumOff, eNextKeyState = KS_OutlineLvOff;
1827cdf0e10cSrcweir
1828cdf0e10cSrcweir //RETURN fuer neuen Absatz mit AutoFormatierung
1829cdf0e10cSrcweir else if( pACfg && pACfg->IsAutoFmtByInput() &&
1830cdf0e10cSrcweir !(nSelectionType & (nsSelectionType::SEL_GRF |
1831cdf0e10cSrcweir nsSelectionType::SEL_OLE | nsSelectionType::SEL_FRM |
1832cdf0e10cSrcweir nsSelectionType::SEL_TBL_CELLS | nsSelectionType::SEL_DRW |
1833cdf0e10cSrcweir nsSelectionType::SEL_DRW_TXT)) )
1834cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_AutoFmtByInput;
1835cdf0e10cSrcweir else
1836cdf0e10cSrcweir eNextKeyState = eKeyState, eKeyState = KS_CheckAutoCorrect;
1837cdf0e10cSrcweir }
1838cdf0e10cSrcweir break;
1839cdf0e10cSrcweir
1840cdf0e10cSrcweir case KEY_RETURN | KEY_MOD2: // ALT-Return
184169a74367SOliver-Rainer Wittmann if ( !rSh.HasReadonlySel()
184269a74367SOliver-Rainer Wittmann && !rSh.IsSttPara()
184369a74367SOliver-Rainer Wittmann && rSh.GetCurNumRule()
184469a74367SOliver-Rainer Wittmann && !rSh.CrsrInsideInputFld() )
184569a74367SOliver-Rainer Wittmann {
1846cdf0e10cSrcweir eKeyState = KS_NoNum;
184769a74367SOliver-Rainer Wittmann }
1848cdf0e10cSrcweir else if( rSh.CanSpecialInsert() )
1849cdf0e10cSrcweir eKeyState = KS_SpecialInsert;
1850cdf0e10cSrcweir break;
1851cdf0e10cSrcweir
1852cdf0e10cSrcweir case KEY_BACKSPACE:
1853cdf0e10cSrcweir case KEY_BACKSPACE | KEY_SHIFT:
1854*23d8f725SOliver-Rainer Wittmann if ( !rSh.HasReadonlySel()
1855*23d8f725SOliver-Rainer Wittmann && !rSh.CrsrInsideInputFld() )
1856cdf0e10cSrcweir {
1857cdf0e10cSrcweir sal_Bool bDone = sal_False;
1858cdf0e10cSrcweir // Remove the paragraph indent, if the cursor is at the
1859cdf0e10cSrcweir // beginning of a paragraph, there is no selection
1860cdf0e10cSrcweir // and no numbering rule found at the current paragraph
1861cdf0e10cSrcweir // Also try to remove indent, if current paragraph
1862cdf0e10cSrcweir // has numbering rule, but isn't counted and only
1863cdf0e10cSrcweir // key <backspace> is hit.
1864*23d8f725SOliver-Rainer Wittmann const bool bOnlyBackspaceKey( KEY_BACKSPACE == rKeyCode.GetFullCode() );
1865*23d8f725SOliver-Rainer Wittmann if ( rSh.IsSttPara()
1866*23d8f725SOliver-Rainer Wittmann && !rSh.HasSelection()
1867*23d8f725SOliver-Rainer Wittmann && ( rSh.GetCurNumRule() == NULL
1868*23d8f725SOliver-Rainer Wittmann || ( rSh.IsNoNum() && bOnlyBackspaceKey ) ) )
1869cdf0e10cSrcweir {
1870cdf0e10cSrcweir bDone = rSh.TryRemoveIndent();
1871cdf0e10cSrcweir }
1872cdf0e10cSrcweir
1873cdf0e10cSrcweir if (bDone)
1874cdf0e10cSrcweir eKeyState = KS_Ende;
1875cdf0e10cSrcweir else
1876cdf0e10cSrcweir {
1877*23d8f725SOliver-Rainer Wittmann if ( rSh.IsSttPara() && !rSh.IsNoNum() )
1878cdf0e10cSrcweir {
1879*23d8f725SOliver-Rainer Wittmann if (nKS_NUMDOWN_Count > 0
1880*23d8f725SOliver-Rainer Wittmann && rSh.GetNumLevel() > 0)
1881cdf0e10cSrcweir {
1882cdf0e10cSrcweir eKeyState = KS_NumUp;
1883cdf0e10cSrcweir nKS_NUMDOWN_Count = 2;
1884cdf0e10cSrcweir bDone = sal_True;
1885cdf0e10cSrcweir }
1886cdf0e10cSrcweir else if (nKS_NUMINDENTINC_Count > 0)
1887cdf0e10cSrcweir {
1888cdf0e10cSrcweir eKeyState = KS_NumIndentDec;
1889cdf0e10cSrcweir nKS_NUMINDENTINC_Count = 2;
1890cdf0e10cSrcweir bDone = sal_True;
1891cdf0e10cSrcweir }
1892cdf0e10cSrcweir }
1893cdf0e10cSrcweir // If the cursor is in an empty paragraph, which has
1894*23d8f725SOliver-Rainer Wittmann // a numbering, but not the outline numbering, and
1895cdf0e10cSrcweir // there is no selection, the numbering has to be
1896cdf0e10cSrcweir // deleted on key <Backspace>.
1897cdf0e10cSrcweir // Otherwise method <SwEditShell::NumOrNoNum(..)>
1898cdf0e10cSrcweir // should only change the <IsCounted()> state of
1899cdf0e10cSrcweir // the current paragraph depending of the key.
1900cdf0e10cSrcweir // On <backspace> it is set to <false>,
1901cdf0e10cSrcweir // on <shift-backspace> it is set to <true>.
1902cdf0e10cSrcweir // Thus, assure that method <SwEditShell::NumOrNum(..)>
1903cdf0e10cSrcweir // is only called for the intended purpose.
1904*23d8f725SOliver-Rainer Wittmann if ( !bDone && rSh.IsSttPara() )
1905cdf0e10cSrcweir {
1906*23d8f725SOliver-Rainer Wittmann bool bCallNumOrNoNum( false );
1907*23d8f725SOliver-Rainer Wittmann if ( bOnlyBackspaceKey && !rSh.IsNoNum() )
1908cdf0e10cSrcweir {
1909*23d8f725SOliver-Rainer Wittmann bCallNumOrNoNum = true;
1910*23d8f725SOliver-Rainer Wittmann }
1911*23d8f725SOliver-Rainer Wittmann else if ( !bOnlyBackspaceKey && rSh.IsNoNum() )
1912*23d8f725SOliver-Rainer Wittmann {
1913*23d8f725SOliver-Rainer Wittmann bCallNumOrNoNum = true;
1914*23d8f725SOliver-Rainer Wittmann }
1915*23d8f725SOliver-Rainer Wittmann else if ( bOnlyBackspaceKey
1916*23d8f725SOliver-Rainer Wittmann && rSh.IsSttPara()
1917*23d8f725SOliver-Rainer Wittmann && rSh.IsEndPara()
1918*23d8f725SOliver-Rainer Wittmann && !rSh.HasSelection() )
1919*23d8f725SOliver-Rainer Wittmann {
1920*23d8f725SOliver-Rainer Wittmann const SwNumRule* pCurrNumRule( rSh.GetCurNumRule() );
1921*23d8f725SOliver-Rainer Wittmann if ( pCurrNumRule != NULL
1922*23d8f725SOliver-Rainer Wittmann && pCurrNumRule != rSh.GetOutlineNumRule() )
1923cdf0e10cSrcweir {
1924cdf0e10cSrcweir bCallNumOrNoNum = true;
1925cdf0e10cSrcweir }
1926*23d8f725SOliver-Rainer Wittmann }
1927*23d8f725SOliver-Rainer Wittmann if ( bCallNumOrNoNum
1928*23d8f725SOliver-Rainer Wittmann && rSh.NumOrNoNum( !bOnlyBackspaceKey, sal_True ) )
1929*23d8f725SOliver-Rainer Wittmann {
1930*23d8f725SOliver-Rainer Wittmann eKeyState = KS_NumOrNoNum;
1931cdf0e10cSrcweir }
1932cdf0e10cSrcweir }
1933cdf0e10cSrcweir }
1934cdf0e10cSrcweir }
1935cdf0e10cSrcweir break;
1936cdf0e10cSrcweir
1937cdf0e10cSrcweir case KEY_RIGHT:
1938cdf0e10cSrcweir {
1939cdf0e10cSrcweir eFlyState = KS_Fly_Change;
1940cdf0e10cSrcweir nDir = MOVE_RIGHT_BIG;
1941cdf0e10cSrcweir eTblChgMode = nsTblChgWidthHeightType::WH_FLAG_INSDEL | nsTblChgWidthHeightType::WH_COL_RIGHT;
1942cdf0e10cSrcweir nTblChgSize = pModOpt->GetTblVInsert();
1943cdf0e10cSrcweir goto KEYINPUT_CHECKTABLE_INSDEL;
1944cdf0e10cSrcweir }
1945cdf0e10cSrcweir case KEY_TAB:
1946cdf0e10cSrcweir {
1947cdf0e10cSrcweir
1948cdf0e10cSrcweir #ifdef SW_CRSR_TIMER
1949cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
1950cdf0e10cSrcweir #endif
1951cdf0e10cSrcweir if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark() || rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
1952cdf0e10cSrcweir {
1953cdf0e10cSrcweir eKeyState=KS_GotoNextFieldMark;
1954cdf0e10cSrcweir }
195569a74367SOliver-Rainer Wittmann else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
195669a74367SOliver-Rainer Wittmann {
195769a74367SOliver-Rainer Wittmann GetView().GetViewFrame()->GetDispatcher()->Execute( FN_GOTO_NEXT_INPUTFLD );
195869a74367SOliver-Rainer Wittmann eKeyState = KS_Ende;
195969a74367SOliver-Rainer Wittmann }
1960*23d8f725SOliver-Rainer Wittmann else if( rSh.GetCurNumRule()
1961*23d8f725SOliver-Rainer Wittmann && rSh.IsSttOfPara()
1962*23d8f725SOliver-Rainer Wittmann && !rSh.HasReadonlySel() )
1963cdf0e10cSrcweir {
1964cdf0e10cSrcweir if ( rSh.IsFirstOfNumRule() &&
1965cdf0e10cSrcweir numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
1966cdf0e10cSrcweir eKeyState = KS_NumIndentInc;
1967cdf0e10cSrcweir else
1968cdf0e10cSrcweir eKeyState = KS_NumDown;
1969cdf0e10cSrcweir }
1970cdf0e10cSrcweir else if ( rSh.GetTableFmt() )
1971cdf0e10cSrcweir {
1972cdf0e10cSrcweir if( rSh.HasSelection() || rSh.HasReadonlySel() )
1973cdf0e10cSrcweir eKeyState = KS_NextCell;
1974cdf0e10cSrcweir else
1975cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_NextCell;
1976cdf0e10cSrcweir }
1977cdf0e10cSrcweir else if ( rSh.GetSelectionType() &
1978cdf0e10cSrcweir (nsSelectionType::SEL_GRF |
1979cdf0e10cSrcweir nsSelectionType::SEL_FRM |
1980cdf0e10cSrcweir nsSelectionType::SEL_OLE |
1981cdf0e10cSrcweir nsSelectionType::SEL_DRW |
1982cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM))
1983cdf0e10cSrcweir
1984cdf0e10cSrcweir eKeyState = KS_NextObject;
1985cdf0e10cSrcweir else
1986cdf0e10cSrcweir {
1987cdf0e10cSrcweir eKeyState = KS_InsTab;
1988cdf0e10cSrcweir if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
1989cdf0e10cSrcweir {
1990cdf0e10cSrcweir SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
1991cdf0e10cSrcweir if( pColl &&
1992cdf0e10cSrcweir //0 <= pColl->GetOutlineLevel() && #i24560#
1993cdf0e10cSrcweir //MAXLEVEL - 1 > pColl->GetOutlineLevel() )//#outline level,zhaojianwei
1994cdf0e10cSrcweir pColl->IsAssignedToListLevelOfOutlineStyle()
1995cdf0e10cSrcweir && MAXLEVEL-1 > pColl->GetAssignedOutlineStyleLevel() )//<-end,zhaojianwei
1996cdf0e10cSrcweir eKeyState = KS_OutlineDown;
1997cdf0e10cSrcweir }
1998cdf0e10cSrcweir }
1999cdf0e10cSrcweir #ifdef SW_CRSR_TIMER
2000cdf0e10cSrcweir rSh.ChgCrsrTimerFlag( bOld );
2001cdf0e10cSrcweir #endif
2002cdf0e10cSrcweir }
2003cdf0e10cSrcweir break;
2004cdf0e10cSrcweir case KEY_TAB | KEY_SHIFT:
2005cdf0e10cSrcweir {
2006cdf0e10cSrcweir #ifdef SW_CRSR_TIMER
2007cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
2008cdf0e10cSrcweir sal_Bool bOld = rSh.ChgCrsrTimerFlag( sal_False );
2009cdf0e10cSrcweir #endif
201069a74367SOliver-Rainer Wittmann if (rSh.IsFormProtected() || rSh.GetCurrentFieldmark()|| rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
201169a74367SOliver-Rainer Wittmann {
2012cdf0e10cSrcweir eKeyState=KS_GotoPrevFieldMark;
2013cdf0e10cSrcweir }
201469a74367SOliver-Rainer Wittmann else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
201569a74367SOliver-Rainer Wittmann {
201669a74367SOliver-Rainer Wittmann GetView().GetViewFrame()->GetDispatcher()->Execute( FN_GOTO_PREV_INPUTFLD );
201769a74367SOliver-Rainer Wittmann eKeyState = KS_Ende;
201869a74367SOliver-Rainer Wittmann }
2019*23d8f725SOliver-Rainer Wittmann else if( rSh.GetCurNumRule()
2020*23d8f725SOliver-Rainer Wittmann && rSh.IsSttOfPara()
2021*23d8f725SOliver-Rainer Wittmann && !rSh.HasReadonlySel() )
2022cdf0e10cSrcweir {
2023cdf0e10cSrcweir if ( rSh.IsFirstOfNumRule() &&
2024cdf0e10cSrcweir numfunc::ChangeIndentOnTabAtFirstPosOfFirstListItem() )
2025cdf0e10cSrcweir eKeyState = KS_NumIndentDec;
2026cdf0e10cSrcweir else
2027cdf0e10cSrcweir eKeyState = KS_NumUp;
2028cdf0e10cSrcweir }
2029cdf0e10cSrcweir else if ( rSh.GetTableFmt() )
2030cdf0e10cSrcweir {
2031cdf0e10cSrcweir if( rSh.HasSelection() || rSh.HasReadonlySel() )
2032cdf0e10cSrcweir eKeyState = KS_PrevCell;
2033cdf0e10cSrcweir else
2034cdf0e10cSrcweir eKeyState = KS_CheckAutoCorrect, eNextKeyState = KS_PrevCell;
2035cdf0e10cSrcweir }
2036cdf0e10cSrcweir else if ( rSh.GetSelectionType() &
2037cdf0e10cSrcweir (nsSelectionType::SEL_GRF |
2038cdf0e10cSrcweir nsSelectionType::SEL_FRM |
2039cdf0e10cSrcweir nsSelectionType::SEL_OLE |
2040cdf0e10cSrcweir nsSelectionType::SEL_DRW |
2041cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM))
2042cdf0e10cSrcweir
2043cdf0e10cSrcweir eKeyState = KS_PrevObject;
2044cdf0e10cSrcweir else
2045cdf0e10cSrcweir {
2046cdf0e10cSrcweir eKeyState = KS_Ende;
2047cdf0e10cSrcweir if( rSh.IsSttOfPara() && !rSh.HasReadonlySel() )
2048cdf0e10cSrcweir {
2049cdf0e10cSrcweir SwTxtFmtColl* pColl = rSh.GetCurTxtFmtColl();
2050cdf0e10cSrcweir //if( pColl && 0 < pColl->GetOutlineLevel() && //#outline level,zhaojianwei
2051cdf0e10cSrcweir // MAXLEVEL - 1 >= pColl->GetOutlineLevel() )
2052cdf0e10cSrcweir if( pColl &&
2053cdf0e10cSrcweir pColl->IsAssignedToListLevelOfOutlineStyle() &&
2054cdf0e10cSrcweir 0 < pColl->GetAssignedOutlineStyleLevel())
2055cdf0e10cSrcweir eKeyState = KS_OutlineUp;
2056cdf0e10cSrcweir }
2057cdf0e10cSrcweir }
2058cdf0e10cSrcweir #ifdef SW_CRSR_TIMER
2059cdf0e10cSrcweir rSh.ChgCrsrTimerFlag( bOld );
2060cdf0e10cSrcweir #endif
2061cdf0e10cSrcweir }
2062cdf0e10cSrcweir break;
2063cdf0e10cSrcweir case KEY_TAB | KEY_MOD1:
2064cdf0e10cSrcweir case KEY_TAB | KEY_MOD2:
2065cdf0e10cSrcweir if( !rSh.HasReadonlySel() )
2066cdf0e10cSrcweir {
2067cdf0e10cSrcweir if( aTmpQHD.HasCntnt() && !rSh.HasSelection() )
2068cdf0e10cSrcweir {
2069cdf0e10cSrcweir // zum naechsten Tip
2070cdf0e10cSrcweir aTmpQHD.Inc( pACorr && pACorr->GetSwFlags().
2071cdf0e10cSrcweir bAutoCmpltEndless );
2072cdf0e10cSrcweir eKeyState = KS_NextPrevGlossary;
2073cdf0e10cSrcweir }
2074cdf0e10cSrcweir else if( rSh.GetTableFmt() )
2075cdf0e10cSrcweir eKeyState = KS_InsTab;
2076cdf0e10cSrcweir else if((rSh.GetSelectionType() &
2077cdf0e10cSrcweir (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM|
2078cdf0e10cSrcweir nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) &&
2079cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked())
2080cdf0e10cSrcweir eKeyState = KS_EnterDrawHandleMode;
2081cdf0e10cSrcweir else
2082cdf0e10cSrcweir {
2083cdf0e10cSrcweir eKeyState = KS_InsTab;
2084cdf0e10cSrcweir }
2085cdf0e10cSrcweir }
2086cdf0e10cSrcweir break;
2087cdf0e10cSrcweir
2088cdf0e10cSrcweir case KEY_TAB | KEY_MOD1 | KEY_SHIFT:
2089cdf0e10cSrcweir if( aTmpQHD.HasCntnt() && !rSh.HasSelection() &&
2090cdf0e10cSrcweir !rSh.HasReadonlySel() )
2091cdf0e10cSrcweir {
2092cdf0e10cSrcweir // zum vorherigen Tip
2093cdf0e10cSrcweir aTmpQHD.Dec( pACorr && pACorr->GetSwFlags().
2094cdf0e10cSrcweir bAutoCmpltEndless );
2095cdf0e10cSrcweir eKeyState = KS_NextPrevGlossary;
2096cdf0e10cSrcweir }
2097cdf0e10cSrcweir else if((rSh.GetSelectionType() & (nsSelectionType::SEL_DRW|nsSelectionType::SEL_DRW_FORM|
2098cdf0e10cSrcweir nsSelectionType::SEL_FRM|nsSelectionType::SEL_OLE|nsSelectionType::SEL_GRF)) &&
2099cdf0e10cSrcweir rSh.GetDrawView()->AreObjectsMarked())
2100cdf0e10cSrcweir eKeyState = KS_EnterDrawHandleMode;
2101cdf0e10cSrcweir break;
2102cdf0e10cSrcweir case KEY_F2 :
2103cdf0e10cSrcweir if( !rSh.HasReadonlySel() )
2104cdf0e10cSrcweir {
2105cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType();
2106cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_FRM)
2107cdf0e10cSrcweir eKeyState = KS_GoIntoFly;
2108cdf0e10cSrcweir else if((nSelectionType & nsSelectionType::SEL_DRW))
2109cdf0e10cSrcweir eKeyState = KS_GoIntoDrawing;
2110cdf0e10cSrcweir }
2111cdf0e10cSrcweir break;
2112cdf0e10cSrcweir }
2113cdf0e10cSrcweir }
2114cdf0e10cSrcweir break;
2115cdf0e10cSrcweir case KS_CheckDocReadOnlyKeys:
2116cdf0e10cSrcweir {
2117cdf0e10cSrcweir eKeyState = KS_KeyToView;
2118cdf0e10cSrcweir switch( rKeyCode.GetModifier() | rKeyCode.GetCode() )
2119cdf0e10cSrcweir {
2120cdf0e10cSrcweir case KEY_TAB:
2121cdf0e10cSrcweir case KEY_TAB | KEY_SHIFT:
2122cdf0e10cSrcweir bNormalChar = sal_False;
2123cdf0e10cSrcweir eKeyState = KS_Ende;
2124cdf0e10cSrcweir if ( rSh.GetSelectionType() &
2125cdf0e10cSrcweir (nsSelectionType::SEL_GRF |
2126cdf0e10cSrcweir nsSelectionType::SEL_FRM |
2127cdf0e10cSrcweir nsSelectionType::SEL_OLE |
2128cdf0e10cSrcweir nsSelectionType::SEL_DRW |
2129cdf0e10cSrcweir nsSelectionType::SEL_DRW_FORM))
2130cdf0e10cSrcweir
2131cdf0e10cSrcweir {
2132cdf0e10cSrcweir eKeyState = rKeyCode.GetModifier() & KEY_SHIFT ?
2133cdf0e10cSrcweir KS_PrevObject : KS_NextObject;
2134cdf0e10cSrcweir }
213569a74367SOliver-Rainer Wittmann else if ( !rSh.IsMultiSelection() && rSh.CrsrInsideInputFld() )
213669a74367SOliver-Rainer Wittmann {
213769a74367SOliver-Rainer Wittmann GetView().GetViewFrame()->GetDispatcher()->Execute(
213869a74367SOliver-Rainer Wittmann KEY_SHIFT != rKeyCode.GetModifier() ? FN_GOTO_NEXT_INPUTFLD : FN_GOTO_PREV_INPUTFLD );
213969a74367SOliver-Rainer Wittmann }
2140cdf0e10cSrcweir else
214169a74367SOliver-Rainer Wittmann {
214269a74367SOliver-Rainer Wittmann rSh.SelectNextPrevHyperlink( KEY_SHIFT != rKeyCode.GetModifier() );
214369a74367SOliver-Rainer Wittmann }
2144cdf0e10cSrcweir break;
2145cdf0e10cSrcweir case KEY_RETURN:
2146cdf0e10cSrcweir {
2147cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType();
2148cdf0e10cSrcweir if(nSelectionType & nsSelectionType::SEL_FRM)
2149cdf0e10cSrcweir eKeyState = KS_GoIntoFly;
2150cdf0e10cSrcweir else
2151cdf0e10cSrcweir {
2152cdf0e10cSrcweir SfxItemSet aSet(rSh.GetAttrPool(), RES_TXTATR_INETFMT, RES_TXTATR_INETFMT);
2153cdf0e10cSrcweir rSh.GetCurAttr(aSet);
2154cdf0e10cSrcweir if(SFX_ITEM_SET == aSet.GetItemState(RES_TXTATR_INETFMT, sal_False))
2155cdf0e10cSrcweir {
2156cdf0e10cSrcweir const SfxPoolItem& rItem = aSet.Get(RES_TXTATR_INETFMT, sal_True);
2157cdf0e10cSrcweir bNormalChar = sal_False;
2158cdf0e10cSrcweir eKeyState = KS_Ende;
2159cdf0e10cSrcweir rSh.ClickToINetAttr((const SwFmtINetFmt&)rItem, URLLOAD_NOFILTER);
2160cdf0e10cSrcweir }
2161cdf0e10cSrcweir }
2162cdf0e10cSrcweir }
2163cdf0e10cSrcweir break;
2164cdf0e10cSrcweir }
2165cdf0e10cSrcweir }
2166cdf0e10cSrcweir break;
2167cdf0e10cSrcweir
2168cdf0e10cSrcweir case KS_EnterCharCell:
2169cdf0e10cSrcweir {
2170cdf0e10cSrcweir eKeyState = KS_KeyToView;
2171cdf0e10cSrcweir switch ( rKeyCode.GetModifier() | rKeyCode.GetCode() )
2172cdf0e10cSrcweir {
2173cdf0e10cSrcweir case KEY_RIGHT | KEY_MOD2:
2174cdf0e10cSrcweir rSh.Right( CRSR_SKIP_CHARS, sal_False, 1, sal_False );
2175cdf0e10cSrcweir eKeyState = KS_Ende;
2176cdf0e10cSrcweir FlushInBuffer();
2177cdf0e10cSrcweir break;
2178cdf0e10cSrcweir case KEY_LEFT | KEY_MOD2:
2179cdf0e10cSrcweir rSh.Left( CRSR_SKIP_CHARS, sal_False, 1, sal_False );
2180cdf0e10cSrcweir eKeyState = KS_Ende;
2181cdf0e10cSrcweir FlushInBuffer();
2182cdf0e10cSrcweir break;
2183cdf0e10cSrcweir }
2184cdf0e10cSrcweir }
2185cdf0e10cSrcweir break;
2186cdf0e10cSrcweir
2187cdf0e10cSrcweir case KS_KeyToView:
2188cdf0e10cSrcweir {
2189cdf0e10cSrcweir eKeyState = KS_Ende;
2190cdf0e10cSrcweir bNormalChar =
2191cdf0e10cSrcweir !rKeyCode.IsMod2() &&
2192cdf0e10cSrcweir rKeyCode.GetModifier() != (KEY_MOD1) &&
2193cdf0e10cSrcweir rKeyCode.GetModifier() != (KEY_MOD1|KEY_SHIFT) &&
2194cdf0e10cSrcweir SW_ISPRINTABLE( aCh );
2195cdf0e10cSrcweir
2196cdf0e10cSrcweir if (bNormalChar && rSh.IsInFrontOfLabel())
2197cdf0e10cSrcweir {
2198cdf0e10cSrcweir rSh.NumOrNoNum(sal_False);
2199cdf0e10cSrcweir }
2200cdf0e10cSrcweir
2201cdf0e10cSrcweir if( aInBuffer.Len() && ( !bNormalChar || bIsDocReadOnly ))
2202cdf0e10cSrcweir FlushInBuffer();
2203cdf0e10cSrcweir
2204cdf0e10cSrcweir if( rView.KeyInput( aKeyEvent ) )
2205cdf0e10cSrcweir bFlushBuffer = sal_True, bNormalChar = sal_False;
2206cdf0e10cSrcweir else
2207cdf0e10cSrcweir {
2208cdf0e10cSrcweir // OS 22.09.95: Da der Sfx Acceleratoren nur aufruft, wenn sie beim letzten
2209cdf0e10cSrcweir // Statusupdate enabled wurden, muss copy ggf. von uns
2210cdf0e10cSrcweir // 'gewaltsam' gerufen werden.
2211cdf0e10cSrcweir if( rKeyCode.GetFunction() == KEYFUNC_COPY )
2212cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute(SID_COPY);
2213cdf0e10cSrcweir
2214cdf0e10cSrcweir
2215cdf0e10cSrcweir if( !bIsDocReadOnly && bNormalChar )
2216cdf0e10cSrcweir {
2217cdf0e10cSrcweir const int nSelectionType = rSh.GetSelectionType();
2218cdf0e10cSrcweir if((nSelectionType & nsSelectionType::SEL_DRW) &&
2219cdf0e10cSrcweir 0 == (nSelectionType & nsSelectionType::SEL_DRW_TXT) &&
2220cdf0e10cSrcweir rSh.GetDrawView()->GetMarkedObjectList().GetMarkCount() == 1)
2221cdf0e10cSrcweir {
2222cdf0e10cSrcweir SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
2223cdf0e10cSrcweir if(pObj)
2224cdf0e10cSrcweir {
2225cdf0e10cSrcweir EnterDrawTextMode(pObj->GetLogicRect().Center());
2226cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
2227cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init();
2228cdf0e10cSrcweir rSh.GetDrawView()->KeyInput( rKEvt, this );
2229cdf0e10cSrcweir }
2230cdf0e10cSrcweir }
2231cdf0e10cSrcweir else if(nSelectionType & nsSelectionType::SEL_FRM)
2232cdf0e10cSrcweir {
2233cdf0e10cSrcweir rSh.UnSelectFrm();
2234cdf0e10cSrcweir rSh.LeaveSelFrmMode();
2235cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
2236cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd );
2237cdf0e10cSrcweir }
2238cdf0e10cSrcweir eKeyState = KS_InsChar;
2239cdf0e10cSrcweir }
2240cdf0e10cSrcweir else
2241cdf0e10cSrcweir {
2242cdf0e10cSrcweir bNormalChar = sal_False;
2243cdf0e10cSrcweir Window::KeyInput( aKeyEvent );
2244cdf0e10cSrcweir }
2245cdf0e10cSrcweir }
2246cdf0e10cSrcweir }
2247cdf0e10cSrcweir break;
2248cdf0e10cSrcweir case KS_LaunchOLEObject:
2249cdf0e10cSrcweir rSh.LaunchOLEObj();
2250cdf0e10cSrcweir eKeyState = KS_Ende;
2251cdf0e10cSrcweir break;
2252cdf0e10cSrcweir case KS_GoIntoFly :
2253cdf0e10cSrcweir rSh.UnSelectFrm();
2254cdf0e10cSrcweir rSh.LeaveSelFrmMode();
2255cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
2256cdf0e10cSrcweir rSh.MoveSection( fnSectionCurr, fnSectionEnd );
2257cdf0e10cSrcweir eKeyState = KS_Ende;
2258cdf0e10cSrcweir break;
2259cdf0e10cSrcweir case KS_GoIntoDrawing :
2260cdf0e10cSrcweir {
2261cdf0e10cSrcweir SdrObject* pObj = rSh.GetDrawView()->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();
2262cdf0e10cSrcweir if(pObj)
2263cdf0e10cSrcweir {
2264cdf0e10cSrcweir EnterDrawTextMode(pObj->GetLogicRect().Center());
2265cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
2266cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init();
2267cdf0e10cSrcweir }
2268cdf0e10cSrcweir eKeyState = KS_Ende;
2269cdf0e10cSrcweir }
2270cdf0e10cSrcweir break;
2271cdf0e10cSrcweir case KS_EnterDrawHandleMode:
2272cdf0e10cSrcweir {
2273cdf0e10cSrcweir const SdrHdlList& rHdlList = rSh.GetDrawView()->GetHdlList();
2274cdf0e10cSrcweir sal_Bool bForward(!aKeyEvent.GetKeyCode().IsShift());
2275cdf0e10cSrcweir
2276cdf0e10cSrcweir ((SdrHdlList&)rHdlList).TravelFocusHdl(bForward);
2277cdf0e10cSrcweir eKeyState = KS_Ende;
2278cdf0e10cSrcweir }
2279cdf0e10cSrcweir break;
2280cdf0e10cSrcweir case KS_InsTab:
2281cdf0e10cSrcweir if( rView.ISA( SwWebView )) //Kein Tabulator fuer Web!
2282cdf0e10cSrcweir {
2283cdf0e10cSrcweir Window::KeyInput( aKeyEvent );
2284cdf0e10cSrcweir eKeyState = KS_Ende;
2285cdf0e10cSrcweir break;
2286cdf0e10cSrcweir }
2287cdf0e10cSrcweir aCh = '\t';
2288cdf0e10cSrcweir // kein break!
2289cdf0e10cSrcweir case KS_InsChar:
2290cdf0e10cSrcweir if (rSh.GetChar(sal_False)==CH_TXT_ATR_FORMELEMENT)
2291cdf0e10cSrcweir {
2292cdf0e10cSrcweir ::sw::mark::ICheckboxFieldmark* pFieldmark =
2293cdf0e10cSrcweir dynamic_cast< ::sw::mark::ICheckboxFieldmark* >
2294cdf0e10cSrcweir (rSh.GetCurrentFieldmark());
2295cdf0e10cSrcweir OSL_ENSURE(pFieldmark,
2296cdf0e10cSrcweir "Where is my FieldMark??");
2297cdf0e10cSrcweir if(pFieldmark)
2298cdf0e10cSrcweir {
2299cdf0e10cSrcweir pFieldmark->SetChecked(!pFieldmark->IsChecked());
2300cdf0e10cSrcweir OSL_ENSURE(pFieldmark->IsExpanded(),
2301cdf0e10cSrcweir "where is the otherpos?");
2302cdf0e10cSrcweir if (pFieldmark->IsExpanded())
2303cdf0e10cSrcweir {
23045b40a975SOliver-Rainer Wittmann rSh.CalcLayout();
2305cdf0e10cSrcweir }
2306cdf0e10cSrcweir }
2307cdf0e10cSrcweir eKeyState = KS_Ende;
2308cdf0e10cSrcweir }
2309*23d8f725SOliver-Rainer Wittmann else if ( !rSh.HasReadonlySel()
2310*23d8f725SOliver-Rainer Wittmann || rSh.CrsrInsideInputFld() )
2311cdf0e10cSrcweir {
2312*23d8f725SOliver-Rainer Wittmann const sal_Bool bIsNormalChar =
2313*23d8f725SOliver-Rainer Wittmann GetAppCharClass().isLetterNumeric( String( aCh ), 0 );
2314cdf0e10cSrcweir if( bChkInsBlank && bIsNormalChar &&
2315cdf0e10cSrcweir (aInBuffer.Len() || !rSh.IsSttPara() || !rSh.IsEndPara() ))
2316cdf0e10cSrcweir {
2317cdf0e10cSrcweir // vor dem Zeichen noch ein Blank einfuegen. Dieses
2318cdf0e10cSrcweir // kommt zwischen den Expandierten Text und dem neuen
2319cdf0e10cSrcweir // "nicht Worttrenner".
2320cdf0e10cSrcweir aInBuffer.Expand( aInBuffer.Len() + 1, ' ' );
2321cdf0e10cSrcweir }
2322cdf0e10cSrcweir
2323*23d8f725SOliver-Rainer Wittmann const sal_Bool bIsAutoCorrectChar = SvxAutoCorrect::IsAutoCorrectChar( aCh );
2324*23d8f725SOliver-Rainer Wittmann const sal_Bool bRunNext = pACorr != NULL && pACorr->HasRunNext();
2325cdf0e10cSrcweir if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) &&
2326cdf0e10cSrcweir pACfg->IsAutoFmtByInput() &&
2327cdf0e10cSrcweir (( pACorr->IsAutoCorrFlag( ChgWeightUnderl ) &&
2328cdf0e10cSrcweir ( '*' == aCh || '_' == aCh ) ) ||
2329cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))||
2330cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh))))
2331cdf0e10cSrcweir {
2332cdf0e10cSrcweir FlushInBuffer();
2333cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh );
2334cdf0e10cSrcweir if( '\"' != aCh && '\'' != aCh ) // nur bei "*_" rufen!
2335cdf0e10cSrcweir rSh.UpdateAttr();
2336cdf0e10cSrcweir }
2337cdf0e10cSrcweir else if( !aKeyEvent.GetRepeat() && pACorr && ( bIsAutoCorrectChar || bRunNext ) &&
2338cdf0e10cSrcweir pACfg->IsAutoFmtByInput() &&
2339cdf0e10cSrcweir pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd |
2340cdf0e10cSrcweir ChgOrdinalNumber | AddNonBrkSpace |
2341cdf0e10cSrcweir ChgToEnEmDash | SetINetAttr |
2342cdf0e10cSrcweir Autocorrect ) &&
2343cdf0e10cSrcweir '\"' != aCh && '\'' != aCh && '*' != aCh && '_' != aCh
2344cdf0e10cSrcweir )
2345cdf0e10cSrcweir {
2346cdf0e10cSrcweir FlushInBuffer();
2347cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh );
2348cdf0e10cSrcweir }
2349cdf0e10cSrcweir else
2350cdf0e10cSrcweir {
2351cdf0e10cSrcweir aInBuffer.Expand( aInBuffer.Len() + aKeyEvent.GetRepeat() + 1,aCh );
2352cdf0e10cSrcweir bFlushCharBuffer = Application::AnyInput( INPUT_KEYBOARD );
2353cdf0e10cSrcweir bFlushBuffer = !bFlushCharBuffer;
2354cdf0e10cSrcweir if( bFlushCharBuffer )
2355cdf0e10cSrcweir aKeyInputFlushTimer.Start();
2356cdf0e10cSrcweir }
2357cdf0e10cSrcweir eKeyState = KS_Ende;
2358cdf0e10cSrcweir }
2359cdf0e10cSrcweir else
2360cdf0e10cSrcweir {
2361cdf0e10cSrcweir InfoBox( this, SW_RES( MSG_READONLY_CONTENT )).Execute();
2362cdf0e10cSrcweir eKeyState = KS_Ende;
2363cdf0e10cSrcweir }
2364cdf0e10cSrcweir break;
2365cdf0e10cSrcweir
2366cdf0e10cSrcweir case KS_CheckAutoCorrect:
2367cdf0e10cSrcweir {
2368cdf0e10cSrcweir if( pACorr && pACfg->IsAutoFmtByInput() &&
2369cdf0e10cSrcweir pACorr->IsAutoCorrFlag( CptlSttSntnc | CptlSttWrd |
23705b40a975SOliver-Rainer Wittmann ChgOrdinalNumber |
2371cdf0e10cSrcweir ChgToEnEmDash | SetINetAttr |
2372cdf0e10cSrcweir Autocorrect ) &&
23735b40a975SOliver-Rainer Wittmann !rSh.HasReadonlySel() )
2374cdf0e10cSrcweir {
2375cdf0e10cSrcweir FlushInBuffer();
2376cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, static_cast< sal_Unicode >('\0') );
2377cdf0e10cSrcweir }
2378cdf0e10cSrcweir eKeyState = eNextKeyState;
2379cdf0e10cSrcweir }
2380cdf0e10cSrcweir break;
2381cdf0e10cSrcweir
2382cdf0e10cSrcweir default:
2383cdf0e10cSrcweir {
2384cdf0e10cSrcweir sal_uInt16 nSlotId = 0;
2385cdf0e10cSrcweir FlushInBuffer();
2386cdf0e10cSrcweir switch( eKeyState )
2387cdf0e10cSrcweir {
2388cdf0e10cSrcweir case KS_SpecialInsert:
2389cdf0e10cSrcweir rSh.DoSpecialInsert();
2390cdf0e10cSrcweir break;
2391cdf0e10cSrcweir
2392cdf0e10cSrcweir case KS_NoNum:
2393cdf0e10cSrcweir rSh.NoNum();
2394cdf0e10cSrcweir break;
2395cdf0e10cSrcweir
2396cdf0e10cSrcweir case KS_NumOff:
2397cdf0e10cSrcweir // Shellwechsel - also vorher aufzeichnen
2398cdf0e10cSrcweir rSh.DelNumRules();
2399cdf0e10cSrcweir eKeyState = eNextKeyState;
2400cdf0e10cSrcweir break;
2401cdf0e10cSrcweir case KS_OutlineLvOff: // delete autofmt outlinelevel later
2402cdf0e10cSrcweir break;
2403cdf0e10cSrcweir
2404cdf0e10cSrcweir case KS_NumDown:
2405cdf0e10cSrcweir rSh.NumUpDown( sal_True );
2406cdf0e10cSrcweir nKS_NUMDOWN_Count = 2; // #i23725#
2407cdf0e10cSrcweir break;
2408cdf0e10cSrcweir case KS_NumUp:
2409cdf0e10cSrcweir rSh.NumUpDown( sal_False );
2410cdf0e10cSrcweir break;
2411cdf0e10cSrcweir
2412cdf0e10cSrcweir case KS_NumIndentInc:
2413cdf0e10cSrcweir rSh.ChangeIndentOfAllListLevels(360);
2414cdf0e10cSrcweir nKS_NUMINDENTINC_Count = 2;
2415cdf0e10cSrcweir break;
2416cdf0e10cSrcweir
2417cdf0e10cSrcweir case KS_GotoNextFieldMark:
2418cdf0e10cSrcweir {
2419cdf0e10cSrcweir ::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkAfter();
2420cdf0e10cSrcweir if(pFieldmark) rSh.GotoFieldmark(pFieldmark);
2421cdf0e10cSrcweir }
2422cdf0e10cSrcweir break;
2423cdf0e10cSrcweir
2424cdf0e10cSrcweir case KS_GotoPrevFieldMark:
2425cdf0e10cSrcweir {
2426cdf0e10cSrcweir ::sw::mark::IFieldmark const * const pFieldmark = rSh.GetFieldmarkBefore();
2427cdf0e10cSrcweir if(pFieldmark) rSh.GotoFieldmark(pFieldmark);
2428cdf0e10cSrcweir }
2429cdf0e10cSrcweir break;
2430cdf0e10cSrcweir
2431cdf0e10cSrcweir case KS_NumIndentDec:
2432cdf0e10cSrcweir rSh.ChangeIndentOfAllListLevels(-360);
2433cdf0e10cSrcweir // <--
2434cdf0e10cSrcweir break;
2435cdf0e10cSrcweir
2436cdf0e10cSrcweir case KS_OutlineDown:
2437cdf0e10cSrcweir rSh.OutlineUpDown( 1 );
2438cdf0e10cSrcweir break;
2439cdf0e10cSrcweir case KS_OutlineUp:
2440cdf0e10cSrcweir rSh.OutlineUpDown( -1 );
2441cdf0e10cSrcweir break;
2442cdf0e10cSrcweir
2443cdf0e10cSrcweir case KS_NextCell:
2444cdf0e10cSrcweir //In Tabelle immer 'flushen'
2445cdf0e10cSrcweir rSh.GoNextCell();
2446cdf0e10cSrcweir nSlotId = FN_GOTO_NEXT_CELL;
2447cdf0e10cSrcweir break;
2448cdf0e10cSrcweir case KS_PrevCell:
2449cdf0e10cSrcweir rSh.GoPrevCell();
2450cdf0e10cSrcweir nSlotId = FN_GOTO_PREV_CELL;
2451cdf0e10cSrcweir break;
2452cdf0e10cSrcweir case KS_AutoFmtByInput:
2453cdf0e10cSrcweir rSh.SplitNode( sal_True );
2454cdf0e10cSrcweir break;
2455cdf0e10cSrcweir
2456cdf0e10cSrcweir case KS_NextObject:
2457cdf0e10cSrcweir case KS_PrevObject:
2458cdf0e10cSrcweir if(rSh.GotoObj( KS_NextObject == eKeyState, GOTOOBJ_GOTO_ANY))
2459cdf0e10cSrcweir {
2460cdf0e10cSrcweir if( rSh.IsFrmSelected() &&
2461cdf0e10cSrcweir rView.GetDrawFuncPtr() )
2462cdf0e10cSrcweir {
2463cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
2464cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
2465cdf0e10cSrcweir rView.LeaveDrawCreate();
2466cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
2467cdf0e10cSrcweir }
2468cdf0e10cSrcweir rSh.HideCrsr();
2469cdf0e10cSrcweir rSh.EnterSelFrmMode();
2470cdf0e10cSrcweir }
2471cdf0e10cSrcweir break;
2472cdf0e10cSrcweir case KS_GlossaryExpand:
2473cdf0e10cSrcweir {
2474cdf0e10cSrcweir // ersetze das Wort oder Kuerzel durch den den Textbaustein
2475cdf0e10cSrcweir rSh.StartUndo( UNDO_START );
2476cdf0e10cSrcweir
2477cdf0e10cSrcweir String sFnd( *aTmpQHD.aArr[ aTmpQHD.nCurArrPos ] );
2478cdf0e10cSrcweir if( aTmpQHD.bIsAutoText )
2479cdf0e10cSrcweir {
2480cdf0e10cSrcweir SwGlossaryList* pList = ::GetGlossaryList();
2481cdf0e10cSrcweir String sShrtNm;
2482cdf0e10cSrcweir String sGroup;
2483cdf0e10cSrcweir if(pList->GetShortName( sFnd, sShrtNm, sGroup))
2484cdf0e10cSrcweir {
2485cdf0e10cSrcweir rSh.SttSelect();
2486cdf0e10cSrcweir rSh.ExtendSelection( sal_False, aTmpQHD.nLen );
2487cdf0e10cSrcweir SwGlossaryHdl* pGlosHdl = GetView().GetGlosHdl();
2488cdf0e10cSrcweir pGlosHdl->SetCurGroup(sGroup, sal_True);
2489cdf0e10cSrcweir pGlosHdl->InsertGlossary( sShrtNm);
2490cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_True;
2491cdf0e10cSrcweir }
2492cdf0e10cSrcweir }
2493cdf0e10cSrcweir else
2494cdf0e10cSrcweir {
2495cdf0e10cSrcweir rSh.Insert( sFnd.Erase( 0, aTmpQHD.nLen ));
2496cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = !pACorr ||
2497cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCmpltAppendBlanc;
2498cdf0e10cSrcweir }
2499cdf0e10cSrcweir rSh.EndUndo( UNDO_END );
2500cdf0e10cSrcweir }
2501cdf0e10cSrcweir break;
2502cdf0e10cSrcweir
2503cdf0e10cSrcweir case KS_NextPrevGlossary:
2504cdf0e10cSrcweir pQuickHlpData->Move( aTmpQHD );
2505cdf0e10cSrcweir pQuickHlpData->Start( rSh, USHRT_MAX );
2506cdf0e10cSrcweir break;
2507cdf0e10cSrcweir
2508cdf0e10cSrcweir case KS_EditFormula:
2509cdf0e10cSrcweir {
2510cdf0e10cSrcweir const sal_uInt16 nId = SwInputChild::GetChildWindowId();
2511cdf0e10cSrcweir
2512cdf0e10cSrcweir SfxViewFrame* pVFrame = GetView().GetViewFrame();
2513cdf0e10cSrcweir pVFrame->ToggleChildWindow( nId );
2514cdf0e10cSrcweir SwInputChild* pChildWin = (SwInputChild*)pVFrame->
2515cdf0e10cSrcweir GetChildWindow( nId );
2516cdf0e10cSrcweir if( pChildWin )
2517cdf0e10cSrcweir pChildWin->SetFormula( sFmlEntry );
2518cdf0e10cSrcweir }
2519cdf0e10cSrcweir break;
2520cdf0e10cSrcweir
2521cdf0e10cSrcweir case KS_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
2522cdf0e10cSrcweir case KS_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
2523cdf0e10cSrcweir case KS_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHMove() ); break;
2524cdf0e10cSrcweir case KS_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHMove() ); break;
2525cdf0e10cSrcweir case KS_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
2526cdf0e10cSrcweir case KS_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVMove() ); break;
2527cdf0e10cSrcweir case KS_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
2528cdf0e10cSrcweir case KS_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHMove() ); break;
2529cdf0e10cSrcweir case KS_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHMove() ); break;
2530cdf0e10cSrcweir case KS_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHMove() ); break;
2531cdf0e10cSrcweir case KS_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
2532cdf0e10cSrcweir case KS_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVMove() ); break;
2533cdf0e10cSrcweir case KS_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVMove() ); break;
2534cdf0e10cSrcweir case KS_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVMove() ); break;
2535cdf0e10cSrcweir
2536cdf0e10cSrcweir //---------------
2537cdf0e10cSrcweir case KS_InsDel_ColLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
2538cdf0e10cSrcweir case KS_InsDel_ColRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
2539cdf0e10cSrcweir case KS_InsDel_ColLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_LEFT, pModOpt->GetTblHInsert() ); break;
2540cdf0e10cSrcweir case KS_InsDel_ColRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_COL_RIGHT, pModOpt->GetTblHInsert() ); break;
2541cdf0e10cSrcweir case KS_InsDel_ColTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
2542cdf0e10cSrcweir case KS_InsDel_ColBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
2543cdf0e10cSrcweir case KS_InsDel_ColTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_TOP, pModOpt->GetTblVInsert() ); break;
2544cdf0e10cSrcweir case KS_InsDel_ColBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_ROW_BOTTOM, pModOpt->GetTblVInsert() ); break;
2545cdf0e10cSrcweir case KS_InsDel_CellLeftBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
2546cdf0e10cSrcweir case KS_InsDel_CellRightBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblHInsert() ); break;
2547cdf0e10cSrcweir case KS_InsDel_CellLeftSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_LEFT, pModOpt->GetTblHInsert() ); break;
2548cdf0e10cSrcweir case KS_InsDel_CellRightSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_RIGHT, pModOpt->GetTblHInsert() ); break;
2549cdf0e10cSrcweir case KS_InsDel_CellTopBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
2550cdf0e10cSrcweir case KS_InsDel_CellBottomBig: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM|nsTblChgWidthHeightType::WH_FLAG_BIGGER, pModOpt->GetTblVInsert() ); break;
2551cdf0e10cSrcweir case KS_InsDel_CellTopSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_TOP, pModOpt->GetTblVInsert() ); break;
2552cdf0e10cSrcweir case KS_InsDel_CellBottomSmall: rSh.SetColRowWidthHeight( nsTblChgWidthHeightType::WH_FLAG_INSDEL|nsTblChgWidthHeightType::WH_CELL_BOTTOM, pModOpt->GetTblVInsert() ); break;
2553cdf0e10cSrcweir //---------------
2554cdf0e10cSrcweir case KS_TblColCellInsDel:
2555cdf0e10cSrcweir rSh.SetColRowWidthHeight( eTblChgMode, nTblChgSize );
2556cdf0e10cSrcweir break;
2557cdf0e10cSrcweir case KS_Fly_Change:
2558cdf0e10cSrcweir {
2559cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
2560cdf0e10cSrcweir const SdrHdlList& rHdlList = pSdrView->GetHdlList();
2561cdf0e10cSrcweir if(rHdlList.GetFocusHdl())
2562cdf0e10cSrcweir ChangeDrawing( nDir );
2563cdf0e10cSrcweir else
2564cdf0e10cSrcweir ChangeFly( nDir, rView.ISA( SwWebView ) );
2565cdf0e10cSrcweir }
2566cdf0e10cSrcweir break;
2567cdf0e10cSrcweir case KS_Draw_Change :
2568cdf0e10cSrcweir ChangeDrawing( nDir );
2569cdf0e10cSrcweir break;
2570cdf0e10cSrcweir default:; //prevent warning
2571cdf0e10cSrcweir }
2572cdf0e10cSrcweir if( nSlotId && rView.GetViewFrame()->GetBindings().GetRecorder().is() )
2573cdf0e10cSrcweir {
2574cdf0e10cSrcweir SfxRequest aReq(rView.GetViewFrame(), nSlotId );
2575cdf0e10cSrcweir aReq.Done();
2576cdf0e10cSrcweir }
2577cdf0e10cSrcweir eKeyState = KS_Ende;
2578cdf0e10cSrcweir }
2579cdf0e10cSrcweir }
2580cdf0e10cSrcweir }
2581cdf0e10cSrcweir
2582cdf0e10cSrcweir if( bStopKeyInputTimer )
2583cdf0e10cSrcweir {
2584cdf0e10cSrcweir aKeyInputTimer.Stop();
2585cdf0e10cSrcweir bTblInsDelMode = sal_False;
2586cdf0e10cSrcweir }
2587cdf0e10cSrcweir
2588cdf0e10cSrcweir // falls die gepufferten Zeichen eingefuegt werden sollen
2589cdf0e10cSrcweir if( bFlushBuffer && aInBuffer.Len() )
2590cdf0e10cSrcweir {
2591cdf0e10cSrcweir //OS 16.02.96 11.04: bFlushCharBuffer wurde hier nicht zurueckgesetzt
2592cdf0e10cSrcweir // warum nicht?
2593cdf0e10cSrcweir sal_Bool bSave = bFlushCharBuffer;
2594cdf0e10cSrcweir FlushInBuffer();
2595cdf0e10cSrcweir bFlushCharBuffer = bSave;
2596cdf0e10cSrcweir
2597cdf0e10cSrcweir // evt. Tip-Hilfe anzeigen
2598cdf0e10cSrcweir String sWord;
2599cdf0e10cSrcweir if( bNormalChar && pACfg && pACorr &&
2600cdf0e10cSrcweir ( pACfg->IsAutoTextTip() ||
2601cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCompleteWords ) &&
2602cdf0e10cSrcweir rSh.GetPrevAutoCorrWord( *pACorr, sWord ) )
2603cdf0e10cSrcweir {
2604cdf0e10cSrcweir ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr);
2605cdf0e10cSrcweir }
2606cdf0e10cSrcweir }
2607cdf0e10cSrcweir }
2608cdf0e10cSrcweir
2609cdf0e10cSrcweir /*--------------------------------------------------------------------
2610cdf0e10cSrcweir Beschreibung: MouseEvents
2611cdf0e10cSrcweir --------------------------------------------------------------------*/
2612cdf0e10cSrcweir
2613cdf0e10cSrcweir
RstMBDownFlags()2614cdf0e10cSrcweir void SwEditWin::RstMBDownFlags()
2615cdf0e10cSrcweir {
2616cdf0e10cSrcweir //Nicht auf allen Systemen kommt vor dem modalen
2617cdf0e10cSrcweir //Dialog noch ein MouseButton Up (wie unter WINDOWS).
2618cdf0e10cSrcweir //Daher hier die Stati zuruecksetzen und die Maus
2619cdf0e10cSrcweir //fuer den Dialog freigeben.
2620cdf0e10cSrcweir bMBPressed = bNoInterrupt = sal_False;
2621cdf0e10cSrcweir EnterArea();
2622cdf0e10cSrcweir ReleaseMouse();
2623cdf0e10cSrcweir }
2624cdf0e10cSrcweir
2625cdf0e10cSrcweir
2626cdf0e10cSrcweir
MouseButtonDown(const MouseEvent & _rMEvt)2627cdf0e10cSrcweir void SwEditWin::MouseButtonDown(const MouseEvent& _rMEvt)
2628cdf0e10cSrcweir {
2629cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
2630cdf0e10cSrcweir
2631cdf0e10cSrcweir // We have to check if a context menu is shown and we have an UI
2632cdf0e10cSrcweir // active inplace client. In that case we have to ignore the mouse
2633cdf0e10cSrcweir // button down event. Otherwise we would crash (context menu has been
2634cdf0e10cSrcweir // opened by inplace client and we would deactivate the inplace client,
2635cdf0e10cSrcweir // the contex menu is closed by VCL asynchronously which in the end
2636cdf0e10cSrcweir // would work on deleted objects or the context menu has no parent anymore)
2637cdf0e10cSrcweir // See #126086# and #128122#
2638cdf0e10cSrcweir SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient();
2639cdf0e10cSrcweir sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
2640cdf0e10cSrcweir
2641cdf0e10cSrcweir if ( bIsOleActive && PopupMenu::IsInExecute() )
2642cdf0e10cSrcweir return;
2643cdf0e10cSrcweir
2644cdf0e10cSrcweir MouseEvent rMEvt(_rMEvt);
2645cdf0e10cSrcweir
2646cdf0e10cSrcweir if (rView.GetPostItMgr()->IsHit(rMEvt.GetPosPixel()))
2647cdf0e10cSrcweir return;
2648cdf0e10cSrcweir
2649cdf0e10cSrcweir rView.GetPostItMgr()->SetActiveSidebarWin(0);
2650cdf0e10cSrcweir
2651cdf0e10cSrcweir GrabFocus();
2652cdf0e10cSrcweir
2653cdf0e10cSrcweir //ignore key modifiers for format paintbrush
2654cdf0e10cSrcweir {
2655cdf0e10cSrcweir sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard
2656cdf0e10cSrcweir && pApplyTempl->pFormatClipboard->HasContent();
2657cdf0e10cSrcweir if( bExecFormatPaintbrush )
2658cdf0e10cSrcweir rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(),
2659cdf0e10cSrcweir _rMEvt.GetMode(), _rMEvt.GetButtons() );
2660cdf0e10cSrcweir }
2661cdf0e10cSrcweir
2662cdf0e10cSrcweir bWasShdwCrsr = 0 != pShadCrsr;
2663cdf0e10cSrcweir if( bWasShdwCrsr )
2664cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
2665cdf0e10cSrcweir
2666cdf0e10cSrcweir const Point aDocPos( PixelToLogic( rMEvt.GetPosPixel() ) );
2667cdf0e10cSrcweir
2668cdf0e10cSrcweir if ( IsChainMode() )
2669cdf0e10cSrcweir {
2670cdf0e10cSrcweir SetChainMode( sal_False );
2671cdf0e10cSrcweir SwRect aDummy;
2672cdf0e10cSrcweir SwFlyFrmFmt *pFmt = (SwFlyFrmFmt*)rSh.GetFlyFrmFmt();
2673cdf0e10cSrcweir if ( !rSh.Chainable( aDummy, *pFmt, aDocPos ) )
2674cdf0e10cSrcweir rSh.Chain( *pFmt, aDocPos );
2675cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
2676cdf0e10cSrcweir return;
2677cdf0e10cSrcweir }
2678cdf0e10cSrcweir
2679cdf0e10cSrcweir //Nach GrabFocus sollte eine Shell gepusht sein. Das muss eigentlich
2680cdf0e10cSrcweir //klappen aber in der Praxis ...
2681cdf0e10cSrcweir lcl_SelectShellForDrop( rView );
2682cdf0e10cSrcweir
2683cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly();
2684cdf0e10cSrcweir sal_Bool bCallBase = sal_True;
2685cdf0e10cSrcweir
2686cdf0e10cSrcweir if( pQuickHlpData->bClear )
2687cdf0e10cSrcweir pQuickHlpData->Stop( rSh );
2688cdf0e10cSrcweir pQuickHlpData->bChkInsBlank = sal_False;
2689cdf0e10cSrcweir
2690cdf0e10cSrcweir if( rSh.FinishOLEObj() )
2691cdf0e10cSrcweir return; //InPlace beenden und der Klick zaehlt nicht mehr
2692cdf0e10cSrcweir
2693cdf0e10cSrcweir SET_CURR_SHELL( &rSh );
2694cdf0e10cSrcweir
2695cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
2696cdf0e10cSrcweir if ( pSdrView )
2697cdf0e10cSrcweir {
2698cdf0e10cSrcweir if (pSdrView->MouseButtonDown( rMEvt, this ) )
2699cdf0e10cSrcweir {
2700cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
2701cdf0e10cSrcweir return; // Event von der SdrView ausgewertet
2702cdf0e10cSrcweir }
2703cdf0e10cSrcweir }
2704cdf0e10cSrcweir
2705cdf0e10cSrcweir
2706cdf0e10cSrcweir bIsInMove = sal_False;
2707cdf0e10cSrcweir aStartPos = rMEvt.GetPosPixel();
2708cdf0e10cSrcweir aRszMvHdlPt.X() = 0, aRszMvHdlPt.Y() = 0;
2709cdf0e10cSrcweir
2710cdf0e10cSrcweir sal_uInt8 nMouseTabCol = 0;
2711cdf0e10cSrcweir const sal_Bool bTmp = !rSh.IsDrawCreate() && !pApplyTempl && !rSh.IsInSelect() &&
2712cdf0e10cSrcweir rMEvt.GetClicks() == 1 && MOUSE_LEFT == rMEvt.GetButtons();
2713cdf0e10cSrcweir if ( bTmp &&
2714cdf0e10cSrcweir 0 != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPos ) ) &&
2715cdf0e10cSrcweir !rSh.IsObjSelectable( aDocPos ) )
2716cdf0e10cSrcweir {
27175b40a975SOliver-Rainer Wittmann // Enhanced table selection
2718cdf0e10cSrcweir if ( SW_TABSEL_HORI <= nMouseTabCol && SW_TABCOLSEL_VERT >= nMouseTabCol )
2719cdf0e10cSrcweir {
2720cdf0e10cSrcweir rSh.EnterStdMode();
2721cdf0e10cSrcweir rSh.SelectTableRowCol( aDocPos );
2722cdf0e10cSrcweir if( SW_TABSEL_HORI != nMouseTabCol && SW_TABSEL_HORI_RTL != nMouseTabCol)
2723cdf0e10cSrcweir {
2724cdf0e10cSrcweir pRowColumnSelectionStart = new Point( aDocPos );
2725cdf0e10cSrcweir bIsRowDrag = SW_TABROWSEL_HORI == nMouseTabCol||
2726cdf0e10cSrcweir SW_TABROWSEL_HORI_RTL == nMouseTabCol ||
2727cdf0e10cSrcweir SW_TABCOLSEL_VERT == nMouseTabCol;
2728cdf0e10cSrcweir bMBPressed = sal_True;
2729cdf0e10cSrcweir CaptureMouse();
2730cdf0e10cSrcweir }
2731cdf0e10cSrcweir return;
2732cdf0e10cSrcweir }
2733cdf0e10cSrcweir
2734cdf0e10cSrcweir if ( !rSh.IsTableMode() )
2735cdf0e10cSrcweir {
2736cdf0e10cSrcweir //Zuppeln von Tabellenspalten aus dem Dokument heraus.
2737cdf0e10cSrcweir if(SW_TABCOL_VERT == nMouseTabCol || SW_TABCOL_HORI == nMouseTabCol)
2738cdf0e10cSrcweir rView.SetTabColFromDoc( sal_True );
2739cdf0e10cSrcweir else
2740cdf0e10cSrcweir rView.SetTabRowFromDoc( sal_True );
2741cdf0e10cSrcweir
2742cdf0e10cSrcweir rView.SetTabColFromDocPos( aDocPos );
2743cdf0e10cSrcweir rView.InvalidateRulerPos();
2744cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
2745cdf0e10cSrcweir rBind.Update();
2746cdf0e10cSrcweir if ( RulerColumnDrag( rMEvt,
2747cdf0e10cSrcweir (SW_TABCOL_VERT == nMouseTabCol || SW_TABROW_HORI == nMouseTabCol)) )
2748cdf0e10cSrcweir {
2749cdf0e10cSrcweir rView.SetTabColFromDoc( sal_False );
2750cdf0e10cSrcweir rView.SetTabRowFromDoc( sal_False );
2751cdf0e10cSrcweir rView.InvalidateRulerPos();
2752cdf0e10cSrcweir rBind.Update();
2753cdf0e10cSrcweir bCallBase = sal_False;
2754cdf0e10cSrcweir }
2755cdf0e10cSrcweir else
2756cdf0e10cSrcweir {
2757cdf0e10cSrcweir return;
2758cdf0e10cSrcweir }
2759cdf0e10cSrcweir }
2760cdf0e10cSrcweir }
2761cdf0e10cSrcweir else if (bTmp &&
2762cdf0e10cSrcweir rSh.IsNumLabel(aDocPos))
2763cdf0e10cSrcweir {
2764cdf0e10cSrcweir SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPos );
2765cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( pNodeAtPos );
2766cdf0e10cSrcweir rView.InvalidateRulerPos();
2767cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
2768cdf0e10cSrcweir rBind.Update();
2769cdf0e10cSrcweir
2770cdf0e10cSrcweir if ( RulerMarginDrag( rMEvt,
2771cdf0e10cSrcweir rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPos ) ) )
2772cdf0e10cSrcweir {
2773cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( NULL );
2774cdf0e10cSrcweir rView.InvalidateRulerPos();
2775cdf0e10cSrcweir rBind.Update();
2776cdf0e10cSrcweir bCallBase = sal_False;
2777cdf0e10cSrcweir }
2778cdf0e10cSrcweir else
2779cdf0e10cSrcweir {
27805b40a975SOliver-Rainer Wittmann // Make sure the pointer is set to 0, otherwise it may point to
27815b40a975SOliver-Rainer Wittmann // nowhere after deleting the corresponding text node.
2782cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc( NULL );
2783cdf0e10cSrcweir return;
2784cdf0e10cSrcweir }
2785cdf0e10cSrcweir }
2786cdf0e10cSrcweir
2787cdf0e10cSrcweir if ( rSh.IsInSelect() )
2788cdf0e10cSrcweir rSh.EndSelect();
2789cdf0e10cSrcweir
2790cdf0e10cSrcweir //Abfrage auf LEFT, da sonst auch bei einem Click mit der rechten Taste
2791cdf0e10cSrcweir //beispielsweise die Selektion aufgehoben wird.
2792cdf0e10cSrcweir if ( MOUSE_LEFT == rMEvt.GetButtons() )
2793cdf0e10cSrcweir {
2794cdf0e10cSrcweir sal_Bool bOnlyText = sal_False;
2795cdf0e10cSrcweir bMBPressed = bNoInterrupt = sal_True;
2796cdf0e10cSrcweir nKS_NUMDOWN_Count = 0; // #i23725#
2797cdf0e10cSrcweir
2798cdf0e10cSrcweir CaptureMouse();
2799cdf0e10cSrcweir
2800cdf0e10cSrcweir //ggf. Cursorpositionen zuruecksetzen
2801cdf0e10cSrcweir rSh.ResetCursorStack();
2802cdf0e10cSrcweir
2803cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
2804cdf0e10cSrcweir {
2805cdf0e10cSrcweir case MOUSE_LEFT:
2806cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT:
2807cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2:
2808cdf0e10cSrcweir if( rSh.IsObjSelected() )
2809cdf0e10cSrcweir {
2810cdf0e10cSrcweir SdrHdl* pHdl;
2811cdf0e10cSrcweir if( !bIsDocReadOnly &&
2812cdf0e10cSrcweir !pAnchorMarker &&
2813cdf0e10cSrcweir 0 != ( pHdl = pSdrView->PickHandle(aDocPos) ) &&
2814cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR ||
2815cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) )
2816cdf0e10cSrcweir {
28175b40a975SOliver-Rainer Wittmann // Set selected during drag
28184772d9afSArmin Le Grand pHdl->SetSelected(true);
2819cdf0e10cSrcweir pAnchorMarker = new SwAnchorMarker( pHdl );
2820cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
2821cdf0e10cSrcweir return;
2822cdf0e10cSrcweir }
2823cdf0e10cSrcweir }
2824cdf0e10cSrcweir if ( EnterDrawMode( rMEvt, aDocPos ) )
2825cdf0e10cSrcweir {
2826cdf0e10cSrcweir bNoInterrupt = sal_False;
2827cdf0e10cSrcweir return;
2828cdf0e10cSrcweir }
2829cdf0e10cSrcweir else if ( rView.GetDrawFuncPtr() && bInsFrm )
2830cdf0e10cSrcweir {
2831cdf0e10cSrcweir StopInsFrm();
2832cdf0e10cSrcweir rSh.Edit();
2833cdf0e10cSrcweir }
2834cdf0e10cSrcweir
2835cdf0e10cSrcweir // Ohne SHIFT, da sonst Toggle bei Selektion nicht funktioniert
2836cdf0e10cSrcweir if (rMEvt.GetClicks() == 1)
2837cdf0e10cSrcweir {
2838cdf0e10cSrcweir if ( rSh.IsSelFrmMode())
2839cdf0e10cSrcweir {
2840cdf0e10cSrcweir SdrHdl* pHdl = rSh.GetDrawView()->PickHandle(aDocPos);
2841cdf0e10cSrcweir sal_Bool bHitHandle = pHdl && pHdl->GetKind() != HDL_ANCHOR &&
2842cdf0e10cSrcweir pHdl->GetKind() != HDL_ANCHOR_TR;
2843cdf0e10cSrcweir
2844cdf0e10cSrcweir if ((rSh.IsInsideSelectedObj(aDocPos) || bHitHandle) &&
2845cdf0e10cSrcweir !(rMEvt.GetModifier() == KEY_SHIFT && !bHitHandle))
2846cdf0e10cSrcweir {
2847cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
2848cdf0e10cSrcweir if ( !pApplyTempl )
2849cdf0e10cSrcweir {
2850cdf0e10cSrcweir //nur, wenn keine Position zum Sizen getroffen ist.
2851cdf0e10cSrcweir if (!bHitHandle)
2852cdf0e10cSrcweir {
2853cdf0e10cSrcweir StartDDTimer();
2854cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
2855cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
2856cdf0e10cSrcweir }
2857cdf0e10cSrcweir bFrmDrag = sal_True;
2858cdf0e10cSrcweir }
2859cdf0e10cSrcweir bNoInterrupt = sal_False;
2860cdf0e10cSrcweir return;
2861cdf0e10cSrcweir }
2862cdf0e10cSrcweir }
2863cdf0e10cSrcweir }
2864cdf0e10cSrcweir }
2865cdf0e10cSrcweir
2866cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
2867cdf0e10cSrcweir if ( !bExecHyperlinks )
2868cdf0e10cSrcweir {
2869cdf0e10cSrcweir SvtSecurityOptions aSecOpts;
2870cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
2871cdf0e10cSrcweir if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) ||
2872cdf0e10cSrcweir ( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) )
2873cdf0e10cSrcweir bExecHyperlinks = sal_True;
2874cdf0e10cSrcweir }
2875cdf0e10cSrcweir
28765b40a975SOliver-Rainer Wittmann // Enhanced selection
2877cdf0e10cSrcweir sal_uInt8 nNumberOfClicks = static_cast< sal_uInt8 >(rMEvt.GetClicks() % 4);
2878cdf0e10cSrcweir if ( 0 == nNumberOfClicks && 0 < rMEvt.GetClicks() )
2879cdf0e10cSrcweir nNumberOfClicks = 4;
2880cdf0e10cSrcweir
2881cdf0e10cSrcweir sal_Bool bExecDrawTextLink = sal_False;
2882cdf0e10cSrcweir
2883cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
2884cdf0e10cSrcweir {
2885cdf0e10cSrcweir case MOUSE_LEFT:
2886cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1:
2887cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2:
2888cdf0e10cSrcweir switch ( nNumberOfClicks )
2889cdf0e10cSrcweir {
2890cdf0e10cSrcweir case 1:
2891cdf0e10cSrcweir {
2892cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
2893cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
2894cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
2895cdf0e10cSrcweir
2896cdf0e10cSrcweir // URL in DrawText-Objekt getroffen?
2897cdf0e10cSrcweir if (bExecHyperlinks && pSdrView)
2898cdf0e10cSrcweir {
2899cdf0e10cSrcweir SdrViewEvent aVEvt;
2900cdf0e10cSrcweir pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
2901cdf0e10cSrcweir
2902cdf0e10cSrcweir if (aVEvt.eEvent == SDREVENT_EXECUTEURL)
2903cdf0e10cSrcweir bExecDrawTextLink = sal_True;
2904cdf0e10cSrcweir }
2905cdf0e10cSrcweir
2906cdf0e10cSrcweir //Rahmen nur zu selektieren versuchen, wenn
2907cdf0e10cSrcweir //der Pointer bereits entsprechend geschaltet wurde
2908cdf0e10cSrcweir if ( aActHitType != SDRHIT_NONE && !rSh.IsSelFrmMode() &&
2909cdf0e10cSrcweir !GetView().GetViewFrame()->GetDispatcher()->IsLocked() &&
2910cdf0e10cSrcweir !bExecDrawTextLink)
2911cdf0e10cSrcweir {
2912cdf0e10cSrcweir // Test if there is a draw object at that position and if it should be selected.
2913cdf0e10cSrcweir sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
2914cdf0e10cSrcweir
2915cdf0e10cSrcweir if(bShould)
2916cdf0e10cSrcweir {
2917cdf0e10cSrcweir rView.NoRotate();
2918cdf0e10cSrcweir rSh.HideCrsr();
2919cdf0e10cSrcweir
2920cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
2921cdf0e10cSrcweir rSh.LockView( sal_True );
2922cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos,
2923cdf0e10cSrcweir rMEvt.IsMod1() ? SW_ENTER_GROUP : 0);
2924cdf0e10cSrcweir if( bUnLockView )
2925cdf0e10cSrcweir rSh.LockView( sal_False );
2926cdf0e10cSrcweir
2927cdf0e10cSrcweir if( bSelObj )
2928cdf0e10cSrcweir {
2929cdf0e10cSrcweir // falls im Macro der Rahmen deselektiert
2930cdf0e10cSrcweir // wurde, muss nur noch der Cursor
2931cdf0e10cSrcweir // wieder angezeigt werden.
2932cdf0e10cSrcweir if( FRMTYPE_NONE == rSh.GetSelFrmType() )
2933cdf0e10cSrcweir rSh.ShowCrsr();
2934cdf0e10cSrcweir else
2935cdf0e10cSrcweir {
2936cdf0e10cSrcweir if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr())
2937cdf0e10cSrcweir {
2938cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
2939cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
2940cdf0e10cSrcweir rView.LeaveDrawCreate();
2941cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
2942cdf0e10cSrcweir }
2943cdf0e10cSrcweir
2944cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
2945cdf0e10cSrcweir bFrmDrag = sal_True;
2946cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
2947cdf0e10cSrcweir }
2948cdf0e10cSrcweir return;
2949cdf0e10cSrcweir }
2950cdf0e10cSrcweir else
2951cdf0e10cSrcweir bOnlyText = static_cast< sal_Bool >(rSh.IsObjSelectable( aDocPos ));
2952cdf0e10cSrcweir
2953cdf0e10cSrcweir if (!rView.GetDrawFuncPtr())
2954cdf0e10cSrcweir rSh.ShowCrsr();
2955cdf0e10cSrcweir }
2956cdf0e10cSrcweir else
2957cdf0e10cSrcweir bOnlyText = KEY_MOD1 != rMEvt.GetModifier();
2958cdf0e10cSrcweir }
2959cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() &&
2960cdf0e10cSrcweir (aActHitType == SDRHIT_NONE ||
2961cdf0e10cSrcweir !rSh.IsInsideSelectedObj( aDocPos )))
2962cdf0e10cSrcweir {
2963cdf0e10cSrcweir rView.NoRotate();
2964cdf0e10cSrcweir SdrHdl *pHdl;
2965cdf0e10cSrcweir if( !bIsDocReadOnly && !pAnchorMarker && 0 !=
2966cdf0e10cSrcweir ( pHdl = pSdrView->PickHandle(aDocPos) ) &&
2967cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR ||
2968cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) )
2969cdf0e10cSrcweir {
2970cdf0e10cSrcweir pAnchorMarker = new SwAnchorMarker( pHdl );
2971cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
2972cdf0e10cSrcweir return;
2973cdf0e10cSrcweir }
2974cdf0e10cSrcweir else
2975cdf0e10cSrcweir {
2976cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
2977cdf0e10cSrcweir rSh.LockView( sal_True );
2978cdf0e10cSrcweir sal_uInt8 nFlag = rMEvt.IsShift() ? SW_ADD_SELECT :0;
2979cdf0e10cSrcweir if( rMEvt.IsMod1() )
2980cdf0e10cSrcweir nFlag = nFlag | SW_ENTER_GROUP;
2981cdf0e10cSrcweir
2982cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
2983cdf0e10cSrcweir {
2984cdf0e10cSrcweir rSh.UnSelectFrm();
2985cdf0e10cSrcweir rSh.LeaveSelFrmMode();
2986cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
2987cdf0e10cSrcweir }
2988cdf0e10cSrcweir
2989cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag );
2990cdf0e10cSrcweir if( bUnLockView )
2991cdf0e10cSrcweir rSh.LockView( sal_False );
2992cdf0e10cSrcweir
2993cdf0e10cSrcweir if( !bSelObj )
2994cdf0e10cSrcweir {
2995cdf0e10cSrcweir // Cursor hier umsetzen, damit er nicht zuerst
2996cdf0e10cSrcweir // im Rahmen gezeichnet wird; ShowCrsr() geschieht
2997cdf0e10cSrcweir // in LeaveSelFrmMode()
2998cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
2999cdf0e10cSrcweir rSh.LeaveSelFrmMode();
3000cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
3001cdf0e10cSrcweir bCallBase = sal_False;
3002cdf0e10cSrcweir }
3003cdf0e10cSrcweir else
3004cdf0e10cSrcweir {
3005cdf0e10cSrcweir rSh.HideCrsr();
3006cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
3007cdf0e10cSrcweir rSh.SelFlyGrabCrsr();
3008cdf0e10cSrcweir rSh.MakeSelVisible();
3009cdf0e10cSrcweir bFrmDrag = sal_True;
3010cdf0e10cSrcweir if( rSh.IsFrmSelected() &&
3011cdf0e10cSrcweir rView.GetDrawFuncPtr() )
3012cdf0e10cSrcweir {
3013cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
3014cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
3015cdf0e10cSrcweir rView.LeaveDrawCreate();
3016cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
3017cdf0e10cSrcweir }
3018cdf0e10cSrcweir UpdatePointer( aDocPos, rMEvt.GetModifier() );
3019cdf0e10cSrcweir return;
3020cdf0e10cSrcweir }
3021cdf0e10cSrcweir }
3022cdf0e10cSrcweir }
3023cdf0e10cSrcweir
3024cdf0e10cSrcweir break;
3025cdf0e10cSrcweir }
3026cdf0e10cSrcweir case 2:
3027cdf0e10cSrcweir {
3028cdf0e10cSrcweir bFrmDrag = sal_False;
3029cdf0e10cSrcweir if ( !bIsDocReadOnly && rSh.IsInsideSelectedObj(aDocPos) &&
3030cdf0e10cSrcweir 0 == rSh.IsSelObjProtected( FLYPROTECT_CONTENT|FLYPROTECT_PARENT ) )
3031cdf0e10cSrcweir
3032cdf0e10cSrcweir /* SJ: 01.03.2005: this is no good, on the one hand GetSelectionType is used as flag field (take a look into the GetSelectionType method)
3033cdf0e10cSrcweir on the other hand the return value is used in a switch without proper masking (very nice), this must lead to trouble
3034cdf0e10cSrcweir */
3035cdf0e10cSrcweir switch ( rSh.GetSelectionType() &~ ( nsSelectionType::SEL_FONTWORK | nsSelectionType::SEL_EXTRUDED_CUSTOMSHAPE ) )
3036cdf0e10cSrcweir {
3037cdf0e10cSrcweir case nsSelectionType::SEL_GRF:
3038cdf0e10cSrcweir RstMBDownFlags();
3039cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute(
3040cdf0e10cSrcweir FN_FORMAT_GRAFIC_DLG, 0, 0,
3041cdf0e10cSrcweir SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT);
3042cdf0e10cSrcweir return;
3043cdf0e10cSrcweir
3044cdf0e10cSrcweir // Doppelklick auf OLE-Objekt --> OLE-InPlace
3045cdf0e10cSrcweir case nsSelectionType::SEL_OLE:
3046cdf0e10cSrcweir if (!rSh.IsSelObjProtected(FLYPROTECT_CONTENT))
3047cdf0e10cSrcweir {
3048cdf0e10cSrcweir RstMBDownFlags();
3049cdf0e10cSrcweir rSh.LaunchOLEObj();
3050cdf0e10cSrcweir }
3051cdf0e10cSrcweir return;
3052cdf0e10cSrcweir
3053cdf0e10cSrcweir case nsSelectionType::SEL_FRM:
3054cdf0e10cSrcweir RstMBDownFlags();
3055cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute(
3056cdf0e10cSrcweir FN_FORMAT_FRAME_DLG, 0, 0, SFX_CALLMODE_RECORD|SFX_CALLMODE_SLOT);
3057cdf0e10cSrcweir return;
3058cdf0e10cSrcweir
3059cdf0e10cSrcweir case nsSelectionType::SEL_DRW:
3060cdf0e10cSrcweir RstMBDownFlags();
3061cdf0e10cSrcweir EnterDrawTextMode(aDocPos);
3062cdf0e10cSrcweir if ( rView.GetCurShell()->ISA(SwDrawTextShell) )
3063cdf0e10cSrcweir ((SwDrawTextShell*)rView.GetCurShell())->Init();
3064cdf0e10cSrcweir return;
3065cdf0e10cSrcweir }
3066cdf0e10cSrcweir
3067cdf0e10cSrcweir //falls die Cursorposition korrigiert wurde oder
3068cdf0e10cSrcweir // ein Fly im ReadOnlyModus selektiert ist,
3069cdf0e10cSrcweir //keine Wortselektion.
3070cdf0e10cSrcweir if ( !bValidCrsrPos ||
3071cdf0e10cSrcweir (rSh.IsFrmSelected() && rSh.IsFrmSelected() ))
3072cdf0e10cSrcweir return;
3073cdf0e10cSrcweir
3074cdf0e10cSrcweir SwField *pFld;
3075cdf0e10cSrcweir sal_Bool bFtn = sal_False;
3076cdf0e10cSrcweir
3077cdf0e10cSrcweir if( !bIsDocReadOnly &&
3078cdf0e10cSrcweir ( 0 != ( pFld = rSh.GetCurFld() ) ||
3079cdf0e10cSrcweir 0 != ( bFtn = rSh.GetCurFtn() )) )
3080cdf0e10cSrcweir {
3081cdf0e10cSrcweir RstMBDownFlags();
3082cdf0e10cSrcweir if( bFtn )
3083cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( FN_EDIT_FOOTNOTE );
3084cdf0e10cSrcweir else
3085cdf0e10cSrcweir {
3086cdf0e10cSrcweir sal_uInt16 nTypeId = pFld->GetTypeId();
3087cdf0e10cSrcweir SfxViewFrame* pVFrame = GetView().GetViewFrame();
3088cdf0e10cSrcweir switch( nTypeId )
3089cdf0e10cSrcweir {
3090cdf0e10cSrcweir case TYP_POSTITFLD:
3091cdf0e10cSrcweir case TYP_SCRIPTFLD:
3092cdf0e10cSrcweir {
3093cdf0e10cSrcweir //falls es ein Readonly-Bereich ist, dann muss der Status
3094cdf0e10cSrcweir //enabled werden
3095cdf0e10cSrcweir sal_uInt16 nSlot = TYP_POSTITFLD == nTypeId ? FN_POSTIT : FN_JAVAEDIT;
3096cdf0e10cSrcweir SfxBoolItem aItem(nSlot, sal_True);
3097cdf0e10cSrcweir pVFrame->GetBindings().SetState(aItem);
3098cdf0e10cSrcweir pVFrame->GetBindings().Execute(nSlot);
3099cdf0e10cSrcweir break;
3100cdf0e10cSrcweir }
3101cdf0e10cSrcweir case TYP_AUTHORITY :
3102cdf0e10cSrcweir pVFrame->GetBindings().Execute(FN_EDIT_AUTH_ENTRY_DLG);
3103cdf0e10cSrcweir break;
3104cdf0e10cSrcweir default:
3105cdf0e10cSrcweir pVFrame->GetBindings().Execute(FN_EDIT_FIELD);
3106cdf0e10cSrcweir }
3107cdf0e10cSrcweir }
3108cdf0e10cSrcweir return;
3109cdf0e10cSrcweir }
3110cdf0e10cSrcweir //im Extended Mode hat Doppel- und
3111cdf0e10cSrcweir //Dreifachklick keine Auswirkungen.
3112cdf0e10cSrcweir if ( rSh.IsExtMode() || rSh.IsBlockMode() )
3113cdf0e10cSrcweir return;
3114cdf0e10cSrcweir
3115cdf0e10cSrcweir //Wort selektieren, gfs. Additional Mode
3116cdf0e10cSrcweir if ( KEY_MOD1 == rMEvt.GetModifier() && !rSh.IsAddMode() )
3117cdf0e10cSrcweir {
3118cdf0e10cSrcweir rSh.EnterAddMode();
3119cdf0e10cSrcweir rSh.SelWrd( &aDocPos );
3120cdf0e10cSrcweir rSh.LeaveAddMode();
3121cdf0e10cSrcweir }
3122cdf0e10cSrcweir else
3123cdf0e10cSrcweir rSh.SelWrd( &aDocPos );
3124cdf0e10cSrcweir bHoldSelection = sal_True;
3125cdf0e10cSrcweir return;
3126cdf0e10cSrcweir }
3127cdf0e10cSrcweir case 3:
3128cdf0e10cSrcweir case 4:
3129cdf0e10cSrcweir {
3130cdf0e10cSrcweir bFrmDrag = sal_False;
3131cdf0e10cSrcweir //im Extended Mode hat Doppel- und
3132cdf0e10cSrcweir //Dreifachklick keine Auswirkungen.
3133cdf0e10cSrcweir if ( rSh.IsExtMode() )
3134cdf0e10cSrcweir return;
3135cdf0e10cSrcweir
3136cdf0e10cSrcweir //falls die Cursorposition korrigiert wurde oder
3137cdf0e10cSrcweir // ein Fly im ReadOnlyModus selektiert ist,
3138cdf0e10cSrcweir //keine Wortselektion.
3139cdf0e10cSrcweir if ( !bValidCrsrPos || rSh.IsFrmSelected() )
3140cdf0e10cSrcweir return;
3141cdf0e10cSrcweir
3142cdf0e10cSrcweir //Zeile selektieren, gfs. Additional Mode
3143cdf0e10cSrcweir const bool bMod = KEY_MOD1 == rMEvt.GetModifier() &&
3144cdf0e10cSrcweir !rSh.IsAddMode();
3145cdf0e10cSrcweir
3146cdf0e10cSrcweir if ( bMod )
3147cdf0e10cSrcweir rSh.EnterAddMode();
3148cdf0e10cSrcweir
31495b40a975SOliver-Rainer Wittmann // Enhanced selection
3150cdf0e10cSrcweir if ( 3 == nNumberOfClicks )
3151cdf0e10cSrcweir rSh.SelSentence( &aDocPos );
3152cdf0e10cSrcweir else
3153cdf0e10cSrcweir rSh.SelPara( &aDocPos );
3154cdf0e10cSrcweir
3155cdf0e10cSrcweir if ( bMod )
3156cdf0e10cSrcweir rSh.LeaveAddMode();
3157cdf0e10cSrcweir
3158cdf0e10cSrcweir bHoldSelection = sal_True;
3159cdf0e10cSrcweir return;
3160cdf0e10cSrcweir }
3161cdf0e10cSrcweir
3162cdf0e10cSrcweir default:
3163cdf0e10cSrcweir return;
3164cdf0e10cSrcweir }
3165cdf0e10cSrcweir /* no break */
3166cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT:
3167cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
3168cdf0e10cSrcweir {
3169cdf0e10cSrcweir sal_Bool bLockView = bWasShdwCrsr;
3170cdf0e10cSrcweir
3171cdf0e10cSrcweir switch ( rMEvt.GetModifier() )
3172cdf0e10cSrcweir {
3173cdf0e10cSrcweir case KEY_MOD1 + KEY_SHIFT:
3174cdf0e10cSrcweir {
3175cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
3176cdf0e10cSrcweir {
3177cdf0e10cSrcweir rView.NoRotate();
3178cdf0e10cSrcweir rSh.HideCrsr();
3179cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
3180cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP);
3181cdf0e10cSrcweir else
3182cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos, SW_ADD_SELECT | SW_ENTER_GROUP ) )
3183cdf0e10cSrcweir {
3184cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
3185cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
3186cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
3187cdf0e10cSrcweir bFrmDrag = sal_True;
3188cdf0e10cSrcweir return;
3189cdf0e10cSrcweir }
3190cdf0e10cSrcweir }
3191cdf0e10cSrcweir }
3192cdf0e10cSrcweir else if( rSh.IsSelFrmMode() &&
3193cdf0e10cSrcweir rSh.GetDrawView()->PickHandle( aDocPos ))
3194cdf0e10cSrcweir {
3195cdf0e10cSrcweir bFrmDrag = sal_True;
3196cdf0e10cSrcweir bNoInterrupt = sal_False;
3197cdf0e10cSrcweir return;
3198cdf0e10cSrcweir }
3199cdf0e10cSrcweir }
3200cdf0e10cSrcweir break;
3201cdf0e10cSrcweir case KEY_MOD1:
3202cdf0e10cSrcweir if ( !bExecDrawTextLink )
3203cdf0e10cSrcweir {
3204cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
3205cdf0e10cSrcweir {
3206cdf0e10cSrcweir rView.NoRotate();
3207cdf0e10cSrcweir rSh.HideCrsr();
3208cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
3209cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ENTER_GROUP);
3210cdf0e10cSrcweir else
3211cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos, SW_ENTER_GROUP ) )
3212cdf0e10cSrcweir {
3213cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
3214cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
3215cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
3216cdf0e10cSrcweir bFrmDrag = sal_True;
3217cdf0e10cSrcweir return;
3218cdf0e10cSrcweir }
3219cdf0e10cSrcweir }
3220cdf0e10cSrcweir }
3221cdf0e10cSrcweir else if( rSh.IsSelFrmMode() &&
3222cdf0e10cSrcweir rSh.GetDrawView()->PickHandle( aDocPos ))
3223cdf0e10cSrcweir {
3224cdf0e10cSrcweir bFrmDrag = sal_True;
3225cdf0e10cSrcweir bNoInterrupt = sal_False;
3226cdf0e10cSrcweir return;
3227cdf0e10cSrcweir }
3228cdf0e10cSrcweir else
3229cdf0e10cSrcweir {
3230cdf0e10cSrcweir if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
3231cdf0e10cSrcweir {
3232cdf0e10cSrcweir rSh.PushMode();
3233cdf0e10cSrcweir bModePushed = sal_True;
3234cdf0e10cSrcweir
3235cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
3236cdf0e10cSrcweir rSh.LockView( sal_True );
3237cdf0e10cSrcweir rSh.EnterAddMode();
3238cdf0e10cSrcweir if( bUnLockView )
3239cdf0e10cSrcweir rSh.LockView( sal_False );
3240cdf0e10cSrcweir }
3241cdf0e10cSrcweir bCallBase = sal_False;
3242cdf0e10cSrcweir }
3243cdf0e10cSrcweir }
3244cdf0e10cSrcweir break;
3245cdf0e10cSrcweir case KEY_MOD2:
3246cdf0e10cSrcweir {
3247cdf0e10cSrcweir if ( !rSh.IsAddMode() && !rSh.IsExtMode() && !rSh.IsBlockMode() )
3248cdf0e10cSrcweir {
3249cdf0e10cSrcweir rSh.PushMode();
3250cdf0e10cSrcweir bModePushed = sal_True;
3251cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
3252cdf0e10cSrcweir rSh.LockView( sal_True );
3253cdf0e10cSrcweir rSh.EnterBlockMode();
3254cdf0e10cSrcweir if( bUnLockView )
3255cdf0e10cSrcweir rSh.LockView( sal_False );
3256cdf0e10cSrcweir }
3257cdf0e10cSrcweir bCallBase = sal_False;
3258cdf0e10cSrcweir }
3259cdf0e10cSrcweir break;
3260cdf0e10cSrcweir case KEY_SHIFT:
3261cdf0e10cSrcweir {
3262cdf0e10cSrcweir if ( !bInsDraw && IsDrawObjSelectable( rSh, aDocPos ) )
3263cdf0e10cSrcweir {
3264cdf0e10cSrcweir rView.NoRotate();
3265cdf0e10cSrcweir rSh.HideCrsr();
3266cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
3267cdf0e10cSrcweir {
3268cdf0e10cSrcweir rSh.SelectObj(aDocPos, SW_ADD_SELECT);
3269cdf0e10cSrcweir
3270cdf0e10cSrcweir const SdrMarkList& rMarkList = pSdrView->GetMarkedObjectList();
3271cdf0e10cSrcweir if (rMarkList.GetMark(0) == NULL)
3272cdf0e10cSrcweir {
3273cdf0e10cSrcweir rSh.LeaveSelFrmMode();
3274cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
3275cdf0e10cSrcweir bFrmDrag = sal_False;
3276cdf0e10cSrcweir }
3277cdf0e10cSrcweir }
3278cdf0e10cSrcweir else
3279cdf0e10cSrcweir { if ( rSh.SelectObj( aDocPos ) )
3280cdf0e10cSrcweir {
3281cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
3282cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
3283cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
3284cdf0e10cSrcweir bFrmDrag = sal_True;
3285cdf0e10cSrcweir return;
3286cdf0e10cSrcweir }
3287cdf0e10cSrcweir }
3288cdf0e10cSrcweir }
3289cdf0e10cSrcweir else
3290cdf0e10cSrcweir {
3291cdf0e10cSrcweir if ( rSh.IsSelFrmMode() &&
3292cdf0e10cSrcweir rSh.IsInsideSelectedObj( aDocPos ) )
3293cdf0e10cSrcweir {
3294cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
3295cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
3296cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
3297cdf0e10cSrcweir bFrmDrag = sal_True;
3298cdf0e10cSrcweir return;
3299cdf0e10cSrcweir }
3300cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
3301cdf0e10cSrcweir {
3302cdf0e10cSrcweir rSh.UnSelectFrm();
3303cdf0e10cSrcweir rSh.LeaveSelFrmMode();
3304cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
3305cdf0e10cSrcweir bFrmDrag = sal_False;
3306cdf0e10cSrcweir }
3307cdf0e10cSrcweir if ( !rSh.IsExtMode() )
3308cdf0e10cSrcweir {
3309cdf0e10cSrcweir // keine Selection anfangen, wenn in ein URL-
3310cdf0e10cSrcweir // Feld oder eine -Grafik geklickt wird
3311cdf0e10cSrcweir sal_Bool bSttSelect = rSh.HasSelection() ||
3312cdf0e10cSrcweir Pointer(POINTER_REFHAND) != GetPointer();
3313cdf0e10cSrcweir
3314cdf0e10cSrcweir if( !bSttSelect )
3315cdf0e10cSrcweir {
3316cdf0e10cSrcweir bSttSelect = sal_True;
3317cdf0e10cSrcweir if( bExecHyperlinks )
3318cdf0e10cSrcweir {
3319cdf0e10cSrcweir SwContentAtPos aCntntAtPos(
3320cdf0e10cSrcweir SwContentAtPos::SW_FTN |
3321cdf0e10cSrcweir SwContentAtPos::SW_INETATTR );
3322cdf0e10cSrcweir
3323cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPos, aCntntAtPos ) )
3324cdf0e10cSrcweir {
3325cdf0e10cSrcweir if( !rSh.IsViewLocked() &&
3326cdf0e10cSrcweir !rSh.IsReadOnlyAvailable() &&
3327cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() )
3328cdf0e10cSrcweir bLockView = sal_True;
3329cdf0e10cSrcweir
3330cdf0e10cSrcweir bSttSelect = sal_False;
3331cdf0e10cSrcweir }
3332cdf0e10cSrcweir else if( rSh.IsURLGrfAtPos( aDocPos ))
3333cdf0e10cSrcweir bSttSelect = sal_False;
3334cdf0e10cSrcweir }
3335cdf0e10cSrcweir }
3336cdf0e10cSrcweir
3337cdf0e10cSrcweir if( bSttSelect )
3338cdf0e10cSrcweir rSh.SttSelect();
3339cdf0e10cSrcweir }
3340cdf0e10cSrcweir }
3341cdf0e10cSrcweir bCallBase = sal_False;
3342cdf0e10cSrcweir break;
3343cdf0e10cSrcweir }
3344cdf0e10cSrcweir default:
3345cdf0e10cSrcweir if( !rSh.IsViewLocked() )
3346cdf0e10cSrcweir {
3347cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD |
3348cdf0e10cSrcweir SwContentAtPos::SW_INETATTR );
3349cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPos, aCntntAtPos, sal_False ) &&
3350cdf0e10cSrcweir !rSh.IsReadOnlyAvailable() &&
3351cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() )
3352cdf0e10cSrcweir bLockView = sal_True;
3353cdf0e10cSrcweir }
3354cdf0e10cSrcweir }
3355cdf0e10cSrcweir
3356cdf0e10cSrcweir if ( rSh.IsGCAttr() )
3357cdf0e10cSrcweir {
3358cdf0e10cSrcweir rSh.GCAttr();
3359cdf0e10cSrcweir rSh.ClearGCAttr();
3360cdf0e10cSrcweir }
3361cdf0e10cSrcweir
3362cdf0e10cSrcweir sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False;
3363cdf0e10cSrcweir if( !bOverSelect )
3364cdf0e10cSrcweir bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos );
3365cdf0e10cSrcweir
3366cdf0e10cSrcweir if ( !bOverSelect )
3367cdf0e10cSrcweir {
3368cdf0e10cSrcweir const sal_Bool bTmpNoInterrupt = bNoInterrupt;
3369cdf0e10cSrcweir bNoInterrupt = sal_False;
3370cdf0e10cSrcweir
3371cdf0e10cSrcweir if( !rSh.IsViewLocked() && bLockView )
3372cdf0e10cSrcweir rSh.LockView( sal_True );
3373cdf0e10cSrcweir else
3374cdf0e10cSrcweir bLockView = sal_False;
3375cdf0e10cSrcweir
3376cdf0e10cSrcweir int nTmpSetCrsr = 0;
3377cdf0e10cSrcweir
3378cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die
3379cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!!
3380cdf0e10cSrcweir MV_KONTEXT( &rSh );
3381cdf0e10cSrcweir nTmpSetCrsr = (rSh.*rSh.fnSetCrsr)(&aDocPos,bOnlyText);
3382cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & nTmpSetCrsr);
3383cdf0e10cSrcweir bCallBase = sal_False;
3384cdf0e10cSrcweir }
3385cdf0e10cSrcweir
3386cdf0e10cSrcweir //#i42732# - notify the edit window that from now on we do not use the input language
3387cdf0e10cSrcweir if ( !(CRSR_POSOLD & nTmpSetCrsr) )
3388cdf0e10cSrcweir SetUseInputLanguage( sal_False );
3389cdf0e10cSrcweir
3390cdf0e10cSrcweir if( bLockView )
3391cdf0e10cSrcweir rSh.LockView( sal_False );
3392cdf0e10cSrcweir
3393cdf0e10cSrcweir bNoInterrupt = bTmpNoInterrupt;
3394cdf0e10cSrcweir }
3395cdf0e10cSrcweir if ( !bOverURLGrf && !bOnlyText )
3396cdf0e10cSrcweir {
3397cdf0e10cSrcweir const int nSelType = rSh.GetSelectionType();
3398cdf0e10cSrcweir // Check in general, if an object is selectable at given position.
3399cdf0e10cSrcweir // Thus, also text fly frames in background become selectable via Ctrl-Click.
3400*23d8f725SOliver-Rainer Wittmann if ( ( nSelType & nsSelectionType::SEL_OLE )
3401*23d8f725SOliver-Rainer Wittmann || ( nSelType & nsSelectionType::SEL_GRF )
3402*23d8f725SOliver-Rainer Wittmann || rSh.IsObjSelectable( aDocPos ) )
3403cdf0e10cSrcweir {
3404cdf0e10cSrcweir MV_KONTEXT( &rSh );
3405cdf0e10cSrcweir if( !rSh.IsFrmSelected() )
3406cdf0e10cSrcweir rSh.GotoNextFly();
3407cdf0e10cSrcweir rSh.EnterSelFrmMode();
3408cdf0e10cSrcweir bCallBase = sal_False;
3409cdf0e10cSrcweir }
3410cdf0e10cSrcweir }
3411cdf0e10cSrcweir break;
3412cdf0e10cSrcweir }
3413cdf0e10cSrcweir }
3414cdf0e10cSrcweir }
3415cdf0e10cSrcweir if (bCallBase)
3416cdf0e10cSrcweir Window::MouseButtonDown(rMEvt);
3417cdf0e10cSrcweir }
3418cdf0e10cSrcweir
3419cdf0e10cSrcweir /*--------------------------------------------------------------------
3420cdf0e10cSrcweir Beschreibung: MouseMove
3421cdf0e10cSrcweir --------------------------------------------------------------------*/
3422cdf0e10cSrcweir
3423cdf0e10cSrcweir
MouseMove(const MouseEvent & _rMEvt)3424cdf0e10cSrcweir void SwEditWin::MouseMove(const MouseEvent& _rMEvt)
3425cdf0e10cSrcweir {
3426cdf0e10cSrcweir MouseEvent rMEvt(_rMEvt);
3427cdf0e10cSrcweir
3428cdf0e10cSrcweir //ignore key modifiers for format paintbrush
3429cdf0e10cSrcweir {
3430cdf0e10cSrcweir sal_Bool bExecFormatPaintbrush = pApplyTempl && pApplyTempl->pFormatClipboard
3431cdf0e10cSrcweir && pApplyTempl->pFormatClipboard->HasContent();
3432cdf0e10cSrcweir if( bExecFormatPaintbrush )
3433cdf0e10cSrcweir rMEvt = MouseEvent( _rMEvt.GetPosPixel(), _rMEvt.GetClicks(),
3434cdf0e10cSrcweir _rMEvt.GetMode(), _rMEvt.GetButtons() );
3435cdf0e10cSrcweir }
3436cdf0e10cSrcweir
3437cdf0e10cSrcweir // solange eine Action laeuft sollte das MouseMove abgeklemmt sein
3438cdf0e10cSrcweir // Ansonsten gibt es den Bug 40102
3439cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
3440cdf0e10cSrcweir if( rSh.ActionPend() )
3441cdf0e10cSrcweir return ;
3442cdf0e10cSrcweir
3443cdf0e10cSrcweir if( pShadCrsr && 0 != (rMEvt.GetModifier() + rMEvt.GetButtons() ) )
3444cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
3445cdf0e10cSrcweir
3446cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly();
3447cdf0e10cSrcweir
3448cdf0e10cSrcweir SET_CURR_SHELL( &rSh );
3449cdf0e10cSrcweir
3450cdf0e10cSrcweir //aPixPt == Point in Pixel, rel. zu ChildWin
3451cdf0e10cSrcweir //aDocPt == Point in Twips, Dokumentkoordinaten
3452cdf0e10cSrcweir const Point aPixPt( rMEvt.GetPosPixel() );
3453cdf0e10cSrcweir const Point aDocPt( PixelToLogic( aPixPt ) );
3454cdf0e10cSrcweir
3455cdf0e10cSrcweir if ( IsChainMode() )
3456cdf0e10cSrcweir {
3457cdf0e10cSrcweir UpdatePointer( aDocPt, rMEvt.GetModifier() );
3458cdf0e10cSrcweir if ( rMEvt.IsLeaveWindow() )
3459cdf0e10cSrcweir rView.GetViewFrame()->HideStatusText();
3460cdf0e10cSrcweir return;
3461cdf0e10cSrcweir }
3462cdf0e10cSrcweir
3463cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
3464cdf0e10cSrcweir
3465cdf0e10cSrcweir const SwCallMouseEvent aLastCallEvent( aSaveCallEvent );
3466cdf0e10cSrcweir aSaveCallEvent.Clear();
3467cdf0e10cSrcweir
3468cdf0e10cSrcweir if ( !bIsDocReadOnly && pSdrView && pSdrView->MouseMove(rMEvt,this) )
3469cdf0e10cSrcweir {
3470cdf0e10cSrcweir SetPointer( POINTER_TEXT );
3471cdf0e10cSrcweir return; // Event von der SdrView ausgewertet
3472cdf0e10cSrcweir }
3473cdf0e10cSrcweir
3474cdf0e10cSrcweir const Point aOldPt( rSh.VisArea().Pos() );
3475cdf0e10cSrcweir const sal_Bool bInsWin = rSh.VisArea().IsInside( aDocPt );
3476cdf0e10cSrcweir
3477cdf0e10cSrcweir if( pShadCrsr && !bInsWin )
3478cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
3479cdf0e10cSrcweir
3480cdf0e10cSrcweir if( bInsWin && pRowColumnSelectionStart )
3481cdf0e10cSrcweir {
3482cdf0e10cSrcweir EnterArea();
3483cdf0e10cSrcweir Point aPos( aDocPt );
3484cdf0e10cSrcweir if( rSh.SelectTableRowCol( *pRowColumnSelectionStart, &aPos, bIsRowDrag ))
3485cdf0e10cSrcweir return;
3486cdf0e10cSrcweir }
3487cdf0e10cSrcweir
3488cdf0e10cSrcweir // Position ist noetig fuer OS/2, da dort nach einem MB-Down
3489cdf0e10cSrcweir // offensichtlich sofort ein MB-Move gerufen wird.
3490cdf0e10cSrcweir if( bDDTimerStarted )
3491cdf0e10cSrcweir {
3492cdf0e10cSrcweir Point aDD( SwEditWin::nDDStartPosX, SwEditWin::nDDStartPosY );
3493cdf0e10cSrcweir aDD = LogicToPixel( aDD );
3494cdf0e10cSrcweir Rectangle aRect( aDD.X()-3, aDD.Y()-3, aDD.X()+3, aDD.Y()+3 );
3495cdf0e10cSrcweir if ( !aRect.IsInside( aPixPt ) ) // MA 23. May. 95: Tatterschutz.
3496cdf0e10cSrcweir StopDDTimer( &rSh, aDocPt );
3497cdf0e10cSrcweir }
3498cdf0e10cSrcweir
3499cdf0e10cSrcweir if(rView.GetDrawFuncPtr())
3500cdf0e10cSrcweir {
3501cdf0e10cSrcweir if( bInsDraw )
3502cdf0e10cSrcweir {
3503cdf0e10cSrcweir rView.GetDrawFuncPtr()->MouseMove( rMEvt );
3504cdf0e10cSrcweir if ( !bInsWin )
3505cdf0e10cSrcweir {
3506cdf0e10cSrcweir Point aTmp( aDocPt );
3507cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt;
3508cdf0e10cSrcweir LeaveArea( aTmp );
3509cdf0e10cSrcweir }
3510cdf0e10cSrcweir else
3511cdf0e10cSrcweir EnterArea();
3512cdf0e10cSrcweir return;
3513cdf0e10cSrcweir }
3514cdf0e10cSrcweir else if(!rSh.IsFrmSelected() && !rSh.IsObjSelected())
3515cdf0e10cSrcweir {
3516cdf0e10cSrcweir SfxBindings &rBnd = rSh.GetView().GetViewFrame()->GetBindings();
3517cdf0e10cSrcweir Point aRelPos = rSh.GetRelativePagePosition(aDocPt);
3518cdf0e10cSrcweir if(aRelPos.X() >= 0)
3519cdf0e10cSrcweir {
3520cdf0e10cSrcweir FieldUnit eMetric = ::GetDfltMetric(0 != PTR_CAST(SwWebView, &GetView()));
3521cdf0e10cSrcweir SW_MOD()->PutItem(SfxUInt16Item(SID_ATTR_METRIC, static_cast< sal_uInt16 >(eMetric)));
3522cdf0e10cSrcweir const SfxPointItem aTmp1( SID_ATTR_POSITION, aRelPos );
3523cdf0e10cSrcweir rBnd.SetState( aTmp1 );
3524cdf0e10cSrcweir }
3525cdf0e10cSrcweir else
3526cdf0e10cSrcweir {
3527cdf0e10cSrcweir rBnd.Invalidate(SID_ATTR_POSITION);
3528cdf0e10cSrcweir }
3529cdf0e10cSrcweir rBnd.Invalidate(SID_ATTR_SIZE);
3530cdf0e10cSrcweir const SfxStringItem aCell( SID_TABLE_CELL, aEmptyStr );
3531cdf0e10cSrcweir rBnd.SetState( aCell );
3532cdf0e10cSrcweir }
3533cdf0e10cSrcweir }
3534cdf0e10cSrcweir
3535cdf0e10cSrcweir sal_uInt8 nMouseTabCol;
3536cdf0e10cSrcweir if( !bIsDocReadOnly && bInsWin && !pApplyTempl && !rSh.IsInSelect() )
3537cdf0e10cSrcweir {
3538cdf0e10cSrcweir if ( SW_TABCOL_NONE != (nMouseTabCol = rSh.WhichMouseTabCol( aDocPt ) ) &&
3539cdf0e10cSrcweir !rSh.IsObjSelectable( aDocPt ) )
3540cdf0e10cSrcweir {
3541cdf0e10cSrcweir sal_uInt16 nPointer = USHRT_MAX;
3542cdf0e10cSrcweir bool bChkTblSel = false;
3543cdf0e10cSrcweir
3544cdf0e10cSrcweir switch ( nMouseTabCol )
3545cdf0e10cSrcweir {
3546cdf0e10cSrcweir case SW_TABCOL_VERT :
3547cdf0e10cSrcweir case SW_TABROW_HORI :
3548cdf0e10cSrcweir nPointer = POINTER_VSIZEBAR;
3549cdf0e10cSrcweir bChkTblSel = true;
3550cdf0e10cSrcweir break;
3551cdf0e10cSrcweir case SW_TABROW_VERT :
3552cdf0e10cSrcweir case SW_TABCOL_HORI :
3553cdf0e10cSrcweir nPointer = POINTER_HSIZEBAR;
3554cdf0e10cSrcweir bChkTblSel = true;
3555cdf0e10cSrcweir break;
35565b40a975SOliver-Rainer Wittmann // Enhanced table selection
3557cdf0e10cSrcweir case SW_TABSEL_HORI :
3558cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_SE;
3559cdf0e10cSrcweir break;
3560cdf0e10cSrcweir case SW_TABSEL_HORI_RTL :
3561cdf0e10cSrcweir case SW_TABSEL_VERT :
3562cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_SW;
3563cdf0e10cSrcweir break;
3564cdf0e10cSrcweir case SW_TABCOLSEL_HORI :
3565cdf0e10cSrcweir case SW_TABROWSEL_VERT :
3566cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_S;
3567cdf0e10cSrcweir break;
3568cdf0e10cSrcweir case SW_TABROWSEL_HORI :
3569cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_E;
3570cdf0e10cSrcweir break;
3571cdf0e10cSrcweir case SW_TABROWSEL_HORI_RTL :
3572cdf0e10cSrcweir case SW_TABCOLSEL_VERT :
3573cdf0e10cSrcweir nPointer = POINTER_TAB_SELECT_W;
3574cdf0e10cSrcweir break;
3575cdf0e10cSrcweir }
3576cdf0e10cSrcweir
3577cdf0e10cSrcweir if ( USHRT_MAX != nPointer &&
3578cdf0e10cSrcweir // Enhanced table selection is explicitely allowed in table mode
3579cdf0e10cSrcweir ( !bChkTblSel || !rSh.IsTableMode() ) )
3580cdf0e10cSrcweir {
3581cdf0e10cSrcweir SetPointer( nPointer );
3582cdf0e10cSrcweir }
3583cdf0e10cSrcweir
3584cdf0e10cSrcweir return;
3585cdf0e10cSrcweir }
3586cdf0e10cSrcweir else if (rSh.IsNumLabel(aDocPt, RULER_MOUSE_MARGINWIDTH))
3587cdf0e10cSrcweir {
3588cdf0e10cSrcweir SwTxtNode* pNodeAtPos = rSh.GetNumRuleNodeAtPos( aDocPt );
3589cdf0e10cSrcweir const sal_uInt16 nPointer =
3590cdf0e10cSrcweir rSh.IsVerticalModeAtNdAndPos( *pNodeAtPos, aDocPt )
3591cdf0e10cSrcweir ? POINTER_VSIZEBAR
3592cdf0e10cSrcweir : POINTER_HSIZEBAR;
3593cdf0e10cSrcweir SetPointer( nPointer );
3594cdf0e10cSrcweir
3595cdf0e10cSrcweir return;
3596cdf0e10cSrcweir }
3597cdf0e10cSrcweir }
3598cdf0e10cSrcweir
3599cdf0e10cSrcweir sal_Bool bDelShadCrsr = sal_True;
3600cdf0e10cSrcweir
3601cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
3602cdf0e10cSrcweir {
3603cdf0e10cSrcweir case MOUSE_LEFT:
3604cdf0e10cSrcweir if( pAnchorMarker )
3605cdf0e10cSrcweir {
3606cdf0e10cSrcweir // Now we need to refresh the SdrHdl pointer of pAnchorMarker.
3607cdf0e10cSrcweir // This looks a little bit tricky, but it solves the following
3608cdf0e10cSrcweir // problem: the pAnchorMarker contains a pointer to an SdrHdl,
3609cdf0e10cSrcweir // if the FindAnchorPos-call cause a scrolling of the visible
3610cdf0e10cSrcweir // area, it's possible that the SdrHdl will be destroyed and a
3611cdf0e10cSrcweir // new one will initialized at the original position(GetHdlPos).
3612cdf0e10cSrcweir // So the pAnchorMarker has to find the right SdrHdl, if it's
3613cdf0e10cSrcweir // the old one, it will find it with position aOld, if this one
3614cdf0e10cSrcweir // is destroyed, it will find a new one at position GetHdlPos().
3615cdf0e10cSrcweir const Point aOld = pAnchorMarker->GetPosForHitTest( *(rSh.GetOut()) );
3616cdf0e10cSrcweir Point aNew = rSh.FindAnchorPos( aDocPt );
3617cdf0e10cSrcweir SdrHdl* pHdl;
3618cdf0e10cSrcweir if( (0!=( pHdl = pSdrView->PickHandle( aOld ) )||
3619cdf0e10cSrcweir 0 !=(pHdl = pSdrView->PickHandle( pAnchorMarker->GetHdlPos()) ) ) &&
3620cdf0e10cSrcweir ( pHdl->GetKind() == HDL_ANCHOR ||
3621cdf0e10cSrcweir pHdl->GetKind() == HDL_ANCHOR_TR ) )
3622cdf0e10cSrcweir {
3623cdf0e10cSrcweir pAnchorMarker->ChgHdl( pHdl );
3624cdf0e10cSrcweir if( aNew.X() || aNew.Y() )
3625cdf0e10cSrcweir {
3626cdf0e10cSrcweir pAnchorMarker->SetPos( aNew );
3627cdf0e10cSrcweir pAnchorMarker->SetLastPos( aDocPt );
3628cdf0e10cSrcweir }
3629cdf0e10cSrcweir }
3630cdf0e10cSrcweir else
3631cdf0e10cSrcweir {
3632cdf0e10cSrcweir delete pAnchorMarker;
3633cdf0e10cSrcweir pAnchorMarker = NULL;
3634cdf0e10cSrcweir }
3635cdf0e10cSrcweir }
3636cdf0e10cSrcweir if ( bInsDraw )
3637cdf0e10cSrcweir {
3638cdf0e10cSrcweir if ( !bMBPressed )
3639cdf0e10cSrcweir break;
3640cdf0e10cSrcweir if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) )
3641cdf0e10cSrcweir {
3642cdf0e10cSrcweir if ( !bInsWin )
3643cdf0e10cSrcweir LeaveArea( aDocPt );
3644cdf0e10cSrcweir else
3645cdf0e10cSrcweir EnterArea();
3646cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() )
3647cdf0e10cSrcweir {
3648cdf0e10cSrcweir pSdrView->SetOrtho(sal_False);
3649cdf0e10cSrcweir rView.GetDrawFuncPtr()->MouseMove( rMEvt );
3650cdf0e10cSrcweir }
3651cdf0e10cSrcweir bIsInMove = sal_True;
3652cdf0e10cSrcweir }
3653cdf0e10cSrcweir return;
3654cdf0e10cSrcweir }
3655cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT:
3656cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
3657cdf0e10cSrcweir if ( !bMBPressed )
3658cdf0e10cSrcweir break;
3659cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1:
3660cdf0e10cSrcweir if ( bFrmDrag && rSh.IsSelFrmMode() )
3661cdf0e10cSrcweir {
3662cdf0e10cSrcweir if( !bMBPressed )
3663cdf0e10cSrcweir break;
3664cdf0e10cSrcweir
3665cdf0e10cSrcweir if ( bIsInMove || IsMinMove( aStartPos, aPixPt ) )
3666cdf0e10cSrcweir {
3667cdf0e10cSrcweir // Event-Verarbeitung fuers Resizen
3668cdf0e10cSrcweir if( pSdrView->AreObjectsMarked() )
3669cdf0e10cSrcweir {
3670cdf0e10cSrcweir const SwFrmFmt* pFlyFmt;
3671cdf0e10cSrcweir const SvxMacro* pMacro;
3672cdf0e10cSrcweir
3673cdf0e10cSrcweir const Point aSttPt( PixelToLogic( aStartPos ) );
3674cdf0e10cSrcweir
3675cdf0e10cSrcweir // geht es los?
3676cdf0e10cSrcweir if( HDL_USER == eSdrMoveHdl )
3677cdf0e10cSrcweir {
3678cdf0e10cSrcweir SdrHdl* pHdl = pSdrView->PickHandle( aSttPt );
3679cdf0e10cSrcweir eSdrMoveHdl = pHdl ? pHdl->GetKind() : HDL_MOVE;
3680cdf0e10cSrcweir }
3681cdf0e10cSrcweir
3682cdf0e10cSrcweir sal_uInt16 nEvent = HDL_MOVE == eSdrMoveHdl
3683cdf0e10cSrcweir ? SW_EVENT_FRM_MOVE
3684cdf0e10cSrcweir : SW_EVENT_FRM_RESIZE;
3685cdf0e10cSrcweir
3686cdf0e10cSrcweir if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) &&
3687cdf0e10cSrcweir 0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable().
3688cdf0e10cSrcweir Get( nEvent )) &&
3689cdf0e10cSrcweir aRszMvHdlPt != aDocPt )
3690cdf0e10cSrcweir {
3691cdf0e10cSrcweir aRszMvHdlPt = aDocPt;
3692cdf0e10cSrcweir sal_uInt16 nPos = 0;
3693cdf0e10cSrcweir String sRet;
3694cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray;
3695cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable;
3696cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() );
3697cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
3698cdf0e10cSrcweir
3699cdf0e10cSrcweir if( SW_EVENT_FRM_RESIZE == nEvent )
3700cdf0e10cSrcweir {
3701cdf0e10cSrcweir xVar = new SbxVariable;
3702cdf0e10cSrcweir xVar->PutUShort( static_cast< sal_uInt16 >(eSdrMoveHdl) );
3703cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
3704cdf0e10cSrcweir }
3705cdf0e10cSrcweir
3706cdf0e10cSrcweir xVar = new SbxVariable;
3707cdf0e10cSrcweir xVar->PutLong( aDocPt.X() - aSttPt.X() );
3708cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
3709cdf0e10cSrcweir xVar = new SbxVariable;
3710cdf0e10cSrcweir xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
3711cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
3712cdf0e10cSrcweir
3713cdf0e10cSrcweir ReleaseMouse();
3714cdf0e10cSrcweir
3715cdf0e10cSrcweir rSh.ExecMacro( *pMacro, &sRet, &xArgs );
3716cdf0e10cSrcweir
3717cdf0e10cSrcweir CaptureMouse();
3718cdf0e10cSrcweir
3719cdf0e10cSrcweir if( sRet.Len() && 0 != sRet.ToInt32() )
3720cdf0e10cSrcweir return ;
3721cdf0e10cSrcweir }
3722cdf0e10cSrcweir }
3723cdf0e10cSrcweir // Event-Verarbeitung fuers Resizen
3724cdf0e10cSrcweir
3725cdf0e10cSrcweir if( bIsDocReadOnly )
3726cdf0e10cSrcweir break;
3727cdf0e10cSrcweir
3728cdf0e10cSrcweir if ( rMEvt.IsShift() )
3729cdf0e10cSrcweir {
3730cdf0e10cSrcweir pSdrView->SetOrtho(sal_True);
3731cdf0e10cSrcweir pSdrView->SetAngleSnapEnabled(sal_True);
3732cdf0e10cSrcweir }
3733cdf0e10cSrcweir else
3734cdf0e10cSrcweir {
3735cdf0e10cSrcweir pSdrView->SetOrtho(sal_False);
3736cdf0e10cSrcweir pSdrView->SetAngleSnapEnabled(sal_False);
3737cdf0e10cSrcweir }
3738cdf0e10cSrcweir
3739cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt, rMEvt.IsShift() );
3740cdf0e10cSrcweir bIsInMove = sal_True;
3741cdf0e10cSrcweir }
3742cdf0e10cSrcweir else if( bIsDocReadOnly )
3743cdf0e10cSrcweir break;
3744cdf0e10cSrcweir
3745cdf0e10cSrcweir if ( !bInsWin )
3746cdf0e10cSrcweir {
3747cdf0e10cSrcweir Point aTmp( aDocPt );
3748cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt;
3749cdf0e10cSrcweir LeaveArea( aTmp );
3750cdf0e10cSrcweir }
3751cdf0e10cSrcweir else if(bIsInMove)
3752cdf0e10cSrcweir EnterArea();
3753cdf0e10cSrcweir return;
3754cdf0e10cSrcweir }
3755cdf0e10cSrcweir if ( !rSh.IsSelFrmMode() && !bDDINetAttr &&
3756cdf0e10cSrcweir (IsMinMove( aStartPos,aPixPt ) || bIsInMove) &&
3757cdf0e10cSrcweir (rSh.IsInSelect() || !rSh.ChgCurrPam( aDocPt )) )
3758cdf0e10cSrcweir {
3759cdf0e10cSrcweir if ( pSdrView )
3760cdf0e10cSrcweir {
3761cdf0e10cSrcweir if ( rMEvt.IsShift() )
3762cdf0e10cSrcweir pSdrView->SetOrtho(sal_True);
3763cdf0e10cSrcweir else
3764cdf0e10cSrcweir pSdrView->SetOrtho(sal_False);
3765cdf0e10cSrcweir }
3766cdf0e10cSrcweir if ( !bInsWin )
3767cdf0e10cSrcweir {
3768cdf0e10cSrcweir Point aTmp( aDocPt );
3769cdf0e10cSrcweir aTmp += rSh.VisArea().Pos() - aOldPt;
3770cdf0e10cSrcweir LeaveArea( aTmp );
3771cdf0e10cSrcweir }
3772cdf0e10cSrcweir else
3773cdf0e10cSrcweir {
3774cdf0e10cSrcweir //JP 24.09.98: Fix fuer die Bugs 55592 / 55931
3775cdf0e10cSrcweir //JP 23.04.99: Fix fuer den Bugs 65289
3776cdf0e10cSrcweir //JP 06.07.99: Fix fuer den Bugs 67360
3777cdf0e10cSrcweir if( !rMEvt.IsSynthetic() &&
3778cdf0e10cSrcweir !(( MOUSE_LEFT + KEY_MOD1 ==
3779cdf0e10cSrcweir rMEvt.GetModifier() + rMEvt.GetButtons() ) &&
3780cdf0e10cSrcweir rSh.Is_FnDragEQBeginDrag() && !rSh.IsAddMode() ))
3781cdf0e10cSrcweir {
3782cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt,sal_False );
3783cdf0e10cSrcweir
3784cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False));
3785cdf0e10cSrcweir EnterArea();
3786cdf0e10cSrcweir }
3787cdf0e10cSrcweir }
3788cdf0e10cSrcweir }
3789cdf0e10cSrcweir bDDINetAttr = sal_False;
3790cdf0e10cSrcweir break;
3791cdf0e10cSrcweir case 0:
3792cdf0e10cSrcweir {
3793cdf0e10cSrcweir if ( pApplyTempl )
3794cdf0e10cSrcweir {
3795cdf0e10cSrcweir UpdatePointer(aDocPt, 0); // evtl. muss hier ein Rahmen markiert werden
3796cdf0e10cSrcweir break;
3797cdf0e10cSrcweir }
3798cdf0e10cSrcweir //#i6193#, change ui if mouse is over SwPostItField
3799cdf0e10cSrcweir // TODO: do the same thing for redlines SW_REDLINE
3800cdf0e10cSrcweir SwRect aFldRect;
3801cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_FIELD);
3802cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_False, &aFldRect ) )
3803cdf0e10cSrcweir {
3804cdf0e10cSrcweir const SwField* pFld = aCntntAtPos.aFnd.pFld;
3805cdf0e10cSrcweir if (pFld->Which()== RES_POSTITFLD)
3806cdf0e10cSrcweir {
3807cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(reinterpret_cast<const SwPostItField*>(pFld),false);
3808cdf0e10cSrcweir }
3809cdf0e10cSrcweir else
3810cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(0,false);
3811cdf0e10cSrcweir }
3812cdf0e10cSrcweir else
3813cdf0e10cSrcweir rView.GetPostItMgr()->SetShadowState(0,false);
3814cdf0e10cSrcweir // no break;
3815cdf0e10cSrcweir }
3816cdf0e10cSrcweir case KEY_SHIFT:
3817cdf0e10cSrcweir case KEY_MOD2:
3818cdf0e10cSrcweir case KEY_MOD1:
3819cdf0e10cSrcweir if ( !bInsDraw )
3820cdf0e10cSrcweir {
3821cdf0e10cSrcweir sal_Bool bTstShdwCrsr = sal_True;
3822cdf0e10cSrcweir
3823cdf0e10cSrcweir UpdatePointer( aDocPt, rMEvt.GetModifier() );
3824cdf0e10cSrcweir
3825cdf0e10cSrcweir const SwFrmFmt* pFmt = 0;
3826cdf0e10cSrcweir const SwFmtINetFmt* pINet = 0;
3827cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_INETATTR );
3828cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos ) )
3829cdf0e10cSrcweir pINet = (SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr;
3830cdf0e10cSrcweir
3831cdf0e10cSrcweir const void* pTmp = pINet;
3832cdf0e10cSrcweir
3833cdf0e10cSrcweir if( pINet ||
3834cdf0e10cSrcweir 0 != ( pTmp = pFmt = rSh.GetFmtFromAnyObj( aDocPt )))
3835cdf0e10cSrcweir {
3836cdf0e10cSrcweir bTstShdwCrsr = sal_False;
3837cdf0e10cSrcweir if( pTmp == pINet )
3838cdf0e10cSrcweir aSaveCallEvent.Set( pINet );
3839cdf0e10cSrcweir else
3840cdf0e10cSrcweir {
3841cdf0e10cSrcweir IMapObject* pIMapObj = pFmt->GetIMapObject( aDocPt );
3842cdf0e10cSrcweir if( pIMapObj )
3843cdf0e10cSrcweir aSaveCallEvent.Set( pFmt, pIMapObj );
3844cdf0e10cSrcweir else
3845cdf0e10cSrcweir aSaveCallEvent.Set( EVENT_OBJECT_URLITEM, pFmt );
3846cdf0e10cSrcweir }
3847cdf0e10cSrcweir
3848cdf0e10cSrcweir // sollte wir ueber einem InternetFeld mit einem
3849cdf0e10cSrcweir // gebundenen Macro stehen?
3850cdf0e10cSrcweir if( aSaveCallEvent != aLastCallEvent )
3851cdf0e10cSrcweir {
3852cdf0e10cSrcweir if( aLastCallEvent.HasEvent() )
3853cdf0e10cSrcweir rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT,
3854cdf0e10cSrcweir aLastCallEvent, sal_True );
3855cdf0e10cSrcweir // 0 besagt, das das Object gar keine Tabelle hat
3856cdf0e10cSrcweir if( !rSh.CallEvent( SFX_EVENT_MOUSEOVER_OBJECT,
3857cdf0e10cSrcweir aSaveCallEvent ))
3858cdf0e10cSrcweir aSaveCallEvent.Clear();
3859cdf0e10cSrcweir }
3860cdf0e10cSrcweir }
3861cdf0e10cSrcweir else if( aLastCallEvent.HasEvent() )
3862cdf0e10cSrcweir {
3863cdf0e10cSrcweir // Cursor stand auf einem Object
3864cdf0e10cSrcweir rSh.CallEvent( SFX_EVENT_MOUSEOUT_OBJECT,
3865cdf0e10cSrcweir aLastCallEvent, sal_True );
3866cdf0e10cSrcweir }
3867cdf0e10cSrcweir
3868cdf0e10cSrcweir if( bTstShdwCrsr && bInsWin && !bIsDocReadOnly &&
3869cdf0e10cSrcweir !bInsFrm &&
3870cdf0e10cSrcweir !rSh.GetViewOptions()->getBrowseMode() &&
3871cdf0e10cSrcweir rSh.GetViewOptions()->IsShadowCursor() &&
3872cdf0e10cSrcweir !(rMEvt.GetModifier() + rMEvt.GetButtons()) &&
3873cdf0e10cSrcweir !rSh.HasSelection() && !GetConnectMetaFile() )
3874cdf0e10cSrcweir {
3875cdf0e10cSrcweir SwRect aRect;
3876cdf0e10cSrcweir sal_Int16 eOrient;
3877cdf0e10cSrcweir SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode();
3878cdf0e10cSrcweir if( rSh.GetShadowCrsrPos( aDocPt, eMode, aRect, eOrient ))
3879cdf0e10cSrcweir {
3880cdf0e10cSrcweir if( !pShadCrsr )
3881cdf0e10cSrcweir pShadCrsr = new SwShadowCursor( *this,
3882cdf0e10cSrcweir SwViewOption::GetDirectCursorColor() );
3883cdf0e10cSrcweir if( text::HoriOrientation::RIGHT != eOrient && text::HoriOrientation::CENTER != eOrient )
3884cdf0e10cSrcweir eOrient = text::HoriOrientation::LEFT;
3885cdf0e10cSrcweir pShadCrsr->SetPos( aRect.Pos(), aRect.Height(), static_cast< sal_uInt16 >(eOrient) );
3886cdf0e10cSrcweir bDelShadCrsr = sal_False;
3887cdf0e10cSrcweir }
3888cdf0e10cSrcweir }
3889cdf0e10cSrcweir }
3890cdf0e10cSrcweir break;
3891cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2:
3892cdf0e10cSrcweir if( rSh.IsBlockMode() && !rMEvt.IsSynthetic() )
3893cdf0e10cSrcweir {
3894cdf0e10cSrcweir (rSh.*rSh.fnDrag)( &aDocPt,sal_False );
3895cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPt,sal_False));
3896cdf0e10cSrcweir EnterArea();
3897cdf0e10cSrcweir }
3898cdf0e10cSrcweir break;
3899cdf0e10cSrcweir }
3900cdf0e10cSrcweir
3901cdf0e10cSrcweir if( bDelShadCrsr && pShadCrsr )
3902cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
3903cdf0e10cSrcweir bWasShdwCrsr = sal_False;
3904cdf0e10cSrcweir }
3905cdf0e10cSrcweir
3906cdf0e10cSrcweir /*--------------------------------------------------------------------
3907cdf0e10cSrcweir Beschreibung: Button Up
3908cdf0e10cSrcweir --------------------------------------------------------------------*/
3909cdf0e10cSrcweir
3910cdf0e10cSrcweir
MouseButtonUp(const MouseEvent & rMEvt)3911cdf0e10cSrcweir void SwEditWin::MouseButtonUp(const MouseEvent& rMEvt)
3912cdf0e10cSrcweir {
3913cdf0e10cSrcweir sal_Bool bCallBase = sal_True;
3914cdf0e10cSrcweir
3915cdf0e10cSrcweir sal_Bool bCallShadowCrsr = bWasShdwCrsr;
3916cdf0e10cSrcweir bWasShdwCrsr = sal_False;
3917cdf0e10cSrcweir if( pShadCrsr )
3918cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
3919cdf0e10cSrcweir
3920cdf0e10cSrcweir if( pRowColumnSelectionStart )
3921cdf0e10cSrcweir DELETEZ( pRowColumnSelectionStart );
3922cdf0e10cSrcweir
3923cdf0e10cSrcweir SdrHdlKind eOldSdrMoveHdl = eSdrMoveHdl;
3924cdf0e10cSrcweir eSdrMoveHdl = HDL_USER; // fuer die MoveEvents - wieder zuruecksetzen
3925cdf0e10cSrcweir
3926cdf0e10cSrcweir // sicherheitshalber zuruecksetzen Bug 27900
3927cdf0e10cSrcweir rView.SetTabColFromDoc( sal_False );
3928cdf0e10cSrcweir rView.SetNumRuleNodeFromDoc(NULL);
3929cdf0e10cSrcweir
3930cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
3931cdf0e10cSrcweir SET_CURR_SHELL( &rSh );
3932cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
3933cdf0e10cSrcweir if ( pSdrView )
3934cdf0e10cSrcweir {
3935cdf0e10cSrcweir pSdrView->SetOrtho(sal_False);
3936cdf0e10cSrcweir
3937cdf0e10cSrcweir if ( pSdrView->MouseButtonUp( rMEvt,this ) )
3938cdf0e10cSrcweir {
3939cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
3940cdf0e10cSrcweir return; // Event von der SdrView ausgewertet
3941cdf0e10cSrcweir }
3942cdf0e10cSrcweir }
3943cdf0e10cSrcweir //MouseButtonUp nur bearbeiten, wenn auch das Down an dieses Fenster ging.
3944cdf0e10cSrcweir if ( !bMBPressed )
3945cdf0e10cSrcweir {
3946cdf0e10cSrcweir return;
3947cdf0e10cSrcweir }
3948cdf0e10cSrcweir
3949cdf0e10cSrcweir Point aDocPt( PixelToLogic( rMEvt.GetPosPixel() ) );
3950cdf0e10cSrcweir
3951cdf0e10cSrcweir if ( bDDTimerStarted )
3952cdf0e10cSrcweir {
3953cdf0e10cSrcweir StopDDTimer( &rSh, aDocPt );
3954cdf0e10cSrcweir bMBPressed = sal_False;
3955cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
3956cdf0e10cSrcweir {
3957cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
3958cdf0e10cSrcweir bFrmDrag = sal_False;
3959cdf0e10cSrcweir }
3960cdf0e10cSrcweir bNoInterrupt = sal_False;
3961cdf0e10cSrcweir ReleaseMouse();
3962cdf0e10cSrcweir return;
3963cdf0e10cSrcweir }
3964cdf0e10cSrcweir
3965cdf0e10cSrcweir if( pAnchorMarker )
3966cdf0e10cSrcweir {
39674772d9afSArmin Le Grand if(pAnchorMarker->GetHdl())
39684772d9afSArmin Le Grand {
39695b40a975SOliver-Rainer Wittmann // delete selected after drag
39704772d9afSArmin Le Grand pAnchorMarker->GetHdl()->SetSelected(false);
39714772d9afSArmin Le Grand }
39724772d9afSArmin Le Grand
3973cdf0e10cSrcweir Point aPnt( pAnchorMarker->GetLastPos() );
3974cdf0e10cSrcweir DELETEZ( pAnchorMarker );
3975cdf0e10cSrcweir if( aPnt.X() || aPnt.Y() )
3976cdf0e10cSrcweir rSh.FindAnchorPos( aPnt, sal_True );
3977cdf0e10cSrcweir }
3978cdf0e10cSrcweir if ( bInsDraw && rView.GetDrawFuncPtr() )
3979cdf0e10cSrcweir {
3980cdf0e10cSrcweir if ( rView.GetDrawFuncPtr()->MouseButtonUp( rMEvt ) )
3981cdf0e10cSrcweir {
3982cdf0e10cSrcweir if (rView.GetDrawFuncPtr()) // Koennte im MouseButtonUp zerstoert worden sein
3983cdf0e10cSrcweir {
3984cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
3985cdf0e10cSrcweir
3986cdf0e10cSrcweir if (!rView.IsDrawMode())
3987cdf0e10cSrcweir {
3988cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
3989cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
3990cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_SIZE );
3991cdf0e10cSrcweir rBind.Invalidate( SID_TABLE_CELL );
3992cdf0e10cSrcweir }
3993cdf0e10cSrcweir }
3994cdf0e10cSrcweir
3995cdf0e10cSrcweir if ( rSh.IsObjSelected() )
3996cdf0e10cSrcweir {
3997cdf0e10cSrcweir rSh.EnterSelFrmMode();
3998cdf0e10cSrcweir if (!rView.GetDrawFuncPtr())
3999cdf0e10cSrcweir StdDrawMode( OBJ_NONE, sal_True );
4000cdf0e10cSrcweir }
4001cdf0e10cSrcweir else if ( rSh.IsFrmSelected() )
4002cdf0e10cSrcweir {
4003cdf0e10cSrcweir rSh.EnterSelFrmMode();
4004cdf0e10cSrcweir StopInsFrm();
4005cdf0e10cSrcweir }
4006cdf0e10cSrcweir else
4007cdf0e10cSrcweir {
4008cdf0e10cSrcweir const Point aDocPos( PixelToLogic( aStartPos ) );
4009cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
4010cdf0e10cSrcweir rSh.Edit();
4011cdf0e10cSrcweir }
4012cdf0e10cSrcweir
4013cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
4014cdf0e10cSrcweir }
4015cdf0e10cSrcweir else if (rMEvt.GetButtons() == MOUSE_RIGHT && rSh.IsDrawCreate())
4016cdf0e10cSrcweir rView.GetDrawFuncPtr()->BreakCreate(); // Zeichnen abbrechen
4017cdf0e10cSrcweir
4018cdf0e10cSrcweir bNoInterrupt = sal_False;
4019cdf0e10cSrcweir ReleaseMouse();
4020cdf0e10cSrcweir return;
4021cdf0e10cSrcweir }
4022cdf0e10cSrcweir sal_Bool bPopMode = sal_False;
4023cdf0e10cSrcweir switch ( rMEvt.GetModifier() + rMEvt.GetButtons() )
4024cdf0e10cSrcweir {
4025cdf0e10cSrcweir case MOUSE_LEFT:
4026cdf0e10cSrcweir if ( bInsDraw && rSh.IsDrawCreate() )
4027cdf0e10cSrcweir {
4028cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && rView.GetDrawFuncPtr()->MouseButtonUp(rMEvt) == sal_True )
4029cdf0e10cSrcweir {
4030cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
4031cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
4032cdf0e10cSrcweir if ( rSh.IsObjSelected() )
4033cdf0e10cSrcweir rSh.EnterSelFrmMode();
4034cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm )
4035cdf0e10cSrcweir StopInsFrm();
4036cdf0e10cSrcweir }
4037cdf0e10cSrcweir bCallBase = sal_False;
4038cdf0e10cSrcweir break;
4039cdf0e10cSrcweir }
4040cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD1:
4041cdf0e10cSrcweir case MOUSE_LEFT + KEY_MOD2:
4042cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT + KEY_MOD1:
4043cdf0e10cSrcweir if ( bFrmDrag && rSh.IsSelFrmMode() )
4044cdf0e10cSrcweir {
4045cdf0e10cSrcweir if ( rMEvt.IsMod1() ) //Kopieren und nicht moven.
4046cdf0e10cSrcweir {
4047cdf0e10cSrcweir //Drag abbrechen, statt dessen internes Copy verwenden
4048cdf0e10cSrcweir Rectangle aRect;
4049cdf0e10cSrcweir rSh.GetDrawView()->TakeActionRect( aRect );
4050cdf0e10cSrcweir if (!aRect.IsEmpty())
4051cdf0e10cSrcweir {
4052cdf0e10cSrcweir rSh.BreakDrag();
4053cdf0e10cSrcweir Point aEndPt, aSttPt;
4054cdf0e10cSrcweir if ( rSh.GetSelFrmType() & FRMTYPE_FLY_ATCNT )
4055cdf0e10cSrcweir {
4056cdf0e10cSrcweir aEndPt = aRect.TopLeft();
4057cdf0e10cSrcweir aSttPt = rSh.GetDrawView()->GetAllMarkedRect().TopLeft();
4058cdf0e10cSrcweir }
4059cdf0e10cSrcweir else
4060cdf0e10cSrcweir {
4061cdf0e10cSrcweir aEndPt = aRect.Center();
4062cdf0e10cSrcweir aSttPt = rSh.GetDrawView()->GetAllMarkedRect().Center();
4063cdf0e10cSrcweir }
4064cdf0e10cSrcweir if ( aSttPt != aEndPt )
4065cdf0e10cSrcweir {
4066cdf0e10cSrcweir rSh.StartUndo( UNDO_UI_DRAG_AND_COPY );
4067cdf0e10cSrcweir rSh.Copy(&rSh, aSttPt, aEndPt, sal_False);
4068cdf0e10cSrcweir rSh.EndUndo( UNDO_UI_DRAG_AND_COPY );
4069cdf0e10cSrcweir }
4070cdf0e10cSrcweir }
4071cdf0e10cSrcweir else
4072cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt,sal_False );
4073cdf0e10cSrcweir }
4074cdf0e10cSrcweir else
4075cdf0e10cSrcweir {
4076cdf0e10cSrcweir {
4077cdf0e10cSrcweir const SwFrmFmt* pFlyFmt;
4078cdf0e10cSrcweir const SvxMacro* pMacro;
4079cdf0e10cSrcweir
4080cdf0e10cSrcweir sal_uInt16 nEvent = HDL_MOVE == eOldSdrMoveHdl
4081cdf0e10cSrcweir ? SW_EVENT_FRM_MOVE
4082cdf0e10cSrcweir : SW_EVENT_FRM_RESIZE;
4083cdf0e10cSrcweir
4084cdf0e10cSrcweir if( 0 != ( pFlyFmt = rSh.GetFlyFrmFmt() ) &&
4085cdf0e10cSrcweir 0 != ( pMacro = pFlyFmt->GetMacro().GetMacroTable().
4086cdf0e10cSrcweir Get( nEvent )) )
4087cdf0e10cSrcweir {
4088cdf0e10cSrcweir const Point aSttPt( PixelToLogic( aStartPos ) );
4089cdf0e10cSrcweir aRszMvHdlPt = aDocPt;
4090cdf0e10cSrcweir sal_uInt16 nPos = 0;
4091cdf0e10cSrcweir SbxArrayRef xArgs = new SbxArray;
4092cdf0e10cSrcweir SbxVariableRef xVar = new SbxVariable;
4093cdf0e10cSrcweir xVar->PutString( pFlyFmt->GetName() );
4094cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
4095cdf0e10cSrcweir
4096cdf0e10cSrcweir if( SW_EVENT_FRM_RESIZE == nEvent )
4097cdf0e10cSrcweir {
4098cdf0e10cSrcweir xVar = new SbxVariable;
4099cdf0e10cSrcweir xVar->PutUShort( static_cast< sal_uInt16 >(eOldSdrMoveHdl) );
4100cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
4101cdf0e10cSrcweir }
4102cdf0e10cSrcweir
4103cdf0e10cSrcweir xVar = new SbxVariable;
4104cdf0e10cSrcweir xVar->PutLong( aDocPt.X() - aSttPt.X() );
4105cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
4106cdf0e10cSrcweir xVar = new SbxVariable;
4107cdf0e10cSrcweir xVar->PutLong( aDocPt.Y() - aSttPt.Y() );
4108cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
4109cdf0e10cSrcweir
4110cdf0e10cSrcweir xVar = new SbxVariable;
4111cdf0e10cSrcweir xVar->PutUShort( 1 );
4112cdf0e10cSrcweir xArgs->Put( &xVar, ++nPos );
4113cdf0e10cSrcweir
4114cdf0e10cSrcweir ReleaseMouse();
4115cdf0e10cSrcweir
4116cdf0e10cSrcweir rSh.ExecMacro( *pMacro, 0, &xArgs );
4117cdf0e10cSrcweir
4118cdf0e10cSrcweir CaptureMouse();
4119cdf0e10cSrcweir }
4120cdf0e10cSrcweir }
4121cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt,sal_False );
4122cdf0e10cSrcweir }
4123cdf0e10cSrcweir bFrmDrag = sal_False;
4124cdf0e10cSrcweir bCallBase = sal_False;
4125cdf0e10cSrcweir break;
4126cdf0e10cSrcweir }
4127cdf0e10cSrcweir bPopMode = sal_True;
4128cdf0e10cSrcweir // no break
4129cdf0e10cSrcweir case MOUSE_LEFT + KEY_SHIFT:
4130cdf0e10cSrcweir if (rSh.IsSelFrmMode())
4131cdf0e10cSrcweir {
4132cdf0e10cSrcweir
4133cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
4134cdf0e10cSrcweir bFrmDrag = sal_False;
4135cdf0e10cSrcweir bCallBase = sal_False;
4136cdf0e10cSrcweir break;
4137cdf0e10cSrcweir }
4138cdf0e10cSrcweir
4139cdf0e10cSrcweir if( bHoldSelection )
4140cdf0e10cSrcweir {
4141cdf0e10cSrcweir //JP 27.04.99: Bug 65389 - das EndDrag sollte auf jedenfall
4142cdf0e10cSrcweir // gerufen werden.
4143cdf0e10cSrcweir bHoldSelection = sal_False;
4144cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
4145cdf0e10cSrcweir }
4146cdf0e10cSrcweir else
4147cdf0e10cSrcweir {
4148cdf0e10cSrcweir if ( !rSh.IsInSelect() && rSh.ChgCurrPam( aDocPt ) )
4149cdf0e10cSrcweir {
4150cdf0e10cSrcweir const sal_Bool bTmpNoInterrupt = bNoInterrupt;
4151cdf0e10cSrcweir bNoInterrupt = sal_False;
4152cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die
4153cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!!
4154cdf0e10cSrcweir MV_KONTEXT( &rSh );
4155cdf0e10cSrcweir const Point aDocPos( PixelToLogic( aStartPos ) );
4156cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
4157cdf0e10cSrcweir }
4158cdf0e10cSrcweir bNoInterrupt = bTmpNoInterrupt;
4159cdf0e10cSrcweir
4160cdf0e10cSrcweir }
4161cdf0e10cSrcweir else
4162cdf0e10cSrcweir {
4163cdf0e10cSrcweir sal_Bool bInSel = rSh.IsInSelect();
4164cdf0e10cSrcweir (rSh.*rSh.fnEndDrag)( &aDocPt, sal_False );
4165cdf0e10cSrcweir
4166cdf0e10cSrcweir // Internetfield? --> Link-Callen (DocLaden!!)
4167cdf0e10cSrcweir //JP 18.10.96: Bug 32437 -
4168cdf0e10cSrcweir // if( !rSh.HasSelection() )
4169cdf0e10cSrcweir if( !bInSel )
4170cdf0e10cSrcweir {
4171cdf0e10cSrcweir sal_uInt16 nFilter = URLLOAD_NOFILTER;
4172cdf0e10cSrcweir if( KEY_MOD1 == rMEvt.GetModifier() )
4173cdf0e10cSrcweir nFilter |= URLLOAD_NEWVIEW;
4174cdf0e10cSrcweir
4175cdf0e10cSrcweir sal_Bool bExecHyperlinks = rView.GetDocShell()->IsReadOnly();
4176cdf0e10cSrcweir if ( !bExecHyperlinks )
4177cdf0e10cSrcweir {
4178cdf0e10cSrcweir SvtSecurityOptions aSecOpts;
4179cdf0e10cSrcweir const sal_Bool bSecureOption = aSecOpts.IsOptionSet( SvtSecurityOptions::E_CTRLCLICK_HYPERLINK );
4180cdf0e10cSrcweir if ( ( bSecureOption && rMEvt.GetModifier() == KEY_MOD1 ) ||
4181cdf0e10cSrcweir ( !bSecureOption && rMEvt.GetModifier() != KEY_MOD1 ) )
4182cdf0e10cSrcweir bExecHyperlinks = sal_True;
4183cdf0e10cSrcweir }
4184cdf0e10cSrcweir
4185cdf0e10cSrcweir const sal_Bool bExecSmarttags = rMEvt.GetModifier() == KEY_MOD1;
4186cdf0e10cSrcweir
4187cdf0e10cSrcweir if(pApplyTempl)
4188cdf0e10cSrcweir bExecHyperlinks = sal_False;
4189cdf0e10cSrcweir
4190cdf0e10cSrcweir SwContentAtPos aCntntAtPos( SwContentAtPos::SW_CLICKFIELD |
4191cdf0e10cSrcweir SwContentAtPos::SW_INETATTR |
4192cdf0e10cSrcweir SwContentAtPos::SW_SMARTTAG | SwContentAtPos::SW_FORMCTRL);
4193cdf0e10cSrcweir
4194cdf0e10cSrcweir if( rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) )
4195cdf0e10cSrcweir {
4196cdf0e10cSrcweir sal_Bool bViewLocked = rSh.IsViewLocked();
4197cdf0e10cSrcweir if( !bViewLocked && !rSh.IsReadOnlyAvailable() &&
4198cdf0e10cSrcweir aCntntAtPos.IsInProtectSect() )
4199cdf0e10cSrcweir rSh.LockView( sal_True );
4200cdf0e10cSrcweir
4201cdf0e10cSrcweir ReleaseMouse();
4202cdf0e10cSrcweir
4203cdf0e10cSrcweir if( SwContentAtPos::SW_FIELD == aCntntAtPos.eCntntAtPos )
4204cdf0e10cSrcweir {
420569a74367SOliver-Rainer Wittmann if ( aCntntAtPos.pFndTxtAttr != NULL
420669a74367SOliver-Rainer Wittmann && aCntntAtPos.pFndTxtAttr->Which() == RES_TXTATR_INPUTFIELD )
420769a74367SOliver-Rainer Wittmann {
420869a74367SOliver-Rainer Wittmann // select content of Input Field, but exclude CH_TXT_ATR_INPUTFIELDSTART
420969a74367SOliver-Rainer Wittmann // and CH_TXT_ATR_INPUTFIELDEND
421069a74367SOliver-Rainer Wittmann rSh.SttSelect();
421169a74367SOliver-Rainer Wittmann rSh.SelectTxt( *(aCntntAtPos.pFndTxtAttr->GetStart()) + 1,
421269a74367SOliver-Rainer Wittmann *(aCntntAtPos.pFndTxtAttr->End()) - 1 );
421369a74367SOliver-Rainer Wittmann }
421469a74367SOliver-Rainer Wittmann else
421569a74367SOliver-Rainer Wittmann {
421669a74367SOliver-Rainer Wittmann rSh.ClickToField( *aCntntAtPos.aFnd.pFld );
421769a74367SOliver-Rainer Wittmann }
4218cdf0e10cSrcweir }
4219cdf0e10cSrcweir else if ( SwContentAtPos::SW_SMARTTAG == aCntntAtPos.eCntntAtPos )
4220cdf0e10cSrcweir {
4221cdf0e10cSrcweir // execute smarttag menu
4222cdf0e10cSrcweir if ( bExecSmarttags && SwSmartTagMgr::Get().IsSmartTagsEnabled() )
4223cdf0e10cSrcweir rView.ExecSmartTagPopup( aDocPt );
4224cdf0e10cSrcweir }
4225cdf0e10cSrcweir else if ( SwContentAtPos::SW_FORMCTRL == aCntntAtPos.eCntntAtPos )
4226cdf0e10cSrcweir {
4227cdf0e10cSrcweir ASSERT( aCntntAtPos.aFnd.pFldmark != NULL, "where is my field ptr???");
4228cdf0e10cSrcweir if ( aCntntAtPos.aFnd.pFldmark != NULL)
4229cdf0e10cSrcweir {
4230cdf0e10cSrcweir IFieldmark *fieldBM = const_cast< IFieldmark* > ( aCntntAtPos.aFnd.pFldmark );
4231cdf0e10cSrcweir if (fieldBM->GetFieldname( ).equalsAscii( ODF_FORMCHECKBOX ) )
4232cdf0e10cSrcweir {
4233cdf0e10cSrcweir ICheckboxFieldmark* pCheckboxFm = dynamic_cast<ICheckboxFieldmark*>(fieldBM);
4234cdf0e10cSrcweir pCheckboxFm->SetChecked(!pCheckboxFm->IsChecked());
4235cdf0e10cSrcweir pCheckboxFm->Invalidate();
4236cdf0e10cSrcweir rSh.InvalidateWindows( rView.GetVisArea() );
4237cdf0e10cSrcweir } else if (fieldBM->GetFieldname().equalsAscii( ODF_FORMDROPDOWN) ) {
4238cdf0e10cSrcweir rView.ExecFieldPopup( aDocPt, fieldBM );
4239cdf0e10cSrcweir fieldBM->Invalidate();
4240cdf0e10cSrcweir rSh.InvalidateWindows( rView.GetVisArea() );
4241cdf0e10cSrcweir } else {
4242cdf0e10cSrcweir // unknown type..
4243cdf0e10cSrcweir }
4244cdf0e10cSrcweir }
4245cdf0e10cSrcweir }
4246cdf0e10cSrcweir else // if ( SwContentAtPos::SW_INETATTR == aCntntAtPos.eCntntAtPos )
4247cdf0e10cSrcweir {
4248cdf0e10cSrcweir if ( bExecHyperlinks )
4249cdf0e10cSrcweir rSh.ClickToINetAttr( *(SwFmtINetFmt*)aCntntAtPos.aFnd.pAttr, nFilter );
4250cdf0e10cSrcweir }
4251cdf0e10cSrcweir
4252cdf0e10cSrcweir rSh.LockView( bViewLocked );
4253cdf0e10cSrcweir bCallShadowCrsr = sal_False;
4254cdf0e10cSrcweir }
4255cdf0e10cSrcweir else
4256cdf0e10cSrcweir {
4257cdf0e10cSrcweir aCntntAtPos = SwContentAtPos( SwContentAtPos::SW_FTN );
4258cdf0e10cSrcweir if( !rSh.GetContentAtPos( aDocPt, aCntntAtPos, sal_True ) && bExecHyperlinks )
4259cdf0e10cSrcweir {
4260cdf0e10cSrcweir SdrViewEvent aVEvt;
4261cdf0e10cSrcweir
4262cdf0e10cSrcweir if (pSdrView)
4263cdf0e10cSrcweir pSdrView->PickAnything(rMEvt, SDRMOUSEBUTTONDOWN, aVEvt);
4264cdf0e10cSrcweir
4265cdf0e10cSrcweir if (pSdrView && aVEvt.eEvent == SDREVENT_EXECUTEURL)
4266cdf0e10cSrcweir {
4267cdf0e10cSrcweir // URL-Feld getroffen
4268cdf0e10cSrcweir const SvxURLField *pField = aVEvt.pURLField;
4269cdf0e10cSrcweir if (pField)
4270cdf0e10cSrcweir {
4271cdf0e10cSrcweir String sURL(pField->GetURL());
4272cdf0e10cSrcweir String sTarget(pField->GetTargetFrame());
4273cdf0e10cSrcweir ::LoadURL( sURL, &rSh, nFilter, &sTarget);
4274cdf0e10cSrcweir }
4275cdf0e10cSrcweir bCallShadowCrsr = sal_False;
4276cdf0e10cSrcweir }
4277cdf0e10cSrcweir else
4278cdf0e10cSrcweir {
4279cdf0e10cSrcweir // Grafik getroffen
4280cdf0e10cSrcweir ReleaseMouse();
4281cdf0e10cSrcweir if( rSh.ClickToINetGrf( aDocPt, nFilter ))
4282cdf0e10cSrcweir bCallShadowCrsr = sal_False;
4283cdf0e10cSrcweir }
4284cdf0e10cSrcweir }
4285cdf0e10cSrcweir }
4286cdf0e10cSrcweir
4287cdf0e10cSrcweir if( bCallShadowCrsr &&
4288cdf0e10cSrcweir rSh.GetViewOptions()->IsShadowCursor() &&
4289cdf0e10cSrcweir MOUSE_LEFT == (rMEvt.GetModifier() + rMEvt.GetButtons()) &&
4290cdf0e10cSrcweir !rSh.HasSelection() &&
4291cdf0e10cSrcweir !GetConnectMetaFile() &&
4292cdf0e10cSrcweir rSh.VisArea().IsInside( aDocPt ))
4293cdf0e10cSrcweir {
4294cdf0e10cSrcweir SwUndoId nLastUndoId(UNDO_EMPTY);
4295cdf0e10cSrcweir if (rSh.GetLastUndoInfo(0, & nLastUndoId))
4296cdf0e10cSrcweir {
4297cdf0e10cSrcweir if (UNDO_INS_FROM_SHADOWCRSR == nLastUndoId)
4298cdf0e10cSrcweir {
4299cdf0e10cSrcweir rSh.Undo();
4300cdf0e10cSrcweir }
4301cdf0e10cSrcweir }
4302cdf0e10cSrcweir SwFillMode eMode = (SwFillMode)rSh.GetViewOptions()->GetShdwCrsrFillMode();
4303cdf0e10cSrcweir rSh.SetShadowCrsrPos( aDocPt, eMode );
4304cdf0e10cSrcweir }
4305cdf0e10cSrcweir }
4306cdf0e10cSrcweir }
4307cdf0e10cSrcweir bCallBase = sal_False;
4308cdf0e10cSrcweir
4309cdf0e10cSrcweir }
4310cdf0e10cSrcweir
4311cdf0e10cSrcweir // gfs. im Down gepushten Mode wieder zuruecksetzen
4312cdf0e10cSrcweir if ( bPopMode && bModePushed )
4313cdf0e10cSrcweir {
4314cdf0e10cSrcweir rSh.PopMode();
4315cdf0e10cSrcweir bModePushed = sal_False;
4316cdf0e10cSrcweir bCallBase = sal_False;
4317cdf0e10cSrcweir }
4318cdf0e10cSrcweir break;
4319cdf0e10cSrcweir
4320cdf0e10cSrcweir default:
4321cdf0e10cSrcweir ReleaseMouse();
4322cdf0e10cSrcweir return;
4323cdf0e10cSrcweir }
4324cdf0e10cSrcweir
4325cdf0e10cSrcweir if( pApplyTempl )
4326cdf0e10cSrcweir {
4327cdf0e10cSrcweir int eSelection = rSh.GetSelectionType();
4328cdf0e10cSrcweir SwFormatClipboard* pFormatClipboard = pApplyTempl->pFormatClipboard;
4329cdf0e10cSrcweir if( pFormatClipboard )//apply format paintbrush
4330cdf0e10cSrcweir {
4331cdf0e10cSrcweir //get some parameters
4332cdf0e10cSrcweir SwWrtShell& rWrtShell = rView.GetWrtShell();
4333cdf0e10cSrcweir SfxStyleSheetBasePool* pPool=0;
4334cdf0e10cSrcweir bool bNoCharacterFormats = false;
4335cdf0e10cSrcweir bool bNoParagraphFormats = false;
4336cdf0e10cSrcweir {
4337cdf0e10cSrcweir SwDocShell* pDocSh = rView.GetDocShell();
4338cdf0e10cSrcweir if(pDocSh)
4339cdf0e10cSrcweir pPool = pDocSh->GetStyleSheetPool();
4340cdf0e10cSrcweir if( (rMEvt.GetModifier()&KEY_MOD1) && (rMEvt.GetModifier()&KEY_SHIFT) )
4341cdf0e10cSrcweir bNoCharacterFormats = true;
4342cdf0e10cSrcweir else if( rMEvt.GetModifier() & KEY_MOD1 )
4343cdf0e10cSrcweir bNoParagraphFormats = true;
4344cdf0e10cSrcweir }
4345cdf0e10cSrcweir //execute paste
4346cdf0e10cSrcweir pFormatClipboard->Paste( rWrtShell, pPool, bNoCharacterFormats, bNoParagraphFormats );
4347cdf0e10cSrcweir
4348cdf0e10cSrcweir //if the clipboard is empty after paste remove the ApplyTemplate
4349cdf0e10cSrcweir if(!pFormatClipboard->HasContent())
4350cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate());
4351cdf0e10cSrcweir }
4352cdf0e10cSrcweir else if( pApplyTempl->nColor )
4353cdf0e10cSrcweir {
4354cdf0e10cSrcweir sal_uInt16 nId = 0;
4355cdf0e10cSrcweir switch( pApplyTempl->nColor )
4356cdf0e10cSrcweir {
4357cdf0e10cSrcweir case SID_ATTR_CHAR_COLOR_EXT:
4358cdf0e10cSrcweir nId = RES_CHRATR_COLOR;
4359cdf0e10cSrcweir break;
4360cdf0e10cSrcweir case SID_ATTR_CHAR_COLOR_BACKGROUND_EXT:
4361cdf0e10cSrcweir nId = RES_CHRATR_BACKGROUND;
4362cdf0e10cSrcweir break;
4363cdf0e10cSrcweir }
4364cdf0e10cSrcweir if( nId && (nsSelectionType::SEL_TXT|nsSelectionType::SEL_TBL) & eSelection)
4365cdf0e10cSrcweir {
4366cdf0e10cSrcweir if( rSh.IsSelection() && !rSh.HasReadonlySel() )
4367cdf0e10cSrcweir {
4368cdf0e10cSrcweir if(nId == RES_CHRATR_BACKGROUND)
4369cdf0e10cSrcweir {
4370cdf0e10cSrcweir Color aColor( COL_TRANSPARENT );
4371cdf0e10cSrcweir if( !SwEditWin::bTransparentBackColor )
4372cdf0e10cSrcweir aColor = SwEditWin::aTextBackColor;
437369a74367SOliver-Rainer Wittmann rSh.SetAttrItem( SvxBrushItem( aColor, nId ) );
4374cdf0e10cSrcweir }
4375cdf0e10cSrcweir else
437669a74367SOliver-Rainer Wittmann rSh.SetAttrItem( SvxColorItem(SwEditWin::aTextColor, nId) );
4377cdf0e10cSrcweir rSh.UnSetVisCrsr();
4378cdf0e10cSrcweir rSh.EnterStdMode();
4379cdf0e10cSrcweir rSh.SetVisCrsr(aDocPt);
4380cdf0e10cSrcweir
4381cdf0e10cSrcweir pApplyTempl->bUndo = sal_True;
4382cdf0e10cSrcweir bCallBase = sal_False;
4383cdf0e10cSrcweir aTemplateTimer.Stop();
4384cdf0e10cSrcweir }
4385cdf0e10cSrcweir else if(rMEvt.GetClicks() == 1)
4386cdf0e10cSrcweir {
4387cdf0e10cSrcweir // keine Selektion -> also Giesskanne abschalten
4388cdf0e10cSrcweir aTemplateTimer.Start();
4389cdf0e10cSrcweir }
4390cdf0e10cSrcweir }
4391cdf0e10cSrcweir }
4392cdf0e10cSrcweir else
4393cdf0e10cSrcweir {
4394cdf0e10cSrcweir String aStyleName;
4395cdf0e10cSrcweir switch ( pApplyTempl->eType )
4396cdf0e10cSrcweir {
4397cdf0e10cSrcweir case SFX_STYLE_FAMILY_PARA:
4398cdf0e10cSrcweir if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL )
4399cdf0e10cSrcweir & eSelection ) && !rSh.HasReadonlySel() )
4400cdf0e10cSrcweir {
4401cdf0e10cSrcweir rSh.SetTxtFmtColl( pApplyTempl->aColl.pTxtColl );
4402cdf0e10cSrcweir pApplyTempl->bUndo = sal_True;
4403cdf0e10cSrcweir bCallBase = sal_False;
4404cdf0e10cSrcweir if ( pApplyTempl->aColl.pTxtColl )
4405cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pTxtColl->GetName();
4406cdf0e10cSrcweir }
4407cdf0e10cSrcweir break;
4408cdf0e10cSrcweir case SFX_STYLE_FAMILY_CHAR:
4409cdf0e10cSrcweir if( (( nsSelectionType::SEL_TXT | nsSelectionType::SEL_TBL )
4410cdf0e10cSrcweir & eSelection ) && !rSh.HasReadonlySel() )
4411cdf0e10cSrcweir {
441269a74367SOliver-Rainer Wittmann rSh.SetAttrItem( SwFmtCharFmt(pApplyTempl->aColl.pCharFmt) );
4413cdf0e10cSrcweir rSh.UnSetVisCrsr();
4414cdf0e10cSrcweir rSh.EnterStdMode();
4415cdf0e10cSrcweir rSh.SetVisCrsr(aDocPt);
4416cdf0e10cSrcweir pApplyTempl->bUndo = sal_True;
4417cdf0e10cSrcweir bCallBase = sal_False;
4418cdf0e10cSrcweir if ( pApplyTempl->aColl.pCharFmt )
4419cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pCharFmt->GetName();
4420cdf0e10cSrcweir }
4421cdf0e10cSrcweir break;
4422cdf0e10cSrcweir case SFX_STYLE_FAMILY_FRAME :
4423cdf0e10cSrcweir {
4424cdf0e10cSrcweir const SwFrmFmt* pFmt = rSh.GetFmtFromObj( aDocPt );
4425cdf0e10cSrcweir if(PTR_CAST(SwFlyFrmFmt, pFmt))
4426cdf0e10cSrcweir {
4427cdf0e10cSrcweir rSh.SetFrmFmt( pApplyTempl->aColl.pFrmFmt, sal_False, &aDocPt );
4428cdf0e10cSrcweir pApplyTempl->bUndo = sal_True;
4429cdf0e10cSrcweir bCallBase = sal_False;
4430cdf0e10cSrcweir if( pApplyTempl->aColl.pFrmFmt )
4431cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pFrmFmt->GetName();
4432cdf0e10cSrcweir }
4433cdf0e10cSrcweir break;
4434cdf0e10cSrcweir }
4435cdf0e10cSrcweir case SFX_STYLE_FAMILY_PAGE:
4436cdf0e10cSrcweir // Kein Undo bei Seitenvorlagen
4437cdf0e10cSrcweir rSh.ChgCurPageDesc( *pApplyTempl->aColl.pPageDesc );
4438cdf0e10cSrcweir if ( pApplyTempl->aColl.pPageDesc )
4439cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pPageDesc->GetName();
4440cdf0e10cSrcweir bCallBase = sal_False;
4441cdf0e10cSrcweir break;
4442cdf0e10cSrcweir case SFX_STYLE_FAMILY_PSEUDO:
4443cdf0e10cSrcweir if( !rSh.HasReadonlySel() )
4444cdf0e10cSrcweir {
4445cdf0e10cSrcweir rSh.SetCurNumRule( *pApplyTempl->aColl.pNumRule,
4446cdf0e10cSrcweir false,
4447cdf0e10cSrcweir pApplyTempl->aColl.pNumRule->GetDefaultListId() );
4448cdf0e10cSrcweir bCallBase = sal_False;
4449cdf0e10cSrcweir pApplyTempl->bUndo = sal_True;
4450cdf0e10cSrcweir if( pApplyTempl->aColl.pNumRule )
4451cdf0e10cSrcweir aStyleName = pApplyTempl->aColl.pNumRule->GetName();
4452cdf0e10cSrcweir }
4453cdf0e10cSrcweir break;
4454cdf0e10cSrcweir }
4455cdf0e10cSrcweir
4456cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder =
4457cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder();
4458cdf0e10cSrcweir if ( aStyleName.Len() && xRecorder.is() )
4459cdf0e10cSrcweir {
4460cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
4461cdf0e10cSrcweir if ( pSfxShell )
4462cdf0e10cSrcweir {
4463cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), SID_STYLE_APPLY );
4464cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( SID_STYLE_APPLY, aStyleName ) );
4465cdf0e10cSrcweir aReq.AppendItem( SfxUInt16Item( SID_STYLE_FAMILY, (sal_uInt16) pApplyTempl->eType ) );
4466cdf0e10cSrcweir aReq.Done();
4467cdf0e10cSrcweir }
4468cdf0e10cSrcweir }
4469cdf0e10cSrcweir }
4470cdf0e10cSrcweir
4471cdf0e10cSrcweir }
4472cdf0e10cSrcweir ReleaseMouse();
4473cdf0e10cSrcweir // Hier kommen nur verarbeitete MouseEvents an; nur bei diesen duerfen
4474cdf0e10cSrcweir // die Modi zurueckgesetzt werden.
4475cdf0e10cSrcweir bMBPressed = sal_False;
4476cdf0e10cSrcweir
4477cdf0e10cSrcweir //sicherheitshalber aufrufen, da jetzt das Selektieren bestimmt zu Ende ist.
4478cdf0e10cSrcweir //Andernfalls koennte der Timeout des Timers Kummer machen.
4479cdf0e10cSrcweir EnterArea();
4480cdf0e10cSrcweir bNoInterrupt = sal_False;
4481cdf0e10cSrcweir
4482cdf0e10cSrcweir if (bCallBase)
4483cdf0e10cSrcweir Window::MouseButtonUp(rMEvt);
4484cdf0e10cSrcweir }
4485cdf0e10cSrcweir
4486cdf0e10cSrcweir
4487cdf0e10cSrcweir /*--------------------------------------------------------------------
4488cdf0e10cSrcweir Beschreibung: Vorlage anwenden
4489cdf0e10cSrcweir --------------------------------------------------------------------*/
4490cdf0e10cSrcweir
4491cdf0e10cSrcweir
SetApplyTemplate(const SwApplyTemplate & rTempl)4492cdf0e10cSrcweir void SwEditWin::SetApplyTemplate(const SwApplyTemplate &rTempl)
4493cdf0e10cSrcweir {
4494cdf0e10cSrcweir static sal_Bool bIdle = sal_False;
4495cdf0e10cSrcweir DELETEZ(pApplyTempl);
4496cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
4497cdf0e10cSrcweir
4498cdf0e10cSrcweir if(rTempl.pFormatClipboard)
4499cdf0e10cSrcweir {
4500cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl );
4501cdf0e10cSrcweir SetPointer( POINTER_FILL );//@todo #i20119# maybe better a new brush pointer here in future
4502cdf0e10cSrcweir rSh.NoEdit( sal_False );
4503cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle();
4504cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
4505cdf0e10cSrcweir }
4506cdf0e10cSrcweir else if(rTempl.nColor)
4507cdf0e10cSrcweir {
4508cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl );
4509cdf0e10cSrcweir SetPointer( POINTER_FILL );
4510cdf0e10cSrcweir rSh.NoEdit( sal_False );
4511cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle();
4512cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
4513cdf0e10cSrcweir }
4514cdf0e10cSrcweir else if( rTempl.eType )
4515cdf0e10cSrcweir {
4516cdf0e10cSrcweir pApplyTempl = new SwApplyTemplate( rTempl );
4517cdf0e10cSrcweir SetPointer( POINTER_FILL );
4518cdf0e10cSrcweir rSh.NoEdit( sal_False );
4519cdf0e10cSrcweir bIdle = rSh.GetViewOptions()->IsIdle();
4520cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( sal_False );
4521cdf0e10cSrcweir }
4522cdf0e10cSrcweir else
4523cdf0e10cSrcweir {
4524cdf0e10cSrcweir SetPointer( POINTER_TEXT );
4525cdf0e10cSrcweir rSh.UnSetVisCrsr();
4526cdf0e10cSrcweir
4527cdf0e10cSrcweir ((SwViewOption *)rSh.GetViewOptions())->SetIdle( bIdle );
4528cdf0e10cSrcweir if ( !rSh.IsSelFrmMode() )
4529cdf0e10cSrcweir rSh.Edit();
4530cdf0e10cSrcweir }
4531cdf0e10cSrcweir
4532cdf0e10cSrcweir static sal_uInt16 __READONLY_DATA aInva[] =
4533cdf0e10cSrcweir {
4534cdf0e10cSrcweir SID_STYLE_WATERCAN,
4535cdf0e10cSrcweir SID_ATTR_CHAR_COLOR_EXT,
4536cdf0e10cSrcweir SID_ATTR_CHAR_COLOR_BACKGROUND_EXT,
4537cdf0e10cSrcweir 0
4538cdf0e10cSrcweir };
4539cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(aInva);
4540cdf0e10cSrcweir }
4541cdf0e10cSrcweir
4542cdf0e10cSrcweir /*--------------------------------------------------------------------
4543cdf0e10cSrcweir Beschreibung: ctor
4544cdf0e10cSrcweir --------------------------------------------------------------------*/
4545cdf0e10cSrcweir
4546cdf0e10cSrcweir
SwEditWin(Window * pParent,SwView & rMyView)4547cdf0e10cSrcweir SwEditWin::SwEditWin(Window *pParent, SwView &rMyView):
4548cdf0e10cSrcweir Window(pParent, WinBits(WB_CLIPCHILDREN | WB_DIALOGCONTROL)),
4549cdf0e10cSrcweir DropTargetHelper( this ),
4550cdf0e10cSrcweir DragSourceHelper( this ),
4551cdf0e10cSrcweir
4552cdf0e10cSrcweir eBufferLanguage(LANGUAGE_DONTKNOW),
4553cdf0e10cSrcweir pApplyTempl(0),
4554cdf0e10cSrcweir pAnchorMarker( 0 ),
4555cdf0e10cSrcweir pUserMarker( 0 ),
4556cdf0e10cSrcweir pUserMarkerObj( 0 ),
4557cdf0e10cSrcweir pShadCrsr( 0 ),
4558cdf0e10cSrcweir pRowColumnSelectionStart( 0 ),
4559cdf0e10cSrcweir
4560cdf0e10cSrcweir rView( rMyView ),
4561cdf0e10cSrcweir
4562cdf0e10cSrcweir aActHitType(SDRHIT_NONE),
4563cdf0e10cSrcweir m_nDropFormat( 0 ),
4564cdf0e10cSrcweir m_nDropAction( 0 ),
4565cdf0e10cSrcweir m_nDropDestination( 0 ),
4566cdf0e10cSrcweir
4567cdf0e10cSrcweir nInsFrmColCount( 1 ),
4568cdf0e10cSrcweir eDrawMode(OBJ_NONE),
4569cdf0e10cSrcweir
4570cdf0e10cSrcweir bLockInput(sal_False),
4571cdf0e10cSrcweir bObjectSelect( sal_False ),
45725b40a975SOliver-Rainer Wittmann nKS_NUMDOWN_Count(0),
45735b40a975SOliver-Rainer Wittmann nKS_NUMINDENTINC_Count(0)
4574cdf0e10cSrcweir {
4575cdf0e10cSrcweir SetHelpId(HID_EDIT_WIN);
4576cdf0e10cSrcweir EnableChildTransparentMode();
4577cdf0e10cSrcweir SetDialogControlFlags( WINDOW_DLGCTRL_RETURN | WINDOW_DLGCTRL_WANTFOCUS );
4578cdf0e10cSrcweir
4579cdf0e10cSrcweir bLinkRemoved = bMBPressed = bInsDraw = bInsFrm =
4580cdf0e10cSrcweir bIsInDrag = bOldIdle = bOldIdleSet = bChainMode = bWasShdwCrsr = sal_False;
4581cdf0e10cSrcweir //#i42732# initially use the input language
4582cdf0e10cSrcweir bUseInputLanguage = sal_True;
4583cdf0e10cSrcweir
4584cdf0e10cSrcweir SetMapMode(MapMode(MAP_TWIP));
4585cdf0e10cSrcweir
4586cdf0e10cSrcweir SetPointer( POINTER_TEXT );
4587cdf0e10cSrcweir aTimer.SetTimeoutHdl(LINK(this, SwEditWin, TimerHandler));
4588cdf0e10cSrcweir
4589cdf0e10cSrcweir bTblInsDelMode = sal_False;
4590cdf0e10cSrcweir aKeyInputTimer.SetTimeout( 3000 );
4591cdf0e10cSrcweir aKeyInputTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputTimerHandler));
4592cdf0e10cSrcweir
4593cdf0e10cSrcweir aKeyInputFlushTimer.SetTimeout( 200 );
4594cdf0e10cSrcweir aKeyInputFlushTimer.SetTimeoutHdl(LINK(this, SwEditWin, KeyInputFlushHandler));
4595cdf0e10cSrcweir
4596cdf0e10cSrcweir // TemplatePointer fuer Farben soll nach Einfachclick
4597cdf0e10cSrcweir // ohne Selektion zurueckgesetzt werden
4598cdf0e10cSrcweir aTemplateTimer.SetTimeout(400);
4599cdf0e10cSrcweir aTemplateTimer.SetTimeoutHdl(LINK(this, SwEditWin, TemplateTimerHdl));
4600cdf0e10cSrcweir
4601cdf0e10cSrcweir //JP 16.12.98: temporaere Loesung!!! Sollte bei jeder Cursorbewegung
4602cdf0e10cSrcweir // den Font von der akt. einfuege Position setzen!
4603cdf0e10cSrcweir if( !rMyView.GetDocShell()->IsReadOnly() )
4604cdf0e10cSrcweir {
4605cdf0e10cSrcweir Font aFont;
4606cdf0e10cSrcweir SetInputContext( InputContext( aFont, INPUTCONTEXT_TEXT |
4607cdf0e10cSrcweir INPUTCONTEXT_EXTTEXTINPUT ) );
4608cdf0e10cSrcweir }
4609cdf0e10cSrcweir }
4610cdf0e10cSrcweir
4611cdf0e10cSrcweir
4612cdf0e10cSrcweir
~SwEditWin()4613cdf0e10cSrcweir SwEditWin::~SwEditWin()
4614cdf0e10cSrcweir {
4615cdf0e10cSrcweir aKeyInputTimer.Stop();
4616cdf0e10cSrcweir delete pShadCrsr;
4617cdf0e10cSrcweir delete pRowColumnSelectionStart;
4618cdf0e10cSrcweir if( pQuickHlpData->bClear && rView.GetWrtShellPtr() )
4619cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() );
4620cdf0e10cSrcweir bExecuteDrag = sal_False;
4621cdf0e10cSrcweir delete pApplyTempl;
4622cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
4623cdf0e10cSrcweir
4624cdf0e10cSrcweir if(pUserMarker)
4625cdf0e10cSrcweir {
4626cdf0e10cSrcweir delete pUserMarker;
4627cdf0e10cSrcweir }
4628cdf0e10cSrcweir
4629cdf0e10cSrcweir delete pAnchorMarker;
4630cdf0e10cSrcweir }
4631cdf0e10cSrcweir
4632cdf0e10cSrcweir
4633cdf0e10cSrcweir /******************************************************************************
4634cdf0e10cSrcweir * Beschreibung: DrawTextEditMode einschalten
4635cdf0e10cSrcweir ******************************************************************************/
4636cdf0e10cSrcweir
4637cdf0e10cSrcweir
EnterDrawTextMode(const Point & aDocPos)4638cdf0e10cSrcweir void SwEditWin::EnterDrawTextMode( const Point& aDocPos )
4639cdf0e10cSrcweir {
4640cdf0e10cSrcweir if ( rView.EnterDrawTextMode(aDocPos) == sal_True )
4641cdf0e10cSrcweir {
4642cdf0e10cSrcweir if (rView.GetDrawFuncPtr())
4643cdf0e10cSrcweir {
4644cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
4645cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
4646cdf0e10cSrcweir rView.LeaveDrawCreate();
4647cdf0e10cSrcweir }
4648cdf0e10cSrcweir rView.NoRotate();
4649cdf0e10cSrcweir rView.AttrChangedNotify( &rView.GetWrtShell() );
4650cdf0e10cSrcweir }
4651cdf0e10cSrcweir }
4652cdf0e10cSrcweir
4653cdf0e10cSrcweir /******************************************************************************
4654cdf0e10cSrcweir * Beschreibung: DrawMode einschalten
4655cdf0e10cSrcweir ******************************************************************************/
4656cdf0e10cSrcweir
4657cdf0e10cSrcweir
4658cdf0e10cSrcweir
EnterDrawMode(const MouseEvent & rMEvt,const Point & aDocPos)4659cdf0e10cSrcweir sal_Bool SwEditWin::EnterDrawMode(const MouseEvent& rMEvt, const Point& aDocPos)
4660cdf0e10cSrcweir {
4661cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
4662cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
4663cdf0e10cSrcweir
4664cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() )
4665cdf0e10cSrcweir {
4666cdf0e10cSrcweir if (rSh.IsDrawCreate())
4667cdf0e10cSrcweir return sal_True;
4668cdf0e10cSrcweir
4669cdf0e10cSrcweir sal_Bool bRet = rView.GetDrawFuncPtr()->MouseButtonDown( rMEvt );
4670cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
4671cdf0e10cSrcweir return bRet;
4672cdf0e10cSrcweir }
4673cdf0e10cSrcweir
4674cdf0e10cSrcweir if ( pSdrView && pSdrView->IsTextEdit() )
4675cdf0e10cSrcweir {
4676cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
4677cdf0e10cSrcweir rSh.LockView( sal_True );
4678cdf0e10cSrcweir
4679cdf0e10cSrcweir rSh.EndTextEdit(); // Danebengeklickt, Ende mit Edit
4680cdf0e10cSrcweir rSh.SelectObj( aDocPos );
4681cdf0e10cSrcweir if ( !rSh.IsObjSelected() && !rSh.IsFrmSelected() )
4682cdf0e10cSrcweir rSh.LeaveSelFrmMode();
4683cdf0e10cSrcweir else
4684cdf0e10cSrcweir {
4685cdf0e10cSrcweir SwEditWin::nDDStartPosY = aDocPos.Y();
4686cdf0e10cSrcweir SwEditWin::nDDStartPosX = aDocPos.X();
4687cdf0e10cSrcweir bFrmDrag = sal_True;
4688cdf0e10cSrcweir }
4689cdf0e10cSrcweir if( bUnLockView )
4690cdf0e10cSrcweir rSh.LockView( sal_False );
4691cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
4692cdf0e10cSrcweir return sal_True;
4693cdf0e10cSrcweir }
4694cdf0e10cSrcweir return sal_False;
4695cdf0e10cSrcweir }
4696cdf0e10cSrcweir
4697cdf0e10cSrcweir /******************************************************************************
4698cdf0e10cSrcweir * Beschreibung:
4699cdf0e10cSrcweir ******************************************************************************/
4700cdf0e10cSrcweir
4701cdf0e10cSrcweir
4702cdf0e10cSrcweir
IsDrawSelMode()4703cdf0e10cSrcweir sal_Bool SwEditWin::IsDrawSelMode()
4704cdf0e10cSrcweir {
4705cdf0e10cSrcweir return IsObjectSelect();
4706cdf0e10cSrcweir }
4707cdf0e10cSrcweir
4708cdf0e10cSrcweir /******************************************************************************
4709cdf0e10cSrcweir * Beschreibung:
4710cdf0e10cSrcweir ******************************************************************************/
4711cdf0e10cSrcweir
4712cdf0e10cSrcweir
GetFocus()4713cdf0e10cSrcweir void SwEditWin::GetFocus()
4714cdf0e10cSrcweir {
4715cdf0e10cSrcweir if ( rView.GetPostItMgr()->HasActiveSidebarWin() )
4716cdf0e10cSrcweir {
4717cdf0e10cSrcweir rView.GetPostItMgr()->GrabFocusOnActiveSidebarWin();
4718cdf0e10cSrcweir }
4719cdf0e10cSrcweir else
4720cdf0e10cSrcweir {
4721cdf0e10cSrcweir rView.GotFocus();
4722cdf0e10cSrcweir Window::GetFocus();
4723cdf0e10cSrcweir rView.GetWrtShell().InvalidateAccessibleFocus();
4724cdf0e10cSrcweir }
4725cdf0e10cSrcweir }
4726cdf0e10cSrcweir
4727cdf0e10cSrcweir /******************************************************************************
4728cdf0e10cSrcweir * Beschreibung:
4729cdf0e10cSrcweir ******************************************************************************/
4730cdf0e10cSrcweir
4731cdf0e10cSrcweir
4732cdf0e10cSrcweir
LoseFocus()4733cdf0e10cSrcweir void SwEditWin::LoseFocus()
4734cdf0e10cSrcweir {
4735cdf0e10cSrcweir rView.GetWrtShell().InvalidateAccessibleFocus();
4736cdf0e10cSrcweir Window::LoseFocus();
4737cdf0e10cSrcweir if( pQuickHlpData->bClear )
4738cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() );
4739cdf0e10cSrcweir rView.LostFocus();
4740cdf0e10cSrcweir }
4741cdf0e10cSrcweir
4742cdf0e10cSrcweir /******************************************************************************
4743cdf0e10cSrcweir * Beschreibung:
4744cdf0e10cSrcweir ******************************************************************************/
4745cdf0e10cSrcweir
4746cdf0e10cSrcweir
4747cdf0e10cSrcweir
Command(const CommandEvent & rCEvt)4748cdf0e10cSrcweir void SwEditWin::Command( const CommandEvent& rCEvt )
4749cdf0e10cSrcweir {
4750cdf0e10cSrcweir SwWrtShell &rSh = rView.GetWrtShell();
4751cdf0e10cSrcweir
4752cdf0e10cSrcweir if ( !rView.GetViewFrame() )
4753cdf0e10cSrcweir {
4754cdf0e10cSrcweir //Wenn der ViewFrame in Kuerze stirbt kein Popup mehr!
4755cdf0e10cSrcweir Window::Command(rCEvt);
4756cdf0e10cSrcweir return;
4757cdf0e10cSrcweir }
4758cdf0e10cSrcweir
4759cdf0e10cSrcweir // The command event is send to the window after a possible context
4760cdf0e10cSrcweir // menu from an inplace client has been closed. Now we have the chance
4761cdf0e10cSrcweir // to deactivate the inplace client without any problem regarding parent
4762cdf0e10cSrcweir // windows and code on the stack.
4763cdf0e10cSrcweir // For more information, see #126086# and #128122#
4764cdf0e10cSrcweir SfxInPlaceClient* pIPClient = rSh.GetSfxViewShell()->GetIPClient();
4765cdf0e10cSrcweir sal_Bool bIsOleActive = ( pIPClient && pIPClient->IsObjectInPlaceActive() );
4766cdf0e10cSrcweir if ( bIsOleActive && ( rCEvt.GetCommand() == COMMAND_CONTEXTMENU ))
4767cdf0e10cSrcweir {
4768cdf0e10cSrcweir rSh.FinishOLEObj();
4769cdf0e10cSrcweir return;
4770cdf0e10cSrcweir }
4771cdf0e10cSrcweir
4772cdf0e10cSrcweir sal_Bool bCallBase = sal_True;
4773cdf0e10cSrcweir
4774cdf0e10cSrcweir switch ( rCEvt.GetCommand() )
4775cdf0e10cSrcweir {
4776cdf0e10cSrcweir case COMMAND_CONTEXTMENU:
4777cdf0e10cSrcweir {
4778cdf0e10cSrcweir const sal_uInt16 nId = SwInputChild::GetChildWindowId();
4779cdf0e10cSrcweir SwInputChild* pChildWin = (SwInputChild*)GetView().GetViewFrame()->
4780cdf0e10cSrcweir GetChildWindow( nId );
4781cdf0e10cSrcweir
4782cdf0e10cSrcweir if (rView.GetPostItMgr()->IsHit(rCEvt.GetMousePosPixel()))
4783cdf0e10cSrcweir return;
4784cdf0e10cSrcweir
4785cdf0e10cSrcweir if((!pChildWin || pChildWin->GetView() != &rView) &&
4786cdf0e10cSrcweir !rSh.IsDrawCreate() && !IsDrawAction())
4787cdf0e10cSrcweir {
4788cdf0e10cSrcweir SET_CURR_SHELL( &rSh );
4789cdf0e10cSrcweir if (!pApplyTempl)
4790cdf0e10cSrcweir {
4791cdf0e10cSrcweir if (bNoInterrupt == sal_True)
4792cdf0e10cSrcweir {
4793cdf0e10cSrcweir ReleaseMouse();
4794cdf0e10cSrcweir bNoInterrupt = sal_False;
4795cdf0e10cSrcweir bMBPressed = sal_False;
4796cdf0e10cSrcweir }
4797cdf0e10cSrcweir Point aDocPos( PixelToLogic( rCEvt.GetMousePosPixel() ) );
4798cdf0e10cSrcweir if ( !rCEvt.IsMouseEvent() )
4799cdf0e10cSrcweir aDocPos = rSh.GetCharRect().Center();
4800cdf0e10cSrcweir else
4801cdf0e10cSrcweir {
4802cdf0e10cSrcweir SelectMenuPosition(rSh, rCEvt.GetMousePosPixel());
4803cdf0e10cSrcweir rView.StopShellTimer();
4804cdf0e10cSrcweir
4805cdf0e10cSrcweir }
4806cdf0e10cSrcweir const Point aPixPos = LogicToPixel( aDocPos );
4807cdf0e10cSrcweir
4808cdf0e10cSrcweir if ( rView.GetDocShell()->IsReadOnly() )
4809cdf0e10cSrcweir {
4810cdf0e10cSrcweir SwReadOnlyPopup* pROPopup = new SwReadOnlyPopup( aDocPos, rView );
4811cdf0e10cSrcweir
4812cdf0e10cSrcweir ui::ContextMenuExecuteEvent aEvent;
4813cdf0e10cSrcweir aEvent.SourceWindow = VCLUnoHelper::GetInterface( this );
4814cdf0e10cSrcweir aEvent.ExecutePosition.X = aPixPos.X();
4815cdf0e10cSrcweir aEvent.ExecutePosition.Y = aPixPos.Y();
4816cdf0e10cSrcweir Menu* pMenu = 0;
4817cdf0e10cSrcweir ::rtl::OUString sMenuName =
4818cdf0e10cSrcweir ::rtl::OUString::createFromAscii( "private:resource/ReadonlyContextMenu");
4819cdf0e10cSrcweir if( GetView().TryContextMenuInterception( *pROPopup, sMenuName, pMenu, aEvent ) )
4820cdf0e10cSrcweir {
4821cdf0e10cSrcweir if ( pMenu )
4822cdf0e10cSrcweir {
4823cdf0e10cSrcweir sal_uInt16 nExecId = ((PopupMenu*)pMenu)->Execute(this, aPixPos);
4824cdf0e10cSrcweir if( !::ExecuteMenuCommand( *static_cast<PopupMenu*>(pMenu), *rView.GetViewFrame(), nExecId ))
4825cdf0e10cSrcweir pROPopup->Execute(this, nExecId);
4826cdf0e10cSrcweir }
4827cdf0e10cSrcweir else
4828cdf0e10cSrcweir pROPopup->Execute(this, aPixPos);
4829cdf0e10cSrcweir }
4830cdf0e10cSrcweir delete pROPopup;
4831cdf0e10cSrcweir }
4832cdf0e10cSrcweir else if ( !rView.ExecSpellPopup( aDocPos ) )
4833cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->ExecutePopup( 0, this, &aPixPos);
4834cdf0e10cSrcweir }
4835cdf0e10cSrcweir else if (pApplyTempl->bUndo)
4836cdf0e10cSrcweir rSh.Do(SwWrtShell::UNDO);
4837cdf0e10cSrcweir bCallBase = sal_False;
4838cdf0e10cSrcweir }
4839cdf0e10cSrcweir }
4840cdf0e10cSrcweir break;
4841cdf0e10cSrcweir
4842cdf0e10cSrcweir case COMMAND_WHEEL:
4843cdf0e10cSrcweir case COMMAND_STARTAUTOSCROLL:
4844cdf0e10cSrcweir case COMMAND_AUTOSCROLL:
4845cdf0e10cSrcweir if( pShadCrsr )
4846cdf0e10cSrcweir delete pShadCrsr, pShadCrsr = 0;
4847cdf0e10cSrcweir bCallBase = !rView.HandleWheelCommands( rCEvt );
4848cdf0e10cSrcweir break;
4849cdf0e10cSrcweir
4850cdf0e10cSrcweir case COMMAND_VOICE:
4851cdf0e10cSrcweir {
4852cdf0e10cSrcweir //ggf. an Outliner weiterleiten
4853cdf0e10cSrcweir if ( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
4854cdf0e10cSrcweir {
4855cdf0e10cSrcweir bCallBase = sal_False;
4856cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
4857cdf0e10cSrcweir break;
4858cdf0e10cSrcweir }
4859cdf0e10cSrcweir
4860cdf0e10cSrcweir const CommandVoiceData *pCData = rCEvt.GetVoiceData();
4861cdf0e10cSrcweir if ( VOICECOMMANDTYPE_CONTROL == pCData->GetType() )
4862cdf0e10cSrcweir break;
4863cdf0e10cSrcweir
4864cdf0e10cSrcweir
4865cdf0e10cSrcweir sal_uInt16 nSlotId = 0;
4866cdf0e10cSrcweir SfxPoolItem *pItem = 0;
4867cdf0e10cSrcweir
4868cdf0e10cSrcweir switch ( pCData->GetCommand() )
4869cdf0e10cSrcweir {
4870cdf0e10cSrcweir case DICTATIONCOMMAND_NEWPARAGRAPH: nSlotId = FN_INSERT_BREAK; break;
4871cdf0e10cSrcweir case DICTATIONCOMMAND_NEWLINE: nSlotId = FN_INSERT_LINEBREAK; break;
4872cdf0e10cSrcweir case DICTATIONCOMMAND_LEFT: nSlotId = FN_PREV_WORD; break;
4873cdf0e10cSrcweir case DICTATIONCOMMAND_RIGHT: nSlotId = FN_NEXT_WORD; break;
4874cdf0e10cSrcweir case DICTATIONCOMMAND_UP: nSlotId = FN_LINE_UP; break;
4875cdf0e10cSrcweir case DICTATIONCOMMAND_DOWN: nSlotId = FN_LINE_DOWN; break;
4876cdf0e10cSrcweir case DICTATIONCOMMAND_UNDO: nSlotId = SID_UNDO; break;
4877cdf0e10cSrcweir case DICTATIONCOMMAND_REPEAT: nSlotId = SID_REPEAT; break;
4878cdf0e10cSrcweir case DICTATIONCOMMAND_DEL: nSlotId = FN_DELETE_BACK_WORD; break;
4879cdf0e10cSrcweir
4880cdf0e10cSrcweir case DICTATIONCOMMAND_BOLD_ON: nSlotId = SID_ATTR_CHAR_WEIGHT;
4881cdf0e10cSrcweir pItem = new SvxWeightItem( WEIGHT_BOLD, RES_CHRATR_WEIGHT );
4882cdf0e10cSrcweir break;
4883cdf0e10cSrcweir case DICTATIONCOMMAND_BOLD_OFF: nSlotId = SID_ATTR_CHAR_WEIGHT;
4884cdf0e10cSrcweir pItem = new SvxWeightItem( WEIGHT_NORMAL, RES_CHRATR_WEIGHT );
4885cdf0e10cSrcweir break;
4886cdf0e10cSrcweir case DICTATIONCOMMAND_UNDERLINE_ON: nSlotId = SID_ATTR_CHAR_UNDERLINE;
4887cdf0e10cSrcweir pItem = new SvxUnderlineItem( UNDERLINE_SINGLE, RES_CHRATR_WEIGHT );
4888cdf0e10cSrcweir break;
4889cdf0e10cSrcweir case DICTATIONCOMMAND_UNDERLINE_OFF:nSlotId = SID_ATTR_CHAR_UNDERLINE;
4890cdf0e10cSrcweir pItem = new SvxUnderlineItem( UNDERLINE_NONE, RES_CHRATR_UNDERLINE );
4891cdf0e10cSrcweir break;
4892cdf0e10cSrcweir case DICTATIONCOMMAND_ITALIC_ON: nSlotId = SID_ATTR_CHAR_POSTURE;
4893cdf0e10cSrcweir pItem = new SvxPostureItem( ITALIC_NORMAL, RES_CHRATR_POSTURE );
4894cdf0e10cSrcweir break;
4895cdf0e10cSrcweir case DICTATIONCOMMAND_ITALIC_OFF: nSlotId = SID_ATTR_CHAR_POSTURE;
4896cdf0e10cSrcweir pItem = new SvxPostureItem( ITALIC_NONE, RES_CHRATR_POSTURE );
4897cdf0e10cSrcweir break;
4898cdf0e10cSrcweir case DICTATIONCOMMAND_NUMBERING_ON:
4899cdf0e10cSrcweir if ( !rSh.GetCurNumRule() )
4900cdf0e10cSrcweir nSlotId = FN_NUM_NUMBERING_ON;
4901cdf0e10cSrcweir break;
4902cdf0e10cSrcweir case DICTATIONCOMMAND_NUMBERING_OFF:
4903cdf0e10cSrcweir if ( rSh.GetCurNumRule() )
4904cdf0e10cSrcweir nSlotId = FN_NUM_NUMBERING_ON;
4905cdf0e10cSrcweir break;
4906cdf0e10cSrcweir case DICTATIONCOMMAND_TAB:
4907cdf0e10cSrcweir {
4908cdf0e10cSrcweir rSh.Insert( '\t' );
4909cdf0e10cSrcweir }
4910cdf0e10cSrcweir break;
4911cdf0e10cSrcweir case DICTATIONCOMMAND_UNKNOWN:
4912cdf0e10cSrcweir {
4913cdf0e10cSrcweir rView.GetWrtShell().Insert( pCData->GetText() );
4914cdf0e10cSrcweir }
4915cdf0e10cSrcweir break;
4916cdf0e10cSrcweir
4917cdf0e10cSrcweir #ifdef DBG_UTIL
4918cdf0e10cSrcweir default:
4919cdf0e10cSrcweir ASSERT( !this, "unknown speech command." );
4920cdf0e10cSrcweir #endif
4921cdf0e10cSrcweir }
4922cdf0e10cSrcweir if ( nSlotId )
4923cdf0e10cSrcweir {
4924cdf0e10cSrcweir bCallBase = sal_False;
4925cdf0e10cSrcweir if ( pItem )
4926cdf0e10cSrcweir {
4927cdf0e10cSrcweir const SfxPoolItem* aArgs[2];
4928cdf0e10cSrcweir aArgs[0] = pItem;
4929cdf0e10cSrcweir aArgs[1] = 0;
4930cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute(
4931cdf0e10cSrcweir nSlotId, aArgs, 0, SFX_CALLMODE_STANDARD );
4932cdf0e10cSrcweir delete pItem;
4933cdf0e10cSrcweir }
4934cdf0e10cSrcweir else
4935cdf0e10cSrcweir GetView().GetViewFrame()->GetBindings().Execute( nSlotId );
4936cdf0e10cSrcweir }
4937cdf0e10cSrcweir }
4938cdf0e10cSrcweir break;
4939cdf0e10cSrcweir
4940cdf0e10cSrcweir case COMMAND_STARTEXTTEXTINPUT:
4941cdf0e10cSrcweir {
4942cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
4943cdf0e10cSrcweir rSh.IsCrsrReadonly();
4944cdf0e10cSrcweir if(!bIsDocReadOnly)
4945cdf0e10cSrcweir {
4946cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
4947cdf0e10cSrcweir {
4948cdf0e10cSrcweir bCallBase = sal_False;
4949cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
4950cdf0e10cSrcweir }
4951cdf0e10cSrcweir else
4952cdf0e10cSrcweir {
4953cdf0e10cSrcweir if( rSh.HasSelection() )
4954cdf0e10cSrcweir rSh.DelRight();
4955cdf0e10cSrcweir
4956cdf0e10cSrcweir bCallBase = sal_False;
4957cdf0e10cSrcweir LanguageType eInputLanguage = GetInputLanguage();
4958cdf0e10cSrcweir rSh.CreateExtTextInput(eInputLanguage);
4959cdf0e10cSrcweir }
4960cdf0e10cSrcweir }
4961cdf0e10cSrcweir break;
4962cdf0e10cSrcweir }
4963cdf0e10cSrcweir case COMMAND_ENDEXTTEXTINPUT:
4964cdf0e10cSrcweir {
4965cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
4966cdf0e10cSrcweir rSh.IsCrsrReadonly();
4967cdf0e10cSrcweir if(!bIsDocReadOnly)
4968cdf0e10cSrcweir {
4969cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
4970cdf0e10cSrcweir {
4971cdf0e10cSrcweir bCallBase = sal_False;
4972cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
4973cdf0e10cSrcweir }
4974cdf0e10cSrcweir else
4975cdf0e10cSrcweir {
4976cdf0e10cSrcweir bCallBase = sal_False;
4977cdf0e10cSrcweir String sRecord = rSh.DeleteExtTextInput();
4978cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder =
4979cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder();
4980cdf0e10cSrcweir
4981cdf0e10cSrcweir if ( sRecord.Len() )
4982cdf0e10cSrcweir {
4983cdf0e10cSrcweir // #102812# convert quotes in IME text
4984cdf0e10cSrcweir // works on the last input character, this is escpecially in Korean text often done
4985cdf0e10cSrcweir // quotes that are inside of the string are not replaced!
4986cdf0e10cSrcweir const sal_Unicode aCh = sRecord.GetChar(sRecord.Len() - 1);
4987cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get();
4988cdf0e10cSrcweir SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect();
4989cdf0e10cSrcweir if(pACorr &&
4990cdf0e10cSrcweir (( pACorr->IsAutoCorrFlag( ChgQuotes ) && ('\"' == aCh ))||
4991cdf0e10cSrcweir ( pACorr->IsAutoCorrFlag( ChgSglQuotes ) && ( '\'' == aCh))))
4992cdf0e10cSrcweir {
4993cdf0e10cSrcweir rSh.DelLeft();
4994cdf0e10cSrcweir rSh.AutoCorrect( *pACorr, aCh );
4995cdf0e10cSrcweir }
4996cdf0e10cSrcweir
4997cdf0e10cSrcweir if ( xRecorder.is() )
4998cdf0e10cSrcweir {
4999cdf0e10cSrcweir //Shell ermitteln
5000cdf0e10cSrcweir SfxShell *pSfxShell = lcl_GetShellFromDispatcher( rView, TYPE(SwTextShell) );
5001cdf0e10cSrcweir // Request generieren und recorden
5002cdf0e10cSrcweir if (pSfxShell)
5003cdf0e10cSrcweir {
5004cdf0e10cSrcweir SfxRequest aReq( rView.GetViewFrame(), FN_INSERT_STRING );
5005cdf0e10cSrcweir aReq.AppendItem( SfxStringItem( FN_INSERT_STRING, sRecord ) );
5006cdf0e10cSrcweir aReq.Done();
5007cdf0e10cSrcweir }
5008cdf0e10cSrcweir }
5009cdf0e10cSrcweir }
5010cdf0e10cSrcweir }
5011cdf0e10cSrcweir }
5012cdf0e10cSrcweir }
5013cdf0e10cSrcweir break;
5014cdf0e10cSrcweir case COMMAND_EXTTEXTINPUT:
5015cdf0e10cSrcweir {
5016cdf0e10cSrcweir sal_Bool bIsDocReadOnly = rView.GetDocShell()->IsReadOnly() &&
5017cdf0e10cSrcweir rSh.IsCrsrReadonly();
5018cdf0e10cSrcweir if(!bIsDocReadOnly)
5019cdf0e10cSrcweir {
5020cdf0e10cSrcweir QuickHelpData aTmpQHD;
5021cdf0e10cSrcweir if( pQuickHlpData->bClear )
5022cdf0e10cSrcweir {
5023cdf0e10cSrcweir aTmpQHD.Move( *pQuickHlpData );
5024cdf0e10cSrcweir pQuickHlpData->Stop( rSh );
5025cdf0e10cSrcweir }
5026cdf0e10cSrcweir String sWord;
5027cdf0e10cSrcweir if( rSh.HasDrawView() && rSh.GetDrawView()->IsTextEdit() )
5028cdf0e10cSrcweir {
5029cdf0e10cSrcweir bCallBase = sal_False;
5030cdf0e10cSrcweir rSh.GetDrawView()->GetTextEditOutlinerView()->Command( rCEvt );
5031cdf0e10cSrcweir }
5032cdf0e10cSrcweir else
5033cdf0e10cSrcweir {
5034cdf0e10cSrcweir const CommandExtTextInputData* pData = rCEvt.GetExtTextInputData();
5035cdf0e10cSrcweir if( pData )
5036cdf0e10cSrcweir {
5037cdf0e10cSrcweir sWord = pData->GetText();
5038cdf0e10cSrcweir bCallBase = sal_False;
5039cdf0e10cSrcweir rSh.SetExtTextInputData( *pData );
5040cdf0e10cSrcweir }
5041cdf0e10cSrcweir }
5042cdf0e10cSrcweir uno::Reference< frame::XDispatchRecorder > xRecorder =
5043cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().GetRecorder();
5044cdf0e10cSrcweir if(!xRecorder.is())
5045cdf0e10cSrcweir {
5046cdf0e10cSrcweir SvxAutoCorrCfg* pACfg = SvxAutoCorrCfg::Get();
5047cdf0e10cSrcweir SvxAutoCorrect* pACorr = pACfg->GetAutoCorrect();
5048cdf0e10cSrcweir if( pACfg && pACorr &&
5049cdf0e10cSrcweir ( pACfg->IsAutoTextTip() ||
5050cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCompleteWords ) &&
5051cdf0e10cSrcweir rSh.GetPrevAutoCorrWord( *pACorr, sWord ) )
5052cdf0e10cSrcweir {
5053cdf0e10cSrcweir ShowAutoTextCorrectQuickHelp(sWord, pACfg, pACorr, sal_True);
5054cdf0e10cSrcweir }
5055cdf0e10cSrcweir }
5056cdf0e10cSrcweir }
5057cdf0e10cSrcweir }
5058cdf0e10cSrcweir break;
5059cdf0e10cSrcweir case COMMAND_CURSORPOS:
5060cdf0e10cSrcweir // will be handled by the base class
5061cdf0e10cSrcweir break;
5062cdf0e10cSrcweir
5063cdf0e10cSrcweir case COMMAND_PASTESELECTION:
5064cdf0e10cSrcweir if( !rView.GetDocShell()->IsReadOnly() )
5065cdf0e10cSrcweir {
5066cdf0e10cSrcweir TransferableDataHelper aDataHelper(
5067cdf0e10cSrcweir TransferableDataHelper::CreateFromSelection( this ));
5068cdf0e10cSrcweir if( !aDataHelper.GetXTransferable().is() )
5069cdf0e10cSrcweir break;
5070cdf0e10cSrcweir
5071cdf0e10cSrcweir sal_uLong nDropFormat;
5072cdf0e10cSrcweir sal_uInt16 nEventAction, nDropAction, nDropDestination;
5073cdf0e10cSrcweir nDropDestination = GetDropDestination( rCEvt.GetMousePosPixel() );
5074cdf0e10cSrcweir if( !nDropDestination )
5075cdf0e10cSrcweir break;
5076cdf0e10cSrcweir
5077cdf0e10cSrcweir nDropAction = SotExchange::GetExchangeAction(
5078cdf0e10cSrcweir aDataHelper.GetDataFlavorExVector(),
5079cdf0e10cSrcweir nDropDestination, EXCHG_IN_ACTION_COPY,
5080cdf0e10cSrcweir EXCHG_IN_ACTION_COPY, nDropFormat,
5081cdf0e10cSrcweir nEventAction );
5082cdf0e10cSrcweir if( EXCHG_INOUT_ACTION_NONE != nDropAction )
5083cdf0e10cSrcweir {
5084cdf0e10cSrcweir const Point aDocPt( PixelToLogic( rCEvt.GetMousePosPixel() ) );
5085cdf0e10cSrcweir SwTransferable::PasteData( aDataHelper, rSh, nDropAction,
5086cdf0e10cSrcweir nDropFormat, nDropDestination, sal_False,
5087cdf0e10cSrcweir sal_False, &aDocPt, EXCHG_IN_ACTION_COPY,
5088cdf0e10cSrcweir sal_True );
5089cdf0e10cSrcweir }
5090cdf0e10cSrcweir }
5091cdf0e10cSrcweir break;
5092cdf0e10cSrcweir case COMMAND_MODKEYCHANGE :
5093cdf0e10cSrcweir {
5094cdf0e10cSrcweir const CommandModKeyData* pCommandData = (const CommandModKeyData*)rCEvt.GetData();
5095cdf0e10cSrcweir if(pCommandData->IsMod1() && !pCommandData->IsMod2())
5096cdf0e10cSrcweir {
5097cdf0e10cSrcweir sal_uInt16 nSlot = 0;
5098cdf0e10cSrcweir if(pCommandData->IsLeftShift() && !pCommandData->IsRightShift())
5099cdf0e10cSrcweir nSlot = SID_ATTR_PARA_LEFT_TO_RIGHT;
5100cdf0e10cSrcweir else if(!pCommandData->IsLeftShift() && pCommandData->IsRightShift())
5101cdf0e10cSrcweir nSlot = SID_ATTR_PARA_RIGHT_TO_LEFT;
5102cdf0e10cSrcweir if(nSlot && SW_MOD()->GetCTLOptions().IsCTLFontEnabled())
5103cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->Execute(nSlot);
5104cdf0e10cSrcweir }
5105cdf0e10cSrcweir }
5106cdf0e10cSrcweir break;
5107cdf0e10cSrcweir case COMMAND_HANGUL_HANJA_CONVERSION :
5108cdf0e10cSrcweir GetView().GetViewFrame()->GetDispatcher()->Execute(SID_HANGUL_HANJA_CONVERSION);
5109cdf0e10cSrcweir break;
5110cdf0e10cSrcweir case COMMAND_INPUTLANGUAGECHANGE :
5111cdf0e10cSrcweir //#i42732# update state of fontname if input language changes
5112cdf0e10cSrcweir bInputLanguageSwitched = true;
5113cdf0e10cSrcweir SetUseInputLanguage( sal_True );
5114cdf0e10cSrcweir break;
5115cdf0e10cSrcweir case COMMAND_SELECTIONCHANGE:
5116cdf0e10cSrcweir {
5117cdf0e10cSrcweir const CommandSelectionChangeData *pData = rCEvt.GetSelectionChangeData();
5118cdf0e10cSrcweir rSh.SttCrsrMove();
5119cdf0e10cSrcweir rSh.GoStartSentence();
5120cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetStart());
5121cdf0e10cSrcweir rSh.SetMark();
5122cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent += sal::static_int_cast<sal_uInt16, sal_uLong>(pData->GetEnd() - pData->GetStart());
5123cdf0e10cSrcweir rSh.EndCrsrMove( sal_True );
5124cdf0e10cSrcweir }
5125cdf0e10cSrcweir break;
5126cdf0e10cSrcweir case COMMAND_PREPARERECONVERSION:
5127cdf0e10cSrcweir if( rSh.HasSelection() )
5128cdf0e10cSrcweir {
5129cdf0e10cSrcweir SwPaM *pCrsr = (SwPaM*)rSh.GetCrsr();
5130cdf0e10cSrcweir
5131cdf0e10cSrcweir if( rSh.IsMultiSelection() )
5132cdf0e10cSrcweir {
5133cdf0e10cSrcweir if( pCrsr && !pCrsr->HasMark() &&
5134cdf0e10cSrcweir pCrsr->GetPoint() == pCrsr->GetMark() )
5135cdf0e10cSrcweir {
5136cdf0e10cSrcweir rSh.GoPrevCrsr();
5137cdf0e10cSrcweir pCrsr = (SwPaM*)rSh.GetCrsr();
5138cdf0e10cSrcweir }
5139cdf0e10cSrcweir
5140cdf0e10cSrcweir // Cancel all selections other than the last selected one.
5141cdf0e10cSrcweir while( rSh.GetCrsr()->GetNext() != rSh.GetCrsr() )
5142cdf0e10cSrcweir delete rSh.GetCrsr()->GetNext();
5143cdf0e10cSrcweir }
5144cdf0e10cSrcweir
5145cdf0e10cSrcweir if( pCrsr )
5146cdf0e10cSrcweir {
5147cdf0e10cSrcweir sal_uLong nPosNodeIdx = pCrsr->GetPoint()->nNode.GetIndex();
5148cdf0e10cSrcweir xub_StrLen nPosIdx = pCrsr->GetPoint()->nContent.GetIndex();
5149cdf0e10cSrcweir sal_uLong nMarkNodeIdx = pCrsr->GetMark()->nNode.GetIndex();
5150cdf0e10cSrcweir xub_StrLen nMarkIdx = pCrsr->GetMark()->nContent.GetIndex();
5151cdf0e10cSrcweir
5152cdf0e10cSrcweir if( !rSh.GetCrsr()->HasMark() )
5153cdf0e10cSrcweir rSh.GetCrsr()->SetMark();
5154cdf0e10cSrcweir
5155cdf0e10cSrcweir rSh.SttCrsrMove();
5156cdf0e10cSrcweir
5157cdf0e10cSrcweir if( nPosNodeIdx < nMarkNodeIdx )
5158cdf0e10cSrcweir {
5159cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx;
5160cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent = nPosIdx;
5161cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nPosNodeIdx;
5162cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent =
5163cdf0e10cSrcweir rSh.GetCrsr()->GetCntntNode( sal_True )->Len();
5164cdf0e10cSrcweir }
5165cdf0e10cSrcweir else if( nPosNodeIdx == nMarkNodeIdx )
5166cdf0e10cSrcweir {
5167cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nPosNodeIdx;
5168cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent = nPosIdx;
5169cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx;
5170cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = nMarkIdx;
5171cdf0e10cSrcweir }
5172cdf0e10cSrcweir else
5173cdf0e10cSrcweir {
5174cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nNode = nMarkNodeIdx;
5175cdf0e10cSrcweir rSh.GetCrsr()->GetMark()->nContent = nMarkIdx;
5176cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nNode = nMarkNodeIdx;
5177cdf0e10cSrcweir rSh.GetCrsr()->GetPoint()->nContent =
5178cdf0e10cSrcweir rSh.GetCrsr()->GetCntntNode( sal_False )->Len();
5179cdf0e10cSrcweir }
5180cdf0e10cSrcweir
5181cdf0e10cSrcweir rSh.EndCrsrMove( sal_True );
5182cdf0e10cSrcweir }
5183cdf0e10cSrcweir }
5184cdf0e10cSrcweir break;
5185cdf0e10cSrcweir #ifdef DBG_UTIL
5186cdf0e10cSrcweir default:
5187cdf0e10cSrcweir ASSERT( !this, "unknown command." );
5188cdf0e10cSrcweir #endif
5189cdf0e10cSrcweir }
5190cdf0e10cSrcweir if (bCallBase)
5191cdf0e10cSrcweir Window::Command(rCEvt);
5192cdf0e10cSrcweir }
5193cdf0e10cSrcweir
5194cdf0e10cSrcweir /* -----------------25.08.2003 10:12-----------------
5195cdf0e10cSrcweir #i18686#: select the object/cursor at the mouse
5196cdf0e10cSrcweir position of the context menu request
5197cdf0e10cSrcweir --------------------------------------------------*/
SelectMenuPosition(SwWrtShell & rSh,const Point & rMousePos)5198cdf0e10cSrcweir sal_Bool SwEditWin::SelectMenuPosition(SwWrtShell& rSh, const Point& rMousePos )
5199cdf0e10cSrcweir {
5200cdf0e10cSrcweir sal_Bool bRet = sal_False;
5201cdf0e10cSrcweir const Point aDocPos( PixelToLogic( rMousePos ) );
5202cdf0e10cSrcweir const bool bIsInsideSelectedObj( rSh.IsInsideSelectedObj( aDocPos ) );
5203cdf0e10cSrcweir //create a synthetic mouse event out of the coordinates
5204cdf0e10cSrcweir MouseEvent aMEvt(rMousePos);
5205cdf0e10cSrcweir SdrView *pSdrView = rSh.GetDrawView();
5206cdf0e10cSrcweir if ( pSdrView )
5207cdf0e10cSrcweir {
52085b40a975SOliver-Rainer Wittmann // no close of insert_draw and reset of draw mode,
52095b40a975SOliver-Rainer Wittmann // if context menu position is inside a selected object.
5210cdf0e10cSrcweir if ( !bIsInsideSelectedObj && rView.GetDrawFuncPtr() )
5211cdf0e10cSrcweir {
5212cdf0e10cSrcweir
5213cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
5214cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
5215cdf0e10cSrcweir rView.LeaveDrawCreate();
5216cdf0e10cSrcweir SfxBindings& rBind = rView.GetViewFrame()->GetBindings();
5217cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_SIZE );
5218cdf0e10cSrcweir rBind.Invalidate( SID_TABLE_CELL );
5219cdf0e10cSrcweir }
5220cdf0e10cSrcweir
5221cdf0e10cSrcweir // if draw text is active and there's a text selection
5222cdf0e10cSrcweir // at the mouse position then do nothing
5223cdf0e10cSrcweir if(rSh.GetSelectionType() & nsSelectionType::SEL_DRW_TXT)
5224cdf0e10cSrcweir {
5225cdf0e10cSrcweir OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();
5226cdf0e10cSrcweir ESelection aSelection = pOLV->GetSelection();
5227cdf0e10cSrcweir if(!aSelection.IsZero())
5228cdf0e10cSrcweir {
5229cdf0e10cSrcweir SdrOutliner* pOutliner = pSdrView->GetTextEditOutliner();
5230cdf0e10cSrcweir sal_Bool bVertical = pOutliner->IsVertical();
5231cdf0e10cSrcweir const EditEngine& rEditEng = pOutliner->GetEditEngine();
5232cdf0e10cSrcweir Point aEEPos(aDocPos);
5233cdf0e10cSrcweir const Rectangle& rOutputArea = pOLV->GetOutputArea();
5234cdf0e10cSrcweir // regard vertical mode
5235cdf0e10cSrcweir if(bVertical)
5236cdf0e10cSrcweir {
5237cdf0e10cSrcweir aEEPos -= rOutputArea.TopRight();
5238cdf0e10cSrcweir //invert the horizontal direction and exchange X and Y
5239cdf0e10cSrcweir long nTemp = -aEEPos.X();
5240cdf0e10cSrcweir aEEPos.X() = aEEPos.Y();
5241cdf0e10cSrcweir aEEPos.Y() = nTemp;
5242cdf0e10cSrcweir }
5243cdf0e10cSrcweir else
5244cdf0e10cSrcweir aEEPos -= rOutputArea.TopLeft();
5245cdf0e10cSrcweir
5246cdf0e10cSrcweir EPosition aDocPosition = rEditEng.FindDocPosition(aEEPos);
5247cdf0e10cSrcweir ESelection aCompare(aDocPosition.nPara, aDocPosition.nIndex);
5248cdf0e10cSrcweir // make it a forward selection - otherwise the IsLess/IsGreater do not work :-(
5249cdf0e10cSrcweir aSelection.Adjust();
5250cdf0e10cSrcweir if(!aCompare.IsLess(aSelection) && !aCompare.IsGreater(aSelection))
5251cdf0e10cSrcweir {
5252cdf0e10cSrcweir return sal_False;
5253cdf0e10cSrcweir }
5254cdf0e10cSrcweir }
5255cdf0e10cSrcweir
5256cdf0e10cSrcweir }
5257cdf0e10cSrcweir
5258cdf0e10cSrcweir if (pSdrView->MouseButtonDown( aMEvt, this ) )
5259cdf0e10cSrcweir {
5260cdf0e10cSrcweir pSdrView->MouseButtonUp( aMEvt, this );
5261cdf0e10cSrcweir rSh.GetView().GetViewFrame()->GetBindings().InvalidateAll(sal_False);
5262cdf0e10cSrcweir return sal_True;
5263cdf0e10cSrcweir }
5264cdf0e10cSrcweir }
5265cdf0e10cSrcweir rSh.ResetCursorStack();
5266cdf0e10cSrcweir
5267cdf0e10cSrcweir if ( EnterDrawMode( aMEvt, aDocPos ) )
5268cdf0e10cSrcweir {
5269cdf0e10cSrcweir return sal_True;
5270cdf0e10cSrcweir }
5271cdf0e10cSrcweir if ( rView.GetDrawFuncPtr() && bInsFrm )
5272cdf0e10cSrcweir {
5273cdf0e10cSrcweir StopInsFrm();
5274cdf0e10cSrcweir rSh.Edit();
5275cdf0e10cSrcweir }
5276cdf0e10cSrcweir
5277cdf0e10cSrcweir UpdatePointer( aDocPos, 0 );
5278cdf0e10cSrcweir
5279cdf0e10cSrcweir if( !rSh.IsSelFrmMode() &&
5280cdf0e10cSrcweir !GetView().GetViewFrame()->GetDispatcher()->IsLocked() )
5281cdf0e10cSrcweir {
5282cdf0e10cSrcweir // #107513#
5283cdf0e10cSrcweir // Test if there is a draw object at that position and if it should be selected.
5284cdf0e10cSrcweir sal_Bool bShould = rSh.ShouldObjectBeSelected(aDocPos);
5285cdf0e10cSrcweir
5286cdf0e10cSrcweir if(bShould)
5287cdf0e10cSrcweir {
5288cdf0e10cSrcweir rView.NoRotate();
5289cdf0e10cSrcweir rSh.HideCrsr();
5290cdf0e10cSrcweir
5291cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
5292cdf0e10cSrcweir rSh.LockView( sal_True );
5293cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, 0);
5294cdf0e10cSrcweir if( bUnLockView )
5295cdf0e10cSrcweir rSh.LockView( sal_False );
5296cdf0e10cSrcweir
5297cdf0e10cSrcweir if( bSelObj )
5298cdf0e10cSrcweir {
5299cdf0e10cSrcweir bRet = sal_True;
5300cdf0e10cSrcweir // falls im Macro der Rahmen deselektiert
5301cdf0e10cSrcweir // wurde, muss nur noch der Cursor
5302cdf0e10cSrcweir // wieder angezeigt werden.
5303cdf0e10cSrcweir if( FRMTYPE_NONE == rSh.GetSelFrmType() )
5304cdf0e10cSrcweir rSh.ShowCrsr();
5305cdf0e10cSrcweir else
5306cdf0e10cSrcweir {
5307cdf0e10cSrcweir if (rSh.IsFrmSelected() && rView.GetDrawFuncPtr())
5308cdf0e10cSrcweir {
5309cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
5310cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
5311cdf0e10cSrcweir rView.LeaveDrawCreate();
5312cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
5313cdf0e10cSrcweir }
5314cdf0e10cSrcweir
5315cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
5316cdf0e10cSrcweir bFrmDrag = sal_True;
5317cdf0e10cSrcweir UpdatePointer( aDocPos, 0 );
5318cdf0e10cSrcweir return bRet;
5319cdf0e10cSrcweir }
5320cdf0e10cSrcweir }
5321cdf0e10cSrcweir
5322cdf0e10cSrcweir if (!rView.GetDrawFuncPtr())
5323cdf0e10cSrcweir rSh.ShowCrsr();
5324cdf0e10cSrcweir }
5325cdf0e10cSrcweir }
5326cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() &&
5327cdf0e10cSrcweir (aActHitType == SDRHIT_NONE ||
5328cdf0e10cSrcweir !bIsInsideSelectedObj))
5329cdf0e10cSrcweir {
5330cdf0e10cSrcweir rView.NoRotate();
5331cdf0e10cSrcweir sal_Bool bUnLockView = !rSh.IsViewLocked();
5332cdf0e10cSrcweir rSh.LockView( sal_True );
5333cdf0e10cSrcweir sal_uInt8 nFlag = 0;
5334cdf0e10cSrcweir
5335cdf0e10cSrcweir if ( rSh.IsSelFrmMode() )
5336cdf0e10cSrcweir {
5337cdf0e10cSrcweir rSh.UnSelectFrm();
5338cdf0e10cSrcweir rSh.LeaveSelFrmMode();
5339cdf0e10cSrcweir rView.AttrChangedNotify(&rSh);
5340cdf0e10cSrcweir bRet = sal_True;
5341cdf0e10cSrcweir }
5342cdf0e10cSrcweir
5343cdf0e10cSrcweir sal_Bool bSelObj = rSh.SelectObj( aDocPos, nFlag );
5344cdf0e10cSrcweir if( bUnLockView )
5345cdf0e10cSrcweir rSh.LockView( sal_False );
5346cdf0e10cSrcweir
5347cdf0e10cSrcweir if( !bSelObj )
5348cdf0e10cSrcweir {
5349cdf0e10cSrcweir // Cursor hier umsetzen, damit er nicht zuerst
5350cdf0e10cSrcweir // im Rahmen gezeichnet wird; ShowCrsr() geschieht
5351cdf0e10cSrcweir // in LeaveSelFrmMode()
5352cdf0e10cSrcweir bValidCrsrPos = !(CRSR_POSCHG & (rSh.*rSh.fnSetCrsr)(&aDocPos,sal_False));
5353cdf0e10cSrcweir rSh.LeaveSelFrmMode();
5354cdf0e10cSrcweir rView.LeaveDrawCreate();
5355cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
5356cdf0e10cSrcweir bRet = sal_True;
5357cdf0e10cSrcweir }
5358cdf0e10cSrcweir else
5359cdf0e10cSrcweir {
5360cdf0e10cSrcweir rSh.HideCrsr();
5361cdf0e10cSrcweir rSh.EnterSelFrmMode( &aDocPos );
5362cdf0e10cSrcweir rSh.SelFlyGrabCrsr();
5363cdf0e10cSrcweir rSh.MakeSelVisible();
5364cdf0e10cSrcweir bFrmDrag = sal_True;
5365cdf0e10cSrcweir if( rSh.IsFrmSelected() &&
5366cdf0e10cSrcweir rView.GetDrawFuncPtr() )
5367cdf0e10cSrcweir {
5368cdf0e10cSrcweir rView.GetDrawFuncPtr()->Deactivate();
5369cdf0e10cSrcweir rView.SetDrawFuncPtr(NULL);
5370cdf0e10cSrcweir rView.LeaveDrawCreate();
5371cdf0e10cSrcweir rView.AttrChangedNotify( &rSh );
5372cdf0e10cSrcweir }
5373cdf0e10cSrcweir UpdatePointer( aDocPos, 0 );
5374cdf0e10cSrcweir bRet = sal_True;
5375cdf0e10cSrcweir }
5376cdf0e10cSrcweir }
5377cdf0e10cSrcweir else if ( rSh.IsSelFrmMode() && bIsInsideSelectedObj )
5378cdf0e10cSrcweir {
5379cdf0e10cSrcweir // ## object at the mouse cursor is already selected - do nothing
5380cdf0e10cSrcweir return sal_False;
5381cdf0e10cSrcweir }
5382cdf0e10cSrcweir
5383cdf0e10cSrcweir if ( rSh.IsGCAttr() )
5384cdf0e10cSrcweir {
5385cdf0e10cSrcweir rSh.GCAttr();
5386cdf0e10cSrcweir rSh.ClearGCAttr();
5387cdf0e10cSrcweir }
5388cdf0e10cSrcweir
5389cdf0e10cSrcweir sal_Bool bOverSelect = rSh.ChgCurrPam( aDocPos ), bOverURLGrf = sal_False;
5390cdf0e10cSrcweir if( !bOverSelect )
5391cdf0e10cSrcweir bOverURLGrf = bOverSelect = 0 != rSh.IsURLGrfAtPos( aDocPos );
5392cdf0e10cSrcweir
5393cdf0e10cSrcweir if ( !bOverSelect )
5394cdf0e10cSrcweir {
5395cdf0e10cSrcweir { // nur temp. Move-Kontext aufspannen, da sonst die
5396cdf0e10cSrcweir // Abfrage auf die Inhaltsform nicht funktioniert!!!
5397cdf0e10cSrcweir MV_KONTEXT( &rSh );
5398cdf0e10cSrcweir (rSh.*rSh.fnSetCrsr)(&aDocPos, sal_False);
5399cdf0e10cSrcweir bRet = sal_True;
5400cdf0e10cSrcweir }
5401cdf0e10cSrcweir }
5402cdf0e10cSrcweir if( !bOverURLGrf )
5403cdf0e10cSrcweir {
5404cdf0e10cSrcweir const int nSelType = rSh.GetSelectionType();
5405cdf0e10cSrcweir if( nSelType == nsSelectionType::SEL_OLE ||
5406cdf0e10cSrcweir nSelType == nsSelectionType::SEL_GRF )
5407cdf0e10cSrcweir {
5408cdf0e10cSrcweir MV_KONTEXT( &rSh );
5409cdf0e10cSrcweir if( !rSh.IsFrmSelected() )
5410cdf0e10cSrcweir rSh.GotoNextFly();
5411cdf0e10cSrcweir rSh.EnterSelFrmMode();
5412cdf0e10cSrcweir bRet = sal_True;
5413cdf0e10cSrcweir }
5414cdf0e10cSrcweir }
5415cdf0e10cSrcweir return bRet;
5416cdf0e10cSrcweir }
5417cdf0e10cSrcweir
lcl_GetShellFromDispatcher(SwView & rView,TypeId nType)5418cdf0e10cSrcweir SfxShell* lcl_GetShellFromDispatcher( SwView& rView, TypeId nType )
5419cdf0e10cSrcweir {
5420cdf0e10cSrcweir //Shell ermitteln
5421cdf0e10cSrcweir SfxShell* pShell;
5422cdf0e10cSrcweir SfxDispatcher* pDispatcher = rView.GetViewFrame()->GetDispatcher();
5423cdf0e10cSrcweir for(sal_uInt16 i = 0; sal_True; ++i )
5424cdf0e10cSrcweir {
5425cdf0e10cSrcweir pShell = pDispatcher->GetShell( i );
5426cdf0e10cSrcweir if( !pShell || pShell->IsA( nType ) )
5427cdf0e10cSrcweir break;
5428cdf0e10cSrcweir }
5429cdf0e10cSrcweir return pShell;
5430cdf0e10cSrcweir }
5431cdf0e10cSrcweir
5432cdf0e10cSrcweir
5433cdf0e10cSrcweir
ClearTip()5434cdf0e10cSrcweir void SwEditWin::ClearTip()
5435cdf0e10cSrcweir {
5436cdf0e10cSrcweir }
5437cdf0e10cSrcweir
IMPL_LINK(SwEditWin,KeyInputFlushHandler,Timer *,EMPTYARG)5438cdf0e10cSrcweir IMPL_LINK( SwEditWin, KeyInputFlushHandler, Timer *, EMPTYARG )
5439cdf0e10cSrcweir {
5440cdf0e10cSrcweir FlushInBuffer();
5441cdf0e10cSrcweir return 0;
5442cdf0e10cSrcweir }
5443cdf0e10cSrcweir
5444cdf0e10cSrcweir
IMPL_LINK(SwEditWin,KeyInputTimerHandler,Timer *,EMPTYARG)5445cdf0e10cSrcweir IMPL_LINK( SwEditWin, KeyInputTimerHandler, Timer *, EMPTYARG )
5446cdf0e10cSrcweir {
5447cdf0e10cSrcweir bTblInsDelMode = sal_False;
5448cdf0e10cSrcweir return 0;
5449cdf0e10cSrcweir }
5450cdf0e10cSrcweir
_InitStaticData()5451cdf0e10cSrcweir void SwEditWin::_InitStaticData()
5452cdf0e10cSrcweir {
5453cdf0e10cSrcweir pQuickHlpData = new QuickHelpData();
5454cdf0e10cSrcweir }
5455cdf0e10cSrcweir
_FinitStaticData()5456cdf0e10cSrcweir void SwEditWin::_FinitStaticData()
5457cdf0e10cSrcweir {
5458cdf0e10cSrcweir delete pQuickHlpData;
5459cdf0e10cSrcweir }
5460cdf0e10cSrcweir /* -----------------23.01.2003 12:15-----------------
5461cdf0e10cSrcweir * #i3370# remove quick help to prevent saving
5462cdf0e10cSrcweir * of autocorrection suggestions
5463cdf0e10cSrcweir * --------------------------------------------------*/
StopQuickHelp()5464cdf0e10cSrcweir void SwEditWin::StopQuickHelp()
5465cdf0e10cSrcweir {
5466cdf0e10cSrcweir if( HasFocus() && pQuickHlpData && pQuickHlpData->bClear )
5467cdf0e10cSrcweir pQuickHlpData->Stop( rView.GetWrtShell() );
5468cdf0e10cSrcweir }
5469cdf0e10cSrcweir
5470cdf0e10cSrcweir /*-----------------23.02.97 18:39-------------------
5471cdf0e10cSrcweir
5472cdf0e10cSrcweir --------------------------------------------------*/
5473cdf0e10cSrcweir
5474cdf0e10cSrcweir
IMPL_LINK(SwEditWin,TemplateTimerHdl,Timer *,EMPTYARG)5475cdf0e10cSrcweir IMPL_LINK(SwEditWin, TemplateTimerHdl, Timer*, EMPTYARG)
5476cdf0e10cSrcweir {
5477cdf0e10cSrcweir SetApplyTemplate(SwApplyTemplate());
5478cdf0e10cSrcweir return 0;
5479cdf0e10cSrcweir }
5480cdf0e10cSrcweir
5481cdf0e10cSrcweir
SetChainMode(sal_Bool bOn)5482cdf0e10cSrcweir void SwEditWin::SetChainMode( sal_Bool bOn )
5483cdf0e10cSrcweir {
5484cdf0e10cSrcweir if ( !bChainMode )
5485cdf0e10cSrcweir StopInsFrm();
5486cdf0e10cSrcweir
5487cdf0e10cSrcweir if ( pUserMarker )
5488cdf0e10cSrcweir {
5489cdf0e10cSrcweir delete pUserMarker;
5490cdf0e10cSrcweir pUserMarker = 0L;
5491cdf0e10cSrcweir }
5492cdf0e10cSrcweir
5493cdf0e10cSrcweir bChainMode = bOn;
5494cdf0e10cSrcweir if ( !bChainMode )
5495cdf0e10cSrcweir rView.GetViewFrame()->HideStatusText();
5496cdf0e10cSrcweir
5497cdf0e10cSrcweir static sal_uInt16 __READONLY_DATA aInva[] =
5498cdf0e10cSrcweir {
5499cdf0e10cSrcweir FN_FRAME_CHAIN, FN_FRAME_UNCHAIN, 0
5500cdf0e10cSrcweir };
5501cdf0e10cSrcweir rView.GetViewFrame()->GetBindings().Invalidate(aInva);
5502cdf0e10cSrcweir }
5503cdf0e10cSrcweir
CreateAccessible()5504cdf0e10cSrcweir uno::Reference< ::com::sun::star::accessibility::XAccessible > SwEditWin::CreateAccessible()
5505cdf0e10cSrcweir {
5506cdf0e10cSrcweir vos::OGuard aGuard(Application::GetSolarMutex()); // this should have
5507cdf0e10cSrcweir // happend already!!!
5508cdf0e10cSrcweir SwWrtShell *pSh = rView.GetWrtShellPtr();
5509cdf0e10cSrcweir ASSERT( pSh, "no writer shell, no accessible object" );
5510cdf0e10cSrcweir uno::Reference<
5511cdf0e10cSrcweir ::com::sun::star::accessibility::XAccessible > xAcc;
5512cdf0e10cSrcweir if( pSh )
5513cdf0e10cSrcweir xAcc = pSh->CreateAccessible();
5514cdf0e10cSrcweir
5515cdf0e10cSrcweir return xAcc;
5516cdf0e10cSrcweir }
5517cdf0e10cSrcweir
5518cdf0e10cSrcweir //-------------------------------------------------------------
5519cdf0e10cSrcweir
Move(QuickHelpData & rCpy)5520cdf0e10cSrcweir void QuickHelpData::Move( QuickHelpData& rCpy )
5521cdf0e10cSrcweir {
5522cdf0e10cSrcweir // Pointer verschieben
5523cdf0e10cSrcweir aArr.Insert( &rCpy.aArr );
5524cdf0e10cSrcweir rCpy.aArr.Remove( (sal_uInt16)0, rCpy.aArr.Count() );
5525cdf0e10cSrcweir // nTipId = rCpy.nTipId;
5526cdf0e10cSrcweir bClear = rCpy.bClear;
5527cdf0e10cSrcweir nLen = rCpy.nLen;
5528cdf0e10cSrcweir nCurArrPos = rCpy.nCurArrPos;
5529cdf0e10cSrcweir bChkInsBlank = rCpy.bChkInsBlank;
5530cdf0e10cSrcweir bIsTip = rCpy.bIsTip;
5531cdf0e10cSrcweir bIsAutoText = rCpy.bIsAutoText;
5532cdf0e10cSrcweir
5533cdf0e10cSrcweir if( pCETID ) delete pCETID;
5534cdf0e10cSrcweir pCETID = rCpy.pCETID;
5535cdf0e10cSrcweir rCpy.pCETID = 0;
5536cdf0e10cSrcweir
5537cdf0e10cSrcweir if( pAttrs )
5538cdf0e10cSrcweir delete[] pAttrs;
5539cdf0e10cSrcweir pAttrs = rCpy.pAttrs;
5540cdf0e10cSrcweir rCpy.pAttrs = 0;
5541cdf0e10cSrcweir }
5542cdf0e10cSrcweir
ClearCntnt()5543cdf0e10cSrcweir void QuickHelpData::ClearCntnt()
5544cdf0e10cSrcweir {
5545cdf0e10cSrcweir nLen = nCurArrPos = 0;
5546cdf0e10cSrcweir bClear = bChkInsBlank = sal_False;
5547cdf0e10cSrcweir nTipId = 0;
5548cdf0e10cSrcweir aArr.DeleteAndDestroy( 0 , aArr.Count() );
5549cdf0e10cSrcweir bIsTip = sal_True;
5550cdf0e10cSrcweir bIsAutoText = sal_True;
5551cdf0e10cSrcweir delete pCETID, pCETID = 0;
5552cdf0e10cSrcweir delete[] pAttrs, pAttrs = 0;
5553cdf0e10cSrcweir }
5554cdf0e10cSrcweir
5555cdf0e10cSrcweir
Start(SwWrtShell & rSh,sal_uInt16 nWrdLen)5556cdf0e10cSrcweir void QuickHelpData::Start( SwWrtShell& rSh, sal_uInt16 nWrdLen )
5557cdf0e10cSrcweir {
5558cdf0e10cSrcweir if( pCETID ) delete pCETID, pCETID = 0;
5559cdf0e10cSrcweir if( pAttrs ) delete[] pAttrs, pAttrs = 0;
5560cdf0e10cSrcweir
5561cdf0e10cSrcweir if( USHRT_MAX != nWrdLen )
5562cdf0e10cSrcweir {
5563cdf0e10cSrcweir nLen = nWrdLen;
5564cdf0e10cSrcweir nCurArrPos = 0;
5565cdf0e10cSrcweir }
5566cdf0e10cSrcweir bClear = sal_True;
5567cdf0e10cSrcweir
5568cdf0e10cSrcweir Window& rWin = rSh.GetView().GetEditWin();
5569cdf0e10cSrcweir if( bIsTip )
5570cdf0e10cSrcweir {
5571cdf0e10cSrcweir Point aPt( rWin.OutputToScreenPixel( rWin.LogicToPixel(
5572cdf0e10cSrcweir rSh.GetCharRect().Pos() )));
5573cdf0e10cSrcweir aPt.Y() -= 3;
5574cdf0e10cSrcweir nTipId = Help::ShowTip( &rWin, Rectangle( aPt, Size( 1, 1 )),
5575cdf0e10cSrcweir *aArr[ nCurArrPos ],
5576cdf0e10cSrcweir QUICKHELP_LEFT | QUICKHELP_BOTTOM );
5577cdf0e10cSrcweir }
5578cdf0e10cSrcweir else
5579cdf0e10cSrcweir {
5580cdf0e10cSrcweir String sStr( *aArr[ nCurArrPos ] );
5581cdf0e10cSrcweir sStr.Erase( 0, nLen );
5582cdf0e10cSrcweir sal_uInt16 nL = sStr.Len();
5583cdf0e10cSrcweir pAttrs = new sal_uInt16[ nL ];
5584cdf0e10cSrcweir for( sal_uInt16 n = nL; n; )
5585cdf0e10cSrcweir *(pAttrs + --n ) = EXTTEXTINPUT_ATTR_DOTTEDUNDERLINE |
5586cdf0e10cSrcweir EXTTEXTINPUT_ATTR_HIGHLIGHT;
5587cdf0e10cSrcweir pCETID = new CommandExtTextInputData( sStr, pAttrs, nL,
5588cdf0e10cSrcweir 0, 0, 0, sal_False );
5589cdf0e10cSrcweir rSh.CreateExtTextInput(rWin.GetInputLanguage());
5590cdf0e10cSrcweir rSh.SetExtTextInputData( *pCETID );
5591cdf0e10cSrcweir }
5592cdf0e10cSrcweir }
5593cdf0e10cSrcweir
Stop(SwWrtShell & rSh)5594cdf0e10cSrcweir void QuickHelpData::Stop( SwWrtShell& rSh )
5595cdf0e10cSrcweir {
5596cdf0e10cSrcweir if( !bIsTip )
5597cdf0e10cSrcweir rSh.DeleteExtTextInput( 0, sal_False );
5598cdf0e10cSrcweir else if( nTipId )
5599cdf0e10cSrcweir Help::HideTip( nTipId );
5600cdf0e10cSrcweir ClearCntnt();
5601cdf0e10cSrcweir }
5602cdf0e10cSrcweir
FillStrArr(SwWrtShell & rSh,const String & rWord)5603cdf0e10cSrcweir void QuickHelpData::FillStrArr( SwWrtShell& rSh, const String& rWord )
5604cdf0e10cSrcweir {
5605b10a5c0bSHerbert Dürr // #i22961# get the letter-case context
5606b10a5c0bSHerbert Dürr const CharClass& rCharClass = GetAppCharClass();
5607b10a5c0bSHerbert Dürr const String aLWord = rCharClass.toLower( rWord, 0, rWord.Len() );
5608b10a5c0bSHerbert Dürr const bool bIsUpper = (rWord == rCharClass.toUpper( rWord, 0, rWord.Len() ) );
5609b10a5c0bSHerbert Dürr const bool bIsLower = (rWord == aLWord);
5610b10a5c0bSHerbert Dürr
5611b10a5c0bSHerbert Dürr // add all matching month/day names from the calendar
5612cdf0e10cSrcweir salhelper::SingletonRef<SwCalendarWrapper>* pCalendar = s_getCalendarWrapper();
5613cdf0e10cSrcweir (*pCalendar)->LoadDefaultCalendar( rSh.GetCurLang() );
5614cdf0e10cSrcweir
5615cdf0e10cSrcweir {
5616cdf0e10cSrcweir uno::Sequence< i18n::CalendarItem > aNames(
5617cdf0e10cSrcweir (*pCalendar)->getMonths() );
5618cdf0e10cSrcweir for( int n = 0; n < 2; ++n )
5619cdf0e10cSrcweir {
5620cdf0e10cSrcweir for( long nPos = 0, nEnd = aNames.getLength(); nPos < nEnd; ++nPos )
5621cdf0e10cSrcweir {
5622b10a5c0bSHerbert Dürr const String& rS = aNames[ nPos ].FullName;
5623b10a5c0bSHerbert Dürr if( rS.Len() <= rWord.Len() + 1 )
5624b10a5c0bSHerbert Dürr continue;
5625b10a5c0bSHerbert Dürr const String aLName = rCharClass.toLower( rS, 0, rWord.Len() );
5626b10a5c0bSHerbert Dürr if( aLName != aLWord )
5627b10a5c0bSHerbert Dürr continue;
5628b10a5c0bSHerbert Dürr // #i22961# provide case-sensitive autocompletion suggestions
5629b10a5c0bSHerbert Dürr String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) );
5630b10a5c0bSHerbert Dürr if( !aArr.Insert( pNew ) )
5631b10a5c0bSHerbert Dürr delete pNew;
5632cdf0e10cSrcweir }
5633cdf0e10cSrcweir if( !n ) // get data for the second loop
5634cdf0e10cSrcweir aNames = (*pCalendar)->getDays();
5635cdf0e10cSrcweir }
5636cdf0e10cSrcweir }
5637cdf0e10cSrcweir
56383234e392SHerbert Dürr // and then add all words from the AutoCompleteWord-List
5639cdf0e10cSrcweir const SwAutoCompleteWord& rACLst = rSh.GetAutoCompleteWords();
5640cdf0e10cSrcweir sal_uInt16 nStt, nEnd;
5641cdf0e10cSrcweir if( rACLst.GetRange( rWord, nStt, nEnd ) )
5642cdf0e10cSrcweir {
56433234e392SHerbert Dürr for(; nStt < nEnd; ++nStt )
5644cdf0e10cSrcweir {
5645cdf0e10cSrcweir const String& rS = rACLst[ nStt ];
56463234e392SHerbert Dürr if( rS.Len() <= rWord.Len() )
56473234e392SHerbert Dürr continue;
56483234e392SHerbert Dürr // #i22961# provide case-sensitive autocompletion suggestions
56493234e392SHerbert Dürr String* pNew = new String( (bIsUpper==bIsLower) ? rS : (bIsUpper ? rCharClass.toUpper(rS,0,rS.Len()) : rCharClass.toLower(rS,0,rS.Len())) );
56503234e392SHerbert Dürr if( !aArr.Insert( pNew ) )
56513234e392SHerbert Dürr delete pNew;
5652cdf0e10cSrcweir }
5653cdf0e10cSrcweir }
5654cdf0e10cSrcweir }
5655b10a5c0bSHerbert Dürr
ShowAutoTextCorrectQuickHelp(const String & rWord,SvxAutoCorrCfg * pACfg,SvxAutoCorrect * pACorr,sal_Bool bFromIME)5656cdf0e10cSrcweir void SwEditWin::ShowAutoTextCorrectQuickHelp(
5657cdf0e10cSrcweir const String& rWord, SvxAutoCorrCfg* pACfg, SvxAutoCorrect* pACorr,
5658cdf0e10cSrcweir sal_Bool bFromIME )
5659cdf0e10cSrcweir {
5660cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell();
5661cdf0e10cSrcweir pQuickHlpData->ClearCntnt();
5662cdf0e10cSrcweir if( pACfg->IsAutoTextTip() )
5663cdf0e10cSrcweir {
5664cdf0e10cSrcweir SwGlossaryList* pList = ::GetGlossaryList();
5665cdf0e10cSrcweir pList->HasLongName( rWord, &pQuickHlpData->aArr );
5666cdf0e10cSrcweir }
5667cdf0e10cSrcweir
5668cdf0e10cSrcweir if( pQuickHlpData->aArr.Count() )
5669cdf0e10cSrcweir {
5670cdf0e10cSrcweir pQuickHlpData->bIsTip = sal_True;
5671cdf0e10cSrcweir pQuickHlpData->bIsAutoText = sal_True;
5672cdf0e10cSrcweir }
5673cdf0e10cSrcweir else if( pACorr->GetSwFlags().bAutoCompleteWords )
5674cdf0e10cSrcweir {
5675cdf0e10cSrcweir pQuickHlpData->bIsAutoText = sal_False;
5676cdf0e10cSrcweir pQuickHlpData->bIsTip = bFromIME ||
5677cdf0e10cSrcweir !pACorr ||
5678cdf0e10cSrcweir pACorr->GetSwFlags().bAutoCmpltShowAsTip;
5679cdf0e10cSrcweir
5680cdf0e10cSrcweir pQuickHlpData->FillStrArr( rSh, rWord );
5681cdf0e10cSrcweir }
5682cdf0e10cSrcweir
5683cdf0e10cSrcweir if( pQuickHlpData->aArr.Count() )
5684cdf0e10cSrcweir pQuickHlpData->Start( rSh, rWord.Len() );
5685cdf0e10cSrcweir }
5686cdf0e10cSrcweir
5687cdf0e10cSrcweir /* -----------------29.03.2006 11:01-----------------
5688cdf0e10cSrcweir *
5689cdf0e10cSrcweir * --------------------------------------------------*/
5690cdf0e10cSrcweir
SetUseInputLanguage(sal_Bool bNew)5691cdf0e10cSrcweir void SwEditWin::SetUseInputLanguage( sal_Bool bNew )
5692cdf0e10cSrcweir {
5693cdf0e10cSrcweir if ( bNew || bUseInputLanguage )
5694cdf0e10cSrcweir {
5695cdf0e10cSrcweir SfxBindings& rBind = GetView().GetViewFrame()->GetBindings();
5696cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_CHAR_FONT );
5697cdf0e10cSrcweir rBind.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
5698cdf0e10cSrcweir }
5699cdf0e10cSrcweir bUseInputLanguage = bNew;
5700cdf0e10cSrcweir }
5701cdf0e10cSrcweir
5702cdf0e10cSrcweir /*-- 13.11.2008 10:18:17---------------------------------------------------
5703cdf0e10cSrcweir
5704cdf0e10cSrcweir -----------------------------------------------------------------------*/
GetSurroundingText() const5705cdf0e10cSrcweir XubString SwEditWin::GetSurroundingText() const
5706cdf0e10cSrcweir {
5707cdf0e10cSrcweir String sReturn;
5708cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell();
5709cdf0e10cSrcweir if( rSh.HasSelection() && !rSh.IsMultiSelection() && rSh.IsSelOnePara() )
5710cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
5711cdf0e10cSrcweir else if( !rSh.HasSelection() )
5712cdf0e10cSrcweir {
5713cdf0e10cSrcweir SwPosition *pPos = rSh.GetCrsr()->GetPoint();
5714cdf0e10cSrcweir xub_StrLen nPos = pPos->nContent.GetIndex();
5715cdf0e10cSrcweir
5716cdf0e10cSrcweir // get the sentence around the cursor
5717cdf0e10cSrcweir rSh.HideCrsr();
5718cdf0e10cSrcweir rSh.GoStartSentence();
5719cdf0e10cSrcweir rSh.SetMark();
5720cdf0e10cSrcweir rSh.GoEndSentence();
5721cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
5722cdf0e10cSrcweir
5723cdf0e10cSrcweir pPos->nContent = nPos;
5724cdf0e10cSrcweir rSh.ClearMark();
5725cdf0e10cSrcweir rSh.HideCrsr();
5726cdf0e10cSrcweir }
5727cdf0e10cSrcweir
5728cdf0e10cSrcweir return sReturn;
5729cdf0e10cSrcweir }
5730cdf0e10cSrcweir /*-- 13.11.2008 10:18:17---------------------------------------------------
5731cdf0e10cSrcweir
5732cdf0e10cSrcweir -----------------------------------------------------------------------*/
GetSurroundingTextSelection() const5733cdf0e10cSrcweir Selection SwEditWin::GetSurroundingTextSelection() const
5734cdf0e10cSrcweir {
5735cdf0e10cSrcweir SwWrtShell& rSh = rView.GetWrtShell();
5736cdf0e10cSrcweir if( rSh.HasSelection() )
5737cdf0e10cSrcweir {
5738cdf0e10cSrcweir String sReturn;
5739cdf0e10cSrcweir rSh.GetSelectedText( sReturn, GETSELTXT_PARABRK_TO_ONLYCR );
5740cdf0e10cSrcweir return Selection( 0, sReturn.Len() );
5741cdf0e10cSrcweir }
5742cdf0e10cSrcweir else
5743cdf0e10cSrcweir {
5744cdf0e10cSrcweir // Return the position of the visible cursor in the sentence
5745cdf0e10cSrcweir // around the visible cursor.
5746cdf0e10cSrcweir SwPosition *pPos = rSh.GetCrsr()->GetPoint();
5747cdf0e10cSrcweir xub_StrLen nPos = pPos->nContent.GetIndex();
5748cdf0e10cSrcweir
5749cdf0e10cSrcweir rSh.HideCrsr();
5750cdf0e10cSrcweir rSh.GoStartSentence();
5751cdf0e10cSrcweir xub_StrLen nStartPos = rSh.GetCrsr()->GetPoint()->nContent.GetIndex();
5752cdf0e10cSrcweir
5753cdf0e10cSrcweir pPos->nContent = nPos;
5754cdf0e10cSrcweir rSh.ClearMark();
5755cdf0e10cSrcweir rSh.ShowCrsr();
5756cdf0e10cSrcweir
5757cdf0e10cSrcweir return Selection( nPos - nStartPos, nPos - nStartPos );
5758cdf0e10cSrcweir }
5759cdf0e10cSrcweir }
5760ca62e2c2SSteve Yin // MT: Removed Windows::SwitchView() introduced with IA2 CWS.
5761ca62e2c2SSteve Yin // There are other notifications for this when the active view has chnaged, so please update the code to use that event mechanism
SwitchView()5762ca62e2c2SSteve Yin void SwEditWin::SwitchView()
5763ca62e2c2SSteve Yin {
5764ca62e2c2SSteve Yin #ifdef ACCESSIBLE_LAYOUT
5765ca62e2c2SSteve Yin if (!Application::IsAccessibilityEnabled())
5766ca62e2c2SSteve Yin {
5767ca62e2c2SSteve Yin return ;
5768ca62e2c2SSteve Yin }
5769ca62e2c2SSteve Yin rView.GetWrtShell().InvalidateAccessibleFocus();
5770ca62e2c2SSteve Yin #endif
5771ca62e2c2SSteve Yin }
5772