graph_c.cc

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

        tpoint t1;
        int i;
        for(i=0; i< P.POL_NSOMMETS; i++)
        t1.TAB[i] = P.POL_TABPOINTS[i];
        return t1;
  }

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

/*----module ARC-----*/ 
/*===================*/
                    
arc Definea(point          DEBUTARC, 
             unsigned long  LARGEUR,
             unsigned long  HAUTEUR,
             int            ANGLEDROIT,
             int            ANGLEGAUCHE,
             style          WSTYLE,
             couleur        WCOULEUR)  {
 
      arc arcloc;
      arcloc.ARC_DEBUTARC    = DEBUTARC;
      arcloc.ARC_LARGEUR     = LARGEUR;
      arcloc.ARC_HAUTEUR     = HAUTEUR;
      arcloc.ARC_ANGLEDROIT  = ANGLEDROIT;
      arcloc.ARC_ANGLEGAUCHE = ANGLEGAUCHE;
      arcloc.ARC_STYLE       = WSTYLE;
      arcloc.ARC_COULEUR     = WCOULEUR;
      return  arcloc;
  } 
                     

void Drawa(arc A) {   
      
      nom_coul = rech(A.ARC_COULEUR);
      code_ret = XAllocNamedColor(canal_aff,
                                   palette,
                                   nom_coul,
                                   &couleu,
                                   &exact); 

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

      c = A.ARC_STYLE;
      lignestyle(c);

      XDrawArc(canal_aff,
               nouv_fen,
               contexte_graph,
               A.ARC_DEBUTARC.X,
               A.ARC_DEBUTARC.Y,
               A.ARC_LARGEUR,
               A.ARC_HAUTEUR,
               A.ARC_ANGLEDROIT*64,
               A.ARC_ANGLEGAUCHE*64); 
      XFlush(canal_aff);
  }                      

void Undrawa(arc A) {  
      
      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,
               A.ARC_DEBUTARC.X,
               A.ARC_DEBUTARC.Y,
               A.ARC_LARGEUR,
               A.ARC_HAUTEUR,
               A.ARC_ANGLEDROIT*64,
               A.ARC_ANGLEGAUCHE*64); 
      XFlush(canal_aff);
  }                      


void Change_attriba(arc     *A,
                     style   WSTYLE,
                     couleur WCOULEUR)  {
       
       Undrawa(*A);
       A->ARC_STYLE    = WSTYLE;
       A->ARC_COULEUR  = WCOULEUR; 
       Drawa(*A); 
  }

void Movea(arc *A, 
            point DEBUTARC) {

      Undrawa(*A); 
      A->ARC_DEBUTARC = DEBUTARC;
      Drawa(*A);
}


void Duplica(arc        A,
              arc        *AD,
              point      DEBUTARC) {

      AD->ARC_DEBUTARC    = DEBUTARC; 
      AD->ARC_LARGEUR     = A.ARC_LARGEUR;
      AD->ARC_HAUTEUR     = A.ARC_HAUTEUR;
      AD->ARC_ANGLEDROIT  = A.ARC_ANGLEDROIT;
      AD->ARC_ANGLEGAUCHE = A.ARC_ANGLEGAUCHE;
      AD->ARC_STYLE       = A.ARC_STYLE;
      AD->ARC_COULEUR     = A.ARC_COULEUR;  
      Definea(AD->ARC_DEBUTARC,
               AD->ARC_LARGEUR,
               AD->ARC_HAUTEUR,
               AD->ARC_ANGLEDROIT,
               AD->ARC_ANGLEGAUCHE,
               AD->ARC_STYLE,
               AD->ARC_COULEUR);
      Drawa(*AD);

}

point Debutarca(arc A)   {

       return A.ARC_DEBUTARC;
  } 
                      
unsigned long Largeura(arc A)  {

       return A.ARC_LARGEUR;
  }

