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>.
11 Released under the terms of the GNU GPL, see file COPYING for more details.
14 Revision 1.1.1.5 2002/04/03 00:08:33 short
15 Found in "gnokii-working" directory, some November-patches version
17 Revision 1.9 2001/09/14 12:53:00 pkot
20 Set valid operator on logos xgnokii screen.
22 Revision 1.8 2001/05/24 20:47:31 chris
23 More updating of 7110 code and some of xgnokii_lowlevel changed over.
25 Revision 1.7 2001/03/23 08:24:56 ja
26 New preview for 6210 in xgnokii's logos module.
35 #include <sys/types.h>
40 #include "gsm-common.h"
42 #include "cfgreader.h"
43 #include "gsm-networks.h"
44 #include "gsm-filetypes.h"
45 #include "gsm-bitmaps.h"
47 #include "xgnokii_logos.h"
48 #include "xgnokii_common.h"
49 #include "xgnokii_lowlevel.h"
52 #include "xpm/Operator_logo.xpm"
53 #include "xpm/Startup_logo.xpm"
54 #include "xpm/Caller_logo.xpm"
56 #include "xpm/Black_point.xpm"
57 #include "xpm/Green_point.xpm"
58 #include "xpm/Green_pixel.xpm"
60 #include "xpm/New.xpm"
61 #include "xpm/Send.xpm"
62 #include "xpm/SendSMS.xpm"
63 #include "xpm/Read.xpm"
64 #include "xpm/Open.xpm"
65 #include "xpm/Save.xpm"
67 #include "xpm/Edit_invert.xpm"
68 #include "xpm/Edit_flip_horizontal.xpm"
69 #include "xpm/Edit_flip_vertical.xpm"
71 #include "xpm/Tool_brush.xpm"
72 #include "xpm/Tool_line.xpm"
73 #include "xpm/Tool_rectangle.xpm"
74 #include "xpm/Tool_filled_rectangle.xpm"
76 extern GSM_Network GSM_Networks[];
77 extern GSM_Statemachine xgnokii_statemachine; /* from xgnokii_lowlevel.c */
79 GtkWidget *GUI_LogosWindow;
81 ErrorDialog errorDialog = {NULL, NULL};
82 InfoDialog infoDialog = {NULL, NULL};
84 /* stuff for drawingArea */
85 GtkWidget *drawingArea = NULL;
86 GdkPixmap *drawingPixmap = NULL;
87 GdkPixmap *greenPointPixmap, *blackPointPixmap;
88 int drawingAreaWidth, drawingAreaHeight; /* in pixels */
89 int mouseButtonPushed = 0;
91 /* stuff for previewArea */
92 GtkWidget *previewArea = NULL;
93 GdkPixmap *previewPixmap = NULL;
94 GdkPixmap *greenPixelPixmap;
95 int previewPixmapWidth, previewPixmapHeight;
96 int previewAvailable = 1, showPreviewErrorDialog = 1;
97 int previewPixmapNumber = 0;
99 GSM_Bitmap bitmap, oldBitmap;
100 GSM_NetworkInfo networkInfo;
102 /* widgets for toolbar - some, need global variables */
103 GtkWidget *buttonStartup, *buttonOperator, *buttonCaller;
104 GtkWidget *networkCombo, *callerCombo;
106 int activeTool = TOOL_BRUSH;
107 int toolStartX, toolStartY, toolLastX, toolLastY;
109 /* tools for drawing */
110 static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
111 static GtkWidget *buttonFilledRectangle;
113 /* Contains fileName for Export dialog. */
118 static ExportDialogData exportDialogData = {NULL};
120 GtkWidget *FileSelection;
122 static int callersGroupsInitialized = 0;
124 /* returns lowest number from three numbers */
125 int GetMinFrom3(int a, int b, int c) {
139 /* returns highest number from three numbers */
140 int GetMaxFrom3(int a, int b, int c) {
154 /* load preview pixmap from file */
155 GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
160 if (previewPixmapNumber == 0)
162 if (!strcmp (xgnokiiConfig.model, "6110") ||
163 !strcmp (xgnokiiConfig.model, "6120"))
165 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
166 "/xpm/Preview_6110.xpm");
167 previewPixmapNumber = 1;
169 else if (!strcmp (xgnokiiConfig.model, "6130") ||
170 !strcmp (xgnokiiConfig.model, "6150") ||
171 !strcmp (xgnokiiConfig.model, "616x") ||
172 !strcmp (xgnokiiConfig.model, "6185") ||
173 !strcmp (xgnokiiConfig.model, "6190"))
175 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
176 "/xpm/Preview_6150.xpm");
177 previewPixmapNumber = 2;
179 else if (!strcmp (xgnokiiConfig.model, "3210"))
181 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
182 "/xpm/Preview_3210.xpm");
183 previewPixmapNumber = 3;
185 else if (!strcmp (xgnokiiConfig.model, "3310") ||
186 !strcmp (xgnokiiConfig.model, "3330"))
188 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
189 "/xpm/Preview_3310.xpm");
190 previewPixmapNumber = 4;
192 else if (!strcmp (xgnokiiConfig.model, "5110") ||
193 !strcmp (xgnokiiConfig.model, "5130"))
195 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
196 "/xpm/Preview_5110.xpm");
197 previewPixmapNumber = 5;
199 else if (!strcmp (xgnokiiConfig.model, "6250"))
201 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
202 "/xpm/Preview_6250.xpm");
203 previewPixmapNumber = 6;
205 else if (!strcmp (xgnokiiConfig.model, "7110"))
207 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
208 "/xpm/Preview_7110.xpm");
209 previewPixmapNumber = 7;
213 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
214 "/xpm/Preview_6210.xpm");
215 previewPixmapNumber = 8;
219 switch (previewPixmapNumber)
221 case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
222 "/xpm/Preview_6110.xpm");
224 case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
225 "/xpm/Preview_6150.xpm");
227 case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
228 "/xpm/Preview_3210.xpm");
230 case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
231 "/xpm/Preview_3310.xpm");
233 case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
234 "/xpm/Preview_5110.xpm");
236 case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
237 "/xpm/Preview_6250.xpm");
239 case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
240 "/xpm/Preview_7110.xpm");
242 default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
243 "/xpm/Preview_6210.xpm");
247 pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
248 &widget->style->bg[GTK_STATE_NORMAL],
256 /* ********************************************************
257 * ** SET/CLEAR POINTS ************************************
258 * ********************************************************
260 void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
261 if (!previewAvailable) return;
263 /* there is difference between positiong of startupLogo and others */
264 if (bitmap.type != GSM_StartupLogo) {
269 /* draw point to pixmap */
271 gdk_draw_point(previewPixmap,widget->style->black_gc,
272 x+PREVIEWSTARTX,y+PREVIEWSTARTY);
275 GdkRectangle updateRect;
277 /* update point on screen */
278 updateRect.width = 1;
279 updateRect.height = 1;
280 updateRect.x = PREVIEWSTARTX+x;
281 updateRect.y = PREVIEWSTARTY+y;
283 gtk_widget_draw(previewArea,&updateRect);
287 void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
288 if (!previewAvailable) return;
290 /* there is difference between positiong of startupLogo and others */
291 if (bitmap.type != GSM_StartupLogo) {
296 /* clean point from pixmap - any idea how to draw green point without pixmap? */
298 gdk_draw_pixmap(previewPixmap,
299 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
300 greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
302 GdkRectangle updateRect;
304 /* clean from screen too */
305 updateRect.width = 1;
306 updateRect.height = 1;
307 updateRect.x = PREVIEWSTARTX+x;
308 updateRect.y = PREVIEWSTARTY+y;
310 gtk_widget_draw(previewArea,&updateRect);
314 int IsPoint(int x, int y) {
315 return GSM_IsPointBitmap(&bitmap,x,y);
318 void SetPoint(GtkWidget *widget, int x, int y, int update) {
319 /* difference between settings points in startupLogo and others */
320 GSM_SetPointBitmap(&bitmap,x,y);
322 /* draw point to pixmap */
323 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
324 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
327 GdkRectangle updateRect;
329 /* calculate update rectangle */
330 updateRect.width = POINTSIZE+2;
331 updateRect.height = POINTSIZE+2;
332 updateRect.x = x * (POINTSIZE+1);
333 updateRect.y = y * (POINTSIZE+1);
335 /* update on screen */
336 gtk_widget_draw(drawingArea,&updateRect);
339 /* draw preview point too */
340 if (previewAvailable) SetPreviewPoint(widget,x,y,update);
343 void ClearPoint(GtkWidget *widget, int x, int y, int update) {
344 /* difference between settings points in startupLogo and others */
345 GSM_ClearPointBitmap(&bitmap,x,y);
347 /* clear point from pixmap */
348 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
349 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
352 GdkRectangle updateRect;
354 /* calculate update rectangle */
355 updateRect.width = POINTSIZE+2;
356 updateRect.height = POINTSIZE+2;
357 updateRect.x = x * (POINTSIZE+1);
358 updateRect.y = y * (POINTSIZE+1);
360 /* update on screen */
361 gtk_widget_draw(drawingArea,&updateRect);
364 /* clear point from previewArea too */
365 if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
368 /* ****************************************************
369 * *** UPDATES - PREVIEW & DRAWING AREAS **************
370 * ****************************************************
373 /* this redraw all logo points - preview & drawing area */
374 void UpdatePointsRectangle(GtkWidget *widget, int x1, int y1, int x2, int y2) {
375 GdkRectangle updateRect;
376 int x, y, dx = 0, dy = 0;
378 if (bitmap.type != GSM_StartupLogo) {
395 for (y = y1;y <= y2;y++)
396 for (x = x1;x <= x2;x++) {
398 /* set on drawing area */
399 gdk_draw_pixmap(drawingPixmap,
400 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
401 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
404 if (previewAvailable && previewPixmap)
405 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
406 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
408 /* clear from drawing */
409 gdk_draw_pixmap(drawingPixmap,
410 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
411 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
413 /* clear from preview */
414 if (previewAvailable && previewPixmap)
415 gdk_draw_pixmap(previewPixmap,
416 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
417 greenPixelPixmap,0,0,x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,
422 if (previewAvailable) {
423 updateRect.x = PREVIEWSTARTX+dx+x1;
424 updateRect.y = PREVIEWSTARTY+dy+y1;
425 updateRect.width = x2-x1+1;
426 updateRect.height = y2-y1+1;
427 gtk_widget_draw(previewArea,&updateRect);
430 updateRect.x = x1*(POINTSIZE+1);
431 updateRect.y = y1*(POINTSIZE+1);
432 updateRect.width = (x2-x1+1)*(POINTSIZE+1)+1;
433 updateRect.height = (y2-y1+1)*(POINTSIZE+1)+1;
434 gtk_widget_draw(drawingArea,&updateRect);
437 void UpdatePoints(GtkWidget *widget) {
438 UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
441 /* this redraw all logo points in previewArea, NO DRAWING AREA */
442 void UpdatePreviewPoints (void) {
443 GdkRectangle updateRect;
444 int x, y, dx = 0, dy = 0;
446 if (!previewPixmap || !previewAvailable) return;
448 if (bitmap.type != GSM_StartupLogo) {
453 for (y = 0;y < bitmap.height;y++)
454 for (x = 0;x < bitmap.width;x++) {
456 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
457 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
459 gdk_draw_pixmap(previewPixmap,
460 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
461 greenPixelPixmap,0,0,
462 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,1,1);
468 updateRect.width = bitmap.width;
469 updateRect.height = bitmap.height;
470 gtk_widget_draw(previewArea,&updateRect);
473 /* ******************************************************
474 * **** DRAWING TOOLS ***********************************
475 * ******************************************************
479 void ToolBrush(GtkWidget *widget, int column, int row, int button) {
480 /* only this tool directly update bitmap & screen */
482 ClearPoint(widget,column,row,1);
484 SetPoint(widget,column,row,1);
489 /* this function clear or draw a line on the screen USED BY TOOLLINEUPDATE */
490 void ToolLine(GtkWidget *widget, int x1, int y1, int x2, int y2, int draw) {
491 int udx, udy, dx, dy, error, loop, xadd, yadd;
493 dx = x2 - x1; /* x delta */
494 dy = y2 - y1; /* y delta */
496 udx = abs(dx); /* unsigned x delta */
497 udy = abs(dy); /* unsigned y delta */
499 if (dx < 0) { xadd = -1; } else { xadd = 1; } /* set directions */
500 if (dy < 0) { yadd = -1; } else { yadd = 1; }
504 if (udx > udy) { /* delta X > delta Y */
508 if (error >= udx) { /* is time to move up or down? */
514 SetPoint(widget,x1,y1,0);
516 /* now clearing line before drawing new one, we must check */
517 /* if there is a point in oldBitmap which saves bitmap before */
518 /* we starting drawing new line */
519 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
520 ClearPoint(widget,x1,y1,0);
523 x1 += xadd; /* move horizontally */
524 } while (loop < udx); /* repeat for x length */
528 if (error >= udy) { /* is time to move left or right? */
534 SetPoint(widget,x1,y1,0);
536 /* check comment in delta X > delta Y */
537 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
538 ClearPoint(widget,x1,y1,0);
541 y1 += yadd; /* move vertically */
542 } while (loop < udy); /* repeat for y length */
546 /* going to rewrite to Bresenham algorithm */
547 void ToolLineUpdate(GtkWidget *widget, int column, int row) {
549 ToolLine(widget,toolStartX,toolStartY,toolLastX,toolLastY,0);
551 ToolLine(widget,toolStartX,toolStartY,column,row,1);
554 /* TOOL - FILLED RECT */
556 /* FIXME - going to rewrite for optimalized version, clearing and */
557 /* drawing new parts only before clearing and drawing whole */
558 /* filled rectangle - it's too slow on diskless terminal ;(( */
559 void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
560 int i, j, x1, y1, x2, y2;
562 /* swap Xs to x1 < x2 */
563 if (toolStartX > toolLastX) {
571 /* swap Ys to y1 < y2 */
572 if (toolStartY > toolLastY) {
581 for (j = y1;j <= y2;j++)
582 for (i = x1;i <= x2;i++)
583 if (!GSM_IsPointBitmap(&oldBitmap,i,j)) ClearPoint(widget,i,j,0);
585 /* swap Xs to x1 < x2 */
586 if (toolStartX > column) {
594 /* swap Ys to y1 < y2 */
595 if (toolStartY > row) {
604 for (j = y1;j <= y2;j++)
605 for (i = x1;i <= x2;i++)
606 SetPoint(widget,i,j,0);
609 /* TOOL - RECTANGLE */
610 void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
611 int i, j, x1, y1, x2, y2;
613 /* clear old rectangle */
614 /* swap Xs to x1 < x2 */
615 if (toolStartX > toolLastX) {
623 /* swap Ys to y1 < y2 */
624 if (toolStartY > toolLastY) {
633 for (i = x1;i <= x2;i++) {
634 if (!GSM_IsPointBitmap(&oldBitmap,i,y1)) ClearPoint(widget,i,y1,0);
635 if (!GSM_IsPointBitmap(&oldBitmap,i,y2)) ClearPoint(widget,i,y2,0);
638 for (j = y1;j <= y2;j++) {
639 if (!GSM_IsPointBitmap(&oldBitmap,x1,j)) ClearPoint(widget,x1,j,0);
640 if (!GSM_IsPointBitmap(&oldBitmap,x2,j)) ClearPoint(widget,x2,j,0);
643 /* draw new rectangle */
644 /* swap Xs to x1 < x2 */
645 if (toolStartX > column) {
653 /* swap Ys to y1 < y2 */
654 if (toolStartY > row) {
663 for (i = x1;i <= x2;i++) {
664 if (!IsPoint(i,y1)) SetPoint(widget,i,y1,0);
665 if (!IsPoint(i,y2)) SetPoint(widget,i,y2,0);
668 for (j = y1;j <= y2;j++) {
669 if (!IsPoint(x1,j)) SetPoint(widget,x1,j,0);
670 if (!IsPoint(x2,j)) SetPoint(widget,x2,j,0);
674 /* this update tools actions on the screen - this is for optimalization */
675 /* eg. for faster redrawing tools actions - we do not need redraw pixel */
676 /* by pixel. Faster is redraw whole rectangle which contains all changes */
677 void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
678 GdkRectangle updateRect;
680 /* update preview area */
681 if (previewAvailable) {
682 updateRect.x = PREVIEWSTARTX+x1;
683 updateRect.y = PREVIEWSTARTY+y1;
684 if (bitmap.type != GSM_StartupLogo) {
685 updateRect.x += PREVIEWJUMPX;
686 updateRect.y += PREVIEWJUMPY;
688 updateRect.width = x2-x1+1;
689 updateRect.height = y2-y1+1;
690 gtk_widget_draw(previewArea,&updateRect);
693 /* update drawing area */
694 updateRect.x = x1 * (POINTSIZE+1);
695 updateRect.y = y1 * (POINTSIZE+1);
696 updateRect.width = (x2-x1+1)*(POINTSIZE+2);
697 updateRect.height = (y2-y1+1)*(POINTSIZE+2);
698 gtk_widget_draw(drawingArea,&updateRect);
701 /* *************************************
702 * ** PREVIEW AREA EVENTS **************
703 * *************************************
706 gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
707 previewPixmapNumber = (previewPixmapNumber % 8) + 1;
709 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
710 previewPixmapWidth,previewPixmapHeight);
715 gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
716 if (previewPixmap) gdk_pixmap_unref(previewPixmap);
717 previewPixmap = GetPreviewPixmap(widget);
719 UpdatePreviewPoints();
724 gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
725 /* got previewPixmap? */
727 /* yes - simply redraw some rectangle */
728 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
729 previewPixmap,event->area.x,event->area.y,event->area.x,
730 event->area.y,event->area.width,event->area.height);
735 /* ********************************
736 * ** DRAWING AREA EVENTS *********
737 * ********************************
740 gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
741 /* got drawingPixmap? */
742 if (drawingPixmap == NULL) return TRUE;
744 if (!mouseButtonPushed) {
745 if ((event->button == 1 && activeTool != TOOL_BRUSH) ||
746 (activeTool == TOOL_BRUSH)) {
747 /* position from we starting drawing */
748 toolStartX = event->x / (POINTSIZE+1);
749 if (toolStartX < 0) toolStartX = 0;
750 if (toolStartX > bitmap.width-1) toolStartX = bitmap.width-1;
752 toolStartY = event->y / (POINTSIZE+1);
753 if (toolStartY < 0) toolStartY = 0;
754 if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
756 toolLastX = toolStartX;
757 toolLastY = toolStartY;
759 /* store old bitmap for drawing, resp. for moving, resizing primitive */
760 memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
763 if (event->button == 1) mouseButtonPushed = 1;
765 switch (activeTool) {
767 ToolBrush(widget,toolStartX,toolStartY,event->button);
771 if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
776 /* user is drawing some tool other than TOOL_BRUSH and pushed mouse button
777 * another than first => cancel tool and redraw to oldBitmap (bitmap when
778 * user start drawing)
780 if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
781 int lowestX, lowestY, highestX, highestY;
784 lowestX = GetMinFrom3(toolStartX,toolLastX,toolLastX);
785 lowestY = GetMinFrom3(toolStartY,toolLastY,toolLastY);
786 highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
787 highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
789 for (j = lowestY;j <= highestY;j++)
790 for (i = lowestX;i <= highestX;i++)
791 if (GSM_IsPointBitmap(&oldBitmap,i,j))
792 SetPoint(widget,i,j,0);
794 ClearPoint(widget,i,j,0);
795 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
797 mouseButtonPushed = 0;
803 gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
804 if (event->button == 1)
805 mouseButtonPushed = 0;
810 gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
812 GdkModifierType state;
814 if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
817 gdk_window_get_pointer(event->window,&x,&y,&state);
821 state = event->state;
824 x = x / (POINTSIZE+1);
825 y = y / (POINTSIZE+1);
828 if (x > bitmap.width-1) x = bitmap.width-1;
829 if (y > bitmap.height-1) y = bitmap.height-1;
831 if (y == toolLastY && x == toolLastX) return TRUE;
833 switch (activeTool) {
835 if (state & GDK_BUTTON1_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,1);
836 if (state & GDK_BUTTON2_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,2);
837 if (state & GDK_BUTTON3_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,3);
840 if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
842 case TOOL_FILLED_RECTANGLE:
843 if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
846 if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
851 * it's simple, above tools updates only bitmap in memory and this
852 * function update from bitmap to screen, it's made as non-blinking
853 * drawing functions with this, simply draw everything we need and
854 * after that, redraw to screen rectangle in which we made changes
855 * it's not redrawing pixel by pixel (blinking)
857 if (activeTool != TOOL_BRUSH) {
858 int lowestX, lowestY, highestX, highestY;
860 lowestX = GetMinFrom3(toolStartX,toolLastX,x);
861 lowestY = GetMinFrom3(toolStartY,toolLastY,y);
862 highestX = GetMaxFrom3(toolStartX,toolLastX,x);
863 highestY = GetMaxFrom3(toolStartY,toolLastY,y);
865 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
873 /* configureEvent? -> event when someone resize windows, ... */
874 gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
876 /* got drawingPixmap? */
877 if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
879 /* make a new pixmap */
880 drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
881 drawingAreaHeight,-1);
883 /* draw grid into pixmap */
884 for (y = 0;y < bitmap.height;y++)
885 for (x = 0;x < bitmap.width;x++)
887 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
888 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
890 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
891 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
896 gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
897 /* got drawingPixmap? */
900 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
902 event->area.x,event->area.y,event->area.x,event->area.y,
903 event->area.width,event->area.height);
907 /* *****************************************
908 * ** TOOLBAR & MENU EVENTS ****************
909 * *****************************************
912 void GetNetworkInfoEvent(GtkWidget *widget) {
914 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
915 D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
917 /* prepare data for event */
918 data->info = &networkInfo;
919 e->event = Event_GetNetworkInfo;
922 /* launch event and wait for result */
924 pthread_mutex_lock(&getNetworkInfoMutex);
925 pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
926 pthread_mutex_unlock(&getNetworkInfoMutex);
927 error = data->status;
930 /* watch for errors */
931 if (error != GE_NONE) {
932 gchar *buf = g_strdup_printf(_("Error getting network info\n(error=%d)"),error);
933 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
934 gtk_widget_show(errorDialog.dialog);
938 /* set new operator name to combo */
939 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
940 GSM_GetNetworkName(networkInfo.NetworkCode));
943 void GetLogoEvent(GtkWidget *widget) {
946 PhoneEvent *e = (PhoneEvent *) g_malloc(sizeof(PhoneEvent));
947 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
948 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
950 /* prepare data for event */
951 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
952 data->bitmap = &bitmap;
953 e->event = Event_GetBitmap;
955 if (phoneMonitor.supported & PM_CALLERGROUP) {
956 for (i = 0;i < 6;i++)
957 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
958 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
961 /* launch event and wait for result */
963 pthread_mutex_lock(&getBitmapMutex);
964 pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
965 pthread_mutex_unlock(&getBitmapMutex);
966 error = data->status;
969 /* watch for errors */
970 if (error != GE_NONE) {
971 gchar *buf = g_strdup_printf(_("Error getting bitmap\n(error=%d)"),error);
972 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
973 gtk_widget_show(errorDialog.dialog);
976 /* no error, draw logo from phone */
977 UpdatePoints(drawingArea);
981 void SetLogoEvent(GtkWidget *widget) {
983 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
984 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
985 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
989 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
991 if (bitmap.type == GSM_CallerLogo) {
992 /* above condition must be there, because if you launch logos before
993 * callerGroups are available, you will see segfault - callerGroups not initialized
995 if (phoneMonitor.supported & PM_CALLERGROUP) {
996 for (i = 0;i < 6;i++)
997 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
998 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
1002 data->bitmap = &bitmap;
1003 e->event = Event_SetBitmap;
1006 /* launch event and wait for result */
1008 pthread_mutex_lock(&setBitmapMutex);
1009 pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
1010 pthread_mutex_unlock(&setBitmapMutex);
1011 error = data->status;
1014 /* watch for errors */
1015 if (error != GE_NONE) {
1016 gchar *buf = g_strdup_printf(_("Error setting bitmap\n(error=%d)"),error);
1017 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1018 gtk_widget_show(errorDialog.dialog);
1027 static SendLogoDialog sendLogoDialog = {NULL, NULL};
1029 static void OkSendLogoDialog(GtkWidget *w, gpointer gtkdata)
1034 char Data[7] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
1036 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
1037 D_SMSMessage *data = (D_SMSMessage *)g_malloc(sizeof(D_SMSMessage));
1038 char *number = gtk_entry_get_text(GTK_ENTRY(sendLogoDialog.entry));
1039 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
1040 char *opcode = GSM_GetNetworkCode(operator);
1045 /* Default settings for SMS message:
1046 - no delivery report
1052 - set UserDataHeaderIndicator
1057 SMS.Compression = false;
1058 SMS.EightBit = true;
1059 SMS.MessageCenter = xgnokiiConfig.smsSetting[0]; /* we need to at least set .Format ! */
1060 SMS.MessageCenter.No = 0;
1061 SMS.Validity = 4320; /* 4320 minutes == 72 hours */
1062 SMS_SetupUDH(&SMS,bitmap.type);
1066 switch (bitmap.type) {
1068 case GSM_CallerLogo:
1069 /* below condition must be there, because if you launch logos before
1070 * callerGroups are available, you will see segfault - callerGroups not initialized
1072 if (phoneMonitor.supported & PM_CALLERGROUP) {
1073 for (i = 0;i < 6;i++)
1074 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
1075 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
1079 case GSM_OperatorLogo:
1080 opcode=GSM_GetNetworkCode(operator);
1081 Data[current++] = ((opcode[1] & 0x0f) << 4) | (opcode[0] & 0xf);
1082 Data[current++] = 0xf0 | (opcode[2] & 0x0f);
1083 Data[current++] = ((opcode[5] & 0x0f) << 4) | (opcode[4] & 0xf);
1086 default: /* unsupported */
1092 strncpy(SMS.Destination,number,sizeof(SMS.Destination));
1093 SMS.Destination[sizeof(SMS.Destination)-1]='\0';
1095 /* Set the logo size */
1097 Data[current++] = bitmap.width;
1098 Data[current++] = bitmap.height;
1100 Data[current++] = 0x01;
1102 memcpy(SMS.MessageText,Data,current);
1103 memcpy(SMS.MessageText+current,bitmap.bitmap,bitmap.size);
1104 SMS.MessageTextLength = current+bitmap.size;
1107 e->event = Event_SendSMSMessage;
1110 /* launch event and wait for result */
1112 pthread_mutex_lock (&sendSMSMutex);
1113 pthread_cond_wait (&sendSMSCond, &sendSMSMutex);
1114 pthread_mutex_unlock (&sendSMSMutex);
1115 error = data->status;
1118 /* watch for errors */
1119 if (error != GE_SMSSENDOK) {
1120 gchar *buf = g_strdup_printf(_("Error sending bitmap\n(error=%d)"),error);
1121 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1122 gtk_widget_show(errorDialog.dialog);
1126 gtk_widget_hide (((SendLogoDialog *) gtkdata)->dialog);
1129 /* Here would be appropriate xgnokii_sms/ShowSelectContactsDialog()
1130 * (and the multi-recipient handling code).
1131 * I haven't implemented yet any such code as the whole XGnokii has broken
1132 * design of hand-coded GTK+ GUI (even w/o any Gnome features) instead of Glade.
1133 * The right solution is to drop 95% of XGNokii code, not to write yet another
1134 * insane +2% of hand-coded GUI code.
1136 void SendLogoEvent(GtkWidget *widget)
1138 if (sendLogoDialog.dialog == NULL)
1140 GtkWidget *button, *label;
1142 sendLogoDialog.dialog = gtk_dialog_new ();
1143 gtk_window_set_title (GTK_WINDOW (sendLogoDialog.dialog), _("Send logo"));
1144 gtk_window_set_modal(GTK_WINDOW (sendLogoDialog.dialog), TRUE);
1145 gtk_container_set_border_width (GTK_CONTAINER (sendLogoDialog.dialog), 10);
1146 gtk_signal_connect (GTK_OBJECT (sendLogoDialog.dialog), "delete_event",
1147 GTK_SIGNAL_FUNC (DeleteEvent), NULL);
1149 button = gtk_button_new_with_label (_("Send"));
1150 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (sendLogoDialog.dialog)->action_area),
1151 button, TRUE, TRUE, 10);
1152 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1153 GTK_SIGNAL_FUNC (OkSendLogoDialog), (gpointer) &sendLogoDialog);
1154 GTK_WIDGET_SET_FLAGS (button, GTK_CAN_DEFAULT);
1155 gtk_widget_grab_default (button);
1156 gtk_widget_show (button);
1158 button = gtk_button_new_with_label (_("Cancel"));
1159 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (sendLogoDialog.dialog)->action_area),
1160 button, TRUE, TRUE, 10);
1161 gtk_signal_connect (GTK_OBJECT (button), "clicked",
1162 GTK_SIGNAL_FUNC (CancelDialog), (gpointer) sendLogoDialog.dialog);
1163 gtk_widget_show (button);
1165 gtk_container_set_border_width (GTK_CONTAINER (GTK_DIALOG (sendLogoDialog.dialog)->vbox), 5);
1167 label = gtk_label_new (_("Number:"));
1168 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (sendLogoDialog.dialog)->vbox), label, FALSE, FALSE, 5);
1169 gtk_widget_show (label);
1171 sendLogoDialog.entry = gtk_entry_new_with_max_length (GSM_MAX_PHONEBOOK_NUMBER_LENGTH);
1172 gtk_box_pack_start (GTK_BOX (GTK_DIALOG (sendLogoDialog.dialog)->vbox), sendLogoDialog.entry, FALSE, FALSE, 5);
1173 gtk_widget_show (sendLogoDialog.entry);
1176 gtk_entry_set_text (GTK_ENTRY (sendLogoDialog.entry), "");
1178 gtk_widget_show (sendLogoDialog.dialog);
1181 static void ClearLogoEvent(GtkWidget *widget) {
1183 // bitmap.size=bitmap.width*bitmap.height/8;
1185 GSM_ClearBitmap(&bitmap);
1187 UpdatePoints(widget);
1190 void InvertLogoEvent(GtkWidget *widget) {
1193 for (column = 0;column < bitmap.width;column++)
1194 for (row = 0;row < bitmap.height;row++)
1195 if (IsPoint(column,row))
1196 GSM_ClearPointBitmap(&bitmap,column,row);
1198 GSM_SetPointBitmap(&bitmap,column,row);
1200 UpdatePoints(widget);
1203 void UpLogoEvent(GtkWidget *widget) {
1208 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1210 for (row = 0;row < bitmap.height-1;row++)
1211 for (column = 0;column < bitmap.width;column++)
1212 if (IsPoint(column,row+1))
1213 GSM_SetPointBitmap(&bitmap,column,row);
1215 GSM_ClearPointBitmap(&bitmap,column,row);
1217 for (column = 0;column < bitmap.width;column++)
1218 if (GSM_IsPointBitmap(&tbitmap,column,0))
1219 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1);
1221 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1);
1223 UpdatePoints(widget);
1226 void DownLogoEvent(GtkWidget *widget) {
1231 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1233 for (row = bitmap.height-1;row > 0;row--)
1234 for (column = 0;column < bitmap.width;column++)
1235 if (IsPoint(column,row-1))
1236 GSM_SetPointBitmap(&bitmap,column,row);
1238 GSM_ClearPointBitmap(&bitmap,column,row);
1240 for (column = 0;column < bitmap.width;column++)
1241 if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
1242 GSM_SetPointBitmap(&bitmap,column,0);
1244 GSM_ClearPointBitmap(&bitmap,column,0);
1246 UpdatePoints(widget);
1249 void LeftLogoEvent(GtkWidget *widget) {
1254 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1256 for (column = 0; column < bitmap.width-1;column++)
1257 for (row = 0;row < bitmap.height;row++)
1258 if (IsPoint(column+1,row))
1259 GSM_SetPointBitmap(&bitmap,column,row);
1261 GSM_ClearPointBitmap(&bitmap,column,row);
1263 for (row = 0;row < bitmap.height;row++)
1264 if (GSM_IsPointBitmap(&tbitmap,0,row))
1265 GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
1267 GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
1269 UpdatePoints(widget);
1272 void RightLogoEvent(GtkWidget *widget) {
1277 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1279 for (column = bitmap.width-1;column > 0;column--)
1280 for (row = 0;row < bitmap.height;row++)
1281 if (IsPoint(column-1,row))
1282 GSM_SetPointBitmap(&bitmap,column,row);
1284 GSM_ClearPointBitmap(&bitmap,column,row);
1286 for (row = 0;row < bitmap.height;row++)
1287 if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
1288 GSM_SetPointBitmap(&bitmap,0,row);
1290 GSM_ClearPointBitmap(&bitmap,0,row);
1292 UpdatePoints(widget);
1295 void FlipVerticalLogoEvent(GtkWidget *widget) {
1296 int row, column, temp;
1298 for (row = 0;row < (bitmap.height/2);row++)
1299 for (column = 0;column < bitmap.width;column++) {
1300 temp = IsPoint(column,row);
1301 if (IsPoint(column,bitmap.height-1-row))
1302 GSM_SetPointBitmap(&bitmap,column,row);
1304 GSM_ClearPointBitmap(&bitmap,column,row);
1307 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
1309 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
1312 UpdatePoints(widget);
1315 void FlipHorizontalLogoEvent(GtkWidget *widget) {
1316 int row, column, temp;
1318 for (row = 0;row < bitmap.height;row++)
1319 for (column = 0;column < (bitmap.width/2);column++) {
1320 temp = IsPoint(column,row);
1322 if (IsPoint(bitmap.width-1-column,row))
1323 GSM_SetPointBitmap(&bitmap,column,row);
1325 GSM_ClearPointBitmap(&bitmap,column,row);
1328 GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
1330 GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
1333 UpdatePoints(widget);
1336 /* this is launched when tool was changed */
1337 gint ToolTypeEvent(GtkWidget *widget) {
1338 if (GTK_TOGGLE_BUTTON(buttonBrush)->active) activeTool = TOOL_BRUSH; else
1339 if (GTK_TOGGLE_BUTTON(buttonLine)->active) activeTool = TOOL_LINE; else
1340 if (GTK_TOGGLE_BUTTON(buttonRectangle)->active) activeTool = TOOL_RECTANGLE; else
1341 if (GTK_TOGGLE_BUTTON(buttonFilledRectangle)->active)
1342 activeTool = TOOL_FILLED_RECTANGLE;
1347 /* this is launched when logo type was change by buttons on toolbar */
1348 gint LogoTypeEvent(GtkWidget *widget) {
1351 /* is startupLogo? */
1352 /* Resize and clear anyway - CK */
1353 if (GTK_TOGGLE_BUTTON(buttonStartup)->active) {
1354 /* look for old bitmap type, clean if another */
1356 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo, &xgnokii_statemachine.Phone.Info);
1359 /* has phone support for callerGroups? */
1360 if (phoneMonitor.supported & PM_CALLERGROUP) {
1361 if (GTK_TOGGLE_BUTTON(buttonCaller)->active && bitmap.type != GSM_CallerLogo) {
1362 /* previous was startup? clear and draw batteries, signal, ... */
1363 /* Clear anyway for 7110...CK */
1365 GSM_ResizeBitmap(&bitmap,GSM_CallerLogo, &xgnokii_statemachine.Phone.Info);
1369 /* is new type operatorLogo? */
1370 if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo) {
1371 /* previous startup? clear and draw batteries, signal, ... */
1372 /* Clear anyway for 7110..CK */
1374 GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo, &xgnokii_statemachine.Phone.Info);
1379 if (previewAvailable) {
1380 /* configure event reload pixmap from disk and redraws */
1381 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1382 previewPixmapWidth,previewPixmapHeight);
1385 /* change new drawingArea size */
1386 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1387 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1389 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1390 drawingAreaWidth,drawingAreaHeight);
1396 inline void CloseLogosWindow (void) {
1397 gtk_widget_hide(GUI_LogosWindow);
1400 void ExportLogoFileMain(gchar *name)
1407 strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
1409 error=GSM_SaveBitmapFile(name,&tbitmap);
1410 if (error!=GE_NONE) {
1411 gchar *buf = g_strdup_printf(_("Error saving file\n(error=%d)"),error);
1412 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1413 gtk_widget_show(errorDialog.dialog);
1418 static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
1420 gtk_widget_hide (GTK_WIDGET (data));
1421 ExportLogoFileMain(exportDialogData.fileName);
1424 static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
1426 static YesNoDialog dialog = { NULL, NULL};
1430 exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1431 gtk_widget_hide (GTK_WIDGET (fs));
1433 if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
1436 if (dialog.dialog == NULL)
1438 CreateYesNoDialog (&dialog, YesLogoFileExportDialog, CancelDialog, GUI_LogosWindow);
1439 gtk_window_set_title (GTK_WINDOW (dialog.dialog), _("Overwrite file?"));
1440 g_snprintf ( err, 80, _("File %s already exist.\nOverwrite?"), exportDialogData.fileName);
1441 gtk_label_set_text (GTK_LABEL(dialog.text), err);
1443 gtk_widget_show (dialog.dialog);
1446 ExportLogoFileMain(exportDialogData.fileName);
1449 void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
1457 fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1458 gtk_widget_hide (GTK_WIDGET (fs));
1460 if ((f = fopen (fileName, "r")) == NULL) {
1461 gchar *buf = g_strdup_printf(_("Can't open file %s for reading !"),fileName);
1462 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1463 gtk_widget_show(errorDialog.dialog);
1468 error=GSM_ReadBitmapFile(fileName,&tbitmap);
1469 if (error!=GE_NONE) {
1470 gchar *buf = g_strdup_printf(_("Error reading file\n(error=%d)"),error);
1471 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1472 gtk_widget_show(errorDialog.dialog);
1477 exportDialogData.fileName=fileName;
1479 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),false);
1480 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),false);
1481 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),false);
1483 if (tbitmap.type==GSM_OperatorLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),true);
1484 if (tbitmap.type==GSM_StartupLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),true);
1485 if (tbitmap.type==GSM_CallerLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),true);
1487 memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
1489 UpdatePoints(drawingArea);
1492 void SaveLogoAs(GtkWidget *widget)
1494 FileSelection=gtk_file_selection_new (_("Save logo as ..."));
1496 gtk_signal_connect (
1497 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1498 "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
1500 gtk_signal_connect_object (
1501 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1502 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1503 GTK_OBJECT (FileSelection));
1505 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1507 gtk_widget_show(FileSelection);
1510 void SaveLogo(GtkWidget *widget)
1512 if (exportDialogData.fileName==NULL) {
1515 ExportLogoFileMain(exportDialogData.fileName);
1519 void OpenLogo(GtkWidget *widget)
1521 FileSelection=gtk_file_selection_new (_("Open logo..."));
1523 gtk_signal_connect (
1524 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1525 "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
1527 gtk_signal_connect_object (
1528 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1529 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1530 GTK_OBJECT (FileSelection));
1532 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1534 gtk_widget_show(FileSelection);
1537 static GtkItemFactoryEntry logosMenuItems[] = {
1538 { NULL, NULL, NULL, 0, "<Branch>"},
1539 { NULL, "<control>O", OpenLogo, 0, NULL},
1540 { NULL, "<control>S", SaveLogo, 0, NULL},
1541 { NULL, NULL, SaveLogoAs, 0, NULL},
1542 { NULL, NULL, NULL, 0, "<Separator>"},
1543 { NULL, "<control>G", GetNetworkInfoEvent, 0, NULL},
1544 { NULL, NULL, GetLogoEvent, 0, NULL},
1545 { NULL, "<control>T", SetLogoEvent, 0, NULL},
1546 { NULL, "<control>N", SendLogoEvent, 0, NULL},
1547 { NULL, NULL, NULL, 0, "<Separator>"},
1548 { NULL, "<control>W", CloseLogosWindow, 0, NULL},
1549 { NULL, NULL, NULL, 0, "<Branch>"},
1550 { NULL, "<control>C", ClearLogoEvent, 0, NULL},
1551 { NULL, "<control>I", InvertLogoEvent, 0, NULL},
1552 { NULL, NULL, NULL, 0, "<Separator>"},
1553 { NULL, "<control>U", UpLogoEvent, 0, NULL},
1554 { NULL, "<control>D", DownLogoEvent, 0, NULL},
1555 { NULL, "<control>L", LeftLogoEvent, 0, NULL},
1556 { NULL, "<control>R", RightLogoEvent, 0, NULL},
1557 { NULL, NULL, NULL, 0, "<Separator>"},
1558 { NULL, "<control>H", FlipHorizontalLogoEvent, 0, NULL},
1559 { NULL, "<control>V", FlipVerticalLogoEvent, 0, NULL},
1562 void InitLogosMenu (void) {
1563 logosMenuItems[0].path = g_strdup(_("/_File"));
1564 logosMenuItems[1].path = g_strdup(_("/File/_Open"));
1565 logosMenuItems[2].path = g_strdup(_("/File/_Save"));
1566 logosMenuItems[3].path = g_strdup(_("/File/Save _as ..."));
1567 logosMenuItems[4].path = g_strdup(_("/File/Sep1"));
1568 logosMenuItems[5].path = g_strdup(_("/File/_Get operator"));
1569 logosMenuItems[6].path = g_strdup(_("/File/Get _logo"));
1570 logosMenuItems[7].path = g_strdup(_("/File/Se_t logo"));
1571 logosMenuItems[8].path = g_strdup(_("/File/Se_nd logo"));
1572 logosMenuItems[9].path = g_strdup(_("/File/Sep2"));
1573 logosMenuItems[10].path = g_strdup(_("/File/_Close"));
1574 logosMenuItems[11].path = g_strdup(_("/_Edit"));
1575 logosMenuItems[12].path = g_strdup(_("/Edit/_Clear"));
1576 logosMenuItems[13].path = g_strdup(_("/Edit/_Invert"));
1577 logosMenuItems[14].path = g_strdup(_("/Edit/Sep3"));
1578 logosMenuItems[15].path = g_strdup(_("/Edit/_Up logo"));
1579 logosMenuItems[16].path = g_strdup(_("/Edit/_Down logo"));
1580 logosMenuItems[17].path = g_strdup(_("/Edit/_Left logo"));
1581 logosMenuItems[18].path = g_strdup(_("/Edit/_Right logo"));
1582 logosMenuItems[19].path = g_strdup(_("/Edit/Sep4"));
1583 logosMenuItems[20].path = g_strdup(_("/Edit/Flip _horizontal"));
1584 logosMenuItems[21].path = g_strdup(_("/Edit/Flip _vertical"));
1587 void GUI_CreateLogosWindow (void) {
1588 int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
1589 GtkAccelGroup *accelGroup;
1590 GtkItemFactory *itemFactory;
1592 GtkWidget *toolBar, *vertToolBar;
1595 GtkWidget *drawingBox;
1596 GtkWidget *separator;
1599 GList *glistNetwork = NULL;
1603 previewPixmapWidth = PREVIEWWIDTH;
1604 previewPixmapHeight = PREVIEWHEIGHT;
1608 /* realize top level window for logos */
1609 GUI_LogosWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1610 gtk_window_set_wmclass(GTK_WINDOW(GUI_LogosWindow), "LogosWindow", "Xgnokii");
1611 gtk_window_set_policy(GTK_WINDOW(GUI_LogosWindow), 1, 1, 1);
1612 gtk_window_set_title(GTK_WINDOW(GUI_LogosWindow), _("Logos"));
1613 gtk_signal_connect(GTK_OBJECT(GUI_LogosWindow), "delete_event",
1614 GTK_SIGNAL_FUNC(DeleteEvent), NULL);
1615 gtk_widget_realize(GUI_LogosWindow);
1617 CreateErrorDialog(&errorDialog, GUI_LogosWindow);
1618 CreateInfoDialog(&infoDialog, GUI_LogosWindow);
1620 accelGroup = gtk_accel_group_new();
1621 gtk_accel_group_attach(accelGroup, GTK_OBJECT(GUI_LogosWindow));
1623 /* create main vbox */
1624 vbox = gtk_vbox_new(FALSE, 1);
1625 gtk_container_add(GTK_CONTAINER(GUI_LogosWindow), vbox);
1626 gtk_widget_show(vbox);
1628 itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accelGroup);
1629 gtk_item_factory_create_items(itemFactory, nMenuItems, logosMenuItems, NULL);
1630 menuBar = gtk_item_factory_get_widget(itemFactory, "<main>");
1632 gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0);
1633 gtk_widget_show(menuBar);
1636 toolBar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
1637 gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolBar), GTK_RELIEF_NORMAL);
1638 gtk_toolbar_set_style(GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS);
1640 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Clear logo"), NULL,
1641 NewPixmap(New_xpm, GUI_LogosWindow->window,
1642 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1643 (GtkSignalFunc)ClearLogoEvent, toolBar);
1645 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1647 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Get logo"), NULL,
1648 NewPixmap(Read_xpm, GUI_LogosWindow->window,
1649 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1650 (GtkSignalFunc)GetLogoEvent, toolBar);
1652 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Set logo"), NULL,
1653 NewPixmap(Send_xpm, GUI_LogosWindow->window,
1654 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1655 (GtkSignalFunc)SetLogoEvent, toolBar);
1657 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Send logo"), NULL,
1658 NewPixmap(SendSMS_xpm, GUI_LogosWindow->window,
1659 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1660 (GtkSignalFunc)SendLogoEvent, toolBar);
1662 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1664 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Import from file"), NULL,
1665 NewPixmap(Open_xpm, GUI_LogosWindow->window,
1666 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1667 (GtkSignalFunc) OpenLogo, NULL);
1668 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Export to file"), NULL,
1669 NewPixmap(Save_xpm, GUI_LogosWindow->window,
1670 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1671 (GtkSignalFunc) SaveLogo, NULL);
1673 gtk_toolbar_append_space (GTK_TOOLBAR (toolBar));
1675 buttonStartup = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1676 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Startup logo"),
1677 "", NewPixmap(Startup_logo_xpm, GUI_LogosWindow->window,
1678 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1679 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1681 buttonOperator = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1682 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonStartup, NULL, _("Operator logo"),
1683 "", NewPixmap(Operator_logo_xpm, GUI_LogosWindow->window,
1684 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1685 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1687 buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1688 GTK_TOOLBAR_CHILD_RADIOBUTTON,
1690 NULL, _("Caller logo"),
1691 "", NewPixmap(Caller_logo_xpm, GUI_LogosWindow->window,
1692 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1693 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1695 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1697 networkCombo = gtk_combo_new();
1698 gtk_combo_set_use_arrows_always(GTK_COMBO(networkCombo), 1);
1699 while (strcmp(GSM_Networks[i].Name, "unknown"))
1700 glistNetwork = g_list_insert_sorted(glistNetwork, GSM_Networks[i++].Name,
1701 (GCompareFunc)strcmp);
1702 gtk_combo_set_popdown_strings(GTK_COMBO(networkCombo), glistNetwork);
1703 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(networkCombo)->entry), FALSE);
1704 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), networkCombo, "", "");
1705 gtk_widget_show(networkCombo);
1706 g_list_free(glistNetwork);
1708 callerCombo = gtk_combo_new();
1709 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(callerCombo)->entry), FALSE);
1710 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), callerCombo, "", "");
1711 gtk_widget_show(callerCombo);
1713 gtk_box_pack_start(GTK_BOX(vbox), toolBar, FALSE, FALSE, 0);
1714 gtk_widget_show(toolBar);
1716 /* vertical separator */
1717 separator = gtk_hseparator_new();
1718 gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
1720 /* create horizontal box for preview and drawing areas */
1721 hbox = gtk_hbox_new(FALSE,5);
1722 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
1723 gtk_widget_show(hbox);
1725 /* set GSM_Bitmap width,height needed for creating drawinArea
1726 * we are starting, default is startupLogo
1728 bitmap.type = GSM_StartupLogo;
1731 bitmap.size = bitmap.height * bitmap.width / 8;
1732 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1733 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1736 previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
1738 if (previewPixmap != NULL) {
1739 previewArea = gtk_drawing_area_new();
1740 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1741 previewPixmapWidth,previewPixmapHeight);
1743 greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1744 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
1747 gtk_signal_connect(GTK_OBJECT(previewArea),"expose_event",
1748 (GtkSignalFunc)PreviewAreaExposeEvent,NULL);
1749 gtk_signal_connect(GTK_OBJECT(previewArea),"configure_event",
1750 (GtkSignalFunc)PreviewAreaConfigureEvent,NULL);
1751 gtk_signal_connect(GTK_OBJECT(previewArea),"button_press_event",
1752 (GtkSignalFunc)PreviewAreaButtonPressEvent,NULL);
1754 gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
1756 gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
1757 gtk_widget_show(previewArea);
1759 /* clear battery, signal, menu & names from preview phone */
1760 UpdatePreviewPoints ();
1762 } else previewAvailable = 0;
1765 greenPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1766 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Green_point_xpm);
1767 blackPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1768 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Black_point_xpm);
1770 drawingBox = gtk_vbox_new(FALSE,3);
1771 gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
1772 gtk_widget_show(drawingBox);
1774 drawingArea = gtk_drawing_area_new();
1775 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1776 drawingAreaWidth,drawingAreaHeight);
1778 gtk_signal_connect(GTK_OBJECT(drawingArea),"configure_event",
1779 (GtkSignalFunc)DrawingAreaConfigureEvent,NULL);
1780 gtk_signal_connect(GTK_OBJECT(drawingArea),"expose_event",
1781 (GtkSignalFunc)DrawingAreaExposeEvent,NULL);
1782 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_press_event",
1783 (GtkSignalFunc)DrawingAreaButtonPressEvent,NULL);
1784 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_release_event",
1785 (GtkSignalFunc)DrawingAreaButtonReleaseEvent,NULL);
1786 gtk_signal_connect(GTK_OBJECT(drawingArea),"motion_notify_event",
1787 (GtkSignalFunc)DrawingAreaMotionNotifyEvent,NULL);
1789 gtk_widget_set_events(drawingArea,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
1790 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1791 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
1793 gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
1794 gtk_widget_show(drawingArea);
1796 /* vertical tool bar */
1797 vertToolBar = gtk_toolbar_new(GTK_ORIENTATION_VERTICAL,GTK_TOOLBAR_ICONS);
1798 gtk_toolbar_set_button_relief(GTK_TOOLBAR(vertToolBar),GTK_RELIEF_NORMAL);
1799 gtk_toolbar_set_style(GTK_TOOLBAR(vertToolBar),GTK_TOOLBAR_ICONS);
1801 buttonBrush = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1802 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Brush tool"),
1803 "", NewPixmap(Tool_brush_xpm, GUI_LogosWindow->window,
1804 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1805 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1807 buttonLine = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1808 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonBrush, NULL, _("Line tool"),
1809 "", NewPixmap(Tool_line_xpm, GUI_LogosWindow->window,
1810 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1811 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1813 buttonRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1814 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonLine, NULL, _("Rectangle tool"),
1815 "", NewPixmap(Tool_rectangle_xpm, GUI_LogosWindow->window,
1816 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1817 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1819 buttonFilledRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1820 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonRectangle, NULL,
1821 _("Filled rectangle tool"),
1822 "", NewPixmap(Tool_filled_rectangle_xpm,
1823 GUI_LogosWindow->window,
1824 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1825 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1827 gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
1829 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Invert logo"), NULL,
1830 NewPixmap(Edit_invert_xpm, GUI_LogosWindow->window,
1831 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1832 (GtkSignalFunc)InvertLogoEvent, vertToolBar);
1834 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Horizontal flip"), NULL,
1835 NewPixmap(Edit_flip_horizontal_xpm, GUI_LogosWindow->window,
1836 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1837 (GtkSignalFunc)FlipHorizontalLogoEvent, vertToolBar);
1839 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Vertical flip"), NULL,
1840 NewPixmap(Edit_flip_vertical_xpm, GUI_LogosWindow->window,
1841 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1842 (GtkSignalFunc)FlipVerticalLogoEvent, vertToolBar);
1845 gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
1846 gtk_widget_show(vertToolBar);
1848 GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
1851 void GUI_RefreshLogosGroupsCombo (void) {
1852 GList *callerList = NULL;
1855 for (i = 0;i < 6;i++)
1856 callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
1858 gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
1859 g_list_free(callerList);
1861 if (!callersGroupsInitialized) callersGroupsInitialized = 1;
1864 void GUI_ShowLogosWindow (void) {
1865 /* Set network name taken from the phone */
1866 GetNetworkInfoEvent(NULL);
1867 /* if phone support caller groups, read callerGroups names */
1868 if (phoneMonitor.supported & PM_CALLERGROUP) {
1869 if (xgnokiiConfig.callerGroups[0] == NULL) {
1871 GUI_InitCallerGroupsInf ();
1873 if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
1874 gtk_widget_show(buttonCaller);
1875 gtk_widget_show(callerCombo);
1877 /* if not supported, hide widget for handling callerGroups */
1878 gtk_widget_hide(buttonCaller);
1879 gtk_widget_hide(callerCombo);
1882 /* Call to reset Startup logo size */
1883 LogoTypeEvent(GUI_LogosWindow);
1885 gtk_widget_show(GUI_LogosWindow);
1887 if (!previewAvailable && showPreviewErrorDialog) {
1888 gchar *buf = g_strdup(_("Load preview pixmap error, feature disabled."));
1889 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1890 gtk_widget_show(errorDialog.dialog);
1893 showPreviewErrorDialog = 0;