src/os2/filedlg.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        filedlg.cpp
// Purpose:     wxFileDialog
// Author:      David Webster
// Modified by:
// Created:     10/05/99
// RCS-ID:      $Id$
// Copyright:   (c) David Webster
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

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

#ifdef __BORLANDC__
    #pragma hdrstop
#endif

#ifndef WX_PRECOMP
    #include "wx/utils.h"
    #include "wx/msgdlg.h"
    #include "wx/dialog.h"
    #include "wx/filedlg.h"
    #include "wx/intl.h"
    #include "wx/log.h"
    #include "wx/app.h"
#endif

#define INCL_PM
#include <os2.h>

#include "wx/os2/private.h"

#include <math.h>
#include <stdlib.h>
#include <string.h>

#include "wx/tokenzr.h"

#define wxMAXPATH                    1024
#define wxMAXFILE                    1024
#define wxMAXEXT                        5

#ifndef MAXPATH
# define MAXPATH                      400
#endif

#ifndef MAXDRIVE
# define MAXDRIVE                       3
#endif

#ifndef MAXFILE
# define MAXFILE                        9
#endif

#ifndef MAXEXT
# define MAXEXT                         5
#endif
IMPLEMENT_CLASS(wxFileDialog, wxDialog)

// ----------------------------------------------------------------------------
// global functions
// ----------------------------------------------------------------------------

wxString wxFileSelector(
  const char*                       pzTitle
, const char*                       pzDefaultDir
, const char*                       pzDefaultFileName
, const char*                       pzDefaultExtension
, const char*                       pzFilter
, int                               nFlags
, wxWindow*                         pParent
, int                               nX
, int                               nY
)
{
    wxString                        sFilter("");
    wxString                        sDefaultDirString;
    wxString                        sDefaultFilenameString;

    //
    // If there's a default extension specified but no filter, we create
    // a suitable filter.
    //
    if (pzDefaultExtension && !pzFilter)
        sFilter = wxString("*.") + wxString(pzDefaultExtension);
    else if (pzFilter)
        sFilter = pzFilter;

    if (pzDefaultDir)
        sDefaultDirString = pzDefaultDir;
    else
        sDefaultDirString = "";

    if (pzDefaultFileName)
        sDefaultFilenameString = pzDefaultFileName;
    else
        sDefaultFilenameString = "";

    wxFileDialog                    vFileDialog( pParent
                                                ,pzTitle
                                                ,sDefaultDirString
                                                ,sDefaultFilenameString
                                                ,sFilter
                                                ,nFlags
                                                ,wxPoint(nX, nY)
                                               );

    if (wxStrlen(pzDefaultExtension) != 0)
    {
        int                         nFilterFind = 0;
        int                         nFilterIndex = 0;

        for (unsigned int i = 0; i < sFilter.Len(); i++)
        {
            if (sFilter.GetChar(i) == wxT('|'))
            {
                //
                // Save the start index of the new filter
                unsigned int        uIs = i++;

                //
                // Find the end of the filter
                //
                for(; i < sFilter.Len(); i++)
                {
                    if(sFilter[i] == wxT('|'))
                        break;
                }

                if( i - uIs - 1 > 0 && uIs + 1 < sFilter.Len() )
                {
                    if(sFilter.Mid(uIs + 1, i - uIs - 1).Contains(pzDefaultExtension))
                    {
                        nFilterFind = nFilterIndex;
                        break;
                    }
                }
                nFilterIndex++;
            }
        }
        vFileDialog.SetFilterIndex(nFilterFind);
    }
    if (vFileDialog.ShowModal() == wxID_OK)
    {
        return vFileDialog.GetPath();
    }
    else
        return wxEmptyString;
} // end of wxFileSelector

