Srikanth Mani
Published © GPL3+

Alarm Clock in Raspberry PI - Updated with Video support

Alarm clock written in C for Raspberry PI works on PI Zero also, features, Photo or Video as wallpaper and alarm

IntermediateFull instructions provided5 hours8
Alarm Clock in Raspberry PI - Updated with Video support

Things used in this project

Story

Read more

Code

Generate Weather report

BatchFile
This Shell script generate the Weather report file which is read by main program
#/bin/bash
rm /home/pi/gtk_prg/wfeed  /home/pi/gtk_prg/wfeed.xml
wget --quiet  --output-document=/home/pi/gtk_prg/wfeed http://api.openweathermap.org/data/2.5/weather\?q=Bangalore\&APPID=<Put your own API code>\&mode=xml\&units=metric
sed 's/<temperature/\n<temperature/g; s/<humidity/\n<humidity/g; s/<weather/\n<weather/g; s/<lastupdate/\n<lastupdate/g;' /home/pi/gtk_prg/wfeed > /home/pi/gtk_prg/wfeed.xml

Main C program

C/C++
main application program
#include<gtk/gtk.h>
#include<gdk/gdkx.h>
#include<gdk/gdkkeysyms.h>
#include<time.h>
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<dirent.h>
#include<vlc/vlc.h>
#include<flite/flite.h>
#include<sys/types.h>
#include<sys/stat.h>
#include<signal.h>
#include<errno.h>
#include<unistd.h>
#include<ctype.h>

  GtkWidget *button_d,*info_text,*alaram_stop,*wlabel,*img;
 struct alaram_t
       {
         int a_hrs, a_mins;
          char a_music[256],a_days[8];
       };
 struct startup_t
       {
         int a_hrs, a_mins;
          char a_music[256],a_days[8];
       };
 struct task_t
       {
         int a_hrs, a_mins,a_day,a_mon;
          char a_desc[50];
       };
char *v_file;
struct alaram_t alaram_data[9] = { {0} };
struct startup_t startup_data[9] = { {0} };
struct task_t task_data[9] = { {0} };
int act_task=9,act_alaram=9,edit_alaram=-1,hd,act_startup=9;
int check_file_exist(char *);
void check_alaram(int,int,int);
void update_task_info(int,int,int);
void speech_text(char *,int );
void load_video_file(char *,int);
void load_image_file(char *);
int isDirectory(char *);
int check_audio_file(char *);
int play_video=1;
int fresh_load='Y';
int img_count,tot_img_count=0;
FILE *img_fp;
//char img_file[25][125]
float pos=0.0;
GtkWidget *player_widget,*img,*vp;
char gl_video_status;
   libvlc_instance_t *inst;
   libvlc_media_player_t *mp;

void listdir(char *path, size_t size, FILE *fpp) {
    DIR *dir;
    struct dirent *entry;
    size_t len = strlen(path);
    if (!(dir = opendir(path))) {
        fprintf(stderr, "path not found: %s: %s\n",path, strerror(errno));
        return;
    }
 //   puts(path);
    while ((entry = readdir(dir)) != NULL) {
        char *name = entry->d_name;
        if (entry->d_type == DT_DIR) {
            if (!strcmp(name, ".") || !strcmp(name, ".."))
                continue;
            if (len + strlen(name) + 2 > size) {
                fprintf(stderr, "path too long: %s/%s\n", path, name);
            } else {
                path[len] = '/';
                strcpy(path + len + 1, name);
                listdir(path, size,fpp);
                path[len] = '\0';
            }
        } else {
           int ll=strlen(name);
           if (tolower(name[ll-1]) == 'g' && tolower(name[ll-2]) == 'p' && tolower(name[ll-3]) == 'j')
               fprintf(fpp,"%s/%s\n", path, name);
        }
    }
    closedir(dir);
}

void change_video_photo(char st) 
{
  gl_video_status = st;
  if (play_video == 0) { 
     gtk_button_set_label(GTK_BUTTON(vp),"Vide_o");
     play_video = 1 ;
     gtk_widget_show(player_widget); gtk_widget_hide(img);
     }
  else {
          libvlc_media_player_pause(mp);
          libvlc_media_player_stop(mp);
     gtk_button_set_label(GTK_BUTTON(vp),"Phot_os");
     play_video = 0 ; fresh_load='Y';
     gtk_widget_show(img); gtk_widget_hide(player_widget);
           gtk_widget_set_sensitive(alaram_stop,FALSE); 
         }
}

 
void Open_playlist(char *dname)
 {
    FILE *d; DIR *di;
    char fullpath[125],str[125];
    int i=0;
 struct dirent *dir;
libvlc_media_t *md1;

      libvlc_media_list_t  *ml = libvlc_media_list_new(inst);
  d = fopen(dname,"rt"); if(d==NULL) return;
    while (fgets(str,125,d) != NULL)
      {  
          str[strlen(str)-1]='\0';
       if(isDirectory(str))
             {
          di = opendir(str);  strcpy(fullpath,str);
                       strcat(fullpath,"/");
                   while((dir = readdir(di)) != NULL) {
                     if (strcmp(dir->d_name,".") && strcmp(dir->d_name,".."))
                       {
                           strcat(fullpath,dir->d_name); 
                       g_print("%s\n",fullpath);
                          if(!check_audio_file(fullpath)) {
                             md1 = libvlc_media_new_path(inst,fullpath);
                             libvlc_media_list_add_media(ml,md1);
                             libvlc_media_release(md1); }
                             strcpy(fullpath,str);
                             strcat(fullpath,"/");
                        }
                      }
               }
     else
         {
         strcpy(fullpath,str);
         g_print("%s\n",fullpath);
          md1 = libvlc_media_new_path(inst,fullpath);
          libvlc_media_list_add_media(ml,md1);
          libvlc_media_release(md1);
         }
      }
   libvlc_media_list_player_t  *mlp = libvlc_media_list_player_new(inst);
   libvlc_media_list_player_set_media_list(mlp,ml);
   libvlc_media_list_player_set_media_player(mlp,mp);
      fclose(d);
   libvlc_media_list_player_play(mlp); sleep(5);
   libvlc_audio_set_volume(mp,99);
 }

