src/MacVim/MMAppController.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  * MMAppController
  12  *
  13  * MMAppController is the delegate of NSApp and as such handles file open
  14  * requests, application termination, etc.  It sets up a named NSConnection on
  15  * which it listens to incoming connections from Vim processes.  It also
  16  * coordinates all MMVimControllers.
  17  *
  18  * A new Vim process is started by calling launchVimProcessWithArguments:.
  19  * When the Vim process is initialized it notifies the app controller by
  20  * sending a connectBackend:pid: message.  At this point a new MMVimController
  21  * is allocated.  Afterwards, the Vim process communicates directly with its
  22  * MMVimController.
  23  *
  24  * A Vim process started from the command line connects directly by sending the
  25  * connectBackend:pid: message (launchVimProcessWithArguments: is never called
  26  * in this case).
  27  */
  28
  29 #import "MMAppController.h"
  30 #import "MMVimController.h"
  31 #import "MMWindowController.h"
  32
  33
  34
  35 // Default timeout intervals on all connections.
  36 static NSTimeInterval MMRequestTimeout = 5;
  37 static NSTimeInterval MMReplyTimeout = 5;
  38
  39
  40
  41 @interface MMAppController (MMServices)
  42 - (void)openSelection:(NSPasteboard *)pboard userData:(NSString *)userData
  43                 error:(NSString **)error;
  44 - (void)openFile:(NSPasteboard *)pboard userData:(NSString *)userData
  45            error:(NSString **)error;
  46 @end
  47
  48
  49 @interface MMAppController (Private)
  50 - (MMVimController *)keyVimController;
  51 - (MMVimController *)topmostVimController;
  52 - (void)launchVimProcessWithArguments:(NSArray *)args;
  53 - (NSArray *)filterFilesAndNotify:(NSArray *)files;
  54 - (NSArray *)filterOpenFilesAndRaiseFirst:(NSArray *)filenames;
  55 @end
  56
  57 @interface NSMenu (MMExtras)
  58 - (void)recurseSetAutoenablesItems:(BOOL)on;
  59 @end
  60
  61 @interface NSNumber (MMExtras)
  62 - (int)tag;
  63 @end
  64
  65
  66
  67 @implementation MMAppController
  68
  69 + (void)initialize
  70 {
  71     NSDictionary *dict = [NSDictionary dictionaryWithObjectsAndKeys:
  72         [NSNumber numberWithBool:NO],   MMNoWindowKey,
  73         [NSNumber numberWithInt:64],    MMTabMinWidthKey,
  74         [NSNumber numberWithInt:6*64],  MMTabMaxWidthKey,
  75         [NSNumber numberWithInt:132],   MMTabOptimumWidthKey,
  76         [NSNumber numberWithInt:2],     MMTextInsetLeftKey,
  77         [NSNumber numberWithInt:1],     MMTextInsetRightKey,
  78         [NSNumber numberWithInt:1],     MMTextInsetTopKey,
  79         [NSNumber numberWithInt:1],     MMTextInsetBottomKey,
  80         [NSNumber numberWithBool:NO],   MMTerminateAfterLastWindowClosedKey,
  81         @"MMTypesetter",                MMTypesetterKey,
  82         [NSNumber numberWithFloat:1],   MMCellWidthMultiplierKey,
  83         [NSNumber numberWithFloat:-1],  MMBaselineOffsetKey,
  84         [NSNumber numberWithBool:YES],  MMTranslateCtrlClickKey,
  85         [NSNumber numberWithBool:NO],   MMOpenFilesInTabsKey,
  86         [NSNumber numberWithBool:NO],   MMNoFontSubstitutionKey,
  87         [NSNumber numberWithBool:YES],  MMLoginShellKey,
  88         nil];
  89
  90     [[NSUserDefaults standardUserDefaults] registerDefaults:dict];
  91
  92     NSArray *types = [NSArray arrayWithObject:NSStringPboardType];
  93     [NSApp registerServicesMenuSendTypes:types returnTypes:types];
  94 }
  95
  96 - (id)init
  97 {
  98     if ((self = [super init])) {
  99         fontContainerRef = loadFonts();
 100
 101         vimControllers = [NSMutableArray new];
 102
 103         // NOTE!  If the name of the connection changes here it must also be
 104         // updated in MMBackend.m.
 105         NSConnection *connection = [NSConnection defaultConnection];
 106         NSString *name = [NSString stringWithFormat:@"%@-connection",
 107                  [[NSBundle mainBundle] bundleIdentifier]];
 108         //NSLog(@"Registering connection with name '%@'", name);
 109         if ([connection registerName:name]) {
 110             [connection setRequestTimeout:MMRequestTimeout];
 111             [connection setReplyTimeout:MMReplyTimeout];
 112             [connection setRootObject:self];
 113
 114             // NOTE: When the user is resizing the window the AppKit puts the
 115             // run loop in event tracking mode.  Unless the connection listens
 116             // to request in this mode, live resizing won't work.
 117             [connection addRequestMode:NSEventTrackingRunLoopMode];
 118         } else {
 119             NSLog(@"WARNING: Failed to register connection with name '%@'",
 120                     name);
 121         }
 122     }
 123
 124     return self;
 125 }
 126
 127 - (void)dealloc
 128 {
 129     //NSLog(@"MMAppController dealloc");
 130
 131     [vimControllers release];
 132     [openSelectionString release];
 133
 134     [super dealloc];
 135 }
 136
 137 - (void)applicationDidFinishLaunching:(NSNotification *)notification
 138 {
 139     [NSApp setServicesProvider:self];
 140 }
 141
 142 - (BOOL)applicationShouldOpenUntitledFile:(NSApplication *)sender
 143 {
 144     // NOTE!  This way it possible to start the app with the command-line
 145     // argument '-nowindow yes' and no window will be opened by default.
 146     untitledWindowOpening =
 147         ![[NSUserDefaults standardUserDefaults] boolForKey:MMNoWindowKey];
 148     return untitledWindowOpening;
 149 }
 150
 151 - (BOOL)applicationOpenUntitledFile:(NSApplication *)sender
 152 {
 153     //NSLog(@"%s NSapp=%@ theApp=%@", _cmd, NSApp, sender);
 154
 155     [self newWindow:self];
 156     return YES;
 157 }
 158
 159 - (void)application:(NSApplication *)sender openFiles:(NSArray *)filenames
 160 {
 161     filenames = [self filterOpenFilesAndRaiseFirst:filenames];
 162     if ([filenames count]) {
 163         MMVimController *vc;
 164         BOOL openInTabs = [[NSUserDefaults standardUserDefaults]
 165             boolForKey:MMOpenFilesInTabsKey];
 166
 167         if (openInTabs && (vc = [self topmostVimController])) {
 168             [vc dropFiles:filenames];
 169         } else {
 170             NSMutableArray *args = [NSMutableArray arrayWithObject:@"-p"];
 171             [args addObjectsFromArray:filenames];
 172             [self launchVimProcessWithArguments:args];
 173         }
 174     }
 175
 176     [NSApp replyToOpenOrPrint:NSApplicationDelegateReplySuccess];
 177     // NSApplicationDelegateReplySuccess = 0,
 178     // NSApplicationDelegateReplyCancel = 1,
 179     // NSApplicationDelegateReplyFailure = 2
 180 }
 181
 182 - (BOOL)applicationShouldTerminateAfterLastWindowClosed:(NSApplication *)sender
 183 {
 184     return [[NSUserDefaults standardUserDefaults]
 185             boolForKey:MMTerminateAfterLastWindowClosedKey];
 186 }
 187
 188 - (NSApplicationTerminateReply)applicationShouldTerminate:
 189     (NSApplication *)sender
 190 {
 191     // TODO: Follow Apple's guidelines for 'Graceful Application Termination'
 192     // (in particular, allow user to review changes and save).
 193     int reply = NSTerminateNow;
 194     BOOL modifiedBuffers = NO;
 195
 196     // Go through windows, checking for modified buffers.  (Each Vim process
 197     // tells MacVim when any buffer has been modified and MacVim sets the
 198     // 'documentEdited' flag of the window correspondingly.)
 199     NSEnumerator *e = [[NSApp windows] objectEnumerator];
 200     id window;
 201     while (window = [e nextObject]) {
 202         if ([window isDocumentEdited]) {
 203             modifiedBuffers = YES;
 204             break;
 205         }
 206     }
 207
 208     if (modifiedBuffers) {
 209         NSAlert *alert = [[NSAlert alloc] init];
 210         [alert addButtonWithTitle:@"Quit"];
 211         [alert addButtonWithTitle:@"Cancel"];
 212         [alert setMessageText:@"Quit without saving?"];
 213         [alert setInformativeText:@"There are modified buffers, "
 214             "if you quit now all changes will be lost.  Quit anyway?"];
 215         [alert setAlertStyle:NSWarningAlertStyle];
 216
 217         if ([alert runModal] != NSAlertFirstButtonReturn)
 218             reply = NSTerminateCancel;
 219
 220         [alert release];
 221     }
 222
 223     return reply;
 224 }
 225
 226 - (void)applicationWillTerminate:(NSNotification *)aNotification
 227 {
 228     // This will invalidate all connections (since they were spawned from the
 229     // default connection).
 230     [[NSConnection defaultConnection] invalidate];
 231
 232     // Send a SIGINT to all running Vim processes, so that they are sure to
 233     // receive the connectionDidDie: notification (a process has to be checking
 234     // the run-loop for this to happen).
 235     unsigned i, count = [vimControllers count];
 236     for (i = 0; i < count; ++i) {
 237         MMVimController *controller = [vimControllers objectAtIndex:i];
 238         int pid = [controller pid];
 239         if (pid > 0)
 240             kill(pid, SIGINT);
 241     }
 242
 243     if (fontContainerRef) {
 244         ATSFontDeactivate(fontContainerRef, NULL, kATSOptionFlagsDefault);
 245         fontContainerRef = 0;
 246     }
 247
 248     // TODO: Is this a correct way of releasing the MMAppController?
 249     // (It doesn't seem like dealloc is ever called.)
 250     [NSApp setDelegate:nil];
 251     [self autorelease];
 252 }
 253
 254 - (void)removeVimController:(id)controller
 255 {
 256     //NSLog(@"%s%@", _cmd, controller);
 257
 258     [[controller windowController] close];
 259
 260     [vimControllers removeObject:controller];
 261
 262     if (![vimControllers count]) {
 263         // Turn on autoenabling of menus (because no Vim is open to handle it),
 264         // but do not touch the MacVim menu.  Note that the menus must be
 265         // enabled first otherwise autoenabling does not work.
 266         NSMenu *mainMenu = [NSApp mainMenu];
 267         int i, count = [mainMenu numberOfItems];
 268         for (i = 1; i < count; ++i) {
 269             NSMenuItem *item = [mainMenu itemAtIndex:i];
 270             [item setEnabled:YES];
 271             [[item submenu] recurseSetAutoenablesItems:YES];
 272         }
 273     }
 274 }
 275
 276 - (void)windowControllerWillOpen:(MMWindowController *)windowController
 277 {
 278     NSPoint topLeft = NSZeroPoint;
 279     NSWindow *keyWin = [NSApp keyWindow];
 280     NSWindow *win = [windowController window];
 281
 282     if (!win) return;
 283
 284     // If there is a key window, cascade from it, otherwise use the autosaved
 285     // window position (if any).
 286     if (keyWin) {
 287         NSRect frame = [keyWin frame];
 288         topLeft = NSMakePoint(frame.origin.x, NSMaxY(frame));
 289     } else {
 290         NSString *topLeftString = [[NSUserDefaults standardUserDefaults]
 291             stringForKey:MMTopLeftPointKey];
 292         if (topLeftString)
 293             topLeft = NSPointFromString(topLeftString);
 294     }
 295
 296     if (!NSEqualPoints(topLeft, NSZeroPoint)) {
 297         if (keyWin)
 298             topLeft = [win cascadeTopLeftFromPoint:topLeft];
 299
 300         [win setFrameTopLeftPoint:topLeft];
 301     }
 302
 303     if (openSelectionString) {
 304         // There is some text to paste into this window as a result of the
 305         // services menu "Open selection ..." being used.
 306         [[windowController vimController] dropString:openSelectionString];
 307         [openSelectionString release];
 308         openSelectionString = nil;
 309     }
 310 }
 311
 312 - (IBAction)newWindow:(id)sender
 313 {
 314     [self launchVimProcessWithArguments:nil];
 315 }
 316
 317 - (IBAction)selectNextWindow:(id)sender
 318 {
 319     unsigned i, count = [vimControllers count];
 320     if (!count) return;
 321
 322     NSWindow *keyWindow = [NSApp keyWindow];
 323     for (i = 0; i < count; ++i) {
 324         MMVimController *vc = [vimControllers objectAtIndex:i];
 325         if ([[[vc windowController] window] isEqual:keyWindow])
 326             break;
 327     }
 328
 329     if (i < count) {
 330         if (++i >= count)
 331             i = 0;
 332         MMVimController *vc = [vimControllers objectAtIndex:i];
 333         [[vc windowController] showWindow:self];
 334     }
 335 }
 336
 337 - (IBAction)selectPreviousWindow:(id)sender
 338 {
 339     unsigned i, count = [vimControllers count];
 340     if (!count) return;
 341
 342     NSWindow *keyWindow = [NSApp keyWindow];
 343     for (i = 0; i < count; ++i) {
 344         MMVimController *vc = [vimControllers objectAtIndex:i];
 345         if ([[[vc windowController] window] isEqual:keyWindow])
 346             break;
 347     }
 348
 349     if (i < count) {
 350         if (i > 0) {
 351             --i;
 352         } else {
 353             i = count - 1;
 354         }
 355         MMVimController *vc = [vimControllers objectAtIndex:i];
 356         [[vc windowController] showWindow:self];
 357     }
 358 }
 359
 360 - (IBAction)fontSizeUp:(id)sender
 361 {
 362     [[NSFontManager sharedFontManager] modifyFont:
 363             [NSNumber numberWithInt:NSSizeUpFontAction]];
 364 }
 365
 366 - (IBAction)fontSizeDown:(id)sender
 367 {
 368     [[NSFontManager sharedFontManager] modifyFont:
 369             [NSNumber numberWithInt:NSSizeDownFontAction]];
 370 }
 371
 372 - (byref id <MMFrontendProtocol>)
 373     connectBackend:(byref in id <MMBackendProtocol>)backend
 374                pid:(int)pid
 375 {
 376     //NSLog(@"Frontend got connection request from backend...adding new "
 377     //        "MMVimController");
 378
 379     [(NSDistantObject*)backend
 380             setProtocolForProxy:@protocol(MMBackendProtocol)];
 381
 382     MMVimController *vc = [[[MMVimController alloc]
 383             initWithBackend:backend pid:pid] autorelease];
 384
 385     if (![vimControllers count]) {
 386         // The first window autosaves its position.  (The autosaving features
 387         // of Cocoa are not used because we need more control over what is
 388         // autosaved and when it is restored.)
 389         [[vc windowController] setWindowAutosaveKey:MMTopLeftPointKey];
 390     }
 391
 392     [vimControllers addObject:vc];
 393
 394     // HACK!  MacVim does not get activated if it is launched from the
 395     // terminal, so we forcibly activate here unless it is an untitled window
 396     // opening (i.e. MacVim was opened from the Finder).  Untitled windows are
 397     // treated differently, else MacVim would steal the focus if another app
 398     // was activated while the untitled window was loading.
 399     if (!untitledWindowOpening)
 400         [NSApp activateIgnoringOtherApps:YES];
 401
 402     untitledWindowOpening = NO;
 403
 404     NSLog(@"connectBackend:pid: done.");
 405     return vc;
 406 }
 407
 408 - (NSArray *)serverList
 409 {
 410     NSMutableArray *array = [NSMutableArray array];
 411
 412     unsigned i, count = [vimControllers count];
 413     for (i = 0; i < count; ++i) {
 414         MMVimController *controller = [vimControllers objectAtIndex:i];
 415         if ([controller serverName])
 416             [array addObject:[controller serverName]];
 417     }
 418
 419     return array;
 420 }
 421
 422 @end // MMAppController
 423
 424
 425
 426
 427 @implementation MMAppController (MMServices)
 428
 429 - (void)openSelection:(NSPasteboard *)pboard userData:(NSString *)userData
 430                 error:(NSString **)error
 431 {
 432     if (![[pboard types] containsObject:NSStringPboardType]) {
 433         NSLog(@"WARNING: Pasteboard contains no object of type "
 434                 "NSStringPboardType");
 435         return;
 436     }
 437
 438     MMVimController *vc = [self topmostVimController];
 439     if (vc) {
 440         // Open a new tab first, since dropString: does not do this.
 441         [vc sendMessage:AddNewTabMsgID data:nil];
 442         [vc dropString:[pboard stringForType:NSStringPboardType]];
 443     } else {
 444         // NOTE: There is no window to paste the selection into, so save the
 445         // text, open a new window, and paste the text when the next window
 446         // opens.  (If this is called several times in a row, then all but the
 447         // last call might be ignored.)
 448         if (openSelectionString) [openSelectionString release];
 449         openSelectionString = [[pboard stringForType:NSStringPboardType] copy];
 450
 451         [self newWindow:self];
 452     }
 453 }
 454
 455 - (void)openFile:(NSPasteboard *)pboard userData:(NSString *)userData
 456            error:(NSString **)error
 457 {
 458     if (![[pboard types] containsObject:NSStringPboardType]) {
 459         NSLog(@"WARNING: Pasteboard contains no object of type "
 460                 "NSStringPboardType");
 461         return;
 462     }
 463
 464     // TODO: Parse multiple filenames and create array with names.
 465     NSString *string = [pboard stringForType:NSStringPboardType];
 466     string = [string stringByTrimmingCharactersInSet:
 467             [NSCharacterSet whitespaceAndNewlineCharacterSet]];
 468     string = [string stringByStandardizingPath];
 469
 470     NSArray *filenames = [self filterFilesAndNotify:
 471             [NSArray arrayWithObject:string]];
 472     if ([filenames count] > 0) {
 473         MMVimController *vc = nil;
 474         if (userData && [userData isEqual:@"Tab"])
 475             vc = [self topmostVimController];
 476
 477         if (vc) {
 478             [vc dropFiles:filenames];
 479         } else {
 480             [self application:NSApp openFiles:filenames];
 481         }
 482     }
 483 }
 484
 485 @end // MMAppController (MMServices)
 486
 487
 488
 489
 490 @implementation MMAppController (Private)
 491
 492 - (MMVimController *)keyVimController
 493 {
 494     NSWindow *keyWindow = [NSApp keyWindow];
 495     if (keyWindow) {
 496         unsigned i, count = [vimControllers count];
 497         for (i = 0; i < count; ++i) {
 498             MMVimController *vc = [vimControllers objectAtIndex:i];
 499             if ([[[vc windowController] window] isEqual:keyWindow])
 500                 return vc;
 501         }
 502     }
 503
 504     return nil;
 505 }
 506
 507 - (MMVimController *)topmostVimController
 508 {
 509     NSArray *windows = [NSApp orderedWindows];
 510     if ([windows count] > 0) {
 511         NSWindow *window = [windows objectAtIndex:0];
 512         unsigned i, count = [vimControllers count];
 513         for (i = 0; i < count; ++i) {
 514             MMVimController *vc = [vimControllers objectAtIndex:i];
 515             if ([[[vc windowController] window] isEqual:window])
 516                 return vc;
 517         }
 518     }
 519
 520     return nil;
 521 }
 522
 523 - (void)launchVimProcessWithArguments:(NSArray *)args
 524 {
 525     NSString *taskPath = nil;
 526     NSArray *taskArgs = nil;
 527     NSString *path = [[NSBundle mainBundle] pathForAuxiliaryExecutable:@"Vim"];
 528
 529     if (!path) {
 530         NSLog(@"ERROR: Vim executable could not be found inside app bundle!");
 531         return;
 532     }
 533
 534     if ([[NSUserDefaults standardUserDefaults] boolForKey:MMLoginShellKey]) {
 535         // Run process with a login shell
 536         //   $SHELL -l -c "exec Vim args"
 537
 538         NSMutableString *execArg = [NSMutableString
 539             stringWithFormat:@"exec \"%@\" -g", path];
 540         if (args) {
 541             // Append all arguments while making sure that arguments containing
 542             // spaces are enclosed in quotes.
 543             NSCharacterSet *space = [NSCharacterSet whitespaceCharacterSet];
 544             unsigned i, count = [args count];
 545
 546             for (i = 0; i < count; ++i) {
 547                 NSString *arg = [args objectAtIndex:i];
 548                 if (NSNotFound != [arg rangeOfCharacterFromSet:space].location)
 549                     [execArg appendFormat:@" \"%@\"", arg];
 550                 else
 551                     [execArg appendFormat:@" %@", arg];
 552             }
 553         }
 554
 555         // Launch the process with a login shell so that users environment
 556         // settings get sourced.  This does not always happen when MacVim is
 557         // started.
 558         taskArgs = [NSArray arrayWithObjects:@"-l", @"-c", execArg, nil];
 559         taskPath = [[[NSProcessInfo processInfo] environment]
 560             objectForKey:@"SHELL"];
 561         if (!taskPath)
 562             taskPath = @"/bin/sh";
 563     } else {
 564         // Run process directly:
 565         //   Vim args
 566         taskPath = path;
 567         taskArgs = [NSArray arrayWithObject:@"-g"];
 568         if (args)
 569             taskArgs = [taskArgs arrayByAddingObjectsFromArray:args];
 570     }
 571
 572     //NSLog(@"Launching: %@  args: %@", taskPath, taskArgs);
 573     [NSTask launchedTaskWithLaunchPath:taskPath arguments:taskArgs];
 574 }
 575
 576 - (NSArray *)filterFilesAndNotify:(NSArray *)filenames
 577 {
 578     // Go trough 'filenames' array and make sure each file exists.  Present
 579     // warning dialog if some file was missing.
 580
 581     NSString *firstMissingFile = nil;
 582     NSMutableArray *files = [NSMutableArray array];
 583     unsigned i, count = [filenames count];
 584
 585     for (i = 0; i < count; ++i) {
 586         NSString *name = [filenames objectAtIndex:i];
 587         if ([[NSFileManager defaultManager] fileExistsAtPath:name]) {
 588             [files addObject:name];
 589         } else if (!firstMissingFile) {
 590             firstMissingFile = name;
 591         }
 592     }
 593
 594     if (firstMissingFile) {
 595         NSAlert *alert = [[NSAlert alloc] init];
 596         [alert addButtonWithTitle:@"OK"];
 597
 598         NSString *text;
 599         if ([files count] >= count-1) {
 600             [alert setMessageText:@"File not found"];
 601             text = [NSString stringWithFormat:@"Could not open file with "
 602                 "name %@.", firstMissingFile];
 603         } else {
 604             [alert setMessageText:@"Multiple files not found"];
 605             text = [NSString stringWithFormat:@"Could not open file with "
 606                 "name %@, and %d other files.", firstMissingFile,
 607                 count-[files count]-1];
 608         }
 609
 610         [alert setInformativeText:text];
 611         [alert setAlertStyle:NSWarningAlertStyle];
 612
 613         [alert runModal];
 614         [alert release];
 615
 616         [NSApp replyToOpenOrPrint:NSApplicationDelegateReplyFailure];
 617     }
 618
 619     return files;
 620 }
 621
 622 - (NSArray *)filterOpenFilesAndRaiseFirst:(NSArray *)filenames
 623 {
 624     // Check if any of the files in the 'filenames' array are open in any Vim
 625     // process.  Remove the files that are open from the 'filenames' array and
 626     // return it.  If all files were filtered out, then raise the first file in
 627     // the Vim process it is open.
 628
 629     MMVimController *raiseController = nil;
 630     NSString *raiseFile = nil;
 631     NSMutableArray *files = [filenames mutableCopy];
 632     NSString *expr = [NSString stringWithFormat:
 633             @"map([\"%@\"],\"bufloaded(v:val)\")",
 634             [files componentsJoinedByString:@"\",\""]];
 635     unsigned i, count = [vimControllers count];
 636
 637     for (i = 0; i < count && [files count]; ++i) {
 638         MMVimController *controller = [vimControllers objectAtIndex:i];
 639         id proxy = [controller backendProxy];
 640
 641         @try {
 642             NSString *eval = [proxy evaluateExpression:expr];
 643             NSIndexSet *idxSet = [NSIndexSet indexSetWithVimList:eval];
 644             if ([idxSet count]) {
 645                 if (!raiseFile) {
 646                     // Remember the file and which Vim that has it open so that
 647                     // we can raise it later on.
 648                     raiseController = controller;
 649                     raiseFile = [files objectAtIndex:[idxSet firstIndex]];
 650                     [[raiseFile retain] autorelease];
 651                 }
 652
 653                 // Remove all the files that were open in this Vim process and
 654                 // create a new expression to evaluate.
 655                 [files removeObjectsAtIndexes:idxSet];
 656                 expr = [NSString stringWithFormat:
 657                         @"map([\"%@\"],\"bufloaded(v:val)\")",
 658                         [files componentsJoinedByString:@"\",\""]];
 659             }
 660         }
 661         @catch (NSException *e) {
 662             // Do nothing ...
 663         }
 664     }
 665
 666     if (![files count] && raiseFile) {
 667         // Raise the window containing the first file that was already open,
 668         // and make sure that the tab containing that file is selected.  Only
 669         // do this if there are no more files to open, otherwise sometimes the
 670         // window with 'raiseFile' will be raised, other times it might be the
 671         // window that will open with the files in the 'files' array.
 672         raiseFile = [raiseFile stringByEscapingSpecialFilenameCharacters];
 673         NSString *input = [NSString stringWithFormat:@"<C-\\><C-N>"
 674             ":let oldswb=&swb|let &swb=\"useopen,usetab\"|"
 675             "tab sb %@|let &swb=oldswb|unl oldswb|"
 676             "cal foreground()|redr|f<CR>", raiseFile];
 677         [raiseController addVimInput:input];
 678     }
 679
 680     return files;
 681 }
 682
 683 @end // MMAppController (Private)
 684
 685
 686
 687
 688 @implementation NSMenu (MMExtras)
 689
 690 - (void)recurseSetAutoenablesItems:(BOOL)on
 691 {
 692     [self setAutoenablesItems:on];
 693
 694     int i, count = [self numberOfItems];
 695     for (i = 0; i < count; ++i) {
 696         NSMenuItem *item = [self itemAtIndex:i];
 697         [item setEnabled:YES];
 698         NSMenu *submenu = [item submenu];
 699         if (submenu) {
 700             [submenu recurseSetAutoenablesItems:on];
 701         }
 702     }
 703 }
 704
 705 @end  // NSMenu (MMExtras)
 706
 707
 708
 709
 710 @implementation NSNumber (MMExtras)
 711 - (int)tag
 712 {
 713     return [self intValue];
 714 }
 715 @end // NSNumber (MMExtras)