src/mac/carbon/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/app.h"
#include "wx/utils.h"
#include "wx/dialog.h"
#include "wx/filedlg.h"
#include "wx/intl.h"

#if !defined(__UNIX__)
  #include "PLStringFuncs.h"
#endif

#if !USE_SHARED_LIBRARY
IMPLEMENT_CLASS(wxFileDialog, wxDialog)
#endif

// begin wxmac

#if defined(__UNIX__)
  #include <Carbon/Carbon.h>
#else
  #include <Navigation.h>
#endif

#ifndef __UNIX__
  #include "morefile.h"
  #include "moreextr.h"
  #include "fullpath.h"
  #include "fspcompa.h"
  #include "PLStringFuncs.h"
#endif

extern bool gUseNavServices ;

static pascal void	NavEventProc(
								NavEventCallbackMessage		inSelector,
								NavCBRecPtr					ioParams,
								NavCallBackUserData			ioUserData);

#if TARGET_CARBON
		static NavEventUPP	sStandardNavEventFilter = NewNavEventUPP(NavEventProc);
#else
		static NavEventUPP	sStandardNavEventFilter = NewNavEventProc(NavEventProc);
#endif

static pascal void
NavEventProc(
	NavEventCallbackMessage		inSelector,
	NavCBRecPtr					ioParams,
	NavCallBackUserData			/* ioUserData */)
{
	if (inSelector == kNavCBEvent) {
			// In Universal Headers 3.2, Apple changed the definition of
		/*
		#if UNIVERSAL_INTERFACES_VERSION >= 0x0320 // Universal Headers 3.2
			UModalAlerts::ProcessModalEvent(*(ioParams->eventData.eventDataParms.event));

		#else
			UModalAlerts::ProcessModalEvent(*(ioParams->eventData.event));
		#endif
		*/

         wxTheApp->MacHandleOneEvent(ioParams->eventData.eventDataParms.event);
	}
}

char * gfilters[] =
{
	"*.TXT" ,

	NULL
} ;

OSType gfiltersmac[] =
{
	'TEXT' ,

	'****'
} ;

// 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;

#if !TARGET_CARBON

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
};

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, void *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;
}
#endif !TARGET_CARBON

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

	memcpy( theSFR->sfFile.name , "\p " , 2 ) ;

	// 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

#if !TARGET_CARBON

	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);
#else
#endif
	// 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, void *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 !TARGET_CARBON
	if ( !gUseNavServices )
	{
	if ( m_dialogStyle & wxSAVE )
	{
		StandardFileReply	reply ;
		Str255				prompt ;
		Str255				filename ;

#if TARGET_CARBON
		c2pstrcpy((StringPtr)prompt, m_message) ;
#else
		strcpy((char *)prompt, m_message) ;
		c2pstr((char *)prompt ) ;
#endif
#if TARGET_CARBON
		c2pstrcpy((StringPtr)filename, m_fileName) ;
#else
		strcpy((char *)filename, m_fileName) ;
		c2pstr((char *)filename ) ;
#endif

		#if !TARGET_CARBON

		StandardPutFile( prompt , filename , &reply ) ;

		#else
		#endif
		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 ;

#if TARGET_CARBON
		c2pstrcpy((StringPtr)prompt, m_message) ;
#else
		strcpy((char *)prompt, m_message) ;
		c2pstr((char *)prompt ) ;
#endif
#if TARGET_CARBON
		c2pstrcpy((StringPtr)path, m_dir ) ;
#else
		strcpy((char *)path, m_dir ) ;
		c2pstr((char *)path ) ;
#endif

		StandardFileReply	reply ;
		FileFilterYDUPP crossPlatformFileFilterUPP = 0 ;
		#if !TARGET_CARBON
		crossPlatformFileFilterUPP =
			NewFileFilterYDProc(CrossPlatformFileFilter);
		#endif

		ExtendedOpenFile( prompt , path , m_wildCard , crossPlatformFileFilterUPP, &reply);
		#if !TARGET_CARBON
		DisposeFileFilterYDUPP(crossPlatformFileFilterUPP);
		#endif
		if ( reply.sfGood == false )
		{
			m_path = "" ;
			return wxID_CANCEL ;
		}
		else
		{
			m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
			return wxID_OK ;
		}
	}
    return wxID_CANCEL;
}
	else
