crono.c

实时操作系统RT LINUX的源代码

#include <string.h>

#include <stdio.h>

#include <stdlib.h>


#include <X11/Xlib.h>

#include <xview/xview.h>

#include <xview/xv_xrect.h>

#include <xview/scrollbar.h>

#include <xview/font.h>

#include <xview/canvas.h>

#include <xview/cursor.h>

#include <xview/panel.h>

#include <xview/file_chsr.h>

#include <sys/types.h>

#include "input.tab.h"

#include "crono.h"


#define SCROLL_JUMPS
    40


extern void PS_output();


static  int ALTO=200, ANCHO=1000;  /*  size of the chrong canvas */


static Frame    frame;

static Display  *dpy;
static Canvas      canvas;
static Window      xwin;
static Panel       control;
static Xv_opaque   bot_file,menu_file;
static Xv_opaque   vsb,hsb;
static Xv_opaque   saveas,openas;

static int         lee_esc_flag;
static Xv_opaque  pan_grid;

int   NPoints;
int   TimeSim;
int   NTasks;
int   NResources;

GC      gc;
GC      gc_xdot;    /* used to do the grid */
GC      gcerase;    /* Cleaner */
GC      gcupper;    /* Up line */
GC      gclower;    /* Down line */
GC      gcdiag;     /* Diag line */
GC      gctasks[MAX_TASKS];   /* colors for the tasks */

Accion        Chronog[MAX_MATRIX];
char          Tasks[MAX_TASKS][20];
char          Resources[MAX_TASKS][20];

char    Name_i[100];
char    Name_o[200]="Sim_crono.ps";



static void Dibuja(XRectangle *);
void X_Run_Simul();
void X_Simul_Start();
static void CreateGCs ();
void Redraw ();


static int     Scale1=10;
static int     Scale2=10;
static int     Grid_old=-1;
static int     Grid_new=-1;
static int     Each=100;


/***************************************************** lee_grid */
static void  lee_grid(Panel_item	item, Event	*event){
  int x = (int) xv_get(item, PANEL_VALUE);
  
  if (x==0) x=-1;

  if (x != Grid_new){
    Grid_old = Grid_new;
    Grid_new = x;
    if ((Grid_new!=-1) &&(Grid_new*Scale1/Scale2 <= 10)) {
      Grid_new=10*Scale2/Scale1;
      Grid_new= Grid_new? Grid_new:1;
      xv_set(pan_grid, PANEL_VALUE , Grid_new, NULL);
    }
    X_Run_Simul();
  }
}

/****************************************************************/
/********************************************** lee_salve_proc  */
void lee_proc(fc,path,file,client_data)
File_chooser fc;
char *path;
char *file;
Xv_opaque client_data;
{
  int ini, fin;
  Rect *rect;
  strcpy(Name_i,path);

  Redraw ();
  xv_set(fc, XV_SHOW,FALSE,NULL);
}

/****************************************************************/
/********************************************** salva_proc  */
void salva_proc(fc,path,file,client_data)
File_chooser fc;
char *path;
char *file;
Xv_opaque client_data;
{
  int ini, fin;
  Rect *rect;





  strcpy(Name_o,(char *)xv_get(saveas,FILE_CHOOSER_DOC_NAME,NULL)); 
  rect=(Rect *) xv_get(canvas,CANVAS_VIEWABLE_RECT,canvas_paint_window(canvas));
  PS_output(Name_o,(int)(rect->r_left*Scale2/Scale1),
	    (int)((rect->r_left+rect->r_width)*Scale2/Scale1));
  xv_set(fc, XV_SHOW,FALSE,NULL);
}

/****************************************************************/
/********************************************** menu_file_proc  */
void  menu_file_proc(Menu menu, Menu_item item){
  char *titulo;

  titulo=(char *)xv_get(item,MENU_STRING,NULL);

  switch (titulo[0]){
  case 'L' :  /* load */
  if(!openas) {
    openas = (File_chooser)xv_create((Xv_opaque)NULL,
				     FILE_CHOOSER_OPEN_DIALOG,
				     XV_LABEL,"File: Open Task Set",
				     FILE_CHOOSER_FILTER_STRING,"[0-9a-zA-Z]+[.]tsk$",
				     FILE_CHOOSER_SHOW_DOT_FILES,FALSE,
				     FILE_CHOOSER_ABBREV_VIEW,TRUE,
				     /*FILE_CHOOSER_ABBREV_VIEW,TRUE,*/
				     FILE_CHOOSER_NO_CONFIRM,FALSE,
				     FILE_CHOOSER_AUTO_UPDATE,TRUE,
				     FILE_CHOOSER_NOTIFY_FUNC,lee_proc,
/*				     XV_X,100,XV_Y,70,*/
				     NULL);
  }
  

    xv_set(openas,FILE_CHOOSER_DOC_NAME,Name_i,NULL);
    xv_set(openas,XV_SHOW,TRUE,NULL);
    lee_esc_flag=0;

    break;
  case 'S' : /* Save */
    if(!saveas) {
      saveas = (File_chooser)xv_create((Xv_opaque) NULL,
				       FILE_CHOOSER_SAVE_DIALOG,
				       XV_LABEL,"File: Save PostScript",
				       /*FILE_CHOOSER_FILTER_STRING,"[.*]*[.]ps",*/
				       /*FILE_CHOOSER_SHOW_DOT_FILES,FALSE,*/
				       FILE_CHOOSER_ABBREV_VIEW,TRUE,
				       FILE_CHOOSER_NO_CONFIRM,FALSE,
				       FILE_CHOOSER_AUTO_UPDATE,TRUE,
				       FILE_CHOOSER_NOTIFY_FUNC,salva_proc,
				       XV_X,100,XV_Y,70,
				       NULL);
    }
    
    xv_set(saveas,FILE_CHOOSER_DOC_NAME,Name_o,NULL);
    xv_set(saveas,XV_SHOW,TRUE,NULL);
    lee_esc_flag=1;
    break;
  case 'Q':
    exit(0);
    break;
  default:
    printf("Menu error\n");
  } 
  /*xv_set(ficha.frame_load_save, XV_SHOW, TRUE, NULL);*/

  
}



/****************************************************************/
/****************************************************** ord_mat */
int ord_mat (const void *A, const void *B){
  return ((Accion*)A)->x1 - ((Accion*)B)->x1;
}

/***************************************************** lee_zoom */
static void  lee_zoom(Panel_item item, Event *event){

  Scale1 = (int) xv_get(item, PANEL_VALUE);


  if (Scale1>0)
    Scale1 += Scale2 = 10;
  else if (Scale1<0){
    Scale2 = 10 - Scale1;  /* Scale1 is a negative number */
    Scale1 = 10;
  } else
    Scale1=Scale2=10;


  Each = (100* Scale2/Scale1);
  if (Each>5)
    Each = (Each/5)*5;
  if (!Each)
    Each=1;

  if ((Grid_new!=-1) && (Grid_new*Scale1/Scale2 <= 10) ){
    Grid_new=10*Scale2/Scale1;
    Grid_new= Grid_new? Grid_new:1;
    xv_set(pan_grid, PANEL_VALUE , Grid_new, NULL);
  }

  X_Run_Simul();
  
}

/****************************************************************/
/****************************************************** Redraw  */
void Redraw (){
  Fill_Matrix(Name_i);



  qsort(Chronog, NPoints, sizeof (Accion),  ord_mat);
  X_Run_Simul();
}


