[wxWidgets.git] / src / mac / filedlg.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        filedlg.cpp
// Purpose:     wxFileDialog
// Author:      AUTHOR
// Modified by:
// Created:     ??/??/98
// RCS-ID:      $Id$
// Copyright:   (c) AUTHOR
// Licence:     wxWindows licence
/////////////////////////////////////////////////////////////////////////////

#ifdef __GNUG__
#pragma implementation "filedlg.h"
#endif

#include "wx/defs.h"
#include "wx/utils.h"
#include "wx/dialog.h"
#include "wx/filedlg.h"
#include "wx/intl.h"

IMPLEMENT_CLASS(wxFileDialog, wxDialog)

// begin wxmac

#include "morefile.h"
#include "moreextr.h"
#include "fullpath.h"
#include "fspcompa.h"
#include "PLStringFuncs.h"

char * gfilters[] =
{
	"*.TXT" ,
	
	NULL 
} ;

OSType gfiltersmac[] =
{
	'TEXT' ,
	
	'****'
} ;

static void wxMacSetupStandardFile(short newVRefNum, long newDirID) 
{ 
	enum 
	{ SFSaveDisk = 0x214, CurDirStore = 0x398 };
	*(short *) SFSaveDisk = -1 * newVRefNum; 
	*(long *) CurDirStore = newDirID; 
}

static void wxMacSetupStandardFileFromPath( const char* s )
{
	Str255	volume ;
	Str255	path ;
	short	vRefNum ;
	long dirRef ;
	short	i,j ;
	Boolean isDirectory ;
	
	for (i=0 ; (s[i]!=0) && (s[i]!=':') ;i++)
		{
		volume[i]=s[i] ;
		}
	volume[i]=':' ;
	volume[i+1]=0 ;
	
	// then copy the rest of the filename
	
	for (j=0;(s[i]!=0);i++,j++)
		{
		path[j]=s[i] ;		
		}
	path[j]=0 ;
	
	c2pstr((Ptr) volume) ;
	c2pstr((Ptr) path) ;
	
	SetVol(volume, 0) ;
	GetVol( NULL, &vRefNum ) ;
		
	GetDirectoryID( vRefNum , fsRtDirID , path , &dirRef , &isDirectory ) ;
	wxMacSetupStandardFile(vRefNum, dirRef) 	;
}

enum {
	kSelectItem = 10, 			// select button item number
	kSFGetFileDlgID = 251,	// dialog resource number
	kStrListID = 251,			// our strings
	kSelectStrNum = 1,			// word 'Select: ' for button
	kDesktopStrNum = 2,			// word 'Desktop' for button
	kSelectNoQuoteStrNum = 3,	// word 'Select: ' for button
	
	kUseQuotes = true,			// parameter for SetButtonName
	kDontUseQuotes = false
};

// the data we need to pass to our standard file hook routine
// includes a pointer to the dialog, a pointer to the standard
// file reply record (so we can inspect the current selection)
// and a copy of the "previous" file spec of the reply record
// so we can see if the selection has changed

const int kwxMacFileTypes = 10 ;

struct OpenUserDataRec {
	StandardFileReply	*sfrPtr;
	FSSpec				oldSelectionFSSpec;
	char				filter[kwxMacFileTypes][10] ;
	OSType				filtermactypes[kwxMacFileTypes] ;
	int					numfilters ;
	DialogPtr			theDlgPtr;
};
typedef struct OpenUserDataRec
	OpenUserDataRec, *OpenUserDataRecPtr;

static void GetLabelString(StringPtr theStr, short stringNum)
{
	GetIndString(theStr, kStrListID, stringNum);
}

static void CopyPStr(StringPtr src, StringPtr dest)
{
	BlockMoveData(src, dest, 1 + src[0]);
}

static char GetSelectKey(void)
{
	// this is the key used to trigger the select button
	
	// NOT INTERNATIONAL SAVVY; should at least grab it from resources
	
	return 's';
}

// FlashButton briefly highlights the dialog button 
// as feedback for key equivalents

