/*

Directory Opus 4
Original GPL release version 4.12
Copyright 1993-2000 Jonathan Potter

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.

All users of Directory Opus 4 (including versions distributed
under the GPL) are entitled to upgrade to the latest version of
Directory Opus version 5 at a reduced price. Please see
http://www.gpsoft.com.au for more information.

The release of Directory Opus 4 under the GPL in NO WAY affects
the existing commercial status of Directory Opus 5.

*/

#include "dopus.h"
#include "view.h"

start_external(func)
struct dopus_func_start *func;
{
	int arg;
	char path[256],*ptr;

	func->key=NULL;
	func->status=0;
	func->resseg=NULL;

	if (!(func->replyport=LCreatePort(NULL,0))) return(0);
	if (!(func->startup.wbstartup.sm_ArgList=LAllocRemember(&func->key,
		sizeof(struct WBArg)*(func->argcount+1),MEMF_CLEAR|MEMF_PUBLIC)))
		return(0);

	func->startup.wbstartup.sm_Message.mn_Node.ln_Type=NT_MESSAGE;
	func->startup.wbstartup.sm_Message.mn_ReplyPort=func->replyport;
	func->startup.wbstartup.sm_Message.mn_Length=(UWORD)sizeof(struct DOpusStartup);

	func->startup.wbstartup.sm_NumArgs=func->argcount;
	for (arg=0;arg<func->argcount;arg++)
		func->startup.wbstartup.sm_ArgList[arg].wa_Name=func->args[arg];

	strcpy(path,func->segname);
	if (ptr=BaseName(path)) *ptr=0;
	if (!(func->startup.wbstartup.sm_ArgList[0].wa_Lock=Lock(path,ACCESS_READ)))
		return(0);

	func->startup.retcode=0;

	func->status=FS_CURDIR;
	func->olddir=CurrentDir(func->startup.wbstartup.sm_ArgList[0].wa_Lock);

	if (!func->segment) {
		if (system_version2) {
			Forbid();
			if (func->resseg=FindSegment(func->segname,NULL,0)) {
				func->resseg->seg_UC++;
				func->segment=func->resseg->seg_Seg;
			}
			Permit();
		}
		if (!func->segment &&
			!(func->segment=(BPTR)LoadSeg(func->segname)))
			return(0);
	}

	func->status=FS_SEGMENT;

	func->startup.wbstartup.sm_Segment=func->segment;
	if (!(func->startup.wbstartup.sm_Process=CreateProc(func->procname,
		main_proc->pr_Task.tc_Node.ln_Pri,func->startup.wbstartup.sm_Segment,func->stack)))
		return(0);

	func->startup.wbstartup.sm_ToolWindow=NULL;
	PutMsg(func->startup.wbstartup.sm_Process,(struct Message *)&func->startup);

	func->status=FS_LAUNCHED;
	return(1);
}

close_external(func,wait)
struct dopus_func_start *func;
int wait;
{
	if (func->status>=FS_LAUNCHED && wait) {
		WaitPort(func->replyport);
		GetMsg(func->replyport);
	}
	if (func->status>=FS_SEGMENT) {
		Forbid();
		if (func->resseg) {
			func->resseg->seg_UC--;
			func->segment=0;
		}
		else if (!func->flags&FF_SAVESEG && func->segment) {
			UnLoadSeg(func->segment);
			func->segment=0;
		}
		Permit();
	}
	if (func->status>=FS_CURDIR) {
		CurrentDir(func->olddir);
		UnLock(func->startup.wbstartup.sm_ArgList[0].wa_Lock);
	}
	if (func->replyport) LDeletePort(func->replyport);
	LFreeRemember(&func->key);
	return(func->startup.retcode);
}

