src/MacVim/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
  18 // This constant controls how often [MMBackend update] may get called (see
  19 // gui_mch_update()).
  20 static NSTimeInterval MMUpdateTimeoutInterval = 0.1f;
  21
  22
  23 static BOOL gui_macvim_is_valid_action(NSString *action);
  24
  25
  26
  27 // -- Initialization --------------------------------------------------------
  28
  29 /*
  30  * Parse the GUI related command-line arguments.  Any arguments used are
  31  * deleted from argv, and *argc is decremented accordingly.  This is called
  32  * when vim is started, whether or not the GUI has been started.
  33  */
  34     void
  35 gui_mch_prepare(int *argc, char **argv)
  36 {
  37     //NSLog(@"gui_mch_prepare(argc=%d)", *argc);
  38
  39     // Set environment variables $VIM and $VIMRUNTIME
  40     // NOTE!  If vim_getenv is called with one of these as parameters before
  41     // they have been set here, they will most likely end up with the wrong
  42     // values!
  43     //
  44     // TODO:
  45     // - ensure this is called first to avoid above problem
  46     // - encoding
  47
  48     NSString *path = [[[NSBundle mainBundle] resourcePath]
  49         stringByAppendingPathComponent:@"vim"];
  50     vim_setenv((char_u*)"VIM", (char_u*)[path UTF8String]);
  51
  52     path = [path stringByAppendingPathComponent:@"runtime"];
  53     vim_setenv((char_u*)"VIMRUNTIME", (char_u*)[path UTF8String]);
  54 }
  55
  56
  57 /*
  58  * Check if the GUI can be started.  Called before gvimrc is sourced.
  59  * Return OK or FAIL.
  60  */
  61     int
  62 gui_mch_init_check(void)
  63 {
  64     //NSLog(@"gui_mch_init_check()");
  65     return OK;
  66 }
  67
  68
  69 /*
  70  * Initialise the GUI.  Create all the windows, set up all the call-backs etc.
  71  * Returns OK for success, FAIL when the GUI can't be started.
  72  */
  73     int
  74 gui_mch_init(void)
  75 {
  76     //NSLog(@"gui_mch_init()");
  77
  78     if (![[MMBackend sharedInstance] checkin])
  79         return FAIL;
  80
  81     // Force 'termencoding' to utf-8 (changes to 'tenc' are disallowed in
  82     // 'option.c', so that ':set termencoding=...' is impossible).
  83     set_option_value((char_u *)"termencoding", 0L, (char_u *)"utf-8", 0);
  84
  85     // Set values so that pixels and characters are in one-to-one
  86     // correspondence (assuming all characters have the same dimensions).
  87     gui.scrollbar_width = gui.scrollbar_height = 0;
  88
  89     gui.char_height = 1;
  90     gui.char_width = 1;
  91     gui.char_ascent = 0;
  92
  93     gui_mch_def_colors();
  94
  95     [[MMBackend sharedInstance]
  96         setDefaultColorsBackground:gui.back_pixel foreground:gui.norm_pixel];
  97     [[MMBackend sharedInstance] setBackgroundColor:gui.back_pixel];
  98     [[MMBackend sharedInstance] setForegroundColor:gui.norm_pixel];
  99
 100     // NOTE: If this call is left out the cursor is opaque.
 101     highlight_gui_started();
 102
 103     return OK;
 104 }
 105
 106
 107
 108     void
 109 gui_mch_exit(int rc)
 110 {
 111     //NSLog(@"gui_mch_exit(rc=%d)", rc);
 112
 113     [[MMBackend sharedInstance] exit];
 114 }
 115
 116
 117 /*
 118  * Open the GUI window which was created by a call to gui_mch_init().
 119  */
 120     int
 121 gui_mch_open(void)
 122 {
 123     //NSLog(@"gui_mch_open()");
 124
 125     return [[MMBackend sharedInstance] openVimWindow];
 126 }
 127
 128
 129 // -- Updating --------------------------------------------------------------
 130
 131
 132 /*
 133  * Catch up with any queued X events.  This may put keyboard input into the
 134  * input buffer, call resize call-backs, trigger timers etc.  If there is
 135  * nothing in the X event queue (& no timers pending), then we return
 136  * immediately.
 137  */
 138 #define MM_LOG_UPDATE_STATS 0
 139     void
 140 gui_mch_update(void)
 141 {
 142     // NOTE: This function can get called A LOT (~1 call/ms) and unfortunately
 143     // checking the run loop takes a long time, resulting in noticable slow
 144     // downs if it is done every time this function is called.  Therefore we
 145     // make sure that it is not done too often.
 146     static NSDate *lastUpdateDate = nil;
 147 #if MM_LOG_UPDATE_STATS
 148     static int skipCount = 0;
 149 #endif
 150
 151     if (lastUpdateDate && -[lastUpdateDate timeIntervalSinceNow] <
 152             MMUpdateTimeoutInterval) {
 153 #if MM_LOG_UPDATE_STATS
 154         ++skipCount;
 155 #endif
 156         return;
 157     }
 158
 159 #if MM_LOG_UPDATE_STATS
 160     NSTimeInterval dt = -[lastUpdateDate timeIntervalSinceNow];
 161     NSLog(@"Updating (last update %.2f seconds ago, skipped %d updates, "
 162             "approx %.1f calls per second)",
 163             dt, skipCount, dt > 0 ? skipCount/dt : 0);
 164     skipCount = 0;
 165 #endif
 166
 167     [[MMBackend sharedInstance] update];
 168
 169     [lastUpdateDate release];
 170     lastUpdateDate = [[NSDate date] retain];
 171 }
 172
 173
 174 /* Flush any output to the screen */
 175     void
 176 gui_mch_flush(void)
 177 {
 178     [[MMBackend sharedInstance] flushQueue:NO];
 179 }
 180
 181
 182 /* Force flush output to MacVim.  Do not call this method unless absolutely
 183  * necessary (use gui_mch_flush() instead). */
 184     void
 185 gui_macvim_force_flush(void)
 186 {
 187     [[MMBackend sharedInstance] flushQueue:YES];
 188 }
 189
 190
 191 /*
 192  * GUI input routine called by gui_wait_for_chars().  Waits for a character
 193  * from the keyboard.
 194  *  wtime == -1     Wait forever.
 195  *  wtime == 0      This should never happen.
 196  *  wtime > 0       Wait wtime milliseconds for a character.
 197  * Returns OK if a character was found to be available within the given time,
 198  * or FAIL otherwise.
 199  */
 200     int
 201 gui_mch_wait_for_chars(int wtime)
 202 {
 203     // NOTE! In all likelihood Vim will take a nap when waitForInput: is
 204     // called, so force a flush of the command queue here.
 205     [[MMBackend sharedInstance] flushQueue:YES];
 206
 207     return [[MMBackend sharedInstance] waitForInput:wtime];
 208 }
 209
 210
 211 // -- Drawing ---------------------------------------------------------------
 212
 213
 214 /*
 215  * Clear the whole text window.
 216  */
 217     void
 218 gui_mch_clear_all(void)
 219 {
 220     [[MMBackend sharedInstance] clearAll];
 221 }
 222
 223
 224 /*
 225  * Clear a rectangular region of the screen from text pos (row1, col1) to
 226  * (row2, col2) inclusive.
 227  */
 228     void
 229 gui_mch_clear_block(int row1, int col1, int row2, int col2)
 230 {
 231     [[MMBackend sharedInstance] clearBlockFromRow:row1 column:col1
 232                                                     toRow:row2 column:col2];
 233 }
 234
 235
 236 /*
 237  * Delete the given number of lines from the given row, scrolling up any
 238  * text further down within the scroll region.
 239  */
 240     void
 241 gui_mch_delete_lines(int row, int num_lines)
 242 {
 243     [[MMBackend sharedInstance] deleteLinesFromRow:row count:num_lines
 244             scrollBottom:gui.scroll_region_bot
 245                     left:gui.scroll_region_left
 246                    right:gui.scroll_region_right];
 247 }
 248
 249
 250     void
 251 gui_mch_draw_string(int row, int col, char_u *s, int len, int flags)
 252 {
 253 #if MM_ENABLE_CONV
 254     char_u *conv_str = NULL;
 255     if (output_conv.vc_type != CONV_NONE) {
 256         conv_str = string_convert(&output_conv, s, &len);
 257         if (conv_str)
 258             s = conv_str;
 259     }
 260 #endif
 261
 262     [[MMBackend sharedInstance] replaceString:(char*)s length:len
 263             row:row column:col flags:flags];
 264
 265 #if MM_ENABLE_CONV
 266     if (conv_str)
 267         vim_free(conv_str);
 268 #endif
 269 }
 270
 271
 272     int
 273 gui_macvim_draw_string(int row, int col, char_u *s, int len, int flags)
 274 {
 275     //
 276     // Output chars until a wide char found.  If a wide char is found, output a
 277     // zero-width space after it so that a wide char looks like two chars to
 278     // MMTextStorage.  This way 1 char corresponds to 1 column.
 279     //
 280
 281     int c;
 282     int cn;
 283     int cl;
 284     int i;
 285     int start = 0;
 286     int endcol = col;
 287     int startcol = col;
 288     BOOL outPad = NO;
 289     MMBackend *backend = [MMBackend sharedInstance];
 290     static char ZeroWidthSpace[] = { 0xe2, 0x80, 0x8b };
 291 #if MM_ENABLE_CONV
 292     char_u *conv_str = NULL;
 293
 294     if (output_conv.vc_type != CONV_NONE) {
 295         conv_str = string_convert(&output_conv, s, &len);
 296         if (conv_str)
 297             s = conv_str;
 298     }
 299 #endif
 300
 301     for (i = 0; i < len; i += cl) {
 302         c = utf_ptr2char(s + i);
 303         cl = utf_ptr2len(s + i);
 304         cn = utf_char2cells(c);
 305
 306         if (!utf_iscomposing(c)) {
 307             if (outPad) {
 308                 outPad = NO;
 309 #if 0
 310                 NSString *string = [[NSString alloc]
 311                         initWithBytesNoCopy:(void*)(s+start)
 312                                      length:i-start
 313                                    encoding:NSUTF8StringEncoding
 314                                freeWhenDone:NO];
 315                 NSLog(@"Flushing string=%@ len=%d row=%d col=%d end=%d",
 316                         string, i-start, row, startcol, endcol);
 317                 [string release];
 318 #endif
 319                 [backend replaceString:(char*)(s+start) length:i-start
 320                         row:row column:startcol flags:flags];
 321                 start = i;
 322                 startcol = endcol;
 323 #if 0
 324                 NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace),
 325                         row, endcol-1);
 326 #endif
 327                 [backend replaceString:ZeroWidthSpace
 328                              length:sizeof(ZeroWidthSpace)
 329                         row:row column:endcol-1 flags:flags];
 330             }
 331
 332             endcol += cn;
 333         }
 334
 335         if (cn > 1) {
 336 #if 0
 337             NSLog(@"Wide char detected! (char=%C hex=%x cells=%d)", c, c, cn);
 338 #endif
 339             outPad = YES;
 340         }
 341     }
 342
 343 #if 0
 344     if (row < 1) {
 345         NSString *string = [[NSString alloc]
 346                 initWithBytesNoCopy:(void*)(s+start)
 347                              length:len-start
 348                            encoding:NSUTF8StringEncoding
 349                        freeWhenDone:NO];
 350         NSLog(@"Output string=%@ len=%d row=%d col=%d", string, len-start, row,
 351                 startcol);
 352         [string release];
 353     }
 354 #endif
 355
 356     // Output remaining characters.
 357     [backend replaceString:(char*)(s+start) length:len-start
 358             row:row column:startcol flags:flags];
 359
 360     if (outPad) {
 361 #if 0
 362         NSLog(@"Padding len=%d row=%d col=%d", sizeof(ZeroWidthSpace), row,
 363                 endcol-1);
 364 #endif
 365         [backend replaceString:ZeroWidthSpace
 366                      length:sizeof(ZeroWidthSpace)
 367                 row:row column:endcol-1 flags:flags];
 368     }
 369
 370 #if MM_ENABLE_CONV
 371     if (conv_str)
 372         vim_free(conv_str);
 373 #endif
 374
 375     return endcol - col;
 376 }
 377
 378
 379 /*
 380  * Insert the given number of lines before the given row, scrolling down any
 381  * following text within the scroll region.
 382  */
 383     void
 384 gui_mch_insert_lines(int row, int num_lines)
 385 {
 386     [[MMBackend sharedInstance] insertLinesFromRow:row count:num_lines
 387             scrollBottom:gui.scroll_region_bot
 388                     left:gui.scroll_region_left
 389                    right:gui.scroll_region_right];
 390 }
 391
 392
 393 /*
 394  * Set the current text foreground color.
 395  */
 396     void
 397 gui_mch_set_fg_color(guicolor_T color)
 398 {
 399     [[MMBackend sharedInstance] setForegroundColor:color];
 400 }
 401
 402
 403 /*
 404  * Set the current text background color.
 405  */
 406     void
 407 gui_mch_set_bg_color(guicolor_T color)
 408 {
 409     [[MMBackend sharedInstance] setBackgroundColor:color];
 410 }
 411
 412
 413 /*
 414  * Set the current text special color (used for underlines).
 415  */
 416     void
 417 gui_mch_set_sp_color(guicolor_T color)
 418 {
 419     [[MMBackend sharedInstance] setSpecialColor:color];
 420 }
 421
 422
 423 /*
 424  * Set default colors.
 425  */
 426     void
 427 gui_mch_def_colors()
 428 {
 429     MMBackend *backend = [MMBackend sharedInstance];
 430
 431     // The default colors are taken from system values
 432     gui.def_norm_pixel = gui.norm_pixel =
 433         [backend lookupColorWithKey:@"MacTextColor"];
 434     gui.def_back_pixel = gui.back_pixel =
 435         [backend lookupColorWithKey:@"MacTextBackgroundColor"];
 436 }
 437
 438
 439 /*
 440  * Called when the foreground or background color has been changed.
 441  */
 442     void
 443 gui_mch_new_colors(void)
 444 {
 445     gui.def_back_pixel = gui.back_pixel;
 446     gui.def_norm_pixel = gui.norm_pixel;
 447
 448     //NSLog(@"gui_mch_new_colors(back=%x, norm=%x)", gui.def_back_pixel,
 449     //        gui.def_norm_pixel);
 450
 451     [[MMBackend sharedInstance]
 452         setDefaultColorsBackground:gui.def_back_pixel
 453                         foreground:gui.def_norm_pixel];
 454 }
 455
 456
 457 // -- Tabline ---------------------------------------------------------------
 458
 459
 460 /*
 461  * Set the current tab to "nr".  First tab is 1.
 462  */
 463     void
 464 gui_mch_set_curtab(int nr)
 465 {
 466     [[MMBackend sharedInstance] selectTab:nr];
 467 }
 468
 469
 470 /*
 471  * Return TRUE when tabline is displayed.
 472  */
 473     int
 474 gui_mch_showing_tabline(void)
 475 {
 476     return [[MMBackend sharedInstance] tabBarVisible];
 477 }
 478
 479 /*
 480  * Update the labels of the tabline.
 481  */
 482     void
 483 gui_mch_update_tabline(void)
 484 {
 485     [[MMBackend sharedInstance] updateTabBar];
 486 }
 487
 488 /*
 489  * Show or hide the tabline.
 490  */
 491     void
 492 gui_mch_show_tabline(int showit)
 493 {
 494     [[MMBackend sharedInstance] showTabBar:showit];
 495 }
 496
 497
 498 // -- Clipboard -------------------------------------------------------------
 499
 500
 501     void
 502 clip_mch_lose_selection(VimClipboard *cbd)
 503 {
 504 }
 505
 506
 507     int
 508 clip_mch_own_selection(VimClipboard *cbd)
 509 {
 510     return 0;
 511 }
 512
 513
 514     void
 515 clip_mch_request_selection(VimClipboard *cbd)
 516 {
 517     NSPasteboard *pb = [NSPasteboard generalPasteboard];
 518     NSString *pbType = [pb availableTypeFromArray:
 519             [NSArray arrayWithObject:NSStringPboardType]];
 520     if (pbType) {
 521         NSMutableString *string =
 522                 [[pb stringForType:NSStringPboardType] mutableCopy];
 523
 524         // Replace unrecognized end-of-line sequences with \x0a (line feed).
 525         NSRange range = { 0, [string length] };
 526         unsigned n = [string replaceOccurrencesOfString:@"\x0d\x0a"
 527                                              withString:@"\x0a" options:0
 528                                                   range:range];
 529         if (0 == n) {
 530             n = [string replaceOccurrencesOfString:@"\x0d" withString:@"\x0a"
 531                                            options:0 range:range];
 532         }
 533
 534         // Scan for newline character to decide whether the string should be
 535         // pasted linewise or characterwise.
 536         int type = MCHAR;
 537         if (0 < n || NSNotFound != [string rangeOfString:@"\n"].location)
 538             type = MLINE;
 539
 540         char_u *str = (char_u*)[string UTF8String];
 541         int len = [string lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
 542
 543 #if MM_ENABLE_CONV
 544         if (input_conv.vc_type != CONV_NONE)
 545             str = string_convert(&input_conv, str, &len);
 546 #endif
 547
 548         if (str)
 549             clip_yank_selection(type, str, len, cbd);
 550
 551 #if MM_ENABLE_CONV
 552         if (input_conv.vc_type != CONV_NONE)
 553             vim_free(str);
 554 #endif
 555     }
 556 }
 557
 558
 559 /*
 560  * Send the current selection to the clipboard.
 561  */
 562     void
 563 clip_mch_set_selection(VimClipboard *cbd)
 564 {
 565     // If the '*' register isn't already filled in, fill it in now.
 566     cbd->owned = TRUE;
 567     clip_get_selection(cbd);
 568     cbd->owned = FALSE;
 569
 570     // Get the text to put on the pasteboard.
 571     long_u llen = 0; char_u *str = 0;
 572     int type = clip_convert_selection(&str, &llen, cbd);
 573     if (type < 0)
 574         return;
 575
 576     // TODO: Avoid overflow.
 577     int len = (int)llen;
 578 #if MM_ENABLE_CONV
 579     if (output_conv.vc_type != CONV_NONE) {
 580         char_u *conv_str = string_convert(&output_conv, str, &len);
 581         if (conv_str) {
 582             vim_free(str);
 583             str = conv_str;
 584         }
 585     }
 586 #endif
 587
 588     if (len > 0) {
 589         NSString *string = [[NSString alloc]
 590             initWithBytes:str length:len encoding:NSUTF8StringEncoding];
 591
 592         NSPasteboard *pb = [NSPasteboard generalPasteboard];
 593         [pb declareTypes:[NSArray arrayWithObject:NSStringPboardType]
 594                    owner:nil];
 595         [pb setString:string forType:NSStringPboardType];
 596
 597         [string release];
 598     }
 599
 600     vim_free(str);
 601 }
 602
 603
 604 // -- Menu ------------------------------------------------------------------
 605
 606
 607 /*
 608  * Add a sub menu to the menu bar.
 609  */
 610     void
 611 gui_mch_add_menu(vimmenu_T *menu, int idx)
 612 {
 613     // HACK!  If menu has no parent, then we set the parent tag to the type of
 614     // menu it is.  This will not mix up tag and type because pointers can not
 615     // take values close to zero (and the tag is simply the value of the
 616     // pointer).
 617     int parent = (int)menu->parent;
 618     if (!parent) {
 619         parent = menu_is_popup(menu->name) ? MenuPopupType :
 620                  menu_is_toolbar(menu->name) ? MenuToolbarType :
 621                  MenuMenubarType;
 622     }
 623
 624     char_u *dname = menu->dname;
 625 #if MM_ENABLE_CONV
 626     dname = CONVERT_TO_UTF8(dname);
 627 #endif
 628
 629     [[MMBackend sharedInstance]
 630             addMenuWithTag:(int)menu parent:parent name:(char*)dname
 631                    atIndex:idx];
 632
 633 #if MM_ENABLE_CONV
 634     CONVERT_TO_UTF8_FREE(dname);
 635 #endif
 636 }
 637
 638
 639 /*
 640  * Add a menu item to a menu
 641  */
 642     void
 643 gui_mch_add_menu_item(vimmenu_T *menu, int idx)
 644 {
 645     // NOTE!  If 'iconfile' is not set but 'iconidx' is, use the name of the
 646     // menu item.  (Should correspond to a stock item.)
 647     char_u *icon = menu->iconfile ? menu->iconfile :
 648                  menu->iconidx >= 0 ? menu->dname :
 649                  NULL;
 650     //char *name = menu_is_separator(menu->name) ? NULL : (char*)menu->dname;
 651     char_u *name = menu->dname;
 652     char_u *tip = menu->strings[MENU_INDEX_TIP]
 653             ? menu->strings[MENU_INDEX_TIP] : menu->actext;
 654     char_u *map_str = menu->strings[MENU_INDEX_NORMAL];
 655
 656 #if MM_ENABLE_CONV
 657     icon = CONVERT_TO_UTF8(icon);
 658     name = CONVERT_TO_UTF8(name);
 659     tip = CONVERT_TO_UTF8(tip);
 660     map_str = CONVERT_TO_UTF8(map_str);
 661 #endif
 662
 663     // HACK!  Check if menu is mapped to ':macaction actionName:'; if so, pass
 664     // the action along so that MacVim can bind the menu item to this action.
 665     // This means that if a menu item maps to an action in normal mode, then
 666     // all other modes will also use the same action.
 667     NSString *action = nil;
 668     if (map_str) {
 669         NSString *mapping = [NSString stringWithCString:(char*)map_str
 670                                                encoding:NSUTF8StringEncoding];
 671         NSArray *parts = [mapping componentsSeparatedByString:@" "];
 672         if ([parts count] >=2
 673                 && [[parts objectAtIndex:0] hasPrefix:@":maca"]) {
 674             action = [parts objectAtIndex:1];
 675             action = [action stringByTrimmingCharactersInSet:
 676                     [NSCharacterSet whitespaceAndNewlineCharacterSet]];
 677             if (!gui_macvim_is_valid_action(action))
 678                 action = nil;
 679         }
 680     }
 681
 682     [[MMBackend sharedInstance]
 683             addMenuItemWithTag:(int)menu
 684                         parent:(int)menu->parent
 685                           name:(char*)name
 686                            tip:(char*)tip
 687                           icon:(char*)icon
 688                  keyEquivalent:menu->mac_key
 689                      modifiers:menu->mac_mods
 690                         action:action
 691                        atIndex:idx];
 692
 693 #if MM_ENABLE_CONV
 694     CONVERT_TO_UTF8_FREE(icon);
 695     CONVERT_TO_UTF8_FREE(name);
 696     CONVERT_TO_UTF8_FREE(tip);
 697     CONVERT_TO_UTF8_FREE(map_str);
 698 #endif
 699 }
 700
 701
 702 /*
 703  * Destroy the machine specific menu widget.
 704  */
 705     void
 706 gui_mch_destroy_menu(vimmenu_T *menu)
 707 {
 708     [[MMBackend sharedInstance] removeMenuItemWithTag:(int)menu];
 709 }
 710
 711
 712 /*
 713  * Make a menu either grey or not grey.
 714  */
 715     void
 716 gui_mch_menu_grey(vimmenu_T *menu, int grey)
 717 {
 718     /* Only update menu if the 'grey' state has changed to avoid having to pass
 719      * lots of unnecessary data to MacVim.  (Skipping this test makes MacVim
 720      * pause noticably on mode changes. */
 721     if (menu->was_grey != grey)
 722     {
 723         menu->was_grey = grey;
 724         [[MMBackend sharedInstance]
 725                 enableMenuItemWithTag:(int)menu state:!grey];
 726     }
 727 }
 728
 729
 730 /*
 731  * Make menu item hidden or not hidden
 732  */
 733     void
 734 gui_mch_menu_hidden(vimmenu_T *menu, int hidden)
 735 {
 736     // HACK! There is no (obvious) way to hide a menu item, so simply
 737     // enable/disable it instead.
 738     gui_mch_menu_grey(menu, hidden);
 739 }
 740
 741
 742 /*
 743  * This is called when user right clicks.
 744  */
 745     void
 746 gui_mch_show_popupmenu(vimmenu_T *menu)
 747 {
 748     char_u *name = menu->name;
 749 #if MM_ENABLE_CONV
 750     name = CONVERT_TO_UTF8(name);
 751 #endif
 752
 753     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)name
 754                                       atMouseLocation:YES];
 755
 756 #if MM_ENABLE_CONV
 757     CONVERT_TO_UTF8_FREE(name);
 758 #endif
 759
 760 }
 761
 762
 763 /*
 764  * This is called when a :popup command is executed.
 765  */
 766     void
 767 gui_make_popup(char_u *path_name, int mouse_pos)
 768 {
 769 #if MM_ENABLE_CONV
 770     path_name = CONVERT_TO_UTF8(path_name);
 771 #endif
 772
 773     [[MMBackend sharedInstance] showPopupMenuWithName:(char*)path_name
 774                                       atMouseLocation:mouse_pos];
 775
 776 #if MM_ENABLE_CONV
 777     CONVERT_TO_UTF8_FREE(path_name);
 778 #endif
 779 }
 780
 781
 782 /*
 783  * This is called after setting all the menus to grey/hidden or not.
 784  */
 785     void
 786 gui_mch_draw_menubar(void)
 787 {
 788     // The (main) menu draws itself in Mac OS X.
 789 }
 790
 791
 792     void
 793 gui_mch_enable_menu(int flag)
 794 {
 795     // The (main) menu is always enabled in Mac OS X.
 796 }
 797
 798
 799 #if 0
 800     void
 801 gui_mch_set_menu_pos(int x, int y, int w, int h)
 802 {
 803     // The (main) menu cannot be moved in Mac OS X.
 804 }
 805 #endif
 806
 807
 808     void
 809 gui_mch_show_toolbar(int showit)
 810 {
 811     int flags = 0;
 812     if (toolbar_flags & TOOLBAR_TEXT) flags |= ToolbarLabelFlag;
 813     if (toolbar_flags & TOOLBAR_ICONS) flags |= ToolbarIconFlag;
 814     if (tbis_flags & (TBIS_MEDIUM|TBIS_LARGE)) flags |= ToolbarSizeRegularFlag;
 815
 816     [[MMBackend sharedInstance] showToolbar:showit flags:flags];
 817 }
 818
 819
 820
 821
 822 // -- Fonts -----------------------------------------------------------------
 823
 824
 825 /*
 826  * If a font is not going to be used, free its structure.
 827  */
 828     void
 829 gui_mch_free_font(font)
 830     GuiFont     font;
 831 {
 832 }
 833
 834
 835 /*
 836  * Get a font structure for highlighting.
 837  */
 838     GuiFont
 839 gui_mch_get_font(char_u *name, int giveErrorIfMissing)
 840 {
 841     //NSLog(@"gui_mch_get_font(name=%s, giveErrorIfMissing=%d)", name,
 842     //        giveErrorIfMissing);
 843     return 0;
 844 }
 845
 846
 847 #if defined(FEAT_EVAL) || defined(PROTO)
 848 /*
 849  * Return the name of font "font" in allocated memory.
 850  * Don't know how to get the actual name, thus use the provided name.
 851  */
 852     char_u *
 853 gui_mch_get_fontname(GuiFont font, char_u *name)
 854 {
 855     //NSLog(@"gui_mch_get_fontname(font=%d, name=%s)", font, name);
 856     return 0;
 857 }
 858 #endif
 859
 860
 861 /*
 862  * Initialise vim to use the font with the given name.  Return FAIL if the font
 863  * could not be loaded, OK otherwise.
 864  */
 865     int
 866 gui_mch_init_font(char_u *font_name, int fontset)
 867 {
 868     //NSLog(@"gui_mch_init_font(font_name=%s, fontset=%d)", font_name, fontset);
 869
 870     // HACK!  This gets called whenever the user types :set gfn=fontname, so
 871     // for now we set the font here.
 872     // TODO!  Proper font handling, the way Vim expects it.
 873
 874 #if MM_ENABLE_CONV
 875     font_name = CONVERT_TO_UTF8(font_name);
 876 #endif
 877
 878     BOOL ok = [[MMBackend sharedInstance] setFontWithName:(char*)font_name];
 879
 880 #if MM_ENABLE_CONV
 881     CONVERT_TO_UTF8_FREE(font_name);
 882 #endif
 883
 884     return ok;
 885 }
 886
 887
 888 /*
 889  * Set the current text font.
 890  */
 891     void
 892 gui_mch_set_font(GuiFont font)
 893 {
 894 }
 895
 896
 897 // -- Scrollbars ------------------------------------------------------------
 898
 899
 900     void
 901 gui_mch_create_scrollbar(
 902         scrollbar_T *sb,
 903         int orient)     /* SBAR_VERT or SBAR_HORIZ */
 904 {
 905     [[MMBackend sharedInstance]
 906             createScrollbarWithIdentifier:sb->ident type:sb->type];
 907 }
 908
 909
 910     void
 911 gui_mch_destroy_scrollbar(scrollbar_T *sb)
 912 {
 913     [[MMBackend sharedInstance]
 914             destroyScrollbarWithIdentifier:sb->ident];
 915 }
 916
 917
 918     void
 919 gui_mch_enable_scrollbar(
 920         scrollbar_T     *sb,
 921         int             flag)
 922 {
 923     [[MMBackend sharedInstance]
 924             showScrollbarWithIdentifier:sb->ident state:flag];
 925 }
 926
 927
 928     void
 929 gui_mch_set_scrollbar_pos(
 930         scrollbar_T *sb,
 931         int x,
 932         int y,
 933         int w,
 934         int h)
 935 {
 936     int pos = y;
 937     int len = h;
 938     if (SBAR_BOTTOM == sb->type) {
 939         pos = x;
 940         len = w;
 941     }
 942
 943     [[MMBackend sharedInstance]
 944             setScrollbarPosition:pos length:len identifier:sb->ident];
 945 }
 946
 947
 948     void
 949 gui_mch_set_scrollbar_thumb(
 950         scrollbar_T *sb,
 951         long val,
 952         long size,
 953         long max)
 954 {
 955     [[MMBackend sharedInstance]
 956             setScrollbarThumbValue:val size:size max:max identifier:sb->ident];
 957 }
 958
 959
 960 // -- Cursor ----------------------------------------------------------------
 961
 962
 963 /*
 964  * Draw a cursor without focus.
 965  */
 966     void
 967 gui_mch_draw_hollow_cursor(guicolor_T color)
 968 {
 969     return [[MMBackend sharedInstance]
 970         drawCursorAtRow:gui.row column:gui.col shape:MMInsertionPointHollow
 971                fraction:100 color:color];
 972 }
 973
 974
 975 /*
 976  * Draw part of a cursor, only w pixels wide, and h pixels high.
 977  */
 978     void
 979 gui_mch_draw_part_cursor(int w, int h, guicolor_T color)
 980 {
 981     // HACK!  'w' and 'h' are always 1 since we do not tell Vim about the exact
 982     // font dimensions.  Thus these parameters are useless.  Instead we look at
 983     // the shape_table to determine the shape and size of the cursor (just like
 984     // gui_update_cursor() does).
 985     int idx = get_shape_idx(FALSE);
 986     int shape = MMInsertionPointBlock;
 987     switch (shape_table[idx].shape) {
 988         case SHAPE_HOR: shape = MMInsertionPointHorizontal; break;
 989         case SHAPE_VER: shape = MMInsertionPointVertical; break;
 990     }
 991
 992     return [[MMBackend sharedInstance]
 993         drawCursorAtRow:gui.row column:gui.col shape:shape
 994                fraction:shape_table[idx].percentage color:color];
 995 }
 996
 997
 998 /*
 999  * Cursor blink functions.
1000  *
1001  * This is a simple state machine:
1002  * BLINK_NONE   not blinking at all
1003  * BLINK_OFF    blinking, cursor is not shown
1004  * BLINK_ON blinking, cursor is shown
1005  */
1006     void
1007 gui_mch_set_blinking(long wait, long on, long off)
1008 {
1009     [[MMBackend sharedInstance] setBlinkWait:wait on:on off:off];
1010 }
1011
1012
1013 /*
1014  * Start the cursor blinking.  If it was already blinking, this restarts the
1015  * waiting time and shows the cursor.
1016  */
1017     void
1018 gui_mch_start_blink(void)
1019 {
1020     [[MMBackend sharedInstance] startBlink];
1021 }
1022
1023
1024 /*
1025  * Stop the cursor blinking.  Show the cursor if it wasn't shown.
1026  */
1027     void
1028 gui_mch_stop_blink(void)
1029 {
1030     [[MMBackend sharedInstance] stopBlink];
1031 }
1032
1033
1034 // -- Mouse -----------------------------------------------------------------
1035
1036
1037 /*
1038  * Get current mouse coordinates in text window.
1039  */
1040     void
1041 gui_mch_getmouse(int *x, int *y)
1042 {
1043     //NSLog(@"gui_mch_getmouse()");
1044 }
1045
1046
1047     void
1048 gui_mch_setmouse(int x, int y)
1049 {
1050     //NSLog(@"gui_mch_setmouse(x=%d, y=%d)", x, y);
1051 }
1052
1053
1054     void
1055 mch_set_mouse_shape(int shape)
1056 {
1057     [[MMBackend sharedInstance] setMouseShape:shape];
1058 }
1059
1060
1061
1062
1063 // -- Unsorted --------------------------------------------------------------
1064
1065
1066     void
1067 ex_macaction(eap)
1068     exarg_T     *eap;
1069 {
1070     if (!gui.in_use) {
1071         EMSG(_("E???: Command only available in GUI mode"));
1072         return;
1073     }
1074
1075     char_u *arg = eap->arg;
1076 #if MM_ENABLE_CONV
1077     arg = CONVERT_TO_UTF8(arg);
1078 #endif
1079
1080     NSString *name = [NSString stringWithCString:(char*)arg
1081                                         encoding:NSUTF8StringEncoding];
1082     if (gui_macvim_is_valid_action(name)) {
1083         [[MMBackend sharedInstance] executeActionWithName:name];
1084     } else {
1085         EMSG2(_("E???: \"%s\" is not a valid action"), eap->arg);
1086     }
1087
1088 #if MM_ENABLE_CONV
1089     arg = CONVERT_TO_UTF8(arg);
1090 #endif
1091 }
1092
1093
1094 /*
1095  * Adjust gui.char_height (after 'linespace' was changed).
1096  */
1097     int
1098 gui_mch_adjust_charheight(void)
1099 {
1100     [[MMBackend sharedInstance] adjustLinespace:p_linespace];
1101     return OK;
1102 }
1103
1104
1105     void
1106 gui_mch_beep(void)
1107 {
1108 }
1109
1110
1111
1112 #ifdef FEAT_BROWSE
1113 /*
1114  * Pop open a file browser and return the file selected, in allocated memory,
1115  * or NULL if Cancel is hit.
1116  *  saving  - TRUE if the file will be saved to, FALSE if it will be opened.
1117  *  title   - Title message for the file browser dialog.
1118  *  dflt    - Default name of file.
1119  *  ext     - Default extension to be added to files without extensions.
1120  *  initdir - directory in which to open the browser (NULL = current dir)
1121  *  filter  - Filter for matched files to choose from.
1122  *  Has a format like this:
1123  *  "C Files (*.c)\0*.c\0"
1124  *  "All Files\0*.*\0\0"
1125  *  If these two strings were concatenated, then a choice of two file
1126  *  filters will be selectable to the user.  Then only matching files will
1127  *  be shown in the browser.  If NULL, the default allows all files.
1128  *
1129  *  *NOTE* - the filter string must be terminated with TWO nulls.
1130  */
1131     char_u *
1132 gui_mch_browse(
1133     int saving,
1134     char_u *title,
1135     char_u *dflt,
1136     char_u *ext,
1137     char_u *initdir,
1138     char_u *filter)
1139 {
1140     //NSLog(@"gui_mch_browse(saving=%d, title=%s, dflt=%s, ext=%s, initdir=%s,"
1141     //        " filter=%s", saving, title, dflt, ext, initdir, filter);
1142
1143 #if MM_ENABLE_CONV
1144     title = CONVERT_TO_UTF8(title);
1145     initdir = CONVERT_TO_UTF8(initdir);
1146 #endif
1147
1148     char_u *s = (char_u*)[[MMBackend sharedInstance]
1149             browseForFileInDirectory:(char*)initdir title:(char*)title
1150                               saving:saving];
1151
1152 #if MM_ENABLE_CONV
1153     CONVERT_TO_UTF8_FREE(title);
1154     CONVERT_TO_UTF8_FREE(initdir);
1155 #endif
1156
1157     return s;
1158 }
1159 #endif /* FEAT_BROWSE */
1160
1161
1162
1163     int
1164 gui_mch_dialog(
1165     int         type,
1166     char_u      *title,
1167     char_u      *message,
1168     char_u      *buttons,
1169     int         dfltbutton,
1170     char_u      *textfield)
1171 {
1172     //NSLog(@"gui_mch_dialog(type=%d title=%s message=%s buttons=%s "
1173     //        "dfltbutton=%d textfield=%s)", type, title, message, buttons,
1174     //        dfltbutton, textfield);
1175
1176 #if MM_ENABLE_CONV
1177     title = CONVERT_TO_UTF8(title);
1178     message = CONVERT_TO_UTF8(message);
1179     buttons = CONVERT_TO_UTF8(buttons);
1180     textfield = CONVERT_TO_UTF8(textfield);
1181 #endif
1182
1183     int ret = [[MMBackend sharedInstance]
1184             presentDialogWithType:type
1185                             title:(char*)title
1186                           message:(char*)message
1187                           buttons:(char*)buttons
1188                         textField:(char*)textfield];
1189
1190 #if MM_ENABLE_CONV
1191     CONVERT_TO_UTF8_FREE(title);
1192     CONVERT_TO_UTF8_FREE(message);
1193     CONVERT_TO_UTF8_FREE(buttons);
1194     CONVERT_TO_UTF8_FREE(textfield);
1195 #endif
1196
1197     return ret;
1198 }
1199
1200
1201     void
1202 gui_mch_flash(int msec)
1203 {
1204 }
1205
1206
1207 /*
1208  * Return the Pixel value (color) for the given color name.  This routine was
1209  * pretty much taken from example code in the Silicon Graphics OSF/Motif
1210  * Programmer's Guide.
1211  * Return INVALCOLOR when failed.
1212  */
1213     guicolor_T
1214 gui_mch_get_color(char_u *name)
1215 {
1216 #if MM_ENABLE_CONV
1217     name = CONVERT_TO_UTF8(name);
1218 #endif
1219
1220     NSString *key = [NSString stringWithUTF8String:(char*)name];
1221     guicolor_T col = [[MMBackend sharedInstance] lookupColorWithKey:key];
1222
1223 #if MM_ENABLE_CONV
1224     CONVERT_TO_UTF8_FREE(name);
1225 #endif
1226
1227     return col;
1228 }
1229
1230
1231 /*
1232  * Return the RGB value of a pixel as long.
1233  */
1234     long_u
1235 gui_mch_get_rgb(guicolor_T pixel)
1236 {
1237     // This is only implemented so that vim can guess the correct value for
1238     // 'background' (which otherwise defaults to 'dark'); it is not used for
1239     // anything else (as far as I know).
1240     // The implementation is simple since colors are stored in an int as
1241     // "rrggbb".
1242     return pixel;
1243 }
1244
1245
1246 /*
1247  * Get the screen dimensions.
1248  * Allow 10 pixels for horizontal borders, 40 for vertical borders.
1249  * Is there no way to find out how wide the borders really are?
1250  * TODO: Add live udate of those value on suspend/resume.
1251  */
1252     void
1253 gui_mch_get_screen_dimensions(int *screen_w, int *screen_h)
1254 {
1255     //NSLog(@"gui_mch_get_screen_dimensions()");
1256     *screen_w = Columns;
1257     *screen_h = Rows;
1258 }
1259
1260
1261 /*
1262  * Get the position of the top left corner of the window.
1263  */
1264     int
1265 gui_mch_get_winpos(int *x, int *y)
1266 {
1267     *x = *y = 0;
1268     return OK;
1269 }
1270
1271
1272 /*
1273  * Return OK if the key with the termcap name "name" is supported.
1274  */
1275     int
1276 gui_mch_haskey(char_u *name)
1277 {
1278     BOOL ok = NO;
1279
1280 #if MM_ENABLE_CONV
1281     name = CONVERT_TO_UTF8(name);
1282 #endif
1283
1284     NSString *value = [NSString stringWithUTF8String:(char*)name];
1285     if (value)
1286         ok =  [[MMBackend sharedInstance] hasSpecialKeyWithValue:value];
1287
1288 #if MM_ENABLE_CONV
1289     CONVERT_TO_UTF8_FREE(name);
1290 #endif
1291
1292     return ok;
1293 }
1294
1295
1296 /*
1297  * Iconify the GUI window.
1298  */
1299     void
1300 gui_mch_iconify(void)
1301 {
1302 }
1303
1304
1305 /*
1306  * Invert a rectangle from row r, column c, for nr rows and nc columns.
1307  */
1308     void
1309 gui_mch_invert_rectangle(int r, int c, int nr, int nc)
1310 {
1311 }
1312
1313
1314 #if defined(FEAT_EVAL) || defined(PROTO)
1315 /*
1316  * Bring the Vim window to the foreground.
1317  */
1318     void
1319 gui_mch_set_foreground(void)
1320 {
1321     [[MMBackend sharedInstance] activate];
1322 }
1323 #endif
1324
1325
1326
1327     void
1328 gui_mch_set_shellsize(
1329     int         width,
1330     int         height,
1331     int         min_width,
1332     int         min_height,
1333     int         base_width,
1334     int         base_height,
1335     int         direction)
1336 {
1337     //NSLog(@"gui_mch_set_shellsize(width=%d, height=%d, min_width=%d,"
1338     //        " min_height=%d, base_width=%d, base_height=%d, direction=%d)",
1339     //        width, height, min_width, min_height, base_width, base_height,
1340     //        direction);
1341     [[MMBackend sharedInstance] setRows:height columns:width];
1342 }
1343
1344
1345     void
1346 gui_mch_set_text_area_pos(int x, int y, int w, int h)
1347 {
1348 }
1349
1350 /*
1351  * Set the position of the top left corner of the window to the given
1352  * coordinates.
1353  */
1354     void
1355 gui_mch_set_winpos(int x, int y)
1356 {
1357 }
1358
1359
1360 #ifdef FEAT_TITLE
1361 /*
1362  * Set the window title and icon.
1363  * (The icon is not taken care of).
1364  */
1365     void
1366 gui_mch_settitle(char_u *title, char_u *icon)
1367 {
1368     //NSLog(@"gui_mch_settitle(title=%s, icon=%s)", title, icon);
1369
1370 #if MM_ENABLE_CONV
1371     title = CONVERT_TO_UTF8(title);
1372 #endif
1373
1374     [[MMBackend sharedInstance] setWindowTitle:(char*)title];
1375
1376 #if MM_ENABLE_CONV
1377     CONVERT_TO_UTF8_FREE(title);
1378 #endif
1379 }
1380 #endif
1381
1382
1383     void
1384 gui_mch_toggle_tearoffs(int enable)
1385 {
1386 }
1387
1388
1389     static BOOL
1390 gui_macvim_is_valid_action(NSString *action)
1391 {
1392     static NSDictionary *actionDict = nil;
1393
1394     if (!actionDict) {
1395         NSBundle *mainBundle = [NSBundle mainBundle];
1396         NSString *path = [mainBundle pathForResource:@"Actions"
1397                                               ofType:@"plist"];
1398         if (path) {
1399             actionDict = [[NSDictionary alloc] initWithContentsOfFile:path];
1400         } else {
1401             // Allocate bogus dictionary so that error only pops up once.
1402             actionDict = [NSDictionary new];
1403             EMSG(_("E???: Failed to load action dictionary"));
1404         }
1405     }
1406
1407     return [actionDict objectForKey:action] != nil;
1408 }
1409
1410
1411     void
1412 gui_mch_enter_fullscreen()
1413 {
1414     [[MMBackend sharedInstance] enterFullscreen];
1415 }
1416
1417
1418     void
1419 gui_mch_leave_fullscreen()
1420 {
1421     [[MMBackend sharedInstance] leaveFullscreen];
1422 }
1423
1424
1425     void
1426 gui_macvim_update_modified_flag()
1427 {
1428     [[MMBackend sharedInstance] updateModifiedFlag];
1429 }
1430
1431
1432
1433
1434 // -- Client/Server ---------------------------------------------------------
1435
1436 #ifdef MAC_CLIENTSERVER
1437
1438 //
1439 // NOTE: Client/Server is only fully supported with a GUI.  Theoretically it
1440 // would be possible to make the server code work with terminal Vim, but it
1441 // would require that a run-loop is set up and checked.  This should not be
1442 // difficult to implement, simply call gui_mch_update() at opportune moments
1443 // and it will take care of the run-loop.  Another (bigger) problem with
1444 // supporting servers in terminal mode is that the server listing code talks to
1445 // MacVim (the GUI) to figure out which servers are running.
1446 //
1447
1448
1449 /*
1450  * Register connection with 'name'.  The actual connection is named something
1451  * like 'org.vim.MacVim.VIM3', whereas the server is called 'VIM3'.
1452  */
1453     void
1454 serverRegisterName(char_u *name)
1455 {
1456 #if MM_ENABLE_CONV
1457     name = CONVERT_TO_UTF8(name);
1458 #endif
1459
1460     NSString *svrName = [NSString stringWithUTF8String:(char*)name];
1461     [[MMBackend sharedInstance] registerServerWithName:svrName];
1462
1463 #if MM_ENABLE_CONV
1464     CONVERT_TO_UTF8_FREE(name);
1465 #endif
1466 }
1467
1468
1469 /*
1470  * Send to an instance of Vim.
1471  * Returns 0 for OK, negative for an error.
1472  */
1473     int
1474 serverSendToVim(char_u *name, char_u *cmd, char_u **result,
1475         int *port, int asExpr, int silent)
1476 {
1477 #if MM_ENABLE_CONV
1478     name = CONVERT_TO_UTF8(name);
1479     cmd = CONVERT_TO_UTF8(cmd);
1480 #endif
1481
1482     BOOL ok = [[MMBackend sharedInstance]
1483             sendToServer:[NSString stringWithUTF8String:(char*)name]
1484                   string:[NSString stringWithUTF8String:(char*)cmd]
1485                    reply:result
1486                     port:port
1487               expression:asExpr
1488                   silent:silent];
1489
1490 #if MM_ENABLE_CONV
1491     CONVERT_TO_UTF8_FREE(name);
1492     CONVERT_TO_UTF8_FREE(cmd);
1493 #endif
1494
1495     return ok ? 0 : -1;
1496 }
1497
1498
1499 /*
1500  * Ask MacVim for the names of all Vim servers.
1501  */
1502     char_u *
1503 serverGetVimNames(void)
1504 {
1505     char_u *names = NULL;
1506     NSArray *list = [[MMBackend sharedInstance] serverList];
1507
1508     if (list) {
1509         NSString *string = [list componentsJoinedByString:@"\n"];
1510         char_u *s = (char_u*)[string UTF8String];
1511 #if MM_ENABLE_CONV
1512         s = CONVERT_FROM_UTF8(s);
1513 #endif
1514         names = vim_strsave(s);
1515 #if MM_ENABLE_CONV
1516         CONVERT_FROM_UTF8_FREE(s);
1517 #endif
1518     }
1519
1520     return names;
1521 }
1522
1523
1524 /*
1525  * 'str' is a hex int representing the send port of the connection.
1526  */
1527     int
1528 serverStrToPort(char_u *str)
1529 {
1530     int port = 0;
1531
1532     sscanf((char *)str, "0x%x", &port);
1533     if (!port)
1534         EMSG2(_("E573: Invalid server id used: %s"), str);
1535
1536     return port;
1537 }
1538
1539
1540 /*
1541  * Check for replies from server with send port 'port'.
1542  * Return TRUE and a non-malloc'ed string if there is.  Else return FALSE.
1543  */
1544     int
1545 serverPeekReply(int port, char_u **str)
1546 {
1547     NSString *reply = [[MMBackend sharedInstance] peekForReplyOnPort:port];
1548     int len = [reply lengthOfBytesUsingEncoding:NSUTF8StringEncoding];
1549
1550     if (str && len > 0) {
1551         *str = (char_u*)[reply UTF8String];
1552
1553 #if MM_ENABLE_CONV
1554         if (input_conv.vc_type != CONV_NONE) {
1555             char_u *s = string_convert(&input_conv, *str, &len);
1556
1557             if (len > 0) {
1558                 // HACK! Since 's' needs to be freed we cannot simply set
1559                 // '*str = s' or memory will leak.  Instead, create a dummy
1560                 // NSData and return its 'bytes' pointer, then autorelease the
1561                 // NSData.
1562                 NSData *data = [NSData dataWithBytes:s length:len+1];
1563                 *str = (char_u*)[data bytes];
1564             }
1565
1566             vim_free(s);
1567         }
1568 #endif
1569     }
1570
1571     return reply != nil;
1572 }
1573
1574
1575 /*
1576  * Wait for replies from server with send port 'port'.
1577  * Return 0 and the malloc'ed string when a reply is available.
1578  * Return -1 on error.
1579  */
1580     int
1581 serverReadReply(int port, char_u **str)
1582 {
1583     NSString *reply = [[MMBackend sharedInstance] waitForReplyOnPort:port];
1584     if (reply && str) {
1585         char_u *s = (char_u*)[reply UTF8String];
1586 #if MM_ENABLE_CONV
1587         s = CONVERT_FROM_UTF8(s);
1588 #endif
1589         *str = vim_strsave(s);
1590 #if MM_ENABLE_CONV
1591         CONVERT_FROM_UTF8_FREE(s);
1592 #endif
1593         return 0;
1594     }
1595
1596     return -1;
1597 }
1598
1599
1600 /*
1601  * Send a reply string (notification) to client with port given by "serverid".
1602  * Return -1 if the window is invalid.
1603  */
1604     int
1605 serverSendReply(char_u *serverid, char_u *reply)
1606 {
1607     int retval = -1;
1608     int port = serverStrToPort(serverid);
1609     if (port > 0 && reply) {
1610 #if MM_ENABLE_CONV
1611         reply = CONVERT_TO_UTF8(reply);
1612 #endif
1613         BOOL ok = [[MMBackend sharedInstance]
1614                 sendReply:[NSString stringWithUTF8String:(char*)reply]
1615                    toPort:port];
1616         retval = ok ? 0 : -1;
1617 #if MM_ENABLE_CONV
1618         CONVERT_TO_UTF8_FREE(reply);
1619 #endif
1620     }
1621
1622     return retval;
1623 }
1624
1625 #endif // MAC_CLIENTSERVER