int parse_startup_file()
 {
   int i=0;
   FILE *fp;
   char temp[256],*token;
     token = malloc(256);
  fp = fopen("/home/pi/gtk_prg/startup_v.file","rt");
   if (fp==NULL) return 0;
  while (fgets(temp,256,fp)!= NULL)
  {
    if (strlen(temp) > 13) {
      token = strtok(temp,";");
       startup_data[i].a_hrs = atoi(token);
          token = strtok(NULL,";");
          startup_data[i].a_mins = atoi(token);
             token = strtok(NULL,";");
              strcpy(startup_data[i].a_music,token);
                token = strtok(NULL,";");
                strcpy(startup_data[i].a_days,token);
        i++;  if (i == 9 ) break;
         }
   }
  fclose(fp);
 }


int parse_alaram_file()
 {
   int i=0;
   FILE *fp;
   char temp[256],*token;
     token = malloc(256);
  fp = fopen("/home/pi/gtk_prg/alaram_v.file","rt");
   if (fp==NULL) return 0;
  while (fgets(temp,256,fp)!= NULL)
  {
    if (strlen(temp) > 13) {
      token = strtok(temp,";");
       alaram_data[i].a_hrs = atoi(token);
          token = strtok(NULL,";");
          alaram_data[i].a_mins = atoi(token);
             token = strtok(NULL,";");
              strcpy(alaram_data[i].a_music,token);
                token = strtok(NULL,";");
                strcpy(alaram_data[i].a_days,token);
        i++;  if (i == 9 ) break;
           }
   }
  fclose(fp);
 }

static gboolean delete_event(GtkWidget *widget, GdkEvent *event, gpointer data)
{
 g_print("Delete event occured\n");
 gtk_main_quit();
return TRUE;
}

static gboolean draw_callback(GtkWidget *widget, cairo_t *cr, gpointer data)
 {
   cairo_set_source_rgba(cr, 0.0, 0.0, 1.0, 0.3);
   cairo_paint(cr);
   return FALSE;
 }

  void player_widget_on_realize(GtkWidget *widget, gpointer data) {
      libvlc_media_player_set_xwindow(mp, GDK_WINDOW_XID(gtk_widget_get_window(widget)));
  }


void write_file()
{
  FILE *fp;
  fp = fopen("/home/pi/gtk_prg/hello_vp_data_file.bin","wb");
   if (fp !=0 ) {
       if(fwrite(alaram_data,sizeof(alaram_data),1,fp) !=1)
             printf("alaram data Write failed\n");
       if(fwrite(task_data,sizeof(task_data),1,fp) !=1)
             printf("task data Write failed\n");
       if(fwrite(startup_data,sizeof(startup_data),1,fp) !=1)
             printf("Startup data Write failed\n");
       if(fwrite(&act_alaram,sizeof(act_alaram),1,fp) !=1)
             printf("alaram data Write failed\n");
       if(fwrite(&act_task,sizeof(act_task),1,fp) !=1)
             printf("task data Write failed\n");
       if(fwrite(&act_startup,sizeof(act_startup),1,fp) !=1)
             printf("startup data Write failed\n");

      fclose(fp);
             }
}

void term(int signum)
{
 write_file();
 gtk_main_quit();
}

static void destroy(GtkWidget *widget, gpointer data)
{
 write_file();
 gtk_main_quit();
}

void w_report()
{
  FILE *fp;
  char wrep[100],wrep1[50],temp[5],str[100],wth[25];;
int i=0,j=0,counter=0;
 char *token;
    system("/home/pi/gtk_prg/wreport.sh");
  fp = fopen("/home/pi/gtk_prg/wfeed.xml","rt"); if (fp==NULL) return;
   while( (fgets (str, 100, fp)!=NULL) && counter < 10 ) 
   {
    i=0;
     if(!strncmp(str,"<temperature",12)) {
                temp[0] = str[20];
               temp[1] = str[21];
               temp[2] = '\0'; 
                 }
   else
   if(!strncmp(str,"<weather",8)) {
              token = strtok(str,"\"");
               while(token != NULL)
               {i++;
              token = strtok(NULL,"\"");
            if(i==3) { 
                sprintf(wrep,"Weather is %s. Current Temperature is %s degree celsius",token,temp);
                sprintf(wrep1,"Temp %s°C/%s",temp,token); }
               }
        }
  }
   fclose(fp);
            speech_text(wrep,1);
    gtk_label_set_text(GTK_LABEL(wlabel),wrep1);

}



void speech_text(char *speech_txt,int head_line) 
{
     libvlc_media_player_pause(mp);

  if(head_line == 0 )
      {
system("/usr/bin/flite -voice file:///home/pi/cmu_us_clb.flitevox  -f /home/pi/gtk_prg/temp_xml_feed.xml");
       //  flite_file_to_speech("/home/pi/gtk_prg/temp_xml_feed.xml",v,"play");

     }
else
   {
    cst_voice *v;
 char spk_str[460];
             cst_voice * register_cmu_us_slt();
              v = register_cmu_us_slt(NULL);
    flite_text_to_speech(speech_txt,v,"play");
   }
     libvlc_media_player_play (mp);
}

