graph_c.cc

certi-SHM-3.0.tar 不错的开源的分布式方针软件 大家多多支持 他是linux

              pointt *PD, 
              point  COORD) {
      
      PD->POI_COORD  = COORD;   
      PD->POI_COULEUR  = P.POI_COULEUR;  
      Definex(PD->POI_COORD,
               PD->POI_COULEUR);
      Drawx(*PD);

}

point Coordx(pointt P)  {
    
       return P.POI_COORD;
  } 
                     
couleur Coulx(pointt P)  {
     
       return P.POI_COULEUR;
  }                                            

/*---------------------------------------------------------------------------*/

/*---module LIGNE-----*/ 
/*====================*/

ligne Definel(point    DEBUT,
               point    FIN,
               style    WSTYLE,
               couleur  WCOULEUR) {

       ligne Ligloc;
       Ligloc.LIG_DEBUT     = DEBUT;
       Ligloc.LIG_FIN       = FIN;
       Ligloc.LIG_STYLE     = WSTYLE; 
       Ligloc.LIG_COULEUR   = WCOULEUR; 
       return  Ligloc;
  } 
   
void Drawl(ligne L)  { 
                        
     nom_coul = rech(L.LIG_COULEUR) ;       
     code_ret = XAllocNamedColor(canal_aff,
                                  palette,
                                  nom_coul,
                                  &couleu,
                                  &exact); 

     masq_bin = GCLineStyle | GCForeground | GCFillStyle; 
     val_gc.line_style = LineSolid; 
     val_gc.foreground = couleu.pixel;
     val_gc.fill_style = FillSolid; 
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc); 

     c = L.LIG_STYLE;
     lignestyle(c);

     XDrawLine(canal_aff,
               nouv_fen,
               contexte_graph,
               L.LIG_DEBUT.X,
               L.LIG_DEBUT.Y,
               L.LIG_FIN.X,
               L.LIG_FIN.Y);
     XFlush(canal_aff);
  }  
   
void Undrawl(ligne L)  { 
                            
     masq_bin = GCForeground | GCLineStyle | GCFillStyle; 
     val_gc.foreground = carrplan; 
     val_gc.line_style = LineSolid;
     val_gc.fill_style = FillSolid;  
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);
  
     XDrawLine(canal_aff,
               nouv_fen,
               contexte_graph,
               L.LIG_DEBUT.X,
               L.LIG_DEBUT.Y,
               L.LIG_FIN.X,
               L.LIG_FIN.Y);
     XFlush(canal_aff);
  }  

void Change_attribl(ligne   *L,
                     style   WSTYLE,
                     couleur WCOULEUR)  { 
      Undrawl(*L);     
      L->LIG_STYLE     = WSTYLE;        
      L->LIG_COULEUR   = WCOULEUR;  
      Drawl(*L);
  }                       

void Movel(ligne *L, 
            short TRANSX,
            short TRANSY) {

      Undrawl(*L); 
      L->LIG_DEBUT.X  =(L->LIG_DEBUT).X + TRANSX;
      L->LIG_DEBUT.Y  =(L->LIG_DEBUT).Y + TRANSY;
      L->LIG_FIN.X    =(L->LIG_FIN).X   + TRANSX;
      L->LIG_FIN.Y    =(L->LIG_FIN).Y   + TRANSY;
      Drawl(*L);
}
 
void Duplicl(ligne         L,
              ligne         *LD,
              short         TRANSX,
              short         TRANSY) {
       
      LD->LIG_DEBUT.X  =(L.LIG_DEBUT).X + TRANSX;
      LD->LIG_DEBUT.Y  =(L.LIG_DEBUT).Y + TRANSY;
      LD->LIG_FIN.X    =(L.LIG_FIN).X   + TRANSX;
      LD->LIG_FIN.Y    =(L.LIG_FIN).Y   + TRANSY;
      LD->LIG_STYLE    = L.LIG_STYLE;
      LD->LIG_COULEUR  = L.LIG_COULEUR;  
      Definel(LD->LIG_DEBUT,
               LD->LIG_FIN,
               LD->LIG_STYLE,
               LD->LIG_COULEUR);
      Drawl(*LD);

}