void doconfig()
{
	char buf[100],buf1[20],replyname[50],portname[50],funcpath[80];
	int old_bufcount,a;
	struct MsgPort *conport,*cmdport;
	struct dopusconfigmsg *repmsg;
	struct configconfig cfg,*rcfg;
	struct ConfigStuff cstuff;
	struct dopus_func_start config_func;
	char *func_args[2];
	char *old_name;
	char old_language[30];

	if (!(checkwindowquit())) return;

	lsprintf(replyname,"dopus4_config_reply%ld",system_dopus_runcount);
	if (!(conport=LCreatePort(replyname,20))) return;

	lsprintf(buf,"%ld",system_dopus_runcount);
	lsprintf(buf1,"dopus4_config%ld",system_dopus_runcount);

	strcpy(funcpath,"ConfigOpus");

	if (!configopus_segment) {
		dostatustext(globstring[STR_LOADING_CONFIG]);
		FindSystemFile("ConfigOpus",funcpath,80,SYSFILE_MODULE);
	}

	func_args[0]=funcpath;
	func_args[1]=buf;

	config_func.segment=configopus_segment;
	config_func.procname="ConfigOpus";

	config_func.segname=funcpath;
	config_func.argcount=2;
	config_func.args=func_args;
	config_func.stack=8000;
	config_func.flags=(config->loadexternal&LOAD_CONFIG)?FF_SAVESEG:0;

	if (!(start_external(&config_func))) {
		close_external(&config_func,0);
		dostatustext(globstring[STR_CONFIG_NOT_FOUND]);
		LDeletePort(conport);
		return;
	}

	dostatustext(globstring[STR_WAITING_FOR_PORT]);
	lsprintf(portname,"dopus4_config_port%ld",system_dopus_runcount);
	cmdport=NULL;

	for (a=0;a<100;a++) {
		Forbid();
		cmdport=FindPort(portname);
		Permit();
		if (cmdport) break;
		Delay(5);
	}

	if (!cmdport) {
		close_external(&config_func,0);
		dostatustext(globstring[STR_CONFIG_NOT_FOUND]);
		LDeletePort(conport);
		return;
	}

	status_configuring=-1;
	shutthingsdown(10);
	old_bufcount=config->bufcount;
	strcpy(old_language,config->language);
	dotaskmsg(hotkeymsg_port,HOTKEY_KILLHOTKEYS,0,0,NULL,0);

	endnotifies();

	Forbid();
	old_name=arexx_port->mp_Node.ln_Name;
	arexx_port->mp_Node.ln_Name="foo";
	Permit();

	FOREVER {
		while (repmsg=(struct dopusconfigmsg *)GetMsg(conport)) {
			switch (repmsg->command) {
				case CONFIG_ALL_DONE:
					ReplyMsg((struct Message *)repmsg);
					goto configdone;
				case CONFIG_GET_CONFIG:
					cfg.config=config;
					cfg.firsttype=dopus_firsttype;
					cfg.typekey=filetype_key;
					cfg.firstbank=dopus_firstgadbank;
					cfg.changed=config_changed;
					cfg.firsthotkey=dopus_firsthotkey;
					strcpy(cfg.configname,str_config_basename);
					repmsg->buffer=(char *)&cfg;
					break;
				case CONFIG_HERES_CONFIG:
					rcfg=(struct configconfig *)repmsg->buffer;
					dopus_firsttype=rcfg->firsttype;
					dopus_firstgadbank=rcfg->firstbank;
					dopus_firsthotkey=rcfg->firsthotkey;
					filetype_key=rcfg->typekey;
					config_changed=rcfg->changed;
					StrCombine(str_config_file,rcfg->configname,".CFG",256);
					strcpy(str_config_basename,rcfg->configname);
					Window=rcfg->Window; MainScreen=rcfg->Screen;
					status_configuring=1;
					break;
				case CONFIG_NEW_HOTKEY:
					dotaskmsg(hotkeymsg_port,HOTKEY_HOTKEYCHANGE,0,0,NULL,0);
					break;
			}
			ReplyMsg((struct Message *)repmsg);
		}

		Wait(1<<conport->mp_SigBit);
	}

configdone:
	config_func.flags=(config->loadexternal&LOAD_CONFIG)?FF_SAVESEG:0;
	close_external(&config_func,1);
	configopus_segment=config_func.segment;

	status_configuring=-1;
	Window=NULL; MainScreen=NULL;
	dopus_curgadbank=dopus_firstgadbank;
	data_gadgetrow_offset=data_drive_offset=0;
	dotaskmsg(hotkeymsg_port,HOTKEY_HOTKEYCHANGE,0,0,NULL,0);
	dotaskmsg(hotkeymsg_port,HOTKEY_NEWHOTKEYS,0,0,NULL,0);
	if (config->bufcount!=old_bufcount) {
		allocdirbuffers(config->bufcount);
		for (a=0;a<2;a++) strcpy(str_pathbuffer[a],dopus_curwin[a]->directory);
	}
	if (strcmp(old_language,config->language)) read_data_files(0);

	for (a=0;a<3;a++) {
		if (!(config->loadexternal&(1<<a)) && external_mod_segment[a]) {
			UnLoadSeg(external_mod_segment[a]);
			external_mod_segment[a]=0;
		}
	}

	fixcstuff(&cstuff);
	CheckConfig(&cstuff);
	SetUp(2);

	LDeletePort(conport);

	Forbid();
	arexx_port->mp_Node.ln_Name=old_name;
	Permit();

	rexx_command(config->configreturnscript,NULL);

	startnotifies();
	status_configuring=0;
}

