/*

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"

/* Allocate or free directory buffers as necessary to achieve desired
   buffer count in each window */

void allocdirbuffers(newnum)
int newnum;
{
	int win,a,num;
	struct DirectoryWindow *dir,*next;

	for (win=0;win<2;win++) {
		if (data_buffer_count[win]>newnum) {
			dir=dopus_firstwin[win];
			for (a=0;a<newnum;a++) dir=dir->next;
			dir->last->next=dopus_firstwin[win];
			dopus_firstwin[win]->last=dir->last;
			num=data_buffer_count[win];
			for (a=newnum;a<num;a++) {
				next=dir->next;
				freedir(dir,-1);
				if (dopus_curwin[win]==dir) dopus_curwin[win]=dopus_firstwin[win];
				FreeMem(dir,sizeof(struct DirectoryWindow));
				if ((--data_buffer_count[win])<1) break;
				dir=next;
			}
		}
		else if (data_buffer_count[win]<newnum) {
			dir=dopus_firstwin[win];
			for (a=0;a<data_buffer_count[win]-1;a++) dir=dir->next;
			for (a=data_buffer_count[win];a<newnum;a++) {
				if (next=AllocMem(sizeof(struct DirectoryWindow),MEMF_CLEAR)) {
					if (!dir) {
						dopus_firstwin[win]=next;
						dopus_curwin[win]=next;
						dir=next;
					}
					dir->next=next;
					next->last=dir;
					next->next=dopus_firstwin[win];
					dopus_firstwin[win]->last=next;
					next->number=a;
					next->hlen=145;
					++data_buffer_count[win];
					dir=next;
				}
			}
		}
	}
}

/* Searches both buffer lists for a given directory, and displays it in
   the active window if found (copying it over if necessary) */

bringinbuffer(dirbuf,win,read)
char *dirbuf;
int win,read;
{
	int a,otherwin;
	struct DirectoryWindow *dir;

	if (status_iconified || !dirbuf) return(0);
	checkcurrentbuffer(win);
	if (!(findbuffer(dirbuf,win,0,0))) {
		otherwin=1-data_active_window;
		dir=dopus_firstwin[otherwin];
		for (a=0;a<data_buffer_count[otherwin];a++,dir=dir->next) {
			if ((LStrCmpI(dirbuf,dir->directory))==0) {
				incrementbuf(data_active_window,1,0);
				copydirwin(dir,dopus_curwin[data_active_window],data_active_window);
				check_old_buffer(data_active_window);
				return(1);
			}
		}
		if (read) {
			strcpy(str_pathbuffer[data_active_window],dirbuf);
			startgetdir(data_active_window,SGDFLAGS_CANMOVEEMPTY);
		}
		else return(0);
	}
	return(1);
}

/* Searches forward from the current buffer to find an empty one, or one
   with the same name (it looks first for one with the same name).
   If a buffer is not found, it uses the current buffer */

void findemptybuffer(win)
int win;
{
	struct DirectoryWindow *dir;
	int a,ok=0;
	char fullbuf[256];

	expand_path(str_pathbuffer[win],fullbuf);
	checkdir(str_pathbuffer[win],NULL);
	checkdir(fullbuf,NULL);

	dir=dopus_curwin[win];
	for (a=0;a<data_buffer_count[win];a++) {
		if (LStrCmpI(dir->directory,str_pathbuffer[win])==0 ||
			LStrCmpI(dir->directory,fullbuf)==0) {
			ok=1;
			break;
		}
		dir=dir->next;
	}
	if (!ok) {
		dir=dopus_curwin[win];
		for (a=0;a<data_buffer_count[win];a++) {
			if (!dir->directory[0]) break;
			dir=dir->next;
		}
	}
	dopus_curwin[win]=dir;
}

/* Sets up and reads a new directory */

void startgetdir(win,flags)
int win,flags;
{
	checkcurrentbuffer(win);

	if (!(config->dirflags&DIRFLAGS_CHECKBUFS && (flags&SGDFLAGS_CANCHECKBUFS)) ||
		!(findbuffer(str_pathbuffer[win],win,1,0))) {
		if ((config->dirflags&DIRFLAGS_FINDEMPTY) && (flags&SGDFLAGS_CANMOVEEMPTY))
			findemptybuffer(win);
		if (str_pathbuffer[win][0]==0) expand_path("",str_pathbuffer[win]);
		checkdir(str_pathbuffer[win],&path_strgadget[win]);
		strcpy(dopus_curwin[win]->directory,str_pathbuffer[win]);
		getdir(dopus_curwin[win],win,(flags&SGDFLAGS_REREADINGOLD));
	}
	seename(win);
	refreshwindow(win,0);
}

/* Moves forward or backward a buffer and refreshes display */

