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-11  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.
 *
 *  REditor.m
 *
 */

#include <R.h>
#include <R_ext/Boolean.h>
#include <R_ext/Rdynload.h>
#include <Rinternals.h>
#include <Rversion.h>
void Rf_PrintDefaults(void);
const char *Rf_EncodeElement(SEXP, int, int, char);

#import "RGUI.h"
#import "REditor.h"
#import "Tools/RDataEditorTableHeaderCell.h"
#import "NSArray_RAdditions.h"

#ifndef max
#define max(x,y) x<y?y:x;
#endif

static id sharedDEController;

extern SEXP work, names, lens, ssNA_STRING;
extern SEXP ssNewVector(SEXPTYPE type, int vlen);
extern int xmaxused, ymaxused, nprotect;
extern double ssNA_REAL;
extern PROTECT_INDEX wpi, npi, lpi;

typedef enum { UP, DOWN, LEFT, RIGHT } DE_DIRECTION;
typedef enum { UNKNOWNN, NUMERIC, CHARACTER } CellType;

int newvar;

BOOL IsDataEntry;

const char *get_col_name(int col)
{
    static char clab[25];
    if (col <= xmaxused) {
        // don't use NA labels
        SEXP tmp = STRING_ELT(names, col);
        if(tmp != NA_STRING) return(CHAR(tmp));
    }
    sprintf(clab, "var%d", col);
    return clab;
}

void printelt(SEXP invec, int vrow, char *strp)
{

    if(!strp) return;

    Rf_PrintDefaults();
    if (TYPEOF(invec) == REALSXP) {
        if (REAL(invec)[vrow] != ssNA_REAL) {
            strcpy(strp, Rf_EncodeElement(invec, vrow, 0, '.'));
            return;
        }
    }
    else if (TYPEOF(invec) == STRSXP) {
        if(CHAR(STRING_ELT(invec, vrow))){
            if ( strcmp( CHAR(STRING_ELT(invec, vrow)),
                          CHAR(STRING_ELT(ssNA_STRING, 0)) ) ) {
                strcpy(strp, Rf_EncodeElement(invec, vrow, 0, '.'));
                return;
            }
        }
    }
    else
        error("dataentry: internal memory error"); // FIXME: localize
}

@implementation REditor

- (id)init
{

    self = [super init];
    if (self) {
        if (!sharedDEController)
            sharedDEController = [self retain];

        // Add your subclass-specific initialization here.
        // If an error occurs here, send a [self release] message and return nil.

        toolbar = nil;
        editedColumnNameIndex = -1;
        objectData = [[NSMutableArray alloc] initWithCapacity:10];
        objectColumnNames = [[NSMutableArray alloc] initWithCapacity:10];
        objectColumnTypes = [[NSMutableArray alloc] initWithCapacity:10];
        numberOfColumns = 0;
        numberOfRows = 0;
    }

    return self;

}

- (void)awakeFromNib
{

    [editorSource setColumnAutoresizingStyle:NSTableViewUniformColumnAutoresizingStyle];
    [self setupToolbar];
    // Since the window will be listed in the main menu > windows after closing
    // let it not listed there at all (and due to the fact that it's a modal window
    // it's not needed to have it there)
    [dataWindow setExcludedFromWindowsMenu:YES];

}

#pragma mark -

+ (id)getDEController
{
    return sharedDEController;
}


+ (void)startDataEntry
{

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

    newvar = 0;

    [[REditor getDEController] setDataTable:YES];
    [[[REditor getDEController] window] orderFront:self];

    NSInteger ret = [NSApp runModalForWindow:[[REditor getDEController] window]];

    // if modal session was aborted cancel edit()
    if( ret == NSRunAbortedResponse )
        error([NLS(@"editing cancelled") UTF8String]);

    [pool release];

}