static char *external_modules[3]={
	"DOpus_Disk",
	"DOpus_Print",
	"DOpus_Icon"};

struct DiskData {
	int function;
	char funcpath[80];
	char *args[16];
	int argcount;
	int background;
};

void dopus_diskop(function,rexx,bg)
int function,rexx,bg;
{
	struct ArbiterLaunch launch;
	struct DiskData *disk_data;
	struct DOpusRemember *memkey=NULL;
	int a,fail=1;

	if ((disk_data=LAllocRemember(&memkey,sizeof(struct DiskData),MEMF_CLEAR))) {
		dostatustext(globstring[STR_STARTING_DISK_MODULE]);

		disk_data->function=function;
		disk_data->background=bg;

		strcpy(disk_data->funcpath,external_modules[SEG_DISK]);
		if (external_mod_segment[SEG_DISK] ||
			(FindSystemFile(external_modules[SEG_DISK],disk_data->funcpath,80,SYSFILE_MODULE))) {
			disk_data->args[0]=disk_data->funcpath;

			switch (function) {
				case FUNC_FORMAT:
				case FUNC_BGFORMAT:
					disk_data->args[1]="f";
					break;
				case FUNC_DISKCOPY:
				case FUNC_BGDISKCOPY:
					disk_data->args[1]="d";
					break;
				case FUNC_INSTALL:
				case FUNC_BGINSTALL:
					disk_data->args[1]="i";
					break;
				default:
					return;
			}

			disk_data->argcount=3;

			if (rexx) {
				if ((disk_data->argcount+=rexx_argcount)>16) disk_data->argcount=16;
				for (a=3;a<disk_data->argcount;a++) {
					if (disk_data->args[a]=LAllocRemember(&memkey,strlen(rexx_args[a-3])+1,0))
						strcpy(disk_data->args[a],rexx_args[a-3]);
				}
			}

			for (a=disk_data->argcount;a<16;a++) disk_data->args[a]="";

			launch.launch_code=(void *)launch_diskop;
			launch.launch_name="dopus_disk_launch";
			launch.launch_memory=memkey;
			launch.data=(APTR)disk_data;

			if (!bg) data_window_refresh=0;

			arbiter_command(ARBITER_LAUNCH,(APTR)&launch,(bg)?0:ARB_WAIT);

			if (!bg) {
				for (a=0;a<2;a++) {
					if (data_window_refresh&(1<<a)) {
						strcpy(str_pathbuffer[a],dopus_curwin[a]->realdevice);
						startgetdir(a,1);
					}
				}
			}

			okay();
			fail=0;
		}
	}
	if (fail) dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
}

void __saveds launch_diskop()
{
	struct Process *my_process;
	struct ArbiterMessage *my_startup_message;
	struct DiskData *disk_data;
	struct MsgPort *control_port;
	struct dopus_func_start disk_func;
	struct DOpusMessage *dopusmsg;
	struct Screen *screen;
	char portname[22],portbuf[22];
	int retcode=-1;

	my_process=(struct Process *)FindTask(NULL);
	my_process->pr_WindowPtr=(APTR)-1;
	WaitPort(&my_process->pr_MsgPort);
	my_startup_message=(struct ArbiterMessage *)GetMsg(&my_process->pr_MsgPort);

	disk_data=(struct DiskData *)(my_startup_message->data);

	if (control_port=CreateUniquePort("DOPUS_DISK",portbuf,NULL)) {
		disk_func.segment=external_mod_segment[SEG_DISK];
		disk_func.procname=external_modules[SEG_DISK];
		disk_func.segname=disk_data->funcpath;

		StrCombine(portname,"&",portbuf,20);
		disk_data->args[2]=portname;

		disk_func.argcount=disk_data->argcount;
		disk_func.args=disk_data->args;
		disk_func.stack=5000;
		disk_func.flags=(config->loadexternal&LOAD_DISK)?FF_SAVESEG:0;

		if (start_external(&disk_func)) {
			struct DOpusRemember *memory=NULL;
			int newscreen=0;

			screen=NULL;

			if (disk_data->background && MainScreen &&
				(screen=open_subprocess_screen(globstring[STR_DISK_OP_TITLE],
					scr_font[FONT_REQUEST],&memory,NULL))) newscreen=1;

			FOREVER {
				if (GetMsg(disk_func.replyport)) break;
				while (dopusmsg=(struct DOpusMessage *)GetMsg(control_port)) {
					switch (dopusmsg->command) {
						case DOPUSMSG_GETVIS:
							fill_out_visinfo((struct VisInfo *)dopusmsg->data,screen);
							break;
						case DOPUSMSG_UPDATEDRIVE:
							if (!disk_data->background) {
								BPTR lock,testlock;
								int win,ret;
								char *drive;

								drive=(char *)dopusmsg->data;
								if (drive && drive[0]) {
									if (lock=Lock(drive,ACCESS_READ)) {
										for (win=0;win<2;win++) {
											if (dopus_curwin[win]->realdevice[0] &&
												(testlock=Lock(dopus_curwin[win]->realdevice,ACCESS_READ))) {
												ret=CompareLock(lock,testlock);
												if (ret!=LOCK_DIFFERENT) data_window_refresh|=1<<win;
												UnLock(testlock);
											}
										}
										UnLock(lock);
									}
								}
							}
							break;
					}
					ReplyMsg((struct Message *)dopusmsg);
				}
				Wait(1<<disk_func.replyport->mp_SigBit|1<<control_port->mp_SigBit);
			}
			if (newscreen) CloseScreen(screen);
			LFreeRemember(&memory);
		}

		close_external(&disk_func,0);
		external_mod_segment[SEG_DISK]=disk_func.segment;
		LDeletePort(control_port);
		retcode=0;
	}

	my_startup_message->command=retcode;
	Forbid();
	ReplyMsg((struct Message *)my_startup_message);
	return;
}