void incrementbuf(win,dir,show)
int win,dir,show;
{
	advancebuf(win,dir);
	strcpy(str_pathbuffer[win],dopus_curwin[win]->directory);
	checkdir(str_pathbuffer[win],&path_strgadget[win]);
	checksize(win);
	check_old_buffer(win);
	if (show) {
		seename(win);
		refreshwindow(win,1);
		doselinfo(win);
	}
	startnotify(win);
}

/* Copies the contents of one window to another */

void copydirwin(sourcewin,destwin,dest)
struct DirectoryWindow *sourcewin,*destwin;
int dest;
{
	struct Directory *copy;

	if (status_iconified) return;
	busy();
	freedir(destwin,dest);
	copy=sourcewin->firstentry;
	strcpy(destwin->realdevice,sourcewin->realdevice);
	while (copy) {
		if (!(addfile(destwin,dest,copy->name,copy->size,copy->type,&copy->date,
			copy->comment,copy->protection,copy->subtype,FALSE,copy->dispstr,NULL,
			copy->owner_id,copy->group_id))) break;
		copy=copy->next;
	}
	strcpy(str_pathbuffer[dest],sourcewin->directory);
	strcpy(destwin->directory,sourcewin->directory);
	strcpy(destwin->diskname,sourcewin->diskname);
	destwin->hlen=sourcewin->hlen;
	destwin->flags=sourcewin->flags;
	copy_datestamp(&sourcewin->dirstamp,&destwin->dirstamp);
	refreshwindow(dest,1);
	checkdir(str_pathbuffer[dest],&path_strgadget[dest]);
	checksize(dest);
	last_selected_entry=NULL;
	okay();
	unbusy();
}

/* Swaps the contents of the two windows */

void swapdirwin()
{
	int tmp;
	struct DirectoryWindow tempwin;

	if (status_iconified) return;

	CopyMem((char *)dopus_curwin[0],(char *)&tempwin,sizeof(struct DirectoryWindow));
	tempwin.next=dopus_curwin[1]->next; tempwin.number=dopus_curwin[1]->number;
	tempwin.last=dopus_curwin[1]->last;
	dopus_curwin[1]->next=dopus_curwin[0]->next; dopus_curwin[1]->number=dopus_curwin[0]->number;
	dopus_curwin[1]->last=dopus_curwin[0]->last;
	CopyMem((char *)dopus_curwin[1],(char *)dopus_curwin[0],sizeof(struct DirectoryWindow));
	CopyMem((char *)&tempwin,(char *)dopus_curwin[1],sizeof(struct DirectoryWindow));

	for (tmp=0;tmp<2;tmp++) {
		strcpy(str_pathbuffer[tmp],dopus_curwin[tmp]->directory);
		refreshwindow(tmp,1);
		checkdir(str_pathbuffer[tmp],&path_strgadget[tmp]);
		checksize(tmp);
	}
	okay();
}

/* Moves forwards or backwards a directory */

void advancebuf(win,dir)
int win,dir;
{
	int a;

	endnotify(win);
	if (!checkcurrentbuffer(win)) {
		if (dir>0) {
			for (a=0;a<dir;a++) dopus_curwin[win]=dopus_curwin[win]->next;
		}
		else {
			for (a=dir;a<0;a++) dopus_curwin[win]=dopus_curwin[win]->last;
		}
	}
}

/* Clears the contents of all unshown buffers */

void clearbuffers()
{
	int a,win;
	struct DirectoryWindow *dir;

	busy();
	for (win=0;win<2;win++) {
		dir=dopus_firstwin[win];
		for (a=0;a<data_buffer_count[win];a++) {
			if (dopus_curwin[win]!=dir) {
				freedir(dir,-1);
				dir->directory[0]=0;
			}
			dir=dir->next;
		}
	}
	unbusy();
	dostatustext(globstring[STR_BUFFERS_CLEARED]);
}

/* Searches backwards for a named buffer and moves to it if found */