void set_vid_ph(GtkWidget *widg, GtkWidget *dt)
{
   change_video_photo('P');
}

char to_lower(unsigned char ch) {
    if (ch >= 'A' && ch <= 'Z')
        ch = 'a' + (ch - 'A');
    return ch;
 }


int check_audio_file(char *filename)
  {
   char ext[5]; 
   int i=0,j=0,len;
   len = strlen(filename);
   ext[0]=filename[len-4];
   ext[1]=to_lower(filename[len-3]);
   ext[2]=to_lower(filename[len-2]);
   ext[3]=to_lower(filename[len-1]);
   ext[4]='\0';
     if(!strcmp(ext,".mp3")) return 0;
     if(!strcmp(ext,".wma")) return 0;
     if(!strcmp(ext,".m4a")) return 0;
     if(!strcmp(ext,".ogg")) return 0;
     if(!strcmp(ext,".jpg")) return 0;
     if(!strcmp(ext,".pls")) return 2;
    return 1;

  }

void set_volume(GtkWidget *widget, gpointer data)
 {
    static int volume;
//    printf("before volume %d\n",volume);
    if (!strcasecmp("mute",gtk_widget_get_name(widget))) {
      if(!strcasecmp("_Mute off",gtk_button_get_label(GTK_BUTTON(widget)))) {
          volume = libvlc_audio_get_volume(mp);
          libvlc_audio_set_volume(mp,0);
          gtk_button_set_label(GTK_BUTTON(widget),"_Mute on");
//          printf("in Mute off\n");
           }
      else {
          if(!strcasecmp("_Mute on",gtk_button_get_label(GTK_BUTTON(widget)))) {
      libvlc_audio_set_volume(mp,volume);
          gtk_button_set_label(GTK_BUTTON(widget),"_Mute off");
//          printf("in Mute on\n");
               }

           }
       }

    if (!strcasecmp("volp",gtk_widget_get_name(widget))) {
         volume = libvlc_audio_get_volume(mp);
          if (volume < 97 )
            volume = volume + 2; 
            libvlc_audio_set_volume(mp,volume);
//          printf("in Vol P\n");
         }
    else {
        if (!strcasecmp("volm",gtk_widget_get_name(widget))) {
            volume = libvlc_audio_get_volume(mp);
             if (volume > 3)
               volume = volume - 2;
            libvlc_audio_set_volume(mp,volume);
//          printf("in Vol M\n"); 
             }
         }
//    printf("after volume %d\n",volume);
}

void Open_Dir(char *dname)
 {
    DIR *d;
    char fullpath[125];
    int i=0,file_count;
 struct dirent *dir;
libvlc_media_t *md1;
 libvlc_media_list_t *ml;
    libvlc_media_list_player_t *mlp;
      ml = libvlc_media_list_new(inst);
         libvlc_audio_set_volume(mp,99);
  d = opendir(dname);  strcpy(fullpath,dname);
                       strcat(fullpath,"/");
  while((dir = readdir(d)) != NULL) {
      if (strcmp(dir->d_name,".") && strcmp(dir->d_name,".."))
                 {
                  strcat(fullpath,dir->d_name); 
                    if(!check_audio_file(fullpath)) {
                   md1 = libvlc_media_new_path(inst,fullpath);g_print("%s\n",fullpath);
                   libvlc_media_list_add_media(ml,md1);
                    libvlc_media_release(md1); }
                  strcpy(fullpath,dname);
                       strcat(fullpath,"/");
                   }
                                     } 
      mlp = libvlc_media_list_player_new(inst);
      libvlc_media_list_player_set_media_list(mlp,ml);
      libvlc_media_list_player_set_media_player(mlp,mp);
      file_count = i;
      closedir(d);
      libvlc_media_list_player_play(mlp); sleep(5);
      libvlc_audio_set_volume(mp,99);

}


void play_music(char *fname,int sec)
 {
     libvlc_media_t *m; 
      m = libvlc_media_new_location (inst, fname);
         libvlc_media_player_set_media(mp, m);
          libvlc_media_player_play (mp); sleep(5);
       libvlc_media_release (m);
//     printf("is playing %d , ",libvlc_media_player_is_playing(mp));
     int ttt = libvlc_audio_get_volume(mp);
//      printf("get volume %d ,",ttt);
      ttt = libvlc_audio_set_volume(mp,99);
//      printf("set volume %d\n",ttt);
 }

void stop_alaram(GtkWidget *widg, gpointer data)
{
      if(libvlc_media_player_is_playing(mp) == 1) {
          libvlc_media_player_pause(mp);
          libvlc_media_player_stop(mp);
           gtk_widget_set_sensitive(alaram_stop,FALSE); 
        } 
}

void spell_time(int t ) 
 {
   char fname[50];
    if( t > 12 && t < 24)
       sprintf(fname,"Current Time is %d PM",(t-12));
    if( t > 0 && t <12)
       sprintf(fname,"Current Time is %d AM",t);
    if(t == 12)
       sprintf(fname,"It is Noon");
    if(t == 0)
       sprintf(fname,"It is Midnight");

    if(t > 5 && t < 22)
                      if(access("mp3player_vlc.run",F_OK))
                            {   speech_text(fname,1);
                              w_report(); }
  }



