The R Project SVN R-packages

/*

 *  R.app : a Cocoa front end to: "R A Computer Language for Statistical Data Analysis"

 *  

 *  R.app Copyright notes:

 *                     Copyright (C) 2004-5  The R Foundation

 *                     written by Stefano M. Iacus and Simon Urbanek

 *

 *                  

 *  R Copyright notes:

 *                     Copyright (C) 1995-1996   Robert Gentleman and Ross Ihaka

 *                     Copyright (C) 1998-2001   The R Development Core Team

 *                     Copyright (C) 2002-2004   The R Foundation

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; either version 2 of the License, or

 *  (at your option) any later version.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  A copy of the GNU General Public License is available via WWW at

 *  http://www.gnu.org/copyleft/gpl.html.  You can also obtain it by

 *  writing to the Free Software Foundation, Inc., 59 Temple Place,

 *  Suite 330, Boston, MA  02111-1307  USA.

 *

 *  $Id: RController.m 1603 2005-06-20 16:50:33Z urbaneks $

 */

#import "RGUI.h"

#include <R.h>

#include <Rversion.h>

#include <Rinternals.h>

#include <R_ext/Parse.h>

#include <Fileio.h>

#if (R_VERSION >= R_Version(2,1,0))

// Rinterface is public, but present only in 2.1+

#include <Rinterface.h>

#else

// if there is no Rinterface, we need private Defn.h

#include <Defn.h>

#endif

#include <langinfo.h>

#include <locale.h>

#import <sys/fcntl.h>

#import <sys/select.h>

#import <sys/types.h>

#import <sys/time.h>

#import <sys/wait.h>

#import <signal.h>

#import <unistd.h>

#import "RController.h"

#import "REngine/Rcallbacks.h"

#import "REngine/Rengine.h"

#import "RConsoleTextStorage.h"

#import "RDocumentWinCtrl.h"

#import "Tools/Authorization.h"

#import "Preferences.h"

#import "SearchTable.h"

// size of the console output cache buffer

#define DEFAULT_WRITE_BUFFER_SIZE 32768

// high water-mark of the buffer - it's [length - x] where x is the smallest possible size to be flushed before a new string will be split.

#define writeBufferHighWaterMark  (DEFAULT_WRITE_BUFFER_SIZE-4096)

// low water-mark of the buffer - if less than the water mark is available then the buffer will be flushed

#define writeBufferLowWaterMark   2048

/*  RController.m: main GUI code originally based on Simon Urbanek's work of embedding R in Cocoa app (RGui?)

The Code and File Completion is due to Simon U.

History handler is due to Simon U.

*/

typedef struct {

	ParseStatus    status;

	int            prompt_type;

	int            browselevel;

	unsigned char  buf[1025];

	unsigned char *bufp;

} R_ReplState;

extern R_ReplState state;

void run_Rmainloop(void); // from Rinit.c

extern void RGUI_ReplConsole(SEXP rho, int savestack, int browselevel); // from Rinit.c

extern int RGUI_ReplIteration(SEXP rho, int savestack, int browselevel, R_ReplState *state);

// from Defn.h

int R_SetOptionWidth(int);

#import "RController.h"

#import "Tools/CodeCompletion.h"

#import "Tools/FileCompletion.h"

#import "HelpManager.h"

#import "RDocument.h"

#import "PackageManager.h"

#import "DataManager.h"

#import "PackageInstaller.h"

#import "WSBrowser.h"

#import "HelpManager.h"

#import "Quartz/RQuartz.h"

#import "RDocumentController.h"

#import "SelectList.h"

#import <unistd.h>

#import <sys/fcntl.h>

static RController* sharedRController;

@interface NSApplication (ScriptingSupport)

- (id)handleDCMDCommand:(NSScriptCommand*)command;

@end

@implementation NSApplication (ScriptingSupport)

- (id)handleDCMDCommand:(NSScriptCommand*)command

{

    NSDictionary *args = [command evaluatedArguments];

    NSString *cmd = [args objectForKey:@""];

    if (!cmd || [cmd isEqualToString:@""])

        return [NSNumber numberWithBool:NO];

	[[RController sharedController] sendInput: cmd];

	return [NSNumber numberWithBool:YES];

}

@end

@implementation RController

