From: <mie...@us...> - 2012-10-14 23:55:10
|
Revision: 8511 http://sourceforge.net/p/oorexx/code-0/8511 Author: miesfeld Date: 2012-10-14 23:55:07 +0000 (Sun, 14 Oct 2012) Log Message: ----------- #419 Add Tooltip control See ticket [Feature-requests:#419] Modified Paths: -------------- ooDialog/trunk/ooDialog/APICommon.cpp ooDialog/trunk/ooDialog/APICommon.hpp ooDialog/trunk/ooDialog/ToolTip.cls ooDialog/trunk/ooDialog/oodPackageEntry.cpp ooDialog/trunk/ooDialog/oodToolTip.cpp Modified: ooDialog/trunk/ooDialog/APICommon.cpp =================================================================== --- ooDialog/trunk/ooDialog/APICommon.cpp 2012-10-14 06:18:11 UTC (rev 8510) +++ ooDialog/trunk/ooDialog/APICommon.cpp 2012-10-14 23:55:07 UTC (rev 8511) @@ -324,6 +324,47 @@ } /** + * Argument 'argument' must be of the 'list' class; found 'actual' + * + * Argument 1 must be of the ToolInfo, PlainBaseDialog, or DialogControl class; + * found a Stem + * + * Similar to 88.914 + * Raises 88.900 + * + * @param c The thread context we are operating under. + * @param pos The 'argument' position. + * @param n The list of the classes expected. + * @param actual Some Rexx object. + * + * @return Pointer to void, could be used in the return statement of a method + * to return NULLOBJECT after the exeception is raised. + * + * @remarks If _actual is a stem object without an assigned name, then + * ObjectToStringValue() will return the empty string, which is + * confusing in the error message. Hence the work around. What would + * be better is to use the real class name for _actual, but currently + * I get Stem, rather than 'a Stem' or Array rather than 'an Array'. + * Need to figure out how to get an Array. + */ +RexxObjectPtr wrongClassListException(RexxThreadContext *c, size_t pos, const char *n, RexxObjectPtr _actual) +{ + char buffer[256]; + + CSTRING actual = c->ObjectToStringValue(_actual); + if ( strlen(actual) == 0 ) + { + actual = strPrintClassID(c, _actual); + } + + snprintf(buffer, sizeof(buffer), "Argument %d must be of the %s class; found %s", + pos, n, actual); + + userDefinedMsgException(c, buffer); + return NULLOBJECT; +} + +/** * Argument 'argument' is not a valid 'msg' * * Argument 3 is not a valid menu handle Modified: ooDialog/trunk/ooDialog/APICommon.hpp =================================================================== --- ooDialog/trunk/ooDialog/APICommon.hpp 2012-10-14 06:18:11 UTC (rev 8510) +++ ooDialog/trunk/ooDialog/APICommon.hpp 2012-10-14 23:55:07 UTC (rev 8511) @@ -89,6 +89,7 @@ extern RexxObjectPtr wrongClassException(RexxThreadContext *c, size_t pos, const char *n); extern RexxObjectPtr wrongClassException(RexxThreadContext *c, size_t pos, const char *n, RexxObjectPtr actual); +extern RexxObjectPtr wrongClassListException(RexxThreadContext *c, size_t pos, const char *n, RexxObjectPtr _actual); extern RexxObjectPtr wrongArgValueException(RexxThreadContext *c, size_t pos, const char *list, RexxObjectPtr actual); extern RexxObjectPtr wrongArgValueException(RexxThreadContext *c, size_t pos, const char *list, const char *actual); extern RexxObjectPtr wrongArgKeywordsException(RexxThreadContext *c, size_t pos, CSTRING list, CSTRING actual); Modified: ooDialog/trunk/ooDialog/ToolTip.cls =================================================================== --- ooDialog/trunk/ooDialog/ToolTip.cls 2012-10-14 06:18:11 UTC (rev 8510) +++ ooDialog/trunk/ooDialog/ToolTip.cls 2012-10-14 23:55:07 UTC (rev 8511) @@ -64,3 +64,12 @@ ::attribute flags get external "LIBRARY oodialog ti_flags" ::attribute flags set external "LIBRARY oodialog ti_setFlags" +::attribute hwndObj get external "LIBRARY oodialog ti_hwndObj" +::attribute idObj get external "LIBRARY oodialog ti_idObj" +::attribute rect get external "LIBRARY oodialog ti_rect" +::attribute rect set external "LIBRARY oodialog ti_setRect" +::attribute resource get external "LIBRARY oodialog ti_resource" +::attribute text get external "LIBRARY oodialog ti_text" +::attribute text set external "LIBRARY oodialog ti_setText" +::attribute userData get external "LIBRARY oodialog ti_userData" +::attribute userData set external "LIBRARY oodialog ti_setUserData" Modified: ooDialog/trunk/ooDialog/oodPackageEntry.cpp =================================================================== --- ooDialog/trunk/ooDialog/oodPackageEntry.cpp 2012-10-14 06:18:11 UTC (rev 8510) +++ ooDialog/trunk/ooDialog/oodPackageEntry.cpp 2012-10-14 23:55:07 UTC (rev 8511) @@ -1117,6 +1117,15 @@ REXX_METHOD_PROTOTYPE(ti_unInit); REXX_METHOD_PROTOTYPE(ti_flags); REXX_METHOD_PROTOTYPE(ti_setFlags); +REXX_METHOD_PROTOTYPE(ti_hwndObj); +REXX_METHOD_PROTOTYPE(ti_idObj); +REXX_METHOD_PROTOTYPE(ti_rect); +REXX_METHOD_PROTOTYPE(ti_setRect); +REXX_METHOD_PROTOTYPE(ti_resource); +REXX_METHOD_PROTOTYPE(ti_text); +REXX_METHOD_PROTOTYPE(ti_setText); +REXX_METHOD_PROTOTYPE(ti_userData); +REXX_METHOD_PROTOTYPE(ti_setUserData); // TreeView REXX_METHOD_PROTOTYPE(tv_delete); @@ -2072,6 +2081,15 @@ REXX_METHOD(ti_unInit, ti_unInit), REXX_METHOD(ti_flags, ti_flags), REXX_METHOD(ti_setFlags, ti_setFlags), + REXX_METHOD(ti_hwndObj, ti_hwndObj), + REXX_METHOD(ti_idObj, ti_idObj), + REXX_METHOD(ti_rect, ti_rect), + REXX_METHOD(ti_setRect, ti_setRect), + REXX_METHOD(ti_resource, ti_resource), + REXX_METHOD(ti_text, ti_text), + REXX_METHOD(ti_setText, ti_setText), + REXX_METHOD(ti_userData, ti_userData), + REXX_METHOD(ti_setUserData, ti_setUserData), // TreeView REXX_METHOD(tv_delete, tv_delete), Modified: ooDialog/trunk/ooDialog/oodToolTip.cpp =================================================================== --- ooDialog/trunk/ooDialog/oodToolTip.cpp 2012-10-14 06:18:11 UTC (rev 8510) +++ ooDialog/trunk/ooDialog/oodToolTip.cpp 2012-10-14 23:55:07 UTC (rev 8511) @@ -57,6 +57,8 @@ #define TOOLTIP_CLASS "ToolTip" +#define MAX_TOOLINFO_TEXT_LENGTH 1023 + static bool lazyInitToolTipTable(RexxMethodContext *c, pCPlainBaseDialog pcpbd) { pcpbd->ToolTipTab = (TOOLTIPTABLEENTRY *)LocalAlloc(LPTR, sizeof(TOOLTIPTABLEENTRY) * DEF_MAX_TTT_ENTRIES); @@ -380,11 +382,12 @@ * * @return True on success, false on error. * - * @notes Many methods require the indentity of the tool. A tool is id is + * @notes Many methods require the indentity of the tool. A tool id is * defined by a hwnd and a unique ID. For addTool(), the identity - * will always be the hwnd of the dialog and the unique ID is always - * the hwnd of the tool (the dialog control passed in as the tool - * arg.) + * will always be the hwnd of the owner dialog of the tool (the + * dialog control passed in as the tool arg) and the unique ID is + * always the hwnd of the tool (the dialog control passed in as the + * tool arg.) */ RexxMethod5(logical_t, tt_addTool, RexxObjectPtr, tool, OPTIONAL_CSTRING, _flags, OPTIONAL_CSTRING, text, OPTIONAL_RexxObjectPtr, userData, CSELF, pCSelf) @@ -417,9 +420,9 @@ } size_t l = strlen(text); - if ( l >= 1024 ) + if ( l > MAX_TOOLINFO_TEXT_LENGTH ) { - stringTooLongException(context->threadContext, 3, 1024, l); + stringTooLongException(context->threadContext, 3, MAX_TOOLINFO_TEXT_LENGTH, l); return false; } if ( l == 0 || StrCmpI("TEXTCALLBACK", text) == 0 ) @@ -467,8 +470,8 @@ * * */ -RexxMethod5(logical_t, tt_addToolRect, RexxObjectPtr, tool, OPTIONAL_CSTRING, flags, OPTIONAL_CSTRING, text, - OPTIONAL_RexxObjectPtr, userData, CSELF, pCSelf) +RexxMethod7(logical_t, tt_addToolRect, RexxObjectPtr, dlg, RexxObjectPtr, rxID, RexxObjectPtr, _rect, + OPTIONAL_CSTRING, _flags, OPTIONAL_CSTRING, text, OPTIONAL_RexxObjectPtr, userData, CSELF, pCSelf) { pCDialogControl pcdc = validateDCCSelf(context, pCSelf); if ( pcdc == NULL ) @@ -476,22 +479,59 @@ return FALSE; } - if ( ! requiredClass(context->threadContext, tool, "DIALOGCONTROL", 1) ) + if ( ! requiredClass(context->threadContext, dlg, "PLAINBASEDIALOG", 1) ) { return FALSE; } + pCPlainBaseDialog pcpbd = dlgToCSelf(context, dlg); - pCDialogControl pcdcTool = controlToCSelf(context, tool); + uint32_t id = oodResolveSymbolicID(context->threadContext, pcpbd->rexxSelf, rxID, -1, 1, false); + if ( id == OOD_ID_EXCEPTION ) + { + return FALSE; + } - TOOLINFO ti = {0}; + PRECT pRect = rxGetRect(context, _rect, 2); + if ( pRect == NULL ) + { + return FALSE; + } - ti.cbSize = sizeof(ti); - ti.uFlags = TTF_IDISHWND | TTF_SUBCLASS; - ti.uId = (UINT_PTR)pcdcTool->hCtrl; + uint32_t flags = TTF_SUBCLASS; + if ( argumentExists(4) ) + { + flags |= keyword2ttfFlags(_flags); + flags &= ~TTF_IDISHWND; + } + + if ( argumentOmitted(5) ) + { + text = ""; + } + + size_t l = strlen(text); + if ( l > MAX_TOOLINFO_TEXT_LENGTH ) + { + stringTooLongException(context->threadContext, 3, MAX_TOOLINFO_TEXT_LENGTH, l); + return false; + } + if ( l == 0 || StrCmpI("TEXTCALLBACK", text) == 0 ) + { + text = LPSTR_TEXTCALLBACK; + } + + TOOLINFO ti = {sizeof(ti)}; + + ti.uFlags = flags; ti.hwnd = pcdc->hDlg; + ti.uId = id; ti.lpszText = (LPSTR)text; - ti.lParam = (LPARAM)(argumentOmitted(4) ? TheNilObj : userData); + if ( argumentExists(6) ) + { + ti.lParam = (LPARAM)userData; + } + return SendMessage(pcdc->hCtrl, TTM_ADDTOOL, 0, (LPARAM)&ti); } @@ -504,63 +544,22 @@ * fails. Not sure how to have the user convey this info to this * method ?? */ -RexxMethod2(logical_t, tt_getToolInfo, RexxObjectPtr, toolID, CSELF, pCSelf) +RexxMethod2(logical_t, tt_getToolInfo, RexxObjectPtr, toolInfo, CSELF, pCSelf) { pCDialogControl pcdc = validateDCCSelf(context, pCSelf); if ( pcdc == NULL ) { return FALSE; } - RexxMethodContext *c = context; - uint32_t resourceID = 0; - pCDialogControl pcdcTool = NULL; - if ( c->IsOfType(toolID, "DIALOGCONTROL") ) + if ( ! requiredClass(context->threadContext, toolInfo, "TOOLINFO", 1) ) { - printf("Tool ID is a dialog control\n"); - pcdcTool = controlToCSelf(context, toolID); + return FALSE; } - else if ( c->IsOfType(toolID, "PLAINBASEDIALOG") ) - { - printf("Tool ID is a dialog\n"); - } - else if ( c->UnsignedInt32(toolID, &resourceID)) - { - printf("Tool ID is an id=%d\n", resourceID); - } - else - { - CSTRING str = c->ObjectToStringValue(toolID); - HWND hwnd = (HWND)string2pointer(str); - if ( IsWindow(hwnd) ) - { - printf("Tool ID is a window handle=%p\n", hwnd); - } - else - { - printf("Tool ID is NOT recognized (%s)\n", str); - } - } + LPTOOLINFO pTI = (LPTOOLINFO)context->ObjectToCSelf(toolInfo); - char buf[1024]; - TOOLINFO ti = {0}; - - ti.cbSize = sizeof(ti); - ti.uId = (UINT_PTR)pcdcTool->hCtrl; - ti.hwnd = pcdcTool->pcpbd->hDlg; - ti.lpszText = buf; - - if ( SendMessage(pcdc->hCtrl, TTM_GETTOOLINFO, 0, (LPARAM)&ti) ) - { - printf("Found tool text=%s hinst=%p lParam=%p hwnd=%p uFlags=0x%x uId=%p, rect.top=%d\n", - ti.lpszText, ti.hinst, ti.lParam, ti.hwnd, ti.uFlags, ti.uId, ti.rect.top); - } - else - { - printf("TTM_GETTOOLINFO message failed\n"); - } - return true; + return SendMessage(pcdc->hCtrl, TTM_GETTOOLINFO, 0, (LPARAM)pTI); } @@ -601,7 +600,7 @@ * * */ -RexxMethod3(uint32_t, tt_trackActivate, RexxObjectPtr, tool, OPTIONAL_logical_t, activate, CSELF, pCSelf) +RexxMethod3(uint32_t, tt_trackActivate, RexxObjectPtr, toolID, OPTIONAL_logical_t, activate, CSELF, pCSelf) { pCDialogControl pcdc = validateDCCSelf(context, pCSelf); if ( pcdc == NULL ) @@ -609,25 +608,35 @@ return FALSE; } - if ( ! requiredClass(context->threadContext, tool, "DIALOGCONTROL", 1) ) + if ( argumentOmitted(2) ) { - return FALSE; + activate = TRUE; } - pCDialogControl pcdcTool = controlToCSelf(context, tool); + if ( context->IsOfType(toolID, "TOOLINFO") ) + { + LPTOOLINFO pTI = (LPTOOLINFO)context->ObjectToCSelf(toolID); - if ( argumentOmitted(2) ) + SendMessage(pcdc->hCtrl, TTM_TRACKACTIVATE, activate, (LPARAM)pTI); + } + else if ( context->IsOfType(toolID, "DIALOGCONTROL") ) { - activate = TRUE; - } + pCDialogControl pcdcTool = controlToCSelf(context, toolID); - TOOLINFO ti = { sizeof(ti) }; + TOOLINFO ti = { sizeof(ti) }; - ti.uId = (UINT_PTR)pcdcTool->hCtrl; - ti.hwnd = pcdc->hDlg; + ti.uId = (UINT_PTR)pcdcTool->hCtrl; + ti.hwnd = pcdc->hDlg; - SendMessage(pcdc->hCtrl, TTM_TRACKACTIVATE, activate, (LPARAM)&ti); + SendMessage(pcdc->hCtrl, TTM_TRACKACTIVATE, activate, (LPARAM)&ti); + } + else + { + wrongClassListException(context->threadContext, 1, "ToolInfo or DialogControl", toolID); + return false; + } + return 0; } @@ -656,7 +665,11 @@ */ #define TOOLINFO_CLASS "ToolInfo" -#define TOOLINFO_MEMALLOCATED "TEXT_MEMORY_IS_ALLOCATED" +// The context variable names used by the ToolInfo object to keep track of +// things. +#define TOOLINFO_MEMALLOCATED_VAR "TEXT_MEMORY_IS_ALLOCATED" +#define TOOLINFO_HWND_OBJECT_VAR "HWND_SUPPLYING_OBJECT" +#define TOOLINFO_UID_OBJECT_VAR "UID_SUPPLYING_OBJECT" /** @@ -673,7 +686,8 @@ * * @return bool */ -bool genericToolID(RexxMethodContext *c, RexxObjectPtr hwndObj, RexxObjectPtr uID, LPTOOLINFO pTI) +bool genericToolID(RexxMethodContext *c, RexxObjectPtr hwndObj, RexxObjectPtr uID, LPTOOLINFO pTI, + RexxObjectPtr *hwndSupplier, RexxObjectPtr *uIDSupplier) { bool success = false; @@ -693,6 +707,12 @@ pTI->hwnd = pcpbd->hDlg; pTI->uId = id; + + if ( hwndSupplier != NULL ) + { + *hwndSupplier = hwndObj; + *uIDSupplier = uID; + } } else { @@ -704,6 +724,12 @@ pTI->hwnd = pcdc->hDlg; pTI->uId = (UINT_PTR)pcdc->hCtrl; + + if ( hwndSupplier != NULL ) + { + *hwndSupplier = pcdc->oDlg; + *uIDSupplier = hwndObj; + } } success = true; @@ -712,6 +738,50 @@ return success; } +/** + * Allocates a buffer for the tool info struct and copies the specified text + * into it. + * + * @param c + * @param pTI + * @param text + * @param argPos + * + * @return bool + */ +static bool setToolInfoText(RexxMethodContext *c, LPTOOLINFO pTI, CSTRING text, size_t argPos) +{ + size_t l = strlen(text); + if ( l > MAX_TOOLINFO_TEXT_LENGTH ) + { + stringTooLongException(c->threadContext, argPos, MAX_TOOLINFO_TEXT_LENGTH, l); + return false; + } + if ( l == 0 ) + { + nullStringMethodException(c, argPos); + return false; + } + + if ( StrCmpI("TEXTCALLBACK", text) == 0 ) + { + pTI->lpszText = LPSTR_TEXTCALLBACK; + } + else + { + pTI->lpszText = (LPSTR)LocalAlloc(LPTR, MAX_TOOLINFO_TEXT_LENGTH + 1); + if ( pTI->lpszText == NULL ) + { + outOfMemoryException(c->threadContext); + return false; + } + c->SetObjectVariable(TOOLINFO_MEMALLOCATED_VAR, TheTrueObj); + strcpy(pTI->lpszText, text); + } + return true; +} + + /** ToolInfo::fromID() [class] * * @remarks It's tempting to allocate a buffer here to receive text in the @@ -729,13 +799,21 @@ memset(pTI, 0, sizeof(TOOLINFO)); pTI->cbSize = sizeof(TOOLINFO); - if ( ! genericToolID(context, hwndObj, _uID, pTI) ) + RexxObjectPtr hwndSupplier; + RexxObjectPtr uIDSupplier; + + if ( ! genericToolID(context, hwndObj, _uID, pTI, &hwndSupplier, &uIDSupplier) ) { goto done_out; } - result = context->SendMessage2(self, "NEW", tiBuf, TheTrueObj); + RexxArrayObject args = context->NewArray(5); + context->ArrayPut(args, tiBuf, 1); + context->ArrayPut(args, uIDSupplier, 2); + context->ArrayPut(args, hwndSupplier, 5); + result = context->SendMessage(self, "NEW", args); + done_out: return result; } @@ -759,8 +837,7 @@ printf("In ti_unInit() lpszText=%p\n", pTI->lpszText != NULL ? pTI->lpszText : "null" ); #endif - RexxObjectPtr memAllocated = context->GetObjectVariable(TOOLINFO_MEMALLOCATED); - if ( memAllocated == TheTrueObj ) + if ( context->GetObjectVariable(TOOLINFO_MEMALLOCATED_VAR) == TheTrueObj ) { safeLocalFree(pTI->lpszText); } @@ -768,7 +845,6 @@ return NULLOBJECT; } - /** ToolInfo::init() * * @param dlg [required] Dialog ojbect. May be a Buffer object to create @@ -782,8 +858,12 @@ * that time, if _resource is used, text will be assumed to * be a resource identifier. For now it is ignored. * - * @remarks When creating from native code, remember to use 2nd arg, but it - * will be ignored. + * @remarks When creating from native code, set arg 1 to the TOOLINFO buffer, + * arg 2 to the object supplying the uID field of the struct, and + * arg 5 to the object supplying the hwnd field of the struct. The + * hwnd and uID supplying objects are set as context variables so + * that they can be returned from the attributes of the ToolInfo + * object. */ RexxMethod7(RexxObjectPtr, ti_init, RexxObjectPtr, dlg, OPTIONAL_RexxObjectPtr, _uID, OPTIONAL_CSTRING, _flags, OPTIONAL_CSTRING, text, OPTIONAL_RexxObjectPtr, userData, OPTIONAL_RexxObjectPtr, _rect, OPTIONAL_RexxObjectPtr, _resource) @@ -791,6 +871,8 @@ if ( context->IsBuffer(dlg) ) { context->SetObjectVariable("CSELF", dlg); + context->SetObjectVariable(TOOLINFO_HWND_OBJECT_VAR, userData); + context->SetObjectVariable(TOOLINFO_UID_OBJECT_VAR, _uID); goto done_out; } @@ -801,10 +883,15 @@ LPTOOLINFO pTI = (LPTOOLINFO)context->BufferData(obj); memset(pTI, 0, sizeof(TOOLINFO)); - if ( ! genericToolID(context, dlg, _uID, pTI) ) + RexxObjectPtr hwndSupplier; + RexxObjectPtr uIDSupplier; + + if ( ! genericToolID(context, dlg, _uID, pTI, &hwndSupplier, &uIDSupplier) ) { goto done_out; } + context->SetObjectVariable(TOOLINFO_HWND_OBJECT_VAR, hwndSupplier); + context->SetObjectVariable(TOOLINFO_UID_OBJECT_VAR, uIDSupplier); if ( argumentExists(3) ) { @@ -813,21 +900,10 @@ if ( argumentExists(4) ) { - size_t l = strlen(text); - if ( l >= 1024 ) + if ( ! setToolInfoText(context, pTI, text, 4) ) { - stringTooLongException(context->threadContext, 3, 1024, l); goto done_out; } - - if ( l == 0 || StrCmpI("TEXTCALLBACK", text) == 0 ) - { - pTI->lpszText = LPSTR_TEXTCALLBACK; - } - else - { - pTI->lpszText = (LPSTR)text; - } } if ( argumentExists(5) ) @@ -861,3 +937,116 @@ return NULLOBJECT; } +/** ToolInfo::hwndObj [attribute] + * + * Note, no setter for this attribute. + */ +RexxMethod1(RexxObjectPtr, ti_hwndObj, CSELF, pTI) +{ + RexxObjectPtr hwndObj = context->GetObjectVariable(TOOLINFO_HWND_OBJECT_VAR); + return (hwndObj ? hwndObj : TheNilObj); +} + +/** ToolInfo::idObj [attribute] + * + * Note, no setter for this attribute. + */ +RexxMethod1(RexxObjectPtr, ti_idObj, CSELF, pTI) +{ + RexxObjectPtr idObj = context->GetObjectVariable(TOOLINFO_UID_OBJECT_VAR); + return (idObj ? idObj : TheNilObj); +} + +/** ToolInfo::rect [attribute] + * + * Note that currently we are returning .nil for an empty rect. But, maybe we + * should just always return a Rect object, and let the user decide what to do + * with an empty Rect? + */ +RexxMethod1(RexxObjectPtr, ti_rect, CSELF, cSelf) +{ + LPTOOLINFO pTI = (LPTOOLINFO)cSelf; + PRECT pRect = &pTI->rect; + + if ( IsRectEmpty(pRect) ) + { + return TheNilObj; + } + else + { + return rxNewRect(context, pRect); + } +} +RexxMethod2(RexxObjectPtr, ti_setRect, RexxObjectPtr, rect, CSELF, cSelf) +{ + LPTOOLINFO pTI = (LPTOOLINFO)cSelf; + PRECT pRect = &pTI->rect; + + PRECT r = rxGetRect(context, rect, 1); + if ( r != NULL ) + { + CopyRect(&pTI->rect, r); + } + return NULLOBJECT; +} + +/** ToolInfo::resource [attribute] + * + * Note that the resource attribute is reserved at this time. If the .Resource + * class is enhanced to work with string resources (a good possibility) then + * this attribute will be used for th hinst field of the tool info struct. + * + * For now, we always return .nil and do not allow the user to set the + * attribute. + */ +RexxMethod1(RexxObjectPtr, ti_resource, CSELF, cSelf) +{ + return TheNilObj; +} + +/** ToolInfo::text [attribute] + * + * @note When getting the text attribute we need to determine if the call back + * feature is in use. + * + * When setting the text attribute, it could be that new text is + * replacing existing text. In that case, we need to determine if the + * old text was allocated, and if so, free the old text buffer. + */ +RexxMethod1(RexxObjectPtr, ti_text, CSELF, cSelf) +{ + LPTOOLINFO pTI = (LPTOOLINFO)cSelf; + + if ( pTI->lpszText == LPSTR_TEXTCALLBACK ) + { + return context->String("TextCallBack"); + } + else + { + return context->String(pTI->lpszText); + } +} +RexxMethod2(RexxObjectPtr, ti_setText, CSTRING, text, CSELF, cSelf) +{ + LPTOOLINFO pTI = (LPTOOLINFO)cSelf; + + if ( context->GetObjectVariable(TOOLINFO_MEMALLOCATED_VAR) == TheTrueObj ) + { + safeLocalFree(pTI->lpszText); + } + setToolInfoText(context, pTI, text, 1); + return NULLOBJECT; +} + +/** ToolInfo::userData [attribute] + */ +RexxMethod1(RexxObjectPtr, ti_userData, CSELF, pTI) +{ + return ( ((LPTOOLINFO)pTI)->lParam ? (RexxObjectPtr)((LPTOOLINFO)pTI)->lParam : TheNilObj ); +} +RexxMethod2(RexxObjectPtr, ti_setUserData, RexxObjectPtr, userData, CSELF, pTI) +{ + ((LPTOOLINFO)pTI)->lParam = (LPARAM)userData; + return NULLOBJECT; +} + |