/*
 *  FM_InfoReq_React.c
 *
 *  Requester for info-request with reaction-support
 *  $VER: V2.0, 13.10.2001
 *  Coded by Edgar Schwan
 */

#include <intuition/gadgetclass.h>
#include <intuition/classusr.h>
#include <intuition/screens.h>
#include <classes/window.h>
#include <dos/dos.h>

#include <clib/intuition_protos.h>
#include <clib/exec_protos.h>
#include <clib/graphics_protos.h>
#include <clib/alib_protos.h>

#include <pragmas/intuition_pragmas.h>
#include <pragmas/exec_pragmas.h>
#include <pragmas/graphics_pragmas.h>

#include <stdlib.h>
#include <stdio.h>

#include "FM_InfoReq_React.h"
#include "FM_ReactionBasics.h"
#include "FM_Reaction.h"
#include "FM_ReactionCD.h"

extern ULONG *PALETTE;

struct ReactWinData *info_rwd = NULL;
struct ReactWinData *workgroup_rwd = NULL;

/*  Do_InfoRequest(): info-requester (full handling).

        SYNOPSIS: void = Do_InfoRequest
                        (
                        struct Window     *Win;
                        char                  *PubScreenName;
                        WORD                    Left;
                        WORD                    Top;
                        );

        INPUTS:     Win:
                            Pointer to the parent-window.

                        PubScreenName:
                            name of the public-screen, where the window should appear.

                        Left:
                            Left edge of palette-window (not supported yet).

                        Top:
                            Top edge of palette-window (not supported yet).

        RETURNS:        -
*/

void Do_InfoRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
{
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenInfoReqWindow(PubScreenName) == TRUE) {
    waitsigs = info_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

    while(result == RESULT_NOTHING) {
        mask = Wait(waitsigs);
#ifndef NDEBUG
        printf("mask: %lX\n", mask);
#endif /*NDEBUG*/
        if (mask & info_rwd->RWD_WSignals) {
            result = HandleInfoReqWindow(Win, PubScreenName);
            }
        if (mask & SIGBREAKF_CTRL_C) {
            result = RESULT_CANCEL;
            }
        }

    CloseInfoReqWindow();
    } else DisplayError(Win, TXT_ERR_Window, 5L);

LoadRGB32(ViewPortAddress (Win), (APTR) PALETTE);
}

/*  OpenInfoReqWindow(): open window of info-requester.

        SYNOPSIS: BOOL res = OpenInfoReqWindow
                        (
                        char                  *PubScreenName;
                        );

        INPUTS:     PubScreenName:
                            name of the public-screen, where the window should appear.

        RETURNS:        res:
                            TRUE, if successfull.
*/

BOOL OpenInfoReqWindow(char *PubScreenName)
{
if (info_rwd = OpenReactionWindow(WIN_INFO_ID, GROUP_Info_ID, PubScreenName)) {
    return(TRUE);
    }

return(FALSE);
}

/*  CloseInfoReqWindow(): close window of info-requester.

        SYNOPSIS: void = CloseInfoReqWindow
                        (
                        void
                        );

        INPUTS:     -

        RETURNS:        -
*/

void CloseInfoReqWindow(void)
{
CloseReactionWindow(info_rwd);
}

/*  HandleInfoReqWindow(): Handle the messages of the info-requester.

        SYNOPSIS: LONG res = HandlePalettePrefWindow
                        (
                        struct Window   *Win;
                        char                *PubScreenName;
                        );

        INPUTS:     Win:
                            Pointer to a window-structure.

                        PubScreenName:
                            name of the public-screen, where windows should appear.

        RETURNS:        res:
                            result of messages: RESULT_NOTHING -> nothing happens.
                                                        RESULT_CANCEL  -> user wants to quit without a change.
                                                        RESULT_OK      -> accept changes and quit.
*/

LONG HandleInfoReqWindow(struct Window *Win, char *PubScreenName)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

