xgnokii/xgnokii_calendar.c

   1 /*
   2
   3   X G N O K I I
   4
   5   A Linux/Unix GUI for Nokia mobile phones.
   6
   7   Released under the terms of the GNU GPL, see file COPYING for more details.
   8
   9 */
  10
  11 #include <time.h>
  12 #include <string.h>
  13 #include <gtk/gtk.h>
  14 #include "misc.h"
  15 #include "xgnokii_common.h"
  16 #include "xgnokii.h"
  17 #include "xgnokii_lowlevel.h"
  18 #include "xgnokii_calendar.h"
  19 #include "xpm/Read.xpm"
  20 #include "xpm/Send.xpm"
  21 #include "xpm/Open.xpm"
  22 #include "xpm/Save.xpm"
  23 #include "xpm/Edit.xpm"
  24 #include "xpm/Delete.xpm"
  25 #include "xpm/SendSMS.xpm"
  26 #include "xpm/NewBD.xpm"
  27 #include "xpm/NewCall.xpm"
  28 #include "xpm/NewMeet.xpm"
  29 #include "xpm/NewRem.xpm"
  30 #include "xpm/quest.xpm"
  31
  32
  33 typedef struct {
  34   GtkWidget *calendar;
  35   GtkWidget *notesClist;
  36   GtkWidget *noteText;
  37   GdkColor   colour;
  38 } CalendarWidget;
  39
  40
  41 typedef struct {
  42   guint year;
  43   guint month;
  44   guint day;
  45   GtkWidget *button;
  46 } Date;
  47
  48
  49 typedef struct {
  50   Date date;
  51   guchar hours;
  52   guchar minutes;
  53   GtkWidget *button;
  54   GtkWidget *hButton;
  55   GtkWidget *mButton;
  56 } DateTime;
  57
  58
  59 typedef struct {
  60   GtkWidget *dialog;
  61   Date       date;
  62   DateTime   alarm;
  63   GtkWidget *alarmCheck;
  64   GtkWidget *text;
  65 } AddDialogData;
  66
  67 typedef struct {
  68   GtkWidget *dialog;
  69   DateTime   date;
  70   DateTime   alarm;
  71   GtkWidget *alarmCheck;
  72   GtkWidget *text;
  73 } AddDialogData2;
  74
  75
  76 typedef struct {
  77   GtkWidget *dialog;
  78   GtkWidget *cal;
  79 } CalendarDialog;
  80
  81
  82 typedef struct {
  83   GtkWidget *dialog;
  84   GtkWidget *cal;
  85 } CalTimeDialog;
  86
  87
  88 static GtkWidget *GUI_CalendarWindow;
  89 static ErrorDialog errorDialog = {NULL, NULL};
  90 static CalendarWidget cal = {NULL, NULL};
  91 static QuestMark questMark;
  92 static AddDialogData addReminderDialogData;
  93 static AddDialogData2 addCallDialogData;
  94 static AddDialogData2 addMeetingDialogData;
  95 static AddDialogData addBirthdayDialogData;
  96 static CalendarDialog calendarDialog = {NULL, NULL};
  97 static CalTimeDialog calTimeDialog = {NULL, NULL};
  98
  99 static inline void Help1 (GtkWidget *w, gpointer data)
 100 {
 101   gchar *indx = g_strdup_printf ("/help/%s/windows/calendar/index.html", xgnokiiConfig.locale);
 102   Help (w, indx);
 103   g_free (indx);
 104 }
 105
 106
 107 static inline void CloseCalendar (GtkWidget *w, gpointer data)
 108 {
 109   gtk_widget_hide (GUI_CalendarWindow);
 110 }
 111
 112
 113 inline void GUI_ShowCalendar ()
 114 {
 115   if (GetModelFeature(FN_CALENDAR)!=0)
 116     gtk_widget_show (GUI_CalendarWindow);
 117 }
 118
 119
 120 static gint InsertCalendarEntry (GSM_CalendarNote *note)
 121 {
 122   gchar *row[6];
 123
 124   row[0] = g_strdup_printf ("%d", note->Location);
 125
 126   switch (note->Type)
 127   {
 128     case GCN_REMINDER:
 129         row[1] = _("Reminder");
 130         row[2] = g_strdup_printf ("%02d/%02d/%04d", note->Time.Day,
 131                                   note->Time.Month, note->Time.Year);
 132         row[5] = "";
 133         break;
 134
 135     case GCN_CALL:
 136         row[1] = _("Call");
 137         row[2] = g_strdup_printf ("%02d/%02d/%04d  %02d:%02d", note->Time.Day,
 138                                   note->Time.Month, note->Time.Year,
 139                                   note->Time.Hour, note->Time.Minute);
 140         row[5] = note->Phone;
 141         break;
 142
 143     case GCN_MEETING:
 144         row[1] = _("Meeting");
 145         row[2] = g_strdup_printf ("%02d/%02d/%04d  %02d:%02d", note->Time.Day,
 146                                   note->Time.Month, note->Time.Year,
 147                                   note->Time.Hour, note->Time.Minute);
 148         row[5] = "";
 149         break;
 150
 151     case GCN_BIRTHDAY:
 152         row[1] = _("Birthday");
 153         row[2] = g_strdup_printf ("%02d/%02d/%04d", note->Time.Day,
 154                                   note->Time.Month, note->Time.Year);
 155         row[5] = "";
 156         break;
 157
 158     default:
 159         row[1] = _("Unknown");
 160         row[5] = "";
 161         break;
 162   }
 163
 164   row[3] = note->Text;
 165
 166   if (note->Alarm.Year == 0)
 167     row[4] = "";
 168   else
 169     row[4] = g_strdup_printf ("%02d/%02d/%04d  %02d:%02d", note->Alarm.Day,
 170                                note->Alarm.Month, note->Alarm.Year,
 171                                note->Alarm.Hour, note->Alarm.Minute);
 172
 173   gtk_clist_freeze (GTK_CLIST (cal.notesClist));
 174   gtk_clist_append (GTK_CLIST (cal.notesClist), row);
 175   gtk_clist_sort (GTK_CLIST (cal.notesClist));
 176   gtk_clist_thaw (GTK_CLIST (cal.notesClist));
 177
 178   g_free (row[0]);
 179   g_free (row[2]);
 180   if (*row[4] != '\0')
 181     g_free (row[4]);
 182
 183   return (GE_NONE);
 184 }
 185
 186 static void ClickEntry (GtkWidget      *clist,
 187                         gint            row,
 188                         gint            column,
 189                         GdkEventButton *event,
 190                         gpointer        data )
 191 {
 192   gchar *buf;
 193
 194   gtk_text_freeze (GTK_TEXT (cal.noteText));
 195
 196   gtk_text_set_point (GTK_TEXT (cal.noteText), 0);
 197   gtk_text_forward_delete (GTK_TEXT (cal.noteText), gtk_text_get_length (GTK_TEXT (cal.noteText)));
 198
 199   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.colour), NULL,
 200                    _("Type: "), -1);
 201   gtk_clist_get_text (GTK_CLIST (clist), row, 1, &buf);
 202   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 203                    buf, -1);
 204   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 205                    "\n", -1);
 206
 207   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.colour), NULL,
 208                    _("Date: "), -1);
 209   gtk_clist_get_text (GTK_CLIST (clist), row, 2, &buf);
 210   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 211                    buf, -1);
 212   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 213                    "\n", -1);
 214
 215   gtk_calendar_select_month (GTK_CALENDAR (cal.calendar),
 216                              atoi (buf + 3) - 1, atoi (buf + 6));
 217   gtk_calendar_select_day (GTK_CALENDAR (cal.calendar), atoi (buf));
 218
 219   gtk_clist_get_text (GTK_CLIST (clist), row, 4, &buf);
 220   if (*buf != '\0')
 221   {
 222     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.colour), NULL,
 223                      _("Alarm: "), -1);
 224
 225     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 226                      buf, -1);
 227     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 228                      "\n", -1);
 229   }
 230
 231   gtk_clist_get_text (GTK_CLIST (clist), row, 5, &buf);
 232   if (*buf != '\0')
 233   {
 234     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.colour), NULL,
 235                      _("Number: "), -1);
 236
 237     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 238                      buf, -1);
 239     gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 240                      "\n", -1);
 241   }
 242
 243   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.colour), NULL,
 244                    _("Text: "), -1);
 245   gtk_clist_get_text (GTK_CLIST (clist), row, 3, &buf);
 246   gtk_text_insert (GTK_TEXT (cal.noteText), NULL, &(cal.noteText->style->black), NULL,
 247                    buf, -1);
 248
 249   gtk_text_thaw (GTK_TEXT (cal.noteText));
 250 }
 251
 252 static inline gint ReadCalendarFailed (gint i)
 253 {
 254   return (0);
 255 }
 256
 257
 258 static void ReadCalNotes (void)
 259 {
 260   PhoneEvent *e;
 261   D_CalendarNoteAll *cna;
 262
 263   gtk_clist_clear (GTK_CLIST (cal.notesClist));
 264
 265   cna = (D_CalendarNoteAll *) g_malloc (sizeof (D_CalendarNoteAll));
 266   cna->InsertEntry = InsertCalendarEntry;
 267   cna->ReadFailed = ReadCalendarFailed;
 268
 269   e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 270   e->event = Event_GetCalendarNoteAll;
 271   e->data = cna;
 272   GUI_InsertEvent (e);
 273 }
 274
 275
 276 static gint CListCompareFunc (GtkCList *clist, gconstpointer ptr1, gconstpointer ptr2)
 277 {
 278   char *text1 = NULL;
 279   char *text2 = NULL;
 280
 281   GtkCListRow *row1 = (GtkCListRow *) ptr1;
 282   GtkCListRow *row2 = (GtkCListRow *) ptr2;
 283
 284   switch (row1->cell[clist->sort_column].type)
 285   {
 286     case GTK_CELL_TEXT:
 287       text1 = GTK_CELL_TEXT (row1->cell[clist->sort_column])->text;
 288       break;
 289     case GTK_CELL_PIXTEXT:
 290       text1 = GTK_CELL_PIXTEXT (row1->cell[clist->sort_column])->text;
 291       break;
 292     default:
 293       break;
 294   }
 295   switch (row2->cell[clist->sort_column].type)
 296   {
 297     case GTK_CELL_TEXT:
 298       text2 = GTK_CELL_TEXT (row2->cell[clist->sort_column])->text;
 299       break;
 300     case GTK_CELL_PIXTEXT:
 301       text2 = GTK_CELL_PIXTEXT (row2->cell[clist->sort_column])->text;
 302       break;
 303     default:
 304       break;
 305   }
 306
 307   if (!text2)
 308     return (text1 != NULL);
 309
 310   if (!text1)
 311     return -1;
 312
 313   if (*text2 == '\0')
 314     return (*text1 != '\0');
 315
 316   if (*text1 == '\0')
 317     return (-1);
 318
 319   if (clist->sort_column == 0)
 320   {
 321     gint n1 = atoi (text1);
 322     gint n2 = atoi (text2);
 323
 324     if (n1 > n2)
 325       return (1);
 326     else if (n1 < n2)
 327       return (-1);
 328     else
 329       return 0;
 330   }
 331
 332   if (clist->sort_column == 2 || clist->sort_column == 4)
 333   {
 334     GDate *date1, *date2;
 335     gint time1, time2;
 336     gint ret;
 337
 338     date1 = g_date_new_dmy (atoi (text1), atoi (text1 + 3), atoi (text1 + 6));
 339     date2 = g_date_new_dmy (atoi (text2), atoi (text2 + 3), atoi (text2 + 6));
 340
 341     ret = g_date_compare (date1, date2);
 342
 343     g_date_free (date1);
 344     g_date_free (date2);
 345
 346     if (ret)
 347       return (ret);
 348
 349     if (strlen (text1) > 10)
 350       time1 = atoi (text1 + 11) * 60 + atoi (text1 + 14);
 351     else
 352       time1 = 0;
 353
 354     if (strlen (text2) > 10)
 355       time2 = atoi (text2 + 11) * 60 + atoi (text2 + 14);
 356     else
 357       time2 = 0;
 358
 359     if (time1 > time2)
 360       return (1);
 361     else if (time1 < time2)
 362       return (-1);
 363     else
 364       return 0;
 365
 366 /*    struct tm bdTime;
 367     time_t time1, time2;
 368
 369     bdTime.tm_sec  = 0;
 370     if (strlen (text1) > 10)
 371     {
 372       bdTime.tm_min  = atoi (text1 + 14);
 373       bdTime.tm_hour = atoi (text1 + 11);
 374     }
 375     else
 376       bdTime.tm_min  = bdTime.tm_hour = 0;
 377     bdTime.tm_mday = atoi (text1);
 378     bdTime.tm_mon  = atoi (text1 + 3);
 379     bdTime.tm_year = atoi (text1 + 6) - 1900;
 380     bdTime.tm_isdst = -1;
 381
 382     time1 = mktime (&bdTime);
 383
 384     bdTime.tm_sec  = 0;
 385     if (strlen (text2) > 10)
 386     {
 387       bdTime.tm_min  = atoi (text2 + 14);
 388       bdTime.tm_hour = atoi (text2 + 11);
 389     }
 390     else
 391       bdTime.tm_min  = bdTime.tm_hour = 0;
 392     bdTime.tm_mday = atoi (text2);
 393     bdTime.tm_mon  = atoi (text2 + 3);
 394     bdTime.tm_year = atoi (text2 + 6) - 1900;
 395     bdTime.tm_isdst = -1;
 396
 397     time2 = mktime (&bdTime);
 398
 399     g_print ("Cas1: %s - %d, Cas2: %s - %d\n", text1, time1, text2, time2);
 400
 401     if (time1 > time2)
 402       return (1);
 403     else if (time1 < time2)
 404       return (-1);
 405     else
 406       return 0; */
 407   }
 408
 409   return (g_strcasecmp (text1, text2));
 410 }
 411
 412
 413 static gint ReverseSelection (gconstpointer a, gconstpointer b)
 414 {
 415   gchar *buf1, *buf2;
 416   gint index1, index2;
 417   gint row1 = GPOINTER_TO_INT (a);
 418   gint row2 = GPOINTER_TO_INT (b);
 419
 420   gtk_clist_get_text (GTK_CLIST (cal.notesClist), row1, 0, &buf1);
 421   gtk_clist_get_text (GTK_CLIST (cal.notesClist), row2, 0, &buf2);
 422
 423   index1 = atoi (buf1);
 424   index2 = atoi (buf2);
 425
 426   if (index1 < index2)
 427     return (1);
 428   else if (index1 > index2)
 429     return (-1);
 430   else
 431     return (0);
 432 }
 433
 434
 435 static gint AddCalendarNote(GSM_CalendarNote *cnote)
 436 {
 437         GSM_Error error;
 438         PhoneEvent *e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 439         D_CalendarNote *dnote = (D_CalendarNote *)g_malloc(sizeof(D_CalendarNote));
 440
 441         dnote->entry = cnote;
 442         e->event = Event_WriteCalendarNote;
 443         e->data = dnote;
 444         GUI_InsertEvent (e);
 445         pthread_mutex_lock (&calendarMutex);
 446         pthread_cond_wait (&calendarCond, &calendarMutex);
 447         pthread_mutex_unlock (&calendarMutex);
 448
 449 #ifdef XDEBUG
 450         g_print ("Saving calendar note\n");
 451 #endif
 452
 453         error = dnote->status;
 454         g_free (dnote);
 455
 456         if (error != GE_NONE)
 457         {
 458                 gchar *buf = g_strdup_printf (_("Saving failed failed\n(error=%d)"), error);
 459                 gtk_label_set_text (GTK_LABEL(errorDialog.text), buf);
 460                 gtk_widget_show (errorDialog.dialog);
 461                 g_free (buf);
 462         }
 463         else
 464                 g_print ("Note saved\n");
 465
 466         return (error);
 467 }
 468
 469 static void OkAddReminderDialog (GtkWidget *widget, gpointer data)
 470 {
 471         GSM_CalendarNote note;
 472
 473         note.Type = GCN_REMINDER;
 474         note.Location = 0;
 475         strncpy(note.Text, gtk_entry_get_text(GTK_ENTRY(((AddDialogData *)data)->text)), 20);
 476         note.Time.Year = ((AddDialogData *)data)->date.year;
 477         note.Time.Month = ((AddDialogData *)data)->date.month;
 478         note.Time.Day = ((AddDialogData *)data)->date.day;
 479         note.Time.Hour = note.Time.Minute = note.Time.Second = note.Time.Timezone = 0;
 480         if (GTK_TOGGLE_BUTTON(((AddDialogData*) data)->alarmCheck)->active) {
 481                 note.Alarm.Year = ((AddDialogData *)data)->alarm.date.year;
 482                 note.Alarm.Month = ((AddDialogData *)data)->alarm.date.month;
 483                 note.Alarm.Day = ((AddDialogData *)data)->alarm.date.day;
 484                 note.Alarm.Hour = ((AddDialogData *)data)->alarm.hours;
 485                 note.Alarm.Minute = ((AddDialogData *)data)->alarm.minutes;
 486                 note.Alarm.Second = note.Alarm.Timezone = 0;
 487         } else {
 488                 note.Alarm.Year = 0;
 489         }
 490         AddCalendarNote(&note);
 491         gtk_entry_set_text(GTK_ENTRY(((AddDialogData *)data)->text), "");
 492         gtk_widget_hide (((AddDialogData *)data)->dialog);
 493 }
 494
 495 static void OkAddCallDialog (GtkWidget *widget, gpointer data)
 496 {
 497         GSM_CalendarNote note;
 498
 499         note.Type = GCN_CALL;
 500         note.Location = 0;
 501         strncpy(note.Text, gtk_entry_get_text(GTK_ENTRY(((AddDialogData2 *)data)->text)), 20);
 502         note.Time.Year = ((AddDialogData2 *)data)->date.date.year;
 503         note.Time.Month = ((AddDialogData2 *)data)->date.date.month;
 504         note.Time.Day = ((AddDialogData2 *)data)->date.date.day;
 505         note.Time.Hour = ((AddDialogData2 *)data)->date.hours;
 506         note.Time.Minute = ((AddDialogData2 *)data)->date.minutes;
 507         note.Time.Second = note.Time.Timezone = 0;
 508         if (GTK_TOGGLE_BUTTON(((AddDialogData2 *) data)->alarmCheck)->active) {
 509                 note.Alarm.Year = ((AddDialogData2 *)data)->alarm.date.year;
 510                 note.Alarm.Month = ((AddDialogData2 *)data)->alarm.date.month;
 511                 note.Alarm.Day = ((AddDialogData2 *)data)->alarm.date.day;
 512                 note.Alarm.Hour = ((AddDialogData2 *)data)->alarm.hours;
 513                 note.Alarm.Minute = ((AddDialogData2 *)data)->alarm.minutes;
 514                 note.Alarm.Second = note.Alarm.Timezone = 0;
 515         } else {
 516                 note.Alarm.Year = 0;
 517         }
 518         AddCalendarNote(&note);
 519         gtk_entry_set_text(GTK_ENTRY(((AddDialogData2 *)data)->text), "");
 520         gtk_widget_hide (((AddDialogData2 *)data)->dialog);
 521 }
 522
 523 static void OkAddMeetingDialog (GtkWidget *widget, gpointer data)
 524 {
 525         GSM_CalendarNote note;
 526
 527         note.Type = GCN_MEETING;
 528         note.Location = 0;
 529         strncpy(note.Text, gtk_entry_get_text(GTK_ENTRY(((AddDialogData2 *)data)->text)), 20);
 530         note.Time.Year = ((AddDialogData2 *)data)->date.date.year;
 531         note.Time.Month = ((AddDialogData2 *)data)->date.date.month;
 532         note.Time.Day = ((AddDialogData2 *)data)->date.date.day;
 533         note.Time.Hour = ((AddDialogData2 *)data)->date.hours;
 534         note.Time.Minute = ((AddDialogData2 *)data)->date.minutes;
 535         note.Time.Second = note.Time.Timezone = 0;
 536         if (GTK_TOGGLE_BUTTON(((AddDialogData2 *) data)->alarmCheck)->active) {
 537                 note.Alarm.Year = ((AddDialogData2 *)data)->alarm.date.year;
 538                 note.Alarm.Month = ((AddDialogData2 *)data)->alarm.date.month;
 539                 note.Alarm.Day = ((AddDialogData2 *)data)->alarm.date.day;
 540                 note.Alarm.Hour = ((AddDialogData2 *)data)->alarm.hours;
 541                 note.Alarm.Minute = ((AddDialogData2 *)data)->alarm.minutes;
 542                 note.Alarm.Second = note.Alarm.Timezone = 0;
 543         } else {
 544                 note.Alarm.Year = 0;
 545         }
 546         AddCalendarNote(&note);
 547         gtk_entry_set_text(GTK_ENTRY(((AddDialogData2 *)data)->text), "");
 548         gtk_widget_hide (((AddDialogData2 *)data)->dialog);
 549 }
 550
 551 static void OkAddBdayDialog (GtkWidget *widget, gpointer data)
 552 {
 553         GSM_CalendarNote note;
 554
 555         note.Type = GCN_BIRTHDAY;
 556         note.Location = 0;
 557         strncpy(note.Text, gtk_entry_get_text(GTK_ENTRY(((AddDialogData *)data)->text)), 20);
 558         note.Time.Year = ((AddDialogData *)data)->date.year;
 559         note.Time.Month = ((AddDialogData *)data)->date.month;
 560         note.Time.Day = ((AddDialogData *)data)->date.day;
 561         note.Time.Hour = note.Time.Minute = note.Time.Second = note.Time.Timezone = 0;
 562         if (GTK_TOGGLE_BUTTON(((AddDialogData*) data)->alarmCheck)->active) {
 563                 note.Alarm.Year = ((AddDialogData *)data)->alarm.date.year;
 564                 note.Alarm.Month = ((AddDialogData *)data)->alarm.date.month;
 565                 note.Alarm.Day = ((AddDialogData *)data)->alarm.date.day;
 566                 note.Alarm.Hour = ((AddDialogData *)data)->alarm.hours;
 567                 note.Alarm.Minute = ((AddDialogData *)data)->alarm.minutes;
 568                 note.Alarm.Second = note.Alarm.Timezone = 0;
 569         } else {
 570                 note.Alarm.Year = 0;
 571         }
 572         AddCalendarNote(&note);
 573         gtk_entry_set_text(GTK_ENTRY(((AddDialogData *)data)->text), "");
 574         gtk_widget_hide (((AddDialogData *)data)->dialog);
 575 }
 576
 577
 578 static inline void SetDateButton (Date *date)
 579 {
 580     gchar *buf = g_strdup_printf ("%d-%02d-%02d", date->year,
 581                                    date->month, date->day);
 582     gtk_label_set_text (GTK_LABEL (date->button), buf);
 583     g_free (buf);
 584 }
 585
 586
 587 static inline void SetDateTimeButton (DateTime *date)
 588 {
 589     gchar *buf = g_strdup_printf ("%d-%02d-%02d  %02d:%02d", date->date.year,
 590                                    date->date.month, date->date.day,
 591                                    date->hours, date->minutes);
 592     gtk_label_set_text (GTK_LABEL (date->button), buf);
 593     g_free (buf);
 594 }
 595
 596
 597 static void OkCalendarDialog (GtkWidget *widget, Date *date)
 598 {
 599   gtk_calendar_get_date (GTK_CALENDAR (calendarDialog.cal), &(date->year),
 600                          &(date->month), &(date->day));
 601   date->month += 1;
 602
 603   SetDateButton (date);
 604
 605   gtk_widget_hide (calendarDialog.dialog);
 606 }
 607
 608
 609 static void OkCalTimeDialog (GtkWidget *widget, DateTime *date)
 610 {
 611   gtk_calendar_get_date (GTK_CALENDAR (calTimeDialog.cal), &(date->date.year),
 612                          &(date->date.month), &(date->date.day));
 613   date->date.month += 1;
 614
 615   date->hours = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (date->hButton));
 616   date->minutes = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (date->mButton));
 617
 618   SetDateTimeButton (date);
 619
 620   gtk_widget_hide (calTimeDialog.dialog);
 621 }
 622
 623
 624 static void ShowCalendar (GtkWidget *widget, Date *date)
 625 {
 626   GtkWidget *button;
 627
 628   if (calendarDialog.dialog == NULL)
 629   {
 630     calendarDialog.dialog = gtk_dialog_new ();
 631     gtk_window_set_title (GTK_WINDOW (calendarDialog.dialog), _("Choose date"));
 632     gtk_window_position (GTK_WINDOW (calendarDialog.dialog), GTK_WIN_POS_MOUSE);
 633     gtk_window_set_modal(GTK_WINDOW (calendarDialog.dialog), TRUE);
 634     gtk_container_set_border_width (GTK_CONTAINER (calendarDialog.dialog), 10);
 635     gtk_signal_connect (GTK_OBJECT (calendarDialog.dialog), "delete_event",
 636                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 637
 638     button = gtk_button_new_with_label (_("Ok"));
 639     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (calendarDialog.dialog)->action_area),
 640                         button, TRUE, TRUE, 10);
 641     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 642                         GTK_SIGNAL_FUNC (OkCalendarDialog), (gpointer) date);
 643     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 644     gtk_widget_grab_default (button);
 645     gtk_widget_show (button);
 646
 647     button = gtk_button_new_with_label (_("Cancel"));
 648     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (calendarDialog.dialog)->action_area),
 649                         button, TRUE, TRUE, 10);
 650     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 651                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) calendarDialog.dialog);
 652     gtk_widget_show (button);
 653
 654     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (calendarDialog.dialog)->vbox), 5);
 655
 656     calendarDialog.cal = gtk_calendar_new ();
 657
 658     gtk_calendar_select_month (GTK_CALENDAR (calendarDialog.cal), date->month - 1, date->year);
 659     gtk_calendar_select_day (GTK_CALENDAR (calendarDialog.cal), date->day);
 660
 661     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (calendarDialog.dialog)->vbox), calendarDialog.cal);
 662     gtk_widget_show (calendarDialog.cal);
 663   }
 664
 665   gtk_widget_show (calendarDialog.dialog);
 666 }
 667
 668
 669 static void ShowCalTime (GtkWidget *widget, DateTime *date)
 670 {
 671   GtkWidget *button, *hbox, *label;
 672   GtkAdjustment *adj;
 673
 674   if (calTimeDialog.dialog == NULL)
 675   {
 676     calTimeDialog.dialog = gtk_dialog_new ();
 677     gtk_window_set_title (GTK_WINDOW (calTimeDialog.dialog), _("Choose date"));
 678     gtk_window_position (GTK_WINDOW (calTimeDialog.dialog), GTK_WIN_POS_MOUSE);
 679     gtk_window_set_modal(GTK_WINDOW (calTimeDialog.dialog), TRUE);
 680     gtk_container_set_border_width (GTK_CONTAINER (calTimeDialog.dialog), 10);
 681     gtk_signal_connect (GTK_OBJECT (calTimeDialog.dialog), "delete_event",
 682                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 683
 684     button = gtk_button_new_with_label (_("Ok"));
 685     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (calTimeDialog.dialog)->action_area),
 686                         button, TRUE, TRUE, 10);
 687     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 688                         GTK_SIGNAL_FUNC (OkCalTimeDialog), (gpointer) date);
 689     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 690     gtk_widget_grab_default (button);
 691     gtk_widget_show (button);
 692
 693     button = gtk_button_new_with_label (_("Cancel"));
 694     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (calTimeDialog.dialog)->action_area),
 695                         button, TRUE, TRUE, 10);
 696     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 697                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) calTimeDialog.dialog);
 698     gtk_widget_show (button);
 699
 700     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (calTimeDialog.dialog)->vbox), 5);
 701
 702     calTimeDialog.cal = gtk_calendar_new ();
 703
 704     gtk_calendar_select_month (GTK_CALENDAR (calTimeDialog.cal), date->date.month - 1, date->date.year);
 705     gtk_calendar_select_day (GTK_CALENDAR (calTimeDialog.cal), date->date.day);
 706
 707     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (calTimeDialog.dialog)->vbox), calTimeDialog.cal);
 708     gtk_widget_show (calTimeDialog.cal);
 709
 710     hbox = gtk_hbox_new (FALSE, 0);
 711     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (calTimeDialog.dialog)->vbox), hbox);
 712     gtk_widget_show (hbox);
 713
 714     label = gtk_label_new (_("Alarm time:"));
 715     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 716     gtk_widget_show (label);
 717
 718     adj = (GtkAdjustment *) gtk_adjustment_new (date->hours,
 719                                                 0.0, 23.0, 1.0, 4.0, 0.0);
 720     date->hButton = gtk_spin_button_new (adj, 0, 0);
 721     gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (date->hButton), TRUE);
 722     gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (date->hButton), TRUE);
 723     gtk_box_pack_start (GTK_BOX (hbox), date->hButton, FALSE, FALSE, 0);
 724     gtk_widget_show (date->hButton);
 725
 726     label = gtk_label_new (":");
 727     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 728     gtk_widget_show (label);
 729
 730     adj = (GtkAdjustment *) gtk_adjustment_new (date->minutes,
 731                                                 0.0, 59.0, 1.0, 10.0, 0.0);
 732     date->mButton = gtk_spin_button_new (adj, 0, 0);
 733     gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (date->mButton), TRUE);
 734     gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (date->mButton), TRUE);
 735     gtk_box_pack_start (GTK_BOX (hbox), date->mButton, FALSE, FALSE, 0);
 736     gtk_widget_show (date->mButton);
 737   }
 738
 739   gtk_widget_show (calTimeDialog.dialog);
 740 }
 741
 742
 743 static void AddReminder (void)
 744 {
 745   GtkWidget *button, *hbox, *vbox, *label;
 746   time_t t;
 747   struct tm *tm;
 748
 749   if (addReminderDialogData.dialog == NULL)
 750   {
 751     addReminderDialogData.dialog = gtk_dialog_new();
 752     gtk_window_set_title (GTK_WINDOW (addReminderDialogData.dialog), _("Add reminder"));
 753     gtk_window_position (GTK_WINDOW (addReminderDialogData.dialog), GTK_WIN_POS_MOUSE);
 754     gtk_window_set_modal(GTK_WINDOW (addReminderDialogData.dialog), TRUE);
 755     gtk_container_set_border_width (GTK_CONTAINER (addReminderDialogData.dialog), 10);
 756     gtk_signal_connect (GTK_OBJECT (addReminderDialogData.dialog), "delete_event",
 757                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 758
 759     button = gtk_button_new_with_label (_("Ok"));
 760     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addReminderDialogData.dialog)->action_area),
 761                         button, TRUE, TRUE, 10);
 762     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 763                         GTK_SIGNAL_FUNC (OkAddReminderDialog), (gpointer) &addReminderDialogData);
 764     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 765     gtk_widget_grab_default (button);
 766     gtk_widget_show (button);
 767     button = gtk_button_new_with_label (_("Cancel"));
 768     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addReminderDialogData.dialog)->action_area),
 769                         button, TRUE, TRUE, 10);
 770     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 771                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) addReminderDialogData.dialog);
 772     gtk_widget_show (button);
 773
 774     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (addReminderDialogData.dialog)->vbox), 5);
 775
 776     vbox = gtk_vbox_new (FALSE, 10);
 777     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (addReminderDialogData.dialog)->vbox), vbox);
 778     gtk_widget_show (vbox);
 779
 780     hbox = gtk_hbox_new (FALSE, 0);
 781     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 782     gtk_widget_show (hbox);
 783
 784     label = gtk_label_new (_("Date:"));
 785     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 786     gtk_widget_show (label);
 787
 788     t = time (NULL);
 789     tm = localtime (&t);
 790
 791     addReminderDialogData.date.year = addReminderDialogData.alarm.date.year =
 792                                       tm->tm_year + 1900;
 793     addReminderDialogData.date.month = addReminderDialogData.alarm.date.month =
 794                                        tm->tm_mon + 1;
 795     addReminderDialogData.date.day = addReminderDialogData.alarm.date.day =
 796                                      tm->tm_mday;
 797
 798     addReminderDialogData.alarm.hours = tm->tm_hour;
 799     addReminderDialogData.alarm.minutes = tm->tm_min;
 800
 801     button = gtk_button_new ();
 802
 803     addReminderDialogData.date.button = gtk_label_new ("");
 804
 805     gtk_container_add (GTK_CONTAINER (button), addReminderDialogData.date.button);
 806     SetDateButton (&(addReminderDialogData.date));
 807
 808     gtk_widget_show (addReminderDialogData.date.button);
 809
 810     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
 811     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 812                         GTK_SIGNAL_FUNC (ShowCalendar), (gpointer) &(addReminderDialogData.date));
 813     gtk_widget_show (button);
 814
 815     hbox = gtk_hbox_new (FALSE, 0);
 816     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 817     gtk_widget_show (hbox);
 818
 819     label = gtk_label_new (_("Subject:"));
 820     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 821     gtk_widget_show (label);
 822
 823     addReminderDialogData.text = gtk_entry_new_with_max_length (30);
 824     gtk_box_pack_end (GTK_BOX (hbox), addReminderDialogData.text, FALSE, FALSE, 2);
 825     gtk_widget_show (addReminderDialogData.text);
 826
 827     hbox = gtk_hbox_new (FALSE, 0);
 828     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 829     gtk_widget_show (hbox);
 830
 831     addReminderDialogData.alarmCheck = gtk_check_button_new_with_label (_("Alarm"));
 832     gtk_box_pack_start (GTK_BOX(hbox), addReminderDialogData.alarmCheck, FALSE, FALSE, 2);
 833 //    gtk_signal_connect (GTK_OBJECT (addReminderDialogData.alarmCheck), "toggled",
 834 //                        GTK_SIGNAL_FUNC (TogleAlarm), &addReminderDialogData);
 835     gtk_widget_show (addReminderDialogData.alarmCheck);
 836
 837     button = gtk_button_new ();
 838
 839     addReminderDialogData.alarm.button = gtk_label_new ("");
 840
 841     gtk_container_add (GTK_CONTAINER (button), addReminderDialogData.alarm.button);
 842     SetDateTimeButton (&(addReminderDialogData.alarm));
 843
 844     gtk_widget_show (addReminderDialogData.alarm.button);
 845
 846     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
 847     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 848                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addReminderDialogData.alarm));
 849     gtk_widget_show (button);
 850   }
 851
 852   gtk_widget_show (GTK_WIDGET (addReminderDialogData.dialog));
 853 }
 854
 855
 856 static void AddCall (void)
 857 {
 858   GtkWidget *button, *hbox, *vbox, *label;
 859   time_t t;
 860   struct tm *tm;
 861
 862   if (addCallDialogData.dialog == NULL)
 863   {
 864     addCallDialogData.dialog = gtk_dialog_new();
 865     gtk_window_set_title (GTK_WINDOW (addCallDialogData.dialog), _("Add Call"));
 866     gtk_window_position (GTK_WINDOW (addCallDialogData.dialog), GTK_WIN_POS_MOUSE);
 867     gtk_window_set_modal(GTK_WINDOW (addCallDialogData.dialog), TRUE);
 868     gtk_container_set_border_width (GTK_CONTAINER (addCallDialogData.dialog), 10);
 869     gtk_signal_connect (GTK_OBJECT (addCallDialogData.dialog), "delete_event",
 870                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 871
 872     button = gtk_button_new_with_label (_("Ok"));
 873     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addCallDialogData.dialog)->action_area),
 874                         button, TRUE, TRUE, 10);
 875     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 876                         GTK_SIGNAL_FUNC (OkAddCallDialog), (gpointer) &addCallDialogData);
 877     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 878     gtk_widget_grab_default (button);
 879     gtk_widget_show (button);
 880     button = gtk_button_new_with_label (_("Cancel"));
 881     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addCallDialogData.dialog)->action_area),
 882                         button, TRUE, TRUE, 10);
 883     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 884                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) addCallDialogData.dialog);
 885     gtk_widget_show (button);
 886
 887     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (addCallDialogData.dialog)->vbox), 5);
 888
 889     vbox = gtk_vbox_new (FALSE, 10);
 890     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (addCallDialogData.dialog)->vbox), vbox);
 891     gtk_widget_show (vbox);
 892
 893     hbox = gtk_hbox_new (FALSE, 0);
 894     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 895     gtk_widget_show (hbox);
 896
 897     label = gtk_label_new (_("Date:"));
 898     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 899     gtk_widget_show (label);
 900
 901     t = time (NULL);
 902     tm = localtime (&t);
 903
 904     addCallDialogData.date.date.year = addCallDialogData.alarm.date.year =
 905                                       tm->tm_year + 1900;
 906     addCallDialogData.date.date.month = addCallDialogData.alarm.date.month =
 907                                        tm->tm_mon + 1;
 908     addCallDialogData.date.date.day = addCallDialogData.alarm.date.day =
 909                                      tm->tm_mday;
 910
 911     addCallDialogData.date.hours = addCallDialogData.alarm.hours = tm->tm_hour;
 912     addCallDialogData.date.minutes = addCallDialogData.alarm.minutes = tm->tm_min;
 913
 914     button = gtk_button_new ();
 915
 916     addCallDialogData.date.button = gtk_label_new ("");
 917
 918     gtk_container_add (GTK_CONTAINER (button), addCallDialogData.date.button);
 919     SetDateTimeButton (&(addCallDialogData.date));
 920
 921     gtk_widget_show (addCallDialogData.date.button);
 922
 923     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
 924     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 925                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addCallDialogData.date));
 926     gtk_widget_show (button);
 927
 928     hbox = gtk_hbox_new (FALSE, 0);
 929     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 930     gtk_widget_show (hbox);
 931
 932     label = gtk_label_new (_("Number:"));
 933     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
 934     gtk_widget_show (label);
 935
 936     addCallDialogData.text = gtk_entry_new_with_max_length (30);
 937     gtk_box_pack_end (GTK_BOX (hbox), addCallDialogData.text, FALSE, FALSE, 2);
 938     gtk_widget_show (addCallDialogData.text);
 939
 940     hbox = gtk_hbox_new (FALSE, 0);
 941     gtk_container_add (GTK_CONTAINER (vbox), hbox);
 942     gtk_widget_show (hbox);
 943
 944     addCallDialogData.alarmCheck = gtk_check_button_new_with_label (_("Alarm"));
 945     gtk_box_pack_start (GTK_BOX(hbox), addCallDialogData.alarmCheck, FALSE, FALSE, 2);
 946
 947     gtk_widget_show (addCallDialogData.alarmCheck);
 948
 949     button = gtk_button_new ();
 950
 951     addCallDialogData.alarm.button = gtk_label_new ("");
 952
 953     gtk_container_add (GTK_CONTAINER (button), addCallDialogData.alarm.button);
 954     SetDateTimeButton (&(addCallDialogData.alarm));
 955
 956     gtk_widget_show (addCallDialogData.alarm.button);
 957
 958     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
 959     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 960                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addCallDialogData.alarm));
 961     gtk_widget_show (button);
 962   }
 963
 964   gtk_widget_show (GTK_WIDGET (addCallDialogData.dialog));
 965 }
 966
 967
 968 static void AddMeeting (void)
 969 {
 970   GtkWidget *button, *hbox, *vbox, *label;
 971   time_t t;
 972   struct tm *tm;
 973
 974   if (addMeetingDialogData.dialog == NULL)
 975   {
 976     addMeetingDialogData.dialog = gtk_dialog_new();
 977     gtk_window_set_title (GTK_WINDOW (addMeetingDialogData.dialog), _("Add meeting"));
 978     gtk_window_position (GTK_WINDOW (addMeetingDialogData.dialog), GTK_WIN_POS_MOUSE);
 979     gtk_window_set_modal(GTK_WINDOW (addMeetingDialogData.dialog), TRUE);
 980     gtk_container_set_border_width (GTK_CONTAINER (addMeetingDialogData.dialog), 10);
 981     gtk_signal_connect (GTK_OBJECT (addMeetingDialogData.dialog), "delete_event",
 982                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 983
 984     button = gtk_button_new_with_label (_("Ok"));
 985     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addMeetingDialogData.dialog)->action_area),
 986                         button, TRUE, TRUE, 10);
 987     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 988                         GTK_SIGNAL_FUNC (OkAddMeetingDialog), (gpointer) &addMeetingDialogData);
 989     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 990     gtk_widget_grab_default (button);
 991     gtk_widget_show (button);
 992     button = gtk_button_new_with_label (_("Cancel"));
 993     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addMeetingDialogData.dialog)->action_area),
 994                         button, TRUE, TRUE, 10);
 995     gtk_signal_connect (GTK_OBJECT (button), "clicked",
 996                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) addMeetingDialogData.dialog);
 997     gtk_widget_show (button);
 998
 999     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (addMeetingDialogData.dialog)->vbox), 5);
