src/common/fldlgcmn.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        src/common/fldlgcmn.cpp
// Purpose:     wxFileDialog common functions
// Author:      John Labenski
// Modified by:
// Created:     14.06.03 (extracted from src/*/filedlg.cpp)
// RCS-ID:      $Id: fldlgcmn.cpp 47482 2007-07-15 14:12:08Z VS $
// Copyright:   (c) Robert Roebling
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __BORLANDC__
#pragma hdrstop
#endif

// For compilers that support precompilation, includes "wx.h".
#include "wx/wxprec.h"

#if wxUSE_FILEDLG

#include "wx/filedlg.h"
#include "wx/dirdlg.h"

#ifndef WX_PRECOMP
    #include "wx/string.h"
    #include "wx/intl.h"
    #include "wx/window.h"
#endif // WX_PRECOMP

//----------------------------------------------------------------------------
// wxFileDialogBase
//----------------------------------------------------------------------------

IMPLEMENT_DYNAMIC_CLASS(wxFileDialogBase, wxDialog)

void wxFileDialogBase::Init()
{
    m_filterIndex =
    m_windowStyle = 0;
}

bool wxFileDialogBase::Create(wxWindow *parent,
                              const wxString& message,
                              const wxString& defaultDir,
                              const wxString& defaultFile,
                              const wxString& wildCard,
                              long style,
                              const wxPoint& WXUNUSED(pos),
                              const wxSize& WXUNUSED(sz),
                              const wxString& WXUNUSED(name))
{
    m_message = message;
    m_dir = defaultDir;
    m_fileName = defaultFile;
    m_wildCard = wildCard;

    m_parent = parent;
    m_windowStyle = style;
    m_filterIndex = 0;

    if (!HasFdFlag(wxFD_OPEN) && !HasFdFlag(wxFD_SAVE))
        m_windowStyle |= wxFD_OPEN;     // wxFD_OPEN is the default

    // check that the styles are not contradictory
    wxASSERT_MSG( !(HasFdFlag(wxFD_SAVE) && HasFdFlag(wxFD_OPEN)),
                  _T("can't specify both wxFD_SAVE and wxFD_OPEN at once") );

    wxASSERT_MSG( !HasFdFlag(wxFD_SAVE) ||
                    (!HasFdFlag(wxFD_MULTIPLE) && !HasFdFlag(wxFD_FILE_MUST_EXIST)),
                   _T("wxFD_MULTIPLE or wxFD_FILE_MUST_EXIST can't be used with wxFD_SAVE" ) );

    wxASSERT_MSG( !HasFdFlag(wxFD_OPEN) || !HasFdFlag(wxFD_OVERWRITE_PROMPT),
                  _T("wxFD_OVERWRITE_PROMPT can't be used with wxFD_OPEN") );

    if ( wildCard.empty() || wildCard == wxFileSelectorDefaultWildcardStr )
    {
        m_wildCard = wxString::Format(_("All files (%s)|%s"),
                                      wxFileSelectorDefaultWildcardStr,
                                      wxFileSelectorDefaultWildcardStr);
    }
    else // have wild card
    {
        // convert m_wildCard from "*.bar" to "bar files (*.bar)|*.bar"
        if ( m_wildCard.Find(wxT('|')) == wxNOT_FOUND )
        {
            wxString::size_type nDot = m_wildCard.find(_T("*."));
            if ( nDot != wxString::npos )
                nDot++;
            else
                nDot = 0;

            m_wildCard = wxString::Format
                         (
                            _("%s files (%s)|%s"),
                            wildCard.c_str() + nDot,
                            wildCard.c_str(),
                            wildCard.c_str()
                         );
        }
    }

    return true;
}

#if WXWIN_COMPATIBILITY_2_4
// Parses the filterStr, returning the number of filters.
// Returns 0 if none or if there's a problem.
// filterStr is in the form: "All files (*.*)|*.*|JPEG Files (*.jpeg)|*.jpg"
int wxFileDialogBase::ParseWildcard(const wxString& filterStr,
                                    wxArrayString& descriptions,
                                    wxArrayString& filters)
{
    return ::wxParseCommonDialogsFilter(filterStr, descriptions, filters);
}
#endif // WXWIN_COMPATIBILITY_2_4