gint update_time(gpointer data)
{
 time_t now;
 struct tm *now_tm;
  char cur_time[10], dt[20];
  char img_buff[1024];
char * arrDaynames[7] = {"Sun", "Mon", "Tue","Wed", "Thu", "Fri", "Sat"};
char * arrMonnames[12] = {"Jan", "Feb", "Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"};

   time(&now);
   now_tm = localtime(&now);
    sprintf(cur_time,"%02d:%02d:%02d", now_tm->tm_hour, now_tm->tm_min,now_tm->tm_sec);
     sprintf(dt,"%s %s %d %d",arrDaynames[now_tm->tm_wday],arrMonnames[now_tm->tm_mon],now_tm->tm_mday,now_tm->tm_year+1900);
     gtk_label_set_text(GTK_LABEL(data),cur_time);
     gtk_label_set_text(GTK_LABEL(button_d),dt);
   if(now_tm->tm_min == 0 && now_tm->tm_sec==0) {
             spell_time(now_tm->tm_hour);
             if (gl_video_status == 'T' && now_tm->tm_hour == 6)
                  change_video_photo('P');
            }
     if(now_tm->tm_sec == 0)  {
         check_alaram(now_tm->tm_hour,now_tm->tm_min,now_tm->tm_wday);
            update_task_info(now_tm->tm_hour,now_tm->tm_min,now_tm->tm_sec); }
  if((now_tm->tm_sec == 0 && (now_tm->tm_min % 5) == 0 && play_video==0)|| (fresh_load == 'Y' && play_video==0)) {
       if (img_fp != NULL){
          fgets(img_buff,1024,img_fp);
             if(feof(img_fp)) {
                   rewind(img_fp);
                   fgets(img_buff,1024,img_fp);
//                  printf("Img file reloaded %s\n",img_buff);
                  img_buff[strlen(img_buff)-1]='\0'; }
             else {
//                   fgets(img_buff,1024,img_fp);
//               printf("Img file %s\n",img_buff);
                  img_buff[strlen(img_buff)-1]='\0'; }
             gtk_image_set_from_file(GTK_IMAGE(img),img_buff);
              GdkPixbuf *spixbuf,*dpixbuf;
             spixbuf= gtk_image_get_pixbuf(GTK_IMAGE(img));
              dpixbuf = gdk_pixbuf_scale_simple(spixbuf,1000,465,GDK_INTERP_BILINEAR);
              gtk_image_set_from_pixbuf(GTK_IMAGE(img),dpixbuf);
//              g_object_unref(G_OBJECT(spixbuf));
              g_object_unref(G_OBJECT(dpixbuf));
 // g_print("%c - Img\n",fresh_load);
             fresh_load = 'N';
                 }
              }
 if(libvlc_media_player_is_playing(mp) == 0 && now_tm->tm_hour < 21 && now_tm->tm_hour > 5 && play_video == 1) {
   sleep(3);
    if(libvlc_media_player_is_playing(mp)==0)
      if (strlen(v_file) > 0 && play_video == 1) {
        libvlc_media_t *m;
         m = libvlc_media_new_location (inst, v_file);
         libvlc_media_add_option(m,"input-repeat=65535");
         libvlc_media_player_set_media(mp, m);
         libvlc_media_player_play (mp); sleep(5);
         libvlc_media_release (m);
         libvlc_media_player_set_position(mp,pos);
         int ttt = libvlc_audio_set_volume(mp,60);
         printf("V  %d\n",ttt);
//           gtk_widget_set_sensitive(alaram_stop,FALSE); hd=0; 
                 }
              }
 if(libvlc_media_player_is_playing(mp) == 1) {
      if (now_tm->tm_hour > 20) {
           if(play_video==1) change_video_photo('T');
           gtk_widget_set_sensitive(alaram_stop,FALSE);} 
      else 
          gtk_widget_set_sensitive(alaram_stop,TRUE); hd=1;
 
           }
     return TRUE;
 }

void update_task_info(int h, int m, int d)
 {
        int i=0,slen;
       if(h != 0 && m != 0) {
           for(i=0;i<9;i++) {
                 if(h == task_data[i].a_hrs && m == task_data[i].a_mins ) // && d == task_data[i].a_day)
                   {   gtk_label_set_text(GTK_LABEL(info_text),task_data[i].a_desc);
                       slen=strlen(task_data[i].a_desc);
                        speech_text(task_data[i].a_desc,1);
GtkDialogFlags flags = GTK_DIALOG_DESTROY_WITH_PARENT;
GtkWidget *dialog = gtk_message_dialog_new (NULL,flags,GTK_MESSAGE_ERROR,GTK_BUTTONS_CLOSE,"%s",task_data[i].a_desc,0);
g_signal_connect_swapped (dialog, "response",G_CALLBACK (gtk_widget_destroy),dialog);
gtk_widget_show_all(dialog);
                        break; }
              }
             }
  }

int isDirectory(char *arg)
 {
    struct stat statbuf;
        stat(arg,&statbuf);
     if(S_ISDIR(statbuf.st_mode))
        return 1;
     else
        return 0;
}


