clock.c

用基于microwindow的一个时钟demo

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#define MWINCLUDECOLORS
#include "microwin/nano-X.h"
#include <math.h>
	           
#define PI       3.14159265358979343846
#define BINPATH  "/mnt/hgfs/share/clock"
#define DATETIME_WID_WIDTH    800
#define DATETIME_WID_HEIGHT  600

static	GR_WINDOW_ID	datetime_wid;		/*datetime main window*/
static	GR_WINDOW_ID	clock_wid;		/*clock window*/
static  GR_WINDOW_ID	pid;
static GR_WINDOW_ID	pid2;
static  GR_WINDOW_ID    clock_wid_dial;
static  GR_WINDOW_ID    clock_wid_digitaldial;
static GR_WINDOW_ID    wi;

static	GR_GC_ID	gc_dial_pivot;		/* graphics context for text */
static	GR_GC_ID	gc_dial_hand;		/* graphics context for rectangle */
static  GR_GC_ID        gc_dial_backimage;
static  GR_GC_ID	gc_text;

static GR_FONT_ID font_s;

static  double          lh = -1, lm = -1, ls = -1;
static  time_t          then=0;
static	GR_COORD	midx;
static	GR_COORD	midy;

GR_IMAGE_ID iid;
GR_IMAGE_INFO iif;

void do_exposure(GR_EVENT_EXPOSURE *ep);
void draw_time(double hour, double minutes, double sec);
void drawlines(double sec,int k,int l,int angle);
void do_clock(void);

void do_button(GR_EVENT_BUTTON *bt);

int main(int ac, char **av)
{
    GR_EVENT	event;	
	
    if (GrOpen() < 0) 
    {
	fprintf(stderr, "cannot open graphics\n");
	exit(1);
    }
    
    if(!(iid = GrLoadImageFromFile(BINPATH"/ico/clock.jpg", 0))) 
    {
	fprintf(stderr, "Failed to load image file \"%s\"\n", BINPATH"/ico/ds.png");
	return 0;
    }

    GrGetImageInfo(iid, &iif);
    midx = iif.width/2.0;
    midy = iif.height/2.0;
    
    datetime_wid = GrNewWindowEx(GR_WM_PROPS_NOAUTOMOVE|GR_WM_PROPS_BORDER|GR_WM_PROPS_CAPTION|
				 GR_WM_PROPS_CLOSEBOX, "wifidatetime", GR_ROOT_WINDOW_ID, 
				 0, 0, DATETIME_WID_WIDTH,DATETIME_WID_HEIGHT, BLUE);
				 
   clock_wid = GrNewWindowEx(GR_WM_PROPS_NOAUTOMOVE|GR_WM_PROPS_NOBACKGROUND, "time",
   						 datetime_wid , 10, 10, iif.width,iif.height+30,YELLOW);
				 
    clock_wid_digitaldial  = GrNewWindowEx(GR_WM_PROPS_NOAUTOMOVE, "dagital time",
   						 clock_wid, 0,iif.height,iif.width,30,RED);				 

    clock_wid_dial = GrNewWindow(clock_wid,0,0,iif.width,iif.height,0,BLUE,BLUE);
    wi = GrNewWindow(datetime_wid,0,0,10,10,0,BLUE,BLUE);
    pid = GrNewPixmap(iif.width, iif.height, NULL);	
	pid2 = GrNewPixmap(iif.width, 30, NULL);	
	 GrRaiseWindow(wi);
	 
    GrSelectEvents(datetime_wid, GR_EVENT_MASK_EXPOSURE | GR_EVENT_MASK_CLOSE_REQ|GR_EVENT_MASK_BUTTON_DOWN);
    GrSelectEvents(clock_wid_dial, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_BUTTON_DOWN);
    GrSelectEvents(clock_wid_digitaldial, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_BUTTON_DOWN);
    GrSelectEvents(datetime_wid, GR_EVENT_MASK_EXPOSURE|GR_EVENT_MASK_BUTTON_DOWN);
   
    gc_dial_pivot = GrNewGC();
    gc_dial_hand = GrNewGC();
    gc_dial_backimage = GrNewGC();
    
    gc_text= GrNewGC(); 
    //font_s = GrCreateFont ("arial",14, NULL);
    //GrSetGCFont (gc_text, font_s);
    GrSetGCForeground(gc_text,BLUE);
    GrSetGCUseBackground(gc_text, GR_FALSE);
      
    GrSetGCForeground(gc_dial_pivot,GRAY );
    GrSetGCForeground(gc_dial_hand, LTGRAY);

    GrSetGCUseBackground(gc_dial_backimage, GR_TRUE);
    GrDrawImageToFit(pid, gc_dial_backimage, 0, 0, iif.width, iif.height, iid);
    
    GrDrawImageFromFile(pid2,gc_dial_backimage,0,0,iif.width, 30,BINPATH"/ico/back.jpg",0);
    GrSetBackgroundPixmap(clock_wid_dial,pid,GR_BACKGROUND_STRETCH);
	 GrSetBackgroundPixmap(clock_wid_digitaldial,pid2,GR_BACKGROUND_STRETCH);
	 
    GrMapWindow(datetime_wid);
    GrMapWindow(clock_wid);
    GrMapWindow(clock_wid_dial);
    GrMapWindow(clock_wid_digitaldial);
    GrMapWindow(wi);
    
    while (1) 
    {
	GrGetNextEventTimeout(&event, 5000L);
	switch (event.type) 
	{
	    case GR_EVENT_TYPE_EXPOSURE:
		do_exposure(&event.exposure);
		break;
		case GR_EVENT_TYPE_BUTTON_DOWN:
		do_button(&event.button);
		break;
		
	    case GR_EVENT_TYPE_CLOSE_REQ:
		GrClose();
		exit(0);
		
	    case GR_EVENT_TYPE_TIMEOUT:
		do_clock();
	}
    }
}

