/*
\\              $VER: Window.ext V1.00 (26/2/96)
*/

        #define EXTMOD
        #include <Global/Main_Global.h>
        #include <Global/Window_Prototypes.ext.c>

ULONG window( struct EMC_Data *emd );
SAVEDS ASM ULONG main( REG(d0) struct EMC_Data *e )
{
        return( window( e ) );
}
	#include "Window.img"
struct windowdata {                     // Custom data for window object
        UBYTE *title, *id;
        ULONG flags;
};
	#include "Window.img"
        #define W_BACKDROP              (1<<0)
        #define W_BORDERLESS    (1<<1)
        #define W_CLOSEGADGET   (1<<2)
        #define W_DRAGBAR               (1<<3)
        #define W_APPWINDOW             (1<<4)
        #define W_SIZEGADGET    (1<<5)
        #define W_NEEDSMOUSE    (1<<6)
        #define W_SIZERIGHT             (1<<7)
        #define W_BOTTOMSCROLL  (1<<8)
        #define W_LEFTSCROLL    (1<<9)
        #define W_RIGHTSCROLL   (1<<10)

ULONG editobj( BOOL );
ULONG makeobj( void );
ULONG killobj( void );
ULONG handle_input( void );
ULONG describe( void );
ULONG initobj( void );

struct ExecBase *SysBase;
struct IntuitionBase *IntuitionBase;
struct Library *MUIMasterBase;
ULONG retval;
struct EMC_Data *emd;
Object *udata, *title, *idstring;
Object *backdrop, *borderless, *closegad, *size, *sizeright, *drag, *appwin;
Object *usebot, *useleft, *useright;


ULONG window( struct EMC_Data *e )
{
        SysBase = *((struct ExecBase **)4);
        IntuitionBase = e->intbase;
        MUIMasterBase = e->muibase;
        emd = e;

        switch( emd->Command )
        {
                case EXTMOD_INIT:       return( initobj());
                case EXTMOD_EDIT:       return( editobj( TRUE ) );
                case EXTMOD_INPT:       return( handle_input());
                case EXTMOD_MAKE:       return( makeobj() );
                case EXTMOD_KILL:       return( killobj() );
                case EXTMOD_GENS:       return( NULL );
                case EXTMOD_DESC:       return( describe() );
                case EXTMOD_CONT:       return( editobj( FALSE ) );
        }
}


ULONG initobj( void )
{
 emd->Image_Object = BodychunkObject,ImageButtonFrame, 			
                      MUIA_Bodychunk_Body	, &Body_Data,
                      MUIA_Bodychunk_Compression, BODY_COMPRESSION,
                      MUIA_Bodychunk_Depth	, BODY_DEPTH,
                      MUIA_Bitmap_Width		, BODY_WIDTH,
                      MUIA_Bitmap_Height	, BODY_HEIGHT,
                      MUIA_FixWidth             , BODY_WIDTH,
                      MUIA_FixHeight            , BODY_HEIGHT,         
                      MUIA_Bitmap_SourceColors	,&Body_Colour,
                      MUIA_Bitmap_Precision	, PRECISION_EXACT,                                          
                     End; 
 return(CLASS_ONECHILD |CLASS_MAKEOBJ|CLASS_NEEDSNAME);
}




UBYTE *copystr( UBYTE *str )
{
	UBYTE *dest;

        if( !(dest = (UBYTE *) AllocPooled( emd->MemoryPool, strlen( str )+1 ) ) )       
                return( NULL );
        strcpy( dest, str );
        return( dest );
}

SAVEDS ULONG Get( Object *Module, ULONG attr )
{
        /* Returns value of requested attr, or NULL */

        ULONG retval;
        if( !GetAttr( attr, Module, &retval ) )
                return( NULL );
        return( retval );
} 

void StrnTag( UBYTE **ptr, ULONG maxchars, UBYTE *string )
{
        // Copy string, update ptr, length limit

        for( ; *string && maxchars; (*ptr)++, maxchars-- )
                **ptr = *string++;
        **ptr = NULL;                                           // Terminate the string
}

void StrTag( UBYTE **ptr, UBYTE *string )
{
        //      Copy string, update ptr

        StrnTag( ptr, -1, string );
}

void StrTagf( UBYTE **ptr, UBYTE *string, ... )
{
        // Copy string via Sprintf, udpate ptr

        UBYTE **dataptr = &string;

        vsprintf( *ptr, string, ++dataptr );
        while( **ptr ) (*ptr)++;
}                 

