/*

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"

struct MsgPort *arbiter_reply_port;
struct MsgPort *arbiter_msg_port=NULL;
struct ProcessStart *arbiter_seglist=NULL;
struct Message arbiter_startup;

install_arbiter()
{
    if (!(arbiter_reply_port=LCreatePort(NULL,0)) ||
        !(arbiter_seglist=AllocMem(sizeof(struct ProcessStart),MEMF_CLEAR|MEMF_PUBLIC)))
        return(0);

    arbiter_seglist->ps_NextSeg=NULL;
    arbiter_seglist->ps_JMP=0x4ef9;
    arbiter_seglist->ps_EntryPoint=(void *)arbiter_process;

    arbiter_startup.mn_Node.ln_Type=NT_MESSAGE;
    arbiter_startup.mn_Node.ln_Pri=0;
    arbiter_startup.mn_ReplyPort=arbiter_reply_port;
    arbiter_startup.mn_Length=(UWORD)sizeof(struct ArbiterMessage);

    if (!(arbiter_msg_port=(struct MsgPort *)
        CreateProc("dopus_arbiter",0,(long)arbiter_seglist>>2,4000))) return(0);

    PutMsg(arbiter_msg_port,&arbiter_startup);
    return(1);
}

void remove_arbiter()
{
    if (arbiter_msg_port) {
        arbiter_command(ARBITER_REMOVE,NULL,0);
        WaitPort(arbiter_reply_port);
        GetMsg(arbiter_reply_port);
    }

    if (arbiter_seglist) FreeMem(arbiter_seglist,sizeof(struct ProcessStart));
    if (arbiter_reply_port) LDeletePort(arbiter_reply_port);
}

arbiter_command(command,data,flags)
int command;
APTR data;
int flags;
{
    struct ArbiterMessage arbiter_msg;
    struct MsgPort command_port;

    CopyMem((char *)arbiter_reply_port,(char *)&command_port,sizeof(struct MsgPort));
    NewList(&command_port.mp_MsgList);

    arbiter_msg.msg.mn_Node.ln_Type=NT_MESSAGE;
    arbiter_msg.msg.mn_Node.ln_Pri=0;
    arbiter_msg.msg.mn_ReplyPort=&command_port;
    arbiter_msg.msg.mn_Length=(UWORD)sizeof(struct ArbiterMessage);
    arbiter_msg.command=command;
    arbiter_msg.data=data;
    arbiter_msg.flags=flags;
    PutMsg(arbiter_msg_port,(struct Message *)&arbiter_msg);
    WaitPort(&command_port);
    GetMsg(&command_port);

    return(arbiter_msg.command);
}

struct LaunchList {
    struct LaunchList *next;
    struct ProcessStart *seglist;
    struct ArbiterMessage launch_msg;
    struct ArbiterMessage *reply_msg;
    struct DOpusRemember *memory;
};

void __saveds arbiter_process()
{
    struct Process *my_process;
    struct Message *my_startup_message;
    struct ArbiterMessage *arb_msg,*remove_msg=NULL;
    struct LaunchList *first_launch=NULL,*launch,*launchpos;
    struct MsgPort *message_reply;
    char ret,remove=0;
    int wait_mask;

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

    wait_mask=1<<my_process->pr_MsgPort.mp_SigBit;

    if (message_reply=LCreatePort(NULL,0))
        wait_mask|=1<<message_reply->mp_SigBit;

    FOREVER {
        if (message_reply) {
            while (arb_msg=(struct ArbiterMessage *)GetMsg(message_reply)) {
                launch=first_launch;
                launchpos=NULL;
                while (launch) {
                    if (arb_msg==&launch->launch_msg) {
                        if (launchpos) launchpos->next=launch->next;
                        else first_launch=launch->next;
                        if (launch->reply_msg) {
                            launch->reply_msg->command=arb_msg->command;
                            ReplyMsg((struct Message *)launch->reply_msg);
                        }
                        LFreeRemember(&launch->memory);
                        FreeMem(launch,sizeof(struct LaunchList));
                        break;
                    }
                    launchpos=launch;
                    launch=launch->next;
                }
            }
            if (remove_msg && !first_launch) {
                ReplyMsg((struct Message *)remove_msg);
                break;
            }
        }
        while (arb_msg=(struct ArbiterMessage *)GetMsg(&my_process->pr_MsgPort)) {
            ret=0;
            switch (arb_msg->command) {
                case ARBITER_REMOVE:
                    if (first_launch) {
                        remove_msg=arb_msg;
                        arb_msg=NULL;
                    }
                    else remove=1;
                    break;
                case ARBITER_LAUNCH:
                    if (message_reply &&
                        (launch=AllocMem(sizeof(struct LaunchList),MEMF_CLEAR))) {
                        struct ArbiterLaunch *arb_launch;
                        struct MsgPort *port;

                        if ((launchpos=first_launch)) {
                            while (launchpos->next) launchpos=launchpos->next;
                        }
                        if (launchpos) launchpos->next=launch;
                        else first_launch=launch;

                        arb_launch=(struct ArbiterLaunch *)arb_msg->data;

                        launch->memory=arb_launch->launch_memory;

                        if (launch->seglist=LAllocRemember(&launch->memory,
                            sizeof(struct ProcessStart),MEMF_PUBLIC|MEMF_CLEAR)) {

                            launch->seglist->ps_JMP=0x4ef9;
                            launch->seglist->ps_EntryPoint=arb_launch->launch_code;

                            launch->launch_msg.msg.mn_Node.ln_Type=NT_MESSAGE;
                            launch->launch_msg.msg.mn_ReplyPort=message_reply;
                            launch->launch_msg.msg.mn_Length=sizeof(struct ArbiterMessage);
                        
                            launch->launch_msg.command=arb_msg->command;
                            launch->launch_msg.data=arb_launch->data;
                            launch->launch_msg.flags=arb_msg->flags;

                            if ((port=(struct MsgPort *)
                                CreateProc(arb_launch->launch_name,0,(long)launch->seglist>>2,4000))) {
                                PutMsg(port,(struct Message *)&launch->launch_msg);
                                if (arb_msg->flags&ARB_WAIT) {
                                    launch->reply_msg=arb_msg;
                                    arb_msg=NULL;
                                }
                                else ret=1;
                            }
                        }
                        else {
                            LFreeRemember(&launch->memory);
                            FreeMem(launch,sizeof(struct ProcessStart));
                        }
                    }
                    break;
            }
            if (arb_msg) {
                arb_msg->command=ret;
                ReplyMsg((struct Message *)arb_msg);
            }
        }
        if (remove) break;
        Wait(wait_mask);
    }

    if (message_reply) LDeletePort(message_reply);
    Forbid();
    ReplyMsg(my_startup_message);
    return;
}

struct Screen *open_subprocess_screen(title,font,memkey,pens)
char *title;
struct TextFont *font;
struct DOpusRemember **memkey;
short *pens;
{
    struct ExtNewScreen newscreen;
    struct TagItem *screentags;
    struct TextAttr *screenattr;
    struct Screen *screen;
    UWORD *screen_drawinfo;

    if (!(screenattr=LAllocRemember(memkey,sizeof(struct TextAttr),MEMF_CLEAR)) ||
        !(screentags=LAllocRemember(memkey,sizeof(struct TagItem)*5,MEMF_CLEAR)) ||
        !(screen_drawinfo=LAllocRemember(memkey,sizeof(scr_drawinfo),0)))
        return(NULL);

    CopyMem((char *)scr_drawinfo,(char *)screen_drawinfo,sizeof(scr_drawinfo));

    if (pens) {
        screen_drawinfo[DETAILPEN]=pens[ARB_PEN_DETAIL];
        screen_drawinfo[BLOCKPEN]=pens[ARB_PEN_BLOCK];
    }

    screentags[0].ti_Tag=SA_DisplayID;
    screentags[0].ti_Data=clone_screen(MainScreen,&newscreen);
    screentags[1].ti_Tag=SA_Pens;
    screentags[1].ti_Data=(ULONG)screen_drawinfo;
    screentags[2].ti_Tag=SA_AutoScroll;
    screentags[2].ti_Data=TRUE;
    screentags[3].ti_Tag=SA_Interleaved;
    screentags[3].ti_Data=TRUE;
    screentags[4].ti_Tag=TAG_END;
    screentags[4].ti_Data=0;

/*  if (system_version2)*/ {
        struct DimensionInfo dimbuf;
        int width,height;

        if ((GetDisplayInfoData(NULL,
            (char *)&dimbuf,
            sizeof(struct DimensionInfo),
            DTAG_DIMS,
            screentags[0].ti_Data))) {

            width=(dimbuf.TxtOScan.MaxX-dimbuf.TxtOScan.MinX)+1;
            height=(dimbuf.TxtOScan.MaxY-dimbuf.TxtOScan.MinY)+1;
            if (newscreen.Width>width) newscreen.Width=width;
            if (newscreen.Height>height) newscreen.Height=height;
        }
  }

    screenattr->ta_Name=font->tf_Message.mn_Node.ln_Name;
    screenattr->ta_YSize=font->tf_YSize;

    newscreen.LeftEdge=0;
    newscreen.TopEdge=0;
    if (pens) {
        newscreen.DetailPen=pens[ARB_PEN_DETAIL];
        newscreen.BlockPen=pens[ARB_PEN_BLOCK];
    }
    else {
        newscreen.DetailPen=0;
        newscreen.BlockPen=1;
    }
    newscreen.Type=CUSTOMSCREEN|NS_EXTENDED;
    newscreen.Font=screenattr;
    newscreen.DefaultTitle=title;
    newscreen.Gadgets=NULL;
    newscreen.Extension=screentags;
    newscreen.Depth=config->scrdepth;

    if (!(screen=OpenScreen((struct NewScreen *)&newscreen))) return(NULL);
    load_palette(screen,config->new_palette);
    return(screen);
}