sc/source/ui/view/spelleng.cxx

   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 <spelleng.hxx>
  21 #include <com/sun/star/i18n/TextConversionOption.hpp>
  22
  23 #include <scitems.hxx>
  24
  25 #include <editeng/langitem.hxx>
  26 #include <editeng/editobj.hxx>
  27 #include <editeng/editview.hxx>
  28 #include <sfx2/viewfrm.hxx>
  29 #include <utility>
  30 #include <vcl/settings.hxx>
  31 #include <vcl/svapp.hxx>
  32 #include <vcl/weld.hxx>
  33 #include <osl/diagnose.h>
  34
  35 #include <spelldialog.hxx>
  36 #include <tabvwsh.hxx>
  37 #include <docsh.hxx>
  38 #include <cellvalue.hxx>
  39 #include <cellform.hxx>
  40 #include <patattr.hxx>
  41 #include <globstr.hrc>
  42 #include <scresid.hxx>
  43 #include <markdata.hxx>
  44
  45 #include <memory>
  46
  47 using namespace ::com::sun::star;
  48
  49 ScConversionEngineBase::ScConversionEngineBase(
  50         SfxItemPool* pEnginePoolP, ScViewData& rViewData,
  51         ScDocument* pUndoDoc, ScDocument* pRedoDoc ) :
  52     ScEditEngineDefaulter( pEnginePoolP ),
  53     mrViewData( rViewData ),
  54     mrDocShell( *rViewData.GetDocShell() ),
  55     mrDoc( rViewData.GetDocShell()->GetDocument() ),
  56     maSelState( rViewData ),
  57     mpUndoDoc( pUndoDoc ),
  58     mpRedoDoc( pRedoDoc ),
  59     meCurrLang( LANGUAGE_ENGLISH_US ),
  60     mbIsAnyModified( false ),
  61     mbInitialState( true ),
  62     mbWrappedInTable( false ),
  63     mbFinished( false )
  64 {
  65     maSelState.GetCellCursor().GetVars( mnStartCol, mnStartRow, mnStartTab );
  66     // start with cell A1 in cell/range/multi-selection, will seek to first selected
  67     if( maSelState.GetSelectionType() == SC_SELECTTYPE_SHEET )
  68     {
  69         mnStartCol = 0;
  70         mnStartRow = 0;
  71     }
  72     mnCurrCol = mnStartCol;
  73     mnCurrRow = mnStartRow;
  74 }
  75
  76 ScConversionEngineBase::~ScConversionEngineBase()
  77 {
  78 }
  79
  80 bool ScConversionEngineBase::FindNextConversionCell()
  81 {
  82     ScMarkData& rMark = mrViewData.GetMarkData();
  83     ScTabViewShell* pViewShell = mrViewData.GetViewShell();
  84     const ScPatternAttr* pPattern = nullptr;
  85     const ScPatternAttr* pLastPattern = nullptr;
  86
  87     SfxItemSet aEditDefaults(GetEmptyItemSet());
  88
  89     if( IsModified() )
  90     {
  91         mbIsAnyModified = true;
  92
  93         OUString aNewStr = GetText();
  94
  95         // Check if the user has changed the language. If the new language is
  96         // applied to the entire string length, we will set the language as cell
  97         // attribute. Otherwise we will commit this as an edit-engine string.
  98         editeng::LanguageSpan aLang = GetLanguage(0, 0);
  99
 100         bool bSimpleString = GetParagraphCount() == 1 &&
 101             aLang.nLang != LANGUAGE_DONTKNOW &&
 102             aLang.nStart == 0 &&
 103             aLang.nEnd == aNewStr.getLength();
 104
 105         bool bMultiTab = (rMark.GetSelectCount() > 1);
 106
 107         OUString aVisibleStr;
 108         if( bMultiTab )
 109             aVisibleStr = mrDoc.GetString(mnCurrCol, mnCurrRow, mnStartTab);
 110
 111         for( SCTAB nTab = 0, nTabCount = mrDoc.GetTableCount(); nTab < nTabCount; ++nTab )
 112         {
 113             //  always change the cell on the visible tab,
 114             //  on the other selected tabs only if they contain the same text
 115
 116             if ((nTab == mnStartTab) ||
 117                 (bMultiTab && rMark.GetTableSelect(nTab) && mrDoc.GetString(mnCurrCol, mnCurrRow, nTab) == aVisibleStr))
 118             {
 119                 ScAddress aPos( mnCurrCol, mnCurrRow, nTab );
 120                 CellType eCellType = mrDoc.GetCellType( aPos );
 121                 bool bEmptyCell = eCellType == CELLTYPE_NONE;
 122
 123                 if (mpUndoDoc && !bEmptyCell)
 124                     mrDoc.CopyCellToDocument(aPos, aPos, *mpUndoDoc);
 125
 126                 if (!bSimpleString || eCellType == CELLTYPE_EDIT)
 127                 {
 128                     std::unique_ptr<EditTextObject> pEditObj(CreateTextObject());
 129                     mrDoc.SetEditText(aPos, *pEditObj, GetEditTextObjectPool());
 130                 }
 131                 else
 132                 {
 133                     // Set the new string and update the language with the cell.
 134                     mrDoc.SetString(aPos, aNewStr);
 135
 136                     const ScPatternAttr* pAttr(mrDoc.GetPattern(aPos));
 137                     ScPatternAttr* pNewAttr(nullptr);
 138
 139                     if (nullptr != pAttr)
 140                         pNewAttr = new ScPatternAttr(*pAttr);
 141                     else
 142                         pNewAttr = new ScPatternAttr(mrDoc.getCellAttributeHelper());
 143
 144                     pNewAttr->GetItemSet().Put(SvxLanguageItem(aLang.nLang, ATTR_FONT_LANGUAGE));
 145                     mrDoc.SetPattern(aPos, CellAttributeHolder(pNewAttr, true));
 146                 }
 147
 148                 if (mpRedoDoc && !bEmptyCell)
 149                     mrDoc.CopyCellToDocument(aPos, aPos, *mpRedoDoc);
 150
 151                 mrDocShell.PostPaintCell(aPos);
 152             }
 153         }
 154     }
 155
 156     SCCOL nNewCol = mnCurrCol;
 157     SCROW nNewRow = mnCurrRow;
 158
 159     if( mbInitialState )
 160     {
 161         /*  On very first call, decrement row to let GetNextSpellingCell() find
 162             the first cell of current range. */
 163         mbInitialState = false;
 164         --nNewRow;
 165     }
 166
 167     bool bSheetSel = maSelState.GetSelectionType() == SC_SELECTTYPE_SHEET;
 168     bool bLoop = true;
 169     bool bFound = false;
 170     while( bLoop && !bFound )
 171     {
 172         bLoop = mrDoc.GetNextSpellingCell( nNewCol, nNewRow, mnStartTab, bSheetSel, rMark );
 173         if( bLoop )
 174         {
 175             FillFromCell( mnCurrCol, mnCurrRow, mnStartTab );
 176
 177             if( mbWrappedInTable && ((nNewCol > mnStartCol) || ((nNewCol == mnStartCol) && (nNewRow >= mnStartRow))) )
 178             {
 179                 ShowFinishDialog();
 180                 bLoop = false;
 181                 mbFinished = true;
 182             }
 183             else if( nNewCol >= mrDoc.GetAllocatedColumnsCount(mnStartTab) )
 184             {
 185                 // no more cells in the sheet - try to restart at top of sheet
 186
 187                 if( bSheetSel || ((mnStartCol == 0) && (mnStartRow == 0)) )
 188                 {
 189                     // conversion started at cell A1 or in selection, do not query to restart at top
 190                     ShowFinishDialog();
 191                     bLoop = false;
 192                     mbFinished = true;
 193                 }
 194                 else if( ShowTableWrapDialog() )
 195                 {
 196                     // conversion started anywhere but in cell A1, user wants to restart
 197                     nNewRow = mrDoc.MaxRow() + 2;
 198                     mbWrappedInTable = true;
 199                 }
 200                 else
 201                 {
 202                     bLoop = false;
 203                     mbFinished = true;
 204                 }
 205             }
 206             else
 207             {
 208                 // GetPattern may implicitly allocates the column if not exists,
 209                 pPattern = mrDoc.GetPattern( nNewCol, nNewRow, mnStartTab );
 210                 if( pPattern && !ScPatternAttr::areSame(pPattern, pLastPattern) )
 211                 {
 212                     pPattern->FillEditItemSet( &aEditDefaults );
 213                     SetDefaults( aEditDefaults );
 214                     pLastPattern = pPattern;
 215                 }
 216
 217                 // language changed?
 218                 const SfxPoolItem* pItem = mrDoc.GetAttr( nNewCol, nNewRow, mnStartTab, ATTR_FONT_LANGUAGE );
 219                 if( const SvxLanguageItem* pLangItem = dynamic_cast<const SvxLanguageItem*>( pItem )  )
 220                 {
 221                     LanguageType eLang = pLangItem->GetValue();
 222                     if( eLang == LANGUAGE_SYSTEM )
 223                         eLang = Application::GetSettings().GetLanguageTag().getLanguageType();   // never use SYSTEM for spelling
 224                     if( eLang != meCurrLang )
 225                     {
 226                         meCurrLang = eLang;
 227                         SetDefaultLanguage( eLang );
 228                     }
 229                 }
 230
 231                 FillFromCell( nNewCol, nNewRow, mnStartTab );
 232
 233                 bFound = bLoop && NeedsConversion();
 234             }
 235         }
 236     }
 237
 238     if( bFound )
 239     {
 240         pViewShell->AlignToCursor( nNewCol, nNewRow, SC_FOLLOW_JUMP );
 241         pViewShell->SetCursor( nNewCol, nNewRow, true );
 242         mrViewData.GetView()->MakeEditView( this, nNewCol, nNewRow );
 243         EditView* pEditView = mrViewData.GetSpellingView();
 244         // maSelState.GetEditSelection() returns (0,0) if not in edit mode -> ok
 245         pEditView->SetSelection( maSelState.GetEditSelection() );
 246
 247         ClearModifyFlag();
 248         mnCurrCol = nNewCol;
 249         mnCurrRow = nNewRow;
 250     }
 251
 252     return bFound;
 253 }
 254
 255 void ScConversionEngineBase::RestoreCursorPos()
 256 {
 257     const ScAddress& rPos = maSelState.GetCellCursor();
 258     mrViewData.GetViewShell()->SetCursor( rPos.Col(), rPos.Row() );
 259 }
 260
 261 bool ScConversionEngineBase::ShowTableWrapDialog()
 262 {
 263     // default: no dialog, always restart at top
 264     return true;
 265 }
 266
 267 void ScConversionEngineBase::ShowFinishDialog()
 268 {
 269     // default: no dialog
 270 }
 271
 272 // private --------------------------------------------------------------------
 273
 274 void ScConversionEngineBase::FillFromCell( SCCOL nCol, SCROW nRow, SCTAB nTab )
 275 {
 276     ScAddress aPos(nCol, nRow, nTab);
 277
 278     ScRefCellValue aCell(mrDoc, aPos);
 279     switch (aCell.getType())
 280     {
 281         case CELLTYPE_STRING:
 282         {
 283             sal_uInt32 nNumFmt = mrDoc.GetNumberFormat(ScRange(aPos));
 284             const Color* pColor;
 285             OUString aText = ScCellFormat::GetString(aCell, nNumFmt, &pColor, nullptr, mrDoc);
 286
 287             SetTextCurrentDefaults(aText);
 288         }
 289         break;
 290         case CELLTYPE_EDIT:
 291         {
 292             const EditTextObject* pNewEditObj = aCell.getEditText();
 293             SetTextCurrentDefaults(*pNewEditObj);
 294         }
 295         break;
 296         default:
 297             SetTextCurrentDefaults(OUString());
 298     }
 299 }
 300
 301 ScSpellingEngine::ScSpellingEngine(
 302         SfxItemPool* pEnginePoolP, ScViewData& rViewData,
 303         ScDocument* pUndoDoc, ScDocument* pRedoDoc,
 304         css::uno::Reference< css::linguistic2::XSpellChecker1 > const & xSpeller ) :
 305     ScConversionEngineBase( pEnginePoolP, rViewData, pUndoDoc, pRedoDoc )
 306 {
 307     SetSpeller( xSpeller );
 308 }
 309
 310 void ScSpellingEngine::ConvertAll(weld::Widget* pDialogParent, EditView& rEditView)
 311 {
 312     EESpellState eState = EESpellState::Ok;
 313     if( FindNextConversionCell() )
 314         eState = rEditView.StartSpeller(pDialogParent, true);
 315
 316     OSL_ENSURE( eState != EESpellState::NoSpeller, "ScSpellingEngine::Convert - no spell checker" );
 317 }
 318
 319 bool ScSpellingEngine::SpellNextDocument()
 320 {
 321     return FindNextConversionCell();
 322 }
 323
 324 bool ScSpellingEngine::NeedsConversion()
 325 {
 326     return HasSpellErrors() != EESpellState::Ok;
 327 }
 328
 329 bool ScSpellingEngine::ShowTableWrapDialog()
 330 {
 331     weld::Widget* pParent = GetDialogParent();
 332     weld::WaitObject aWaitOff(pParent);
 333
 334     std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(pParent,
 335                                               VclMessageType::Question, VclButtonsType::YesNo,
 336                                               ScResId(STR_SPELLING_BEGIN_TAB))); // "delete data?"
 337     xBox->set_title(ScResId(STR_MSSG_DOSUBTOTALS_0));
 338     xBox->set_default_response(RET_YES);
 339     return xBox->run() == RET_YES;
 340 }
 341
 342 void ScSpellingEngine::ShowFinishDialog()
 343 {
 344     weld::Widget* pParent = GetDialogParent();
 345     weld::WaitObject aWaitOff(pParent);
 346     std::unique_ptr<weld::MessageDialog> xInfoBox(Application::CreateMessageDialog(pParent,
 347                                                   VclMessageType::Info, VclButtonsType::Ok,
 348                                                   ScResId(STR_SPELLING_STOP_OK)));
 349     xInfoBox->run();
 350 }
 351
 352 weld::Widget* ScSpellingEngine::GetDialogParent()
 353 {
 354     sal_uInt16 nWinId = ScSpellDialogChildWindow::GetChildWindowId();
 355     SfxViewFrame& rViewFrm = mrViewData.GetViewShell()->GetViewFrame();
 356     if( rViewFrm.HasChildWindow( nWinId ) )
 357     {
 358         if( SfxChildWindow* pChild = rViewFrm.GetChildWindow( nWinId ) )
 359         {
 360             auto xController = pChild->GetController();
 361             if (xController)
 362             {
 363                 if (weld::Window *pRet = xController->getDialog())
 364                 {
 365                     if (pRet->get_visible())
 366                         return pRet;
 367                 }
 368             }
 369         }
 370     }
 371
 372     // fall back to standard dialog parent
 373     return ScDocShell::GetActiveDialogParent();
 374 }
 375
 376 ScConversionParam::ScConversionParam( ScConversionType eConvType ) :
 377     meConvType( eConvType ),
 378     meSourceLang( LANGUAGE_NONE ),
 379     meTargetLang( LANGUAGE_NONE ),
 380     mnOptions( 0 ),
 381     mbUseTargetFont( false ),
 382     mbIsInteractive( false )
 383 {
 384 }
 385
 386 ScConversionParam::ScConversionParam( ScConversionType eConvType,
 387         LanguageType eLang, sal_Int32 nOptions, bool bIsInteractive ) :
 388     meConvType( eConvType ),
 389     meSourceLang( eLang ),
 390     meTargetLang( eLang ),
 391     mnOptions( nOptions ),
 392     mbUseTargetFont( false ),
 393     mbIsInteractive( bIsInteractive )
 394 {
 395     if (LANGUAGE_KOREAN == eLang)
 396         mnOptions = i18n::TextConversionOption::CHARACTER_BY_CHARACTER;
 397 }
 398
 399 ScConversionParam::ScConversionParam( ScConversionType eConvType,
 400         LanguageType eSourceLang, LanguageType eTargetLang, vcl::Font aTargetFont,
 401         sal_Int32 nOptions, bool bIsInteractive ) :
 402     meConvType( eConvType ),
 403     meSourceLang( eSourceLang ),
 404     meTargetLang( eTargetLang ),
 405     maTargetFont(std::move( aTargetFont )),
 406     mnOptions( nOptions ),
 407     mbUseTargetFont( true ),
 408     mbIsInteractive( bIsInteractive )
 409 {
 410     if (LANGUAGE_KOREAN == meSourceLang && LANGUAGE_KOREAN == meTargetLang)
 411         mnOptions = i18n::TextConversionOption::CHARACTER_BY_CHARACTER;
 412 }
 413
 414 ScTextConversionEngine::ScTextConversionEngine(
 415         SfxItemPool* pEnginePoolP, ScViewData& rViewData,
 416         ScConversionParam aConvParam,
 417         ScDocument* pUndoDoc, ScDocument* pRedoDoc ) :
 418     ScConversionEngineBase( pEnginePoolP, rViewData, pUndoDoc, pRedoDoc ),
 419     maConvParam(std::move( aConvParam ))
 420 {
 421 }
 422
 423 void ScTextConversionEngine::ConvertAll(weld::Widget* pDialogParent, EditView& rEditView)
 424 {
 425     if( FindNextConversionCell() )
 426     {
 427         rEditView.StartTextConversion(pDialogParent,
 428             maConvParam.GetSourceLang(), maConvParam.GetTargetLang(), maConvParam.GetTargetFont(),
 429             maConvParam.GetOptions(), maConvParam.IsInteractive(), true );
 430         // #i34769# restore initial cursor position
 431         RestoreCursorPos();
 432     }
 433 }
 434
 435 bool ScTextConversionEngine::ConvertNextDocument()
 436 {
 437     return FindNextConversionCell();
 438 }
 439
 440 bool ScTextConversionEngine::NeedsConversion()
 441 {
 442     return HasConvertibleTextPortion( maConvParam.GetSourceLang() );
 443 }
 444
 445 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */