gui_macvim.m

   1 /* vi:set ts=8 sts=4 sw=4 ft=objc:
   2  *
   3  * VIM - Vi IMproved            by Bram Moolenaar
   4  *                              MacVim GUI port by Bjorn Winckler
   5  *
   6  * Do ":help uganda"  in Vim to read copying and usage conditions.
   7  * Do ":help credits" in Vim to see a list of people who contributed.
   8  * See README.txt for an overview of the Vim source code.
   9  */
  10
  11 #import <Foundation/Foundation.h>
  12 #import "MMBackend.h"
  13 #import "MacVim.h"
  14 #import "vim.h"
  15
  16
  17 static BOOL gui_cocoa_is_valid_action(NSString *action);
  18
  19
  20 // -- Initialization --------------------------------------------------------
  21
  22 /*
  23  * Parse the GUI related command-line arguments.  Any arguments used are
  24  * deleted from argv, and *argc is decremented accordingly.  This is called
  25  * when vim is started, whether or not the GUI has been started.
  26  */
  27     void
  28 gui_mch_prepare(int *argc, char **argv)
  29 {
  30     //NSLog(@"gui_mch_prepare(argc=%d)", *argc);
  31
  32     // Set environment variables $VIM and $VIMRUNTIME
  33     // NOTE!  If vim_getenv is called with one of these as parameters before
  34     // they have been set here, they will most likely end up with the wrong
  35     // values!
  36     //
  37     // TODO:
  38     // - ensure this is called first to avoid above problem
  39     // - encoding
  40
  41     NSString *path = [[[NSBundle mainBundle] resourcePath]
  42         stringByAppendingPathComponent:@"vim"];
  43     vim_setenv((char_u*)"VIM", (char_u*)[path UTF8String]);
  44
  45     path = [path stringByAppendingPathComponent:@"runtime"];
  46     vim_setenv((char_u*)"VIMRUNTIME", (char_u*)[path UTF8String]);
  47 }
  48
  49
  50 /*
  51  * Check if the GUI can be started.  Called before gvimrc is sourced.
  52  * Return OK or FAIL.
  53  */
  54     int
  55 gui_mch_init_check(void)
  56 {
  57     //NSLog(@"gui_mch_init_check()");
  58     return OK;
  59 }
  60
  61
  62 /*
  63  * Initialise the GUI.  Create all the windows, set up all the call-backs etc.
  64  * Returns OK for success, FAIL when the GUI can't be started.
  65  */
  66     int
  67 gui_mch_init(void)
  68 {
  69     //NSLog(@"gui_mch_init()");
  70
  71     if (![[MMBackend sharedInstance] checkin])
  72         return FAIL;
  73
  74     // HACK!  Force the 'termencoding to utf-8.  For the moment also force
  75     // 'encoding', although this will change in the future.  The user can still
  76     // change 'encoding'; doing so WILL crash the program.
  77     set_option_value((char_u *)"termencoding", 0L, (char_u *)"utf-8", 0);
  78     set_option_value((char_u *)"encoding", 0L, (char_u *)"utf-8", 0);
  79
  80     // Set values so that pixels and characters are in one-to-one
  81     // correspondence (assuming all characters have the same dimensions).
  82     gui.scrollbar_width = gui.scrollbar_height = 0;
  83
  84     gui.char_height = 1;
  85     gui.char_width = 1;
  86     gui.char_ascent = 0;
  87
  88     gui_mch_def_colors();
  89
  90     [[MMBackend sharedInstance]
  91         setDefaultColorsBackground:gui.back_pixel foreground:gui.norm_pixel];
  92     [[MMBackend sharedInstance] setBackgroundColor:gui.back_pixel];
  93     [[MMBackend sharedInstance] setForegroundColor:gui.norm_pixel];
  94
  95     // NOTE: If this call is left out the cursor is opaque.
  96     highlight_gui_started();
  97
  98     return OK;
  99 }
 100
 101
 102
 103     void
 104 gui_mch_exit(int rc)
 105 {
 106     //NSLog(@"gui_mch_exit(rc=%d)", rc);
 107
 108     [[MMBackend sharedInstance] exit];
 109 }
 110
 111
 112 /*
 113  * Open the GUI window which was created by a call to gui_mch_init().
 114  */
 115     int
 116 gui_mch_open(void)
 117 {
 118     //NSLog(@"gui_mch_open()");
 119
 120     return [[MMBackend sharedInstance] openVimWindow];
 121 }
 122
 123
 124 // -- Updating --------------------------------------------------------------
 125
 126
 127 /*
 128  * Catch up with any queued X events.  This may put keyboard input into the
 129  * input buffer, call resize call-backs, trigger timers etc.  If there is
 130  * nothing in the X event queue (& no timers pending), then we return
 131  * immediately.
 132  */
 133     void
 134 gui_mch_update(void)
 135 {
 136     [[MMBackend sharedInstance] flushQueue:NO];
 137 }
 138
 139
 140 /* Flush any output to the screen */
 141     void
 142 gui_mch_flush(void)
 143 {
 144     [[MMBackend sharedInstance] flushQueue:NO];
 145 }
 146
 147
 148 /*
 149  * GUI input routine called by gui_wait_for_chars().  Waits for a character
 150  * from the keyboard.
 151  *  wtime == -1     Wait forever.
 152  *  wtime == 0      This should never happen.
 153  *  wtime > 0       Wait wtime milliseconds for a character.
 154  * Returns OK if a character was found to be available within the given time,
 155  * or FAIL otherwise.
 156  */
 157     int
 158 gui_mch_wait_for_chars(int wtime)
 159 {
 160     // NOTE! In all likelihood Vim will take a nap when waitForInput: is
 161     // called, so force a flush of the command queue here.
 162     [[MMBackend sharedInstance] flushQueue:YES];
 163
 164     return [[MMBackend sharedInstance] waitForInput:wtime];
 165 }
 166
 167
 168 // -- Drawing ---------------------------------------------------------------
 169
 170
 171 /*
 172  * Clear the whole text window.
 173  */
 174     void
 175 gui_mch_clear_all(void)
 176 {
 177     [[MMBackend sharedInstance] clearAll];
 178 }
 179
 180
 181 /*
 182  * Clear a rectangular region of the screen from text pos (row1, col1) to
 183  * (row2, col2) inclusive.
 184  */
 185     void
 186 gui_mch_clear_block(int row1, int col1, int row2, int col2)
 187 {
 188     [[MMBackend sharedInstance] clearBlockFromRow:row1 column:col1
 189                                                     toRow:row2 column:col2];
 190 }
 191
 192
 193 /*
 194  * Delete the given number of lines from the given row, scrolling up any
 195  * text further down within the scroll region.
 196  */
 197     void
 198 gui_mch_delete_lines(int row, int num_lines)
 199 {
 200     [[MMBackend sharedInstance] deleteLinesFromRow:row count:num_lines
 201             scrollBottom:gui.scroll_region_bot
 202                     left:gui.scroll_region_left
 203                    right:gui.scroll_region_right];
 204 }
 205
 206
 207     void
 208 gui_mch_draw_string(int row, int col, char_u *s, int len, int flags)
 209 {
 210     [[MMBackend sharedInstance] replaceString:(char*)s length:len
 211             row:row column:col flags:flags];
 212 }
 213
 214
 215     int
 216 gui_macvim_draw_string(int row, int col, char_u *s, int len, int flags)
 217 {
 218 #if 0
 219     NSString *string = [[NSString alloc]
 220             initWithBytesNoCopy:(void*)s
 221                          length:len
 222                        encoding:NSUTF8StringEncoding
 223                    freeWhenDone:NO];
 224     int cells = [string length];
 225     [string release];
 226
 227     NSLog(@"gui_macvim_draw_string(row=%d, col=%d, len=%d, cells=%d, flags=%d)",
 228             row, col, len, cells, flags);
 229
 230     [[MMBackend sharedInstance] replaceString:(char*)s length:len
 231             row:row column:col flags:flags];
 232
 233     return cells;
 234 #elif 0
 235     int c;
 236     int cn;
 237     int cl;
 238     int i;
 239     BOOL wide = NO;
 240     int start = 0;
 241     int endcol = col;
 242     int startcol = col;
 243     MMBackend *backend = [MMBackend sharedInstance];
 244
 245     for (i = 0; i < len; i += cl) {
 246         c = utf_ptr2char(s + i);
 247         cl = utf_ptr2len(s + i);
 248         cn = utf_char2cells(c);
 249         comping = utf_iscomposing(c);
 250
 251         if (!comping)
 252             endcol += cn;
 253
 254         if (cn > 1 && !wide) {
 255             // Start of wide characters.
 256             wide = YES;
 257
 258             // Output non-wide characters.
 259             if (start > i) {
 260                 NSLog(@"Outputting %d non-wide chars (%d bytes)",
 261                         endcol-startcol, start-i);
 262                 [backend replaceString:(char*)(s+start) length:start-i
 263                         row:row column:startcol flags:flags];
 264                 startcol = endcol;
 265                 start = i;
 266             }
 267         } else if (cn <= 1 && !comping && wide) {
 268             // End of wide characters.
 269             wide = NO;
 270
 271             // Output wide characters.
 272             if (start > i) {
 273                 NSLog(@"Outputting %d wide chars (%d bytes)",
 274                         endcol-startcol, start-i);
 275                 [backend replaceString:(char*)(s+start) length:start-i
 276                         row:row column:startcol flags:(flags|0x80)];
 277                 startcol = endcol;
 278                 start = i;
 279             }
 280         }
 281     }
 282
 283     // Output remaining characters.
 284     flags = wide ? flags|0x80 : flags;
 285     NSLog(@"Outputting %d %s chars (%d bytes)", endcol-startcol, wide ? "wide"
 286             : "non-wide", len-start);
 287     [backend replaceString:(char*)(s+start) length:len-start
 288             row:row column:startcol flags:flags];
 289
 290     return endcol - col;
 291 #elif 1
 292     //
 293     // Output chars until a wide char found.  If a wide char is found, output a
 294     // zero-width space after it so that a wide char looks like two chars to
 295     // MMTextStorage.  This way 1 char corresponds to 1 column.
 296     //
 297
 298     int c;
 299     int cn;
 300     int cl;
 301     int i;
 302     int start = 0;
 303     int endcol = col;
 304     int startcol = col;
 305     BOOL outPad = NO;
 306     MMBackend *backend = [MMBackend sharedInstance];
 307     static char ZeroWidthSpace[] = { 0xe2, 0x80, 0x8b };
 308 #if MM_ENABLE_CONV
 309     char_u *conv_str = NULL;
 310
 311     if (output_conv.vc_type != CONV_NONE) {
 312         char_u *conv_str = string_convert(&output_conv, s, &len);
 313         if (conv_str)
 314             s = conv_str;
 315     }
 316 #endif
 317
 318     for (i = 0; i < len; i += cl) {
 319         c = utf_ptr2char(s + i);
 320         cl = utf_ptr2len(s + i);
 321         cn = utf_char2cells(c);
 322
 323         if (!utf_iscomposing(c)) {
 324             if (outPad) {
 325                 outPad = NO;
 326 #if 0
 327                 NSString *string = [[NSString alloc]
 328                         initWithBytesNoCopy:(void*)(s+start)
 329                                      length:i-start
 330                                    encoding:NSUTF8StringEncoding
 331                                freeWhenDone:NO];
 332                 NSLog(@"Flushing string=%@ len=%d row=%d col=%d end=%d",
 333                         string, i-start, row, startcol, endcol);
 334                 [string release];
 335 #endif
 336                 [backend replaceString:(char*)(s+start) length:i-start
 337                         row:row column:startcol flags:flags];
 338                 start = i;
 339                 startcol = endcol;
 340 #if 0
 341                 NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace),
 342                         row, endcol-1);
 343 #endif
 344                 [backend replaceString:ZeroWidthSpace
 345                              length:sizeof(ZeroWidthSpace)
 346                         row:row column:endcol-1 flags:flags];
 347             }
 348
 349             endcol += cn;
 350         }
 351
 352         if (cn > 1) {
 353 #if 0
 354             NSLog(@"Wide char detected! (char=%C hex=%x cells=%d)", c, c, cn);
 355 #endif
 356             outPad = YES;
 357         }
 358     }
 359
 360 #if 0
 361     if (row < 1) {
 362         NSString *string = [[NSString alloc]
 363                 initWithBytesNoCopy:(void*)(s+start)
 364                              length:len-start
 365                            encoding:NSUTF8StringEncoding
 366                        freeWhenDone:NO];
 367         NSLog(@"Output string=%@ len=%d row=%d col=%d", string, len-start, row,
 368                 startcol);
 369         [string release];
 370     }
 371 #endif
 372
 373     // Output remaining characters.
 374     [backend replaceString:(char*)(s+start) length:len-start
 375             row:row column:startcol flags:flags];
 376
 377     if (outPad) {
 378 #if 0
 379         NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace), row,
 380                 endcol-1);
 381 #endif
 382         [backend replaceString:ZeroWidthSpace
 383                      length:sizeof(ZeroWidthSpace)
 384                 row:row column:endcol-1 flags:flags];
 385     }
 386
 387 #if MM_ENABLE_CONV
 388     if (conv_str)
 389         vim_free(conv_str);
 390 #endif
 391
 392     return endcol - col;
 393 #else
 394     // This will fail abysmally when wide or composing characters are used.
 395     [[MMBackend sharedInstance]
 396             replaceString:(char*)s length:len row:row column:col flags:flags];
 397
 398     int i, c, cl, cn, cells = 0;
 399     for (i = 0; i < len; i += cl) {
 400         c = utf_ptr2char(s + i);
 401         cl = utf_ptr2len(s + i);
 402         cn = utf_char2cells(c);
 403
 404         if (!utf_iscomposing(c))
 405             cells += cn;
 406     }
 407
 408     return cells;
 409 #endif
 410 }
 411
 412
 413 /*
 414  * Insert the given number of lines before the given row, scrolling down any
 415  * following text within the scroll region.
 416  */
 417     void
 418 gui_mch_insert_lines(int row, int num_lines)
 419 {
 420     [[MMBackend sharedInstance] insertLinesFromRow:row count:num_lines
 421             scrollBottom:gui.scroll_region_bot
 422                     left:gui.scroll_region_left
 423                    right:gui.scroll_region_right];
 424 }
 425
 426
 427 // -- Tab line --------------------------------------------------------------
 428
 429
 430 /*
 431  * Set the current tab to "nr".  First tab is 1.
 432  */
 433     void
 434 gui_mch_set_curtab(int nr)
 435 {
 436     //NSLog(@"gui_mch_set_curtab(nr=%d)", nr);
 437     [[MMBackend sharedInstance] selectTab:nr];
 438 }
 439
 440
 441 /*
 442  * Return TRUE when tabline is displayed.
 443  */
 444     int
 445 gui_mch_showing_tabline(void)
 446 {
 447     //NSLog(@"gui_mch_showing_tabline()");
 448     return [[MMBackend sharedInstance] tabBarVisible];
 449 }
 450
 451 /*
 452  * Update the labels of the tabline.
 453  */
 454     void
 455 gui_mch_update_tabline(void)
 456 {
 457     //NSLog(@"gui_mch_update_tabline()");
 458     [[MMBackend sharedInstance] updateTabBar];
 459 }
 460
 461 /*
 462  * Show or hide the tabline.
 463  */
 464     void
 465 gui_mch_show_tabline(int showit)
 466 {
 467     //NSLog(@"gui_mch_show_tabline(showit=%d)", showit);
 468     [[MMBackend sharedInstance] showTabBar:showit];
 469 }
 470
 471
 472 // -- Clipboard -------------------------------------------------------------
 473
 474
 475     void
 476 clip_mch_lose_selection(VimClipboard *cbd)
 477 {
 478 }
 479
 480
 481     int
 482 clip_mch_own_selection(VimClipboard *cbd)
 483 {
 484     return 0;
 485 }
 486
 487
 488     void
 489 clip_mch_request_selection(VimClipboard *cbd)
 490 {
 491     NSPasteboard *pb = [NSPasteboard generalPasteboard];
 492     NSString *pbType = [pb availableTypeFromArray:
 493             [NSArray arrayWithObject:NSStringPboardType]];
 494     if (pbType) {
 495         NSMutableString *string =
 496                 [[pb stringForType:NSStringPboardType] mutableCopy];
 497
 498         // Replace unrecognized end-of-line sequences with \x0a (line feed).
 499         NSRange range = { 0, [string length] };
 500         unsigned n = [string replaceOccurrencesOfString:@"\x0d\x0a"
 501                                              withString:@"\x0a" options:0
 502                                                   range:range];
 503         if (0 == n) {
 504             n = [string replaceOccurrencesOfString:@"\x0d" withString:@"\x0a"
 505                                            options:0 range:range];
 506         }
 507
 508         // Scan for newline character to decide whether the string should be
 509         // pasted linewise or characterwise.
 510         int type = MCHAR;
 511         if (0 < n || NSNotFound != [string rangeOfString:@"\n"].location)
 512             type = MLINE;
 513
 514         char_u *str = (char_u*)[string UTF8String];
 515         int len = [string lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 516
 517 #if MM_ENABLE_CONV
 518         if (input_conv.vc_type != CONV_NONE) {
 519             NSLog(@"Converting from: '%@'", string);
 520             char_u *conv_str = string_convert(&input_conv, str, &len);
 521             if (conv_str) {
 522                 NSLog(@"           to: '%s'", conv_str);
 523                 clip_yank_selection(type, conv_str, len, cbd);
 524                 vim_free(conv_str);
 525                 return;
 526             }
 527         }
 528 #endif
 529
 530         clip_yank_selection(type, str, len, cbd);
 531     }
 532 }
 533
 534
 535 /*
 536  * Send the current selection to the clipboard.
 537  */
 538     void
 539 clip_mch_set_selection(VimClipboard *cbd)
 540 {
 541     // If the '*' register isn't already filled in, fill it in now.
 542     cbd->owned = TRUE;
 543     clip_get_selection(cbd);
 544     cbd->owned = FALSE;
 545
 546     // Get the text to put on the pasteboard.
 547     long_u llen = 0; char_u *str = 0;
 548     int type = clip_convert_selection(&str, &llen, cbd);
 549     if (type < 0)
 550         return;
 551
 552     // TODO: Avoid overflow.
 553     int len = (int)llen;
 554 #if MM_ENABLE_CONV
 555     if (output_conv.vc_type != CONV_NONE) {
 556         char_u *conv_str = string_convert(&output_conv, str, &len);
 557         if (conv_str) {
 558             vim_free(str);
 559             str = conv_str;
 560         }
 561     }
 562 #endif
 563
 564     if (len > 0) {
 565         NSString *string = [[NSString alloc]
 566             initWithBytes:str length:len encoding:NSUTF8StringEncoding];
 567
 568         NSPasteboard *pb = [NSPasteboard generalPasteboard];
 569         [pb declareTypes:[NSArray arrayWithObject:NSStringPboardType]
 570                    owner:nil];
 571         [pb setString:string forType:NSStringPboardType];
 572
 573         [string release];
 574     }
 575
 576     vim_free(str);
 577 }
 578
 579
 580 // -- Menu ------------------------------------------------------------------
 581
 582
 583 /*
 584  * Add a sub menu to the menu bar.
 585  */
 586     void
 587 gui_mch_add_menu(vimmenu_T *menu, int idx)
 588 {
 589     //NSLog(@"gui_mch_add_menu(name=%s, idx=%d)", menu->name, idx);
 590
 591     // HACK!  If menu has no parent, then we set the parent tag to the type of
 592     // menu it is.  This will not mix up tag and type because pointers can not
 593     // take values close to zero (and the tag is simply the value of the
 594     // pointer).
 595     int parent = (int)menu->parent;
 596     if (!parent) {
 597         parent = menu_is_popup(menu->name) ? MenuPopupType :
 598                  menu_is_toolbar(menu->name) ? MenuToolbarType :
 599                  MenuMenubarType;
 600     }
 601
 602     [[MMBackend sharedInstance]
 603             addMenuWithTag:(int)menu parent:parent name:(char*)menu->dname
 604                    atIndex:idx];
 605 }
 606
 607
 608 /*
 609  * Add a menu item to a menu
 610  */
 611     void
 612 gui_mch_add_menu_item(vimmenu_T *menu, int idx)
 613 {
 614     //NSLog(@"gui_mch_add_menu_item(name=%s, accel=%s idx=%d)", menu->dname,
 615     //        menu->actext, idx);
 616
 617     // NOTE!  If 'iconfile' is not set but 'iconidx' is, use the name of the
 618     // menu item.  (Should correspond to a stock item.)
 619     char *icon = menu->iconfile ? (char*)menu->iconfile :
 620                  menu->iconidx >= 0 ? (char*)menu->dname :
 621                  NULL;
 622     //char *name = menu_is_separator(menu->name) ? NULL : (char*)menu->dname;
 623     char *name = (char*)menu->dname;
 624     char *tip = menu->strings[MENU_INDEX_TIP]
 625             ? (char*)menu->strings[MENU_INDEX_TIP] : (char*)menu->actext;
 626
 627     // HACK!  Check if menu is mapped to ':action actionName:'; if so, pass the
 628     // action along so that MacVim can bind the menu item to this action.  This
 629     // means that if a menu item maps to an action in normal mode, then all
 630     // other modes will also use the same action.
 631     NSString *action = nil;
 632     char_u *map_str = menu->strings[MENU_INDEX_NORMAL];
 633     if (map_str) {
 634         NSString *mapping = [NSString stringWithCString:(char*)map_str
 635                                                encoding:NSUTF8StringEncoding];
 636         NSArray *parts = [mapping componentsSeparatedByString:@" "];
 637         if ([parts count] >=2
 638                 && [[parts objectAtIndex:0] isEqual:@":action"]) {
 639             action = [parts objectAtIndex:1];
 640             action = [action stringByTrimmingCharactersInSet:
 641                     [NSCharacterSet whitespaceAndNewlineCharacterSet]];
 642             if (!gui_cocoa_is_valid_action(action))
 643                 action = nil;
 644         }
 645     }
 646
 647     [[MMBackend sharedInstance]
 648             addMenuItemWithTag:(int)menu
 649                         parent:(int)menu->parent
 650                           name:name
 651                            tip:tip
 652                           icon:(char*)icon
 653                  keyEquivalent:menu->ke_key
 654                      modifiers:menu->ke_mods
 655                         action:action
 656                        atIndex:idx];
 657 }
 658
 659
 660 /*
 661  * Destroy the machine specific menu widget.
 662  */
 663     void
 664 gui_mch_destroy_menu(vimmenu_T *menu)
 665 {
 666     //NSLog(@"gui_mch_destroy_menu(name=%s)", menu->name);
 667
 668     [[MMBackend sharedInstance] removeMenuItemWithTag:(int)menu];
 669 }
 670
 671
 672 /*
 673  * Make a menu either grey or not grey.
 674  */
 675     void
 676 gui_mch_menu_grey(vimmenu_T *menu, int grey)
 677 {
 678     //NSLog(@"gui_mch_menu_grey(name=%s, grey=%d)", menu->name, grey);
 679     [[MMBackend sharedInstance]
 680             enableMenuItemWithTag:(int)menu state:!grey];
 681 }
 682
 683
 684 /*
 685  * Make menu item hidden or not hidden
 686  */
 687     void
 688 gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
 689 {
 690     //NSLog(@"gui_mch_menu_hidden(name=%s, hidden=%d)", menu->name, hidden);
 691
 692     // HACK! There is no (obvious) way to hide a menu item, so simply
 693     // enable/disable it instead.
 694     [[MMBackend sharedInstance]
 695             enableMenuItemWithTag:(int)menu state:!hidden];
 696 }
 697
 698
 699 /*
 700  * This is called when user right clicks.
 701  */
 702     void
 703 gui_mch_show_popupmenu(vimmenu_T *menu)
 704 {
 705     //NSLog(@"gui_mch_show_popupmenu(name=%s)", menu->name);
 706
 707     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)menu->name
 708                                       atMouseLocation:YES];
 709 }
 710
 711
 712 /*
 713  * This is called when a :popup command is executed.
 714  */
 715     void
 716 gui_make_popup(char_u *path_name, int mouse_pos)
 717 {
 718     // TODO: Unless mouse_pos set, popup at cursor location.
 719     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)path_name
 720                                       atMouseLocation:mouse_pos];
 721 }
 722
 723
 724 /*
 725  * This is called after setting all the menus to grey/hidden or not.
 726  */
 727     void
 728 gui_mch_draw_menubar(void)
 729 {
 730     // The (main) menu draws itself in Mac OS X.
 731 }
 732
 733
 734     void
 735 gui_mch_enable_menu(int flag)
 736 {
 737     // The (main) menu is always enabled in Mac OS X.
 738 }
 739
 740
 741 #if 0
 742     void
 743 gui_mch_set_menu_pos(int x, int y, int w, int h)
 744 {
 745     // The (main) menu cannot be moved in Mac OS X.
 746 }
 747 #endif
 748
 749
 750     void
 751 gui_mch_show_toolbar(int showit)
 752 {
 753     int flags = 0;
 754     if (toolbar_flags & TOOLBAR_TEXT) flags |= ToolbarLabelFlag;
 755     if (toolbar_flags & TOOLBAR_ICONS) flags |= ToolbarIconFlag;
 756     if (tbis_flags & (TBIS_MEDIUM|TBIS_LARGE)) flags |= ToolbarSizeRegularFlag;
 757
 758     //NSLog(@"gui_mch_show_toolbar(showit=%d, flags=%d)", showit, flags);
 759
 760     [[MMBackend sharedInstance] showToolbar:showit flags:flags];
 761 }
 762
 763
 764
 765
 766 // -- Fonts -----------------------------------------------------------------
 767
 768
 769 /*
 770  * If a font is not going to be used, free its structure.
 771  */
 772     void
 773 gui_mch_free_font(font)
 774     GuiFont     font;
 775 {
 776 }
 777
 778
 779 /*
 780  * Get a font structure for highlighting.
 781  */
 782     GuiFont
 783 gui_mch_get_font(char_u *name, int giveErrorIfMissing)
 784 {
 785     //NSLog(@"gui_mch_get_font(name=%s, giveErrorIfMissing=%d)", name,
 786     //        giveErrorIfMissing);
 787     return 0;
 788 }
 789
 790
 791 #if defined(FEAT_EVAL) || defined(PROTO)
 792 /*
 793  * Return the name of font "font" in allocated memory.
 794  * Don't know how to get the actual name, thus use the provided name.
 795  */
 796     char_u *
 797 gui_mch_get_fontname(GuiFont font, char_u *name)
 798 {
 799     //NSLog(@"gui_mch_get_fontname(font=%d, name=%s)", font, name);
 800     return 0;
 801 }
 802 #endif
 803
 804
 805 /*
 806  * Initialise vim to use the font with the given name.  Return FAIL if the font
 807  * could not be loaded, OK otherwise.
 808  */
 809     int
 810 gui_mch_init_font(char_u *font_name, int fontset)
 811 {
 812     //NSLog(@"gui_mch_init_font(font_name=%s, fontset=%d)", font_name, fontset);
 813
 814     // HACK!  This gets called whenever the user types :set gfn=fontname, so
 815     // for now we set the font here.
 816     // TODO!  Proper font handling, the way Vim expects it.
 817     return [[MMBackend sharedInstance]
 818             setFontWithName:(char*)font_name];
 819 }
 820
 821
 822 /*
 823  * Set the current text font.
 824  */
 825     void
 826 gui_mch_set_font(GuiFont font)
 827 {
 828 }
 829
 830
 831
 832
 833 // -- Scrollbars ------------------------------------------------------------
 834
 835
 836     void
 837 gui_mch_create_scrollbar(
 838         scrollbar_T *sb,
 839         int orient)     /* SBAR_VERT or SBAR_HORIZ */
 840 {
 841     //NSLog(@"gui_mch_create_scrollbar(id=%d, orient=%d, type=%d)",
 842     //        sb->ident, orient, sb->type);
 843
 844     [[MMBackend sharedInstance]
 845             createScrollbarWithIdentifier:sb->ident type:sb->type];
 846 }
 847
 848
 849     void
 850 gui_mch_destroy_scrollbar(scrollbar_T *sb)
 851 {
 852     //NSLog(@"gui_mch_destroy_scrollbar(id=%d)", sb->ident);
 853
 854     [[MMBackend sharedInstance]
 855             destroyScrollbarWithIdentifier:sb->ident];
 856 }
 857
 858
 859     void
 860 gui_mch_enable_scrollbar(
 861         scrollbar_T     *sb,
 862         int             flag)
 863 {
 864     //NSLog(@"gui_mch_enable_scrollbar(id=%d, flag=%d)", sb->ident, flag);
 865
 866     [[MMBackend sharedInstance]
 867             showScrollbarWithIdentifier:sb->ident state:flag];
 868 }
 869
 870
 871     void
 872 gui_mch_set_scrollbar_pos(
 873         scrollbar_T *sb,
 874         int x,
 875         int y,
 876         int w,
 877         int h)
 878 {
 879     //NSLog(@"gui_mch_set_scrollbar_pos(id=%d, x=%d, y=%d, w=%d, h=%d)",
 880     //        sb->ident, x, y, w, h);
 881
 882     int pos = y;
 883     int len = h;
 884     if (SBAR_BOTTOM == sb->type) {
 885         pos = x;
 886         len = w;
 887     }
 888
 889     [[MMBackend sharedInstance]
 890             setScrollbarPosition:pos length:len identifier:sb->ident];
 891 }
 892
 893
 894     void
 895 gui_mch_set_scrollbar_thumb(
 896         scrollbar_T *sb,
 897         long val,
 898         long size,
 899         long max)
 900 {
 901     //NSLog(@"gui_mch_set_scrollbar_thumb(id=%d, val=%d, size=%d, max=%d)",
 902     //        sb->ident, val, size, max);
 903
 904     [[MMBackend sharedInstance]
 905             setScrollbarThumbValue:val size:size max:max identifier:sb->ident];
 906 }
 907
 908
 909
 910
 911
 912 // -- Unsorted --------------------------------------------------------------
 913
 914
 915     void
 916 ex_action(eap)
 917     exarg_T     *eap;
 918 {
 919     if (!gui.in_use) {
 920         EMSG(_("E???: Command only available in GUI mode"));
 921         return;
 922     }
 923
 924     NSString *name = [NSString stringWithCString:(char*)eap->arg
 925                                         encoding:NSUTF8StringEncoding];
 926     if (gui_cocoa_is_valid_action(name)) {
 927         [[MMBackend sharedInstance] executeActionWithName:name];
 928     } else {
 929         EMSG2(_("E???: \"%s\" is not a valid action"), eap->arg);
 930     }
 931 }
 932
 933
 934 /*
 935  * Adjust gui.char_height (after 'linespace' was changed).
 936  */
 937     int
 938 gui_mch_adjust_charheight(void)
 939 {
 940     return 0;
 941 }
 942
 943
 944     void
 945 gui_mch_beep(void)
 946 {
 947 }
 948
 949
 950
 951 #ifdef FEAT_BROWSE
 952 /*
 953  * Pop open a file browser and return the file selected, in allocated memory,
 954  * or NULL if Cancel is hit.
 955  *  saving  - TRUE if the file will be saved to, FALSE if it will be opened.
 956  *  title   - Title message for the file browser dialog.
 957  *  dflt    - Default name of file.
 958  *  ext     - Default extension to be added to files without extensions.
 959  *  initdir - directory in which to open the browser (NULL = current dir)
 960  *  filter  - Filter for matched files to choose from.
 961  *  Has a format like this:
 962  *  "C Files (*.c)\0*.c\0"
 963  *  "All Files\0*.*\0\0"
 964  *  If these two strings were concatenated, then a choice of two file
 965  *  filters will be selectable to the user.  Then only matching files will
 966  *  be shown in the browser.  If NULL, the default allows all files.
 967  *
 968  *  *NOTE* - the filter string must be terminated with TWO nulls.
 969  */
 970     char_u *
 971 gui_mch_browse(
 972     int saving,
 973     char_u *title,
 974     char_u *dflt,
 975     char_u *ext,
 976     char_u *initdir,
 977     char_u *filter)
 978 {
 979     //NSLog(@"gui_mch_browse(saving=%d, title=%s, dflt=%s, ext=%s, initdir=%s,"
 980     //        " filter=%s", saving, title, dflt, ext, initdir, filter);
 981
 982     char_u *s = (char_u*)[[MMBackend sharedInstance]
 983             browseForFileInDirectory:(char*)initdir title:(char*)title
 984                               saving:saving];
 985
 986     return s;
 987 }
 988 #endif /* FEAT_BROWSE */
 989
 990
 991
 992     int
 993 gui_mch_dialog(
 994     int         type,
 995     char_u      *title,
 996     char_u      *message,
 997     char_u      *buttons,
 998     int         dfltbutton,
 999     char_u      *textfield)