ULONG editobj( BOOL firstrun )
{
        // Open edit window, handle user input

        ULONG signals, id;
        struct windowdata *wd;
                 

        
       
          wd = AllocPooled( emd->MemoryPool, sizeof(struct windowdata));
                   
          emd->This_Module->data = wd;
          wd->title = copystr( "<no title>" );
          wd->flags = W_CLOSEGADGET | W_SIZEGADGET | W_DRAGBAR;
        

        if( firstrun )
        {
                if( !(udata =   GroupObject,
                                                                Child, HGroup,
                                                                        Child, VGroup,
                                                                                MUIA_Group_SameSize, TRUE,
                                                                                MUIA_Weight, 0,
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033rWindow Title",
                                                                                        MUIA_Text_HiChar, 'w',
                                                                                        MUIA_Frame, MUIV_Frame_String,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033rWindow ID",
                                                                                        MUIA_Text_HiChar, 'i',
                                                                                        MUIA_Frame, MUIV_Frame_String,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                        End,
                                                                        Child, VGroup,
                                                                                Child, title = KeyString( wd->title, 80, 'w' ),
                                                                                Child, idstring = KeyString( wd->id, 5, 'i' ),
                                                                        End,
                                                                End,
                                                                Child, RectangleObject,
                                                                        MUIA_Rectangle_HBar, TRUE,
                                                                        MUIA_FixHeight, 8,
                                                                End,
                                                                Child, HGroup,
                                                                        MUIA_Group_SameSize, TRUE,
                                                                        Child, ColGroup(2),
                                                                                Child, backdrop = KeyCheckMark( wd->flags & W_BACKDROP, 'k' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lBackdrop",
                                                                                        MUIA_Text_HiChar, 'k',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, borderless = KeyCheckMark( wd->flags & W_BORDERLESS, 'o' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lBorderless",
                                                                                        MUIA_Text_HiChar, 'o',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, closegad = KeyCheckMark( wd->flags & W_CLOSEGADGET, 'c' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lClose Gadget",
                                                                                        MUIA_Text_HiChar, 'c',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, drag = KeyCheckMark( wd->flags & W_DRAGBAR, 'd' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lDragbar",
                                                                                        MUIA_Text_HiChar, 'd',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, appwin = KeyCheckMark( wd->flags & W_APPWINDOW, 'a' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lApp-Window",
                                                                                        MUIA_Text_HiChar, 'a',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                        End,
                                                                        Child, ColGroup(2),
                                                                                Child, size = KeyCheckMark( wd->flags & W_SIZEGADGET, 's' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lSize Gadget",
                                                                                        MUIA_Text_HiChar, 's',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, sizeright = KeyCheckMark( wd->flags & W_SIZERIGHT, 't' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lSize Right",
                                                                                        MUIA_Text_HiChar, 't',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, usebot = KeyCheckMark( wd->flags & W_BOTTOMSCROLL, 'b' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lUse Bottom Border Scroll",
                                                                                        MUIA_Text_HiChar, 'b',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, useleft = KeyCheckMark( wd->flags & W_LEFTSCROLL, 'l' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lUse Left Border Scroll",
                                                                                        MUIA_Text_HiChar, 'l',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                                Child, useright = KeyCheckMark( wd->flags & W_RIGHTSCROLL, 'r' ),
                                                                                Child, TextObject,
                                                                                        MUIA_Text_Contents, "\033lUse Right Border Scroll",
                                                                                        MUIA_Text_HiChar, 'r',
                                                                                        MUIA_Frame, MUIV_Frame_ImageButton,
                                                                                        MUIA_FramePhantomHoriz, TRUE,
                                                                                End,
                                                                        End,
                                                                End,
                                                        End ) )
                        return( NULL );
                DoMethod( emd->Config_Group, OM_ADDMEMBER, udata );
                set( emd->Config_Win, MUIA_Window_Open, TRUE );
        }
        
}
ULONG handle_input()
{
        ULONG signals, id;
        struct windowdata *wd;
        
        wd = emd->This_Module->data;
        if(!wd||!emd->Config_Win)
          return(NULL);
        
     for(;;)
        {
                id = DoMethod( emd->Config_App, MUIM_Application_Input, &signals );
                if( (id == OBJ_OKBUTTON) || (id == OBJ_CANCELBUTTON) ) break;
                if( signals ) Wait( signals );
        }
        if( id == OBJ_OKBUTTON )                   // Ok, set data
        {
                //FreeVecPooled( wd->id );
                //FreeVecPooled( wd->title );
                wd->title       = copystr( (UBYTE *) Get( title, MUIA_String_Contents ) );
                wd->id          = copystr( (UBYTE *) Get( idstring, MUIA_String_Contents ) );
                wd->flags =     (Get( backdrop, MUIA_Selected ) ? W_BACKDROP            : 0) |
                                                (Get( borderless,       MUIA_Selected ) ? W_BORDERLESS  : 0) |
                                                (Get( closegad, MUIA_Selected ) ? W_CLOSEGADGET : 0) |
                                                (Get( size,                     MUIA_Selected ) ? W_SIZEGADGET  : 0) |
                                                (Get( sizeright,        MUIA_Selected ) ? W_SIZERIGHT           : 0) |
                                                (Get( drag,                     MUIA_Selected ) ? W_DRAGBAR             : 0) |
                                                (Get( appwin,           MUIA_Selected ) ? W_APPWINDOW           : 0) |
                                                (Get( usebot,           MUIA_Selected ) ? W_BOTTOMSCROLL        : 0) |
                                                (Get( useleft,          MUIA_Selected ) ? W_LEFTSCROLL  : 0) |
                                                (Get( useright, MUIA_Selected ) ? W_RIGHTSCROLL : 0);
        }
	//DisplayBeep(0);
        return( (BOOL) (id == OBJ_OKBUTTON) );

}

Object * Make_MUIObject( struct Module *EMC_Data)
{
        struct Class  *Current;
        struct EMC_Data OutGoing;
        Object *Dummy;

        ASM ULONG (*Launch_Pad)( REG(d0) struct EMC_Data *);
        Current = EMC_Data->Class;
        
        if(!Current) return( NULL);
        
       // Init_EMC_Data( &OutGoing  );
    
        OutGoing.Command = EXTMOD_MAKE;
        OutGoing.This_Module = EMC_Data;
        Launch_Pad = Current->Launcher;
        Dummy = Launch_Pad(&OutGoing);
        return(Dummy);       
}


ULONG makeobj()
{
        Object       *win;
        struct       Module     *bob;
        Object *fish;
        int counter =  0;
        LONG error;
        struct MinList *List;
        struct windowdata *wd = emd->This_Module->data;
           
         win =  WindowObject,                                               
                MUIA_Window_Title,                      wd->title,
                MUIA_Window_ID,                         wd->id,
                MUIA_Window_Backdrop,                   wd->flags & W_BACKDROP,
                MUIA_Window_Borderless,                 wd->flags & W_BORDERLESS,
                MUIA_Window_CloseGadget,                wd->flags & W_CLOSEGADGET,
                MUIA_Window_SizeGadget,                 wd->flags & W_SIZEGADGET,
                MUIA_Window_SizeRight,                  wd->flags & W_SIZERIGHT,
                MUIA_Window_DragBar,                    wd->flags & W_DRAGBAR,
                MUIA_Window_AppWindow,                  wd->flags & W_APPWINDOW,
                MUIA_Window_UseBottomBorderScroller,    wd->flags & W_BOTTOMSCROLL,
                MUIA_Window_UseLeftBorderScroller,      wd->flags & W_LEFTSCROLL,
                MUIA_Window_UseRightBorderScroller,     wd->flags & W_RIGHTSCROLL,
                
                MUIA_Window_RootObject,                 VGroup,End,
                End;
        
        if(win==NULL)
        {
          error = MUI_Error();
          MUI_Request(NULL, NULL, NULL, "Warning...", "_Continue", "Error is %d\n",error);
          DisplayBeep(0);
         }
          
         
          
          
        return( (ULONG) win );
}

ULONG killobj()
{
        //      Do any removal/deletion necessary on custom data

        struct windowdata *wd;

        if( wd = emd->This_Module->data )
        {
                //FreeVecPooled( wd->title );
                //FreeVecPooled( wd->id );
                //FreeVecPooled( wd );
        }
        return( NULL );
}

ULONG describe()
{
        // Make description to show in stats floattext
/*
        UBYTE *ptr = emd->Buffer;
        struct windowdata *wd = emd->This_Module->data;

        StrTagf( &ptr, "   \033bWindow:\033n %s - `%s'", emd->This_Module->Name, wd->title );
        if( *wd->id ) StrTagf( &ptr, " (ID:`%s')", wd->id );
        StrTag( &ptr, "\n\n   \033bProperties: \033n" );
        if( wd->flags & W_BACKDROP )            StrTag( &ptr, "backdrop, " );
        if( wd->flags & W_BORDERLESS )  StrTag( &ptr, "borderless, " );
        if(!(wd->flags & W_CLOSEGADGET))        StrTag( &ptr, "no close gadget, " );
        if(!(wd->flags & W_DRAGBAR))            StrTag( &ptr, "no drag bar, " );
        if( wd->flags & W_APPWINDOW )           StrTag( &ptr, "appwindow, " );
        if( wd->flags & W_NEEDSMOUSE )  StrTag( &ptr, "needs mouse object, " );
        if(!(wd->flags & W_SIZEGADGET)) StrTag( &ptr, "no size gadget, " );
        else if(wd->flags & W_SIZERIGHT)        StrTag( &ptr, "size gadget in right border, " );
        if( wd->flags & W_BOTTOMSCROLL )        StrTag( &ptr, "prop/bottomborder, " );
        if( wd->flags & W_LEFTSCROLL )  StrTag( &ptr, "prop/leftborder, " );
        if( wd->flags & W_RIGHTSCROLL ) StrTag( &ptr, "prop/rightborder, " );
        ptr -= 2;
        if( *ptr == ',' ) StrTag( &ptr, "." );
        else StrTag( &ptr, " \033nstandard." );
*/
        return( TRUE );
}
