#include <gtk/gtksignal.h>

 #include <gdk/gdkevents.h>

 #include <gdk/gdkkeysyms.h>

 #include "mmyth_uicommon.h"

 #include "mmyth_epg_grid_widget.h"

 #include <gmyth/gmyth_util.h>

 #include <gmyth/gmyth_epg.h>

 #define PIXELS_HOUR 105

 #define PROGRAM_SEPARATION 2

 enum {

     SELECTION_UPDATED_SIGNAL,

     LAST_SIGNAL

 };

 struct _MMythEpgGridWidgetPrivate {

     /*

      * private widget components 

      */

     GtkWidget      *epg_channels_vbox;

     GtkWidget      *epg_programs_vbox;

     GHashTable     *service_model_hash;

     /*

      * guidegrid attributes 

      */

     gboolean        show_favorites;

     gint            current_start_channel_id;

     GTimeVal       *current_start_time;

     GTimeVal       *current_end_time;

     guint           selected_channel_index;

     /*

      * GList of ProgramInfo for each Channel 

      */

     GList          *program_list[MAX_DISPLAY_CHANS];

     GList          *channel_list;

     GMythEPG       *mmyth_epg;

     GMythBackendInfo *backend_info;

     gint            DISPLAY_CHANS;

 };

 static void     mmyth_epg_grid_widget_class_init(MMythEpgGridWidgetClass *

                                                  klass);

 static void     mmyth_epg_grid_widget_init(MMythEpgGridWidget * object);

 static void    

 mmyth_epg_grid_widget_private_init(MMythEpgGridWidgetPrivate * private);

 static void     mmyth_epg_grid_widget_mount_services(MMythEpgGridWidget *

                                                      object,

                                                      GTimeVal * start_time,

                                                      GTimeVal * end_time);

 static void     mmyth_epg_grid_widget_mount_header(MMythEpgGridWidget *

                                                    object);

 static void     mmyth_epg_grid_widget_clicked(GtkWidget * widget,

                                               GdkEventExpose * event,

                                               gpointer data);

 static GtkWidget *create_event_box_lbl(gchar * str, int width,

                                        const GdkColor * bg_color,

                                        const GdkColor * fg_color);

 static void    

 mmyth_epg_grid_widget_fill_programinfos(MMythEpgGridWidgetPrivate *

                                         private);

 static void    

 mmyth_epg_grid_widget_fill_program_row_infos(MMythEpgGridWidgetPrivate *

                                              private, unsigned int chanNum,

                                              unsigned int row);

 static gint     mmyth_epg_grid_widget_signals[LAST_SIGNAL] = { 0 };

 G_DEFINE_TYPE(MMythEpgGridWidget, mmyth_epg_grid_widget,

               GTK_TYPE_EVENT_BOX)

     static void

           mmyth_epg_grid_widget_class_init(MMythEpgGridWidgetClass * klass)

 {

     g_type_class_add_private(klass, sizeof(MMythEpgGridWidgetPrivate));

     mmyth_epg_grid_widget_signals[SELECTION_UPDATED_SIGNAL] =

         g_signal_new("selection_updated", G_TYPE_FROM_CLASS(klass),

                      G_SIGNAL_RUN_FIRST, 0, NULL, NULL,

                      g_cclosure_marshal_VOID__POINTER, G_TYPE_NONE, 1,

                      G_TYPE_POINTER);

 }

 static void

 mmyth_epg_grid_widget_private_init(MMythEpgGridWidgetPrivate * private)

 {

     time_t          cur_time;

     g_return_if_fail(private != NULL);

     private->epg_channels_vbox = NULL;

     private->epg_programs_vbox = NULL;

     private->service_model_hash = NULL;

     private->show_favorites = FALSE;

     private->current_start_channel_id = -1;

     /*

      * Selected the first diplayable channel initially 

      */

     private->selected_channel_index = 0;

     /*

      * TODO fix the current start/end time 

      */

     private->current_start_time = g_new0(GTimeVal, 1);

     private->current_start_time->tv_sec = time(&cur_time);

     private->current_end_time = g_new0(GTimeVal, 1);

     private->current_end_time->tv_sec = time(&cur_time) + 10800;

     private->DISPLAY_CHANS = MAX_DISPLAY_CHANS;

     private->backend_info =

         gmyth_backend_info_new_full("localhost", "mythtv", "mythtv",

                                     "mythconverg", 6543);

     // TODO: Close the epg and unref it in dispose call

     private->mmyth_epg = gmyth_epg_new();

     if (!gmyth_epg_connect(private->mmyth_epg, private->backend_info)) {

         g_warning("[%s] Could not connect mysql handler to db",

                   __FUNCTION__);

         g_object_unref(private->mmyth_epg);

         private->mmyth_epg = NULL;

     }

 }

 static void

 mmyth_epg_grid_widget_init(MMythEpgGridWidget * mmyth_epg_grid_widget)

 {

     MMythEpgGridWidgetPrivate *private =

         MMYTH_EPG_GRID_WIDGET_GET_PRIVATE(mmyth_epg_grid_widget);

     /*

      * init private fields 

      */

     mmyth_epg_grid_widget_private_init(private);

     mmyth_epg_grid_widget->epg_view_model = NULL;

     mmyth_epg_grid_widget->selected_grid_item = NULL;

     GtkWidget      *epg_event_box = GTK_WIDGET(mmyth_epg_grid_widget);

     gtk_widget_modify_bg(epg_event_box, GTK_STATE_NORMAL, &main_bg_color);

     gtk_widget_set_size_request(epg_event_box, 0, 125);

     GtkWidget      *epg_main_hbox = gtk_hbox_new(FALSE, 10);

     gtk_container_set_border_width(GTK_CONTAINER(epg_main_hbox), 10);

     gtk_container_add(GTK_CONTAINER(epg_event_box), epg_main_hbox);

     /*

      * channels vbox 

      */

     GtkWidget      *epg_channels_vbox = gtk_vbox_new(FALSE, 3);

     private->epg_channels_vbox = epg_channels_vbox;

     /*

      * programs vbox 

      */

     GtkWidget      *epg_programs_vbox = gtk_vbox_new(FALSE, 3);

     private->epg_programs_vbox = epg_programs_vbox;

     /*

      * packing start 

      */

     gtk_box_pack_start(GTK_BOX(epg_main_hbox),

                        epg_channels_vbox, FALSE, FALSE, 0);

     gtk_box_pack_start(GTK_BOX(epg_main_hbox),

                        epg_programs_vbox, FALSE, FALSE, 0);

     /*

      * table header (first line) 

      */

     mmyth_epg_grid_widget_mount_header(mmyth_epg_grid_widget);

     /*

      * service programs 

      */

     /*

      * mount service programs with current time 

      */

     mmyth_epg_grid_widget_mount_services(mmyth_epg_grid_widget,

                                          private->current_start_time,

                                          private->current_end_time);

 }

 GtkWidget      *

 mmyth_epg_grid_widget_new()

 {

     return GTK_WIDGET(gtk_type_new(mmyth_epg_grid_widget_get_type()));

 }

 static void

 mmyth_epg_grid_widget_mount_services(MMythEpgGridWidget *

                                      mmyth_epg_grid_widget,

                                      GTimeVal * start_time,

                                      GTimeVal * end_time)

 {

     GList          *proglist;

     GList          *channel_list = NULL;

     GMythChannelInfo *channel_info;

     int             chanid;

     MMythEpgGridWidgetPrivate *private =

         MMYTH_EPG_GRID_WIDGET_GET_PRIVATE(mmyth_epg_grid_widget);

     // update view_model

     /*

      * FIXME shallow free or recursive? 

      */

     if (mmyth_epg_grid_widget->epg_view_model != NULL) {

         g_list_free(mmyth_epg_grid_widget->epg_view_model);

         mmyth_epg_grid_widget->epg_view_model = NULL;

     }

     if (private->service_model_hash != NULL) {

         g_hash_table_destroy(private->service_model_hash);

     }

     private->service_model_hash = g_hash_table_new(NULL, NULL);

     /*

      * fill program infos from db 

      */

     mmyth_epg_grid_widget_fill_programinfos(private);

     channel_list = private->channel_list;

     /*

      * for each channel get_programs() 

      */

     for (chanid = 0; channel_list &&

          chanid < private->DISPLAY_CHANS; chanid++) {

         proglist = (GList *) private->program_list[chanid];

         channel_info = (GMythChannelInfo *) channel_list->data;

         channel_list = g_list_next(channel_list);

         /*

          * Service Title

          */

         GString        *name = NULL;

         if (channel_info->channel_name)

             name = g_string_new(channel_info->channel_name->str);

         GdkColor        title_bg_color;

         title_bg_color.red = 5000;

         title_bg_color.green = 9000;

         title_bg_color.blue = 40000;

         GdkColor        title_fg_color;

         title_fg_color.red = 60000;

         title_fg_color.green = 60000;

         title_fg_color.blue = 60000;

         GtkWidget      *event_box_channel =

             create_event_box_lbl(name->str, 90,

                                  &title_bg_color,

                                  &title_fg_color);

         gtk_box_pack_start(GTK_BOX(private->epg_channels_vbox),

                            event_box_channel, FALSE, FALSE, 0);

         GtkWidget      *epg_line_hbox = gtk_hbox_new(FALSE, 0);

         GdkColor        bg_color;

         bg_color.red = 5000;

         bg_color.green = 30000;

         bg_color.blue = 60000;

         GdkColor        fg_color;

         fg_color.red = 60000;

         fg_color.green = 60000;

         fg_color.blue = 60000;

         /*

          * Content parsing 

          */

         GList          *epg_grid_list = NULL;

         GMythProgramInfo *proginfo;

         int             pixel_count = 0;

         for (; proglist; proglist = proglist->next) {

             proginfo = (GMythProgramInfo *) proglist->data;

             GString        *content_name = proginfo->title;

             GTimeVal       *initial_time = g_new0(GTimeVal, 1);

             GTimeVal       *last_time = g_new0(GTimeVal, 1);

             GTimeVal       *duration = g_new0(GTimeVal, 1);

             GTimeVal       *schedule_start_time = proginfo->startts;

             GTimeVal       *schedule_end_time = proginfo->endts;

             initial_time->tv_sec =

                 (schedule_start_time->tv_sec <

                  start_time->tv_sec) ? start_time->

                 tv_sec : schedule_start_time->tv_sec;

             last_time->tv_sec =

                 (schedule_end_time->tv_sec >

                  end_time->tv_sec) ? end_time->tv_sec : schedule_end_time->

                 tv_sec;

             duration->tv_sec = last_time->tv_sec - initial_time->tv_sec;

             // Verify program time 

 #if 0

             g_debug("ServiceID: %d, ScheduleID: %d\n", service->id,

                     schedule->id);

             fprintf(stderr, "program time\nfrom = %d, to = %d\n",

                     schedule->validFrom, schedule->validTo);

             struct tm       loctime;

             /*

              * Convert it to local time representation. 

              */

             if (localtime_r((time_t *) & schedule->validFrom, &loctime) ==

                 NULL) {

                 g_warning("localtime_r error in mmyth_epg_grid_widget!\n");

                 return NULL;

             }

             fprintf(stderr, asctime(&loctime));

             if (localtime_r((time_t *) & schedule->validTo, &loctime) ==

                 NULL) {

                 g_warning("localtime_r error in mmyth_epg_grid_widget!\n");

                 return NULL;

             }

             fprintf(stderr, asctime(&loctime));

 #endif

             /*

              * fprintf(stderr, "duration = %d\n", duration); 

              */

             double          duration_hour =

                 duration->tv_sec / (double) 3600.0;

             /*

              * fprintf(stderr, "duration_hour = %lf\n", duration_hour); 

              */

             int             size = PIXELS_HOUR * duration_hour;

             /*

              * complete hour 

              */

             /*

              * FIXME: UGLY WRONG HACK TO ALIGN PROGRAM TIME!!!

              */

             if (last_time->tv_sec % 3600 != 0) {

                 size -= PROGRAM_SEPARATION;

             }

             if (initial_time->tv_sec % 3600 != 0) {

                 size -= PROGRAM_SEPARATION;

             }

             pixel_count += size + PROGRAM_SEPARATION;

             GtkWidget      *event_box =

                 create_event_box_lbl(content_name->str,

                                      size, &bg_color,

                                      &fg_color);

             gtk_widget_add_events(event_box,

                                   GDK_BUTTON_PRESS_MASK |

                                   GDK_BUTTON_RELEASE_MASK);

             /*

              * create EpgGridItem 

              */

             EpgGridItem    *epg_grid_item = g_new0(EpgGridItem, 1);

             epg_grid_item->proginfo = proginfo;

             epg_grid_item->event_box = event_box;

             epg_grid_item->object = mmyth_epg_grid_widget;

             epg_grid_list =

                 g_list_prepend(epg_grid_list, (gpointer) epg_grid_item);

             gtk_box_pack_start(GTK_BOX(epg_line_hbox),

                                event_box, FALSE, FALSE,

                                PROGRAM_SEPARATION);

             g_signal_connect(G_OBJECT(event_box), "button-press-event",

                              G_CALLBACK(mmyth_epg_grid_widget_clicked),

                              (gpointer *) epg_grid_list);

         }

 #if 0

         printf("chaind = %d!!!!" chanid);

         fflush(stdout);

 #endif

         if (!epg_grid_list) {

             /*

              * No programs for current channel 

              */

             /*

              * FIXME: size HARDCODED 

              */

             GtkWidget      *event_box =

                 create_event_box_lbl("No program list available",

                                      PIXELS_HOUR * 3, &bg_color,

                                      &fg_color);

             gtk_widget_add_events(event_box,

                                   GDK_BUTTON_PRESS_MASK |

                                   GDK_BUTTON_RELEASE_MASK);

             /*

              * create EpgGridItem 

              */

             EpgGridItem    *epg_grid_item = g_new0(EpgGridItem, 1);

             epg_grid_item->proginfo = NULL;

             epg_grid_item->event_box = event_box;

             epg_grid_item->object = mmyth_epg_grid_widget;

             epg_grid_list =

                 g_list_prepend(epg_grid_list, (gpointer) epg_grid_item);

             gtk_box_pack_start(GTK_BOX(epg_line_hbox),

                                event_box, FALSE, FALSE,

                                PROGRAM_SEPARATION);

             g_signal_connect(G_OBJECT(event_box), "button-press-event",

                              G_CALLBACK(mmyth_epg_grid_widget_clicked),

                              (gpointer *) epg_grid_list);

         }

         epg_grid_list = g_list_reverse(epg_grid_list);

         mmyth_epg_grid_widget->epg_view_model =

             g_list_append(mmyth_epg_grid_widget->epg_view_model,

                           epg_grid_list);

         gtk_box_pack_start(GTK_BOX(private->epg_programs_vbox),

                            epg_line_hbox, FALSE, FALSE, 0);

     }

 }

 static void

 mmyth_epg_grid_widget_mount_header(MMythEpgGridWidget *

                                    mmyth_epg_grid_widget)

 {

     MMythEpgGridWidgetPrivate *private =

         MMYTH_EPG_GRID_WIDGET_GET_PRIVATE(mmyth_epg_grid_widget);

     struct tm       hour_tm;

     const gchar     name_title[] = "Today";

     GtkWidget      *lbl_title = gtk_label_new(name_title);

     gtk_misc_set_alignment(GTK_MISC(lbl_title), 0.0, 0.5);

     gtk_box_pack_start(GTK_BOX(private->epg_channels_vbox),

                        lbl_title, FALSE, FALSE, 0);

     /*

      * hours title line 

      */

     GtkWidget      *epg_programs_hours_hbox = gtk_hbox_new(TRUE, 0);

     if (localtime_r

         ((time_t *) & private->current_start_time->tv_sec,

          &hour_tm) == NULL) {

         g_warning("localtime_r error in mmyth_epg_grid_widget!\n");

         return;

     }

     if (hour_tm.tm_min > 30) {

         hour_tm.tm_min = 30;

     } else if (hour_tm.tm_min > 0) {

         hour_tm.tm_min = 0;

     }

     gchar           hour1_str[10];

     strftime(hour1_str, 8, "%H:%M", &hour_tm);

     GtkWidget      *lbl_hour1 = gtk_label_new(hour1_str);

     gtk_misc_set_alignment(GTK_MISC(lbl_hour1), 0.0, 0.5);

     hour_tm.tm_hour++;

     gchar           hour2_str[10];

     strftime(hour2_str, 8, "%H:%M", &hour_tm);

     GtkWidget      *lbl_hour2 = gtk_label_new(hour2_str);

     gtk_misc_set_alignment(GTK_MISC(lbl_hour2), 0.0, 0.5);

     hour_tm.tm_hour++;

     gchar           hour3_str[10];

     strftime(hour3_str, 8, "%H:%M", &hour_tm);

     GtkWidget      *lbl_hour3 = gtk_label_new(hour3_str);

     gtk_misc_set_alignment(GTK_MISC(lbl_hour3), 0.0, 0.5);

     gtk_box_pack_start(GTK_BOX(epg_programs_hours_hbox),

                        lbl_hour1, TRUE, TRUE, 0);

     gtk_box_pack_start(GTK_BOX(epg_programs_hours_hbox),

                        lbl_hour2, TRUE, TRUE, 0);

     gtk_box_pack_start(GTK_BOX(epg_programs_hours_hbox),

                        lbl_hour3, TRUE, TRUE, 0);

     gtk_box_pack_start(GTK_BOX(private->epg_programs_vbox),

                        epg_programs_hours_hbox, FALSE, FALSE, 0);

 }

 /******************************************************************************

  *              INTERNAL CALLBACKS FOR STATE CHANGE                           *

  *****************************************************************************/

 static void

 mmyth_epg_grid_widget_deselect_service(MMythEpgGridWidget *

                                        mmyth_epg_grid_widget)

 {

     EpgGridItem    *epg_grid_item;

     /*

      * deselect

      */

     if (mmyth_epg_grid_widget->selected_grid_item != NULL) {

         epg_grid_item =

             (EpgGridItem *) mmyth_epg_grid_widget->selected_grid_item->

             data;

         gtk_widget_set_state(GTK_WIDGET(epg_grid_item->event_box),

                              GTK_STATE_NORMAL);

     }

 }

 static void

 mmyth_epg_grid_widget_clicked(GtkWidget * widget,

                               GdkEventExpose * event, gpointer data)

 {

     g_return_if_fail(data != NULL);

     GList          *epg_grid_item_list = (GList *) data;

     EpgGridItem    *epg_grid_item =

         (EpgGridItem *) epg_grid_item_list->data;

     /*

      * update the selected service 

      */

     mmyth_epg_grid_widget_update_service(epg_grid_item->object,

                                          (GList *) data);

 }

 void

 mmyth_epg_grid_widget_update_service(MMythEpgGridWidget * object,

                                      GList * selected_grid_list)

 {

     g_return_if_fail(object != NULL);

     g_return_if_fail(selected_grid_list != NULL);

     EpgGridItem    *epg_grid_item =

         (EpgGridItem *) selected_grid_list->data;

     mmyth_epg_grid_widget_deselect_service(epg_grid_item->object);

     /*

      * updating current selected schedule_item and schedule_list

      */

     object->selected_grid_item = selected_grid_list;

     /*

      * set state of the event box 

      */

     gtk_widget_set_state(GTK_WIDGET(epg_grid_item->event_box),

                          GTK_STATE_SELECTED);

     /*

      * emit update signal for listeners 

      */

     g_signal_emit(object,

                   mmyth_epg_grid_widget_signals[SELECTION_UPDATED_SIGNAL],

                   0, (gpointer) epg_grid_item);

 }

 static GtkWidget *

 create_event_box_lbl(gchar * str, int width, const GdkColor * bg_color,

                      const GdkColor * fg_color)

 {

     GtkWidget      *event_box = gtk_event_box_new();

     GtkWidget      *lbl = gtk_label_new(str);

     gtk_label_set_ellipsize(GTK_LABEL(lbl), PANGO_ELLIPSIZE_END);

     gtk_widget_modify_bg(event_box, GTK_STATE_NORMAL, bg_color);

     gtk_widget_modify_fg(lbl, GTK_STATE_NORMAL, fg_color);

     /*

      * selected colors are const

      */

     GdkColor        selected_bg_color;

     selected_bg_color.red = 100;

     selected_bg_color.green = 40000;

     selected_bg_color.blue = 100;

     GdkColor        selected_fg_color;

     selected_fg_color.red = 100;

     selected_fg_color.green = 100;

     selected_fg_color.blue = 100;

     gtk_widget_modify_bg(event_box, GTK_STATE_SELECTED,

                          &selected_bg_color);

     gtk_widget_modify_fg(lbl, GTK_STATE_SELECTED, &selected_fg_color);

     gtk_misc_set_alignment(GTK_MISC(lbl), 0.0, 0.5);

     gtk_container_add(GTK_CONTAINER(event_box), lbl);

     gtk_widget_set_size_request(event_box, width, -1);

     return event_box;

 }

 /******************************************************************************

  *                            METHODS                                         *

  *****************************************************************************/

 /*

  * Callback for hardware keys 

  */

 gboolean

 mmyth_epg_grid_widget_key_press(MMythEpgGridWidget * object,

                                 GtkWidget * widget, GdkEventKey * event)

 {

     MMythEpgGridWidgetPrivate *private =

         MMYTH_EPG_GRID_WIDGET_GET_PRIVATE(object);

     EpgGridItem    *epg_grid_item;

     GList          *tmp;

     /*

      * List of selected_grid_item 

      */

     GList          *selected_view_model;

     gint            channel_index;

     if (object->selected_grid_item == NULL) {

         g_warning("No program selected");

         return FALSE;

     }

     epg_grid_item = (EpgGridItem *) object->selected_grid_item->data;

     channel_index = private->selected_channel_index;

     switch (event->keyval) {

     case GDK_Up:

         selected_view_model =

             g_list_nth(object->epg_view_model, channel_index - 1);

         if (selected_view_model != NULL) {

             private->selected_channel_index = channel_index - 1;

             tmp = (GList *) selected_view_model->data;

             /*

              * TODO: select a better centralized item currently is

              * picking the 1st or last item 

              */

             if (g_list_next(object->selected_grid_item) == NULL &&

                 g_list_previous(object->selected_grid_item) != NULL) {

                 /*

                  * in this case the new selected will be the last 

                  */

                 tmp = g_list_last(tmp);

             }

             /*

              * update the selected service 

              */

             mmyth_epg_grid_widget_update_service(object, tmp);

         }

         return TRUE;

     case GDK_Down:

         selected_view_model =

             g_list_nth(object->epg_view_model, channel_index + 1);

         if (selected_view_model != NULL) {

             private->selected_channel_index = channel_index + 1;

             tmp = (GList *) selected_view_model->data;

             /*

              * TODO: select a better centralized item currently is

              * picking the 1st or last item 

              */

             if (g_list_next(object->selected_grid_item) == NULL &&

                 g_list_previous(object->selected_grid_item) != NULL) {

                 /*

                  * in this case the new selected will be the last 

                  */

                 tmp = g_list_last(tmp);

             }

             /*

              * update the selected service 

              */

             mmyth_epg_grid_widget_update_service(object, tmp);

         }

         return TRUE;

     case GDK_Left:

         tmp = g_list_previous(object->selected_grid_item);

         if (tmp != NULL) {

             /*

              * update the selected service 

              */

             mmyth_epg_grid_widget_update_service(object, tmp);

         }

         return TRUE;

     case GDK_Right:

         tmp = g_list_next(object->selected_grid_item);

         if (tmp != NULL) {

             /*

              * update the selected service 

              */

             mmyth_epg_grid_widget_update_service(object, tmp);

         }

         return TRUE;

     default:

         return TRUE;

     }

     return FALSE;

 }

 static void

 mmyth_epg_grid_widget_fill_programinfos(MMythEpgGridWidgetPrivate *

                                         private)

 {

     GList          *channels_list = NULL;

     int             y;

     if ((private->mmyth_epg != NULL) &&

         (gmyth_epg_get_channel_list(private->mmyth_epg, &channels_list) <

          0)) {

         private->channel_list = NULL;

         return;

     }

     private->channel_list = channels_list;

     for (y = 0; y < private->DISPLAY_CHANS && channels_list; y++) {

         GMythChannelInfo *channel_info =

             (GMythChannelInfo *) channels_list->data;

         mmyth_epg_grid_widget_fill_program_row_infos(private,

                                                      channel_info->

                                                      channel_ID, y);

         channels_list = g_list_next(channels_list);

     }

 }

 static void

 mmyth_epg_grid_widget_fill_program_row_infos(MMythEpgGridWidgetPrivate *

                                              private, guint chanNum,

                                              guint row)

 {

     gint            res = gmyth_epg_get_program_list(private->mmyth_epg,

                                                      &(private->

                                                        program_list[row]),

                                                      chanNum,

                                                      private->

                                                      current_start_time,

                                                      private->

                                                      current_end_time);

     if (res < 0) {

         g_warning("[%s] Error while retrieving epg programs",

                   __FUNCTION__);

     }

 }