/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */

/*

 * This file is part of the LibreOffice project.

 *

 * This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 * This file incorporates work covered by the following license notice:

 *

 *   Licensed to the Apache Software Foundation (ASF) under one or more

 *   contributor license agreements. See the NOTICE file distributed

 *   with this work for additional information regarding copyright

 *   ownership. The ASF licenses this file to you under the Apache

 *   License, Version 2.0 (the "License"); you may not use this file

 *   except in compliance with the License. You may obtain a copy of

 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .

 */

#include <memory>

#include <SwSpellDialogChildWindow.hxx>

#include <vcl/svapp.hxx>

#include <vcl/weld/MessageDialog.hxx>

#include <editeng/svxacorr.hxx>

#include <editeng/acorrcfg.hxx>

#include <sfx2/basedlgs.hxx>

#include <sfx2/bindings.hxx>

#include <sfx2/dispatch.hxx>

#include <sfx2/viewfrm.hxx>

#include <wrtsh.hxx>

#include <sfx2/printer.hxx>

#include <svx/svdoutl.hxx>

#include <svx/svdview.hxx>

#include <unotools/linguprops.hxx>

#include <unotools/lingucfg.hxx>

#include <osl/diagnose.h>

#include <doc.hxx>

#include <IDocumentDeviceAccess.hxx>

#include <IDocumentDrawModelAccess.hxx>

#include <docsh.hxx>

#include <drawdoc.hxx>

#include <dcontact.hxx>

#include <edtwin.hxx>

#include <pam.hxx>

#include <drawbase.hxx>

#include <unotextrange.hxx>

#include <strings.hrc>

#include <cmdid.h>

using namespace ::com::sun::star;

using namespace ::com::sun::star::uno;

using namespace ::com::sun::star::linguistic2;

SFX_IMPL_CHILDWINDOW_WITHID(SwSpellDialogChildWindow, FN_SPELL_GRAMMAR_DIALOG)

struct SpellState

{

    bool                m_bInitialCall;

    bool                m_bLockFocus; // lock the focus notification while a modal dialog is active

    bool                m_bLostFocus;

    // restart and progress information

    bool                m_bBodySpelled;  // body already spelled

    bool                m_bOtherSpelled; // frames, footnotes, headers and footers spelled

    bool                m_bStartedInOther; // started the spelling inside of the _other_ area

    bool                m_bStartedInSelection; // there was an initial text selection

    std::unique_ptr<SwPaM>

                        pOtherCursor; // position where the spelling inside the _other_ area started

    bool                m_bDrawingsSpelled; // all drawings spelled

    rtl::Reference<SwXTextRange> m_xStartRange; // text range that marks the start of spelling

    const SdrObject*    m_pStartDrawing; // draw text object spelling started in

    ESelection          m_aStartDrawingSelection; // draw text start selection

    bool                m_bRestartDrawing; // the first selected drawing object is found again

    // lose/get focus information to decide if spelling can be continued

    ShellMode           m_eSelMode;

    const SwNode*       m_pPointNode;

    const SwNode*       m_pMarkNode;

    sal_Int32           m_nPointPos;

    sal_Int32           m_nMarkPos;

    const SdrOutliner*  m_pOutliner;

    ESelection          m_aESelection;

    // iterating over draw text objects

    std::list<SdrTextObj*> m_aTextObjects;

    bool                m_bTextObjectsCollected;

    SpellState() :

        m_bInitialCall(true),

        m_bLockFocus(false),

        m_bLostFocus(false),

        m_bBodySpelled(false),

        m_bOtherSpelled(false),

        m_bStartedInOther(false),

        m_bStartedInSelection(false),

        m_bDrawingsSpelled(false),

        m_pStartDrawing(nullptr),

        m_bRestartDrawing(false),

        m_eSelMode(ShellMode::Object), // initially invalid

        m_pPointNode(nullptr),

        m_pMarkNode(nullptr),

        m_nPointPos(0),

        m_nMarkPos(0),

        m_pOutliner(nullptr),

        m_bTextObjectsCollected(false)

        {}

    // reset state in ::InvalidateSpellDialog

    void    Reset()