struct DirectoryWindow *findbuffer(dirbuf,win,canchecklocks,onlyreturn)
char *dirbuf;
int win,canchecklocks,onlyreturn;
{
	int a,founddir=0,ret=0,try,checklocks=0;
	struct DirectoryWindow *dir;
	BPTR lock=0,testlock;
	struct FileInfoBlock __aligned fblock;
	char tempbuf[300];

	if (status_iconified) return(NULL);
	dir=dopus_curwin[win];
	main_proc->pr_WindowPtr=(APTR)-1;

	strcpy(tempbuf,dirbuf);

	if (config->dirflags&DIRFLAGS_EXPANDPATHS) {
		canchecklocks=0;
		expand_path(dirbuf,tempbuf);
	}

	TackOn(tempbuf,NULL,300);

	for (try=0;try<2;try++) {
		if (checklocks && !(lock=Lock(tempbuf,ACCESS_READ))) break;

		for (a=0;a<data_buffer_count[win];a++,dir=dir->last) {
			if (dir->directory[0]) {
				if (checklocks &&
					(testlock=Lock(dir->directory,ACCESS_READ))) {
					if (CompareLock(lock,testlock)==LOCK_SAME) founddir=1;
					UnLock(testlock);
					if (!founddir) continue;
				}
				if (founddir || (LStrCmpI(tempbuf,dir->directory))==0) {
					if (!(lockandexamine(tempbuf,&fblock)) ||
						(CompareDate(&fblock.fib_Date,&dir->dirstamp)!=0)) continue;
					if (!onlyreturn) go_to_buffer(win,dir);
					ret=1;
					break;
				}
			}
		}
		if (ret) break;
		if (canchecklocks) checklocks=1;
		else break;
	}
	if (lock) UnLock(lock);
	if (config->errorflags&ERROR_ENABLE_DOS) main_proc->pr_WindowPtr=(APTR)Window;
	return((ret)?dir:NULL);
}

/* Checks all buffers for a pathname and changes it to the new
   pathname if found */

void renamebuffers(old,new)
char *old,*new;
{
	int a,win;
	struct DirectoryWindow *dir;

	for (win=0;win<2;win++) {
		dir=dopus_firstwin[win];
		for (a=0;a<data_buffer_count[win];a++) {
			if (replacepart(dir->directory,old,new) && dopus_curwin[win]==dir) {
				strcpy(str_pathbuffer[win],dir->directory);
				checkdir(str_pathbuffer[win],&path_strgadget[win]);
			}
			dir=dir->next;
		}
	}
}

replacepart(string,old,new)
char *string,*old,*new;
{
	int oldlen,stringlen;
	char tempbuf[256];

	oldlen=strlen(old);
	if (LStrnCmpI(string,old,oldlen)) return(0);
	if ((stringlen=strlen(string))>oldlen) {
		stringlen-=oldlen;
		strncpy(tempbuf,&string[oldlen],stringlen);
		tempbuf[stringlen]=0;
	}
	else stringlen=0;
	strcpy(string,new);
	if (stringlen>0) StrConcat(string,tempbuf,256);
	return(1);
}

/* Generates a list of all available buffers in a window */

void dolistbuffers(destwin)
int destwin;
{
	int a,b,c,win;
	struct DateStamp ds;
	struct DirectoryWindow *dir;
	char name[2];

	if (status_iconified) return;
	makespecialdir(destwin,globstring[STR_BUFFER_LIST_TITLE]);

	busy(); b=scrdata_dispwin_nchars[destwin]; name[0]=0;
	DateStamp(&ds);
	for (win=0;win<2;win++) {
		dir=dopus_firstwin[win];
		for (a=0;a<data_buffer_count[win];a++) {
			if (dir->directory[0]) {
				addfile(dopus_curwin[destwin],destwin,name,0,
					ENTRY_CUSTOM,&ds,dir->directory,0,
					CUSTOMENTRY_BUFFERLIST,FALSE,dir->directory,NULL,0,0);
				if ((c=strlen(dir->directory))>b) b=c;
			}
			dir=dir->next;
		}
	}
	dopus_curwin[destwin]->hlen=b;
	refreshwindow(destwin,3);
	unbusy();
	okay();
}

/* Check if buffer is a special buffer, and return to normal if so */

checkcurrentbuffer(win)
int win;
{
	if (dopus_curwin[win]==dopus_specialwin[win]) {
		dopus_curwin[win]=dopus_oldwin[win];
		return(1);
	}
	return(0);
}

/* Send message to custom entry handler */

