From 9921a2d507793bff4a231c74d95d2cc32905cf5e Mon Sep 17 00:00:00 2001 From: Tino Rachui Date: Thu, 28 Mar 2002 07:57:33 +0000 Subject: #98418# --- fpicker/source/win32/filepicker/FileOpenDlg.cxx | 457 +++++++++------------ fpicker/source/win32/filepicker/FileOpenDlg.hxx | 130 ++---- fpicker/source/win32/filepicker/FilePicker.cxx | 397 +++++++++--------- fpicker/source/win32/filepicker/FilePicker.hxx | 17 +- .../source/win32/filepicker/WinFileOpenImpl.cxx | 229 ++++++----- .../source/win32/filepicker/WinFileOpenImpl.hxx | 6 +- .../source/win32/filepicker/asynceventnotifier.cxx | 45 +- .../source/win32/filepicker/asynceventnotifier.hxx | 9 +- .../source/win32/filepicker/getfilenamewrapper.cxx | 214 +++++----- .../source/win32/filepicker/getfilenamewrapper.hxx | 91 +--- fpicker/source/win32/filepicker/previewadapter.cxx | 24 +- fpicker/source/win32/filepicker/previewadapter.hxx | 8 +- 12 files changed, 690 insertions(+), 937 deletions(-) (limited to 'fpicker') diff --git a/fpicker/source/win32/filepicker/FileOpenDlg.cxx b/fpicker/source/win32/filepicker/FileOpenDlg.cxx index 5a6b7a332aaa..d921561676b7 100644 --- a/fpicker/source/win32/filepicker/FileOpenDlg.cxx +++ b/fpicker/source/win32/filepicker/FileOpenDlg.cxx @@ -2,9 +2,9 @@ * * $RCSfile: FileOpenDlg.cxx,v $ * - * $Revision: 1.6 $ + * $Revision: 1.7 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:32:14 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -78,12 +78,6 @@ #include #include -//------------------------------------------------------------------------ -// namespace directives -//------------------------------------------------------------------------ - -using rtl::OUString; - //------------------------------------------------------------------------ // constants //------------------------------------------------------------------------ @@ -112,18 +106,18 @@ namespace /* private */ //------------------------------------------------------------------------ CFileOpenDialog::CFileOpenDialog( - sal_Bool bFileOpenDialog, + bool bFileOpenDialog, sal_uInt32 dwFlags, sal_uInt32 dwTemplateId, - HINSTANCE hInstance ) : - m_filterBuffer( MAX_FILTER_BUFF_SIZE, sal_True ), - m_fileNameBuffer( MAX_FILENAME_BUFF_SIZE ), - m_fileTitleBuffer( MAX_FILETITLE_BUFF_SIZE ), - m_helperBuffer( MAX_FILENAME_BUFF_SIZE ), - m_hwndFileOpenDlg( 0 ), - m_hwndFileOpenDlgChild( 0 ), - m_bFileOpenDialog( bFileOpenDialog ), - m_GetFileNameWrapper( CGetFileNameWrapper::create( ) ) + HINSTANCE hInstance) : + m_hwndFileOpenDlg(0), + m_hwndFileOpenDlgChild(0), + m_bFileOpenDialog(bFileOpenDialog), + m_filterBuffer(MAX_FILTER_BUFF_SIZE), + m_fileTitleBuffer(MAX_FILETITLE_BUFF_SIZE), + m_helperBuffer(MAX_FILENAME_BUFF_SIZE), + m_fileNameBuffer(MAX_FILENAME_BUFF_SIZE), + m_pfnBaseDlgProc(0) { // initialize the OPENFILENAME struct if (IsWindows2000Platform()) @@ -152,36 +146,33 @@ CFileOpenDialog::CFileOpenDialog( // we get a parent window (using a vcl window?) m_ofn.hwndOwner = GetForegroundWindow( ); - // we don't use custom filters - m_ofn.lpstrCustomFilter = 0; - - m_ofn.lpstrFile = m_fileNameBuffer; - m_ofn.nMaxFile = m_fileNameBuffer.size( ); + m_ofn.lpstrFile = const_cast(m_fileNameBuffer.getStr()); + m_ofn.nMaxFile = m_fileNameBuffer.getCapacity(); - m_ofn.lpstrFileTitle = m_fileTitleBuffer; - m_ofn.nMaxFileTitle = m_fileTitleBuffer.size( ); + m_ofn.lpstrFileTitle = const_cast(m_fileTitleBuffer.getStr()); + m_ofn.nMaxFileTitle = m_fileTitleBuffer.getCapacity(); m_ofn.lpfnHook = CFileOpenDialog::ofnHookProc; // set a custom template - if ( dwTemplateId ) + if (dwTemplateId) { - OSL_ASSERT( hInstance ); + OSL_ASSERT(hInstance); m_ofn.Flags |= OFN_ENABLETEMPLATE; - m_ofn.lpTemplateName = MAKEINTRESOURCEW( dwTemplateId ); + m_ofn.lpTemplateName = MAKEINTRESOURCEW(dwTemplateId); m_ofn.hInstance = hInstance; } // set a pointer to myself as ofn parameter - m_ofn.lCustData = reinterpret_cast< long > ( this ); + m_ofn.lCustData = reinterpret_cast(this); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -CFileOpenDialog::~CFileOpenDialog( ) +CFileOpenDialog::~CFileOpenDialog() { } @@ -189,30 +180,31 @@ CFileOpenDialog::~CFileOpenDialog( ) // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::setTitle( const OUString& aTitle ) +void SAL_CALL CFileOpenDialog::setTitle(const rtl::OUString& aTitle) { - m_dialogTitle = aTitle.getStr( ); - m_ofn.lpstrTitle = m_dialogTitle.getStr( ); + m_dialogTitle = aTitle; + m_ofn.lpstrTitle = m_dialogTitle.getStr(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -void CFileOpenDialog::setFilter( const OUString& aFilter ) +void CFileOpenDialog::setFilter(const rtl::OUString& aFilter) { - m_filterBuffer.resize( aFilter.getLength( ) + 1 ); - m_filterBuffer.fill( aFilter.getStr( ), aFilter.getLength( ) ); - m_ofn.lpstrFilter = m_filterBuffer; + m_filterBuffer.ensureCapacity(aFilter.getLength()); + m_filterBuffer.setLength(0); + m_filterBuffer.append(aFilter); + m_ofn.lpstrFilter = m_filterBuffer.getStr(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -sal_Bool CFileOpenDialog::setFilterIndex( sal_uInt32 aIndex ) +bool CFileOpenDialog::setFilterIndex(sal_uInt32 aIndex) { - OSL_ASSERT( aIndex > 0 ); + OSL_ASSERT(aIndex > 0); m_ofn.nFilterIndex = aIndex; return sal_True; } @@ -221,7 +213,7 @@ sal_Bool CFileOpenDialog::setFilterIndex( sal_uInt32 aIndex ) // //------------------------------------------------------------------------ -sal_uInt32 CFileOpenDialog::getSelectedFilterIndex( ) const +sal_uInt32 CFileOpenDialog::getSelectedFilterIndex() const { return m_ofn.nFilterIndex; } @@ -230,18 +222,18 @@ sal_uInt32 CFileOpenDialog::getSelectedFilterIndex( ) const // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::setDefaultName( const OUString& aName ) +void SAL_CALL CFileOpenDialog::setDefaultName(const rtl::OUString& aName) { - m_fileNameBuffer.empty( ); - m_fileNameBuffer.fill( aName.getStr( ), aName.getLength( ) ); - m_ofn.lpstrFile = m_fileNameBuffer; + m_fileNameBuffer.setLength(0); + m_fileNameBuffer.append(aName); + m_ofn.lpstrFile = const_cast(m_fileNameBuffer.getStr()); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::setDisplayDirectory( const OUString& aDirectory ) +void SAL_CALL CFileOpenDialog::setDisplayDirectory(const rtl::OUString& aDirectory) { m_displayDirectory = aDirectory; m_ofn.lpstrInitialDir = m_displayDirectory; @@ -251,7 +243,7 @@ void SAL_CALL CFileOpenDialog::setDisplayDirectory( const OUString& aDirectory ) // //------------------------------------------------------------------------ -rtl::OUString SAL_CALL CFileOpenDialog::getLastDisplayDirectory( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getLastDisplayDirectory() const { return m_displayDirectory; } @@ -260,141 +252,92 @@ rtl::OUString SAL_CALL CFileOpenDialog::getLastDisplayDirectory( ) const // //------------------------------------------------------------------------ -rtl::OUString SAL_CALL CFileOpenDialog::getFullFileName( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getFullFileName() const { - return OUString( &m_fileNameBuffer, _wcslenex( &m_fileNameBuffer ) ); + return rtl::OUString(m_fileNameBuffer.getStr(), + _wcslenex(m_fileNameBuffer.getStr())); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -rtl::OUString SAL_CALL CFileOpenDialog::getFileName( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getFileName() const { - return OUString( &m_fileTitleBuffer, wcslen( &m_fileTitleBuffer ) + 1 ); + return rtl::OUString(m_fileTitleBuffer); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -rtl::OUString CFileOpenDialog::getFileExtension( ) +rtl::OUString CFileOpenDialog::getFileExtension() { - OUString fileExt; + if (m_ofn.nFileExtension) + return rtl::OUString(m_fileNameBuffer.getStr() + m_ofn.nFileExtension, + wcslen(m_fileNameBuffer.getStr() + m_ofn.nFileExtension)); - if ( m_ofn.nFileExtension ) - fileExt = OUString( m_fileNameBuffer + m_ofn.nFileExtension, - wcslen( m_fileNameBuffer + m_ofn.nFileExtension ) ); - - return fileExt; + return rtl::OUString(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -void CFileOpenDialog::setDefaultFileExtension( const OUString& aExtension ) +void CFileOpenDialog::setDefaultFileExtension(const rtl::OUString& aExtension) { m_defaultExtension = aExtension; - m_ofn.lpstrDefExt = m_defaultExtension.getStr( ); + m_ofn.lpstrDefExt = m_defaultExtension.getStr(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::setMultiSelectionMode( sal_Bool bMode ) +void SAL_CALL CFileOpenDialog::setMultiSelectionMode(bool bMode) { - if ( bMode ) + if (bMode) m_ofn.Flags |= OFN_ALLOWMULTISELECT; - else if ( m_ofn.Flags & OFN_ALLOWMULTISELECT ) - m_ofn.Flags ^= OFN_ALLOWMULTISELECT; -} - -//------------------------------------------------------------------------ -// -//------------------------------------------------------------------------ - -sal_Bool SAL_CALL CFileOpenDialog::getMultiSelectionMode( ) const -{ - return ( m_ofn.Flags & OFN_ALLOWMULTISELECT ); -} - -//------------------------------------------------------------------------ -// -//------------------------------------------------------------------------ - -sal_Bool CFileOpenDialog::setControlLabel( sal_Int16 ElementID, const OUString& aLabel ) -{ - return sal_True; -} - -//------------------------------------------------------------------------ -// -//------------------------------------------------------------------------ - -void SAL_CALL CFileOpenDialog::enableControl( sal_Int16 ElementID, sal_Bool bEnabled ) -{ - -} - -//------------------------------------------------------------------------ -// -//------------------------------------------------------------------------ - -sal_Bool CFileOpenDialog::showControl( sal_Int16 ElementID, sal_Bool bShow ) -{ - return sal_True; -} - -//------------------------------------------------------------------------ -// -//------------------------------------------------------------------------ - -CFileOpenDialog::POSITION SAL_CALL CFileOpenDialog::beginEnumFileNames( ) -{ - return 0; + else + m_ofn.Flags &= ~OFN_ALLOWMULTISELECT; } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -sal_Bool SAL_CALL CFileOpenDialog::getNextFileName( - POSITION& pos, OUString& aNextFileName ) +bool SAL_CALL CFileOpenDialog::getMultiSelectionMode() const { - return sal_False; + return ((m_ofn.Flags & OFN_ALLOWMULTISELECT) > 0); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -sal_Int16 SAL_CALL CFileOpenDialog::doModal( ) +sal_Int16 SAL_CALL CFileOpenDialog::doModal() { sal_Int16 nRC = -1; // pre-processing - if ( preModal( ) ) + if (preModal()) { - sal_Bool bRet; + bool bRet; - OSL_ASSERT( m_GetFileNameWrapper.get( ) ); + if (m_bFileOpenDialog) + bRet = m_GetFileNameWrapper.getOpenFileName( + reinterpret_cast(&m_ofn)); + else + bRet = m_GetFileNameWrapper.getSaveFileName( + reinterpret_cast(&m_ofn)); - if ( m_GetFileNameWrapper.get( ) ) - { - if ( m_bFileOpenDialog ) - bRet = m_GetFileNameWrapper->getOpenFileName( (LPOPENFILENAMEW)&m_ofn ); - else - bRet = m_GetFileNameWrapper->getSaveFileName( (LPOPENFILENAMEW)&m_ofn ); - - nRC = 1; - if ( !bRet ) - nRC = (0 == m_GetFileNameWrapper->commDlgExtendedError( )) ? 0 : -1; - } + nRC = 1; + + if (!bRet) + nRC = (0 == m_GetFileNameWrapper.commDlgExtendedError()) ? 0 : -1; // post-processing - postModal( nRC ); + postModal(nRC); } return nRC; @@ -404,16 +347,16 @@ sal_Int16 SAL_CALL CFileOpenDialog::doModal( ) // //------------------------------------------------------------------------ -sal_uInt32 SAL_CALL CFileOpenDialog::getLastDialogError( ) const +sal_uInt32 SAL_CALL CFileOpenDialog::getLastDialogError() const { - return CommDlgExtendedError( ); + return CommDlgExtendedError(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -sal_Bool SAL_CALL CFileOpenDialog::preModal( ) +bool SAL_CALL CFileOpenDialog::preModal() { return sal_True; } @@ -422,20 +365,16 @@ sal_Bool SAL_CALL CFileOpenDialog::preModal( ) // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::postModal( sal_Int16 nDialogResult ) +void SAL_CALL CFileOpenDialog::postModal(sal_Int16 nDialogResult) { - OSL_ASSERT( (-1 <= nDialogResult) && (nDialogResult <= 1) ); + OSL_ASSERT((-1 <= nDialogResult) && (nDialogResult <= 1)); - if ( m_ofn.lpstrFile ) + if (1 == nDialogResult) { - OUString lastDir; - sal_Unicode* pLastDirChar = m_ofn.lpstrFile + m_ofn.nFileOffset - 1; - if ( m_ofn.nFileOffset && 0 == *pLastDirChar ) - lastDir = OUString( m_ofn.lpstrFile, m_ofn.nFileOffset - 1 ); - else if ( m_ofn.nFileOffset ) - lastDir = OUString( m_ofn.lpstrFile, m_ofn.nFileOffset ); - - m_displayDirectory = lastDir; + // Attention: assuming that nFileOffset is always greater 0 because under + // Windows there is always a drive letter or a server in a complete path + // the OPENFILENAME docu never says that nFileOffset can be 0 + m_displayDirectory = rtl::OUString(m_ofn.lpstrFile,m_ofn.nFileOffset); } } @@ -443,53 +382,55 @@ void SAL_CALL CFileOpenDialog::postModal( sal_Int16 nDialogResult ) // //------------------------------------------------------------------------ -OUString SAL_CALL CFileOpenDialog::getCurrentFilePath( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFilePath() const { - OSL_ASSERT( IsWindow( m_hwndFileOpenDlg ) ); + OSL_ASSERT(IsWindow(m_hwndFileOpenDlg)); LPARAM nLen = SendMessageW( m_hwndFileOpenDlg, CDM_GETFILEPATH, - m_helperBuffer.size( ), - reinterpret_cast< LPARAM >( &m_helperBuffer ) ); + m_helperBuffer.getCapacity(), + reinterpret_cast(m_helperBuffer.getStr())); - OUString filePath; - - if ( nLen > 0 ) - filePath = OUString( &m_helperBuffer, (nLen - 1) ); + if (nLen > 0) + { + m_helperBuffer.setLength(nLen - 1); + return rtl::OUString(m_helperBuffer); + } - return filePath; + return rtl::OUString(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -OUString SAL_CALL CFileOpenDialog::getCurrentFolderPath( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFolderPath() const { - OSL_ASSERT( IsWindow( m_hwndFileOpenDlg ) ); + OSL_ASSERT(IsWindow(m_hwndFileOpenDlg)); LPARAM nLen = SendMessageW( m_hwndFileOpenDlg, CDM_GETFOLDERPATH, - m_helperBuffer.size( ), - reinterpret_cast< LPARAM >( &m_helperBuffer ) ); - - OUString folderPath; + m_helperBuffer.getCapacity(), + reinterpret_cast(m_helperBuffer.getStr())); - if ( nLen > 0 ) - folderPath = OUString( &m_helperBuffer, (nLen -1) ); + if (nLen > 0) + { + m_helperBuffer.setLength(nLen - 1); + return rtl::OUString(m_helperBuffer); + } - return folderPath; + return rtl::OUString(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -OUString SAL_CALL CFileOpenDialog::getCurrentFileName( ) const +rtl::OUString SAL_CALL CFileOpenDialog::getCurrentFileName() const { - OSL_ASSERT( IsWindow( m_hwndFileOpenDlg ) ); + OSL_ASSERT(IsWindow(m_hwndFileOpenDlg)); // this is an ugly hack because beause // CDM_GETSPEC and BFFM_SETSTATUSTEXT @@ -499,32 +440,33 @@ OUString SAL_CALL CFileOpenDialog::getCurrentFileName( ) const OSVERSIONINFO OSVerInfo; - OSVerInfo.dwOSVersionInfoSize = sizeof( OSVERSIONINFO ); + OSVerInfo.dwOSVersionInfoSize = sizeof(OSVERSIONINFO); GetVersionEx( &OSVerInfo ); // if windows 95/98 - if ( VER_PLATFORM_WIN32_WINDOWS == OSVerInfo.dwPlatformId ) + if (VER_PLATFORM_WIN32_WINDOWS == OSVerInfo.dwPlatformId) MsgId = CDM_GETSPEC + 100; LPARAM nLen = SendMessageW( m_hwndFileOpenDlg, MsgId, - m_helperBuffer.size( ), - reinterpret_cast< LPARAM >( &m_helperBuffer ) ); + m_helperBuffer.getCapacity(), + reinterpret_cast(m_helperBuffer.getStr())); - OUString fileName; - - if ( nLen > 0 ) - fileName = OUString( &m_helperBuffer, (nLen - 1) ); + if (nLen > 0) + { + m_helperBuffer.setLength(nLen - 1); + return rtl::OUString(m_helperBuffer); + } - return fileName; + return rtl::OUString(); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -sal_uInt32 SAL_CALL CFileOpenDialog::onShareViolation( const OUString& aPathName) +sal_uInt32 SAL_CALL CFileOpenDialog::onShareViolation(const rtl::OUString& aPathName) { return 0; } @@ -542,7 +484,7 @@ sal_uInt32 SAL_CALL CFileOpenDialog::onFileOk() // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::onSelChanged( HWND hwndListBox ) +void SAL_CALL CFileOpenDialog::onSelChanged(HWND hwndListBox) { } @@ -550,7 +492,7 @@ void SAL_CALL CFileOpenDialog::onSelChanged( HWND hwndListBox ) // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::onHelp( ) +void SAL_CALL CFileOpenDialog::onHelp() { } @@ -560,7 +502,7 @@ void SAL_CALL CFileOpenDialog::onHelp( ) void SAL_CALL CFileOpenDialog::onInitDone() { - centerPositionToParent( ); + centerPositionToParent(); } //------------------------------------------------------------------------ @@ -575,7 +517,7 @@ void SAL_CALL CFileOpenDialog::onFolderChanged() // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::onTypeChanged( sal_uInt32 nFilterIndex ) +void SAL_CALL CFileOpenDialog::onTypeChanged(sal_uInt32 nFilterIndex) { } @@ -583,7 +525,7 @@ void SAL_CALL CFileOpenDialog::onTypeChanged( sal_uInt32 nFilterIndex ) // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::onInitDialog( HWND hwndDlg, HWND hwndChild ) +void SAL_CALL CFileOpenDialog::onInitDialog(HWND hwndDlg, HWND hwndChild) { } @@ -592,7 +534,7 @@ void SAL_CALL CFileOpenDialog::onInitDialog( HWND hwndDlg, HWND hwndChild ) //------------------------------------------------------------------------ sal_uInt32 SAL_CALL CFileOpenDialog::onCtrlCommand( - HWND hwndChild, sal_uInt16 ctrlId, sal_uInt16 notifyCode ) + HWND hwndChild, sal_uInt16 ctrlId, sal_uInt16 notifyCode) { return 0; } @@ -601,35 +543,35 @@ sal_uInt32 SAL_CALL CFileOpenDialog::onCtrlCommand( // //------------------------------------------------------------------------ -sal_uInt32 SAL_CALL CFileOpenDialog::onWMNotify( HWND hwndChild, LPOFNOTIFYW lpOfNotify ) +sal_uInt32 SAL_CALL CFileOpenDialog::onWMNotify(HWND hwndChild, LPOFNOTIFYW lpOfNotify) { - switch( lpOfNotify->hdr.code ) + switch(lpOfNotify->hdr.code) { case CDN_SHAREVIOLATION: - return onShareViolation( lpOfNotify->pszFile ); + return onShareViolation(lpOfNotify->pszFile); case CDN_FILEOK: - return onFileOk( ); + return onFileOk(); case CDN_SELCHANGE: - onSelChanged( lpOfNotify->hdr.hwndFrom ); + onSelChanged(lpOfNotify->hdr.hwndFrom); break; case CDN_HELP: - onHelp( ); + onHelp(); break; case CDN_INITDONE: - onInitDone( ); + onInitDone(); break; case CDN_FOLDERCHANGE: - onFolderChanged( ); + onFolderChanged(); break; case CDN_TYPECHANGE: m_ofn.nFilterIndex = lpOfNotify->lpOFN->nFilterIndex; - onTypeChanged( lpOfNotify->lpOFN->nFilterIndex ); + onTypeChanged(lpOfNotify->lpOFN->nFilterIndex); break; } @@ -640,16 +582,16 @@ sal_uInt32 SAL_CALL CFileOpenDialog::onWMNotify( HWND hwndChild, LPOFNOTIFYW lpO // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::handleInitDialog( HWND hwndDlg, HWND hwndChild ) +void SAL_CALL CFileOpenDialog::handleInitDialog(HWND hwndDlg, HWND hwndChild) { m_hwndFileOpenDlg = hwndDlg; m_hwndFileOpenDlgChild = hwndChild; - OSL_ASSERT( GetParent( hwndChild ) == hwndDlg ); + OSL_ASSERT(GetParent(hwndChild) == hwndDlg); // calling virtual function which the // client can overload - onInitDialog( hwndDlg, hwndChild ); + onInitDialog(hwndDlg, hwndChild); } //------------------------------------------------------------------------ @@ -657,7 +599,7 @@ void SAL_CALL CFileOpenDialog::handleInitDialog( HWND hwndDlg, HWND hwndChild ) //------------------------------------------------------------------------ unsigned int CALLBACK CFileOpenDialog::ofnHookProc( - HWND hChildDlg, unsigned int uiMsg, WPARAM wParam, LPARAM lParam ) + HWND hChildDlg, unsigned int uiMsg, WPARAM wParam, LPARAM lParam) { HWND hwndDlg = GetParent( hChildDlg ); CFileOpenDialog* pImpl = NULL; @@ -666,38 +608,38 @@ unsigned int CALLBACK CFileOpenDialog::ofnHookProc( { case WM_INITDIALOG: { - _OPENFILENAMEW* lpofn = reinterpret_cast< _OPENFILENAMEW* >( lParam ); - pImpl = reinterpret_cast< CFileOpenDialog* >( lpofn->lCustData ); - OSL_ASSERT( pImpl ); + _OPENFILENAMEW* lpofn = reinterpret_cast<_OPENFILENAMEW*>(lParam); + pImpl = reinterpret_cast(lpofn->lCustData); + OSL_ASSERT(pImpl); // subclass the base dialog for WM_NCDESTROY processing pImpl->m_pfnBaseDlgProc = reinterpret_cast< DLGPROC >( SetWindowLong( hwndDlg, DWL_DLGPROC, - reinterpret_cast< DWORD >( CFileOpenDialog::BaseDlgProc ) ) ); + reinterpret_cast(CFileOpenDialog::BaseDlgProc))); // connect the instance handle to the window - SetPropA( hwndDlg, CURRENT_INSTANCE, pImpl ); + SetPropA(hwndDlg, CURRENT_INSTANCE, pImpl); - pImpl->handleInitDialog( hwndDlg, hChildDlg ); + pImpl->handleInitDialog(hwndDlg, hChildDlg); } return 0; case WM_NOTIFY: { - pImpl = getCurrentInstance( hwndDlg ); + pImpl = getCurrentInstance(hwndDlg); return pImpl->onWMNotify( - hChildDlg, reinterpret_cast< LPOFNOTIFYW >( lParam ) ); + hChildDlg, reinterpret_cast(lParam)); } case WM_COMMAND: { - pImpl = getCurrentInstance( hwndDlg ); - OSL_ASSERT( pImpl ); + pImpl = getCurrentInstance(hwndDlg); + OSL_ASSERT(pImpl); return pImpl->onCtrlCommand( - hChildDlg, LOWORD( wParam ), HIWORD( lParam ) ); + hChildDlg, LOWORD(wParam), HIWORD(lParam)); } } @@ -709,111 +651,88 @@ unsigned int CALLBACK CFileOpenDialog::ofnHookProc( //------------------------------------------------------------------------ unsigned int CALLBACK CFileOpenDialog::BaseDlgProc( - HWND hWnd, WORD wMessage, WPARAM wParam, LPARAM lParam ) + HWND hWnd, WORD wMessage, WPARAM wParam, LPARAM lParam) { - unsigned int lResult = 0; - CFileOpenDialog* pImpl = NULL; + CFileOpenDialog* pImpl = 0; - switch( wMessage ) + if (WM_NCDESTROY == wMessage) { - case WM_NCDESTROY: - - // RemoveProp returns the saved value on success - pImpl = reinterpret_cast< CFileOpenDialog* >( - RemovePropA( hWnd, CURRENT_INSTANCE ) ); - OSL_ASSERT( pImpl ); - - // fall through in order to call the - // base dlg proc - default: - if ( !pImpl ) - { - pImpl = getCurrentInstance( hWnd ); - OSL_ASSERT( pImpl ); - } - - // !!! we use CallWindowProcA - lResult = CallWindowProcA( - reinterpret_cast< WNDPROC >( pImpl->m_pfnBaseDlgProc ), - hWnd, wMessage, wParam, lParam ); + pImpl = reinterpret_cast( + RemovePropA(hWnd,CURRENT_INSTANCE)); - break; - - } // switch + SetWindowLong(hWnd, DWL_DLGPROC, + reinterpret_cast(pImpl->m_pfnBaseDlgProc)); + } + else + { + pImpl = getCurrentInstance(hWnd); + } - return lResult; + OSL_ASSERT(pImpl); + return CallWindowProcA( + reinterpret_cast(pImpl->m_pfnBaseDlgProc), + hWnd,wMessage,wParam,lParam); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -CFileOpenDialog* SAL_CALL CFileOpenDialog::getCurrentInstance( HWND hwnd ) +CFileOpenDialog* SAL_CALL CFileOpenDialog::getCurrentInstance(HWND hwnd) { - OSL_ASSERT( IsWindow( hwnd ) ); - return reinterpret_cast< CFileOpenDialog* >( - GetPropA( hwnd, CURRENT_INSTANCE ) ); + OSL_ASSERT(IsWindow(hwnd)); + + return reinterpret_cast( + GetPropA(hwnd, CURRENT_INSTANCE)); } //------------------------------------------------------------------------ // //------------------------------------------------------------------------ -void SAL_CALL CFileOpenDialog::centerPositionToParent( ) const +void SAL_CALL CFileOpenDialog::centerPositionToParent() const { - OSL_PRECOND( IsWindow( m_hwndFileOpenDlg ), "no dialog window, call method only after or in onInitDone" ); - - HDC hdc = GetDC( m_hwndFileOpenDlg ); + OSL_PRECOND(IsWindow(m_hwndFileOpenDlg), "no dialog window, call method only after or in onInitDone"); HWND hwndParent = m_ofn.hwndOwner; - if ( !IsWindow( hwndParent ) ) - hwndParent = GetDesktopWindow( ); + if (!IsWindow(hwndParent)) + hwndParent = GetDesktopWindow(); - OSL_ASSERT( IsWindow( hwndParent ) ); + OSL_ASSERT(IsWindow(hwndParent)); - RECT rcParent; - GetWindowRect( hwndParent, &rcParent ); + RECT rcPar; + GetWindowRect(hwndParent, &rcPar); - RECT rcDialog; - GetWindowRect( m_hwndFileOpenDlg, &rcDialog ); + RECT rcDlg; + GetWindowRect(m_hwndFileOpenDlg, &rcDlg); - LONG lParentWidth = rcParent.right - rcParent.left; - LONG lParentHeight = rcParent.bottom - rcParent.top; + int lDlgW = rcDlg.right - rcDlg.left; + int lDlgH = rcDlg.bottom - rcDlg.top; - LONG lDialogWidth = rcDialog.right - rcDialog.left; - LONG lDialogHeight = rcDialog.bottom - rcDialog.top; + int x = (rcPar.left + rcPar.right - lDlgW) / 2; + int y = (rcPar.top + rcPar.bottom - lDlgH) / 2; - int xParentMid = rcParent.left + (lParentWidth / 2); - int yParentMid = rcParent.top + (lParentHeight / 2); + HDC hdc = GetDC(m_hwndFileOpenDlg); - int x = xParentMid - (lDialogWidth / 2); - int y = yParentMid - (lDialogHeight / 2); + int hResol = GetDeviceCaps(hdc, HORZRES); + int vResol = GetDeviceCaps(hdc, VERTRES); - int xScreen = GetDeviceCaps( hdc, HORZRES ); - int yScreen = GetDeviceCaps( hdc, VERTRES ); + ReleaseDC(m_hwndFileOpenDlg, hdc); - if ( x < 0 ) + if (x < 0) x = 0; + else if ((x + lDlgW) > hResol) + x = hResol - lDlgW; - if ( y < 0 ) + if (y < 0) y = 0; - - if ( (x + lDialogWidth) > xScreen ) - x = xScreen - lDialogWidth; - - if ( (y + lDialogHeight) > yScreen ) - y = yScreen - lDialogHeight; + else if ((y + lDlgH) > vResol) + y = vResol - lDlgH; SetWindowPos( m_hwndFileOpenDlg, - NULL, - x, - y, - 0, - 0, + NULL, x, y, 0, 0, SWP_NOACTIVATE | SWP_NOZORDER | SWP_NOSIZE ); - - ReleaseDC( m_hwndFileOpenDlg, hdc ); } \ No newline at end of file diff --git a/fpicker/source/win32/filepicker/FileOpenDlg.hxx b/fpicker/source/win32/filepicker/FileOpenDlg.hxx index 1e966b979d15..e2e3f3521713 100644 --- a/fpicker/source/win32/filepicker/FileOpenDlg.hxx +++ b/fpicker/source/win32/filepicker/FileOpenDlg.hxx @@ -2,9 +2,9 @@ * * $RCSfile: FileOpenDlg.hxx,v $ * - * $Revision: 1.5 $ + * $Revision: 1.6 $ * - * last change: $Author: tra $ $Date: 2001-10-04 11:10:45 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -74,12 +74,10 @@ #include #endif -#ifndef _AUTO_BUFFER_HXX_ -#include "..\misc\AutoBuffer.hxx" +#ifndef _RTL_USTRBUF_HXX_ +#include #endif -#include - #include #ifndef _GETFILENAMEWRAPPER_HXX_ @@ -117,10 +115,6 @@ typedef struct _tagOFNW { LPARAM lCustData; LPOFNHOOKPROC lpfnHook; LPCWSTR lpTemplateName; -#ifdef _MAC - LPEDITMENU lpEditInfo; - LPCSTR lpstrPrompt; -#endif #if (_WIN32_WINNT >= 0x0500) void * pvReserved; DWORD dwReserved; @@ -142,10 +136,6 @@ typedef struct _tagOFNW { class CFileOpenDialog { public: - typedef sal_Unicode* POSITION; - -public: - // ctor // bFileOpenDialog idicates if we want a FileOpen or FileSave // dialog @@ -155,92 +145,63 @@ public: // which provides the custom template, unused if dwTemplateId // is 0 CFileOpenDialog( - sal_Bool bFileOpenDialog = sal_True, + bool bFileOpenDialog = sal_True, sal_uInt32 dwFlags = OFN_HIDEREADONLY | OFN_OVERWRITEPROMPT, sal_uInt32 dwTemplateId = 0, - HINSTANCE hInstance = 0 ); + HINSTANCE hInstance = 0); - virtual ~CFileOpenDialog( ); + virtual ~CFileOpenDialog(); - virtual void SAL_CALL setTitle( const rtl::OUString& aTitle ); + virtual void SAL_CALL setTitle(const rtl::OUString& aTitle); // to set a filter string using the M$ format // e.g. FltName\0*.txt;*.rtf\0...\0\0 - void SAL_CALL setFilter( const rtl::OUString& aFilter ); + void SAL_CALL setFilter(const rtl::OUString& aFilter); // set the index of the current filter when the // dialog is about to shown, the index starts with 1 // the function succeeded if the given filter index // is greater than zero and is a valid position // within filter string that was previously set - sal_Bool SAL_CALL setFilterIndex( sal_uInt32 aIndex ); + bool SAL_CALL setFilterIndex(sal_uInt32 aIndex); // get the index of the currently selected filter // the index of the returned filter starts with 1 - sal_uInt32 SAL_CALL getSelectedFilterIndex( ) const; + sal_uInt32 SAL_CALL getSelectedFilterIndex() const; // set the name and optional the path of the // file that will be initially be shown when // the dialog will be displayed - virtual void SAL_CALL setDefaultName( const rtl::OUString& aName ); + virtual void SAL_CALL setDefaultName(const rtl::OUString& aName); // set the initial directory - virtual void SAL_CALL setDisplayDirectory( const rtl::OUString& aDirectory ); + virtual void SAL_CALL setDisplayDirectory(const rtl::OUString& aDirectory); // returns only the path of the selected file - virtual rtl::OUString SAL_CALL getLastDisplayDirectory( ) const; + virtual rtl::OUString SAL_CALL getLastDisplayDirectory() const; // returns the full file name including drive letter, path // file name and file extension - virtual rtl::OUString SAL_CALL getFullFileName( ) const; + virtual rtl::OUString SAL_CALL getFullFileName() const; // returns the file name and the file extension without // drive letter and path - rtl::OUString SAL_CALL getFileName( ) const; + rtl::OUString SAL_CALL getFileName() const; // returns the file extension of the selected file - rtl::OUString SAL_CALL getFileExtension( ); + rtl::OUString SAL_CALL getFileExtension(); // set a default extension, only the first three letters of // the given extension will be used; the given extension // should not contain a '.' - void SAL_CALL setDefaultFileExtension( const rtl::OUString& aExtension ); + void SAL_CALL setDefaultFileExtension(const rtl::OUString& aExtension); // enables or disables the multiselection mode for // the FileOpen/FileSave dialog - void SAL_CALL setMultiSelectionMode( sal_Bool bMode ); + void SAL_CALL setMultiSelectionMode(bool bMode); // returns whether multi-selection mode is enabled or not - sal_Bool SAL_CALL getMultiSelectionMode( ) const; - - // sets the label of the specified control - // returns true on success or false if the control id - // is invalid or another error occured - sal_Bool SAL_CALL setControlLabel( sal_Int16 ElementID, const rtl::OUString& aLabel ); - - // enables or disables the specified control - virtual void SAL_CALL enableControl( sal_Int16 ElementID, sal_Bool bEnabled ); - - // shows or hides a control ( bShow = true shows the control - // and bShow = false hides the control ) - // returns true on success and false if the control id - // is invalid or another error occured - sal_Bool SAL_CALL showControl( sal_Int16 ElementID, sal_Bool bShow ); - - // starts enumerating the selected file names if - // the multiselection mode is enabled - POSITION SAL_CALL beginEnumFileNames( ); - - // returns true if multiselection mode is enabled and - // another file name was copied to aNextFileName - // else returns false - // on success the function returns the complete - // file name including drive letter and path - // pos is an in-out parameter and receives the next - // position when there are further file names or - // 0 if there aren't - sal_Bool SAL_CALL getNextFileName( - /*in|out*/ POSITION& pos, rtl::OUString& aNextFileName ); + bool SAL_CALL getMultiSelectionMode() const; // shows the dialog, calls preModal before // showing the dialog and postModal after @@ -249,23 +210,23 @@ public: // 0 - when the dialog was canceled by the user // 1 - when the dialog was closed with ok // -1 - when an error occured - sal_Int16 SAL_CALL doModal( ); + sal_Int16 SAL_CALL doModal(); // returns the last dialog error that occured - sal_uInt32 SAL_CALL getLastDialogError( ) const; + sal_uInt32 SAL_CALL getLastDialogError() const; // retrievs the currently selected file // including path and drive information // can be called only if the dialog is // already displayed - rtl::OUString SAL_CALL getCurrentFilePath( ) const; + rtl::OUString SAL_CALL getCurrentFilePath() const; // retrievs the currently selected folder - rtl::OUString SAL_CALL getCurrentFolderPath( ) const; + rtl::OUString SAL_CALL getCurrentFolderPath() const; // retrievs the currently selected file name // without drive and path - rtl::OUString SAL_CALL getCurrentFileName( ) const; + rtl::OUString SAL_CALL getCurrentFileName() const; protected: // have to be overwritten when subclasses @@ -275,34 +236,34 @@ protected: // if preModal return true processing will // continue else doModal exit without showing // a dialog and returns -1 - virtual sal_Bool SAL_CALL preModal( ); + virtual bool SAL_CALL preModal(); // post modal processing // the function should accept only values returned from // doModal and act appropriately - virtual void SAL_CALL postModal( sal_Int16 nDialogResult ); + virtual void SAL_CALL postModal(sal_Int16 nDialogResult); // message handler, to be overwritten by subclasses - virtual sal_uInt32 SAL_CALL onShareViolation( const rtl::OUString& aPathName ); + virtual sal_uInt32 SAL_CALL onShareViolation(const rtl::OUString& aPathName); virtual sal_uInt32 SAL_CALL onFileOk(); - virtual void SAL_CALL onSelChanged( HWND hwndListBox ); - virtual void SAL_CALL onHelp( ); + virtual void SAL_CALL onSelChanged(HWND hwndListBox); + virtual void SAL_CALL onHelp(); // only called back if OFN_EXPLORER is set virtual void SAL_CALL onInitDone(); virtual void SAL_CALL onFolderChanged(); - virtual void SAL_CALL onTypeChanged( sal_uInt32 nFilterIndex ); + virtual void SAL_CALL onTypeChanged(sal_uInt32 nFilterIndex); // call base class method first when overloading - virtual void SAL_CALL onInitDialog( HWND hwndDlg, HWND hwndChild ); + virtual void SAL_CALL onInitDialog(HWND hwndDlg, HWND hwndChild); - virtual sal_uInt32 SAL_CALL onCtrlCommand( HWND hwndDlg, sal_uInt16 ctrlId, sal_uInt16 notifyCode ); + virtual sal_uInt32 SAL_CALL onCtrlCommand(HWND hwndDlg, sal_uInt16 ctrlId, sal_uInt16 notifyCode); - sal_uInt32 SAL_CALL onWMNotify( HWND hwndChild, LPOFNOTIFYW lpOfNotify ); + sal_uInt32 SAL_CALL onWMNotify(HWND hwndChild, LPOFNOTIFYW lpOfNotify); // we use non-virtual functions to do necessary work before // calling the virtual funtions (see Gamma: Template method) - void SAL_CALL handleInitDialog( HWND hwndDlg, HWND hwndChild ); + void SAL_CALL handleInitDialog(HWND hwndDlg, HWND hwndChild); protected: @@ -319,23 +280,23 @@ protected: // we connect the instance with the dialog window using // SetProp, with this function we can reconnect from // callback functions to this instance - static CFileOpenDialog* SAL_CALL getCurrentInstance( HWND hwnd ); + static CFileOpenDialog* SAL_CALL getCurrentInstance(HWND hwnd); - void SAL_CALL centerPositionToParent( ) const; + void SAL_CALL centerPositionToParent() const; private: // FileOpen or FileSaveDialog - BOOL m_bFileOpenDialog; + bool m_bFileOpenDialog; rtl::OUString m_dialogTitle; rtl::OUString m_displayDirectory; rtl::OUString m_defaultExtension; - CAutoUnicodeBuffer m_filterBuffer; - CAutoUnicodeBuffer m_fileNameBuffer; - CAutoUnicodeBuffer m_fileTitleBuffer; - CAutoUnicodeBuffer m_helperBuffer; + mutable rtl::OUStringBuffer m_filterBuffer; + mutable rtl::OUStringBuffer m_fileTitleBuffer; + mutable rtl::OUStringBuffer m_helperBuffer; + mutable rtl::OUStringBuffer m_fileNameBuffer; - ::std::auto_ptr< CGetFileNameWrapper > m_GetFileNameWrapper; + CGetFileNameWrapper m_GetFileNameWrapper; DLGPROC m_pfnBaseDlgProc; @@ -355,10 +316,9 @@ private: HWND hWnd, WORD wMessage, WPARAM wParam, LPARAM lParam ); private: - // avoid copy and assignment - CFileOpenDialog( const CFileOpenDialog& ); - CFileOpenDialog& operator=( const CFileOpenDialog& ); + CFileOpenDialog(const CFileOpenDialog&); + CFileOpenDialog& operator=(const CFileOpenDialog&); }; #endif diff --git a/fpicker/source/win32/filepicker/FilePicker.cxx b/fpicker/source/win32/filepicker/FilePicker.cxx index 89d28c090772..e2baed55e1d5 100644 --- a/fpicker/source/win32/filepicker/FilePicker.cxx +++ b/fpicker/source/win32/filepicker/FilePicker.cxx @@ -2,9 +2,9 @@ * * $RCSfile: FilePicker.cxx,v $ * - * $Revision: 1.16 $ + * $Revision: 1.17 $ * - * last change: $Author: tra $ $Date: 2002-03-21 08:20:57 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -79,6 +79,10 @@ #include "filepicker.hxx" #endif +#ifndef _WINFILEOPENIMPL_HXX_ +#include "WinFileOpenImpl.hxx" +#endif + #include "FPServiceInfo.hxx" #include "..\misc\WinImplHelper.hxx" @@ -94,31 +98,11 @@ // namespace directives //------------------------------------------------------------------------ -using ::com::sun::star::lang::XMultiServiceFactory; -using ::com::sun::star::lang::IllegalArgumentException; -using ::com::sun::star::lang::XEventListener; -using ::com::sun::star::lang::XServiceInfo; -using ::com::sun::star::lang::DisposedException; -using ::com::sun::star::lang::XInitialization; -using ::com::sun::star::lang::EventObject; -using ::com::sun::star::util::XCancellable; - -using ::com::sun::star::uno::Reference; -using ::com::sun::star::uno::Exception; -using ::com::sun::star::uno::RuntimeException; -using ::com::sun::star::uno::XInterface; -using ::com::sun::star::uno::Any; -using ::com::sun::star::uno::Sequence; +using namespace com::sun::star; using namespace ::com::sun::star::ui::dialogs; using namespace ::com::sun::star::ui::dialogs::TemplateDescription; -using ::cppu::WeakComponentImplHelper9; -using ::rtl::OUString; -using ::osl::MutexGuard; - -using ::com::sun::star::beans::StringPair; - //------------------------------------------------------------------------ // defines //------------------------------------------------------------------------ @@ -131,11 +115,11 @@ using ::com::sun::star::beans::StringPair; namespace { - Sequence< OUString > SAL_CALL FilePicker_getSupportedServiceNames() + uno::Sequence SAL_CALL FilePicker_getSupportedServiceNames() { - Sequence< OUString > aRet(2); - aRet[0] = OUString::createFromAscii("com.sun.star.ui.dialogs.FilePicker"); - aRet[1] = OUString::createFromAscii("com.sun.star.ui.dialogs.SystemFilePicker"); + uno::Sequence aRet(2); + aRet[0] = rtl::OUString::createFromAscii("com.sun.star.ui.dialogs.FilePicker"); + aRet[1] = rtl::OUString::createFromAscii("com.sun.star.ui.dialogs.SystemFilePicker"); return aRet; } } @@ -144,17 +128,18 @@ namespace // //----------------------------------------------------------------------------------------- -CFilePicker::CFilePicker( const Reference< XMultiServiceFactory >& xServiceMgr ) : - WeakComponentImplHelper9< +CFilePicker::CFilePicker( const uno::Reference& xServiceMgr) : + cppu::WeakComponentImplHelper9< XFilterManager, XFilterGroupManager, XFilePickerControlAccess, XFilePickerNotifier, XFilePreview, - XInitialization, - XCancellable, - XEventListener, - XServiceInfo >( m_rbHelperMtx ), + lang::XInitialization, + util::XCancellable, + lang::XEventListener, + lang::XServiceInfo>(m_rbHelperMtx), + m_xServiceMgr(xServiceMgr), m_aAsyncEventNotifier(rBHelper) { HINSTANCE hInstance = GetModuleHandleA( FILE_PICKER_DLL_NAME ); @@ -174,12 +159,12 @@ CFilePicker::CFilePicker( const Reference< XMultiServiceFactory >& xServiceMgr ) // XFPEventListenerManager //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::addFilePickerListener( const Reference< XFilePickerListener >& xListener ) - throw( RuntimeException ) +void SAL_CALL CFilePicker::addFilePickerListener(const uno::Reference& xListener) + throw(uno::RuntimeException) { if ( rBHelper.bDisposed ) - throw DisposedException( - OUString::createFromAscii( "object is already disposed" ), + throw lang::DisposedException( + rtl::OUString::createFromAscii( "object is already disposed" ), static_cast< XFilePicker* >( this ) ); if ( !rBHelper.bInDispose && !rBHelper.bDisposed ) @@ -190,12 +175,12 @@ void SAL_CALL CFilePicker::addFilePickerListener( const Reference< XFilePickerLi // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::removeFilePickerListener( const Reference< XFilePickerListener >& xListener ) - throw( RuntimeException ) +void SAL_CALL CFilePicker::removeFilePickerListener(const uno::Reference& xListener ) + throw(uno::RuntimeException) { if ( rBHelper.bDisposed ) - throw DisposedException( - OUString::createFromAscii( "object is already disposed" ), + throw lang::DisposedException( + rtl::OUString::createFromAscii( "object is already disposed" ), static_cast< XFilePicker* >( this ) ); rBHelper.aLC.removeInterface( getCppuType( &xListener ), xListener ); @@ -205,9 +190,9 @@ void SAL_CALL CFilePicker::removeFilePickerListener( const Reference< XFilePicke // XEventListener // ------------------------------------------------- -void SAL_CALL CFilePicker::disposing( const EventObject& aEvent ) throw(RuntimeException) +void SAL_CALL CFilePicker::disposing(const lang::EventObject& aEvent) throw(uno::RuntimeException) { - Reference< XFilePickerListener > xFilePickerListener( aEvent.Source, ::com::sun::star::uno::UNO_QUERY ); + uno::Reference xFilePickerListener(aEvent.Source, ::com::sun::star::uno::UNO_QUERY); if (xFilePickerListener.is()) removeFilePickerListener(xFilePickerListener); @@ -217,9 +202,9 @@ void SAL_CALL CFilePicker::disposing( const EventObject& aEvent ) throw(RuntimeE // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::fileSelectionChanged( FilePickerEvent aEvent ) +void SAL_CALL CFilePicker::fileSelectionChanged(FilePickerEvent aEvent) { - aEvent.Source = Reference(static_cast(this)); + aEvent.Source = uno::Reference(static_cast(this)); m_aAsyncEventNotifier.notifyEvent( new CFilePickerParamEventNotification(&XFilePickerListener::fileSelectionChanged,aEvent)); } @@ -228,9 +213,9 @@ void SAL_CALL CFilePicker::fileSelectionChanged( FilePickerEvent aEvent ) // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::directoryChanged( FilePickerEvent aEvent ) +void SAL_CALL CFilePicker::directoryChanged(FilePickerEvent aEvent) { - aEvent.Source = Reference(static_cast(this)); + aEvent.Source = uno::Reference(static_cast(this)); m_aAsyncEventNotifier.notifyEvent( new CFilePickerParamEventNotification(&XFilePickerListener::directoryChanged,aEvent)); } @@ -239,9 +224,9 @@ void SAL_CALL CFilePicker::directoryChanged( FilePickerEvent aEvent ) // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::controlStateChanged( FilePickerEvent aEvent ) +void SAL_CALL CFilePicker::controlStateChanged(FilePickerEvent aEvent) { - aEvent.Source = Reference(static_cast(this)); + aEvent.Source = uno::Reference(static_cast(this)); m_aAsyncEventNotifier.notifyEvent( new CFilePickerParamEventNotification(&XFilePickerListener::controlStateChanged,aEvent)); } @@ -250,7 +235,7 @@ void SAL_CALL CFilePicker::controlStateChanged( FilePickerEvent aEvent ) // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::dialogSizeChanged( ) +void SAL_CALL CFilePicker::dialogSizeChanged() { m_aAsyncEventNotifier.notifyEvent( new CFilePickerEventNotification(&XFilePickerListener::dialogSizeChanged)); @@ -260,51 +245,41 @@ void SAL_CALL CFilePicker::dialogSizeChanged( ) // If there are more then one listener the return value of the last one wins //----------------------------------------------------------------------------------------- -OUString SAL_CALL CFilePicker::helpRequested( FilePickerEvent aEvent ) const +rtl::OUString SAL_CALL CFilePicker::helpRequested(FilePickerEvent aEvent) const { - OUString aHelpText; + rtl::OUString aHelpText; - if ( !rBHelper.bDisposed ) + ::cppu::OInterfaceContainerHelper* pICHelper = + rBHelper.getContainer( getCppuType((uno::Reference*)0)); + + if (pICHelper) { - ::osl::ClearableMutexGuard aGuard( rBHelper.rMutex ); + ::cppu::OInterfaceIteratorHelper iter(*pICHelper); - if ( !rBHelper.bDisposed ) + while(iter.hasMoreElements()) { - aGuard.clear( ); - - ::cppu::OInterfaceContainerHelper* pICHelper = - rBHelper.getContainer( getCppuType((Reference*)0)); - - if ( pICHelper ) + try { - ::cppu::OInterfaceIteratorHelper iter(*pICHelper); + /* + if there are multiple listeners responding + to this notification the next response + overwrittes the one before if it is not empty + */ + + rtl::OUString temp; - while(iter.hasMoreElements()) + uno::Reference xFPListener(iter.next(), uno::UNO_QUERY); + if (xFPListener.is()) { - try - { - /* - if there are multiple listeners responding - to this notification the next response - overwrittes the one before if it is not empty - */ - - OUString temp; - - Reference< XFilePickerListener > xFPListener( iter.next( ), ::com::sun::star::uno::UNO_QUERY ); - if ( xFPListener.is( ) ) - { - temp = xFPListener->helpRequested( aEvent ); - if ( temp.getLength( ) ) - aHelpText = temp; - } - - } - catch( RuntimeException& ) - { - OSL_ENSURE( false, "RuntimeException during event dispatching" ); - } + temp = xFPListener->helpRequested(aEvent); + if (temp.getLength()) + aHelpText = temp; } + + } + catch(uno::RuntimeException&) + { + OSL_ENSURE( false, "RuntimeException during event dispatching" ); } } } @@ -316,122 +291,122 @@ OUString SAL_CALL CFilePicker::helpRequested( FilePickerEvent aEvent ) const // XFilePicker functions //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::setMultiSelectionMode( sal_Bool bMode ) throw(RuntimeException) +void SAL_CALL CFilePicker::setMultiSelectionMode(sal_Bool bMode) throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setMultiSelectionMode( bMode ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setMultiSelectionMode(bMode); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::setTitle( const OUString& aTitle ) throw(RuntimeException) +void SAL_CALL CFilePicker::setTitle(const rtl::OUString& aTitle) throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setTitle( aTitle ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setTitle(aTitle); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::appendFilter( const OUString& aTitle, const OUString& aFilter ) - throw(IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::appendFilter(const rtl::OUString& aTitle, const rtl::OUString& aFilter) + throw(lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->appendFilter( aTitle, aFilter ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->appendFilter(aTitle, aFilter); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::setCurrentFilter( const OUString& aTitle ) - throw(IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::setCurrentFilter(const rtl::OUString& aTitle) + throw(lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setCurrentFilter( aTitle ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setCurrentFilter(aTitle); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -OUString SAL_CALL CFilePicker::getCurrentFilter( ) throw(RuntimeException) +rtl::OUString SAL_CALL CFilePicker::getCurrentFilter() throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getCurrentFilter( ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getCurrentFilter(); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::appendFilterGroup( const OUString& sGroupTitle, const Sequence< StringPair >& aFilters ) - throw (IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::appendFilterGroup(const rtl::OUString& sGroupTitle, const uno::Sequence& aFilters) + throw (lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->appendFilterGroup( sGroupTitle, aFilters ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->appendFilterGroup(sGroupTitle, aFilters); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::setDefaultName( const OUString& aName ) - throw(IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::setDefaultName(const rtl::OUString& aName) + throw(lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setDefaultName( aName ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setDefaultName(aName); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::setDisplayDirectory( const OUString& aDirectory ) - throw(IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::setDisplayDirectory(const rtl::OUString& aDirectory) + throw(lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setDisplayDirectory( aDirectory ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setDisplayDirectory(aDirectory); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -OUString SAL_CALL CFilePicker::getDisplayDirectory( ) throw(RuntimeException) +rtl::OUString SAL_CALL CFilePicker::getDisplayDirectory() throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getDisplayDirectory( ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getDisplayDirectory(); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -Sequence< OUString > SAL_CALL CFilePicker::getFiles( ) throw(RuntimeException) +uno::Sequence SAL_CALL CFilePicker::getFiles() throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getFiles( ); + OSL_ASSERT(0 != m_pImpl.get()); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getFiles(); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -sal_Int16 SAL_CALL CFilePicker::execute( ) throw(RuntimeException) +sal_Int16 SAL_CALL CFilePicker::execute() throw(uno::RuntimeException) { OSL_ASSERT(0 != m_pImpl.get()); @@ -451,8 +426,8 @@ sal_Int16 SAL_CALL CFilePicker::execute( ) throw(RuntimeException) { OSL_ENSURE(sal_False, "Could not start event notifier thread!"); - throw RuntimeException( - OUString::createFromAscii("Error executing dialog"), + throw uno::RuntimeException( + rtl::OUString::createFromAscii("Error executing dialog"), static_cast(this)); } @@ -463,38 +438,38 @@ sal_Int16 SAL_CALL CFilePicker::execute( ) throw(RuntimeException) // XFilePicker functions //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::setValue( sal_Int16 aControlId, sal_Int16 aControlAction, const Any& aValue ) - throw(RuntimeException) +void SAL_CALL CFilePicker::setValue(sal_Int16 aControlId, sal_Int16 aControlAction, const uno::Any& aValue) + throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setValue( aControlId, aControlAction, aValue ); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setValue(aControlId, aControlAction, aValue); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -Any SAL_CALL CFilePicker::getValue( sal_Int16 aControlId, sal_Int16 aControlAction ) - throw(RuntimeException) +uno::Any SAL_CALL CFilePicker::getValue(sal_Int16 aControlId, sal_Int16 aControlAction) + throw(uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getValue( aControlId, aControlAction ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getValue(aControlId, aControlAction); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::enableControl( sal_Int16 aControlId, sal_Bool bEnable ) - throw(RuntimeException) +void SAL_CALL CFilePicker::enableControl(sal_Int16 aControlId, sal_Bool bEnable) +throw(uno::RuntimeException) { OSL_ASSERT( 0 != m_pImpl.get( ) ); - MutexGuard aGuard( m_aMutex ); + osl::MutexGuard aGuard( m_aMutex ); m_pImpl->enableControl( aControlId, bEnable ); } @@ -502,136 +477,134 @@ void SAL_CALL CFilePicker::enableControl( sal_Int16 aControlId, sal_Bool bEnable // //----------------------------------------------------------------------------------------- -void SAL_CALL CFilePicker::setLabel( sal_Int16 aControlId, const ::rtl::OUString& aLabel ) - throw (RuntimeException) +void SAL_CALL CFilePicker::setLabel(sal_Int16 aControlId, const ::rtl::OUString& aLabel) + throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setLabel( aControlId, aLabel ); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setLabel(aControlId, aLabel); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -OUString SAL_CALL CFilePicker::getLabel( sal_Int16 aControlId ) - throw (RuntimeException) +rtl::OUString SAL_CALL CFilePicker::getLabel(sal_Int16 aControlId) + throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getLabel( aControlId ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getLabel(aControlId); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -Sequence< sal_Int16 > SAL_CALL CFilePicker::getSupportedImageFormats( ) throw (RuntimeException) +uno::Sequence SAL_CALL CFilePicker::getSupportedImageFormats() throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getSupportedImageFormats( ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getSupportedImageFormats(); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -sal_Int32 SAL_CALL CFilePicker::getTargetColorDepth( ) throw (RuntimeException) +sal_Int32 SAL_CALL CFilePicker::getTargetColorDepth() throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getTargetColorDepth( ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getTargetColorDepth(); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -sal_Int32 SAL_CALL CFilePicker::getAvailableWidth( ) throw (RuntimeException) +sal_Int32 SAL_CALL CFilePicker::getAvailableWidth() throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getAvailableWidth( ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getAvailableWidth(); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -sal_Int32 SAL_CALL CFilePicker::getAvailableHeight( ) throw (RuntimeException) +sal_Int32 SAL_CALL CFilePicker::getAvailableHeight() throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getAvailableHeight( ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getAvailableHeight(); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::setImage( sal_Int16 aImageFormat, const Any& aImage ) - throw (IllegalArgumentException, RuntimeException) +void SAL_CALL CFilePicker::setImage(sal_Int16 aImageFormat, const uno::Any& aImage) + throw (lang::IllegalArgumentException, uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - m_pImpl->setImage( aImageFormat, aImage ); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->setImage(aImageFormat, aImage); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -sal_Bool SAL_CALL CFilePicker::setShowState( sal_Bool bShowState ) throw (RuntimeException) +sal_Bool SAL_CALL CFilePicker::setShowState(sal_Bool bShowState) throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->setShowState( bShowState ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->setShowState(bShowState); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -sal_Bool SAL_CALL CFilePicker::getShowState( ) throw (RuntimeException) +sal_Bool SAL_CALL CFilePicker::getShowState() throw (uno::RuntimeException) { - OSL_ASSERT( 0 != m_pImpl.get( ) ); + OSL_ASSERT(0 != m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - return m_pImpl->getShowState( ); + osl::MutexGuard aGuard(m_aMutex); + return m_pImpl->getShowState(); } //------------------------------------------------------------------------------------ // //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::initialize( const Sequence< Any >& aArguments ) - throw( Exception, RuntimeException) +void SAL_CALL CFilePicker::initialize(const uno::Sequence& aArguments) + throw( uno::Exception, uno::RuntimeException) { // parameter checking - Any aAny; + uno::Any aAny; if ( 0 == aArguments.getLength( ) ) - throw IllegalArgumentException( - OUString::createFromAscii( "no arguments" ), - static_cast< XFilePicker* >( this ), - 1 ); + throw lang::IllegalArgumentException( + rtl::OUString::createFromAscii( "no arguments" ), + static_cast(this), 1); aAny = aArguments[0]; if ( (aAny.getValueType() != ::getCppuType((sal_Int16*)0)) && (aAny.getValueType() != ::getCppuType((sal_Int8*)0)) ) - throw IllegalArgumentException( - OUString::createFromAscii( "invalid argument type" ), - static_cast< XFilePicker* >( this ), - 1 ); + throw lang::IllegalArgumentException( + rtl::OUString::createFromAscii("invalid argument type"), + static_cast(this), 1); sal_Int16 templateId = -1; aAny >>= templateId; @@ -719,8 +692,8 @@ void SAL_CALL CFilePicker::initialize( const Sequence< Any >& aArguments ) break; default: - throw IllegalArgumentException( - OUString::createFromAscii( "Unknown template" ), + throw lang::IllegalArgumentException( + rtl::OUString::createFromAscii( "Unknown template" ), static_cast< XFilePicker* >( this ), 1 ); } @@ -744,34 +717,34 @@ void SAL_CALL CFilePicker::initialize( const Sequence< Any >& aArguments ) // //------------------------------------------------------------------------------------ -void SAL_CALL CFilePicker::cancel( ) +void SAL_CALL CFilePicker::cancel() { - OSL_ASSERT( m_pImpl.get( ) ); + OSL_ASSERT(m_pImpl.get()); - MutexGuard aGuard( m_aMutex ); - m_pImpl->cancel( ); + osl::MutexGuard aGuard(m_aMutex); + m_pImpl->cancel(); } // ------------------------------------------------- // XServiceInfo // ------------------------------------------------- -OUString SAL_CALL CFilePicker::getImplementationName( ) - throw( RuntimeException ) +rtl::OUString SAL_CALL CFilePicker::getImplementationName() + throw(uno::RuntimeException) { - return OUString::createFromAscii( FILE_PICKER_IMPL_NAME ); + return rtl::OUString::createFromAscii(FILE_PICKER_IMPL_NAME); } // ------------------------------------------------- // XServiceInfo // ------------------------------------------------- -sal_Bool SAL_CALL CFilePicker::supportsService( const OUString& ServiceName ) - throw( RuntimeException ) +sal_Bool SAL_CALL CFilePicker::supportsService(const rtl::OUString& ServiceName) + throw(uno::RuntimeException ) { - Sequence < OUString > SupportedServicesNames = FilePicker_getSupportedServiceNames(); + uno::Sequence SupportedServicesNames = FilePicker_getSupportedServiceNames(); - for ( sal_Int32 n = SupportedServicesNames.getLength(); n--; ) + for (sal_Int32 n = SupportedServicesNames.getLength(); n--;) if (SupportedServicesNames[n].compareTo(ServiceName) == 0) return sal_True; @@ -782,8 +755,8 @@ sal_Bool SAL_CALL CFilePicker::supportsService( const OUString& ServiceName ) // XServiceInfo // ------------------------------------------------- -Sequence< OUString > SAL_CALL CFilePicker::getSupportedServiceNames( ) - throw( RuntimeException ) +uno::Sequence SAL_CALL CFilePicker::getSupportedServiceNames() + throw(uno::RuntimeException) { return FilePicker_getSupportedServiceNames(); } \ No newline at end of file diff --git a/fpicker/source/win32/filepicker/FilePicker.hxx b/fpicker/source/win32/filepicker/FilePicker.hxx index 94f76928bab5..3a82db79c262 100644 --- a/fpicker/source/win32/filepicker/FilePicker.hxx +++ b/fpicker/source/win32/filepicker/FilePicker.hxx @@ -2,9 +2,9 @@ * * $RCSfile: FilePicker.hxx,v $ * - * $Revision: 1.7 $ + * $Revision: 1.8 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:33:32 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -107,10 +107,6 @@ #include #endif -#ifndef _WINFILEOPENIMPL_HXX_ -#include "WinFileOpenImpl.hxx" -#endif - #ifndef _ASYNCEVENTNOTIFIER_HXX_ #include "asynceventnotifier.hxx" #endif @@ -129,8 +125,7 @@ // forward declarations //---------------------------------------------------------- -//class OFPImplBase; -class CFPImplFactory; +class CWinFileOpenImpl; //---------------------------------------------------------- // class declaration @@ -305,9 +300,9 @@ private: CFilePicker& operator=( const CFilePicker& ); private: - ::com::sun::star::uno::Reference< ::com::sun::star::lang::XMultiServiceFactory > m_xServiceMgr; // to instanciate own services - std::auto_ptr< CWinFileOpenImpl > m_pImpl; - CAsyncEventNotifier m_aAsyncEventNotifier; + ::com::sun::star::uno::Reference<::com::sun::star::lang::XMultiServiceFactory> m_xServiceMgr; // to instanciate own services + CAsyncEventNotifier m_aAsyncEventNotifier; + std::auto_ptr m_pImpl; }; #endif diff --git a/fpicker/source/win32/filepicker/WinFileOpenImpl.cxx b/fpicker/source/win32/filepicker/WinFileOpenImpl.cxx index 0d59f35ad1b9..15a1c66cb41d 100644 --- a/fpicker/source/win32/filepicker/WinFileOpenImpl.cxx +++ b/fpicker/source/win32/filepicker/WinFileOpenImpl.cxx @@ -2,9 +2,9 @@ * * $RCSfile: WinFileOpenImpl.cxx,v $ * - * $Revision: 1.15 $ + * $Revision: 1.16 $ * - * last change: $Author: tra $ $Date: 2002-03-27 10:35:59 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -138,20 +138,11 @@ // namespace directives //------------------------------------------------------------------------ -using namespace std; -using rtl::OUString; -using rtl::OUStringBuffer; +using namespace com::sun::star; -using ::com::sun::star::uno::RuntimeException; -using ::com::sun::star::uno::XInterface; -using ::com::sun::star::uno::Reference; -using ::com::sun::star::uno::Sequence; -using ::com::sun::star::uno::Any; -using ::com::sun::star::ui::dialogs::FilePickerEvent; -using ::com::sun::star::lang::IllegalArgumentException; -using ::com::sun::star::ui::dialogs::XFilePicker; - -using ::com::sun::star::beans::StringPair; +using com::sun::star::ui::dialogs::FilePickerEvent; +using com::sun::star::lang::IllegalArgumentException; +using com::sun::star::ui::dialogs::XFilePicker; using namespace ::com::sun::star::ui::dialogs::ExtendedFilePickerElementIds; using namespace ::com::sun::star::ui::dialogs::CommonFilePickerElementIds; @@ -182,9 +173,9 @@ struct EnumParam // //------------------------------------------------------------------------- -const OUString BACKSLASH = OUString::createFromAscii( "\\" ); -const OUString FILTER_SEPARATOR = OUString::createFromAscii( "------------------------------------------" ); -const OUString ALL_FILES_WILDCARD = OUString::createFromAscii( "*.*" ); +const rtl::OUString BACKSLASH = rtl::OUString::createFromAscii( "\\" ); +const rtl::OUString FILTER_SEPARATOR = rtl::OUString::createFromAscii( "------------------------------------------" ); +const rtl::OUString ALL_FILES_WILDCARD = rtl::OUString::createFromAscii( "*.*" ); const sal_Bool ALLOW_DUPLICATES = sal_True; //------------------------------------------------------------------------- @@ -225,16 +216,16 @@ CWinFileOpenImpl::~CWinFileOpenImpl() // we expect the directory in URL format //------------------------------------------------------------------------ -void CWinFileOpenImpl::setDisplayDirectory( const OUString& aDirectory ) - throw( IllegalArgumentException, RuntimeException ) +void CWinFileOpenImpl::setDisplayDirectory(const rtl::OUString& aDirectory) + throw( IllegalArgumentException, uno::RuntimeException ) { - OUString aSysDirectory; - if( aDirectory.getLength( ) > 0 ) + rtl::OUString aSysDirectory; + if( aDirectory.getLength() > 0) { if ( ::osl::FileBase::E_None != ::osl::FileBase::getSystemPathFromFileURL(aDirectory,aSysDirectory)) throw IllegalArgumentException( - OUString::createFromAscii("Invalid directory"), + rtl::OUString::createFromAscii("Invalid directory"), static_cast(m_FilePicker), 1); // we ensure that there is a trailing '/' at the end of @@ -255,17 +246,17 @@ void CWinFileOpenImpl::setDisplayDirectory( const OUString& aDirectory ) // we return the directory in URL format //------------------------------------------------------------------------ -OUString CWinFileOpenImpl::getDisplayDirectory( ) throw( RuntimeException ) +rtl::OUString CWinFileOpenImpl::getDisplayDirectory() throw(uno::RuntimeException) { - return m_FilePickerState->getDisplayDirectory( this ); + return m_FilePickerState->getDisplayDirectory(this); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::setDefaultName( const OUString& aName ) - throw( IllegalArgumentException, RuntimeException ) +void SAL_CALL CWinFileOpenImpl::setDefaultName(const rtl::OUString& aName) + throw( IllegalArgumentException, uno::RuntimeException ) { // we don't set the default name directly // because this influences how the file open @@ -285,27 +276,28 @@ void SAL_CALL CWinFileOpenImpl::setDefaultName( const OUString& aName ) // the first entry is the path url, all other entries are file names //----------------------------------------------------------------------------------------- -Sequence< OUString > SAL_CALL CWinFileOpenImpl::getFiles( ) throw(RuntimeException) +uno::Sequence SAL_CALL CWinFileOpenImpl::getFiles() + throw(uno::RuntimeException) { - return m_FilePickerState->getFiles( this ); + return m_FilePickerState->getFiles(this); } //----------------------------------------------------------------------------------------- // shows the FileOpen/FileSave dialog //----------------------------------------------------------------------------------------- -sal_Int16 SAL_CALL CWinFileOpenImpl::execute( ) throw(RuntimeException) +sal_Int16 SAL_CALL CWinFileOpenImpl::execute( ) throw(uno::RuntimeException) { sal_Int16 rc = CFileOpenDialog::doModal(); - if ( 1 == rc ) + if (1 == rc) rc = ::com::sun::star::ui::dialogs::ExecutableDialogResults::OK; - else if ( 0 == rc ) + else if (0 == rc) rc = ::com::sun::star::ui::dialogs::ExecutableDialogResults::CANCEL; else - throw RuntimeException( - OUString::createFromAscii( "Error executing dialog" ), - static_cast< XFilePicker* >( m_FilePicker ) ); + throw uno::RuntimeException( + rtl::OUString::createFromAscii("Error executing dialog"), + static_cast(m_FilePicker)); return rc; } @@ -316,16 +308,15 @@ sal_Int16 SAL_CALL CWinFileOpenImpl::execute( ) throw(RuntimeException) // empty //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::appendFilter( const OUString& aTitle, const OUString& aFilter ) - throw(IllegalArgumentException, RuntimeException) +void SAL_CALL CWinFileOpenImpl::appendFilter(const rtl::OUString& aTitle, const rtl::OUString& aFilter) + throw(IllegalArgumentException, uno::RuntimeException) { - sal_Bool bRet = m_filterContainer->addFilter( aTitle, aFilter ); + sal_Bool bRet = m_filterContainer->addFilter(aTitle, aFilter); - if ( !bRet ) + if (!bRet) throw IllegalArgumentException( - OUString::createFromAscii("filter already exists"), - static_cast< XFilePicker* >( m_FilePicker ), - 1 ); + rtl::OUString::createFromAscii("filter already exists"), + static_cast(m_FilePicker), 1); // #95345# see MSDN OPENFILENAME // If nFilterIndex is zero and lpstrCustomFilter is NULL, @@ -334,43 +325,42 @@ void SAL_CALL CWinFileOpenImpl::appendFilter( const OUString& aTitle, const OUSt // to getSelectedFilterIndex without explicitly calling // setFilterIndex before does not return 0 which leads to a // false state - if ( 0 == getSelectedFilterIndex() ) - CFileOpenDialog::setFilterIndex( 1 ); + if (0 == getSelectedFilterIndex()) + CFileOpenDialog::setFilterIndex(1); } //----------------------------------------------------------------------------------------- // sets a current filter //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::setCurrentFilter( const OUString& aTitle ) - throw( IllegalArgumentException, RuntimeException) +void SAL_CALL CWinFileOpenImpl::setCurrentFilter(const rtl::OUString& aTitle) + throw( IllegalArgumentException, uno::RuntimeException) { - sal_Int32 filterPos = m_filterContainer->getFilterPos( aTitle ); + sal_Int32 filterPos = m_filterContainer->getFilterPos(aTitle); - if ( filterPos < 0 ) + if (filterPos < 0) throw IllegalArgumentException( - OUString::createFromAscii( "filter doesn't exist"), - static_cast< XFilePicker* >( m_FilePicker ), - 1 ); + rtl::OUString::createFromAscii("filter doesn't exist"), + static_cast(m_FilePicker), 1); // filter index of the base class starts with 1 - CFileOpenDialog::setFilterIndex( filterPos + 1 ); + CFileOpenDialog::setFilterIndex(filterPos + 1); } //----------------------------------------------------------------------------------------- // returns the currently selected filter //----------------------------------------------------------------------------------------- -OUString SAL_CALL CWinFileOpenImpl::getCurrentFilter( ) throw(RuntimeException) +rtl::OUString SAL_CALL CWinFileOpenImpl::getCurrentFilter() throw(uno::RuntimeException) { - sal_uInt32 nIndex = getSelectedFilterIndex( ); + sal_uInt32 nIndex = getSelectedFilterIndex(); - OUString currentFilter; - if ( nIndex > 0 ) + rtl::OUString currentFilter; + if (nIndex > 0) { // filter index of the base class starts with 1 - sal_Bool bRet = m_filterContainer->getFilter( nIndex - 1, currentFilter ); - OSL_ASSERT( bRet ); + sal_Bool bRet = m_filterContainer->getFilter(nIndex - 1, currentFilter); + OSL_ASSERT(bRet); } return currentFilter; @@ -380,33 +370,33 @@ OUString SAL_CALL CWinFileOpenImpl::getCurrentFilter( ) throw(RuntimeException) // //----------------------------------------------------------------------------------------- -inline void SAL_CALL CWinFileOpenImpl::appendFilterGroupSeparator( ) +inline void SAL_CALL CWinFileOpenImpl::appendFilterGroupSeparator() { - m_filterContainer->addFilter( FILTER_SEPARATOR, ALL_FILES_WILDCARD, ALLOW_DUPLICATES ); + m_filterContainer->addFilter(FILTER_SEPARATOR, ALL_FILES_WILDCARD, ALLOW_DUPLICATES); } //----------------------------------------------------------------------------------------- // XFilterGroupManager //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::appendFilterGroup( const OUString& sGroupTitle, const Sequence< StringPair >& aFilters ) - throw (IllegalArgumentException, RuntimeException) +void SAL_CALL CWinFileOpenImpl::appendFilterGroup(const rtl::OUString& sGroupTitle, const uno::Sequence& aFilters) + throw (IllegalArgumentException, uno::RuntimeException) { - OSL_ENSURE( 0 == sGroupTitle.getLength( ), "appendFilterGroup: Parameter 'GroupTitle' currently ignored" ); + OSL_ENSURE(0 == sGroupTitle.getLength(), "appendFilterGroup: Parameter 'GroupTitle' currently ignored"); - sal_Int32 nFilters = aFilters.getLength( ); + sal_Int32 nFilters = aFilters.getLength(); - OSL_PRECOND( nFilters > 0, "Empty filter list" ); + OSL_PRECOND(nFilters > 0, "Empty filter list"); - if ( nFilters > 0 ) + if (nFilters > 0) { // append a separator before the next group if // there is already a group of filters - if ( m_filterContainer->numFilter( ) > 0 ) - appendFilterGroupSeparator( ); + if (m_filterContainer->numFilter() > 0) + appendFilterGroupSeparator(); - for ( int i = 0; i < nFilters; i++ ) - appendFilter( aFilters[i].First, aFilters[i].Second ); + for (int i = 0; i < nFilters; i++) + appendFilter(aFilters[i].First, aFilters[i].Second); } } @@ -414,11 +404,11 @@ void SAL_CALL CWinFileOpenImpl::appendFilterGroup( const OUString& sGroupTitle, // XExtendedFilePicker //================================================================================================================= -void SAL_CALL CWinFileOpenImpl::setValue( sal_Int16 aControlId, sal_Int16 aControlAction, const Any& aValue ) - throw(RuntimeException) +void SAL_CALL CWinFileOpenImpl::setValue(sal_Int16 aControlId, sal_Int16 aControlAction, const uno::Any& aValue) + throw(uno::RuntimeException) { - OSL_ASSERT( m_FilePickerState ); - m_FilePickerState->setValue( aControlId, aControlAction, aValue ); + OSL_ASSERT(m_FilePickerState); + m_FilePickerState->setValue(aControlId, aControlAction, aValue); } //----------------------------------------------------------------------------------------- @@ -426,50 +416,50 @@ void SAL_CALL CWinFileOpenImpl::setValue( sal_Int16 aControlId, sal_Int16 aContr // we assume that there are only checkboxes or comboboxes //----------------------------------------------------------------------------------------- -Any SAL_CALL CWinFileOpenImpl::getValue( sal_Int16 aControlId, sal_Int16 aControlAction ) - throw(RuntimeException) +uno::Any SAL_CALL CWinFileOpenImpl::getValue(sal_Int16 aControlId, sal_Int16 aControlAction) + throw(uno::RuntimeException) { - OSL_ASSERT( m_FilePickerState ); - return m_FilePickerState->getValue( aControlId, aControlAction ); + OSL_ASSERT(m_FilePickerState); + return m_FilePickerState->getValue(aControlId, aControlAction); } //----------------------------------------------------------------------------------------- // enables a custom template element //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::enableControl( sal_Int16 ControlID, sal_Bool bEnable ) - throw(RuntimeException) +void SAL_CALL CWinFileOpenImpl::enableControl(sal_Int16 ControlID, sal_Bool bEnable) + throw(uno::RuntimeException) { - OSL_ASSERT( m_FilePickerState ); - m_FilePickerState->enableControl( ControlID, bEnable ); + OSL_ASSERT(m_FilePickerState); + m_FilePickerState->enableControl(ControlID, bEnable); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::setLabel( sal_Int16 aControlId, const ::rtl::OUString& aLabel ) - throw (RuntimeException) +void SAL_CALL CWinFileOpenImpl::setLabel( sal_Int16 aControlId, const rtl::OUString& aLabel ) + throw (uno::RuntimeException) { - m_FilePickerState->setLabel( aControlId, aLabel ); + m_FilePickerState->setLabel(aControlId, aLabel); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -OUString SAL_CALL CWinFileOpenImpl::getLabel( sal_Int16 aControlId ) - throw (RuntimeException) +rtl::OUString SAL_CALL CWinFileOpenImpl::getLabel( sal_Int16 aControlId ) + throw (uno::RuntimeException) { - return m_FilePickerState->getLabel( aControlId ); + return m_FilePickerState->getLabel(aControlId); } //----------------------------------------------------------------------------------------- // //----------------------------------------------------------------------------------------- -Sequence< sal_Int16 > SAL_CALL CWinFileOpenImpl::getSupportedImageFormats() - throw (RuntimeException) +uno::Sequence SAL_CALL CWinFileOpenImpl::getSupportedImageFormats() + throw (uno::RuntimeException) { return m_Preview->getSupportedImageFormats(); } @@ -479,7 +469,7 @@ Sequence< sal_Int16 > SAL_CALL CWinFileOpenImpl::getSupportedImageFormats() //----------------------------------------------------------------------------------------- sal_Int32 SAL_CALL CWinFileOpenImpl::getTargetColorDepth() - throw (RuntimeException) + throw (uno::RuntimeException) { return m_Preview->getTargetColorDepth(); } @@ -489,7 +479,7 @@ sal_Int32 SAL_CALL CWinFileOpenImpl::getTargetColorDepth() //----------------------------------------------------------------------------------------- sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableWidth() - throw (RuntimeException) + throw (uno::RuntimeException) { return m_Preview->getAvailableWidth(); } @@ -499,7 +489,7 @@ sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableWidth() //----------------------------------------------------------------------------------------- sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableHeight() - throw (::com::sun::star::uno::RuntimeException) + throw (uno::RuntimeException) { return m_Preview->getAvailableHeight(); } @@ -508,8 +498,8 @@ sal_Int32 SAL_CALL CWinFileOpenImpl::getAvailableHeight() // //----------------------------------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::setImage(sal_Int16 aImageFormat, const Any& aImage) - throw (IllegalArgumentException, RuntimeException) +void SAL_CALL CWinFileOpenImpl::setImage(sal_Int16 aImageFormat, const uno::Any& aImage) + throw (IllegalArgumentException, uno::RuntimeException) { m_Preview->setImage(aImageFormat,aImage); } @@ -519,7 +509,7 @@ void SAL_CALL CWinFileOpenImpl::setImage(sal_Int16 aImageFormat, const Any& aIma //----------------------------------------------------------------------------------------- sal_Bool SAL_CALL CWinFileOpenImpl::setShowState(sal_Bool bShowState) - throw (::com::sun::star::uno::RuntimeException) + throw (uno::RuntimeException) { return m_Preview->setShowState(bShowState); } @@ -529,7 +519,7 @@ sal_Bool SAL_CALL CWinFileOpenImpl::setShowState(sal_Bool bShowState) //----------------------------------------------------------------------------------------- sal_Bool SAL_CALL CWinFileOpenImpl::getShowState() - throw (RuntimeException) + throw (uno::RuntimeException) { return m_Preview->getShowState(); } @@ -630,6 +620,16 @@ unsigned int CALLBACK CWinFileOpenImpl::SubClassFunc( pImpl->onWMShow(hWnd,(BOOL)wParam,(int)lParam); break; + case WM_NCDESTROY: + // restore the old window proc + SetWindowLong(hWnd, DWL_DLGPROC, + reinterpret_cast(pImpl->m_pfnOldDlgProc)); + + lResult = CallWindowProcA( + reinterpret_cast(pImpl->m_pfnOldDlgProc), + hWnd,wMessage,wParam,lParam); + break; + default: // !!! we use CallWindowProcA lResult = CallWindowProcA( @@ -646,7 +646,7 @@ unsigned int CALLBACK CWinFileOpenImpl::SubClassFunc( // //----------------------------------------------------------------- -void SAL_CALL CWinFileOpenImpl::InitControlLabel( HWND hWnd ) +void SAL_CALL CWinFileOpenImpl::InitControlLabel(HWND hWnd) { CResourceProvider aResProvider; @@ -655,9 +655,9 @@ void SAL_CALL CWinFileOpenImpl::InitControlLabel( HWND hWnd ) //----------------------------------------- sal_Int16 aCtrlId = GetDlgCtrlID(hWnd); - OUString aLabel = aResProvider.getResString(aCtrlId); - if ( aLabel.getLength( ) ) - setLabel( aCtrlId, aLabel ); + rtl::OUString aLabel = aResProvider.getResString(aCtrlId); + if (aLabel.getLength()) + setLabel(aCtrlId, aLabel); } //----------------------------------------------------------------- @@ -874,7 +874,7 @@ LRESULT SAL_CALL CWinFileOpenImpl::onWMShow(HWND hwnd, BOOL bShow, int fState) LRESULT SAL_CALL CWinFileOpenImpl::onWMWindowPosChanged(HWND hwnd) { LONG wl = GetWindowLong(hwnd,GWL_STYLE); - m_Preview->notifyParentWindowPosChanged(wl & WS_VISIBLE); + m_Preview->notifyParentWindowPosChanged((wl & WS_VISIBLE) > 0); return 0; } @@ -887,7 +887,7 @@ LRESULT SAL_CALL CWinFileOpenImpl::onCustomControlHelpRequest(LPHELPINFO lphi) FilePickerEvent evt; evt.ElementId = lphi->iCtrlId; - OUString aPopupHelpText = m_FilePicker->helpRequested(evt); + rtl::OUString aPopupHelpText = m_FilePicker->helpRequested(evt); if (aPopupHelpText.getLength()) { @@ -908,9 +908,8 @@ void SAL_CALL CWinFileOpenImpl::onInitDialog(HWND hwndDlg, HWND hwndChild) { // subclass the dialog window m_pfnOldDlgProc = - reinterpret_cast< DLGPROC >( - SetWindowLong( hwndDlg, - DWL_DLGPROC, + reinterpret_cast( + SetWindowLong( hwndDlg, DWL_DLGPROC, reinterpret_cast(SubClassFunc))); } @@ -918,12 +917,12 @@ void SAL_CALL CWinFileOpenImpl::onInitDialog(HWND hwndDlg, HWND hwndChild) // processing before showing the dialog //----------------------------------------------------------------------------------------- -sal_Bool SAL_CALL CWinFileOpenImpl::preModal( ) +bool SAL_CALL CWinFileOpenImpl::preModal() { CFileOpenDialog::setFilter( makeWinFilterBuffer(*m_filterContainer.get())); - return sal_True; + return true; } //----------------------------------------------------------------------------------------- @@ -933,6 +932,12 @@ sal_Bool SAL_CALL CWinFileOpenImpl::preModal( ) void CWinFileOpenImpl::postModal(sal_Int16 nDialogResult) { CFileOpenDialog::postModal(nDialogResult); + + // empty the container in order to get rid off + // invalid controls in case someone calls execute + // twice in sequence with the same instance + m_CustomControls->RemoveAllControls(); + m_FilePickerState = m_NonExecuteFilePickerState; } @@ -956,14 +961,14 @@ void SAL_CALL CWinFileOpenImpl::SetDefaultExtension() if ( hwndChkSaveWithExt ) { - Any aAny = CheckboxGetState( hwndChkSaveWithExt ); + uno::Any aAny = CheckboxGetState( hwndChkSaveWithExt ); sal_Bool bChecked = *reinterpret_cast< const sal_Bool* >( aAny.getValue( ) ); if ( bChecked ) { sal_uInt32 nIndex = getSelectedFilterIndex( ); - OUString currentFilter; + rtl::OUString currentFilter; if ( nIndex > 0 ) { // filter index of the base class starts with 1 @@ -971,7 +976,7 @@ void SAL_CALL CWinFileOpenImpl::SetDefaultExtension() if ( currentFilter.getLength( ) ) { - OUString FilterExt; + rtl::OUString FilterExt; m_filterContainer->getFilter( currentFilter, FilterExt ); sal_Int32 posOfPoint = FilterExt.indexOf( L'.' ); @@ -981,7 +986,7 @@ void SAL_CALL CWinFileOpenImpl::SetDefaultExtension() if ( posOfSemiColon < 0 ) posOfSemiColon = FilterExt.getLength( ) - 1; - FilterExt = OUString( pFirstExtStart, posOfSemiColon - posOfPoint ); + FilterExt = rtl::OUString( pFirstExtStart, posOfSemiColon - posOfPoint ); if ( bIsWin9x ) { diff --git a/fpicker/source/win32/filepicker/WinFileOpenImpl.hxx b/fpicker/source/win32/filepicker/WinFileOpenImpl.hxx index 7ea6247787e1..ce186eadfb9e 100644 --- a/fpicker/source/win32/filepicker/WinFileOpenImpl.hxx +++ b/fpicker/source/win32/filepicker/WinFileOpenImpl.hxx @@ -2,9 +2,9 @@ * * $RCSfile: WinFileOpenImpl.hxx,v $ * - * $Revision: 1.9 $ + * $Revision: 1.10 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:37:13 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -231,7 +231,7 @@ public: protected: sal_Int16 SAL_CALL getFocused( ); - virtual sal_Bool SAL_CALL preModal( ); + virtual bool SAL_CALL preModal( ); virtual void SAL_CALL postModal( sal_Int16 nDialogResult ); virtual sal_uInt32 SAL_CALL onFileOk(); diff --git a/fpicker/source/win32/filepicker/asynceventnotifier.cxx b/fpicker/source/win32/filepicker/asynceventnotifier.cxx index 222e7cc689e4..763d5f4e5830 100644 --- a/fpicker/source/win32/filepicker/asynceventnotifier.cxx +++ b/fpicker/source/win32/filepicker/asynceventnotifier.cxx @@ -2,9 +2,9 @@ * * $RCSfile: asynceventnotifier.cxx,v $ * - * $Revision: 1.8 $ + * $Revision: 1.9 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:35:14 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -75,25 +75,19 @@ #include #endif -#ifndef _COM_SUN_STAR_UI_DIALOGS_XFILEPICKERNOTIFIER_HPP_ -#include +#ifndef _COM_SUN_STAR_UI_DIALOGS_XFILEPICKERLISTENER_HPP_ +#include #endif #include -#include #include //------------------------------------------------ // //------------------------------------------------ -using namespace osl; -using namespace com::sun::star::uno; -using ::com::sun::star::uno::Reference; +using namespace com::sun::star; using ::com::sun::star::ui::dialogs::XFilePickerListener; -using ::com::sun::star::ui::dialogs::XFilePickerNotifier; -using ::com::sun::star::ui::dialogs::FilePickerEvent; -using ::cppu::OBroadcastHelper; //------------------------------------------------ // @@ -111,16 +105,25 @@ CAsyncEventNotifier::CAsyncEventNotifier(cppu::OBroadcastHelper& rBroadcastHelpe // //------------------------------------------------ +CAsyncEventNotifier::~CAsyncEventNotifier() +{ + OSL_ENSURE(0 == m_hThread,"Thread not stopped, destroying this instance leads to desaster"); +} + +//------------------------------------------------ +// +//------------------------------------------------ + bool SAL_CALL CAsyncEventNotifier::start() { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); // m_bRun may already be false because of a // call to stop but the thread did not yet // terminate so m_hEventNotifierThread is // yet a valid thread handle that should // not be overwritten - if ( !m_bRun && 0==m_hThread ) + if (!m_bRun) { m_hThread = (HANDLE)_beginthreadex( NULL, 0, CAsyncEventNotifier::ThreadProc, this, 0, &m_ThreadId); @@ -144,7 +147,7 @@ void SAL_CALL CAsyncEventNotifier::stop() { OSL_PRECOND(GetCurrentThreadId() != m_ThreadId, "Method called in wrong thread context!"); - ResettableMutexGuard aGuard(m_Mutex); + osl::ResettableMutexGuard aGuard(m_Mutex); OSL_PRECOND(m_bRun,"Event notifier does not run!"); @@ -176,7 +179,7 @@ void SAL_CALL CAsyncEventNotifier::stop() void SAL_CALL CAsyncEventNotifier::notifyEvent(CEventNotification* EventNotification) { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); OSL_ENSURE(m_bRun,"Event notifier is not running!"); @@ -193,7 +196,7 @@ void SAL_CALL CAsyncEventNotifier::notifyEvent(CEventNotification* EventNotifica size_t SAL_CALL CAsyncEventNotifier::getEventListSize() { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); return m_EventList.size(); } @@ -203,7 +206,7 @@ size_t SAL_CALL CAsyncEventNotifier::getEventListSize() void SAL_CALL CAsyncEventNotifier::resetNotifyEvent() { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); if (0 == m_EventList.size()) m_NotifyEvent.reset(); } @@ -214,7 +217,7 @@ void SAL_CALL CAsyncEventNotifier::resetNotifyEvent() CEventNotification* SAL_CALL CAsyncEventNotifier::getNextEventRecord() { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); return m_EventList.front(); } @@ -224,7 +227,7 @@ CEventNotification* SAL_CALL CAsyncEventNotifier::getNextEventRecord() void SAL_CALL CAsyncEventNotifier::removeNextEventRecord() { - MutexGuard aGuard(m_Mutex); + osl::MutexGuard aGuard(m_Mutex); m_EventList.pop_front(); } @@ -246,7 +249,7 @@ void SAL_CALL CAsyncEventNotifier::run() removeNextEventRecord(); ::cppu::OInterfaceContainerHelper* pICHelper = - m_rBroadcastHelper.getContainer(getCppuType((Reference*)0)); + m_rBroadcastHelper.getContainer(getCppuType((uno::Reference*)0)); if (pICHelper) { @@ -258,7 +261,7 @@ void SAL_CALL CAsyncEventNotifier::run() { EventNotification->notifyEventListener(iter.next()); } - catch(RuntimeException&) + catch(uno::RuntimeException&) { OSL_ENSURE(sal_False,"RuntimeException during event dispatching"); } diff --git a/fpicker/source/win32/filepicker/asynceventnotifier.hxx b/fpicker/source/win32/filepicker/asynceventnotifier.hxx index aa40b5f5fdf8..84597c1bdc2c 100644 --- a/fpicker/source/win32/filepicker/asynceventnotifier.hxx +++ b/fpicker/source/win32/filepicker/asynceventnotifier.hxx @@ -2,9 +2,9 @@ * * $RCSfile: asynceventnotifier.hxx,v $ * - * $Revision: 1.4 $ + * $Revision: 1.5 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:35:14 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -74,10 +74,6 @@ #include #endif -#ifndef _COM_SUN_STAR_UI_DIALOGS_XFILEPICKERLISTENER_HPP_ -#include -#endif - #ifndef _CPPUHELPER_INTERFACECONTAINER_H_ #include #endif @@ -99,6 +95,7 @@ class CAsyncEventNotifier { public: CAsyncEventNotifier(cppu::OBroadcastHelper& rBroadcastHelper); + ~CAsyncEventNotifier(); bool SAL_CALL start(); void SAL_CALL stop(); diff --git a/fpicker/source/win32/filepicker/getfilenamewrapper.cxx b/fpicker/source/win32/filepicker/getfilenamewrapper.cxx index b67256b3f3c8..c990a62057d6 100644 --- a/fpicker/source/win32/filepicker/getfilenamewrapper.cxx +++ b/fpicker/source/win32/filepicker/getfilenamewrapper.cxx @@ -2,9 +2,9 @@ * * $RCSfile: getfilenamewrapper.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: tra $ $Date: 2001-10-04 11:08:11 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -67,188 +67,162 @@ #include #endif - #ifndef _GETFILENAMEWRAPPER_HXX_ #include "getfilenamewrapper.hxx" #endif - #include -//----------------------------------------------- -// Simple struct for automatically init/deinit -// of a STA -//----------------------------------------------- -struct STAInit +namespace /* private */ { - STAInit( ) { CoInitialize( NULL ); } - ~STAInit( ) { CoUninitialize( ); } -}; -//----------------------------------------------- -// This function returns true if either the -// calling thread belongs to an STA or to no -// apartment at all -//----------------------------------------------- - -bool IsThreadContextSTA( ) -{ - HRESULT hr = CoInitialize( NULL ); - bool bRet = false; + //----------------------------------------------- + // + //----------------------------------------------- - if ( SUCCEEDED( hr ) ) + struct GetFileNameParam { - bRet = true; - CoUninitialize( ); - } - - return bRet; -} + GetFileNameParam(bool bOpen, LPOPENFILENAMEW lpofn) : + m_bOpen(bOpen), + m_lpofn(lpofn), + m_bRet(false), + m_ExtErr(0) + {} + + bool m_bOpen; + LPOPENFILENAMEW m_lpofn; + bool m_bRet; + int m_ExtErr; + }; + + //----------------------------------------------- + // + //----------------------------------------------- + + unsigned __stdcall ThreadProc(void* pParam) + { + GetFileNameParam* lpgfnp = + reinterpret_cast(pParam); -//----------------------------------------------- -// Someone may extend this method on demand and -// even create the appropriate instance depending -// on the OS version etc. -//----------------------------------------------- + if (lpgfnp->m_bOpen) + lpgfnp->m_bRet = GetOpenFileNameW(lpgfnp->m_lpofn); + else + lpgfnp->m_bRet = GetSaveFileNameW(lpgfnp->m_lpofn); -CGetFileNameWrapper* CGetFileNameWrapper::create( ) -{ - CGetFileNameWrapper* pGetFileNameWrapper = new CSTAGetFileNameWrapper( ); + lpgfnp->m_ExtErr = CommDlgExtendedError(); - OSL_POSTCOND( pGetFileNameWrapper, "can't create instance, not enough memory" ); + return 0; + } - return pGetFileNameWrapper; -} + //----------------------------------------------- + // exceutes GetOpenFileName/GetSaveFileName in + // a separat thread + //----------------------------------------------- + bool ThreadExecGetFileName(LPOPENFILENAMEW lpofn, bool bOpen, /*out*/ int& ExtErr) + { + GetFileNameParam gfnp(bOpen,lpofn); + unsigned id; -//############################################### + HANDLE hThread = reinterpret_cast( + _beginthreadex(0, 0, ThreadProc, &gfnp, 0, &id)); + OSL_POSTCOND(hThread, "could not create STA thread"); -//----------------------------------------------- -// -//----------------------------------------------- + WaitForSingleObject(hThread, INFINITE); + CloseHandle(hThread); -CSTAGetFileNameWrapper::CSTAGetFileNameWrapper( ) -{ -} + ExtErr = gfnp.m_ExtErr; -//----------------------------------------------- -// -//----------------------------------------------- + return gfnp.m_bRet; + } -CSTAGetFileNameWrapper::~CSTAGetFileNameWrapper( ) -{ -} + //----------------------------------------------- + // This function returns true if the calling + // thread belongs to a Multithreaded Appartment + // (MTA) + //----------------------------------------------- -//----------------------------------------------- -// -//----------------------------------------------- + bool IsMTA() + { + HRESULT hr = CoInitialize(NULL); -BOOL SAL_CALL CSTAGetFileNameWrapper::getOpenFileName( LPOPENFILENAMEW lpofn ) -{ - executeGetFileName( true, lpofn ); - return m_bResult; -} + if (RPC_E_CHANGED_MODE == hr) + return true; -//----------------------------------------------- -// -//----------------------------------------------- + if(SUCCEEDED(hr)) + CoUninitialize(); -BOOL SAL_CALL CSTAGetFileNameWrapper::getSaveFileName( LPOPENFILENAMEW lpofn ) -{ - executeGetFileName( false, lpofn ); - return m_bResult; -} + return false; + } -//----------------------------------------------- -// -//----------------------------------------------- +} // namespace private -DWORD SAL_CALL CSTAGetFileNameWrapper::commDlgExtendedError( ) -{ - return m_LastError; -} //----------------------------------------------- // //----------------------------------------------- -void SAL_CALL CSTAGetFileNameWrapper::executeGetFileName( ) +CGetFileNameWrapper::CGetFileNameWrapper() : + m_ExtendedDialogError(0) { - if ( m_bFileOpenDialog ) - m_bResult = CGetFileNameWrapper::getOpenFileName( m_lpofn ); - else - m_bResult = CGetFileNameWrapper::getSaveFileName( m_lpofn ); - - if ( !m_bResult ) - m_LastError = CGetFileNameWrapper::commDlgExtendedError( ); } //----------------------------------------------- // //----------------------------------------------- -void SAL_CALL CSTAGetFileNameWrapper::executeGetFileName( BOOL bFileOpenDialog, LPOPENFILENAMEW lpofn ) +bool CGetFileNameWrapper::getOpenFileName(LPOPENFILENAMEW lpofn) { - m_bFileOpenDialog = bFileOpenDialog; - m_lpofn = lpofn; - m_bResult = false; + OSL_PRECOND(lpofn,"invalid parameter"); + + bool bRet = false; - if ( !IsThreadContextSTA( ) && threadExecuteGetFileName( ) ) + if (IsMTA()) { - return; + bRet = ThreadExecGetFileName( + lpofn, true, m_ExtendedDialogError); } else { - // execute in the context of the calling thread - // if it lives in an STA or the execution in a - // separat thread failed - executeGetFileName( ); + bRet = GetOpenFileNameW(lpofn); + m_ExtendedDialogError = CommDlgExtendedError(); } + + return bRet; } //----------------------------------------------- // //----------------------------------------------- -bool SAL_CALL CSTAGetFileNameWrapper::threadExecuteGetFileName( ) +bool CGetFileNameWrapper::getSaveFileName(LPOPENFILENAMEW lpofn) { - unsigned ThreadId; - bool bSuccess = false; - - HANDLE hThread = reinterpret_cast< HANDLE >( - _beginthreadex( 0, 0, CSTAGetFileNameWrapper::threadProc, this, 0, &ThreadId ) ); + OSL_PRECOND(lpofn,"invalid parameter"); - OSL_POSTCOND( hThread, "could not create STA thread" ); + bool bRet = false; - if ( hThread ) + if (IsMTA()) + { + bRet = ThreadExecGetFileName( + lpofn, false, m_ExtendedDialogError); + } + else { - // stop the calling thread until the sta thread - // has ended - WaitForSingleObject( hThread, INFINITE ); - CloseHandle( hThread ); - bSuccess = true; + bRet = GetSaveFileNameW(lpofn); + m_ExtendedDialogError = CommDlgExtendedError(); } - return bSuccess; + return bRet; } //----------------------------------------------- // //----------------------------------------------- -unsigned __stdcall CSTAGetFileNameWrapper::threadProc( void* pParam ) +int CGetFileNameWrapper::commDlgExtendedError( ) { - CSTAGetFileNameWrapper* pImpl = - reinterpret_cast< CSTAGetFileNameWrapper* >( pParam ); - - OSL_ASSERT( pImpl ); - - // setup a STA environment - STAInit staInit; - - pImpl->executeGetFileName( ); - - return 0; + return m_ExtendedDialogError; } + diff --git a/fpicker/source/win32/filepicker/getfilenamewrapper.hxx b/fpicker/source/win32/filepicker/getfilenamewrapper.hxx index 790b0937f225..2606ad020012 100644 --- a/fpicker/source/win32/filepicker/getfilenamewrapper.hxx +++ b/fpicker/source/win32/filepicker/getfilenamewrapper.hxx @@ -2,9 +2,9 @@ * * $RCSfile: getfilenamewrapper.hxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: tra $ $Date: 2001-10-04 11:08:05 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -59,7 +59,6 @@ * ************************************************************************/ - #ifndef _GETFILENAMEWRAPPER_HXX_ #define _GETFILENAMEWRAPPER_HXX_ @@ -67,97 +66,25 @@ // includes //------------------------------------------------------------------------ -#ifndef _SAL_TYPES_H_ -#include -#endif - #include /* A simple wrapper around the GetOpenFileName/GetSaveFileName API. - This wrapper serves as base class because currently the Win32 - API functions GetOpenFileName/GetSaveFileName work only properly - in an STA. If this changes in the future we simply use the base - class else we use an derived class which calls the API functions - from within an STA. + Because currently the Win32 API functions GetOpenFileName/GetSaveFileName + work only properly in an Single Threaded Appartment. */ class CGetFileNameWrapper { public: - virtual ~CGetFileNameWrapper( ) { }; - - virtual BOOL SAL_CALL getOpenFileName( LPOPENFILENAMEW lpofn ) - { - return ::GetOpenFileNameW( lpofn ); - } - - virtual BOOL SAL_CALL getSaveFileName( LPOPENFILENAMEW lpofn ) - { - return ::GetSaveFileNameW( lpofn ); - } - - virtual DWORD SAL_CALL commDlgExtendedError( ) - { - return ::CommDlgExtendedError( ); - } - - // a factory method, so it's possible to create - // different instances of this class depending - // on the apartment model of the calling thread, - // the OS version etc. - // the client owns the returned instance and - // should destroy it using delete - static CGetFileNameWrapper* create( ); + CGetFileNameWrapper(); -protected: - - // let instances only be created through - // the create method - CGetFileNameWrapper( ) { }; -}; - -/* - The wrapper always calls the GetOpenFileName/GetSaveFileName in - a STA thread because a lot of features of the system file dialogs - are disabled when the calling thread is an MTA thread - (this is a MS Bug at least that they don't document this). - This class is not thread-safe. -*/ - -class CSTAGetFileNameWrapper : public CGetFileNameWrapper -{ -public: - virtual ~CSTAGetFileNameWrapper( ); - - virtual BOOL SAL_CALL getOpenFileName( LPOPENFILENAMEW lpofn ); - - virtual BOOL SAL_CALL getSaveFileName( LPOPENFILENAMEW lpofn ); - - virtual DWORD SAL_CALL commDlgExtendedError( ); - -protected: - CSTAGetFileNameWrapper( ); + bool getOpenFileName(LPOPENFILENAMEW lpofn); + bool getSaveFileName(LPOPENFILENAMEW lpofn); + int commDlgExtendedError(); private: - void SAL_CALL executeGetFileName( ); - void SAL_CALL executeGetFileName( BOOL bFileOpenDialog, LPOPENFILENAMEW lpofn ); - bool SAL_CALL threadExecuteGetFileName( ); - - static unsigned __stdcall threadProc( void * pParam ); - -private: - DWORD m_LastError; - BOOL m_bFileOpenDialog; - BOOL m_bResult; - LPOPENFILENAMEW m_lpofn; - -// prevent copy/assignment -private: - CSTAGetFileNameWrapper( const CSTAGetFileNameWrapper& ); - CSTAGetFileNameWrapper& operator=( const CSTAGetFileNameWrapper& ); - - friend class CGetFileNameWrapper; + int m_ExtendedDialogError; }; #endif diff --git a/fpicker/source/win32/filepicker/previewadapter.cxx b/fpicker/source/win32/filepicker/previewadapter.cxx index 9108927786d5..e25f41775aa7 100644 --- a/fpicker/source/win32/filepicker/previewadapter.cxx +++ b/fpicker/source/win32/filepicker/previewadapter.cxx @@ -2,9 +2,9 @@ * * $RCSfile: previewadapter.cxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:11:50 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -118,11 +118,11 @@ public: // parent notification handler //------------------------------------- - virtual void SAL_CALL notifyParentShow(sal_Bool bShow); + virtual void SAL_CALL notifyParentShow(bool bShow); virtual void SAL_CALL notifyParentSizeChanged(); - virtual void SAL_CALL notifyParentWindowPosChanged(sal_Bool bIsVisible); + virtual void SAL_CALL notifyParentWindowPosChanged(bool bIsVisible); protected: virtual void SAL_CALL calcRightMargin(); @@ -280,7 +280,7 @@ void SAL_CALL CPreviewAdapterImpl::calcRightMargin() // //----------------------------------------- -void SAL_CALL CPreviewAdapterImpl::notifyParentShow(sal_Bool bShow) +void SAL_CALL CPreviewAdapterImpl::notifyParentShow(bool bShow) { } @@ -297,7 +297,7 @@ void SAL_CALL CPreviewAdapterImpl::notifyParentSizeChanged() // //----------------------------------------- -void SAL_CALL CPreviewAdapterImpl::notifyParentWindowPosChanged(sal_Bool bIsVisible) +void SAL_CALL CPreviewAdapterImpl::notifyParentWindowPosChanged(bool bIsVisible) { } @@ -453,7 +453,7 @@ class CWin98PreviewAdapterImpl : public CPreviewAdapterImpl public: CWin98PreviewAdapterImpl(HINSTANCE instance); - virtual void SAL_CALL notifyParentWindowPosChanged(sal_Bool bIsVisible); + virtual void SAL_CALL notifyParentWindowPosChanged(bool bIsVisible); protected: virtual void SAL_CALL rearrangeLayout(); @@ -486,7 +486,7 @@ CWin98PreviewAdapterImpl::CWin98PreviewAdapterImpl(HINSTANCE instance) : // //-------------------------------------------- -void SAL_CALL CWin98PreviewAdapterImpl::notifyParentWindowPosChanged(sal_Bool bIsVisible) +void SAL_CALL CWin98PreviewAdapterImpl::notifyParentWindowPosChanged(bool bIsVisible) { try { @@ -593,7 +593,7 @@ class CWin95NTPreviewAdapterImpl : public CPreviewAdapterImpl public: CWin95NTPreviewAdapterImpl(HINSTANCE instance); - virtual void SAL_CALL notifyParentShow(sal_Bool bShow); + virtual void SAL_CALL notifyParentShow(bool bShow); }; //-------------------------------------------- @@ -609,7 +609,7 @@ CWin95NTPreviewAdapterImpl::CWin95NTPreviewAdapterImpl(HINSTANCE instance) : // //-------------------------------------------- -void SAL_CALL CWin95NTPreviewAdapterImpl::notifyParentShow(sal_Bool bShow) +void SAL_CALL CWin95NTPreviewAdapterImpl::notifyParentShow(bool bShow) { try { @@ -727,7 +727,7 @@ void SAL_CALL CPreviewAdapter::setParent(HWND parent) // //------------------------------- -void SAL_CALL CPreviewAdapter::notifyParentShow(sal_Bool bShow) +void SAL_CALL CPreviewAdapter::notifyParentShow(bool bShow) { m_pImpl->notifyParentShow(bShow); } @@ -745,7 +745,7 @@ void SAL_CALL CPreviewAdapter::notifyParentSizeChanged() // //------------------------------- -void SAL_CALL CPreviewAdapter::notifyParentWindowPosChanged(sal_Bool bIsVisible) +void SAL_CALL CPreviewAdapter::notifyParentWindowPosChanged(bool bIsVisible) { m_pImpl->notifyParentWindowPosChanged(bIsVisible); } diff --git a/fpicker/source/win32/filepicker/previewadapter.hxx b/fpicker/source/win32/filepicker/previewadapter.hxx index 39e114da4ce3..bb21e5ba9f4a 100644 --- a/fpicker/source/win32/filepicker/previewadapter.hxx +++ b/fpicker/source/win32/filepicker/previewadapter.hxx @@ -2,9 +2,9 @@ * * $RCSfile: previewadapter.hxx,v $ * - * $Revision: 1.1 $ + * $Revision: 1.2 $ * - * last change: $Author: tra $ $Date: 2002-03-21 07:11:58 $ + * last change: $Author: tra $ $Date: 2002-03-28 08:57:33 $ * * The Contents of this file are made available subject to the terms of * either of the following licenses @@ -128,11 +128,11 @@ public: // notification from parent //-------------------------------------- - void SAL_CALL notifyParentShow(sal_Bool bShow); + void SAL_CALL notifyParentShow(bool bShow); void SAL_CALL notifyParentSizeChanged(); - void SAL_CALL notifyParentWindowPosChanged(sal_Bool bIsVisible); + void SAL_CALL notifyParentWindowPosChanged(bool bIsVisible); private: // hide implementation details using the -- cgit