            {   m_bInitialCall = true;

                m_bBodySpelled = m_bOtherSpelled = m_bDrawingsSpelled = false;

                m_xStartRange = nullptr;

                m_pStartDrawing = nullptr;

                m_bRestartDrawing = false;

                m_bTextObjectsCollected = false;

                m_aTextObjects.clear();

                m_bStartedInOther = false;

                pOtherCursor.reset();

            }

};

static void lcl_LeaveDrawText(SwWrtShell& rSh)

{

    if(rSh.GetDrawView())

    {

        rSh.GetDrawView()->SdrEndTextEdit( true );

        Point aPt(LONG_MIN, LONG_MIN);

        // go out of the frame

        rSh.SelectObj(aPt, SW_LEAVE_FRAME);

        rSh.EnterStdMode();

        rSh.GetView().AttrChangedNotify(nullptr);

    }

}

static void lcl_updateSpellStateCursorPos(SpellState& rSpellState, const SwWrtShell& rWrtShell)

{

    rSpellState.m_eSelMode = rWrtShell.GetView().GetShellMode();

    rSpellState.m_pPointNode = nullptr;

    rSpellState.m_pMarkNode = nullptr;

    rSpellState.m_nPointPos = 0;

    rSpellState.m_nMarkPos = 0;

    rSpellState.m_pOutliner = nullptr;

    switch(rSpellState.m_eSelMode)

    {

        case ShellMode::Text:

        case ShellMode::ListText:

        case ShellMode::TableText:

        case ShellMode::TableListText:

        {

            // store a node pointer and a pam-position to be able to check on next GetFocus();

            const SwPaM& rCursor = *rWrtShell.GetCursor();

            rSpellState.m_pPointNode = &rCursor.GetPointNode();

            rSpellState.m_pMarkNode = &rCursor.GetMarkNode();

            rSpellState.m_nPointPos = rCursor.GetPoint()->GetContentIndex();

            rSpellState.m_nMarkPos = rCursor.GetMark()->GetContentIndex();

        }

        break;

        case ShellMode::DrawText:

        {

            const SdrView& rSdrView = *rWrtShell.GetDrawView();

            const SdrOutliner* pOutliner = rSdrView.GetTextEditOutliner();

            rSpellState.m_pOutliner = pOutliner;

            const OutlinerView* pOLV = rSdrView.GetTextEditOutlinerView();

            OSL_ENSURE(pOutliner && pOLV, "no Outliner/OutlinerView in SwSpellDialogChildWindow::LoseFocus()");

            if (pOLV)

                rSpellState.m_aESelection = pOLV->GetSelection();

        }

        break;

        default:;// prevent warning

    }

}

SwSpellDialogChildWindow::SwSpellDialogChildWindow (

            vcl::Window* _pParent,

            sal_uInt16 nId,

            SfxBindings* pBindings,

            SfxChildWinInfo* /*pInfo*/)

    : svx::SpellDialogChildWindow (

        _pParent, nId, pBindings)

    , m_bIsGrammarCheckingOn(false)

    , m_pSpellState(new SpellState)

{

    SvtLinguConfig().GetProperty( UPN_IS_GRAMMAR_INTERACTIVE ) >>= m_bIsGrammarCheckingOn;

}

SwSpellDialogChildWindow::~SwSpellDialogChildWindow ()

{

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(!m_pSpellState->m_bInitialCall && pWrtShell)

        pWrtShell->SpellEnd();

    m_pSpellState.reset();

}

SfxChildWinInfo SwSpellDialogChildWindow::GetInfo() const

{

    SfxChildWinInfo aInfo = svx::SpellDialogChildWindow::GetInfo();

    aInfo.bVisible = false;

    return aInfo;

}

svx::SpellPortions SwSpellDialogChildWindow::GetNextWrongSentence(bool bRecheck)

