src/mac/carbon/filedlg.cpp

/////////////////////////////////////////////////////////////////////////////
// Name:        filedlg.cpp
// Purpose:     wxFileDialog
// Author:      Stefan Csomor
// Modified by:
// Created:     1998-01-01
// RCS-ID:      $Id$
// Copyright:   (c) Stefan Csomor
// 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"
#include "wx/tokenzr.h"
#include "wx/filename.h"

#ifndef __DARWIN__
  #include "PLStringFuncs.h"
#endif

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

// begin wxmac

#include "wx/mac/private.h"

#include <Navigation.h>

#ifdef __DARWIN__
#  include "MoreFilesX.h"
#else
#  include "MoreFiles.h"
#  include "MoreFilesExtras.h"
#endif

extern bool gUseNavServices ;

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

struct OpenUserDataRec {
  int                currentfilter ;
  bool               saveMode ;
  wxArrayString      name ;
  wxArrayString      extensions ;
  wxArrayLong        filtermactypes ;
  wxString           defaultLocation;
#if TARGET_CARBON
  CFArrayRef         menuitems ;
#else
  NavMenuItemSpecArrayHandle menuitems ;
#endif
};

typedef struct OpenUserDataRec
OpenUserDataRec, *OpenUserDataRecPtr;

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    )
{
    OpenUserDataRec * data = ( OpenUserDataRec *) ioUserData ;
    if (inSelector == kNavCBEvent) {
#if TARGET_CARBON
#else
        wxTheApp->MacHandleOneEvent(ioParams->eventData.eventDataParms.event);
#endif
    }
    else if ( inSelector == kNavCBStart )
    {
#if TARGET_CARBON
        if (data && !(data->defaultLocation).IsEmpty())
        {
            // Set default location for the modern Navigation APIs
            // Apple Technical Q&A 1151
            FSSpec theFSSpec;
            wxMacFilename2FSSpec(data->defaultLocation, &theFSSpec);
            AEDesc theLocation = {typeNull, NULL};
            if (noErr == ::AECreateDesc(typeFSS, &theFSSpec, sizeof(FSSpec), &theLocation))
                ::NavCustomControl(ioParams->context, kNavCtlSetLocation, (void *) &theLocation);
        }

        NavMenuItemSpec  menuItem;
        menuItem.version = kNavMenuItemSpecVersion;
        menuItem.menuCreator = 'WXNG';
        menuItem.menuType = data->currentfilter;
        wxMacStringToPascal( data->name[data->currentfilter] , (StringPtr)(menuItem.menuItemName) ) ;
        ::NavCustomControl(ioParams->context, kNavCtlSelectCustomType, &menuItem);

#else
        if ( data->menuitems )
            NavCustomControl(ioParams->context, kNavCtlSelectCustomType, &(*data->menuitems)[data->currentfilter]);
#endif
    }
    else if ( inSelector == kNavCBPopupMenuSelect )
    {
        NavMenuItemSpec * menu = (NavMenuItemSpec *) ioParams->eventData.eventDataParms.param ;
#if TARGET_CARBON
        const size_t numFilters = data->extensions.GetCount();

        if ( menu->menuType < numFilters )
#else
        if ( menu->menuCreator == 'WXNG' )
#endif
        {
            data->currentfilter = menu->menuType ;
            if ( data->saveMode )
            {
                int i = menu->menuType ;
                wxString extension =  data->extensions[i].AfterLast('.') ;
                extension.MakeLower() ;
                wxString sfilename ;

#if TARGET_CARBON
                wxMacCFStringHolder cfString( NavDialogGetSaveFileName( ioParams->context ) , false  );
                sfilename = cfString.AsString() ;
#else
                Str255 filename ;
                // get the current filename
                NavCustomControl(ioParams->context, kNavCtlGetEditFileName, &filename);
                sfilename = wxMacMakeStringFromPascal( filename ) ;
#endif

                int pos = sfilename.Find('.', true) ;
                if ( pos != wxNOT_FOUND )
                {
                    sfilename = sfilename.Left(pos+1)+extension ;
#if TARGET_CARBON
                    cfString.Assign( sfilename , wxFONTENCODING_DEFAULT ) ;
                    NavDialogSetSaveFileName( ioParams->context , cfString ) ;
#else
                    wxMacStringToPascal( sfilename , filename ) ;
                    NavCustomControl(ioParams->context, kNavCtlSetEditFileName, &filename);
#endif
                }
            }
        }
    }
}


void MakeUserDataRec(OpenUserDataRec    *myData , const wxString& filter )
{
    myData->menuitems = NULL ;
    myData->currentfilter = 0 ;
    myData->saveMode = false ;

    if ( filter && filter[0] )
    {
        wxString filter2(filter) ;
        int filterIndex = 0;
        bool isName = true ;
        wxString current ;
        for( unsigned int i = 0; i < filter2.Len() ; i++ )
        {
            if( filter2.GetChar(i) == wxT('|') )
            {
                if( isName ) {
                    myData->name.Add( current ) ;
                }
                else {
                    myData->extensions.Add( current.MakeUpper() ) ;
                    ++filterIndex ;
                }
                isName = !isName ;
                current = wxEmptyString ;
            }
            else
            {
                current += filter2.GetChar(i) ;
            }
        }
        // we allow for compatibility reason to have a single filter expression (like *.*) without
        // an explanatory text, in that case the first part is name and extension at the same time

        wxASSERT_MSG( filterIndex == 0 || !isName , wxT("incorrect format of format string") ) ;
        if ( current.IsEmpty() )
            myData->extensions.Add( myData->name[filterIndex] ) ;
        else
            myData->extensions.Add( current.MakeUpper() ) ;
        if ( filterIndex == 0 || isName )
            myData->name.Add( current.MakeUpper() ) ;

        ++filterIndex ;

        const size_t extCount = myData->extensions.GetCount();
        for ( size_t i = 0 ; i < extCount; i++ )
        {
            wxUint32 fileType;
            wxUint32 creator;
            wxString extension = myData->extensions[i];

            if (extension.GetChar(0) == '*')
                extension = extension.Mid(1);	// Remove leading *

            if (extension.GetChar(0) == '.')
            {
                extension = extension.Mid(1);	// Remove leading .
            }

            if (wxFileName::MacFindDefaultTypeAndCreator( extension, &fileType, &creator ))
            {
                myData->filtermactypes.Add( (OSType)fileType );
            }
            else
            {
                myData->filtermactypes.Add( '****' ) ;		// We'll fail safe if it's not recognized
        	}
        }
    }
}