- (id) init {

	self = [super init];

	runSystemAsRoot = NO;

	toolbar = nil;

	toolbarStopItem = nil;

	rootFD = -1;

	childPID = 0;

	RLtimer = nil;

	busyRFlag = YES;

	appLaunched = NO;

	outputPosition = promptPosition = committedLength = 0;

	consoleInputQueue = [[NSMutableArray alloc] initWithCapacity:8];

	currentConsoleInput = nil;

	forceStdFlush = NO;

	writeBufferLen = DEFAULT_WRITE_BUFFER_SIZE;

	writeBufferPos = writeBuffer = (char*) malloc(writeBufferLen);

	readConsTransBufferSize = 1024; // initial size - will grow as needed

	readConsTransBuffer = (char*) malloc(readConsTransBufferSize);

	textViewSync = [[NSString alloc] initWithString:@"consoleTextViewSemahphore"];

	consoleColorsKeys = [[NSArray alloc] initWithObjects:

		backgColorKey, inputColorKey, outputColorKey, promptColorKey,

		stderrColorKey, stdoutColorKey, rootColorKey];

	defaultConsoleColors = [[NSArray alloc] initWithObjects: // default colors

		[NSColor whiteColor], [NSColor blueColor], [NSColor blackColor], [NSColor purpleColor],

		[NSColor redColor], [NSColor grayColor], [NSColor purpleColor]];

	consoleColors = [defaultConsoleColors mutableCopy];

	textFont = [[NSFont userFixedPitchFontOfSize:currentFontSize] retain];

	return self;

}

- (void) setRootFlag: (BOOL) flag

{

	if (!flag) removeRootAuthorization();

	runSystemAsRoot=flag;

	{

		NSArray * ia = [toolbar items];

		int l = [ia count], i=0;

		while (i<l) {

			NSToolbarItem *ti = [ia objectAtIndex:i];

			if ([[ti itemIdentifier] isEqual:AuthenticationToolbarItemIdentifier]) {

				[ti setImage: [NSImage imageNamed: flag?@"lock-unlocked":@"lock-locked"]];

				break;

			}

			i++;

		}

	}

}

- (BOOL) getRootFlag { return runSystemAsRoot; }

- (void) setRootFD: (int) fd {

	rootFD=fd;

}

- (NSFont*) currentFont

{

	return textFont;

}

