/***********************************************************************\
**                                                                     **
**       TIMER :     pour chronometrer son temps !                     **
**                                                                     **
**                   Fabrice NEYRET - decembre 2001 - copyright iMAGIS **
**                                                                     **
\***********************************************************************/
/*
  CC -Ofast=IP27 -woff 1198,1174,1552 timer.c -o timer -lglut -lGLU -lGL -lXmu -lX11 -lm -I/usr/local/include

  cc -O3 timer.c -o timer.l686 -L/usr/X11R6/lib -lglut -lGLU -lGL -lXmu -lX11 -lXi -lm -I/usr/local/include
*/

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/time.h>
/* #include <GL/gl.h>   déjà dans glut.h */
/* #include <GL/glu.h>  déjà dans glut.h */
#include <GL/glut.h>
#define error(chaine,para) { printf(chaine,para); printf("\n"); exit(-1); }
#define warning(chaine,para) { printf(chaine,para); printf("\n"); }
typedef float vector[3];
#define vector(P, x,y,z) { P[0]=x; P[1]=y; P[2]=z; }
#define MAX(a,b) (((a)>=(b))?(a):(b))
#define MIN(a,b) (((a)<=(b))?(a):(b))

int nb=1, current=0, PRINT=0, BORDER=1, len=1;
#define NB_TIMERS 10
float timer[NB_TIMERS], base[NB_TIMERS]; int active[NB_TIMERS];
char* (label[NB_TIMERS]); int persist[NB_TIMERS],col[NB_TIMERS];
int PERSIST=0; int lu=0;
int SIZEX=100, SIZEY; float kx=1,ky=1;
#define SIZE_PER_TIMER 30
#define set_win_size() { SIZEY = 15+SIZE_PER_TIMER*nb; if (!BORDER) BORDER=-1; }
float temps=0;
int is_idle=0;
#define STEPS_BEFORE_IDLE 150

struct timeval time0, time1;

void reset_time() {
  gettimeofday(&time0,NULL);
}
void init() {
  len=1; nb=1; PERSIST=0;
  reset_time();
  memset(timer,0,NB_TIMERS*sizeof(float));
  memset(base,0,NB_TIMERS*sizeof(float));
  memset(active,0,NB_TIMERS*sizeof(int));
  memset(label,0,NB_TIMERS*sizeof(char*));
  memset(persist,0,NB_TIMERS*sizeof(int));
  memset(col,0xff,NB_TIMERS*sizeof(int));
}

float mytime() {
  gettimeofday(&time1,NULL);
  return (time1.tv_sec-time0.tv_sec) + 1e-6*(time1.tv_usec-time0.tv_usec);
}

void active_timer(int i) {
  if ((i<0)||(i>=NB_TIMERS)) return;
  if (active[i]) return;
  active[i] = 1;
  base[i] = mytime();
}
void stop_timer(int i) {
  void save();
  if ((i<0)||(i>=NB_TIMERS)) return;
  if (!active[i]) return;
  active[i] = 0;
  timer[i] += mytime()-base[i];
  if (PERSIST) save();
}
void reset_timer(int i) {
  void save();
  if ((i<0)||(i>=NB_TIMERS)) return;
  active[i] = 0;
  timer[i] = 0;
  if (PERSIST) save();
}

void switch_timer(int i) {
if ((i<0)||(i>=NB_TIMERS)) return;
  if (active[i]) stop_timer(i);
        else     active_timer(i);
}
void inc_timer(int i) {
  float t;
  if ((i<0)||(i>=NB_TIMERS)) return;
  if (!active[i]) return;
  t = mytime();
  timer[i] += t-base[i];
  base [i] = t;
}
char* built_date(char* buff, int num) {
  sprintf(buff,"%d:%02d:%02d",num/3600,(num%3600)/60,num%60);
  return buff;
}
int date2time(char* buff) {
  int n,h,m,s;
  n = sscanf(buff,"%d:%d:%d",&h,&m,&s);
  switch(n) {
    case 0: warning("horaire %s mal forme'",buff); return -1;
    case 1: s=h; h=m=0; break;
    case 2: s=m; m=h; h=0; break;
    case 3: break;
  }
  return h*3600+m*60+s;
}

