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.1 2001/11/25 21:59:31 short
15 :pserver:cvs@pserver.samba.org:/cvsroot - gnokii - Sun Nov 25 22:56 CET 2001
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/Read.xpm"
63 #include "xpm/Open.xpm"
64 #include "xpm/Save.xpm"
66 #include "xpm/Edit_invert.xpm"
67 #include "xpm/Edit_flip_horizontal.xpm"
68 #include "xpm/Edit_flip_vertical.xpm"
70 #include "xpm/Tool_brush.xpm"
71 #include "xpm/Tool_line.xpm"
72 #include "xpm/Tool_rectangle.xpm"
73 #include "xpm/Tool_filled_rectangle.xpm"
75 extern GSM_Network GSM_Networks[];
76 extern GSM_Statemachine statemachine;
78 GtkWidget *GUI_LogosWindow;
80 ErrorDialog errorDialog = {NULL, NULL};
81 InfoDialog infoDialog = {NULL, NULL};
83 /* stuff for drawingArea */
84 GtkWidget *drawingArea = NULL;
85 GdkPixmap *drawingPixmap = NULL;
86 GdkPixmap *greenPointPixmap, *blackPointPixmap;
87 int drawingAreaWidth, drawingAreaHeight; /* in pixels */
88 int mouseButtonPushed = 0;
90 /* stuff for previewArea */
91 GtkWidget *previewArea = NULL;
92 GdkPixmap *previewPixmap = NULL;
93 GdkPixmap *greenPixelPixmap;
94 int previewPixmapWidth, previewPixmapHeight;
95 int previewAvailable = 1, showPreviewErrorDialog = 1;
96 int previewPixmapNumber = 0;
98 GSM_Bitmap bitmap, oldBitmap;
99 GSM_NetworkInfo networkInfo;
101 /* widgets for toolbar - some, need global variables */
102 GtkWidget *buttonStartup, *buttonOperator, *buttonCaller;
103 GtkWidget *networkCombo, *callerCombo;
105 int activeTool = TOOL_BRUSH;
106 int toolStartX, toolStartY, toolLastX, toolLastY;
108 /* tools for drawing */
109 static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
110 static GtkWidget *buttonFilledRectangle;
112 /* Contains fileName for Export dialog. */
117 static ExportDialogData exportDialogData = {NULL};
119 GtkWidget *FileSelection;
121 static int callersGroupsInitialized = 0;
123 /* returns lowest number from three numbers */
124 int GetMinFrom3(int a, int b, int c) {
138 /* returns highest number from three numbers */
139 int GetMaxFrom3(int a, int b, int c) {
153 /* load preview pixmap from file */
154 GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
159 if (previewPixmapNumber == 0)
161 if (!strcmp (xgnokiiConfig.model, "6110") ||
162 !strcmp (xgnokiiConfig.model, "6120"))
164 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
165 "/xpm/Preview_6110.xpm");
166 previewPixmapNumber = 1;
168 else if (!strcmp (xgnokiiConfig.model, "6130") ||
169 !strcmp (xgnokiiConfig.model, "6150") ||
170 !strcmp (xgnokiiConfig.model, "616x") ||
171 !strcmp (xgnokiiConfig.model, "6185") ||
172 !strcmp (xgnokiiConfig.model, "6190"))
174 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
175 "/xpm/Preview_6150.xpm");
176 previewPixmapNumber = 2;
178 else if (!strcmp (xgnokiiConfig.model, "3210"))
180 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
181 "/xpm/Preview_3210.xpm");
182 previewPixmapNumber = 3;
184 else if (!strcmp (xgnokiiConfig.model, "3310") ||
185 !strcmp (xgnokiiConfig.model, "3330"))
187 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
188 "/xpm/Preview_3310.xpm");
189 previewPixmapNumber = 4;
191 else if (!strcmp (xgnokiiConfig.model, "5110") ||
192 !strcmp (xgnokiiConfig.model, "5130"))
194 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
195 "/xpm/Preview_5110.xpm");
196 previewPixmapNumber = 5;
198 else if (!strcmp (xgnokiiConfig.model, "6250"))
200 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
201 "/xpm/Preview_6250.xpm");
202 previewPixmapNumber = 6;
204 else if (!strcmp (xgnokiiConfig.model, "7110"))
206 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
207 "/xpm/Preview_7110.xpm");
208 previewPixmapNumber = 7;
212 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
213 "/xpm/Preview_6210.xpm");
214 previewPixmapNumber = 8;
218 switch (previewPixmapNumber)
220 case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
221 "/xpm/Preview_6110.xpm");
223 case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
224 "/xpm/Preview_6150.xpm");
226 case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
227 "/xpm/Preview_3210.xpm");
229 case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
230 "/xpm/Preview_3310.xpm");
232 case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
233 "/xpm/Preview_5110.xpm");
235 case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
236 "/xpm/Preview_6250.xpm");
238 case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
239 "/xpm/Preview_7110.xpm");
241 default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
242 "/xpm/Preview_6210.xpm");
246 pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
247 &widget->style->bg[GTK_STATE_NORMAL],
255 /* ********************************************************
256 * ** SET/CLEAR POINTS ************************************
257 * ********************************************************
259 void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
260 if (!previewAvailable) return;
262 /* there is difference between positiong of startupLogo and others */
263 if (bitmap.type != GSM_StartupLogo) {
268 /* draw point to pixmap */
270 gdk_draw_point(previewPixmap,widget->style->black_gc,
271 x+PREVIEWSTARTX,y+PREVIEWSTARTY);
274 GdkRectangle updateRect;
276 /* update point on screen */
277 updateRect.width = 1;
278 updateRect.height = 1;
279 updateRect.x = PREVIEWSTARTX+x;
280 updateRect.y = PREVIEWSTARTY+y;
282 gtk_widget_draw(previewArea,&updateRect);
286 void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
287 if (!previewAvailable) return;
289 /* there is difference between positiong of startupLogo and others */
290 if (bitmap.type != GSM_StartupLogo) {
295 /* clean point from pixmap - any idea how to draw green point without pixmap? */
297 gdk_draw_pixmap(previewPixmap,
298 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
299 greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
301 GdkRectangle updateRect;
303 /* clean from screen too */
304 updateRect.width = 1;
305 updateRect.height = 1;
306 updateRect.x = PREVIEWSTARTX+x;
307 updateRect.y = PREVIEWSTARTY+y;
309 gtk_widget_draw(previewArea,&updateRect);
313 int IsPoint(int x, int y) {
314 return GSM_IsPointBitmap(&bitmap,x,y);
317 void SetPoint(GtkWidget *widget, int x, int y, int update) {
318 /* difference between settings points in startupLogo and others */
319 GSM_SetPointBitmap(&bitmap,x,y);
321 /* draw point to pixmap */
322 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
323 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
326 GdkRectangle updateRect;
328 /* calculate update rectangle */
329 updateRect.width = POINTSIZE+2;
330 updateRect.height = POINTSIZE+2;
331 updateRect.x = x * (POINTSIZE+1);
332 updateRect.y = y * (POINTSIZE+1);
334 /* update on screen */
335 gtk_widget_draw(drawingArea,&updateRect);
338 /* draw preview point too */
339 if (previewAvailable) SetPreviewPoint(widget,x,y,update);
342 void ClearPoint(GtkWidget *widget, int x, int y, int update) {
343 /* difference between settings points in startupLogo and others */
344 GSM_ClearPointBitmap(&bitmap,x,y);
346 /* clear point from pixmap */
347 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
348 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
351 GdkRectangle updateRect;
353 /* calculate update rectangle */
354 updateRect.width = POINTSIZE+2;
355 updateRect.height = POINTSIZE+2;
356 updateRect.x = x * (POINTSIZE+1);
357 updateRect.y = y * (POINTSIZE+1);
359 /* update on screen */
360 gtk_widget_draw(drawingArea,&updateRect);
363 /* clear point from previewArea too */
364 if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
367 /* ****************************************************
368 * *** UPDATES - PREVIEW & DRAWING AREAS **************
369 * ****************************************************
372 /* this redraw all logo points - preview & drawing area */
373 void UpdatePointsRectangle(GtkWidget *widget, int x1, int y1, int x2, int y2) {
374 GdkRectangle updateRect;
375 int x, y, dx = 0, dy = 0;
377 if (bitmap.type != GSM_StartupLogo) {
394 for (y = y1;y <= y2;y++)
395 for (x = x1;x <= x2;x++) {
397 /* set on drawing area */
398 gdk_draw_pixmap(drawingPixmap,
399 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
400 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
403 if (previewAvailable && previewPixmap)
404 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
405 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
407 /* clear from drawing */
408 gdk_draw_pixmap(drawingPixmap,
409 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
410 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
412 /* clear from preview */
413 if (previewAvailable && previewPixmap)
414 gdk_draw_pixmap(previewPixmap,
415 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
416 greenPixelPixmap,0,0,x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,
421 if (previewAvailable) {
422 updateRect.x = PREVIEWSTARTX+dx+x1;
423 updateRect.y = PREVIEWSTARTY+dy+y1;
424 updateRect.width = x2-x1+1;
425 updateRect.height = y2-y1+1;
426 gtk_widget_draw(previewArea,&updateRect);
429 updateRect.x = x1*(POINTSIZE+1);
430 updateRect.y = y1*(POINTSIZE+1);
431 updateRect.width = (x2-x1+1)*(POINTSIZE+1)+1;
432 updateRect.height = (y2-y1+1)*(POINTSIZE+1)+1;
433 gtk_widget_draw(drawingArea,&updateRect);
436 void UpdatePoints(GtkWidget *widget) {
437 UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
440 /* this redraw all logo points in previewArea, NO DRAWING AREA */
441 void UpdatePreviewPoints (void) {
442 GdkRectangle updateRect;
443 int x, y, dx = 0, dy = 0;
445 if (!previewPixmap || !previewAvailable) return;
447 if (bitmap.type != GSM_StartupLogo) {
452 for (y = 0;y < bitmap.height;y++)
453 for (x = 0;x < bitmap.width;x++) {
455 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
456 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
458 gdk_draw_pixmap(previewPixmap,
459 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
460 greenPixelPixmap,0,0,
461 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,1,1);
467 updateRect.width = bitmap.width;
468 updateRect.height = bitmap.height;
469 gtk_widget_draw(previewArea,&updateRect);
472 /* ******************************************************
473 * **** DRAWING TOOLS ***********************************
474 * ******************************************************
478 void ToolBrush(GtkWidget *widget, int column, int row, int button) {
479 /* only this tool directly update bitmap & screen */
481 ClearPoint(widget,column,row,1);
483 SetPoint(widget,column,row,1);
488 /* this function clear or draw a line on the screen USED BY TOOLLINEUPDATE */
489 void ToolLine(GtkWidget *widget, int x1, int y1, int x2, int y2, int draw) {
490 int udx, udy, dx, dy, error, loop, xadd, yadd;
492 dx = x2 - x1; /* x delta */
493 dy = y2 - y1; /* y delta */
495 udx = abs(dx); /* unsigned x delta */
496 udy = abs(dy); /* unsigned y delta */
498 if (dx < 0) { xadd = -1; } else { xadd = 1; } /* set directions */
499 if (dy < 0) { yadd = -1; } else { yadd = 1; }
503 if (udx > udy) { /* delta X > delta Y */
507 if (error >= udx) { /* is time to move up or down? */
513 SetPoint(widget,x1,y1,0);
515 /* now clearing line before drawing new one, we must check */
516 /* if there is a point in oldBitmap which saves bitmap before */
517 /* we starting drawing new line */
518 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
519 ClearPoint(widget,x1,y1,0);
522 x1 += xadd; /* move horizontally */
523 } while (loop < udx); /* repeat for x length */
527 if (error >= udy) { /* is time to move left or right? */
533 SetPoint(widget,x1,y1,0);
535 /* check comment in delta X > delta Y */
536 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
537 ClearPoint(widget,x1,y1,0);
540 y1 += yadd; /* move vertically */
541 } while (loop < udy); /* repeat for y length */
545 /* going to rewrite to Bresenham algorithm */
546 void ToolLineUpdate(GtkWidget *widget, int column, int row) {
548 ToolLine(widget,toolStartX,toolStartY,toolLastX,toolLastY,0);
550 ToolLine(widget,toolStartX,toolStartY,column,row,1);
553 /* TOOL - FILLED RECT */
555 /* FIXME - going to rewrite for optimalized version, clearing and */
556 /* drawing new parts only before clearing and drawing whole */
557 /* filled rectangle - it's too slow on diskless terminal ;(( */
558 void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
559 int i, j, x1, y1, x2, y2;
561 /* swap Xs to x1 < x2 */
562 if (toolStartX > toolLastX) {
570 /* swap Ys to y1 < y2 */
571 if (toolStartY > toolLastY) {
580 for (j = y1;j <= y2;j++)
581 for (i = x1;i <= x2;i++)
582 if (!GSM_IsPointBitmap(&oldBitmap,i,j)) ClearPoint(widget,i,j,0);
584 /* swap Xs to x1 < x2 */
585 if (toolStartX > column) {
593 /* swap Ys to y1 < y2 */
594 if (toolStartY > row) {
603 for (j = y1;j <= y2;j++)
604 for (i = x1;i <= x2;i++)
605 SetPoint(widget,i,j,0);
608 /* TOOL - RECTANGLE */
609 void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
610 int i, j, x1, y1, x2, y2;
612 /* clear old rectangle */
613 /* swap Xs to x1 < x2 */
614 if (toolStartX > toolLastX) {
622 /* swap Ys to y1 < y2 */
623 if (toolStartY > toolLastY) {
632 for (i = x1;i <= x2;i++) {
633 if (!GSM_IsPointBitmap(&oldBitmap,i,y1)) ClearPoint(widget,i,y1,0);
634 if (!GSM_IsPointBitmap(&oldBitmap,i,y2)) ClearPoint(widget,i,y2,0);
637 for (j = y1;j <= y2;j++) {
638 if (!GSM_IsPointBitmap(&oldBitmap,x1,j)) ClearPoint(widget,x1,j,0);
639 if (!GSM_IsPointBitmap(&oldBitmap,x2,j)) ClearPoint(widget,x2,j,0);
642 /* draw new rectangle */
643 /* swap Xs to x1 < x2 */
644 if (toolStartX > column) {
652 /* swap Ys to y1 < y2 */
653 if (toolStartY > row) {
662 for (i = x1;i <= x2;i++) {
663 if (!IsPoint(i,y1)) SetPoint(widget,i,y1,0);
664 if (!IsPoint(i,y2)) SetPoint(widget,i,y2,0);
667 for (j = y1;j <= y2;j++) {
668 if (!IsPoint(x1,j)) SetPoint(widget,x1,j,0);
669 if (!IsPoint(x2,j)) SetPoint(widget,x2,j,0);
673 /* this update tools actions on the screen - this is for optimalization */
674 /* eg. for faster redrawing tools actions - we do not need redraw pixel */
675 /* by pixel. Faster is redraw whole rectangle which contains all changes */
676 void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
677 GdkRectangle updateRect;
679 /* update preview area */
680 if (previewAvailable) {
681 updateRect.x = PREVIEWSTARTX+x1;
682 updateRect.y = PREVIEWSTARTY+y1;
683 if (bitmap.type != GSM_StartupLogo) {
684 updateRect.x += PREVIEWJUMPX;
685 updateRect.y += PREVIEWJUMPY;
687 updateRect.width = x2-x1+1;
688 updateRect.height = y2-y1+1;
689 gtk_widget_draw(previewArea,&updateRect);
692 /* update drawing area */
693 updateRect.x = x1 * (POINTSIZE+1);
694 updateRect.y = y1 * (POINTSIZE+1);
695 updateRect.width = (x2-x1+1)*(POINTSIZE+2);
696 updateRect.height = (y2-y1+1)*(POINTSIZE+2);
697 gtk_widget_draw(drawingArea,&updateRect);
700 /* *************************************
701 * ** PREVIEW AREA EVENTS **************
702 * *************************************
705 gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
706 previewPixmapNumber = (previewPixmapNumber % 8) + 1;
708 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
709 previewPixmapWidth,previewPixmapHeight);
714 gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
715 if (previewPixmap) gdk_pixmap_unref(previewPixmap);
716 previewPixmap = GetPreviewPixmap(widget);
718 UpdatePreviewPoints();
723 gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
724 /* got previewPixmap? */
726 /* yes - simply redraw some rectangle */
727 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
728 previewPixmap,event->area.x,event->area.y,event->area.x,
729 event->area.y,event->area.width,event->area.height);
734 /* ********************************
735 * ** DRAWING AREA EVENTS *********
736 * ********************************
739 gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
740 /* got drawingPixmap? */
741 if (drawingPixmap == NULL) return TRUE;
743 if (!mouseButtonPushed) {
744 if ((event->button == 1 && activeTool != TOOL_BRUSH) ||
745 (activeTool == TOOL_BRUSH)) {
746 /* position from we starting drawing */
747 toolStartX = event->x / (POINTSIZE+1);
748 if (toolStartX < 0) toolStartX = 0;
749 if (toolStartX > bitmap.width-1) toolStartX = bitmap.width-1;
751 toolStartY = event->y / (POINTSIZE+1);
752 if (toolStartY < 0) toolStartY = 0;
753 if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
755 toolLastX = toolStartX;
756 toolLastY = toolStartY;
758 /* store old bitmap for drawing, resp. for moving, resizing primitive */
759 memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
762 if (event->button == 1) mouseButtonPushed = 1;
764 switch (activeTool) {
766 ToolBrush(widget,toolStartX,toolStartY,event->button);
770 if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
775 /* user is drawing some tool other than TOOL_BRUSH and pushed mouse button
776 * another than first => cancel tool and redraw to oldBitmap (bitmap when
777 * user start drawing)
779 if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
780 int lowestX, lowestY, highestX, highestY;
783 lowestX = GetMinFrom3(toolStartX,toolLastX,toolLastX);
784 lowestY = GetMinFrom3(toolStartY,toolLastY,toolLastY);
785 highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
786 highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
788 for (j = lowestY;j <= highestY;j++)
789 for (i = lowestX;i <= highestX;i++)
790 if (GSM_IsPointBitmap(&oldBitmap,i,j))
791 SetPoint(widget,i,j,0);
793 ClearPoint(widget,i,j,0);
794 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
796 mouseButtonPushed = 0;
802 gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
803 if (event->button == 1)
804 mouseButtonPushed = 0;
809 gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
811 GdkModifierType state;
813 if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
816 gdk_window_get_pointer(event->window,&x,&y,&state);
820 state = event->state;
823 x = x / (POINTSIZE+1);
824 y = y / (POINTSIZE+1);
827 if (x > bitmap.width-1) x = bitmap.width-1;
828 if (y > bitmap.height-1) y = bitmap.height-1;
830 if (y == toolLastY && x == toolLastX) return TRUE;
832 switch (activeTool) {
834 if (state & GDK_BUTTON1_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,1);
835 if (state & GDK_BUTTON2_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,2);
836 if (state & GDK_BUTTON3_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,3);
839 if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
841 case TOOL_FILLED_RECTANGLE:
842 if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
845 if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
850 * it's simple, above tools updates only bitmap in memory and this
851 * function update from bitmap to screen, it's made as non-blinking
852 * drawing functions with this, simply draw everything we need and
853 * after that, redraw to screen rectangle in which we made changes
854 * it's not redrawing pixel by pixel (blinking)
856 if (activeTool != TOOL_BRUSH) {
857 int lowestX, lowestY, highestX, highestY;
859 lowestX = GetMinFrom3(toolStartX,toolLastX,x);
860 lowestY = GetMinFrom3(toolStartY,toolLastY,y);
861 highestX = GetMaxFrom3(toolStartX,toolLastX,x);
862 highestY = GetMaxFrom3(toolStartY,toolLastY,y);
864 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
872 /* configureEvent? -> event when someone resize windows, ... */
873 gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
875 /* got drawingPixmap? */
876 if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
878 /* make a new pixmap */
879 drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
880 drawingAreaHeight,-1);
882 /* draw grid into pixmap */
883 for (y = 0;y < bitmap.height;y++)
884 for (x = 0;x < bitmap.width;x++)
886 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
887 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
889 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
890 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
895 gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
896 /* got drawingPixmap? */
899 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
901 event->area.x,event->area.y,event->area.x,event->area.y,
902 event->area.width,event->area.height);
906 /* *****************************************
907 * ** TOOLBAR & MENU EVENTS ****************
908 * *****************************************
911 void GetNetworkInfoEvent(GtkWidget *widget) {
913 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
914 D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
916 /* prepare data for event */
917 data->info = &networkInfo;
918 e->event = Event_GetNetworkInfo;
921 /* launch event and wait for result */
923 pthread_mutex_lock(&getNetworkInfoMutex);
924 pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
925 pthread_mutex_unlock(&getNetworkInfoMutex);
926 error = data->status;
929 /* watch for errors */
930 if (error != GE_NONE) {
931 gchar *buf = g_strdup_printf(_("Error getting network info\n(error=%d)"),error);
932 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
933 gtk_widget_show(errorDialog.dialog);
937 /* set new operator name to combo */
938 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
939 GSM_GetNetworkName(networkInfo.NetworkCode));
942 void GetLogoEvent(GtkWidget *widget) {
945 PhoneEvent *e = (PhoneEvent *) g_malloc(sizeof(PhoneEvent));
946 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
947 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
949 /* prepare data for event */
950 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
951 data->bitmap = &bitmap;
952 e->event = Event_GetBitmap;
954 if (phoneMonitor.supported & PM_CALLERGROUP) {
955 for (i = 0;i < 6;i++)
956 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
957 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
960 /* launch event and wait for result */
962 pthread_mutex_lock(&getBitmapMutex);
963 pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
964 pthread_mutex_unlock(&getBitmapMutex);
965 error = data->status;
968 /* watch for errors */
969 if (error != GE_NONE) {
970 gchar *buf = g_strdup_printf(_("Error getting bitmap\n(error=%d)"),error);
971 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
972 gtk_widget_show(errorDialog.dialog);
975 /* no error, draw logo from phone */
976 UpdatePoints(drawingArea);
980 void SetLogoEvent(GtkWidget *widget) {
982 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
983 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
984 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
988 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
990 if (bitmap.type == GSM_CallerLogo) {
991 /* above condition must be there, because if you launch logos before
992 * callerGroups are available, you will see segfault - callerGroups not initialized
994 if (phoneMonitor.supported & PM_CALLERGROUP) {
995 for (i = 0;i < 6;i++)
996 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
997 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
1001 data->bitmap = &bitmap;
1002 e->event = Event_SetBitmap;
1005 /* launch event and wait for result */
1007 pthread_mutex_lock(&setBitmapMutex);
1008 pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
1009 pthread_mutex_unlock(&setBitmapMutex);
1010 error = data->status;
1013 /* watch for errors */
1014 if (error != GE_NONE) {
1015 gchar *buf = g_strdup_printf(_("Error setting bitmap\n(error=%d)"),error);
1016 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1017 gtk_widget_show(errorDialog.dialog);
1022 static void ClearLogoEvent(GtkWidget *widget) {
1024 // bitmap.size=bitmap.width*bitmap.height/8;
1026 GSM_ClearBitmap(&bitmap);
1028 UpdatePoints(widget);
1031 void InvertLogoEvent(GtkWidget *widget) {
1034 for (column = 0;column < bitmap.width;column++)
1035 for (row = 0;row < bitmap.height;row++)
1036 if (IsPoint(column,row))
1037 GSM_ClearPointBitmap(&bitmap,column,row);
1039 GSM_SetPointBitmap(&bitmap,column,row);
1041 UpdatePoints(widget);
1044 void UpLogoEvent(GtkWidget *widget) {
1049 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1051 for (row = 0;row < bitmap.height-1;row++)
1052 for (column = 0;column < bitmap.width;column++)
1053 if (IsPoint(column,row+1))
1054 GSM_SetPointBitmap(&bitmap,column,row);
1056 GSM_ClearPointBitmap(&bitmap,column,row);
1058 for (column = 0;column < bitmap.width;column++)
1059 if (GSM_IsPointBitmap(&tbitmap,column,0))
1060 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1);
1062 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1);
1064 UpdatePoints(widget);
1067 void DownLogoEvent(GtkWidget *widget) {
1072 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1074 for (row = bitmap.height-1;row > 0;row--)
1075 for (column = 0;column < bitmap.width;column++)
1076 if (IsPoint(column,row-1))
1077 GSM_SetPointBitmap(&bitmap,column,row);
1079 GSM_ClearPointBitmap(&bitmap,column,row);
1081 for (column = 0;column < bitmap.width;column++)
1082 if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
1083 GSM_SetPointBitmap(&bitmap,column,0);
1085 GSM_ClearPointBitmap(&bitmap,column,0);
1087 UpdatePoints(widget);
1090 void LeftLogoEvent(GtkWidget *widget) {
1095 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1097 for (column = 0; column < bitmap.width-1;column++)
1098 for (row = 0;row < bitmap.height;row++)
1099 if (IsPoint(column+1,row))
1100 GSM_SetPointBitmap(&bitmap,column,row);
1102 GSM_ClearPointBitmap(&bitmap,column,row);
1104 for (row = 0;row < bitmap.height;row++)
1105 if (GSM_IsPointBitmap(&tbitmap,0,row))
1106 GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
1108 GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
1110 UpdatePoints(widget);
1113 void RightLogoEvent(GtkWidget *widget) {
1118 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1120 for (column = bitmap.width-1;column > 0;column--)
1121 for (row = 0;row < bitmap.height;row++)
1122 if (IsPoint(column-1,row))
1123 GSM_SetPointBitmap(&bitmap,column,row);
1125 GSM_ClearPointBitmap(&bitmap,column,row);
1127 for (row = 0;row < bitmap.height;row++)
1128 if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
1129 GSM_SetPointBitmap(&bitmap,0,row);
1131 GSM_ClearPointBitmap(&bitmap,0,row);
1133 UpdatePoints(widget);
1136 void FlipVerticalLogoEvent(GtkWidget *widget) {
1137 int row, column, temp;
1139 for (row = 0;row < (bitmap.height/2);row++)
1140 for (column = 0;column < bitmap.width;column++) {
1141 temp = IsPoint(column,row);
1142 if (IsPoint(column,bitmap.height-1-row))
1143 GSM_SetPointBitmap(&bitmap,column,row);
1145 GSM_ClearPointBitmap(&bitmap,column,row);
1148 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
1150 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
1153 UpdatePoints(widget);
1156 void FlipHorizontalLogoEvent(GtkWidget *widget) {
1157 int row, column, temp;
1159 for (row = 0;row < bitmap.height;row++)
1160 for (column = 0;column < (bitmap.width/2);column++) {
1161 temp = IsPoint(column,row);
1163 if (IsPoint(bitmap.width-1-column,row))
1164 GSM_SetPointBitmap(&bitmap,column,row);
1166 GSM_ClearPointBitmap(&bitmap,column,row);
1169 GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
1171 GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
1174 UpdatePoints(widget);
1177 /* this is launched when tool was changed */
1178 gint ToolTypeEvent(GtkWidget *widget) {
1179 if (GTK_TOGGLE_BUTTON(buttonBrush)->active) activeTool = TOOL_BRUSH; else
1180 if (GTK_TOGGLE_BUTTON(buttonLine)->active) activeTool = TOOL_LINE; else
1181 if (GTK_TOGGLE_BUTTON(buttonRectangle)->active) activeTool = TOOL_RECTANGLE; else
1182 if (GTK_TOGGLE_BUTTON(buttonFilledRectangle)->active)
1183 activeTool = TOOL_FILLED_RECTANGLE;
1188 /* this is launched when logo type was change by buttons on toolbar */
1189 gint LogoTypeEvent(GtkWidget *widget) {
1192 /* is startupLogo? */
1193 /* Resize and clear anyway - CK */
1194 if (GTK_TOGGLE_BUTTON(buttonStartup)->active) {
1195 /* look for old bitmap type, clean if another */
1197 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo, &statemachine.Phone.Info);
1200 /* has phone support for callerGroups? */
1201 if (phoneMonitor.supported & PM_CALLERGROUP) {
1202 if (GTK_TOGGLE_BUTTON(buttonCaller)->active && bitmap.type != GSM_CallerLogo) {
1203 /* previous was startup? clear and draw batteries, signal, ... */
1204 /* Clear anyway for 7110...CK */
1206 GSM_ResizeBitmap(&bitmap,GSM_CallerLogo, &statemachine.Phone.Info);
1210 /* is new type operatorLogo? */
1211 if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo) {
1212 /* previous startup? clear and draw batteries, signal, ... */
1213 /* Clear anyway for 7110..CK */
1215 GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo, &statemachine.Phone.Info);
1220 if (previewAvailable) {
1221 /* configure event reload pixmap from disk and redraws */
1222 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1223 previewPixmapWidth,previewPixmapHeight);
1226 /* change new drawingArea size */
1227 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1228 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1230 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1231 drawingAreaWidth,drawingAreaHeight);
1237 inline void CloseLogosWindow (void) {
1238 gtk_widget_hide(GUI_LogosWindow);
1241 void ExportLogoFileMain(gchar *name)
1248 strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
1250 error=GSM_SaveBitmapFile(name,&tbitmap);
1251 if (error!=GE_NONE) {
1252 gchar *buf = g_strdup_printf(_("Error saving file\n(error=%d)"),error);
1253 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1254 gtk_widget_show(errorDialog.dialog);
1259 static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
1261 gtk_widget_hide (GTK_WIDGET (data));
1262 ExportLogoFileMain(exportDialogData.fileName);
1265 static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
1267 static YesNoDialog dialog = { NULL, NULL};
1271 exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1272 gtk_widget_hide (GTK_WIDGET (fs));
1274 if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
1277 if (dialog.dialog == NULL)
1279 CreateYesNoDialog (&dialog, YesLogoFileExportDialog, CancelDialog, GUI_LogosWindow);
1280 gtk_window_set_title (GTK_WINDOW (dialog.dialog), _("Overwrite file?"));
1281 g_snprintf ( err, 80, _("File %s already exist.\nOverwrite?"), exportDialogData.fileName);
1282 gtk_label_set_text (GTK_LABEL(dialog.text), err);
1284 gtk_widget_show (dialog.dialog);
1287 ExportLogoFileMain(exportDialogData.fileName);
1290 void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
1298 fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1299 gtk_widget_hide (GTK_WIDGET (fs));
1301 if ((f = fopen (fileName, "r")) == NULL) {
1302 gchar *buf = g_strdup_printf(_("Can't open file %s for reading !"),fileName);
1303 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1304 gtk_widget_show(errorDialog.dialog);
1309 error=GSM_ReadBitmapFile(fileName,&tbitmap);
1310 if (error!=GE_NONE) {
1311 gchar *buf = g_strdup_printf(_("Error reading file\n(error=%d)"),error);
1312 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1313 gtk_widget_show(errorDialog.dialog);
1318 exportDialogData.fileName=fileName;
1320 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),false);
1321 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),false);
1322 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),false);
1324 if (tbitmap.type==GSM_OperatorLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),true);
1325 if (tbitmap.type==GSM_StartupLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),true);
1326 if (tbitmap.type==GSM_CallerLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),true);
1328 memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
1330 UpdatePoints(drawingArea);
1333 void SaveLogoAs(GtkWidget *widget)
1335 FileSelection=gtk_file_selection_new (_("Save logo as ..."));
1337 gtk_signal_connect (
1338 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1339 "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
1341 gtk_signal_connect_object (
1342 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1343 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1344 GTK_OBJECT (FileSelection));
1346 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1348 gtk_widget_show(FileSelection);
1351 void SaveLogo(GtkWidget *widget)
1353 if (exportDialogData.fileName==NULL) {
1356 ExportLogoFileMain(exportDialogData.fileName);
1360 void OpenLogo(GtkWidget *widget)
1362 FileSelection=gtk_file_selection_new (_("Open logo..."));
1364 gtk_signal_connect (
1365 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1366 "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
1368 gtk_signal_connect_object (
1369 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1370 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1371 GTK_OBJECT (FileSelection));
1373 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1375 gtk_widget_show(FileSelection);
1378 static GtkItemFactoryEntry logosMenuItems[] = {
1379 { NULL, NULL, NULL, 0, "<Branch>"},
1380 { NULL, "<control>O", OpenLogo, 0, NULL},
1381 { NULL, "<control>S", SaveLogo, 0, NULL},
1382 { NULL, NULL, SaveLogoAs, 0, NULL},
1383 { NULL, NULL, NULL, 0, "<Separator>"},
1384 { NULL, "<control>G", GetNetworkInfoEvent, 0, NULL},
1385 { NULL, NULL, GetLogoEvent, 0, NULL},
1386 { NULL, "<control>T", SetLogoEvent, 0, NULL},
1387 { NULL, NULL, NULL, 0, "<Separator>"},
1388 { NULL, "<control>W", CloseLogosWindow, 0, NULL},
1389 { NULL, NULL, NULL, 0, "<Branch>"},
1390 { NULL, "<control>C", ClearLogoEvent, 0, NULL},
1391 { NULL, "<control>I", InvertLogoEvent, 0, NULL},
1392 { NULL, NULL, NULL, 0, "<Separator>"},
1393 { NULL, "<control>U", UpLogoEvent, 0, NULL},
1394 { NULL, "<control>D", DownLogoEvent, 0, NULL},
1395 { NULL, "<control>L", LeftLogoEvent, 0, NULL},
1396 { NULL, "<control>R", RightLogoEvent, 0, NULL},
1397 { NULL, NULL, NULL, 0, "<Separator>"},
1398 { NULL, "<control>H", FlipHorizontalLogoEvent, 0, NULL},
1399 { NULL, "<control>V", FlipVerticalLogoEvent, 0, NULL},
1402 void InitLogosMenu (void) {
1403 logosMenuItems[0].path = g_strdup(_("/_File"));
1404 logosMenuItems[1].path = g_strdup(_("/File/_Open"));
1405 logosMenuItems[2].path = g_strdup(_("/File/_Save"));
1406 logosMenuItems[3].path = g_strdup(_("/File/Save _as ..."));
1407 logosMenuItems[4].path = g_strdup(_("/File/Sep1"));
1408 logosMenuItems[5].path = g_strdup(_("/File/_Get operator"));
1409 logosMenuItems[6].path = g_strdup(_("/File/Get _logo"));
1410 logosMenuItems[7].path = g_strdup(_("/File/Se_t logo"));
1411 logosMenuItems[8].path = g_strdup(_("/File/Sep2"));
1412 logosMenuItems[9].path = g_strdup(_("/File/_Close"));
1413 logosMenuItems[10].path = g_strdup(_("/_Edit"));
1414 logosMenuItems[11].path = g_strdup(_("/Edit/_Clear"));
1415 logosMenuItems[12].path = g_strdup(_("/Edit/_Invert"));
1416 logosMenuItems[13].path = g_strdup(_("/Edit/Sep3"));
1417 logosMenuItems[14].path = g_strdup(_("/Edit/_Up logo"));
1418 logosMenuItems[15].path = g_strdup(_("/Edit/_Down logo"));
1419 logosMenuItems[16].path = g_strdup(_("/Edit/_Left logo"));
1420 logosMenuItems[17].path = g_strdup(_("/Edit/_Right logo"));
1421 logosMenuItems[18].path = g_strdup(_("/Edit/Sep4"));
1422 logosMenuItems[19].path = g_strdup(_("/Edit/Flip _horizontal"));
1423 logosMenuItems[20].path = g_strdup(_("/Edit/Flip _vertical"));
1426 void GUI_CreateLogosWindow (void) {
1427 int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
1428 GtkAccelGroup *accelGroup;
1429 GtkItemFactory *itemFactory;
1431 GtkWidget *toolBar, *vertToolBar;
1434 GtkWidget *drawingBox;
1435 GtkWidget *separator;
1438 GList *glistNetwork = NULL;
1442 previewPixmapWidth = PREVIEWWIDTH;
1443 previewPixmapHeight = PREVIEWHEIGHT;
1447 /* realize top level window for logos */
1448 GUI_LogosWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1449 gtk_window_set_wmclass(GTK_WINDOW(GUI_LogosWindow), "LogosWindow", "Xgnokii");
1450 gtk_window_set_policy(GTK_WINDOW(GUI_LogosWindow), 1, 1, 1);
1451 gtk_window_set_title(GTK_WINDOW(GUI_LogosWindow), _("Logos"));
1452 gtk_signal_connect(GTK_OBJECT(GUI_LogosWindow), "delete_event",
1453 GTK_SIGNAL_FUNC(DeleteEvent), NULL);
1454 gtk_widget_realize(GUI_LogosWindow);
1456 CreateErrorDialog(&errorDialog, GUI_LogosWindow);
1457 CreateInfoDialog(&infoDialog, GUI_LogosWindow);
1459 accelGroup = gtk_accel_group_new();
1460 gtk_accel_group_attach(accelGroup, GTK_OBJECT(GUI_LogosWindow));
1462 /* create main vbox */
1463 vbox = gtk_vbox_new(FALSE, 1);
1464 gtk_container_add(GTK_CONTAINER(GUI_LogosWindow), vbox);
1465 gtk_widget_show(vbox);
1467 itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accelGroup);
1468 gtk_item_factory_create_items(itemFactory, nMenuItems, logosMenuItems, NULL);
1469 menuBar = gtk_item_factory_get_widget(itemFactory, "<main>");
1471 gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0);
1472 gtk_widget_show(menuBar);
1475 toolBar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
1476 gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolBar), GTK_RELIEF_NORMAL);
1477 gtk_toolbar_set_style(GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS);
1479 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Clear logo"), NULL,
1480 NewPixmap(New_xpm, GUI_LogosWindow->window,
1481 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1482 (GtkSignalFunc)ClearLogoEvent, toolBar);
1484 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1486 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Get logo"), NULL,
1487 NewPixmap(Read_xpm, GUI_LogosWindow->window,
1488 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1489 (GtkSignalFunc)GetLogoEvent, toolBar);
1491 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Set logo"), NULL,
1492 NewPixmap(Send_xpm, GUI_LogosWindow->window,
1493 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1494 (GtkSignalFunc)SetLogoEvent, toolBar);
1496 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1498 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Import from file"), NULL,
1499 NewPixmap(Open_xpm, GUI_LogosWindow->window,
1500 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1501 (GtkSignalFunc) OpenLogo, NULL);
1502 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Export to file"), NULL,
1503 NewPixmap(Save_xpm, GUI_LogosWindow->window,
1504 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1505 (GtkSignalFunc) SaveLogo, NULL);
1507 gtk_toolbar_append_space (GTK_TOOLBAR (toolBar));
1509 buttonStartup = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1510 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Startup logo"),
1511 "", NewPixmap(Startup_logo_xpm, GUI_LogosWindow->window,
1512 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1513 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1515 buttonOperator = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1516 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonStartup, NULL, _("Operator logo"),
1517 "", NewPixmap(Operator_logo_xpm, GUI_LogosWindow->window,
1518 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1519 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1521 buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1522 GTK_TOOLBAR_CHILD_RADIOBUTTON,
1524 NULL, _("Caller logo"),
1525 "", NewPixmap(Caller_logo_xpm, GUI_LogosWindow->window,
1526 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1527 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1529 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1531 networkCombo = gtk_combo_new();
1532 gtk_combo_set_use_arrows_always(GTK_COMBO(networkCombo), 1);
1533 while (strcmp(GSM_Networks[i].Name, "unknown"))
1534 glistNetwork = g_list_insert_sorted(glistNetwork, GSM_Networks[i++].Name,
1535 (GCompareFunc)strcmp);
1536 gtk_combo_set_popdown_strings(GTK_COMBO(networkCombo), glistNetwork);
1537 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(networkCombo)->entry), FALSE);
1538 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), networkCombo, "", "");
1539 gtk_widget_show(networkCombo);
1540 g_list_free(glistNetwork);
1542 callerCombo = gtk_combo_new();
1543 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(callerCombo)->entry), FALSE);
1544 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), callerCombo, "", "");
1545 gtk_widget_show(callerCombo);
1547 gtk_box_pack_start(GTK_BOX(vbox), toolBar, FALSE, FALSE, 0);
1548 gtk_widget_show(toolBar);
1550 /* vertical separator */
1551 separator = gtk_hseparator_new();
1552 gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
1554 /* create horizontal box for preview and drawing areas */
1555 hbox = gtk_hbox_new(FALSE,5);
1556 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
1557 gtk_widget_show(hbox);
1559 /* set GSM_Bitmap width,height needed for creating drawinArea
1560 * we are starting, default is startupLogo
1562 bitmap.type = GSM_StartupLogo;
1565 bitmap.size = bitmap.height * bitmap.width / 8;
1566 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1567 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1570 previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
1572 if (previewPixmap != NULL) {
1573 previewArea = gtk_drawing_area_new();
1574 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1575 previewPixmapWidth,previewPixmapHeight);
1577 greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1578 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
1581 gtk_signal_connect(GTK_OBJECT(previewArea),"expose_event",
1582 (GtkSignalFunc)PreviewAreaExposeEvent,NULL);
1583 gtk_signal_connect(GTK_OBJECT(previewArea),"configure_event",
1584 (GtkSignalFunc)PreviewAreaConfigureEvent,NULL);
1585 gtk_signal_connect(GTK_OBJECT(previewArea),"button_press_event",
1586 (GtkSignalFunc)PreviewAreaButtonPressEvent,NULL);
1588 gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
1590 gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
1591 gtk_widget_show(previewArea);
1593 /* clear battery, signal, menu & names from preview phone */
1594 UpdatePreviewPoints ();
1596 } else previewAvailable = 0;
1599 greenPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1600 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Green_point_xpm);
1601 blackPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1602 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Black_point_xpm);
1604 drawingBox = gtk_vbox_new(FALSE,3);
1605 gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
1606 gtk_widget_show(drawingBox);
1608 drawingArea = gtk_drawing_area_new();
1609 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1610 drawingAreaWidth,drawingAreaHeight);
1612 gtk_signal_connect(GTK_OBJECT(drawingArea),"configure_event",
1613 (GtkSignalFunc)DrawingAreaConfigureEvent,NULL);
1614 gtk_signal_connect(GTK_OBJECT(drawingArea),"expose_event",
1615 (GtkSignalFunc)DrawingAreaExposeEvent,NULL);
1616 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_press_event",
1617 (GtkSignalFunc)DrawingAreaButtonPressEvent,NULL);
1618 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_release_event",
1619 (GtkSignalFunc)DrawingAreaButtonReleaseEvent,NULL);
1620 gtk_signal_connect(GTK_OBJECT(drawingArea),"motion_notify_event",
1621 (GtkSignalFunc)DrawingAreaMotionNotifyEvent,NULL);
1623 gtk_widget_set_events(drawingArea,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
1624 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1625 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
1627 gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
1628 gtk_widget_show(drawingArea);
1630 /* vertical tool bar */
1631 vertToolBar = gtk_toolbar_new(GTK_ORIENTATION_VERTICAL,GTK_TOOLBAR_ICONS);
1632 gtk_toolbar_set_button_relief(GTK_TOOLBAR(vertToolBar),GTK_RELIEF_NORMAL);
1633 gtk_toolbar_set_style(GTK_TOOLBAR(vertToolBar),GTK_TOOLBAR_ICONS);
1635 buttonBrush = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1636 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Brush tool"),
1637 "", NewPixmap(Tool_brush_xpm, GUI_LogosWindow->window,
1638 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1639 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1641 buttonLine = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1642 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonBrush, NULL, _("Line tool"),
1643 "", NewPixmap(Tool_line_xpm, GUI_LogosWindow->window,
1644 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1645 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1647 buttonRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1648 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonLine, NULL, _("Rectangle tool"),
1649 "", NewPixmap(Tool_rectangle_xpm, GUI_LogosWindow->window,
1650 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1651 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1653 buttonFilledRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1654 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonRectangle, NULL,
1655 _("Filled rectangle tool"),
1656 "", NewPixmap(Tool_filled_rectangle_xpm,
1657 GUI_LogosWindow->window,
1658 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1659 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1661 gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
1663 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Invert logo"), NULL,
1664 NewPixmap(Edit_invert_xpm, GUI_LogosWindow->window,
1665 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1666 (GtkSignalFunc)InvertLogoEvent, vertToolBar);
1668 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Horizontal flip"), NULL,
1669 NewPixmap(Edit_flip_horizontal_xpm, GUI_LogosWindow->window,
1670 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1671 (GtkSignalFunc)FlipHorizontalLogoEvent, vertToolBar);
1673 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Vertical flip"), NULL,
1674 NewPixmap(Edit_flip_vertical_xpm, GUI_LogosWindow->window,
1675 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1676 (GtkSignalFunc)FlipVerticalLogoEvent, vertToolBar);
1679 gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
1680 gtk_widget_show(vertToolBar);
1682 GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
1685 void GUI_RefreshLogosGroupsCombo (void) {
1686 GList *callerList = NULL;
1689 for (i = 0;i < 6;i++)
1690 callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
1692 gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
1693 g_list_free(callerList);
1695 if (!callersGroupsInitialized) callersGroupsInitialized = 1;
1698 void GUI_ShowLogosWindow (void) {
1699 /* Set network name taken from the phone */
1700 GetNetworkInfoEvent(NULL);
1701 /* if phone support caller groups, read callerGroups names */
1702 if (phoneMonitor.supported & PM_CALLERGROUP) {
1703 if (xgnokiiConfig.callerGroups[0] == NULL) {
1705 GUI_InitCallerGroupsInf ();
1707 if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
1708 gtk_widget_show(buttonCaller);
1709 gtk_widget_show(callerCombo);
1711 /* if not supported, hide widget for handling callerGroups */
1712 gtk_widget_hide(buttonCaller);
1713 gtk_widget_hide(callerCombo);
1716 /* Call to reset Startup logo size */
1717 LogoTypeEvent(GUI_LogosWindow);
1719 gtk_widget_show(GUI_LogosWindow);
1721 if (!previewAvailable && showPreviewErrorDialog) {
1722 gchar *buf = g_strdup(_("Load preview pixmap error, feature disabled."));
1723 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1724 gtk_widget_show(errorDialog.dialog);
1727 showPreviewErrorDialog = 0;