- (void) awakeFromNib {

	char *args[4]={ "R", "--no-save", "--gui=cocoa", 0 };

	SLog(@"RController.awakeFromNib");

	sharedRController = self;

	NSLayoutManager *lm = [[RTextView layoutManager] retain];

	NSTextStorage *origTS = [[RTextView textStorage] retain];

	RConsoleTextStorage * textStorage = [[RConsoleTextStorage alloc] init];

	[origTS removeLayoutManager:lm];

	[textStorage addLayoutManager:lm];

	[lm release];

	[origTS release];

	[RConsoleWindow setBackgroundColor:[defaultConsoleColors objectAtIndex:iBackgroundColor]]; // we need this, because "update" doesn't touch the color if it's equal - and by default the window has *no* background - not even the default one, so we bring it in sync

	[RConsoleWindow setOpaque:NO]; // Needed so we can see through it when we have clear stuff on top

	[RTextView setDrawsBackground:NO];

	[[RTextView enclosingScrollView] setDrawsBackground:NO];

	SLog(@" - load preferences");

	[self updatePreferences]; // first update, then add self

	[[Preferences sharedPreferences] addDependent: self];

	SLog(@" - init R_LIBS");	

	{ // first initialize R_LIBS if necessary

		NSString *prefStr = [Preferences stringForKey:miscRAquaLibPathKey withDefault:nil];

		BOOL flag = !isAdmin(); // the default is YES for users and NO for admins

		if (prefStr)

			flag=[prefStr isEqualToString: @"YES"];

		if (flag) {

			char *cRLIBS = getenv("R_LIBS");

			NSString *addPath = [@"~/Library/R/library" stringByExpandingTildeInPath];

			if (![[NSFileManager defaultManager] fileExistsAtPath:addPath]) { // make sure the directory exists

				[[NSFileManager defaultManager] createDirectoryAtPath:[@"~/Library/R" stringByExpandingTildeInPath] attributes:nil];

				[[NSFileManager defaultManager] createDirectoryAtPath:addPath attributes:nil];

			}

			if (cRLIBS && *cRLIBS)

				addPath = [NSString stringWithFormat: @"%s:%@", cRLIBS, addPath];

			setenv("R_LIBS", [addPath UTF8String], 1);

			SLog(@" - setting R_LIBS=%s", [addPath UTF8String]);

		}

	}

	SLog(@" - set APP VERSION");

	setenv("R_GUI_APP_VERSION", R_GUI_VERSION_STR, 1);

	SLog(@" - set R home");

	if (!getenv("R_HOME")) {

		NSBundle *rfb = [NSBundle bundleWithIdentifier:@"org.r-project.R-framework"];

		if (!rfb) {

			SLog(@" * problem: R_HOME is not set and I can't find the framework bundle");

			if ([[NSFileManager defaultManager] fileExistsAtPath:@"/Library/Frameworks/R.framework/Resources/bin/R"]) {

				SLog(@" * I'm being desperate and I found R at /Library/Frameworks/R.framework - so I'll use it, wish me luck");

				setenv("R_HOME", "/Library/Frameworks/R.framework/Resources", 1);

			} else

				SLog(@" * I didn't even found R framework in the default location, I'm giving up - you're on your own");

		} else {

			SLog(@"   %s", [[rfb resourcePath] UTF8String]);

			setenv("R_HOME", [[rfb resourcePath] UTF8String], 1);

		}

	}

#if (R_VERSION >= R_Version(2,2,0))

	 if (!getenv("RGUI_NOWARN_RDEVEL"))

	 NSRunAlertPanel(@"Using R-devel (unstable!)",@"You are using R-devel (to become 2.2.0)\n\nSeveral properites that I rely on are changing in R-devel. I will take a wild guess as of how they change, but that guess can be completely wrong. Most importantly you have to use the default build settings. Proceed at your own risk.\n\n(Set RGUI_NOWARN_RDEVEL to get rid of this message)",NLS(@"OK"),nil,nil);

	 {

		 char tp[1024];

		 if (!getenv("R_INCLUDE_DIR")) {

			 strcpy(tp, getenv("R_HOME")); strcat(tp, "/include"); setenv("R_INCLUDE_DIR", tp, 1);

		 }

		 if (!getenv("R_SHARE_DIR")) {

			 strcpy(tp, getenv("R_HOME")); strcat(tp, "/share"); setenv("R_SHARE_DIR", tp, 1);

		 }

		 if (!getenv("R_DOC_DIR")) {

			 strcpy(tp, getenv("R_HOME")); strcat(tp, "/doc"); setenv("R_DOC_DIR", tp, 1);

		 }

	 }

#endif

	/* setup LANG variable to match the system locale based on user's CFLocale */

#if (R_VERSION >= R_Version(2,1,0))

	SLog(@" - set locale");

	if ([Preferences stringForKey:@"force.LANG"]) {

		const char *ls = [[Preferences stringForKey:@"force.LANG"] UTF8String];

		if (*ls) {

			setenv("LANG", ls, 1);

			SLog(@" - force.LANG present, setting LANG to \"%s\"", ls);

		} else

			SLog(@" - force.LANG present, but empty. LANG won't be set at all.");

	} else if ([Preferences flagForKey:@"ignore.system.locale"]==YES) {

		setenv("LANG", "en_US.UTF-8", 1);

		SLog(@" - ignore.system.locale is set to YES, using en_US.UTF-8");

	} else {

		char cloc[64];

		char *c = getenv("LANG");

		cloc[63]=0;

		if (c)

			strcpy(cloc, c);

		else {

			CFLocaleRef lr = CFLocaleCopyCurrent();

			CFStringRef ls = CFLocaleGetIdentifier(lr);

			strncpy(cloc, [((NSString*)ls) UTF8String],63);

			CFRelease(lr);

		}

		if (!strchr(cloc,'.'))

			strcat(cloc,".UTF-8");

		setenv("LANG", cloc, 1);

		SLog(@" - setting LANG=%s", getenv("LANG"));

	}

#endif

	BOOL noReenter = [Preferences flagForKey:@"REngine prevent reentrance"];

	if (noReenter == YES) preventReentrance = YES;

	SLog(@" - init R");

	[[[REngine alloc] initWithHandler:self arguments:args] setCocoaHandler:self];

	SLog(@" - font and other widgets");

	/*

	[RTextView setFont:[NSFont userFixedPitchFontOfSize:currentFontSize]];

	[fontSizeStepper setIntValue:currentFontSize];

    theFont=[RTextView font];

    theFont=[[NSFontManager sharedFontManager] convertFont:theFont toSize:[fontSizeStepper intValue]];

    [RTextView setFont:theFont];

	 */

	[RTextView setFont: textFont];

	{

		NSMutableDictionary *md = [[RTextView typingAttributes] mutableCopy];

		[md setObject: [consoleColors objectAtIndex:iInputColor] forKey: @"NSColor"];

		[RTextView setTypingAttributes:[NSDictionary dictionaryWithDictionary:md]];

		[md release];

	}

	[RTextView setContinuousSpellCheckingEnabled:NO]; // force 'no spell checker'

	[[RTextView textStorage] setDelegate:self];

	//	[RTextView changeColor: inputColor];

	[RTextView display];

	[self setupToolbar];

	[ RConsoleWindow setDocumentEdited:YES];

    //NSLog(@"RController: awake: done");

	SLog(@" - setup timer");

	WDirtimer = [NSTimer scheduledTimerWithTimeInterval:0.5

												 target:self

											   selector:@selector(showWorkingDir:)

											   userInfo:0

												repeats:YES];

	hist=[[History alloc] init];

    BOOL WantThread = YES;

	SLog(@" - setup stdout/err grabber");

    if(WantThread){ // re-route the stdout to our own file descriptor and use ConnectionCache on it

        int pfd[2];

        pipe(pfd);

        dup2(pfd[1], STDOUT_FILENO);

        close(pfd[1]);

        stdoutFD=pfd[0];

        pipe(pfd);

#ifndef PLAIN_STDERR

        dup2(pfd[1], STDERR_FILENO);

        close(pfd[1]);

#endif

        stderrFD=pfd[0];

		[self addConnectionLog];

    }

	SLog(@" - set cwd and load history");

	[historyView setDoubleAction: @selector(historyDoubleClick:)];

	currentSize = [[RTextView textContainer] containerSize].width;

	//currentFontSize = [[RTextView font] pointSize];

	currentConsoleWidth = -1;

	[[NSFileManager defaultManager] changeCurrentDirectoryPath: [[Preferences stringForKey:initialWorkingDirectoryKey withDefault:@"~"] stringByExpandingTildeInPath]];

	if ([Preferences flagForKey:importOnStartupKey withDefault:YES]) {

		[self doLoadHistory:nil];

	}

	SLog(@" - awake is done");

}