1000
1001     vbox = gtk_vbox_new (FALSE, 10);
1002     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (addMeetingDialogData.dialog)->vbox), vbox);
1003     gtk_widget_show (vbox);
1004
1005     hbox = gtk_hbox_new (FALSE, 0);
1006     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1007     gtk_widget_show (hbox);
1008
1009     label = gtk_label_new (_("Date:"));
1010     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1011     gtk_widget_show (label);
1012
1013     t = time (NULL);
1014     tm = localtime (&t);
1015
1016     addMeetingDialogData.date.date.year = addMeetingDialogData.alarm.date.year =
1017                                       tm->tm_year + 1900;
1018     addMeetingDialogData.date.date.month = addMeetingDialogData.alarm.date.month =
1019                                        tm->tm_mon + 1;
1020     addMeetingDialogData.date.date.day = addMeetingDialogData.alarm.date.day =
1021                                      tm->tm_mday;
1022
1023     addMeetingDialogData.date.hours = addMeetingDialogData.alarm.hours = tm->tm_hour;
1024     addMeetingDialogData.date.minutes = addMeetingDialogData.alarm.minutes = tm->tm_min;
1025
1026     button = gtk_button_new ();
1027
1028     addMeetingDialogData.date.button = gtk_label_new ("");
1029
1030     gtk_container_add (GTK_CONTAINER (button), addMeetingDialogData.date.button);
1031     SetDateTimeButton (&(addMeetingDialogData.date));
1032
1033     gtk_widget_show (addMeetingDialogData.date.button);
1034
1035     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
1036     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1037                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addMeetingDialogData.date));
1038     gtk_widget_show (button);
1039
1040     hbox = gtk_hbox_new (FALSE, 0);
1041     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1042     gtk_widget_show (hbox);
1043
1044     label = gtk_label_new (_("Name:"));
1045     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1046     gtk_widget_show (label);
1047
1048     addMeetingDialogData.text = gtk_entry_new_with_max_length (30);
1049     gtk_box_pack_end (GTK_BOX (hbox), addMeetingDialogData.text, FALSE, FALSE, 2);
1050     gtk_widget_show (addMeetingDialogData.text);
1051
1052     hbox = gtk_hbox_new (FALSE, 0);
1053     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1054     gtk_widget_show (hbox);
1055
1056     addMeetingDialogData.alarmCheck = gtk_check_button_new_with_label (_("Alarm"));
1057     gtk_box_pack_start (GTK_BOX(hbox), addMeetingDialogData.alarmCheck, FALSE, FALSE, 2);
1058 //    gtk_signal_connect (GTK_OBJECT (addMeetingDialogData.alarmCheck), "toggled",
1059 //                        GTK_SIGNAL_FUNC (TogleAlarm), &addMeetingDialogData);
1060     gtk_widget_show (addMeetingDialogData.alarmCheck);
1061
1062     button = gtk_button_new ();
1063
1064     addMeetingDialogData.alarm.button = gtk_label_new ("");
1065
1066     gtk_container_add (GTK_CONTAINER (button), addMeetingDialogData.alarm.button);
1067     SetDateTimeButton (&(addMeetingDialogData.alarm));
1068
1069     gtk_widget_show (addMeetingDialogData.alarm.button);
1070
1071     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
1072     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1073                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addMeetingDialogData.alarm));
1074     gtk_widget_show (button);
1075   }
1076
1077   gtk_widget_show (GTK_WIDGET (addMeetingDialogData.dialog));
1078 }
1079
1080
1081 static void AddBirthday (void)
1082 {
1083   GtkWidget *button, *hbox, *vbox, *label;
1084   time_t t;
1085   struct tm *tm;
1086
1087   if (addBirthdayDialogData.dialog == NULL)
1088   {
1089     addBirthdayDialogData.dialog = gtk_dialog_new();
1090     gtk_window_set_title (GTK_WINDOW (addBirthdayDialogData.dialog), _("Add birthday"));
1091     gtk_window_position (GTK_WINDOW (addBirthdayDialogData.dialog), GTK_WIN_POS_MOUSE);
1092     gtk_window_set_modal(GTK_WINDOW (addBirthdayDialogData.dialog), TRUE);
1093     gtk_container_set_border_width (GTK_CONTAINER (addBirthdayDialogData.dialog), 10);
1094     gtk_signal_connect (GTK_OBJECT (addBirthdayDialogData.dialog), "delete_event",
1095                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1096
1097     button = gtk_button_new_with_label (_("Ok"));
1098     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addBirthdayDialogData.dialog)->action_area),
1099                         button, TRUE, TRUE, 10);
1100     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1101                         GTK_SIGNAL_FUNC (OkAddBdayDialog), (gpointer) &addBirthdayDialogData);
1102     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1103     gtk_widget_grab_default (button);
1104     gtk_widget_show (button);
1105     button = gtk_button_new_with_label (_("Cancel"));
1106     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (addBirthdayDialogData.dialog)->action_area),
1107                         button, TRUE, TRUE, 10);
1108     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1109                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) addBirthdayDialogData.dialog);
1110     gtk_widget_show (button);
1111
1112     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (addBirthdayDialogData.dialog)->vbox), 5);
1113
1114     vbox = gtk_vbox_new (FALSE, 10);
1115     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (addBirthdayDialogData.dialog)->vbox), vbox);
1116     gtk_widget_show (vbox);
1117
1118     hbox = gtk_hbox_new (FALSE, 0);
1119     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1120     gtk_widget_show (hbox);
1121
1122     label = gtk_label_new (_("Date:"));
1123     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1124     gtk_widget_show (label);
1125
1126     t = time (NULL);
1127     tm = localtime (&t);
1128
1129     addBirthdayDialogData.date.year = addBirthdayDialogData.alarm.date.year =
1130                                       tm->tm_year + 1900;
1131     addBirthdayDialogData.date.month = addBirthdayDialogData.alarm.date.month =
1132                                        tm->tm_mon + 1;
1133     addBirthdayDialogData.date.day = addBirthdayDialogData.alarm.date.day =
1134                                      tm->tm_mday;
1135
1136     addBirthdayDialogData.alarm.hours = tm->tm_hour;
1137     addBirthdayDialogData.alarm.minutes = tm->tm_min;
1138
1139     button = gtk_button_new ();
1140
1141     addBirthdayDialogData.date.button = gtk_label_new ("");
1142
1143     gtk_container_add (GTK_CONTAINER (button), addBirthdayDialogData.date.button);
1144     SetDateButton (&(addBirthdayDialogData.date));
1145
1146     gtk_widget_show (addBirthdayDialogData.date.button);
1147
1148     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
1149     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1150                         GTK_SIGNAL_FUNC (ShowCalendar), (gpointer) &(addBirthdayDialogData.date));
1151     gtk_widget_show (button);
1152
1153     hbox = gtk_hbox_new (FALSE, 0);
1154     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1155     gtk_widget_show (hbox);
1156
1157     label = gtk_label_new (_("Name:"));
1158     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1159     gtk_widget_show (label);
1160
1161     addBirthdayDialogData.text = gtk_entry_new_with_max_length (30);
1162     gtk_box_pack_end (GTK_BOX (hbox), addBirthdayDialogData.text, FALSE, FALSE, 2);
1163     gtk_widget_show (addBirthdayDialogData.text);
1164
1165     hbox = gtk_hbox_new (FALSE, 0);
1166     gtk_container_add (GTK_CONTAINER (vbox), hbox);
1167     gtk_widget_show (hbox);
1168
1169     addBirthdayDialogData.alarmCheck = gtk_check_button_new_with_label (_("Alarm"));
1170     gtk_box_pack_start (GTK_BOX(hbox), addBirthdayDialogData.alarmCheck, FALSE, FALSE, 2);
1171 //    gtk_signal_connect (GTK_OBJECT (addBirthdayDialogData.alarmCheck), "toggled",
1172 //                        GTK_SIGNAL_FUNC (TogleAlarm), &addBirthdayDialogData);
1173     gtk_widget_show (addBirthdayDialogData.alarmCheck);
1174
1175     button = gtk_button_new ();
1176
1177     addBirthdayDialogData.alarm.button = gtk_label_new ("");
1178
1179     gtk_container_add (GTK_CONTAINER (button), addBirthdayDialogData.alarm.button);
1180     SetDateTimeButton (&(addBirthdayDialogData.alarm));
1181
1182     gtk_widget_show (addBirthdayDialogData.alarm.button);
1183
1184     gtk_box_pack_start (GTK_BOX (hbox), button, TRUE, TRUE, 2);
1185     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1186                         GTK_SIGNAL_FUNC (ShowCalTime), (gpointer) &(addBirthdayDialogData.alarm));
1187     gtk_widget_show (button);
1188   }
1189
1190   gtk_widget_show (GTK_WIDGET (addBirthdayDialogData.dialog));
1191 }
1192
1193
1194 static void OkDeleteNoteDialog (GtkWidget *widget, gpointer data)
1195 {
1196   GSM_CalendarNote *note;
1197   PhoneEvent *e;
1198   GList *sel;
1199   gint row;
1200   gchar *buf;
1201
1202
1203   sel = GTK_CLIST (cal.notesClist)->selection;
1204
1205   gtk_clist_freeze (GTK_CLIST (cal.notesClist));
1206
1207   sel = g_list_sort (sel, ReverseSelection);
1208
1209   while (sel != NULL)
1210   {
1211     row = GPOINTER_TO_INT (sel->data);
1212     sel = sel->next;
1213
1214     note = (GSM_CalendarNote *) g_malloc (sizeof (GSM_CalendarNote));
1215     gtk_clist_get_text (GTK_CLIST (cal.notesClist), row, 0, &buf);
1216     note->Location = atoi (buf);
1217
1218     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1219     e->event = Event_DeleteCalendarNote;
1220     e->data = note;
1221     GUI_InsertEvent (e);
1222   }
1223
1224   gtk_widget_hide (GTK_WIDGET (data));
1225
1226   gtk_clist_thaw (GTK_CLIST (cal.notesClist));
1227
1228   ReadCalNotes ();
1229 }
1230
1231
1232 static void DeleteNote (void)
1233 {
1234   static GtkWidget *dialog = NULL;
1235   GtkWidget *button, *hbox, *label, *pixmap;
1236
1237   if (dialog == NULL)
1238   {
1239     dialog = gtk_dialog_new();
1240     gtk_window_set_title (GTK_WINDOW (dialog), _("Delete calendar note"));
1241     gtk_window_position (GTK_WINDOW (dialog), GTK_WIN_POS_MOUSE);
1242     gtk_window_set_modal(GTK_WINDOW (dialog), TRUE);
1243     gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1244     gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1245                         GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1246
1247     button = gtk_button_new_with_label (_("Ok"));
1248     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1249                         button, TRUE, TRUE, 10);
1250     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1251                         GTK_SIGNAL_FUNC (OkDeleteNoteDialog), (gpointer) dialog);
1252     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1253     gtk_widget_grab_default (button);
1254     gtk_widget_show (button);
1255     button = gtk_button_new_with_label (_("Cancel"));
1256     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1257                         button, TRUE, TRUE, 10);
1258     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1259                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) dialog);
1260     gtk_widget_show (button);
1261
1262     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
1263
1264     hbox = gtk_hbox_new (FALSE, 0);
1265     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1266     gtk_widget_show (hbox);
1267
1268     pixmap = gtk_pixmap_new (questMark.pixmap, questMark.mask);
1269     gtk_box_pack_start (GTK_BOX (hbox), pixmap, FALSE, FALSE, 10);
1270     gtk_widget_show (pixmap);
1271
1272     label = gtk_label_new (_("Do you want to delete selected note(s)?"));
1273     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 10);
1274     gtk_widget_show (label);
1275   }
1276
1277   gtk_widget_show (GTK_WIDGET (dialog));
1278 }
1279
1280 static GtkItemFactoryEntry menu_items[] = {
1281   { NULL,               NULL,           NULL, 0, "<Branch>"},
1282   { NULL,               "<control>R",   ReadCalNotes, 0, NULL},
1283   { NULL,               "<control>S",   NULL, 0, NULL},
1284   { NULL,               NULL,           NULL, 0, "<Separator>"},
1285   { NULL,               "<control>X",   NULL, 0, NULL},
1286   { NULL,               NULL,           NULL, 0, "<Separator>"},
1287   { NULL,               "<control>I",   NULL, 0, NULL},
1288   { NULL,               "<control>E",   NULL, 0, NULL},
1289   { NULL,               NULL,           NULL, 0, "<Separator>"},
1290   { NULL,               "<control>W",   CloseCalendar, 0, NULL},
1291   { NULL,               NULL,           NULL, 0, "<Branch>"},
1292   { NULL,               "<control>N",   AddReminder, 0, NULL},
1293   { NULL,               "<control>C",   AddCall, 0, NULL},
1294   { NULL,               "<control>M",   AddMeeting, 0, NULL},
1295   { NULL,               "<control>B",   AddBirthday, 0, NULL},
1296   { NULL,               NULL,           NULL, 0, NULL},
1297   { NULL,               "<control>D",   DeleteNote, 0, NULL},
1298   { NULL,               NULL,           NULL, 0, "<Separator>"},
1299   { NULL,               "<control>A",   NULL, 0, NULL},
1300   { NULL,               NULL,           NULL, 0, "<LastBranch>"},
1301   { NULL,               NULL,           Help1, 0, NULL},
1302   { NULL,               NULL,           GUI_ShowAbout, 0, NULL},
1303 };
1304
1305 static void InitMainMenu (void)
1306 {
1307   menu_items[0].path = g_strdup (_("/_File"));
1308   menu_items[1].path = g_strdup (_("/File/_Read from phone"));
1309   menu_items[2].path = g_strdup (_("/File/_Save to phone"));
1310   menu_items[3].path = g_strdup (_("/File/Sep1"));
1311   menu_items[4].path = g_strdup (_("/File/Send via S_MS"));
1312   menu_items[5].path = g_strdup (_("/File/Sep2"));
1313   menu_items[6].path = g_strdup (_("/File/_Import from file"));
1314   menu_items[7].path = g_strdup (_("/File/_Export to file"));
1315   menu_items[8].path = g_strdup (_("/File/Sep3"));
1316   menu_items[9].path = g_strdup (_("/File/_Close"));
1317   menu_items[10].path = g_strdup (_("/_Edit"));
1318   menu_items[11].path = g_strdup (_("/Edit/Add _reminder"));
1319   menu_items[12].path = g_strdup (_("/Edit/Add _call"));
1320   menu_items[13].path = g_strdup (_("/Edit/Add _meeting"));
1321   menu_items[14].path = g_strdup (_("/Edit/Add _birthday"));
1322   menu_items[15].path = g_strdup (_("/Edit/_Edit"));
1323   menu_items[16].path = g_strdup (_("/Edit/_Delete"));
1324   menu_items[17].path = g_strdup (_("/Edit/Sep4"));
1325   menu_items[18].path = g_strdup (_("/Edit/Select _all"));
1326   menu_items[19].path = g_strdup (_("/_Help"));
1327   menu_items[20].path = g_strdup (_("/Help/_Help"));
1328   menu_items[21].path = g_strdup (_("/Help/_About"));
1329 }
1330
1331 void GUI_CreateCalendarWindow ()
1332 {
1333   int nmenu_items = sizeof (menu_items) / sizeof (menu_items[0]);
1334   GtkItemFactory *item_factory;
1335   GtkAccelGroup *accel_group;
1336   GtkWidget *menubar, *toolbar, *scrolledWindow, *hpaned;
1337   GtkWidget *main_vbox;
1338   GdkColormap *cmap;
1339   time_t t;
1340   struct tm *tm;
1341   SortColumn *sColumn;
1342   register gint i;
1343   gchar *titles[6] = { _("#"), _("Type"), _("Date"), _("Text"),
1344                        _("Alarm"), _("Number")};
1345
1346   InitMainMenu ();
1347   GUI_CalendarWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
1348   gtk_window_set_wmclass (GTK_WINDOW (GUI_CalendarWindow), "CalendarWindow", "Xgnokii");
1349   gtk_window_set_title (GTK_WINDOW (GUI_CalendarWindow), _("Calendar"));
1350   //gtk_widget_set_usize (GTK_WIDGET (GUI_CalendarWindow), 436, 220);
1351   gtk_signal_connect (GTK_OBJECT (GUI_CalendarWindow), "delete_event",
1352                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1353   gtk_widget_realize (GUI_CalendarWindow);
1354
1355   accel_group = gtk_accel_group_new ();
1356   item_factory = gtk_item_factory_new (GTK_TYPE_MENU_BAR, "<main>",
1357                                        accel_group);
1358
1359   gtk_item_factory_create_items (item_factory, nmenu_items, menu_items, NULL);
1360
1361   gtk_accel_group_attach (accel_group, GTK_OBJECT (GUI_CalendarWindow));
1362
1363   /* Finally, return the actual menu bar created by the item factory. */
1364   menubar = gtk_item_factory_get_widget (item_factory, "<main>");
1365
1366   main_vbox = gtk_vbox_new (FALSE, 1);
1367   gtk_container_border_width (GTK_CONTAINER (main_vbox), 1);
1368   gtk_container_add (GTK_CONTAINER (GUI_CalendarWindow), main_vbox);
1369   gtk_widget_show (main_vbox);
1370
1371   gtk_box_pack_start (GTK_BOX (main_vbox), menubar, FALSE, FALSE, 0);
1372   gtk_widget_show (menubar);
1373
1374   /* Create the toolbar */
1375   toolbar = gtk_toolbar_new (GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
1376   gtk_toolbar_set_button_relief (GTK_TOOLBAR (toolbar), GTK_RELIEF_NORMAL);
1377
1378   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Read from phone"), NULL,
1379                            NewPixmap(Read_xpm, GUI_CalendarWindow->window,
1380                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1381                            (GtkSignalFunc) ReadCalNotes, NULL);
1382   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Save to phone"), NULL,
1383                            NewPixmap(Send_xpm, GUI_CalendarWindow->window,
1384                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1385                            (GtkSignalFunc) NULL, NULL);
1386
1387   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1388
1389   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Send via SMS"), NULL,
1390                            NewPixmap(SendSMS_xpm, GUI_CalendarWindow->window,
1391                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1392                            (GtkSignalFunc) NULL, NULL);
1393
1394   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1395
1396   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Import from file"), NULL,
1397                            NewPixmap(Open_xpm, GUI_CalendarWindow->window,
1398                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1399                            (GtkSignalFunc) NULL, NULL);
1400   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Export to file"), NULL,
1401                            NewPixmap(Save_xpm, GUI_CalendarWindow->window,
1402                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1403                            (GtkSignalFunc) NULL, NULL);
1404
1405   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
1406
1407   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Edit note"), NULL,
1408                            NewPixmap(Edit_xpm, GUI_CalendarWindow->window,
1409                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1410                            (GtkSignalFunc) NULL, NULL);
1411   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Add reminder"), NULL,
1412                            NewPixmap(NewRem_xpm, GUI_CalendarWindow->window,
1413                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1414                            (GtkSignalFunc) AddReminder, NULL);
1415   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Add call"), NULL,
1416                            NewPixmap(NewCall_xpm, GUI_CalendarWindow->window,
1417                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1418                            (GtkSignalFunc) AddCall, NULL);
1419   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Add meeting"), NULL,
1420                            NewPixmap(NewMeet_xpm, GUI_CalendarWindow->window,
1421                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1422                            (GtkSignalFunc) AddMeeting, NULL);
1423   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Add birthday"), NULL,
1424                            NewPixmap(NewBD_xpm, GUI_CalendarWindow->window,
1425                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1426                            (GtkSignalFunc) AddBirthday, NULL);
1427   gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), NULL, _("Delete note"), NULL,
1428                            NewPixmap(Delete_xpm, GUI_CalendarWindow->window,
1429                            &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL]),
1430                            (GtkSignalFunc) DeleteNote, NULL);
1431
1432   gtk_box_pack_start (GTK_BOX (main_vbox), toolbar, FALSE, FALSE, 0);
1433   gtk_widget_show (toolbar);
1434
1435   hpaned = gtk_hpaned_new ();
1436   //gtk_paned_set_handle_size (GTK_PANED (hpaned), 10);
1437   //gtk_paned_set_gutter_size (GTK_PANED (hpaned), 15);
1438   gtk_box_pack_start (GTK_BOX (main_vbox), hpaned, TRUE, TRUE, 0);
1439   gtk_widget_show (hpaned);
1440
1441   /* Note viewer */
1442   cal.noteText = gtk_text_new (NULL, NULL);
1443   gtk_text_set_editable (GTK_TEXT (cal.noteText), FALSE);
1444   gtk_text_set_word_wrap (GTK_TEXT (cal.noteText), TRUE);
1445
1446   scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
1447   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledWindow),
1448                                   GTK_POLICY_NEVER,
1449                                   GTK_POLICY_AUTOMATIC);
1450
1451   gtk_paned_add1 (GTK_PANED (hpaned), scrolledWindow);
1452
1453   gtk_container_add (GTK_CONTAINER (scrolledWindow), cal.noteText);
1454   gtk_widget_show_all (scrolledWindow);
1455
1456   /* Calendar */
1457   cal.calendar = gtk_calendar_new ();
1458
1459   t = time (NULL);
1460   tm = localtime (&t);
1461   gtk_calendar_select_month (GTK_CALENDAR (cal.calendar), tm->tm_mon, tm->tm_year + 1900);
1462   gtk_calendar_select_day (GTK_CALENDAR (cal.calendar), tm->tm_mday);
1463
1464   gtk_paned_add2 (GTK_PANED (hpaned), cal.calendar);
1465   gtk_widget_show (cal.calendar);
1466
1467   /* Notes list */
1468   cal.notesClist = gtk_clist_new_with_titles (6, titles);
1469   gtk_clist_set_shadow_type (GTK_CLIST (cal.notesClist), GTK_SHADOW_OUT);
1470   gtk_clist_set_compare_func (GTK_CLIST (cal.notesClist), CListCompareFunc);
1471   gtk_clist_set_sort_column (GTK_CLIST (cal.notesClist), 0);
1472   gtk_clist_set_sort_type (GTK_CLIST (cal.notesClist), GTK_SORT_ASCENDING);
1473   gtk_clist_set_auto_sort (GTK_CLIST (cal.notesClist), FALSE);
1474   gtk_clist_set_selection_mode (GTK_CLIST (cal.notesClist), GTK_SELECTION_EXTENDED);
1475
1476   gtk_clist_set_column_width (GTK_CLIST (cal.notesClist), 0, 15);
1477   gtk_clist_set_column_width (GTK_CLIST (cal.notesClist), 1, 52);
1478   gtk_clist_set_column_width (GTK_CLIST (cal.notesClist), 2, 110);
1479   gtk_clist_set_column_width (GTK_CLIST (cal.notesClist), 3, 130);
1480   gtk_clist_set_column_width (GTK_CLIST (cal.notesClist), 4, 110);
1481   gtk_clist_set_column_justification (GTK_CLIST (cal.notesClist), 0, GTK_JUSTIFY_RIGHT);
1482
1483   for (i = 0; i < 6; i++)
1484   {
1485     if ((sColumn = g_malloc (sizeof (SortColumn))) == NULL)
1486     {
1487       g_print (_("Error: %s: line %d: Can't allocate memory!\n"), __FILE__, __LINE__);
1488       gtk_main_quit ();
1489     }
1490     sColumn->clist = cal.notesClist;
1491     sColumn->column = i;
1492     gtk_signal_connect (GTK_OBJECT (GTK_CLIST (cal.notesClist)->column[i].button), "clicked",
1493                         GTK_SIGNAL_FUNC (SetSortColumn), (gpointer) sColumn);
1494   }
1495
1496   gtk_signal_connect (GTK_OBJECT (cal.notesClist), "select_row",
1497                       GTK_SIGNAL_FUNC (ClickEntry), NULL);
1498
1499   scrolledWindow = gtk_scrolled_window_new (NULL, NULL);
1500   gtk_widget_set_usize (scrolledWindow, 550, 100);
1501   gtk_container_add (GTK_CONTAINER (scrolledWindow), cal.notesClist);
1502   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (scrolledWindow),
1503                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1504
1505   gtk_box_pack_end (GTK_BOX (main_vbox), scrolledWindow,
1506                       TRUE, TRUE, 0);
1507
1508   gtk_widget_show (cal.notesClist);
1509   gtk_widget_show (scrolledWindow);
1510
1511   cmap = gdk_colormap_get_system();
1512   cal.colour.red = 0xffff;
1513   cal.colour.green = 0;
1514   cal.colour.blue = 0;
1515   if (!gdk_color_alloc (cmap, &(cal.colour)))
1516     g_error (_("couldn't allocate colour"));
1517
1518   questMark.pixmap = gdk_pixmap_create_from_xpm_d (GUI_CalendarWindow->window,
1519                          &questMark.mask,
1520                          &GUI_CalendarWindow->style->bg[GTK_STATE_NORMAL],
1521                          quest_xpm);
1522
1523   CreateErrorDialog (&errorDialog, GUI_CalendarWindow);
1524 }