wxString wxFileSelectorEx (
  const char*                       pzTitle
, const char*                       pzDefaultDir
, const char*                       pzDefaultFileName
, int*                              pnDefaultFilterIndex
, const char*                       pzFilter
, int                               nFlags
, wxWindow*                         pParent
, int                               nX
, int                               nY
)
{
    wxFileDialog                    vFileDialog( pParent
                                                ,pzTitle ? pzTitle : ""
                                                ,pzDefaultDir ? pzDefaultDir : ""
                                                ,pzDefaultFileName ? pzDefaultFileName : ""
                                                ,pzFilter ? pzFilter : ""
                                                ,nFlags
                                                ,wxPoint(nX, nY)
                                               );

    if (vFileDialog.ShowModal() == wxID_OK)
    {
        *pnDefaultFilterIndex = vFileDialog.GetFilterIndex();
        return vFileDialog.GetPath();
    }
    else
        return wxEmptyString;
} // end of wxFileSelectorEx

// ----------------------------------------------------------------------------
// CLASS wxFileDialog
// ----------------------------------------------------------------------------

wxFileDialog::wxFileDialog (
  wxWindow*                         pParent
, const wxString&                   rsMessage
, const wxString&                   rsDefaultDir
, const wxString&                   rsDefaultFileName
, const wxString&                   rsWildCard
, long                              lStyle
, const wxPoint&                    rPos
)
{
    m_sMessage     = rsMessage;
    m_lDialogStyle = lStyle;
    if ((m_lDialogStyle & wxMULTIPLE) && (m_lDialogStyle & wxSAVE))
        m_lDialogStyle &= ~wxMULTIPLE;
    m_pParent      = pParent;
    m_sPath        = "";
    m_sFileName    = rsDefaultFileName;
    m_sDir         = rsDefaultDir;
    m_sWildCard    = rsWildCard;
    m_nFilterIndex = 1;
    m_vPos         = rPos;
} // end of wxFileDialog::wxFileDialog

void wxFileDialog::GetPaths (
  wxArrayString&                    rasPaths
) const
{
    wxString                        sDir(m_sDir);
    size_t                          nCount = m_asFileNames.GetCount();

    rasPaths.Empty();
    if (m_sDir.Last() != _T('\\'))
        sDir += _T('\\');

    for ( size_t n = 0; n < nCount; n++ )
    {
        rasPaths.Add(sDir + m_asFileNames[n]);
    }
} // end of wxFileDialog::GetPaths