static void FlashButton(DialogPtr theDlgPtr, short buttonID)
{
	short	buttonType;
	Handle	buttonHandle;
	Rect	buttonRect;
	unsigned long	finalTicks;
	
	GetDialogItem(theDlgPtr, buttonID, &buttonType, &buttonHandle, &buttonRect);
	HiliteControl((ControlHandle) buttonHandle, kControlButtonPart);
	Delay(10, &finalTicks);
	HiliteControl((ControlHandle) buttonHandle, 0);
}

static Boolean SameFSSpec(FSSpecPtr spec1, FSSpecPtr spec2)
{
	return (spec1->vRefNum == spec2->vRefNum
			&& spec1->parID == spec2->parID
			&& EqualString(spec1->name, spec2->name, false, false));
}
// MyModalDialogFilter maps a key to the Select button, and handles
// flashing of the button when the key is hit

static pascal Boolean SFGetFolderModalDialogFilter(DialogPtr theDlgPtr, EventRecord *eventRec,
											short *item, Ptr dataPtr)
{
#pragma unused (dataPtr)

	// make certain the proper dialog is showing, 'cause standard file
	// can nest dialogs but calls the same filter for each
	
	if (((WindowPeek) theDlgPtr)->refCon == sfMainDialogRefCon)
	{
		// check if the select button was hit
		/*
		if ((eventRec->what == keyDown)
			&& (eventRec->modifiers & cmdKey) 
			&& ((eventRec->message & charCodeMask) == GetSelectKey()))
		{
			*item = kSelectItem;
			FlashButton(theDlgPtr, kSelectItem);
			return true;
		}
		*/
	}
		
	return false;
}

void ExtendedOpenFile( ConstStr255Param message , ConstStr255Param path , const char *filter , FileFilterYDUPP fileFilter, StandardFileReply *theSFR)
{
	Point 				thePt;
	OpenUserDataRec			myData;
	FSSpec				tempSpec;
	Boolean				folderFlag;
	Boolean				wasAliasedFlag;
	DlgHookYDUPP		dlgHookUPP;
	ModalFilterYDUPP	myModalFilterUPP;
	OSErr				err;
	SFTypeList			types ;
	
	
	// presumably we're running System 7 or later so CustomGetFile is
	// available
	
	// set initial contents of Select button to a space
	
	CopyPStr("\p ", theSFR->sfFile.name);
	
	// point the user data parameter at the reply record so we can get to it later
	
	myData.sfrPtr = theSFR;
	if ( filter && filter[0] )
	{
		myData.numfilters = 1 ;
		for ( int i = 0 ; i < myData.numfilters ; i++ )
		{
			int j ;
			
			strcpy( myData.filter[i] , filter ) ;
			for( j = 0 ; myData.filter[i][j] ; j++ )
			{
				myData.filter[i][j] = toupper( myData.filter[i][j] ) ;
			}
			for ( j = 0 ; gfilters[j] ; j++ )
			{
				if ( strcmp( myData.filter[i] , gfilters[j] ) == 0 )
				{
					myData.filtermactypes[i] = gfiltersmac[j] ;
					break ;
				}
			}
			if( gfilters[j] == NULL )
			{
				myData.filtermactypes[i] = '****' ;
			}
		}
	}
	else
	{
		myData.numfilters = 0 ;
	}
	// display the dialog
	
	dlgHookUPP = NULL ;
//	dlgHookUPP = NewDlgHookYDProc(SFGetFolderDialogHook);
	myModalFilterUPP = NewModalFilterYDProc(SFGetFolderModalDialogFilter);
	
	thePt.h = thePt.v = -1;	// center dialog
	
	ParamText( message , NULL , NULL , NULL ) ;
	
	CustomGetFile(	fileFilter, 
					-1,					// show all types
					NULL,
					theSFR,
					kSFGetFileDlgID,
					thePt,				// top left point
					dlgHookUPP,
					myModalFilterUPP,
					nil,				// activate list
					nil,				// activate proc
					&myData);
					
	DisposeRoutineDescriptor(dlgHookUPP);
	DisposeRoutineDescriptor(myModalFilterUPP);
	
	// if cancel wasn't pressed and no fatal error occurred...
	
	if (theSFR->sfGood)
	{
		// if no name is in the reply record file spec,
		// use the file spec of the parent folder
		
		if (theSFR->sfFile.name[0] == '\0')
		{
			err = FSMakeFSSpec(theSFR->sfFile.vRefNum, theSFR->sfFile.parID,
								"\p", &tempSpec);
			if (err == noErr)
			{
				theSFR->sfFile = tempSpec;
			}
			else
			{
				// no name to return, forget it
				
				theSFR->sfGood = false;
			}
		}
		
		// if there is now a name in the file spec, check if it's
		// for a folder or a volume
		
		if (theSFR->sfFile.name[0] != '\0')
		{
			// the parID of the root of a disk is always fsRtParID == 1
			
			if (theSFR->sfFile.parID == fsRtParID)
			{
				theSFR->sfIsVolume = true;
				theSFR->sfIsFolder = false;	// it would be reasonable for this to be true, too
			}
			
			// we have a valid FSSpec, now let's make sure it's not for an alias file
			
			err = ResolveAliasFile(&theSFR->sfFile, true, &folderFlag, &wasAliasedFlag);
			if (err != noErr)
			{
				theSFR->sfGood = false;
			}
			
			// did the alias resolve to a folder?
			
			if (folderFlag  && ! theSFR->sfIsVolume)
			{
				theSFR->sfIsFolder = true;
			}
		}
	}
}

