/* 
  * MINIGUI - Harbour Win32 GUI library Demo 
 */ 
  
 #include "minigui.ch" 
  
 FUNCTION MAIN 
    LOCAL nCol 
  
    DEFINE WINDOW FORM_1 ; 
 	AT 0,0 WIDTH 350 HEIGHT 235 ; 
 	MINWIDTH 350 MINHEIGHT 235 ; 
 	TITLE "Get Form Client Height" ; 
 	MAIN ; 
 	ON INIT      Form_Resize() ; 
 	ON SIZE      Form_Resize() ; 
 	ON MAXIMIZE  Form_Resize() 
  
 	DEFINE MAIN MENU 
 		POPUP "&File" NAME mnuFile 
 			MENUITEM "&Exit" NAME mnuFileExit ; 
 				ACTION  ThisWindow.Release 
 		END POPUP 
 	END MENU 
  
 	DEFINE STATUSBAR 
 		STATUSITEM "Ready" RAISED 
 		DATE 
 		CLOCK 
 	END STATUSBAR 
  
 	@ 05,10 LABEL lblWindow    VALUE "WindowHeight = " AUTOSIZE 
 	@ 25,10 LABEL lblBorder    VALUE "BorderHeight = " AUTOSIZE 
 	@ 45,10 LABEL lblTitlebar  VALUE "TitleHeight = " AUTOSIZE 
 	@ 65,10 LABEL lblMenubar   VALUE "MenubarHeight = " AUTOSIZE 
 	@ 85,10 LABEL lblStatusbar VALUE "StatusbarHeight = " AUTOSIZE 
 	@105,10 LABEL lblClient    VALUE "ClientHeight = " AUTOSIZE 
 	@125,10 LABEL lblClientW   VALUE "ClientWidth = " AUTOSIZE 
 	@145,10 LABEL lblWorkArea  VALUE "WorkAreaHeight = " AUTOSIZE 
  
 	nCol := This.lblStatusbar.Width + 10 
  
 	@ 05,nCol LABEL lblWindowHeight    VALUE "" WIDTH 70 HEIGHT 16 RIGHTALIGN 
 	@ 25,nCol LABEL lblBorderHeight    VALUE hb_ntos(GetBorderHeight()) WIDTH 70 RIGHTALIGN 
 	@ 45,nCol LABEL lblTitleHeight     VALUE hb_ntos(GetTitleHeight()) WIDTH 70 RIGHTALIGN 
 	@ 65,nCol LABEL lblMenubarHeight   VALUE hb_ntos(GetMenubarHeight()) WIDTH 70 RIGHTALIGN 
 	@ 85,nCol LABEL lblStatusbarHeight VALUE hb_ntos(This.StatusBar.Height) WIDTH 70 RIGHTALIGN 
 	@105,nCol LABEL lblClientHeight    VALUE "" WIDTH 70 RIGHTALIGN 
 	@125,nCol LABEL lblClientWidth     VALUE "" WIDTH 70 RIGHTALIGN 
 	@145,nCol LABEL lblWorkAreaHeight  VALUE "" WIDTH 70 HEIGHT 16 RIGHTALIGN 
  
 	@ 0,nCol+100 EDITBOX edx WIDTH 100 HEIGHT 100 //NOHSCROLL 
  
    END WINDOW 
  
    CENTER WINDOW FORM_1 
    ACTIVATE WINDOW FORM_1 
  
 RETURN NIL 
  
  
 STATIC PROCEDURE Form_Resize() 
    LOCAL nWindowHeight, nClientHeight 
  
    nWindowHeight := This.Height 
    nClientHeight := nWindowHeight - 2 * GetBorderHeight() 
    nClientHeight -= GetTitleHeight() + GetMenubarHeight() 
    nClientHeight -= This.StatusBar.Height 
  
    This.lblWindowHeight.Value   := hb_ntos(nWindowHeight) 
    This.edx.Height              := nClientHeight 
    This.edx.Width               := This.Width - This.edx.Col - 2 * GetBorderWidth() 
    This.lblClientHeight.Value   := hb_ntos(This.edx.ClientHeight) 
    This.lblClientWidth.Value    := hb_ntos(This.edx.ClientWidth) 
  
    This.lblWorkAreaHeight.Value := hb_ntos(This.ClientHeight - This.StatusBar.Height) 
  
 RETURN 
 

