| /************************************************************** | |
| * | |
| * 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_cui.hxx" | |
| #include <memory> | |
| #include <sfx2/objsh.hxx> | |
| #include <vcl/svapp.hxx> | |
| #include <vcl/msgbox.hxx> | |
| #include <vos/mutex.hxx> | |
| #include <cuires.hrc> | |
| #include "scriptdlg.hrc" | |
| #include "scriptdlg.hxx" | |
| #include <dialmgr.hxx> | |
| #include "selector.hxx" | |
| #include <com/sun/star/uno/XComponentContext.hpp> | |
| #include <com/sun/star/frame/XDesktop.hpp> | |
| #include <com/sun/star/script/XInvocation.hpp> | |
| #include <com/sun/star/script/provider/XScriptProviderSupplier.hpp> | |
| #include <com/sun/star/script/provider/XScriptProvider.hpp> | |
| #include <com/sun/star/script/browse/BrowseNodeTypes.hpp> | |
| #include <com/sun/star/script/browse/XBrowseNodeFactory.hpp> | |
| #include <com/sun/star/script/browse/BrowseNodeFactoryViewTypes.hpp> | |
| #include <com/sun/star/script/provider/ScriptErrorRaisedException.hpp> | |
| #include <com/sun/star/script/provider/ScriptExceptionRaisedException.hpp> | |
| #include <com/sun/star/script/provider/ScriptFrameworkErrorType.hpp> | |
| #include <com/sun/star/frame/XModuleManager.hpp> | |
| #include <com/sun/star/script/XInvocation.hpp> | |
| #include <com/sun/star/document/XEmbeddedScripts.hpp> | |
| #include <cppuhelper/implbase1.hxx> | |
| #include <comphelper/documentinfo.hxx> | |
| #include <comphelper/uno3.hxx> | |
| #include <comphelper/processfactory.hxx> | |
| #include <comphelper/broadcasthelper.hxx> | |
| #include <comphelper/propertycontainer.hxx> | |
| #include <comphelper/proparrhlp.hxx> | |
| #include <basic/sbx.hxx> | |
| #include <svtools/imagemgr.hxx> | |
| #include <tools/urlobj.hxx> | |
| #include <vector> | |
| #include <algorithm> | |
| using namespace ::com::sun::star; | |
| using namespace ::com::sun::star::uno; | |
| using namespace ::com::sun::star::script; | |
| using namespace ::com::sun::star::frame; | |
| using namespace ::com::sun::star::document; | |
| void ShowErrorDialog( const Any& aException ) | |
| { | |
| SvxScriptErrorDialog* pDlg = new SvxScriptErrorDialog( NULL, aException ); | |
| pDlg->Execute(); | |
| delete pDlg; | |
| } | |
| SFTreeListBox::SFTreeListBox( Window* pParent, const ResId& rResId ) : | |
| SvTreeListBox( pParent, ResId( rResId.GetId(),*rResId.GetResMgr() ) ), | |
| m_hdImage(ResId(IMG_HARDDISK,*rResId.GetResMgr())), | |
| m_hdImage_hc(ResId(IMG_HARDDISK_HC,*rResId.GetResMgr())), | |
| m_libImage(ResId(IMG_LIB,*rResId.GetResMgr())), | |
| m_libImage_hc(ResId(IMG_LIB_HC,*rResId.GetResMgr())), | |
| m_macImage(ResId(IMG_MACRO,*rResId.GetResMgr())), | |
| m_macImage_hc(ResId(IMG_MACRO_HC,*rResId.GetResMgr())), | |
| m_docImage(ResId(IMG_DOCUMENT,*rResId.GetResMgr())), | |
| m_docImage_hc(ResId(IMG_DOCUMENT_HC,*rResId.GetResMgr())), | |
| m_sMyMacros(String(ResId(STR_MYMACROS,*rResId.GetResMgr()))), | |
| m_sProdMacros(String(ResId(STR_PRODMACROS,*rResId.GetResMgr()))) | |
| { | |
| FreeResource(); | |
| SetSelectionMode( SINGLE_SELECTION ); | |
| SetStyle( GetStyle() | WB_CLIPCHILDREN | WB_HSCROLL | | |
| WB_HASBUTTONS | WB_HASBUTTONSATROOT | WB_HIDESELECTION | | |
| WB_HASLINES | WB_HASLINESATROOT ); | |
| SetNodeDefaultImages(); | |
| nMode = 0xFF; // Alles | |
| } | |
| SFTreeListBox::~SFTreeListBox() | |
| { | |
| deleteAllTree(); | |
| } | |
| void SFTreeListBox::delUserData( SvLBoxEntry* pEntry ) | |
| { | |
| if ( pEntry ) | |
| { | |
| String text = GetEntryText( pEntry ); | |
| SFEntry* pUserData = (SFEntry*)pEntry->GetUserData(); | |
| if ( pUserData ) | |
| { | |
| delete pUserData; | |
| // TBD seem to get a Select event on node that is remove ( below ) | |
| // so need to be able to detect that this node is not to be | |
| // processed in order to do this, setting userData to NULL ( must | |
| // be a better way to do this ) | |
| pUserData = 0; | |
| pEntry->SetUserData( pUserData ); | |
| } | |
| } | |
| } | |
| void SFTreeListBox::deleteTree( SvLBoxEntry* pEntry ) | |
| { | |
| delUserData( pEntry ); | |
| pEntry = FirstChild( pEntry ); | |
| while ( pEntry ) | |
| { | |
| SvLBoxEntry* pNextEntry = NextSibling( pEntry ); | |
| deleteTree( pEntry ); | |
| GetModel()->Remove( pEntry ); | |
| pEntry = pNextEntry; | |
| } | |
| } | |
| void SFTreeListBox::deleteAllTree() | |
| { | |
| SvLBoxEntry* pEntry = GetEntry( 0 ); | |
| // TBD - below is a candidate for a destroyAllTrees method | |
| if ( pEntry ) | |
| { | |
| while ( pEntry ) | |
| { | |
| String text = GetEntryText( pEntry ); | |
| SvLBoxEntry* pNextEntry = NextSibling( pEntry ) ; | |
| deleteTree( pEntry ); | |
| GetModel()->Remove( pEntry ); | |
| pEntry = pNextEntry; | |
| } | |
| } | |
| } | |
| void SFTreeListBox::Init( const ::rtl::OUString& language ) | |
| { | |
| SetUpdateMode( sal_False ); | |
| deleteAllTree(); | |
| Reference< browse::XBrowseNode > rootNode; | |
| Reference< XComponentContext > xCtx; | |
| Sequence< Reference< browse::XBrowseNode > > children; | |
| ::rtl::OUString userStr = ::rtl::OUString::createFromAscii("user"); | |
| ::rtl::OUString shareStr = ::rtl::OUString::createFromAscii("share"); | |
| ::rtl::OUString singleton = ::rtl::OUString::createFromAscii( | |
| "/singletons/com.sun.star.script.browse.theBrowseNodeFactory" ); | |
| try | |
| { | |
| Reference < beans::XPropertySet > xProps( | |
| ::comphelper::getProcessServiceFactory(), UNO_QUERY_THROW ); | |
| xCtx.set( xProps->getPropertyValue( rtl::OUString( | |
| RTL_CONSTASCII_USTRINGPARAM("DefaultContext" ))), UNO_QUERY_THROW ); | |
| Reference< browse::XBrowseNodeFactory > xFac( | |
| xCtx->getValueByName( singleton ), UNO_QUERY_THROW ); | |
| rootNode.set( xFac->createView( | |
| browse::BrowseNodeFactoryViewTypes::MACROORGANIZER ) ); | |
| if ( rootNode.is() && rootNode->hasChildNodes() == sal_True ) | |
| { | |
| children = rootNode->getChildNodes(); | |
| } | |
| } | |
| catch( Exception& e ) | |
| { | |
| OSL_TRACE("Exception getting root browse node from factory: %s", | |
| ::rtl::OUStringToOString( | |
| e.Message , RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| // TODO exception handling | |
| } | |
| Reference<XModel> xDocumentModel; | |
| for ( sal_Int32 n = 0; n < children.getLength(); n++ ) | |
| { | |
| bool app = false; | |
| ::rtl::OUString uiName = children[ n ]->getName(); | |
| ::rtl::OUString factoryURL; | |
| if ( uiName.equals( userStr ) || uiName.equals( shareStr ) ) | |
| { | |
| app = true; | |
| if ( uiName.equals( userStr ) ) | |
| { | |
| uiName = m_sMyMacros; | |
| } | |
| else | |
| { | |
| uiName = m_sProdMacros; | |
| } | |
| } | |
| else | |
| { | |
| xDocumentModel.set(getDocumentModel(xCtx, uiName ), UNO_QUERY); | |
| if ( xDocumentModel.is() ) | |
| { | |
| Reference< ::com::sun::star::frame::XModuleManager > | |
| xModuleManager( xCtx->getServiceManager()->createInstanceWithContext( | |
| ::rtl::OUString::createFromAscii("com.sun.star.frame.ModuleManager"), xCtx ), | |
| UNO_QUERY_THROW ); | |
| Reference<container::XNameAccess> xModuleConfig( | |
| xModuleManager, UNO_QUERY_THROW ); | |
| // get the long name of the document: | |
| Sequence<beans::PropertyValue> moduleDescr; | |
| try{ | |
| ::rtl::OUString appModule = xModuleManager->identify( xDocumentModel ); | |
| xModuleConfig->getByName(appModule) >>= moduleDescr; | |
| } catch(const uno::Exception&) | |
| {} | |
| beans::PropertyValue const * pmoduleDescr = | |
| moduleDescr.getConstArray(); | |
| for ( sal_Int32 pos = moduleDescr.getLength(); pos--; ) | |
| { | |
| if (pmoduleDescr[ pos ].Name.equalsAsciiL( | |
| RTL_CONSTASCII_STRINGPARAM( | |
| "ooSetupFactoryEmptyDocumentURL") )) | |
| { | |
| pmoduleDescr[ pos ].Value >>= factoryURL; | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| ::rtl::OUString lang( language ); | |
| Reference< browse::XBrowseNode > langEntries = | |
| getLangNodeFromRootNode( children[ n ], lang ); | |
| /*SvLBoxEntry* pBasicManagerRootEntry =*/ | |
| insertEntry( uiName, app ? IMG_HARDDISK : IMG_DOCUMENT, | |
| 0, true, std::auto_ptr< SFEntry >(new SFEntry( OBJTYPE_SFROOT, langEntries, xDocumentModel )), factoryURL ); | |
| } | |
| SetUpdateMode( sal_True ); | |
| } | |
| Reference< XInterface > | |
| SFTreeListBox::getDocumentModel( Reference< XComponentContext >& xCtx, ::rtl::OUString& docName ) | |
| { | |
| Reference< XInterface > xModel; | |
| Reference< lang::XMultiComponentFactory > mcf = | |
| xCtx->getServiceManager(); | |
| Reference< frame::XDesktop > desktop ( | |
| mcf->createInstanceWithContext( | |
| ::rtl::OUString::createFromAscii("com.sun.star.frame.Desktop"), xCtx ), | |
| UNO_QUERY ); | |
| Reference< container::XEnumerationAccess > componentsAccess = | |
| desktop->getComponents(); | |
| Reference< container::XEnumeration > components = | |
| componentsAccess->createEnumeration(); | |
| while (components->hasMoreElements()) | |
| { | |
| Reference< frame::XModel > model( | |
| components->nextElement(), UNO_QUERY ); | |
| if ( model.is() ) | |
| { | |
| ::rtl::OUString sTdocUrl = ::comphelper::DocumentInfo::getDocumentTitle( model ); | |
| if( sTdocUrl.equals( docName ) ) | |
| { | |
| xModel = model; | |
| break; | |
| } | |
| } | |
| } | |
| return xModel; | |
| } | |
| Reference< browse::XBrowseNode > | |
| SFTreeListBox::getLangNodeFromRootNode( Reference< browse::XBrowseNode >& rootNode, ::rtl::OUString& language ) | |
| { | |
| Reference< browse::XBrowseNode > langNode; | |
| try | |
| { | |
| Sequence < Reference< browse::XBrowseNode > > children = rootNode->getChildNodes(); | |
| for ( sal_Int32 n = 0; n < children.getLength(); n++ ) | |
| { | |
| if ( children[ n ]->getName().equals( language ) ) | |
| { | |
| langNode = children[ n ]; | |
| break; | |
| } | |
| } | |
| } | |
| catch ( Exception& ) | |
| { | |
| // if getChildNodes() throws an exception we just return | |
| // the empty Reference | |
| } | |
| return langNode; | |
| } | |
| void SFTreeListBox:: RequestSubEntries( SvLBoxEntry* pRootEntry, Reference< ::com::sun::star::script::browse::XBrowseNode >& node, | |
| Reference< XModel >& model ) | |
| { | |
| if (! node.is() ) | |
| { | |
| return; | |
| } | |
| Sequence< Reference< browse::XBrowseNode > > children; | |
| try | |
| { | |
| children = node->getChildNodes(); | |
| } | |
| catch ( Exception& ) | |
| { | |
| // if we catch an exception in getChildNodes then no entries are added | |
| } | |
| for ( sal_Int32 n = 0; n < children.getLength(); n++ ) | |
| { | |
| ::rtl::OUString name( children[ n ]->getName() ); | |
| if ( children[ n ]->getType() != browse::BrowseNodeTypes::SCRIPT) | |
| { | |
| insertEntry( name, IMG_LIB, pRootEntry, true, std::auto_ptr< SFEntry >(new SFEntry( OBJTYPE_SCRIPTCONTAINER, children[ n ],model ))); | |
| } | |
| else | |
| { | |
| if ( children[ n ]->getType() == browse::BrowseNodeTypes::SCRIPT ) | |
| { | |
| insertEntry( name, IMG_MACRO, pRootEntry, false, std::auto_ptr< SFEntry >(new SFEntry( OBJTYPE_METHOD, children[ n ],model ))); | |
| } | |
| } | |
| } | |
| } | |
| long SFTreeListBox::ExpandingHdl() | |
| { | |
| return sal_True; | |
| } | |
| void SFTreeListBox::ExpandAllTrees() | |
| { | |
| } | |
| SvLBoxEntry * SFTreeListBox::insertEntry( | |
| String const & rText, sal_uInt16 nBitmap, SvLBoxEntry * pParent, | |
| bool bChildrenOnDemand, std::auto_ptr< SFEntry > aUserData, ::rtl::OUString factoryURL ) | |
| { | |
| SvLBoxEntry * p; | |
| if( nBitmap == IMG_DOCUMENT && factoryURL.getLength() > 0 ) | |
| { | |
| Image aImage = SvFileInformationManager::GetFileImage( | |
| INetURLObject(factoryURL), false, | |
| BMP_COLOR_NORMAL ); | |
| Image aHCImage = SvFileInformationManager::GetFileImage( | |
| INetURLObject(factoryURL), false, | |
| BMP_COLOR_HIGHCONTRAST ); | |
| p = InsertEntry( | |
| rText, aImage, aImage, pParent, bChildrenOnDemand, LIST_APPEND, | |
| aUserData.release()); // XXX possible leak | |
| SetExpandedEntryBmp(p, aHCImage, BMP_COLOR_HIGHCONTRAST); | |
| SetCollapsedEntryBmp(p, aHCImage, BMP_COLOR_HIGHCONTRAST); | |
| } | |
| else | |
| { | |
| p = insertEntry( rText, nBitmap, pParent, bChildrenOnDemand, aUserData ); | |
| } | |
| return p; | |
| } | |
| SvLBoxEntry * SFTreeListBox::insertEntry( | |
| String const & rText, sal_uInt16 nBitmap, SvLBoxEntry * pParent, | |
| bool bChildrenOnDemand, std::auto_ptr< SFEntry > aUserData ) | |
| { | |
| Image aHCImage, aImage; | |
| if( nBitmap == IMG_HARDDISK ) | |
| { | |
| aImage = m_hdImage; | |
| aHCImage = m_hdImage_hc; | |
| } | |
| else if( nBitmap == IMG_LIB ) | |
| { | |
| aImage = m_libImage; | |
| aHCImage = m_libImage_hc; | |
| } | |
| else if( nBitmap == IMG_MACRO ) | |
| { | |
| aImage = m_macImage; | |
| aHCImage = m_macImage_hc; | |
| } | |
| else if( nBitmap == IMG_DOCUMENT ) | |
| { | |
| aImage = m_docImage; | |
| aHCImage = m_docImage_hc; | |
| } | |
| SvLBoxEntry * p = InsertEntry( | |
| rText, aImage, aImage, pParent, bChildrenOnDemand, LIST_APPEND, | |
| aUserData.release()); // XXX possible leak | |
| SetExpandedEntryBmp(p, aHCImage, BMP_COLOR_HIGHCONTRAST); | |
| SetCollapsedEntryBmp(p, aHCImage, BMP_COLOR_HIGHCONTRAST); | |
| return p; | |
| } | |
| void __EXPORT SFTreeListBox::RequestingChilds( SvLBoxEntry* pEntry ) | |
| { | |
| SFEntry* userData = 0; | |
| if ( !pEntry ) | |
| { | |
| return; | |
| } | |
| userData = (SFEntry*)pEntry->GetUserData(); | |
| Reference< browse::XBrowseNode > node; | |
| Reference< XModel > model; | |
| if ( userData && !userData->isLoaded() ) | |
| { | |
| node = userData->GetNode(); | |
| model = userData->GetModel(); | |
| RequestSubEntries( pEntry, node, model ); | |
| userData->setLoaded(); | |
| } | |
| } | |
| void __EXPORT SFTreeListBox::ExpandedHdl() | |
| { | |
| /* SvLBoxEntry* pEntry = GetHdlEntry(); | |
| DBG_ASSERT( pEntry, "Was wurde zugeklappt?" ); | |
| if ( !IsExpanded( pEntry ) && pEntry->HasChildsOnDemand() ) | |
| { | |
| SvLBoxEntry* pChild = FirstChild( pEntry ); | |
| while ( pChild ) | |
| { | |
| GetModel()->Remove( pChild ); // Ruft auch den DTOR | |
| pChild = FirstChild( pEntry ); | |
| } | |
| }*/ | |
| } | |
| // ---------------------------------------------------------------------------- | |
| // InputDialog ------------------------------------------------------------ | |
| // ---------------------------------------------------------------------------- | |
| InputDialog::InputDialog(Window * pParent, sal_uInt16 nMode ) | |
| : ModalDialog( pParent, CUI_RES( RID_DLG_NEWLIB ) ), | |
| aText( this, CUI_RES( FT_NEWLIB ) ), | |
| aEdit( this, CUI_RES( ED_LIBNAME ) ), | |
| aOKButton( this, CUI_RES( PB_OK ) ), | |
| aCancelButton( this, CUI_RES( PB_CANCEL ) ) | |
| { | |
| aEdit.GrabFocus(); | |
| if ( nMode == INPUTMODE_NEWLIB ) | |
| { | |
| SetText( String( CUI_RES( STR_NEWLIB ) ) ); | |
| } | |
| else if ( nMode == INPUTMODE_NEWMACRO ) | |
| { | |
| SetText( String( CUI_RES( STR_NEWMACRO ) ) ); | |
| aText.SetText( String( CUI_RES( STR_FT_NEWMACRO ) ) ); | |
| } | |
| else if ( nMode == INPUTMODE_RENAME ) | |
| { | |
| SetText( String( CUI_RES( STR_RENAME ) ) ); | |
| aText.SetText( String( CUI_RES( STR_FT_RENAME ) ) ); | |
| } | |
| FreeResource(); | |
| // some resizing so that the text fits | |
| Point point, newPoint; | |
| Size siz, newSiz; | |
| long gap; | |
| sal_uInt16 style = TEXT_DRAW_MULTILINE | TEXT_DRAW_TOP | | |
| TEXT_DRAW_LEFT | TEXT_DRAW_WORDBREAK; | |
| // get dimensions of dialog instructions control | |
| point = aText.GetPosPixel(); | |
| siz = aText.GetSizePixel(); | |
| // get dimensions occupied by text in the control | |
| Rectangle rect = | |
| GetTextRect( Rectangle( point, siz ), aText.GetText(), style ); | |
| newSiz = rect.GetSize(); | |
| // the gap is the difference between the text width and its control width | |
| gap = siz.Height() - newSiz.Height(); | |
| //resize the text field | |
| newSiz = Size( siz.Width(), siz.Height() - gap ); | |
| aText.SetSizePixel( newSiz ); | |
| //move the OK & cancel buttons | |
| point = aEdit.GetPosPixel(); | |
| newPoint = Point( point.X(), point.Y() - gap ); | |
| aEdit.SetPosPixel( newPoint ); | |
| } | |
| InputDialog::~InputDialog() | |
| { | |
| } | |
| // ---------------------------------------------------------------------------- | |
| // ScriptOrgDialog ------------------------------------------------------------ | |
| // ---------------------------------------------------------------------------- | |
| SvxScriptOrgDialog::SvxScriptOrgDialog( Window* pParent, ::rtl::OUString language ) | |
| : SfxModalDialog( pParent, CUI_RES( RID_DLG_SCRIPTORGANIZER ) ), | |
| aScriptsTxt( this, CUI_RES( SF_TXT_SCRIPTS ) ), | |
| aScriptsBox( this, CUI_RES( SF_CTRL_SCRIPTSBOX ) ), | |
| aRunButton( this, CUI_RES( SF_PB_RUN ) ), | |
| aCloseButton( this, CUI_RES( SF_PB_CLOSE ) ), | |
| aCreateButton( this, CUI_RES( SF_PB_CREATE ) ), | |
| aEditButton( this, CUI_RES( SF_PB_EDIT ) ), | |
| aRenameButton(this, CUI_RES( SF_PB_RENAME ) ), | |
| aDelButton( this, CUI_RES( SF_PB_DEL ) ), | |
| aHelpButton( this, CUI_RES( SF_PB_HELP ) ), | |
| m_sLanguage( language ), | |
| m_delErrStr( CUI_RES( RID_SVXSTR_DELFAILED ) ), | |
| m_delErrTitleStr( CUI_RES( RID_SVXSTR_DELFAILED_TITLE ) ), | |
| m_delQueryStr( CUI_RES( RID_SVXSTR_DELQUERY ) ), | |
| m_delQueryTitleStr( CUI_RES( RID_SVXSTR_DELQUERY_TITLE ) ) , | |
| m_createErrStr( CUI_RES ( RID_SVXSTR_CREATEFAILED ) ), | |
| m_createDupStr( CUI_RES ( RID_SVXSTR_CREATEFAILEDDUP ) ), | |
| m_createErrTitleStr( CUI_RES( RID_SVXSTR_CREATEFAILED_TITLE ) ), | |
| m_renameErrStr( CUI_RES ( RID_SVXSTR_RENAMEFAILED ) ), | |
| m_renameErrTitleStr( CUI_RES( RID_SVXSTR_RENAMEFAILED_TITLE ) ) | |
| { | |
| // must be a neater way to deal with the strings than as above | |
| // append the language to the dialog title | |
| String winTitle( GetText() ); | |
| winTitle.SearchAndReplace( String::CreateFromAscii( "%MACROLANG" ), language.pData->buffer ); | |
| SetText( winTitle ); | |
| aScriptsBox.SetSelectHdl( LINK( this, SvxScriptOrgDialog, ScriptSelectHdl ) ); | |
| aRunButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aCloseButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aRenameButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aEditButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aDelButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aCreateButton.SetClickHdl( LINK( this, SvxScriptOrgDialog, ButtonHdl ) ); | |
| aRunButton.Disable(); | |
| aRenameButton.Disable(); | |
| aEditButton.Disable(); | |
| aDelButton.Disable(); | |
| aCreateButton.Disable(); | |
| aScriptsBox.Init( m_sLanguage ); | |
| RestorePreviousSelection(); | |
| FreeResource(); | |
| } | |
| __EXPORT SvxScriptOrgDialog::~SvxScriptOrgDialog() | |
| { | |
| // clear the SelectHdl so that it isn't called during the dtor | |
| aScriptsBox.SetSelectHdl( Link() ); | |
| }; | |
| short SvxScriptOrgDialog::Execute() | |
| { | |
| SfxObjectShell *pDoc = SfxObjectShell::GetFirst(); | |
| // force load of MSPs for all documents | |
| while ( pDoc ) | |
| { | |
| Reference< provider::XScriptProviderSupplier > xSPS = | |
| Reference< provider::XScriptProviderSupplier > | |
| ( pDoc->GetModel(), UNO_QUERY ); | |
| if ( xSPS.is() ) | |
| { | |
| Reference< provider::XScriptProvider > ScriptProvider = | |
| xSPS->getScriptProvider(); | |
| } | |
| pDoc = SfxObjectShell::GetNext(*pDoc); | |
| } | |
| aScriptsBox.ExpandAllTrees(); | |
| Window* pPrevDlgParent = Application::GetDefDialogParent(); | |
| Application::SetDefDialogParent( this ); | |
| short nRet = ModalDialog::Execute(); | |
| Application::SetDefDialogParent( pPrevDlgParent ); | |
| return nRet; | |
| } | |
| void SvxScriptOrgDialog::CheckButtons( Reference< browse::XBrowseNode >& node ) | |
| { | |
| if ( node.is() ) | |
| { | |
| if ( node->getType() == browse::BrowseNodeTypes::SCRIPT) | |
| { | |
| aRunButton.Enable(); | |
| } | |
| else | |
| { | |
| aRunButton.Disable(); | |
| } | |
| Reference< beans::XPropertySet > xProps( node, UNO_QUERY ); | |
| if ( !xProps.is() ) | |
| { | |
| aEditButton.Disable(); | |
| aDelButton.Disable(); | |
| aCreateButton.Disable(); | |
| aRunButton.Disable(); | |
| return; | |
| } | |
| ::rtl::OUString sName; | |
| sName = String::CreateFromAscii("Editable") ; | |
| if ( getBoolProperty( xProps, sName ) ) | |
| { | |
| aEditButton.Enable(); | |
| } | |
| else | |
| { | |
| aEditButton.Disable(); | |
| } | |
| sName = String::CreateFromAscii("Deletable") ; | |
| if ( getBoolProperty( xProps, sName ) ) | |
| { | |
| aDelButton.Enable(); | |
| } | |
| else | |
| { | |
| aDelButton.Disable(); | |
| } | |
| sName = String::CreateFromAscii("Creatable") ; | |
| if ( getBoolProperty( xProps, sName ) ) | |
| { | |
| aCreateButton.Enable(); | |
| } | |
| else | |
| { | |
| aCreateButton.Disable(); | |
| } | |
| sName = String::CreateFromAscii("Renamable") ; | |
| if ( getBoolProperty( xProps, sName ) ) | |
| { | |
| aRenameButton.Enable(); | |
| } | |
| else | |
| { | |
| aRenameButton.Disable(); | |
| } | |
| } | |
| else | |
| { | |
| // no node info available, disable all configurable actions | |
| aDelButton.Disable(); | |
| aCreateButton.Disable(); | |
| aEditButton.Disable(); | |
| aRunButton.Disable(); | |
| aRenameButton.Disable(); | |
| } | |
| } | |
| IMPL_LINK_INLINE_START( SvxScriptOrgDialog, MacroDoubleClickHdl, SvTreeListBox *, EMPTYARG ) | |
| { | |
| return 0; | |
| } | |
| IMPL_LINK_INLINE_END( SvxScriptOrgDialog, MacroDoubleClickHdl, SvTreeListBox *, EMPTYARG ) | |
| IMPL_LINK( SvxScriptOrgDialog, ScriptSelectHdl, SvTreeListBox *, pBox ) | |
| { | |
| if ( !pBox->IsSelected( pBox->GetHdlEntry() ) ) | |
| { | |
| return 0; | |
| } | |
| SvLBoxEntry* pEntry = pBox->GetHdlEntry(); | |
| SFEntry* userData = 0; | |
| if ( !pEntry ) | |
| { | |
| return 0; | |
| } | |
| userData = (SFEntry*)pEntry->GetUserData(); | |
| Reference< browse::XBrowseNode > node; | |
| if ( userData ) | |
| { | |
| node = userData->GetNode(); | |
| CheckButtons( node ); | |
| } | |
| return 0; | |
| } | |
| IMPL_LINK( SvxScriptOrgDialog, ButtonHdl, Button *, pButton ) | |
| { | |
| if ( pButton == &aCloseButton ) | |
| { | |
| StoreCurrentSelection(); | |
| EndDialog( 0 ); | |
| } | |
| if ( pButton == &aEditButton || | |
| pButton == &aCreateButton || | |
| pButton == &aDelButton || | |
| pButton == &aRunButton || | |
| pButton == &aRenameButton ) | |
| { | |
| if ( aScriptsBox.IsSelected( aScriptsBox.GetHdlEntry() ) ) | |
| { | |
| SvLBoxEntry* pEntry = aScriptsBox.GetHdlEntry(); | |
| SFEntry* userData = 0; | |
| if ( !pEntry ) | |
| { | |
| return 0; | |
| } | |
| userData = (SFEntry*)pEntry->GetUserData(); | |
| if ( userData ) | |
| { | |
| Reference< browse::XBrowseNode > node; | |
| Reference< XModel > xModel; | |
| node = userData->GetNode(); | |
| xModel = userData->GetModel(); | |
| if ( !node.is() ) | |
| { | |
| return 0; | |
| } | |
| if ( pButton == &aRunButton ) | |
| { | |
| ::rtl::OUString tmpString; | |
| Reference< beans::XPropertySet > xProp( node, UNO_QUERY ); | |
| Reference< provider::XScriptProvider > mspNode; | |
| if( !xProp.is() ) | |
| { | |
| return 0; | |
| } | |
| if ( xModel.is() ) | |
| { | |
| Reference< XEmbeddedScripts > xEmbeddedScripts( xModel, UNO_QUERY); | |
| if( !xEmbeddedScripts.is() ) | |
| { | |
| return 0; | |
| } | |
| if (!xEmbeddedScripts->getAllowMacroExecution()) | |
| { | |
| // Please FIXME: Show a message box if AllowMacroExecution is false | |
| return 0; | |
| } | |
| } | |
| SvLBoxEntry* pParent = aScriptsBox.GetParent( pEntry ); | |
| while ( pParent && !mspNode.is() ) | |
| { | |
| SFEntry* mspUserData = (SFEntry*)pParent->GetUserData(); | |
| mspNode.set( mspUserData->GetNode() , UNO_QUERY ); | |
| pParent = aScriptsBox.GetParent( pParent ); | |
| } | |
| xProp->getPropertyValue( String::CreateFromAscii("URI" ) ) >>= tmpString; | |
| const String scriptURL( tmpString ); | |
| if ( mspNode.is() ) | |
| { | |
| try | |
| { | |
| Reference< provider::XScript > xScript( | |
| mspNode->getScript( scriptURL ), UNO_QUERY_THROW ); | |
| const Sequence< Any > args(0); | |
| Any aRet; | |
| Sequence< sal_Int16 > outIndex; | |
| Sequence< Any > outArgs( 0 ); | |
| aRet = xScript->invoke( args, outIndex, outArgs ); | |
| } | |
| catch ( reflection::InvocationTargetException& ite ) | |
| { | |
| ::com::sun::star::uno::Any a = makeAny(ite); | |
| ShowErrorDialog(a); | |
| } | |
| catch ( provider::ScriptFrameworkErrorException& ite ) | |
| { | |
| ::com::sun::star::uno::Any a = makeAny(ite); | |
| ShowErrorDialog(a); | |
| } | |
| catch ( RuntimeException& re ) | |
| { | |
| ::com::sun::star::uno::Any a = makeAny(re); | |
| ShowErrorDialog(a); | |
| } | |
| catch ( Exception& e ) | |
| { | |
| ::com::sun::star::uno::Any a = makeAny(e); | |
| ShowErrorDialog(a); | |
| } | |
| } | |
| StoreCurrentSelection(); | |
| EndDialog( 0 ); | |
| } | |
| else if ( pButton == &aEditButton ) | |
| { | |
| Reference< script::XInvocation > xInv( node, UNO_QUERY ); | |
| if ( xInv.is() ) | |
| { | |
| StoreCurrentSelection(); | |
| EndDialog( 0 ); | |
| Sequence< Any > args(0); | |
| Sequence< Any > outArgs( 0 ); | |
| Sequence< sal_Int16 > outIndex; | |
| try | |
| { | |
| // ISSUE need code to run script here | |
| xInv->invoke( ::rtl::OUString::createFromAscii( "Editable" ), args, outIndex, outArgs ); | |
| } | |
| catch( Exception& e ) | |
| { | |
| OSL_TRACE("Caught exception trying to invoke %s", ::rtl::OUStringToOString( e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| } | |
| } | |
| else if ( pButton == &aCreateButton ) | |
| { | |
| createEntry( pEntry ); | |
| } | |
| else if ( pButton == &aDelButton ) | |
| { | |
| deleteEntry( pEntry ); | |
| } | |
| else if ( pButton == &aRenameButton ) | |
| { | |
| renameEntry( pEntry ); | |
| } | |
| } | |
| } | |
| } | |
| return 0; | |
| } | |
| Reference< browse::XBrowseNode > SvxScriptOrgDialog::getBrowseNode( SvLBoxEntry* pEntry ) | |
| { | |
| Reference< browse::XBrowseNode > node; | |
| if ( pEntry ) | |
| { | |
| SFEntry* userData = (SFEntry*)pEntry->GetUserData(); | |
| if ( userData ) | |
| { | |
| node = userData->GetNode(); | |
| } | |
| } | |
| return node; | |
| } | |
| Reference< XModel > SvxScriptOrgDialog::getModel( SvLBoxEntry* pEntry ) | |
| { | |
| Reference< XModel > model; | |
| if ( pEntry ) | |
| { | |
| SFEntry* userData = (SFEntry*)pEntry->GetUserData(); | |
| if ( userData ) | |
| { | |
| model = userData->GetModel(); | |
| } | |
| } | |
| return model; | |
| } | |
| void SvxScriptOrgDialog::createEntry( SvLBoxEntry* pEntry ) | |
| { | |
| Reference< browse::XBrowseNode > aChildNode; | |
| Reference< browse::XBrowseNode > node = getBrowseNode( pEntry ); | |
| Reference< script::XInvocation > xInv( node, UNO_QUERY ); | |
| if ( xInv.is() ) | |
| { | |
| ::rtl::OUString aNewName; | |
| ::rtl::OUString aNewStdName; | |
| sal_uInt16 nMode = INPUTMODE_NEWLIB; | |
| if( aScriptsBox.GetModel()->GetDepth( pEntry ) == 0 ) | |
| { | |
| aNewStdName = ::rtl::OUString::createFromAscii( "Library" ) ; | |
| } | |
| else | |
| { | |
| aNewStdName = ::rtl::OUString::createFromAscii( "Macro" ) ; | |
| nMode = INPUTMODE_NEWMACRO; | |
| } | |
| //do we need L10N for this? ie somethng like: | |
| //String aNewStdName( ResId( STR_STDMODULENAME ) ); | |
| sal_Bool bValid = sal_False; | |
| sal_uInt16 i = 1; | |
| Sequence< Reference< browse::XBrowseNode > > childNodes; | |
| // no children => ok to create Parcel1 or Script1 without checking | |
| try | |
| { | |
| if( node->hasChildNodes() == sal_False ) | |
| { | |
| aNewName = aNewStdName; | |
| aNewName += String::CreateFromInt32( i ); | |
| bValid = sal_True; | |
| } | |
| else | |
| { | |
| childNodes = node->getChildNodes(); | |
| } | |
| } | |
| catch ( Exception& ) | |
| { | |
| // ignore, will continue on with empty sequence | |
| } | |
| ::rtl::OUString extn; | |
| while ( !bValid ) | |
| { | |
| aNewName = aNewStdName; | |
| aNewName += String::CreateFromInt32( i ); | |
| sal_Bool bFound = sal_False; | |
| if(childNodes.getLength() > 0 ) | |
| { | |
| ::rtl::OUString nodeName = childNodes[0]->getName(); | |
| sal_Int32 extnPos = nodeName.lastIndexOf( '.' ); | |
| if(extnPos>0) | |
| extn = nodeName.copy(extnPos); | |
| } | |
| for( sal_Int32 index = 0; index < childNodes.getLength(); index++ ) | |
| { | |
| if ( (aNewName+extn).equals( childNodes[index]->getName() ) ) | |
| { | |
| bFound = sal_True; | |
| break; | |
| } | |
| } | |
| if( bFound ) | |
| { | |
| i++; | |
| } | |
| else | |
| { | |
| bValid = sal_True; | |
| } | |
| } | |
| std::auto_ptr< InputDialog > xNewDlg( new InputDialog( static_cast<Window*>(this), nMode ) ); | |
| xNewDlg->SetObjectName( aNewName ); | |
| do | |
| { | |
| if ( xNewDlg->Execute() && xNewDlg->GetObjectName().Len() ) | |
| { | |
| ::rtl::OUString aUserSuppliedName = xNewDlg->GetObjectName(); | |
| bValid = sal_True; | |
| for( sal_Int32 index = 0; index < childNodes.getLength(); index++ ) | |
| { | |
| if ( (aUserSuppliedName+extn).equals( childNodes[index]->getName() ) ) | |
| { | |
| bValid = sal_False; | |
| String aError( m_createErrStr ); | |
| aError.Append( m_createDupStr ); | |
| ErrorBox aErrorBox( static_cast<Window*>(this), WB_OK | RET_OK, aError ); | |
| aErrorBox.SetText( m_createErrTitleStr ); | |
| aErrorBox.Execute(); | |
| xNewDlg->SetObjectName( aNewName ); | |
| break; | |
| } | |
| } | |
| if( bValid ) | |
| aNewName = aUserSuppliedName; | |
| } | |
| else | |
| { | |
| // user hit cancel or hit OK with nothing in the editbox | |
| return; | |
| } | |
| } | |
| while ( !bValid ); | |
| // open up parent node (which ensures it's loaded) | |
| aScriptsBox.RequestingChilds( pEntry ); | |
| Sequence< Any > args( 1 ); | |
| args[ 0 ] <<= aNewName; | |
| Sequence< Any > outArgs( 0 ); | |
| Sequence< sal_Int16 > outIndex; | |
| try | |
| { | |
| Any aResult; | |
| aResult = xInv->invoke( ::rtl::OUString::createFromAscii( "Creatable" ), args, outIndex, outArgs ); | |
| Reference< browse::XBrowseNode > newNode( aResult, UNO_QUERY ); | |
| aChildNode = newNode; | |
| } | |
| catch( Exception& e ) | |
| { | |
| OSL_TRACE("Caught exception trying to Create %s", | |
| ::rtl::OUStringToOString( | |
| e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| } | |
| if ( aChildNode.is() ) | |
| { | |
| String aChildName = aChildNode->getName(); | |
| SvLBoxEntry* pNewEntry = NULL; | |
| ::rtl::OUString name( aChildName ); | |
| Reference<XModel> xDocumentModel = getModel( pEntry ); | |
| // ISSUE do we need to remove all entries for parent | |
| // to achieve sort? Just need to determine position | |
| // SvTreeListBox::InsertEntry can take position arg | |
| // -- Basic doesn't do this on create. | |
| // Suppose we could avoid this too. -> created nodes are | |
| // not in alphabetical order | |
| if ( aChildNode->getType() == browse::BrowseNodeTypes::SCRIPT ) | |
| { | |
| pNewEntry = aScriptsBox.insertEntry( aChildName, | |
| IMG_MACRO, pEntry, false, std::auto_ptr< SFEntry >(new SFEntry( OBJTYPE_METHOD, aChildNode,xDocumentModel ) ) ); | |
| } | |
| else | |
| { | |
| pNewEntry = aScriptsBox.insertEntry( aChildName, | |
| IMG_LIB, pEntry, false, std::auto_ptr< SFEntry >(new SFEntry( OBJTYPE_SCRIPTCONTAINER, aChildNode,xDocumentModel ) ) ); | |
| // If the Parent is not loaded then set to | |
| // loaded, this will prevent RequestingChilds ( called | |
| // from vcl via RequestingChilds ) from | |
| // creating new ( duplicate ) children | |
| SFEntry* userData = (SFEntry*)pEntry->GetUserData(); | |
| if ( userData && !userData->isLoaded() ) | |
| { | |
| userData->setLoaded(); | |
| } | |
| } | |
| aScriptsBox.SetCurEntry( pNewEntry ); | |
| aScriptsBox.Select( aScriptsBox.GetCurEntry() ); | |
| } | |
| else | |
| { | |
| //ISSUE L10N & message from exception? | |
| String aError( m_createErrStr ); | |
| ErrorBox aErrorBox( static_cast<Window*>(this), WB_OK | RET_OK, aError ); | |
| aErrorBox.SetText( m_createErrTitleStr ); | |
| aErrorBox.Execute(); | |
| } | |
| } | |
| void SvxScriptOrgDialog::renameEntry( SvLBoxEntry* pEntry ) | |
| { | |
| Reference< browse::XBrowseNode > aChildNode; | |
| Reference< browse::XBrowseNode > node = getBrowseNode( pEntry ); | |
| Reference< script::XInvocation > xInv( node, UNO_QUERY ); | |
| if ( xInv.is() ) | |
| { | |
| ::rtl::OUString aNewName = node->getName(); | |
| sal_Int32 extnPos = aNewName.lastIndexOf( '.' ); | |
| ::rtl::OUString extn; | |
| if(extnPos>0) | |
| { | |
| extn = aNewName.copy(extnPos); | |
| aNewName = aNewName.copy(0,extnPos); | |
| } | |
| sal_uInt16 nMode = INPUTMODE_RENAME; | |
| std::auto_ptr< InputDialog > xNewDlg( new InputDialog( static_cast<Window*>(this), nMode ) ); | |
| xNewDlg->SetObjectName( aNewName ); | |
| sal_Bool bValid; | |
| do | |
| { | |
| if ( xNewDlg->Execute() && xNewDlg->GetObjectName().Len() ) | |
| { | |
| ::rtl::OUString aUserSuppliedName = xNewDlg->GetObjectName(); | |
| bValid = sal_True; | |
| /* | |
| for( sal_Int32 index = 0; index < childNodes.getLength(); index++ ) | |
| { | |
| if ( (aUserSuppliedName+extn).equals( childNodes[index]->getName() ) ) | |
| { | |
| bValid = sal_False; | |
| String aError( m_createErrStr ); | |
| aError.Append( m_createDupStr ); | |
| ErrorBox aErrorBox( static_cast<Window*>(this), WB_OK | RET_OK, aError ); | |
| aErrorBox.SetText( m_createErrTitleStr ); | |
| aErrorBox.Execute(); | |
| xNewDlg->SetObjectName( aNewName ); | |
| break; | |
| } | |
| } */ | |
| if( bValid ) | |
| aNewName = aUserSuppliedName; | |
| } | |
| else | |
| { | |
| // user hit cancel or hit OK with nothing in the editbox | |
| return; | |
| } | |
| } | |
| while ( !bValid ); | |
| Sequence< Any > args( 1 ); | |
| args[ 0 ] <<= aNewName; | |
| Sequence< Any > outArgs( 0 ); | |
| Sequence< sal_Int16 > outIndex; | |
| try | |
| { | |
| Any aResult; | |
| aResult = xInv->invoke( ::rtl::OUString::createFromAscii( "Renamable" ), args, outIndex, outArgs ); | |
| Reference< browse::XBrowseNode > newNode( aResult, UNO_QUERY ); | |
| aChildNode = newNode; | |
| } | |
| catch( Exception& e ) | |
| { | |
| OSL_TRACE("Caught exception trying to Rename %s", | |
| ::rtl::OUStringToOString( | |
| e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| } | |
| if ( aChildNode.is() ) | |
| { | |
| aScriptsBox.SetEntryText( pEntry, aChildNode->getName() ); | |
| aScriptsBox.SetCurEntry( pEntry ); | |
| aScriptsBox.Select( aScriptsBox.GetCurEntry() ); | |
| } | |
| else | |
| { | |
| //ISSUE L10N & message from exception? | |
| String aError( m_renameErrStr ); | |
| ErrorBox aErrorBox( static_cast<Window*>(this), WB_OK | RET_OK, aError ); | |
| aErrorBox.SetText( m_renameErrTitleStr ); | |
| aErrorBox.Execute(); | |
| } | |
| } | |
| void SvxScriptOrgDialog::deleteEntry( SvLBoxEntry* pEntry ) | |
| { | |
| sal_Bool result = sal_False; | |
| Reference< browse::XBrowseNode > node = getBrowseNode( pEntry ); | |
| // ISSUE L10N string & can we centre list? | |
| String aQuery( m_delQueryStr ); | |
| aQuery.Append( getListOfChildren( node, 0 ) ); | |
| QueryBox aQueryBox( static_cast<Window*>(this), WB_YES_NO | WB_DEF_YES, aQuery ); | |
| aQueryBox.SetText( m_delQueryTitleStr ); | |
| if ( aQueryBox.Execute() == RET_NO ) | |
| { | |
| return; | |
| } | |
| Reference< script::XInvocation > xInv( node, UNO_QUERY ); | |
| if ( xInv.is() ) | |
| { | |
| Sequence< Any > args( 0 ); | |
| Sequence< Any > outArgs( 0 ); | |
| Sequence< sal_Int16 > outIndex; | |
| try | |
| { | |
| Any aResult; | |
| aResult = xInv->invoke( ::rtl::OUString::createFromAscii( "Deletable" ), args, outIndex, outArgs ); | |
| aResult >>= result; // or do we just assume true if no exception ? | |
| } | |
| catch( Exception& e ) | |
| { | |
| OSL_TRACE("Caught exception trying to delete %s", | |
| ::rtl::OUStringToOString( | |
| e.Message, RTL_TEXTENCODING_ASCII_US ).pData->buffer ); | |
| } | |
| } | |
| if ( result == sal_True ) | |
| { | |
| aScriptsBox.deleteTree( pEntry ); | |
| aScriptsBox.GetModel()->Remove( pEntry ); | |
| } | |
| else | |
| { | |
| //ISSUE L10N & message from exception? | |
| ErrorBox aErrorBox( static_cast<Window*>(this), WB_OK | RET_OK, m_delErrStr ); | |
| aErrorBox.SetText( m_delErrTitleStr ); | |
| aErrorBox.Execute(); | |
| } | |
| } | |
| sal_Bool SvxScriptOrgDialog::getBoolProperty( Reference< beans::XPropertySet >& xProps, | |
| ::rtl::OUString& propName ) | |
| { | |
| sal_Bool result = false; | |
| try | |
| { | |
| sal_Bool bTemp = sal_False; | |
| xProps->getPropertyValue( propName ) >>= bTemp; | |
| result = ( bTemp == sal_True ); | |
| } | |
| catch ( Exception& ) | |
| { | |
| return result; | |
| } | |
| return result; | |
| } | |
| String SvxScriptOrgDialog::getListOfChildren( Reference< browse::XBrowseNode > node, int depth ) | |
| { | |
| String result; | |
| result.Append( String::CreateFromAscii( "\n" ) ); | |
| for( int i=0;i<=depth;i++ ) | |
| { | |
| result.Append( String::CreateFromAscii( "\t" ) ); | |
| } | |
| result.Append( String( node->getName() ) ); | |
| try | |
| { | |
| if ( node->hasChildNodes() == sal_True ) | |
| { | |
| Sequence< Reference< browse::XBrowseNode > > children | |
| = node->getChildNodes(); | |
| for ( sal_Int32 n = 0; n < children.getLength(); n++ ) | |
| { | |
| result.Append( getListOfChildren( children[ n ] , depth+1 ) ); | |
| } | |
| } | |
| } | |
| catch ( Exception& ) | |
| { | |
| // ignore, will return an empty string | |
| } | |
| return result; | |
| } | |
| Selection_hash SvxScriptOrgDialog::m_lastSelection; | |
| void SvxScriptOrgDialog::StoreCurrentSelection() | |
| { | |
| String aDescription; | |
| if ( aScriptsBox.IsSelected( aScriptsBox.GetHdlEntry() ) ) | |
| { | |
| SvLBoxEntry* pEntry = aScriptsBox.GetHdlEntry(); | |
| while( pEntry ) | |
| { | |
| aDescription.Insert( aScriptsBox.GetEntryText( pEntry ), 0 ); | |
| pEntry = aScriptsBox.GetParent( pEntry ); | |
| if ( pEntry ) | |
| aDescription.Insert( ';', 0 ); | |
| } | |
| ::rtl::OUString sDesc( aDescription ); | |
| m_lastSelection[ m_sLanguage ] = sDesc; | |
| } | |
| } | |
| void SvxScriptOrgDialog::RestorePreviousSelection() | |
| { | |
| String aStoredEntry = String( m_lastSelection[ m_sLanguage ] ); | |
| if( aStoredEntry.Len() <= 0 ) | |
| return; | |
| SvLBoxEntry* pEntry = 0; | |
| sal_uInt16 nIndex = 0; | |
| while ( nIndex != STRING_NOTFOUND ) | |
| { | |
| String aTmp( aStoredEntry.GetToken( 0, ';', nIndex ) ); | |
| SvLBoxEntry* pTmpEntry = aScriptsBox.FirstChild( pEntry ); | |
| ::rtl::OUString debugStr(aTmp); | |
| while ( pTmpEntry ) | |
| { | |
| debugStr = ::rtl::OUString(aScriptsBox.GetEntryText( pTmpEntry )); | |
| if ( aScriptsBox.GetEntryText( pTmpEntry ) == aTmp ) | |
| { | |
| pEntry = pTmpEntry; | |
| break; | |
| } | |
| pTmpEntry = aScriptsBox.NextSibling( pTmpEntry ); | |
| } | |
| if ( !pTmpEntry ) | |
| break; | |
| aScriptsBox.RequestingChilds( pEntry ); | |
| } | |
| aScriptsBox.SetCurEntry( pEntry ); | |
| } | |
| ::rtl::OUString ReplaceString( | |
| const ::rtl::OUString& source, | |
| const ::rtl::OUString& token, | |
| const ::rtl::OUString& value ) | |
| { | |
| sal_Int32 pos = source.indexOf( token ); | |
| if ( pos != -1 && value.getLength() != 0 ) | |
| { | |
| return source.replaceAt( pos, token.getLength(), value ); | |
| } | |
| else | |
| { | |
| return source; | |
| } | |
| } | |
| ::rtl::OUString FormatErrorString( | |
| const ::rtl::OUString& unformatted, | |
| const ::rtl::OUString& language, | |
| const ::rtl::OUString& script, | |
| const ::rtl::OUString& line, | |
| const ::rtl::OUString& type, | |
| const ::rtl::OUString& message ) | |
| { | |
| ::rtl::OUString result = unformatted.copy( 0 ); | |
| result = ReplaceString( | |
| result, ::rtl::OUString::createFromAscii( "%LANGUAGENAME" ), language ); | |
| result = ReplaceString( | |
| result, ::rtl::OUString::createFromAscii( "%SCRIPTNAME" ), script ); | |
| result = ReplaceString( | |
| result, ::rtl::OUString::createFromAscii( "%LINENUMBER" ), line ); | |
| if ( type.getLength() != 0 ) | |
| { | |
| result += ::rtl::OUString::createFromAscii( "\n\n" ); | |
| result += ::rtl::OUString(String(CUI_RES(RID_SVXSTR_ERROR_TYPE_LABEL))); | |
| result += ::rtl::OUString::createFromAscii( " " ); | |
| result += type; | |
| } | |
| if ( message.getLength() != 0 ) | |
| { | |
| result += ::rtl::OUString::createFromAscii( "\n\n" ); | |
| result += ::rtl::OUString(String(CUI_RES(RID_SVXSTR_ERROR_MESSAGE_LABEL))); | |
| result += ::rtl::OUString::createFromAscii( " " ); | |
| result += message; | |
| } | |
| return result; | |
| } | |
| ::rtl::OUString GetErrorMessage( | |
| const provider::ScriptErrorRaisedException& eScriptError ) | |
| { | |
| ::rtl::OUString unformatted = String( CUI_RES( RID_SVXSTR_ERROR_AT_LINE ) ); | |
| ::rtl::OUString unknown = ::rtl::OUString::createFromAscii( "UNKNOWN" ); | |
| ::rtl::OUString language = unknown; | |
| ::rtl::OUString script = unknown; | |
| ::rtl::OUString line = unknown; | |
| ::rtl::OUString type = ::rtl::OUString(); | |
| ::rtl::OUString message = eScriptError.Message; | |
| if ( eScriptError.language.getLength() != 0 ) | |
| { | |
| language = eScriptError.language; | |
| } | |
| if ( eScriptError.scriptName.getLength() != 0 ) | |
| { | |
| script = eScriptError.scriptName; | |
| } | |
| if ( eScriptError.Message.getLength() != 0 ) | |
| { | |
| message = eScriptError.Message; | |
| } | |
| if ( eScriptError.lineNum != -1 ) | |
| { | |
| line = ::rtl::OUString::valueOf( eScriptError.lineNum ); | |
| unformatted = String( | |
| CUI_RES( RID_SVXSTR_ERROR_AT_LINE ) ); | |
| } | |
| else | |
| { | |
| unformatted = String( | |
| CUI_RES( RID_SVXSTR_ERROR_RUNNING ) ); | |
| } | |
| return FormatErrorString( | |
| unformatted, language, script, line, type, message ); | |
| } | |
| ::rtl::OUString GetErrorMessage( | |
| const provider::ScriptExceptionRaisedException& eScriptException ) | |
| { | |
| ::rtl::OUString unformatted = | |
| String( CUI_RES( RID_SVXSTR_EXCEPTION_AT_LINE ) ); | |
| ::rtl::OUString unknown = ::rtl::OUString::createFromAscii( "UNKNOWN" ); | |
| ::rtl::OUString language = unknown; | |
| ::rtl::OUString script = unknown; | |
| ::rtl::OUString line = unknown; | |
| ::rtl::OUString type = unknown; | |
| ::rtl::OUString message = eScriptException.Message; | |
| if ( eScriptException.language.getLength() != 0 ) | |
| { | |
| language = eScriptException.language; | |
| } | |
| if ( eScriptException.scriptName.getLength() != 0 ) | |
| { | |
| script = eScriptException.scriptName; | |
| } | |
| if ( eScriptException.Message.getLength() != 0 ) | |
| { | |
| message = eScriptException.Message; | |
| } | |
| if ( eScriptException.lineNum != -1 ) | |
| { | |
| line = ::rtl::OUString::valueOf( eScriptException.lineNum ); | |
| unformatted = String( | |
| CUI_RES( RID_SVXSTR_EXCEPTION_AT_LINE ) ); | |
| } | |
| else | |
| { | |
| unformatted = String( | |
| CUI_RES( RID_SVXSTR_EXCEPTION_RUNNING ) ); | |
| } | |
| if ( eScriptException.exceptionType.getLength() != 0 ) | |
| { | |
| type = eScriptException.exceptionType; | |
| } | |
| return FormatErrorString( | |
| unformatted, language, script, line, type, message ); | |
| } | |
| ::rtl::OUString GetErrorMessage( | |
| const provider::ScriptFrameworkErrorException& sError ) | |
| { | |
| ::rtl::OUString unformatted = String( | |
| CUI_RES( RID_SVXSTR_FRAMEWORK_ERROR_RUNNING ) ); | |
| ::rtl::OUString language = | |
| ::rtl::OUString::createFromAscii( "UNKNOWN" ); | |
| ::rtl::OUString script = | |
| ::rtl::OUString::createFromAscii( "UNKNOWN" ); | |
| ::rtl::OUString message; | |
| if ( sError.scriptName.getLength() > 0 ) | |
| { | |
| script = sError.scriptName; | |
| } | |
| if ( sError.language.getLength() > 0 ) | |
| { | |
| language = sError.language; | |
| } | |
| if ( sError.errorType == provider::ScriptFrameworkErrorType::NOTSUPPORTED ) | |
| { | |
| message = String( | |
| CUI_RES( RID_SVXSTR_ERROR_LANG_NOT_SUPPORTED ) ); | |
| message = ReplaceString( | |
| message, ::rtl::OUString::createFromAscii( "%LANGUAGENAME" ), language ); | |
| } | |
| else | |
| { | |
| message = sError.Message; | |
| } | |
| return FormatErrorString( | |
| unformatted, language, script, ::rtl::OUString(), ::rtl::OUString(), message ); | |
| } | |
| ::rtl::OUString GetErrorMessage( const RuntimeException& re ) | |
| { | |
| Type t = ::getCppuType( &re ); | |
| ::rtl::OUString message = t.getTypeName(); | |
| message += re.Message; | |
| return message; | |
| } | |
| ::rtl::OUString GetErrorMessage( const Exception& e ) | |
| { | |
| Type t = ::getCppuType( &e ); | |
| ::rtl::OUString message = t.getTypeName(); | |
| message += e.Message; | |
| return message; | |
| } | |
| ::rtl::OUString GetErrorMessage( const com::sun::star::uno::Any& aException ) | |
| { | |
| ::rtl::OUString exType; | |
| if ( aException.getValueType() == | |
| ::getCppuType( (const reflection::InvocationTargetException* ) NULL ) ) | |
| { | |
| reflection::InvocationTargetException ite; | |
| aException >>= ite; | |
| if ( ite.TargetException.getValueType() == ::getCppuType( ( const provider::ScriptErrorRaisedException* ) NULL ) ) | |
| { | |
| // Error raised by script | |
| provider::ScriptErrorRaisedException scriptError; | |
| ite.TargetException >>= scriptError; | |
| return GetErrorMessage( scriptError ); | |
| } | |
| else if ( ite.TargetException.getValueType() == ::getCppuType( ( const provider::ScriptExceptionRaisedException* ) NULL ) ) | |
| { | |
| // Exception raised by script | |
| provider::ScriptExceptionRaisedException scriptException; | |
| ite.TargetException >>= scriptException; | |
| return GetErrorMessage( scriptException ); | |
| } | |
| else | |
| { | |
| // Unknown error, shouldn't happen | |
| // OSL_ASSERT(...) | |
| } | |
| } | |
| else if ( aException.getValueType() == ::getCppuType( ( const provider::ScriptFrameworkErrorException* ) NULL ) ) | |
| { | |
| // A Script Framework error has occurred | |
| provider::ScriptFrameworkErrorException sfe; | |
| aException >>= sfe; | |
| return GetErrorMessage( sfe ); | |
| } | |
| // unknown exception | |
| Exception e; | |
| RuntimeException rte; | |
| if ( aException >>= rte ) | |
| { | |
| return GetErrorMessage( rte ); | |
| } | |
| aException >>= e; | |
| return GetErrorMessage( e ); | |
| } | |
| SvxScriptErrorDialog::SvxScriptErrorDialog( | |
| Window* , ::com::sun::star::uno::Any aException ) | |
| : m_sMessage() | |
| { | |
| ::vos::OGuard aGuard( Application::GetSolarMutex() ); | |
| m_sMessage = GetErrorMessage( aException ); | |
| } | |
| SvxScriptErrorDialog::~SvxScriptErrorDialog() | |
| { | |
| } | |
| short SvxScriptErrorDialog::Execute() | |
| { | |
| // Show Error dialog asynchronously | |
| // | |
| // Pass a copy of the message to the ShowDialog method as the | |
| // SvxScriptErrorDialog may be deleted before ShowDialog is called | |
| Application::PostUserEvent( | |
| LINK( this, SvxScriptErrorDialog, ShowDialog ), | |
| new rtl::OUString( m_sMessage ) ); | |
| return 0; | |
| } | |
| IMPL_LINK( SvxScriptErrorDialog, ShowDialog, ::rtl::OUString*, pMessage ) | |
| { | |
| ::rtl::OUString message; | |
| if ( pMessage && pMessage->getLength() != 0 ) | |
| { | |
| message = *pMessage; | |
| } | |
| else | |
| { | |
| message = String( CUI_RES( RID_SVXSTR_ERROR_TITLE ) ); | |
| } | |
| MessBox* pBox = new WarningBox( NULL, WB_OK, message ); | |
| pBox->SetText( CUI_RES( RID_SVXSTR_ERROR_TITLE ) ); | |
| pBox->Execute(); | |
| if ( pBox ) delete pBox; | |
| if ( pMessage ) delete pMessage; | |
| return 0; | |
| } |