void GUIScrollArea::horzScrollUpdate(float scrollPos)
{
UINT32 scrollableWidth = (UINT32)std::max(0, INT32(mContentSize.x) - INT32(mVisibleSize.x));
mHorzOffset = scrollableWidth * Math::clamp01(scrollPos);
_markLayoutAsDirty();
}
void CPlayer::SetBotPlayerData(const MoGui::MoGuiXY::DBServerXY::DBS_BotPlayerData& bpd)
{
m_AID = bpd.m_AID;
m_PID = bpd.m_PID;
m_Sex = bpd.m_Sex;
m_NickName = bpd.m_NickName;
m_HeadPicURL = bpd.m_HeadPicURL;
m_HomePageURL = bpd.m_HomePageURL;
m_City = bpd.m_City;
m_nGameMoney = bpd.m_nGameMoney;
m_nJF = bpd.m_nJF;
m_nEP = bpd.m_nEP;
m_nWinTimes = INT32(bpd.m_nWinTimes);
m_nLossTimes = INT32(bpd.m_nLossTimes);
m_nGameTime = INT32(bpd.m_nGameTime);
m_MaxPai = bpd.m_MaxPai;
m_MaxPaiTime = bpd.m_MaxPaiTime;
m_MaxMoney = bpd.m_MaxMoney;
m_MaxMoneyTime = bpd.m_MaxMoneyTime;
m_MaxWin = bpd.m_MaxWin;
m_MaxWinTime = bpd.m_MaxWinTime;
m_JoinTime = bpd.m_JoinTime;
m_LandTime = UINT32(time(NULL));
m_InvitePID = bpd.m_InvitePID;
ClearMoneyLog();
AddMoneyLog(bpd.m_nGameMoney,"SetBotPlayerData");
}
static void em_1000geodpos(struct gps_state *gps)
{
double speed;
int bearing, solinv;
solinv = INT16(&packet[WD(10)]) & 0x5;
if (solinv) gps->fix &= ~0x3; /* do we know whether it is a 2D or 3D fix? */
else gps->fix |= 0x3;
gps->lat = INT32(&packet[WD(27)]) * 1.0e-8;
gps->lon = INT32(&packet[WD(29)]) * 1.0e-8;
gps->alt = INT32(&packet[WD(31)]) * 1.0e-2;
speed = ((unsigned int)INT32(&packet[WD(34)])) * 1.0e-2;
bearing = radtodeg(INT16(&packet[WD(36)]) * 1.0e-3);
if (bearing < 0) bearing += 2 * M_PI;
gps->bearing = radtodeg(bearing);
gps->spd_up = 0.0;
gps->spd_east = sin(bearing) * speed;
gps->spd_north = cos(bearing) * speed;
gps->time = conv_date(INT16(&packet[WD(21)]),
INT16(&packet[WD(20)]), INT16(&packet[WD(19)])) +
INT16(&packet[WD(24)])+(60*INT16(&packet[WD(23)])) +
(3600*INT16(&packet[WD(22)]));
gps->updated |= GPS_STATE_FIX | GPS_STATE_COORD | GPS_STATE_BEARING | GPS_STATE_SPEED;
}
void GUIScrollArea::vertScrollUpdate(float scrollPos)
{
UINT32 scrollableHeight = (UINT32)std::max(0, INT32(mContentSize.y) - INT32(mVisibleSize.y));
mVertOffset = scrollableHeight * Math::clamp01(scrollPos);
_markLayoutAsDirty();
}
BOOL FASTCALL WM32SBMGetRange (LPWM32MSGPARAMEX lpwm32mpex)
{
//
// Changed semantics for this message to support 32-bit
// scroll bar ranges (vs. 16-bit).
//
// Win16:
// posMin = LOWORD(SendMessage(hwnd, SBM_GETRANGE, 0, 0));
// posMax = HIWORD(SendMessage(hwnd, SBM_GETRANGE, 0, 0));
//
// Win32:
// SendMessage(hwnd, SBM_GETRANGE,
// (WPARAM) &posMin, (LPARAM) &posMax);
//
if (lpwm32mpex->fThunk) {
lpwm32mpex->Parm16.WndProc.wMsg = OLDSBM_GETRANGE;
} else {
*(DWORD *)lpwm32mpex->uParam = INT32(LOWORD(lpwm32mpex->lReturn));
*(DWORD *)lpwm32mpex->lParam = INT32(HIWORD(lpwm32mpex->lReturn));
lpwm32mpex->lReturn = 0;
}
return (TRUE);
}
ULONG FASTCALL WU32TabbedTextOut(PVDMFRAME pFrame)
{
ULONG ul;
PSZ psz4;
PINT p7;
register PTABBEDTEXTOUT16 parg16;
INT BufferT[256];
GETARGPTR(pFrame, sizeof(TABBEDTEXTOUT16), parg16);
GETPSZPTR(parg16->f4, psz4);
p7 = STACKORHEAPALLOC(parg16->f6 * sizeof(INT), sizeof(BufferT), BufferT);
getintarray16(parg16->f7, parg16->f6, p7);
ul = GETLONG16(TabbedTextOut(
HDC32(parg16->f1),
INT32(parg16->f2),
INT32(parg16->f3),
psz4,
INT32(parg16->f5),
INT32(parg16->f6),
p7,
INT32(parg16->f8)
));
STACKORHEAPFREE(p7, BufferT);
FREEPSZPTR(psz4);
FREEARGPTR(parg16);
RETURN(ul);
}
void DocCoord::Scale(const DocCoord dcOrigin, const double dDPI)
{
//Subtract the origin from this coord
x-=dcOrigin.x;
y-=dcOrigin.y;
//And scale by the appropriate DPI, inverting the y-axis
//and rounding to the nearest pixel
x=INT32(x*(dDPI/72000.0)+0.5);
y=INT32(-y*(dDPI/72000.0)+0.5);
}
/* Error.chpl:67 */
static void ioerror2(syserr error, chpl_string msg, chpl_string path, int64_t offset, int64_t _ln, c_string _fn) {
int32_t call_tmp;
chpl_bool call_tmp2;
int32_t strerror_err;
c_string call_tmp3;
_ref_int32_t _ref_tmp_ = NULL;
c_string call_tmp4;
int64_t call_tmp5;
c_string call_tmp6;
c_string_copy call_tmp7;
c_string call_tmp8;
c_string call_tmp9;
c_string_copy call_tmp10;
c_string call_tmp11;
c_string_copy call_tmp12;
c_string call_tmp13;
c_string_copy call_tmp14;
c_string call_tmp15;
c_string_copy call_tmp16;
c_string_copy call_tmp17;
uint32_t call_tmp18;
c_string call_tmp19;
c_string call_tmp20;
c_string_copy call_tmp21;
call_tmp = qio_err_iserr(error);
call_tmp2 = (call_tmp != INT32(0));
if (call_tmp2) {
strerror_err = INT32(0);
_ref_tmp_ = &strerror_err;
call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);
c_string_from_string(&call_tmp4, &path, _ln, _fn);
call_tmp5 = string_length(call_tmp4);
call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);
call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);
c_string_from_string(&call_tmp8, &msg, _ln, _fn);
call_tmp9 = ((c_string)(call_tmp7));
call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);
call_tmp11 = ((c_string)(call_tmp10));
call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);
call_tmp13 = ((c_string)(call_tmp12));
call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);
call_tmp15 = ((c_string)(call_tmp14));
call_tmp16 = string_concat(call_tmp15, " offset ", _ln, _fn);
call_tmp18 = ((uint32_t)(INT64(8)));
call_tmp17 = integral_to_c_string_copy(offset, call_tmp18, true);
call_tmp19 = ((c_string)(call_tmp16));
call_tmp20 = ((c_string)(call_tmp17));
call_tmp21 = string_concat(call_tmp19, call_tmp20, _ln, _fn);
chpl_error(call_tmp21, _ln, _fn);
}
return;
}
void GUIScrollArea::scrollRightPx(UINT32 pixels)
{
if(mHorzScroll != nullptr)
{
UINT32 scrollableSize = (UINT32)std::max(0, INT32(mContentSize.x) - INT32(mVisibleSize.x));
float offset = 0.0f;
if(scrollableSize > 0)
offset = pixels / (float)scrollableSize;
mHorzScroll->scroll(-offset);
}
}
WinRect OilRect::ToWin(View *pView) const
{
// Get pixel size for this view
// NB. Previously this was done with 4 function calls! - Tim
FIXED16 PixelWidth, PixelHeight;
pView->GetPixelSize(&PixelWidth, &PixelHeight);
// Do the conversion and return the results.
return WinRect(INT32(MPtoPixel(lo.x, PixelWidth)),
-INT32(MPtoPixel(hi.y, PixelHeight) ),
INT32(MPtoPixel(hi.x, PixelWidth)),
-INT32(MPtoPixel(lo.y, PixelHeight) ));
}
void GUIScrollArea::scrollUpPx(UINT32 pixels)
{
if(mVertScroll != nullptr)
{
UINT32 scrollableSize = (UINT32)std::max(0, INT32(mContentSize.y) - INT32(mVisibleSize.y));
float offset = 0.0f;
if(scrollableSize > 0)
offset = pixels / (float)scrollableSize;
mVertScroll->scroll(offset);
}
}
TimeDelta getMJD( int ridx )
{
GUInt32 mjd[3] ;
if ( ridx < 0 ) ridx += nrec ;
EnvisatFile_ReadDatasetRecordChunk(&envfile,index,ridx,mjd,0,12) ;
#define INT32(x) ((GInt32)CPL_MSBWORD32(x))
return TimeDelta( INT32(mjd[0]), INT32(mjd[1]), INT32(mjd[2]) ) ;
#undef INT32
}
/* Error.chpl:25 */
static c_string quote_string(chpl_string s, int64_t len, int64_t _ln, c_string _fn) {
c_void_ptr local_c_nil;
c_string ret;
c_string ret2;
c_string call_tmp;
syserr call_tmp2;
_ref_c_string _ref_tmp_ = NULL;
int32_t call_tmp3;
chpl_bool call_tmp4;
c_string call_tmp5;
local_c_nil = c_nil;
ret2 = "";
c_string_from_string(&call_tmp, &s, _ln, _fn);
_ref_tmp_ = &ret2;
call_tmp2 = qio_quote_string(UINT8(34), UINT8(34), QIO_STRING_FORMAT_CHPL, call_tmp, len, _ref_tmp_, local_c_nil);
call_tmp3 = qio_err_iserr(call_tmp2);
call_tmp4 = (call_tmp3 != INT32(0));
if (call_tmp4) {
call_tmp5 = qio_strdup("<error>");
ret = call_tmp5;
goto _end_quote_string;
}
ret = ret2;
_end_quote_string:;
return ret;
}
void CCAttrMap::TransformBrushFills(TransformBase& Trans)
{
CCRuntimeClass *pType;
void *pVal;
for( iterator Pos = GetStartPosition(); Pos != GetEndPosition(); )
{
GetNextAssoc(Pos,pType,pVal);
if (pVal != NULL)
{
NodeAttribute* pNodeAttr = (NodeAttribute *)pVal;
// check that we are not about to set line width to zero
if( pNodeAttr->IsALineWidthAttr() && Trans.TransLines != FALSE )
{
INT32 Test = labs( INT32(Trans.GetScalar().MakeDouble() * ((AttrLineWidth*)pNodeAttr)->Value.LineWidth) );
if (Test <= 10)
Trans.TransLines = FALSE;
}
if (!pNodeAttr->NeedsToRenderAtEachBrushStroke())
pNodeAttr->Transform(Trans);
}
}
}
/* gtk_types.chpl:1 */
static void chpl__init_gtk_types(int64_t _ln_chpl, int32_t _fn_chpl) {
c_string modFormatStr_chpl;
c_string modStr_chpl;
_ref_int32_t refIndentLevel_chpl = NULL;
#line 1 "gtk_types.chpl"
if (chpl__init_gtk_types_p) /* ZLINE: 1 ./gtk_types.chpl */
#line 1 "gtk_types.chpl"
{
#line 1 "gtk_types.chpl"
goto _exit_chpl__init_gtk_types_chpl;
#line 1 "gtk_types.chpl"
}
#line 1 "gtk_types.chpl"
modFormatStr_chpl = "%*s\n";
#line 1 "gtk_types.chpl"
modStr_chpl = "gtk_types";
#line 1 "gtk_types.chpl"
printModuleInit(modFormatStr_chpl, modStr_chpl, INT64(9), INT64(1), INT32(44));
#line 1 "gtk_types.chpl"
refIndentLevel_chpl = &moduleInitLevel;
#line 1 "gtk_types.chpl"
*(refIndentLevel_chpl) += INT64(1);
#line 1 "gtk_types.chpl"
chpl__init_gtk_types_p = UINT8(true);
#line 1 "gtk_types.chpl"
*(refIndentLevel_chpl) -= INT64(1);
#line 1 "gtk_types.chpl"
_exit_chpl__init_gtk_types_chpl:;
#line 1 "gtk_types.chpl"
return;
#line 1 "gtk_types.chpl"
}
bool CompManager::SupportLayerAsCursor(Handle comp_handle, HWLayers *hw_layers) {
DisplayCompositionContext *display_comp_ctx =
reinterpret_cast<DisplayCompositionContext *>(comp_handle);
Handle &display_resource_ctx = display_comp_ctx->display_resource_ctx;
LayerStack *layer_stack = hw_layers->info.stack;
bool supported = false;
int32_t gpu_index = -1;
if (!layer_stack->flags.cursor_present) {
return supported;
}
for (int32_t i = INT32(layer_stack->layers.size() - 1); i >= 0; i--) {
Layer *layer = layer_stack->layers.at(UINT32(i));
if (layer->composition == kCompositionGPUTarget) {
gpu_index = i;
break;
}
}
if (gpu_index <= 0) {
return supported;
}
Layer *cursor_layer = layer_stack->layers.at(UINT32(gpu_index) - 1);
if (cursor_layer->flags.cursor && resource_intf_->ValidateCursorConfig(display_resource_ctx,
cursor_layer, true) == kErrorNone) {
supported = true;
}
return supported;
}
/********************************************************************************************
> virtual BOOL DragTool::BeyondFixedRange(double fpFixedVal)
Author: Karim_MacDonald (Xara Group Ltd) <*****@*****.**> from JustinF's SelectorTool::BeyondFixedRange code.
Created: 14/10/1999
Inputs: fpFixedVal the double that is to be converted to fixed-point
Returns: TRUE if the number is beyond the range that fixed-piont numbers can
represent, FALSE if its OK to convert.
Purpose: Checks for under/overflow in fixed-point calculations.
This function hails from SelectorTool::BeyondFixedRange.
The reason it is here is that it needs to be called from
a pointer to a DragTool, without going through everyone
elses code and re-casting their pointer to SelectorTool*.
Because it is a small function, it is implemented here, as well as
in SelectorTool.
********************************************************************************************/
BOOL DragTool::BeyondFixedRange(double fpFixedVal)
{
const double fpMinFixPt = 1.0 / (INT32(SHRT_MAX) + 1); // 1/32768
const double fpMaxFixPt = SHRT_MAX; // 32767
double fp = fabs(fpFixedVal);
return fp < fpMinFixPt || fp > fpMaxFixPt;
}
bool GUIScrollArea::_mouseEvent(const GUIMouseEvent& ev)
{
if(ev.getType() == GUIMouseEventType::MouseWheelScroll)
{
// Mouse wheel only scrolls on the Y axis
if(mVertScroll != nullptr)
{
UINT32 scrollableHeight = (UINT32)std::max(0, INT32(mContentSize.y) - INT32(mVisibleSize.y));
float additionalScroll = (float)WheelScrollAmount / scrollableHeight;
mVertScroll->scroll(additionalScroll * ev.getWheelScrollAmount());
return true;
}
}
return false;
}
std::vector<int> CFilesTab::GetSelectedFiles()
{
std::vector<int> fileids;
int count = m_wndFiles.GetItemCount();
for(int i=0;i<count;i++)
{
if(m_wndFiles.GetItemState(i, LVIS_SELECTED) == LVIS_SELECTED)
fileids.push_back(INT32(m_wndFiles.GetItemData(i)));
}
return fileids;
}
void chaseLoadParams()
{
prm_add("Translation P gain", 0,
"@c Chase_demo tranlational proportional gain (default 500)", INT32(500), END);
prm_add("Translation D gain", 0,
"@c Chase_demo translational derivative gain (default 800)", INT32(800), END);
prm_add("Rotation P gain", 0,
"@c Chase_demo rotational proportional gain (default 500)", INT32(500), END);
prm_add("Rotation D gain", 0,
"@c Chase_demo rotational derivative gain (default 800)", INT32(800), END);
int32_t pgain, dgain;
prm_get("Translation P gain", &pgain, END);
prm_get("Translation D gain", &dgain, END);
g_transLoop.setGains(pgain, dgain);
prm_get("Rotation P gain", &pgain, END);
prm_get("Rotation D gain", &dgain, END);
g_rotLoop.setGains(pgain, dgain);
}
void ptLoadParams()
{
prm_add("Pan P gain", PRM_FLAG_SIGNED,
"@c Pan/tilt_Demo Pan axis proportional gain (default 350)", INT32(350), END);
prm_add("Pan D gain", PRM_FLAG_SIGNED,
"@c Pan/tilt_Demo Pan axis derivative gain (default 600)", INT32(600), END);
prm_add("Tilt P gain", PRM_FLAG_SIGNED,
"@c Pan/tilt_Demo Tilt axis proportional gain (default 500)", INT32(500), END);
prm_add("Tilt D gain", PRM_FLAG_SIGNED,
"@c Pan/tilt_Demo Tilt axis derivative gain (default 700)", INT32(700), END);
int32_t pgain, dgain;
prm_get("Pan P gain", &pgain, END);
prm_get("Pan D gain", &dgain, END);
g_panLoop.setGains(pgain, dgain);
prm_get("Tilt P gain", &pgain, END);
prm_get("Tilt D gain", &dgain, END);
g_tiltLoop.setGains(pgain, dgain);
}
ULONG FASTCALL WU32GetTabbedTextExtent(PVDMFRAME pFrame)
{
ULONG ul;
PSZ psz2;
PINT p5;
register PGETTABBEDTEXTEXTENT16 parg16;
INT BufferT[256];
GETARGPTR(pFrame, sizeof(GETTABBEDTEXTEXTENT16), parg16);
GETPSZPTR(parg16->f2, psz2);
p5 = STACKORHEAPALLOC(parg16->f4 * sizeof(INT), sizeof(BufferT), BufferT);
getintarray16(parg16->f5, parg16->f4, p5);
ul = GETDWORD16(GetTabbedTextExtent(HDC32(parg16->f1), psz2,
INT32(parg16->f3), INT32(parg16->f4), p5 ));
STACKORHEAPFREE(p5, BufferT);
FREEPSZPTR(psz2);
FREEARGPTR(parg16);
RETURN(ul);
}
void ViewState::Dump() const
{
TCHAR *pszTrue = wxT("TRUE"), *pszFalse = wxT("FALSE");
TRACE( wxT("\nDUMP OF VIEWSTATE AT 0x%lX\n"), this );
// Window attributes.
TRACE( _T("\tScreenRect:\t\tlow = (%ld, %ld)\t\thigh = (%ld, %ld)\n"),
ScreenRect.lo.x, ScreenRect.lo.y, ScreenRect.hi.x, ScreenRect.hi.y);
TRACE( _T("\tParentRect:\t\tlow = (%ld, %ld)\t\thigh = (%ld, %ld)\n"),
ParentRect.lo.x, ParentRect.lo.y, ParentRect.hi.x, ParentRect.hi.y);
TRACE( _T("\tViewRect:\t\tlow = (%ld, %ld)\t\thigh = (%ld, %ld)\n"),
ViewRect.lo.x, ViewRect.lo.y, ViewRect.hi.x, ViewRect.hi.y);
TRACE( _T("\tIconPoint:\t\t(%ld, %ld)\n"), IconPoint.x, IconPoint.y);
TRACE( _T("\tIsNewView:\t\t%s\n"), (IsNewView ? pszTrue : pszFalse));
TRACE( _T("\tIsMinimised:\t%s\n"), (IsMinimised ? pszTrue : pszFalse));
TRACE( _T("\tIsMaximised:\t%s\n"), (IsMaximised ? pszTrue : pszFalse));
TRACE( _T("\tAlwaysOnTop:\t%s\n"), (AlwaysOnTop ? pszTrue : pszFalse));
// Document view attributes.
TRACE( _T("\tWork-Area Ext:\t(%ld, %ld) --> (%ld, %ld)\n"),
INT32(WorkAreaExtent.lo.x), INT32(WorkAreaExtent.lo.y),
INT32(WorkAreaExtent.hi.x), INT32(WorkAreaExtent.hi.y) );
TRACE( _T("\tScroll Offset:\t(%ld, %ld)\n"),
INT32(ScrollPosition.x), INT32(ScrollPosition.y) );
// TRACE( _T("\tPixel Width:\t%ld\n\tPixelHeight:\t%ld\n"), PixelWidth, PixelHeight);
}
void *DebugTreeInfo::GetDebugInfo(INT32 Index)
{
PORTNOTETRACE("other","DebugTreeInfo::GetDebugInfo - do nothing");
#ifndef EXCLUDE_FROM_XARALX
// Take the easy way out under Windows - let the list box do all the hard work.
INT32 nVal = INT32(::SendMessage((HWND) WindowID, LB_GETITEMDATA, (WPARAM) Index, 0));
if( -1 == nVal )
return NULL;
return (void *)nVal
#else
return NULL;
#endif
}
/* Error.chpl:55 */
static void ioerror(syserr error, chpl_string msg, chpl_string path, int64_t _ln, c_string _fn) {
int32_t call_tmp;
chpl_bool call_tmp2;
int32_t strerror_err;
c_string call_tmp3;
_ref_int32_t _ref_tmp_ = NULL;
c_string call_tmp4;
int64_t call_tmp5;
c_string call_tmp6;
c_string_copy call_tmp7;
c_string call_tmp8;
c_string call_tmp9;
c_string_copy call_tmp10;
c_string call_tmp11;
c_string_copy call_tmp12;
c_string call_tmp13;
c_string_copy call_tmp14;
call_tmp = qio_err_iserr(error);
call_tmp2 = (call_tmp != INT32(0));
if (call_tmp2) {
strerror_err = INT32(0);
_ref_tmp_ = &strerror_err;
call_tmp3 = sys_strerror_syserr_str(error, _ref_tmp_);
c_string_from_string(&call_tmp4, &path, _ln, _fn);
call_tmp5 = string_length(call_tmp4);
call_tmp6 = quote_string(path, call_tmp5, _ln, _fn);
call_tmp7 = string_concat(call_tmp3, " ", _ln, _fn);
c_string_from_string(&call_tmp8, &msg, _ln, _fn);
call_tmp9 = ((c_string)(call_tmp7));
call_tmp10 = string_concat(call_tmp9, call_tmp8, _ln, _fn);
call_tmp11 = ((c_string)(call_tmp10));
call_tmp12 = string_concat(call_tmp11, " with path ", _ln, _fn);
call_tmp13 = ((c_string)(call_tmp12));
call_tmp14 = string_concat(call_tmp13, call_tmp6, _ln, _fn);
chpl_error(call_tmp14, _ln, _fn);
}
return;
}
ULONG FASTCALL WU32EndDialog(PVDMFRAME pFrame)
{
register PENDDIALOG16 parg16;
GETARGPTR(pFrame, sizeof(ENDDIALOG16), parg16);
EndDialog(
HWND32(parg16->f1),
INT32(parg16->f2)
);
FREEARGPTR(parg16);
RETURN(0);
}
void CGeneralPage::OnBnClickedSetupKeys()
{
CKeyCompDlg dlg;
dlg.DoModal();
m_Hotkey = dlg.m_Hotkey;
m_KeyEdit.SetWindowText(CKeyCompDlg::GetHotkeyString(m_Hotkey));
if(m_bPush && m_Hotkey.size())
{
TT_HotKey_Unregister(ttInst, HOTKEY_PUSHTOTALK_ID);
TT_HotKey_Register(ttInst, HOTKEY_PUSHTOTALK_ID, &m_Hotkey[0], INT32(m_Hotkey.size()));
}
}
int ETEC_jump ( int argc, const char *argv[] )
{
assert ( EditBoard != NULL );
if ( argc != 2 )
{
printf ( "Error: Missing offset argument\n" );
return 0;
}
LearnTree tree;
if ( !OpenForRead(tree) )
return 1;
long scanofs = 0;
if ( sscanf(argv[1],"%ld",&scanofs) != 1 || scanofs < 0 )
{
printf ( "Invalid offset '%s'\n", argv[1] );
return 0;
}
EditPly = 0;
EditBoard->Init();
int found = 0;
try
{
found = FindPathToOffset (tree, 0, INT32(scanofs));
}
catch ( const char *message )
{
printf ( ">>> %s\n", message );
}
if ( found )
{
printf ( "Successfully found offset %ld\n", scanofs );
ListBranches();
}
else
{
printf ( ">>> Could not find path to offset %ld\n", scanofs );
printf ( ">>> Returned to root of tree.\n" );
}
return 0;
}
ULONG FASTCALL WU32SetDlgItemInt(PVDMFRAME pFrame)
{
register PSETDLGITEMINT16 parg16;
GETARGPTR(pFrame, sizeof(SETDLGITEMINT16), parg16);
SetDlgItemInt(
HWND32(parg16->f1),
WORD32(parg16->f2), // see comment in wu32getdlgitem
(parg16->f4) ? INT32(parg16->f3) : WORD32(parg16->f3),
BOOL32(parg16->f4)
);
FREEARGPTR(parg16);
RETURN(0);
}
SGNameItem* NameItemIter::ForEachItem(SGNameGroup* pGroup)
{
if (pGroup == 0) return 0;
SGNameItem* pItem = (SGNameItem*) pGroup->GetChild();
while (pItem != 0)
{
// NB. careful to fetch next item in iteration before calling Do() in case
// Do() deletes the item and we lose its next link.
SGNameItem* pNextItem = (SGNameItem*) pItem->GetNext();
if (((INT32(m_eMask) & 2) == 0 || pItem->IsSelected()) && !Do(pItem))
return pItem;
pItem = pNextItem;
}
return 0;
}