unsigned long Hauteura(arc A)  {  

       return A.ARC_HAUTEUR;
  }

int  Angledroita(arc A)  {

       return A.ARC_ANGLEDROIT;
  }

int  Anglegauchea(arc A)  {

       return A.ARC_ANGLEGAUCHE;
  }

style Stylea(arc A)  {
   
       return A.ARC_STYLE;
  }

couleur Coula(arc A)  {
     
       return A.ARC_COULEUR;
  }  
          
/*--------------------------------------------------------------------------*/ 

/*==================================================*/
/*      corps des fonctions et des procedures       */
/*               figures pleines                    */
/*==================================================*/
 
/*---module RECTANGLE-----*/ 
/*=======================*/

rectangler  Definerr(point         DEBUT,
                      unsigned long LARGEUR,
                      unsigned long HAUTEUR,
                      mode_remp     REMPLI,
                      couleur       WCOULEUR) {

       rectangler Recloc;
       Recloc.PREC_DEBUT    = DEBUT;
       Recloc.PREC_LARGEUR  = LARGEUR;
       Recloc.PREC_HAUTEUR  = HAUTEUR; 
       Recloc.PREC_REMPLI   = REMPLI;
       Recloc.PREC_COULEUR  = WCOULEUR; 
       return  Recloc;
  } 

void Drawrr(rectangler PR)  { 
       
     nom_coul = rech(PR.PREC_COULEUR);
     code_ret = XAllocNamedColor(canal_aff,
                                  palette,
                                  nom_coul,
                                  &couleu,
                                  &exact); 

     masq_bin = GCForeground | GCFillStyle; 
     val_gc.foreground = couleu.pixel; 
     val_gc.fill_style = FillSolid;   
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);
                 
     b = PR.PREC_REMPLI;
     rempli(b);    

     XFillRectangle(canal_aff,
                    nouv_fen,
                    contexte_graph,
                    PR.PREC_DEBUT.X,
                    PR.PREC_DEBUT.Y,
                    PR.PREC_LARGEUR,
                    PR.PREC_HAUTEUR);
     XFlush(canal_aff);
  }  
   
void Undrawrr(rectangler PR)  { 
                            
     masq_bin = GCForeground | GCFillStyle; 
     val_gc.foreground = carrplan; 
     val_gc.fill_style = FillSolid;   
     XChangeGC(canal_aff,
                contexte_graph,
                masq_bin,
                &val_gc);
  
     XFillRectangle(canal_aff,
                    nouv_fen,
                    contexte_graph,
                    PR.PREC_DEBUT.X,
                    PR.PREC_DEBUT.Y,
                    PR.PREC_LARGEUR,
                    PR.PREC_HAUTEUR);
     XFlush(canal_aff);
  }  


void Change_attribrr(rectangler  *PR, 
                      mode_remp   REMPLI,
                      couleur     WCOULEUR)  { 
      
      Undrawrr(*PR); 
      PR->PREC_REMPLI   = REMPLI;
      PR->PREC_COULEUR  = WCOULEUR;
      Drawrr(*PR); 
  }

void Moverr(rectangler *PR, 
             point      DEBUT) {

      Undrawrr(*PR); 
      PR->PREC_DEBUT = DEBUT;
      Drawrr(*PR);
}


void Duplicrr(rectangler     PR,
               rectangler     *PRD,
               point          DEBUT) {
             
      PRD->PREC_DEBUT    = DEBUT; 
      PRD->PREC_LARGEUR  = PR.PREC_LARGEUR; 
      PRD->PREC_HAUTEUR  = PR.PREC_HAUTEUR;
      PRD->PREC_REMPLI   = PR.PREC_REMPLI;
      PRD->PREC_COULEUR  = PR.PREC_COULEUR;  
      Definerr(PRD->PREC_DEBUT,
                PRD->PREC_LARGEUR,
                PRD->PREC_HAUTEUR,
                PRD->PREC_REMPLI,
                PRD->PREC_COULEUR);
      Drawrr(*PRD);

}

