1*b1cdbd2cSJim Jagielski /**************************************************************
2*b1cdbd2cSJim Jagielski *
3*b1cdbd2cSJim Jagielski * Licensed to the Apache Software Foundation (ASF) under one
4*b1cdbd2cSJim Jagielski * or more contributor license agreements. See the NOTICE file
5*b1cdbd2cSJim Jagielski * distributed with this work for additional information
6*b1cdbd2cSJim Jagielski * regarding copyright ownership. The ASF licenses this file
7*b1cdbd2cSJim Jagielski * to you under the Apache License, Version 2.0 (the
8*b1cdbd2cSJim Jagielski * "License"); you may not use this file except in compliance
9*b1cdbd2cSJim Jagielski * with the License. You may obtain a copy of the License at
10*b1cdbd2cSJim Jagielski *
11*b1cdbd2cSJim Jagielski * http://www.apache.org/licenses/LICENSE-2.0
12*b1cdbd2cSJim Jagielski *
13*b1cdbd2cSJim Jagielski * Unless required by applicable law or agreed to in writing,
14*b1cdbd2cSJim Jagielski * software distributed under the License is distributed on an
15*b1cdbd2cSJim Jagielski * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16*b1cdbd2cSJim Jagielski * KIND, either express or implied. See the License for the
17*b1cdbd2cSJim Jagielski * specific language governing permissions and limitations
18*b1cdbd2cSJim Jagielski * under the License.
19*b1cdbd2cSJim Jagielski *
20*b1cdbd2cSJim Jagielski *************************************************************/
21*b1cdbd2cSJim Jagielski
22*b1cdbd2cSJim Jagielski
23*b1cdbd2cSJim Jagielski
24*b1cdbd2cSJim Jagielski // MARKER(update_precomp.py): autogen include statement, do not remove
25*b1cdbd2cSJim Jagielski #include "precompiled_sw.hxx"
26*b1cdbd2cSJim Jagielski #include <com/sun/star/util/SearchOptions.hpp>
27*b1cdbd2cSJim Jagielski #include <com/sun/star/text/XTextRange.hpp>
28*b1cdbd2cSJim Jagielski #include <hintids.hxx>
29*b1cdbd2cSJim Jagielski #include <svx/svdmodel.hxx>
30*b1cdbd2cSJim Jagielski #include <editeng/frmdiritem.hxx>
31*b1cdbd2cSJim Jagielski
32*b1cdbd2cSJim Jagielski #include <SwSmartTagMgr.hxx>
33*b1cdbd2cSJim Jagielski #include <doc.hxx>
34*b1cdbd2cSJim Jagielski #include <rootfrm.hxx>
35*b1cdbd2cSJim Jagielski #include <pagefrm.hxx>
36*b1cdbd2cSJim Jagielski #include <cntfrm.hxx>
37*b1cdbd2cSJim Jagielski #include <viewimp.hxx>
38*b1cdbd2cSJim Jagielski #include <pam.hxx>
39*b1cdbd2cSJim Jagielski #include <swselectionlist.hxx>
40*b1cdbd2cSJim Jagielski #include <IBlockCursor.hxx>
41*b1cdbd2cSJim Jagielski #include "BlockCursor.hxx"
42*b1cdbd2cSJim Jagielski #include <ndtxt.hxx>
43*b1cdbd2cSJim Jagielski #include <flyfrm.hxx>
44*b1cdbd2cSJim Jagielski #include <dview.hxx>
45*b1cdbd2cSJim Jagielski #include <viewopt.hxx>
46*b1cdbd2cSJim Jagielski #include <frmtool.hxx>
47*b1cdbd2cSJim Jagielski #include <crsrsh.hxx>
48*b1cdbd2cSJim Jagielski #include <tabfrm.hxx>
49*b1cdbd2cSJim Jagielski #include <txtfrm.hxx>
50*b1cdbd2cSJim Jagielski #include <sectfrm.hxx>
51*b1cdbd2cSJim Jagielski #include <swtable.hxx>
52*b1cdbd2cSJim Jagielski #include <callnk.hxx>
53*b1cdbd2cSJim Jagielski #include <viscrs.hxx>
54*b1cdbd2cSJim Jagielski #include <section.hxx>
55*b1cdbd2cSJim Jagielski #include <docsh.hxx>
56*b1cdbd2cSJim Jagielski #include <scriptinfo.hxx>
57*b1cdbd2cSJim Jagielski #include <globdoc.hxx>
58*b1cdbd2cSJim Jagielski #include <pamtyp.hxx>
59*b1cdbd2cSJim Jagielski #include <mdiexp.hxx> // ...Percent()
60*b1cdbd2cSJim Jagielski #include <fmteiro.hxx>
61*b1cdbd2cSJim Jagielski #include <wrong.hxx> // SMARTTAGS
62*b1cdbd2cSJim Jagielski #include <unotextrange.hxx> // SMARTTAGS
63*b1cdbd2cSJim Jagielski #include <vcl/svapp.hxx>
64*b1cdbd2cSJim Jagielski #include <numrule.hxx>
65*b1cdbd2cSJim Jagielski #include <IGrammarContact.hxx>
66*b1cdbd2cSJim Jagielski
67*b1cdbd2cSJim Jagielski #include <globals.hrc>
68*b1cdbd2cSJim Jagielski
69*b1cdbd2cSJim Jagielski #include <comcore.hrc>
70*b1cdbd2cSJim Jagielski
71*b1cdbd2cSJim Jagielski using namespace com::sun::star;
72*b1cdbd2cSJim Jagielski using namespace util;
73*b1cdbd2cSJim Jagielski
74*b1cdbd2cSJim Jagielski TYPEINIT2(SwCrsrShell,ViewShell,SwModify);
75*b1cdbd2cSJim Jagielski
76*b1cdbd2cSJim Jagielski
77*b1cdbd2cSJim Jagielski // Funktion loescht, alle ueberlappenden Cursor aus einem Cursor-Ring
78*b1cdbd2cSJim Jagielski void CheckRange( SwCursor* );
79*b1cdbd2cSJim Jagielski
80*b1cdbd2cSJim Jagielski //-----------------------------------------------------------------------
81*b1cdbd2cSJim Jagielski
82*b1cdbd2cSJim Jagielski /*
83*b1cdbd2cSJim Jagielski * Ueberpruefe ob der pCurCrsr in einen schon bestehenden Bereich zeigt.
84*b1cdbd2cSJim Jagielski * Wenn ja, dann hebe den alten Bereich auf.
85*b1cdbd2cSJim Jagielski */
86*b1cdbd2cSJim Jagielski
87*b1cdbd2cSJim Jagielski
CheckRange(SwCursor * pCurCrsr)88*b1cdbd2cSJim Jagielski void CheckRange( SwCursor* pCurCrsr )
89*b1cdbd2cSJim Jagielski {
90*b1cdbd2cSJim Jagielski const SwPosition *pStt = pCurCrsr->Start(),
91*b1cdbd2cSJim Jagielski *pEnd = pCurCrsr->GetPoint() == pStt ? pCurCrsr->GetMark() : pCurCrsr->GetPoint();
92*b1cdbd2cSJim Jagielski
93*b1cdbd2cSJim Jagielski SwPaM *pTmpDel = 0,
94*b1cdbd2cSJim Jagielski *pTmp = (SwPaM*)pCurCrsr->GetNext();
95*b1cdbd2cSJim Jagielski
96*b1cdbd2cSJim Jagielski // durchsuche den gesamten Ring
97*b1cdbd2cSJim Jagielski while( pTmp != pCurCrsr )
98*b1cdbd2cSJim Jagielski {
99*b1cdbd2cSJim Jagielski const SwPosition *pTmpStt = pTmp->Start(),
100*b1cdbd2cSJim Jagielski *pTmpEnd = pTmp->GetPoint() == pTmpStt ?
101*b1cdbd2cSJim Jagielski pTmp->GetMark() : pTmp->GetPoint();
102*b1cdbd2cSJim Jagielski if( *pStt <= *pTmpStt )
103*b1cdbd2cSJim Jagielski {
104*b1cdbd2cSJim Jagielski if( *pEnd > *pTmpStt ||
105*b1cdbd2cSJim Jagielski ( *pEnd == *pTmpStt && *pEnd == *pTmpEnd ))
106*b1cdbd2cSJim Jagielski pTmpDel = pTmp;
107*b1cdbd2cSJim Jagielski }
108*b1cdbd2cSJim Jagielski else
109*b1cdbd2cSJim Jagielski if( *pStt < *pTmpEnd )
110*b1cdbd2cSJim Jagielski pTmpDel = pTmp;
111*b1cdbd2cSJim Jagielski /*
112*b1cdbd2cSJim Jagielski * liegt ein SPoint oder GetMark innerhalb vom Crsr-Bereich
113*b1cdbd2cSJim Jagielski * muss der alte Bereich aufgehoben werden.
114*b1cdbd2cSJim Jagielski * Beim Vergleich ist darauf zu achten, das SPoint nicht mehr zum
115*b1cdbd2cSJim Jagielski * Bereich gehoert !
116*b1cdbd2cSJim Jagielski */
117*b1cdbd2cSJim Jagielski pTmp = (SwPaM*)pTmp->GetNext();
118*b1cdbd2cSJim Jagielski if( pTmpDel )
119*b1cdbd2cSJim Jagielski {
120*b1cdbd2cSJim Jagielski delete pTmpDel; // hebe alten Bereich auf
121*b1cdbd2cSJim Jagielski pTmpDel = 0;
122*b1cdbd2cSJim Jagielski }
123*b1cdbd2cSJim Jagielski }
124*b1cdbd2cSJim Jagielski }
125*b1cdbd2cSJim Jagielski
126*b1cdbd2cSJim Jagielski // -------------- Methoden von der SwCrsrShell -------------
127*b1cdbd2cSJim Jagielski
CreateCrsr()128*b1cdbd2cSJim Jagielski SwPaM * SwCrsrShell::CreateCrsr()
129*b1cdbd2cSJim Jagielski {
130*b1cdbd2cSJim Jagielski // Innerhalb der Tabellen-SSelection keinen neuen Crsr anlegen
131*b1cdbd2cSJim Jagielski ASSERT( !IsTableMode(), "in Tabellen SSelection" );
132*b1cdbd2cSJim Jagielski
133*b1cdbd2cSJim Jagielski // neuen Cursor als Kopie vom akt. und in den Ring aufnehmen
134*b1cdbd2cSJim Jagielski // Verkettung zeigt immer auf den zuerst erzeugten, also vorwaerts
135*b1cdbd2cSJim Jagielski SwShellCrsr* pNew = new SwShellCrsr( *pCurCrsr );
136*b1cdbd2cSJim Jagielski
137*b1cdbd2cSJim Jagielski // hier den akt. Pam nur logisch Hiden, weil sonst die Invertierung
138*b1cdbd2cSJim Jagielski // vom kopierten Pam aufgehoben wird !!
139*b1cdbd2cSJim Jagielski
140*b1cdbd2cSJim Jagielski // #i75172# to be able to make a complete content swap, i moved this to a method
141*b1cdbd2cSJim Jagielski // pNew->Insert( pCurCrsr, 0 );
142*b1cdbd2cSJim Jagielski // pCurCrsr->Remove( 0, pCurCrsr->Count() );
143*b1cdbd2cSJim Jagielski pNew->swapContent(*pCurCrsr);
144*b1cdbd2cSJim Jagielski
145*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
146*b1cdbd2cSJim Jagielski
147*b1cdbd2cSJim Jagielski UpdateCrsr( SwCrsrShell::SCROLLWIN );
148*b1cdbd2cSJim Jagielski // return pCurCrsr;
149*b1cdbd2cSJim Jagielski return pNew;
150*b1cdbd2cSJim Jagielski }
151*b1cdbd2cSJim Jagielski
152*b1cdbd2cSJim Jagielski // loesche den aktuellen Cursor und der folgende wird zum Aktuellen
153*b1cdbd2cSJim Jagielski
154*b1cdbd2cSJim Jagielski
DestroyCrsr()155*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::DestroyCrsr()
156*b1cdbd2cSJim Jagielski {
157*b1cdbd2cSJim Jagielski // Innerhalb der Tabellen-SSelection keinen neuen Crsr loeschen
158*b1cdbd2cSJim Jagielski ASSERT( !IsTableMode(), "in Tabellen SSelection" );
159*b1cdbd2cSJim Jagielski
160*b1cdbd2cSJim Jagielski // ist ueberhaupt ein naechtser vorhanden ?
161*b1cdbd2cSJim Jagielski if(pCurCrsr->GetNext() == pCurCrsr)
162*b1cdbd2cSJim Jagielski return sal_False;
163*b1cdbd2cSJim Jagielski
164*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen,
165*b1cdbd2cSJim Jagielski SwCursor* pNextCrsr = (SwCursor*)pCurCrsr->GetNext();
166*b1cdbd2cSJim Jagielski delete pCurCrsr;
167*b1cdbd2cSJim Jagielski pCurCrsr = dynamic_cast<SwShellCrsr*>(pNextCrsr);
168*b1cdbd2cSJim Jagielski UpdateCrsr();
169*b1cdbd2cSJim Jagielski return sal_True;
170*b1cdbd2cSJim Jagielski }
171*b1cdbd2cSJim Jagielski
172*b1cdbd2cSJim Jagielski
CreateNewShellCursor()173*b1cdbd2cSJim Jagielski SwPaM & SwCrsrShell::CreateNewShellCursor()
174*b1cdbd2cSJim Jagielski {
175*b1cdbd2cSJim Jagielski if (HasSelection())
176*b1cdbd2cSJim Jagielski {
177*b1cdbd2cSJim Jagielski (void) CreateCrsr(); // n.b. returns old cursor
178*b1cdbd2cSJim Jagielski }
179*b1cdbd2cSJim Jagielski return *GetCrsr();
180*b1cdbd2cSJim Jagielski }
181*b1cdbd2cSJim Jagielski
GetCurrentShellCursor()182*b1cdbd2cSJim Jagielski SwPaM & SwCrsrShell::GetCurrentShellCursor()
183*b1cdbd2cSJim Jagielski {
184*b1cdbd2cSJim Jagielski return *GetCrsr();
185*b1cdbd2cSJim Jagielski }
186*b1cdbd2cSJim Jagielski
187*b1cdbd2cSJim Jagielski
188*b1cdbd2cSJim Jagielski // gebe den aktuellen zurueck
189*b1cdbd2cSJim Jagielski
GetCrsr(sal_Bool bMakeTblCrsr) const190*b1cdbd2cSJim Jagielski SwPaM* SwCrsrShell::GetCrsr( sal_Bool bMakeTblCrsr ) const
191*b1cdbd2cSJim Jagielski {
192*b1cdbd2cSJim Jagielski if( pTblCrsr )
193*b1cdbd2cSJim Jagielski {
194*b1cdbd2cSJim Jagielski if( bMakeTblCrsr && pTblCrsr->IsCrsrMovedUpdt() )
195*b1cdbd2cSJim Jagielski {
196*b1cdbd2cSJim Jagielski // geparkte Cursor werden nicht wieder erzeugt
197*b1cdbd2cSJim Jagielski const SwCntntNode* pCNd;
198*b1cdbd2cSJim Jagielski if( pTblCrsr->GetPoint()->nNode.GetIndex() &&
199*b1cdbd2cSJim Jagielski pTblCrsr->GetMark()->nNode.GetIndex() &&
200*b1cdbd2cSJim Jagielski 0 != ( pCNd = pTblCrsr->GetCntntNode() ) && pCNd->getLayoutFrm( GetLayout() ) &&
201*b1cdbd2cSJim Jagielski 0 != ( pCNd = pTblCrsr->GetCntntNode(sal_False) ) && pCNd->getLayoutFrm( GetLayout() ) )
202*b1cdbd2cSJim Jagielski {
203*b1cdbd2cSJim Jagielski SwShellTableCrsr* pTC = (SwShellTableCrsr*)pTblCrsr;
204*b1cdbd2cSJim Jagielski GetLayout()->MakeTblCrsrs( *pTC );
205*b1cdbd2cSJim Jagielski }
206*b1cdbd2cSJim Jagielski }
207*b1cdbd2cSJim Jagielski
208*b1cdbd2cSJim Jagielski if( pTblCrsr->IsChgd() )
209*b1cdbd2cSJim Jagielski {
210*b1cdbd2cSJim Jagielski const_cast<SwCrsrShell*>(this)->pCurCrsr =
211*b1cdbd2cSJim Jagielski dynamic_cast<SwShellCrsr*>(pTblCrsr->MakeBoxSels( pCurCrsr ));
212*b1cdbd2cSJim Jagielski }
213*b1cdbd2cSJim Jagielski }
214*b1cdbd2cSJim Jagielski return pCurCrsr;
215*b1cdbd2cSJim Jagielski }
216*b1cdbd2cSJim Jagielski
217*b1cdbd2cSJim Jagielski
StartAction()218*b1cdbd2cSJim Jagielski void SwCrsrShell::StartAction()
219*b1cdbd2cSJim Jagielski {
220*b1cdbd2cSJim Jagielski if( !ActionPend() )
221*b1cdbd2cSJim Jagielski {
222*b1cdbd2cSJim Jagielski // fuer das Update des Ribbon-Bars merken
223*b1cdbd2cSJim Jagielski const SwNode& rNd = pCurCrsr->GetPoint()->nNode.GetNode();
224*b1cdbd2cSJim Jagielski nAktNode = rNd.GetIndex();
225*b1cdbd2cSJim Jagielski nAktCntnt = pCurCrsr->GetPoint()->nContent.GetIndex();
226*b1cdbd2cSJim Jagielski nAktNdTyp = rNd.GetNodeType();
227*b1cdbd2cSJim Jagielski bAktSelection = *pCurCrsr->GetPoint() != *pCurCrsr->GetMark();
228*b1cdbd2cSJim Jagielski if( ND_TEXTNODE & nAktNdTyp )
229*b1cdbd2cSJim Jagielski nLeftFrmPos = SwCallLink::getLayoutFrm( GetLayout(), (SwTxtNode&)rNd, nAktCntnt, sal_True );
230*b1cdbd2cSJim Jagielski else
231*b1cdbd2cSJim Jagielski nLeftFrmPos = 0;
232*b1cdbd2cSJim Jagielski }
233*b1cdbd2cSJim Jagielski ViewShell::StartAction(); // zur ViewShell
234*b1cdbd2cSJim Jagielski }
235*b1cdbd2cSJim Jagielski
236*b1cdbd2cSJim Jagielski
EndAction(const sal_Bool bIdleEnd)237*b1cdbd2cSJim Jagielski void SwCrsrShell::EndAction( const sal_Bool bIdleEnd )
238*b1cdbd2cSJim Jagielski {
239*b1cdbd2cSJim Jagielski /*
240*b1cdbd2cSJim Jagielski //OS: Wird z.B. eine Basic-Action im Hintergrund ausgefuehrt, geht es so nicht
241*b1cdbd2cSJim Jagielski if( !bHasFocus )
242*b1cdbd2cSJim Jagielski {
243*b1cdbd2cSJim Jagielski // hat die Shell nicht den Focus, dann nur das EndAction an
244*b1cdbd2cSJim Jagielski // die ViewShell weitergeben.
245*b1cdbd2cSJim Jagielski ViewShell::EndAction( bIdleEnd );
246*b1cdbd2cSJim Jagielski return;
247*b1cdbd2cSJim Jagielski }
248*b1cdbd2cSJim Jagielski */
249*b1cdbd2cSJim Jagielski
250*b1cdbd2cSJim Jagielski sal_Bool bVis = bSVCrsrVis;
251*b1cdbd2cSJim Jagielski
252*b1cdbd2cSJim Jagielski // Idle-Formatierung ?
253*b1cdbd2cSJim Jagielski if( bIdleEnd && Imp()->GetRegion() )
254*b1cdbd2cSJim Jagielski {
255*b1cdbd2cSJim Jagielski pCurCrsr->Hide();
256*b1cdbd2cSJim Jagielski
257*b1cdbd2cSJim Jagielski #ifdef SHOW_IDLE_REGION
258*b1cdbd2cSJim Jagielski if( GetWin() )
259*b1cdbd2cSJim Jagielski {
260*b1cdbd2cSJim Jagielski GetWin()->Push();
261*b1cdbd2cSJim Jagielski GetWin()->ChangePen( Pen( Color( COL_YELLOW )));
262*b1cdbd2cSJim Jagielski for( sal_uInt16 n = 0; n < aPntReg.Count(); ++n )
263*b1cdbd2cSJim Jagielski {
264*b1cdbd2cSJim Jagielski SwRect aIRect( aPntReg[n] );
265*b1cdbd2cSJim Jagielski GetWin()->DrawRect( aIRect.SVRect() );
266*b1cdbd2cSJim Jagielski }
267*b1cdbd2cSJim Jagielski GetWin()->Pop();
268*b1cdbd2cSJim Jagielski }
269*b1cdbd2cSJim Jagielski #endif
270*b1cdbd2cSJim Jagielski
271*b1cdbd2cSJim Jagielski }
272*b1cdbd2cSJim Jagielski
273*b1cdbd2cSJim Jagielski // vor der letzten Action alle invaliden Numerierungen updaten
274*b1cdbd2cSJim Jagielski if( 1 == nStartAction )
275*b1cdbd2cSJim Jagielski GetDoc()->UpdateNumRule();
276*b1cdbd2cSJim Jagielski
277*b1cdbd2cSJim Jagielski // Task: 76923: dont show the cursor in the ViewShell::EndAction() - call.
278*b1cdbd2cSJim Jagielski // Only the UpdateCrsr shows the cursor.
279*b1cdbd2cSJim Jagielski sal_Bool bSavSVCrsrVis = bSVCrsrVis;
280*b1cdbd2cSJim Jagielski bSVCrsrVis = sal_False;
281*b1cdbd2cSJim Jagielski
282*b1cdbd2cSJim Jagielski ViewShell::EndAction( bIdleEnd ); //der ViewShell den Vortritt lassen
283*b1cdbd2cSJim Jagielski
284*b1cdbd2cSJim Jagielski bSVCrsrVis = bSavSVCrsrVis;
285*b1cdbd2cSJim Jagielski
286*b1cdbd2cSJim Jagielski if( ActionPend() )
287*b1cdbd2cSJim Jagielski {
288*b1cdbd2cSJim Jagielski if( bVis ) // auch SV-Cursor wieder anzeigen
289*b1cdbd2cSJim Jagielski pVisCrsr->Show();
290*b1cdbd2cSJim Jagielski
291*b1cdbd2cSJim Jagielski // falls noch ein ChgCall vorhanden ist und nur noch die Basic
292*b1cdbd2cSJim Jagielski // Klammerung vorhanden ist, dann rufe ihn. Dadurch wird die interne
293*b1cdbd2cSJim Jagielski // mit der Basic-Klammerung entkoppelt; die Shells werden umgeschaltet
294*b1cdbd2cSJim Jagielski if( !BasicActionPend() )
295*b1cdbd2cSJim Jagielski {
296*b1cdbd2cSJim Jagielski //JP 12.01.98: Bug #46496# - es muss innerhalb einer BasicAction
297*b1cdbd2cSJim Jagielski // der Cursor geupdatet werden; um z.B. den
298*b1cdbd2cSJim Jagielski // TabellenCursor zu erzeugen. Im UpdateCrsr wird
299*b1cdbd2cSJim Jagielski // das jetzt beruecksichtigt!
300*b1cdbd2cSJim Jagielski UpdateCrsr( SwCrsrShell::CHKRANGE, bIdleEnd );
301*b1cdbd2cSJim Jagielski
302*b1cdbd2cSJim Jagielski {
303*b1cdbd2cSJim Jagielski // Crsr-Moves ueberwachen, evt. Link callen
304*b1cdbd2cSJim Jagielski // der DTOR ist das interressante!!
305*b1cdbd2cSJim Jagielski SwCallLink aLk( *this, nAktNode, nAktCntnt, (sal_uInt8)nAktNdTyp,
306*b1cdbd2cSJim Jagielski nLeftFrmPos, bAktSelection );
307*b1cdbd2cSJim Jagielski
308*b1cdbd2cSJim Jagielski }
309*b1cdbd2cSJim Jagielski if( bCallChgLnk && bChgCallFlag && aChgLnk.IsSet() )
310*b1cdbd2cSJim Jagielski {
311*b1cdbd2cSJim Jagielski aChgLnk.Call( this );
312*b1cdbd2cSJim Jagielski bChgCallFlag = sal_False; // Flag zuruecksetzen
313*b1cdbd2cSJim Jagielski }
314*b1cdbd2cSJim Jagielski }
315*b1cdbd2cSJim Jagielski return;
316*b1cdbd2cSJim Jagielski }
317*b1cdbd2cSJim Jagielski
318*b1cdbd2cSJim Jagielski sal_uInt16 nParm = SwCrsrShell::CHKRANGE;
319*b1cdbd2cSJim Jagielski if ( !bIdleEnd )
320*b1cdbd2cSJim Jagielski nParm |= SwCrsrShell::SCROLLWIN;
321*b1cdbd2cSJim Jagielski // if( !IsViewLocked() )
322*b1cdbd2cSJim Jagielski UpdateCrsr( nParm, bIdleEnd ); // Cursor-Aenderungen anzeigen
323*b1cdbd2cSJim Jagielski
324*b1cdbd2cSJim Jagielski {
325*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen,
326*b1cdbd2cSJim Jagielski aLk.nNode = nAktNode; // evt. Link callen
327*b1cdbd2cSJim Jagielski aLk.nNdTyp = (sal_uInt8)nAktNdTyp;
328*b1cdbd2cSJim Jagielski aLk.nCntnt = nAktCntnt;
329*b1cdbd2cSJim Jagielski aLk.nLeftFrmPos = nLeftFrmPos;
330*b1cdbd2cSJim Jagielski
331*b1cdbd2cSJim Jagielski if( !nCrsrMove ||
332*b1cdbd2cSJim Jagielski ( 1 == nCrsrMove && bInCMvVisportChgd ) )
333*b1cdbd2cSJim Jagielski ShowCrsrs( bSVCrsrVis ? sal_True : sal_False ); // Cursor & Selektionen wieder anzeigen
334*b1cdbd2cSJim Jagielski }
335*b1cdbd2cSJim Jagielski // falls noch ein ChgCall vorhanden ist, dann rufe ihn
336*b1cdbd2cSJim Jagielski if( bCallChgLnk && bChgCallFlag && aChgLnk.IsSet() )
337*b1cdbd2cSJim Jagielski {
338*b1cdbd2cSJim Jagielski aChgLnk.Call( this );
339*b1cdbd2cSJim Jagielski bChgCallFlag = sal_False; // Flag zuruecksetzen
340*b1cdbd2cSJim Jagielski }
341*b1cdbd2cSJim Jagielski }
342*b1cdbd2cSJim Jagielski
343*b1cdbd2cSJim Jagielski
344*b1cdbd2cSJim Jagielski #if defined(DBG_UTIL)
345*b1cdbd2cSJim Jagielski
SttCrsrMove()346*b1cdbd2cSJim Jagielski void SwCrsrShell::SttCrsrMove()
347*b1cdbd2cSJim Jagielski {
348*b1cdbd2cSJim Jagielski ASSERT( nCrsrMove < USHRT_MAX, "To many nested CrsrMoves." );
349*b1cdbd2cSJim Jagielski ++nCrsrMove;
350*b1cdbd2cSJim Jagielski StartAction();
351*b1cdbd2cSJim Jagielski }
352*b1cdbd2cSJim Jagielski
EndCrsrMove(const sal_Bool bIdleEnd)353*b1cdbd2cSJim Jagielski void SwCrsrShell::EndCrsrMove( const sal_Bool bIdleEnd )
354*b1cdbd2cSJim Jagielski {
355*b1cdbd2cSJim Jagielski ASSERT( nCrsrMove, "EndCrsrMove() ohne SttCrsrMove()." );
356*b1cdbd2cSJim Jagielski EndAction( bIdleEnd );
357*b1cdbd2cSJim Jagielski if( !--nCrsrMove )
358*b1cdbd2cSJim Jagielski bInCMvVisportChgd = sal_False;
359*b1cdbd2cSJim Jagielski }
360*b1cdbd2cSJim Jagielski
361*b1cdbd2cSJim Jagielski #endif
362*b1cdbd2cSJim Jagielski
363*b1cdbd2cSJim Jagielski
LeftRight(sal_Bool bLeft,sal_uInt16 nCnt,sal_uInt16 nMode,sal_Bool bVisualAllowed)364*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::LeftRight( sal_Bool bLeft, sal_uInt16 nCnt, sal_uInt16 nMode,
365*b1cdbd2cSJim Jagielski sal_Bool bVisualAllowed )
366*b1cdbd2cSJim Jagielski {
367*b1cdbd2cSJim Jagielski if( IsTableMode() )
368*b1cdbd2cSJim Jagielski return bLeft ? GoPrevCell() : GoNextCell();
369*b1cdbd2cSJim Jagielski
370*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
371*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
372*b1cdbd2cSJim Jagielski
373*b1cdbd2cSJim Jagielski // #i27615# Handle cursor in front of label.
374*b1cdbd2cSJim Jagielski const SwTxtNode* pTxtNd = 0;
375*b1cdbd2cSJim Jagielski
376*b1cdbd2cSJim Jagielski if( pBlockCrsr )
377*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
378*b1cdbd2cSJim Jagielski
379*b1cdbd2cSJim Jagielski //
380*b1cdbd2cSJim Jagielski // 1. CASE: Cursor is in front of label. A move to the right
381*b1cdbd2cSJim Jagielski // will simply reset the bInFrontOfLabel flag:
382*b1cdbd2cSJim Jagielski //
383*b1cdbd2cSJim Jagielski SwShellCrsr* pShellCrsr = getShellCrsr( true );
384*b1cdbd2cSJim Jagielski if ( !bLeft && pShellCrsr->IsInFrontOfLabel() )
385*b1cdbd2cSJim Jagielski {
386*b1cdbd2cSJim Jagielski SetInFrontOfLabel( sal_False );
387*b1cdbd2cSJim Jagielski bRet = sal_True;
388*b1cdbd2cSJim Jagielski }
389*b1cdbd2cSJim Jagielski //
390*b1cdbd2cSJim Jagielski // 2. CASE: Cursor is at beginning of numbered paragraph. A move
391*b1cdbd2cSJim Jagielski // to the left will simply set the bInFrontOfLabel flag:
392*b1cdbd2cSJim Jagielski //
393*b1cdbd2cSJim Jagielski else if ( bLeft && 0 == pShellCrsr->GetPoint()->nContent.GetIndex() &&
394*b1cdbd2cSJim Jagielski !pShellCrsr->IsInFrontOfLabel() && !pShellCrsr->HasMark() &&
395*b1cdbd2cSJim Jagielski 0 != ( pTxtNd = pShellCrsr->GetNode()->GetTxtNode() ) &&
396*b1cdbd2cSJim Jagielski pTxtNd->HasVisibleNumberingOrBullet() )
397*b1cdbd2cSJim Jagielski {
398*b1cdbd2cSJim Jagielski SetInFrontOfLabel( sal_True );
399*b1cdbd2cSJim Jagielski bRet = sal_True;
400*b1cdbd2cSJim Jagielski }
401*b1cdbd2cSJim Jagielski //
402*b1cdbd2cSJim Jagielski // 3. CASE: Regular cursor move. Reset the bInFrontOfLabel flag:
403*b1cdbd2cSJim Jagielski //
404*b1cdbd2cSJim Jagielski else
405*b1cdbd2cSJim Jagielski {
406*b1cdbd2cSJim Jagielski const sal_Bool bSkipHidden = !GetViewOptions()->IsShowHiddenChar();
407*b1cdbd2cSJim Jagielski // --> OD 2009-12-30 #i107447#
408*b1cdbd2cSJim Jagielski // To avoid loop the reset of <bInFrontOfLabel> flag is no longer
409*b1cdbd2cSJim Jagielski // reflected in the return value <bRet>.
410*b1cdbd2cSJim Jagielski const bool bResetOfInFrontOfLabel = SetInFrontOfLabel( sal_False );
411*b1cdbd2cSJim Jagielski bRet = pShellCrsr->LeftRight( bLeft, nCnt, nMode, bVisualAllowed,
412*b1cdbd2cSJim Jagielski bSkipHidden, !IsOverwriteCrsr() );
413*b1cdbd2cSJim Jagielski if ( !bRet && bLeft && bResetOfInFrontOfLabel )
414*b1cdbd2cSJim Jagielski {
415*b1cdbd2cSJim Jagielski // undo reset of <bInFrontOfLabel> flag
416*b1cdbd2cSJim Jagielski SetInFrontOfLabel( sal_True );
417*b1cdbd2cSJim Jagielski }
418*b1cdbd2cSJim Jagielski // <--
419*b1cdbd2cSJim Jagielski }
420*b1cdbd2cSJim Jagielski
421*b1cdbd2cSJim Jagielski if( bRet )
422*b1cdbd2cSJim Jagielski {
423*b1cdbd2cSJim Jagielski UpdateCrsr();
424*b1cdbd2cSJim Jagielski }
425*b1cdbd2cSJim Jagielski return bRet;
426*b1cdbd2cSJim Jagielski }
FirePageChangeEvent(sal_uInt16 nOldPage,sal_uInt16 nNewPage)427*b1cdbd2cSJim Jagielski void SwCrsrShell::FirePageChangeEvent(sal_uInt16 nOldPage, sal_uInt16 nNewPage)
428*b1cdbd2cSJim Jagielski {
429*b1cdbd2cSJim Jagielski #ifdef ACCESSIBLE_LAYOUT
430*b1cdbd2cSJim Jagielski if( Imp()->IsAccessible() )
431*b1cdbd2cSJim Jagielski Imp()->FirePageChangeEvent( nOldPage, nNewPage );
432*b1cdbd2cSJim Jagielski #endif
433*b1cdbd2cSJim Jagielski }
434*b1cdbd2cSJim Jagielski
FireColumnChangeEvent(sal_uInt16 nOldColumn,sal_uInt16 nNewColumn)435*b1cdbd2cSJim Jagielski void SwCrsrShell::FireColumnChangeEvent(sal_uInt16 nOldColumn, sal_uInt16 nNewColumn)
436*b1cdbd2cSJim Jagielski {
437*b1cdbd2cSJim Jagielski #ifdef ACCESSIBLE_LAYOUT
438*b1cdbd2cSJim Jagielski if( Imp()->IsAccessible() )
439*b1cdbd2cSJim Jagielski Imp()->FireColumnChangeEvent( nOldColumn, nNewColumn);
440*b1cdbd2cSJim Jagielski #endif
441*b1cdbd2cSJim Jagielski }
442*b1cdbd2cSJim Jagielski
443*b1cdbd2cSJim Jagielski
FireSectionChangeEvent(sal_uInt16 nOldSection,sal_uInt16 nNewSection)444*b1cdbd2cSJim Jagielski void SwCrsrShell::FireSectionChangeEvent(sal_uInt16 nOldSection, sal_uInt16 nNewSection)
445*b1cdbd2cSJim Jagielski {
446*b1cdbd2cSJim Jagielski #ifdef ACCESSIBLE_LAYOUT
447*b1cdbd2cSJim Jagielski if( Imp()->IsAccessible() )
448*b1cdbd2cSJim Jagielski Imp()->FireSectionChangeEvent( nOldSection, nNewSection );
449*b1cdbd2cSJim Jagielski #endif
450*b1cdbd2cSJim Jagielski }
bColumnChange()451*b1cdbd2cSJim Jagielski bool SwCrsrShell::bColumnChange()
452*b1cdbd2cSJim Jagielski {
453*b1cdbd2cSJim Jagielski
454*b1cdbd2cSJim Jagielski SwFrm* pCurrFrm = GetCurrFrm(sal_False);
455*b1cdbd2cSJim Jagielski
456*b1cdbd2cSJim Jagielski if (pCurrFrm == NULL)
457*b1cdbd2cSJim Jagielski {
458*b1cdbd2cSJim Jagielski return sal_False;
459*b1cdbd2cSJim Jagielski }
460*b1cdbd2cSJim Jagielski
461*b1cdbd2cSJim Jagielski SwFrm* pCurrCol=((SwFrm*)pCurrFrm)->FindColFrm();
462*b1cdbd2cSJim Jagielski
463*b1cdbd2cSJim Jagielski while(pCurrCol== NULL && pCurrFrm!=NULL )
464*b1cdbd2cSJim Jagielski {
465*b1cdbd2cSJim Jagielski SwLayoutFrm* pParent = pCurrFrm->GetUpper();
466*b1cdbd2cSJim Jagielski if(pParent!=NULL)
467*b1cdbd2cSJim Jagielski {
468*b1cdbd2cSJim Jagielski pCurrCol=((SwFrm*)pParent)->FindColFrm();
469*b1cdbd2cSJim Jagielski pCurrFrm = (SwFrm*)pParent;
470*b1cdbd2cSJim Jagielski }
471*b1cdbd2cSJim Jagielski else
472*b1cdbd2cSJim Jagielski {
473*b1cdbd2cSJim Jagielski break;
474*b1cdbd2cSJim Jagielski }
475*b1cdbd2cSJim Jagielski }
476*b1cdbd2cSJim Jagielski if(oldColFrm == pCurrCol)
477*b1cdbd2cSJim Jagielski return sal_False;
478*b1cdbd2cSJim Jagielski else
479*b1cdbd2cSJim Jagielski {
480*b1cdbd2cSJim Jagielski oldColFrm = pCurrCol;
481*b1cdbd2cSJim Jagielski return sal_True;
482*b1cdbd2cSJim Jagielski }
483*b1cdbd2cSJim Jagielski }
484*b1cdbd2cSJim Jagielski
485*b1cdbd2cSJim Jagielski // --> OD 2008-04-02 #refactorlists#
MarkListLevel(const String & sListId,const int nListLevel)486*b1cdbd2cSJim Jagielski void SwCrsrShell::MarkListLevel( const String& sListId,
487*b1cdbd2cSJim Jagielski const int nListLevel )
488*b1cdbd2cSJim Jagielski {
489*b1cdbd2cSJim Jagielski if ( sListId != sMarkedListId ||
490*b1cdbd2cSJim Jagielski nListLevel != nMarkedListLevel)
491*b1cdbd2cSJim Jagielski {
492*b1cdbd2cSJim Jagielski if ( sMarkedListId.Len() > 0 )
493*b1cdbd2cSJim Jagielski pDoc->MarkListLevel( sMarkedListId, nMarkedListLevel, sal_False );
494*b1cdbd2cSJim Jagielski
495*b1cdbd2cSJim Jagielski if ( sListId.Len() > 0 )
496*b1cdbd2cSJim Jagielski {
497*b1cdbd2cSJim Jagielski pDoc->MarkListLevel( sListId, nListLevel, sal_True );
498*b1cdbd2cSJim Jagielski }
499*b1cdbd2cSJim Jagielski
500*b1cdbd2cSJim Jagielski sMarkedListId = sListId;
501*b1cdbd2cSJim Jagielski nMarkedListLevel = nListLevel;
502*b1cdbd2cSJim Jagielski }
503*b1cdbd2cSJim Jagielski }
504*b1cdbd2cSJim Jagielski
UpdateMarkedListLevel()505*b1cdbd2cSJim Jagielski void SwCrsrShell::UpdateMarkedListLevel()
506*b1cdbd2cSJim Jagielski {
507*b1cdbd2cSJim Jagielski SwTxtNode * pTxtNd = _GetCrsr()->GetNode()->GetTxtNode();
508*b1cdbd2cSJim Jagielski
509*b1cdbd2cSJim Jagielski if ( pTxtNd )
510*b1cdbd2cSJim Jagielski {
511*b1cdbd2cSJim Jagielski if ( !pTxtNd->IsNumbered() )
512*b1cdbd2cSJim Jagielski {
513*b1cdbd2cSJim Jagielski pCurCrsr->_SetInFrontOfLabel( sal_False );
514*b1cdbd2cSJim Jagielski MarkListLevel( String(), 0 );
515*b1cdbd2cSJim Jagielski }
516*b1cdbd2cSJim Jagielski else if ( pCurCrsr->IsInFrontOfLabel() )
517*b1cdbd2cSJim Jagielski {
518*b1cdbd2cSJim Jagielski if ( pTxtNd->IsInList() )
519*b1cdbd2cSJim Jagielski {
520*b1cdbd2cSJim Jagielski ASSERT( pTxtNd->GetActualListLevel() >= 0 &&
521*b1cdbd2cSJim Jagielski pTxtNd->GetActualListLevel() < MAXLEVEL, "Which level?")
522*b1cdbd2cSJim Jagielski MarkListLevel( pTxtNd->GetListId(),
523*b1cdbd2cSJim Jagielski pTxtNd->GetActualListLevel() );
524*b1cdbd2cSJim Jagielski }
525*b1cdbd2cSJim Jagielski }
526*b1cdbd2cSJim Jagielski else
527*b1cdbd2cSJim Jagielski {
528*b1cdbd2cSJim Jagielski MarkListLevel( String(), 0 );
529*b1cdbd2cSJim Jagielski }
530*b1cdbd2cSJim Jagielski }
531*b1cdbd2cSJim Jagielski }
532*b1cdbd2cSJim Jagielski // <--
533*b1cdbd2cSJim Jagielski
UpDown(sal_Bool bUp,sal_uInt16 nCnt)534*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::UpDown( sal_Bool bUp, sal_uInt16 nCnt )
535*b1cdbd2cSJim Jagielski {
536*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
537*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
538*b1cdbd2cSJim Jagielski
539*b1cdbd2cSJim Jagielski sal_Bool bTableMode = IsTableMode();
540*b1cdbd2cSJim Jagielski SwShellCrsr* pTmpCrsr = getShellCrsr( true );
541*b1cdbd2cSJim Jagielski
542*b1cdbd2cSJim Jagielski sal_Bool bRet = pTmpCrsr->UpDown( bUp, nCnt );
543*b1cdbd2cSJim Jagielski // --> FME 2005-01-10 #i40019# UpDown should always reset the
544*b1cdbd2cSJim Jagielski // bInFrontOfLabel flag:
545*b1cdbd2cSJim Jagielski bRet = SetInFrontOfLabel(sal_False) || bRet;
546*b1cdbd2cSJim Jagielski // <--
547*b1cdbd2cSJim Jagielski
548*b1cdbd2cSJim Jagielski if( pBlockCrsr )
549*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
550*b1cdbd2cSJim Jagielski
551*b1cdbd2cSJim Jagielski if( bRet )
552*b1cdbd2cSJim Jagielski {
553*b1cdbd2cSJim Jagielski eMvState = MV_UPDOWN; // Status fuers Crsr-Travelling - GetCrsrOfst
554*b1cdbd2cSJim Jagielski if( !ActionPend() )
555*b1cdbd2cSJim Jagielski {
556*b1cdbd2cSJim Jagielski CrsrFlag eUpdtMode = SwCrsrShell::SCROLLWIN;
557*b1cdbd2cSJim Jagielski if( !bTableMode )
558*b1cdbd2cSJim Jagielski eUpdtMode = (CrsrFlag) (eUpdtMode
559*b1cdbd2cSJim Jagielski | SwCrsrShell::UPDOWN | SwCrsrShell::CHKRANGE);
560*b1cdbd2cSJim Jagielski UpdateCrsr( static_cast<sal_uInt16>(eUpdtMode) );
561*b1cdbd2cSJim Jagielski }
562*b1cdbd2cSJim Jagielski }
563*b1cdbd2cSJim Jagielski return bRet;
564*b1cdbd2cSJim Jagielski }
565*b1cdbd2cSJim Jagielski
566*b1cdbd2cSJim Jagielski
LRMargin(sal_Bool bLeft,sal_Bool bAPI)567*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::LRMargin( sal_Bool bLeft, sal_Bool bAPI)
568*b1cdbd2cSJim Jagielski {
569*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
570*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
571*b1cdbd2cSJim Jagielski eMvState = MV_LEFTMARGIN; // Status fuers Crsr-Travelling - GetCrsrOfst
572*b1cdbd2cSJim Jagielski
573*b1cdbd2cSJim Jagielski const sal_Bool bTableMode = IsTableMode();
574*b1cdbd2cSJim Jagielski SwShellCrsr* pTmpCrsr = getShellCrsr( true );
575*b1cdbd2cSJim Jagielski
576*b1cdbd2cSJim Jagielski if( pBlockCrsr )
577*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
578*b1cdbd2cSJim Jagielski
579*b1cdbd2cSJim Jagielski const sal_Bool bWasAtLM =
580*b1cdbd2cSJim Jagielski ( 0 == _GetCrsr()->GetPoint()->nContent.GetIndex() );
581*b1cdbd2cSJim Jagielski
582*b1cdbd2cSJim Jagielski sal_Bool bRet = pTmpCrsr->LeftRightMargin( bLeft, bAPI );
583*b1cdbd2cSJim Jagielski
584*b1cdbd2cSJim Jagielski if ( bLeft && !bTableMode && bRet && bWasAtLM && !_GetCrsr()->HasMark() )
585*b1cdbd2cSJim Jagielski {
586*b1cdbd2cSJim Jagielski const SwTxtNode * pTxtNd = _GetCrsr()->GetNode()->GetTxtNode();
587*b1cdbd2cSJim Jagielski if ( pTxtNd && pTxtNd->HasVisibleNumberingOrBullet() )
588*b1cdbd2cSJim Jagielski SetInFrontOfLabel( sal_True );
589*b1cdbd2cSJim Jagielski }
590*b1cdbd2cSJim Jagielski else if ( !bLeft )
591*b1cdbd2cSJim Jagielski {
592*b1cdbd2cSJim Jagielski bRet = SetInFrontOfLabel( sal_False ) || bRet;
593*b1cdbd2cSJim Jagielski }
594*b1cdbd2cSJim Jagielski
595*b1cdbd2cSJim Jagielski if( bRet )
596*b1cdbd2cSJim Jagielski {
597*b1cdbd2cSJim Jagielski UpdateCrsr();
598*b1cdbd2cSJim Jagielski }
599*b1cdbd2cSJim Jagielski return bRet;
600*b1cdbd2cSJim Jagielski }
601*b1cdbd2cSJim Jagielski
IsAtLRMargin(sal_Bool bLeft,sal_Bool bAPI) const602*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsAtLRMargin( sal_Bool bLeft, sal_Bool bAPI ) const
603*b1cdbd2cSJim Jagielski {
604*b1cdbd2cSJim Jagielski const SwShellCrsr* pTmpCrsr = getShellCrsr( true );
605*b1cdbd2cSJim Jagielski return pTmpCrsr->IsAtLeftRightMargin( bLeft, bAPI );
606*b1cdbd2cSJim Jagielski }
607*b1cdbd2cSJim Jagielski
608*b1cdbd2cSJim Jagielski
SttEndDoc(sal_Bool bStt)609*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::SttEndDoc( sal_Bool bStt )
610*b1cdbd2cSJim Jagielski {
611*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
612*b1cdbd2cSJim Jagielski
613*b1cdbd2cSJim Jagielski SwShellCrsr* pTmpCrsr = pBlockCrsr ? &pBlockCrsr->getShellCrsr() : pCurCrsr;
614*b1cdbd2cSJim Jagielski sal_Bool bRet = pTmpCrsr->SttEndDoc( bStt );
615*b1cdbd2cSJim Jagielski if( bRet )
616*b1cdbd2cSJim Jagielski {
617*b1cdbd2cSJim Jagielski if( bStt )
618*b1cdbd2cSJim Jagielski pTmpCrsr->GetPtPos().Y() = 0; // expl. 0 setzen (TabellenHeader)
619*b1cdbd2cSJim Jagielski if( pBlockCrsr )
620*b1cdbd2cSJim Jagielski {
621*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
622*b1cdbd2cSJim Jagielski RefreshBlockCursor();
623*b1cdbd2cSJim Jagielski }
624*b1cdbd2cSJim Jagielski
625*b1cdbd2cSJim Jagielski UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
626*b1cdbd2cSJim Jagielski }
627*b1cdbd2cSJim Jagielski return bRet;
628*b1cdbd2cSJim Jagielski }
629*b1cdbd2cSJim Jagielski
ExtendedSelectAll()630*b1cdbd2cSJim Jagielski void SwCrsrShell::ExtendedSelectAll()
631*b1cdbd2cSJim Jagielski {
632*b1cdbd2cSJim Jagielski SwNodes& rNodes = GetDoc()->GetNodes();
633*b1cdbd2cSJim Jagielski SwPosition* pPos = pCurCrsr->GetPoint();
634*b1cdbd2cSJim Jagielski pPos->nNode = rNodes.GetEndOfPostIts();
635*b1cdbd2cSJim Jagielski pPos->nContent.Assign( rNodes.GoNext( &pPos->nNode ), 0 );
636*b1cdbd2cSJim Jagielski pPos = pCurCrsr->GetMark();
637*b1cdbd2cSJim Jagielski pPos->nNode = rNodes.GetEndOfContent();
638*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = rNodes.GoPrevious( &pPos->nNode );
639*b1cdbd2cSJim Jagielski pPos->nContent.Assign( pCNd, pCNd ? pCNd->Len() : 0 );
640*b1cdbd2cSJim Jagielski }
641*b1cdbd2cSJim Jagielski
MovePage(SwWhichPage fnWhichPage,SwPosPage fnPosPage)642*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::MovePage( SwWhichPage fnWhichPage, SwPosPage fnPosPage )
643*b1cdbd2cSJim Jagielski {
644*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
645*b1cdbd2cSJim Jagielski
646*b1cdbd2cSJim Jagielski // Springe beim Selektieren nie ueber Section-Grenzen !!
647*b1cdbd2cSJim Jagielski if( !pCurCrsr->HasMark() || !pCurCrsr->IsNoCntnt() )
648*b1cdbd2cSJim Jagielski {
649*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
650*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
651*b1cdbd2cSJim Jagielski
652*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCurCrsr );
653*b1cdbd2cSJim Jagielski Point& rPt = pCurCrsr->GetPtPos();
654*b1cdbd2cSJim Jagielski SwCntntFrm * pFrm = pCurCrsr->GetCntntNode()->
655*b1cdbd2cSJim Jagielski getLayoutFrm( GetLayout(), &rPt, pCurCrsr->GetPoint(), sal_False );
656*b1cdbd2cSJim Jagielski if( pFrm && sal_True == ( bRet = GetFrmInPage( pFrm, fnWhichPage,
657*b1cdbd2cSJim Jagielski fnPosPage, pCurCrsr ) ) &&
658*b1cdbd2cSJim Jagielski !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
659*b1cdbd2cSJim Jagielski nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ))
660*b1cdbd2cSJim Jagielski UpdateCrsr();
661*b1cdbd2cSJim Jagielski else
662*b1cdbd2cSJim Jagielski bRet = sal_False;
663*b1cdbd2cSJim Jagielski }
664*b1cdbd2cSJim Jagielski return bRet;
665*b1cdbd2cSJim Jagielski }
666*b1cdbd2cSJim Jagielski
667*b1cdbd2cSJim Jagielski
MovePara(SwWhichPara fnWhichPara,SwPosPara fnPosPara)668*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::MovePara(SwWhichPara fnWhichPara, SwPosPara fnPosPara )
669*b1cdbd2cSJim Jagielski {
670*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
671*b1cdbd2cSJim Jagielski SwCursor* pTmpCrsr = getShellCrsr( true );
672*b1cdbd2cSJim Jagielski sal_Bool bRet = pTmpCrsr->MovePara( fnWhichPara, fnPosPara );
673*b1cdbd2cSJim Jagielski if( bRet )
674*b1cdbd2cSJim Jagielski UpdateCrsr();
675*b1cdbd2cSJim Jagielski return bRet;
676*b1cdbd2cSJim Jagielski }
677*b1cdbd2cSJim Jagielski
678*b1cdbd2cSJim Jagielski
MoveSection(SwWhichSection fnWhichSect,SwPosSection fnPosSect)679*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::MoveSection( SwWhichSection fnWhichSect,
680*b1cdbd2cSJim Jagielski SwPosSection fnPosSect)
681*b1cdbd2cSJim Jagielski {
682*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
683*b1cdbd2cSJim Jagielski SwCursor* pTmpCrsr = getShellCrsr( true );
684*b1cdbd2cSJim Jagielski sal_Bool bRet = pTmpCrsr->MoveSection( fnWhichSect, fnPosSect );
685*b1cdbd2cSJim Jagielski if( bRet )
686*b1cdbd2cSJim Jagielski UpdateCrsr();
687*b1cdbd2cSJim Jagielski return bRet;
688*b1cdbd2cSJim Jagielski
689*b1cdbd2cSJim Jagielski }
690*b1cdbd2cSJim Jagielski
691*b1cdbd2cSJim Jagielski
692*b1cdbd2cSJim Jagielski // Positionieren des Cursors
693*b1cdbd2cSJim Jagielski
694*b1cdbd2cSJim Jagielski
lcl_IsInHeaderFooter(const SwNodeIndex & rIdx,Point & rPt)695*b1cdbd2cSJim Jagielski SwFrm* lcl_IsInHeaderFooter( const SwNodeIndex& rIdx, Point& rPt )
696*b1cdbd2cSJim Jagielski {
697*b1cdbd2cSJim Jagielski SwFrm* pFrm = 0;
698*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = rIdx.GetNode().GetCntntNode();
699*b1cdbd2cSJim Jagielski if( pCNd )
700*b1cdbd2cSJim Jagielski {
701*b1cdbd2cSJim Jagielski pFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout(), &rPt, 0, sal_False )->GetUpper();
702*b1cdbd2cSJim Jagielski while( pFrm && !pFrm->IsHeaderFrm() && !pFrm->IsFooterFrm() )
703*b1cdbd2cSJim Jagielski pFrm = pFrm->IsFlyFrm() ? ((SwFlyFrm*)pFrm)->AnchorFrm()
704*b1cdbd2cSJim Jagielski : pFrm->GetUpper();
705*b1cdbd2cSJim Jagielski }
706*b1cdbd2cSJim Jagielski return pFrm;
707*b1cdbd2cSJim Jagielski }
708*b1cdbd2cSJim Jagielski
IsInHeaderFooter(sal_Bool * pbInHeader) const709*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsInHeaderFooter( sal_Bool* pbInHeader ) const
710*b1cdbd2cSJim Jagielski {
711*b1cdbd2cSJim Jagielski Point aPt;
712*b1cdbd2cSJim Jagielski SwFrm* pFrm = ::lcl_IsInHeaderFooter( pCurCrsr->GetPoint()->nNode, aPt );
713*b1cdbd2cSJim Jagielski if( pFrm && pbInHeader )
714*b1cdbd2cSJim Jagielski *pbInHeader = pFrm->IsHeaderFrm();
715*b1cdbd2cSJim Jagielski return 0 != pFrm;
716*b1cdbd2cSJim Jagielski }
717*b1cdbd2cSJim Jagielski
SetCrsr(const Point & rLPt,sal_Bool bOnlyText,bool bBlock)718*b1cdbd2cSJim Jagielski int SwCrsrShell::SetCrsr( const Point &rLPt, sal_Bool bOnlyText, bool bBlock )
719*b1cdbd2cSJim Jagielski {
720*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
721*b1cdbd2cSJim Jagielski
722*b1cdbd2cSJim Jagielski SwShellCrsr* pCrsr = getShellCrsr( bBlock );
723*b1cdbd2cSJim Jagielski SwPosition aPos( *pCrsr->GetPoint() );
724*b1cdbd2cSJim Jagielski Point aPt( rLPt );
725*b1cdbd2cSJim Jagielski Point & rAktCrsrPt = pCrsr->GetPtPos();
726*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( IsTableMode() ? MV_TBLSEL :
727*b1cdbd2cSJim Jagielski bOnlyText ? MV_SETONLYTEXT : MV_NONE );
728*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
729*b1cdbd2cSJim Jagielski
730*b1cdbd2cSJim Jagielski SwTxtNode * pTxtNd = pCrsr->GetNode()->GetTxtNode();
731*b1cdbd2cSJim Jagielski
732*b1cdbd2cSJim Jagielski if ( pTxtNd && !IsTableMode() &&
733*b1cdbd2cSJim Jagielski // --> FME 2004-11-25 #i37515# No bInFrontOfLabel during selection
734*b1cdbd2cSJim Jagielski !pCrsr->HasMark() &&
735*b1cdbd2cSJim Jagielski // <--
736*b1cdbd2cSJim Jagielski pTxtNd->HasVisibleNumberingOrBullet() )
737*b1cdbd2cSJim Jagielski {
738*b1cdbd2cSJim Jagielski aTmpState.bInFrontOfLabel = sal_True; // #i27615#
739*b1cdbd2cSJim Jagielski }
740*b1cdbd2cSJim Jagielski else
741*b1cdbd2cSJim Jagielski {
742*b1cdbd2cSJim Jagielski aTmpState.bInFrontOfLabel = sal_False;
743*b1cdbd2cSJim Jagielski }
744*b1cdbd2cSJim Jagielski
745*b1cdbd2cSJim Jagielski int bRet = CRSR_POSOLD |
746*b1cdbd2cSJim Jagielski ( GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState )
747*b1cdbd2cSJim Jagielski ? 0 : CRSR_POSCHG );
748*b1cdbd2cSJim Jagielski
749*b1cdbd2cSJim Jagielski const bool bOldInFrontOfLabel = IsInFrontOfLabel();
750*b1cdbd2cSJim Jagielski const bool bNewInFrontOfLabel = aTmpState.bInFrontOfLabel;
751*b1cdbd2cSJim Jagielski
752*b1cdbd2cSJim Jagielski pCrsr->SetCrsrBidiLevel( aTmpState.nCursorBidiLevel );
753*b1cdbd2cSJim Jagielski
754*b1cdbd2cSJim Jagielski if( MV_RIGHTMARGIN == aTmpState.eState )
755*b1cdbd2cSJim Jagielski eMvState = MV_RIGHTMARGIN;
756*b1cdbd2cSJim Jagielski // steht neu Pos im Header/Footer ?
757*b1cdbd2cSJim Jagielski SwFrm* pFrm = lcl_IsInHeaderFooter( aPos.nNode, aPt );
758*b1cdbd2cSJim Jagielski if( IsTableMode() && !pFrm && aPos.nNode.GetNode().StartOfSectionNode() ==
759*b1cdbd2cSJim Jagielski pCrsr->GetPoint()->nNode.GetNode().StartOfSectionNode() )
760*b1cdbd2cSJim Jagielski // gleiche Tabellenzelle und nicht im Header/Footer
761*b1cdbd2cSJim Jagielski // -> zurueck
762*b1cdbd2cSJim Jagielski return bRet;
763*b1cdbd2cSJim Jagielski
764*b1cdbd2cSJim Jagielski if( pBlockCrsr && bBlock )
765*b1cdbd2cSJim Jagielski {
766*b1cdbd2cSJim Jagielski pBlockCrsr->setEndPoint( rLPt );
767*b1cdbd2cSJim Jagielski if( !pCrsr->HasMark() )
768*b1cdbd2cSJim Jagielski pBlockCrsr->setStartPoint( rLPt );
769*b1cdbd2cSJim Jagielski else if( !pBlockCrsr->getStartPoint() )
770*b1cdbd2cSJim Jagielski pBlockCrsr->setStartPoint( pCrsr->GetMkPos() );
771*b1cdbd2cSJim Jagielski }
772*b1cdbd2cSJim Jagielski if( !pCrsr->HasMark() )
773*b1cdbd2cSJim Jagielski {
774*b1cdbd2cSJim Jagielski // steht an der gleichen Position und wenn im Header/Footer,
775*b1cdbd2cSJim Jagielski // dann im gleichen
776*b1cdbd2cSJim Jagielski if( aPos == *pCrsr->GetPoint() &&
777*b1cdbd2cSJim Jagielski bOldInFrontOfLabel == bNewInFrontOfLabel )
778*b1cdbd2cSJim Jagielski {
779*b1cdbd2cSJim Jagielski if( pFrm )
780*b1cdbd2cSJim Jagielski {
781*b1cdbd2cSJim Jagielski if( pFrm->Frm().IsInside( rAktCrsrPt ))
782*b1cdbd2cSJim Jagielski return bRet;
783*b1cdbd2cSJim Jagielski }
784*b1cdbd2cSJim Jagielski else if( aPos.nNode.GetNode().IsCntntNode() )
785*b1cdbd2cSJim Jagielski {
786*b1cdbd2cSJim Jagielski // im gleichen Frame gelandet?
787*b1cdbd2cSJim Jagielski SwFrm* pOld = ((SwCntntNode&)aPos.nNode.GetNode()).getLayoutFrm(
788*b1cdbd2cSJim Jagielski GetLayout(), &aCharRect.Pos(), 0, sal_False );
789*b1cdbd2cSJim Jagielski SwFrm* pNew = ((SwCntntNode&)aPos.nNode.GetNode()).getLayoutFrm(
790*b1cdbd2cSJim Jagielski GetLayout(), &aPt, 0, sal_False );
791*b1cdbd2cSJim Jagielski if( pNew == pOld )
792*b1cdbd2cSJim Jagielski return bRet;
793*b1cdbd2cSJim Jagielski }
794*b1cdbd2cSJim Jagielski }
795*b1cdbd2cSJim Jagielski }
796*b1cdbd2cSJim Jagielski else
797*b1cdbd2cSJim Jagielski {
798*b1cdbd2cSJim Jagielski // SSelection ueber nicht erlaubte Sections oder wenn im Header/Footer
799*b1cdbd2cSJim Jagielski // dann in verschiedene
800*b1cdbd2cSJim Jagielski if( !CheckNodesRange( aPos.nNode, pCrsr->GetMark()->nNode, sal_True )
801*b1cdbd2cSJim Jagielski || ( pFrm && !pFrm->Frm().IsInside( pCrsr->GetMkPos() ) ))
802*b1cdbd2cSJim Jagielski return bRet;
803*b1cdbd2cSJim Jagielski
804*b1cdbd2cSJim Jagielski // steht an der gleichen Position und nicht im Header/Footer
805*b1cdbd2cSJim Jagielski if( aPos == *pCrsr->GetPoint() )
806*b1cdbd2cSJim Jagielski return bRet;
807*b1cdbd2cSJim Jagielski }
808*b1cdbd2cSJim Jagielski
809*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
810*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCrsr );
811*b1cdbd2cSJim Jagielski
812*b1cdbd2cSJim Jagielski *pCrsr->GetPoint() = aPos;
813*b1cdbd2cSJim Jagielski rAktCrsrPt = aPt;
814*b1cdbd2cSJim Jagielski
815*b1cdbd2cSJim Jagielski // --> FME 2005-01-31 #i41424# Only update the marked number levels if necessary
816*b1cdbd2cSJim Jagielski // Force update of marked number levels if necessary.
817*b1cdbd2cSJim Jagielski if ( bNewInFrontOfLabel || bOldInFrontOfLabel )
818*b1cdbd2cSJim Jagielski pCurCrsr->_SetInFrontOfLabel( !bNewInFrontOfLabel );
819*b1cdbd2cSJim Jagielski SetInFrontOfLabel( bNewInFrontOfLabel );
820*b1cdbd2cSJim Jagielski // <--
821*b1cdbd2cSJim Jagielski
822*b1cdbd2cSJim Jagielski if( !pCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ) )
823*b1cdbd2cSJim Jagielski {
824*b1cdbd2cSJim Jagielski sal_uInt16 nFlag = SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE;
825*b1cdbd2cSJim Jagielski UpdateCrsr( nFlag );
826*b1cdbd2cSJim Jagielski bRet &= ~CRSR_POSOLD;
827*b1cdbd2cSJim Jagielski }
828*b1cdbd2cSJim Jagielski else if( bOnlyText && !pCurCrsr->HasMark() )
829*b1cdbd2cSJim Jagielski {
830*b1cdbd2cSJim Jagielski if( FindValidCntntNode( bOnlyText ) )
831*b1cdbd2cSJim Jagielski {
832*b1cdbd2cSJim Jagielski // Cursor in einen gueltigen Content stellen
833*b1cdbd2cSJim Jagielski if( aPos == *pCrsr->GetPoint() )
834*b1cdbd2cSJim Jagielski bRet = CRSR_POSOLD;
835*b1cdbd2cSJim Jagielski else
836*b1cdbd2cSJim Jagielski {
837*b1cdbd2cSJim Jagielski UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE );
838*b1cdbd2cSJim Jagielski bRet &= ~CRSR_POSOLD;
839*b1cdbd2cSJim Jagielski }
840*b1cdbd2cSJim Jagielski }
841*b1cdbd2cSJim Jagielski else
842*b1cdbd2cSJim Jagielski {
843*b1cdbd2cSJim Jagielski // es gibt keinen gueltigen Inhalt -> Cursor verstecken
844*b1cdbd2cSJim Jagielski pVisCrsr->Hide(); // sichtbaren Cursor immer verstecken
845*b1cdbd2cSJim Jagielski eMvState = MV_NONE; // Status fuers Crsr-Travelling
846*b1cdbd2cSJim Jagielski bAllProtect = sal_True;
847*b1cdbd2cSJim Jagielski if( GetDoc()->GetDocShell() )
848*b1cdbd2cSJim Jagielski {
849*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->SetReadOnlyUI( sal_True );
850*b1cdbd2cSJim Jagielski CallChgLnk(); // UI bescheid sagen!
851*b1cdbd2cSJim Jagielski }
852*b1cdbd2cSJim Jagielski }
853*b1cdbd2cSJim Jagielski }
854*b1cdbd2cSJim Jagielski
855*b1cdbd2cSJim Jagielski return bRet;
856*b1cdbd2cSJim Jagielski }
857*b1cdbd2cSJim Jagielski
858*b1cdbd2cSJim Jagielski
TblCrsrToCursor()859*b1cdbd2cSJim Jagielski void SwCrsrShell::TblCrsrToCursor()
860*b1cdbd2cSJim Jagielski {
861*b1cdbd2cSJim Jagielski ASSERT( pTblCrsr, "TblCrsrToCursor: Why?" );
862*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
863*b1cdbd2cSJim Jagielski }
864*b1cdbd2cSJim Jagielski
BlockCrsrToCrsr()865*b1cdbd2cSJim Jagielski void SwCrsrShell::BlockCrsrToCrsr()
866*b1cdbd2cSJim Jagielski {
867*b1cdbd2cSJim Jagielski ASSERT( pBlockCrsr, "BlockCrsrToCrsr: Why?" );
868*b1cdbd2cSJim Jagielski if( pBlockCrsr && !HasSelection() )
869*b1cdbd2cSJim Jagielski {
870*b1cdbd2cSJim Jagielski SwPaM& rPam = pBlockCrsr->getShellCrsr();
871*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
872*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *rPam.GetPoint();
873*b1cdbd2cSJim Jagielski if( rPam.HasMark() )
874*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *rPam.GetMark();
875*b1cdbd2cSJim Jagielski else
876*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
877*b1cdbd2cSJim Jagielski }
878*b1cdbd2cSJim Jagielski delete pBlockCrsr, pBlockCrsr = 0;
879*b1cdbd2cSJim Jagielski }
880*b1cdbd2cSJim Jagielski
CrsrToBlockCrsr()881*b1cdbd2cSJim Jagielski void SwCrsrShell::CrsrToBlockCrsr()
882*b1cdbd2cSJim Jagielski {
883*b1cdbd2cSJim Jagielski if( !pBlockCrsr )
884*b1cdbd2cSJim Jagielski {
885*b1cdbd2cSJim Jagielski SwPosition aPos( *pCurCrsr->GetPoint() );
886*b1cdbd2cSJim Jagielski pBlockCrsr = createBlockCursor( *this, aPos );
887*b1cdbd2cSJim Jagielski SwShellCrsr &rBlock = pBlockCrsr->getShellCrsr();
888*b1cdbd2cSJim Jagielski rBlock.GetPtPos() = pCurCrsr->GetPtPos();
889*b1cdbd2cSJim Jagielski if( pCurCrsr->HasMark() )
890*b1cdbd2cSJim Jagielski {
891*b1cdbd2cSJim Jagielski rBlock.SetMark();
892*b1cdbd2cSJim Jagielski *rBlock.GetMark() = *pCurCrsr->GetMark();
893*b1cdbd2cSJim Jagielski rBlock.GetMkPos() = pCurCrsr->GetMkPos();
894*b1cdbd2cSJim Jagielski }
895*b1cdbd2cSJim Jagielski }
896*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
897*b1cdbd2cSJim Jagielski RefreshBlockCursor();
898*b1cdbd2cSJim Jagielski }
899*b1cdbd2cSJim Jagielski
ClearMark()900*b1cdbd2cSJim Jagielski void SwCrsrShell::ClearMark()
901*b1cdbd2cSJim Jagielski {
902*b1cdbd2cSJim Jagielski // ist ueberhaupt ein GetMark gesetzt ?
903*b1cdbd2cSJim Jagielski if( pTblCrsr )
904*b1cdbd2cSJim Jagielski {
905*b1cdbd2cSJim Jagielski while( pCurCrsr->GetNext() != pCurCrsr )
906*b1cdbd2cSJim Jagielski delete pCurCrsr->GetNext();
907*b1cdbd2cSJim Jagielski pTblCrsr->DeleteMark();
908*b1cdbd2cSJim Jagielski
909*b1cdbd2cSJim Jagielski if( pCurCrsr->HasMark() )
910*b1cdbd2cSJim Jagielski {
911*b1cdbd2cSJim Jagielski // falls doch nicht alle Indizies richtig verschoben werden
912*b1cdbd2cSJim Jagielski // (z.B.: Kopf-/Fusszeile loeschen) den Content-Anteil vom
913*b1cdbd2cSJim Jagielski // Mark aufs Nodes-Array setzen
914*b1cdbd2cSJim Jagielski SwPosition& rPos = *pCurCrsr->GetMark();
915*b1cdbd2cSJim Jagielski rPos.nNode.Assign( pDoc->GetNodes(), 0 );
916*b1cdbd2cSJim Jagielski rPos.nContent.Assign( 0, 0 );
917*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
918*b1cdbd2cSJim Jagielski }
919*b1cdbd2cSJim Jagielski
920*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *pTblCrsr->GetPoint();
921*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos() = pTblCrsr->GetPtPos();
922*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
923*b1cdbd2cSJim Jagielski pCurCrsr->SwSelPaintRects::Show();
924*b1cdbd2cSJim Jagielski }
925*b1cdbd2cSJim Jagielski else
926*b1cdbd2cSJim Jagielski {
927*b1cdbd2cSJim Jagielski if( !pCurCrsr->HasMark() )
928*b1cdbd2cSJim Jagielski return;
929*b1cdbd2cSJim Jagielski // falls doch nicht alle Indizies richtig verschoben werden
930*b1cdbd2cSJim Jagielski // (z.B.: Kopf-/Fusszeile loeschen) den Content-Anteil vom
931*b1cdbd2cSJim Jagielski // Mark aufs Nodes-Array setzen
932*b1cdbd2cSJim Jagielski SwPosition& rPos = *pCurCrsr->GetMark();
933*b1cdbd2cSJim Jagielski rPos.nNode.Assign( pDoc->GetNodes(), 0 );
934*b1cdbd2cSJim Jagielski rPos.nContent.Assign( 0, 0 );
935*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
936*b1cdbd2cSJim Jagielski if( !nCrsrMove )
937*b1cdbd2cSJim Jagielski pCurCrsr->SwSelPaintRects::Show();
938*b1cdbd2cSJim Jagielski }
939*b1cdbd2cSJim Jagielski }
940*b1cdbd2cSJim Jagielski
941*b1cdbd2cSJim Jagielski
NormalizePam(sal_Bool bPointFirst)942*b1cdbd2cSJim Jagielski void SwCrsrShell::NormalizePam(sal_Bool bPointFirst)
943*b1cdbd2cSJim Jagielski {
944*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
945*b1cdbd2cSJim Jagielski pCurCrsr->Normalize(bPointFirst);
946*b1cdbd2cSJim Jagielski }
947*b1cdbd2cSJim Jagielski
SwapPam()948*b1cdbd2cSJim Jagielski void SwCrsrShell::SwapPam()
949*b1cdbd2cSJim Jagielski {
950*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
951*b1cdbd2cSJim Jagielski pCurCrsr->Exchange();
952*b1cdbd2cSJim Jagielski }
953*b1cdbd2cSJim Jagielski
954*b1cdbd2cSJim Jagielski
955*b1cdbd2cSJim Jagielski // suche innerhalb der Selektierten-Bereiche nach einer Selektion, die
956*b1cdbd2cSJim Jagielski // den angebenen SPoint umschliesst
957*b1cdbd2cSJim Jagielski // Ist das Flag bTstOnly gesetzt, dann wird nur getestet, ob dort eine
958*b1cdbd2cSJim Jagielski // SSelection besteht; des akt. Cursr wird nicht umgesetzt!
959*b1cdbd2cSJim Jagielski // Ansonsten wird er auf die gewaehlte SSelection gesetzt.
960*b1cdbd2cSJim Jagielski
961*b1cdbd2cSJim Jagielski
ChgCurrPam(const Point & rPt,sal_Bool bTstOnly,sal_Bool bTstHit)962*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::ChgCurrPam(
963*b1cdbd2cSJim Jagielski const Point & rPt,
964*b1cdbd2cSJim Jagielski sal_Bool bTstOnly,
965*b1cdbd2cSJim Jagielski sal_Bool bTstHit )
966*b1cdbd2cSJim Jagielski {
967*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
968*b1cdbd2cSJim Jagielski
969*b1cdbd2cSJim Jagielski // Pruefe ob der SPoint in einer Tabellen-Selektion liegt
970*b1cdbd2cSJim Jagielski if( bTstOnly && pTblCrsr )
971*b1cdbd2cSJim Jagielski return pTblCrsr->IsInside( rPt );
972*b1cdbd2cSJim Jagielski
973*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
974*b1cdbd2cSJim Jagielski // Suche die Position rPt im Dokument
975*b1cdbd2cSJim Jagielski SwPosition aPtPos( *pCurCrsr->GetPoint() );
976*b1cdbd2cSJim Jagielski Point aPt( rPt );
977*b1cdbd2cSJim Jagielski
978*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_NONE );
979*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
980*b1cdbd2cSJim Jagielski if ( !GetLayout()->GetCrsrOfst( &aPtPos, aPt, &aTmpState ) && bTstHit )
981*b1cdbd2cSJim Jagielski return sal_False;
982*b1cdbd2cSJim Jagielski
983*b1cdbd2cSJim Jagielski // suche in allen Selektionen nach dieser Position
984*b1cdbd2cSJim Jagielski SwShellCrsr* pCmp = (SwShellCrsr*)pCurCrsr; // sicher den Pointer auf Cursor
985*b1cdbd2cSJim Jagielski do {
986*b1cdbd2cSJim Jagielski if( pCmp->HasMark() &&
987*b1cdbd2cSJim Jagielski *pCmp->Start() <= aPtPos && *pCmp->End() > aPtPos )
988*b1cdbd2cSJim Jagielski {
989*b1cdbd2cSJim Jagielski if( bTstOnly || pCurCrsr == pCmp ) // ist der aktuelle.
990*b1cdbd2cSJim Jagielski return sal_True; // return ohne Update
991*b1cdbd2cSJim Jagielski
992*b1cdbd2cSJim Jagielski pCurCrsr = pCmp;
993*b1cdbd2cSJim Jagielski UpdateCrsr(); // Cursor steht schon richtig
994*b1cdbd2cSJim Jagielski return sal_True;
995*b1cdbd2cSJim Jagielski }
996*b1cdbd2cSJim Jagielski } while( pCurCrsr !=
997*b1cdbd2cSJim Jagielski ( pCmp = dynamic_cast<SwShellCrsr*>(pCmp->GetNext()) ) );
998*b1cdbd2cSJim Jagielski return sal_False;
999*b1cdbd2cSJim Jagielski }
1000*b1cdbd2cSJim Jagielski
1001*b1cdbd2cSJim Jagielski
KillPams()1002*b1cdbd2cSJim Jagielski void SwCrsrShell::KillPams()
1003*b1cdbd2cSJim Jagielski {
1004*b1cdbd2cSJim Jagielski // keiner zum loeschen vorhanden?
1005*b1cdbd2cSJim Jagielski if( !pTblCrsr && !pBlockCrsr && pCurCrsr->GetNext() == pCurCrsr )
1006*b1cdbd2cSJim Jagielski return;
1007*b1cdbd2cSJim Jagielski
1008*b1cdbd2cSJim Jagielski while( pCurCrsr->GetNext() != pCurCrsr )
1009*b1cdbd2cSJim Jagielski delete pCurCrsr->GetNext();
1010*b1cdbd2cSJim Jagielski pCurCrsr->SetColumnSelection( false );
1011*b1cdbd2cSJim Jagielski
1012*b1cdbd2cSJim Jagielski if( pTblCrsr )
1013*b1cdbd2cSJim Jagielski {
1014*b1cdbd2cSJim Jagielski // Cursor Ring loeschen
1015*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1016*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *pTblCrsr->GetPoint();
1017*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos() = pTblCrsr->GetPtPos();
1018*b1cdbd2cSJim Jagielski delete pTblCrsr;
1019*b1cdbd2cSJim Jagielski pTblCrsr = 0;
1020*b1cdbd2cSJim Jagielski }
1021*b1cdbd2cSJim Jagielski else if( pBlockCrsr )
1022*b1cdbd2cSJim Jagielski {
1023*b1cdbd2cSJim Jagielski // delete the ring of cursors
1024*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1025*b1cdbd2cSJim Jagielski SwShellCrsr &rBlock = pBlockCrsr->getShellCrsr();
1026*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *rBlock.GetPoint();
1027*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos() = rBlock.GetPtPos();
1028*b1cdbd2cSJim Jagielski rBlock.DeleteMark();
1029*b1cdbd2cSJim Jagielski pBlockCrsr->clearPoints();
1030*b1cdbd2cSJim Jagielski }
1031*b1cdbd2cSJim Jagielski UpdateCrsr( SwCrsrShell::SCROLLWIN );
1032*b1cdbd2cSJim Jagielski }
1033*b1cdbd2cSJim Jagielski
1034*b1cdbd2cSJim Jagielski
CompareCursor(CrsrCompareType eType) const1035*b1cdbd2cSJim Jagielski int SwCrsrShell::CompareCursor( CrsrCompareType eType ) const
1036*b1cdbd2cSJim Jagielski {
1037*b1cdbd2cSJim Jagielski int nRet = 0;
1038*b1cdbd2cSJim Jagielski const SwPosition *pFirst = 0, *pSecond = 0;
1039*b1cdbd2cSJim Jagielski const SwPaM *pCur = GetCrsr(), *pStk = pCrsrStk;
1040*b1cdbd2cSJim Jagielski if( CurrPtCurrMk != eType && pStk )
1041*b1cdbd2cSJim Jagielski {
1042*b1cdbd2cSJim Jagielski switch ( eType)
1043*b1cdbd2cSJim Jagielski {
1044*b1cdbd2cSJim Jagielski case StackPtStackMk:
1045*b1cdbd2cSJim Jagielski pFirst = pStk->GetPoint();
1046*b1cdbd2cSJim Jagielski pSecond = pStk->GetMark();
1047*b1cdbd2cSJim Jagielski break;
1048*b1cdbd2cSJim Jagielski case StackPtCurrPt:
1049*b1cdbd2cSJim Jagielski pFirst = pStk->GetPoint();
1050*b1cdbd2cSJim Jagielski pSecond = pCur->GetPoint();
1051*b1cdbd2cSJim Jagielski break;
1052*b1cdbd2cSJim Jagielski case StackPtCurrMk:
1053*b1cdbd2cSJim Jagielski pFirst = pStk->GetPoint();
1054*b1cdbd2cSJim Jagielski pSecond = pCur->GetMark();
1055*b1cdbd2cSJim Jagielski break;
1056*b1cdbd2cSJim Jagielski case StackMkCurrPt:
1057*b1cdbd2cSJim Jagielski pFirst = pStk->GetMark();
1058*b1cdbd2cSJim Jagielski pSecond = pCur->GetPoint();
1059*b1cdbd2cSJim Jagielski break;
1060*b1cdbd2cSJim Jagielski case StackMkCurrMk:
1061*b1cdbd2cSJim Jagielski pFirst = pStk->GetMark();
1062*b1cdbd2cSJim Jagielski pSecond = pStk->GetMark();
1063*b1cdbd2cSJim Jagielski break;
1064*b1cdbd2cSJim Jagielski case CurrPtCurrMk:
1065*b1cdbd2cSJim Jagielski pFirst = pCur->GetPoint();
1066*b1cdbd2cSJim Jagielski pSecond = pCur->GetMark();
1067*b1cdbd2cSJim Jagielski break;
1068*b1cdbd2cSJim Jagielski }
1069*b1cdbd2cSJim Jagielski }
1070*b1cdbd2cSJim Jagielski if( !pFirst || !pSecond )
1071*b1cdbd2cSJim Jagielski nRet = INT_MAX;
1072*b1cdbd2cSJim Jagielski else if( *pFirst < *pSecond )
1073*b1cdbd2cSJim Jagielski nRet = -1;
1074*b1cdbd2cSJim Jagielski else if( *pFirst == *pSecond )
1075*b1cdbd2cSJim Jagielski nRet = 0;
1076*b1cdbd2cSJim Jagielski else
1077*b1cdbd2cSJim Jagielski nRet = 1;
1078*b1cdbd2cSJim Jagielski return nRet;
1079*b1cdbd2cSJim Jagielski }
1080*b1cdbd2cSJim Jagielski
1081*b1cdbd2cSJim Jagielski
IsSttPara() const1082*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsSttPara() const
1083*b1cdbd2cSJim Jagielski { return( pCurCrsr->GetPoint()->nContent == 0 ? sal_True : sal_False ); }
1084*b1cdbd2cSJim Jagielski
1085*b1cdbd2cSJim Jagielski
IsEndPara() const1086*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsEndPara() const
1087*b1cdbd2cSJim Jagielski { return( pCurCrsr->GetPoint()->nContent == pCurCrsr->GetCntntNode()->Len() ? sal_True : sal_False ); }
1088*b1cdbd2cSJim Jagielski
1089*b1cdbd2cSJim Jagielski
IsInFrontOfLabel() const1090*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsInFrontOfLabel() const
1091*b1cdbd2cSJim Jagielski {
1092*b1cdbd2cSJim Jagielski return pCurCrsr->IsInFrontOfLabel();
1093*b1cdbd2cSJim Jagielski }
1094*b1cdbd2cSJim Jagielski
SetInFrontOfLabel(sal_Bool bNew)1095*b1cdbd2cSJim Jagielski bool SwCrsrShell::SetInFrontOfLabel( sal_Bool bNew )
1096*b1cdbd2cSJim Jagielski {
1097*b1cdbd2cSJim Jagielski if ( bNew != IsInFrontOfLabel() )
1098*b1cdbd2cSJim Jagielski {
1099*b1cdbd2cSJim Jagielski pCurCrsr->_SetInFrontOfLabel( bNew );
1100*b1cdbd2cSJim Jagielski UpdateMarkedListLevel();
1101*b1cdbd2cSJim Jagielski return true;
1102*b1cdbd2cSJim Jagielski }
1103*b1cdbd2cSJim Jagielski return false;
1104*b1cdbd2cSJim Jagielski }
1105*b1cdbd2cSJim Jagielski
GotoPage(sal_uInt16 nPage)1106*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::GotoPage( sal_uInt16 nPage )
1107*b1cdbd2cSJim Jagielski {
1108*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1109*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
1110*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCurCrsr );
1111*b1cdbd2cSJim Jagielski sal_Bool bRet = GetLayout()->SetCurrPage( pCurCrsr, nPage ) &&
1112*b1cdbd2cSJim Jagielski !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
1113*b1cdbd2cSJim Jagielski nsSwCursorSelOverFlags::SELOVER_CHANGEPOS );
1114*b1cdbd2cSJim Jagielski if( bRet )
1115*b1cdbd2cSJim Jagielski UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
1116*b1cdbd2cSJim Jagielski return bRet;
1117*b1cdbd2cSJim Jagielski }
1118*b1cdbd2cSJim Jagielski
1119*b1cdbd2cSJim Jagielski
GetPageNum(sal_uInt16 & rnPhyNum,sal_uInt16 & rnVirtNum,sal_Bool bAtCrsrPos,const sal_Bool bCalcFrm)1120*b1cdbd2cSJim Jagielski void SwCrsrShell::GetPageNum( sal_uInt16 &rnPhyNum, sal_uInt16 &rnVirtNum,
1121*b1cdbd2cSJim Jagielski sal_Bool bAtCrsrPos, const sal_Bool bCalcFrm )
1122*b1cdbd2cSJim Jagielski {
1123*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1124*b1cdbd2cSJim Jagielski // Seitennummer: die erste sichtbare Seite oder die am Cursor
1125*b1cdbd2cSJim Jagielski const SwCntntFrm* pCFrm;
1126*b1cdbd2cSJim Jagielski const SwPageFrm *pPg = 0;
1127*b1cdbd2cSJim Jagielski
1128*b1cdbd2cSJim Jagielski if( !bAtCrsrPos || 0 == (pCFrm = GetCurrFrm( bCalcFrm )) ||
1129*b1cdbd2cSJim Jagielski 0 == (pPg = pCFrm->FindPageFrm()) )
1130*b1cdbd2cSJim Jagielski {
1131*b1cdbd2cSJim Jagielski pPg = Imp()->GetFirstVisPage();
1132*b1cdbd2cSJim Jagielski while( pPg && pPg->IsEmptyPage() )
1133*b1cdbd2cSJim Jagielski pPg = (const SwPageFrm *)pPg->GetNext();
1134*b1cdbd2cSJim Jagielski }
1135*b1cdbd2cSJim Jagielski // Abfrage auf pPg muss fuer den Sonderfall Writerstart mit
1136*b1cdbd2cSJim Jagielski // standard.vor sein.
1137*b1cdbd2cSJim Jagielski rnPhyNum = pPg? pPg->GetPhyPageNum() : 1;
1138*b1cdbd2cSJim Jagielski rnVirtNum = pPg? pPg->GetVirtPageNum() : 1;
1139*b1cdbd2cSJim Jagielski }
1140*b1cdbd2cSJim Jagielski
1141*b1cdbd2cSJim Jagielski
GetNextPrevPageNum(sal_Bool bNext)1142*b1cdbd2cSJim Jagielski sal_uInt16 SwCrsrShell::GetNextPrevPageNum( sal_Bool bNext )
1143*b1cdbd2cSJim Jagielski {
1144*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1145*b1cdbd2cSJim Jagielski
1146*b1cdbd2cSJim Jagielski // Seitennummer: die erste sichtbare Seite oder die am Cursor
1147*b1cdbd2cSJim Jagielski const SwPageFrm *pPg = Imp()->GetFirstVisPage();
1148*b1cdbd2cSJim Jagielski if( pPg )
1149*b1cdbd2cSJim Jagielski {
1150*b1cdbd2cSJim Jagielski const SwTwips nPageTop = pPg->Frm().Top();
1151*b1cdbd2cSJim Jagielski
1152*b1cdbd2cSJim Jagielski if( bNext )
1153*b1cdbd2cSJim Jagielski {
1154*b1cdbd2cSJim Jagielski // go to next view layout row:
1155*b1cdbd2cSJim Jagielski do
1156*b1cdbd2cSJim Jagielski {
1157*b1cdbd2cSJim Jagielski pPg = (const SwPageFrm *)pPg->GetNext();
1158*b1cdbd2cSJim Jagielski }
1159*b1cdbd2cSJim Jagielski while( pPg && pPg->Frm().Top() == nPageTop );
1160*b1cdbd2cSJim Jagielski
1161*b1cdbd2cSJim Jagielski while( pPg && pPg->IsEmptyPage() )
1162*b1cdbd2cSJim Jagielski pPg = (const SwPageFrm *)pPg->GetNext();
1163*b1cdbd2cSJim Jagielski }
1164*b1cdbd2cSJim Jagielski else
1165*b1cdbd2cSJim Jagielski {
1166*b1cdbd2cSJim Jagielski // go to previous view layout row:
1167*b1cdbd2cSJim Jagielski do
1168*b1cdbd2cSJim Jagielski {
1169*b1cdbd2cSJim Jagielski pPg = (const SwPageFrm *)pPg->GetPrev();
1170*b1cdbd2cSJim Jagielski }
1171*b1cdbd2cSJim Jagielski while( pPg && pPg->Frm().Top() == nPageTop );
1172*b1cdbd2cSJim Jagielski
1173*b1cdbd2cSJim Jagielski while( pPg && pPg->IsEmptyPage() )
1174*b1cdbd2cSJim Jagielski pPg = (const SwPageFrm *)pPg->GetPrev();
1175*b1cdbd2cSJim Jagielski }
1176*b1cdbd2cSJim Jagielski }
1177*b1cdbd2cSJim Jagielski // Abfrage auf pPg muss fuer den Sonderfall Writerstart mit
1178*b1cdbd2cSJim Jagielski // standard.vor sein.
1179*b1cdbd2cSJim Jagielski return pPg ? pPg->GetPhyPageNum() : USHRT_MAX;
1180*b1cdbd2cSJim Jagielski }
1181*b1cdbd2cSJim Jagielski
1182*b1cdbd2cSJim Jagielski
GetPageCnt()1183*b1cdbd2cSJim Jagielski sal_uInt16 SwCrsrShell::GetPageCnt()
1184*b1cdbd2cSJim Jagielski {
1185*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1186*b1cdbd2cSJim Jagielski // gebe die Anzahl der Seiten zurueck
1187*b1cdbd2cSJim Jagielski return GetLayout()->GetPageNum();
1188*b1cdbd2cSJim Jagielski }
1189*b1cdbd2cSJim Jagielski
1190*b1cdbd2cSJim Jagielski // Gehe zur naechsten SSelection
1191*b1cdbd2cSJim Jagielski
1192*b1cdbd2cSJim Jagielski
GoNextCrsr()1193*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::GoNextCrsr()
1194*b1cdbd2cSJim Jagielski {
1195*b1cdbd2cSJim Jagielski // besteht ueberhaupt ein Ring ?
1196*b1cdbd2cSJim Jagielski if( pCurCrsr->GetNext() == pCurCrsr )
1197*b1cdbd2cSJim Jagielski return sal_False;
1198*b1cdbd2cSJim Jagielski
1199*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1200*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
1201*b1cdbd2cSJim Jagielski pCurCrsr = dynamic_cast<SwShellCrsr*>(pCurCrsr->GetNext());
1202*b1cdbd2cSJim Jagielski
1203*b1cdbd2cSJim Jagielski // Bug 24086: auch alle anderen anzeigen
1204*b1cdbd2cSJim Jagielski if( !ActionPend() )
1205*b1cdbd2cSJim Jagielski {
1206*b1cdbd2cSJim Jagielski UpdateCrsr();
1207*b1cdbd2cSJim Jagielski pCurCrsr->Show();
1208*b1cdbd2cSJim Jagielski }
1209*b1cdbd2cSJim Jagielski return sal_True;
1210*b1cdbd2cSJim Jagielski }
1211*b1cdbd2cSJim Jagielski
1212*b1cdbd2cSJim Jagielski // gehe zur vorherigen SSelection
1213*b1cdbd2cSJim Jagielski
1214*b1cdbd2cSJim Jagielski
GoPrevCrsr()1215*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::GoPrevCrsr()
1216*b1cdbd2cSJim Jagielski {
1217*b1cdbd2cSJim Jagielski // besteht ueberhaupt ein Ring ?
1218*b1cdbd2cSJim Jagielski if( pCurCrsr->GetNext() == pCurCrsr )
1219*b1cdbd2cSJim Jagielski return sal_False;
1220*b1cdbd2cSJim Jagielski
1221*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1222*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
1223*b1cdbd2cSJim Jagielski pCurCrsr = dynamic_cast<SwShellCrsr*>(pCurCrsr->GetPrev());
1224*b1cdbd2cSJim Jagielski
1225*b1cdbd2cSJim Jagielski // Bug 24086: auch alle anderen anzeigen
1226*b1cdbd2cSJim Jagielski if( !ActionPend() )
1227*b1cdbd2cSJim Jagielski {
1228*b1cdbd2cSJim Jagielski UpdateCrsr();
1229*b1cdbd2cSJim Jagielski pCurCrsr->Show();
1230*b1cdbd2cSJim Jagielski }
1231*b1cdbd2cSJim Jagielski
1232*b1cdbd2cSJim Jagielski return sal_True;
1233*b1cdbd2cSJim Jagielski }
1234*b1cdbd2cSJim Jagielski
1235*b1cdbd2cSJim Jagielski
Paint(const Rectangle & rRect)1236*b1cdbd2cSJim Jagielski void SwCrsrShell::Paint( const Rectangle &rRect)
1237*b1cdbd2cSJim Jagielski {
1238*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1239*b1cdbd2cSJim Jagielski
1240*b1cdbd2cSJim Jagielski // beim Painten immer alle Cursor ausschalten
1241*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
1242*b1cdbd2cSJim Jagielski
1243*b1cdbd2cSJim Jagielski sal_Bool bVis = sal_False;
1244*b1cdbd2cSJim Jagielski // ist Cursor sichtbar, dann verstecke den SV-Cursor
1245*b1cdbd2cSJim Jagielski if( pVisCrsr->IsVisible() && !aRect.IsOver( aCharRect ) ) //JP 18.06.97: ???
1246*b1cdbd2cSJim Jagielski {
1247*b1cdbd2cSJim Jagielski bVis = sal_True;
1248*b1cdbd2cSJim Jagielski pVisCrsr->Hide();
1249*b1cdbd2cSJim Jagielski }
1250*b1cdbd2cSJim Jagielski
1251*b1cdbd2cSJim Jagielski // Bereich neu painten
1252*b1cdbd2cSJim Jagielski ViewShell::Paint( rRect );
1253*b1cdbd2cSJim Jagielski
1254*b1cdbd2cSJim Jagielski if( bHasFocus && !bBasicHideCrsr )
1255*b1cdbd2cSJim Jagielski {
1256*b1cdbd2cSJim Jagielski SwShellCrsr* pAktCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
1257*b1cdbd2cSJim Jagielski // pAktCrsr->Invalidate( aRect );
1258*b1cdbd2cSJim Jagielski if( !ActionPend() )
1259*b1cdbd2cSJim Jagielski {
1260*b1cdbd2cSJim Jagielski // damit nicht rechts/unten die Raender abgeschnitten werden
1261*b1cdbd2cSJim Jagielski pAktCrsr->Invalidate( VisArea() );
1262*b1cdbd2cSJim Jagielski pAktCrsr->Show();
1263*b1cdbd2cSJim Jagielski }
1264*b1cdbd2cSJim Jagielski else
1265*b1cdbd2cSJim Jagielski pAktCrsr->Invalidate( aRect );
1266*b1cdbd2cSJim Jagielski
1267*b1cdbd2cSJim Jagielski }
1268*b1cdbd2cSJim Jagielski if( bSVCrsrVis && bVis ) // auch SV-Cursor wieder anzeigen
1269*b1cdbd2cSJim Jagielski pVisCrsr->Show();
1270*b1cdbd2cSJim Jagielski }
1271*b1cdbd2cSJim Jagielski
1272*b1cdbd2cSJim Jagielski
1273*b1cdbd2cSJim Jagielski
VisPortChgd(const SwRect & rRect)1274*b1cdbd2cSJim Jagielski void SwCrsrShell::VisPortChgd( const SwRect & rRect )
1275*b1cdbd2cSJim Jagielski {
1276*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1277*b1cdbd2cSJim Jagielski sal_Bool bVis; // beim Scrollen immer alle Cursor ausschalten
1278*b1cdbd2cSJim Jagielski
1279*b1cdbd2cSJim Jagielski // ist Cursor sichtbar, dann verstecke den SV-Cursor
1280*b1cdbd2cSJim Jagielski if( sal_True == ( bVis = pVisCrsr->IsVisible() ))
1281*b1cdbd2cSJim Jagielski pVisCrsr->Hide();
1282*b1cdbd2cSJim Jagielski
1283*b1cdbd2cSJim Jagielski bVisPortChgd = sal_True;
1284*b1cdbd2cSJim Jagielski aOldRBPos.X() = VisArea().Right();
1285*b1cdbd2cSJim Jagielski aOldRBPos.Y() = VisArea().Bottom();
1286*b1cdbd2cSJim Jagielski
1287*b1cdbd2cSJim Jagielski //Damit es es keine Probleme mit dem SV-Cursor gibt, wird in
1288*b1cdbd2cSJim Jagielski //ViewShell::VisPo.. ein Update() auf das Window gerufen.
1289*b1cdbd2cSJim Jagielski //Waehrend des Paintens duerfen aber nun wieder keine Selectionen
1290*b1cdbd2cSJim Jagielski //angezeigt werden, deshalb wird der Aufruf hier geklammert.
1291*b1cdbd2cSJim Jagielski ViewShell::VisPortChgd( rRect ); // Bereich verschieben
1292*b1cdbd2cSJim Jagielski
1293*b1cdbd2cSJim Jagielski /*
1294*b1cdbd2cSJim Jagielski SwRect aRect( rRect );
1295*b1cdbd2cSJim Jagielski if( VisArea().IsOver( aRect ) )
1296*b1cdbd2cSJim Jagielski pCurCrsr->Invalidate( aRect );
1297*b1cdbd2cSJim Jagielski */
1298*b1cdbd2cSJim Jagielski
1299*b1cdbd2cSJim Jagielski if( bSVCrsrVis && bVis ) // auch SV-Cursor wieder anzeigen
1300*b1cdbd2cSJim Jagielski pVisCrsr->Show();
1301*b1cdbd2cSJim Jagielski
1302*b1cdbd2cSJim Jagielski if( nCrsrMove )
1303*b1cdbd2cSJim Jagielski bInCMvVisportChgd = sal_True;
1304*b1cdbd2cSJim Jagielski
1305*b1cdbd2cSJim Jagielski bVisPortChgd = sal_False;
1306*b1cdbd2cSJim Jagielski }
1307*b1cdbd2cSJim Jagielski
1308*b1cdbd2cSJim Jagielski // aktualisiere den Crsrs, d.H. setze ihn wieder in den Content.
1309*b1cdbd2cSJim Jagielski // Das sollte nur aufgerufen werden, wenn der Cursor z.B. beim
1310*b1cdbd2cSJim Jagielski // Loeschen von Rahmen irgendwohin gesetzt wurde. Die Position
1311*b1cdbd2cSJim Jagielski // ergibt sich aus seiner aktuellen Position im Layout !!
1312*b1cdbd2cSJim Jagielski
1313*b1cdbd2cSJim Jagielski
UpdateCrsrPos()1314*b1cdbd2cSJim Jagielski void SwCrsrShell::UpdateCrsrPos()
1315*b1cdbd2cSJim Jagielski {
1316*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1317*b1cdbd2cSJim Jagielski ++nStartAction;
1318*b1cdbd2cSJim Jagielski SwShellCrsr* pShellCrsr = getShellCrsr( true );
1319*b1cdbd2cSJim Jagielski Size aOldSz( GetDocSize() );
1320*b1cdbd2cSJim Jagielski SwCntntNode *pCNode = pShellCrsr->GetCntntNode();
1321*b1cdbd2cSJim Jagielski SwCntntFrm *pFrm = pCNode ?
1322*b1cdbd2cSJim Jagielski pCNode->getLayoutFrm( GetLayout(), &pShellCrsr->GetPtPos(), pShellCrsr->GetPoint(), sal_False ) :0;
1323*b1cdbd2cSJim Jagielski if( !pFrm || (pFrm->IsTxtFrm() && ((SwTxtFrm*)pFrm)->IsHiddenNow()) )
1324*b1cdbd2cSJim Jagielski {
1325*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_NONE );
1326*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
1327*b1cdbd2cSJim Jagielski GetLayout()->GetCrsrOfst( pShellCrsr->GetPoint(), pShellCrsr->GetPtPos(),
1328*b1cdbd2cSJim Jagielski &aTmpState );
1329*b1cdbd2cSJim Jagielski if( pShellCrsr->HasMark())
1330*b1cdbd2cSJim Jagielski pShellCrsr->DeleteMark();
1331*b1cdbd2cSJim Jagielski }
1332*b1cdbd2cSJim Jagielski IGrammarContact *pGrammarContact = GetDoc() ? GetDoc()->getGrammarContact() : 0;
1333*b1cdbd2cSJim Jagielski if( pGrammarContact )
1334*b1cdbd2cSJim Jagielski pGrammarContact->updateCursorPosition( *pCurCrsr->GetPoint() );
1335*b1cdbd2cSJim Jagielski --nStartAction;
1336*b1cdbd2cSJim Jagielski if( aOldSz != GetDocSize() )
1337*b1cdbd2cSJim Jagielski SizeChgNotify();
1338*b1cdbd2cSJim Jagielski }
1339*b1cdbd2cSJim Jagielski
1340*b1cdbd2cSJim Jagielski // JP 30.04.99: Bug 65475 - falls Point/Mark in versteckten Bereichen
1341*b1cdbd2cSJim Jagielski // stehen, so mussen diese daraus verschoben werden
lcl_CheckHiddenSection(SwNodeIndex & rIdx)1342*b1cdbd2cSJim Jagielski static void lcl_CheckHiddenSection( SwNodeIndex& rIdx )
1343*b1cdbd2cSJim Jagielski {
1344*b1cdbd2cSJim Jagielski const SwSectionNode* pSectNd = rIdx.GetNode().FindSectionNode();
1345*b1cdbd2cSJim Jagielski if( pSectNd && pSectNd->GetSection().IsHiddenFlag() )
1346*b1cdbd2cSJim Jagielski {
1347*b1cdbd2cSJim Jagielski SwNodeIndex aTmp( *pSectNd );
1348*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
1349*b1cdbd2cSJim Jagielski const SwNode* pFrmNd =
1350*b1cdbd2cSJim Jagielski #endif
1351*b1cdbd2cSJim Jagielski rIdx.GetNodes().FindPrvNxtFrmNode( aTmp, pSectNd->EndOfSectionNode() );
1352*b1cdbd2cSJim Jagielski
1353*b1cdbd2cSJim Jagielski #if OSL_DEBUG_LEVEL > 1
1354*b1cdbd2cSJim Jagielski (void) pFrmNd;
1355*b1cdbd2cSJim Jagielski ASSERT( pFrmNd, "keinen Node mit Frames gefunden" );
1356*b1cdbd2cSJim Jagielski #endif
1357*b1cdbd2cSJim Jagielski rIdx = aTmp;
1358*b1cdbd2cSJim Jagielski }
1359*b1cdbd2cSJim Jagielski }
1360*b1cdbd2cSJim Jagielski
1361*b1cdbd2cSJim Jagielski // Try to set the cursor to the next visible content node.
lcl_CheckHiddenPara(SwPosition & rPos)1362*b1cdbd2cSJim Jagielski static void lcl_CheckHiddenPara( SwPosition& rPos )
1363*b1cdbd2cSJim Jagielski {
1364*b1cdbd2cSJim Jagielski SwNodeIndex aTmp( rPos.nNode );
1365*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = aTmp.GetNode().GetTxtNode();
1366*b1cdbd2cSJim Jagielski while( pTxtNd && pTxtNd->HasHiddenCharAttribute( true ) )
1367*b1cdbd2cSJim Jagielski {
1368*b1cdbd2cSJim Jagielski SwCntntNode* pCntnt = aTmp.GetNodes().GoNext( &aTmp );
1369*b1cdbd2cSJim Jagielski if ( pCntnt && pCntnt->IsTxtNode() )
1370*b1cdbd2cSJim Jagielski pTxtNd = (SwTxtNode*)pCntnt;
1371*b1cdbd2cSJim Jagielski else
1372*b1cdbd2cSJim Jagielski pTxtNd = 0;
1373*b1cdbd2cSJim Jagielski }
1374*b1cdbd2cSJim Jagielski
1375*b1cdbd2cSJim Jagielski if ( pTxtNd )
1376*b1cdbd2cSJim Jagielski rPos = SwPosition( aTmp, SwIndex( pTxtNd, 0 ) );
1377*b1cdbd2cSJim Jagielski }
1378*b1cdbd2cSJim Jagielski
1379*b1cdbd2cSJim Jagielski // --> OD 2005-12-14 #i27301# - helper class, which notifies the accessibility
1380*b1cdbd2cSJim Jagielski // about invalid text selections in its destructor
1381*b1cdbd2cSJim Jagielski class SwNotifyAccAboutInvalidTextSelections
1382*b1cdbd2cSJim Jagielski {
1383*b1cdbd2cSJim Jagielski private:
1384*b1cdbd2cSJim Jagielski SwCrsrShell& mrCrsrSh;
1385*b1cdbd2cSJim Jagielski
1386*b1cdbd2cSJim Jagielski public:
SwNotifyAccAboutInvalidTextSelections(SwCrsrShell & _rCrsrSh)1387*b1cdbd2cSJim Jagielski SwNotifyAccAboutInvalidTextSelections( SwCrsrShell& _rCrsrSh )
1388*b1cdbd2cSJim Jagielski : mrCrsrSh( _rCrsrSh )
1389*b1cdbd2cSJim Jagielski {}
1390*b1cdbd2cSJim Jagielski
~SwNotifyAccAboutInvalidTextSelections()1391*b1cdbd2cSJim Jagielski ~SwNotifyAccAboutInvalidTextSelections()
1392*b1cdbd2cSJim Jagielski {
1393*b1cdbd2cSJim Jagielski mrCrsrSh.InvalidateAccessibleParaTextSelection();
1394*b1cdbd2cSJim Jagielski }
1395*b1cdbd2cSJim Jagielski };
1396*b1cdbd2cSJim Jagielski // <--
UpdateCrsr(sal_uInt16 eFlags,sal_Bool bIdleEnd)1397*b1cdbd2cSJim Jagielski void SwCrsrShell::UpdateCrsr( sal_uInt16 eFlags, sal_Bool bIdleEnd )
1398*b1cdbd2cSJim Jagielski {
1399*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
1400*b1cdbd2cSJim Jagielski
1401*b1cdbd2cSJim Jagielski ClearUpCrsrs();
1402*b1cdbd2cSJim Jagielski
1403*b1cdbd2cSJim Jagielski // erfrage den Count fuer die Start-/End-Actions und ob die Shell
1404*b1cdbd2cSJim Jagielski // ueberhaupt den Focus hat
1405*b1cdbd2cSJim Jagielski // if( ActionPend() /*|| !bHasFocus*/ )
1406*b1cdbd2cSJim Jagielski //JP 12.01.98: Bug #46496# - es muss innerhalb einer BasicAction der
1407*b1cdbd2cSJim Jagielski // Cursor geupdatet werden; um z.B. den TabellenCursor zu
1408*b1cdbd2cSJim Jagielski // erzeugen. Im EndAction wird jetzt das UpdateCrsr gerufen!
1409*b1cdbd2cSJim Jagielski if( ActionPend() && BasicActionPend() )
1410*b1cdbd2cSJim Jagielski {
1411*b1cdbd2cSJim Jagielski if ( eFlags & SwCrsrShell::READONLY )
1412*b1cdbd2cSJim Jagielski bIgnoreReadonly = sal_True;
1413*b1cdbd2cSJim Jagielski return; // wenn nicht, dann kein Update !!
1414*b1cdbd2cSJim Jagielski }
1415*b1cdbd2cSJim Jagielski
1416*b1cdbd2cSJim Jagielski SwNotifyAccAboutInvalidTextSelections aInvalidateTextSelections( *this );
1417*b1cdbd2cSJim Jagielski
1418*b1cdbd2cSJim Jagielski if ( bIgnoreReadonly )
1419*b1cdbd2cSJim Jagielski {
1420*b1cdbd2cSJim Jagielski bIgnoreReadonly = sal_False;
1421*b1cdbd2cSJim Jagielski eFlags |= SwCrsrShell::READONLY;
1422*b1cdbd2cSJim Jagielski }
1423*b1cdbd2cSJim Jagielski
1424*b1cdbd2cSJim Jagielski if( eFlags & SwCrsrShell::CHKRANGE ) // alle Cursor-Bewegungen auf
1425*b1cdbd2cSJim Jagielski CheckRange( pCurCrsr ); // ueberlappende Bereiche testen
1426*b1cdbd2cSJim Jagielski
1427*b1cdbd2cSJim Jagielski if( !bIdleEnd )
1428*b1cdbd2cSJim Jagielski CheckTblBoxCntnt();
1429*b1cdbd2cSJim Jagielski
1430*b1cdbd2cSJim Jagielski // steht der akt. Crsr in einer Tabelle und in unterschiedlichen Boxen
1431*b1cdbd2cSJim Jagielski // (oder ist noch TabellenMode), dann gilt der Tabellen Mode
1432*b1cdbd2cSJim Jagielski SwPaM* pTstCrsr = getShellCrsr( true );
1433*b1cdbd2cSJim Jagielski if( pTstCrsr->HasMark() && !pBlockCrsr &&
1434*b1cdbd2cSJim Jagielski pDoc->IsIdxInTbl( pTstCrsr->GetPoint()->nNode ) &&
1435*b1cdbd2cSJim Jagielski ( pTblCrsr ||
1436*b1cdbd2cSJim Jagielski pTstCrsr->GetNode( sal_True )->StartOfSectionNode() !=
1437*b1cdbd2cSJim Jagielski pTstCrsr->GetNode( sal_False )->StartOfSectionNode() ) )
1438*b1cdbd2cSJim Jagielski {
1439*b1cdbd2cSJim Jagielski SwShellCrsr* pITmpCrsr = getShellCrsr( true );
1440*b1cdbd2cSJim Jagielski Point aTmpPt( pITmpCrsr->GetPtPos() );
1441*b1cdbd2cSJim Jagielski Point aTmpMk( pITmpCrsr->GetMkPos() );
1442*b1cdbd2cSJim Jagielski SwPosition* pPos = pITmpCrsr->GetPoint();
1443*b1cdbd2cSJim Jagielski
1444*b1cdbd2cSJim Jagielski // JP 30.04.99: Bug 65475 - falls Point/Mark in versteckten Bereichen
1445*b1cdbd2cSJim Jagielski // stehen, so mussen diese daraus verschoben werden
1446*b1cdbd2cSJim Jagielski lcl_CheckHiddenSection( pPos->nNode );
1447*b1cdbd2cSJim Jagielski lcl_CheckHiddenSection( pITmpCrsr->GetMark()->nNode );
1448*b1cdbd2cSJim Jagielski
1449*b1cdbd2cSJim Jagielski // Move cursor out of hidden paragraphs
1450*b1cdbd2cSJim Jagielski if ( !GetViewOptions()->IsShowHiddenChar() )
1451*b1cdbd2cSJim Jagielski {
1452*b1cdbd2cSJim Jagielski lcl_CheckHiddenPara( *pPos );
1453*b1cdbd2cSJim Jagielski lcl_CheckHiddenPara( *pITmpCrsr->GetMark() );
1454*b1cdbd2cSJim Jagielski }
1455*b1cdbd2cSJim Jagielski
1456*b1cdbd2cSJim Jagielski SwCntntFrm *pTblFrm = pPos->nNode.GetNode().GetCntntNode()->
1457*b1cdbd2cSJim Jagielski getLayoutFrm( GetLayout(), &aTmpPt, pPos, sal_False );
1458*b1cdbd2cSJim Jagielski
1459*b1cdbd2cSJim Jagielski ASSERT( pTblFrm, "Tabelle Crsr nicht im Content ??" );
1460*b1cdbd2cSJim Jagielski
1461*b1cdbd2cSJim Jagielski // --> FME 2005-12-02 #126107# Make code robust. The table
1462*b1cdbd2cSJim Jagielski // cursor may point to a table in a currently inactive header.
1463*b1cdbd2cSJim Jagielski SwTabFrm *pTab = pTblFrm ? pTblFrm->FindTabFrm() : 0;
1464*b1cdbd2cSJim Jagielski // <--
1465*b1cdbd2cSJim Jagielski
1466*b1cdbd2cSJim Jagielski if ( pTab && pTab->GetTable()->GetRowsToRepeat() > 0 )
1467*b1cdbd2cSJim Jagielski {
1468*b1cdbd2cSJim Jagielski // First check if point is in repeated headline:
1469*b1cdbd2cSJim Jagielski bool bInRepeatedHeadline = pTab->IsFollow() && pTab->IsInHeadline( *pTblFrm );
1470*b1cdbd2cSJim Jagielski
1471*b1cdbd2cSJim Jagielski // Second check if mark is in repeated headline:
1472*b1cdbd2cSJim Jagielski if ( !bInRepeatedHeadline )
1473*b1cdbd2cSJim Jagielski {
1474*b1cdbd2cSJim Jagielski SwCntntFrm* pMarkTblFrm = pITmpCrsr->GetCntntNode( sal_False )->
1475*b1cdbd2cSJim Jagielski getLayoutFrm( GetLayout(), &aTmpMk, pITmpCrsr->GetMark(), sal_False );
1476*b1cdbd2cSJim Jagielski ASSERT( pMarkTblFrm, "Tabelle Crsr nicht im Content ??" );
1477*b1cdbd2cSJim Jagielski
1478*b1cdbd2cSJim Jagielski if ( pMarkTblFrm )
1479*b1cdbd2cSJim Jagielski {
1480*b1cdbd2cSJim Jagielski SwTabFrm* pMarkTab = pMarkTblFrm->FindTabFrm();
1481*b1cdbd2cSJim Jagielski ASSERT( pMarkTab, "Tabelle Crsr nicht im Content ??" );
1482*b1cdbd2cSJim Jagielski
1483*b1cdbd2cSJim Jagielski // --> FME 2005-11-28 #120360# Make code robust:
1484*b1cdbd2cSJim Jagielski if ( pMarkTab )
1485*b1cdbd2cSJim Jagielski {
1486*b1cdbd2cSJim Jagielski bInRepeatedHeadline = pMarkTab->IsFollow() && pMarkTab->IsInHeadline( *pMarkTblFrm );
1487*b1cdbd2cSJim Jagielski }
1488*b1cdbd2cSJim Jagielski // <--
1489*b1cdbd2cSJim Jagielski }
1490*b1cdbd2cSJim Jagielski }
1491*b1cdbd2cSJim Jagielski
1492*b1cdbd2cSJim Jagielski // No table cursor in repeaded headlines:
1493*b1cdbd2cSJim Jagielski if ( bInRepeatedHeadline )
1494*b1cdbd2cSJim Jagielski {
1495*b1cdbd2cSJim Jagielski pTblFrm = 0;
1496*b1cdbd2cSJim Jagielski
1497*b1cdbd2cSJim Jagielski SwPosSection fnPosSect = *pPos < *pITmpCrsr->GetMark()
1498*b1cdbd2cSJim Jagielski ? fnSectionStart
1499*b1cdbd2cSJim Jagielski : fnSectionEnd;
1500*b1cdbd2cSJim Jagielski
1501*b1cdbd2cSJim Jagielski // dann nur innerhalb der Box selektieren
1502*b1cdbd2cSJim Jagielski if( pTblCrsr )
1503*b1cdbd2cSJim Jagielski {
1504*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
1505*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *pTblCrsr->GetMark();
1506*b1cdbd2cSJim Jagielski pCurCrsr->GetMkPos() = pTblCrsr->GetMkPos();
1507*b1cdbd2cSJim Jagielski pTblCrsr->DeleteMark();
1508*b1cdbd2cSJim Jagielski pTblCrsr->SwSelPaintRects::Hide();
1509*b1cdbd2cSJim Jagielski }
1510*b1cdbd2cSJim Jagielski
1511*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *pCurCrsr->GetMark();
1512*b1cdbd2cSJim Jagielski (*fnSectionCurr)( *pCurCrsr, fnPosSect );
1513*b1cdbd2cSJim Jagielski }
1514*b1cdbd2cSJim Jagielski }
1515*b1cdbd2cSJim Jagielski
1516*b1cdbd2cSJim Jagielski // wir wollen wirklich eine Tabellen-Selektion
1517*b1cdbd2cSJim Jagielski if( pTab && pTblFrm )
1518*b1cdbd2cSJim Jagielski {
1519*b1cdbd2cSJim Jagielski if( !pTblCrsr )
1520*b1cdbd2cSJim Jagielski {
1521*b1cdbd2cSJim Jagielski pTblCrsr = new SwShellTableCrsr( *this,
1522*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark(), pCurCrsr->GetMkPos(),
1523*b1cdbd2cSJim Jagielski *pPos, aTmpPt );
1524*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1525*b1cdbd2cSJim Jagielski pCurCrsr->SwSelPaintRects::Hide();
1526*b1cdbd2cSJim Jagielski
1527*b1cdbd2cSJim Jagielski CheckTblBoxCntnt();
1528*b1cdbd2cSJim Jagielski }
1529*b1cdbd2cSJim Jagielski
1530*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_NONE );
1531*b1cdbd2cSJim Jagielski aTmpState.bRealHeight = sal_True;
1532*b1cdbd2cSJim Jagielski if( !pTblFrm->GetCharRect( aCharRect, *pTblCrsr->GetPoint(), &aTmpState ) )
1533*b1cdbd2cSJim Jagielski {
1534*b1cdbd2cSJim Jagielski Point aCentrPt( aCharRect.Center() );
1535*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
1536*b1cdbd2cSJim Jagielski pTblFrm->GetCrsrOfst( pTblCrsr->GetPoint(), aCentrPt, &aTmpState );
1537*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
1538*b1cdbd2cSJim Jagielski pTblFrm->GetCharRect( aCharRect, *pTblCrsr->GetPoint() );
1539*b1cdbd2cSJim Jagielski #else
1540*b1cdbd2cSJim Jagielski if ( !pTblFrm->GetCharRect( aCharRect, *pTblCrsr->GetPoint() ) )
1541*b1cdbd2cSJim Jagielski ASSERT( !this, "GetCharRect failed." );
1542*b1cdbd2cSJim Jagielski #endif
1543*b1cdbd2cSJim Jagielski }
1544*b1cdbd2cSJim Jagielski // ALIGNRECT( aCharRect );
1545*b1cdbd2cSJim Jagielski
1546*b1cdbd2cSJim Jagielski pVisCrsr->Hide(); // sichtbaren Cursor immer verstecken
1547*b1cdbd2cSJim Jagielski // Curosr in den sichtbaren Bereich scrollen
1548*b1cdbd2cSJim Jagielski if( (eFlags & SwCrsrShell::SCROLLWIN) &&
1549*b1cdbd2cSJim Jagielski (HasSelection() || eFlags & SwCrsrShell::READONLY ||
1550*b1cdbd2cSJim Jagielski !IsCrsrReadonly()) )
1551*b1cdbd2cSJim Jagielski {
1552*b1cdbd2cSJim Jagielski SwFrm* pBoxFrm = pTblFrm;
1553*b1cdbd2cSJim Jagielski while( pBoxFrm && !pBoxFrm->IsCellFrm() )
1554*b1cdbd2cSJim Jagielski pBoxFrm = pBoxFrm->GetUpper();
1555*b1cdbd2cSJim Jagielski if( pBoxFrm && pBoxFrm->Frm().HasArea() )
1556*b1cdbd2cSJim Jagielski MakeVisible( pBoxFrm->Frm() );
1557*b1cdbd2cSJim Jagielski else
1558*b1cdbd2cSJim Jagielski MakeVisible( aCharRect );
1559*b1cdbd2cSJim Jagielski }
1560*b1cdbd2cSJim Jagielski
1561*b1cdbd2cSJim Jagielski // lasse vom Layout die Crsr in den Boxen erzeugen
1562*b1cdbd2cSJim Jagielski if( pTblCrsr->IsCrsrMovedUpdt() )
1563*b1cdbd2cSJim Jagielski GetLayout()->MakeTblCrsrs( *pTblCrsr );
1564*b1cdbd2cSJim Jagielski if( bHasFocus && !bBasicHideCrsr )
1565*b1cdbd2cSJim Jagielski pTblCrsr->Show();
1566*b1cdbd2cSJim Jagielski
1567*b1cdbd2cSJim Jagielski // Cursor-Points auf die neuen Positionen setzen
1568*b1cdbd2cSJim Jagielski pTblCrsr->GetPtPos().X() = aCharRect.Left();
1569*b1cdbd2cSJim Jagielski pTblCrsr->GetPtPos().Y() = aCharRect.Top();
1570*b1cdbd2cSJim Jagielski
1571*b1cdbd2cSJim Jagielski if( bSVCrsrVis )
1572*b1cdbd2cSJim Jagielski {
1573*b1cdbd2cSJim Jagielski aCrsrHeight.X() = 0;
1574*b1cdbd2cSJim Jagielski aCrsrHeight.Y() = aTmpState.aRealHeight.Y() < 0 ?
1575*b1cdbd2cSJim Jagielski -aCharRect.Width() : aCharRect.Height();
1576*b1cdbd2cSJim Jagielski pVisCrsr->Show(); // wieder anzeigen
1577*b1cdbd2cSJim Jagielski }
1578*b1cdbd2cSJim Jagielski eMvState = MV_NONE; // Status fuers Crsr-Travelling - GetCrsrOfst
1579*b1cdbd2cSJim Jagielski if( pTblFrm && Imp()->IsAccessible() )
1580*b1cdbd2cSJim Jagielski Imp()->InvalidateAccessibleCursorPosition( pTblFrm );
1581*b1cdbd2cSJim Jagielski return;
1582*b1cdbd2cSJim Jagielski }
1583*b1cdbd2cSJim Jagielski }
1584*b1cdbd2cSJim Jagielski
1585*b1cdbd2cSJim Jagielski if( pTblCrsr )
1586*b1cdbd2cSJim Jagielski {
1587*b1cdbd2cSJim Jagielski // Cursor Ring loeschen
1588*b1cdbd2cSJim Jagielski while( pCurCrsr->GetNext() != pCurCrsr )
1589*b1cdbd2cSJim Jagielski delete pCurCrsr->GetNext();
1590*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1591*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *pTblCrsr->GetPoint();
1592*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos() = pTblCrsr->GetPtPos();
1593*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
1594*b1cdbd2cSJim Jagielski }
1595*b1cdbd2cSJim Jagielski
1596*b1cdbd2cSJim Jagielski pVisCrsr->Hide(); // sichtbaren Cursor immer verstecken
1597*b1cdbd2cSJim Jagielski
1598*b1cdbd2cSJim Jagielski // sind wir vielleicht in einer geschuetzten/versteckten Section ?
1599*b1cdbd2cSJim Jagielski {
1600*b1cdbd2cSJim Jagielski SwShellCrsr* pShellCrsr = getShellCrsr( true );
1601*b1cdbd2cSJim Jagielski sal_Bool bChgState = sal_True;
1602*b1cdbd2cSJim Jagielski const SwSectionNode* pSectNd = pShellCrsr->GetNode()->FindSectionNode();
1603*b1cdbd2cSJim Jagielski if( pSectNd && ( pSectNd->GetSection().IsHiddenFlag() ||
1604*b1cdbd2cSJim Jagielski ( !IsReadOnlyAvailable() &&
1605*b1cdbd2cSJim Jagielski pSectNd->GetSection().IsProtectFlag() &&
1606*b1cdbd2cSJim Jagielski ( !pDoc->GetDocShell() ||
1607*b1cdbd2cSJim Jagielski !pDoc->GetDocShell()->IsReadOnly() || bAllProtect )) ) )
1608*b1cdbd2cSJim Jagielski {
1609*b1cdbd2cSJim Jagielski if( !FindValidCntntNode( !HasDrawView() ||
1610*b1cdbd2cSJim Jagielski 0 == Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount()))
1611*b1cdbd2cSJim Jagielski {
1612*b1cdbd2cSJim Jagielski // alles ist geschuetzt / versteckt -> besonderer Mode
1613*b1cdbd2cSJim Jagielski if( bAllProtect && !IsReadOnlyAvailable() &&
1614*b1cdbd2cSJim Jagielski pSectNd->GetSection().IsProtectFlag() )
1615*b1cdbd2cSJim Jagielski bChgState = sal_False;
1616*b1cdbd2cSJim Jagielski else
1617*b1cdbd2cSJim Jagielski {
1618*b1cdbd2cSJim Jagielski eMvState = MV_NONE; // Status fuers Crsr-Travelling
1619*b1cdbd2cSJim Jagielski bAllProtect = sal_True;
1620*b1cdbd2cSJim Jagielski if( GetDoc()->GetDocShell() )
1621*b1cdbd2cSJim Jagielski {
1622*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->SetReadOnlyUI( sal_True );
1623*b1cdbd2cSJim Jagielski CallChgLnk(); // UI bescheid sagen!
1624*b1cdbd2cSJim Jagielski }
1625*b1cdbd2cSJim Jagielski return;
1626*b1cdbd2cSJim Jagielski }
1627*b1cdbd2cSJim Jagielski }
1628*b1cdbd2cSJim Jagielski }
1629*b1cdbd2cSJim Jagielski if( bChgState )
1630*b1cdbd2cSJim Jagielski {
1631*b1cdbd2cSJim Jagielski sal_Bool bWasAllProtect = bAllProtect;
1632*b1cdbd2cSJim Jagielski bAllProtect = sal_False;
1633*b1cdbd2cSJim Jagielski if( bWasAllProtect && GetDoc()->GetDocShell() &&
1634*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->IsReadOnlyUI() )
1635*b1cdbd2cSJim Jagielski {
1636*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->SetReadOnlyUI( sal_False );
1637*b1cdbd2cSJim Jagielski CallChgLnk(); // UI bescheid sagen!
1638*b1cdbd2cSJim Jagielski }
1639*b1cdbd2cSJim Jagielski }
1640*b1cdbd2cSJim Jagielski }
1641*b1cdbd2cSJim Jagielski
1642*b1cdbd2cSJim Jagielski UpdateCrsrPos();
1643*b1cdbd2cSJim Jagielski
1644*b1cdbd2cSJim Jagielski // #100722# The cursor must always point into content; there's some code
1645*b1cdbd2cSJim Jagielski // that relies on this. (E.g. in SwEditShell::GetScriptType, which always
1646*b1cdbd2cSJim Jagielski // loops _behind_ the last node in the selection, which always works if you
1647*b1cdbd2cSJim Jagielski // are in content.) To achieve this, we'll force cursor(s) to point into
1648*b1cdbd2cSJim Jagielski // content, if UpdateCrsrPos() hasn't already done so.
1649*b1cdbd2cSJim Jagielski SwPaM* pCmp = pCurCrsr;
1650*b1cdbd2cSJim Jagielski do
1651*b1cdbd2cSJim Jagielski {
1652*b1cdbd2cSJim Jagielski // start will move forwards, end will move backwards
1653*b1cdbd2cSJim Jagielski bool bPointIsStart = ( pCmp->Start() == pCmp->GetPoint() );
1654*b1cdbd2cSJim Jagielski
1655*b1cdbd2cSJim Jagielski // move point; forward if it's the start, backwards if it's the end
1656*b1cdbd2cSJim Jagielski if( ! pCmp->GetPoint()->nNode.GetNode().IsCntntNode() )
1657*b1cdbd2cSJim Jagielski pCmp->Move( bPointIsStart ? fnMoveForward : fnMoveBackward,
1658*b1cdbd2cSJim Jagielski fnGoCntnt );
1659*b1cdbd2cSJim Jagielski
1660*b1cdbd2cSJim Jagielski // move mark (if exists); forward if it's the start, else backwards
1661*b1cdbd2cSJim Jagielski if( pCmp->HasMark() )
1662*b1cdbd2cSJim Jagielski {
1663*b1cdbd2cSJim Jagielski if( ! pCmp->GetMark()->nNode.GetNode().IsCntntNode() )
1664*b1cdbd2cSJim Jagielski {
1665*b1cdbd2cSJim Jagielski pCmp->Exchange();
1666*b1cdbd2cSJim Jagielski pCmp->Move( !bPointIsStart ? fnMoveForward : fnMoveBackward,
1667*b1cdbd2cSJim Jagielski fnGoCntnt );
1668*b1cdbd2cSJim Jagielski pCmp->Exchange();
1669*b1cdbd2cSJim Jagielski }
1670*b1cdbd2cSJim Jagielski }
1671*b1cdbd2cSJim Jagielski
1672*b1cdbd2cSJim Jagielski // iterate to next PaM in ring
1673*b1cdbd2cSJim Jagielski pCmp = static_cast<SwPaM*>( pCmp->GetNext() );
1674*b1cdbd2cSJim Jagielski }
1675*b1cdbd2cSJim Jagielski while( pCmp != pCurCrsr );
1676*b1cdbd2cSJim Jagielski
1677*b1cdbd2cSJim Jagielski
1678*b1cdbd2cSJim Jagielski SwRect aOld( aCharRect );
1679*b1cdbd2cSJim Jagielski sal_Bool bFirst = sal_True;
1680*b1cdbd2cSJim Jagielski SwCntntFrm *pFrm;
1681*b1cdbd2cSJim Jagielski int nLoopCnt = 100;
1682*b1cdbd2cSJim Jagielski SwShellCrsr* pShellCrsr = getShellCrsr( true );
1683*b1cdbd2cSJim Jagielski
1684*b1cdbd2cSJim Jagielski do {
1685*b1cdbd2cSJim Jagielski sal_Bool bAgainst;
1686*b1cdbd2cSJim Jagielski do {
1687*b1cdbd2cSJim Jagielski bAgainst = sal_False;
1688*b1cdbd2cSJim Jagielski pFrm = pShellCrsr->GetCntntNode()->getLayoutFrm( GetLayout(),
1689*b1cdbd2cSJim Jagielski &pShellCrsr->GetPtPos(), pShellCrsr->GetPoint(), sal_False );
1690*b1cdbd2cSJim Jagielski // ist der Frm nicht mehr vorhanden, dann muss das gesamte Layout
1691*b1cdbd2cSJim Jagielski // erzeugt werden, weil ja mal hier einer vorhanden war !!
1692*b1cdbd2cSJim Jagielski if ( !pFrm )
1693*b1cdbd2cSJim Jagielski {
1694*b1cdbd2cSJim Jagielski do
1695*b1cdbd2cSJim Jagielski {
1696*b1cdbd2cSJim Jagielski CalcLayout();
1697*b1cdbd2cSJim Jagielski pFrm = pShellCrsr->GetCntntNode()->getLayoutFrm( GetLayout(),
1698*b1cdbd2cSJim Jagielski &pShellCrsr->GetPtPos(), pShellCrsr->GetPoint(), sal_False );
1699*b1cdbd2cSJim Jagielski } while( !pFrm );
1700*b1cdbd2cSJim Jagielski }
1701*b1cdbd2cSJim Jagielski else if ( Imp()->IsIdleAction() )
1702*b1cdbd2cSJim Jagielski //Wir stellen sicher, dass anstaendig Formatiert wurde #42224#
1703*b1cdbd2cSJim Jagielski pFrm->PrepareCrsr();
1704*b1cdbd2cSJim Jagielski
1705*b1cdbd2cSJim Jagielski // im geschuetzten Fly? aber bei Rahmenselektion ignorieren
1706*b1cdbd2cSJim Jagielski if( !IsReadOnlyAvailable() && pFrm->IsProtected() &&
1707*b1cdbd2cSJim Jagielski ( !Imp()->GetDrawView() ||
1708*b1cdbd2cSJim Jagielski !Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount() ) &&
1709*b1cdbd2cSJim Jagielski (!pDoc->GetDocShell() ||
1710*b1cdbd2cSJim Jagielski !pDoc->GetDocShell()->IsReadOnly() || bAllProtect ) )
1711*b1cdbd2cSJim Jagielski {
1712*b1cdbd2cSJim Jagielski // dann suche eine gueltige Position
1713*b1cdbd2cSJim Jagielski sal_Bool bChgState = sal_True;
1714*b1cdbd2cSJim Jagielski if( !FindValidCntntNode(!HasDrawView() ||
1715*b1cdbd2cSJim Jagielski 0 == Imp()->GetDrawView()->GetMarkedObjectList().GetMarkCount()))
1716*b1cdbd2cSJim Jagielski {
1717*b1cdbd2cSJim Jagielski // alles ist geschuetzt / versteckt -> besonderer Mode
1718*b1cdbd2cSJim Jagielski if( bAllProtect )
1719*b1cdbd2cSJim Jagielski bChgState = sal_False;
1720*b1cdbd2cSJim Jagielski else
1721*b1cdbd2cSJim Jagielski {
1722*b1cdbd2cSJim Jagielski eMvState = MV_NONE; // Status fuers Crsr-Travelling
1723*b1cdbd2cSJim Jagielski bAllProtect = sal_True;
1724*b1cdbd2cSJim Jagielski if( GetDoc()->GetDocShell() )
1725*b1cdbd2cSJim Jagielski {
1726*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->SetReadOnlyUI( sal_True );
1727*b1cdbd2cSJim Jagielski CallChgLnk(); // UI bescheid sagen!
1728*b1cdbd2cSJim Jagielski }
1729*b1cdbd2cSJim Jagielski return;
1730*b1cdbd2cSJim Jagielski }
1731*b1cdbd2cSJim Jagielski }
1732*b1cdbd2cSJim Jagielski
1733*b1cdbd2cSJim Jagielski if( bChgState )
1734*b1cdbd2cSJim Jagielski {
1735*b1cdbd2cSJim Jagielski sal_Bool bWasAllProtect = bAllProtect;
1736*b1cdbd2cSJim Jagielski bAllProtect = sal_False;
1737*b1cdbd2cSJim Jagielski if( bWasAllProtect && GetDoc()->GetDocShell() &&
1738*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->IsReadOnlyUI() )
1739*b1cdbd2cSJim Jagielski {
1740*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->SetReadOnlyUI( sal_False );
1741*b1cdbd2cSJim Jagielski CallChgLnk(); // UI bescheid sagen!
1742*b1cdbd2cSJim Jagielski }
1743*b1cdbd2cSJim Jagielski bAllProtect = sal_False;
1744*b1cdbd2cSJim Jagielski bAgainst = sal_True; // nochmal den richigen Frm suchen
1745*b1cdbd2cSJim Jagielski }
1746*b1cdbd2cSJim Jagielski }
1747*b1cdbd2cSJim Jagielski } while( bAgainst );
1748*b1cdbd2cSJim Jagielski
1749*b1cdbd2cSJim Jagielski if( !( eFlags & SwCrsrShell::NOCALRECT ))
1750*b1cdbd2cSJim Jagielski {
1751*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( eMvState );
1752*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
1753*b1cdbd2cSJim Jagielski aTmpState.bRealHeight = sal_True;
1754*b1cdbd2cSJim Jagielski aTmpState.bRealWidth = IsOverwriteCrsr();
1755*b1cdbd2cSJim Jagielski aTmpState.nCursorBidiLevel = pShellCrsr->GetCrsrBidiLevel();
1756*b1cdbd2cSJim Jagielski
1757*b1cdbd2cSJim Jagielski // #i27615#,#i30453#
1758*b1cdbd2cSJim Jagielski SwSpecialPos aSpecialPos;
1759*b1cdbd2cSJim Jagielski aSpecialPos.nExtendRange = SP_EXTEND_RANGE_BEFORE;
1760*b1cdbd2cSJim Jagielski if (pShellCrsr->IsInFrontOfLabel())
1761*b1cdbd2cSJim Jagielski {
1762*b1cdbd2cSJim Jagielski aTmpState.pSpecialPos = &aSpecialPos;
1763*b1cdbd2cSJim Jagielski }
1764*b1cdbd2cSJim Jagielski
1765*b1cdbd2cSJim Jagielski if( !pFrm->GetCharRect( aCharRect, *pShellCrsr->GetPoint(), &aTmpState ) )
1766*b1cdbd2cSJim Jagielski {
1767*b1cdbd2cSJim Jagielski Point& rPt = pShellCrsr->GetPtPos();
1768*b1cdbd2cSJim Jagielski rPt = aCharRect.Center();
1769*b1cdbd2cSJim Jagielski pFrm->GetCrsrOfst( pShellCrsr->GetPoint(), rPt, &aTmpState );
1770*b1cdbd2cSJim Jagielski }
1771*b1cdbd2cSJim Jagielski // ALIGNRECT( aCharRect );
1772*b1cdbd2cSJim Jagielski
1773*b1cdbd2cSJim Jagielski if( !pShellCrsr->HasMark() )
1774*b1cdbd2cSJim Jagielski aCrsrHeight = aTmpState.aRealHeight;
1775*b1cdbd2cSJim Jagielski else
1776*b1cdbd2cSJim Jagielski {
1777*b1cdbd2cSJim Jagielski aCrsrHeight.X() = 0;
1778*b1cdbd2cSJim Jagielski aCrsrHeight.Y() = aTmpState.aRealHeight.Y() < 0 ?
1779*b1cdbd2cSJim Jagielski -aCharRect.Width() : aCharRect.Height();
1780*b1cdbd2cSJim Jagielski }
1781*b1cdbd2cSJim Jagielski }
1782*b1cdbd2cSJim Jagielski else
1783*b1cdbd2cSJim Jagielski {
1784*b1cdbd2cSJim Jagielski aCrsrHeight.X() = 0;
1785*b1cdbd2cSJim Jagielski aCrsrHeight.Y() = aCharRect.Height();
1786*b1cdbd2cSJim Jagielski }
1787*b1cdbd2cSJim Jagielski
1788*b1cdbd2cSJim Jagielski if( !bFirst && aOld == aCharRect )
1789*b1cdbd2cSJim Jagielski break;
1790*b1cdbd2cSJim Jagielski
1791*b1cdbd2cSJim Jagielski // falls das Layout meint, nach dem 100 durchlauf ist man immer noch
1792*b1cdbd2cSJim Jagielski // im Fluss, sollte man die akt. Pos. als gegeben hinnehmen!
1793*b1cdbd2cSJim Jagielski // siehe Bug: 29658
1794*b1cdbd2cSJim Jagielski if( !--nLoopCnt )
1795*b1cdbd2cSJim Jagielski {
1796*b1cdbd2cSJim Jagielski ASSERT( !this, "Endlosschleife? CharRect != OldCharRect ");
1797*b1cdbd2cSJim Jagielski break;
1798*b1cdbd2cSJim Jagielski }
1799*b1cdbd2cSJim Jagielski aOld = aCharRect;
1800*b1cdbd2cSJim Jagielski bFirst = sal_False;
1801*b1cdbd2cSJim Jagielski
1802*b1cdbd2cSJim Jagielski // Cursor-Points auf die neuen Positionen setzen
1803*b1cdbd2cSJim Jagielski pShellCrsr->GetPtPos().X() = aCharRect.Left();
1804*b1cdbd2cSJim Jagielski pShellCrsr->GetPtPos().Y() = aCharRect.Top();
1805*b1cdbd2cSJim Jagielski
1806*b1cdbd2cSJim Jagielski if( !(eFlags & SwCrsrShell::UPDOWN )) // alte Pos. von Up/Down loeschen
1807*b1cdbd2cSJim Jagielski {
1808*b1cdbd2cSJim Jagielski pFrm->Calc();
1809*b1cdbd2cSJim Jagielski nUpDownX = pFrm->IsVertical() ?
1810*b1cdbd2cSJim Jagielski aCharRect.Top() - pFrm->Frm().Top() :
1811*b1cdbd2cSJim Jagielski aCharRect.Left() - pFrm->Frm().Left();
1812*b1cdbd2cSJim Jagielski }
1813*b1cdbd2cSJim Jagielski
1814*b1cdbd2cSJim Jagielski // Curosr in den sichtbaren Bereich scrollen
1815*b1cdbd2cSJim Jagielski if( bHasFocus && eFlags & SwCrsrShell::SCROLLWIN &&
1816*b1cdbd2cSJim Jagielski (HasSelection() || eFlags & SwCrsrShell::READONLY ||
1817*b1cdbd2cSJim Jagielski !IsCrsrReadonly() || GetViewOptions()->IsSelectionInReadonly()) )
1818*b1cdbd2cSJim Jagielski {
1819*b1cdbd2cSJim Jagielski //JP 30.04.99: damit das EndAction, beim evtuellen Scrollen, den
1820*b1cdbd2cSJim Jagielski // SV-Crsr nicht wieder sichtbar macht, wird hier das Flag
1821*b1cdbd2cSJim Jagielski // gesichert und zurueckgesetzt.
1822*b1cdbd2cSJim Jagielski sal_Bool bSav = bSVCrsrVis; bSVCrsrVis = sal_False;
1823*b1cdbd2cSJim Jagielski MakeSelVisible();
1824*b1cdbd2cSJim Jagielski bSVCrsrVis = bSav;
1825*b1cdbd2cSJim Jagielski }
1826*b1cdbd2cSJim Jagielski
1827*b1cdbd2cSJim Jagielski } while( eFlags & SwCrsrShell::SCROLLWIN );
1828*b1cdbd2cSJim Jagielski
1829*b1cdbd2cSJim Jagielski if( pBlockCrsr )
1830*b1cdbd2cSJim Jagielski RefreshBlockCursor();
1831*b1cdbd2cSJim Jagielski
1832*b1cdbd2cSJim Jagielski if( !bIdleEnd && bHasFocus && !bBasicHideCrsr )
1833*b1cdbd2cSJim Jagielski {
1834*b1cdbd2cSJim Jagielski if( pTblCrsr )
1835*b1cdbd2cSJim Jagielski pTblCrsr->SwSelPaintRects::Show();
1836*b1cdbd2cSJim Jagielski else
1837*b1cdbd2cSJim Jagielski {
1838*b1cdbd2cSJim Jagielski pCurCrsr->SwSelPaintRects::Show();
1839*b1cdbd2cSJim Jagielski if( pBlockCrsr )
1840*b1cdbd2cSJim Jagielski {
1841*b1cdbd2cSJim Jagielski SwShellCrsr* pNxt = dynamic_cast<SwShellCrsr*>(pCurCrsr->GetNext());
1842*b1cdbd2cSJim Jagielski while( pNxt && pNxt != pCurCrsr )
1843*b1cdbd2cSJim Jagielski {
1844*b1cdbd2cSJim Jagielski pNxt->SwSelPaintRects::Show();
1845*b1cdbd2cSJim Jagielski pNxt = dynamic_cast<SwShellCrsr*>(pNxt->GetNext());
1846*b1cdbd2cSJim Jagielski }
1847*b1cdbd2cSJim Jagielski }
1848*b1cdbd2cSJim Jagielski }
1849*b1cdbd2cSJim Jagielski }
1850*b1cdbd2cSJim Jagielski
1851*b1cdbd2cSJim Jagielski eMvState = MV_NONE; // Status fuers Crsr-Travelling - GetCrsrOfst
1852*b1cdbd2cSJim Jagielski
1853*b1cdbd2cSJim Jagielski if( pFrm && Imp()->IsAccessible() )
1854*b1cdbd2cSJim Jagielski Imp()->InvalidateAccessibleCursorPosition( pFrm );
1855*b1cdbd2cSJim Jagielski
1856*b1cdbd2cSJim Jagielski // switch from blinking cursor to read-only-text-selection cursor
1857*b1cdbd2cSJim Jagielski static const long nNoBlinkTime = STYLE_CURSOR_NOBLINKTIME;
1858*b1cdbd2cSJim Jagielski const long nBlinkTime = GetOut()->GetSettings().GetStyleSettings().
1859*b1cdbd2cSJim Jagielski GetCursorBlinkTime();
1860*b1cdbd2cSJim Jagielski
1861*b1cdbd2cSJim Jagielski if ( (IsCrsrReadonly() && GetViewOptions()->IsSelectionInReadonly()) ==
1862*b1cdbd2cSJim Jagielski ( nBlinkTime != nNoBlinkTime ) )
1863*b1cdbd2cSJim Jagielski {
1864*b1cdbd2cSJim Jagielski // non blinking cursor in read only - text selection mode
1865*b1cdbd2cSJim Jagielski AllSettings aSettings = GetOut()->GetSettings();
1866*b1cdbd2cSJim Jagielski StyleSettings aStyleSettings = aSettings.GetStyleSettings();
1867*b1cdbd2cSJim Jagielski const long nNewBlinkTime = nBlinkTime == nNoBlinkTime ?
1868*b1cdbd2cSJim Jagielski Application::GetSettings().GetStyleSettings().GetCursorBlinkTime() :
1869*b1cdbd2cSJim Jagielski nNoBlinkTime;
1870*b1cdbd2cSJim Jagielski aStyleSettings.SetCursorBlinkTime( nNewBlinkTime );
1871*b1cdbd2cSJim Jagielski aSettings.SetStyleSettings( aStyleSettings );
1872*b1cdbd2cSJim Jagielski GetOut()->SetSettings( aSettings );
1873*b1cdbd2cSJim Jagielski }
1874*b1cdbd2cSJim Jagielski
1875*b1cdbd2cSJim Jagielski if( bSVCrsrVis )
1876*b1cdbd2cSJim Jagielski pVisCrsr->Show(); // wieder anzeigen
1877*b1cdbd2cSJim Jagielski }
1878*b1cdbd2cSJim Jagielski
RefreshBlockCursor()1879*b1cdbd2cSJim Jagielski void SwCrsrShell::RefreshBlockCursor()
1880*b1cdbd2cSJim Jagielski {
1881*b1cdbd2cSJim Jagielski ASSERT( pBlockCrsr, "Don't call me without a block cursor" );
1882*b1cdbd2cSJim Jagielski SwShellCrsr &rBlock = pBlockCrsr->getShellCrsr();
1883*b1cdbd2cSJim Jagielski Point aPt = rBlock.GetPtPos();
1884*b1cdbd2cSJim Jagielski SwCntntFrm* pFrm = rBlock.GetCntntNode()->getLayoutFrm( GetLayout(), &aPt, rBlock.GetPoint(), sal_False );
1885*b1cdbd2cSJim Jagielski Point aMk;
1886*b1cdbd2cSJim Jagielski if( pBlockCrsr->getEndPoint() && pBlockCrsr->getStartPoint() )
1887*b1cdbd2cSJim Jagielski {
1888*b1cdbd2cSJim Jagielski aPt = *pBlockCrsr->getStartPoint();
1889*b1cdbd2cSJim Jagielski aMk = *pBlockCrsr->getEndPoint();
1890*b1cdbd2cSJim Jagielski }
1891*b1cdbd2cSJim Jagielski else
1892*b1cdbd2cSJim Jagielski {
1893*b1cdbd2cSJim Jagielski aPt = rBlock.GetPtPos();
1894*b1cdbd2cSJim Jagielski if( pFrm )
1895*b1cdbd2cSJim Jagielski {
1896*b1cdbd2cSJim Jagielski if( pFrm->IsVertical() )
1897*b1cdbd2cSJim Jagielski aPt.Y() = pFrm->Frm().Top() + GetUpDownX();
1898*b1cdbd2cSJim Jagielski else
1899*b1cdbd2cSJim Jagielski aPt.X() = pFrm->Frm().Left() + GetUpDownX();
1900*b1cdbd2cSJim Jagielski }
1901*b1cdbd2cSJim Jagielski aMk = rBlock.GetMkPos();
1902*b1cdbd2cSJim Jagielski }
1903*b1cdbd2cSJim Jagielski SwRect aRect( aMk, aPt );
1904*b1cdbd2cSJim Jagielski aRect.Justify();
1905*b1cdbd2cSJim Jagielski SwSelectionList aSelList( pFrm );
1906*b1cdbd2cSJim Jagielski
1907*b1cdbd2cSJim Jagielski if( GetLayout()->FillSelection( aSelList, aRect ) )
1908*b1cdbd2cSJim Jagielski {
1909*b1cdbd2cSJim Jagielski SwCursor* pNxt = (SwCursor*)pCurCrsr->GetNext();
1910*b1cdbd2cSJim Jagielski while( pNxt != pCurCrsr )
1911*b1cdbd2cSJim Jagielski {
1912*b1cdbd2cSJim Jagielski delete pNxt;
1913*b1cdbd2cSJim Jagielski pNxt = (SwCursor*)pCurCrsr->GetNext();
1914*b1cdbd2cSJim Jagielski }
1915*b1cdbd2cSJim Jagielski
1916*b1cdbd2cSJim Jagielski std::list<SwPaM*>::iterator pStart = aSelList.getStart();
1917*b1cdbd2cSJim Jagielski std::list<SwPaM*>::iterator pPam = aSelList.getEnd();
1918*b1cdbd2cSJim Jagielski ASSERT( pPam != pStart, "FillSelection should deliver at least one PaM" )
1919*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
1920*b1cdbd2cSJim Jagielski --pPam;
1921*b1cdbd2cSJim Jagielski // If there is only one text portion inside the rectangle, a simple
1922*b1cdbd2cSJim Jagielski // selection is created
1923*b1cdbd2cSJim Jagielski if( pPam == pStart )
1924*b1cdbd2cSJim Jagielski {
1925*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *(*pPam)->GetPoint();
1926*b1cdbd2cSJim Jagielski if( (*pPam)->HasMark() )
1927*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *(*pPam)->GetMark();
1928*b1cdbd2cSJim Jagielski else
1929*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1930*b1cdbd2cSJim Jagielski delete *pPam;
1931*b1cdbd2cSJim Jagielski pCurCrsr->SetColumnSelection( false );
1932*b1cdbd2cSJim Jagielski }
1933*b1cdbd2cSJim Jagielski else
1934*b1cdbd2cSJim Jagielski {
1935*b1cdbd2cSJim Jagielski // The order of the SwSelectionList has to be preserved but
1936*b1cdbd2cSJim Jagielski // the order inside the ring created by CreateCrsr() is not like
1937*b1cdbd2cSJim Jagielski // exspected => First create the selections before the last one
1938*b1cdbd2cSJim Jagielski // downto the first selection.
1939*b1cdbd2cSJim Jagielski // At least create the cursor for the last selection
1940*b1cdbd2cSJim Jagielski --pPam;
1941*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *(*pPam)->GetPoint(); // n-1 (if n == number of selections)
1942*b1cdbd2cSJim Jagielski if( (*pPam)->HasMark() )
1943*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *(*pPam)->GetMark();
1944*b1cdbd2cSJim Jagielski else
1945*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1946*b1cdbd2cSJim Jagielski delete *pPam;
1947*b1cdbd2cSJim Jagielski pCurCrsr->SetColumnSelection( true );
1948*b1cdbd2cSJim Jagielski while( pPam != pStart )
1949*b1cdbd2cSJim Jagielski {
1950*b1cdbd2cSJim Jagielski --pPam;
1951*b1cdbd2cSJim Jagielski
1952*b1cdbd2cSJim Jagielski SwShellCrsr* pNew = new SwShellCrsr( *pCurCrsr );
1953*b1cdbd2cSJim Jagielski pNew->Insert( pCurCrsr, 0 );
1954*b1cdbd2cSJim Jagielski pCurCrsr->Remove( 0, pCurCrsr->Count() );
1955*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1956*b1cdbd2cSJim Jagielski
1957*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *(*pPam)->GetPoint(); // n-2, n-3, .., 2, 1
1958*b1cdbd2cSJim Jagielski if( (*pPam)->HasMark() )
1959*b1cdbd2cSJim Jagielski {
1960*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
1961*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *(*pPam)->GetMark();
1962*b1cdbd2cSJim Jagielski }
1963*b1cdbd2cSJim Jagielski else
1964*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1965*b1cdbd2cSJim Jagielski pCurCrsr->SetColumnSelection( true );
1966*b1cdbd2cSJim Jagielski delete *pPam;
1967*b1cdbd2cSJim Jagielski }
1968*b1cdbd2cSJim Jagielski {
1969*b1cdbd2cSJim Jagielski SwShellCrsr* pNew = new SwShellCrsr( *pCurCrsr );
1970*b1cdbd2cSJim Jagielski pNew->Insert( pCurCrsr, 0 );
1971*b1cdbd2cSJim Jagielski pCurCrsr->Remove( 0, pCurCrsr->Count() );
1972*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1973*b1cdbd2cSJim Jagielski }
1974*b1cdbd2cSJim Jagielski pPam = aSelList.getEnd();
1975*b1cdbd2cSJim Jagielski --pPam;
1976*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *(*pPam)->GetPoint(); // n, the last selection
1977*b1cdbd2cSJim Jagielski if( (*pPam)->HasMark() )
1978*b1cdbd2cSJim Jagielski {
1979*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
1980*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *(*pPam)->GetMark();
1981*b1cdbd2cSJim Jagielski }
1982*b1cdbd2cSJim Jagielski else
1983*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
1984*b1cdbd2cSJim Jagielski pCurCrsr->SetColumnSelection( true );
1985*b1cdbd2cSJim Jagielski delete *pPam;
1986*b1cdbd2cSJim Jagielski }
1987*b1cdbd2cSJim Jagielski }
1988*b1cdbd2cSJim Jagielski }
1989*b1cdbd2cSJim Jagielski
1990*b1cdbd2cSJim Jagielski // erzeuge eine Kopie vom Cursor und speicher diese im Stack
1991*b1cdbd2cSJim Jagielski
1992*b1cdbd2cSJim Jagielski
Push()1993*b1cdbd2cSJim Jagielski void SwCrsrShell::Push()
1994*b1cdbd2cSJim Jagielski {
1995*b1cdbd2cSJim Jagielski pCrsrStk = new SwShellCrsr( *this, *pCurCrsr->GetPoint(),
1996*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos(), pCrsrStk );
1997*b1cdbd2cSJim Jagielski
1998*b1cdbd2cSJim Jagielski if( pCurCrsr->HasMark() )
1999*b1cdbd2cSJim Jagielski {
2000*b1cdbd2cSJim Jagielski pCrsrStk->SetMark();
2001*b1cdbd2cSJim Jagielski *pCrsrStk->GetMark() = *pCurCrsr->GetMark();
2002*b1cdbd2cSJim Jagielski }
2003*b1cdbd2cSJim Jagielski }
2004*b1cdbd2cSJim Jagielski
2005*b1cdbd2cSJim Jagielski /*
2006*b1cdbd2cSJim Jagielski * Loescht einen Cursor (gesteuert durch bOldCrsr)
2007*b1cdbd2cSJim Jagielski * - vom Stack oder ( bOldCrsr = sal_True )
2008*b1cdbd2cSJim Jagielski * - den aktuellen und der auf dem Stack stehende wird zum aktuellen
2009*b1cdbd2cSJim Jagielski *
2010*b1cdbd2cSJim Jagielski * Return: es war auf dem Stack noch einer vorhanden
2011*b1cdbd2cSJim Jagielski */
2012*b1cdbd2cSJim Jagielski
2013*b1cdbd2cSJim Jagielski
Pop(sal_Bool bOldCrsr)2014*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::Pop( sal_Bool bOldCrsr )
2015*b1cdbd2cSJim Jagielski {
2016*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
2017*b1cdbd2cSJim Jagielski
2018*b1cdbd2cSJim Jagielski // noch weitere vorhanden ?
2019*b1cdbd2cSJim Jagielski if( 0 == pCrsrStk )
2020*b1cdbd2cSJim Jagielski return sal_False;
2021*b1cdbd2cSJim Jagielski
2022*b1cdbd2cSJim Jagielski SwShellCrsr *pTmp = 0, *pOldStk = pCrsrStk;
2023*b1cdbd2cSJim Jagielski
2024*b1cdbd2cSJim Jagielski // der Nachfolger wird der Aktuelle
2025*b1cdbd2cSJim Jagielski if( pCrsrStk->GetNext() != pCrsrStk )
2026*b1cdbd2cSJim Jagielski {
2027*b1cdbd2cSJim Jagielski pTmp = dynamic_cast<SwShellCrsr*>(pCrsrStk->GetNext());
2028*b1cdbd2cSJim Jagielski }
2029*b1cdbd2cSJim Jagielski
2030*b1cdbd2cSJim Jagielski if( bOldCrsr ) // loesche vom Stack
2031*b1cdbd2cSJim Jagielski delete pCrsrStk; //
2032*b1cdbd2cSJim Jagielski
2033*b1cdbd2cSJim Jagielski pCrsrStk = pTmp; // neu zuweisen
2034*b1cdbd2cSJim Jagielski
2035*b1cdbd2cSJim Jagielski if( !bOldCrsr )
2036*b1cdbd2cSJim Jagielski {
2037*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCurCrsr );
2038*b1cdbd2cSJim Jagielski
2039*b1cdbd2cSJim Jagielski // wurde die sichtbare SSelection nicht veraendert
2040*b1cdbd2cSJim Jagielski if( pOldStk->GetPtPos() == pCurCrsr->GetPtPos() ||
2041*b1cdbd2cSJim Jagielski pOldStk->GetPtPos() == pCurCrsr->GetMkPos() )
2042*b1cdbd2cSJim Jagielski {
2043*b1cdbd2cSJim Jagielski // "Selektions-Rechtecke" verschieben
2044*b1cdbd2cSJim Jagielski pCurCrsr->Insert( pOldStk, 0 );
2045*b1cdbd2cSJim Jagielski pOldStk->Remove( 0, pOldStk->Count() );
2046*b1cdbd2cSJim Jagielski }
2047*b1cdbd2cSJim Jagielski
2048*b1cdbd2cSJim Jagielski if( pOldStk->HasMark() )
2049*b1cdbd2cSJim Jagielski {
2050*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
2051*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *pOldStk->GetMark();
2052*b1cdbd2cSJim Jagielski pCurCrsr->GetMkPos() = pOldStk->GetMkPos();
2053*b1cdbd2cSJim Jagielski }
2054*b1cdbd2cSJim Jagielski else
2055*b1cdbd2cSJim Jagielski // keine Selection also alte aufheben und auf die alte Pos setzen
2056*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
2057*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *pOldStk->GetPoint();
2058*b1cdbd2cSJim Jagielski pCurCrsr->GetPtPos() = pOldStk->GetPtPos();
2059*b1cdbd2cSJim Jagielski delete pOldStk;
2060*b1cdbd2cSJim Jagielski
2061*b1cdbd2cSJim Jagielski if( !pCurCrsr->IsInProtectTable( sal_True ) &&
2062*b1cdbd2cSJim Jagielski !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
2063*b1cdbd2cSJim Jagielski nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ) )
2064*b1cdbd2cSJim Jagielski UpdateCrsr(); // akt. Cursor Updaten
2065*b1cdbd2cSJim Jagielski }
2066*b1cdbd2cSJim Jagielski return sal_True;
2067*b1cdbd2cSJim Jagielski }
2068*b1cdbd2cSJim Jagielski
2069*b1cdbd2cSJim Jagielski /*
2070*b1cdbd2cSJim Jagielski * Verbinde zwei Cursor miteinander.
2071*b1cdbd2cSJim Jagielski * Loesche vom Stack den obersten und setzen dessen GetMark im Aktuellen.
2072*b1cdbd2cSJim Jagielski */
2073*b1cdbd2cSJim Jagielski
2074*b1cdbd2cSJim Jagielski
Combine()2075*b1cdbd2cSJim Jagielski void SwCrsrShell::Combine()
2076*b1cdbd2cSJim Jagielski {
2077*b1cdbd2cSJim Jagielski // noch weitere vorhanden ?
2078*b1cdbd2cSJim Jagielski if( 0 == pCrsrStk )
2079*b1cdbd2cSJim Jagielski return;
2080*b1cdbd2cSJim Jagielski
2081*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
2082*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCurCrsr );
2083*b1cdbd2cSJim Jagielski if( pCrsrStk->HasMark() ) // nur wenn GetMark gesetzt wurde
2084*b1cdbd2cSJim Jagielski {
2085*b1cdbd2cSJim Jagielski #ifndef DBG_UTIL
2086*b1cdbd2cSJim Jagielski CheckNodesRange( pCrsrStk->GetMark()->nNode, pCurCrsr->GetPoint()->nNode, sal_True );
2087*b1cdbd2cSJim Jagielski #else
2088*b1cdbd2cSJim Jagielski if( !CheckNodesRange( pCrsrStk->GetMark()->nNode, pCurCrsr->GetPoint()->nNode, sal_True ))
2089*b1cdbd2cSJim Jagielski ASSERT( !this, "StackCrsr & akt. Crsr nicht in gleicher Section." );
2090*b1cdbd2cSJim Jagielski #endif
2091*b1cdbd2cSJim Jagielski // kopiere das GetMark
2092*b1cdbd2cSJim Jagielski if( !pCurCrsr->HasMark() )
2093*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
2094*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *pCrsrStk->GetMark();
2095*b1cdbd2cSJim Jagielski pCurCrsr->GetMkPos() = pCrsrStk->GetMkPos();
2096*b1cdbd2cSJim Jagielski }
2097*b1cdbd2cSJim Jagielski
2098*b1cdbd2cSJim Jagielski SwShellCrsr * pTmp = 0;
2099*b1cdbd2cSJim Jagielski if( pCrsrStk->GetNext() != pCrsrStk )
2100*b1cdbd2cSJim Jagielski {
2101*b1cdbd2cSJim Jagielski pTmp = dynamic_cast<SwShellCrsr*>(pCrsrStk->GetNext());
2102*b1cdbd2cSJim Jagielski }
2103*b1cdbd2cSJim Jagielski delete pCrsrStk;
2104*b1cdbd2cSJim Jagielski pCrsrStk = pTmp;
2105*b1cdbd2cSJim Jagielski if( !pCurCrsr->IsInProtectTable( sal_True ) &&
2106*b1cdbd2cSJim Jagielski !pCurCrsr->IsSelOvr( nsSwCursorSelOverFlags::SELOVER_TOGGLE |
2107*b1cdbd2cSJim Jagielski nsSwCursorSelOverFlags::SELOVER_CHANGEPOS ) )
2108*b1cdbd2cSJim Jagielski UpdateCrsr(); // akt. Cursor Updaten
2109*b1cdbd2cSJim Jagielski }
2110*b1cdbd2cSJim Jagielski
2111*b1cdbd2cSJim Jagielski
HideCrsrs()2112*b1cdbd2cSJim Jagielski void SwCrsrShell::HideCrsrs()
2113*b1cdbd2cSJim Jagielski {
2114*b1cdbd2cSJim Jagielski if( !bHasFocus || bBasicHideCrsr )
2115*b1cdbd2cSJim Jagielski return;
2116*b1cdbd2cSJim Jagielski
2117*b1cdbd2cSJim Jagielski // ist Cursor sichtbar, dann verstecke den SV-Cursor
2118*b1cdbd2cSJim Jagielski if( pVisCrsr->IsVisible() )
2119*b1cdbd2cSJim Jagielski {
2120*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2121*b1cdbd2cSJim Jagielski pVisCrsr->Hide();
2122*b1cdbd2cSJim Jagielski }
2123*b1cdbd2cSJim Jagielski // hebe die Invertierung der SSelection auf
2124*b1cdbd2cSJim Jagielski SwShellCrsr* pAktCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
2125*b1cdbd2cSJim Jagielski pAktCrsr->Hide();
2126*b1cdbd2cSJim Jagielski }
2127*b1cdbd2cSJim Jagielski
2128*b1cdbd2cSJim Jagielski
2129*b1cdbd2cSJim Jagielski
ShowCrsrs(sal_Bool bCrsrVis)2130*b1cdbd2cSJim Jagielski void SwCrsrShell::ShowCrsrs( sal_Bool bCrsrVis )
2131*b1cdbd2cSJim Jagielski {
2132*b1cdbd2cSJim Jagielski if( !bHasFocus || bAllProtect || bBasicHideCrsr )
2133*b1cdbd2cSJim Jagielski return;
2134*b1cdbd2cSJim Jagielski
2135*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2136*b1cdbd2cSJim Jagielski SwShellCrsr* pAktCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
2137*b1cdbd2cSJim Jagielski pAktCrsr->Show();
2138*b1cdbd2cSJim Jagielski
2139*b1cdbd2cSJim Jagielski if( bSVCrsrVis && bCrsrVis ) // auch SV-Cursor wieder anzeigen
2140*b1cdbd2cSJim Jagielski pVisCrsr->Show();
2141*b1cdbd2cSJim Jagielski }
2142*b1cdbd2cSJim Jagielski
2143*b1cdbd2cSJim Jagielski // Methoden zum Anzeigen bzw. Verstecken des sichtbaren Text-Cursors
2144*b1cdbd2cSJim Jagielski
2145*b1cdbd2cSJim Jagielski
ShowCrsr()2146*b1cdbd2cSJim Jagielski void SwCrsrShell::ShowCrsr()
2147*b1cdbd2cSJim Jagielski {
2148*b1cdbd2cSJim Jagielski if( !bBasicHideCrsr )
2149*b1cdbd2cSJim Jagielski {
2150*b1cdbd2cSJim Jagielski bSVCrsrVis = sal_True;
2151*b1cdbd2cSJim Jagielski pCurCrsr->SetShowTxtInputFldOverlay( true );
2152*b1cdbd2cSJim Jagielski UpdateCrsr();
2153*b1cdbd2cSJim Jagielski }
2154*b1cdbd2cSJim Jagielski }
2155*b1cdbd2cSJim Jagielski
2156*b1cdbd2cSJim Jagielski
HideCrsr()2157*b1cdbd2cSJim Jagielski void SwCrsrShell::HideCrsr()
2158*b1cdbd2cSJim Jagielski {
2159*b1cdbd2cSJim Jagielski if( !bBasicHideCrsr )
2160*b1cdbd2cSJim Jagielski {
2161*b1cdbd2cSJim Jagielski bSVCrsrVis = sal_False;
2162*b1cdbd2cSJim Jagielski // evt. die sel. Bereiche aufheben !!
2163*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2164*b1cdbd2cSJim Jagielski pCurCrsr->SetShowTxtInputFldOverlay( false );
2165*b1cdbd2cSJim Jagielski pVisCrsr->Hide();
2166*b1cdbd2cSJim Jagielski }
2167*b1cdbd2cSJim Jagielski }
2168*b1cdbd2cSJim Jagielski
2169*b1cdbd2cSJim Jagielski
ShLooseFcs()2170*b1cdbd2cSJim Jagielski void SwCrsrShell::ShLooseFcs()
2171*b1cdbd2cSJim Jagielski {
2172*b1cdbd2cSJim Jagielski if( !bBasicHideCrsr )
2173*b1cdbd2cSJim Jagielski HideCrsrs();
2174*b1cdbd2cSJim Jagielski bHasFocus = sal_False;
2175*b1cdbd2cSJim Jagielski }
2176*b1cdbd2cSJim Jagielski
2177*b1cdbd2cSJim Jagielski
ShGetFcs(sal_Bool bUpdate)2178*b1cdbd2cSJim Jagielski void SwCrsrShell::ShGetFcs( sal_Bool bUpdate )
2179*b1cdbd2cSJim Jagielski {
2180*b1cdbd2cSJim Jagielski bHasFocus = sal_True;
2181*b1cdbd2cSJim Jagielski if( !bBasicHideCrsr && VisArea().Width() )
2182*b1cdbd2cSJim Jagielski {
2183*b1cdbd2cSJim Jagielski UpdateCrsr( static_cast<sal_uInt16>( bUpdate ?
2184*b1cdbd2cSJim Jagielski SwCrsrShell::CHKRANGE|SwCrsrShell::SCROLLWIN
2185*b1cdbd2cSJim Jagielski : SwCrsrShell::CHKRANGE ) );
2186*b1cdbd2cSJim Jagielski ShowCrsrs( bSVCrsrVis ? sal_True : sal_False );
2187*b1cdbd2cSJim Jagielski }
2188*b1cdbd2cSJim Jagielski }
2189*b1cdbd2cSJim Jagielski
2190*b1cdbd2cSJim Jagielski // gebe den aktuellen Frame, in dem der Cursor steht, zurueck
2191*b1cdbd2cSJim Jagielski
GetCurrFrm(const sal_Bool bCalcFrm) const2192*b1cdbd2cSJim Jagielski SwCntntFrm *SwCrsrShell::GetCurrFrm( const sal_Bool bCalcFrm ) const
2193*b1cdbd2cSJim Jagielski {
2194*b1cdbd2cSJim Jagielski SET_CURR_SHELL( (ViewShell*)this );
2195*b1cdbd2cSJim Jagielski SwCntntFrm *pRet = 0;
2196*b1cdbd2cSJim Jagielski SwCntntNode *pNd = pCurCrsr->GetCntntNode();
2197*b1cdbd2cSJim Jagielski if ( pNd )
2198*b1cdbd2cSJim Jagielski {
2199*b1cdbd2cSJim Jagielski if ( bCalcFrm )
2200*b1cdbd2cSJim Jagielski {
2201*b1cdbd2cSJim Jagielski const sal_uInt16* pST = &nStartAction;
2202*b1cdbd2cSJim Jagielski ++(*((sal_uInt16*)pST));
2203*b1cdbd2cSJim Jagielski const Size aOldSz( GetDocSize() );
2204*b1cdbd2cSJim Jagielski pRet = pNd->getLayoutFrm( GetLayout(), &pCurCrsr->GetPtPos(), pCurCrsr->GetPoint() );
2205*b1cdbd2cSJim Jagielski --(*((sal_uInt16*)pST));
2206*b1cdbd2cSJim Jagielski if( aOldSz != GetDocSize() )
2207*b1cdbd2cSJim Jagielski ((SwCrsrShell*)this)->SizeChgNotify();
2208*b1cdbd2cSJim Jagielski }
2209*b1cdbd2cSJim Jagielski else
2210*b1cdbd2cSJim Jagielski pRet = pNd->getLayoutFrm( GetLayout(), &pCurCrsr->GetPtPos(), pCurCrsr->GetPoint(), sal_False);
2211*b1cdbd2cSJim Jagielski }
2212*b1cdbd2cSJim Jagielski return pRet;
2213*b1cdbd2cSJim Jagielski }
2214*b1cdbd2cSJim Jagielski
2215*b1cdbd2cSJim Jagielski
2216*b1cdbd2cSJim Jagielski // alle Attribut/Format-Aenderungen am akt. Node werden an den
2217*b1cdbd2cSJim Jagielski // Link weitergeleitet.
2218*b1cdbd2cSJim Jagielski
2219*b1cdbd2cSJim Jagielski
Modify(const SfxPoolItem * pOld,const SfxPoolItem * pNew)2220*b1cdbd2cSJim Jagielski void SwCrsrShell::Modify( const SfxPoolItem* pOld, const SfxPoolItem* pNew )
2221*b1cdbd2cSJim Jagielski {
2222*b1cdbd2cSJim Jagielski const sal_uInt16 nWhich = pOld ?
2223*b1cdbd2cSJim Jagielski pOld->Which() :
2224*b1cdbd2cSJim Jagielski pNew ?
2225*b1cdbd2cSJim Jagielski pNew->Which() :
2226*b1cdbd2cSJim Jagielski sal::static_int_cast<sal_uInt16>(RES_MSG_BEGIN);
2227*b1cdbd2cSJim Jagielski
2228*b1cdbd2cSJim Jagielski if( bCallChgLnk &&
2229*b1cdbd2cSJim Jagielski ( nWhich < RES_MSG_BEGIN || nWhich >= RES_MSG_END ||
2230*b1cdbd2cSJim Jagielski nWhich == RES_FMT_CHG || nWhich == RES_UPDATE_ATTR ||
2231*b1cdbd2cSJim Jagielski nWhich == RES_ATTRSET_CHG ))
2232*b1cdbd2cSJim Jagielski // die Messages werden nicht weitergemeldet
2233*b1cdbd2cSJim Jagielski //MA 07. Apr. 94 fix(6681): RES_UPDATE_ATTR wird implizit vom
2234*b1cdbd2cSJim Jagielski //SwTxtNode::Insert(SwTxtHint*, sal_uInt16) abgesetzt; hier wird reagiert und
2235*b1cdbd2cSJim Jagielski //vom Insert brauch nicht mehr die Keule RES_FMT_CHG versandt werden.
2236*b1cdbd2cSJim Jagielski CallChgLnk();
2237*b1cdbd2cSJim Jagielski
2238*b1cdbd2cSJim Jagielski if( aGrfArrivedLnk.IsSet() &&
2239*b1cdbd2cSJim Jagielski ( RES_GRAPHIC_ARRIVED == nWhich || RES_GRAPHIC_SWAPIN == nWhich ))
2240*b1cdbd2cSJim Jagielski aGrfArrivedLnk.Call( this );
2241*b1cdbd2cSJim Jagielski }
2242*b1cdbd2cSJim Jagielski
2243*b1cdbd2cSJim Jagielski
2244*b1cdbd2cSJim Jagielski // Abfrage, ob der aktuelle Cursor eine Selektion aufspannt,
2245*b1cdbd2cSJim Jagielski // also, ob GetMark gesetzt und SPoint und GetMark unterschiedlich sind.
2246*b1cdbd2cSJim Jagielski
2247*b1cdbd2cSJim Jagielski
HasSelection() const2248*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::HasSelection() const
2249*b1cdbd2cSJim Jagielski {
2250*b1cdbd2cSJim Jagielski const SwPaM* pCrsr = getShellCrsr( true );
2251*b1cdbd2cSJim Jagielski return( IsTableMode() || ( pCrsr->HasMark() &&
2252*b1cdbd2cSJim Jagielski *pCrsr->GetPoint() != *pCrsr->GetMark())
2253*b1cdbd2cSJim Jagielski ? sal_True : sal_False );
2254*b1cdbd2cSJim Jagielski }
2255*b1cdbd2cSJim Jagielski
2256*b1cdbd2cSJim Jagielski
CallChgLnk()2257*b1cdbd2cSJim Jagielski void SwCrsrShell::CallChgLnk()
2258*b1cdbd2cSJim Jagielski {
2259*b1cdbd2cSJim Jagielski // innerhalb von Start-/End-Action kein Call, sondern nur merken,
2260*b1cdbd2cSJim Jagielski // das sich etwas geaendert hat. Wird bei EndAction beachtet.
2261*b1cdbd2cSJim Jagielski if( BasicActionPend() )
2262*b1cdbd2cSJim Jagielski bChgCallFlag = sal_True; // das Change merken
2263*b1cdbd2cSJim Jagielski else if( aChgLnk.IsSet() )
2264*b1cdbd2cSJim Jagielski {
2265*b1cdbd2cSJim Jagielski if( bCallChgLnk )
2266*b1cdbd2cSJim Jagielski aChgLnk.Call( this );
2267*b1cdbd2cSJim Jagielski bChgCallFlag = sal_False; // Flag zuruecksetzen
2268*b1cdbd2cSJim Jagielski }
2269*b1cdbd2cSJim Jagielski }
2270*b1cdbd2cSJim Jagielski
2271*b1cdbd2cSJim Jagielski // returne den am akt.Cursor selektierten Text eines Nodes.
2272*b1cdbd2cSJim Jagielski
2273*b1cdbd2cSJim Jagielski
GetSelTxt() const2274*b1cdbd2cSJim Jagielski String SwCrsrShell::GetSelTxt() const
2275*b1cdbd2cSJim Jagielski {
2276*b1cdbd2cSJim Jagielski String aTxt;
2277*b1cdbd2cSJim Jagielski if( pCurCrsr->GetPoint()->nNode.GetIndex() ==
2278*b1cdbd2cSJim Jagielski pCurCrsr->GetMark()->nNode.GetIndex() )
2279*b1cdbd2cSJim Jagielski {
2280*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = pCurCrsr->GetNode()->GetTxtNode();
2281*b1cdbd2cSJim Jagielski if( pTxtNd )
2282*b1cdbd2cSJim Jagielski {
2283*b1cdbd2cSJim Jagielski xub_StrLen nStt = pCurCrsr->Start()->nContent.GetIndex();
2284*b1cdbd2cSJim Jagielski aTxt = pTxtNd->GetExpandTxt( nStt,
2285*b1cdbd2cSJim Jagielski pCurCrsr->End()->nContent.GetIndex() - nStt );
2286*b1cdbd2cSJim Jagielski }
2287*b1cdbd2cSJim Jagielski }
2288*b1cdbd2cSJim Jagielski return aTxt;
2289*b1cdbd2cSJim Jagielski }
2290*b1cdbd2cSJim Jagielski
2291*b1cdbd2cSJim Jagielski // gebe nur den Text ab der akt. Cursor Position zurueck (bis zum NodeEnde)
2292*b1cdbd2cSJim Jagielski
2293*b1cdbd2cSJim Jagielski
GetText() const2294*b1cdbd2cSJim Jagielski String SwCrsrShell::GetText() const
2295*b1cdbd2cSJim Jagielski {
2296*b1cdbd2cSJim Jagielski String aTxt;
2297*b1cdbd2cSJim Jagielski if( pCurCrsr->GetPoint()->nNode.GetIndex() ==
2298*b1cdbd2cSJim Jagielski pCurCrsr->GetMark()->nNode.GetIndex() )
2299*b1cdbd2cSJim Jagielski {
2300*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = pCurCrsr->GetNode()->GetTxtNode();
2301*b1cdbd2cSJim Jagielski if( pTxtNd )
2302*b1cdbd2cSJim Jagielski aTxt = pTxtNd->GetTxt().Copy(
2303*b1cdbd2cSJim Jagielski pCurCrsr->GetPoint()->nContent.GetIndex() );
2304*b1cdbd2cSJim Jagielski }
2305*b1cdbd2cSJim Jagielski return aTxt;
2306*b1cdbd2cSJim Jagielski }
2307*b1cdbd2cSJim Jagielski
2308*b1cdbd2cSJim Jagielski // hole vom Start/Ende der akt. SSelection das nte Zeichen
GetChar(sal_Bool bEnd,long nOffset)2309*b1cdbd2cSJim Jagielski sal_Unicode SwCrsrShell::GetChar( sal_Bool bEnd, long nOffset )
2310*b1cdbd2cSJim Jagielski {
2311*b1cdbd2cSJim Jagielski if( IsTableMode() ) // im TabelleMode nicht moeglich
2312*b1cdbd2cSJim Jagielski return 0;
2313*b1cdbd2cSJim Jagielski
2314*b1cdbd2cSJim Jagielski const SwPosition* pPos = !pCurCrsr->HasMark() ? pCurCrsr->GetPoint()
2315*b1cdbd2cSJim Jagielski : bEnd ? pCurCrsr->End() : pCurCrsr->Start();
2316*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
2317*b1cdbd2cSJim Jagielski if( !pTxtNd )
2318*b1cdbd2cSJim Jagielski return 0;
2319*b1cdbd2cSJim Jagielski
2320*b1cdbd2cSJim Jagielski xub_StrLen nPos = pPos->nContent.GetIndex();
2321*b1cdbd2cSJim Jagielski const String& rStr = pTxtNd->GetTxt();
2322*b1cdbd2cSJim Jagielski sal_Unicode cCh = 0;
2323*b1cdbd2cSJim Jagielski
2324*b1cdbd2cSJim Jagielski if( ((nPos+nOffset) >= 0 ) && (nPos+nOffset) < rStr.Len() )
2325*b1cdbd2cSJim Jagielski cCh = rStr.GetChar( static_cast<xub_StrLen>(nPos+nOffset) );
2326*b1cdbd2cSJim Jagielski
2327*b1cdbd2cSJim Jagielski return cCh;
2328*b1cdbd2cSJim Jagielski }
2329*b1cdbd2cSJim Jagielski
2330*b1cdbd2cSJim Jagielski // erweiter die akt. SSelection am Anfang/Ende um n Zeichen
2331*b1cdbd2cSJim Jagielski
2332*b1cdbd2cSJim Jagielski
ExtendSelection(sal_Bool bEnd,xub_StrLen nCount)2333*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::ExtendSelection( sal_Bool bEnd, xub_StrLen nCount )
2334*b1cdbd2cSJim Jagielski {
2335*b1cdbd2cSJim Jagielski if( !pCurCrsr->HasMark() || IsTableMode() )
2336*b1cdbd2cSJim Jagielski return sal_False; // keine Selektion
2337*b1cdbd2cSJim Jagielski
2338*b1cdbd2cSJim Jagielski SwPosition* pPos = bEnd ? pCurCrsr->End() : pCurCrsr->Start();
2339*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = pPos->nNode.GetNode().GetTxtNode();
2340*b1cdbd2cSJim Jagielski ASSERT( pTxtNd, "kein TextNode, wie soll erweitert werden?" );
2341*b1cdbd2cSJim Jagielski
2342*b1cdbd2cSJim Jagielski xub_StrLen nPos = pPos->nContent.GetIndex();
2343*b1cdbd2cSJim Jagielski if( bEnd )
2344*b1cdbd2cSJim Jagielski {
2345*b1cdbd2cSJim Jagielski if( ( nPos + nCount ) <= pTxtNd->GetTxt().Len() )
2346*b1cdbd2cSJim Jagielski nPos = nPos + nCount;
2347*b1cdbd2cSJim Jagielski else
2348*b1cdbd2cSJim Jagielski return sal_False; // nicht mehr moeglich
2349*b1cdbd2cSJim Jagielski }
2350*b1cdbd2cSJim Jagielski else if( nPos >= nCount )
2351*b1cdbd2cSJim Jagielski nPos = nPos - nCount;
2352*b1cdbd2cSJim Jagielski else
2353*b1cdbd2cSJim Jagielski return sal_False; // nicht mehr moeglich
2354*b1cdbd2cSJim Jagielski
2355*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen,
2356*b1cdbd2cSJim Jagielski
2357*b1cdbd2cSJim Jagielski pPos->nContent = nPos;
2358*b1cdbd2cSJim Jagielski UpdateCrsr();
2359*b1cdbd2cSJim Jagielski
2360*b1cdbd2cSJim Jagielski return sal_True;
2361*b1cdbd2cSJim Jagielski }
2362*b1cdbd2cSJim Jagielski
2363*b1cdbd2cSJim Jagielski // setze nur den sichtbaren Cursor an die angegebene Dokument-Pos.
2364*b1cdbd2cSJim Jagielski // returnt sal_False: wenn der SPoint vom Layout korrigiert wurde.
2365*b1cdbd2cSJim Jagielski
SetVisCrsr(const Point & rPt)2366*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::SetVisCrsr( const Point &rPt )
2367*b1cdbd2cSJim Jagielski {
2368*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2369*b1cdbd2cSJim Jagielski Point aPt( rPt );
2370*b1cdbd2cSJim Jagielski SwPosition aPos( *pCurCrsr->GetPoint() );
2371*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_SETONLYTEXT );
2372*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
2373*b1cdbd2cSJim Jagielski aTmpState.bRealHeight = sal_True;
2374*b1cdbd2cSJim Jagielski
2375*b1cdbd2cSJim Jagielski sal_Bool bRet = GetLayout()->GetCrsrOfst( &aPos, aPt /*, &aTmpState*/ );
2376*b1cdbd2cSJim Jagielski
2377*b1cdbd2cSJim Jagielski SetInFrontOfLabel( sal_False ); // #i27615#
2378*b1cdbd2cSJim Jagielski
2379*b1cdbd2cSJim Jagielski // nur in TextNodes anzeigen !!
2380*b1cdbd2cSJim Jagielski SwTxtNode* pTxtNd = aPos.nNode.GetNode().GetTxtNode();
2381*b1cdbd2cSJim Jagielski if( !pTxtNd )
2382*b1cdbd2cSJim Jagielski return sal_False;
2383*b1cdbd2cSJim Jagielski
2384*b1cdbd2cSJim Jagielski const SwSectionNode* pSectNd = pTxtNd->FindSectionNode();
2385*b1cdbd2cSJim Jagielski if( pSectNd && (pSectNd->GetSection().IsHiddenFlag() ||
2386*b1cdbd2cSJim Jagielski ( !IsReadOnlyAvailable() &&
2387*b1cdbd2cSJim Jagielski pSectNd->GetSection().IsProtectFlag())) )
2388*b1cdbd2cSJim Jagielski return sal_False;
2389*b1cdbd2cSJim Jagielski
2390*b1cdbd2cSJim Jagielski SwCntntFrm *pFrm = pTxtNd->getLayoutFrm( GetLayout(), &aPt, &aPos );
2391*b1cdbd2cSJim Jagielski if ( Imp()->IsIdleAction() )
2392*b1cdbd2cSJim Jagielski pFrm->PrepareCrsr();
2393*b1cdbd2cSJim Jagielski SwRect aTmp( aCharRect );
2394*b1cdbd2cSJim Jagielski
2395*b1cdbd2cSJim Jagielski pFrm->GetCharRect( aCharRect, aPos, &aTmpState );
2396*b1cdbd2cSJim Jagielski // ALIGNRECT( aCharRect );
2397*b1cdbd2cSJim Jagielski
2398*b1cdbd2cSJim Jagielski if( aTmp == aCharRect && // BUG 10137: bleibt der Cursor auf der
2399*b1cdbd2cSJim Jagielski pVisCrsr->IsVisible() ) // Position nicht hidden & showen
2400*b1cdbd2cSJim Jagielski return sal_True;
2401*b1cdbd2cSJim Jagielski
2402*b1cdbd2cSJim Jagielski pVisCrsr->Hide(); // sichtbaren Cursor immer verstecken
2403*b1cdbd2cSJim Jagielski if( IsScrollMDI( this, aCharRect ))
2404*b1cdbd2cSJim Jagielski {
2405*b1cdbd2cSJim Jagielski MakeVisible( aCharRect );
2406*b1cdbd2cSJim Jagielski pCurCrsr->Show();
2407*b1cdbd2cSJim Jagielski }
2408*b1cdbd2cSJim Jagielski
2409*b1cdbd2cSJim Jagielski // Bug 29584: bei Rahmenselektion ist der Cursor versteckt, aber den
2410*b1cdbd2cSJim Jagielski // D&D-Cursor will man trotzdem haben
2411*b1cdbd2cSJim Jagielski // if( bSVCrsrVis )
2412*b1cdbd2cSJim Jagielski {
2413*b1cdbd2cSJim Jagielski if( aTmpState.bRealHeight )
2414*b1cdbd2cSJim Jagielski aCrsrHeight = aTmpState.aRealHeight;
2415*b1cdbd2cSJim Jagielski else
2416*b1cdbd2cSJim Jagielski {
2417*b1cdbd2cSJim Jagielski aCrsrHeight.X() = 0;
2418*b1cdbd2cSJim Jagielski aCrsrHeight.Y() = aCharRect.Height();
2419*b1cdbd2cSJim Jagielski }
2420*b1cdbd2cSJim Jagielski
2421*b1cdbd2cSJim Jagielski pVisCrsr->SetDragCrsr( sal_True );
2422*b1cdbd2cSJim Jagielski pVisCrsr->Show(); // wieder anzeigen
2423*b1cdbd2cSJim Jagielski }
2424*b1cdbd2cSJim Jagielski return bRet;
2425*b1cdbd2cSJim Jagielski }
2426*b1cdbd2cSJim Jagielski
IsOverReadOnlyPos(const Point & rPt) const2427*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsOverReadOnlyPos( const Point& rPt ) const
2428*b1cdbd2cSJim Jagielski {
2429*b1cdbd2cSJim Jagielski Point aPt( rPt );
2430*b1cdbd2cSJim Jagielski SwPaM aPam( *pCurCrsr->GetPoint() );
2431*b1cdbd2cSJim Jagielski GetLayout()->GetCrsrOfst( aPam.GetPoint(), aPt );
2432*b1cdbd2cSJim Jagielski return aPam.HasReadonlySel( GetViewOptions()->IsFormView() );
2433*b1cdbd2cSJim Jagielski }
2434*b1cdbd2cSJim Jagielski
2435*b1cdbd2cSJim Jagielski
2436*b1cdbd2cSJim Jagielski // returne die Anzahl der Cursor im Ring (Flag besagt ob man nur
2437*b1cdbd2cSJim Jagielski // aufgepspannte haben will - sprich etwas selektiert ist (Basic))
GetCrsrCnt(sal_Bool bAll) const2438*b1cdbd2cSJim Jagielski sal_uInt16 SwCrsrShell::GetCrsrCnt( sal_Bool bAll ) const
2439*b1cdbd2cSJim Jagielski {
2440*b1cdbd2cSJim Jagielski Ring* pTmp = GetCrsr()->GetNext();
2441*b1cdbd2cSJim Jagielski sal_uInt16 n = (bAll || ( pCurCrsr->HasMark() &&
2442*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() != *pCurCrsr->GetMark())) ? 1 : 0;
2443*b1cdbd2cSJim Jagielski while( pTmp != pCurCrsr )
2444*b1cdbd2cSJim Jagielski {
2445*b1cdbd2cSJim Jagielski if( bAll || ( ((SwPaM*)pTmp)->HasMark() &&
2446*b1cdbd2cSJim Jagielski *((SwPaM*)pTmp)->GetPoint() != *((SwPaM*)pTmp)->GetMark()))
2447*b1cdbd2cSJim Jagielski ++n;
2448*b1cdbd2cSJim Jagielski pTmp = pTmp->GetNext();
2449*b1cdbd2cSJim Jagielski }
2450*b1cdbd2cSJim Jagielski return n;
2451*b1cdbd2cSJim Jagielski }
2452*b1cdbd2cSJim Jagielski
2453*b1cdbd2cSJim Jagielski
IsStartOfDoc() const2454*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsStartOfDoc() const
2455*b1cdbd2cSJim Jagielski {
2456*b1cdbd2cSJim Jagielski if( pCurCrsr->GetPoint()->nContent.GetIndex() )
2457*b1cdbd2cSJim Jagielski return sal_False;
2458*b1cdbd2cSJim Jagielski
2459*b1cdbd2cSJim Jagielski // Hinter EndOfIcons kommt die Content-Section (EndNd+StNd+CntntNd)
2460*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( GetDoc()->GetNodes().GetEndOfExtras(), 2 );
2461*b1cdbd2cSJim Jagielski if( !aIdx.GetNode().IsCntntNode() )
2462*b1cdbd2cSJim Jagielski GetDoc()->GetNodes().GoNext( &aIdx );
2463*b1cdbd2cSJim Jagielski return aIdx == pCurCrsr->GetPoint()->nNode;
2464*b1cdbd2cSJim Jagielski }
2465*b1cdbd2cSJim Jagielski
2466*b1cdbd2cSJim Jagielski
IsEndOfDoc() const2467*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsEndOfDoc() const
2468*b1cdbd2cSJim Jagielski {
2469*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( GetDoc()->GetNodes().GetEndOfContent(), -1 );
2470*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = aIdx.GetNode().GetCntntNode();
2471*b1cdbd2cSJim Jagielski if( !pCNd )
2472*b1cdbd2cSJim Jagielski pCNd = GetDoc()->GetNodes().GoPrevious( &aIdx );
2473*b1cdbd2cSJim Jagielski
2474*b1cdbd2cSJim Jagielski return aIdx == pCurCrsr->GetPoint()->nNode &&
2475*b1cdbd2cSJim Jagielski pCNd->Len() == pCurCrsr->GetPoint()->nContent.GetIndex();
2476*b1cdbd2cSJim Jagielski }
2477*b1cdbd2cSJim Jagielski
2478*b1cdbd2cSJim Jagielski
2479*b1cdbd2cSJim Jagielski // loesche alle erzeugten Crsr, setze den Tabellen-Crsr und den letzten
2480*b1cdbd2cSJim Jagielski // Cursor auf seinen TextNode (oder StartNode?).
2481*b1cdbd2cSJim Jagielski // Beim naechsten ::GetCrsr werden sie wieder alle erzeugt
2482*b1cdbd2cSJim Jagielski // Wird fuers Drag&Drop / ClipBorad-Paste in Tabellen benoetigt.
ParkTblCrsr()2483*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::ParkTblCrsr()
2484*b1cdbd2cSJim Jagielski {
2485*b1cdbd2cSJim Jagielski if( !pTblCrsr )
2486*b1cdbd2cSJim Jagielski return sal_False;
2487*b1cdbd2cSJim Jagielski
2488*b1cdbd2cSJim Jagielski pTblCrsr->ParkCrsr();
2489*b1cdbd2cSJim Jagielski
2490*b1cdbd2cSJim Jagielski while( pCurCrsr->GetNext() != pCurCrsr )
2491*b1cdbd2cSJim Jagielski delete pCurCrsr->GetNext();
2492*b1cdbd2cSJim Jagielski
2493*b1cdbd2cSJim Jagielski // vom Cursor !immer! SPoint und Mark umsetzen
2494*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
2495*b1cdbd2cSJim Jagielski *pCurCrsr->GetMark() = *pCurCrsr->GetPoint() = *pTblCrsr->GetPoint();
2496*b1cdbd2cSJim Jagielski pCurCrsr->DeleteMark();
2497*b1cdbd2cSJim Jagielski
2498*b1cdbd2cSJim Jagielski return sal_True;
2499*b1cdbd2cSJim Jagielski }
2500*b1cdbd2cSJim Jagielski
2501*b1cdbd2cSJim Jagielski /***********************************************************************
2502*b1cdbd2cSJim Jagielski #* Class : SwCrsrShell
2503*b1cdbd2cSJim Jagielski #* Methode : ParkCrsr
2504*b1cdbd2cSJim Jagielski #* Beschreibung: Vernichtet Selektionen und zus. Crsr aller Shell der
2505*b1cdbd2cSJim Jagielski #* verbleibende Crsr der Shell wird geparkt.
2506*b1cdbd2cSJim Jagielski #* Datum : MA 05. Nov. 92
2507*b1cdbd2cSJim Jagielski #* Update : JP 19.09.97
2508*b1cdbd2cSJim Jagielski #***********************************************************************/
2509*b1cdbd2cSJim Jagielski
_ParkPams(SwPaM * pDelRg,SwShellCrsr ** ppDelRing)2510*b1cdbd2cSJim Jagielski void SwCrsrShell::_ParkPams( SwPaM* pDelRg, SwShellCrsr** ppDelRing )
2511*b1cdbd2cSJim Jagielski {
2512*b1cdbd2cSJim Jagielski const SwPosition *pStt = pDelRg->Start(),
2513*b1cdbd2cSJim Jagielski *pEnd = pDelRg->GetPoint() == pStt ? pDelRg->GetMark() : pDelRg->GetPoint();
2514*b1cdbd2cSJim Jagielski
2515*b1cdbd2cSJim Jagielski SwPaM *pTmpDel = 0, *pTmp = *ppDelRing;
2516*b1cdbd2cSJim Jagielski
2517*b1cdbd2cSJim Jagielski // durchsuche den gesamten Ring
2518*b1cdbd2cSJim Jagielski sal_Bool bGoNext;
2519*b1cdbd2cSJim Jagielski do {
2520*b1cdbd2cSJim Jagielski const SwPosition *pTmpStt = pTmp->Start(),
2521*b1cdbd2cSJim Jagielski *pTmpEnd = pTmp->GetPoint() == pTmpStt ?
2522*b1cdbd2cSJim Jagielski pTmp->GetMark() : pTmp->GetPoint();
2523*b1cdbd2cSJim Jagielski /*
2524*b1cdbd2cSJim Jagielski * liegt ein SPoint oder GetMark innerhalb vom Crsr-Bereich
2525*b1cdbd2cSJim Jagielski * muss der alte Bereich aufgehoben werden.
2526*b1cdbd2cSJim Jagielski * Beim Vergleich ist darauf zu achten, das End() nicht mehr zum
2527*b1cdbd2cSJim Jagielski * Bereich gehoert !
2528*b1cdbd2cSJim Jagielski */
2529*b1cdbd2cSJim Jagielski if( *pStt <= *pTmpStt )
2530*b1cdbd2cSJim Jagielski {
2531*b1cdbd2cSJim Jagielski if( *pEnd > *pTmpStt ||
2532*b1cdbd2cSJim Jagielski ( *pEnd == *pTmpStt && *pEnd == *pTmpEnd ))
2533*b1cdbd2cSJim Jagielski pTmpDel = pTmp;
2534*b1cdbd2cSJim Jagielski }
2535*b1cdbd2cSJim Jagielski else
2536*b1cdbd2cSJim Jagielski if( *pStt < *pTmpEnd )
2537*b1cdbd2cSJim Jagielski pTmpDel = pTmp;
2538*b1cdbd2cSJim Jagielski
2539*b1cdbd2cSJim Jagielski bGoNext = sal_True;
2540*b1cdbd2cSJim Jagielski if( pTmpDel ) // ist der Pam im Bereich ?? loesche ihn
2541*b1cdbd2cSJim Jagielski {
2542*b1cdbd2cSJim Jagielski sal_Bool bDelete = sal_True;
2543*b1cdbd2cSJim Jagielski if( *ppDelRing == pTmpDel )
2544*b1cdbd2cSJim Jagielski {
2545*b1cdbd2cSJim Jagielski if( *ppDelRing == pCurCrsr )
2546*b1cdbd2cSJim Jagielski {
2547*b1cdbd2cSJim Jagielski if( sal_True == ( bDelete = GoNextCrsr() ))
2548*b1cdbd2cSJim Jagielski {
2549*b1cdbd2cSJim Jagielski bGoNext = sal_False;
2550*b1cdbd2cSJim Jagielski pTmp = (SwPaM*)pTmp->GetNext();
2551*b1cdbd2cSJim Jagielski }
2552*b1cdbd2cSJim Jagielski }
2553*b1cdbd2cSJim Jagielski else
2554*b1cdbd2cSJim Jagielski bDelete = sal_False; // StackCrsr nie loeschen !!
2555*b1cdbd2cSJim Jagielski }
2556*b1cdbd2cSJim Jagielski
2557*b1cdbd2cSJim Jagielski if( bDelete )
2558*b1cdbd2cSJim Jagielski delete pTmpDel; // hebe alten Bereich auf
2559*b1cdbd2cSJim Jagielski else
2560*b1cdbd2cSJim Jagielski {
2561*b1cdbd2cSJim Jagielski pTmpDel->GetPoint()->nContent.Assign( 0, 0 );
2562*b1cdbd2cSJim Jagielski pTmpDel->GetPoint()->nNode = 0;
2563*b1cdbd2cSJim Jagielski pTmpDel->SetMark();
2564*b1cdbd2cSJim Jagielski pTmpDel->DeleteMark();
2565*b1cdbd2cSJim Jagielski }
2566*b1cdbd2cSJim Jagielski pTmpDel = 0;
2567*b1cdbd2cSJim Jagielski }
2568*b1cdbd2cSJim Jagielski else if( !pTmp->HasMark() ) // sorge auf jedenfall dafuer, das
2569*b1cdbd2cSJim Jagielski { // nicht benutzte Indizies beachtet werden!
2570*b1cdbd2cSJim Jagielski pTmp->SetMark(); // SPoint liegt nicht im Bereich,
2571*b1cdbd2cSJim Jagielski pTmp->DeleteMark(); // aber vielleicht GetMark, also setzen
2572*b1cdbd2cSJim Jagielski }
2573*b1cdbd2cSJim Jagielski if( bGoNext )
2574*b1cdbd2cSJim Jagielski pTmp = (SwPaM*)pTmp->GetNext();
2575*b1cdbd2cSJim Jagielski } while( !bGoNext || *ppDelRing != pTmp );
2576*b1cdbd2cSJim Jagielski }
2577*b1cdbd2cSJim Jagielski
ParkCrsr(const SwNodeIndex & rIdx)2578*b1cdbd2cSJim Jagielski void SwCrsrShell::ParkCrsr( const SwNodeIndex &rIdx )
2579*b1cdbd2cSJim Jagielski {
2580*b1cdbd2cSJim Jagielski SwNode *pNode = &rIdx.GetNode();
2581*b1cdbd2cSJim Jagielski
2582*b1cdbd2cSJim Jagielski // erzeuge einen neuen Pam
2583*b1cdbd2cSJim Jagielski SwPaM * pNew = new SwPaM( *GetCrsr()->GetPoint() );
2584*b1cdbd2cSJim Jagielski if( pNode->GetStartNode() )
2585*b1cdbd2cSJim Jagielski {
2586*b1cdbd2cSJim Jagielski if( ( pNode = pNode->StartOfSectionNode())->IsTableNode() )
2587*b1cdbd2cSJim Jagielski {
2588*b1cdbd2cSJim Jagielski // der angegebene Node steht in einer Tabelle, also Parke
2589*b1cdbd2cSJim Jagielski // den Crsr auf dem Tabellen-Node (ausserhalb der Tabelle)
2590*b1cdbd2cSJim Jagielski pNew->GetPoint()->nNode = *pNode->StartOfSectionNode();
2591*b1cdbd2cSJim Jagielski }
2592*b1cdbd2cSJim Jagielski else // also auf dem StartNode selbst.
2593*b1cdbd2cSJim Jagielski // Dann immer ueber seinen EndNode den StartNode erfragen !!!
2594*b1cdbd2cSJim Jagielski // (StartOfSection vom StartNode ist der Parent !)
2595*b1cdbd2cSJim Jagielski pNew->GetPoint()->nNode = *pNode->EndOfSectionNode()->StartOfSectionNode();
2596*b1cdbd2cSJim Jagielski }
2597*b1cdbd2cSJim Jagielski else
2598*b1cdbd2cSJim Jagielski pNew->GetPoint()->nNode = *pNode->StartOfSectionNode();
2599*b1cdbd2cSJim Jagielski pNew->SetMark();
2600*b1cdbd2cSJim Jagielski pNew->GetPoint()->nNode = *pNode->EndOfSectionNode();
2601*b1cdbd2cSJim Jagielski
2602*b1cdbd2cSJim Jagielski //Alle Shells wollen etwas davon haben.
2603*b1cdbd2cSJim Jagielski ViewShell *pTmp = this;
2604*b1cdbd2cSJim Jagielski do {
2605*b1cdbd2cSJim Jagielski if( pTmp->IsA( TYPE( SwCrsrShell )))
2606*b1cdbd2cSJim Jagielski {
2607*b1cdbd2cSJim Jagielski SwCrsrShell* pSh = (SwCrsrShell*)pTmp;
2608*b1cdbd2cSJim Jagielski if( pSh->pCrsrStk )
2609*b1cdbd2cSJim Jagielski pSh->_ParkPams( pNew, &pSh->pCrsrStk );
2610*b1cdbd2cSJim Jagielski
2611*b1cdbd2cSJim Jagielski pSh->_ParkPams( pNew, &pSh->pCurCrsr );
2612*b1cdbd2cSJim Jagielski if( pSh->pTblCrsr )
2613*b1cdbd2cSJim Jagielski {
2614*b1cdbd2cSJim Jagielski // setze den Tabellen Cursor immer auf 0, den aktuellen
2615*b1cdbd2cSJim Jagielski // immer auf den Anfang der Tabelle
2616*b1cdbd2cSJim Jagielski SwPaM* pTCrsr = pSh->GetTblCrs();
2617*b1cdbd2cSJim Jagielski SwNode* pTblNd = pTCrsr->GetPoint()->nNode.GetNode().FindTableNode();
2618*b1cdbd2cSJim Jagielski if ( pTblNd )
2619*b1cdbd2cSJim Jagielski {
2620*b1cdbd2cSJim Jagielski pTCrsr->GetPoint()->nContent.Assign( 0, 0 );
2621*b1cdbd2cSJim Jagielski pTCrsr->GetPoint()->nNode = 0;
2622*b1cdbd2cSJim Jagielski pTCrsr->SetMark();
2623*b1cdbd2cSJim Jagielski pTCrsr->DeleteMark();
2624*b1cdbd2cSJim Jagielski pSh->pCurCrsr->GetPoint()->nNode = *pTblNd;
2625*b1cdbd2cSJim Jagielski }
2626*b1cdbd2cSJim Jagielski }
2627*b1cdbd2cSJim Jagielski }
2628*b1cdbd2cSJim Jagielski } while ( this != (pTmp = (ViewShell*)pTmp->GetNext() ));
2629*b1cdbd2cSJim Jagielski delete pNew;
2630*b1cdbd2cSJim Jagielski }
2631*b1cdbd2cSJim Jagielski
2632*b1cdbd2cSJim Jagielski //=========================================================================
2633*b1cdbd2cSJim Jagielski
2634*b1cdbd2cSJim Jagielski /*
2635*b1cdbd2cSJim Jagielski * der Copy-Constructor
2636*b1cdbd2cSJim Jagielski * Cursor-Position kopieren, in den Ring eingetragen.
2637*b1cdbd2cSJim Jagielski * Alle Ansichten eines Dokumentes stehen im Ring der Shells.
2638*b1cdbd2cSJim Jagielski */
2639*b1cdbd2cSJim Jagielski
SwCrsrShell(SwCrsrShell & rShell,Window * pInitWin)2640*b1cdbd2cSJim Jagielski SwCrsrShell::SwCrsrShell( SwCrsrShell& rShell, Window *pInitWin )
2641*b1cdbd2cSJim Jagielski : ViewShell( rShell, pInitWin ),
2642*b1cdbd2cSJim Jagielski SwModify( 0 ), pCrsrStk( 0 ), pBlockCrsr( 0 ), pTblCrsr( 0 ),
2643*b1cdbd2cSJim Jagielski pBoxIdx( 0 ), pBoxPtr( 0 ), nCrsrMove( 0 ), nBasicActionCnt( 0 ),
2644*b1cdbd2cSJim Jagielski eMvState( MV_NONE ),
2645*b1cdbd2cSJim Jagielski // --> OD 2008-04-02 #refactorlists#
2646*b1cdbd2cSJim Jagielski sMarkedListId(),
2647*b1cdbd2cSJim Jagielski nMarkedListLevel( 0 )
2648*b1cdbd2cSJim Jagielski // <--
2649*b1cdbd2cSJim Jagielski {
2650*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2651*b1cdbd2cSJim Jagielski // Nur die Position vom aktuellen Cursor aus der Copy-Shell uebernehmen
2652*b1cdbd2cSJim Jagielski pCurCrsr = new SwShellCrsr( *this, *(rShell.pCurCrsr->GetPoint()) );
2653*b1cdbd2cSJim Jagielski pCurCrsr->GetCntntNode()->Add( this );
2654*b1cdbd2cSJim Jagielski
2655*b1cdbd2cSJim Jagielski bAllProtect = bVisPortChgd = bChgCallFlag = bInCMvVisportChgd =
2656*b1cdbd2cSJim Jagielski bGCAttr = bIgnoreReadonly = bSelTblCells = bBasicHideCrsr =
2657*b1cdbd2cSJim Jagielski bOverwriteCrsr = sal_False;
2658*b1cdbd2cSJim Jagielski bCallChgLnk = bHasFocus = bSVCrsrVis = bAutoUpdateCells = sal_True;
2659*b1cdbd2cSJim Jagielski bSetCrsrInReadOnly = sal_True;
2660*b1cdbd2cSJim Jagielski pVisCrsr = new SwVisCrsr( this );
2661*b1cdbd2cSJim Jagielski // UpdateCrsr( 0 );
2662*b1cdbd2cSJim Jagielski // OD 11.02.2003 #100556#
2663*b1cdbd2cSJim Jagielski mbMacroExecAllowed = rShell.IsMacroExecAllowed();
2664*b1cdbd2cSJim Jagielski oldColFrm = NULL;
2665*b1cdbd2cSJim Jagielski }
2666*b1cdbd2cSJim Jagielski
2667*b1cdbd2cSJim Jagielski
2668*b1cdbd2cSJim Jagielski /*
2669*b1cdbd2cSJim Jagielski * der normale Constructor
2670*b1cdbd2cSJim Jagielski */
2671*b1cdbd2cSJim Jagielski
SwCrsrShell(SwDoc & rDoc,Window * pInitWin,const SwViewOption * pInitOpt)2672*b1cdbd2cSJim Jagielski SwCrsrShell::SwCrsrShell( SwDoc& rDoc, Window *pInitWin,
2673*b1cdbd2cSJim Jagielski const SwViewOption *pInitOpt )
2674*b1cdbd2cSJim Jagielski : ViewShell( rDoc, pInitWin, pInitOpt ),
2675*b1cdbd2cSJim Jagielski SwModify( 0 ), pCrsrStk( 0 ), pBlockCrsr( 0 ), pTblCrsr( 0 ),
2676*b1cdbd2cSJim Jagielski pBoxIdx( 0 ), pBoxPtr( 0 ), nCrsrMove( 0 ), nBasicActionCnt( 0 ),
2677*b1cdbd2cSJim Jagielski eMvState( MV_NONE ), // state for crsr-travelling - GetCrsrOfst
2678*b1cdbd2cSJim Jagielski // --> OD 2008-04-02 #refactorlists#
2679*b1cdbd2cSJim Jagielski sMarkedListId(),
2680*b1cdbd2cSJim Jagielski nMarkedListLevel( 0 )
2681*b1cdbd2cSJim Jagielski // <--
2682*b1cdbd2cSJim Jagielski {
2683*b1cdbd2cSJim Jagielski SET_CURR_SHELL( this );
2684*b1cdbd2cSJim Jagielski /*
2685*b1cdbd2cSJim Jagielski * Erzeugen des initialen Cursors, wird auf die erste
2686*b1cdbd2cSJim Jagielski * Inhaltsposition gesetzt
2687*b1cdbd2cSJim Jagielski */
2688*b1cdbd2cSJim Jagielski SwNodes& rNds = rDoc.GetNodes();
2689*b1cdbd2cSJim Jagielski
2690*b1cdbd2cSJim Jagielski SwNodeIndex aNodeIdx( *rNds.GetEndOfContent().StartOfSectionNode() );
2691*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = rNds.GoNext( &aNodeIdx ); // gehe zum 1. ContentNode
2692*b1cdbd2cSJim Jagielski
2693*b1cdbd2cSJim Jagielski pCurCrsr = new SwShellCrsr( *this, SwPosition( aNodeIdx, SwIndex( pCNd, 0 )));
2694*b1cdbd2cSJim Jagielski
2695*b1cdbd2cSJim Jagielski // melde die Shell beim akt. Node als abhaengig an, dadurch koennen alle
2696*b1cdbd2cSJim Jagielski // Attribut-Aenderungen ueber den Link weiter gemeldet werden.
2697*b1cdbd2cSJim Jagielski pCNd->Add( this );
2698*b1cdbd2cSJim Jagielski
2699*b1cdbd2cSJim Jagielski bAllProtect = bVisPortChgd = bChgCallFlag = bInCMvVisportChgd =
2700*b1cdbd2cSJim Jagielski bGCAttr = bIgnoreReadonly = bSelTblCells = bBasicHideCrsr =
2701*b1cdbd2cSJim Jagielski bOverwriteCrsr = sal_False;
2702*b1cdbd2cSJim Jagielski bCallChgLnk = bHasFocus = bSVCrsrVis = bAutoUpdateCells = sal_True;
2703*b1cdbd2cSJim Jagielski bSetCrsrInReadOnly = sal_True;
2704*b1cdbd2cSJim Jagielski
2705*b1cdbd2cSJim Jagielski pVisCrsr = new SwVisCrsr( this );
2706*b1cdbd2cSJim Jagielski // UpdateCrsr( 0 );
2707*b1cdbd2cSJim Jagielski // OD 11.02.2003 #100556#
2708*b1cdbd2cSJim Jagielski mbMacroExecAllowed = true;
2709*b1cdbd2cSJim Jagielski }
2710*b1cdbd2cSJim Jagielski
2711*b1cdbd2cSJim Jagielski
2712*b1cdbd2cSJim Jagielski
~SwCrsrShell()2713*b1cdbd2cSJim Jagielski SwCrsrShell::~SwCrsrShell()
2714*b1cdbd2cSJim Jagielski {
2715*b1cdbd2cSJim Jagielski // wenn es nicht die letzte View so sollte zu mindest das
2716*b1cdbd2cSJim Jagielski // Feld noch geupdatet werden.
2717*b1cdbd2cSJim Jagielski if( GetNext() != this )
2718*b1cdbd2cSJim Jagielski CheckTblBoxCntnt( pCurCrsr->GetPoint() );
2719*b1cdbd2cSJim Jagielski else
2720*b1cdbd2cSJim Jagielski ClearTblBoxCntnt();
2721*b1cdbd2cSJim Jagielski
2722*b1cdbd2cSJim Jagielski delete pVisCrsr;
2723*b1cdbd2cSJim Jagielski delete pBlockCrsr;
2724*b1cdbd2cSJim Jagielski delete pTblCrsr;
2725*b1cdbd2cSJim Jagielski
2726*b1cdbd2cSJim Jagielski /*
2727*b1cdbd2cSJim Jagielski * Freigabe der Cursor
2728*b1cdbd2cSJim Jagielski */
2729*b1cdbd2cSJim Jagielski while(pCurCrsr->GetNext() != pCurCrsr)
2730*b1cdbd2cSJim Jagielski delete pCurCrsr->GetNext();
2731*b1cdbd2cSJim Jagielski delete pCurCrsr;
2732*b1cdbd2cSJim Jagielski
2733*b1cdbd2cSJim Jagielski // Stack freigeben
2734*b1cdbd2cSJim Jagielski if( pCrsrStk )
2735*b1cdbd2cSJim Jagielski {
2736*b1cdbd2cSJim Jagielski while( pCrsrStk->GetNext() != pCrsrStk )
2737*b1cdbd2cSJim Jagielski delete pCrsrStk->GetNext();
2738*b1cdbd2cSJim Jagielski delete pCrsrStk;
2739*b1cdbd2cSJim Jagielski }
2740*b1cdbd2cSJim Jagielski
2741*b1cdbd2cSJim Jagielski // JP 27.07.98: Bug 54025 - ggfs. den HTML-Parser, der als Client in
2742*b1cdbd2cSJim Jagielski // der CursorShell haengt keine Chance geben, sich an den
2743*b1cdbd2cSJim Jagielski // TextNode zu haengen.
2744*b1cdbd2cSJim Jagielski if( GetRegisteredIn() )
2745*b1cdbd2cSJim Jagielski GetRegisteredInNonConst()->Remove( this );
2746*b1cdbd2cSJim Jagielski }
2747*b1cdbd2cSJim Jagielski
getShellCrsr(bool bBlock)2748*b1cdbd2cSJim Jagielski SwShellCrsr* SwCrsrShell::getShellCrsr( bool bBlock )
2749*b1cdbd2cSJim Jagielski {
2750*b1cdbd2cSJim Jagielski if( pTblCrsr )
2751*b1cdbd2cSJim Jagielski return pTblCrsr;
2752*b1cdbd2cSJim Jagielski if( pBlockCrsr && bBlock )
2753*b1cdbd2cSJim Jagielski return &pBlockCrsr->getShellCrsr();
2754*b1cdbd2cSJim Jagielski return pCurCrsr;
2755*b1cdbd2cSJim Jagielski }
2756*b1cdbd2cSJim Jagielski
2757*b1cdbd2cSJim Jagielski //Sollte fuer das Clipboard der WaitPtr geschaltet werden?
2758*b1cdbd2cSJim Jagielski //Warten bei TableMode, Mehrfachselektion und mehr als x Selektieren Absaetzen.
2759*b1cdbd2cSJim Jagielski
ShouldWait() const2760*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::ShouldWait() const
2761*b1cdbd2cSJim Jagielski {
2762*b1cdbd2cSJim Jagielski if ( IsTableMode() || GetCrsrCnt() > 1 )
2763*b1cdbd2cSJim Jagielski return sal_True;
2764*b1cdbd2cSJim Jagielski
2765*b1cdbd2cSJim Jagielski if( HasDrawView() && GetDrawView()->GetMarkedObjectList().GetMarkCount() )
2766*b1cdbd2cSJim Jagielski return sal_True;
2767*b1cdbd2cSJim Jagielski
2768*b1cdbd2cSJim Jagielski SwPaM* pPam = GetCrsr();
2769*b1cdbd2cSJim Jagielski return pPam->Start()->nNode.GetIndex() + 10 <
2770*b1cdbd2cSJim Jagielski pPam->End()->nNode.GetIndex();
2771*b1cdbd2cSJim Jagielski }
2772*b1cdbd2cSJim Jagielski
2773*b1cdbd2cSJim Jagielski
UpdateTblSelBoxes()2774*b1cdbd2cSJim Jagielski sal_uInt16 SwCrsrShell::UpdateTblSelBoxes()
2775*b1cdbd2cSJim Jagielski {
2776*b1cdbd2cSJim Jagielski if( pTblCrsr && ( pTblCrsr->IsChgd() || !pTblCrsr->GetBoxesCount() ))
2777*b1cdbd2cSJim Jagielski GetLayout()->MakeTblCrsrs( *pTblCrsr );
2778*b1cdbd2cSJim Jagielski return pTblCrsr ? pTblCrsr->GetBoxesCount() : 0;
2779*b1cdbd2cSJim Jagielski }
2780*b1cdbd2cSJim Jagielski
2781*b1cdbd2cSJim Jagielski // zeige das akt. selektierte "Object" an
MakeSelVisible()2782*b1cdbd2cSJim Jagielski void SwCrsrShell::MakeSelVisible()
2783*b1cdbd2cSJim Jagielski {
2784*b1cdbd2cSJim Jagielski ASSERT( bHasFocus, "kein Focus aber Cursor sichtbar machen?" );
2785*b1cdbd2cSJim Jagielski if( aCrsrHeight.Y() < aCharRect.Height() && aCharRect.Height() > VisArea().Height() )
2786*b1cdbd2cSJim Jagielski {
2787*b1cdbd2cSJim Jagielski SwRect aTmp( aCharRect );
2788*b1cdbd2cSJim Jagielski long nDiff = aCharRect.Height() - VisArea().Height();
2789*b1cdbd2cSJim Jagielski if( nDiff < aCrsrHeight.X() )
2790*b1cdbd2cSJim Jagielski aTmp.Top( nDiff + aCharRect.Top() );
2791*b1cdbd2cSJim Jagielski else
2792*b1cdbd2cSJim Jagielski {
2793*b1cdbd2cSJim Jagielski aTmp.Top( aCrsrHeight.X() + aCharRect.Top() );
2794*b1cdbd2cSJim Jagielski aTmp.Height( aCrsrHeight.Y() );
2795*b1cdbd2cSJim Jagielski }
2796*b1cdbd2cSJim Jagielski if( !aTmp.HasArea() )
2797*b1cdbd2cSJim Jagielski {
2798*b1cdbd2cSJim Jagielski aTmp.SSize().Height() += 1;
2799*b1cdbd2cSJim Jagielski aTmp.SSize().Width() += 1;
2800*b1cdbd2cSJim Jagielski }
2801*b1cdbd2cSJim Jagielski MakeVisible( aTmp );
2802*b1cdbd2cSJim Jagielski }
2803*b1cdbd2cSJim Jagielski else
2804*b1cdbd2cSJim Jagielski {
2805*b1cdbd2cSJim Jagielski if( aCharRect.HasArea() )
2806*b1cdbd2cSJim Jagielski MakeVisible( aCharRect );
2807*b1cdbd2cSJim Jagielski else
2808*b1cdbd2cSJim Jagielski {
2809*b1cdbd2cSJim Jagielski SwRect aTmp( aCharRect );
2810*b1cdbd2cSJim Jagielski aTmp.SSize().Height() += 1; aTmp.SSize().Width() += 1;
2811*b1cdbd2cSJim Jagielski MakeVisible( aTmp );
2812*b1cdbd2cSJim Jagielski }
2813*b1cdbd2cSJim Jagielski }
2814*b1cdbd2cSJim Jagielski }
2815*b1cdbd2cSJim Jagielski
2816*b1cdbd2cSJim Jagielski
2817*b1cdbd2cSJim Jagielski // suche eine gueltige ContentPosition (nicht geschuetzt/nicht versteckt)
FindValidCntntNode(sal_Bool bOnlyText)2818*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::FindValidCntntNode( sal_Bool bOnlyText )
2819*b1cdbd2cSJim Jagielski {
2820*b1cdbd2cSJim Jagielski if( pTblCrsr ) // was soll ich jetzt machen ??
2821*b1cdbd2cSJim Jagielski {
2822*b1cdbd2cSJim Jagielski ASSERT( !this, "TabellenSelection nicht aufgehoben!" );
2823*b1cdbd2cSJim Jagielski return sal_False;
2824*b1cdbd2cSJim Jagielski }
2825*b1cdbd2cSJim Jagielski
2826*b1cdbd2cSJim Jagielski //JP 28.10.97: Bug 45129 - im UI-ReadOnly ist alles erlaubt
2827*b1cdbd2cSJim Jagielski if( !bAllProtect && GetDoc()->GetDocShell() &&
2828*b1cdbd2cSJim Jagielski GetDoc()->GetDocShell()->IsReadOnlyUI() )
2829*b1cdbd2cSJim Jagielski return sal_True;
2830*b1cdbd2cSJim Jagielski
2831*b1cdbd2cSJim Jagielski // dann raus da!
2832*b1cdbd2cSJim Jagielski if( pCurCrsr->HasMark() )
2833*b1cdbd2cSJim Jagielski ClearMark();
2834*b1cdbd2cSJim Jagielski
2835*b1cdbd2cSJim Jagielski // als erstes mal auf Rahmen abpruefen
2836*b1cdbd2cSJim Jagielski SwNodeIndex& rNdIdx = pCurCrsr->GetPoint()->nNode;
2837*b1cdbd2cSJim Jagielski sal_uLong nNdIdx = rNdIdx.GetIndex(); // sichern
2838*b1cdbd2cSJim Jagielski SwNodes& rNds = pDoc->GetNodes();
2839*b1cdbd2cSJim Jagielski SwCntntNode* pCNd = rNdIdx.GetNode().GetCntntNode();
2840*b1cdbd2cSJim Jagielski const SwCntntFrm * pFrm;
2841*b1cdbd2cSJim Jagielski
2842*b1cdbd2cSJim Jagielski if( pCNd && 0 != (pFrm = pCNd->getLayoutFrm( GetLayout(),0,pCurCrsr->GetPoint(),sal_False)) &&
2843*b1cdbd2cSJim Jagielski !IsReadOnlyAvailable() && pFrm->IsProtected() &&
2844*b1cdbd2cSJim Jagielski nNdIdx < rNds.GetEndOfExtras().GetIndex() )
2845*b1cdbd2cSJim Jagielski {
2846*b1cdbd2cSJim Jagielski // geschuetzter Rahmen ueberspringen
2847*b1cdbd2cSJim Jagielski SwPaM aPam( *pCurCrsr->GetPoint() );
2848*b1cdbd2cSJim Jagielski aPam.SetMark();
2849*b1cdbd2cSJim Jagielski aPam.GetMark()->nNode = rNds.GetEndOfContent();
2850*b1cdbd2cSJim Jagielski aPam.GetPoint()->nNode = *pCNd->EndOfSectionNode();
2851*b1cdbd2cSJim Jagielski
2852*b1cdbd2cSJim Jagielski sal_Bool bFirst = sal_False;
2853*b1cdbd2cSJim Jagielski if( 0 == (pCNd = ::GetNode( aPam, bFirst, fnMoveForward, sal_False )))
2854*b1cdbd2cSJim Jagielski {
2855*b1cdbd2cSJim Jagielski aPam.GetMark()->nNode = *rNds.GetEndOfPostIts().StartOfSectionNode();
2856*b1cdbd2cSJim Jagielski pCNd = ::GetNode( aPam, bFirst, fnMoveBackward, sal_False );
2857*b1cdbd2cSJim Jagielski }
2858*b1cdbd2cSJim Jagielski
2859*b1cdbd2cSJim Jagielski if( !pCNd ) // sollte nie passieren !!!
2860*b1cdbd2cSJim Jagielski {
2861*b1cdbd2cSJim Jagielski rNdIdx = nNdIdx; // alten Node zurueck
2862*b1cdbd2cSJim Jagielski return sal_False;
2863*b1cdbd2cSJim Jagielski }
2864*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *aPam.GetPoint();
2865*b1cdbd2cSJim Jagielski }
2866*b1cdbd2cSJim Jagielski else if( bOnlyText && pCNd && pCNd->IsNoTxtNode() )
2867*b1cdbd2cSJim Jagielski {
2868*b1cdbd2cSJim Jagielski // dann auf den Anfang vom Doc stellen
2869*b1cdbd2cSJim Jagielski rNdIdx = pDoc->GetNodes().GetEndOfExtras();
2870*b1cdbd2cSJim Jagielski pCurCrsr->GetPoint()->nContent.Assign( pDoc->GetNodes().GoNext(
2871*b1cdbd2cSJim Jagielski &rNdIdx ), 0 );
2872*b1cdbd2cSJim Jagielski nNdIdx = rNdIdx.GetIndex();
2873*b1cdbd2cSJim Jagielski }
2874*b1cdbd2cSJim Jagielski
2875*b1cdbd2cSJim Jagielski sal_Bool bOk = sal_True;
2876*b1cdbd2cSJim Jagielski
2877*b1cdbd2cSJim Jagielski // #i9059# cursor may not stand in protected cells
2878*b1cdbd2cSJim Jagielski // (unless cursor in protected areas is OK.)
2879*b1cdbd2cSJim Jagielski const SwTableNode* pTableNode = rNdIdx.GetNode().FindTableNode();
2880*b1cdbd2cSJim Jagielski if( !IsReadOnlyAvailable() &&
2881*b1cdbd2cSJim Jagielski pTableNode != NULL && rNdIdx.GetNode().IsProtect() )
2882*b1cdbd2cSJim Jagielski {
2883*b1cdbd2cSJim Jagielski // we're in a table, and we're in a protected area, so we're
2884*b1cdbd2cSJim Jagielski // probably in a protected cell.
2885*b1cdbd2cSJim Jagielski
2886*b1cdbd2cSJim Jagielski // move forward into non-protected area.
2887*b1cdbd2cSJim Jagielski SwPaM aPam( rNdIdx.GetNode(), 0 );
2888*b1cdbd2cSJim Jagielski while( aPam.GetNode()->IsProtect() &&
2889*b1cdbd2cSJim Jagielski aPam.Move( fnMoveForward, fnGoCntnt ) )
2890*b1cdbd2cSJim Jagielski ; // nothing to do in the loop; the aPam.Move does the moving!
2891*b1cdbd2cSJim Jagielski
2892*b1cdbd2cSJim Jagielski // didn't work? then go backwards!
2893*b1cdbd2cSJim Jagielski if( aPam.GetNode()->IsProtect() )
2894*b1cdbd2cSJim Jagielski {
2895*b1cdbd2cSJim Jagielski SwPaM aTmpPaM( rNdIdx.GetNode(), 0 );
2896*b1cdbd2cSJim Jagielski aPam = aTmpPaM;
2897*b1cdbd2cSJim Jagielski while( aPam.GetNode()->IsProtect() &&
2898*b1cdbd2cSJim Jagielski aPam.Move( fnMoveBackward, fnGoCntnt ) )
2899*b1cdbd2cSJim Jagielski ; // nothing to do in the loop; the aPam.Move does the moving!
2900*b1cdbd2cSJim Jagielski }
2901*b1cdbd2cSJim Jagielski
2902*b1cdbd2cSJim Jagielski // if we're successful, set the new position
2903*b1cdbd2cSJim Jagielski if( ! aPam.GetNode()->IsProtect() )
2904*b1cdbd2cSJim Jagielski {
2905*b1cdbd2cSJim Jagielski *pCurCrsr->GetPoint() = *aPam.GetPoint();
2906*b1cdbd2cSJim Jagielski }
2907*b1cdbd2cSJim Jagielski }
2908*b1cdbd2cSJim Jagielski
2909*b1cdbd2cSJim Jagielski // in einem geschuetzten Bereich
2910*b1cdbd2cSJim Jagielski const SwSectionNode* pSectNd = rNdIdx.GetNode().FindSectionNode();
2911*b1cdbd2cSJim Jagielski if( pSectNd && ( pSectNd->GetSection().IsHiddenFlag() ||
2912*b1cdbd2cSJim Jagielski ( !IsReadOnlyAvailable() &&
2913*b1cdbd2cSJim Jagielski pSectNd->GetSection().IsProtectFlag() )) )
2914*b1cdbd2cSJim Jagielski {
2915*b1cdbd2cSJim Jagielski typedef SwCntntNode* (SwNodes:: *FNGoSection)( SwNodeIndex *, int, int ) const;
2916*b1cdbd2cSJim Jagielski FNGoSection funcGoSection = &SwNodes::GoNextSection;
2917*b1cdbd2cSJim Jagielski
2918*b1cdbd2cSJim Jagielski bOk = sal_False;
2919*b1cdbd2cSJim Jagielski
2920*b1cdbd2cSJim Jagielski for( int nLoopCnt = 0; !bOk && nLoopCnt < 2; ++nLoopCnt )
2921*b1cdbd2cSJim Jagielski {
2922*b1cdbd2cSJim Jagielski sal_Bool bWeiter;
2923*b1cdbd2cSJim Jagielski do {
2924*b1cdbd2cSJim Jagielski bWeiter = sal_False;
2925*b1cdbd2cSJim Jagielski while( 0 != ( pCNd = (rNds.*funcGoSection)( &rNdIdx,
2926*b1cdbd2cSJim Jagielski sal_True, !IsReadOnlyAvailable() )) )
2927*b1cdbd2cSJim Jagielski {
2928*b1cdbd2cSJim Jagielski // in eine Tabelle verschoben -> pruefe ob die
2929*b1cdbd2cSJim Jagielski // vielleicht geschuetzt ist
2930*b1cdbd2cSJim Jagielski if( pCNd->FindTableNode() )
2931*b1cdbd2cSJim Jagielski {
2932*b1cdbd2cSJim Jagielski SwCallLink aTmp( *this );
2933*b1cdbd2cSJim Jagielski SwCrsrSaveState aSaveState( *pCurCrsr );
2934*b1cdbd2cSJim Jagielski aTmp.nNdTyp = 0; // im DTOR nichts machen!
2935*b1cdbd2cSJim Jagielski if( !pCurCrsr->IsInProtectTable( sal_True, sal_True ) )
2936*b1cdbd2cSJim Jagielski {
2937*b1cdbd2cSJim Jagielski const SwSectionNode* pSNd = pCNd->FindSectionNode();
2938*b1cdbd2cSJim Jagielski if( !pSNd || !pSNd->GetSection().IsHiddenFlag()
2939*b1cdbd2cSJim Jagielski || (!IsReadOnlyAvailable() &&
2940*b1cdbd2cSJim Jagielski pSNd->GetSection().IsProtectFlag() ))
2941*b1cdbd2cSJim Jagielski {
2942*b1cdbd2cSJim Jagielski bOk = sal_True;
2943*b1cdbd2cSJim Jagielski break; // eine nicht geschuetzte Zelle gef.
2944*b1cdbd2cSJim Jagielski }
2945*b1cdbd2cSJim Jagielski continue; // dann weiter suchen
2946*b1cdbd2cSJim Jagielski }
2947*b1cdbd2cSJim Jagielski }
2948*b1cdbd2cSJim Jagielski else
2949*b1cdbd2cSJim Jagielski {
2950*b1cdbd2cSJim Jagielski bOk = sal_True;
2951*b1cdbd2cSJim Jagielski break; // eine nicht geschuetzte Zelle gef.
2952*b1cdbd2cSJim Jagielski }
2953*b1cdbd2cSJim Jagielski }
2954*b1cdbd2cSJim Jagielski
2955*b1cdbd2cSJim Jagielski if( bOk && rNdIdx.GetIndex() < rNds.GetEndOfExtras().GetIndex() )
2956*b1cdbd2cSJim Jagielski {
2957*b1cdbd2cSJim Jagielski // Teste mal auf Fly - kann auch noch geschuetzt sein!!
2958*b1cdbd2cSJim Jagielski if( 0 == (pFrm = pCNd->getLayoutFrm( GetLayout(),0,0,sal_False)) ||
2959*b1cdbd2cSJim Jagielski ( !IsReadOnlyAvailable() && pFrm->IsProtected() ) ||
2960*b1cdbd2cSJim Jagielski ( bOnlyText && pCNd->IsNoTxtNode() ) )
2961*b1cdbd2cSJim Jagielski {
2962*b1cdbd2cSJim Jagielski // dann weiter suchen!
2963*b1cdbd2cSJim Jagielski bOk = sal_False;
2964*b1cdbd2cSJim Jagielski bWeiter = sal_True;
2965*b1cdbd2cSJim Jagielski }
2966*b1cdbd2cSJim Jagielski }
2967*b1cdbd2cSJim Jagielski } while( bWeiter );
2968*b1cdbd2cSJim Jagielski
2969*b1cdbd2cSJim Jagielski if( !bOk )
2970*b1cdbd2cSJim Jagielski {
2971*b1cdbd2cSJim Jagielski if( !nLoopCnt )
2972*b1cdbd2cSJim Jagielski funcGoSection = &SwNodes::GoPrevSection;
2973*b1cdbd2cSJim Jagielski rNdIdx = nNdIdx;
2974*b1cdbd2cSJim Jagielski }
2975*b1cdbd2cSJim Jagielski }
2976*b1cdbd2cSJim Jagielski }
2977*b1cdbd2cSJim Jagielski if( bOk )
2978*b1cdbd2cSJim Jagielski {
2979*b1cdbd2cSJim Jagielski pCNd = rNdIdx.GetNode().GetCntntNode();
2980*b1cdbd2cSJim Jagielski // sal_uInt16 nCntnt = Min( pCNd->Len(), pCurCrsr->GetPoint()->nContent.GetIndex() );
2981*b1cdbd2cSJim Jagielski xub_StrLen nCntnt = rNdIdx.GetIndex() < nNdIdx ? pCNd->Len() : 0;
2982*b1cdbd2cSJim Jagielski pCurCrsr->GetPoint()->nContent.Assign( pCNd, nCntnt );
2983*b1cdbd2cSJim Jagielski }
2984*b1cdbd2cSJim Jagielski else
2985*b1cdbd2cSJim Jagielski {
2986*b1cdbd2cSJim Jagielski pCNd = rNdIdx.GetNode().GetCntntNode();
2987*b1cdbd2cSJim Jagielski
2988*b1cdbd2cSJim Jagielski // falls Cursor im versteckten Bereich ist, auf jedenfall schon mal
2989*b1cdbd2cSJim Jagielski // verschieben!!
2990*b1cdbd2cSJim Jagielski if( !pCNd || !pCNd->getLayoutFrm( GetLayout(),0,0,sal_False) )
2991*b1cdbd2cSJim Jagielski {
2992*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_NONE );
2993*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
2994*b1cdbd2cSJim Jagielski GetLayout()->GetCrsrOfst( pCurCrsr->GetPoint(), pCurCrsr->GetPtPos(),
2995*b1cdbd2cSJim Jagielski &aTmpState );
2996*b1cdbd2cSJim Jagielski }
2997*b1cdbd2cSJim Jagielski }
2998*b1cdbd2cSJim Jagielski return bOk;
2999*b1cdbd2cSJim Jagielski }
3000*b1cdbd2cSJim Jagielski
3001*b1cdbd2cSJim Jagielski
IsCrsrReadonly() const3002*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsCrsrReadonly() const
3003*b1cdbd2cSJim Jagielski {
3004*b1cdbd2cSJim Jagielski if ( GetViewOptions()->IsReadonly() ||
3005*b1cdbd2cSJim Jagielski GetViewOptions()->IsFormView() ) // Formular view
3006*b1cdbd2cSJim Jagielski {
3007*b1cdbd2cSJim Jagielski SwFrm *pFrm = GetCurrFrm( sal_False );
3008*b1cdbd2cSJim Jagielski const SwFlyFrm* pFly;
3009*b1cdbd2cSJim Jagielski const SwSection* pSection;
3010*b1cdbd2cSJim Jagielski
3011*b1cdbd2cSJim Jagielski if( pFrm && pFrm->IsInFly() &&
3012*b1cdbd2cSJim Jagielski (pFly = pFrm->FindFlyFrm())->GetFmt()->GetEditInReadonly().GetValue() &&
3013*b1cdbd2cSJim Jagielski pFly->Lower() &&
3014*b1cdbd2cSJim Jagielski !pFly->Lower()->IsNoTxtFrm() &&
3015*b1cdbd2cSJim Jagielski !GetDrawView()->GetMarkedObjectList().GetMarkCount() )
3016*b1cdbd2cSJim Jagielski {
3017*b1cdbd2cSJim Jagielski return sal_False;
3018*b1cdbd2cSJim Jagielski }
3019*b1cdbd2cSJim Jagielski // edit in readonly sections
3020*b1cdbd2cSJim Jagielski else if ( pFrm && pFrm->IsInSct() &&
3021*b1cdbd2cSJim Jagielski 0 != ( pSection = pFrm->FindSctFrm()->GetSection() ) &&
3022*b1cdbd2cSJim Jagielski pSection->IsEditInReadonlyFlag() )
3023*b1cdbd2cSJim Jagielski {
3024*b1cdbd2cSJim Jagielski return sal_False;
3025*b1cdbd2cSJim Jagielski }
3026*b1cdbd2cSJim Jagielski else if ( !IsMultiSelection() && CrsrInsideInputFld() )
3027*b1cdbd2cSJim Jagielski {
3028*b1cdbd2cSJim Jagielski return sal_False;
3029*b1cdbd2cSJim Jagielski }
3030*b1cdbd2cSJim Jagielski
3031*b1cdbd2cSJim Jagielski return sal_True;
3032*b1cdbd2cSJim Jagielski }
3033*b1cdbd2cSJim Jagielski return sal_False;
3034*b1cdbd2cSJim Jagielski }
3035*b1cdbd2cSJim Jagielski
3036*b1cdbd2cSJim Jagielski
3037*b1cdbd2cSJim Jagielski // darf der Cursor in ReadOnlyBereiche?
SetReadOnlyAvailable(sal_Bool bFlag)3038*b1cdbd2cSJim Jagielski void SwCrsrShell::SetReadOnlyAvailable( sal_Bool bFlag )
3039*b1cdbd2cSJim Jagielski {
3040*b1cdbd2cSJim Jagielski // im GlobalDoc darf NIE umgeschaltet werden
3041*b1cdbd2cSJim Jagielski if( (!GetDoc()->GetDocShell() ||
3042*b1cdbd2cSJim Jagielski !GetDoc()->GetDocShell()->IsA( SwGlobalDocShell::StaticType() )) &&
3043*b1cdbd2cSJim Jagielski bFlag != bSetCrsrInReadOnly )
3044*b1cdbd2cSJim Jagielski {
3045*b1cdbd2cSJim Jagielski // wenn das Flag ausgeschaltet wird, dann muessen erstmal alle
3046*b1cdbd2cSJim Jagielski // Selektionen aufgehoben werden. Denn sonst wird sich darauf
3047*b1cdbd2cSJim Jagielski // verlassen, das nichts geschuetztes selektiert ist!
3048*b1cdbd2cSJim Jagielski if( !bFlag )
3049*b1cdbd2cSJim Jagielski {
3050*b1cdbd2cSJim Jagielski ClearMark();
3051*b1cdbd2cSJim Jagielski }
3052*b1cdbd2cSJim Jagielski bSetCrsrInReadOnly = bFlag;
3053*b1cdbd2cSJim Jagielski UpdateCrsr();
3054*b1cdbd2cSJim Jagielski }
3055*b1cdbd2cSJim Jagielski }
3056*b1cdbd2cSJim Jagielski
HasReadonlySel() const3057*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::HasReadonlySel() const
3058*b1cdbd2cSJim Jagielski {
3059*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
3060*b1cdbd2cSJim Jagielski if ( IsReadOnlyAvailable() || GetViewOptions()->IsFormView() )
3061*b1cdbd2cSJim Jagielski {
3062*b1cdbd2cSJim Jagielski if ( pTblCrsr != NULL )
3063*b1cdbd2cSJim Jagielski {
3064*b1cdbd2cSJim Jagielski bRet = pTblCrsr->HasReadOnlyBoxSel()
3065*b1cdbd2cSJim Jagielski || pTblCrsr->HasReadonlySel( GetViewOptions()->IsFormView() );
3066*b1cdbd2cSJim Jagielski }
3067*b1cdbd2cSJim Jagielski else
3068*b1cdbd2cSJim Jagielski {
3069*b1cdbd2cSJim Jagielski const SwPaM* pCrsr = pCurCrsr;
3070*b1cdbd2cSJim Jagielski
3071*b1cdbd2cSJim Jagielski do
3072*b1cdbd2cSJim Jagielski {
3073*b1cdbd2cSJim Jagielski if ( pCrsr->HasReadonlySel( GetViewOptions()->IsFormView() ) )
3074*b1cdbd2cSJim Jagielski {
3075*b1cdbd2cSJim Jagielski bRet = sal_True;
3076*b1cdbd2cSJim Jagielski }
3077*b1cdbd2cSJim Jagielski
3078*b1cdbd2cSJim Jagielski pCrsr = (SwPaM*)pCrsr->GetNext();
3079*b1cdbd2cSJim Jagielski } while ( !bRet && pCrsr != pCurCrsr );
3080*b1cdbd2cSJim Jagielski }
3081*b1cdbd2cSJim Jagielski }
3082*b1cdbd2cSJim Jagielski return bRet;
3083*b1cdbd2cSJim Jagielski }
3084*b1cdbd2cSJim Jagielski
IsSelFullPara() const3085*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsSelFullPara() const
3086*b1cdbd2cSJim Jagielski {
3087*b1cdbd2cSJim Jagielski sal_Bool bRet = sal_False;
3088*b1cdbd2cSJim Jagielski
3089*b1cdbd2cSJim Jagielski if( pCurCrsr->GetPoint()->nNode.GetIndex() ==
3090*b1cdbd2cSJim Jagielski pCurCrsr->GetMark()->nNode.GetIndex() && pCurCrsr == pCurCrsr->GetNext() )
3091*b1cdbd2cSJim Jagielski {
3092*b1cdbd2cSJim Jagielski xub_StrLen nStt = pCurCrsr->GetPoint()->nContent.GetIndex(),
3093*b1cdbd2cSJim Jagielski nEnd = pCurCrsr->GetMark()->nContent.GetIndex();
3094*b1cdbd2cSJim Jagielski if( nStt > nEnd )
3095*b1cdbd2cSJim Jagielski {
3096*b1cdbd2cSJim Jagielski xub_StrLen nTmp = nStt;
3097*b1cdbd2cSJim Jagielski nStt = nEnd;
3098*b1cdbd2cSJim Jagielski nEnd = nTmp;
3099*b1cdbd2cSJim Jagielski }
3100*b1cdbd2cSJim Jagielski const SwCntntNode* pCNd = pCurCrsr->GetCntntNode();
3101*b1cdbd2cSJim Jagielski bRet = pCNd && !nStt && nEnd == pCNd->Len();
3102*b1cdbd2cSJim Jagielski }
3103*b1cdbd2cSJim Jagielski return bRet;
3104*b1cdbd2cSJim Jagielski }
3105*b1cdbd2cSJim Jagielski
GetTextDirection(const Point * pPt) const3106*b1cdbd2cSJim Jagielski short SwCrsrShell::GetTextDirection( const Point* pPt ) const
3107*b1cdbd2cSJim Jagielski {
3108*b1cdbd2cSJim Jagielski SwPosition aPos( *pCurCrsr->GetPoint() );
3109*b1cdbd2cSJim Jagielski Point aPt( pPt ? *pPt : pCurCrsr->GetPtPos() );
3110*b1cdbd2cSJim Jagielski if( pPt )
3111*b1cdbd2cSJim Jagielski {
3112*b1cdbd2cSJim Jagielski SwCrsrMoveState aTmpState( MV_NONE );
3113*b1cdbd2cSJim Jagielski aTmpState.bSetInReadOnly = IsReadOnlyAvailable();
3114*b1cdbd2cSJim Jagielski
3115*b1cdbd2cSJim Jagielski GetLayout()->GetCrsrOfst( &aPos, aPt, &aTmpState );
3116*b1cdbd2cSJim Jagielski }
3117*b1cdbd2cSJim Jagielski
3118*b1cdbd2cSJim Jagielski return pDoc->GetTextDirection( aPos, &aPt );
3119*b1cdbd2cSJim Jagielski }
3120*b1cdbd2cSJim Jagielski
IsInVerticalText(const Point * pPt) const3121*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsInVerticalText( const Point* pPt ) const
3122*b1cdbd2cSJim Jagielski {
3123*b1cdbd2cSJim Jagielski const short nDir = GetTextDirection( pPt );
3124*b1cdbd2cSJim Jagielski return FRMDIR_VERT_TOP_RIGHT == nDir || FRMDIR_VERT_TOP_LEFT == nDir;
3125*b1cdbd2cSJim Jagielski }
3126*b1cdbd2cSJim Jagielski
IsInRightToLeftText(const Point * pPt) const3127*b1cdbd2cSJim Jagielski sal_Bool SwCrsrShell::IsInRightToLeftText( const Point* pPt ) const
3128*b1cdbd2cSJim Jagielski {
3129*b1cdbd2cSJim Jagielski const short nDir = GetTextDirection( pPt );
3130*b1cdbd2cSJim Jagielski // GetTextDirection uses FRMDIR_VERT_TOP_LEFT to indicate RTL in
3131*b1cdbd2cSJim Jagielski // vertical environment
3132*b1cdbd2cSJim Jagielski return FRMDIR_VERT_TOP_LEFT == nDir || FRMDIR_HORI_RIGHT_TOP == nDir;
3133*b1cdbd2cSJim Jagielski }
3134*b1cdbd2cSJim Jagielski
3135*b1cdbd2cSJim Jagielski //
3136*b1cdbd2cSJim Jagielski // If the current cursor position is inside a hidden range, the hidden range
3137*b1cdbd2cSJim Jagielski // is selected:
3138*b1cdbd2cSJim Jagielski //
SelectHiddenRange()3139*b1cdbd2cSJim Jagielski bool SwCrsrShell::SelectHiddenRange()
3140*b1cdbd2cSJim Jagielski {
3141*b1cdbd2cSJim Jagielski bool bRet = false;
3142*b1cdbd2cSJim Jagielski if ( !GetViewOptions()->IsShowHiddenChar() && !pCurCrsr->HasMark() )
3143*b1cdbd2cSJim Jagielski {
3144*b1cdbd2cSJim Jagielski SwPosition& rPt = *(SwPosition*)pCurCrsr->GetPoint();
3145*b1cdbd2cSJim Jagielski const SwTxtNode* pNode = rPt.nNode.GetNode().GetTxtNode();
3146*b1cdbd2cSJim Jagielski if ( pNode )
3147*b1cdbd2cSJim Jagielski {
3148*b1cdbd2cSJim Jagielski const xub_StrLen nPos = rPt.nContent.GetIndex();
3149*b1cdbd2cSJim Jagielski
3150*b1cdbd2cSJim Jagielski // check if nPos is in hidden range
3151*b1cdbd2cSJim Jagielski xub_StrLen nHiddenStart;
3152*b1cdbd2cSJim Jagielski xub_StrLen nHiddenEnd;
3153*b1cdbd2cSJim Jagielski SwScriptInfo::GetBoundsOfHiddenRange( *pNode, nPos, nHiddenStart, nHiddenEnd );
3154*b1cdbd2cSJim Jagielski if ( STRING_LEN != nHiddenStart )
3155*b1cdbd2cSJim Jagielski {
3156*b1cdbd2cSJim Jagielski // make selection:
3157*b1cdbd2cSJim Jagielski pCurCrsr->SetMark();
3158*b1cdbd2cSJim Jagielski pCurCrsr->GetMark()->nContent = nHiddenEnd;
3159*b1cdbd2cSJim Jagielski bRet = true;
3160*b1cdbd2cSJim Jagielski }
3161*b1cdbd2cSJim Jagielski }
3162*b1cdbd2cSJim Jagielski }
3163*b1cdbd2cSJim Jagielski
3164*b1cdbd2cSJim Jagielski return bRet;
3165*b1cdbd2cSJim Jagielski }
3166*b1cdbd2cSJim Jagielski
3167*b1cdbd2cSJim Jagielski /* */
3168*b1cdbd2cSJim Jagielski
3169*b1cdbd2cSJim Jagielski // die Suchfunktionen
Find(const SearchOptions & rSearchOpt,sal_Bool bSearchInNotes,SwDocPositions eStart,SwDocPositions eEnde,sal_Bool & bCancel,FindRanges eRng,int bReplace)3170*b1cdbd2cSJim Jagielski sal_uLong SwCrsrShell::Find( const SearchOptions& rSearchOpt, sal_Bool bSearchInNotes,
3171*b1cdbd2cSJim Jagielski SwDocPositions eStart, SwDocPositions eEnde,
3172*b1cdbd2cSJim Jagielski sal_Bool& bCancel,
3173*b1cdbd2cSJim Jagielski FindRanges eRng, int bReplace )
3174*b1cdbd2cSJim Jagielski {
3175*b1cdbd2cSJim Jagielski if( pTblCrsr )
3176*b1cdbd2cSJim Jagielski GetCrsr();
3177*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
3178*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
3179*b1cdbd2cSJim Jagielski sal_uLong nRet = pCurCrsr->Find( rSearchOpt, bSearchInNotes, eStart, eEnde, bCancel, eRng, bReplace );
3180*b1cdbd2cSJim Jagielski if( nRet || bCancel )
3181*b1cdbd2cSJim Jagielski UpdateCrsr();
3182*b1cdbd2cSJim Jagielski return nRet;
3183*b1cdbd2cSJim Jagielski }
3184*b1cdbd2cSJim Jagielski
Find(const SwTxtFmtColl & rFmtColl,SwDocPositions eStart,SwDocPositions eEnde,sal_Bool & bCancel,FindRanges eRng,const SwTxtFmtColl * pReplFmt)3185*b1cdbd2cSJim Jagielski sal_uLong SwCrsrShell::Find( const SwTxtFmtColl& rFmtColl,
3186*b1cdbd2cSJim Jagielski SwDocPositions eStart, SwDocPositions eEnde,
3187*b1cdbd2cSJim Jagielski sal_Bool& bCancel,
3188*b1cdbd2cSJim Jagielski FindRanges eRng, const SwTxtFmtColl* pReplFmt )
3189*b1cdbd2cSJim Jagielski {
3190*b1cdbd2cSJim Jagielski if( pTblCrsr )
3191*b1cdbd2cSJim Jagielski GetCrsr();
3192*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
3193*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
3194*b1cdbd2cSJim Jagielski sal_uLong nRet = pCurCrsr->Find( rFmtColl, eStart, eEnde, bCancel, eRng, pReplFmt );
3195*b1cdbd2cSJim Jagielski if( nRet )
3196*b1cdbd2cSJim Jagielski UpdateCrsr();
3197*b1cdbd2cSJim Jagielski return nRet;
3198*b1cdbd2cSJim Jagielski }
3199*b1cdbd2cSJim Jagielski
Find(const SfxItemSet & rSet,sal_Bool bNoCollections,SwDocPositions eStart,SwDocPositions eEnde,sal_Bool & bCancel,FindRanges eRng,const SearchOptions * pSearchOpt,const SfxItemSet * rReplSet)3200*b1cdbd2cSJim Jagielski sal_uLong SwCrsrShell::Find( const SfxItemSet& rSet, sal_Bool bNoCollections,
3201*b1cdbd2cSJim Jagielski SwDocPositions eStart, SwDocPositions eEnde,
3202*b1cdbd2cSJim Jagielski sal_Bool& bCancel,
3203*b1cdbd2cSJim Jagielski FindRanges eRng, const SearchOptions* pSearchOpt,
3204*b1cdbd2cSJim Jagielski const SfxItemSet* rReplSet )
3205*b1cdbd2cSJim Jagielski {
3206*b1cdbd2cSJim Jagielski if( pTblCrsr )
3207*b1cdbd2cSJim Jagielski GetCrsr();
3208*b1cdbd2cSJim Jagielski delete pTblCrsr, pTblCrsr = 0;
3209*b1cdbd2cSJim Jagielski SwCallLink aLk( *this ); // Crsr-Moves ueberwachen, evt. Link callen
3210*b1cdbd2cSJim Jagielski sal_uLong nRet = pCurCrsr->Find( rSet, bNoCollections, eStart, eEnde, bCancel,
3211*b1cdbd2cSJim Jagielski eRng, pSearchOpt, rReplSet );
3212*b1cdbd2cSJim Jagielski if( nRet )
3213*b1cdbd2cSJim Jagielski UpdateCrsr();
3214*b1cdbd2cSJim Jagielski return nRet;
3215*b1cdbd2cSJim Jagielski }
3216*b1cdbd2cSJim Jagielski
SetSelection(const SwPaM & rCrsr)3217*b1cdbd2cSJim Jagielski void SwCrsrShell::SetSelection( const SwPaM& rCrsr )
3218*b1cdbd2cSJim Jagielski {
3219*b1cdbd2cSJim Jagielski StartAction();
3220*b1cdbd2cSJim Jagielski SwPaM* pCrsr = GetCrsr();
3221*b1cdbd2cSJim Jagielski *pCrsr->GetPoint() = *rCrsr.GetPoint();
3222*b1cdbd2cSJim Jagielski if(rCrsr.HasMark())
3223*b1cdbd2cSJim Jagielski {
3224*b1cdbd2cSJim Jagielski pCrsr->SetMark();
3225*b1cdbd2cSJim Jagielski *pCrsr->GetMark() = *rCrsr.GetMark();
3226*b1cdbd2cSJim Jagielski }
3227*b1cdbd2cSJim Jagielski if((SwPaM*)rCrsr.GetNext() != &rCrsr)
3228*b1cdbd2cSJim Jagielski {
3229*b1cdbd2cSJim Jagielski const SwPaM *_pStartCrsr = (SwPaM*)rCrsr.GetNext();
3230*b1cdbd2cSJim Jagielski do
3231*b1cdbd2cSJim Jagielski {
3232*b1cdbd2cSJim Jagielski SwPaM* pCurrentCrsr = CreateCrsr();
3233*b1cdbd2cSJim Jagielski *pCurrentCrsr->GetPoint() = *_pStartCrsr->GetPoint();
3234*b1cdbd2cSJim Jagielski if(_pStartCrsr->HasMark())
3235*b1cdbd2cSJim Jagielski {
3236*b1cdbd2cSJim Jagielski pCurrentCrsr->SetMark();
3237*b1cdbd2cSJim Jagielski *pCurrentCrsr->GetMark() = *_pStartCrsr->GetMark();
3238*b1cdbd2cSJim Jagielski }
3239*b1cdbd2cSJim Jagielski } while( (_pStartCrsr=(SwPaM *)_pStartCrsr->GetNext()) != &rCrsr );
3240*b1cdbd2cSJim Jagielski }
3241*b1cdbd2cSJim Jagielski EndAction();
3242*b1cdbd2cSJim Jagielski }
3243*b1cdbd2cSJim Jagielski
lcl_RemoveMark(SwPaM * pPam)3244*b1cdbd2cSJim Jagielski void lcl_RemoveMark( SwPaM* pPam )
3245*b1cdbd2cSJim Jagielski {
3246*b1cdbd2cSJim Jagielski ASSERT( pPam->HasMark(), "Don't remove pPoint!" )
3247*b1cdbd2cSJim Jagielski pPam->GetMark()->nContent.Assign( 0, 0 );
3248*b1cdbd2cSJim Jagielski pPam->GetMark()->nNode = 0;
3249*b1cdbd2cSJim Jagielski pPam->DeleteMark();
3250*b1cdbd2cSJim Jagielski }
3251*b1cdbd2cSJim Jagielski
lcl_NodeContext(const SwNode & rNode)3252*b1cdbd2cSJim Jagielski const SwStartNode* lcl_NodeContext( const SwNode& rNode )
3253*b1cdbd2cSJim Jagielski {
3254*b1cdbd2cSJim Jagielski const SwStartNode *pRet = rNode.StartOfSectionNode();
3255*b1cdbd2cSJim Jagielski while( pRet->IsSectionNode() || pRet->IsTableNode() ||
3256*b1cdbd2cSJim Jagielski pRet->GetStartNodeType() == SwTableBoxStartNode )
3257*b1cdbd2cSJim Jagielski {
3258*b1cdbd2cSJim Jagielski pRet = pRet->StartOfSectionNode();
3259*b1cdbd2cSJim Jagielski }
3260*b1cdbd2cSJim Jagielski return pRet;
3261*b1cdbd2cSJim Jagielski }
3262*b1cdbd2cSJim Jagielski
3263*b1cdbd2cSJim Jagielski /**
3264*b1cdbd2cSJim Jagielski Checks if a position is valid. To be valid the position's node must
3265*b1cdbd2cSJim Jagielski be a content node and the content must not be unregistered.
3266*b1cdbd2cSJim Jagielski
3267*b1cdbd2cSJim Jagielski @param aPos the position to check.
3268*b1cdbd2cSJim Jagielski */
lcl_PosOk(const SwPosition & aPos)3269*b1cdbd2cSJim Jagielski bool lcl_PosOk(const SwPosition & aPos)
3270*b1cdbd2cSJim Jagielski {
3271*b1cdbd2cSJim Jagielski return NULL != aPos.nNode.GetNode().GetCntntNode() &&
3272*b1cdbd2cSJim Jagielski SwIndexReg::pEmptyIndexArray != aPos.nContent.GetIdxReg();
3273*b1cdbd2cSJim Jagielski }
3274*b1cdbd2cSJim Jagielski
3275*b1cdbd2cSJim Jagielski /**
3276*b1cdbd2cSJim Jagielski Checks if a PaM is valid. For a PaM to be valid its point must be
3277*b1cdbd2cSJim Jagielski valid. Additionaly if the PaM has a mark this has to be valid, too.
3278*b1cdbd2cSJim Jagielski
3279*b1cdbd2cSJim Jagielski @param aPam the PaM to check
3280*b1cdbd2cSJim Jagielski */
lcl_CrsrOk(SwPaM & aPam)3281*b1cdbd2cSJim Jagielski static bool lcl_CrsrOk(SwPaM & aPam)
3282*b1cdbd2cSJim Jagielski {
3283*b1cdbd2cSJim Jagielski return lcl_PosOk(*aPam.GetPoint()) && (! aPam.HasMark()
3284*b1cdbd2cSJim Jagielski || lcl_PosOk(*aPam.GetMark()));
3285*b1cdbd2cSJim Jagielski }
3286*b1cdbd2cSJim Jagielski
ClearUpCrsrs()3287*b1cdbd2cSJim Jagielski void SwCrsrShell::ClearUpCrsrs()
3288*b1cdbd2cSJim Jagielski {
3289*b1cdbd2cSJim Jagielski // start of the ring
3290*b1cdbd2cSJim Jagielski SwPaM * pStartCrsr = GetCrsr();
3291*b1cdbd2cSJim Jagielski // start loop with second entry of the ring
3292*b1cdbd2cSJim Jagielski SwPaM * pCrsr = (SwPaM *) pStartCrsr->GetNext();
3293*b1cdbd2cSJim Jagielski SwPaM * pTmpCrsr;
3294*b1cdbd2cSJim Jagielski bool bChanged = false;
3295*b1cdbd2cSJim Jagielski
3296*b1cdbd2cSJim Jagielski /*
3297*b1cdbd2cSJim Jagielski For all entries in the ring except the start entry delete the
3298*b1cdbd2cSJim Jagielski entry if it is invalid.
3299*b1cdbd2cSJim Jagielski */
3300*b1cdbd2cSJim Jagielski while (pCrsr != pStartCrsr)
3301*b1cdbd2cSJim Jagielski {
3302*b1cdbd2cSJim Jagielski pTmpCrsr = (SwPaM *) pCrsr->GetNext();
3303*b1cdbd2cSJim Jagielski
3304*b1cdbd2cSJim Jagielski if ( ! lcl_CrsrOk(*pCrsr))
3305*b1cdbd2cSJim Jagielski {
3306*b1cdbd2cSJim Jagielski delete pCrsr;
3307*b1cdbd2cSJim Jagielski
3308*b1cdbd2cSJim Jagielski bChanged = true;
3309*b1cdbd2cSJim Jagielski }
3310*b1cdbd2cSJim Jagielski
3311*b1cdbd2cSJim Jagielski pCrsr = pTmpCrsr;
3312*b1cdbd2cSJim Jagielski }
3313*b1cdbd2cSJim Jagielski
3314*b1cdbd2cSJim Jagielski if( pStartCrsr->HasMark() && !lcl_PosOk( *pStartCrsr->GetMark() ) )
3315*b1cdbd2cSJim Jagielski {
3316*b1cdbd2cSJim Jagielski lcl_RemoveMark( pStartCrsr );
3317*b1cdbd2cSJim Jagielski bChanged = true;
3318*b1cdbd2cSJim Jagielski }
3319*b1cdbd2cSJim Jagielski if( !lcl_PosOk( *pStartCrsr->GetPoint() ) )
3320*b1cdbd2cSJim Jagielski {
3321*b1cdbd2cSJim Jagielski SwNodes & aNodes = GetDoc()->GetNodes();
3322*b1cdbd2cSJim Jagielski const SwNode* pStart = lcl_NodeContext( pStartCrsr->GetPoint()->nNode.GetNode() );
3323*b1cdbd2cSJim Jagielski SwNodeIndex aIdx( pStartCrsr->GetPoint()->nNode );
3324*b1cdbd2cSJim Jagielski SwNode * pNode = aNodes.GoPrevious(&aIdx);
3325*b1cdbd2cSJim Jagielski if( pNode == NULL || lcl_NodeContext( *pNode ) != pStart )
3326*b1cdbd2cSJim Jagielski aNodes.GoNext( &aIdx );
3327*b1cdbd2cSJim Jagielski if( pNode == NULL || lcl_NodeContext( *pNode ) != pStart )
3328*b1cdbd2cSJim Jagielski {
3329*b1cdbd2cSJim Jagielski /*
3330*b1cdbd2cSJim Jagielski If the start entry of the ring is invalid replace it with a
3331*b1cdbd2cSJim Jagielski cursor pointing to the beginning of the first content node in
3332*b1cdbd2cSJim Jagielski the document.
3333*b1cdbd2cSJim Jagielski */
3334*b1cdbd2cSJim Jagielski aIdx = (*(aNodes.GetEndOfContent().StartOfSectionNode()));
3335*b1cdbd2cSJim Jagielski pNode = aNodes.GoNext( &aIdx );
3336*b1cdbd2cSJim Jagielski }
3337*b1cdbd2cSJim Jagielski bool bFound = (pNode != NULL);
3338*b1cdbd2cSJim Jagielski
3339*b1cdbd2cSJim Jagielski ASSERT(bFound, "no content node found");
3340*b1cdbd2cSJim Jagielski
3341*b1cdbd2cSJim Jagielski if (bFound)
3342*b1cdbd2cSJim Jagielski {
3343*b1cdbd2cSJim Jagielski SwPaM aTmpPam(*pNode);
3344*b1cdbd2cSJim Jagielski *pStartCrsr = aTmpPam;
3345*b1cdbd2cSJim Jagielski }
3346*b1cdbd2cSJim Jagielski
3347*b1cdbd2cSJim Jagielski bChanged = true;
3348*b1cdbd2cSJim Jagielski }
3349*b1cdbd2cSJim Jagielski
3350*b1cdbd2cSJim Jagielski /*
3351*b1cdbd2cSJim Jagielski If at least one of the cursors in the ring have been deleted or
3352*b1cdbd2cSJim Jagielski replaced, remove the table cursor.
3353*b1cdbd2cSJim Jagielski */
3354*b1cdbd2cSJim Jagielski if (pTblCrsr != NULL && bChanged)
3355*b1cdbd2cSJim Jagielski TblCrsrToCursor();
3356*b1cdbd2cSJim Jagielski }
3357*b1cdbd2cSJim Jagielski
3358*b1cdbd2cSJim Jagielski // #111827#
GetCrsrDescr() const3359*b1cdbd2cSJim Jagielski String SwCrsrShell::GetCrsrDescr() const
3360*b1cdbd2cSJim Jagielski {
3361*b1cdbd2cSJim Jagielski String aResult;
3362*b1cdbd2cSJim Jagielski
3363*b1cdbd2cSJim Jagielski if (IsMultiSelection())
3364*b1cdbd2cSJim Jagielski aResult += String(SW_RES(STR_MULTISEL));
3365*b1cdbd2cSJim Jagielski else
3366*b1cdbd2cSJim Jagielski aResult = GetDoc()->GetPaMDescr(*GetCrsr());
3367*b1cdbd2cSJim Jagielski
3368*b1cdbd2cSJim Jagielski return aResult;
3369*b1cdbd2cSJim Jagielski }
3370*b1cdbd2cSJim Jagielski
3371*b1cdbd2cSJim Jagielski // SMARTTAGS
3372*b1cdbd2cSJim Jagielski
lcl_FillRecognizerData(uno::Sequence<rtl::OUString> & rSmartTagTypes,uno::Sequence<uno::Reference<container::XStringKeyMap>> & rStringKeyMaps,const SwWrongList & rSmartTagList,xub_StrLen nCurrent)3373*b1cdbd2cSJim Jagielski void lcl_FillRecognizerData( uno::Sequence< rtl::OUString >& rSmartTagTypes,
3374*b1cdbd2cSJim Jagielski uno::Sequence< uno::Reference< container::XStringKeyMap > >& rStringKeyMaps,
3375*b1cdbd2cSJim Jagielski const SwWrongList& rSmartTagList, xub_StrLen nCurrent )
3376*b1cdbd2cSJim Jagielski {
3377*b1cdbd2cSJim Jagielski // Insert smart tag information
3378*b1cdbd2cSJim Jagielski std::vector< rtl::OUString > aSmartTagTypes;
3379*b1cdbd2cSJim Jagielski std::vector< uno::Reference< container::XStringKeyMap > > aStringKeyMaps;
3380*b1cdbd2cSJim Jagielski
3381*b1cdbd2cSJim Jagielski for ( sal_uInt16 i = 0; i < rSmartTagList.Count(); ++i )
3382*b1cdbd2cSJim Jagielski {
3383*b1cdbd2cSJim Jagielski const xub_StrLen nSTPos = rSmartTagList.Pos( i );
3384*b1cdbd2cSJim Jagielski const xub_StrLen nSTLen = rSmartTagList.Len( i );
3385*b1cdbd2cSJim Jagielski
3386*b1cdbd2cSJim Jagielski if ( nSTPos <= nCurrent && nCurrent < nSTPos + nSTLen )
3387*b1cdbd2cSJim Jagielski {
3388*b1cdbd2cSJim Jagielski const SwWrongArea* pArea = rSmartTagList.GetElement( i );
3389*b1cdbd2cSJim Jagielski if ( pArea )
3390*b1cdbd2cSJim Jagielski {
3391*b1cdbd2cSJim Jagielski aSmartTagTypes.push_back( pArea->maType );
3392*b1cdbd2cSJim Jagielski aStringKeyMaps.push_back( pArea->mxPropertyBag );
3393*b1cdbd2cSJim Jagielski }
3394*b1cdbd2cSJim Jagielski }
3395*b1cdbd2cSJim Jagielski }
3396*b1cdbd2cSJim Jagielski
3397*b1cdbd2cSJim Jagielski if ( aSmartTagTypes.size() )
3398*b1cdbd2cSJim Jagielski {
3399*b1cdbd2cSJim Jagielski rSmartTagTypes.realloc( aSmartTagTypes.size() );
3400*b1cdbd2cSJim Jagielski rStringKeyMaps.realloc( aSmartTagTypes.size() );
3401*b1cdbd2cSJim Jagielski
3402*b1cdbd2cSJim Jagielski std::vector< rtl::OUString >::const_iterator aTypesIter = aSmartTagTypes.begin();
3403*b1cdbd2cSJim Jagielski sal_uInt16 i = 0;
3404*b1cdbd2cSJim Jagielski for ( aTypesIter = aSmartTagTypes.begin(); aTypesIter != aSmartTagTypes.end(); ++aTypesIter )
3405*b1cdbd2cSJim Jagielski rSmartTagTypes[i++] = *aTypesIter;
3406*b1cdbd2cSJim Jagielski
3407*b1cdbd2cSJim Jagielski std::vector< uno::Reference< container::XStringKeyMap > >::const_iterator aMapsIter = aStringKeyMaps.begin();
3408*b1cdbd2cSJim Jagielski i = 0;
3409*b1cdbd2cSJim Jagielski for ( aMapsIter = aStringKeyMaps.begin(); aMapsIter != aStringKeyMaps.end(); ++aMapsIter )
3410*b1cdbd2cSJim Jagielski rStringKeyMaps[i++] = *aMapsIter;
3411*b1cdbd2cSJim Jagielski }
3412*b1cdbd2cSJim Jagielski }
3413*b1cdbd2cSJim Jagielski
lcl_FillTextRange(uno::Reference<text::XTextRange> & rRange,SwTxtNode & rNode,xub_StrLen nBegin,xub_StrLen nLen)3414*b1cdbd2cSJim Jagielski void lcl_FillTextRange( uno::Reference<text::XTextRange>& rRange,
3415*b1cdbd2cSJim Jagielski SwTxtNode& rNode, xub_StrLen nBegin, xub_StrLen nLen )
3416*b1cdbd2cSJim Jagielski {
3417*b1cdbd2cSJim Jagielski // create SwPosition for nStartIndex
3418*b1cdbd2cSJim Jagielski SwIndex aIndex( &rNode, nBegin );
3419*b1cdbd2cSJim Jagielski SwPosition aStartPos( rNode, aIndex );
3420*b1cdbd2cSJim Jagielski
3421*b1cdbd2cSJim Jagielski // create SwPosition for nEndIndex
3422*b1cdbd2cSJim Jagielski SwPosition aEndPos( aStartPos );
3423*b1cdbd2cSJim Jagielski aEndPos.nContent = nBegin + nLen;
3424*b1cdbd2cSJim Jagielski
3425*b1cdbd2cSJim Jagielski const uno::Reference<text::XTextRange> xRange =
3426*b1cdbd2cSJim Jagielski SwXTextRange::CreateXTextRange(*rNode.GetDoc(), aStartPos, &aEndPos);
3427*b1cdbd2cSJim Jagielski
3428*b1cdbd2cSJim Jagielski rRange = xRange;
3429*b1cdbd2cSJim Jagielski }
3430*b1cdbd2cSJim Jagielski
GetSmartTagTerm(uno::Sequence<rtl::OUString> & rSmartTagTypes,uno::Sequence<uno::Reference<container::XStringKeyMap>> & rStringKeyMaps,uno::Reference<text::XTextRange> & rRange) const3431*b1cdbd2cSJim Jagielski void SwCrsrShell::GetSmartTagTerm( uno::Sequence< rtl::OUString >& rSmartTagTypes,
3432*b1cdbd2cSJim Jagielski uno::Sequence< uno::Reference< container::XStringKeyMap > >& rStringKeyMaps,
3433*b1cdbd2cSJim Jagielski uno::Reference< text::XTextRange>& rRange ) const
3434*b1cdbd2cSJim Jagielski {
3435*b1cdbd2cSJim Jagielski if ( !SwSmartTagMgr::Get().IsSmartTagsEnabled() )
3436*b1cdbd2cSJim Jagielski return;
3437*b1cdbd2cSJim Jagielski
3438*b1cdbd2cSJim Jagielski SwPaM* pCrsr = GetCrsr();
3439*b1cdbd2cSJim Jagielski SwPosition aPos( *pCrsr->GetPoint() );
3440*b1cdbd2cSJim Jagielski SwTxtNode *pNode = aPos.nNode.GetNode().GetTxtNode();
3441*b1cdbd2cSJim Jagielski if ( pNode && !pNode->IsInProtectSect() )
3442*b1cdbd2cSJim Jagielski {
3443*b1cdbd2cSJim Jagielski const SwWrongList *pSmartTagList = pNode->GetSmartTags();
3444*b1cdbd2cSJim Jagielski if ( pSmartTagList )
3445*b1cdbd2cSJim Jagielski {
3446*b1cdbd2cSJim Jagielski xub_StrLen nCurrent = aPos.nContent.GetIndex();
3447*b1cdbd2cSJim Jagielski xub_StrLen nBegin = nCurrent;
3448*b1cdbd2cSJim Jagielski xub_StrLen nLen = 1;
3449*b1cdbd2cSJim Jagielski
3450*b1cdbd2cSJim Jagielski if( pSmartTagList->InWrongWord( nBegin, nLen ) && !pNode->IsSymbol(nBegin) )
3451*b1cdbd2cSJim Jagielski {
3452*b1cdbd2cSJim Jagielski const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin );
3453*b1cdbd2cSJim Jagielski const SwWrongList* pSubList = pSmartTagList->SubList( nIndex );
3454*b1cdbd2cSJim Jagielski if ( pSubList )
3455*b1cdbd2cSJim Jagielski {
3456*b1cdbd2cSJim Jagielski pSmartTagList = pSubList;
3457*b1cdbd2cSJim Jagielski nCurrent = 0;
3458*b1cdbd2cSJim Jagielski }
3459*b1cdbd2cSJim Jagielski
3460*b1cdbd2cSJim Jagielski lcl_FillRecognizerData( rSmartTagTypes, rStringKeyMaps, *pSmartTagList, nCurrent );
3461*b1cdbd2cSJim Jagielski lcl_FillTextRange( rRange, *pNode, nBegin, nLen );
3462*b1cdbd2cSJim Jagielski }
3463*b1cdbd2cSJim Jagielski }
3464*b1cdbd2cSJim Jagielski }
3465*b1cdbd2cSJim Jagielski }
3466*b1cdbd2cSJim Jagielski
3467*b1cdbd2cSJim Jagielski // see also SwEditShell::GetCorrection( const Point* pPt, SwRect& rSelectRect )
GetSmartTagTerm(const Point & rPt,SwRect & rSelectRect,uno::Sequence<rtl::OUString> & rSmartTagTypes,uno::Sequence<uno::Reference<container::XStringKeyMap>> & rStringKeyMaps,uno::Reference<text::XTextRange> & rRange)3468*b1cdbd2cSJim Jagielski void SwCrsrShell::GetSmartTagTerm( const Point& rPt, SwRect& rSelectRect,
3469*b1cdbd2cSJim Jagielski uno::Sequence< rtl::OUString >& rSmartTagTypes,
3470*b1cdbd2cSJim Jagielski uno::Sequence< uno::Reference< container::XStringKeyMap > >& rStringKeyMaps,
3471*b1cdbd2cSJim Jagielski uno::Reference<text::XTextRange>& rRange )
3472*b1cdbd2cSJim Jagielski {
3473*b1cdbd2cSJim Jagielski if ( !SwSmartTagMgr::Get().IsSmartTagsEnabled() )
3474*b1cdbd2cSJim Jagielski return;
3475*b1cdbd2cSJim Jagielski
3476*b1cdbd2cSJim Jagielski SwPaM* pCrsr = GetCrsr();
3477*b1cdbd2cSJim Jagielski SwPosition aPos( *pCrsr->GetPoint() );
3478*b1cdbd2cSJim Jagielski Point aPt( rPt );
3479*b1cdbd2cSJim Jagielski SwCrsrMoveState eTmpState( MV_SETONLYTEXT );
3480*b1cdbd2cSJim Jagielski SwSpecialPos aSpecialPos;
3481*b1cdbd2cSJim Jagielski eTmpState.pSpecialPos = &aSpecialPos;
3482*b1cdbd2cSJim Jagielski SwTxtNode *pNode;
3483*b1cdbd2cSJim Jagielski const SwWrongList *pSmartTagList;
3484*b1cdbd2cSJim Jagielski
3485*b1cdbd2cSJim Jagielski if( GetLayout()->GetCrsrOfst( &aPos, aPt, &eTmpState ) &&
3486*b1cdbd2cSJim Jagielski 0 != (pNode = aPos.nNode.GetNode().GetTxtNode()) &&
3487*b1cdbd2cSJim Jagielski 0 != (pSmartTagList = pNode->GetSmartTags()) &&
3488*b1cdbd2cSJim Jagielski !pNode->IsInProtectSect() )
3489*b1cdbd2cSJim Jagielski {
3490*b1cdbd2cSJim Jagielski xub_StrLen nCurrent = aPos.nContent.GetIndex();
3491*b1cdbd2cSJim Jagielski xub_StrLen nBegin = nCurrent;
3492*b1cdbd2cSJim Jagielski xub_StrLen nLen = 1;
3493*b1cdbd2cSJim Jagielski
3494*b1cdbd2cSJim Jagielski if( pSmartTagList->InWrongWord( nBegin, nLen ) && !pNode->IsSymbol(nBegin) )
3495*b1cdbd2cSJim Jagielski {
3496*b1cdbd2cSJim Jagielski const sal_uInt16 nIndex = pSmartTagList->GetWrongPos( nBegin );
3497*b1cdbd2cSJim Jagielski const SwWrongList* pSubList = pSmartTagList->SubList( nIndex );
3498*b1cdbd2cSJim Jagielski if ( pSubList )
3499*b1cdbd2cSJim Jagielski {
3500*b1cdbd2cSJim Jagielski pSmartTagList = pSubList;
3501*b1cdbd2cSJim Jagielski nCurrent = eTmpState.pSpecialPos->nCharOfst;
3502*b1cdbd2cSJim Jagielski }
3503*b1cdbd2cSJim Jagielski
3504*b1cdbd2cSJim Jagielski lcl_FillRecognizerData( rSmartTagTypes, rStringKeyMaps, *pSmartTagList, nCurrent );
3505*b1cdbd2cSJim Jagielski lcl_FillTextRange( rRange, *pNode, nBegin, nLen );
3506*b1cdbd2cSJim Jagielski
3507*b1cdbd2cSJim Jagielski // get smarttag word
3508*b1cdbd2cSJim Jagielski String aText( pNode->GetTxt().Copy( nBegin, nLen ) );
3509*b1cdbd2cSJim Jagielski
3510*b1cdbd2cSJim Jagielski //save the start and end positons of the line and the starting point
3511*b1cdbd2cSJim Jagielski Push();
3512*b1cdbd2cSJim Jagielski LeftMargin();
3513*b1cdbd2cSJim Jagielski xub_StrLen nLineStart = GetCrsr()->GetPoint()->nContent.GetIndex();
3514*b1cdbd2cSJim Jagielski RightMargin();
3515*b1cdbd2cSJim Jagielski xub_StrLen nLineEnd = GetCrsr()->GetPoint()->nContent.GetIndex();
3516*b1cdbd2cSJim Jagielski Pop(sal_False);
3517*b1cdbd2cSJim Jagielski
3518*b1cdbd2cSJim Jagielski // make sure the selection build later from the
3519*b1cdbd2cSJim Jagielski // data below does not include footnotes and other
3520*b1cdbd2cSJim Jagielski // "in word" character to the left and right in order
3521*b1cdbd2cSJim Jagielski // to preserve those. Therefore count those "in words"
3522*b1cdbd2cSJim Jagielski // in order to modify the selection accordingly.
3523*b1cdbd2cSJim Jagielski const sal_Unicode* pChar = aText.GetBuffer();
3524*b1cdbd2cSJim Jagielski xub_StrLen nLeft = 0;
3525*b1cdbd2cSJim Jagielski while (pChar && *pChar++ == CH_TXTATR_INWORD)
3526*b1cdbd2cSJim Jagielski ++nLeft;
3527*b1cdbd2cSJim Jagielski pChar = aText.Len() ? aText.GetBuffer() + aText.Len() - 1 : 0;
3528*b1cdbd2cSJim Jagielski xub_StrLen nRight = 0;
3529*b1cdbd2cSJim Jagielski while (pChar && *pChar-- == CH_TXTATR_INWORD)
3530*b1cdbd2cSJim Jagielski ++nRight;
3531*b1cdbd2cSJim Jagielski
3532*b1cdbd2cSJim Jagielski aPos.nContent = nBegin + nLeft;
3533*b1cdbd2cSJim Jagielski pCrsr = GetCrsr();
3534*b1cdbd2cSJim Jagielski *pCrsr->GetPoint() = aPos;
3535*b1cdbd2cSJim Jagielski pCrsr->SetMark();
3536*b1cdbd2cSJim Jagielski ExtendSelection( sal_True, nLen - nLeft - nRight );
3537*b1cdbd2cSJim Jagielski //no determine the rectangle in the current line
3538*b1cdbd2cSJim Jagielski xub_StrLen nWordStart = (nBegin + nLeft) < nLineStart ? nLineStart : nBegin + nLeft;
3539*b1cdbd2cSJim Jagielski //take one less than the line end - otherwise the next line would be calculated
3540*b1cdbd2cSJim Jagielski xub_StrLen nWordEnd = (nBegin + nLen - nLeft - nRight) > nLineEnd ? nLineEnd - 1: (nBegin + nLen - nLeft - nRight);
3541*b1cdbd2cSJim Jagielski Push();
3542*b1cdbd2cSJim Jagielski pCrsr->DeleteMark();
3543*b1cdbd2cSJim Jagielski SwIndex& rContent = GetCrsr()->GetPoint()->nContent;
3544*b1cdbd2cSJim Jagielski rContent = nWordStart;
3545*b1cdbd2cSJim Jagielski SwRect aStartRect;
3546*b1cdbd2cSJim Jagielski SwCrsrMoveState aState;
3547*b1cdbd2cSJim Jagielski aState.bRealWidth = sal_True;
3548*b1cdbd2cSJim Jagielski SwCntntNode* pCntntNode = pCrsr->GetCntntNode();
3549*b1cdbd2cSJim Jagielski SwCntntFrm *pCntntFrame = pCntntNode->getLayoutFrm( GetLayout(), &rPt, pCrsr->GetPoint(), sal_False);
3550*b1cdbd2cSJim Jagielski
3551*b1cdbd2cSJim Jagielski pCntntFrame->GetCharRect( aStartRect, *pCrsr->GetPoint(), &aState );
3552*b1cdbd2cSJim Jagielski rContent = nWordEnd;
3553*b1cdbd2cSJim Jagielski SwRect aEndRect;
3554*b1cdbd2cSJim Jagielski pCntntFrame->GetCharRect( aEndRect, *pCrsr->GetPoint(),&aState );
3555*b1cdbd2cSJim Jagielski rSelectRect = aStartRect.Union( aEndRect );
3556*b1cdbd2cSJim Jagielski Pop(sal_False);
3557*b1cdbd2cSJim Jagielski }
3558*b1cdbd2cSJim Jagielski }
3559*b1cdbd2cSJim Jagielski }
3560*b1cdbd2cSJim Jagielski
3561