{

    svx::SpellPortions aRet;

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(pWrtShell)

    {

        bool bNoDictionaryAvailable = pWrtShell->GetDoc()->IsDictionaryMissing();

        if (!bRecheck)

        {

            // first set continuation point for spell/grammar check to the

            // end of the current sentence

            SwEditShell::MoveContinuationPosToEndOfCheckedSentence();

        }

        ShellMode eSelMode = pWrtShell->GetView().GetShellMode();

        bool bDrawText = ShellMode::DrawText == eSelMode;

        bool bNormalText =

            ShellMode::TableText == eSelMode ||

            ShellMode::ListText == eSelMode ||

            ShellMode::TableListText == eSelMode ||

            ShellMode::Text == eSelMode;

        // Writer text outside of the body

        bool bOtherText = false;

        if( m_pSpellState->m_bInitialCall )

        {

            // if no text selection exists the cursor has to be set into the text

            if(!bDrawText && !bNormalText)

            {

                MakeTextSelection_Impl(*pWrtShell, eSelMode);

                // the selection type has to be checked again - both text types are possible

                if(pWrtShell->GetSelectionType() & SelectionType::DrawObjectEditMode)

                    bDrawText = true;

                bNormalText = !bDrawText;

            }

            if(bNormalText)

            {

                // set cursor to the start of the sentence

                if(!pWrtShell->HasSelection())

                    pWrtShell->GoStartSentence();

                else

                {

                    pWrtShell->ExpandToSentenceBorders();

                    m_pSpellState->m_bStartedInSelection = true;

                }

                // determine if the selection is outside of the body text

                bOtherText = !(pWrtShell->GetFrameType(nullptr,true) & FrameTypeFlags::BODY);

                if(bOtherText)

                {

                    m_pSpellState->pOtherCursor.reset( new SwPaM(*pWrtShell->GetCursor()->GetPoint()) );

                    m_pSpellState->m_bStartedInOther = true;

                    pWrtShell->SpellStart( SwDocPositions::OtherStart, SwDocPositions::OtherEnd, SwDocPositions::Curr );

                }

                else

                {

                    // mark the start position only if not at start of doc

                    if(!pWrtShell->IsStartOfDoc())

                    {

                        // Record the position *before* the current cursor, as

                        // the word at the current cursor can possibly be

                        // replaced by a spellcheck correction which invalidates

                        // an XTextRange at this position.

                        SwDoc *pDoc = pWrtShell->GetDoc();

                        auto pStart = pWrtShell->GetCursor()->Start();

                        auto pUnoCursor = pDoc->CreateUnoCursor(*pStart);

                        pUnoCursor->Left( 1 );

                        pStart = pUnoCursor->Start();

                        m_pSpellState->m_xStartRange

                            = SwXTextRange::CreateXTextRange(*pDoc, *pStart, nullptr);

                    }

                    pWrtShell->SpellStart( SwDocPositions::Start, SwDocPositions::End, SwDocPositions::Curr );

                }

            }

            else

            {

                SdrView* pSdrView = pWrtShell->GetDrawView();

                m_pSpellState->m_pStartDrawing = pSdrView->GetMarkedObjectList().GetMark(0)->GetMarkedSdrObj();

                OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();

                // start checking at the top of the drawing object

                pOLV->SetSelection( ESelection() );

                m_pSpellState->m_aStartDrawingSelection = ESelection();

/*

Note: spelling in a selection only, or starting in a mid of a drawing object requires

further changes elsewhere. (Especially if it should work in sc and sd as well.)

The code below would only be part of the solution.

(Keeping it as a comment for the time being)

                ESelection aCurSel( pOLV->GetSelection() );

                ESelection aSentenceSel( pOLV->GetEditView().GetEditEngine()->SelectSentence( aCurSel ) );

                if (!aCurSel.HasRange())

                {

                    aSentenceSel.nEndPara = aSentenceSel.nStartPara;

                    aSentenceSel.nEndPos  = aSentenceSel.nStartPos;

                }

                pOLV->SetSelection( aSentenceSel );

                m_pSpellState->m_aStartDrawingSelection = aSentenceSel;

*/

            }

            m_pSpellState->m_bInitialCall = false;

        }

        if( bDrawText )

        {

            // spell inside of the current draw text

            if(!SpellDrawText_Impl(*pWrtShell, aRet))

            {

                if(!FindNextDrawTextError_Impl(*pWrtShell) || !SpellDrawText_Impl(*pWrtShell, aRet))

                {

                    lcl_LeaveDrawText(*pWrtShell);

                    // now the drawings have been spelled

                    m_pSpellState->m_bDrawingsSpelled = true;

                    // the spelling continues at the other content

                    // if there's any that has not been spelled yet

                    if(!m_pSpellState->m_bOtherSpelled && pWrtShell->HasOtherCnt())

                    {

                        pWrtShell->SpellStart(SwDocPositions::OtherStart, SwDocPositions::OtherEnd, SwDocPositions::OtherStart );

                        if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

                        {

                            pWrtShell->SpellEnd();

                            m_pSpellState->m_bOtherSpelled = true;

                        }

                    }

                    else

                        m_pSpellState->m_bOtherSpelled = true;

                    // if no result has been found try at the body text - completely

                    if(!m_pSpellState->m_bBodySpelled && aRet.empty())

                    {

                        pWrtShell->SpellStart(SwDocPositions::Start, SwDocPositions::End, SwDocPositions::Start );

                        if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

                        {

                            m_pSpellState->m_bBodySpelled = true;

                            pWrtShell->SpellEnd();

                        }

                    }

                }

            }

        }

        else

        {

            // spell inside of the Writer text

            if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

            {

                // if there is a selection (within body or header/footer text)

                // then spell/grammar checking should not move outside of it.

                if (!m_pSpellState->m_bStartedInSelection)

                {

                    // find out which text has been spelled body or other

                    bOtherText = !(pWrtShell->GetFrameType(nullptr,true) & FrameTypeFlags::BODY);

                    if(bOtherText && m_pSpellState->m_bStartedInOther && m_pSpellState->pOtherCursor)

                    {

                        m_pSpellState->m_bStartedInOther = false;

                        pWrtShell->SetSelection(*m_pSpellState->pOtherCursor);

                        pWrtShell->SpellEnd();

                        m_pSpellState->pOtherCursor.reset();

                        pWrtShell->SpellStart(SwDocPositions::OtherStart, SwDocPositions::Curr, SwDocPositions::OtherStart );

                        (void)pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn);

                    }

                    if(aRet.empty())

                    {

                        // end spelling

                        pWrtShell->SpellEnd();

                        if(bOtherText)

                        {

                            m_pSpellState->m_bOtherSpelled = true;

                            // has the body been spelled?

                            if(!m_pSpellState->m_bBodySpelled)

                            {

                                pWrtShell->SpellStart(SwDocPositions::Start, SwDocPositions::End, SwDocPositions::Start );

                                if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

                                {

                                    m_pSpellState->m_bBodySpelled = true;

                                    pWrtShell->SpellEnd();

                                }

                            }

                        }

                        else

                        {

                             m_pSpellState->m_bBodySpelled = true;

                             if(!m_pSpellState->m_bOtherSpelled && pWrtShell->HasOtherCnt())

                             {

                                pWrtShell->SpellStart(SwDocPositions::OtherStart, SwDocPositions::OtherEnd, SwDocPositions::OtherStart );

                                if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

                                {

                                    pWrtShell->SpellEnd();

                                    m_pSpellState->m_bOtherSpelled = true;

                                }

                             }

                             else

                                 m_pSpellState->m_bOtherSpelled = true;

                        }

                    }

                    // search for a draw text object that contains error and spell it

                    if(aRet.empty() &&

                            (m_pSpellState->m_bDrawingsSpelled ||

                            !FindNextDrawTextError_Impl(*pWrtShell) || !SpellDrawText_Impl(*pWrtShell, aRet)))

                    {

                        lcl_LeaveDrawText(*pWrtShell);

                        m_pSpellState->m_bDrawingsSpelled = true;

                    }

                }

            }

        }

        // now only the rest of the body text can be spelled -

        // if the spelling started inside of the body

        bool bCloseMessage = true;

        if(aRet.empty() && !m_pSpellState->m_bStartedInSelection)

        {

            OSL_ENSURE(m_pSpellState->m_bDrawingsSpelled &&

                        m_pSpellState->m_bOtherSpelled && m_pSpellState->m_bBodySpelled,

                        "not all parts of the document are already spelled");

            if( m_pSpellState->m_xStartRange.is() && !bNoDictionaryAvailable )

            {

                LockFocusNotification( true );

                std::unique_ptr<weld::MessageDialog> xBox(Application::CreateMessageDialog(GetController()->getDialog(),

                                                                                        VclMessageType::Question, VclButtonsType::YesNo, SwResId(STR_QUERY_SPELL_CONTINUE)));

                sal_uInt16 nRet = xBox->run();

                if (RET_YES == nRet)

                {

                    SwUnoInternalPaM aPam(*pWrtShell->GetDoc());

                    if (::sw::XTextRangeToSwPaM(aPam,

                                m_pSpellState->m_xStartRange))

                    {

                        pWrtShell->SetSelection(aPam);

                        pWrtShell->SpellStart(SwDocPositions::Start, SwDocPositions::Curr, SwDocPositions::Start);

                        if(!pWrtShell->SpellSentence(aRet, m_bIsGrammarCheckingOn))

                            pWrtShell->SpellEnd();

                    }

                    m_pSpellState->m_xStartRange = nullptr;

                    LockFocusNotification( false );

                }

                else

                    bCloseMessage = false; // no closing message if a wrap around has been denied

            }

        }

        lcl_updateSpellStateCursorPos(*m_pSpellState, *pWrtShell);

        if( aRet.empty() && bCloseMessage )

        {

            LockFocusNotification( true );

            OUString sInfo( SwResId( bNoDictionaryAvailable ? STR_DICTIONARY_UNAVAILABLE : STR_SPELLING_COMPLETED ) );

            auto xSpellController = GetController();

            // #i84610#

            std::unique_ptr<weld::MessageDialog> xBox(

                Application::CreateMessageDialog( xSpellController->getDialog(),

                                                  VclMessageType::Info,

                                                  VclButtonsType::Ok,

                                                  sInfo ) );

            xBox->run();

            LockFocusNotification( false );

            xSpellController->getDialog()->grab_focus();

        }

    }

    return aRet;

}

