?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Stop leaking all ScPostIt instances.
[LibreOffice.git] / sc / source / ui / app / inputhdl.cxx
blob0c6bbc51a1cbbf478df2d684444d8f83d9e7e387
1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2 /*
3 * This file is part of the LibreOffice project.
4 *
5 * This Source Code Form is subject to the terms of the Mozilla Public
6 * License, v. 2.0. If a copy of the MPL was not distributed with this
7 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
8 *
9 * This file incorporates work covered by the following license notice:
10 *
11 * Licensed to the Apache Software Foundation (ASF) under one or more
12 * contributor license agreements. See the NOTICE file distributed
13 * with this work for additional information regarding copyright
14 * ownership. The ASF licenses this file to you under the Apache
15 * License, Version 2.0 (the "License"); you may not use this file
16 * except in compliance with the License. You may obtain a copy of
17 * the License at http://www.apache.org/licenses/LICENSE-2.0 .
18 */
19
20 #include "inputhdl.hxx"
21 #include "scitems.hxx"
22 #include <editeng/eeitem.hxx>
23
24 #include <sfx2/app.hxx>
25 #include <editeng/acorrcfg.hxx>
26 #include <svx/algitem.hxx>
27 #include <editeng/adjustitem.hxx>
28 #include <editeng/brushitem.hxx>
29 #include <svtools/colorcfg.hxx>
30 #include <editeng/colritem.hxx>
31 #include <editeng/editobj.hxx>
32 #include <editeng/editstat.hxx>
33 #include <editeng/editview.hxx>
34 #include <editeng/escapementitem.hxx>
35 #include <editeng/forbiddencharacterstable.hxx>
36 #include <editeng/langitem.hxx>
37 #include <editeng/svxacorr.hxx>
38 #include <editeng/unolingu.hxx>
39 #include <editeng/wghtitem.hxx>
40 #include <editeng/justifyitem.hxx>
41 #include "editeng/misspellrange.hxx"
42 #include <sfx2/bindings.hxx>
43 #include <sfx2/viewfrm.hxx>
44 #include <sfx2/dispatch.hxx>
45 #include <sfx2/docfile.hxx>
46 #include <sfx2/printer.hxx>
47 #include <svl/zforlist.hxx>
48 #include <unotools/localedatawrapper.hxx>
49 #include <vcl/help.hxx>
50 #include <vcl/cursor.hxx>
51 #include <tools/urlobj.hxx>
52 #include <comphelper/string.hxx>
53 #include <formula/formulahelper.hxx>
54
55 #include "inputwin.hxx"
56 #include "tabvwsh.hxx"
57 #include "docsh.hxx"
58 #include "scmod.hxx"
59 #include "uiitems.hxx"
60 #include "global.hxx"
61 #include "sc.hrc"
62 #include "globstr.hrc"
63 #include "patattr.hxx"
64 #include "viewdata.hxx"
65 #include "document.hxx"
66 #include "docpool.hxx"
67 #include "editutil.hxx"
68 #include "appoptio.hxx"
69 #include "docoptio.hxx"
70 #include "validat.hxx"
71 #include "userlist.hxx"
72 #include "rfindlst.hxx"
73 #include "inputopt.hxx"
74 #include "simpleformulacalc.hxx"
75 #include "compiler.hxx"
76 #include "editable.hxx"
77 #include "funcdesc.hxx"
78 #include "markdata.hxx"
79 #include "tokenarray.hxx"
80
81 // max. Ranges im RangeFinder
82 #define RANGEFIND_MAX 32
83
84 using namespace formula;
85
86 // STATIC DATA -----------------------------------------------------------
87
88 bool ScInputHandler::bOptLoaded = false; // App-Optionen ausgewertet
89 bool ScInputHandler::bAutoComplete = false; // wird in KeyInput gesetzt
90
91 extern sal_uInt16 nEditAdjust; //! Member an ViewData
92
93 namespace {
94
95 // delimiters (in addition to ScEditUtil) needed for range finder:
96 // only characters that are allowed in formulas next to references
97 // and the quotation mark (so string constants can be skipped)
98 const sal_Char pMinDelimiters[] = " !\"";
99
100 sal_Unicode lcl_getSheetSeparator(ScDocument* pDoc)
101 {
102 ScCompiler aComp(pDoc, ScAddress());
103 aComp.SetGrammar(pDoc->GetGrammar());
104 return aComp.GetNativeAddressSymbol(ScCompiler::Convention::SHEET_SEPARATOR);
105 }
106
107 ScTypedCaseStrSet::const_iterator findText(
108 const ScTypedCaseStrSet& rDataSet, ScTypedCaseStrSet::const_iterator itPos,
109 const OUString& rStart, OUString& rResult, bool bBack)
110 {
111 if (bBack) // rueckwaerts
112 {
113 ScTypedCaseStrSet::const_reverse_iterator it = rDataSet.rbegin(), itEnd = rDataSet.rend();
114 if (itPos != rDataSet.end())
115 {
116 size_t nPos = std::distance(rDataSet.begin(), itPos);
117 size_t nRPos = rDataSet.size() - 1 - nPos;
118 std::advance(it, nRPos);
119 ++it;
120 }
121
122 for (; it != itEnd; ++it)
123 {
124 const ScTypedStrData& rData = *it;
125 if (rData.GetStringType() == ScTypedStrData::Value)
126 // skip values.
127 continue;
128
129 if (!ScGlobal::GetpTransliteration()->isMatch(rStart, rData.GetString()))
130 // not a match.
131 continue;
132
133 rResult = rData.GetString();
134 return (++it).base(); // convert the reverse iterator back to iterator.
135 }
136 }
137 else // vorwaerts
138 {
139 ScTypedCaseStrSet::const_iterator it = rDataSet.begin(), itEnd = rDataSet.end();
140 if (itPos != rDataSet.end())
141 {
142 it = itPos;
143 ++it;
144 }
145
146 for (; it != itEnd; ++it)
147 {
148 const ScTypedStrData& rData = *it;
149 if (rData.GetStringType() == ScTypedStrData::Value)
150 // skip values.
151 continue;
152
153 if (!ScGlobal::GetpTransliteration()->isMatch(rStart, rData.GetString()))
154 // not a match.
155 continue;
156
157 rResult = rData.GetString();
158 return it;
159 }
160 }
161
162 return rDataSet.end(); // no matching text found.
163 }
164
165 OUString getExactMatch(const ScTypedCaseStrSet& rDataSet, const OUString& rString)
166 {
167 ScTypedCaseStrSet::const_iterator it = rDataSet.begin(), itEnd = rDataSet.end();
168 for (; it != itEnd; ++it)
169 {
170 const ScTypedStrData& rData = *it;
171 if (rData.GetStringType() == ScTypedStrData::Value)
172 continue;
173
174 if (!ScGlobal::GetpTransliteration()->isEqual(rData.GetString(), rString))
175 continue;
176
177 return rData.GetString();
178 }
179 return rString;
180 }
181
182 void removeChars(OUString& rStr, sal_Unicode c)
183 {
184 OUStringBuffer aBuf(rStr);
185 for (sal_Int32 i = 0, n = aBuf.getLength(); i < n; ++i)
186 {
187 if (aBuf[i] == c)
188 aBuf[i] = ' ';
189 }
190 rStr = aBuf.makeStringAndClear();
191 }
192
193 }
194
195 void ScInputHandler::InitRangeFinder( const OUString& rFormula )
196 {
197 DeleteRangeFinder();
198 ScDocShell* pDocSh = pActiveViewSh->GetViewData()->GetDocShell();
199 ScDocument* pDoc = pDocSh->GetDocument();
200 const sal_Unicode cSheetSep = lcl_getSheetSeparator(pDoc);
201
202 if ( !pActiveViewSh || !SC_MOD()->GetInputOptions().GetRangeFinder() )
203 return;
204
205 OUString aDelimiters = ScEditUtil::ModifyDelimiters(
206 OUString::createFromAscii( pMinDelimiters ) );
207
208 sal_Int32 nColon = aDelimiters.indexOf( ':' );
209 if ( nColon != -1 )
210 aDelimiters = aDelimiters.replaceAt( nColon, 1, ""); // Delimiter ohne Doppelpunkt
211 sal_Int32 nDot = aDelimiters.indexOf(cSheetSep);
212 if ( nDot != -1 )
213 aDelimiters = aDelimiters.replaceAt( nDot, 1 , ""); // Delimiter ohne Punkt
214
215 const sal_Unicode* pChar = rFormula.getStr();
216 sal_Int32 nLen = rFormula.getLength();
217 sal_Int32 nPos = 0;
218 sal_Int32 nStart = 0;
219 sal_uInt16 nCount = 0;
220 ScRange aRange;
221 while ( nPos < nLen && nCount < RANGEFIND_MAX )
222 {
223 // Trenner ueberlesen
224 while ( nPos<nLen && ScGlobal::UnicodeStrChr( aDelimiters.getStr(), pChar[nPos] ) )
225 {
226 if ( pChar[nPos] == '"' ) // String
227 {
228 ++nPos;
229 while (nPos<nLen && pChar[nPos] != '"') // bis zum Ende ueberlesen
230 ++nPos;
231 }
232 ++nPos; // Trennzeichen oder schliessender Quote
233 }
234
235 // Text zwischen Trennern
236 nStart = nPos;
237 handle_r1c1:
238 while ( nPos<nLen && !ScGlobal::UnicodeStrChr( aDelimiters.getStr(), pChar[nPos] ) )
239 ++nPos;
240
241 // for R1C1 '-' in R[-]... or C[-]... are not delimiters
242 // Nothing heroic here to ensure that there are '[]' around a negative
243 // integer. we need to clean up this code.
244 if( nPos < nLen && nPos > 0 &&
245 '-' == pChar[nPos] && '[' == pChar[nPos-1] &&
246 NULL != pDoc &&
247 formula::FormulaGrammar::CONV_XL_R1C1 == pDoc->GetAddressConvention() )
248 {
249 nPos++;
250 goto handle_r1c1;
251 }
252
253 if ( nPos > nStart )
254 {
255 OUString aTest = rFormula.copy( nStart, nPos-nStart );
256 const ScAddress::Details aAddrDetails( pDoc, aCursorPos );
257 sal_uInt16 nFlags = aRange.ParseAny( aTest, pDoc, aAddrDetails );
258 if ( nFlags & SCA_VALID )
259 {
260 // Tabelle setzen, wenn nicht angegeben
261 if ( (nFlags & SCA_TAB_3D) == 0 )
262 aRange.aStart.SetTab( pActiveViewSh->GetViewData()->GetTabNo() );
263 if ( (nFlags & SCA_TAB2_3D) == 0 )
264 aRange.aEnd.SetTab( aRange.aStart.Tab() );
265
266 if ( ( nFlags & ( SCA_VALID_COL2 | SCA_VALID_ROW2 | SCA_VALID_TAB2 ) ) == 0 )
267 {
268 // #i73766# if a single ref was parsed, set the same "abs" flags for ref2,
269 // so Format doesn't output a double ref because of different flags.
270 sal_uInt16 nAbsFlags = nFlags & ( SCA_COL_ABSOLUTE | SCA_ROW_ABSOLUTE | SCA_TAB_ABSOLUTE );
271 nFlags |= nAbsFlags << 4;
272 }
273
274 if (!nCount)
275 {
276 pEngine->SetUpdateMode( false );
277 pRangeFindList = new ScRangeFindList( pDocSh->GetTitle() );
278 }
279
280 pRangeFindList->Insert( ScRangeFindData( aRange, nFlags, nStart, nPos ) );
281
282 ESelection aSel( 0, nStart, 0, nPos );
283 SfxItemSet aSet( pEngine->GetEmptyItemSet() );
284 aSet.Put( SvxColorItem( Color( ScRangeFindList::GetColorName( nCount ) ),
285 EE_CHAR_COLOR ) );
286 pEngine->QuickSetAttribs( aSet, aSel );
287 ++nCount;
288 }
289 }
290
291 // letzten Trenner nicht ueberlesen, koennte ja ein Quote sein (?)
292 }
293
294 if (nCount)
295 {
296 pEngine->SetUpdateMode( true );
297
298 pDocSh->Broadcast( SfxSimpleHint( SC_HINT_SHOWRANGEFINDER ) );
299 }
300 }
301
302 static void lcl_Replace( EditView* pView, const OUString& rNewStr, const ESelection& rOldSel )
303 {
304 if ( pView )
305 {
306 ESelection aOldSel = pView->GetSelection();
307 if (aOldSel.HasRange())
308 pView->SetSelection( ESelection( aOldSel.nEndPara, aOldSel.nEndPos,
309 aOldSel.nEndPara, aOldSel.nEndPos ) );
310
311 EditEngine* pEngine = pView->GetEditEngine();
312 pEngine->QuickInsertText( rNewStr, rOldSel );
313
314 // Dummy-InsertText fuer Update und Paint
315 // dafuer muss oben die Selektion aufgehoben werden (vor QuickInsertText)
316 pView->InsertText( EMPTY_OUSTRING, false );
317
318 xub_StrLen nLen = pEngine->GetTextLen(0);
319 ESelection aSel( 0, nLen, 0, nLen );
320 pView->SetSelection( aSel ); // Cursor ans Ende
321 }
322 }
323
324 void ScInputHandler::UpdateRange( sal_uInt16 nIndex, const ScRange& rNew )
325 {
326 ScTabViewShell* pDocView = pRefViewSh ? pRefViewSh : pActiveViewSh;
327 if ( pDocView && pRangeFindList && nIndex < pRangeFindList->Count() )
328 {
329 ScRangeFindData* pData = pRangeFindList->GetObject( nIndex );
330 xub_StrLen nOldStart = pData->nSelStart;
331 xub_StrLen nOldEnd = pData->nSelEnd;
332
333 ScRange aJustified = rNew;
334 aJustified.Justify(); // Ref in der Formel immer richtigherum anzeigen
335 ScDocument* pDoc = pDocView->GetViewData()->GetDocument();
336 const ScAddress::Details aAddrDetails( pDoc, aCursorPos );
337 OUString aNewStr(aJustified.Format(pData->nFlags, pDoc, aAddrDetails));
338 ESelection aOldSel( 0, nOldStart, 0, nOldEnd );
339
340 DataChanging();
341
342 lcl_Replace( pTopView, aNewStr, aOldSel );
343 lcl_Replace( pTableView, aNewStr, aOldSel );
344
345 bInRangeUpdate = true;
346 DataChanged();
347 bInRangeUpdate = false;
348
349 long nDiff = aNewStr.getLength() - (long)(nOldEnd-nOldStart);
350
351 pData->aRef = rNew;
352 pData->nSelEnd = (xub_StrLen)(pData->nSelEnd + nDiff);
353
354 sal_uInt16 nCount = (sal_uInt16) pRangeFindList->Count();
355 for (sal_uInt16 i=nIndex+1; i<nCount; i++)
356 {
357 ScRangeFindData* pNext = pRangeFindList->GetObject( i );
358 pNext->nSelStart = (xub_StrLen)(pNext->nSelStart + nDiff);
359 pNext->nSelEnd = (xub_StrLen)(pNext->nSelEnd + nDiff);
360 }
361 }
362 else
363 {
364 OSL_FAIL("UpdateRange: da fehlt was");
365 }
366 }
367
368 void ScInputHandler::DeleteRangeFinder()
369 {
370 ScTabViewShell* pPaintView = pRefViewSh ? pRefViewSh : pActiveViewSh;
371 if ( pRangeFindList && pPaintView )
372 {
373 ScDocShell* pDocSh = pActiveViewSh->GetViewData()->GetDocShell();
374 pRangeFindList->SetHidden(true);
375 pDocSh->Broadcast( SfxSimpleHint( SC_HINT_SHOWRANGEFINDER ) ); // wegnehmen
376 DELETEZ(pRangeFindList);
377 }
378 }
379
380 //==================================================================
381
382 inline OUString GetEditText(EditEngine* pEng)
383 {
384 return ScEditUtil::GetSpaceDelimitedString(*pEng);
385 }
386
387 static void lcl_RemoveTabs(OUString& rStr)
388 {
389 removeChars(rStr, '\t');
390 }
391
392 static void lcl_RemoveLineEnd(OUString& rStr)
393 {
394 rStr = convertLineEnd(rStr, LINEEND_LF);
395 removeChars(rStr, '\n');
396 }
397
398 static sal_Int32 lcl_MatchParenthesis( const OUString& rStr, xub_StrLen nPos )
399 {
400 int nDir;
401 sal_Unicode c1, c2 = 0;
402 c1 = rStr[nPos];
403 switch ( c1 )
404 {
405 case '(' :
406 c2 = ')';
407 nDir = 1;
408 break;
409 case ')' :
410 c2 = '(';
411 nDir = -1;
412 break;
413 case '<' :
414 c2 = '>';
415 nDir = 1;
416 break;
417 case '>' :
418 c2 = '<';
419 nDir = -1;
420 break;
421 case '{' :
422 c2 = '}';
423 nDir = 1;
424 break;
425 case '}' :
426 c2 = '{';
427 nDir = -1;
428 break;
429 case '[' :
430 c2 = ']';
431 nDir = 1;
432 break;
433 case ']' :
434 c2 = '[';
435 nDir = -1;
436 break;
437 default:
438 nDir = 0;
439 }
440 if ( !nDir )
441 return -1;
442 sal_Int32 nLen = rStr.getLength();
443 const sal_Unicode* p0 = rStr.getStr();
444 const sal_Unicode* p;
445 const sal_Unicode* p1;
446 sal_uInt16 nQuotes = 0;
447 if ( nPos < nLen / 2 )
448 {
449 p = p0;
450 p1 = p0 + nPos;
451 }
452 else
453 {
454 p = p0 + nPos;
455 p1 = p0 + nLen;
456 }
457 while ( p < p1 )
458 {
459 if ( *p++ == '\"' )
460 nQuotes++;
461 }
462 // Odd number of quotes that we find ourselves in a string
463 bool bLookInString = ((nQuotes % 2) != 0);
464 bool bInString = bLookInString;
465 p = p0 + nPos;
466 p1 = (nDir < 0 ? p0 : p0 + nLen) ;
467 sal_uInt16 nLevel = 1;
468 while ( p != p1 && nLevel )
469 {
470 p += nDir;
471 if ( *p == '\"' )
472 {
473 bInString = !bInString;
474 if ( bLookInString && !bInString )
475 p = p1; //That's it then
476 }
477 else if ( bInString == bLookInString )
478 {
479 if ( *p == c1 )
480 nLevel++;
481 else if ( *p == c2 )
482 nLevel--;
483 }
484 }
485 if ( nLevel )
486 return -1;
487 return (sal_Int32) (p - p0);
488 }
489
490 //==================================================================
491
492 ScInputHandler::ScInputHandler()
493 : pInputWin( NULL ),
494 pEngine( NULL ),
495 pTableView( NULL ),
496 pTopView( NULL ),
497 pColumnData( NULL ),
498 pFormulaData( NULL ),
499 pFormulaDataPara( NULL ),
500 pTipVisibleParent( NULL ),
501 nTipVisible( 0 ),
502 pTipVisibleSecParent( NULL ),
503 nTipVisibleSec( 0 ),
504 nFormSelStart( 0 ),
505 nFormSelEnd( 0 ),
506 nAutoPar( 0 ),
507 eMode( SC_INPUT_NONE ),
508 bUseTab( false ),
509 bTextValid( true ),
510 bModified( false ),
511 bSelIsRef( false ),
512 bFormulaMode( false ),
513 bInRangeUpdate( false ),
514 bParenthesisShown( false ),
515 bCreatingFuncView( false ),
516 bInEnterHandler( false ),
517 bCommandErrorShown( false ),
518 bInOwnChange( false ),
519 bProtected( false ),
520 bCellHasPercentFormat( false ),
521 bLastIsSymbol( false ),
522 nValidation( 0 ),
523 eAttrAdjust( SVX_HOR_JUSTIFY_STANDARD ),
524 aScaleX( 1,1 ),
525 aScaleY( 1,1 ),
526 pRefViewSh( NULL ),
527 pLastPattern( NULL ),
528 pEditDefaults( NULL ),
529 pLastState( NULL ),
530 pDelayTimer( NULL ),
531 pRangeFindList( NULL )
532 {
533 // The InputHandler is constructed with the view, so SfxViewShell::Current
534 // doesn't have the right view yet. pActiveViewSh is updated in NotifyChange.
535 pActiveViewSh = NULL;
536
537 // Bindings (nur noch fuer Invalidate benutzt) werden bei Bedarf aktuell geholt
538 }
539
540 ScInputHandler::~ScInputHandler()
541 {
542 // Wenn dies der Applikations-InputHandler ist, wird der dtor erst nach SfxApplication::Main
543 // gerufen, darf sich also auf keine Sfx-Funktionen mehr verlassen
544
545 if ( !SFX_APP()->IsDowning() ) // inplace
546 EnterHandler(); // Eingabe noch abschliessen
547
548 if (SC_MOD()->GetRefInputHdl()==this)
549 SC_MOD()->SetRefInputHdl(NULL);
550
551 if ( pInputWin && pInputWin->GetInputHandler() == this )
552 pInputWin->SetInputHandler( NULL );
553
554 delete pRangeFindList;
555 delete pEditDefaults;
556 delete pEngine;
557 delete pLastState;
558 delete pDelayTimer;
559 delete pColumnData;
560 delete pFormulaData;
561 delete pFormulaDataPara;
562 }
563
564 void ScInputHandler::SetRefScale( const Fraction& rX, const Fraction& rY )
565 {
566 if ( rX != aScaleX || rY != aScaleY )
567 {
568 aScaleX = rX;
569 aScaleY = rY;
570 if (pEngine)
571 {
572 MapMode aMode( MAP_100TH_MM, Point(), aScaleX, aScaleY );
573 pEngine->SetRefMapMode( aMode );
574 }
575 }
576 }
577
578 void ScInputHandler::UpdateRefDevice()
579 {
580 if (!pEngine)
581 return;
582
583 bool bTextWysiwyg = SC_MOD()->GetInputOptions().GetTextWysiwyg();
584 bool bInPlace = pActiveViewSh && pActiveViewSh->GetViewFrame()->GetFrame().IsInPlace();
585 sal_uLong nCtrl = pEngine->GetControlWord();
586 if ( bTextWysiwyg || bInPlace )
587 nCtrl |= EE_CNTRL_FORMAT100; // EditEngine default: always format for 100%
588 else
589 nCtrl &= ~EE_CNTRL_FORMAT100; // when formatting for screen, use the actual MapMode
590 pEngine->SetControlWord( nCtrl );
591 if ( bTextWysiwyg && pActiveViewSh )
592 pEngine->SetRefDevice( pActiveViewSh->GetViewData()->GetDocument()->GetPrinter() );
593 else
594 pEngine->SetRefDevice( NULL );
595
596 MapMode aMode( MAP_100TH_MM, Point(), aScaleX, aScaleY );
597 pEngine->SetRefMapMode( aMode );
598
599 // SetRefDevice(NULL) uses VirtualDevice, SetRefMapMode forces creation of a local VDev,
600 // so the DigitLanguage can be safely modified (might use an own VDev instead of NULL).
601 if ( !( bTextWysiwyg && pActiveViewSh ) )
602 {
603 pEngine->GetRefDevice()->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
604 }
605 }
606
607 void ScInputHandler::ImplCreateEditEngine()
608 {
609 if ( !pEngine )
610 {
611 if ( pActiveViewSh )
612 {
613 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
614 pEngine = new ScFieldEditEngine(pDoc, pDoc->GetEnginePool(), pDoc->GetEditPool());
615 }
616 else
617 pEngine = new ScFieldEditEngine(NULL, EditEngine::CreatePool(), NULL, true);
618 pEngine->SetWordDelimiters( ScEditUtil::ModifyDelimiters( pEngine->GetWordDelimiters() ) );
619 UpdateRefDevice(); // also sets MapMode
620 pEngine->SetPaperSize( Size( 1000000, 1000000 ) );
621 pEditDefaults = new SfxItemSet( pEngine->GetEmptyItemSet() );
622
623 pEngine->SetControlWord( pEngine->GetControlWord() | EE_CNTRL_AUTOCORRECT );
624 pEngine->SetModifyHdl( LINK( this, ScInputHandler, ModifyHdl ) );
625 }
626 }
627
628 void ScInputHandler::UpdateAutoCorrFlag()
629 {
630 sal_uLong nCntrl = pEngine->GetControlWord();
631 sal_uLong nOld = nCntrl;
632
633 // don't use pLastPattern here (may be invalid because of AutoStyle)
634
635 bool bDisable = bLastIsSymbol || bFormulaMode;
636 if ( bDisable )
637 nCntrl &= ~EE_CNTRL_AUTOCORRECT;
638 else
639 nCntrl |= EE_CNTRL_AUTOCORRECT;
640
641 if ( nCntrl != nOld )
642 pEngine->SetControlWord(nCntrl);
643 }
644
645 void ScInputHandler::UpdateSpellSettings( bool bFromStartTab )
646 {
647 if ( pActiveViewSh )
648 {
649 ScViewData* pViewData = pActiveViewSh->GetViewData();
650 bool bOnlineSpell = pViewData->GetDocument()->GetDocOptions().IsAutoSpell();
651
652 // SetDefaultLanguage is independent of the language attributes,
653 // ScGlobal::GetEditDefaultLanguage is always used.
654 // It must be set every time in case the office language was changed.
655
656 pEngine->SetDefaultLanguage( ScGlobal::GetEditDefaultLanguage() );
657
658 // if called for changed options, update flags only if already editing
659 // if called from StartTable, always update flags
660
661 if ( bFromStartTab || eMode != SC_INPUT_NONE )
662 {
663 sal_uLong nCntrl = pEngine->GetControlWord();
664 sal_uLong nOld = nCntrl;
665 if( bOnlineSpell )
666 nCntrl |= EE_CNTRL_ONLINESPELLING;
667 else
668 nCntrl &= ~EE_CNTRL_ONLINESPELLING;
669 // kein AutoCorrect auf Symbol-Font (EditEngine wertet Default nicht aus)
670 if ( pLastPattern && pLastPattern->IsSymbolFont() )
671 nCntrl &= ~EE_CNTRL_AUTOCORRECT;
672 else
673 nCntrl |= EE_CNTRL_AUTOCORRECT;
674 if ( nCntrl != nOld )
675 pEngine->SetControlWord(nCntrl);
676
677 ScDocument* pDoc = pViewData->GetDocument();
678 pDoc->ApplyAsianEditSettings( *pEngine );
679 pEngine->SetDefaultHorizontalTextDirection(
680 (EEHorizontalTextDirection)pDoc->GetEditTextDirection( pViewData->GetTabNo() ) );
681 pEngine->SetFirstWordCapitalization( false );
682 }
683
684 // language is set separately, so the speller is needed only if online
685 // spelling is active
686
687 if ( bOnlineSpell ) {
688 com::sun::star::uno::Reference<com::sun::star::linguistic2::XSpellChecker1> xXSpellChecker1( LinguMgr::GetSpellChecker() );
689 pEngine->SetSpeller( xXSpellChecker1 );
690 }
691
692 bool bHyphen = pLastPattern && ((const SfxBoolItem&)pLastPattern->GetItem(ATTR_HYPHENATE)).GetValue();
693 if ( bHyphen ) {
694 com::sun::star::uno::Reference<com::sun::star::linguistic2::XHyphenator> xXHyphenator( LinguMgr::GetHyphenator() );
695 pEngine->SetHyphenator( xXHyphenator );
696 }
697 }
698 }
699
700 //
701 // Funktionen/Bereichsnamen etc. als Tip-Hilfe
702 //
703
704 // die anderen Typen sind in ScDocument::GetFormulaEntries festgelegt
705
706 void ScInputHandler::GetFormulaData()
707 {
708 if ( pActiveViewSh )
709 {
710 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
711
712 if ( pFormulaData )
713 pFormulaData->clear();
714 else
715 {
716 pFormulaData = new ScTypedCaseStrSet;
717 miAutoPosFormula = pFormulaData->end();
718 }
719
720 if( pFormulaDataPara )
721 pFormulaDataPara->clear();
722 else
723 pFormulaDataPara = new ScTypedCaseStrSet;
724
725 // MRU-Funktionen aus dem Funktions-Autopiloten
726 // wie in ScPosWnd::FillFunctions (inputwin.cxx)
727
728 const ScAppOptions& rOpt = SC_MOD()->GetAppOptions();
729 sal_uInt16 nMRUCount = rOpt.GetLRUFuncListCount();
730 const sal_uInt16* pMRUList = rOpt.GetLRUFuncList();
731 const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
732 sal_uLong nListCount = pFuncList->GetCount();
733 if (pMRUList)
734 {
735 for (sal_uInt16 i=0; i<nMRUCount; i++)
736 {
737 sal_uInt16 nId = pMRUList[i];
738 for (sal_uLong j=0; j<nListCount; j++)
739 {
740 const ScFuncDesc* pDesc = pFuncList->GetFunction( j );
741 if ( pDesc->nFIndex == nId && pDesc->pFuncName )
742 {
743 OUString aEntry = *pDesc->pFuncName;
744 aEntry += "()";
745 pFormulaData->insert(ScTypedStrData(aEntry, 0.0, ScTypedStrData::Standard));
746 break; // nicht weitersuchen
747 }
748 }
749 }
750 }
751 for(sal_uLong i=0;i<nListCount;i++)
752 {
753 const ScFuncDesc* pDesc = pFuncList->GetFunction( i );
754 if ( pDesc->pFuncName )
755 {
756 pDesc->initArgumentInfo();
757 OUString aEntry = pDesc->getSignature();
758 pFormulaDataPara->insert(ScTypedStrData(aEntry, 0.0, ScTypedStrData::Standard));
759 }
760 }
761 pDoc->GetFormulaEntries( *pFormulaData );
762 pDoc->GetFormulaEntries( *pFormulaDataPara );
763 }
764 }
765
766 IMPL_LINK( ScInputHandler, ShowHideTipVisibleParentListener, VclWindowEvent*, pEvent )
767 {
768 if( pEvent->GetId() == VCLEVENT_OBJECT_DYING || pEvent->GetId() == VCLEVENT_WINDOW_HIDE )
769 HideTip();
770 return 0;
771 }
772
773 IMPL_LINK( ScInputHandler, ShowHideTipVisibleSecParentListener, VclWindowEvent*, pEvent )
774 {
775 if( pEvent->GetId() == VCLEVENT_OBJECT_DYING || pEvent->GetId() == VCLEVENT_WINDOW_HIDE )
776 HideTipBelow();
777 return 0;
778 }
779
780 void ScInputHandler::HideTip()
781 {
782 if ( nTipVisible )
783 {
784 if (pTipVisibleParent)
785 pTipVisibleParent->RemoveEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleParentListener ) );
786 Help::HideTip( nTipVisible );
787 nTipVisible = 0;
788 pTipVisibleParent = NULL;
789 }
790 aManualTip = OUString();
791 }
792 void ScInputHandler::HideTipBelow()
793 {
794 if ( nTipVisibleSec )
795 {
796 if (pTipVisibleSecParent)
797 pTipVisibleSecParent->RemoveEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleSecParentListener ) );
798 Help::HideTip( nTipVisibleSec );
799 nTipVisibleSec = 0;
800 pTipVisibleSecParent = NULL;
801 }
802 aManualTip = OUString();
803 }
804
805 void ScInputHandler::ShowTipCursor()
806 {
807 HideTip();
808 HideTipBelow();
809 EditView* pActiveView = pTopView ? pTopView : pTableView;
810 ScDocShell* pDocSh = pActiveViewSh->GetViewData()->GetDocShell();
811 const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
812 const sal_Unicode cSheetSep = lcl_getSheetSeparator(pDocSh->GetDocument());
813
814 if ( bFormulaMode && pActiveView && pFormulaDataPara && pEngine->GetParagraphCount() == 1 )
815 {
816 OUString aFormula = pEngine->GetText( 0 );
817 ESelection aSel = pActiveView->GetSelection();
818 aSel.Adjust();
819 if( aSel.nEndPos )
820 {
821 if ( aFormula.getLength() < aSel.nEndPos )
822 return;
823 xub_StrLen nPos = aSel.nEndPos;
824 OUString aSelText = aFormula.copy( 0, nPos );
825 xub_StrLen nNextFStart = 0;
826 xub_StrLen nNextFEnd = 0;
827 xub_StrLen nArgPos = 0;
828 const IFunctionDescription* ppFDesc;
829 ::std::vector< OUString> aArgs;
830 sal_uInt16 nArgs;
831 bool bFound = false;
832 FormulaHelper aHelper(ScGlobal::GetStarCalcFunctionMgr());
833
834 while( !bFound )
835 {
836 aSelText += ")";
837 sal_Int32 nLeftParentPos = lcl_MatchParenthesis( aSelText, aSelText.getLength()-1 );
838 if( nLeftParentPos != -1 )
839 {
840 sal_Unicode c = ( nLeftParentPos > 0 ) ? aSelText[ nLeftParentPos-1 ] : 0;
841 if( !(comphelper::string::isalphaAscii(c)) )
842 continue;
843 nNextFStart = aHelper.GetFunctionStart( aSelText, nLeftParentPos, true);
844 if( aHelper.GetNextFunc( aSelText, false, nNextFStart, &nNextFEnd, &ppFDesc, &aArgs ) )
845 {
846 if( !ppFDesc->getFunctionName().isEmpty() )
847 {
848 nArgPos = aHelper.GetArgStart( aSelText, nNextFStart, 0 );
849 nArgs = static_cast<sal_uInt16>(ppFDesc->getParameterCount());
850
851 OUString aNew;
852 ScTypedCaseStrSet::const_iterator it =
853 findText(*pFormulaDataPara, pFormulaDataPara->end(), ppFDesc->getFunctionName(), aNew, false);
854 if (it != pFormulaDataPara->end())
855 {
856 bool bFlag = false;
857 sal_uInt16 nActive = 0;
858 for( sal_uInt16 i=0; i < nArgs; i++ )
859 {
860 xub_StrLen nLength = static_cast<xub_StrLen>(aArgs[i].getLength());
861 if( nArgPos <= aSelText.getLength()-1 )
862 {
863 nActive = i+1;
864 bFlag = true;
865 }
866 nArgPos+=nLength+1;
867 }
868 if( bFlag )
869 {
870 sal_Int32 nCountSemicolon = comphelper::string::getTokenCount(aNew, cSep) - 1;
871 sal_Int32 nCountDot = comphelper::string::getTokenCount(aNew, cSheetSep) - 1;
872 sal_Int32 nStartPosition = 0;
873 sal_Int32 nEndPosition = 0;
874
875 if( !nCountSemicolon )
876 {
877 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
878 {
879 sal_Unicode cNext = aNew[i];
880 if( cNext == '(' )
881 {
882 nStartPosition = i+1;
883 }
884 }
885 }
886 else if( !nCountDot )
887 {
888 sal_uInt16 nCount = 0;
889 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
890 {
891 sal_Unicode cNext = aNew[i];
892 if( cNext == '(' )
893 {
894 nStartPosition = i+1;
895 }
896 else if( cNext == cSep )
897 {
898 nCount ++;
899 nEndPosition = i;
900 if( nCount == nActive )
901 {
902 break;
903 }
904 nStartPosition = nEndPosition+1;
905 }
906 }
907 }
908 else
909 {
910 sal_uInt16 nCount = 0;
911 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
912 {
913 sal_Unicode cNext = aNew[i];
914 if( cNext == '(' )
915 {
916 nStartPosition = i+1;
917 }
918 else if( cNext == cSep )
919 {
920 nCount ++;
921 nEndPosition = i;
922 if( nCount == nActive )
923 {
924 break;
925 }
926 nStartPosition = nEndPosition+1;
927 }
928 else if( cNext == cSheetSep )
929 {
930 continue;
931 }
932 }
933 }
934
935 if (nStartPosition > 0)
936 {
937 OUStringBuffer aBuf;
938 aBuf.append(aNew.copy(0, nStartPosition));
939 aBuf.append(static_cast<sal_Unicode>(0x25BA));
940 aBuf.append(aNew.copy(nStartPosition));
941 aNew = aBuf.makeStringAndClear();
942 ShowTipBelow( aNew );
943 bFound = true;
944 }
945 }
946 else
947 {
948 ShowTipBelow( aNew );
949 bFound = true;
950 }
951 }
952 }
953 }
954 }
955 else
956 {
957 sal_uInt16 nPosition = 0;
958 OUString aText = pEngine->GetWord( 0, aSel.nEndPos-1 );
959 /* XXX: dubious, what is this condition supposed to exactly match? */
960 if (aSel.nEndPos <= aText.getLength() && aText[ aSel.nEndPos-1 ] == '=')
961 {
962 break;
963 }
964 OUString aNew;
965 nPosition = aText.getLength()+1;
966 ScTypedCaseStrSet::const_iterator it =
967 findText(*pFormulaDataPara, pFormulaDataPara->end(), aText, aNew, false);
968 if (it != pFormulaDataPara->end())
969 {
970 if( nPosition < aFormula.getLength() && aFormula[ nPosition ] =='(' )
971 {
972 ShowTipBelow( aNew );
973 bFound = true;
974 }
975 else
976 break;
977 }
978 else
979 {
980 break;
981 }
982 }
983 }
984 }
985 }
986 }
987
988 void ScInputHandler::ShowTip( const OUString& rText )
989 {
990 // aManualTip muss hinterher von aussen gesetzt werden
991 HideTip();
992
993 EditView* pActiveView = pTopView ? pTopView : pTableView;
994 if (pActiveView)
995 {
996 Point aPos;
997 pTipVisibleParent = pActiveView->GetWindow();
998 Cursor* pCur = pActiveView->GetCursor();
999 if (pCur)
1000 aPos = pTipVisibleParent->LogicToPixel( pCur->GetPos() );
1001 aPos = pTipVisibleParent->OutputToScreenPixel( aPos );
1002 Rectangle aRect( aPos, aPos );
1003
1004 sal_uInt16 nAlign = QUICKHELP_LEFT|QUICKHELP_BOTTOM;
1005 nTipVisible = Help::ShowTip(pTipVisibleParent, aRect, rText, nAlign);
1006 pTipVisibleParent->AddEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleParentListener ) );
1007 }
1008 }
1009
1010 void ScInputHandler::ShowTipBelow( const OUString& rText )
1011 {
1012 HideTipBelow();
1013
1014 EditView* pActiveView = pTopView ? pTopView : pTableView;
1015 if ( pActiveView )
1016 {
1017 Point aPos;
1018 pTipVisibleSecParent = pActiveView->GetWindow();
1019 Cursor* pCur = pActiveView->GetCursor();
1020 if ( pCur )
1021 {
1022 Point aLogicPos = pCur->GetPos();
1023 aLogicPos.Y() += pCur->GetHeight();
1024 aPos = pTipVisibleSecParent->LogicToPixel( aLogicPos );
1025 }
1026 aPos = pTipVisibleSecParent->OutputToScreenPixel( aPos );
1027 Rectangle aRect( aPos, aPos );
1028 sal_uInt16 nAlign = QUICKHELP_LEFT | QUICKHELP_TOP | QUICKHELP_NOEVADEPOINTER;
1029 nTipVisibleSec = Help::ShowTip(pTipVisibleSecParent, aRect, rText, nAlign);
1030 pTipVisibleSecParent->AddEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleSecParentListener ) );
1031 }
1032 }
1033
1034 void ScInputHandler::UseFormulaData()
1035 {
1036 EditView* pActiveView = pTopView ? pTopView : pTableView;
1037 ScDocShell* pDocSh = pActiveViewSh->GetViewData()->GetDocShell();
1038 const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1039 const sal_Unicode cSheetSep = lcl_getSheetSeparator(pDocSh->GetDocument());
1040
1041 // Formeln duerfen nur 1 Absatz haben
1042 if ( pActiveView && pFormulaData && pEngine->GetParagraphCount() == 1 )
1043 {
1044 OUString aTotal = pEngine->GetText( 0 );
1045 ESelection aSel = pActiveView->GetSelection();
1046 aSel.Adjust();
1047
1048 // Durch Differenzen zwischen Tabelle und Eingabezeile
1049 // (z.B. Clipboard mit Zeilenumbruechen) kann es sein, dass die Selektion
1050 // nicht mehr zur EditEngine passt. Dann halt kommentarlos abbrechen:
1051
1052 if ( aSel.nEndPos > aTotal.getLength() )
1053 return;
1054
1055 // steht der Cursor am Ende eines Wortes?
1056
1057 if ( aSel.nEndPos > 0 )
1058 {
1059 xub_StrLen nPos = aSel.nEndPos;
1060 OUString aFormula = aTotal.copy( 0, nPos );;
1061 sal_Int32 nLeftParentPos = 0;
1062 xub_StrLen nNextFStart = 0;
1063 xub_StrLen nNextFEnd = 0;
1064 xub_StrLen nArgPos = 0;
1065 const IFunctionDescription* ppFDesc;
1066 ::std::vector< OUString> aArgs;
1067 sal_uInt16 nArgs;
1068 bool bFound = false;
1069
1070 OUString aText = pEngine->GetWord( 0, aSel.nEndPos-1 );
1071 if (!aText.isEmpty())
1072 {
1073 OUString aNew;
1074 miAutoPosFormula = pFormulaData->end();
1075 miAutoPosFormula = findText(*pFormulaData, miAutoPosFormula, aText, aNew, false);
1076 if (miAutoPosFormula != pFormulaData->end())
1077 {
1078 ShowTip( aNew );
1079 aAutoSearch = aText;
1080 }
1081 }
1082 FormulaHelper aHelper(ScGlobal::GetStarCalcFunctionMgr());
1083
1084 while( !bFound )
1085 {
1086 aFormula += ")";
1087 nLeftParentPos = lcl_MatchParenthesis( aFormula, aFormula.getLength()-1 );
1088 if( nLeftParentPos == -1 )
1089 break;
1090
1091 // nLeftParentPos can be 0 if a parenthesis is inserted before the formula
1092 sal_Unicode c = ( nLeftParentPos > 0 ) ? aFormula[ nLeftParentPos-1 ] : 0;
1093 if( !(comphelper::string::isalphaAscii(c)) )
1094 continue;
1095 nNextFStart = aHelper.GetFunctionStart( aFormula, nLeftParentPos, true);
1096 if( aHelper.GetNextFunc( aFormula, false, nNextFStart, &nNextFEnd, &ppFDesc, &aArgs ) )
1097 {
1098 if( !ppFDesc->getFunctionName().isEmpty() )
1099 {
1100 nArgPos = aHelper.GetArgStart( aFormula, nNextFStart, 0 );
1101 nArgs = static_cast<sal_uInt16>(ppFDesc->getParameterCount());
1102
1103 OUString aNew;
1104 ScTypedCaseStrSet::const_iterator it =
1105 findText(*pFormulaDataPara, pFormulaDataPara->end(), ppFDesc->getFunctionName(), aNew, false);
1106 if (it != pFormulaDataPara->end())
1107 {
1108 bool bFlag = false;
1109 sal_uInt16 nActive = 0;
1110 for( sal_uInt16 i=0; i < nArgs; i++ )
1111 {
1112 xub_StrLen nLength = static_cast<xub_StrLen>(aArgs[i].getLength());
1113 if( nArgPos <= aFormula.getLength()-1 )
1114 {
1115 nActive = i+1;
1116 bFlag = true;
1117 }
1118 nArgPos+=nLength+1;
1119 }
1120 if( bFlag )
1121 {
1122 sal_Int32 nCountSemicolon = comphelper::string::getTokenCount(aNew, cSep) - 1;
1123 sal_Int32 nCountDot = comphelper::string::getTokenCount(aNew, cSheetSep) - 1;
1124 sal_Int32 nStartPosition = 0;
1125 sal_Int32 nEndPosition = 0;
1126
1127 if( !nCountSemicolon )
1128 {
1129 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1130 {
1131 sal_Unicode cNext = aNew[i];
1132 if( cNext == '(' )
1133 {
1134 nStartPosition = i+1;
1135 }
1136 }
1137 }
1138 else if( !nCountDot )
1139 {
1140 sal_uInt16 nCount = 0;
1141 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1142 {
1143 sal_Unicode cNext = aNew[i];
1144 if( cNext == '(' )
1145 {
1146 nStartPosition = i+1;
1147 }
1148 else if( cNext == cSep )
1149 {
1150 nCount ++;
1151 nEndPosition = i;
1152 if( nCount == nActive )
1153 {
1154 break;
1155 }
1156 nStartPosition = nEndPosition+1;
1157 }
1158 }
1159 }
1160 else
1161 {
1162 sal_uInt16 nCount = 0;
1163 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1164 {
1165 sal_Unicode cNext = aNew[i];
1166 if( cNext == '(' )
1167 {
1168 nStartPosition = i+1;
1169 }
1170 else if( cNext == cSep )
1171 {
1172 nCount ++;
1173 nEndPosition = i;
1174 if( nCount == nActive )
1175 {
1176 break;
1177 }
1178 nStartPosition = nEndPosition+1;
1179 }
1180 else if( cNext == cSheetSep )
1181 {
1182 continue;
1183 }
1184 }
1185 }
1186
1187 if (nStartPosition > 0)
1188 {
1189 OUStringBuffer aBuf;
1190 aBuf.append(aNew.copy(0, nStartPosition));
1191 aBuf.append(static_cast<sal_Unicode>(0x25BA));
1192 aBuf.append(aNew.copy(nStartPosition));
1193 aNew = aBuf.makeStringAndClear();
1194 ShowTipBelow( aNew );
1195 bFound = true;
1196 }
1197 }
1198 else
1199 {
1200 ShowTipBelow( aNew );
1201 bFound = true;
1202 }
1203 }
1204 }
1205 }
1206 }
1207 }
1208 }
1209 }
1210
1211 void ScInputHandler::NextFormulaEntry( bool bBack )
1212 {
1213 EditView* pActiveView = pTopView ? pTopView : pTableView;
1214 if ( pActiveView && pFormulaData )
1215 {
1216 OUString aNew;
1217 ScTypedCaseStrSet::const_iterator itNew = findText(*pFormulaData, miAutoPosFormula, aAutoSearch, aNew, bBack);
1218 if (itNew != pFormulaData->end())
1219 {
1220 miAutoPosFormula = itNew;
1221 ShowTip(aNew); // Display a quick help.
1222 }
1223 }
1224
1225 // bei Tab wird vorher immer HideCursor gerufen
1226
1227 if (pActiveView)
1228 pActiveView->ShowCursor();
1229 }
1230
1231 static void lcl_CompleteFunction( EditView* pView, const OUString& rInsert, bool& rParInserted )
1232 {
1233 if (pView)
1234 {
1235 ESelection aSel = pView->GetSelection();
1236 --aSel.nStartPos;
1237 --aSel.nEndPos;
1238 pView->SetSelection(aSel);
1239 pView->SelectCurrentWord();
1240
1241 OUString aInsStr = rInsert;
1242 xub_StrLen nInsLen = aInsStr.getLength();
1243 bool bDoParen = ( nInsLen > 1 && aInsStr[nInsLen-2] == '('
1244 && aInsStr[nInsLen-1] == ')' );
1245 if ( bDoParen )
1246 {
1247 // Klammern hinter Funktionsnamen nicht einfuegen, wenn direkt dahinter
1248 // schon eine Klammer steht (z.B. wenn der Funktionsname geaendert wurde).
1249
1250 ESelection aWordSel = pView->GetSelection();
1251 OUString aOld = pView->GetEditEngine()->GetText(0);
1252 // aWordSel.EndPos points one behind string if word at end.
1253 if (aWordSel.nEndPos < aOld.getLength())
1254 {
1255 sal_Unicode cNext = aOld[aWordSel.nEndPos];
1256 if ( cNext == '(' )
1257 {
1258 bDoParen = false;
1259 aInsStr = aInsStr.copy( 0, nInsLen - 2 ); // Klammern weglassen
1260 }
1261 }
1262 }
1263
1264 pView->InsertText( aInsStr, false );
1265
1266 if ( bDoParen ) // Cursor zwischen die Klammern setzen
1267 {
1268 aSel = pView->GetSelection();
1269 --aSel.nStartPos;
1270 --aSel.nEndPos;
1271 pView->SetSelection(aSel);
1272
1273 rParInserted = true;
1274 }
1275 }
1276 }
1277
1278 void ScInputHandler::PasteFunctionData()
1279 {
1280 if (pFormulaData && miAutoPosFormula != pFormulaData->end())
1281 {
1282 const ScTypedStrData& rData = *miAutoPosFormula;
1283 const OUString& aInsert = rData.GetString();
1284 bool bParInserted = false;
1285
1286 DataChanging(); // kann nicht neu sein
1287 lcl_CompleteFunction( pTopView, aInsert, bParInserted );
1288 lcl_CompleteFunction( pTableView, aInsert, bParInserted );
1289 DataChanged();
1290 ShowTipCursor();
1291
1292 if (bParInserted)
1293 AutoParAdded();
1294 }
1295
1296 HideTip();
1297
1298 EditView* pActiveView = pTopView ? pTopView : pTableView;
1299 if (pActiveView)
1300 pActiveView->ShowCursor();
1301 }
1302
1303 //
1304 // Selektion berechnen und als Tip-Hilfe anzeigen
1305 //
1306
1307 static OUString lcl_Calculate( const OUString& rFormula, ScDocument* pDoc, const ScAddress &rPos )
1308 {
1309 //! mit ScFormulaDlg::CalcValue zusammenfassen und ans Dokument verschieben !!!!
1310 //! (Anfuehrungszeichen bei Strings werden nur hier eingefuegt)
1311
1312 if(rFormula.isEmpty())
1313 return OUString();
1314
1315 boost::scoped_ptr<ScSimpleFormulaCalculator> pCalc( new ScSimpleFormulaCalculator( pDoc, rPos, rFormula ) );
1316
1317 // HACK! um bei ColRowNames kein #REF! zu bekommen,
1318 // wenn ein Name eigentlich als Bereich in die Gesamt-Formel
1319 // eingefuegt wird, bei der Einzeldarstellung aber als
1320 // single-Zellbezug interpretiert wird
1321 bool bColRowName = pCalc->HasColRowName();
1322 if ( bColRowName )
1323 {
1324 // ColRowName im RPN-Code?
1325 if ( pCalc->GetCode()->GetCodeLen() <= 1 )
1326 { // ==1: einzelner ist als Parameter immer Bereich
1327 // ==0: es waere vielleicht einer, wenn..
1328 OUStringBuffer aBraced;
1329 aBraced.append('(');
1330 aBraced.append(rFormula);
1331 aBraced.append(')');
1332 pCalc.reset( new ScSimpleFormulaCalculator( pDoc, rPos, aBraced.makeStringAndClear() ) );
1333 }
1334 else
1335 bColRowName = false;
1336 }
1337
1338 sal_uInt16 nErrCode = pCalc->GetErrCode();
1339 if ( nErrCode != 0 )
1340 return ScGlobal::GetErrorString(nErrCode);
1341
1342 SvNumberFormatter& aFormatter = *(pDoc->GetFormatTable());
1343 OUString aValue;
1344 if ( pCalc->IsValue() )
1345 {
1346 double n = pCalc->GetValue();
1347 sal_uLong nFormat = aFormatter.GetStandardFormat( n, 0,
1348 pCalc->GetFormatType(), ScGlobal::eLnge );
1349 aFormatter.GetInputLineString( n, nFormat, aValue );
1350 //! display OutputString but insert InputLineString
1351 }
1352 else
1353 {
1354 OUString aStr = pCalc->GetString().getString();
1355 sal_uLong nFormat = aFormatter.GetStandardFormat(
1356 pCalc->GetFormatType(), ScGlobal::eLnge);
1357 {
1358 Color* pColor;
1359 aFormatter.GetOutputString( aStr, nFormat,
1360 aValue, &pColor );
1361 }
1362
1363 aValue = "\"" + aValue + "\"";
1364 //! Anfuehrungszeichen im String escapen ????
1365 }
1366
1367 ScRange aTestRange;
1368 if ( bColRowName || (aTestRange.Parse(rFormula) & SCA_VALID) )
1369 aValue = aValue + " ...";
1370
1371 return aValue;
1372 }
1373
1374 void ScInputHandler::FormulaPreview()
1375 {
1376 OUString aValue;
1377 EditView* pActiveView = pTopView ? pTopView : pTableView;
1378 if ( pActiveView && pActiveViewSh )
1379 {
1380 OUString aPart = pActiveView->GetSelected();
1381 if (aPart.isEmpty())
1382 aPart = pEngine->GetText(0);
1383 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
1384 aValue = lcl_Calculate( aPart, pDoc, aCursorPos );
1385 }
1386
1387 if (!aValue.isEmpty())
1388 {
1389 ShowTip( aValue ); // als QuickHelp anzeigen
1390 aManualTip = aValue; // nach ShowTip setzen
1391 if (pFormulaData)
1392 miAutoPosFormula = pFormulaData->end();
1393 if (pColumnData)
1394 miAutoPosColumn = pColumnData->end();
1395 }
1396 }
1397
1398 void ScInputHandler::PasteManualTip()
1399 {
1400 // drei Punkte am Ende -> Bereichsreferenz -> nicht einfuegen
1401 // (wenn wir mal Matrix-Konstanten haben, kann das geaendert werden)
1402
1403 sal_Int32 nTipLen = aManualTip.getLength();
1404 sal_uInt32 const nTipLen2(sal::static_int_cast<sal_uInt32>(nTipLen));
1405 if ( nTipLen && ( nTipLen < 3 || aManualTip.copy( nTipLen2-3 ) != "..." ) )
1406 {
1407 DataChanging(); // kann nicht neu sein
1408
1409 OUString aInsert = aManualTip;
1410 EditView* pActiveView = pTopView ? pTopView : pTableView;
1411 if (!pActiveView->HasSelection())
1412 {
1413 // nichts selektiert -> alles selektieren
1414 xub_StrLen nOldLen = pEngine->GetTextLen(0);
1415 ESelection aAllSel( 0, 0, 0, nOldLen );
1416 if ( pTopView )
1417 pTopView->SetSelection( aAllSel );
1418 if ( pTableView )
1419 pTableView->SetSelection( aAllSel );
1420 }
1421
1422 ESelection aSel = pActiveView->GetSelection();
1423 aSel.Adjust();
1424 OSL_ENSURE( !aSel.nStartPara && !aSel.nEndPara, "Zuviele Absaetze in Formel" );
1425 if ( !aSel.nStartPos ) // Selektion ab Anfang?
1426 {
1427 if ( aSel.nEndPos == pEngine->GetTextLen(0) )
1428 {
1429 // alles selektiert -> Anfuehrungszeichen weglassen
1430 if ( aInsert[0] == '"' )
1431 aInsert = aInsert.copy(1);
1432 xub_StrLen nInsLen = aInsert.getLength();
1433 if ( aInsert.endsWith("\"") )
1434 aInsert = aInsert.copy( 0, nInsLen-1 );
1435 }
1436 else if ( aSel.nEndPos )
1437 {
1438 // nicht alles selektiert -> Gleichheitszeichen nicht ueberschreiben
1439 //! doppelte Gleichheitszeichen auch ???
1440
1441 aSel.nStartPos = 1;
1442 if ( pTopView )
1443 pTopView->SetSelection( aSel );
1444 if ( pTableView )
1445 pTableView->SetSelection( aSel );
1446 }
1447 }
1448 if ( pTopView )
1449 pTopView->InsertText( aInsert, true );
1450 if ( pTableView )
1451 pTableView->InsertText( aInsert, true );
1452
1453 DataChanged();
1454 }
1455
1456 HideTip();
1457 }
1458
1459 void ScInputHandler::ResetAutoPar()
1460 {
1461 nAutoPar = 0;
1462 }
1463
1464 void ScInputHandler::AutoParAdded()
1465 {
1466 ++nAutoPar; // closing parenthesis can be overwritten
1467 }
1468
1469 bool ScInputHandler::CursorAtClosingPar()
1470 {
1471 // test if the cursor is before a closing parenthesis
1472
1473 // selection from SetReference has been removed before
1474 EditView* pActiveView = pTopView ? pTopView : pTableView;
1475 if ( pActiveView && !pActiveView->HasSelection() && bFormulaMode )
1476 {
1477 ESelection aSel = pActiveView->GetSelection();
1478 xub_StrLen nPos = aSel.nStartPos;
1479 OUString aFormula = pEngine->GetText(0);
1480 if ( nPos < aFormula.getLength() && aFormula[nPos] == ')' )
1481 return true;
1482 }
1483 return false;
1484 }
1485
1486 void ScInputHandler::SkipClosingPar()
1487 {
1488 // this is called when a ')' is typed and the cursor is before a ')'
1489 // that can be overwritten -> just set the cursor behind the ')'
1490
1491 EditView* pActiveView = pTopView ? pTopView : pTableView;
1492 if (pActiveView)
1493 {
1494 ESelection aSel = pActiveView->GetSelection();
1495 ++aSel.nStartPos;
1496 ++aSel.nEndPos;
1497
1498 // this is in a formula (only one paragraph), so the selection
1499 // can be used directly for the TopView
1500
1501 if ( pTopView )
1502 pTopView->SetSelection( aSel );
1503 if ( pTableView )
1504 pTableView->SetSelection( aSel );
1505 }
1506
1507 OSL_ENSURE(nAutoPar, "SkipClosingPar: count is wrong");
1508 --nAutoPar;
1509 }
1510
1511 //
1512 // Auto-Eingabe
1513 //
1514
1515 void ScInputHandler::GetColData()
1516 {
1517 if ( pActiveViewSh )
1518 {
1519 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
1520
1521 if ( pColumnData )
1522 pColumnData->clear();
1523 else
1524 {
1525 pColumnData = new ScTypedCaseStrSet;
1526 miAutoPosColumn = pColumnData->end();
1527 }
1528
1529 std::vector<ScTypedStrData> aEntries;
1530 pDoc->GetDataEntries(
1531 aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), true, aEntries, true);
1532 if (!aEntries.empty())
1533 pColumnData->insert(aEntries.begin(), aEntries.end());
1534 }
1535 }
1536
1537 void ScInputHandler::UseColData() // beim Tippen
1538 {
1539 EditView* pActiveView = pTopView ? pTopView : pTableView;
1540 if ( pActiveView && pColumnData )
1541 {
1542 // nur anpassen, wenn Cursor am Ende steht
1543
1544 ESelection aSel = pActiveView->GetSelection();
1545 aSel.Adjust();
1546
1547 sal_Int32 nParCnt = pEngine->GetParagraphCount();
1548 if ( aSel.nEndPara+1 == nParCnt )
1549 {
1550 xub_StrLen nParLen = pEngine->GetTextLen( aSel.nEndPara );
1551 if ( aSel.nEndPos == nParLen )
1552 {
1553 OUString aText = GetEditText(pEngine);
1554 if (!aText.isEmpty())
1555 {
1556 OUString aNew;
1557 miAutoPosColumn = pColumnData->end();
1558 miAutoPosColumn = findText(*pColumnData, miAutoPosColumn, aText, aNew, false);
1559 if (miAutoPosColumn != pColumnData->end())
1560 {
1561 // durch dBase Import etc. koennen Umbrueche im String sein,
1562 // das wuerde hier mehrere Absaetze ergeben -> nicht gut
1563 //! GetExactMatch funktioniert dann auch nicht
1564 lcl_RemoveLineEnd( aNew );
1565
1566 // Absaetze beibehalten, nur den Rest anfuegen
1567 //! genaue Ersetzung im EnterHandler !!!
1568
1569 // ein Space zwischen Absaetzen:
1570 sal_Int32 nEdLen = pEngine->GetTextLen() + nParCnt - 1;
1571 OUString aIns = aNew.copy(nEdLen);
1572
1573 // selection must be "backwards", so the cursor stays behind the last
1574 // typed character
1575 ESelection aSelection( aSel.nEndPara, aSel.nEndPos + aIns.getLength(),
1576 aSel.nEndPara, aSel.nEndPos );
1577
1578 // when editing in input line, apply to both edit views
1579 if ( pTableView )
1580 {
1581 pTableView->InsertText( aIns, false );
1582 pTableView->SetSelection( aSelection );
1583 }
1584 if ( pTopView )
1585 {
1586 pTopView->InsertText( aIns, false );
1587 pTopView->SetSelection( aSelection );
1588 }
1589
1590 aAutoSearch = aText; // zum Weitersuchen - nAutoPos ist gesetzt
1591
1592 if (aText.getLength() == aNew.getLength())
1593 {
1594 // Wenn der eingegebene Text gefunden wurde, TAB nur dann
1595 // verschlucken, wenn noch etwas kommt
1596
1597 OUString aDummy;
1598 ScTypedCaseStrSet::const_iterator itNextPos =
1599 findText(*pColumnData, miAutoPosColumn, aText, aDummy, false);
1600 bUseTab = itNextPos != pColumnData->end();
1601 }
1602 else
1603 bUseTab = true;
1604 }
1605 }
1606 }
1607 }
1608 }
1609 }
1610
1611 void ScInputHandler::NextAutoEntry( bool bBack )
1612 {
1613 EditView* pActiveView = pTopView ? pTopView : pTableView;
1614 if ( pActiveView && pColumnData )
1615 {
1616 if (miAutoPosColumn != pColumnData->end() && !aAutoSearch.isEmpty())
1617 {
1618 // stimmt die Selektion noch? (kann per Maus geaendert sein)
1619
1620 ESelection aSel = pActiveView->GetSelection();
1621 aSel.Adjust();
1622 sal_Int32 nParCnt = pEngine->GetParagraphCount();
1623 if ( aSel.nEndPara+1 == nParCnt && aSel.nStartPara == aSel.nEndPara )
1624 {
1625 OUString aText = GetEditText(pEngine);
1626 xub_StrLen nSelLen = aSel.nEndPos - aSel.nStartPos;
1627 xub_StrLen nParLen = pEngine->GetTextLen( aSel.nEndPara );
1628 if ( aSel.nEndPos == nParLen && aText.getLength() == aAutoSearch.getLength() + nSelLen )
1629 {
1630 OUString aNew;
1631 ScTypedCaseStrSet::const_iterator itNew =
1632 findText(*pColumnData, miAutoPosColumn, aAutoSearch, aNew, bBack);
1633
1634 if (itNew != pColumnData->end())
1635 {
1636 // match found!
1637 miAutoPosColumn = itNew;
1638 bInOwnChange = true; // disable ModifyHdl (reset below)
1639
1640 lcl_RemoveLineEnd( aNew );
1641 OUString aIns = aNew.copy(aAutoSearch.getLength());
1642
1643 // when editing in input line, apply to both edit views
1644 if ( pTableView )
1645 {
1646 pTableView->DeleteSelected();
1647 pTableView->InsertText( aIns, false );
1648 pTableView->SetSelection( ESelection(
1649 aSel.nEndPara, aSel.nStartPos + aIns.getLength(),
1650 aSel.nEndPara, aSel.nStartPos ) );
1651 }
1652 if ( pTopView )
1653 {
1654 pTopView->DeleteSelected();
1655 pTopView->InsertText( aIns, false );
1656 pTopView->SetSelection( ESelection(
1657 aSel.nEndPara, aSel.nStartPos + aIns.getLength(),
1658 aSel.nEndPara, aSel.nStartPos ) );
1659 }
1660
1661 bInOwnChange = false;
1662 }
1663 }
1664 }
1665 }
1666 }
1667
1668 // bei Tab wird vorher immer HideCursor gerufen
1669
1670 if (pActiveView)
1671 pActiveView->ShowCursor();
1672 }
1673
1674 //
1675 // Klammern hervorheben
1676 //
1677
1678 void ScInputHandler::UpdateParenthesis()
1679 {
1680 // Klammern suchen
1681
1682 //! Klammer-Hervorhebung einzeln abschaltbar ????
1683
1684 bool bFound = false;
1685 if ( bFormulaMode && eMode != SC_INPUT_TOP )
1686 {
1687 if ( pTableView && !pTableView->HasSelection() ) // Selektion ist immer unten
1688 {
1689 ESelection aSel = pTableView->GetSelection();
1690 if (aSel.nStartPos)
1691 {
1692 // Das Zeichen links vom Cursor wird angeschaut
1693
1694 xub_StrLen nPos = aSel.nStartPos - 1;
1695 OUString aFormula = pEngine->GetText(0);
1696 sal_Unicode c = aFormula[nPos];
1697 if ( c == '(' || c == ')' )
1698 {
1699 sal_Int32 nOther = lcl_MatchParenthesis( aFormula, nPos );
1700 if ( nOther != -1 )
1701 {
1702 SfxItemSet aSet( pEngine->GetEmptyItemSet() );
1703 aSet.Put( SvxWeightItem( WEIGHT_BOLD, EE_CHAR_WEIGHT ) );
1704 //! Unterscheidung, wenn die Zelle schon fett ist !!!!
1705
1706 if (bParenthesisShown)
1707 {
1708 // alte Hervorhebung wegnehmen
1709 sal_Int32 nCount = pEngine->GetParagraphCount();
1710 for (sal_Int32 i=0; i<nCount; i++)
1711 pEngine->QuickRemoveCharAttribs( i, EE_CHAR_WEIGHT );
1712 }
1713
1714 ESelection aSelThis( 0,nPos, 0,nPos+1 );
1715 pEngine->QuickSetAttribs( aSet, aSelThis );
1716 ESelection aSelOther( 0,nOther, 0,nOther+1 );
1717 pEngine->QuickSetAttribs( aSet, aSelOther );
1718
1719 // Dummy-InsertText fuer Update und Paint (Selektion ist leer)
1720 pTableView->InsertText( EMPTY_OUSTRING, false );
1721
1722 bFound = true;
1723 }
1724 }
1725 }
1726
1727 // mark parenthesis right of cursor if it will be overwritten (nAutoPar)
1728 // with different color (COL_LIGHTBLUE) ??
1729 }
1730 }
1731
1732 // alte Hervorhebung wegnehmen, wenn keine neue gesetzt
1733
1734 if ( bParenthesisShown && !bFound && pTableView )
1735 {
1736 sal_Int32 nCount = pEngine->GetParagraphCount();
1737 for (sal_Int32 i=0; i<nCount; i++)
1738 pTableView->RemoveCharAttribs( i, EE_CHAR_WEIGHT );
1739 }
1740
1741 bParenthesisShown = bFound;
1742 }
1743
1744 void ScInputHandler::ViewShellGone(ScTabViewShell* pViewSh) // wird synchron aufgerufen!
1745 {
1746 if ( pViewSh == pActiveViewSh )
1747 {
1748 delete pLastState;
1749 pLastState = NULL;
1750 pLastPattern = NULL;
1751 }
1752
1753 if ( pViewSh == pRefViewSh )
1754 {
1755 //! Die Eingabe kommt aus dem EnterHandler nicht mehr an
1756 // Trotzdem wird immerhin der Editmodus beendet
1757
1758 EnterHandler();
1759 bFormulaMode = false;
1760 pRefViewSh = NULL;
1761 SFX_APP()->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
1762 SC_MOD()->SetRefInputHdl(NULL);
1763 if (pInputWin)
1764 pInputWin->SetFormulaMode(false);
1765 UpdateAutoCorrFlag();
1766 }
1767
1768 pActiveViewSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
1769
1770 if ( pActiveViewSh && pActiveViewSh == pViewSh )
1771 {
1772 OSL_FAIL("pActiveViewSh weg");
1773 pActiveViewSh = NULL;
1774 }
1775
1776 if ( SC_MOD()->GetInputOptions().GetTextWysiwyg() )
1777 UpdateRefDevice(); // don't keep old document's printer as RefDevice
1778 }
1779
1780 void ScInputHandler::UpdateActiveView()
1781 {
1782 ImplCreateEditEngine();
1783
1784 // #i20588# Don't rely on focus to find the active edit view. Instead, the
1785 // active pane at the start of editing is now stored (GetEditActivePart).
1786 // GetActiveWin (the currently active pane) fails for ref input across the
1787 // panes of a split view.
1788
1789 Window* pShellWin = pActiveViewSh ?
1790 pActiveViewSh->GetWindowByPos( pActiveViewSh->GetViewData()->GetEditActivePart() ) :
1791 NULL;
1792
1793 sal_uInt16 nCount = pEngine->GetViewCount();
1794 if (nCount > 0)
1795 {
1796 pTableView = pEngine->GetView(0);
1797 for (sal_uInt16 i=1; i<nCount; i++)
1798 {
1799 EditView* pThis = pEngine->GetView(i);
1800 Window* pWin = pThis->GetWindow();
1801 if ( pWin==pShellWin )
1802 pTableView = pThis;
1803 }
1804 }
1805 else
1806 pTableView = NULL;
1807
1808 if (pInputWin && eMode == SC_INPUT_TOP )
1809 pTopView = pInputWin->GetEditView();
1810 else
1811 pTopView = NULL;
1812 }
1813
1814 void ScInputHandler::StopInputWinEngine( bool bAll )
1815 {
1816 if (pInputWin)
1817 pInputWin->StopEditEngine( bAll );
1818
1819 pTopView = NULL; // invalid now
1820 }
1821
1822 EditView* ScInputHandler::GetActiveView()
1823 {
1824 UpdateActiveView();
1825 return pTopView ? pTopView : pTableView;
1826 }
1827
1828 void ScInputHandler::ForgetLastPattern()
1829 {
1830 pLastPattern = NULL;
1831 if ( !pLastState && pActiveViewSh )
1832 pActiveViewSh->UpdateInputHandler( true ); // Status neu holen
1833 else
1834 NotifyChange( pLastState, true );
1835 }
1836
1837 void ScInputHandler::UpdateAdjust( sal_Unicode cTyped )
1838 {
1839 SvxAdjust eSvxAdjust;
1840 switch (eAttrAdjust)
1841 {
1842 case SVX_HOR_JUSTIFY_STANDARD:
1843 {
1844 bool bNumber = false;
1845 if (cTyped) // neu angefangen
1846 bNumber = (cTyped>='0' && cTyped<='9'); // nur Ziffern sind Zahlen
1847 else if ( pActiveViewSh )
1848 {
1849 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
1850 bNumber = ( pDoc->GetCellType( aCursorPos ) == CELLTYPE_VALUE );
1851 }
1852 eSvxAdjust = bNumber ? SVX_ADJUST_RIGHT : SVX_ADJUST_LEFT;
1853 }
1854 break;
1855 case SVX_HOR_JUSTIFY_BLOCK:
1856 eSvxAdjust = SVX_ADJUST_BLOCK;
1857 break;
1858 case SVX_HOR_JUSTIFY_CENTER:
1859 eSvxAdjust = SVX_ADJUST_CENTER;
1860 break;
1861 case SVX_HOR_JUSTIFY_RIGHT:
1862 eSvxAdjust = SVX_ADJUST_RIGHT;
1863 break;
1864 default: // SVX_HOR_JUSTIFY_LEFT
1865 eSvxAdjust = SVX_ADJUST_LEFT;
1866 break;
1867 }
1868
1869 bool bAsianVertical = pLastPattern &&
1870 ((const SfxBoolItem&)pLastPattern->GetItem( ATTR_STACKED )).GetValue() &&
1871 ((const SfxBoolItem&)pLastPattern->GetItem( ATTR_VERTICAL_ASIAN )).GetValue();
1872 if ( bAsianVertical )
1873 {
1874 // always edit at top of cell -> LEFT when editing vertically
1875 eSvxAdjust = SVX_ADJUST_LEFT;
1876 }
1877
1878 pEditDefaults->Put( SvxAdjustItem( eSvxAdjust, EE_PARA_JUST ) );
1879 pEngine->SetDefaults( *pEditDefaults );
1880
1881 nEditAdjust = sal::static_int_cast<sal_uInt16>(eSvxAdjust); //! set at ViewData or with PostEditView
1882
1883 pEngine->SetVertical( bAsianVertical );
1884 }
1885
1886 void ScInputHandler::RemoveAdjust()
1887 {
1888 // harte Ausrichtungs-Attribute loeschen
1889
1890 bool bUndo = pEngine->IsUndoEnabled();
1891 if ( bUndo )
1892 pEngine->EnableUndo( false );
1893
1894 // non-default paragraph attributes (e.g. from clipboard)
1895 // must be turned into character attributes
1896 pEngine->RemoveParaAttribs();
1897
1898 if ( bUndo )
1899 pEngine->EnableUndo( true );
1900
1901 }
1902
1903 void ScInputHandler::RemoveRangeFinder()
1904 {
1905 // pRangeFindList und Farben loeschen
1906
1907 pEngine->SetUpdateMode(false);
1908 sal_Int32 nCount = pEngine->GetParagraphCount(); // koennte gerade neu eingefuegt worden sein
1909 for (sal_Int32 i=0; i<nCount; i++)
1910 pEngine->QuickRemoveCharAttribs( i, EE_CHAR_COLOR );
1911 pEngine->SetUpdateMode(true);
1912
1913 EditView* pActiveView = pTopView ? pTopView : pTableView;
1914 pActiveView->ShowCursor( false, true );
1915
1916 DeleteRangeFinder(); // loescht die Liste und die Markierungen auf der Tabelle
1917 }
1918
1919 bool ScInputHandler::StartTable( sal_Unicode cTyped, bool bFromCommand, bool bInputActivated )
1920 {
1921 bool bNewTable = false;
1922
1923 if (bModified || !ValidCol(aCursorPos.Col()))
1924 return false;
1925
1926 if (pActiveViewSh)
1927 {
1928 ImplCreateEditEngine();
1929 UpdateActiveView();
1930 SyncViews();
1931
1932 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocShell()->GetDocument();
1933
1934 const ScMarkData& rMark = pActiveViewSh->GetViewData()->GetMarkData();
1935 ScEditableTester aTester;
1936 if ( rMark.IsMarked() || rMark.IsMultiMarked() )
1937 aTester.TestSelection( pDoc, rMark );
1938 else
1939 aTester.TestSelectedBlock(
1940 pDoc, aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Col(), aCursorPos.Row(), rMark );
1941
1942 bool bStartInputMode = true;
1943
1944 if (!aTester.IsEditable())
1945 {
1946 bProtected = true;
1947 // We allow read-only input mode activation regardless
1948 // whether it's part of an array or not or whether explicit cell
1949 // activation is requested (double-click or F2) or a click in input
1950 // line.
1951 bool bShowError = (!bInputActivated || aTester.GetMessageId() != STR_PROTECTIONERR) &&
1952 !pActiveViewSh->GetViewData()->GetDocShell()->IsReadOnly();
1953 if (bShowError)
1954 {
1955 eMode = SC_INPUT_NONE;
1956 StopInputWinEngine( true );
1957 UpdateFormulaMode();
1958 if ( pActiveViewSh && ( !bFromCommand || !bCommandErrorShown ) )
1959 {
1960 // Prevent repeated error messages for the same cell from command events
1961 // (for keyboard events, multiple messages are wanted).
1962 // Set the flag before showing the error message because the command handler
1963 // for the next IME command may be called when showing the dialog.
1964 if ( bFromCommand )
1965 bCommandErrorShown = true;
1966
1967 pActiveViewSh->GetActiveWin()->GrabFocus();
1968 pActiveViewSh->ErrorMessage(aTester.GetMessageId());
1969 }
1970 bStartInputMode = false;
1971 }
1972 }
1973
1974 if (bStartInputMode)
1975 {
1976 // UpdateMode is enabled again in ScViewData::SetEditEngine (and not needed otherwise)
1977 pEngine->SetUpdateMode( false );
1978
1979 // Attribute in EditEngine uebernehmen
1980
1981 const ScPatternAttr* pPattern = pDoc->GetPattern( aCursorPos.Col(),
1982 aCursorPos.Row(),
1983 aCursorPos.Tab() );
1984 if (pPattern != pLastPattern)
1985 {
1986 // Prozent-Format?
1987
1988 const SfxItemSet& rAttrSet = pPattern->GetItemSet();
1989 const SfxPoolItem* pItem;
1990
1991 if ( SFX_ITEM_SET == rAttrSet.GetItemState( ATTR_VALUE_FORMAT, true, &pItem ) )
1992 {
1993 sal_uLong nFormat = ((const SfxUInt32Item*)pItem)->GetValue();
1994 bCellHasPercentFormat = ( NUMBERFORMAT_PERCENT ==
1995 pDoc->GetFormatTable()->GetType( nFormat ) );
1996 }
1997 else
1998 bCellHasPercentFormat = false; // Default: kein Prozent
1999
2000 // Gueltigkeit angegeben?
2001
2002 if ( SFX_ITEM_SET == rAttrSet.GetItemState( ATTR_VALIDDATA, true, &pItem ) )
2003 nValidation = ((const SfxUInt32Item*)pItem)->GetValue();
2004 else
2005 nValidation = 0;
2006
2007 // EditEngine Defaults
2008
2009 // Hier auf keinen Fall SetParaAttribs, weil die EditEngine evtl.
2010 // schon gefuellt ist (bei Edit-Zellen).
2011 // SetParaAttribs wuerde dann den Inhalt aendern
2012
2013 //! The SetDefaults is now (since MUST/src602
2014 //! EditEngine changes) implemented as a SetParaAttribs.
2015 //! Any problems?
2016
2017 pPattern->FillEditItemSet( pEditDefaults );
2018 pEngine->SetDefaults( *pEditDefaults );
2019 pLastPattern = pPattern;
2020 bLastIsSymbol = pPattern->IsSymbolFont();
2021
2022 // Background color must be known for automatic font color.
2023 // For transparent cell background, the document background color must be used.
2024
2025 Color aBackCol = ((const SvxBrushItem&)
2026 pPattern->GetItem( ATTR_BACKGROUND )).GetColor();
2027 ScModule* pScMod = SC_MOD();
2028 if ( aBackCol.GetTransparency() > 0 ||
2029 Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
2030 aBackCol.SetColor( pScMod->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor );
2031 pEngine->SetBackgroundColor( aBackCol );
2032
2033 // Ausrichtung
2034
2035 eAttrAdjust = (SvxCellHorJustify)((const SvxHorJustifyItem&)pPattern->
2036 GetItem(ATTR_HOR_JUSTIFY)).GetValue();
2037 if ( eAttrAdjust == SVX_HOR_JUSTIFY_REPEAT &&
2038 static_cast<const SfxBoolItem&>(pPattern->GetItem(ATTR_LINEBREAK)).GetValue() )
2039 {
2040 // #i31843# "repeat" with "line breaks" is treated as default alignment
2041 eAttrAdjust = SVX_HOR_JUSTIFY_STANDARD;
2042 }
2043 }
2044
2045 // UpdateSpellSettings enables online spelling if needed
2046 // -> also call if attributes are unchanged
2047
2048 UpdateSpellSettings( true ); // uses pLastPattern
2049
2050 // Edit-Engine fuellen
2051
2052 OUString aStr;
2053 if (bTextValid)
2054 {
2055 pEngine->SetText(aCurrentText);
2056 aStr = aCurrentText;
2057 bTextValid = false;
2058 aCurrentText = OUString();
2059 }
2060 else
2061 aStr = GetEditText(pEngine);
2062
2063 if (aStr.startsWith("{=") && aStr.endsWith("}") ) // Matrix-Formel ?
2064 {
2065 aStr = aStr.copy(1, aStr.getLength() -2);
2066 pEngine->SetText(aStr);
2067 if ( pInputWin )
2068 pInputWin->SetTextString(aStr);
2069 }
2070
2071 UpdateAdjust( cTyped );
2072
2073 if ( bAutoComplete )
2074 GetColData();
2075
2076 if ( !aStr.isEmpty() && ( aStr[0] == '=' || aStr[0] == '+' || aStr[0] == '-' ) &&
2077 !cTyped && !bCreatingFuncView )
2078 InitRangeFinder(aStr); // Formel wird editiert -> RangeFinder
2079
2080 bNewTable = true; // -> PostEditView-Aufruf
2081 }
2082 }
2083
2084 if (!bProtected && pInputWin)
2085 pInputWin->SetOkCancelMode();
2086
2087 return bNewTable;
2088 }
2089
2090 static void lcl_SetTopSelection( EditView* pEditView, ESelection& rSel )
2091 {
2092 OSL_ENSURE( rSel.nStartPara==0 && rSel.nEndPara==0, "SetTopSelection: Para != 0" );
2093
2094 EditEngine* pEngine = pEditView->GetEditEngine();
2095 sal_Int32 nCount = pEngine->GetParagraphCount();
2096 if (nCount > 1)
2097 {
2098 xub_StrLen nParLen = pEngine->GetTextLen(rSel.nStartPara);
2099 while (rSel.nStartPos > nParLen && rSel.nStartPara+1 < nCount)
2100 {
2101 rSel.nStartPos -= nParLen + 1; // incl. Leerzeichen vom Umbruch
2102 nParLen = pEngine->GetTextLen(++rSel.nStartPara);
2103 }
2104
2105 nParLen = pEngine->GetTextLen(rSel.nEndPara);
2106 while (rSel.nEndPos > nParLen && rSel.nEndPara+1 < nCount)
2107 {
2108 rSel.nEndPos -= nParLen + 1; // incl. Leerzeichen vom Umbruch
2109 nParLen = pEngine->GetTextLen(++rSel.nEndPara);
2110 }
2111 }
2112
2113 ESelection aSel = pEditView->GetSelection();
2114
2115 if ( rSel.nStartPara != aSel.nStartPara || rSel.nEndPara != aSel.nEndPara
2116 || rSel.nStartPos != aSel.nStartPos || rSel.nEndPos != aSel.nEndPos )
2117 pEditView->SetSelection( rSel );
2118 }
2119
2120 void ScInputHandler::SyncViews( EditView* pSourceView )
2121 {
2122 if (pSourceView)
2123 {
2124 bool bSelectionForTopView = false;
2125 if (pTopView && pTopView != pSourceView)
2126 bSelectionForTopView = true;
2127 bool bSelectionForTableView = false;
2128 if (pTableView && pTableView != pSourceView)
2129 bSelectionForTableView = true;
2130 if (bSelectionForTopView || bSelectionForTableView)
2131 {
2132 ESelection aSel(pSourceView->GetSelection());
2133 if (bSelectionForTopView)
2134 pTopView->SetSelection(aSel);
2135 if (bSelectionForTableView)
2136 lcl_SetTopSelection(pTableView, aSel);
2137 }
2138 }
2139 // Only sync selection from topView if we are actually editiing there
2140 else if (pTopView && pTableView)
2141 {
2142 ESelection aSel(pTopView->GetSelection());
2143 lcl_SetTopSelection( pTableView, aSel );
2144 }
2145 }
2146
2147 IMPL_LINK_NOARG(ScInputHandler, ModifyHdl)
2148 {
2149 if ( !bInOwnChange && ( eMode==SC_INPUT_TYPE || eMode==SC_INPUT_TABLE ) &&
2150 pEngine && pEngine->GetUpdateMode() && pInputWin )
2151 {
2152 // update input line from ModifyHdl for changes that are not
2153 // wrapped by DataChanging/DataChanged calls (like Drag&Drop)
2154
2155 OUString aText;
2156 if ( pInputWin->IsMultiLineInput() )
2157 aText = ScEditUtil::GetMultilineString(*pEngine);
2158 else
2159 aText = GetEditText(pEngine);
2160 lcl_RemoveTabs(aText);
2161 pInputWin->SetTextString(aText);
2162 }
2163 return 0;
2164 }
2165
2166 bool ScInputHandler::DataChanging( sal_Unicode cTyped, bool bFromCommand ) // return true = new view created
2167 {
2168 if (pActiveViewSh)
2169 pActiveViewSh->GetViewData()->SetPasteMode( SC_PASTE_NONE );
2170 bInOwnChange = true; // disable ModifyHdl (reset in DataChanged)
2171
2172 if ( eMode == SC_INPUT_NONE )
2173 return StartTable( cTyped, bFromCommand, false );
2174 else
2175 return false;
2176 }
2177
2178 void ScInputHandler::DataChanged( bool bFromTopNotify, bool bSetModified )
2179 {
2180 ImplCreateEditEngine();
2181
2182 if (eMode==SC_INPUT_NONE)
2183 eMode = SC_INPUT_TYPE;
2184
2185 if ( eMode == SC_INPUT_TOP && pTopView && !bFromTopNotify )
2186 {
2187 // table EditEngine is formatted below, input line needs formatting after paste
2188 // #i20282# not when called from the input line's modify handler
2189 pTopView->GetEditEngine()->QuickFormatDoc( true );
2190
2191 // #i23720# QuickFormatDoc hides the cursor, but can't show it again because it
2192 // can't safely access the EditEngine's current view, so the cursor has to be
2193 // shown again here.
2194 pTopView->ShowCursor();
2195 }
2196
2197 if (bSetModified)
2198 bModified = true;
2199 bSelIsRef = false;
2200
2201 if ( pRangeFindList && !bInRangeUpdate )
2202 RemoveRangeFinder(); // Attribute und Markierung loeschen
2203
2204 UpdateParenthesis(); // Hervorhebung der Klammern neu
2205
2206 if (eMode==SC_INPUT_TYPE || eMode==SC_INPUT_TABLE)
2207 {
2208 OUString aText;
2209 if ( pInputWin && pInputWin->IsMultiLineInput() )
2210 aText = ScEditUtil::GetMultilineString(*pEngine);
2211 else
2212 aText = GetEditText(pEngine);
2213 lcl_RemoveTabs(aText);
2214
2215 if ( pInputWin )
2216 pInputWin->SetTextString( aText );
2217 }
2218
2219 // wenn der Cursor vor dem Absatzende steht, werden Teile rechts rausgeschoben
2220 // (unabhaengig von eMode) -> View anpassen!
2221 // wenn der Cursor am Ende steht, reicht der Status-Handler an der ViewData
2222
2223 // first make sure the status handler is called now if the cursor
2224 // is outside the visible area
2225 pEngine->QuickFormatDoc();
2226
2227 EditView* pActiveView = pTopView ? pTopView : pTableView;
2228 if (pActiveView && pActiveViewSh)
2229 {
2230 ScViewData* pViewData = pActiveViewSh->GetViewData();
2231
2232 bool bNeedGrow = ( nEditAdjust != SVX_ADJUST_LEFT ); // rechtsbuendig immer
2233 if (!bNeedGrow)
2234 {
2235 // Cursor vor dem Ende?
2236 ESelection aSel = pActiveView->GetSelection();
2237 aSel.Adjust();
2238 bNeedGrow = ( aSel.nEndPos != pEngine->GetTextLen(aSel.nEndPara) );
2239 }
2240 if (!bNeedGrow)
2241 {
2242 bNeedGrow = pViewData->GetDocument()->IsLayoutRTL( pViewData->GetTabNo() );
2243 }
2244 if (bNeedGrow)
2245 {
2246 // adjust inplace view
2247 pViewData->EditGrowY();
2248 pViewData->EditGrowX();
2249 }
2250 }
2251
2252 UpdateFormulaMode();
2253 bTextValid = false; // Aenderungen sind nur in der Edit-Engine
2254 bInOwnChange = false;
2255 }
2256
2257 void ScInputHandler::UpdateFormulaMode()
2258 {
2259 SfxApplication* pSfxApp = SFX_APP();
2260
2261 bool bIsFormula = !bProtected && pEngine->GetParagraphCount() == 1;
2262 if (bIsFormula)
2263 {
2264 const OUString& rText = pEngine->GetText(0);
2265 bIsFormula = !rText.isEmpty() &&
2266 (rText[0] == '=' || rText[0] == '+' || rText[0] == '-');
2267 }
2268
2269 if ( bIsFormula )
2270 {
2271 if (!bFormulaMode)
2272 {
2273 bFormulaMode = true;
2274 pRefViewSh = pActiveViewSh;
2275 pSfxApp->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
2276 SC_MOD()->SetRefInputHdl(this);
2277 if (pInputWin)
2278 pInputWin->SetFormulaMode(true);
2279
2280 if ( bAutoComplete )
2281 GetFormulaData();
2282
2283 UpdateParenthesis();
2284 UpdateAutoCorrFlag();
2285 }
2286 }
2287 else // ausschalten
2288 {
2289 if (bFormulaMode)
2290 {
2291 ShowRefFrame();
2292 bFormulaMode = false;
2293 pRefViewSh = NULL;
2294 pSfxApp->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
2295 SC_MOD()->SetRefInputHdl(NULL);
2296 if (pInputWin)
2297 pInputWin->SetFormulaMode(false);
2298 UpdateAutoCorrFlag();
2299 }
2300 }
2301 }
2302
2303 void ScInputHandler::ShowRefFrame()
2304 {
2305 // Modifying pActiveViewSh here would interfere with the bInEnterHandler / bRepeat
2306 // checks in NotifyChange, and lead to keeping the wrong value in pActiveViewSh.
2307 // A local variable is used instead.
2308 ScTabViewShell* pVisibleSh = PTR_CAST( ScTabViewShell, SfxViewShell::Current() );
2309 if ( pRefViewSh && pRefViewSh != pVisibleSh )
2310 {
2311 bool bFound = false;
2312 SfxViewFrame* pRefFrame = pRefViewSh->GetViewFrame();
2313 SfxViewFrame* pOneFrame = SfxViewFrame::GetFirst();
2314 while ( pOneFrame && !bFound )
2315 {
2316 if ( pOneFrame == pRefFrame )
2317 bFound = true;
2318 pOneFrame = SfxViewFrame::GetNext( *pOneFrame );
2319 }
2320
2321 if (bFound)
2322 {
2323 // Hier wird sich darauf verlassen, dass Activate synchron funktioniert
2324 // (dabei wird pActiveViewSh umgesetzt)
2325
2326 pRefViewSh->SetActive(); // Appear und SetViewFrame
2327
2328 // pLastState wird im NotifyChange aus dem Activate richtig gesetzt
2329 }
2330 else
2331 {
2332 OSL_FAIL("ViewFrame fuer Referenzeingabe ist nicht mehr da");
2333 }
2334 }
2335 }
2336
2337 void ScInputHandler::RemoveSelection()
2338 {
2339 EditView* pActiveView = pTopView ? pTopView : pTableView;
2340 if (!pActiveView)
2341 return;
2342
2343 ESelection aSel = pActiveView->GetSelection();
2344 aSel.nStartPara = aSel.nEndPara;
2345 aSel.nStartPos = aSel.nEndPos;
2346 if (pTableView)
2347 pTableView->SetSelection( aSel );
2348 if (pTopView)
2349 pTopView->SetSelection( aSel );
2350 }
2351
2352 void ScInputHandler::InvalidateAttribs()
2353 {
2354 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
2355 if (pViewFrm)
2356 {
2357 SfxBindings& rBindings = pViewFrm->GetBindings();
2358
2359 rBindings.Invalidate( SID_ATTR_CHAR_FONT );
2360 rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
2361 rBindings.Invalidate( SID_ATTR_CHAR_COLOR );
2362
2363 rBindings.Invalidate( SID_ATTR_CHAR_WEIGHT );
2364 rBindings.Invalidate( SID_ATTR_CHAR_POSTURE );
2365 rBindings.Invalidate( SID_ATTR_CHAR_UNDERLINE );
2366 rBindings.Invalidate( SID_ULINE_VAL_NONE );
2367 rBindings.Invalidate( SID_ULINE_VAL_SINGLE );
2368 rBindings.Invalidate( SID_ULINE_VAL_DOUBLE );
2369 rBindings.Invalidate( SID_ULINE_VAL_DOTTED );
2370
2371 rBindings.Invalidate( SID_HYPERLINK_GETLINK );
2372
2373 rBindings.Invalidate( SID_ATTR_CHAR_KERNING );
2374 rBindings.Invalidate( SID_SET_SUPER_SCRIPT );
2375 rBindings.Invalidate( SID_SET_SUB_SCRIPT );
2376 rBindings.Invalidate( SID_ATTR_CHAR_STRIKEOUT );
2377 rBindings.Invalidate( SID_ATTR_CHAR_SHADOWED );
2378 }
2379 }
2380
2381 //
2382 // --------------- public Methoden --------------------------------------------
2383 //
2384
2385 void ScInputHandler::SetMode( ScInputMode eNewMode )
2386 {
2387 if ( eMode == eNewMode )
2388 return;
2389
2390 ImplCreateEditEngine();
2391
2392 if (bProtected)
2393 {
2394 eMode = SC_INPUT_NONE;
2395 StopInputWinEngine( true );
2396 if (pActiveViewSh)
2397 pActiveViewSh->GetActiveWin()->GrabFocus();
2398 return;
2399 }
2400
2401 if (eNewMode != SC_INPUT_NONE && pActiveViewSh)
2402 // Disable paste mode when edit mode starts.
2403 pActiveViewSh->GetViewData()->SetPasteMode( SC_PASTE_NONE );
2404
2405 bInOwnChange = true; // disable ModifyHdl (reset below)
2406
2407 ScInputMode eOldMode = eMode;
2408 eMode = eNewMode;
2409 if (eOldMode == SC_INPUT_TOP && eNewMode != eOldMode)
2410 StopInputWinEngine( false );
2411
2412 if (eMode==SC_INPUT_TOP || eMode==SC_INPUT_TABLE)
2413 {
2414 if (eOldMode == SC_INPUT_NONE) // not when switching between modes
2415 {
2416 if (StartTable(0, false, eMode == SC_INPUT_TABLE))
2417 {
2418 if (pActiveViewSh)
2419 pActiveViewSh->GetViewData()->GetDocShell()->PostEditView( pEngine, aCursorPos );
2420 }
2421 }
2422
2423 sal_Int32 nPara = pEngine->GetParagraphCount()-1;
2424 sal_Int32 nLen = pEngine->GetText(nPara).getLength();
2425 sal_uInt16 nCount = pEngine->GetViewCount();
2426
2427 for (sal_uInt16 i=0; i<nCount; i++)
2428 {
2429 if ( eMode == SC_INPUT_TABLE && eOldMode == SC_INPUT_TOP )
2430 {
2431 // Selektion bleibt
2432 }
2433 else
2434 {
2435 pEngine->GetView(i)->
2436 SetSelection( ESelection( nPara, nLen, nPara, nLen ) );
2437 }
2438 pEngine->GetView(i)->ShowCursor(false);
2439 }
2440 }
2441
2442 UpdateActiveView();
2443 if (eMode==SC_INPUT_TABLE || eMode==SC_INPUT_TYPE)
2444 {
2445 if (pTableView)
2446 pTableView->SetEditEngineUpdateMode(true);
2447 }
2448 else
2449 {
2450 if (pTopView)
2451 pTopView->SetEditEngineUpdateMode(true);
2452 }
2453
2454 if (eNewMode != eOldMode)
2455 UpdateFormulaMode();
2456
2457 bInOwnChange = false;
2458 }
2459
2460 //----------------------------------------------------------------------------------------
2461
2462 // lcl_IsNumber - true, wenn nur Ziffern (dann keine Autokorrektur)
2463
2464 static bool lcl_IsNumber(const OUString& rString)
2465 {
2466 sal_Int32 nLen = rString.getLength();
2467 for (sal_Int32 i=0; i<nLen; i++)
2468 {
2469 sal_Unicode c = rString[i];
2470 if ( c < '0' || c > '9' )
2471 return false;
2472 }
2473 return true;
2474 }
2475
2476 static void lcl_SelectionToEnd( EditView* pView )
2477 {
2478 if ( pView )
2479 {
2480 EditEngine* pEngine = pView->GetEditEngine();
2481 sal_Int32 nParCnt = pEngine->GetParagraphCount();
2482 if ( nParCnt == 0 )
2483 nParCnt = 1;
2484 ESelection aSel( nParCnt-1, pEngine->GetTextLen(nParCnt-1) ); // empty selection, cursor at the end
2485 pView->SetSelection( aSel );
2486 }
2487 }
2488
2489 void ScInputHandler::EnterHandler( sal_uInt8 nBlockMode )
2490 {
2491 // Bei Makro-Aufrufen fuer Gueltigkeit kann Tod und Teufel passieren,
2492 // darum dafuer sorgen, dass EnterHandler nicht verschachtelt gerufen wird:
2493
2494 if (bInEnterHandler) return;
2495 bInEnterHandler = true;
2496 bInOwnChange = true; // disable ModifyHdl (reset below)
2497
2498 ImplCreateEditEngine();
2499
2500 bool bMatrix = ( nBlockMode == SC_ENTER_MATRIX );
2501
2502 SfxApplication* pSfxApp = SFX_APP();
2503 EditTextObject* pObject = NULL;
2504 ScPatternAttr* pCellAttrs = NULL;
2505 bool bForget = false; // wegen Gueltigkeit streichen ?
2506
2507 OUString aString = GetEditText(pEngine);
2508 EditView* pActiveView = pTopView ? pTopView : pTableView;
2509 if (bModified && pActiveView && !aString.isEmpty() && !lcl_IsNumber(aString))
2510 {
2511 if (pColumnData && miAutoPosColumn != pColumnData->end())
2512 {
2513 // #i47125# If AutoInput appended something, do the final AutoCorrect
2514 // with the cursor at the end of the input.
2515
2516 lcl_SelectionToEnd(pTopView);
2517 lcl_SelectionToEnd(pTableView);
2518 }
2519
2520 Window* pFrameWin = pActiveViewSh ? pActiveViewSh->GetFrameWin() : NULL;
2521
2522 if (pTopView)
2523 pTopView->CompleteAutoCorrect(); // CompleteAutoCorrect fuer beide Views
2524 if (pTableView)
2525 pTableView->CompleteAutoCorrect(pFrameWin);
2526 aString = GetEditText(pEngine);
2527 }
2528 lcl_RemoveTabs(aString);
2529
2530 // Test, ob zulaessig (immer mit einfachem String)
2531
2532 if ( bModified && nValidation && pActiveViewSh )
2533 {
2534 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocument();
2535 const ScValidationData* pData = pDoc->GetValidationEntry( nValidation );
2536 if (pData && pData->HasErrMsg())
2537 {
2538 // #i67990# don't use pLastPattern in EnterHandler
2539 const ScPatternAttr* pPattern = pDoc->GetPattern( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
2540 bool bOk = pData->IsDataValid( aString, *pPattern, aCursorPos );
2541
2542 if (!bOk)
2543 {
2544 if ( pActiveViewSh ) // falls aus MouseButtonDown gekommen
2545 pActiveViewSh->StopMarking(); // (die InfoBox verschluckt das MouseButtonUp)
2546
2547 //! es gibt noch Probleme, wenn die Eingabe durch Aktivieren einer
2548 //! anderen View ausgeloest wurde
2549
2550 Window* pParent = Application::GetDefDialogParent();
2551 if ( pData->DoError( pParent, aString, aCursorPos ) )
2552 bForget = true; // Eingabe nicht uebernehmen
2553 }
2554 }
2555 }
2556
2557 // check for input into DataPilot table
2558
2559 if ( bModified && pActiveViewSh && !bForget )
2560 {
2561 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocument();
2562 ScDPObject* pDPObj = pDoc->GetDPAtCursor( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
2563 if ( pDPObj )
2564 {
2565 // any input within the DataPilot table is either a valid renaming
2566 // or an invalid action - normal cell input is always aborted
2567
2568 pActiveViewSh->DataPilotInput( aCursorPos, aString );
2569 bForget = true;
2570 }
2571 }
2572
2573 std::vector<editeng::MisspellRanges> aMisspellRanges;
2574 pEngine->CompleteOnlineSpelling();
2575 bool bSpellErrors = !bFormulaMode && pEngine->HasOnlineSpellErrors();
2576 if ( bSpellErrors )
2577 {
2578 // #i3820# If the spell checker flags numerical input as error,
2579 // it still has to be treated as number, not EditEngine object.
2580
2581 if ( pActiveViewSh )
2582 {
2583 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocument();
2584 // #i67990# don't use pLastPattern in EnterHandler
2585 const ScPatternAttr* pPattern = pDoc->GetPattern( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
2586 if (pPattern)
2587 {
2588 SvNumberFormatter* pFormatter = pDoc->GetFormatTable();
2589 // without conditional format, as in ScColumn::SetString
2590 sal_uInt32 nFormat = pPattern->GetNumberFormat( pFormatter );
2591 double nVal;
2592 if ( pFormatter->IsNumberFormat( aString, nFormat, nVal ) )
2593 {
2594 bSpellErrors = false; // ignore the spelling errors
2595 }
2596 }
2597 }
2598 }
2599
2600 // After RemoveAdjust, the EditView must not be repainted (has wrong font size etc).
2601 // SetUpdateMode must come after CompleteOnlineSpelling.
2602 // The view is hidden in any case below (Broadcast).
2603 pEngine->SetUpdateMode( false );
2604
2605 if ( bModified && !bForget ) // was wird eingeben (Text/Objekt) ?
2606 {
2607 sal_Int32 nParCnt = pEngine->GetParagraphCount();
2608 if ( nParCnt == 0 )
2609 nParCnt = 1;
2610
2611 bool bUniformAttribs = true;
2612 SfxItemSet aPara1Attribs = pEngine->GetAttribs(0, 0, pEngine->GetTextLen(0));
2613 for (sal_Int32 nPara = 1; nPara < nParCnt; ++nPara)
2614 {
2615 SfxItemSet aPara2Attribs = pEngine->GetAttribs(nPara, 0, pEngine->GetTextLen(nPara));
2616 if (!(aPara1Attribs == aPara2Attribs))
2617 {
2618 // paragraph format different from that of the 1st paragraph.
2619 bUniformAttribs = false;
2620 break;
2621 }
2622 }
2623
2624 ESelection aSel( 0, 0, nParCnt-1, pEngine->GetTextLen(nParCnt-1) );
2625 SfxItemSet aOldAttribs = pEngine->GetAttribs( aSel );
2626 const SfxPoolItem* pItem = NULL;
2627
2628 // find common (cell) attributes before RemoveAdjust
2629
2630 if ( pActiveViewSh && bUniformAttribs )
2631 {
2632 SfxItemSet* pCommonAttrs = NULL;
2633 for (sal_uInt16 nId = EE_CHAR_START; nId <= EE_CHAR_END; nId++)
2634 {
2635 SfxItemState eState = aOldAttribs.GetItemState( nId, false, &pItem );
2636 if ( eState == SFX_ITEM_SET &&
2637 nId != EE_CHAR_ESCAPEMENT && nId != EE_CHAR_PAIRKERNING &&
2638 nId != EE_CHAR_KERNING && nId != EE_CHAR_XMLATTRIBS &&
2639 *pItem != pEditDefaults->Get(nId) )
2640 {
2641 if ( !pCommonAttrs )
2642 pCommonAttrs = new SfxItemSet( pEngine->GetEmptyItemSet() );
2643 pCommonAttrs->Put( *pItem );
2644 }
2645 }
2646
2647 if ( pCommonAttrs )
2648 {
2649 ScDocument* pDoc = pActiveViewSh->GetViewData()->GetDocument();
2650 pCellAttrs = new ScPatternAttr( pDoc->GetPool() );
2651 pCellAttrs->GetFromEditItemSet( pCommonAttrs );
2652 delete pCommonAttrs;
2653 }
2654 }
2655
2656 // clear ParaAttribs (including adjustment)
2657
2658 RemoveAdjust();
2659
2660 bool bAttrib = false; // Formatierung vorhanden ?
2661 // check if EditObject is needed
2662
2663 if (nParCnt > 1)
2664 bAttrib = true;
2665 else
2666 {
2667 for (sal_uInt16 nId = EE_CHAR_START; nId <= EE_CHAR_END && !bAttrib; nId++)
2668 {
2669 SfxItemState eState = aOldAttribs.GetItemState( nId, false, &pItem );
2670 if (eState == SFX_ITEM_DONTCARE)
2671 bAttrib = true;
2672 else if (eState == SFX_ITEM_SET)
2673 {
2674 // keep same items in EditEngine as in ScEditAttrTester
2675 if ( nId == EE_CHAR_ESCAPEMENT || nId == EE_CHAR_PAIRKERNING ||
2676 nId == EE_CHAR_KERNING || nId == EE_CHAR_XMLATTRIBS )
2677 {
2678 if ( *pItem != pEditDefaults->Get(nId) )
2679 bAttrib = true;
2680 }
2681 }
2682 }
2683
2684 // Feldbefehle enthalten?
2685
2686 SfxItemState eFieldState = aOldAttribs.GetItemState( EE_FEATURE_FIELD, false );
2687 if ( eFieldState == SFX_ITEM_DONTCARE || eFieldState == SFX_ITEM_SET )
2688 bAttrib = true;
2689
2690 // not converted characters?
2691
2692 SfxItemState eConvState = aOldAttribs.GetItemState( EE_FEATURE_NOTCONV, false );
2693 if ( eConvState == SFX_ITEM_DONTCARE || eConvState == SFX_ITEM_SET )
2694 bAttrib = true;
2695
2696 // Formeln immer als Formeln erkennen (#38309#)
2697 // (der Test vorher ist trotzdem noetig wegen Zell-Attributen)
2698 }
2699
2700 if (bSpellErrors)
2701 pEngine->GetAllMisspellRanges(aMisspellRanges);
2702
2703 if (bMatrix)
2704 bAttrib = false;
2705
2706 if (bAttrib)
2707 {
2708 pEngine->ClearSpellErrors();
2709 pObject = pEngine->CreateTextObject();
2710 }
2711 else if (bAutoComplete) // Gross-/Kleinschreibung anpassen
2712 {
2713 // Perform case-matching only when the typed text is partial.
2714 if (pColumnData && aAutoSearch.getLength() < aString.getLength())
2715 aString = getExactMatch(*pColumnData, aString);
2716 }
2717 }
2718
2719 // don't rely on ShowRefFrame switching the active view synchronously
2720 // execute the function directly on the correct view's bindings instead
2721 // pRefViewSh is reset in ShowRefFrame - get pointer before ShowRefFrame call
2722 ScTabViewShell* pExecuteSh = pRefViewSh ? pRefViewSh : pActiveViewSh;
2723
2724 if (bFormulaMode)
2725 {
2726 ShowRefFrame();
2727
2728 if (pExecuteSh)
2729 {
2730 pExecuteSh->SetTabNo(aCursorPos.Tab());
2731 pExecuteSh->ActiveGrabFocus();
2732 }
2733
2734 bFormulaMode = false;
2735 pSfxApp->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
2736 SC_MOD()->SetRefInputHdl(NULL);
2737 if (pInputWin)
2738 pInputWin->SetFormulaMode(false);
2739 UpdateAutoCorrFlag();
2740 }
2741 pRefViewSh = NULL; // auch ohne FormulaMode wegen Funktions-AP
2742 DeleteRangeFinder();
2743 ResetAutoPar();
2744
2745 bool bOldMod = bModified;
2746
2747 bModified = false;
2748 bSelIsRef = false;
2749 eMode = SC_INPUT_NONE;
2750 StopInputWinEngine(true);
2751
2752 // Text input (through number formats) or ApplySelectionPattern modify
2753 // the cell's attributes, so pLastPattern is no longer valid
2754 pLastPattern = NULL;
2755
2756 if (bOldMod && !bProtected && !bForget)
2757 {
2758 // keine typographische Anfuehrungszeichen in Formeln
2759
2760 if (aString.startsWith("="))
2761 {
2762 SvxAutoCorrect* pAuto = SvxAutoCorrCfg::Get().GetAutoCorrect();
2763 if ( pAuto )
2764 {
2765 OUString aReplace(pAuto->GetStartDoubleQuote());
2766 if( aReplace.isEmpty() )
2767 aReplace = ScGlobal::pLocaleData->getDoubleQuotationMarkStart();
2768 if( aReplace != "\"" )
2769 aString = aString.replaceAll( aReplace, "\"" );
2770
2771 aReplace = OUString(pAuto->GetEndDoubleQuote());
2772 if( aReplace.isEmpty() )
2773 aReplace = ScGlobal::pLocaleData->getDoubleQuotationMarkEnd();
2774 if( aReplace != "\"" )
2775 aString = aString.replaceAll( aReplace, "\"" );
2776
2777 aReplace = OUString(pAuto->GetStartSingleQuote());
2778 if( aReplace.isEmpty() )
2779 aReplace = ScGlobal::pLocaleData->getQuotationMarkStart();
2780 if( aReplace != "'" )
2781 aString = aString.replaceAll( aReplace, "'" );
2782
2783 aReplace = OUString(pAuto->GetEndSingleQuote());
2784 if( aReplace.isEmpty() )
2785 aReplace = ScGlobal::pLocaleData->getQuotationMarkEnd();
2786 if( aReplace != "'" )
2787 aString = aString.replaceAll( aReplace, "'");
2788 }
2789 }
2790
2791 pSfxApp->Broadcast( SfxSimpleHint( FID_KILLEDITVIEW_NOPAINT ) );
2792
2793 if ( pExecuteSh )
2794 {
2795 SfxBindings& rBindings = pExecuteSh->GetViewFrame()->GetBindings();
2796
2797 sal_uInt16 nId = FID_INPUTLINE_ENTER;
2798 if ( nBlockMode == SC_ENTER_BLOCK )
2799 nId = FID_INPUTLINE_BLOCK;
2800 else if ( nBlockMode == SC_ENTER_MATRIX )
2801 nId = FID_INPUTLINE_MATRIX;
2802
2803 ScInputStatusItem aItem( FID_INPUTLINE_STATUS,
2804 aCursorPos, aCursorPos, aCursorPos,
2805 aString, pObject );
2806
2807 if (!aMisspellRanges.empty())
2808 aItem.SetMisspellRanges(&aMisspellRanges);
2809
2810 const SfxPoolItem* aArgs[2];
2811 aArgs[0] = &aItem;
2812 aArgs[1] = NULL;
2813 rBindings.Execute( nId, aArgs );
2814 }
2815
2816 delete pLastState; // pLastState enthaelt noch den alten Text
2817 pLastState = NULL;
2818 }
2819 else
2820 pSfxApp->Broadcast( SfxSimpleHint( FID_KILLEDITVIEW ) );
2821
2822 if ( bOldMod && pExecuteSh && pCellAttrs && !bForget )
2823 {
2824 // mit Eingabe zusammenfassen ?
2825 pExecuteSh->ApplySelectionPattern( *pCellAttrs, true, true );
2826 pExecuteSh->AdjustBlockHeight();
2827 }
2828
2829 delete pCellAttrs;
2830 delete pObject;
2831
2832 HideTip();
2833 HideTipBelow();
2834
2835 nFormSelStart = nFormSelEnd = 0;
2836 aFormText = OUString();
2837
2838 bInOwnChange = false;
2839 bInEnterHandler = false;
2840 }
2841
2842 void ScInputHandler::CancelHandler()
2843 {
2844 bInOwnChange = true; // disable ModifyHdl (reset below)
2845
2846 ImplCreateEditEngine();
2847
2848 bModified = false;
2849
2850 // don't rely on ShowRefFrame switching the active view synchronously
2851 // execute the function directly on the correct view's bindings instead
2852 // pRefViewSh is reset in ShowRefFrame - get pointer before ShowRefFrame call
2853 ScTabViewShell* pExecuteSh = pRefViewSh ? pRefViewSh : pActiveViewSh;
2854
2855 if (bFormulaMode)
2856 {
2857 ShowRefFrame();
2858 if (pExecuteSh)
2859 {
2860 pExecuteSh->SetTabNo(aCursorPos.Tab());
2861 pExecuteSh->ActiveGrabFocus();
2862 }
2863 bFormulaMode = false;
2864 SFX_APP()->Broadcast( SfxSimpleHint( FID_REFMODECHANGED ) );
2865 SC_MOD()->SetRefInputHdl(NULL);
2866 if (pInputWin)
2867 pInputWin->SetFormulaMode(false);
2868 UpdateAutoCorrFlag();
2869 }
2870 pRefViewSh = NULL; // auch ohne FormulaMode wegen Funktions-AP
2871 DeleteRangeFinder();
2872 ResetAutoPar();
2873
2874 eMode = SC_INPUT_NONE;
2875 StopInputWinEngine( true );
2876 if (pExecuteSh)
2877 pExecuteSh->StopEditShell();
2878
2879 aCursorPos.Set(MAXCOL+1,0,0); // Flag, dass ungueltig
2880 pEngine->SetText(OUString());
2881
2882 if ( !pLastState && pExecuteSh )
2883 pExecuteSh->UpdateInputHandler( true ); // Status neu holen
2884 else
2885 NotifyChange( pLastState, true );
2886
2887 nFormSelStart = nFormSelEnd = 0;
2888 aFormText = OUString();
2889
2890 bInOwnChange = false;
2891 }
2892
2893 bool ScInputHandler::IsModalMode( SfxObjectShell* pDocSh )
2894 {
2895 // Referenzen auf unbenanntes Dokument gehen nicht
2896
2897 return bFormulaMode && pRefViewSh
2898 && pRefViewSh->GetViewData()->GetDocument()->GetDocumentShell() != pDocSh
2899 && !pDocSh->HasName();
2900 }
2901
2902 void ScInputHandler::AddRefEntry()
2903 {
2904 const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
2905 UpdateActiveView();
2906 if (!pTableView && !pTopView)
2907 return; // z.B. FillMode
2908
2909 DataChanging(); // kann nicht neu sein
2910
2911 RemoveSelection();
2912 if (pTableView)
2913 pTableView->InsertText( OUString(cSep), false );
2914 if (pTopView)
2915 pTopView->InsertText( OUString(cSep), false );
2916
2917 DataChanged();
2918 }
2919
2920 void ScInputHandler::SetReference( const ScRange& rRef, ScDocument* pDoc )
2921 {
2922 HideTip();
2923
2924 bool bOtherDoc = ( pRefViewSh &&
2925 pRefViewSh->GetViewData()->GetDocument() != pDoc );
2926 if (bOtherDoc)
2927 if (!pDoc->GetDocumentShell()->HasName())
2928 {
2929 // Referenzen auf unbenanntes Dokument gehen nicht
2930 // (SetReference sollte dann auch nicht gerufen werden)
2931
2932 return;
2933 }
2934
2935 UpdateActiveView();
2936 if (!pTableView && !pTopView)
2937 return; // z.B. FillMode
2938
2939 // nie das "=" ueberschreiben!
2940 EditView* pActiveView = pTopView ? pTopView : pTableView;
2941 ESelection aSel = pActiveView->GetSelection();
2942 aSel.Adjust();
2943 if ( aSel.nStartPara == 0 && aSel.nStartPos == 0 )
2944 return;
2945
2946 DataChanging(); // kann nicht neu sein
2947
2948 // Selektion umdrehen, falls rueckwaerts (noetig ???)
2949
2950 if (pTableView)
2951 {
2952 ESelection aTabSel = pTableView->GetSelection();
2953 if (aTabSel.nStartPos > aTabSel.nEndPos && aTabSel.nStartPara == aTabSel.nEndPara)
2954 {
2955 aTabSel.Adjust();
2956 pTableView->SetSelection(aTabSel);
2957 }
2958 }
2959 if (pTopView)
2960 {
2961 ESelection aTopSel = pTopView->GetSelection();
2962 if (aTopSel.nStartPos > aTopSel.nEndPos && aTopSel.nStartPara == aTopSel.nEndPara)
2963 {
2964 aTopSel.Adjust();
2965 pTopView->SetSelection(aTopSel);
2966 }
2967 }
2968
2969 // String aus Referenz erzeugen
2970
2971 OUString aRefStr;
2972 const ScAddress::Details aAddrDetails( pDoc, aCursorPos );
2973 if (bOtherDoc)
2974 {
2975 // Referenz auf anderes Dokument
2976
2977 OSL_ENSURE(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab");
2978
2979 OUString aTmp(rRef.Format(SCA_VALID|SCA_TAB_3D, pDoc, aAddrDetails)); // immer 3d
2980
2981 SfxObjectShell* pObjSh = pDoc->GetDocumentShell();
2982 // #i75893# convert escaped URL of the document to something user friendly
2983 OUString aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DECODE_UNAMBIGUOUS );
2984
2985 aRefStr = "\'";
2986 aRefStr += aFileName;
2987 aRefStr += "'#";
2988 aRefStr += aTmp;
2989 }
2990 else
2991 {
2992 if ( ( rRef.aStart.Tab() != aCursorPos.Tab() ||
2993 rRef.aStart.Tab() != rRef.aEnd.Tab() ) && pDoc )
2994 aRefStr = rRef.Format(SCA_VALID|SCA_TAB_3D, pDoc, aAddrDetails);
2995 else
2996 aRefStr = rRef.Format(SCA_VALID, pDoc, aAddrDetails);
2997 }
2998
2999 if (pTableView || pTopView)
3000 {
3001 if (pTableView)
3002 pTableView->InsertText( aRefStr, true );
3003 if (pTopView)
3004 pTopView->InsertText( aRefStr, true );
3005
3006 DataChanged();
3007 }
3008
3009 bSelIsRef = true;
3010 }
3011
3012 void ScInputHandler::InsertFunction( const OUString& rFuncName, bool bAddPar )
3013 {
3014 if ( eMode == SC_INPUT_NONE )
3015 {
3016 OSL_FAIL("InsertFunction, nicht im Eingabemodus");
3017 return;
3018 }
3019
3020 UpdateActiveView();
3021 if (!pTableView && !pTopView)
3022 return; // z.B. FillMode
3023
3024 DataChanging(); // kann nicht neu sein
3025
3026 OUString aText = rFuncName;
3027 if (bAddPar)
3028 aText += "()";
3029
3030 if (pTableView)
3031 {
3032 pTableView->InsertText( aText, false );
3033 if (bAddPar)
3034 {
3035 ESelection aSel = pTableView->GetSelection();
3036 --aSel.nStartPos;
3037 --aSel.nEndPos;
3038 pTableView->SetSelection(aSel);
3039 }
3040 }
3041 if (pTopView)
3042 {
3043 pTopView->InsertText( aText, false );
3044 if (bAddPar)
3045 {
3046 ESelection aSel = pTopView->GetSelection();
3047 --aSel.nStartPos;
3048 --aSel.nEndPos;
3049 pTopView->SetSelection(aSel);
3050 }
3051 }
3052
3053 DataChanged();
3054
3055 if (bAddPar)
3056 AutoParAdded();
3057 }
3058
3059 void ScInputHandler::ClearText()
3060 {
3061 if ( eMode == SC_INPUT_NONE )
3062 {
3063 OSL_FAIL("ClearText, nicht im Eingabemodus");
3064 return;
3065 }
3066
3067 UpdateActiveView();
3068 if (!pTableView && !pTopView)
3069 return; // z.B. FillMode
3070
3071 DataChanging(); // darf nicht neu sein
3072
3073 OUString aEmpty;
3074 if (pTableView)
3075 {
3076 pTableView->GetEditEngine()->SetText( aEmpty );
3077 pTableView->SetSelection( ESelection(0,0, 0,0) );
3078 }
3079 if (pTopView)
3080 {
3081 pTopView->GetEditEngine()->SetText( aEmpty );
3082 pTopView->SetSelection( ESelection(0,0, 0,0) );
3083 }
3084
3085 DataChanged();
3086 }
3087
3088 bool ScInputHandler::KeyInput( const KeyEvent& rKEvt, bool bStartEdit /* = false */ )
3089 {
3090 if (!bOptLoaded)
3091 {
3092 bAutoComplete = SC_MOD()->GetAppOptions().GetAutoComplete();
3093 bOptLoaded = true;
3094 }
3095
3096 KeyCode aCode = rKEvt.GetKeyCode();
3097 sal_uInt16 nModi = aCode.GetModifier();
3098 bool bShift = aCode.IsShift();
3099 bool bControl = aCode.IsMod1();
3100 bool bAlt = aCode.IsMod2();
3101 sal_uInt16 nCode = aCode.GetCode();
3102 sal_Unicode nChar = rKEvt.GetCharCode();
3103
3104 if (bAlt && !bControl && nCode != KEY_RETURN)
3105 // Alt-Return and Alt-Ctrl-* are accepted. Everything else with ALT are not.
3106 return false;
3107
3108 if (!bControl && nCode == KEY_TAB)
3109 {
3110 // Normal TAB moves the cursor right.
3111 EnterHandler();
3112
3113 if (pActiveViewSh)
3114 pActiveViewSh->FindNextUnprot( bShift );
3115 return true;
3116 }
3117
3118 bool bInputLine = ( eMode==SC_INPUT_TOP );
3119
3120 bool bUsed = false;
3121 bool bSkip = false;
3122 bool bDoEnter = false;
3123
3124 switch ( nCode )
3125 {
3126 case KEY_RETURN:
3127 if (bControl && !bShift && ( !bInputLine || ( pInputWin && pInputWin->IsMultiLineInput() ) ) )
3128 bDoEnter = true;
3129 else if (nModi == 0 && nTipVisible && pFormulaData && miAutoPosFormula != pFormulaData->end())
3130 {
3131 PasteFunctionData();
3132 bUsed = true;
3133 }
3134 else if ( nModi == 0 && nTipVisible && !aManualTip.isEmpty() )
3135 {
3136 PasteManualTip();
3137 bUsed = true;
3138 }
3139 else
3140 {
3141 sal_uInt8 nMode = SC_ENTER_NORMAL;
3142 if ( bShift && bControl )
3143 nMode = SC_ENTER_MATRIX;
3144 else if ( bAlt )
3145 nMode = SC_ENTER_BLOCK;
3146 EnterHandler( nMode );
3147
3148 if (pActiveViewSh)
3149 pActiveViewSh->MoveCursorEnter( bShift && !bControl );
3150
3151 bUsed = true;
3152 }
3153 break;
3154 case KEY_TAB:
3155 if (bControl && !bAlt)
3156 {
3157 if (pFormulaData && nTipVisible && miAutoPosFormula != pFormulaData->end())
3158 {
3159 // blaettern
3160
3161 NextFormulaEntry( bShift );
3162 bUsed = true;
3163 }
3164 else if (pColumnData && bUseTab && miAutoPosColumn != pColumnData->end())
3165 {
3166 // in den Eintraegen der AutoEingabe blaettern
3167
3168 NextAutoEntry( bShift );
3169 bUsed = true;
3170 }
3171 }
3172 break;
3173 case KEY_ESCAPE:
3174 if ( nTipVisible )
3175 {
3176 HideTip();
3177 bUsed = true;
3178 }
3179 else if( nTipVisibleSec )
3180 {
3181 HideTipBelow();
3182 bUsed = true;
3183 }
3184 else if (eMode != SC_INPUT_NONE)
3185 {
3186 CancelHandler();
3187 bUsed = true;
3188 }
3189 else
3190 bSkip = true;
3191 break;
3192 case KEY_F2:
3193 if ( !bShift && !bControl && !bAlt && eMode == SC_INPUT_TABLE )
3194 {
3195 eMode = SC_INPUT_TYPE;
3196 bUsed = true;
3197 }
3198 break;
3199 }
3200
3201 // Cursortasten nur ausfuehren, wenn schon im Edit-Modus
3202 // z.B. wegen Shift-Ctrl-PageDn (ist nicht als Accelerator definiert)
3203
3204 bool bCursorKey = EditEngine::DoesKeyMoveCursor(rKEvt);
3205 bool bInsKey = ( nCode == KEY_INSERT && !nModi ); // Insert wie Cursortasten behandeln
3206 if ( !bUsed && !bSkip && ( bDoEnter || EditEngine::DoesKeyChangeText(rKEvt) ||
3207 ( eMode != SC_INPUT_NONE && ( bCursorKey || bInsKey ) ) ) )
3208 {
3209 HideTip();
3210 HideTipBelow();
3211
3212 if (bSelIsRef)
3213 {
3214 RemoveSelection();
3215 bSelIsRef = false;
3216 }
3217
3218 UpdateActiveView();
3219 bool bNewView = DataChanging( nChar );
3220
3221 if (bProtected) // Zelle geschuetzt?
3222 bUsed = true; // Key-Event nicht weiterleiten
3223 else // Aenderungen erlaubt
3224 {
3225 if (bNewView ) // neu anlegen
3226 {
3227 if (pActiveViewSh)
3228 pActiveViewSh->GetViewData()->GetDocShell()->PostEditView( pEngine, aCursorPos );
3229 UpdateActiveView();
3230 if (eMode==SC_INPUT_NONE)
3231 if (pTableView || pTopView)
3232 {
3233 OUString aStrLoP;
3234
3235 if ( bStartEdit && bCellHasPercentFormat && ((nChar >= '0' && nChar <= '9') || nChar == '-') )
3236 aStrLoP = "%";
3237
3238 if (pTableView)
3239 {
3240 pTableView->GetEditEngine()->SetText( aStrLoP );
3241 if ( !aStrLoP.isEmpty() )
3242 pTableView->SetSelection( ESelection(0,0, 0,0) ); // before the '%'
3243
3244 // don't call SetSelection if the string is empty anyway,
3245 // to avoid breaking the bInitial handling in ScViewData::EditGrowY
3246 }
3247 if (pTopView)
3248 {
3249 pTopView->GetEditEngine()->SetText( aStrLoP );
3250 if ( !aStrLoP.isEmpty() )
3251 pTopView->SetSelection( ESelection(0,0, 0,0) ); // before the '%'
3252 }
3253 }
3254 SyncViews();
3255 }
3256
3257 if (pTableView || pTopView)
3258 {
3259 if (bDoEnter)
3260 {
3261 if (pTableView)
3262 if( pTableView->PostKeyEvent( KeyEvent( CHAR_CR, KeyCode(KEY_RETURN) ) ) )
3263 bUsed = true;
3264 if (pTopView)
3265 if( pTopView->PostKeyEvent( KeyEvent( CHAR_CR, KeyCode(KEY_RETURN) ) ) )
3266 bUsed = true;
3267 }
3268 else if ( nAutoPar && nChar == ')' && CursorAtClosingPar() )
3269 {
3270 SkipClosingPar();
3271 bUsed = true;
3272 }
3273 else
3274 {
3275 if (pTableView)
3276 {
3277 Window* pFrameWin = pActiveViewSh ? pActiveViewSh->GetFrameWin() : NULL;
3278 if ( pTableView->PostKeyEvent( rKEvt, pFrameWin ) )
3279 bUsed = true;
3280 }
3281 if (pTopView)
3282 if ( pTopView->PostKeyEvent( rKEvt ) )
3283 bUsed = true;
3284 }
3285
3286 // Auto-Eingabe:
3287
3288 if ( bUsed && bAutoComplete )
3289 {
3290 bUseTab = false;
3291 if (pFormulaData)
3292 miAutoPosFormula = pFormulaData->end(); // do not search further
3293 if (pColumnData)
3294 miAutoPosColumn = pColumnData->end();
3295
3296 KeyFuncType eFunc = rKEvt.GetKeyCode().GetFunction();
3297 if ( nChar && nChar != 8 && nChar != 127 && // no 'backspace', no 'delete'
3298 KEYFUNC_CUT != eFunc) // and no 'CTRL-X'
3299 {
3300 if (bFormulaMode)
3301 UseFormulaData();
3302 else
3303 UseColData();
3304 }
3305 }
3306
3307 // when the selection is changed manually or an opening parenthesis
3308 // is typed, stop overwriting parentheses
3309 if ( bUsed && nChar == '(' )
3310 ResetAutoPar();
3311
3312 if ( KEY_INSERT == nCode )
3313 {
3314 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
3315 if (pViewFrm)
3316 pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERT );
3317 }
3318 if( bUsed && bFormulaMode && ( bCursorKey || bInsKey || nCode == KEY_DELETE || nCode == KEY_BACKSPACE ) )
3319 {
3320 ShowTipCursor();
3321 }
3322 }
3323
3324 // #i114511# don't count cursor keys as modification
3325 sal_Bool bSetModified = !bCursorKey;
3326 DataChanged(sal_False, bSetModified); // also calls UpdateParenthesis()
3327 InvalidateAttribs(); //! in DataChanged ?
3328 }
3329 }
3330
3331 if (pTopView && eMode != SC_INPUT_NONE)
3332 SyncViews();
3333
3334 return bUsed;
3335 }
3336
3337 bool ScInputHandler::InputCommand( const CommandEvent& rCEvt, bool bForce )
3338 {
3339 bool bUsed = false;
3340
3341 if ( rCEvt.GetCommand() == COMMAND_CURSORPOS )
3342 {
3343 // for COMMAND_CURSORPOS, do as little as possible, because
3344 // with remote VCL, even a ShowCursor will generate another event.
3345 if ( eMode != SC_INPUT_NONE )
3346 {
3347 UpdateActiveView();
3348 if (pTableView || pTopView)
3349 {
3350 if (pTableView)
3351 pTableView->Command( rCEvt );
3352 else if (pTopView) // call only once
3353 pTopView->Command( rCEvt );
3354 bUsed = true;
3355 }
3356 }
3357 }
3358 else if ( rCEvt.GetCommand() == COMMAND_QUERYCHARPOSITION )
3359 {
3360 if ( eMode != SC_INPUT_NONE )
3361 {
3362 UpdateActiveView();
3363 if (pTableView || pTopView)
3364 {
3365 if (pTableView)
3366 pTableView->Command( rCEvt );
3367 else if (pTopView) // call only once
3368 pTopView->Command( rCEvt );
3369 bUsed = true;
3370 }
3371 }
3372 }
3373 else
3374 {
3375 if ( bForce || eMode != SC_INPUT_NONE )
3376 {
3377 if (!bOptLoaded)
3378 {
3379 bAutoComplete = SC_MOD()->GetAppOptions().GetAutoComplete();
3380 bOptLoaded = true;
3381 }
3382
3383 HideTip();
3384 HideTipBelow();
3385
3386 if ( bSelIsRef )
3387 {
3388 RemoveSelection();
3389 bSelIsRef = false;
3390 }
3391
3392 UpdateActiveView();
3393 bool bNewView = DataChanging( 0, true );
3394
3395 if (bProtected) // cell protected
3396 bUsed = true; // event is used
3397 else // changes allowed
3398 {
3399 if (bNewView) // create new edit view
3400 {
3401 if (pActiveViewSh)
3402 pActiveViewSh->GetViewData()->GetDocShell()->PostEditView( pEngine, aCursorPos );
3403 UpdateActiveView();
3404 if (eMode==SC_INPUT_NONE)
3405 if (pTableView || pTopView)
3406 {
3407 OUString aStrLoP;
3408 if (pTableView)
3409 {
3410 pTableView->GetEditEngine()->SetText( aStrLoP );
3411 pTableView->SetSelection( ESelection(0,0, 0,0) );
3412 }
3413 if (pTopView)
3414 {
3415 pTopView->GetEditEngine()->SetText( aStrLoP );
3416 pTopView->SetSelection( ESelection(0,0, 0,0) );
3417 }
3418 }
3419 SyncViews();
3420 }
3421
3422 if (pTableView || pTopView)
3423 {
3424 if (pTableView)
3425 pTableView->Command( rCEvt );
3426 if (pTopView)
3427 pTopView->Command( rCEvt );
3428
3429 bUsed = true;
3430
3431 if ( rCEvt.GetCommand() == COMMAND_ENDEXTTEXTINPUT )
3432 {
3433 // AutoInput after ext text input
3434
3435 if (pFormulaData)
3436 miAutoPosFormula = pFormulaData->end();
3437 if (pColumnData)
3438 miAutoPosColumn = pColumnData->end();
3439
3440 if (bFormulaMode)
3441 UseFormulaData();
3442 else
3443 UseColData();
3444 }
3445 }
3446
3447 DataChanged(); // calls UpdateParenthesis()
3448 InvalidateAttribs(); //! in DataChanged ?
3449 }
3450 }
3451
3452 if (pTopView && eMode != SC_INPUT_NONE)
3453 SyncViews();
3454 }
3455
3456 return bUsed;
3457 }
3458
3459 void ScInputHandler::NotifyChange( const ScInputHdlState* pState,
3460 bool bForce, ScTabViewShell* pSourceSh,
3461 bool bStopEditing)
3462 {
3463 // Wenn der Aufruf aus einem Makro-Aufruf im EnterHandler kommt,
3464 // gleich abbrechen und nicht den Status durcheinander bringen
3465 if (bInEnterHandler)
3466 return;
3467
3468 bool bRepeat = (pState == pLastState);
3469 if (!bRepeat && pState && pLastState)
3470 bRepeat = (*pState == *pLastState);
3471 if (bRepeat && !bForce)
3472 return;
3473
3474 bInOwnChange = true; // disable ModifyHdl (reset below)
3475
3476 if ( pState && !pLastState ) // wieder enablen
3477 bForce = true;
3478
3479 bool bHadObject = pLastState && pLastState->GetEditData();
3480
3481 //! Before EditEngine gets eventually created (so it gets the right pools)
3482 if ( pSourceSh )
3483 pActiveViewSh = pSourceSh;
3484 else
3485 pActiveViewSh = PTR_CAST(ScTabViewShell, SfxViewShell::Current());
3486
3487 ImplCreateEditEngine();
3488
3489 if ( pState != pLastState )
3490 {
3491 delete pLastState;
3492 pLastState = pState ? new ScInputHdlState( *pState ) : NULL;
3493 }
3494
3495 if ( pState && pActiveViewSh )
3496 {
3497 ScModule* pScMod = SC_MOD();
3498
3499 if ( pState )
3500 {
3501
3502 // hier auch fremde Referenzeingabe beruecksichtigen (z.B. Funktions-AP),
3503 // FormEditData falls gerade von der Hilfe auf Calc umgeschaltet wird:
3504
3505 if ( !bFormulaMode && !pScMod->IsFormulaMode() && !pScMod->GetFormEditData() )
3506 {
3507 bool bIgnore = false;
3508 if ( bModified )
3509 {
3510 if (pState->GetPos() != aCursorPos)
3511 {
3512 if (!bProtected)
3513 EnterHandler();
3514 }
3515 else
3516 bIgnore = true;
3517 }
3518
3519 if ( !bIgnore )
3520 {
3521 const ScAddress& rSPos = pState->GetStartPos();
3522 const ScAddress& rEPos = pState->GetEndPos();
3523 const EditTextObject* pData = pState->GetEditData();
3524 OUString aString = pState->GetString();
3525 bool bTxtMod = false;
3526 ScDocShell* pDocSh = pActiveViewSh->GetViewData()->GetDocShell();
3527 ScDocument* pDoc = pDocSh->GetDocument();
3528
3529 aCursorPos = pState->GetPos();
3530
3531 if ( pData )
3532 bTxtMod = true;
3533 else if ( bHadObject )
3534 bTxtMod = true;
3535 else if ( bTextValid )
3536 bTxtMod = ( !aString.equals(aCurrentText) );
3537 else
3538 bTxtMod = ( !aString.equals(GetEditText(pEngine)) );
3539
3540 if ( bTxtMod || bForce )
3541 {
3542 if (pData)
3543 {
3544 pEngine->SetText( *pData );
3545 if ( pInputWin && pInputWin->IsMultiLineInput() )
3546 aString = ScEditUtil::GetMultilineString(*pEngine);
3547 else
3548 aString = GetEditText(pEngine);
3549 lcl_RemoveTabs(aString);
3550 bTextValid = false;
3551 aCurrentText = OUString();
3552 }
3553 else
3554 {
3555 aCurrentText = aString;
3556 bTextValid = true; //! erst nur als String merken
3557 }
3558
3559 if ( pInputWin )
3560 pInputWin->SetTextString(aString);
3561 }
3562
3563 if ( pInputWin ) // Bereichsanzeige
3564 {
3565 OUString aPosStr;
3566 const ScAddress::Details aAddrDetails( pDoc, aCursorPos );
3567
3568 // Ist der Bereich ein Name?
3569 //! per Timer suchen ???
3570
3571 if ( pActiveViewSh )
3572 pActiveViewSh->GetViewData()->GetDocument()->
3573 GetRangeAtBlock( ScRange( rSPos, rEPos ), &aPosStr );
3574
3575 if ( aPosStr.isEmpty() ) // kein Name -> formatieren
3576 {
3577 sal_uInt16 nFlags = 0;
3578 if( aAddrDetails.eConv == formula::FormulaGrammar::CONV_XL_R1C1 )
3579 nFlags |= SCA_COL_ABSOLUTE | SCA_ROW_ABSOLUTE;
3580 if ( rSPos != rEPos )
3581 {
3582 ScRange r(rSPos, rEPos);
3583 nFlags |= (nFlags << 4);
3584 aPosStr = r.Format(SCA_VALID | nFlags, pDoc, aAddrDetails);
3585 }
3586 else
3587 aPosStr = aCursorPos.Format(SCA_VALID | nFlags, pDoc, aAddrDetails);
3588 }
3589
3590 // Disable the accessible VALUE_CHANGE event
3591 bool bIsSuppressed = pInputWin->IsAccessibilityEventsSuppressed(false);
3592 pInputWin->SetAccessibilityEventsSuppressed(true);
3593 pInputWin->SetPosString(aPosStr);
3594 pInputWin->SetAccessibilityEventsSuppressed(bIsSuppressed);
3595 pInputWin->SetSumAssignMode();
3596 }
3597
3598 if (bStopEditing)
3599 SFX_APP()->Broadcast( SfxSimpleHint( FID_KILLEDITVIEW ) );
3600
3601 // As long as the content is not edited, turn off online spelling.
3602 // Online spelling is turned back on in StartTable, after setting
3603 // the right language from cell attributes.
3604
3605 sal_uLong nCntrl = pEngine->GetControlWord();
3606 if ( nCntrl & EE_CNTRL_ONLINESPELLING )
3607 pEngine->SetControlWord( nCntrl & ~EE_CNTRL_ONLINESPELLING );
3608
3609 bModified = false;
3610 bSelIsRef = false;
3611 bProtected = false;
3612 bCommandErrorShown = false;
3613 }
3614 }
3615 }
3616
3617 if ( pInputWin)
3618 {
3619 if(!pScMod->IsFormulaMode()&& !pScMod->IsRefDialogOpen()) //BugID 54702
3620 { //Wenn RefDialog offen, dann nicht enablen
3621 if ( !pInputWin->IsEnabled())
3622 {
3623 pInputWin->Enable();
3624 if(pDelayTimer )
3625 {
3626 DELETEZ( pDelayTimer );
3627 }
3628 }
3629 }
3630 else if(pScMod->IsRefDialogOpen())
3631 { // Da jedes Dokument eigenes InputWin hat, sollte
3632 if ( !pDelayTimer ) // nochmals Timer gestartet werden, da sonst Ein-
3633 { // gabezeile evt. noch aktiv ist.
3634 pDelayTimer = new Timer;
3635 pDelayTimer->SetTimeout( 500 ); // 100ms Verzoegerung
3636 pDelayTimer->SetTimeoutHdl( LINK( this, ScInputHandler, DelayTimer ) );
3637 pDelayTimer->Start();
3638 }
3639 }
3640 }
3641 }
3642 else // !pState || !pActiveViewSh
3643 {
3644 if ( !pDelayTimer )
3645 {
3646 pDelayTimer = new Timer;
3647 pDelayTimer->SetTimeout( 500 ); // 100ms Verzoegerung
3648 pDelayTimer->SetTimeoutHdl( LINK( this, ScInputHandler, DelayTimer ) );
3649 pDelayTimer->Start();
3650 }
3651 }
3652
3653 HideTip();
3654 HideTipBelow();
3655 bInOwnChange = false;
3656 }
3657
3658 void ScInputHandler::UpdateCellAdjust( SvxCellHorJustify eJust )
3659 {
3660 eAttrAdjust = eJust;
3661 UpdateAdjust( 0 );
3662 }
3663
3664 void ScInputHandler::ResetDelayTimer()
3665 {
3666 if(pDelayTimer!=NULL)
3667 {
3668 DELETEZ( pDelayTimer );
3669
3670 if ( pInputWin)
3671 {
3672 pInputWin->Enable();
3673 }
3674 }
3675 }
3676
3677 IMPL_LINK( ScInputHandler, DelayTimer, Timer*, pTimer )
3678 {
3679 if ( pTimer == pDelayTimer )
3680 {
3681 DELETEZ( pDelayTimer );
3682
3683 if ( NULL == pLastState || SC_MOD()->IsFormulaMode() || SC_MOD()->IsRefDialogOpen())
3684 {
3685 //! new method at ScModule to query if function autopilot is open
3686
3687 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
3688 if ( pViewFrm && pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) )
3689 {
3690 if ( pInputWin)
3691 {
3692 pInputWin->EnableButtons( false );
3693 pInputWin->Disable();
3694 }
3695 }
3696 else if ( !bFormulaMode ) // Formel auch z.B. bei Hilfe behalten
3697 {
3698 bInOwnChange = true; // disable ModifyHdl (reset below)
3699
3700 pActiveViewSh = NULL;
3701 pEngine->SetText( EMPTY_OUSTRING );
3702 if ( pInputWin )
3703 {
3704 pInputWin->SetPosString( EMPTY_OUSTRING );
3705 pInputWin->SetTextString( EMPTY_OUSTRING );
3706 pInputWin->Disable();
3707 }
3708
3709 bInOwnChange = false;
3710 }
3711 }
3712 }
3713 return 0;
3714 }
3715
3716 void ScInputHandler::InputSelection( EditView* pView )
3717 {
3718 SyncViews( pView );
3719 ShowTipCursor();
3720 UpdateParenthesis(); // Selektion geaendert -> Klammer-Hervorhebung neu
3721
3722 // when the selection is changed manually, stop overwriting parentheses
3723 ResetAutoPar();
3724 }
3725
3726 void ScInputHandler::InputChanged( EditView* pView, bool bFromNotify )
3727 {
3728 UpdateActiveView();
3729
3730 // #i20282# DataChanged needs to know if this is from the input line's modify handler
3731 bool bFromTopNotify = ( bFromNotify && pView == pTopView );
3732
3733 bool bNewView = DataChanging(); //! kann das hier ueberhaupt sein?
3734 aCurrentText = pView->GetEditEngine()->GetText(); // auch den String merken
3735 pEngine->SetText( aCurrentText );
3736 DataChanged( bFromTopNotify );
3737 bTextValid = true; // wird in DataChanged auf false gesetzt
3738
3739 if ( pActiveViewSh )
3740 {
3741 ScViewData* pViewData = pActiveViewSh->GetViewData();
3742 if ( bNewView )
3743 pViewData->GetDocShell()->PostEditView( pEngine, aCursorPos );
3744
3745 pViewData->EditGrowY();
3746 pViewData->EditGrowX();
3747 }
3748
3749 SyncViews( pView );
3750 }
3751
3752 const OUString& ScInputHandler::GetEditString()
3753 {
3754 if (pEngine)
3755 {
3756 aCurrentText = pEngine->GetText(); // immer neu aus Engine
3757 bTextValid = true;
3758 }
3759
3760 return aCurrentText;
3761 }
3762
3763 Size ScInputHandler::GetTextSize()
3764 {
3765 Size aSize;
3766 if ( pEngine )
3767 aSize = Size( pEngine->CalcTextWidth(), pEngine->GetTextHeight() );
3768
3769 return aSize;
3770 }
3771
3772 bool ScInputHandler::GetTextAndFields( ScEditEngineDefaulter& rDestEngine )
3773 {
3774 bool bRet = false;
3775 if (pEngine)
3776 {
3777 // Feldbefehle enthalten?
3778
3779 sal_Int32 nParCnt = pEngine->GetParagraphCount();
3780 SfxItemSet aSet = pEngine->GetAttribs( ESelection(0,0,nParCnt,0) );
3781 SfxItemState eFieldState = aSet.GetItemState( EE_FEATURE_FIELD, false );
3782 if ( eFieldState == SFX_ITEM_DONTCARE || eFieldState == SFX_ITEM_SET )
3783 {
3784 // Inhalt kopieren
3785
3786 EditTextObject* pObj = pEngine->CreateTextObject();
3787 rDestEngine.SetText(*pObj);
3788 delete pObj;
3789
3790 // Attribute loeschen
3791
3792 for (sal_Int32 i=0; i<nParCnt; i++)
3793 rDestEngine.QuickRemoveCharAttribs( i );
3794
3795 // Absaetze zusammenfassen
3796
3797 while ( nParCnt > 1 )
3798 {
3799 xub_StrLen nLen = rDestEngine.GetTextLen( 0 );
3800 ESelection aSel( 0,nLen, 1,0 );
3801 rDestEngine.QuickInsertText( OUString(' '), aSel ); // Umbruch durch Space ersetzen
3802 --nParCnt;
3803 }
3804
3805 bRet = true;
3806 }
3807 }
3808 return bRet;
3809 }
3810
3811 //------------------------------------------------------------------------
3812 // Methoden fuer FunktionsAutopiloten:
3813 // InputGetSelection, InputSetSelection, InputReplaceSelection, InputGetFormulaStr
3814 //------------------------------------------------------------------------
3815
3816 void ScInputHandler::InputGetSelection( xub_StrLen& rStart, xub_StrLen& rEnd )
3817 {
3818 rStart = nFormSelStart;
3819 rEnd = nFormSelEnd;
3820 }
3821
3822 //------------------------------------------------------------------------
3823
3824 EditView* ScInputHandler::GetFuncEditView()
3825 {
3826 UpdateActiveView(); // wegen pTableView
3827
3828 EditView* pView = NULL;
3829 if ( pInputWin )
3830 {
3831 pInputWin->MakeDialogEditView();
3832 pView = pInputWin->GetEditView();
3833 }
3834 else
3835 {
3836 if ( eMode != SC_INPUT_TABLE )
3837 {
3838 bCreatingFuncView = true; // RangeFinder nicht anzeigen
3839 SetMode( SC_INPUT_TABLE );
3840 bCreatingFuncView = false;
3841 if ( pTableView )
3842 pTableView->GetEditEngine()->SetText( EMPTY_OUSTRING );
3843 }
3844 pView = pTableView;
3845 }
3846
3847 return pView;
3848 }
3849
3850 //------------------------------------------------------------------------
3851
3852 void ScInputHandler::InputSetSelection( xub_StrLen nStart, xub_StrLen nEnd )
3853 {
3854 if ( nStart <= nEnd )
3855 {
3856 nFormSelStart = nStart;
3857 nFormSelEnd = nEnd;
3858 }
3859 else
3860 {
3861 nFormSelEnd = nStart;
3862 nFormSelStart = nEnd;
3863 }
3864
3865 EditView* pView = GetFuncEditView();
3866 if (pView)
3867 pView->SetSelection( ESelection(0,nStart, 0,nEnd) );
3868
3869 bModified = true;
3870 }
3871
3872 //------------------------------------------------------------------------
3873
3874 void ScInputHandler::InputReplaceSelection( const OUString& rStr )
3875 {
3876 if (!pRefViewSh)
3877 pRefViewSh = pActiveViewSh;
3878
3879 OSL_ENSURE(nFormSelEnd>=nFormSelStart,"Selektion kaputt...");
3880
3881 sal_Int32 nOldLen = nFormSelEnd - nFormSelStart;
3882 sal_Int32 nNewLen = rStr.getLength();
3883
3884 OUStringBuffer aBuf(aFormText);
3885 if (nOldLen)
3886 aBuf.remove(nFormSelStart, nOldLen);
3887 if (nNewLen)
3888 aBuf.insert(nFormSelStart, rStr);
3889
3890 aFormText = aBuf.makeStringAndClear();
3891
3892 nFormSelEnd = nFormSelStart + nNewLen;
3893
3894 EditView* pView = GetFuncEditView();
3895 if (pView)
3896 {
3897 pView->SetEditEngineUpdateMode( false );
3898 pView->GetEditEngine()->SetText( aFormText );
3899 pView->SetSelection( ESelection(0,nFormSelStart, 0,nFormSelEnd) );
3900 pView->SetEditEngineUpdateMode( true );
3901 }
3902 bModified = true;
3903 }
3904
3905 void ScInputHandler::InputTurnOffWinEngine()
3906 {
3907 bInOwnChange = true; // disable ModifyHdl (reset below)
3908
3909 eMode = SC_INPUT_NONE;
3910 /* TODO: it would be better if there was some way to reset the input bar
3911 * engine instead of deleting and having it recreate through
3912 * GetFuncEditView(), but first least invasively let this fix fdo#71667 and
3913 * fdo#72278 without reintroducing fdo#69971. */
3914 StopInputWinEngine(true);
3915
3916 bInOwnChange = false;
3917 }
3918
3919 //========================================================================
3920 // ScInputHdlState
3921 //========================================================================
3922
3923 ScInputHdlState::ScInputHdlState( const ScAddress& rCurPos,
3924 const ScAddress& rStartPos,
3925 const ScAddress& rEndPos,
3926 const OUString& rString,
3927 const EditTextObject* pData )
3928 : aCursorPos ( rCurPos ),
3929 aStartPos ( rStartPos ),
3930 aEndPos ( rEndPos ),
3931 aString ( rString ),
3932 pEditData ( pData ? pData->Clone() : NULL )
3933 {
3934 }
3935
3936 //------------------------------------------------------------------------
3937
3938 ScInputHdlState::ScInputHdlState( const ScInputHdlState& rCpy )
3939 : pEditData ( NULL )
3940 {
3941 *this = rCpy;
3942 }
3943
3944 //------------------------------------------------------------------------
3945
3946 ScInputHdlState::~ScInputHdlState()
3947 {
3948 delete pEditData;
3949 }
3950
3951 //------------------------------------------------------------------------
3952
3953 int ScInputHdlState::operator==( const ScInputHdlState& r ) const
3954 {
3955 return ( (aStartPos == r.aStartPos)
3956 && (aEndPos == r.aEndPos)
3957 && (aCursorPos == r.aCursorPos)
3958 && (aString == r.aString)
3959 && ScGlobal::EETextObjEqual( pEditData, r.pEditData ) );
3960 }
3961
3962 //------------------------------------------------------------------------
3963
3964 ScInputHdlState& ScInputHdlState::operator=( const ScInputHdlState& r )
3965 {
3966 delete pEditData;
3967
3968 aCursorPos = r.aCursorPos;
3969 aStartPos = r.aStartPos;
3970 aEndPos = r.aEndPos;
3971 aString = r.aString;
3972 pEditData = r.pEditData ? r.pEditData->Clone() : NULL;
3973
3974 return *this;
3975 }
3976
3977 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE