xgnokii/xgnokii.c

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