graph_c.cc

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

}

int   Nsommetspr(polygoner PP)  {

       return PP.PPOL_NSOMMETS;
  }

mode_remp Remppr(polygoner PP)  {
    
       return PP.PPOL_REMPLI;
  }  

couleur Coulpr(polygoner PP)  {
    
       return PP.PPOL_COULEUR;
  }

tpoint Tpointsr(polygoner PP) {
                           
        tpoint t1;
        int i;
        for(i=0; i< PP.PPOL_NSOMMETS; i++)
        t1.TAB[i] = PP.PPOL_TABPOINTS[i];
        return t1;
  }
   
/*---------------------------------------------------------------------------*/

/*----module ARC-----*/ 
/*===================*/
                    
arcr Definear(point          DEBUTARC, 
               unsigned long  LARGEUR,
               unsigned long  HAUTEUR,
               int            ANGLEDROIT,
               int            ANGLEGAUCHE,
               mode_remp      REMPLI,
               couleur        WCOULEUR)  {
 
      arcr arcloc;
      arcloc.PARC_DEBUTARC    = DEBUTARC;
      arcloc.PARC_LARGEUR     = LARGEUR;
      arcloc.PARC_HAUTEUR     = HAUTEUR;
      arcloc.PARC_ANGLEDROIT  = ANGLEDROIT;
      arcloc.PARC_ANGLEGAUCHE = ANGLEGAUCHE;
      arcloc.PARC_REMPLI      = REMPLI;
      arcloc.PARC_COULEUR     = WCOULEUR;
      return  arcloc;
  } 

void Drawar(arcr PA) { 
                         
      b = PA.PARC_REMPLI;
      rempli(b);
                       
      nom_coul = rech(PA.PARC_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);

      XFillArc(canal_aff,
               nouv_fen,
               contexte_graph,
               PA.PARC_DEBUTARC.X,
               PA.PARC_DEBUTARC.Y,
               PA.PARC_LARGEUR,
               PA.PARC_HAUTEUR,
               PA.PARC_ANGLEDROIT*64,
               PA.PARC_ANGLEGAUCHE*64); 
      XFlush(canal_aff);
  }                      

void Undrawar(arcr PA) {  
      
      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,
               PA.PARC_DEBUTARC.X,
               PA.PARC_DEBUTARC.Y,
               PA.PARC_LARGEUR,
               PA.PARC_HAUTEUR,
               PA.PARC_ANGLEDROIT*64,
               PA.PARC_ANGLEGAUCHE*64); 
      XFlush(canal_aff);
  }                      


void Change_attribar(arcr      *PA, 
                      mode_remp REMPLI,
                      couleur   WCOULEUR)  {
                               
      Undrawar(*PA);
      PA->PARC_REMPLI   = REMPLI;
      PA->PARC_COULEUR  = WCOULEUR; 
      Drawar(*PA); 
  }
                      
void Movear(arcr       *PA, 
             point      DEBUTARC) {

      Undrawar(*PA); 
      PA->PARC_DEBUTARC = DEBUTARC;
      Drawar(*PA);
}
 
void Duplicar(arcr        PA,
               arcr        *PAD,
               point       DEBUTARC) {

      PAD->PARC_DEBUTARC    = DEBUTARC; 
      PAD->PARC_LARGEUR     = PA.PARC_LARGEUR;
      PAD->PARC_HAUTEUR     = PA.PARC_HAUTEUR;
      PAD->PARC_ANGLEDROIT  = PA.PARC_ANGLEDROIT;
      PAD->PARC_ANGLEGAUCHE = PA.PARC_ANGLEGAUCHE;
      PAD->PARC_REMPLI      = PA.PARC_REMPLI;
      PAD->PARC_COULEUR     = PA.PARC_COULEUR;  
      Definear(PAD->PARC_DEBUTARC,
                PAD->PARC_LARGEUR,
                PAD->PARC_HAUTEUR,
                PAD->PARC_ANGLEDROIT,
                PAD->PARC_ANGLEGAUCHE,
                PAD->PARC_REMPLI,
                PAD->PARC_COULEUR);
      Drawar(*PAD);

}

point Debutarcar(arcr PA)   {

       return PA.PARC_DEBUTARC;
  } 
                      
unsigned long Largeurar(arcr PA)  {

       return PA.PARC_LARGEUR;
  }

unsigned long Hauteurar(arcr PA)  {  

       return PA.PARC_HAUTEUR;
  }

int  Angledroitar(arcr PA)  {

       return PA.PARC_ANGLEDROIT;
  }

int  Anglegauchear(arcr PA)  {

       return PA.PARC_ANGLEGAUCHE;
  }

mode_remp Rempar(arcr PA)  {
     
       return PA.PARC_REMPLI;
  } 
 
