// Shave and a Haircut // (c) 2019 Epic Games // US Patent 6720962 /////////////// #include #include #include #include /////////////////////// int getMOUSE1( ) { return ( 0 ); } int getTAB( ) { return ( 0 ); } int getCOMMAND( ) { int vv = 0, vv2; #ifdef NOLIB int k = 55; // Escape = 53 unsigned char km[16]; // GetKeys((unsigned long*)km); GetKeys( ( long * ) km ); // if (valuator[MOUSE2]!=0) { vv = ( ( km[k >> 3] >> ( k & 7 ) ) & 1 ); // if ((vv==0)&&(valuator[MOUSE1]==1)) // valuator[MOUSE1]=2; // if ((vv==1)&&(valuator[MOUSE1]==0)) // valuator[MOUSE1]=1; // if (valuator[MOUSE1]) DRAW_STATUS("got mouse1"); //if (vv) DRAW_STATUS("command"); } #endif return ( vv ); // return(0); } int getCTRL( ) { int vv = 0, vv2; #ifdef NOLIB int k = 59; // Escape = 53 unsigned char km[16]; // GetKeys((unsigned long*)km); GetKeys( ( long * ) km ); // if (valuator[MOUSE2]!=0) { vv = ( ( km[k >> 3] >> ( k & 7 ) ) & 1 ); // if ((vv==0)&&(valuator[MOUSE1]==1)) // valuator[MOUSE1]=2; // if ((vv==1)&&(valuator[MOUSE1]==0)) // valuator[MOUSE1]=1; // if (valuator[MOUSE1]) DRAW_STATUS("got mouse1"); //if (vv) DRAW_STATUS("command"); } #endif return ( vv ); // return(0); } int getESCAPE( ) { int vvv = 0; return ( valuator[ESCKEY] ); } int getSHIFT( void ) { int tmp = 0; return ( tmp ); } HWND GetFocus( void ) { return ( 0 ); } void SetCapture( long junk ) { //fprintf(stderr, "SetCapture(): NOT YET IMPLEMENTED\n"); } #define BOOL int #define LPPOINT VERT * BOOL SetCursorPos( int x, int y ) { //fprintf(stderr, "SetCursorPos(): NOT YET IMPLEMENTED\n"); // valuator[MOUSEX]=x; // valuator[MOUSEY]=y; } BOOL GetCursorPos( LPPOINT p ) { p->x = valuator[MOUSEX]; p->y = valuator[MOUSEY]; } // GET HANDLE TO WINDOW FOR TIMERS -- DOES NOTHING ON SGI HWND GetForegroundWindow( ) { return ( 0 ); } int filechooserSV( const char *title, const char *comment, char *filename, int filenamemax, char *filter, int filtermax ) { return 0; } int filechooser( const char *title, const char *comment, char *filename, int filenamemax, char *filter, int filtermax ) { int ret = -1; #ifdef NOLIB NavDialogOptions dialogOptions; // NavEventUPP eventProc = NewNavEventProc(myEventProc); // NavObjectFilterUPP filterProc = NewNavObjectFilterProc(myFilterProc); NavTypeListHandle typeList; NavReplyRecord reply; OSErr anErr = noErr; // Specify default options for dialog box anErr = NavGetDefaultDialogOptions( &dialogOptions ); if( anErr == noErr ) { AEDesc defaultLocation; // Adjust the options to fit our needs // Set default location option dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation; // dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation; // Clear preview option dialogOptions.dialogOptionFlags ^= kNavAllowPreviews; // Get 'open' resource. A nil handle being returned is OK, // this simply means no automatic file filtering. typeList = ( NavTypeListHandle ) GetResource( 'open', 128 ); // Call NavChooseFile() with specified options and // declare our app-defined functions and type list // anErr = NavChooseFile (nil, &reply, &dialogOptions, eventProc, nil, filterProc, typeList, nil); anErr = NavChooseFile( nil, &reply, &dialogOptions, nil, nil, nil, typeList, nil ); if( anErr == noErr && reply.validRecord ) { AEKeyword theKeyword; DescType actualType; Size actualSize; FSSpec documentFSSpec; // Get a pointer to selected file anErr = AEGetNthPtr( &( reply.selection ), 1, typeFSS, &theKeyword, &actualType, &documentFSSpec, sizeof( documentFSSpec ), &actualSize ); if( anErr == noErr ) { char *pfilter; int lenstr = ( int ) ( documentFSSpec.name[0] ); int i = 1; for( ; i <= lenstr; i++ ) { filename[i - 1] = documentFSSpec.name[i]; } filename[lenstr] = '\0'; if( filter[0] == '*' && filter[1] == '.' ) pfilter = filter + 2; else pfilter = filter; if( strstr( filename, pfilter ) ) ret = 0; else filename[0] = '\0'; } // Dispose of NavReplyRecord, resources, descriptors anErr = NavDisposeReply( &reply ); } if( typeList != NULL ) { ReleaseResource( ( Handle ) typeList ); } } #endif // DisposeRoutineDescriptor(eventProc); // DisposeRoutineDescriptor(filterProc); //if (ret==0) printf("DEBUG: gonna open %s\n", filename); //else printf("DEBUG: not opening anything\n"); return ( ret ); } /* NAVIGATION SERVICE EXAMPLE */ /* This function allows the user to choose a single file, such as a preferences file, for an action other than opening. The NavChooseFile function is similar to NavGetFile, but is limited to selecting a single file. OSErr MyOpenDocument(const FSSpecPtr defaultLocationfssPtr) { NavDialogOptions dialogOptions; AEDesc defaultLocation; NavEventUPP eventProc = NewNavEventProc(myEventProc); NavObjectFilterUPP filterProc = NewNavObjectFilterProc(myFilterProc); OSErr anErr = noErr; // Specify default options for dialog box anErr = NavGetDefaultDialogOptions(&dialogOptions); if (anErr == noErr) { // Adjust the options to fit our needs // Set default location option dialogOptions.dialogOptionFlags |= kNavSelectDefaultLocation; // Clear preview option dialogOptions.dialogOptionFlags ^= kNavAllowPreviews; // make descriptor for default location anErr = AECreateDesc(typeFSS, defaultLocationfssPtr, sizeof(*defaultLocationfssPtr), &defaultLocation ); if (anErr == noErr) { // Get 'open' resource. A nil handle being returned is OK, // this simply means no automatic file filtering. NavTypeListHandle typeList = (NavTypeListHandle)GetResource( 'open', 128); NavReplyRecord reply; // Call NavGetFile() with specified options and // declare our app-defined functions and type list anErr = NavGetFile (&defaultLocation, &reply, &dialogOptions, eventProc, nil, filterProc, typeList, nil); if (anErr == noErr && reply.validRecord) { // Deal with multiple file selection long count; anErr = AECountItems(&(reply.selection), &count); // Set up index for file list if (anErr == noErr) { longindex; for (index = 1; index <= count; index++) { AEKeyword theKeyword; DescType actualType; Size actualSize; FSSpec documentFSSpec; // Get a pointer to selected file anErr = AEGetNthPtr(&(reply.selection), index, typeFSS, &theKeyword, &actualType,&documentFSSpec, sizeof(documentFSSpec), &actualSize); if (anErr == noErr) { anErr = DoOpenFile(&documentFSSpec); } } } // Dispose of NavReplyRecord, resources, descriptors anErr = NavDisposeReply(&reply); } if (typeList != NULL) { ReleaseResource( (Handle)typeList); } (void) AEDisposeDesc(&defaultLocation); } } DisposeRoutineDescriptor(eventProc); DisposeRoutineDescriptor(filterProc); return anErr; } */ ///////////////// vald|10Jun2010 stuf to replace ...InetInterface deprecated in MacOS10.5 sdk /////////////////////// //////////////////////////////// used for retrieving MAC address //////////////////////////////////////////////////// //static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices); //static kern_return_t GetMACAddress(io_iterator_t intfIterator, UInt8 *MACAddress, UInt8 bufferSize); // Returns an iterator containing the primary (built-in) Ethernet interface. The caller is responsible for // releasing the iterator after the caller is done with it. static kern_return_t FindEthernetInterfaces(io_iterator_t *matchingServices) { kern_return_t kernResult; CFMutableDictionaryRef matchingDict; CFMutableDictionaryRef propertyMatchDict; // Ethernet interfaces are instances of class kIOEthernetInterfaceClass. // IOServiceMatching is a convenience function to create a dictionary with the key kIOProviderClassKey and // the specified value. matchingDict = IOServiceMatching(kIOEthernetInterfaceClass); // Note that another option here would be: // matchingDict = IOBSDMatching("en0"); if (NULL == matchingDict) { printf("IOServiceMatching returned a NULL dictionary.\n"); } else { // Each IONetworkInterface object has a Boolean property with the key kIOPrimaryInterface. Only the // primary (built-in) interface has this property set to TRUE. // IOServiceGetMatchingServices uses the default matching criteria defined by IOService. This considers // only the following properties plus any family-specific matching in this order of precedence // (see IOService::passiveMatch): // // kIOProviderClassKey (IOServiceMatching) // kIONameMatchKey (IOServiceNameMatching) // kIOPropertyMatchKey // kIOPathMatchKey // kIOMatchedServiceCountKey // family-specific matching // kIOBSDNameKey (IOBSDNameMatching) // kIOLocationMatchKey // The IONetworkingFamily does not define any family-specific matching. This means that in // order to have IOServiceGetMatchingServices consider the kIOPrimaryInterface property, we must // add that property to a separate dictionary and then add that to our matching dictionary // specifying kIOPropertyMatchKey. propertyMatchDict = CFDictionaryCreateMutable(kCFAllocatorDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks); if (NULL == propertyMatchDict) { printf("CFDictionaryCreateMutable returned a NULL dictionary.\n"); } else { // Set the value in the dictionary of the property with the given key, or add the key // to the dictionary if it doesn't exist. This call retains the value object passed in. CFDictionarySetValue(propertyMatchDict, CFSTR(kIOPrimaryInterface), kCFBooleanTrue); // Now add the dictionary containing the matching value for kIOPrimaryInterface to our main // matching dictionary. This call will retain propertyMatchDict, so we can release our reference // on propertyMatchDict after adding it to matchingDict. CFDictionarySetValue(matchingDict, CFSTR(kIOPropertyMatchKey), propertyMatchDict); CFRelease(propertyMatchDict); } } // IOServiceGetMatchingServices retains the returned iterator, so release the iterator when we're done with it. // IOServiceGetMatchingServices also consumes a reference on the matching dictionary so we don't need to release // the dictionary explicitly. kernResult = IOServiceGetMatchingServices(kIOMasterPortDefault, matchingDict, matchingServices); if (KERN_SUCCESS != kernResult) { printf("IOServiceGetMatchingServices returned 0x%08x\n", kernResult); } return kernResult; } // Given an iterator across a set of Ethernet interfaces, return the MAC address of the last one. // If no interfaces are found the MAC address is set to an empty string. // In this sample the iterator should contain just the primary interface. static kern_return_t GetMACAddress(io_iterator_t intfIterator, UInt8 *MACAddress, UInt8 bufferSize) { io_object_t intfService; io_object_t controllerService; kern_return_t kernResult = KERN_FAILURE; // Make sure the caller provided enough buffer space. Protect against buffer overflow problems. if (bufferSize < kIOEthernetAddressSize) { return kernResult; } // Initialize the returned address bzero(MACAddress, bufferSize); // IOIteratorNext retains the returned object, so release it when we're done with it. while (intfService = IOIteratorNext(intfIterator)) { CFTypeRef MACAddressAsCFData; // IONetworkControllers can't be found directly by the IOServiceGetMatchingServices call, // since they are hardware nubs and do not participate in driver matching. In other words, // registerService() is never called on them. So we've found the IONetworkInterface and will // get its parent controller by asking for it specifically. // IORegistryEntryGetParentEntry retains the returned object, so release it when we're done with it. kernResult = IORegistryEntryGetParentEntry(intfService, kIOServicePlane, &controllerService); if (KERN_SUCCESS != kernResult) { printf("IORegistryEntryGetParentEntry returned 0x%08x\n", kernResult); } else { // Retrieve the MAC address property from the I/O Registry in the form of a CFData MACAddressAsCFData = IORegistryEntryCreateCFProperty(controllerService, CFSTR(kIOMACAddress), kCFAllocatorDefault, 0); if (MACAddressAsCFData) { //CFShow(MACAddressAsCFData); // for display purposes only; output goes to stderr // Get the raw bytes of the MAC address from the CFData CFDataGetBytes(MACAddressAsCFData, CFRangeMake(0, kIOEthernetAddressSize), MACAddress); CFRelease(MACAddressAsCFData); } // Done with the parent Ethernet controller object so we release it. (void) IOObjectRelease(controllerService); } // Done with the Ethernet interface object so we release it. (void) IOObjectRelease(intfService); } return kernResult; }