void SwSpellDialogChildWindow::ApplyChangedSentence(const svx::SpellPortions& rChanged, bool bRecheck)

{

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(!pWrtShell || m_pSpellState->m_bInitialCall)

        return;

    ShellMode eSelMode = pWrtShell->GetView().GetShellMode();

    bool bDrawText = ShellMode::DrawText == eSelMode;

    bool bNormalText =

        ShellMode::TableText == eSelMode ||

        ShellMode::ListText == eSelMode ||

        ShellMode::TableListText == eSelMode ||

        ShellMode::Text == eSelMode;

    // evaluate if the same sentence should be rechecked or not.

    // Sentences that got grammar checked should always be rechecked in order

    // to detect possible errors that get introduced with the changes

    bRecheck |= SwEditShell::HasLastSentenceGotGrammarChecked();

    if(bNormalText)

        pWrtShell->ApplyChangedSentence(rChanged, bRecheck);

    else if(bDrawText )

    {

        SdrView* pDrView = pWrtShell->GetDrawView();

        SdrOutliner *pOutliner = pDrView->GetTextEditOutliner();

        pOutliner->ApplyChangedSentence(pDrView->GetTextEditOutlinerView()->GetEditView(), rChanged, bRecheck);

    }

}

void SwSpellDialogChildWindow::AddAutoCorrection(

        const OUString& rOld, const OUString& rNew, LanguageType eLanguage)