/************************************************************* Draw_event */
static void Draw_event(Accion *item){
  /*                               to draw  |_______^ */
  static XPoint  exec_frame[7]={{0,0},                                 
                                  {0,20},
                                  {0,0},
                                  {0,-10},
                                  {-2,5},
                                  {2,-5},
                                  {2,5}};

  switch(item->accion){
  case ACTI:
   exec_frame[0].x=10+item->x1*Scale1/Scale2;
    exec_frame[0].y=(int)(item->id)*40;
    exec_frame[2].x=(item->x2 - item->x1)*Scale1/Scale2;
    XDrawLines(dpy, xwin, gc, exec_frame, 7, CoordModePrevious);
    break;

  case EXEC:
    XFillRectangle(dpy, xwin, gctasks[item->id], 
		   10+item->x1*Scale1/Scale2,
		   (int)(item->id)*40+7, 
		   (item->x2 - item->x1)*Scale1/Scale2, 
		   13);

    XDrawRectangle(dpy, xwin, gc, 
		   10+item->x1*Scale1/Scale2,
		   (int)(item->id)*40+7, 
		   (item->x2 - item->x1)*Scale1/Scale2, 
		   13);

    break;

  case END:
    
    break;

    } /* switch */
}

/************************************************************* Dibuja */
static void Dibuja(XRectangle *area){
  int    x,y,m_period,fin_area_x,fina_area_y;
  char   cade[100];
  Rect  *rect;

  fin_area_x = area->x + area->width;
  area->x -=10;

  if (Each){
    x = ((area->x*Scale2/Scale1)/Each)* Each;
    for ( ; x<= (fin_area_x)*Scale2/Scale1 ; x += Each){
      sprintf(cade,"%d",x);
      XDrawString(dpy, xwin, gc, 10+x*Scale1/Scale2, 15, cade, strlen (cade));
      XDrawLine(dpy, xwin, gc_xdot, 10+x*Scale1/Scale2,15,10+x*Scale1/Scale2, 40);
    }
  }

  if (Grid_new != -1)
    for (x=((area->x*Scale2/Scale1)/Grid_new)*Grid_new ; x<=fin_area_x*Scale2/Scale1; x+=Grid_new)  /* grid */
      XDrawLine(dpy, xwin, gc_xdot, 10+x*Scale1/Scale2,40,10+x*Scale1/Scale2, 
		(NTasks)*40+40);

            /* looking for the start point in the chronog array */
  for (x=0; (Chronog[x].x2*Scale1/Scale2+4 <  area->x) && (x< NPoints) ; x++);
  
            /* Draw the chronog */
  for (; (x< NPoints) && (Chronog[x].x1*Scale1/Scale2< fin_area_x); x++)
    Draw_event(&Chronog[x]);
  
            /* Draw a circle if one task lose its deadline */
}



/************************************************************* X_Run_Simul */
void X_Run_Simul(){

  XRectangle  region;

  xv_set(canvas, CANVAS_HEIGHT,(NTasks+1)*40+40,NULL);
  xv_set(canvas, CANVAS_WIDTH,TimeSim*Scale1/Scale2+30,NULL);
  XClearWindow(dpy,xwin);
 
  region.x = 0;
  region.y =  0;
  region.width =  TimeSim*Scale1/Scale2+30;
  region.height = (NTasks+1)*40+40;

  Dibuja(&region);

}

/************************************************************* REPAINT_PROC */

static void repaint_proc(Canvas canvas,Xv_Window  paint_window ,
			 Display *dpy,Window xwin, Xv_xrectlist *xrects){
  int x;
  xv_set(canvas, CANVAS_HEIGHT,(NTasks+1)*40,NULL);
  xv_set(canvas, CANVAS_WIDTH,(int)(Scale1*TimeSim/Scale2)+30,NULL);
  for (x=0; x< xrects->count; x++)
    Dibuja(&(xrects->rect_array[x]));
  
}


void X_Simul_Start( ){
  
  
  frame = (Frame) xv_create((Xv_opaque) NULL, FRAME,
			   FRAME_SHOW_RESIZE_CORNER, TRUE,
			   FRAME_LABEL,              "Execution Display",
			   XV_HEIGHT,                ALTO+26,
			   NULL);
  
  control = (Panel) xv_create(frame,PANEL,
		      XV_X,0,
		      XV_Y,0,
		      XV_HEIGHT, 26,
		      NULL);
   menu_file = (Xv_opaque)xv_create((Xv_opaque)NULL,  MENU,
		       MENU_NOTIFY_PROC,  menu_file_proc,
		       MENU_STRINGS, "Load Task File", "Save as PostScript", "Quit", NULL,
		       NULL);
  bot_file = xv_create( control, PANEL_BUTTON,
		       XV_X,5,
		       XV_Y,5,
		       PANEL_LABEL_STRING, "File",
		       PANEL_ITEM_MENU, menu_file,
		       NULL);
  (void) xv_create(control,PANEL_BUTTON,
                          PANEL_LABEL_STRING,      "Redraw",
                          PANEL_NOTIFY_PROC,   Redraw,
                          NULL);       
   
  (void) xv_create(control, PANEL_NUMERIC_TEXT,
		   PANEL_VALUE_DISPLAY_LENGTH, 6,
		   PANEL_VALUE_STORED_LENGTH, 6,
		   PANEL_LABEL_STRING, "Zoom:",
		   PANEL_LAYOUT, PANEL_HORIZONTAL, 
		   PANEL_MAX_VALUE, 1000,
		   PANEL_MIN_VALUE, -1000,
		   PANEL_VALUE, 0,
		   PANEL_READ_ONLY, FALSE,
		   PANEL_NOTIFY_PROC, lee_zoom,
		   NULL);
   pan_grid = xv_create(control, PANEL_NUMERIC_TEXT,
		       PANEL_VALUE_DISPLAY_LENGTH, 6,
		       PANEL_VALUE_STORED_LENGTH, 6,
		       PANEL_LABEL_STRING, "Grid  :",
		       PANEL_LAYOUT, PANEL_HORIZONTAL, 
		       PANEL_MAX_VALUE, 1000,
		       PANEL_MIN_VALUE, 0,
		       PANEL_VALUE, 0,
		       PANEL_READ_ONLY, FALSE,
		       PANEL_NOTIFY_PROC, lee_grid,
		       NULL);
  
  canvas = (Canvas)xv_create(frame, CANVAS,
			     XV_X,0,
			     XV_Y,26,
			     CANVAS_X_PAINT_WINDOW,  TRUE,
			     CANVAS_REPAINT_PROC,    repaint_proc,
			     CANVAS_AUTO_SHRINK,     FALSE,
			     CANVAS_AUTO_EXPAND,     FALSE,
			     CANVAS_RETAINED,        FALSE,
			     CANVAS_WIDTH,      ANCHO,
			     CANVAS_HEIGHT,     (NTasks+1)*40,
			     OPENWIN_AUTO_CLEAR,     FALSE,
			     NULL);
  dpy = (Display *)xv_get (canvas_paint_window(canvas),XV_DISPLAY,NULL);
  xwin= xv_get (canvas_paint_window(canvas),XV_XID);
  
  
  vsb=xv_create(canvas, SCROLLBAR,
		SCROLLBAR_DIRECTION,            SCROLLBAR_VERTICAL,
		SCROLLBAR_PIXELS_PER_UNIT,      2,
		NULL);
	    
  hsb=xv_create(canvas, SCROLLBAR,
		SCROLLBAR_DIRECTION,            SCROLLBAR_HORIZONTAL,
		SCROLLBAR_PIXELS_PER_UNIT,      SCROLL_JUMPS,
		NULL);
  
  
  window_fit(frame);

}