void check_alaram(int h, int m, int w)
 {
   int i=0;
if( h != 0 && m != 0) {
   for (i=0;i<act_alaram;i++ ) {
    if(alaram_data[i].a_hrs == h  && alaram_data[i].a_mins == m && alaram_data[i].a_days[w] == 'Y')
       {
           pos =libvlc_media_player_get_position(mp); 
           libvlc_media_player_pause(mp);
           libvlc_media_player_stop(mp);
     if(isDirectory(alaram_data[i].a_music))
          Open_Dir(alaram_data[i].a_music);
     else {
           if(check_audio_file(alaram_data[i].a_music) == 2){
               Open_playlist(alaram_data[i].a_music); }
           else {
               play_music(alaram_data[i].a_music,60);
               libvlc_audio_set_volume(mp,99); }
           }
       gtk_widget_set_sensitive(alaram_stop,TRUE);
             hd=1;
            }
 if(startup_data[i].a_hrs == h  && startup_data[i].a_mins == m && startup_data[i].a_days[w] == 'Y')
       {
     if(isDirectory(alaram_data[i].a_music))
          load_image_file(startup_data[i].a_music);
     else
         load_video_file(startup_data[i].a_music,0);
         }

     }
   }
}

int cls_win(GtkWidget *widget, gpointer window)
  {
    gtk_widget_destroy(GTK_WIDGET(window));
   }

int chk_hrmi(GtkWidget *widget, gpointer  hrmi)
 {
   char cb_name[5];
   int i;
      strcpy(cb_name,gtk_widget_get_name(widget));
    i = cb_name[2] - '0' ;
            if (!strncmp(cb_name,"HB",2)) {
              alaram_data[i].a_hrs =atoi(gtk_entry_get_text(GTK_ENTRY(widget)));
                    if(alaram_data[i].a_hrs <0 || alaram_data[i].a_hrs > 24)
                              alaram_data[i].a_hrs =0;
                   }
            if(!strncmp(cb_name,"MB",2)) {
              alaram_data[i].a_mins =atoi(gtk_entry_get_text(GTK_ENTRY(widget)));
                    if(alaram_data[i].a_mins <0 || alaram_data[i].a_mins > 59)
                              alaram_data[i].a_mins =0;
                 }
 return FALSE;
  } 

int task_time(GtkWidget *widget, gpointer  hrmi)
 {
   char cb_name[5]; 
   int i; 
      strcpy(cb_name,gtk_widget_get_name(widget));
    i = cb_name[2] - '0' ;
            if (!strncmp(cb_name,"HB",2)) {
              task_data[i].a_hrs =atoi(gtk_entry_get_text(GTK_ENTRY(widget)));
                    if(task_data[i].a_hrs <0 || task_data[i].a_hrs > 24)
                              task_data[i].a_hrs =0;
                   }
            if(!strncmp(cb_name,"MB",2)) {
              task_data[i].a_mins =atoi(gtk_entry_get_text(GTK_ENTRY(widget)));
                    if(task_data[i].a_mins <0 || task_data[i].a_mins > 59)
                              task_data[i].a_mins =0;
                  }
              if(!strncmp(cb_name,"TA",2)) 
                 strcpy(task_data[i].a_desc,gtk_entry_get_text(GTK_ENTRY(widget)));

   return FALSE; 
 } 


int chk_chk(GtkWidget *widget, gpointer chkb)
  {
char  cb_name[5]; 
int i,j;
      strcpy(cb_name,gtk_widget_get_name(widget));
      i = cb_name[2] - '0';   j = cb_name[3] - '0' ;
    if (gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(GTK_WIDGET(chkb))))
        {
                  alaram_data[i].a_days[j]='Y';
          }
       else
          {
                 alaram_data[i].a_days[j]='N';

          }
   return FALSE;
    }

void set_music_file(GtkWidget *widget, GtkWidget *dt)
 {
   char cb_name[5]; int i;
    GtkWidget *dialog;
   dialog = gtk_file_chooser_dialog_new("Choose Tone File", NULL, GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel",GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
          char *uri;
          uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog)); 

 strcpy(cb_name,gtk_widget_get_name(widget));
    i = cb_name[2] - '0' ;

         strcpy(alaram_data[i].a_music,uri); 
   gtk_label_set_text(GTK_LABEL(dt),uri);
                 } 
 gtk_widget_destroy(GTK_WIDGET(dialog));
}

void set_alaram_music(GtkWidget *widget, gpointer data)
  {
   GtkWidget *sbutton[9], *hbutton[9], *sb, *hb,*wind,*fxd,*n;
   int i=0,k=0;
  char ll[5],nm[5], music_file[50];
      wind = gtk_window_new(GTK_WINDOW_TOPLEVEL);
    gtk_window_set_position(GTK_WINDOW(wind),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW(wind),"Set Alaram Tone");
    sb=gtk_label_new("Alaram no");
    hb = gtk_label_new("Music File");
    
     for(int i=0;i<9;i++) {  
          sprintf(ll,"%2d",i+1);
         sbutton[i] = gtk_button_new_with_label(ll);
          sprintf(nm,"SB%1d",i);gtk_widget_set_name(sbutton[i],nm);
  
         hbutton[i] = gtk_label_new(alaram_data[i].a_music); 
           sprintf(nm,"HB%1d",i);gtk_widget_set_name(hbutton[i],nm);
      g_signal_connect  (sbutton[i],"clicked",G_CALLBACK(set_music_file),GTK_WIDGET(hbutton[i]));
   }
     n = gtk_button_new_with_label("Done");

    fxd = gtk_fixed_new();    gtk_container_add(GTK_CONTAINER(wind),fxd);
    gtk_widget_show(fxd);
   int j = 30;
     gtk_fixed_put(GTK_FIXED(fxd),n,300,350);
     gtk_fixed_put(GTK_FIXED(fxd),sb,5,5);
     gtk_fixed_put(GTK_FIXED(fxd),hb,100,5);
  
   for(int i =0; i <9; i++) {
     gtk_fixed_put(GTK_FIXED(fxd),sbutton[i],5,j);
     gtk_fixed_put(GTK_FIXED(fxd),hbutton[i],60,j+5);
  
                j = j+ 35;
                       }
 gtk_window_set_default_size(GTK_WINDOW(wind),600,400);
 g_signal_connect  (n,"clicked",G_CALLBACK(cls_win),G_OBJECT(wind));

 gtk_widget_show_all(wind);
}