{

    SvxAutoCorrect* pACorr = SvxAutoCorrCfg::Get().GetAutoCorrect();

    pACorr->PutText( rOld, rNew, eLanguage );

}

bool SwSpellDialogChildWindow::HasAutoCorrection()

{

    return true;

}

bool SwSpellDialogChildWindow::HasGrammarChecking()

{

    return SvtLinguConfig().HasGrammarChecker();

}

bool SwSpellDialogChildWindow::IsGrammarChecking()

{

    return m_bIsGrammarCheckingOn;

}

void SwSpellDialogChildWindow::SetGrammarChecking(bool bOn)

{

    uno::Any aVal;

    aVal <<= bOn;

    m_bIsGrammarCheckingOn = bOn;

    SvtLinguConfig().SetProperty( UPN_IS_GRAMMAR_INTERACTIVE, aVal );

    // set current spell position to the start of the current sentence to

    // continue with this sentence after grammar checking state has been changed

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(!pWrtShell)

        return;

    ShellMode eSelMode = pWrtShell->GetView().GetShellMode();

    bool bDrawText = ShellMode::DrawText == eSelMode;

    bool bNormalText =

        ShellMode::TableText == eSelMode ||

        ShellMode::ListText == eSelMode ||

        ShellMode::TableListText == eSelMode ||

        ShellMode::Text == eSelMode;

    if( bNormalText )

        SwEditShell::PutSpellingToSentenceStart();

    else if( bDrawText )

    {

        SdrView*     pSdrView = pWrtShell->GetDrawView();

        SdrOutliner* pOutliner = pSdrView ? pSdrView->GetTextEditOutliner() : nullptr;

        OSL_ENSURE(pOutliner, "No Outliner in SwSpellDialogChildWindow::SetGrammarChecking");

        if(pOutliner)

        {

            pOutliner->PutSpellingToSentenceStart( pSdrView->GetTextEditOutlinerView()->GetEditView() );

        }

    }

}