void dopus_print(rexx,arglist,printdir,port,vdata)
int rexx;
struct DOpusArgsList *arglist;
int printdir;
char *port;
struct ViewData *vdata;
{
	char *args[16],portname[21],arglistbuf[20],funcpath[80];
	struct dopus_func_start print_func;
	int a,argcount,waitbits,abase=3;

	if (!vdata) dostatustext(globstring[STR_STARTING_PRINT_MODULE]);

	print_func.segment=external_mod_segment[SEG_PRINT];
	print_func.procname=external_modules[SEG_PRINT];

	strcpy(funcpath,external_modules[SEG_PRINT]);

	if (!print_func.segment)
		FindSystemFile(external_modules[SEG_PRINT],funcpath,80,SYSFILE_MODULE);

	print_func.segname=funcpath;

	args[0]=print_func.segname;

	StrCombine(portname,"&",port,20);
	args[1]=portname;

	if (printdir) {
		int win;

		if (!rexx || rexx_argcount<1 ||
			(win=atoi(rexx_args[0]))<0 || win>1) win=data_active_window;
		lsprintf(arglistbuf,"@%ld",win);
		abase=2;
		--rexx_argcount;
	}
	else lsprintf(arglistbuf,"!%ld",arglist);

	args[2]=arglistbuf;
	argcount=3;

	if (rexx && rexx_argcount>0) {
		if ((argcount+=rexx_argcount)>16) argcount=16;
		for (a=3;a<argcount;a++) args[a]=rexx_args[a-abase];
	}

	for (a=argcount;a<16;a++) args[a]="";

	print_func.argcount=argcount;
	print_func.args=args;
	print_func.stack=5000;
	print_func.flags=(config->loadexternal&LOAD_PRINT)?FF_SAVESEG:0;

	if (!(start_external(&print_func))) {
		close_external(&print_func,0);
		if (!vdata) dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
		return;
	}

	waitbits=1<<print_func.replyport->mp_SigBit;
	if (vdata) waitbits|=1<<vdata->view_port->mp_SigBit;
	else waitbits|=rexx_signalbit;

	FOREVER {
		if ((Wait(waitbits))&rexx_signalbit && !vdata) {
			rexx_dispatch(0);
			continue;
		}
		if (vdata) {
			struct DOpusMessage *dmsg;
			struct DOpusArgsList *arg;

			while (dmsg=(struct DOpusMessage *)GetMsg(vdata->view_port)) {
				switch (dmsg->command) {
					case DOPUSMSG_GETVIS:
						CopyMem((char *)&vdata->view_vis_info,(char *)dmsg->data,
							sizeof(struct VisInfo));
						break;
					case DOPUSMSG_GETNEXTFILE:
						arg=(struct DOpusArgsList *)dmsg->data;
						if (arg->single_file) {
							strcpy(arg->file_data,arg->single_file);
							arg->single_file=NULL;
						}
						else arg->file_data[0]=0;
						break;
				}
				ReplyMsg((struct Message *)dmsg);
			}
		}
		if (GetMsg(print_func.replyport)) break;
	}