point Debutl(ligne L)  {
    
       return L.LIG_DEBUT;
  } 
                     
point Finl(ligne L)  {
   
       return L.LIG_FIN;
  }

style Stylel(ligne L)  {
   
       return L.LIG_STYLE;
  }

couleur Coull(ligne L)  {
     
       return L.LIG_COULEUR;
  }  
                                 
/*---------------------------------------------------------------------------*/

/*---module RECTANGLE-----*/ 
/*=======================*/

rectangle  Definer(point         DEBUT,
                    unsigned long LARGEUR,
                    unsigned long HAUTEUR,
                    style         WSTYLE,
                    couleur       WCOULEUR) {

       rectangle Recloc;
       Recloc.REC_DEBUT     = DEBUT;
       Recloc.REC_LARGEUR   = LARGEUR;
       Recloc.REC_HAUTEUR   = HAUTEUR;
       Recloc.REC_STYLE     = WSTYLE; 
       Recloc.REC_COULEUR   = WCOULEUR; 
       return  Recloc;
  } 

void Drawr(rectangle R)  { 
     
     nom_coul = rech(R.REC_COULEUR);
     code_ret = XAllocNamedColor(canal_aff,
                                  palette,
                                  nom_coul,
                                  &couleu,
                                  &exact); 
           
     masq_bin = GCLineStyle | GCForeground | GCFillStyle; 
     val_gc.line_style = LineSolid; 
     val_gc.foreground = couleu.pixel; 
     val_gc.fill_style = FillSolid;   
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);  
 
     c = R.REC_STYLE;
     lignestyle(c);

     XDrawRectangle(canal_aff,
                    nouv_fen,
                    contexte_graph,
                    R.REC_DEBUT.X,
                    R.REC_DEBUT.Y,
                    R.REC_LARGEUR,
                    R.REC_HAUTEUR);
     XFlush(canal_aff);
  }  
   
void Undrawr(rectangle R)  { 
                            
     masq_bin = GCForeground | GCLineStyle | GCFillStyle; 
     val_gc.line_style = LineSolid;
     val_gc.foreground = carrplan; 
     val_gc.fill_style = FillSolid;   
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);
  
     XDrawRectangle(canal_aff,
                    nouv_fen,
                    contexte_graph,
                    R.REC_DEBUT.X,
                    R.REC_DEBUT.Y,
                    R.REC_LARGEUR,
                    R.REC_HAUTEUR);
     XFlush(canal_aff);
  }  


void Change_attribr(rectangle  *R,
                     style      WSTYLE,
                     couleur    WCOULEUR)  { 
      Undrawr(*R);
      R->REC_STYLE    = WSTYLE;        
      R->REC_COULEUR  = WCOULEUR; 
      Drawr(*R);
  }

void Mover(rectangle *R, 
            point     DEBUT) {

      Undrawr(*R);  
      R->REC_DEBUT = DEBUT;
      Drawr(*R);
}
 
void Duplicr(rectangle     R,
              rectangle     *RD,
              point         DEBUT) {
                          
        
      RD->REC_DEBUT    = DEBUT;
      RD->REC_LARGEUR  = R.REC_LARGEUR; 
      RD->REC_HAUTEUR  = R.REC_HAUTEUR;
      RD->REC_STYLE    = R.REC_STYLE;
      RD->REC_COULEUR  = R.REC_COULEUR;  
      Definer(RD->REC_DEBUT,
               RD->REC_LARGEUR,
               RD->REC_HAUTEUR,
               RD->REC_STYLE,
               RD->REC_COULEUR);
      Drawr(*RD);

}

