/************************************************************** * * 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 * * Unless required by applicable law or agreed to in writing, * software distributed under the License is distributed on an * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY * KIND, either express or implied. See the License for the * specific language governing permissions and limitations * under the License. * *************************************************************/ // MARKER(update_precomp.py): autogen include statement, do not remove #include "precompiled_sw.hxx" #include #ifndef _SVSTDARR_HXX #define _SVSTDARR_STRINGSDTOR #include #endif #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include // fuer SpellPointer #include #include #include #include #include // CheckSpellChanges #include // Viewoptions #include // fuer Undo-Ids #include // Trennung #include // PopupMenu fuer OnlineSpelling #include // Spelling: Multiselektion #include #include #include #include #include #include #include // STR_MULT_INTERACT_SPELL_WARN #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "stmenu.hxx" // PopupMenu for smarttags #include #include #include #include #include #include #include using namespace sw::mark; using ::rtl::OUString; using namespace ::com::sun::star; using namespace ::com::sun::star::beans; using namespace ::com::sun::star::uno; using namespace ::com::sun::star::linguistic2; using namespace ::com::sun::star::smarttags; /*-------------------------------------------------------------------- Beschreibung: Lingu-Dispatcher --------------------------------------------------------------------*/ void SwView::ExecLingu(SfxRequest &rReq) { switch(rReq.GetSlot()) { case SID_THESAURUS: StartThesaurus(); rReq.Ignore(); break; case SID_HANGUL_HANJA_CONVERSION: StartTextConversion( LANGUAGE_KOREAN, LANGUAGE_KOREAN, NULL, i18n::TextConversionOption::CHARACTER_BY_CHARACTER, sal_True ); break; case SID_CHINESE_CONVERSION: { //open ChineseTranslationDialog Reference< XComponentContext > xContext( ::cppu::defaultBootstrap_InitialComponentContext() ); //@todo get context from calc if that has one if(xContext.is()) { Reference< lang::XMultiComponentFactory > xMCF( xContext->getServiceManager() ); if(xMCF.is()) { Reference< ui::dialogs::XExecutableDialog > xDialog( xMCF->createInstanceWithContext( rtl::OUString::createFromAscii("com.sun.star.linguistic2.ChineseTranslationDialog") , xContext), UNO_QUERY); Reference< lang::XInitialization > xInit( xDialog, UNO_QUERY ); if( xInit.is() ) { // initialize dialog Reference< awt::XWindow > xDialogParentWindow(0); Sequence aSeq(1); Any* pArray = aSeq.getArray(); PropertyValue aParam; aParam.Name = rtl::OUString::createFromAscii("ParentWindow"); aParam.Value <<= makeAny(xDialogParentWindow); pArray[0] <<= makeAny(aParam); xInit->initialize( aSeq ); //execute dialog sal_Int16 nDialogRet = xDialog->execute(); if( RET_OK == nDialogRet ) { //get some parameters from the dialog sal_Bool bToSimplified = sal_True; sal_Bool bUseVariants = sal_True; sal_Bool bCommonTerms = sal_True; Reference< beans::XPropertySet > xProp( xDialog, UNO_QUERY ); if( xProp.is() ) { try { xProp->getPropertyValue( C2U("IsDirectionToSimplified") ) >>= bToSimplified; xProp->getPropertyValue( C2U("IsUseCharacterVariants") ) >>= bUseVariants; xProp->getPropertyValue( C2U("IsTranslateCommonTerms") ) >>= bCommonTerms; } catch( Exception& ) { } } //execute translation sal_Int16 nSourceLang = bToSimplified ? LANGUAGE_CHINESE_TRADITIONAL : LANGUAGE_CHINESE_SIMPLIFIED; sal_Int16 nTargetLang = bToSimplified ? LANGUAGE_CHINESE_SIMPLIFIED : LANGUAGE_CHINESE_TRADITIONAL; sal_Int32 nOptions = bUseVariants ? i18n::TextConversionOption::USE_CHARACTER_VARIANTS : 0; if( !bCommonTerms ) nOptions = nOptions | i18n::TextConversionOption::CHARACTER_BY_CHARACTER; Font aTargetFont = GetEditWin().GetDefaultFont( DEFAULTFONT_CJK_TEXT, nTargetLang, DEFAULTFONT_FLAGS_ONLYONE ); // disallow formatting, updating the view, ... while // converting the document. (saves time) // Also remember the current view and cursor position for later pWrtShell->StartAction(); // remember cursor position data for later restoration of the cursor const SwPosition *pPoint = pWrtShell->GetCrsr()->GetPoint(); sal_Bool bRestoreCursor = pPoint->nNode.GetNode().IsTxtNode(); const SwNodeIndex aPointNodeIndex( pPoint->nNode ); xub_StrLen nPointIndex = pPoint->nContent.GetIndex();; // since this conversion is not interactive the whole converted // document should be undone in a single undo step. pWrtShell->StartUndo( UNDO_OVERWRITE ); StartTextConversion( nSourceLang, nTargetLang, &aTargetFont, nOptions, sal_False ); pWrtShell->EndUndo( UNDO_OVERWRITE ); if (bRestoreCursor) { SwTxtNode *pTxtNode = aPointNodeIndex.GetNode().GetTxtNode(); // check for unexpected error case DBG_ASSERT( pTxtNode && pTxtNode->GetTxt().Len() >= nPointIndex, "text missing: corrupted node?" ); if (!pTxtNode || pTxtNode->GetTxt().Len() < nPointIndex) nPointIndex = 0; // restore cursor to its original position pWrtShell->GetCrsr()->GetPoint()->nContent.Assign( pTxtNode, nPointIndex ); } // enable all, restore view and cursor position pWrtShell->EndAction(); } } Reference< lang::XComponent > xComponent( xDialog, UNO_QUERY ); if( xComponent.is() ) xComponent->dispose(); } } break; } case FN_HYPHENATE_OPT_DLG: HyphenateDocument(); break; default: ASSERT(sal_False, "wrong dispatcher"); return; } } /*-------------------------------------------------------------------- Description: start language specific text conversion --------------------------------------------------------------------*/ void SwView::StartTextConversion( LanguageType nSourceLang, LanguageType nTargetLang, const Font *pTargetFont, sal_Int32 nOptions, sal_Bool bIsInteractive ) { // do not do text conversion if it is active elsewhere if (GetWrtShell().HasConvIter()) { return; } SpellKontext(sal_True); const SwViewOption* pVOpt = pWrtShell->GetViewOptions(); const sal_Bool bOldIdle = pVOpt->IsIdle(); pVOpt->SetIdle( sal_False ); sal_Bool bOldIns = pWrtShell->IsInsMode(); pWrtShell->SetInsMode( sal_True ); sal_Bool bSelection = ((SwCrsrShell*)pWrtShell)->HasSelection() || pWrtShell->GetCrsr() != pWrtShell->GetCrsr()->GetNext(); sal_Bool bStart = bSelection || pWrtShell->IsStartOfDoc(); sal_Bool bOther = !bSelection && !(pWrtShell->GetFrmType(0,sal_True) & FRMTYPE_BODY); { const uno::Reference< lang::XMultiServiceFactory > xMgr( comphelper::getProcessServiceFactory() ); SwHHCWrapper aWrap( this, xMgr, nSourceLang, nTargetLang, pTargetFont, nOptions, bIsInteractive, bStart, bOther, bSelection ); aWrap.Convert(); } pWrtShell->SetInsMode( bOldIns ); pVOpt->SetIdle( bOldIdle ); SpellKontext(sal_False); } /*-------------------------------------------------------------------- spellcheck and text conversion related stuff --------------------------------------------------------------------*/ void SwView::SpellStart( SvxSpellArea eWhich, sal_Bool bStartDone, sal_Bool bEndDone, SwConversionArgs *pConvArgs ) { Reference< beans::XPropertySet > xProp( ::GetLinguPropertySet() ); sal_Bool bIsWrapReverse = (!pConvArgs && xProp.is()) ? *(sal_Bool*)xProp->getPropertyValue( C2U(UPN_IS_WRAP_REVERSE) ).getValue() : sal_False; SwDocPositions eStart = DOCPOS_START; SwDocPositions eEnde = DOCPOS_END; SwDocPositions eCurr = DOCPOS_CURR; switch ( eWhich ) { case SVX_SPELL_BODY: if( bIsWrapReverse ) eCurr = DOCPOS_END; else eCurr = DOCPOS_START; break; case SVX_SPELL_BODY_END: if( bIsWrapReverse ) { if( bStartDone ) eStart = DOCPOS_CURR; eCurr = DOCPOS_END; } else if( bStartDone ) eCurr = DOCPOS_START; break; case SVX_SPELL_BODY_START: if( !bIsWrapReverse ) { if( bEndDone ) eEnde = DOCPOS_CURR; eCurr = DOCPOS_START; } else if( bEndDone ) eCurr = DOCPOS_END; break; case SVX_SPELL_OTHER: if( bIsWrapReverse ) { eStart = DOCPOS_OTHERSTART; eEnde = DOCPOS_OTHEREND; eCurr = DOCPOS_OTHEREND; } else { eStart = DOCPOS_OTHERSTART; eEnde = DOCPOS_OTHEREND; eCurr = DOCPOS_OTHERSTART; } break; default: ASSERT( sal_False, "SpellStart with unknown Area" ); } pWrtShell->SpellStart( eStart, eEnde, eCurr, pConvArgs ); } /*-------------------------------------------------------------------- Beschreibung: Fehlermeldung beim Spelling --------------------------------------------------------------------*/ // Der uebergebene Pointer nLang ist selbst der Wert IMPL_LINK( SwView, SpellError, LanguageType *, pLang ) { #if OSL_DEBUG_LEVEL > 1 sal_Bool bFocus = GetEditWin().HasFocus(); #endif sal_uInt16 nPend = 0; if ( pWrtShell->ActionPend() ) { pWrtShell->Push(); pWrtShell->ClearMark(); do { pWrtShell->EndAction(); ++nPend; } while( pWrtShell->ActionPend() ); } LanguageType eLang = pLang ? *pLang : LANGUAGE_NONE; String aErr(SvtLanguageTable::GetLanguageString( eLang ) ); SwEditWin &rEditWin = GetEditWin(); #if OSL_DEBUG_LEVEL > 1 bFocus = rEditWin.HasFocus(); #endif sal_uInt16 nWaitCnt = 0; while( rEditWin.IsWait() ) { rEditWin.LeaveWait(); ++nWaitCnt; } if ( LANGUAGE_NONE == eLang ) ErrorHandler::HandleError( ERRCODE_SVX_LINGU_NOLANGUAGE ); else ErrorHandler::HandleError( *new StringErrorInfo( ERRCODE_SVX_LINGU_LANGUAGENOTEXISTS, aErr ) ); while( nWaitCnt ) { rEditWin.EnterWait(); --nWaitCnt; } #if OSL_DEBUG_LEVEL > 1 bFocus = GetEditWin().HasFocus(); #endif if ( nPend ) { while( nPend-- ) pWrtShell->StartAction(); pWrtShell->Combine(); } #if OSL_DEBUG_LEVEL > 1 if( !bFocus ) GetEditWin().GrabFocus(); #endif return 0; } /*-------------------------------------------------------------------- Beschreibung: Spelling beenden und Cursor wiederherstellen --------------------------------------------------------------------*/ void SwView::SpellEnd( SwConversionArgs *pConvArgs ) { pWrtShell->SpellEnd( pConvArgs ); if( pWrtShell->IsExtMode() ) pWrtShell->SetMark(); } void SwView::HyphStart( SvxSpellArea eWhich ) { switch ( eWhich ) { case SVX_SPELL_BODY: pWrtShell->HyphStart( DOCPOS_START, DOCPOS_END ); break; case SVX_SPELL_BODY_END: pWrtShell->HyphStart( DOCPOS_CURR, DOCPOS_END ); break; case SVX_SPELL_BODY_START: pWrtShell->HyphStart( DOCPOS_START, DOCPOS_CURR ); break; case SVX_SPELL_OTHER: pWrtShell->HyphStart( DOCPOS_OTHERSTART, DOCPOS_OTHEREND ); break; default: ASSERT( sal_False, "HyphStart with unknown Area" ); } } /*-------------------------------------------------------------------- Beschreibung: Interaktive Trennung --------------------------------------------------------------------*/ void SwView::HyphenateDocument() { // do not hyphenate if interactive hyphenationg is active elsewhere if (GetWrtShell().HasHyphIter()) { MessBox( 0, WB_OK, String( SW_RES( STR_HYPH_TITLE ) ), String( SW_RES( STR_MULT_INTERACT_HYPH_WARN ) ) ).Execute(); return; } SfxErrorContext aContext( ERRCTX_SVX_LINGU_HYPHENATION, aEmptyStr, pEditWin, RID_SVXERRCTX, &DIALOG_MGR() ); Reference< XHyphenator > xHyph( ::GetHyphenator() ); if (!xHyph.is()) { ErrorHandler::HandleError( ERRCODE_SVX_LINGU_LINGUNOTEXISTS ); return; } if (pWrtShell->GetSelectionType() & (nsSelectionType::SEL_DRW_TXT|nsSelectionType::SEL_DRW)) { // Silbentrennung in einem Draw-Objekt HyphenateDrawText(); } else { SwViewOption* pVOpt = (SwViewOption*)pWrtShell->GetViewOptions(); sal_Bool bOldIdle = pVOpt->IsIdle(); pVOpt->SetIdle( sal_False ); Reference< beans::XPropertySet > xProp( ::GetLinguPropertySet() ); pWrtShell->StartUndo(UNDO_INSATTR); // spaeter gueltig sal_Bool bHyphSpecial = xProp.is() ? *(sal_Bool*)xProp->getPropertyValue( C2U(UPN_IS_HYPH_SPECIAL) ).getValue() : sal_False; sal_Bool bSelection = ((SwCrsrShell*)pWrtShell)->HasSelection() || pWrtShell->GetCrsr() != pWrtShell->GetCrsr()->GetNext(); sal_Bool bOther = pWrtShell->HasOtherCnt() && bHyphSpecial && !bSelection; sal_Bool bStart = bSelection || ( !bOther && pWrtShell->IsStartOfDoc() ); sal_Bool bStop = sal_False; if( !bOther && !(pWrtShell->GetFrmType(0,sal_True) & FRMTYPE_BODY) && !bSelection ) // kein Sonderbereich eingeschaltet { // Ich will auch in Sonderbereichen trennen QueryBox aBox( &GetEditWin(), SW_RES( DLG_SPECIAL_FORCED ) ); if( aBox.Execute() == RET_YES ) { bOther = sal_True; if (xProp.is()) { sal_Bool bTrue = sal_True; Any aTmp(&bTrue, ::getBooleanCppuType()); xProp->setPropertyValue( C2U(UPN_IS_HYPH_SPECIAL), aTmp ); } } else bStop = sal_True; // Nein Es wird nicht getrennt } if( !bStop ) { SwHyphWrapper aWrap( this, xHyph, bStart, bOther, bSelection ); aWrap.SpellDocument(); pWrtShell->EndUndo(UNDO_INSATTR); } pVOpt->SetIdle( bOldIdle ); } } /*-------------------------------------------------------------------- --------------------------------------------------------------------*/ bool SwView::IsValidSelectionForThesaurus() const { // must not be a multi-selection, and if it is a selection it needs // to be within a single paragraph const bool bMultiSel = pWrtShell->GetCrsr() != pWrtShell->GetCrsr()->GetNext(); const sal_Bool bSelection = ((SwCrsrShell*)pWrtShell)->HasSelection(); return !bMultiSel && (!bSelection || pWrtShell->IsSelOnePara() ); } String SwView::GetThesaurusLookUpText( bool bSelection ) const { return bSelection ? pWrtShell->GetSelTxt() : pWrtShell->GetCurWord(); } void SwView::InsertThesaurusSynonym( const String &rSynonmText, const String &rLookUpText, bool bSelection ) { sal_Bool bOldIns = pWrtShell->IsInsMode(); pWrtShell->SetInsMode( sal_True ); pWrtShell->StartAllAction(); pWrtShell->StartUndo(UNDO_DELETE); if( !bSelection ) { if(pWrtShell->IsEndWrd()) pWrtShell->Left(CRSR_SKIP_CELLS, sal_False, 1, sal_False ); pWrtShell->SelWrd(); // make sure the selection build later from the // data below does not include footnotes and other // "in word" character to the left and right in order // to preserve those. Therefore count those "in words" // in order to modify the selection accordingly. const sal_Unicode* pChar = rLookUpText.GetBuffer(); xub_StrLen nLeft = 0; while (pChar && *pChar++ == CH_TXTATR_INWORD) ++nLeft; pChar = rLookUpText.Len() ? rLookUpText.GetBuffer() + rLookUpText.Len() - 1 : 0; xub_StrLen nRight = 0; while (pChar && *pChar-- == CH_TXTATR_INWORD) ++nRight; // adjust existing selection SwPaM *pCrsr = pWrtShell->GetCrsr(); pCrsr->GetPoint()->nContent/*.nIndex*/ -= nRight; pCrsr->GetMark()->nContent/*.nIndex*/ += nLeft; } pWrtShell->Insert( rSynonmText ); pWrtShell->EndUndo(UNDO_DELETE); pWrtShell->EndAllAction(); pWrtShell->SetInsMode( bOldIns ); } /*-------------------------------------------------------------------- Beschreibung: Thesaurus starten --------------------------------------------------------------------*/ void SwView::StartThesaurus() { if (!IsValidSelectionForThesaurus()) return; SfxErrorContext aContext( ERRCTX_SVX_LINGU_THESAURUS, aEmptyStr, pEditWin, RID_SVXERRCTX, &DIALOG_MGR() ); // Sprache rausholen // LanguageType eLang = pWrtShell->GetCurLang(); if( LANGUAGE_SYSTEM == eLang ) eLang = GetAppLanguage(); if( eLang == LANGUAGE_DONTKNOW || eLang == LANGUAGE_NONE ) { LanguageType nLanguage = LANGUAGE_NONE; SpellError( &nLanguage ); return; } SwViewOption* pVOpt = (SwViewOption*)pWrtShell->GetViewOptions(); sal_Bool bOldIdle = pVOpt->IsIdle(); pVOpt->SetIdle( sal_False ); // get initial LookUp text const sal_Bool bSelection = ((SwCrsrShell*)pWrtShell)->HasSelection(); String aTmp = GetThesaurusLookUpText( bSelection ); Reference< XThesaurus > xThes( ::GetThesaurus() ); AbstractThesaurusDialog *pDlg = NULL; if ( !xThes.is() || !xThes->hasLocale( SvxCreateLocale( eLang ) ) ) SpellError( &eLang ); else { // create dialog { //Scope for SwWait-Object SwWait aWait( *GetDocShell(), true ); // load library with dialog only on demand ... SvxAbstractDialogFactory* pFact = SvxAbstractDialogFactory::Create(); pDlg = pFact->CreateThesaurusDialog( &GetEditWin(), xThes, aTmp, eLang ); } if ( pDlg->Execute()== RET_OK ) InsertThesaurusSynonym( pDlg->GetWord(), aTmp, bSelection ); } delete pDlg; pVOpt->SetIdle( bOldIdle ); } /*-------------------------------------------------------------------- Beschreibung: Online-Vorschlaege anbieten *--------------------------------------------------------------------*/ //!! Start of extra code for context menu modifying extensions struct ExecuteInfo { uno::Reference< frame::XDispatch > xDispatch; util::URL aTargetURL; uno::Sequence< PropertyValue > aArgs; }; class AsyncExecute { public: DECL_STATIC_LINK( AsyncExecute, ExecuteHdl_Impl, ExecuteInfo* ); }; IMPL_STATIC_LINK_NOINSTANCE( AsyncExecute, ExecuteHdl_Impl, ExecuteInfo*, pExecuteInfo ) { const sal_uInt32 nRef = Application::ReleaseSolarMutex(); try { // Asynchronous execution as this can lead to our own destruction! // Framework can recycle our current frame and the layout manager disposes all user interface // elements if a component gets detached from its frame! pExecuteInfo->xDispatch->dispatch( pExecuteInfo->aTargetURL, pExecuteInfo->aArgs ); } catch ( Exception& ) { } Application::AcquireSolarMutex( nRef ); delete pExecuteInfo; return 0; } //!! End of extra code for context menu modifying extensions sal_Bool SwView::ExecSpellPopup(const Point& rPt) { sal_Bool bRet = sal_False; const SwViewOption* pVOpt = pWrtShell->GetViewOptions(); if( pVOpt->IsOnlineSpell() && !pWrtShell->IsSelection()) { if (pWrtShell->GetSelectionType() & nsSelectionType::SEL_DRW_TXT) bRet = ExecDrwTxtSpellPopup(rPt); else if (!pWrtShell->IsSelFrmMode()) { const sal_Bool bOldViewLock = pWrtShell->IsViewLocked(); pWrtShell->LockView( sal_True ); pWrtShell->Push(); SwRect aToFill; // decide which variant of the context menu to use... // if neither spell checking nor grammar checking provides suggestions use the // default context menu. bool bUseGrammarContext = false; Reference< XSpellAlternatives > xAlt( pWrtShell->GetCorrection(&rPt, aToFill) ); /*linguistic2::*/ProofreadingResult aGrammarCheckRes; sal_Int32 nErrorPosInText = -1; sal_Int32 nErrorInResult = -1; uno::Sequence< rtl::OUString > aSuggestions; bool bCorrectionRes = false; if (!xAlt.is() || xAlt->getAlternatives().getLength() == 0) { bCorrectionRes = pWrtShell->GetGrammarCorrection( aGrammarCheckRes, nErrorPosInText, nErrorInResult, aSuggestions, &rPt, aToFill ); ::rtl::OUString aMessageText; if (nErrorInResult >= 0) aMessageText = aGrammarCheckRes.aErrors[ nErrorInResult ].aShortComment; // we like to use the grammar checking context menu if we either get // some suggestions or at least a comment about the error found... bUseGrammarContext = bCorrectionRes && (aSuggestions.getLength() > 0 || aMessageText.getLength() > 0); } // open respective context menu for spell check or grammar errors with correction suggestions... if ((!bUseGrammarContext && xAlt.is()) || (bUseGrammarContext && bCorrectionRes && aGrammarCheckRes.aErrors.getLength() > 0)) { // get paragraph text String aParaText; SwPosition aPoint( *pWrtShell->GetCrsr()->GetPoint() ); const SwTxtNode *pNode = dynamic_cast< const SwTxtNode * >( &aPoint.nNode.GetNode() ); if (pNode) aParaText = pNode->GetTxt(); // this may include hidden text but that should be Ok else { DBG_ERROR( "text node expected but not found" ); } bRet = sal_True; pWrtShell->SttSelect(); std::auto_ptr< SwSpellPopup > pPopup; if (bUseGrammarContext) { sal_Int32 nPos = aPoint.nContent.GetIndex(); (void) nPos; pPopup = std::auto_ptr< SwSpellPopup >(new SwSpellPopup( pWrtShell, aGrammarCheckRes, nErrorInResult, aSuggestions, aParaText )); } else pPopup = std::auto_ptr< SwSpellPopup >(new SwSpellPopup( pWrtShell, xAlt, aParaText )); ui::ContextMenuExecuteEvent aEvent; const Point aPixPos = GetEditWin().LogicToPixel( rPt ); aEvent.SourceWindow = VCLUnoHelper::GetInterface( pEditWin ); aEvent.ExecutePosition.X = aPixPos.X(); aEvent.ExecutePosition.Y = aPixPos.Y(); Menu* pMenu = 0; ::rtl::OUString sMenuName = ::rtl::OUString::createFromAscii( bUseGrammarContext ? "private:resource/GrammarContextMenu" : "private:resource/SpellContextMenu"); if(TryContextMenuInterception( *pPopup, sMenuName, pMenu, aEvent )) { //! happy hacking for context menu modifying extensions of this //! 'custom made' menu... *sigh* (code copied from sfx2 and framework) if ( pMenu ) { OUString aSlotURL( RTL_CONSTASCII_USTRINGPARAM( "slot:" )); sal_uInt16 nId = ((PopupMenu*)pMenu)->Execute(pEditWin, aPixPos); OUString aCommand = ((PopupMenu*)pMenu)->GetItemCommand(nId); if (aCommand.getLength() == 0 ) { if(!ExecuteMenuCommand( *dynamic_cast(pMenu), *GetViewFrame(), nId )) pPopup->Execute(nId); } else { SfxViewFrame *pSfxViewFrame = GetViewFrame(); uno::Reference< frame::XFrame > xFrame; if ( pSfxViewFrame ) xFrame = pSfxViewFrame->GetFrame().GetFrameInterface(); com::sun::star::util::URL aURL; uno::Reference< frame::XDispatchProvider > xDispatchProvider( xFrame, UNO_QUERY ); uno::Reference< lang::XMultiServiceFactory > xMgr( utl::getProcessServiceFactory(), uno::UNO_QUERY ); try { uno::Reference< frame::XDispatch > xDispatch; uno::Reference< util::XURLTransformer > xURLTransformer; if (xMgr.is()) { xURLTransformer = uno::Reference< util::XURLTransformer >( xMgr->createInstance( C2U("com.sun.star.util.URLTransformer")), UNO_QUERY); } aURL.Complete = aCommand; xURLTransformer->parseStrict(aURL); uno::Sequence< beans::PropertyValue > aArgs; xDispatch = xDispatchProvider->queryDispatch( aURL, rtl::OUString(), 0 ); if (xDispatch.is()) { // Execute dispatch asynchronously ExecuteInfo* pExecuteInfo = new ExecuteInfo; pExecuteInfo->xDispatch = xDispatch; pExecuteInfo->aTargetURL = aURL; pExecuteInfo->aArgs = aArgs; Application::PostUserEvent( STATIC_LINK(0, AsyncExecute , ExecuteHdl_Impl), pExecuteInfo ); } } catch (Exception &) { } } } else { pPopup->Execute( aToFill.SVRect(), pEditWin ); } } } pWrtShell->Pop( sal_False ); pWrtShell->LockView( bOldViewLock ); } } return bRet; } /** Function: ExecSmartTagPopup This function shows the popup menu for smarttag actions. */ sal_Bool SwView::ExecSmartTagPopup( const Point& rPt ) { sal_Bool bRet = sal_False; const sal_Bool bOldViewLock = pWrtShell->IsViewLocked(); pWrtShell->LockView( sal_True ); pWrtShell->Push(); // get word that was clicked on // This data structure maps a smart tag type string to the property bag SwRect aToFill; Sequence< rtl::OUString > aSmartTagTypes; Sequence< Reference< container::XStringKeyMap > > aStringKeyMaps; Reference xRange; pWrtShell->GetSmartTagTerm( rPt, aToFill, aSmartTagTypes, aStringKeyMaps, xRange); if ( xRange.is() && aSmartTagTypes.getLength() ) { bRet = sal_True; pWrtShell->SttSelect(); SwSmartTagPopup aPopup( this, aSmartTagTypes, aStringKeyMaps, xRange ); aPopup.Execute( aToFill.SVRect(), pEditWin ); } pWrtShell->Pop( sal_False ); pWrtShell->LockView( bOldViewLock ); return bRet; } class SwFieldPopup : public PopupMenu { public: SwFieldPopup() { InsertItem(1, ::rtl::OUString::createFromAscii("Hello")); } }; class SwFieldListBox : public ListBox { public: SwFieldListBox(Window* pParent) : ListBox(pParent /*, WB_DROPDOWN*/) { } void *GetImplWin() { return NULL; //FIXME!!! // return mpImplWin; } protected: virtual void LoseFocus() { // printf("ListBox: lose focus!!\n"); ListBox::LoseFocus(); } virtual void Select() { // printf("SELECT!!! IsTravelSelect=%i\n", IsTravelSelect()); ListBox::Select(); } }; class SwFieldDialog : public Dialog { private: SwFieldListBox aListBox; Edit aText; int selection; DECL_LINK( MyListBoxHandler, ListBox * ); public: SwFieldDialog(Window* parent, IFieldmark *fieldBM) : Dialog(parent, WB_BORDER | WB_SYSTEMWINDOW | WB_NOSHADOW ), aListBox(this), aText(this, WB_RIGHT | WB_READONLY), selection(-1) { assert(fieldBM!=NULL); if (fieldBM!=NULL) { const IFieldmark::parameter_map_t* const pParameters = fieldBM->GetParameters(); IFieldmark::parameter_map_t::const_iterator pListEntries = pParameters->find(::rtl::OUString::createFromAscii(ODF_FORMDROPDOWN_LISTENTRY)); if(pListEntries != pParameters->end()) { Sequence< ::rtl::OUString> vListEntries; pListEntries->second >>= vListEntries; for( ::rtl::OUString* pCurrent = vListEntries.getArray(); pCurrent != vListEntries.getArray() + vListEntries.getLength(); ++pCurrent) { aListBox.InsertEntry(*pCurrent); } } } Size lbSize=aListBox.GetOptimalSize(WINDOWSIZE_PREFERRED); lbSize.Width()+=50; lbSize.Height()+=20; aListBox.SetSizePixel(lbSize); aListBox.SetSelectHdl( LINK( this, SwFieldDialog, MyListBoxHandler ) ); aListBox.Show(); aText.SetText(rtl::OUString::createFromAscii("Cancel")); Size tSize=aText.GetOptimalSize(WINDOWSIZE_PREFERRED); aText.SetSizePixel(Size(lbSize.Width(), tSize.Height())); aText.SetPosPixel(Point(0, lbSize.Height())); aText.Show(); SetSizePixel(Size(lbSize.Width(), lbSize.Height()+tSize.Height())); // SetSizePixel(Size(200, 200)); } int getSelection() { return selection; } protected: /* virtual void LoseFocus() { printf("lose focus!!\n"); Dialog::LoseFocus(); printf("close:\n"); EndDialog(8); } */ virtual long PreNotify( NotifyEvent& rNEvt ) { if (rNEvt.GetType() == EVENT_LOSEFOCUS && aListBox.GetImplWin()==rNEvt.GetWindow()) { EndDialog(8); return 1; } if (rNEvt.GetType() == EVENT_KEYINPUT) { // printf("PreNotify::KEYINPUT\n"); } return Dialog::PreNotify(rNEvt); } }; IMPL_LINK( SwFieldDialog, MyListBoxHandler, ListBox *, pBox ) { // printf("### DROP DOWN SELECT... IsTravelSelect=%i\n", pBox->IsTravelSelect()); if (pBox->IsTravelSelect()) { return 0; } else { this->selection=pBox->GetSelectEntryPos(); EndDialog(9); //@TODO have meaningful returns... return 1; } } sal_Bool SwView::ExecFieldPopup( const Point& rPt, IFieldmark *fieldBM ) { sal_Bool bRet = sal_False; const sal_Bool bOldViewLock = pWrtShell->IsViewLocked(); pWrtShell->LockView( sal_True ); pWrtShell->Push(); bRet=sal_True; const Point aPixPos = GetEditWin().LogicToPixel( rPt ); SwFieldDialog aFldDlg(pEditWin, fieldBM); aFldDlg.SetPosPixel(pEditWin->OutputToScreenPixel(aPixPos)); /*short ret=*/aFldDlg.Execute(); sal_Int32 selection=aFldDlg.getSelection(); if (selection>=0) { (*fieldBM->GetParameters())[::rtl::OUString::createFromAscii(ODF_FORMDROPDOWN_RESULT)] = makeAny(selection); } pWrtShell->Pop( sal_False ); pWrtShell->LockView( bOldViewLock ); return bRet; }