#define NA_CHARS " <NA> "
- (BOOL)writeDataBackToObject
{
    NSInteger buflen = 256;
    NSInteger i, j;
    NSInteger nCols = [[editorSource tableColumns] count];
    NSInteger nRows = (nCols) ? [[objectData objectAtIndex:0] count] : 0;
    NSInteger colType;
    SEXP work3, names3;

    numberOfRows = 0;

    PROTECT(work3  = allocVector(VECSXP, nCols)); nprotect++;
    PROTECT(names3 = allocVector(STRSXP, nCols)); nprotect++;

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

        SET_VECTOR_ELT(work3, i, ssNewVector(([NSArrayObjectAtIndex(objectColumnTypes, i) intValue] == NUMERIC) ? REALSXP : STRSXP, nRows));

        SEXP tmp = VECTOR_ELT(work3, i);
        SET_STRING_ELT(names3, i, mkChar([NSArrayObjectAtIndex(objectColumnNames, i) UTF8String]));

        colType = [NSArrayObjectAtIndex(objectColumnTypes, i) intValue];
        for(j = 0; j < nRows; j++) {

            NSString *anObject = NSArrayObjectAtIndex(NSArrayObjectAtIndex(objectData, i), j);
            buflen = 256;

            // get the number of utf-8 bytes for CHARACTER type
            if(colType == CHARACTER)
                buflen = strlen([anObject UTF8String])+2;

            char buf[buflen];
            buf[0] = '\0';

            CFStringGetCString((CFStringRef)anObject, buf, buflen-1, kCFStringEncodingUTF8);

            switch(colType) {

                case NUMERIC:
                if(buf[0] == '\0')
                    REAL(tmp)[j] = NA_REAL;
                 else {
                    char *endp;
                    double new = R_strtod(buf, &endp);
                    REAL(tmp)[j] = new;
                 }
                break;

                case CHARACTER:
//              if(buf[0] == '\0')
                    if(strcmp(buf, NA_CHARS) == 0)
                    SET_STRING_ELT(tmp, j, NA_STRING);
                 else
                    SET_STRING_ELT(tmp, j, mkChar(buf));

                break;

                default:
                return NO;
                break;

            }
        }
    }
    
    REPROTECT(work  = allocVector(VECSXP, nCols), wpi);
    REPROTECT(names = allocVector(STRSXP, nCols), npi);

    xmaxused = nCols;

    for (i = 0; i < nCols; i++) {
        SET_VECTOR_ELT(work,  i, VECTOR_ELT(work3,  i));
        SET_STRING_ELT(names, i, STRING_ELT(names3, i));
        INTEGER(lens)[i] = nRows;
    }

    return YES;
}

- (BOOL)initData
{

    numberOfRows = 0;
    numberOfColumns = 0;

    if(objectData) [objectData release], objectData = nil;
    if(objectColumnNames) [objectColumnNames release], objectColumnNames = nil;
    if(objectColumnTypes) [objectColumnTypes release], objectColumnTypes = nil;
    objectData = [[NSMutableArray alloc] initWithCapacity:xmaxused];
    objectColumnNames = [[NSMutableArray alloc] initWithCapacity:xmaxused];
    objectColumnTypes = [[NSMutableArray alloc] initWithCapacity:xmaxused];

    numberOfRows = ymaxused;

    NSInteger i;
    NSNumber *charNumber = [NSNumber numberWithInt:CHARACTER];
    NSNumber *numNumber  = [NSNumber numberWithInt:NUMERIC];

    for(i = 0; i < xmaxused; i++) {
        SEXP tmp = VECTOR_ELT(work, i);
        if (isNull(tmp)) {
            NSBeep();
            error([NLS(@"R Data Editor - error while reading object data") UTF8String]);
            return NO;
            break;
        }
        CFArrayAppendValue((CFMutableArrayRef)objectColumnTypes, (TYPEOF(tmp) == STRSXP) ? charNumber : numNumber);
        CFArrayAppendValue((CFMutableArrayRef)objectColumnNames, CFStringCreateWithCString(NULL, get_col_name(i), kCFStringEncodingUTF8));
        if(TYPEOF(tmp) == STRSXP) {

            NSUInteger k=0, l=LENGTH(tmp);
            id *cont=(id *)malloc(sizeof(id)*l);
            while (k<l) {
                if ( strcmp( CHAR(STRING_ELT(tmp, k)), CHAR(STRING_ELT(ssNA_STRING, 0)) ) )
                    cont[k] = (NSString*)CFStringCreateWithCString(NULL, CHAR(STRING_ELT(tmp, k)), kCFStringEncodingUTF8);
                else
                    cont[k] = @NA_CHARS;
                k++;
            }
            NSArray *a = [NSArray arrayWithObjects:cont count:l];
            k=0;
            while (k<l) [cont[k++] release];
            free(cont);

            CFArrayAppendValue((CFMutableArrayRef)objectData, [a mutableCopy]);

        }
        else if(TYPEOF(tmp) == REALSXP){

            NSUInteger k=0, l=LENGTH(tmp);
            id *cont = malloc(sizeof(id)*l);
            while (k<l) {

                cont[k] = (NSString*)CFStringCreateWithCString(NULL, Rf_EncodeElement(tmp, k, 0, '.'), kCFStringEncodingASCII);

                k++;
            }
            NSArray *a = [NSArray arrayWithObjects:cont count:l];
            k=0;
            while (k<l) [cont[k++] release];
            free(cont);

            CFArrayAppendValue((CFMutableArrayRef)objectData, [a mutableCopy]);

        }
        else {
            NSBeep();
            error([NLS(@"R Data Editor - error while reading object data") UTF8String]);
            return NO;
        }
    }

    numberOfColumns = xmaxused;

    return YES;

}