-(void) applicationDidFinishLaunching: (NSNotification *)aNotification

{

	SLog(@"RController.applicationDidFinishLaunching");

	SLog(@" - initalizing R");

	if (![[REngine mainEngine] activate]) {

		NSRunAlertPanel(NLS(@"Cannot start R"),[NSString stringWithFormat:NLS(@"Unable to start R: %@"), [[REngine mainEngine] lastError]],NLS(@"OK"),nil,nil);

		exit(-1);

	}

	SLog(@" - set R options");

	// force html-help, because that's the only format we can handle ATM

	[[REngine mainEngine] executeString: @"options(htmlhelp=TRUE)"];

	SLog(@" - set default CRAN mirror");

	{

		NSString *url = [Preferences stringForKey:defaultCRANmirrorURLKey withDefault:@""];

		if (![url isEqualToString:@""])

			[[REngine mainEngine] executeString:[NSString stringWithFormat:@"try({ r <- getOption('repos'); r['CRAN']<-gsub('/$', '', \"%@\"); options(repos = r) },silent=TRUE)", url]];

	}

	SLog(@" - clean up and flush console");

	[self setOptionWidth:YES];

	[RTextView setEditable:YES];

	[self flushROutput];

	SLog(@" - setup notification and timers");

	[[NSNotificationCenter defaultCenter] 

		addObserver:self

		   selector:@selector(RConsoleDidResize:)

			   name:NSWindowDidResizeNotification

			 object: RConsoleWindow];

	timer = [NSTimer scheduledTimerWithTimeInterval:0.05

											 target:self

										   selector:@selector(otherEventLoops:)

										   userInfo:0

											repeats:YES];

	Flushtimer = [NSTimer scheduledTimerWithTimeInterval:0.5

												  target:self

												selector:@selector(flushTimerHook:)

												userInfo:0

												 repeats:YES];

	// once we're ready with the doc transition, the following will actually fire up the cconsole window

	//[[NSDocumentController sharedDocumentController] openUntitledDocumentOfType:@"Rcommand" display:YES];

	SLog(@" - show main window");

	[RConsoleWindow makeKeyAndOrderFront:self];

	//[[REngine mainEngine] runDelayedREPL]; // start delayed REPL

	//CGPostKeyboardEvent(27, 53, 1); // post <ESC> to cause SIGINT and thus the actual start of REPL

	SLog(@" - setup REPL trigger timer");

	if (!RLtimer)

		RLtimer = [NSTimer scheduledTimerWithTimeInterval:0.001

												   target:self

												 selector:@selector(kickstart:)

												 userInfo:0

												  repeats:NO];

	appLaunched = YES;

	SLog(@" - done, ready to go");

}

- (BOOL)appLaunched {

	return appLaunched;

}

- (void) kickstart:(id) sender {

	//kill(getpid(),SIGINT);

	[self setStatusLineText:@""];

	[[REngine mainEngine] runREPL];

}

-(void) addConnectionLog

{

	NSPort *port1;

	NSPort *port2;

	NSArray *portArray;

	NSConnection *connectionToTransferServer;

	port1 = [NSPort port];

	port2 = [NSPort port];

	connectionToTransferServer = [[NSConnection alloc] initWithReceivePort:port1 sendPort:port2];

	[connectionToTransferServer setRootObject:self];

	portArray = [NSArray arrayWithObjects:port2, port1, nil];

	[NSThread detachNewThreadSelector:@selector(readThread:)

							 toTarget:self

						   withObject:portArray];

}

- (void) readThread: (NSArray *)portArray