point Debutr(rectangle R)  {
    
       return R.REC_DEBUT;
  } 
                     
unsigned long Largr(rectangle R)  {
   
       return R.REC_LARGEUR;
  }
   
unsigned long Hautr(rectangle R)  {

       return R.REC_HAUTEUR;
  }

style Styler(rectangle R)  {
   
       return R.REC_STYLE;
  }

couleur Coulr(rectangle R)  {
     
       return R.REC_COULEUR;
  }  

/*---------------------------------------------------------------------------*/

/*---module CERCLE-----*/ 
/*=====================*/

cercle Definec(point          CENTRE,
                unsigned long  RAYON,
                style          WSTYLE,
                couleur        WCOULEUR)   {

      cercle  Cerloc;
      Cerloc.CER_CENTRE  = CENTRE;
      Cerloc.CER_RAYON   = RAYON;
      Cerloc.CER_STYLE   = WSTYLE;
      Cerloc.CER_COULEUR = WCOULEUR; 
      return   Cerloc;
  } 

void Drawc(cercle C)  {  
      
      nom_coul = rech(C.CER_COULEUR);
      code_ret = XAllocNamedColor(canal_aff,
                                   palette,
                                   nom_coul,
                                   &couleu,
                                   &exact); 
                                            
      masq_bin = GCLineStyle | GCForeground | GCFillStyle; 
      val_gc.line_style = LineSolid; 
      val_gc.foreground = couleu.pixel;
      val_gc.fill_style = FillSolid;   
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);
                                                             
      c = C.CER_STYLE;
      lignestyle(c);

      XDrawArc(canal_aff,
               nouv_fen,
               contexte_graph,
               C.CER_CENTRE.X-C.CER_RAYON,
               C.CER_CENTRE.Y-C.CER_RAYON,
               C.CER_RAYON*2,
               C.CER_RAYON*2,
               0,
               360*64);
      XFlush(canal_aff); 
  }
     
void Undrawc(cercle C)  { 
                            
     masq_bin = GCForeground | GCLineStyle | GCFillStyle; 
     val_gc.foreground = carrplan; 
     val_gc.line_style = LineSolid;
     val_gc.fill_style = FillSolid;   
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);
       
     XDrawArc(canal_aff,
              nouv_fen,
              contexte_graph,
              C.CER_CENTRE.X-C.CER_RAYON,
              C.CER_CENTRE.Y-C.CER_RAYON,
              C.CER_RAYON*2,
              C.CER_RAYON*2,
              0,
              360*64);
     XFlush(canal_aff);
  }  
  

void Change_attribc(cercle  *C,
                     style   WSTYLE,
                     couleur WCOULEUR)  {
      
       Undrawc(*C);             
       C->CER_STYLE    = WSTYLE;
       C->CER_COULEUR  = WCOULEUR; 
       Drawc(*C);
  }
 
void Movec(cercle *C, 
            point  CENTRE) {

      Undrawc(*C); 
      C->CER_CENTRE = CENTRE;
      Drawc(*C);
}
 

void Duplicc(cercle     C,
              cercle     *CD,
              point      CENTRE) {

      CD->CER_CENTRE   = CENTRE; 
      CD->CER_RAYON    = C.CER_RAYON;
      CD->CER_STYLE    = C.CER_STYLE;
      CD->CER_COULEUR  = C.CER_COULEUR;  
      Definec(CD->CER_CENTRE,
               CD->CER_RAYON,
               CD->CER_STYLE,
               CD->CER_COULEUR);
      Drawc(*CD);

}

point Centrec(cercle C)  {
    
       return C.CER_CENTRE;
  } 
                     
unsigned long Rayonc(cercle C)  {
    
       return C.CER_RAYON;
  }

style Stylec(cercle C)  {
    
       return C.CER_STYLE;
  }

couleur Coulc(cercle C)  {
    
       return C.CER_COULEUR;
  }  
           
/*---------------------------------------------------------------------------*/

