forked from aniani/vim
abab0b0fdd
Problem: Too many curly braces.
Solution: Remove curly braces where they are not needed. (Hirohito Higashi,
closes #3982)
6707 lines
164 KiB
C
6707 lines
164 KiB
C
/* 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 <Devices.h> /* 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 <Menus.h>
|
|
#include <Resources.h>
|
|
#include <Processes.h>
|
|
#ifdef USE_AEVENT
|
|
# include <AppleEvents.h>
|
|
# include <AERegistry.h>
|
|
#endif
|
|
# include <Gestalt.h>
|
|
#if UNIVERSAL_INTERFACES_VERSION >= 0x0330
|
|
# include <ControlDefinitions.h>
|
|
# include <Navigation.h> /* 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 <MacHelp.h>
|
|
# 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 = (char_u **) alloc(*numFiles * sizeof(char_u *));
|
|
|
|
/* 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 */
|
|
/* 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);
|
|
*/
|
|
|
|
#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 (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);
|
|
}
|
|
}*/
|
|
}
|
|
|
|
/*
|
|
* ------------------------------------------------------------
|
|
* 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 = (UniChar *)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);
|
|
|
|
/* Interpret META, include SHIFT, etc. */
|
|
key_char = extract_modifiers(key_char, (int *)&vimModifiers);
|
|
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 technic return 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 = (char_u **)alloc(count * sizeof(char_u *));
|
|
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. */
|
|
/*
|
|
ATSUAttributeTag fallbackTags[] = { kATSULineFontFallbacksTag };
|
|
ByteCount fallbackSizes[] = { sizeof(ATSUFontFallbacks) };
|
|
ATSUCreateFontFallbacks(&gFontFallbacks);
|
|
ATSUSetObjFontFallbacks(gFontFallbacks, );
|
|
*/
|
|
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 (dragRectControl == kCreateEmpty)
|
|
{
|
|
dragRgn = NULL;
|
|
dragRectControl = kNothing;
|
|
}
|
|
else*/ 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(VimClipboard *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 = lalloc(scrapSize+1, TRUE); */
|
|
HLock(textOfClip);
|
|
error = GetScrapFlavorData(scrap,
|
|
flavor ? VIMSCRAPFLAVOR : SCRAPTEXTFLAVOR,
|
|
&scrapSize, *textOfClip);
|
|
scrapSize -= flavor;
|
|
|
|
if (flavor)
|
|
type = **textOfClip;
|
|
else
|
|
type = MAUTO;
|
|
|
|
tempclip = lalloc(scrapSize + 1, TRUE);
|
|
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(VimClipboard *cbd)
|
|
{
|
|
/*
|
|
* TODO: Really nothing to do?
|
|
*/
|
|
}
|
|
|
|
int
|
|
clip_mch_own_selection(VimClipboard *cbd)
|
|
{
|
|
return OK;
|
|
}
|
|
|
|
/*
|
|
* Send the current selection to the clipboard.
|
|
*/
|
|
void
|
|
clip_mch_set_selection(VimClipboard *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., "<D-S-t>" or "<C-7>"), 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, FALSE, FALSE, FALSE);
|
|
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
|
|
* "<D-C-x>" 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 (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);
|
|
}*/
|
|
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
|
|
}
|
|
|
|
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)
|
|
{
|
|
/* TODO: TODO: TODO: TODO: */
|
|
/* blink_waittime = wait;
|
|
blink_ontime = on;
|
|
blink_offtime = off;*/
|
|
}
|
|
|
|
/*
|
|
* 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);
|
|
/* TODO: TODO: TODO: TODO: */
|
|
/* gui_w32_rm_blink_timer();
|
|
if (blink_state == BLINK_OFF)
|
|
gui_update_cursor(TRUE, FALSE);
|
|
blink_state = BLINK_NONE;*/
|
|
}
|
|
|
|
/*
|
|
* 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 (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);
|
|
}*/
|
|
}
|
|
|
|
/*
|
|
* 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 */
|
|
vim_memset(hotKeys, 0, sizeof(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 <ENTER> and <ESC> 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 <mach-o/dyld.h>
|
|
|
|
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
|