void FlameParticleEmitter::emit()
{
if (!on)
return;
Particle *p = objects[NextObject()];
p->alive = true;
p->age = 0.0f;
p->lifespan = 0.6f;
p->halfSize = 0.06f;
p->color->r() = 1.0f;
p->color->g() = (float)(((rand() % 40) + 50) / 100.0f);
p->color->b() = 0.0f;
p->color->a() = 0.8f;
p->colorDecay->g() = 2.0f;
p->colorDecay->a() = 1.5f;
p->position->x() = this->position->x() + 0.3f * (facingRight ? 1.0f : -1.0f);
p->position->y() = this->position->y();
p->position->z() = this->position->z();
p->velocity->x() = velocity->x() + (2.5f + ((rand() % 100) / 100.0f)) * (facingRight ? 1.0f : -1.0f);
p->velocity->y() = ((rand() % 100) / 100.0f) - 0.5f;
p->velocity->z() = ((rand() % 100) / 100.0f) - 0.5f;
p->acceleration->y() = 2.0f;
}
LONGLONG CCpuUsage::CPerfCounters::GetCounterValue(PERF_DATA_BLOCK **pPerfData, DWORD dwObjectIndex, DWORD dwCounterIndex, LPCTSTR pInstanceName)
{
QueryPerformanceData(pPerfData, dwObjectIndex, dwCounterIndex);
PPERF_OBJECT_TYPE pPerfObj = NULL;
LONGLONG lnValue = {0};
// Get the first object type.
pPerfObj = FirstObject( *pPerfData );
// Look for the given object index
for( DWORD i=0; i < (*pPerfData)->NumObjectTypes; i++ )
{
if (pPerfObj->ObjectNameTitleIndex == dwObjectIndex)
{
lnValue = GetCounterValue(pPerfObj, dwCounterIndex, pInstanceName);
break;
}
pPerfObj = NextObject( pPerfObj );
}
return lnValue;
}
IPTR ModelClass__OM_UPDATE(Class *cl, Object *o, struct opUpdate *msg)
{
struct ModelData *data = (struct ModelData *)INST_DATA(cl, o);
/* send OM_UPDATE to all members without mapping the tags! */
if (!IsListEmpty((struct List *)&data->memberlist))
{
STACKULONG method = ICM_CHECKLOOP;
if (DoMethodA(o, (Msg)&method) == 0) /* avoid loops */
{
struct TagItem *clonetags;
if ((clonetags = CloneTagItems(msg->opu_AttrList)))
{
struct opUpdate opu = *msg;
Object *member, *objstate;
opu.MethodID = OM_UPDATE; /* not OM_NOTIFY! */
opu.opu_AttrList = clonetags;
method = ICM_SETLOOP;
DoMethodA(o, (Msg)&method);
objstate = (Object *)data->memberlist.mlh_Head;
while((member = NextObject(&objstate)))
{
DoMethodA(member, (Msg)&opu);
/* in case the member object poked around in the taglist: */
RefreshTagItemClones(clonetags, msg->opu_AttrList);
}
method = ICM_CLEARLOOP;
DoMethodA(o, (Msg)&method);
FreeTagItems(clonetags);
}
} /* if (DoMethod(o, ICM_CHECKLOOP) == 0) */
} /* if (!IsListEmpty(&data->memberlist)) */
/* modelclass is a superclass of icclass so not only the members are targets,
* but possibly also the modelclass object itself could have an ICA_Target.
* This is handled by the superclass */
return DoSuperMethodA(cl, o, (Msg)msg);
}
void SavePerfInfo(const Char_t *filename)
{
// Save PROOF timing information from TPerfStats to file 'filename'
if (!gProof) {
cout << "PROOF must be run to save output performance information" << endl;
return;
}
TFile f(filename, "UPDATE");
if (f.IsZombie()) {
cout << "Could not open file " << filename << " for writing" << endl;
} else {
f.cd();
TIter NextObject(gProof->GetOutputList());
TObject* obj = 0;
while (obj = NextObject()) {
TString objname = obj->GetName();
if (objname.Contains(TRegexp("^PROOF_"))) {
// must list the objects since other PROOF_ objects exist
// besides timing objects
if (objname == "PROOF_PerfStats" ||
objname == "PROOF_PacketsHist" ||
objname == "PROOF_EventsHist" ||
objname == "PROOF_NodeHist" ||
objname == "PROOF_LatencyHist" ||
objname == "PROOF_ProcTimeHist" ||
objname == "PROOF_CpuTimeHist")
obj->Write();
}
}
f.Close();
}
}
//*********************************************************************
//
// FindObject
//
// Returns pointer to object with TitleIndex. If not found, NULL
// is returned.
//
PPERF_OBJECT FindObject (PPERF_DATA pData, DWORD TitleIndex)
{
PPERF_OBJECT pObject;
DWORD i = 0;
if (pObject = FirstObject (pData))
while (i < pData->NumObjectTypes)
{
if (pObject->ObjectNameTitleIndex == TitleIndex)
return pObject;
pObject = NextObject (pObject);
i++;
}
return NULL;
}
void SnowmanManager::UpdateAll(float deltaTime)
{
spawnTimer += deltaTime;
if (spawnTimer > spawnFrequency)
{
if (leftToSpawn-- > 0)
objects[NextObject()]->Respawn(&zValues);
spawnTimer = 0.0f;
// Don't let it go negative
leftToSpawn = (leftToSpawn < 0 ? 0 : leftToSpawn);
}
for (int i=0; i<objectCount; i++)
objects[i]->Update(deltaTime);
}
static Object *findWinObjByAttr(Object *app, ULONG attr, IPTR val)
{
struct List *winlist;
Object *obj;
Object *state;
/* return the window object which supports OM_GET on attr, and
whose value of attr == val */
winlist = (struct List *)xget(app,MUIA_Application_WindowList);
state = (Object *)winlist->lh_Head;
while((obj = NextObject(&state)) != NULL)
{
IPTR value;
if((value = xget(obj,attr)) != 0 && (value == val))
break;
}
return obj;
}
void SnowfallParticleEmitter::emit()
{
if (!on)
return;
Particle *p = objects[NextObject()];
p->alive = true;
p->age = 0.0f;
p->lifespan = 5.0f;
p->halfSize = 0.02f;
p->color->r() = 1.0f;
p->color->g() = 1.0f;
p->color->b() = 1.0f;
p->color->a() = 0.5f;
p->position->x() = (float)((((rand() % 100) / 100.0f) * 16.0f) - 3.0f);
p->position->y() = 2.8f;
p->position->z() = (float)((rand() % 200) / 100.0f);
p->velocity->y() = ((rand() % 100) / 100.0f) - 1.5f;
}
static void closeAllWindows(Object *app)
{
BOOL loop;
ENTER();
do
{
struct List *list;
Object *mstate;
Object *win;
loop = FALSE;
list = (struct List *)xget(app, MUIA_Application_WindowList);
mstate = (Object *)list->lh_Head;
while((win = NextObject(&mstate)) != NULL)
{
ULONG ok = FALSE;
ok = xget(win, MUIA_App_IsSubWin);
if(ok)
{
set(win, MUIA_Window_Open, FALSE);
DoMethod(app, OM_REMMEMBER, (IPTR)win);
MUI_DisposeObject(win);
loop = TRUE;
break;
}
}
}
while(loop == TRUE);
LEAVE();
}
IPTR ModelClass__OM_DISPOSE(Class *cl, Object *o, Msg msg)
{
struct ModelData *data = (struct ModelData *)INST_DATA(cl, o);
for(;;)
{
/* free all member objects */
Object *member, *objstate;
ULONG method;
objstate = (Object *)data->memberlist.mlh_Head;
member = NextObject(&objstate);
if (!member) break;
method = OM_REMOVE;
DoMethodA(member, (Msg)&method);
DisposeObject(member);
}
return DoSuperMethodA(cl, o, msg);
}
/**
* Accept the current filter settings.
*/
static void filter_accept_rule(void)
{
if (filter_last_selected)
{
/* Store the DestFolder */
free(filter_last_selected->dest_folder); /* Safe to call with NULL */
filter_last_selected->dest_folder = mystrdup((char*)xget(filter_move_text,MUIA_Text_Contents));
filter_last_selected->use_dest_folder = xget(filter_move_check,MUIA_Selected);
/* Store the ARexxfile */
free(filter_last_selected->arexx_file);
filter_last_selected->arexx_file = mystrdup((char*)xget(filter_arexx_string,MUIA_String_Contents));
filter_last_selected->use_arexx_file = xget(filter_arexx_check,MUIA_Selected);
/* Store the Soundfile */
free(filter_last_selected->sound_file);
filter_last_selected->sound_file = mystrdup((char*)xget(filter_sound_string,MUIA_String_Contents));
filter_last_selected->use_sound_file = xget(filter_sound_check,MUIA_Selected);
/* Store the flags */
filter_last_selected->flags = 0;
if (xget(filter_request_check, MUIA_Selected)) filter_last_selected->flags |= FILTER_FLAG_REQUEST;
if (xget(filter_new_check, MUIA_Selected)) filter_last_selected->flags |= FILTER_FLAG_NEW;
if (xget(filter_sent_check, MUIA_Selected)) filter_last_selected->flags |= FILTER_FLAG_SENT;
if (xget(filter_remote_check, MUIA_Selected)) filter_last_selected->flags |= FILTER_FLAG_REMOTE;
/* Go though all objects of the rule_rule_group and build a new
rule list from it */
{
struct List *child_list = (struct List*)xget(filter_rule_group,MUIA_Group_ChildList);
Object *cstate = (Object *)child_list->lh_Head;
Object *child;
while ((child = (Object*)NextObject(&cstate)))
{
struct filter_rule *fr = (struct filter_rule*)xget(child,MUIA_UserData);
if (fr)
{
struct filter_rule *new_fr = (struct filter_rule*)xget(child,MUIA_FilterRule_Data);
/* free all strings of the rule */
switch (fr->type)
{
case RULE_FROM_MATCH:
array_free(fr->u.from.from);
array_free(fr->u.from.from_pat);
break;
case RULE_RCPT_MATCH:
array_free(fr->u.rcpt.rcpt);
array_free(fr->u.rcpt.rcpt_pat);
break;
case RULE_SUBJECT_MATCH:
array_free(fr->u.subject.subject);
array_free(fr->u.subject.subject_pat);
break;
case RULE_HEADER_MATCH:
if (fr->u.header.name) free(fr->u.header.name);
if (fr->u.header.name_pat) free(fr->u.header.name_pat);
array_free(fr->u.header.contents);
array_free(fr->u.header.contents_pat);
break;
case RULE_BODY_MATCH:
if (fr->u.body.body) free(fr->u.body.body);
filter_deinit_rule(&fr->u.body.body_parsed);
break;
}
/* clear all the memory. the node it self should not be cleared, so it stays
on the same position */
memset(((char*)fr)+sizeof(struct node),0,sizeof(struct filter_rule)-sizeof(struct node));
/* now copy over the new settings */
fr->type = new_fr->type;
fr->flags = new_fr->flags;
switch (new_fr->type)
{
case RULE_FROM_MATCH:
fr->u.from.from = array_duplicate(new_fr->u.from.from);
break;
case RULE_RCPT_MATCH:
fr->u.rcpt.rcpt = array_duplicate(new_fr->u.rcpt.rcpt);
break;
case RULE_SUBJECT_MATCH:
fr->u.subject.subject = array_duplicate(new_fr->u.subject.subject);
break;
case RULE_HEADER_MATCH:
fr->u.header.name = mystrdup(new_fr->u.header.name);
fr->u.header.contents = array_duplicate(new_fr->u.header.contents);
break;
case RULE_STATUS_MATCH:
fr->u.status.status = new_fr->u.status.status;
break;
}
}
}
}
filter_parse_filter_rules(filter_last_selected);
}
}
static int HostStatsFetchData(void)
{
DWORD o;
PPERF_OBJECT_TYPE objPtr = NULL;
DWORD res;
DWORD oldBufferSize = BufferSize;
const char * qstr;
qstr = LEVEL1_QUERY_STRING;
while ((res = RegQueryValueEx(HKEY_PERFORMANCE_DATA, qstr,
NULL, NULL,
(LPBYTE)PerfData,
&BufferSize)) == ERROR_MORE_DATA) {
oldBufferSize += 4096;
BufferSize = oldBufferSize;
PerfData = (PPERF_DATA_BLOCK)realloc(PerfData, BufferSize);
}
if (res != ERROR_SUCCESS) {
fprintf(stderr,
"Can't get Windows performance data. RegQueryValueEx returned %ld, errorno \"%d\"\n",
GetLastError(),
res);
return -1;
}
#ifdef NTDBG
fprintf(stderr, "buffersize is %ld\n", BufferSize);
fflush(stderr);
#endif
ProcessObj = NULL;
ProcessorObj = NULL;
MemoryObj = NULL;
SystemObj = NULL;
ObjectsObj = NULL;
objPtr = FirstObject(PerfData);
for (o=0; o < PerfData->NumObjectTypes; o++) {
#ifdef NTDBG
fprintf(stderr, "Object %ld\n", objPtr->ObjectNameTitleIndex);
fflush(stderr);
#endif
switch (objPtr->ObjectNameTitleIndex) {
case PROCESS_OBJ_ID: ProcessObj = objPtr; break;
case PROCESSOR_OBJ_ID: ProcessorObj = objPtr; break;
case MEMORY_OBJ_ID: MemoryObj = objPtr; break;
case SYSTEM_OBJ_ID: SystemObj = objPtr; break;
case OBJECTS_OBJ_ID: ObjectsObj = objPtr; break;
case NETWORK_OBJ_ID: NetworkObj = objPtr; break;
case UDP_OBJ_ID: UdpObj = objPtr; break;
}
objPtr = NextObject(objPtr);
}
if ( ProcessObj == NULL ||
ProcessorObj == NULL ||
MemoryObj == NULL ||
SystemObj == NULL ||
ObjectsObj == NULL ||
NetworkObj == NULL ||
UdpObj == NULL )
{
return -1;
}
loadProcessData();
loadProcessorData();
loadSystemData();
loadMemoryData();
loadObjectData();
loadUdpData();
loadCpuData();
loadNetworkData();
return 0;
}
// Listview dispatcher
ULONG LIBFUNC listview_dispatch(
REG(a0, Class *cl),
REG(a2, Object *obj),
REG(a1, Msg msg))
{
ListViewData *data=0;
struct Gadget *gadget=0;
ULONG retval=0;
// Get gadget and data pointers
if (obj)
{
gadget=(struct Gadget *)obj;
data=INST_DATA(cl,obj);
}
// Look at method
switch (msg->MethodID)
{
// Create a new instance
case OM_NEW:
// Create superclass instance
if ((retval=DoSuperMethodA(cl,obj,msg)))
{
struct TagItem *tags,*tag;
short a;
struct Image *image;
struct TextAttr *attr;
// Get pointer to our gadget and instance data
gadget=(struct Gadget *)retval;
data=INST_DATA(cl,(APTR)retval);
// Initialise data
data->dims=*(struct IBox *)&gadget->LeftEdge;
NewList(&data->boopsi_list);
data->sel=-1;
data->last_selection=-1;
// Initialise mapping tags
data->scroll_map[0].ti_Tag=PGA_Top;
data->scroll_map[0].ti_Data=DLV_Top;
data->scroll_map[1].ti_Tag=TAG_END;
data->arrow_up_map[0].ti_Tag=GA_ID;
data->arrow_up_map[0].ti_Data=DLV_ScrollUp;
data->arrow_up_map[1].ti_Tag=TAG_END;
data->arrow_down_map[0].ti_Tag=GA_ID;
data->arrow_down_map[0].ti_Data=DLV_ScrollDown;
data->arrow_down_map[1].ti_Tag=TAG_END;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Get width of scroller
data->scroller_width=GetTagData(DLV_ScrollWidth,16,tags);
// Flags
if (FindTagItem(DLV_ShowSelected,tags))
data->flags|=LVF_SHOW_SELECTED;
if (GetTagData(DLV_ThinBorder,0,tags))
data->flags|=LVF_THIN_BORDER;
if (GetTagData(DLV_MultiSelect,0,tags))
data->flags|=LVF_MULTI_SELECT;
else
if (GetTagData(DLV_Check,0,tags))
data->flags|=LVF_SELECTED_CHECK;
else
if ((a=GetTagData(DLV_ShowChecks,0,tags)))
{
data->flags|=LVF_SHOW_CHECKS;
if (a==2) data->flags|=LVF_NO_HIGHLIGHT;
}
if (GetTagData(DLV_Highlight,0,tags))
data->flags|=LVF_SELECTED_HIGH;
if (GetTagData(DLV_ReadOnly,0,tags))
data->flags|=LVF_READ_ONLY;
if (GetTagData(DLV_NoScroller,0,tags))
{
data->flags|=LVF_NO_SCROLLER;
data->scroller_width=0;
}
else
if (GetTagData(DLV_ScrollLeft,0,tags))
data->flags|=LVF_SCROLLER_LEFT;
if (GetTagData(DLV_TopJustify,0,tags))
data->flags|=LVF_TOP_JUSTIFY;
if (GetTagData(DLV_RightJustify,0,tags))
data->flags|=LVF_RIGHT_JUSTIFY;
if ((a=GetTagData(DLV_DragNotify,0,tags)))
{
data->flags|=LVF_DRAG_NOTIFY;
if (a==2) data->flags|=LVF_NO_VERT_SCROLL;
}
data->layout_flags=GetTagData(DLV_Flags,PLACETEXT_ABOVE,tags);
if (GetTagData(DLV_ShowFilenames,0,tags))
data->flags|=LVF_SHOW_FILENAMES;
if (GetTagData(DLV_ShowSeparators,0,tags))
data->flags|=LVF_SHOW_SEPARATORS;
// Get title
if ((tag=FindTagItem(GA_Text,tags)))
{
char *ptr;
short pos=0;
// Get pointer to title
if ((ptr=(char *)tag->ti_Data))
{
data->title_uscore=-1;
// Copy title string, look for underscore
while (*ptr && pos<78)
{
// Underscore?
if (*ptr=='_')
{
// Remember position, skip over it
data->title_uscore=pos;
}
// Otherwise, store
else data->title[pos++]=*ptr;
++ptr;
}
data->title[pos]=0;
}
}
// Get font to use
if ((attr=(struct TextAttr *)GetTagData(GTCustom_TextAttr,0,tags)))
{
if ((data->list_font=OpenFont(attr)))
data->flags|=LVF_GOT_FONT;
}
if (!data->list_font) data->list_font=((struct GfxBase *)GfxBase)->DefaultFont;
// Arrow height
data->arrow_height=data->list_font->tf_YSize-2;
if (data->arrow_height<10) data->arrow_height=10;
// Fix dimensions
listview_get_dims(cl,data);
data->text_height=data->list_font->tf_YSize;
// Need check mark?
if (data->flags&(LVF_MULTI_SELECT|LVF_SHOW_CHECKS) ||
(data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
{
// Create check image
if ((data->check=(struct Image *)NewObject(
0,"dopusiclass",
DIA_Type,IM_CHECK,
IA_Width,13,
IA_Height,data->text_height-1,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->check,OM_ADDTAIL,&data->boopsi_list);
}
data->text_offset=23;
}
else data->text_offset=2;
// Scroller needed?
if (!(data->flags&LVF_NO_SCROLLER))
{
// Create scroller
if ((data->scroller=(struct Gadget *)NewObject(
0,"propgclass",
GA_Previous,gadget,
GA_ID,LVGID_SCROLLER,
GA_Left,(data->flags&LVF_SCROLLER_LEFT)?data->dims.Left+4:data->dims.Left+data->dims.Width-data->scroller_width+4,
GA_Top,data->dims.Top+2,
GA_Width,data->scroller_width-8,
GA_Height,data->dims.Height-4-(data->arrow_height<<1),
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
PGA_Freedom,FREEVERT,
PGA_NewLook, TRUE,
PGA_Borderless,TRUE,
PGA_Visible,1,
PGA_Total,1,
ICA_TARGET,gadget,
ICA_MAP,data->scroll_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->scroller,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_UP,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create up arrow button
if ((data->arrows[0]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->scroller,
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_up_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[0],OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow image
if ((image=(struct Image *)NewObject(
0,"dopusiclass",
IA_Width,data->scroller_dims.Width,
IA_Height,data->arrow_height,
DIA_Type,IM_ARROW_DOWN,
DIA_ThinBorders,(data->flags&LVF_THIN_BORDER)?TRUE:FALSE,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)image,OM_ADDTAIL,&data->boopsi_list);
}
// Create down arrow button
if ((data->arrows[1]=(struct Gadget *)NewObject(
0,"buttongclass",
GA_ID,LVGID_ARROW,
GA_Previous,data->arrows[0],
GA_Left,data->scroller_dims.Left,
GA_Top,data->scroller_dims.Top+data->scroller_dims.Height+data->arrow_height,
GA_Width,data->scroller_dims.Width,
GA_Height,data->arrow_height,
GA_Image,image,
GA_Disabled,(gadget->Flags&GFLG_DISABLED)?TRUE:FALSE,
ICA_TARGET,gadget,
ICA_MAP,data->arrow_down_map,
TAG_END)))
{
// Add to boopsi list
DoMethod((Object *)data->arrows[1],OM_ADDTAIL,&data->boopsi_list);
}
}
}
else break;
// Fall through to OM_SET
// Update/Set
case OM_UPDATE:
case OM_SET:
{
struct TagItem *tag,*tags;
unsigned short old;
struct Node *node;
short item;
short redraw=0;
// Get taglist
tags=((struct opSet *)msg)->ops_AttrList;
// Make visible?
if ((tag=FindTagItem(DLV_MakeVisible,tags)))
{
short scroll;
// Remember old top
old=data->top;
// Get scroll amount
scroll=tag->ti_Data-old;
// Need to scroll?
if (scroll<0 ||
scroll>=data->lines)
{
// Get scroll amount
if (scroll>=data->lines)
scroll-=data->lines-1;
// Get new top
data->top+=scroll;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
}
// New top?
else
if ((tag=FindTagItem(DLV_Top,tags)))
{
// Remember old top
old=data->top;
// Get new top
data->top=tag->ti_Data;
// Bounds check
if (data->top>data->count-data->lines)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Redraw?
if (old!=data->top)
{
data->last_sel=-1;
redraw=2;
}
}
// Scroll up
else
if ((tag=FindTagItem(DLV_ScrollUp,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top>0)
{
--data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// Scroll down
else
if ((tag=FindTagItem(DLV_ScrollDown,tags)))
{
// Is this the gadgetup?
if (msg->MethodID==OM_UPDATE &&
!(((struct opUpdate *)msg)->opu_Flags&OPUF_INTERIM))
{
// Clear scroll count
data->scroll_count=0;
}
// Or is this the second/third scroll (first/second intuitick)?
else
if (msg->MethodID==OM_UPDATE &&
(data->scroll_count==1 || data->scroll_count==2))
{
// Throw this away
++data->scroll_count;
}
// Otherwise, check it's valid
else
if (tag->ti_Data!=(ULONG)-LVGID_ARROW)
{
// Bounds check
if (data->top<data->count-data->lines)
{
++data->top;
data->last_sel=-1;
redraw=2;
}
// Increment scroll count if necessary
if (msg->MethodID==OM_UPDATE) ++data->scroll_count;
}
}
// New labels
if ((tag=FindTagItem(DLV_Labels,tags)))
{
// clear top item
data->top_item=0;
// Store new label pointer
data->labels=(struct List *)tag->ti_Data;
// Detached list?
if (data->labels==(struct List *)~0)
data->flags|=LVF_DETACHED;
// No list
else
if (data->labels==0)
{
// Clear detach flag
data->count=0;
data->flags&=~LVF_DETACHED;
redraw=1;
}
// Valid list
else
{
// Count items
for (data->count=0,node=data->labels->lh_Head;
node->ln_Succ;
data->count++,node=node->ln_Succ);
// Bounds check top
if (data->top+data->lines>data->count)
data->top=data->count-data->lines;
if (data->top<0) data->top=0;
// Check selection for out-of-bounds
if (data->sel>data->count-1) data->sel=-1;
// Clear detach flag
data->flags&=~LVF_DETACHED;
redraw=1;
}
}
// Selected
if ((tag=FindTagItem(DLV_Selected,tags)) ||
(tag=FindTagItem(DLV_SelectPrevious,tags)) ||
(tag=FindTagItem(DLV_SelectNext,tags)) ||
(tag=FindTagItem(DLV_PageUp,tags)) ||
(tag=FindTagItem(DLV_PageDown,tags)) ||
(tag=FindTagItem(DLV_Home,tags)) ||
(tag=FindTagItem(DLV_End,tags)))
{
// Store old
old=data->sel;
// Get new selected
if (tag->ti_Tag==DLV_Selected)
{
data->sel=tag->ti_Data;
}
else
if (tag->ti_Tag==DLV_SelectPrevious)
{
if (data->sel>0) --data->sel;
}
else
if (tag->ti_Tag==DLV_SelectNext)
{
++data->sel;
}
else
if (tag->ti_Tag==DLV_PageUp)
{
if (data->sel==data->top)
data->sel-=data->lines-1;
else
data->sel=data->top;
if (data->sel<0) data->sel=0;
}
else
if (tag->ti_Tag==DLV_PageDown)
{
if (data->sel==data->top+data->lines-1)
data->sel+=data->lines-1;
else
data->sel=data->top+data->lines-1;
}
else
if (tag->ti_Tag==DLV_Home)
{
data->sel=0;
}
else
if (tag->ti_Tag==DLV_End)
{
data->sel=data->count-1;
}
// Bounds check
if (data->sel>data->count-1) data->sel=data->count-1;
if (data->sel<0) data->sel=-1;
// Changed?
if (data->sel!=old && !(gadget->Flags&GFLG_DISABLED))
{
// Save selection
if (!redraw)
{
data->last_sel=data->last_selection;
redraw=2;
}
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct opSet *)msg)->ops_GInfo,0);
}
}
// Disabled (set only)
if (msg->MethodID==OM_SET &&
(tag=FindTagItem(GA_Disabled,tags)))
{
// Different to current state?
if ((tag->ti_Data && !(gadget->Flags&GFLG_DISABLED)) ||
(!tag->ti_Data && gadget->Flags&GFLG_DISABLED))
{
struct TagItem distags[2];
short a;
// Fill out disable tags
distags[0].ti_Tag=GA_Disabled;
distags[0].ti_Data=tag->ti_Data;
distags[1].ti_Tag=TAG_DONE;
// Set state of slider
if (data->scroller)
{
DoMethod(
(Object *)data->scroller,
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// And arrows
for (a=0;a<2;a++)
DoMethod(
(Object *)data->arrows[a],
OM_SET,
distags,
((struct opSet *)msg)->ops_GInfo);
// Set flag to say disable state changed
if (!tag->ti_Data)
data->flags|=LVF_DISABLE_CHANGE;
}
// Change disable state and redraw
gadget->Flags^=GFLG_DISABLED;
redraw=1;
}
}
// Get top item
if (!data->labels) data->top_item=0;
else
if (!(data->flags&LVF_DETACHED) && data->labels)
{
for (node=data->labels->lh_Head,item=0;
node->ln_Succ && item<data->top;
node=node->ln_Succ,item++);
data->top_item=node;
}
// Do we need to redraw the list?
if (msg->MethodID==OM_SET || msg->MethodID==OM_UPDATE)
{
if (redraw && !(data->flags&LVF_DETACHED))
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(((struct opSet *)msg)->ops_GInfo)))
{
// Send redraw
DoMethod(
obj,
GM_RENDER,
((struct opSet *)msg)->ops_GInfo,
rp,
(redraw==2)?GREDRAW_UPDATE:GREDRAW_REDRAW);
ReleaseGIRPort(rp);
}
}
}
}
break;
// Get an attribute
case OM_GET:
{
struct opGet *get;
// Get get message
get=(struct opGet *)msg;
// Default to ok
retval=1;
// Look at attribute
switch (get->opg_AttrID)
{
// Selected
case DLV_Selected:
*get->opg_Storage=(ULONG)data->last_selection;
break;
// Top
case DLV_Top:
*get->opg_Storage=(ULONG)data->top;
break;
// Lines
case DLV_Lines:
*get->opg_Storage=(ULONG)data->lines;
break;
// Labels
case DLV_Labels:
*get->opg_Storage=(ULONG)data->labels;
break;
// Get line from coordinates
case DLV_GetLine:
{
unsigned short x,y;
struct gpInput fake;
// Get coordinates
x=((*get->opg_Storage)>>16)&0xffff;
y=(*get->opg_Storage)&0xffff;
// Fake gpInput
fake.gpi_Mouse.X=x-gadget->LeftEdge;
fake.gpi_Mouse.Y=y-gadget->TopEdge;
// Get selection
*get->opg_Storage=(ULONG)listview_get_sel(cl,gadget,data,&fake,0);
}
break;
// Draw a line from the listview
case DLV_DrawLine:
{
ListViewDraw *draw=(ListViewDraw *)*get->opg_Storage;
// Draw line
listview_draw_item(
cl,
gadget,
draw->rp,
draw->drawinfo,
data,
draw->node,
draw->line,
&draw->box);
}
break;
// Other
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
}
break;
// Kill an instance
case OM_DISPOSE:
{
APTR object_ptr;
Object *object;
// Free BOOPSI objects
object_ptr=data->boopsi_list.lh_Head;
while ((object=NextObject((APTR)&object_ptr)))
DisposeObject(object);
// Free font
if (data->flags&LVF_GOT_FONT)
CloseFont(data->list_font);
retval=DoSuperMethodA(cl,obj,msg);
}
break;
// Render gadget
case GM_RENDER:
// Cache DrawInfo
data->draw_info=((struct gpRender *)msg)->gpr_GInfo->gi_DrInfo;
// If a full redraw, clear double-click time
if (((struct gpRender *)msg)->gpr_Redraw==GREDRAW_REDRAW)
data->seconds=0;
// Show gadget
listview_render(cl,gadget,data,(struct gpRender *)msg);
break;
// Hit test
case GM_HITTEST:
{
struct gpHitTest *test;
// Get test pointer
test=(struct gpHitTest *)msg;
// See if we're hit
if (test->gpht_Mouse.X>=data->text_dims.Left-gadget->LeftEdge &&
test->gpht_Mouse.Y>=data->text_dims.Top-gadget->TopEdge &&
test->gpht_Mouse.X<data->text_dims.Left+data->text_dims.Width-gadget->LeftEdge &&
test->gpht_Mouse.Y<data->text_dims.Top+data->text_dims.Height-gadget->TopEdge)
{
retval=GMR_GADGETHIT;
}
}
break;
// Notify
case OM_NOTIFY:
// Drag notify?
if (data->flags&LVF_DRAG_FLAG)
{
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_DragNotify;
data->notify_tags[0].ti_Data=data->drag_sel;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=GA_Left;
data->notify_tags[2].ti_Data=data->text_dims.Left;
data->notify_tags[3].ti_Tag=GA_Top;
data->notify_tags[3].ti_Data=data->text_dims.Top+
UMult32(data->drag_sel-data->top,data->text_height);
data->notify_tags[4].ti_Tag=GA_Width;
data->notify_tags[4].ti_Data=data->text_dims.Width;
data->notify_tags[5].ti_Tag=GA_Height;
data->notify_tags[5].ti_Data=data->text_height;
data->notify_tags[6].ti_Tag=GA_RelRight;
data->notify_tags[6].ti_Data=data->drag_x_position;
data->notify_tags[7].ti_Tag=GA_RelBottom;
data->notify_tags[7].ti_Data=data->drag_y_position;
data->notify_tags[8].ti_Tag=DLV_Top;
data->notify_tags[8].ti_Data=data->top;
data->notify_tags[9].ti_Tag=DLV_Object;
data->notify_tags[9].ti_Data=(ULONG)gadget;
data->notify_tags[10].ti_Tag=TAG_END;
// Clear flag
data->flags&=~LVF_DRAG_FLAG;
}
// Otherwise normal notify
else
{
ULONG seconds,micros;
// Fill out tags
data->notify_tags[0].ti_Tag=DLV_Selected;
data->notify_tags[0].ti_Data=data->last_selection;
data->notify_tags[1].ti_Tag=GA_ID;
data->notify_tags[1].ti_Data=gadget->GadgetID;
data->notify_tags[2].ti_Tag=TAG_END;
// Get current time
CurrentTime(&seconds,µs);
// Double-click?
if (data->click_sel==data->last_selection &&
DoubleClick(data->seconds,data->micros,seconds,micros))
{
// Set double-click flag
data->notify_tags[2].ti_Tag=DLV_DoubleClick;
data->notify_tags[2].ti_Data=TRUE;
data->notify_tags[3].ti_Tag=TAG_END;
// Clear double-click
data->seconds=0;
}
// Otherwise
else
{
// Remember double-click
data->seconds=seconds;
data->micros=micros;
data->click_sel=data->last_selection;
}
}
// Send message
DoSuperMethod(cl,obj,OM_NOTIFY,data->notify_tags,((struct opUpdate *)msg)->opu_GInfo,0);
break;
// Go (in)active/Handle input
case GM_GOACTIVE:
case GM_GOINACTIVE:
case GM_HANDLEINPUT:
{
struct gpInput *input;
short redraw=0;
// Get input pointer
input=(struct gpInput *)msg;
// Go active?
if (input->MethodID==GM_GOACTIVE)
{
// Default is not to activate
retval=GMR_NOREUSE;
// Ok to go active?
if (!(gadget->Flags&GFLG_DISABLED) && input->gpi_IEvent)
{
// Left button down and valid list?
if (input->gpi_IEvent->ie_Code==SELECTDOWN &&
data->labels &&
!(data->flags&(LVF_READ_ONLY|LVF_DETACHED)))
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,0))>-1)
{
// Ok to activate
retval=GMR_MEACTIVE;
// Store current top
data->last_top=data->top;
// Remember x and y click-offset
data->drag_x_position=input->gpi_Mouse.X-
(data->text_dims.Left-data->dims.Left);
data->drag_y_position=input->gpi_Mouse.Y-
(data->text_dims.Top-data->dims.Top)-
UMult32(sel-data->top,data->text_height);
// Change?
if (data->sel!=sel ||
!(data->flags&LVF_SHOW_SELECTED) ||
(data->flags&LVF_SELECTED_CHECK))
{
// New selection
data->last_sel=data->last_selection;
data->sel=sel;
redraw=1;
}
// Set selected flag
gadget->Flags|=GFLG_SELECTED;
}
}
}
}
// Go inactive?
else
if (msg->MethodID==GM_GOINACTIVE)
{
// Clear selected flag
gadget->Flags&=~GFLG_SELECTED;
// If we're showing selection with checks, we need to redraw last selection
if ((data->flags&(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))==(LVF_SHOW_SELECTED|LVF_SELECTED_CHECK))
data->last_sel=data->last_selection;
redraw=1;
// Save this selection
data->last_selection=data->sel;
// Send notify
DoMethod(obj,OM_NOTIFY,0,((struct gpInput *)msg)->gpi_GInfo,0);
// Clear cancel flag
data->flags&=~LVF_CANCEL;
}
// Handle input
else
{
// Default return value
retval=GMR_MEACTIVE;
// Is it a mouse event?
if (input->gpi_IEvent->ie_Class==IECLASS_RAWMOUSE)
{
// Look at mouse code
switch (input->gpi_IEvent->ie_Code)
{
// Left button up
case SELECTUP:
{
// Set return code
*input->gpi_Termination=data->sel;
// Gadget processing finished
retval=GMR_NOREUSE|GMR_VERIFY;
data->flags|=LVF_CANCEL;
// Multi-selection?
if (data->flags&LVF_MULTI_SELECT)
{
struct Node *node;
short count;
// Get this node
for (node=data->labels->lh_Head,count=0;
node->ln_Succ && count<data->sel;
node=node->ln_Succ,count++);
// Did we get it?
if (node && node->ln_Succ)
{
// Save old selection
data->last_sel=data->sel;
// Toggle selection
node->lve_Flags^=LVEF_SELECTED;
redraw=1;
}
}
}
break;
// No button; mouse moved
case IECODE_NOBUTTON:
{
short sel;
// Is mouse outside of lister?
if (input->gpi_Mouse.X<0 ||
input->gpi_Mouse.X>=data->list_dims.Width)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Valid selection?
if (data->sel>-1)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN (if NO_VERT_SCROLL)
if (!(data->flags&LVF_NO_VERT_SCROLL))
{
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
break;
}
}
else break;
}
else break;
}
// Get selection
else
if ((sel=listview_get_sel(cl,gadget,data,input,1))>-1 ||
(sel==-1 && (data->flags&LVF_NO_VERT_SCROLL)))
{
// Change?
if (data->sel!=sel || sel==-1)
{
// Clear double-click
data->seconds=0;
// No vertical scroll?
if (data->flags&LVF_NO_VERT_SCROLL)
{
// Drag notify?
if (data->flags&LVF_DRAG_NOTIFY)
{
// Notify drag
data->flags|=LVF_DRAG_FLAG;
data->drag_sel=data->sel;
// Will fall through to MENUDOWN
}
else break;
}
// Otherwise
else
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
redraw=1;
break;
}
}
else break;
}
else break;
}
// Right button does cancel
case MENUDOWN:
{
// Gadget processing finished
retval=GMR_NOREUSE;
data->flags|=LVF_CANCEL;
// Show selected?
if (data->flags&LVF_SHOW_SELECTED)
{
// Restore last selection
data->last_sel=data->sel;
data->sel=data->last_selection;
// Does top need to change?
if (data->top!=data->last_top)
{
short item;
data->top=data->last_top;
data->last_sel=-1;
for (data->top_item=data->labels->lh_Head,item=0;
data->top_item->ln_Succ && item<data->top;
data->top_item=data->top_item->ln_Succ,item++);
}
redraw=1;
}
}
break;
}
}
// Or a timer event
else
if (input->gpi_IEvent->ie_Class==IECLASS_TIMER)
{
short sel;
// Get selection
if ((sel=listview_get_sel(cl,gadget,data,input,2))>-1)
{
// Change?
if (data->sel!=sel)
{
// Save old selection
data->last_sel=data->sel;
// New selection
data->sel=sel;
// Do we have to scroll?
if (sel<data->top)
{
if (data->top>0)
{
// Scroll up
--data->top;
data->top_item=data->top_item->ln_Pred;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else
if (sel>=data->top+data->lines)
{
if (data->top+data->lines<data->count)
{
// Scroll down
++data->top;
data->top_item=data->top_item->ln_Succ;
// Redraw the list
data->last_sel=-1;
redraw=1;
}
}
else redraw=1;
}
}
}
}
// Redraw needed?
if (redraw)
{
struct RastPort *rp;
// Get rastport
if ((rp=ObtainGIRPort(input->gpi_GInfo)))
{
// Send redraw
DoMethod(obj,GM_RENDER,input->gpi_GInfo,rp,GREDRAW_UPDATE);
ReleaseGIRPort(rp);
}
}
}
break;
// Resize
case GM_RESIZE:
// Handle the resize
listview_resize(cl,gadget,data,(struct gpResize *)msg);
break;
// Unknown method
default:
retval=DoSuperMethodA(cl,obj,msg);
break;
}
return retval;
}
int main(void)
{
Object *app, *win, *iconCon, *vert, *horiz;
Object *strip;
struct MUI_CustomClass *iconContainerClass;
BOOL running=TRUE;
ULONG signals=0;
struct Screen *screen;
struct NewMenu *menuDat;
struct TagItem icTags[6];
ULONG inputResult;
MUIMasterBase=OpenLibrary("muimaster.library", 0);
if(!MUIMasterBase)
printf("could not open muimaster.library\n");
DesktopBase=OpenLibrary("desktop.library", 0);
if(!DesktopBase)
printf("could not open desktop.library\n");
menuDat=BuildDesktopMenus();
if(!menuDat)
kprintf("EEK! EEKK! Menu ERROR!!!\n");
screen=LockPubScreen(NULL);
horiz=PropObject,
MUIA_Prop_Horiz, TRUE,
MUIA_Prop_Entries, 0,
MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Bottom,
End;
vert=PropObject,
MUIA_Prop_Horiz, FALSE,
MUIA_Prop_UseWinBorder, MUIV_Prop_UseWinBorder_Right,
End;
icTags[0].ti_Tag=MUIA_InnerLeft;
icTags[0].ti_Data=0;
icTags[1].ti_Tag=MUIA_InnerTop;
icTags[1].ti_Data=0;
icTags[2].ti_Tag=MUIA_InnerBottom;
icTags[2].ti_Data=0;
icTags[3].ti_Tag=MUIA_InnerRight;
icTags[3].ti_Data=0;
icTags[4].ti_Tag=MUIA_FillArea;
icTags[4].ti_Data=FALSE;
// icTags[1].ti_Tag=ICOA_Directory;
// icTags[1].ti_Data="C:";
// icTags[2].ti_Tag=ICA_VertScroller;
// icTags[2].ti_Data=vert;
// icTags[3].ti_Tag=ICA_HorizScroller;
// icTags[3].ti_Data=horiz;
icTags[5].ti_Tag=TAG_END;
icTags[5].ti_Data=0;
kprintf("here1\n");
app=ApplicationObject,
SubWindow, win=WindowObject,
MUIA_Window_Backdrop, TRUE,
MUIA_Window_Borderless, TRUE,
MUIA_Window_CloseGadget, FALSE,
MUIA_Window_DepthGadget, FALSE,
MUIA_Window_SizeGadget, FALSE,
MUIA_Window_DragBar, FALSE,
MUIA_Window_LeftEdge, 0,
MUIA_Window_TopEdge, screen->BarHeight+1,
MUIA_Window_Width, screen->Width,
MUIA_Window_Height, screen->Height-screen->BarHeight-1,
MUIA_Window_Menustrip, strip=MUI_MakeObject(MUIO_MenustripNM, menuDat, 0),
// MUIA_Window_UseBottomBorderScroller, TRUE,
// MUIA_Window_UseRightBorderScroller, TRUE,
MUIA_Window_EraseArea, FALSE,
WindowContents, iconCon=CreateDesktopObjectA(CDO_Desktop, icTags),
End,
End;
if(app)
{
DoMethod(win, MUIM_Notify, MUIA_Window_CloseRequest, TRUE, app, 2, MUIM_Application_ReturnID, MUIV_Application_ReturnID_Quit);
// these are here temporarily..
DoMethod(vert, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToVert, MUIV_TriggerValue);
DoMethod(horiz, MUIM_Notify, MUIA_Prop_First, MUIV_EveryTime, iconCon, 3, MUIM_Set, ICA_ScrollToHoriz, MUIV_TriggerValue);
SetAttrs(win, MUIA_Window_Open, TRUE, TAG_DONE);
while(running)
{
inputResult=DoMethod(app, MUIM_Application_Input, &signals);
switch(inputResult)
{
case MUIV_Application_ReturnID_Quit:
running=FALSE;
break;
case 2:
running=FALSE;
break;
default:
{
// a menuitem was selected...
struct MinList *subjects=NULL;
Object *member, *ostate;
Tag activeSubjectsTag;
struct TagItem args[2];
if(inputResult & DOC_DESKTOPOP)
{
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=iconCon;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
else if(inputResult & DOC_ICONOP)
{
GetAttr(AICA_SelectedIcons, iconCon, &subjects);
ostate=subjects->mlh_Head;
while((member=NextObject(&ostate)))
{
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=member;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
}
else if(inputResult & DOC_WINDOWOP)
{
GetAttr(DA_ActiveWindow, iconCon, &subjects);
args[0].ti_Tag=DDO_Target;
args[0].ti_Data=subjects;
args[1].ti_Tag=TAG_END;
args[1].ti_Data=0;
DoDesktopOperation(inputResult, args);
}
}
}
if(running && signals)
Wait(signals);
}
SetAttrs(win, MUIA_Window_Open, FALSE, TAG_DONE);
DisposeObject(app);
}
else
kprintf("could not create app\n");
CloseLibrary(DesktopBase);
CloseLibrary(MUIMasterBase);
return 0;
}
void GetProcessID(LPCTSTR pProcessName, std::vector<DWORD>& SetOfPID)
{
PPERF_DATA_BLOCK pPerfData = NULL;
PPERF_OBJECT_TYPE pPerfObj;
PPERF_INSTANCE_DEFINITION pPerfInst;
PPERF_COUNTER_DEFINITION pPerfCntr, pCurCntr;
PPERF_COUNTER_BLOCK PtrToCntr;
DWORD BufferSize = TOTALBYTES;
DWORD i, j;
LONG k;
// Allocate the buffer for the performance data.
pPerfData = (PPERF_DATA_BLOCK)malloc(BufferSize);
wchar_t szKey[32];
swprintf_s(szKey, L"%d %d", PROCESS_OBJECT_INDEX, PROC_ID_COUNTER);
LONG lRes;
while ((lRes = RegQueryValueEx(HKEY_PERFORMANCE_DATA,
szKey,
NULL,
NULL,
(LPBYTE)pPerfData,
&BufferSize)) == ERROR_MORE_DATA)
{
// Get a buffer that is big enough.
BufferSize += BYTEINCREMENT;
pPerfData = (PPERF_DATA_BLOCK)realloc(pPerfData, BufferSize);
}
// Get the first object type.
pPerfObj = FirstObject(pPerfData);
// Process all objects.
for (i = 0; i < pPerfData->NumObjectTypes; i++)
{
if (pPerfObj->ObjectNameTitleIndex != PROCESS_OBJECT_INDEX)
{
pPerfObj = NextObject(pPerfObj);
continue;
}
SetOfPID.clear();
// Get the first counter.
pPerfCntr = FirstCounter(pPerfObj);
// Get the first instance.
pPerfInst = FirstInstance(pPerfObj);
_bstr_t bstrProcessName, bstrInput;
// Retrieve all instances.
for (k = 0; k < pPerfObj->NumInstances; k++)
{
pCurCntr = pPerfCntr;
bstrInput = pProcessName;
bstrProcessName = (wchar_t *)((PBYTE)pPerfInst + pPerfInst->NameOffset);
if (!_wcsicmp((LPCTSTR)bstrProcessName, (LPCTSTR)bstrInput))
{
// Retrieve all counters.
for (j = 0; j < pPerfObj->NumCounters; j++)
{
if (pCurCntr->CounterNameTitleIndex == PROC_ID_COUNTER)
{
PtrToCntr = CounterBlock(pPerfInst);
DWORD *pdwValue = (DWORD*)((LPBYTE)PtrToCntr + pCurCntr->CounterOffset);
SetOfPID.push_back(*pdwValue);
break;
}
// Get the next counter.
pCurCntr = NextCounter(pCurCntr);
}
}
// Get the next instance.
pPerfInst = NextInstance(pPerfInst);
}
}
free(pPerfData);
RegCloseKey(HKEY_PERFORMANCE_DATA);
}