/*-----module POLYGONE------*/
/*==========================*/

                                         
polygone Definep(int            NSOMMETS,
                  style          WSTYLE,
                  couleur        WCOULEUR, 
                  point          TABPOINTS[100]) {      
                                    

      polygone polloc; 
      int i;

      for(i=0; i<NSOMMETS; i++)                   
      polloc.POL_TABPOINTS[i] = TABPOINTS[i];      
      polloc.POL_NSOMMETS  = NSOMMETS;
      polloc.POL_STYLE     = WSTYLE;
      polloc.POL_COULEUR   = WCOULEUR; 
      return polloc;
} 

void Drawp(polygone P)  { 
      
      nom_coul = rech(P.POL_COULEUR);
      code_ret = XAllocNamedColor(canal_aff,
                                   palette,
                                   nom_coul,
                                   &couleu,
                                   &exact); 

      masq_bin = GCLineStyle | GCForeground | GCFillStyle; 
      val_gc.line_style = LineSolid; 
      val_gc.foreground = couleu.pixel;
      val_gc.fill_style = FillSolid;   
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);   
      
      c = P.POL_STYLE;
      lignestyle(c);
  
      XDrawLines(canal_aff,
                 nouv_fen,
                 contexte_graph, 
(XPoint *)P.POL_TABPOINTS,
                 P.POL_NSOMMETS,       
                 CoordModeOrigin); 
      XFlush(canal_aff);                                    
  }

  
void Undrawp(polygone P)  { 
       
      masq_bin = GCForeground | GCLineStyle | GCFillStyle; 
      val_gc.foreground = carrplan;
      val_gc.line_style = LineSolid;
      val_gc.fill_style = FillSolid;   
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);
  
      XDrawLines(canal_aff,
                 nouv_fen,
                 contexte_graph, 
(XPoint *)P.POL_TABPOINTS,
                 P.POL_NSOMMETS,       
                 CoordModeOrigin); 
      XFlush(canal_aff);                                    
  }


void Change_attribp(polygone *P,
                     style    WSTYLE,
                     couleur  WCOULEUR)  {
      
       Undrawp(*P);
       P->POL_STYLE    = WSTYLE;
       P->POL_COULEUR  = WCOULEUR;   
       Drawp(*P);
  }            


void Movep(polygone *P, 
            short    TRANSX,
            short    TRANSY) { 

      int i;
      Undrawp(*P); 

      for(i=0; i<P->POL_NSOMMETS; i++)   {                
      P->POL_TABPOINTS[i].X =(P->POL_TABPOINTS[i]).X + TRANSX; 
      P->POL_TABPOINTS[i].Y =(P->POL_TABPOINTS[i]).Y + TRANSY; }
      Drawp(*P);
}


void Duplicp(polygone         P,
              polygone         *PD,
              short            TRANSX,
              short            TRANSY) {
                                            
      int i;

      for(i=0; i<P.POL_NSOMMETS; i++)   {                
      PD->POL_TABPOINTS[i].X =(P.POL_TABPOINTS[i]).X + TRANSX; 
      PD->POL_TABPOINTS[i].Y =(P.POL_TABPOINTS[i]).Y + TRANSY; }
      PD->POL_STYLE    = P.POL_STYLE;
      PD->POL_COULEUR  = P.POL_COULEUR;  
      PD->POL_NSOMMETS = P.POL_NSOMMETS;
      Definep(PD->POL_NSOMMETS,
               PD->POL_STYLE,
               PD->POL_COULEUR,
               PD->POL_TABPOINTS);
      Drawp(*PD);

}

int   Nsommetsp(polygone P)  {

       return P.POL_NSOMMETS;
  }

    
style Stylep(polygone P)   {
    
       return P.POL_STYLE;
  }

couleur Coulp(polygone P)  {
    
       return P.POL_COULEUR;
  }
 
tpoint Tpoints(polygone P) {