| /************************************************************** |
| * |
| * 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_svtools.hxx" |
| #include "templwin.hxx" |
| #include <svtools/templdlg.hxx> |
| #include <svtools/svtdata.hxx> |
| #include <unotools/pathoptions.hxx> |
| #include <unotools/dynamicmenuoptions.hxx> |
| #include <unotools/extendedsecurityoptions.hxx> |
| #include <svtools/xtextedt.hxx> |
| #include <svl/inettype.hxx> |
| #include <svtools/imagemgr.hxx> |
| #include <svtools/miscopt.hxx> |
| #include <svtools/templatefoldercache.hxx> |
| #include <svtools/imgdef.hxx> |
| #include <svtools/txtattr.hxx> |
| #include <svtools/svtools.hrc> |
| #include "templwin.hrc" |
| #include <svtools/helpid.hrc> |
| #include <unotools/pathoptions.hxx> |
| #include <unotools/viewoptions.hxx> |
| #include <unotools/ucbhelper.hxx> |
| #include "unotools/configmgr.hxx" |
| #include <com/sun/star/awt/XWindow.hpp> |
| #include <com/sun/star/lang/XMultiServiceFactory.hpp> |
| #include <com/sun/star/frame/XFrame.hpp> |
| #include <toolkit/helper/vclunohelper.hxx> |
| #include <com/sun/star/util/URL.hpp> |
| #include <com/sun/star/util/XURLTransformer.hpp> |
| #include <com/sun/star/util/XOfficeInstallationDirectories.hpp> |
| #include <com/sun/star/frame/XDispatchProvider.hpp> |
| #include <com/sun/star/frame/XDocumentTemplates.hpp> |
| #include <com/sun/star/frame/XComponentLoader.hpp> |
| #include <com/sun/star/beans/PropertyValue.hpp> |
| #include <com/sun/star/ucb/XContent.hpp> |
| #include <com/sun/star/ucb/XCommandEnvironment.hpp> |
| #include <com/sun/star/view/XPrintable.hpp> |
| #include <com/sun/star/awt/XWindow.hpp> |
| #include <com/sun/star/document/XDocumentProperties.hpp> |
| #include <com/sun/star/beans/XPropertySet.hpp> |
| #include <com/sun/star/beans/XMultiPropertySet.hpp> |
| #include <com/sun/star/beans/XPropertySetInfo.hpp> |
| #include <com/sun/star/io/IOException.hpp> |
| #include <com/sun/star/util/DateTime.hpp> |
| #include <com/sun/star/script/XTypeConverter.hpp> |
| #include <com/sun/star/system/SystemShellExecute.hpp> |
| #include <com/sun/star/system/SystemShellExecuteFlags.hpp> |
| #include <unotools/localedatawrapper.hxx> |
| #include <com/sun/star/container/XNameContainer.hpp> |
| #include <vcl/waitobj.hxx> |
| #include <comphelper/processfactory.hxx> |
| #include <tools/urlobj.hxx> |
| #include <tools/datetime.hxx> |
| #include <vcl/svapp.hxx> |
| #include <vcl/split.hxx> |
| #include <vcl/msgbox.hxx> |
| #include <svtools/DocumentInfoPreview.hxx> |
| #include <vcl/mnemonic.hxx> |
| |
| #include <ucbhelper/content.hxx> |
| #include <comphelper/string.hxx> |
| |
| |
| using namespace ::com::sun::star; |
| using namespace ::com::sun::star::beans; |
| using namespace ::com::sun::star::container; |
| using namespace ::com::sun::star::frame; |
| using namespace ::com::sun::star::document; |
| using namespace ::com::sun::star::lang; |
| using namespace ::com::sun::star::ucb; |
| using namespace ::com::sun::star::uno; |
| using namespace ::com::sun::star::view; |
| using namespace svtools; |
| |
| extern ::rtl::OUString CreateExactSizeText_Impl( sal_Int64 nSize ); // fileview.cxx |
| |
| #define SPLITSET_ID 0 |
| #define COLSET_ID 1 |
| #define ICONWIN_ID 2 |
| #define FILEWIN_ID 3 |
| #define FRAMEWIN_ID 4 |
| |
| #define ICON_POS_NEWDOC 0 |
| #define ICON_POS_TEMPLATES 1 |
| #define ICON_POS_MYDOCS 2 |
| #define ICON_POS_SAMPLES 3 |
| |
| #define ASCII_STR(s) ::rtl::OUString( RTL_CONSTASCII_USTRINGPARAM(s) ) |
| #define VIEWSETTING_NEWFROMTEMPLATE ASCII_STR("NewFromTemplate") |
| #define VIEWSETTING_SELECTEDGROUP ASCII_STR("SelectedGroup") |
| #define VIEWSETTING_SELECTEDVIEW ASCII_STR("SelectedView") |
| #define VIEWSETTING_SPLITRATIO ASCII_STR("SplitRatio") |
| #define VIEWSETTING_LASTFOLDER ASCII_STR("LastFolder") |
| |
| struct FolderHistory |
| { |
| String m_sURL; |
| sal_uLong m_nGroup; |
| |
| FolderHistory( const String& _rURL, sal_Int32 _nGroup ) : |
| m_sURL( _rURL ), m_nGroup( _nGroup ) {} |
| }; |
| |
| DECLARE_LIST( HistoryList_Impl, FolderHistory* ) |
| DECLARE_LIST( NewDocList_Impl, ::rtl::OUString* ) |
| |
| ODocumentInfoPreview::ODocumentInfoPreview( Window* pParent ,WinBits _nBits) : Window(pParent,WB_DIALOGCONTROL) |
| { |
| m_pEditWin = new SvtExtendedMultiLineEdit_Impl(this,_nBits); |
| m_pEditWin->Show(); |
| m_pEditWin->EnableCursor( sal_False ); |
| m_pInfoTable = new SvtDocInfoTable_Impl(); |
| // detect application language |
| m_aLocale = SvtPathOptions().GetLocale(); |
| } |
| // ----------------------------------------------------------------------------- |
| ODocumentInfoPreview::~ODocumentInfoPreview() |
| { |
| delete m_pEditWin; |
| delete m_pInfoTable; |
| } |
| // ----------------------------------------------------------------------------- |
| void ODocumentInfoPreview::Resize() |
| { |
| Size aOutputSize( GetOutputSize() ); |
| m_pEditWin->SetPosSizePixel( Point(0,0),aOutputSize); |
| } |
| // ----------------------------------------------------------------------------- |
| void ODocumentInfoPreview::Clear() |
| { |
| m_pEditWin->Clear(); |
| } |
| // ----------------------------------------------------------------------------- |
| |
| void lcl_insertDateTimeEntry(SvtExtendedMultiLineEdit_Impl* i_pEditWin, |
| const ::rtl::OUString & i_rName, const util::DateTime & i_rUDT) |
| { |
| DateTime aToolsDT = |
| DateTime( Date( i_rUDT.Day, i_rUDT.Month, i_rUDT.Year ), |
| Time( i_rUDT.Hours, i_rUDT.Minutes, |
| i_rUDT.Seconds, i_rUDT.HundredthSeconds ) ); |
| if ( aToolsDT.IsValid() ) |
| { |
| LocaleDataWrapper aLocaleWrapper( |
| ::comphelper::getProcessServiceFactory(), |
| Application::GetSettings().GetLocale() ); |
| String aDateStr = aLocaleWrapper.getDate( aToolsDT ); |
| aDateStr += String( RTL_CONSTASCII_STRINGPARAM(", ") ); |
| aDateStr += aLocaleWrapper.getTime( aToolsDT ); |
| i_pEditWin->InsertEntry( i_rName, aDateStr ); |
| } |
| } |
| |
| void ODocumentInfoPreview::fill( |
| const Reference< XDocumentProperties >& i_xDocProps, const String& i_rURL) |
| { |
| if (!i_xDocProps.is()) throw RuntimeException(); |
| |
| ::rtl::OUString aStr; |
| m_pEditWin->SetAutoScroll( sal_False ); |
| |
| aStr = i_xDocProps->getTitle(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_TITLE ), aStr ); |
| } |
| |
| aStr = i_xDocProps->getAuthor(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_FROM ), aStr ); |
| } |
| |
| lcl_insertDateTimeEntry(m_pEditWin, |
| m_pInfoTable->GetString( DI_DATE ), |
| i_xDocProps->getCreationDate()); |
| |
| aStr = i_xDocProps->getModifiedBy(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString(DI_MODIFIEDBY), aStr ); |
| } |
| |
| lcl_insertDateTimeEntry(m_pEditWin, |
| m_pInfoTable->GetString( DI_MODIFIEDDATE ), |
| i_xDocProps->getModificationDate()); |
| |
| aStr = i_xDocProps->getPrintedBy(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_PRINTBY ), aStr ); |
| } |
| |
| lcl_insertDateTimeEntry(m_pEditWin, |
| m_pInfoTable->GetString( DI_PRINTDATE ), |
| i_xDocProps->getPrintDate()); |
| |
| aStr = i_xDocProps->getSubject(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_THEME ), aStr ); |
| } |
| |
| aStr = |
| ::comphelper::string::convertCommaSeparated(i_xDocProps->getKeywords()); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_KEYWORDS ), aStr ); |
| } |
| |
| aStr = i_xDocProps->getDescription(); |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_DESCRIPTION ), |
| aStr ); |
| } |
| |
| // size |
| if ( i_rURL.Len() > 0 ) |
| { |
| sal_uLong nDocSize = ::utl::UCBContentHelper::GetSize( i_rURL ); |
| m_pEditWin->InsertEntry( |
| m_pInfoTable->GetString( DI_SIZE ), |
| CreateExactSizeText_Impl( nDocSize ) ); |
| } |
| |
| // MIMEType |
| if ( i_rURL.Len() > 0 ) |
| { |
| INetContentType eTypeID = |
| INetContentTypes::GetContentTypeFromURL( i_rURL ); |
| if ( eTypeID != CONTENT_TYPE_APP_OCTSTREAM ) { |
| aStr = INetContentTypes::GetPresentation( eTypeID, m_aLocale ); |
| } else { |
| aStr = SvFileInformationManager::GetDescription( |
| INetURLObject(i_rURL) ); |
| } |
| if (aStr.getLength()) { |
| m_pEditWin->InsertEntry( m_pInfoTable->GetString( DI_MIMETYPE ), |
| aStr ); |
| } |
| } |
| |
| // user-defined (custom) properties |
| Reference< XPropertySet > xUserDefined( |
| i_xDocProps->getUserDefinedProperties(), UNO_QUERY_THROW ); |
| Reference< XPropertySetInfo > xUDInfo = xUserDefined->getPropertySetInfo(); |
| Sequence< Property > props = xUDInfo->getProperties(); |
| for (sal_Int32 i = 0; i < props.getLength(); ++i) { |
| const ::rtl::OUString name = props[i].Name; |
| uno::Any aAny; |
| try { |
| aAny = xUserDefined->getPropertyValue(name); |
| uno::Reference < script::XTypeConverter > xConverter( |
| comphelper::getProcessServiceFactory()->createInstance( |
| ASCII_STR("com.sun.star.script.Converter")), |
| UNO_QUERY ); |
| uno::Any aNew; |
| aNew = xConverter->convertToSimpleType( aAny, TypeClass_STRING ); |
| if ((aNew >>= aStr) && aStr.getLength()) { |
| m_pEditWin->InsertEntry( name, aStr); |
| } |
| } catch (uno::Exception &) { |
| // ignore |
| } |
| } |
| |
| m_pEditWin->SetSelection( Selection( 0, 0 ) ); |
| m_pEditWin->SetAutoScroll( sal_True ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| void ODocumentInfoPreview::InsertEntry( const String& rTitle, const String& rValue ) |
| { |
| m_pEditWin->InsertEntry( rTitle, rValue); |
| } |
| // ----------------------------------------------------------------------------- |
| |
| // class SvtDummyHeaderBar_Impl ------------------------------------------ |
| |
| void SvtDummyHeaderBar_Impl::UpdateBackgroundColor() |
| { |
| SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetWindowColor() ) ); |
| } |
| |
| SvtDummyHeaderBar_Impl::SvtDummyHeaderBar_Impl( Window* pPar ) : Window( pPar ) |
| { |
| SetSizePixel( HeaderBar( this, 0 ).CalcWindowSizePixel() ); // HeaderBar used only to calculate size |
| |
| UpdateBackgroundColor(); |
| } |
| |
| SvtDummyHeaderBar_Impl::~SvtDummyHeaderBar_Impl() |
| { |
| } |
| |
| void SvtDummyHeaderBar_Impl::DataChanged( const DataChangedEvent& r ) |
| { |
| Window::DataChanged( r ); |
| if( r.GetType() == DATACHANGED_SETTINGS ) |
| UpdateBackgroundColor(); |
| } |
| |
| // class SvtIconWindow_Impl ---------------------------------------------- |
| |
| SvtIconWindow_Impl::SvtIconWindow_Impl( Window* pParent ) : |
| |
| Window( pParent, WB_DIALOGCONTROL | WB_BORDER | WB_3DLOOK ), |
| |
| aDummyHeaderBar( this ), |
| aIconCtrl( this, WB_ICON | WB_NOCOLUMNHEADER | WB_HIGHLIGHTFRAME | /*!WB_NOSELECTION |*/ |
| WB_NODRAGSELECTION | WB_TABSTOP | WB_CLIPCHILDREN ), |
| aNewDocumentRootURL( ASCII_STR("private:newdoc") ), |
| aMyDocumentsRootURL( SvtPathOptions().GetWorkPath() ), |
| aSamplesFolderRootURL( SvtPathOptions(). |
| SubstituteVariable( String( ASCII_STR("$(insturl)/share/samples/$(vlang)") ) ) ), |
| nMaxTextLength( 0 ) |
| |
| { |
| aDummyHeaderBar.Show(); |
| |
| aIconCtrl.SetAccessibleName( String( RTL_CONSTASCII_USTRINGPARAM("Groups") ) ); |
| aIconCtrl.SetHelpId( HID_TEMPLATEDLG_ICONCTRL ); |
| aIconCtrl.SetChoiceWithCursor( sal_True ); |
| aIconCtrl.SetSelectionMode( SINGLE_SELECTION ); |
| aIconCtrl.Show(); |
| |
| // detect the root URL of templates |
| Reference< XDocumentTemplates > xTemplates( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.DocumentTemplates") ), UNO_QUERY ); |
| |
| if ( xTemplates.is() ) |
| { |
| Reference < XContent > aRootContent = xTemplates->getContent(); |
| Reference < XCommandEnvironment > aCmdEnv; |
| |
| if ( aRootContent.is() ) |
| aTemplateRootURL = aRootContent->getIdentifier()->getContentIdentifier(); |
| } |
| |
| // insert the categories |
| // "New Document" |
| sal_Bool bHiContrast = GetSettings().GetStyleSettings().GetHighContrastMode(); |
| Image aImage( SvtResId( bHiContrast ? IMG_SVT_NEWDOC_HC : IMG_SVT_NEWDOC ) ); |
| nMaxTextLength = aImage.GetSizePixel().Width(); |
| String aEntryStr = String( SvtResId( STR_SVT_NEWDOC ) ); |
| SvxIconChoiceCtrlEntry* pEntry = |
| aIconCtrl.InsertEntry( aEntryStr, aImage, ICON_POS_NEWDOC ); |
| pEntry->SetUserData( new String( aNewDocumentRootURL ) ); |
| pEntry->SetQuickHelpText( String( SvtResId( STR_SVT_NEWDOC_HELP ) ) ); |
| DBG_ASSERT( !pEntry->GetBoundRect().IsEmpty(), "empty rectangle" ); |
| long nTemp = pEntry->GetBoundRect().GetSize().Width(); |
| if (nTemp > nMaxTextLength) |
| nMaxTextLength = nTemp; |
| |
| // "Templates" |
| if( aTemplateRootURL.Len() > 0 ) |
| { |
| aEntryStr = String( SvtResId( STR_SVT_TEMPLATES ) ); |
| pEntry = aIconCtrl.InsertEntry( |
| aEntryStr, Image( SvtResId( bHiContrast ? IMG_SVT_TEMPLATES_HC : IMG_SVT_TEMPLATES ) ), ICON_POS_TEMPLATES ); |
| pEntry->SetUserData( new String( aTemplateRootURL ) ); |
| pEntry->SetQuickHelpText( String( SvtResId( STR_SVT_TEMPLATES_HELP ) ) ); |
| DBG_ASSERT( !pEntry->GetBoundRect().IsEmpty(), "empty rectangle" ); |
| nTemp = pEntry->GetBoundRect().GetSize().Width(); |
| if (nTemp > nMaxTextLength) |
| nMaxTextLength = nTemp; |
| } |
| |
| // "My Documents" |
| aEntryStr = String( SvtResId( STR_SVT_MYDOCS ) ); |
| pEntry = aIconCtrl.InsertEntry( |
| aEntryStr, Image( SvtResId( bHiContrast ? IMG_SVT_MYDOCS_HC : IMG_SVT_MYDOCS ) ), ICON_POS_MYDOCS ); |
| pEntry->SetUserData( new String( aMyDocumentsRootURL ) ); |
| pEntry->SetQuickHelpText( String( SvtResId( STR_SVT_MYDOCS_HELP ) ) ); |
| DBG_ASSERT( !pEntry->GetBoundRect().IsEmpty(), "empty rectangle" ); |
| nTemp = pEntry->GetBoundRect().GetSize().Width(); |
| if( nTemp > nMaxTextLength ) |
| nMaxTextLength = nTemp; |
| |
| // "Samples" |
| aEntryStr = String( SvtResId( STR_SVT_SAMPLES ) ); |
| pEntry = aIconCtrl.InsertEntry( |
| aEntryStr, Image( SvtResId( bHiContrast ? IMG_SVT_SAMPLES_HC : IMG_SVT_SAMPLES ) ), ICON_POS_SAMPLES ); |
| pEntry->SetUserData( new String( aSamplesFolderRootURL ) ); |
| pEntry->SetQuickHelpText( String( SvtResId( STR_SVT_SAMPLES_HELP ) ) ); |
| DBG_ASSERT( !pEntry->GetBoundRect().IsEmpty(), "empty rectangle" ); |
| nTemp = pEntry->GetBoundRect().GetSize().Width(); |
| if (nTemp > nMaxTextLength) |
| nMaxTextLength = nTemp; |
| |
| aIconCtrl.CreateAutoMnemonics(); |
| } |
| |
| SvtIconWindow_Impl::~SvtIconWindow_Impl() |
| { |
| for ( sal_uLong i = 0; i < aIconCtrl.GetEntryCount(); ++i ) |
| { |
| SvxIconChoiceCtrlEntry* pEntry = aIconCtrl.GetEntry( i ); |
| delete (String*)pEntry->GetUserData(); |
| } |
| } |
| |
| SvxIconChoiceCtrlEntry* SvtIconWindow_Impl::GetEntry( const String& rURL ) const |
| { |
| SvxIconChoiceCtrlEntry* pEntry = NULL; |
| for ( sal_uLong i = 0; i < aIconCtrl.GetEntryCount(); ++i ) |
| { |
| SvxIconChoiceCtrlEntry* pTemp = aIconCtrl.GetEntry( i ); |
| String aURL( *( (String*)pTemp->GetUserData() ) ); |
| if ( aURL == rURL ) |
| { |
| pEntry = pTemp; |
| break; |
| } |
| } |
| |
| return pEntry; |
| } |
| |
| void SvtIconWindow_Impl::Resize() |
| { |
| Size aWinSize = GetOutputSizePixel(); |
| Size aHeaderSize = aDummyHeaderBar.GetSizePixel(); |
| aHeaderSize.Width() = aWinSize.Width(); |
| aDummyHeaderBar.SetSizePixel( aHeaderSize ); |
| long nHeaderHeight = aHeaderSize.Height(); |
| aWinSize.Height() -= nHeaderHeight; |
| aIconCtrl.SetPosSizePixel( Point( 0, nHeaderHeight ), aWinSize ); |
| aIconCtrl.ArrangeIcons(); |
| } |
| |
| String SvtIconWindow_Impl::GetCursorPosIconURL() const |
| { |
| String aURL; |
| SvxIconChoiceCtrlEntry* pEntry = aIconCtrl.GetCursor( ); |
| if ( pEntry ) |
| aURL = *static_cast<String*>(pEntry->GetUserData()); |
| return aURL; |
| |
| } |
| |
| String SvtIconWindow_Impl::GetSelectedIconURL() const |
| { |
| sal_uLong nPos; |
| SvxIconChoiceCtrlEntry* pEntry = aIconCtrl.GetSelectedEntry( nPos ); |
| String aURL; |
| if ( pEntry ) |
| aURL = *static_cast<String*>(pEntry->GetUserData()); |
| return aURL; |
| } |
| |
| String SvtIconWindow_Impl::GetSelectedIconText() const |
| { |
| sal_uLong nPos; |
| return MnemonicGenerator::EraseAllMnemonicChars( aIconCtrl.GetSelectedEntry( nPos )->GetText() ); |
| } |
| |
| String SvtIconWindow_Impl::GetIconText( const String& rURL ) const |
| { |
| String aText; |
| SvxIconChoiceCtrlEntry* pEntry = GetEntry( rURL ); |
| if ( pEntry ) |
| aText = MnemonicGenerator::EraseAllMnemonicChars( pEntry->GetText() ); |
| return aText; |
| } |
| |
| void SvtIconWindow_Impl::InvalidateIconControl() |
| { |
| aIconCtrl.Invalidate(); |
| } |
| |
| sal_uLong SvtIconWindow_Impl::GetCursorPos() const |
| { |
| sal_uLong nPos = ~sal_uLong(0); |
| |
| SvxIconChoiceCtrlEntry* pCursorEntry = aIconCtrl.GetCursor( ); |
| if ( pCursorEntry ) |
| nPos = aIconCtrl.GetEntryListPos( pCursorEntry ); |
| |
| return nPos; |
| } |
| |
| sal_uLong SvtIconWindow_Impl::GetSelectEntryPos() const |
| { |
| sal_uLong nPos; |
| if ( !aIconCtrl.GetSelectedEntry( nPos ) ) |
| nPos = ~sal_uLong(0); |
| return nPos; |
| } |
| |
| void SvtIconWindow_Impl::SetCursorPos( sal_uLong nPos ) |
| { |
| SvxIconChoiceCtrlEntry* pEntry = aIconCtrl.GetEntry( nPos ); |
| aIconCtrl.SetCursor( pEntry ); |
| aIconCtrl.Invalidate(); |
| aIconCtrl.Update(); |
| } |
| |
| void SvtIconWindow_Impl::SetFocus() |
| { |
| aIconCtrl.GrabFocus(); |
| } |
| |
| long SvtIconWindow_Impl::CalcHeight() const |
| { |
| // calculate the required height of the IconControl |
| long nHeight = 0; |
| sal_uLong nCount = aIconCtrl.GetEntryCount(); |
| if ( nCount > 0 ) |
| // bottom of the last icon |
| nHeight = aIconCtrl.GetEntry(nCount-1)->GetBoundRect().Bottom(); |
| |
| // + headerbar height |
| nHeight += aDummyHeaderBar.GetSizePixel().Height(); |
| |
| return nHeight; |
| } |
| |
| sal_Bool SvtIconWindow_Impl::IsRootURL( const String& rURL ) const |
| { |
| return rURL == aNewDocumentRootURL || |
| rURL == aTemplateRootURL || |
| rURL == aMyDocumentsRootURL || |
| rURL == aSamplesFolderRootURL; |
| } |
| |
| sal_uLong SvtIconWindow_Impl::GetRootPos( const String& rURL ) const |
| { |
| sal_uLong nPos = ~sal_uLong(0); |
| if ( aNewDocumentRootURL.Match( rURL ) == STRING_MATCH ) |
| nPos = 0; |
| else if ( aTemplateRootURL.Match( rURL ) == STRING_MATCH ) |
| nPos = 1; |
| else if ( aMyDocumentsRootURL.Match( rURL ) == STRING_MATCH ) |
| nPos = 2; |
| else if ( aSamplesFolderRootURL.Match( rURL ) == STRING_MATCH ) |
| nPos = 3; |
| else if ( rURL.Match( aMyDocumentsRootURL ) == STRING_MATCH ) |
| nPos = 2; |
| else |
| { |
| DBG_WARNING( "SvtIconWindow_Impl::GetRootPos(): invalid position" ); |
| nPos = 2; |
| } |
| |
| return nPos; |
| } |
| |
| void SvtIconWindow_Impl::UpdateIcons( sal_Bool _bHiContrast ) |
| { |
| aIconCtrl.GetEntry( ICON_POS_NEWDOC )->SetImage( |
| Image( SvtResId( _bHiContrast ? IMG_SVT_NEWDOC_HC : IMG_SVT_NEWDOC ) ) ); |
| aIconCtrl.GetEntry( ICON_POS_TEMPLATES )->SetImage( |
| Image( SvtResId( _bHiContrast ? IMG_SVT_TEMPLATES_HC : IMG_SVT_TEMPLATES ) ) ); |
| aIconCtrl.GetEntry( ICON_POS_MYDOCS )->SetImage( |
| Image( SvtResId( _bHiContrast ? IMG_SVT_MYDOCS_HC : IMG_SVT_MYDOCS ) ) ); |
| aIconCtrl.GetEntry( ICON_POS_SAMPLES )->SetImage( |
| Image( SvtResId( _bHiContrast ? IMG_SVT_SAMPLES_HC : IMG_SVT_SAMPLES ) ) ); |
| } |
| /* -----------------27.11.2002 16:58----------------- |
| * |
| * --------------------------------------------------*/ |
| void SvtIconWindow_Impl::SelectFolder(sal_Int32 nFolderPosition) |
| { |
| SvxIconChoiceCtrlEntry* pEntry = aIconCtrl.GetEntry( nFolderPosition ); |
| if(pEntry) |
| { |
| aIconCtrl.SetCursor( pEntry ); |
| aIconCtrl.GetClickHdl().Call(&aIconCtrl); |
| } |
| } |
| |
| // class SvtFileViewWindow_Impl -----------------------------------------_ |
| |
| SvtFileViewWindow_Impl::SvtFileViewWindow_Impl( SvtTemplateWindow* pParent ) : |
| |
| Window( pParent, WB_DIALOGCONTROL | WB_TABSTOP | WB_BORDER | WB_3DLOOK ), |
| |
| rParent ( *pParent ), |
| aFileView ( this, SvtResId( CTRL_FILEVIEW ), FILEVIEW_SHOW_TITLE ), |
| bIsTemplateFolder ( sal_False ) |
| |
| { |
| aFileView.SetStyle( aFileView.GetStyle() | WB_DIALOGCONTROL | WB_TABSTOP ); |
| aFileView.SetHelpId( HID_TEMPLATEDLG_FILEVIEW ); |
| aFileView.Show(); |
| aFileView.SetPosPixel( Point( 0, 0 ) ); |
| aFileView.EnableAutoResize(); |
| aFileView.EnableContextMenu( sal_False ); |
| aFileView.EnableDelete( sal_False ); |
| } |
| |
| SvtFileViewWindow_Impl::~SvtFileViewWindow_Impl() |
| { |
| } |
| |
| void GetMenuEntry_Impl |
| ( |
| Sequence< PropertyValue >& aDynamicMenuEntry, |
| ::rtl::OUString& rTitle, |
| ::rtl::OUString& rURL, |
| ::rtl::OUString& rFrame, |
| ::rtl::OUString& rImageId |
| ) |
| { |
| for ( int i = 0; i < aDynamicMenuEntry.getLength(); i++ ) |
| { |
| if ( aDynamicMenuEntry[i].Name == DYNAMICMENU_PROPERTYNAME_URL ) |
| aDynamicMenuEntry[i].Value >>= rURL; |
| else if ( aDynamicMenuEntry[i].Name == DYNAMICMENU_PROPERTYNAME_TITLE ) |
| aDynamicMenuEntry[i].Value >>= rTitle; |
| else if ( aDynamicMenuEntry[i].Name == DYNAMICMENU_PROPERTYNAME_IMAGEIDENTIFIER ) |
| aDynamicMenuEntry[i].Value >>= rImageId; |
| else if ( aDynamicMenuEntry[i].Name == DYNAMICMENU_PROPERTYNAME_TARGETNAME ) |
| aDynamicMenuEntry[i].Value >>= rFrame; |
| } |
| } |
| Sequence< ::rtl::OUString > SvtFileViewWindow_Impl::GetNewDocContents() const |
| { |
| NewDocList_Impl aNewDocs; |
| Sequence< Sequence< PropertyValue > > aDynamicMenuEntries; |
| aDynamicMenuEntries = SvtDynamicMenuOptions().GetMenu( E_NEWMENU ); |
| |
| ::rtl::OUString aTitle; |
| ::rtl::OUString aURL; |
| ::rtl::OUString aImageURL; |
| ::rtl::OUString aTargetFrame; |
| |
| sal_uInt32 i, nCount = aDynamicMenuEntries.getLength(); |
| ::rtl::OUString sSeparator( ASCII_STR("private:separator") ); |
| ::rtl::OUString sSlotURL( ASCII_STR("slot:5500") ); |
| |
| for ( i = 0; i < nCount; ++i ) |
| { |
| GetMenuEntry_Impl( aDynamicMenuEntries[i], aTitle, aURL, aTargetFrame, aImageURL ); |
| |
| if ( aURL == sSeparator || aURL == sSlotURL ) |
| continue; |
| else |
| { |
| // title |
| String aRow = MnemonicGenerator::EraseAllMnemonicChars( String( aTitle ) ); |
| aRow += '\t'; |
| // no type |
| aRow += '\t'; |
| // no size |
| aRow += '\t'; |
| // no date |
| aRow += '\t'; |
| // url |
| aRow += String( aURL ); |
| aRow += '\t'; |
| // folder == false |
| aRow += '0'; |
| // image url? |
| if ( aImageURL.getLength() > 0 ) |
| { |
| aRow += '\t'; |
| aRow += String( aImageURL ); |
| } |
| |
| ::rtl::OUString* pRow = new ::rtl::OUString( aRow ); |
| aNewDocs.Insert( pRow, LIST_APPEND ); |
| } |
| } |
| |
| nCount = aNewDocs.Count(); |
| Sequence < ::rtl::OUString > aRet( nCount ); |
| ::rtl::OUString* pRet = aRet.getArray(); |
| for ( i = 0; i < nCount; ++i ) |
| { |
| ::rtl::OUString* pNewDoc = aNewDocs.GetObject(i); |
| pRet[i] = *( pNewDoc ); |
| delete pNewDoc; |
| } |
| |
| return aRet; |
| } |
| |
| void SvtFileViewWindow_Impl::Resize() |
| { |
| Size aWinSize = GetOutputSizePixel(); |
| |
| static int x = 0; |
| static int y = 0; |
| |
| aWinSize.nA += x; |
| aWinSize.nB += y; |
| aFileView.SetSizePixel( aWinSize ); |
| } |
| |
| String SvtFileViewWindow_Impl::GetSelectedFile() const |
| { |
| return aFileView.GetCurrentURL(); |
| } |
| |
| void SvtFileViewWindow_Impl::OpenFolder( const String& rURL ) |
| { |
| aFolderURL = rURL; |
| |
| rParent.SetPrevLevelButtonState( rURL ); |
| |
| aFileView.SetUrlFilter( &aURLFilter ); |
| |
| INetProtocol eProt = INetURLObject( rURL ).GetProtocol(); |
| bIsTemplateFolder = ( eProt == INET_PROT_VND_SUN_STAR_HIER ); |
| bool isNewDocumentFolder = ( eProt == INET_PROT_PRIVATE ); |
| |
| aURLFilter.enableFilter( !bIsTemplateFolder && !isNewDocumentFolder ); |
| |
| if ( isNewDocumentFolder ) |
| { |
| aFileView.EnableNameReplacing( sal_False ); |
| aFileView.Initialize( GetNewDocContents() ); |
| } |
| else |
| { |
| xub_StrLen nSampFoldLen = aSamplesFolderURL.Len(); |
| aFileView.EnableNameReplacing( |
| nSampFoldLen && rURL.CompareTo( aSamplesFolderURL, nSampFoldLen ) == COMPARE_EQUAL ); |
| aFileView.Initialize( rURL, String(), NULL ); |
| } |
| aNewFolderLink.Call( this ); |
| } |
| |
| sal_Bool SvtFileViewWindow_Impl::HasPreviousLevel( String& rURL ) const |
| { |
| INetURLObject aViewObj( aFileView.GetViewURL() ); |
| INetURLObject aRootObj( aCurrentRootURL ); |
| INetURLObject aMyDocObj( aMyDocumentsURL ); |
| |
| return ( ( aViewObj != aRootObj || aRootObj == aMyDocObj ) && aFileView.GetParentURL( rURL ) ); |
| } |
| |
| String SvtFileViewWindow_Impl::GetFolderTitle() const |
| { |
| String aTitle; |
| ::utl::UCBContentHelper::GetTitle( aFolderURL, aTitle ); |
| return aTitle; |
| } |
| |
| void SvtFileViewWindow_Impl::SetFocus() |
| { |
| aFileView.SetFocus(); |
| } |
| |
| // class SvtDocInfoTable_Impl -------------------------------------------- |
| |
| SvtDocInfoTable_Impl::SvtDocInfoTable_Impl() : |
| |
| ResStringArray( SvtResId( STRARY_SVT_DOCINFO ) ) |
| |
| { |
| } |
| // ----------------------------------------------------------------------------- |
| // class SvtExtendedMultiLineEdit_Impl -------------------------------------------- |
| SvtExtendedMultiLineEdit_Impl::SvtExtendedMultiLineEdit_Impl( Window* pParent,WinBits _nBits ) : |
| |
| ExtMultiLineEdit( pParent, _nBits ) |
| |
| { |
| SetLeftMargin( 10 ); |
| } |
| // ----------------------------------------------------------------------------- |
| void SvtExtendedMultiLineEdit_Impl::InsertEntry( const String& rTitle, const String& rValue ) |
| { |
| String aText( '\n' ); |
| aText += rTitle; |
| aText += ':'; |
| InsertText( aText ); |
| sal_uLong nPara = GetParagraphCount() - 1; |
| SetAttrib( TextAttribFontWeight( WEIGHT_BOLD ), nPara, 0, aText.Len() ); |
| |
| aText = '\n'; |
| aText += rValue; |
| InsertText( aText ); |
| nPara = GetParagraphCount() - 1; |
| SetAttrib( TextAttribFontWeight( WEIGHT_NORMAL ), nPara, 0, aText.Len() ); |
| |
| InsertText( String( '\n' ) ); |
| } |
| // ----------------------------------------------------------------------------- |
| |
| // ----------------------------------------------------------------------- |
| |
| const String& SvtDocInfoTable_Impl::GetString( long nId ) const |
| { |
| sal_uInt32 nPos( FindIndex( nId ) ); |
| |
| if ( RESARRAY_INDEX_NOTFOUND != nPos ) |
| return ResStringArray::GetString( nPos ); |
| else |
| return aEmptyString; |
| } |
| |
| // class SvtFrameWindow_Impl --------------------------------------------- |
| |
| SvtFrameWindow_Impl::SvtFrameWindow_Impl( Window* pParent ) : |
| |
| Window( pParent ) |
| |
| { |
| // detect application language |
| aLocale= SvtPathOptions().GetLocale(); |
| |
| // create windows and frame |
| pEditWin = new ODocumentInfoPreview( this ,WB_LEFT | WB_VSCROLL | WB_READONLY | WB_BORDER | WB_3DLOOK); |
| pTextWin = new Window( this ); |
| xFrame = Reference < XFrame > ( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.Frame") ), UNO_QUERY ); |
| xWindow = VCLUnoHelper::GetInterface( pTextWin ); |
| xFrame->initialize( xWindow ); |
| |
| // create docinfo instance |
| m_xDocProps.set( ::comphelper::getProcessServiceFactory()->createInstance( |
| ASCII_STR("com.sun.star.document.DocumentProperties") ), |
| UNO_QUERY ); |
| |
| pEmptyWin = new Window( this, WB_BORDER | WB_3DLOOK ); |
| } |
| |
| SvtFrameWindow_Impl::~SvtFrameWindow_Impl() |
| { |
| delete pEditWin; |
| delete pEmptyWin; |
| xFrame->dispose(); |
| } |
| |
| void SvtFrameWindow_Impl::ViewEditWin() |
| { |
| pEmptyWin->Hide(); |
| xWindow->setVisible( sal_False ); |
| pTextWin->Hide(); |
| pEditWin->Show(); |
| } |
| |
| void SvtFrameWindow_Impl::ViewTextWin() |
| { |
| pEmptyWin->Hide(); |
| pEditWin->Hide(); |
| xWindow->setVisible( sal_True ); |
| pTextWin->Show(); |
| } |
| |
| void SvtFrameWindow_Impl::ViewEmptyWin() |
| { |
| xWindow->setVisible( sal_False ); |
| pTextWin->Hide(); |
| pEditWin->Hide(); |
| pEmptyWin->Show(); |
| } |
| |
| void SvtFrameWindow_Impl::ViewNonEmptyWin() |
| { |
| if( bDocInfo ) |
| ViewEditWin(); |
| else |
| ViewTextWin(); |
| } |
| |
| IMPL_STATIC_LINK_NOINSTANCE( SvtFrameWindow_Impl, ExecuteHdl_Impl, SvtExecuteInfo*, pExecuteInfo ) |
| { |
| try |
| { |
| pExecuteInfo->xDispatch->dispatch( pExecuteInfo->aTargetURL, Sequence < PropertyValue >() ); |
| } |
| catch ( Exception& ) |
| { |
| } |
| |
| delete pExecuteInfo; |
| return 0; |
| } |
| |
| void SvtFrameWindow_Impl::ShowDocInfo( const String& rURL ) |
| { |
| try |
| { |
| uno::Reference < task::XInteractionHandler > xInteractionHandler( ::comphelper::getProcessServiceFactory()->createInstance( |
| ::rtl::OUString::createFromAscii("com.sun.star.task.InteractionHandler") ), uno::UNO_QUERY ); |
| uno::Sequence < beans::PropertyValue> aProps(1); |
| aProps[0].Name = ::rtl::OUString::createFromAscii("InteractionHandler"); |
| aProps[0].Value <<= xInteractionHandler; |
| m_xDocProps->loadFromMedium( rURL, aProps ); |
| pEditWin->fill( m_xDocProps, rURL ); |
| } |
| catch ( UnknownPropertyException& ) {} |
| catch ( Exception& ) {} |
| } |
| |
| void SvtFrameWindow_Impl::Resize() |
| { |
| Size aWinSize = GetOutputSizePixel(); |
| pEditWin->SetSizePixel( aWinSize ); |
| pTextWin->SetSizePixel( aWinSize ); |
| pEmptyWin->SetSizePixel( aWinSize ); |
| } |
| |
| void SvtFrameWindow_Impl::OpenFile( const String& rURL, sal_Bool bPreview, sal_Bool bIsTemplate, sal_Bool bAsTemplate ) |
| { |
| if ( bPreview ) |
| aCurrentURL = rURL; |
| |
| ViewNonEmptyWin(); |
| pEditWin->Clear(); |
| |
| if ( rURL.Len() > 0 && bPreview && m_xDocProps.is() ) |
| ShowDocInfo( rURL ); |
| |
| if ( rURL.Len() == 0 ) |
| { |
| xFrame->setComponent( Reference < com::sun::star::awt::XWindow >(), Reference < XController >() ); |
| ViewEmptyWin(); |
| } |
| else if ( !::utl::UCBContentHelper::IsFolder( rURL ) ) |
| { |
| com::sun::star::util::URL aURL; |
| aURL.Complete = rURL; |
| Reference < com::sun::star::util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.util.URLTransformer" ) ), UNO_QUERY ); |
| xTrans->parseStrict( aURL ); |
| |
| String aTarget; |
| Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY ); |
| if ( bPreview ) |
| aTarget = ASCII_STR("_self"); |
| else |
| { |
| // can be removed if the database application change its URL |
| String sServiceScheme( RTL_CONSTASCII_STRINGPARAM( "service:" ) ); |
| if ( rURL.Match( sServiceScheme ) != sServiceScheme.Len() ) |
| // service URL has no default target |
| aTarget = ASCII_STR("_default"); |
| xProv = Reference < XDispatchProvider >( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.Desktop") ), UNO_QUERY ); |
| } |
| |
| Reference < XDispatch > xDisp = xProv.is() ? |
| xProv->queryDispatch( aURL, aTarget, 0 ) : Reference < XDispatch >(); |
| |
| if ( xDisp.is() ) |
| { |
| if ( bPreview ) |
| { |
| if ( m_aOpenURL != aURL.Complete ) |
| { |
| WaitObject aWaitCursor( GetParent() ); |
| // disabling must be done here, does not work in ctor because |
| // execute of the dialog will overwrite it |
| // ( own execute method would help ) |
| pTextWin->EnableInput( sal_False, sal_True ); |
| if ( pTextWin->IsReallyVisible() ) |
| { |
| sal_Bool b = sal_True; |
| Sequence < PropertyValue > aArgs( 4 ); |
| aArgs[0].Name = ASCII_STR("Preview"); |
| aArgs[0].Value.setValue( &b, ::getBooleanCppuType() ); |
| aArgs[1].Name = ASCII_STR("ReadOnly"); |
| aArgs[1].Value.setValue( &b, ::getBooleanCppuType() ); |
| aArgs[2].Name = ASCII_STR("AsTemplate"); // prevents getting an empty URL with getURL()! |
| |
| uno::Reference < task::XInteractionHandler > xInteractionHandler( ::comphelper::getProcessServiceFactory()->createInstance( |
| ::rtl::OUString::createFromAscii("com.sun.star.task.InteractionHandler") ), uno::UNO_QUERY ); |
| aArgs[3].Name = ::rtl::OUString::createFromAscii("InteractionHandler"); |
| aArgs[3].Value <<= xInteractionHandler; |
| |
| b = sal_False; |
| aArgs[2].Value.setValue( &b, ::getBooleanCppuType() ); |
| xDisp->dispatch( aURL, aArgs ); |
| |
| ::rtl::OUString aDispURL; |
| Reference< ::com::sun::star::frame::XController > xCtrl = xFrame->getController(); |
| if( xCtrl.is() ) |
| { |
| Reference< ::com::sun::star::frame::XModel > xMdl = xCtrl->getModel(); |
| if( xMdl.is() ) |
| aDispURL = xMdl->getURL(); |
| } |
| |
| if( aDispURL != aURL.Complete ) |
| { |
| xFrame->setComponent( Reference < com::sun::star::awt::XWindow >(), Reference < XController >() ); |
| ViewEmptyWin(); |
| m_aOpenURL = rtl::OUString(); |
| } |
| else |
| m_aOpenURL = aDispURL; |
| } |
| } |
| } |
| else if ( bIsTemplate ) |
| { |
| Sequence < PropertyValue > aArgs( 1 ); |
| aArgs[0].Name = ASCII_STR("AsTemplate"); |
| aArgs[0].Value <<= bAsTemplate; |
| xDisp->dispatch( aURL, aArgs ); |
| m_aOpenURL = rtl::OUString(); |
| } |
| else |
| { |
| /* |
| SvtExecuteInfo* pExecuteInfo = new SvtExecuteInfo; |
| pExecuteInfo->xDispatch = xDisp; |
| pExecuteInfo->aTargetURL = aURL; |
| Application::PostUserEvent( |
| STATIC_LINK(0, SvtFrameWindow_Impl, ExecuteHdl_Impl), pExecuteInfo ); |
| */ |
| Sequence < PropertyValue > aArgs; |
| xDisp->dispatch( aURL, aArgs ); |
| m_aOpenURL = rtl::OUString(); |
| } |
| } |
| } |
| } |
| |
| void SvtFrameWindow_Impl::ToggleView( sal_Bool bDI ) |
| { |
| bDocInfo = bDI; |
| |
| // view is set properly in OpenFile() |
| |
| OpenFile( aCurrentURL, sal_True, sal_False, sal_False ); |
| } |
| |
| // class SvtTemplateWindow ----------------------------------------------- |
| |
| SvtTemplateWindow::SvtTemplateWindow( Window* pParent ) : |
| |
| Window( pParent, WB_DIALOGCONTROL ), |
| |
| aFileViewTB ( this, SvtResId( TB_SVT_FILEVIEW ) ), |
| aFrameWinTB ( this, SvtResId( TB_SVT_FRAMEWIN ) ), |
| aSplitWin ( this, WB_DIALOGCONTROL | WB_NOSPLITDRAW ), |
| pHistoryList ( NULL ) |
| |
| { |
| // create windows |
| pIconWin = new SvtIconWindow_Impl( this ); |
| pFileWin = new SvtFileViewWindow_Impl( this ); |
| pFileWin->SetMyDocumentsURL( pIconWin->GetMyDocumentsRootURL() ); |
| pFileWin->SetSamplesFolderURL( pIconWin->GetSamplesFolderURL() ); |
| pFrameWin = new SvtFrameWindow_Impl( this ); |
| |
| // set handlers |
| pIconWin->SetClickHdl( LINK( this, SvtTemplateWindow, IconClickHdl_Impl ) ); |
| pFileWin->SetSelectHdl( LINK( this, SvtTemplateWindow, FileSelectHdl_Impl ) ); |
| pFileWin->SetDoubleClickHdl( LINK( this, SvtTemplateWindow, FileDblClickHdl_Impl ) ); |
| pFileWin->SetNewFolderHdl( LINK( this, SvtTemplateWindow, NewFolderHdl_Impl ) ); |
| |
| // create the split items |
| aSplitWin.SetAlign( WINDOWALIGN_LEFT ); |
| long nWidth = pIconWin->GetMaxTextLength() * 8 / 7 + 1; // extra space for border |
| aSplitWin.InsertItem( ICONWIN_ID, pIconWin, nWidth, SPLITWINDOW_APPEND, 0, SWIB_FIXED ); |
| aSplitWin.InsertItem( FILEWIN_ID, pFileWin, 50, SPLITWINDOW_APPEND, 0, SWIB_PERCENTSIZE ); |
| aSplitWin.InsertItem( FRAMEWIN_ID, pFrameWin, 50, SPLITWINDOW_APPEND, 0, SWIB_PERCENTSIZE ); |
| aSplitWin.SetSplitHdl( LINK( this, SvtTemplateWindow, ResizeHdl_Impl ) ); |
| |
| // show the windows |
| pIconWin->Show(); |
| pFileWin->Show(); |
| pFrameWin->Show(); |
| aSplitWin.Show(); |
| |
| // initialize the timers |
| aSelectTimer.SetTimeout( 200 ); |
| aSelectTimer.SetTimeoutHdl( LINK( this, SvtTemplateWindow, TimeoutHdl_Impl ) ); |
| |
| // initialize the toolboxes and then show them |
| InitToolBoxes(); |
| aFileViewTB.Show(); |
| aFrameWinTB.Show(); |
| |
| ReadViewSettings( ); |
| |
| Application::PostUserEvent( LINK( this, SvtTemplateWindow, ResizeHdl_Impl ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SvtTemplateWindow::~SvtTemplateWindow() |
| { |
| WriteViewSettings( ); |
| |
| delete pIconWin; |
| delete pFileWin; |
| delete pFrameWin; |
| if ( pHistoryList ) |
| { |
| for ( sal_uInt32 i = 0; i < pHistoryList->Count(); ++i ) |
| delete pHistoryList->GetObject(i); |
| delete pHistoryList; |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , IconClickHdl_Impl, SvtIconChoiceCtrl *, EMPTYARG ) |
| { |
| String aURL = pIconWin->GetSelectedIconURL(); |
| if ( !aURL.Len() ) |
| aURL = pIconWin->GetCursorPosIconURL(); |
| if ( pFileWin->GetRootURL() != aURL ) |
| { |
| pFileWin->OpenRoot( aURL ); |
| pIconWin->InvalidateIconControl(); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PRINT, sal_False ); |
| } |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , FileSelectHdl_Impl, SvtFileView *, EMPTYARG ) |
| { |
| aSelectTimer.Start(); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , FileDblClickHdl_Impl, SvtFileView *, EMPTYARG ) |
| { |
| if ( aSelectTimer.IsActive() ) |
| aSelectTimer.Stop(); |
| |
| String aURL = pFileWin->GetSelectedFile(); |
| if ( aURL.Len() > 0 ) |
| { |
| if ( ::utl::UCBContentHelper::IsFolder( aURL ) ) |
| pFileWin->OpenFolder( aURL ); |
| else |
| aDoubleClickHdl.Call( this ); |
| } |
| |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , NewFolderHdl_Impl, SvtFileView *, EMPTYARG ) |
| { |
| pFrameWin->OpenFile( String(), sal_True, sal_False, sal_False ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PRINT, sal_False ); |
| |
| String sURL = pFileWin->GetFolderURL(); |
| sal_uLong nPos = pIconWin->GetRootPos( sURL ); |
| AppendHistoryURL( sURL, nPos ); |
| |
| aNewFolderHdl.Call( this ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , TimeoutHdl_Impl, Timer *, EMPTYARG ) |
| { |
| aSelectHdl.Call( this ); |
| String sURL = pFileWin->GetSelectedFile(); |
| sal_Bool bIsNewDoc = ( pIconWin->GetSelectEntryPos() == ICON_POS_NEWDOC ); |
| sal_Bool bIsFile = ( sURL.Len() != 0 && !::utl::UCBContentHelper::IsFolder( sURL ) && |
| INetURLObject( sURL ).GetProtocol() != INET_PROT_PRIVATE && !bIsNewDoc ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PRINT, bIsFile ); |
| aFrameWinTB.EnableItem( TI_DOCTEMPLATE_PREVIEW, !bIsNewDoc ); |
| |
| if ( bIsFile ) |
| pFrameWin->OpenFile( sURL, sal_True, sal_False, sal_False ); |
| else if ( bIsNewDoc && aFrameWinTB.IsItemChecked( TI_DOCTEMPLATE_PREVIEW ) ) |
| { |
| aFrameWinTB.CheckItem( TI_DOCTEMPLATE_DOCINFO ); |
| DoAction( TI_DOCTEMPLATE_DOCINFO ); |
| } |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , ClickHdl_Impl, ToolBox *, pToolBox ) |
| { |
| DoAction( pToolBox->GetCurItemId() ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtTemplateWindow , ResizeHdl_Impl, SplitWindow *, EMPTYARG ) |
| { |
| Resize(); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::PrintFile( const String& rURL ) |
| { |
| // open the file readonly and hidden |
| Sequence < PropertyValue > aArgs( 2 ); |
| aArgs[0].Name = ASCII_STR("ReadOnly"); |
| aArgs[0].Value <<= sal_True; |
| aArgs[1].Name = ASCII_STR("Hidden"); |
| aArgs[1].Value <<= sal_True; |
| |
| Reference < XComponentLoader > xDesktop( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.Desktop") ), UNO_QUERY ); |
| Reference < XModel > xModel( xDesktop->loadComponentFromURL( |
| rURL, ASCII_STR("_blank"), 0, aArgs ), UNO_QUERY ); |
| if ( xModel.is() ) |
| { |
| // print |
| Reference < XPrintable > xPrintable( xModel, UNO_QUERY ); |
| if ( xPrintable.is() ) |
| xPrintable->print( Sequence < PropertyValue >() ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::AppendHistoryURL( const String& rURL, sal_uLong nGroup ) |
| { |
| sal_Bool bInsert = sal_True; |
| if ( !pHistoryList ) |
| pHistoryList = new HistoryList_Impl; |
| else if ( pHistoryList->Count() > 0 ) |
| { |
| FolderHistory* pLastEntry = pHistoryList->GetObject( pHistoryList->Count() - 1 ); |
| bInsert = ( rURL != pLastEntry->m_sURL); |
| } |
| |
| if ( bInsert ) |
| { |
| FolderHistory* pEntry = new FolderHistory( rURL, nGroup ); |
| pHistoryList->Insert( pEntry, LIST_APPEND ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_BACK, pHistoryList->Count() > 1 ); |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::OpenHistory() |
| { |
| FolderHistory* pEntry = pHistoryList->Remove( pHistoryList->Count() - 1 ); |
| pEntry = pHistoryList->Remove( pHistoryList->Count() - 1 ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_BACK, pHistoryList->Count() > 1 ); |
| pFileWin->OpenFolder( pEntry->m_sURL ); |
| pIconWin->SetCursorPos( pEntry->m_nGroup ); |
| delete pEntry; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::DoAction( sal_uInt16 nAction ) |
| { |
| switch( nAction ) |
| { |
| case TI_DOCTEMPLATE_BACK : |
| { |
| if ( pHistoryList && pHistoryList->Count() > 1 ) |
| OpenHistory(); |
| break; |
| } |
| |
| case TI_DOCTEMPLATE_PREV : |
| { |
| String aURL; |
| if ( pFileWin->HasPreviousLevel( aURL ) ) |
| pFileWin->OpenFolder( aURL ); |
| break; |
| } |
| |
| case TI_DOCTEMPLATE_PRINT : |
| { |
| String sPrintFile( pFileWin->GetSelectedFile() ); |
| if ( sPrintFile.Len() > 0 ) |
| PrintFile( sPrintFile ); |
| break; |
| } |
| |
| case TI_DOCTEMPLATE_DOCINFO : |
| case TI_DOCTEMPLATE_PREVIEW : |
| { |
| pFrameWin->ToggleView( TI_DOCTEMPLATE_DOCINFO == nAction ); |
| break; |
| } |
| } |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::InitToolBoxes() |
| { |
| InitToolBoxImages(); |
| |
| Size aSize = aFileViewTB.CalcWindowSizePixel(); |
| aSize.Height() += 4; |
| aFileViewTB.SetPosSizePixel( Point( 0, 2 ), aSize ); |
| aSize = aFrameWinTB.CalcWindowSizePixel(); |
| aSize.Height() += 4; |
| aFrameWinTB.SetPosSizePixel( Point( pFrameWin->GetPosPixel().X() + 2, 2 ), aSize ); |
| |
| sal_Bool bFlat = ( SvtMiscOptions().GetToolboxStyle() == TOOLBOX_STYLE_FLAT ); |
| if ( bFlat ) |
| { |
| aFileViewTB.SetOutStyle( TOOLBOX_STYLE_FLAT ); |
| aFrameWinTB.SetOutStyle( TOOLBOX_STYLE_FLAT ); |
| } |
| |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_BACK, sal_False ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PREV, sal_False ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PRINT, sal_False ); |
| |
| Link aLink = LINK( this, SvtTemplateWindow, ClickHdl_Impl ); |
| aFileViewTB.SetClickHdl( aLink ); |
| aFrameWinTB.SetClickHdl( aLink ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::InitToolBoxImages() |
| { |
| SvtMiscOptions aMiscOpt; |
| sal_Bool bLarge = aMiscOpt.AreCurrentSymbolsLarge(); |
| sal_Bool bHiContrast = aFileViewTB.GetSettings().GetStyleSettings().GetHighContrastMode(); |
| |
| aFileViewTB.SetItemImage( TI_DOCTEMPLATE_BACK, Image( SvtResId( |
| bLarge ? bHiContrast ? IMG_SVT_DOCTEMPL_HC_BACK_LARGE : IMG_SVT_DOCTEMPLATE_BACK_LARGE |
| : bHiContrast ? IMG_SVT_DOCTEMPL_HC_BACK_SMALL : IMG_SVT_DOCTEMPLATE_BACK_SMALL ) ) ); |
| aFileViewTB.SetItemImage( TI_DOCTEMPLATE_PREV, Image( SvtResId( |
| bLarge ? bHiContrast ? IMG_SVT_DOCTEMPL_HC_PREV_LARGE : IMG_SVT_DOCTEMPLATE_PREV_LARGE |
| : bHiContrast ? IMG_SVT_DOCTEMPL_HC_PREV_SMALL : IMG_SVT_DOCTEMPLATE_PREV_SMALL ) ) ); |
| aFileViewTB.SetItemImage( TI_DOCTEMPLATE_PRINT, Image( SvtResId( |
| bLarge ? bHiContrast ? IMG_SVT_DOCTEMPL_HC_PRINT_LARGE : IMG_SVT_DOCTEMPLATE_PRINT_LARGE |
| : bHiContrast ? IMG_SVT_DOCTEMPL_HC_PRINT_SMALL : IMG_SVT_DOCTEMPLATE_PRINT_SMALL ) ) ); |
| |
| aFrameWinTB.SetItemImage( TI_DOCTEMPLATE_DOCINFO, Image( SvtResId( |
| bLarge ? bHiContrast ? IMG_SVT_DOCTEMPL_HC_DOCINFO_LARGE : IMG_SVT_DOCTEMPLATE_DOCINFO_LARGE |
| : bHiContrast ? IMG_SVT_DOCTEMPL_HC_DOCINFO_SMALL : IMG_SVT_DOCTEMPLATE_DOCINFO_SMALL ) ) ); |
| aFrameWinTB.SetItemImage( TI_DOCTEMPLATE_PREVIEW, Image( SvtResId( |
| bLarge ? bHiContrast ? IMG_SVT_DOCTEMPL_HC_PREVIEW_LARGE : IMG_SVT_DOCTEMPLATE_PREVIEW_LARGE |
| : bHiContrast ? IMG_SVT_DOCTEMPL_HC_PREVIEW_SMALL : IMG_SVT_DOCTEMPLATE_PREVIEW_SMALL ) ) ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::UpdateIcons() |
| { |
| pIconWin->UpdateIcons( aFileViewTB.GetSettings().GetStyleSettings().GetHighContrastMode() ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| long SvtTemplateWindow::PreNotify( NotifyEvent& rNEvt ) |
| { |
| sal_uInt16 nType = rNEvt.GetType(); |
| long nRet = 0; |
| |
| if ( EVENT_KEYINPUT == nType && rNEvt.GetKeyEvent() ) |
| { |
| const KeyCode& rKeyCode = rNEvt.GetKeyEvent()->GetKeyCode(); |
| sal_uInt16 nCode = rKeyCode.GetCode(); |
| |
| if ( KEY_BACKSPACE == nCode && !rKeyCode.GetModifier() && pFileWin->HasChildPathFocus() ) |
| { |
| DoAction( TI_DOCTEMPLATE_BACK ); |
| nRet = 1; |
| } |
| else if ( pIconWin->ProcessKeyEvent( *rNEvt.GetKeyEvent() ) ) |
| { |
| nRet = 1; |
| } |
| } |
| |
| return nRet ? nRet : Window::PreNotify( rNEvt ); |
| } |
| |
| // ----------------------------------------------------------------------------- |
| |
| void SvtTemplateWindow::DataChanged( const DataChangedEvent& rDCEvt ) |
| { |
| Window::DataChanged( rDCEvt ); |
| |
| if ( ( ( rDCEvt.GetType() == DATACHANGED_SETTINGS ) || |
| ( rDCEvt.GetType() == DATACHANGED_DISPLAY ) ) && |
| ( rDCEvt.GetFlags() & SETTINGS_STYLE ) ) |
| { |
| // update of the background for the area left of the FileView toolbox |
| SetBackground( Wallpaper( GetSettings().GetStyleSettings().GetFaceColor() ) ); |
| // update of the images of the IconChoiceControl |
| UpdateIcons(); |
| // update of the toolbox images |
| InitToolBoxImages(); |
| } |
| } |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::Resize() |
| { |
| long nItemSize = aSplitWin.GetItemSize( ICONWIN_ID ); |
| long nSplitterWidth = Splitter( this, 0 ).GetSizePixel().Width(); |
| |
| Point aPos = aFileViewTB.GetPosPixel(); |
| aPos.X() = nItemSize + nSplitterWidth / 2; |
| aFileViewTB.SetPosPixel( aPos ); |
| |
| Size aWinSize = GetOutputSizePixel(); |
| long nWidth = aWinSize.Width() - aPos.X(); |
| |
| nItemSize = nWidth * aSplitWin.GetItemSize( FILEWIN_ID ) / 100; |
| aPos.X() = pFrameWin->GetPosPixel().X() + 2; |
| aFrameWinTB.SetPosPixel( aPos ); |
| |
| Size aSize = aFileViewTB.GetSizePixel(); |
| aSize.Width() = nItemSize; |
| aFileViewTB.SetSizePixel( aSize ); |
| |
| aSize = aFrameWinTB.GetSizePixel(); |
| aSize.Width() = nWidth - nItemSize; |
| aFrameWinTB.SetSizePixel( aSize ); |
| |
| long nToolBoxHeight = aSize.Height() + aFrameWinTB.GetPosPixel().Y(); |
| aSize = aWinSize; |
| aSize.Height() -= nToolBoxHeight; |
| aSplitWin.SetPosSizePixel( Point( 0, nToolBoxHeight ), aSize ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| String SvtTemplateWindow::GetSelectedFile() const |
| { |
| return pFileWin->GetSelectedFile(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool SvtTemplateWindow::IsFileSelected() const |
| { |
| String aURL = pFileWin->GetSelectedFile(); |
| sal_Bool bRet = ( aURL.Len() > 0 && !::utl::UCBContentHelper::IsFolder( aURL ) ); |
| return bRet; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::OpenFile( sal_Bool bNotAsTemplate ) |
| { |
| String aURL = pFileWin->GetSelectedFile(); |
| if ( aURL.Len() > 0 && !::utl::UCBContentHelper::IsFolder( aURL ) ) |
| pFrameWin->OpenFile( aURL, sal_False, pFileWin->IsTemplateFolder(), !bNotAsTemplate ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| String SvtTemplateWindow::GetFolderTitle() const |
| { |
| String sTitle; |
| String sFolderURL = pFileWin->GetFolderURL(); |
| if ( pIconWin->IsRootURL( sFolderURL ) ) |
| sTitle = pIconWin->GetIconText( sFolderURL ); |
| else |
| sTitle = pFileWin->GetFolderTitle(); |
| return sTitle; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| String SvtTemplateWindow::GetFolderURL() const |
| { |
| return pFileWin->GetFolderURL(); |
| } |
| |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::SetFocus( sal_Bool bIconWin ) |
| { |
| if ( bIconWin ) |
| pIconWin->SetFocus(); |
| else |
| pFileWin->SetFocus(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::OpenTemplateRoot() |
| { |
| pFileWin->OpenFolder( pIconWin->GetTemplateRootURL() ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::SetPrevLevelButtonState( const String& rURL ) |
| { |
| // disable the prev level button on root folder of the icon pane (except My Documents) |
| // and on the root of all (file:/// -> count == 0) |
| INetURLObject aObj( rURL ); |
| sal_Int32 nCount = aObj.getSegmentCount(); |
| sal_Bool bEnable = |
| ( nCount > 0 && |
| ( !pIconWin->IsRootURL( rURL ) || rURL == pIconWin->GetMyDocumentsRootURL() ) ); |
| aFileViewTB.EnableItem( TI_DOCTEMPLATE_PREV, bEnable ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::ClearHistory() |
| { |
| if( pHistoryList ) |
| pHistoryList->Clear(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| long SvtTemplateWindow::CalcHeight() const |
| { |
| // toolbox height |
| long nHeight = aFileViewTB.GetSizePixel().Height(); |
| // + iconwin height |
| nHeight += pIconWin->CalcHeight(); |
| // + little offset |
| nHeight += 8; |
| return nHeight; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::ReadViewSettings() |
| { |
| // defaults |
| sal_Int32 nSelectedGroup = ICON_POS_TEMPLATES; |
| sal_Int32 nSelectedView = TI_DOCTEMPLATE_DOCINFO; |
| double nSplitRatio = 0.5; |
| ::rtl::OUString sLastFolder; |
| |
| SvtViewOptions aViewSettings( E_DIALOG, VIEWSETTING_NEWFROMTEMPLATE ); |
| if ( aViewSettings.Exists() ) |
| { |
| // read the settings |
| Sequence< NamedValue > aSettings = aViewSettings.GetUserData( ); |
| |
| aViewSettings.GetUserItem( VIEWSETTING_SELECTEDGROUP ) >>= nSelectedGroup; |
| aViewSettings.GetUserItem( VIEWSETTING_SELECTEDVIEW ) >>= nSelectedView; |
| aViewSettings.GetUserItem( VIEWSETTING_SPLITRATIO ) >>= nSplitRatio; |
| aViewSettings.GetUserItem( VIEWSETTING_LASTFOLDER ) >>= sLastFolder; |
| } |
| // normalize |
| if ( nSelectedGroup < ICON_POS_NEWDOC ) nSelectedGroup = ICON_POS_NEWDOC; |
| if ( nSelectedGroup > ICON_POS_SAMPLES ) nSelectedGroup = ICON_POS_SAMPLES; |
| |
| if ( ( TI_DOCTEMPLATE_DOCINFO != nSelectedView ) && ( TI_DOCTEMPLATE_PREVIEW != nSelectedView ) ) |
| nSelectedView = TI_DOCTEMPLATE_DOCINFO; |
| |
| if ( nSplitRatio < 0.2 ) nSplitRatio = 0.2; |
| if ( nSplitRatio > 0.8 ) nSplitRatio = 0.8; |
| |
| // change our view according to the settings |
| |
| // the selected view (details or preview) |
| pFrameWin->ToggleView( TI_DOCTEMPLATE_DOCINFO == nSelectedView ); |
| aFrameWinTB.CheckItem( (sal_uInt16)nSelectedView, sal_True ); |
| |
| // the split ratio |
| sal_Int32 nSplitFileAndFrameSize = aSplitWin.GetItemSize( FILEWIN_ID ) + aSplitWin.GetItemSize( FRAMEWIN_ID ); |
| sal_Int32 nSplitFileSize = (sal_Int32)(nSplitFileAndFrameSize * nSplitRatio); |
| sal_Int32 nSplitFrameSize = nSplitFileAndFrameSize - nSplitFileSize; |
| aSplitWin.SetItemSize( FILEWIN_ID, nSplitFileSize ); |
| aSplitWin.SetItemSize( FRAMEWIN_ID, nSplitFrameSize ); |
| Resize(); |
| |
| // the selected folder |
| pIconWin->SetCursorPos( nSelectedGroup ); |
| |
| // open the last folder or the selected group |
| if ( sLastFolder.getLength() > 0 ) |
| pFileWin->OpenFolder( sLastFolder ); |
| else |
| IconClickHdl_Impl( NULL ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtTemplateWindow::WriteViewSettings() |
| { |
| // collect |
| Sequence< NamedValue > aSettings(4); |
| |
| // the selected group |
| aSettings[0].Name = VIEWSETTING_SELECTEDGROUP; |
| pIconWin->SetFocus(); |
| aSettings[0].Value <<= (sal_Int32)pIconWin->GetCursorPos( ); |
| |
| // the selected view mode |
| aSettings[1].Name = VIEWSETTING_SELECTEDVIEW; |
| aSettings[1].Value <<= sal_Int32( aFrameWinTB.IsItemChecked( TI_DOCTEMPLATE_DOCINFO ) ? TI_DOCTEMPLATE_DOCINFO : TI_DOCTEMPLATE_PREVIEW ); |
| |
| // the split ratio |
| aSettings[2].Name = VIEWSETTING_SPLITRATIO; |
| sal_Int32 nSplitFileSize = aSplitWin.GetItemSize( FILEWIN_ID ); |
| sal_Int32 nSplitFileAndFrameSize = nSplitFileSize + aSplitWin.GetItemSize( FRAMEWIN_ID ); |
| aSettings[2].Value <<= double( 1.0 * nSplitFileSize / nSplitFileAndFrameSize ); |
| |
| // last folder |
| aSettings[3].Name = VIEWSETTING_LASTFOLDER; |
| aSettings[3].Value <<= ::rtl::OUString( pFileWin->GetFolderURL() ); |
| |
| // write |
| SvtViewOptions aViewSettings( E_DIALOG, VIEWSETTING_NEWFROMTEMPLATE ); |
| aViewSettings.SetUserData( aSettings ); |
| } |
| /* -----------------27.11.2002 17:20----------------- |
| * |
| * --------------------------------------------------*/ |
| |
| void SvtTemplateWindow::SelectFolder(sal_Int32 nFolderPosition) |
| { |
| pIconWin->SelectFolder(nFolderPosition); |
| } |
| // struct SvtTmplDlg_Impl ------------------------------------------------ |
| |
| struct SvtTmplDlg_Impl |
| { |
| SvtTemplateWindow* pWin; |
| String aTitle; |
| Timer aUpdateTimer; |
| sal_Bool bSelectNoOpen; |
| |
| uno::Reference< util::XOfficeInstallationDirectories > m_xOfficeInstDirs; |
| |
| |
| SvtTmplDlg_Impl( Window* pParent ) : pWin( new SvtTemplateWindow( pParent ) ) ,bSelectNoOpen( sal_False ) {} |
| |
| ~SvtTmplDlg_Impl() { delete pWin; } |
| |
| uno::Reference< util::XOfficeInstallationDirectories > getOfficeInstDirs(); |
| }; |
| |
| uno::Reference< util::XOfficeInstallationDirectories > SvtTmplDlg_Impl::getOfficeInstDirs() |
| { |
| if ( !m_xOfficeInstDirs.is() ) |
| { |
| try |
| { |
| uno::Reference< lang::XMultiServiceFactory > xSMgr = comphelper::getProcessServiceFactory(); |
| |
| uno::Reference< beans::XPropertySet > xPropSet( xSMgr, uno::UNO_QUERY ); |
| if ( xPropSet.is() ) |
| { |
| uno::Reference< uno::XComponentContext > xCtx; |
| xPropSet->getPropertyValue( |
| rtl::OUString( |
| RTL_CONSTASCII_USTRINGPARAM( "DefaultContext" ) ) ) |
| >>= xCtx; |
| |
| if ( xCtx.is() ) |
| { |
| xCtx->getValueByName( |
| rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( |
| "/singletons/com.sun.star.util.theOfficeInstallationDirectories" ) ) ) |
| >>= m_xOfficeInstDirs; |
| } |
| } |
| } |
| catch( uno::Exception& ) |
| {} |
| } |
| |
| return m_xOfficeInstDirs; |
| } |
| |
| // class SvtDocumentTemplateDialog --------------------------------------- |
| |
| SvtDocumentTemplateDialog::SvtDocumentTemplateDialog( Window* _pParent, SelectOnly ) : |
| ModalDialog( _pParent, SvtResId( DLG_DOCTEMPLATE ) ), |
| |
| aMoreTemplatesLink ( this, SvtResId( FT_DOCTEMPLATE_LINK ) ), |
| aLine ( this, SvtResId( FL_DOCTEMPLATE ) ), |
| aManageBtn ( this, SvtResId( BTN_DOCTEMPLATE_MANAGE ) ), |
| aEditBtn ( this, SvtResId( BTN_DOCTEMPLATE_EDIT ) ), |
| aOKBtn ( this, SvtResId( BTN_DOCTEMPLATE_OPEN ) ), |
| aCancelBtn ( this, SvtResId( BTN_DOCTEMPLATE_CANCEL ) ), |
| aHelpBtn ( this, SvtResId( BTN_DOCTEMPLATE_HELP ) ), |
| pImpl ( NULL ) |
| { |
| FreeResource(); |
| InitImpl( ); |
| |
| // no editing of templates |
| aEditBtn.Hide(); |
| |
| pImpl->bSelectNoOpen = sal_True; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SvtDocumentTemplateDialog::SvtDocumentTemplateDialog( Window* pParent ) : |
| |
| ModalDialog( pParent, SvtResId( DLG_DOCTEMPLATE ) ), |
| |
| aMoreTemplatesLink ( this, SvtResId( FT_DOCTEMPLATE_LINK ) ), |
| aLine ( this, SvtResId( FL_DOCTEMPLATE ) ), |
| aManageBtn ( this, SvtResId( BTN_DOCTEMPLATE_MANAGE ) ), |
| aEditBtn ( this, SvtResId( BTN_DOCTEMPLATE_EDIT ) ), |
| aOKBtn ( this, SvtResId( BTN_DOCTEMPLATE_OPEN ) ), |
| aCancelBtn ( this, SvtResId( BTN_DOCTEMPLATE_CANCEL ) ), |
| aHelpBtn ( this, SvtResId( BTN_DOCTEMPLATE_HELP ) ), |
| pImpl ( NULL ) |
| { |
| FreeResource(); |
| InitImpl( ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| void SvtDocumentTemplateDialog::InitImpl( ) |
| { |
| pImpl = new SvtTmplDlg_Impl( this ); |
| pImpl->aTitle = GetText(); |
| |
| bool bHideLink = ( SvtExtendedSecurityOptions().GetOpenHyperlinkMode() |
| == SvtExtendedSecurityOptions::OPEN_NEVER ); |
| if ( !bHideLink ) |
| { |
| aMoreTemplatesLink.SetURL( String( |
| RTL_CONSTASCII_STRINGPARAM( "http://templates.services.openoffice.org/?cid=923508" ) ) ); |
| aMoreTemplatesLink.SetClickHdl( LINK( this, SvtDocumentTemplateDialog, OpenLinkHdl_Impl ) ); |
| } |
| else |
| aMoreTemplatesLink.Hide(); |
| |
| aManageBtn.SetClickHdl( LINK( this, SvtDocumentTemplateDialog, OrganizerHdl_Impl ) ); |
| Link aLink = LINK( this, SvtDocumentTemplateDialog, OKHdl_Impl ); |
| aEditBtn.SetClickHdl( aLink ); |
| aOKBtn.SetClickHdl( aLink ); |
| |
| pImpl->pWin->SetSelectHdl( LINK( this, SvtDocumentTemplateDialog, SelectHdl_Impl ) ); |
| pImpl->pWin->SetDoubleClickHdl( LINK( this, SvtDocumentTemplateDialog, DoubleClickHdl_Impl ) ); |
| pImpl->pWin->SetNewFolderHdl( LINK( this, SvtDocumentTemplateDialog, NewFolderHdl_Impl ) ); |
| pImpl->pWin->SetSendFocusHdl( LINK( this, SvtDocumentTemplateDialog, SendFocusHdl_Impl ) ); |
| |
| // dynamic height adjustment |
| long nHeight = pImpl->pWin->CalcHeight(); |
| |
| Size aSize = GetOutputSizePixel(); |
| Point aPos = aMoreTemplatesLink.GetPosPixel(); |
| Size a6Size = LogicToPixel( Size( 6, 6 ), MAP_APPFONT ); |
| if ( bHideLink ) |
| aPos.Y() += aMoreTemplatesLink.GetSizePixel().Height(); |
| else |
| aPos.Y() -= a6Size.Height(); |
| long nDelta = aPos.Y() - nHeight; |
| aSize.Height() -= nDelta; |
| SetOutputSizePixel( aSize ); |
| |
| aSize.Height() = nHeight; |
| aSize.Width() -= ( a6Size.Width() * 2 ); |
| pImpl->pWin->SetPosSizePixel( Point( a6Size.Width(), 0 ), aSize ); |
| |
| aPos = aMoreTemplatesLink.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aMoreTemplatesLink.SetPosPixel( aPos ); |
| aPos = aLine.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aLine.SetPosPixel( aPos ); |
| aPos = aManageBtn.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aManageBtn.SetPosPixel( aPos ); |
| aPos = aEditBtn.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aEditBtn.SetPosPixel( aPos ); |
| aPos = aOKBtn.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aOKBtn.SetPosPixel( aPos ); |
| aPos = aCancelBtn.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aCancelBtn.SetPosPixel( aPos ); |
| aPos = aHelpBtn.GetPosPixel(); |
| aPos.Y() -= nDelta; |
| aHelpBtn.SetPosPixel( aPos ); |
| |
| pImpl->pWin->Show(); |
| |
| SelectHdl_Impl( NULL ); |
| NewFolderHdl_Impl( NULL ); |
| |
| UpdateHdl_Impl( NULL ); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| SvtDocumentTemplateDialog::~SvtDocumentTemplateDialog() |
| { |
| delete pImpl; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool SvtDocumentTemplateDialog::IsFileSelected( ) const |
| { |
| return pImpl->pWin->IsFileSelected(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| String SvtDocumentTemplateDialog::GetSelectedFileURL( ) const |
| { |
| return pImpl->pWin->GetSelectedFile(); |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| sal_Bool SvtDocumentTemplateDialog::CanEnableEditBtn() const |
| { |
| sal_Bool bEnable = sal_False; |
| |
| ::rtl::OUString aFolderURL = pImpl->pWin->GetFolderURL(); |
| if ( pImpl->pWin->IsFileSelected() && aFolderURL.getLength() ) |
| { |
| ::rtl::OUString aFileTargetURL = pImpl->pWin->GetSelectedFile(); |
| bEnable = aFileTargetURL.getLength() > 0; |
| } |
| |
| return bEnable; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , SelectHdl_Impl, SvtTemplateWindow *, EMPTYARG ) |
| { |
| aEditBtn.Enable( pImpl->pWin->IsTemplateFolderOpen() && CanEnableEditBtn() ); |
| aOKBtn.Enable( pImpl->pWin->IsFileSelected() ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , DoubleClickHdl_Impl, SvtTemplateWindow *, EMPTYARG ) |
| { |
| EndDialog( RET_OK ); |
| |
| if ( !pImpl->bSelectNoOpen ) |
| pImpl->pWin->OpenFile( !pImpl->pWin->IsTemplateFolderOpen() ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , NewFolderHdl_Impl, SvtTemplateWindow *, EMPTYARG ) |
| { |
| String aNewTitle( pImpl->aTitle ); |
| aNewTitle += String( ASCII_STR(" - ") ); |
| aNewTitle += pImpl->pWin->GetFolderTitle(); |
| SetText( aNewTitle ); |
| |
| SelectHdl_Impl( NULL ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , SendFocusHdl_Impl, SvtTemplateWindow *, EMPTYARG ) |
| { |
| if ( pImpl->pWin->HasIconWinFocus() ) |
| aHelpBtn.GrabFocus(); |
| else |
| { |
| if ( aEditBtn.IsEnabled() ) |
| aEditBtn.GrabFocus(); |
| else if ( aOKBtn.IsEnabled() ) |
| aOKBtn.GrabFocus(); |
| else |
| aCancelBtn.GrabFocus(); |
| } |
| |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , OKHdl_Impl, PushButton *, pBtn ) |
| { |
| if ( pImpl->pWin->IsFileSelected() ) |
| { |
| EndDialog( RET_OK ); |
| |
| if ( !pImpl->bSelectNoOpen ) |
| pImpl->pWin->OpenFile( &aEditBtn == pBtn ); |
| } |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog , OrganizerHdl_Impl, PushButton *, EMPTYARG ) |
| { |
| Window* pOldDefWin = Application::GetDefDialogParent(); |
| Application::SetDefDialogParent( this ); |
| Reference < XFramesSupplier > xDesktop = Reference < XFramesSupplier >( |
| ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.Desktop") ), UNO_QUERY ); |
| Reference < XFrame > xFrame( xDesktop->getActiveFrame() ); |
| if ( !xFrame.is() ) |
| xFrame = Reference < XFrame >( xDesktop, UNO_QUERY ); |
| |
| com::sun::star::util::URL aTargetURL; |
| aTargetURL.Complete = ASCII_STR("slot:5540"); |
| Reference < com::sun::star::util::XURLTransformer > xTrans( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.util.URLTransformer") ), UNO_QUERY ); |
| xTrans->parseStrict( aTargetURL ); |
| |
| Reference < XDispatchProvider > xProv( xFrame, UNO_QUERY ); |
| Reference < XDispatch > xDisp; |
| xDisp = xProv->queryDispatch( aTargetURL, ::rtl::OUString(), 0 ); |
| |
| if ( xDisp.is() ) |
| { |
| Sequence<PropertyValue> aArgs(1); |
| PropertyValue* pArg = aArgs.getArray(); |
| pArg[0].Name = ASCII_STR("Referer"); |
| pArg[0].Value <<= ASCII_STR("private:user"); |
| xDisp->dispatch( aTargetURL, aArgs ); |
| } |
| |
| Application::SetDefDialogParent( pOldDefWin ); |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog, UpdateHdl_Impl, Timer*, _pEventSource ) |
| { |
| pImpl->pWin->SetFocus( sal_False ); |
| Reference< XDocumentTemplates > xTemplates( ::comphelper::getProcessServiceFactory()-> |
| createInstance( ASCII_STR("com.sun.star.frame.DocumentTemplates") ), UNO_QUERY ); |
| if ( xTemplates.is() ) |
| { |
| if ( _pEventSource ) |
| { // it was no direct call, which means it was triggered by the timer, which means we alread checked the necessity |
| WaitObject aWaitCursor( this ); |
| xTemplates->update(); |
| if ( pImpl->pWin->IsTemplateFolderOpen() ) |
| { |
| pImpl->pWin->ClearHistory(); |
| pImpl->pWin->OpenTemplateRoot(); |
| } |
| } |
| else |
| { |
| // check if we really need to do the update |
| ::svt::TemplateFolderCache aCache; |
| if ( aCache.needsUpdate() ) |
| { // yes -> do it asynchronous (it will take a noticeable time) |
| |
| // (but first store the current state) |
| aCache.storeState(); |
| |
| // start the timer for the async update |
| pImpl->aUpdateTimer.SetTimeout( 300 ); |
| pImpl->aUpdateTimer.SetTimeoutHdl( LINK( this, SvtDocumentTemplateDialog, UpdateHdl_Impl ) ); |
| pImpl->aUpdateTimer.Start(); |
| } |
| } |
| } |
| return 0; |
| } |
| |
| // ------------------------------------------------------------------------ |
| |
| IMPL_LINK ( SvtDocumentTemplateDialog, OpenLinkHdl_Impl, svt::FixedHyperlink*, EMPTYARG ) |
| { |
| ::rtl::OUString sURL( aMoreTemplatesLink.GetURL() ); |
| if ( sURL.getLength() > 0 ) |
| { |
| try |
| { |
| uno::Reference< com::sun::star::system::XSystemShellExecute > xSystemShell( |
| com::sun::star::system::SystemShellExecute::create( |
| ::comphelper::getProcessComponentContext() ) ); |
| if ( xSystemShell.is() ) |
| xSystemShell->execute( sURL, ::rtl::OUString(), com::sun::star::system::SystemShellExecuteFlags::DEFAULTS ); |
| EndDialog( RET_CANCEL ); |
| } |
| catch( const uno::Exception& e ) |
| { |
| OSL_TRACE( "Caught exception: %s\n thread terminated.\n", |
| rtl::OUStringToOString(e.Message, RTL_TEXTENCODING_UTF8).getStr()); |
| } |
| } |
| return 0; |
| } |
| |
| /* -----------------27.11.2002 16:54----------------- |
| * |
| * --------------------------------------------------*/ |
| void SvtDocumentTemplateDialog::SelectTemplateFolder() |
| { |
| pImpl->pWin->SelectFolder(ICON_POS_TEMPLATES); |
| } |
| |