void userentrymessage(dir,entry,type)
struct DirectoryWindow *dir;
struct Directory *entry;
int type;
{
	struct RexxMsg *msg,*reply;
	struct MsgPort *port;
	int fail=0;

	/* If no customhandler installed or rexx library is not there, return */
	if (!dir->custhandler[0] || !RexxSysBase) return;

	/* Attempt to create the message packet */
	if (!(msg=CreateRexxMsg(general_port,NULL,str_arexx_portname))) fail=1;
	else {
		/* Set message type (and argument count of 4) */
		msg->rm_Action=RXFUNC|4;

		/* Fill out argument pointers.

		   Arg0   = operation type
		   Arg1   = entry number
		   Arg2   = entry text
		   Arg3   = userdata          */

		msg->rm_Args[0]=(STRPTR)type;
		msg->rm_Args[1]=entry->name;
		msg->rm_Args[2]=entry->comment;
		msg->rm_Args[3]=(STRPTR)entry->protection;

		/* Fill in the message correctly.
		   Arguments are integer/string/string/integer
                        1       0      0      1       = 9 */

		if (!(FillRexxMsg(msg,4,9))) fail=1;
	}

	/* If we failed to create the message properly, release it and return */
	if (fail) {
		if (msg) DeleteRexxMsg(msg);
		doerror(103);
		return;
	}

	/* Forbid() to find the port */
	Forbid();
	if (!(port=FindPort(dir->custhandler))) {
		char message[200];

		/* Port was not out there; put up an error requester */
		lsprintf(message,globstring[STR_CUSTPORT_NOT_FOUND],dir->custhandler);
		simplerequest(message,str_okaystring,NULL);

		/* Clear message and return */
		ClearRexxMsg(msg,4);
		DeleteRexxMsg(msg);
		Permit();
		return;
	}

	/* Turn busy pointer on and send the message */
	busy();
	PutMsg(port,(struct Message *)msg);

	Permit();
	SetSignal(0,INPUTSIG_ABORT);

	FOREVER {
		/* If abort sequence hit, break out immediately. The message is now
		   lost to us, we can never free it */
		if ((Wait(1<<general_port->mp_SigBit|INPUTSIG_ABORT))&INPUTSIG_ABORT) {
			status_haveaborted=status_justabort=0;
			break;
		}

		/* If message has been replied, free it and break out */
		if (reply=(struct RexxMsg *)GetMsg(general_port)) {
			ClearRexxMsg(msg,4);
			DeleteRexxMsg(msg);
			break;
		}
	}
	unbusy();
	okay();
}

/* Opens the "special" dir in the window for a custom list */

void makespecialdir(win,title)
int win;
char *title;
{
	freedir(dopus_specialwin[win],win);
	if (dopus_curwin[win]!=dopus_specialwin[win]) {
		dopus_oldwin[win]=dopus_curwin[win];
		dopus_curwin[win]=dopus_specialwin[win];
	}
	strcpy(dopus_curwin[win]->diskname,title);
	str_pathbuffer[win][0]=0;
	checkdir(str_pathbuffer[win],&path_strgadget[win]);
	freedir(dopus_curwin[win],win);
	dopus_curwin[win]->diskfree=dopus_curwin[win]->disktot=dopus_curwin[win]->diskblock=-1;
}

/* Checks buffers to see if they need re-reading */

void check_old_buffer(win)
int win;
{
	int reread=0;

	if (config->dirflags&DIRFLAGS_REREADOLD && dopus_curwin[win]->directory[0]) {
		if (dopus_curwin[win]->firstentry &&
			(dopus_curwin[win]->firstentry->type==ENTRY_CUSTOM ||
			dopus_curwin[win]->firstentry->type==ENTRY_DEVICE)) return;
		else {
			struct FileInfoBlock __aligned testinfo;

			main_proc->pr_WindowPtr=(APTR)-1;
			if (lockandexamine(dopus_curwin[win]->directory,&testinfo)) {
				if (CompareDate(&dopus_curwin[win]->dirstamp,&testinfo.fib_Date)<0)
					reread=1;
				else if (!(config->dirflags&DIRFLAGS_EXPANDPATHS) &&
					dopus_curwin[win]->volumename[0]) {

					char rootname[256];

					strcpy(rootname,dopus_curwin[win]->directory);
					if (getroot(rootname,NULL) &&
						(strcmp(rootname,dopus_curwin[win]->volumename))!=0)
						reread=1;
				}
			}
			if (config->errorflags&ERROR_ENABLE_DOS) main_proc->pr_WindowPtr=(APTR)Window;
		}
		if (reread) {
			struct DirWindowPars notifypars;

			notifypars.reselection_list=NULL;
			makereselect(&notifypars,win);
			startgetdir(win,SGDFLAGS_REREADINGOLD);
			doreselect(&notifypars,0);
			makereselect(&notifypars,-1);
		}
	}
}

/* Refresh the display of a window */

void refreshwindow(win,type)
int win,type;
{
	if (win>-1) {
		if (dopus_curwin[win]->offset>dopus_curwin[win]->total-scrdata_dispwin_lines)
			dopus_curwin[win]->offset=dopus_curwin[win]->total-scrdata_dispwin_lines;
		if (dopus_curwin[win]->offset<0)
			dopus_curwin[win]->offset=0;

		if (type&1) {
			fixprop(win);
			fixhorizprop(win);
		}
		if (type&2) displayname(win,1);
		dopus_curwin[win]->oldoff=dopus_curwin[win]->oldhoff=-1;
		displaydir(win);
	}
}

/* Move to a buffer */

void go_to_buffer(win,dir)
int win;
struct DirectoryWindow *dir;
{
	endnotify(win);
	dopus_curwin[win]=dir;
	strcpy(str_pathbuffer[win],dir->directory);
	checkdir(str_pathbuffer[win],&path_strgadget[win]);
	checksize(win);
	check_old_buffer(win);
	refreshwindow(win,1);
	doselinfo(win);
	startnotify(win);
}