couleur Coular(arcr PA)  {
     
       return PA.PARC_COULEUR;
  }  

/*--------------------------------------------------------------------------*/ 
     
/*==================================================*/
/*      corps des fonctions et des procedures       */
/*               chaine de caracteres               */
/*==================================================*/
 

/*----module TEXTE-----*/
/*=====================*/

   texte Definet(point          DEBUTCHAINE,
                  policecar      POLICE, 
                  taillecar      TAILLE,
                  couleur        WCOULEUR,
                  char           CHAINE[100])  {
                       
      texte texteloc; 

      strcpy(texteloc.TEX_CHAINE,CHAINE);

      texteloc.TEX_DEBUTCHAINE = DEBUTCHAINE;
      texteloc.TEX_POLICE      = POLICE;
      texteloc.TEX_TAILLE      = TAILLE;
      texteloc.TEX_COULEUR     = WCOULEUR; 
      return   texteloc;
  } 

void Drawt(texte T)  { 
       
      choixfonte(T.TEX_POLICE,T.TEX_TAILLE);   
      nom_coul = rech(T.TEX_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);
      XDrawString(canal_aff,
                  nouv_fen,
                  contexte_graph,                   

                  T.TEX_DEBUTCHAINE.X,
                  T.TEX_DEBUTCHAINE.Y,
                  T.TEX_CHAINE,
                  strlen(T.TEX_CHAINE)); 
      XFlush(canal_aff);
  }   
 
void Undrawt(texte T)  { 
     
      masq_bin =  GCForeground | GCFillStyle; 
      val_gc.foreground = carrplan; 
      val_gc.fill_style = FillSolid;  
           
      XChangeGC(canal_aff,
                 contexte_graph,
                 masq_bin,
                 &val_gc);
      XDrawString(canal_aff,
                  nouv_fen,
                  contexte_graph,
                  T.TEX_DEBUTCHAINE.X,
                  T.TEX_DEBUTCHAINE.Y,
                  T.TEX_CHAINE,
                  strlen(T.TEX_CHAINE)); 
      XFlush(canal_aff);
  }   

void Change_attribt(texte     *T,
                     policecar POLICE, 
                     taillecar TAILLE,
                     couleur   WCOULEUR)  {
       
       Undrawt(*T);
       T->TEX_POLICE    = POLICE; 
       T->TEX_TAILLE    = TAILLE;
       T->TEX_COULEUR   = WCOULEUR; 
       Drawt(*T);
  }


void Movet(texte *T, 
            point DEBUTCHAINE) {

      Undrawt(*T); 
      T->TEX_DEBUTCHAINE = DEBUTCHAINE;
      Drawt(*T);
}


void Duplict(texte      T,
              texte      *TD,
              point      DEBUTCHAINE) {

      TD->TEX_DEBUTCHAINE   = DEBUTCHAINE; 
      TD->TEX_POLICE        = T.TEX_POLICE;
      TD->TEX_TAILLE        = T.TEX_TAILLE;
      TD->TEX_COULEUR       = T.TEX_COULEUR; 
      strcpy(TD->TEX_CHAINE,T.TEX_CHAINE);
      Definet(TD->TEX_DEBUTCHAINE, 
               TD->TEX_POLICE,
               TD->TEX_TAILLE,
               TD->TEX_COULEUR,
               TD->TEX_CHAINE);

      Drawt(*TD);

}

point Debchainet(texte T)  {

       return T.TEX_DEBUTCHAINE;
  }
                     
policecar Policet(texte T)  {    

       return T.TEX_POLICE;     
  }
    
taillecar Taillet(texte T)  {
     
       return T.TEX_TAILLE;
  }

couleur Coult(texte T)   {
  
       return T.TEX_COULEUR;
  }        
 
tchar Chainet(texte T)  {

        tchar t2;
        int i;
        for(i=0; i< 100; i++)
        t2.TAC[i] = T.TEX_CHAINE[i];
        return t2;
  }  

/*----------------------------------------------------------------------------*/
 