static pascal Boolean CrossPlatformFileFilter(CInfoPBPtr myCInfoPBPtr, Ptr dataPtr)
{	
	Str255 			filename ;
	OpenUserDataRecPtr data = (OpenUserDataRecPtr) dataPtr ;
	// return true if this item is invisible or a file

	Boolean visibleFlag;
	Boolean folderFlag;
	
	visibleFlag = ! (myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible);
	folderFlag = (myCInfoPBPtr->hFileInfo.ioFlAttrib & 0x10);
	
	// because the semantics of the filter proc are "true means don't show
	// it" we need to invert the result that we return
	
	if ( !visibleFlag )
		return true ;
		
	if ( !folderFlag )
	{
		if ( data->numfilters > 0 )
		{
			PLstrcpy( filename ,myCInfoPBPtr->hFileInfo.ioNamePtr ) ;
			if ( filename[0] >= 4 )
			{
				for( int j = 1 ; j <= filename[0] ; j++ )
				{
					filename[j] = toupper( filename[j] ) ;
				}
				for ( int i = 0 ; i < data->numfilters ; ++i )
				{
					if ( myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdType == data->filtermactypes[i] )
						return false ;

					if ( strncmp( (char*) filename + 1 + filename[0] - 4 , 
							& data->filter[i][ strlen(data->filter[i]) - 4 ] , 4 ) == 0 )
							return false ;
				}
			}
			return true ;				
		}
	}	
		
	return false ;
}

// end wxmac

wxString wxFileSelector(const char *title,
                     const char *defaultDir, const char *defaultFileName,
                     const char *defaultExtension, const char *filter, int flags,
                     wxWindow *parent, int x, int y)
{
    // If there's a default extension specified but no filter, we create a suitable
    // filter.

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

    wxString defaultDirString;
    if (defaultDir)
        defaultDirString = defaultDir;
    else
        defaultDirString = "";

    wxString defaultFilenameString;
    if (defaultFileName)
        defaultFilenameString = defaultFileName;
    else
        defaultFilenameString = "";

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

    if ( fileDialog.ShowModal() == wxID_OK )
    {
        strcpy(wxBuffer, (const char *)fileDialog.GetPath());
        return wxBuffer;
    }
    else
        return wxGetEmptyString();
}

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

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

    if ( fileDialog.ShowModal() == wxID_OK )
    {
        *defaultFilterIndex = fileDialog.GetFilterIndex();
        strcpy(wxBuffer, (const char *)fileDialog.GetPath());
        return wxBuffer;
    }
    else
        return wxGetEmptyString();
}

wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
        const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
        long style, const wxPoint& pos)
{
    m_message = message;
    m_dialogStyle = style;
    m_parent = parent;
    m_path = "";
    m_fileName = defaultFileName;
    m_dir = defaultDir;
    m_wildCard = wildCard;
    m_filterIndex = 1;
}

int wxFileDialog::ShowModal()
{
	if ( m_dialogStyle & wxSAVE )
	{
		StandardFileReply	reply ;
		Str255				prompt ;
		Str255				filename ;

		strcpy((char *)prompt, m_message) ;
		c2pstr((char *)prompt ) ;
	
		strcpy((char *)filename, m_fileName) ;
		c2pstr((char *)filename ) ;
		
		StandardPutFile( prompt , filename , &reply ) ;
		if ( reply.sfGood == false )
		{
			m_path = "" ;
			return wxID_CANCEL ;
		}
		else
		{
			m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
			return wxID_OK ;
		}
	}
	else
	{
		OSType types = '????' ;
		Str255				prompt ;
		Str255				path ;

		strcpy((char *)prompt, m_message) ;
		c2pstr((char *)prompt ) ;
	
		strcpy((char *)path, m_path ) ;
		c2pstr((char *)path ) ;

		FileFilterYDUPP 	crossPlatformFileFilterUPP;
		StandardFileReply	reply ;
		crossPlatformFileFilterUPP = 
			NewFileFilterYDProc(CrossPlatformFileFilter);

		ExtendedOpenFile( prompt , path , m_wildCard , crossPlatformFileFilterUPP, &reply);
	
		DisposeRoutineDescriptor(crossPlatformFileFilterUPP);
		if ( reply.sfGood == false )
		{
			m_path = "" ;
			return wxID_CANCEL ;
		}
		else
		{
			m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
			return wxID_OK ;
		}
	}
    return wxID_CANCEL;
}

// Generic file load/save dialog
static wxString
wxDefaultFileSelector(bool load, const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
  char *ext = (char *)extension;
  
  char prompt[50];
  wxString str;
  if (load)
    str = "Load %s file";
  else
    str = "Save %s file";
  sprintf(prompt, wxGetTranslation(str), what);

  if (*ext == '.') ext++;
  char wild[60];
  sprintf(wild, "*.%s", ext);

  return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
}

// Generic file load dialog
wxString
wxLoadFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
  return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
}


// Generic file save dialog
wxString
wxSaveFileSelector(const char *what, const char *extension, const char *default_name, wxWindow *parent)
{
  return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
}
Commit	Line	Data
e9576ca5 SC	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: filedlg.cpp
	3	// Purpose: wxFileDialog
	4	// Author: AUTHOR
	5	// Modified by:
	6	// Created: ??/??/98
	7	// RCS-ID: $Id$
	8	// Copyright: (c) AUTHOR
	9	// Licence: wxWindows licence
	10	/////////////////////////////////////////////////////////////////////////////
	11
	12	#ifdef __GNUG__
	13	#pragma implementation "filedlg.h"
	14	#endif
	15
	16	#include "wx/defs.h"
	17	#include "wx/utils.h"
	18	#include "wx/dialog.h"
	19	#include "wx/filedlg.h"
	20	#include "wx/intl.h"
	21