point Debutrr(rectangler PR)  {
    
       return PR.PREC_DEBUT;
  } 
                     
unsigned long Largrr(rectangler PR)  {
   
       return PR.PREC_LARGEUR;
  }
   
unsigned long Hautrr(rectangler PR)  {

       return PR.PREC_HAUTEUR;
  }

mode_remp Remprr(rectangler PR)  {
     
       return PR.PREC_REMPLI;
  }  

couleur Coulrr(rectangler PR)  {
     
       return PR.PREC_COULEUR;
  }  

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

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

cercler Definecr(point          CENTRE,
                  unsigned long  RAYON,
                  mode_remp      REMPLI,
                  couleur        WCOULEUR)   {

      cercler  Cerloc;
      Cerloc.PCER_CENTRE    = CENTRE;
      Cerloc.PCER_RAYON     = RAYON; 
      Cerloc.PCER_REMPLI    = REMPLI;
      Cerloc.PCER_COULEUR   = WCOULEUR; 
      return   Cerloc;
  } 

void Drawcr(cercler PC)  {    

      nom_coul = rech(PC.PCER_COULEUR);
      code_ret = XAllocNamedColor(canal_aff,
                                   palette,
                                   nom_coul,
                                   &couleu,
                                   &exact); 

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

      b = PC.PCER_REMPLI; 
      rempli(b);  

      XFillArc(canal_aff,
               nouv_fen,
               contexte_graph,
               PC.PCER_CENTRE.X-PC.PCER_RAYON,
               PC.PCER_CENTRE.Y-PC.PCER_RAYON,
               PC.PCER_RAYON*2,
               PC.PCER_RAYON*2,
               0, 
               360*64);
      XFlush(canal_aff); 
  }

void Undrawcr(cercler PC)  {   
       
      masq_bin =  GCForeground | GCFillStyle; 
      val_gc.foreground = carrplan; 
      val_gc.fill_style = FillSolid;  
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);
      
      XFillArc(canal_aff,
               nouv_fen,
               contexte_graph,
               PC.PCER_CENTRE.X-PC.PCER_RAYON,
               PC.PCER_CENTRE.Y-PC.PCER_RAYON,
               PC.PCER_RAYON*2,
               PC.PCER_RAYON*2,
               0, 
               360*64);
      XFlush(canal_aff); 
  }
     
void Change_attribcr(cercler   *PC,
                      mode_remp REMPLI,
                      couleur   WCOULEUR)  {  

       Undrawcr(*PC);
       PC->PCER_REMPLI   = REMPLI;
       PC->PCER_COULEUR  = WCOULEUR; 
       Drawcr(*PC);
  }

void Movecr(cercler    *PC, 
             point      CENTRE) {

      Undrawcr(*PC); 
      PC->PCER_CENTRE = CENTRE;
      Drawcr(*PC);
}


void Dupliccr(cercler     PC,
               cercler     *PCD,
               point       CENTRE) {

      PCD->PCER_CENTRE   = CENTRE; 
      PCD->PCER_RAYON    = PC.PCER_RAYON;
      PCD->PCER_REMPLI   = PC.PCER_REMPLI;
      PCD->PCER_COULEUR  = PC.PCER_COULEUR;  
      Definecr(PCD->PCER_CENTRE,
                PCD->PCER_RAYON,
                PCD->PCER_REMPLI,
                PCD->PCER_COULEUR);
      Drawcr(*PCD);

}

point Centrecr(cercler PC)  {
    
       return PC.PCER_CENTRE;
  } 
                     
unsigned long Rayoncr(cercler PC)  {
    
       return PC.PCER_RAYON;
  }

mode_remp Rempcr(cercler PC)  {
    
       return PC.PCER_REMPLI;
  } 
 
