xref: /trunk/main/sw/source/core/crsr/trvltbl.cxx (revision 86e1cf34)
1 /**************************************************************
2  *
3  * Licensed to the Apache Software Foundation (ASF) under one
4  * or more contributor license agreements.  See the NOTICE file
5  * distributed with this work for additional information
6  * regarding copyright ownership.  The ASF licenses this file
7  * to you under the Apache License, Version 2.0 (the
8  * "License"); you may not use this file except in compliance
9  * with the License.  You may obtain a copy of the License at
10  *
11  *   http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing,
14  * software distributed under the License is distributed on an
15  * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
16  * KIND, either express or implied.  See the License for the
17  * specific language governing permissions and limitations
18  * under the License.
19  *
20  *************************************************************/
21 
22 
23 
24 // MARKER(update_precomp.py): autogen include statement, do not remove
25 #include "precompiled_sw.hxx"
26 #include <hintids.hxx>
27 
28 #include <vcl/svapp.hxx>
29 #include <editeng/protitem.hxx>
30 #include <crsrsh.hxx>
31 #include <doc.hxx>
32 #include <cntfrm.hxx>
33 #include <editsh.hxx>		//EndAllAction gibts nur an der EditShell
34 #include <pam.hxx>
35 #include <swtable.hxx>
36 #include <docary.hxx>
37 #include <frmatr.hxx>
38 #include <frmfmt.hxx>
39 #include <viscrs.hxx>
40 #include <callnk.hxx>
41 #include <tabfrm.hxx>
42 #include <ndtxt.hxx>
43 #include <shellres.hxx>
44 #include <cellatr.hxx>
45 #include <cellfrm.hxx>
46 #include <rowfrm.hxx>
47 
48 
49 // setze Crsr in die naechsten/vorherigen Celle
GoNextCell(sal_Bool bAppendLine)50 sal_Bool SwCrsrShell::GoNextCell( sal_Bool bAppendLine )
51 {
52 	sal_Bool bRet = sal_False;
53     const SwTableNode* pTblNd = 0;
54 
55 	if( IsTableMode() || 0 != ( pTblNd = IsCrsrInTbl() ))
56 	{
57 		SwCursor* pCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
58 		SwCallLink aLk( *this );		// Crsr-Moves ueberwachen,
59 		bRet = sal_True;
60 
61         // Check if we have to move the cursor to a covered cell before
62         // proceeding:
63         const SwNode* pTableBoxStartNode = pCrsr->GetNode()->FindTableBoxStartNode();
64         const SwTableBox* pTableBox = 0;
65 
66         if ( pCrsr->GetCrsrRowSpanOffset() )
67         {
68             pTableBox = pTableBoxStartNode->GetTblBox();
69             if ( pTableBox->getRowSpan() > 1 )
70             {
71                 if ( !pTblNd )
72                     pTblNd = IsCrsrInTbl();
73                 pTableBox = & pTableBox->FindEndOfRowSpan( pTblNd->GetTable(),
74                                                            (sal_uInt16)(pTableBox->getRowSpan() + pCrsr->GetCrsrRowSpanOffset() ) );
75                 pTableBoxStartNode = pTableBox->GetSttNd();
76             }
77         }
78 
79         SwNodeIndex  aCellStt( *pTableBoxStartNode->EndOfSectionNode(), 1 );
80 
81         // folgt nach dem EndNode der Cell ein weiterer StartNode, dann
82 		// gibt es auch eine naechste Celle
83 
84         if( !aCellStt.GetNode().IsStartNode() )
85 		{
86 			if( pCrsr->HasMark() ||	!bAppendLine )
87 				bRet = sal_False;
88 			else
89 			{
90 				// auf besonderen Wunsch: keine Line mehr vorhanden, dann
91 				// mache doch eine neue:
92                 if ( !pTableBox )
93                     pTableBox = pTblNd->GetTable().GetTblBox(
94 								    pCrsr->GetPoint()->nNode.GetNode().
95 								    StartOfSectionIndex() );
96 
97                 ASSERT( pTableBox, "Box steht nicht in dieser Tabelle" );
98 				SwSelBoxes aBoxes;
99 
100 				//Das Dokument veraendert sich evtl. ohne Action wuerden die Sichten
101 				//nichts mitbekommen.
102 				((SwEditShell*)this)->StartAllAction();
103 				bRet = pDoc->InsertRow( pTblNd->GetTable().
104 									SelLineFromBox( pTableBox, aBoxes, sal_False ));
105 				((SwEditShell*)this)->EndAllAction();
106 			}
107 		}
108 		if( bRet && 0 != ( bRet = pCrsr->GoNextCell() ))
109 			UpdateCrsr();				  // und den akt. Updaten
110 	}
111 	return bRet;
112 }
113 
114 
GoPrevCell()115 sal_Bool SwCrsrShell::GoPrevCell()
116 {
117 	sal_Bool bRet = sal_False;
118 	const SwTableNode* pTblNd;
119 	if( IsTableMode() || 0 != ( pTblNd = IsCrsrInTbl() ))
120 	{
121 		SwCursor* pCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
122 		SwCallLink aLk( *this );		// Crsr-Moves ueberwachen,
123 		bRet = pCrsr->GoPrevCell();
124 		if( bRet )
125 			UpdateCrsr();				  // und den akt. Updaten
126 	}
127 	return bRet;
128 }
129 
lcl_FindMostUpperCellFrm(const SwFrm * pFrm)130 const SwFrm* lcl_FindMostUpperCellFrm( const SwFrm* pFrm )
131 {
132     while ( pFrm &&
133             ( !pFrm->IsCellFrm() ||
134               !pFrm->GetUpper()->GetUpper()->IsTabFrm() ||
135                pFrm->GetUpper()->GetUpper()->GetUpper()->IsInTab() ) )
136     {
137         pFrm = pFrm->GetUpper();
138     }
139     return pFrm;
140 }
141 
_SelTblRowOrCol(bool bRow,bool bRowSimple)142 sal_Bool SwCrsrShell::_SelTblRowOrCol( bool bRow, bool bRowSimple )
143 {
144 	// pruefe ob vom aktuellen Crsr der SPoint/Mark in einer Tabelle stehen
145 	SwFrm *pFrm = GetCurrFrm();
146 	if( !pFrm->IsInTab() )
147 		return sal_False;
148 
149     const SwTabFrm* pTabFrm = pFrm->FindTabFrm();
150     const SwTabFrm* pMasterTabFrm = pTabFrm->IsFollow() ? pTabFrm->FindMaster( true ) : pTabFrm;
151     const SwTable* pTable = pTabFrm->GetTable();
152 
153 	SET_CURR_SHELL( this );
154 
155     const SwTableBox* pStt = 0;
156     const SwTableBox* pEnd = 0;
157 
158     // lasse ueber das Layout die Boxen suchen
159     SwSelBoxes aBoxes;
160     SwTblSearchType eType = bRow ? nsSwTblSearchType::TBLSEARCH_ROW : nsSwTblSearchType::TBLSEARCH_COL;
161     const bool bCheckProtected = !IsReadOnlyAvailable();
162 
163     if( bCheckProtected )
164         eType = (SwTblSearchType)(eType | nsSwTblSearchType::TBLSEARCH_PROTECT);
165 
166     if ( !bRowSimple )
167     {
168         GetTblSel( *this, aBoxes, eType );
169 
170         if( !aBoxes.Count() )
171             return sal_False;
172 
173         pStt = aBoxes[0];
174         pEnd = aBoxes[aBoxes.Count() - 1];
175     }
176     // --> FME 2004-07-30 #i32329# Enhanced table selection
177     else if ( pTable->IsNewModel() )
178     {
179     	const SwShellCrsr *pCrsr = _GetCrsr();
180         SwTable::SearchType eSearchType = bRow ? SwTable::SEARCH_ROW : SwTable::SEARCH_COL;
181         pTable->CreateSelection( *pCrsr, aBoxes, eSearchType, bCheckProtected );
182         if( !aBoxes.Count() )
183             return sal_False;
184 
185         pStt = aBoxes[0];
186         pEnd = aBoxes[aBoxes.Count() - 1];
187     }
188     else
189     {
190     	const SwShellCrsr *pCrsr = _GetCrsr();
191 		const SwFrm* pStartFrm = pFrm;
192         const SwCntntNode *pCNd = pCrsr->GetCntntNode( sal_False );
193         const SwFrm* pEndFrm   = pCNd ? pCNd->getLayoutFrm( GetLayout(), &pCrsr->GetMkPos() ) : 0;
194 
195         if ( bRow )
196         {
197             pStartFrm = lcl_FindMostUpperCellFrm( pStartFrm );
198             pEndFrm   = lcl_FindMostUpperCellFrm( pEndFrm   );
199         }
200 
201         if ( !pStartFrm || !pEndFrm )
202             return sal_False;
203 
204         const bool bVert = pFrm->ImplFindTabFrm()->IsVertical();
205 
206         // If we select upwards it is sufficient to set pStt and pEnd
207         // to the first resp. last box of the selection obtained from
208         // GetTblSel. However, selecting downwards requires the frames
209         // located at the corners of the selection. This does not work
210         // for column selections in vertical tables:
211         const bool bSelectUp = ( bVert && !bRow ) ||
212                                 *pCrsr->GetPoint() <= *pCrsr->GetMark();
213         SwCellFrms aCells;
214         GetTblSel( static_cast<const SwCellFrm*>(pStartFrm),
215                    static_cast<const SwCellFrm*>(pEndFrm),
216                    aBoxes, bSelectUp ? 0 : &aCells, eType );
217 
218         if( !aBoxes.Count() || ( !bSelectUp && 4 != aCells.Count() ) )
219             return sal_False;
220 
221         if ( bSelectUp )
222         {
223             pStt = aBoxes[0];
224             pEnd = aBoxes[aBoxes.Count() - 1];
225         }
226         else
227         {
228             pStt = aCells[ bVert ? (bRow ? 0 : 3) : (bRow ? 2 : 1) ]->GetTabBox();  // will become point of table cursor
229             pEnd = aCells[ bVert ? (bRow ? 3 : 0) : (bRow ? 1 : 2) ]->GetTabBox();  // will become mark of table cursor
230         }
231     }
232     // <--
233 
234     // noch kein Tabellen-Cursor vorhanden, dann erzeuge einen
235 	if( !pTblCrsr )
236 	{
237 		pTblCrsr = new SwShellTableCrsr( *this, *pCurCrsr->GetPoint() );
238 		pCurCrsr->DeleteMark();
239 		pCurCrsr->SwSelPaintRects::Hide();
240 	}
241 
242     pTblCrsr->DeleteMark();
243 
244     // dann setze mal Anfang und Ende der Spalte
245     pTblCrsr->GetPoint()->nNode = *pEnd->GetSttNd();
246     pTblCrsr->Move( fnMoveForward, fnGoCntnt );
247 	pTblCrsr->SetMark();
248     pTblCrsr->GetPoint()->nNode = *pStt->GetSttNd()->EndOfSectionNode();
249     pTblCrsr->Move( fnMoveBackward, fnGoCntnt );
250 
251     // set PtPos 'close' to the reference table, otherwise we might get problems with the
252     // repeated headlines check in UpdateCrsr():
253     if ( !bRow )
254         pTblCrsr->GetPtPos() = pMasterTabFrm->IsVertical() ? pMasterTabFrm->Frm().TopRight() : pMasterTabFrm->Frm().TopLeft();
255 
256 	UpdateCrsr();				  // und den akt. Updaten
257 	return sal_True;
258 }
259 
SelTbl()260 sal_Bool SwCrsrShell::SelTbl()
261 {
262     // pruefe ob vom aktuellen Crsr der SPoint/Mark in einer Tabelle stehen
263     SwFrm *pFrm = GetCurrFrm();
264     if( !pFrm->IsInTab() )
265         return sal_False;
266 
267     const SwTabFrm *pTblFrm = pFrm->ImplFindTabFrm();
268     const SwTabFrm* pMasterTabFrm = pTblFrm->IsFollow() ? pTblFrm->FindMaster( true ) : pTblFrm;
269     const SwTableNode* pTblNd = pTblFrm->GetTable()->GetTableNode();
270 
271     SET_CURR_SHELL( this );
272 
273     if( !pTblCrsr )
274     {
275         pTblCrsr = new SwShellTableCrsr( *this, *pCurCrsr->GetPoint() );
276         pCurCrsr->DeleteMark();
277         pCurCrsr->SwSelPaintRects::Hide();
278     }
279 
280     pTblCrsr->DeleteMark();
281     pTblCrsr->GetPoint()->nNode = *pTblNd;
282     pTblCrsr->Move( fnMoveForward, fnGoCntnt );
283     pTblCrsr->SetMark();
284     // set MkPos 'close' to the master table, otherwise we might get problems with the
285     // repeated headlines check in UpdateCrsr():
286     pTblCrsr->GetMkPos() = pMasterTabFrm->IsVertical() ? pMasterTabFrm->Frm().TopRight() : pMasterTabFrm->Frm().TopLeft();
287     pTblCrsr->GetPoint()->nNode = *pTblNd->EndOfSectionNode();
288     pTblCrsr->Move( fnMoveBackward, fnGoCntnt );
289     UpdateCrsr();                 // und den akt. Updaten
290     return sal_True;
291 }
292 
293 
SelTblBox()294 sal_Bool SwCrsrShell::SelTblBox()
295 {
296     // if we're in a table, create a table cursor, and select the cell
297     // that the current cursor's point resides in
298 
299     // search for start node of our table box. If not found, exit really
300     const SwStartNode* pStartNode =
301         pCurCrsr->GetPoint()->nNode.GetNode().FindTableBoxStartNode();
302 
303 #ifdef DBG_UTIL
304     // the old code checks whether we're in a table by asking the
305     // frame. This should yield the same result as searching for the
306     // table box start node, right?
307 	SwFrm *pFrm = GetCurrFrm();
308 	DBG_ASSERT( !pFrm->IsInTab() == !(pStartNode != NULL),
309                 "Schroedinger's table: We're in a box, and also we aren't." );
310 #endif
311 
312     if( pStartNode == NULL )
313         return sal_False;
314 
315 
316 	SET_CURR_SHELL( this );
317 
318     // create a table cursor, if there isn't one already
319 	if( !pTblCrsr )
320 	{
321 		pTblCrsr = new SwShellTableCrsr( *this, *pCurCrsr->GetPoint() );
322 		pCurCrsr->DeleteMark();
323 		pCurCrsr->SwSelPaintRects::Hide();
324 	}
325 
326     // select the complete box with our shiny new pTblCrsr
327     // 1. delete mark, and move point to first content node in box
328     // 2. set mark, and move point to last content node in box
329     // 3. exchange
330 
331 	pTblCrsr->DeleteMark();
332     *(pTblCrsr->GetPoint()) = SwPosition( *pStartNode );
333     pTblCrsr->Move( fnMoveForward, fnGoNode );
334 
335     pTblCrsr->SetMark();
336     *(pTblCrsr->GetPoint()) = SwPosition( *(pStartNode->EndOfSectionNode()) );
337     pTblCrsr->Move( fnMoveBackward, fnGoNode );
338 
339     pTblCrsr->Exchange();
340 
341     // with some luck, UpdateCrsr() will now update everything that
342     // needs updateing
343 	UpdateCrsr();
344 
345 	return sal_True;
346 }
347 
348 // return the next non-protected cell inside a table
349 //      rIdx    - is on a table node
350 //  return:
351 //      true  - Idx points to content in a suitable cell
352 //      false - could not find a suitable cell
lcl_FindNextCell(SwNodeIndex & rIdx,sal_Bool bInReadOnly)353 bool lcl_FindNextCell( SwNodeIndex& rIdx, sal_Bool bInReadOnly )
354 {
355     // ueberpruefe geschuetzte Zellen
356     SwNodeIndex aTmp( rIdx, 2 );            // TableNode + StartNode
357 
358     // the resulting cell should be in that table:
359     const SwTableNode* pTblNd = rIdx.GetNode().GetTableNode();
360 
361     if ( !pTblNd )
362     {
363         ASSERT( false, "lcl_FindNextCell not celled with table start node!" )
364         return false;
365     }
366 
367     const SwNode* pTableEndNode = pTblNd->EndOfSectionNode();
368 
369     SwNodes& rNds = aTmp.GetNode().GetNodes();
370     SwCntntNode* pCNd = aTmp.GetNode().GetCntntNode();
371 
372     // no content node => go to next content node
373     if( !pCNd )
374         pCNd = rNds.GoNext( &aTmp );
375 
376     // robust
377     if ( !pCNd )
378         return false;
379 
380     SwCntntFrm* pFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout() );
381 
382     if ( 0 == pFrm || pCNd->FindTableNode() != pTblNd ||
383         (!bInReadOnly && pFrm->IsProtected() ) )
384     {
385         // we are not located inside a 'valid' cell. We have to continue searching...
386 
387         // skip behind current section. This might be the end of the table cell
388         // or behind a inner section or or or...
389         aTmp.Assign( *pCNd->EndOfSectionNode(), 1 );
390 
391         // loop to find a suitable cell...
392         for( ;; )
393         {
394             SwNode* pNd = &aTmp.GetNode();
395 
396             // we break this loop if we reached the end of the table.
397             // to make this code even more robust, we also break if we are
398             // already behind the table end node:
399             if( pNd == pTableEndNode || /*robust: */ pNd->GetIndex() > pTableEndNode->GetIndex() )
400                 return false;
401 
402             // ok, get the next content node:
403             pCNd = aTmp.GetNode().GetCntntNode();
404             if( 0 == pCNd )
405                 pCNd = rNds.GoNext( &aTmp );
406 
407             // robust:
408             if ( !pCNd )
409                 return false;
410 
411             // check if we have found a suitable table cell:
412             pFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout() );
413 
414             if ( 0 != pFrm && pCNd->FindTableNode() == pTblNd &&
415                 (bInReadOnly || !pFrm->IsProtected() ) )
416             {
417                 // finally, we have found a suitable table cell => set index and return
418                 rIdx = *pCNd;
419                 return true;
420             }
421 
422             // continue behind the current section:
423             aTmp.Assign( *pCNd->EndOfSectionNode(), +1 );
424         }
425     }
426 
427     rIdx = *pCNd;
428     return true;
429 }
430 
431 // comments see lcl_FindNextCell
lcl_FindPrevCell(SwNodeIndex & rIdx,sal_Bool bInReadOnly)432 bool lcl_FindPrevCell( SwNodeIndex& rIdx, sal_Bool bInReadOnly  )
433 {
434     SwNodeIndex aTmp( rIdx, -2 );       // TableNode + EndNode
435 
436     const SwNode* pTableEndNode = &rIdx.GetNode();
437     const SwTableNode* pTblNd = pTableEndNode->StartOfSectionNode()->GetTableNode();
438 
439     if ( !pTblNd )
440     {
441         ASSERT( false, "lcl_FindPrevCell not celled with table start node!" )
442         return false;
443     }
444 
445     SwNodes& rNds = aTmp.GetNode().GetNodes();
446 	SwCntntNode* pCNd = aTmp.GetNode().GetCntntNode();
447 
448     if( !pCNd )
449         pCNd = rNds.GoPrevious( &aTmp );
450 
451     if ( !pCNd )
452         return false;
453 
454     SwCntntFrm* pFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout() );
455 
456     if( 0 == pFrm || pCNd->FindTableNode() != pTblNd ||
457 		(!bInReadOnly && pFrm->IsProtected() ))
458 	{
459         // skip before current section
460 		aTmp.Assign( *pCNd->StartOfSectionNode(), -1 );
461         for( ;; )
462 		{
463             SwNode* pNd = &aTmp.GetNode();
464 
465             if( pNd == pTblNd || pNd->GetIndex() < pTblNd->GetIndex() )
466                 return false;
467 
468             pCNd = aTmp.GetNode().GetCntntNode();
469             if( 0 == pCNd )
470 				pCNd = rNds.GoPrevious( &aTmp );
471 
472             if ( !pCNd )
473                 return false;
474 
475             pFrm = pCNd->getLayoutFrm( pCNd->GetDoc()->GetCurrentLayout() );
476 
477             if( 0 != pFrm && pCNd->FindTableNode() == pTblNd &&
478                 (bInReadOnly || !pFrm->IsProtected() ) )
479 			{
480                 rIdx = *pCNd;
481                 return true;      // Ok, nicht geschuetzt
482 			}
483 			aTmp.Assign( *pCNd->StartOfSectionNode(), - 1 );
484 		}
485 	}
486 
487     rIdx = *pCNd;
488     return true;
489 }
490 
491 
GotoPrevTable(SwPaM & rCurCrsr,SwPosTable fnPosTbl,sal_Bool bInReadOnly)492 sal_Bool GotoPrevTable( SwPaM& rCurCrsr, SwPosTable fnPosTbl,
493 						sal_Bool bInReadOnly )
494 {
495 	SwNodeIndex aIdx( rCurCrsr.GetPoint()->nNode );
496 
497 	SwTableNode* pTblNd = aIdx.GetNode().FindTableNode();
498 	if( pTblNd )
499     {
500         // #i26532#: If we are inside a table, we may not go backward
501         // to the table start node, because we would miss any tables
502         // inside this table.
503     	SwTableNode* pInnerTblNd = 0;
504         SwNodeIndex aTmpIdx( aIdx );
505         while( aTmpIdx.GetIndex() &&
506                 0 == ( pInnerTblNd = aTmpIdx.GetNode().StartOfSectionNode()->GetTableNode()) )
507 		    aTmpIdx--;
508 
509         if( pInnerTblNd == pTblNd )
510     		aIdx.Assign( *pTblNd, - 1 );
511     }
512 
513 	do {
514 		while( aIdx.GetIndex() &&
515             0 == ( pTblNd = aIdx.GetNode().StartOfSectionNode()->GetTableNode()) )
516 			aIdx--;
517 
518 		if( pTblNd )		// gibt einen weiteren TableNode ?
519 		{
520 			if( fnPosTbl == fnMoveForward )			// an Anfang ?
521 			{
522 				aIdx = *aIdx.GetNode().StartOfSectionNode();
523                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
524 				{
525 					// Tabelle ueberspringen
526 					aIdx.Assign( *pTblNd, -1 );
527 					continue;
528 				}
529 			}
530 			else
531 			{
532 				// ueberpruefe geschuetzte Zellen
533                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
534 				{
535 					// Tabelle ueberspringen
536 					aIdx.Assign( *pTblNd, -1 );
537 					continue;
538 				}
539 			}
540 
541             SwTxtNode* pTxtNode = aIdx.GetNode().GetTxtNode();
542             if ( pTxtNode )
543             {
544                 rCurCrsr.GetPoint()->nNode = *pTxtNode;
545                 rCurCrsr.GetPoint()->nContent.Assign( pTxtNode, fnPosTbl == fnMoveBackward ?
546                                                       pTxtNode->Len() :
547                                                       0 );
548             }
549 			return sal_True;
550 		}
551 	} while( pTblNd );
552 
553 	return sal_False;
554 }
555 
556 
GotoNextTable(SwPaM & rCurCrsr,SwPosTable fnPosTbl,sal_Bool bInReadOnly)557 sal_Bool GotoNextTable( SwPaM& rCurCrsr, SwPosTable fnPosTbl,
558 						sal_Bool bInReadOnly )
559 {
560 	SwNodeIndex aIdx( rCurCrsr.GetPoint()->nNode );
561 	SwTableNode* pTblNd = aIdx.GetNode().FindTableNode();
562 
563 	if( pTblNd )
564 		aIdx.Assign( *pTblNd->EndOfSectionNode(), 1 );
565 
566 	sal_uLong nLastNd = rCurCrsr.GetDoc()->GetNodes().Count() - 1;
567 	do {
568 		while( aIdx.GetIndex() < nLastNd &&
569 				0 == ( pTblNd = aIdx.GetNode().GetTableNode()) )
570 			aIdx++;
571 		if( pTblNd )		// gibt einen weiteren TableNode ?
572 		{
573 			if( fnPosTbl == fnMoveForward )			// an Anfang ?
574 			{
575                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
576 				{
577 					// Tabelle ueberspringen
578 					aIdx.Assign( *pTblNd->EndOfSectionNode(), + 1 );
579 					continue;
580 				}
581 			}
582 			else
583 			{
584 				aIdx = *aIdx.GetNode().EndOfSectionNode();
585 				// ueberpruefe geschuetzte Zellen
586                 if( !lcl_FindNextCell( aIdx, bInReadOnly ))
587 				{
588 					// Tabelle ueberspringen
589 					aIdx.Assign( *pTblNd->EndOfSectionNode(), + 1 );
590 					continue;
591 				}
592 			}
593 
594             SwTxtNode* pTxtNode = aIdx.GetNode().GetTxtNode();
595             if ( pTxtNode )
596             {
597                 rCurCrsr.GetPoint()->nNode = *pTxtNode;
598                 rCurCrsr.GetPoint()->nContent.Assign( pTxtNode, fnPosTbl == fnMoveBackward ?
599                                                       pTxtNode->Len() :
600                                                       0 );
601             }
602 			return sal_True;
603 		}
604 	} while( pTblNd );
605 
606 	return sal_False;
607 }
608 
609 
GotoCurrTable(SwPaM & rCurCrsr,SwPosTable fnPosTbl,sal_Bool bInReadOnly)610 sal_Bool GotoCurrTable( SwPaM& rCurCrsr, SwPosTable fnPosTbl,
611 						sal_Bool bInReadOnly )
612 {
613 	SwTableNode* pTblNd = rCurCrsr.GetPoint()->nNode.GetNode().FindTableNode();
614 	if( !pTblNd )
615 		return sal_False;
616 
617     SwTxtNode* pTxtNode = 0;
618 	if( fnPosTbl == fnMoveBackward )	// ans Ende der Tabelle
619 	{
620 		SwNodeIndex aIdx( *pTblNd->EndOfSectionNode() );
621         if( !lcl_FindPrevCell( aIdx, bInReadOnly ))
622 			return sal_False;
623         pTxtNode = aIdx.GetNode().GetTxtNode();
624 	}
625 	else
626 	{
627 		SwNodeIndex aIdx( *pTblNd );
628         if( !lcl_FindNextCell( aIdx, bInReadOnly ))
629 			return sal_False;
630         pTxtNode = aIdx.GetNode().GetTxtNode();
631 	}
632 
633     if ( pTxtNode )
634     {
635         rCurCrsr.GetPoint()->nNode = *pTxtNode;
636         rCurCrsr.GetPoint()->nContent.Assign( pTxtNode, fnPosTbl == fnMoveBackward ?
637                                                         pTxtNode->Len() :
638                                                         0 );
639     }
640 
641     return sal_True;
642 }
643 
644 
MoveTable(SwWhichTable fnWhichTbl,SwPosTable fnPosTbl)645 sal_Bool SwCursor::MoveTable( SwWhichTable fnWhichTbl, SwPosTable fnPosTbl )
646 {
647 	sal_Bool bRet = sal_False;
648     SwTableCursor* pTblCrsr = dynamic_cast<SwTableCursor*>(this);
649 
650 	if( pTblCrsr || !HasMark() )	// nur wenn kein Mark oder ein TblCrsr
651 	{
652 		SwCrsrSaveState aSaveState( *this );
653 		bRet = (*fnWhichTbl)( *this, fnPosTbl, IsReadOnlyAvailable() ) &&
654                 !IsSelOvr( nsSwCursorSelOverFlags::SELOVER_CHECKNODESSECTION |
655                            nsSwCursorSelOverFlags::SELOVER_TOGGLE );
656 	}
657 	return bRet;
658 }
659 
MoveTable(SwWhichTable fnWhichTbl,SwPosTable fnPosTbl)660 sal_Bool SwCrsrShell::MoveTable( SwWhichTable fnWhichTbl, SwPosTable fnPosTbl )
661 {
662 	SwCallLink aLk( *this );		// Crsr-Moves ueberwachen, evt. Link callen
663 
664 	SwShellCrsr* pCrsr = pTblCrsr ? pTblCrsr : pCurCrsr;
665 	sal_Bool bCheckPos, bRet;
666     sal_uLong nPtNd = 0;
667     xub_StrLen nPtCnt = 0;
668 
669 	if( !pTblCrsr && pCurCrsr->HasMark() )		// wenn Mark und kein TblCrsr,
670 	{
671 		// dann auf jedenfall in den Tabellen-Modus schalten
672 		pTblCrsr = new SwShellTableCrsr( *this, *pCurCrsr->GetPoint() );
673 		pCurCrsr->DeleteMark();
674 		pCurCrsr->SwSelPaintRects::Hide();
675 		pTblCrsr->SetMark();
676 		pCrsr = pTblCrsr;
677 		bCheckPos = sal_False;
678 	}
679 	else
680 	{
681 		bCheckPos = sal_True;
682 		nPtNd = pCrsr->GetPoint()->nNode.GetIndex();
683 		nPtCnt = pCrsr->GetPoint()->nContent.GetIndex();
684 	}
685 
686 	bRet = pCrsr->MoveTable( fnWhichTbl, fnPosTbl );
687 
688 	if( bRet )
689 	{
690 		//JP 28.10.97: Bug 45028 - die "oberste" Position setzen fuer
691 		//				wiederholte Kopfzeilen
692 		pCrsr->GetPtPos() = Point();
693 
694 		UpdateCrsr(SwCrsrShell::SCROLLWIN|SwCrsrShell::CHKRANGE|SwCrsrShell::READONLY);
695 
696 		if( bCheckPos &&
697 			pCrsr->GetPoint()->nNode.GetIndex() == nPtNd &&
698 			pCrsr->GetPoint()->nContent.GetIndex() == nPtCnt )
699 			bRet = sal_False;
700 	}
701 	return bRet;
702 }
703 
704 
IsTblComplex() const705 sal_Bool SwCrsrShell::IsTblComplex() const
706 {
707 	SwFrm *pFrm = GetCurrFrm( sal_False );
708 	if ( pFrm && pFrm->IsInTab() )
709 		return pFrm->FindTabFrm()->GetTable()->IsTblComplex();
710 	return sal_False;
711 }
712 
713 
IsTblComplexForChart()714 sal_Bool SwCrsrShell::IsTblComplexForChart()
715 {
716 	sal_Bool bRet = sal_False;
717 
718     StartAction();	// IsTblComplexForChart() may trigger table formatting
719                     // we better do that inside an action
720 
721 	const SwTableNode* pTNd = pCurCrsr->GetPoint()->nNode.GetNode().FindTableNode();
722 	if( pTNd )
723 	{
724 		// wir stehen in der Tabelle, dann teste mal, ob die Tabelle oder die
725 		// Selektion ausgeglichen ist.
726 		String sSel;
727 		if( pTblCrsr )
728 			sSel = GetBoxNms();
729 		bRet = pTNd->GetTable().IsTblComplexForChart( sSel );
730 	}
731 
732 	EndAction();
733 
734 	return bRet;
735 }
736 
GetBoxNms() const737 String SwCrsrShell::GetBoxNms() const
738 {
739 	String sNm;
740 	const SwPosition* pPos;
741 	SwFrm* pFrm;
742 
743 	if( IsTableMode() )
744 	{
745         SwCntntNode *pCNd = pTblCrsr->Start()->nNode.GetNode().GetCntntNode();
746 		pFrm = pCNd ? pCNd->getLayoutFrm( GetLayout() ) : 0;
747         if( !pFrm )
748             return sNm;
749 
750 		do {
751 			pFrm = pFrm->GetUpper();
752 		} while ( pFrm && !pFrm->IsCellFrm() );
753 
754 		ASSERT( pFrm, "kein Frame zur Box" );
755 		sNm = ((SwCellFrm*)pFrm)->GetTabBox()->GetName();
756 		sNm += ':';
757 		pPos = pTblCrsr->End();
758 	}
759 	else
760 	{
761 		const SwTableNode* pTblNd = IsCrsrInTbl();
762 		if( !pTblNd )
763 			return sNm;
764 		pPos = GetCrsr()->GetPoint();
765 	}
766 
767     SwCntntNode* pCNd = pPos->nNode.GetNode().GetCntntNode();
768 	pFrm = pCNd ? pCNd->getLayoutFrm( GetLayout() ) : 0;
769 
770     if( pFrm )
771     {
772         do {
773             pFrm = pFrm->GetUpper();
774         } while ( pFrm && !pFrm->IsCellFrm() );
775 
776         if( pFrm )
777             sNm += ((SwCellFrm*)pFrm)->GetTabBox()->GetName();
778     }
779 	return sNm;
780 }
781 
782 
GotoTable(const String & rName)783 sal_Bool SwCrsrShell::GotoTable( const String& rName )
784 {
785 	SwCallLink aLk( *this );		// Crsr-Moves ueberwachen,
786 	sal_Bool bRet = !pTblCrsr && pCurCrsr->GotoTable( rName );
787 	if( bRet )
788 	{
789 		pCurCrsr->GetPtPos() = Point();
790 		UpdateCrsr( SwCrsrShell::SCROLLWIN | SwCrsrShell::CHKRANGE |
791 					SwCrsrShell::READONLY ); // und den akt. Updaten
792 	}
793 	return bRet;
794 }
795 
796 
CheckTblBoxCntnt(const SwPosition * pPos)797 sal_Bool SwCrsrShell::CheckTblBoxCntnt( const SwPosition* pPos )
798 {
799 	if( !pBoxIdx || !pBoxPtr || IsSelTblCells() || !IsAutoUpdateCells() )
800 		return sal_False;
801 
802 	// ueberpruefe, ob der Box Inhalt mit dem angegebenen Format der Box
803 	// ueber einstimmt. Wenn nicht, setze neu
804 	SwTableBox* pChkBox = 0;
805 	SwStartNode* pSttNd = 0;
806 	if( !pPos )
807 	{
808 		// gesicherte Position heraus holen.
809 		if( pBoxIdx && pBoxPtr &&
810 			0 != ( pSttNd = pBoxIdx->GetNode().GetStartNode() ) &&
811 			SwTableBoxStartNode == pSttNd->GetStartNodeType() &&
812 			pBoxPtr == pSttNd->FindTableNode()->GetTable().
813 						GetTblBox( pBoxIdx->GetIndex() ) )
814 			pChkBox = pBoxPtr;
815 	}
816 	else if( 0 != ( pSttNd = pPos->nNode.GetNode().
817 								FindSttNodeByType( SwTableBoxStartNode )) )
818 	{
819 		pChkBox = pSttNd->FindTableNode()->GetTable().GetTblBox( pSttNd->GetIndex() );
820 	}
821 
822 
823 	// Box mehr als 1 Absatz?
824 	if( pChkBox && pSttNd->GetIndex() + 2 != pSttNd->EndOfSectionIndex() )
825 		pChkBox = 0;
826 
827 	// jetzt sollten wir mal die Pointer zerstoeren, bevor eine erneute
828 	// Actionklammerung kommt.
829 	if( !pPos && !pChkBox )
830 		ClearTblBoxCntnt();
831 
832 	// liegt der Cursor nicht mehr in dem Bereich ?
833 	if( pChkBox && !pPos &&
834 		( pCurCrsr->HasMark() || pCurCrsr->GetNext() != pCurCrsr ||
835 		  pSttNd->GetIndex() + 1 == pCurCrsr->GetPoint()->nNode.GetIndex() ))
836 		pChkBox = 0;
837 
838 	//JP 12.01.99: hat sich der Inhalt der Box ueberhaupt veraendert?
839 	// Ist wichtig, wenn z.B. Undo nicht den richtigen Inhalt wieder
840 	// herstellen konnte.
841 	if( pChkBox )
842 	{
843 		const SwTxtNode* pNd = GetDoc()->GetNodes()[
844 									pSttNd->GetIndex() + 1 ]->GetTxtNode();
845 		if( !pNd ||
846 			( pNd->GetTxt() == ViewShell::GetShellRes()->aCalc_Error &&
847 			  SFX_ITEM_SET == pChkBox->GetFrmFmt()->
848 							GetItemState( RES_BOXATR_FORMULA )) )
849 			pChkBox = 0;
850 	}
851 
852 	if( pChkBox )
853 	{
854 		// jetzt sollten wir mal die Pointer zerstoeren, bevor ein weiterer
855 		// aufruf kommt.
856 		ClearTblBoxCntnt();
857 		StartAction();
858 		GetDoc()->ChkBoxNumFmt( *pChkBox, sal_True );
859 		EndAction();
860 	}
861 
862 	return 0 != pChkBox;
863 }
864 
865 
SaveTblBoxCntnt(const SwPosition * pPos)866 void SwCrsrShell::SaveTblBoxCntnt( const SwPosition* pPos )
867 {
868 	if( IsSelTblCells() || !IsAutoUpdateCells() )
869 		return ;
870 
871 	if( !pPos )
872 		pPos = pCurCrsr->GetPoint();
873 
874 	SwStartNode* pSttNd = pPos->nNode.GetNode().FindSttNodeByType( SwTableBoxStartNode );
875 
876 	sal_Bool bCheckBox = sal_False;
877 	if( pSttNd && pBoxIdx )
878 	{
879 		if( pSttNd == &pBoxIdx->GetNode() )
880 			pSttNd = 0;		// die haben wir schon
881 		else
882 			bCheckBox = sal_True;
883 	}
884 	else
885 		bCheckBox = 0 != pBoxIdx;
886 
887 	if( bCheckBox )
888 	{
889 		// pBoxIdx Checken
890 		SwPosition aPos( *pBoxIdx );
891 		CheckTblBoxCntnt( &aPos );
892 	}
893 
894 	if( pSttNd )
895 	{
896 		pBoxPtr = pSttNd->FindTableNode()->GetTable().GetTblBox( pSttNd->GetIndex() );
897 
898 		if( pBoxIdx )
899 			*pBoxIdx = *pSttNd;
900 		else
901 			pBoxIdx = new SwNodeIndex( *pSttNd );
902 	}
903 }
904 
905 
ClearTblBoxCntnt()906 void SwCrsrShell::ClearTblBoxCntnt()
907 {
908 	delete pBoxIdx, pBoxIdx = 0;
909 	pBoxPtr = 0;
910 }
911 
EndAllTblBoxEdit()912 sal_Bool SwCrsrShell::EndAllTblBoxEdit()
913 {
914 	sal_Bool bRet = sal_False;
915 	ViewShell *pSh = this;
916 	do {
917 		if( pSh->IsA( TYPE( SwCrsrShell ) ) )
918 			bRet |= ((SwCrsrShell*)pSh)->CheckTblBoxCntnt(
919 						((SwCrsrShell*)pSh)->pCurCrsr->GetPoint() );
920 
921 	} while( this != (pSh = (ViewShell *)pSh->GetNext()) );
922 	return bRet;
923 }
924 
925 
926 
927 
928