#if WXWIN_COMPATIBILITY_2_6
long wxFileDialogBase::GetStyle() const
{
    return GetWindowStyle();
}

void wxFileDialogBase::SetStyle(long style)
{
    SetWindowStyle(style);
}
#endif // WXWIN_COMPATIBILITY_2_6


wxString wxFileDialogBase::AppendExtension(const wxString &filePath,
                                           const wxString &extensionList)
{
    // strip off path, to avoid problems with "path.bar/foo"
    wxString fileName = filePath.AfterLast(wxFILE_SEP_PATH);

    // if fileName is of form "foo.bar" it's ok, return it
    int idx_dot = fileName.Find(wxT('.'), true);
    if ((idx_dot != wxNOT_FOUND) && (idx_dot < (int)fileName.length() - 1))
        return filePath;

    // get the first extension from extensionList, or all of it
    wxString ext = extensionList.BeforeFirst(wxT(';'));

    // if ext == "foo" or "foo." there's no extension
    int idx_ext_dot = ext.Find(wxT('.'), true);
    if ((idx_ext_dot == wxNOT_FOUND) || (idx_ext_dot == (int)ext.length() - 1))
        return filePath;
    else
        ext = ext.AfterLast(wxT('.'));

    // if ext == "*" or "bar*" or "b?r" or " " then its not valid
    if ((ext.Find(wxT('*')) != wxNOT_FOUND) ||
        (ext.Find(wxT('?')) != wxNOT_FOUND) ||
        (ext.Strip(wxString::both).empty()))
        return filePath;

    // if fileName doesn't have a '.' then add one
    if (filePath.Last() != wxT('.'))
        ext = wxT(".") + ext;

    return filePath + ext;
}

//----------------------------------------------------------------------------
// wxFileDialog convenience functions
//----------------------------------------------------------------------------

wxString wxFileSelector(const wxChar *title,
                               const wxChar *defaultDir,
                               const wxChar *defaultFileName,
                               const wxChar *defaultExtension,
                               const wxChar *filter,
                               int flags,
                               wxWindow *parent,
                               int x, int y)
{
    // The defaultExtension, if non-NULL, is
    // appended to the filename if the user fails to type an extension. The new
    // implementation (taken from wxFileSelectorEx) appends the extension
    // automatically, by looking at the filter specification. In fact this
    // should be better than the native Microsoft implementation because
    // Windows only allows *one* default extension, whereas here we do the
    // right thing depending on the filter the user has chosen.

    // If there's a default extension specified but no filter, we create a
    // suitable filter.

    wxString filter2;
    if ( !wxIsEmpty(defaultExtension) && wxIsEmpty(filter) )
        filter2 = wxString(wxT("*.")) + defaultExtension;
    else if ( !wxIsEmpty(filter) )
        filter2 = filter;

    wxString defaultDirString;
    if (!wxIsEmpty(defaultDir))
        defaultDirString = defaultDir;

    wxString defaultFilenameString;
    if (!wxIsEmpty(defaultFileName))
        defaultFilenameString = defaultFileName;

    wxFileDialog fileDialog(parent, title, defaultDirString,
                            defaultFilenameString, filter2,
                            flags, wxPoint(x, y));

   // if filter is of form "All files (*)|*|..." set correct filter index
    if((wxStrlen(defaultExtension) != 0) && (filter2.Find(wxT('|')) != wxNOT_FOUND))
    {
        int filterIndex = 0;

        wxArrayString descriptions, filters;
        // don't care about errors, handled already by wxFileDialog
        (void)wxParseCommonDialogsFilter(filter2, descriptions, filters);
        for (size_t n=0; n<filters.GetCount(); n++)
        {
            if (filters[n].Contains(defaultExtension))
            {
                filterIndex = n;
                        break;
            }
        }

        if (filterIndex > 0)
            fileDialog.SetFilterIndex(filterIndex);
    }

    wxString filename;
    if ( fileDialog.ShowModal() == wxID_OK )
    {
        filename = fileDialog.GetPath();
    }

    return filename;
}