void edit_alarams(GtkWidget *widget, gpointer data)
 {
   GtkWidget *sbutton[10], *hbutton[10],*mbutton[10],*chk[10][7],*fxd;
   GtkWidget *sb,*hb,*mb,*ck[7],*wind,*n;
 char ll[5], nm[10],val[5];
      wind = gtk_window_new(GTK_WINDOW_TOPLEVEL);
gtk_window_set_position(GTK_WINDOW(wind),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW(wind),"Set Alaram");
    sb=gtk_label_new("S.no");
    hb = gtk_label_new("Hrs");
    mb = gtk_label_new("Mins");
    ck[0] = gtk_label_new("S");
    ck[1] = gtk_label_new("M");
    ck[2] = gtk_label_new("T");
    ck[3] = gtk_label_new("W");
    ck[4] = gtk_label_new("T");
    ck[5] = gtk_label_new("F");
    ck[6] = gtk_label_new("S");
     for(int i=0;i<9;i++) {  
         sprintf(ll,"%2d",i+1);
         sbutton[i] = gtk_button_new_with_label(ll);
          sprintf(nm,"SB%1d",i);gtk_widget_set_name(sbutton[i],nm);
          sprintf(val,"%2d",alaram_data[i].a_hrs);
         hbutton[i] = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(hbutton[i]),val);
           sprintf(nm,"HB%1d",i);gtk_widget_set_name(hbutton[i],nm);
 g_signal_connect  (hbutton[i],"focus-out-event",G_CALLBACK(chk_hrmi),G_OBJECT(wind));
          sprintf(val,"%2d",alaram_data[i].a_mins);
         mbutton[i]=gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(mbutton[i]),val);
           sprintf(nm,"MB%1d",i);gtk_widget_set_name(mbutton[i],nm);          
 g_signal_connect  (mbutton[i],"focus-out-event",G_CALLBACK(chk_hrmi),G_OBJECT(wind));
         for(int j=0;j<7;j++) { 
             chk[i][j] = gtk_check_button_new();
               sprintf(nm,"CH%1d%1d",i,j);gtk_widget_set_name(chk[i][j],nm);
              if(alaram_data[i].a_days[j] == 'Y') {
          gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(chk[i][j]),TRUE); }
g_signal_connect (chk[i][j], "toggled", G_CALLBACK(chk_chk),G_OBJECT(chk[i][j]));
                             }
           }
     n = gtk_button_new_with_label("Done");

    fxd = gtk_fixed_new();    gtk_container_add(GTK_CONTAINER(wind),fxd);
    gtk_widget_show(fxd);
   int j = 30;
     gtk_fixed_put(GTK_FIXED(fxd),n,300,400);
     gtk_fixed_put(GTK_FIXED(fxd),sb,5,5);
     gtk_fixed_put(GTK_FIXED(fxd),hb,50,5);
     gtk_fixed_put(GTK_FIXED(fxd),mb,85,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[0],140,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[1],165,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[2],190,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[3],215,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[4],240,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[5],265,5);
     gtk_fixed_put(GTK_FIXED(fxd),ck[6],290,5);
   for(int i =0; i <9; i++) {
     gtk_fixed_put(GTK_FIXED(fxd),sbutton[i],5,j);
     gtk_fixed_put(GTK_FIXED(fxd),hbutton[i],50,j);
     gtk_fixed_put(GTK_FIXED(fxd),mbutton[i],85,j);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][0],140,j+5);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][1],165,j+5);    
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][2],190,j+5);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][3],215,j+5);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][4],240,j+5);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][5],265,j+5);
     gtk_fixed_put(GTK_FIXED(fxd),chk[i][6],290,j+5);  
  gtk_widget_set_size_request(sbutton[i], 30,20);
  gtk_entry_set_width_chars(GTK_ENTRY(hbutton[i]), 3); gtk_entry_set_max_length(GTK_ENTRY(hbutton[i]),3);
  gtk_entry_set_width_chars(GTK_ENTRY(mbutton[i]), 3); gtk_entry_set_max_length(GTK_ENTRY(mbutton[i]),3);
              j = j+ 40;
                       }
 gtk_window_set_default_size(GTK_WINDOW(wind),500,450);
 g_signal_connect  (n,"clicked",G_CALLBACK(cls_win),G_OBJECT(wind));
 gtk_widget_show_all(wind);
}