	close_external(&print_func,0);
	external_mod_segment[SEG_PRINT]=print_func.segment;

	if (!vdata) okay();
}

dopus_iconinfo(filename)
char *filename;
{
	char *args[3],portname[14],funcpath[80];
	struct dopus_func_start icon_func;
	int a;

	icon_func.segment=external_mod_segment[SEG_ICON];
	icon_func.procname=external_modules[SEG_ICON];

	strcpy(funcpath,external_modules[SEG_ICON]);

	if (!icon_func.segment)
		FindSystemFile(external_modules[SEG_ICON],funcpath,80,SYSFILE_MODULE);

	icon_func.segname=funcpath;

	StrCombine(portname,"&",str_arexx_portname,13);

	args[0]=icon_func.segname;
	args[1]=portname;
	args[2]=filename;

	icon_func.argcount=3;
	icon_func.args=args;
	icon_func.stack=5000;
	icon_func.flags=(config->loadexternal&LOAD_ICON)?FF_SAVESEG:0;

	if (!(start_external(&icon_func))) {
		close_external(&icon_func,0);
		dostatustext(globstring[STR_UNABLE_TO_LOAD_MODULE]);
		return(-4);
	}

	FOREVER {
		if ((Wait(1<<icon_func.replyport->mp_SigBit|rexx_signalbit))&rexx_signalbit) {
			rexx_dispatch(0);
			continue;
		}
		if (GetMsg(icon_func.replyport)) break;
	}

	a=close_external(&icon_func,0);
	external_mod_segment[SEG_ICON]=icon_func.segment;
	return(a);
}

void setup_externals()
{
	int a;
	char funcbuf[256];
	APTR wsave;

	wsave=main_proc->pr_WindowPtr;
	main_proc->pr_WindowPtr=(APTR)-1;

	if (config->loadexternal&LOAD_CONFIG) {
		FindSystemFile("ConfigOpus",funcbuf,256,SYSFILE_MODULE);
		configopus_segment=LoadSeg(funcbuf);
	}
	else configopus_segment=NULL;

	for (a=0;a<3;a++) {
		if (config->loadexternal&(1<<a)) {
			FindSystemFile(external_modules[a],funcbuf,256,SYSFILE_MODULE);
			external_mod_segment[a]=LoadSeg(funcbuf);
		}
		else external_mod_segment[a]=NULL;
	}

	main_proc->pr_WindowPtr=wsave;
}

void fill_out_visinfo(vis,scr)
struct VisInfo *vis;
struct Screen *scr;
{
	if (scr && (!Window || Window->WScreen!=scr)) {
		vis->vi_flags&=~VISF_WINDOW;
		vis->vi_screen=scr;

		vis->vi_fg=config->requestfg;
		vis->vi_bg=config->requestbg;
		vis->vi_shine=config->gadgettopcol;
		vis->vi_shadow=config->gadgetbotcol;
		vis->vi_stringcol[0]=config->stringfgcol;
		vis->vi_stringcol[1]=config->stringbgcol;
		vis->vi_activestringcol[0]=config->stringselfgcol;
		vis->vi_activestringcol[1]=config->stringselbgcol;
	}
	else {
		if (vis->vi_flags&VISF_WINDOW) vis->vi_screen=(struct Screen *)Window;
		else if (Window) vis->vi_screen=Window->WScreen;
		else vis->vi_screen=NULL;

		vis->vi_fg=screen_pens[config->requestfg].pen;
		vis->vi_bg=screen_pens[config->requestbg].pen;
		vis->vi_shine=screen_pens[config->gadgettopcol].pen;
		vis->vi_shadow=screen_pens[config->gadgetbotcol].pen;
		vis->vi_stringcol[0]=screen_pens[config->stringfgcol].pen;
		vis->vi_stringcol[1]=screen_pens[config->stringbgcol].pen;
		vis->vi_activestringcol[0]=screen_pens[config->stringselfgcol].pen;
		vis->vi_activestringcol[1]=screen_pens[config->stringselbgcol].pen;
	}

	if (vis->vi_flags&VISF_8POINTFONT) vis->vi_font=scr_font[FONT_GENERAL];
	else vis->vi_font=scr_font[FONT_REQUEST];

	if (config->generalscreenflags&SCR_GENERAL_REQDRAG)
		vis->vi_flags|=VISF_BORDERS;
	else vis->vi_flags&=~VISF_BORDERS;

	vis->vi_language=config->language;
}