static Boolean CheckFile( const wxString &filename , OSType type , OpenUserDataRecPtr data)
{
    wxString file(filename) ;
    file.MakeUpper() ;

    if ( data->extensions.GetCount() > 0 )
    {
        //for ( int i = 0 ; i < data->numfilters ; ++i )
        int i = data->currentfilter ;
        if ( data->extensions[i].Right(2) == wxT(".*") )
            return true ;

        {
            if ( type == (OSType)data->filtermactypes[i] )
                return true ;

            wxStringTokenizer tokenizer( data->extensions[i] , wxT(";") ) ;
            while( tokenizer.HasMoreTokens() )
            {
                wxString extension = tokenizer.GetNextToken() ;
                if ( extension.GetChar(0) == '*' )
                    extension = extension.Mid(1) ;

                if ( file.Len() >= extension.Len() && extension == file.Right(extension.Len() ) )
                    return true ;
            }
        }
        return false ;
    }
    return true ;
}

#ifndef __DARWIN__
static pascal Boolean CrossPlatformFileFilter(CInfoPBPtr myCInfoPBPtr, void *dataPtr)
{
    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 )
    {
        wxString file = wxMacMakeStringFromPascal( myCInfoPBPtr->hFileInfo.ioNamePtr ) ;
        return !CheckFile( file , myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdType , data ) ;
    }

    return false ;
}
#endif

// end wxmac

wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
        const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
        long style, const wxPoint& pos)
             :wxFileDialogBase(parent, message, defaultDir, defaultFileName, wildCard, style, pos)
{
    wxASSERT_MSG( NavServicesAvailable() , wxT("Navigation Services are not running") ) ;
}

pascal Boolean CrossPlatformFilterCallback (
    AEDesc *theItem,
    void *info,
    void *callBackUD,
    NavFilterModes filterMode
)
{
    bool display = true;
    OpenUserDataRecPtr data = (OpenUserDataRecPtr) callBackUD ;

    if (filterMode == kNavFilteringBrowserList)
    {
        NavFileOrFolderInfo* theInfo = (NavFileOrFolderInfo*) info ;
        if ( !theInfo->isFolder )
        {
            if (theItem->descriptorType == typeFSS )
            {
                FSSpec    spec;
                memcpy( &spec , *theItem->dataHandle , sizeof(FSSpec) ) ;
                wxString file = wxMacMakeStringFromPascal( spec.name ) ;
                display = CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
            }
 #if TARGET_CARBON
            else if ( theItem->descriptorType == typeFSRef )
            {
                FSRef fsref ;
                memcpy( &fsref , *theItem->dataHandle , sizeof(FSRef) ) ;


            	CFURLRef fullURLRef;
                fullURLRef = ::CFURLCreateFromFSRef(NULL, &fsref);
#ifdef __UNIX__
            	CFURLPathStyle pathstyle = kCFURLPOSIXPathStyle;
#else
            	CFURLPathStyle pathstyle = kCFURLHFSPathStyle;
#endif
            	CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, pathstyle);
            	::CFRelease( fullURLRef ) ;
            	wxString file = wxMacCFStringHolder(cfString).AsString(wxFont::GetDefaultEncoding());

                display = CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
            }
#endif
        }
    }

    return display;
}

