The R Project SVN – R – Diff – /trunk/src/modules/aqua/DataBrowser.c


/*
 *  R : A Computer Language for Statistical Data Analysis
 *  Copyright (C) 1995, 1996  Robert Gentleman and Ross Ihaka
 *  Copyright (C) 1997--2003  Robert Gentleman, Ross Ihaka
 *			      and the R Development Core Team
 *
 *  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.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
#ifndef __AQUA_DATA_BROWSER__
#define __AQUA_DATA_BROWSER__
 
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <Defn.h>
 
#ifdef HAVE_AQUA
#define __DEBUGGING__
 
# include <Carbon/Carbon.h>
# include "DataBrowser.h"
 
#include <limits.h>
 
#include <R.h>
#include <R_ext/Boolean.h>
#include <R_ext/Rdynload.h>
#include <Rdefines.h>
#include <Rinternals.h>
 
#ifndef kDataBrowserListViewAppendColumn
#define kDataBrowserListViewAppendColumn ULONG_MAX
#endif
#include "Raqua.h"
 
extern RAquaPrefs CurrentPrefs;
 
static void ConfigureDataBrowser(ControlRef);
static void CreateDataBrowser(WindowRef, ControlRef*);
static ControlRef GetDataBrowserFromWindow(WindowRef window);
static void InstallDataBrowserCallbacks(ControlRef);
 
static pascal OSStatus MyGetSetItemData(ControlRef browser, 
    DataBrowserItemID itemID, DataBrowserPropertyID property, 
    DataBrowserItemDataRef itemData, Boolean changeValue);
    
static pascal void MyItemNotification(
	ControlRef browser, 
	DataBrowserItemID itemID, 
	DataBrowserItemNotification message);
pascal OSStatus BrowserEventHandler(EventHandlerCallRef, EventRef, void*);
 
static pascal Boolean MyItemComparison(
	ControlRef browser, DataBrowserItemID itemOneID, 
	DataBrowserItemID itemTwoID, DataBrowserPropertyID sortProperty);
	
	
void OpenDataBrowser(void);
void CloseDataBrowser(void);
void FreeBrowserStuff(void);
 
Boolean isBrowserOpen = false;
WindowRef BrowserWindow = NULL;
ControlRef WSpaceBrowser = NULL;
Rboolean isEventHandlerOn = FALSE;
 
#define MaxItems  2500
 
/*
  How works the workspace browser? Suppose you have 4 objects
  in the workspace. The should be prepeared as follows:
 
  w vector
  x list of 3 objects
  y list of 2 object (d,e)
  z vector
 
  number of 
  total items  1  <-  w
             3+1  <-  x
             1+2  <-  y
            1  <-  z
            ---------
               9  Totale
            
object	ID			subitems	IsRoot	IsContainer
w		1			0			*
x		2			3			*		*
y		3			2			*		*
z		4			0			*
 
from x 
 
a		5			0
b		6			0
c		7			0
 
from y
d		8			0					
e		9			0
 
 
*/
 
UInt32		NumOfRoots = 0;
DataBrowserItemID	*RootItems = NULL; 
int		**SubItemsID;
int		CurrentID = 0;
void	InitContainers(void);
void	SetSubItems(int i);
 
Rect WSBounds = { 400, 400, 600, 800 };
 
/*
  id : integer, id number in the browser
  isroot : boolean, this id is a root item
  iscont : boolean, is container?
  numofit : integer, number of items
  parid   : parent id number
  name   : char, name of objects
  type   : type, class or mode
  objsize: can be dim, length or number of levels 
*/
 
/* The following are local copies of the above */
 
int *IDNum;              /* id          */
Rboolean *IsRoot;        /* isroot      */
Rboolean *IsContainer;   /* iscontainer */
UInt32 *NumberOfItems;      /* numofit     */
int *ParentID;           /* parid       */
char **Names;            /* name        */
char **Types;            /* type        */
char **Sizes;            /* objsize     */
int NumOfID = 0;         /* length of the vectors    */
                                /* We do not check for this */ 
 
SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env);
void EmptyDataBrowser(void);
 
SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env)
{
  int i;
   SEXP id, isroot, iscont, numofit, parid;
  SEXP name, type, objsize;
  char *vm;
   
  if(isBrowserOpen){
    EmptyDataBrowser();
   }
 
  FreeBrowserStuff();
    
  checkArity(op, args);
 
  vm = vmaxget();
  id = CAR(args); args = CDR(args);
  isroot = CAR(args); args = CDR(args);
  iscont = CAR(args); args = CDR(args);
  numofit = CAR(args); args = CDR(args);
  parid = CAR(args); args = CDR(args);
  name = CAR(args); args = CDR(args);
  type = CAR(args); args = CDR(args);
  objsize = CAR(args); 
 
  if(!isInteger(id)) {
   CloseDataBrowser();
   errorcall(call,"`id' must be integer");
   }
   
  NumOfID = LENGTH(id);
  if(NumOfID > MaxItems)
   NumOfID = MaxItems;
 
   
  if(!isString(name)){
    CloseDataBrowser();
	errorcall(call, "invalid objects' name");
  }
    
  if(!isString(type)){
    CloseDataBrowser();
    errorcall(call, "invalid objects' type");
   }
   
  if(!isString(objsize)){
    CloseDataBrowser();
	errorcall(call, "invalid objects' size");
  } 
  if(!isLogical(isroot)){
   CloseDataBrowser();
   errorcall(call, "invalid `isroot' definition");
  }
  
  if(!isLogical(iscont)){
    CloseDataBrowser();
	errorcall(call, "invalid `iscont' definition");
  } 
  
  if(!isInteger(numofit)){
   CloseDataBrowser(); 
   errorcall(call,"`numofit' must be integer");
  }
   
  if(!isInteger(parid)){
   CloseDataBrowser(); 
   errorcall(call,"`parid' must be integer");
  }
  
   
  Names = (char**)malloc(NumOfID * sizeof(char*));
  Sizes = (char**)malloc(NumOfID * sizeof(char*));
  Types = (char**)malloc(NumOfID * sizeof(char*));
 
  IDNum = (int*)malloc(NumOfID * sizeof(int));
  IsRoot = (Rboolean*)malloc(NumOfID * sizeof(Rboolean));
  IsContainer = (Rboolean *)malloc(NumOfID * sizeof(Rboolean));
  NumberOfItems = (UInt32 *)malloc(NumOfID * sizeof(UInt32));
  ParentID = (int*)malloc(NumOfID * sizeof(int));
   
  for(i=0; i<NumOfID; i++){
 
   if (!isNull(STRING_ELT(name, i)))
	    Names[i] = CHAR(STRING_ELT(name, i));
	else
	    Names[i] = CHAR(R_BlankString);
 
   if (!isNull(STRING_ELT(type, i)))
	    Types[i] = CHAR(STRING_ELT(type, i));
	else
	    Types[i] = CHAR(R_BlankString);
 
   if (!isNull(STRING_ELT(objsize, i)))
	    Sizes[i] = CHAR(STRING_ELT(objsize, i));
	else
	    Sizes[i] = CHAR(R_BlankString);  
 
    IDNum[i] = INTEGER(id)[i];
    NumberOfItems[i] = INTEGER(numofit)[i];
    if(INTEGER(parid)[i] == -1)
     ParentID[i] = kDataBrowserNoItem;
    else 
    ParentID[i] = INTEGER(parid)[i]; 
    IsRoot[i] = LOGICAL(isroot)[i];
    IsContainer[i] = LOGICAL(iscont)[i];
   
  }
 
  OpenDataBrowser();
 
  vmaxset(vm);
  return R_NilValue;
}
 
 
 