void SwSpellDialogChildWindow::GetFocus(bool bForceResume)

{

    if(m_pSpellState->m_bLockFocus)

        return;

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    bool bInvalidate = bForceResume || !pWrtShell || m_pSpellState->m_bInitialCall;

    if (!bInvalidate)

    {

        ShellMode eSelMode = pWrtShell->GetView().GetShellMode();

        if(eSelMode != m_pSpellState->m_eSelMode)

        {

            // prevent initial invalidation

            if(m_pSpellState->m_bLostFocus)

                bInvalidate = true;

        }

        else

        {

            switch(m_pSpellState->m_eSelMode)

            {

                case ShellMode::Text:

                case ShellMode::ListText:

                case ShellMode::TableText:

                case ShellMode::TableListText:

                {

                    SwPaM* pCursor = pWrtShell->GetCursor();

                    if(m_pSpellState->m_pPointNode != &pCursor->GetPointNode() ||

                        m_pSpellState->m_pMarkNode != &pCursor->GetMarkNode()||

                        m_pSpellState->m_nPointPos != pCursor->GetPoint()->GetContentIndex()||

                        m_pSpellState->m_nMarkPos != pCursor->GetMark()->GetContentIndex())

                            bInvalidate = true;

                }

                break;

                case ShellMode::DrawText:

                {

                    SdrView*     pSdrView = pWrtShell->GetDrawView();

                    SdrOutliner* pOutliner = pSdrView ? pSdrView->GetTextEditOutliner() : nullptr;

                    if(!pOutliner || m_pSpellState->m_pOutliner != pOutliner)

                        bInvalidate = true;

                    else

                    {

                        OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();

                        OSL_ENSURE(pOLV, "no OutlinerView in SwSpellDialogChildWindow::GetFocus()");

                        if(!pOLV || m_pSpellState->m_aESelection != pOLV->GetSelection())

                            bInvalidate = true;

                    }

                }

                break;

                default: bInvalidate = true;

            }

        }

    }

    if(bInvalidate)

        InvalidateSpellDialog();

}

void SwSpellDialogChildWindow::LoseFocus()

{

    // prevent initial invalidation

    m_pSpellState->m_bLostFocus = true;

    if(m_pSpellState->m_bLockFocus)

        return;

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(pWrtShell)

        lcl_updateSpellStateCursorPos(*m_pSpellState, *pWrtShell);

    else

        m_pSpellState->m_eSelMode = ShellMode::Object;

}

void SwSpellDialogChildWindow::InvalidateSpellDialog()

{

    SwWrtShell* pWrtShell = GetWrtShell_Impl();

    if(!m_pSpellState->m_bInitialCall && pWrtShell)

        pWrtShell->SpellEnd(nullptr, false);

    m_pSpellState->Reset();

    svx::SpellDialogChildWindow::InvalidateSpellDialog();

}

SwWrtShell* SwSpellDialogChildWindow::GetWrtShell_Impl()