/************ affichage ****************************************/

void afflabel(char *msg, vector P, float scale) {
  char *p;
  scale /= (119.05 + 33.33);
  glPushMatrix();
  glTranslatef(P[0],P[1],P[2]);
  glScalef(scale,scale,scale);
  for (p = msg; *p; p++) 
    glutStrokeCharacter(GLUT_STROKE_ROMAN, *p);
  glPopMatrix();
}
void affnum(int num, vector P, float scale) {
  char buff[256];
  sprintf(buff,"%d",num);
  afflabel(buff,P,scale);
}
void affdate(int num, vector P, float scale) {
  char buff[256];
  afflabel(built_date(buff, num),P,scale);
}

void redisplay() {        /* routine générale d'affichage */
  int i; vector P;
  char buff[256];
  void resetgraph();

  resetgraph();       /* on réinitialise l'affichage */

  for (i=0; i<nb; i++) {
			glColor3f(1-.5*(is_idle>STEPS_BEFORE_IDLE),.7,.7);
    vector(P, 3,15+SIZE_PER_TIMER*(nb-1-i),0);
    if (label[i]) afflabel(label[i],P,10);
        else      affnum((i+1)%10,P,10);
    glLineWidth(2.);
    if (active[i]) glColor3ub((col[i]>>16)&255,(col[i]>>8)&255,col[i]&255);
         else      glColor3f(0,0,.8);
    vector(P, 23+4*((len>2)?len-2:0),12+SIZE_PER_TIMER*(nb-1-i),0);
    affdate((int)timer[i], P, 20);
    glLineWidth(1.);
  }

  if (PRINT) {
    printf("\r");
    for (i=0; i<nb; i++)
      printf("%s  ",built_date(buff,(int)timer[i]));
    printf("   \r"); fflush(stdout);
  }
  glutSwapBuffers();  /* on rend le tracé visible    */
}

	       
void idle() {            /* animation */
  int i;

  if (BORDER==-1) { int x,y;
    x=glutGet(GLUT_WINDOW_X);
    y=glutGet(GLUT_WINDOW_Y);
    if (x&&y) {
      glutFullScreen();
      glutReshapeWindow(kx*SIZEX,ky*SIZEY);
      glutPositionWindow(x,y);
      BORDER=0;
    }
  }
  
  if (is_idle>STEPS_BEFORE_IDLE) sleep(1);

	for (i=0; i<nb; i++)
    if (active[i]) inc_timer(i);

  glutPostRedisplay();
	is_idle++;
}
  
int  main(int argc, char **argv) {
    void initgraph();
    void parse_args(int argc, char **argv);
    void parse_default(int);
    void load();
      
    init();
    glutInit(&argc,argv);     /* initialisation de GLUT          */
    parse_default(0);         /* lit le fichier de config        */
    parse_args(argc,argv);    /* analyse de la ligne de commande */
    if (PERSIST) load();
    initgraph();              /* initialisations graphiques      */
    glutMainLoop();           /* boucle des evenements           */
    return 0;
}
 
/*************** interface (ligne commande, clavier, souris, menus) */

void reshape(int x,int y) {    /* la taille de la fenetre change */
    kx=x/(float)SIZEX; ky=y/(float)SIZEY;
    glViewport(0,0,x,y);
}