void InitContainers(void){
 
	int i, j, k=0, l;
	NumOfRoots = 0;
	
	for(i=0;i<NumOfID; i++)
	 if(IsRoot[i])
	  NumOfRoots++;
	if(RootItems) free(RootItems);
	  
	RootItems = malloc(sizeof(DataBrowserItemID)*NumOfRoots);
	SubItemsID = malloc(NumOfID * sizeof(int*));
 
	for(i = 0; i < NumOfID; i++){
     if(IsRoot[i]) { RootItems[k] = IDNum[i]; k++;}     
     if(IsContainer[i]){
      l = 0;
      SubItemsID[i] = malloc(sizeof(int)*NumberOfItems[i]);
      for(j=0; j<NumOfID; j++){
        if(ParentID[j] == IDNum[i]){
          SubItemsID[i][l] = IDNum[j];
          l++;
         }
       }
     } else {   /* if(IsContainer[i]) */
      SubItemsID[i] = malloc(sizeof(int));
      SubItemsID[i][0] = 0;
     }
	} /* for */
 
}
 
 
 
 
void OpenDataBrowser(void)
{
	OSStatus err = noErr;
	int i;
        Rect bounds; 
    EventTypeSpec windowEvents[] = {
		{ kEventClassCommand,	kEventCommandProcess }, 
		{ kEventClassCommand,	kEventCommandUpdateStatus }, 
		{ kEventClassWindow,	kEventWindowClose }, 
		{ kEventClassWindow,	kEventWindowGetIdealSize },
		{ kEventClassWindow,	kEventWindowBoundsChanged }, 
		{ kEventClassWindow,	kEventWindowGetClickActivation }
			};
    
     
      
   
    InitContainers();
 
 
    if(BrowserWindow == NULL) 
    CreateNewWindow(kDocumentWindowClass,  kWindowStandardHandlerAttribute |
            kWindowStandardDocumentAttributes, &WSBounds, &BrowserWindow);
 
    if(BrowserWindow == NULL)
     return;
     
     	
    if(!isEventHandlerOn){
     InstallWindowEventHandler(BrowserWindow, 
    		NewEventHandlerUPP(BrowserEventHandler), 
    		sizeof(windowEvents)/sizeof(EventTypeSpec), windowEvents, NULL, NULL);
     isEventHandlerOn = TRUE;
     SetWindowTitleWithCFString(BrowserWindow, CFSTR("R Workspace Browser"));
    }
     
     
    
    /* Create the DataBrowser */
    if(WSpaceBrowser==NULL){
     CreateDataBrowser(BrowserWindow, &WSpaceBrowser);
     InstallDataBrowserCallbacks(WSpaceBrowser);
 
    /* Configure the DataBrowser */
	if(!isBrowserOpen)
	 ConfigureDataBrowser(WSpaceBrowser);
    err = SetDataBrowserTarget(WSpaceBrowser, 0);
   
    AddDataBrowserItems(WSpaceBrowser, kDataBrowserNoItem, 
				NumOfRoots, RootItems, kDataBrowserItemNoProperty);
 
    /* Set the keyboard focus */
	SetKeyboardFocus(BrowserWindow, WSpaceBrowser, kControlDataBrowserPart);
	
	/* Store DB as a window property */
    SetWindowProperty(BrowserWindow,
        kMyCreator, kMyDataBrowser,
        sizeof(WSpaceBrowser), &WSpaceBrowser);
 
	
    }
    
	if(WSpaceBrowser == NULL){              
	 CloseDataBrowser();	 
	 return;
	}
	
 
    ShowWindow(BrowserWindow);
   
    GetPortBounds(GetWindowPort(BrowserWindow), &bounds);
    SizeControl(WSpaceBrowser, bounds.right - bounds.left, bounds.bottom - bounds.top);
 
 
    isBrowserOpen = true;
}
 
void FreeBrowserStuff(void)
{    
    if(SubItemsID) { free(SubItemsID); SubItemsID = NULL; }
 
    NumOfID = 0;
    
    if(RootItems)
     { free(RootItems); RootItems = NULL; }
 
    if(Names)   { free(Names); Names = NULL; }
    if(Sizes)   { free(Sizes); Sizes = NULL; }
    if(Types)   { free(Types); Types = NULL; }
    if(IDNum)   { free(IDNum); IDNum = NULL; }
    if(IsRoot)  { free(IsRoot); IsRoot = NULL; }
    if(IsContainer)  { free(IsContainer); IsContainer = NULL; }
    if(NumberOfItems) { free(NumberOfItems); NumberOfItems = NULL; }
    if(ParentID) { free(ParentID); ParentID = NULL; }
 
}
 
 
 
void EmptyDataBrowser(void)
{
  RemoveDataBrowserItems (WSpaceBrowser, kDataBrowserNoItem, 0, 
          NULL, kDataBrowserItemNoProperty);
} 
 
void CloseDataBrowser(void)
{
 
    if(BrowserWindow){
     if( GetWindowBounds(BrowserWindow,kWindowStructureRgn,&WSBounds) != noErr)
      SetRect(&WSBounds, 400, 400, 600, 800);
    }
    else 
     SetRect(&WSBounds, 400, 400, 600, 800);
      
	
    DisposeWindow(BrowserWindow);
    BrowserWindow = NULL;
    
	isEventHandlerOn = FALSE;
	
    FreeBrowserStuff();
          
    isBrowserOpen = false;
    WSpaceBrowser = NULL;
} 
 
static void CreateDataBrowser(WindowRef window, ControlRef *browser)
{
    Rect bounds;
    Boolean frameAndFocus = false;
    
    /* Create a DataBrowser */
    GetWindowBounds(window, kWindowContentRgn, &bounds);
 
    bounds.top = bounds.left = 0;
    bounds.right = bounds.right - bounds.left;
    bounds.bottom = bounds.bottom - bounds.top;
    
    CreateDataBrowserControl(window, 
    	&bounds, kDataBrowserListView, browser);
 
    /* Turn off DB's focus frame */
	SetControlData(
		*browser, kControlNoPart, 
		kControlDataBrowserIncludesFrameAndFocusTag,
		sizeof(frameAndFocus), &frameAndFocus);
}
 
