/** DialogControl::getTextSizeDlg()
*
* Gets the size (width and height) in dialog units for any given string.
*
* Since dialog units only have meaning for a specific dialog, normally the
* dialog units are calculated using the font of the dialog. Optionally, this
* method will calculate the dialog units using a specified font.
*
* @param text The string whose size is needed.
*
* @param fontName Optional. If specified, use this font to calculate the
* size. The default is to use the font of the owner
* dialog of the dialog control. This would be the normal
* usage.
*
* @param fontSize Optional. If specified, use this font size with
* fontName to calculate the size. The default if omitted
* is 8. This arg is ignored if fontName is omitted.
*
* @param hwndFontSrc Optional. Use this window's font to calculate the size.
* This arg is always ignored if fontName is specified.
*
* @return A .Size object representing the area (width and height,) in dialog
* units, needed for the specified string.
*
* @note This method, mapped to a dialog control object, does not really make
* sense. It, and its convoluted optional arguments, are maintained
* only for backward compatibility. Its use should be strongly
* discouraged.
*/
RexxMethod5(RexxObjectPtr, dlgctrl_getTextSizeDlg, CSTRING, text, OPTIONAL_CSTRING, fontName,
OPTIONAL_uint32_t, fontSize, OPTIONAL_POINTERSTRING, hwndFontSrc, CSELF, pCSelf)
{
HWND hwndSrc = NULL;
if ( argumentExists(2) )
{
if ( argumentOmitted(3) )
{
fontSize = DEFAULT_FONTSIZE;
}
}
else if ( argumentExists(4) )
{
hwndSrc = (HWND)hwndFontSrc;
if ( hwndFontSrc == NULL )
{
nullObjectException(context->threadContext, "window handle", 4);
return NULLOBJECT;
}
}
SIZE textSize = {0};
RXCA2T(text);
RXCA2T(fontName);
if ( getTextSize(context, textT, fontNameT, fontSize, hwndSrc, getDCownerDlg(pCSelf), &textSize) )
{
return rxNewSize(context, textSize.cx, textSize.cy);
}
return NULLOBJECT;
}
RexxMethod2(logical_t, dlgctrl_hasKeyPressConnection, OPTIONAL_CSTRING, methodName, CSELF, pCSelf)
{
if ( ComCtl32Version < COMCTL32_6_0 )
{
return FALSE;
}
pCDialogControl pcdc = (pCDialogControl)pCSelf;
SUBCLASSDATA *pData = NULL;
if ( ! GetWindowSubclass(pcdc->hCtrl, KeyPressSubclassProc, pcdc->id, (DWORD_PTR *)&pData) )
{
return FALSE;
}
if ( pData == NULL )
{
return FALSE;
}
if ( argumentOmitted(1) )
{
return TRUE;
}
char *tmpName = strdupupr(methodName);
if ( tmpName == NULL )
{
outOfMemoryException(context->threadContext);
return FALSE;
}
BOOL exists = (seekKeyPressMethod((KEYPRESSDATA *)pData->pData, tmpName) > 0);
free(tmpName);
return exists;
}
/** DialogControl::setColor()
* DialogControl::setSysColor
*/
RexxMethod4(logical_t, dlgctrl_setColor, int32_t, bkColor, OPTIONAL_int32_t, fgColor, NAME, method, CSELF, pCSelf)
{
pCDialogControl pcdc = validateDCCSelf(context, pCSelf);
if ( pcdc == NULL )
{
return 0;
}
return oodColorTable(context, dlgToCSelf(context, pcdc->oDlg), pcdc->id, bkColor,
argumentOmitted(2) ? -1 : fgColor, method[3] == 'S');
}
/** DialogControl::init()
*
* The base init() for all dialog control objects.
*
* Initializes the WindowBase and sets the 3 attributes: id, hDlg, and oDlg.
* These attributes are 'get' only attributes and can not be changed.
*/
RexxMethod2(uint32_t, dlgctrl_init, OPTIONAL_POINTER, args, OSELF, self)
{
RexxMethodContext *c = context;
uint32_t result = 1;
if ( argumentOmitted(1) || args == NULL )
{
goto done_out;
}
// Set up for the DialogControl CSelf.
RexxBufferObject cdcBuf = c->NewBuffer(sizeof(CDialogControl));
if ( cdcBuf == NULLOBJECT )
{
goto done_out;
}
// Do the WindowBase initialization.
pCWindowBase wbCSelf;
PNEWCONTROLPARAMS params = (PNEWCONTROLPARAMS)args;
if ( ! initWindowBase(context, params->hwnd, self, &wbCSelf) )
{
goto done_out;
}
if ( ! initWindowExtensions(context, self, params->hwnd, wbCSelf, NULL) )
{
goto done_out;
}
pCDialogControl cdcCSelf = (pCDialogControl)c->BufferData(cdcBuf);
memset(cdcCSelf, 0, sizeof(CDialogControl));
cdcCSelf->controlType = params->controlType;
cdcCSelf->lastItem = -1;
cdcCSelf->wndBase = wbCSelf;
cdcCSelf->rexxSelf = self;
cdcCSelf->hCtrl = params->hwnd;
cdcCSelf->id = params->id;
cdcCSelf->hDlg = params->hwndDlg;
cdcCSelf->oDlg = params->parentDlg;
cdcCSelf->isInCategoryDlg = params->isCatDlg;
context->SetObjectVariable("CSELF", cdcBuf);
context->SetObjectVariable("ID", c->UnsignedInt32(params->id));
context->SetObjectVariable("HDLG", pointer2string(context, params->hwndDlg));
context->SetObjectVariable("ODLG", params->parentDlg);
result = 0;
done_out:
return result;
}
/** playSoundFile()
*
*/
RexxRoutine3(RexxObjectPtr, play_rtn, OPTIONAL_CSTRING, fileName, OPTIONAL_CSTRING, modifier, NAME, routineName)
{
bool isStopRoutine = strcmp("STOPSOUNDFILE", routineName) == 0;
if ( (! isStopRoutine && argumentOmitted(1)) || isStopRoutine )
{
return (sndPlaySound(NULL, SND_SYNC | SND_NODEFAULT) ? TheZeroObj : TheOneObj);
}
char *fullFileName = searchSoundPath(fileName, context);
if ( fullFileName == NULL )
{
return TheOneObj;
}
uint32_t opts = SND_NODEFAULT;
if ( strcmp("PLAYSOUNDFILE", routineName) == 0 )
{
opts |= isYes(modifier) ? SND_ASYNC : SND_SYNC;
}
else if ( strcmp("PLAYSOUNDFILEINLOOP", routineName) == 0 )
{
opts |= SND_ASYNC | SND_LOOP;
}
else
{
// Must be Play()
if ( argumentExists(2) )
{
if ( stricmp("LOOP", modifier) == 0 )
{
opts |= SND_ASYNC | SND_LOOP;
}
else
{
opts |= isYes(modifier) ? SND_ASYNC : SND_SYNC;
}
}
else
{
opts |= SND_SYNC;
}
}
RexxObjectPtr result = sndPlaySound(fullFileName, opts) ? TheZeroObj : TheOneObj;
free(fullFileName);
return result;
}
/** DialogControl::new()
*
*
*/
RexxMethod3(RexxObjectPtr, dlgctrl_new_cls, OPTIONAL_RexxObjectPtr, args, OSELF, self, SUPER, superClass)
{
RexxMethodContext *c = context;
RexxObjectPtr control = TheNilObj;
if ( argumentOmitted(1) || ! c->IsPointer(args) )
{
goto done_out;
}
// Forwarding this message to the super class will also invoke the init()
// method of the control instance object.
control = c->ForwardMessage(NULLOBJECT, NULL, superClass, NULL);
if ( control == NULLOBJECT )
{
control = TheNilObj;
}
done_out:
return control;
}
/** DialogControl::tabstop()
* DialogControl::group()
*/
RexxMethod3(RexxObjectPtr, dlgctrl_tabGroup, OPTIONAL_logical_t, addStyle, NAME, method, CSELF, pCSelf)
{
oodResetSysErrCode(context->threadContext);
pCDialogControl pcdc = (pCDialogControl)pCSelf;
if ( argumentOmitted(1) )
{
addStyle = TRUE;
}
uint32_t style = GetWindowLong(pcdc->hCtrl, GWL_STYLE);
if ( *method == 'T' )
{
style = (addStyle ? (style | WS_TABSTOP) : (style & ~WS_TABSTOP));
}
else
{
style = (addStyle ? (style | WS_GROUP) : (style & ~WS_GROUP));
}
return setWindowStyle(context, pcdc->hCtrl, style);
}
/*------------------------------------------------------------------
* gethostbyaddr()
*------------------------------------------------------------------*/
RexxRoutine3(int, SockGetHostByAddr, CSTRING, addrArg, RexxObjectPtr, stemSource, OPTIONAL_int, domain)
{
struct hostent *pHostEnt;
in_addr addr;
StemManager stem(context);
if (!stem.resolveStem(stemSource))
{
return 0;
}
addr.s_addr = inet_addr(addrArg);
if (argumentOmitted(3))
{
domain = AF_INET;
}
/*---------------------------------------------------------------
* call function
*---------------------------------------------------------------*/
pHostEnt = gethostbyaddr((char*)&addr, sizeof(addr), domain);
// set the errno information
cleanup(context);
if (!pHostEnt)
{
return 0;
}
else
{
hostEntToStem(context, pHostEnt, stem);
return 1;
}
}
/*------------------------------------------------------------------
* select()
*------------------------------------------------------------------*/
RexxRoutine4(int, SockSelect, OPTIONAL_RexxObjectPtr, array1, OPTIONAL_RexxObjectPtr, array2, OPTIONAL_RexxObjectPtr, array3, OPTIONAL_int, timeout)
{
struct timeval timeOutS;
struct timeval *timeOutP;
int rCount = 0;
int wCount = 0;
int eCount = 0;
int *rArray = NULL;
int *wArray = NULL;
int *eArray = NULL;
int i;
int j;
int rc;
#if defined(OPSYS_LINUX)
fd_set rSetS, *rSet = &rSetS;
fd_set wSetS, *wSet = &wSetS;
fd_set eSetS, *eSet = &eSetS;
#else
struct fd_set rSetS, *rSet = &rSetS;
struct fd_set wSetS, *wSet = &wSetS;
struct fd_set eSetS, *eSet = &eSetS;
#endif
int max;
/*---------------------------------------------------------------
* get timeout value
*---------------------------------------------------------------*/
if (argumentOmitted(4))
{
timeOutP = NULL;
}
else
{
if (timeout < 0)
{
timeout = 0;
}
timeOutS.tv_sec = timeout;
timeOutS.tv_usec = 0;
timeOutP = &timeOutS;
}
/*---------------------------------------------------------------
* get arrays of sockets
*---------------------------------------------------------------*/
stemToIntArray(context, array1, rCount, rArray);
stemToIntArray(context, array2, wCount, wArray);
stemToIntArray(context, array3, eCount, eArray);
/*------------------------------------------------------------------
* unix-specific stuff
*------------------------------------------------------------------*/
/*---------------------------------------------------------------
* fill in fd_set's
*---------------------------------------------------------------*/
FD_ZERO(rSet);
FD_ZERO(wSet);
FD_ZERO(eSet);
for (i=0; i<rCount; i++)
{
FD_SET(rArray[i],rSet);
}
for (i=0; i<wCount; i++)
{
FD_SET(wArray[i],wSet);
}
for (i=0; i<eCount; i++)
{
FD_SET(eArray[i],eSet);
}
/*---------------------------------------------------------------
* get max number
*---------------------------------------------------------------*/
max = 0;
for (i=0; i<rCount; i++)
{
if (rArray[i] > max)
{
max = rArray[i];
}
}
for (i=0; i<wCount; i++)
{
if (wArray[i] > max)
{
max = wArray[i];
}
}
for (i=0; i<eCount; i++)
{
if (eArray[i] > max)
{
max = eArray[i];
}
}
/*---------------------------------------------------------------
* make the call
*---------------------------------------------------------------*/
rc = select(max+1,rSet,wSet,eSet,timeOutP);
// set the errno information
cleanup(context);
/*---------------------------------------------------------------
* fix up the socket arrays
*---------------------------------------------------------------*/
if (rc != 0)
{
j = 0;
for (i=0; i<rCount; i++)
{
if (FD_ISSET(rArray[i],rSet))
{
rArray[j] = rArray[i];
j++;
}
}
rCount = j;
j = 0;
for (i=0; i<wCount; i++)
{
if (FD_ISSET(wArray[i],wSet))
{
wArray[j] = wArray[i];
j++;
}
}
wCount = j;
j = 0;
for (i=0; i<eCount; i++)
{
if (FD_ISSET(eArray[i],eSet))
{
eArray[j] = eArray[i];
j++;
}
}
eCount = j;
}
/*---------------------------------------------------------------
* reset the stem variables
*---------------------------------------------------------------*/
if (rArray)
{
intArrayToStem(context, array1, rCount, rArray);
}
if (wArray)
{
intArrayToStem(context, array2, wCount, wArray);
}
if (eArray)
{
intArrayToStem(context, array3, eCount, eArray);
}
/*---------------------------------------------------------------
* free arrays
*---------------------------------------------------------------*/
if (rArray)
{
free(rArray);
}
if (wArray)
{
free(wArray);
}
if (eArray)
{
free(eArray);
}
/*---------------------------------------------------------------
* set return code
*---------------------------------------------------------------*/
return rc;
}
/** MessageDialog()
*
*
* @param text
* @param hwnd Handle of owner window. If the user specifies 0 we do not use
* an owner window. If the user omits hwnd, then we try the to
* find and use the topmost dialog.
*
*
* @note Sets the .SystemErrorCode.
*
*/
RexxRoutine6(int, messageDialog_rtn, CSTRING, text, OPTIONAL_CSTRING, hwnd, OPTIONAL_CSTRING, _title,
OPTIONAL_CSTRING, button, OPTIONAL_CSTRING, icon, OPTIONAL_CSTRING, miscStyles)
{
oodResetSysErrCode(context->threadContext);
int result = -1;
char *uprButton = NULL;
char *uprIcon = NULL;
char *uprMiscStyles = NULL;
HWND hwndOwner = (HWND)string2pointer(hwnd);
if ( hwndOwner == NULL )
{
if ( argumentOmitted(2) && TopDlg != NULL && TopDlg->onTheTop )
{
hwndOwner = TopDlg->hDlg;
}
}
CSTRING title = "ooDialog Application Message";
if ( argumentExists(3) )
{
title = _title;
}
// Defaults. These values are all 0.
uint32_t flags = MB_OK | MB_DEFBUTTON1 | MB_APPLMODAL;
uint32_t flag;
if ( argumentExists(4) )
{
uprButton = strdupupr(button);
if ( uprButton == NULL )
{
outOfMemoryException(context->threadContext);
goto done_out;
}
flag = winKeyword2ID(uprButton, context->threadContext, 4, "MessageDialog button keyword");
if ( flag == (int)-1 )
{
goto done_out;
}
flags |= flag;
}
// There is no default for the icon, if omitted there is no icon.
if ( argumentExists(5) )
{
uprIcon = strdupupr(icon);
if ( uprIcon == NULL )
{
outOfMemoryException(context->threadContext);
goto done_out;
}
flag = winKeyword2ID(uprIcon, context->threadContext, 5, "MessageDialog icon keyword");
if ( flag == (int)-1 )
{
goto done_out;
}
flags |= flag;
}
if ( argumentExists(6) )
{
uprMiscStyles = strdupupr(miscStyles);
if ( uprMiscStyles == NULL )
{
outOfMemoryException(context->threadContext);
goto done_out;
}
flag = getMiscMBStyle(uprMiscStyles, context, 6, "MessageDialog style keyword");
if ( flag == (int)-1 )
{
goto done_out;
}
flags |= flag;
}
result = MessageBox(hwndOwner, text, title, flags);
if ( result == 0 )
{
oodSetSysErrCode(context->threadContext);
}
done_out:
safeFree(uprButton);
safeFree(uprIcon);
safeFree(uprMiscStyles);
return result;
}
RexxMethod2(int32_t, dlgctrl_disconnectKeyPress, OPTIONAL_CSTRING, methodName, CSELF, pCSelf)
{
char *tmpName = NULL;
keyPressErr_t result = winAPIErr;
if ( ! requiredComCtl32Version(context, context->GetMessageName(), COMCTL32_6_0) )
{
goto done_out;
}
pCDialogControl pcdc = (pCDialogControl)pCSelf;
SUBCLASSDATA *pSubclassData = NULL;
GetWindowSubclass(pcdc->hCtrl, KeyPressSubclassProc, pcdc->id, (DWORD_PTR *)&pSubclassData);
// If pSubclassData is not null, the subclass is still installed, otherwise
// the subclass has already been removed, (or never existed.)
if ( pSubclassData != NULL )
{
// If no method name, remove the whole thing.
if ( argumentOmitted(1) )
{
result = (removeKeyPressSubclass(pSubclassData, pcdc->hDlg, pcdc->id) ? noErr : winAPIErr);
goto done_out;
}
// Have a method name, just remove that method from the mapping.
tmpName = strdupupr(methodName);
if ( tmpName == NULL )
{
result = memoryErr;
goto done_out;
}
KEYPRESSDATA *pKeyPressData = (KEYPRESSDATA *)pSubclassData->pData;
uint32_t index = seekKeyPressMethod(pKeyPressData, tmpName);
if ( index == 0 )
{
result = nameErr;
goto done_out;
}
// If only 1 method left, remove the subclass entirely. Otherwise,
// remove the subclass, fix up the subclass data block, then reinstall
// the subclass.
BOOL success = FALSE;
if ( pKeyPressData->usedMethods == 1 )
{
success = removeKeyPressSubclass(pSubclassData, pcdc->hDlg, pcdc->id);
}
else
{
if ( SendMessage(pcdc->hDlg, WM_USER_SUBCLASS_REMOVE, (WPARAM)KeyPressSubclassProc, (LPARAM)pcdc->id) )
{
removeKeyPressMethod(pKeyPressData, index);
success = (BOOL)SendMessage(pcdc->hDlg, WM_USER_SUBCLASS, (WPARAM)KeyPressSubclassProc, (LPARAM)pSubclassData);
// If not success, then the subclass procedure is no longer
// installed, (even though it was originally,) and the memory
// will never be cleaned up, so clean it up now.
if ( ! success )
{
freeKeyPressData(pSubclassData);
}
}
}
result = (success ? noErr : winAPIErr);
}
done_out:
return -(int32_t)result;
}
