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