- (void)setDataTable:(BOOL)removeAll
{

    if(removeAll)
        if(![self initData]) return;

    NSInteger i;
    NSArray *theColumns = [editorSource tableColumns];

    while ([theColumns count])
        [editorSource removeTableColumn:NSArrayObjectAtIndex(theColumns ,0)];

    if(!objectData) return;

    for (i = 0; i < numberOfColumns; i++) {
        NSTableColumn *col = [[NSTableColumn alloc] initWithIdentifier:[NSString stringWithFormat:@"%ld", i]];
        NSString *colName  = NSArrayObjectAtIndex(objectColumnNames, i);
        NSInteger colType  = [NSArrayObjectAtIndex(objectColumnTypes, i) intValue];
        if(colName) {
            RDataEditorTableHeaderCell *c = [[RDataEditorTableHeaderCell alloc] initTextCell:colName];
            [col setHeaderCell:c];
            [c release];
            [[col headerCell] setAlignment:NSCenterTextAlignment];
            [col setHeaderToolTip:[NSString stringWithFormat:@"%@\n  (%@)", colName,
                (colType == NUMERIC) ? @"numeric" : @"character"]];
        }
        [col setResizingMask:NSTableColumnUserResizingMask];
        [col setEditable:YES];
        // set text cell alignment to 'right' for numeric values
        if(colType == NUMERIC) [[col dataCell] setAlignment:NSRightTextAlignment];
        [col setMinWidth:18.0f];
        [col setMaxWidth:1000.0f];
        [editorSource addTableColumn:col];
        [col release];
    }

    // column auto-sizing
    for(i = 0; i < numberOfColumns; i++) {
        [[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", i]] setWidth:
                [editorSource widthForColumn:i andHeaderName:NSArrayObjectAtIndex(objectColumnNames, i)]];
        if(i+1 < numberOfColumns)
            [[[[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", i]] headerCell] controlView] setNextKeyView:[[[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", i+1]] headerCell] controlView]];
        else if(i-1 == numberOfColumns)
            [[[[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", i]] headerCell] controlView] setNextKeyView:editorSource];
    }

    [editorSource sizeLastColumnToFit];

    //tries to fix problem with last row
    if ( [[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", numberOfColumns-1]] width] < 30 )
        [[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", numberOfColumns-1]]
                setWidth:[[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", 0L]] width]];

    [editorSource reloadData];

}

- (void)editColumnNameOfTableColumn:(NSTableColumn *)aTableColumn
{

    RDataEditorTableHeaderCell *headerCellEditor = [aTableColumn headerCell];
    NSText *editor = [[[REditor getDEController] window] fieldEditor:YES forObject:headerCellEditor];
    editedColumnNameIndex = [[aTableColumn identifier] intValue];
    [editor setFieldEditor:YES];
    NSRect r = [[editorSource headerView] headerRectOfColumn:editedColumnNameIndex];
    r = NSInsetRect(r, 0.0f, 1.0f);
    [headerCellEditor editWithFrame: r
                             inView:[editorSource headerView] 
                             editor:editor 
                           delegate:self 
                              event:nil];

    [headerCellEditor hideTitle];
    [editor selectAll:nil];

}

- (NSArray*)objectData
{
    return objectData;
}

- (NSArray*)objectColumnTypes
{
    return objectColumnTypes;
}

- (void)clearData
{
    [objectColumnTypes removeAllObjects];
    [objectColumnNames removeAllObjects];
    [objectData removeAllObjects];
}

- (void)dealloc
{
    if(objectColumnTypes) [objectColumnTypes release];
    if(objectColumnNames) [objectColumnNames release];
    if(objectData) [objectData release];
    [super dealloc];
}

#pragma mark -

- (id)window
{
    return dataWindow;
}

#pragma mark -
#pragma mark NSWindow delegates

- (BOOL)windowShouldClose:(id)sender
{

    // Make sure that any pending changes will be stored before closing
    if(editedColumnNameIndex > -1)
        [self textView:(NSTextView*)[[NSApp keyWindow] firstResponder] doCommandBySelector:@selector(insertNewline:)];
    [[[REditor getDEController] window] makeFirstResponder:editorSource];

    if(![self writeDataBackToObject]) {
        error([NLS(@"R Data Editor couldn't write object data") UTF8String]);
    }

    if(IsDataEntry){
        [NSApp stopModal];
        IsDataEntry = NO;
    }

    return YES;

}

#pragma mark -
#pragma mark NSTableView delegates

- (NSInteger)numberOfRowsInTableView:(NSTableView *)tableView
{
    return numberOfRows;
}

- (void)tableViewSelectionIsChanging:(NSNotification *)aNotification
{
    if([[[NSApp keyWindow] firstResponder] isKindOfClass:[NSTableView class]] && editedColumnNameIndex > -1) {
        // Submit pending changes
        [self textView:(NSTextView*)[[NSApp keyWindow] firstResponder] doCommandBySelector:@selector(insertNewline:)];
        editedColumnNameIndex = -1;
    }
}

- (id)tableView:(NSTableView *)tableView objectValueForTableColumn:(NSTableColumn *)tableColumn row:(NSInteger)row
{
    if(row < 0) return @"…";
    int col = (int) [[tableColumn identifier] intValue];
    if (col >= [objectData count]) return @"…";
    NSArray *a = NSArrayObjectAtIndex(objectData, col);
    if (!a || row >= [a count]) return @"…";
    return NSArrayObjectAtIndex(a, row);
}

- (void)tableView:(NSTableView *)aTableView setObjectValue:(id)anObject forTableColumn:(NSTableColumn *)tableColumn row:(NSInteger)row
{

    if(row < 0) return;

    NSInteger col = [[tableColumn identifier] intValue];

    if([[objectColumnTypes objectAtIndex:col] intValue] == NUMERIC) {
        // validate NUMERIC value
        char *endp;
        (void)R_strtod([anObject UTF8String], &endp);
        if(strlen(endp))
            [[objectData objectAtIndex:col] replaceObjectAtIndex:row withObject:@"NA"];
        else {
            [[objectData objectAtIndex:col] replaceObjectAtIndex:row withObject:anObject];
        }
    } else {
        [[objectData objectAtIndex:col] replaceObjectAtIndex:row withObject:anObject];
    }

    // resize column width
    CGFloat newSize = [editorSource widthForColumn:col andHeaderName:(NSString*)anObject];
    if(newSize > [tableColumn width]) [tableColumn setWidth:newSize];

    return;

}

/**
 * Enable drag from tableview
 */
- (BOOL)tableView:(NSTableView *)aTableView writeRowsWithIndexes:(NSIndexSet *)rows toPasteboard:(NSPasteboard*)pboard
{

    if (aTableView == editorSource) {
        NSString *tmp;

        // By holding ⌘ or/and ⌥ copies selected rows as CSV
        // otherwise \t delimited lines
        if([[NSApp currentEvent] modifierFlags] & (NSCommandKeyMask|NSAlternateKeyMask))
            tmp = [editorSource rowsAsCsvStringWithHeaders:YES];
        else
            tmp = [editorSource rowsAsTabStringWithHeaders:YES];

        if ( nil != tmp && [tmp length] )
        {
            [pboard declareTypes:[NSArray arrayWithObjects:NSTabularTextPboardType,
                                  NSStringPboardType, nil]
                           owner:nil];

            [pboard setString:tmp forType:NSStringPboardType];
            [pboard setString:tmp forType:NSTabularTextPboardType];
            return YES;
        }
    }

    return NO;
}

- (void)tableView:(NSTableView *)tableView mouseDownInHeaderOfTableColumn:(NSTableColumn *)tableColumn
{
    // Go into column name editing mode if user did a double-click at the column's header
    if([[NSApp currentEvent] clickCount] > 1) {
        [self editColumnNameOfTableColumn:tableColumn];
    }

}

#pragma mark -
#pragma mark NSText delegates

- (BOOL)textView:(NSTextView *)aTextView doCommandBySelector:(SEL)commandSelector
{

    SLog(@"REditor:textView:doCommandBySelector: %@ %@", [aTextView class], NSStringFromSelector(commandSelector));

    if(editedColumnNameIndex < 0) return NO;

    // Trap ESC while editing column names to cancel editing
    if (@selector(cancelOperation:) == commandSelector) {
        NSTableColumn *col = [editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", editedColumnNameIndex]];
        [[col headerCell] setTitle:[[col headerCell] titleBeforeEditing]];
        editedColumnNameIndex = -1;
        [[[[REditor getDEController] window] fieldEditor:NO forObject:[col headerCell]] setFieldEditor:YES];
        [[[REditor getDEController] window] makeFirstResponder:editorSource];
        [[[REditor getDEController] window] endEditingFor:[col headerCell]];
        [[editorSource headerView] setNeedsDisplay:YES];
        return YES;
    }

    // Trap RETURN, TAB, SHIFT+TAB while editing column names to end editing and 
    // storing the new column name after validation; in addition for TABs edit
    // the next/previous column name if possible
    if (   @selector(insertNewline:) == commandSelector
        || @selector(insertTab:)     == commandSelector
        || @selector(insertBacktab:) == commandSelector
        ) {

        NSTableColumn *col = [editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", editedColumnNameIndex]];
        if(![[[REditor getDEController] window] fieldEditor:NO forObject:[col headerCell]]) return NO;
        NSString *newColumnName = [[[[[REditor getDEController] window] fieldEditor:NO forObject:[col headerCell]] string] copy];

        // validate newColumnName
        BOOL newNameIsValid = YES;
        if(!newColumnName || ![newColumnName length]) newNameIsValid = NO;
        if(newNameIsValid) {
            NSArray *allCols = [editorSource tableColumns];
            NSInteger i;
            for(i = 0; i < [allCols count]; i++) {
                if([[[[allCols objectAtIndex:i] headerCell] title] isEqualToString:newColumnName]) {
                    newNameIsValid = NO;
                    break;
                }
            }
        }

        if(newNameIsValid) {
            [[col headerCell] setTitle:newColumnName];
            [col setHeaderToolTip:[NSString stringWithFormat:@"%@\n  (%@)", newColumnName,
                ([[objectColumnTypes objectAtIndex:editedColumnNameIndex] intValue] == NUMERIC) ? @"numeric" : @"character"]];
            [objectColumnNames replaceObjectAtIndex:[[col identifier] intValue] withObject:newColumnName];
        } else {
            [[col headerCell] setTitle:[[col headerCell] titleBeforeEditing]];
            if([aTextView isKindOfClass:[NSTextView class]] && ![[[col headerCell] title] isEqualToString:newColumnName])
                NSBeep();
        }

        [[[[REditor getDEController] window] fieldEditor:NO forObject:[col headerCell]] setFieldEditor:YES];
        [[[REditor getDEController] window] makeFirstResponder:editorSource];
        [[[REditor getDEController] window] endEditingFor:[col headerCell]];

        [[[col headerCell] controlView] display];
        [[editorSource headerView] display];
        [newColumnName release];
        // TAB select next column name if any
        if(@selector(insertTab:) == commandSelector) {
            if(editedColumnNameIndex + 1 < [[editorSource tableColumns] count]) {
                NSInteger i = editedColumnNameIndex;
                editedColumnNameIndex = -1;
                [self editColumnNameOfTableColumn:[[editorSource tableColumns] objectAtIndex:i+1]];
                return YES;
            }
        }
        // SHIFT+TAB select previous column name if any
        else if(@selector(insertBacktab:) == commandSelector) {
            if(editedColumnNameIndex > 0) {
                NSInteger i = editedColumnNameIndex;
                editedColumnNameIndex = -1;
                [self editColumnNameOfTableColumn:[[editorSource tableColumns] objectAtIndex:i-1]];
                return YES;
            }
        }

        editedColumnNameIndex = -1;

        return (![aTextView isKindOfClass:[NSTextView class]]);
    }

    return NO;

}

/**
 * Trap ESC,⇡, and ⇣ inside TableView
 */
- (BOOL)control:(NSControl*)control textView:(NSTextView*)aTextView doCommandBySelector:(SEL)command
{

    if([control isKindOfClass:[RDataEditorTableView class]]) {

        // Check firstly if RDataEditorTableView can handle command (handle ⇡ ⇣)
        if([editorSource control:control textView:aTextView doCommandBySelector:(SEL)command])
            return YES;

        // Trap the escape key to abort editing
        if ([[control window] methodForSelector:command] == [[control window] methodForSelector:@selector(cancelOperation:)])
        {
            // Abort editing
            [control abortEditing];
            [[[REditor getDEController] window] makeFirstResponder:editorSource];
            return YES;
        }

    }

    return NO;

}

#pragma mark -
#pragma mark Toolbar Methods

- (void)setupToolbar
{

    // Create a new toolbar instance, and attach it to our document window
    toolbar = [[NSToolbar alloc] initWithIdentifier:DataEditorToolbarIdentifier];

    // Set up toolbar properties: Allow customization, give a default display mode, and remember state in user defaults
    [toolbar setAllowsUserCustomization:YES];
    [toolbar setAutosavesConfiguration:YES];
    [toolbar setDisplayMode:NSToolbarDisplayModeIconOnly];

    // We are the delegate
    [toolbar setDelegate:self];

    // Attach the toolbar to the document window
    [dataWindow setToolbar:toolbar];
}

- (NSToolbarItem *)toolbar:(NSToolbar *)toolbar itemForItemIdentifier:(NSString *)itemIdent willBeInsertedIntoToolbar:(BOOL)willBeInserted
{
    // Required delegate method:  Given an item identifier, this method returns an item
    // The toolbar will use this method to obtain toolbar items that can be displayed in the customization sheet, or in the toolbar itself
    // NSLog(@"toolbar: %@ itemForItemIdentifier:%@ willBeInsertedIntoToolbar:%d\n", toolbar, itemIdent, willBeInserted);
    NSToolbarItem *toolbarItem = [[[NSToolbarItem alloc] initWithItemIdentifier:itemIdent] autorelease];

    if ([itemIdent isEqual:AddColToolbarItemIdentifier]) {
        // Set the text label to be displayed in the toolbar and customization palette
        [toolbarItem setLabel:NLSC(@"Add Col", @"Add column - label for a toolbar, keep short!")];
        [toolbarItem setPaletteLabel:NLS(@"Add Column")];

        // Set up a reasonable tooltip, and image   Note, these aren't localized, but you will likely want to localize many of the item's properties
        [toolbarItem setToolTip:[NSString stringWithFormat:
            NLS(@"Adds a new column to the right of a group of selected columns or just at the end of the data. The new column type complies with that column left of it.\n\n(%@)\tAdd column of type ‘CHARACTER’\n(%@)\tAdd column of type ‘NUMERIC’"), @"⇧⌥⌘C", @"⌥⌘C"]];
        [toolbarItem setImage:[NSImage imageNamed:@"add_col"]];

        // Tell the item what message to send when it is clicked
        [toolbarItem setTarget:self];
        [toolbarItem setAction:@selector(addCol:)];
    } else  if ([itemIdent isEqual:RemoveColsToolbarItemIdentifier]) {
        // Set the text label to be displayed in the toolbar and customization palette
        [toolbarItem setLabel:NLSC(@"Remove Col",v@"Remove columns - label for a toolbar, keep short!")];
        [toolbarItem setPaletteLabel:NLS(@"Remove Columns")];

        // Set up a reasonable tooltip, and image   Note, these aren't localized, but you will likely want to localize many of the item's properties
        [toolbarItem setToolTip:[NSString stringWithFormat:@"%@ (⌘⌫)", NLS(@"Remove selected columns")]];
        [toolbarItem setImage:[NSImage imageNamed:@"rem_col"]];

        // Tell the item what message to send when it is clicked
        [toolbarItem setTarget:self];
        [toolbarItem setAction:@selector(remCols:)];
    } else  if ([itemIdent isEqual:AddRowToolbarItemIdentifier]) {
        // Set the text label to be displayed in the toolbar and customization palette
        [toolbarItem setLabel:NLSC(@"Add Row", @"Add row - label for a toolbar, keep short!")];
        [toolbarItem setPaletteLabel:NLS(@"Add New Row")];

        // Set up a reasonable tooltip, and image   Note, these aren't localized, but you will likely want to localize many of the item's properties
        [toolbarItem setToolTip:[NSString stringWithFormat:@"%@ (⌥⌘A)", NLS(@"Adds a row below a group of selected rows or at the bottom of the data")]];
        [toolbarItem setImage:[NSImage imageNamed:@"add_row"]];

        // Tell the item what message to send when it is clicked
        [toolbarItem setTarget:self];
        [toolbarItem setAction:@selector(addRow:)];
    } else  if ([itemIdent isEqual:RemoveRowsToolbarItemIdentifier]) {
        // Set the text label to be displayed in the toolbar and customization palette
        [toolbarItem setLabel:NLSC(@"Remove Row", @"Remove row - label for a toolbar, keep short!")];
        [toolbarItem setPaletteLabel:NLS(@"Remove Rows")];

        // Set up a reasonable tooltip, and image   Note, these aren't localized, but you will likely want to localize many of the item's properties
        [toolbarItem setToolTip:[NSString stringWithFormat:@"%@ (⌘⌫)", NLS(@"Removes selected rows")]];
        [toolbarItem setImage:[NSImage imageNamed:@"rem_row"]];

        // Tell the item what message to send when it is clicked
        [toolbarItem setTarget:self];
        [toolbarItem setAction:@selector(remRows:)];
    } else  if ([itemIdent isEqual:CancelEditToolbarItemIdentifier]) {
        // Set the text label to be displayed in the toolbar and customization palette
        [toolbarItem setLabel:NLSC(@"Cancel Editing", @"Cancel Editing - label for a toolbar, keep short!")];
        [toolbarItem setPaletteLabel:NLS(@"Cancel Editing")];

        // Set up a reasonable tooltip, and image   Note, these aren't localized, but you will likely want to localize many of the item's properties
        [toolbarItem setToolTip:[NSString stringWithFormat:@"%@ (⌃⌥⌘⎋)", NLS(@"Cancels object editing without passing data back to R and closes the editor window")]];
        [toolbarItem setImage:[NSImage imageNamed:@"stop"]];

        // Tell the item what message to send when it is clicked
        [toolbarItem setTarget:self];
        [toolbarItem setAction:@selector(cancelEditing:)];
    } else {
        // itemIdent refered to a toolbar item that is not provide or supported by us or cocoa
        // Returning nil will inform the toolbar this kind of item is not supported
        toolbarItem = nil;
    }
    return toolbarItem;
}


- (NSArray *)toolbarDefaultItemIdentifiers:(NSToolbar *)toolbar
{
    // Required delegate method:  Returns the ordered list of items to be shown in the toolbar by default
    // If during the toolbar's initialization, no overriding values are found in the user defaults, or if the
    // user chooses to revert to the default items this set will be used
    return [NSArray arrayWithObjects:AddColToolbarItemIdentifier, RemoveColsToolbarItemIdentifier,
        AddRowToolbarItemIdentifier, RemoveRowsToolbarItemIdentifier, CancelEditToolbarItemIdentifier
        , nil];
}


- (NSArray *)toolbarAllowedItemIdentifiers:(NSToolbar *)toolbar
{
    // Required delegate method:  Returns the list of all allowed items by identifier.  By default, the toolbar
    // does not assume any items are allowed, even the separator.  So, every allowed item must be explicitly listed
    // The set of allowed items is used to construct the customization palette
    return [NSArray arrayWithObjects:AddColToolbarItemIdentifier, RemoveColsToolbarItemIdentifier,
        AddRowToolbarItemIdentifier, RemoveRowsToolbarItemIdentifier, CancelEditToolbarItemIdentifier
        , nil];
}

- (void)toolbarWillAddItem:(NSNotification *)notification
{
    // Optional delegate method:  Before an new item is added to the toolbar, this notification is posted.
    // This is the best place to notice a new item is going into the toolbar.  For instance, if you need to
    // cache a reference to the toolbar item or need to set up some initial state, this is the best place
    // to do it.  The notification object is the toolbar to which the item is being added.  The item being
    // added is found by referencing the @"item" key in the userInfo
    //NSToolbarItem *addedItem = [[notif userInfo] objectForKey: @"item"];
    //NSLog(@"toolbarWillAddItem: %@", addedItem);
}

- (void)toolbarDidRemoveItem:(NSNotification *)notification
{
    // Optional delegate method:  After an item is removed from a toolbar, this notification is sent.   This allows
    // the chance to tear down information related to the item that may have been cached.   The notification object
    // is the toolbar from which the item is being removed.  The item being added is found by referencing the @"item"
    // key in the userInfo
    //NSToolbarItem *removedItem = [[notif userInfo] objectForKey: @"item"];
    //NSLog(@"toolbarDidRemoveItem: %@", removedItem);
}

- (BOOL)validateToolbarItem:(NSToolbarItem *)toolbarItem
{
    // Optional method:  This message is sent to us since we are the target of some toolbar item actions
    // (for example:  of the save items action)

    if ([[toolbarItem itemIdentifier] isEqualToString:AddColToolbarItemIdentifier])
        return(editedColumnNameIndex < 0);
    else if ([[toolbarItem itemIdentifier] isEqualToString:RemoveColsToolbarItemIdentifier])
        return(editedColumnNameIndex < 0 && [[editorSource selectedColumnIndexes] count]);
    else if ([[toolbarItem itemIdentifier] isEqualToString:AddRowToolbarItemIdentifier])
        return(editedColumnNameIndex < 0);
    else if ([[toolbarItem itemIdentifier] isEqualToString:RemoveRowsToolbarItemIdentifier])
        return(editedColumnNameIndex < 0 && [[editorSource selectedRowIndexes] count]);
    else if ([[toolbarItem itemIdentifier] isEqualToString:CancelEditToolbarItemIdentifier])
        return(YES);

    return NO;

}

#pragma mark -
#pragma mark IBActions

/**
 * Adds a column to the data either at the end or after the last columns selected by the user.
 * sender's tag will choose column type
 *   0 = type of column left of it
 *   1 = CHARACTER
 *   2 = NUMERIC
 */
- (IBAction)addCol:(id)sender
{

    NSUInteger lastcol, i;
    BOOL isEmpty = NO;
    BOOL typeWasPassed = NO;
    NSInteger newColType = CHARACTER;

    // if sender's tag pre-set type of to be added columns
    switch([sender tag]) {
        case 1:
        newColType = NUMERIC;
        typeWasPassed = YES;
        break;
        case 2:
        newColType = CHARACTER;
        typeWasPassed = YES;
        break;
    }

    NSIndexSet *cols =  [editorSource selectedColumnIndexes];
    NSInteger nCols = [[editorSource tableColumns] count];
    lastcol = [cols lastIndex];
    if(lastcol == NSNotFound) {
        isEmpty = (nCols == 0);
        lastcol = !isEmpty ? (nCols - 1) : 0;
    }

    // add a column of type of last selected column or last
    if(!typeWasPassed && !isEmpty)
        newColType = [[objectColumnTypes objectAtIndex:lastcol] intValue];

    newvar++;

    if((nCols-1) == lastcol) {
        [objectColumnNames addObject:[NSString stringWithFormat:@"var %d", newvar]];
        [objectColumnTypes addObject:[NSNumber numberWithInteger:newColType]];
        [objectData addObject:[NSMutableArray array]];
    } else {
        [objectColumnNames insertObject:[NSString stringWithFormat:@"var %d", newvar] atIndex:lastcol+1];
        [objectColumnTypes insertObject:[NSNumber numberWithInteger:newColType] atIndex:lastcol+1];
        [objectData insertObject:[NSMutableArray array] atIndex:lastcol+1];
    }

    numberOfColumns++;

    if(!isEmpty) 
        for(i = 0; i < numberOfRows; i++)
            [NSArrayObjectAtIndex(objectData, (lastcol+1)) addObject:(newColType == NUMERIC) ? @"NA" : @""];

    [self setDataTable:NO];

}

/**
 * Adds a row to the data either at the end or after the last row selected by the user
 *
 *    FIXME: it actually crashes if a row is added in the middle of the data
 *           Bibiko: cannot reproduce anymore; still valid?
 *
 */
- (IBAction)addRow:(id)sender
{

    NSUInteger col, lastrow;
    BOOL isEmpty = NO;

    if(![[editorSource tableColumns] count]) return;

    NSIndexSet *rows =  [editorSource selectedRowIndexes];
    NSInteger nRows = ([objectData count]) ? [[objectData objectAtIndex:0] count] : 0;
    lastrow = [rows lastIndex]; // last row selected by the user

    if(lastrow == NSNotFound) {
        isEmpty = (nRows == 0);
        lastrow = isEmpty ? 0 : (nRows - 1);
    }

    if(lastrow == nRows)
        for(col = 0; col < [[editorSource tableColumns] count]; col++)
            [[objectData objectAtIndex:col] addObject:([[objectColumnTypes objectAtIndex:col] intValue] == NUMERIC) ? @"NA" : @""];
    else
        for(col = 0; col < [[editorSource tableColumns] count]; col++)
            [[objectData objectAtIndex:col] insertObject:([[objectColumnTypes objectAtIndex:col] intValue] == NUMERIC) ? @"NA" : @"" atIndex:lastrow+1];

    numberOfRows++;

    [editorSource reloadData];

    if([rows count] == 1)
        [editorSource selectRowIndexes:[NSIndexSet indexSetWithIndex:lastrow+1] byExtendingSelection:NO];

    return;

}

/**
 * Remove selected columns
 */
- (IBAction)remCols:(id)sender
{

    NSUInteger i;

    NSIndexSet *cols =  [editorSource selectedColumnIndexes];
    NSUInteger current_index = [cols firstIndex];
    if(current_index == NSNotFound)
        return;

    while (current_index != NSNotFound) {
        [editorSource removeTableColumn:[editorSource tableColumnWithIdentifier:[NSString stringWithFormat:@"%ld", current_index]]];
        current_index = [cols indexGreaterThanIndex:current_index];
    }

    [objectData removeObjectsAtIndexes:cols];
    [objectColumnTypes removeObjectsAtIndexes:cols];
    [objectColumnNames removeObjectsAtIndexes:cols];

    numberOfColumns -= [cols count];

    // if no column is given create a matrix 1 x 1 of value NA
    if(!numberOfColumns) {
        [objectData addObject:[NSMutableArray array]];
        [[objectData objectAtIndex:0] addObject:@"NA"];
        [objectColumnNames addObject:@"var1"];
        [objectColumnTypes addObject:[NSNumber numberWithInteger:NUMERIC]];
        numberOfRows = 1;
        numberOfColumns++;
        [self setDataTable:NO];
    } else {

        for(i = 0; i < numberOfColumns; i++)
            [[[editorSource tableColumns] objectAtIndex:i] setIdentifier:[NSString stringWithFormat:@"%ld", i]];

        [editorSource reloadData];

        [editorSource selectColumnIndexes:[NSIndexSet indexSetWithIndex:([cols lastIndex] < [[editorSource tableColumns] count]) ? [cols lastIndex] : [[editorSource tableColumns] count]-1] byExtendingSelection:NO];
    }

}

/**
 * Removes selected rows
 */
- (IBAction)remRows:(id)sender
{

    NSUInteger col, nrows;

    NSIndexSet *rows =  [editorSource selectedRowIndexes];
    nrows = [rows count];

    if (nrows < 1) return;

    numberOfRows -= nrows;

    for(col = 0; col < numberOfColumns; col++)
        [[objectData objectAtIndex:col] removeObjectsAtIndexes:rows];

    [editorSource reloadData];

    // Check last selected rows to reset selection if user deleted last row
    [editorSource selectRowIndexes:[NSIndexSet indexSetWithIndex:([rows firstIndex] < numberOfRows) ? [rows firstIndex] : numberOfRows-1] byExtendingSelection:NO];

}

- (IBAction)remSelection:(id)sender
{
    if([[editorSource selectedColumnIndexes] count])
        [self remCols:nil];
    else if([[editorSource selectedRowIndexes] count])
        [self remRows:nil];
}

- (IBAction)editColumnNames:(id)sender
{
    if([[editorSource tableColumns] count])
        [self editColumnNameOfTableColumn:[[editorSource tableColumns] objectAtIndex:0]];
    else
        NSBeep();
}

/**
 * Cancel editing without storing data and close the window
 */
- (IBAction)cancelEditing:(id)sender
{

    // sending abort signal to startDataEntry's runModalForWindow
    // to cancel the edit() by sending an error() message back to R
    [NSApp abortModal];

    [[[REditor getDEController] window] orderOut:self];
    [[[REditor getDEController] window] close];

}

#pragma mark -

- (BOOL)validateMenuItem:(NSMenuItem*)menuItem
{

    if ([menuItem action] == @selector(remSelection:)) {
        return ([[editorSource selectedColumnIndexes] count] || [[editorSource selectedRowIndexes] count]);
    }

    if ([menuItem action] == @selector(editColumnNames:)) {
        return ([[editorSource tableColumns] count] && editedColumnNameIndex < 0);
    }

    return YES;

}

@end