/************************************************************* CreateGCs */
/* This function choose the best way to display the line according       */
/* to the monitor (BW, COLOR).                                           */
/*************************************************************************/
static void CreateGCs (){
  int           x;
  XGCValues     val;
  unsigned long gcmask;
  /* 0-> Diagonal line
     1-> Upper line
     2-> lower line
     3....-> tasks */
  static char   *ColorNames[][2]={{"black","red"},
                                    {"black","DarkSeeGreen"},
                                    {"black","blue"},
                                    {"black","NavyBlue"},
                                    {"black","plum"},
                                    {"black","orange1"},
                                    {"black","OliveDrab1"},
                                    {"black","hot pink"},
                                    {"black","coral1"},
                                    {"black","VioletRed4"},
                                    {"black","gold1"},
                                    {"black","yellow"},
                                    {"black","tomato"},
                                    {"black","peru"},
                                    {"black","pink"},
                                    {"black","SlateGray1"},
                                    {"black","coral1"},
                                    {"black","turquoise2"},
                                    {"black","SeeGreen3"},
                                    {"black","IndianRed3"},
                                    {"black","purple1"}};
  static        char      dash[3]={(char)1,(char)5};
  Colormap      dc;
  XColor        ColorNum[40],bgc;
  int           mon_type;
 
if (DefaultDepth (dpy, DefaultScreen (dpy)) < 2) /* Monochrome display */
    mon_type=0;
  else     /* Color display */
    mon_type=1;

 dc = DefaultColormap (dpy, DefaultScreen(dpy) );

  for (x=0; x< 20; x++){
    XParseColor (dpy, dc, ColorNames[x][mon_type], &ColorNum[x]);
    XAllocColor (dpy, dc, &ColorNum[x]);
  }
  XParseColor (dpy, dc, "white", &bgc);
  XAllocColor (dpy, dc, &bgc);
 
  gcmask = 0L;
  val.foreground = bgc.pixel;     gcmask |= GCForeground; 
  val.background = bgc.pixel;     gcmask |= GCBackground;
  val.graphics_exposures = False; gcmask |= GCGraphicsExposures;
  val.line_width = 1;             gcmask |= GCLineWidth;
  val.plane_mask = AllPlanes;     gcmask |= GCPlaneMask;

  gcerase = XCreateGC (dpy, xwin, gcmask, &val);

  val.foreground = ColorNum[0].pixel;
  gcdiag = XCreateGC (dpy, xwin, gcmask, &val);

  val.foreground = ColorNum[1].pixel;
  gcupper = XCreateGC (dpy, xwin, gcmask, &val);
 
  val.foreground = ColorNum[2].pixel;
  gclower = XCreateGC (dpy, xwin, gcmask, &val);
 
  for (x=0 ; x<MAX_TASKS; x++){
    val.foreground = ColorNum[3+(x%17)].pixel;
    gctasks[x]= XCreateGC (dpy, xwin, gcmask, &val);
  }

  gc = DefaultGC(dpy, DefaultScreen(dpy));
  XSetForeground(dpy, gc, XBlackPixel(dpy, DefaultScreen(dpy) ));
 
  gcmask = 0L;
  gc_xdot = XCreateGC (dpy, xwin, gcmask, &val);
  XSetForeground(dpy, gc_xdot, XBlackPixel(dpy, DefaultScreen(dpy) )); 
  XSetBackground(dpy, gc_xdot, XWhitePixel(dpy, DefaultScreen(dpy) )); 
  XSetDashes(dpy,gc_xdot , 0, dash, 2);
  XSetLineAttributes(dpy, gc_xdot, 0, LineOnOffDash ,CapRound, JoinBevel);


  
}


/****************************************************************/
/********************************************************* main */
main(int argc, char *argv[]) {
  int i,j;
  char *fil;

  xv_init(XV_INIT_ARGC_PTR_ARGV, &argc, argv, NULL);

  Name_o[0]=0x0;

  if (argc<2) {
    printf("Usage: crono filename\n");
    strcpy(Name_i,"");
  } else
    strcpy(Name_i,argv[1]);

  Fill_Matrix(Name_i);
  qsort(Chronog, NPoints, sizeof (Accion), ord_mat);
  
  X_Simul_Start( );
  CreateGCs (); 

  xv_main_loop(frame);
}