int wxFileDialog::ShowModal()
{
    wxString                        sTheFilter;
    wxString                        sFilterBuffer;
    wxChar*                         pzFilterBuffer;
    static wxChar                   zFileNameBuffer[wxMAXPATH];           // the file-name
    HWND                            hWnd = 0;
    wxChar                          zTitleBuffer[wxMAXFILE + 1 + wxMAXEXT];  // the file-name, without path
    wxString                        sDir;
    size_t                          i;
    size_t                          nLen = m_sDir.length();
    int                             nCount = 0;
    FILEDLG                         vFileDlg;
    ULONG                           lFlags = 0L;

    memset(&vFileDlg, '\0', sizeof(FILEDLG));
    if (m_pParent)
        hWnd = (HWND) m_pParent->GetHWND();
    if (!hWnd && wxTheApp->GetTopWindow())
        hWnd = (HWND) wxTheApp->GetTopWindow()->GetHWND();


    *zFileNameBuffer = wxT('\0');
    *zTitleBuffer    = wxT('\0');

    if (m_lDialogStyle & wxSAVE)
        lFlags = FDS_SAVEAS_DIALOG;
    else
        lFlags = FDS_OPEN_DIALOG;

    if ((m_lDialogStyle & wxHIDE_READONLY) || (m_lDialogStyle & wxSAVE))
        lFlags |= FDS_SAVEAS_DIALOG;
    if (m_lDialogStyle & wxMULTIPLE )
        lFlags |= FDS_OPEN_DIALOG | FDS_MULTIPLESEL;

    vFileDlg.cbSize = sizeof(FILEDLG);
    vFileDlg.fl = lFlags;
    vFileDlg.pszTitle = zTitleBuffer;

    //
    // Convert forward slashes to backslashes (file selector doesn't like
    // forward slashes) and also squeeze multiple consecutive slashes into one
    // as it doesn't like two backslashes in a row neither
    //
    sDir.reserve(nLen);
    for ( i = 0; i < nLen; i++ )
    {
        wxChar                      ch = m_sDir[i];

        switch (ch)
        {
            case _T('/'):
                //
                // Convert to backslash
                //
                ch = _T('\\');

                //
                // Fall through
                //
            case _T('\\'):
                while (i < nLen - 1)
                {
                    wxChar          chNext = m_sDir[i + 1];

                    if (chNext != _T('\\') && chNext != _T('/'))
                        break;

                    //
                    // Ignore the next one, unless it is at the start of a UNC path
                    //
                    if (i > 0)
                        i++;
                    else
                        break;
                }

                //
                // Fall through
                //

            default:
                //
                // Normal char
                sDir += ch;
        }
    }
    if ( wxStrlen(m_sWildCard) == 0 )
        sTheFilter = "";
    else
        sTheFilter = m_sWildCard;

    pzFilterBuffer = strtok((char*)sTheFilter.c_str(), "|");
    while(pzFilterBuffer != NULL)
    {
        if (nCount > 0 && !(nCount % 2))
            sDir += wxT(";");
        if (nCount % 2)
        {
            sDir += pzFilterBuffer;
        }
        pzFilterBuffer = strtok(NULL, "|");
        nCount++;
    }
    if (nCount == 0)
        sDir += m_sFileName;
    if (sDir.IsEmpty())
        sDir = "*.*";
    wxStrcpy(vFileDlg.szFullFile, sDir.c_str());
    sFilterBuffer = sDir;

    hWnd = ::WinFileDlg( HWND_DESKTOP
                        ,GetHwndOf(m_pParent)
                        ,&vFileDlg
                       );
    if (hWnd && vFileDlg.lReturn == DID_OK)
    {
        m_asFileNames.Empty();
        if ((m_lDialogStyle & wxMULTIPLE ) && vFileDlg.ulFQFCount > 1)
        {
            for (int i = 0; i < vFileDlg.ulFQFCount; i++)
            {
                if (i == 0)
                {
                    m_sDir = wxPathOnly(wxString((const char*)*vFileDlg.papszFQFilename[0]));
                    m_sPath = (const char*)*vFileDlg.papszFQFilename[0];
                }
                m_sFileName = wxFileNameFromPath(wxString((const char*)*vFileDlg.papszFQFilename[i]));
                m_asFileNames.Add(m_sFileName);
            }
            ::WinFreeFileDlgList(vFileDlg.papszFQFilename);
        }
        else if (!(m_lDialogStyle & wxSAVE))
        {
            m_sPath = vFileDlg.szFullFile;
            m_sFileName = wxFileNameFromPath(vFileDlg.szFullFile);
            m_sDir = wxPathOnly(vFileDlg.szFullFile);
        }
        else // save file
        {
            const wxChar*           pzExtension = NULL;

            wxStrcpy(zFileNameBuffer, vFileDlg.szFullFile);

            int                     nIdx = wxStrlen(zFileNameBuffer) - 1;
            wxString                sExt;

            wxSplitPath( zFileNameBuffer
                        ,&m_sPath
                        ,&m_sFileName
                        ,&sExt
                       );
            if (zFileNameBuffer[nIdx] == wxT('.') || sExt.IsEmpty())
            {
                zFileNameBuffer[nIdx] = wxT('\0');

                //
                // User has typed a filename without an extension:
                //
                // A filename can end in a "." here ("abc."), this means it
                // does not have an extension. Because later on a "." with
                // the default extension is appended we remove the "." if
                // filename ends with one (We don't want files called
                // "abc..ext")
                //
                pzExtension = sFilterBuffer.c_str();

                for( int i = 0; i < sFilterBuffer.length(); i++ )
                {
                    //
                    // Get extension
                    //
                    pzExtension = wxStrrchr(pzExtension, wxT('.'));
                    if ( pzExtension                      &&
                        !wxStrrchr(pzExtension, wxT('*')) &&
                        !wxStrrchr(pzExtension, wxT('?')) &&
                        pzExtension[1]                    &&
                        pzExtension[1] != wxT(' ')
                       )              // != "blabla. "
                    {
                        //
                        // Now concat extension to the fileName:
                        //
                        m_sPath = wxString(zFileNameBuffer) + pzExtension;
                    }
                }
            }
            else
            {
                m_sPath = vFileDlg.szFullFile;
            }
            m_sFileName = wxFileNameFromPath(vFileDlg.szFullFile);
            m_sDir = wxPathOnly(vFileDlg.szFullFile);

            //
            // === Simulating the wxOVERWRITE_PROMPT >>============================
            //
            if ((m_lDialogStyle & wxOVERWRITE_PROMPT) &&
                (m_lDialogStyle & wxSAVE) &&
                (wxFileExists(m_sPath.c_str())))
            {
                wxString            sMessageText;

                sMessageText.Printf( _("File '%s' already exists.\nDo you want to replace it?")
                                    ,m_sPath.c_str()
                                   );
                if (wxMessageBox( sMessageText
                                 ,wxT("Save File As")
                                 ,wxYES_NO | wxICON_EXCLAMATION
                                ) != wxYES)
                {
                    return wxID_CANCEL;
                }
            }
        }
        return wxID_OK;
    }
    return wxID_CANCEL;
} // end of wxFileDialog::ShowModal

