int print_data( pwr_sAttrRef *arp, FILE *fp)
{
int sts;
char *s;
pwr_tClassId classid;
char *object_p;
pwr_tAName dataname;
pwr_tAName objectname;
pwr_tAName attributename;
pwr_tAttrRef aref;
int object_backup;
int array_element = 0;
int index;
int nr;
sts = gdh_AttrrefToName( arp, dataname, sizeof(dataname), cdh_mNName);
if ( EVEN(sts)) return sts;
strcpy( objectname, dataname);
if ( !arp->Flags.b.ObjectAttr && (s = strchr( objectname, '.'))) {
*s = 0;
object_backup = 0;
strcpy( attributename, dataname);
if ( (s = strchr( dataname, '['))) {
array_element = 1;
nr = sscanf( s+1, "%d", &index);
if ( nr != 1) return 0;
}
}
else {
object_backup = 1;
}
sts = gdh_NameToAttrref( pwr_cNOid, objectname, &aref);
if ( EVEN(sts)) return sts;
sts = gdh_AttrRefToPointer( &aref, (void **)&object_p);
if ( EVEN(sts)) return sts;
sts = gdh_GetAttrRefTid( &aref, &classid);
if ( EVEN(sts)) return sts;
if ( object_backup) {
print_object( &aref, classid, object_p, 0, objectname, fp);
}
else {
print_attribute( &aref, classid, object_p, attributename, array_element, index, fp);
}
return 1;
}
void ra_result::setPointer(int resultNo, const char *pointer)
// Set pointer to result
{
pwr_sAttrRef attrref;
pwr_tDlid refid;
pwr_tStatus sts;
resultNo_ = resultNo;
sts = gdh_NameToAttrref( pwr_cNObjid, pointer, &attrref);
if ( EVEN(sts)) throw co_error(sts);
sts = gdh_DLRefObjectInfoAttrref( &attrref, (void**)&pointer_, &refid);
if ( EVEN(sts)) throw co_error(sts);
dlid_ = &refid;
}
/* aaref points to ActualValue */
static int IsDisabled( pwr_tAttrRef *aaref)
{
pwr_tDisableAttr disabled;
pwr_tAName name;
pwr_tAttrRef oaref;
pwr_tStatus sts;
char *s;
sts = gdh_AttrrefToName( aaref, name, sizeof(name), cdh_mNName);
if ( EVEN(sts)) return 0;
if ( (s = strrchr( name, '.')))
*s = 0;
else
return 0;
sts = gdh_NameToAttrref( pwr_cNObjid, name, &oaref);
if ( EVEN(sts)) return 0;
sts = gdh_ArefDisabled( &oaref, &disabled);
if ( ODD(sts) && disabled)
return 1;
return 0;
}
int XAttNav::get_select( pwr_tAttrRef *arp)
{
brow_tNode *node_list;
int node_count;
ItemCollect *item;
pwr_tStatus sts;
brow_GetSelectedNodes( brow->ctx, &node_list, &node_count);
if ( node_count != 1)
return 0;
brow_GetUserData( node_list[0], (void **)&item);
free( node_list);
switch( item->type) {
case xnav_eItemType_Collect:
sts = gdh_NameToAttrref( pwr_cNObjid, item->name, arp);
if ( EVEN(sts)) return sts;
break;
default:
return 0;
}
return XATT__SUCCESS;
}
XttFast::XttFast( void *parent_ctx,
char *name,
pwr_sAttrRef *fast_arp,
int *sts) :
xnav(parent_ctx), fast_cnt(0), timerid(0), close_cb(0), help_cb(0), first_scan(1),
axis_configured(false)
{
pwr_sAttrRef aref = pwr_cNAttrRef;
pwr_tAName fast_name;
pwr_tAName attr_name;
pwr_sClass_DsFastCurve fp;
int i, j;
*sts = XNAV__SUCCESS;
// Get current status of the fast objects
i = 0;
aref = *fast_arp;
if ( cdh_ObjidIsNull( aref.Objid)) {
*sts = XNAV__FASTCONFIG;
return;
}
*sts = gdh_AttrrefToName( &aref, fast_name, sizeof(fast_name),
cdh_mNName);
if (EVEN(*sts)) return;
*sts = gdh_GetObjectInfo( fast_name, &fp, sizeof(fp));
if ( EVEN(*sts)) return;
max_points = fp.NoOfPoints;
fast_function = fp.Function;
strcpy( attr_name, fast_name);
strcat( attr_name, ".TriggTime");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_time_attr);
if ( fast_function & fast_mFunction_BeforeTrigg) {
strcpy( attr_name, fast_name);
strcat( attr_name, ".TriggIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &trigg_index_attr);
strcpy( attr_name, fast_name);
strcat( attr_name, ".FirstIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &first_index_attr);
strcpy( attr_name, fast_name);
strcat( attr_name, ".LastIndex");
gdh_NameToAttrref( pwr_cNObjid, attr_name, &last_index_attr);
}
// Create data for time axis
gcd = new GeCurveData( curve_eDataType_DsTrend);
gcd->x_data[0] = (double *) malloc( 8 * max_points);
strcpy( gcd->x_name, "Time");
gcd->x_axis_type[0] = curve_eAxis_x;
memcpy( &time_buff, &fp.TimeBuffer, sizeof(time_buff));
fast_cnt = 0;
for ( i = 0; i < FAST_CURVES; i++) {
if ( fp.CurveValid[i]) {
gcd->y_data[fast_cnt] = (double *) calloc( 1, 8 * max_points);
gcd->y_axis_type[fast_cnt] = curve_eAxis_y;
memcpy( &buff[fast_cnt], &fp.Buffers[i], sizeof(buff[0]));
type[fast_cnt] = (pwr_eType) fp.AttributeType[i];
fast_idx[i] = fast_cnt;
curve_idx[fast_cnt] = i;
*sts = gdh_AttrrefToName( &fp.Attribute[i], attr_name,
sizeof(attr_name), cdh_mNName);
if (EVEN(*sts)) continue;
strcpy( gcd->y_name[fast_cnt], attr_name);
fast_cnt++;
}
}
if ( !fast_cnt) {
*sts = XNAV__NOVALIDCURVE;
free(gcd);
gcd = 0;
return;
}
// Subscribe to object
strcpy( attr_name, fast_name);
strcat( attr_name, ".New");
*sts = gdh_RefObjectInfo( attr_name, (pwr_tAddress *)&new_p,
&new_subid, sizeof(pwr_tBoolean));
if ( EVEN(*sts)) return;
for ( i = 0; i < fast_cnt; i++) {
switch( type[i]) {
case pwr_eType_Float32:
case pwr_eType_Int32:
case pwr_eType_UInt32:
element_size[i] = 4;
break;
case pwr_eType_Float64:
case pwr_eType_Int64:
case pwr_eType_UInt64:
element_size[i] = 8;
break;
case pwr_eType_Int16:
case pwr_eType_UInt16:
element_size[i] = 2;
break;
case pwr_eType_Int8:
case pwr_eType_UInt8:
element_size[i] = 1;
break;
default:
element_size[i] = 4;
}
gcd->rows[i] = max_points;
}
gcd->cols = fast_cnt;
axis_configured = true;
for ( i = 0; i < FAST_CURVES; i++) {
if ( fp.CurveValid[i]) {
j = fast_idx[i];
if ( fp.YMinValue[i] != fp.YMaxValue[i])
gcd->scale( gcd->y_axis_type[j], gcd->y_value_type[j],
fp.YMinValue[i], fp.YMaxValue[i],
&gcd->y_min_value_axis[j], &gcd->y_max_value_axis[j],
&gcd->y_trend_lines[j], &gcd->y_axis_lines[j], &gcd->y_axis_linelongq[j],
&gcd->y_axis_valueq[j], gcd->y_format[j], &gcd->y_axis_width[j], 1, 1);
else
axis_configured = false;
}
}
if ( fp.Active)
first_scan = 0;
fast_scan( this);
gcd->select_color( 0);
if ( strcmp( fp.Title, "") != 0)
strcpy( title, fp.Title);
else
cdh_StrncpyCutOff( title, name, sizeof(title), 1);
// timerid = XtAppAddTimeOut(
// XtWidgetToApplicationContext(parent_widget), 1000,
// (XtTimerCallbackProc)fast_scan, this);
}
int XNav::getAllMenuItems( xmenu_sMenuCall *ip,
xmenu_sMenuItem **Item,
pwr_tObjid objid,
pwr_tUInt32 Level,
int *nItems,
int AddSeparator,
pwr_sAttrRef *CurrentObject)
{
int sts;
pwr_tCid classid;
pwr_tObjid child;
pwr_sMenuButton *mbp;
pwr_sMenuCascade *mcp;
pwr_sMenuRef *mrp;
pwr_tStatus (*filter)( xmenu_sMenuCall *);
int sensitive;
int i;
Level++;
memset(*Item, 0, sizeof(**Item));
if(AddSeparator) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Separator;
(*Item)->MenuObject = pwr_cNObjid;
(*Item)++;
(*nItems)++;
}
else {
sts = gdh_GetObjectClass( objid, &classid);
if ( EVEN(sts)) return sts;
if ( classid == pwr_eClass_MenuButton) {
sts = gdh_ObjidToPointer( objid, (void **) &mbp);
if ( EVEN(sts)) return sts;
ip->ChosenItem = *nItems;
for ( i = 0; i < 5; i++) {
strcpy( (*Item)->FilterArguments[i], mbp->FilterArguments[i]);
}
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
sensitive = 1;
if ( strcmp( mbp->FilterName, "") != 0) {
sts = GetMethod( mbp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
if ( sts == XNAV__INSENSITIVE)
sensitive = 0;
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Button;
(*Item)->MenuObject = objid;
(*Item)->Flags.f.Sensitive = sensitive;
if (strcmp( mbp->MethodName, "") == 0)
(*Item)->Flags.f.Sensitive = 0;
strcpy((*Item)->Name, mbp->ButtonName);
strcpy( (*Item)->Method, mbp->MethodName);
strcpy( (*Item)->Filter, mbp->FilterName);
for ( i = 0; i < 5; i++) {
strcpy( (*Item)->MethodArguments[i], mbp->MethodArguments[i]);
}
(*Item)++;
(*nItems)++;
}
}
else if ( classid == pwr_eClass_MenuSeparator) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Separator;
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
}
else if ( classid == pwr_eClass_MenuCascade) {
sts = gdh_ObjidToPointer( objid, (void **) &mcp);
if ( EVEN(sts)) return sts;
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
if ( strcmp( mcp->FilterName, "") != 0) {
sts = GetMethod( mcp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Cascade;
(*Item)->Flags.f.Sensitive = 1;
strcpy((*Item)->Name, mcp->ButtonName);
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
sts = gdh_GetChild( objid, &child);
while( ODD(sts)) {
sts = getAllMenuItems(ip, Item, child, Level, nItems, 0, CurrentObject);
if ( EVEN(sts)) return sts;
sts = gdh_GetNextSibling( child, &child);
}
}
}
else if ( classid == pwr_eClass_MenuRef &&
cdh_ObjidIsNull( CurrentObject->Objid)) {
pwr_tAName aname;
pwr_sAttrRef currentar;
pwr_tCid current_cid;
pwr_tTid a_tid;
pwr_tUInt32 a_size, a_offs, a_elem;
sts = gdh_ObjidToPointer( objid, (void **) &mrp);
if ( EVEN(sts)) return sts;
// Call any filter method
(*Item)->CurrentObject = *CurrentObject;
if ( strcmp( mrp->FilterName, "") != 0) {
sts = GetMethod( mrp->FilterName, &filter);
if ( ODD(sts)) {
sts = (filter) ( ip);
}
}
else
sts = XNAV__SUCCESS;
if ( ODD(sts)) {
int create_object_button = 0;
if ( strcmp( mrp->RefAttribute, "_SelfObject") == 0) {
// Object entry for attributes
char *s;
sts = gdh_AttrrefToName( &ip->Pointed, aname, sizeof(aname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
if ( (s = strrchr( aname, '.')))
*s = 0;
sts = gdh_NameToAttrref( pwr_cNOid, aname, ¤tar);
if ( EVEN(sts)) return sts;
}
else {
sts = gdh_AttrrefToName( &ip->Pointed, aname, sizeof(aname), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( aname, ".");
strcat( aname, mrp->RefAttribute);
sts = gdh_GetAttributeCharacteristics( aname, &a_tid, &a_size,
&a_offs, &a_elem);
if ( ODD(sts)) {
switch ( a_tid) {
case pwr_eType_AttrRef:
sts = gdh_GetObjectInfo( aname, ¤tar, sizeof(currentar));
break;
case pwr_eType_Objid: {
pwr_tOid oid;
currentar = pwr_cNAttrRef;
sts = gdh_GetObjectInfo( aname, &oid, sizeof(oid));
currentar = cdh_ObjidToAref( oid);
break;
}
default:
sts = 0;
}
}
create_object_button = 0;
}
if ( ODD(sts) && cdh_ObjidIsNotNull( currentar.Objid)) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Ref;
(*Item)->Flags.f.Sensitive = 1;
strcpy((*Item)->Name, mrp->ButtonName);
(*Item)->MenuObject = objid;
(*Item)++;
(*nItems)++;
// Create a label with current object name
sts = gdh_AttrrefToName( ¤tar, aname, sizeof(aname),
cdh_mNName);
if ( ODD(sts) && create_object_button) {
(*Item)->Level = Level;
(*Item)->Item = xmenu_eMenuItem_Button;
(*Item)->MenuObject = pwr_cNObjid;
strncpy((*Item)->Name, aname, sizeof((*Item)->Name));
(*Item)->Name[sizeof((*Item)->Name)-1] = 0;
(*Item)->MenuObject = pwr_cNObjid;
(*Item)->CurrentObject = currentar;
(*Item)->Flags.f.Sensitive = 1;
strcpy( (*Item)->Method, "$Object-OpenObject");
(*Item)++;
(*nItems)++;
}
sts = gdh_GetAttrRefTid( ¤tar, ¤t_cid);
if ( EVEN(sts)) return sts;
xmenu_eItemType item_type = ip->ItemType;
if ( currentar.Flags.b.Object)
ip->ItemType = xmenu_eItemType_Object;
else
ip->ItemType = xmenu_eItemType_AttrObject;
sts = GetObjectMenu(ip, current_cid, Item, Level, nItems, 0, ¤tar);
if ( EVEN(sts)) return sts;
ip->ItemType = item_type;
}
}
}
}
return XNAV__SUCCESS;
}
int Graph::init_object_graph( int mode)
{
char classname[120];
pwr_tClassId classid;
char *s;
int sts;
int i;
int is_type = 0;
pwr_sAttrRef attrref;
if ( mode == 0) {
if ( strcmp( filename, "_none_.pwg") == 0) {
if ( strcmp( object_name[0], "collect") == 0) {
sts = graph_object_collect_build( this, 0);
return sts;
}
}
return 1;
}
if ( strcmp( filename, "_none_.pwg") == 0) {
if ( strcmp( object_name[0], "collect") == 0)
return 1;
}
// Get class from filename
if ( (s = strrchr( filename, '/')) ||
(s = strrchr( filename, '>')) ||
(s = strrchr( filename, ']')) ||
(s = strrchr( filename, ':')))
{
if ( strncmp( s+1, "pwr_t_", 6) == 0)
{
is_type = 1;
strcpy( classname, s+7);
}
else if ( strncmp( s+1, "pwr_c_", 6) == 0)
strcpy( classname, s+7);
else
strcpy( classname, s+1);
}
else
strcpy( classname, filename);
if ( (s = strrchr( classname, '.')))
*s = 0;
if ( is_type)
{
sts = gdh_NameToAttrref( pwr_cNObjid, object_name[0], &attrref);
if ( EVEN(sts)) return sts;
// Types are removed
return 0;
}
else
{
sts = gdh_ClassNameToId( classname, &classid);
if ( EVEN(sts)) return sts;
sts = gdh_NameToAttrref( pwr_cNObjid, object_name[0], &attrref);
if ( EVEN(sts)) return sts;
for ( i = 0; graph_object_functions[i].classid; i++)
{
if ( classid == graph_object_functions[i].classid)
{
sts = (graph_object_functions[i].func)( this, &attrref);
return sts;
}
}
}
return 0;
}
//
// Callbacks from brow
//
int XAttNav::brow_cb( FlowCtx *ctx, flow_tEvent event)
{
XAttNav *xattnav;
Item *item;
if ( event->event == flow_eEvent_ObjectDeleted) {
brow_GetUserData( event->object.object, (void **)&item);
delete item;
return 1;
}
brow_GetCtxUserData( (BrowCtx *)ctx, (void **) &xattnav);
xattnav->message( ' ', "");
switch ( event->event) {
case flow_eEvent_Key_Up: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetLastVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( xattnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetLastVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetPrevious( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.25);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_Key_Down: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count) {
sts = brow_GetFirstVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
if ( !brow_IsVisible( xattnav->brow->ctx, node_list[0], flow_eVisible_Partial)) {
sts = brow_GetFirstVisible( xattnav->brow->ctx, &object);
if ( EVEN(sts)) return 1;
}
else {
sts = brow_GetNext( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
if ( node_count)
free( node_list);
return 1;
}
}
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.75);
if ( node_count)
free( node_list);
break;
}
case flow_eEvent_SelectClear:
brow_ResetSelectInverse( xattnav->brow->ctx);
break;
case flow_eEvent_MB1Click: {
// Select
double ll_x, ll_y, ur_x, ur_y;
int sts;
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_MeasureNode( event->object.object, &ll_x, &ll_y,
&ur_x, &ur_y);
if ( event->object.x < ll_x + 1.0) {
// Simulate doubleclick
flow_tEvent doubleclick_event;
doubleclick_event = (flow_tEvent) calloc( 1, sizeof(*doubleclick_event));
memcpy( doubleclick_event, event, sizeof(*doubleclick_event));
doubleclick_event->event = flow_eEvent_MB1DoubleClick;
sts = brow_cb( ctx, doubleclick_event);
free( (char *) doubleclick_event);
return sts;
}
if ( brow_FindSelectedObject( xattnav->brow->ctx, event->object.object)) {
brow_SelectClear( xattnav->brow->ctx);
}
else {
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( event->object.object, 1);
brow_SelectInsert( xattnav->brow->ctx, event->object.object);
}
break;
default:
brow_SelectClear( xattnav->brow->ctx);
}
break;
}
case flow_eEvent_Key_PageDown: {
brow_Page( xattnav->brow->ctx, 0.8);
break;
}
case flow_eEvent_Key_PageUp: {
brow_Page( xattnav->brow->ctx, -0.8);
break;
}
case flow_eEvent_ScrollDown: {
brow_Page( xattnav->brow->ctx, 0.1);
break;
}
case flow_eEvent_ScrollUp: {
brow_Page( xattnav->brow->ctx, -0.1);
break;
}
case flow_eEvent_Key_Left: {
brow_tNode *node_list;
int node_count;
brow_tObject object;
int sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
if ( brow_IsOpen( node_list[0]))
// Close this node
object = node_list[0];
else {
// Close parent
sts = brow_GetParent( xattnav->brow->ctx, node_list[0], &object);
if ( EVEN(sts)) {
free( node_list);
return 1;
}
}
brow_GetUserData( object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
((ItemAttr *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrArrayElem:
((ItemAttrArrayElem *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->close( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->close( xattnav->brow, 0, 0);
break;
default:
;
}
brow_SelectClear( xattnav->brow->ctx);
brow_SetInverse( object, 1);
brow_SelectInsert( xattnav->brow->ctx, object);
if ( !brow_IsVisible( xattnav->brow->ctx, object, flow_eVisible_Full))
brow_CenterObject( xattnav->brow->ctx, object, 0.25);
free( node_list);
break;
}
case flow_eEvent_MB3Down: {
brow_SetClickSensitivity( xattnav->brow->ctx,
flow_mSensitivity_MB3Press);
break;
}
case flow_eEvent_MB3Press: {
// Popup menu
int x, y;
pwr_sAttrRef attrref;
int sts;
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
if ( cdh_ObjidIsNull( item->objid))
break;
xattnav->popup_position( event->any.x_pixel + 8, event->any.y_pixel, &x, &y);
memset( &attrref, 0, sizeof(attrref));
switch ( item->type) {
case xnav_eItemType_Attr:
case xnav_eItemType_AttrArrayElem:
case xnav_eItemType_AttrObject: {
pwr_tAName attr_str;
sts = gdh_ObjidToName( item->objid,
attr_str, sizeof(attr_str), cdh_mName_volumeStrict);
if ( EVEN(sts)) return sts;
strcat( attr_str, ".");
strcat( attr_str, item->name);
sts = gdh_NameToAttrref( pwr_cNObjid, attr_str, &attrref);
if ( EVEN(sts)) return sts;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Attribute,
(unsigned long)xmenu_mUtility_AttrEditor, NULL, x, y);
break;
}
case xnav_eItemType_Collect: {
sts = gdh_NameToAttrref( pwr_cNObjid, item->name, &attrref);
if ( EVEN(sts)) return sts;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Attribute,
(unsigned long)xmenu_mUtility_AttrEditor, NULL, x, y);
break;
}
case xnav_eItemType_Crossref: {
ItemCrossref *itemc = (ItemCrossref *)item;
memset( &attrref, 0, sizeof(attrref));
attrref.Objid = itemc->objid;
(xattnav->popup_menu_cb)( xattnav->parent_ctx, attrref,
(unsigned long)xmenu_eItemType_Crossref,
(unsigned long)xmenu_mUtility_AttrEditor,
itemc->ref_name, x, y);
break;
}
default:
;
}
break;
default:
;
}
break;
}
case flow_eEvent_Key_Right: {
brow_tNode *node_list;
int node_count;
pwr_tStatus sts;
brow_GetSelectedNodes( xattnav->brow->ctx, &node_list, &node_count);
if ( !node_count)
return 1;
brow_GetUserData( node_list[0], (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
case xnav_eItemType_AttrArrayElem:
case xnav_eItemType_Collect:
sts = item->open_children( xattnav->brow, 0, 0);
if (ODD(sts)) break;
if ( xattnav->advanced_user && xattnav->change_value_cb)
(xattnav->change_value_cb)( xattnav->parent_ctx);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->open_attributes( xattnav->brow, 0, 0);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->open_attributes( xattnav->brow, 0, 0);
break;
case xnav_eItemType_Enum:
if ( xattnav->advanced_user)
((ItemEnum *)item)->set_value();
break;
case xnav_eItemType_Mask:
if ( xattnav->advanced_user)
((ItemMask *)item)->toggle_value();
break;
default:
;
}
free( node_list);
break;
}
case flow_eEvent_MB1DoubleClick:
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Attr:
((ItemAttr *)item)->open_children( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrArray:
((ItemAttrArray *)item)->open_attributes( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrObject:
((ItemAttrObject *)item)->open_attributes( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_AttrArrayElem:
((ItemAttrArrayElem *)item)->open_children( xattnav->brow,
event->object.x, event->object.y);
break;
case xnav_eItemType_Crossref:
if ( xattnav->start_trace_cb) {
(xattnav->start_trace_cb)( xattnav->parent_ctx, item->objid,
((ItemCrossref *)item)->ref_name);
if ( xattnav->close_cb) {
(xattnav->close_cb)( xattnav->parent_ctx);
return 1;
}
}
break;
default:
;
}
break;
default:
;
}
break;
case flow_eEvent_Radiobutton: {
switch ( event->object.object_type) {
case flow_eObjectType_Node:
brow_GetUserData( event->object.object, (void **)&item);
switch( item->type) {
case xnav_eItemType_Enum:
if ( !event->radiobutton.value)
((ItemEnum *)item)->set_value();
break;
case xnav_eItemType_Mask:
((ItemMask *)item)->set_value( !event->radiobutton.value);
break;
default:
;
}
break;
default:
;
}
break;
}
case flow_eEvent_Map: {
xattnav->displayed = 1;
break;
}
default:
;
}
return 1;
}
