/* vi:set ts=8 sts=4 sw=4 noet: * * VIM - Vi IMproved by Bram Moolenaar * GUI/Motif support by Robert Webb * Macintosh port by Dany St-Amant * and Axel Kielhorn * Port to MPW by Bernhard Pruemmer * Initial Carbon port by Ammon Skidmore * * Do ":help uganda" in Vim to read copying and usage conditions. * Do ":help credits" in Vim to see a list of people who contributed. * See README.txt for an overview of the Vim source code. */ /* * NOTES: - Vim 7+ does not support classic MacOS. Please use Vim 6.x * - Comments mentioning FAQ refer to the book: * "Macworld Mac Programming FAQs" from "IDG Books" */ /* * TODO: Change still to merge from the macvim's iDisk * * error_ga, mch_errmsg, Navigation's changes in gui_mch_browse * uses of MenuItemIndex, changes in gui_mch_set_shellsize, * ScrapManager error handling. * Comments about function remaining to Carbonize. * */ /* * TODO (Jussi) * * Clipboard does not work (at least some cases) * * ATSU font rendering has some problems * * Investigate and remove dead code (there is still lots of that) */ #include // included first to avoid CR problems #include "vim.h" #define USE_CARBONIZED #define USE_AEVENT // Enable AEVENT #undef USE_OFFSETED_WINDOW // Debugging feature: start Vim window OFFSETed // Compile as CodeWarrior External Editor #if defined(FEAT_CW_EDITOR) && !defined(USE_AEVENT) # define USE_AEVENT // Need Apple Event Support #endif // Vim's Scrap flavor. #define VIMSCRAPFLAVOR 'VIM!' #define SCRAPTEXTFLAVOR kScrapFlavorTypeUnicode static EventHandlerUPP mouseWheelHandlerUPP = NULL; SInt32 gMacSystemVersion; #ifdef MACOS_CONVERT # define USE_CARBONKEYHANDLER static int im_is_active = FALSE; # if 0 // TODO: Implement me! static int im_start_row = 0; static int im_start_col = 0; # endif # define NR_ELEMS(x) (sizeof(x) / sizeof(x[0])) static TSMDocumentID gTSMDocument; static void im_on_window_switch(int active); static EventHandlerUPP keyEventHandlerUPP = NULL; static EventHandlerUPP winEventHandlerUPP = NULL; static pascal OSStatus gui_mac_handle_window_activate( EventHandlerCallRef nextHandler, EventRef theEvent, void *data); static pascal OSStatus gui_mac_handle_text_input( EventHandlerCallRef nextHandler, EventRef theEvent, void *data); static pascal OSStatus gui_mac_update_input_area( EventHandlerCallRef nextHandler, EventRef theEvent); static pascal OSStatus gui_mac_unicode_key_event( EventHandlerCallRef nextHandler, EventRef theEvent); #endif // Include some file. TODO: move into os_mac.h #include #include #include #ifdef USE_AEVENT # include # include #endif # include #if UNIVERSAL_INTERFACES_VERSION >= 0x0330 # include # include // Navigation only part of ?? #endif // Help Manager (balloon.h, HM prefixed functions) are not supported // under Carbon (Jussi) # if 0 // New Help Interface for Mac, not implemented yet. # include # endif /* * These seem to be rectangle options. Why are they not found in * headers? (Jussi) */ #define kNothing 0 #define kCreateEmpty 2 //1 #define kCreateRect 2 #define kDestroy 3 /* * Dany: Don't like those... */ #define topLeft(r) (((Point*)&(r))[0]) #define botRight(r) (((Point*)&(r))[1]) // Time of last mouse click, to detect double-click static long lastMouseTick = 0; // ??? static RgnHandle cursorRgn; static RgnHandle dragRgn; static Rect dragRect; static short dragRectEnbl; static short dragRectControl; // This variable is set when waiting for an event, which is the only moment // scrollbar dragging can be done directly. It's not allowed while commands // are executed, because it may move the cursor and that may cause unexpected // problems (e.g., while ":s" is working). static int allow_scrollbar = FALSE; // Last mouse click caused contextual menu, (to provide proper release) static short clickIsPopup; // Feedback Action for Scrollbar ControlActionUPP gScrollAction; ControlActionUPP gScrollDrag; // Keeping track of which scrollbar is being dragged static ControlHandle dragged_sb = NULL; // Vector of char_u --> control index for hotkeys in dialogs static short *gDialogHotKeys; static struct { FMFontFamily family; FMFontSize size; FMFontStyle style; Boolean isPanelVisible; } gFontPanelInfo = { 0, 0, 0, false }; #ifdef MACOS_CONVERT # define USE_ATSUI_DRAWING int p_macatsui_last; ATSUStyle gFontStyle; ATSUStyle gWideFontStyle; Boolean gIsFontFallbackSet; UInt32 useAntialias_cached = 0x0; #endif // Colors Macros #define RGB(r,g,b) ((r) << 16) + ((g) << 8) + (b) #define Red(c) ((c & 0x00FF0000) >> 16) #define Green(c) ((c & 0x0000FF00) >> 8) #define Blue(c) ((c & 0x000000FF) >> 0) // Key mapping #define vk_Esc 0x35 // -> 1B #define vk_F1 0x7A // -> 10 #define vk_F2 0x78 //0x63 #define vk_F3 0x63 //0x76 #define vk_F4 0x76 //0x60 #define vk_F5 0x60 //0x61 #define vk_F6 0x61 //0x62 #define vk_F7 0x62 //0x63 ? #define vk_F8 0x64 #define vk_F9 0x65 #define vk_F10 0x6D #define vk_F11 0x67 #define vk_F12 0x6F #define vk_F13 0x69 #define vk_F14 0x6B #define vk_F15 0x71 #define vk_Clr 0x47 // -> 1B (ESC) #define vk_Enter 0x4C // -> 03 #define vk_Space 0x31 // -> 20 #define vk_Tab 0x30 // -> 09 #define vk_Return 0x24 // -> 0D // This is wrong for OSX, what is it for? #define vk_Delete 0X08 // -> 08 BackSpace #define vk_Help 0x72 // -> 05 #define vk_Home 0x73 // -> 01 #define vk_PageUp 0x74 // -> 0D #define vk_FwdDelete 0x75 // -> 7F #define vk_End 0x77 // -> 04 #define vk_PageDown 0x79 // -> 0C #define vk_Up 0x7E // -> 1E #define vk_Down 0x7D // -> 1F #define vk_Left 0x7B // -> 1C #define vk_Right 0x7C // -> 1D #define vk_Undo vk_F1 #define vk_Cut vk_F2 #define vk_Copy vk_F3 #define vk_Paste vk_F4 #define vk_PrintScreen vk_F13 #define vk_SCrollLock vk_F14 #define vk_Pause vk_F15 #define vk_NumLock vk_Clr #define vk_Insert vk_Help #define KeySym char static struct { KeySym key_sym; char_u vim_code0; char_u vim_code1; } special_keys[] = { {vk_Up, 'k', 'u'}, {vk_Down, 'k', 'd'}, {vk_Left, 'k', 'l'}, {vk_Right, 'k', 'r'}, {vk_F1, 'k', '1'}, {vk_F2, 'k', '2'}, {vk_F3, 'k', '3'}, {vk_F4, 'k', '4'}, {vk_F5, 'k', '5'}, {vk_F6, 'k', '6'}, {vk_F7, 'k', '7'}, {vk_F8, 'k', '8'}, {vk_F9, 'k', '9'}, {vk_F10, 'k', ';'}, {vk_F11, 'F', '1'}, {vk_F12, 'F', '2'}, {vk_F13, 'F', '3'}, {vk_F14, 'F', '4'}, {vk_F15, 'F', '5'}, // {XK_Help, '%', '1'}, // {XK_Undo, '&', '8'}, // {XK_BackSpace, 'k', 'b'}, // {vk_Delete, 'k', 'b'}, {vk_Insert, 'k', 'I'}, {vk_FwdDelete, 'k', 'D'}, {vk_Home, 'k', 'h'}, {vk_End, '@', '7'}, // {XK_Prior, 'k', 'P'}, // {XK_Next, 'k', 'N'}, // {XK_Print, '%', '9'}, {vk_PageUp, 'k', 'P'}, {vk_PageDown, 'k', 'N'}, // End of list marker: {(KeySym)0, 0, 0} }; /* * ------------------------------------------------------------ * Forward declaration (for those needed) * ------------------------------------------------------------ */ #ifdef USE_AEVENT OSErr HandleUnusedParms(const AppleEvent *theAEvent); #endif #ifdef FEAT_GUI_TABLINE static void initialise_tabline(void); static WindowRef drawer = NULL; // TODO: put into gui.h #endif #ifdef USE_ATSUI_DRAWING static void gui_mac_set_font_attributes(GuiFont font); #endif /* * ------------------------------------------------------------ * Conversion Utility * ------------------------------------------------------------ */ /* * C2Pascal_save * * Allocate memory and convert the C-String passed in * into a pascal string * */ char_u * C2Pascal_save(char_u *Cstring) { char_u *PascalString; int len; if (Cstring == NULL) return NULL; len = STRLEN(Cstring); if (len > 255) // Truncate if necessary len = 255; PascalString = alloc(len + 1); if (PascalString != NULL) { mch_memmove(PascalString + 1, Cstring, len); PascalString[0] = len; } return PascalString; } /* * C2Pascal_save_and_remove_backslash * * Allocate memory and convert the C-String passed in * into a pascal string. Also remove the backslash at the same time * */ char_u * C2Pascal_save_and_remove_backslash(char_u *Cstring) { char_u *PascalString; int len; char_u *p, *c; len = STRLEN(Cstring); if (len > 255) // Truncate if necessary len = 255; PascalString = alloc(len + 1); if (PascalString != NULL) { for (c = Cstring, p = PascalString+1, len = 0; (*c != 0) && (len < 255); c++) { if ((*c == '\\') && (c[1] != 0)) c++; *p = *c; p++; len++; } PascalString[0] = len; } return PascalString; } /* * Convert the modifiers of an Event into vim's modifiers (mouse) */ int_u EventModifiers2VimMouseModifiers(EventModifiers macModifiers) { int_u vimModifiers = 0x00; if (macModifiers & (shiftKey | rightShiftKey)) vimModifiers |= MOUSE_SHIFT; if (macModifiers & (controlKey | rightControlKey)) vimModifiers |= MOUSE_CTRL; if (macModifiers & (optionKey | rightOptionKey)) vimModifiers |= MOUSE_ALT; #if 0 // Not yet supported if (macModifiers & (cmdKey)) // There's no rightCmdKey vimModifiers |= MOUSE_CMD; #endif return (vimModifiers); } /* * Convert the modifiers of an Event into vim's modifiers (keys) */ static int_u EventModifiers2VimModifiers(EventModifiers macModifiers) { int_u vimModifiers = 0x00; if (macModifiers & (shiftKey | rightShiftKey)) vimModifiers |= MOD_MASK_SHIFT; if (macModifiers & (controlKey | rightControlKey)) vimModifiers |= MOD_MASK_CTRL; if (macModifiers & (optionKey | rightOptionKey)) vimModifiers |= MOD_MASK_ALT; #ifdef USE_CMD_KEY if (macModifiers & (cmdKey)) // There's no rightCmdKey vimModifiers |= MOD_MASK_CMD; #endif return (vimModifiers); } /* * Convert a string representing a point size into pixels. The string should * be a positive decimal number, with an optional decimal point (eg, "12", or * "10.5"). The pixel value is returned, and a pointer to the next unconverted * character is stored in *end. The flag "vertical" says whether this * calculation is for a vertical (height) size or a horizontal (width) one. * * From gui_w48.c */ static int points_to_pixels(char_u *str, char_u **end, int vertical) { int pixels; int points = 0; int divisor = 0; while (*str) { if (*str == '.' && divisor == 0) { // Start keeping a divisor, for later divisor = 1; continue; } if (!isdigit(*str)) break; points *= 10; points += *str - '0'; divisor *= 10; ++str; } if (divisor == 0) divisor = 1; pixels = points/divisor; *end = str; return pixels; } #ifdef MACOS_CONVERT /* * Deletes all traces of any Windows-style mnemonic text (including any * parentheses) from a menu item and returns the cleaned menu item title. * The caller is responsible for releasing the returned string. */ static CFStringRef menu_title_removing_mnemonic(vimmenu_T *menu) { CFStringRef name; size_t menuTitleLen; CFIndex displayLen; CFRange mnemonicStart; CFRange mnemonicEnd; CFMutableStringRef cleanedName; menuTitleLen = STRLEN(menu->dname); name = (CFStringRef) mac_enc_to_cfstring(menu->dname, menuTitleLen); if (name) { // Simple mnemonic-removal algorithm, assumes single parenthesized // mnemonic character towards the end of the menu text mnemonicStart = CFStringFind(name, CFSTR("("), kCFCompareBackwards); displayLen = CFStringGetLength(name); if (mnemonicStart.location != kCFNotFound && (mnemonicStart.location + 2) < displayLen && CFStringGetCharacterAtIndex(name, mnemonicStart.location + 1) == (UniChar)menu->mnemonic) { if (CFStringFindWithOptions(name, CFSTR(")"), CFRangeMake(mnemonicStart.location + 1, displayLen - mnemonicStart.location - 1), kCFCompareBackwards, &mnemonicEnd) && (mnemonicStart.location + 2) == mnemonicEnd.location) { cleanedName = CFStringCreateMutableCopy(NULL, 0, name); if (cleanedName) { CFStringDelete(cleanedName, CFRangeMake(mnemonicStart.location, mnemonicEnd.location + 1 - mnemonicStart.location)); CFRelease(name); name = cleanedName; } } } } return name; } #endif /* * Convert a list of FSSpec aliases into a list of fullpathname * character strings. */ char_u ** new_fnames_from_AEDesc(AEDesc *theList, long *numFiles, OSErr *error) { char_u **fnames = NULL; OSErr newError; long fileCount; FSSpec fileToOpen; long actualSize; AEKeyword dummyKeyword; DescType dummyType; // Get number of files in list *error = AECountItems(theList, numFiles); if (*error) return fnames; // Allocate the pointer list fnames = ALLOC_MULT(char_u *, *numFiles); // Empty out the list for (fileCount = 0; fileCount < *numFiles; fileCount++) fnames[fileCount] = NULL; // Scan the list of FSSpec for (fileCount = 1; fileCount <= *numFiles; fileCount++) { // Get the alias for the nth file, convert to an FSSpec newError = AEGetNthPtr(theList, fileCount, typeFSS, &dummyKeyword, &dummyType, (Ptr) &fileToOpen, sizeof(FSSpec), &actualSize); if (newError) { // Caller is able to clean up // TODO: Should be clean up or not? For safety. return fnames; } // Convert the FSSpec to a pathname fnames[fileCount - 1] = FullPathFromFSSpec_save(fileToOpen); } return (fnames); } /* * ------------------------------------------------------------ * CodeWarrior External Editor Support * ------------------------------------------------------------ */ #ifdef FEAT_CW_EDITOR /* * Handle the Window Search event from CodeWarrior * * Description * ----------- * * The IDE sends the Window Search AppleEvent to the editor when it * needs to know whether a particular file is open in the editor. * * Event Reply * ----------- * * None. Put data in the location specified in the structure received. * * Remarks * ------- * * When the editor receives this event, determine whether the specified * file is open. If it is, return the modification date/time for that file * in the appropriate location specified in the structure. If the file is * not opened, put the value fnfErr(file not found) in that location. * */ typedef struct WindowSearch WindowSearch; struct WindowSearch // for handling class 'KAHL', event 'SRCH', keyDirectObject typeChar { FSSpec theFile; // identifies the file long *theDate; // where to put the modification date/time }; pascal OSErr Handle_KAHL_SRCH_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; buf_T *buf; int foundFile = false; DescType typeCode; WindowSearch SearchData; Size actualSize; error = AEGetParamPtr(theAEvent, keyDirectObject, typeChar, &typeCode, (Ptr) &SearchData, sizeof(WindowSearch), &actualSize); if (error) return error; error = HandleUnusedParms(theAEvent); if (error) return error; FOR_ALL_BUFFERS(buf) if (buf->b_ml.ml_mfp != NULL && SearchData.theFile.parID == buf->b_FSSpec.parID && SearchData.theFile.name[0] == buf->b_FSSpec.name[0] && STRNCMP(SearchData.theFile.name, buf->b_FSSpec.name, buf->b_FSSpec.name[0] + 1) == 0) { foundFile = true; break; } if (foundFile == false) *SearchData.theDate = fnfErr; else *SearchData.theDate = buf->b_mtime; return error; }; /* * Handle the Modified (from IDE to Editor) event from CodeWarrior * * Description * ----------- * * The IDE sends this event to the external editor when it wants to * know which files that are open in the editor have been modified. * * Parameters None. * ---------- * * Event Reply * ----------- * The reply for this event is: * * keyDirectObject typeAEList required * each element in the list is a structure of typeChar * * Remarks * ------- * * When building the reply event, include one element in the list for * each open file that has been modified. * */ typedef struct ModificationInfo ModificationInfo; struct ModificationInfo // for replying to class 'KAHL', event 'MOD ', keyDirectObject typeAEList { FSSpec theFile; // identifies the file long theDate; // the date/time the file was last modified short saved; // set this to zero when replying, unused }; pascal OSErr Handle_KAHL_MOD_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; AEDescList replyList; long numFiles; ModificationInfo theFile; buf_T *buf; theFile.saved = 0; error = HandleUnusedParms(theAEvent); if (error) return error; // Send the reply // replyObject.descriptorType = typeNull; // replyObject.dataHandle = nil; // AECreateDesc(typeChar, (Ptr)&title[1], title[0], &data) error = AECreateList(nil, 0, false, &replyList); if (error) return error; #if 0 error = AECountItems(&replyList, &numFiles); // AEPutKeyDesc(&replyList, keyAEPnject, &aDesc) // AEPutKeyPtr(&replyList, keyAEPosition, typeChar, (Ptr)&theType, // sizeof(DescType)) // AEPutDesc #endif numFiles = 0; FOR_ALL_BUFFERS(buf) if (buf->b_ml.ml_mfp != NULL) { // Add this file to the list theFile.theFile = buf->b_FSSpec; theFile.theDate = buf->b_mtime; // theFile.theDate = time(NULL) & (time_t) 0xFFFFFFF0; error = AEPutPtr(&replyList, numFiles, typeChar, (Ptr) &theFile, sizeof(theFile)); }; #if 0 error = AECountItems(&replyList, &numFiles); #endif // We can add data only if something to reply error = AEPutParamDesc(theReply, keyDirectObject, &replyList); if (replyList.dataHandle) AEDisposeDesc(&replyList); return error; }; /* * Handle the Get Text event from CodeWarrior * * Description * ----------- * * The IDE sends the Get Text AppleEvent to the editor when it needs * the source code from a file. For example, when the user issues a * Check Syntax or Compile command, the compiler needs access to * the source code contained in the file. * * Event Reply * ----------- * * None. Put data in locations specified in the structure received. * * Remarks * ------- * * When the editor receives this event, it must set the size of the handle * in theText to fit the data in the file. It must then copy the entire * contents of the specified file into the memory location specified in * theText. * */ typedef struct CW_GetText CW_GetText; struct CW_GetText // for handling class 'KAHL', event 'GTTX', keyDirectObject typeChar { FSSpec theFile; // identifies the file Handle theText; // the location where you return the text (must be resized properly) long *unused; // 0 (not used) long *theDate; // where to put the modification date/time }; pascal OSErr Handle_KAHL_GTTX_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; buf_T *buf; int foundFile = false; DescType typeCode; CW_GetText GetTextData; Size actualSize; char_u *line; char_u *fullbuffer = NULL; long linesize; long lineStart; long BufferSize; long lineno; error = AEGetParamPtr(theAEvent, keyDirectObject, typeChar, &typeCode, (Ptr) &GetTextData, sizeof(GetTextData), &actualSize); if (error) return error; FOR_ALL_BUFFERS(buf) if (buf->b_ml.ml_mfp != NULL) if (GetTextData.theFile.parID == buf->b_FSSpec.parID) { foundFile = true; break; } if (foundFile) { BufferSize = 0; // GetHandleSize(GetTextData.theText); for (lineno = 0; lineno <= buf->b_ml.ml_line_count; lineno++) { // Must use the right buffer line = ml_get_buf(buf, (linenr_T) lineno, FALSE); linesize = STRLEN(line) + 1; lineStart = BufferSize; BufferSize += linesize; // Resize handle to linesize+1 to include the linefeed SetHandleSize(GetTextData.theText, BufferSize); if (GetHandleSize(GetTextData.theText) != BufferSize) { break; // Simple handling for now } else { HLock(GetTextData.theText); fullbuffer = (char_u *) *GetTextData.theText; STRCPY((char_u *)(fullbuffer + lineStart), line); fullbuffer[BufferSize-1] = '\r'; HUnlock(GetTextData.theText); } } if (fullbuffer != NULL) { HLock(GetTextData.theText); fullbuffer[BufferSize-1] = 0; HUnlock(GetTextData.theText); } if (foundFile == false) *GetTextData.theDate = fnfErr; else // *GetTextData.theDate = time(NULL) & (time_t) 0xFFFFFFF0; *GetTextData.theDate = buf->b_mtime; } error = HandleUnusedParms(theAEvent); return error; } /* * */ /* * Taken from MoreAppleEvents:ProcessHelpers */ pascal OSErr FindProcessBySignature( const OSType targetType, const OSType targetCreator, ProcessSerialNumberPtr psnPtr) { OSErr anErr = noErr; Boolean lookingForProcess = true; ProcessInfoRec infoRec; infoRec.processInfoLength = sizeof(ProcessInfoRec); infoRec.processName = nil; infoRec.processAppSpec = nil; psnPtr->lowLongOfPSN = kNoProcess; psnPtr->highLongOfPSN = kNoProcess; while (lookingForProcess) { anErr = GetNextProcess(psnPtr); if (anErr != noErr) lookingForProcess = false; else { anErr = GetProcessInformation(psnPtr, &infoRec); if ((anErr == noErr) && (infoRec.processType == targetType) && (infoRec.processSignature == targetCreator)) lookingForProcess = false; } } return anErr; }//end FindProcessBySignature void Send_KAHL_MOD_AE(buf_T *buf) { OSErr anErr = noErr; AEDesc targetAppDesc = { typeNull, nil }; ProcessSerialNumber psn = { kNoProcess, kNoProcess }; AppleEvent theReply = { typeNull, nil }; AESendMode sendMode; AppleEvent theEvent = {typeNull, nil }; AEIdleUPP idleProcUPP = nil; ModificationInfo ModData; anErr = FindProcessBySignature('APPL', 'CWIE', &psn); if (anErr == noErr) { anErr = AECreateDesc(typeProcessSerialNumber, &psn, sizeof(ProcessSerialNumber), &targetAppDesc); if (anErr == noErr) { anErr = AECreateAppleEvent( 'KAHL', 'MOD ', &targetAppDesc, kAutoGenerateReturnID, kAnyTransactionID, &theEvent); } AEDisposeDesc(&targetAppDesc); // Add the parms ModData.theFile = buf->b_FSSpec; ModData.theDate = buf->b_mtime; if (anErr == noErr) anErr = AEPutParamPtr(&theEvent, keyDirectObject, typeChar, &ModData, sizeof(ModData)); if (idleProcUPP == nil) sendMode = kAENoReply; else sendMode = kAEWaitReply; if (anErr == noErr) anErr = AESend(&theEvent, &theReply, sendMode, kAENormalPriority, kNoTimeOut, idleProcUPP, nil); if (anErr == noErr && sendMode == kAEWaitReply) { // anErr = AEHGetHandlerError(&theReply); } (void) AEDisposeDesc(&theReply); } } #endif // FEAT_CW_EDITOR /* * ------------------------------------------------------------ * Apple Event Handling procedure * ------------------------------------------------------------ */ #ifdef USE_AEVENT /* * Handle the Unused parms of an AppleEvent */ OSErr HandleUnusedParms(const AppleEvent *theAEvent) { OSErr error; long actualSize; DescType dummyType; AEKeyword missedKeyword; // Get the "missed keyword" attribute from the AppleEvent. error = AEGetAttributePtr(theAEvent, keyMissedKeywordAttr, typeKeyword, &dummyType, (Ptr)&missedKeyword, sizeof(missedKeyword), &actualSize); // If the descriptor isn't found, then we got the required parameters. if (error == errAEDescNotFound) { error = noErr; } else { #if 0 // Why is this removed? error = errAEEventNotHandled; #endif } return error; } /* * Handle the ODoc AppleEvent * * Deals with all files dragged to the application icon. * */ typedef struct SelectionRange SelectionRange; struct SelectionRange // for handling kCoreClassEvent:kOpenDocuments:keyAEPosition typeChar { short unused1; // 0 (not used) short lineNum; // line to select (<0 to specify range) long startRange; // start of selection range (if line < 0) long endRange; // end of selection range (if line < 0) long unused2; // 0 (not used) long theDate; // modification date/time }; static long drop_numFiles; static short drop_gotPosition; static SelectionRange drop_thePosition; static void drop_callback(void *cookie UNUSED) { // TODO: Handle the goto/select line more cleanly if ((drop_numFiles == 1) & (drop_gotPosition)) { if (drop_thePosition.lineNum >= 0) { lnum = drop_thePosition.lineNum + 1; // oap->motion_type = MLINE; // setpcmark(); if (lnum < 1L) lnum = 1L; else if (lnum > curbuf->b_ml.ml_line_count) lnum = curbuf->b_ml.ml_line_count; curwin->w_cursor.lnum = lnum; curwin->w_cursor.col = 0; // beginline(BL_SOL | BL_FIX); } else goto_byte(drop_thePosition.startRange + 1); } // Update the screen display update_screen(NOT_VALID); // Select the text if possible if (drop_gotPosition) { VIsual_active = TRUE; VIsual_select = FALSE; VIsual = curwin->w_cursor; if (drop_thePosition.lineNum < 0) { VIsual_mode = 'v'; goto_byte(drop_thePosition.endRange); } else { VIsual_mode = 'V'; VIsual.col = 0; } } } /* * The IDE uses the optional keyAEPosition parameter to tell the ed- * itor the selection range. If lineNum is zero or greater, scroll the text * to the specified line. If lineNum is less than zero, use the values in * startRange and endRange to select the specified characters. Scroll * the text to display the selection. If lineNum, startRange, and * endRange are all negative, there is no selection range specified. */ pascal OSErr HandleODocAE(const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { /* * TODO: Clean up the code with convert the AppleEvent into * a ":args" */ OSErr error = noErr; // OSErr firstError = noErr; // short numErrors = 0; AEDesc theList; DescType typeCode; long numFiles; // long fileCount; char_u **fnames; // char_u fname[256]; Size actualSize; SelectionRange thePosition; short gotPosition = false; long lnum; // the direct object parameter is the list of aliases to files (one or more) error = AEGetParamDesc(theAEvent, keyDirectObject, typeAEList, &theList); if (error) return error; error = AEGetParamPtr(theAEvent, keyAEPosition, typeChar, &typeCode, (Ptr) &thePosition, sizeof(SelectionRange), &actualSize); if (error == noErr) gotPosition = true; if (error == errAEDescNotFound) error = noErr; if (error) return error; /* error = AEGetParamDesc(theAEvent, keyAEPosition, typeChar, &thePosition); if (^error) then { if (thePosition.lineNum >= 0) { // Goto this line } else { // Set the range char wise } } */ reset_VIsual(); fnames = new_fnames_from_AEDesc(&theList, &numFiles, &error); if (error) { // TODO: empty fnames[] first vim_free(fnames); return (error); } if (starting > 0) { int i; char_u *p; int fnum = -1; // these are the initial files dropped on the Vim icon for (i = 0 ; i < numFiles; i++) { if (ga_grow(&global_alist.al_ga, 1) == FAIL || (p = vim_strsave(fnames[i])) == NULL) mch_exit(2); else alist_add(&global_alist, p, 2); if (fnum == -1) fnum = GARGLIST[GARGCOUNT - 1].ae_fnum; } // If the file name was already in the buffer list we need to switch // to it. if (curbuf->b_fnum != fnum) { char_u cmd[30]; vim_snprintf((char *)cmd, 30, "silent %dbuffer", fnum); do_cmdline_cmd(cmd); } // Change directory to the location of the first file. if (GARGCOUNT > 0 && vim_chdirfile(alist_name(&GARGLIST[0]), "drop") == OK) shorten_fnames(TRUE); goto finished; } // Handle the drop, :edit to get to the file drop_numFiles = numFiles; drop_gotPosition = gotPosition; drop_thePosition = thePosition; handle_drop(numFiles, fnames, FALSE, drop_callback, NULL); setcursor(); out_flush(); // Fake mouse event to wake from stall PostEvent(mouseUp, 0); finished: AEDisposeDesc(&theList); // dispose what we allocated error = HandleUnusedParms(theAEvent); return error; } /* * */ pascal OSErr Handle_aevt_oapp_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; error = HandleUnusedParms(theAEvent); return error; } /* * */ pascal OSErr Handle_aevt_quit_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; error = HandleUnusedParms(theAEvent); if (error) return error; // Need to fake a :confirm qa do_cmdline_cmd((char_u *)"confirm qa"); return error; } /* * */ pascal OSErr Handle_aevt_pdoc_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; error = HandleUnusedParms(theAEvent); return error; } /* * Handling of unknown AppleEvent * * (Just get rid of all the parms) */ pascal OSErr Handle_unknown_AE( const AppleEvent *theAEvent, AppleEvent *theReply, long refCon) { OSErr error = noErr; error = HandleUnusedParms(theAEvent); return error; } /* * Install the various AppleEvent Handlers */ OSErr InstallAEHandlers(void) { OSErr error; // install open application handler error = AEInstallEventHandler(kCoreEventClass, kAEOpenApplication, NewAEEventHandlerUPP(Handle_aevt_oapp_AE), 0, false); if (error) return error; // install quit application handler error = AEInstallEventHandler(kCoreEventClass, kAEQuitApplication, NewAEEventHandlerUPP(Handle_aevt_quit_AE), 0, false); if (error) return error; // install open document handler error = AEInstallEventHandler(kCoreEventClass, kAEOpenDocuments, NewAEEventHandlerUPP(HandleODocAE), 0, false); if (error) return error; // install print document handler error = AEInstallEventHandler(kCoreEventClass, kAEPrintDocuments, NewAEEventHandlerUPP(Handle_aevt_pdoc_AE), 0, false); // Install Core Suite #if 0 error = AEInstallEventHandler(kAECoreSuite, kAEClone, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEClose, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAECountElements, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAECreateElement, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEDelete, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEDoObjectsExist, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEGetData, NewAEEventHandlerUPP(Handle_unknown_AE), kAEGetData, false); error = AEInstallEventHandler(kAECoreSuite, kAEGetDataSize, NewAEEventHandlerUPP(Handle_unknown_AE), kAEGetDataSize, false); error = AEInstallEventHandler(kAECoreSuite, kAEGetClassInfo, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEGetEventInfo, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAEMove, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAESave, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); error = AEInstallEventHandler(kAECoreSuite, kAESetData, NewAEEventHandlerUPP(Handle_unknown_AE), nil, false); #endif #ifdef FEAT_CW_EDITOR /* * Bind codewarrior support handlers */ error = AEInstallEventHandler('KAHL', 'GTTX', NewAEEventHandlerUPP(Handle_KAHL_GTTX_AE), 0, false); if (error) return error; error = AEInstallEventHandler('KAHL', 'SRCH', NewAEEventHandlerUPP(Handle_KAHL_SRCH_AE), 0, false); if (error) return error; error = AEInstallEventHandler('KAHL', 'MOD ', NewAEEventHandlerUPP(Handle_KAHL_MOD_AE), 0, false); #endif return error; } #endif // USE_AEVENT /* * Callback function, installed by InstallFontPanelHandler(), below, * to handle Font Panel events. */ static OSStatus FontPanelHandler( EventHandlerCallRef inHandlerCallRef, EventRef inEvent, void *inUserData) { if (GetEventKind(inEvent) == kEventFontPanelClosed) { gFontPanelInfo.isPanelVisible = false; return noErr; } if (GetEventKind(inEvent) == kEventFontSelection) { OSStatus status; FMFontFamily newFamily; FMFontSize newSize; FMFontStyle newStyle; // Retrieve the font family ID number. status = GetEventParameter(inEvent, kEventParamFMFontFamily, /*inDesiredType=*/typeFMFontFamily, /*outActualType=*/NULL, /*inBufferSize=*/sizeof(FMFontFamily), /*outActualSize=*/NULL, &newFamily); if (status == noErr) gFontPanelInfo.family = newFamily; // Retrieve the font size. status = GetEventParameter(inEvent, kEventParamFMFontSize, typeFMFontSize, NULL, sizeof(FMFontSize), NULL, &newSize); if (status == noErr) gFontPanelInfo.size = newSize; // Retrieve the font style (bold, etc.). Currently unused. status = GetEventParameter(inEvent, kEventParamFMFontStyle, typeFMFontStyle, NULL, sizeof(FMFontStyle), NULL, &newStyle); if (status == noErr) gFontPanelInfo.style = newStyle; } return noErr; } static void InstallFontPanelHandler(void) { EventTypeSpec eventTypes[2]; EventHandlerUPP handlerUPP; // EventHandlerRef handlerRef; eventTypes[0].eventClass = kEventClassFont; eventTypes[0].eventKind = kEventFontSelection; eventTypes[1].eventClass = kEventClassFont; eventTypes[1].eventKind = kEventFontPanelClosed; handlerUPP = NewEventHandlerUPP(FontPanelHandler); InstallApplicationEventHandler(handlerUPP, /*numTypes=*/2, eventTypes, /*userData=*/NULL, /*handlerRef=*/NULL); } /* * Fill the buffer pointed to by outName with the name and size * of the font currently selected in the Font Panel. */ #define FONT_STYLE_BUFFER_SIZE 32 static void GetFontPanelSelection(char_u *outName) { Str255 buf; ByteCount fontNameLen = 0; ATSUFontID fid; char_u styleString[FONT_STYLE_BUFFER_SIZE]; if (!outName) return; if (FMGetFontFamilyName(gFontPanelInfo.family, buf) == noErr) { // Canonicalize localized font names if (FMGetFontFromFontFamilyInstance(gFontPanelInfo.family, gFontPanelInfo.style, &fid, NULL) != noErr) return; // Request font name with Mac encoding (otherwise we could // get an unwanted utf-16 name) if (ATSUFindFontName(fid, kFontFullName, kFontMacintoshPlatform, kFontNoScriptCode, kFontNoLanguageCode, 255, (char *)outName, &fontNameLen, NULL) != noErr) return; // Only encode font size, because style (bold, italic, etc) is // already part of the font full name vim_snprintf((char *)styleString, FONT_STYLE_BUFFER_SIZE, ":h%d", gFontPanelInfo.size/*, ((gFontPanelInfo.style & bold)!=0 ? ":b" : ""), ((gFontPanelInfo.style & italic)!=0 ? ":i" : ""), ((gFontPanelInfo.style & underline)!=0 ? ":u" : "")*/); if ((fontNameLen + STRLEN(styleString)) < 255) STRCPY(outName + fontNameLen, styleString); } else { *outName = NUL; } } /* * ------------------------------------------------------------ * Unfiled yet * ------------------------------------------------------------ */ /* * gui_mac_get_menu_item_index * * Returns the index inside the menu where */ short // Should we return MenuItemIndex? gui_mac_get_menu_item_index(vimmenu_T *pMenu) { short index; short itemIndex = -1; vimmenu_T *pBrother; // Only menu without parent are the: // -menu in the menubar // -popup menu // -toolbar (guess) // // Which are not items anyway. if (pMenu->parent) { // Start from the Oldest Brother pBrother = pMenu->parent->children; index = 1; while ((pBrother) && (itemIndex == -1)) { if (pBrother == pMenu) itemIndex = index; index++; pBrother = pBrother->next; } } return itemIndex; } static vimmenu_T * gui_mac_get_vim_menu(short menuID, short itemIndex, vimmenu_T *pMenu) { short index; vimmenu_T *pChildMenu; vimmenu_T *pElder = pMenu->parent; // Only menu without parent are the: // -menu in the menubar // -popup menu // -toolbar (guess) // // Which are not items anyway. if ((pElder) && (pElder->submenu_id == menuID)) { for (index = 1; (index != itemIndex) && (pMenu != NULL); index++) pMenu = pMenu->next; } else { for (; pMenu != NULL; pMenu = pMenu->next) { if (pMenu->children != NULL) { pChildMenu = gui_mac_get_vim_menu (menuID, itemIndex, pMenu->children); if (pChildMenu) { pMenu = pChildMenu; break; } } } } return pMenu; } /* * ------------------------------------------------------------ * MacOS Feedback procedures * ------------------------------------------------------------ */ pascal void gui_mac_drag_thumb(ControlHandle theControl, short partCode) { scrollbar_T *sb; int value, dragging; ControlHandle theControlToUse; int dont_scroll_save = dont_scroll; theControlToUse = dragged_sb; sb = gui_find_scrollbar((long) GetControlReference(theControlToUse)); if (sb == NULL) return; // Need to find value by diff between Old Poss New Pos value = GetControl32BitValue(theControlToUse); dragging = (partCode != 0); // When "allow_scrollbar" is FALSE still need to remember the new // position, but don't actually scroll by setting "dont_scroll". dont_scroll = !allow_scrollbar; gui_drag_scrollbar(sb, value, dragging); dont_scroll = dont_scroll_save; } pascal void gui_mac_scroll_action(ControlHandle theControl, short partCode) { // TODO: have live support scrollbar_T *sb, *sb_info; long data; long value; int page; int dragging = FALSE; int dont_scroll_save = dont_scroll; sb = gui_find_scrollbar((long)GetControlReference(theControl)); if (sb == NULL) return; if (sb->wp != NULL) // Left or right scrollbar { /* * Careful: need to get scrollbar info out of first (left) scrollbar * for window, but keep real scrollbar too because we must pass it to * gui_drag_scrollbar(). */ sb_info = &sb->wp->w_scrollbars[0]; if (sb_info->size > 5) page = sb_info->size - 2; // use two lines of context else page = sb_info->size; } else // Bottom scrollbar { sb_info = sb; page = curwin->w_width - 5; } switch (partCode) { case kControlUpButtonPart: data = -1; break; case kControlDownButtonPart: data = 1; break; case kControlPageDownPart: data = page; break; case kControlPageUpPart: data = -page; break; default: data = 0; break; } value = sb_info->value + data; // if (value > sb_info->max) // value = sb_info->max; // else if (value < 0) // value = 0; // When "allow_scrollbar" is FALSE still need to remember the new // position, but don't actually scroll by setting "dont_scroll". dont_scroll = !allow_scrollbar; gui_drag_scrollbar(sb, value, dragging); dont_scroll = dont_scroll_save; out_flush(); gui_mch_set_scrollbar_thumb(sb, value, sb_info->size, sb_info->max); #if 0 if (sb_info->wp != NULL) { win_T *wp; int sb_num; sb_num = 0; for (wp = firstwin; wp != sb->wp && wp != NULL; wp = W_NEXT(wp)) sb_num++; if (wp != NULL) { current_scrollbar = sb_num; scrollbar_value = value; gui_do_scroll(); gui_mch_set_scrollbar_thumb(sb, value, sb_info->size, sb_info->max); } } #endif } /* * ------------------------------------------------------------ * MacOS Click Handling procedures * ------------------------------------------------------------ */ /* * Handle a click inside the window, it may happens in the * scrollbar or the contents. * * TODO: Add support for potential TOOLBAR */ void gui_mac_doInContentClick(EventRecord *theEvent, WindowPtr whichWindow) { Point thePoint; int_u vimModifiers; short thePortion; ControlHandle theControl; int vimMouseButton; short dblClick; thePoint = theEvent->where; GlobalToLocal(&thePoint); SelectWindow(whichWindow); thePortion = FindControl(thePoint, whichWindow, &theControl); if (theControl != NUL) { // We hit a scrollbar if (thePortion != kControlIndicatorPart) { dragged_sb = theControl; TrackControl(theControl, thePoint, gScrollAction); dragged_sb = NULL; } else { dragged_sb = theControl; #if 1 TrackControl(theControl, thePoint, gScrollDrag); #else TrackControl(theControl, thePoint, NULL); #endif // pass 0 as the part to tell gui_mac_drag_thumb, that the mouse // button has been released gui_mac_drag_thumb(theControl, 0); // Should it be thePortion ? (Dany) dragged_sb = NULL; } } else { // We are inside the contents // Convert the CTRL, OPTION, SHIFT and CMD key vimModifiers = EventModifiers2VimMouseModifiers(theEvent->modifiers); // Defaults to MOUSE_LEFT as there's only one mouse button vimMouseButton = MOUSE_LEFT; // Convert the CTRL_MOUSE_LEFT to MOUSE_RIGHT // TODO: NEEDED? clickIsPopup = FALSE; if (mouse_model_popup() && IsShowContextualMenuClick(theEvent)) { vimMouseButton = MOUSE_RIGHT; vimModifiers &= ~MOUSE_CTRL; clickIsPopup = TRUE; } // Is it a double click ? dblClick = ((theEvent->when - lastMouseTick) < GetDblTime()); // Send the mouse click to Vim gui_send_mouse_event(vimMouseButton, thePoint.h, thePoint.v, dblClick, vimModifiers); // Create the rectangle around the cursor to detect // the mouse dragging #if 0 // TODO: Do we need to this even for the contextual menu? // It may be require for popup_setpos, but for popup? if (vimMouseButton == MOUSE_LEFT) #endif { SetRect(&dragRect, FILL_X(X_2_COL(thePoint.h)), FILL_Y(Y_2_ROW(thePoint.v)), FILL_X(X_2_COL(thePoint.h)+1), FILL_Y(Y_2_ROW(thePoint.v)+1)); dragRectEnbl = TRUE; dragRectControl = kCreateRect; } } } /* * Handle the click in the titlebar (to move the window) */ void gui_mac_doInDragClick(Point where, WindowPtr whichWindow) { Rect movingLimits; Rect *movingLimitsPtr = &movingLimits; // TODO: may try to prevent move outside screen? movingLimitsPtr = GetRegionBounds(GetGrayRgn(), &movingLimits); DragWindow(whichWindow, where, movingLimitsPtr); } /* * Handle the click in the grow box */ void gui_mac_doInGrowClick(Point where, WindowPtr whichWindow) { long newSize; unsigned short newWidth; unsigned short newHeight; Rect resizeLimits; Rect *resizeLimitsPtr = &resizeLimits; Rect NewContentRect; resizeLimitsPtr = GetRegionBounds(GetGrayRgn(), &resizeLimits); // Set the minimum size // TODO: Should this come from Vim? resizeLimits.top = 100; resizeLimits.left = 100; newSize = ResizeWindow(whichWindow, where, &resizeLimits, &NewContentRect); newWidth = NewContentRect.right - NewContentRect.left; newHeight = NewContentRect.bottom - NewContentRect.top; gui_resize_shell(newWidth, newHeight); gui_mch_set_bg_color(gui.back_pixel); gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH); } /* * Handle the click in the zoom box */ static void gui_mac_doInZoomClick(EventRecord *theEvent, WindowPtr whichWindow) { Rect r; Point p; short thePart; // ideal width is current p.h = Columns * gui.char_width + 2 * gui.border_offset; if (gui.which_scrollbars[SBAR_LEFT]) p.h += gui.scrollbar_width; if (gui.which_scrollbars[SBAR_RIGHT]) p.h += gui.scrollbar_width; // ideal height is as high as we can get p.v = 15 * 1024; thePart = IsWindowInStandardState(whichWindow, &p, &r) ? inZoomIn : inZoomOut; if (!TrackBox(whichWindow, theEvent->where, thePart)) return; // use returned width p.h = r.right - r.left; // adjust returned height p.v = r.bottom - r.top - 2 * gui.border_offset; if (gui.which_scrollbars[SBAR_BOTTOM]) p.v -= gui.scrollbar_height; p.v -= p.v % gui.char_height; p.v += 2 * gui.border_width; if (gui.which_scrollbars[SBAR_BOTTOM]) p.v += gui.scrollbar_height; ZoomWindowIdeal(whichWindow, thePart, &p); GetWindowBounds(whichWindow, kWindowContentRgn, &r); gui_resize_shell(r.right - r.left, r.bottom - r.top); gui_mch_set_bg_color(gui.back_pixel); gui_set_shellsize(TRUE, FALSE, RESIZE_BOTH); } /* * ------------------------------------------------------------ * MacOS Event Handling procedure * ------------------------------------------------------------ */ /* * Handle the Update Event */ void gui_mac_doUpdateEvent(EventRecord *event) { WindowPtr whichWindow; GrafPtr savePort; RgnHandle updateRgn; Rect updateRect; Rect *updateRectPtr; Rect rc; Rect growRect; RgnHandle saveRgn; updateRgn = NewRgn(); if (updateRgn == NULL) return; // This could be done by the caller as we // don't require anything else out of the event whichWindow = (WindowPtr) event->message; // Save Current Port GetPort(&savePort); // Select the Window's Port SetPortWindowPort(whichWindow); // Let's update the window BeginUpdate(whichWindow); // Redraw the biggest rectangle covering the area // to be updated. GetPortVisibleRegion(GetWindowPort(whichWindow), updateRgn); # if 0 // Would be more appropriate to use the following but doesn't // seem to work under MacOS X (Dany) GetWindowRegion(whichWindow, kWindowUpdateRgn, updateRgn); # endif // Use the HLock useless in Carbon? Is it harmful? HLock((Handle) updateRgn); updateRectPtr = GetRegionBounds(updateRgn, &updateRect); # if 0 // Code from original Carbon Port (using GetWindowRegion. // I believe the UpdateRgn is already in local (Dany) GlobalToLocal(&topLeft(updateRect)); // preCarbon? GlobalToLocal(&botRight(updateRect)); # endif // Update the content (i.e. the text) gui_redraw(updateRectPtr->left, updateRectPtr->top, updateRectPtr->right - updateRectPtr->left, updateRectPtr->bottom - updateRectPtr->top); // Clear the border areas if needed gui_mch_set_bg_color(gui.back_pixel); if (updateRectPtr->left < FILL_X(0)) { SetRect(&rc, 0, 0, FILL_X(0), FILL_Y(Rows)); EraseRect(&rc); } if (updateRectPtr->top < FILL_Y(0)) { SetRect(&rc, 0, 0, FILL_X(Columns), FILL_Y(0)); EraseRect(&rc); } if (updateRectPtr->right > FILL_X(Columns)) { SetRect(&rc, FILL_X(Columns), 0, FILL_X(Columns) + gui.border_offset, FILL_Y(Rows)); EraseRect(&rc); } if (updateRectPtr->bottom > FILL_Y(Rows)) { SetRect(&rc, 0, FILL_Y(Rows), FILL_X(Columns) + gui.border_offset, FILL_Y(Rows) + gui.border_offset); EraseRect(&rc); } HUnlock((Handle) updateRgn); DisposeRgn(updateRgn); // Update scrollbars DrawControls(whichWindow); // Update the GrowBox // Taken from FAQ 33-27 saveRgn = NewRgn(); GetWindowBounds(whichWindow, kWindowGrowRgn, &growRect); GetClip(saveRgn); ClipRect(&growRect); DrawGrowIcon(whichWindow); SetClip(saveRgn); DisposeRgn(saveRgn); EndUpdate(whichWindow); // Restore original Port SetPort(savePort); } /* * Handle the activate/deactivate event * (apply to a window) */ void gui_mac_doActivateEvent(EventRecord *event) { WindowPtr whichWindow; whichWindow = (WindowPtr) event->message; // Dim scrollbars if (whichWindow == gui.VimWindow) { ControlRef rootControl; GetRootControl(gui.VimWindow, &rootControl); if ((event->modifiers) & activeFlag) ActivateControl(rootControl); else DeactivateControl(rootControl); } // Activate gui_focus_change((event->modifiers) & activeFlag); } /* * Handle the suspend/resume event * (apply to the application) */ void gui_mac_doSuspendEvent(EventRecord *event) { // The frontmost application just changed // NOTE: the suspend may happen before the deactivate // seen on MacOS X // May not need to change focus as the window will // get an activate/deactivate event if (event->message & 1) // Resume gui_focus_change(TRUE); else // Suspend gui_focus_change(FALSE); } /* * Handle the key */ #ifdef USE_CARBONKEYHANDLER static pascal OSStatus gui_mac_handle_window_activate( EventHandlerCallRef nextHandler, EventRef theEvent, void *data) { UInt32 eventClass = GetEventClass(theEvent); UInt32 eventKind = GetEventKind(theEvent); if (eventClass == kEventClassWindow) { switch (eventKind) { case kEventWindowActivated: im_on_window_switch(TRUE); return noErr; case kEventWindowDeactivated: im_on_window_switch(FALSE); return noErr; } } return eventNotHandledErr; } static pascal OSStatus gui_mac_handle_text_input( EventHandlerCallRef nextHandler, EventRef theEvent, void *data) { UInt32 eventClass = GetEventClass(theEvent); UInt32 eventKind = GetEventKind(theEvent); if (eventClass != kEventClassTextInput) return eventNotHandledErr; if ((kEventTextInputUpdateActiveInputArea != eventKind) && (kEventTextInputUnicodeForKeyEvent != eventKind) && (kEventTextInputOffsetToPos != eventKind) && (kEventTextInputPosToOffset != eventKind) && (kEventTextInputGetSelectedText != eventKind)) return eventNotHandledErr; switch (eventKind) { case kEventTextInputUpdateActiveInputArea: return gui_mac_update_input_area(nextHandler, theEvent); case kEventTextInputUnicodeForKeyEvent: return gui_mac_unicode_key_event(nextHandler, theEvent); case kEventTextInputOffsetToPos: case kEventTextInputPosToOffset: case kEventTextInputGetSelectedText: break; } return eventNotHandledErr; } static pascal OSStatus gui_mac_update_input_area( EventHandlerCallRef nextHandler, EventRef theEvent) { return eventNotHandledErr; } static int dialog_busy = FALSE; // TRUE when gui_mch_dialog() wants the // keys # define INLINE_KEY_BUFFER_SIZE 80 static pascal OSStatus gui_mac_unicode_key_event( EventHandlerCallRef nextHandler, EventRef theEvent) { // Multibyte-friendly key event handler OSStatus err = -1; UInt32 actualSize; UniChar *text; char_u result[INLINE_KEY_BUFFER_SIZE]; short len = 0; UInt32 key_sym; char charcode; int key_char; UInt32 modifiers, vimModifiers; size_t encLen; char_u *to = NULL; Boolean isSpecial = FALSE; int i; EventRef keyEvent; // Mask the mouse (as per user setting) if (p_mh) ObscureCursor(); // Don't use the keys when the dialog wants them. if (dialog_busy) return eventNotHandledErr; if (noErr != GetEventParameter(theEvent, kEventParamTextInputSendText, typeUnicodeText, NULL, 0, &actualSize, NULL)) return eventNotHandledErr; text = alloc(actualSize); if (!text) return eventNotHandledErr; err = GetEventParameter(theEvent, kEventParamTextInputSendText, typeUnicodeText, NULL, actualSize, NULL, text); require_noerr(err, done); err = GetEventParameter(theEvent, kEventParamTextInputSendKeyboardEvent, typeEventRef, NULL, sizeof(EventRef), NULL, &keyEvent); require_noerr(err, done); err = GetEventParameter(keyEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &modifiers); require_noerr(err, done); err = GetEventParameter(keyEvent, kEventParamKeyCode, typeUInt32, NULL, sizeof(UInt32), NULL, &key_sym); require_noerr(err, done); err = GetEventParameter(keyEvent, kEventParamKeyMacCharCodes, typeChar, NULL, sizeof(char), NULL, &charcode); require_noerr(err, done); #ifndef USE_CMD_KEY if (modifiers & cmdKey) goto done; // Let system handle Cmd+... #endif key_char = charcode; vimModifiers = EventModifiers2VimModifiers(modifiers); // Find the special key (eg., for cursor keys) if (actualSize <= sizeof(UniChar) && ((text[0] < 0x20) || (text[0] == 0x7f))) { for (i = 0; special_keys[i].key_sym != (KeySym)0; ++i) if (special_keys[i].key_sym == key_sym) { key_char = TO_SPECIAL(special_keys[i].vim_code0, special_keys[i].vim_code1); key_char = simplify_key(key_char, (int *)&vimModifiers); isSpecial = TRUE; break; } } // Intercept CMD-. and CTRL-c if (((modifiers & controlKey) && key_char == 'c') || ((modifiers & cmdKey) && key_char == '.')) got_int = TRUE; if (!isSpecial) { // remove SHIFT for keys that are already shifted, e.g., // '(' and '*' if (key_char < 0x100 && !isalpha(key_char) && isprint(key_char)) vimModifiers &= ~MOD_MASK_SHIFT; // remove CTRL from keys that already have it if (key_char < 0x20) vimModifiers &= ~MOD_MASK_CTRL; // don't process unicode characters here if (!IS_SPECIAL(key_char)) { // Following code to simplify and consolidate vimModifiers // taken liberally from gui_w48.c key_char = simplify_key(key_char, (int *)&vimModifiers); // Unify modifiers somewhat. No longer use ALT to set the 8th bit. key_char = extract_modifiers(key_char, (int *)&vimModifiers, FALSE, NULL); if (key_char == CSI) key_char = K_CSI; if (IS_SPECIAL(key_char)) isSpecial = TRUE; } } if (vimModifiers) { result[len++] = CSI; result[len++] = KS_MODIFIER; result[len++] = vimModifiers; } if (isSpecial && IS_SPECIAL(key_char)) { result[len++] = CSI; result[len++] = K_SECOND(key_char); result[len++] = K_THIRD(key_char); } else { encLen = actualSize; to = mac_utf16_to_enc(text, actualSize, &encLen); if (to) { // This is basically add_to_input_buf_csi() for (i = 0; i < encLen && len < (INLINE_KEY_BUFFER_SIZE-1); ++i) { result[len++] = to[i]; if (to[i] == CSI) { result[len++] = KS_EXTRA; result[len++] = (int)KE_CSI; } } vim_free(to); } } add_to_input_buf(result, len); err = noErr; done: vim_free(text); if (err == noErr) { // Fake event to wake up WNE (required to get // key repeat working PostEvent(keyUp, 0); return noErr; } return eventNotHandledErr; } #else void gui_mac_doKeyEvent(EventRecord *theEvent) { // TODO: add support for COMMAND KEY long menu; unsigned char string[20]; short num, i; short len = 0; KeySym key_sym; int key_char; int modifiers; int simplify = FALSE; // Mask the mouse (as per user setting) if (p_mh) ObscureCursor(); // Get the key code and its ASCII representation key_sym = ((theEvent->message & keyCodeMask) >> 8); key_char = theEvent->message & charCodeMask; num = 1; // Intercept CTRL-C if (theEvent->modifiers & controlKey) { if (key_char == Ctrl_C && ctrl_c_interrupts) got_int = TRUE; else if ((theEvent->modifiers & ~(controlKey|shiftKey)) == 0 && (key_char == '2' || key_char == '6')) { // CTRL-^ and CTRL-@ don't work in the normal way. if (key_char == '2') key_char = Ctrl_AT; else key_char = Ctrl_HAT; theEvent->modifiers = 0; } } // Intercept CMD-. if (theEvent->modifiers & cmdKey) if (key_char == '.') got_int = TRUE; // Handle command key as per menu // TODO: should override be allowed? Require YAO or could use 'winaltkey' if (theEvent->modifiers & cmdKey) // Only accept CMD alone or with CAPLOCKS and the mouse button. // Why the mouse button? if ((theEvent->modifiers & (~(cmdKey | btnState | alphaLock))) == 0) { menu = MenuKey(key_char); if (HiWord(menu)) { gui_mac_handle_menu(menu); return; } } // Convert the modifiers modifiers = EventModifiers2VimModifiers(theEvent->modifiers); // Handle special keys. #if 0 // Why has this been removed? if (!(theEvent->modifiers & (cmdKey | controlKey | rightControlKey))) #endif { // Find the special key (for non-printable keyt_char) if ((key_char < 0x20) || (key_char == 0x7f)) for (i = 0; special_keys[i].key_sym != (KeySym)0; i++) if (special_keys[i].key_sym == key_sym) { # if 0 // We currently don't have not so special key if (special_keys[i].vim_code1 == NUL) key_char = special_keys[i].vim_code0; else # endif key_char = TO_SPECIAL(special_keys[i].vim_code0, special_keys[i].vim_code1); simplify = TRUE; break; } } // For some keys the modifier is included in the char itself. if (simplify || key_char == TAB || key_char == ' ') key_char = simplify_key(key_char, &modifiers); // Add the modifier to the input bu if needed // Do not want SHIFT-A or CTRL-A with modifier if (!IS_SPECIAL(key_char) && key_sym != vk_Space && key_sym != vk_Tab && key_sym != vk_Return && key_sym != vk_Enter && key_sym != vk_Esc) { #if 1 // Clear modifiers when only one modifier is set if ((modifiers == MOD_MASK_SHIFT) || (modifiers == MOD_MASK_CTRL) || (modifiers == MOD_MASK_ALT)) modifiers = 0; #else if (modifiers & MOD_MASK_CTRL) modifiers = modifiers & ~MOD_MASK_CTRL; if (modifiers & MOD_MASK_ALT) modifiers = modifiers & ~MOD_MASK_ALT; if (modifiers & MOD_MASK_SHIFT) modifiers = modifiers & ~MOD_MASK_SHIFT; #endif } if (modifiers) { string[len++] = CSI; string[len++] = KS_MODIFIER; string[len++] = modifiers; } if (IS_SPECIAL(key_char)) { string[len++] = CSI; string[len++] = K_SECOND(key_char); string[len++] = K_THIRD(key_char); } else { // Convert characters when needed (e.g., from MacRoman to latin1). // This doesn't work for the NUL byte. if (input_conv.vc_type != CONV_NONE && key_char > 0) { char_u from[2], *to; int l; from[0] = key_char; from[1] = NUL; l = 1; to = string_convert(&input_conv, from, &l); if (to != NULL) { for (i = 0; i < l && len < 19; i++) { if (to[i] == CSI) { string[len++] = KS_EXTRA; string[len++] = KE_CSI; } else string[len++] = to[i]; } vim_free(to); } else string[len++] = key_char; } else string[len++] = key_char; } if (len == 1 && string[0] == CSI) { // Turn CSI into K_CSI. string[ len++ ] = KS_EXTRA; string[ len++ ] = KE_CSI; } add_to_input_buf(string, len); } #endif /* * Handle MouseClick */ void gui_mac_doMouseDownEvent(EventRecord *theEvent) { short thePart; WindowPtr whichWindow; thePart = FindWindow(theEvent->where, &whichWindow); #ifdef FEAT_GUI_TABLINE // prevent that the vim window size changes if it's activated by a // click into the tab pane if (whichWindow == drawer) return; #endif switch (thePart) { case (inDesk): // TODO: what to do? break; case (inMenuBar): gui_mac_handle_menu(MenuSelect(theEvent->where)); break; case (inContent): gui_mac_doInContentClick(theEvent, whichWindow); break; case (inDrag): gui_mac_doInDragClick(theEvent->where, whichWindow); break; case (inGrow): gui_mac_doInGrowClick(theEvent->where, whichWindow); break; case (inGoAway): if (TrackGoAway(whichWindow, theEvent->where)) gui_shell_closed(); break; case (inZoomIn): case (inZoomOut): gui_mac_doInZoomClick(theEvent, whichWindow); break; } } /* * Handle MouseMoved * [this event is a moving in and out of a region] */ void gui_mac_doMouseMovedEvent(EventRecord *event) { Point thePoint; int_u vimModifiers; thePoint = event->where; GlobalToLocal(&thePoint); vimModifiers = EventModifiers2VimMouseModifiers(event->modifiers); if (!Button()) gui_mouse_moved(thePoint.h, thePoint.v); else if (!clickIsPopup) gui_send_mouse_event(MOUSE_DRAG, thePoint.h, thePoint.v, FALSE, vimModifiers); // Reset the region from which we move in and out SetRect(&dragRect, FILL_X(X_2_COL(thePoint.h)), FILL_Y(Y_2_ROW(thePoint.v)), FILL_X(X_2_COL(thePoint.h)+1), FILL_Y(Y_2_ROW(thePoint.v)+1)); if (dragRectEnbl) dragRectControl = kCreateRect; } /* * Handle the mouse release */ void gui_mac_doMouseUpEvent(EventRecord *theEvent) { Point thePoint; int_u vimModifiers; // TODO: Properly convert the Contextual menu mouse-up // Potential source of the double menu lastMouseTick = theEvent->when; dragRectEnbl = FALSE; dragRectControl = kCreateEmpty; thePoint = theEvent->where; GlobalToLocal(&thePoint); vimModifiers = EventModifiers2VimMouseModifiers(theEvent->modifiers); if (clickIsPopup) { vimModifiers &= ~MOUSE_CTRL; clickIsPopup = FALSE; } gui_send_mouse_event(MOUSE_RELEASE, thePoint.h, thePoint.v, FALSE, vimModifiers); } static pascal OSStatus gui_mac_mouse_wheel(EventHandlerCallRef nextHandler, EventRef theEvent, void *data) { Point point; Rect bounds; UInt32 mod; SInt32 delta; int_u vim_mod; EventMouseWheelAxis axis; if (noErr == GetEventParameter(theEvent, kEventParamMouseWheelAxis, typeMouseWheelAxis, NULL, sizeof(axis), NULL, &axis) && axis != kEventMouseWheelAxisY) goto bail; // Vim only does up-down scrolling if (noErr != GetEventParameter(theEvent, kEventParamMouseWheelDelta, typeSInt32, NULL, sizeof(SInt32), NULL, &delta)) goto bail; if (noErr != GetEventParameter(theEvent, kEventParamMouseLocation, typeQDPoint, NULL, sizeof(Point), NULL, &point)) goto bail; if (noErr != GetEventParameter(theEvent, kEventParamKeyModifiers, typeUInt32, NULL, sizeof(UInt32), NULL, &mod)) goto bail; vim_mod = 0; if (mod & shiftKey) vim_mod |= MOUSE_SHIFT; if (mod & controlKey) vim_mod |= MOUSE_CTRL; if (mod & optionKey) vim_mod |= MOUSE_ALT; if (noErr == GetWindowBounds(gui.VimWindow, kWindowContentRgn, &bounds)) { point.h -= bounds.left; point.v -= bounds.top; } gui_send_mouse_event((delta > 0) ? MOUSE_4 : MOUSE_5, point.h, point.v, FALSE, vim_mod); // post a bogus event to wake up WaitNextEvent PostEvent(keyUp, 0); return noErr; bail: /* * when we fail give any additional callback handler a chance to perform * its actions */ return CallNextEventHandler(nextHandler, theEvent); } void gui_mch_mousehide(int hide) { // TODO } #if 0 /* * This would be the normal way of invoking the contextual menu * but the Vim API doesn't seem to a support a request to get * the menu that we should display */ void gui_mac_handle_contextual_menu(EventRecord *event) { /* * Clone PopUp to use menu * Create a object descriptor for the current selection * Call the procedure */ // Call to Handle Popup OSStatus status = ContextualMenuSelect(CntxMenu, event->where, false, kCMHelpItemNoHelp, "", NULL, &CntxType, &CntxMenuID, &CntxMenuItem); if (status != noErr) return; if (CntxType == kCMMenuItemSelected) { // Handle the menu CntxMenuID, CntxMenuItem // The submenu can be handle directly by gui_mac_handle_menu // But what about the current menu, is the many changed by ContextualMenuSelect gui_mac_handle_menu((CntxMenuID << 16) + CntxMenuItem); } else if (CntxMenuID == kCMShowHelpSelected) { // Should come up with the help } } #endif /* * Handle menubar selection */ void gui_mac_handle_menu(long menuChoice) { short menu = HiWord(menuChoice); short item = LoWord(menuChoice); vimmenu_T *theVimMenu = root_menu; if (menu == 256) // TODO: use constant or gui.xyz { if (item == 1) gui_mch_beep(); // TODO: Popup dialog or do :intro } else if (item != 0) { theVimMenu = gui_mac_get_vim_menu(menu, item, root_menu); if (theVimMenu) gui_menu_cb(theVimMenu); } HiliteMenu(0); } /* * Dispatch the event to proper handler */ void gui_mac_handle_event(EventRecord *event) { OSErr error; // Handle contextual menu right now (if needed) if (IsShowContextualMenuClick(event)) { # if 0 gui_mac_handle_contextual_menu(event); # else gui_mac_doMouseDownEvent(event); # endif return; } // Handle normal event switch (event->what) { #ifndef USE_CARBONKEYHANDLER case (keyDown): case (autoKey): gui_mac_doKeyEvent(event); break; #endif case (keyUp): // We don't care about when the key is released break; case (mouseDown): gui_mac_doMouseDownEvent(event); break; case (mouseUp): gui_mac_doMouseUpEvent(event); break; case (updateEvt): gui_mac_doUpdateEvent(event); break; case (diskEvt): // We don't need special handling for disk insertion break; case (activateEvt): gui_mac_doActivateEvent(event); break; case (osEvt): switch ((event->message >> 24) & 0xFF) { case (0xFA): // mouseMovedMessage gui_mac_doMouseMovedEvent(event); break; case (0x01): // suspendResumeMessage gui_mac_doSuspendEvent(event); break; } break; #ifdef USE_AEVENT case (kHighLevelEvent): // Someone's talking to us, through AppleEvents error = AEProcessAppleEvent(event); // TODO: Error Handling break; #endif } } /* * ------------------------------------------------------------ * Unknown Stuff * ------------------------------------------------------------ */ GuiFont gui_mac_find_font(char_u *font_name) { char_u c; char_u *p; char_u pFontName[256]; Str255 systemFontname; short font_id; short size=9; GuiFont font; #if 0 char_u *fontNamePtr; #endif for (p = font_name; ((*p != 0) && (*p != ':')); p++) ; c = *p; *p = 0; #if 1 STRCPY(&pFontName[1], font_name); pFontName[0] = STRLEN(font_name); *p = c; // Get the font name, minus the style suffix (:h, etc) char_u fontName[256]; char_u *styleStart = vim_strchr(font_name, ':'); size_t fontNameLen = styleStart ? styleStart - font_name : STRLEN(fontName); vim_strncpy(fontName, font_name, fontNameLen); ATSUFontID fontRef; FMFontStyle fontStyle; font_id = 0; if (ATSUFindFontFromName(&pFontName[1], pFontName[0], kFontFullName, kFontMacintoshPlatform, kFontNoScriptCode, kFontNoLanguageCode, &fontRef) == noErr) { if (FMGetFontFamilyInstanceFromFont(fontRef, &font_id, &fontStyle) != noErr) font_id = 0; } if (font_id == 0) { /* * Try again, this time replacing underscores in the font name * with spaces (:set guifont allows the two to be used * interchangeably; the Font Manager doesn't). */ int i, changed = FALSE; for (i = pFontName[0]; i > 0; --i) { if (pFontName[i] == '_') { pFontName[i] = ' '; changed = TRUE; } } if (changed) if (ATSUFindFontFromName(&pFontName[1], pFontName[0], kFontFullName, kFontNoPlatformCode, kFontNoScriptCode, kFontNoLanguageCode, &fontRef) == noErr) { if (FMGetFontFamilyInstanceFromFont(fontRef, &font_id, &fontStyle) != noErr) font_id = 0; } } #else // name = C2Pascal_save(menu->dname); fontNamePtr = C2Pascal_save_and_remove_backslash(font_name); GetFNum(fontNamePtr, &font_id); #endif if (font_id == 0) { // Oups, the system font was it the one the user want if (FMGetFontFamilyName(systemFont, systemFontname) != noErr) return NOFONT; if (!EqualString(pFontName, systemFontname, false, false)) return NOFONT; } if (*p == ':') { p++; // Set the values found after ':' while (*p) { switch (*p++) { case 'h': size = points_to_pixels(p, &p, TRUE); break; /* * TODO: Maybe accept width and styles */ } while (*p == ':') p++; } } if (size < 1) size = 1; // Avoid having a size of 0 with system font font = (size << 16) + ((long) font_id & 0xFFFF); return font; } /* * ------------------------------------------------------------ * GUI_MCH functionality * ------------------------------------------------------------ */ /* * Parse the GUI related command-line arguments. Any arguments used are * deleted from argv, and *argc is decremented accordingly. This is called * when vim is started, whether or not the GUI has been started. */ void gui_mch_prepare(int *argc, char **argv) { // TODO: Move most of this stuff toward gui_mch_init #ifdef USE_EXE_NAME FSSpec applDir; # ifndef USE_FIND_BUNDLE_PATH short applVRefNum; long applDirID; Str255 volName; # else ProcessSerialNumber psn; FSRef applFSRef; # endif #endif #if 0 InitCursor(); RegisterAppearanceClient(); #ifdef USE_AEVENT (void) InstallAEHandlers(); #endif pomme = NewMenu(256, "\p\024"); // 0x14= = Apple Menu AppendMenu(pomme, "\pAbout VIM"); InsertMenu(pomme, 0); DrawMenuBar(); #ifndef USE_OFFSETED_WINDOW SetRect(&windRect, 10, 48, 10+80*7 + 16, 48+24*11); #else SetRect(&windRect, 300, 40, 300+80*7 + 16, 40+24*11); #endif CreateNewWindow(kDocumentWindowClass, kWindowResizableAttribute | kWindowCollapseBoxAttribute, &windRect, &gui.VimWindow); SetPortWindowPort(gui.VimWindow); gui.char_width = 7; gui.char_height = 11; gui.char_ascent = 6; gui.num_rows = 24; gui.num_cols = 80; gui.in_focus = TRUE; // For the moment -> syn. of front application gScrollAction = NewControlActionUPP(gui_mac_scroll_action); gScrollDrag = NewControlActionUPP(gui_mac_drag_thumb); dragRectEnbl = FALSE; dragRgn = NULL; dragRectControl = kCreateEmpty; cursorRgn = NewRgn(); #endif #ifdef USE_EXE_NAME # ifndef USE_FIND_BUNDLE_PATH HGetVol(volName, &applVRefNum, &applDirID); // TN2015: mention a possible bad VRefNum FSMakeFSSpec(applVRefNum, applDirID, "\p", &applDir); # else // OSErr GetApplicationBundleFSSpec(FSSpecPtr theFSSpecPtr) // of TN2015 (void)GetCurrentProcess(&psn); // if (err != noErr) return err; (void)GetProcessBundleLocation(&psn, &applFSRef); // if (err != noErr) return err; (void)FSGetCatalogInfo(&applFSRef, kFSCatInfoNone, NULL, NULL, &applDir, NULL); // This technique returns NIL when we disallow_gui # endif exe_name = FullPathFromFSSpec_save(applDir); #endif } #ifndef ALWAYS_USE_GUI /* * Check if the GUI can be started. Called before gvimrc is sourced. * Return OK or FAIL. */ int gui_mch_init_check(void) { // TODO: For MacOS X find a way to return FAIL, if the user logged in // using the >console if (disallow_gui) // see main.c for reason to disallow return FAIL; return OK; } #endif static OSErr receiveHandler(WindowRef theWindow, void *handlerRefCon, DragRef theDrag) { int x, y; int_u modifiers; char_u **fnames = NULL; int count; int i, j; // Get drop position, modifiers and count of items { Point point; SInt16 mouseUpModifiers; UInt16 countItem; GetDragMouse(theDrag, &point, NULL); GlobalToLocal(&point); x = point.h; y = point.v; GetDragModifiers(theDrag, NULL, NULL, &mouseUpModifiers); modifiers = EventModifiers2VimMouseModifiers(mouseUpModifiers); CountDragItems(theDrag, &countItem); count = countItem; } fnames = ALLOC_MULT(char_u *, count); if (fnames == NULL) return dragNotAcceptedErr; // Get file names dropped for (i = j = 0; i < count; ++i) { DragItemRef item; OSErr err; Size size; FlavorType type = flavorTypeHFS; HFSFlavor hfsFlavor; fnames[i] = NULL; GetDragItemReferenceNumber(theDrag, i + 1, &item); err = GetFlavorDataSize(theDrag, item, type, &size); if (err != noErr || size > sizeof(hfsFlavor)) continue; err = GetFlavorData(theDrag, item, type, &hfsFlavor, &size, 0); if (err != noErr) continue; fnames[j++] = FullPathFromFSSpec_save(hfsFlavor.fileSpec); } count = j; gui_handle_drop(x, y, modifiers, fnames, count); // Fake mouse event to wake from stall PostEvent(mouseUp, 0); return noErr; } /* * Initialise the GUI. Create all the windows, set up all the call-backs * etc. */ int gui_mch_init(void) { // TODO: Move most of this stuff toward gui_mch_init Rect windRect; MenuHandle pomme; EventHandlerRef mouseWheelHandlerRef; EventTypeSpec eventTypeSpec; ControlRef rootControl; if (Gestalt(gestaltSystemVersion, &gMacSystemVersion) != noErr) gMacSystemVersion = 0x1000; // TODO: Default to minimum sensible value #if 1 InitCursor(); RegisterAppearanceClient(); #ifdef USE_AEVENT (void) InstallAEHandlers(); #endif pomme = NewMenu(256, "\p\024"); // 0x14= = Apple Menu AppendMenu(pomme, "\pAbout VIM"); InsertMenu(pomme, 0); DrawMenuBar(); #ifndef USE_OFFSETED_WINDOW SetRect(&windRect, 10, 48, 10+80*7 + 16, 48+24*11); #else SetRect(&windRect, 300, 40, 300+80*7 + 16, 40+24*11); #endif gui.VimWindow = NewCWindow(nil, &windRect, "\pgVim on Macintosh", true, zoomDocProc, (WindowPtr)-1L, true, 0); CreateRootControl(gui.VimWindow, &rootControl); InstallReceiveHandler((DragReceiveHandlerUPP)receiveHandler, gui.VimWindow, NULL); SetPortWindowPort(gui.VimWindow); gui.char_width = 7; gui.char_height = 11; gui.char_ascent = 6; gui.num_rows = 24; gui.num_cols = 80; gui.in_focus = TRUE; // For the moment -> syn. of front application gScrollAction = NewControlActionUPP(gui_mac_scroll_action); gScrollDrag = NewControlActionUPP(gui_mac_drag_thumb); // Install Carbon event callbacks. (void)InstallFontPanelHandler(); dragRectEnbl = FALSE; dragRgn = NULL; dragRectControl = kCreateEmpty; cursorRgn = NewRgn(); #endif // Display any pending error messages display_errors(); // Get background/foreground colors from system // TODO: do the appropriate call to get real defaults gui.norm_pixel = 0x00000000; gui.back_pixel = 0x00FFFFFF; // Get the colors from the "Normal" group (set in syntax.c or in a vimrc // file). set_normal_colors(); /* * Check that none of the colors are the same as the background color. * Then store the current values as the defaults. */ gui_check_colors(); gui.def_norm_pixel = gui.norm_pixel; gui.def_back_pixel = gui.back_pixel; // Get the colors for the highlight groups (gui_check_colors() might have // changed them) highlight_gui_started(); /* * Setting the gui constants */ #ifdef FEAT_MENU gui.menu_height = 0; #endif gui.scrollbar_height = gui.scrollbar_width = 15; // cheat 1 overlap gui.border_offset = gui.border_width = 2; // If Quartz-style text anti aliasing is available (see // gui_mch_draw_string() below), enable it for all font sizes. vim_setenv((char_u *)"QDTEXT_MINSIZE", (char_u *)"1"); eventTypeSpec.eventClass = kEventClassMouse; eventTypeSpec.eventKind = kEventMouseWheelMoved; mouseWheelHandlerUPP = NewEventHandlerUPP(gui_mac_mouse_wheel); if (noErr != InstallApplicationEventHandler(mouseWheelHandlerUPP, 1, &eventTypeSpec, NULL, &mouseWheelHandlerRef)) { mouseWheelHandlerRef = NULL; DisposeEventHandlerUPP(mouseWheelHandlerUPP); mouseWheelHandlerUPP = NULL; } #ifdef USE_CARBONKEYHANDLER InterfaceTypeList supportedServices = { kUnicodeDocument }; NewTSMDocument(1, supportedServices, &gTSMDocument, 0); // We don't support inline input yet, use input window by default UseInputWindow(gTSMDocument, TRUE); // Should we activate the document by default? // ActivateTSMDocument(gTSMDocument); EventTypeSpec textEventTypes[] = { { kEventClassTextInput, kEventTextInputUpdateActiveInputArea }, { kEventClassTextInput, kEventTextInputUnicodeForKeyEvent }, { kEventClassTextInput, kEventTextInputPosToOffset }, { kEventClassTextInput, kEventTextInputOffsetToPos }, }; keyEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_text_input); if (noErr != InstallApplicationEventHandler(keyEventHandlerUPP, NR_ELEMS(textEventTypes), textEventTypes, NULL, NULL)) { DisposeEventHandlerUPP(keyEventHandlerUPP); keyEventHandlerUPP = NULL; } EventTypeSpec windowEventTypes[] = { { kEventClassWindow, kEventWindowActivated }, { kEventClassWindow, kEventWindowDeactivated }, }; // Install window event handler to support TSMDocument activate and // deactivate winEventHandlerUPP = NewEventHandlerUPP(gui_mac_handle_window_activate); if (noErr != InstallWindowEventHandler(gui.VimWindow, winEventHandlerUPP, NR_ELEMS(windowEventTypes), windowEventTypes, NULL, NULL)) { DisposeEventHandlerUPP(winEventHandlerUPP); winEventHandlerUPP = NULL; } #endif #ifdef FEAT_GUI_TABLINE /* * Create the tabline */ initialise_tabline(); #endif // TODO: Load bitmap if using TOOLBAR return OK; } /* * Called when the foreground or background color has been changed. */ void gui_mch_new_colors(void) { // TODO: // This proc is called when Normal is set to a value // so what must be done? I don't know } /* * Open the GUI window which was created by a call to gui_mch_init(). */ int gui_mch_open(void) { ShowWindow(gui.VimWindow); if (gui_win_x != -1 && gui_win_y != -1) gui_mch_set_winpos(gui_win_x, gui_win_y); /* * Make the GUI the foreground process (in case it was launched * from the Terminal or via :gui). */ { ProcessSerialNumber psn; if (GetCurrentProcess(&psn) == noErr) SetFrontProcess(&psn); } return OK; } #ifdef USE_ATSUI_DRAWING static void gui_mac_dispose_atsui_style(void) { if (p_macatsui && gFontStyle) ATSUDisposeStyle(gFontStyle); if (p_macatsui && gWideFontStyle) ATSUDisposeStyle(gWideFontStyle); } #endif void gui_mch_exit(int rc) { // TODO: find out all what is missing here? DisposeRgn(cursorRgn); #ifdef USE_CARBONKEYHANDLER if (keyEventHandlerUPP) DisposeEventHandlerUPP(keyEventHandlerUPP); #endif if (mouseWheelHandlerUPP != NULL) DisposeEventHandlerUPP(mouseWheelHandlerUPP); #ifdef USE_ATSUI_DRAWING gui_mac_dispose_atsui_style(); #endif #ifdef USE_CARBONKEYHANDLER FixTSMDocument(gTSMDocument); DeactivateTSMDocument(gTSMDocument); DeleteTSMDocument(gTSMDocument); #endif // Exit to shell? exit(rc); } /* * Get the position of the top left corner of the window. */ int gui_mch_get_winpos(int *x, int *y) { // TODO Rect bounds; OSStatus status; // Carbon >= 1.0.2, MacOS >= 8.5 status = GetWindowBounds(gui.VimWindow, kWindowStructureRgn, &bounds); if (status != noErr) return FAIL; *x = bounds.left; *y = bounds.top; return OK; } /* * Set the position of the top left corner of the window to the given * coordinates. */ void gui_mch_set_winpos(int x, int y) { // TODO: Should make sure the window is move within range // e.g.: y > ~16 [Menu bar], x > 0, x < screen width MoveWindowStructure(gui.VimWindow, x, y); } void gui_mch_set_shellsize( int width, int height, int min_width, int min_height, int base_width, int base_height, int direction) { CGrafPtr VimPort; Rect VimBound; if (gui.which_scrollbars[SBAR_LEFT]) { VimPort = GetWindowPort(gui.VimWindow); GetPortBounds(VimPort, &VimBound); VimBound.left = -gui.scrollbar_width; // + 1; SetPortBounds(VimPort, &VimBound); // GetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &winPortRect); ?? } else { VimPort = GetWindowPort(gui.VimWindow); GetPortBounds(VimPort, &VimBound); VimBound.left = 0; SetPortBounds(VimPort, &VimBound); } SizeWindow(gui.VimWindow, width, height, TRUE); gui_resize_shell(width, height); } /* * Get the screen dimensions. * Allow 10 pixels for horizontal borders, 40 for vertical borders. * Is there no way to find out how wide the borders really are? * TODO: Add live update of those value on suspend/resume. */ void gui_mch_get_screen_dimensions(int *screen_w, int *screen_h) { GDHandle dominantDevice = GetMainDevice(); Rect screenRect = (**dominantDevice).gdRect; *screen_w = screenRect.right - 10; *screen_h = screenRect.bottom - 40; } /* * Open the Font Panel and wait for the user to select a font and * close the panel. Then fill the buffer pointed to by font_name with * the name and size of the selected font and return the font's handle, * or NOFONT in case of an error. */ static GuiFont gui_mac_select_font(char_u *font_name) { GuiFont selected_font = NOFONT; OSStatus status; FontSelectionQDStyle curr_font; // Initialize the Font Panel with the current font. curr_font.instance.fontFamily = gui.norm_font & 0xFFFF; curr_font.size = (gui.norm_font >> 16); // TODO: set fontStyle once styles are supported in gui_mac_find_font() curr_font.instance.fontStyle = 0; curr_font.hasColor = false; curr_font.version = 0; // version number of the style structure status = SetFontInfoForSelection(kFontSelectionQDType, /*numStyles=*/1, &curr_font, /*eventTarget=*/NULL); gFontPanelInfo.family = curr_font.instance.fontFamily; gFontPanelInfo.style = curr_font.instance.fontStyle; gFontPanelInfo.size = curr_font.size; // Pop up the Font Panel. status = FPShowHideFontPanel(); if (status == noErr) { /* * The Font Panel is modeless. We really need it to be modal, * so we spin in an event loop until the panel is closed. */ gFontPanelInfo.isPanelVisible = true; while (gFontPanelInfo.isPanelVisible) { EventRecord e; WaitNextEvent(everyEvent, &e, /*sleep=*/20, /*mouseRgn=*/NULL); } GetFontPanelSelection(font_name); selected_font = gui_mac_find_font(font_name); } return selected_font; } #ifdef USE_ATSUI_DRAWING static void gui_mac_create_atsui_style(void) { if (p_macatsui && gFontStyle == NULL) { if (ATSUCreateStyle(&gFontStyle) != noErr) gFontStyle = NULL; } if (p_macatsui && gWideFontStyle == NULL) { if (ATSUCreateStyle(&gWideFontStyle) != noErr) gWideFontStyle = NULL; } p_macatsui_last = p_macatsui; } #endif /* * Initialise vim to use the font with the given name. Return FAIL if the font * could not be loaded, OK otherwise. */ int gui_mch_init_font(char_u *font_name, int fontset) { // TODO: Add support for bold italic underline proportional etc... Str255 suggestedFont = "\pMonaco"; int suggestedSize = 10; FontInfo font_info; short font_id; GuiFont font; char_u used_font_name[512]; #ifdef USE_ATSUI_DRAWING gui_mac_create_atsui_style(); #endif if (font_name == NULL) { // First try to get the suggested font GetFNum(suggestedFont, &font_id); if (font_id == 0) { // Then pickup the standard application font font_id = GetAppFont(); STRCPY(used_font_name, "default"); } else STRCPY(used_font_name, "Monaco"); font = (suggestedSize << 16) + ((long) font_id & 0xFFFF); } else if (STRCMP(font_name, "*") == 0) { char_u *new_p_guifont; font = gui_mac_select_font(used_font_name); if (font == NOFONT) return FAIL; // Set guifont to the name of the selected font. new_p_guifont = alloc(STRLEN(used_font_name) + 1); if (new_p_guifont != NULL) { STRCPY(new_p_guifont, used_font_name); vim_free(p_guifont); p_guifont = new_p_guifont; // Replace spaces in the font name with underscores. for ( ; *new_p_guifont; ++new_p_guifont) { if (*new_p_guifont == ' ') *new_p_guifont = '_'; } } } else { font = gui_mac_find_font(font_name); vim_strncpy(used_font_name, font_name, sizeof(used_font_name) - 1); if (font == NOFONT) return FAIL; } gui.norm_font = font; hl_set_font_name(used_font_name); TextSize(font >> 16); TextFont(font & 0xFFFF); GetFontInfo(&font_info); gui.char_ascent = font_info.ascent; gui.char_width = CharWidth('_'); gui.char_height = font_info.ascent + font_info.descent + p_linespace; #ifdef USE_ATSUI_DRAWING if (p_macatsui && gFontStyle) gui_mac_set_font_attributes(font); #endif return OK; } /* * Adjust gui.char_height (after 'linespace' was changed). */ int gui_mch_adjust_charheight(void) { FontInfo font_info; GetFontInfo(&font_info); gui.char_height = font_info.ascent + font_info.descent + p_linespace; gui.char_ascent = font_info.ascent + p_linespace / 2; return OK; } /* * Get a font structure for highlighting. */ GuiFont gui_mch_get_font(char_u *name, int giveErrorIfMissing) { GuiFont font; font = gui_mac_find_font(name); if (font == NOFONT) { if (giveErrorIfMissing) semsg(_(e_font), name); return NOFONT; } /* * TODO : Accept only monospace */ return font; } #if defined(FEAT_EVAL) || defined(PROTO) /* * Return the name of font "font" in allocated memory. * Don't know how to get the actual name, thus use the provided name. */ char_u * gui_mch_get_fontname(GuiFont font, char_u *name) { if (name == NULL) return NULL; return vim_strsave(name); } #endif #ifdef USE_ATSUI_DRAWING static void gui_mac_set_font_attributes(GuiFont font) { ATSUFontID fontID; Fixed fontSize; Fixed fontWidth; fontID = font & 0xFFFF; fontSize = Long2Fix(font >> 16); fontWidth = Long2Fix(gui.char_width); ATSUAttributeTag attribTags[] = { kATSUFontTag, kATSUSizeTag, kATSUImposeWidthTag, kATSUMaxATSUITagValue + 1 }; ByteCount attribSizes[] = { sizeof(ATSUFontID), sizeof(Fixed), sizeof(fontWidth), sizeof(font) }; ATSUAttributeValuePtr attribValues[] = { &fontID, &fontSize, &fontWidth, &font }; if (FMGetFontFromFontFamilyInstance(fontID, 0, &fontID, NULL) == noErr) { if (ATSUSetAttributes(gFontStyle, (sizeof attribTags) / sizeof(ATSUAttributeTag), attribTags, attribSizes, attribValues) != noErr) { # ifndef NDEBUG fprintf(stderr, "couldn't set font style\n"); # endif ATSUDisposeStyle(gFontStyle); gFontStyle = NULL; } if (has_mbyte) { // FIXME: we should use a more mbyte sensitive way to support // wide font drawing fontWidth = Long2Fix(gui.char_width * 2); if (ATSUSetAttributes(gWideFontStyle, (sizeof attribTags) / sizeof(ATSUAttributeTag), attribTags, attribSizes, attribValues) != noErr) { ATSUDisposeStyle(gWideFontStyle); gWideFontStyle = NULL; } } } } #endif /* * Set the current text font. */ void gui_mch_set_font(GuiFont font) { #ifdef USE_ATSUI_DRAWING GuiFont currFont; ByteCount actualFontByteCount; if (p_macatsui && gFontStyle) { // Avoid setting same font again if (ATSUGetAttribute(gFontStyle, kATSUMaxATSUITagValue + 1, sizeof(font), &currFont, &actualFontByteCount) == noErr && actualFontByteCount == (sizeof font)) { if (currFont == font) return; } gui_mac_set_font_attributes(font); } if (p_macatsui && !gIsFontFallbackSet) { // Setup automatic font substitution. The user's guifontwide // is tried first, then the system tries other fonts. #if 0 ATSUAttributeTag fallbackTags[] = { kATSULineFontFallbacksTag }; ByteCount fallbackSizes[] = { sizeof(ATSUFontFallbacks) }; ATSUCreateFontFallbacks(&gFontFallbacks); ATSUSetObjFontFallbacks(gFontFallbacks, ); #endif if (gui.wide_font) { ATSUFontID fallbackFonts; gIsFontFallbackSet = TRUE; if (FMGetFontFromFontFamilyInstance( (gui.wide_font & 0xFFFF), 0, &fallbackFonts, NULL) == noErr) { ATSUSetFontFallbacks((sizeof fallbackFonts)/sizeof(ATSUFontID), &fallbackFonts, kATSUSequentialFallbacksPreferred); } // ATSUAttributeValuePtr fallbackValues[] = { }; } } #endif TextSize(font >> 16); TextFont(font & 0xFFFF); } /* * If a font is not going to be used, free its structure. */ void gui_mch_free_font(GuiFont font) { /* * Free font when "font" is not 0. * Nothing to do in the current implementation, since * nothing is allocated for each font used. */ } /* * Return the Pixel value (color) for the given color name. This routine was * pretty much taken from example code in the Silicon Graphics OSF/Motif * Programmer's Guide. * Return INVALCOLOR when failed. */ guicolor_T gui_mch_get_color(char_u *name) { // TODO: Add support for the new named color of MacOS 8 RGBColor MacColor; if (STRICMP(name, "hilite") == 0) { LMGetHiliteRGB(&MacColor); return (RGB(MacColor.red >> 8, MacColor.green >> 8, MacColor.blue >> 8)); } return gui_get_color_cmn(name); } guicolor_T gui_mch_get_rgb_color(int r, int g, int b) { return gui_get_rgb_color_cmn(r, g, b); } /* * Set the current text foreground color. */ void gui_mch_set_fg_color(guicolor_T color) { RGBColor TheColor; TheColor.red = Red(color) * 0x0101; TheColor.green = Green(color) * 0x0101; TheColor.blue = Blue(color) * 0x0101; RGBForeColor(&TheColor); } /* * Set the current text background color. */ void gui_mch_set_bg_color(guicolor_T color) { RGBColor TheColor; TheColor.red = Red(color) * 0x0101; TheColor.green = Green(color) * 0x0101; TheColor.blue = Blue(color) * 0x0101; RGBBackColor(&TheColor); } RGBColor specialColor; /* * Set the current text special color. */ void gui_mch_set_sp_color(guicolor_T color) { specialColor.red = Red(color) * 0x0101; specialColor.green = Green(color) * 0x0101; specialColor.blue = Blue(color) * 0x0101; } /* * Draw undercurl at the bottom of the character cell. */ static void draw_undercurl(int flags, int row, int col, int cells) { int x; int offset; const static int val[8] = {1, 0, 0, 0, 1, 2, 2, 2 }; int y = FILL_Y(row + 1) - 1; RGBForeColor(&specialColor); offset = val[FILL_X(col) % 8]; MoveTo(FILL_X(col), y - offset); for (x = FILL_X(col); x < FILL_X(col + cells); ++x) { offset = val[x % 8]; LineTo(x, y - offset); } } static void draw_string_QD(int row, int col, char_u *s, int len, int flags) { char_u *tofree = NULL; if (output_conv.vc_type != CONV_NONE) { tofree = string_convert(&output_conv, s, &len); if (tofree != NULL) s = tofree; } /* * On OS X, try using Quartz-style text antialiasing. */ if (gMacSystemVersion >= 0x1020) { // Quartz antialiasing is available only in OS 10.2 and later. UInt32 qd_flags = (p_antialias ? kQDUseCGTextRendering | kQDUseCGTextMetrics : 0); QDSwapTextFlags(qd_flags); } /* * When antialiasing we're using srcOr mode, we have to clear the block * before drawing the text. * Also needed when 'linespace' is non-zero to remove the cursor and * underlining. * But not when drawing transparently. * The following is like calling gui_mch_clear_block(row, col, row, col + * len - 1), but without setting the bg color to gui.back_pixel. */ if (((gMacSystemVersion >= 0x1020 && p_antialias) || p_linespace != 0) && !(flags & DRAW_TRANSP)) { Rect rc; rc.left = FILL_X(col); rc.top = FILL_Y(row); // Multibyte computation taken from gui_w32.c if (has_mbyte) { // Compute the length in display cells. rc.right = FILL_X(col + mb_string2cells(s, len)); } else rc.right = FILL_X(col + len) + (col + len == Columns); rc.bottom = FILL_Y(row + 1); EraseRect(&rc); } if (gMacSystemVersion >= 0x1020 && p_antialias) { StyleParameter face; face = normal; if (flags & DRAW_BOLD) face |= bold; if (flags & DRAW_UNDERL) face |= underline; TextFace(face); // Quartz antialiasing works only in srcOr transfer mode. TextMode(srcOr); MoveTo(TEXT_X(col), TEXT_Y(row)); DrawText((char*)s, 0, len); } else { // Use old-style, non-antialiased QuickDraw text rendering. TextMode(srcCopy); TextFace(normal); // SelectFont(hdc, gui.currFont); if (flags & DRAW_TRANSP) TextMode(srcOr); MoveTo(TEXT_X(col), TEXT_Y(row)); DrawText((char *)s, 0, len); if (flags & DRAW_BOLD) { TextMode(srcOr); MoveTo(TEXT_X(col) + 1, TEXT_Y(row)); DrawText((char *)s, 0, len); } if (flags & DRAW_UNDERL) { MoveTo(FILL_X(col), FILL_Y(row + 1) - 1); LineTo(FILL_X(col + len) - 1, FILL_Y(row + 1) - 1); } if (flags & DRAW_STRIKE) { MoveTo(FILL_X(col), FILL_Y(row + 1) - gui.char_height/2); LineTo(FILL_X(col + len) - 1, FILL_Y(row + 1) - gui.char_height/2); } } if (flags & DRAW_UNDERC) draw_undercurl(flags, row, col, len); vim_free(tofree); } #ifdef USE_ATSUI_DRAWING static void draw_string_ATSUI(int row, int col, char_u *s, int len, int flags) { // ATSUI requires utf-16 strings UniCharCount utf16_len; UniChar *tofree = mac_enc_to_utf16(s, len, (size_t *)&utf16_len); utf16_len /= sizeof(UniChar); // - ATSUI automatically antialiases text (Someone) // - for some reason it does not work... (Jussi) #ifdef MAC_ATSUI_DEBUG fprintf(stderr, "row = %d, col = %d, len = %d: '%c'\n", row, col, len, len == 1 ? s[0] : ' '); #endif /* * When antialiasing we're using srcOr mode, we have to clear the block * before drawing the text. * Also needed when 'linespace' is non-zero to remove the cursor and * underlining. * But not when drawing transparently. * The following is like calling gui_mch_clear_block(row, col, row, col + * len - 1), but without setting the bg color to gui.back_pixel. */ if ((flags & DRAW_TRANSP) == 0) { Rect rc; rc.left = FILL_X(col); rc.top = FILL_Y(row); // Multibyte computation taken from gui_w32.c if (has_mbyte) { // Compute the length in display cells. rc.right = FILL_X(col + mb_string2cells(s, len)); } else rc.right = FILL_X(col + len) + (col + len == Columns); rc.bottom = FILL_Y(row + 1); EraseRect(&rc); } { TextMode(srcCopy); TextFace(normal); // SelectFont(hdc, gui.currFont); if (flags & DRAW_TRANSP) TextMode(srcOr); MoveTo(TEXT_X(col), TEXT_Y(row)); if (gFontStyle && flags & DRAW_BOLD) { Boolean attValue = true; ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag }; ByteCount attribSizes[] = { sizeof(Boolean) }; ATSUAttributeValuePtr attribValues[] = { &attValue }; ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, attribValues); } UInt32 useAntialias = p_antialias ? kATSStyleApplyAntiAliasing : kATSStyleNoAntiAliasing; if (useAntialias != useAntialias_cached) { ATSUAttributeTag attribTags[] = { kATSUStyleRenderingOptionsTag }; ByteCount attribSizes[] = { sizeof(UInt32) }; ATSUAttributeValuePtr attribValues[] = { &useAntialias }; if (gFontStyle) ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, attribValues); if (gWideFontStyle) ATSUSetAttributes(gWideFontStyle, 1, attribTags, attribSizes, attribValues); useAntialias_cached = useAntialias; } if (has_mbyte) { int n, width_in_cell, last_width_in_cell; UniCharArrayOffset offset = 0; UniCharCount yet_to_draw = 0; ATSUTextLayout textLayout; ATSUStyle textStyle; last_width_in_cell = 1; ATSUCreateTextLayout(&textLayout); ATSUSetTextPointerLocation(textLayout, tofree, kATSUFromTextBeginning, kATSUToTextEnd, utf16_len); /* ATSUSetRunStyle(textLayout, gFontStyle, kATSUFromTextBeginning, kATSUToTextEnd); */ // Compute the length in display cells. for (n = 0; n < len; n += MB_BYTE2LEN(s[n])) { width_in_cell = (*mb_ptr2cells)(s + n); // probably we are switching from single byte character // to multibyte characters (which requires more than one // cell to draw) if (width_in_cell != last_width_in_cell) { #ifdef MAC_ATSUI_DEBUG fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n", n, last_width_in_cell, width_in_cell, offset, yet_to_draw); #endif textStyle = last_width_in_cell > 1 ? gWideFontStyle : gFontStyle; ATSUSetRunStyle(textLayout, textStyle, offset, yet_to_draw); offset += yet_to_draw; yet_to_draw = 0; last_width_in_cell = width_in_cell; } yet_to_draw++; } if (yet_to_draw) { #ifdef MAC_ATSUI_DEBUG fprintf(stderr, "\tn = %2d, (%d-%d), offset = %d, yet_to_draw = %d\n", n, last_width_in_cell, width_in_cell, offset, yet_to_draw); #endif // finish the rest style textStyle = width_in_cell > 1 ? gWideFontStyle : gFontStyle; ATSUSetRunStyle(textLayout, textStyle, offset, kATSUToTextEnd); } ATSUSetTransientFontMatching(textLayout, TRUE); ATSUDrawText(textLayout, kATSUFromTextBeginning, kATSUToTextEnd, kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc); ATSUDisposeTextLayout(textLayout); } else { ATSUTextLayout textLayout; if (ATSUCreateTextLayoutWithTextPtr(tofree, kATSUFromTextBeginning, kATSUToTextEnd, utf16_len, (gFontStyle ? 1 : 0), &utf16_len, (gFontStyle ? &gFontStyle : NULL), &textLayout) == noErr) { ATSUSetTransientFontMatching(textLayout, TRUE); ATSUDrawText(textLayout, kATSUFromTextBeginning, kATSUToTextEnd, kATSUUseGrafPortPenLoc, kATSUUseGrafPortPenLoc); ATSUDisposeTextLayout(textLayout); } } // drawing is done, now reset bold to normal if (gFontStyle && flags & DRAW_BOLD) { Boolean attValue = false; ATSUAttributeTag attribTags[] = { kATSUQDBoldfaceTag }; ByteCount attribSizes[] = { sizeof(Boolean) }; ATSUAttributeValuePtr attribValues[] = { &attValue }; ATSUSetAttributes(gFontStyle, 1, attribTags, attribSizes, attribValues); } } if (flags & DRAW_UNDERC) draw_undercurl(flags, row, col, len); vim_free(tofree); } #endif void gui_mch_draw_string(int row, int col, char_u *s, int len, int flags) { #if defined(USE_ATSUI_DRAWING) if (p_macatsui == 0 && p_macatsui_last != 0) // switch from macatsui to nomacatsui gui_mac_dispose_atsui_style(); else if (p_macatsui != 0 && p_macatsui_last == 0) // switch from nomacatsui to macatsui gui_mac_create_atsui_style(); if (p_macatsui) draw_string_ATSUI(row, col, s, len, flags); else #endif draw_string_QD(row, col, s, len, flags); } /* * Return OK if the key with the termcap name "name" is supported. */ int gui_mch_haskey(char_u *name) { int i; for (i = 0; special_keys[i].key_sym != (KeySym)0; i++) if (name[0] == special_keys[i].vim_code0 && name[1] == special_keys[i].vim_code1) return OK; return FAIL; } void gui_mch_beep(void) { SysBeep(1); // Should this be 0? (????) } void gui_mch_flash(int msec) { // Do a visual beep by reversing the foreground and background colors Rect rc; /* * Note: InvertRect() excludes right and bottom of rectangle. */ rc.left = 0; rc.top = 0; rc.right = gui.num_cols * gui.char_width; rc.bottom = gui.num_rows * gui.char_height; InvertRect(&rc); ui_delay((long)msec, TRUE); // wait for some msec InvertRect(&rc); } /* * Invert a rectangle from row r, column c, for nr rows and nc columns. */ void gui_mch_invert_rectangle(int r, int c, int nr, int nc) { Rect rc; /* * Note: InvertRect() excludes right and bottom of rectangle. */ rc.left = FILL_X(c); rc.top = FILL_Y(r); rc.right = rc.left + nc * gui.char_width; rc.bottom = rc.top + nr * gui.char_height; InvertRect(&rc); } /* * Iconify the GUI window. */ void gui_mch_iconify(void) { // TODO: find out what could replace iconify // -window shade? // -hide application? } #if defined(FEAT_EVAL) || defined(PROTO) /* * Bring the Vim window to the foreground. */ void gui_mch_set_foreground(void) { // TODO } #endif /* * Draw a cursor without focus. */ void gui_mch_draw_hollow_cursor(guicolor_T color) { Rect rc; /* * Note: FrameRect() excludes right and bottom of rectangle. */ rc.left = FILL_X(gui.col); rc.top = FILL_Y(gui.row); rc.right = rc.left + gui.char_width; if (mb_lefthalve(gui.row, gui.col)) rc.right += gui.char_width; rc.bottom = rc.top + gui.char_height; gui_mch_set_fg_color(color); FrameRect(&rc); } /* * Draw part of a cursor, only w pixels wide, and h pixels high. */ void gui_mch_draw_part_cursor(int w, int h, guicolor_T color) { Rect rc; #ifdef FEAT_RIGHTLEFT // vertical line should be on the right of current point if (CURSOR_BAR_RIGHT) rc.left = FILL_X(gui.col + 1) - w; else #endif rc.left = FILL_X(gui.col); rc.top = FILL_Y(gui.row) + gui.char_height - h; rc.right = rc.left + w; rc.bottom = rc.top + h; gui_mch_set_fg_color(color); FrameRect(&rc); // PaintRect(&rc); } /* * Catch up with any queued X events. This may put keyboard input into the * input buffer, call resize call-backs, trigger timers etc. If there is * nothing in the X event queue (& no timers pending), then we return * immediately. */ void gui_mch_update(void) { // TODO: find what to do // maybe call gui_mch_wait_for_chars (0) // more like look at EventQueue then // call heart of gui_mch_wait_for_chars; // // if (eventther) // gui_mac_handle_event(&event); EventRecord theEvent; if (EventAvail(everyEvent, &theEvent)) if (theEvent.what != nullEvent) gui_mch_wait_for_chars(0); } /* * Simple wrapper to neglect more easily the time * spent inside WaitNextEvent while profiling. */ pascal Boolean WaitNextEventWrp(EventMask eventMask, EventRecord *theEvent, UInt32 sleep, RgnHandle mouseRgn) { if (((long) sleep) < -1) sleep = 32767; return WaitNextEvent(eventMask, theEvent, sleep, mouseRgn); } /* * GUI input routine called by gui_wait_for_chars(). Waits for a character * from the keyboard. * wtime == -1 Wait forever. * wtime == 0 This should never happen. * wtime > 0 Wait wtime milliseconds for a character. * Returns OK if a character was found to be available within the given time, * or FAIL otherwise. */ int gui_mch_wait_for_chars(int wtime) { EventMask mask = (everyEvent); EventRecord event; long entryTick; long currentTick; long sleeppyTick; // If we are providing life feedback with the scrollbar, // we don't want to try to wait for an event, or else // there won't be any life feedback. if (dragged_sb != NULL) return FAIL; // TODO: Check if FAIL is the proper return code entryTick = TickCount(); allow_scrollbar = TRUE; do { #if 0 if (dragRectControl == kCreateEmpty) { dragRgn = NULL; dragRectControl = kNothing; } else #endif if (dragRectControl == kCreateRect) { dragRgn = cursorRgn; RectRgn(dragRgn, &dragRect); dragRectControl = kNothing; } /* * Don't use gui_mch_update() because then we will spin-lock until a * char arrives, instead we use WaitNextEventWrp() to hang until an * event arrives. No need to check for input_buf_full because we are * returning as soon as it contains a single char. */ // TODO: reduce wtime accordingly??? if (wtime > -1) sleeppyTick = 60 * wtime / 1000; else sleeppyTick = 32767; if (WaitNextEventWrp(mask, &event, sleeppyTick, dragRgn)) { gui_mac_handle_event(&event); if (input_available()) { allow_scrollbar = FALSE; return OK; } } currentTick = TickCount(); } while ((wtime == -1) || ((currentTick - entryTick) < 60*wtime/1000)); allow_scrollbar = FALSE; return FAIL; } /* * Output routines. */ /* * Flush any output to the screen */ void gui_mch_flush(void) { // TODO: Is anything needed here? } /* * Clear a rectangular region of the screen from text pos (row1, col1) to * (row2, col2) inclusive. */ void gui_mch_clear_block(int row1, int col1, int row2, int col2) { Rect rc; /* * Clear one extra pixel at the far right, for when bold characters have * spilled over to the next column. */ rc.left = FILL_X(col1); rc.top = FILL_Y(row1); rc.right = FILL_X(col2 + 1) + (col2 == Columns - 1); rc.bottom = FILL_Y(row2 + 1); gui_mch_set_bg_color(gui.back_pixel); EraseRect(&rc); } /* * Clear the whole text window. */ void gui_mch_clear_all(void) { Rect rc; rc.left = 0; rc.top = 0; rc.right = Columns * gui.char_width + 2 * gui.border_width; rc.bottom = Rows * gui.char_height + 2 * gui.border_width; gui_mch_set_bg_color(gui.back_pixel); EraseRect(&rc); // gui_mch_set_fg_color(gui.norm_pixel); // FrameRect(&rc); } /* * Delete the given number of lines from the given row, scrolling up any * text further down within the scroll region. */ void gui_mch_delete_lines(int row, int num_lines) { Rect rc; // changed without checking! rc.left = FILL_X(gui.scroll_region_left); rc.right = FILL_X(gui.scroll_region_right + 1); rc.top = FILL_Y(row); rc.bottom = FILL_Y(gui.scroll_region_bot + 1); gui_mch_set_bg_color(gui.back_pixel); ScrollRect(&rc, 0, -num_lines * gui.char_height, (RgnHandle) nil); gui_clear_block(gui.scroll_region_bot - num_lines + 1, gui.scroll_region_left, gui.scroll_region_bot, gui.scroll_region_right); } /* * Insert the given number of lines before the given row, scrolling down any * following text within the scroll region. */ void gui_mch_insert_lines(int row, int num_lines) { Rect rc; rc.left = FILL_X(gui.scroll_region_left); rc.right = FILL_X(gui.scroll_region_right + 1); rc.top = FILL_Y(row); rc.bottom = FILL_Y(gui.scroll_region_bot + 1); gui_mch_set_bg_color(gui.back_pixel); ScrollRect(&rc, 0, gui.char_height * num_lines, (RgnHandle) nil); // Update gui.cursor_row if the cursor scrolled or copied over if (gui.cursor_row >= gui.row && gui.cursor_col >= gui.scroll_region_left && gui.cursor_col <= gui.scroll_region_right) { if (gui.cursor_row <= gui.scroll_region_bot - num_lines) gui.cursor_row += num_lines; else if (gui.cursor_row <= gui.scroll_region_bot) gui.cursor_is_valid = FALSE; } gui_clear_block(row, gui.scroll_region_left, row + num_lines - 1, gui.scroll_region_right); } /* * TODO: add a vim format to the clipboard which remember * LINEWISE, CHARWISE, BLOCKWISE */ void clip_mch_request_selection(Clipboard_T *cbd) { Handle textOfClip; int flavor = 0; Size scrapSize; ScrapFlavorFlags scrapFlags; ScrapRef scrap = nil; OSStatus error; int type; char *searchCR; char_u *tempclip; error = GetCurrentScrap(&scrap); if (error != noErr) return; error = GetScrapFlavorFlags(scrap, VIMSCRAPFLAVOR, &scrapFlags); if (error == noErr) { error = GetScrapFlavorSize(scrap, VIMSCRAPFLAVOR, &scrapSize); if (error == noErr && scrapSize > 1) flavor = 1; } if (flavor == 0) { error = GetScrapFlavorFlags(scrap, SCRAPTEXTFLAVOR, &scrapFlags); if (error != noErr) return; error = GetScrapFlavorSize(scrap, SCRAPTEXTFLAVOR, &scrapSize); if (error != noErr) return; } ReserveMem(scrapSize); // In CARBON we don't need a Handle, a pointer is good textOfClip = NewHandle(scrapSize); // tempclip = alloc(scrapSize+1); HLock(textOfClip); error = GetScrapFlavorData(scrap, flavor ? VIMSCRAPFLAVOR : SCRAPTEXTFLAVOR, &scrapSize, *textOfClip); scrapSize -= flavor; if (flavor) type = **textOfClip; else type = MAUTO; tempclip = alloc(scrapSize + 1); mch_memmove(tempclip, *textOfClip + flavor, scrapSize); tempclip[scrapSize] = 0; #ifdef MACOS_CONVERT { // Convert from utf-16 (clipboard) size_t encLen = 0; char_u *to = mac_utf16_to_enc((UniChar *)tempclip, scrapSize, &encLen); if (to != NULL) { scrapSize = encLen; vim_free(tempclip); tempclip = to; } } #endif searchCR = (char *)tempclip; while (searchCR != NULL) { searchCR = strchr(searchCR, '\r'); if (searchCR != NULL) *searchCR = '\n'; } clip_yank_selection(type, tempclip, scrapSize, cbd); vim_free(tempclip); HUnlock(textOfClip); DisposeHandle(textOfClip); } void clip_mch_lose_selection(Clipboard_T *cbd) { /* * TODO: Really nothing to do? */ } int clip_mch_own_selection(Clipboard_T *cbd) { return OK; } /* * Send the current selection to the clipboard. */ void clip_mch_set_selection(Clipboard_T *cbd) { Handle textOfClip; long scrapSize; int type; ScrapRef scrap; char_u *str = NULL; if (!cbd->owned) return; clip_get_selection(cbd); /* * Once we set the clipboard, lose ownership. If another application sets * the clipboard, we don't want to think that we still own it. */ cbd->owned = FALSE; type = clip_convert_selection(&str, (long_u *)&scrapSize, cbd); #ifdef MACOS_CONVERT size_t utf16_len = 0; UniChar *to = mac_enc_to_utf16(str, scrapSize, &utf16_len); if (to) { scrapSize = utf16_len; vim_free(str); str = (char_u *)to; } #endif if (type >= 0) { ClearCurrentScrap(); textOfClip = NewHandle(scrapSize + 1); HLock(textOfClip); **textOfClip = type; mch_memmove(*textOfClip + 1, str, scrapSize); GetCurrentScrap(&scrap); PutScrapFlavor(scrap, SCRAPTEXTFLAVOR, kScrapFlavorMaskNone, scrapSize, *textOfClip + 1); PutScrapFlavor(scrap, VIMSCRAPFLAVOR, kScrapFlavorMaskNone, scrapSize + 1, *textOfClip); HUnlock(textOfClip); DisposeHandle(textOfClip); } vim_free(str); } void gui_mch_set_text_area_pos(int x, int y, int w, int h) { Rect VimBound; // HideWindow(gui.VimWindow); GetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &VimBound); if (gui.which_scrollbars[SBAR_LEFT]) VimBound.left = -gui.scrollbar_width + 1; else VimBound.left = 0; SetWindowBounds(gui.VimWindow, kWindowGlobalPortRgn, &VimBound); ShowWindow(gui.VimWindow); } /* * Menu stuff. */ void gui_mch_enable_menu(int flag) { /* * Menu is always active. */ } void gui_mch_set_menu_pos(int x, int y, int w, int h) { /* * The menu is always at the top of the screen. */ } /* * Add a sub menu to the menu bar. */ void gui_mch_add_menu(vimmenu_T *menu, int idx) { /* * TODO: Try to use only menu_id instead of both menu_id and menu_handle. * TODO: use menu->mnemonic and menu->actext * TODO: Try to reuse menu id * Carbon Help suggest to use only id between 1 and 235 */ static long next_avail_id = 128; long menu_after_me = 0; // Default to the end CFStringRef name; short index; vimmenu_T *parent = menu->parent; vimmenu_T *brother = menu->next; // Cannot add a menu if ... if ((parent != NULL && parent->submenu_id == 0)) return; // menu ID greater than 1024 are reserved for ??? if (next_avail_id == 1024) return; // My brother could be the PopUp, find my real brother while ((brother != NULL) && (!menu_is_menubar(brother->name))) brother = brother->next; // Find where to insert the menu (for MenuBar) if ((parent == NULL) && (brother != NULL)) menu_after_me = brother->submenu_id; // If the menu is not part of the menubar (and its submenus), add it 'nowhere' if (!menu_is_menubar(menu->name)) menu_after_me = hierMenu; // Convert the name #ifdef MACOS_CONVERT name = menu_title_removing_mnemonic(menu); #else name = C2Pascal_save(menu->dname); #endif if (name == NULL) return; // Create the menu unless it's the help menu { // Carbon suggest use of // OSStatus CreateNewMenu(MenuID, MenuAttributes, MenuRef *); // OSStatus SetMenuTitle(MenuRef, ConstStr255Param title); menu->submenu_id = next_avail_id; if (CreateNewMenu(menu->submenu_id, 0, (MenuRef *)&menu->submenu_handle) == noErr) SetMenuTitleWithCFString((MenuRef)menu->submenu_handle, name); next_avail_id++; } if (parent == NULL) { // Adding a menu to the menubar, or in the no mans land (for PopUp) // TODO: Verify if we could only Insert Menu if really part of the // menubar The Inserted menu are scanned or the Command-key combos // Insert the menu InsertMenu(menu->submenu_handle, menu_after_me); // insert before #if 1 // Vim should normally update it. TODO: verify DrawMenuBar(); #endif } else { // Adding as a submenu index = gui_mac_get_menu_item_index(menu); // Call InsertMenuItem followed by SetMenuItemText // to avoid special character recognition by InsertMenuItem InsertMenuItem(parent->submenu_handle, "\p ", idx); // afterItem SetMenuItemTextWithCFString(parent->submenu_handle, idx+1, name); SetItemCmd(parent->submenu_handle, idx+1, 0x1B); SetItemMark(parent->submenu_handle, idx+1, menu->submenu_id); InsertMenu(menu->submenu_handle, hierMenu); } CFRelease(name); #if 0 // Done by Vim later on DrawMenuBar(); #endif } /* * Add a menu item to a menu */ void gui_mch_add_menu_item(vimmenu_T *menu, int idx) { CFStringRef name; vimmenu_T *parent = menu->parent; int menu_inserted; // Cannot add item, if the menu have not been created if (parent->submenu_id == 0) return; // Could call SetMenuRefCon [CARBON] to associate with the Menu, // for older OS call GetMenuItemData (menu, item, isCommandID?, data) // Convert the name #ifdef MACOS_CONVERT name = menu_title_removing_mnemonic(menu); #else name = C2Pascal_save(menu->dname); #endif // Where are just a menu item, so no handle, no id menu->submenu_id = 0; menu->submenu_handle = NULL; menu_inserted = 0; if (menu->actext) { // If the accelerator text for the menu item looks like it describes // a command key (e.g., "" or ""), display it as the // item's command equivalent. int key = 0; int modifiers = 0; char_u *p_actext; p_actext = menu->actext; key = find_special_key(&p_actext, &modifiers, FSK_SIMPLIFY, NULL); if (*p_actext != 0) key = 0; // error: trailing text // find_special_key() returns a keycode with as many of the // specified modifiers as appropriate already applied (e.g., for // "" it returns Ctrl-X as the keycode and MOD_MASK_CMD // as the only modifier). Since we want to display all of the // modifiers, we need to convert the keycode back to a printable // character plus modifiers. // TODO: Write an alternative find_special_key() that doesn't // apply modifiers. if (key > 0 && key < 32) { // Convert a control key to an uppercase letter. Note that // by this point it is no longer possible to distinguish // between, e.g., Ctrl-S and Ctrl-Shift-S. modifiers |= MOD_MASK_CTRL; key += '@'; } // If the keycode is an uppercase letter, set the Shift modifier. // If it is a lowercase letter, don't set the modifier, but convert // the letter to uppercase for display in the menu. else if (key >= 'A' && key <= 'Z') modifiers |= MOD_MASK_SHIFT; else if (key >= 'a' && key <= 'z') key += 'A' - 'a'; // Note: keycodes below 0x22 are reserved by Apple. if (key >= 0x22 && vim_isprintc_strict(key)) { int valid = 1; char_u mac_mods = kMenuNoModifiers; // Convert Vim modifier codes to Menu Manager equivalents. if (modifiers & MOD_MASK_SHIFT) mac_mods |= kMenuShiftModifier; if (modifiers & MOD_MASK_CTRL) mac_mods |= kMenuControlModifier; if (!(modifiers & MOD_MASK_CMD)) mac_mods |= kMenuNoCommandModifier; if (modifiers & MOD_MASK_ALT || modifiers & MOD_MASK_MULTI_CLICK) valid = 0; // TODO: will Alt someday map to Option? if (valid) { char_u item_txt[10]; // Insert the menu item after idx, with its command key. item_txt[0] = 3; item_txt[1] = ' '; item_txt[2] = '/'; item_txt[3] = key; InsertMenuItem(parent->submenu_handle, item_txt, idx); // Set the modifier keys. SetMenuItemModifiers(parent->submenu_handle, idx+1, mac_mods); menu_inserted = 1; } } } // Call InsertMenuItem followed by SetMenuItemText // to avoid special character recognition by InsertMenuItem if (!menu_inserted) InsertMenuItem(parent->submenu_handle, "\p ", idx); // afterItem // Set the menu item name. SetMenuItemTextWithCFString(parent->submenu_handle, idx+1, name); #if 0 // Called by Vim DrawMenuBar(); #endif CFRelease(name); } void gui_mch_toggle_tearoffs(int enable) { // no tearoff menus } /* * Destroy the machine specific menu widget. */ void gui_mch_destroy_menu(vimmenu_T *menu) { short index = gui_mac_get_menu_item_index(menu); if (index > 0) { if (menu->parent) { { // For now just don't delete help menu items. (Huh? Dany) DeleteMenuItem(menu->parent->submenu_handle, index); // Delete the Menu if it was a hierarchical Menu if (menu->submenu_id != 0) { DeleteMenu(menu->submenu_id); DisposeMenu(menu->submenu_handle); } } } #ifdef DEBUG_MAC_MENU else { printf("gmdm 2\n"); } #endif } else { { DeleteMenu(menu->submenu_id); DisposeMenu(menu->submenu_handle); } } // Shouldn't this be already done by Vim. TODO: Check DrawMenuBar(); } /* * Make a menu either grey or not grey. */ void gui_mch_menu_grey(vimmenu_T *menu, int grey) { // TODO: Check if menu really exists short index = gui_mac_get_menu_item_index(menu); /* index = menu->index; */ if (grey) { if (menu->children) DisableMenuItem(menu->submenu_handle, index); if (menu->parent) if (menu->parent->submenu_handle) DisableMenuItem(menu->parent->submenu_handle, index); } else { if (menu->children) EnableMenuItem(menu->submenu_handle, index); if (menu->parent) if (menu->parent->submenu_handle) EnableMenuItem(menu->parent->submenu_handle, index); } } /* * Make menu item hidden or not hidden */ void gui_mch_menu_hidden(vimmenu_T *menu, int hidden) { // There's no hidden mode on MacOS gui_mch_menu_grey(menu, hidden); } /* * This is called after setting all the menus to grey/hidden or not. */ void gui_mch_draw_menubar(void) { DrawMenuBar(); } /* * Scrollbar stuff. */ void gui_mch_enable_scrollbar( scrollbar_T *sb, int flag) { if (flag) ShowControl(sb->id); else HideControl(sb->id); #ifdef DEBUG_MAC_SB printf("enb_sb (%x) %x\n",sb->id, flag); #endif } void gui_mch_set_scrollbar_thumb( scrollbar_T *sb, long val, long size, long max) { SetControl32BitMaximum (sb->id, max); SetControl32BitMinimum (sb->id, 0); SetControl32BitValue (sb->id, val); SetControlViewSize (sb->id, size); #ifdef DEBUG_MAC_SB printf("thumb_sb (%x) %lx, %lx,%lx\n",sb->id, val, size, max); #endif } void gui_mch_set_scrollbar_pos( scrollbar_T *sb, int x, int y, int w, int h) { gui_mch_set_bg_color(gui.back_pixel); #if 0 if (gui.which_scrollbars[SBAR_LEFT]) { MoveControl(sb->id, x-16, y); SizeControl(sb->id, w + 1, h); } else { MoveControl(sb->id, x, y); SizeControl(sb->id, w + 1, h); } #endif if (sb == &gui.bottom_sbar) h += 1; else w += 1; if (gui.which_scrollbars[SBAR_LEFT]) x -= 15; MoveControl(sb->id, x, y); SizeControl(sb->id, w, h); #ifdef DEBUG_MAC_SB printf("size_sb (%x) %x, %x, %x, %x\n",sb->id, x, y, w, h); #endif } int gui_mch_get_scrollbar_xpadding(void) { // TODO: Calculate the padding for adjust scrollbar position when the // Window is maximized. return 0; } int gui_mch_get_scrollbar_ypadding(void) { // TODO: Calculate the padding for adjust scrollbar position when the // Window is maximized. return 0; } void gui_mch_create_scrollbar( scrollbar_T *sb, int orient) // SBAR_VERT or SBAR_HORIZ { Rect bounds; bounds.top = -16; bounds.bottom = -10; bounds.right = -10; bounds.left = -16; sb->id = NewControl(gui.VimWindow, &bounds, "\pScrollBar", TRUE, 0, // current 0, // top 0, // bottom kControlScrollBarLiveProc, (long) sb->ident); #ifdef DEBUG_MAC_SB printf("create_sb (%x) %x\n",sb->id, orient); #endif } void gui_mch_destroy_scrollbar(scrollbar_T *sb) { gui_mch_set_bg_color(gui.back_pixel); DisposeControl(sb->id); #ifdef DEBUG_MAC_SB printf("dest_sb (%x) \n",sb->id); #endif } int gui_mch_is_blinking(void) { return FALSE; } int gui_mch_is_blink_off(void) { return FALSE; } /* * Cursor blink functions. * * This is a simple state machine: * BLINK_NONE not blinking at all * BLINK_OFF blinking, cursor is not shown * BLINK_ON blinking, cursor is shown */ void gui_mch_set_blinking(long wait, long on, long off) { #if 0 // TODO: TODO: TODO: TODO: blink_waittime = wait; blink_ontime = on; blink_offtime = off; #endif } /* * Stop the cursor blinking. Show the cursor if it wasn't shown. */ void gui_mch_stop_blink(int may_call_gui_update_cursor) { if (may_call_gui_update_cursor) gui_update_cursor(TRUE, FALSE); #if 0 // TODO: TODO: TODO: TODO: gui_w32_rm_blink_timer(); if (blink_state == BLINK_OFF) gui_update_cursor(TRUE, FALSE); blink_state = BLINK_NONE; #endif } /* * Start the cursor blinking. If it was already blinking, this restarts the * waiting time and shows the cursor. */ void gui_mch_start_blink(void) { gui_update_cursor(TRUE, FALSE); // TODO: TODO: TODO: TODO: // gui_w32_rm_blink_timer(); // Only switch blinking on if none of the times is zero #if 0 if (blink_waittime && blink_ontime && blink_offtime) { blink_timer = SetTimer(NULL, 0, (UINT)blink_waittime, (TIMERPROC)_OnBlinkTimer); blink_state = BLINK_ON; gui_update_cursor(TRUE, FALSE); } #endif } /* * Return the RGB value of a pixel as long. */ guicolor_T gui_mch_get_rgb(guicolor_T pixel) { return (guicolor_T)((Red(pixel) << 16) + (Green(pixel) << 8) + Blue(pixel)); } #ifdef FEAT_BROWSE /* * Pop open a file browser and return the file selected, in allocated memory, * or NULL if Cancel is hit. * saving - TRUE if the file will be saved to, FALSE if it will be opened. * title - Title message for the file browser dialog. * dflt - Default name of file. * ext - Default extension to be added to files without extensions. * initdir - directory in which to open the browser (NULL = current dir) * filter - Filter for matched files to choose from. * Has a format like this: * "C Files (*.c)\0*.c\0" * "All Files\0*.*\0\0" * If these two strings were concatenated, then a choice of two file * filters will be selectable to the user. Then only matching files will * be shown in the browser. If NULL, the default allows all files. * * *NOTE* - the filter string must be terminated with TWO nulls. */ char_u * gui_mch_browse( int saving, char_u *title, char_u *dflt, char_u *ext, char_u *initdir, char_u *filter) { // TODO: Add Ammon's safety check (Dany) NavReplyRecord reply; char_u *fname = NULL; char_u **fnames = NULL; long numFiles; NavDialogOptions navOptions; OSErr error; // Get Navigation Service Defaults value NavGetDefaultDialogOptions(&navOptions); // TODO: If we get a :browse args, set the Multiple bit. navOptions.dialogOptionFlags = kNavAllowInvisibleFiles | kNavDontAutoTranslate | kNavDontAddTranslateItems // | kNavAllowMultipleFiles | kNavAllowStationery; (void) C2PascalString(title, &navOptions.message); (void) C2PascalString(dflt, &navOptions.savedFileName); // Could set clientName? // windowTitle? (there's no title bar?) if (saving) { // Change first parm AEDesc (typeFSS) *defaultLocation to match dflt NavPutFile(NULL, &reply, &navOptions, NULL, 'TEXT', 'VIM!', NULL); if (!reply.validRecord) return NULL; } else { // Change first parm AEDesc (typeFSS) *defaultLocation to match dflt NavGetFile(NULL, &reply, &navOptions, NULL, NULL, NULL, NULL, NULL); if (!reply.validRecord) return NULL; } fnames = new_fnames_from_AEDesc(&reply.selection, &numFiles, &error); NavDisposeReply(&reply); if (fnames) { fname = fnames[0]; vim_free(fnames); } // TODO: Shorten the file name if possible return fname; } #endif // FEAT_BROWSE #ifdef FEAT_GUI_DIALOG /* * Stuff for dialogues */ /* * Create a dialogue dynamically from the parameter strings. * type = type of dialogue (question, alert, etc.) * title = dialogue title. may be NULL for default title. * message = text to display. Dialogue sizes to accommodate it. * buttons = '\n' separated list of button captions, default first. * dfltbutton = number of default button. * * This routine returns 1 if the first button is pressed, * 2 for the second, etc. * * 0 indicates Esc was pressed. * -1 for unexpected error * * If stubbing out this fn, return 1. */ typedef struct { short idx; short width; // Size of the text in pixel Rect box; } vgmDlgItm; // Vim Gui_Mac.c Dialog Item #define MoveRectTo(r,x,y) OffsetRect(r,x-r->left,y-r->top) static void macMoveDialogItem( DialogRef theDialog, short itemNumber, short X, short Y, Rect *inBox) { #if 0 // USE_CARBONIZED // Untested MoveDialogItem(theDialog, itemNumber, X, Y); if (inBox != nil) GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, inBox); #else short itemType; Handle itemHandle; Rect localBox; Rect *itemBox = &localBox; if (inBox != nil) itemBox = inBox; GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, itemBox); OffsetRect(itemBox, -itemBox->left, -itemBox->top); OffsetRect(itemBox, X, Y); // To move a control (like a button) we need to call both // MoveControl and SetDialogItem. FAQ 6-18 if (1) //(itemType & kControlDialogItem) MoveControl((ControlRef) itemHandle, X, Y); SetDialogItem(theDialog, itemNumber, itemType, itemHandle, itemBox); #endif } static void macSizeDialogItem( DialogRef theDialog, short itemNumber, short width, short height) { short itemType; Handle itemHandle; Rect itemBox; GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, &itemBox); // When width or height is zero do not change it if (width == 0) width = itemBox.right - itemBox.left; if (height == 0) height = itemBox.bottom - itemBox.top; #if 0 // USE_CARBONIZED SizeDialogItem(theDialog, itemNumber, width, height); // Untested #else // Resize the bounding box itemBox.right = itemBox.left + width; itemBox.bottom = itemBox.top + height; // To resize a control (like a button) we need to call both // SizeControl and SetDialogItem. (deducted from FAQ 6-18) if (itemType & kControlDialogItem) SizeControl((ControlRef) itemHandle, width, height); // Configure back the item SetDialogItem(theDialog, itemNumber, itemType, itemHandle, &itemBox); #endif } static void macSetDialogItemText( DialogRef theDialog, short itemNumber, Str255 itemName) { short itemType; Handle itemHandle; Rect itemBox; GetDialogItem(theDialog, itemNumber, &itemType, &itemHandle, &itemBox); if (itemType & kControlDialogItem) SetControlTitle((ControlRef) itemHandle, itemName); else SetDialogItemText(itemHandle, itemName); } /* * ModalDialog() handler for message dialogs that have hotkey accelerators. * Expects a mapping of hotkey char to control index in gDialogHotKeys; * setting gDialogHotKeys to NULL disables any hotkey handling. */ static pascal Boolean DialogHotkeyFilterProc ( DialogRef theDialog, EventRecord *event, DialogItemIndex *itemHit) { char_u keyHit; if (event->what == keyDown || event->what == autoKey) { keyHit = (event->message & charCodeMask); if (gDialogHotKeys && gDialogHotKeys[keyHit]) { #ifdef DEBUG_MAC_DIALOG_HOTKEYS printf("user pressed hotkey '%c' --> item %d\n", keyHit, gDialogHotKeys[keyHit]); #endif *itemHit = gDialogHotKeys[keyHit]; // When handing off to StdFilterProc, pretend that the user // clicked the control manually. Note that this is also supposed // to cause the button to hilite briefly (to give some user // feedback), but this seems not to actually work (or it's too // fast to be seen). event->what = kEventControlSimulateHit; return true; // we took care of it } // Defer to the OS's standard behavior for this event. // This ensures that Enter will still activate the default button. return StdFilterProc(theDialog, event, itemHit); } return false; // Let ModalDialog deal with it } /* * TODO: There have been some crashes with dialogs, check your inbox * (Jussi) */ int gui_mch_dialog( int type, char_u *title, char_u *message, char_u *buttons, int dfltbutton, char_u *textfield, int ex_cmd) { Handle buttonDITL; Handle iconDITL; Handle inputDITL; Handle messageDITL; Handle itemHandle; Handle iconHandle; DialogPtr theDialog; char_u len; char_u PascalTitle[256]; // place holder for the title char_u name[256]; GrafPtr oldPort; short itemHit; char_u *buttonChar; short hotKeys[256]; // map of hotkey -> control ID char_u aHotKey; Rect box; short button; short lastButton; short itemType; short useIcon; short width; short totalButtonWidth = 0; // the width of all buttons together // including spacing short widestButton = 0; short dfltButtonEdge = 20; // gut feeling short dfltElementSpacing = 13; // from IM:V.2-29 short dfltIconSideSpace = 23; // from IM:V.2-29 short maximumWidth = 400; // gut feeling short maxButtonWidth = 175; // gut feeling short vertical; short dialogHeight; short messageLines = 3; FontInfo textFontInfo; vgmDlgItm iconItm; vgmDlgItm messageItm; vgmDlgItm inputItm; vgmDlgItm buttonItm; WindowRef theWindow; ModalFilterUPP dialogUPP; // Check 'v' flag in 'guioptions': vertical button placement. vertical = (vim_strchr(p_go, GO_VERTICAL) != NULL); // Create a new Dialog Box from template. theDialog = GetNewDialog(129, nil, (WindowRef) -1); // Get the WindowRef theWindow = GetDialogWindow(theDialog); // Hide the window. // 1. to avoid seeing slow drawing // 2. to prevent a problem seen while moving dialog item // within a visible window. (non-Carbon MacOS 9) // Could be avoided by changing the resource. HideWindow(theWindow); // Change the graphical port to the dialog, // so we can measure the text with the proper font GetPort(&oldPort); SetPortDialogPort(theDialog); // Get the info about the default text, // used to calculate the height of the message // and of the text field GetFontInfo(&textFontInfo); // Set the dialog title if (title != NULL) { (void) C2PascalString(title, &PascalTitle); SetWTitle(theWindow, PascalTitle); } // Creates the buttons and add them to the Dialog Box. buttonDITL = GetResource('DITL', 130); buttonChar = buttons; button = 0; // initialize the hotkey mapping CLEAR_FIELD(hotKeys); for (;*buttonChar != 0;) { // Get the name of the button button++; len = 0; for (;((*buttonChar != DLG_BUTTON_SEP) && (*buttonChar != 0) && (len < 255)); buttonChar++) { if (*buttonChar != DLG_HOTKEY_CHAR) name[++len] = *buttonChar; else { aHotKey = (char_u)*(buttonChar+1); if (aHotKey >= 'A' && aHotKey <= 'Z') aHotKey = (char_u)((int)aHotKey + (int)'a' - (int)'A'); hotKeys[aHotKey] = button; #ifdef DEBUG_MAC_DIALOG_HOTKEYS printf("### hotKey for button %d is '%c'\n", button, aHotKey); #endif } } if (*buttonChar != 0) buttonChar++; name[0] = len; // Add the button AppendDITL(theDialog, buttonDITL, overlayDITL); // appendDITLRight); // Change the button's name macSetDialogItemText(theDialog, button, name); // Resize the button to fit its name width = StringWidth(name) + 2 * dfltButtonEdge; // Limit the size of any button to an acceptable value. // TODO: Should be based on the message width if (width > maxButtonWidth) width = maxButtonWidth; macSizeDialogItem(theDialog, button, width, 0); totalButtonWidth += width; if (width > widestButton) widestButton = width; } ReleaseResource(buttonDITL); lastButton = button; // Add the icon to the Dialog Box. iconItm.idx = lastButton + 1; iconDITL = GetResource('DITL', 131); switch (type) { case VIM_GENERIC: case VIM_INFO: case VIM_QUESTION: useIcon = kNoteIcon; break; case VIM_WARNING: useIcon = kCautionIcon; break; case VIM_ERROR: useIcon = kStopIcon; break; default: useIcon = kStopIcon; } AppendDITL(theDialog, iconDITL, overlayDITL); ReleaseResource(iconDITL); GetDialogItem(theDialog, iconItm.idx, &itemType, &itemHandle, &box); // TODO: Should the item be freed? iconHandle = GetIcon(useIcon); SetDialogItem(theDialog, iconItm.idx, itemType, iconHandle, &box); // Add the message to the Dialog box. messageItm.idx = lastButton + 2; messageDITL = GetResource('DITL', 132); AppendDITL(theDialog, messageDITL, overlayDITL); ReleaseResource(messageDITL); GetDialogItem(theDialog, messageItm.idx, &itemType, &itemHandle, &box); (void) C2PascalString(message, &name); SetDialogItemText(itemHandle, name); messageItm.width = StringWidth(name); // Add the input box if needed if (textfield != NULL) { // Cheat for now reuse the message and convert to text edit inputItm.idx = lastButton + 3; inputDITL = GetResource('DITL', 132); AppendDITL(theDialog, inputDITL, overlayDITL); ReleaseResource(inputDITL); GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &box); // SetDialogItem(theDialog, inputItm.idx, kEditTextDialogItem, itemHandle, &box); (void) C2PascalString(textfield, &name); SetDialogItemText(itemHandle, name); inputItm.width = StringWidth(name); // Hotkeys don't make sense if there's a text field gDialogHotKeys = NULL; } else // Install hotkey table gDialogHotKeys = (short *)&hotKeys; // Set the and button. SetDialogDefaultItem(theDialog, dfltbutton); SetDialogCancelItem(theDialog, 0); // Reposition element // Check if we need to force vertical if (totalButtonWidth > maximumWidth) vertical = TRUE; // Place icon macMoveDialogItem(theDialog, iconItm.idx, dfltIconSideSpace, dfltElementSpacing, &box); iconItm.box.right = box.right; iconItm.box.bottom = box.bottom; // Place Message messageItm.box.left = iconItm.box.right + dfltIconSideSpace; macSizeDialogItem(theDialog, messageItm.idx, 0, messageLines * (textFontInfo.ascent + textFontInfo.descent)); macMoveDialogItem(theDialog, messageItm.idx, messageItm.box.left, dfltElementSpacing, &messageItm.box); // Place Input if (textfield != NULL) { inputItm.box.left = messageItm.box.left; inputItm.box.top = messageItm.box.bottom + dfltElementSpacing; macSizeDialogItem(theDialog, inputItm.idx, 0, textFontInfo.ascent + textFontInfo.descent); macMoveDialogItem(theDialog, inputItm.idx, inputItm.box.left, inputItm.box.top, &inputItm.box); // Convert the static text into a text edit. // For some reason this change need to be done last (Dany) GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &inputItm.box); SetDialogItem(theDialog, inputItm.idx, kEditTextDialogItem, itemHandle, &inputItm.box); SelectDialogItemText(theDialog, inputItm.idx, 0, 32767); } // Place Button if (textfield != NULL) { buttonItm.box.left = inputItm.box.left; buttonItm.box.top = inputItm.box.bottom + dfltElementSpacing; } else { buttonItm.box.left = messageItm.box.left; buttonItm.box.top = messageItm.box.bottom + dfltElementSpacing; } for (button=1; button <= lastButton; button++) { macMoveDialogItem(theDialog, button, buttonItm.box.left, buttonItm.box.top, &box); // With vertical, it's better to have all buttons the same length if (vertical) { macSizeDialogItem(theDialog, button, widestButton, 0); GetDialogItem(theDialog, button, &itemType, &itemHandle, &box); } // Calculate position of next button if (vertical) buttonItm.box.top = box.bottom + dfltElementSpacing; else buttonItm.box.left = box.right + dfltElementSpacing; } // Resize the dialog box dialogHeight = box.bottom + dfltElementSpacing; SizeWindow(theWindow, maximumWidth, dialogHeight, TRUE); // Magic resize AutoSizeDialog(theDialog); // Need a horizontal resize anyway so not that useful // Display it ShowWindow(theWindow); // BringToFront(theWindow); SelectWindow(theWindow); // DrawDialog(theDialog); #if 0 GetPort(&oldPort); SetPortDialogPort(theDialog); #endif #ifdef USE_CARBONKEYHANDLER // Avoid that we use key events for the main window. dialog_busy = TRUE; #endif // Prepare the shortcut-handling filterProc for handing to the dialog dialogUPP = NewModalFilterUPP(DialogHotkeyFilterProc); // Hang until one of the button is hit do ModalDialog(dialogUPP, &itemHit); while ((itemHit < 1) || (itemHit > lastButton)); #ifdef USE_CARBONKEYHANDLER dialog_busy = FALSE; #endif // Copy back the text entered by the user into the param if (textfield != NULL) { GetDialogItem(theDialog, inputItm.idx, &itemType, &itemHandle, &box); GetDialogItemText(itemHandle, (char_u *) &name); #if IOSIZE < 256 // Truncate the name to IOSIZE if needed if (name[0] > IOSIZE) name[0] = IOSIZE - 1; #endif vim_strncpy(textfield, &name[1], name[0]); } // Restore the original graphical port SetPort(oldPort); // Free the modal filterProc DisposeRoutineDescriptor(dialogUPP); // Get ride of the dialog (free memory) DisposeDialog(theDialog); return itemHit; /* * Useful thing which could be used * SetDialogTimeout(): Auto click a button after timeout * SetDialogTracksCursor() : Get the I-beam cursor over input box * MoveDialogItem(): Probably better than SetDialogItem * SizeDialogItem(): (but is it Carbon Only?) * AutoSizeDialog(): Magic resize of dialog based on text length */ } #endif // FEAT_DIALOG_GUI /* * Display the saved error message(s). */ #ifdef USE_MCH_ERRMSG void display_errors(void) { char *p; char_u pError[256]; if (error_ga.ga_data == NULL) return; // avoid putting up a message box with blanks only for (p = (char *)error_ga.ga_data; *p; ++p) if (!isspace(*p)) { if (STRLEN(p) > 255) pError[0] = 255; else pError[0] = STRLEN(p); STRNCPY(&pError[1], p, pError[0]); ParamText(pError, nil, nil, nil); Alert(128, nil); break; // TODO: handled message longer than 256 chars // use auto-sizeable alert // or dialog with scrollbars (TextEdit zone) } ga_clear(&error_ga); } #endif /* * Get current mouse coordinates in text window. */ void gui_mch_getmouse(int *x, int *y) { Point where; GetMouse(&where); *x = where.h; *y = where.v; } void gui_mch_setmouse(int x, int y) { // TODO #if 0 // From FAQ 3-11 CursorDevicePtr myMouse; Point where; if ( NGetTrapAddress(_CursorDeviceDispatch, ToolTrap) != NGetTrapAddress(_Unimplemented, ToolTrap)) { // New way /* * Get first device with one button. * This will probably be the standard mouse * start at head of cursor dev list * */ myMouse = nil; do { // Get the next cursor device CursorDeviceNextDevice(&myMouse); } while ((myMouse != nil) && (myMouse->cntButtons != 1)); CursorDeviceMoveTo(myMouse, x, y); } else { // Old way where.h = x; where.v = y; *(Point *)RawMouse = where; *(Point *)MTemp = where; *(Ptr) CrsrNew = 0xFFFF; } #endif } void gui_mch_show_popupmenu(vimmenu_T *menu) { /* * Clone PopUp to use menu * Create a object descriptor for the current selection * Call the procedure */ MenuHandle CntxMenu; Point where; OSStatus status; UInt32 CntxType; SInt16 CntxMenuID; UInt16 CntxMenuItem; Str255 HelpName = ""; GrafPtr savePort; // Save Current Port: On MacOS X we seem to lose the port GetPort(&savePort); //OSX GetMouse(&where); LocalToGlobal(&where); //OSX CntxMenu = menu->submenu_handle; // TODO: Get the text selection from Vim // Call to Handle Popup status = ContextualMenuSelect(CntxMenu, where, false, kCMHelpItemRemoveHelp, HelpName, NULL, &CntxType, &CntxMenuID, &CntxMenuItem); if (status == noErr) { if (CntxType == kCMMenuItemSelected) { // Handle the menu CntxMenuID, CntxMenuItem // The submenu can be handle directly by gui_mac_handle_menu // But what about the current menu, is the menu changed by // ContextualMenuSelect gui_mac_handle_menu((CntxMenuID << 16) + CntxMenuItem); } else if (CntxMenuID == kCMShowHelpSelected) { // Should come up with the help } } // Restore original Port SetPort(savePort); //OSX } #if defined(FEAT_CW_EDITOR) || defined(PROTO) // TODO: Is it need for MACOS_X? (Dany) void mch_post_buffer_write(buf_T *buf) { GetFSSpecFromPath(buf->b_ffname, &buf->b_FSSpec); Send_KAHL_MOD_AE(buf); } #endif #ifdef FEAT_TITLE /* * Set the window title and icon. * (The icon is not taken care of). */ void gui_mch_settitle(char_u *title, char_u *icon) { // TODO: Get vim to make sure maxlen (from p_titlelen) is smaller // that 256. Even better get it to fit nicely in the titlebar. #ifdef MACOS_CONVERT CFStringRef windowTitle; size_t windowTitleLen; #else char_u *pascalTitle; #endif if (title == NULL) // nothing to do return; #ifdef MACOS_CONVERT windowTitleLen = STRLEN(title); windowTitle = (CFStringRef)mac_enc_to_cfstring(title, windowTitleLen); if (windowTitle) { SetWindowTitleWithCFString(gui.VimWindow, windowTitle); CFRelease(windowTitle); } #else pascalTitle = C2Pascal_save(title); if (pascalTitle != NULL) { SetWTitle(gui.VimWindow, pascalTitle); vim_free(pascalTitle); } #endif } #endif /* * Transferred from os_mac.c for MacOS X using os_unix.c prep work */ int C2PascalString(char_u *CString, Str255 *PascalString) { char_u *PascalPtr = (char_u *) PascalString; int len; int i; PascalPtr[0] = 0; if (CString == NULL) return 0; len = STRLEN(CString); if (len > 255) len = 255; for (i = 0; i < len; i++) PascalPtr[i+1] = CString[i]; PascalPtr[0] = len; return 0; } int GetFSSpecFromPath(char_u *file, FSSpec *fileFSSpec) { // From FAQ 8-12 Str255 filePascal; CInfoPBRec myCPB; OSErr err; (void) C2PascalString(file, &filePascal); myCPB.dirInfo.ioNamePtr = filePascal; myCPB.dirInfo.ioVRefNum = 0; myCPB.dirInfo.ioFDirIndex = 0; myCPB.dirInfo.ioDrDirID = 0; err= PBGetCatInfo(&myCPB, false); // vRefNum, dirID, name FSMakeFSSpec(0, 0, filePascal, fileFSSpec); // TODO: Use an error code mechanism return 0; } /* * Convert a FSSpec to a full path */ char_u *FullPathFromFSSpec_save(FSSpec file) { /* * TODO: Add protection for 256 char max. */ CInfoPBRec theCPB; char_u fname[256]; char_u *filenamePtr = fname; OSErr error; int folder = 1; #ifdef USE_UNIXFILENAME SInt16 dfltVol_vRefNum; SInt32 dfltVol_dirID; FSRef refFile; OSStatus status; UInt32 pathSize = 256; char_u pathname[256]; char_u *path = pathname; #else Str255 directoryName; char_u temporary[255]; char_u *temporaryPtr = temporary; #endif #ifdef USE_UNIXFILENAME // Get the default volume // TODO: Remove as this only work if Vim is on the Boot Volume error=HGetVol(NULL, &dfltVol_vRefNum, &dfltVol_dirID); if (error) return NULL; #endif // Start filling fname with file.name vim_strncpy(filenamePtr, &file.name[1], file.name[0]); // Get the info about the file specified in FSSpec theCPB.dirInfo.ioFDirIndex = 0; theCPB.dirInfo.ioNamePtr = file.name; theCPB.dirInfo.ioVRefNum = file.vRefNum; //theCPB.hFileInfo.ioDirID = 0; theCPB.dirInfo.ioDrDirID = file.parID; // As ioFDirIndex = 0, get the info of ioNamePtr, // which is relative to ioVrefNum, ioDirID error = PBGetCatInfo(&theCPB, false); // If we are called for a new file we expect fnfErr if ((error) && (error != fnfErr)) return NULL; // Check if it's a file or folder // default to file if file don't exist if (((theCPB.hFileInfo.ioFlAttrib & ioDirMask) == 0) || (error)) folder = 0; // It's not a folder else folder = 1; #ifdef USE_UNIXFILENAME /* * The functions used here are available in Carbon, but do nothing on * MacOS 8 and 9. */ if (error == fnfErr) { // If the file to be saved does not already exist, it isn't possible // to convert its FSSpec into an FSRef. But we can construct an // FSSpec for the file's parent folder (since we have its volume and // directory IDs), and since that folder does exist, we can convert // that FSSpec into an FSRef, convert the FSRef in turn into a path, // and, finally, append the filename. FSSpec dirSpec; FSRef dirRef; Str255 emptyFilename = "\p"; error = FSMakeFSSpec(theCPB.dirInfo.ioVRefNum, theCPB.dirInfo.ioDrDirID, emptyFilename, &dirSpec); if (error) return NULL; error = FSpMakeFSRef(&dirSpec, &dirRef); if (error) return NULL; status = FSRefMakePath(&dirRef, (UInt8*)path, pathSize); if (status) return NULL; STRCAT(path, "/"); STRCAT(path, filenamePtr); } else { // If the file to be saved already exists, we can get its full path // by converting its FSSpec into an FSRef. error=FSpMakeFSRef(&file, &refFile); if (error) return NULL; status=FSRefMakePath(&refFile, (UInt8 *) path, pathSize); if (status) return NULL; } // Add a slash at the end if needed if (folder) STRCAT(path, "/"); return (vim_strsave(path)); #else // TODO: Get rid of all USE_UNIXFILENAME below // Set ioNamePtr, it's the same area which is always reused. theCPB.dirInfo.ioNamePtr = directoryName; // Trick for first entry, set ioDrParID to the first value // we want for ioDrDirID theCPB.dirInfo.ioDrParID = file.parID; theCPB.dirInfo.ioDrDirID = file.parID; if ((TRUE) && (file.parID != fsRtDirID /*fsRtParID*/)) do { theCPB.dirInfo.ioFDirIndex = -1; // theCPB.dirInfo.ioNamePtr = directoryName; Already done above. theCPB.dirInfo.ioVRefNum = file.vRefNum; // theCPB.dirInfo.ioDirID = irrelevant when ioFDirIndex = -1 theCPB.dirInfo.ioDrDirID = theCPB.dirInfo.ioDrParID; // As ioFDirIndex = -1, get the info of ioDrDirID, // *ioNamePtr[0 TO 31] will be updated error = PBGetCatInfo(&theCPB,false); if (error) return NULL; // Put the new directoryName in front of the current fname STRCPY(temporaryPtr, filenamePtr); vim_strncpy(filenamePtr, &directoryName[1], directoryName[0]); STRCAT(filenamePtr, ":"); STRCAT(filenamePtr, temporaryPtr); } #if 1 // def USE_UNIXFILENAME while ((theCPB.dirInfo.ioDrParID != fsRtDirID) /* && (theCPB.dirInfo.ioDrDirID != fsRtDirID)*/); #else while (theCPB.dirInfo.ioDrDirID != fsRtDirID); #endif // Get the information about the volume on which the file reside theCPB.dirInfo.ioFDirIndex = -1; // theCPB.dirInfo.ioNamePtr = directoryName; Already done above. theCPB.dirInfo.ioVRefNum = file.vRefNum; // theCPB.dirInfo.ioDirID = irrelevant when ioFDirIndex = -1 theCPB.dirInfo.ioDrDirID = theCPB.dirInfo.ioDrParID; // As ioFDirIndex = -1, get the info of ioDrDirID, // *ioNamePtr[0 TO 31] will be updated error = PBGetCatInfo(&theCPB,false); if (error) return NULL; // For MacOS Classic always add the volume name // For MacOS X add the volume name preceded by "Volumes" // when we are not referring to the boot volume #ifdef USE_UNIXFILENAME if (file.vRefNum != dfltVol_vRefNum) #endif { // Add the volume name STRCPY(temporaryPtr, filenamePtr); vim_strncpy(filenamePtr, &directoryName[1], directoryName[0]); STRCAT(filenamePtr, ":"); STRCAT(filenamePtr, temporaryPtr); #ifdef USE_UNIXFILENAME STRCPY(temporaryPtr, filenamePtr); filenamePtr[0] = 0; // NULL terminate the string STRCAT(filenamePtr, "Volumes:"); STRCAT(filenamePtr, temporaryPtr); #endif } // Append final path separator if it's a folder if (folder) STRCAT(fname, ":"); // As we use Unix File Name for MacOS X convert it #ifdef USE_UNIXFILENAME // Need to insert leading / // TODO: get the above code to use directly the / STRCPY(&temporaryPtr[1], filenamePtr); temporaryPtr[0] = '/'; STRCPY(filenamePtr, temporaryPtr); { char *p; for (p = fname; *p; p++) if (*p == ':') *p = '/'; } #endif return (vim_strsave(fname)); #endif } #if defined(USE_CARBONKEYHANDLER) || defined(PROTO) /* * Input Method Control functions. */ /* * Notify cursor position to IM. */ void im_set_position(int row, int col) { # if 0 // TODO: Implement me! im_start_row = row; im_start_col = col; # endif } static ScriptLanguageRecord gTSLWindow; static ScriptLanguageRecord gTSLInsert; static ScriptLanguageRecord gTSLDefault = { 0, 0 }; static Component gTSCWindow; static Component gTSCInsert; static Component gTSCDefault; static int im_initialized = 0; static void im_on_window_switch(int active) { ScriptLanguageRecord *slptr = NULL; OSStatus err; if (! gui.in_use) return; if (im_initialized == 0) { im_initialized = 1; // save default TSM component (should be U.S.) to default GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault, kKeyboardInputMethodClass); } if (active == TRUE) { im_is_active = TRUE; ActivateTSMDocument(gTSMDocument); slptr = &gTSLWindow; if (slptr) { err = SetDefaultInputMethodOfClass(gTSCWindow, slptr, kKeyboardInputMethodClass); if (err == noErr) err = SetTextServiceLanguage(slptr); if (err == noErr) KeyScript(slptr->fScript | smKeyForceKeyScriptMask); } } else { err = GetTextServiceLanguage(&gTSLWindow); if (err == noErr) slptr = &gTSLWindow; if (slptr) GetDefaultInputMethodOfClass(&gTSCWindow, slptr, kKeyboardInputMethodClass); im_is_active = FALSE; DeactivateTSMDocument(gTSMDocument); } } /* * Set IM status on ("active" is TRUE) or off ("active" is FALSE). */ void im_set_active(int active) { ScriptLanguageRecord *slptr = NULL; OSStatus err; if (!gui.in_use) return; if (im_initialized == 0) { im_initialized = 1; // save default TSM component (should be U.S.) to default GetDefaultInputMethodOfClass(&gTSCDefault, &gTSLDefault, kKeyboardInputMethodClass); } if (active == TRUE) { im_is_active = TRUE; ActivateTSMDocument(gTSMDocument); slptr = &gTSLInsert; if (slptr) { err = SetDefaultInputMethodOfClass(gTSCInsert, slptr, kKeyboardInputMethodClass); if (err == noErr) err = SetTextServiceLanguage(slptr); if (err == noErr) KeyScript(slptr->fScript | smKeyForceKeyScriptMask); } } else { err = GetTextServiceLanguage(&gTSLInsert); if (err == noErr) slptr = &gTSLInsert; if (slptr) GetDefaultInputMethodOfClass(&gTSCInsert, slptr, kKeyboardInputMethodClass); // restore to default when switch to normal mode, so than we could // enter commands easier SetDefaultInputMethodOfClass(gTSCDefault, &gTSLDefault, kKeyboardInputMethodClass); SetTextServiceLanguage(&gTSLDefault); im_is_active = FALSE; DeactivateTSMDocument(gTSMDocument); } } /* * Get IM status. When IM is on, return not 0. Else return 0. */ int im_get_status(void) { if (! gui.in_use) return 0; return im_is_active; } #endif #if defined(FEAT_GUI_TABLINE) || defined(PROTO) // drawer implementation static MenuRef contextMenu = NULL; enum { kTabContextMenuId = 42 }; // the caller has to CFRelease() the returned string static CFStringRef getTabLabel(tabpage_T *page) { get_tabline_label(page, FALSE); #ifdef MACOS_CONVERT return (CFStringRef)mac_enc_to_cfstring(NameBuff, STRLEN(NameBuff)); #else // TODO: check internal encoding? return CFStringCreateWithCString(kCFAllocatorDefault, (char *)NameBuff, kCFStringEncodingMacRoman); #endif } #define DRAWER_SIZE 150 #define DRAWER_INSET 16 static ControlRef dataBrowser = NULL; // when the tabline is hidden, vim doesn't call update_tabline(). When // the tabline is shown again, show_tabline() is called before update_tabline(), // and because of this, the tab labels and vim's internal tabs are out of sync // for a very short time. to prevent inconsistent state, we store the labels // of the tabs, not pointers to the tabs (which are invalid for a short time). static CFStringRef *tabLabels = NULL; static int tabLabelsSize = 0; enum { kTabsColumn = 'Tabs' }; static int getTabCount(void) { tabpage_T *tp; int numTabs = 0; FOR_ALL_TABPAGES(tp) ++numTabs; return numTabs; } // data browser item display callback static OSStatus dbItemDataCallback(ControlRef browser, DataBrowserItemID itemID, DataBrowserPropertyID property /* column id */, DataBrowserItemDataRef itemData, Boolean changeValue) { OSStatus status = noErr; // assert(property == kTabsColumn); // why is this violated?? // changeValue is true if we have a modifiable list and data was changed. // In our case, it's always false. // (that is: if (changeValue) updateInternalData(); else return // internalData(); if (!changeValue) { CFStringRef str; assert(itemID - 1 >= 0 && itemID - 1 < tabLabelsSize); str = tabLabels[itemID - 1]; status = SetDataBrowserItemDataText(itemData, str); } else status = errDataBrowserPropertyNotSupported; return status; } // data browser action callback static void dbItemNotificationCallback(ControlRef browser, DataBrowserItemID item, DataBrowserItemNotification message) { switch (message) { case kDataBrowserItemSelected: send_tabline_event(item); break; } } // callbacks needed for contextual menu: static void dbGetContextualMenuCallback(ControlRef browser, MenuRef *menu, UInt32 *helpType, CFStringRef *helpItemString, AEDesc *selection) { // on mac os 9: kCMHelpItemNoHelp, but it's not the same *helpType = kCMHelpItemRemoveHelp; // OS X only ;-) *helpItemString = NULL; *menu = contextMenu; } static void dbSelectContextualMenuCallback(ControlRef browser, MenuRef menu, UInt32 selectionType, SInt16 menuID, MenuItemIndex menuItem) { if (selectionType == kCMMenuItemSelected) { MenuCommand command; GetMenuItemCommandID(menu, menuItem, &command); // get tab that was selected when the context menu appeared // (there is always one tab selected). TODO: check if the context menu // isn't opened on an item but on empty space (has to be possible some // way, the finder does it too ;-) ) Handle items = NewHandle(0); if (items != NULL) { int numItems; GetDataBrowserItems(browser, kDataBrowserNoItem, false, kDataBrowserItemIsSelected, items); numItems = GetHandleSize(items) / sizeof(DataBrowserItemID); if (numItems > 0) { int idx; DataBrowserItemID *itemsPtr; HLock(items); itemsPtr = (DataBrowserItemID *)*items; idx = itemsPtr[0]; HUnlock(items); send_tabline_menu_event(idx, command); } DisposeHandle(items); } } } // focus callback of the data browser to always leave focus in vim static OSStatus dbFocusCallback(EventHandlerCallRef handler, EventRef event, void *data) { assert(GetEventClass(event) == kEventClassControl && GetEventKind(event) == kEventControlSetFocusPart); return paramErr; } // drawer callback to resize data browser to drawer size static OSStatus drawerCallback(EventHandlerCallRef handler, EventRef event, void *data) { switch (GetEventKind(event)) { case kEventWindowBoundsChanged: // move or resize { UInt32 attribs; GetEventParameter(event, kEventParamAttributes, typeUInt32, NULL, sizeof(attribs), NULL, &attribs); if (attribs & kWindowBoundsChangeSizeChanged) // resize { Rect r; GetWindowBounds(drawer, kWindowContentRgn, &r); SetRect(&r, 0, 0, r.right - r.left, r.bottom - r.top); SetControlBounds(dataBrowser, &r); SetDataBrowserTableViewNamedColumnWidth(dataBrowser, kTabsColumn, r.right); } } break; } return eventNotHandledErr; } // Load DataBrowserChangeAttributes() dynamically on tiger (and better). // This way the code works on 10.2 and 10.3 as well (it doesn't have the // blue highlights in the list view on these systems, though. Oh well.) #import enum { kMyDataBrowserAttributeListViewAlternatingRowColors = (1 << 1) }; static OSStatus myDataBrowserChangeAttributes(ControlRef inDataBrowser, OptionBits inAttributesToSet, OptionBits inAttributesToClear) { long osVersion; char *symbolName; NSSymbol symbol = NULL; OSStatus (*dataBrowserChangeAttributes)(ControlRef inDataBrowser, OptionBits inAttributesToSet, OptionBits inAttributesToClear); Gestalt(gestaltSystemVersion, &osVersion); if (osVersion < 0x1040) // only supported for 10.4 (and up) return noErr; // C name mangling... symbolName = "_DataBrowserChangeAttributes"; if (!NSIsSymbolNameDefined(symbolName) || (symbol = NSLookupAndBindSymbol(symbolName)) == NULL) return noErr; dataBrowserChangeAttributes = NSAddressOfSymbol(symbol); if (dataBrowserChangeAttributes == NULL) return noErr; // well... return dataBrowserChangeAttributes(inDataBrowser, inAttributesToSet, inAttributesToClear); } static void initialise_tabline(void) { Rect drawerRect = { 0, 0, 0, DRAWER_SIZE }; DataBrowserCallbacks dbCallbacks; EventTypeSpec focusEvent = {kEventClassControl, kEventControlSetFocusPart}; EventTypeSpec resizeEvent = {kEventClassWindow, kEventWindowBoundsChanged}; DataBrowserListViewColumnDesc colDesc; // drawers have to have compositing enabled CreateNewWindow(kDrawerWindowClass, kWindowStandardHandlerAttribute | kWindowCompositingAttribute | kWindowResizableAttribute | kWindowLiveResizeAttribute, &drawerRect, &drawer); SetThemeWindowBackground(drawer, kThemeBrushDrawerBackground, true); SetDrawerParent(drawer, gui.VimWindow); SetDrawerOffsets(drawer, kWindowOffsetUnchanged, DRAWER_INSET); // create list view embedded in drawer CreateDataBrowserControl(drawer, &drawerRect, kDataBrowserListView, &dataBrowser); dbCallbacks.version = kDataBrowserLatestCallbacks; InitDataBrowserCallbacks(&dbCallbacks); dbCallbacks.u.v1.itemDataCallback = NewDataBrowserItemDataUPP(dbItemDataCallback); dbCallbacks.u.v1.itemNotificationCallback = NewDataBrowserItemNotificationUPP(dbItemNotificationCallback); dbCallbacks.u.v1.getContextualMenuCallback = NewDataBrowserGetContextualMenuUPP(dbGetContextualMenuCallback); dbCallbacks.u.v1.selectContextualMenuCallback = NewDataBrowserSelectContextualMenuUPP(dbSelectContextualMenuCallback); SetDataBrowserCallbacks(dataBrowser, &dbCallbacks); SetDataBrowserListViewHeaderBtnHeight(dataBrowser, 0); // no header SetDataBrowserHasScrollBars(dataBrowser, false, true); // only vertical SetDataBrowserSelectionFlags(dataBrowser, kDataBrowserSelectOnlyOne | kDataBrowserNeverEmptySelectionSet); SetDataBrowserTableViewHiliteStyle(dataBrowser, kDataBrowserTableViewFillHilite); Boolean b = false; SetControlData(dataBrowser, kControlEntireControl, kControlDataBrowserIncludesFrameAndFocusTag, sizeof(b), &b); // enable blue background in data browser (this is only in 10.4 and vim // has to support older osx versions as well, so we have to load this // function dynamically) myDataBrowserChangeAttributes(dataBrowser, kMyDataBrowserAttributeListViewAlternatingRowColors, 0); // install callback that keeps focus in vim and away from the data browser InstallControlEventHandler(dataBrowser, dbFocusCallback, 1, &focusEvent, NULL, NULL); // install callback that keeps data browser at the size of the drawer InstallWindowEventHandler(drawer, drawerCallback, 1, &resizeEvent, NULL, NULL); // add "tabs" column to data browser colDesc.propertyDesc.propertyID = kTabsColumn; colDesc.propertyDesc.propertyType = kDataBrowserTextType; // add if items can be selected (?): kDataBrowserListViewSelectionColumn colDesc.propertyDesc.propertyFlags = kDataBrowserDefaultPropertyFlags; colDesc.headerBtnDesc.version = kDataBrowserListViewLatestHeaderDesc; colDesc.headerBtnDesc.minimumWidth = 100; colDesc.headerBtnDesc.maximumWidth = 150; colDesc.headerBtnDesc.titleOffset = 0; colDesc.headerBtnDesc.titleString = CFSTR("Tabs"); colDesc.headerBtnDesc.initialOrder = kDataBrowserOrderIncreasing; colDesc.headerBtnDesc.btnFontStyle.flags = 0; // use default font colDesc.headerBtnDesc.btnContentInfo.contentType = kControlContentTextOnly; AddDataBrowserListViewColumn(dataBrowser, &colDesc, 0); // create tabline popup menu required by vim docs (see :he tabline-menu) CreateNewMenu(kTabContextMenuId, 0, &contextMenu); AppendMenuItemTextWithCFString(contextMenu, CFSTR("Close Tab"), 0, TABLINE_MENU_CLOSE, NULL); AppendMenuItemTextWithCFString(contextMenu, CFSTR("New Tab"), 0, TABLINE_MENU_NEW, NULL); AppendMenuItemTextWithCFString(contextMenu, CFSTR("Open Tab..."), 0, TABLINE_MENU_OPEN, NULL); } /* * Show or hide the tabline. */ void gui_mch_show_tabline(int showit) { if (showit == 0) CloseDrawer(drawer, true); else OpenDrawer(drawer, kWindowEdgeRight, true); } /* * Return TRUE when tabline is displayed. */ int gui_mch_showing_tabline(void) { WindowDrawerState state = GetDrawerState(drawer); return state == kWindowDrawerOpen || state == kWindowDrawerOpening; } /* * Update the labels of the tabline. */ void gui_mch_update_tabline(void) { tabpage_T *tp; int numTabs = getTabCount(); int nr = 1; int curtabidx = 1; // adjust data browser if (tabLabels != NULL) { int i; for (i = 0; i < tabLabelsSize; ++i) CFRelease(tabLabels[i]); free(tabLabels); } tabLabels = (CFStringRef *)malloc(numTabs * sizeof(CFStringRef)); tabLabelsSize = numTabs; for (tp = first_tabpage; tp != NULL; tp = tp->tp_next, ++nr) { if (tp == curtab) curtabidx = nr; tabLabels[nr-1] = getTabLabel(tp); } RemoveDataBrowserItems(dataBrowser, kDataBrowserNoItem, 0, NULL, kDataBrowserItemNoProperty); // data browser uses ids 1, 2, 3, ... numTabs per default, so we // can pass NULL for the id array AddDataBrowserItems(dataBrowser, kDataBrowserNoItem, numTabs, NULL, kDataBrowserItemNoProperty); DataBrowserItemID item = curtabidx; SetDataBrowserSelectedItems(dataBrowser, 1, &item, kDataBrowserItemsAssign); } /* * Set the current tab to "nr". First tab is 1. */ void gui_mch_set_curtab(int nr) { DataBrowserItemID item = nr; SetDataBrowserSelectedItems(dataBrowser, 1, &item, kDataBrowserItemsAssign); // TODO: call something like this?: (or restore scroll position, or...) RevealDataBrowserItem(dataBrowser, item, kTabsColumn, kDataBrowserRevealOnly); } #endif // FEAT_GUI_TABLINE