/* 
    tdi_test2.prg 
 */ 
  
 #include "minigui.ch" 
 #include "tdi.ch" 
  
 PROCEDURE main() 
    LOCAL aConfig := Array( TDC_CONFIG ) 
    LOCAL nButton, nRadioButton 
    LOCAL lVerificationFlagChecked := .F. 
    LOCAL nResult 
  
    LOCAL aButton := { { IDOK, "Ok!" } } 
  
    aConfig[ TDC_COMMON_BUTTON_FLAGS ]  := hb_bitOr( TDCBF_OK_BUTTON, TDCBF_CANCEL_BUTTON ) 
  
    //aConfig[ TDC_BUTTON ]               := Len( aButton ) 
    //aConfig[ TDC_TASKDIALOG_BUTTON ]    := aButton 
  
    aConfig[ TDC_HWND ]                 := 0 
    aConfig[ TDC_HINSTANCE ]            := GetInstance() 
    aConfig[ TDC_MAINICON ]             := TD_INFORMATION_ICON 
    aConfig[ TDC_WINDOWTITLE ]          := "Task Dialog Title" 
    aConfig[ TDC_MAININSTRUCTION ]      := "The main instruction text for the TaskDialog goes here." 
    aConfig[ TDC_CONTENT ]              := "The content text for the task dialog is shown here and the text will automatically wrap as needed." 
    // aConfig[ TDC_VERIFICATIONTEXT ]     := NILL 
    aConfig[ TDC_VERIFICATIONTEXT ]     := "Don't show me this message again" 
    aConfig[ TDC_EXPANDEDINFORMATION ]  := "Any expanded content text for the task dialog is shown here and the text will automatically wrap as needed."  
    aConfig[ TDC_EXPANDEDCONTROLTEXT ]  := "Expanded Control Text" 
    aConfig[ TDC_COLLAPSEDCONTROLTEXT ] := "Collapsed Control Text" 
    aConfig[ TDC_FOOTERICON ]           := TD_INFORMATION_ICON 
    aConfig[ TDC_FOOTER ]               := "Optional footer text with an icon can be included" 
  
    aConfig[ TDC_CALLBACK ]             := { |h,n,w,l| callback( h,n,w,l ) } 
  
    nResult := win_TaskDialogIndirect( aConfig, @nButton, @nRadioButton, @lVerificationFlagChecked ) 
  
    IF nResult == 0           // no error occurs 
       SWITCH nButton 
       CASE IDOK 
          ? "Button OK pressed" 
          EXIT 
       OTHERWISE 
          ? "Button ID is", hb_ntos( nButton ) 
          EXIT 
       END SWITCH 
       ? "Verification Flag is", If( lVerificationFlagChecked, "Checked", "UnChecked" ) 
    ELSE 
       ? "TaskDialogIndirect0() returns", nResult 
    END IF 
  
    RETURN 
  
 STATIC FUNCTION callback( hWnd, nNotification, wParam, lParam ) 
    LOCAL lResult := .F. 
    /* 
    To prevent the task dialog from closing, the application must return FALSE, 
    otherwise the task dialog is closed  
    */ 
  
    SWITCH nNotification 
    CASE TDN_CREATED 
        ? "Notification: TDN_CREATED" 
       EXIT 
  
    CASE TDN_DESTROYED 
        ? "Notification: TDN_DESTROYED" 
       EXIT 
  
    CASE TDN_BUTTON_CLICKED 
       // wParam - an int that specifies the ID of the button or comand link that was selected 
        ? "Notification: TDN_BUTTON_CLICKED. ID of the button:", wParam 
       IF wParam == IDOK  
          lResult := .T. 
       ELSEIF wParam == IDCANCEL 
          lResult := .T. 
       ENDIF 
       EXIT 
  
    CASE TDN_RADIO_BUTTON_CLICKED 
       // wParam - an int that specifies the ID corresponding to the radio button that was clicked 
        ? "Notification: TDN_RADIO_BUTTON_CLICKED. ID of the button:", wParam 
       EXIT 
  
    CASE TDN_EXPANDO_BUTTON_CLICKED  
       // the user clicks on the dialog's expando button: wParam is 1 if the dialog is expanded, or 0 if not 
       ? "Notification: TDN_EXPANDO_BUTTON_CLICKED. Dialog is", If( wParam == 1, "expanded", "colapsed" ) 
       EXIT 
  
    CASE TDN_HELP 
       // the user presses F1 on the keyboard while the dialog has focus 
       ? "Notification: TDN_HELP" 
       EXIT 
  
    CASE TDN_VERIFICATION_CLICKED 
       // the user clicks the task dialog verification check box: wParam is the status of the checkbox. 
       // It is 1 if the verification checkbox is checked, or 0 if it is unchecked. 
       ? "Notification: TDN_VERIFICATION_CLICKED. Verification checkbox is", If( wParam == 1, "checked", "unchecked" ) 
       EXIT 
  
    CASE TDN_HYPERLINK_CLICKED 
       ? "Notification: TDN_HYPERLINK_CLICKED" 
       ShellExecute( hWnd, "open", lParam, , , SW_SHOW ) 
    END SWITCH    
  
    RETURN lResult 
  
  
 #pragma BEGINDUMP 
  
 #define _WIN32_WINNT 0x0600 //VISTA 
 #define UNICODE 
  
 #if( defined( __MINGW32__ )) 
 #define MAKEINTRESOURCEA(i) ((LPSTR)((ULONG_PTR)((WORD)(i)))) 
 #define MAKEINTRESOURCEW(i) ((LPWSTR)((ULONG_PTR)((WORD)(i)))) 
 #ifdef UNICODE 
 #define MAKEINTRESOURCE  MAKEINTRESOURCEW 
 #else 
 #define MAKEINTRESOURCE  MAKEINTRESOURCEA 
 #endif 
 #endif 
  
 #include <hbwinuni.h> 
 #include <windows.h> 
 #include <commctrl.h> 
  
 #include "hbapi.h" 
 #include "hbapierr.h" 
 #include "hbapiitm.h" 
 #include "hbvm.h" 
  
 #define TDC_CONFIG                 24   
  
 #define TDC_HWND                   2 
 #define TDC_HINSTANCE              3 
 #define TDC_TASKDIALOG_FLAGS       4 
 #define TDC_COMMON_BUTTON_FLAGS    5 
 #define TDC_WINDOWTITLE            6   
 #define TDC_MAINICON               7 
 #define TDC_MAININSTRUCTION        8   
 #define TDC_CONTENT                9   
 #define TDC_BUTTON                 10 
 #define TDC_TASKDIALOG_BUTTON      11 
 #define TDC_DEFAULTBUTTON          12 
 #define TDC_RADIOBUTTON            13 
 #define TDC_TASKDIALOG_RADIOBUTTON 14 
 #define TDC_DEFAULTRADIOBUTTON     15 
 #define TDC_VERIFICATIONTEXT       16  
 #define TDC_EXPANDEDINFORMATION    17  
 #define TDC_EXPANDEDCONTROLTEXT    18  
 #define TDC_COLLAPSEDCONTROLTEXT   19  
 #define TDC_FOOTERICON             20 
 #define TDC_FOOTER                 21  
 #define TDC_CALLBACK               22 
 #define TDC_WIDTH                  24            
  
 static HB_BOOL checkButton( const PHB_ITEM arrayOfButtons, HB_SIZE arraysize ); 
 HRESULT CALLBACK TDCallbackProc( HWND hWnd, UINT uNotification, WPARAM wParam, LPARAM lParam, LONG_PTR dwRefData ); 
  
 HB_FUNC( WIN_TASKDIALOGINDIRECT ) 
 { 
    PHB_ITEM pConfig = hb_param( 1, HB_IT_ARRAY ); 
  
    if ( pConfig && hb_arrayLen( pConfig ) >= TDC_CONFIG ) 
    { 
       TASKDIALOGCONFIG config  = {0}; 
       int nButton; 
       int nRadioButton; 
       BOOL fVerificationFlagChecked; 
       HRESULT hResult; 
  
       HB_TYPE typ; 
  
       void ** hText = ( void ** ) hb_xgrab( sizeof( void * ) * 10 );   
       int iText = 0; 
  
       TASKDIALOG_BUTTON * buttons = NULL; 
       void ** hButton;    
       int iButton = 0; 
  
       TASKDIALOG_BUTTON * radiobuttons = NULL; 
       void ** hRadioButton;    
       int iRadioButton = 0; 
  
       PHB_ITEM pCallbackData; 
  
       // 1 UINT cbSize 
       config.cbSize     = sizeof( config ); 
  
       // 2 HWND hwndParent 
       if ( hb_arrayGetType( pConfig, TDC_HWND ) & HB_IT_NUMERIC ) 
       { 
          config.hwndParent = ( HWND ) hb_arrayGetNL( pConfig, TDC_HWND ); 
       } 
       else 
       { 
          config.hwndParent = NULL; 
       } 
  
       // 3 HINSTANCE hInstance 
       config.hInstance  = ( HINSTANCE ) hb_arrayGetNL( pConfig, TDC_HINSTANCE ); 
  
       // 4 TASKDIALOG_FLAGS dwFlags 
       if ( hb_arrayGetType( pConfig, TDC_TASKDIALOG_FLAGS ) & HB_IT_NUMERIC ) 
       { 
          config.dwCommonButtons = hb_arrayGetNInt( pConfig, TDC_TASKDIALOG_FLAGS ); 
       } 
  
       // 5 TASKDIALOG_COMMON_BUTTON_FLAGS dwCommonButtons 
       if ( hb_arrayGetType( pConfig, TDC_COMMON_BUTTON_FLAGS ) & HB_IT_NUMERIC ) 
       { 
          config.dwCommonButtons = hb_arrayGetNInt( pConfig, TDC_COMMON_BUTTON_FLAGS ); 
       } 
  
       // 6 PCWSTR pszWindowTitle 
       typ = hb_arrayGetType( pConfig, TDC_WINDOWTITLE ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszWindowTitle = HB_PARASTRDEF( 1, TDC_WINDOWTITLE, &hText[iText++], NULL ); 
       } 
       else if ( typ & HB_IT_NUMERIC ) 
       { 
          config.pszWindowTitle = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_WINDOWTITLE ) ); 
       } 
       else 
       { 
          config.pszWindowTitle = NULL; 
       } 
  
       // 7 union { HICON  hMainIcon; PCWSTR pszMainIcon; }; 
       if ( hb_arrayGetType( pConfig, TDC_MAINICON ) & HB_IT_NUMERIC ) 
       { 
          config.pszMainIcon = ( PCWSTR ) hb_arrayGetNL( pConfig, TDC_MAINICON ); 
       } 
       else 
       { 
          config.pszMainIcon = NULL; 
       } 
  
       // 8 PCWSTR pszMainInstruction 
       typ = hb_arrayGetType( pConfig, TDC_MAININSTRUCTION ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszMainInstruction = HB_PARASTRDEF( 1, TDC_MAININSTRUCTION, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszMainInstruction = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_MAININSTRUCTION ) ); 
       } 
  
       // 9 PCWSTR pszContent; 
       typ = hb_arrayGetType( pConfig, TDC_CONTENT ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszContent = HB_PARASTRDEF( 1, TDC_CONTENT, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszContent = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_CONTENT ) ); 
       } 
  
       // 10 UINT cButtons 
       config.cButtons = ( hb_arrayGetType( pConfig, TDC_BUTTON ) & HB_IT_NUMERIC ) ? hb_arrayGetNI( pConfig, TDC_BUTTON ) : 0; 
  
       // 11 const TASKDIALOG_BUTTON *pButtons 
       typ = hb_arrayGetType( pConfig, TDC_TASKDIALOG_BUTTON ); 
       if ( typ & HB_IT_ARRAY ) 
       { 
          PHB_ITEM pButtons = hb_arrayGetItemPtr( pConfig, TDC_TASKDIALOG_BUTTON ); 
          HB_SIZE arrsize;  
  
          arrsize = hb_arrayLen( pButtons );  
  
          if ( ( arrsize > 0 ) && checkButton( pButtons, arrsize ) ) 
          { 
             HB_SIZE i;  
  
             buttons = ( TASKDIALOG_BUTTON * ) hb_xgrab( sizeof( TASKDIALOG_BUTTON ) * arrsize ); 
             memset( buttons, 0, sizeof( TASKDIALOG_BUTTON ) * arrsize ); 
             hButton = ( void ** ) hb_xgrab( sizeof( void * ) * ( arrsize ) ); 
  
             for ( i = 0; i < arrsize; ++i ) 
             { 
                PHB_ITEM button = hb_arrayGetItemPtr( pButtons, i + 1 ); 
  
                buttons.nButtonID = hb_arrayGetNI( button, 1 ); 
                if ( ( hb_arrayGetType( button, 2 ) & HB_IT_STRING ) != 0 ) 
                { 
                   buttons.pszButtonText = HB_ARRAYGETSTR( button, 2, &hButton[ iButton++ ], NULL ); 
                } 
                else 
                { 
                   buttons.pszButtonText = MAKEINTRESOURCE( hb_arrayGetNI( button, 2 ) ); 
                } 
             } 
             config.cButtons = HB_MIN( config.cButtons, arrsize ); 
             config.pButtons = buttons; 
          } 
       } 
  
       // 12 int nDefaultButton 
       config.nDefaultButton = ( hb_arrayGetType( pConfig, TDC_DEFAULTBUTTON ) & HB_IT_NUMERIC ) ? 
                                  hb_arrayGetNI( pConfig, TDC_DEFAULTBUTTON ) : 0; 
  
       // 13 UINT cRadioButtons 
       config.cRadioButtons = ( hb_arrayGetType( pConfig, TDC_RADIOBUTTON ) & HB_IT_NUMERIC ) ? 
                                  hb_arrayGetNI( pConfig, TDC_RADIOBUTTON ) : 0; 
  
       // 14 const TASKDIALOG_BUTTON *pRadioButtons 
       typ = hb_arrayGetType( pConfig, TDC_TASKDIALOG_RADIOBUTTON ); 
       if ( typ & HB_IT_ARRAY ) 
       { 
          PHB_ITEM pButtons = hb_arrayGetItemPtr( pConfig, TDC_TASKDIALOG_RADIOBUTTON ); 
          HB_SIZE arrsize;  
  
          arrsize = hb_arrayLen( pButtons );  
  
          if ( ( arrsize > 0 ) && checkButton( pButtons, arrsize ) ) 
          { 
             HB_SIZE i;  
  
             radiobuttons = ( TASKDIALOG_BUTTON * ) hb_xgrab( sizeof( TASKDIALOG_BUTTON ) * arrsize ); 
             memset( radiobuttons, 0, sizeof( TASKDIALOG_BUTTON ) * arrsize ); 
             hRadioButton = ( void ** ) hb_xgrab( sizeof( void * ) * ( arrsize ) ); 
  
             for ( i = 0; i < arrsize; ++i ) 
             { 
                PHB_ITEM button = hb_arrayGetItemPtr( pButtons, i + 1 ); 
  
                radiobuttons.nButtonID = hb_arrayGetNI( button, 1 ); 
                if ( ( hb_arrayGetType( button, 2 ) & HB_IT_STRING ) != 0 ) 
                { 
                   radiobuttons.pszButtonText = HB_ARRAYGETSTR( button, 2, &hRadioButton[ iRadioButton++ ], NULL ); 
                } 
                else 
                { 
                   radiobuttons.pszButtonText = MAKEINTRESOURCE( hb_arrayGetNI( button, 2 ) ); 
                } 
             } 
             config.cRadioButtons = HB_MIN( config.cRadioButtons, arrsize ); 
             config.pRadioButtons = radiobuttons; 
          } 
       } 
  
       // 15 int nDefaultRadioButton 
       config.nDefaultRadioButton = ( hb_arrayGetType( pConfig, TDC_DEFAULTRADIOBUTTON ) & HB_IT_NUMERIC ) ? 
                                        hb_arrayGetNI( pConfig, TDC_DEFAULTRADIOBUTTON ) : 0; 
  
       // 16 PCWSTR pszVerificationText 
       typ = hb_arrayGetType( pConfig, TDC_VERIFICATIONTEXT ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszVerificationText = HB_PARASTRDEF( 1, TDC_VERIFICATIONTEXT, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszVerificationText = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_VERIFICATIONTEXT ) ); 
       } 
       else 
       { 
          config.pszVerificationText = NULL; 
       } 
  
       // 17 PCWSTR pszExpandedInformation 
       typ = hb_arrayGetType( pConfig, TDC_EXPANDEDINFORMATION ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszExpandedInformation = HB_PARASTRDEF( 1, TDC_EXPANDEDINFORMATION, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszExpandedInformation = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_EXPANDEDINFORMATION ) ); 
       } 
  
       // 18 PCWSTR pszExpandedControlText 
       typ = hb_arrayGetType( pConfig, TDC_EXPANDEDCONTROLTEXT ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszExpandedControlText = HB_PARASTRDEF( 1, TDC_EXPANDEDCONTROLTEXT, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszExpandedControlText = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_EXPANDEDCONTROLTEXT ) ); 
       } 
  
       // 19 PCWSTR pszCollapsedControlText 
       typ = hb_arrayGetType( pConfig, TDC_COLLAPSEDCONTROLTEXT ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszCollapsedControlText = HB_PARASTRDEF( 1, TDC_COLLAPSEDCONTROLTEXT, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszCollapsedControlText = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_COLLAPSEDCONTROLTEXT ) ); 
       } 
  
       // 20 union { HICON  hFooterIcon; PCWSTR pszFooterIcon; } 
       if ( hb_arrayGetType( pConfig, TDC_FOOTERICON ) & HB_IT_NUMERIC ) 
       { 
          config.pszFooterIcon = ( PCWSTR ) hb_arrayGetNL( pConfig, TDC_FOOTERICON ); 
       } 
       else 
       { 
          config.pszFooterIcon = NULL; 
       } 
  
       // 21 PCWSTR pszFooter; 
       typ = hb_arrayGetType( pConfig, TDC_FOOTER ); 
       if ( typ & HB_IT_STRING ) 
       { 
          config.pszFooter = HB_PARASTRDEF( 1, TDC_FOOTER, &hText[iText++], NULL ); 
       } 
       else if (typ & HB_IT_NUMERIC ) 
       { 
          config.pszFooter = MAKEINTRESOURCE( hb_arrayGetNI( pConfig, TDC_FOOTER ) ); 
       } 
  
       // 22 PFTASKDIALOGCALLBACK pfCallback; 
       // 23 LONG_PTR lpCallbackData; 
       if ( hb_arrayGetType( pConfig, TDC_CALLBACK ) & HB_IT_EVALITEM ) 
       { 
          pCallbackData = hb_itemNew( hb_arrayGetItemPtr( pConfig, TDC_CALLBACK ) ); 
          hb_gcUnlock( pCallbackData ); 
  
          config.lpCallbackData = ( LONG_PTR ) pCallbackData; 
          config.pfCallback = TDCallbackProc;  
       } 
  
       // 24 UINT cxWidth; 
       config.cxWidth = ( hb_arrayGetType( pConfig, TDC_WIDTH ) & HB_IT_NUMERIC ) ? hb_arrayGetNI( pConfig, TDC_WIDTH ) : 0; 
  
       hResult = TaskDialogIndirect( &config, &nButton, &nRadioButton, &fVerificationFlagChecked ); 
  
       while( --iText >= 0 ) 
          hb_strfree( hText[ iText ] ); 
  
       hb_xfree( hText ); 
  
       while( --iButton >= 0 ) 
          hb_strfree( hButton[ iButton ] ); 
  
       if ( hButton ) 
          hb_xfree( hButton ); 
  
       while( --iRadioButton >= 0 ) 
          hb_strfree( hRadioButton[ iRadioButton ] ); 
  
       if ( hRadioButton ) 
          hb_xfree( hRadioButton ); 
  
       if ( hb_arrayGetType( pConfig, TDC_CALLBACK ) & HB_IT_EVALITEM ) 
       { 
          hb_itemRelease( ( PHB_ITEM ) config.lpCallbackData );  
       } 
  
       if ( hResult == S_OK )  
       { 
          if ( nButton ) 
          { 
             hb_storni( nButton, 2 );  
          } 
          else 
          { 
             hb_stor( 2 ); 
          } 
  
          if ( nRadioButton ) 
          { 
             hb_storni( nRadioButton, 3 );  
          } 
          else 
          { 
             hb_stor( 3 ); 
          } 
  
          hb_storl( fVerificationFlagChecked, 4 ); 
       } 
       else 
       { 
          hb_stor( 2 ); 
          hb_stor( 3 ); 
          hb_stor( 4 ); 
       } 
  
       hb_retnint( hResult ); 
    } 
    else 
    { 
       hb_errRT_BASE_SubstR( EG_ARG, 0, NULL, HB_ERR_FUNCNAME, HB_ERR_ARGS_BASEPARAMS ); 
    } 
 } 
  
 static HB_BOOL checkButton( const PHB_ITEM arrayOfButtons, HB_SIZE arraysize ) 
 { 
    PHB_ITEM button; 
    HB_SIZE i; 
  
    for ( i = 1; i <= arraysize; ++i ) 
    { 
       button = hb_arrayGetItemPtr( arrayOfButtons, i ); 
       if( HB_IS_ARRAY( button ) && hb_arrayLen( button ) > 1 ) 
       { 
          if ( ! ( ( ( hb_arrayGetType( button, 1 ) & HB_IT_NUMERIC ) != 0 ) &&  
             ( ( hb_arrayGetType( button, 2 ) & ( HB_IT_STRING | HB_IT_NUMERIC ) ) !=0 ) ) ) 
          { 
             return HB_FALSE; 
          } 
       } 
       else 
       { 
          return HB_FALSE; 
       } 
    }    
    return HB_TRUE; 
 } 
  
 HRESULT CALLBACK TDCallbackProc( HWND hWnd, UINT uNotification, WPARAM wParam, LPARAM lParam, LONG_PTR dwRefData ) 
 { 
    HRESULT hRes; 
    PHB_ITEM pCallback = ( PHB_ITEM ) dwRefData; 
  
    if( pCallback && hb_vmRequestReenter() ) 
    { 
       hb_vmPushEvalSym(); 
       hb_vmPush( pCallback ); 
       hb_vmPushNumInt( ( HB_MAXINT ) ( HB_PTRUINT ) hWnd ); 
       hb_vmPushNumInt( ( HB_MAXINT ) uNotification );     
       hb_vmPushNumInt( wParam ); 
       hb_vmPushNumInt( lParam ); 
       hb_vmSend( 4 ); 
  
       hRes = ( ( hb_parl( -1 ) == HB_TRUE ) ? S_OK : S_FALSE ); 
       hb_vmRequestRestore(); 
  
       return hRes; 
    } 
    return S_OK; 
 } 
  
 #pragma ENDDUMP