{

    SfxDispatcher* pDispatch = GetBindings().GetDispatcher();

    SwView* pView = nullptr;

    if(pDispatch)

    {

        sal_uInt16 nShellIdx = 0;

        SfxShell* pShell;

        while(nullptr != (pShell = pDispatch->GetShell(nShellIdx++)))

            if(auto pSwView = dynamic_cast< SwView *>( pShell ))

            {

                pView = pSwView;

                break;

            }

    }

    return pView ? pView->GetWrtShellPtr(): nullptr;

}

// set the cursor into the body text - necessary if any object is selected

// on start of the spelling dialog

void SwSpellDialogChildWindow::MakeTextSelection_Impl(SwWrtShell& rShell, ShellMode eSelMode)

{

    SwView& rView = rShell.GetView();

    switch(eSelMode)

    {

        case ShellMode::Text:

        case ShellMode::ListText:

        case ShellMode::TableText:

        case ShellMode::TableListText:

        case ShellMode::DrawText:

            OSL_FAIL("text already active in SwSpellDialogChildWindow::MakeTextSelection_Impl()");

        break;

        case ShellMode::Frame:

        {

            rShell.UnSelectFrame();

            rShell.LeaveSelFrameMode();

            rView.AttrChangedNotify(nullptr);

        }

        break;

        case ShellMode::Draw:

        case ShellMode::DrawForm:

        case ShellMode::Bezier:

            if(FindNextDrawTextError_Impl(rShell))

            {

                rView.AttrChangedNotify(nullptr);

                break;

            }

            [[fallthrough]]; // to deselect the object

        case ShellMode::Graphic:

        case ShellMode::Object:

        {

            if ( rShell.IsDrawCreate() )

            {

                rView.GetDrawFuncPtr()->BreakCreate();

                rView.AttrChangedNotify(nullptr);

            }

            else if ( rShell.HasSelection() || rView.IsDrawMode() )

            {

                SdrView *pSdrView = rShell.GetDrawView();

                if(pSdrView && pSdrView->GetMarkedObjectList().GetMarkCount() != 0 &&

                    pSdrView->GetHdlList().GetFocusHdl())

                {

                    const_cast<SdrHdlList&>(pSdrView->GetHdlList()).ResetFocusHdl();

                }

                else

                {

                    rView.LeaveDrawCreate();

                    Point aPt(LONG_MIN, LONG_MIN);

                    // go out of the frame

                    rShell.SelectObj(aPt, SW_LEAVE_FRAME);

                    SfxBindings& rBind = rView.GetViewFrame().GetBindings();

                    rBind.Invalidate( SID_ATTR_SIZE );

                    rShell.EnterStdMode();

                    rView.AttrChangedNotify(nullptr);

                }

            }

        }

        break;

        default:; // prevent warning

    }

}

// select the next draw text object that has a spelling error

bool SwSpellDialogChildWindow::FindNextDrawTextError_Impl(SwWrtShell& rSh)