//----------------------------------------------------------------------------
// wxFileSelectorEx
//----------------------------------------------------------------------------

wxString wxFileSelectorEx(const wxChar *title,
                          const wxChar *defaultDir,
                          const wxChar *defaultFileName,
                          int* defaultFilterIndex,
                          const wxChar *filter,
                          int       flags,
                          wxWindow* parent,
                          int       x,
                          int       y)

{
    wxFileDialog fileDialog(parent,
                            !wxIsEmpty(title) ? title : wxEmptyString,
                            !wxIsEmpty(defaultDir) ? defaultDir : wxEmptyString,
                            !wxIsEmpty(defaultFileName) ? defaultFileName : wxEmptyString,
                            !wxIsEmpty(filter) ? filter : wxEmptyString,
                            flags, wxPoint(x, y));

    wxString filename;
    if ( fileDialog.ShowModal() == wxID_OK )
    {
        if ( defaultFilterIndex )
            *defaultFilterIndex = fileDialog.GetFilterIndex();

        filename = fileDialog.GetPath();
    }

    return filename;
}

//----------------------------------------------------------------------------
// wxDefaultFileSelector - Generic load/save dialog (for internal use only)
//----------------------------------------------------------------------------

static wxString wxDefaultFileSelector(bool load,
                                      const wxChar *what,
                                      const wxChar *extension,
                                      const wxChar *default_name,
                                      wxWindow *parent)
{
    wxString prompt;
    wxString str;
    if (load)
        str = _("Load %s file");
    else
        str = _("Save %s file");
    prompt.Printf(str, what);

    wxString wild;
    const wxChar *ext = extension;
    if ( !wxIsEmpty(ext) )
    {
        if ( *ext == wxT('.') )
            ext++;

        wild.Printf(wxT("*.%s"), ext);
    }
    else // no extension specified
    {
        wild = wxFileSelectorDefaultWildcardStr;
    }

    return wxFileSelector(prompt, NULL, default_name, ext, wild,
                          load ? wxFD_OPEN : wxFD_SAVE, parent);
}

//----------------------------------------------------------------------------
// wxLoadFileSelector
//----------------------------------------------------------------------------

WXDLLEXPORT wxString wxLoadFileSelector(const wxChar *what,
                                        const wxChar *extension,
                                        const wxChar *default_name,
                                        wxWindow *parent)
{
    return wxDefaultFileSelector(true, what, extension, default_name, parent);
}

//----------------------------------------------------------------------------
// wxSaveFileSelector
//----------------------------------------------------------------------------

WXDLLEXPORT wxString wxSaveFileSelector(const wxChar *what,
                                        const wxChar *extension,
                                        const wxChar *default_name,
                                        wxWindow *parent)
{
    return wxDefaultFileSelector(false, what, extension, default_name, parent);
}


//----------------------------------------------------------------------------
// wxDirDialogBase
//----------------------------------------------------------------------------

#if WXWIN_COMPATIBILITY_2_6
long wxDirDialogBase::GetStyle() const
{
    return GetWindowStyle();
}

void wxDirDialogBase::SetStyle(long style)
{
    SetWindowStyle(style);
}
#endif // WXWIN_COMPATIBILITY_2_6