/*==================================================*/
/*      corps des fonctions et des procedures       */
/*      initialisation fenetre sous X WINDOW        */
/*==================================================*/

                     
void InitGraphe(int X,
                 int Y,
                 unsigned WIDTH,
                 unsigned HEIGHT)  {

     XSizeHints infos_fen; 
     int ecran;
     //     sleep(5);
     if((canal_aff = XOpenDisplay(0))==NULL)
     {
     	printf("Ne peut se connecter au serveur X. \
     	Verifiez la variable DISPLAY\n");
     	exit(1);
     }
     
     ecran     = DefaultScreen(canal_aff);
     cavplan   = BlackPixel(canal_aff,ecran);
     carrplan  = WhitePixel(canal_aff,ecran);  
     palette   = DefaultColormap(canal_aff,ecran);  
     infos_fen.x = X;
     infos_fen.y = Y;
     infos_fen.width  = WIDTH;
     infos_fen.height = HEIGHT; 
     infos_fen.flags  = PPosition | PSize;    
     masq_attrib = CWOverrideRedirect;
     xswa.override_redirect = True;
     
     nouv_fen = XCreateSimpleWindow(canal_aff,
                                     DefaultRootWindow(canal_aff),
                                     infos_fen.x,
                                     infos_fen.y,
                                     infos_fen.width,
                                     infos_fen.height,
                                     5,
                                     cavplan,
                                     carrplan);  
     XChangeWindowAttributes(canal_aff,
                              nouv_fen,
                              masq_attrib,
                              &xswa);
     XSetWindowBorder(canal_aff,
                       nouv_fen,
                       couleu.pixel);
     contexte_graph = XCreateGC(canal_aff,
                                 nouv_fen,
                                 0,
                                 0);
     XSetForeground(canal_aff,
                     contexte_graph,
                     cavplan);
     XSetBackground(canal_aff,
                     contexte_graph,
                     carrplan);
     curseur = XCreateFontCursor(canal_aff,132);
     XDefineCursor(canal_aff,nouv_fen,curseur);
     
     XSelectInput(canal_aff,
                   nouv_fen,
                   ExposureMask | KeyPressMask | ButtonPressMask);
     XMapRaised(canal_aff,
                 nouv_fen);
     XNextEvent(canal_aff,
                 &evenem);      
 }      
/*---------------------------------------------------------------------------*/

void CloseGraphe() {

     XFreeGC(canal_aff,contexte_graph);
     XDestroyWindow(canal_aff,nouv_fen);
     XCloseDisplay(canal_aff);
 }
/*---------------------------------------------------------------------------*/

void Clear() {

     XClearWindow(canal_aff,nouv_fen);
 }
/*---------------------------------------------------------------------------*/

int Keypressed() {
     
     if(XEventsQueued(canal_aff,QueuedAfterReading) != 0) {  

     XNextEvent(canal_aff,
                 &evenem);   

     if(evenem.type == KeyPress) return 0; 
     
     else return 1; } 
     else return 1;

} 

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

tcla1 retourkey1(point COORD) {

     int   nbcar;
     tcla1 tret;
     char  frappe[5];
     int   i;
     
     for(i=0; i<=49; i++)
     tret.TAD[i] = ' ';
     
     for(i=1; i<=50; i++) {
     
     if(XEventsQueued(canal_aff,QueuedAfterReading) !=0) {
     
     XNextEvent(canal_aff,
                 &evenem);
                 
     if(evenem.type == KeyPress) {
     nbcar = XLookupString((XKeyEvent *)&evenem,
                           frappe,
                           5,
                           &touche,
                           0);
     XDrawString(canal_aff,
                nouv_fen,
                contexte_graph,
                COORD.X,
                COORD.Y,
                frappe,
                nbcar);
     XFlush(canal_aff);
     COORD.X = COORD.X + 10;
     if(frappe[0] != ' ')
     tret.TAD[i] = frappe [0];
     }
     }
     }
     return tret;
 }

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

tcla2 retourkey2() {

     int   nbcar;
     tcla2 tret1;
     char  frappe[5];
     int   i;
     
     for(i=0; i<=49; i++)
     tret1.TAE[i] = ' ';
     
     for(i=1; i<=50; i++) {
     
     if(XEventsQueued(canal_aff,QueuedAfterReading) !=0) {
     
     XNextEvent(canal_aff,
                 &evenem);
                 
     if(evenem.type == KeyPress) {
     nbcar = XLookupString((XKeyEvent *)&evenem,
                           frappe,
                           5,
                           &touche,
                           0);
     XFlush(canal_aff);
     if(frappe[0] != ' ')
     tret1.TAE[i] = frappe [0];
     }
     }
     }
     return tret1;
 }
 
/*---------------------------------------------------------------------------*/

int Buttonpressed() {
     
     if(XEventsQueued(canal_aff,QueuedAfterReading) != 0) {  

     XNextEvent(canal_aff,
                 &evenem);   

     if(evenem.type == ButtonPress) return 0;
                                              
     else return 1; } 
     else return 1;

} 

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

void PointCursor(point COORD) {

     XWarpPointer(canal_aff,
                   None,
                   nouv_fen,
                   0,
                   0,
                   0,
                   0,
                   COORD.X,
                   COORD.Y);
     XFlush(canal_aff);
     
}

void ModeXOR()
{
	XSetFunction(canal_aff,contexte_graph,GXxor);
}

void ModeNORMAL()
{
	XSetFunction(canal_aff,contexte_graph,GXcopy);
}

#endif // WITH_X11

// $Id: graph_c.cc,v 3.3 2003/02/19 17:20:28 breholee Exp $