/*
 * $Source: $
 * $Revision: $
 * $Date: $
 * $State: $
 * $Author: $
 *
 *
 * $Log: $
 *
 */

/* 
 *	Copyright (c) 1991 by the Massachusetts Institute of Technology,
 *	For copying and distribution information, see the file
 *	"mit-copyright.h".
 *
 * 	dataMgr.c  - WADE 4/20/90
 *
 *	data_current_nodeid
 *	
 */
 
#include <Limits.h>
#include <Types.h>
#include <QuickDraw.h>
#include <Fonts.h>
#include <Events.h>
#include <Controls.h>
#include <Windows.h>
#include <Menus.h>
#include <TextEdit.h>
#include <Dialogs.h>
#include <Desk.h>
#include <Scrap.h>
#include <ToolUtils.h>
#include <Memory.h>
#include <SegLoad.h>
#include <Files.h>
#include <OSUtils.h>
#include <Traps.h>
#include <string.h>
#include "pips.h" 
#include "prototype.h"
#include <stdio.h>
#include <time.h>
#include <resources.h>
#include "mit-copyright.h"

/*     
 *
 *  data_current_nodeid:
 * 
 *	maintain the nodeid of the current menu list
 *
 */
#pragma segment aux
void
data_current_nodeid(mode,message)
int   mode;
char *message;
{
	static Str255	node_id = {'\0'};
	
	switch(mode) {
		case store:
			strcpy(node_id,message);
			break;
		case retrieve:
			strcpy(message,node_id);
			break;
	}
}

/*     
 *
 * data_source:
 * 
 *
 */
#pragma segment aux
void
data_source(mode,message)
int   mode;
char *message;
{
	static Str255	source;
	
	switch(mode) {
		case store:
			strcpy(source,message);
			break;
		case retrieve:
			strcpy(message,source);
			break;
	}
}

/*     
 *
 * data_parent:
 * 
 *
 */
#pragma segment aux
Boolean
data_parent(mode,message)
int   mode;
char *message;
{
	static  Str255	parent_list = {'\0'};
	Boolean good = true;
	
	switch(mode) {
		case store:
			strcpy(parent_list,message);
			break;
		case retrieve:
			if (strlen(parent_list) == 0)
				good = !good;
			else
				strcpy(message,parent_list);
			break;
	}
	
	return good;
}

/*     
 *
 * data_locker:
 * 
 *
 */
#pragma segment aux
Boolean
data_locker(mode,message)
int   mode;
char *message;
{
	static  Str255	locker_static = {'\0'};
	Boolean good = true;
	
	switch(mode) {
		case store:
			strcpy(locker_static,message);
			break;
		case retrieve:
			if (strlen(locker_static) == 0)
				good = !good;
			else
				strcpy(message,locker_static);
			break;
	}
	
	return good;
}

/*     
 *
 * data_path:
 * 
 *
 */
#pragma segment aux
Boolean
data_path(mode,message)
int   mode;
char *message;
{
	static  Str255	path_static = {'\0'};
	Boolean good = true;
	
	switch(mode) {
		case store:
			strcpy(path_static,message);
			break;
		case retrieve:
			if (strlen(path_static) == 0)
				good = !good;
			else
				strcpy(message,path_static);
			break;
	}
	
	return good;
}

/*     
 *
 * data_sendcheckbox:
 * 
 *
 */
#pragma segment aux
data_sendcheckbox(mode,message)
int   	mode;
int		*message;
{
	static  Boolean	send_static = 0;
	
	switch(mode) {
		case store:
			send_static = *message;
			break;
		case retrieve:
			*message = send_static;
			break;
	}
	
}

/*     
 *
 * data_debug:
 * 
 *
 */
#pragma segment aux
void
data_debug(mode,message)
int   	mode;
Boolean	*message;
{
	static Boolean	debug;
	
	switch(mode) {
		case store:
			debug = *message;
			break;
		case retrieve:
			*message = debug;
			break;
	}
}

/*     
 *
 * data_port:
 * 
 *
 */
#pragma segment aux
data_port(mode,message)
int   mode;
char *message;
{
	static  Str255	port;
	
	switch(mode) {
		case store:
			strcpy(port,message);
			break;
		case retrieve:
			strcpy(message,port);
			break;
	}
}

/*     
 *
 * data_host:
 * 
 *
 */
#pragma segment aux
data_host(mode,message)
int   mode;
char *message;
{
	static  Str255	host;
	
	switch(mode) {
		case store:
			strcpy(host,message);
			break;
		case retrieve:
			strcpy(message,host);
			break;
	}
}

/*     
 *
 * data_text_size:
 * 
 *
 */
#pragma segment aux
data_text_size(mode,message)
int  mode;
int *message;
{
	static  int	text_size;
	
	switch(mode) {
		case store:
			text_size = *message;
			break;
		case retrieve:
			*message = text_size;
			break;
	}
}

/*     
 *
 * data_text_nodeid:
 * 
 *
 */
#pragma segment aux
data_text_nodeid(mode,message)
int  mode;
char *message;
{
	static  char	node_id[6];
	
	switch(mode) {
		case store:
			strcpy(node_id,message);
			break;
		case retrieve:
			strcpy(message,node_id);
			break;
	}
}


/*     
 *
 * data_text_active:
 * 
 *
 */
#pragma segment aux
data_text_active(mode,message)
int    mode;
short *message;
{
	static  short	active;
	
	switch(mode) {
		case store:
			active = *message;
			break;
		case retrieve:
			*message = active;
			break;
	}
}

/*     
 *
 * data_anchor_cell:
 * 
 *
 */
#pragma segment aux
Boolean
data_anchor_cell(mode,message)
int    mode;
short *message;
{
	static  short	anchor = -1;
	
	switch(mode) {
		case store:
			anchor = *message;
			return true;
			break;
		case retrieve:
			*message = anchor;
			if (anchor < 0)
				return false; /* we don't have an anchor */
			else
				return true;
			break;
	}
}

/*     
 *
 * data_local_menu_size:
 * 
 *
 */
#pragma segment aux
data_local_menu_size(mode,message)
int    mode;
int *message;
{
	static  int	local = 0;
	
	switch(mode) {
		case store:
			local = *message;
			break;
		case retrieve:
			*message = local;
			break;
	}
}

/*     
 *
 * data_edits:
 * 
 *
 */
#pragma segment aux
data_edits(mode,message)
int    		mode;
data_edit *message;
{
	static data_edit undo_edit = {0,NULL,NULL,NULL};
	
	switch(mode) {
		case store:
			memcpy(&undo_edit,message,sizeof(undo_edit));
			break;
		case retrieve:
			memcpy(message,&undo_edit,sizeof(undo_edit));
			break;
	}
}	/* end data_edits */