//
// Generic file load/save dialog
//
static wxString wxDefaultFileSelector (
  bool                              bLoad
, const char*                       pzWhat
, const char*                       pzExtension
, const char*                       pzDefaultName
, wxWindow*                         pParent
)
{
    char*                           pzExt = (char *)pzExtension;
    char                            zPrompt[50];
    wxString                        sStr;
    char                            zWild[60];

    if (bLoad)
        sStr = "Load %s file";
    else
        sStr = "Save %s file";
    sprintf(zPrompt, wxGetTranslation(sStr), pzWhat);

    if (*pzExt == '.')
        pzExt++;
    sprintf(zWild, "*.%s", pzExt);
    return wxFileSelector ( zPrompt
                           ,NULL
                           ,pzDefaultName
                           ,pzExt
                           ,zWild
                           ,0
                           ,pParent
                          );
} // end of wxDefaultFileSelector

//
// Generic file load dialog
//
wxString wxLoadFileSelector (
  const char*                       pzWhat
, const char*                       pzExtension
, const char*                       pzDefaultName
, wxWindow*                         pParent
)
{
    return wxDefaultFileSelector( TRUE
                                 ,pzWhat
                                 ,pzExtension
                                 ,pzDefaultName
                                 ,pParent
                                );
} // end of wxLoadFileSelector


