?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
calc: on editing invalidation of view with different zoom is wrong
[LibreOffice.git] / sc / source / ui / app / inputhdl.cxx
blob1153a7dc03d4b6aea1593d4583858d91fd61d473
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 <iterator>
21 #include <memory>
22 #include <string_view>
23
24 #include <inputhdl.hxx>
25 #include <scitems.hxx>
26 #include <editeng/eeitem.hxx>
27
28 #include <sfx2/app.hxx>
29 #include <editeng/acorrcfg.hxx>
30 #include <formula/errorcodes.hxx>
31 #include <editeng/adjustitem.hxx>
32 #include <editeng/brushitem.hxx>
33 #include <svtools/colorcfg.hxx>
34 #include <editeng/colritem.hxx>
35 #include <editeng/editobj.hxx>
36 #include <editeng/editstat.hxx>
37 #include <editeng/editview.hxx>
38 #include <editeng/langitem.hxx>
39 #include <editeng/svxacorr.hxx>
40 #include <editeng/unolingu.hxx>
41 #include <editeng/wghtitem.hxx>
42 #include <editeng/justifyitem.hxx>
43 #include <editeng/misspellrange.hxx>
44 #include <sfx2/bindings.hxx>
45 #include <sfx2/viewfrm.hxx>
46 #include <sfx2/docfile.hxx>
47 #include <sfx2/printer.hxx>
48 #include <svl/numformat.hxx>
49 #include <svl/zforlist.hxx>
50 #include <svx/svxids.hrc>
51 #include <unotools/localedatawrapper.hxx>
52 #include <unotools/charclass.hxx>
53 #include <utility>
54 #include <vcl/help.hxx>
55 #include <vcl/jsdialog/executor.hxx>
56 #include <vcl/commandevent.hxx>
57 #include <vcl/cursor.hxx>
58 #include <vcl/settings.hxx>
59 #include <vcl/svapp.hxx>
60 #include <tools/urlobj.hxx>
61 #include <formula/formulahelper.hxx>
62 #include <formula/funcvarargs.h>
63 #include <LibreOfficeKit/LibreOfficeKitEnums.h>
64 #include <comphelper/lok.hxx>
65 #include <osl/diagnose.h>
66
67 #include <attrib.hxx>
68 #include <inputwin.hxx>
69 #include <tabvwsh.hxx>
70 #include <docsh.hxx>
71 #include <scmod.hxx>
72 #include <formulaopt.hxx>
73 #include <uiitems.hxx>
74 #include <global.hxx>
75 #include <sc.hrc>
76 #include <globstr.hrc>
77 #include <scresid.hxx>
78 #include <patattr.hxx>
79 #include <viewdata.hxx>
80 #include <document.hxx>
81 #include <docpool.hxx>
82 #include <editutil.hxx>
83 #include <appoptio.hxx>
84 #include <docoptio.hxx>
85 #include <validat.hxx>
86 #include <rfindlst.hxx>
87 #include <inputopt.hxx>
88 #include <simpleformulacalc.hxx>
89 #include <compiler.hxx>
90 #include <editable.hxx>
91 #include <funcdesc.hxx>
92 #include <markdata.hxx>
93 #include <tokenarray.hxx>
94 #include <gridwin.hxx>
95 #include <output.hxx>
96 #include <fillinfo.hxx>
97
98 // Maximum Ranges in RangeFinder
99 #define RANGEFIND_MAX 128
100
101 using namespace formula;
102
103 namespace {
104
105 ScTypedCaseStrSet::const_iterator findText(
106 const ScTypedCaseStrSet& rDataSet, ScTypedCaseStrSet::const_iterator const & itPos,
107 const OUString& rStart, OUString& rResult, bool bBack)
108 {
109 auto lIsMatch = [&rStart](const ScTypedStrData& rData) {
110 return (rData.GetStringType() != ScTypedStrData::Value) && ScGlobal::GetTransliteration().isMatch(rStart, rData.GetString()); };
111
112 if (bBack) // Backwards
113 {
114 ScTypedCaseStrSet::const_reverse_iterator it = rDataSet.rbegin(), itEnd = rDataSet.rend();
115 if (itPos != rDataSet.end())
116 {
117 size_t nPos = std::distance(rDataSet.begin(), itPos);
118 size_t nRPos = rDataSet.size() - 1 - nPos;
119 std::advance(it, nRPos);
120 ++it;
121 }
122
123 it = std::find_if(it, itEnd, lIsMatch);
124 if (it != itEnd)
125 {
126 rResult = it->GetString();
127 return (++it).base(); // convert the reverse iterator back to iterator.
128 }
129 }
130 else // Forwards
131 {
132 ScTypedCaseStrSet::const_iterator it = rDataSet.begin(), itEnd = rDataSet.end();
133 if (itPos != itEnd)
134 {
135 it = std::next(itPos);
136 }
137
138 it = std::find_if(it, itEnd, lIsMatch);
139 if (it != itEnd)
140 {
141 rResult = it->GetString();
142 return it;
143 }
144 }
145
146 return rDataSet.end(); // no matching text found
147 }
148
149 OUString getExactMatch(const ScTypedCaseStrSet& rDataSet, const OUString& rString)
150 {
151 auto it = std::find_if(rDataSet.begin(), rDataSet.end(),
152 [&rString](const ScTypedStrData& rData) {
153 return (rData.GetStringType() != ScTypedStrData::Value)
154 && ScGlobal::GetTransliteration().isEqual(rData.GetString(), rString);
155 });
156 if (it != rDataSet.end())
157 return it->GetString();
158 return rString;
159 }
160
161 // This assumes that rResults is a sorted ring w.r.t ScTypedStrData::LessCaseInsensitive() or
162 // in the reverse direction, whose origin is specified by nRingOrigin.
163 sal_Int32 getLongestCommonPrefixLength(const std::vector<OUString>& rResults, std::u16string_view aUserEntry, sal_Int32 nRingOrigin)
164 {
165 sal_Int32 nResults = rResults.size();
166 if (!nResults)
167 return 0;
168
169 if (nResults == 1)
170 return rResults[0].getLength();
171
172 sal_Int32 nMinLen = aUserEntry.size();
173 sal_Int32 nLastIdx = nRingOrigin ? nRingOrigin - 1 : nResults - 1;
174 const OUString& rFirst = rResults[nRingOrigin];
175 const OUString& rLast = rResults[nLastIdx];
176 const sal_Int32 nMaxLen = std::min(rFirst.getLength(), rLast.getLength());
177
178 for (sal_Int32 nLen = nMaxLen; nLen > nMinLen; --nLen)
179 {
180 if (ScGlobal::GetTransliteration().isMatch(rFirst.copy(0, nLen), rLast))
181 return nLen;
182 }
183
184 return nMinLen;
185 }
186
187 ScTypedCaseStrSet::const_iterator findTextAll(
188 const ScTypedCaseStrSet& rDataSet, ScTypedCaseStrSet::const_iterator const & itPos,
189 const OUString& rStart, ::std::vector< OUString > &rResultVec, bool bBack, sal_Int32* pLongestPrefixLen = nullptr)
190 {
191 rResultVec.clear(); // clear contents
192
193 if (!rDataSet.size())
194 return rDataSet.end();
195
196 sal_Int32 nRingOrigin = 0;
197 size_t nCount = 0;
198 ScTypedCaseStrSet::const_iterator retit;
199 if ( bBack ) // Backwards
200 {
201 ScTypedCaseStrSet::const_reverse_iterator it, itEnd;
202 if ( itPos == rDataSet.end() )
203 {
204 it = rDataSet.rend();
205 --it;
206 itEnd = it;
207 }
208 else
209 {
210 it = rDataSet.rbegin();
211 size_t nPos = std::distance(rDataSet.begin(), itPos);
212 size_t nRPos = rDataSet.size() - 1 - nPos; // if itPos == rDataSet.end(), then nRPos = -1
213 std::advance(it, nRPos);
214 if ( it == rDataSet.rend() )
215 it = rDataSet.rbegin();
216 itEnd = it;
217 }
218 bool bFirstTime = true;
219
220 while ( it != itEnd || bFirstTime )
221 {
222 ++it;
223 if ( it == rDataSet.rend() ) // go to the first if reach the end
224 {
225 it = rDataSet.rbegin();
226 nRingOrigin = nCount;
227 }
228
229 if ( bFirstTime )
230 bFirstTime = false;
231 const ScTypedStrData& rData = *it;
232 if ( rData.GetStringType() == ScTypedStrData::Value )
233 // skip values
234 continue;
235
236 if ( !ScGlobal::GetTransliteration().isMatch(rStart, rData.GetString()) )
237 // not a match
238 continue;
239
240 rResultVec.push_back(rData.GetString()); // set the match data
241 if ( nCount == 0 ) // convert the reverse iterator back to iterator.
242 {
243 // actually we want to do "retit = it;".
244 retit = rDataSet.begin();
245 size_t nRPos = std::distance(rDataSet.rbegin(), it);
246 size_t nPos = rDataSet.size() - 1 - nRPos;
247 std::advance(retit, nPos);
248 }
249 ++nCount;
250 }
251 }
252 else // Forwards
253 {
254 ScTypedCaseStrSet::const_iterator it, itEnd;
255 it = itPos;
256 if ( it == rDataSet.end() )
257 it = --rDataSet.end();
258 itEnd = it;
259 bool bFirstTime = true;
260
261 while ( it != itEnd || bFirstTime )
262 {
263 ++it;
264 if ( it == rDataSet.end() ) // go to the first if reach the end
265 {
266 it = rDataSet.begin();
267 nRingOrigin = nCount;
268 }
269
270 if ( bFirstTime )
271 bFirstTime = false;
272 const ScTypedStrData& rData = *it;
273 if ( rData.GetStringType() == ScTypedStrData::Value )
274 // skip values
275 continue;
276
277 if ( !ScGlobal::GetTransliteration().isMatch(rStart, rData.GetString()) )
278 // not a match
279 continue;
280
281 rResultVec.push_back(rData.GetString()); // set the match data
282 if ( nCount == 0 )
283 retit = it; // remember first match iterator
284 ++nCount;
285 }
286 }
287
288 if (pLongestPrefixLen)
289 {
290 if (nRingOrigin >= static_cast<sal_Int32>(nCount))
291 {
292 // All matches were picked when rDataSet was read in one direction.
293 nRingOrigin = 0;
294 }
295 // rResultsVec is a sorted ring with nRingOrigin "origin".
296 // The direction of sorting is not important for getLongestCommonPrefixLength.
297 *pLongestPrefixLen = getLongestCommonPrefixLength(rResultVec, rStart, nRingOrigin);
298 }
299
300 if ( nCount > 0 ) // at least one function has matched
301 return retit;
302 return rDataSet.end(); // no matching text found
303 }
304
305 }
306
307 void ScInputHandler::SendReferenceMarks( const SfxViewShell* pViewShell,
308 const std::vector<ReferenceMark>& rReferenceMarks )
309 {
310 if ( !pViewShell )
311 return;
312
313 bool bSend = false;
314
315 std::stringstream ss;
316
317 ss << "{ \"marks\": [ ";
318
319 for ( size_t i = 0; i < rReferenceMarks.size(); i++ )
320 {
321 if ( rReferenceMarks[i].Is() )
322 {
323 if ( bSend )
324 ss << ", ";
325
326 ss << "{ \"rectangle\": \""
327 << rReferenceMarks[i].nX << ", "
328 << rReferenceMarks[i].nY << ", "
329 << rReferenceMarks[i].nWidth << ", "
330 << rReferenceMarks[i].nHeight << "\", "
331 "\"color\": \"" << rReferenceMarks[i].aColor.AsRGBHexString() << "\", "
332 "\"part\": \"" << rReferenceMarks[i].nTab << "\" } ";
333
334 bSend = true;
335 }
336 }
337
338 ss << " ] }";
339
340 OString aPayload = ss.str().c_str();
341 pViewShell->libreOfficeKitViewCallback(
342 LOK_CALLBACK_REFERENCE_MARKS, aPayload.getStr() );
343 }
344
345 static inline void incPos( const sal_Unicode c, sal_Int32& rPos, ESelection& rSel )
346 {
347 ++rPos;
348 if (c == '\n')
349 {
350 ++rSel.nEndPara;
351 rSel.nEndPos = 0;
352 }
353 else
354 {
355 ++rSel.nEndPos;
356 }
357 }
358
359 void ScInputHandler::InitRangeFinder( const OUString& rFormula )
360 {
361 DeleteRangeFinder();
362 if ( !pActiveViewSh || !SC_MOD()->GetInputOptions().GetRangeFinder() )
363 return;
364 ScDocShell* pDocSh = pActiveViewSh->GetViewData().GetDocShell();
365 ScDocument& rDoc = pDocSh->GetDocument();
366 const sal_Unicode cSheetSep = rDoc.GetSheetSeparator();
367
368 OUString aDelimiters = ScEditUtil::ModifyDelimiters(" !~%\"\t\n");
369 // delimiters (in addition to ScEditUtil): only characters that are
370 // allowed in formulas next to references and the quotation mark (so
371 // string constants can be skipped)
372
373 sal_Int32 nColon = aDelimiters.indexOf( ':' );
374 if ( nColon != -1 )
375 aDelimiters = aDelimiters.replaceAt( nColon, 1, u""); // Delimiter without colon
376 sal_Int32 nDot = aDelimiters.indexOf(cSheetSep);
377 if ( nDot != -1 )
378 aDelimiters = aDelimiters.replaceAt( nDot, 1 , u""); // Delimiter without dot
379
380 const sal_Unicode* pChar = rFormula.getStr();
381 sal_Int32 nLen = rFormula.getLength();
382 sal_Int32 nPos = 0;
383 sal_Int32 nStart = 0;
384 ESelection aSel;
385 sal_uInt16 nCount = 0;
386 ScRange aRange;
387 while ( nPos < nLen && nCount < RANGEFIND_MAX )
388 {
389 // Skip separator
390 while ( nPos<nLen && ScGlobal::UnicodeStrChr( aDelimiters.getStr(), pChar[nPos] ) )
391 {
392 if ( pChar[nPos] == '"' ) // String
393 {
394 incPos( pChar[nPos], nPos, aSel);
395 while (nPos<nLen && pChar[nPos] != '"') // Skip until end
396 incPos( pChar[nPos], nPos, aSel);
397 }
398 incPos( pChar[nPos], nPos, aSel); // Separator or closing quote
399 }
400
401 // Text between separators. We only consider within one line/paragraph.
402 aSel.nStartPara = aSel.nEndPara;
403 aSel.nStartPos = aSel.nEndPos;
404 nStart = nPos;
405 handle_r1c1:
406 {
407 bool bSingleQuoted = false;
408 while (nPos < nLen)
409 {
410 // tdf#114113: handle addresses with quoted sheet names like "'Sheet 1'.A1"
411 // Literal single quotes in sheet names are masked by another single quote
412 if (pChar[nPos] == '\'')
413 {
414 bSingleQuoted = !bSingleQuoted;
415 }
416 else if (!bSingleQuoted) // Get everything in single quotes, including separators
417 {
418 if (ScGlobal::UnicodeStrChr(aDelimiters.getStr(), pChar[nPos]))
419 break;
420 }
421 incPos( pChar[nPos], nPos, aSel);
422 }
423 }
424
425 // for R1C1 '-' in R[-]... or C[-]... are not delimiters
426 // Nothing heroic here to ensure that there are '[]' around a negative
427 // integer. we need to clean up this code.
428 if( nPos < nLen && nPos > 0 &&
429 '-' == pChar[nPos] && '[' == pChar[nPos-1] &&
430 formula::FormulaGrammar::CONV_XL_R1C1 == rDoc.GetAddressConvention() )
431 {
432 incPos( pChar[nPos], nPos, aSel);
433 goto handle_r1c1;
434 }
435
436 if ( nPos > nStart )
437 {
438 OUString aTest = rFormula.copy( nStart, nPos-nStart );
439 const ScAddress::Details aAddrDetails( rDoc, aCursorPos );
440 ScRefFlags nFlags = aRange.ParseAny( aTest, rDoc, aAddrDetails );
441 if ( nFlags & ScRefFlags::VALID )
442 {
443 // Set tables if not specified
444 if ( (nFlags & ScRefFlags::TAB_3D) == ScRefFlags::ZERO)
445 aRange.aStart.SetTab( pActiveViewSh->GetViewData().GetTabNo() );
446 if ( (nFlags & ScRefFlags::TAB2_3D) == ScRefFlags::ZERO)
447 aRange.aEnd.SetTab( aRange.aStart.Tab() );
448
449 if ( ( nFlags & (ScRefFlags::COL2_VALID|ScRefFlags::ROW2_VALID|ScRefFlags::TAB2_VALID) ) ==
450 ScRefFlags::ZERO )
451 {
452 // #i73766# if a single ref was parsed, set the same "abs" flags for ref2,
453 // so Format doesn't output a double ref because of different flags.
454 ScRefFlags nAbsFlags = nFlags & (ScRefFlags::COL_ABS|ScRefFlags::ROW_ABS|ScRefFlags::TAB_ABS);
455 applyStartToEndFlags(nFlags, nAbsFlags);
456 }
457
458 if (!nCount)
459 {
460 mpEditEngine->SetUpdateLayout( false );
461 pRangeFindList.reset(new ScRangeFindList( pDocSh->GetTitle() ));
462 }
463
464 Color nColor = pRangeFindList->Insert( ScRangeFindData( aRange, nFlags, aSel));
465
466 SfxItemSet aSet( mpEditEngine->GetEmptyItemSet() );
467 aSet.Put( SvxColorItem( nColor, EE_CHAR_COLOR ) );
468 mpEditEngine->QuickSetAttribs( aSet, aSel );
469 ++nCount;
470 }
471 }
472
473 // Do not skip last separator; could be a quote (?)
474 }
475
476 UpdateLokReferenceMarks();
477
478 if (nCount)
479 {
480 mpEditEngine->SetUpdateLayout( true );
481
482 pDocSh->Broadcast( SfxHint( SfxHintId::ScShowRangeFinder ) );
483 }
484 }
485
486 ReferenceMark ScInputHandler::GetReferenceMark( const ScViewData& rViewData, ScDocShell* pDocSh,
487 tools::Long nX1, tools::Long nX2, tools::Long nY1, tools::Long nY2,
488 tools::Long nTab, const Color& rColor )
489 {
490 ScSplitPos eWhich = rViewData.GetActivePart();
491
492 // This method is LOK specific.
493 if (comphelper::LibreOfficeKit::isCompatFlagSet(
494 comphelper::LibreOfficeKit::Compat::scPrintTwipsMsgs))
495 {
496 SCCOL nCol1 = nX1, nCol2 = nX2;
497 SCROW nRow1 = nY1, nRow2 = nY2;
498 ScDocument& rDoc = pDocSh->GetDocument();
499
500 PutInOrder(nCol1, nCol2);
501 PutInOrder(nRow1, nRow2);
502
503 if (nCol1 == nCol2 && nRow1 == nRow2)
504 rDoc.ExtendMerge(nCol1, nRow1, nCol2, nRow2, nTab);
505 else if (rDoc.HasAttrib(nCol2, nRow2, nTab, HasAttrFlags::Merged))
506 rDoc.ExtendMerge(nCol2, nRow2, nCol2, nRow2, nTab);
507
508 Point aTopLeft = rViewData.GetPrintTwipsPos(nCol1, nRow1);
509 Point aBottomRight = rViewData.GetPrintTwipsPos(nCol2 + 1, nRow2 + 1);
510 tools::Long nSizeX = aBottomRight.X() - aTopLeft.X() - 1;
511 tools::Long nSizeY = aBottomRight.Y() - aTopLeft.Y() - 1;
512
513 return ReferenceMark(aTopLeft.X(), aTopLeft.Y(), nSizeX, nSizeY, nTab, rColor);
514 }
515
516 Point aScrPos = rViewData.GetScrPos( nX1, nY1, eWhich );
517 tools::Long nScrX = aScrPos.X();
518 tools::Long nScrY = aScrPos.Y();
519
520 double nPPTX = rViewData.GetPPTX();
521 double nPPTY = rViewData.GetPPTY();
522
523 Fraction aZoomX = rViewData.GetZoomX();
524 Fraction aZoomY = rViewData.GetZoomY();
525
526 ScTableInfo aTabInfo;
527 pDocSh->GetDocument().FillInfo( aTabInfo, nX1, nY1, nX2, nY2,
528 nTab, nPPTX, nPPTY, false, false );
529
530 ScOutputData aOutputData( nullptr, OUTTYPE_WINDOW, aTabInfo,
531 &( pDocSh->GetDocument() ), nTab,
532 nScrX, nScrY,
533 nX1, nY1, nX2, nY2,
534 nPPTX, nPPTY,
535 &aZoomX, &aZoomY );
536
537 return aOutputData.FillReferenceMark( nX1, nY1, nX2, nY2,
538 rColor );
539 }
540
541 void ScInputHandler::UpdateLokReferenceMarks()
542 {
543 if ( !comphelper::LibreOfficeKit::isActive())
544 return;
545
546 ScTabViewShell* pShell = pActiveViewSh ? pActiveViewSh
547 : dynamic_cast<ScTabViewShell*>(SfxViewShell::Current());
548
549 if (!pShell)
550 return;
551
552 ScViewData& rViewData = pShell->GetViewData();
553 ScDocShell* pDocSh = rViewData.GetDocShell();
554 ScRangeFindList* pRangeFinder = GetRangeFindList();
555
556 if ( !pRangeFinder && !rViewData.IsRefMode() )
557 return;
558
559 sal_uInt16 nAdditionalMarks = 0;
560 std::vector<ReferenceMark> aReferenceMarks( 1 );
561
562 if ( rViewData.IsRefMode() )
563 {
564 nAdditionalMarks = 1;
565
566 const svtools::ColorConfig& rColorCfg = SC_MOD()->GetColorConfig();
567 Color aRefColor( rColorCfg.GetColorValue( svtools::CALCREFERENCE ).nColor );
568 tools::Long nX1 = rViewData.GetRefStartX();
569 tools::Long nX2 = rViewData.GetRefEndX();
570 tools::Long nY1 = rViewData.GetRefStartY();
571 tools::Long nY2 = rViewData.GetRefEndY();
572 tools::Long nTab = rViewData.GetRefStartZ();
573
574 if (rViewData.GetRefEndZ() == rViewData.GetTabNo())
575 nTab = rViewData.GetRefEndZ();
576
577 PutInOrder(nX1, nX2);
578 PutInOrder(nY1, nY2);
579
580 aReferenceMarks[0] = ScInputHandler::GetReferenceMark( rViewData, pDocSh,
581 nX1, nX2, nY1, nY2,
582 nTab, aRefColor );
583 }
584
585 sal_uInt16 nCount = pRangeFinder ?
586 ( static_cast<sal_uInt16>( pRangeFinder->Count() ) + nAdditionalMarks ) : nAdditionalMarks;
587 aReferenceMarks.resize( nCount );
588
589 if ( nCount && pRangeFinder && !pRangeFinder->IsHidden() &&
590 pRangeFinder->GetDocName() == pDocSh->GetTitle() )
591 {
592 for (sal_uInt16 i = 0; i < nCount - nAdditionalMarks; i++)
593 {
594 ScRangeFindData& rData = pRangeFinder->GetObject( i );
595 ScRange aRef = rData.aRef;
596 aRef.PutInOrder();
597
598 tools::Long nX1 = aRef.aStart.Col();
599 tools::Long nX2 = aRef.aEnd.Col();
600 tools::Long nY1 = aRef.aStart.Row();
601 tools::Long nY2 = aRef.aEnd.Row();
602 tools::Long nTab = aRef.aStart.Tab();
603
604 aReferenceMarks[i + nAdditionalMarks] = ScInputHandler::GetReferenceMark( rViewData, pDocSh,
605 nX1, nX2, nY1, nY2,
606 nTab, rData.nColor );
607
608 ScInputHandler::SendReferenceMarks( pShell, aReferenceMarks );
609 }
610 }
611 else if ( nCount )
612 {
613 ScInputHandler::SendReferenceMarks( pShell, aReferenceMarks );
614 }
615 else
616 {
617 // Clear
618 aReferenceMarks.clear();
619 ScInputHandler::SendReferenceMarks( pShell, aReferenceMarks );
620 }
621 }
622
623 void ScInputHandler::SetDocumentDisposing( bool b )
624 {
625 mbDocumentDisposing = b;
626 }
627
628 static void lcl_Replace( EditView* pView, const OUString& rNewStr, const ESelection& rOldSel )
629 {
630 if ( !pView )
631 return;
632
633 ESelection aOldSel = pView->GetSelection();
634 if (aOldSel.HasRange())
635 pView->SetSelection( ESelection( aOldSel.nEndPara, aOldSel.nEndPos,
636 aOldSel.nEndPara, aOldSel.nEndPos ) );
637
638 EditEngine* pEngine = pView->GetEditEngine();
639 pEngine->QuickInsertText( rNewStr, rOldSel );
640
641 // Dummy InsertText for Update and Paint
642 // To do that we need to cancel the selection from above (before QuickInsertText)
643 pView->InsertText( OUString() );
644
645 const sal_Int32 nPara = pEngine->GetParagraphCount() - 1;
646 const sal_Int32 nLen = pEngine->GetTextLen(nPara);
647 ESelection aSel( nPara, nLen, nPara, nLen );
648 pView->SetSelection( aSel ); // Set cursor to the end
649 }
650
651 void ScInputHandler::UpdateRange( sal_uInt16 nIndex, const ScRange& rNew )
652 {
653 ScTabViewShell* pDocView = pRefViewSh ? pRefViewSh : pActiveViewSh;
654 if ( pDocView && pRangeFindList && nIndex < pRangeFindList->Count() )
655 {
656 ScRangeFindData& rData = pRangeFindList->GetObject( nIndex );
657 Color nNewColor = pRangeFindList->FindColor( rNew, nIndex );
658
659 ScRange aJustified = rNew;
660 aJustified.PutInOrder(); // Always display Ref in the Formula the right way
661 ScDocument& rDoc = pDocView->GetViewData().GetDocument();
662 const ScAddress::Details aAddrDetails( rDoc, aCursorPos );
663 OUString aNewStr(aJustified.Format(rDoc, rData.nFlags, aAddrDetails));
664 SfxItemSet aSet( mpEditEngine->GetEmptyItemSet() );
665
666 DataChanging();
667
668 lcl_Replace( pTopView, aNewStr, rData.maSel );
669 lcl_Replace( pTableView, aNewStr, rData.maSel );
670
671 // We are within one paragraph.
672 const sal_Int32 nDiff = aNewStr.getLength() - (rData.maSel.nEndPos - rData.maSel.nStartPos);
673 rData.maSel.nEndPos += nDiff;
674
675 aSet.Put( SvxColorItem( nNewColor, EE_CHAR_COLOR ) );
676 mpEditEngine->QuickSetAttribs( aSet, rData.maSel );
677
678 bInRangeUpdate = true;
679 DataChanged();
680 bInRangeUpdate = false;
681
682 rData.aRef = rNew;
683 rData.nColor = nNewColor;
684
685 if (nDiff)
686 {
687 const size_t nCount = pRangeFindList->Count();
688 for (size_t i = nIndex + 1; i < nCount; ++i)
689 {
690 ScRangeFindData& rNext = pRangeFindList->GetObject( i );
691 if (rNext.maSel.nStartPara != rData.maSel.nStartPara)
692 break;
693
694 rNext.maSel.nStartPos += nDiff;
695 rNext.maSel.nEndPos += nDiff;
696 }
697 }
698
699 EditView* pActiveView = pTopView ? pTopView : pTableView;
700 pActiveView->ShowCursor( false );
701 }
702 else
703 {
704 OSL_FAIL("UpdateRange: we're missing something");
705 }
706 }
707
708 void ScInputHandler::DeleteRangeFinder()
709 {
710 ScTabViewShell* pPaintView = pRefViewSh ? pRefViewSh : pActiveViewSh;
711 if ( pRangeFindList && pPaintView )
712 {
713 ScDocShell* pDocSh = pActiveViewSh->GetViewData().GetDocShell();
714 pRangeFindList->SetHidden(true);
715 pDocSh->Broadcast( SfxHint( SfxHintId::ScShowRangeFinder ) ); // Steal
716 pRangeFindList.reset();
717 }
718 }
719
720 static OUString GetEditText(const EditEngine* pEng)
721 {
722 return ScEditUtil::GetMultilineString(*pEng);
723 }
724
725 static void lcl_RemoveTabs(OUString& rStr)
726 {
727 rStr = rStr.replace('\t', ' ');
728 }
729
730 static void lcl_RemoveLineEnd(OUString& rStr)
731 {
732 rStr = convertLineEnd(rStr, LINEEND_LF);
733 rStr = rStr.replace('\n', ' ');
734 }
735
736 static sal_Int32 lcl_MatchParenthesis( const OUString& rStr, sal_Int32 nPos )
737 {
738 int nDir;
739 sal_Unicode c1, c2 = 0;
740 c1 = rStr[nPos];
741 switch ( c1 )
742 {
743 case '(' :
744 c2 = ')';
745 nDir = 1;
746 break;
747 case ')' :
748 c2 = '(';
749 nDir = -1;
750 break;
751 case '<' :
752 c2 = '>';
753 nDir = 1;
754 break;
755 case '>' :
756 c2 = '<';
757 nDir = -1;
758 break;
759 case '{' :
760 c2 = '}';
761 nDir = 1;
762 break;
763 case '}' :
764 c2 = '{';
765 nDir = -1;
766 break;
767 case '[' :
768 c2 = ']';
769 nDir = 1;
770 break;
771 case ']' :
772 c2 = '[';
773 nDir = -1;
774 break;
775 default:
776 nDir = 0;
777 }
778 if ( !nDir )
779 return -1;
780 sal_Int32 nLen = rStr.getLength();
781 const sal_Unicode* p0 = rStr.getStr();
782 const sal_Unicode* p;
783 const sal_Unicode* p1;
784 sal_uInt16 nQuotes = 0;
785 if ( nPos < nLen / 2 )
786 {
787 p = p0;
788 p1 = p0 + nPos;
789 }
790 else
791 {
792 p = p0 + nPos;
793 p1 = p0 + nLen;
794 }
795 while ( p < p1 )
796 {
797 if ( *p++ == '\"' )
798 nQuotes++;
799 }
800 // Odd number of quotes that we find ourselves in a string
801 bool bLookInString = ((nQuotes % 2) != 0);
802 bool bInString = bLookInString;
803 p = p0 + nPos;
804 p1 = (nDir < 0 ? p0 : p0 + nLen) ;
805 sal_uInt16 nLevel = 1;
806 while ( p != p1 && nLevel )
807 {
808 p += nDir;
809 if ( *p == '\"' )
810 {
811 bInString = !bInString;
812 if ( bLookInString && !bInString )
813 p = p1; // That's it then
814 }
815 else if ( bInString == bLookInString )
816 {
817 if ( *p == c1 )
818 nLevel++;
819 else if ( *p == c2 )
820 nLevel--;
821 }
822 }
823 if ( nLevel )
824 return -1;
825 return static_cast<sal_Int32>(p - p0);
826 }
827
828 ScInputHandler::ScInputHandler()
829 : pInputWin( nullptr ),
830 pTableView( nullptr ),
831 pTopView( nullptr ),
832 pTipVisibleParent( nullptr ),
833 nTipVisible( nullptr ),
834 pTipVisibleSecParent( nullptr ),
835 nTipVisibleSec( nullptr ),
836 nFormSelStart( 0 ),
837 nFormSelEnd( 0 ),
838 nCellPercentFormatDecSep( 0 ),
839 nAutoPar( 0 ),
840 eMode( SC_INPUT_NONE ),
841 bUseTab( false ),
842 bTextValid( true ),
843 bModified( false ),
844 bSelIsRef( false ),
845 bFormulaMode( false ),
846 bInRangeUpdate( false ),
847 bParenthesisShown( false ),
848 bCreatingFuncView( false ),
849 bInEnterHandler( false ),
850 bCommandErrorShown( false ),
851 bInOwnChange( false ),
852 bProtected( false ),
853 bLastIsSymbol( false ),
854 mbDocumentDisposing(false),
855 mbPartialPrefix(false),
856 mbEditingExistingContent(false),
857 nValidation( 0 ),
858 eAttrAdjust( SvxCellHorJustify::Standard ),
859 aScaleX( 1,1 ),
860 aScaleY( 1,1 ),
861 pRefViewSh( nullptr ),
862 pLastPattern( nullptr )
863 {
864 // The InputHandler is constructed with the view, so SfxViewShell::Current
865 // doesn't have the right view yet. pActiveViewSh is updated in NotifyChange.
866 pActiveViewSh = nullptr;
867
868 // Bindings (only still used for Invalidate) are retrieved if needed on demand
869
870 pDelayTimer.reset( new Timer( "ScInputHandlerDelay timer" ) );
871 pDelayTimer->SetTimeout( 500 ); // 500 ms delay
872 pDelayTimer->SetInvokeHandler( LINK( this, ScInputHandler, DelayTimer ) );
873 }
874
875 ScInputHandler::~ScInputHandler()
876 {
877 // If this is the application InputHandler, the dtor is called after SfxApplication::Main,
878 // thus we can't rely on any Sfx functions
879 if (!mbDocumentDisposing) // inplace
880 EnterHandler(); // Finish input
881
882 if (SC_MOD()->GetRefInputHdl() == this)
883 SC_MOD()->SetRefInputHdl(nullptr);
884
885 if ( pInputWin && pInputWin->GetInputHandler() == this )
886 pInputWin->SetInputHandler( nullptr );
887 }
888
889 void ScInputHandler::SetRefScale( const Fraction& rX, const Fraction& rY )
890 {
891 if ( rX != aScaleX || rY != aScaleY )
892 {
893 aScaleX = rX;
894 aScaleY = rY;
895 if (mpEditEngine)
896 {
897 MapMode aMode( MapUnit::Map100thMM, Point(), aScaleX, aScaleY );
898 mpEditEngine->SetRefMapMode( aMode );
899 }
900 }
901 }
902
903 void ScInputHandler::UpdateRefDevice()
904 {
905 if (!mpEditEngine)
906 return;
907
908 bool bTextWysiwyg = SC_MOD()->GetInputOptions().GetTextWysiwyg();
909 bool bInPlace = pActiveViewSh && pActiveViewSh->GetViewFrame()->GetFrame().IsInPlace();
910 EEControlBits nCtrl = mpEditEngine->GetControlWord();
911 if ( bTextWysiwyg || bInPlace )
912 nCtrl |= EEControlBits::FORMAT100; // EditEngine default: always format for 100%
913 else
914 nCtrl &= ~EEControlBits::FORMAT100; // when formatting for screen, use the actual MapMode
915 mpEditEngine->SetControlWord( nCtrl );
916 if ( bTextWysiwyg && pActiveViewSh )
917 mpEditEngine->SetRefDevice( pActiveViewSh->GetViewData().GetDocument().GetPrinter() );
918 else
919 mpEditEngine->SetRefDevice( nullptr );
920
921 MapMode aMode( MapUnit::Map100thMM, Point(), aScaleX, aScaleY );
922 mpEditEngine->SetRefMapMode( aMode );
923
924 // SetRefDevice(NULL) uses VirtualDevice, SetRefMapMode forces creation of a local VDev,
925 // so the DigitLanguage can be safely modified (might use an own VDev instead of NULL).
926 if ( !( bTextWysiwyg && pActiveViewSh ) )
927 {
928 mpEditEngine->GetRefDevice()->SetDigitLanguage( SC_MOD()->GetOptDigitLanguage() );
929 }
930 }
931
932 void ScInputHandler::ImplCreateEditEngine()
933 {
934 if ( mpEditEngine )
935 return;
936
937 if ( pActiveViewSh )
938 {
939 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
940 mpEditEngine = std::make_unique<ScFieldEditEngine>(&rDoc, rDoc.GetEnginePool(), rDoc.GetEditPool());
941 }
942 else
943 mpEditEngine = std::make_unique<ScFieldEditEngine>(nullptr, EditEngine::CreatePool().get(), nullptr, true);
944
945 mpEditEngine->SetWordDelimiters( ScEditUtil::ModifyDelimiters( mpEditEngine->GetWordDelimiters() ) );
946 UpdateRefDevice(); // also sets MapMode
947 mpEditEngine->SetPaperSize( Size( 1000000, 1000000 ) );
948 pEditDefaults.reset( new SfxItemSet( mpEditEngine->GetEmptyItemSet() ) );
949
950 mpEditEngine->SetControlWord( mpEditEngine->GetControlWord() | EEControlBits::AUTOCORRECT );
951 mpEditEngine->SetReplaceLeadingSingleQuotationMark( false );
952 mpEditEngine->SetModifyHdl( LINK( this, ScInputHandler, ModifyHdl ) );
953 }
954
955 void ScInputHandler::UpdateAutoCorrFlag()
956 {
957 EEControlBits nCntrl = mpEditEngine->GetControlWord();
958 EEControlBits nOld = nCntrl;
959
960 // Don't use pLastPattern here (may be invalid because of AutoStyle)
961 bool bDisable = bLastIsSymbol || bFormulaMode;
962 if ( bDisable )
963 nCntrl &= ~EEControlBits::AUTOCORRECT;
964 else
965 nCntrl |= EEControlBits::AUTOCORRECT;
966
967 if ( nCntrl != nOld )
968 mpEditEngine->SetControlWord(nCntrl);
969 }
970
971 void ScInputHandler::UpdateSpellSettings( bool bFromStartTab )
972 {
973 if ( !pActiveViewSh )
974 return;
975
976 ScViewData& rViewData = pActiveViewSh->GetViewData();
977 bool bOnlineSpell = rViewData.GetDocument().GetDocOptions().IsAutoSpell();
978
979 // SetDefaultLanguage is independent of the language attributes,
980 // ScGlobal::GetEditDefaultLanguage is always used.
981 // It must be set every time in case the office language was changed.
982
983 mpEditEngine->SetDefaultLanguage( ScGlobal::GetEditDefaultLanguage() );
984
985 // if called for changed options, update flags only if already editing
986 // if called from StartTable, always update flags
987
988 if ( bFromStartTab || eMode != SC_INPUT_NONE )
989 {
990 EEControlBits nCntrl = mpEditEngine->GetControlWord();
991 EEControlBits nOld = nCntrl;
992 if( bOnlineSpell )
993 nCntrl |= EEControlBits::ONLINESPELLING;
994 else
995 nCntrl &= ~EEControlBits::ONLINESPELLING;
996 // No AutoCorrect for Symbol Font (EditEngine does no evaluate Default)
997 if ( pLastPattern && pLastPattern->IsSymbolFont() )
998 nCntrl &= ~EEControlBits::AUTOCORRECT;
999 else
1000 nCntrl |= EEControlBits::AUTOCORRECT;
1001 if ( nCntrl != nOld )
1002 mpEditEngine->SetControlWord(nCntrl);
1003
1004 ScDocument& rDoc = rViewData.GetDocument();
1005 rDoc.ApplyAsianEditSettings( *mpEditEngine );
1006 mpEditEngine->SetDefaultHorizontalTextDirection(
1007 rDoc.GetEditTextDirection( rViewData.GetTabNo() ) );
1008 mpEditEngine->SetFirstWordCapitalization( false );
1009 }
1010
1011 // Language is set separately, so the speller is needed only if online spelling is active
1012 if ( bOnlineSpell ) {
1013 css::uno::Reference<css::linguistic2::XSpellChecker1> xXSpellChecker1( LinguMgr::GetSpellChecker() );
1014 mpEditEngine->SetSpeller( xXSpellChecker1 );
1015 }
1016
1017 bool bHyphen = pLastPattern && pLastPattern->GetItem(ATTR_HYPHENATE).GetValue();
1018 if ( bHyphen ) {
1019 css::uno::Reference<css::linguistic2::XHyphenator> xXHyphenator( LinguMgr::GetHyphenator() );
1020 mpEditEngine->SetHyphenator( xXHyphenator );
1021 }
1022 }
1023
1024 // Function/Range names etc. as Tip help
1025
1026 // The other types are defined in ScDocument::GetFormulaEntries
1027 void ScInputHandler::GetFormulaData()
1028 {
1029 if ( !pActiveViewSh )
1030 return;
1031
1032 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
1033
1034 if ( pFormulaData )
1035 pFormulaData->clear();
1036 else
1037 {
1038 pFormulaData.reset( new ScTypedCaseStrSet );
1039 }
1040
1041 if( pFormulaDataPara )
1042 pFormulaDataPara->clear();
1043 else
1044 pFormulaDataPara.reset( new ScTypedCaseStrSet );
1045
1046 const OUString aParenthesesReplacement( cParenthesesReplacement);
1047 const ScFunctionList* pFuncList = ScGlobal::GetStarCalcFunctionList();
1048 const sal_uInt32 nListCount = pFuncList->GetCount();
1049 const InputHandlerFunctionNames& rFunctionNames = ScGlobal::GetInputHandlerFunctionNames();
1050 *pFormulaData = rFunctionNames.maFunctionData;
1051 *pFormulaDataPara = rFunctionNames.maFunctionDataPara;
1052 maFormulaChar = rFunctionNames.maFunctionChar;
1053
1054 // Increase suggestion priority of MRU formulas
1055 const ScAppOptions& rOpt = SC_MOD()->GetAppOptions();
1056 const sal_uInt16 nMRUCount = rOpt.GetLRUFuncListCount();
1057 const sal_uInt16* pMRUList = rOpt.GetLRUFuncList();
1058 for (sal_uInt16 i = 0; i < nMRUCount; i++)
1059 {
1060 const sal_uInt16 nId = pMRUList[i];
1061 for (sal_uInt32 j = 0; j < nListCount; j++)
1062 {
1063 const ScFuncDesc* pDesc = pFuncList->GetFunction(j);
1064 if (pDesc->nFIndex == nId && pDesc->mxFuncName)
1065 {
1066 const OUString aEntry = *pDesc->mxFuncName + aParenthesesReplacement;;
1067 const ScTypedStrData aData(aEntry, 0.0, 0.0, ScTypedStrData::Standard);
1068 auto it = pFormulaData->find(aData);
1069 if (it != pFormulaData->end())
1070 pFormulaData->erase(it);
1071 pFormulaData->insert(ScTypedStrData(aEntry, 0.0, 0.0, ScTypedStrData::MRU));
1072 break; // Stop searching
1073 }
1074 }
1075 }
1076 miAutoPosFormula = pFormulaData->end();
1077
1078 // tdf#142031 - collect all the characters for the formula suggestion auto input
1079 ScTypedCaseStrSet aStrSet;
1080 rDoc.GetFormulaEntries( aStrSet );
1081 for (auto iter = aStrSet.begin(); iter != aStrSet.end(); ++iter)
1082 {
1083 const OUString aFuncName = ScGlobal::getCharClass().uppercase((*iter).GetString());
1084 // fdo#75264 fill maFormulaChar with all characters used in formula names
1085 for (sal_Int32 j = 0; j < aFuncName.getLength(); j++)
1086 maFormulaChar.insert(aFuncName[j]);
1087 }
1088 pFormulaData->insert(aStrSet.begin(), aStrSet.end());
1089 pFormulaDataPara->insert(aStrSet.begin(), aStrSet.end());
1090 }
1091
1092 IMPL_LINK( ScInputHandler, ShowHideTipVisibleParentListener, VclWindowEvent&, rEvent, void )
1093 {
1094 if (rEvent.GetId() == VclEventId::ObjectDying || rEvent.GetId() == VclEventId::WindowHide
1095 || rEvent.GetId() == VclEventId::WindowLoseFocus || rEvent.GetId() == VclEventId::ControlLoseFocus)
1096 HideTip();
1097 }
1098
1099 IMPL_LINK( ScInputHandler, ShowHideTipVisibleSecParentListener, VclWindowEvent&, rEvent, void )
1100 {
1101 if (rEvent.GetId() == VclEventId::ObjectDying || rEvent.GetId() == VclEventId::WindowHide
1102 || rEvent.GetId() == VclEventId::WindowLoseFocus || rEvent.GetId() == VclEventId::ControlLoseFocus)
1103 HideTipBelow();
1104 }
1105
1106 void ScInputHandler::HideTip()
1107 {
1108 if ( nTipVisible )
1109 {
1110 pTipVisibleParent->RemoveEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleParentListener ) );
1111 Help::HidePopover(pTipVisibleParent, nTipVisible );
1112 nTipVisible = nullptr;
1113 pTipVisibleParent = nullptr;
1114 }
1115 aManualTip.clear();
1116 }
1117 void ScInputHandler::HideTipBelow()
1118 {
1119 if ( nTipVisibleSec )
1120 {
1121 pTipVisibleSecParent->RemoveEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleSecParentListener ) );
1122 Help::HidePopover(pTipVisibleSecParent, nTipVisibleSec);
1123 nTipVisibleSec = nullptr;
1124 pTipVisibleSecParent = nullptr;
1125 }
1126 aManualTip.clear();
1127 }
1128
1129 namespace
1130 {
1131
1132 bool lcl_hasSingleToken(std::u16string_view s, sal_Unicode c)
1133 {
1134 return !s.empty() && s.find(c) == std::u16string_view::npos;
1135 }
1136
1137 }
1138
1139 void ScInputHandler::ShowArgumentsTip( OUString& rSelText )
1140 {
1141 if (comphelper::LibreOfficeKit::isActive())
1142 {
1143 return;
1144 }
1145
1146 if ( !pActiveViewSh )
1147 return;
1148
1149 ScDocShell* pDocSh = pActiveViewSh->GetViewData().GetDocShell();
1150 const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
1151 const sal_Unicode cSheetSep = pDocSh->GetDocument().GetSheetSeparator();
1152 FormulaHelper aHelper(ScGlobal::GetStarCalcFunctionMgr());
1153 bool bFound = false;
1154 while( !bFound )
1155 {
1156 rSelText += ")";
1157 sal_Int32 nLeftParentPos = lcl_MatchParenthesis( rSelText, rSelText.getLength()-1 );
1158 if( nLeftParentPos != -1 )
1159 {
1160 sal_Int32 nNextFStart = aHelper.GetFunctionStart( rSelText, nLeftParentPos, true);
1161 const IFunctionDescription* ppFDesc;
1162 ::std::vector< OUString> aArgs;
1163 if( aHelper.GetNextFunc( rSelText, false, nNextFStart, nullptr, &ppFDesc, &aArgs ) )
1164 {
1165 if( !ppFDesc->getFunctionName().isEmpty() )
1166 {
1167 sal_Int32 nArgPos = aHelper.GetArgStart( rSelText, nNextFStart, 0 );
1168 sal_uInt16 nArgs = static_cast<sal_uInt16>(ppFDesc->getParameterCount());
1169 OUString aFuncName( ppFDesc->getFunctionName() + "(");
1170 OUString aNew;
1171 ScTypedCaseStrSet::const_iterator it =
1172 findText(*pFormulaDataPara, pFormulaDataPara->end(), aFuncName, aNew, false);
1173 if (it != pFormulaDataPara->end())
1174 {
1175 bool bFlag = false;
1176 sal_uInt16 nActive = 0;
1177 for( sal_uInt16 i=0; i < nArgs; i++ )
1178 {
1179 sal_Int32 nLength = aArgs[i].getLength();
1180 if( nArgPos <= rSelText.getLength()-1 )
1181 {
1182 nActive = i+1;
1183 bFlag = true;
1184 }
1185 nArgPos+=nLength+1;
1186 }
1187 if( bFlag )
1188 {
1189 sal_Int32 nStartPosition = 0;
1190 sal_Int32 nEndPosition = 0;
1191
1192 if( lcl_hasSingleToken(aNew, cSep) )
1193 {
1194 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1195 {
1196 sal_Unicode cNext = aNew[i];
1197 if( cNext == '(' )
1198 {
1199 nStartPosition = i+1;
1200 }
1201 }
1202 }
1203 else if( lcl_hasSingleToken(aNew, cSheetSep) )
1204 {
1205 sal_uInt16 nCount = 0;
1206 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1207 {
1208 sal_Unicode cNext = aNew[i];
1209 if( cNext == '(' )
1210 {
1211 nStartPosition = i+1;
1212 }
1213 else if( cNext == cSep )
1214 {
1215 nCount ++;
1216 nEndPosition = i;
1217 if( nCount == nActive )
1218 {
1219 break;
1220 }
1221 nStartPosition = nEndPosition+1;
1222 }
1223 }
1224 }
1225 else
1226 {
1227 sal_uInt16 nCount = 0;
1228 for (sal_Int32 i = 0; i < aNew.getLength(); ++i)
1229 {
1230 sal_Unicode cNext = aNew[i];
1231 if( cNext == '(' )
1232 {
1233 nStartPosition = i+1;
1234 }
1235 else if( cNext == cSep )
1236 {
1237 nCount ++;
1238 nEndPosition = i;
1239 if( nCount == nActive )
1240 {
1241 break;
1242 }
1243 nStartPosition = nEndPosition+1;
1244 }
1245 else if( cNext == cSheetSep )
1246 {
1247 continue;
1248 }
1249 }
1250 }
1251
1252 if (nStartPosition > 0)
1253 {
1254 nArgs = ppFDesc->getParameterCount();
1255 sal_Int16 nVarArgsSet = 0;
1256 if ( nArgs >= PAIRED_VAR_ARGS )
1257 {
1258 nVarArgsSet = 2;
1259 nArgs -= PAIRED_VAR_ARGS - nVarArgsSet;
1260 }
1261 else if ( nArgs >= VAR_ARGS )
1262 {
1263 nVarArgsSet = 1;
1264 nArgs -= VAR_ARGS - nVarArgsSet;
1265 }
1266 if ( nVarArgsSet > 0 && nActive > nArgs )
1267 nActive = nArgs - (nActive - nArgs) % nVarArgsSet;
1268 aNew = OUString::Concat(aNew.subView(0, nStartPosition)) +
1269 u"\x25BA" +
1270 aNew.subView(nStartPosition) +
1271 " : " +
1272 ppFDesc->getParameterDescription(nActive-1);
1273 if (eMode != SC_INPUT_TOP)
1274 {
1275 ShowTipBelow( aNew );
1276 }
1277 else
1278 {
1279 ShowTip(aNew);
1280 }
1281 bFound = true;
1282 }
1283 }
1284 else
1285 {
1286 ShowTipBelow( aNew );
1287 bFound = true;
1288 }
1289 }
1290 }
1291 }
1292 }
1293 else
1294 {
1295 break;
1296 }
1297 }
1298 }
1299
1300 void ScInputHandler::ShowTipCursor()
1301 {
1302 HideTip();
1303 HideTipBelow();
1304 EditView* pActiveView = pTopView ? pTopView : pTableView;
1305
1306 /* TODO: MLFORMULA: this should work also with multi-line formulas. */
1307 if ( !(bFormulaMode && pActiveView && pFormulaDataPara && mpEditEngine->GetParagraphCount() == 1) )
1308 return;
1309
1310 OUString aParagraph = mpEditEngine->GetText( 0 );
1311 ESelection aSel = pActiveView->GetSelection();
1312 aSel.Adjust();
1313
1314 if ( aParagraph.getLength() < aSel.nEndPos )
1315 return;
1316
1317 if ( aSel.nEndPos > 0 )
1318 {
1319 OUString aSelText( aParagraph.copy( 0, aSel.nEndPos ));
1320
1321 ShowArgumentsTip( aSelText );
1322 }
1323 }
1324
1325 void ScInputHandler::ShowTip( const OUString& rText )
1326 {
1327 // aManualTip needs to be set afterwards from outside
1328
1329 HideTip();
1330 HideTipBelow();
1331
1332 EditView* pActiveView = pTopView ? pTopView : pTableView;
1333 if (!pActiveView)
1334 return;
1335
1336 Point aPos;
1337 if (pInputWin && pInputWin->GetEditView() == pActiveView)
1338 {
1339 pTipVisibleParent = pInputWin->GetEditWindow();
1340 aPos = pInputWin->GetCursorScreenPixelPos();
1341 }
1342 else
1343 {
1344 pTipVisibleParent = pActiveView->GetWindow();
1345 if (vcl::Cursor* pCur = pActiveView->GetCursor())
1346 aPos = pTipVisibleParent->LogicToPixel( pCur->GetPos() );
1347 aPos = pTipVisibleParent->OutputToScreenPixel( aPos );
1348 }
1349
1350 tools::Rectangle aRect( aPos, aPos );
1351 QuickHelpFlags const nAlign = QuickHelpFlags::Left|QuickHelpFlags::Bottom;
1352 nTipVisible = Help::ShowPopover(pTipVisibleParent, aRect, rText, nAlign);
1353 pTipVisibleParent->AddEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleParentListener ) );
1354 }
1355
1356 void ScInputHandler::ShowTipBelow( const OUString& rText )
1357 {
1358 HideTipBelow();
1359
1360 EditView* pActiveView = pTopView ? pTopView : pTableView;
1361 if ( !pActiveView )
1362 return;
1363
1364 Point aPos;
1365 if (pInputWin && pInputWin->GetEditView() == pActiveView)
1366 {
1367 pTipVisibleSecParent = pInputWin->GetEditWindow();
1368 aPos = pInputWin->GetCursorScreenPixelPos(true);
1369 }
1370 else
1371 {
1372 pTipVisibleSecParent = pActiveView->GetWindow();
1373 if (vcl::Cursor* pCur = pActiveView->GetCursor())
1374 {
1375 Point aLogicPos = pCur->GetPos();
1376 aLogicPos.AdjustY(pCur->GetHeight() );
1377 aPos = pTipVisibleSecParent->LogicToPixel( aLogicPos );
1378 }
1379 aPos = pTipVisibleSecParent->OutputToScreenPixel( aPos );
1380 }
1381
1382 tools::Rectangle aRect( aPos, aPos );
1383 QuickHelpFlags const nAlign = QuickHelpFlags::Left | QuickHelpFlags::Top | QuickHelpFlags::NoEvadePointer;
1384 nTipVisibleSec = Help::ShowPopover(pTipVisibleSecParent, aRect, rText, nAlign);
1385 pTipVisibleSecParent->AddEventListener( LINK( this, ScInputHandler, ShowHideTipVisibleSecParentListener ) );
1386 }
1387
1388 bool ScInputHandler::GetFuncName( OUString& aStart, OUString& aResult )
1389 {
1390 if ( aStart.isEmpty() )
1391 return false;
1392
1393 aStart = ScGlobal::getCharClass().uppercase( aStart );
1394 sal_Int32 nPos = aStart.getLength() - 1;
1395 sal_Unicode c = aStart[ nPos ];
1396 // fdo#75264 use maFormulaChar to check if characters are used in function names
1397 ::std::set< sal_Unicode >::const_iterator p = maFormulaChar.find( c );
1398 if ( p == maFormulaChar.end() )
1399 return false; // last character is not part of any function name, quit
1400
1401 ::std::vector<sal_Unicode> aTemp { c };
1402 for(sal_Int32 i = nPos - 1; i >= 0; --i)
1403 {
1404 c = aStart[ i ];
1405 p = maFormulaChar.find( c );
1406
1407 if (p == maFormulaChar.end())
1408 break;
1409
1410 aTemp.push_back( c );
1411 }
1412
1413 ::std::vector<sal_Unicode>::reverse_iterator rIt = aTemp.rbegin();
1414 aResult = OUString( *rIt++ );
1415 while ( rIt != aTemp.rend() )
1416 aResult += OUStringChar( *rIt++ );
1417
1418 return true;
1419 }
1420
1421 namespace {
1422 /// Rid ourselves of unwanted " quoted json characters.
1423 OString escapeJSON(const OUString &aStr)
1424 {
1425 OUString aEscaped = aStr;
1426 aEscaped = aEscaped.replaceAll("\n", " ");
1427 aEscaped = aEscaped.replaceAll("\"", "'");
1428 return OUStringToOString(aEscaped, RTL_TEXTENCODING_UTF8);
1429 }
1430 }
1431
1432 void ScInputHandler::ShowFuncList( const ::std::vector< OUString > & rFuncStrVec )
1433 {
1434 const SfxViewShell* pViewShell = SfxViewShell::Current();
1435 if (comphelper::LibreOfficeKit::isActive())
1436 {
1437 if (rFuncStrVec.size() && pViewShell && pViewShell->isLOKMobilePhone())
1438 {
1439 auto aPos = pFormulaData->begin();
1440 sal_uInt32 nCurIndex = std::distance(aPos, miAutoPosFormula);
1441 const sal_uInt32 nSize = pFormulaData->size();
1442
1443 OUString aFuncNameStr;
1444 OUString aDescFuncNameStr;
1445 OStringBuffer aPayload;
1446 aPayload.append("[ ");
1447 for (const OUString& rFunc : rFuncStrVec)
1448 {
1449 if ( rFunc[rFunc.getLength()-1] == cParenthesesReplacement )
1450 {
1451 aFuncNameStr = rFunc.copy(0, rFunc.getLength()-1);
1452 }
1453 else
1454 {
1455 aFuncNameStr = rFunc;
1456 }
1457
1458 FormulaHelper aHelper(ScGlobal::GetStarCalcFunctionMgr());
1459 aDescFuncNameStr = aFuncNameStr + "()";
1460 sal_Int32 nNextFStart = 0;
1461 const IFunctionDescription* ppFDesc;
1462 ::std::vector< OUString > aArgs;
1463 OUString eqPlusFuncName = "=" + aDescFuncNameStr;
1464 if ( aHelper.GetNextFunc( eqPlusFuncName, false, nNextFStart, nullptr, &ppFDesc, &aArgs ) )
1465 {
1466 if ( !ppFDesc->getFunctionName().isEmpty() )
1467 {
1468 aPayload.append("{");
1469 aPayload.append("\"index\": ");
1470 aPayload.append(static_cast<sal_Int64>(nCurIndex));
1471 aPayload.append(", ");
1472 aPayload.append("\"signature\": \"");
1473 aPayload.append(escapeJSON(ppFDesc->getSignature()));
1474 aPayload.append("\", ");
1475 aPayload.append("\"description\": \"");
1476 aPayload.append(escapeJSON(ppFDesc->getDescription()));
1477 aPayload.append("\"}, ");
1478 }
1479 }
1480 ++nCurIndex;
1481 if (nCurIndex == nSize)
1482 nCurIndex = 0;
1483 }
1484 sal_Int32 nLen = aPayload.getLength();
1485 aPayload[nLen - 2] = ' ';
1486 aPayload[nLen - 1] = ']';
1487
1488 OString s = aPayload.makeStringAndClear();
1489 pViewShell->libreOfficeKitViewCallback(LOK_CALLBACK_CALC_FUNCTION_LIST, s.getStr());
1490 }
1491 // not tunnel tooltips in the lok case
1492 return;
1493 }
1494
1495 OUStringBuffer aTipStr;
1496 OUString aFuncNameStr;
1497 OUString aDescFuncNameStr;
1498 ::std::vector<OUString>::const_iterator itStr = rFuncStrVec.begin();
1499 sal_Int32 nMaxFindNumber = 3;
1500 sal_Int32 nRemainFindNumber = nMaxFindNumber;
1501 for ( ; itStr != rFuncStrVec.end(); ++itStr )
1502 {
1503 const OUString& rFunc = *itStr;
1504 if ( rFunc[rFunc.getLength()-1] == cParenthesesReplacement )
1505 {
1506 aFuncNameStr = rFunc.copy(0, rFunc.getLength()-1);
1507 }
1508 else
1509 {
1510 aFuncNameStr = rFunc;
1511 }
1512 if ( itStr == rFuncStrVec.begin() )
1513 {
1514 aTipStr = "[";
1515 aDescFuncNameStr = aFuncNameStr + "()";
1516 }
1517 else
1518 {
1519 aTipStr.append(", ");
1520 }
1521 aTipStr.append(aFuncNameStr);
1522 if ( itStr == rFuncStrVec.begin() )
1523 aTipStr.append("]");
1524 if ( --nRemainFindNumber <= 0 )
1525 break;
1526 }
1527 sal_Int32 nRemainNumber = rFuncStrVec.size() - nMaxFindNumber;
1528 if ( nRemainFindNumber == 0 && nRemainNumber > 0 )
1529 {
1530 OUString aMessage( ScResId( STR_FUNCTIONS_FOUND ) );
1531 aMessage = aMessage.replaceFirst("%2", OUString::number(nRemainNumber));
1532 aMessage = aMessage.replaceFirst("%1", aTipStr);
1533 aTipStr = aMessage;
1534 }
1535 FormulaHelper aHelper(ScGlobal::GetStarCalcFunctionMgr());
1536 sal_Int32 nNextFStart = 0;
1537 const IFunctionDescription* ppFDesc;
1538 ::std::vector< OUString > aArgs;
1539 OUString eqPlusFuncName = "=" + aDescFuncNameStr;
1540 if ( aHelper.GetNextFunc( eqPlusFuncName, false, nNextFStart, nullptr, &ppFDesc, &aArgs ) )
1541 {
1542 if ( !ppFDesc->getFunctionName().isEmpty() )
1543 {
1544 aTipStr.append(" : " + ppFDesc->getDescription());
1545 }
1546 }
1547 ShowTip( aTipStr.makeStringAndClear() );
1548 }
1549
1550 void ScInputHandler::UseFormulaData()
1551 {
1552 EditView* pActiveView = pTopView ? pTopView : pTableView;
1553
1554 /* TODO: MLFORMULA: this should work also with multi-line formulas. */
1555 if ( !(pActiveView && pFormulaData && mpEditEngine->GetParagraphCount() == 1) )
1556 return;
1557
1558 OUString aParagraph = mpEditEngine->GetText( 0 );
1559 ESelection aSel = pActiveView->GetSelection();
1560 aSel.Adjust();
1561
1562 // Due to differences between table and input cell (e.g clipboard with line breaks),
1563 // the selection may not be in line with the EditEngine anymore.
1564 // Just return without any indication as to why.
1565 if ( aSel.nEndPos > aParagraph.getLength() )
1566 return;
1567
1568 if ( aParagraph.getLength() > aSel.nEndPos &&
1569 ( ScGlobal::getCharClass().isLetterNumeric( aParagraph, aSel.nEndPos ) ||
1570 aParagraph[ aSel.nEndPos ] == '_' ||
1571 aParagraph[ aSel.nEndPos ] == '.' ||
1572 aParagraph[ aSel.nEndPos ] == '$' ) )
1573 return;
1574
1575 // Is the cursor at the end of a word?
1576 if ( aSel.nEndPos <= 0 )
1577 return;
1578
1579 OUString aSelText( aParagraph.copy( 0, aSel.nEndPos ));
1580
1581 OUString aText;
1582 if ( GetFuncName( aSelText, aText ) )
1583 {
1584 // function name is incomplete:
1585 // show matching functions name as tip above cell
1586 ::std::vector<OUString> aNewVec;
1587 miAutoPosFormula = pFormulaData->end();
1588 miAutoPosFormula = findTextAll(*pFormulaData, miAutoPosFormula, aText, aNewVec, false);
1589 if (miAutoPosFormula != pFormulaData->end())
1590 {
1591 // check if partial function name is not between quotes
1592 sal_Unicode cBetweenQuotes = 0;
1593 for ( int n = 0; n < aSelText.getLength(); n++ )
1594 {
1595 if (cBetweenQuotes)
1596 {
1597 if (aSelText[n] == cBetweenQuotes)
1598 cBetweenQuotes = 0;
1599 }
1600 else if ( aSelText[ n ] == '"' )
1601 cBetweenQuotes = '"';
1602 else if ( aSelText[ n ] == '\'' )
1603 cBetweenQuotes = '\'';
1604 }
1605 if ( cBetweenQuotes )
1606 return; // we're between quotes
1607
1608 ShowFuncList(aNewVec);
1609 aAutoSearch = aText;
1610 }
1611 return;
1612 }
1613
1614 // function name is complete:
1615 // show tip below the cell with function name and arguments of function
1616 ShowArgumentsTip( aSelText );
1617 }
1618
1619 void ScInputHandler::NextFormulaEntry( bool bBack )
1620 {
1621 EditView* pActiveView = pTopView ? pTopView : pTableView;
1622 if ( pActiveView && pFormulaData )
1623 {
1624 ::std::vector<OUString> aNewVec;
1625 ScTypedCaseStrSet::const_iterator itNew = findTextAll(*pFormulaData, miAutoPosFormula, aAutoSearch, aNewVec, bBack);
1626 if (itNew != pFormulaData->end())
1627 {
1628 miAutoPosFormula = itNew;
1629 ShowFuncList( aNewVec );
1630 }
1631 }
1632
1633 // For Tab we always call HideCursor first
1634 if (pActiveView)
1635 pActiveView->ShowCursor();
1636 }
1637
1638 namespace {
1639
1640 void completeFunction( EditView* pView, const OUString& rInsert, bool& rParInserted )
1641 {
1642 if (!pView)
1643 return;
1644
1645 ESelection aSel = pView->GetSelection();
1646
1647 bool bNoInitialLetter = false;
1648 OUString aOld = pView->GetEditEngine()->GetText(0);
1649 // in case we want just insert a function and not completing
1650 if ( comphelper::LibreOfficeKit::isActive() )
1651 {
1652 ESelection aSelRange = aSel;
1653 --aSelRange.nStartPos;
1654 --aSelRange.nEndPos;
1655 pView->SetSelection(aSelRange);
1656 pView->SelectCurrentWord();
1657
1658 if ( aOld == "=" )
1659 {
1660 bNoInitialLetter = true;
1661 aSelRange.nStartPos = 1;
1662 aSelRange.nEndPos = 1;
1663 pView->SetSelection(aSelRange);
1664 }
1665 else if ( pView->GetSelected().startsWith("()") )
1666 {
1667 bNoInitialLetter = true;
1668 ++aSelRange.nStartPos;
1669 ++aSelRange.nEndPos;
1670 pView->SetSelection(aSelRange);
1671 }
1672 }
1673
1674 if(!bNoInitialLetter)
1675 {
1676 const sal_Int32 nMinLen = std::max(aSel.nEndPos - aSel.nStartPos, sal_Int32(1));
1677 // Since transliteration service is used to test for match, the replaced string could be
1678 // longer than rInsert, so in order to find longest match before the cursor, test whole
1679 // string from start to current cursor position (don't limit to length of rInsert)
1680 // Disclaimer: I really don't know if a match longer than rInsert is actually possible,
1681 // so the above is based on assumptions how "transliteration" might possibly work. If
1682 // it's in fact impossible, an optimization would be useful to limit aSel.nStartPos to
1683 // std::max(sal_Int32(0), aSel.nEndPos - rInsert.getLength()).
1684 aSel.nStartPos = 0;
1685 pView->SetSelection(aSel);
1686 const OUString aAll = pView->GetSelected();
1687 OUString aMatch;
1688 for (sal_Int32 n = aAll.getLength(); n >= nMinLen && aMatch.isEmpty(); --n)
1689 {
1690 const OUString aTest = aAll.copy(aAll.getLength() - n); // n trailing chars
1691 if (ScGlobal::GetTransliteration().isMatch(aTest, rInsert))
1692 aMatch = aTest; // Found => break the loop
1693 }
1694
1695 aSel.nStartPos = aSel.nEndPos - aMatch.getLength();
1696 pView->SetSelection(aSel);
1697 }
1698
1699 OUString aInsStr = rInsert;
1700 sal_Int32 nInsLen = aInsStr.getLength();
1701 bool bDoParen = ( nInsLen > 1 && aInsStr[nInsLen-2] == '('
1702 && aInsStr[nInsLen-1] == ')' );
1703 if ( bDoParen )
1704 {
1705 // Do not insert parentheses after function names if there already are some
1706 // (e.g. if the function name was edited).
1707 ESelection aWordSel = pView->GetSelection();
1708
1709 // aWordSel.EndPos points one behind string if word at end
1710 if (aWordSel.nEndPos < aOld.getLength())
1711 {
1712 sal_Unicode cNext = aOld[aWordSel.nEndPos];
1713 if ( cNext == '(' )
1714 {
1715 bDoParen = false;
1716 aInsStr = aInsStr.copy( 0, nInsLen - 2 ); // Skip parentheses
1717 }
1718 }
1719 }
1720
1721 pView->InsertText( aInsStr );
1722
1723 if ( bDoParen ) // Put cursor between parentheses
1724 {
1725 aSel = pView->GetSelection();
1726 --aSel.nStartPos;
1727 --aSel.nEndPos;
1728 pView->SetSelection(aSel);
1729
1730 rParInserted = true;
1731 }
1732 }
1733
1734 }
1735
1736 void ScInputHandler::PasteFunctionData()
1737 {
1738 if (pFormulaData && miAutoPosFormula != pFormulaData->end())
1739 {
1740 const ScTypedStrData& rData = *miAutoPosFormula;
1741 OUString aInsert = rData.GetString();
1742 if (aInsert[aInsert.getLength()-1] == cParenthesesReplacement)
1743 aInsert = OUString::Concat(aInsert.subView( 0, aInsert.getLength()-1)) + "()";
1744 bool bParInserted = false;
1745
1746 DataChanging(); // Cannot be new
1747 completeFunction( pTopView, aInsert, bParInserted );
1748 completeFunction( pTableView, aInsert, bParInserted );
1749 DataChanged();
1750 ShowTipCursor();
1751
1752 if (bParInserted)
1753 AutoParAdded();
1754 }
1755
1756 HideTip();
1757
1758 EditView* pActiveView = pTopView ? pTopView : pTableView;
1759 if (comphelper::LibreOfficeKit::isActive() && pTopView && pInputWin)
1760 pInputWin->TextGrabFocus();
1761 if (pActiveView)
1762 pActiveView->ShowCursor();
1763 }
1764
1765 void ScInputHandler::LOKPasteFunctionData(const OUString& rFunctionName)
1766 {
1767 // in case we have no top view try to create it
1768 if (!pTopView && pInputWin)
1769 {
1770 ScInputMode eCurMode = eMode;
1771 SetMode(SC_INPUT_TOP);
1772 if (!pTopView)
1773 SetMode(eCurMode);
1774 }
1775
1776 EditView* pEditView = pTopView ? pTopView : pTableView;
1777
1778 if (!pActiveViewSh || !pEditView)
1779 return;
1780
1781 bool bEdit = false;
1782 OUString aFormula;
1783 const EditEngine* pEditEngine = pEditView->GetEditEngine();
1784 if (pEditEngine)
1785 {
1786 aFormula = pEditEngine->GetText(0);
1787 /* TODO: LOK: are you sure you want '+' and '-' let start formulas with
1788 * function names? That was meant for "data typist" numeric keyboard
1789 * input. */
1790 bEdit = aFormula.getLength() > 1 && (aFormula[0] == '=' || aFormula[0] == '+' || aFormula[0] == '-');
1791 }
1792
1793 if ( !bEdit )
1794 {
1795 OUString aNewFormula('=');
1796 if ( aFormula.startsWith("=") )
1797 aNewFormula = aFormula;
1798
1799 InputReplaceSelection( aNewFormula );
1800 }
1801
1802 if (pFormulaData)
1803 {
1804 OUString aNew;
1805 ScTypedCaseStrSet::const_iterator aPos = findText(*pFormulaData, pFormulaData->begin(), rFunctionName, aNew, /* backward = */false);
1806
1807 if (aPos != pFormulaData->end())
1808 {
1809 miAutoPosFormula = aPos;
1810 PasteFunctionData();
1811 }
1812 }
1813 }
1814
1815 void ScTabViewShell::LOKSendFormulabarUpdate(EditView* pActiveView,
1816 const OUString& rText,
1817 const ESelection& rSelection)
1818 {
1819 OUString aSelection;
1820 if (pActiveView)
1821 {
1822 aSelection = OUString::number(pActiveView->GetPosWithField(0, rSelection.nStartPos)) + ";" +
1823 OUString::number(pActiveView->GetPosWithField(0, rSelection.nEndPos)) + ";" +
1824 OUString::number(rSelection.nStartPara) + ";" + OUString::number(rSelection.nEndPara);
1825 }
1826 else
1827 {
1828 aSelection = OUString::number(rSelection.nStartPos) + ";" + OUString::number(rSelection.nEndPos) + ";" +
1829 OUString::number(rSelection.nStartPara) + ";" + OUString::number(rSelection.nEndPara);
1830 }
1831
1832 sal_uInt64 nCurrentShellId = reinterpret_cast<sal_uInt64>(this);
1833
1834 // We can get three updates per keystroke, StartExtTextInput, ExtTextInput and PostExtTextInput
1835 // Skip duplicate updates. Be conservative and don't skip duplicates that are 5+ seconds
1836 // apart.
1837 std::chrono::steady_clock::time_point now = std::chrono::steady_clock::now();
1838 if (maSendFormulabarUpdate.m_nShellId == nCurrentShellId &&
1839 maSendFormulabarUpdate.m_aText == rText &&
1840 maSendFormulabarUpdate.m_aSelection == aSelection &&
1841 std::chrono::duration_cast<std::chrono::seconds>(
1842 now - maSendFormulabarUpdate.m_nTimeStamp) < std::chrono::seconds(5))
1843 {
1844 return;
1845 }
1846
1847 maSendFormulabarUpdate.m_nShellId = nCurrentShellId;
1848 maSendFormulabarUpdate.m_aText = rText;
1849 maSendFormulabarUpdate.m_aSelection = aSelection;
1850 maSendFormulabarUpdate.m_nTimeStamp = now;
1851 maSendFormulabarUpdate.Send();
1852 }
1853
1854 void ScTabViewShell::SendFormulabarUpdate::Send()
1855 {
1856 std::unique_ptr<jsdialog::ActionDataMap> pData = std::make_unique<jsdialog::ActionDataMap>();
1857 (*pData)["action_type"] = "setText";
1858 (*pData)["text"] = m_aText;
1859 (*pData)["selection"] = m_aSelection;
1860 std::string sWindowId = std::to_string(m_nShellId) + "formulabar";
1861 jsdialog::SendAction(sWindowId, "sc_input_window", std::move(pData));
1862 }
1863
1864 // Calculate selection and display as tip help
1865 static OUString lcl_Calculate( const OUString& rFormula, ScDocument& rDoc, const ScAddress &rPos )
1866 {
1867 //TODO: Merge with ScFormulaDlg::CalcValue and move into Document!
1868 // Quotation marks for Strings are only inserted here.
1869
1870 if(rFormula.isEmpty())
1871 return OUString();
1872
1873 std::optional<ScSimpleFormulaCalculator> pCalc( std::in_place, rDoc, rPos, rFormula, false );
1874
1875 // FIXME: HACK! In order to not get a #REF! for ColRowNames, if a name is actually inserted as a Range
1876 // into the whole Formula, but is interpreted as a single cell reference when displaying it on its own
1877 bool bColRowName = pCalc->HasColRowName();
1878 if ( bColRowName )
1879 {
1880 // ColRowName in RPN code?
1881 if ( pCalc->GetCode()->GetCodeLen() <= 1 )
1882 { // ==1: Single one is as a Parameter always a Range
1883 // ==0: It might be one, if ...
1884 OUString aBraced = "(" + rFormula + ")";
1885 pCalc.emplace( rDoc, rPos, aBraced, false );
1886 }
1887 else
1888 bColRowName = false;
1889 }
1890
1891 FormulaError nErrCode = pCalc->GetErrCode();
1892 if ( nErrCode != FormulaError::NONE )
1893 return ScGlobal::GetErrorString(nErrCode);
1894
1895 SvNumberFormatter& aFormatter = *rDoc.GetFormatTable();
1896 OUString aValue;
1897 if ( pCalc->IsValue() )
1898 {
1899 double n = pCalc->GetValue();
1900 sal_uInt32 nFormat = aFormatter.GetStandardFormat( n, 0,
1901 pCalc->GetFormatType(), ScGlobal::eLnge );
1902 aFormatter.GetInputLineString( n, nFormat, aValue );
1903 //! display OutputString but insert InputLineString
1904 }
1905 else
1906 {
1907 OUString aStr = pCalc->GetString().getString();
1908 sal_uInt32 nFormat = aFormatter.GetStandardFormat(
1909 pCalc->GetFormatType(), ScGlobal::eLnge);
1910 {
1911 const Color* pColor;
1912 aFormatter.GetOutputString( aStr, nFormat,
1913 aValue, &pColor );
1914 }
1915
1916 aValue = "\"" + aValue + "\"";
1917 //! Escape quotation marks in String??
1918 }
1919
1920 ScRange aTestRange;
1921 if ( bColRowName || (aTestRange.Parse(rFormula, rDoc) & ScRefFlags::VALID) )
1922 aValue += " ...";
1923
1924 return aValue;
1925 }
1926
1927 void ScInputHandler::FormulaPreview()
1928 {
1929 OUString aValue;
1930 EditView* pActiveView = pTopView ? pTopView : pTableView;
1931 if ( pActiveView && pActiveViewSh )
1932 {
1933 OUString aPart = pActiveView->GetSelected();
1934 if (aPart.isEmpty())
1935 aPart = mpEditEngine->GetText(0);
1936 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
1937 aValue = lcl_Calculate( aPart, rDoc, aCursorPos );
1938 }
1939
1940 if (!aValue.isEmpty())
1941 {
1942 ShowTip( aValue ); // Display as QuickHelp
1943 aManualTip = aValue; // Set after ShowTip
1944 if (pFormulaData)
1945 miAutoPosFormula = pFormulaData->end();
1946 if (pColumnData)
1947 miAutoPosColumn = pColumnData->end();
1948 }
1949 }
1950
1951 void ScInputHandler::PasteManualTip()
1952 {
1953 // Three dots at the end -> Range reference -> do not insert
1954 // FIXME: Once we have matrix constants, we can change this
1955 sal_Int32 nTipLen = aManualTip.getLength();
1956 sal_uInt32 const nTipLen2(sal::static_int_cast<sal_uInt32>(nTipLen));
1957 if ( nTipLen && ( nTipLen < 3 || aManualTip.subView( nTipLen2-3 ) != u"..." ) )
1958 {
1959 DataChanging(); // Cannot be new
1960
1961 OUString aInsert = aManualTip;
1962 EditView* pActiveView = pTopView ? pTopView : pTableView;
1963 if (!pActiveView->HasSelection())
1964 {
1965 // Nothing selected -> select everything
1966 sal_Int32 nOldLen = mpEditEngine->GetTextLen(0);
1967 ESelection aAllSel( 0, 0, 0, nOldLen );
1968 if ( pTopView )
1969 pTopView->SetSelection( aAllSel );
1970 if ( pTableView )
1971 pTableView->SetSelection( aAllSel );
1972 }
1973
1974 ESelection aSel = pActiveView->GetSelection();
1975 aSel.Adjust();
1976 OSL_ENSURE( !aSel.nStartPara && !aSel.nEndPara, "Too many paragraphs in Formula" );
1977 if ( !aSel.nStartPos ) // Selection from the start?
1978 {
1979 if ( aSel.nEndPos == mpEditEngine->GetTextLen(0) )
1980 {
1981 // Everything selected -> skip quotation marks
1982 if ( aInsert[0] == '"' )
1983 aInsert = aInsert.copy(1);
1984 sal_Int32 nInsLen = aInsert.getLength();
1985 if ( aInsert.endsWith("\"") )
1986 aInsert = aInsert.copy( 0, nInsLen-1 );
1987 }
1988 else if ( aSel.nEndPos )
1989 {
1990 // Not everything selected -> do not overwrite equality sign
1991 //FIXME: Even double equality signs??
1992 aSel.nStartPos = 1;
1993 if ( pTopView )
1994 pTopView->SetSelection( aSel );
1995 if ( pTableView )
1996 pTableView->SetSelection( aSel );
1997 }
1998 }
1999 if ( pTopView )
2000 pTopView->InsertText( aInsert, true );
2001 if ( pTableView )
2002 pTableView->InsertText( aInsert, true );
2003
2004 DataChanged();
2005 }
2006
2007 HideTip();
2008 }
2009
2010 void ScInputHandler::ResetAutoPar()
2011 {
2012 nAutoPar = 0;
2013 }
2014
2015 void ScInputHandler::AutoParAdded()
2016 {
2017 ++nAutoPar; // Closing parenthesis can be overwritten
2018 }
2019
2020 bool ScInputHandler::CursorAtClosingPar()
2021 {
2022 // Test if the cursor is before a closing parenthesis
2023 // Selection from SetReference has been removed before
2024 EditView* pActiveView = pTopView ? pTopView : pTableView;
2025 if ( pActiveView && !pActiveView->HasSelection() && bFormulaMode )
2026 {
2027 ESelection aSel = pActiveView->GetSelection();
2028 sal_Int32 nPos = aSel.nStartPos;
2029 OUString aFormula = mpEditEngine->GetText(0);
2030 if ( nPos < aFormula.getLength() && aFormula[nPos] == ')' )
2031 return true;
2032 }
2033 return false;
2034 }
2035
2036 void ScInputHandler::SkipClosingPar()
2037 {
2038 // this is called when a ')' is typed and the cursor is before a ')'
2039 // that can be overwritten -> just set the cursor behind the ')'
2040
2041 EditView* pActiveView = pTopView ? pTopView : pTableView;
2042 if (pActiveView)
2043 {
2044 ESelection aSel = pActiveView->GetSelection();
2045 ++aSel.nStartPos;
2046 ++aSel.nEndPos;
2047
2048 // this is in a formula (only one paragraph), so the selection
2049 // can be used directly for the TopView
2050
2051 if ( pTopView )
2052 pTopView->SetSelection( aSel );
2053 if ( pTableView )
2054 pTableView->SetSelection( aSel );
2055 }
2056
2057 OSL_ENSURE(nAutoPar, "SkipClosingPar: count is wrong");
2058 --nAutoPar;
2059 }
2060
2061 // Auto input
2062
2063 void ScInputHandler::GetColData()
2064 {
2065 if ( !pActiveViewSh )
2066 return;
2067
2068 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
2069
2070 if ( pColumnData )
2071 pColumnData->clear();
2072 else
2073 pColumnData.reset( new ScTypedCaseStrSet );
2074
2075 std::vector<ScTypedStrData> aEntries;
2076 rDoc.GetDataEntries(
2077 aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab(), aEntries);
2078 if (!aEntries.empty())
2079 pColumnData->insert(aEntries.begin(), aEntries.end());
2080
2081 miAutoPosColumn = pColumnData->end();
2082 }
2083
2084 void ScInputHandler::UseColData() // When typing
2085 {
2086 EditView* pActiveView = pTopView ? pTopView : pTableView;
2087 if ( !(pActiveView && pColumnData) )
2088 return;
2089
2090 // Only change when cursor is at the end
2091 ESelection aSel = pActiveView->GetSelection();
2092 aSel.Adjust();
2093
2094 sal_Int32 nParCnt = mpEditEngine->GetParagraphCount();
2095 if ( aSel.nEndPara+1 != nParCnt )
2096 return;
2097
2098 sal_Int32 nParLen = mpEditEngine->GetTextLen( aSel.nEndPara );
2099 if ( aSel.nEndPos != nParLen )
2100 return;
2101
2102 OUString aText = GetEditText(mpEditEngine.get());
2103 if (aText.isEmpty())
2104 return;
2105
2106 std::vector< OUString > aResultVec;
2107 OUString aNew;
2108 sal_Int32 nLongestPrefixLen = 0;
2109 miAutoPosColumn = pColumnData->end();
2110 mbPartialPrefix = false;
2111 miAutoPosColumn = findTextAll(*pColumnData, miAutoPosColumn, aText, aResultVec, false, &nLongestPrefixLen);
2112
2113 if (nLongestPrefixLen <= 0 || aResultVec.empty())
2114 return;
2115
2116 if (aResultVec.size() > 1)
2117 {
2118 mbPartialPrefix = true;
2119 bUseTab = true; // Allow Ctrl (+ Shift + ) + TAB cycling.
2120 miAutoPosColumn = pColumnData->end();
2121
2122 // Display the rest of longest common prefix as suggestion.
2123 aNew = aResultVec[0].copy(0, nLongestPrefixLen);
2124 }
2125 else
2126 {
2127 aNew = aResultVec[0];
2128 }
2129
2130 // Strings can contain line endings (e.g. due to dBase import),
2131 // which would result in multiple paragraphs here, which is not desirable.
2132 //! Then GetExactMatch doesn't work either
2133 lcl_RemoveLineEnd( aNew );
2134
2135 // Keep paragraph, just append the rest
2136 //! Exact replacement in EnterHandler !!!
2137 // One Space between paragraphs:
2138 sal_Int32 nEdLen = mpEditEngine->GetTextLen() + nParCnt - 1;
2139 OUString aIns = aNew.copy(nEdLen);
2140
2141 // Selection must be "backwards", so the cursor stays behind the last
2142 // typed character
2143 ESelection aSelection( aSel.nEndPara, aSel.nEndPos + aIns.getLength(),
2144 aSel.nEndPara, aSel.nEndPos );
2145
2146 // When editing in input line, apply to both edit views
2147 if ( pTableView )
2148 {
2149 pTableView->InsertText( aIns );
2150 pTableView->SetSelection( aSelection );
2151 }
2152 if ( pTopView )
2153 {
2154 pTopView->InsertText( aIns );
2155 pTopView->SetSelection( aSelection );
2156 }
2157
2158 aAutoSearch = aText; // To keep searching - nAutoPos is set
2159 }
2160
2161 void ScInputHandler::NextAutoEntry( bool bBack )
2162 {
2163 EditView* pActiveView = pTopView ? pTopView : pTableView;
2164 if ( pActiveView && pColumnData )
2165 {
2166 if (!aAutoSearch.isEmpty())
2167 {
2168 // Is the selection still valid (could be changed via the mouse)?
2169 ESelection aSel = pActiveView->GetSelection();
2170 aSel.Adjust();
2171 sal_Int32 nParCnt = mpEditEngine->GetParagraphCount();
2172 if ( aSel.nEndPara+1 == nParCnt && aSel.nStartPara == aSel.nEndPara )
2173 {
2174 OUString aText = GetEditText(mpEditEngine.get());
2175 sal_Int32 nSelLen = aSel.nEndPos - aSel.nStartPos;
2176 sal_Int32 nParLen = mpEditEngine->GetTextLen( aSel.nEndPara );
2177 if ( aSel.nEndPos == nParLen && aText.getLength() == aAutoSearch.getLength() + nSelLen )
2178 {
2179 OUString aNew;
2180 ScTypedCaseStrSet::const_iterator itNew =
2181 findText(*pColumnData, miAutoPosColumn, aAutoSearch, aNew, bBack);
2182
2183 if (itNew != pColumnData->end())
2184 {
2185 // match found!
2186 miAutoPosColumn = itNew;
2187 bInOwnChange = true; // disable ModifyHdl (reset below)
2188 mbPartialPrefix = false;
2189
2190 lcl_RemoveLineEnd( aNew );
2191 OUString aIns = aNew.copy(aAutoSearch.getLength());
2192
2193 // when editing in input line, apply to both edit views
2194 if ( pTableView )
2195 {
2196 pTableView->DeleteSelected();
2197 pTableView->InsertText( aIns );
2198 pTableView->SetSelection( ESelection(
2199 aSel.nEndPara, aSel.nStartPos + aIns.getLength(),
2200 aSel.nEndPara, aSel.nStartPos ) );
2201 }
2202 if ( pTopView )
2203 {
2204 pTopView->DeleteSelected();
2205 pTopView->InsertText( aIns );
2206 pTopView->SetSelection( ESelection(
2207 aSel.nEndPara, aSel.nStartPos + aIns.getLength(),
2208 aSel.nEndPara, aSel.nStartPos ) );
2209 }
2210
2211 bInOwnChange = false;
2212 }
2213 }
2214 }
2215 }
2216 }
2217
2218 // For Tab, HideCursor was always called first
2219 if (pActiveView)
2220 pActiveView->ShowCursor();
2221 }
2222
2223 // Highlight parentheses
2224 void ScInputHandler::UpdateParenthesis()
2225 {
2226 // Find parentheses
2227 //TODO: Can we disable parentheses highlighting per parentheses?
2228 bool bFound = false;
2229 if ( bFormulaMode && eMode != SC_INPUT_TOP )
2230 {
2231 if ( pTableView && !pTableView->HasSelection() ) // Selection is always at the bottom
2232 {
2233 ESelection aSel = pTableView->GetSelection();
2234 if (aSel.nStartPos)
2235 {
2236 // Examine character left to the cursor
2237 sal_Int32 nPos = aSel.nStartPos - 1;
2238 OUString aFormula = mpEditEngine->GetText(aSel.nStartPara);
2239 sal_Unicode c = aFormula[nPos];
2240 if ( c == '(' || c == ')' )
2241 {
2242 // Note this matches only within one paragraph.
2243 sal_Int32 nOther = lcl_MatchParenthesis( aFormula, nPos );
2244 if ( nOther != -1 )
2245 {
2246 SfxItemSet aSet( mpEditEngine->GetEmptyItemSet() );
2247 aSet.Put( SvxWeightItem( WEIGHT_BOLD, EE_CHAR_WEIGHT ) );
2248
2249 //! Distinguish if cell is already highlighted!!!!
2250 if (bParenthesisShown)
2251 {
2252 // Remove old highlighting
2253 sal_Int32 nCount = mpEditEngine->GetParagraphCount();
2254 for (sal_Int32 i=0; i<nCount; i++)
2255 mpEditEngine->RemoveCharAttribs( i, EE_CHAR_WEIGHT );
2256 }
2257
2258 ESelection aSelThis( aSel.nStartPara, nPos, aSel.nStartPara, nPos+1);
2259 mpEditEngine->QuickSetAttribs( aSet, aSelThis );
2260 ESelection aSelOther( aSel.nStartPara, nOther, aSel.nStartPara, nOther+1);
2261 mpEditEngine->QuickSetAttribs( aSet, aSelOther );
2262
2263 // Dummy InsertText for Update and Paint (selection is empty)
2264 pTableView->InsertText( OUString() );
2265
2266 bFound = true;
2267 }
2268 }
2269 }
2270
2271 // mark parenthesis right of cursor if it will be overwritten (nAutoPar)
2272 // with different color (COL_LIGHTBLUE) ??
2273 }
2274 }
2275
2276 // Remove old highlighting, if no new one is set
2277 if ( bParenthesisShown && !bFound && pTableView )
2278 {
2279 sal_Int32 nCount = mpEditEngine->GetParagraphCount();
2280 for (sal_Int32 i=0; i<nCount; i++)
2281 pTableView->RemoveCharAttribs( i, EE_CHAR_WEIGHT );
2282 }
2283
2284 bParenthesisShown = bFound;
2285 }
2286
2287 void ScInputHandler::ViewShellGone(const ScTabViewShell* pViewSh) // Executed synchronously!
2288 {
2289 if ( pViewSh == pActiveViewSh )
2290 {
2291 pLastState.reset();
2292 pLastPattern = nullptr;
2293 }
2294
2295 if ( pViewSh == pRefViewSh )
2296 {
2297 //! The input from the EnterHandler does not arrive anymore
2298 // We end the EditMode anyways
2299 EnterHandler();
2300 bFormulaMode = false;
2301 pRefViewSh = nullptr;
2302 SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScRefModeChanged ) );
2303 SC_MOD()->SetRefInputHdl(nullptr);
2304 if (pInputWin)
2305 pInputWin->SetFormulaMode(false);
2306 UpdateAutoCorrFlag();
2307 }
2308
2309 pActiveViewSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current() );
2310
2311 if ( pActiveViewSh && pActiveViewSh == pViewSh )
2312 {
2313 OSL_FAIL("pActiveViewSh is gone");
2314 pActiveViewSh = nullptr;
2315 }
2316
2317 if ( SC_MOD()->GetInputOptions().GetTextWysiwyg() )
2318 UpdateRefDevice(); // Don't keep old document's printer as RefDevice
2319 }
2320
2321 void ScInputHandler::UpdateActiveView()
2322 {
2323 ImplCreateEditEngine();
2324
2325 // #i20588# Don't rely on focus to find the active edit view. Instead, the
2326 // active pane at the start of editing is now stored (GetEditActivePart).
2327 // GetActiveWin (the currently active pane) fails for ref input across the
2328 // panes of a split view.
2329
2330 vcl::Window* pShellWin = pActiveViewSh ?
2331 pActiveViewSh->GetWindowByPos( pActiveViewSh->GetViewData().GetEditActivePart() ) :
2332 nullptr;
2333
2334 sal_uInt16 nCount = mpEditEngine->GetViewCount();
2335 if (nCount > 0)
2336 {
2337 pTableView = mpEditEngine->GetView();
2338 for (sal_uInt16 i=1; i<nCount; i++)
2339 {
2340 EditView* pThis = mpEditEngine->GetView(i);
2341 vcl::Window* pWin = pThis->GetWindow();
2342 if ( pWin==pShellWin )
2343 pTableView = pThis;
2344 }
2345 }
2346 else
2347 pTableView = nullptr;
2348
2349 // setup the pTableView editeng for tiled rendering to get cursor and selections
2350 if (pTableView && pActiveViewSh)
2351 {
2352 if (comphelper::LibreOfficeKit::isActive())
2353 {
2354 pTableView->RegisterViewShell(pActiveViewSh);
2355 }
2356 }
2357
2358 if (pInputWin && (eMode == SC_INPUT_TOP || eMode == SC_INPUT_TABLE))
2359 {
2360 // tdf#71409: Always create the edit engine instance for the input
2361 // window, in order to properly manage accessibility events.
2362 pTopView = pInputWin->GetEditView();
2363 if (eMode != SC_INPUT_TOP)
2364 pTopView = nullptr;
2365 }
2366 else
2367 pTopView = nullptr;
2368 }
2369
2370 void ScInputHandler::SetInputWindow( ScInputWindow* pNew )
2371 {
2372 pInputWin = pNew;
2373 }
2374
2375 void ScInputHandler::StopInputWinEngine( bool bAll )
2376 {
2377 if (pInputWin && !pInputWin->isDisposed())
2378 pInputWin->StopEditEngine( bAll );
2379
2380 pTopView = nullptr; // invalid now
2381 }
2382
2383 EditView* ScInputHandler::GetActiveView()
2384 {
2385 UpdateActiveView();
2386 return pTopView ? pTopView : pTableView;
2387 }
2388
2389 void ScInputHandler::ForgetLastPattern()
2390 {
2391 pLastPattern = nullptr;
2392 if ( !pLastState && pActiveViewSh )
2393 pActiveViewSh->UpdateInputHandler( true ); // Get status again
2394 else
2395 NotifyChange( pLastState.get(), true );
2396 }
2397
2398 void ScInputHandler::UpdateAdjust( sal_Unicode cTyped )
2399 {
2400 SvxAdjust eSvxAdjust;
2401 switch (eAttrAdjust)
2402 {
2403 case SvxCellHorJustify::Standard:
2404 {
2405 bool bNumber = false;
2406 if (cTyped) // Restarted
2407 bNumber = (cTyped>='0' && cTyped<='9'); // Only ciphers are numbers
2408 else if ( pActiveViewSh )
2409 {
2410 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
2411 bNumber = ( rDoc.GetCellType( aCursorPos ) == CELLTYPE_VALUE );
2412 }
2413 eSvxAdjust = bNumber ? SvxAdjust::Right : SvxAdjust::Left;
2414 }
2415 break;
2416 case SvxCellHorJustify::Block:
2417 eSvxAdjust = SvxAdjust::Block;
2418 break;
2419 case SvxCellHorJustify::Center:
2420 eSvxAdjust = SvxAdjust::Center;
2421 break;
2422 case SvxCellHorJustify::Right:
2423 eSvxAdjust = SvxAdjust::Right;
2424 break;
2425 default: // SvxCellHorJustify::Left
2426 eSvxAdjust = SvxAdjust::Left;
2427 break;
2428 }
2429
2430 bool bAsianVertical = pLastPattern &&
2431 pLastPattern->GetItem( ATTR_STACKED ).GetValue() &&
2432 pLastPattern->GetItem( ATTR_VERTICAL_ASIAN ).GetValue();
2433 if ( bAsianVertical )
2434 {
2435 // Always edit at top of cell -> LEFT when editing vertically
2436 eSvxAdjust = SvxAdjust::Left;
2437 }
2438
2439 pEditDefaults->Put( SvxAdjustItem( eSvxAdjust, EE_PARA_JUST ) );
2440 mpEditEngine->SetDefaults( *pEditDefaults );
2441
2442 if ( pActiveViewSh )
2443 {
2444 pActiveViewSh->GetViewData().SetEditAdjust( eSvxAdjust );
2445 }
2446 mpEditEngine->SetVertical( bAsianVertical );
2447 }
2448
2449 void ScInputHandler::RemoveAdjust()
2450 {
2451 // Delete hard alignment attributes
2452 bool bUndo = mpEditEngine->IsUndoEnabled();
2453 if ( bUndo )
2454 mpEditEngine->EnableUndo( false );
2455
2456 // Non-default paragraph attributes (e.g. from clipboard)
2457 // must be turned into character attributes
2458 mpEditEngine->RemoveParaAttribs();
2459
2460 if ( bUndo )
2461 mpEditEngine->EnableUndo( true );
2462
2463 }
2464
2465 void ScInputHandler::RemoveRangeFinder()
2466 {
2467 // Delete pRangeFindList and colors
2468 mpEditEngine->SetUpdateLayout(false);
2469 sal_Int32 nCount = mpEditEngine->GetParagraphCount(); // Could just have been inserted
2470 for (sal_Int32 i=0; i<nCount; i++)
2471 mpEditEngine->RemoveCharAttribs( i, EE_CHAR_COLOR );
2472 mpEditEngine->SetUpdateLayout(true);
2473
2474 EditView* pActiveView = pTopView ? pTopView : pTableView;
2475 pActiveView->ShowCursor( false );
2476
2477 DeleteRangeFinder(); // Deletes the list and the labels on the table
2478 }
2479
2480 bool ScInputHandler::StartTable( sal_Unicode cTyped, bool bFromCommand, bool bInputActivated,
2481 ScEditEngineDefaulter* pTopEngine )
2482 {
2483 bool bNewTable = false;
2484
2485 if (bModified)
2486 return false;
2487
2488 if (pActiveViewSh)
2489 {
2490 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocShell()->GetDocument();
2491
2492 if (!rDoc.ValidCol(aCursorPos.Col()))
2493 return false;
2494
2495 ImplCreateEditEngine();
2496 UpdateActiveView();
2497 SyncViews();
2498
2499
2500 const ScMarkData& rMark = pActiveViewSh->GetViewData().GetMarkData();
2501 ScEditableTester aTester;
2502 if ( rMark.IsMarked() || rMark.IsMultiMarked() )
2503 aTester.TestSelection( rDoc, rMark );
2504 else
2505 aTester.TestSelectedBlock(
2506 rDoc, aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Col(), aCursorPos.Row(), rMark );
2507
2508 bool bStartInputMode = true;
2509
2510 if (!aTester.IsEditable())
2511 {
2512 bProtected = true;
2513 // We allow read-only input mode activation regardless
2514 // whether it's part of an array or not or whether explicit cell
2515 // activation is requested (double-click or F2) or a click in input
2516 // line.
2517 bool bShowError = (!bInputActivated || !aTester.GetMessageId() || aTester.GetMessageId() != STR_PROTECTIONERR) &&
2518 !pActiveViewSh->GetViewData().GetDocShell()->IsReadOnly();
2519 if (bShowError)
2520 {
2521 eMode = SC_INPUT_NONE;
2522 StopInputWinEngine( true );
2523 UpdateFormulaMode();
2524 if ( pActiveViewSh && ( !bFromCommand || !bCommandErrorShown ) )
2525 {
2526 // Prevent repeated error messages for the same cell from command events
2527 // (for keyboard events, multiple messages are wanted).
2528 // Set the flag before showing the error message because the command handler
2529 // for the next IME command may be called when showing the dialog.
2530 if ( bFromCommand )
2531 bCommandErrorShown = true;
2532
2533 pActiveViewSh->GetActiveWin()->GrabFocus();
2534 pActiveViewSh->ErrorMessage(aTester.GetMessageId());
2535 }
2536 bStartInputMode = false;
2537 }
2538 }
2539
2540 if (bStartInputMode)
2541 {
2542 // UpdateMode is enabled again in ScViewData::SetEditEngine (and not needed otherwise)
2543 mpEditEngine->SetUpdateLayout( false );
2544
2545 // Take over attributes in EditEngine
2546 const ScPatternAttr* pPattern = rDoc.GetPattern( aCursorPos.Col(),
2547 aCursorPos.Row(),
2548 aCursorPos.Tab() );
2549 if (pPattern != pLastPattern)
2550 {
2551 // Percent format?
2552 const SfxItemSet& rAttrSet = pPattern->GetItemSet();
2553
2554 if ( const SfxUInt32Item* pItem = rAttrSet.GetItemIfSet( ATTR_VALUE_FORMAT ) )
2555 {
2556 sal_uInt32 nFormat = pItem->GetValue();
2557 if (SvNumFormatType::PERCENT == rDoc.GetFormatTable()->GetType( nFormat ))
2558 nCellPercentFormatDecSep = rDoc.GetFormatTable()->GetFormatDecimalSep( nFormat).toChar();
2559 else
2560 nCellPercentFormatDecSep = 0;
2561 }
2562 else
2563 nCellPercentFormatDecSep = 0; // Default: no percent
2564
2565 // Validity specified?
2566 if ( const SfxUInt32Item* pItem = rAttrSet.GetItemIfSet( ATTR_VALIDDATA ) )
2567 nValidation = pItem->GetValue();
2568 else
2569 nValidation = 0;
2570
2571 // EditEngine Defaults
2572 // In no case SetParaAttribs, because the EditEngine might already
2573 // be filled (for Edit cells).
2574 // SetParaAttribs would change the content.
2575
2576 //! The SetDefaults is now (since MUST/src602
2577 //! EditEngine changes) implemented as a SetParaAttribs.
2578 //! Any problems?
2579
2580 pPattern->FillEditItemSet( pEditDefaults.get() );
2581 mpEditEngine->SetDefaults( *pEditDefaults );
2582 pLastPattern = pPattern;
2583 bLastIsSymbol = pPattern->IsSymbolFont();
2584
2585 // Background color must be known for automatic font color.
2586 // For transparent cell background, the document background color must be used.
2587
2588 Color aBackCol = pPattern->GetItem( ATTR_BACKGROUND ).GetColor();
2589 ScModule* pScMod = SC_MOD();
2590 if ( aBackCol.IsTransparent() ||
2591 Application::GetSettings().GetStyleSettings().GetHighContrastMode() )
2592 aBackCol = pScMod->GetColorConfig().GetColorValue(svtools::DOCCOLOR).nColor;
2593 mpEditEngine->SetBackgroundColor( aBackCol );
2594
2595 // Adjustment
2596 eAttrAdjust = pPattern->GetItem(ATTR_HOR_JUSTIFY).GetValue();
2597 if ( eAttrAdjust == SvxCellHorJustify::Repeat &&
2598 pPattern->GetItem(ATTR_LINEBREAK).GetValue() )
2599 {
2600 // #i31843# "repeat" with "line breaks" is treated as default alignment
2601 eAttrAdjust = SvxCellHorJustify::Standard;
2602 }
2603 }
2604
2605 if (pTopEngine)
2606 {
2607 // Necessary to sync SvxAutoCorrect behavior. This has to be
2608 // done before InitRangeFinder() below.
2609 MergeLanguageAttributes( *pTopEngine);
2610 }
2611
2612 // UpdateSpellSettings enables online spelling if needed
2613 // -> also call if attributes are unchanged
2614 UpdateSpellSettings( true ); // uses pLastPattern
2615
2616 // Fill EditEngine
2617 OUString aStr;
2618 if (bTextValid)
2619 {
2620 mpEditEngine->SetTextCurrentDefaults(aCurrentText);
2621 aStr = aCurrentText;
2622 bTextValid = false;
2623 aCurrentText.clear();
2624 }
2625 else
2626 aStr = GetEditText(mpEditEngine.get());
2627
2628 // cTyped!=0 is overtyping, not editing.
2629 mbEditingExistingContent = !cTyped && !aStr.isEmpty();
2630
2631 if (aStr.startsWith("{=") && aStr.endsWith("}") ) // Matrix formula?
2632 {
2633 aStr = aStr.copy(1, aStr.getLength() -2);
2634 mpEditEngine->SetTextCurrentDefaults(aStr);
2635 if ( pInputWin )
2636 pInputWin->SetTextString(aStr, true);
2637 }
2638
2639 UpdateAdjust( cTyped );
2640
2641 if ( SC_MOD()->GetAppOptions().GetAutoComplete() )
2642 GetColData();
2643
2644 if (!cTyped && !bCreatingFuncView && StartsLikeFormula(aStr))
2645 InitRangeFinder(aStr); // Formula is being edited -> RangeFinder
2646
2647 bNewTable = true; // -> PostEditView Call
2648 }
2649 }
2650
2651 if (!bProtected && pInputWin)
2652 pInputWin->SetOkCancelMode();
2653
2654 return bNewTable;
2655 }
2656
2657 void ScInputHandler::MergeLanguageAttributes( ScEditEngineDefaulter& rDestEngine ) const
2658 {
2659 const SfxItemSet& rSrcSet = mpEditEngine->GetDefaults();
2660 rDestEngine.SetDefaultItem( rSrcSet.Get( EE_CHAR_LANGUAGE ));
2661 rDestEngine.SetDefaultItem( rSrcSet.Get( EE_CHAR_LANGUAGE_CJK ));
2662 rDestEngine.SetDefaultItem( rSrcSet.Get( EE_CHAR_LANGUAGE_CTL ));
2663 }
2664
2665 static void lcl_SetTopSelection( EditView* pEditView, ESelection& rSel )
2666 {
2667 OSL_ENSURE( rSel.nStartPara==0 && rSel.nEndPara==0, "SetTopSelection: Para != 0" );
2668
2669 EditEngine* pEngine = pEditView->GetEditEngine();
2670 sal_Int32 nCount = pEngine->GetParagraphCount();
2671 if (nCount > 1)
2672 {
2673 sal_Int32 nParLen = pEngine->GetTextLen(rSel.nStartPara);
2674 while (rSel.nStartPos > nParLen && rSel.nStartPara+1 < nCount)
2675 {
2676 rSel.nStartPos -= nParLen + 1; // Including space from line break
2677 nParLen = pEngine->GetTextLen(++rSel.nStartPara);
2678 }
2679
2680 nParLen = pEngine->GetTextLen(rSel.nEndPara);
2681 while (rSel.nEndPos > nParLen && rSel.nEndPara+1 < nCount)
2682 {
2683 rSel.nEndPos -= nParLen + 1; // Including space from line break
2684 nParLen = pEngine->GetTextLen(++rSel.nEndPara);
2685 }
2686 }
2687
2688 ESelection aSel = pEditView->GetSelection();
2689
2690 if ( rSel.nStartPara != aSel.nStartPara || rSel.nEndPara != aSel.nEndPara
2691 || rSel.nStartPos != aSel.nStartPos || rSel.nEndPos != aSel.nEndPos )
2692 pEditView->SetSelection( rSel );
2693 }
2694
2695 void ScInputHandler::SyncViews( const EditView* pSourceView )
2696 {
2697 if (pSourceView)
2698 {
2699 bool bSelectionForTopView = false;
2700 if (pTopView && pTopView != pSourceView)
2701 bSelectionForTopView = true;
2702 bool bSelectionForTableView = false;
2703 if (pTableView && pTableView != pSourceView)
2704 bSelectionForTableView = true;
2705 if (bSelectionForTopView || bSelectionForTableView)
2706 {
2707 ESelection aSel(pSourceView->GetSelection());
2708 if (bSelectionForTopView)
2709 pTopView->SetSelection(aSel);
2710 if (bSelectionForTableView)
2711 lcl_SetTopSelection(pTableView, aSel);
2712 }
2713 }
2714 // Only sync selection from topView if we are actually editing there
2715 else if (pTopView && pTableView)
2716 {
2717 ESelection aSel(pTopView->GetSelection());
2718 lcl_SetTopSelection( pTableView, aSel );
2719 }
2720 }
2721
2722 IMPL_LINK_NOARG(ScInputHandler, ModifyHdl, LinkParamNone*, void)
2723 {
2724 if ( !bInOwnChange && ( eMode==SC_INPUT_TYPE || eMode==SC_INPUT_TABLE ) &&
2725 mpEditEngine && mpEditEngine->IsUpdateLayout() && pInputWin )
2726 {
2727 // Update input line from ModifyHdl for changes that are not
2728 // wrapped by DataChanging/DataChanged calls (like Drag&Drop)
2729 OUString aText(ScEditUtil::GetMultilineString(*mpEditEngine));
2730 lcl_RemoveTabs(aText);
2731 pInputWin->SetTextString(aText, true);
2732 }
2733 }
2734
2735 /**
2736 * @return true means new view created
2737 */
2738 bool ScInputHandler::DataChanging( sal_Unicode cTyped, bool bFromCommand )
2739 {
2740 if (pActiveViewSh)
2741 pActiveViewSh->GetViewData().SetPasteMode( ScPasteFlags::NONE );
2742 bInOwnChange = true; // disable ModifyHdl (reset in DataChanged)
2743
2744 if ( eMode == SC_INPUT_NONE )
2745 return StartTable( cTyped, bFromCommand, false, nullptr );
2746 else
2747 return false;
2748 }
2749
2750 void ScInputHandler::DataChanged( bool bFromTopNotify, bool bSetModified )
2751 {
2752 ImplCreateEditEngine();
2753
2754 if (eMode==SC_INPUT_NONE)
2755 eMode = SC_INPUT_TYPE;
2756
2757 if ( eMode == SC_INPUT_TOP && pTopView && !bFromTopNotify )
2758 {
2759 // table EditEngine is formatted below, input line needs formatting after paste
2760 // #i20282# not when called from the input line's modify handler
2761 pTopView->GetEditEngine()->QuickFormatDoc( true );
2762
2763 // #i23720# QuickFormatDoc hides the cursor, but can't show it again because it
2764 // can't safely access the EditEngine's current view, so the cursor has to be
2765 // shown again here.
2766 pTopView->ShowCursor();
2767 }
2768
2769 if (bSetModified)
2770 bModified = true;
2771 bSelIsRef = false;
2772
2773 if ( pRangeFindList && !bInRangeUpdate )
2774 RemoveRangeFinder(); // Delete attributes and labels
2775
2776 UpdateParenthesis(); // Highlight parentheses anew
2777
2778 const bool bUpdateKit = comphelper::LibreOfficeKit::isActive() && pActiveViewSh && pInputWin;
2779
2780 if (eMode==SC_INPUT_TYPE || eMode==SC_INPUT_TABLE)
2781 {
2782 OUString aText;
2783 if (pInputWin)
2784 aText = ScEditUtil::GetMultilineString(*mpEditEngine);
2785 else
2786 aText = GetEditText(mpEditEngine.get());
2787 lcl_RemoveTabs(aText);
2788
2789 if (pInputWin)
2790 {
2791 // If we will end up updating LoKit at the end, we can skip it here
2792 pInputWin->SetTextString(aText, !bUpdateKit);
2793 }
2794
2795 if (comphelper::LibreOfficeKit::isActive())
2796 {
2797 if (pActiveViewSh)
2798 {
2799 // TODO: deprecated?
2800 pActiveViewSh->libreOfficeKitViewCallback(LOK_CALLBACK_CELL_FORMULA, aText.toUtf8().getStr());
2801 }
2802 }
2803 }
2804
2805 // If the cursor is before the end of a paragraph, parts are being pushed to
2806 // the right (independently from the eMode) -> Adapt View!
2807 // If the cursor is at the end, the StatusHandler of the ViewData is sufficient.
2808 //
2809 // First make sure the status handler is called now if the cursor
2810 // is outside the visible area
2811 mpEditEngine->QuickFormatDoc();
2812
2813 EditView* pActiveView = pTopView ? pTopView : pTableView;
2814 ESelection aSel;
2815 if (pActiveView && pActiveViewSh)
2816 {
2817 ScViewData& rViewData = pActiveViewSh->GetViewData();
2818
2819 bool bNeedGrow = ( rViewData.GetEditAdjust() != SvxAdjust::Left ); // Always right-aligned
2820 if (!bNeedGrow)
2821 {
2822 // Cursor before the end?
2823 aSel = pActiveView->GetSelection();
2824 aSel.Adjust();
2825 bNeedGrow = ( aSel.nEndPos != mpEditEngine->GetTextLen(aSel.nEndPara) );
2826 }
2827 if (!bNeedGrow)
2828 {
2829 bNeedGrow = rViewData.GetDocument().IsLayoutRTL( rViewData.GetTabNo() );
2830 }
2831 if (bNeedGrow)
2832 {
2833 // Adjust inplace view
2834 rViewData.EditGrowY();
2835 rViewData.EditGrowX();
2836 }
2837 }
2838
2839 if (bUpdateKit)
2840 {
2841 UpdateActiveView();
2842 if (pActiveView)
2843 aSel = pActiveView->GetSelection();
2844
2845 pActiveViewSh->LOKSendFormulabarUpdate(pActiveView,
2846 ScEditUtil::GetMultilineString(*mpEditEngine),
2847 aSel);
2848 }
2849
2850 UpdateFormulaMode();
2851 bTextValid = false; // Changes only in the EditEngine
2852 bInOwnChange = false;
2853 }
2854
2855 bool ScInputHandler::StartsLikeFormula( std::u16string_view rStr ) const
2856 {
2857 // For new input '+' and '-' may start the dreaded "lazy data typist"
2858 // formula input, editing existing formula content can only start with '='.
2859 return !rStr.empty() && (rStr[0] == '=' || (!mbEditingExistingContent && (rStr[0] == '+' || rStr[0] == '-')));
2860 }
2861
2862 void ScInputHandler::UpdateFormulaMode()
2863 {
2864 SfxApplication* pSfxApp = SfxGetpApp();
2865
2866 bool bIsFormula = !bProtected;
2867 if (bIsFormula)
2868 {
2869 const OUString& rText = mpEditEngine->GetText(0);
2870 bIsFormula = StartsLikeFormula(rText);
2871 }
2872
2873 if ( bIsFormula )
2874 {
2875 if (!bFormulaMode)
2876 {
2877 bFormulaMode = true;
2878 pRefViewSh = pActiveViewSh;
2879 pSfxApp->Broadcast( SfxHint( SfxHintId::ScRefModeChanged ) );
2880 ScModule* pMod = SC_MOD();
2881 pMod->SetRefInputHdl(this);
2882 if (pInputWin)
2883 pInputWin->SetFormulaMode(true);
2884
2885 // in LOK, we always need to perform the GetFormulaData() call so
2886 // that the formula insertion works
2887 if (comphelper::LibreOfficeKit::isActive() || pMod->GetAppOptions().GetAutoComplete())
2888 GetFormulaData();
2889
2890 UpdateParenthesis();
2891 UpdateAutoCorrFlag();
2892 }
2893 }
2894 else // Deactivate
2895 {
2896 if (bFormulaMode)
2897 {
2898 ShowRefFrame();
2899 bFormulaMode = false;
2900 pRefViewSh = nullptr;
2901 pSfxApp->Broadcast( SfxHint( SfxHintId::ScRefModeChanged ) );
2902 SC_MOD()->SetRefInputHdl(nullptr);
2903 if (pInputWin)
2904 pInputWin->SetFormulaMode(false);
2905 UpdateAutoCorrFlag();
2906 }
2907 }
2908 }
2909
2910 void ScInputHandler::ShowRefFrame()
2911 {
2912 // Modifying pActiveViewSh here would interfere with the bInEnterHandler / bRepeat
2913 // checks in NotifyChange, and lead to keeping the wrong value in pActiveViewSh.
2914 // A local variable is used instead.
2915 ScTabViewShell* pVisibleSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current() );
2916 if ( !(pRefViewSh && pRefViewSh != pVisibleSh) )
2917 return;
2918
2919 bool bFound = false;
2920 SfxViewFrame* pRefFrame = pRefViewSh->GetViewFrame();
2921 SfxViewFrame* pOneFrame = SfxViewFrame::GetFirst();
2922 while ( pOneFrame && !bFound )
2923 {
2924 if ( pOneFrame == pRefFrame )
2925 bFound = true;
2926 pOneFrame = SfxViewFrame::GetNext( *pOneFrame );
2927 }
2928
2929 if (bFound)
2930 {
2931 // We count on Activate working synchronously here
2932 // (pActiveViewSh is set while doing so)
2933 pRefViewSh->SetActive(); // Appear and SetViewFrame
2934
2935 // pLastState is set correctly in the NotifyChange from the Activate
2936 }
2937 else
2938 {
2939 OSL_FAIL("ViewFrame for reference input is not here anymore");
2940 }
2941 }
2942
2943 void ScInputHandler::RemoveSelection()
2944 {
2945 EditView* pActiveView = pTopView ? pTopView : pTableView;
2946 if (!pActiveView)
2947 return;
2948
2949 ESelection aSel = pActiveView->GetSelection();
2950 aSel.nStartPara = aSel.nEndPara;
2951 aSel.nStartPos = aSel.nEndPos;
2952 if (pTableView)
2953 pTableView->SetSelection( aSel );
2954 if (pTopView)
2955 pTopView->SetSelection( aSel );
2956 }
2957
2958 void ScInputHandler::InvalidateAttribs()
2959 {
2960 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
2961 if (!pViewFrm)
2962 return;
2963
2964 SfxBindings& rBindings = pViewFrm->GetBindings();
2965
2966 rBindings.Invalidate( SID_ATTR_CHAR_FONT );
2967 rBindings.Invalidate( SID_ATTR_CHAR_FONTHEIGHT );
2968 rBindings.Invalidate( SID_ATTR_CHAR_COLOR );
2969
2970 rBindings.Invalidate( SID_ATTR_CHAR_WEIGHT );
2971 rBindings.Invalidate( SID_ATTR_CHAR_POSTURE );
2972 rBindings.Invalidate( SID_ATTR_CHAR_UNDERLINE );
2973 rBindings.Invalidate( SID_ATTR_CHAR_OVERLINE );
2974 rBindings.Invalidate( SID_ULINE_VAL_NONE );
2975 rBindings.Invalidate( SID_ULINE_VAL_SINGLE );
2976 rBindings.Invalidate( SID_ULINE_VAL_DOUBLE );
2977 rBindings.Invalidate( SID_ULINE_VAL_DOTTED );
2978
2979 rBindings.Invalidate( SID_HYPERLINK_GETLINK );
2980
2981 rBindings.Invalidate( SID_ATTR_CHAR_KERNING );
2982 rBindings.Invalidate( SID_SET_SUPER_SCRIPT );
2983 rBindings.Invalidate( SID_SET_SUB_SCRIPT );
2984 rBindings.Invalidate( SID_ATTR_CHAR_STRIKEOUT );
2985 rBindings.Invalidate( SID_ATTR_CHAR_SHADOWED );
2986
2987 rBindings.Invalidate( SID_SAVEDOC );
2988 rBindings.Invalidate( SID_DOC_MODIFIED );
2989 }
2990
2991 // --------------- public methods --------------------------------------------
2992
2993 void ScInputHandler::SetMode( ScInputMode eNewMode, const OUString* pInitText, ScEditEngineDefaulter* pTopEngine )
2994 {
2995 if ( eMode == eNewMode )
2996 return;
2997
2998 ImplCreateEditEngine();
2999
3000 if (bProtected)
3001 {
3002 eMode = SC_INPUT_NONE;
3003 StopInputWinEngine( true );
3004 if (pActiveViewSh)
3005 pActiveViewSh->GetActiveWin()->GrabFocus();
3006 return;
3007 }
3008
3009 if (eNewMode != SC_INPUT_NONE && pActiveViewSh)
3010 // Disable paste mode when edit mode starts.
3011 pActiveViewSh->GetViewData().SetPasteMode( ScPasteFlags::NONE );
3012
3013 bInOwnChange = true; // disable ModifyHdl (reset below)
3014
3015 ScInputMode eOldMode = eMode;
3016 eMode = eNewMode;
3017 if (eOldMode == SC_INPUT_TOP && eNewMode != eOldMode)
3018 StopInputWinEngine( false );
3019
3020 if (eMode==SC_INPUT_TOP || eMode==SC_INPUT_TABLE)
3021 {
3022 if (eOldMode == SC_INPUT_NONE) // not if switching between modes
3023 {
3024 if (StartTable(0, false, eMode == SC_INPUT_TABLE, pTopEngine))
3025 {
3026 if (pActiveViewSh)
3027 pActiveViewSh->GetViewData().GetDocShell()->PostEditView( mpEditEngine.get(), aCursorPos );
3028 }
3029 }
3030
3031 if (pInitText)
3032 {
3033 mpEditEngine->SetTextCurrentDefaults(*pInitText);
3034 bModified = true;
3035 }
3036
3037 sal_Int32 nPara = mpEditEngine->GetParagraphCount()-1;
3038 sal_Int32 nLen = mpEditEngine->GetText(nPara).getLength();
3039 sal_uInt16 nCount = mpEditEngine->GetViewCount();
3040
3041 for (sal_uInt16 i=0; i<nCount; i++)
3042 {
3043 if ( eMode == SC_INPUT_TABLE && eOldMode == SC_INPUT_TOP )
3044 {
3045 // Keep Selection
3046 }
3047 else
3048 {
3049 mpEditEngine->GetView(i)->
3050 SetSelection( ESelection( nPara, nLen, nPara, nLen ) );
3051 }
3052 mpEditEngine->GetView(i)->ShowCursor(false);
3053 }
3054 }
3055
3056 UpdateActiveView();
3057 if (eMode==SC_INPUT_TABLE || eMode==SC_INPUT_TYPE)
3058 {
3059 if (pTableView)
3060 pTableView->SetEditEngineUpdateLayout(true);
3061 }
3062 else
3063 {
3064 if (pTopView)
3065 pTopView->SetEditEngineUpdateLayout(true);
3066 }
3067
3068 if (eNewMode != eOldMode)
3069 UpdateFormulaMode();
3070
3071 bInOwnChange = false;
3072 }
3073
3074 /**
3075 * @return true if rString only contains digits (no autocorrect then)
3076 */
3077 static bool lcl_IsNumber(std::u16string_view aString)
3078 {
3079 size_t nLen = aString.size();
3080 for (size_t i=0; i<nLen; i++)
3081 {
3082 sal_Unicode c = aString[i];
3083 if ( c < '0' || c > '9' )
3084 return false;
3085 }
3086 return true;
3087 }
3088
3089 static void lcl_SelectionToEnd( EditView* pView )
3090 {
3091 if ( pView )
3092 {
3093 EditEngine* pEngine = pView->GetEditEngine();
3094 sal_Int32 nParCnt = pEngine->GetParagraphCount();
3095 if ( nParCnt == 0 )
3096 nParCnt = 1;
3097 ESelection aSel( nParCnt-1, pEngine->GetTextLen(nParCnt-1) ); // empty selection, cursor at the end
3098 pView->SetSelection( aSel );
3099 }
3100 }
3101
3102 void ScInputHandler::EnterHandler( ScEnterMode nBlockMode, bool bBeforeSavingInLOK )
3103 {
3104 if (!mbDocumentDisposing && comphelper::LibreOfficeKit::isActive()
3105 && pActiveViewSh != SfxViewShell::Current())
3106 return;
3107
3108 // Macro calls for validity can cause a lot of problems, so inhibit
3109 // nested calls of EnterHandler().
3110 if (bInEnterHandler) return;
3111 bInEnterHandler = true;
3112 bInOwnChange = true; // disable ModifyHdl (reset below)
3113 mbPartialPrefix = false;
3114
3115 ImplCreateEditEngine();
3116
3117 bool bMatrix = ( nBlockMode == ScEnterMode::MATRIX );
3118
3119 SfxApplication* pSfxApp = SfxGetpApp();
3120 std::unique_ptr<EditTextObject> pObject;
3121 std::unique_ptr<ScPatternAttr> pCellAttrs;
3122 bool bForget = false; // Remove due to validity?
3123
3124 OUString aString = GetEditText(mpEditEngine.get());
3125 OUString aPreAutoCorrectString(aString);
3126 EditView* pActiveView = pTopView ? pTopView : pTableView;
3127 if (bModified && pActiveView && !aString.isEmpty() && !lcl_IsNumber(aString))
3128 {
3129 if (pColumnData && miAutoPosColumn != pColumnData->end())
3130 {
3131 // #i47125# If AutoInput appended something, do the final AutoCorrect
3132 // with the cursor at the end of the input.
3133 lcl_SelectionToEnd(pTopView);
3134 lcl_SelectionToEnd(pTableView);
3135 }
3136
3137 vcl::Window* pFrameWin = pActiveViewSh ? pActiveViewSh->GetFrameWin() : nullptr;
3138
3139 if (pTopView)
3140 pTopView->CompleteAutoCorrect(); // CompleteAutoCorrect for both Views
3141 if (pTableView)
3142 pTableView->CompleteAutoCorrect(pFrameWin);
3143 aString = GetEditText(mpEditEngine.get());
3144 }
3145 lcl_RemoveTabs(aString);
3146 lcl_RemoveTabs(aPreAutoCorrectString);
3147
3148 if (aString.indexOf('\n') != -1)
3149 {
3150 // Cell contains line breaks, enable wrapping
3151 ScLineBreakCell aBreakItem(true);
3152 pActiveViewSh->ApplyAttr(aBreakItem);
3153
3154 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
3155 if (pViewFrm)
3156 pViewFrm->GetBindings().Invalidate(SID_ATTR_ALIGN_LINEBREAK);
3157 }
3158
3159 // Test if valid (always with simple string)
3160 if (bModified && nValidation && pActiveViewSh)
3161 {
3162 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocument();
3163 const ScValidationData* pData = rDoc.GetValidationEntry( nValidation );
3164 if (pData && pData->HasErrMsg())
3165 {
3166 // #i67990# don't use pLastPattern in EnterHandler
3167 const ScPatternAttr* pPattern = rDoc.GetPattern( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
3168
3169 bool bOk;
3170
3171 if (pData->GetDataMode() == SC_VALID_CUSTOM)
3172 {
3173 bOk = pData->IsDataValidCustom( aString, *pPattern, aCursorPos, ScValidationData::CustomValidationPrivateAccess() );
3174 }
3175 else
3176 {
3177 bOk = pData->IsDataValid( aString, *pPattern, aCursorPos );
3178 }
3179
3180 if (!bOk)
3181 {
3182 pActiveViewSh->StopMarking(); // (the InfoBox consumes the MouseButtonUp)
3183
3184 // tdf#125917 Release the grab that a current mouse-down event being handled
3185 // by ScTabView has put on the mouse via its SelectionEngine.
3186 // Otherwise the warning box cannot interact with the mouse
3187 if (ScTabView* pView = pActiveViewSh->GetViewData().GetView())
3188 {
3189 if (ScViewSelectionEngine* pSelEngine = pView->GetSelEngine())
3190 pSelEngine->ReleaseMouse();
3191 }
3192
3193 if (bBeforeSavingInLOK)
3194 {
3195 // Invalid entry but not applied to the document model.
3196 // Exit to complete the "save", leaving the edit view as it is
3197 // for the user to continue after save.
3198 bInOwnChange = false;
3199 bInEnterHandler = false;
3200 return;
3201 }
3202
3203 if (pData->DoError(pActiveViewSh->GetFrameWeld(), aString, aCursorPos))
3204 bForget = true; // Do not take over input
3205 }
3206 }
3207 }
3208
3209 // Check for input into DataPilot table
3210 if ( bModified && pActiveViewSh && !bForget )
3211 {
3212 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocument();
3213 ScDPObject* pDPObj = rDoc.GetDPAtCursor( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
3214 if ( pDPObj )
3215 {
3216 // Any input within the DataPilot table is either a valid renaming
3217 // or an invalid action - normal cell input is always aborted
3218 pActiveViewSh->DataPilotInput( aCursorPos, aString );
3219 bForget = true;
3220 }
3221 }
3222
3223 std::vector<editeng::MisspellRanges> aMisspellRanges;
3224 // UpdateLayout must be true during CompleteOnlineSpelling
3225 const bool bUpdateLayout = mpEditEngine->SetUpdateLayout( true );
3226 mpEditEngine->CompleteOnlineSpelling();
3227 bool bSpellErrors = !bFormulaMode && mpEditEngine->HasOnlineSpellErrors();
3228 if ( bSpellErrors )
3229 {
3230 // #i3820# If the spell checker flags numerical input as error,
3231 // it still has to be treated as number, not EditEngine object.
3232 if ( pActiveViewSh )
3233 {
3234 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocument();
3235 // #i67990# don't use pLastPattern in EnterHandler
3236 const ScPatternAttr* pPattern = rDoc.GetPattern( aCursorPos.Col(), aCursorPos.Row(), aCursorPos.Tab() );
3237 if (pPattern)
3238 {
3239 SvNumberFormatter* pFormatter = rDoc.GetFormatTable();
3240 // without conditional format, as in ScColumn::SetString
3241 sal_uInt32 nFormat = pPattern->GetNumberFormat( pFormatter );
3242 double nVal;
3243 if ( pFormatter->IsNumberFormat( aString, nFormat, nVal ) )
3244 {
3245 bSpellErrors = false; // ignore the spelling errors
3246 }
3247 }
3248 }
3249 }
3250
3251 // After RemoveAdjust, the EditView must not be repainted (has wrong font size etc).
3252 // SetUpdateLayout must come after CompleteOnlineSpelling.
3253 // The view is hidden in any case below (Broadcast).
3254 mpEditEngine->SetUpdateLayout( false );
3255
3256 if ( bModified && !bForget ) // What is being entered (text/object)?
3257 {
3258 sal_Int32 nParCnt = mpEditEngine->GetParagraphCount();
3259 if ( nParCnt == 0 )
3260 nParCnt = 1;
3261
3262 bool bUniformAttribs = true;
3263 SfxItemSet aPara1Attribs = mpEditEngine->GetAttribs(0, 0, mpEditEngine->GetTextLen(0));
3264 for (sal_Int32 nPara = 1; nPara < nParCnt; ++nPara)
3265 {
3266 SfxItemSet aPara2Attribs = mpEditEngine->GetAttribs(nPara, 0, mpEditEngine->GetTextLen(nPara));
3267 if (!(aPara1Attribs == aPara2Attribs))
3268 {
3269 // Paragraph format different from that of the 1st paragraph.
3270 bUniformAttribs = false;
3271 break;
3272 }
3273 }
3274
3275 ESelection aSel( 0, 0, nParCnt-1, mpEditEngine->GetTextLen(nParCnt-1) );
3276 SfxItemSet aOldAttribs = mpEditEngine->GetAttribs( aSel );
3277 const SfxPoolItem* pItem = nullptr;
3278
3279 // Find common (cell) attributes before RemoveAdjust
3280 if ( pActiveViewSh && bUniformAttribs )
3281 {
3282 std::optional<SfxItemSet> pCommonAttrs;
3283 for (sal_uInt16 nId = EE_CHAR_START; nId <= EE_CHAR_END; nId++)
3284 {
3285 SfxItemState eState = aOldAttribs.GetItemState( nId, false, &pItem );
3286 if ( eState == SfxItemState::SET &&
3287 nId != EE_CHAR_ESCAPEMENT && nId != EE_CHAR_PAIRKERNING &&
3288 nId != EE_CHAR_KERNING && nId != EE_CHAR_XMLATTRIBS &&
3289 *pItem != pEditDefaults->Get(nId) )
3290 {
3291 if ( !pCommonAttrs )
3292 pCommonAttrs.emplace( mpEditEngine->GetEmptyItemSet() );
3293 pCommonAttrs->Put( *pItem );
3294 }
3295 }
3296
3297 if ( pCommonAttrs )
3298 {
3299 ScDocument& rDoc = pActiveViewSh->GetViewData().GetDocument();
3300 pCellAttrs = std::make_unique<ScPatternAttr>(rDoc.GetPool());
3301 pCellAttrs->GetFromEditItemSet( &*pCommonAttrs );
3302 }
3303 }
3304
3305 // Clear ParaAttribs (including adjustment)
3306 RemoveAdjust();
3307
3308 bool bAttrib = false; // Formatting present?
3309
3310 // check if EditObject is needed
3311 if (nParCnt > 1)
3312 bAttrib = true;
3313 else
3314 {
3315 for (sal_uInt16 nId = EE_CHAR_START; nId <= EE_CHAR_END && !bAttrib; nId++)
3316 {
3317 SfxItemState eState = aOldAttribs.GetItemState( nId, false, &pItem );
3318 if (eState == SfxItemState::DONTCARE)
3319 bAttrib = true;
3320 else if (eState == SfxItemState::SET)
3321 {
3322 // Keep same items in EditEngine as in ScEditAttrTester
3323 if ( nId == EE_CHAR_ESCAPEMENT || nId == EE_CHAR_PAIRKERNING ||
3324 nId == EE_CHAR_KERNING || nId == EE_CHAR_XMLATTRIBS )
3325 {
3326 if ( *pItem != pEditDefaults->Get(nId) )
3327 bAttrib = true;
3328 }
3329 }
3330 }
3331
3332 // Contains fields?
3333 SfxItemState eFieldState = aOldAttribs.GetItemState( EE_FEATURE_FIELD, false );
3334 if ( eFieldState == SfxItemState::DONTCARE || eFieldState == SfxItemState::SET )
3335 bAttrib = true;
3336
3337 // Not converted characters?
3338 SfxItemState eConvState = aOldAttribs.GetItemState( EE_FEATURE_NOTCONV, false );
3339 if ( eConvState == SfxItemState::DONTCARE || eConvState == SfxItemState::SET )
3340 bAttrib = true;
3341
3342 // Always recognize formulas as formulas
3343 // We still need the preceding test due to cell attributes
3344 }
3345
3346 if (bSpellErrors)
3347 mpEditEngine->GetAllMisspellRanges(aMisspellRanges);
3348
3349 if (bMatrix)
3350 bAttrib = false;
3351
3352 if (bAttrib)
3353 {
3354 mpEditEngine->ClearSpellErrors();
3355 pObject = mpEditEngine->CreateTextObject();
3356 }
3357 else if (SC_MOD()->GetAppOptions().GetAutoComplete()) // Adjust Upper/Lower case
3358 {
3359 // Perform case-matching only when the typed text is partial.
3360 if (pColumnData && aAutoSearch.getLength() < aString.getLength())
3361 aString = getExactMatch(*pColumnData, aString);
3362 }
3363 }
3364
3365 // Don't rely on ShowRefFrame switching the active view synchronously
3366 // execute the function directly on the correct view's bindings instead
3367 // pRefViewSh is reset in ShowRefFrame - get pointer before ShowRefFrame call
3368 ScTabViewShell* pExecuteSh = pRefViewSh ? pRefViewSh : pActiveViewSh;
3369
3370 if (bFormulaMode)
3371 {
3372 ShowRefFrame();
3373
3374 if (pExecuteSh)
3375 {
3376 pExecuteSh->SetTabNo(aCursorPos.Tab());
3377 pExecuteSh->ActiveGrabFocus();
3378 }
3379
3380 bFormulaMode = false;
3381 pSfxApp->Broadcast( SfxHint( SfxHintId::ScRefModeChanged ) );
3382 SC_MOD()->SetRefInputHdl(nullptr);
3383 if (pInputWin)
3384 pInputWin->SetFormulaMode(false);
3385 UpdateAutoCorrFlag();
3386 }
3387 pRefViewSh = nullptr; // Also without FormulaMode due to FunctionsAutoPilot
3388 DeleteRangeFinder();
3389 ResetAutoPar();
3390
3391 bool bOldMod = bModified;
3392
3393 bModified = false;
3394 bSelIsRef = false;
3395 eMode = SC_INPUT_NONE;
3396 StopInputWinEngine(true);
3397
3398 // Text input (through number formats) or ApplySelectionPattern modify
3399 // the cell's attributes, so pLastPattern is no longer valid
3400 pLastPattern = nullptr;
3401
3402 if (bOldMod && !bProtected && !bForget)
3403 {
3404 bool bInsertPreCorrectedString = true;
3405 // No typographic quotes in formulas
3406 if (aString.startsWith("="))
3407 {
3408 SvxAutoCorrect* pAuto = SvxAutoCorrCfg::Get().GetAutoCorrect();
3409 if ( pAuto )
3410 {
3411 bInsertPreCorrectedString = false;
3412 OUString aReplace(pAuto->GetStartDoubleQuote());
3413 if( aReplace.isEmpty() )
3414 aReplace = ScGlobal::getLocaleData().getDoubleQuotationMarkStart();
3415 if( aReplace != "\"" )
3416 aString = aString.replaceAll( aReplace, "\"" );
3417
3418 aReplace = OUString(pAuto->GetEndDoubleQuote());
3419 if( aReplace.isEmpty() )
3420 aReplace = ScGlobal::getLocaleData().getDoubleQuotationMarkEnd();
3421 if( aReplace != "\"" )
3422 aString = aString.replaceAll( aReplace, "\"" );
3423
3424 aReplace = OUString(pAuto->GetStartSingleQuote());
3425 if( aReplace.isEmpty() )
3426 aReplace = ScGlobal::getLocaleData().getQuotationMarkStart();
3427 if( aReplace != "'" )
3428 aString = aString.replaceAll( aReplace, "'" );
3429
3430 aReplace = OUString(pAuto->GetEndSingleQuote());
3431 if( aReplace.isEmpty() )
3432 aReplace = ScGlobal::getLocaleData().getQuotationMarkEnd();
3433 if( aReplace != "'" )
3434 aString = aString.replaceAll( aReplace, "'");
3435 }
3436 }
3437
3438 pSfxApp->Broadcast( SfxHint( SfxHintId::ScKillEditViewNoPaint ) );
3439
3440 if ( pExecuteSh )
3441 {
3442 SfxBindings& rBindings = pExecuteSh->GetViewFrame()->GetBindings();
3443
3444 sal_uInt16 nId = FID_INPUTLINE_ENTER;
3445 if ( nBlockMode == ScEnterMode::BLOCK )
3446 nId = FID_INPUTLINE_BLOCK;
3447 else if ( nBlockMode == ScEnterMode::MATRIX )
3448 nId = FID_INPUTLINE_MATRIX;
3449
3450 const SfxPoolItem* aArgs[2];
3451 aArgs[1] = nullptr;
3452
3453 if ( bInsertPreCorrectedString && aString != aPreAutoCorrectString )
3454 {
3455 ScInputStatusItem aItem(FID_INPUTLINE_STATUS,
3456 aCursorPos, aCursorPos, aCursorPos,
3457 aPreAutoCorrectString, pObject.get());
3458 aArgs[0] = &aItem;
3459 rBindings.Execute(nId, aArgs);
3460 }
3461
3462 ScInputStatusItem aItemCorrected(FID_INPUTLINE_STATUS,
3463 aCursorPos, aCursorPos, aCursorPos,
3464 aString, pObject.get());
3465 if ( !aMisspellRanges.empty() )
3466 aItemCorrected.SetMisspellRanges(&aMisspellRanges);
3467
3468 aArgs[0] = &aItemCorrected;
3469 rBindings.Execute(nId, aArgs);
3470 }
3471
3472 pLastState.reset(); // pLastState still contains the old text
3473 }
3474 else
3475 pSfxApp->Broadcast( SfxHint( SfxHintId::ScKillEditView ) );
3476
3477 if ( bOldMod && pExecuteSh && pCellAttrs && !bForget )
3478 {
3479 // Combine with input?
3480 pExecuteSh->ApplySelectionPattern( *pCellAttrs, true );
3481 pExecuteSh->AdjustBlockHeight();
3482 }
3483
3484 HideTip();
3485 HideTipBelow();
3486
3487 nFormSelStart = nFormSelEnd = 0;
3488 aFormText.clear();
3489
3490 mbEditingExistingContent = false;
3491 bInOwnChange = false;
3492 bInEnterHandler = false;
3493 if (bUpdateLayout)
3494 mpEditEngine->SetUpdateLayout( true );
3495 }
3496
3497 void ScInputHandler::CancelHandler()
3498 {
3499 bInOwnChange = true; // Also without FormulaMode due to FunctionsAutoPilot
3500
3501 ImplCreateEditEngine();
3502
3503 bModified = false;
3504 mbPartialPrefix = false;
3505 mbEditingExistingContent = false;
3506
3507 // Don't rely on ShowRefFrame switching the active view synchronously
3508 // execute the function directly on the correct view's bindings instead
3509 // pRefViewSh is reset in ShowRefFrame - get pointer before ShowRefFrame call
3510 ScTabViewShell* pExecuteSh = pRefViewSh ? pRefViewSh : pActiveViewSh;
3511
3512 if (bFormulaMode)
3513 {
3514 ShowRefFrame();
3515 if (pExecuteSh)
3516 {
3517 pExecuteSh->SetTabNo(aCursorPos.Tab());
3518 pExecuteSh->ActiveGrabFocus();
3519 }
3520 bFormulaMode = false;
3521 SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScRefModeChanged ) );
3522 SC_MOD()->SetRefInputHdl(nullptr);
3523 if (pInputWin)
3524 pInputWin->SetFormulaMode(false);
3525 UpdateAutoCorrFlag();
3526 }
3527 pRefViewSh = nullptr; // Also without FormulaMode due to FunctionsAutoPilot
3528 DeleteRangeFinder();
3529 ResetAutoPar();
3530
3531 eMode = SC_INPUT_NONE;
3532 StopInputWinEngine( true );
3533 SCCOL nMaxCol(MAXCOL);
3534 if (pExecuteSh)
3535 {
3536 pExecuteSh->StopEditShell();
3537 nMaxCol = pExecuteSh->GetViewData().GetDocument().MaxCol();
3538 }
3539
3540 aCursorPos.Set(nMaxCol+1,0,0); // Invalid flag
3541 mpEditEngine->SetTextCurrentDefaults(OUString());
3542
3543 if ( !pLastState && pExecuteSh )
3544 pExecuteSh->UpdateInputHandler( true ); // Update status again
3545 else
3546 NotifyChange( pLastState.get(), true );
3547
3548 nFormSelStart = nFormSelEnd = 0;
3549 aFormText.clear();
3550
3551 bInOwnChange = false;
3552
3553 if ( comphelper::LibreOfficeKit::isActive() && pExecuteSh )
3554 {
3555 // Clear
3556 std::vector<ReferenceMark> aReferenceMarks;
3557 ScInputHandler::SendReferenceMarks( pActiveViewSh, aReferenceMarks );
3558 }
3559 }
3560
3561 bool ScInputHandler::IsModalMode( const SfxObjectShell* pDocSh )
3562 {
3563 // References to unnamed document; that doesn't work
3564 return bFormulaMode && pRefViewSh
3565 && pRefViewSh->GetViewData().GetDocument().GetDocumentShell() != pDocSh
3566 && !pDocSh->HasName();
3567 }
3568
3569 void ScInputHandler::AddRefEntry()
3570 {
3571 const sal_Unicode cSep = ScCompiler::GetNativeSymbolChar(ocSep);
3572 UpdateActiveView();
3573 if (!pTableView && !pTopView)
3574 return; // E.g. FillMode
3575
3576 DataChanging(); // Cannot be new
3577
3578 RemoveSelection();
3579 OUString aText = GetEditText(mpEditEngine.get());
3580 sal_Unicode cLastChar = 0;
3581 sal_Int32 nPos = aText.getLength() - 1;
3582 while (nPos >= 0) //checking space
3583 {
3584 cLastChar = aText[nPos];
3585 if (cLastChar != ' ')
3586 break;
3587 --nPos;
3588 }
3589
3590 bool bAppendSeparator = (cLastChar != '(' && cLastChar != cSep && cLastChar != '=');
3591 if (bAppendSeparator)
3592 {
3593 if (pTableView)
3594 pTableView->InsertText( OUString(cSep) );
3595 if (pTopView)
3596 pTopView->InsertText( OUString(cSep) );
3597 }
3598
3599 DataChanged();
3600 }
3601
3602 void ScInputHandler::SetReference( const ScRange& rRef, const ScDocument& rDoc )
3603 {
3604 HideTip();
3605
3606 const ScDocument* pThisDoc = nullptr;
3607 if (pRefViewSh)
3608 pThisDoc = &pRefViewSh->GetViewData().GetDocument();
3609 bool bOtherDoc = (pThisDoc != &rDoc);
3610 if (bOtherDoc && !rDoc.GetDocumentShell()->HasName())
3611 {
3612 // References to unnamed document; that doesn't work
3613 // SetReference should not be called, then
3614 return;
3615 }
3616 if (!pThisDoc)
3617 pThisDoc = &rDoc;
3618
3619 UpdateActiveView();
3620 if (!pTableView && !pTopView)
3621 return; // E.g. FillMode
3622
3623 // Never overwrite the "="!
3624 EditView* pActiveView = pTopView ? pTopView : pTableView;
3625 ESelection aSel = pActiveView->GetSelection();
3626 aSel.Adjust();
3627 if ( aSel.nStartPara == 0 && aSel.nStartPos == 0 )
3628 return;
3629
3630 DataChanging(); // Cannot be new
3631
3632 // Turn around selection if backwards.
3633 if (pTableView)
3634 {
3635 ESelection aTabSel = pTableView->GetSelection();
3636 if (aTabSel.nStartPos > aTabSel.nEndPos && aTabSel.nStartPara == aTabSel.nEndPara)
3637 {
3638 aTabSel.Adjust();
3639 pTableView->SetSelection(aTabSel);
3640 }
3641 }
3642 if (pTopView)
3643 {
3644 ESelection aTopSel = pTopView->GetSelection();
3645 if (aTopSel.nStartPos > aTopSel.nEndPos && aTopSel.nStartPara == aTopSel.nEndPara)
3646 {
3647 aTopSel.Adjust();
3648 pTopView->SetSelection(aTopSel);
3649 }
3650 }
3651
3652 // Create string from reference, in the syntax of the document being edited.
3653 OUString aRefStr;
3654 const ScAddress::Details aAddrDetails( *pThisDoc, aCursorPos );
3655 if (bOtherDoc)
3656 {
3657 // Reference to other document
3658 OSL_ENSURE(rRef.aStart.Tab()==rRef.aEnd.Tab(), "nStartTab!=nEndTab");
3659
3660 // Always 3D and absolute.
3661 OUString aTmp(rRef.Format(rDoc, ScRefFlags::VALID | ScRefFlags::TAB_ABS_3D, aAddrDetails));
3662
3663 SfxObjectShell* pObjSh = rDoc.GetDocumentShell();
3664 // #i75893# convert escaped URL of the document to something user friendly
3665 OUString aFileName = pObjSh->GetMedium()->GetURLObject().GetMainURL( INetURLObject::DecodeMechanism::Unambiguous );
3666
3667 switch(aAddrDetails.eConv)
3668 {
3669 case formula::FormulaGrammar::CONV_XL_A1 :
3670 case formula::FormulaGrammar::CONV_XL_OOX :
3671 case formula::FormulaGrammar::CONV_XL_R1C1 :
3672 aRefStr = "[\'" + aFileName + "']";
3673 break;
3674 case formula::FormulaGrammar::CONV_OOO :
3675 default:
3676 aRefStr = "\'" + aFileName + "'#";
3677 break;
3678 }
3679 aRefStr += aTmp;
3680 }
3681 else
3682 {
3683 if ( rRef.aStart.Tab() != aCursorPos.Tab() ||
3684 rRef.aStart.Tab() != rRef.aEnd.Tab() )
3685 // pointer-selected => absolute sheet reference
3686 aRefStr = rRef.Format(rDoc, ScRefFlags::VALID | ScRefFlags::TAB_ABS_3D, aAddrDetails);
3687 else
3688 aRefStr = rRef.Format(rDoc, ScRefFlags::VALID, aAddrDetails);
3689 }
3690 bool bLOKShowSelect = true;
3691 if(comphelper::LibreOfficeKit::isActive() && pRefViewSh->GetViewData().GetRefTabNo() != pRefViewSh->GetViewData().GetTabNo())
3692 bLOKShowSelect = false;
3693
3694 if (pTableView || pTopView)
3695 {
3696 if (pTableView)
3697 pTableView->InsertText( aRefStr, true, bLOKShowSelect );
3698 if (pTopView)
3699 pTopView->InsertText( aRefStr, true, bLOKShowSelect );
3700
3701 DataChanged();
3702 }
3703
3704 bSelIsRef = true;
3705 }
3706
3707 void ScInputHandler::InsertFunction( const OUString& rFuncName, bool bAddPar )
3708 {
3709 if ( eMode == SC_INPUT_NONE )
3710 {
3711 OSL_FAIL("InsertFunction, not during input mode");
3712 return;
3713 }
3714
3715 UpdateActiveView();
3716 if (!pTableView && !pTopView)
3717 return; // E.g. FillMode
3718
3719 DataChanging(); // Cannot be new
3720
3721 OUString aText = rFuncName;
3722 if (bAddPar)
3723 aText += "()";
3724
3725 if (pTableView)
3726 {
3727 pTableView->InsertText( aText );
3728 if (bAddPar)
3729 {
3730 ESelection aSel = pTableView->GetSelection();
3731 --aSel.nStartPos;
3732 --aSel.nEndPos;
3733 pTableView->SetSelection(aSel);
3734 }
3735 }
3736 if (pTopView)
3737 {
3738 pTopView->InsertText( aText );
3739 if (bAddPar)
3740 {
3741 ESelection aSel = pTopView->GetSelection();
3742 --aSel.nStartPos;
3743 --aSel.nEndPos;
3744 pTopView->SetSelection(aSel);
3745 }
3746 }
3747
3748 DataChanged();
3749
3750 if (bAddPar)
3751 AutoParAdded();
3752 }
3753
3754 void ScInputHandler::ClearText()
3755 {
3756 if ( eMode == SC_INPUT_NONE )
3757 {
3758 OSL_FAIL("ClearText, not during input mode");
3759 return;
3760 }
3761
3762 UpdateActiveView();
3763 if (!pTableView && !pTopView)
3764 return; // E.g. FillMode
3765
3766 DataChanging(); // Cannot be new
3767
3768 if (pTableView)
3769 {
3770 pTableView->GetEditEngine()->SetText( "" );
3771 pTableView->SetSelection( ESelection(0,0, 0,0) );
3772 }
3773 if (pTopView)
3774 {
3775 pTopView->GetEditEngine()->SetText( "" );
3776 pTopView->SetSelection( ESelection(0,0, 0,0) );
3777 }
3778
3779 DataChanged();
3780 }
3781
3782 bool ScInputHandler::KeyInput( const KeyEvent& rKEvt, bool bStartEdit /* = false */ )
3783 {
3784 vcl::KeyCode aCode = rKEvt.GetKeyCode();
3785 sal_uInt16 nModi = aCode.GetModifier();
3786 bool bShift = aCode.IsShift();
3787 bool bControl = aCode.IsMod1();
3788 bool bAlt = aCode.IsMod2();
3789 sal_uInt16 nCode = aCode.GetCode();
3790 sal_Unicode nChar = rKEvt.GetCharCode();
3791
3792 if (bAlt && !bControl && nCode != KEY_RETURN)
3793 // Alt-Return and Alt-Ctrl-* are accepted. Everything else with ALT are not.
3794 return false;
3795
3796 // There is a partial autocomplete suggestion.
3797 // Allow its completion with right arrow key (without modifiers).
3798 if (mbPartialPrefix && nCode == KEY_RIGHT && !bControl && !bShift && !bAlt &&
3799 (pTopView || pTableView))
3800 {
3801 if (pTopView)
3802 pTopView->PostKeyEvent(KeyEvent(0, css::awt::Key::MOVE_TO_END_OF_PARAGRAPH));
3803 if (pTableView)
3804 pTableView->PostKeyEvent(KeyEvent(0, css::awt::Key::MOVE_TO_END_OF_PARAGRAPH));
3805
3806 mbPartialPrefix = false;
3807
3808 // Indicate that this event has been consumed and ScTabViewShell should not act on this.
3809 return true;
3810 }
3811
3812 if (!bControl && nCode == KEY_TAB)
3813 {
3814 // Normal TAB moves the cursor right.
3815 EnterHandler();
3816
3817 if (pActiveViewSh)
3818 pActiveViewSh->FindNextUnprot( bShift, true );
3819 return true;
3820 }
3821
3822 bool bInputLine = ( eMode==SC_INPUT_TOP );
3823
3824 bool bUsed = false;
3825 bool bSkip = false;
3826 bool bDoEnter = false;
3827
3828 switch ( nCode )
3829 {
3830 case KEY_RETURN:
3831 // New line when in the input line and Shift/Ctrl-Enter is pressed,
3832 // or when in a cell and Ctrl-Enter is pressed.
3833 if ((pInputWin && bInputLine && bControl != bShift) || (!bInputLine && bControl && !bShift))
3834 {
3835 bDoEnter = true;
3836 }
3837 else if (nModi == 0 && nTipVisible && pFormulaData && miAutoPosFormula != pFormulaData->end())
3838 {
3839 PasteFunctionData();
3840 bUsed = true;
3841 }
3842 else if ( nModi == 0 && nTipVisible && !aManualTip.isEmpty() )
3843 {
3844 PasteManualTip();
3845 bUsed = true;
3846 }
3847 else
3848 {
3849 ScEnterMode nMode = ScEnterMode::NORMAL;
3850 if ( bShift && bControl )
3851 nMode = ScEnterMode::MATRIX;
3852 else if ( bAlt )
3853 nMode = ScEnterMode::BLOCK;
3854 EnterHandler( nMode );
3855
3856 if (pActiveViewSh)
3857 pActiveViewSh->MoveCursorEnter( bShift && !bControl );
3858
3859 bUsed = true;
3860 }
3861 break;
3862 case KEY_TAB:
3863 if (bControl && !bAlt)
3864 {
3865 if (pFormulaData && nTipVisible && miAutoPosFormula != pFormulaData->end())
3866 {
3867 // Iterate
3868 NextFormulaEntry( bShift );
3869 bUsed = true;
3870 }
3871 else if (pColumnData && bUseTab)
3872 {
3873 // Iterate through AutoInput entries
3874 NextAutoEntry( bShift );
3875 bUsed = true;
3876 }
3877 }
3878 break;
3879 case KEY_ESCAPE:
3880 if ( nTipVisible )
3881 {
3882 HideTip();
3883 bUsed = true;
3884 }
3885 else if( nTipVisibleSec )
3886 {
3887 HideTipBelow();
3888 bUsed = true;
3889 }
3890 else if (eMode != SC_INPUT_NONE)
3891 {
3892 CancelHandler();
3893 bUsed = true;
3894 }
3895 else
3896 bSkip = true;
3897 break;
3898 case KEY_F2:
3899 if ( !bShift && !bControl && !bAlt && eMode == SC_INPUT_TABLE )
3900 {
3901 eMode = SC_INPUT_TYPE;
3902 bUsed = true;
3903 }
3904 break;
3905 }
3906
3907 // Only execute cursor keys if already in EditMode
3908 // E.g. due to Shift-Ctrl-PageDn (not defined as an accelerator)
3909 bool bCursorKey = EditEngine::DoesKeyMoveCursor(rKEvt);
3910 bool bInsKey = ( nCode == KEY_INSERT && !nModi ); // Treat Insert like Cursorkeys
3911 if ( !bUsed && !bSkip && ( bDoEnter || EditEngine::DoesKeyChangeText(rKEvt) ||
3912 ( eMode != SC_INPUT_NONE && ( bCursorKey || bInsKey ) ) ) )
3913 {
3914 HideTip();
3915 HideTipBelow();
3916
3917 if (bSelIsRef)
3918 {
3919 RemoveSelection();
3920 bSelIsRef = false;
3921 }
3922
3923 UpdateActiveView();
3924 bool bNewView = DataChanging( nChar );
3925
3926 if (bProtected) // Protected cell?
3927 bUsed = true; // Don't forward KeyEvent
3928 else // Changes allowed
3929 {
3930 if (bNewView ) // Create anew
3931 {
3932 if (pActiveViewSh)
3933 pActiveViewSh->GetViewData().GetDocShell()->PostEditView( mpEditEngine.get(), aCursorPos );
3934 UpdateActiveView();
3935 if (eMode==SC_INPUT_NONE)
3936 if (pTableView || pTopView)
3937 {
3938 OUString aStrLoP;
3939
3940 if (bStartEdit && nCellPercentFormatDecSep != 0 &&
3941 ((nChar >= '0' && nChar <= '9') || nChar == '-' || nChar == nCellPercentFormatDecSep))
3942 {
3943 aStrLoP = "%";
3944 }
3945
3946 if (pTableView)
3947 {
3948 pTableView->GetEditEngine()->SetText( aStrLoP );
3949 if ( !aStrLoP.isEmpty() )
3950 pTableView->SetSelection( ESelection(0,0, 0,0) ); // before the '%'
3951
3952 // Don't call SetSelection if the string is empty anyway,
3953 // to avoid breaking the bInitial handling in ScViewData::EditGrowY
3954 }
3955 if (pTopView)
3956 {
3957 pTopView->GetEditEngine()->SetText( aStrLoP );
3958 if ( !aStrLoP.isEmpty() )
3959 pTopView->SetSelection( ESelection(0,0, 0,0) ); // before the '%'
3960 }
3961 }
3962 SyncViews();
3963 }
3964
3965 if (pTableView || pTopView)
3966 {
3967 if (bDoEnter)
3968 {
3969 if (pTableView)
3970 if( pTableView->PostKeyEvent( KeyEvent( '\r', vcl::KeyCode(KEY_RETURN) ) ) )
3971 bUsed = true;
3972 if (pTopView)
3973 if( pTopView->PostKeyEvent( KeyEvent( '\r', vcl::KeyCode(KEY_RETURN) ) ) )
3974 bUsed = true;
3975 }
3976 else if ( nAutoPar && nChar == ')' && CursorAtClosingPar() )
3977 {
3978 SkipClosingPar();
3979 bUsed = true;
3980 }
3981 else
3982 {
3983 if (pTableView)
3984 {
3985 if (pTopView)
3986 pTableView->SetControlWord(pTableView->GetControlWord() | EVControlBits::SINGLELINEPASTE);
3987
3988 vcl::Window* pFrameWin = pActiveViewSh ? pActiveViewSh->GetFrameWin() : nullptr;
3989 if ( pTableView->PostKeyEvent( rKEvt, pFrameWin ) )
3990 bUsed = true;
3991
3992 pTableView->SetControlWord(pTableView->GetControlWord() & ~EVControlBits::SINGLELINEPASTE);
3993 }
3994 if (pTopView)
3995 {
3996 if ( bUsed && rKEvt.GetKeyCode().GetFunction() == KeyFuncType::CUT )
3997 pTopView->DeleteSelected();
3998 else if ( pTopView->PostKeyEvent( rKEvt ) )
3999 bUsed = true;
4000 }
4001 }
4002
4003 // AutoInput:
4004 if ( bUsed && SC_MOD()->GetAppOptions().GetAutoComplete() )
4005 {
4006 bUseTab = false;
4007 if (pFormulaData)
4008 miAutoPosFormula = pFormulaData->end(); // do not search further
4009 if (pColumnData)
4010 miAutoPosColumn = pColumnData->end();
4011
4012 KeyFuncType eFunc = rKEvt.GetKeyCode().GetFunction();
4013 if ( nChar && nChar != 8 && nChar != 127 && // no 'backspace', no 'delete'
4014 KeyFuncType::CUT != eFunc) // and no 'CTRL-X'
4015 {
4016 if (bFormulaMode)
4017 UseFormulaData();
4018 else
4019 UseColData();
4020 }
4021 }
4022
4023 // When the selection is changed manually or an opening parenthesis
4024 // is typed, stop overwriting parentheses
4025 if ( bUsed && nChar == '(' )
4026 ResetAutoPar();
4027
4028 if ( KEY_INSERT == nCode )
4029 {
4030 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
4031 if (pViewFrm)
4032 pViewFrm->GetBindings().Invalidate( SID_ATTR_INSERT );
4033 }
4034 if( bUsed && bFormulaMode && ( bCursorKey || bInsKey || nCode == KEY_DELETE || nCode == KEY_BACKSPACE ) )
4035 {
4036 ShowTipCursor();
4037 }
4038 if( bUsed && bFormulaMode && nCode == KEY_BACKSPACE )
4039 {
4040 UseFormulaData();
4041 }
4042
4043 }
4044
4045 // #i114511# don't count cursor keys as modification
4046 bool bSetModified = !bCursorKey;
4047 DataChanged(false, bSetModified); // also calls UpdateParenthesis()
4048
4049 // In the LOK case, we want to set the document modified state
4050 // right away at the start of the edit, so that the content is
4051 // saved even when the user leaves the document before hitting
4052 // Enter
4053 if (comphelper::LibreOfficeKit::isActive() && bSetModified && pActiveViewSh && !pActiveViewSh->GetViewData().GetDocShell()->IsModified())
4054 pActiveViewSh->GetViewData().GetDocShell()->SetModified();
4055
4056 InvalidateAttribs(); //! in DataChanged?
4057 }
4058 }
4059
4060 if (pTopView && eMode != SC_INPUT_NONE)
4061 SyncViews();
4062
4063 return bUsed;
4064 }
4065
4066 OUString ScInputHandler::GetSurroundingText()
4067 {
4068 if (eMode != SC_INPUT_NONE)
4069 {
4070 UpdateActiveView();
4071 if (pTableView || pTopView)
4072 {
4073 if (pTableView)
4074 return pTableView->GetSurroundingText();
4075 else if (pTopView) // call only once
4076 return pTopView->GetSurroundingText();
4077 }
4078 }
4079 return OUString();
4080 }
4081
4082 Selection ScInputHandler::GetSurroundingTextSelection()
4083 {
4084 if (eMode != SC_INPUT_NONE)
4085 {
4086 UpdateActiveView();
4087 if (pTableView || pTopView)
4088 {
4089 if (pTableView)
4090 return pTableView->GetSurroundingTextSelection();
4091 else if (pTopView) // call only once
4092 return pTopView->GetSurroundingTextSelection();
4093 }
4094 }
4095 return Selection(0, 0);
4096 }
4097
4098 bool ScInputHandler::DeleteSurroundingText(const Selection& rSelection)
4099 {
4100 if (eMode != SC_INPUT_NONE)
4101 {
4102 UpdateActiveView();
4103 if (pTableView || pTopView)
4104 {
4105 if (pTableView)
4106 return pTableView->DeleteSurroundingText(rSelection);
4107 else if (pTopView) // call only once
4108 return pTopView->DeleteSurroundingText(rSelection);
4109 }
4110 }
4111 return false;
4112 }
4113
4114 void ScInputHandler::InputCommand( const CommandEvent& rCEvt )
4115 {
4116 if ( rCEvt.GetCommand() == CommandEventId::CursorPos )
4117 {
4118 // For CommandEventId::CursorPos, do as little as possible, because
4119 // with remote VCL, even a ShowCursor will generate another event.
4120 if ( eMode != SC_INPUT_NONE )
4121 {
4122 UpdateActiveView();
4123 if (pTableView || pTopView)
4124 {
4125 if (pTableView)
4126 pTableView->Command( rCEvt );
4127 else if (pTopView) // call only once
4128 pTopView->Command( rCEvt );
4129 }
4130 }
4131 }
4132 else if ( rCEvt.GetCommand() == CommandEventId::QueryCharPosition )
4133 {
4134 if ( eMode != SC_INPUT_NONE )
4135 {
4136 UpdateActiveView();
4137 if (pTableView || pTopView)
4138 {
4139 if (pTableView)
4140 pTableView->Command( rCEvt );
4141 else if (pTopView) // call only once
4142 pTopView->Command( rCEvt );
4143 }
4144 }
4145 }
4146 else
4147 {
4148 HideTip();
4149 HideTipBelow();
4150
4151 if ( bSelIsRef )
4152 {
4153 RemoveSelection();
4154 bSelIsRef = false;
4155 }
4156
4157 UpdateActiveView();
4158 bool bNewView = DataChanging( 0, true );
4159
4160 if (!bProtected) // changes allowed
4161 {
4162 if (bNewView) // create new edit view
4163 {
4164 if (pActiveViewSh)
4165 pActiveViewSh->GetViewData().GetDocShell()->PostEditView( mpEditEngine.get(), aCursorPos );
4166 UpdateActiveView();
4167 if (eMode==SC_INPUT_NONE)
4168 if (pTableView || pTopView)
4169 {
4170 if (pTableView)
4171 {
4172 pTableView->GetEditEngine()->SetText( "" );
4173 pTableView->SetSelection( ESelection(0,0, 0,0) );
4174 }
4175 if (pTopView)
4176 {
4177 pTopView->GetEditEngine()->SetText( "" );
4178 pTopView->SetSelection( ESelection(0,0, 0,0) );
4179 }
4180 }
4181 SyncViews();
4182 }
4183
4184 if (pTableView || pTopView)
4185 {
4186 if (pTableView)
4187 pTableView->Command( rCEvt );
4188 if (pTopView)
4189 pTopView->Command( rCEvt );
4190
4191 if ( rCEvt.GetCommand() == CommandEventId::EndExtTextInput )
4192 {
4193 // AutoInput after ext text input
4194
4195 if (pFormulaData)
4196 miAutoPosFormula = pFormulaData->end();
4197 if (pColumnData)
4198 miAutoPosColumn = pColumnData->end();
4199
4200 if (bFormulaMode)
4201 UseFormulaData();
4202 else
4203 UseColData();
4204 }
4205 }
4206
4207 DataChanged(); // calls UpdateParenthesis()
4208 InvalidateAttribs(); //! in DataChanged ?
4209 }
4210
4211 if (pTopView && eMode != SC_INPUT_NONE)
4212 SyncViews();
4213 }
4214 }
4215
4216 void ScInputHandler::NotifyChange( const ScInputHdlState* pState,
4217 bool bForce, ScTabViewShell* pSourceSh,
4218 bool bStopEditing)
4219 {
4220 // If the call originates from a macro call in the EnterHandler,
4221 // return immediately and don't mess up the status
4222 if (bInEnterHandler)
4223 return;
4224
4225 bool bRepeat = (pState == pLastState.get());
4226 if (!bRepeat && pState && pLastState)
4227 bRepeat = (*pState == *pLastState);
4228 if (bRepeat && !bForce)
4229 return;
4230
4231 bInOwnChange = true; // disable ModifyHdl (reset below)
4232
4233 if ( pState && !pLastState ) // Enable again
4234 bForce = true;
4235
4236 bool bHadObject = pLastState && pLastState->GetEditData();
4237
4238 //! Before EditEngine gets eventually created (so it gets the right pools)
4239 if ( pSourceSh )
4240 pActiveViewSh = pSourceSh;
4241 else
4242 pActiveViewSh = dynamic_cast<ScTabViewShell*>( SfxViewShell::Current() );
4243
4244 ImplCreateEditEngine();
4245
4246 if ( pState != pLastState.get() )
4247 {
4248 pLastState.reset( pState ? new ScInputHdlState( *pState ) : nullptr);
4249 }
4250
4251 if ( pState && pActiveViewSh )
4252 {
4253 ScModule* pScMod = SC_MOD();
4254
4255 ScTabViewShell* pScTabViewShell = dynamic_cast<ScTabViewShell*>(pScMod->GetViewShell());
4256
4257 // Also take foreign reference input into account here (e.g. FunctionsAutoPilot),
4258 // FormEditData, if we're switching from Help to Calc:
4259 if ( !bFormulaMode && !pScMod->IsFormulaMode() &&
4260 ( !pScTabViewShell || !pScTabViewShell->GetFormEditData() ) )
4261 {
4262 bool bIgnore = false;
4263 if ( bModified )
4264 {
4265 if (pState->GetPos() != aCursorPos)
4266 {
4267 if (!bProtected)
4268 EnterHandler();
4269 }
4270 else
4271 bIgnore = true;
4272 }
4273
4274 if ( !bIgnore )
4275 {
4276 const ScAddress& rSPos = pState->GetStartPos();
4277 const ScAddress& rEPos = pState->GetEndPos();
4278 const EditTextObject* pData = pState->GetEditData();
4279 OUString aString = pState->GetString();
4280 bool bTxtMod = false;
4281 ScDocShell* pDocSh = pActiveViewSh->GetViewData().GetDocShell();
4282 ScDocument& rDoc = pDocSh->GetDocument();
4283
4284 aCursorPos = pState->GetPos();
4285
4286 if ( pData )
4287 bTxtMod = true;
4288 else if ( bHadObject )
4289 bTxtMod = true;
4290 else if ( bTextValid )
4291 bTxtMod = ( aString != aCurrentText );
4292 else
4293 bTxtMod = ( aString != GetEditText(mpEditEngine.get()) );
4294
4295 if ( bTxtMod || bForce )
4296 {
4297 if (pData)
4298 {
4299 mpEditEngine->SetTextCurrentDefaults( *pData );
4300 if (pInputWin)
4301 aString = ScEditUtil::GetMultilineString(*mpEditEngine);
4302 else
4303 aString = GetEditText(mpEditEngine.get());
4304 lcl_RemoveTabs(aString);
4305 bTextValid = false;
4306 aCurrentText.clear();
4307 }
4308 else
4309 {
4310 aCurrentText = aString;
4311 bTextValid = true; //! To begin with remember as a string
4312 }
4313
4314 const bool bUpdateKit = comphelper::LibreOfficeKit::isActive() && pActiveViewSh;
4315
4316 if (pInputWin)
4317 {
4318 // If we will end up updating LoKit after this, we can skip it here
4319 pInputWin->SetTextString(aString, !bUpdateKit);
4320 }
4321
4322 if (bUpdateKit)
4323 {
4324 UpdateActiveView();
4325 EditView* pActiveView = pTopView ? pTopView : pTableView;
4326 ESelection aSel = pActiveView ? pActiveView->GetSelection() : ESelection();
4327
4328 // if we switched content completely - don't send huge numbers
4329 if (aSel.nStartPara == EE_PARA_NOT_FOUND)
4330 aSel.nStartPara = 0;
4331
4332 if (aSel.nEndPara == EE_PARA_NOT_FOUND)
4333 aSel.nEndPara = 0;
4334
4335 pActiveViewSh->LOKSendFormulabarUpdate(pActiveView, aString, aSel);
4336 // TODO: deprecated?
4337 pActiveViewSh->libreOfficeKitViewCallback(LOK_CALLBACK_CELL_FORMULA, aString.toUtf8().getStr());
4338 }
4339 }
4340
4341 if ( pInputWin || comphelper::LibreOfficeKit::isActive()) // Named range input
4342 {
4343 OUString aPosStr;
4344 bool bSheetLocal = false;
4345 const ScAddress::Details aAddrDetails( rDoc, aCursorPos );
4346
4347 // Is the range a name?
4348 //! Find by Timer?
4349 if ( pActiveViewSh )
4350 pActiveViewSh->GetViewData().GetDocument().
4351 GetRangeAtBlock( ScRange( rSPos, rEPos ), aPosStr, &bSheetLocal);
4352
4353 if ( aPosStr.isEmpty() ) // Not a name -> format
4354 {
4355 ScRefFlags nFlags = ScRefFlags::ZERO;
4356 if( aAddrDetails.eConv == formula::FormulaGrammar::CONV_XL_R1C1 )
4357 nFlags |= ScRefFlags::COL_ABS | ScRefFlags::ROW_ABS;
4358 if ( rSPos != rEPos )
4359 {
4360 ScRange r(rSPos, rEPos);
4361 applyStartToEndFlags(nFlags);
4362 aPosStr = r.Format(rDoc, ScRefFlags::VALID | nFlags, aAddrDetails);
4363 }
4364 else
4365 aPosStr = aCursorPos.Format(ScRefFlags::VALID | nFlags, &rDoc, aAddrDetails);
4366 }
4367 else if (bSheetLocal)
4368 {
4369 OUString aName;
4370 if (rDoc.GetName( rSPos.Tab(), aName))
4371 aPosStr = ScPosWnd::createLocalRangeName( aPosStr, aName);
4372 }
4373
4374 if (pInputWin)
4375 {
4376 // Disable the accessible VALUE_CHANGE event
4377 bool bIsSuppressed = pInputWin->IsAccessibilityEventsSuppressed(false);
4378 pInputWin->SetAccessibilityEventsSuppressed(true);
4379 pInputWin->SetPosString(aPosStr);
4380 pInputWin->SetAccessibilityEventsSuppressed(bIsSuppressed);
4381 pInputWin->SetSumAssignMode();
4382 }
4383
4384 if (comphelper::LibreOfficeKit::isActive() && pActiveViewSh)
4385 pActiveViewSh->libreOfficeKitViewCallback(LOK_CALLBACK_CELL_ADDRESS, aPosStr.toUtf8().getStr());
4386 }
4387
4388 if (bStopEditing) {
4389 SfxGetpApp()->Broadcast( SfxHint( SfxHintId::ScKillEditView ) );
4390
4391 // As long as the content is not edited, turn off online spelling.
4392 // Online spelling is turned back on in StartTable, after setting
4393 // the right language from cell attributes.
4394
4395 EEControlBits nCntrl = mpEditEngine->GetControlWord();
4396 if ( nCntrl & EEControlBits::ONLINESPELLING )
4397 mpEditEngine->SetControlWord( nCntrl & ~EEControlBits::ONLINESPELLING );
4398 }
4399
4400 bModified = false;
4401 bSelIsRef = false;
4402 bProtected = false;
4403 bCommandErrorShown = false;
4404 }
4405 }
4406
4407 if ( pInputWin)
4408 {
4409 // Do not enable if RefDialog is open
4410 if(!pScMod->IsFormulaMode()&& !pScMod->IsRefDialogOpen())
4411 {
4412 if ( !pInputWin->IsEnabled())
4413 {
4414 pDelayTimer->Stop();
4415 pInputWin->Enable();
4416 }
4417 }
4418 else if(pScMod->IsRefDialogOpen())
4419 { // Because every document has its own InputWin,
4420 // we should start Timer again, because the input line may
4421 // still be active
4422 if ( !pDelayTimer->IsActive() )
4423 pDelayTimer->Start();
4424 }
4425 }
4426 }
4427 else // !pState || !pActiveViewSh
4428 {
4429 if ( !pDelayTimer->IsActive() )
4430 pDelayTimer->Start();
4431 }
4432
4433 HideTip();
4434 HideTipBelow();
4435 bInOwnChange = false;
4436 }
4437
4438 void ScInputHandler::UpdateCellAdjust( SvxCellHorJustify eJust )
4439 {
4440 eAttrAdjust = eJust;
4441 UpdateAdjust( 0 );
4442 }
4443
4444 void ScInputHandler::ResetDelayTimer()
4445 {
4446 if( pDelayTimer->IsActive() )
4447 {
4448 pDelayTimer->Stop();
4449 if ( pInputWin )
4450 pInputWin->Enable();
4451 }
4452 }
4453
4454 IMPL_LINK_NOARG( ScInputHandler, DelayTimer, Timer*, void )
4455 {
4456 if ( !(nullptr == pLastState || SC_MOD()->IsFormulaMode() || SC_MOD()->IsRefDialogOpen()))
4457 return;
4458
4459 //! New method at ScModule to query if function autopilot is open
4460 SfxViewFrame* pViewFrm = SfxViewFrame::Current();
4461 if ( pViewFrm && pViewFrm->GetChildWindow( SID_OPENDLG_FUNCTION ) )
4462 {
4463 if ( pInputWin)
4464 {
4465 pInputWin->EnableButtons( false );
4466 pInputWin->Disable();
4467 }
4468 }
4469 else if ( !bFormulaMode ) // Keep formula e.g. for help
4470 {
4471 bInOwnChange = true; // disable ModifyHdl (reset below)
4472
4473 pActiveViewSh = nullptr;
4474 mpEditEngine->SetTextCurrentDefaults( OUString() );
4475 if ( pInputWin )
4476 {
4477 pInputWin->SetPosString( OUString() );
4478 pInputWin->SetTextString(OUString(), true);
4479 pInputWin->Disable();
4480 }
4481
4482 bInOwnChange = false;
4483 }
4484 }
4485
4486 void ScInputHandler::InputSelection( const EditView* pView )
4487 {
4488 SyncViews( pView );
4489 ShowTipCursor();
4490 UpdateParenthesis(); // Selection changed -> update parentheses highlighting
4491
4492 // When the selection is changed manually, stop overwriting parentheses
4493 ResetAutoPar();
4494
4495 if (comphelper::LibreOfficeKit::isActive() && pActiveViewSh)
4496 {
4497 EditView* pActiveView = pTopView ? pTopView : pTableView;
4498 ESelection aSel = pActiveView ? pActiveView->GetSelection() : ESelection();
4499 pActiveViewSh->LOKSendFormulabarUpdate(pActiveView, GetEditString(), aSel);
4500 }
4501 }
4502
4503 void ScInputHandler::InputChanged( const EditView* pView, bool bFromNotify )
4504 {
4505 if ( !pView )
4506 return;
4507
4508 UpdateActiveView();
4509
4510 // #i20282# DataChanged needs to know if this is from the input line's modify handler
4511 bool bFromTopNotify = ( bFromNotify && pView == pTopView );
4512
4513 bool bNewView = DataChanging(); //FIXME: Is this at all possible?
4514 aCurrentText = pView->GetEditEngine()->GetText(); // Also remember the string
4515 mpEditEngine->SetTextCurrentDefaults( aCurrentText );
4516 DataChanged( bFromTopNotify );
4517 bTextValid = true; // Is set to false in DataChanged
4518
4519 if ( pActiveViewSh )
4520 {
4521 ScViewData& rViewData = pActiveViewSh->GetViewData();
4522 if ( bNewView )
4523 rViewData.GetDocShell()->PostEditView( mpEditEngine.get(), aCursorPos );
4524
4525 rViewData.EditGrowY();
4526 rViewData.EditGrowX();
4527 }
4528
4529 SyncViews( pView );
4530 }
4531
4532 const OUString& ScInputHandler::GetEditString()
4533 {
4534 if (mpEditEngine)
4535 {
4536 aCurrentText = mpEditEngine->GetText(); // Always new from Engine
4537 bTextValid = true;
4538 }
4539
4540 return aCurrentText;
4541 }
4542
4543 Size ScInputHandler::GetTextSize()
4544 {
4545 Size aSize;
4546 if ( mpEditEngine )
4547 aSize = Size( mpEditEngine->CalcTextWidth(), mpEditEngine->GetTextHeight() );
4548
4549 return aSize;
4550 }
4551
4552 bool ScInputHandler::GetTextAndFields( ScEditEngineDefaulter& rDestEngine )
4553 {
4554 bool bRet = false;
4555 if (mpEditEngine)
4556 {
4557 // Contains field?
4558 sal_Int32 nParCnt = mpEditEngine->GetParagraphCount();
4559 SfxItemSet aSet = mpEditEngine->GetAttribs( ESelection(0,0,nParCnt,0) );
4560 SfxItemState eFieldState = aSet.GetItemState( EE_FEATURE_FIELD, false );
4561 if ( eFieldState == SfxItemState::DONTCARE || eFieldState == SfxItemState::SET )
4562 {
4563 // Copy content
4564 std::unique_ptr<EditTextObject> pObj = mpEditEngine->CreateTextObject();
4565 rDestEngine.SetTextCurrentDefaults(*pObj);
4566 pObj.reset();
4567
4568 // Delete attributes
4569 for (sal_Int32 i=0; i<nParCnt; i++)
4570 rDestEngine.RemoveCharAttribs( i );
4571
4572 // Combine paragraphs
4573 while ( nParCnt > 1 )
4574 {
4575 sal_Int32 nLen = rDestEngine.GetTextLen( 0 );
4576 ESelection aSel( 0,nLen, 1,0 );
4577 rDestEngine.QuickInsertText( OUString(' '), aSel ); // Replace line break with space
4578 --nParCnt;
4579 }
4580
4581 bRet = true;
4582 }
4583 }
4584 return bRet;
4585 }
4586
4587 /**
4588 * Methods for FunctionAutoPilot:
4589 * InputGetSelection, InputSetSelection, InputReplaceSelection, InputGetFormulaStr
4590 */
4591 void ScInputHandler::InputGetSelection( sal_Int32& rStart, sal_Int32& rEnd )
4592 {
4593 rStart = nFormSelStart;
4594 rEnd = nFormSelEnd;
4595 }
4596
4597 EditView* ScInputHandler::GetFuncEditView()
4598 {
4599 UpdateActiveView(); // Due to pTableView
4600
4601 EditView* pView = nullptr;
4602 if ( pInputWin )
4603 {
4604 pInputWin->MakeDialogEditView();
4605 pView = pInputWin->GetEditView();
4606 }
4607 else
4608 {
4609 if ( eMode != SC_INPUT_TABLE )
4610 {
4611 bCreatingFuncView = true; // Don't display RangeFinder
4612 SetMode( SC_INPUT_TABLE );
4613 bCreatingFuncView = false;
4614 if ( pTableView )
4615 pTableView->GetEditEngine()->SetText( OUString() );
4616 }
4617 pView = pTableView;
4618 }
4619
4620 return pView;
4621 }
4622
4623 void ScInputHandler::InputSetSelection( sal_Int32 nStart, sal_Int32 nEnd )
4624 {
4625 if ( nStart <= nEnd )
4626 {
4627 nFormSelStart = nStart;
4628 nFormSelEnd = nEnd;
4629 }
4630 else
4631 {
4632 nFormSelEnd = nStart;
4633 nFormSelStart = nEnd;
4634 }
4635
4636 EditView* pView = GetFuncEditView();
4637 if (pView)
4638 pView->SetSelection( ESelection(0,nStart, 0,nEnd) );
4639
4640 bModified = true;
4641 }
4642
4643 void ScInputHandler::InputReplaceSelection( std::u16string_view aStr )
4644 {
4645 if (!pRefViewSh)
4646 pRefViewSh = pActiveViewSh;
4647
4648 OSL_ENSURE(nFormSelEnd>=nFormSelStart,"Selection broken...");
4649
4650 sal_Int32 nOldLen = nFormSelEnd - nFormSelStart;
4651 sal_Int32 nNewLen = aStr.size();
4652
4653 OUStringBuffer aBuf(aFormText);
4654 if (nOldLen)
4655 aBuf.remove(nFormSelStart, nOldLen);
4656 if (nNewLen)
4657 aBuf.insert(nFormSelStart, aStr);
4658
4659 aFormText = aBuf.makeStringAndClear();
4660
4661 nFormSelEnd = nFormSelStart + nNewLen;
4662
4663 EditView* pView = GetFuncEditView();
4664 if (pView)
4665 {
4666 pView->SetEditEngineUpdateLayout( false );
4667 pView->GetEditEngine()->SetText( aFormText );
4668 pView->SetSelection( ESelection(0,nFormSelStart, 0,nFormSelEnd) );
4669 pView->SetEditEngineUpdateLayout( true );
4670 }
4671 bModified = true;
4672 }
4673
4674 void ScInputHandler::InputTurnOffWinEngine()
4675 {
4676 bInOwnChange = true; // disable ModifyHdl (reset below)
4677
4678 eMode = SC_INPUT_NONE;
4679 /* TODO: it would be better if there was some way to reset the input bar
4680 * engine instead of deleting and having it recreate through
4681 * GetFuncEditView(), but first least invasively let this fix fdo#71667 and
4682 * fdo#72278 without reintroducing fdo#69971. */
4683 StopInputWinEngine(true);
4684
4685 bInOwnChange = false;
4686 }
4687
4688 /**
4689 * ScInputHdlState
4690 */
4691 ScInputHdlState::ScInputHdlState( const ScAddress& rCurPos,
4692 const ScAddress& rStartPos,
4693 const ScAddress& rEndPos,
4694 OUString _aString,
4695 const EditTextObject* pData )
4696 : aCursorPos ( rCurPos ),
4697 aStartPos ( rStartPos ),
4698 aEndPos ( rEndPos ),
4699 aString (std::move( _aString )),
4700 pEditData ( pData ? pData->Clone() : nullptr )
4701 {
4702 }
4703
4704 ScInputHdlState::ScInputHdlState( const ScInputHdlState& rCpy )
4705 {
4706 *this = rCpy;
4707 }
4708
4709 ScInputHdlState::~ScInputHdlState()
4710 {
4711 }
4712
4713 bool ScInputHdlState::operator==( const ScInputHdlState& r ) const
4714 {
4715 return ( (aStartPos == r.aStartPos)
4716 && (aEndPos == r.aEndPos)
4717 && (aCursorPos == r.aCursorPos)
4718 && (aString == r.aString)
4719 && ScGlobal::EETextObjEqual( pEditData.get(), r.pEditData.get() ) );
4720 }
4721
4722 ScInputHdlState& ScInputHdlState::operator=( const ScInputHdlState& r )
4723 {
4724 if (this != &r)
4725 {
4726 aCursorPos = r.aCursorPos;
4727 aStartPos = r.aStartPos;
4728 aEndPos = r.aEndPos;
4729 aString = r.aString;
4730 pEditData.reset();
4731 if (r.pEditData)
4732 pEditData = r.pEditData->Clone();
4733 }
4734 return *this;
4735 }
4736
4737 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
FREE OFFICE SUITE