{

    NSAutoreleasePool *pool=[[NSAutoreleasePool alloc] init];

    NSConnection *connectionToController;

	RController *rc;

	unsigned int bufSize=2048;

    char *buf=(char*) malloc(bufSize+16);

    int n=0, pib=0, flushMark=bufSize-(bufSize>>2);

	int bufFD=0;

    fd_set readfds;

	struct timeval timv;

	timv.tv_sec=0; timv.tv_usec=300000; /* timeout */

	connectionToController = [NSConnection connectionWithReceivePort:[portArray objectAtIndex:0]

															sendPort:[portArray objectAtIndex:1]];

	rc = ((RController *)[connectionToController rootProxy]);

    fcntl(stdoutFD, F_SETFL, O_NONBLOCK);

    fcntl(stderrFD, F_SETFL, O_NONBLOCK);

    while (1) {

		int selr=0, maxfd=stdoutFD;

		int validRootFD=-1;

        FD_ZERO(&readfds);

        FD_SET(stdoutFD,&readfds);

        FD_SET(stderrFD,&readfds); if(stderrFD>maxfd) maxfd=stderrFD;

		if (rootFD!=-1) {

			validRootFD = rootFD; // we copy it as to not run into threading problems when it is changed while we're in the middle of processing

			FD_SET(rootFD,&readfds);

			if(rootFD>maxfd) maxfd=rootFD;

		}

        selr=select(maxfd+1, &readfds, 0, 0, &timv);

        if (FD_ISSET(stdoutFD, &readfds)) {

			if (bufFD!=0 && pib>0) {

				@try{

					[rc writeLogsWithBytes:buf length:pib type:bufFD];

				} @catch(NSException *ex) {

				}

				pib=0;

			}

			bufFD=0;

            while (pib<bufSize && (n=read(stdoutFD,buf+pib,bufSize-pib))>0)

				pib+=n;

			if (pib>flushMark) { // if we reach the flush mark, dump it

				@try{

					[rc writeLogsWithBytes:buf length:pib type:bufFD];

				} @catch(NSException *ex) {

				}

				pib=0;

            }

        } 

		if (FD_ISSET(stderrFD, &readfds)) {

			if (bufFD!=1 && pib>0) {

				[rc writeLogsWithBytes:buf length:pib type:bufFD];

				pib=0;

			}

			bufFD=1;

			while (pib<bufSize && (n=read(stderrFD,buf+pib,bufSize-pib))>0)

				pib+=n;

			if (pib>flushMark) { // if we reach the flush mark, dump it

				@try{

					[rc writeLogsWithBytes:buf length:pib type:bufFD];

				} @catch(NSException *ex) {

				}

				pib=0;

			}

		}

		if (validRootFD!=-1 && FD_ISSET(validRootFD, &readfds)) {

			if (bufFD!=2 && pib>0) {

				@try{

					[rc writeLogsWithBytes:buf length:pib type:bufFD];

				} @catch(NSException *ex) {

				}

				pib=0;

			}

			bufFD=2;

			while (pib<bufSize && (n=read(validRootFD,buf+pib,bufSize-pib))>0)

				pib+=n;

			if (n==0 || pib>flushMark) { // if we reach the flush mark, dump it

				@try{

					[rc writeLogsWithBytes:buf length:pib type:bufFD];

				} @catch(NSException *ex) {

				}

				pib=0;

			}

			if (n==0) rootFD=-1; // we indicate EOF on the rootFD by setting it to -1

		}

		if ((forceStdFlush || selr==0) && pib>0) { // dump also if we got a timeout

			@try{

				[rc writeLogsWithBytes:buf length:pib type:bufFD];

			} @catch(NSException *ex) {

			}

			pib=0;

		}

    }

    free(buf);

    [pool release];

}

- (void) flushStdConsole

{

	fflush(stderr);

	fflush(stdout);

	forceStdFlush=YES;

}

- (void) addChildProcess: (pid_t) pid

{

	childPID=pid;

	if (pid>0 && toolbarStopItem) [toolbarStopItem setEnabled:YES];

}

- (void) rmChildProcess: (pid_t) pid

{

	childPID=0;

	if (!busyRFlag && toolbarStopItem) [toolbarStopItem setEnabled:NO];

	[self flushStdConsole];

}

// When you have the toolbar in text-only mode, this action is called

// by the toolbar item's menu to make the font bigger.  We just change the stepper control and

// call our -changeFontSize: action.

-(IBAction) fontSizeBigger:(id)sender

{

	if ([RConsoleWindow isKeyWindow]) {

		[fontSizeStepper setIntValue:[fontSizeStepper intValue]+1];

		[self changeFontSize:NULL];

	} else

		[[NSFontManager sharedFontManager] modifyFont:sender];

}

// When you have the toolbar in text-only mode, this action is called