static void ConfigureDataBrowser(ControlRef browser)
{
	Rect insetRect;
	DataBrowserViewStyle viewStyle;
        SInt16                            fontID;
        Str255	fontname;
     
	GetDataBrowserViewStyle(browser, &viewStyle);
	
	GetDataBrowserScrollBarInset(browser, &insetRect);
	
	insetRect.right = 16 - 1;
	SetDataBrowserScrollBarInset(browser, &insetRect);
 
	switch (viewStyle)
	{
		case kDataBrowserListView:
		{	DataBrowserListViewColumnDesc columnDesc;
			
			columnDesc.headerBtnDesc.titleOffset = 0;
			
			columnDesc.headerBtnDesc.version = 
				kDataBrowserListViewLatestHeaderDesc;
				
			columnDesc.headerBtnDesc.btnFontStyle.flags	= 
				kControlUseFontMask | kControlUseJustMask;
			
			columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlNoContent;
 
 
			/* Add the Object column */
			
			columnDesc.propertyDesc.propertyID = kObjectColumn;
			columnDesc.propertyDesc.propertyType = kDataBrowserTextType;
			columnDesc.propertyDesc.propertyFlags = kDataBrowserPropertyIsMutable | 
			  kDataBrowserListViewDefaultColumnFlags;
			
		 
			columnDesc.headerBtnDesc.minimumWidth = 30;
			columnDesc.headerBtnDesc.maximumWidth = 200;
			
			columnDesc.headerBtnDesc.btnFontStyle.just = teFlushLeft;
	
                        CopyCStringToPascal(CurrentPrefs.ConsoleFontName, fontname);
                        GetFNum(fontname,&fontID);
      
			columnDesc.headerBtnDesc.btnFontStyle.font = fontID;
			columnDesc.headerBtnDesc.btnFontStyle.size = CurrentPrefs.ConsoleFontSize;
			columnDesc.headerBtnDesc.btnFontStyle.style = normal;
			columnDesc.headerBtnDesc.btnFontStyle.backColor = CurrentPrefs.BGOutputColor;
			
			columnDesc.headerBtnDesc.titleString = CFStringCreateWithCString(
				CFAllocatorGetDefault(), "Object", kCFStringEncodingMacRoman);
			
			AddDataBrowserListViewColumn(browser, 
				&columnDesc, kDataBrowserListViewAppendColumn),
			
			/* Add the Type column */
			
			columnDesc.propertyDesc.propertyID = kTypeColumn;
			
			columnDesc.headerBtnDesc.btnFontStyle.just = teFlushLeft;
 
			columnDesc.propertyDesc.propertyFlags = kDataBrowserPropertyIsMutable | 
													kDataBrowserListViewDefaultColumnFlags;
 
			columnDesc.headerBtnDesc.titleString = CFStringCreateWithCString(
				CFAllocatorGetDefault(), "Type", kCFStringEncodingMacRoman);
			
			AddDataBrowserListViewColumn(browser, 
				&columnDesc, kDataBrowserListViewAppendColumn);
			
			/* Add the Properties column */
			
			columnDesc.propertyDesc.propertyID = kSizeColumn;
			columnDesc.propertyDesc.propertyType = kDataBrowserTextType;
			columnDesc.propertyDesc.propertyFlags = kDataBrowserPropertyIsMutable | 
													kDataBrowserListViewDefaultColumnFlags;
			
		
			columnDesc.headerBtnDesc.minimumWidth = 30;
			columnDesc.headerBtnDesc.maximumWidth = 200;
			columnDesc.headerBtnDesc.btnFontStyle.just = teFlushLeft;
			
			columnDesc.headerBtnDesc.titleString =CFStringCreateWithCString(
				CFAllocatorGetDefault(), "Property", kCFStringEncodingMacRoman);
		
			AddDataBrowserListViewColumn(browser, 
				&columnDesc, kDataBrowserListViewAppendColumn);
			 
			SetDataBrowserListViewDisclosureColumn(browser, kObjectColumn, false);
			
		}	break;
	}
}
 
 
static ControlRef GetDataBrowserFromWindow(WindowRef window)
{
	ControlRef browser = NULL;
	
	if (window != NULL)
		GetWindowProperty(window, kMyCreator, 
		kMyDataBrowser, sizeof(browser), NULL, &browser);
	
	return browser;
}
 
 
void InstallDataBrowserCallbacks(ControlRef browser)
{
    DataBrowserCallbacks myCallbacks;
    
 
    myCallbacks.version = kDataBrowserLatestCallbacks;
    InitDataBrowserCallbacks(&myCallbacks);
    
    myCallbacks.u.v1.itemDataCallback = 
        NewDataBrowserItemDataUPP(MyGetSetItemData);
	
	myCallbacks.u.v1.itemCompareCallback = 
		NewDataBrowserItemCompareUPP(MyItemComparison);
 
    myCallbacks.u.v1.itemNotificationCallback = 
        NewDataBrowserItemNotificationUPP(MyItemNotification);
     
 
    SetDataBrowserCallbacks(browser, &myCallbacks);
}
 
 
 
static pascal Boolean MyItemComparison(
	ControlRef browser, DataBrowserItemID itemOneID, 
	DataBrowserItemID itemTwoID, DataBrowserPropertyID sortProperty)
{
	SInt16 compareResult = 0;
	
	#define Compare(i1,i2,p) MyItemComparison(browser,i1,i2,p)
	
	switch (sortProperty)
	{
		case kObjectColumn:
		{	Str255 s1, s2;
			compareResult = strcmp(Names[itemOneID-1],Names[itemTwoID-1]);
			if (compareResult < 0) return true;
			else if (compareResult > 0) return false;
			else return Compare(itemOneID, itemTwoID, kDontKnow);
		}	break;
		
		default:
		{	return itemOneID < itemTwoID;
		}	break;
	}
}
 
 
 
static pascal OSStatus MyGetSetItemData(ControlRef browser, 
    DataBrowserItemID itemID, DataBrowserPropertyID property, 
    DataBrowserItemDataRef itemData, Boolean changeValue)
{
#pragma unused (browser)
	Str255 pascalString;
	OSStatus err = noErr;
	
	if (!changeValue) 
	 switch (property)
	{
		
		case kObjectColumn:
		{
			CFStringRef text;
                        CopyCStringToPascal(Names[itemID-1],pascalString);
			text = CFStringCreateWithPascalString(
				CFAllocatorGetDefault(), pascalString, kCFStringEncodingMacRoman);
			err = SetDataBrowserItemDataText(itemData, text); 
		CFRelease(text);
		}	
		break;
 
		case kTypeColumn:
		{	CFStringRef text;
			CopyCStringToPascal(Types[itemID-1],pascalString);
			 text = CFStringCreateWithPascalString(
				CFAllocatorGetDefault(), pascalString, kCFStringEncodingMacRoman);
			err = SetDataBrowserItemDataText(itemData, text); 
			CFRelease(text);
		}	
		break;
				
 
		case kSizeColumn:
		{
			CFStringRef text=NULL;
				CopyCStringToPascal(Sizes[itemID-1],pascalString);
			text = CFStringCreateWithPascalString(
				CFAllocatorGetDefault(), pascalString, kCFStringEncodingMacRoman);
			err = SetDataBrowserItemDataText(itemData, text); 
			CFRelease(text);
		}	
		break;
		
 
		
		case kDataBrowserItemIsEditableProperty:
		{	err = SetDataBrowserItemDataBooleanValue(itemData, false);
		}	break;
		
		case kDataBrowserItemIsContainerProperty:
		{	err = SetDataBrowserItemDataBooleanValue(itemData, IsContainer[itemID-1]);
		}	break;
		
		case kDataBrowserItemParentContainerProperty:
		{	err = SetDataBrowserItemDataItemID(itemData, ParentID[itemID-1]);
		}	break;
 
		default:
		{	err = errDataBrowserPropertyNotSupported;
		}	break;
	}
	else err = errDataBrowserPropertyNotSupported;
	
	return err;
}
 
 
 static pascal void MyItemNotification(
	ControlRef browser, 
	DataBrowserItemID itemID, 
	DataBrowserItemNotification message)
{
	UInt32 i;
	UInt32 numSelectedItems;
	UInt16 j;
	
	switch (message)
	{
		case kDataBrowserItemSelected:
		{	Handle handle = NewHandle(0);
			GetDataBrowserItems(browser, 
				kDataBrowserNoItem, true, kDataBrowserItemIsSelected, handle);
		    numSelectedItems = GetHandleSize(handle)/sizeof(DataBrowserItemID);
		}	break;
		
		case kDataBrowserContainerOpened:
		{	
                AddDataBrowserItems(browser, itemID, NumberOfItems[itemID-1], (DataBrowserItemID *)SubItemsID[itemID-1], kObjectColumn);
			{	
				Boolean variableHeightRows;
				GetDataBrowserTableViewGeometry(
					browser, NULL, &variableHeightRows);
					
				if (variableHeightRows)
					for ( j = 0; j < NumberOfItems[itemID-1]; j++)
						SetDataBrowserTableViewItemRowHeight(
							browser, SubItemsID[itemID-1][j], 20 + (SubItemsID[itemID-1][j] - 1) % 10 * 3);
			}
		}	
		
		break;
	}
}
 