1000 {
1001     //NSLog(@"gui_mch_dialog(type=%d title=%s message=%s buttons=%s "
1002     //        "dfltbutton=%d textfield=%s)", type, title, message, buttons,
1003     //        dfltbutton, textfield);
1004
1005     return [[MMBackend sharedInstance] presentDialogWithType:type
1006                                                        title:(char*)title
1007                                                      message:(char*)message
1008                                                      buttons:(char*)buttons
1009                                                    textField:(char*)textfield];
1010 }
1011
1012
1013 /*
1014  * Draw a cursor without focus.
1015  */
1016     void
1017 gui_mch_draw_hollow_cursor(guicolor_T color)
1018 {
1019 }
1020
1021
1022 /*
1023  * Draw part of a cursor, only w pixels wide, and h pixels high.
1024  */
1025     void
1026 gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
1027 {
1028 }
1029
1030
1031     void
1032 gui_mch_flash(int msec)
1033 {
1034 }
1035
1036
1037 /*
1038  * Return the Pixel value (color) for the given color name.  This routine was
1039  * pretty much taken from example code in the Silicon Graphics OSF/Motif
1040  * Programmer's Guide.
1041  * Return INVALCOLOR when failed.
1042  */
1043     guicolor_T
1044 gui_mch_get_color(char_u *name)
1045 {
1046     NSString *key = [NSString stringWithUTF8String:(char*)name];
1047     return [[MMBackend sharedInstance] lookupColorWithKey:key];
1048 }
1049
1050
1051 /*
1052  * Return the RGB value of a pixel as long.
1053  */
1054     long_u
1055 gui_mch_get_rgb(guicolor_T pixel)
1056 {
1057     // This is only implemented so that vim can guess the correct value for
1058     // 'background' (which otherwise defaults to 'dark'); it is not used for
1059     // anything else (as far as I know).
1060     // The implementation is simple since colors are stored in an int as
1061     // "rrggbb".
1062     return pixel;
1063 }
1064
1065
1066 /*
1067  * Get the screen dimensions.
1068  * Allow 10 pixels for horizontal borders, 40 for vertical borders.
1069  * Is there no way to find out how wide the borders really are?
1070  * TODO: Add live udate of those value on suspend/resume.
1071  */
1072     void
1073 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
1074 {
1075     //NSLog(@"gui_mch_get_screen_dimensions()");
1076     *screen_w = Columns;
1077     *screen_h = Rows;
1078 }
1079
1080
1081 /*
1082  * Get the position of the top left corner of the window.
1083  */
1084     int
1085 gui_mch_get_winpos(int *x, int *y)
1086 {
1087     *x = *y = 0;
1088     return OK;
1089 }
1090
1091
1092 /*
1093  * Get current mouse coordinates in text window.
1094  */
1095     void
1096 gui_mch_getmouse(int *x, int *y)
1097 {
1098 }
1099
1100
1101 /*
1102  * Return OK if the key with the termcap name "name" is supported.
1103  */
1104     int
1105 gui_mch_haskey(char_u *name)
1106 {
1107     NSLog(@"gui_mch_haskey(name=%s)", name);
1108     return 0;
1109 }
1110
1111
1112 /*
1113  * Iconify the GUI window.
1114  */
1115     void
1116 gui_mch_iconify(void)
1117 {
1118 }
1119
1120
1121 /*
1122  * Invert a rectangle from row r, column c, for nr rows and nc columns.
1123  */
1124     void
1125 gui_mch_invert_rectangle(int r, int c, int nr, int nc)
1126 {
1127 }
1128
1129
1130 /*
1131  * Called when the foreground or background color has been changed.
1132  */
1133     void
1134 gui_mch_new_colors(void)
1135 {
1136     gui.def_back_pixel = gui.back_pixel;
1137     gui.def_norm_pixel = gui.norm_pixel;
1138
1139     //NSLog(@"gui_mch_new_colors(back=%x, norm=%x)", gui.def_back_pixel,
1140     //        gui.def_norm_pixel);
1141
1142     [[MMBackend sharedInstance]
1143         setDefaultColorsBackground:gui.def_back_pixel
1144                         foreground:gui.def_norm_pixel];
1145 }
1146
1147
1148     void
1149 gui_mch_def_colors()
1150 {
1151     // Default foreground and background colors are black and white.
1152     gui.def_norm_pixel = gui.norm_pixel = 0;
1153     gui.def_back_pixel = gui.back_pixel = 0xffffff;
1154 }
1155
1156
1157 /*
1158  * Set the current text background color.
1159  */
1160     void
1161 gui_mch_set_bg_color(guicolor_T color)
1162 {
1163     [[MMBackend sharedInstance] setBackgroundColor:color];
1164 }
1165
1166
1167 /*
1168  * Cursor blink functions.
1169  *
1170  * This is a simple state machine:
1171  * BLINK_NONE   not blinking at all
1172  * BLINK_OFF    blinking, cursor is not shown
1173  * BLINK_ON blinking, cursor is shown
1174  */
1175     void
1176 gui_mch_set_blinking(long wait, long on, long off)
1177 {
1178 }
1179
1180
1181 /*
1182  * Set the current text foreground color.
1183  */
1184     void
1185 gui_mch_set_fg_color(guicolor_T color)
1186 {
1187     [[MMBackend sharedInstance] setForegroundColor:color];
1188 }
1189
1190
1191 #if defined(FEAT_EVAL) || defined(PROTO)
1192 /*
1193  * Bring the Vim window to the foreground.
1194  */
1195     void
1196 gui_mch_set_foreground(void)
1197 {
1198 }
1199 #endif
1200
1201
1202
1203     void
1204 gui_mch_set_shellsize(
1205     int         width,
1206     int         height,
1207     int         min_width,
1208     int         min_height,
1209     int         base_width,
1210     int         base_height,
1211     int         direction)
1212 {
1213     //NSLog(@"gui_mch_set_shellsize(width=%d, height=%d, min_width=%d,"
1214     //        " min_height=%d, base_width=%d, base_height=%d, direction=%d)",
1215     //        width, height, min_width, min_height, base_width, base_height,
1216     //        direction);
1217     [[MMBackend sharedInstance] setRows:height columns:width];
1218 }
1219
1220
1221 /*
1222  * Set the current text special color.
1223  */
1224     void
1225 gui_mch_set_sp_color(guicolor_T color)
1226 {
1227 }
1228
1229
1230     void
1231 gui_mch_set_text_area_pos(int x, int y, int w, int h)
1232 {
1233 }
1234
1235 /*
1236  * Set the position of the top left corner of the window to the given
1237  * coordinates.
1238  */
1239     void
1240 gui_mch_set_winpos(int x, int y)
1241 {
1242 }
1243
1244
1245     void
1246 gui_mch_setmouse(int x, int y)
1247 {
1248 }
1249
1250
1251 #ifdef FEAT_TITLE
1252 /*
1253  * Set the window title and icon.
1254  * (The icon is not taken care of).
1255  */
1256     void
1257 gui_mch_settitle(char_u *title, char_u *icon)
1258 {
1259     //NSLog(@"gui_mch_settitle(title=%s, icon=%s)", title, icon);
1260
1261     [[MMBackend sharedInstance] setVimWindowTitle:(char*)title];
1262 }
1263 #endif
1264
1265
1266 /*
1267  * Start the cursor blinking.  If it was already blinking, this restarts the
1268  * waiting time and shows the cursor.
1269  */
1270     void
1271 gui_mch_start_blink(void)
1272 {
1273 }
1274
1275
1276 /*
1277  * Stop the cursor blinking.  Show the cursor if it wasn't shown.
1278  */
1279     void
1280 gui_mch_stop_blink(void)
1281 {
1282 }
1283
1284
1285     void
1286 gui_mch_toggle_tearoffs(int enable)
1287 {
1288 }
1289
1290
1291     void
1292 mch_set_mouse_shape(int shape)
1293 {
1294 }
1295
1296
1297     static BOOL
1298 gui_cocoa_is_valid_action(NSString *action)
1299 {
1300     static NSDictionary *actionDict = nil;
1301
1302     if (!actionDict) {
1303         NSBundle *mainBundle = [NSBundle mainBundle];
1304         NSString *path = [mainBundle pathForResource:@"Actions"
1305                                               ofType:@"plist"];
1306         if (path) {
1307             actionDict = [[NSDictionary alloc] initWithContentsOfFile:path];
1308         } else {
1309             // Allocate bogus dictionary so that error only pops up once.
1310             actionDict = [NSDictionary new];
1311             EMSG(_("E???: Failed to load action dictionary"));
1312         }
1313     }
1314
1315     return [actionDict objectForKey:action] != nil;
1316 }