// by the toolbar item's menu to make the font smaller.  We just change the stepper control and

// call our -changeFontSize: action.

-(IBAction) fontSizeSmaller:(id)sender

{

	if ([RConsoleWindow isKeyWindow]) {

		[fontSizeStepper setIntValue:[fontSizeStepper intValue]-1];

		[self changeFontSize:NULL];

	} else

		[[NSFontManager sharedFontManager] modifyFont:sender];

}

// This action is called to change the font size.  It's called by the NSPopUpButton in the toolbar item's 

// custom view, and also by the above routines called from the toolbar item's menu (in text-only mode).

-(IBAction) changeFontSize:(id)sender

{

    NSFont *theFont;

    [fontSizeField takeIntValueFrom:fontSizeStepper];

    theFont=[RTextView font];

    theFont=[[NSFontManager sharedFontManager] convertFont:theFont toSize:[fontSizeStepper intValue]];

    [RTextView setFont:theFont];

	[self setOptionWidth:NO];

	[[NSUserDefaults standardUserDefaults] setFloat: [fontSizeStepper intValue] forKey:FontSizeKey];

}

extern BOOL isTimeToFinish;

- (NSApplicationTerminateReply)applicationShouldTerminate:(NSApplication *)app {

	if (![self windowShouldClose:self])

		return NSTerminateCancel;

	if(timer){

		[timer invalidate];

		timer = nil;

	}

	if(RLtimer){

		[RLtimer invalidate];

		RLtimer = nil;

	}

	if(Flushtimer){

		[Flushtimer invalidate];

		Flushtimer = nil;

	}

	if(WDirtimer){

		[WDirtimer invalidate];

		WDirtimer = nil;

	}

	return NSTerminateNow;

}

- (void) dealloc {

	[[NSNotificationCenter defaultCenter] removeObserver:self];

	[[Preferences sharedPreferences] removeDependent:self];

	[defaultConsoleColors release];

	[consoleColors release];

	[consoleColorsKeys release];

	[super dealloc];

}

- (void) flushTimerHook: (NSTimer*) source

{

	[self flushROutput];

}

- (void) flushROutput {

	if (writeBuffer!=writeBufferPos) {

		[self writeConsoleDirectly:[NSString stringWithUTF8String:writeBuffer] withColor:[consoleColors objectAtIndex:iOutputColor]];

		writeBufferPos=writeBuffer;

	}

}

- (void) handleFlushConsole {

	[self flushROutput];

	[self flushStdConsole];

}

/* this writes R output to the Console window, but indirectly by using a buffer */

- (void) handleWriteConsole: (NSString*) txt {

	const char *s = [txt UTF8String];

	int sl = strlen(s);

	int fits = writeBufferLen-(writeBufferPos-writeBuffer)-1;

	// let's flush the buffer if the new string is large and it would, but the buffer should be occupied

	if (fits<sl && fits>writeBufferHighWaterMark) {

		// for efficiency we're not using handleFlushConsole, because that would trigger stdxx flush, too

		[self writeConsoleDirectly:[NSString stringWithUTF8String:writeBuffer] withColor:[consoleColors objectAtIndex:iOutputColor]];

		writeBufferPos=writeBuffer;

		fits = writeBufferLen-1;

	}

	while (fits<sl) {	// ok, we're in a situation where we must split the string

		memcpy(writeBufferPos, s, fits);

		writeBufferPos[writeBufferLen-1]=0;

		[self writeConsoleDirectly:[NSString stringWithUTF8String:writeBuffer] withColor:[consoleColors objectAtIndex:iOutputColor]];

		sl-=fits; s+=fits;

		writeBufferPos=writeBuffer;

		fits=writeBufferLen-1;

	}

	strcpy(writeBufferPos, s);

	writeBufferPos+=sl;

	// flush the buffer if the low watermark is reached

	if (fits-sl<writeBufferLowWaterMark) {

		[self writeConsoleDirectly:[NSString stringWithUTF8String:writeBuffer] withColor:[consoleColors objectAtIndex:iOutputColor]];

		writeBufferPos=writeBuffer;

	}

}

/* this writes R output to the Console window directly, i.e. without using a buffer. Use handleWriteConsole: for the regular way. */

