/*
 * $Source: $
 * $Revision: $
 * $Date: $
 * $State: $
 * $Author: $
 *
 *
 * $Log: $
 *
 * Revision 4.2a3 6/8/94 - edward
 * Included StandardFile
 *
 * Revision 4.2a3 6/17/94 - edward
 * data_sendcheckbox is type void and takes an argument message of type Boolean *
 *
 * Revision 4.2a4 7/5/94 - edward
 * Porting to MW C/C++ 68K.  The headers are only included if we're not using MW
 * Changed data_port, data_host, data_text_size, data_text_nodeid, data_text_active, 
 *  data_local_menu_size, data_edits to return void
 */

/* 
 *	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
 *	
 */

// 7/5/94 edward - If we're compiling with MW all of these headers are precompiled in TIFast*
#ifndef __MWERKS__
 
#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 <Lists.h>
#include <string.h>
#include <StandardFile.h>
#include "pips.h"
#ifdef TE32K
#include "TE32K.h"
#endif
#include "documentRec.h"
#include "prototype.h"
#include <stdio.h>
#include <resources.h>

#endif

#include <time.h>
#include "mit-copyright.h"

/*     
 *
 *  data_current_nodeid:
 * 
 *	maintain the nodeid of the current menu list
 *
 */
#pragma segment aux

void data_current_nodeid(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(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(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(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(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
void data_sendcheckbox(int mode, Boolean *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(int mode, Boolean *message)
{
	static Boolean	debug;
	
	switch(mode) {
		case store:
			debug = *message;
			break;
		case retrieve:
			*message = debug;
			break;
	}
}

/*     
 *
 * data_port:
 * 
 *
 */
#pragma segment aux
void data_port(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
void data_host(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
void data_text_size(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
void data_text_nodeid(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
void data_text_active(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(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;
	}
	return false;
}

/*     
 *
 * data_local_menu_size:
 * 
 *
 */
#pragma segment aux
void data_local_menu_size(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
void data_edits(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 */