// radioSet1x-
//
//	This program demonstrates operations on a radio button, including
// simulated button clicks, double clicks, showing and hiding radio buttons,
// enabling and disabling radio buttons, moving radio buttons, and resizing 
// radio buttons.
//
// This version of the program implements the button manually, without using the
// wForm..endwForm macro (the HOWL declarative language).

program radioSet1x;
#linker( "comdlg32.lib" ) 
#linker( "comctl32.lib" )

?@NoDisplay 	:= true;
?@NoStackAlign	:= true;

#includeOnce( "stdlib.hhf" )
#includeOnce( "howl.hhf" )

const
	applicationName := "Radio Buttons #1x";
	formX			:= w.CW_USEDEFAULT;	// Let Windows position this guy
	formY			:= w.CW_USEDEFAULT;
	formW			:= 600;
	formH			:= 600;



static
	align( 4 );
	bkgBrush_g	:dword;
	bkgColor_g	:dword;

// Forward declarations for the onClick widgetProcs that we're going to
// call when an event occurs.

proc onClick1					:widgetProc; @forward;
proc hideShowRadioButton		:widgetProc; @forward;
proc enableDisableRadioButton	:widgetProc; @forward;
proc moveRadioButton			:widgetProc; @forward;
proc resizeRadioButton			:widgetProc; @forward;
proc onDblClick					:widgetProc; @forward;
proc onQuit						:widgetProc; @forward;
	

type

	// Create a new class for our main application window.
	// All application forms must be derived from wForm_t:
		
	mainAppWindow_t:
		class inherits( wForm_t );
		
			// We have to add VAR declarations for all our widgets
			// here.
			
			var
				radioButton1	:wRadioButton_p;
				radioButton2	:wRadioButtonLT_p;
				button2			:wPushButton_p;
				button3			:wPushButton_p;
				button4			:wPushButton_p;
				button5			:wPushButton_p;
				button6			:wPushButton_p;
				quitButton		:wPushButton_p;
				showState		:boolean;
				b1Enabled		:boolean;
				align(4);
	
		
			// We need to override these (actually, onClose is the
			// only one that is important):
			
			override method onClose;
			override method onCreate;
			
			// Every main application window must have a
			// constructor with the following prototype:
			
			procedure create_mainAppWindow
			(
			        caption :string;
			        exStyle :dword;
			        style   :dword;
			        parent  :dword;
			        x       :dword;
			        y       :dword;
			        width   :dword;
			        height  :dword;
			        bkgClr  :dword;
			        visible :boolean
			);
			
		endclass;
		
		mainAppWindow_p	:pointer to mainAppWindow_t;

// Must have the following declarations in all (manually written) HOWL apps:
	
static
    vmt( mainAppWindow_t );
    mainAppWindow: mainAppWindow_t;
    pmainAppWindow: mainAppWindow_p := &mainAppWindow;	





// Here is the constructor we must supply for the mainAppWindow class:

procedure mainAppWindow_t.create_mainAppWindow
(
        caption :string;
        exStyle :dword;
        style   :dword;
        parent  :dword;
        x       :dword;
        y       :dword;
        width   :dword;
        height  :dword;
        bkgClr  :dword;
        visible :boolean
);
var
    main :mainAppWindow_p;