//
// Generic file save dialog
//
wxString wxSaveFileSelector (
  const char*                       pzWhat
, const char*                       pzExtension
, const char*                       pzDefaultName
, wxWindow*                         pParent
)
{
    return wxDefaultFileSelector( FALSE
                                 ,pzWhat
                                 ,pzExtension
                                 ,pzDefaultName
                                 ,pParent
                                );
} // end of wxSaveFileSelector
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: filedlg.cpp
	3	// Purpose: wxFileDialog
	4	// Author: David Webster
	5	// Modified by:
	6	// Created: 10/05/99
	7	// RCS-ID: $Id$
	8	// Copyright: (c) David Webster
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	// For compilers that support precompilation, includes "wx.h".
	13	#include "wx/wxprec.h"
	14
	15	#ifdef __BORLANDC__
	16	#pragma hdrstop
	17	#endif
	18
	19	#ifndef WX_PRECOMP
	20	#include "wx/utils.h"
	21	#include "wx/msgdlg.h"
	22	#include "wx/dialog.h"
	23	#include "wx/filedlg.h"
	24	#include "wx/intl.h"
	25	#include "wx/log.h"
	26	#include "wx/app.h"
	27	#endif
	28
	29	#define INCL_PM
	30	#include <os2.h>
	31
	32	#include "wx/os2/private.h"
	33
	34	#include <math.h>
	35	#include <stdlib.h>
	36	#include <string.h>
	37
	38	#include "wx/tokenzr.h"
	39
	40	#define wxMAXPATH 1024
	41	#define wxMAXFILE 1024
	42	#define wxMAXEXT 5
	43
	44	#ifndef MAXPATH
	45	# define MAXPATH 400
	46	#endif
	47
	48	#ifndef MAXDRIVE
	49	# define MAXDRIVE 3
	50	#endif
	51
	52	#ifndef MAXFILE
	53	# define MAXFILE 9
	54	#endif
	55
	56	#ifndef MAXEXT
	57	# define MAXEXT 5
	58	#endif
	59	IMPLEMENT_CLASS(wxFileDialog, wxDialog)
	60
	61	// ----------------------------------------------------------------------------
	62	// global functions
	63	// ----------------------------------------------------------------------------
	64
	65	wxString wxFileSelector(
	66	const char* pzTitle
	67	, const char* pzDefaultDir
	68	, const char* pzDefaultFileName
	69	, const char* pzDefaultExtension
	70	, const char* pzFilter
	71	, int nFlags
	72	, wxWindow* pParent
	73	, int nX
	74	, int nY
	75	)
	76	{
	77	wxString sFilter("");
	78	wxString sDefaultDirString;
	79	wxString sDefaultFilenameString;
	80
	81	//
	82	// If there's a default extension specified but no filter, we create
	83	// a suitable filter.
	84	//
	85	if (pzDefaultExtension && !pzFilter)
	86	sFilter = wxString("*.") + wxString(pzDefaultExtension);
	87	else if (pzFilter)
	88	sFilter = pzFilter;
	89
	90	if (pzDefaultDir)
	91	sDefaultDirString = pzDefaultDir;
	92	else
	93	sDefaultDirString = "";
	94
	95	if (pzDefaultFileName)
	96	sDefaultFilenameString = pzDefaultFileName;
	97	else
	98	sDefaultFilenameString = "";
	99
	100	wxFileDialog vFileDialog( pParent
	101	,pzTitle
	102	,sDefaultDirString
	103	,sDefaultFilenameString
	104	,sFilter
	105	,nFlags
	106	,wxPoint(nX, nY)
	107	);
	108
	109	if (wxStrlen(pzDefaultExtension) != 0)
	110	{
	111	int nFilterFind = 0;
	112	int nFilterIndex = 0;
	113
	114	for (unsigned int i = 0; i < sFilter.Len(); i++)
	115	{
	116	if (sFilter.GetChar(i) == wxT('\|'))
	117	{
	118	//
	119	// Save the start index of the new filter
	120	unsigned int uIs = i++;
	121
	122	//
	123	// Find the end of the filter
	124	//
	125	for(; i < sFilter.Len(); i++)
	126	{
	127	if(sFilter[i] == wxT('\|'))
	128	break;
	129	}
	130
	131	if( i - uIs - 1 > 0 && uIs + 1 < sFilter.Len() )
	132	{
	133	if(sFilter.Mid(uIs + 1, i - uIs - 1).Contains(pzDefaultExtension))
	134	{
	135	nFilterFind = nFilterIndex;
	136	break;
	137	}
	138	}
	139	nFilterIndex++;
	140	}
	141	}
	142	vFileDialog.SetFilterIndex(nFilterFind);
	143	}
	144	if (vFileDialog.ShowModal() == wxID_OK)
	145	{
	146	return vFileDialog.GetPath();
	147	}
	148	else
	149	return wxEmptyString;
	150	} // end of wxFileSelector
	151
	152	wxString wxFileSelectorEx (
	153	const char* pzTitle
	154	, const char* pzDefaultDir
	155	, const char* pzDefaultFileName
	156	, int* pnDefaultFilterIndex
	157	, const char* pzFilter
	158	, int nFlags
	159	, wxWindow* pParent
	160	, int nX
	161	, int nY
	162	)
	163	{
	164	wxFileDialog vFileDialog( pParent
	165	,pzTitle ? pzTitle : ""
	166	,pzDefaultDir ? pzDefaultDir : ""
	167	,pzDefaultFileName ? pzDefaultFileName : ""
	168	,pzFilter ? pzFilter : ""
	169	,nFlags
	170	,wxPoint(nX, nY)
	171	);
	172
	173	if (vFileDialog.ShowModal() == wxID_OK)
	174	{
	175	*pnDefaultFilterIndex = vFileDialog.GetFilterIndex();
	176	return vFileDialog.GetPath();
	177	}
	178	else
	179	return wxEmptyString;
	180	} // end of wxFileSelectorEx
	181
	182	// ----------------------------------------------------------------------------
	183	// CLASS wxFileDialog
	184	// ----------------------------------------------------------------------------
	185
	186	wxFileDialog::wxFileDialog (
	187	wxWindow* pParent
	188	, const wxString& rsMessage
	189	, const wxString& rsDefaultDir
	190	, const wxString& rsDefaultFileName
	191	, const wxString& rsWildCard
	192	, long lStyle
	193	, const wxPoint& rPos
	194	)
	195	{
	196	m_sMessage = rsMessage;
	197	m_lDialogStyle = lStyle;
	198	if ((m_lDialogStyle & wxMULTIPLE) && (m_lDialogStyle & wxSAVE))
	199	m_lDialogStyle &= ~wxMULTIPLE;
	200	m_pParent = pParent;
	201	m_sPath = "";
	202	m_sFileName = rsDefaultFileName;
	203	m_sDir = rsDefaultDir;
	204	m_sWildCard = rsWildCard;
	205	m_nFilterIndex = 1;
	206	m_vPos = rPos;
	207	} // end of wxFileDialog::wxFileDialog
	208
	209	void wxFileDialog::GetPaths (
	210	wxArrayString& rasPaths
	211	) const
	212	{
	213	wxString sDir(m_sDir);
	214	size_t nCount = m_asFileNames.GetCount();
	215
	216	rasPaths.Empty();
	217	if (m_sDir.Last() != _T('\\'))
	218	sDir += _T('\\');
	219
	220	for ( size_t n = 0; n < nCount; n++ )
	221	{
	222	rasPaths.Add(sDir + m_asFileNames[n]);
	223	}
	224	} // end of wxFileDialog::GetPaths
	225
	226	int wxFileDialog::ShowModal()
	227	{
	228	wxString sTheFilter;
	229	wxString sFilterBuffer;
	230	wxChar* pzFilterBuffer;
	231	static wxChar zFileNameBuffer[wxMAXPATH]; // the file-name
	232	HWND hWnd = 0;
	233	wxChar zTitleBuffer[wxMAXFILE + 1 + wxMAXEXT]; // the file-name, without path
	234	wxString sDir;
	235	size_t i;
	236	size_t nLen = m_sDir.length();
	237	int nCount = 0;
	238	FILEDLG vFileDlg;
	239	ULONG lFlags = 0L;
	240
	241	memset(&vFileDlg, '\0', sizeof(FILEDLG));
	242	if (m_pParent)
	243	hWnd = (HWND) m_pParent->GetHWND();
	244	if (!hWnd && wxTheApp->GetTopWindow())
	245	hWnd = (HWND) wxTheApp->GetTopWindow()->GetHWND();
	246
	247
	248	*zFileNameBuffer = wxT('\0');
	249	*zTitleBuffer = wxT('\0');
	250
	251	if (m_lDialogStyle & wxSAVE)
	252	lFlags = FDS_SAVEAS_DIALOG;
	253	else
	254	lFlags = FDS_OPEN_DIALOG;
	255
	256	if ((m_lDialogStyle & wxHIDE_READONLY) \|\| (m_lDialogStyle & wxSAVE))
	257	lFlags \|= FDS_SAVEAS_DIALOG;
	258	if (m_lDialogStyle & wxMULTIPLE )
	259	lFlags \|= FDS_OPEN_DIALOG \| FDS_MULTIPLESEL;
	260
	261	vFileDlg.cbSize = sizeof(FILEDLG);
	262	vFileDlg.fl = lFlags;
	263	vFileDlg.pszTitle = zTitleBuffer;
	264
	265	//
	266	// Convert forward slashes to backslashes (file selector doesn't like
	267	// forward slashes) and also squeeze multiple consecutive slashes into one
	268	// as it doesn't like two backslashes in a row neither
	269	//
	270	sDir.reserve(nLen);
	271	for ( i = 0; i < nLen; i++ )
	272	{
	273	wxChar ch = m_sDir[i];
	274
	275	switch (ch)
	276	{
	277	case _T('/'):
	278	//
	279	// Convert to backslash
	280	//
	281	ch = _T('\\');
	282
	283	//
	284	// Fall through
	285	//
	286	case _T('\\'):
	287	while (i < nLen - 1)
	288	{
	289	wxChar chNext = m_sDir[i + 1];
	290
	291	if (chNext != _T('\\') && chNext != _T('/'))
	292	break;
	293
	294	//
	295	// Ignore the next one, unless it is at the start of a UNC path
	296	//
	297	if (i > 0)
	298	i++;
	299	else
	300	break;
	301	}
	302
	303	//
	304	// Fall through
	305	//
	306
	307	default:
	308	//
	309	// Normal char
	310	sDir += ch;
	311	}
	312	}
	313	if ( wxStrlen(m_sWildCard) == 0 )
	314	sTheFilter = "";
	315	else
	316	sTheFilter = m_sWildCard;
	317
	318	pzFilterBuffer = strtok((char*)sTheFilter.c_str(), "\|");
	319	while(pzFilterBuffer != NULL)
	320	{
	321	if (nCount > 0 && !(nCount % 2))
	322	sDir += wxT(";");
	323	if (nCount % 2)
	324	{
	325	sDir += pzFilterBuffer;
	326	}
	327	pzFilterBuffer = strtok(NULL, "\|");
	328	nCount++;
	329	}
	330	if (nCount == 0)
	331	sDir += m_sFileName;
	332	if (sDir.IsEmpty())
	333	sDir = ".";
	334	wxStrcpy(vFileDlg.szFullFile, sDir.c_str());
	335	sFilterBuffer = sDir;
	336
	337	hWnd = ::WinFileDlg( HWND_DESKTOP
	338	,GetHwndOf(m_pParent)
	339	,&vFileDlg
	340	);
	341	if (hWnd && vFileDlg.lReturn == DID_OK)
	342	{
	343	m_asFileNames.Empty();
	344	if ((m_lDialogStyle & wxMULTIPLE ) && vFileDlg.ulFQFCount > 1)
	345	{
	346	for (int i = 0; i < vFileDlg.ulFQFCount; i++)
	347	{
	348	if (i == 0)
	349	{
	350	m_sDir = wxPathOnly(wxString((const char)vFileDlg.papszFQFilename[0]));
	351	m_sPath = (const char)vFileDlg.papszFQFilename[0];
	352	}
	353	m_sFileName = wxFileNameFromPath(wxString((const char)vFileDlg.papszFQFilename[i]));
	354	m_asFileNames.Add(m_sFileName);
	355	}
	356	::WinFreeFileDlgList(vFileDlg.papszFQFilename);
	357	}
	358	else if (!(m_lDialogStyle & wxSAVE))
	359	{
	360	m_sPath = vFileDlg.szFullFile;
	361	m_sFileName = wxFileNameFromPath(vFileDlg.szFullFile);
	362	m_sDir = wxPathOnly(vFileDlg.szFullFile);
	363	}
	364	else // save file
	365	{
	366	const wxChar* pzExtension = NULL;
	367
	368	wxStrcpy(zFileNameBuffer, vFileDlg.szFullFile);
	369
	370	int nIdx = wxStrlen(zFileNameBuffer) - 1;
	371	wxString sExt;
	372
	373	wxSplitPath( zFileNameBuffer
	374	,&m_sPath
	375	,&m_sFileName
	376	,&sExt
	377	);
	378	if (zFileNameBuffer[nIdx] == wxT('.') \|\| sExt.IsEmpty())
	379	{
	380	zFileNameBuffer[nIdx] = wxT('\0');
	381
	382	//
	383	// User has typed a filename without an extension:
	384	//
	385	// A filename can end in a "." here ("abc."), this means it
	386	// does not have an extension. Because later on a "." with
	387	// the default extension is appended we remove the "." if
	388	// filename ends with one (We don't want files called
	389	// "abc..ext")
	390	//
	391	pzExtension = sFilterBuffer.c_str();
	392
	393	for( int i = 0; i < sFilterBuffer.length(); i++ )
	394	{
	395	//
	396	// Get extension
	397	//
	398	pzExtension = wxStrrchr(pzExtension, wxT('.'));
	399	if ( pzExtension &&
	400	!wxStrrchr(pzExtension, wxT('*')) &&
	401	!wxStrrchr(pzExtension, wxT('?')) &&
	402	pzExtension[1] &&
	403	pzExtension[1] != wxT(' ')
	404	) // != "blabla. "
	405	{
	406	//
	407	// Now concat extension to the fileName:
	408	//
	409	m_sPath = wxString(zFileNameBuffer) + pzExtension;
	410	}
	411	}
	412	}
	413	else
	414	{
	415	m_sPath = vFileDlg.szFullFile;
	416	}
	417	m_sFileName = wxFileNameFromPath(vFileDlg.szFullFile);
	418	m_sDir = wxPathOnly(vFileDlg.szFullFile);
	419
	420	//
	421	// === Simulating the wxOVERWRITE_PROMPT >>============================
	422	//
	423	if ((m_lDialogStyle & wxOVERWRITE_PROMPT) &&
	424	(m_lDialogStyle & wxSAVE) &&
	425	(wxFileExists(m_sPath.c_str())))
	426	{
	427	wxString sMessageText;
	428
	429	sMessageText.Printf( _("File '%s' already exists.\nDo you want to replace it?")
	430	,m_sPath.c_str()
	431	);
	432	if (wxMessageBox( sMessageText
	433	,wxT("Save File As")
	434	,wxYES_NO \| wxICON_EXCLAMATION
	435	) != wxYES)
	436	{
	437	return wxID_CANCEL;
	438	}
	439	}
	440	}
	441	return wxID_OK;
	442	}
	443	return wxID_CANCEL;
	444	} // end of wxFileDialog::ShowModal
	445
	446	//
	447	// Generic file load/save dialog
	448	//
	449	static wxString wxDefaultFileSelector (
	450	bool bLoad
	451	, const char* pzWhat
	452	, const char* pzExtension
	453	, const char* pzDefaultName
	454	, wxWindow* pParent
	455	)
	456	{
	457	char* pzExt = (char *)pzExtension;
	458	char zPrompt[50];
	459	wxString sStr;
	460	char zWild[60];
	461
	462	if (bLoad)
	463	sStr = "Load %s file";
	464	else
	465	sStr = "Save %s file";
	466	sprintf(zPrompt, wxGetTranslation(sStr), pzWhat);
	467
	468	if (*pzExt == '.')
	469	pzExt++;
	470	sprintf(zWild, "*.%s", pzExt);
	471	return wxFileSelector ( zPrompt
	472	,NULL
	473	,pzDefaultName
	474	,pzExt
	475	,zWild
	476	,0
	477	,pParent
	478	);
	479	} // end of wxDefaultFileSelector
	480
	481	//
	482	// Generic file load dialog
	483	//
	484	wxString wxLoadFileSelector (
	485	const char* pzWhat
	486	, const char* pzExtension
	487	, const char* pzDefaultName
	488	, wxWindow* pParent
	489	)
	490	{
	491	return wxDefaultFileSelector( TRUE
	492	,pzWhat
	493	,pzExtension
	494	,pzDefaultName
	495	,pParent
	496	);
	497	} // end of wxLoadFileSelector
	498
	499
	500	//
	501	// Generic file save dialog
	502	//
	503	wxString wxSaveFileSelector (
	504	const char* pzWhat
	505	, const char* pzExtension
	506	, const char* pzDefaultName
	507	, wxWindow* pParent
	508	)
	509	{
	510	return wxDefaultFileSelector( FALSE
	511	,pzWhat
	512	,pzExtension
	513	,pzDefaultName
	514	,pParent
	515	);
	516	} // end of wxSaveFileSelector
	517