Xlib 制作按纽

/* button.h */
#ifndef _BUTTON_H_
#define _BUTTON_H_

#include 

#define STATUS(args...) fprintf(stdout, args);
#define ERROR(args...)  fprintf(stderr, "ERROR: "args);
#define WARN(args...)   fprintf(stderr, "WARNING: "args);

#define FOCUS_IN     1
#define FOCUS_OUT    0
#define FOCUS_NONE   0xff

#define BUTTON_DOWN  1
#define BUTTON_UP    0
#define BUTTON_NONE  0xff

#define SB_LONGLABEL  50      
#define SB_CURSOR     XC_top_left_arrow  
#define SB_FOCUS      0
#define SB_NORMAL     1
#define SB_INPUTMASK ExposureMask|EnterWindowMask|LeaveWindowMask
        |ButtonPressMask|ButtonReleaseMask

#define BUTTON_FONT     "-adobe-times-bold-r-normal
        --17-120-100-100-p-88-iso8859-15"

#define BUTTON_FT_COLOT "black"

typedef struct _Button
{
   int      id;
   int      type;
   Window   parent;
   Window   window;
   GC       gc;      
   char     label[SB_LONGLABEL];
   int      focus;
   int      isdown;
   int      startx;
   int      starty;
   int      width;
   int      height;
   XImage   *normal;
   XImage   *grey;
   int      (*func)();
} BUTTON;

void CreatButtonGC(BUTTON* but);
BUTTON* MakeButton(Window win,int type,int startx,int starty,
        int w,int h,char* label,int (*fun)(),int id,char* img1,char* img2);
void ExposeButton(BUTTON* but);
int  HandleButton(BUTTON* but,XEvent *event);
void FreeButton(BUTTON* but);

#endif

/*button.c*/
#include 
#include 
#include 
#include 
#include 
#include 
#include 

extern Display* display;
extern int      screen;     

XFontStruct *fontinfo;
GC          gr_context; 

#include "button.h"
  
void CreatButtonGC(BUTTON* but)
{
  
  XGCValues   gr_values;

  XColor      color,dummy;

  fontinfo = XLoadQueryFont(display,BUTTON_FONT);
  XAllocNamedColor(display,DefaultColormap(display,DefaultScreendisplay)),
        BUTTON_FT_COLOT,&color,&dummy);
  gr_values.font = fontinfo->fid;
  gr_values.foreground = color.pixel;
  gr_context=XCreateGC(display,but->window,GCFont+GCForeground, &gr_values);
  
  but->gc = gr_context;
}

BUTTON* MakeButton(win,type,startx,starty,w,h,label,fun,id,img1,img2)
int   id;
int   type;
int   startx,starty;     
int   w,h;
char  *label;
int   (*fun)();
Window win;
char* img1;
char* img2;
{
   BUTTON* but;
   Cursor  tempcursor;
   int     status;
   XSetWindowAttributes setwinattr;
   
   but=(BUTTON *)malloc(sizeof(BUTTON));
   if(!but)
   {
     // Error("memery error:%s %s",__FILE__,__LINE___);
     return NULL;
   }
   
   but->id    =id;
   but->parent=win;
   if(type == SB_FOCUS)
     but->focus=FOCUS_OUT;
   else
     but->focus=FOCUS_NONE;

   if(type == SB_NORMAL)
     but->isdown=BUTTON_UP;
   else
     but->isdown=BUTTON_NONE;

   but->type=type;
   but->startx=startx;
   but->starty=starty;
   but->width =w;
   but->height=h;
   if(label) 
     strncpy(but->label,label,SB_LONGLABEL);
   but->func = fun;

   but->window = XCreateSimpleWindow(display,win, 
       startx,starty,
        w,h,0,BlackPixel(display,screen),WhitePixel(display,screen));

   CreatButtonGC(but);

   XSelectInput(display,but->window,SB_INPUTMASK );
   tempcursor = XCreateFontCursor(display,SB_CURSOR);
   XDefineCursor(display,but->window,tempcursor);

   // load the xpm images
   status=XpmReadFileToImage(display,img1,&but->normal,NULL,NULL);
   if(status != XpmSuccess)
   {
     ERROR("XpmError when laod %s:%s
",img1,XpmGetErrorString(status));
     return NULL;
   }
   status=XpmReadFileToImage(display,img2,&but->grey,NULL,NULL);
   if(status != XpmSuccess)
   {
     ERROR("XpmError when laod %s:%s
",img2,XpmGetErrorString(status));
     return NULL;
   }

   setwinattr.backing_store = Always;
   XChangeWindowAttributes(display,but->window,CWBackingStore,&setwinattr);
   XMapWindow(display,but->window);

   return but;
}

void ExposeButton(BUTTON* but)
{
   int  width,center;

   XClearWindow(display,but->window);

   if(but->type == SB_FOCUS)
   {
    if(but->focus)
       XPutImage(display,but->window,gr_context,but->normal,0,0,0,0,
                       but->width,but->height);
    else
      XPutImage(display,but->window,gr_context,but->grey,0,0,0,0,
                       but->width,but->height);
   }

   else if(but->type == SB_NORMAL)
   {
     if(but->isdown)
        XPutImage(display,but->window,gr_context,but->grey,0,0,0,0,
                       but->width,but->height);
      else
       XPutImage(display,but->window,gr_context,but->normal,0,0,0,0,
                       but->width,but->height);
   }
   if(but->label)
   { 
     width  = XTextWidth(fontinfo,but->label,strlen(but->label));
     center = (but->width-width)/2;
     XDrawString(display,but->window,but->gc,center,
          fontinfo->ascent,but->label,strlen(but->label));
   }
   XFlush(display);
}

int HandleButton(but,event)
BUTTON* but;
XEvent *event;
{
   switch(event->type) 
   {
     case Expose:
          ExposeButton(but);
          break;
     case EnterNotify:
          if(but->type == SB_FOCUS) 
          {
             but->focus=FOCUS_IN;
             ExposeButton(but);
          }
          break;
     case LeaveNotify:
          if(but->type == SB_FOCUS)
          {
             but->focus=FOCUS_OUT;
             ExposeButton(but);
          }
          break;
     case ButtonPress:
          if(but->type == SB_NORMAL)
          {  
             but->isdown=BUTTON_DOWN;
             ExposeButton(but);
          }
          break;
     case ButtonRelease:
          but->func();
          if(but->type == SB_NORMAL)
          {
             but->isdown=BUTTON_UP;
             ExposeButton(but);
          }
          break;
     default:
          break;
   }
}

void FreeButton(BUTTON* but)
{
   if(!but) return;
   if(but->label)  free(but->label);
   if(but->normal) XDestroyImage(but->normal);
   if(but->grey)   XDestroyImage(but->grey);
}