begin create_mainAppWindow;

    push( eax );
    push( ebx );
    push( ecx );
    push( edx );
	
	// Standad main form initialization:
	//
	// If a class procedure call (not typical), then allocate storage
	// for this object:
	
    if( esi = NULL ) then
        mem.alloc( @size( mainAppWindow_t ));
        mov( eax, esi );
        mov( true, cl );
    else
        mov( this.wBase_private.onHeap, cl );
    endif;
	
	// Call the wForm_t constructor to do all the default initialization:
	
    (type wForm_t [esi]).create_wForm
    (
        "mainAppWindow",
        caption,
        exStyle,
        style,
        parent,
        x,
        y,
        width,
        height,
        bkgClr,
        visible
    );
	
	// Initialize the VMT pointer:
	
    mov( &mainAppWindow_t._VMT_, this._pVMT_ );
	
	// Retrieve the onHeap value from above and store it into
	// the onHeap data field:
	
    mov( cl, this.wBase_private.onHeap );
	
	// Preserve "this" because we're about to make an object call
	// that will overwrite this' value:
	
    mov( esi, main );
	
	//////////////////////////////////////////////
	//
	// Create all the widgets on this form:
	//
	//////////////////////////////////////////////
	
	// The primary radio button on the form:
	
	wRadioButton_t.create_wRadioButton
	(
		"radioButton1",				// radio button name
		"Radio Button #1 abc",		// Caption for radio button
		0,							// Style
		this.handle,				// Parent window handle
		10,							// x position 
		10,							// y position 
		125,						// width 
		25,							// height 
		&onClick1					// initial "on click" event handler 
	);

	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.radioButton1 );	// Save button pointer.
	
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The left-text radio button on the form:
	
	wRadioButtonLT_t.create_wRadioButtonLT
	(
		"radioButton2",				// radio button name
		"Radio Button #2 abc",		// Caption for radio button
		0,							// Style
		this.handle,				// Parent window handle
		10,							// x position 
		70,							// y position 
		125,						// width 
		25,							// height 
		&onClick1					// initial "on click" event handler 
	);

	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.radioButton2 );		// Save button pointer.
	
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The show/hide button on the form:
	
	wPushButton_t.create_wPushButton
	(
		"button2",					// Button name
		"Hide radio button 1",		// Caption for push button
		this.handle,				// Parent window handle
		175,						// x position 
		10,							// y position 
		150,						// width 
		25,							// height 
		&hideShowRadioButton		// initial "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.button2 );		// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The enable/disable button on the form:
	
	wPushButton_t.create_wPushButton
	(
		"button3",					// Button name
		"Disable radio button 1",	// Caption for push button
		this.handle,				// Parent window handle
		175,						// x position 
		40,							// y position 
		150,						// width 
		25,							// height 
		&enableDisableRadioButton	// initial "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.button3 );		// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The move button on the form:
	
	wPushButton_t.create_wPushButton
	(
		"button4",					// Button name
		"Move radio button 1",		// Caption for push button
		this.handle,				// Parent window handle
		175,						// x position 
		70,							// y position 
		150,						// width 
		25,							// height 
		&moveRadioButton			// initial "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.button4 );		// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The resize button on the form:
	
	wPushButton_t.create_wPushButton
	(
		"button5",					// Button name
		"Resize radio buttons",		// Caption for push button
		this.handle,				// Parent window handle
		175,						// x position 
		100,						// y position 
		150,						// width 
		25,							// height 
		&resizeRadioButton			// initial "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.button5 );		// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.



	
	
	// The double-click button on the form:
	
	wPushButton_t.create_wPushButton
	(
		"button6",					// Button name
		"DblClick to Click",		// Caption for push button
		this.handle,				// Parent window handle
		175,						// x position 
		130,						// y position 
		150,						// width 
		25,							// height 
		NULL						// initial "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.button6 );		// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.
	
	
	
	

	
	// We need to create a quit button and store the pointer to the
	// new button object in the this.button field on the form:
	
	wPushButton_t.create_wPushButton
	(
		"quitButton",				// Button name
		"Quit",						// Caption
		this.handle,				// parent window handle
		450,						// x position 
		525,						// y position 
		125,						// width 
		25,							// height 
		&onQuit						// "on click" event handler 
	);
	mov( esi, eax );				// Save ptr to new button		
	mov( main, esi );				// Retrieve ptr to main app's object
	mov( eax, this.quitButton );	// Save button pointer.
	this.insertWidget( eax );		// Add button to wForm's widget list.
	
    this.onCreate();				// Be nice, call this guy (even if empty).
    pop( edx );
    pop( ecx );
    pop( ebx );
    pop( eax );

end create_mainAppWindow;	
	
	


	






// The onDblClick widget proc will handle a double click on button6
// and simulate a single click on radio button1.

proc onDblClick:widgetProc;
begin onDblClick;

	mov( mainAppWindow.radioButton1, esi );
	(type wRadioButton_t [esi]).click();
	mov( mainAppWindow.radioButton2, esi );
	(type wRadioButton_t [esi]).click();
	
end onDblClick;
	


// The resizeRadioButton widget proc will resize radio button1 between widths 125 and 150.

proc resizeRadioButton:widgetProc;
begin resizeRadioButton;

	mov( mainAppWindow.radioButton1, esi );
	(type wRadioButton_t [esi]).get_width();
	if( eax = 125 ) then
	
		stdout.put( "Resizing radio button to width 150" nl );
		(type wRadioButton_t [esi]).set_width( 150 );
		mov( mainAppWindow.radioButton2, esi );
		(type wRadioButton_t [esi]).set_width( 150 );
		
	else
	
		stdout.put( "Resizing radio button to width 125" nl );
		(type wRadioButton_t [esi]).set_width( 125 );
		mov( mainAppWindow.radioButton2, esi );
		(type wRadioButton_t [esi]).set_width( 125 );
		
	endif;
	
end resizeRadioButton;
	


// The moveRadioButton widget proc will move radio button1 between y positions 10 and 40.

proc moveRadioButton:widgetProc;
begin moveRadioButton;

	mov( mainAppWindow.radioButton1, esi );
	(type wRadioButton_t [esi]).get_y();
	if( eax = 10 ) then
	
		stdout.put( "Moving radio button to y-position 40" nl );
		(type wRadioButton_t [esi]).set_y( 40 );
		
	else
	
		stdout.put( "Moving radio button to y-position 10" nl );
		(type wRadioButton_t [esi]).set_y( 10 );
		
	endif;
	
end moveRadioButton;
	


// The enableDisableRadioButton widget proc will hide and show radio button1.

proc enableDisableRadioButton:widgetProc;
begin enableDisableRadioButton;

	mov( thisPtr, esi );
	if( mainAppWindow.b1Enabled ) then
	
		(type wRadioButton_t [esi]).set_text( "Enable radio button 1" );
		mov( false, mainAppWindow.b1Enabled );
		stdout.put( "Disabling button 1" nl );
		mov( mainAppWindow.radioButton1, esi );
		(type wRadioButton_t [esi]).disable();
		
	else
	
		(type wRadioButton_t [esi]).set_text( "Disable radio button 1" );
		mov( true, mainAppWindow.b1Enabled );
		stdout.put( "Enabling button 1" nl );
		mov( mainAppWindow.radioButton1, esi );
		(type wRadioButton_t [esi]).enable();
		
	endif;	
	
end enableDisableRadioButton;
	


// The hideShowRadioButton widget proc will hide and show radio button1.

proc hideShowRadioButton:widgetProc;
begin hideShowRadioButton;

	mov( thisPtr, esi );
	if( mainAppWindow.showState ) then
	
		(type wRadioButton_t [esi]).set_text( "Hide radio button 1" );
		mov( false, mainAppWindow.showState );
		stdout.put( "Showing button 1" nl );
		mov( mainAppWindow.radioButton1, esi );
		(type wRadioButton_t [esi]).show();
		
	else
	
		(type wRadioButton_t [esi]).set_text( "Show radio button 1" );
		mov( true, mainAppWindow.showState );
		stdout.put( "Hiding button 1" nl );
		mov( mainAppWindow.radioButton1, esi );
		(type wRadioButton_t [esi]).hide();
		
	endif;	
	
end hideShowRadioButton;
	



// Here's the onClick handler for the radio button. Invert the state on each click.


proc onClick1:widgetProc;
begin onClick1;

	// Invert the dot in the radio button:
	
	mov( thisPtr, esi );
	(type wRadioButton_t [esi]).get_check();
	xor( 1, eax );
	and( 1, eax );
	(type wRadioButton_t [esi]).set_check( eax );
	

end onClick1;
	
	

// Here's the onClick event handler for our quit button on the form.
// This handler will simply quit the application:

proc onQuit:widgetProc;
begin onQuit;

	// Quit the app:
	
	w.PostQuitMessage( 0 );

end onQuit;





// We'll use the main application form's onCreate method to initialize
// the various buttons on the form.
//
// This could be done in appStart, but better to leave appStart mainly
// as boilerplate code. Also, putting this code here allows us to use
// "this" to access the mainAppWindow fields (a minor convenience).
		
method mainAppWindow_t.onCreate;
var
	thisPtr	:dword;
	
begin onCreate;

	mov( esi, thisPtr );
	
	// Initialize the showState and enableDisableButton data fields:
		
	mov( false, this.showState );
	mov( true, this.b1Enabled );
	
	// Set up button6's onDblClick handler:
	
	mov( thisPtr, esi );
	mov( this.button6, esi );
	(type wPushButton_t [esi]).set_onDblClick( &onDblClick );

end onCreate;

	
	

///////////////////////////////////////////////////////////////////////////////
//
//
// The following is mostly boilerplate code for all apps (about the only thing
// you would change is the size of the main app's form)
//
//
///////////////////////////////////////////////////////////////////////////////
//	
// When the main application window closes, we need to terminate the 
// application. This overridden method handles that situation.  Notice the
// override declaration for onClose in the wForm declaration given earlier.
// Without that, mainAppWindow_t would default to using the wVisual_t.onClose
// method (which does nothing). 
		
method mainAppWindow_t.onClose;
begin onClose;
	
	// Tell the winmain main program that it's time to terminate.
	// Note that this message will (ultimately) cause the appTerminate
	// procedure to be called.
	
	w.PostQuitMessage( 0 );
	
	
end onClose;

			   
   

			   
   
// When the application begins execution, the following procedure
// is called.  This procedure must create the main
// application window in order to kick off the execution of the
// GUI application:
  
procedure appStart;
begin appStart;

	push( esi );
	
	// Set up the background color (gray) for the form:
	
	w.GetSysColor( w.COLOR_MENU );
	mov( eax, bkgColor_g );
	w.CreateSolidBrush( eax );
	mov( eax, bkgBrush_g );

	// Create the main application window:
	
	mainAppWindow.create_mainAppWindow
	(
		applicationName,		// Window title
		w.WS_EX_CONTROLPARENT,	// Need this to support TAB control selection
		w.WS_OVERLAPPEDWINDOW,	// Style 
		NULL,					// No parent window 									
		formX,					// x-coordinate for window. 
		formY,					// y-coordinate for window.
		formW,					// Width
		formH,					// Height
		bkgColor_g,				// Background color
		true					// Make visible on creation 
	);
	pop( esi );

end appStart;



// appTerminate-
//
//	Called when the application is quitting, giving the app a chance
// to clean up after itself.
//
// Note that this is called *after* the mainAppWindow_t.onClose method
// executes (indeed, mainAppWindow_t.onClose, by posting the quit message,
// is what actually causes the program to begin terminating, which leads
// to the execution of this procedure).

procedure appTerminate;
begin appTerminate;
	
	// Clean up the main application's form.
	// Note that this will recursively clean up all the widgets on the form.
	
	mainAppWindow.destroy();
	w.DeleteObject( bkgBrush_g );	
	
end appTerminate;


// appException-
//
// Gives the application the opportunity to clean up before
// aborting when an unhandled exception comes along:

procedure appException( theException:dword in eax );
begin appException;

	raise( eax );

end appException;



// The main program for a HOWL application must simply
// call the HowlMainApp procedure.

begin radioSet1x;

	HowlMainApp();			
				
end radioSet1x;