xgnokii/xgnokii.c

   1 /*
   2
   3   $Id$
   4
   5   X G N O K I I
   6
   7   A Linux/Unix GUI for Nokia mobile phones.
   8   Copyright (C) 1999 Pavel Janík ml., Hugh Blemings
   9   & Ján Derfiòák <ja@mail.upjs.sk>.
  10
  11   Released under the terms of the GNU GPL, see file COPYING for more details.
  12
  13   $Log$
  14   Revision 1.1.1.4  2002/04/03 00:08:26  short
  15   Found in "gnokii-working" directory, some November-patches version
  16
  17   Revision 1.38  2001/09/14 13:14:03  pkot
  18   Xgnokii WM fixes (Martin Lucina)
  19
  20   Revision 1.37  2001/06/27 23:52:52  pkot
  21   7110/6210 updates (Marian Jancar)
  22
  23   Revision 1.36  2001/06/20 21:27:36  pkot
  24   IrDA patch (Marian Jancar)
  25
  26   Revision 1.35  2001/05/24 20:47:30  chris
  27   More updating of 7110 code and some of xgnokii_lowlevel changed over.
  28
  29   Revision 1.34  2001/03/23 08:24:56  ja
  30   New preview for 6210 in xgnokii's logos module.
  31
  32   Revision 1.33  2001/03/19 23:43:47  pkot
  33   Solaris/BSD '#if defined' cleanup
  34
  35   Revision 1.32  2001/03/13 01:21:39  pkot
  36   *BSD updates (Bert Driehuis)
  37
  38   Revision 1.31  2001/03/05 10:42:02  ja
  39   Pavel Machek's vcard and finegrained indicators patch.
  40
  41   Revision 1.30  2001/01/29 15:22:20  machek
  42   Use integer as bitfield instead of struct of int:1.
  43
  44   Be able to read phonebook saved in gnokii format from xgnokii.
  45
  46   Revision 1.29  2001/01/15 21:10:20  ja
  47   Better status reporting in xgnokii, fixed phone capabilities detection in xgnokii.
  48
  49   Revision 1.28  2000/12/20 11:49:25  ja
  50   Bringing back to life smsd. It was broken after last Pawel update.
  51
  52   Revision 1.27  2000/12/19 16:18:21  pkot
  53   configure script updates and added shared function for configfile reading
  54
  55
  56 */
  57
  58 #include <stdlib.h>  /* for getenv */
  59 #include <locale.h>
  60 #include <string.h>
  61 #include <time.h>    /* for time   */
  62 #include <pthread.h>
  63
  64 #ifndef WIN32
  65 # include <unistd.h>  /* for usleep */
  66 # include <signal.h>
  67 #else
  68 # include <windows.h>
  69 # include "../win32/winserial.h"
  70 # define WRITEPHONE(a, b, c) WriteCommBlock(b, c)
  71 # undef IN
  72 # undef OUT
  73 # define sleep(x) Sleep((x) * 1000)
  74 # define usleep(x) Sleep(((x) < 1000) ? 1 : ((x) / 1000))
  75 #endif
  76
  77 #include <gdk/gdkkeysyms.h>
  78 #include <gtk/gtk.h>
  79
  80 #include "misc.h"
  81 #include "gsm-common.h"
  82 #include "gsm-api.h"
  83 #include "fbus-6110.h"
  84 #include "fbus-3810.h"
  85 #include "cfgreader.h"
  86 #include "xgnokii.h"
  87 #include "xgnokii_common.h"
  88 #include "xgnokii_lowlevel.h"
  89 #include "xgnokii_contacts.h"
  90 #include "xgnokii_sms.h"
  91 #include "xgnokii_netmon.h"
  92 #include "xgnokii_dtmf.h"
  93 #include "xgnokii_speed.h"
  94 #include "xgnokii_xkeyb.h"
  95 #include "xgnokii_calendar.h"
  96 #include "xgnokii_logos.h"
  97 #include "xgnokii_cfg.h"
  98 #include "xgnokii_data.h"
  99
 100 #include "xpm/logo.xpm"
 101 #include "xpm/background.xpm"
 102 #include "xpm/sms.xpm"
 103 #include "xpm/alarm.xpm"
 104
 105 /* Widgets for dialogs. */
 106 static GtkWidget *SplashWindow;
 107 static GtkWidget *GUI_MainWindow;
 108 static GtkWidget *AboutDialog;
 109 static ErrorDialog errorDialog = {NULL, NULL};
 110 static InfoDialog infoDialog = {NULL, NULL};
 111 static GtkWidget *OptionsDialog;
 112 static bool optionsDialogIsOpened;
 113
 114 /* SMS sets list */
 115 static GtkWidget *SMSClist;
 116
 117 /* Pixmap used for drawing all the stuff. */
 118 static GdkPixmap *Pixmap = NULL;
 119
 120 /* Pixmap used for background. */
 121 static GdkPixmap *BackgroundPixmap = NULL;
 122
 123 /* Pixmap used for SMS picture. */
 124 static GdkPixmap *SMSPixmap = NULL;
 125
 126 /* Pixmap used for alarm picture. */
 127 static GdkPixmap *AlarmPixmap = NULL;
 128
 129
 130 /* Widget for popup menu */
 131 static GtkWidget *Menu;
 132 static GtkWidget *netmon_menu_item;
 133 static GtkWidget *sms_menu_item;
 134 static GtkWidget *calendar_menu_item;
 135 static GtkWidget *logos_menu_item;
 136 static GtkWidget *dtmf_menu_item;
 137 static GtkWidget *speedDial_menu_item;
 138 static GtkWidget *xkeyb_menu_item;
 139 static GtkWidget *cg_names_option_frame;
 140 static GtkWidget *sms_option_frame;
 141 static GtkWidget *mail_option_frame;
 142 static GtkWidget *user_option_frame;
 143 static GtkWidget *data_menu_item;
 144
 145 /* Hold main configuration data for xgnokii */
 146 XgnokiiConfig xgnokiiConfig;
 147
 148 gint max_phonebook_name_length;
 149 gint max_phonebook_number_length;
 150 gint max_phonebook_sim_name_length;
 151 gint max_phonebook_sim_number_length;
 152
 153 /* Local variables */
 154 static char *DefaultXGnokiiDir = XGNOKIIDIR;
 155 static bool SMSSettingsInitialized = FALSE;
 156 static bool CallersGroupsInitialized = FALSE;
 157 static gint hiddenCallDialog;
 158 static guint splashRemoveHandler;
 159
 160 static struct CallDialog {
 161   GtkWidget *dialog;
 162   GtkWidget *label;
 163 } inCallDialog;
 164
 165 typedef struct {
 166   GtkWidget *alarmSwitch;
 167   GtkWidget *alarmHour;
 168   GtkWidget *alarmMin;
 169 } AlarmWidgets;
 170
 171 typedef struct {
 172   GtkWidget *port;
 173   GtkWidget *model;
 174   GtkWidget *init;
 175   GtkWidget *bindir;
 176   GtkWidget *serial, *infrared, *irda;
 177 } ConnectionWidgets;
 178
 179 typedef struct {
 180   GtkWidget *model;
 181   GtkWidget *version;
 182   GtkWidget *revision;
 183   GtkWidget *imei;
 184   GtkWidget *simNameLen;
 185   GtkWidget *phoneNameLen;
 186 } PhoneWidgets;
 187
 188 typedef struct {
 189   GtkWidget *set;
 190   GtkWidget *number;
 191   GtkWidget *format;
 192   GtkWidget *validity;
 193   GSM_MessageCenter smsSetting[MAX_SMS_CENTER];
 194 } SMSWidgets;
 195
 196 typedef struct {
 197   GtkWidget *name;
 198   GtkWidget *title;
 199   GtkWidget *company;
 200   GtkWidget *telephone;
 201   GtkWidget *fax;
 202   GtkWidget *email;
 203   GtkWidget *address;
 204   GtkWidget *status;
 205   gint   max;
 206   gint   used;
 207 } UserWidget;
 208
 209 static struct ConfigDialogData
 210 {
 211   ConnectionWidgets connection;
 212   PhoneWidgets phone;
 213   GtkWidget *groups[6];
 214   AlarmWidgets alarm;
 215   SMSWidgets sms;
 216   UserWidget user;
 217   GtkWidget *mailbox;
 218   GtkWidget *help;
 219 } configDialogData;
 220
 221 static GSM_MessageCenter tempMessageSettings;
 222
 223
 224 static inline void Help1 (GtkWidget *w, gpointer data)
 225 {
 226   gchar *indx = g_strdup_printf ("/help/%s/index.html", xgnokiiConfig.locale);
 227   Help (w, indx);
 228   g_free (indx);
 229 }
 230
 231
 232 void GUI_InitCallerGroupsInf (void)
 233 {
 234   D_CallerGroup *cg;
 235   PhoneEvent *e;
 236   register gint i;
 237
 238   if (CallersGroupsInitialized)
 239     return;
 240
 241   gtk_label_set_text (GTK_LABEL (infoDialog.text), _("Reading caller groups names ..."));
 242   gtk_widget_show_now (infoDialog.dialog);
 243   GUI_Refresh ();
 244
 245   xgnokiiConfig.callerGroups[0] = g_strndup( _("Familly"), MAX_CALLER_GROUP_LENGTH);
 246   xgnokiiConfig.callerGroups[1] = g_strndup( _("VIP"), MAX_CALLER_GROUP_LENGTH);
 247   xgnokiiConfig.callerGroups[2] = g_strndup( _("Friends"), MAX_CALLER_GROUP_LENGTH);
 248   xgnokiiConfig.callerGroups[3] = g_strndup( _("Colleagues"), MAX_CALLER_GROUP_LENGTH);
 249   xgnokiiConfig.callerGroups[4] = g_strndup( _("Other"), MAX_CALLER_GROUP_LENGTH);
 250   xgnokiiConfig.callerGroups[5] = g_strndup( _("No group"), MAX_CALLER_GROUP_LENGTH);
 251
 252   if (phoneMonitor.supported & PM_CALLERGROUP)
 253     for (i = 0; i < 5; i++)
 254     {
 255       cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
 256       cg->number = i;
 257       e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 258       e->event = Event_GetCallerGroup;
 259       e->data = cg;
 260       GUI_InsertEvent (e);
 261       pthread_mutex_lock (&callerGroupMutex);
 262       pthread_cond_wait (&callerGroupCond, &callerGroupMutex);
 263       pthread_mutex_unlock (&callerGroupMutex);
 264
 265       if (*cg->text != '\0' && cg->status == GE_NONE)
 266       {
 267         g_free (xgnokiiConfig.callerGroups[i]);
 268         xgnokiiConfig.callerGroups[i] = g_strndup (cg->text, MAX_CALLER_GROUP_LENGTH);
 269       }
 270       g_free (cg);
 271     }
 272
 273   CallersGroupsInitialized = TRUE;
 274   gtk_widget_hide (infoDialog.dialog);
 275   GUIEventSend (GUI_EVENT_CALLERS_GROUPS_CHANGED);
 276 }
 277
 278
 279 static inline void DrawBackground (GtkWidget *data)
 280 {
 281   gdk_draw_pixmap (Pixmap,
 282                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 283                    BackgroundPixmap,
 284                    0, 0,
 285                    0, 0,
 286                    261, 96);
 287 }
 288
 289
 290 int network_levels[] = {
 291   152, 69, 11, 3,
 292   138, 69, 11, 3,
 293   124, 69, 11, 4,
 294   110, 69, 11, 6
 295 };
 296
 297
 298 static inline void DrawNetwork (GtkWidget *data, int rflevel)
 299 {
 300   int i;
 301
 302   if (rflevel > 100)
 303     rflevel = 100;
 304   for (i = 0; (i * 25) <= rflevel; i++)
 305   {
 306     float percent = ((float) rflevel - i * 25) / 25;
 307
 308     if (percent > 1)
 309       percent = 1;
 310     gdk_draw_rectangle (Pixmap, GTK_WIDGET (data)->style->white_gc, TRUE,
 311                         network_levels[4 * i] + network_levels[4 * i + 2] * (1 - percent),
 312                         network_levels[4 * i + 1],
 313                         network_levels[4 * i + 2] * percent,
 314                         network_levels[4 * i + 3]);
 315   }
 316 }
 317
 318
 319 int battery_levels[] = {
 320   50, 69, 11, 3,
 321   64, 69, 11, 3,
 322   78, 69, 11, 4,
 323   92, 69, 11, 6
 324 };
 325
 326
 327 static inline void DrawBattery (GtkWidget *data, int batterylevel)
 328 {
 329   int i;
 330
 331   if (batterylevel < 0)
 332     return;
 333   if (batterylevel > 100)
 334     batterylevel = 100;
 335   for (i = 0; (i * 25) <= batterylevel; i++)
 336   {
 337     float percent = ((float) batterylevel - i * 25) / 25;
 338     if (percent > 1)
 339       percent = 1;
 340     gdk_draw_rectangle (Pixmap, GTK_WIDGET (data)->style->white_gc, TRUE,
 341                         battery_levels[4 * i],
 342                         battery_levels[4 * i + 1],
 343                         battery_levels[4 * i + 2] * percent,
 344                         battery_levels[4 * i + 3]);
 345   }
 346 }
 347
 348
 349 static inline void DrawSMS (GtkWidget *data)
 350 {
 351   gdk_draw_pixmap (Pixmap,
 352                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 353                    SMSPixmap,
 354                    0, 0,
 355                    25, 47,
 356                    26, 7);
 357 }
 358
 359
 360 static inline void DrawAlarm (GtkWidget *data)
 361 {
 362   gdk_draw_pixmap (Pixmap,
 363                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 364                    AlarmPixmap,
 365                    0, 0,
 366                    163, 11,
 367                    9, 9);
 368 }
 369
 370
 371 static inline void DrawText (GtkWidget *data, int at, char *text)
 372 {
 373   static GdkFont *Font;
 374
 375   Font = gdk_font_load ("-misc-fixed-medium-r-*-*-*-90-*-*-*-*-iso8859-*");
 376   gdk_draw_string (Pixmap,
 377                    Font,
 378                    GTK_WIDGET(data)->style->fg_gc[GTK_STATE_NORMAL],
 379                    33, at, text);
 380 }
 381
 382
 383 static inline void DrawSMSReceived (GtkWidget *data)
 384 {
 385   DrawText (data, 25, _("Short Message received"));
 386 }
 387
 388
 389 static inline void DrawWorking (GtkWidget *data)
 390 {
 391   DrawText(data, 40, _("Working ..."));
 392 }
 393
 394
 395 static inline void HideCallDialog (GtkWidget *widget, gpointer data)
 396 {
 397   hiddenCallDialog = 1;
 398   gtk_widget_hide (GTK_WIDGET (data));
 399 }
 400
 401
 402 static void CreateInCallDialog (void)
 403 {
 404   GtkWidget *button, *hbox;
 405
 406   inCallDialog.dialog = gtk_dialog_new ();
 407   gtk_window_position (GTK_WINDOW (inCallDialog.dialog), GTK_WIN_POS_MOUSE);
 408   gtk_window_set_title (GTK_WINDOW (inCallDialog.dialog), _("Call in progress"));
 409   gtk_container_set_border_width (GTK_CONTAINER (inCallDialog.dialog), 5);
 410   gtk_signal_connect (GTK_OBJECT (inCallDialog.dialog), "delete_event",
 411                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
 412
 413   hbox = gtk_hbox_new (FALSE, 0);
 414   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (inCallDialog.dialog)->vbox), hbox, FALSE, FALSE, 5);
 415   gtk_widget_show (hbox);
 416
 417   inCallDialog.label = gtk_label_new ("");
 418   gtk_box_pack_start (GTK_BOX (hbox), inCallDialog.label, FALSE, FALSE, 0);
 419   gtk_widget_show (inCallDialog.label);
 420
 421   button = gtk_button_new_with_label (_("Hide"));
 422   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (inCallDialog.dialog)->action_area),
 423                       button, TRUE, FALSE, 0);
 424   gtk_signal_connect (GTK_OBJECT (button), "clicked",
 425                       GTK_SIGNAL_FUNC (HideCallDialog), (gpointer) inCallDialog.dialog);
 426   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
 427   gtk_widget_grab_default (button);
 428   gtk_widget_show (button);
 429 }
 430
 431
 432 static gint Update (gpointer data)
 433 {
 434   static gchar lastCallNum[20] = "";
 435   static gchar callBuf[80];
 436   static gchar timeBuf[10];
 437   static gchar *anonym = "anonymous";
 438   static struct tm stm;
 439   static gint smsUsed = 0;
 440   static gint callTimerStart = 0;
 441   gint callTimer = 0;
 442   time_t t;
 443   static gchar *name;
 444   static bool outgoing = TRUE;
 445
 446
 447   /* The number of SMS messages before second */
 448   static int smsUnRead=0;
 449
 450   /* The number of second for we should display "Short Message Received" message */
 451   static int smsreceived=-1;
 452
 453   DrawBackground (data);
 454
 455   DrawNetwork (data, phoneMonitor.rfLevel);
 456
 457   if (phoneMonitor.powerSource == GPS_ACDC)
 458     phoneMonitor.batteryLevel = ((gint) phoneMonitor.batteryLevel + 25) % 125;
 459   DrawBattery (data, phoneMonitor.batteryLevel);
 460
 461   if (phoneMonitor.alarm)
 462     DrawAlarm (data);
 463
 464   if (phoneMonitor.working)
 465     DrawText (data, 25, phoneMonitor.working);
 466
 467   pthread_mutex_lock (&smsMutex);
 468   if (phoneMonitor.sms.unRead > 0)
 469   {
 470     DrawSMS (data);
 471
 472     if (phoneMonitor.sms.unRead > smsUnRead && smsUnRead != -1)
 473       smsreceived = 10;  /* The message "Short Message Received" is displayed for 10s */
 474   }
 475   if (smsUsed != phoneMonitor.sms.used)
 476     GUIEventSend (GUI_EVENT_SMS_NUMBER_CHANGED);
 477
 478   smsUnRead = phoneMonitor.sms.unRead;
 479
 480   smsUsed = phoneMonitor.sms.used;
 481
 482   pthread_mutex_unlock (&smsMutex);
 483
 484   if (smsreceived >= 0)
 485   {
 486     DrawSMSReceived (data);
 487     smsreceived--;
 488   }
 489
 490   pthread_mutex_lock (&callMutex);
 491   if (phoneMonitor.call.callInProgress != CS_Idle)
 492   {
 493     if (phoneMonitor.call.callInProgress == CS_InProgress)
 494     {
 495       if (!callTimerStart)
 496         callTimerStart = callTimer = time (NULL);
 497       else
 498         callTimer = time (NULL);
 499     }
 500
 501     if (phoneMonitor.call.callInProgress == CS_Waiting)
 502     {
 503       outgoing = FALSE;
 504
 505       if (*phoneMonitor.call.callNum == '\0')
 506         name = anonym;
 507       else if (strncmp (phoneMonitor.call.callNum, lastCallNum, 20))
 508       {
 509         strncpy (lastCallNum, phoneMonitor.call.callNum, 20);
 510         lastCallNum[19] = '\0';
 511         name = GUI_GetName (phoneMonitor.call.callNum);
 512         if (!name)
 513           name = phoneMonitor.call.callNum;
 514       }
 515     }
 516     t = (time_t) difftime (callTimer, callTimerStart);
 517     (void) gmtime_r (&t, &stm);
 518     strftime (timeBuf, 10, "%T", &stm);
 519     if (outgoing)
 520       g_snprintf (callBuf, 80, _("Outgoing call in progress:\nTime: %s"),
 521                   timeBuf);
 522     else
 523       g_snprintf (callBuf, 80, _("Incomming call from: %s\nTime: %s"),
 524                   name, timeBuf);
 525
 526     gtk_label_set_text (GTK_LABEL (inCallDialog.label), callBuf);
 527     if (!GTK_WIDGET_VISIBLE (inCallDialog.dialog) && !hiddenCallDialog)
 528       gtk_widget_show (inCallDialog.dialog);
 529   }
 530   else
 531   {
 532     callTimerStart = callTimer = 0;
 533     *lastCallNum = '\0';
 534     outgoing = TRUE;
 535     if (GTK_WIDGET_VISIBLE (inCallDialog.dialog))
 536       gtk_widget_hide (inCallDialog.dialog);
 537     hiddenCallDialog = 0;
 538   }
 539   pthread_mutex_unlock (&callMutex);
 540
 541   gtk_widget_draw (data,NULL);
 542
 543   GUIEventSend (GUI_EVENT_NETMON_CHANGED);
 544
 545   return TRUE;
 546 }
 547
 548
 549 /* Redraw the screen from the backing pixmap */
 550 static inline gint ExposeEvent (GtkWidget *widget, GdkEventExpose *event)
 551 {
 552   gdk_draw_pixmap (widget->window,
 553                    widget->style->fg_gc[GTK_WIDGET_STATE (widget)],
 554                    Pixmap,
 555                    event->area.x, event->area.y,
 556                    event->area.x, event->area.y,
 557                    event->area.width, event->area.height);
 558
 559   return FALSE;
 560 }
 561
 562
 563 static void ParseSMSCenters (void)
 564 {
 565   register gint i;
 566   register gint j;
 567
 568   gtk_clist_freeze (GTK_CLIST (SMSClist));
 569
 570   gtk_clist_clear (GTK_CLIST (SMSClist));
 571
 572   for (i = 0; i < xgnokiiConfig.smsSets; i++)
 573   {
 574     gchar *row[4];
 575     if (*(configDialogData.sms.smsSetting[i].Name) == '\0')
 576       row[0] = g_strdup_printf (_("Set %d"), i + 1);
 577     else
 578       row[0] = g_strdup (configDialogData.sms.smsSetting[i].Name);
 579
 580     row[1] = g_strdup (configDialogData.sms.smsSetting[i].Number);
 581
 582     switch (configDialogData.sms.smsSetting[i].Format)
 583     {
 584       case GSMF_Text:
 585         row[2] = g_strdup (_("Text"));
 586         break;
 587
 588     case GSMF_Paging:
 589         row[2] = g_strdup (_("Paging"));
 590         break;
 591
 592     case GSMF_Fax:
 593         row[2] = g_strdup (_("Fax"));
 594         break;
 595
 596     case GSMF_Email:
 597     case GSMF_UCI:
 598         row[2] = g_strdup (_("E-Mail"));
 599         break;
 600
 601     case GSMF_ERMES:
 602         row[2] = g_strdup (_("ERMES"));
 603         break;
 604
 605     case GSMF_X400:
 606         row[2] = g_strdup (_("X.400"));
 607         break;
 608
 609     case GSMF_Voice:
 610         row[2] = g_strdup (_("Voice"));
 611         break;
 612
 613     default:
 614         row[2] = g_strdup (_("Text"));
 615         break;
 616     }
 617
 618     switch (configDialogData.sms.smsSetting[i].Validity)
 619     {
 620       case GSMV_1_Hour:
 621         row[3] = g_strdup (_("1 h"));
 622         break;
 623
 624       case GSMV_6_Hours:
 625         row[3] = g_strdup (_("6 h"));
 626         break;
 627
 628       case GSMV_24_Hours:
 629         row[3] = g_strdup (_("24 h"));
 630         break;
 631
 632       case GSMV_72_Hours:
 633         row[3] = g_strdup (_("72 h"));
 634         break;
 635
 636       case GSMV_1_Week:
 637         row[3] = g_strdup (_("1 week"));
 638         break;
 639
 640       case GSMV_Max_Time:
 641         row[3] = g_strdup (_("Max. time"));
 642         break;
 643
 644       default:
 645         row[3] = g_strdup (_("24 h"));
 646         break;
 647     }
 648
 649     gtk_clist_append( GTK_CLIST (SMSClist), row);
 650
 651     for (j = 0; j < 4; j++)
 652       g_free (row[j]);
 653   }
 654
 655   gtk_clist_thaw (GTK_CLIST (SMSClist));
 656 }
 657
 658
 659 static void RefreshUserStatus (void)
 660 {
 661   gchar buf[8];
 662   configDialogData.user.used = GTK_ENTRY (configDialogData.user.name)->text_length
 663                              + GTK_ENTRY (configDialogData.user.title)->text_length
 664                              + GTK_ENTRY (configDialogData.user.company)->text_length
 665                              + GTK_ENTRY (configDialogData.user.telephone)->text_length
 666                              + GTK_ENTRY (configDialogData.user.fax)->text_length
 667                              + GTK_ENTRY (configDialogData.user.email)->text_length
 668                              + GTK_ENTRY (configDialogData.user.address)->text_length;
 669   configDialogData.user.max = MAX_BUSINESS_CARD_LENGTH;
 670   if (GTK_ENTRY (configDialogData.user.telephone)->text_length > 0)
 671     configDialogData.user.max -= 4;
 672   if (GTK_ENTRY (configDialogData.user.fax)->text_length > 0)
 673     configDialogData.user.max -= 4;
 674   g_snprintf (buf, 8, "%d/%d", configDialogData.user.used, configDialogData.user.max);
 675   gtk_label_set_text (GTK_LABEL (configDialogData.user.status), buf);
 676 }
 677
 678
 679 void GUI_InitSMSSettings (void)
 680 {
 681   PhoneEvent *e;
 682   D_SMSCenter *c;
 683   register gint i;
 684
 685   if (SMSSettingsInitialized)
 686     return;
 687
 688   gtk_label_set_text (GTK_LABEL (infoDialog.text), _("Reading SMS centers ..."));
 689   gtk_widget_show_now (infoDialog.dialog);
 690   GUI_Refresh ();
 691
 692   for (i = 1; i <= MAX_SMS_CENTER; i++)
 693   {
 694     xgnokiiConfig.smsSetting[i - 1].No = i;
 695     c = (D_SMSCenter *) g_malloc (sizeof (D_SMSCenter));
 696     c->center = &(xgnokiiConfig.smsSetting[i - 1]);
 697
 698     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 699     e->event = Event_GetSMSCenter;
 700     e->data = c;
 701     GUI_InsertEvent (e);
 702     pthread_mutex_lock (&smsCenterMutex);
 703     pthread_cond_wait (&smsCenterCond, &smsCenterMutex);
 704     pthread_mutex_unlock (&smsCenterMutex);
 705
 706     if (c->status != GE_NONE)
 707       break;
 708
 709     g_free (c);
 710
 711     configDialogData.sms.smsSetting[i - 1] = xgnokiiConfig.smsSetting[i - 1];
 712   }
 713
 714   xgnokiiConfig.smsSets = i - 1;
 715
 716   ParseSMSCenters ();
 717
 718   SMSSettingsInitialized = TRUE;
 719
 720   gtk_widget_hide (infoDialog.dialog);
 721 }
 722
 723
 724 void GUI_ShowOptions (void)
 725 {
 726   PhoneEvent *e;
 727   D_Alarm *alarm;
 728   register gint i;
 729
 730   if (optionsDialogIsOpened)
 731     return;
 732
 733   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.port), xgnokiiConfig.port);
 734
 735   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.model), xgnokiiConfig.model);
 736
 737   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.init), xgnokiiConfig.initlength);
 738
 739   gtk_entry_set_text (GTK_ENTRY (configDialogData.connection.bindir), xgnokiiConfig.bindir);
 740
 741   if(!strcmp(xgnokiiConfig.connection, "serial")) {
 742     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.serial), TRUE);
 743   } else   if(!strcmp(xgnokiiConfig.connection, "infrared")) {
 744     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.infrared), TRUE);
 745   } else {
 746     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.connection.irda), TRUE);
 747   }
 748
 749   /* Phone */
 750   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.model), phoneMonitor.phone.model);
 751
 752   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.version), phoneMonitor.phone.version);
 753
 754   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.revision), phoneMonitor.phone.revision);
 755
 756   gtk_entry_set_text (GTK_ENTRY (configDialogData.phone.imei), phoneMonitor.phone.imei);
 757
 758   gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen),
 759                              atof (xgnokiiConfig.maxSIMLen));
 760
 761   gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen),
 762                              atof (xgnokiiConfig.maxPhoneLen));
 763
 764   /* Alarm */
 765   alarm = (D_Alarm *) g_malloc (sizeof (D_Alarm));
 766   e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 767   e->event = Event_GetAlarm;
 768   e->data = alarm;
 769   GUI_InsertEvent (e);
 770   pthread_mutex_lock (&alarmMutex);
 771   pthread_cond_wait (&alarmCond, &alarmMutex);
 772   pthread_mutex_unlock (&alarmMutex);
 773
 774   if (alarm->status != GE_NONE)
 775   {
 776     xgnokiiConfig.alarmSupported = FALSE;
 777     gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), FALSE);
 778     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), 0.0);
 779     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), 0.0);
 780   }
 781   else
 782   {
 783     xgnokiiConfig.alarmSupported = TRUE;
 784     if (alarm->time.AlarmEnabled)
 785       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), TRUE);
 786     else
 787       gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch), FALSE);
 788     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour), alarm->time.Hour);
 789     gtk_spin_button_set_value (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin), alarm->time.Minute);
 790   }
 791   g_free (alarm);
 792
 793   /* SMS */
 794   if (phoneMonitor.supported & PM_SMS)
 795   {
 796     gtk_widget_show (sms_option_frame);
 797     GUI_InitSMSSettings ();
 798   }
 799   else
 800     gtk_widget_hide (sms_option_frame);
 801
 802
 803   /* BUSINESS CARD */
 804   if (phoneMonitor.supported & PM_SMS)
 805   {
 806     gtk_widget_show (user_option_frame);
 807
 808     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.name),
 809                         xgnokiiConfig.user.name);
 810     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.title),
 811                         xgnokiiConfig.user.title);
 812     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.company),
 813                         xgnokiiConfig.user.company);
 814     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.telephone),
 815                         xgnokiiConfig.user.telephone);
 816     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.fax),
 817                         xgnokiiConfig.user.fax);
 818     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.email),
 819                         xgnokiiConfig.user.email);
 820     gtk_entry_set_text (GTK_ENTRY (configDialogData.user.address),
 821                         xgnokiiConfig.user.address);
 822
 823     RefreshUserStatus();
 824   }
 825   else
 826     gtk_widget_hide (user_option_frame);
 827
 828
 829   /* Groups */
 830   if (phoneMonitor.supported & PM_CALLERGROUP)
 831   {
 832     gtk_widget_show (cg_names_option_frame);
 833     GUI_InitCallerGroupsInf ();
 834     for ( i = 0; i < 6; i++)
 835       gtk_entry_set_text (GTK_ENTRY (configDialogData.groups[i]), xgnokiiConfig.callerGroups[i]);
 836   }
 837   else
 838     gtk_widget_hide (cg_names_option_frame);
 839
 840   /* Mail */
 841   if (phoneMonitor.supported & PM_SMS)
 842   {
 843     gtk_widget_show (mail_option_frame);
 844     gtk_entry_set_text (GTK_ENTRY (configDialogData.mailbox),
 845                         xgnokiiConfig.mailbox);;
 846   }
 847   else
 848     gtk_widget_hide (mail_option_frame);
 849
 850   /* Help */
 851   gtk_entry_set_text (GTK_ENTRY (configDialogData.help),
 852                       xgnokiiConfig.helpviewer);
 853
 854   optionsDialogIsOpened = TRUE;
 855   gtk_widget_show (OptionsDialog);
 856 }
 857
 858
 859 inline void GUI_ShowAbout (void)
 860 {
 861   gtk_widget_show (AboutDialog);
 862 }
 863
 864
 865 inline void GUI_HideAbout(void)
 866 {
 867   gtk_widget_hide (AboutDialog);
 868 }
 869
 870
 871 static void MainExit (void)
 872 {
 873   PhoneEvent *e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
 874
 875   e->event = Event_Exit;
 876   e->data = NULL;
 877   GUI_InsertEvent (e);
 878   pthread_join (monitor_th, NULL);
 879   gtk_main_quit();
 880 }
 881
 882
 883 static void ShowMenu (GdkEventButton *event)
 884 {
 885   GdkEventButton *bevent = (GdkEventButton *) event;
 886
 887   if (phoneMonitor.supported & PM_KEYBOARD)
 888     gtk_widget_show (xkeyb_menu_item);
 889   else
 890     gtk_widget_hide (xkeyb_menu_item);
 891
 892   if (phoneMonitor.supported & PM_NETMONITOR)
 893     gtk_widget_show (netmon_menu_item);
 894   else
 895     gtk_widget_hide (netmon_menu_item);
 896
 897   if (phoneMonitor.supported & PM_SMS)
 898     gtk_widget_show (sms_menu_item);
 899   else
 900     gtk_widget_hide (sms_menu_item);
 901
 902   if (phoneMonitor.supported & PM_CALENDAR)
 903     gtk_widget_show (calendar_menu_item);
 904   else
 905     gtk_widget_hide (calendar_menu_item);
 906
 907   if (phoneMonitor.supported & PM_DTMF)
 908     gtk_widget_show (dtmf_menu_item);
 909   else
 910     gtk_widget_hide (dtmf_menu_item);
 911
 912   if (phoneMonitor.supported & PM_SPEEDDIAL)
 913     gtk_widget_show (speedDial_menu_item);
 914   else
 915     gtk_widget_hide (speedDial_menu_item);
 916
 917   if (phoneMonitor.supported & PM_DATA)
 918     gtk_widget_show (data_menu_item);
 919   else
 920     gtk_widget_hide (data_menu_item);
 921
 922   gtk_menu_popup (GTK_MENU (Menu), NULL, NULL, NULL, NULL,
 923                           bevent->button, bevent->time);
 924 }
 925
 926
 927 static gint ButtonPressEvent (GtkWidget *widget, GdkEventButton *event)
 928 {
 929   /* Left button */
 930   if (event->button == 1) {
 931
 932     /* Close */
 933     if (event->x >= 206 && event->x <= 221 &&
 934         event->y >=  42 && event->y <= 55)
 935     {
 936       if (GUI_ContactsIsChanged())
 937         GUI_QuitSaveContacts();
 938       else
 939         MainExit ();
 940     }
 941     else if ((event->x >= 180 && event->x <= 195 &&
 942              event->y >=  30 && event->y <= 50) ||
 943              (event->x >= 185 && event->x <= 215 &&
 944              event->y >=  15 && event->y <= 30))
 945     {
 946       GUI_ShowContacts ();
 947     }
 948     else if (event->x >= 190 && event->x <= 210 &&
 949              event->y >=  70 && event->y <= 85)
 950     {
 951       if (!phoneMonitor.supported & PM_SMS)
 952         phoneMonitor.working = _("SMS not supported!");
 953       else
 954         GUI_ShowSMS ();
 955     }
 956     else if (event->x >= 235 && event->x <= 248 &&
 957              event->y >=  27 && event->y <= 75)
 958     {
 959       if (!phoneMonitor.supported & PM_CALENDAR)
 960         phoneMonitor.working = _("Calendar not supported!");
 961       else
 962         GUI_ShowCalendar ();
 963     }
 964     else if (event->x >= 245 && event->x <= 258 &&
 965              event->y >=  83 && event->y <= 93)
 966     {
 967       GUI_ShowOptions();
 968     }
 969   } /* Right button */
 970   else if (event->button == 3)
 971     ShowMenu (event);
 972
 973   // g_print ("event->x: %f\n", event->x);
 974   // g_print ("event->y: %f\n", event->y);
 975
 976   return TRUE;
 977 }
 978
 979
 980 static void OptionsApplyCallback (GtkWidget *widget, gpointer data )
 981 {
 982   PhoneEvent *e;
 983   D_Alarm *alarm;
 984   register gint i;
 985
 986   /* Phone */
 987   max_phonebook_sim_name_length = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.phone.simNameLen));
 988   max_phonebook_name_length = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.phone.phoneNameLen));
 989   g_free (xgnokiiConfig.maxSIMLen);
 990   g_free (xgnokiiConfig.maxPhoneLen);
 991   xgnokiiConfig.maxSIMLen = g_strdup_printf ("%d", max_phonebook_sim_name_length);
 992   xgnokiiConfig.maxPhoneLen = g_strdup_printf ("%d", max_phonebook_name_length);
 993
 994   /* ALARM */
 995   /* From fbus-6110.c
 996      FIXME: we should also allow to set the alarm off :-) */
 997   if (xgnokiiConfig.alarmSupported
 998       && GTK_TOGGLE_BUTTON (configDialogData.alarm.alarmSwitch)->active)
 999   {
1000     alarm = (D_Alarm *) g_malloc (sizeof (D_Alarm));
1001     alarm->time.Hour = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.alarm.alarmHour));
1002     alarm->time.Minute = gtk_spin_button_get_value_as_int (GTK_SPIN_BUTTON (configDialogData.alarm.alarmMin));
1003     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1004     e->event = Event_SetAlarm;
1005     e->data = alarm;
1006     GUI_InsertEvent (e);
1007   }
1008
1009   /* SMS */
1010   if (phoneMonitor.supported & PM_SMS)
1011   {
1012     for (i = 0; i < xgnokiiConfig.smsSets; i++)
1013       xgnokiiConfig.smsSetting[i] = configDialogData.sms.smsSetting[i];
1014     GUIEventSend (GUI_EVENT_SMS_CENTERS_CHANGED);
1015   }
1016
1017   /* BUSINESS CARD */
1018   if (phoneMonitor.supported & PM_SMS)
1019   {
1020     g_free(xgnokiiConfig.user.name);
1021     xgnokiiConfig.user.name = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.name)));
1022     g_free(xgnokiiConfig.user.title);
1023     xgnokiiConfig.user.title = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.title)));
1024     g_free(xgnokiiConfig.user.company);
1025     xgnokiiConfig.user.company = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.company)));
1026     g_free(xgnokiiConfig.user.telephone);
1027     xgnokiiConfig.user.telephone = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.telephone)));
1028     g_free(xgnokiiConfig.user.fax);
1029     xgnokiiConfig.user.fax = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.fax)));
1030     g_free(xgnokiiConfig.user.email);
1031     xgnokiiConfig.user.email = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.email)));
1032     g_free(xgnokiiConfig.user.address);
1033     xgnokiiConfig.user.address = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.user.address)));
1034   }
1035
1036   /* GROUPS */
1037   if (phoneMonitor.supported & PM_CALLERGROUP)
1038   {
1039     for ( i = 0; i < 6; i++)
1040     {
1041       strncpy(xgnokiiConfig.callerGroups[i],
1042               gtk_entry_get_text(GTK_ENTRY (configDialogData.groups[i])),
1043               MAX_CALLER_GROUP_LENGTH);
1044       xgnokiiConfig.callerGroups[i][MAX_CALLER_GROUP_LENGTH] = '\0';
1045     }
1046     GUIEventSend (GUI_EVENT_CALLERS_GROUPS_CHANGED);
1047     GUIEventSend (GUI_EVENT_CONTACTS_CHANGED);
1048   }
1049
1050   /* Mail */
1051   if (phoneMonitor.supported & PM_SMS)
1052   {
1053     g_free(xgnokiiConfig.mailbox);
1054     xgnokiiConfig.mailbox = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.mailbox)));
1055   }
1056
1057   /* Help */
1058   g_free(xgnokiiConfig.helpviewer);
1059   xgnokiiConfig.helpviewer = g_strdup (gtk_entry_get_text(GTK_ENTRY (configDialogData.help)));
1060 }
1061
1062
1063 static void OptionsSaveCallback (GtkWidget *widget, gpointer data )
1064 {
1065   D_CallerGroup *cg;
1066   D_SMSCenter *c;
1067   PhoneEvent *e;
1068   register gint i;
1069
1070   //gtk_widget_hide(GTK_WIDGET(data));
1071   OptionsApplyCallback (widget, data);
1072   for (i = 0; i < xgnokiiConfig.smsSets; i++)
1073   {
1074     xgnokiiConfig.smsSetting[i].No = i + 1;
1075     c = (D_SMSCenter *) g_malloc (sizeof (D_SMSCenter));
1076     c->center = &(xgnokiiConfig.smsSetting[i]);
1077     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1078     e->event = Event_SetSMSCenter;
1079     e->data = c;
1080     GUI_InsertEvent (e);
1081   }
1082
1083   if (phoneMonitor.supported & PM_CALLERGROUP)
1084   {
1085     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1086     cg->number = 0;
1087     if (strcmp (xgnokiiConfig.callerGroups[0], _("Familly")) == 0)
1088       *cg->text = '\0';
1089     else
1090       strncpy (cg->text, xgnokiiConfig.callerGroups[0], 256);
1091     cg->text[255] = '\0';
1092     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1093     e->event = Event_SendCallerGroup;
1094     e->data = cg;
1095     GUI_InsertEvent (e);
1096
1097     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1098     cg->number = 1;
1099     if (strcmp (xgnokiiConfig.callerGroups[1], _("VIP")) == 0)
1100       *cg->text = '\0';
1101     else
1102       strncpy (cg->text, xgnokiiConfig.callerGroups[1], 256);
1103     cg->text[255] = '\0';
1104     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1105     e->event = Event_SendCallerGroup;
1106     e->data = cg;
1107     GUI_InsertEvent (e);
1108
1109     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1110     cg->number = 2;
1111     if (strcmp (xgnokiiConfig.callerGroups[2], _("Friends")) == 0)
1112       *cg->text = '\0';
1113     else
1114       strncpy (cg->text, xgnokiiConfig.callerGroups[2], 256);
1115     cg->text[255] = '\0';
1116     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1117     e->event = Event_SendCallerGroup;
1118     e->data = cg;
1119     GUI_InsertEvent (e);
1120
1121     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1122     cg->number = 3;
1123     if (strcmp (xgnokiiConfig.callerGroups[3], _("Colleagues")) == 0)
1124       *cg->text = '\0';
1125     else
1126       strncpy (cg->text, xgnokiiConfig.callerGroups[3], 256);
1127     cg->text[255] = '\0';
1128     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1129     e->event = Event_SendCallerGroup;
1130     e->data = cg;
1131     GUI_InsertEvent (e);
1132
1133     cg = (D_CallerGroup *) g_malloc (sizeof (D_CallerGroup));
1134     cg->number = 4;
1135     if (strcmp (xgnokiiConfig.callerGroups[4], _("Other")) == 0)
1136       *cg->text = '\0';
1137     else
1138       strncpy (cg->text, xgnokiiConfig.callerGroups[4], 256);
1139     cg->text[255] = '\0';
1140     e = (PhoneEvent *) g_malloc (sizeof (PhoneEvent));
1141     e->event = Event_SendCallerGroup;
1142     e->data = cg;
1143     GUI_InsertEvent (e);
1144   }
1145
1146   if (GUI_SaveXConfig())
1147   {
1148     gtk_label_set_text (GTK_LABEL(errorDialog.text), _("Error writing configuration file!"));
1149     gtk_widget_show (errorDialog.dialog);
1150   }
1151 }
1152
1153
1154 static GtkWidget *CreateMenu (void)
1155 {
1156   GtkWidget *menu, *menu_items;
1157
1158   menu = gtk_menu_new ();
1159
1160   menu_items = gtk_menu_item_new_with_label (_("Contacts"));
1161   gtk_menu_append (GTK_MENU (menu), menu_items);
1162   gtk_signal_connect_object (GTK_OBJECT (menu_items), "activate",
1163                              GTK_SIGNAL_FUNC (GUI_ShowContacts), NULL);
1164   gtk_widget_show (menu_items);
1165
1166   sms_menu_item = gtk_menu_item_new_with_label (_("SMS"));
1167   gtk_menu_append (GTK_MENU (menu), sms_menu_item);
1168   gtk_signal_connect_object (GTK_OBJECT (sms_menu_item), "activate",
1169                              GTK_SIGNAL_FUNC (GUI_ShowSMS), NULL);
1170
1171   calendar_menu_item = gtk_menu_item_new_with_label (_("Calendar"));
1172   gtk_menu_append (GTK_MENU (menu), calendar_menu_item);
1173   gtk_signal_connect_object (GTK_OBJECT (calendar_menu_item), "activate",
1174                              GTK_SIGNAL_FUNC (GUI_ShowCalendar), NULL);
1175
1176   logos_menu_item = gtk_menu_item_new_with_label (_("Logos"));
1177   gtk_menu_append (GTK_MENU (menu), logos_menu_item);
1178   gtk_signal_connect_object (GTK_OBJECT (logos_menu_item), "activate",
1179                              GTK_SIGNAL_FUNC (GUI_ShowLogosWindow), NULL);
1180   gtk_widget_show(logos_menu_item);
1181
1182   dtmf_menu_item = gtk_menu_item_new_with_label (_("DTMF"));
1183   gtk_menu_append (GTK_MENU (menu), dtmf_menu_item);
1184   gtk_signal_connect_object (GTK_OBJECT (dtmf_menu_item), "activate",
1185                              GTK_SIGNAL_FUNC (GUI_ShowDTMF), NULL);
1186
1187   speedDial_menu_item = gtk_menu_item_new_with_label (_("Speed Dial"));
1188   gtk_menu_append (GTK_MENU (menu), speedDial_menu_item);
1189   gtk_signal_connect_object (GTK_OBJECT (speedDial_menu_item), "activate",
1190                              GTK_SIGNAL_FUNC (GUI_ShowSpeedDial), NULL);
1191
1192   xkeyb_menu_item = gtk_menu_item_new_with_label (_("Keyboard"));
1193   gtk_menu_append (GTK_MENU (menu), xkeyb_menu_item);
1194   gtk_signal_connect_object (GTK_OBJECT (xkeyb_menu_item), "activate",
1195                              GTK_SIGNAL_FUNC (GUI_ShowXkeyb), NULL);
1196
1197   netmon_menu_item = gtk_menu_item_new_with_label (_("Net Monitor"));
1198   gtk_menu_append (GTK_MENU (menu), netmon_menu_item);
1199   gtk_signal_connect_object (GTK_OBJECT (netmon_menu_item), "activate",
1200                              GTK_SIGNAL_FUNC (GUI_ShowNetmon), NULL);
1201
1202   data_menu_item = gtk_menu_item_new_with_label (_("Data calls"));
1203   gtk_menu_append (GTK_MENU (menu), data_menu_item);
1204   gtk_signal_connect_object (GTK_OBJECT (data_menu_item), "activate",
1205                              GTK_SIGNAL_FUNC (GUI_ShowData), NULL);
1206
1207   menu_items = gtk_menu_item_new ();
1208   gtk_menu_append (GTK_MENU (menu), menu_items);
1209   gtk_widget_show (menu_items);
1210
1211   menu_items = gtk_menu_item_new_with_label (_("Options"));
1212   gtk_menu_append (GTK_MENU (menu), menu_items);
1213   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1214                              GTK_SIGNAL_FUNC(GUI_ShowOptions), NULL);
1215   gtk_widget_show (menu_items);
1216
1217   menu_items = gtk_menu_item_new ();
1218   gtk_menu_append (GTK_MENU (menu), menu_items);
1219   gtk_widget_show (menu_items);
1220
1221   menu_items = gtk_menu_item_new_with_label (_("Help"));
1222   gtk_menu_append (GTK_MENU (menu), menu_items);
1223   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1224                              GTK_SIGNAL_FUNC(Help1), NULL);
1225   gtk_widget_show (menu_items);
1226
1227   menu_items = gtk_menu_item_new_with_label (_("About"));
1228   gtk_menu_append (GTK_MENU (menu), menu_items);
1229   gtk_signal_connect_object (GTK_OBJECT(menu_items), "activate",
1230                              GTK_SIGNAL_FUNC (GUI_ShowAbout), NULL);
1231   gtk_widget_show (menu_items);
1232
1233   return menu;
1234 }
1235
1236
1237 static GtkWidget *CreateAboutDialog (void)
1238 {
1239   GtkWidget *dialog;
1240   GtkWidget *button, *hbox, *label;
1241   gchar buf[2000];
1242
1243   dialog = gtk_dialog_new ();
1244   gtk_window_set_title (GTK_WINDOW (dialog), _("About"));
1245   gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1246   gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1247                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1248   button = gtk_button_new_with_label (_("Ok"));
1249   gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1250                       button, TRUE, FALSE, 5);
1251   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1252                       GTK_SIGNAL_FUNC (GUI_HideAbout), NULL);
1253   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1254   gtk_widget_grab_default (button);
1255   gtk_widget_show (button);
1256
1257   hbox = gtk_hbox_new (FALSE, 0);
1258   gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1259   gtk_widget_show (hbox);
1260
1261   g_snprintf (buf, 2000, _("xgnokii version: %s\ngnokii version: %s\n\n\
1262 Copyright (C) 1999,2000 Pavel Janík ml.,\nHugh Blemings, Jan Derfinak and others\n\
1263 xgnokii is free software, covered by the GNU General Public License, and you are\n\
1264 welcome to change it and/or distribute copies of it under certain conditions.\n\
1265 There is absolutely no waranty for xgnokii. See GPL for details.\n"),
1266               XVERSION, VERSION);
1267   label = gtk_label_new ((gchar *) buf);
1268   gtk_box_pack_start (GTK_BOX(hbox), label, FALSE, FALSE, 0);
1269   gtk_widget_show (label);
1270
1271   return dialog;
1272 }
1273
1274
1275 static inline void SetFormat (GtkWidget *item, gpointer data)
1276 {
1277   tempMessageSettings.Format = GPOINTER_TO_INT (data);
1278 }
1279
1280
1281 static inline void SetValidity (GtkWidget *item, gpointer data)
1282 {
1283   tempMessageSettings.Validity = GPOINTER_TO_INT (data);
1284 }
1285
1286
1287 static inline void OptionsDeleteEvent (GtkWidget *widget, GdkEvent *event, gpointer data )
1288 {
1289   gtk_widget_hide( GTK_WIDGET (widget));
1290   optionsDialogIsOpened = FALSE;
1291 }
1292
1293
1294 static inline void OptionsCloseCallback (GtkWidget *widget, gpointer data )
1295 {
1296   gtk_widget_hide(GTK_WIDGET(data));
1297   optionsDialogIsOpened = FALSE;
1298 }
1299
1300
1301 static gint CheckInUserDataLength (GtkWidget *widget,
1302                                    GdkEvent  *event,
1303                                    gpointer   callback_data)
1304 {
1305   register gint len;
1306
1307   len = configDialogData.user.max - (GTK_ENTRY (configDialogData.user.name)->text_length
1308       + GTK_ENTRY (configDialogData.user.title)->text_length
1309       + GTK_ENTRY (configDialogData.user.company)->text_length
1310       + GTK_ENTRY (configDialogData.user.telephone)->text_length
1311       + GTK_ENTRY (configDialogData.user.fax)->text_length
1312       + GTK_ENTRY (configDialogData.user.email)->text_length
1313       + GTK_ENTRY (configDialogData.user.address)->text_length
1314       - GTK_ENTRY (widget)->text_length);
1315
1316   if (len < 1)
1317   {
1318     gtk_entry_set_editable (GTK_ENTRY (widget), FALSE);
1319     return (FALSE);
1320   }
1321   else
1322     gtk_entry_set_editable (GTK_ENTRY (widget), TRUE);
1323   if (GPOINTER_TO_INT (callback_data) == 3
1324       || GPOINTER_TO_INT (callback_data) == 4)
1325   {
1326     if ((GPOINTER_TO_INT (callback_data) == 3
1327         && GTK_ENTRY (configDialogData.user.telephone)->text_length == 0)
1328         || (GPOINTER_TO_INT (callback_data) == 4
1329         && GTK_ENTRY (configDialogData.user.fax)->text_length == 0))
1330       len -= 4;
1331
1332     if (len < 1)
1333     {
1334       gtk_entry_set_editable (GTK_ENTRY (widget), FALSE);
1335       return (FALSE);
1336     }
1337
1338     if (len > max_phonebook_number_length)
1339       len = max_phonebook_number_length;
1340   }
1341
1342   gtk_entry_set_max_length (GTK_ENTRY (widget), len);
1343   return (FALSE);
1344 }
1345
1346
1347 static inline gint CheckOutUserDataLength (GtkWidget *widget,
1348                                            GdkEvent  *event,
1349                                            gpointer   callback_data)
1350 {
1351   gtk_entry_set_max_length (GTK_ENTRY (widget), GPOINTER_TO_INT (callback_data));
1352   return (FALSE);
1353 }
1354
1355
1356 static inline gint RefreshUserStatusCallBack (GtkWidget   *widget,
1357                                               GdkEventKey *event,
1358                                               gpointer     callback_data)
1359 {
1360   RefreshUserStatus ();
1361   if (GTK_EDITABLE (widget)->editable == FALSE)
1362     return (FALSE);
1363   if (event->keyval == GDK_BackSpace || event->keyval == GDK_Clear ||
1364       event->keyval == GDK_Insert || event->keyval == GDK_Delete ||
1365       event->keyval == GDK_Home || event->keyval == GDK_End ||
1366       event->keyval == GDK_Left || event->keyval == GDK_Right ||
1367       event->keyval == GDK_Return ||
1368       (event->keyval >= 0x20 && event->keyval <= 0xFF))
1369     return (TRUE);
1370
1371   return (FALSE);
1372 }
1373
1374
1375 static void OkEditSMSSetDialog (GtkWidget *w, gpointer data)
1376 {
1377
1378   strncpy(configDialogData.sms.smsSetting
1379           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name,
1380           gtk_entry_get_text(GTK_ENTRY (configDialogData.sms.set)),
1381           GSM_MAX_SMS_CENTER_NAME_LENGTH);
1382   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name[GSM_MAX_SMS_CENTER_NAME_LENGTH - 1]
1383     = '\0';
1384
1385   strncpy(configDialogData.sms.smsSetting
1386           [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number,
1387           gtk_entry_get_text(GTK_ENTRY (configDialogData.sms.number)),
1388           GSM_MAX_SMS_CENTER_LENGTH);
1389   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number[GSM_MAX_SMS_CENTER_LENGTH]
1390     = '\0';
1391
1392   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Format
1393     = tempMessageSettings.Format;
1394
1395   configDialogData.sms.smsSetting[GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Validity
1396     = tempMessageSettings.Validity;
1397
1398   ParseSMSCenters ();
1399
1400   gtk_widget_hide (GTK_WIDGET (data));
1401 }
1402
1403
1404 static inline void EditSMSSetDialogClick (GtkWidget        *clist,
1405                                           gint              row,
1406                                           gint              column,
1407                                           GdkEventButton   *event,
1408                                           GtkWidget        *data )
1409 {
1410   if(event && event->type == GDK_2BUTTON_PRESS)
1411     gtk_signal_emit_by_name(GTK_OBJECT (data), "clicked");
1412 }
1413
1414
1415 static void ShowEditSMSSetDialog (GtkWidget *w, gpointer data)
1416 {
1417   static GtkWidget *dialog = NULL;
1418   GtkWidget *button, *label, *hbox, *menu, *item;
1419
1420   if (GTK_CLIST (SMSClist)->selection == NULL)
1421     return;
1422
1423   if (dialog == NULL)
1424   {
1425     dialog = gtk_dialog_new();
1426     gtk_window_set_title (GTK_WINDOW (dialog), _("Edit SMS Setting"));
1427     gtk_window_set_modal(GTK_WINDOW (dialog), TRUE);
1428     gtk_container_set_border_width (GTK_CONTAINER (dialog), 10);
1429     gtk_signal_connect (GTK_OBJECT (dialog), "delete_event",
1430                       GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1431
1432     button = gtk_button_new_with_label (_("Ok"));
1433     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1434                         button, TRUE, TRUE, 10);
1435     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1436                         GTK_SIGNAL_FUNC (OkEditSMSSetDialog), (gpointer) dialog);
1437     GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1438     gtk_widget_grab_default (button);
1439     gtk_widget_show (button);
1440     button = gtk_button_new_with_label (_("Cancel"));
1441     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->action_area),
1442                         button, TRUE, TRUE, 10);
1443     gtk_signal_connect (GTK_OBJECT (button), "clicked",
1444                         GTK_SIGNAL_FUNC (CancelDialog), (gpointer) dialog);
1445     gtk_widget_show (button);
1446
1447     gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), 5);
1448
1449     hbox = gtk_hbox_new (FALSE, 0);
1450     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1451     gtk_widget_show (hbox);
1452
1453     label = gtk_label_new (_("Set's name:"));
1454     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
1455     gtk_widget_show (label);
1456
1457     configDialogData.sms.set = gtk_entry_new_with_max_length(GSM_MAX_SMS_CENTER_NAME_LENGTH - 1);
1458     gtk_widget_set_usize (configDialogData.sms.set, 110, 22);
1459     gtk_box_pack_end(GTK_BOX(hbox), configDialogData.sms.set, FALSE, FALSE, 2);
1460     gtk_widget_show (configDialogData.sms.set);
1461
1462     hbox = gtk_hbox_new (FALSE, 0);
1463     gtk_container_add (GTK_CONTAINER (GTK_DIALOG (dialog)->vbox), hbox);
1464     gtk_widget_show (hbox);
1465
1466     label = gtk_label_new (_("Center:"));
1467     gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
1468     gtk_widget_show (label);
1469
1470     configDialogData.sms.number = gtk_entry_new_with_max_length(GSM_MAX_SMS_CENTER_LENGTH - 1);
1471     gtk_widget_set_usize (configDialogData.sms.number, 110, 22);
1472     gtk_box_pack_end(GTK_BOX(hbox), configDialogData.sms.number, FALSE, FALSE, 2);
1473     gtk_widget_show (configDialogData.sms.number);
1474
1475     hbox = gtk_hbox_new (FALSE, 0);
1476     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 9);
1477     gtk_widget_show (hbox);
1478
1479     label = gtk_label_new (_("Sending Format:"));
1480     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1481     gtk_widget_show (label);
1482
1483     configDialogData.sms.format = gtk_option_menu_new ();
1484     menu = gtk_menu_new ();
1485     gtk_widget_set_usize (configDialogData.sms.format, 110, 28);
1486
1487     item = gtk_menu_item_new_with_label (_("Text"));
1488     gtk_signal_connect (GTK_OBJECT (item), "activate",
1489                         GTK_SIGNAL_FUNC(SetFormat),
1490                         (gpointer) GSMF_Text);
1491     gtk_widget_show (item);
1492     gtk_menu_append (GTK_MENU (menu), item);
1493
1494     item = gtk_menu_item_new_with_label (_("Fax"));
1495     gtk_signal_connect (GTK_OBJECT (item), "activate",
1496                         GTK_SIGNAL_FUNC(SetFormat),
1497                         (gpointer) GSMF_Fax);
1498     gtk_widget_show (item);
1499     gtk_menu_append (GTK_MENU (menu), item);
1500
1501     item = gtk_menu_item_new_with_label (_("Paging"));
1502     gtk_signal_connect (GTK_OBJECT (item), "activate",
1503                         GTK_SIGNAL_FUNC(SetFormat),
1504                         (gpointer) GSMF_Paging);
1505     gtk_widget_show (item);
1506     gtk_menu_append (GTK_MENU (menu), item);
1507
1508     item = gtk_menu_item_new_with_label (_("E-Mail"));
1509     gtk_signal_connect (GTK_OBJECT (item), "activate",
1510                         GTK_SIGNAL_FUNC(SetFormat),
1511                         (gpointer) GSMF_Email);
1512     gtk_widget_show (item);
1513     gtk_menu_append (GTK_MENU (menu), item);
1514
1515     gtk_option_menu_set_menu (GTK_OPTION_MENU (configDialogData.sms.format), menu);
1516     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.sms.format, FALSE, FALSE, 2);
1517     gtk_widget_show (configDialogData.sms.format);
1518
1519     hbox = gtk_hbox_new (FALSE, 0);
1520     gtk_box_pack_start (GTK_BOX (GTK_DIALOG (dialog)->vbox), hbox, FALSE, FALSE, 9);
1521     gtk_widget_show (hbox);
1522
1523     label = gtk_label_new (_("Validity Period:"));
1524     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
1525     gtk_widget_show (label);
1526
1527     configDialogData.sms.validity = gtk_option_menu_new ();
1528     menu = gtk_menu_new ();
1529     gtk_widget_set_usize (configDialogData.sms.validity, 110, 28);
1530
1531     item = gtk_menu_item_new_with_label (_("Max. Time"));
1532     gtk_signal_connect (GTK_OBJECT (item), "activate",
1533                         GTK_SIGNAL_FUNC(SetValidity),
1534                         (gpointer) GSMV_Max_Time);
1535     gtk_widget_show (item);
1536     gtk_menu_append (GTK_MENU (menu), item);
1537
1538     item = gtk_menu_item_new_with_label (_("1 h"));
1539     gtk_signal_connect (GTK_OBJECT (item), "activate",
1540                         GTK_SIGNAL_FUNC(SetValidity),
1541                         (gpointer) GSMV_1_Hour);
1542     gtk_widget_show (item);
1543     gtk_menu_append (GTK_MENU (menu), item);
1544
1545     item = gtk_menu_item_new_with_label (_("6 h"));
1546     gtk_signal_connect (GTK_OBJECT (item), "activate",
1547                         GTK_SIGNAL_FUNC(SetValidity),
1548                         (gpointer) GSMV_6_Hours);
1549     gtk_widget_show (item);
1550     gtk_menu_append (GTK_MENU (menu), item);
1551
1552     item = gtk_menu_item_new_with_label (_("24 h"));
1553     gtk_signal_connect (GTK_OBJECT (item), "activate",
1554                         GTK_SIGNAL_FUNC(SetValidity),
1555                         (gpointer) GSMV_24_Hours);
1556     gtk_widget_show (item);
1557     gtk_menu_append (GTK_MENU (menu), item);
1558
1559     item = gtk_menu_item_new_with_label (_("72 h"));
1560     gtk_signal_connect (GTK_OBJECT (item), "activate",
1561                         GTK_SIGNAL_FUNC(SetValidity),
1562                         (gpointer) GSMV_72_Hours);
1563     gtk_widget_show (item);
1564     gtk_menu_append (GTK_MENU (menu), item);
1565
1566     item = gtk_menu_item_new_with_label (_("1 week"));
1567     gtk_signal_connect (GTK_OBJECT (item), "activate",
1568                         GTK_SIGNAL_FUNC(SetValidity),
1569                         (gpointer) GSMV_1_Week);
1570     gtk_widget_show (item);
1571     gtk_menu_append (GTK_MENU (menu), item);
1572
1573     gtk_option_menu_set_menu (GTK_OPTION_MENU (configDialogData.sms.validity), menu);
1574     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.sms.validity, FALSE, FALSE, 2);
1575     gtk_widget_show (configDialogData.sms.validity);
1576   }
1577
1578   gtk_entry_set_text (GTK_ENTRY (configDialogData.sms.set),
1579                       configDialogData.sms.smsSetting
1580                       [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Name);
1581
1582   gtk_entry_set_text (GTK_ENTRY (configDialogData.sms.number),
1583                       configDialogData.sms.smsSetting
1584                       [GPOINTER_TO_INT(GTK_CLIST (SMSClist)->selection->data)].Number);
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[4] = { _("Set's name"), _("Center number"), _("Format"), _("Validity")};
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, 2);
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)), _("serial"));
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.irda = gtk_radio_button_new_with_label (
1795             gtk_radio_button_group (GTK_RADIO_BUTTON (configDialogData.connection.infrared)), _("irda"));
1796   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.connection.irda, TRUE, FALSE, 2);
1797   gtk_widget_show (configDialogData.connection.irda);
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 (4, 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_justification (GTK_CLIST (SMSClist), 1, GTK_JUSTIFY_RIGHT);
1963
1964   clistScrolledWindow = gtk_scrolled_window_new (NULL, NULL);
1965   gtk_container_add (GTK_CONTAINER (clistScrolledWindow), SMSClist);
1966   gtk_scrolled_window_set_policy (GTK_SCROLLED_WINDOW (clistScrolledWindow),
1967                                   GTK_POLICY_AUTOMATIC, GTK_POLICY_AUTOMATIC);
1968   gtk_box_pack_start (GTK_BOX (vbox), clistScrolledWindow,
1969                       TRUE, TRUE, 10);
1970
1971   gtk_widget_show (SMSClist);
1972   gtk_widget_show (clistScrolledWindow);
1973
1974   hbox = gtk_hbox_new (FALSE, 0);
1975   gtk_box_pack_end (GTK_BOX (vbox), hbox, FALSE, FALSE, 9);
1976   gtk_widget_show (hbox);
1977
1978   button = gtk_button_new_with_label (_("Edit"));
1979   gtk_box_pack_start (GTK_BOX (hbox),
1980                       button, TRUE, FALSE, 0);
1981   gtk_signal_connect (GTK_OBJECT (button), "clicked",
1982                       GTK_SIGNAL_FUNC (ShowEditSMSSetDialog), (gpointer)dialog);
1983   GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1984   gtk_widget_grab_default (button);
1985   gtk_widget_show (button);
1986
1987   gtk_signal_connect (GTK_OBJECT (SMSClist), "select_row",
1988                       GTK_SIGNAL_FUNC (EditSMSSetDialogClick),
1989                       (gpointer) button);
1990
1991   /***  Business notebook  ***/
1992   user_option_frame = gtk_frame_new (_("Business Card"));
1993
1994   vbox = gtk_vbox_new( FALSE, 0);
1995   gtk_container_add (GTK_CONTAINER (user_option_frame), vbox);
1996   gtk_widget_show(vbox);
1997
1998   label = gtk_label_new(_("User"));
1999   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), user_option_frame, label);
2000
2001   hbox = gtk_hbox_new (FALSE, 0);
2002   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2003   gtk_widget_show (hbox);
2004
2005   configDialogData.user.status = gtk_label_new ("");
2006   gtk_box_pack_end(GTK_BOX(hbox), configDialogData.user.status, FALSE, FALSE, 2);
2007   gtk_widget_show (configDialogData.user.status);
2008
2009   configDialogData.user.max = MAX_BUSINESS_CARD_LENGTH;
2010   configDialogData.user.used = 0;
2011
2012   hbox = gtk_hbox_new (FALSE, 0);
2013   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2014   gtk_widget_show (hbox);
2015
2016   label = gtk_label_new (_("Name:"));
2017   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2018   gtk_widget_show (label);
2019
2020   configDialogData.user.name = gtk_entry_new_with_max_length(configDialogData.user.max);
2021   gtk_widget_set_usize (configDialogData.user.name, 220, 22);
2022   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.name),
2023                       "key_press_event",
2024                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2025   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.name),
2026                       "button_press_event",
2027                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2028   gtk_signal_connect (GTK_OBJECT (configDialogData.user.name),
2029                       "focus_in_event",
2030                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 0);
2031   gtk_signal_connect (GTK_OBJECT (configDialogData.user.name),
2032                       "focus_out_event",
2033                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2034                       (gpointer) configDialogData.user.max);
2035   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.name, FALSE, FALSE, 2);
2036   gtk_widget_show (configDialogData.user.name);
2037
2038   hbox = gtk_hbox_new (FALSE, 0);
2039   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2040   gtk_widget_show (hbox);
2041
2042   label = gtk_label_new (_("Title:"));
2043   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2044   gtk_widget_show (label);
2045
2046   configDialogData.user.title = gtk_entry_new_with_max_length(configDialogData.user.max);
2047   gtk_widget_set_usize (configDialogData.user.title, 220, 22);
2048   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.title),
2049                       "key_press_event",
2050                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2051   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.title),
2052                       "button_press_event",
2053                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2054   gtk_signal_connect (GTK_OBJECT (configDialogData.user.title),
2055                       "focus_in_event",
2056                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 1);
2057   gtk_signal_connect (GTK_OBJECT (configDialogData.user.title),
2058                       "focus_out_event",
2059                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2060                       (gpointer) configDialogData.user.max);
2061   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.title, FALSE, FALSE, 2);
2062   gtk_widget_show (configDialogData.user.title);
2063
2064   hbox = gtk_hbox_new (FALSE, 0);
2065   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2066   gtk_widget_show (hbox);
2067
2068   label = gtk_label_new (_("Company:"));
2069   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2070   gtk_widget_show (label);
2071
2072   configDialogData.user.company = gtk_entry_new_with_max_length(configDialogData.user.max);
2073   gtk_widget_set_usize (configDialogData.user.company, 220, 22);
2074   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.company),
2075                       "key_press_event",
2076                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2077   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.company),
2078                       "button_press_event",
2079                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2080   gtk_signal_connect (GTK_OBJECT (configDialogData.user.company),
2081                       "focus_in_event",
2082                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 2);
2083   gtk_signal_connect (GTK_OBJECT (configDialogData.user.company),
2084                       "focus_out_event",
2085                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2086                       (gpointer) configDialogData.user.max);
2087   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.company, FALSE, FALSE, 2);
2088   gtk_widget_show (configDialogData.user.company);
2089
2090   hbox = gtk_hbox_new (FALSE, 0);
2091   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2092   gtk_widget_show (hbox);
2093
2094   label = gtk_label_new (_("Telephone:"));
2095   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2096   gtk_widget_show (label);
2097
2098   configDialogData.user.telephone = gtk_entry_new_with_max_length(max_phonebook_number_length);
2099   gtk_widget_set_usize (configDialogData.user.telephone, 220, 22);
2100   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.telephone),
2101                       "key_press_event",
2102                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2103   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.telephone),
2104                       "button_press_event",
2105                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2106   gtk_signal_connect (GTK_OBJECT (configDialogData.user.telephone),
2107                       "focus_in_event",
2108                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 3);
2109   gtk_signal_connect (GTK_OBJECT (configDialogData.user.telephone),
2110                       "focus_out_event",
2111                       GTK_SIGNAL_FUNC(CheckOutUserDataLength), (gpointer) max_phonebook_number_length);
2112   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.telephone, FALSE, FALSE, 2);
2113   gtk_widget_show (configDialogData.user.telephone);
2114
2115   hbox = gtk_hbox_new (FALSE, 0);
2116   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2117   gtk_widget_show (hbox);
2118
2119   label = gtk_label_new (_("Fax:"));
2120   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2121   gtk_widget_show (label);
2122
2123   configDialogData.user.fax = gtk_entry_new_with_max_length(max_phonebook_number_length);
2124   gtk_widget_set_usize (configDialogData.user.fax, 220, 22);
2125   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.fax),
2126                       "key_press_event",
2127                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2128   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.fax),
2129                       "button_press_event",
2130                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2131   gtk_signal_connect (GTK_OBJECT (configDialogData.user.fax),
2132                       "focus_in_event",
2133                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 4);
2134   gtk_signal_connect (GTK_OBJECT (configDialogData.user.fax),
2135                       "focus_out_event",
2136                       GTK_SIGNAL_FUNC(CheckOutUserDataLength), (gpointer) max_phonebook_number_length);
2137   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.fax, FALSE, FALSE, 2);
2138   gtk_widget_show (configDialogData.user.fax);
2139
2140   hbox = gtk_hbox_new (FALSE, 0);
2141   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2142   gtk_widget_show (hbox);
2143
2144   label = gtk_label_new (_("E-Mail:"));
2145   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2146   gtk_widget_show (label);
2147
2148   configDialogData.user.email = gtk_entry_new_with_max_length(configDialogData.user.max);
2149   gtk_widget_set_usize (configDialogData.user.email, 220, 22);
2150   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.email),
2151                       "key_press_event",
2152                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2153   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.email),
2154                       "button_press_event",
2155                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2156   gtk_signal_connect (GTK_OBJECT (configDialogData.user.email),
2157                       "focus_in_event",
2158                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 5);
2159   gtk_signal_connect (GTK_OBJECT (configDialogData.user.email),
2160                       "focus_out_event",
2161                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2162                       (gpointer) configDialogData.user.max);
2163   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.email, FALSE, FALSE, 2);
2164   gtk_widget_show (configDialogData.user.email);
2165
2166   hbox = gtk_hbox_new (FALSE, 0);
2167   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2168   gtk_widget_show (hbox);
2169
2170   label = gtk_label_new (_("Address:"));
2171   gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 2);
2172   gtk_widget_show (label);
2173
2174   configDialogData.user.address = gtk_entry_new_with_max_length(configDialogData.user.max);
2175   gtk_widget_set_usize (configDialogData.user.address, 220, 22);
2176   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.address),
2177                       "key_press_event",
2178                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2179   gtk_signal_connect_after (GTK_OBJECT (configDialogData.user.address),
2180                       "button_press_event",
2181                       GTK_SIGNAL_FUNC(RefreshUserStatusCallBack), (gpointer) NULL);
2182   gtk_signal_connect (GTK_OBJECT (configDialogData.user.address),
2183                       "focus_in_event",
2184                       GTK_SIGNAL_FUNC(CheckInUserDataLength), (gpointer) 6);
2185   gtk_signal_connect (GTK_OBJECT (configDialogData.user.address),
2186                       "focus_out_event",
2187                       GTK_SIGNAL_FUNC(CheckOutUserDataLength),
2188                       (gpointer) configDialogData.user.max);
2189   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.user.address, FALSE, FALSE, 2);
2190   gtk_widget_show (configDialogData.user.address);
2191
2192
2193   /***  Groups notebook  ***/
2194   cg_names_option_frame = gtk_frame_new (_("Caller groups names"));
2195
2196
2197   vbox = gtk_vbox_new (FALSE, 0);
2198   gtk_container_add (GTK_CONTAINER (cg_names_option_frame), vbox);
2199   gtk_widget_show (vbox);
2200
2201   label = gtk_label_new (_("Groups"));
2202   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), cg_names_option_frame, label);
2203
2204   for ( i = 0; i < 6; i++)
2205   {
2206     hbox = gtk_hbox_new (FALSE, 0);
2207     gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 3);
2208     gtk_widget_show (hbox);
2209
2210     g_snprintf (labelBuffer, 10, _("Group %d:"), i + 1);
2211     label = gtk_label_new (labelBuffer);
2212     gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 2);
2213     gtk_widget_show (label);
2214
2215     configDialogData.groups[i] = gtk_entry_new_with_max_length (MAX_CALLER_GROUP_LENGTH);
2216     gtk_widget_set_usize (configDialogData.groups[i], 220, 22);
2217
2218     gtk_box_pack_end (GTK_BOX (hbox), configDialogData.groups[i], FALSE, FALSE, 2);
2219     gtk_widget_show (configDialogData.groups[i]);
2220   }
2221
2222   /* Mail */
2223   mail_option_frame = gtk_frame_new (_("Mailbox"));
2224   gtk_widget_show (mail_option_frame);
2225
2226   vbox = gtk_vbox_new (FALSE, 0);
2227   gtk_container_add (GTK_CONTAINER (mail_option_frame), vbox);
2228   gtk_widget_show (vbox);
2229
2230   label = gtk_label_new (_("Mail"));
2231   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), mail_option_frame, label);
2232
2233   hbox = gtk_hbox_new (FALSE, 0);
2234   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2235   gtk_widget_show (hbox);
2236
2237   label = gtk_label_new (_("Path to mailbox:"));
2238   gtk_box_pack_start(GTK_BOX (hbox), label, FALSE, FALSE, 2);
2239   gtk_widget_show (label);
2240
2241   configDialogData.mailbox = gtk_entry_new_with_max_length (MAILBOX_LENGTH - 1);
2242   gtk_widget_set_usize (configDialogData.mailbox, 220, 22);
2243
2244   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.mailbox, FALSE, FALSE, 2);
2245   gtk_widget_show (configDialogData.mailbox);
2246
2247   /* Help */
2248   frame = gtk_frame_new (_("Help viewer"));
2249   gtk_widget_show (frame);
2250
2251   vbox = gtk_vbox_new (FALSE, 0);
2252   gtk_container_add (GTK_CONTAINER (frame), vbox);
2253   gtk_widget_show (vbox);
2254
2255   label = gtk_label_new (_("Help"));
2256   gtk_notebook_append_page( GTK_NOTEBOOK (notebook), frame, label);
2257
2258   hbox = gtk_hbox_new (FALSE, 0);
2259   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
2260   gtk_widget_show (hbox);
2261
2262   label = gtk_label_new (_("Viewer:"));
2263   gtk_box_pack_start(GTK_BOX (hbox), label, FALSE, FALSE, 2);
2264   gtk_widget_show (label);
2265
2266   configDialogData.help = gtk_entry_new_with_max_length (HTMLVIEWER_LENGTH - 1);
2267   gtk_widget_set_usize (configDialogData.help, 220, 22);
2268
2269   gtk_box_pack_end (GTK_BOX (hbox), configDialogData.help, FALSE, FALSE, 2);
2270   gtk_widget_show (configDialogData.help);
2271
2272
2273   optionsDialogIsOpened = FALSE;
2274   return dialog;
2275 }
2276
2277
2278 static void TopLevelWindow (void)
2279 {
2280   GtkWidget *drawing_area;
2281   GdkBitmap *mask;
2282   GtkStyle *style;
2283   GdkGC *gc;
2284   struct sigaction act;
2285
2286   GUI_MainWindow = gtk_window_new (GTK_WINDOW_TOPLEVEL);
2287   gtk_window_set_wmclass (GTK_WINDOW (GUI_MainWindow), "MainWindow", "Xgnokii");
2288 /*  gtk_window_set_decorated (GTK_WINDOW (GUI_MainWindow), GTK_FALSE); */
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   CreateErrorDialog (&errorDialog, GUI_MainWindow);
2345   CreateInfoDialog (&infoDialog, GUI_MainWindow);
2346   CreateInCallDialog ();
2347
2348   act.sa_handler = RemoveZombie;
2349   sigemptyset (&(act.sa_mask));
2350   act.sa_flags = SA_NOCLDSTOP;
2351   sigaction (SIGCHLD, &act, NULL);
2352
2353 #if __unices__
2354   act.sa_handler = SIG_IGN;
2355   sigemptyset (&(act.sa_mask));
2356   sigaction (SIGALRM, &act, NULL);
2357 #endif
2358
2359   gtk_widget_show_all (GUI_MainWindow);
2360   GUI_Refresh ();
2361
2362   GUI_InitPhoneMonitor ();
2363   pthread_create (&monitor_th, NULL, GUI_Connect, NULL);
2364
2365   gtk_timeout_add (1000, (GtkFunction) Update, GUI_MainWindow);
2366
2367   hiddenCallDialog = 0;
2368 }
2369
2370
2371 static void SplashScreen (void)
2372 {
2373   GtkWidget *pixmap, *fixed;
2374   GdkPixmap *gdk_pixmap;
2375   GdkBitmap *mask;
2376   GtkStyle *style;
2377   GdkGC *gc;
2378
2379   SplashWindow = gtk_window_new (GTK_WINDOW_POPUP);
2380   gtk_widget_realize (SplashWindow);
2381
2382   gtk_widget_set_usize (SplashWindow, 475, 160);
2383   gtk_window_position (GTK_WINDOW (SplashWindow), GTK_WIN_POS_CENTER);
2384
2385   style = gtk_widget_get_default_style();
2386   gc = style->black_gc;
2387   gdk_pixmap = gdk_pixmap_create_from_xpm_d(SplashWindow->window, &mask,
2388                                             &style->bg[GTK_STATE_NORMAL],
2389                                             XPM_logo);
2390   pixmap = gtk_pixmap_new(gdk_pixmap, mask);
2391
2392   fixed = gtk_fixed_new();
2393   gtk_widget_set_usize(fixed, 261, 96);
2394   gtk_fixed_put(GTK_FIXED(fixed), pixmap, 0, 0);
2395   gtk_container_add(GTK_CONTAINER (SplashWindow), fixed);
2396
2397   gtk_widget_shape_combine_mask (SplashWindow, mask, 0, 0);
2398
2399   gtk_widget_show_all (SplashWindow);
2400 }
2401
2402
2403 static gint RemoveSplash (GtkWidget *Win)
2404 {
2405   if (GTK_WIDGET_VISIBLE (SplashWindow))
2406   {
2407     gtk_timeout_remove (splashRemoveHandler);
2408     gtk_widget_hide (SplashWindow);
2409     gtk_widget_destroy (SplashWindow);
2410     return TRUE;
2411   }
2412
2413   return FALSE;
2414 }
2415
2416 static void ReadConfig (void)
2417 {
2418 #ifdef WIN32
2419   xgnokiiConfig.locale = "";
2420 #else
2421   if ((xgnokiiConfig.locale = getenv ("LC_ALL")) == NULL)
2422     if ((xgnokiiConfig.locale = getenv ("LC_MESSAGES")) == NULL)
2423       if ((xgnokiiConfig.locale = getenv ("LANG")) == NULL)
2424         xgnokiiConfig.locale = "POSIX";
2425 #endif
2426   if (readconfig(&xgnokiiConfig.model, &xgnokiiConfig.port,
2427            &xgnokiiConfig.initlength, &xgnokiiConfig.connection,
2428            &xgnokiiConfig.bindir) < 0)
2429   {
2430     exit(-1);
2431   }
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
2440 #if 0
2441   if (strstr(FB38_Information.Models, xgnokiiConfig.model) != NULL)
2442   {
2443     max_phonebook_number_length = 30;
2444     max_phonebook_sim_number_length = 30;
2445   }
2446   else
2447 #endif
2448 #endif
2449 #if 0
2450   if (strstr(FB61_Information.Models, xgnokiiConfig.model) != NULL)
2451   {
2452     max_phonebook_number_length = FB61_MAX_PHONEBOOK_NUMBER_LENGTH;
2453     max_phonebook_sim_number_length = FB61_MAX_PHONEBOOK_NUMBER_LENGTH;
2454   }
2455   else
2456 #endif
2457   {
2458     max_phonebook_number_length = max_phonebook_sim_number_length = GSM_MAX_PHONEBOOK_NUMBER_LENGTH;
2459   }
2460
2461   xgnokiiConfig.callerGroups[0] = xgnokiiConfig.callerGroups[1] =
2462   xgnokiiConfig.callerGroups[2] = xgnokiiConfig.callerGroups[3] =
2463   xgnokiiConfig.callerGroups[4] = xgnokiiConfig.callerGroups[5] = NULL;
2464   xgnokiiConfig.smsSets = 0;
2465 }
2466
2467
2468 int main (int argc, char *argv[])
2469 {
2470 #ifdef USE_NLS
2471   textdomain("gnokii");
2472 #endif
2473
2474   (void) gtk_set_locale ();
2475
2476   gtk_init (&argc, &argv);
2477
2478   /* Show the splash screen. */
2479
2480   SplashScreen ();
2481
2482   /* Remove it after a while. */
2483
2484   ReadConfig ();
2485   TopLevelWindow ();
2486
2487   splashRemoveHandler = gtk_timeout_add(5000, (GtkFunction) RemoveSplash, (gpointer) SplashWindow);
2488
2489   gtk_main ();
2490
2491   return (0);
2492 }