couleur Coulcr(cercler PC)  {
    
       return PC.PCER_COULEUR;
  }  

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

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

                                         
polygoner Definepr(int            NSOMMETS,
                    mode_remp      REMPLI,
                    couleur        WCOULEUR, 
                    point          TABPOINTS[100]) {      
                                    

      polygoner polloc; 
      int i;

      for(i=0; i<NSOMMETS; i++)                   
      polloc.PPOL_TABPOINTS[i] = TABPOINTS[i];      
 
      polloc.PPOL_NSOMMETS  = NSOMMETS;
      polloc.PPOL_REMPLI    = REMPLI;
      polloc.PPOL_COULEUR   = WCOULEUR; 
      return polloc;
} 

void Drawpr(polygoner PP)  {

      b = PP.PPOL_REMPLI;
      rempli(b);

      nom_coul = rech(PP.PPOL_COULEUR);
      code_ret = XAllocNamedColor(canal_aff,
                                   palette,
                                   nom_coul,
                                   &couleu, 
                                   &exact); 

      masq_bin = GCForeground; 
      val_gc.foreground = couleu.pixel;   
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);
                  
      XSetFillRule(canal_aff,
                    contexte_graph,
                    EvenOddRule);
      XFillPolygon(canal_aff,
                   nouv_fen,
                   contexte_graph, 
(XPoint *)PP.PPOL_TABPOINTS,
                   PP.PPOL_NSOMMETS,
                   Complex,      
                   CoordModeOrigin); 
      XFlush(canal_aff);                                    
  }

  
void Undrawpr(polygoner PP)  { 
       
      masq_bin = GCForeground | GCFillStyle; 
      val_gc.foreground = carrplan;  
      val_gc.fill_style = FillSolid; 
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);

      XSetFillRule(canal_aff,
                    contexte_graph,
                    EvenOddRule);
      XFillPolygon(canal_aff,
                   nouv_fen,
                   contexte_graph, 
(XPoint *)PP.PPOL_TABPOINTS,
                   PP.PPOL_NSOMMETS,
                   Complex,      
                   CoordModeOrigin); 
      XFlush(canal_aff);                   
  }


void Change_attribpr(polygoner *PP, 
                      mode_remp REMPLI,
                      couleur   WCOULEUR)  {
       
       Undrawpr(*PP); 
       PP->PPOL_REMPLI    = REMPLI;
       PP->PPOL_COULEUR   = WCOULEUR;  
       Drawpr(*PP);
  }            
 

void Movepr(polygoner *PP, 
             short     TRANSX,
             short     TRANSY) { 

      int i;
      Undrawpr(*PP); 

      for(i=0; i<PP->PPOL_NSOMMETS; i++)   {                
      PP->PPOL_TABPOINTS[i].X =(PP->PPOL_TABPOINTS[i]).X + TRANSX; 
      PP->PPOL_TABPOINTS[i].Y =(PP->PPOL_TABPOINTS[i]).Y + TRANSY; }
      Drawpr(*PP);
}


void Duplicpr(polygoner         PP,
               polygoner         *PPD,
               short             TRANSX,
               short             TRANSY) {
                                             
      int i;

      for(i=0; i<PP.PPOL_NSOMMETS; i++)   {                
      PPD->PPOL_TABPOINTS[i].X =(PP.PPOL_TABPOINTS[i]).X + TRANSX; 
      PPD->PPOL_TABPOINTS[i].Y =(PP.PPOL_TABPOINTS[i]).Y + TRANSY; }  
      PPD->PPOL_REMPLI         = PP.PPOL_REMPLI;
      PPD->PPOL_COULEUR        = PP.PPOL_COULEUR;  
      PPD->PPOL_NSOMMETS       = PP.PPOL_NSOMMETS;
      Definepr(PPD->PPOL_NSOMMETS,
                PPD->PPOL_REMPLI,
                PPD->PPOL_COULEUR,
                PPD->PPOL_TABPOINTS);
      Drawpr(*PPD);