void help() {
    printf( "\n"
"     commande:                                           \n"
"        timer [-imhpba<N>][<N>]                          \n"
"          -p:    afficher aussi les timers dans le shell \n"
"          -b:    fenetre sans bord                       \n"
"          -a:    active le 1er timer tout de suite       \n"
"          -i:    ignore config par defaut (~/.timerrc)   \n"
"          -m:    considere config memorisee (~/.timerrc) \n"
"          <N>:   nombre de timers                        \n"
"     touches:                                            \n"
"           ESC:  quitter                                 \n"
"           h:    ce message                              \n"
"          SPACE: on/off du timer sous la souris          \n"
"           1-9:  on/off du timer indique'                \n"
"           p:    afficher aussi les timers dans le shell \n"
"        DEL,ctrl-r: reset du timer sous la souris        \n"
"        ctrl-n:  entrer nouvelle valeur du timer sous la souris \n"
"        fleches: avancer ou reculer les minutes et les secondes \n"
"           +:    ajouter un timer                        \n"
"           -:    supprimer le dernier timer              \n"
"           b:    supprimer/remettre bord de fenetre      \n"
"                 (rappel: ALT-F7,ALT-F8 pour deplacer ou retailler fenetre) \n"
"     souris:                                             \n"
"           LEFT: on/off du timer sous la souris          \n\n"
"     fichier ~/.timerrc  (la ligne de commande prend le pas sur ce fichier)\n"
"           options [-pbia<N>]          \n"
"              pba<N>: cf options de la ligne de commande  \n"
"              i: ignore ce fichier sauf si -m sur ligne de commande \n"
"           timer <N> <LABEL> [-persist] [-col RRGGBB]     \n"
"              config du timer <N>: nom, couleur du compteur \n"
"              -persist: compteur persistant (sauvé dans .timerdata)\n"
	    );
}

/* ----- lit le fichier de config */
void parse_default(int mode) {
  FILE *f;
  char *ptr,mot[256],nom[256]; int i,n,l;
  char *home = getenv("HOME");

  if (!home) error("pas de $HOME !",NULL);
  sprintf(nom,"%s/.timerrc",home);
  f = fopen(nom,"r");
  if (!f) return;
  
  while (ptr=fgets(nom,256,f)) {
    mot[0]=0; sscanf(ptr,"%s%n",mot,&i);
    if (mot[0]==0) continue;
    if ((strcmp(mot,"option")==0)||(strcmp(mot,"options")==0)) {
      ptr += i;
      while (*++ptr)
	switch(*ptr) {
	  case 'p': PRINT  = 1-PRINT;  break;
	  case 'b': BORDER = 1-BORDER; break;
	  case 'i': if (!mode) {fclose(f); return; }// par defaut, ignore prefs
	            break;
	  case 'a': active_timer(0);   break;
	  case '0': case '1': case '2': case '3': case '4':
	  case '5': case '6': case '7': case '8': case '9':
	            nb = *ptr - '0';   break;
	}
    } else
      if (strcmp(mot,"timer")==0) {
	ptr = ptr+i;
	sscanf(ptr,"%d%s%n",&n,mot,&i);
	nb = MAX(n,nb); n--;
	label[n]=strdup(mot);
	l = strlen(mot); len = MAX(l,len);
	ptr += i; sscanf(ptr,"%s%n",mot,&i);
	if (strcmp(mot,"-persist")==0) PERSIST=persist[n]=1;
	else if (strcmp(mot,"-col")==0) {
	  ptr += i; sscanf(ptr,"%x",&(col[n]));
	}
    }
  }
  fclose(f); lu=1;
  set_win_size();
}

void load() {
  FILE * f;
  char nom[256],*ptr; int i;
  char *home = getenv("HOME");

  if (!home) error("pas de $HOME !",NULL);
  sprintf(nom,"%s/.timerdata",home);
  f = fopen(nom,"r");
  if (!f) return;
  for (i=0; i<NB_TIMERS; i++) {
    ptr=fgets(nom,256,f); if (!ptr) break;
    if (persist[i]) timer[i]=date2time(ptr);  
  }
  fclose(f);
}

void save() {
  FILE * f;
  char nom[256],buff[256],*ptr; int i,fin=0;
  char *home = getenv("HOME");
  int data[NB_TIMERS];

  memset(data,0,NB_TIMERS*sizeof(int));
  if (!home) error("pas de $HOME !",NULL);
  sprintf(nom,"%s/.timerdata",home);
  f = fopen(nom,"r");
  if (f) {
    for (i=0; i<nb; i++) {
      ptr=fgets(buff,256,f); if (!ptr) break;
      data[i] = date2time(ptr);  
    }
    fclose(f);
    f = fopen(nom,"r+");
  } else f = fopen(nom,"w");
  if (!f) error("je n'arrive pas a ecrire",NULL);
  for (i=0; i<nb; i++) {
    if (persist[i]) fprintf(f,"%s\n",built_date(buff,timer[i]));
         else       fprintf(f,"%s\n",built_date(buff,data[i]));
    /*      if (fin) fputs(built_date(nom,0),f);
      else {
	ptr=fgets(nom,256,f);
	if (!ptr) {fin=1; fputs(built_date(nom,0),f);}
	}*/
  }
  fclose(f);
}

