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 likelyhood 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
 309     for (i = 0; i < len; i += cl) {
 310         c = utf_ptr2char(s + i);
 311         cl = utf_ptr2len(s + i);
 312         cn = utf_char2cells(c);
 313
 314         if (!utf_iscomposing(c)) {
 315             if (outPad) {
 316                 outPad = NO;
 317 #if 0
 318                 NSString *string = [[NSString alloc]
 319                         initWithBytesNoCopy:(void*)(s+start)
 320                                      length:i-start
 321                                    encoding:NSUTF8StringEncoding
 322                                freeWhenDone:NO];
 323                 NSLog(@"Flushing string=%@ len=%d row=%d col=%d end=%d",
 324                         string, i-start, row, startcol, endcol);
 325                 [string release];
 326 #endif
 327                 [backend replaceString:(char*)(s+start) length:i-start
 328                         row:row column:startcol flags:flags];
 329                 start = i;
 330                 startcol = endcol;
 331 #if 0
 332                 NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace),
 333                         row, endcol-1);
 334 #endif
 335                 [backend replaceString:ZeroWidthSpace
 336                              length:sizeof(ZeroWidthSpace)
 337                         row:row column:endcol-1 flags:flags];
 338             }
 339
 340             endcol += cn;
 341         }
 342
 343         if (cn > 1) {
 344 #if 0
 345             NSLog(@"Wide char detected! (char=%C hex=%x cells=%d)", c, c, cn);
 346 #endif
 347             outPad = YES;
 348         }
 349     }
 350
 351 #if 0
 352     if (row < 1) {
 353         NSString *string = [[NSString alloc]
 354                 initWithBytesNoCopy:(void*)(s+start)
 355                              length:len-start
 356                            encoding:NSUTF8StringEncoding
 357                        freeWhenDone:NO];
 358         NSLog(@"Output string=%@ len=%d row=%d col=%d", string, len-start, row,
 359                 startcol);
 360         [string release];
 361     }
 362 #endif
 363
 364     // Output remaining characters.
 365     [backend replaceString:(char*)(s+start) length:len-start
 366             row:row column:startcol flags:flags];
 367
 368     if (outPad) {
 369 #if 0
 370         NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace), row,
 371                 endcol-1);
 372 #endif
 373         [backend replaceString:ZeroWidthSpace
 374                      length:sizeof(ZeroWidthSpace)
 375                 row:row column:endcol-1 flags:flags];
 376     }
 377
 378     return endcol - col;
 379 #else
 380     // This will fail abysmally when wide or composing characters are used.
 381     [[MMBackend sharedInstance]
 382             replaceString:(char*)s length:len row:row column:col flags:flags];
 383
 384     int i, c, cl, cn, cells = 0;
 385     for (i = 0; i < len; i += cl) {
 386         c = utf_ptr2char(s + i);
 387         cl = utf_ptr2len(s + i);
 388         cn = utf_char2cells(c);
 389
 390         if (!utf_iscomposing(c))
 391             cells += cn;
 392     }
 393
 394     return cells;
 395 #endif
 396 }
 397
 398
 399 /*
 400  * Insert the given number of lines before the given row, scrolling down any
 401  * following text within the scroll region.
 402  */
 403     void
 404 gui_mch_insert_lines(int row, int num_lines)
 405 {
 406     [[MMBackend sharedInstance] insertLinesFromRow:row count:num_lines
 407             scrollBottom:gui.scroll_region_bot
 408                     left:gui.scroll_region_left
 409                    right:gui.scroll_region_right];
 410 }
 411
 412
 413 // -- Tab line --------------------------------------------------------------
 414
 415
 416 /*
 417  * Set the current tab to "nr".  First tab is 1.
 418  */
 419     void
 420 gui_mch_set_curtab(int nr)
 421 {
 422     //NSLog(@"gui_mch_set_curtab(nr=%d)", nr);
 423     [[MMBackend sharedInstance] selectTab:nr];
 424 }
 425
 426
 427 /*
 428  * Return TRUE when tabline is displayed.
 429  */
 430     int
 431 gui_mch_showing_tabline(void)
 432 {
 433     //NSLog(@"gui_mch_showing_tabline()");
 434     return [[MMBackend sharedInstance] tabBarVisible];
 435 }
 436
 437 /*
 438  * Update the labels of the tabline.
 439  */
 440     void
 441 gui_mch_update_tabline(void)
 442 {
 443     //NSLog(@"gui_mch_update_tabline()");
 444     [[MMBackend sharedInstance] updateTabBar];
 445 }
 446
 447 /*
 448  * Show or hide the tabline.
 449  */
 450     void
 451 gui_mch_show_tabline(int showit)
 452 {
 453     //NSLog(@"gui_mch_show_tabline(showit=%d)", showit);
 454     [[MMBackend sharedInstance] showTabBar:showit];
 455 }
 456
 457
 458 // -- Clipboard -------------------------------------------------------------
 459
 460
 461     void
 462 clip_mch_lose_selection(VimClipboard *cbd)
 463 {
 464 }
 465
 466
 467     int
 468 clip_mch_own_selection(VimClipboard *cbd)
 469 {
 470     return 0;
 471 }
 472
 473
 474     void
 475 clip_mch_request_selection(VimClipboard *cbd)
 476 {
 477     NSPasteboard *pb = [NSPasteboard generalPasteboard];
 478     NSString *type = [pb availableTypeFromArray:
 479             [NSArray arrayWithObject:NSStringPboardType]];
 480     if (type) {
 481         NSMutableString *string =
 482                 [[pb stringForType:NSStringPboardType] mutableCopy];
 483
 484         // Replace unrecognized end-of-line sequences with \x0a (line feed).
 485         NSRange range = { 0, [string length] };
 486         unsigned n = [string replaceOccurrencesOfString:@"\x0d\x0a"
 487                                              withString:@"\x0a" options:0
 488                                                   range:range];
 489         if (0 == n) {
 490             n = [string replaceOccurrencesOfString:@"\x0d" withString:@"\x0a"
 491                                            options:0 range:range];
 492         }
 493
 494         // Scan for newline character to decide whether the string should be
 495         // pasted linewise or characterwise.
 496         int type = MCHAR;
 497         if (0 < n || NSNotFound != [string rangeOfString:@"\n"].location)
 498             type = MLINE;
 499
 500         const char *utf8chars = [string UTF8String];
 501         clip_yank_selection(type, (char_u*)utf8chars, strlen(utf8chars), cbd);
 502     }
 503 }
 504
 505
 506 /*
 507  * Send the current selection to the clipboard.
 508  */
 509     void
 510 clip_mch_set_selection(VimClipboard *cbd)
 511 {
 512     // If the '*' register isn't already filled in, fill it in now.
 513     cbd->owned = TRUE;
 514     clip_get_selection(cbd);
 515     cbd->owned = FALSE;
 516
 517     // Get the text to put on the pasteboard.
 518     long_u len = 0; char_u *str = 0;
 519     int type = clip_convert_selection(&str, &len, cbd);
 520     if (type < 0)
 521         return;
 522
 523     NSString *string = [[NSString alloc] initWithBytes:str length:len
 524                                               encoding:NSUTF8StringEncoding];
 525
 526     NSPasteboard *pb = [NSPasteboard generalPasteboard];
 527     [pb declareTypes:[NSArray arrayWithObject:NSStringPboardType] owner:nil];
 528     [pb setString:string forType:NSStringPboardType];
 529
 530     [string release];
 531     vim_free(str);
 532 }
 533
 534
 535 // -- Menu ------------------------------------------------------------------
 536
 537
 538 /*
 539  * Add a sub menu to the menu bar.
 540  */
 541     void
 542 gui_mch_add_menu(vimmenu_T *menu, int idx)
 543 {
 544     //NSLog(@"gui_mch_add_menu(name=%s, idx=%d)", menu->name, idx);
 545
 546     // HACK!  If menu has no parent, then we set the parent tag to the type of
 547     // menu it is.  This will not mix up tag and type because pointers can not
 548     // take values close to zero (and the tag is simply the value of the
 549     // pointer).
 550     int parent = (int)menu->parent;
 551     if (!parent) {
 552         parent = menu_is_popup(menu->name) ? MenuPopupType :
 553                  menu_is_toolbar(menu->name) ? MenuToolbarType :
 554                  MenuMenubarType;
 555     }
 556
 557     [[MMBackend sharedInstance]
 558             addMenuWithTag:(int)menu parent:parent name:(char*)menu->dname
 559                    atIndex:idx];
 560 }
 561
 562
 563 /*
 564  * Add a menu item to a menu
 565  */
 566     void
 567 gui_mch_add_menu_item(vimmenu_T *menu, int idx)
 568 {
 569     //NSLog(@"gui_mch_add_menu_item(name=%s, accel=%s idx=%d)", menu->dname,
 570     //        menu->actext, idx);
 571
 572     // NOTE!  If 'iconfile' is not set but 'iconidx' is, use the name of the
 573     // menu item.  (Should correspond to a stock item.)
 574     char *icon = menu->iconfile ? (char*)menu->iconfile :
 575                  menu->iconidx >= 0 ? (char*)menu->dname :
 576                  NULL;
 577     //char *name = menu_is_separator(menu->name) ? NULL : (char*)menu->dname;
 578     char *name = (char*)menu->dname;
 579     char *tip = menu->strings[MENU_INDEX_TIP]
 580             ? (char*)menu->strings[MENU_INDEX_TIP] : (char*)menu->actext;
 581
 582     // HACK!  Check if menu is mapped to ':action actionName:'; if so, pass the
 583     // action along so that MacVim can bind the menu item to this action.  This
 584     // means that if a menu item maps to an action in normal mode, then all
 585     // other modes will also use the same action.
 586     NSString *action = nil;
 587     char_u *map_str = menu->strings[MENU_INDEX_NORMAL];
 588     if (map_str) {
 589         NSString *mapping = [NSString stringWithCString:(char*)map_str
 590                                                encoding:NSUTF8StringEncoding];
 591         NSArray *parts = [mapping componentsSeparatedByString:@" "];
 592         if ([parts count] >=2
 593                 && [[parts objectAtIndex:0] isEqual:@":action"]) {
 594             action = [parts objectAtIndex:1];
 595             action = [action stringByTrimmingCharactersInSet:
 596                     [NSCharacterSet whitespaceAndNewlineCharacterSet]];
 597             if (!gui_cocoa_is_valid_action(action))
 598                 action = nil;
 599         }
 600     }
 601
 602     [[MMBackend sharedInstance]
 603             addMenuItemWithTag:(int)menu
 604                         parent:(int)menu->parent
 605                           name:name
 606                            tip:tip
 607                           icon:(char*)icon
 608                  keyEquivalent:menu->ke_key
 609                      modifiers:menu->ke_mods
 610                         action:action
 611                        atIndex:idx];
 612 }
 613
 614
 615 /*
 616  * Destroy the machine specific menu widget.
 617  */
 618     void
 619 gui_mch_destroy_menu(vimmenu_T *menu)
 620 {
 621     //NSLog(@"gui_mch_destroy_menu(name=%s)", menu->name);
 622
 623     [[MMBackend sharedInstance] removeMenuItemWithTag:(int)menu];
 624 }
 625
 626
 627 /*
 628  * Make a menu either grey or not grey.
 629  */
 630     void
 631 gui_mch_menu_grey(vimmenu_T *menu, int grey)
 632 {
 633     //NSLog(@"gui_mch_menu_grey(name=%s, grey=%d)", menu->name, grey);
 634     [[MMBackend sharedInstance]
 635             enableMenuItemWithTag:(int)menu state:!grey];
 636 }
 637
 638
 639 /*
 640  * Make menu item hidden or not hidden
 641  */
 642     void
 643 gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
 644 {
 645     //NSLog(@"gui_mch_menu_hidden(name=%s, hidden=%d)", menu->name, hidden);
 646
 647     // HACK! There is no (obvious) way to hide a menu item, so simply
 648     // enable/disable it instead.
 649     [[MMBackend sharedInstance]
 650             enableMenuItemWithTag:(int)menu state:!hidden];
 651 }
 652
 653
 654 /*
 655  * This is called when user right clicks.
 656  */
 657     void
 658 gui_mch_show_popupmenu(vimmenu_T *menu)
 659 {
 660     //NSLog(@"gui_mch_show_popupmenu(name=%s)", menu->name);
 661
 662     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)menu->name
 663                                       atMouseLocation:YES];
 664 }
 665
 666
 667 /*
 668  * This is called when a :popup command is executed.
 669  */
 670     void
 671 gui_make_popup(char_u *path_name, int mouse_pos)
 672 {
 673     // TODO: Unless mouse_pos set, popup at cursor location.
 674     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)path_name
 675                                       atMouseLocation:mouse_pos];
 676 }
 677
 678
 679 /*
 680  * This is called after setting all the menus to grey/hidden or not.
 681  */
 682     void
 683 gui_mch_draw_menubar(void)
 684 {
 685     // The (main) menu draws itself in Mac OS X.
 686 }
 687
 688
 689     void
 690 gui_mch_enable_menu(int flag)
 691 {
 692     // The (main) menu is always enabled in Mac OS X.
 693 }
 694
 695
 696 #if 0
 697     void
 698 gui_mch_set_menu_pos(int x, int y, int w, int h)
 699 {
 700     // The (main) menu cannot be moved in Mac OS X.
 701 }
 702 #endif
 703
 704
 705     void
 706 gui_mch_show_toolbar(int showit)
 707 {
 708     int flags = 0;
 709     if (toolbar_flags & TOOLBAR_TEXT) flags |= ToolbarLabelFlag;
 710     if (toolbar_flags & TOOLBAR_ICONS) flags |= ToolbarIconFlag;
 711     if (tbis_flags & (TBIS_MEDIUM|TBIS_LARGE)) flags |= ToolbarSizeRegularFlag;
 712
 713     //NSLog(@"gui_mch_show_toolbar(showit=%d, flags=%d)", showit, flags);
 714
 715     [[MMBackend sharedInstance] showToolbar:showit flags:flags];
 716 }
 717
 718
 719
 720
 721 // -- Fonts -----------------------------------------------------------------
 722
 723
 724 /*
 725  * If a font is not going to be used, free its structure.
 726  */
 727     void
 728 gui_mch_free_font(font)
 729     GuiFont     font;
 730 {
 731 }
 732
 733
 734 /*
 735  * Get a font structure for highlighting.
 736  */
 737     GuiFont
 738 gui_mch_get_font(char_u *name, int giveErrorIfMissing)
 739 {
 740     //NSLog(@"gui_mch_get_font(name=%s, giveErrorIfMissing=%d)", name,
 741     //        giveErrorIfMissing);
 742     return 0;
 743 }
 744
 745
 746 #if defined(FEAT_EVAL) || defined(PROTO)
 747 /*
 748  * Return the name of font "font" in allocated memory.
 749  * Don't know how to get the actual name, thus use the provided name.
 750  */
 751     char_u *
 752 gui_mch_get_fontname(GuiFont font, char_u *name)
 753 {
 754     //NSLog(@"gui_mch_get_fontname(font=%d, name=%s)", font, name);
 755     return 0;
 756 }
 757 #endif
 758
 759
 760 /*
 761  * Initialise vim to use the font with the given name.  Return FAIL if the font
 762  * could not be loaded, OK otherwise.
 763  */
 764     int
 765 gui_mch_init_font(char_u *font_name, int fontset)
 766 {
 767     //NSLog(@"gui_mch_init_font(font_name=%s, fontset=%d)", font_name, fontset);
 768
 769     // HACK!  This gets called whenever the user types :set gfn=fontname, so
 770     // for now we set the font here.
 771     // TODO!  Proper font handling, the way Vim expects it.
 772     return [[MMBackend sharedInstance]
 773             setFontWithName:(char*)font_name];
 774 }
 775
 776
 777 /*
 778  * Set the current text font.
 779  */
 780     void
 781 gui_mch_set_font(GuiFont font)
 782 {
 783 }
 784
 785
 786
 787
 788 // -- Scrollbars ------------------------------------------------------------
 789
 790
 791     void
 792 gui_mch_create_scrollbar(
 793         scrollbar_T *sb,
 794         int orient)     /* SBAR_VERT or SBAR_HORIZ */
 795 {
 796     //NSLog(@"gui_mch_create_scrollbar(id=%d, orient=%d, type=%d)",
 797     //        sb->ident, orient, sb->type);
 798
 799     [[MMBackend sharedInstance]
 800             createScrollbarWithIdentifier:sb->ident type:sb->type];
 801 }
 802
 803
 804     void
 805 gui_mch_destroy_scrollbar(scrollbar_T *sb)
 806 {
 807     //NSLog(@"gui_mch_destroy_scrollbar(id=%d)", sb->ident);
 808
 809     [[MMBackend sharedInstance]
 810             destroyScrollbarWithIdentifier:sb->ident];
 811 }
 812
 813
 814     void
 815 gui_mch_enable_scrollbar(
 816         scrollbar_T     *sb,
 817         int             flag)
 818 {
 819     //NSLog(@"gui_mch_enable_scrollbar(id=%d, flag=%d)", sb->ident, flag);
 820
 821     [[MMBackend sharedInstance]
 822             showScrollbarWithIdentifier:sb->ident state:flag];
 823 }
 824
 825
 826     void
 827 gui_mch_set_scrollbar_pos(
 828         scrollbar_T *sb,
 829         int x,
 830         int y,
 831         int w,
 832         int h)
 833 {
 834     //NSLog(@"gui_mch_set_scrollbar_pos(id=%d, x=%d, y=%d, w=%d, h=%d)",
 835     //        sb->ident, x, y, w, h);
 836
 837     int pos = y;
 838     int len = h;
 839     if (SBAR_BOTTOM == sb->type) {
 840         pos = x;
 841         len = w;
 842     }
 843
 844     [[MMBackend sharedInstance]
 845             setScrollbarPosition:pos length:len identifier:sb->ident];
 846 }
 847
 848
 849     void
 850 gui_mch_set_scrollbar_thumb(
 851         scrollbar_T *sb,
 852         long val,
 853         long size,
 854         long max)
 855 {
 856     //NSLog(@"gui_mch_set_scrollbar_thumb(id=%d, val=%d, size=%d, max=%d)",
 857     //        sb->ident, val, size, max);
 858
 859     [[MMBackend sharedInstance]
 860             setScrollbarThumbValue:val size:size max:max identifier:sb->ident];
 861 }
 862
 863
 864
 865
 866
 867 // -- Unsorted --------------------------------------------------------------
 868
 869
 870     void
 871 ex_action(eap)
 872     exarg_T     *eap;
 873 {
 874     if (!gui.in_use) {
 875         EMSG(_("E???: Command only available in GUI mode"));
 876         return;
 877     }
 878
 879     NSString *name = [NSString stringWithCString:(char*)eap->arg
 880                                         encoding:NSUTF8StringEncoding];
 881     if (gui_cocoa_is_valid_action(name)) {
 882         [[MMBackend sharedInstance] executeActionWithName:name];
 883     } else {
 884         EMSG2(_("E???: \"%s\" is not a valid action"), eap->arg);
 885     }
 886 }
 887
 888
 889 /*
 890  * Adjust gui.char_height (after 'linespace' was changed).
 891  */
 892     int
 893 gui_mch_adjust_charheight(void)
 894 {
 895     return 0;
 896 }
 897
 898
 899     void
 900 gui_mch_beep(void)
 901 {
 902 }
 903
 904
 905
 906 #ifdef FEAT_BROWSE
 907 /*
 908  * Pop open a file browser and return the file selected, in allocated memory,
 909  * or NULL if Cancel is hit.
 910  *  saving  - TRUE if the file will be saved to, FALSE if it will be opened.
 911  *  title   - Title message for the file browser dialog.
 912  *  dflt    - Default name of file.
 913  *  ext     - Default extension to be added to files without extensions.
 914  *  initdir - directory in which to open the browser (NULL = current dir)
 915  *  filter  - Filter for matched files to choose from.
 916  *  Has a format like this:
 917  *  "C Files (*.c)\0*.c\0"
 918  *  "All Files\0*.*\0\0"
 919  *  If these two strings were concatenated, then a choice of two file
 920  *  filters will be selectable to the user.  Then only matching files will
 921  *  be shown in the browser.  If NULL, the default allows all files.
 922  *
 923  *  *NOTE* - the filter string must be terminated with TWO nulls.
 924  */
 925     char_u *
 926 gui_mch_browse(
 927     int saving,
 928     char_u *title,
 929     char_u *dflt,
 930     char_u *ext,
 931     char_u *initdir,
 932     char_u *filter)
 933 {
 934     //NSLog(@"gui_mch_browse(saving=%d, title=%s, dflt=%s, ext=%s, initdir=%s,"
 935     //        " filter=%s", saving, title, dflt, ext, initdir, filter);
 936
 937     char_u *s = (char_u*)[[MMBackend sharedInstance]
 938             browseForFileInDirectory:(char*)initdir title:(char*)title
 939                               saving:saving];
 940
 941     return s;
 942 }
 943 #endif /* FEAT_BROWSE */
 944
 945
 946
 947     int
 948 gui_mch_dialog(
 949     int         type,
 950     char_u      *title,
 951     char_u      *message,
 952     char_u      *buttons,
 953     int         dfltbutton,
 954     char_u      *textfield)
 955 {
 956     return 0;
 957 }
 958
 959
 960 /*
 961  * Draw a cursor without focus.
 962  */
 963     void
 964 gui_mch_draw_hollow_cursor(guicolor_T color)
 965 {
 966 }
 967
 968
 969 /*
 970  * Draw part of a cursor, only w pixels wide, and h pixels high.
 971  */
 972     void
 973 gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
 974 {
 975 }
 976
 977
 978     void
 979 gui_mch_flash(int msec)
 980 {
 981 }
 982
 983
 984 /*
 985  * Return the Pixel value (color) for the given color name.  This routine was
 986  * pretty much taken from example code in the Silicon Graphics OSF/Motif
 987  * Programmer's Guide.
 988  * Return INVALCOLOR when failed.
 989  */
 990     guicolor_T
 991 gui_mch_get_color(char_u *name)
 992 {
 993     NSString *key = [NSString stringWithUTF8String:(char*)name];
 994     return [[MMBackend sharedInstance] lookupColorWithKey:key];
 995 }
 996
 997
 998 /*
 999  * Return the RGB value of a pixel as long.
1000  */
1001     long_u
1002 gui_mch_get_rgb(guicolor_T pixel)
1003 {
1004     // This is only implemented so that vim can guess the correct value for
1005     // 'background' (which otherwise defaults to 'dark'); it is not used for
1006     // anything else (as far as I know).
1007     // The implementation is simple since colors are stored in an int as
1008     // "rrggbb".
1009     return pixel;
1010 }
1011
1012
1013 /*
1014  * Get the screen dimensions.
1015  * Allow 10 pixels for horizontal borders, 40 for vertical borders.
1016  * Is there no way to find out how wide the borders really are?
1017  * TODO: Add live udate of those value on suspend/resume.
1018  */
1019     void
1020 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
1021 {
1022     //NSLog(@"gui_mch_get_screen_dimensions()");
1023     *screen_w = Columns;
1024     *screen_h = Rows;
1025 }
1026
1027
1028 /*
1029  * Get the position of the top left corner of the window.
1030  */
1031     int
1032 gui_mch_get_winpos(int *x, int *y)
1033 {
1034     *x = *y = 0;
1035     return OK;
1036 }
1037
1038
1039 /*
1040  * Get current mouse coordinates in text window.
1041  */
1042     void
1043 gui_mch_getmouse(int *x, int *y)
1044 {
1045 }
1046
1047
1048 /*
1049  * Return OK if the key with the termcap name "name" is supported.
1050  */
1051     int
1052 gui_mch_haskey(char_u *name)
1053 {
1054     NSLog(@"gui_mch_haskey(name=%s)", name);
1055     return 0;
1056 }
1057
1058
1059 /*
1060  * Iconify the GUI window.
1061  */
1062     void
1063 gui_mch_iconify(void)
1064 {
1065 }
1066
1067
1068 /*
1069  * Invert a rectangle from row r, column c, for nr rows and nc columns.
1070  */
1071     void
1072 gui_mch_invert_rectangle(int r, int c, int nr, int nc)
1073 {
1074 }
1075
1076
1077 /*
1078  * Called when the foreground or background color has been changed.
1079  */
1080     void
1081 gui_mch_new_colors(void)
1082 {
1083     gui.def_back_pixel = gui.back_pixel;
1084     gui.def_norm_pixel = gui.norm_pixel;
1085
1086     //NSLog(@"gui_mch_new_colors(back=%x, norm=%x)", gui.def_back_pixel,
1087     //        gui.def_norm_pixel);
1088
1089     [[MMBackend sharedInstance]
1090         setDefaultColorsBackground:gui.def_back_pixel
1091                         foreground:gui.def_norm_pixel];
1092 }
1093
1094
1095     void
1096 gui_mch_def_colors()
1097 {
1098     // Default foreground and background colors are black and white.
1099     gui.def_norm_pixel = gui.norm_pixel = 0;
1100     gui.def_back_pixel = gui.back_pixel = 0xffffff;
1101 }
1102
1103
1104 /*
1105  * Set the current text background color.
1106  */
1107     void
1108 gui_mch_set_bg_color(guicolor_T color)
1109 {
1110     [[MMBackend sharedInstance] setBackgroundColor:color];
1111 }
1112
1113
1114 /*
1115  * Cursor blink functions.
1116  *
1117  * This is a simple state machine:
1118  * BLINK_NONE   not blinking at all
1119  * BLINK_OFF    blinking, cursor is not shown
1120  * BLINK_ON blinking, cursor is shown
1121  */
1122     void
1123 gui_mch_set_blinking(long wait, long on, long off)
1124 {
1125 }
1126
1127
1128 /*
1129  * Set the current text foreground color.
1130  */
1131     void
1132 gui_mch_set_fg_color(guicolor_T color)
1133 {
1134     [[MMBackend sharedInstance] setForegroundColor:color];
1135 }
1136
1137
1138 #if defined(FEAT_EVAL) || defined(PROTO)
1139 /*
1140  * Bring the Vim window to the foreground.
1141  */
1142     void
1143 gui_mch_set_foreground(void)
1144 {
1145 }
1146 #endif
1147
1148
1149
1150     void
1151 gui_mch_set_shellsize(
1152     int         width,
1153     int         height,
1154     int         min_width,
1155     int         min_height,
1156     int         base_width,
1157     int         base_height,
1158     int         direction)
1159 {
1160     //NSLog(@"gui_mch_set_shellsize(width=%d, height=%d, min_width=%d,"
1161     //        " min_height=%d, base_width=%d, base_height=%d, direction=%d)",
1162     //        width, height, min_width, min_height, base_width, base_height,
1163     //        direction);
1164     [[MMBackend sharedInstance] setRows:height columns:width];
1165 }
1166
1167
1168 /*
1169  * Set the current text special color.
1170  */
1171     void
1172 gui_mch_set_sp_color(guicolor_T color)
1173 {
1174 }
1175
1176
1177     void
1178 gui_mch_set_text_area_pos(int x, int y, int w, int h)
1179 {
1180 }
1181
1182 /*
1183  * Set the position of the top left corner of the window to the given
1184  * coordinates.
1185  */
1186     void
1187 gui_mch_set_winpos(int x, int y)
1188 {
1189 }
1190
1191
1192     void
1193 gui_mch_setmouse(int x, int y)
1194 {
1195 }
1196
1197
1198 #ifdef FEAT_TITLE
1199 /*
1200  * Set the window title and icon.
1201  * (The icon is not taken care of).
1202  */
1203     void
1204 gui_mch_settitle(char_u *title, char_u *icon)
1205 {
1206     //NSLog(@"gui_mch_settitle(title=%s, icon=%s)", title, icon);
1207
1208     [[MMBackend sharedInstance] setVimWindowTitle:(char*)title];
1209 }
1210 #endif
1211
1212
1213 /*
1214  * Start the cursor blinking.  If it was already blinking, this restarts the
1215  * waiting time and shows the cursor.
1216  */
1217     void
1218 gui_mch_start_blink(void)
1219 {
1220 }
1221
1222
1223 /*
1224  * Stop the cursor blinking.  Show the cursor if it wasn't shown.
1225  */
1226     void
1227 gui_mch_stop_blink(void)
1228 {
1229 }
1230
1231
1232     void
1233 gui_mch_toggle_tearoffs(int enable)
1234 {
1235 }
1236
1237
1238     void
1239 mch_set_mouse_shape(int shape)
1240 {
1241 }
1242
1243
1244     static BOOL
1245 gui_cocoa_is_valid_action(NSString *action)
1246 {
1247     static NSDictionary *actionDict = nil;
1248
1249     if (!actionDict) {
1250         NSBundle *mainBundle = [NSBundle mainBundle];
1251         NSString *path = [mainBundle pathForResource:@"Actions"
1252                                               ofType:@"plist"];
1253         if (path) {
1254             actionDict = [[NSDictionary alloc] initWithContentsOfFile:path];
1255         } else {
1256             // Allocate bogus dictionary so that error only pops up once.
1257             actionDict = [NSDictionary new];
1258             EMSG(_("E???: Failed to load action dictionary"));
1259         }
1260     }
1261
1262     return [actionDict objectForKey:action] != nil;
1263 }