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