/* ----- analyse de la ligne de commande */

void parse_args(int argc, char **argv) {
  char* c;
    void change_cur_objet(int obj);

    printf("timer: multi-chronometre. Faire -h pour l'aide.\n");
    argc--; argv++;
    while (argc && (*argv)[0]=='-') {
      c = argv[0];
      while (*++c)
	switch(*c) {
	  case 'h': help(); exit(0);
	  case 'p': PRINT  = 1-PRINT;  break;
	  case 'b': BORDER = 1-BORDER; break;
	  case 'm': if (!lu) parse_default(1);  break;
	  case 'i': init();            break; // raz prefs
	  case 'a': active_timer(0);   break;
	  case '0': case '1': case '2': case '3': case '4':
	  case '5': case '6': case '7': case '8': case '9':
	            nb = *c - '0';     break;
	}
	argc--; argv++;
    }
    if (argc) sscanf(argv[0],"%d",&nb);
    if (nb<0) nb = 0;
    if (nb>NB_TIMERS) nb = NB_TIMERS;
    set_win_size();
}

/* ----- gestion des touches du clavier */

void key(unsigned char c,int x,int y) {
  int i; char buff[256];
    switch (c) {
      case 27:  if (PERSIST) save();   exit (0);
      case 'h': help(); break;
      case ' ': switch_timer(current= y*nb/(ky*SIZEY)); break;
      case '1':
      case '2':
      case '3':
      case '4':
      case '5':
      case '6':
      case '7':
      case '8':
      case '9':
      case '0': switch_timer(current= ((c=='0')? 9 : c-'1')); break;
      case  8 : // DEL
      case 18 : reset_timer(current= y*nb/(ky*SIZEY)); break; // ctrl-r
      case 'p': PRINT=1-PRINT; break;
      case 14 : current= y*nb/(ky*SIZEY);    // ctrl-n
                printf("\nvaleur du timer %d: ",current);
                scanf("%s",buff);
		i = date2time(buff);
		if (i>=0) {reset_timer(current); timer[current]=i;}
		break;
      case '+':
      case '=': if (nb<NB_TIMERS) {
	nb++; set_win_size();
	glutReshapeWindow(kx*SIZEX,ky*SIZEY);
      }
      break;
      case '-':
      case '_': if (nb>0) {
	nb--; set_win_size();
	glutReshapeWindow(kx*SIZEX,ky*SIZEY);
      }
      break;
      case 'b':
        BORDER = 1-BORDER;
        if (BORDER)
	  glutReshapeWindow(kx*SIZEX,ky*SIZEY);
	else { int x,y;
            x=glutGet(GLUT_WINDOW_X);
            y=glutGet(GLUT_WINDOW_Y);
            glutFullScreen();
            glutReshapeWindow(kx*SIZEX,ky*SIZEY);
            glutPositionWindow(x,y);
        }
        break;
    }
    glutPostRedisplay();  is_idle=0;
}

void special(int c,int x,int y) {
  switch (c) {
    case GLUT_KEY_UP:   timer[current= y*nb/(ky*SIZEY)] += 60; break;
    case GLUT_KEY_DOWN: timer[current= y*nb/(ky*SIZEY)] -= 60; break;
    case GLUT_KEY_RIGHT: timer[current= y*nb/(ky*SIZEY)]+= 1;  break;
    case GLUT_KEY_LEFT: timer[current= y*nb/(ky*SIZEY)] -= 1;  break;
  }
  if (timer[current]<0) timer[current]=0;
  glutPostRedisplay();   is_idle=0;
}