#endif
	{
		NavDialogOptions		mNavOptions;
		NavObjectFilterUPP		mNavFilterUPP = NULL;
		NavPreviewUPP			mNavPreviewUPP = NULL ;
		NavReplyRecord			mNavReply;
		AEDesc					mDefaultLocation ;
		bool					mSelectDefault = false ;

		::NavGetDefaultDialogOptions(&mNavOptions);

		mNavFilterUPP	= nil;
		mNavPreviewUPP	= nil;
		mSelectDefault	= false;
		mNavReply.validRecord				= false;
		mNavReply.replacing					= false;
		mNavReply.isStationery				= false;
		mNavReply.translationNeeded			= false;
		mNavReply.selection.descriptorType = typeNull;
		mNavReply.selection.dataHandle		= nil;
		mNavReply.keyScript					= smSystemScript;
		mNavReply.fileTranslation			= nil;

		// Set default location, the location
		//   that's displayed when the dialog
		//   first appears

		FSSpec location ;
		wxUnixFilename2FSSpec( m_dir , &location ) ;
		OSErr err = noErr ;

		mDefaultLocation.descriptorType = typeNull;
		mDefaultLocation.dataHandle     = nil;

		err = ::AECreateDesc(typeFSS, &location, sizeof(FSSpec), &mDefaultLocation );

		if ( mDefaultLocation.dataHandle ) {

			if (mSelectDefault) {
				mNavOptions.dialogOptionFlags |= kNavSelectDefaultLocation;
			} else {
				mNavOptions.dialogOptionFlags &= ~kNavSelectDefaultLocation;
			}
		}

#if TARGET_CARBON
		c2pstrcpy((StringPtr)mNavOptions.message, m_message) ;
#else
		strcpy((char *)mNavOptions.message, m_message) ;
		c2pstr((char *)mNavOptions.message ) ;
#endif
#if TARGET_CARBON
		c2pstrcpy((StringPtr)mNavOptions.savedFileName, m_fileName) ;
#else
		strcpy((char *)mNavOptions.savedFileName, m_fileName) ;
		c2pstr((char *)mNavOptions.savedFileName ) ;
#endif

		if ( m_dialogStyle & wxSAVE )
		{

			mNavOptions.dialogOptionFlags |= kNavNoTypePopup ;
			mNavOptions.dialogOptionFlags |= kNavDontAutoTranslate ;
			mNavOptions.dialogOptionFlags |= kNavDontAddTranslateItems ;

			err = ::NavPutFile(
						&mDefaultLocation,
						&mNavReply,
						&mNavOptions,
						sStandardNavEventFilter ,
						'TEXT',
						'TEXT',
						0L);					// User Data
		}
		else
		{
			if ( m_dialogStyle & wxMULTIPLE )
				mNavOptions.dialogOptionFlags |= kNavAllowMultipleFiles ;
			else
				mNavOptions.dialogOptionFlags &= ~kNavAllowMultipleFiles ;

		 	err = ::NavGetFile(
						&mDefaultLocation,
						&mNavReply,
						&mNavOptions,
						sStandardNavEventFilter ,
						mNavPreviewUPP,
						mNavFilterUPP,
						0L /*inFileTypes.TypeListHandle() */,
						0L);							// User Data
		}

		if ( mDefaultLocation.dataHandle != nil )
		{
			::AEDisposeDesc(&mDefaultLocation);
		}

		if ( (err != noErr) && (err != userCanceledErr) ) {
			m_path = "" ;
			return wxID_CANCEL ;
		}

		if (mNavReply.validRecord) {

			FSSpec  outFileSpec ;
			AEDesc specDesc ;

			long count ;
			::AECountItems( &mNavReply.selection , &count ) ;
			for ( long i = 1 ; i <= count ; ++i )
			{
				OSErr err = ::AEGetNthDesc( &mNavReply.selection , i , typeFSS, NULL , &specDesc);
				if ( err != noErr ) {
					m_path = "" ;
					return wxID_CANCEL ;
				}
				outFileSpec = **(FSSpec**) specDesc.dataHandle;
				if (specDesc.dataHandle != nil) {
					::AEDisposeDesc(&specDesc);
				}


				// outFolderDirID = thePB.dirInfo.ioDrDirID;
				m_path = wxMacFSSpec2UnixFilename( &outFileSpec ) ;
				m_paths.Add( m_path ) ;
	            m_fileNames.Add(m_fileName);
	         }
	         // set these to the first hit
	         m_path = m_paths[ 0 ] ;
	         m_fileName = wxFileNameFromPath(m_path);
	         m_dir = wxPathOnly(m_path);

			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
	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/app.h"
	18	#include "wx/utils.h"
	19	#include "wx/dialog.h"
	20	#include "wx/filedlg.h"
	21	#include "wx/intl.h"
	22
	23	#if !defined(__UNIX__)
	24	#include "PLStringFuncs.h"
	25	#endif
	26
	27	#if !USE_SHARED_LIBRARY
	28	IMPLEMENT_CLASS(wxFileDialog, wxDialog)
	29	#endif
	30
	31	// begin wxmac
	32
	33	#if defined(__UNIX__)
	34	#include <Carbon/Carbon.h>
	35	#else
	36	#include <Navigation.h>
	37	#endif
	38
	39	#ifndef __UNIX__
	40	#include "morefile.h"
	41	#include "moreextr.h"
	42	#include "fullpath.h"
	43	#include "fspcompa.h"
	44	#include "PLStringFuncs.h"
	45	#endif
	46
	47	extern bool gUseNavServices ;
	48
	49	static pascal void NavEventProc(
	50	NavEventCallbackMessage inSelector,
	51	NavCBRecPtr ioParams,
	52	NavCallBackUserData ioUserData);
	53
	54	#if TARGET_CARBON
	55	static NavEventUPP sStandardNavEventFilter = NewNavEventUPP(NavEventProc);
	56	#else
	57	static NavEventUPP sStandardNavEventFilter = NewNavEventProc(NavEventProc);
	58	#endif
	59
	60	static pascal void
	61	NavEventProc(
	62	NavEventCallbackMessage inSelector,
	63	NavCBRecPtr ioParams,
	64	NavCallBackUserData /* ioUserData */)
	65	{
	66	if (inSelector == kNavCBEvent) {
	67	// In Universal Headers 3.2, Apple changed the definition of
	68	/*
	69	#if UNIVERSAL_INTERFACES_VERSION >= 0x0320 // Universal Headers 3.2
	70	UModalAlerts::ProcessModalEvent(*(ioParams->eventData.eventDataParms.event));
	71
	72	#else
	73	UModalAlerts::ProcessModalEvent(*(ioParams->eventData.event));
	74	#endif
	75	*/
	76
	77	wxTheApp->MacHandleOneEvent(ioParams->eventData.eventDataParms.event);
	78	}
	79	}
	80
	81	char * gfilters[] =
	82	{
	83	"*.TXT" ,
	84
	85	NULL
	86	} ;
	87
	88	OSType gfiltersmac[] =
	89	{
	90	'TEXT' ,
	91
	92	'****'
	93	} ;
	94
	95	// the data we need to pass to our standard file hook routine
	96	// includes a pointer to the dialog, a pointer to the standard
	97	// file reply record (so we can inspect the current selection)
	98	// and a copy of the "previous" file spec of the reply record
	99	// so we can see if the selection has changed
	100
	101	const int kwxMacFileTypes = 10 ;
	102
	103	struct OpenUserDataRec {
	104	StandardFileReply *sfrPtr;
	105	FSSpec oldSelectionFSSpec;
	106	char filter[kwxMacFileTypes][10] ;
	107	OSType filtermactypes[kwxMacFileTypes] ;
	108	int numfilters ;
	109	DialogPtr theDlgPtr;
	110	};
	111	typedef struct OpenUserDataRec
	112	OpenUserDataRec, *OpenUserDataRecPtr;
	113
	114	#if !TARGET_CARBON
	115
	116	static void wxMacSetupStandardFile(short newVRefNum, long newDirID)
	117	{
	118	enum
	119	{ SFSaveDisk = 0x214, CurDirStore = 0x398 };
	120	(short ) SFSaveDisk = -1 * newVRefNum;
	121	(long ) CurDirStore = newDirID;
	122	}
	123
	124	static void wxMacSetupStandardFileFromPath( const char* s )
	125	{
	126	Str255 volume ;
	127	Str255 path ;
	128	short vRefNum ;
	129	long dirRef ;
	130	short i,j ;
	131	Boolean isDirectory ;
	132
	133	for (i=0 ; (s[i]!=0) && (s[i]!=':') ;i++)
	134	{
	135	volume[i]=s[i] ;
	136	}
	137	volume[i]=':' ;
	138	volume[i+1]=0 ;
	139
	140	// then copy the rest of the filename
	141
	142	for (j=0;(s[i]!=0);i++,j++)
	143	{
	144	path[j]=s[i] ;
	145	}
	146	path[j]=0 ;
	147
	148	c2pstr((Ptr) volume) ;
	149	c2pstr((Ptr) path) ;
	150
	151	SetVol(volume, 0) ;
	152	GetVol( NULL, &vRefNum ) ;
	153
	154	GetDirectoryID( vRefNum , fsRtDirID , path , &dirRef , &isDirectory ) ;
	155	wxMacSetupStandardFile(vRefNum, dirRef) ;
	156	}
	157
	158	enum {
	159	kSelectItem = 10, // select button item number
	160	kSFGetFileDlgID = 251, // dialog resource number
	161	kStrListID = 251, // our strings
	162	kSelectStrNum = 1, // word 'Select: ' for button
	163	kDesktopStrNum = 2, // word 'Desktop' for button
	164	kSelectNoQuoteStrNum = 3, // word 'Select: ' for button
	165
	166	kUseQuotes = true, // parameter for SetButtonName
	167	kDontUseQuotes = false
	168	};
	169
	170	static void GetLabelString(StringPtr theStr, short stringNum)
	171	{
	172	GetIndString(theStr, kStrListID, stringNum);
	173	}
	174
	175	static void CopyPStr(StringPtr src, StringPtr dest)
	176	{
	177	BlockMoveData(src, dest, 1 + src[0]);
	178	}
	179
	180	static char GetSelectKey(void)
	181	{
	182	// this is the key used to trigger the select button
	183
	184	// NOT INTERNATIONAL SAVVY; should at least grab it from resources
	185
	186	return 's';
	187	}
	188
	189	// FlashButton briefly highlights the dialog button
	190	// as feedback for key equivalents
	191
	192	static void FlashButton(DialogPtr theDlgPtr, short buttonID)
	193	{
	194	short buttonType;
	195	Handle buttonHandle;
	196	Rect buttonRect;
	197	unsigned long finalTicks;
	198
	199	GetDialogItem(theDlgPtr, buttonID, &buttonType, &buttonHandle, &buttonRect);
	200	HiliteControl((ControlHandle) buttonHandle, kControlButtonPart);
	201	Delay(10, &finalTicks);
	202	HiliteControl((ControlHandle) buttonHandle, 0);
	203	}
	204
	205	static Boolean SameFSSpec(FSSpecPtr spec1, FSSpecPtr spec2)
	206	{
	207	return (spec1->vRefNum == spec2->vRefNum
	208	&& spec1->parID == spec2->parID
	209	&& EqualString(spec1->name, spec2->name, false, false));
	210	}
	211	// MyModalDialogFilter maps a key to the Select button, and handles
	212	// flashing of the button when the key is hit
	213
	214	static pascal Boolean SFGetFolderModalDialogFilter(DialogPtr theDlgPtr, EventRecord *eventRec,
	215	short item, void dataPtr)
	216	{
	217	#pragma unused (dataPtr)
	218
	219	// make certain the proper dialog is showing, 'cause standard file
	220	// can nest dialogs but calls the same filter for each
	221
	222	if (((WindowPeek) theDlgPtr)->refCon == sfMainDialogRefCon)
	223	{
	224	// check if the select button was hit
	225	/*
	226	if ((eventRec->what == keyDown)
	227	&& (eventRec->modifiers & cmdKey)
	228	&& ((eventRec->message & charCodeMask) == GetSelectKey()))
	229	{
	230	*item = kSelectItem;
	231	FlashButton(theDlgPtr, kSelectItem);
	232	return true;
	233	}
	234	*/
	235	}
	236
	237	return false;
	238	}
	239	#endif !TARGET_CARBON
	240
	241	void ExtendedOpenFile( ConstStr255Param message , ConstStr255Param path , const char filter , FileFilterYDUPP fileFilter, StandardFileReply theSFR)
	242	{
	243	Point thePt;
	244	OpenUserDataRec myData;
	245	FSSpec tempSpec;
	246	Boolean folderFlag;
	247	Boolean wasAliasedFlag;
	248	DlgHookYDUPP dlgHookUPP;
	249	ModalFilterYDUPP myModalFilterUPP;
	250	OSErr err;
	251	SFTypeList types ;
	252
	253
	254	// presumably we're running System 7 or later so CustomGetFile is
	255	// available
	256
	257	// set initial contents of Select button to a space
	258
	259	memcpy( theSFR->sfFile.name , "\p " , 2 ) ;
	260
	261	// point the user data parameter at the reply record so we can get to it later
	262
	263	myData.sfrPtr = theSFR;
	264	if ( filter && filter[0] )
	265	{
	266	myData.numfilters = 1 ;
	267	for ( int i = 0 ; i < myData.numfilters ; i++ )
	268	{
	269	int j ;
	270
	271	strcpy( myData.filter[i] , filter ) ;
	272	for( j = 0 ; myData.filter[i][j] ; j++ )
	273	{
	274	myData.filter[i][j] = toupper( myData.filter[i][j] ) ;
	275	}
	276	for ( j = 0 ; gfilters[j] ; j++ )
	277	{
	278	if ( strcmp( myData.filter[i] , gfilters[j] ) == 0 )
	279	{
	280	myData.filtermactypes[i] = gfiltersmac[j] ;
	281	break ;
	282	}
	283	}
	284	if( gfilters[j] == NULL )
	285	{
	286	myData.filtermactypes[i] = '****' ;
	287	}
	288	}
	289	}
	290	else
	291	{
	292	myData.numfilters = 0 ;
	293	}
	294	// display the dialog
	295
	296	#if !TARGET_CARBON
	297
	298	dlgHookUPP = NULL ;
	299	// dlgHookUPP = NewDlgHookYDProc(SFGetFolderDialogHook);
	300	myModalFilterUPP = NewModalFilterYDProc(SFGetFolderModalDialogFilter);
	301
	302	thePt.h = thePt.v = -1; // center dialog
	303
	304	ParamText( message , NULL , NULL , NULL ) ;
	305
	306	CustomGetFile( fileFilter,
	307	-1, // show all types
	308	NULL,
	309	theSFR,
	310	kSFGetFileDlgID,
	311	thePt, // top left point
	312	dlgHookUPP,
	313	myModalFilterUPP,
	314	nil, // activate list
	315	nil, // activate proc
	316	&myData);
	317
	318	DisposeRoutineDescriptor(dlgHookUPP);
	319	DisposeRoutineDescriptor(myModalFilterUPP);
	320	#else
	321	#endif
	322	// if cancel wasn't pressed and no fatal error occurred...
	323
	324	if (theSFR->sfGood)
	325	{
	326	// if no name is in the reply record file spec,
	327	// use the file spec of the parent folder
	328
	329	if (theSFR->sfFile.name[0] == '\0')
	330	{
	331	err = FSMakeFSSpec(theSFR->sfFile.vRefNum, theSFR->sfFile.parID,
	332	"\p", &tempSpec);
	333	if (err == noErr)
	334	{
	335	theSFR->sfFile = tempSpec;
	336	}
	337	else
	338	{
	339	// no name to return, forget it
	340
	341	theSFR->sfGood = false;
	342	}
	343	}
	344
	345	// if there is now a name in the file spec, check if it's
	346	// for a folder or a volume
	347
	348	if (theSFR->sfFile.name[0] != '\0')
	349	{
	350	// the parID of the root of a disk is always fsRtParID == 1
	351
	352	if (theSFR->sfFile.parID == fsRtParID)
	353	{
	354	theSFR->sfIsVolume = true;
	355	theSFR->sfIsFolder = false; // it would be reasonable for this to be true, too
	356	}
	357
	358	// we have a valid FSSpec, now let's make sure it's not for an alias file
	359
	360	err = ResolveAliasFile(&theSFR->sfFile, true, &folderFlag, &wasAliasedFlag);
	361	if (err != noErr)
	362	{
	363	theSFR->sfGood = false;
	364	}
	365
	366	// did the alias resolve to a folder?
	367
	368	if (folderFlag && ! theSFR->sfIsVolume)
	369	{
	370	theSFR->sfIsFolder = true;
	371	}
	372	}
	373	}
	374	}
	375
	376	static pascal Boolean CrossPlatformFileFilter(CInfoPBPtr myCInfoPBPtr, void *dataPtr)
	377	{
	378	Str255 filename ;
	379	OpenUserDataRecPtr data = (OpenUserDataRecPtr) dataPtr ;
	380	// return true if this item is invisible or a file
	381
	382	Boolean visibleFlag;
	383	Boolean folderFlag;
	384
	385	visibleFlag = ! (myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible);
	386	folderFlag = (myCInfoPBPtr->hFileInfo.ioFlAttrib & 0x10);
	387
	388	// because the semantics of the filter proc are "true means don't show
	389	// it" we need to invert the result that we return
	390
	391	if ( !visibleFlag )
	392	return true ;
	393
	394	if ( !folderFlag )
	395	{
	396	if ( data->numfilters > 0 )
	397	{
	398	PLstrcpy( filename ,myCInfoPBPtr->hFileInfo.ioNamePtr ) ;
	399	if ( filename[0] >= 4 )
	400	{
	401	for( int j = 1 ; j <= filename[0] ; j++ )
	402	{
	403	filename[j] = toupper( filename[j] ) ;
	404	}
	405	for ( int i = 0 ; i < data->numfilters ; ++i )
	406	{
	407	if ( myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdType == data->filtermactypes[i] )
	408	return false ;
	409
	410	if ( strncmp( (char*) filename + 1 + filename[0] - 4 ,
	411	& data->filter[i][ strlen(data->filter[i]) - 4 ] , 4 ) == 0 )
	412	return false ;
	413	}
	414	}
	415	return true ;
	416	}
	417	}
	418
	419	return false ;
	420	}
	421
	422	// end wxmac
	423
	424	wxString wxFileSelector(const char *title,
	425	const char defaultDir, const char defaultFileName,
	426	const char defaultExtension, const char filter, int flags,
	427	wxWindow *parent, int x, int y)
	428	{
	429	// If there's a default extension specified but no filter, we create a suitable
	430	// filter.
	431
	432	wxString filter2("");
	433	if ( defaultExtension && !filter )
	434	filter2 = wxString("*.") + wxString(defaultExtension) ;
	435	else if ( filter )
	436	filter2 = filter;
	437
	438	wxString defaultDirString;
	439	if (defaultDir)
	440	defaultDirString = defaultDir;
	441	else
	442	defaultDirString = "";
	443
	444	wxString defaultFilenameString;
	445	if (defaultFileName)
	446	defaultFilenameString = defaultFileName;
	447	else
	448	defaultFilenameString = "";
	449
	450	wxFileDialog fileDialog(parent, title, defaultDirString, defaultFilenameString, filter2, flags, wxPoint(x, y));
	451
	452	if ( fileDialog.ShowModal() == wxID_OK )
	453	{
	454	strcpy(wxBuffer, (const char *)fileDialog.GetPath());
	455	return wxBuffer;
	456	}
	457	else
	458	return wxGetEmptyString();
	459	}
	460
	461	WXDLLEXPORT wxString wxFileSelectorEx(const char *title,
	462	const char *defaultDir,
	463	const char *defaultFileName,
	464	int* defaultFilterIndex,
	465	const char *filter,
	466	int flags,
	467	wxWindow* parent,
	468	int x,
	469	int y)
	470
	471	{
	472	wxFileDialog fileDialog(parent, title ? title : "", defaultDir ? defaultDir : "",
	473	defaultFileName ? defaultFileName : "", filter ? filter : "", flags, wxPoint(x, y));
	474
	475	if ( fileDialog.ShowModal() == wxID_OK )
	476	{
	477	*defaultFilterIndex = fileDialog.GetFilterIndex();
	478	strcpy(wxBuffer, (const char *)fileDialog.GetPath());
	479	return wxBuffer;
	480	}
	481	else
	482	return wxGetEmptyString();
	483	}
	484
	485	wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
	486	const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
	487	long style, const wxPoint& pos)
	488	{
	489	m_message = message;
	490	m_dialogStyle = style;
	491	m_parent = parent;
	492	m_path = "";
	493	m_fileName = defaultFileName;
	494	m_dir = defaultDir;
	495	m_wildCard = wildCard;
	496	m_filterIndex = 1;
	497	}
	498
	499	int wxFileDialog::ShowModal()
	500	{
	501	#if !TARGET_CARBON
	502	if ( !gUseNavServices )
	503	{
	504	if ( m_dialogStyle & wxSAVE )
	505	{
	506	StandardFileReply reply ;
	507	Str255 prompt ;
	508	Str255 filename ;
	509
	510	#if TARGET_CARBON
	511	c2pstrcpy((StringPtr)prompt, m_message) ;
	512	#else
	513	strcpy((char *)prompt, m_message) ;
	514	c2pstr((char *)prompt ) ;
	515	#endif
	516	#if TARGET_CARBON
	517	c2pstrcpy((StringPtr)filename, m_fileName) ;
	518	#else
	519	strcpy((char *)filename, m_fileName) ;
	520	c2pstr((char *)filename ) ;
	521	#endif
	522
	523	#if !TARGET_CARBON
	524
	525	StandardPutFile( prompt , filename , &reply ) ;
	526
	527	#else
	528	#endif
	529	if ( reply.sfGood == false )
	530	{
	531	m_path = "" ;
	532	return wxID_CANCEL ;
	533	}
	534	else
	535	{
	536	m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
	537	return wxID_OK ;
	538	}
	539	}
	540	else
	541	{
	542	OSType types = '????' ;
	543	Str255 prompt ;
	544	Str255 path ;
	545
	546	#if TARGET_CARBON
	547	c2pstrcpy((StringPtr)prompt, m_message) ;
	548	#else
	549	strcpy((char *)prompt, m_message) ;
	550	c2pstr((char *)prompt ) ;
	551	#endif
	552	#if TARGET_CARBON
	553	c2pstrcpy((StringPtr)path, m_dir ) ;
	554	#else
	555	strcpy((char *)path, m_dir ) ;
	556	c2pstr((char *)path ) ;
	557	#endif
	558
	559	StandardFileReply reply ;
	560	FileFilterYDUPP crossPlatformFileFilterUPP = 0 ;
	561	#if !TARGET_CARBON
	562	crossPlatformFileFilterUPP =
	563	NewFileFilterYDProc(CrossPlatformFileFilter);
	564	#endif
	565
	566	ExtendedOpenFile( prompt , path , m_wildCard , crossPlatformFileFilterUPP, &reply);
	567	#if !TARGET_CARBON
	568	DisposeFileFilterYDUPP(crossPlatformFileFilterUPP);
	569	#endif
	570	if ( reply.sfGood == false )
	571	{
	572	m_path = "" ;
	573	return wxID_CANCEL ;
	574	}
	575	else
	576	{
	577	m_path = wxMacFSSpec2UnixFilename( &reply.sfFile ) ;
	578	return wxID_OK ;
	579	}
	580	}
	581	return wxID_CANCEL;
	582	}
	583	else
	584	#endif
	585	{
	586	NavDialogOptions mNavOptions;
	587	NavObjectFilterUPP mNavFilterUPP = NULL;
	588	NavPreviewUPP mNavPreviewUPP = NULL ;
	589	NavReplyRecord mNavReply;
	590	AEDesc mDefaultLocation ;
	591	bool mSelectDefault = false ;
	592
	593	::NavGetDefaultDialogOptions(&mNavOptions);
	594
	595	mNavFilterUPP = nil;
	596	mNavPreviewUPP = nil;
	597	mSelectDefault = false;
	598	mNavReply.validRecord = false;
	599	mNavReply.replacing = false;
	600	mNavReply.isStationery = false;
	601	mNavReply.translationNeeded = false;
	602	mNavReply.selection.descriptorType = typeNull;
	603	mNavReply.selection.dataHandle = nil;
	604	mNavReply.keyScript = smSystemScript;
	605	mNavReply.fileTranslation = nil;
	606
	607	// Set default location, the location
	608	// that's displayed when the dialog
	609	// first appears
	610
	611	FSSpec location ;
	612	wxUnixFilename2FSSpec( m_dir , &location ) ;
	613	OSErr err = noErr ;
	614
	615	mDefaultLocation.descriptorType = typeNull;
	616	mDefaultLocation.dataHandle = nil;
	617
	618	err = ::AECreateDesc(typeFSS, &location, sizeof(FSSpec), &mDefaultLocation );
	619
	620	if ( mDefaultLocation.dataHandle ) {
	621
	622	if (mSelectDefault) {
	623	mNavOptions.dialogOptionFlags \|= kNavSelectDefaultLocation;
	624	} else {
	625	mNavOptions.dialogOptionFlags &= ~kNavSelectDefaultLocation;
	626	}
	627	}
	628
	629	#if TARGET_CARBON
	630	c2pstrcpy((StringPtr)mNavOptions.message, m_message) ;
	631	#else
	632	strcpy((char *)mNavOptions.message, m_message) ;
	633	c2pstr((char *)mNavOptions.message ) ;
	634	#endif
	635	#if TARGET_CARBON
	636	c2pstrcpy((StringPtr)mNavOptions.savedFileName, m_fileName) ;
	637	#else
	638	strcpy((char *)mNavOptions.savedFileName, m_fileName) ;
	639	c2pstr((char *)mNavOptions.savedFileName ) ;
	640	#endif
	641
	642	if ( m_dialogStyle & wxSAVE )
	643	{
	644
	645	mNavOptions.dialogOptionFlags \|= kNavNoTypePopup ;
	646	mNavOptions.dialogOptionFlags \|= kNavDontAutoTranslate ;
	647	mNavOptions.dialogOptionFlags \|= kNavDontAddTranslateItems ;
	648
	649	err = ::NavPutFile(
	650	&mDefaultLocation,
	651	&mNavReply,
	652	&mNavOptions,
	653	sStandardNavEventFilter ,
	654	'TEXT',
	655	'TEXT',
	656	0L); // User Data
	657	}
	658	else
	659	{
	660	if ( m_dialogStyle & wxMULTIPLE )
	661	mNavOptions.dialogOptionFlags \|= kNavAllowMultipleFiles ;
	662	else
	663	mNavOptions.dialogOptionFlags &= ~kNavAllowMultipleFiles ;
	664
	665	err = ::NavGetFile(
	666	&mDefaultLocation,
	667	&mNavReply,
	668	&mNavOptions,
	669	sStandardNavEventFilter ,
	670	mNavPreviewUPP,
	671	mNavFilterUPP,
	672	0L /inFileTypes.TypeListHandle() /,
	673	0L); // User Data
	674	}
	675
	676	if ( mDefaultLocation.dataHandle != nil )
	677	{
	678	::AEDisposeDesc(&mDefaultLocation);
	679	}
	680
	681	if ( (err != noErr) && (err != userCanceledErr) ) {
	682	m_path = "" ;
	683	return wxID_CANCEL ;
	684	}
	685
	686	if (mNavReply.validRecord) {
	687
	688	FSSpec outFileSpec ;
	689	AEDesc specDesc ;
	690
	691	long count ;
	692	::AECountItems( &mNavReply.selection , &count ) ;
	693	for ( long i = 1 ; i <= count ; ++i )
	694	{
	695	OSErr err = ::AEGetNthDesc( &mNavReply.selection , i , typeFSS, NULL , &specDesc);
	696	if ( err != noErr ) {
	697	m_path = "" ;
	698	return wxID_CANCEL ;
	699	}
	700	outFileSpec = (FSSpec) specDesc.dataHandle;
	701	if (specDesc.dataHandle != nil) {
	702	::AEDisposeDesc(&specDesc);
	703	}
	704
	705
	706	// outFolderDirID = thePB.dirInfo.ioDrDirID;
	707	m_path = wxMacFSSpec2UnixFilename( &outFileSpec ) ;
	708	m_paths.Add( m_path ) ;
	709	m_fileNames.Add(m_fileName);
	710	}
	711	// set these to the first hit
	712	m_path = m_paths[ 0 ] ;
	713	m_fileName = wxFileNameFromPath(m_path);
	714	m_dir = wxPathOnly(m_path);
	715
	716	return wxID_OK ;
	717	}
	718	return wxID_CANCEL;
	719	}
	720	}
	721
	722	// Generic file load/save dialog
	723	static wxString
	724	wxDefaultFileSelector(bool load, const char what, const char extension, const char default_name, wxWindow parent)
	725	{
	726	char ext = (char )extension;
	727
	728	char prompt[50];
	729	wxString str;
	730	if (load)
	731	str = "Load %s file";
	732	else
	733	str = "Save %s file";
	734	sprintf(prompt, wxGetTranslation(str), what);
	735
	736	if (*ext == '.') ext++;
	737	char wild[60];
	738	sprintf(wild, "*.%s", ext);
	739
	740	return wxFileSelector (prompt, NULL, default_name, ext, wild, 0, parent);
	741	}
	742
	743	// Generic file load dialog
	744	wxString
	745	wxLoadFileSelector(const char what, const char extension, const char default_name, wxWindow parent)
	746	{
	747	return wxDefaultFileSelector(TRUE, what, extension, default_name, parent);
	748	}
	749
	750
	751	// Generic file save dialog
	752	wxString
	753	wxSaveFileSelector(const char what, const char extension, const char default_name, wxWindow parent)
	754	{
	755	return wxDefaultFileSelector(FALSE, what, extension, default_name, parent);
	756	}
	757
	758