LibreOffice Module sc (master)  1
viewfun4.cxx
Go to the documentation of this file.
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 <config_features.h>
21 
22 #include <memory>
23 #include <editeng/eeitem.hxx>
24 
25 #include <editeng/editobj.hxx>
26 #include <editeng/editstat.hxx>
27 #include <editeng/editview.hxx>
28 #include <editeng/flditem.hxx>
29 #include <sot/storage.hxx>
30 #include <svx/hlnkitem.hxx>
31 #include <editeng/unolingu.hxx>
32 
33 #include <sfx2/bindings.hxx>
34 #include <sfx2/dispatch.hxx>
35 #include <sfx2/docfile.hxx>
36 #include <sfx2/docfilt.hxx>
37 #include <sfx2/fcontnr.hxx>
38 #include <svtools/langtab.hxx>
39 #include <vcl/graphicfilter.hxx>
40 #include <svl/stritem.hxx>
41 #include <vcl/transfer.hxx>
42 #include <svl/urlbmk.hxx>
43 #include <svl/sharedstringpool.hxx>
44 #include <vcl/svapp.hxx>
45 #include <vcl/weld.hxx>
46 #include <avmedia/mediawindow.hxx>
47 
49 
50 #include <viewfunc.hxx>
51 #include <docsh.hxx>
52 #include <document.hxx>
53 #include <globstr.hrc>
54 #include <global.hxx>
55 #include <scresid.hxx>
56 #include <undoblk.hxx>
57 #include <undocell.hxx>
58 #include <formulacell.hxx>
59 #include <scmod.hxx>
60 #include <spelleng.hxx>
61 #include <patattr.hxx>
62 #include <sc.hrc>
63 #include <tabvwsh.hxx>
64 #include <impex.hxx>
65 #include <editutil.hxx>
66 #include <editable.hxx>
67 #include <dociter.hxx>
68 #include <reffind.hxx>
69 #include <compiler.hxx>
70 #include <tokenarray.hxx>
71 #include <refupdatecontext.hxx>
72 #include <gridwin.hxx>
73 #include <refundo.hxx>
74 
75 using namespace com::sun::star;
76 
77 void ScViewFunc::PasteRTF( SCCOL nStartCol, SCROW nStartRow,
78  const css::uno::Reference< css::datatransfer::XTransferable >& rxTransferable )
79 {
80  TransferableDataHelper aDataHelper( rxTransferable );
81  if ( aDataHelper.HasFormat( SotClipboardFormatId::EDITENGINE_ODF_TEXT_FLAT ) )
82  {
83  HideAllCursors();
84 
85  ScDocShell* pDocSh = GetViewData().GetDocShell();
86  ScDocument& rDoc = pDocSh->GetDocument();
87  SCTAB nTab = GetViewData().GetTabNo();
88  const bool bRecord (rDoc.IsUndoEnabled());
89 
90  const ScPatternAttr* pPattern = rDoc.GetPattern( nStartCol, nStartRow, nTab );
91  std::unique_ptr<ScTabEditEngine> pEngine(new ScTabEditEngine( *pPattern, rDoc.GetEnginePool(), &rDoc ));
92  pEngine->EnableUndo( false );
93 
94  vcl::Window* pActWin = GetActiveWin();
95  if (pActWin)
96  {
97  pEngine->SetPaperSize(Size(100000,100000));
99  EditView aEditView( pEngine.get(), aWin.get() );
100  aEditView.SetOutputArea(tools::Rectangle(0,0,100000,100000));
101 
102  // same method now for clipboard or drag&drop
103  // mba: clipboard always must contain absolute URLs (could be from alien source)
104  aEditView.InsertText( rxTransferable, OUString(), true );
105  }
106 
107  sal_Int32 nParCnt = pEngine->GetParagraphCount();
108  if (nParCnt)
109  {
110  SCROW nEndRow = nStartRow + static_cast<SCROW>(nParCnt) - 1;
111  if (nEndRow > rDoc.MaxRow())
112  nEndRow = rDoc.MaxRow();
113 
114  ScDocumentUniquePtr pUndoDoc;
115  if (bRecord)
116  {
117  pUndoDoc.reset(new ScDocument( SCDOCMODE_UNDO ));
118  pUndoDoc->InitUndo( rDoc, nTab, nTab );
119  rDoc.CopyToDocument( nStartCol,nStartRow,nTab, nStartCol,nEndRow,nTab, InsertDeleteFlags::ALL, false, *pUndoDoc );
120  }
121 
122  SCROW nRow = nStartRow;
123 
124  // Temporarily turn off undo generation for this lot
125  bool bUndoEnabled = rDoc.IsUndoEnabled();
126  rDoc.EnableUndo( false );
127  for( sal_Int32 n = 0; n < nParCnt; n++ )
128  {
129  std::unique_ptr<EditTextObject> pObject(pEngine->CreateTextObject(n));
130  EnterData(nStartCol, nRow, nTab, *pObject, true);
131  if( ++nRow > rDoc.MaxRow() )
132  break;
133  }
134  rDoc.EnableUndo(bUndoEnabled);
135 
136  if (bRecord)
137  {
139  pRedoDoc->InitUndo( rDoc, nTab, nTab );
140  rDoc.CopyToDocument( nStartCol,nStartRow,nTab, nStartCol,nEndRow,nTab, InsertDeleteFlags::ALL|InsertDeleteFlags::NOCAPTIONS, false, *pRedoDoc );
141 
142  ScRange aMarkRange(nStartCol, nStartRow, nTab, nStartCol, nEndRow, nTab);
143  ScMarkData aDestMark(rDoc.GetSheetLimits());
144  aDestMark.SetMarkArea( aMarkRange );
145  pDocSh->GetUndoManager()->AddUndoAction(
146  std::make_unique<ScUndoPaste>( pDocSh, aMarkRange, aDestMark,
147  std::move(pUndoDoc), std::move(pRedoDoc), InsertDeleteFlags::ALL, nullptr));
148  }
149  }
150 
151  pEngine.reset();
152 
153  ShowAllCursors();
154  }
155  else
156  {
157  HideAllCursors();
158  ScDocShell* pDocSh = GetViewData().GetDocShell();
159  ScImportExport aImpEx( pDocSh->GetDocument(),
160  ScAddress( nStartCol, nStartRow, GetViewData().GetTabNo() ) );
161 
162  OUString aStr;
164  if ( aDataHelper.GetSotStorageStream( SotClipboardFormatId::RTF, xStream ) && xStream.is() )
165  // mba: clipboard always must contain absolute URLs (could be from alien source)
166  aImpEx.ImportStream( *xStream, OUString(), SotClipboardFormatId::RTF );
167  else if ( aDataHelper.GetString( SotClipboardFormatId::RTF, aStr ) )
168  aImpEx.ImportString( aStr, SotClipboardFormatId::RTF );
169  else if ( aDataHelper.GetSotStorageStream( SotClipboardFormatId::RICHTEXT, xStream ) && xStream.is() )
170  aImpEx.ImportStream( *xStream, OUString(), SotClipboardFormatId::RICHTEXT );
171  else if ( aDataHelper.GetString( SotClipboardFormatId::RICHTEXT, aStr ) )
172  aImpEx.ImportString( aStr, SotClipboardFormatId::RICHTEXT );
173 
174  AdjustRowHeight( nStartRow, aImpEx.GetRange().aEnd.Row() );
175  pDocSh->UpdateOle(GetViewData());
176  ShowAllCursors();
177  }
178 }
180 {
181  ScDocument& rDoc = GetViewData().GetDocument();
182  ScMarkData& rMark = GetViewData().GetMarkData();
183  SCTAB nTabCount = rDoc.GetTableCount();
184  bool bRecord = true;
185  if (!rDoc.IsUndoEnabled())
186  bRecord = false;
187 
188  ScRange aMarkRange;
189  rMark.MarkToSimple();
190  bool bMulti = rMark.IsMultiMarked();
191  if (bMulti)
192  rMark.GetMultiMarkArea( aMarkRange );
193  else if (rMark.IsMarked())
194  rMark.GetMarkArea( aMarkRange );
195  else
196  {
197  aMarkRange = ScRange( GetViewData().GetCurX(),
198  GetViewData().GetCurY(), GetViewData().GetTabNo() );
199  }
200  ScEditableTester aTester( rDoc, aMarkRange.aStart.Col(), aMarkRange.aStart.Row(),
201  aMarkRange.aEnd.Col(), aMarkRange.aEnd.Row(),rMark );
202  if (!aTester.IsEditable())
203  {
204  ErrorMessage(aTester.GetMessageId());
205  return;
206  }
207 
208  ScDocShell* pDocSh = GetViewData().GetDocShell();
209  bool bOk = false;
210 
211  ScDocumentUniquePtr pUndoDoc;
212  if (bRecord)
213  {
214  pUndoDoc.reset( new ScDocument( SCDOCMODE_UNDO ) );
215  SCTAB nTab = aMarkRange.aStart.Tab();
216  pUndoDoc->InitUndo( rDoc, nTab, nTab );
217 
218  if ( rMark.GetSelectCount() > 1 )
219  {
220  for (const auto& rTab : rMark)
221  if ( rTab != nTab )
222  pUndoDoc->AddUndoTab( rTab, rTab );
223  }
224  ScRange aCopyRange = aMarkRange;
225  aCopyRange.aStart.SetTab(0);
226  aCopyRange.aEnd.SetTab(nTabCount-1);
227  rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ALL, bMulti, *pUndoDoc, &rMark );
228  }
229 
230  ScRangeListRef xRanges;
231  GetViewData().GetMultiArea( xRanges );
232  size_t nCount = xRanges->size();
233 
234  for (const SCTAB& i : rMark)
235  {
236  for (size_t j = 0; j < nCount; ++j)
237  {
238  ScRange aRange = (*xRanges)[j];
239  aRange.aStart.SetTab(i);
240  aRange.aEnd.SetTab(i);
241  ScCellIterator aIter( rDoc, aRange );
242  for (bool bHas = aIter.first(); bHas; bHas = aIter.next())
243  {
244  if (aIter.getType() != CELLTYPE_FORMULA)
245  continue;
246 
247  ScFormulaCell* pCell = aIter.getFormulaCell();
248  ScMatrixMode eMatrixMode = pCell->GetMatrixFlag();
249  if (eMatrixMode == ScMatrixMode::Reference)
250  continue;
251 
252  OUString aOld;
253  pCell->GetFormula(aOld);
254  sal_Int32 nLen = aOld.getLength();
255  if (eMatrixMode == ScMatrixMode::Formula)
256  {
257  assert(nLen >= 2 && aOld[0] == '{' && aOld[nLen-1] == '}');
258  nLen -= 2;
259  aOld = aOld.copy( 1, nLen);
260  }
261  ScRefFinder aFinder( aOld, aIter.GetPos(), rDoc, rDoc.GetAddressConvention() );
262  aFinder.ToggleRel( 0, nLen );
263  if (aFinder.GetFound())
264  {
265  ScAddress aPos = pCell->aPos;
266  const OUString& aNew = aFinder.GetText();
267  ScCompiler aComp( rDoc, aPos, rDoc.GetGrammar());
268  std::unique_ptr<ScTokenArray> pArr(aComp.CompileString(aNew));
269  ScFormulaCell* pNewCell =
270  new ScFormulaCell(
271  rDoc, aPos, *pArr, formula::FormulaGrammar::GRAM_DEFAULT, eMatrixMode);
272 
273  rDoc.SetFormulaCell(aPos, pNewCell);
274  bOk = true;
275  }
276  }
277  }
278  }
279  if (bRecord)
280  {
282  SCTAB nTab = aMarkRange.aStart.Tab();
283  pRedoDoc->InitUndo( rDoc, nTab, nTab );
284 
285  if ( rMark.GetSelectCount() > 1 )
286  {
287  for (const auto& rTab : rMark)
288  if ( rTab != nTab )
289  pRedoDoc->AddUndoTab( rTab, rTab );
290  }
291  ScRange aCopyRange = aMarkRange;
292  aCopyRange.aStart.SetTab(0);
293  aCopyRange.aEnd.SetTab(nTabCount-1);
294  rDoc.CopyToDocument( aCopyRange, InsertDeleteFlags::ALL, bMulti, *pRedoDoc, &rMark );
295 
296  pDocSh->GetUndoManager()->AddUndoAction(
297  std::make_unique<ScUndoRefConversion>( pDocSh,
298  aMarkRange, rMark, std::move(pUndoDoc), std::move(pRedoDoc), bMulti) );
299  }
300 
301  pDocSh->PostPaint( aMarkRange, PaintPartFlags::Grid );
302  pDocSh->UpdateOle(GetViewData());
303  pDocSh->SetDocumentModified();
304  CellContentChanged();
305 
306  if (!bOk)
307  ErrorMessage(STR_ERR_NOREF);
308 }
309 // Thesaurus - Undo ok
311 {
312  SCCOL nCol;
313  SCROW nRow;
314  SCTAB nTab;
315  ScDocShell* pDocSh = GetViewData().GetDocShell();
316  ScDocument& rDoc = pDocSh->GetDocument();
317  ScMarkData& rMark = GetViewData().GetMarkData();
318  ScSplitPos eWhich = GetViewData().GetActivePart();
319  EESpellState eState;
320  EditView* pEditView = nullptr;
321  std::unique_ptr<ESelection> pEditSel;
322  std::unique_ptr<ScEditEngineDefaulter> pThesaurusEngine;
323  bool bIsEditMode = GetViewData().HasEditView(eWhich);
324  bool bRecord = true;
325  if (!rDoc.IsUndoEnabled())
326  bRecord = false;
327  if (bIsEditMode) // edit mode active
328  {
329  GetViewData().GetEditView(eWhich, pEditView, nCol, nRow);
330  pEditSel.reset(new ESelection(pEditView->GetSelection()));
331  SC_MOD()->InputEnterHandler();
332  GetViewData().GetBindings().Update(); // otherwise the Sfx becomes mixed-up...
333  }
334  else
335  {
336  nCol = GetViewData().GetCurX();
337  nRow = GetViewData().GetCurY();
338  }
339  nTab = GetViewData().GetTabNo();
340 
341  ScAddress aPos(nCol, nRow, nTab);
342  ScEditableTester aTester( rDoc, nCol, nRow, nCol, nRow, rMark );
343  if (!aTester.IsEditable())
344  {
345  ErrorMessage(aTester.GetMessageId());
346  return;
347  }
348 
349  ScCellValue aOldText;
350  aOldText.assign(rDoc, aPos);
351  if (aOldText.meType != CELLTYPE_STRING && aOldText.meType != CELLTYPE_EDIT)
352  {
353  ErrorMessage(STR_THESAURUS_NO_STRING);
354  return;
355  }
356 
357  uno::Reference<linguistic2::XSpellChecker1> xSpeller = LinguMgr::GetSpellChecker();
358 
359  pThesaurusEngine.reset(new ScEditEngineDefaulter(rDoc.GetEnginePool()));
360  pThesaurusEngine->SetEditTextObjectPool( rDoc.GetEditPool() );
361  pThesaurusEngine->SetRefDevice(GetViewData().GetActiveWin());
362  pThesaurusEngine->SetSpeller(xSpeller);
363  MakeEditView(pThesaurusEngine.get(), nCol, nRow );
364  std::unique_ptr<SfxItemSet> pEditDefaults(
365  new SfxItemSet(pThesaurusEngine->GetEmptyItemSet()));
366  const ScPatternAttr* pPattern = rDoc.GetPattern(nCol, nRow, nTab);
367  if (pPattern)
368  {
369  pPattern->FillEditItemSet( pEditDefaults.get() );
370  pThesaurusEngine->SetDefaults( *pEditDefaults );
371  }
372 
373  if (aOldText.meType == CELLTYPE_EDIT)
374  pThesaurusEngine->SetTextCurrentDefaults(*aOldText.mpEditText);
375  else
376  pThesaurusEngine->SetTextCurrentDefaults(aOldText.getString(rDoc));
377 
378  pEditView = GetViewData().GetEditView(GetViewData().GetActivePart());
379  if (pEditSel)
380  pEditView->SetSelection(*pEditSel);
381  else
382  pEditView->SetSelection(ESelection(0,0,0,0));
383 
384  pThesaurusEngine->ClearModifyFlag();
385 
386  // language is now in EditEngine attributes -> no longer passed to StartThesaurus
387 
388  eState = pEditView->StartThesaurus();
389  OSL_ENSURE(eState != EESpellState::NoSpeller, "No SpellChecker");
390 
391  if (eState == EESpellState::ErrorFound) // should happen later through Wrapper!
392  {
393  LanguageType eLnge = ScViewUtil::GetEffLanguage( rDoc, ScAddress( nCol, nRow, nTab ) );
394  OUString aErr = SvtLanguageTable::GetLanguageString(eLnge) + ScResId( STR_SPELLING_NO_LANG );
395 
396  std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(GetViewData().GetDialogParent(),
397  VclMessageType::Info, VclButtonsType::Ok,
398  aErr));
399  xInfoBox->run();
400  }
401  if (pThesaurusEngine->IsModified())
402  {
403  ScCellValue aNewText;
404 
405  if (aOldText.meType == CELLTYPE_EDIT)
406  {
407  // The cell will own the text object instance.
408  std::unique_ptr<EditTextObject> pText = pThesaurusEngine->CreateTextObject();
409  auto tmp = pText.get();
410  if (rDoc.SetEditText(ScAddress(nCol,nRow,nTab), std::move(pText)))
411  aNewText.set(*tmp);
412  }
413  else
414  {
415  OUString aStr = pThesaurusEngine->GetText();
416  aNewText.set(rDoc.GetSharedStringPool().intern(aStr));
417  rDoc.SetString(nCol, nRow, nTab, aStr);
418  }
419 
420  pDocSh->SetDocumentModified();
421  if (bRecord)
422  {
423  GetViewData().GetDocShell()->GetUndoManager()->AddUndoAction(
424  std::make_unique<ScUndoThesaurus>(
425  GetViewData().GetDocShell(), nCol, nRow, nTab, aOldText, aNewText));
426  }
427  }
428 
429  KillEditView(true);
430  pDocSh->PostPaintGridAll();
431 }
432 
434 {
436  DoSheetConversion( aConvParam );
437 }
438 
440 {
441  SCCOL nCol;
442  SCROW nRow;
443  SCTAB nTab;
444  ScViewData& rViewData = GetViewData();
445  ScDocShell* pDocSh = rViewData.GetDocShell();
446  ScDocument& rDoc = pDocSh->GetDocument();
447  ScMarkData& rMark = rViewData.GetMarkData();
448  ScSplitPos eWhich = rViewData.GetActivePart();
449  EditView* pEditView = nullptr;
450  bool bIsEditMode = rViewData.HasEditView(eWhich);
451  bool bRecord = true;
452  if (!rDoc.IsUndoEnabled())
453  bRecord = false;
454  if (bIsEditMode) // edit mode active
455  {
456  rViewData.GetEditView(eWhich, pEditView, nCol, nRow);
457  SC_MOD()->InputEnterHandler();
458  }
459  else
460  {
461  nCol = rViewData.GetCurX();
462  nRow = rViewData.GetCurY();
463 
464  AlignToCursor( nCol, nRow, SC_FOLLOW_JUMP);
465  }
466  nTab = rViewData.GetTabNo();
467 
468  rMark.MarkToMulti();
469  bool bMarked = rMark.IsMultiMarked();
470  if (bMarked)
471  {
472  ScEditableTester aTester( rDoc, rMark );
473  if (!aTester.IsEditable())
474  {
475  ErrorMessage(aTester.GetMessageId());
476  return;
477  }
478  }
479 
480  ScDocumentUniquePtr pUndoDoc;
481  ScDocumentUniquePtr pRedoDoc;
482  if (bRecord)
483  {
484  pUndoDoc.reset( new ScDocument( SCDOCMODE_UNDO ) );
485  pUndoDoc->InitUndo( rDoc, nTab, nTab );
486  pRedoDoc.reset( new ScDocument( SCDOCMODE_UNDO ) );
487  pRedoDoc->InitUndo( rDoc, nTab, nTab );
488 
489  if ( rMark.GetSelectCount() > 1 )
490  {
491  for (const auto& rTab : rMark)
492  if ( rTab != nTab )
493  {
494  pUndoDoc->AddUndoTab( rTab, rTab );
495  pRedoDoc->AddUndoTab( rTab, rTab );
496  }
497  }
498  }
499 
500  // from here no return
501 
502  bool bOldEnabled = rDoc.IsIdleEnabled();
503  rDoc.EnableIdle(false); // stop online spelling
504 
505  // *** create and init the edit engine *** --------------------------------
506 
507  std::unique_ptr<ScConversionEngineBase> pEngine;
508  switch( rConvParam.GetType() )
509  {
511  pEngine.reset(new ScSpellingEngine(
512  rDoc.GetEnginePool(), rViewData, pUndoDoc.get(), pRedoDoc.get(), LinguMgr::GetSpellChecker() ));
513  break;
516  pEngine.reset(new ScTextConversionEngine(
517  rDoc.GetEnginePool(), rViewData, rConvParam, pUndoDoc.get(), pRedoDoc.get() ));
518  break;
519  default:
520  OSL_FAIL( "ScViewFunc::DoSheetConversion - unknown conversion type" );
521  }
522 
523  MakeEditView( pEngine.get(), nCol, nRow );
524  pEngine->SetRefDevice( rViewData.GetActiveWin() );
525  // simulate dummy cell:
526  pEditView = rViewData.GetEditView( rViewData.GetActivePart() );
527  rViewData.SetSpellingView( pEditView );
528  tools::Rectangle aRect( Point( 0, 0 ), Point( 0, 0 ) );
529  pEditView->SetOutputArea( aRect );
530  pEngine->SetControlWord( EEControlBits::USECHARATTRIBS );
531  pEngine->EnableUndo( false );
532  pEngine->SetPaperSize( aRect.GetSize() );
533  pEngine->SetTextCurrentDefaults( EMPTY_OUSTRING );
534 
535  // *** do the conversion *** ----------------------------------------------
536 
537  pEngine->ClearModifyFlag();
538  pEngine->ConvertAll( *pEditView );
539 
540  // *** undo/redo *** ------------------------------------------------------
541 
542  if( pEngine->IsAnyModified() )
543  {
544  if (bRecord)
545  {
546  SCCOL nNewCol = rViewData.GetCurX();
547  SCROW nNewRow = rViewData.GetCurY();
548  rViewData.GetDocShell()->GetUndoManager()->AddUndoAction(
549  std::make_unique<ScUndoConversion>(
550  pDocSh, rMark,
551  nCol, nRow, nTab, std::move(pUndoDoc),
552  nNewCol, nNewRow, nTab, std::move(pRedoDoc), rConvParam ) );
553  }
554 
556  rDoc.SetAllFormulasDirty(aCxt);
557 
558  pDocSh->SetDocumentModified();
559  }
560  else
561  {
562  pUndoDoc.reset();
563  pRedoDoc.reset();
564  }
565 
566  // *** final cleanup *** --------------------------------------------------
567 
568  rViewData.SetSpellingView( nullptr );
569  KillEditView(true);
570  pEngine.reset();
571  pDocSh->PostPaintGridAll();
572  rViewData.GetViewShell()->UpdateInputHandler();
573  rDoc.EnableIdle(bOldEnabled);
574 }
575 
576 // past from SotClipboardFormatId::FILE items
577 // is not called directly from Drop, but asynchronously -> dialogs are allowed
578 
579 bool ScViewFunc::PasteFile( const Point& rPos, const OUString& rFile, bool bLink )
580 {
582  aURL.SetSmartURL( rFile );
583  OUString aStrURL = aURL.GetMainURL( INetURLObject::DecodeMechanism::NONE );
584 
585  // is it a media URL?
586 #if HAVE_FEATURE_AVMEDIA
587  if( ::avmedia::MediaWindow::isMediaURL( aStrURL, ""/*TODO?*/ ) )
588  {
589  const SfxStringItem aMediaURLItem( SID_INSERT_AVMEDIA, aStrURL );
590  return ( nullptr != GetViewData().GetDispatcher().ExecuteList(
591  SID_INSERT_AVMEDIA, SfxCallMode::SYNCHRON,
592  { &aMediaURLItem }) );
593  }
594 #endif
595 
596  if (!bLink) // for bLink only graphics or URL
597  {
598  // 1. can I open the file?
599  std::shared_ptr<const SfxFilter> pFlt;
600 
601  // search only for its own filters, without selection box (as in ScDocumentLoader)
602  SfxFilterMatcher aMatcher( ScDocShell::Factory().GetFilterContainer()->GetName() );
603  SfxMedium aSfxMedium( aStrURL, (StreamMode::READ | StreamMode::SHARE_DENYNONE) );
604  // #i73992# GuessFilter no longer calls UseInteractionHandler.
605  // This is UI, so it can be called here.
606  aSfxMedium.UseInteractionHandler(true);
607  ErrCode nErr = aMatcher.GuessFilter( aSfxMedium, pFlt );
608 
609  if ( pFlt && !nErr )
610  {
611  // code stolen from the SFX!
612  SfxDispatcher &rDispatcher = GetViewData().GetDispatcher();
613  SfxStringItem aFileNameItem( SID_FILE_NAME, aStrURL );
614  SfxStringItem aFilterItem( SID_FILTER_NAME, pFlt->GetName() );
615  // #i69524# add target, as in SfxApplication when the Open dialog is used
616  SfxStringItem aTargetItem( SID_TARGETNAME, "_default" );
617 
618  // Open Asynchronously, because it can also happen from D&D
619  // and that is not so good for the MAC...
620  return (nullptr != rDispatcher.ExecuteList(SID_OPENDOC,
621  SfxCallMode::ASYNCHRON,
622  { &aFileNameItem, &aFilterItem, &aTargetItem}));
623  }
624  }
625 
626  // 2. can the file be inserted using the graphics filter?
627  // (as a link, since the Gallery provides it in this way)
628 
629  sal_uInt16 nFilterFormat;
630  Graphic aGraphic;
632 
633  if (!rGraphicFilter.ImportGraphic(aGraphic, aURL,
634  GRFILTER_FORMAT_DONTKNOW, &nFilterFormat ))
635  {
636  if ( bLink )
637  {
638  OUString aFltName = rGraphicFilter.GetImportFormatName(nFilterFormat);
639  return PasteGraphic( rPos, aGraphic, aStrURL, aFltName );
640  }
641  else
642  {
643  // #i76709# if bLink isn't set, pass empty URL/filter, so a non-linked image is inserted
644  return PasteGraphic( rPos, aGraphic, EMPTY_OUSTRING, EMPTY_OUSTRING );
645  }
646  }
647 
648  if (bLink) // for bLink everything, which is not graphics, as URL
649  {
650  tools::Rectangle aRect( rPos, Size(0,0) );
651  ScRange aRange = GetViewData().GetDocument().
652  GetRange( GetViewData().GetTabNo(), aRect );
653  SCCOL nPosX = aRange.aStart.Col();
654  SCROW nPosY = aRange.aStart.Row();
655 
656  InsertBookmark( aStrURL, aStrURL, nPosX, nPosY );
657  return true;
658  }
659  else
660  {
661  // 3. can the file be inserted as OLE?
662  // also non-storages, for instance sounds (#38282#)
663  uno::Reference < embed::XStorage > xStorage = comphelper::OStorageHelper::GetTemporaryStorage();
664 
665  //TODO/LATER: what about "bLink"?
666 
667  uno::Sequence < beans::PropertyValue > aMedium(1);
668  aMedium[0].Name = "URL";
669  aMedium[0].Value <<= aStrURL;
670 
671  comphelper::EmbeddedObjectContainer aCnt( xStorage );
672  OUString aName;
673  uno::Reference < embed::XEmbeddedObject > xObj = aCnt.InsertEmbeddedObject( aMedium, aName );
674  if( xObj.is() )
675  return PasteObject( rPos, xObj, nullptr );
676 
677  // If an OLE object can't be created, insert a URL button
678 
679  GetViewData().GetViewShell()->InsertURLButton( aStrURL, aStrURL, EMPTY_OUSTRING, &rPos );
680  return true;
681  }
682 }
683 
685  const css::uno::Reference< css::datatransfer::XTransferable >& rxTransferable,
686  SCCOL nPosX, SCROW nPosY )
687 {
688  INetBookmark aBookmark;
689  TransferableDataHelper aDataHelper( rxTransferable );
690  if ( !aDataHelper.GetINetBookmark( nFormatId, aBookmark ) )
691  return false;
692 
693  InsertBookmark( aBookmark.GetDescription(), aBookmark.GetURL(), nPosX, nPosY );
694  return true;
695 }
696 
697 void ScViewFunc::InsertBookmark( const OUString& rDescription, const OUString& rURL,
698  SCCOL nPosX, SCROW nPosY, const OUString* pTarget,
699  bool bTryReplace )
700 {
701  ScViewData& rViewData = GetViewData();
702  if ( rViewData.HasEditView( rViewData.GetActivePart() ) &&
703  nPosX >= rViewData.GetEditStartCol() && nPosX <= rViewData.GetEditEndCol() &&
704  nPosY >= rViewData.GetEditStartRow() && nPosY <= rViewData.GetEditEndRow() )
705  {
706  // insert into the cell which just got edited
707 
708  OUString aTargetFrame;
709  if (pTarget)
710  aTargetFrame = *pTarget;
711  rViewData.GetViewShell()->InsertURLField( rDescription, rURL, aTargetFrame );
712  return;
713  }
714 
715  // insert into not edited cell
716 
717  ScDocument& rDoc = GetViewData().GetDocument();
718  SCTAB nTab = GetViewData().GetTabNo();
719  ScAddress aCellPos( nPosX, nPosY, nTab );
720  EditEngine aEngine( rDoc.GetEnginePool() );
721 
722  const EditTextObject* pOld = rDoc.GetEditText(aCellPos);
723  if (pOld)
724  aEngine.SetText(*pOld);
725  else
726  {
727  OUString aOld;
728  rDoc.GetInputString(nPosX, nPosY, nTab, aOld);
729  if (!aOld.isEmpty())
730  aEngine.SetText(aOld);
731  }
732 
733  sal_Int32 nPara = aEngine.GetParagraphCount();
734  if (nPara)
735  --nPara;
736  sal_Int32 nTxtLen = aEngine.GetTextLen(nPara);
737  ESelection aInsSel( nPara, nTxtLen, nPara, nTxtLen );
738 
739  if ( bTryReplace && HasBookmarkAtCursor( nullptr ) )
740  {
741  // if called from hyperlink slot and cell contains only a URL,
742  // replace old URL with new one
743 
744  aInsSel = ESelection( 0, 0, 0, 1 ); // replace first character (field)
745  }
746 
747  SvxURLField aField( rURL, rDescription, SvxURLFormat::AppDefault );
748  if (pTarget)
749  aField.SetTargetFrame(*pTarget);
750  aEngine.QuickInsertField( SvxFieldItem( aField, EE_FEATURE_FIELD ), aInsSel );
751 
752  std::unique_ptr<EditTextObject> pData(aEngine.CreateTextObject());
753  EnterData(nPosX, nPosY, nTab, *pData);
754 }
755 
757 {
758  ScAddress aPos( GetViewData().GetCurX(), GetViewData().GetCurY(), GetViewData().GetTabNo() );
759  ScDocument& rDoc = GetViewData().GetDocShell()->GetDocument();
760 
761  const EditTextObject* pData = rDoc.GetEditText(aPos);
762  if (!pData)
763  return false;
764 
765  if (!pData->IsFieldObject())
766  // not a field object.
767  return false;
768 
769  const SvxFieldItem* pFieldItem = pData->GetField();
770  if (!pFieldItem)
771  // doesn't have a field item.
772  return false;
773 
774  const SvxFieldData* pField = pFieldItem->GetField();
775  if (!pField)
776  // doesn't have a field item data.
777  return false;
778 
779  if (pField->GetClassId() != css::text::textfield::Type::URL)
780  // not a URL field.
781  return false;
782 
783  if (pContent)
784  {
785  const SvxURLField* pURLField = static_cast<const SvxURLField*>(pField);
786  pContent->SetName( pURLField->GetRepresentation() );
787  pContent->SetURL( pURLField->GetURL() );
788  pContent->SetTargetFrame( pURLField->GetTargetFrame() );
789  }
790  return true;
791 }
792 
793 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */
ScMarkData & GetMarkData()
Definition: viewdata.cxx:3046
void SetURL(const OUString &rURL)
bool is() const
void set(double fValue)
Definition: cellvalue.cxx:295
EESpellState StartThesaurus()
void EnableIdle(bool bDo)
Definition: document.hxx:2118
const SfxPoolItem * ExecuteList(sal_uInt16 nSlot, SfxCallMode nCall, std::initializer_list< SfxPoolItem const * > args, std::initializer_list< SfxPoolItem const * > internalargs=std::initializer_list< SfxPoolItem const * >())
void SetTargetFrame(const OUString &rFrm)
URL aURL
void MarkToSimple()
Definition: markdata.cxx:237
CellType meType
Definition: cellvalue.hxx:38
ScDocShell * GetDocShell() const
Definition: viewdata.hxx:354
ScAddress aStart
Definition: address.hxx:500
const SvxFieldItem * GetField() const
SharedString intern(const OUString &rStr)
SC_DLLPUBLIC svl::SharedStringPool & GetSharedStringPool()
Definition: documen2.cxx:563
SC_DLLPUBLIC void GetInputString(SCCOL nCol, SCROW nRow, SCTAB nTab, OUString &rString)
Definition: document.cxx:3540
todo: It should be possible to have MarkArrays for each table, in order to enable "search all" across...
Definition: markdata.hxx:43
ErrCode ImportGraphic(Graphic &rGraphic, const INetURLObject &rPath, sal_uInt16 nFormat=GRFILTER_FORMAT_DONTKNOW, sal_uInt16 *pDeterminedFormat=nullptr, GraphicFilterImportFlags nImportFlags=GraphicFilterImportFlags::NONE)
#define EMPTY_OUSTRING
Definition: global.hxx:215
bool PasteBookmark(SotClipboardFormatId nFormatId, const css::uno::Reference< css::datatransfer::XTransferable > &rxTransferable, SCCOL nPosX, SCROW nPosY)
Definition: viewfun4.cxx:684
Sheet / outlining (grouping) information.
SCROW Row() const
Definition: address.hxx:262
void PostPaintGridAll()
Definition: docsh3.cxx:181
void MarkToMulti()
Definition: markdata.cxx:224
void DoSheetConversion(const ScConversionParam &rParam)
Generic implementation of sheet conversion functions.
Definition: viewfun4.cxx:439
std::unique_ptr< ContentProperties > pData
void GetFormula(OUString &rFormula, const formula::FormulaGrammar::Grammar=formula::FormulaGrammar::GRAM_DEFAULT, const ScInterpreterContext *pContext=nullptr) const
OUString GetImportFormatName(sal_uInt16 nFormat)
SCROW GetCurY() const
Definition: viewdata.hxx:402
#define LANGUAGE_KOREAN
sal_Int64 n
void SetDocumentModified()
Definition: docsh.cxx:2819
void SetSpellingView(EditView *pSpView)
Definition: viewdata.hxx:632
bool HasEditView(ScSplitPos eWhich) const
Definition: viewdata.hxx:564
SCTAB GetTabNo() const
Definition: viewdata.hxx:395
ErrCode GuessFilter(SfxMedium &rMedium, std::shared_ptr< const SfxFilter > &, SfxFilterFlags nMust=SfxFilterFlags::IMPORT, SfxFilterFlags nDont=SFX_FILTER_NOTINSTALLED) const
ScAddress aEnd
Definition: address.hxx:501
ScSplitPos GetActivePart() const
Definition: viewdata.hxx:398
void ToggleRel(sal_Int32 nStartPos, sal_Int32 nEndPos)
Definition: reffind.cxx:234
SC_DLLPUBLIC formula::FormulaGrammar::Grammar GetGrammar() const
Definition: document.hxx:985
bool GetINetBookmark(SotClipboardFormatId nFormat, INetBookmark &rBmk)
EmbeddedObjectRef * pObject
bool HasFormat(SotClipboardFormatId nFormat) const
const OUString & GetTargetFrame() const
SC_DLLPUBLIC formula::FormulaGrammar::AddressConvention GetAddressConvention() const
Definition: documen3.cxx:489
ScFormulaCell * getFormulaCell()
Definition: dociter.hxx:239
SCROW GetEditEndRow() const
Definition: viewdata.hxx:590
ScSplitPos
Definition: viewdata.hxx:45
CellType getType() const
Definition: dociter.hxx:236
void GetMarkArea(ScRange &rRange) const
Definition: markdata.cxx:112
virtual SfxUndoManager * GetUndoManager() override
Definition: docsh.cxx:2805
Store arbitrary cell value of any kind.
Definition: cellvalue.hxx:36
void SetAllFormulasDirty(const sc::SetFormulaDirtyContext &rCxt)
Definition: document.cxx:3835
OUString getString(const ScDocument &rDoc) const
Definition: cellvalue.cxx:494
Edit engine for text conversion.
Definition: spelleng.hxx:128
void SetTargetFrame(const OUString &rTarget)
Reference< XInputStream > xStream
SC_DLLPUBLIC SCROW MaxRow() const
Definition: document.hxx:873
const BorderLinePrimitive2D *pCandidateB assert(pCandidateA)
SC_DLLPUBLIC SCTAB GetTableCount() const
Definition: document.cxx:314
SCTAB GetSelectCount() const
Definition: markdata.cxx:195
bool IsMultiMarked() const
Definition: markdata.hxx:83
int nCount
void CopyToDocument(SCCOL nCol1, SCROW nRow1, SCTAB nTab1, SCCOL nCol2, SCROW nRow2, SCTAB nTab2, InsertDeleteFlags nFlags, bool bMarked, ScDocument &rDestDoc, const ScMarkData *pMarks=nullptr, bool bColRowFlags=true)
Definition: document.cxx:2076
bool HasBookmarkAtCursor(SvxHyperlinkItem *pContent)
Definition: viewfun4.cxx:756
Walk through all cells in an area.
Definition: dociter.hxx:208
void UpdateInputHandler(bool bForce=false, bool bStopEditing=true)
Definition: tabvwsha.cxx:638
SCTAB Tab() const
Definition: address.hxx:271
SotClipboardFormatId
ScAddress aPos
SC_DLLPUBLIC const ScPatternAttr * GetPattern(SCCOL nCol, SCROW nRow, SCTAB nTab) const
Definition: document.cxx:4735
bool PasteFile(const Point &, const OUString &, bool bLink)
Definition: viewfun4.cxx:579
ScTabViewShell * GetViewShell() const
Definition: viewdata.hxx:357
SC_DLLPUBLIC bool SetEditText(const ScAddress &rPos, std::unique_ptr< EditTextObject > pEditText)
This method manages the lifecycle of the passed edit text object.
Definition: document.cxx:3394
const char * GetMessageId() const
Definition: editable.cxx:152
void SetMarkArea(const ScRange &rRange)
Definition: markdata.cxx:97
SC_DLLPUBLIC bool SetString(SCCOL nCol, SCROW nRow, SCTAB nTab, const OUString &rString, const ScSetStringParam *pParam=nullptr)
Definition: document.cxx:3363
void SetTab(SCTAB nTabP)
Definition: address.hxx:283
Edit engine for spell checking.
Definition: spelleng.hxx:96
virtual void AddUndoAction(std::unique_ptr< SfxUndoAction > pAction, bool bTryMerg=false)
static css::uno::Reference< css::embed::XStorage > GetTemporaryStorage(const css::uno::Reference< css::uno::XComponentContext > &rxContext=css::uno::Reference< css::uno::XComponentContext >())
static css::uno::Reference< css::linguistic2::XSpellChecker1 > GetSpellChecker()
bool IsMarked() const
Definition: markdata.hxx:82
int i
std::unique_ptr< ScDocument, o3tl::default_delete< ScDocument > > ScDocumentUniquePtr
Definition: document.hxx:2613
sal_Int16 SCCOL
Definition: types.hxx:22
void UseInteractionHandler(bool)
bool GetString(SotClipboardFormatId nFormat, OUString &rStr)
#define SC_MOD()
Definition: scmod.hxx:253
void InsertBookmark(const OUString &rDescription, const OUString &rURL, SCCOL nPosX, SCROW nPosY, const OUString *pTarget=nullptr, bool bTryReplace=false)
Definition: viewfun4.cxx:697
Parameters for conversion.
Definition: spellparam.hxx:33
ScSheetLimits & GetSheetLimits() const
Definition: document.hxx:874
SC_DLLPUBLIC SfxItemPool * GetEnginePool() const
Definition: documen2.cxx:449
size_t size() const
Definition: rangelst.hxx:90
OUString ScResId(const char *pId)
Definition: scdll.cxx:95
ScGridWindow * GetActiveWin()
Definition: viewdata.cxx:3062
const OUString & GetDescription() const
#define GRFILTER_FORMAT_DONTKNOW
const OUString & GetRepresentation() const
bool IsFieldObject() const
SC_DLLPUBLIC const EditTextObject * GetEditText(const ScAddress &rPos) const
Definition: document.cxx:3611
bool IsEditable() const
Definition: editable.hxx:84
void InsertURLField(const OUString &rName, const OUString &rURL, const OUString &rTarget)
Definition: tabvwshe.cxx:165
void SetName(const OUString &rName)
static bool isMediaURL(const OUString &rURL, const OUString &rReferer, bool bDeep=false, Size *pPreferredSizePixel=nullptr)
void PostPaint(SCCOL nStartCol, SCROW nStartRow, SCTAB nStartTab, SCCOL nEndCol, SCROW nEndRow, SCTAB nEndTab, PaintPartFlags nPart, sal_uInt16 nExtFlags=0)
Definition: docsh3.cxx:99
ScConversionType GetType() const
Definition: spellparam.hxx:55
Size GetSize() const
SCCOL Col() const
Definition: address.hxx:267
const OUString & GetURL() const
bool GetSotStorageStream(SotClipboardFormatId nFormat, tools::SvRef< SotStorageStream > &rStreamRef)
virtual sal_Int32 GetClassId() const
OUString GetMainURL(DecodeMechanism eMechanism, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8) const
const ScAddress & GetPos() const
Definition: dociter.hxx:234
void PasteRTF(SCCOL nCol, SCROW nStartRow, const css::uno::Reference< css::datatransfer::XTransferable > &rxTransferable)
Definition: viewfun4.cxx:77
sal_Int32 SCROW
Definition: types.hxx:18
void UpdateOle(const ScViewData &rViewData, bool bSnapSize=false)
Definition: docsh6.cxx:152
SC_DLLPUBLIC ScFormulaCell * SetFormulaCell(const ScAddress &rPos, ScFormulaCell *pCell)
Set formula cell, and transfer its ownership to the document.
Definition: documen2.cxx:1081
SfxDispatcher * GetDispatcher()
EESpellState
SCCOL GetEditStartCol() const
Definition: viewdata.hxx:587
void assign(const ScDocument &rDoc, const ScAddress &rPos)
Take cell value from specified position in specified document.
Definition: cellvalue.cxx:330
OUString aName
SCCOL GetEditEndCol() const
Definition: viewdata.hxx:589
const OUString & GetURL() const
const ScDocument & GetDocument() const
Definition: docsh.hxx:216
Hangul-Hanja converter.
Definition: spellparam.hxx:29
ScMatrixMode
EditTextObject * mpEditText
Definition: cellvalue.hxx:42
SC_DLLPUBLIC SfxItemPool * GetEditPool() const
Definition: documen2.cxx:444
void DoRefConversion()
Definition: viewfun4.cxx:179
static OUString GetLanguageString(const LanguageType eType)
bool InsertEmbeddedObject(const css::uno::Reference< css::embed::XEmbeddedObject > &, OUString &)
void SetSelection(const ESelection &rNewSel)
void SetOutputArea(const tools::Rectangle &rRect)
static GraphicFilter & GetGraphicFilter()
reference_type * get() const
bool IsUndoEnabled() const
Definition: document.hxx:1531
void DoHangulHanjaConversion()
Definition: viewfun4.cxx:433
ESelection GetSelection() const
constexpr sal_uInt16 EE_FEATURE_FIELD(EE_FEATURE_NOTCONV+1)
void GetMultiMarkArea(ScRange &rRange) const
Definition: markdata.cxx:117
static LanguageType GetEffLanguage(ScDocument &rDoc, const ScAddress &rPos)
Definition: viewutil.cxx:69
SC_DLLPUBLIC void EnableUndo(bool bVal)
Definition: document.cxx:6470
ScMatrixMode GetMatrixFlag() const
void DoThesaurus()
Definition: viewfun4.cxx:310
bool IsIdleEnabled() const
Definition: document.hxx:2117
aStr
static weld::MessageDialog * CreateMessageDialog(weld::Widget *pParent, VclMessageType eMessageType, VclButtonsType eButtonType, const OUString &rPrimaryMessage, bool bMobile=false)
void GetEditView(ScSplitPos eWhich, EditView *&rViewPtr, SCCOL &rCol, SCROW &rRow)
Definition: viewdata.cxx:2219
sal_Int16 SCTAB
Definition: types.hxx:23
bool SetSmartURL(OUString const &rTheAbsURIRef, EncodeMechanism eMechanism=EncodeMechanism::WasEncoded, rtl_TextEncoding eCharset=RTL_TEXTENCODING_UTF8, FSysStyle eStyle=FSysStyle::Detect)
SCCOL GetCurX() const
Definition: viewdata.hxx:401
SCROW GetEditStartRow() const
Definition: viewdata.hxx:588
const SvxFieldData * GetField() const
void FillEditItemSet(SfxItemSet *pEditSet, const SfxItemSet *pCondSet=nullptr) const
Converts all Calc items contained in the own item set to edit engine items and puts them into pEditSe...
Definition: patattr.cxx:776