EvMotif::EvMotif( void *ev_parent_ctx, Widget ev_parent_wid, char *eve_name, char *ala_name, char *blk_name, pwr_tObjid ev_user, int display_ala, int display_eve, int display_blk, int display_return, int display_ack, int ev_beep, pwr_tMask ev_pop_mask, int ev_eventname_seg, pwr_tStatus *status) : Ev( ev_parent_ctx, eve_name, ala_name, blk_name, ev_user, display_ala, display_eve, display_blk, display_return, display_ack, ev_beep, ev_pop_mask, ev_eventname_seg, status), parent_wid(ev_parent_wid), parent_wid_eve(NULL), parent_wid_ala(NULL) { char uid_filename[120] = {"xtt_eve.uid"}; char *uid_filename_p = uid_filename; Arg args[20]; pwr_tStatus sts; int i; pwr_sClass_User *userobject_ptr; MrmHierarchy s_DRMh; MrmType dclass; static char eve_translations[] = "<FocusIn>: eve_inputfocus()\n"; static char ala_translations[] = "<FocusIn>: ala_inputfocus()\n"; static char blk_translations[] = "<FocusIn>: blk_inputfocus()\n"; static XtTranslations eve_compiled_translations = NULL; static XtTranslations ala_compiled_translations = NULL; static XtTranslations blk_compiled_translations = NULL; static XtActionsRec eve_actions[] = { {(char*) "eve_inputfocus", (XtActionProc) eve_action_inputfocus} }; static XtActionsRec ala_actions[] = { {(char*) "ala_inputfocus", (XtActionProc) ala_action_inputfocus} }; static XtActionsRec blk_actions[] = { {(char*) "blk_inputfocus", (XtActionProc) blk_action_inputfocus} }; static MrmRegisterArg reglist[] = { {(char*) "ev_ctx", 0 }, {(char*) "ev_eve_activate_exit",(caddr_t)eve_activate_exit }, {(char*) "ev_eve_activate_print",(caddr_t)eve_activate_print }, {(char*) "ev_eve_activate_ack_last",(caddr_t)eve_activate_ack_last }, {(char*) "ev_eve_activate_zoom_in",(caddr_t)eve_activate_zoom_in }, {(char*) "ev_eve_activate_zoom_out",(caddr_t)eve_activate_zoom_out }, {(char*) "ev_eve_activate_zoom_reset",(caddr_t)eve_activate_zoom_reset }, {(char*) "ev_eve_activate_open_plc",(caddr_t)eve_activate_open_plc }, {(char*) "ev_eve_activate_display_in_xnav",(caddr_t)eve_activate_display_in_xnav }, {(char*) "ev_eve_activate_disp_hundredth",(caddr_t)eve_activate_disp_hundredth }, {(char*) "ev_eve_activate_hide_object",(caddr_t)eve_activate_hide_object }, {(char*) "ev_eve_activate_hide_text",(caddr_t)eve_activate_hide_text }, {(char*) "ev_eve_activate_help",(caddr_t)eve_activate_help }, {(char*) "ev_eve_activate_helpevent",(caddr_t)eve_activate_helpevent }, {(char*) "ev_eve_create_form",(caddr_t)eve_create_form }, {(char*) "ev_ala_activate_exit",(caddr_t)ala_activate_exit }, {(char*) "ev_ala_activate_print",(caddr_t)ala_activate_print }, {(char*) "ev_ala_activate_ack_last",(caddr_t)ala_activate_ack_last }, {(char*) "ev_ala_activate_zoom_in",(caddr_t)ala_activate_zoom_in }, {(char*) "ev_ala_activate_zoom_out",(caddr_t)ala_activate_zoom_out }, {(char*) "ev_ala_activate_zoom_reset",(caddr_t)ala_activate_zoom_reset }, {(char*) "ev_ala_activate_open_plc",(caddr_t)ala_activate_open_plc }, {(char*) "ev_ala_activate_display_in_xnav",(caddr_t)ala_activate_display_in_xnav }, {(char*) "ev_ala_activate_disp_hundredth",(caddr_t)ala_activate_disp_hundredth }, {(char*) "ev_ala_activate_hide_object",(caddr_t)ala_activate_hide_object }, {(char*) "ev_ala_activate_hide_text",(caddr_t)ala_activate_hide_text }, {(char*) "ev_ala_activate_help",(caddr_t)ala_activate_help }, {(char*) "ev_ala_activate_helpevent",(caddr_t)ala_activate_helpevent }, {(char*) "ev_ala_create_form",(caddr_t)ala_create_form }, {(char*) "ev_blk_activate_exit",(caddr_t)blk_activate_exit }, {(char*) "ev_blk_activate_print",(caddr_t)blk_activate_print }, {(char*) "ev_blk_activate_zoom_in",(caddr_t)blk_activate_zoom_in }, {(char*) "ev_blk_activate_zoom_out",(caddr_t)blk_activate_zoom_out }, {(char*) "ev_blk_activate_zoom_reset",(caddr_t)blk_activate_zoom_reset }, {(char*) "ev_blk_activate_block_remove",(caddr_t)blk_activate_block_remove }, {(char*) "ev_blk_activate_open_plc",(caddr_t)blk_activate_open_plc }, {(char*) "ev_blk_activate_display_in_xnav",(caddr_t)blk_activate_display_in_xnav }, {(char*) "ev_blk_activate_help",(caddr_t)blk_activate_help }, {(char*) "ev_blk_create_form",(caddr_t)blk_create_form } }; static int reglist_num = (sizeof reglist / sizeof reglist[0]); *status = 1; Lng::get_uid( uid_filename, uid_filename); // Check user object if ( cdh_ObjidIsNull( user)) { *status = XNAV__NOUSER; return; } sts = gdh_ObjidToPointer ( user, (pwr_tAddress *) &userobject_ptr); if ( EVEN(sts)) { *status = XNAV__NOUSER; return; } ala_size = userobject_ptr->MaxNoOfAlarms; eve_size = userobject_ptr->MaxNoOfEvents; blk_size = 0; create_aliaslist( userobject_ptr); reglist[0].value = (caddr_t) this; // Motif MrmInitialize(); // Save the context structure in the widget i = 0; XtSetArg(args[i], XmNuserData, (XtPointer) this);i++; XtSetArg(args[i], XmNdeleteResponse, XmDO_NOTHING);i++; sts = MrmOpenHierarchy( 1, &uid_filename_p, NULL, &s_DRMh); if (sts != MrmSUCCESS) printf("can't open %s\n", uid_filename); MrmRegisterNames(reglist, reglist_num); parent_wid_eve = XtCreatePopupShell( eve_name, topLevelShellWidgetClass, parent_wid, args, i); sts = MrmFetchWidgetOverride( s_DRMh, (char*) "eve_window", parent_wid_eve, eve_name, args, 1, &toplevel_eve, &dclass); if (sts != MrmSUCCESS) printf("can't fetch %s\n", eve_name); parent_wid_ala = XtCreatePopupShell( ala_name, topLevelShellWidgetClass, parent_wid, args, i); sts = MrmFetchWidgetOverride( s_DRMh, (char*) "ala_window", parent_wid_ala, ala_name, args, 1, &toplevel_ala, &dclass); if (sts != MrmSUCCESS) printf("can't fetch %s\n", ala_name); parent_wid_blk = XtCreatePopupShell( blk_name, topLevelShellWidgetClass, parent_wid, args, i); sts = MrmFetchWidgetOverride( s_DRMh, (char*) "blk_window", parent_wid_blk, blk_name, args, 1, &toplevel_blk, &dclass); if (sts != MrmSUCCESS) printf("can't fetch %s\n", blk_name); MrmCloseHierarchy(s_DRMh); if ( eve_compiled_translations == NULL) { XtAppAddActions( XtWidgetToApplicationContext( toplevel_eve), eve_actions, XtNumber(eve_actions)); eve_compiled_translations = XtParseTranslationTable( eve_translations); } XtOverrideTranslations( toplevel_eve, eve_compiled_translations); if ( ala_compiled_translations == NULL) { XtAppAddActions( XtWidgetToApplicationContext( toplevel_ala), ala_actions, XtNumber(ala_actions)); ala_compiled_translations = XtParseTranslationTable( ala_translations); } XtOverrideTranslations( toplevel_ala, ala_compiled_translations); if ( blk_compiled_translations == NULL) { XtAppAddActions( XtWidgetToApplicationContext( toplevel_blk), blk_actions, XtNumber(blk_actions)); blk_compiled_translations = XtParseTranslationTable( blk_translations); } XtOverrideTranslations( toplevel_blk, blk_compiled_translations); i = 0; XtSetArg(args[i],XmNwidth,700);i++; XtSetArg(args[i],XmNheight,600);i++; XtSetValues( toplevel_eve ,args,i); i = 0; XtSetArg(args[i],XmNwidth,700);i++; XtSetArg(args[i],XmNheight,300);i++; XtSetValues( toplevel_ala ,args,i); i = 0; XtSetArg(args[i],XmNwidth,700);i++; XtSetArg(args[i],XmNheight,300);i++; XtSetValues( toplevel_blk ,args,i); XtManageChild( toplevel_eve); XtManageChild( toplevel_ala); XtManageChild( toplevel_blk); // Create ala and eve... eve = new EvListMotif( this, form_eve, ev_eType_EventList, eve_size, eventname_seg, &eve_widget); eve->start_trace_cb = &eve_start_trace_cb; eve->display_in_xnav_cb = &eve_display_in_xnav_cb; eve->name_to_alias_cb = &ev_name_to_alias_cb; eve->popup_menu_cb = &ev_popup_menu_cb; ala = new EvListMotif( this, form_ala, ev_eType_AlarmList, ala_size, eventname_seg, &ala_widget); ala->start_trace_cb = &ala_start_trace_cb; ala->display_in_xnav_cb = &ala_display_in_xnav_cb; ala->name_to_alias_cb = &ev_name_to_alias_cb; ala->popup_menu_cb = &ev_popup_menu_cb; ala->sound_cb = &ev_sound_cb; blk = new EvListMotif( this, form_blk, ev_eType_BlockList, blk_size, eventname_seg, &blk_widget); blk->start_trace_cb = &blk_start_trace_cb; blk->display_in_xnav_cb = &blk_display_in_xnav_cb; blk->popup_menu_cb = &ev_popup_menu_cb; // blk->hide_text = 1; // XtManageChild( form_widget); if ( display_eve) { XtPopup( parent_wid_eve, XtGrabNone); eve_displayed = 1; } else XtRealizeWidget( parent_wid_eve); if ( display_ala) { XtPopup( parent_wid_ala, XtGrabNone); ala_displayed = 1; } else XtRealizeWidget( parent_wid_ala); if ( display_blk) { XtPopup( parent_wid_blk, XtGrabNone); blk_displayed = 1; } else XtRealizeWidget( parent_wid_blk); // Connect the window manager close-button to exit flow_AddCloseVMProtocolCb( parent_wid_eve, (XtCallbackProc)eve_activate_exit, this); flow_AddCloseVMProtocolCb( parent_wid_ala, (XtCallbackProc)ala_activate_exit, this); flow_AddCloseVMProtocolCb( parent_wid_blk, (XtCallbackProc)blk_activate_exit, this); wow = new CoWowMotif( toplevel_ala); // Store this for the mh callbacks ev = this; sts = outunit_connect( user); if ( EVEN(sts)) *status = sts; }
int main(int argc, char *argv[]) { pwr_tStatus sts; char remote_address[40]; char remote_host_name[40]; rpvd_sMsg *msg; rpvd_sMsgAny umsg; rpvd_sMsgAny *rmsg; int udp_port; /* Read arguments */ if ( argc < 3) { usage(); exit(0); } strcpy( remote_address, argv[1]); strcpy( remote_host_name, argv[2]); if ( argc >= 4) { sts = sscanf( argv[3], "%d", &udp_port); if ( sts != 1) { usage(); exit(0); } } else udp_port = 3051; sts = udp_Init( remote_address, remote_host_name, udp_port); if ( EVEN(sts)) { exit(0); } sts = gdh_Init( "remote_pvd_pwrsrv"); if ( EVEN(sts)) return sts; umsg.Type = rpvd_eMsg_NodeUp; umsg.Id = 0; sts = udp_Request( (char *)&umsg, sizeof(umsg), (char **)&rmsg); if ( ODD(sts) && sts != REM__TIMEOUT && ODD(rmsg->Status)) printf( "Link up\n"); for (;;) { sts = udp_Receive( (char **)&msg, 5000); if ( sts == REM__TIMEOUT) { printf( "Alive\n"); } else if ( ODD(sts)) { switch ( msg->Any.Type) { case rpvd_eMsg_Oid: pwrsrv_Oid( &msg->Oid); break; case rpvd_eMsg_ObjectName: pwrsrv_ObjectName( &msg->ObjectName); break; case rpvd_eMsg_ReadAttribute: pwrsrv_ReadAttribute( &msg->ReadAttribute); break; case rpvd_eMsg_WriteAttribute: pwrsrv_WriteAttribute( &msg->WriteAttribute); break; case rpvd_eMsg_SubAdd: pwrsrv_SubAdd( &msg->SubAdd); break; case rpvd_eMsg_SubRemove: pwrsrv_SubRemove( &msg->SubRemove); break; case rpvd_eMsg_SubRequest: pwrsrv_SubSend( &msg->Any); break; case rpvd_eMsg_NodeUp: pwrsrv_NodeUp( &msg->Any); break; } } } }
int goen_create_nodetype_m15( pwr_sGraphPlcNode *graphbody, pwr_tClassId cid, ldh_tSesContext ldhses, flow_tCtx ctx, unsigned int *mask, unsigned long subwindowmark, unsigned long node_width, flow_tNodeClass *node_class, vldh_t_node node) { int i; int inputpoints, outputpoints; unsigned long pointmask; unsigned int *inmask_pointer; unsigned int *outmask_pointer; unsigned int *invertmask_pointer; int inputs; int interns; int outputs; int sts, size; int first_input, second_input; ldh_sParDef *bodydef; int rows; int inputcount; char annot_str[3][80]; int annot_nr[3]; int annot_count; double annot_width[3]; double annot_height; float f_width_left; float annot2_width; float annot3_width; char annot3_found; flow_tNodeClass nc_pid; char name[80]; int conpoint_nr; int annot_rows; static int idx = 0; flow_tObject cp; sts = ldh_ClassIdToName(ldhses, cid, name, sizeof(name), &size); if ( EVEN(sts) ) return sts; sprintf( &name[strlen(name)], "%d", idx++); /* Get the runtime paramteers for this class */ sts = ldh_GetObjectBodyDef(ldhses, cid, "RtBody", 1, &bodydef, &rows); if ( EVEN(sts) ) return sts; /* Get number of annotations and the width of the annotations */ sts = WGre::get_annotations( node, (char *)annot_str, annot_nr, &annot_count, sizeof( annot_str)/sizeof(annot_str[0]), sizeof( annot_str[0])); if ( EVEN(sts)) return sts; if ( annot_count > 0) { flow_MeasureAnnotText( ctx, annot_str[0], flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, &annot_width[0], &annot_height, &annot_rows); } if ( annot_count > 1) { flow_MeasureAnnotText( ctx, annot_str[1], flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, &annot_width[1], &annot_height, &annot_rows); } if ( annot_count > 2) { flow_MeasureAnnotText( ctx, annot_str[2], flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, &annot_width[2], &annot_height, &annot_rows); } /* Find the widths for annotation 2 and 3 */ annot3_found = 0; annot2_width = 0; for ( i = 1; i < annot_count; i++) { if ( annot_nr[i] == 2) annot2_width = annot_width[i]; if ( annot_nr[i] == 3) { annot3_width = annot_width[i]; annot3_found = 1; } } /* Get how many parameters there are */ inputs = graphbody->parameters[PAR_INPUT]; interns = graphbody->parameters[PAR_INTERN]; outputs = graphbody->parameters[PAR_OUTPUT]; inmask_pointer = mask++; outmask_pointer = mask++; invertmask_pointer = mask; /* Check if first input in mask (first bit) */ pointmask = 1; first_input = ((*inmask_pointer & pointmask) != 0); pointmask = 2; second_input = ((*inmask_pointer & pointmask) != 0); inputpoints = first_input + second_input; /* Check if output in mask (first bit) */ pointmask = 1; outputpoints = 0; outputpoints += ((*outmask_pointer & pointmask) != 0); f_classnamewidth = f_strlength * (strlen( graphbody->graphname) + 2); f_height = f_repeat * 2; if ( !annot3_found) f_width = co_max( f_strlength * 2 + co_max( annot_width[0], annot2_width), f_defwidth) + f_classnamewidth; else { f_width = co_max( f_strlength * 4 + co_max( annot_width[0], annot2_width) + annot3_width, f_defwidth + f_strlength * 2) + f_classnamewidth; f_width_left = f_strlength * 2 + annot3_width; } flow_CreateNodeClass(ctx, name, flow_eNodeGroup_Common, &nc_pid); /* Draw the rectangle for gate */ flow_AddRect( nc_pid, 0, -f_yoffs, f_width, f_height, flow_eDrawType_Line, 2, flow_mDisplayLevel_1); if ( subwindowmark == 0 ) { flow_AddLine( nc_pid, f_classnamewidth, -f_yoffs, f_classnamewidth, f_height - f_yoffs, flow_eDrawType_Line, 2); } else { flow_AddLine( nc_pid, f_classnamewidth, -f_yoffs, f_classnamewidth, f_height - f_yoffs, flow_eDrawType_LineGray, 4); } if ( annot3_found) { /* Draw line for second annotation */ flow_AddLine( nc_pid, f_width - f_width_left, -f_yoffs, f_width - f_width_left, f_height - f_yoffs, flow_eDrawType_Line, 2); } flow_AddText( nc_pid, graphbody->graphname, f_strlength, f_height/4 + f_strheight/2 - f_yoffs, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE); /* Draw the leadnames and lines */ conpoint_nr = 0; if ( first_input ) { if ( (*invertmask_pointer & 1) == 0) { flow_AddLine( nc_pid, -f_pinlength, f_height/4 - f_yoffs, 0, f_height/4 - f_yoffs, flow_eDrawType_Line, 2); } else { flow_AddLine( nc_pid, -f_pinlength, f_height/4 - f_yoffs, -f_circle, f_height/4 - f_yoffs, flow_eDrawType_Line, 2); flow_AddArc( nc_pid, -f_circle, f_height/4 - f_circle / 2 - f_yoffs, 0, f_height/4 + f_circle / 2 - f_yoffs, 0, 360, flow_eDrawType_Line, 2); } flow_AddConPoint( nc_pid, -f_pinlength, f_height/4 - f_yoffs, conpoint_nr++, flow_eDirection_Left); } if ( second_input ) { /* Get the graphname of second input parameter */ inputcount = 0; for ( i = 0; i < rows; i++) { if ( bodydef[i].ParClass == pwr_eClass_Input) { inputcount++; if (inputcount == 2) /* This is the second input */ break; } } flow_AddText( nc_pid, bodydef[i].Par->Input.Graph.GraphName, f_strlength, f_height*3/4 + f_strheight/2 - f_yoffs, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE); if ( (*invertmask_pointer & 2) == 0) { flow_AddLine( nc_pid, -f_pinlength, f_height*3/4 - f_yoffs, 0, f_height*3/4 - f_yoffs, flow_eDrawType_Line, 2); } else { flow_AddLine( nc_pid, -f_pinlength, f_height*3/4 - f_yoffs, -f_circle, f_height*3/4 - f_yoffs, flow_eDrawType_Line, 2); flow_AddArc( nc_pid, -f_circle, f_height*3/4 - f_circle / 2 - f_yoffs, 0, f_height*3/4 + f_circle / 2 - f_yoffs, 0, 360, flow_eDrawType_Line, 2); } flow_AddConPoint( nc_pid, -f_pinlength, f_height*3/4 - f_yoffs, conpoint_nr++, flow_eDirection_Left); } if (outputpoints != 0) { flow_AddLine( nc_pid, f_width, f_height/4 - f_yoffs, f_width+f_pinlength, f_height/4 - f_yoffs, flow_eDrawType_Line, 2); flow_CreateConPoint( ctx, f_width + f_pinlength, f_height/4 - f_yoffs, conpoint_nr++, flow_eDirection_Right, &cp); flow_NodeClassAdd( nc_pid, cp); if (bodydef[inputs+interns].Par->Output.Info.Type == pwr_eType_Float32) flow_SetTraceAttr( cp, NULL, bodydef[inputs+interns].Par->Output.Info.PgmName, flow_eTraceType_Float32, 0); else if (bodydef[inputs+interns].Par->Output.Info.Type == pwr_eType_Int32) flow_SetTraceAttr( cp, NULL, bodydef[inputs+interns].Par->Output.Info.PgmName, flow_eTraceType_Int32, 0); else if (bodydef[inputs+interns].Par->Output.Info.Type == pwr_eType_Boolean) flow_SetTraceAttr( cp, NULL, bodydef[inputs+interns].Par->Output.Info.PgmName, flow_eTraceType_Boolean, 0); } f_namelength = f_strlength*6; f_node_width = node_width; flow_AddAnnot( nc_pid, f_classnamewidth + f_strlength, f_height/4 + f_strheight/2 - f_yoffs, 0, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, flow_mDisplayLevel_1); flow_AddAnnot( nc_pid, f_classnamewidth + f_strlength, f_height/4 + f_strheight/2 + GOEN_F_GRID - f_yoffs, 1, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, flow_mDisplayLevel_1); if ( annot3_found ) { flow_AddAnnot( nc_pid, f_width - f_width_left + f_strlength, GOEN_F_GRID/2 + f_strheight/2 - f_yoffs, 2, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, flow_mDisplayLevel_1); } /* Add execute order display */ flow_AddFilledRect( nc_pid, f_width - GOEN_DISPLAYNODEWIDTH, -f_yoffs, GOEN_DISPLAYNODEWIDTH, GOEN_DISPLAYNODEHEIGHT, flow_eDrawType_LineGray, flow_mDisplayLevel_2); flow_AddAnnot( nc_pid, f_width - GOEN_DISPLAYNODEWIDTH + f_strlength, (GOEN_DISPLAYNODEHEIGHT + f_strheight)/2.0 - f_yoffs, GOEN_DISPLAYNODE_ANNOT, flow_eDrawType_TextHelvetica, GOEN_F_TEXTSIZE, flow_eAnnotType_OneLine, flow_mDisplayLevel_2); free((char *) bodydef); *node_class = nc_pid; return GOEN__SUCCESS; }
/*********************************************************************** * DecodePreviews *********************************************************************** * Decode 10 pictures for the given title. * It assumes that data->reader and data->vts have successfully been * DVDOpen()ed and ifoOpen()ed. **********************************************************************/ static int DecodePreviews( hb_scan_t * data, hb_title_t * title ) { int i, npreviews = 0; hb_buffer_t * buf, * buf_es; hb_list_t * list_es; int progressive_count = 0; int pulldown_count = 0; int doubled_frame_count = 0; int interlaced_preview_count = 0; info_list_t * info_list = calloc( data->preview_count+1, sizeof(*info_list) ); crop_record_t *crops = crop_record_init( data->preview_count ); list_es = hb_list_init(); if( data->batch ) { hb_log( "scan: decoding previews for title %d (%s)", title->index, title->path ); } else { hb_log( "scan: decoding previews for title %d", title->index ); } if (data->bd) { hb_bd_start( data->bd, title ); hb_log( "scan: title angle(s) %d", title->angle_count ); } else if (data->dvd) { hb_dvd_start( data->dvd, title, 1 ); title->angle_count = hb_dvd_angle_count( data->dvd ); hb_log( "scan: title angle(s) %d", title->angle_count ); } else if (data->batch) { data->stream = hb_stream_open( title->path, title, 1 ); } if (title->video_codec == WORK_NONE) { hb_error("No video decoder set!"); return 0; } hb_work_object_t *vid_decoder = hb_get_work(title->video_codec); vid_decoder->codec_param = title->video_codec_param; vid_decoder->title = title; vid_decoder->init( vid_decoder, NULL ); for( i = 0; i < data->preview_count; i++ ) { int j; UpdateState3(data, i + 1); if ( *data->die ) { free( info_list ); crop_record_free( crops ); return 0; } if (data->bd) { if( !hb_bd_seek( data->bd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) { continue; } } if (data->dvd) { if( !hb_dvd_seek( data->dvd, (float) ( i + 1 ) / ( data->preview_count + 1.0 ) ) ) { continue; } } else if (data->stream) { /* we start reading streams at zero rather than 1/11 because * short streams may have only one sequence header in the entire * file and we need it to decode any previews. */ if (!hb_stream_seek(data->stream, (float) i / ( data->preview_count + 1.0 ) ) ) { continue; } } hb_deep_log( 2, "scan: preview %d", i + 1 ); if ( vid_decoder->flush ) vid_decoder->flush( vid_decoder ); hb_buffer_t * vid_buf = NULL; for( j = 0; j < 10240 ; j++ ) { if (data->bd) { if( (buf = hb_bd_read( data->bd )) == NULL ) { if ( vid_buf ) { break; } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } } else if (data->dvd) { if( (buf = hb_dvd_read( data->dvd )) == NULL ) { if ( vid_buf ) { break; } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } } else if (data->stream) { if ( (buf = hb_stream_read( data->stream )) == NULL ) { if ( vid_buf ) { break; } hb_log( "Warning: Could not read data for preview %d, skipped", i + 1 ); goto skip_preview; } } else { // Silence compiler warning buf = NULL; hb_error( "Error: This can't happen!" ); goto skip_preview; } (hb_demux[title->demuxer])(buf, list_es, 0 ); while( ( buf_es = hb_list_item( list_es, 0 ) ) ) { hb_list_rem( list_es, buf_es ); if( buf_es->s.id == title->video_id && vid_buf == NULL ) { vid_decoder->work( vid_decoder, &buf_es, &vid_buf ); } else if( ! AllAudioOK( title ) ) { LookForAudio( title, buf_es ); buf_es = NULL; } if ( buf_es ) hb_buffer_close( &buf_es ); } if( vid_buf && AllAudioOK( title ) ) break; } if( ! vid_buf ) { hb_log( "scan: could not get a decoded picture" ); continue; } /* Get size and rate infos */ hb_work_info_t vid_info; if( !vid_decoder->info( vid_decoder, &vid_info ) ) { /* * Could not fill vid_info, don't continue and try to use vid_info * in this case. */ if (vid_buf) { hb_buffer_close( &vid_buf ); } hb_log( "scan: could not get a video information" ); continue; } remember_info( info_list, &vid_info ); if( is_close_to( vid_info.rate_base, 900900, 100 ) && ( vid_buf->s.flags & PIC_FLAG_REPEAT_FIRST_FIELD ) ) { /* Potentially soft telecine material */ pulldown_count++; } if( vid_buf->s.flags & PIC_FLAG_REPEAT_FRAME ) { // AVCHD-Lite specifies that all streams are // 50 or 60 fps. To produce 25 or 30 fps, camera // makers are repeating all frames. doubled_frame_count++; } if( is_close_to( vid_info.rate_base, 1126125, 100 ) ) { // Frame FPS is 23.976 (meaning it's progressive), so start keeping // track of how many are reporting at that speed. When enough // show up that way, we want to make that the overall title FPS. progressive_count++; } while( ( buf_es = hb_list_item( list_es, 0 ) ) ) { hb_list_rem( list_es, buf_es ); hb_buffer_close( &buf_es ); } /* Check preview for interlacing artifacts */ if( hb_detect_comb( vid_buf, 10, 30, 9, 10, 30, 9 ) ) { hb_deep_log( 2, "Interlacing detected in preview frame %i", i+1); interlaced_preview_count++; } if( data->store_previews ) { hb_save_preview( data->h, title->index, i, vid_buf ); } /* Detect black borders */ int top, bottom, left, right; int h4 = vid_info.height / 4, w4 = vid_info.width / 4; // When widescreen content is matted to 16:9 or 4:3 there's sometimes // a thin border on the outer edge of the matte. On TV content it can be // "line 21" VBI data that's normally hidden in the overscan. For HD // content it can just be a diagnostic added in post production so that // the frame borders are visible. We try to ignore these borders so // we can crop the matte. The border width depends on the resolution // (12 pixels on 1080i looks visually the same as 4 pixels on 480i) // so we allow the border to be up to 1% of the frame height. const int border = vid_info.height / 100; for ( top = border; top < h4; ++top ) { if ( ! row_all_dark( vid_buf, top ) ) break; } if ( top <= border ) { // we never made it past the border region - see if the rows we // didn't check are dark or if we shouldn't crop at all. for ( top = 0; top < border; ++top ) { if ( ! row_all_dark( vid_buf, top ) ) break; } if ( top >= border ) { top = 0; } } for ( bottom = border; bottom < h4; ++bottom ) { if ( ! row_all_dark( vid_buf, vid_info.height - 1 - bottom ) ) break; } if ( bottom <= border ) { for ( bottom = 0; bottom < border; ++bottom ) { if ( ! row_all_dark( vid_buf, vid_info.height - 1 - bottom ) ) break; } if ( bottom >= border ) { bottom = 0; } } for ( left = 0; left < w4; ++left ) { if ( ! column_all_dark( vid_buf, top, bottom, left ) ) break; } for ( right = 0; right < w4; ++right ) { if ( ! column_all_dark( vid_buf, top, bottom, vid_info.width - 1 - right ) ) break; } // only record the result if all the crops are less than a quarter of // the frame otherwise we can get fooled by frames with a lot of black // like titles, credits & fade-thru-black transitions. if ( top < h4 && bottom < h4 && left < w4 && right < w4 ) { record_crop( crops, top, bottom, left, right ); } ++npreviews; skip_preview: /* Make sure we found audio rates and bitrates */ for( j = 0; j < hb_list_count( title->list_audio ); j++ ) { hb_audio_t * audio = hb_list_item( title->list_audio, j ); if ( audio->priv.scan_cache ) { hb_fifo_flush( audio->priv.scan_cache ); } } if (vid_buf) { hb_buffer_close( &vid_buf ); } } UpdateState3(data, i); vid_decoder->close( vid_decoder ); free( vid_decoder ); if ( data->batch && data->stream ) { hb_stream_close( &data->stream ); } if ( npreviews ) { // use the most common frame info for our final title dimensions hb_work_info_t vid_info; most_common_info( info_list, &vid_info ); title->has_resolution_change = has_resolution_change( info_list ); if ( title->video_codec_name == NULL ) { title->video_codec_name = strdup( vid_info.name ); } title->width = vid_info.width; title->height = vid_info.height; if ( vid_info.rate && vid_info.rate_base ) { // if the frame rate is very close to one of our "common" framerates, // assume it actually is said frame rate; e.g. some 24000/1001 sources // may have a rate_base of 1126124 (instead of 1126125) const hb_rate_t *video_framerate = NULL; while ((video_framerate = hb_video_framerate_get_next(video_framerate)) != NULL) { if (is_close_to(vid_info.rate_base, video_framerate->rate, 100)) { vid_info.rate_base = video_framerate->rate; break; } } title->rate = vid_info.rate; title->rate_base = vid_info.rate_base; if( vid_info.rate_base == 900900 ) { if( npreviews >= 4 && pulldown_count >= npreviews / 4 ) { title->rate_base = 1126125; hb_deep_log( 2, "Pulldown detected, setting fps to 23.976" ); } if( npreviews >= 2 && progressive_count >= npreviews / 2 ) { // We've already deduced that the frame rate is 23.976, // so set it back again. title->rate_base = 1126125; hb_deep_log( 2, "Title's mostly NTSC Film, setting fps to 23.976" ); } } if( npreviews >= 2 && doubled_frame_count >= 3 * npreviews / 4 ) { // We've detected that a significant number of the frames // have been doubled in duration by repeat flags. title->rate_base = 2 * vid_info.rate_base; hb_deep_log( 2, "Repeat frames detected, setting fps to %.3f", (float)title->rate / title->rate_base ); } } title->video_bitrate = vid_info.bitrate; if( vid_info.pixel_aspect_width && vid_info.pixel_aspect_height ) { title->pixel_aspect_width = vid_info.pixel_aspect_width; title->pixel_aspect_height = vid_info.pixel_aspect_height; } title->color_prim = vid_info.color_prim; title->color_transfer = vid_info.color_transfer; title->color_matrix = vid_info.color_matrix; title->video_decode_support = vid_info.video_decode_support; // TODO: check video dimensions title->opencl_support = !!hb_opencl_available(); // compute the aspect ratio based on the storage dimensions and the // pixel aspect ratio (if supplied) or just storage dimensions if no PAR. title->aspect = (double)title->width / (double)title->height; title->aspect *= (double)title->pixel_aspect_width / (double)title->pixel_aspect_height; // For unknown reasons some French PAL DVDs put the original // content's aspect ratio into the mpeg PAR even though it's // the wrong PAR for the DVD. Apparently they rely on the fact // that DVD players ignore the content PAR and just use the // aspect ratio from the DVD metadata. So, if the aspect computed // from the PAR is different from the container's aspect we use // the container's aspect & recompute the PAR from it. if( title->container_aspect && (int)(title->aspect * 9) != (int)(title->container_aspect * 9) ) { hb_log("scan: content PAR gives wrong aspect %.2f; " "using container aspect %.2f", title->aspect, title->container_aspect ); title->aspect = title->container_aspect; hb_reduce( &title->pixel_aspect_width, &title->pixel_aspect_height, (int)(title->aspect * title->height + 0.5), title->width ); } // don't try to crop unless we got at least 3 previews if ( crops->n > 2 ) { sort_crops( crops ); // The next line selects median cropping - at least // 50% of the frames will have their borders removed. // Other possible choices are loose cropping (i = 0) where // no non-black pixels will be cropped from any frame and a // tight cropping (i = crops->n - (crops->n >> 2)) where at // least 75% of the frames will have their borders removed. i = crops->n >> 1; title->crop[0] = EVEN( crops->t[i] ); title->crop[1] = EVEN( crops->b[i] ); title->crop[2] = EVEN( crops->l[i] ); title->crop[3] = EVEN( crops->r[i] ); } hb_log( "scan: %d previews, %dx%d, %.3f fps, autocrop = %d/%d/%d/%d, " "aspect %s, PAR %d:%d", npreviews, title->width, title->height, (float) title->rate / (float) title->rate_base, title->crop[0], title->crop[1], title->crop[2], title->crop[3], aspect_to_string( title->aspect ), title->pixel_aspect_width, title->pixel_aspect_height ); if( interlaced_preview_count >= ( npreviews / 2 ) ) { hb_log("Title is likely interlaced or telecined (%i out of %i previews). You should do something about that.", interlaced_preview_count, npreviews); title->detected_interlacing = 1; } else { title->detected_interlacing = 0; } }
int main () { pwr_tStatus sts; pwr_tObjid oid; qcom_sQid my_q = qcom_cNQid; qcom_sGet get; pwr_tBoolean firstTime = TRUE; pwr_tUInt32 nrOfEvents = 0; pwr_tUInt32 nrOfKeys = 0; errh_Init("pwr_elog", errh_eAnix_elog); errh_SetStatus( PWR__SRVSTARTUP); memset(&lHelCB, 0, sizeof(lHelCB)); /* Declare process */ sts = gdh_Init("pwr_elog"); If_Error_Log_Exit(sts, "gdh_Init"); Init(); /* Create queue for receival of events */ if (!qcom_CreateQ(&sts, &my_q, NULL, "events")) { errh_Fatal("qcom_CreateQ, %m", sts); errh_SetStatus( PWR__APPLTERM); exit(sts); } if (!qcom_Bind(&sts, &my_q, &qcom_cQini)) { errh_Fatal("qcom_Bind(Qini), %m", sts); errh_SetStatus( PWR__APPLTERM); exit(-1); } oid.vid = lHelCB.Nid; oid.oix = pwr_cNVolumeId; sts = mh_OutunitConnect( oid, mh_eOutunitType_Logger, mh_mOutunitFlags_ReadWait, (mh_cbOutunitAck)Insert, (mh_cbOutunitAlarm)Insert, (mh_cbOutunitBlock)Insert, (mh_cbOutunitCancel)Insert, NULL, NULL, (mh_cbOutunitInfo)Insert, (mh_cbOutunitReturn)Insert, NULL ); If_Error_Log_Exit(sts, "mh_OutunitConnect"); sts = mh_OutunitSetTimeout(lHelCB.ScanTime); errh_SetStatus( PWR__SRUN); for (;;) { sts = mh_OutunitReceive(); if (EVEN(sts) && sts != MH__TMO) Log_Error(sts, "mh_OutunitReceive"); Store(&firstTime, &nrOfEvents, &nrOfKeys); get.data = NULL; qcom_Get(&sts, &my_q, &get, 0); if (sts != QCOM__TMO && sts != QCOM__QEMPTY) { if (get.type.b == qcom_eBtype_event) { qcom_sEvent *ep = (qcom_sEvent*) get.data; ini_mEvent new_event; if (get.type.s == qcom_cIini) { new_event.m = ep->mask; if (new_event.b.terminate) { errh_SetStatus( PWR__APPLTERM); exit(0); } } } qcom_Free(&sts, get.data); } aproc_TimeStamp( lHelCB.ScanTime/1000, 5.0); } }
static int graph_object_collect_build( Graph *graph, pwr_sAttrRef *attrref) { pwr_sAttrRef *alist, *ap; int *is_attrp, *is_attr; int sts; char name[120]; double x1, y1; grow_sAttrInfo *grow_info, *grow_info_p; int grow_info_cnt; int i; grow_tObject scantime_button; grow_tObject hold_button; grow_tObject t1, l1; double z_width, z_height, z_descent; double name_width = 0; double trend_width = 48; double trend_height = 1.2; double y0 = 2.2; double x0 = 2; pwr_tTypeId attr_type; unsigned int attr_size, attr_offset, attr_dimension; GeDyn *dyn; char attr_name[120]; grow_sAttributes grow_attr; unsigned long mask; int trend_cnt = 0; if ( ! graph->get_current_objects_cb) return 0; sts = (graph->get_current_objects_cb) (graph->parent_ctx, &alist, &is_attr); if ( EVEN(sts)) return sts; if ( cdh_ObjidIsNull( alist->Objid)) return 0; graph->graph_object_data = 0; graph->graph_object_close = 0; grow_SetPath( graph->grow->ctx, 1, "pwr_exe:"); // Set graph attributes // Default color theme mask = grow_eAttr_color_theme; strcpy( grow_attr.color_theme, "$default"); grow_SetAttributes( graph->grow->ctx, &grow_attr, mask); grow_ReadCustomColorFile( graph->grow->ctx, 0); grow_SetBackgroundColor( graph->grow->ctx, glow_eDrawType_CustomColor1); // Scantime input field graph->create_node( NULL, "pwrct_valueinputsmallbg", x0, y0 - 1.3, 4, y0 - 1.3 + 1.2, &scantime_button); dyn = new GeDyn( graph); grow_SetUserData( scantime_button, (void *)dyn); dyn->set_dyn( ge_mDynType1_Value, ge_mDynType2_No, ge_mActionType1_ValueInput, ge_mActionType2_No); dyn->update_elements(); dyn->set_access( (glow_mAccess) 65535); dyn->set_attribute( scantime_button, "$local.ScanTime##Float32", 0); dyn->set_value_input( "%3.0f", 2, 10000000); // Hold button graph->create_node( "TrendHold", "pwrct_buttonsmalltoggle", x0 + trend_width/2 - 3./2, y0 - 1.4 , x0 + trend_width/2 + 3./2, y0 - 1.4 + 1.2, &hold_button); grow_SetAnnotation( hold_button, 1, "Hold", 4); dyn = new GeDyn( graph); grow_SetUserData( hold_button, (void *)dyn); dyn->set_access( (glow_mAccess) 65535); dyn->set_attribute( hold_button, "$local.TrendHold##Boolean", 0); // Zero text grow_CreateGrowText( graph->grow->ctx, "", "0", x0 + trend_width - 0.2, y0 - 0.3, glow_eDrawType_TextHelvetica, glow_eDrawType_CustomColor5, 3, glow_eFont_LucidaSans, glow_mDisplayLevel_1, NULL, &t1); ap = alist; is_attrp = is_attr; x1 = x0; y1 = y0; while( cdh_ObjidIsNotNull( ap->Objid)) { if ( *is_attrp) { sts = gdh_AttrrefToName( ap, name, sizeof(name), cdh_mNName); if ( EVEN(sts)) return sts; sts = gdh_GetAttributeCharacteristics( name, &attr_type, &attr_size, &attr_offset, &attr_dimension); if ( EVEN(sts)) return sts; switch ( attr_type) { case pwr_eType_Boolean: { grow_tObject trend; grow_CreateGrowTrend( graph->grow->ctx, "ActualValueTrend", x1, y1, trend_width, trend_height, glow_eDrawType_Color37, 0, glow_mDisplayLevel_1, 1, 1, glow_eDrawType_Color40, NULL, &trend); dyn = new GeDyn( graph); dyn->dyn_type1 = ge_mDynType1_Trend; dyn->update_dyntype( trend); dyn->update_elements(); grow_SetUserData( trend, (void *)dyn); grow_GetObjectAttrInfo( trend, NULL, &grow_info, &grow_info_cnt); strcpy( attr_name, name); strcat( attr_name, "##Boolean"); grow_GetUserData( trend, (void **)&dyn); strcpy( ((GeTrend *)dyn->elements)->attribute1, attr_name); strcpy( ((GeTrend *)dyn->elements)->timerange_attr, "$local.ScanTime##Float32"); strcpy( ((GeTrend *)dyn->elements)->hold_attr, "$local.TrendHold##Boolean"); grow_info_p = grow_info; for ( i = 0; i < grow_info_cnt; i++) { if ( strcmp( grow_info_p->name, "NoOfPoints") == 0) *(int *) grow_info_p->value_p = 200; else if ( strcmp( grow_info_p->name, "HorizontalLines") == 0) *(int *) grow_info_p->value_p = 0; else if ( strcmp( grow_info_p->name, "VerticalLines") == 0) *(int *) grow_info_p->value_p = 9; else if ( strcmp( grow_info_p->name, "CurveColor1") == 0) *(int *) grow_info_p->value_p = glow_eDrawType_CustomColor68; else if ( strcmp( grow_info_p->name, "MaxValue1") == 0) *(double *) grow_info_p->value_p = 1.2; else if ( strcmp( grow_info_p->name, "MinValue1") == 0) *(double *) grow_info_p->value_p = -0.1; grow_info_p++; } grow_FreeObjectAttrInfo( grow_info); // This will configure the curves grow_SetTrendScanTime( trend, 0.5); grow_SetObjectOriginalFillColor( trend, glow_eDrawType_CustomColor66); grow_SetObjectOriginalBorderColor( trend, glow_eDrawType_CustomColor67); grow_GetTextExtent( graph->grow->ctx, name, strlen(name), glow_eDrawType_TextHelvetica, 4, glow_eFont_LucidaSans, &z_width, &z_height, &z_descent); grow_CreateGrowText( graph->grow->ctx, "", name, x1 + trend_width + 1, y1 + trend_height/2 + z_height/2, glow_eDrawType_TextHelvetica, glow_eDrawType_CustomColor5, 4, glow_eFont_LucidaSans, glow_mDisplayLevel_1, NULL, &t1); if ( z_width > name_width) name_width = z_width; trend_cnt++; y1 += trend_height; break; } default: ; } if ( trend_cnt >= MAX_TREND_OBJECTS) break; } ap++; is_attrp++; } free( alist); free( is_attr); // Draw separator lines between name texts y1 = y0; x1 = x0 + trend_width; grow_CreateGrowLine( graph->grow->ctx, "", x0 + trend_width, y1, x0 + trend_width + name_width + 2, y1, glow_eDrawType_CustomColor4, 1, 0, NULL, &l1); for ( i = 0; i < trend_cnt; i++) { y1 += trend_height; grow_CreateGrowLine( graph->grow->ctx, "", x0 + trend_width, y1, x0 + trend_width + name_width + 2, y1, glow_eDrawType_CustomColor4, 1, 0, NULL, &l1); } // Draw frame grow_CreateGrowRect( graph->grow->ctx, "R1", x0 - 1.5, y0 - 2.7, trend_width + name_width + 5.5, 1, glow_eDrawType_CustomColor3, 1, 0, glow_mDisplayLevel_1, 1, 0, 0, glow_eDrawType_CustomColor3, NULL, &l1); grow_CreateGrowRect( graph->grow->ctx, "R2", x0 - 1.5, y0 + trend_cnt * trend_height + 0.5, trend_width + name_width + 5.5, 5, glow_eDrawType_CustomColor3, 1, 0, glow_mDisplayLevel_1, 1, 0, 0, glow_eDrawType_CustomColor3, NULL, &l1); grow_CreateGrowRect( graph->grow->ctx, "R3", x0 + trend_width + name_width + 2, y0 - 1.7, 2, y0 + trend_cnt * trend_height + 0.9, glow_eDrawType_CustomColor3, 1, 0, glow_mDisplayLevel_1, 1, 0, 0, glow_eDrawType_CustomColor3, NULL, &l1); grow_CreateGrowRect( graph->grow->ctx, "R4", x0 - 1.5, y0 - 1.7, 1, y0 + trend_cnt * trend_height + 0.9, glow_eDrawType_CustomColor3, 1, 0, glow_mDisplayLevel_1, 1, 0, 0, glow_eDrawType_CustomColor3, NULL, &l1); grow_SetLayout( graph->grow->ctx, x0 - 1, y0 - 2.3, x0 + trend_width + name_width + 3, y0 + trend_cnt * trend_height + 1.5); // Set graph attributes mask = grow_eAttr_double_buffer_on; grow_attr.double_buffer_on = 1; grow_SetAttributes( graph->grow->ctx, &grow_attr, mask); return 1; }
static gdb_sNode * testClient ( pwr_tStatus *sts, sub_sClient *cp ) { pwr_tStatus lsts = GDH__SUCCESS; pwr_tSubid sid = cp->sid; cdh_sParseName parseName; cdh_sParseName *pn; gdb_sObject *op = NULL; sub_sClient *rcp; gdb_sVolume *vp; gdb_sNode *np = NULL; mvol_sAttribute attribute; mvol_sAttribute *ap; pwr_sAttrRef *arp; pwr_sAttrRef *rarp; gdb_sCclass *ccp; gdb_sCclass *ccpLocked; pool_tRef ccr; pwr_tUInt32 ridx; pwr_tBoolean equal; pwr_tBoolean fetched; gdb_AssumeLocked; do { if (cp->sub_by_name) { /* Lookup by name. */ pn = cdh_ParseName(&lsts, &parseName, pwr_cNObjid, cp->name, 0); if (pn == NULL) break; do { ap = vol_NameToAttribute(&lsts, &attribute, pn, gdb_mLo_global, vol_mTrans_all); if (ap == NULL) break; rcp = hash_Search(sts, gdbroot->subc_ht, &sid); if (rcp != cp) break; /* Subscription client no longer exists! */ arp = mvol_AttributeToAref(&lsts, ap, &cp->aref); if (arp == NULL) break; op = ap->op; /* */ vp = pool_Address(NULL, gdbroot->pool, op->l.vr); np = hash_Search(&lsts, gdbroot->nid_ht, &vp->g.nid); if (np == NULL) { op = NULL; break; } ccp = NULL; equal = 1; /* Get cached class if needed */ if (!op->u.c.flags.b.classChecked || !op->u.c.flags.b.classEqual) { ccp = cmvolc_GetCachedClass(&lsts, np, vp, ap, &equal, &fetched, NULL); if (EVEN(lsts)) { np = NULL; op = NULL; break; } if (fetched) { rcp = hash_Search(sts, gdbroot->subc_ht, &sid); if (rcp != cp) break; /* Subscription client no longer exists! */ } if (equal) { if (cp->cclass != pool_cNRef) { ccp = pool_Address(NULL, gdbroot->pool, cp->cclass); if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "cached class address"); cmvolc_UnlockClass(NULL, ccp); cp->cclass = pool_cNRef; } ccp = NULL; } else { ccr = pool_ItemReference(NULL, gdbroot->pool, ccp); if (ccr == pool_cNRef) errh_Bugcheck(GDH__WEIRD, "cache class address to reference"); if (ccr != cp->cclass) { if (cp->cclass != pool_cNRef) { gdb_sCclass *cc2p = pool_Address(NULL, gdbroot->pool, cp->cclass); cmvolc_UnlockClass(NULL, cc2p); } cmvolc_LockClass(NULL, ccp); cp->cclass = ccr; } } /* If gdb has been unlocked, refresh pointers */ /** @todo Check if we can do it more efficient, eg. vol_ArefToAttribute */ if (fetched) { np = NULL; op = NULL; continue; } } break; } while (1); } else { /* Lookup by attribute reference. */ do { op = vol_OidToObject(&lsts, cp->aref.Objid, gdb_mLo_global, vol_mTrans_all, cvol_eHint_none); if (op == NULL) { lsts = GDH__NOSUCHOBJ; break; } rcp = hash_Search(sts, gdbroot->subc_ht, &sid); if (rcp != cp) break; /* Subscription client no longer exists! */ if (op->g.flags.b.isAliasServer) cp->aref.Objid = op->g.oid; /* This is a not to ugly fix, but it should be removed, LW. It's done to make Leif-Göran Hansson happier. I.e. it makes the linksup program work. */ cp->aref.Objid = op->g.oid; vp = pool_Address(NULL, gdbroot->pool, op->l.vr); np = hash_Search(&lsts, gdbroot->nid_ht, &vp->g.nid); if (np == NULL) { op = NULL; break; } ccp = NULL; equal = 1; /* Get cached class if needed */ if (!op->u.c.flags.b.classChecked || !op->u.c.flags.b.classEqual) { ap = vol_ArefToAttribute(&lsts, &attribute, &cp->aref, gdb_mLo_global, vol_mTrans_all); if (ap == NULL) break; ccp = cmvolc_GetCachedClass(&lsts, np, vp, ap, &equal, &fetched, NULL); if (EVEN(lsts)) { np = NULL; op = NULL; break; } if (fetched) { rcp = hash_Search(sts, gdbroot->subc_ht, &sid); if (rcp != cp) break; /* Subscription client no longer exists! */ } if (equal) { if (cp->cclass != pool_cNRef) { ccp = pool_Address(NULL, gdbroot->pool, cp->cclass); if (ccp == NULL) errh_Bugcheck(GDH__WEIRD, "cached class address"); cmvolc_UnlockClass(NULL, ccp); cp->cclass = pool_cNRef; } ccp = NULL; } else { ccr = pool_ItemReference(NULL, gdbroot->pool, ccp); if (ccr == pool_cNRef) errh_Bugcheck(GDH__WEIRD, "cache class address to reference"); if (ccr != cp->cclass) { if (cp->cclass != pool_cNRef) { gdb_sCclass *cc2p = pool_Address(NULL, gdbroot->pool, cp->cclass); cmvolc_UnlockClass(NULL, cc2p); } cmvolc_LockClass(NULL, ccp); cp->cclass = ccr; } } /* If gdb has been unlocked, refresh pointers */ /** @todo Check if we can do it more efficient, eg. vol_ArefToAttribute */ if (fetched) { np = NULL; op = NULL; continue; } } break; } while (1); } } while (0); /* There is a risk that the client has disappeared after these calls (can result in a cache lookup). Verify that it still exists... */ rcp = hash_Search(sts, gdbroot->subc_ht, &sid); if (rcp == cp) { /* OK, it exists! */ cp->sts = lsts; if (op != NULL) { if (gdbroot->db->log.b.sub) errh_Info("Test client %s", op->g.f.name.orig); vp = pool_Address(NULL, gdbroot->pool, op->l.vr); np = pool_Address(NULL, gdbroot->pool, vp->l.nr); if (!equal) { ccpLocked = ccp; rarp = ndc_NarefToRaref(sts, ap, arp, ccp, &ridx, &cp->raref, &equal, NULL, ccpLocked, vp, np ); if (rarp == NULL || equal) { if (ccp->flags.b.cacheLock) cmvolc_UnlockClass(NULL, ccp); cp->cclass = pool_cNRef; if (rarp == NULL) np = gdbroot->no_node; } else { if (!ccp->flags.b.rnConv) { ndc_sRemoteToNative *tbl; gdb_sClass *c = hash_Search(sts, gdbroot->cid_ht, &ccp->key.cid); if (c == NULL) errh_Bugcheck(GDH__WEIRD, "can't get class"); tbl = pool_Alloc(sts, gdbroot->pool, sizeof(*tbl) * c->acount); ndc_UpdateRemoteToNativeTable(sts, tbl, c->acount, c, ccp, np->nid); if (ODD(*sts)) { ccp->rnConv = pool_Reference(NULL, gdbroot->pool, tbl); ccp->flags.b.rnConv = 1; } else { pool_Free(NULL, gdbroot->pool, tbl); cmvolc_UnlockClass(NULL, ccp); cp->cclass = pool_cNRef; np = gdbroot->no_node; } } } } /* not equal class versions */ } else { np = gdbroot->no_node; } } return np; }
bool wb_treeimport::importUpdateSubClass( wb_adrep *subattr, char *body, wb_vrep *vrep, bool *modified) { pwr_tStatus sts; pwr_tOix oix; pwr_tCid cid = subattr->subClass(); wb_cdrep *cdrep = vrep->merep()->cdrep( &sts, cid); if ( EVEN(sts)) throw wb_error(sts); wb_bdrep *bdrep = cdrep->bdrep( &sts, pwr_eBix_rt); if ( EVEN(sts)) throw wb_error(sts); int subattr_elements = subattr->isArray() ? subattr->nElement() : 1; for ( int i = 0; i < subattr_elements; i++) { wb_adrep *adrep = bdrep->adrep( &sts); while ( ODD(sts)) { int elements = adrep->isArray() ? adrep->nElement() : 1; if ( adrep->isClass()) { importUpdateSubClass( adrep, body + i * subattr->size() / subattr_elements + adrep->offset(), vrep, modified); } else { switch ( adrep->type()) { case pwr_eType_Objid: { pwr_tOid *oidp = (pwr_tOid *)(body + i * subattr->size() / subattr_elements + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( oidp->vid == m_import_source_vid && (oix = importTranslate( oidp->oix))) { oidp->vid = vrep->vid(); oidp->oix = oix; *modified = true; } else if ( ldh_isSymbolicVid( oidp->vid) && (oix = importTranslateCid(oidp->oix))) { oidp->oix = oix; *modified = true; } oidp++; } break; } case pwr_eType_AttrRef: { pwr_sAttrRef *arp = (pwr_sAttrRef *)(body + i * subattr->size() / subattr_elements + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( arp->Objid.vid == m_import_source_vid && (oix = importTranslate( arp->Objid.oix))) { arp->Objid.vid = vrep->vid(); arp->Objid.oix = oix; *modified = true; } else if ( ldh_isSymbolicVid( arp->Objid.vid) && (oix = importTranslateCid(arp->Objid.oix))) { arp->Objid.oix = oix; *modified = true; } arp++; } break; } case pwr_eType_DataRef: { pwr_tDataRef *drp = (pwr_tDataRef *)(body + i * subattr->size() / subattr_elements + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( drp->Aref.Objid.vid == m_import_source_vid && (oix = importTranslate( drp->Aref.Objid.oix))) { drp->Aref.Objid.vid = vrep->vid(); drp->Aref.Objid.oix = oix; *modified = true; } drp++; } break; } default: ; } } wb_adrep *prev = adrep; adrep = adrep->next( &sts); delete prev; } } delete bdrep; delete cdrep; return true; }
bool wb_treeimport::importUpdateObject( wb_orep *o, wb_vrep *vrep) { pwr_tOix oix; pwr_tStatus sts; wb_cdrep *cdrep = vrep->merep()->cdrep( &sts, o->cid()); if ( EVEN(sts)) throw wb_error(sts); pwr_mClassDef flags = cdrep->flags(); for ( int i = 0; i < 2; i++) { pwr_eBix bix = i ? pwr_eBix_rt : pwr_eBix_dev; wb_bdrep *bdrep = cdrep->bdrep( &sts, bix); if ( EVEN(sts)) continue; int size = bdrep->size(); char *body = (char *)malloc( bdrep->size()); vrep->readBody( &sts, o, bix, body); if ( EVEN(sts)) throw wb_error(sts); bool modified = false; wb_adrep *adrep = bdrep->adrep( &sts); while ( ODD(sts)) { int elements = adrep->isArray() ? adrep->nElement() : 1; if (adrep->offset() < 0 || ((int)(adrep->offset() + adrep->size()) > size)) printf("(adrep->offset() < 0 || (adrep->offset() + adrep->size() > size))\n"); if ( adrep->isClass()) { importUpdateSubClass( adrep, body + adrep->offset(), vrep, &modified); } else { switch ( adrep->type()) { case pwr_eType_Objid: { pwr_tOid *oidp = (pwr_tOid *)(body + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( oidp->vid == m_import_source_vid && (oix = importTranslate( oidp->oix))) { oidp->vid = vrep->vid(); oidp->oix = oix; modified = true; } else if ( ldh_isSymbolicVid( oidp->vid) && (oix = importTranslateCid(oidp->oix))) { oidp->oix = oix; modified = true; } oidp++; } break; } case pwr_eType_AttrRef: { pwr_sAttrRef *arp = (pwr_sAttrRef *)(body + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( arp->Objid.vid == m_import_source_vid && (oix = importTranslate( arp->Objid.oix))) { arp->Objid.vid = vrep->vid(); arp->Objid.oix = oix; modified = true; } else if ( ldh_isSymbolicVid( arp->Objid.vid) && (oix = importTranslateCid(arp->Objid.oix))) { arp->Objid.oix = oix; modified = true; } arp++; } break; } case pwr_eType_DataRef: { pwr_tDataRef *drp = (pwr_tDataRef *)(body + adrep->offset()); for ( int j = 0; j < elements; j++) { if ( drp->Aref.Objid.vid == m_import_source_vid && (oix = importTranslate( drp->Aref.Objid.oix))) { drp->Aref.Objid.vid = vrep->vid(); drp->Aref.Objid.oix = oix; modified = true; } drp++; } break; } default: ; } } wb_adrep *prev = adrep; adrep = adrep->next( &sts); delete prev; } if ( modified) { vrep->writeBody( &sts, o, bix, body); if ( EVEN(sts)) throw wb_error(sts); } free( body); delete bdrep; } delete cdrep; return true; }
int G77_ef1asc_0 (ftnint * a, ftnlen * la, ftnint * b, ftnlen * lb) { s_copy ((char *) a, (char *) b, EVEN (*la), *lb); return 0; /* ignored return value */ }
wb_adrep *wb_bdrep::adrep( pwr_tStatus *sts, const char *aname) { #if 0 wb_attrname n(aname); if ( n.evenSts()) { *sts = n.sts(); return 0; } char fullname[120]; wb_bdrep *bd = this; wb_adrep *adrep = 0; int offset; for ( int i = 0; i < n.attributes(); i++) { wb_name an(n.attribute(i)); wb_orep *orep = bd->m_orep->vrep()->child( sts, bd->m_orep, an); if ( EVEN(*sts)) return 0; if ( adrep) delete adrep; adrep = new wb_adrep( *orep); if ( i == 0) { offset = adrep->offset(); strcpy( fullname, adrep->name()); } else { offset += adrep->offset(); strcat( fullname, "."); strcat( fullname, adrep->name()); } if ( n.hasAttrIndex(i)) { sprintf( &fullname[strlen(fullname)], "[%d]", n.attrIndex(i)); if ( n.attrIndex(i) >= adrep->nElement() || n.attrIndex(i) < 0) { *sts = LDH__ATTRINDEX; return 0; } offset += n.attrIndex(i) * adrep->size() / adrep->nElement(); } if ( (i != n.attributes() - 1) && adrep->isClass()) { wb_cdrep *cd = m_orep->vrep()->merep()->cdrep( sts, adrep->subClass()); if ( EVEN(*sts)) return 0; if ( bd != this) delete bd; bd = cd->bdrep( sts, pwr_eBix_rt); if ( EVEN(*sts)) { delete cd; return 0;} delete cd; } } adrep->setSubattr( offset, fullname); #endif wb_attrname n(aname); if ( n.evenSts()) { *sts = n.sts(); return 0; } wb_bdrep *bd = this; wb_adrep *adrep = 0; wb_adrep *old = 0; for ( int i = 0; i < n.attributes(); i++) { bool next_attr = false; wb_name an(n.attribute(i)); wb_orep *orep = bd->m_orep->vrep()->child( sts, bd->m_orep, an); while ( EVEN(*sts)) { // Try Super attribute orep = bd->m_orep->vrep()->first( sts, bd->m_orep); if ( EVEN(*sts)) { if ( bd != this) delete bd; if ( adrep) delete adrep; return 0; } if ( cdh_NoCaseStrcmp( orep->name(), "Super") == 0) { if ( adrep) old = adrep; adrep = new wb_adrep( *orep); if ( old) adrep->add( old); delete old; wb_cdrep *cd = m_orep->vrep()->merep()->cdrep( sts, adrep->subClass()); if ( EVEN(*sts)) return 0; if ( bd != this) delete bd; bd = cd->bdrep( sts, pwr_eBix_rt); if ( EVEN(*sts)) { delete cd; return 0;} delete cd; orep = bd->m_orep->vrep()->child( sts, bd->m_orep, an); } else { if ( adrep && adrep->flags() & PWR_MASK_CASTATTR && n.hasSuper()) { // Allow additional super attributesegement for casted attributes next_attr = true; break; } orep->ref(); orep->unref(); *sts = LDH__NOSUCHATTR; return 0; } } if ( next_attr) continue; if ( adrep) old = adrep; adrep = new wb_adrep( *orep); if ( i != 0) { if ( n.hasAttrIndex( i - 1)) adrep->add( old, n.attrIndex( i - 1)); else adrep->add( old); delete old; } if ( n.hasAttrIndex(i) && (n.attrIndex(i) >= adrep->nElement() || n.attrIndex(i) < 0)) { *sts = LDH__ATTRINDEX; return 0; } if ( (i != n.attributes() - 1) && adrep->isClass()) { wb_cdrep *cd; if ( m_merep) cd = m_merep->cdrep( sts, adrep->subClass()); else cd = m_orep->vrep()->merep()->cdrep( sts, adrep->subClass()); if ( EVEN(*sts)) return 0; if ( bd != this) delete bd; bd = cd->bdrep( sts, pwr_eBix_rt); if ( EVEN(*sts)) { delete cd; return 0;} delete cd; } else if ( (i != n.attributes() - 1) && !adrep->isClass()) { // To many attribute delete adrep; *sts = LDH__NOSUCHATTR; return 0; } } return adrep; }
// // Callbacks from brow // int CoLogWNav::brow_cb( FlowCtx *ctx, flow_tEvent event) { CoLogWNav *logwnav; ItemLog *item; if ( event->event == flow_eEvent_ObjectDeleted) { brow_GetUserData( event->object.object, (void **)&item); delete item; return 1; } brow_GetCtxUserData( (BrowCtx *)ctx, (void **) &logwnav); switch ( event->event) { case flow_eEvent_Key_Up: { brow_tNode *node_list; int node_count; brow_tObject object; int sts; brow_GetSelectedNodes( logwnav->brow->ctx, &node_list, &node_count); if ( !node_count) { sts = brow_GetLastVisible( logwnav->brow->ctx, &object); if ( EVEN(sts)) return 1; } else { if ( !brow_IsVisible( logwnav->brow->ctx, node_list[0], flow_eVisible_Partial)) { sts = brow_GetLastVisible( logwnav->brow->ctx, &object); if ( EVEN(sts)) return 1; } else { sts = brow_GetPrevious( logwnav->brow->ctx, node_list[0], &object); if ( EVEN(sts)) { if ( node_count) free( node_list); return 1; } } } brow_SelectClear( logwnav->brow->ctx); brow_SetInverse( object, 1); brow_SelectInsert( logwnav->brow->ctx, object); if ( !brow_IsVisible( logwnav->brow->ctx, object, flow_eVisible_Full)) brow_CenterObject( logwnav->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( logwnav->brow->ctx, &node_list, &node_count); if ( !node_count) { sts = brow_GetFirstVisible( logwnav->brow->ctx, &object); if ( EVEN(sts)) return 1; } else { if ( !brow_IsVisible( logwnav->brow->ctx, node_list[0], flow_eVisible_Partial)) { sts = brow_GetFirstVisible( logwnav->brow->ctx, &object); if ( EVEN(sts)) return 1; } else { sts = brow_GetNext( logwnav->brow->ctx, node_list[0], &object); if ( EVEN(sts)) { if ( node_count) free( node_list); return 1; } } } brow_SelectClear( logwnav->brow->ctx); brow_SetInverse( object, 1); brow_SelectInsert( logwnav->brow->ctx, object); if ( !brow_IsVisible( logwnav->brow->ctx, object, flow_eVisible_Full)) brow_CenterObject( logwnav->brow->ctx, object, 0.75); if ( node_count) free( node_list); break; } case flow_eEvent_SelectClear: brow_ResetSelectInverse( logwnav->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 = CoLogWNav::brow_cb( ctx, doubleclick_event); free( (char *) doubleclick_event); return sts; } if ( brow_FindSelectedObject( logwnav->brow->ctx, event->object.object)) { brow_SelectClear( logwnav->brow->ctx); } else { brow_SelectClear( logwnav->brow->ctx); brow_SetInverse( event->object.object, 1); brow_SelectInsert( logwnav->brow->ctx, event->object.object); } break; default: brow_SelectClear( logwnav->brow->ctx); } break; case flow_eEvent_Key_PageDown: { brow_Page( logwnav->brow->ctx, 0.95); break; } case flow_eEvent_Key_PageUp: { brow_Page( logwnav->brow->ctx, -0.95); break; } case flow_eEvent_ScrollDown: { brow_Page( logwnav->brow->ctx, 0.10); break; } case flow_eEvent_ScrollUp: { brow_Page( logwnav->brow->ctx, -0.10); break; } case flow_eEvent_MB1DoubleClick: break; default: ; } return 1; }
pwr_tStatus vipc616_GetAddress( pwr_tObjid ipObjid, /* Objid of IP-module */ pwr_tUInt32 slot, char **ioAddress, char **idAddress, char **memoryAddress ) { pwr_tStatus sts; pwr_tObjid parent; pwr_tClassId cid; pwr_sClass_VIPC616* vipc; unsigned int memSize; int slotNo; unsigned int ioAdrs; unsigned int memAdrs; sts = gdh_GetParent(ipObjid, &parent); if (EVEN(sts)) return IO__NOTIPCARRIER; sts = gdh_GetObjectClass(parent, &cid); if (EVEN(sts)) return IO__NOTIPCARRIER; if (pwr_cClass_VIPC616 != cid) return IO__NOTIPCARRIER; sts = gdh_ObjidToPointer(parent, (pwr_tAddress *)&vipc); if (EVEN(sts)) return IO__NOTIPCARRIER; switch (toupper(slot)) { case 'A': case 'B': case 'C': case 'D': slotNo = toupper(slot) - 'A'; break; default: return IO__INVIPSLOT; break; } if (vipc->MemoryBase == 32) memSize = 0x800000; /* 8 MB */ else if (vipc->MemorySlotSize <= 128) memSize = 0x20000; /* 128 kB */ else if (vipc->MemorySlotSize <= 256) memSize = 0x40000; /* 256 kB */ else if (vipc->MemorySlotSize <= 512) memSize = 0x80000; /* 512 kB */ else if (vipc->MemorySlotSize <= 1024) memSize = 0x100000; /* 1 MB */ else memSize = 0x200000; /* 2 MB */ ioAdrs = io_GetShortIoAddress(); /* Each slot have 128 bytes IO space */ if (ioAddress != NULL) *ioAddress = (char *) (ioAdrs + vipc->IoAddress + (unsigned int)(slotNo * 0x100)); /* After the IO space each slot have 128 ID bytes */ if (idAddress != NULL) *idAddress = (char *) (ioAdrs + vipc->IoAddress + (unsigned int) 0x80 + (unsigned int)(slotNo * 0x100)); if (memoryAddress != NULL) { if (vipc->MemoryBase == 32) memAdrs = io_GetA32D16Address(); else memAdrs = io_GetA24Address(); *memoryAddress = (char *)(memAdrs + (unsigned int)(slotNo * memSize) + vipc->MemoryAddress); } return IO__SUCCESS; }
// // Callbackfunctions from menu entries // void WPkg::activate_distribute() { WItemPkg **itemlist; int item_count; int sts; message( ' ', ""); sts = wpkgnav->get_select( &itemlist, &item_count); if ( EVEN(sts)) { message( 'E', "Select a node or package"); return; } if ( item_count > 1) { for ( int i = 0; i < item_count; i++) { if ( typeid( *itemlist[i]) != typeid( WItemPkgNode)) { message( 'E', "All selected items are not nodes"); free( itemlist); return; } } set_clock_cursor(); for ( int i = 0; i < item_count; i++) { try { wb_pkg *pkg = new wb_pkg( ((WItemPkgNode *)itemlist[i])->nodename); delete pkg; } catch ( wb_error &e) { message(' ', (char *)e.what().c_str()); reset_cursor(); free( itemlist); return; } wpkgnav->refresh_node( itemlist[i]); char msg[80]; sprintf( msg, "Distribution successful to %s", ((WItemPkgNode *)itemlist[i])->nodename); message('I', msg); flush(); } reset_cursor(); free( itemlist); } else { // One is selected if ( typeid( *itemlist[0]) == typeid( WItemPkgNode)) { set_clock_cursor(); try { wb_pkg *pkg = new wb_pkg( ((WItemPkgNode *)itemlist[0])->nodename); delete pkg; } catch ( wb_error &e) { message(' ', (char *)e.what().c_str()); } wpkgnav->refresh_node( itemlist[0]); char msg[80]; sprintf( msg, "Distribution successful to %s", ((WItemPkgNode *)itemlist[0])->nodename); message('I', msg); reset_cursor(); } else if ( typeid( *itemlist[0]) == typeid( WItemPkgPackage)) { set_clock_cursor(); wb_pkg::copyPackage( ((WItemPkgPackage *)itemlist[0])->packagename); char msg[80]; sprintf( msg, "Distribution successful of %s", ((WItemPkgPackage *)itemlist[0])->packagename); message('I', msg); reset_cursor(); } else { message( 'E', "Select a node or package"); } } }
static int graph_object_dx( Graph *graph, pwr_sAttrRef *arp) { int sts; graph_sObjectDx *od; pwr_tAttrRef aref, chanaref; pwr_tAName aname; pwr_tCid card_cid; od = (graph_sObjectDx *) calloc( 1, sizeof(graph_sObjectDx)); graph->graph_object_data = (void *) od; graph->graph_object_close = graph_object_dx_close; sts = gdh_GetAttrRefTid( arp, &od->cid); if ( EVEN(sts)) return sts; // Get channel object sts = gdh_ArefANameToAref( arp, "SigChanCon", &aref); if ( EVEN(sts)) { // Dv object, register scan function and return with success graph->graph_object_scan = graph_object_dx_scan; return 1; } sts = gdh_GetObjectInfoAttrref( &aref, &chanaref, sizeof(chanaref)); if ( EVEN(sts)) return sts; od->local_conv_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "ConversionOn", pwr_eType_Boolean); od->local_inv_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "InvertOn", pwr_eType_Boolean); od->local_test_p = (pwr_tBoolean *) graph->localdb_ref_or_create( "TestOn", pwr_eType_Boolean); // Get card object if ( chanaref.Flags.b.ObjectAttr) { sts = gdh_GetObjectClass( chanaref.Objid, &card_cid); if ( EVEN(sts)) return sts; } else card_cid = 0; switch ( card_cid) { case pwr_cClass_Ssab_DI32D: { pwr_tAName card_name; unsigned int chan_idx = (chanaref.Offset - pwr_AlignLW(sizeof(pwr_sClass_Ssab_BaseDiCard))) / pwr_AlignLW(sizeof(pwr_sClass_ChanDi)); sts = gdh_ObjidToName( chanaref.Objid, card_name, sizeof(card_name), cdh_mNName); if ( EVEN(sts)) return sts; if ( chan_idx < 16) { strcpy( aname, card_name); strcat( aname, ".ConvMask1"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid, sizeof(pwr_tBoolean), 0, true); strcpy( aname, card_name); strcat( aname, ".InvMask1"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid, sizeof(pwr_tBoolean), 0, true); od->mask = 1 << chan_idx; } else if ( chan_idx < 32) { strcpy( aname, card_name); strcat( aname, ".ConvMask2"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid, sizeof(pwr_tBoolean), 0, true); strcpy( aname, card_name); strcat( aname, ".InvMask2"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid, sizeof(pwr_tBoolean), 0, true); od->mask = 1 << (chan_idx - 16); } else return 0; break; } case pwr_cClass_Ssab_DO32DKS: case pwr_cClass_Ssab_DO32DKS_Stall: { pwr_tAName card_name; unsigned int chan_idx = (chanaref.Offset - pwr_AlignLW(sizeof(pwr_sClass_Ssab_BaseDoCard))) / pwr_AlignLW(sizeof(pwr_sClass_ChanDo)); sts = gdh_ObjidToName( chanaref.Objid, card_name, sizeof(card_name), cdh_mNName); if ( EVEN(sts)) return sts; if ( chan_idx < 16) { strcpy( aname, card_name); strcat( aname, ".TestMask1"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid, sizeof(pwr_tBoolean), 0, true); strcpy( aname, card_name); strcat( aname, ".InvMask1"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid, sizeof(pwr_tBoolean), 0, true); od->mask = 1 << chan_idx; } else if ( chan_idx < 32) { strcpy( aname, card_name); strcat( aname, ".TestMask2"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid, sizeof(pwr_tBoolean), 0, true); strcpy( aname, card_name); strcat( aname, ".InvMask2"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid, sizeof(pwr_tBoolean), 0, true); od->mask = 1 << (chan_idx - 16); } else return 0; if ( od->local_conv_p) *od->local_conv_p = 1; break; } default: { pwr_tAName chan_name; sts = gdh_AttrrefToName( &chanaref, chan_name, sizeof(chan_name), cdh_mNName); if ( ODD(sts)) { if ( od->cid == pwr_cClass_Di) { strcpy( aname, chan_name); strcat( aname, ".ConversionOn"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->conv_p, &od->conv_subid, sizeof(pwr_tBoolean), 0, true); } strcpy( aname, chan_name); strcat( aname, ".InvertOn"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->inv_p, &od->inv_subid, sizeof(pwr_tBoolean), 0, true); if ( od->cid == pwr_cClass_Do) { strcpy( aname, chan_name); strcat( aname, ".TestOn"); graph->ref_object_info( glow_eCycle_Slow, aname, (void **)&od->test_p, &od->test_subid, sizeof(pwr_tBoolean), 0, true); if ( od->local_conv_p) *od->local_conv_p = 1; } } } } // Register scan function graph->graph_object_scan = graph_object_dx_scan; return 1; }
static void* mb_connect(void* arg) { io_sRack* rp = (io_sRack*)arg; io_sServerLocal* local = rp->Local; int sts; pwr_sClass_Modbus_TCP_Server* op; struct sockaddr_in r_addr; socklen_t r_addr_len; int c_socket; mb_sCondata* condata; int idx; int found; int i; op = (pwr_sClass_Modbus_TCP_Server*)rp->op; while (1) { /* Wait for client connect request */ r_addr_len = sizeof(r_addr); c_socket = accept(local->s, (struct sockaddr*)&r_addr, &r_addr_len); if (c_socket < 0) { errh_Error( "Error accept IO modbus tcp server %s, %d", rp->Name, local->s); continue; } if (op->DisableServer) continue; errh_Info("Connection accepted for IO modbus tcp server %s, %d", rp->Name, c_socket); /* Close other connections to this address */ for (i = 0; i < MB_MAX_CONNECTIONS; i++) { if (local->connections[i].occupied && r_addr_len == local->connections[i].addrlen && r_addr.sin_family == local->connections[i].addr.sin_family && memcmp(&r_addr.sin_addr, &local->connections[i].addr.sin_addr, sizeof(r_addr.sin_addr)) == 0) { mb_close_connection(rp, i); } } /* Find next empty in connection list */ found = 0; for (i = 0; i < MB_MAX_CONNECTIONS; i++) { if (!local->connections[i].occupied) { found = 1; idx = i; break; } } if (!found) { /* Remove the oldest connection */ int oldest_idx = 0; for (i = 1; i < MB_MAX_CONNECTIONS; i++) { if (time_Acomp(&local->connections[i].last_req_time, &local->connections[oldest_idx].last_req_time) < 0) oldest_idx = i; } mb_close_connection(rp, oldest_idx); errh_Info( "Connection closed, IO modbus tcp server %s, %d", rp->Name, local->s); idx = oldest_idx; } local->connections[idx].c_socket = c_socket; local->connections[idx].occupied = 1; time_GetTime(&local->connections[idx].last_req_time); local->connections[idx].addrlen = r_addr_len; memcpy(&local->connections[idx].addr, &r_addr, r_addr_len); /* Create a thread for this connection */ condata = (mb_sCondata*)malloc(sizeof(mb_sCondata)); condata->rp = rp; condata->idx = idx; sts = thread_Create( &local->connections[idx].t, 0, mb_receive, (void*)condata); if (EVEN(sts)) { local->connections[idx].occupied = 0; errh_Error("Error creating thread IO modbus tcp server %s, %d", rp->Name, local->s); free(condata); continue; } } return 0; }
int Graph::trend_init( graph_sObjectTrend *td, pwr_sAttrRef *arp) { pwr_tClassId classid; pwr_tFloat32 max_limit = 100; pwr_tFloat32 min_limit = 0; int sts; pwr_sAttrRef attrref; grow_tObject object; int presminlimit_found = 0; int presmaxlimit_found = 0; double scan_time; if ( arp && cdh_ObjidIsNotNull( arp->Objid)) { sts = gdh_GetAttrRefTid( arp, &classid); if ( EVEN(sts)) return sts; // Try to find attributes PresMaxLimit and PresMinLimit sts = gdh_ArefANameToAref( arp, "PresMaxLimit", &attrref); if ( ODD(sts)) { sts = gdh_GetObjectInfoAttrref( &attrref, (void *)&max_limit, sizeof(max_limit)); if ( EVEN(sts)) return sts; presmaxlimit_found = 1; } sts = gdh_ArefANameToAref( arp, "PresMinLimit", &attrref); if ( ODD(sts)) { sts = gdh_GetObjectInfoAttrref( &attrref, (void *)&min_limit, sizeof(min_limit)); if ( EVEN(sts)) return sts; presminlimit_found = 1; } } td->pres_max_limit_old = max_limit; td->pres_min_limit_old = min_limit; // Configure bar sts = grow_FindObjectByName( grow->ctx, "ActualValueBar", &td->bar_object); if ( ODD(sts)) { if ( min_limit != max_limit) grow_SetBarRange( td->bar_object, double(min_limit), double(max_limit)); } // Get pointers to max and min value sts = grow_FindObjectByName( grow->ctx, "PresMaxLimit", &object); if ( ODD(sts)) { GeDyn *dyn; grow_GetUserData( object, (void **)&dyn); td->pres_max_limit_p = (pwr_tFloat32 *) dyn->get_p(); if ( !presmaxlimit_found) // PresMaxLimit in local database, set value *td->pres_max_limit_p = max_limit; } sts = grow_FindObjectByName( grow->ctx, "PresMinLimit", &object); if ( ODD(sts)) { GeDyn *dyn; grow_GetUserData( object, (void **)&dyn); td->pres_min_limit_p = (pwr_tFloat32 *) dyn->get_p(); if ( !presminlimit_found) // PresMinLimit in local database, set value *td->pres_min_limit_p = min_limit; } // Configure trend sts = grow_FindObjectByName( grow->ctx, "ActualValueTrend", &td->trend_object); if ( EVEN(sts)) return sts; if ( td->pres_min_limit_p && td->pres_max_limit_p) { if ( min_limit != max_limit) grow_SetTrendRangeY( td->trend_object, 0, double(min_limit), double(max_limit)); } // Configure slider sts = grow_FindObjectByName( grow->ctx, "ActualValueSlider", &td->slider_object); if ( ODD(sts)) { if ( td->pres_min_limit_p && td->pres_max_limit_p) { if ( min_limit != max_limit) grow_SetSliderRange( td->slider_object, double(min_limit), double(max_limit)); } GeDyn *dyn; grow_GetUserData( td->slider_object, (void **)&dyn); td->slider_disable_p = dyn->ref_slider_disabled(); if ( td->slider_disable_p) *td->slider_disable_p = 1; } // Set scantime variable in local database grow_GetTrendScanTime( td->trend_object, &scan_time); td->scan_time_p = (float *) localdb_ref_or_create( "ScanTime", pwr_eType_Float32); td->old_scan_time = float( scan_time*200); *td->scan_time_p = td->old_scan_time; // Get Hold button sts = grow_FindObjectByName( grow->ctx, "TrendHold", &td->hold_button_object); if ( ODD(sts)) td->hold_button_p = (int *) localdb_ref_or_create( "TrendHold", pwr_eType_Boolean); GeDyn *dyn; grow_GetUserData( td->trend_object, (void **)&dyn); td->data_scan_time_p = dyn->ref_trend_scantime(); td->hold_p = dyn->ref_trend_hold(); sts = grow_FindObjectByName( grow->ctx, "SliderDisable", &td->slider_button_object); if ( ODD(sts)) td->slider_button_p = (int *) localdb_ref_or_create( "SliderDisable", pwr_eType_Boolean); return 1; }
static pwr_tStatus IoRackInit(io_tCtx ctx, io_sAgent* ap, io_sRack* rp) { io_sServerLocal* local; pthread_t thread; pwr_tOName name; pwr_tStatus sts; pwr_sClass_Modbus_TCP_Server* op; int i; unsigned short port; op = (pwr_sClass_Modbus_TCP_Server*)rp->op; op->Connections = 0; port = op->Port == 0 ? 502 : op->Port; sts = gdh_ObjidToName(rp->Objid, (char*)&name, sizeof(name), cdh_mNName); errh_Info("Init of Modbus TCP Server %s", name); rp->Local = calloc(1, sizeof(io_sServerLocal)); local = rp->Local; if (op->DisableServer) return IO__SUCCESS; /* Create socket, store in local struct */ uid_t ruid; ruid = getuid(); printf("ruid: %d\n", ruid); local->s = socket(AF_INET, SOCK_STREAM, 0); if (local->s < 0) { errh_Error("Error creating socket for IO modbus tcp server %s, %d", rp->Name, local->s); return 0; } local->loc_addr.sin_family = AF_INET; local->loc_addr.sin_port = htons(port); for (i = 0; i < 10; i++) { sts = bind( local->s, (struct sockaddr*)&local->loc_addr, sizeof(local->loc_addr)); if (sts == 0) break; perror("Modbus TCP Bind socket failure, retrying... "); sleep(10); } if (sts != 0) { printf("Modbus TCP Bind socket failure, exiting"); errh_Error("Error bind socket to port for IO modbus tcp server %s, %d", rp->Name, local->s); return 0; } errh_Info("Modbus TCP Sever bind to port %d, %s", port, name); sts = listen(local->s, 16); sts = thread_MutexInit(&local->mutex); if (EVEN(sts)) return sts; /* Create a thread that listens for connections */ sts = pthread_create(&thread, NULL, mb_connect, (void*)rp); if (sts != 0) return sts; sts = mb_init_channels(ctx, ap, rp); if (EVEN(sts)) return sts; op->Status = MB__NORMAL; return IO__SUCCESS; }
static int graph_object_PlcThread( Graph *graph, pwr_sAttrRef *arp) { pwr_sAttrRef attrref; int sts; graph_sObjectPlcThread *od; pwr_tClassId classid; pwr_tFloat32 max_limit = 1; pwr_tFloat32 min_limit = 0; pwr_tObjid objid = arp->Objid; od = (graph_sObjectPlcThread *) calloc( 1, sizeof(graph_sObjectPlcThread)); graph->graph_object_data = (void *) od; graph->graph_object_close = graph_object_PlcThread_close; sts = gdh_GetObjectClass( objid, &classid); if ( EVEN(sts)) return sts; // Get value for ScanTime sts = gdh_ClassAttrToAttrref( classid, ".ScanTime", &attrref); if ( EVEN(sts)) return sts; attrref.Objid = objid; sts = gdh_GetObjectInfoAttrref( &attrref, (void *)&max_limit, sizeof(max_limit)); if ( EVEN(sts)) return sts; max_limit = max_limit * 2; od->set_max_show_old = max_limit; od->set_min_show_old = min_limit; // Configure ProcVal and SetVal bar sts = grow_FindObjectByName( graph->grow->ctx, "ActualScanTimeBar", &od->set_bar_object); if ( EVEN(sts)) return sts; if ( min_limit != max_limit) grow_SetBarRange( od->set_bar_object, double(min_limit), double(max_limit)); // Get pointers to max and min value od->set_max_show_p = (float *) graph->localdb_ref_or_create( "MaxShow", pwr_eType_Float32); *od->set_max_show_p = od->set_max_show_old; od->set_min_show_p = (float *) graph->localdb_ref_or_create( "MinShow", pwr_eType_Float32); *od->set_min_show_p = od->set_min_show_old; // Configure SetVal trend sts = grow_FindObjectByName( graph->grow->ctx, "ActualScanTimeTrend", &od->set_trend_object); if ( EVEN(sts)) return sts; if ( min_limit != max_limit) { grow_SetTrendRangeY( od->set_trend_object, 0, double(min_limit), double(max_limit)); grow_SetTrendRangeY( od->set_trend_object, 1, double(min_limit), double(max_limit)); } // Register scan function graph->graph_object_scan = graph_object_PlcThread_scan; return 1; }
int rtt_view( menu_ctx parent_ctx, char *filename, char *inbuff, char *intitle, int type) { view_ctx ctx; unsigned long terminator; char input_str[80]; int maxlen = 30; unsigned long option; int sts; int i, start_i, end_i; int size, offset; int left_marg; int page_size = 21; int row_change; int redraw = 1; char str[100]; char title[80]; FILE *infile; char last_char; char pagestr[80]; if ( type == RTT_VIEWTYPE_FILE) { infile = fopen( filename, "r"); if ( !infile) { rtt_message('E',"Unable to open file"); return RTT__NOPICTURE; } rtt_fgetname( infile, title, filename); } else { strcpy( title, intitle); } ctx = calloc( 1, sizeof( *ctx)); if ( !ctx) { rtt_message('E',"Unable to allocate memory"); return RTT__NOPICTURE; } rtt_ctx_push( (menu_ctx) ctx); ctx->ctx_type = RTT_CTXTYPE_VIEW; strcpy( ctx->title, title); ctx->parent_ctx = parent_ctx; ctx->first = 1; if ( type == RTT_VIEWTYPE_FILE) ctx->infile = infile; else ctx->inbuff = inbuff; ctx->read_sts = (char *) 1; ctx->buff = calloc( 1, RTTVIEW_BUFF_SIZE); if ( !ctx->buff) { rtt_ctx_pop(); rtt_message('E',"Unable to allocate memory"); return RTT__NOPICTURE; } ctx->buffrow = calloc( RTTVIEW_BUFFROW_SIZE, sizeof(*ctx->buffrow)); if ( !ctx->buffrow) { rtt_ctx_pop(); rtt_message('E',"Unable to allocate memory"); return RTT__NOPICTURE; } ctx->buffrow_count = 0; ctx->start_row = 0; left_marg = 0; row_change = 0; if ( type == RTT_VIEWTYPE_FILE) rtt_read_file( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 0, page_size, &ctx->start_row); else rtt_read_buff( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 0, page_size, &ctx->start_row); option = RTT_OPT_NORECALL | RTT_OPT_NOEDIT | RTT_OPT_NOECHO | RTT_OPT_TIMEOUT; while (1) { if ( ctx->start_row + page_size > ctx->buffrow_count ) { if ( type == RTT_VIEWTYPE_FILE) rtt_read_file( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 0, page_size, &ctx->start_row); else ctx->start_row = max( 0, ctx->buffrow_count - page_size); /* rtt_read_buff( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 0, page_size, &ctx->start_row); */ redraw = 1; } else if ( ctx->start_row < 0) { if ( type == RTT_VIEWTYPE_FILE) rtt_read_file( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 1, page_size, &ctx->start_row); else ctx->start_row = 0; /* rtt_read_buff( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 1, page_size, &ctx->start_row); */ redraw = 1; } if ( redraw || row_change != 0) { redraw = 0; rtt_display_erase(); start_i = ctx->start_row; end_i = min(ctx->start_row+page_size, ctx->buffrow_count); rtt_cursor_abs( 1, 22-page_size); for ( i = ctx->start_row; i < end_i; i++) { if ( i == ctx->buffrow_count - 1) { offset = ctx->buffrow[i] + left_marg; rtt_view_get_row_size( &ctx->buff[offset], 80, &size, &last_char); size = min( size, 80); if ( last_char != 10) r_print("%.*s\n\r", size, &ctx->buff[offset]); else r_print("%.*s\r", size, &ctx->buff[offset]); /* str[80] = 0; r_print("%80s\n", str); */ } else { offset = min( ctx->buffrow[i+1] - 1, ctx->buffrow[i] + left_marg); size = min( ctx->buffrow[i+1] - offset, 80); rtt_view_get_row_size( &ctx->buff[offset], 80, &size, &last_char); size = min( size, 80); if ( last_char != 10) r_print("%.*s\n\r", size, &ctx->buff[offset]); else r_print("%.*s\r", size, &ctx->buff[offset]); } } rtt_cursor_abs( 1, 22); rtt_char_inverse_start(); if ( end_i == ctx->buffrow_count) sprintf( pagestr, "%d-EOF(%d)", start_i+1, ctx->buffrow_count); else sprintf( pagestr, "%d-%d(%d)", start_i+1, end_i, ctx->buffrow_count); sprintf( str, " |%12s | Ctrl/R back", pagestr); strncpy( &str[1], title, min( strlen( title), 49)); r_print( "%80s", str); rtt_char_inverse_end(); rtt_cursor_abs( 1, 23); rtt_eofline_erase(); rtt_cursor_abs( 1, 24); rtt_eofline_erase(); } row_change = 0; r_print_buffer(); rtt_command_get_input_string( (char *) &rtt_chn, input_str, &terminator, maxlen, rtt_recallbuff, option, rtt_scantime, &rtt_scan, ctx, NULL, RTT_COMMAND_PICTURE); rtt_message('S',""); switch ( terminator) { case RTT_K_ARROW_UP: if ( type == RTT_VIEWTYPE_BUF) { if ( ctx->start_row - RTTVIEW_ARROW_INC < 0) { ctx->start_row = 0; row_change = RTTVIEW_ARROW_INC - ctx->start_row; } else { ctx->start_row -= RTTVIEW_ARROW_INC; row_change = -RTTVIEW_ARROW_INC; } redraw = 0; } else { ctx->start_row -= RTTVIEW_ARROW_INC; row_change = -RTTVIEW_ARROW_INC; redraw = 0; } break; case RTT_K_ARROW_DOWN: ctx->start_row += RTTVIEW_ARROW_INC; row_change = RTTVIEW_ARROW_INC; redraw = 0; break; case RTT_K_ARROW_RIGHT: left_marg += 8; redraw = 1; break; case RTT_K_ARROW_LEFT: redraw = 1; left_marg -= 8; if ( left_marg < 0) left_marg = 0; break; case RTT_K_NEXTPAGE: /* Next page */ ctx->start_row += RTTVIEW_PAGE_INC; row_change = RTTVIEW_PAGE_INC; redraw = 0; break; case RTT_K_PREVPAGE: /* Previous page */ ctx->start_row -= RTTVIEW_PAGE_INC; row_change = -RTTVIEW_PAGE_INC; redraw = 0; break; case RTT_K_RETURN: break; case RTT_K_PF1: /* Top */ ctx->buffstart_row = 0; ctx->start_row = 0; rtt_read_buff( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 1, page_size, &ctx->start_row); redraw = 1; break; case RTT_K_PF2: /* Bottom */ ctx->start_row = max( 0, ctx->buffrow_count - page_size); if ( type == RTT_VIEWTYPE_FILE) { while( ctx->read_sts != NULL) { rtt_read_buff( ctx, ctx->buff, RTTVIEW_BUFF_SIZE, ctx->buffrow, RTTVIEW_BUFFROW_SIZE, &ctx->buffrow_count, 0, page_size, &ctx->start_row); ctx->start_row = ctx->buffrow_count - page_size + 1; } } redraw = 1; break; case RTT_K_PF3: rtt_message('E', "Function not defined"); break; case RTT_K_PF4: if ( type == RTT_VIEWTYPE_FILE) fclose( ctx->infile); free( ctx->buff); free( ctx->buffrow); free( ctx); rtt_ctx_pop(); return RTT__SUCCESS; case RTT_K_FAST_1: case RTT_K_FAST_2: case RTT_K_FAST_3: case RTT_K_FAST_4: case RTT_K_FAST_5: case RTT_K_FAST_6: case RTT_K_FAST_7: case RTT_K_FAST_8: case RTT_K_FAST_9: case RTT_K_FAST_10: case RTT_K_FAST_11: case RTT_K_FAST_12: case RTT_K_FAST_13: case RTT_K_FAST_14: case RTT_K_FAST_15: rtt_fastkey = terminator - RTT_K_FAST; sts = rtt_get_fastkey_type(); if ( sts == RTT__NOPICTURE) { sts = rtt_get_fastkey_picture( (menu_ctx) ctx); if ( EVEN(sts)) return sts; break; } case RTT_K_CTRLZ: if ( type == RTT_VIEWTYPE_FILE) fclose( ctx->infile); free( ctx->buff); free( ctx->buffrow); free( ctx); rtt_ctx_pop(); return RTT__FASTBACK; case RTT_K_CTRLW: redraw = 1; break; case RTT_K_CTRLK: /* Acknowledge last alarm */ sts = rtt_alarm_ack_last(); break; case RTT_K_CTRLL: /* Change description mode */ if ( !rtt_description_on) sts = rtt_cli( rtt_command_table, "SET DESCRIPTION", (void *) ctx, 0); else sts = rtt_cli( rtt_command_table, "SET NODESCRIPTION", (void *) ctx, 0); break; case RTT_K_CTRLV: break; case RTT_K_CTRLN: break; case RTT_K_DELETE: break; case RTT_K_COMMAND: sts = rtt_get_command( (menu_ctx) ctx, (char *) &rtt_chn, rtt_recallbuff, 0, 0, ctx, "pwr_rtt> ", 0, RTT_ROW_COMMAND, rtt_command_table); /* menu_ptr might have been changed */ if ( EVEN(sts)) return sts; if ( sts == RTT__FASTBACK) { if ( type == RTT_VIEWTYPE_FILE) fclose( ctx->infile); free( ctx->buff); free( ctx->buffrow); free( ctx); rtt_ctx_pop(); return RTT__FASTBACK; } if ( sts == RTT__BACK) { if ( type == RTT_VIEWTYPE_FILE) fclose( ctx->infile); free( ctx->buff); free( ctx->buffrow); free( ctx); rtt_ctx_pop(); return RTT__SUCCESS; } if ( sts == RTT__BACKTOCOLLECT) { if ( type == RTT_VIEWTYPE_FILE) fclose( ctx->infile); free( ctx->buff); free( ctx->buffrow); free( ctx); rtt_ctx_pop(); return RTT__BACKTOCOLLECT; } if ( sts != RTT__NOPICTURE) { redraw = 1; } break; case RTT_K_HELP: /* Try to find subject in application help */ sts = rtt_help( parent_ctx, "VIEW WINDOW", rtt_appl_helptext); if ( sts == RTT__NOHELPSUBJ) rtt_help( parent_ctx, "OBJECT MENU", (rtt_t_helptext *) rtt_command_helptext); redraw = 1; break; } } return RTT__SUCCESS; }
int main(int argc, char* argv[]) { remtrans_item* remtrans; unsigned char id[32]; unsigned char pname[32]; pwr_tStatus sts; int i; float time_since_scan = 0.0; /* Read arg number 2, should be id for this instance and id is our queue * number */ if (argc >= 2) strcpy((char*)id, argv[1]); else strcpy((char*)id, "0"); /* Build process name with id */ sprintf((char*)pname, "rs_remrabbitmq_%s", id); /* Init of errh */ errh_Init((char*)pname, errh_eAnix_remote); errh_SetStatus(PWR__SRVSTARTUP); /* Init of gdh */ if (debug) printf("Before gdh_init\n"); sts = gdh_Init((char*)pname); if (EVEN(sts)) { errh_Fatal("gdh_Init, %m", sts); errh_SetStatus(PWR__SRVTERM); exit(sts); } /* Arg number 3 should be my remnodes objid in string representation, read it, convert to real objid and store in remnode_item */ sts = 0; if (argc >= 3) sts = cdh_StringToObjid(argv[2], &rn.objid); if (EVEN(sts)) { errh_Fatal("cdh_StringToObjid, %m", sts); errh_SetStatus(PWR__SRVTERM); exit(sts); } /* Get pointer to RemnodeRabbitMQ object and store locally */ sts = gdh_ObjidToPointer(rn.objid, (pwr_tAddress*)&rn_rmq); if (EVEN(sts)) { errh_Fatal("cdh_ObjidToPointer, %m", sts); errh_SetStatus(PWR__SRVTERM); exit(sts); } if (streq(rn_rmq->ReceiveQueue, "") && streq(rn_rmq->SendQueue, "")) { errh_Fatal( "Process terminated, neither send or receive queue configured, %s", id); errh_SetStatus(PWR__SRVTERM); exit(sts); } /* Create context */ ctx = calloc(1, sizeof(*ctx)); ctx->op = rn_rmq; if (!streq(rn_rmq->ReceiveQueue, "")) ctx->is_consumer = 1; if (!streq(rn_rmq->SendQueue, "")) ctx->is_producer = 1; /* Initialize some internal data and make standard remtrans init */ rn.next = NULL; rn.local = NULL; // We dont use local structure since we only have one remnode rn_rmq->ErrCount = 0; if (debug) printf("Before remtrans_init\n"); sts = RemTrans_Init(&rn); if (EVEN(sts)) { errh_Fatal("RemTrans_Init, %m", sts); errh_SetStatus(PWR__SRVTERM); exit(sts); } /* Store remtrans objects objid in remnode_qcom object */ remtrans = rn.remtrans; i = 0; while (remtrans) { rn_rmq->RemTransObjects[i++] = remtrans->objid; if (i >= (int)(sizeof(rn_rmq->RemTransObjects) / sizeof(rn_rmq->RemTransObjects[0]))) break; remtrans = (remtrans_item*)remtrans->next; } /* Connect to rabbitmq broker */ sts = rmq_connect(); if (EVEN(sts)) { rmq_close(1); errh_Fatal("Process terminated, unable to connect to RabbitMQ, %s", id); errh_SetStatus(PWR__SRVTERM); exit(sts); } /* Set running status */ errh_SetStatus(PWR__SRUN); /* Set (re)start time in remnode object */ time_GetTime(&rn_rmq->RestartTime); /* Loop forever */ while (!doomsday) { if (rn_rmq->Disable == 1) { errh_Fatal("Disabled, exiting"); errh_SetStatus(PWR__SRVTERM); exit(0); } aproc_TimeStamp(TIME_INCR, 5); if (ctx->is_consumer) sts = rmq_receive(); else RemoteSleep(TIME_INCR); time_since_scan += TIME_INCR; if (time_since_scan >= rn_rmq->ScanTime) { if (ctx->is_producer) sts = RemTrans_Cyclic(&rn, &rmq_send); time_since_scan = 0.0; } } }
static void attrvalue_to_string( int type_id, void *value_ptr, char *str, int size, int *len, char *format) { pwr_tObjid objid; pwr_sAttrRef *attrref; int sts; char timstr[64]; if ( value_ptr == 0) { strcpy( str, "UNDEFINED"); return; } switch ( type_id ) { case pwr_eType_Boolean: { if ( !format) *len = sprintf( str, "%d", *(pwr_tBoolean *)value_ptr); else *len = sprintf( str, format, *(pwr_tBoolean *)value_ptr); break; } case pwr_eType_Float32: { if ( !format) *len = sprintf( str, "%f", *(float *)value_ptr); else *len = sprintf( str, format, *(float *)value_ptr); break; } case pwr_eType_Float64: { if ( !format) *len = sprintf( str, "%f", *(double *)value_ptr); else *len = sprintf( str, format, *(double *)value_ptr); break; } case pwr_eType_Char: { if ( !format) *len = sprintf( str, "%c", *(char *)value_ptr); else *len = sprintf( str, format, *(char *)value_ptr); break; } case pwr_eType_Int8: { if ( !format) *len = sprintf( str, "%d", *(char *)value_ptr); else *len = sprintf( str, format, *(char *)value_ptr); break; } case pwr_eType_Int16: { if ( !format) *len = sprintf( str, "%hd", *(short *)value_ptr); else *len = sprintf( str, format, *(short *)value_ptr); break; } case pwr_eType_Int32: { if ( !format) *len = sprintf( str, "%d", *(int *)value_ptr); else *len = sprintf( str, format, *(int *)value_ptr); break; } case pwr_eType_Int64: { if ( !format) *len = sprintf( str, pwr_dFormatInt64, *(pwr_tInt64 *)value_ptr); else *len = sprintf( str, format, *(pwr_tInt64 *)value_ptr); break; } case pwr_eType_UInt8: { if ( !format) *len = sprintf( str, "%d", *(unsigned char *)value_ptr); else *len = sprintf( str, format, *(unsigned char *)value_ptr); break; } case pwr_eType_UInt16: { if ( !format) *len = sprintf( str, "%hd", *(unsigned short *)value_ptr); else *len = sprintf( str, format, *(unsigned short *)value_ptr); break; } case pwr_eType_UInt32: case pwr_eType_Mask: case pwr_eType_Enum: { if ( !format) *len = sprintf( str, "%d", *(unsigned int *)value_ptr); else *len = sprintf( str, format, *(unsigned int *)value_ptr); break; } case pwr_eType_UInt64: { if ( !format) *len = sprintf( str, pwr_dFormatUInt64, *(pwr_tUInt64 *)value_ptr); else *len = sprintf( str, format, *(pwr_tUInt64 *)value_ptr); break; } case pwr_eType_String: { strncpy( str, (char *)value_ptr, size); str[size-1] = 0; *len = strlen(str); break; } case pwr_eType_Objid: { pwr_tOName hiername; objid = *(pwr_tObjid *)value_ptr; if ( !objid.oix) sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mName_volumeStrict); else sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mNName); if (EVEN(sts)) { strcpy( str, ""); *len = 0; break; } *len = sprintf( str, "%s", hiername); break; } case pwr_eType_AttrRef: { pwr_tAName hiername; attrref = (pwr_sAttrRef *) value_ptr; sts = gdh_AttrrefToName ( attrref, hiername, sizeof(hiername), cdh_mNName); if (EVEN(sts)) { strcpy( str, ""); *len = 0; break; } *len = sprintf( str, "%s", hiername); break; } case pwr_eType_Time: { sts = time_AtoAscii( (pwr_tTime *) value_ptr, time_eFormat_DateAndTime, timstr, sizeof(timstr)); if ( EVEN(sts)) strcpy( timstr, "-"); *len = sprintf( str, "%s", timstr); break; } case pwr_eType_DeltaTime: { sts = time_DtoAscii( (pwr_tDeltaTime *) value_ptr, 1, timstr, sizeof(timstr)); if ( EVEN(sts)) strcpy( timstr, "Undefined time"); *len = sprintf( str, "%s", timstr); break; } case pwr_eType_ObjectIx: { *len = sprintf( str, "%s", cdh_ObjectIxToString( NULL, *(pwr_tObjectIx *) value_ptr, 1)); break; } case pwr_eType_ClassId: { pwr_tOName hiername; objid = cdh_ClassIdToObjid( *(pwr_tClassId *) value_ptr); sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mNName); if (EVEN(sts)) { strcpy( str, ""); *len = 0; break; } *len = sprintf( str, "%s", hiername); break; } case pwr_eType_TypeId: { pwr_tOName hiername; objid = cdh_TypeIdToObjid( *(pwr_tTypeId *) value_ptr); sts = gdh_ObjidToName ( objid, hiername, sizeof(hiername), cdh_mNName); if (EVEN(sts)) { strcpy( str, ""); *len = 0; break; } *len = sprintf( str, "%s", hiername); break; } case pwr_eType_VolumeId: { *len = sprintf( str, "%s", cdh_VolumeIdToString( NULL, *(pwr_tVolumeId *) value_ptr, 1, 0)); break; } case pwr_eType_RefId: { *len = sprintf( str, "%s", cdh_SubidToString( NULL, *(pwr_tSubid *) value_ptr, 1)); break; } } }
Boolean WNavMotif::sel_convert_cb( Widget w, Atom *selection, Atom *target, Atom *type_return, XtPointer *value_return, unsigned long *length_return, int *format_return) { WNavMotif *wnav; brow_tCtx browctx; int sts; int size; WItem *item; pwr_tAName attr_str; pwr_sAttrRef attrref; char name[200]; char *buffp; BrowCtxFromWidget( w, (void **) &browctx); brow_GetCtxUserData( browctx, (void **) &wnav); if (*target == XA_TARGETS(flow_Display(wnav->brow_widget))) { Atom *targetP; Atom *std_targets; unsigned long std_length; XSelectionRequestEvent *req = XtGetSelectionRequest( w, *selection, (XtRequestId)NULL); XmuConvertStandardSelection( w, req->time, selection, target, type_return, (caddr_t *)&std_targets, &std_length, format_return); *value_return = XtMalloc( sizeof(Atom) * (std_length + 2)); targetP = *(Atom **) value_return; *targetP++ = XA_STRING; *targetP++ = XA_TEXT(flow_Display(wnav->brow_widget)); *length_return = std_length + (targetP - (*(Atom **) value_return)); bcopy((char *)std_targets, (char *)targetP, sizeof(Atom) * std_length); XtFree( (char *)std_targets); *type_return = XA_ATOM; *format_return = 32; return True; } if (*target == XA_STRING || *target == XA_TEXT(flow_Display(wnav->brow_widget)) || *target == XA_COMPOUND_TEXT(flow_Display(wnav->brow_widget)) || *target == wnav->graph_atom || *target == wnav->objid_atom || *target == wnav->attrref_atom) { brow_tNode *node_list; int node_count; wnav_eSelectionFormat format; if ( *target == wnav->graph_atom) format = wnav_eSelectionFormat_Graph; else if ( *target == wnav->objid_atom) format = wnav_eSelectionFormat_Objid; else if ( *target == wnav->attrref_atom) format = wnav_eSelectionFormat_Attrref; else format = wnav_eSelectionFormat_User; brow_GetSelectedNodes( wnav->brow->ctx, &node_list, &node_count); if ( !node_count) return FALSE; brow_GetUserData( node_list[0], (void **)&item); switch( item->type) { case wnav_eItemType_Attr: case wnav_eItemType_AttrInput: case wnav_eItemType_AttrInputInv: case wnav_eItemType_AttrInputF: case wnav_eItemType_AttrOutput: case wnav_eItemType_AttrArray: case wnav_eItemType_AttrArrayOutput: case wnav_eItemType_AttrArrayElem: case wnav_eItemType_AttrObject: { WItemBaseAttr *aitem = (WItemBaseAttr *)item; sts = ldh_ObjidToName( wnav->ldhses, item->objid, ldh_eName_Hierarchy, attr_str, sizeof(attr_str), &size); if ( EVEN(sts)) return FALSE; strcat( attr_str, "."); strcat( attr_str, aitem->name); sts = ldh_NameToAttrRef( wnav->ldhses, attr_str, &attrref); if ( EVEN(sts)) return FALSE; sts = (wnav->format_selection_cb)( wnav->parent_ctx, attrref, &buffp, 0, 1, format); *value_return = XtNewString(buffp); *length_return = strlen(buffp) + 1; if ( !sts) return FALSE; break; } case wnav_eItemType_Object: memset( &attrref, 0, sizeof(attrref)); attrref.Objid = item->objid; sts = (wnav->format_selection_cb)( wnav->parent_ctx, attrref, &buffp, 0, 0, format); *value_return = XtNewString(buffp); *length_return = strlen(buffp) + 1; if ( !sts) return FALSE; break; default: brow_GetAnnotation( node_list[0], 0, name, sizeof(name)); *value_return = XtNewString(name); *length_return = strlen(name) + 1; } free( node_list); if ( *target == XA_COMPOUND_TEXT(flow_Display(wnav->brow_widget)) || *target == wnav->graph_atom || *target == wnav->objid_atom || *target == wnav->attrref_atom) *type_return = *target; else *type_return = XA_STRING; *format_return = 8; return TRUE; } return FALSE; }
main(int argc, char *argv[]) { int sts; char *ssts; int size; char object_var[] = "Z800022"; char newstr[1000000]; char str[1000000]; FILE *infile; FILE *outfile; char error_line[80]; int error_num; char filename[80]; int pos; char line[400]; int arg_classdef_idx; int outsize; FILE *idxfile; if ( argc >= 2 ) strcpy( filename, argv[1]); else { printf("\n"); printf("Usage:\n"); printf(" Argument 1: filename of wb_load-file.\n"); printf(" Argument 2: Start index for $ClassDef objekts or\n"); printf(" if \"storedidx\" fetch from classdef_idx.dat\n"); printf(" Argument 3: if \"replace\" old index will be replaced\n"); printf("\n"); exit(0); } if ( argc >= 3 ) { if ( !strcmp( argv[2], "storedidx")) { idxfile = fopen( "classdef_idx.dat", "r"); if ( idxfile == 0) { printf( "-- Index file not found\n"); arg_classdef_idx = 1; } fscanf( idxfile, "%d", &arg_classdef_idx); fclose( idxfile); } else if ( sscanf( argv[2], "%d", &arg_classdef_idx) != 1) { printf("** WbloadConvert Error, Syntax error in argument 2\n"); exit(0); } } else arg_classdef_idx = 1; classdef_idx = arg_classdef_idx; noclassdef = 0; replace_idx = 1; if ( argc >= 4 ) { if ( !strcmp( argv[3], "noreplace")) replace_idx = 0; else if ( !strcmp( argv[3], "NOREPLACE")) replace_idx = 0; else if ( !strcmp( argv[3], "noclassdef")) noclassdef = 1; else if ( !strcmp( argv[3], "NOCLASSDEF")) noclassdef = 1; else { printf("** WbloadConvert Error, Syntax error in argument 3\n"); exit(0); } } printf("-- Processing %s Startindex $ClassDef: %d\n", filename, arg_classdef_idx); str[0] = 0; pos = 0; infile = fopen( filename, "r"); ssts = fgets( line, sizeof(line), infile); while ( ssts != NULL) { strcpy( str + pos, line); pos += strlen(line); ssts = fgets( line, sizeof(line), infile); } fclose( infile); size = sizeof(error_line); sts = convwbl_convert( str, newstr, object_var, sizeof(newstr), error_line, &size, &error_num, &outsize); if (EVEN(sts)) { printf( "Error in line %d,\n %s\n", error_num, error_line); printf( "sts : %d\n", sts); exit( 0); } if ( idx_count) { outfile = fopen( filename, "w"); fwrite( newstr, outsize, 1, outfile); fgetname( outfile, filename); fclose( outfile); printf( "-- File %s created\n Endindex $ClassDef %d, %d changes\n", filename, classdef_idx, idx_count); } else printf( "-- No changes in file\n", filename); idxfile = fopen( "classdef_idx.dat", "r+"); if ( !idxfile) { idxfile = fopen( "classdef_idx.dat", "w"); if ( !idxfile ) { printf( "** Unable to store index i indexfile\n"); exit(0); } } fprintf( idxfile, "%d", classdef_idx+1); fclose( idxfile); exit( sts); }
static void pwrsrv_SubAdd( rpvd_sMsgSubAdd *msg) { rpvd_sMsgAny rmsg; pwr_tAName name; pwr_tUInt32 asize, aoffs, aelem; pwr_tTypeId atid; pwr_tStatus sts; pwrsrv_sSubItem *si; void *p; pwr_tRefId dlid; rmsg.Type = rpvd_eMsg_Status; rmsg.Id = msg->Id; /* Check that this rix doesn't exist */ for ( si = pwrsrv_sublist; si; si = si->next) { if ( si->rix == msg->Rix) { return; } } sts = gdh_ObjidToName( msg->Oid, name, sizeof(name), cdh_mName_volumeStrict); if ( EVEN(sts)) { rmsg.Status = sts; udp_Send( (char *)&rmsg, sizeof(rmsg)); return; } if ( strcmp( msg->Attribute, "") != 0) { strcat( name, "."); strcat( name, msg->Attribute); sts = gdh_GetAttributeCharacteristics( name, &atid, &asize, &aoffs, &aelem); if ( EVEN(sts)) { rmsg.Status = sts; udp_Send( (char *)&rmsg, sizeof(rmsg)); return; } } else { sts = gdh_GetObjectSize( msg->Oid, &asize); if ( EVEN(sts)) { rmsg.Status = sts; udp_Send( (char *)&rmsg, sizeof(rmsg)); return; } } /* Direct link to atttribute */ sts = gdh_RefObjectInfo( name, &p, &dlid, asize); if ( EVEN(sts)) { rmsg.Status = sts; udp_Send( (char *)&rmsg, sizeof(rmsg)); return; } /* Insert first in sublist */ si = (pwrsrv_sSubItem *) calloc( 1, sizeof(pwrsrv_sSubItem)); si->oid = msg->Oid; strcpy( si->attribute, msg->Attribute); si->size = asize; si->rix = msg->Rix; si->p = p; si->dlid = dlid; si->next = pwrsrv_sublist; if ( si->next) si->next->prev = si; pwrsrv_sublist = si; printf( "SubAdd: %d %s\n", msg->Rix, name); rmsg.Status = GDH__SUCCESS; udp_Send( (char *)&rmsg, sizeof(rmsg)); }
/************************************************************************* * * Name: convwbl_convert * * Type int * * Type Parameter IOGF Description * char *str I buffer to convert. * char *newstr I converted code. * char *object I name of object pointer. * char *bufsize I size of newstr. * * Description: * Convert a wb_load text. * **************************************************************************/ pwr_tStatus convwbl_convert ( char *str, char *newstr, char *object, int bufsize, char *error_line, int *error_line_size, int *error_line_num, int *outsize ) { char line[200]; char *p; convwbl_t_item *item_ptr; pwr_tStatus sts; char *t; char *delim_p; int hit, delim_hit; char tmpstr[160]; char *write_from; int first_line; int end_of_text; int len; convwbl_ctx convwblctx; int pos; int incr; char *l; sts = convwbl_create_ctx( &convwblctx); if ( EVEN(sts)) return sts; idx_count = 0; pos = 0; *newstr = 0; first_line = 1; while( 1) { end_of_text = convwbl_get_next_line( str, &p, line, sizeof(line), first_line); convwblctx->line_count++; first_line = 0; item_ptr = convwblctx->items; while( item_ptr->item[0] != 0) { item_ptr->hit = 0; item_ptr->hit_count = 0; item_ptr++; } hit = 0; for ( l = line; *l != 0; l++) { if ( !(*l == ' ' || *l == ' ')) break; } if ( *l == '!') { sprintf( newstr+pos, "%s", line); pos += strlen(line); } else { t = line; write_from = t; item_ptr = convwblctx->items; while( item_ptr->item[0] != 0) { if ( item_ptr->hit == 0) { /* Check front delimiter */ delim_p = &item_ptr->delim_front[0]; while( *delim_p != 0) { if ( *delim_p == 'A' || *delim_p == 'X') { item_ptr->hit = 1; item_ptr->hit_count = 1; } delim_p++; } } item_ptr++; } while( *t != 0) { item_ptr = convwblctx->items; while( item_ptr->item[0] != 0) { if ( item_ptr->hit == 0) { /* Check front delimiter */ delim_p = &item_ptr->delim_front[0]; while( *delim_p != 0) { if ( ( *delim_p == 'A' && !convwbl_isascii(*t)) || ( *delim_p == 'X') || ( *delim_p == *t && *delim_p != 'A')) { item_ptr->hit = 1; item_ptr->hit_count = 1; } delim_p++; } } else { if ( item_ptr->hit_count >= 1 && item_ptr->hit_count < strlen( item_ptr->item) + 1) { if ( item_ptr->item[item_ptr->hit_count-1] == *t) { /* Still hit */ item_ptr->hit_count++; } else { delim_hit = 0; if ( item_ptr->hit_count == 1) { /* More delimiter */ delim_p = &item_ptr->delim_front[0]; while( *delim_p != 0) { if (( *delim_p == 'A' && !convwbl_isascii(*t)) || ( *delim_p == 'X')) delim_hit = 1; else if ( *delim_p == *t) delim_hit = 1; delim_p++; } } if ( !delim_hit) { item_ptr->hit = 0; item_ptr->hit_count = 0; } } } else if ( item_ptr->hit_count == strlen( item_ptr->item) + 1) { delim_p = &item_ptr->delim_back[0]; while( *delim_p != 0) { if (( *delim_p == 'A' && !convwbl_isascii(*t)) || ( *delim_p == 'X')) { hit = 1; } else if ( *delim_p == *t) { hit = 1; } delim_p++; } if ( hit) break; item_ptr->hit = 0; item_ptr->hit_count = 0; } } item_ptr++; } if ( hit) { if ( convwblctx->comment && !(item_ptr->func == &convwbl_comment_end)) { /* Reset all except the comment_end (first item)*/ hit = 0; item_ptr = convwblctx->items; item_ptr++; while( item_ptr->item[0] != 0) { item_ptr->hit = 0; item_ptr->hit_count = 0; item_ptr++; } } else { /* Write line */ strcpy( tmpstr, write_from); tmpstr[ t - write_from - strlen(item_ptr->item)] = 0; strcpy( newstr+pos, tmpstr); pos += strlen(tmpstr); sts = (item_ptr->func) (convwblctx, line, t, newstr+pos, &incr, object); if ( EVEN(sts)) { strncpy( error_line, line, *error_line_size); *error_line_num = convwblctx->line_count, convwbl_delete_ctx( convwblctx); return sts; } pos += incr; write_from = t; item_ptr = convwblctx->items; while( item_ptr->item[0] != 0) { item_ptr->hit = 0; item_ptr->hit_count = 0; item_ptr++; } hit = 0; } } else t++; } strcpy( newstr+pos, write_from); pos += strlen(write_from); newstr[ pos] = 0; if ( pos > bufsize - 100) { convwbl_delete_ctx( convwblctx); return GSX__CONVWBLBUFSIZE; } } if ( end_of_text) break; } *outsize = pos; convwbl_delete_ctx( convwblctx); return GSX__SUCCESS; }
static void pwrsrv_Oid( rpvd_sMsgOid *msg) { rpvd_sMsgObject rmsg; pwr_tOid fth; pwr_tOid fch; pwr_tOid lch; pwr_tOid bws; pwr_tOid fws; pwr_tCid cid; pwr_tObjName name; pwr_tOid o; pwr_tStatus sts; pwr_tOid plist[200]; int psize = 0; int i, j; char *s; rmsg.Type = rpvd_eMsg_Object; rmsg.Id = msg->Id; rmsg.Status = 1; rmsg.Oid = msg->Oid; sts = gdh_GetObjectClass( msg->Oid, &cid); if ( EVEN(sts)) { rmsg.Status = sts; udp_Send( (char *)&rmsg, sizeof(rmsg)); return; } plist[psize++] = msg->Oid; for ( sts = gdh_GetParent( plist[psize-1], &o); ODD(sts); sts = gdh_GetParent( plist[psize-1], &o)) { plist[psize++] = o; } /* Add volume object */ plist[psize].oix = 0; plist[psize++].vid = msg->Oid.vid; for ( j = 0; j < psize; j++) { i = psize - j - 1; sts = gdh_GetObjectClass( plist[i], &cid); if ( i == psize - 1) { /* Volume object */ fth.oix = 0; sts = gdh_GetRootList( &fch); if ( EVEN(sts)) { fch.oix = 0; lch.oix = 0; } else { sts = 1; for ( lch = fch; ODD(sts); sts = gdh_GetNextSibling( lch, &o)) { lch = o; } } fws.oix = 0; bws.oix = 0; sts = gdh_ObjidToName( plist[i], name, sizeof(name), cdh_mName_volume); if ( (s = strrchr( name, ':'))) *s = 0; } else { sts = gdh_GetParent( plist[i], &fth); if ( EVEN(sts)) fth.oix = 0; sts = gdh_GetChild( plist[i], &fch); if ( EVEN(sts)) { fch.oix = 0; lch.oix = 0; } else { lch = fch; for ( sts = gdh_GetNextSibling( lch, &o); ODD(sts); sts = gdh_GetNextSibling( lch, &o)) { lch = o; } } sts = gdh_GetNextSibling( plist[i], &fws); if ( EVEN(sts)) fws.oix = rmsg.o[j-1].fchoix; sts = gdh_GetPreviousSibling( plist[i], &bws); if ( EVEN(sts)) bws.oix = rmsg.o[j-1].lchoix; sts = gdh_ObjidToName( plist[i], name, sizeof(name), cdh_mName_object); } rmsg.o[j].oix = plist[i].oix; rmsg.o[j].fthoix = fth.oix; rmsg.o[j].fchoix = fch.oix; rmsg.o[j].lchoix = lch.oix; rmsg.o[j].fwsoix = fws.oix; rmsg.o[j].bwsoix = bws.oix; rmsg.o[j].cid = cid; strcpy( rmsg.o[j].name, name); } rmsg.OSize = psize; udp_Send( (char *)&rmsg, sizeof(rmsg)); }
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; }
int main(int argc, char** argv) { pwr_tStatus sts; io_tCtx io_ctx; float ctime = 1; pwr_sClass_EplHandler* plhp; pwr_tOid oid; int tmo; char mp[2000]; qcom_sGet get; qcom_sQattr qAttr; qcom_sQid qini; qcom_sQid qid = qcom_cNQid; if (argc > 1) { if (streq(argv[1], "-m")) { io_methods_print(); exit(0); } if (streq(argv[1], "-h")) { usage(); exit(0); } } // Make connection to error handler errh_Init("pwr_powerlink", errh_eAnix_powerlink); errh_SetStatus(PWR__SRVSTARTUP); if (!qcom_Init(&sts, 0, "pwr_powerlink")) { errh_Fatal("qcom_Init, %m", sts); exit(sts); } qAttr.type = qcom_eQtype_private; qAttr.quota = 100; if (!qcom_CreateQ(&sts, &qid, &qAttr, "events")) { errh_Fatal("qcom_CreateQ, %m", sts); exit(sts); } qini = qcom_cQini; if (!qcom_Bind(&sts, &qid, &qini)) { errh_Fatal("qcom_Bind(Qini), %m", sts); exit(-1); } // Make connection to realtime database sts = gdh_Init("rt_powerlink"); if (EVEN(sts)) { errh_Fatal("rt_powerlink aborted, gdh_Init failed\n%m", sts); errh_SetStatus(PWR__SRVTERM); exit(sts); } sts = gdh_GetClassList(pwr_cClass_Epl_CNServer, &oid); if (ODD(sts)) { system("rt_powerlink_cn &"); exit(0); } // Get Powerlink handler object sts = io_get_plhandler_object(&plhp, &oid); if (EVEN(sts)) { errh_SetStatus(0); errh_Info("rt_powerlink terminated, no EplHandler object found"); exit(sts); } // Create context and call init functions of all agent, // rack and cardobjects sts = io_init(io_mProcess_Powerlink, pwr_cNObjid, &io_ctx, 1, ctime); if (EVEN(sts)) { errh_SetStatus(PWR__SRVTERM); errh_Fatal("rt_powerlink aborted, io_init() failed\n%m", sts); exit(sts); } tmo = (plhp->CycleTime) * 1000; aproc_TimeStamp(plhp->CycleTime, 5.0); errh_SetStatus(PWR__SRUN); aproc_RegisterObject(oid); // Call IoAgentRead() IoAgentWrite() IoCardRead() IoCardWrite() // IoModuleRead() IoModuleWrite() forever for (;;) { get.maxSize = sizeof(mp); get.data = mp; qcom_Get(&sts, &qid, &get, tmo); if (sts == QCOM__TMO || sts == QCOM__QEMPTY) { sts = io_read(io_ctx); sts = io_write(io_ctx); aproc_TimeStamp(plhp->CycleTime, 5.0); } else { ini_mEvent new_event; qcom_sEvent* ep = (qcom_sEvent*)get.data; new_event.m = ep->mask; if (new_event.b.oldPlcStop) { // TODO } else if (new_event.b.swapDone) { // TODO } else if (new_event.b.terminate) { // io_close(io_ctx); exit(0); } } } }
pwr_tStatus WVsel::check_volumelist( int quiet, int *display_window ) { pwr_tVolumeId volume; pwr_tClassId classid; char name[80]; int size; pwr_tStatus sts; int i; lfu_t_volumelist *volumelist; lfu_t_volumelist *volumelist_ptr; int volumecount; int class_error; char volname_conf[80]; char volname_db[80]; int volume_found; int error_count; int errlen=0; int errlen_old = 0; char errstr[800]; error_count = 0; *display_window = 0; if ( !(CoLogin::privilege() & pwr_mPrv_DevConfig )) // No privileges for edit, don't check the volumes return 1; // Load the configured volume list sts = lfu_volumelist_load( pwr_cNameVolumeList, &volumelist, &volumecount); if (sts == FOE__NOFILE) { if ( !quiet) { printf( "** Error, project is not configured\n"); BEEP; *display_window = 1; } return 1; } else if (EVEN(sts)) return 1; sts = ldh_GetVolumeList( wbctx, &volume); while ( ODD(sts) ) { sts = ldh_GetVolumeClass( wbctx, volume, &classid); if (EVEN(sts)) return sts; sts = ldh_VolumeIdToName( wbctx, volume, name, sizeof(name), &size); if (EVEN(sts)) return sts; if ( classid == pwr_eClass_RootVolume || classid == pwr_eClass_SubVolume || (classid == pwr_eClass_SharedVolume && volume != ldh_cRtVolume) || (cdh_isClassVolumeClass(classid) && (cdh_cUserClassVolMin <= volume && volume <= cdh_cUserClassVolMax))) { // This volume should be configured volume_found = 0; volumelist_ptr = volumelist; for ( i = 0; i < volumecount; i++) { if ( volumelist_ptr->volume_id == volume) { // Mark that volume is found volume_found = 1; strcpy( volumelist_ptr->p3, "Found"); // Check volume name utl_toupper( volname_conf, volumelist_ptr->volume_name); utl_toupper( volname_db, name); if ( strcmp( volname_db, volname_conf)) { // Volume name differs if ( !quiet && errlen < (int)(sizeof(errstr)-100)) { errlen += sprintf( &errstr[errlen], "** Error, Volume %s is configured with another name '%s'\n", name, volumelist_ptr->volume_name); MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No); errlen_old = errlen; BEEP; } error_count++; } class_error = 0; switch( classid) { case pwr_eClass_RootVolume : if ( strcmp( volumelist_ptr->p1, "RootVolume")) class_error = 1; break; case pwr_eClass_SubVolume : if ( strcmp( volumelist_ptr->p1, "SubVolume")) class_error = 1; break; case pwr_eClass_ClassVolume : if ( strcmp( volumelist_ptr->p1, "ClassVolume")) class_error = 1; break; case pwr_eClass_DetachedClassVolume : if ( strcmp( volumelist_ptr->p1, "DetachedClassVolume")) class_error = 1; break; case pwr_eClass_SharedVolume : if ( strcmp( volumelist_ptr->p1, "SharedVolume")) class_error = 1; break; } if ( class_error) { if ( !quiet && errlen < (int)(sizeof(errstr)-100)) { errlen += sprintf( &errstr[errlen], "** Error, Volume %s is configured with another class '%s'\n", name, volumelist_ptr->p1); MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No); errlen_old = errlen; BEEP; } error_count++; } break; } volumelist_ptr++; } if ( !volume_found) { if ( !quiet && errlen < (int)(sizeof(errstr)-100)) { errlen += sprintf( &errstr[errlen], "** Error, Volume %s (%s) is not configured in the ProjectVolume\nCheck volume name and identity\n", name, cdh_VolumeIdToString( 0, volume, 1, 0)); MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No); errlen_old = errlen; BEEP; } error_count++; } } sts = ldh_GetNextVolume( wbctx, volume, &volume); } if ( error_count) { *display_window = 1; if ( !quiet) { errlen += sprintf( &errstr[errlen], "\n %d syntax error%s found\n", error_count, (error_count == 1) ? "" : "s"); MsgWindow::message( 'E', &errstr[errlen_old], msgw_ePop_No); errlen_old = errlen; wow->DisplayError( "Syntax control", errstr); } } return 1; }