/* ----- gestion de la souris */

struct {        /* memoire des evenements souris + modifieurs */
    float x ,y,             /* position souris normalisee     */
	  x0,y0,            /* position precedente            */
	  dx,dy;            /* mouvement                      */
    int left,middle,right;  /* etat des boutons de la souris  */
    int shift,ctrl,alt;     /* etat des modifieurs du clavier */
    int state;              /* etat global (cf flags dessous) */
} mouse;

#define SHIFT  0x0001
#define CTRL   0x0002
#define ALT    0x0004
#define LEFT   0x0010
#define MIDDLE 0x0020
#define RIGHT  0x0040

 void mouse_motion(int x,int y) {    /* mouvement de la souris */
    float xx = mouse.x,
	  yy = mouse.y;
    mouse.x =       x/(float)(kx*SIZEX); 
    mouse.y = 1. -  y/(float)(ky*SIZEY);
    mouse.dx = mouse.x-xx;
    mouse.dy = mouse.y-yy;

    switch(mouse.state) {
      case LEFT:  break ;
    }
    glutPostRedisplay();   is_idle=0;
}


void mouse_click(int button,int state,int x,int y) {  /* clic de souris */
    int alt;    /* on stocke dans 'mouse' l'etat de tous les modifieurs */
    switch(button) {
    case GLUT_LEFT_BUTTON:   mouse.left   = (state==GLUT_DOWN); break;
    case GLUT_MIDDLE_BUTTON: mouse.middle = (state==GLUT_DOWN); break;
    case GLUT_RIGHT_BUTTON:  mouse.right  = (state==GLUT_DOWN); break;
    }
    alt = glutGetModifiers();
    mouse.shift = (alt&GLUT_ACTIVE_SHIFT) ?1:0;
    mouse.ctrl  = (alt&GLUT_ACTIVE_CTRL)  ?1:0;
    mouse.alt   = (alt&GLUT_ACTIVE_ALT)   ?1:0;

    mouse.state = SHIFT*mouse.shift | CTRL*mouse.ctrl | ALT*mouse.alt |
	          LEFT*mouse.left | MIDDLE*mouse.middle | RIGHT*mouse.right;
	
    mouse.x0 =       x /(float)(kx*SIZEX); mouse.x=mouse.x0; mouse.dx=0;
    mouse.y0 =  1. - y /(float)(ky*SIZEY); mouse.y=mouse.y0; mouse.dy=0;

    switch(mouse.state) {
      case LEFT: switch_timer(current= y*nb/(ky*SIZEY)); break;
     }
    glutPostRedisplay();   is_idle=0;
}

/*************** initialisations graphiques *************************/

void initgraph() {

  glutInitDisplayString("rgb double");
  glutInitWindowSize(SIZEX,SIZEY);
  glutCreateWindow("multi-chrono");

  glutDisplayFunc(redisplay);
  glutReshapeFunc(reshape);
  glutMouseFunc(mouse_click);
  glutMotionFunc(mouse_motion);
  glutKeyboardFunc(key);
  glutSpecialFunc(special);
  // glutIgnoreKeyRepeat(1);
  glutVisibilityFunc(NULL);
  glutIdleFunc(idle);

  glDrawBuffer(GL_BACK);
  glDepthMask(GL_TRUE);
  glDisable(GL_DEPTH_TEST);  // Enable
  glShadeModel(GL_FLAT);   /* SMOOTH */
  glDisable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  glDisable(GL_NORMALIZE);
 
  glEnable(GL_BLEND); glEnable(GL_LINE_SMOOTH);
  glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  glBlendEquation(GL_FUNC_ADD);

  glColorMaterial(GL_FRONT_AND_BACK,GL_AMBIENT_AND_DIFFUSE);
  glEnable(GL_COLOR_MATERIAL);
}

void resetgraph() {
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); /* on efface */
  glMatrixMode(GL_PROJECTION);
  glLoadIdentity();
  gluOrtho2D(0,SIZEX-1,0,SIZEY-1);
  
  glMatrixMode(GL_MODELVIEW); 
  glLoadIdentity();
}