int wxFileDialog::ShowModal()
{
#if TARGET_CARBON
    OSErr err;
    NavDialogCreationOptions dialogCreateOptions;
    // set default options
    ::NavGetDefaultDialogCreationOptions(&dialogCreateOptions);

    // this was always unset in the old code
    dialogCreateOptions.optionFlags &= ~kNavSelectDefaultLocation;

    wxMacCFStringHolder message(m_message, m_font.GetEncoding());
    dialogCreateOptions.windowTitle = message;

    wxMacCFStringHolder defaultFileName(m_fileName, m_font.GetEncoding());
    dialogCreateOptions.saveFileName = defaultFileName;


    NavDialogRef dialog;
    NavObjectFilterUPP navFilterUPP = NULL;
    CFArrayRef cfArray = NULL; // for popupExtension
    OpenUserDataRec myData;
    myData.defaultLocation = m_dir;

    MakeUserDataRec(&myData , m_wildCard);
    myData.currentfilter = m_filterIndex;
    size_t numFilters = myData.extensions.GetCount();
    if (numFilters)
    {
        CFMutableArrayRef popup = CFArrayCreateMutable( kCFAllocatorDefault ,
            numFilters , &kCFTypeArrayCallBacks ) ;
        dialogCreateOptions.popupExtension = popup ;
        myData.menuitems = dialogCreateOptions.popupExtension ;
        for ( size_t i = 0 ; i < numFilters ; ++i )
        {
            CFArrayAppendValue( popup , (CFStringRef) wxMacCFStringHolder( myData.name[i] , m_font.GetEncoding() ) ) ;
        }
    }

    if (m_dialogStyle & wxSAVE)
    {
        myData.saveMode = true;

        if (!numFilters)
        {
            dialogCreateOptions.optionFlags |= kNavNoTypePopup;
        }
        dialogCreateOptions.optionFlags |= kNavDontAutoTranslate;
        dialogCreateOptions.optionFlags |= kNavDontAddTranslateItems;

        // The extension is important
        if (numFilters < 2)
            dialogCreateOptions.optionFlags |= kNavPreserveSaveFileExtension;

#if TARGET_API_MAC_OSX
        if (!(m_dialogStyle & wxOVERWRITE_PROMPT))
        {
	        dialogCreateOptions.optionFlags |= kNavDontConfirmReplacement;
        }
#endif
        err = ::NavCreatePutFileDialog(&dialogCreateOptions,
                                       // Suppresses the 'Default' (top) menu item
                                       kNavGenericSignature, kNavGenericSignature,
                                       sStandardNavEventFilter,
                                       &myData, // for defaultLocation
                                       &dialog);
    }
    else
    {

        //let people select bundles/programs in dialogs
        dialogCreateOptions.optionFlags |= kNavSupportPackages;

        navFilterUPP = NewNavObjectFilterUPP(CrossPlatformFilterCallback);
        err = ::NavCreateGetFileDialog(&dialogCreateOptions,
                                       NULL, // NavTypeListHandle
                                       sStandardNavEventFilter,
                                       NULL, // NavPreviewUPP
                                       navFilterUPP,
                                       (void *) &myData, // inClientData
                                       &dialog);
    }

    if (err == noErr)
        err = ::NavDialogRun(dialog);

    // clean up filter related data, etc.
    if (navFilterUPP)
        ::DisposeNavObjectFilterUPP(navFilterUPP);
    if (cfArray)
        ::CFRelease(cfArray);

    if (err != noErr)
        return wxID_CANCEL;

    NavReplyRecord navReply;
    err = ::NavDialogGetReply(dialog, &navReply);
    if (err == noErr && navReply.validRecord)
    {
        AEKeyword   theKeyword;
        DescType    actualType;
        Size        actualSize;
        FSRef       theFSRef;
        wxString thePath ;

        m_filterIndex = myData.currentfilter ;

        long count;
        ::AECountItems(&navReply.selection , &count);
        for (long i = 1; i <= count; ++i)
        {
            err = ::AEGetNthPtr(&(navReply.selection), i, typeFSRef, &theKeyword, &actualType,
                                &theFSRef, sizeof(theFSRef), &actualSize);
            if (err != noErr)
                break;

            CFURLRef fullURLRef = 0 ;
            if (m_dialogStyle & wxSAVE)
            {
                CFURLRef parentURLRef = ::CFURLCreateFromFSRef(NULL, &theFSRef);

                if (parentURLRef)
                {
                    fullURLRef =
                        ::CFURLCreateCopyAppendingPathComponent(NULL,
                                                                parentURLRef,
                                                                navReply.saveFileName,
                                                                false);
                    ::CFRelease(parentURLRef);
                }
            }
            else
            {
                fullURLRef = ::CFURLCreateFromFSRef(NULL, &theFSRef);
            }
#ifdef __UNIX__
            CFURLPathStyle pathstyle = kCFURLPOSIXPathStyle;
#else
            CFURLPathStyle pathstyle = kCFURLHFSPathStyle;
#endif
            CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, pathstyle);
            thePath = wxMacCFStringHolder(cfString).AsString(m_font.GetEncoding());
            if (!thePath)
            {
                ::NavDisposeReply(&navReply);
                return wxID_CANCEL;
            }
            m_path = thePath;
            m_paths.Add(m_path);
            m_fileName = wxFileNameFromPath(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);
    }
    ::NavDisposeReply(&navReply);

    return (err == noErr) ? wxID_OK : wxID_CANCEL;
#else // TARGET_CARBON

    NavDialogOptions           mNavOptions;
    NavObjectFilterUPP           mNavFilterUPP = NULL;
    NavPreviewUPP           mNavPreviewUPP = NULL ;
    NavReplyRecord           mNavReply;
    AEDesc               mDefaultLocation ;
    bool               mSelectDefault = false ;
    OSStatus            err = noErr ;
    // setup dialog

    mNavFilterUPP    = nil;
    mNavPreviewUPP    = nil;
    mSelectDefault    = false;
    mDefaultLocation.descriptorType = typeNull;
    mDefaultLocation.dataHandle     = nil;

    NavGetDefaultDialogOptions(&mNavOptions);
    wxMacStringToPascal( m_message , (StringPtr)mNavOptions.message ) ;
    wxMacStringToPascal( m_fileName , (StringPtr)mNavOptions.savedFileName ) ;

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

    FSSpec location ;
    wxMacFilename2FSSpec( m_dir , &location ) ;

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

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

    memset( &mNavReply , 0 , sizeof( mNavReply ) ) ;
    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;
    mNavReply.version = kNavReplyRecordVersion ;

    // zero all data

    m_path = wxEmptyString ;
    m_fileName = wxEmptyString ;
    m_paths.Empty();
    m_fileNames.Empty();

    OpenUserDataRec            myData;
    MakeUserDataRec( &myData , m_wildCard ) ;
    myData.currentfilter = m_filterIndex ;
    if ( myData.extensions.GetCount() > 0 )
    {
        mNavOptions.popupExtension = (NavMenuItemSpecArrayHandle) NewHandle( sizeof( NavMenuItemSpec ) * myData.extensions.GetCount() ) ;
        myData.menuitems = mNavOptions.popupExtension ;
        for ( size_t i = 0 ; i < myData.extensions.GetCount() ; ++i )
        {
            (*mNavOptions.popupExtension)[i].version     = kNavMenuItemSpecVersion ;
            (*mNavOptions.popupExtension)[i].menuCreator = 'WXNG' ;
            // TODO : according to the new docs  -1 to 10 are reserved for the OS
            (*mNavOptions.popupExtension)[i].menuType    = i ;
            wxMacStringToPascal( myData.name[i] , (StringPtr)(*mNavOptions.popupExtension)[i].menuItemName ) ;
        }
    }
    if ( m_dialogStyle & wxSAVE )
    {
        myData.saveMode = true ;

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

        err = ::NavPutFile(
                           &mDefaultLocation,
                           &mNavReply,
                           &mNavOptions,
                           sStandardNavEventFilter ,
                           NULL,
                           kNavGenericSignature,
                           &myData);                    // User Data
        m_filterIndex = myData.currentfilter ;
    }
    else
    {
        myData.saveMode = false ;

        mNavFilterUPP = NewNavObjectFilterUPP( CrossPlatformFilterCallback ) ;
        if ( m_dialogStyle & wxMULTIPLE )
            mNavOptions.dialogOptionFlags |= kNavAllowMultipleFiles ;
        else
            mNavOptions.dialogOptionFlags &= ~kNavAllowMultipleFiles ;

        err = ::NavGetFile(
                           &mDefaultLocation,
                           &mNavReply,
                           &mNavOptions,
                           sStandardNavEventFilter ,
                           mNavPreviewUPP,
                           mNavFilterUPP,
                           NULL ,
                           &myData);
        m_filterIndex = myData.currentfilter ;
    }

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

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

    if (mNavReply.validRecord)
    {
        FSSpec  outFileSpec ;
        AEDesc specDesc ;
        AEKeyword keyWord ;

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

            m_paths.Add( m_path ) ;
            m_fileName = wxFileNameFromPath(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);
        NavDisposeReply( &mNavReply ) ;
        return wxID_OK ;
    }
    return wxID_CANCEL;
#endif // TARGET_CARBON
}
Commit	Line	Data
	1	/////////////////////////////////////////////////////////////////////////////
	2	// Name: filedlg.cpp
	3	// Purpose: wxFileDialog
	4	// Author: Stefan Csomor
	5	// Modified by:
	6	// Created: 1998-01-01
	7	// RCS-ID: $Id$
	8	// Copyright: (c) Stefan Csomor
	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	#include "wx/tokenzr.h"
	23	#include "wx/filename.h"
	24
	25	#ifndef __DARWIN__
	26	#include "PLStringFuncs.h"
	27	#endif
	28
	29	#if !USE_SHARED_LIBRARY
	30	IMPLEMENT_CLASS(wxFileDialog, wxFileDialogBase)
	31	#endif
	32
	33	// begin wxmac
	34
	35	#include "wx/mac/private.h"
	36
	37	#include <Navigation.h>
	38
	39	#ifdef __DARWIN__
	40	# include "MoreFilesX.h"
	41	#else
	42	# include "MoreFiles.h"
	43	# include "MoreFilesExtras.h"
	44	#endif
	45
	46	extern bool gUseNavServices ;
	47
	48	// the data we need to pass to our standard file hook routine
	49	// includes a pointer to the dialog, a pointer to the standard
	50	// file reply record (so we can inspect the current selection)
	51	// and a copy of the "previous" file spec of the reply record
	52	// so we can see if the selection has changed
	53
	54	struct OpenUserDataRec {
	55	int currentfilter ;
	56	bool saveMode ;
	57	wxArrayString name ;
	58	wxArrayString extensions ;
	59	wxArrayLong filtermactypes ;
	60	wxString defaultLocation;
	61	#if TARGET_CARBON
	62	CFArrayRef menuitems ;
	63	#else
	64	NavMenuItemSpecArrayHandle menuitems ;
	65	#endif
	66	};
	67
	68	typedef struct OpenUserDataRec
	69	OpenUserDataRec, *OpenUserDataRecPtr;
	70
	71	static pascal void NavEventProc(
	72	NavEventCallbackMessage inSelector,
	73	NavCBRecPtr ioParams,
	74	NavCallBackUserData ioUserData);
	75
	76	#if TARGET_CARBON
	77	static NavEventUPP sStandardNavEventFilter = NewNavEventUPP(NavEventProc);
	78	#else
	79	static NavEventUPP sStandardNavEventFilter = NewNavEventProc(NavEventProc);
	80	#endif
	81
	82	static pascal void
	83	NavEventProc(
	84	NavEventCallbackMessage inSelector,
	85	NavCBRecPtr ioParams,
	86	NavCallBackUserData ioUserData )
	87	{
	88	OpenUserDataRec * data = ( OpenUserDataRec *) ioUserData ;
	89	if (inSelector == kNavCBEvent) {
	90	#if TARGET_CARBON
	91	#else
	92	wxTheApp->MacHandleOneEvent(ioParams->eventData.eventDataParms.event);
	93	#endif
	94	}
	95	else if ( inSelector == kNavCBStart )
	96	{
	97	#if TARGET_CARBON
	98	if (data && !(data->defaultLocation).IsEmpty())
	99	{
	100	// Set default location for the modern Navigation APIs
	101	// Apple Technical Q&A 1151
	102	FSSpec theFSSpec;
	103	wxMacFilename2FSSpec(data->defaultLocation, &theFSSpec);
	104	AEDesc theLocation = {typeNull, NULL};
	105	if (noErr == ::AECreateDesc(typeFSS, &theFSSpec, sizeof(FSSpec), &theLocation))
	106	::NavCustomControl(ioParams->context, kNavCtlSetLocation, (void *) &theLocation);
	107	}
	108
	109	NavMenuItemSpec menuItem;
	110	menuItem.version = kNavMenuItemSpecVersion;
	111	menuItem.menuCreator = 'WXNG';
	112	menuItem.menuType = data->currentfilter;
	113	wxMacStringToPascal( data->name[data->currentfilter] , (StringPtr)(menuItem.menuItemName) ) ;
	114	::NavCustomControl(ioParams->context, kNavCtlSelectCustomType, &menuItem);
	115
	116	#else
	117	if ( data->menuitems )
	118	NavCustomControl(ioParams->context, kNavCtlSelectCustomType, &(*data->menuitems)[data->currentfilter]);
	119	#endif
	120	}
	121	else if ( inSelector == kNavCBPopupMenuSelect )
	122	{
	123	NavMenuItemSpec * menu = (NavMenuItemSpec *) ioParams->eventData.eventDataParms.param ;
	124	#if TARGET_CARBON
	125	const size_t numFilters = data->extensions.GetCount();
	126
	127	if ( menu->menuType < numFilters )
	128	#else
	129	if ( menu->menuCreator == 'WXNG' )
	130	#endif
	131	{
	132	data->currentfilter = menu->menuType ;
	133	if ( data->saveMode )
	134	{
	135	int i = menu->menuType ;
	136	wxString extension = data->extensions[i].AfterLast('.') ;
	137	extension.MakeLower() ;
	138	wxString sfilename ;
	139
	140	#if TARGET_CARBON
	141	wxMacCFStringHolder cfString( NavDialogGetSaveFileName( ioParams->context ) , false );
	142	sfilename = cfString.AsString() ;
	143	#else
	144	Str255 filename ;
	145	// get the current filename
	146	NavCustomControl(ioParams->context, kNavCtlGetEditFileName, &filename);
	147	sfilename = wxMacMakeStringFromPascal( filename ) ;
	148	#endif
	149
	150	int pos = sfilename.Find('.', true) ;
	151	if ( pos != wxNOT_FOUND )
	152	{
	153	sfilename = sfilename.Left(pos+1)+extension ;
	154	#if TARGET_CARBON
	155	cfString.Assign( sfilename , wxFONTENCODING_DEFAULT ) ;
	156	NavDialogSetSaveFileName( ioParams->context , cfString ) ;
	157	#else
	158	wxMacStringToPascal( sfilename , filename ) ;
	159	NavCustomControl(ioParams->context, kNavCtlSetEditFileName, &filename);
	160	#endif
	161	}
	162	}
	163	}
	164	}
	165	}
	166
	167
	168	void MakeUserDataRec(OpenUserDataRec *myData , const wxString& filter )
	169	{
	170	myData->menuitems = NULL ;
	171	myData->currentfilter = 0 ;
	172	myData->saveMode = false ;
	173
	174	if ( filter && filter[0] )
	175	{
	176	wxString filter2(filter) ;
	177	int filterIndex = 0;
	178	bool isName = true ;
	179	wxString current ;
	180	for( unsigned int i = 0; i < filter2.Len() ; i++ )
	181	{
	182	if( filter2.GetChar(i) == wxT('\|') )
	183	{
	184	if( isName ) {
	185	myData->name.Add( current ) ;
	186	}
	187	else {
	188	myData->extensions.Add( current.MakeUpper() ) ;
	189	++filterIndex ;
	190	}
	191	isName = !isName ;
	192	current = wxEmptyString ;
	193	}
	194	else
	195	{
	196	current += filter2.GetChar(i) ;
	197	}
	198	}
	199	// we allow for compatibility reason to have a single filter expression (like .) without
	200	// an explanatory text, in that case the first part is name and extension at the same time
	201
	202	wxASSERT_MSG( filterIndex == 0 \|\| !isName , wxT("incorrect format of format string") ) ;
	203	if ( current.IsEmpty() )
	204	myData->extensions.Add( myData->name[filterIndex] ) ;
	205	else
	206	myData->extensions.Add( current.MakeUpper() ) ;
	207	if ( filterIndex == 0 \|\| isName )
	208	myData->name.Add( current.MakeUpper() ) ;
	209
	210	++filterIndex ;
	211
	212	const size_t extCount = myData->extensions.GetCount();
	213	for ( size_t i = 0 ; i < extCount; i++ )
	214	{
	215	wxUint32 fileType;
	216	wxUint32 creator;
	217	wxString extension = myData->extensions[i];
	218
	219	if (extension.GetChar(0) == '*')
	220	extension = extension.Mid(1); // Remove leading *
	221
	222	if (extension.GetChar(0) == '.')
	223	{
	224	extension = extension.Mid(1); // Remove leading .
	225	}
	226
	227	if (wxFileName::MacFindDefaultTypeAndCreator( extension, &fileType, &creator ))
	228	{
	229	myData->filtermactypes.Add( (OSType)fileType );
	230	}
	231	else
	232	{
	233	myData->filtermactypes.Add( '****' ) ; // We'll fail safe if it's not recognized
	234	}
	235	}
	236	}
	237	}
	238
	239	static Boolean CheckFile( const wxString &filename , OSType type , OpenUserDataRecPtr data)
	240	{
	241	wxString file(filename) ;
	242	file.MakeUpper() ;
	243
	244	if ( data->extensions.GetCount() > 0 )
	245	{
	246	//for ( int i = 0 ; i < data->numfilters ; ++i )
	247	int i = data->currentfilter ;
	248	if ( data->extensions[i].Right(2) == wxT(".*") )
	249	return true ;
	250
	251	{
	252	if ( type == (OSType)data->filtermactypes[i] )
	253	return true ;
	254
	255	wxStringTokenizer tokenizer( data->extensions[i] , wxT(";") ) ;
	256	while( tokenizer.HasMoreTokens() )
	257	{
	258	wxString extension = tokenizer.GetNextToken() ;
	259	if ( extension.GetChar(0) == '*' )
	260	extension = extension.Mid(1) ;
	261
	262	if ( file.Len() >= extension.Len() && extension == file.Right(extension.Len() ) )
	263	return true ;
	264	}
	265	}
	266	return false ;
	267	}
	268	return true ;
	269	}
	270
	271	#ifndef __DARWIN__
	272	static pascal Boolean CrossPlatformFileFilter(CInfoPBPtr myCInfoPBPtr, void *dataPtr)
	273	{
	274	OpenUserDataRecPtr data = (OpenUserDataRecPtr) dataPtr ;
	275	// return true if this item is invisible or a file
	276
	277	Boolean visibleFlag;
	278	Boolean folderFlag;
	279
	280	visibleFlag = ! (myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdFlags & kIsInvisible);
	281	folderFlag = (myCInfoPBPtr->hFileInfo.ioFlAttrib & 0x10);
	282
	283	// because the semantics of the filter proc are "true means don't show
	284	// it" we need to invert the result that we return
	285
	286	if ( !visibleFlag )
	287	return true ;
	288
	289	if ( !folderFlag )
	290	{
	291	wxString file = wxMacMakeStringFromPascal( myCInfoPBPtr->hFileInfo.ioNamePtr ) ;
	292	return !CheckFile( file , myCInfoPBPtr->hFileInfo.ioFlFndrInfo.fdType , data ) ;
	293	}
	294
	295	return false ;
	296	}
	297	#endif
	298
	299	// end wxmac
	300
	301	wxFileDialog::wxFileDialog(wxWindow *parent, const wxString& message,
	302	const wxString& defaultDir, const wxString& defaultFileName, const wxString& wildCard,
	303	long style, const wxPoint& pos)
	304	:wxFileDialogBase(parent, message, defaultDir, defaultFileName, wildCard, style, pos)
	305	{
	306	wxASSERT_MSG( NavServicesAvailable() , wxT("Navigation Services are not running") ) ;
	307	}
	308
	309	pascal Boolean CrossPlatformFilterCallback (
	310	AEDesc *theItem,
	311	void *info,
	312	void *callBackUD,
	313	NavFilterModes filterMode
	314	)
	315	{
	316	bool display = true;
	317	OpenUserDataRecPtr data = (OpenUserDataRecPtr) callBackUD ;
	318
	319	if (filterMode == kNavFilteringBrowserList)
	320	{
	321	NavFileOrFolderInfo* theInfo = (NavFileOrFolderInfo*) info ;
	322	if ( !theInfo->isFolder )
	323	{
	324	if (theItem->descriptorType == typeFSS )
	325	{
	326	FSSpec spec;
	327	memcpy( &spec , *theItem->dataHandle , sizeof(FSSpec) ) ;
	328	wxString file = wxMacMakeStringFromPascal( spec.name ) ;
	329	display = CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
	330	}
	331	#if TARGET_CARBON
	332	else if ( theItem->descriptorType == typeFSRef )
	333	{
	334	FSRef fsref ;
	335	memcpy( &fsref , *theItem->dataHandle , sizeof(FSRef) ) ;
	336
	337
	338
	339	CFURLRef fullURLRef;
	340	fullURLRef = ::CFURLCreateFromFSRef(NULL, &fsref);
	341	#ifdef __UNIX__
	342	CFURLPathStyle pathstyle = kCFURLPOSIXPathStyle;
	343	#else
	344	CFURLPathStyle pathstyle = kCFURLHFSPathStyle;
	345	#endif
	346	CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, pathstyle);
	347	::CFRelease( fullURLRef ) ;
	348	wxString file = wxMacCFStringHolder(cfString).AsString(wxFont::GetDefaultEncoding());
	349
	350	display = CheckFile( file , theInfo->fileAndFolder.fileInfo.finderInfo.fdType , data ) ;
	351	}
	352	#endif
	353	}
	354	}
	355
	356	return display;
	357	}
	358
	359	int wxFileDialog::ShowModal()
	360	{
	361	#if TARGET_CARBON
	362	OSErr err;
	363	NavDialogCreationOptions dialogCreateOptions;
	364	// set default options
	365	::NavGetDefaultDialogCreationOptions(&dialogCreateOptions);
	366
	367	// this was always unset in the old code
	368	dialogCreateOptions.optionFlags &= ~kNavSelectDefaultLocation;
	369
	370	wxMacCFStringHolder message(m_message, m_font.GetEncoding());
	371	dialogCreateOptions.windowTitle = message;
	372
	373	wxMacCFStringHolder defaultFileName(m_fileName, m_font.GetEncoding());
	374	dialogCreateOptions.saveFileName = defaultFileName;
	375
	376
	377	NavDialogRef dialog;
	378	NavObjectFilterUPP navFilterUPP = NULL;
	379	CFArrayRef cfArray = NULL; // for popupExtension
	380	OpenUserDataRec myData;
	381	myData.defaultLocation = m_dir;
	382
	383	MakeUserDataRec(&myData , m_wildCard);
	384	myData.currentfilter = m_filterIndex;
	385	size_t numFilters = myData.extensions.GetCount();
	386	if (numFilters)
	387	{
	388	CFMutableArrayRef popup = CFArrayCreateMutable( kCFAllocatorDefault ,
	389	numFilters , &kCFTypeArrayCallBacks ) ;
	390	dialogCreateOptions.popupExtension = popup ;
	391	myData.menuitems = dialogCreateOptions.popupExtension ;
	392	for ( size_t i = 0 ; i < numFilters ; ++i )
	393	{
	394	CFArrayAppendValue( popup , (CFStringRef) wxMacCFStringHolder( myData.name[i] , m_font.GetEncoding() ) ) ;
	395	}
	396	}
	397
	398	if (m_dialogStyle & wxSAVE)
	399	{
	400	myData.saveMode = true;
	401
	402	if (!numFilters)
	403	{
	404	dialogCreateOptions.optionFlags \|= kNavNoTypePopup;
	405	}
	406	dialogCreateOptions.optionFlags \|= kNavDontAutoTranslate;
	407	dialogCreateOptions.optionFlags \|= kNavDontAddTranslateItems;
	408
	409	// The extension is important
	410	if (numFilters < 2)
	411	dialogCreateOptions.optionFlags \|= kNavPreserveSaveFileExtension;
	412
	413	#if TARGET_API_MAC_OSX
	414	if (!(m_dialogStyle & wxOVERWRITE_PROMPT))
	415	{
	416	dialogCreateOptions.optionFlags \|= kNavDontConfirmReplacement;
	417	}
	418	#endif
	419	err = ::NavCreatePutFileDialog(&dialogCreateOptions,
	420	// Suppresses the 'Default' (top) menu item
	421	kNavGenericSignature, kNavGenericSignature,
	422	sStandardNavEventFilter,
	423	&myData, // for defaultLocation
	424	&dialog);
	425	}
	426	else
	427	{
	428
	429	//let people select bundles/programs in dialogs
	430	dialogCreateOptions.optionFlags \|= kNavSupportPackages;
	431
	432	navFilterUPP = NewNavObjectFilterUPP(CrossPlatformFilterCallback);
	433	err = ::NavCreateGetFileDialog(&dialogCreateOptions,
	434	NULL, // NavTypeListHandle
	435	sStandardNavEventFilter,
	436	NULL, // NavPreviewUPP
	437	navFilterUPP,
	438	(void *) &myData, // inClientData
	439	&dialog);
	440	}
	441
	442	if (err == noErr)
	443	err = ::NavDialogRun(dialog);
	444
	445	// clean up filter related data, etc.
	446	if (navFilterUPP)
	447	::DisposeNavObjectFilterUPP(navFilterUPP);
	448	if (cfArray)
	449	::CFRelease(cfArray);
	450
	451	if (err != noErr)
	452	return wxID_CANCEL;
	453
	454	NavReplyRecord navReply;
	455	err = ::NavDialogGetReply(dialog, &navReply);
	456	if (err == noErr && navReply.validRecord)
	457	{
	458	AEKeyword theKeyword;
	459	DescType actualType;
	460	Size actualSize;
	461	FSRef theFSRef;
	462	wxString thePath ;
	463
	464	m_filterIndex = myData.currentfilter ;
	465
	466	long count;
	467	::AECountItems(&navReply.selection , &count);
	468	for (long i = 1; i <= count; ++i)
	469	{
	470	err = ::AEGetNthPtr(&(navReply.selection), i, typeFSRef, &theKeyword, &actualType,
	471	&theFSRef, sizeof(theFSRef), &actualSize);
	472	if (err != noErr)
	473	break;
	474
	475	CFURLRef fullURLRef = 0 ;
	476	if (m_dialogStyle & wxSAVE)
	477	{
	478	CFURLRef parentURLRef = ::CFURLCreateFromFSRef(NULL, &theFSRef);
	479
	480	if (parentURLRef)
	481	{
	482	fullURLRef =
	483	::CFURLCreateCopyAppendingPathComponent(NULL,
	484	parentURLRef,
	485	navReply.saveFileName,
	486	false);
	487	::CFRelease(parentURLRef);
	488	}
	489	}
	490	else
	491	{
	492	fullURLRef = ::CFURLCreateFromFSRef(NULL, &theFSRef);
	493	}
	494	#ifdef __UNIX__
	495	CFURLPathStyle pathstyle = kCFURLPOSIXPathStyle;
	496	#else
	497	CFURLPathStyle pathstyle = kCFURLHFSPathStyle;
	498	#endif
	499	CFStringRef cfString = CFURLCopyFileSystemPath(fullURLRef, pathstyle);
	500	thePath = wxMacCFStringHolder(cfString).AsString(m_font.GetEncoding());
	501	if (!thePath)
	502	{
	503	::NavDisposeReply(&navReply);
	504	return wxID_CANCEL;
	505	}
	506	m_path = thePath;
	507	m_paths.Add(m_path);
	508	m_fileName = wxFileNameFromPath(m_path);
	509	m_fileNames.Add(m_fileName);
	510	}
	511	// set these to the first hit
	512	m_path = m_paths[0];
	513	m_fileName = wxFileNameFromPath(m_path);
	514	m_dir = wxPathOnly(m_path);
	515	}
	516	::NavDisposeReply(&navReply);
	517
	518	return (err == noErr) ? wxID_OK : wxID_CANCEL;
	519	#else // TARGET_CARBON
	520
	521	NavDialogOptions mNavOptions;
	522	NavObjectFilterUPP mNavFilterUPP = NULL;
	523	NavPreviewUPP mNavPreviewUPP = NULL ;
	524	NavReplyRecord mNavReply;
	525	AEDesc mDefaultLocation ;
	526	bool mSelectDefault = false ;
	527	OSStatus err = noErr ;
	528	// setup dialog
	529
	530	mNavFilterUPP = nil;
	531	mNavPreviewUPP = nil;
	532	mSelectDefault = false;
	533	mDefaultLocation.descriptorType = typeNull;
	534	mDefaultLocation.dataHandle = nil;
	535
	536	NavGetDefaultDialogOptions(&mNavOptions);
	537	wxMacStringToPascal( m_message , (StringPtr)mNavOptions.message ) ;
	538	wxMacStringToPascal( m_fileName , (StringPtr)mNavOptions.savedFileName ) ;
	539
	540	// Set default location, the location
	541	// that's displayed when the dialog
	542	// first appears
	543
	544	FSSpec location ;
	545	wxMacFilename2FSSpec( m_dir , &location ) ;
	546
	547	err = ::AECreateDesc(typeFSS, &location, sizeof(FSSpec), &mDefaultLocation );
	548
	549	if ( mDefaultLocation.dataHandle )
	550	{
	551	if (mSelectDefault)
	552	{
	553	mNavOptions.dialogOptionFlags \|= kNavSelectDefaultLocation;
	554	} else {
	555	mNavOptions.dialogOptionFlags &= ~kNavSelectDefaultLocation;
	556	}
	557	}
	558
	559	memset( &mNavReply , 0 , sizeof( mNavReply ) ) ;
	560	mNavReply.validRecord = false;
	561	mNavReply.replacing = false;
	562	mNavReply.isStationery = false;
	563	mNavReply.translationNeeded = false;
	564	mNavReply.selection.descriptorType = typeNull;
	565	mNavReply.selection.dataHandle = nil;
	566	mNavReply.keyScript = smSystemScript;
	567	mNavReply.fileTranslation = nil;
	568	mNavReply.version = kNavReplyRecordVersion ;
	569
	570	// zero all data
	571
	572	m_path = wxEmptyString ;
	573	m_fileName = wxEmptyString ;
	574	m_paths.Empty();
	575	m_fileNames.Empty();
	576
	577	OpenUserDataRec myData;
	578	MakeUserDataRec( &myData , m_wildCard ) ;
	579	myData.currentfilter = m_filterIndex ;
	580	if ( myData.extensions.GetCount() > 0 )
	581	{
	582	mNavOptions.popupExtension = (NavMenuItemSpecArrayHandle) NewHandle( sizeof( NavMenuItemSpec ) * myData.extensions.GetCount() ) ;
	583	myData.menuitems = mNavOptions.popupExtension ;
	584	for ( size_t i = 0 ; i < myData.extensions.GetCount() ; ++i )
	585	{
	586	(*mNavOptions.popupExtension)[i].version = kNavMenuItemSpecVersion ;
	587	(*mNavOptions.popupExtension)[i].menuCreator = 'WXNG' ;
	588	// TODO : according to the new docs -1 to 10 are reserved for the OS
	589	(*mNavOptions.popupExtension)[i].menuType = i ;
	590	wxMacStringToPascal( myData.name[i] , (StringPtr)(*mNavOptions.popupExtension)[i].menuItemName ) ;
	591	}
	592	}
	593	if ( m_dialogStyle & wxSAVE )
	594	{
	595	myData.saveMode = true ;
	596
	597	mNavOptions.dialogOptionFlags \|= kNavDontAutoTranslate ;
	598	mNavOptions.dialogOptionFlags \|= kNavDontAddTranslateItems ;
	599
	600	err = ::NavPutFile(
	601	&mDefaultLocation,
	602	&mNavReply,
	603	&mNavOptions,
	604	sStandardNavEventFilter ,
	605	NULL,
	606	kNavGenericSignature,
	607	&myData); // User Data
	608	m_filterIndex = myData.currentfilter ;
	609	}
	610	else
	611	{
	612	myData.saveMode = false ;
	613
	614	mNavFilterUPP = NewNavObjectFilterUPP( CrossPlatformFilterCallback ) ;
	615	if ( m_dialogStyle & wxMULTIPLE )
	616	mNavOptions.dialogOptionFlags \|= kNavAllowMultipleFiles ;
	617	else
	618	mNavOptions.dialogOptionFlags &= ~kNavAllowMultipleFiles ;
	619
	620	err = ::NavGetFile(
	621	&mDefaultLocation,
	622	&mNavReply,
	623	&mNavOptions,
	624	sStandardNavEventFilter ,
	625	mNavPreviewUPP,
	626	mNavFilterUPP,
	627	NULL ,
	628	&myData);
	629	m_filterIndex = myData.currentfilter ;
	630	}
	631
	632	DisposeNavObjectFilterUPP(mNavFilterUPP);
	633	if ( mDefaultLocation.dataHandle != nil )
	634	{
	635	::AEDisposeDesc(&mDefaultLocation);
	636	}
	637
	638	if ( (err != noErr) && (err != userCanceledErr) ) {
	639	return wxID_CANCEL ;
	640	}
	641
	642	if (mNavReply.validRecord)
	643	{
	644	FSSpec outFileSpec ;
	645	AEDesc specDesc ;
	646	AEKeyword keyWord ;
	647
	648	long count ;
	649	::AECountItems( &mNavReply.selection , &count ) ;
	650	for ( long i = 1 ; i <= count ; ++i )
	651	{
	652	OSErr err = ::AEGetNthDesc( &mNavReply.selection , i , typeFSS, &keyWord , &specDesc);
	653	if ( err != noErr )
	654	{
	655	m_path = wxT("") ;
	656	return wxID_CANCEL ;
	657	}
	658	outFileSpec = (FSSpec) specDesc.dataHandle;
	659	if (specDesc.dataHandle != nil) {
	660	::AEDisposeDesc(&specDesc);
	661	}
	662	m_path = wxMacFSSpec2MacFilename( &outFileSpec ) ;
	663
	664	m_paths.Add( m_path ) ;
	665	m_fileName = wxFileNameFromPath(m_path);
	666	m_fileNames.Add(m_fileName);
	667	}
	668	// set these to the first hit
	669	m_path = m_paths[ 0 ] ;
	670	m_fileName = wxFileNameFromPath(m_path);
	671	m_dir = wxPathOnly(m_path);
	672	NavDisposeReply( &mNavReply ) ;
	673	return wxID_OK ;
	674	}
	675	return wxID_CANCEL;
	676	#endif // TARGET_CARBON
	677	}
	678