908 lines
31 KiB
Plaintext
908 lines
31 KiB
Plaintext
compile function RTI_HTTP_DOWNLOAD_TEST( object, method, param1, param2, param3, param4, param5, param6 )
|
|
/*
|
|
** Copyright (C) 2012-2021 Revelation Software Inc. All Rights Reserved **
|
|
|
|
Author : Mr C
|
|
Date :
|
|
Purpose : Commuter module for the RTI_HTTP_DOWNLOAD_TEST form
|
|
|
|
Comments
|
|
========
|
|
|
|
This is a simple form used to test the RTI_HTTP_DOWNLOAD proc.
|
|
|
|
Amended Date Reason
|
|
======= ==== ======
|
|
Mr C 14 Dec 21 Removed System Compiler statements :)
|
|
*/
|
|
#pragma precomp event_precomp
|
|
|
|
declare function get_Property, set_Property, utility, retStack, rti_IDE_Cfg
|
|
declare function ps_Get_Property, rti_Res2Str, msg, exec_Method, dialog_Box
|
|
declare function rti_ErrorText
|
|
$insert rti_Http_Download_Equates
|
|
$insert msWin_GetOpenFileName_Equates
|
|
$insert ps_ChooseFile_Equates
|
|
$insert rti_IDE_PGO_TextLine_Equates
|
|
$insert rti_IDE_Open_Equates
|
|
$insert rti_Get_Proc_Info_Equates
|
|
$insert rti_IDE_Cfg_Equates
|
|
$insert rti_Resources_Equates
|
|
$insert rti_Conv_Equates
|
|
$insert rti_SSP_Equates
|
|
$insert logical
|
|
|
|
errorText = ""
|
|
abort = FALSE$
|
|
retVal = ""
|
|
|
|
// Conversion processing - we're overloading the commuter module here to
|
|
// keep control-specific conversion code in the same proc.
|
|
locate object in "ICONV" using "," setting pos then
|
|
on pos goSub onIconv
|
|
return retVal
|
|
end
|
|
|
|
if assigned( object ) else object = ""
|
|
if assigned( method ) else method = ""
|
|
if assigned( param1 ) else param1 = ""
|
|
if assigned( param2 ) else param2 = ""
|
|
if assigned( param3 ) else param3 = ""
|
|
if assigned( param4 ) else param4 = ""
|
|
if assigned( param5 ) else param5 = ""
|
|
if assigned( param6 ) else param6 = ""
|
|
|
|
atCtrl = field( object, ".", 2, 99 )
|
|
|
|
if bLen( method ) then
|
|
locate method in "CHANGED,CHAR,CLICK,ENDDIALOG,GOTFOCUS,OMNIEVENT,OPTIONS,PROPCHANGED,PROPOPTIONS" using "," setting pos then
|
|
on pos goSub onChanged,onChar,onClick,onEndDialog,onGotFocus,onOmniEvent,onOptions,onPropChanged,onPropOptions
|
|
end else
|
|
* // ERR002: Invalid method "%1% passed to the %2% procedure
|
|
errorText = rti_Res2Str( RESID$, "ERR002", method : @fm : retStack()<1> )
|
|
abort = TRUE$
|
|
end
|
|
end else
|
|
* // ERR001: No method passed to the %1% procedure
|
|
errorText = rti_Res2Str( RESID$, "ERR001", retStack()<1> )
|
|
abort = TRUE$
|
|
end
|
|
|
|
if abort then
|
|
if bLen( errorText ) then
|
|
goSub errorMsg
|
|
if ( method = "CREATE" ) then
|
|
call send_Event( @window, "CLOSE" )
|
|
end
|
|
|
|
end
|
|
end
|
|
|
|
return retVal
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onChanged subroutine
|
|
//
|
|
// Main CHANGED event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] param1 : NewData - this is the text that has changed.
|
|
// [i] atCtrl : ID of the object triggering the CHANGED event - this is
|
|
// : NOT fully qualified.
|
|
// ----------------------------------------------------------------------------
|
|
onChanged:
|
|
|
|
newData = param1
|
|
|
|
begin case
|
|
case ( atCtrl == "EDL_URL" )
|
|
goSub edlURL_OnChanged
|
|
|
|
case ( atCtrl == "CBO_METHOD" )
|
|
goSub cboMethod_OnChanged
|
|
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onChar subroutine
|
|
//
|
|
// Main CHAR event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i ] atCtrl : Non-qualified (i.e. sans window ID) control ID that triggered
|
|
// : the CHAR event
|
|
// [i] param1 : virtCode
|
|
// [i] param2 : scanCode
|
|
// [i] param3 : ctrlKey
|
|
// [i] param4 : shiftKey
|
|
// [i] param5 : altKey
|
|
// ----------------------------------------------------------------------------
|
|
onChar:
|
|
|
|
virtCode = param1
|
|
scanCode = param2
|
|
ctrlkey = param3
|
|
shiftkey = param4
|
|
altkey = param5
|
|
|
|
begin case
|
|
case ( atCtrl == "CBO_METHOD" )
|
|
goSub cboMethod_OnChar
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onClick subroutine
|
|
//
|
|
// Main CLICK event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] atCtrl : ID of the object triggering the CLICK event - this is
|
|
// : NOT fully qualified.
|
|
// ----------------------------------------------------------------------------
|
|
onClick:
|
|
|
|
begin case
|
|
case ( atCtrl == "BTN_TEST" )
|
|
goSub btnTest_OnClick
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onEndDialog
|
|
//
|
|
// ENDDIALOG dispatch handler. This assumes that the asyncID contains the
|
|
// value used for the dispatch process.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] param1 : dialogID - name of the dialog that triggered the event
|
|
// [i] param2 : dialogValue - data returned from the End_Dialog call
|
|
// [i] param3 : asyncID - "cookie" value passed to the dialog when created
|
|
// ----------------------------------------------------------------------------
|
|
onEndDialog:
|
|
|
|
dialogID = param1
|
|
dialogValue = param2
|
|
asyncID = param3
|
|
|
|
begin case
|
|
case ( asyncID<HDL_RSPINFO_POS_ID$> == .pgd_UIParams->valueByName( "EndDialog AsyncID" ) )
|
|
goSub onEndDialog_httpDownloadCallback
|
|
|
|
end case
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onEndDialog_httpDownloadCallback subroutine
|
|
//
|
|
// ENDDIALOG event handler for the RTI_HTTP_DOWNLOAD callback event.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] dialogID : name of the dialog that triggered the event
|
|
// [i] dialogValue : Response content (if not file based)
|
|
// [i] asyncID : Response header info
|
|
// ----------------------------------------------------------------------------
|
|
onEndDialog_httpDownloadCallback:
|
|
|
|
objxArray = @window : ".EDL_RESPONSE_ID"
|
|
propArray = "TEXT"
|
|
dataArray = asyncID<HDL_RSPINFO_POS_ID$>
|
|
|
|
objxArray := @rm : @window : ".EDL_RESPONSE_STATUS_CODE"
|
|
propArray := @rm : "TEXT"
|
|
dataArray := @rm : asyncID<HDL_RSPINFO_POS_STATUSCODE$>
|
|
|
|
objxArray := @rm : @window : ".EDL_RESPONSE_STATUS_TEXT"
|
|
propArray := @rm : "TEXT"
|
|
dataArray := @rm : asyncID<HDL_RSPINFO_POS_STATUSTEXT$>
|
|
|
|
objxArray := @rm : @window : ".EDL_RESPONSE_CONTENTLEN"
|
|
propArray := @rm : "TEXT"
|
|
dataArray := @rm : asyncID<HDL_RSPINFO_POS_CONTENTLEN$>
|
|
|
|
tmp = asyncID<HDL_RSPINFO_POS_HEADERS$>; swap @vm with \0D0A\ in tmp
|
|
|
|
objxArray := @rm : @window : ".EDB_RESPONSE_HEADERS"
|
|
propArray := @rm : "TEXT"
|
|
dataArray := @rm : tmp
|
|
|
|
tmp = asyncID<HDL_RSPINFO_POS_BYTESRECEIVED$>
|
|
fileName = .edl_ResponseFile->text
|
|
if bLen( fileName ) then
|
|
// The response was downloaded into a file so just highlight this
|
|
tmp := " (in " : fileName[-1,"B\"] : ")"
|
|
end
|
|
|
|
objxArray := @rm : @window : ".EDL_BYTES_RECEIVED"
|
|
propArray := @rm : "TEXT"
|
|
dataArray := @rm : tmp
|
|
|
|
call set_Property_Only( objxArray, propArray, dataArray )
|
|
|
|
call set_Property( @window : ".EBD_RESPONSE_CONTENT", "TEXT", dialogValue )
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onGotFocus subroutine
|
|
//
|
|
// Main GOTFOCUS event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] atCtrl : ID of the object triggering the CLICK event - this is
|
|
// : NOT fully qualified.
|
|
// [i] param1 : prevFocusID - ID of the last control on the window that
|
|
// : had an event handler defined for the GOTFOCUS event.
|
|
// ----------------------------------------------------------------------------
|
|
onGotFocus:
|
|
|
|
prevFocusID = param1
|
|
|
|
begin case
|
|
case atCtrl == "CBO_METHOD"
|
|
goSub cboMethod_OnGotFocus
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onIConv subroutine
|
|
//
|
|
// ICONV dispatch handler. Handles Iconv() processing for the following
|
|
// branches:
|
|
//
|
|
// CALLBACKPROC
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] object : The literal string "ICONV"
|
|
// [i] method : "oValue" - The data to be validated
|
|
// [i] param1 : "branch" - the requested Iconv handler
|
|
// [o] param2 : "iValue" - The validated data
|
|
// ----------------------------------------------------------------------------
|
|
// Errors are returned via status() as per normal Iconv processing
|
|
// ----------------------------------------------------------------------------
|
|
onIconv:
|
|
|
|
oValue = method
|
|
branch = param1
|
|
iValue = param2
|
|
|
|
iValue = ""
|
|
status() = CONV_VALID$
|
|
|
|
locate branch in "CALLBACKPROC" using "," setting pos then
|
|
on pos goSub onIconv_CallBackProc
|
|
end else
|
|
status() = CONV_INVALID_CONV$
|
|
end
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onIconv_CallBackProc subroutine
|
|
//
|
|
// Verifies that a passed proc supports at least 2 args
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] oValue : The stored procedure name
|
|
// [o] iValue : The stored procedure name
|
|
// ----------------------------------------------------------------------------
|
|
// Errors are returned via status() as per normal Iconv processing
|
|
// ----------------------------------------------------------------------------
|
|
onIconv_CallBackProc:
|
|
|
|
call set_Status( SETSTAT_OK$ )
|
|
procInfo = rti_Get_Proc_Info( oValue )
|
|
if get_Status( errorText ) then
|
|
goSub setSPError;
|
|
end else
|
|
if ( procInfo<GPI_ARGCOUNT$> < 2 ) then
|
|
errorText = "The Callback Procedure Name must support at least 2 parameters"
|
|
abort = TRUE$
|
|
end
|
|
end
|
|
|
|
if abort then
|
|
// We're about to display a validation error which will end
|
|
// up moving the focus - the problem is there may also be
|
|
// a SELPROPCHANGED event waiting, which we don't want to run
|
|
// so we'll kill all pending events first
|
|
call exec_Method( "SYSTEM", "FLUSH" )
|
|
|
|
goSub errorMsg
|
|
|
|
abort = FALSE$
|
|
status() = CONV_INVALID_NOMSG$
|
|
|
|
end
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onOmniEvent subroutine
|
|
//
|
|
// Main OMNIEVENT event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] param1 : message
|
|
// [i] param2 : Param 1
|
|
// [i] param3 : Param 2
|
|
// [i] param4 : Param 3
|
|
// [i] param5 : Param 4
|
|
// [i] param6 : Param 5
|
|
// [i] param7 : Param 6
|
|
// ----------------------------------------------------------------------------
|
|
onOmniEvent:
|
|
|
|
transfer param1 to message
|
|
transfer param2 to param1
|
|
transfer param3 to param2
|
|
transfer param4 to param3
|
|
transfer param5 to param4
|
|
transfer param6 to param5
|
|
transfer param7 to param6
|
|
|
|
begin case
|
|
case ( atCtrl == "PGD_UIPARAMS" )
|
|
goSub pgdUIParams_OnOmniEvent
|
|
end case
|
|
|
|
transfer param6 to param7
|
|
transfer param5 to param6
|
|
transfer param4 to param5
|
|
transfer param3 to param4
|
|
transfer param2 to param3
|
|
transfer param1 to param2
|
|
transfer message to param1
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onOptions subroutine
|
|
//
|
|
// Main OPTIONS event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] atCtrl : ID of the object triggering the PROPCHANGED event
|
|
// : this is not fully qualified.
|
|
// ----------------------------------------------------------------------------
|
|
onOptions:
|
|
|
|
begin case
|
|
case ( atCtrl == "EDL_RESPONSEFILE" )
|
|
goSub edlResponseFile_OnOptions
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onPropChanged subroutine
|
|
//
|
|
// Main PROPCHANGED event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] atCtrl : ID of the object triggering the PROPCHANGED event
|
|
// : this is not fully qualified.
|
|
// [i] param1 : propName - Name of the property that has changed
|
|
// [i] param2 : propValue - Value of the property that has changed
|
|
// [i] param3 : contextFlags - Context the change was raised from
|
|
// ----------------------------------------------------------------------------
|
|
onPropChanged:
|
|
|
|
propName = param1
|
|
propValue = param2
|
|
contextFlags = param3
|
|
|
|
begin case
|
|
case ( atCtrl == "PGD_UIPARAMS" )
|
|
goSub pgdUIParams_OnPropChanged
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// onPropOptions subroutine
|
|
//
|
|
// Main PROPOPTIONS event dispatch handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] atCtrl : ID of the object triggering the PROPOPTIONS event - this
|
|
// : is not fully qualified.
|
|
// [i] param1 : PropertyName - name of the property to display the options
|
|
// : for
|
|
// [i] param2 : Current Property Value
|
|
// ----------------------------------------------------------------------------
|
|
onPropOptions:
|
|
|
|
propName = param1
|
|
propValue = param2
|
|
|
|
begin case
|
|
case ( atCtrl == "PGD_UIPARAMS" )
|
|
goSub pgdUIParams_OnPropOptions
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#region CBO_METHOD
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// cboMethod_OnChanged subroutine
|
|
//
|
|
// CHANGED event handler for the CBO_METHOD control - update the enabled state
|
|
// of BTN_TEST
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
cboMethod_OnChanged:
|
|
goSub checkBtnTestEnabledState
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// cboMethod_OnChar subroutine
|
|
//
|
|
// CHAR event handler for the CBO_METHOD control - update the enabled state
|
|
// of BTN_TEST
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] virtCode
|
|
// [i] scanCode
|
|
// [i] ctrlKey
|
|
// [i] shiftKey
|
|
// [i] altKey
|
|
// ----------------------------------------------------------------------------
|
|
cboMethod_OnChar:
|
|
goSub checkBtnTestEnabledState
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// cboMethod_OnGotFocus subroutine
|
|
//
|
|
// GOTFOCUS event handler for the CBO_METHOD control - Using the "default"
|
|
// handler to load the verb doesn't trigger the CHANGED event so we do it
|
|
// manually here.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] prevFocusID : ID of the last control on the window that
|
|
// : had an event handler defined for the GOTFOCUS event.
|
|
// ----------------------------------------------------------------------------
|
|
cboMethod_OnGotFocus:
|
|
goSub checkBtnTestEnabledState
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#endregion
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#region BTN_TEST
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// btnTest_OnClick subroutine
|
|
//
|
|
// CLICK event handler for the BTN_TEST button: Extracts the list of arguments
|
|
// from the form and calls RTI_HTTP_DOWNLOAD to run the test.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
btnTest_OnClick:
|
|
|
|
useED = .pgd_UIParams->valueByName( "Use EndDialog event" )
|
|
asyncID = ""
|
|
callBackProc = ""
|
|
callBackID = ""
|
|
|
|
if useED then
|
|
asyncID = trim( .pgd_UIParams->valueByName( "EndDialog AsyncID" ) )
|
|
end else
|
|
callbackProc = trim( .pgd_UIParams->valueByName( "Procedure Name" ) )
|
|
callBackID = trim( .pgd_UIParams->valueByName( "Callback ID" ) )
|
|
end
|
|
|
|
objxArray = @window : ".EDL_URL"
|
|
propArray = "TEXT"
|
|
|
|
objxArray := @rm : @window : ".CBO_METHOD"
|
|
propArray := @rm : "TEXT"
|
|
|
|
objxArray := @rm : @window : ".EDL_TIMEOUT"
|
|
propArray := @rm : "TEXT"
|
|
|
|
objxArray := @rm : @window : ".EDL_PAYLOAD"
|
|
propArray := @rm : "TEXT"
|
|
|
|
objxArray := @rm : @window : ".EDL_USERNAME"
|
|
propArray := @rm : "TEXT"
|
|
|
|
objxArray := @rm : @window : ".EDL_PASSWORD"
|
|
propArray := @rm : "TEXT"
|
|
|
|
objxArray := @rm : @window : ".EDT_REQUESTHEADERS"
|
|
propArray := @rm : "ARRAY"
|
|
|
|
objxArray := @rm : @window : ".EDL_RESPONSEFILE"
|
|
propArray := @rm : "TEXT"
|
|
|
|
dataArray = get_Property( objxArray, propArray )
|
|
|
|
url = dataArray[1,@rm,TRUE$]
|
|
method = dataArray[bCol2()+1,@rm,TRUE$]
|
|
timeoutInfo = dataArray[bCol2()+1,@rm,TRUE$]
|
|
payload = dataArray[bCol2()+1,@rm,TRUE$]
|
|
userName = trim( dataArray[bCol2()+1,@rm,TRUE$] )
|
|
password = dataArray[bCol2()+1,@rm,TRUE$]
|
|
headers = dataArray[bCol2()+1,@rm,TRUE$]
|
|
responseFile = dataArray[bCol2()+1,@rm,TRUE$]
|
|
|
|
uiParams = ""
|
|
|
|
if ( .pgd_UIParams->valueByName( "Use Parent Window" ) ) then
|
|
uiParams<HDL_UIPARAM_POS_PARENTWIN$> = @window
|
|
end
|
|
uiParams<HDL_UIPARAM_POS_MODAL$> = .pgd_UIParams->valueByName( "Modal" )
|
|
uiParams<HDL_UIPARAM_POS_ENDDIALOGASYNCID$> = asyncID
|
|
uiParams<HDL_UIPARAM_POS_CALLBACKPROC$> = callbackProc
|
|
uiParams<HDL_UIPARAM_POS_CALLBACKID$> = callBackID
|
|
uiParams<HDL_UIPARAM_POS_DOWNLOADTEXT$> = .pgd_UIParams->valueByName( "Loading Text" )
|
|
uiParams<HDL_UIPARAM_POS_SYNCPROGRESS$> = .pgd_UIParams->valueByName( "Sync Taskbar" )
|
|
|
|
if bLen( userName ) then
|
|
credentials = userName : @fm : password
|
|
end else
|
|
credentials = ""
|
|
end
|
|
|
|
tmp = headers
|
|
convert " ":@fm:@vm to "" in tmp
|
|
if bLen( tmp ) else
|
|
headers = ""
|
|
end
|
|
|
|
call set_Status( SETSTAT_OK$ )
|
|
call rti_HTTP_Download( uiParams, url, method, payload, credentials, |
|
|
headers, timeoutInfo, responseFile )
|
|
if get_Status( errorText ) then
|
|
goSub setSPError
|
|
end
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#endregion
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#region EDL_RESPONSEFILE
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// edlResponseFile_OnOptions subroutine
|
|
//
|
|
// OPTIONS event handler for the EDL_RESPONSEFILE button - displays the
|
|
// standard File Open dialog for the user to choose a file to write the
|
|
// content to.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
edlResponseFile_OnOptions:
|
|
|
|
cfFlags = bitOr( OFN_HIDEREADONLY$, OFN_NOCHANGEDIR$ )
|
|
|
|
fileName = @object->text
|
|
|
|
if index( fileName, "\", 1 ) then
|
|
defName = fileName[-1,"B\"]
|
|
filePath = fileName[1,col1()-1]
|
|
if index( defName, ".", 1 ) else
|
|
if ( $fileSystem->dirExists( fileName ) ) then
|
|
defName = "ResponseContent.txt"
|
|
filePath = fileName
|
|
end
|
|
end
|
|
end else
|
|
filePath = drive()
|
|
defName = fileName
|
|
end
|
|
|
|
cfOptions = ""
|
|
cfOptions<CHFILE_POS_MODE$> = CHFILE_MODE_SAVEAS$
|
|
cfOptions<CHFILE_POS_FILTERSTRING$> = "All Files (*.*)/*.*/"
|
|
cfOptions<CHFILE_POS_FILTERINDEX$> = 1
|
|
cfOptions<CHFILE_POS_DFLTNAME$> = defName
|
|
cfOptions<CHFILE_POS_FLAGS$> = cfFlags
|
|
cfOptions<CHFILE_POS_INITDIR$> = filePath
|
|
cfOptions<CHFILE_POS_TITLE$> = "Specify Response File"
|
|
|
|
fileName = $fileSystem->chooseFile( @window, cfOptions )
|
|
if bLen( fileName ) then
|
|
@object->text = fileName
|
|
end
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#endregion
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#region EDL_URL
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// edlURL_OnChanged subroutine
|
|
//
|
|
// CHANGED event handler for the EDL_URL control - update the enabled state
|
|
// of BTN_TEST
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
edlURL_OnChanged:
|
|
goSub checkBtnTestEnabledState
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#endregion
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#region PDG_UIPARAMS
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_OnOmniEvent subroutine
|
|
//
|
|
// PGD_UIPARAMS OMNIEVENT handler
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] message : Identifies the OMNIEVENT message
|
|
// [i] param1 : Polymorphic message parameters
|
|
// ... ... : ...
|
|
// [i] param8 : Polymorphic message parameters
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_OnOmniEvent:
|
|
|
|
begin case
|
|
case ( message == "PGO_ENDDIALOG" )
|
|
goSub pgdUIParams_OnOmniEvent_PGO_EndDialog
|
|
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_OnOmniEvent_PGO_EndDialog subroutine
|
|
//
|
|
// OMNIEVENT PGO_ENDDIALOG handler - updates the property grid with the results
|
|
// of a PGO non-modal dialog
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] param1 : Property name
|
|
// [1] param2 : New property value
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_OnOmniEvent_PGO_EndDialog:
|
|
|
|
@object->valueByName( param1, param2 )
|
|
goSub checkBtnTestEnabledState
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_onPropChanged subroutine
|
|
//
|
|
// PROPCHANGED event handler for the PGD_UIPARAMS property grid.
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] propName - Name of the property that has changed
|
|
// [i] propValue - Value of the property that has changed
|
|
// [i] contextFlags - Context the change was raised from
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_onPropChanged:
|
|
|
|
begin case
|
|
case ( propName == "Use EndDialog event" )
|
|
// If this is enabled then:
|
|
//
|
|
// EndDialog AsyncID should be enabled
|
|
// Procedure Name CallBack ID should be disabled
|
|
//
|
|
// else
|
|
// EndDialog AsyncID should be disabled
|
|
// Procedure Name CallBack ID should be enabled
|
|
|
|
@object{"EndDialog AsyncID"}->enabled = propValue
|
|
@object{"Procedure Name"}->enabled = not( propValue )
|
|
@object{"CallBack ID"}->enabled = not( propValue )
|
|
|
|
end case
|
|
|
|
goSub checkBtnTestEnabledState
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_OnPropOptions subroutine
|
|
//
|
|
// PROPOPTIONS event handler for the PDG_UIPARAMS property grid control
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] propName : Name of the property to display the options
|
|
// [i] propValue : Current Property Value
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_OnPropOptions:
|
|
|
|
begin case
|
|
case propName == "EndDialog AsyncID"
|
|
// Display the RTI_IDE_PGO_TEXTLINE dialog
|
|
goSub pgdUIParams_OnPropOptions_Display_TextLine_Dlg
|
|
case propName == "Procedure Name"
|
|
// Display the RTI_IDE_OPEN dialog with STPROCEXES loaded
|
|
goSub pgdUIParams_OnPropOptions_Display_EntOpen_Dlg
|
|
case propName == "Callback ID"
|
|
// Display the RTI_IDE_PGO_TEXTLINE dialog
|
|
goSub pgdUIParams_OnPropOptions_Display_TextLine_Dlg
|
|
case propName == "Loading Text"
|
|
// Display the RTI_IDE_PGO_TEXTLINE dialog
|
|
goSub pgdUIParams_OnPropOptions_Display_TextLine_Dlg
|
|
end case
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_OnPropOptions_Display_TextLine_Dlg subroutine
|
|
//
|
|
// Display the RTI_IDE_PGO_TEXTLINE dialog to allow the user to enter a larger
|
|
// display a larger amount of text.
|
|
// ----------------------------------------------------------------------------
|
|
// [i] propName : Name of the property to display the options
|
|
// [i] propValue : Current Property Value
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_OnPropOptions_Display_TextLine_Dlg:
|
|
|
|
dlgParam = ""
|
|
dlgParam<PGOTEXTLINE_CREATEPARAM_PROPGRID$> = object
|
|
dlgParam<PGOTEXTLINE_CREATEPARAM_PROPNAME$> = propName
|
|
dlgParam<PGOTEXTLINE_CREATEPARAM_TEXT$> = propValue
|
|
dlgParam<PGOTEXTLINE_CREATEPARAM_CACHEID$> = "RTI_HTTP_DOWNLOAD_TEST"
|
|
|
|
call start_Window( "RTI_IDE_PGO_TEXTLINE", @window, dlgParam )
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// pgdUIParams_OnPropOptions_Display_EntOpen_Dlg subroutine
|
|
//
|
|
// Display the RTI_IDE_OPEN dialog to allow the user to select an STPROCEXE
|
|
// ----------------------------------------------------------------------------
|
|
// [i] propName : Name of the property to display the options
|
|
// [i] propValue : Current Property Value
|
|
// ----------------------------------------------------------------------------
|
|
pgdUIParams_OnPropOptions_Display_EntOpen_Dlg:
|
|
|
|
dlgID = rti_IDE_CFG( "GETDIALOG", IDE_CFG_GETDLG_T_OPENENT$ )
|
|
|
|
itemSize = @object->screenSizeByName( propName )
|
|
|
|
xPos = itemSize<1> + itemSize<3>
|
|
yPos = itemSize<2> + itemSize<4>
|
|
|
|
dlgParam = ""
|
|
dlgParam<IDE_OPN_CREATEPARAM_TYPEID$> = "STPROCEXE"
|
|
dlgParam<IDE_OPN_CREATEPARAM_ENTITYID$> = propValue
|
|
dlgParam<IDE_OPN_CREATEPARAM_MODE$> = FALSE$
|
|
dlgParam<IDE_OPN_CREATEPARAM_XPOS$> = xPos : @vm : TRUE$ : @vm : TRUE$
|
|
dlgParam<IDE_OPN_CREATEPARAM_YPOS$> = yPos : @vm : FALSE$ : @vm : TRUE$
|
|
dlgParam<IDE_OPN_CREATEPARAM_NONSEL$> = TRUE$
|
|
dlgParam<IDE_OPN_CREATEPARAM_TITLE$> = propName
|
|
|
|
propValue = dialog_Box( dlgID, @window, dlgParam )
|
|
if bLen( propValue ) then
|
|
// Verify that it can take at least 2 args for the callback from the
|
|
// download form
|
|
|
|
propValue = field( propValue, "*", 4, 9999 )
|
|
|
|
call set_Status( SETSTAT_OK$ )
|
|
procInfo = rti_Get_Proc_Info( propValue )
|
|
if get_Status( errorText ) then
|
|
goSub setSPError
|
|
return
|
|
end
|
|
|
|
if ( procInfo<GPI_ARGCOUNT$> < 2 ) then
|
|
errorText = "The Callback Procedure Name must support at least 2 parameters"
|
|
abort = TRUE$
|
|
return
|
|
end
|
|
|
|
@object->valueByName( propName, propValue )
|
|
goSub checkBtnTestEnabledState
|
|
|
|
end
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
#endregion
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// checkBtnTestEnabledState subroutine
|
|
//
|
|
// This subroutine scans the Request parameters and enables the BTN_TEST
|
|
// button if there is enough information to conduct a RTI_HTTP_DOWNLOAD test.
|
|
//
|
|
// We have to meet the following criteria:
|
|
//
|
|
// 1) We have a URL
|
|
// 2) We have a method (verb)
|
|
// 3) We have one of the following:
|
|
// i) An End Dialog AsyncID, or
|
|
// ii) A CallbackProcID
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
checkBtnTestEnabledState:
|
|
|
|
enableTest = TRUE$
|
|
useED = .pgd_UIParams->valueByName( "Use EndDialog event" )
|
|
if useED then
|
|
asyncID = trim( .pgd_UIParams->valueByName( "EndDialog AsyncID" ) )
|
|
if bLen( asyncID ) else
|
|
enableTest = FALSE$
|
|
end
|
|
end else
|
|
callbackProc = trim( .pgd_UIParams->valueByName( "Procedure Name" ) )
|
|
if bLen( callbackProc ) else
|
|
enableTest = FALSE$
|
|
end
|
|
end
|
|
|
|
if enableTest then
|
|
if bLen( trim( .edl_URL->text ) ) then
|
|
if bLen( trim( .cbo_Method->text ) ) else
|
|
enableTest = FALSE$
|
|
end
|
|
end else
|
|
enableTest = FALSE$
|
|
end
|
|
end
|
|
|
|
.btn_Test->enabled = enableTest
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// errorMsg subroutine
|
|
//
|
|
// Displays a simple error message
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i] errorText : Text to display in the message
|
|
// [i] errorCaption : Caption for the message
|
|
// ----------------------------------------------------------------------------
|
|
errorMsg:
|
|
|
|
if assigned( errorCaption ) else errorCaption = ""
|
|
if bLen( errorCaption ) else
|
|
errorCaption = @@window->text
|
|
end
|
|
|
|
msgArray = errorText
|
|
msgArray<4> = "!"
|
|
msgArray<6> = -2
|
|
msgArray<7> = -2
|
|
msgArray<8> = "C"
|
|
msgArray<12> = errorCaption
|
|
|
|
call msg( @window, msgArray )
|
|
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
// setSPError subroutine
|
|
//
|
|
// Translates an SSP status error array into a "text version" from REVERROR.DAT
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
// [i,o] errorText : SSP status error to convert. Returns the "text" version
|
|
// ----------------------------------------------------------------------------
|
|
setSPError:
|
|
errorText = rti_ErrorText( "SP", errorText )
|
|
abort = TRUE$
|
|
return
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|