{

    bool bNextDoc = false;

    SdrView* pDrView = rSh.GetDrawView();

    if(!pDrView)

        return bNextDoc;

    SwView& rView = rSh.GetView();

    SwDoc* pDoc = rView.GetDocShell()->GetDoc();

    const SdrMarkList& rMarkList = pDrView->GetMarkedObjectList();

    // start at the current draw object - if there is any selected

    SdrTextObj* pCurrentTextObj = nullptr;

    if ( rMarkList.GetMarkCount() == 1 )

    {

        SdrObject* pObj = rMarkList.GetMark(0)->GetMarkedSdrObj();

        if( auto pSdrTextObj = DynCastSdrTextObj( pObj ) )

            pCurrentTextObj = pSdrTextObj;

    }

    // at first fill the list of drawing objects

    if(!m_pSpellState->m_bTextObjectsCollected )

    {

        m_pSpellState->m_bTextObjectsCollected = true;

        SwDrawContact::GetTextObjectsFromFormat(m_pSpellState->m_aTextObjects, *pDoc);

        if(pCurrentTextObj)

        {

            m_pSpellState->m_aTextObjects.remove(pCurrentTextObj);

            m_pSpellState->m_aTextObjects.push_back(pCurrentTextObj);

        }

    }

    if(!m_pSpellState->m_aTextObjects.empty())

    {

        Reference< XSpellChecker1 >  xSpell( GetSpellChecker() );

        while(!bNextDoc && !m_pSpellState->m_aTextObjects.empty())

        {

            std::list<SdrTextObj*>::iterator aStart = m_pSpellState->m_aTextObjects.begin();

            SdrTextObj* pTextObj = *aStart;

            if(m_pSpellState->m_pStartDrawing == pTextObj)

                m_pSpellState->m_bRestartDrawing = true;

            m_pSpellState->m_aTextObjects.erase(aStart);

            OutlinerParaObject* pParaObj = pTextObj->GetOutlinerParaObject();

            if ( pParaObj )

            {

                bool bHasSpellError = false;

                {

                    SdrOutliner aTmpOutliner(pDoc->getIDocumentDrawModelAccess().GetDrawModel()->

                                             GetDrawOutliner().GetEmptyItemSet().GetPool(),

                                                OutlinerMode::TextObject );

                    aTmpOutliner.SetRefDevice( pDoc->getIDocumentDeviceAccess().getPrinter( false ) );

                    MapMode aMapMode (MapUnit::MapTwip);

                    aTmpOutliner.SetRefMapMode(aMapMode);

                    aTmpOutliner.SetPaperSize( pTextObj->GetLogicRect().GetSize() );

                    aTmpOutliner.SetSpeller( xSpell );

                    OutlinerView aOutlView( aTmpOutliner, &(rView.GetEditWin()) );

                    aOutlView.GetOutliner().SetRefDevice( rSh.getIDocumentDeviceAccess().getPrinter( false ) );

                    aTmpOutliner.InsertView( &aOutlView );

                    Size aSize(1,1);

                    tools::Rectangle aRect( Point(), aSize );

                    aOutlView.SetOutputArea( aRect );

                    aTmpOutliner.SetText( *pParaObj );

                    aTmpOutliner.ClearModifyFlag();

                    bHasSpellError = EESpellState::Ok != aTmpOutliner.HasSpellErrors();

                    aTmpOutliner.RemoveView( &aOutlView );

                }

                if(bHasSpellError)

                {

                    // now the current one has to be deselected

                    if(pCurrentTextObj)

                        pDrView->SdrEndTextEdit( true );

                    // and the found one should be activated

                    rSh.MakeVisible(SwRect(pTextObj->GetLogicRect()));

                    Point aTmp( 0,0 );

                    rSh.SelectObj( aTmp, 0, pTextObj );

                    SdrPageView* pPV = pDrView->GetSdrPageView();

                    rView.BeginTextEdit( pTextObj, pPV, &rView.GetEditWin(), false, true );

                    rView.AttrChangedNotify(nullptr);

                    bNextDoc = true;

                }

            }

        }

    }

    return bNextDoc;

}

bool SwSpellDialogChildWindow::SpellDrawText_Impl(SwWrtShell& rSh, svx::SpellPortions& rPortions)

{

    bool bRet = false;

    SdrView*     pSdrView = rSh.GetDrawView();

    SdrOutliner* pOutliner = pSdrView ? pSdrView->GetTextEditOutliner() : nullptr;

    OSL_ENSURE(pOutliner, "No Outliner in SwSpellDialogChildWindow::SpellDrawText_Impl");

    if(pOutliner)

    {

        bRet = pOutliner->SpellSentence(pSdrView->GetTextEditOutlinerView()->GetEditView(), rPortions);

        // find out if the current selection is in the first spelled drawing object

        // and behind the initial selection

        if(bRet && m_pSpellState->m_bRestartDrawing)

        {

            OutlinerView* pOLV = pSdrView->GetTextEditOutlinerView();

            ESelection aCurrentSelection = pOLV->GetSelection();

            if (m_pSpellState->m_aStartDrawingSelection.end < aCurrentSelection.end)

            {

                bRet = false;

                rPortions.clear();

            }

        }

    }

    return bRet;

}

void SwSpellDialogChildWindow::LockFocusNotification(bool bLock)

{

    if (!m_pSpellState)

    {

        return;

    }

    OSL_ENSURE(m_pSpellState->m_bLockFocus != bLock, "invalid locking - no change of state");

    m_pSpellState->m_bLockFocus = bLock;

}

/* vim:set shiftwidth=4 softtabstop=4 expandtab: */