void do_button(GR_EVENT_BUTTON *bt)
{
GrMoveWindow(wi,bt->x,bt->y);
}

void do_exposure(GR_EVENT_EXPOSURE *ep)
{
 if(ep->wid == datetime_wid)
 {
 GrDrawImageFromFile(datetime_wid,gc_dial_backimage,0,0,800,600,BINPATH"/ico/calendar.jpg",0);
 }
    if(ep->wid == clock_wid_digitaldial)
    
	;

    if(ep->wid == clock_wid_dial)
    {
	GrFillEllipse(clock_wid_dial,gc_dial_hand,iif.width/2.0,iif.height/2.0,2,2);
	do_clock();
    }
}

void draw_time(double hour, double minutes, double sec)
{
    GrClearWindow(clock_wid_dial,0);
    drawlines(sec,15,70,2);	
    drawlines(minutes,15,55,8);
    drawlines(hour,15,40,12);
    GrFillEllipse(clock_wid_dial,gc_dial_pivot,midx,midy,5,5);
    lh = hour;
    lm = minutes;
    ls = sec;
}

void do_clock(void)
{
    struct timeval tv;
    struct timezone tz;
    struct tm * tp;
    char sbuf[30] = "";
    time_t now;
    double minutes, hour, sec;
    
    gettimeofday(&tv, &tz);
    now = tv.tv_sec - (60 * tz.tz_minuteswest);
    if (now == then) 
    {
	return;
    }
    then = now;
    tp = gmtime(&now);
    minutes = tp->tm_min * 6*PI/180.0;
    sec = tp->tm_sec * 6*PI/180.0;
    hour = tp->tm_hour;
    if (hour > 12) 
    {
	hour -= 12;
    }
    hour =(hour*30+tp->tm_min*6.0/12.0)*PI/180.0;
    draw_time(hour, minutes, sec);   
    
    sprintf(sbuf, "%s\n",asctime(tp));
    GrClearWindow(clock_wid_digitaldial,0);
    GrText(clock_wid_digitaldial,gc_text,55,25,sbuf,-1,GR_TFASCII);
}

void drawlines(double s,int k,int l,int angle)
{
    GR_POINT  points[3];
    points[0].x = midx;
    points[0].y = midy;
    points[2].x = midx+l*sin(s);
    points[2].y = midy-l*cos(s);
    points[1].x = midx + k*sin(s-angle*PI/180.0);
    points[1].y = midy - k*cos(s-angle*PI/180.0);
    //points[3].x = midx + k*sin(s+angle*PI/180.0);
    //points[3].y = midy - k*cos(s+angle*PI/180.0);
    GrFillPoly(clock_wid_dial,gc_dial_hand,3,points);
    GrLine(clock_wid_dial, gc_dial_hand,midx,midy,midx + l*sin(s),midy - l*cos(s));
    GrLine(clock_wid_dial, gc_dial_hand,midx,midy,midx + k*sin(s-angle*PI/180.0),midy - k*cos(s-angle*PI/180.0));
    GrLine(clock_wid_dial, gc_dial_hand,midx,midy,midx + k*sin(s+angle*PI/180.0),midy - k*cos(s+angle*PI/180.0));
    GrLine(clock_wid_dial, gc_dial_hand, midx+l*sin(s),midy - l*cos(s),midx + k*sin(s-angle*PI/180.0),midy - k*cos(s-angle*PI/180.0));
    GrLine(clock_wid_dial, gc_dial_hand, midx+l*sin(s),midy - l*cos(s),midx + k*sin(s+angle*PI/180.0),midy - k*cos(s+angle*PI/180.0));
}