while((result = DoMethod(info_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {

#ifndef NDEBUG
    printf("result: %ld\n", result);
#endif /*NDEBUG*/

    switch (result & WMHI_CLASSMASK) {
        case WMHI_CLOSEWINDOW:
            rc = RESULT_CANCEL;
            break;

        case WMHI_GADGETUP:
            switch (result & RL_GADGETMASK) {
                case Info_BUTTON_OK:
                    rc = RESULT_OK;
                    break;
                case Info_BUTTON_More:
                    SetAttrs(info_rwd->RWD_WindowObject, WA_BusyPointer, TRUE);
                    Do_WorkgroupRequest(info_rwd->RWD_IWindow, PubScreenName, 50, 50);
                    SetAttrs(info_rwd->RWD_WindowObject, WA_BusyPointer, FALSE);
                    rc = RESULT_OK;
                    break;
#ifndef NDEBUG
                default:
                    printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
                    DisplayBeep(NULL);
                    break;
#endif /*NDEBUG*/
                }
            break;

        case WMHI_ICONIFY:
            DoMethod(info_rwd->RWD_WindowObject, WM_ICONIFY);
            GetAttr(WINDOW_Window, info_rwd->RWD_WindowObject, (ULONG *) &info_rwd->RWD_IWindow);
            break;

        case WMHI_UNICONIFY:
            DoMethod(info_rwd->RWD_WindowObject, WM_OPEN);
            GetAttr(WINDOW_Window, info_rwd->RWD_WindowObject, (ULONG *) &info_rwd->RWD_IWindow);
            break;
#ifndef NDEBUG
        default:
            printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
            DisplayBeep(NULL);
            break;
#endif /*NDEBUG*/
        }
    }
return(rc);
}

/*  Do_WorkgroupRequest(): workgroup-requester (full handling).

        SYNOPSIS: void = Do_WorkgroupRequest
                        (
                        struct Window     *Win;
                        char                  *PubScreenName;
                        WORD                    Left;
                        WORD                    Top;
                        );

        INPUTS:     Win:
                            Pointer to the parent-window.

                        PubScreenName:
                            name of the public-screen, where the window should appear.

                        Left:
                            Left edge of palette-window.

                        Top:
                            Top edge of palette-window.

        RETURNS:        -
*/

void Do_WorkgroupRequest(struct Window *Win, char *PubScreenName, WORD Left, WORD Top)
{
LONG result = RESULT_NOTHING;
ULONG waitsigs, mask;

if (OpenWorkgroupReqWindow(PubScreenName) == TRUE) {
    waitsigs = workgroup_rwd->RWD_WSignals|SIGBREAKF_CTRL_C;

    while(result == RESULT_NOTHING) {
        mask = Wait(waitsigs);
#ifndef NDEBUG
        printf("mask: %lX\n", mask);
#endif /*NDEBUG*/
        if (mask & workgroup_rwd->RWD_WSignals) {
            result = HandleWorkgroupReqWindow(Win);
            }
        if (mask & SIGBREAKF_CTRL_C) {
            result = RESULT_CANCEL;
            }
        }

    CloseWorkgroupReqWindow();
    } else DisplayError(Win, TXT_ERR_Window, 5L);
}

/*  OpenWorkgroupReqWindow(): open window of workgroup-requester.

        SYNOPSIS: BOOL res = OpenWorkgroupReqWindow
                        (
                        char                  *PubScreenName;
                        );

        INPUTS:     PubScreenName:
                            name of the public-screen, where the window should appear.

        RETURNS:        res:
                            TRUE, if successfull.
*/

BOOL OpenWorkgroupReqWindow(char *PubScreenName)
{
if (workgroup_rwd = OpenReactionWindow(WIN_WORK_ID, GROUP_Work_ID, PubScreenName)) {
    return(TRUE);
    }
return(FALSE);
}

/*  CloseWorkgroupReqWindow(): close window of workgroup-requester.

        SYNOPSIS: void = CloseWorkgroupReqWindow
                        (
                        void
                        );

        INPUTS:     -

        RETURNS:        -
*/

void CloseWorkgroupReqWindow(void)
{
CloseReactionWindow(workgroup_rwd);
}

/*  HandleWorkgroupReqWindow(): Handle the messages of the workgroup-requester.

        SYNOPSIS: BOOL = HandleWorkgroupReqWindow
                        (
                        struct Window   *Win;
                        );

        INPUTS:     Win:
                            Pointer to a window-structure.

        RETURNS:        res:
                            result of messages: RESULT_NOTHING -> nothing happens.
                                                        RESULT_CANCEL  -> user wants to quit without a change.
                                                        RESULT_OK      -> accept changes and quit.
*/

LONG HandleWorkgroupReqWindow(struct Window *Win)
{
LONG rc = RESULT_NOTHING;
ULONG result, code;

while((result = DoMethod(workgroup_rwd->RWD_WindowObject, WM_HANDLEINPUT, &code)) != WMHI_LASTMSG) {

#ifndef NDEBUG
    printf("result: %ld\n", result);
#endif /*NDEBUG*/

    switch (result & WMHI_CLASSMASK) {
        case WMHI_CLOSEWINDOW:
            rc = RESULT_CANCEL;
            break;

        case WMHI_GADGETUP:
            switch (result & RL_GADGETMASK) {
                case Work_BUTTON_OK:
                    rc = RESULT_OK;
                    break;
#ifndef NDEBUG
                default:
                    printf("unknown result: %lX\nunknown gadget: %lX\n", result, result & WMHI_GADGETMASK);
                    DisplayBeep(NULL);
                    break;
#endif /*NDEBUG*/
                }
            break;

        case WMHI_ICONIFY:
            DoMethod(workgroup_rwd->RWD_WindowObject, WM_ICONIFY);
            GetAttr(WINDOW_Window, workgroup_rwd->RWD_WindowObject, (ULONG *) &workgroup_rwd->RWD_IWindow);
            break;

        case WMHI_UNICONIFY:
            DoMethod(workgroup_rwd->RWD_WindowObject, WM_OPEN);
            GetAttr(WINDOW_Window, workgroup_rwd->RWD_WindowObject, (ULONG *) &workgroup_rwd->RWD_IWindow);
            break;
#ifndef NDEBUG
        default:
            printf("unknown result: %lX\nunknown class: %lX\n", result, result & WMHI_CLASSMASK);
            DisplayBeep(NULL);
            break;
#endif /*NDEBUG*/
        }
    }
return(rc);
}