#endif // wxUSE_FILEDLG
1	william	31	/////////////////////////////////////////////////////////////////////////////
2			// Name: src/common/fldlgcmn.cpp
3			// Purpose: wxFileDialog common functions
4			// Author: John Labenski
5			// Modified by:
6			// Created: 14.06.03 (extracted from src/*/filedlg.cpp)
7			// RCS-ID: $Id: fldlgcmn.cpp 47482 2007-07-15 14:12:08Z VS $
8			// Copyright: (c) Robert Roebling
9			// Licence: wxWindows licence
10			/////////////////////////////////////////////////////////////////////////////
11
12			#ifdef __BORLANDC__
13			#pragma hdrstop
14			#endif
15
16			// For compilers that support precompilation, includes "wx.h".
17			#include "wx/wxprec.h"
18
19			#if wxUSE_FILEDLG
20
21			#include "wx/filedlg.h"
22			#include "wx/dirdlg.h"
23
24			#ifndef WX_PRECOMP
25			#include "wx/string.h"
26			#include "wx/intl.h"
27			#include "wx/window.h"
28			#endif // WX_PRECOMP
29
30			//----------------------------------------------------------------------------
31			// wxFileDialogBase
32			//----------------------------------------------------------------------------
33
34			IMPLEMENT_DYNAMIC_CLASS(wxFileDialogBase, wxDialog)
35
36			void wxFileDialogBase::Init()
37			{
38			m_filterIndex =
39			m_windowStyle = 0;
40			}
41
42			bool wxFileDialogBase::Create(wxWindow *parent,
43			const wxString& message,
44			const wxString& defaultDir,
45			const wxString& defaultFile,
46			const wxString& wildCard,
47			long style,
48			const wxPoint& WXUNUSED(pos),
49			const wxSize& WXUNUSED(sz),
50			const wxString& WXUNUSED(name))
51			{
52			m_message = message;
53			m_dir = defaultDir;
54			m_fileName = defaultFile;
55			m_wildCard = wildCard;
56
57			m_parent = parent;
58			m_windowStyle = style;
59			m_filterIndex = 0;
60
61			if (!HasFdFlag(wxFD_OPEN) && !HasFdFlag(wxFD_SAVE))
62			m_windowStyle \|= wxFD_OPEN; // wxFD_OPEN is the default
63
64			// check that the styles are not contradictory
65			wxASSERT_MSG( !(HasFdFlag(wxFD_SAVE) && HasFdFlag(wxFD_OPEN)),
66			_T("can't specify both wxFD_SAVE and wxFD_OPEN at once") );
67
68			wxASSERT_MSG( !HasFdFlag(wxFD_SAVE) \|\|
69			(!HasFdFlag(wxFD_MULTIPLE) && !HasFdFlag(wxFD_FILE_MUST_EXIST)),
70			_T("wxFD_MULTIPLE or wxFD_FILE_MUST_EXIST can't be used with wxFD_SAVE" ) );
71
72			wxASSERT_MSG( !HasFdFlag(wxFD_OPEN) \|\| !HasFdFlag(wxFD_OVERWRITE_PROMPT),
73			_T("wxFD_OVERWRITE_PROMPT can't be used with wxFD_OPEN") );
74
75			if ( wildCard.empty() \|\| wildCard == wxFileSelectorDefaultWildcardStr )
76			{
77			m_wildCard = wxString::Format(_("All files (%s)\|%s"),
78			wxFileSelectorDefaultWildcardStr,
79			wxFileSelectorDefaultWildcardStr);
80			}
81			else // have wild card
82			{
83			// convert m_wildCard from ".bar" to "bar files (.bar)\|*.bar"
84			if ( m_wildCard.Find(wxT('\|')) == wxNOT_FOUND )
85			{
86			wxString::size_type nDot = m_wildCard.find(_T("*."));
87			if ( nDot != wxString::npos )
88			nDot++;
89			else
90			nDot = 0;
91
92			m_wildCard = wxString::Format
93			(
94			_("%s files (%s)\|%s"),
95			wildCard.c_str() + nDot,
96			wildCard.c_str(),
97			wildCard.c_str()
98			);
99			}
100			}
101
102			return true;
103			}
104
105			#if WXWIN_COMPATIBILITY_2_4
106			// Parses the filterStr, returning the number of filters.
107			// Returns 0 if none or if there's a problem.
108			// filterStr is in the form: "All files (.)\|.\|JPEG Files (.jpeg)\|.jpg"
109			int wxFileDialogBase::ParseWildcard(const wxString& filterStr,
110			wxArrayString& descriptions,
111			wxArrayString& filters)
112			{
113			return ::wxParseCommonDialogsFilter(filterStr, descriptions, filters);
114			}
115			#endif // WXWIN_COMPATIBILITY_2_4
116
117			#if WXWIN_COMPATIBILITY_2_6
118			long wxFileDialogBase::GetStyle() const
119			{
120			return GetWindowStyle();
121			}
122
123			void wxFileDialogBase::SetStyle(long style)
124			{
125			SetWindowStyle(style);
126			}
127			#endif // WXWIN_COMPATIBILITY_2_6
128
129
130			wxString wxFileDialogBase::AppendExtension(const wxString &filePath,
131			const wxString &extensionList)
132			{
133			// strip off path, to avoid problems with "path.bar/foo"
134			wxString fileName = filePath.AfterLast(wxFILE_SEP_PATH);
135
136			// if fileName is of form "foo.bar" it's ok, return it
137			int idx_dot = fileName.Find(wxT('.'), true);
138			if ((idx_dot != wxNOT_FOUND) && (idx_dot < (int)fileName.length() - 1))
139			return filePath;
140
141			// get the first extension from extensionList, or all of it
142			wxString ext = extensionList.BeforeFirst(wxT(';'));
143
144			// if ext == "foo" or "foo." there's no extension
145			int idx_ext_dot = ext.Find(wxT('.'), true);
146			if ((idx_ext_dot == wxNOT_FOUND) \|\| (idx_ext_dot == (int)ext.length() - 1))
147			return filePath;
148			else
149			ext = ext.AfterLast(wxT('.'));
150
151			// if ext == "" or "bar" or "b?r" or " " then its not valid
152			if ((ext.Find(wxT('*')) != wxNOT_FOUND) \|\|
153			(ext.Find(wxT('?')) != wxNOT_FOUND) \|\|
154			(ext.Strip(wxString::both).empty()))
155			return filePath;
156
157			// if fileName doesn't have a '.' then add one
158			if (filePath.Last() != wxT('.'))
159			ext = wxT(".") + ext;
160
161			return filePath + ext;
162			}
163
164			//----------------------------------------------------------------------------
165			// wxFileDialog convenience functions
166			//----------------------------------------------------------------------------
167
168			wxString wxFileSelector(const wxChar *title,
169			const wxChar *defaultDir,
170			const wxChar *defaultFileName,
171			const wxChar *defaultExtension,
172			const wxChar *filter,
173			int flags,
174			wxWindow *parent,
175			int x, int y)
176			{
177			// The defaultExtension, if non-NULL, is
178			// appended to the filename if the user fails to type an extension. The new
179			// implementation (taken from wxFileSelectorEx) appends the extension
180			// automatically, by looking at the filter specification. In fact this
181			// should be better than the native Microsoft implementation because
182			// Windows only allows one default extension, whereas here we do the
183			// right thing depending on the filter the user has chosen.
184
185			// If there's a default extension specified but no filter, we create a
186			// suitable filter.
187
188			wxString filter2;
189			if ( !wxIsEmpty(defaultExtension) && wxIsEmpty(filter) )
190			filter2 = wxString(wxT("*.")) + defaultExtension;
191			else if ( !wxIsEmpty(filter) )
192			filter2 = filter;
193
194			wxString defaultDirString;
195			if (!wxIsEmpty(defaultDir))
196			defaultDirString = defaultDir;
197
198			wxString defaultFilenameString;
199			if (!wxIsEmpty(defaultFileName))
200			defaultFilenameString = defaultFileName;
201
202			wxFileDialog fileDialog(parent, title, defaultDirString,
203			defaultFilenameString, filter2,
204			flags, wxPoint(x, y));
205
206			// if filter is of form "All files ()\|\|..." set correct filter index
207			if((wxStrlen(defaultExtension) != 0) && (filter2.Find(wxT('\|')) != wxNOT_FOUND))
208			{
209			int filterIndex = 0;
210
211			wxArrayString descriptions, filters;
212			// don't care about errors, handled already by wxFileDialog
213			(void)wxParseCommonDialogsFilter(filter2, descriptions, filters);
214			for (size_t n=0; n<filters.GetCount(); n++)
215			{
216			if (filters[n].Contains(defaultExtension))
217			{
218			filterIndex = n;
219			break;
220			}
221			}
222
223			if (filterIndex > 0)
224			fileDialog.SetFilterIndex(filterIndex);
225			}
226
227			wxString filename;
228			if ( fileDialog.ShowModal() == wxID_OK )
229			{
230			filename = fileDialog.GetPath();
231			}
232
233			return filename;
234			}
235
236			//----------------------------------------------------------------------------
237			// wxFileSelectorEx
238			//----------------------------------------------------------------------------
239
240			wxString wxFileSelectorEx(const wxChar *title,
241			const wxChar *defaultDir,
242			const wxChar *defaultFileName,
243			int* defaultFilterIndex,
244			const wxChar *filter,
245			int flags,
246			wxWindow* parent,
247			int x,
248			int y)
249
250			{
251			wxFileDialog fileDialog(parent,
252			!wxIsEmpty(title) ? title : wxEmptyString,
253			!wxIsEmpty(defaultDir) ? defaultDir : wxEmptyString,
254			!wxIsEmpty(defaultFileName) ? defaultFileName : wxEmptyString,
255			!wxIsEmpty(filter) ? filter : wxEmptyString,
256			flags, wxPoint(x, y));
257
258			wxString filename;
259			if ( fileDialog.ShowModal() == wxID_OK )
260			{
261			if ( defaultFilterIndex )
262			*defaultFilterIndex = fileDialog.GetFilterIndex();
263
264			filename = fileDialog.GetPath();
265			}
266
267			return filename;
268			}
269
270			//----------------------------------------------------------------------------
271			// wxDefaultFileSelector - Generic load/save dialog (for internal use only)
272			//----------------------------------------------------------------------------
273
274			static wxString wxDefaultFileSelector(bool load,
275			const wxChar *what,
276			const wxChar *extension,
277			const wxChar *default_name,
278			wxWindow *parent)
279			{
280			wxString prompt;
281			wxString str;
282			if (load)
283			str = _("Load %s file");
284			else
285			str = _("Save %s file");
286			prompt.Printf(str, what);
287
288			wxString wild;
289			const wxChar *ext = extension;
290			if ( !wxIsEmpty(ext) )
291			{
292			if ( *ext == wxT('.') )
293			ext++;
294
295			wild.Printf(wxT("*.%s"), ext);
296			}
297			else // no extension specified
298			{
299			wild = wxFileSelectorDefaultWildcardStr;
300			}
301
302			return wxFileSelector(prompt, NULL, default_name, ext, wild,
303			load ? wxFD_OPEN : wxFD_SAVE, parent);
304			}
305
306			//----------------------------------------------------------------------------
307			// wxLoadFileSelector
308			//----------------------------------------------------------------------------
309
310			WXDLLEXPORT wxString wxLoadFileSelector(const wxChar *what,
311			const wxChar *extension,
312			const wxChar *default_name,
313			wxWindow *parent)
314			{
315			return wxDefaultFileSelector(true, what, extension, default_name, parent);
316			}
317
318			//----------------------------------------------------------------------------
319			// wxSaveFileSelector
320			//----------------------------------------------------------------------------
321
322			WXDLLEXPORT wxString wxSaveFileSelector(const wxChar *what,
323			const wxChar *extension,
324			const wxChar *default_name,
325			wxWindow *parent)
326			{
327			return wxDefaultFileSelector(false, what, extension, default_name, parent);
328			}
329
330
331			//----------------------------------------------------------------------------
332			// wxDirDialogBase
333			//----------------------------------------------------------------------------
334
335			#if WXWIN_COMPATIBILITY_2_6
336			long wxDirDialogBase::GetStyle() const
337			{
338			return GetWindowStyle();
339			}
340
341			void wxDirDialogBase::SetStyle(long style)
342			{
343			SetWindowStyle(style);
344			}
345			#endif // WXWIN_COMPATIBILITY_2_6
346
347
348			#endif // wxUSE_FILEDLG