e9576ca5	22	IMPLEMENT_CLASS(wxFileDialog, wxDialog)
e9576ca5	23
519cb848 SC	24	// begin wxmac
	25
	26	#include "morefile.h"
	27	#include "moreextr.h"
	28	#include "fullpath.h"
	29	#include "fspcompa.h"
	30	#include "PLStringFuncs.h"
	31
	32	char * gfilters[] =
	33	{
	34	"*.TXT" ,
	35
	36	NULL
	37	} ;
	38
	39	OSType gfiltersmac[] =
	40	{
	41	'TEXT' ,
	42
	43	'****'
	44	} ;
	45
	46	static void wxMacSetupStandardFile(short newVRefNum, long newDirID)
	47	{
	48	enum
	49	{ SFSaveDisk = 0x214, CurDirStore = 0x398 };
	50	(short ) SFSaveDisk = -1 * newVRefNum;
	51	(long ) CurDirStore = newDirID;
	52	}
	53
	54	static void wxMacSetupStandardFileFromPath( const char* s )
	55	{
	56	Str255 volume ;
	57	Str255 path ;
	58	short vRefNum ;
	59	long dirRef ;
	60	short i,j ;
	61	Boolean isDirectory ;
	62
	63	for (i=0 ; (s[i]!=0) && (s[i]!=':') ;i++)
	64	{
	65	volume[i]=s[i] ;
	66	}
	67	volume[i]=':' ;
	68	volume[i+1]=0 ;
	69
	70	// then copy the rest of the filename
	71
	72	for (j=0;(s[i]!=0);i++,j++)
	73	{
	74	path[j]=s[i] ;
	75	}
	76	path[j]=0 ;
	77
	78	c2pstr((Ptr) volume) ;
	79	c2pstr((Ptr) path) ;
	80
	81	SetVol(volume, 0) ;
	82	GetVol( NULL, &vRefNum ) ;
	83
	84	GetDirectoryID( vRefNum , fsRtDirID , path , &dirRef , &isDirectory ) ;
	85	wxMacSetupStandardFile(vRefNum, dirRef) ;
	86	}
	87