- (void) writeConsoleDirectly: (NSString*) txt withColor: (NSColor*) color{

	@synchronized(textViewSync) {

		RConsoleTextStorage *textStorage = (RConsoleTextStorage*) [RTextView textStorage];

		NSRange origSel = [RTextView selectedRange];

		unsigned tl = [txt length];

		if (tl>0) {

			unsigned oldCL=committedLength;

			/* NSLog(@"original: %d:%d, insertion: %d, length: %d, prompt: %d, commit: %d", origSel.location,

			origSel.length, outputPosition, tl, promptPosition, committedLength); */

			[textStorage beginEditing];

			committedLength=0;

			[textStorage insertText:txt atIndex:outputPosition withColor:color];

			if (outputPosition<=promptPosition) promptPosition+=tl;

			committedLength=oldCL;

			if (outputPosition<=committedLength) committedLength+=tl;

			if (outputPosition<=origSel.location) origSel.location+=tl;

			outputPosition+=tl;

			[textStorage endEditing];

			[RTextView setSelectedRange:origSel];

			[RTextView scrollRangeToVisible:origSel];

		}

	}

}

/* Just writes the prompt in a different color */

- (void)handleWritePrompt: (NSString*) prompt {

    [self handleFlushConsole];

	@synchronized(textViewSync) {

		RConsoleTextStorage *textStorage = (RConsoleTextStorage*) [RTextView textStorage];

		unsigned textLength = [textStorage length];

		int promptLength=[prompt length];

//		NSLog(@"Prompt: %@", prompt);

		NSRange lr = [[textStorage string] lineRangeForRange:NSMakeRange(textLength,0)];

		[textStorage beginEditing];

		promptPosition=textLength;

		if (lr.location!=textLength) { // the prompt must be on the beginning of the line

			[textStorage insertText: @"\n" atIndex: textLength withColor:[consoleColors objectAtIndex:iPromptColor]];

			textLength = [textStorage length];

			promptLength++;

		}

		if (promptLength>0) {

			[textStorage insertText:prompt atIndex: textLength withColor:[consoleColors objectAtIndex:iPromptColor]];

			if (promptLength>1) // this is a trick to make sure that the insertion color doesn't change at the prompt

				[textStorage addAttribute:@"NSColor" value:[consoleColors objectAtIndex:iInputColor] range:NSMakeRange(promptPosition+promptLength-1, 1)];

			committedLength=promptPosition+promptLength;

		}

		committedLength=promptPosition+promptLength;

		[textStorage endEditing];

		{

			NSRange targetRange = NSMakeRange(committedLength,0);

			[RTextView setSelectedRange:targetRange];

			[RTextView scrollRangeToVisible:targetRange];

		}

	}

}

- (void)  handleProcessingInput: (char*) cmd

{

	NSString *s = [[NSString alloc] initWithUTF8String:cmd];

	@synchronized(textViewSync) {

		unsigned textLength = [[RTextView textStorage] length];

		[RTextView setSelectedRange:NSMakeRange(committedLength, textLength-committedLength)];

		[RTextView insertText:s];

		textLength = [[RTextView textStorage] length];

		[RTextView setTextColor:[consoleColors objectAtIndex:iInputColor] range:NSMakeRange(committedLength, textLength-committedLength)];

		outputPosition=committedLength=textLength;

		// remove undo actions to prevent undo across prompts

		[[RTextView undoManager] removeAllActions];

	}

	[s release];

// the ?/help hack is no longer needed in 2.1

#if (R_VERSION < R_Version(2,1,0))

	if((*cmd == '?') || (!strncmp("help(",cmd,5))){ 

		[self openHelpFor: cmd];

		cmd[0] = '\n'; cmd[1] = 0;

	}

#endif

}

- (char*) handleReadConsole: (int) addtohist

{

	if (currentConsoleInput) {

		[currentConsoleInput release];

		currentConsoleInput=nil;

	}

	while ([consoleInputQueue count]==0)

		[self doProcessEvents: YES];

	currentConsoleInput = [consoleInputQueue objectAtIndex:0];

	[consoleInputQueue removeObjectAtIndex:0];

	if (addtohist) {

//		Figure out how to get hold of ParseStatus here!

		[hist commit:currentConsoleInput];

		[historyView reloadData];

	}

	{

		const char *c = [currentConsoleInput UTF8String];

		if (!c) return 0;

		if (strlen(c)>readConsTransBufferSize-1) { // grow as necessary

			free(readConsTransBuffer);

			readConsTransBufferSize = (strlen(c)+2048)&0xfffffc00;

			readConsTransBuffer = (char*) malloc(readConsTransBufferSize);

		} // we don't shrink the buffer if gets too large - we may want to think about that ...

		strcpy(readConsTransBuffer, c);

	}

	return readConsTransBuffer;

}

- (int) handleEdit: (char*) file

{

	NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];

	NSString *fn = [[NSString stringWithUTF8String:file] stringByExpandingTildeInPath];

	SLog(@"RController.handleEdit: %s", file);

	if (![[NSFileManager defaultManager] isReadableFileAtPath:fn]) {

		[pool release];

		return 0;

	}

	RDocument *document = [[RDocumentController sharedDocumentController] openRDocumentWithContentsOfFile: fn display:YES];

	[document setREditFlag: YES];

	NSEnumerator *e = [[document windowControllers] objectEnumerator];

	NSWindowController *wc = nil;

	while (wc = [e nextObject]) {

		NSWindow *window = [wc window];

		NSModalSession session = [NSApp beginModalSessionForWindow:window];

		while([document hasREditFlag]) {

			[NSApp runModalSession:session];

		}

		[NSApp endModalSession:session];

	}

	[pool release];

	return(0);

}