pascal OSStatus BrowserEventHandler(
	EventHandlerCallRef a, EventRef inEvent, void*b)
{
    OSStatus result = noErr;
 
	switch (GetEventClass(inEvent))
	{
    	default:
    	{	result = eventNotHandledErr;
    	}	break;
		
 
		
	    case kEventClassWindow:
		{
		    WindowRef window = NULL;
			GetEventParameter(inEvent, 
		        kEventParamDirectObject, typeWindowRef, 
		        NULL, sizeof(window), NULL, &window);
 
		    switch (GetEventKind(inEvent))
		 	{
		    	default:
		    	{	result = eventNotHandledErr;
		    	}	break;
				
				
				 case kEventWindowClose:
		     	{
                  	CloseDataBrowser();
			 	}	break;
 
		    	case kEventWindowBoundsChanged:
		    	{	ControlRef browser = GetDataBrowserFromWindow(window);
		    		Rect bounds; GetPortBounds(GetWindowPort(window), &bounds);
		        	SizeControl(browser, bounds.right - bounds.left, bounds.bottom - bounds.top);
		    	}	break;
				
							
				 
			}
		}	break;
	}
	   
    return result;
}
 
#endif  /* HAVE_AQUA */
 
#endif /* __AQUA_DATA_BROWSER__ */

