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