| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_svtools.hxx" |
| #include <vcl/svapp.hxx> |
| #include <vcl/button.hxx> |
| #include <vcl/fixed.hxx> |
| #include <vcl/edit.hxx> |
| #include <vcl/lstbox.hxx> |
| #include <svtools/svtdata.hxx> |
| #include <filedlg2.hxx> |
| #include <svtools/filedlg.hxx> |
| #include <svtools/filedlg2.hrc> |
| #include <vcl/msgbox.hxx> |
| #include <vos/security.hxx> |
| #include <com/sun/star/i18n/XCollator.hpp> |
| |
| #include <svtools/stdctrl.hxx> |
| |
| #ifdef _MSC_VER |
| #pragma optimize ("", off) |
| #endif |
| |
| #include <svtools/helpid.hrc> |
| |
| using namespace com::sun::star; |
| using namespace com::sun::star::uno; |
| |
| |
| DECLARE_LIST( UniStringList, UniString* ) |
| |
| #define STD_BTN_WIDTH 80 |
| #define STD_BTN_HEIGHT 26 |
| |
| #ifndef UNX |
| #define ALLFILES "*.*" |
| #else |
| #define ALLFILES "*" |
| #endif |
| // #define STD_BTN_WIDTH 90 |
| // #define STD_BTN_HEIGHT 35 |
| |
| #define INITCONTROL( p, ControlClass, nBits, aPos, aSize, aTitel, rHelpId ) \ |
| p = new ControlClass( GetPathDialog(), WinBits( nBits ) ); \ |
| p->SetHelpId( rHelpId ); \ |
| p->SetPosSizePixel( aPos, aSize ); \ |
| p->SetText( aTitel ); \ |
| p->Show(); |
| |
| |
| inline sal_Bool IsPrintable( sal_Unicode c ) |
| { |
| return c >= 32 && c != 127 ? sal_True : sal_False; |
| } |
| |
| long |
| KbdListBox::PreNotify( NotifyEvent& rNEvt ) |
| { |
| if ( rNEvt.GetType() == EVENT_KEYINPUT ) |
| { |
| KeyEvent aKeyEvt = *rNEvt.GetKeyEvent(); |
| sal_Unicode cCharCode = aKeyEvt.GetCharCode(); |
| |
| if ( IsPrintable ( cCharCode ) ) |
| { |
| sal_uInt16 nCurrentPos = GetSelectEntryPos(); |
| sal_uInt16 nEntries = GetEntryCount(); |
| |
| for ( sal_uInt16 i = 1; i < nEntries; i++ ) |
| { |
| UniString aEntry = GetEntry ( (i + nCurrentPos) % nEntries ); |
| aEntry.EraseLeadingChars( ' ' ); |
| aEntry.ToUpperAscii(); |
| UniString aCompare( cCharCode ); |
| aCompare.ToUpperAscii(); |
| |
| if ( aEntry.CompareTo( aCompare, 1 ) == COMPARE_EQUAL ) |
| { |
| SelectEntryPos ( (i + nCurrentPos) % nEntries ); |
| break; |
| } |
| } |
| } |
| else |
| if ( aKeyEvt.GetKeyCode().GetCode() == KEY_RETURN ) |
| { |
| DoubleClick(); |
| } |
| } |
| |
| return ListBox::PreNotify ( rNEvt ); |
| } |
| |
| ImpPathDialog::ImpPathDialog( PathDialog* pDlg, RESOURCE_TYPE nType, sal_Bool bCreateDir ) |
| { |
| pSvPathDialog = pDlg; |
| nDirCount = 0; |
| |
| // initialize Controls if not used as a base class |
| if ( nType == WINDOW_PATHDIALOG ) |
| { |
| InitControls(); |
| if( pNewDirBtn ) |
| pNewDirBtn->Enable( bCreateDir ); |
| } |
| |
| pDlg->SetHelpId( HID_FILEDLG_PATHDLG ); |
| |
| lang::Locale aLocale = Application::GetSettings().GetLocale(); |
| xCollator = ::vcl::unohelper::CreateCollator(); |
| if( xCollator.is() ) |
| xCollator->loadDefaultCollator( aLocale, 1 ); |
| DBG_ASSERT( xCollator.is(), "not collator service for path dialog" ); |
| } |
| |
| ImpPathDialog::~ImpPathDialog() |
| { |
| delete pEdit; |
| delete pDirTitel; |
| delete pDirList; |
| delete pDirPath; |
| delete pDriveList; |
| delete pDriveTitle; |
| delete pLoadBtn; |
| delete pOkBtn; |
| delete pCancelBtn; |
| delete pNewDirBtn; |
| # if defined(UNX) || defined(OS2) |
| delete pHomeBtn; |
| # endif |
| } |
| |
| void ImpPathDialog::InitControls() |
| { |
| PathDialog* pDlg = GetPathDialog(); |
| pDlg->SetText( UniString( SvtResId( STR_FILEDLG_SELECT ) ) ); |
| |
| Size a3Siz = pDlg->LogicToPixel( Size( 3, 3 ), MAP_APPFONT ); |
| Size a6Siz = pDlg->LogicToPixel( Size( 6, 6 ), MAP_APPFONT ); |
| Size aBtnSiz = pDlg->LogicToPixel( Size( 50, 14 ), MAP_APPFONT ); |
| Size aFTSiz = pDlg->LogicToPixel( Size( 142, 10 ), MAP_APPFONT ); |
| Size aEDSiz = pDlg->LogicToPixel( Size( 142, 12 ), MAP_APPFONT ); |
| Point aPnt( a6Siz.Width(), a6Siz.Height() ); |
| long nLbH1 = pDlg->LogicToPixel( Size( 0, 93 ), MAP_APPFONT ).Height(); |
| long nH = 0; |
| UniString aEmptyStr; |
| |
| INITCONTROL( pDirTitel, FixedText, 0, |
| aPnt, aFTSiz, UniString( SvtResId( STR_FILEDLG_DIR ) ), HID_FILEDLG_DIR ); |
| aPnt.Y() += aFTSiz.Height() + a3Siz.Height(); |
| |
| INITCONTROL( pEdit, Edit, WB_BORDER, aPnt, aEDSiz, aPath.GetFull(), HID_FILEDLG_EDIT ); |
| |
| aPnt.Y() += aEDSiz.Height() + a3Siz.Height(); |
| #ifndef UNX |
| long nLbH2 = pDlg->LogicToPixel( Size( 0, 60 ), MAP_APPFONT ).Height(); |
| INITCONTROL( pDirList, KbdListBox, WB_AUTOHSCROLL | WB_BORDER, |
| aPnt, Size( aEDSiz.Width(), nLbH1 ), aEmptyStr, HID_FILEDLG_DIRS ); |
| aPnt.Y() += nLbH1 + a6Siz.Height(); |
| INITCONTROL( pDriveTitle, FixedText, 0, |
| aPnt, aFTSiz, UniString( SvtResId( STR_FILEDLG_DRIVES ) ), HID_FILEDLG_DRIVE ); |
| aPnt.Y() += aFTSiz.Height() + a3Siz.Height(); |
| INITCONTROL( pDriveList, ListBox, WB_DROPDOWN, |
| aPnt, Size( aEDSiz.Width(), nLbH2 ), aEmptyStr, HID_FILEDLG_DRIVES ); |
| nH = aPnt.Y() + aEDSiz.Height() + a6Siz.Height(); |
| #else |
| long nNewH = nLbH1 + 3 * a3Siz.Height() + |
| aFTSiz.Height() + aEDSiz.Height(); |
| INITCONTROL( pDirList, KbdListBox, WB_AUTOHSCROLL | WB_BORDER, |
| aPnt, Size( aEDSiz.Width(), nNewH ), aEmptyStr, HID_FILEDLG_DIRS ); |
| nH = aPnt.Y() + nNewH + a6Siz.Height(); |
| pDriveTitle = NULL; |
| pDriveList = NULL; |
| #endif |
| |
| long nExtraWidth = pDlg->GetTextWidth( String( RTL_CONSTASCII_USTRINGPARAM( "(W)" ) ) )+10; |
| String aOkStr = Button::GetStandardText( BUTTON_OK ); |
| long nTextWidth = pDlg->GetTextWidth( aOkStr )+nExtraWidth; |
| if( nTextWidth > aBtnSiz.Width() ) |
| aBtnSiz.Width() = nTextWidth; |
| |
| String aCancelStr = Button::GetStandardText( BUTTON_CANCEL ); |
| nTextWidth = pDlg->GetTextWidth( aCancelStr )+nExtraWidth; |
| if( nTextWidth > aBtnSiz.Width() ) |
| aBtnSiz.Width() = nTextWidth; |
| |
| String aNewDirStr( SvtResId( STR_FILEDLG_NEWDIR ) ); |
| nTextWidth = pDlg->GetTextWidth( aNewDirStr )+nExtraWidth; |
| if( nTextWidth > aBtnSiz.Width() ) |
| aBtnSiz.Width() = nTextWidth; |
| #if defined(UNX) || defined(OS2) |
| String aHomeDirStr( SvtResId( STR_FILEDLG_HOME ) ); |
| nTextWidth = pDlg->GetTextWidth( aHomeDirStr )+nExtraWidth; |
| if( nTextWidth > aBtnSiz.Width() ) |
| aBtnSiz.Width() = nTextWidth; |
| #endif |
| |
| aPnt.X() = 2 * a6Siz.Width() + aEDSiz.Width(); |
| aPnt.Y() = a6Siz.Height(); |
| INITCONTROL( pOkBtn, PushButton, WB_DEFBUTTON, |
| aPnt, aBtnSiz, aOkStr, "" ); |
| aPnt.Y() += aBtnSiz.Height() + a3Siz.Height(); |
| INITCONTROL( pCancelBtn, CancelButton, 0, |
| aPnt, aBtnSiz, aCancelStr, "" ); |
| aPnt.Y() += aBtnSiz.Height() + a3Siz.Height(); |
| INITCONTROL( pNewDirBtn, PushButton, WB_DEFBUTTON, |
| aPnt, aBtnSiz, aNewDirStr, HID_FILEDLG_NEWDIR ); |
| #if defined(UNX) || defined(OS2) |
| aPnt.Y() += aBtnSiz.Height() + a3Siz.Height(); |
| INITCONTROL( pHomeBtn, PushButton, WB_DEFBUTTON, |
| aPnt, aBtnSiz, aHomeDirStr, HID_FILEDLG_HOME ); |
| #else |
| pHomeBtn = NULL; |
| #endif |
| |
| pDirPath = 0; |
| pLoadBtn = 0; |
| // Dialogbreite == OKBtn-Position + OKBtn-Breite + Rand |
| long nW = aPnt.X() + aBtnSiz.Width() + a6Siz.Width(); |
| |
| pDlg->SetOutputSizePixel( Size( nW, nH ) ); // Groesse ggf. auch Resource wird geplaettet? |
| |
| if (pDirList) |
| pDirList->SetDoubleClickHdl(LINK( this, ImpPathDialog, DblClickHdl) ); |
| |
| if (pDirList) |
| pDirList->SetSelectHdl( LINK( this, ImpPathDialog, SelectHdl ) ); |
| |
| if (pDriveList) |
| pDriveList->SetSelectHdl( LINK( this, ImpPathDialog, SelectHdl ) ); |
| |
| if (pOkBtn) |
| pOkBtn->SetClickHdl( LINK( this, ImpPathDialog, ClickHdl) ); |
| |
| if (pCancelBtn) |
| pCancelBtn->SetClickHdl( LINK( this, ImpPathDialog, ClickHdl) ); |
| |
| if (pHomeBtn) |
| pHomeBtn->SetClickHdl( LINK( this, ImpPathDialog, ClickHdl) ); |
| |
| if (pNewDirBtn) |
| pNewDirBtn->SetClickHdl( LINK( this, ImpPathDialog, ClickHdl) ); |
| |
| nOwnChilds = pDlg->GetChildCount(); |
| } |
| |
| |
| |
| IMPL_LINK( ImpPathDialog, SelectHdl, ListBox *, p ) |
| { |
| if( p == pDriveList ) |
| { |
| UniString aDrive( pDriveList->GetSelectEntry(), 0, 2); |
| aDrive += '\\'; |
| SetPath( aDrive ); |
| } |
| else |
| if( p == pDirList ) |
| { |
| // isolate the pure name of the entry |
| // removing trainling stuff and leading spaces |
| UniString aEntry( pDirList->GetSelectEntry() ); |
| |
| aEntry.EraseLeadingChars( ' ' ); |
| sal_uInt16 nPos = aEntry.Search( '/' ); |
| aEntry.Erase( nPos ); |
| |
| // build the absolute path to the selected item |
| DirEntry aNewPath; |
| aNewPath.ToAbs(); |
| |
| sal_uInt16 nCurPos = pDirList->GetSelectEntryPos(); |
| |
| // Wird nach oben gewechselt |
| if( nCurPos < nDirCount ) |
| aNewPath = aNewPath[nDirCount-nCurPos-1]; |
| else |
| aNewPath += aEntry; |
| |
| pEdit->SetText( aNewPath.GetFull() ); |
| } |
| |
| return 0; |
| } |
| |
| |
| IMPL_LINK( ImpPathDialog, ClickHdl, Button*, pBtn ) |
| { |
| if ( pBtn == pOkBtn || pBtn == pLoadBtn ) |
| { |
| DirEntry aFile( pEdit->GetText() ); |
| |
| // Existiert File / File ueberschreiben |
| if( IsFileOk( aFile ) ) |
| { |
| // Ja, dann kompletten Pfad mit Filenamen merken und Dialog beenden |
| aPath = aFile; |
| aPath.ToAbs(); |
| GetPathDialog()->EndDialog( sal_True ); |
| } |
| else |
| { |
| DirEntry aCheck( aPath ); |
| aCheck += aFile; |
| if( aCheck.Exists() ) |
| { |
| aCheck.ToAbs(); |
| SetPath( aCheck.GetFull() ); |
| pEdit->SetSelection( Selection( 0x7FFFFFFF, 0x7FFFFFFF ) ); |
| } |
| } |
| } |
| else |
| if ( pBtn == pCancelBtn ) |
| { |
| GetPathDialog()->EndDialog( sal_False ); |
| } |
| else |
| if ( pBtn == pHomeBtn ) |
| { |
| ::rtl::OUString aHomeDir; |
| vos:: OSecurity aSecurity; |
| if ( aSecurity.getHomeDir( aHomeDir ) ) |
| { |
| DirEntry aFile ( aHomeDir ); |
| if ( IsFileOk( aFile ) ) |
| { |
| aFile.ToAbs(); |
| SetPath( aFile.GetFull() ); |
| } |
| } |
| } |
| else |
| if ( pBtn == pNewDirBtn ) |
| { |
| DirEntry aFile( pEdit->GetText() ); |
| if( ! aFile.Exists() && ! FileStat( aFile ).IsKind( FSYS_KIND_WILD ) ) |
| aFile.MakeDir(); |
| |
| if( IsFileOk ( aFile ) ) |
| { |
| aFile.ToAbs(); |
| SetPath( aFile.GetFull() ); |
| } |
| } |
| |
| return 0; |
| } |
| |
| |
| IMPL_LINK( ImpPathDialog, DblClickHdl, ListBox*, pBox ) |
| { |
| // isolate the pure name of the entry |
| // removing trainling stuff and leading spaces |
| UniString aEntry( pBox->GetSelectEntry() ); |
| |
| aEntry.EraseLeadingChars( ' ' ); |
| sal_uInt16 nPos = aEntry.Search( '/' ); |
| aEntry.Erase( nPos ); |
| |
| // build the absolute path to the selected item |
| DirEntry aNewPath; |
| aNewPath.ToAbs(); |
| if( pBox == pDirList ) |
| { |
| sal_uInt16 nCurPos = pDirList->GetSelectEntryPos(); |
| |
| // Wenn es schon das aktuelle ist, dann mache nichts |
| if( nCurPos == nDirCount-1 ) |
| return 0; |
| |
| // Wird nach oben gewechselt |
| if( nCurPos < nDirCount ) |
| aNewPath = aNewPath[nDirCount-nCurPos-1]; |
| else |
| aNewPath += aEntry; |
| } |
| else |
| aNewPath += aEntry; |
| |
| pSvPathDialog->EnterWait(); |
| |
| if( FileStat( aNewPath ).GetKind() & FSYS_KIND_DIR ) |
| { |
| // Neuen Pfad setzen und Listboxen updaten |
| aPath = aNewPath; |
| if( !aPath.SetCWD( sal_True ) ) |
| { |
| ErrorBox aBox( GetPathDialog(), |
| WB_OK_CANCEL | WB_DEF_OK, |
| UniString( SvtResId( STR_FILEDLG_CANTCHDIR ) ) ); |
| if( aBox.Execute() == RET_CANCEL ) |
| GetPathDialog()->EndDialog( sal_False ); |
| } |
| UpdateEntries( sal_True ); |
| } |
| |
| pSvPathDialog->LeaveWait(); |
| return 0; |
| } |
| |
| void ImpPathDialog::UpdateEntries( const sal_Bool ) |
| { |
| UniString aTabString; |
| DirEntry aTmpPath; |
| aTmpPath.ToAbs(); |
| |
| nDirCount = aTmpPath.Level(); |
| |
| pDirList->SetUpdateMode( sal_False ); |
| pDirList->Clear(); |
| |
| for( sal_uInt16 i = nDirCount; i > 0; i-- ) |
| { |
| UniString aName( aTabString ); |
| aName += aTmpPath[i-1].GetName(); |
| pDirList->InsertEntry( aName ); |
| aTabString.AppendAscii( " ", 2 ); |
| } |
| |
| // scan the directory |
| DirEntry aCurrent; |
| aCurrent.ToAbs(); |
| |
| Dir aDir( aCurrent, FSYS_KIND_DIR|FSYS_KIND_FILE ); |
| |
| sal_uInt16 nEntries = aDir.Count(); |
| if( nEntries ) |
| { |
| UniStringList aSortDirList; |
| for ( sal_uInt16 n = 0; n < nEntries; n++ ) |
| { |
| DirEntry& rEntry = aDir[n]; |
| UniString aName( rEntry.GetName() ); |
| if( aName.Len() && ( aName.GetChar(0) != '.' ) && rEntry.Exists() ) |
| { |
| if( FileStat( rEntry ).GetKind() & FSYS_KIND_DIR ) |
| { |
| sal_uLong l = 0; |
| if( xCollator.is() ) |
| { |
| for( l = 0; l < aSortDirList.Count(); l++ ) |
| if( xCollator->compareString( *aSortDirList.GetObject(l), aName ) > 0 ) |
| break; |
| } |
| aSortDirList.Insert( new UniString( aName ), l ); |
| } |
| } |
| } |
| |
| for( sal_uLong l = 0; l < aSortDirList.Count(); l++ ) |
| { |
| UniString aEntryStr( aTabString ); |
| aEntryStr += *aSortDirList.GetObject(l); |
| pDirList->InsertEntry( aEntryStr ); |
| delete aSortDirList.GetObject(l); |
| } |
| } |
| |
| UpdateDirs( aTmpPath ); |
| } |
| |
| void ImpPathDialog::UpdateDirs( const DirEntry& rTmpPath ) |
| { |
| pDirList->SelectEntryPos( nDirCount-1 ); |
| pDirList->SetTopEntry( nDirCount > 1 |
| ? nDirCount - 2 |
| : nDirCount - 1 ); |
| pDirList->SetUpdateMode( sal_True ); |
| pDirList->Invalidate(); |
| pDirList->Update(); |
| |
| UniString aDirName = rTmpPath.GetFull(); |
| if( pDirPath ) |
| pDirPath->SetText( aDirName ); |
| else |
| pEdit->SetText( aDirName ); |
| } |
| |
| sal_Bool ImpPathDialog::IsFileOk( const DirEntry& rDirEntry ) |
| { |
| if( FileStat( rDirEntry ).GetKind() & (FSYS_KIND_WILD | FSYS_KIND_DEV) ) |
| return sal_False; |
| else |
| { |
| // Datei vorhanden ? |
| if( ! rDirEntry.Exists() ) |
| { |
| UniString aQueryTxt( SvtResId( STR_FILEDLG_ASKNEWDIR ) ); |
| aQueryTxt.SearchAndReplaceAscii( "%s", rDirEntry.GetFull() ); |
| QueryBox aQuery( GetPathDialog(), |
| WB_YES_NO | WB_DEF_YES, |
| aQueryTxt ); |
| if( aQuery.Execute() == RET_YES ) |
| rDirEntry.MakeDir(); |
| else |
| return sal_False; |
| } |
| if( !FileStat( rDirEntry ).IsKind( FSYS_KIND_DIR ) ) |
| { |
| UniString aBoxText( SvtResId( STR_FILEDLG_CANTOPENDIR ) ); |
| aBoxText.AppendAscii( "\n[" ); |
| aBoxText += rDirEntry.GetFull(); |
| aBoxText.AppendAscii( "]" ); |
| InfoBox aBox( GetPathDialog(), aBoxText ); |
| aBox.Execute(); |
| return sal_False; |
| } |
| } |
| return GetPathDialog()->OK() != 0; |
| } |
| |
| |
| void ImpPathDialog::PreExecute() |
| { |
| // Neues Verzeichnis setzen und Listboxen updaten |
| aPath.SetCWD( sal_True ); |
| UpdateEntries( sal_True ); |
| |
| // Zusaetzliche Buttons anordnen |
| Point aPos; |
| Size aSize; |
| long nDY; |
| if( pLoadBtn ) |
| { |
| aPos = pLoadBtn->GetPosPixel(); |
| aSize = pLoadBtn->GetSizePixel(); |
| nDY = pLoadBtn->GetSizePixel().Height() * 2; |
| } |
| else |
| { |
| aPos = pCancelBtn->GetPosPixel(); |
| aSize = pCancelBtn->GetSizePixel(); |
| nDY = pCancelBtn->GetPosPixel().Y() - pOkBtn->GetPosPixel().Y(); |
| } |
| |
| // Standard-Controls anpassen |
| long nMaxWidth = 0; |
| |
| // Maximale Breite ermitteln |
| sal_uInt16 nChilds = GetPathDialog()->GetChildCount(); |
| sal_uInt16 n; |
| for ( n = nOwnChilds; n < nChilds; n++ ) |
| { |
| Window* pChild = GetPathDialog()->GetChild( n ); |
| pChild = pChild->GetWindow( WINDOW_CLIENT ); |
| if( pChild->GetType() != WINDOW_WINDOW ) |
| { |
| long nWidth = pChild->GetTextWidth( pChild->GetText() ) + 12; |
| if( nMaxWidth < nWidth ) |
| nMaxWidth = nWidth; |
| nWidth = pChild->GetSizePixel().Width(); |
| if( nMaxWidth < nWidth ) |
| nMaxWidth = nWidth; |
| } |
| } |
| |
| if( nMaxWidth > aSize.Width() ) |
| { |
| Size aDlgSize = GetPathDialog()->GetOutputSizePixel(); |
| GetPathDialog()->SetOutputSizePixel( Size( aDlgSize.Width()+nMaxWidth-aSize.Width(), aDlgSize.Height() ) ); |
| aSize.Width() = nMaxWidth; |
| |
| if( pOkBtn ) |
| pOkBtn->SetSizePixel( aSize ); |
| if( pCancelBtn ) |
| pCancelBtn->SetSizePixel( aSize ); |
| if( pLoadBtn ) |
| pLoadBtn->SetSizePixel( aSize ); |
| } |
| else |
| nMaxWidth = aSize.Width(); |
| |
| for ( n = nOwnChilds; n < nChilds; n++ ) |
| { |
| Window* pChild = GetPathDialog()->GetChild( n ); |
| pChild = pChild->GetWindow( WINDOW_CLIENT ); |
| if( pChild->GetType() != WINDOW_WINDOW ) |
| { |
| aPos.Y() += nDY; |
| pChild->SetPosSizePixel( aPos, aSize ); |
| } |
| else |
| { |
| Size aDlgSize = GetPathDialog()->GetOutputSizePixel(); |
| long nExtra = Min( aDlgSize.Height(), (long)160); |
| GetPathDialog()->SetOutputSizePixel( Size( aDlgSize.Width()+nExtra, aDlgSize.Height() ) ); |
| Size aSz( nExtra, nExtra ); |
| aSz.Width() -= 8; |
| aSz.Height() -= 8; |
| Point aCtrlPos( aDlgSize.Width() + 2, (aDlgSize.Height()-aSz.Height())/2 ); |
| pChild->SetPosSizePixel( aCtrlPos, aSz ); |
| } |
| } |
| |
| // Laufwerke-LB fuellen |
| if( pDriveList ) |
| { |
| DirEntry aTmpDirEntry; |
| Dir aDir( aTmpDirEntry, FSYS_KIND_BLOCK ); |
| |
| sal_uInt16 nCount = aDir.Count(), i; |
| for( i = 0; i < nCount; ++i ) |
| { |
| DirEntry& rEntry = aDir[i]; |
| UniString aStr = rEntry.GetFull( FSYS_STYLE_HOST, sal_False ); |
| |
| UniString aVolume = rEntry.GetVolume() ; |
| aStr.ToUpperAscii(); |
| if ( aVolume.Len() ) |
| { |
| aStr += ' '; |
| aStr += aVolume; |
| } |
| pDriveList->InsertEntry( aStr ); |
| |
| } |
| UniString aPathStr = aPath.GetFull(); |
| |
| for ( i = 0; i < pDriveList->GetEntryCount(); ++i ) |
| { |
| UniString aEntry = pDriveList->GetEntry(i); |
| xub_StrLen nLen = aEntry.Len(); |
| nLen = nLen > 2 ? 2 : nLen; |
| if ( aEntry.CompareIgnoreCaseToAscii( aPathStr, nLen ) == COMPARE_EQUAL ) |
| { |
| pDriveList->SelectEntryPos(i); |
| break; |
| } |
| } |
| } |
| } |
| |
| void ImpPathDialog::PostExecute() |
| { |
| } |
| |
| void ImpPathDialog::SetPath( UniString const & rPath ) |
| { |
| aPath = DirEntry( rPath ); |
| |
| pSvPathDialog->EnterWait(); |
| |
| DirEntry aFile( rPath ); |
| // Falls der Pfad eine Wildcard oder einen Filenamen enthaelt |
| // -> abschneiden und merken |
| if( FileStat( aFile ).GetKind() & (FSYS_KIND_FILE | FSYS_KIND_WILD) || !aFile.Exists() ) |
| aFile.CutName(); |
| |
| // Neue Maske und neues Verzeichnis setzen, und Listboxen updaten |
| pEdit->SetText( rPath ); |
| aFile.SetCWD( sal_True ); |
| UpdateEntries( sal_True ); |
| |
| pSvPathDialog->LeaveWait(); |
| } |
| |
| void ImpPathDialog::SetPath( Edit const & rEdit ) |
| { |
| UniString aPresetText = rEdit.GetText(); |
| if( aPresetText.Len() ) |
| SetPath( aPresetText ); |
| } |
| |
| |
| UniString ImpPathDialog::GetPath() const |
| { |
| DirEntry aFile( pEdit->GetText() ); |
| aFile.ToAbs(); |
| return aFile.GetFull(); |
| } |
| |
| |
| ImpFileDialog::ImpFileDialog( PathDialog* pDlg, WinBits nWinBits, RESOURCE_TYPE nType ) : |
| ImpPathDialog( pDlg, nType, sal_False ) |
| { |
| bOpen = (nWinBits & WB_SAVEAS) == 0; |
| |
| SvtResId aSvtResId = bOpen ? STR_FILEDLG_OPEN : STR_FILEDLG_SAVE; |
| |
| // Titel setzen |
| GetFileDialog()->SetText( UniString( aSvtResId ) ); |
| nDirCount = 0; |
| |
| // initialize Controls if not used as a base class |
| if ( nType == WINDOW_FILEDIALOG ) |
| InitControls(); |
| |
| pDlg->SetHelpId( HID_FILEDLG_OPENDLG ); |
| |
| } |
| |
| ImpFileDialog::~ImpFileDialog() |
| { |
| ImpFilterItem* pItem = aFilterList.First(); |
| while( pItem ) |
| { |
| delete pItem; |
| pItem = aFilterList.Next(); |
| } |
| |
| delete pFileTitel; |
| if (pFileList && ( pFileList != pDirList ) ) |
| delete pFileList; |
| |
| delete pTypeTitel; |
| delete pTypeList; |
| } |
| |
| void ImpFileDialog::InitControls() |
| { |
| UniString aEmptyStr; |
| |
| const int nW = 160; |
| const int nH = 48; // Um den Dialog in eine akzeptable Form zu bringen |
| |
| INITCONTROL( pFileTitel, FixedText, 0, |
| Point(10, 12), Size(nW, 18), UniString( SvtResId( STR_FILEDLG_FILE ) ), HID_FILEDLG_FILE ); |
| INITCONTROL( pEdit, Edit, WB_BORDER, |
| Point(10, 31), Size(nW, 20), aEmptyStr, HID_FILEDLG_EDIT ); // aMask() |
| INITCONTROL( pFileList, ListBox, WB_SORT | WB_AUTOHSCROLL | WB_BORDER, |
| Point(10, 58), Size(nW, 180-nH), aEmptyStr, HID_FILEDLG_FILES ); |
| |
| INITCONTROL( pDirTitel, FixedText, 0, |
| Point(nW+20, 12), Size(nW, 18), UniString( SvtResId( STR_FILEDLG_DIR ) ), HID_FILEDLG_DIR ); |
| INITCONTROL( pDirPath, FixedInfo, WB_PATHELLIPSIS, |
| Point(nW+20, 33), Size(nW, 20), aPath.GetFull(), HID_FILEDLG_PATH ); |
| INITCONTROL( pDirList, KbdListBox, WB_AUTOHSCROLL | WB_BORDER, |
| Point(nW+20, 58), Size(nW, 180-nH ), aEmptyStr, HID_FILEDLG_DIRS ); |
| |
| INITCONTROL( pTypeTitel, FixedText, 0, |
| Point(10, 246-nH), Size(nW, 18), UniString( SvtResId( STR_FILEDLG_TYPE ) ), HID_FILEDLG_TYPE ); |
| |
| #ifndef UNX |
| INITCONTROL( pTypeList, ListBox, WB_DROPDOWN, |
| Point(10, 265-nH ), Size(nW, 100 ), aEmptyStr, HID_FILEDLG_TYPES ); |
| |
| INITCONTROL( pDriveTitle, FixedText, 0, |
| Point(nW+20, 246-nH), Size(nW, 18), UniString( SvtResId( STR_FILEDLG_DRIVES ) ), HID_FILEDLG_DRIVE ); |
| INITCONTROL( pDriveList, ListBox, WB_DROPDOWN, |
| Point(nW+20, 265-nH ), Size(nW, 100 ), aEmptyStr, HID_FILEDLG_DRIVES ); |
| pNewDirBtn = NULL; |
| pHomeBtn = NULL; |
| #else |
| INITCONTROL( pTypeList, ListBox, WB_DROPDOWN, |
| Point(10, 265-nH ), Size(2*nW+20, 100 ), aEmptyStr, HID_FILEDLG_TYPES ); |
| |
| pDriveTitle = NULL; |
| pDriveList = NULL; |
| pNewDirBtn = NULL; |
| pHomeBtn = NULL; |
| #endif |
| |
| const long nButtonStartX = 2*nW+20+15; |
| INITCONTROL( pOkBtn, PushButton, WB_DEFBUTTON, |
| Point(nButtonStartX, 10), Size(STD_BTN_WIDTH, STD_BTN_HEIGHT), |
| Button::GetStandardText( BUTTON_OK ), "" ); |
| INITCONTROL( pCancelBtn, CancelButton, 0, |
| Point(nButtonStartX, 45 ), Size(STD_BTN_WIDTH, STD_BTN_HEIGHT), |
| Button::GetStandardText( BUTTON_CANCEL ), "" ); |
| |
| pLoadBtn = 0; |
| |
| GetFileDialog()->SetOutputSizePixel( Size(nButtonStartX+STD_BTN_WIDTH+10, 298-nH) ); |
| |
| nOwnChilds = GetPathDialog()->GetChildCount(); |
| |
| // Handler setzen |
| if (pDriveList) |
| pDriveList->SetSelectHdl( LINK( this, ImpFileDialog, SelectHdl ) ); |
| |
| if (pDirList) |
| pDirList->SetDoubleClickHdl(LINK( this, ImpFileDialog, DblClickHdl) ); |
| |
| if (pOkBtn) |
| pOkBtn->SetClickHdl( LINK( this, ImpFileDialog, ClickHdl) ); |
| |
| if (pCancelBtn) |
| pCancelBtn->SetClickHdl( LINK( this, ImpFileDialog, ClickHdl) ); |
| |
| if( pFileList ) |
| { |
| pFileList->SetSelectHdl( LINK( this, ImpFileDialog, SelectHdl ) ); |
| pFileList->SetDoubleClickHdl( LINK( this, ImpFileDialog, DblClickHdl ) ); |
| } |
| |
| if( pTypeList ) |
| pTypeList->SetSelectHdl( LINK( this, ImpFileDialog, DblClickHdl ) ); |
| } |
| |
| IMPL_LINK( ImpFileDialog, SelectHdl, ListBox *, p ) |
| { |
| if( p == pDriveList ) |
| { |
| UniString aDrive ( pDriveList->GetSelectEntry(), 0, 2); |
| aDrive += '\\'; |
| SetPath( aDrive ); |
| } |
| else if (p == pFileList) |
| { |
| // Ausgewaehltes File in das Edit stellen |
| pEdit->SetText( pFileList->GetSelectEntry() ); |
| GetFileDialog()->FileSelect(); |
| } |
| return 0; |
| } |
| |
| |
| IMPL_LINK( ImpFileDialog, DblClickHdl, ListBox *, pBox ) |
| { |
| // isolate the pure name of the entry |
| // removing trailing stuff and leading spaces |
| UniString aEntry( pBox->GetSelectEntry() ); |
| |
| aEntry.EraseLeadingChars( ' ' ); |
| sal_uInt16 nPos = aEntry.Search( '/' ); |
| aEntry.Erase( nPos ); |
| |
| // build the absolute path to the selected item |
| DirEntry aNewPath; |
| aNewPath.ToAbs(); |
| |
| if( ( pDirList != pFileList ) && ( pBox == pDirList ) ) |
| { |
| // SVLOOK |
| sal_uInt16 nCurPos = pDirList->GetSelectEntryPos(); |
| |
| // Wenn es schon das aktuelle ist, dann mache nichts |
| if( nCurPos == nDirCount-1 ) |
| return 0; |
| |
| // Wird nach oben gewechselt |
| if( nCurPos < nDirCount ) |
| aNewPath = aNewPath[nDirCount-nCurPos-1]; |
| else |
| aNewPath += aEntry; |
| } |
| else |
| { |
| // non-SVLOOK |
| if( aEntry == UniString( SvtResId( STR_FILEDLG_GOUP ) ) ) |
| aEntry.AssignAscii( ".." ); |
| aNewPath += aEntry; |
| } |
| |
| if( pBox == pFileList ) |
| { |
| DirEntry aFile( aEntry ); |
| |
| // Abfrage, ob File ueberschrieben werden soll... |
| if( !FileStat(aFile).IsKind(FSYS_KIND_DIR) && IsFileOk( aFile ) ) |
| { |
| // dann kompletten Pfad mit Filenamen merken und Dialog beenden |
| aPath = aNewPath; |
| GetFileDialog()->EndDialog( sal_True ); |
| } |
| } |
| |
| GetFileDialog()->EnterWait(); |
| |
| UniString aFull = aNewPath.GetFull(); |
| |
| if( ( ( pBox == pDirList ) && ( pDirList != pFileList ) ) || |
| ( ( pDirList == pFileList ) && FileStat( aNewPath ).GetKind() & FSYS_KIND_DIR ) ) |
| { |
| // Neuen Pfad setzen und Listboxen updaten |
| aPath = aNewPath; |
| if( !aPath.SetCWD( sal_True ) ) |
| { |
| if( ErrorBox( GetFileDialog(), WB_OK_CANCEL|WB_DEF_OK, |
| UniString( SvtResId( STR_FILEDLG_CANTCHDIR ) ) ).Execute() == RET_CANCEL ) |
| { |
| GetFileDialog()->EndDialog( sal_False ); |
| } |
| } |
| UpdateEntries( sal_True ); |
| GetFileDialog()->FileSelect(); |
| } |
| |
| if( pBox == pTypeList ) |
| { |
| // Neue Maske setzen, und Listboxen updaten |
| sal_uInt16 nCurPos = pTypeList->GetSelectEntryPos(); |
| if( nCurPos+1 > (sal_uInt16)aFilterList.Count() ) |
| aMask = UniString::CreateFromAscii( ALLFILES ); |
| else |
| { |
| UniString aFilterListMask = aFilterList.GetObject( nCurPos )->aMask; |
| // if( aFilterListMask.Search( ';' ) == STRING_NOTFOUND ) // kein ; in der Maske |
| // aMask = WildCard( aFilterListMask, '\0' ); |
| // else // ; muss beruecksichtigt werden |
| aMask = WildCard( aFilterListMask, ';' ); |
| } |
| |
| pEdit->SetText( aMask() ); |
| UpdateEntries( sal_False ); |
| GetFileDialog()->FilterSelect(); |
| } |
| |
| GetFileDialog()->LeaveWait(); |
| |
| return 0; |
| } |
| |
| IMPL_LINK( ImpFileDialog, ClickHdl, Button*, pBtn ) |
| { |
| if( ( pBtn == pOkBtn ) || ( pBtn == pLoadBtn ) ) |
| { |
| DirEntry aFile( pEdit->GetText() ); |
| |
| // Existiert File / File ueberschreiben |
| if( IsFileOk( aFile ) ) |
| { |
| // Ja, dann kompletten Pfad mit Filenamen merken und Dialog beenden |
| aPath = aFile; |
| aPath.ToAbs(); |
| GetFileDialog()->EndDialog( sal_True ); |
| } |
| else |
| { |
| GetFileDialog()->EnterWait(); |
| |
| // Falls der Pfad eine Wildcard oder einen Filenamen enthaelt |
| // -> abschneiden und merken |
| if( FileStat( aFile ).GetKind() & (FSYS_KIND_FILE | FSYS_KIND_WILD) || !aFile.Exists() ) |
| { |
| aMask = aFile.CutName(); |
| } |
| |
| // Neue Maske und neues Verzeichnis setzen, und Listboxen updaten |
| pEdit->SetText( aMask() ); |
| aFile.SetCWD( sal_True ); |
| UpdateEntries( sal_True ); |
| |
| GetFileDialog()->LeaveWait(); |
| } |
| } |
| else if( pBtn == pCancelBtn ) |
| GetFileDialog()->EndDialog( sal_False ); |
| |
| return 0; |
| } |
| |
| void ImpFileDialog::UpdateEntries( const sal_Bool bWithDirs ) |
| { |
| GetFileDialog()->EnterWait(); |
| |
| UniString aTabString; |
| DirEntry aTmpPath; |
| aTmpPath.ToAbs(); |
| nDirCount = aTmpPath.Level(); |
| |
| if( pFileList ) |
| { |
| pFileList->SetUpdateMode( sal_False ); |
| pFileList->Clear(); |
| } |
| |
| if( bWithDirs && (pDirList != pFileList) ) |
| { |
| pDirList->SetUpdateMode( sal_False ); |
| pDirList->Clear(); |
| |
| for( sal_uInt16 i = nDirCount; i > 0; i-- ) |
| { |
| UniString aEntryStr( aTabString ); |
| aEntryStr += aTmpPath[i-1].GetName(); |
| pDirList->InsertEntry( aEntryStr ); |
| aTabString.AppendAscii( " ", 2 ); |
| } |
| } |
| |
| // for the combined box insert a '..' |
| // (this happens only if WB_3DLOOK is not set) |
| |
| if( pDirList == pFileList && nDirCount != 1 ) |
| pFileList->InsertEntry( UniString( SvtResId( STR_FILEDLG_GOUP ) ) ); |
| |
| // scan the directory |
| DirEntry aCurrent; |
| aCurrent.ToAbs(); |
| Dir aDir( aCurrent, FSYS_KIND_DIR|FSYS_KIND_FILE ); |
| sal_uInt16 nEntries = aDir.Count(); |
| |
| // TempMask, weil Vergleich case-sensitiv |
| sal_Bool bMatchCase = sal_False; //aCurrent.IsCaseSensitive(); |
| UniString aWildCard( aMask.GetWildCard() ); |
| if ( !bMatchCase ) |
| aWildCard.ToLowerAscii(); |
| WildCard aTmpMask( aWildCard, ';' ); |
| if ( nEntries ) |
| { |
| UniStringList aSortDirList; |
| for ( sal_uInt16 n = 0; n < nEntries; n++ ) |
| { |
| DirEntry& rEntry = aDir[n]; |
| UniString aName( rEntry.GetName() ); |
| |
| if( aName.Len() && |
| ( ( ( aName.GetChar(0) != '.' ) || |
| ( ( aName.GetChar(0) == '.' ) && ( aMask.GetWildCard() ).GetChar(0) == '.' ) ) |
| && rEntry.Exists() ) ) |
| { |
| FileStat aFileStat( rEntry ); |
| UniString aTmpName( aName ); |
| if ( !bMatchCase ) |
| aTmpName.ToLowerAscii(); |
| if( ( aFileStat.GetKind() & FSYS_KIND_FILE ) && aTmpMask.Matches( aTmpName ) ) |
| { |
| if( pFileList ) |
| pFileList->InsertEntry( aName ); |
| } |
| else if( bWithDirs && ( aFileStat.GetKind() & FSYS_KIND_DIR ) ) |
| { |
| if( pDirList == pFileList ) |
| { |
| UniString aEntryStr( aName ); |
| aEntryStr += '/'; |
| pDirList->InsertEntry( aEntryStr ); |
| } |
| else |
| { |
| sal_uLong l = 0; |
| if( xCollator.is() ) |
| { |
| for( l = 0; l < aSortDirList.Count(); l++ ) |
| if( xCollator->compareString( *aSortDirList.GetObject(l), aName ) > 0 ) |
| break; |
| } |
| aSortDirList.Insert( new UniString( aName ), l ); |
| } |
| } |
| } |
| } |
| for( sal_uLong l = 0; l < aSortDirList.Count(); l++ ) |
| { |
| UniString aEntryStr( aTabString ); |
| aEntryStr += *aSortDirList.GetObject(l); |
| pDirList->InsertEntry( aEntryStr ); |
| delete aSortDirList.GetObject(l); |
| } |
| } |
| |
| if( bWithDirs ) |
| UpdateDirs( aTmpPath ); |
| |
| if( pFileList ) |
| { |
| if ( pDirList == pFileList && nDirCount > 1 ) |
| pFileList->SelectEntryPos( 1 ); |
| else |
| pFileList->SetNoSelection(); |
| pFileList->SetUpdateMode( sal_True ); |
| pFileList->Invalidate(); |
| pFileList->Update(); |
| } |
| |
| if( pDriveList ) |
| { |
| if( pDirList->GetEntryCount() > 0 ) |
| { |
| UniString aStr( pDirList->GetEntry( 0 ) ); |
| aStr.Erase( 2 ); |
| aStr.ToLowerAscii(); |
| pDriveList->SelectEntry( aStr ); |
| } |
| } |
| |
| GetFileDialog()->LeaveWait(); |
| } |
| |
| sal_Bool ImpFileDialog::IsFileOk( const DirEntry& rDirEntry ) |
| { |
| if( FileStat( rDirEntry ).GetKind() & (FSYS_KIND_WILD | FSYS_KIND_DEV) ) |
| return sal_False; |
| if( FileStat( rDirEntry ).GetKind() & FSYS_KIND_DIR ) |
| { |
| if( pFileList ) |
| return sal_False; |
| } |
| else if( bOpen ) |
| { |
| // Datei vorhanden ? |
| if( !FileStat( rDirEntry ).IsKind( FSYS_KIND_FILE ) ) |
| { |
| UniString aErrorString( SvtResId( STR_FILEDLG_CANTOPENFILE ) ); |
| aErrorString.AppendAscii( "\n[" ); |
| aErrorString += rDirEntry.GetFull(); |
| aErrorString += ']'; |
| InfoBox aBox( GetFileDialog(), |
| aErrorString ); |
| aBox.Execute(); |
| return sal_False; |
| } |
| } |
| else |
| { |
| // Datei vorhanden ? |
| if( FileStat( ExtendFileName( rDirEntry ) ).IsKind( FSYS_KIND_FILE ) ) |
| { |
| UniString aQueryString( SvtResId( STR_FILEDLG_OVERWRITE ) ); |
| aQueryString.AppendAscii( "\n[" ); |
| aQueryString += rDirEntry.GetFull(); |
| aQueryString += ']'; |
| QueryBox aBox( GetFileDialog(), |
| WinBits( WB_YES_NO | WB_DEF_NO ), |
| aQueryString ); |
| if( aBox.Execute() != RET_YES ) |
| return sal_False; |
| } |
| } |
| return GetFileDialog()->OK() != 0; |
| } |
| |
| void ImpFileDialog::SetPath( UniString const & rPath ) |
| { |
| aPath = DirEntry( rPath ); |
| GetFileDialog()->EnterWait(); |
| |
| DirEntry aFile( rPath ); |
| |
| // Falls der Pfad eine Wildcard oder einen Filenamen enthaelt |
| // -> abschneiden und merken |
| if( FileStat( aFile ).GetKind() & (FSYS_KIND_FILE | FSYS_KIND_WILD) || !aFile.Exists() ) |
| { |
| aMask = aFile.CutName(); |
| |
| // Neue Maske und neues Verzeichnis setzen, und Listboxen updaten |
| if( pDirList ) |
| { |
| UniString aWildCard( aMask.GetWildCard() ); |
| pEdit->SetText( aWildCard ); |
| } |
| else |
| pEdit->SetText( rPath ); |
| } |
| |
| aFile.SetCWD( sal_True ); |
| |
| UpdateEntries( sal_True ); |
| |
| GetFileDialog()->LeaveWait(); |
| } |
| |
| void ImpFileDialog::SetPath( Edit const& rEdit ) |
| { |
| UniString aPresetText = rEdit.GetText(); |
| if( aPresetText.Len() ) |
| SetPath( aPresetText ); |
| } |
| |
| |
| void ImpFileDialog::AddFilter( const UniString& rFilter, const UniString& rMask ) |
| { |
| aFilterList.Insert( new ImpFilterItem( rFilter, rMask ), LIST_APPEND ); |
| if( pTypeList ) |
| pTypeList->InsertEntry( rFilter, LISTBOX_APPEND ); |
| |
| if( !GetCurFilter().Len() ) |
| SetCurFilter( rFilter ); |
| } |
| |
| void ImpFileDialog::RemoveFilter( const UniString& rFilter ) |
| { |
| ImpFilterItem* pItem = aFilterList.First(); |
| while( pItem && pItem->aName != rFilter ) |
| pItem = aFilterList.Next(); |
| |
| if( pItem ) |
| { |
| delete aFilterList.Remove(); |
| if( pTypeList ) |
| pTypeList->RemoveEntry( rFilter ); |
| } |
| } |
| |
| void ImpFileDialog::RemoveAllFilter() |
| { |
| ImpFilterItem* pItem = aFilterList.First(); |
| while( pItem ) |
| { |
| delete pItem; |
| pItem = aFilterList.Next(); |
| } |
| aFilterList.Clear(); |
| |
| if( pTypeList ) |
| pTypeList->Clear(); |
| } |
| |
| void ImpFileDialog::SetCurFilter( const UniString& rFilter ) |
| { |
| if( !pTypeList ) |
| return; |
| |
| ImpFilterItem* pItem = aFilterList.First(); |
| while( pItem && pItem->aName != rFilter ) |
| pItem = aFilterList.Next(); |
| |
| if( pItem ) |
| pTypeList->SelectEntryPos( (sal_uInt16)aFilterList.GetCurPos() ); |
| else |
| pTypeList->SetNoSelection(); |
| } |
| |
| UniString ImpFileDialog::GetCurFilter() const |
| { |
| UniString aFilter; |
| if ( pTypeList ) |
| aFilter = pTypeList->GetSelectEntry(); |
| return aFilter; |
| } |
| |
| void ImpFileDialog::PreExecute() |
| { |
| // ListBoxen erst unmittelbar vor Execute fuellen |
| // (damit vor Execute der Pfad umgesetzt werden kann, ohne das immer die |
| // Listboxen sofort upgedatet werden) |
| |
| GetFileDialog()->EnterWait(); |
| |
| // Wenn kein Filter vorhanden, dann auch keine FilterBox |
| if( pTypeList && !pTypeList->GetEntryCount() ) |
| { |
| // pTypeList->InsertEntry( "* (all files)" ); |
| pTypeTitel->Disable(); |
| pTypeList->Disable(); |
| } |
| |
| if( pTypeList ) |
| { |
| sal_uInt16 nCurType = pTypeList->GetSelectEntryPos(); |
| if( nCurType < aFilterList.Count() ) |
| { |
| UniString aFilterListMask = aFilterList.GetObject( nCurType )->aMask; |
| if( aFilterListMask.Search( ';' ) == STRING_NOTFOUND ) // kein ; in der Maske |
| aMask = WildCard( aFilterListMask, '\0' ); |
| else // ; in der Maske, muss in der Wildcard beruecksichtigt werden |
| aMask = WildCard( aFilterListMask, ';' ); |
| } |
| else |
| aMask = UniString::CreateFromAscii( ALLFILES ); |
| } |
| else |
| aMask = UniString::CreateFromAscii( ALLFILES ); |
| |
| // Neue Maske setzen |
| if( pEdit->GetText().Len() == 0 ) |
| pEdit->SetText( aMask() ); |
| |
| ImpPathDialog::PreExecute(); |
| |
| GetFileDialog()->LeaveWait(); |
| } |
| |
| UniString ImpFileDialog::GetPath() const |
| { |
| DirEntry aFile( pEdit->GetText() ); |
| return ExtendFileName( aFile ); |
| } |
| |
| UniString ImpFileDialog::ExtendFileName( DirEntry aEntry ) const |
| { |
| aEntry.ToAbs(); |
| // das ganze Theater hier ohnehin nur machen, wenn Dateiname |
| // ohne Extension angegeben wurde |
| if( !aEntry.GetExtension().Len() ) |
| { |
| UniString aPostfix; // hier kommt die ausgesuchte Extension herein |
| |
| // ist ein Filter mit Extension gesetzt? |
| sal_uInt16 nChosenFilterPos = pTypeList->GetSelectEntryPos(); |
| if( nChosenFilterPos != LISTBOX_ENTRY_NOTFOUND ) |
| { |
| UniString aExtensionMask = GetFileDialog()->GetFilterType( nChosenFilterPos ); |
| // aExtension ist z.B. *.sdw, alles bis einschliesslich Punkt abschneiden |
| UniString aExtension = aExtensionMask.Copy( aExtensionMask.Search( '.' )+1 ); |
| |
| // hat der Filter ueberhaupt eine Extension |
| if( aExtension.Len() ) |
| { |
| // keine Wildcards enthalten? |
| if( ( aExtension.Search( '*' ) == STRING_NOTFOUND ) && |
| ( aExtension.Search( '?' ) == STRING_NOTFOUND ) ) |
| { |
| // OK, Filter hat Extension ohne Wildcards -> verwenden |
| aPostfix = aExtension; |
| } |
| else |
| { |
| // Filter hat Extension mit Wildcards (z.B. *.*) -> nicht verwenden |
| aPostfix.Erase(); |
| } |
| } |
| else |
| { |
| // Filter hatte keine Extension (schwer vorstellbar) -> nichts anhaengen |
| aPostfix.Erase(); |
| } |
| } |
| else |
| { |
| // kein Filter gefunden (merkw�rdig) -> Default-Extension anhaengen |
| aPostfix = GetFileDialog()->GetDefaultExt(); |
| } |
| |
| // jetzt kann es mit dem Anhaengen losgehen |
| const sal_Unicode* pExt = aPostfix.GetBuffer(); |
| while( *pExt == '*' || *pExt == '?' ) |
| pExt++; |
| |
| if( *pExt ) |
| { |
| UniString aName = aEntry.GetName(); |
| if( *pExt != '.' ) |
| aName += '.'; |
| aName += pExt; |
| aEntry.SetName( aName ); |
| } |
| } |
| return aEntry.GetFull(); |
| } |
| |
| |
| void ImpSvFileDlg::CreateDialog( PathDialog* pSvDlg, WinBits nStyle, RESOURCE_TYPE nType, sal_Bool bCreate ) |
| { |
| delete pDlg; |
| if ( nType == WINDOW_PATHDIALOG ) |
| pDlg = new ImpPathDialog( pSvDlg, nType, bCreate ); |
| else |
| pDlg = new ImpFileDialog( pSvDlg, nStyle, nType ); |
| } |
| |
| |