/* FIXME: the filename is not set for newvly created files */

- (int) handleEditFiles: (int) nfile withNames: (char**) file titles: (char**) wtitle pager: (char*) pager

{

	int    	i;

	SLog(@"RController.handleEditFiles (%d of them, pager %s)", nfile, pager);

    if (nfile <=0) return 1;

    for (i = 0; i < nfile; i++) {

		NSString *fn = [[NSString stringWithUTF8String:file[i]] stringByExpandingTildeInPath];

		if([[NSFileManager defaultManager] fileExistsAtPath:fn])

			[[RDocumentController sharedDocumentController] openRDocumentWithContentsOfFile:fn display:true];

		else

			[[NSDocumentController sharedDocumentController] newDocument: [RController sharedController]];

		NSDocument *document = [[NSDocumentController sharedDocumentController] currentDocument];

		if(wtitle[i]!=nil)

			[RDocument changeDocumentTitle: document Title: [NSString stringWithUTF8String:wtitle[i]]];

    }

	return 1;

}

- (int) handleShowFiles: (int) nfile withNames: (char**) file headers: (char**) headers windowTitle: (char*) wtitle pager: (char*) pages andDelete: (BOOL) del

{

	int    	i;

    if (nfile <=0) return 1;

	SLog(@"RController.handleShowFiles (%d of them, title %s, pager %s)", nfile, wtitle, pages);

    for (i = 0; i < nfile; i++){

		NSString *fn = [[NSString stringWithUTF8String:file[i]] stringByExpandingTildeInPath];

		RDocument *document = [[RDocumentController sharedDocumentController] openRDocumentWithContentsOfFile:fn display:NO];

		// don't dsiplay - we need to prevent the window controller from using highlighting

		if (document) {

			NSArray *wcs = [document windowControllers];

			if (wcs && [wcs count]>0) {

				SLog(@" - Disabling syntax highlighting for this document");

				[(RDocumentWinCtrl*) [wcs objectAtIndex:0] setPlain:YES];

			}

			if(wtitle[i]!=nil)

				[RDocument changeDocumentTitle: document Title: [NSString stringWithUTF8String:wtitle]];

			[document setEditable: NO];

			SLog(@" - finally show the document window");

			[document showWindows];

		}

    }

	return 1;

}

//======== Cocoa Handler ======

- (int) handlePackages: (int) count withNames: (char**) name descriptions: (char**) desc URLs: (char**) url status: (BOOL*) stat

{

	[[PackageManager sharedController] updatePackages:count withNames:name descriptions:desc URLs:url status:stat];

	return 0;

}

- (int) handleListItems: (int) count withNames: (char**) name status: (BOOL*) stat multiple: (BOOL) multiple title: (NSString*) title;

{

	return [[SelectList sharedController] selectList:count withNames:name status:stat multiple: multiple title:title];

}

- (int) handleHelpSearch: (int) count withTopics: (char**) topics packages: (char**) pkgs descriptions: (char**) descs urls: (char**) urls title: (char*) title

{

	[[SearchTable sharedController] updateHelpSearch:count withTopics:topics packages:pkgs descriptions:descs urls:urls title:title];

	return 0;

}

- (BOOL*) handleDatasets: (int) count withNames: (char**) name descriptions: (char**) desc packages: (char**) pkg URLs: (char**) url

{

	[[DataManager sharedController] updateDatasets:count withNames:name descriptions:desc packages:pkg URLs:url];

	return 0; // we don't load the DS this way, we use REngine instead

}

- (int) handleInstalledPackages: (int) count withNames: (char**) name installedVersions: (char**) iver repositoryVersions: (char**) rver update: (BOOL*) stat label: (char*) label

{

	[[PackageInstaller sharedController] updateInstalledPackages:count withNames:name installedVersions:iver repositoryVersions:rver update:stat label:label];

	return 0;

}

- (int) handleSystemCommand: (char*) cmd

{	

	int cstat=-1;

	pid_t pid;

	if ([self getRootFlag]) {

		FILE *f;

		char *argv[3] = { "-c", cmd, 0 };

		int res;

 		NSBundle *b = [NSBundle mainBundle];

		char *sushPath=0;

		if (b) {

			NSString *sush=[[b resourcePath] stringByAppendingString:@"/sush"];

			sushPath = (char*) malloc([sush cStringLength]+1);