Ejemplo n.º 1
0
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;
}
Ejemplo n.º 2
0
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;
      }
    }
  }
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
/***********************************************************************
 * 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;
        }
    }
Ejemplo n.º 5
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);
  }
}
Ejemplo n.º 6
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;
}
Ejemplo n.º 7
0
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;
}
Ejemplo n.º 8
0
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;
}
Ejemplo n.º 9
0
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;
}
Ejemplo n.º 10
0
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 */
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
//
// 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;
}
Ejemplo n.º 13
0
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;  

}
Ejemplo n.º 14
0
//
//  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");
    }
  }
}
Ejemplo n.º 15
0
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;
}
Ejemplo n.º 16
0
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;
}
Ejemplo n.º 17
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;
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
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;
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
0
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;
    }
  }
}
Ejemplo n.º 22
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;
    }

  }
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
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);
}
Ejemplo n.º 25
0
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));
}
Ejemplo n.º 26
0
/*************************************************************************
*
* 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;
}
Ejemplo n.º 27
0
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));
}
Ejemplo n.º 28
0
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;
}
Ejemplo n.º 29
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);
      }
    }
  }
}
Ejemplo n.º 30
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;
}