void set_tasks(GtkWidget *widget, gpointer data)
 {
   GtkWidget *hbutton[9],*mbutton[9],*dbutton[9],*desc[9],*fxd,*db;
   GtkWidget *ds,*hb,*mb,*wind,*n;
 char nm[10],val[5];
      wind = gtk_window_new(GTK_WINDOW_TOPLEVEL);
   gtk_window_set_position(GTK_WINDOW(wind),GTK_WIN_POS_CENTER);
gtk_window_set_title (GTK_WINDOW(wind),"Set Tasks");
    ds=gtk_label_new("Description");
    hb = gtk_label_new("Hrs");
    mb = gtk_label_new("Mins");
    db = gtk_label_new("Date");
     for(int i=0;i<9;i++) {  
          sprintf(val,"%2d",task_data[i].a_hrs);
         hbutton[i] = gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(hbutton[i]),val);
           sprintf(nm,"HB%1d",i);gtk_widget_set_name(hbutton[i],nm);
 g_signal_connect  (hbutton[i],"focus-out-event",G_CALLBACK(task_time),G_OBJECT(wind));
          sprintf(val,"%2d",task_data[i].a_mins);
         mbutton[i]=gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(mbutton[i]),val);
           sprintf(nm,"MB%1d",i);gtk_widget_set_name(mbutton[i],nm);          
 g_signal_connect  (mbutton[i],"focus-out-event",G_CALLBACK(task_time),G_OBJECT(wind));
         sprintf(val,"%2d",task_data[i].a_day);
         dbutton[i]=gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(dbutton[i]),val);
           sprintf(nm,"DB%1d",i);gtk_widget_set_name(dbutton[i],nm);          
 g_signal_connect  (dbutton[i],"focus-out-event",G_CALLBACK(task_time),G_OBJECT(wind));
         desc[i]=gtk_entry_new(); gtk_entry_set_text(GTK_ENTRY(desc[i]),task_data[i].a_desc);
           sprintf(nm,"TA%1d",i);gtk_widget_set_name(desc[i],nm);          
 g_signal_connect  (desc[i],"focus-out-event",G_CALLBACK(task_time),G_OBJECT(wind));
           }
     n = gtk_button_new_with_label("Done");
    fxd = gtk_fixed_new();    gtk_container_add(GTK_CONTAINER(wind),fxd);
    gtk_widget_show(fxd);
   int j = 30;
     gtk_fixed_put(GTK_FIXED(fxd),n,300,350);
     gtk_fixed_put(GTK_FIXED(fxd),hb,5,5);
     gtk_fixed_put(GTK_FIXED(fxd),mb,40,5);
     gtk_fixed_put(GTK_FIXED(fxd),db,90,5);
     gtk_fixed_put(GTK_FIXED(fxd),ds,150,5);
   for(int i =0; i <9; i++) {
     gtk_fixed_put(GTK_FIXED(fxd),hbutton[i],5,j);
     gtk_fixed_put(GTK_FIXED(fxd),mbutton[i],40,j);
     gtk_fixed_put(GTK_FIXED(fxd),dbutton[i],90,j);
     gtk_fixed_put(GTK_FIXED(fxd),desc[i],150,j);
  gtk_entry_set_width_chars(GTK_ENTRY(hbutton[i]), 3); gtk_entry_set_max_length(GTK_ENTRY(hbutton[i]),3);
  gtk_entry_set_width_chars(GTK_ENTRY(mbutton[i]), 3); gtk_entry_set_max_length(GTK_ENTRY(mbutton[i]),3);
  gtk_entry_set_width_chars(GTK_ENTRY(dbutton[i]), 3); gtk_entry_set_max_length(GTK_ENTRY(dbutton[i]),3);
  gtk_entry_set_width_chars(GTK_ENTRY(desc[i]), 30); gtk_entry_set_max_length(GTK_ENTRY(desc[i]),45);
              j = j+ 35;
                       }
 gtk_window_set_default_size(GTK_WINDOW(wind),600,400);
 g_signal_connect  (n,"clicked",G_CALLBACK(cls_win),G_OBJECT(wind));
 gtk_widget_show_all(wind);
}

gboolean on_key_press (GtkWidget *widget, GdkEventKey *event, gpointer user_data)
  {
    switch(event->keyval)
     {
      case GDK_KEY_r:
               g_print("Key pressed\n");
                 parse_alaram_file();
                break;
      case GDK_KEY_s:
              libvlc_media_player_pause(mp);
              break;
      }
  return FALSE;
  }

void Load_picture(GtkWidget *widget, gpointer data)
{
  GtkWidget *dialog;
    if (play_video==1) {
      dialog = gtk_file_chooser_dialog_new("Choose Video", GTK_WINDOW(data), GTK_FILE_CHOOSER_ACTION_OPEN, "Cancel",GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
          char *uri;
          uri = gtk_file_chooser_get_uri(GTK_FILE_CHOOSER(dialog));
    load_video_file(uri,1);
            }
        }
      else {
            if (play_video==0) {
     dialog = gtk_file_chooser_dialog_new("Choose Photo Folder",GTK_WINDOW(data), GTK_FILE_CHOOSER_ACTION_SELECT_FOLDER,"Cancel",GTK_RESPONSE_CANCEL, "Open", GTK_RESPONSE_ACCEPT, NULL);
      if(gtk_dialog_run(GTK_DIALOG(dialog)) == GTK_RESPONSE_ACCEPT) {
         char *uri;
          uri = gtk_file_chooser_get_current_folder(GTK_FILE_CHOOSER(dialog));
          load_image_file(uri);
           }
       }
    }
 gtk_widget_destroy(GTK_WIDGET(dialog));
 }

void load_image_file(char *uri) 
{
    if (img_fp!=NULL) fclose(img_fp);
    FILE *fp;
    fp = fopen("/tmp/jpglist.lst","w"); if (fp == NULL) return;
    listdir(uri, sizeof uri, fp);
    fclose(fp);
    img_fp = fopen("/tmp/jpglist.lst","r"); if (img_fp == NULL) return;
    fresh_load='Y';
}


void load_video_file(char *uri, int v)
 {
//     libvlc_media_t *m;
/*     if (v != 1) {
        if (!check_file_exist(uri))
             printf("Video file doesnt exist\n");
             return; } */
         strcpy(v_file,uri);
         pos=0.0; if (play_video==0) change_video_photo('P');
     if(libvlc_media_player_is_playing(mp)==1){
           libvlc_media_player_pause(mp);
            libvlc_media_player_stop(mp);
           }
/*         m = libvlc_media_new_location (inst, uri);
         libvlc_media_player_set_media(mp, m);
         libvlc_audio_set_volume(mp,60);
         libvlc_media_add_option(m,"input-repeat=65535");
         libvlc_media_player_play (mp);
         libvlc_media_release (m); */
 }