Rev 26123	Rev 27143
1	`/*`	1	`/*`
2	`* R : A Computer Language for Statistical Data Analysis`	2	`* R : A Computer Language for Statistical Data Analysis`
3	`* Copyright (C) 1995, 1996 Robert Gentleman and Ross Ihaka`	3	`* Copyright (C) 1995, 1996 Robert Gentleman and Ross Ihaka`
4	`* Copyright (C) 1997--2003 Robert Gentleman, Ross Ihaka`	4	`* Copyright (C) 1997--2003 Robert Gentleman, Ross Ihaka`
5	`* and the R Development Core Team`	5	`* and the R Development Core Team`
6	`*`	6	`*`
7	`* This program is free software; you can redistribute it and/or modify`	7	`* This program is free software; you can redistribute it and/or modify`
8	`* it under the terms of the GNU General Public License as published by`	8	`* it under the terms of the GNU General Public License as published by`
9	`* the Free Software Foundation; either version 2 of the License, or`	9	`* the Free Software Foundation; either version 2 of the License, or`
10	`* (at your option) any later version.`	10	`* (at your option) any later version.`
11	`*`	11	`*`
12	`* This program is distributed in the hope that it will be useful,`	12	`* This program is distributed in the hope that it will be useful,`
13	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`	13	`* but WITHOUT ANY WARRANTY; without even the implied warranty of`
14	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`	14	`* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the`
15	`* GNU General Public License for more details.`	15	`* GNU General Public License for more details.`
16	`*`	16	`*`
17	`* You should have received a copy of the GNU General Public License`	17	`* You should have received a copy of the GNU General Public License`
18	`* along with this program; if not, write to the Free Software`	18	`* along with this program; if not, write to the Free Software`
19	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`	19	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
20	`*/`	20	`*/`
21		21
22	`#ifndef __AQUA_DATA_BROWSER__`	22	`#ifndef __AQUA_DATA_BROWSER__`
23	`#define __AQUA_DATA_BROWSER__`	23	`#define __AQUA_DATA_BROWSER__`
24		24
25		25
26	`#ifdef HAVE_CONFIG_H`	26	`#ifdef HAVE_CONFIG_H`
27	`#include <config.h>`	27	`#include <config.h>`
28	`#endif`	28	`#endif`
29	`#include <Defn.h>`	29	`#include <Defn.h>`
30		30
31	`#ifdef HAVE_AQUA`	31	`#ifdef HAVE_AQUA`
32	`#define __DEBUGGING__`	32	`#define __DEBUGGING__`
33		33
34	`# include <Carbon/Carbon.h>`	34	`# include <Carbon/Carbon.h>`
35	`# include "DataBrowser.h"`	35	`# include "DataBrowser.h"`
36		36
37	`#include <limits.h>`	37	`#include <limits.h>`
38		38
39	`#include <R.h>`	39	`#include <R.h>`
40	`#include <R_ext/Boolean.h>`	40	`#include <R_ext/Boolean.h>`
41	`#include <R_ext/Rdynload.h>`	41	`#include <R_ext/Rdynload.h>`
42	`#include <Rdefines.h>`	42	`#include <Rdefines.h>`
43	`#include <Rinternals.h>`	43	`#include <Rinternals.h>`
44		44
45	`#ifndef kDataBrowserListViewAppendColumn`	45	`#ifndef kDataBrowserListViewAppendColumn`
46	`#define kDataBrowserListViewAppendColumn ULONG_MAX`	46	`#define kDataBrowserListViewAppendColumn ULONG_MAX`
47	`#endif`	47	`#endif`
48	`#include "Raqua.h"`	48	`#include "Raqua.h"`
49		49
50	`extern RAquaPrefs CurrentPrefs;`	50	`extern RAquaPrefs CurrentPrefs;`
51		51
52	`static void ConfigureDataBrowser(ControlRef);`	52	`static void ConfigureDataBrowser(ControlRef);`
53	`static void CreateDataBrowser(WindowRef, ControlRef*);`	53	`static void CreateDataBrowser(WindowRef, ControlRef*);`
54	`static ControlRef GetDataBrowserFromWindow(WindowRef window);`	54	`static ControlRef GetDataBrowserFromWindow(WindowRef window);`
55	`static void InstallDataBrowserCallbacks(ControlRef);`	55	`static void InstallDataBrowserCallbacks(ControlRef);`
56		56
57	`static pascal OSStatus MyGetSetItemData(ControlRef browser,`	57	`static pascal OSStatus MyGetSetItemData(ControlRef browser,`
58	`DataBrowserItemID itemID, DataBrowserPropertyID property,`	58	`DataBrowserItemID itemID, DataBrowserPropertyID property,`
59	`DataBrowserItemDataRef itemData, Boolean changeValue);`	59	`DataBrowserItemDataRef itemData, Boolean changeValue);`
60		60
61	`static pascal void MyItemNotification(`	61	`static pascal void MyItemNotification(`
62	`ControlRef browser,`	62	`ControlRef browser,`
63	`DataBrowserItemID itemID,`	63	`DataBrowserItemID itemID,`
64	`DataBrowserItemNotification message);`	64	`DataBrowserItemNotification message);`
65	`pascal OSStatus BrowserEventHandler(EventHandlerCallRef, EventRef, void*);`	65	`pascal OSStatus BrowserEventHandler(EventHandlerCallRef, EventRef, void*);`
66		66
67	`static pascal Boolean MyItemComparison(`	67	`static pascal Boolean MyItemComparison(`
68	`ControlRef browser, DataBrowserItemID itemOneID,`	68	`ControlRef browser, DataBrowserItemID itemOneID,`
69	`DataBrowserItemID itemTwoID, DataBrowserPropertyID sortProperty);`	69	`DataBrowserItemID itemTwoID, DataBrowserPropertyID sortProperty);`
70		70
71		71
72	`void OpenDataBrowser(void);`	72	`void OpenDataBrowser(void);`
73	`void CloseDataBrowser(void);`	73	`void CloseDataBrowser(void);`
74	`void FreeBrowserStuff(void);`	74	`void FreeBrowserStuff(void);`
75		75
76	`Boolean isBrowserOpen = false;`	76	`Boolean isBrowserOpen = false;`
77	`WindowRef BrowserWindow = NULL;`	77	`WindowRef BrowserWindow = NULL;`
78	`ControlRef WSpaceBrowser = NULL;`	78	`ControlRef WSpaceBrowser = NULL;`
79	`Rboolean isEventHandlerOn = FALSE;`	79	`Rboolean isEventHandlerOn = FALSE;`
80		80
81	`#define MaxItems 2500`	81	`#define MaxItems 2500`
82		82
83	`/*`	83	`/*`
84	`How works the workspace browser? Suppose you have 4 objects`	84	`How works the workspace browser? Suppose you have 4 objects`
85	`in the workspace. The should be prepeared as follows:`	85	`in the workspace. The should be prepeared as follows:`
86		86
87	`w vector`	87	`w vector`
88	`x list of 3 objects`	88	`x list of 3 objects`
89	`y list of 2 object (d,e)`	89	`y list of 2 object (d,e)`
90	`z vector`	90	`z vector`
91		91
92	`number of`	92	`number of`
93	`total items 1 <- w`	93	`total items 1 <- w`
94	`3+1 <- x`	94	`3+1 <- x`
95	`1+2 <- y`	95	`1+2 <- y`
96	`1 <- z`	96	`1 <- z`
97	`---------`	97	`---------`
98	`9 Totale`	98	`9 Totale`
99		99
100	`object ID subitems IsRoot IsContainer`	100	`object ID subitems IsRoot IsContainer`
101	`w 1 0 *`	101	`w 1 0 *`
102	`x 2 3 * *`	102	`x 2 3 * *`
103	`y 3 2 * *`	103	`y 3 2 * *`
104	`z 4 0 *`	104	`z 4 0 *`
105		105
106	`from x`	106	`from x`
107		107
108	`a 5 0`	108	`a 5 0`
109	`b 6 0`	109	`b 6 0`
110	`c 7 0`	110	`c 7 0`
111		111
112	`from y`	112	`from y`
113	`d 8 0`	113	`d 8 0`
114	`e 9 0`	114	`e 9 0`
115		115
116		116
117	`*/`	117	`*/`
118		118
119	`int NumOfRoots = 0;`	119	`UInt32 NumOfRoots = 0;`
120	`int *RootItems = NULL;`	120	`DataBrowserItemID *RootItems = NULL;`
121	`int **SubItemsID;`	121	`int **SubItemsID;`
122	`int CurrentID = 0;`	122	`int CurrentID = 0;`
123	`void InitContainers(void);`	123	`void InitContainers(void);`
124	`void SetSubItems(int i);`	124	`void SetSubItems(int i);`
125		125
126	`Rect WSBounds = { 400, 400, 600, 800 };`	126	`Rect WSBounds = { 400, 400, 600, 800 };`
127		127
128	`/*`	128	`/*`
129	`id : integer, id number in the browser`	129	`id : integer, id number in the browser`
130	`isroot : boolean, this id is a root item`	130	`isroot : boolean, this id is a root item`
131	`iscont : boolean, is container?`	131	`iscont : boolean, is container?`
132	`numofit : integer, number of items`	132	`numofit : integer, number of items`
133	`parid : parent id number`	133	`parid : parent id number`
134	`name : char, name of objects`	134	`name : char, name of objects`
135	`type : type, class or mode`	135	`type : type, class or mode`
136	`objsize: can be dim, length or number of levels`	136	`objsize: can be dim, length or number of levels`
137	`*/`	137	`*/`
138		138
139	`/* The following are local copies of the above */`	139	`/* The following are local copies of the above */`
140		140
141	`int IDNum; / id */`	141	`int IDNum; / id */`
142	`Rboolean IsRoot; / isroot */`	142	`Rboolean IsRoot; / isroot */`
143	`Rboolean IsContainer; / iscontainer */`	143	`Rboolean IsContainer; / iscontainer */`
144	`int NumberOfItems; / numofit */`	144	`UInt32 NumberOfItems; / numofit */`
145	`int ParentID; / parid */`	145	`int ParentID; / parid */`
146	`char *Names; / name */`	146	`char *Names; / name */`
147	`char *Types; / type */`	147	`char *Types; / type */`
148	`char *Sizes; / objsize */`	148	`char *Sizes; / objsize */`
149	`int NumOfID = 0; /* length of the vectors */`	149	`int NumOfID = 0; /* length of the vectors */`
150	`/* We do not check for this */`	150	`/* We do not check for this */`
151		151
152	`SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env);`	152	`SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env);`
153	`void EmptyDataBrowser(void);`	153	`void EmptyDataBrowser(void);`
154		154
155	`SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env)`	155	`SEXP Raqua_do_wsbrowser(SEXP call, SEXP op, SEXP args, SEXP env)`
156	`{`	156	`{`
157	`int i;`	157	`int i;`
158	`SEXP id, isroot, iscont, numofit, parid;`	158	`SEXP id, isroot, iscont, numofit, parid;`
159	`SEXP name, type, objsize;`	159	`SEXP name, type, objsize;`
160	`char *vm;`	160	`char *vm;`
161		161
162	`if(isBrowserOpen){`	162	`if(isBrowserOpen){`
163	`EmptyDataBrowser();`	163	`EmptyDataBrowser();`
164	`}`	164	`}`
165		165
166	`FreeBrowserStuff();`	166	`FreeBrowserStuff();`
167		167
168	`checkArity(op, args);`	168	`checkArity(op, args);`
169		169
170	`vm = vmaxget();`	170	`vm = vmaxget();`
171	`id = CAR(args); args = CDR(args);`	171	`id = CAR(args); args = CDR(args);`
172	`isroot = CAR(args); args = CDR(args);`	172	`isroot = CAR(args); args = CDR(args);`
173	`iscont = CAR(args); args = CDR(args);`	173	`iscont = CAR(args); args = CDR(args);`
174	`numofit = CAR(args); args = CDR(args);`	174	`numofit = CAR(args); args = CDR(args);`
175	`parid = CAR(args); args = CDR(args);`	175	`parid = CAR(args); args = CDR(args);`
176	`name = CAR(args); args = CDR(args);`	176	`name = CAR(args); args = CDR(args);`
177	`type = CAR(args); args = CDR(args);`	177	`type = CAR(args); args = CDR(args);`
178	`objsize = CAR(args);`	178	`objsize = CAR(args);`
179		179
180	`if(!isInteger(id)) {`	180	`if(!isInteger(id)) {`
181	`CloseDataBrowser();`	181	`CloseDataBrowser();`
182	errorcall(call,"`id' must be integer");	182	errorcall(call,"`id' must be integer");
183	`}`	183	`}`
184		184
185	`NumOfID = LENGTH(id);`	185	`NumOfID = LENGTH(id);`
186	`if(NumOfID > MaxItems)`	186	`if(NumOfID > MaxItems)`
187	`NumOfID = MaxItems;`	187	`NumOfID = MaxItems;`
188		188
189		189
190	`if(!isString(name)){`	190	`if(!isString(name)){`
191	`CloseDataBrowser();`	191	`CloseDataBrowser();`
192	`errorcall(call, "invalid objects' name");`	192	`errorcall(call, "invalid objects' name");`
193	`}`	193	`}`
194		194
195	`if(!isString(type)){`	195	`if(!isString(type)){`
196	`CloseDataBrowser();`	196	`CloseDataBrowser();`
197	`errorcall(call, "invalid objects' type");`	197	`errorcall(call, "invalid objects' type");`
198	`}`	198	`}`
199		199
200	`if(!isString(objsize)){`	200	`if(!isString(objsize)){`
201	`CloseDataBrowser();`	201	`CloseDataBrowser();`
202	`errorcall(call, "invalid objects' size");`	202	`errorcall(call, "invalid objects' size");`
203	`}`	203	`}`
204	`if(!isLogical(isroot)){`	204	`if(!isLogical(isroot)){`
205	`CloseDataBrowser();`	205	`CloseDataBrowser();`
206	errorcall(call, "invalid `isroot' definition");	206	errorcall(call, "invalid `isroot' definition");
207	`}`	207	`}`
208		208
209	`if(!isLogical(iscont)){`	209	`if(!isLogical(iscont)){`
210	`CloseDataBrowser();`	210	`CloseDataBrowser();`
211	errorcall(call, "invalid `iscont' definition");	211	errorcall(call, "invalid `iscont' definition");
212	`}`	212	`}`
213		213
214	`if(!isInteger(numofit)){`	214	`if(!isInteger(numofit)){`
215	`CloseDataBrowser();`	215	`CloseDataBrowser();`
216	errorcall(call,"`numofit' must be integer");	216	errorcall(call,"`numofit' must be integer");
217	`}`	217	`}`
218		218
219	`if(!isInteger(parid)){`	219	`if(!isInteger(parid)){`
220	`CloseDataBrowser();`	220	`CloseDataBrowser();`
221	errorcall(call,"`parid' must be integer");	221	errorcall(call,"`parid' must be integer");
222	`}`	222	`}`
223		223
224		224
225	`Names = (char*)malloc(NumOfID sizeof(char*));`	225	`Names = (char*)malloc(NumOfID sizeof(char*));`
226	`Sizes = (char*)malloc(NumOfID sizeof(char*));`	226	`Sizes = (char*)malloc(NumOfID sizeof(char*));`
227	`Types = (char*)malloc(NumOfID sizeof(char*));`	227	`Types = (char*)malloc(NumOfID sizeof(char*));`
228		228
229	`IDNum = (int)malloc(NumOfID sizeof(int));`	229	`IDNum = (int)malloc(NumOfID sizeof(int));`
230	`IsRoot = (Rboolean)malloc(NumOfID sizeof(Rboolean));`	230	`IsRoot = (Rboolean)malloc(NumOfID sizeof(Rboolean));`
231	`IsContainer = (Rboolean)malloc(NumOfID sizeof(Rboolean));`	231	`IsContainer = (Rboolean )malloc(NumOfID sizeof(Rboolean));`
232	`NumberOfItems = (int)malloc(NumOfID sizeof(int));`	232	`NumberOfItems = (UInt32 )malloc(NumOfID sizeof(UInt32));`
233	`ParentID = (int)malloc(NumOfID sizeof(int));`	233	`ParentID = (int)malloc(NumOfID sizeof(int));`
234		234
235	`for(i=0; i<NumOfID; i++){`	235	`for(i=0; i<NumOfID; i++){`
236		236
237	`if (!isNull(STRING_ELT(name, i)))`	237	`if (!isNull(STRING_ELT(name, i)))`
238	`Names[i] = CHAR(STRING_ELT(name, i));`	238	`Names[i] = CHAR(STRING_ELT(name, i));`
239	`else`	239	`else`
240	`Names[i] = CHAR(R_BlankString);`	240	`Names[i] = CHAR(R_BlankString);`
241		241
242	`if (!isNull(STRING_ELT(type, i)))`	242	`if (!isNull(STRING_ELT(type, i)))`
243	`Types[i] = CHAR(STRING_ELT(type, i));`	243	`Types[i] = CHAR(STRING_ELT(type, i));`
244	`else`	244	`else`
245	`Types[i] = CHAR(R_BlankString);`	245	`Types[i] = CHAR(R_BlankString);`
246		246
247	`if (!isNull(STRING_ELT(objsize, i)))`	247	`if (!isNull(STRING_ELT(objsize, i)))`
248	`Sizes[i] = CHAR(STRING_ELT(objsize, i));`	248	`Sizes[i] = CHAR(STRING_ELT(objsize, i));`
249	`else`	249	`else`
250	`Sizes[i] = CHAR(R_BlankString);`	250	`Sizes[i] = CHAR(R_BlankString);`
251		251
252	`IDNum[i] = INTEGER(id)[i];`	252	`IDNum[i] = INTEGER(id)[i];`
253	`NumberOfItems[i] = INTEGER(numofit)[i];`	253	`NumberOfItems[i] = INTEGER(numofit)[i];`
-		254	`if(INTEGER(parid)[i] == -1)`
-		255	`ParentID[i] = kDataBrowserNoItem;`
-		256	`else`
254	`ParentID[i] = INTEGER(parid)[i];`	257	`ParentID[i] = INTEGER(parid)[i];`
255	`IsRoot[i] = LOGICAL(isroot)[i];`	258	`IsRoot[i] = LOGICAL(isroot)[i];`
256	`IsContainer[i] = LOGICAL(iscont)[i];`	259	`IsContainer[i] = LOGICAL(iscont)[i];`
-		260
257	`}`	261	`}`
258		262
259	`OpenDataBrowser();`	263	`OpenDataBrowser();`
260		264
261	`vmaxset(vm);`	265	`vmaxset(vm);`
262	`return R_NilValue;`	266	`return R_NilValue;`
263	`}`	267	`}`
264		268
265		269
266		270
267	`void InitContainers(void){`	271	`void InitContainers(void){`
268		272
269	`int i, j, k=0, l;`	273	`int i, j, k=0, l;`
270	`NumOfRoots = 0;`	274	`NumOfRoots = 0;`
271		275
272	`for(i=0;i<NumOfID; i++)`	276	`for(i=0;i<NumOfID; i++)`
273	`if(IsRoot[i])`	277	`if(IsRoot[i])`
274	`NumOfRoots++;`	278	`NumOfRoots++;`
275	`if(RootItems) free(RootItems);`	279	`if(RootItems) free(RootItems);`
276		280
277	`RootItems = malloc(sizeof(int)*NumOfRoots);`	281	`RootItems = malloc(sizeof(DataBrowserItemID)*NumOfRoots);`
278	`SubItemsID = malloc(NumOfID * sizeof(int*));`	282	`SubItemsID = malloc(NumOfID * sizeof(int*));`
279		283
280	`for(i = 0; i < NumOfID; i++){`	284	`for(i = 0; i < NumOfID; i++){`
281	`if(IsRoot[i]) { RootItems[k] = IDNum[i]; k++;}`	285	`if(IsRoot[i]) { RootItems[k] = IDNum[i]; k++;}`
282	`if(IsContainer[i]){`	286	`if(IsContainer[i]){`
283	`l = 0;`	287	`l = 0;`
284	`SubItemsID[i] = malloc(sizeof(int)*NumberOfItems[i]);`	288	`SubItemsID[i] = malloc(sizeof(int)*NumberOfItems[i]);`
285	`for(j=0; j<NumOfID; j++){`	289	`for(j=0; j<NumOfID; j++){`
286	`if(ParentID[j] == IDNum[i]){`	290	`if(ParentID[j] == IDNum[i]){`
287	`SubItemsID[i][l] = IDNum[j];`	291	`SubItemsID[i][l] = IDNum[j];`
288	`l++;`	292	`l++;`
289	`}`	293	`}`
290	`}`	294	`}`
291	`} /* if(IsContainer[i]) */`	295	`} else { /* if(IsContainer[i]) */`
-		296	`SubItemsID[i] = malloc(sizeof(int));`
-		297	`SubItemsID[i][0] = 0;`
-		298	`}`
292	`} /* for */`	299	`} /* for */`
293		300
294	`}`	301	`}`
295		302
296		303
297		304
298		305
299	`void OpenDataBrowser(void)`	306	`void OpenDataBrowser(void)`
300	`{`	307	`{`
301	`OSStatus err = noErr;`	308	`OSStatus err = noErr;`
302	`int i;`	309	`int i;`
303	`Rect bounds;`	310	`Rect bounds;`
304	`EventTypeSpec windowEvents[] = {`	311	`EventTypeSpec windowEvents[] = {`
305	`{ kEventClassCommand, kEventCommandProcess },`	312	`{ kEventClassCommand, kEventCommandProcess },`
306	`{ kEventClassCommand, kEventCommandUpdateStatus },`	313	`{ kEventClassCommand, kEventCommandUpdateStatus },`
307	`{ kEventClassWindow, kEventWindowClose },`	314	`{ kEventClassWindow, kEventWindowClose },`
308	`{ kEventClassWindow, kEventWindowGetIdealSize },`	315	`{ kEventClassWindow, kEventWindowGetIdealSize },`
309	`{ kEventClassWindow, kEventWindowBoundsChanged },`	316	`{ kEventClassWindow, kEventWindowBoundsChanged },`
310	`{ kEventClassWindow, kEventWindowGetClickActivation }`	317	`{ kEventClassWindow, kEventWindowGetClickActivation }`
311	`};`	318	`};`
312		319
313		320
314		321
315		322
316	`InitContainers();`	323	`InitContainers();`
317		324
318		325
319	`if(BrowserWindow == NULL)`	326	`if(BrowserWindow == NULL)`
320	`CreateNewWindow(kDocumentWindowClass, kWindowStandardHandlerAttribute \|`	327	`CreateNewWindow(kDocumentWindowClass, kWindowStandardHandlerAttribute \|`
321	`kWindowStandardDocumentAttributes, &WSBounds, &BrowserWindow);`	328	`kWindowStandardDocumentAttributes, &WSBounds, &BrowserWindow);`
322		329
323	`if(BrowserWindow == NULL)`	330	`if(BrowserWindow == NULL)`
324	`return;`	331	`return;`
325		332
326		333
327	`if(!isEventHandlerOn){`	334	`if(!isEventHandlerOn){`
328	`InstallWindowEventHandler(BrowserWindow,`	335	`InstallWindowEventHandler(BrowserWindow,`
329	`NewEventHandlerUPP(BrowserEventHandler),`	336	`NewEventHandlerUPP(BrowserEventHandler),`
330	`sizeof(windowEvents)/sizeof(EventTypeSpec), windowEvents, NULL, NULL);`	337	`sizeof(windowEvents)/sizeof(EventTypeSpec), windowEvents, NULL, NULL);`
331	`isEventHandlerOn = TRUE;`	338	`isEventHandlerOn = TRUE;`
332	`SetWindowTitleWithCFString(BrowserWindow, CFSTR("R Workspace Browser"));`	339	`SetWindowTitleWithCFString(BrowserWindow, CFSTR("R Workspace Browser"));`
333	`}`	340	`}`
334		341
335		342
336		343
337	`/* Create the DataBrowser */`	344	`/* Create the DataBrowser */`
338	`if(WSpaceBrowser==NULL){`	345	`if(WSpaceBrowser==NULL){`
339	`CreateDataBrowser(BrowserWindow, &WSpaceBrowser);`	346	`CreateDataBrowser(BrowserWindow, &WSpaceBrowser);`
340	`InstallDataBrowserCallbacks(WSpaceBrowser);`	347	`InstallDataBrowserCallbacks(WSpaceBrowser);`
341		348
342	`/* Configure the DataBrowser */`	349	`/* Configure the DataBrowser */`
343	`if(!isBrowserOpen)`	350	`if(!isBrowserOpen)`
344	`ConfigureDataBrowser(WSpaceBrowser);`	351	`ConfigureDataBrowser(WSpaceBrowser);`
345	`err = SetDataBrowserTarget(WSpaceBrowser, 1);`	352	`err = SetDataBrowserTarget(WSpaceBrowser, 0);`
346		353
347	`AddDataBrowserItems(WSpaceBrowser, kDataBrowserNoItem,`	354	`AddDataBrowserItems(WSpaceBrowser, kDataBrowserNoItem,`
348	`(UInt32)NumOfRoots, (DataBrowserItemID *)RootItems, kDataBrowserItemNoProperty);`	355	`NumOfRoots, RootItems, kDataBrowserItemNoProperty);`
349		-
350	`/* Set the keyboard focus */`	356	`/* Set the keyboard focus */`
351	`SetKeyboardFocus(BrowserWindow, WSpaceBrowser, kControlDataBrowserPart);`	357	`SetKeyboardFocus(BrowserWindow, WSpaceBrowser, kControlDataBrowserPart);`
352		358
353	`/* Store DB as a window property */`	359	`/* Store DB as a window property */`
354	`SetWindowProperty(BrowserWindow,`	360	`SetWindowProperty(BrowserWindow,`
355	`kMyCreator, kMyDataBrowser,`	361	`kMyCreator, kMyDataBrowser,`
356	`sizeof(WSpaceBrowser), &WSpaceBrowser);`	362	`sizeof(WSpaceBrowser), &WSpaceBrowser);`
357		363
358		364
359	`}`	365	`}`
360		366
361	`if(WSpaceBrowser == NULL){`	367	`if(WSpaceBrowser == NULL){`
362	`CloseDataBrowser();`	368	`CloseDataBrowser();`
363	`return;`	369	`return;`
364	`}`	370	`}`
365		371
366		372
367	`ShowWindow(BrowserWindow);`	373	`ShowWindow(BrowserWindow);`
368		374
369	`GetPortBounds(GetWindowPort(BrowserWindow), &bounds);`	375	`GetPortBounds(GetWindowPort(BrowserWindow), &bounds);`
370	`SizeControl(WSpaceBrowser, bounds.right - bounds.left, bounds.bottom - bounds.top);`	376	`SizeControl(WSpaceBrowser, bounds.right - bounds.left, bounds.bottom - bounds.top);`
371		377
372		378
373	`isBrowserOpen = true;`	379	`isBrowserOpen = true;`
374	`}`	380	`}`
375		381
376	`void FreeBrowserStuff(void)`	382	`void FreeBrowserStuff(void)`
377	`{`	383	`{`
378	`if(SubItemsID) { free(SubItemsID); SubItemsID = NULL; }`	384	`if(SubItemsID) { free(SubItemsID); SubItemsID = NULL; }`
379		385
380	`NumOfID = 0;`	386	`NumOfID = 0;`
381		387
382	`if(RootItems)`	388	`if(RootItems)`
383	`{ free(RootItems); RootItems = NULL; }`	389	`{ free(RootItems); RootItems = NULL; }`
384		390
385	`if(Names) { free(Names); Names = NULL; }`	391	`if(Names) { free(Names); Names = NULL; }`
386	`if(Sizes) { free(Sizes); Sizes = NULL; }`	392	`if(Sizes) { free(Sizes); Sizes = NULL; }`
387	`if(Types) { free(Types); Types = NULL; }`	393	`if(Types) { free(Types); Types = NULL; }`
388	`if(IDNum) { free(IDNum); IDNum = NULL; }`	394	`if(IDNum) { free(IDNum); IDNum = NULL; }`
389	`if(IsRoot) { free(IsRoot); IsRoot = NULL; }`	395	`if(IsRoot) { free(IsRoot); IsRoot = NULL; }`
390	`if(IsContainer) { free(IsContainer); IsContainer = NULL; }`	396	`if(IsContainer) { free(IsContainer); IsContainer = NULL; }`
391	`if(NumberOfItems) { free(NumberOfItems); NumberOfItems = NULL; }`	397	`if(NumberOfItems) { free(NumberOfItems); NumberOfItems = NULL; }`
392	`if(ParentID) { free(ParentID); ParentID = NULL; }`	398	`if(ParentID) { free(ParentID); ParentID = NULL; }`
393		399
394	`}`	400	`}`
395		401
396		402
397		403
398	`void EmptyDataBrowser(void)`	404	`void EmptyDataBrowser(void)`
399	`{`	405	`{`
400	`RemoveDataBrowserItems (WSpaceBrowser, kDataBrowserNoItem, 0,`	406	`RemoveDataBrowserItems (WSpaceBrowser, kDataBrowserNoItem, 0,`
401	`NULL, kDataBrowserItemNoProperty);`	407	`NULL, kDataBrowserItemNoProperty);`
402	`}`	408	`}`
403		409
404	`void CloseDataBrowser(void)`	410	`void CloseDataBrowser(void)`
405	`{`	411	`{`
406		412
407	`if(BrowserWindow){`	413	`if(BrowserWindow){`
408	`if( GetWindowBounds(BrowserWindow,kWindowStructureRgn,&WSBounds) != noErr)`	414	`if( GetWindowBounds(BrowserWindow,kWindowStructureRgn,&WSBounds) != noErr)`
409	`SetRect(&WSBounds, 400, 400, 600, 800);`	415	`SetRect(&WSBounds, 400, 400, 600, 800);`
410	`}`	416	`}`
411	`else`	417	`else`
412	`SetRect(&WSBounds, 400, 400, 600, 800);`	418	`SetRect(&WSBounds, 400, 400, 600, 800);`
413		419
414		420
415	`DisposeWindow(BrowserWindow);`	421	`DisposeWindow(BrowserWindow);`
416	`BrowserWindow = NULL;`	422	`BrowserWindow = NULL;`
417		423
418	`isEventHandlerOn = FALSE;`	424	`isEventHandlerOn = FALSE;`
419		425
420	`FreeBrowserStuff();`	426	`FreeBrowserStuff();`
421		427
422	`isBrowserOpen = false;`	428	`isBrowserOpen = false;`
423	`WSpaceBrowser = NULL;`	429	`WSpaceBrowser = NULL;`
424	`}`	430	`}`
425		431
426	`static void CreateDataBrowser(WindowRef window, ControlRef *browser)`	432	`static void CreateDataBrowser(WindowRef window, ControlRef *browser)`
427	`{`	433	`{`
428	`Rect bounds;`	434	`Rect bounds;`
429	`Boolean frameAndFocus = false;`	435	`Boolean frameAndFocus = false;`
430		436
431	`/* Create a DataBrowser */`	437	`/* Create a DataBrowser */`
432	`GetWindowBounds(window, kWindowContentRgn, &bounds);`	438	`GetWindowBounds(window, kWindowContentRgn, &bounds);`
433		439
434	`bounds.top = bounds.left = 0;`	440	`bounds.top = bounds.left = 0;`
435	`bounds.right = bounds.right - bounds.left;`	441	`bounds.right = bounds.right - bounds.left;`
436	`bounds.bottom = bounds.bottom - bounds.top;`	442	`bounds.bottom = bounds.bottom - bounds.top;`
437		443
438	`CreateDataBrowserControl(window,`	444	`CreateDataBrowserControl(window,`
439	`&bounds, kDataBrowserListView, browser);`	445	`&bounds, kDataBrowserListView, browser);`
440		446
441	`/* Turn off DB's focus frame */`	447	`/* Turn off DB's focus frame */`
442	`SetControlData(`	448	`SetControlData(`
443	`*browser, kControlNoPart,`	449	`*browser, kControlNoPart,`
444	`kControlDataBrowserIncludesFrameAndFocusTag,`	450	`kControlDataBrowserIncludesFrameAndFocusTag,`
445	`sizeof(frameAndFocus), &frameAndFocus);`	451	`sizeof(frameAndFocus), &frameAndFocus);`
446	`}`	452	`}`
447		453
448	`static void ConfigureDataBrowser(ControlRef browser)`	454	`static void ConfigureDataBrowser(ControlRef browser)`
449	`{`	455	`{`
450	`Rect insetRect;`	456	`Rect insetRect;`
451	`DataBrowserViewStyle viewStyle;`	457	`DataBrowserViewStyle viewStyle;`
452	`SInt16 fontID;`	458	`SInt16 fontID;`
453	`Str255 fontname;`	459	`Str255 fontname;`
454		460
455	`GetDataBrowserViewStyle(browser, &viewStyle);`	461	`GetDataBrowserViewStyle(browser, &viewStyle);`
456		462
457	`GetDataBrowserScrollBarInset(browser, &insetRect);`	463	`GetDataBrowserScrollBarInset(browser, &insetRect);`
458		464
459	`insetRect.right = 16 - 1;`	465	`insetRect.right = 16 - 1;`
460	`SetDataBrowserScrollBarInset(browser, &insetRect);`	466	`SetDataBrowserScrollBarInset(browser, &insetRect);`
461		467
462	`switch (viewStyle)`	468	`switch (viewStyle)`
463	`{`	469	`{`
464	`case kDataBrowserListView:`	470	`case kDataBrowserListView:`
465	`{ DataBrowserListViewColumnDesc columnDesc;`	471	`{ DataBrowserListViewColumnDesc columnDesc;`
466		472
467	`columnDesc.headerBtnDesc.titleOffset = 0;`	473	`columnDesc.headerBtnDesc.titleOffset = 0;`
468		474
469	`columnDesc.headerBtnDesc.version =`	475	`columnDesc.headerBtnDesc.version =`
470	`kDataBrowserListViewLatestHeaderDesc;`	476	`kDataBrowserListViewLatestHeaderDesc;`
471		477
472	`columnDesc.headerBtnDesc.btnFontStyle.flags =`	478	`columnDesc.headerBtnDesc.btnFontStyle.flags =`
473	`kControlUseFontMask \| kControlUseJustMask;`	479	`kControlUseFontMask \| kControlUseJustMask;`
474		480
475	`columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlNoContent;`	481	`columnDesc.headerBtnDesc.btnContentInfo.contentType = kControlNoContent;`
476		482
477		483
478	`/* Add the Object column */`	484	`/* Add the Object column */`
479		485
480	`columnDesc.propertyDesc.propertyID = kObjectColumn;`	486	`columnDesc.propertyDesc.propertyID = kObjectColumn;`
481	`columnDesc.propertyDesc.propertyType = kDataBrowserTextType;`	487	`columnDesc.propertyDesc.propertyType = kDataBrowserTextType;`
482	`columnDesc.propertyDesc.propertyFlags = kDataBrowserPropertyIsMutable \|`	488	`columnDesc.propertyDesc.propertyFlags = kDataBrowserPropertyIsMutable \|`
483	`kDataBrowserListViewDefaultColumnFlags;`	489	`kDataBrowserListViewDefaultColumnFlags;`
484		490
485		491
486	`columnDesc.headerBtnDesc.minimumWidth = 30;`	492	`columnDesc.headerBtnDesc.minimumWidth = 30;`
487	`columnDesc.headerBtnDesc.maximumWidth = 200;`	493	`columnDesc.headerBtnDesc.maximumWidth = 200;`
488		494
489	`columnDesc.headerBtnDesc.btnFontStyle.just = teFlushLeft;`	495	`columnDesc.headerBtnDesc.btnFontStyle.just = teFlushLeft;`
490		496
491	`CopyCStringToPascal(CurrentPrefs.ConsoleFontName, fontname);`	497	`CopyCStringToPascal(CurrentPrefs.ConsoleFontName, fontname);`
492	`GetFNum(fontname,&fontID);`	498	`GetFNum(fontname,&fontID);`
493		499

The R Project SVN R

(root)/trunk/src/modules/aqua/DataBrowser.c @ 28362 – Rev 26123 → 27143