xgnokii/xgnokii.c

   1 /*
   2
   3   $Id$
   4
   5   X G N O K I I
   6
   7   A Linux/Unix GUI for Nokia mobile phones.
   8   Copyright (C) 1999 Pavel Janík ml., Hugh Blemings
   9   & Ján Derfiòák <ja@mail.upjs.sk>.
  10
  11   Released under the terms of the GNU GPL, see file COPYING for more details.
  12
  13 */
  14
  15 #include <stdlib.h>  /* for getenv */
  16 #include <locale.h>
  17 #include <string.h>
  18 #include <time.h>    /* for time   */
  19 #include <pthread.h>
  20
  21 #ifndef WIN32
  22 # include <unistd.h>  /* for usleep */
  23 # include <signal.h>
  24 #else
  25 # include <windows.h>
  26 # include "../win32/winserial.h"
  27 # define WRITEPHONE(a, b, c) WriteCommBlock(b, c)
  28 # undef IN
  29 # undef OUT
  30 # define sleep(x) Sleep((x) * 1000)
  31 # define usleep(x) Sleep(((x) < 1000) ? 1 : ((x) / 1000))
  32 #endif
  33
  34 #include <gdk/gdkkeysyms.h>
  35 #include <gtk/gtk.h>
  36
  37 #include "misc.h"
  38 #include "gsm-common.h"
  39 #include "gsm-api.h"
  40 #include "cfgreader.h"
  41 #include "phones/nk7110.h"
  42 #include "phones/nk6100.h"
  43 #include "phones/nk3110.h"
  44 #include "phones/nk2110.h"
  45 #include "xgnokii.h"
  46 #include "xgnokii_common.h"
  47 #include "xgnokii_lowlevel.h"
  48 #include "xgnokii_contacts.h"
  49 #include "xgnokii_sms.h"
  50 #include "xgnokii_netmon.h"
  51 #include "xgnokii_dtmf.h"
  52 #include "xgnokii_speed.h"
  53 #include "xgnokii_xkeyb.h"
  54 #include "xgnokii_calendar.h"
  55 #include "xgnokii_logos.h"
  56 #include "xgnokii_cfg.h"
  57 #include "xgnokii_data.h"
  58
  59 #include "xpm/logo.xpm"
  60 #include "xpm/background.xpm"
  61 #include "xpm/sms.xpm"
  62 #include "xpm/alarm.xpm"
  63
  64 /* Widgets for dialogs. */
  65 static GtkWidget *SplashWindow;
  66 static GtkWidget *GUI_MainWindow;
  67 static GtkWidget *AboutDialog;
  68 static ErrorDialog errorDialog = {NULL, NULL};
  69 static InfoDialog infoDialog = {NULL, NULL};
  70 static GtkWidget *OptionsDialog;
  71 static bool optionsDialogIsOpened;
  72
  73 /* SMS sets list */
  74 static GtkWidget *SMSClist;
  75
  76 /* Pixmap used for drawing all the stuff. */
  77 static GdkPixmap *Pixmap = NULL;
  78
  79 /* Pixmap used for background. */
  80 static GdkPixmap *BackgroundPixmap = NULL;
  81
  82 /* Pixmap used for SMS picture. */
  83 static GdkPixmap *SMSPixmap = NULL;
  84
  85 /* Pixmap used for alarm picture. */
  86 static GdkPixmap *AlarmPixmap = NULL;
  87
  88
  89 /* Widget for popup menu */
  90 static GtkWidget *Menu;
  91 static GtkWidget *netmon_menu_item;
  92 static GtkWidget *sms_menu_item;
  93 static GtkWidget *calendar_menu_item;
  94 static GtkWidget *logos_menu_item;
  95 static GtkWidget *dtmf_menu_item;
  96 static GtkWidget *speedDial_menu_item;
  97 static GtkWidget *xkeyb_menu_item;
  98 static GtkWidget *cg_names_option_frame;
  99 static GtkWidget *sms_option_frame;
 100 static GtkWidget *mail_option_frame;
 101 static GtkWidget *user_option_frame;
 102 static GtkWidget *data_menu_item;
 103
 104 /* Hold main configuration data for xgnokii */
 105 XgnokiiConfig xgnokiiConfig;
 106
 107 gint max_phonebook_name_length;
 108 gint max_phonebook_number_length;
 109 gint max_phonebook_sim_name_length;
 110 gint max_phonebook_sim_number_length;
 111
 112 /* Local variables */
 113 static char *DefaultXGnokiiDir = XGNOKIIDIR;
 114 static bool SMSSettingsInitialized = FALSE;
 115 static bool CallersGroupsInitialized = FALSE;
 116 static gint hiddenCallDialog;
 117 static guint splashRemoveHandler;
 118
 119 static struct CallDialog {
 120   GtkWidget *dialog;
 121   GtkWidget *label;
 122 } inCallDialog;
 123
 124 typedef struct {
 125   GtkWidget *alarmSwitch;
 126   GtkWidget *alarmHour;
 127   GtkWidget *alarmMin;
 128 } AlarmWidgets;
 129
 130 typedef struct {
 131   GtkWidget *port;
 132   GtkWidget *model;
 133   GtkWidget *init;
 134   GtkWidget *bindir;
 135   GtkWidget *serial, *infrared, *irda;
 136 } ConnectionWidgets;
 137
 138 typedef struct {
 139   GtkWidget *model;
 140   GtkWidget *version;
 141   GtkWidget *revision;
 142   GtkWidget *imei;
 143   GtkWidget *simNameLen;
 144   GtkWidget *phoneNameLen;
 145 } PhoneWidgets;
 146
 147 typedef struct {
 148   GtkWidget *set;
 149   GtkWidget *number;
 150   GtkWidget *format;
 151   GtkWidget *validity;
 152   SMS_MessageCenter smsSetting[MAX_SMS_CENTER];
 153 } SMSWidgets;
 154
 155 typedef struct {
 156   GtkWidget *name;
 157   GtkWidget *title;
 158   GtkWidget *company;
 159   GtkWidget *telephone;
 160   GtkWidget *fax;
 161   GtkWidget *email;
 162   GtkWidget *address;
 163   GtkWidget *status;
 164   gint   max;
 165   gint   used;
 166 } UserWidget;
 167
 168 static struct ConfigDialogData
 169 {
 170   ConnectionWidgets connection;
 171   PhoneWidgets phone;
 172   GtkWidget *groups[6];
 173   AlarmWidgets alarm;
 174   SMSWidgets sms;
 175   UserWidget user;
 176   GtkWidget *mailbox;
 177   GtkWidget *help;
 178 } configDialogData;
 179
 180 static SMS_MessageCenter tempMessageSettings;
 181
 182
 183 static inline void Help1 (GtkWidget *w, gpointer data)
 184 {
 185   gchar *indx = g_strdup_printf ("/help/%s/index.html", xgnokiiConfig.locale);
 186   Help (w, indx);
 187   g_free (indx);
 188 }
 189
 190
 191 void GUI_InitCallerGroupsInf (void)
 192 {
 193   D_CallerGroup *cg;
 194   PhoneEvent *e;
 195   register gint i;
 196
 197   if (CallersGroupsInitialized)
 198     return;
 199
 200   gtk_label_set_text (GTK_LABEL (infoDialog.text), _("Reading caller groups names ..."));
 201   gtk_widget_show_now (infoDialog.dialog);
 202   GUI_Refresh ();
 203
 204   xgnokiiConfig.callerGroups[0] = g_strndup( _("Familly"), MAX_CALLER_GROUP_LENGTH);
 205   xgnokiiConfig.callerGroups[1] = g_strndup( _("VIP"), MAX_CALLER_GROUP_LENGTH);
 206   xgnokiiConfig.callerGroups[2] = g_strndup( _("Friends"), MAX_CALLER_GROUP_LENGTH);
 207   xgnokiiConfig.callerGroups[3] = g_strndup( _("Colleagues"), MAX_CALLER_GROUP_LENGTH);
 208   xgnokiiConfig.callerGroups[4] = g_strndup( _("Other"), MAX_CALLER_GROUP_LENGTH);
 209   xgnokiiConfig.callerGroups[5] = g_strndup( _("No group"), MAX_CALLER_GROUP_LENGTH);
 210
 211   if (phoneMonitor.supported & PM_CALLERGROUP)
 212     for (i = 0; i < 5; i++)
 213     {
 214       cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
 215       cg->number = i;
 216       e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 217       e->event = Event_GetCallerGroup;
 218       e->data = cg;
 219       GUI_InsertEvent (e);
 220       pthread_mutex_lock (&callerGroupMutex);
 221       pthread_cond_wait (&callerGroupCond, &callerGroupMutex);
 222       pthread_mutex_unlock (&callerGroupMutex);
 223
 224       if (*cg->text != '\0' && cg->status == GE_NONE)
 225       {
 226         g_free (xgnokiiConfig.callerGroups[i]);
 227         xgnokiiConfig.callerGroups[i] = g_strndup (cg->text, MAX_CALLER_GROUP_LENGTH);
 228       }
 229       g_free (cg);
 230     }
 231
 232   CallersGroupsInitialized = TRUE;
 233   gtk_widget_hide (infoDialog.dialog);
 234   GUIEventSend (GUI_EVENT_CALLERS_GROUPS_CHANGED);
 235 }
 236
 237
 238 static inline void DrawBackground (GtkWidget *data)
 239 {
 240   gdk_draw_pixmap (Pixmap,
 241                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 242                    BackgroundPixmap,
 243                    0, 0,
 244                    0, 0,
 245                    261, 96);
 246 }
 247
 248
 249 int network_levels[] = {
 250   152, 69, 11, 3,
 251   138, 69, 11, 3,
 252   124, 69, 11, 4,
 253   110, 69, 11, 6
 254 };
 255
 256
 257 static inline void DrawNetwork (GtkWidget *data, int rflevel)
 258 {
 259   int i;
 260
 261   if (rflevel > 100)
 262     rflevel = 100;
 263   for (i = 0; (i * 25) <= rflevel; i++)
 264   {
 265     float percent = ((float) rflevel - i * 25) / 25;
 266
 267     if (percent > 1)
 268       percent = 1;
 269     gdk_draw_rectangle (Pixmap, GTK_WIDGET (data)->style->white_gc, TRUE,
 270                         network_levels[4 * i] + network_levels[4 * i + 2] * (1 - percent),
 271                         network_levels[4 * i + 1],
 272                         network_levels[4 * i + 2] * percent,
 273                         network_levels[4 * i + 3]);
 274   }
 275 }
 276
 277
 278 int battery_levels[] = {
 279   50, 69, 11, 3,
 280   64, 69, 11, 3,
 281   78, 69, 11, 4,
 282   92, 69, 11, 6
 283 };
 284
 285
 286 static inline void DrawBattery (GtkWidget *data, int batterylevel)
 287 {
 288   int i;
 289
 290   if (batterylevel < 0)
 291     return;
 292   if (batterylevel > 100)
 293     batterylevel = 100;
 294   for (i = 0; (i * 25) <= batterylevel; i++)
 295   {
 296     float percent = ((float) batterylevel - i * 25) / 25;
 297     if (percent > 1)
 298       percent = 1;
 299     gdk_draw_rectangle (Pixmap, GTK_WIDGET (data)->style->white_gc, TRUE,
 300                         battery_levels[4 * i],
 301                         battery_levels[4 * i + 1],
 302                         battery_levels[4 * i + 2] * percent,
 303                         battery_levels[4 * i + 3]);
 304   }
 305 }
 306
 307
 308 static inline void DrawSMS (GtkWidget *data)
 309 {
 310   gdk_draw_pixmap (Pixmap,
 311                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 312                    SMSPixmap,
 313                    0, 0,
 314                    25, 47,
 315                    26, 7);
 316 }
 317
 318
 319 static inline void DrawAlarm (GtkWidget *data)
 320 {
 321   gdk_draw_pixmap (Pixmap,
 322                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 323                    AlarmPixmap,
 324                    0, 0,
 325                    163, 11,
 326                    9, 9);
 327 }
 328
 329
 330 static inline void DrawText (GtkWidget *data, int at, char *text)
 331 {
 332   static GdkFont *Font;
 333
 334   Font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-90-*-*-*-*-iso8859-*");
 335   gdk_draw_string (Pixmap,
 336                    Font,
 337                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 338                    33, at, text);
 339 }
 340
 341
 342 static inline void DrawSMSReceived (GtkWidget *data)
 343 {
 344   DrawText (data, 25, _("Short Message received"));
 345 }
 346
 347
 348 static inline void DrawWorking (GtkWidget *data)
 349 {
 350   DrawText(data, 40, _("Working ..."));
 351 }
 352
 353
 354 static inline void HideCallDialog (GtkWidget *widget, gpointer data)
 355 {
 356   hiddenCallDialog = 1;
 357   gtk_widget_hide (GTK_WIDGET (data));
 358 }
 359
 360
 361 static void CreateInCallDialog (void)
 362 {
 363   GtkWidget *button, *hbox;
 364
 365   inCallDialog.dialog = gtk_dialog_new ();
 366   gtk_window_position (GTK_WINDOW (inCallDialog.dialog), GTK_WIN_POS_MOUSE);
 367   gtk_window_set_title (GTK_WINDOW (inCallDialog.dialog), _("Call in progress"));
 368   gtk_container_set_border_width (GTK_CONTAINER (inCallDialog.dialog), 5);
 369   gtk_signal_connect (GTK_OBJECT (inCallDialog.dialog), "delete_event",
 370                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 371
 372   hbox = gtk_hbox_new (FALSE, 0);
 373   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (inCallDialog.dialog)->vbox), hbox, FALSE, FALSE, 5);
 374   gtk_widget_show (hbox);
 375
 376   inCallDialog.label = gtk_label_new ("");
 377   gtk_box_pack_start (GTK_BOX (hbox), inCallDialog.label, FALSE, FALSE, 0);
 378   gtk_widget_show (inCallDialog.label);
 379
 380   button = gtk_button_new_with_label (_("Hide"));
 381   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (inCallDialog.dialog)->action_area),
 382                       button, TRUE, FALSE, 0);
 383   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 384                       GTK_SIGNAL_FUNC (HideCallDialog), (gpointer) inCallDialog.dialog);
 385   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 386   gtk_widget_grab_default (button);
 387   gtk_widget_show (button);
 388 }
 389
 390
 391 static gint Update (gpointer data)
 392 {
 393   static gchar lastCallNum[20] = "";
 394   static gchar callBuf[80];
 395   static gchar timeBuf[10];
 396   static gchar *anonym = "anonymous";
 397   static struct tm stm;
 398   static gint smsNumber = 0;
 399   static gint callTimerStart = 0;
 400   gint callTimer = 0;
 401   time_t t;
 402   static gchar *name;
 403   static bool outgoing = TRUE;
 404
 405
 406   /* The number of SMS messages before second */
 407   static int smsold=0;
 408
 409   /* The number of second for we should display "Short Message Received" message */
 410   static int smsreceived=-1;
 411
 412   DrawBackground (data);
 413
 414   DrawNetwork (data, phoneMonitor.rfLevel);
 415
 416   DrawBattery (data, phoneMonitor.batteryLevel);
 417
 418   if (phoneMonitor.alarm)
 419     DrawAlarm (data);
 420
 421   if (phoneMonitor.working)
 422     DrawText (data, 25, phoneMonitor.working);
 423
 424   pthread_mutex_lock (&smsMutex);
 425   if (phoneMonitor.sms.unRead > 0)
 426   {
 427     DrawSMS (data);
 428
 429     if (phoneMonitor.sms.unRead > smsold && smsold != -1)
 430       smsreceived = 10;  /* The message "Short Message Received" is displayed for 10s */
 431   }
 432   if (smsNumber != phoneMonitor.sms.number)
 433     GUIEventSend (GUI_EVENT_SMS_NUMBER_CHANGED);
 434
 435   smsold = phoneMonitor.sms.unRead;
 436
 437   smsNumber = phoneMonitor.sms.number;
 438
 439   pthread_mutex_unlock (&smsMutex);
 440
 441   if (smsreceived >= 0)
 442   {
 443     DrawSMSReceived (data);
 444     smsreceived--;
 445   }
 446
 447   pthread_mutex_lock (&callMutex);
 448   if (phoneMonitor.call.callInProgress != CS_Idle)
 449   {
 450     if (phoneMonitor.call.callInProgress == CS_InProgress)
 451     {
 452       if (!callTimerStart)
 453         callTimerStart = callTimer = time (NULL);
 454       else
 455         callTimer = time (NULL);
 456     }
 457
 458     if (phoneMonitor.call.callInProgress == CS_Waiting)
 459     {
 460       outgoing = FALSE;
 461
 462       if (*phoneMonitor.call.callNum == '\0')
 463         name = anonym;
 464       else if (strncmp (phoneMonitor.call.callNum, lastCallNum, 20))
 465       {
 466         strncpy (lastCallNum, phoneMonitor.call.callNum, 20);
 467         lastCallNum[19] = '\0';
 468         name = GUI_GetName (phoneMonitor.call.callNum);
 469         if (!name)
 470           name = phoneMonitor.call.callNum;
 471       }
 472     }
 473     t = (time_t) difftime (callTimer, callTimerStart);
 474     (void) gmtime_r (&t, &stm);
 475     strftime (timeBuf, 10, "%T", &stm);
 476     if (outgoing)
 477       g_snprintf (callBuf, 80, _("Outgoing call in progress:\nTime: %s"),
 478                   timeBuf);
 479     else
 480       g_snprintf (callBuf, 80, _("Incomming call from: %s\nTime: %s"),
 481                   name, timeBuf);
 482
 483     gtk_label_set_text (GTK_LABEL (inCallDialog.label), callBuf);
 484     if (!GTK_WIDGET_VISIBLE (inCallDialog.dialog) && !hiddenCallDialog)
 485       gtk_widget_show (inCallDialog.dialog);
 486   }
 487   else
 488   {
 489     callTimerStart = callTimer = 0;
 490     *lastCallNum = '\0';
 491     outgoing = TRUE;
 492     if (GTK_WIDGET_VISIBLE (inCallDialog.dialog))
 493       gtk_widget_hide (inCallDialog.dialog);
 494     hiddenCallDialog = 0;
 495   }
 496   pthread_mutex_unlock (&callMutex);
 497
 498   gtk_widget_draw (data,NULL);
 499
 500   GUIEventSend (GUI_EVENT_NETMON_CHANGED);
 501
 502   return TRUE;
 503 }
 504
 505
 506 /* Redraw the screen from the backing pixmap */
 507 static inline gint ExposeEvent (GtkWidget *widget, GdkEventExpose *event)
 508 {
 509   gdk_draw_pixmap (widget->window,
 510                    widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 511                    Pixmap,
 512                    event->area.x, event->area.y,
 513                    event->area.x, event->area.y,
 514                    event->area.width, event->area.height);
 515
 516   return FALSE;
 517 }
 518
 519
 520 static void ParseSMSCenters (void)
 521 {
 522   register gint i;
 523   register gint j;
 524
 525   gtk_clist_freeze (GTK_CLIST (SMSClist));
 526
 527   gtk_clist_clear (GTK_CLIST (SMSClist));
 528
 529   for (i = 0; i < xgnokiiConfig.smsSets; i++)
 530   {
 531     gchar *row[4];
 532     if (*(configDialogData.sms.smsSetting[i].Name) == '\0')
 533       row[0] = g_strdup_printf (_("Set %d"), i + 1);
 534     else
 535       row[0] = g_strdup (configDialogData.sms.smsSetting[i].Name);
 536
 537     row[1] = g_strdup (configDialogData.sms.smsSetting[i].Number);
 538
 539     switch (configDialogData.sms.smsSetting[i].Format)
 540     {
 541     case SMS_FText:
 542         row[2] = g_strdup (_("Text"));
 543         break;
 544
 545     case SMS_FPaging:
 546         row[2] = g_strdup (_("Paging"));
 547         break;
 548
 549     case SMS_FFax:
 550         row[2] = g_strdup (_("Fax"));
 551         break;
 552
 553     case SMS_FEmail:
 554     case SMS_FUCI:
 555         row[2] = g_strdup (_("E-Mail"));
 556         break;
 557
 558     case SMS_FERMES:
 559         row[2] = g_strdup (_("ERMES"));
 560         break;
 561
 562     case SMS_FX400:
 563         row[2] = g_strdup (_("X.400"));
 564         break;
 565
 566     case SMS_FVoice:
 567         row[2] = g_strdup (_("Voice"));
 568         break;
 569
 570     default:
 571         row[2] = g_strdup (_("Text"));
 572         break;
 573     }
 574
 575     switch (configDialogData.sms.smsSetting[i].Validity)
 576     {
 577       case SMS_V1H:
 578         row[3] = g_strdup (_("1 h"));
 579         break;
 580
 581       case SMS_V6H:
 582         row[3] = g_strdup (_("6 h"));
 583         break;
 584
 585       case SMS_V24H:
 586         row[3] = g_strdup (_("24 h"));
 587         break;
 588
 589       case SMS_V72H:
 590         row[3] = g_strdup (_("72 h"));
 591         break;
 592
 593       case SMS_V1W:
 594         row[3] = g_strdup (_("1 week"));
 595         break;
 596
 597       case SMS_VMax:
 598         row[3] = g_strdup (_("Max. time"));
 599         break;
 600
 601       default:
 602         row[3] = g_strdup (_("24 h"));
 603         break;
 604     }
 605
 606     gtk_clist_append( GTK_CLIST (SMSClist), row);
 607
 608     for (j = 0; j < 4; j++)
 609       g_free (row[j]);
 610   }
 611
 612   gtk_clist_thaw (GTK_CLIST (SMSClist));
 613 }
 614
 615
 616 static void RefreshUserStatus (void)
 617 {
 618   gchar buf[8];
 619   configDialogData.user.used = GTK_ENTRY (configDialogData.user.name)->text_length
 620                              + GTK_ENTRY (configDialogData.user.title)->text_length
 621                              + GTK_ENTRY (configDialogData.user.company)->text_length
 622                              + GTK_ENTRY (configDialogData.user.telephone)->text_length
 623                              + GTK_ENTRY (configDialogData.user.fax)->text_length
 624                              + GTK_ENTRY (configDialogData.user.email)->text_length
 625                              + GTK_ENTRY (configDialogData.user.address)->text_length;
 626   configDialogData.user.max = MAX_BUSINESS_CARD_LENGTH;
 627   if (GTK_ENTRY (configDialogData.user.telephone)->text_length > 0)
 628     configDialogData.user.max -= 4;
 629   if (GTK_ENTRY (configDialogData.user.fax)->text_length > 0)
 630     configDialogData.user.max -= 4;
 631   g_snprintf (buf, 8, "%d/%d", configDialogData.user.used, configDialogData.user.max);
 632   gtk_label_set_text (GTK_LABEL (configDialogData.user.status), buf);
 633 }
 634
 635
 636 void GUI_InitSMSSettings (void)
 637 {
 638   PhoneEvent *e;
 639   D_SMSCenter *c;
 640   register gint i;
 641
 642   if (SMSSettingsInitialized)
 643     return;
 644
 645   gtk_label_set_text (GTK_LABEL (infoDialog.text), _("Reading SMS centers ..."));
 646   gtk_widget_show_now (infoDialog.dialog);
 647   GUI_Refresh ();
 648
 649   for (i = 1; i <= MAX_SMS_CENTER; i++)
 650   {
 651     xgnokiiConfig.smsSetting[i - 1].No = i;
 652     c = (D_SMSCenter *) g_malloc (sizeof (D_SMSCenter));
 653     c->center = &(xgnokiiConfig.smsSetting[i - 1]);
 654
 655     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 656     e->event = Event_GetSMSCenter;
 657     e->data = c;
 658     GUI_InsertEvent (e);
 659     pthread_mutex_lock (&smsCenterMutex);
 660     pthread_cond_wait (&smsCenterCond, &smsCenterMutex);
 661     pthread_mutex_unlock (&smsCenterMutex);
 662
 663     if (c->status != GE_NONE)
 664       break;
 665
 666     g_free (c);
 667
 668     configDialogData.sms.smsSetting[i - 1] = xgnokiiConfig.smsSetting[i - 1];
 669   }
 670
 671   xgnokiiConfig.smsSets = i - 1;
 672
 673   ParseSMSCenters ();
 674
 675   SMSSettingsInitialized = TRUE;
 676
 677   gtk_widget_hide (infoDialog.dialog);
 678 }
 679
 680
 681 void GUI_ShowOptions (void)
 682 {
 683   PhoneEvent *e;
 684   D_Alarm *alarm;
 685   register gint i;
 686
 687   if (optionsDialogIsOpened)
 688     return;
 689
 690   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.port), xgnokiiConfig.port);
 691
 692   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.model), xgnokiiConfig.model);
 693
 694   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.init), xgnokiiConfig.initlength);
 695
 696   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.bindir), xgnokiiConfig.bindir);
 697
 698   if(!strcmp(xgnokiiConfig.connection, "serial")) {
 699     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.serial), TRUE);
 700   } else   if(!strcmp(xgnokiiConfig.connection, "infrared")) {
 701     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.infrared), TRUE);
 702   } else {
 703     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.irda), TRUE);
 704   }
 705
 706   /* Phone */
 707   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.model), phoneMonitor.phone.model);
 708
 709   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.version), phoneMonitor.phone.version);
 710
 711   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.revision), phoneMonitor.phone.revision);
 712
 713   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.imei), phoneMonitor.phone.imei);
 714
 715   gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen),
 716                              atof (xgnokiiConfig.maxSIMLen));
 717
 718   gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen),
 719                              atof (xgnokiiConfig.maxPhoneLen));
 720
 721   /* Alarm */
 722   alarm = (D_Alarm *) g_malloc (sizeof (D_Alarm));
 723   e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 724   e->event = Event_GetAlarm;
 725   e->data = alarm;
 726   GUI_InsertEvent (e);
 727   pthread_mutex_lock (&alarmMutex);
 728   pthread_cond_wait (&alarmCond, &alarmMutex);
 729   pthread_mutex_unlock (&alarmMutex);
 730
 731   if (alarm->status != GE_NONE)
 732   {
 733     xgnokiiConfig.alarmSupported = FALSE;
 734     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), FALSE);
 735     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), 0.0);
 736     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), 0.0);
 737   }
 738   else
 739   {
 740     xgnokiiConfig.alarmSupported = TRUE;
 741     if (alarm->time.AlarmEnabled)
 742       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), TRUE);
 743     else
 744       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), FALSE);
 745     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), alarm->time.Hour);
 746     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), alarm->time.Minute);
 747   }
 748   g_free (alarm);
 749
 750   /* SMS */
 751   if (phoneMonitor.supported & PM_SMS)
 752   {
 753     gtk_widget_show (sms_option_frame);
 754     GUI_InitSMSSettings ();
 755   }
 756   else
 757     gtk_widget_hide (sms_option_frame);
 758
 759
 760   /* BUSINESS CARD */
 761   if (phoneMonitor.supported & PM_SMS)
 762   {
 763     gtk_widget_show (user_option_frame);
 764
 765     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.name),
 766                         xgnokiiConfig.user.name);
 767     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.title),
 768                         xgnokiiConfig.user.title);
 769     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.company),
 770                         xgnokiiConfig.user.company);
 771     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.telephone),
 772                         xgnokiiConfig.user.telephone);
 773     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.fax),
 774                         xgnokiiConfig.user.fax);
 775     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.email),
 776                         xgnokiiConfig.user.email);
 777     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.address),
 778                         xgnokiiConfig.user.address);
 779
 780     RefreshUserStatus();
 781   }
 782   else
 783     gtk_widget_hide (user_option_frame);
 784
 785
 786   /* Groups */
 787   if (phoneMonitor.supported & PM_CALLERGROUP)
 788   {
 789     gtk_widget_show (cg_names_option_frame);
 790     GUI_InitCallerGroupsInf ();
 791     for ( i = 0; i < 6; i++)
 792       gtk_entry_set_text (GTK_ENTRY (configDialogData.groups[i]), xgnokiiConfig.callerGroups[i]);
 793   }
 794   else
 795     gtk_widget_hide (cg_names_option_frame);
 796
 797   /* Mail */
 798   if (phoneMonitor.supported & PM_SMS)
 799   {
 800     gtk_widget_show (mail_option_frame);
 801     gtk_entry_set_text (GTK_ENTRY (configDialogData.mailbox),
 802                         xgnokiiConfig.mailbox);;
 803   }
 804   else
 805     gtk_widget_hide (mail_option_frame);
 806
 807   /* Help */
 808   gtk_entry_set_text (GTK_ENTRY (configDialogData.help),
 809                       xgnokiiConfig.helpviewer);
 810
 811   optionsDialogIsOpened = TRUE;
 812   gtk_widget_show (OptionsDialog);
 813 }
 814
 815
 816 inline void GUI_ShowAbout (void)
 817 {
 818   gtk_widget_show (AboutDialog);
 819 }
 820
 821
 822 inline void GUI_HideAbout(void)
 823 {
 824   gtk_widget_hide (AboutDialog);
 825 }
 826
 827
 828 static void MainExit (void)
 829 {
 830   PhoneEvent *e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 831
 832   e->event = Event_Exit;
 833   e->data = NULL;
 834   GUI_InsertEvent (e);
 835   pthread_join (monitor_th, NULL);
 836   gtk_main_quit();
 837 }
 838
 839
 840 static void ShowMenu (GdkEventButton *event)
 841 {
 842   GdkEventButton *bevent = (GdkEventButton *) event;
 843
 844   if (phoneMonitor.supported & PM_KEYBOARD)
 845     gtk_widget_show (xkeyb_menu_item);
 846   else
 847     gtk_widget_hide (xkeyb_menu_item);
 848
 849   if (phoneMonitor.supported & PM_NETMONITOR)
 850     gtk_widget_show (netmon_menu_item);
 851   else
 852     gtk_widget_hide (netmon_menu_item);
 853
 854   if (phoneMonitor.supported & PM_SMS)
 855     gtk_widget_show (sms_menu_item);
 856   else
 857     gtk_widget_hide (sms_menu_item);
 858
 859   if (phoneMonitor.supported & PM_CALENDAR)
 860     gtk_widget_show (calendar_menu_item);
 861   else
 862     gtk_widget_hide (calendar_menu_item);
 863
 864   if (phoneMonitor.supported & PM_DTMF)
 865     gtk_widget_show (dtmf_menu_item);
 866   else
 867     gtk_widget_hide (dtmf_menu_item);
 868
 869   if (phoneMonitor.supported & PM_SPEEDDIAL)
 870     gtk_widget_show (speedDial_menu_item);
 871   else
 872     gtk_widget_hide (speedDial_menu_item);
 873
 874   if (phoneMonitor.supported & PM_DATA)
 875     gtk_widget_show (data_menu_item);
 876   else
 877     gtk_widget_hide (data_menu_item);
 878
 879   gtk_menu_popup (GTK_MENU (Menu), NULL, NULL, NULL, NULL,
 880                           bevent->button, bevent->time);
 881 }
 882
 883
 884 static gint ButtonPressEvent (GtkWidget *widget, GdkEventButton *event)
 885 {
 886   /* Left button */
 887   if (event->button == 1) {
 888
 889     /* Close */
 890     if (event->x >= 206 && event->x <= 221 &&
 891         event->y >=  42 && event->y <= 55)
 892     {
 893       if (GUI_ContactsIsChanged())
 894         GUI_QuitSaveContacts();
 895       else
 896         MainExit ();
 897     }
 898     else if ((event->x >= 180 && event->x <= 195 &&
 899              event->y >=  30 && event->y <= 50) ||
 900              (event->x >= 185 && event->x <= 215 &&
 901              event->y >=  15 && event->y <= 30))
 902     {
 903       GUI_ShowContacts ();
 904     }
 905     else if (event->x >= 190 && event->x <= 210 &&
 906              event->y >=  70 && event->y <= 85)
 907     {
 908       if (!phoneMonitor.supported & PM_SMS)
 909         phoneMonitor.working = _("SMS not supported!");
 910       else
 911         GUI_ShowSMS ();
 912     }
 913     else if (event->x >= 235 && event->x <= 248 &&
 914              event->y >=  27 && event->y <= 75)
 915     {
 916       if (!phoneMonitor.supported & PM_CALENDAR)
 917         phoneMonitor.working = _("Calendar not supported!");
 918       else
 919         GUI_ShowCalendar ();
 920     }
 921     else if (event->x >= 245 && event->x <= 258 &&
 922              event->y >=  83 && event->y <= 93)
 923     {
 924       GUI_ShowOptions();
 925     }
 926   } /* Right button */
 927   else if (event->button == 3)
 928     ShowMenu (event);
 929
 930   // g_print ("event->x: %f\n", event->x);
 931   // g_print ("event->y: %f\n", event->y);
 932
 933   return TRUE;
 934 }
 935
 936
 937 static void OptionsApplyCallback (GtkWidget *widget, gpointer data )
 938 {
 939   PhoneEvent *e;
 940   D_Alarm *alarm;
 941   register gint i;
 942
 943   /* Phone */
 944   max_phonebook_sim_name_length = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen));
 945   max_phonebook_name_length = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen));
 946   g_free (xgnokiiConfig.maxSIMLen);
 947   g_free (xgnokiiConfig.maxPhoneLen);
 948   xgnokiiConfig.maxSIMLen = g_strdup_printf ("%d", max_phonebook_sim_name_length);
 949   xgnokiiConfig.maxPhoneLen = g_strdup_printf ("%d", max_phonebook_name_length);
 950
 951   /* ALARM */
 952   /* From fbus-6110.c
 953      FIXME: we should also allow to set the alarm off :-) */
 954   if (xgnokiiConfig.alarmSupported
 955       && GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch)->active)
 956   {
 957     alarm = (D_Alarm *) g_malloc (sizeof (D_Alarm));
 958     alarm->time.Hour = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour));
 959     alarm->time.Minute = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin));
 960     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 961     e->event = Event_SetAlarm;
 962     e->data = alarm;
 963     GUI_InsertEvent (e);
 964   }
 965
 966   /* SMS */
 967   if (phoneMonitor.supported & PM_SMS)
 968   {
 969     for (i = 0; i < xgnokiiConfig.smsSets; i++)
 970       xgnokiiConfig.smsSetting[i] = configDialogData.sms.smsSetting[i];
 971     GUIEventSend (GUI_EVENT_SMS_CENTERS_CHANGED);
 972   }
 973
 974   /* BUSINESS CARD */
 975   if (phoneMonitor.supported & PM_SMS)
 976   {
 977     g_free(xgnokiiConfig.user.name);
 978     xgnokiiConfig.user.name = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.name)));
 979     g_free(xgnokiiConfig.user.title);
 980     xgnokiiConfig.user.title = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.title)));
 981     g_free(xgnokiiConfig.user.company);
 982     xgnokiiConfig.user.company = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.company)));
 983     g_free(xgnokiiConfig.user.telephone);
 984     xgnokiiConfig.user.telephone = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.telephone)));
 985     g_free(xgnokiiConfig.user.fax);
 986     xgnokiiConfig.user.fax = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.fax)));
 987     g_free(xgnokiiConfig.user.email);
 988     xgnokiiConfig.user.email = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.email)));
 989     g_free(xgnokiiConfig.user.address);
 990     xgnokiiConfig.user.address = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.address)));
 991   }
 992
 993   /* GROUPS */
 994   if (phoneMonitor.supported & PM_CALLERGROUP)
 995   {
 996     for ( i = 0; i < 6; i++)
 997     {
 998       strncpy(xgnokiiConfig.callerGroups[i],
 999               gtk_entry_get_text(GTK_ENTRY (configDialogData.groups[i])),
1000               MAX_CALLER_GROUP_LENGTH);
1001       xgnokiiConfig.callerGroups[i][MAX_CALLER_GROUP_LENGTH] = '\0';
1002     }
1003     GUIEventSend (GUI_EVENT_CALLERS_GROUPS_CHANGED);
1004     GUIEventSend (GUI_EVENT_CONTACTS_CHANGED);
1005   }
1006
1007   /* Mail */
1008   if (phoneMonitor.supported & PM_SMS)
1009   {
1010     g_free(xgnokiiConfig.mailbox);
1011     xgnokiiConfig.mailbox = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.mailbox)));
1012   }
1013
1014   /* Help */
1015   g_free(xgnokiiConfig.helpviewer);
1016   xgnokiiConfig.helpviewer = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.help)));
1017 }
1018
1019
1020 static void OptionsSaveCallback (GtkWidget *widget, gpointer data )
1021 {
1022   D_CallerGroup *cg;
1023   D_SMSCenter *c;
1024   PhoneEvent *e;
1025   register gint i;
1026
1027   //gtk_widget_hide(GTK_WIDGET(data));
1028   OptionsApplyCallback (widget, data);
1029   for (i = 0; i < xgnokiiConfig.smsSets; i++)
1030   {
1031     xgnokiiConfig.smsSetting[i].No = i + 1;
1032     c = (D_SMSCenter *) g_malloc (sizeof (D_SMSCenter));
1033     c->center = &(xgnokiiConfig.smsSetting[i]);
1034     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1035     e->event = Event_SetSMSCenter;
1036     e->data = c;
1037     GUI_InsertEvent (e);
1038   }
1039
1040   if (phoneMonitor.supported & PM_CALLERGROUP)
1041   {
1042     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1043     cg->number = 0;
1044     if (strcmp (xgnokiiConfig.callerGroups[0], _("Familly")) == 0)
1045       *cg->text = '\0';
1046     else
1047       strncpy (cg->text, xgnokiiConfig.callerGroups[0], 256);
1048     cg->text[255] = '\0';
1049     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1050     e->event = Event_SendCallerGroup;
1051     e->data = cg;
1052     GUI_InsertEvent (e);
1053
1054     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1055     cg->number = 1;
1056     if (strcmp (xgnokiiConfig.callerGroups[1], _("VIP")) == 0)
1057       *cg->text = '\0';
1058     else
1059       strncpy (cg->text, xgnokiiConfig.callerGroups[1], 256);
1060     cg->text[255] = '\0';
1061     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1062     e->event = Event_SendCallerGroup;
1063     e->data = cg;
1064     GUI_InsertEvent (e);
1065
1066     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1067     cg->number = 2;
1068     if (strcmp (xgnokiiConfig.callerGroups[2], _("Friends")) == 0)
1069       *cg->text = '\0';
1070     else
1071       strncpy (cg->text, xgnokiiConfig.callerGroups[2], 256);
1072     cg->text[255] = '\0';
1073     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1074     e->event = Event_SendCallerGroup;
1075     e->data = cg;
1076     GUI_InsertEvent (e);
1077
1078     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1079     cg->number = 3;
1080     if (strcmp (xgnokiiConfig.callerGroups[3], _("Colleagues")) == 0)
1081       *cg->text = '\0';
1082     else
1083       strncpy (cg->text, xgnokiiConfig.callerGroups[3], 256);
1084     cg->text[255] = '\0';
1085     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1086     e->event = Event_SendCallerGroup;
1087     e->data = cg;
1088     GUI_InsertEvent (e);
1089
1090     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1091     cg->number = 4;
1092     if (strcmp (xgnokiiConfig.callerGroups[4], _("Other")) == 0)
1093       *cg->text = '\0';
1094     else
1095       strncpy (cg->text, xgnokiiConfig.callerGroups[4], 256);
1096     cg->text[255] = '\0';
1097     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1098     e->event = Event_SendCallerGroup;
1099     e->data = cg;
1100     GUI_InsertEvent (e);
1101   }
1102
1103   if (GUI_SaveXConfig())
1104   {
1105     gtk_label_set_text (GTK_LABEL(errorDialog.text), _("Error writing configuration file!"));
1106     gtk_widget_show (errorDialog.dialog);
1107   }
1108 }
1109
1110
1111 static GtkWidget *CreateMenu (void)
1112 {
1113   GtkWidget *menu, *menu_items;
1114
1115   menu = gtk_menu_new ();
1116
1117   menu_items = gtk_menu_item_new_with_label (_("Contacts"));
1118   gtk_menu_append (GTK_MENU (menu), menu_items);
1119   gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
1120                              GTK_SIGNAL_FUNC (GUI_ShowContacts), NULL);
1121   gtk_widget_show (menu_items);
1122
1123   sms_menu_item = gtk_menu_item_new_with_label (_("SMS"));
1124   gtk_menu_append (GTK_MENU (menu), sms_menu_item);
1125   gtk_signal_connect_object (GTK_OBJECT (sms_menu_item), "activate",
1126                              GTK_SIGNAL_FUNC (GUI_ShowSMS), NULL);
1127
1128   calendar_menu_item = gtk_menu_item_new_with_label (_("Calendar"));
1129   gtk_menu_append (GTK_MENU (menu), calendar_menu_item);
1130   gtk_signal_connect_object (GTK_OBJECT (calendar_menu_item), "activate",
1131                              GTK_SIGNAL_FUNC (GUI_ShowCalendar), NULL);
1132
1133   logos_menu_item = gtk_menu_item_new_with_label (_("Logos"));
1134   gtk_menu_append (GTK_MENU (menu), logos_menu_item);
1135   gtk_signal_connect_object (GTK_OBJECT (logos_menu_item), "activate",
1136                              GTK_SIGNAL_FUNC (GUI_ShowLogosWindow), NULL);
1137   gtk_widget_show(logos_menu_item);
1138
1139   dtmf_menu_item = gtk_menu_item_new_with_label (_("DTMF"));
1140   gtk_menu_append (GTK_MENU (menu), dtmf_menu_item);
1141   gtk_signal_connect_object (GTK_OBJECT (dtmf_menu_item), "activate",
1142                              GTK_SIGNAL_FUNC (GUI_ShowDTMF), NULL);
1143
1144   speedDial_menu_item = gtk_menu_item_new_with_label (_("Speed Dial"));
1145   gtk_menu_append (GTK_MENU (menu), speedDial_menu_item);
1146   gtk_signal_connect_object (GTK_OBJECT (speedDial_menu_item), "activate",
1147                              GTK_SIGNAL_FUNC (GUI_ShowSpeedDial), NULL);
1148
1149   xkeyb_menu_item = gtk_menu_item_new_with_label (_("Keyboard"));
1150   gtk_menu_append (GTK_MENU (menu), xkeyb_menu_item);
1151   gtk_signal_connect_object (GTK_OBJECT (xkeyb_menu_item), "activate",
1152                              GTK_SIGNAL_FUNC (GUI_ShowXkeyb), NULL);
1153
1154   netmon_menu_item = gtk_menu_item_new_with_label (_("Net Monitor"));
1155   gtk_menu_append (GTK_MENU (menu), netmon_menu_item);
1156   gtk_signal_connect_object (GTK_OBJECT (netmon_menu_item), "activate",
1157                              GTK_SIGNAL_FUNC (GUI_ShowNetmon), NULL);
1158
1159   data_menu_item = gtk_menu_item_new_with_label (_("Data calls"));
1160   gtk_menu_append (GTK_MENU (menu), data_menu_item);
1161   gtk_signal_connect_object (GTK_OBJECT (data_menu_item), "activate",
1162                              GTK_SIGNAL_FUNC (GUI_ShowData), NULL);
1163
1164   menu_items = gtk_menu_item_new ();
1165   gtk_menu_append (GTK_MENU (menu), menu_items);
1166   gtk_widget_show (menu_items);
1167
1168   menu_items = gtk_menu_item_new_with_label (_("Options"));
1169   gtk_menu_append (GTK_MENU (menu), menu_items);
1170   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1171                              GTK_SIGNAL_FUNC(GUI_ShowOptions), NULL);
1172   gtk_widget_show (menu_items);
1173
1174   menu_items = gtk_menu_item_new ();
1175   gtk_menu_append (GTK_MENU (menu), menu_items);
1176   gtk_widget_show (menu_items);
1177
1178   menu_items = gtk_menu_item_new_with_label (_("Help"));
1179   gtk_menu_append (GTK_MENU (menu), menu_items);
1180   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1181                              GTK_SIGNAL_FUNC(Help1), NULL);
1182   gtk_widget_show (menu_items);
1183
1184   menu_items = gtk_menu_item_new_with_label (_("About"));
1185   gtk_menu_append (GTK_MENU (menu), menu_items);
1186   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1187                              GTK_SIGNAL_FUNC (GUI_ShowAbout), NULL);
1188   gtk_widget_show (menu_items);
1189
1190   return menu;
1191 }
1192
1193
1194 static GtkWidget *CreateAboutDialog (void)
1195 {
1196   GtkWidget *dialog;
1197   GtkWidget *button, *hbox, *label;
1198   gchar buf[2000];
1199
1200   dialog = gtk_dialog_new ();
1201   gtk_window_set_title (GTK_WINDOW (dialog), _("About"));
1202   gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1203   gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1204                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1205   button = gtk_button_new_with_label (_("Ok"));
1206   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1207                       button, TRUE, FALSE, 5);
1208   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1209                       GTK_SIGNAL_FUNC (GUI_HideAbout), NULL);
1210   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1211   gtk_widget_grab_default (button);
1212   gtk_widget_show (button);
1213
1214   hbox = gtk_hbox_new (FALSE, 0);
1215   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1216   gtk_widget_show (hbox);
1217
1218   g_snprintf (buf, 2000, _("xgnokii version: %s\ngnokii version: %s\n\n\
1219 Copyright (C) 1999,2000 Pavel Janík ml.,\nHugh Blemings, Jan Derfinak and others\n\
1220 xgnokii is free software, covered by the GNU General Public License, and you are\n\
1221 welcome to change it and/or distribute copies of it under certain conditions.\n\
1222 There is absolutely no waranty for xgnokii. See GPL for details.\n"),
1223               XVERSION, VERSION);
1224   label = gtk_label_new ((gchar *) buf);
1225   gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
1226   gtk_widget_show (label);
1227
1228   return dialog;
1229 }
1230
1231
1232 static inline void SetFormat (GtkWidget *item, gpointer data)
1233 {
1234   tempMessageSettings.Format = GPOINTER_TO_INT (data);
1235 }
1236
1237
1238 static inline void SetValidity (GtkWidget *item, gpointer data)
1239 {
1240   tempMessageSettings.Validity = GPOINTER_TO_INT (data);
1241 }
1242
1243
1244 static inline void OptionsDeleteEvent (GtkWidget *widget, GdkEvent *event, gpointer data )
1245 {
1246   gtk_widget_hide( GTK_WIDGET (widget));
1247   optionsDialogIsOpened = FALSE;
1248 }
1249
1250
1251 static inline void OptionsCloseCallback (GtkWidget *widget, gpointer data )
1252 {
1253   gtk_widget_hide(GTK_WIDGET(data));
1254   optionsDialogIsOpened = FALSE;
1255 }
1256
1257
1258 static gint CheckInUserDataLength (GtkWidget *widget,
1259                                    GdkEvent  *event,
1260                                    gpointer   callback_data)
1261 {
1262   register gint len;
1263
1264   len = configDialogData.user.max - (GTK_ENTRY (configDialogData.user.name)->text_length
1265       + GTK_ENTRY (configDialogData.user.title)->text_length
1266       + GTK_ENTRY (configDialogData.user.company)->text_length
1267       + GTK_ENTRY (configDialogData.user.telephone)->text_length
1268       + GTK_ENTRY (configDialogData.user.fax)->text_length
1269       + GTK_ENTRY (configDialogData.user.email)->text_length
1270       + GTK_ENTRY (configDialogData.user.address)->text_length
1271       - GTK_ENTRY (widget)->text_length);
1272
1273   if (len < 1)
1274   {
1275     gtk_entry_set_editable (GTK_ENTRY (widget), FALSE);
1276     return (FALSE);
1277   }
1278   else
1279     gtk_entry_set_editable (GTK_ENTRY (widget), TRUE);
1280   if (GPOINTER_TO_INT (callback_data) == 3
1281       || GPOINTER_TO_INT (callback_data) == 4)
1282   {
1283     if ((GPOINTER_TO_INT (callback_data) == 3
1284         && GTK_ENTRY (configDialogData.user.telephone)->text_length == 0)
1285         || (GPOINTER_TO_INT (callback_data) == 4
1286         && GTK_ENTRY (configDialogData.user.fax)->text_length == 0))
1287       len -= 4;
1288
1289     if (len < 1)
1290     {
1291       gtk_entry_set_editable (GTK_ENTRY (widget), FALSE);
1292       return (FALSE);
1293     }
1294
1295     if (len > max_phonebook_number_length)
1296       len = max_phonebook_number_length;
1297   }
1298
1299   gtk_entry_set_max_length (GTK_ENTRY (widget), len);
1300   return (FALSE);
1301 }
1302
1303
1304 static inline gint CheckOutUserDataLength (GtkWidget *widget,
1305                                            GdkEvent  *event,
1306                                            gpointer   callback_data)
1307 {
1308   gtk_entry_set_max_length (GTK_ENTRY (widget), GPOINTER_TO_INT (callback_data));
1309   return (FALSE);
1310 }
1311
1312
1313 static inline gint RefreshUserStatusCallBack (GtkWidget   *widget,
1314                                               GdkEventKey *event,
1315                                               gpointer     callback_data)
1316 {
1317   RefreshUserStatus ();
1318   if (GTK_EDITABLE (widget)->editable == FALSE)
1319     return (FALSE);
1320   if (event->keyval == GDK_BackSpace || event->keyval == GDK_Clear ||
1321       event->keyval == GDK_Insert || event->keyval == GDK_Delete ||
1322       event->keyval == GDK_Home || event->keyval == GDK_End ||
1323       event->keyval == GDK_Left || event->keyval == GDK_Right ||
1324       event->keyval == GDK_Return ||
1325       (event->keyval >= 0x20 && event->keyval <= 0xFF))
1326     return (TRUE);
1327
1328   return (FALSE);
1329 }
1330
1331
1332 static void OkEditSMSSetDialog (GtkWidget *w, gpointer data)
1333 {
1334
1335   strncpy(configDialogData.sms.smsSetting
1336           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name,
1337           gtk_entry_get_text(GTK_ENTRY (configDialogData.sms.set)),
1338           GSM_MAX_SMS_CENTER_NAME_LENGTH);
1339   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name[GSM_MAX_SMS_CENTER_NAME_LENGTH - 1]
1340     = '\0';
1341
1342   strncpy(configDialogData.sms.smsSetting
1343           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number,
1344           gtk_entry_get_text(GTK_ENTRY (configDialogData.sms.number)),
1345           GSM_MAX_SMS_CENTER_LENGTH);
1346   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number[GSM_MAX_SMS_CENTER_LENGTH]
1347     = '\0';
1348
1349   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Format
1350     = tempMessageSettings.Format;
1351
1352   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Validity
1353     = tempMessageSettings.Validity;
1354
1355   ParseSMSCenters ();
1356
1357   gtk_widget_hide (GTK_WIDGET (data));
1358 }
1359
1360
1361 static inline void EditSMSSetDialogClick (GtkWidget        *clist,
1362                                           gint              row,
1363                                           gint              column,
1364                                           GdkEventButton   *event,
1365                                           GtkWidget        *data )
1366 {
1367   if(event && event->type == GDK_2BUTTON_PRESS)
1368     gtk_signal_emit_by_name(GTK_OBJECT (data), "clicked");
1369 }
1370
1371
1372 static void ShowEditSMSSetDialog (GtkWidget *w, gpointer data)
1373 {
1374   static GtkWidget *dialog = NULL;
1375   GtkWidget *button, *label, *hbox, *menu, *item;
1376
1377   if (GTK_CLIST (SMSClist)->selection == NULL)
1378     return;
1379
1380   if (dialog == NULL)
1381   {
1382     dialog = gtk_dialog_new();
1383     gtk_window_set_title (GTK_WINDOW (dialog), _("Edit SMS Setting"));
1384     gtk_window_set_modal(GTK_WINDOW (dialog), TRUE);
1385     gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1386     gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1387                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1388
1389     button = gtk_button_new_with_label (_("Ok"));
1390     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1391                         button, TRUE, TRUE, 10);
1392     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1393                         GTK_SIGNAL_FUNC (OkEditSMSSetDialog), (gpointer) dialog);
1394     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1395     gtk_widget_grab_default (button);
1396     gtk_widget_show (button);
1397     button = gtk_button_new_with_label (_("Cancel"));
1398     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1399                         button, TRUE, TRUE, 10);
1400     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1401                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) dialog);
1402     gtk_widget_show (button);
1403
1404     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
1405
1406     hbox = gtk_hbox_new (FALSE, 0);
1407     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1408     gtk_widget_show (hbox);
1409
1410     label = gtk_label_new (_("Set's name:"));
1411     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
1412     gtk_widget_show (label);
1413
1414     configDialogData.sms.set = gtk_entry_new_with_max_length(GSM_MAX_SMS_CENTER_NAME_LENGTH - 1);
1415     gtk_widget_set_usize (configDialogData.sms.set, 110, 22);
1416     gtk_box_pack_end(GTK_BOX(hbox), configDialogData.sms.set, FALSE, FALSE, 2);
1417     gtk_widget_show (configDialogData.sms.set);
1418
1419     hbox = gtk_hbox_new (FALSE, 0);
1420     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1421     gtk_widget_show (hbox);
1422
1423     label = gtk_label_new (_("Center:"));
1424     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
1425     gtk_widget_show (label);
1426
1427     configDialogData.sms.number = gtk_entry_new_with_max_length(GSM_MAX_SMS_CENTER_LENGTH - 1);
1428     gtk_widget_set_usize (configDialogData.sms.number, 110, 22);
1429     gtk_box_pack_end(GTK_BOX(hbox), configDialogData.sms.number, FALSE, FALSE, 2);
1430     gtk_widget_show (configDialogData.sms.number);
1431
1432     hbox = gtk_hbox_new (FALSE, 0);
1433     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 9);
1434     gtk_widget_show (hbox);
1435
1436     label = gtk_label_new (_("Sending Format:"));
1437     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1438     gtk_widget_show (label);
1439
1440     configDialogData.sms.format = gtk_option_menu_new ();
1441     menu = gtk_menu_new ();
1442     gtk_widget_set_usize (configDialogData.sms.format, 110, 28);
1443
1444     item = gtk_menu_item_new_with_label (_("Text"));
1445     gtk_signal_connect (GTK_OBJECT (item), "activate",
1446                         GTK_SIGNAL_FUNC(SetFormat),
1447                         (gpointer) SMS_FText);
1448     gtk_widget_show (item);
1449     gtk_menu_append (GTK_MENU (menu), item);
1450
1451     item = gtk_menu_item_new_with_label (_("Fax"));
1452     gtk_signal_connect (GTK_OBJECT (item), "activate",
1453                         GTK_SIGNAL_FUNC(SetFormat),
1454                         (gpointer) SMS_FFax);
1455     gtk_widget_show (item);
1456     gtk_menu_append (GTK_MENU (menu), item);
1457
1458     item = gtk_menu_item_new_with_label (_("Paging"));
1459     gtk_signal_connect (GTK_OBJECT (item), "activate",
1460                         GTK_SIGNAL_FUNC(SetFormat),
1461                         (gpointer) SMS_FPaging);
1462     gtk_widget_show (item);
1463     gtk_menu_append (GTK_MENU (menu), item);
1464
1465     item = gtk_menu_item_new_with_label (_("E-Mail"));
1466     gtk_signal_connect (GTK_OBJECT (item), "activate",
1467                         GTK_SIGNAL_FUNC(SetFormat),
1468                         (gpointer) SMS_FEmail);
1469     gtk_widget_show (item);
1470     gtk_menu_append (GTK_MENU (menu), item);
1471
1472     gtk_option_menu_set_menu (GTK_OPTION_MENU (configDialogData.sms.format), menu);
1473     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.sms.format, FALSE, FALSE, 2);
1474     gtk_widget_show (configDialogData.sms.format);
1475
1476     hbox = gtk_hbox_new (FALSE, 0);
1477     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 9);
1478     gtk_widget_show (hbox);
1479
1480     label = gtk_label_new (_("Validity Period:"));
1481     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1482     gtk_widget_show (label);
1483
1484     configDialogData.sms.validity = gtk_option_menu_new ();
1485     menu = gtk_menu_new ();
1486     gtk_widget_set_usize (configDialogData.sms.validity, 110, 28);
1487
1488     item = gtk_menu_item_new_with_label (_("Max. Time"));
1489     gtk_signal_connect (GTK_OBJECT (item), "activate",
1490                         GTK_SIGNAL_FUNC(SetValidity),
1491                         (gpointer) SMS_VMax);
1492     gtk_widget_show (item);
1493     gtk_menu_append (GTK_MENU (menu), item);
1494
1495     item = gtk_menu_item_new_with_label (_("1 h"));
1496     gtk_signal_connect (GTK_OBJECT (item), "activate",
1497                         GTK_SIGNAL_FUNC(SetValidity),
1498                         (gpointer) SMS_V1H);
1499     gtk_widget_show (item);
1500     gtk_menu_append (GTK_MENU (menu), item);
1501
1502     item = gtk_menu_item_new_with_label (_("6 h"));
1503     gtk_signal_connect (GTK_OBJECT (item), "activate",
1504                         GTK_SIGNAL_FUNC(SetValidity),
1505                         (gpointer) SMS_V6H);
1506     gtk_widget_show (item);
1507     gtk_menu_append (GTK_MENU (menu), item);
1508
1509     item = gtk_menu_item_new_with_label (_("24 h"));
1510     gtk_signal_connect (GTK_OBJECT (item), "activate",
1511                         GTK_SIGNAL_FUNC(SetValidity),
1512                         (gpointer) SMS_V24H);
1513     gtk_widget_show (item);
1514     gtk_menu_append (GTK_MENU (menu), item);
1515
1516     item = gtk_menu_item_new_with_label (_("72 h"));
1517     gtk_signal_connect (GTK_OBJECT (item), "activate",
1518                         GTK_SIGNAL_FUNC(SetValidity),
1519                         (gpointer) SMS_V72H);
1520     gtk_widget_show (item);
1521     gtk_menu_append (GTK_MENU (menu), item);
1522
1523     item = gtk_menu_item_new_with_label (_("1 week"));
1524     gtk_signal_connect (GTK_OBJECT (item), "activate",
1525                         GTK_SIGNAL_FUNC(SetValidity),
1526                         (gpointer) SMS_V1W);
1527     gtk_widget_show (item);
1528     gtk_menu_append (GTK_MENU (menu), item);
1529
1530     gtk_option_menu_set_menu (GTK_OPTION_MENU (configDialogData.sms.validity), menu);
1531     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.sms.validity, FALSE, FALSE, 2);
1532     gtk_widget_show (configDialogData.sms.validity);
1533   }
1534
1535   gtk_entry_set_text (GTK_ENTRY (configDialogData.sms.set),
1536                       configDialogData.sms.smsSetting
1537                       [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name);
1538
1539   gtk_entry_set_text (GTK_ENTRY (configDialogData.sms.number),
1540                       configDialogData.sms.smsSetting
1541                       [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number);
1542
1543   switch (configDialogData.sms.smsSetting
1544           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Format)
1545   {
1546     case SMS_FText:
1547       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.format),
1548                                    0);
1549       break;
1550
1551     case SMS_FPaging:
1552       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.format),
1553                                    2);
1554       break;
1555
1556     case SMS_FFax:
1557       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.format),
1558                                    1);
1559       break;
1560
1561     case SMS_FEmail:
1562       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.format),
1563                                    3);
1564       break;
1565
1566     default:
1567       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.format),
1568                                    0);
1569   }
1570
1571   switch (configDialogData.sms.smsSetting
1572           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Validity)
1573   {
1574     case SMS_V1H:
1575       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1576                                    1);
1577       break;
1578
1579     case SMS_V6H:
1580       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1581                                    2);
1582       break;
1583
1584     case SMS_V24H:
1585       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1586                                    3);
1587       break;
1588
1589     case SMS_V72H:
1590       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1591                                    4);
1592       break;
1593
1594     case SMS_V1W:
1595       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1596                                    5);
1597       break;
1598
1599     case SMS_VMax:
1600       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1601                                    0);
1602       break;
1603
1604     default:
1605       gtk_option_menu_set_history (GTK_OPTION_MENU (configDialogData.sms.validity),
1606                                    3);
1607   }
1608
1609   tempMessageSettings.Format = configDialogData.sms.smsSetting
1610                [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Format;
1611   tempMessageSettings.Validity = configDialogData.sms.smsSetting
1612                [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Validity;
1613
1614   gtk_widget_show (dialog);
1615 }
1616
1617
1618 static GtkWidget *CreateOptionsDialog (void)
1619 {
1620   gchar labelBuffer[10];
1621   GtkWidget *dialog;
1622   GtkWidget *button, *hbox, *vbox, *label, *notebook, *frame, *clistScrolledWindow;
1623   register gint i;
1624   GtkAdjustment *adj;
1625   gchar *titles[4] = { _("Set's name"), _("Center number"), _("Format"), _("Validity")};
1626
1627   dialog = gtk_dialog_new ();
1628   gtk_window_set_title (GTK_WINDOW (dialog), _("Options"));
1629   gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1630   gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1631                       GTK_SIGNAL_FUNC (OptionsDeleteEvent), NULL);
1632
1633   button = gtk_button_new_with_label (_("Apply"));
1634   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1635                       button, TRUE, TRUE, 10);
1636   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1637                       GTK_SIGNAL_FUNC (OptionsApplyCallback), (gpointer)dialog);
1638   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1639   gtk_widget_grab_default (button);
1640   gtk_widget_show (button);
1641
1642   button = gtk_button_new_with_label (_("Save"));
1643   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1644                       button, TRUE, TRUE, 10);
1645   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1646                       GTK_SIGNAL_FUNC (OptionsSaveCallback), (gpointer)dialog);
1647   gtk_widget_show (button);
1648
1649   button = gtk_button_new_with_label (_("Close"));
1650   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1651                       button, TRUE, TRUE, 10);
1652   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1653                       GTK_SIGNAL_FUNC (OptionsCloseCallback), (gpointer)dialog);
1654   gtk_widget_show (button);
1655
1656   gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
1657
1658   notebook = gtk_notebook_new ();
1659   gtk_notebook_set_tab_pos (GTK_NOTEBOOK (notebook), GTK_POS_TOP);
1660   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), notebook);
1661   gtk_widget_show(notebook);
1662
1663   /***  Connection notebook  ***/
1664   frame = gtk_frame_new (_("Phone and connection type"));
1665   gtk_widget_show (frame);
1666
1667   vbox = gtk_vbox_new( FALSE, 0);
1668   gtk_container_add (GTK_CONTAINER (frame), vbox);
1669   gtk_widget_show (vbox);
1670
1671   label = gtk_label_new (_("Connection"));
1672   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
1673
1674   hbox = gtk_hbox_new (FALSE, 0);
1675   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1676   gtk_widget_show (hbox);
1677
1678   label = gtk_label_new (_("Port:"));
1679   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1680   gtk_widget_show (label);
1681
1682   configDialogData.connection.port = gtk_entry_new_with_max_length (10);
1683   gtk_widget_set_usize (configDialogData.connection.port, 220, 22);
1684   gtk_entry_set_editable (GTK_ENTRY (configDialogData.connection.port),
1685                           FALSE);
1686   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.port, FALSE, FALSE, 2);
1687   gtk_widget_show (configDialogData.connection.port);
1688
1689   hbox = gtk_hbox_new (FALSE, 0);
1690   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1691   gtk_widget_show (hbox);
1692
1693   label = gtk_label_new (_("Model:"));
1694   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1695   gtk_widget_show (label);
1696
1697   configDialogData.connection.model = gtk_entry_new_with_max_length (5);
1698   gtk_widget_set_usize (configDialogData.connection.model, 220, 22);
1699   gtk_entry_set_editable (GTK_ENTRY (configDialogData.connection.model),
1700                           FALSE);
1701   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.model, FALSE, FALSE, 2);
1702   gtk_widget_show (configDialogData.connection.model);
1703
1704   hbox = gtk_hbox_new (FALSE, 0);
1705   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1706   gtk_widget_show (hbox);
1707
1708   label = gtk_label_new (_("Init length:"));
1709   gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 2);
1710   gtk_widget_show (label);
1711
1712   configDialogData.connection.init = gtk_entry_new_with_max_length (100);
1713   gtk_widget_set_usize (configDialogData.connection.init, 220, 22);
1714   gtk_entry_set_editable (GTK_ENTRY (configDialogData.connection.init),
1715                           FALSE);
1716   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.init, FALSE, FALSE, 2);
1717   gtk_widget_show (configDialogData.connection.init);
1718
1719   hbox = gtk_hbox_new (FALSE, 0);
1720   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1721   gtk_widget_show (hbox);
1722
1723   label = gtk_label_new (_("Bindir:"));
1724   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1725   gtk_widget_show (label);
1726
1727   configDialogData.connection.bindir = gtk_entry_new_with_max_length (100);
1728   gtk_widget_set_usize (configDialogData.connection.bindir, 220, 22);
1729   gtk_entry_set_editable (GTK_ENTRY (configDialogData.connection.bindir),
1730                           FALSE);
1731   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.bindir, FALSE, FALSE, 2);
1732   gtk_widget_show (configDialogData.connection.bindir);
1733
1734   hbox = gtk_hbox_new (FALSE, 0);
1735   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1736   gtk_widget_show (hbox);
1737
1738   label = gtk_label_new (_("Connection:"));
1739   gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 2);
1740   gtk_widget_show (label);
1741
1742   configDialogData.connection.infrared = gtk_radio_button_new_with_label (NULL, _("infrared"));
1743   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.infrared, TRUE, FALSE, 2);
1744   gtk_widget_show (configDialogData.connection.infrared);
1745
1746   configDialogData.connection.serial = gtk_radio_button_new_with_label (
1747             gtk_radio_button_group (GTK_RADIO_BUTTON (configDialogData.connection.infrared)), _("serial"));
1748   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.serial, TRUE, FALSE, 2);
1749   gtk_widget_show (configDialogData.connection.serial);
1750
1751   configDialogData.connection.irda = gtk_radio_button_new_with_label (
1752             gtk_radio_button_group (GTK_RADIO_BUTTON (configDialogData.connection.infrared)), _("irda"));
1753   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.irda, TRUE, FALSE, 2);
1754   gtk_widget_show (configDialogData.connection.irda);
1755
1756   /***  Phone notebook  ***/
1757   frame = gtk_frame_new (_("Phone information"));
1758   gtk_widget_show (frame);
1759
1760   vbox = gtk_vbox_new( FALSE, 0);
1761   gtk_container_add (GTK_CONTAINER (frame), vbox);
1762   gtk_widget_show (vbox);
1763
1764   label = gtk_label_new (_("Phone"));
1765   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), frame, label);
1766
1767   hbox = gtk_hbox_new (FALSE, 0);
1768   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1769   gtk_widget_show (hbox);
1770
1771   label = gtk_label_new (_("Model:"));
1772   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1773   gtk_widget_show (label);
1774
1775   configDialogData.phone.model = gtk_entry_new_with_max_length (7);
1776   gtk_widget_set_usize (configDialogData.phone.model, 220, 22);
1777   gtk_entry_set_editable (GTK_ENTRY (configDialogData.phone.model),
1778                           FALSE);
1779   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.phone.model, FALSE, FALSE, 2);
1780   gtk_widget_show (configDialogData.phone.model);
1781
1782   hbox = gtk_hbox_new (FALSE, 0);
1783   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1784   gtk_widget_show (hbox);
1785
1786   label = gtk_label_new (_("Version:"));
1787   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1788   gtk_widget_show (label);
1789
1790   configDialogData.phone.version = gtk_entry_new_with_max_length (7);
1791   gtk_widget_set_usize (configDialogData.phone.version, 220, 22);
1792   gtk_entry_set_editable (GTK_ENTRY (configDialogData.phone.version),
1793                           FALSE);
1794   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.phone.version, FALSE, FALSE, 2);
1795   gtk_widget_show (configDialogData.phone.version);
1796
1797   hbox = gtk_hbox_new (FALSE, 0);
1798   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1799   gtk_widget_show (hbox);
1800
1801   label = gtk_label_new (_("Revision:"));
1802   gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 2);
1803   gtk_widget_show (label);
1804
1805   configDialogData.phone.revision = gtk_entry_new_with_max_length (64);
1806   gtk_widget_set_usize (configDialogData.phone.revision, 220, 22);
1807   gtk_entry_set_editable (GTK_ENTRY (configDialogData.phone.revision),
1808                           FALSE);
1809   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.phone.revision, FALSE, FALSE, 2);
1810   gtk_widget_show (configDialogData.phone.revision);
1811
1812   hbox = gtk_hbox_new (FALSE, 0);
1813   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1814   gtk_widget_show (hbox);
1815
1816   label = gtk_label_new (_("IMEI:"));
1817   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1818   gtk_widget_show (label);
1819
1820   configDialogData.phone.imei = gtk_entry_new_with_max_length (64);
1821   gtk_widget_set_usize (configDialogData.phone.imei, 220, 22);
1822   gtk_entry_set_editable (GTK_ENTRY (configDialogData.phone.imei),
1823                           FALSE);
1824   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.phone.imei, FALSE, FALSE, 2);
1825   gtk_widget_show (configDialogData.phone.imei);
1826
1827   hbox = gtk_hbox_new (FALSE, 0);
1828   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1829   gtk_widget_show (hbox);
1830
1831   label = gtk_label_new (_("Names length:"));
1832   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1833   gtk_widget_show (label);
1834
1835   hbox = gtk_hbox_new (FALSE, 0);
1836   gtk_container_add (GTK_CONTAINER (vbox), hbox);
1837   gtk_widget_show (hbox);
1838
1839   label = gtk_label_new (_("SIM:"));
1840   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1841   gtk_widget_show (label);
1842
1843   adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 1.0, 100.0, 1.0, 10.0, 0.0);
1844   configDialogData.phone.simNameLen = gtk_spin_button_new (adj, 0, 0);
1845   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen), TRUE);
1846   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen), TRUE);
1847   gtk_box_pack_start (GTK_BOX (hbox), configDialogData.phone.simNameLen, FALSE, FALSE, 2);
1848   gtk_widget_show (configDialogData.phone.simNameLen);
1849
1850   adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 1.0, 100.0, 1.0, 10.0, 0.0);
1851   configDialogData.phone.phoneNameLen = gtk_spin_button_new (adj, 0, 0);
1852   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen), TRUE);
1853   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen), TRUE);
1854   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.phone.phoneNameLen, FALSE, FALSE, 2);
1855   gtk_widget_show (configDialogData.phone.phoneNameLen);
1856
1857   label = gtk_label_new (_("Phone:"));
1858   gtk_box_pack_end (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1859   gtk_widget_show (label);
1860
1861   /***  Alarm notebook  ***/
1862   xgnokiiConfig.alarmSupported = TRUE;
1863
1864   frame = gtk_frame_new (_("Alarm setting"));
1865   gtk_widget_show (frame);
1866
1867   vbox = gtk_vbox_new( FALSE, 0);
1868   gtk_container_add (GTK_CONTAINER (frame), vbox);
1869   gtk_widget_show(vbox);
1870
1871   label = gtk_label_new (_("Alarm"));
1872   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), frame, label);
1873
1874   hbox = gtk_hbox_new (FALSE, 0);
1875   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 5);
1876   gtk_widget_show (hbox);
1877
1878   configDialogData.alarm.alarmSwitch = gtk_check_button_new_with_label (_("Alarm"));
1879   gtk_box_pack_start (GTK_BOX (hbox), configDialogData.alarm.alarmSwitch, FALSE, FALSE, 10);
1880   gtk_widget_show (configDialogData.alarm.alarmSwitch);
1881
1882   adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 23.0, 1.0, 4.0, 0.0);
1883   configDialogData.alarm.alarmHour = gtk_spin_button_new (adj, 0, 0);
1884   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), TRUE);
1885   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), TRUE);
1886   gtk_box_pack_start (GTK_BOX (hbox), configDialogData.alarm.alarmHour, FALSE, FALSE, 0);
1887   gtk_widget_show (configDialogData.alarm.alarmHour);
1888
1889   label = gtk_label_new (":");
1890   gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1891   gtk_widget_show (label);
1892
1893   adj = (GtkAdjustment *) gtk_adjustment_new (0.0, 0.0, 59.0, 1.0, 10.0, 0.0);
1894   configDialogData.alarm.alarmMin = gtk_spin_button_new (adj, 0, 0);
1895   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), TRUE);
1896   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), TRUE);
1897   gtk_box_pack_start (GTK_BOX (hbox), configDialogData.alarm.alarmMin, FALSE, FALSE, 0);
1898   gtk_widget_show (configDialogData.alarm.alarmMin);
1899
1900   /***  SMS notebook     ***/
1901   sms_option_frame = gtk_frame_new (_("Short Message Service"));
1902
1903   vbox = gtk_vbox_new (FALSE, 0);
1904   gtk_container_add (GTK_CONTAINER (sms_option_frame), vbox);
1905   gtk_widget_show (vbox);
1906
1907   label = gtk_label_new (_("SMS"));
1908   gtk_notebook_append_page (GTK_NOTEBOOK (notebook), sms_option_frame, label);
1909
1910   SMSClist = gtk_clist_new_with_titles (4, titles);
1911   gtk_clist_set_shadow_type (GTK_CLIST (SMSClist), GTK_SHADOW_OUT);
1912   gtk_clist_column_titles_passive (GTK_CLIST (SMSClist));
1913   gtk_clist_set_auto_sort (GTK_CLIST (SMSClist), FALSE);
1914
1915   gtk_clist_set_column_width (GTK_CLIST (SMSClist), 0, 70);
1916   gtk_clist_set_column_width (GTK_CLIST (SMSClist), 1, 115);
1917   gtk_clist_set_column_width (GTK_CLIST (SMSClist), 2, 40);
1918   gtk_clist_set_column_width (GTK_CLIST (SMSClist), 3, 55);
1919 //  gtk_clist_set_column_justification (GTK_CLIST (SMSClist), 1, GTK_JUSTIFY_RIGHT);
1920
1921   clistScrolledWindow = gtk_scrolled_window_new (NULL, NULL);
1922   gtk_container_add (GTK_CONTAINER (clistScrolledWindow), SMSClist);
1923   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clistScrolledWindow),
1924                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1925   gtk_box_pack_start (GTK_BOX (vbox), clistScrolledWindow,
1926                       TRUE, TRUE, 10);
1927
1928   gtk_widget_show (SMSClist);
1929   gtk_widget_show (clistScrolledWindow);
1930
1931   hbox = gtk_hbox_new (FALSE, 0);
1932   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 9);
1933   gtk_widget_show (hbox);
1934
1935   button = gtk_button_new_with_label (_("Edit"));
1936   gtk_box_pack_start (GTK_BOX (hbox),
1937                       button, TRUE, FALSE, 0);
1938   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1939                       GTK_SIGNAL_FUNC (ShowEditSMSSetDialog), (gpointer)dialog);
1940   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1941   gtk_widget_grab_default (button);
1942   gtk_widget_show (button);
1943
1944   gtk_signal_connect (GTK_OBJECT (SMSClist), "select_row",
1945                       GTK_SIGNAL_FUNC (EditSMSSetDialogClick),
1946                       (gpointer) button);
1947
1948   /***  Business notebook  ***/
1949   user_option_frame = gtk_frame_new (_("Business Card"));
1950
1951   vbox = gtk_vbox_new( FALSE, 0);
1952   gtk_container_add (GTK_CONTAINER (user_option_frame), vbox);
1953   gtk_widget_show(vbox);
1954
1955   label = gtk_label_new(_("User"));
1956   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), user_option_frame, label);
1957
1958   hbox = gtk_hbox_new (FALSE, 0);
1959   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
1960   gtk_widget_show (hbox);
1961
1962   configDialogData.user.status = gtk_label_new ("");
1963   gtk_box_pack_end(GTK_BOX(hbox), configDialogData.user.status, FALSE, FALSE, 2);
1964   gtk_widget_show (configDialogData.user.status);
1965
1966   configDialogData.user.max = MAX_BUSINESS_CARD_LENGTH;
1967   configDialogData.user.used = 0;
1968
1969   hbox = gtk_hbox_new (FALSE, 0);
1970   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
1971   gtk_widget_show (hbox);
1972
1973   label = gtk_label_new (_("Name:"));
1974   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
1975   gtk_widget_show (label);
1976
1977   configDialogData.user.name = gtk_entry_new_with_max_length(configDialogData.user.max);
1978   gtk_widget_set_usize (configDialogData.user.name, 220, 22);
1979   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.name),
1980                       "key_press_event",
1981                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
1982   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.name),
1983                       "button_press_event",
1984                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
1985   gtk_signal_connect (GTK_OBJECT (configDialogData.user.name),
1986                       "focus_in_event",
1987                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 0);
1988   gtk_signal_connect (GTK_OBJECT (configDialogData.user.name),
1989                       "focus_out_event",
1990                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
1991                       (gpointer) configDialogData.user.max);
1992   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.name, FALSE, FALSE, 2);
1993   gtk_widget_show (configDialogData.user.name);
1994
1995   hbox = gtk_hbox_new (FALSE, 0);
1996   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
1997   gtk_widget_show (hbox);
1998
1999   label = gtk_label_new (_("Title:"));
2000   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2001   gtk_widget_show (label);
2002
2003   configDialogData.user.title = gtk_entry_new_with_max_length(configDialogData.user.max);
2004   gtk_widget_set_usize (configDialogData.user.title, 220, 22);
2005   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.title),
2006                       "key_press_event",
2007                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2008   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.title),
2009                       "button_press_event",
2010                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2011   gtk_signal_connect (GTK_OBJECT (configDialogData.user.title),
2012                       "focus_in_event",
2013                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 1);
2014   gtk_signal_connect (GTK_OBJECT (configDialogData.user.title),
2015                       "focus_out_event",
2016                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2017                       (gpointer) configDialogData.user.max);
2018   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.title, FALSE, FALSE, 2);
2019   gtk_widget_show (configDialogData.user.title);
2020
2021   hbox = gtk_hbox_new (FALSE, 0);
2022   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2023   gtk_widget_show (hbox);
2024
2025   label = gtk_label_new (_("Company:"));
2026   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2027   gtk_widget_show (label);
2028
2029   configDialogData.user.company = gtk_entry_new_with_max_length(configDialogData.user.max);
2030   gtk_widget_set_usize (configDialogData.user.company, 220, 22);
2031   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.company),
2032                       "key_press_event",
2033                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2034   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.company),
2035                       "button_press_event",
2036                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2037   gtk_signal_connect (GTK_OBJECT (configDialogData.user.company),
2038                       "focus_in_event",
2039                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 2);
2040   gtk_signal_connect (GTK_OBJECT (configDialogData.user.company),
2041                       "focus_out_event",
2042                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2043                       (gpointer) configDialogData.user.max);
2044   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.company, FALSE, FALSE, 2);
2045   gtk_widget_show (configDialogData.user.company);
2046
2047   hbox = gtk_hbox_new (FALSE, 0);
2048   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2049   gtk_widget_show (hbox);
2050
2051   label = gtk_label_new (_("Telephone:"));
2052   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2053   gtk_widget_show (label);
2054
2055   configDialogData.user.telephone = gtk_entry_new_with_max_length(max_phonebook_number_length);
2056   gtk_widget_set_usize (configDialogData.user.telephone, 220, 22);
2057   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.telephone),
2058                       "key_press_event",
2059                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2060   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.telephone),
2061                       "button_press_event",
2062                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2063   gtk_signal_connect (GTK_OBJECT (configDialogData.user.telephone),
2064                       "focus_in_event",
2065                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 3);
2066   gtk_signal_connect (GTK_OBJECT (configDialogData.user.telephone),
2067                       "focus_out_event",
2068                       GTK_SIGNAL_FUNC(CheckOutUserDataLength), (gpointer) max_phonebook_number_length);
2069   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.telephone, FALSE, FALSE, 2);
2070   gtk_widget_show (configDialogData.user.telephone);
2071
2072   hbox = gtk_hbox_new (FALSE, 0);
2073   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2074   gtk_widget_show (hbox);
2075
2076   label = gtk_label_new (_("Fax:"));
2077   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2078   gtk_widget_show (label);
2079
2080   configDialogData.user.fax = gtk_entry_new_with_max_length(max_phonebook_number_length);
2081   gtk_widget_set_usize (configDialogData.user.fax, 220, 22);
2082   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.fax),
2083                       "key_press_event",
2084                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2085   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.fax),
2086                       "button_press_event",
2087                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2088   gtk_signal_connect (GTK_OBJECT (configDialogData.user.fax),
2089                       "focus_in_event",
2090                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 4);
2091   gtk_signal_connect (GTK_OBJECT (configDialogData.user.fax),
2092                       "focus_out_event",
2093                       GTK_SIGNAL_FUNC(CheckOutUserDataLength), (gpointer) max_phonebook_number_length);
2094   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.fax, FALSE, FALSE, 2);
2095   gtk_widget_show (configDialogData.user.fax);
2096
2097   hbox = gtk_hbox_new (FALSE, 0);
2098   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2099   gtk_widget_show (hbox);
2100
2101   label = gtk_label_new (_("E-Mail:"));
2102   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2103   gtk_widget_show (label);
2104
2105   configDialogData.user.email = gtk_entry_new_with_max_length(configDialogData.user.max);
2106   gtk_widget_set_usize (configDialogData.user.email, 220, 22);
2107   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.email),
2108                       "key_press_event",
2109                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2110   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.email),
2111                       "button_press_event",
2112                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2113   gtk_signal_connect (GTK_OBJECT (configDialogData.user.email),
2114                       "focus_in_event",
2115                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 5);
2116   gtk_signal_connect (GTK_OBJECT (configDialogData.user.email),
2117                       "focus_out_event",
2118                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2119                       (gpointer) configDialogData.user.max);
2120   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.email, FALSE, FALSE, 2);
2121   gtk_widget_show (configDialogData.user.email);
2122
2123   hbox = gtk_hbox_new (FALSE, 0);
2124   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2125   gtk_widget_show (hbox);
2126
2127   label = gtk_label_new (_("Address:"));
2128   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2129   gtk_widget_show (label);
2130
2131   configDialogData.user.address = gtk_entry_new_with_max_length(configDialogData.user.max);
2132   gtk_widget_set_usize (configDialogData.user.address, 220, 22);
2133   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.address),
2134                       "key_press_event",
2135                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2136   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.address),
2137                       "button_press_event",
2138                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2139   gtk_signal_connect (GTK_OBJECT (configDialogData.user.address),
2140                       "focus_in_event",
2141                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 6);
2142   gtk_signal_connect (GTK_OBJECT (configDialogData.user.address),
2143                       "focus_out_event",
2144                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2145                       (gpointer) configDialogData.user.max);
2146   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.address, FALSE, FALSE, 2);
2147   gtk_widget_show (configDialogData.user.address);
2148
2149
2150   /***  Groups notebook  ***/
2151   cg_names_option_frame = gtk_frame_new (_("Caller groups names"));
2152
2153
2154   vbox = gtk_vbox_new (FALSE, 0);
2155   gtk_container_add (GTK_CONTAINER (cg_names_option_frame), vbox);
2156   gtk_widget_show (vbox);
2157
2158   label = gtk_label_new (_("Groups"));
2159   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), cg_names_option_frame, label);
2160
2161   for ( i = 0; i < 6; i++)
2162   {
2163     hbox = gtk_hbox_new (FALSE, 0);
2164     gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 3);
2165     gtk_widget_show (hbox);
2166
2167     g_snprintf (labelBuffer, 10, _("Group %d:"), i + 1);
2168     label = gtk_label_new (labelBuffer);
2169     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
2170     gtk_widget_show (label);
2171
2172     configDialogData.groups[i] = gtk_entry_new_with_max_length (MAX_CALLER_GROUP_LENGTH);
2173     gtk_widget_set_usize (configDialogData.groups[i], 220, 22);
2174
2175     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.groups[i], FALSE, FALSE, 2);
2176     gtk_widget_show (configDialogData.groups[i]);
2177   }
2178
2179   /* Mail */
2180   mail_option_frame = gtk_frame_new (_("Mailbox"));
2181   gtk_widget_show (mail_option_frame);
2182
2183   vbox = gtk_vbox_new (FALSE, 0);
2184   gtk_container_add (GTK_CONTAINER (mail_option_frame), vbox);
2185   gtk_widget_show (vbox);
2186
2187   label = gtk_label_new (_("Mail"));
2188   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), mail_option_frame, label);
2189
2190   hbox = gtk_hbox_new (FALSE, 0);
2191   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2192   gtk_widget_show (hbox);
2193
2194   label = gtk_label_new (_("Path to mailbox:"));
2195   gtk_box_pack_start(GTK_BOX (hbox), label, FALSE, FALSE, 2);
2196   gtk_widget_show (label);
2197
2198   configDialogData.mailbox = gtk_entry_new_with_max_length (MAILBOX_LENGTH - 1);
2199   gtk_widget_set_usize (configDialogData.mailbox, 220, 22);
2200
2201   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.mailbox, FALSE, FALSE, 2);
2202   gtk_widget_show (configDialogData.mailbox);
2203
2204   /* Help */
2205   frame = gtk_frame_new (_("Help viewer"));
2206   gtk_widget_show (frame);
2207
2208   vbox = gtk_vbox_new (FALSE, 0);
2209   gtk_container_add (GTK_CONTAINER (frame), vbox);
2210   gtk_widget_show (vbox);
2211
2212   label = gtk_label_new (_("Help"));
2213   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), frame, label);
2214
2215   hbox = gtk_hbox_new (FALSE, 0);
2216   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2217   gtk_widget_show (hbox);
2218
2219   label = gtk_label_new (_("Viewer:"));
2220   gtk_box_pack_start(GTK_BOX (hbox), label, FALSE, FALSE, 2);
2221   gtk_widget_show (label);
2222
2223   configDialogData.help = gtk_entry_new_with_max_length (HTMLVIEWER_LENGTH - 1);
2224   gtk_widget_set_usize (configDialogData.help, 220, 22);
2225
2226   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.help, FALSE, FALSE, 2);
2227   gtk_widget_show (configDialogData.help);
2228
2229
2230   optionsDialogIsOpened = FALSE;
2231   return dialog;
2232 }
2233
2234
2235 static void TopLevelWindow (void)
2236 {
2237   GtkWidget *drawing_area;
2238   GdkBitmap *mask;
2239   GtkStyle *style;
2240   GdkGC *gc;
2241   struct sigaction act;
2242
2243   GUI_MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2244   gtk_window_set_wmclass (GTK_WINDOW (GUI_MainWindow), "MainWindow", "Xgnokii");
2245 /*  gtk_window_set_decorated (GTK_WINDOW (GUI_MainWindow), GTK_FALSE); */
2246   gtk_widget_realize (GUI_MainWindow);
2247
2248   BackgroundPixmap = gdk_pixmap_create_from_xpm_d (GUI_MainWindow->window, &mask, &GUI_MainWindow->style->white, (gchar **) XPM_background);
2249
2250   SMSPixmap = gdk_pixmap_create_from_xpm_d (GUI_MainWindow->window, &mask, &GUI_MainWindow->style->white, (gchar **) XPM_sms);
2251
2252   AlarmPixmap = gdk_pixmap_create_from_xpm_d (GUI_MainWindow->window, &mask, &GUI_MainWindow->style->white, (gchar **) XPM_alarm);
2253
2254   Pixmap = gdk_pixmap_create_from_xpm_d (GUI_MainWindow->window, &mask, &GUI_MainWindow->style->white, (gchar **) XPM_background);
2255
2256 //  gdk_window_set_icon_name (GUI_MainWindow->window, "XXX");
2257   style = gtk_widget_get_default_style ();
2258   gc = style->black_gc;
2259
2260   /* Create the drawing area */
2261   drawing_area = gtk_drawing_area_new ();
2262
2263   /* Signals used to handle backing pixmap */
2264   gtk_signal_connect (GTK_OBJECT (drawing_area), "expose_event",
2265                       (GtkSignalFunc) ExposeEvent, NULL);
2266
2267   gtk_signal_connect (GTK_OBJECT (drawing_area), "button_press_event",
2268                       (GtkSignalFunc) ButtonPressEvent, NULL);
2269
2270   gtk_widget_set_events (drawing_area, GDK_EXPOSURE_MASK
2271                          | GDK_BUTTON_PRESS_MASK);
2272
2273   gtk_drawing_area_size (GTK_DRAWING_AREA (drawing_area), 261, 96);
2274   gtk_container_add (GTK_CONTAINER (GUI_MainWindow), drawing_area);
2275
2276   gdk_draw_pixmap (drawing_area->window,
2277                    drawing_area->style->fg_gc[GTK_WIDGET_STATE (drawing_area)],
2278                    Pixmap,
2279                    0, 0,
2280                    0, 0,
2281                    261, 96);
2282
2283   gtk_widget_shape_combine_mask (GUI_MainWindow, mask, 0, 0);
2284
2285   gtk_signal_connect (GTK_OBJECT (GUI_MainWindow), "destroy",
2286                       GTK_SIGNAL_FUNC (MainExit),
2287                       NULL);
2288
2289   Menu = CreateMenu ();
2290   OptionsDialog = CreateOptionsDialog ();
2291   AboutDialog = CreateAboutDialog ();
2292   GUI_CreateSMSWindow ();
2293   GUI_CreateContactsWindow ();
2294   GUI_CreateNetmonWindow ();
2295   GUI_CreateDTMFWindow ();
2296   GUI_CreateSpeedDialWindow ();
2297   GUI_CreateXkeybWindow ();
2298   GUI_CreateCalendarWindow ();
2299   GUI_CreateLogosWindow ();
2300   GUI_CreateDataWindow();
2301   CreateErrorDialog (&errorDialog, GUI_MainWindow);
2302   CreateInfoDialog (&infoDialog, GUI_MainWindow);
2303   CreateInCallDialog ();
2304
2305   act.sa_handler = RemoveZombie;
2306   sigemptyset (&(act.sa_mask));
2307   act.sa_flags = SA_NOCLDSTOP;
2308   sigaction (SIGCHLD, &act, NULL);
2309
2310 #if __unices__
2311   act.sa_handler = SIG_IGN;
2312   sigemptyset (&(act.sa_mask));
2313   sigaction (SIGALRM, &act, NULL);
2314 #endif
2315
2316   gtk_widget_show_all (GUI_MainWindow);
2317   GUI_Refresh ();
2318
2319   GUI_InitPhoneMonitor ();
2320   pthread_create (&monitor_th, NULL, GUI_Connect, NULL);
2321
2322   gtk_timeout_add (1000, (GtkFunction) Update, GUI_MainWindow);
2323
2324   hiddenCallDialog = 0;
2325 }
2326
2327
2328 static void SplashScreen (void)
2329 {
2330   GtkWidget *pixmap, *fixed;
2331   GdkPixmap *gdk_pixmap;
2332   GdkBitmap *mask;
2333   GtkStyle *style;
2334   GdkGC *gc;
2335
2336   SplashWindow = gtk_window_new (GTK_WINDOW_POPUP);
2337   gtk_widget_realize (SplashWindow);
2338
2339   gtk_widget_set_usize (SplashWindow, 475, 160);
2340   gtk_window_position (GTK_WINDOW (SplashWindow), GTK_WIN_POS_CENTER);
2341
2342   style = gtk_widget_get_default_style();
2343   gc = style->black_gc;
2344   gdk_pixmap = gdk_pixmap_create_from_xpm_d(SplashWindow->window, &mask,
2345                                             &style->bg[GTK_STATE_NORMAL],
2346                                             XPM_logo);
2347   pixmap = gtk_pixmap_new(gdk_pixmap, mask);
2348
2349   fixed = gtk_fixed_new();
2350   gtk_widget_set_usize(fixed, 261, 96);
2351   gtk_fixed_put(GTK_FIXED(fixed), pixmap, 0, 0);
2352   gtk_container_add(GTK_CONTAINER (SplashWindow), fixed);
2353
2354   gtk_widget_shape_combine_mask (SplashWindow, mask, 0, 0);
2355
2356   gtk_widget_show_all (SplashWindow);
2357 }
2358
2359
2360 static gint RemoveSplash (GtkWidget *Win)
2361 {
2362   if (GTK_WIDGET_VISIBLE (SplashWindow))
2363   {
2364     gtk_timeout_remove (splashRemoveHandler);
2365     gtk_widget_hide (SplashWindow);
2366     gtk_widget_destroy (SplashWindow);
2367     return TRUE;
2368   }
2369
2370   return FALSE;
2371 }
2372
2373 static void ReadConfig (void)
2374 {
2375 #ifdef WIN32
2376   xgnokiiConfig.locale = "";
2377 #else
2378   if ((xgnokiiConfig.locale = getenv ("LC_ALL")) == NULL)
2379     if ((xgnokiiConfig.locale = getenv ("LC_MESSAGES")) == NULL)
2380       if ((xgnokiiConfig.locale = getenv ("LANG")) == NULL)
2381         xgnokiiConfig.locale = "POSIX";
2382 #endif
2383   if (readconfig(&xgnokiiConfig.model, &xgnokiiConfig.port,
2384            &xgnokiiConfig.initlength, &xgnokiiConfig.connection,
2385            &xgnokiiConfig.bindir) < 0)
2386   {
2387     exit(-1);
2388   }
2389
2390   GUI_ReadXConfig();
2391   max_phonebook_name_length = atoi (xgnokiiConfig.maxPhoneLen);
2392   max_phonebook_sim_name_length = atoi (xgnokiiConfig.maxSIMLen);
2393
2394 #ifndef WIN32
2395   xgnokiiConfig.xgnokiidir = DefaultXGnokiiDir;
2396 #endif
2397   max_phonebook_number_length = max_phonebook_sim_number_length = GSM_MAX_PHONEBOOK_NUMBER_LENGTH;
2398
2399   xgnokiiConfig.callerGroups[0] = xgnokiiConfig.callerGroups[1] =
2400   xgnokiiConfig.callerGroups[2] = xgnokiiConfig.callerGroups[3] =
2401   xgnokiiConfig.callerGroups[4] = xgnokiiConfig.callerGroups[5] = NULL;
2402   xgnokiiConfig.smsSets = 0;
2403 }
2404
2405
2406 int main (int argc, char *argv[])
2407 {
2408 #ifdef USE_NLS
2409   textdomain("gnokii");
2410 #endif
2411
2412   (void) gtk_set_locale ();
2413
2414   gtk_init (&argc, &argv);
2415
2416   /* Show the splash screen. */
2417
2418   SplashScreen ();
2419
2420   /* Remove it after a while. */
2421
2422   ReadConfig ();
2423   TopLevelWindow ();
2424
2425   splashRemoveHandler = gtk_timeout_add(5000, (GtkFunction) RemoveSplash, (gpointer) SplashWindow);
2426
2427   gtk_main ();
2428
2429   return (0);
2430 }