88	enum {
89	kSelectItem = 10, // select button item number
90	kSFGetFileDlgID = 251, // dialog resource number
91	kStrListID = 251, // our strings
92	kSelectStrNum = 1, // word 'Select: ' for button
93	kDesktopStrNum = 2, // word 'Desktop' for button
94	kSelectNoQuoteStrNum = 3, // word 'Select: ' for button
95
96	kUseQuotes = true, // parameter for SetButtonName
97	kDontUseQuotes = false
98	};
99
100	// the data we need to pass to our standard file hook routine
101	// includes a pointer to the dialog, a pointer to the standard
102	// file reply record (so we can inspect the current selection)
103	// and a copy of the "previous" file spec of the reply record
104	// so we can see if the selection has changed
105
106	const int kwxMacFileTypes = 10 ;
107
108	struct OpenUserDataRec {
109	StandardFileReply *sfrPtr;
110	FSSpec oldSelectionFSSpec;
111	char filter[kwxMacFileTypes][10] ;
112	OSType filtermactypes[kwxMacFileTypes] ;
113	int numfilters ;
114	DialogPtr theDlgPtr;
115	};
116	typedef struct OpenUserDataRec
117	OpenUserDataRec, *OpenUserDataRecPtr;
118
119	static void GetLabelString(StringPtr theStr, short stringNum)
120	{
121	GetIndString(theStr, kStrListID, stringNum);
122	}
123
124	static void CopyPStr(StringPtr src, StringPtr dest)
125	{
126	BlockMoveData(src, dest, 1 + src[0]);
127	}
128
129	static char GetSelectKey(void)
130	{
131	// this is the key used to trigger the select button
132
133	// NOT INTERNATIONAL SAVVY; should at least grab it from resources
134
135	return 's';
136	}
137
138	// FlashButton briefly highlights the dialog button
139	// as feedback for key equivalents
140
141	static void FlashButton(DialogPtr theDlgPtr, short buttonID)
142	{
143	short buttonType;
144	Handle buttonHandle;
145	Rect buttonRect;
146	unsigned long finalTicks;
147
148	GetDialogItem(theDlgPtr, buttonID, &buttonType, &buttonHandle, &buttonRect);
149	HiliteControl((ControlHandle) buttonHandle, kControlButtonPart);
150	Delay(10, &finalTicks);
151	HiliteControl((ControlHandle) buttonHandle, 0);
152	}
153
154	static Boolean SameFSSpec(FSSpecPtr spec1, FSSpecPtr spec2)
155	{
156	return (spec1->vRefNum == spec2->vRefNum
157	&& spec1->parID == spec2->parID
158	&& EqualString(spec1->name, spec2->name, false, false));
159	}
160	// MyModalDialogFilter maps a key to the Select button, and handles
161	// flashing of the button when the key is hit
162
163	static pascal Boolean SFGetFolderModalDialogFilter(DialogPtr theDlgPtr, EventRecord *eventRec,
164	short *item, Ptr dataPtr)
165	{
166	#pragma unused (dataPtr)
167
168	// make certain the proper dialog is showing, 'cause standard file
169	// can nest dialogs but calls the same filter for each
170
171	if (((WindowPeek) theDlgPtr)->refCon == sfMainDialogRefCon)
172	{
173	// check if the select button was hit
174	/*
175	if ((eventRec->what == keyDown)
176	&& (eventRec->modifiers & cmdKey)
177	&& ((eventRec->message & charCodeMask) == GetSelectKey()))
178	{
179	*item = kSelectItem;
180	FlashButton(theDlgPtr, kSelectItem);
181	return true;
182	}
183	*/
184	}
185
186	return false;
187	}
188
189	void ExtendedOpenFile( ConstStr255Param message , ConstStr255Param path , const char filter , FileFilterYDUPP fileFilter, StandardFileReply theSFR)
190	{
191	Point thePt;
192	OpenUserDataRec myData;
193	FSSpec tempSpec;
194	Boolean folderFlag;
195	Boolean wasAliasedFlag;
196	DlgHookYDUPP dlgHookUPP;
197	ModalFilterYDUPP myModalFilterUPP;
198	OSErr err;
199	SFTypeList types ;
200
201
202	// presumably we're running System 7 or later so CustomGetFile is
203	// available
204
205	// set initial contents of Select button to a space
206
207	CopyPStr("\p ", theSFR->sfFile.name);
208
209	// point the user data parameter at the reply record so we can get to it later
210
211	myData.sfrPtr = theSFR;
212	if ( filter && filter[0] )
213	{
214	myData.numfilters = 1 ;
215	for ( int i = 0 ; i < myData.numfilters ; i++ )
216	{
217	int j ;
218
219	strcpy( myData.filter[i] , filter ) ;
220	for( j = 0 ; myData.filter[i][j] ; j++ )
221	{
222	myData.filter[i][j] = toupper( myData.filter[i][j] ) ;
223	}
224	for ( j = 0 ; gfilters[j] ; j++ )
225	{
226	if ( strcmp( myData.filter[i] , gfilters[j] ) == 0 )
227	{
228	myData.filtermactypes[i] = gfiltersmac[j] ;
229	break ;
230	}
231	}
232	if( gfilters[j] == NULL )
233	{
234	myData.filtermactypes[i] = '****' ;
235	}
236	}
237	}
238	else
239	{
240	myData.numfilters = 0 ;
241	}
242	// display the dialog
243
244	dlgHookUPP = NULL ;
245	// dlgHookUPP = NewDlgHookYDProc(SFGetFolderDialogHook);
246	myModalFilterUPP = NewModalFilterYDProc(SFGetFolderModalDialogFilter);
247
248	thePt.h = thePt.v = -1; // center dialog
249
250	ParamText( message , NULL , NULL , NULL ) ;
251
252	CustomGetFile( fileFilter,
253	-1, // show all types
254	NULL,
255	theSFR,
256	kSFGetFileDlgID,
257	thePt, // top left point
258	dlgHookUPP,
259	myModalFilterUPP,
260	nil, // activate list
261	nil, // activate proc
262	&myData);
263
264	DisposeRoutineDescriptor(dlgHookUPP);
265	DisposeRoutineDescriptor(myModalFilterUPP);
266
267	// if cancel wasn't pressed and no fatal error occurred...
268
269	if (theSFR->sfGood)
270	{
271	// if no name is in the reply record file spec,
272	// use the file spec of the parent folder
273
274	if (theSFR->sfFile.name[0] == '\0')
275	{
276	err = FSMakeFSSpec(theSFR->sfFile.vRefNum, theSFR->sfFile.parID,
277	"\p", &tempSpec);
278	if (err == noErr)
279	{
280	theSFR->sfFile = tempSpec;
281	}
282	else
283	{
284	// no name to return, forget it
285
286	theSFR->sfGood = false;
287	}
288	}
289
290	// if there is now a name in the file spec, check if it's
291	// for a folder or a volume
292
293	if (theSFR->sfFile.name[0] != '\0')
294	{
295	// the parID of the root of a disk is always fsRtParID == 1
296
297	if (theSFR->sfFile.parID == fsRtParID)
298	{
299	theSFR->sfIsVolume = true;
300	theSFR->sfIsFolder = false; // it would be reasonable for this to be true, too
301	}
302
303	// we have a valid FSSpec, now let's make sure it's not for an alias file
304
305	err = ResolveAliasFile(&theSFR->sfFile, true, &folderFlag, &wasAliasedFlag);
306	if (err != noErr)
307	{
308	theSFR->sfGood = false;
309	}
310
311	// did the alias resolve to a folder?
312
313	if (folderFlag && ! theSFR->sfIsVolume)
314	{
315	theSFR->sfIsFolder = true;
316	}
317	}
318	}
319	}
320
321	static pascal Boolean CrossPlatformFileFilter(CInfoPBPtr myCInfoPBPtr, Ptr dataPtr)
322	{
323	Str255 filename ;
324	OpenUserDataRecPtr data = (OpenUserDataRecPtr) dataPtr ;
325	// return true if this item is invisible or a file
326
327	Boolean visibleFlag;
328	Boolean folderFlag;
329
330	visibleFlag = ! (myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible);
331	folderFlag = (myCInfoPBPtr->hFileInfo.ioFlAttrib & 0x10);
332
333	// because the semantics of the filter proc are "true means don't show
334	// it" we need to invert the result that we return
335
336	if ( !visibleFlag )
337	return true ;
338
339	if ( !folderFlag )
340	{
341	if ( data->numfilters > 0 )
342	{
343	PLstrcpy( filename ,myCInfoPBPtr->hFileInfo.ioNamePtr ) ;
344	if ( filename[0] >= 4 )
345	{
346	for( int j = 1 ; j <= filename[0] ; j++ )
347	{
348	filename[j] = toupper( filename[j] ) ;
349	}
350	for ( int i = 0 ; i < data->numfilters ; ++i )
351	{
352	if ( myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdType == data->filtermactypes[i] )
353	return false ;
354
355	if ( strncmp( (char*) filename + 1 + filename[0] - 4 ,
356	& data->filter[i][ strlen(data->filter[i]) - 4 ] , 4 ) == 0 )
357	return false ;
358	}
359	}
360	return true ;
361	}
362	}
363
364	return false ;
365	}
366
367	// end wxmac
368
369	wxString wxFileSelector(const char *title,
e9576ca5 SC	370	const char defaultDir, const char defaultFileName,
	371	const char defaultExtension, const char filter, int flags,
	372	wxWindow *parent, int x, int y)
	373	{
	374	// If there's a default extension specified but no filter, we create a suitable
	375	// filter.
	376
	377	wxString filter2("");
	378	if ( defaultExtension && !filter )
	379	filter2 = wxString("*.") + wxString(defaultExtension) ;
	380	else if ( filter )
	381	filter2 = filter;
	382
	383	wxString defaultDirString;
	384	if (defaultDir)
	385	defaultDirString = defaultDir;
	386	else
	387	defaultDirString = "";
	388
	389	wxString defaultFilenameString;
	390	if (defaultFileName)
	391	defaultFilenameString = defaultFileName;
	392	else
	393	defaultFilenameString = "";
	394
	395	wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
	396
	397	if ( fileDialog.ShowModal() == wxID_OK )
	398	{
	399	strcpy(wxBuffer, (const char *)fileDialog.GetPath());
	400	return wxBuffer;
	401	}
	402	else
8be97d65	403	return wxGetEmptyString();
e9576ca5 SC	404	}
e9576ca5 SC	405
169935ad	406	WXDLLEXPORT wxString wxFileSelectorEx(const char *title,
e9576ca5 SC	407	const char *defaultDir,
	408	const char *defaultFileName,
	409	int* defaultFilterIndex,
	410	const char *filter,
	411	int flags,
	412	wxWindow* parent,
	413	int x,
	414	int y)
	415
	416	{
	417	wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
	418	defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
	419
	420	if ( fileDialog.ShowModal() == wxID_OK )
	421	{
	422	*defaultFilterIndex = fileDialog.GetFilterIndex();
	423	strcpy(wxBuffer, (const char *)fileDialog.GetPath());
	424	return wxBuffer;
	425	}
	426	else
8be97d65	427	return wxGetEmptyString();
e9576ca5 SC	428	}
	429
	430	wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
	431	const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
	432	long style, const wxPoint& pos)
	433	{
	434	m_message = message;
	435	m_dialogStyle = style;
	436	m_parent = parent;
	437	m_path = "";
	438	m_fileName = defaultFileName;
	439	m_dir = defaultDir;
	440	m_wildCard = wildCard;
	441	m_filterIndex = 1;
	442	}
	443
	444	int wxFileDialog::ShowModal()
	445	{
519cb848 SC	446	if ( m_dialogStyle & wxSAVE )
	447	{
	448	StandardFileReply reply ;
	449	Str255 prompt ;
	450	Str255 filename ;
	451
	452	strcpy((char *)prompt, m_message) ;
	453	c2pstr((char *)prompt ) ;
	454
	455	strcpy((char *)filename, m_fileName) ;
	456	c2pstr((char *)filename ) ;
	457
	458	StandardPutFile( prompt , filename , &reply ) ;
	459	if ( reply.sfGood == false )
	460	{
	461	m_path = "" ;
	462	return wxID_CANCEL ;
	463	}
	464	else
	465	{
	466	m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
	467	return wxID_OK ;
	468	}
	469	}
	470	else
	471	{
	472	OSType types = '????' ;
	473	Str255 prompt ;
	474	Str255 path ;
	475
	476	strcpy((char *)prompt, m_message) ;
	477	c2pstr((char *)prompt ) ;
	478
	479	strcpy((char *)path, m_path ) ;
	480	c2pstr((char *)path ) ;
	481
	482	FileFilterYDUPP crossPlatformFileFilterUPP;
	483	StandardFileReply reply ;
	484	crossPlatformFileFilterUPP =
	485	NewFileFilterYDProc(CrossPlatformFileFilter);
	486
	487	ExtendedOpenFile( prompt , path , m_wildCard , crossPlatformFileFilterUPP, &reply);
	488
	489	DisposeRoutineDescriptor(crossPlatformFileFilterUPP);
	490	if ( reply.sfGood == false )
	491	{
	492	m_path = "" ;
	493	return wxID_CANCEL ;
	494	}
	495	else
	496	{
	497	m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
	498	return wxID_OK ;
	499	}
	500	}
e9576ca5 SC	501	return wxID_CANCEL;
	502	}
	503
	504	// Generic file load/save dialog
169935ad	505	static wxString
e9576ca5 SC	506	wxDefaultFileSelector(bool load, const char what, const char extension, const char default_name, wxWindow parent)
	507	{
	508	char ext = (char )extension;
	509
	510	char prompt[50];
	511	wxString str;
	512	if (load)
	513	str = "Load %s file";
	514	else
	515	str = "Save %s file";
	516	sprintf(prompt, wxGetTranslation(str), what);
	517
	518	if (*ext == '.') ext++;
	519	char wild[60];
	520	sprintf(wild, "*.%s", ext);
	521
	522	return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
	523	}
	524
	525	// Generic file load dialog
169935ad	526	wxString
e9576ca5 SC	527	wxLoadFileSelector(const char what, const char extension, const char default_name, wxWindow parent)
	528	{
	529	return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
	530	}
	531
	532
	533	// Generic file save dialog
169935ad	534	wxString
e9576ca5 SC	535	wxSaveFileSelector(const char what, const char extension, const char default_name, wxWindow parent)
	536	{
	537	return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
	538	}
	539
	540