int check_file_exist(char *fname)
{
 char f_name[150];
 int i,j;
printf("fname %s\n",fname);
 for (i=7,j=0;i<strlen(fname);i++,j++)
    f_name[j] = fname[i];
 fname[j]='\0';
 if(!access(fname,F_OK))
    return 1;
 else
    return 0;
}


void media_config(GtkWidget *widget, gpointer gdata)
{
  parse_alaram_file();
  parse_startup_file();
}

int main(int argc, char *argv[])
{
  GtkWidget *window;
  GtkWidget *dt_label,*setalaram,*editalaram,*taskbutton,*exitbutton,*volp,*volm,*mute,*mc;
  GtkWidget *fixed,*photo;
   signal(SIGTERM,term);
   gtk_init(&argc, &argv);
 FILE *fp,*fp_img;
 char uri[1024];
    strcpy(uri,"/home/pi/wp");
    fp_img = fopen("/tmp/jpglist.lst","w"); if (fp_img == NULL) return 0;
    listdir(uri, sizeof uri, fp_img);
    fclose(fp_img);
    img_fp = fopen("/tmp/jpglist.lst","r"); if (img_fp == NULL) return 0;

    fp = fopen("/home/pi/gtk_prg/hello_vp_data_file.bin","rb");
  if(fp !=0) {
         if(fread(alaram_data,sizeof(alaram_data),1,fp) !=1)
           printf("alaram data read failed\n");
          if(fread(task_data,sizeof(task_data),1,fp) !=1)
           printf("task data read failed\n"); 
          if(fread(startup_data,sizeof(startup_data),1,fp) !=1)
           printf("startup data read failed\n"); 
          if(fread(&act_alaram,sizeof(act_alaram),1,fp) !=1)
           printf("alaram data read failed\n"); 
          if(fread(&act_task,sizeof(act_task),1,fp) !=1)
           printf("task data read failed\n"); 
          if(fread(&act_startup,sizeof(act_startup),1,fp) !=1)
           printf("startup data read failed\n"); 
    fclose(fp);
             } 
    GtkCssProvider* Provider = gtk_css_provider_new();
    GdkDisplay* Display = gdk_display_get_default();
    GdkScreen* Screen = gdk_display_get_default_screen(Display);
    gtk_style_context_add_provider_for_screen(Screen, GTK_STYLE_PROVIDER(Provider), GTK_STYLE_PROVIDER_PRIORITY_USER);
    gtk_css_provider_load_from_path(GTK_CSS_PROVIDER(Provider), "/home/pi/gtk_prg/Style_new.css", NULL);
window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
g_signal_connect(window, "delete-event", G_CALLBACK(delete_event), NULL);
g_signal_connect(window, "destroy", G_CALLBACK(destroy), NULL);
g_signal_connect(window, "key_press_event", G_CALLBACK (on_key_press), NULL);
gtk_container_set_border_width(GTK_CONTAINER(window), 10);
gtk_window_set_title (GTK_WINDOW(window),"Smart Clock");
player_widget = gtk_drawing_area_new(); //For VLC
img=gtk_image_new();
setalaram = gtk_button_new_with_label("Set _Tone");
gtk_button_set_use_underline(GTK_BUTTON(setalaram),TRUE);
editalaram = gtk_button_new_with_label("Set _Alaram");
gtk_button_set_use_underline(GTK_BUTTON(editalaram),TRUE);
taskbutton = gtk_button_new_with_label("Set Tas_k");
gtk_button_set_use_underline(GTK_BUTTON(taskbutton),TRUE);
exitbutton = gtk_button_new_with_label("E_xit");
...

This file has been truncated, please download it to see its full contents.

Style sheet

CSS
CSS file
.window {
   background: black;
   border-radius: 15px;
}
.player_widget {
   background-color: black;
   border-radius: 15px;
}
.dt_label{
    color: white;
    font-family: DejaVu Serif;
    font-style: italic;
    font-weight: bold;
    font-size: 50px;
    padding: 10px 10px 10px 10px;
}
.wlabel{
    color: white;
    font-family: DejaVu Serif;
    font-style: italic;
    font-weight: normal;
    font-size: 20px;
    padding: 10px 10px 10px 10px;
}
.button_d {
    color: white;
    font-family: DejaVu Serif;
    font-style: italic;
    font-weight: bold;
    font-size: 30px;
    padding: 10px 10px 10px 10px;
}
.info_text {
    font-style: italic;
    font-weight: bold;
    font-size: 12px;
    padding: 10px 10px 10px 10px;
    background: rgba(100, 100, 100, 1);
    color: white;
}
.setalaram {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.setalaram:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.editalaram {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.editalaram:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.alaram_stop {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.alaram_stop:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.taskbutton {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.taskbutton:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.exitbutton {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.exitbutton:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}

.volp {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.volp:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}

.volm {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.volm:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.photo {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.photo:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.mute {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.mute:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.mc {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.mc:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.headline {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.headline:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}
.vp {
    border-radius: 12px;
    color: yellow;
    background: black;
}
.vp:hover {
    border-radius: 12px;
    color: white;
    background: blue;
}

Credits

Srikanth Mani
2 projects • 1 follower
Contact

Comments

Please log in or sign up to comment.