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.
19 #include <sys/types.h>
24 #include "gsm-common.h"
26 #include "cfgreader.h"
27 #include "gsm-networks.h"
28 #include "gsm-filetypes.h"
29 #include "gsm-bitmaps.h"
31 #include "xgnokii_logos.h"
32 #include "xgnokii_common.h"
33 #include "xgnokii_lowlevel.h"
36 #include "xpm/Operator_logo.xpm"
37 #include "xpm/Startup_logo.xpm"
38 #include "xpm/Caller_logo.xpm"
40 #include "xpm/Black_point.xpm"
41 #include "xpm/Green_point.xpm"
42 #include "xpm/Green_pixel.xpm"
44 #include "xpm/New.xpm"
45 #include "xpm/Send.xpm"
46 #include "xpm/Read.xpm"
47 #include "xpm/Open.xpm"
48 #include "xpm/Save.xpm"
50 #include "xpm/Edit_invert.xpm"
51 #include "xpm/Edit_flip_horizontal.xpm"
52 #include "xpm/Edit_flip_vertical.xpm"
54 #include "xpm/Tool_brush.xpm"
55 #include "xpm/Tool_line.xpm"
56 #include "xpm/Tool_rectangle.xpm"
57 #include "xpm/Tool_filled_rectangle.xpm"
59 extern GSM_Network GSM_Networks[];
60 extern GSM_Statemachine statemachine;
62 GtkWidget *GUI_LogosWindow;
64 ErrorDialog errorDialog = {NULL, NULL};
65 InfoDialog infoDialog = {NULL, NULL};
67 /* stuff for drawingArea */
68 GtkWidget *drawingArea = NULL;
69 GdkPixmap *drawingPixmap = NULL;
70 GdkPixmap *greenPointPixmap, *blackPointPixmap;
71 int drawingAreaWidth, drawingAreaHeight; /* in pixels */
72 int mouseButtonPushed = 0;
74 /* stuff for previewArea */
75 GtkWidget *previewArea = NULL;
76 GdkPixmap *previewPixmap = NULL;
77 GdkPixmap *greenPixelPixmap;
78 int previewPixmapWidth, previewPixmapHeight;
79 int previewAvailable = 1, showPreviewErrorDialog = 1;
80 int previewPixmapNumber = 0;
82 GSM_Bitmap bitmap, oldBitmap;
83 GSM_NetworkInfo networkInfo;
85 /* widgets for toolbar - some, need global variables */
86 GtkWidget *buttonStartup, *buttonOperator, *buttonCaller;
87 GtkWidget *networkCombo, *callerCombo;
89 int activeTool = TOOL_BRUSH;
90 int toolStartX, toolStartY, toolLastX, toolLastY;
92 /* tools for drawing */
93 static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
94 static GtkWidget *buttonFilledRectangle;
96 /* Contains fileName for Export dialog. */
101 static ExportDialogData exportDialogData = {NULL};
103 GtkWidget *FileSelection;
105 static int callersGroupsInitialized = 0;
107 /* returns lowest number from three numbers */
108 int GetMinFrom3(int a, int b, int c) {
122 /* returns highest number from three numbers */
123 int GetMaxFrom3(int a, int b, int c) {
137 /* load preview pixmap from file */
138 GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
143 if (previewPixmapNumber == 0)
145 if (!strcmp (xgnokiiConfig.model, "6110") ||
146 !strcmp (xgnokiiConfig.model, "6120"))
148 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
149 "/xpm/Preview_6110.xpm");
150 previewPixmapNumber = 1;
152 else if (!strcmp (xgnokiiConfig.model, "6130") ||
153 !strcmp (xgnokiiConfig.model, "6150") ||
154 !strcmp (xgnokiiConfig.model, "616x") ||
155 !strcmp (xgnokiiConfig.model, "6185") ||
156 !strcmp (xgnokiiConfig.model, "6190"))
158 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
159 "/xpm/Preview_6150.xpm");
160 previewPixmapNumber = 2;
162 else if (!strcmp (xgnokiiConfig.model, "3210"))
164 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
165 "/xpm/Preview_3210.xpm");
166 previewPixmapNumber = 3;
168 else if (!strcmp (xgnokiiConfig.model, "3310") ||
169 !strcmp (xgnokiiConfig.model, "3330"))
171 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
172 "/xpm/Preview_3310.xpm");
173 previewPixmapNumber = 4;
175 else if (!strcmp (xgnokiiConfig.model, "5110") ||
176 !strcmp (xgnokiiConfig.model, "5130"))
178 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
179 "/xpm/Preview_5110.xpm");
180 previewPixmapNumber = 5;
182 else if (!strcmp (xgnokiiConfig.model, "6250"))
184 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
185 "/xpm/Preview_6250.xpm");
186 previewPixmapNumber = 6;
188 else if (!strcmp (xgnokiiConfig.model, "7110"))
190 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
191 "/xpm/Preview_7110.xpm");
192 previewPixmapNumber = 7;
196 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
197 "/xpm/Preview_6210.xpm");
198 previewPixmapNumber = 8;
202 switch (previewPixmapNumber)
204 case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
205 "/xpm/Preview_6110.xpm");
207 case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
208 "/xpm/Preview_6150.xpm");
210 case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
211 "/xpm/Preview_3210.xpm");
213 case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
214 "/xpm/Preview_3310.xpm");
216 case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
217 "/xpm/Preview_5110.xpm");
219 case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
220 "/xpm/Preview_6250.xpm");
222 case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
223 "/xpm/Preview_7110.xpm");
225 default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
226 "/xpm/Preview_6210.xpm");
230 pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
231 &widget->style->bg[GTK_STATE_NORMAL],
239 /* ********************************************************
240 * ** SET/CLEAR POINTS ************************************
241 * ********************************************************
243 void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
244 if (!previewAvailable) return;
246 /* there is difference between positiong of startupLogo and others */
247 if (bitmap.type != GSM_StartupLogo) {
252 /* draw point to pixmap */
254 gdk_draw_point(previewPixmap,widget->style->black_gc,
255 x+PREVIEWSTARTX,y+PREVIEWSTARTY);
258 GdkRectangle updateRect;
260 /* update point on screen */
261 updateRect.width = 1;
262 updateRect.height = 1;
263 updateRect.x = PREVIEWSTARTX+x;
264 updateRect.y = PREVIEWSTARTY+y;
266 gtk_widget_draw(previewArea,&updateRect);
270 void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
271 if (!previewAvailable) return;
273 /* there is difference between positiong of startupLogo and others */
274 if (bitmap.type != GSM_StartupLogo) {
279 /* clean point from pixmap - any idea how to draw green point without pixmap? */
281 gdk_draw_pixmap(previewPixmap,
282 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
283 greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
285 GdkRectangle updateRect;
287 /* clean from screen too */
288 updateRect.width = 1;
289 updateRect.height = 1;
290 updateRect.x = PREVIEWSTARTX+x;
291 updateRect.y = PREVIEWSTARTY+y;
293 gtk_widget_draw(previewArea,&updateRect);
297 int IsPoint(int x, int y) {
298 return GSM_IsPointBitmap(&bitmap,x,y);
301 void SetPoint(GtkWidget *widget, int x, int y, int update) {
302 /* difference between settings points in startupLogo and others */
303 GSM_SetPointBitmap(&bitmap,x,y);
305 /* draw point to pixmap */
306 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
307 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
310 GdkRectangle updateRect;
312 /* calculate update rectangle */
313 updateRect.width = POINTSIZE+2;
314 updateRect.height = POINTSIZE+2;
315 updateRect.x = x * (POINTSIZE+1);
316 updateRect.y = y * (POINTSIZE+1);
318 /* update on screen */
319 gtk_widget_draw(drawingArea,&updateRect);
322 /* draw preview point too */
323 if (previewAvailable) SetPreviewPoint(widget,x,y,update);
326 void ClearPoint(GtkWidget *widget, int x, int y, int update) {
327 /* difference between settings points in startupLogo and others */
328 GSM_ClearPointBitmap(&bitmap,x,y);
330 /* clear point from pixmap */
331 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
332 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
335 GdkRectangle updateRect;
337 /* calculate update rectangle */
338 updateRect.width = POINTSIZE+2;
339 updateRect.height = POINTSIZE+2;
340 updateRect.x = x * (POINTSIZE+1);
341 updateRect.y = y * (POINTSIZE+1);
343 /* update on screen */
344 gtk_widget_draw(drawingArea,&updateRect);
347 /* clear point from previewArea too */
348 if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
351 /* ****************************************************
352 * *** UPDATES - PREVIEW & DRAWING AREAS **************
353 * ****************************************************
356 /* this redraw all logo points - preview & drawing area */
357 void UpdatePointsRectangle(GtkWidget *widget, int x1, int y1, int x2, int y2) {
358 GdkRectangle updateRect;
359 int x, y, dx = 0, dy = 0;
361 if (bitmap.type != GSM_StartupLogo) {
378 for (y = y1;y <= y2;y++)
379 for (x = x1;x <= x2;x++) {
381 /* set on drawing area */
382 gdk_draw_pixmap(drawingPixmap,
383 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
384 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
387 if (previewAvailable && previewPixmap)
388 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
389 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
391 /* clear from drawing */
392 gdk_draw_pixmap(drawingPixmap,
393 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
394 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
396 /* clear from preview */
397 if (previewAvailable && previewPixmap)
398 gdk_draw_pixmap(previewPixmap,
399 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
400 greenPixelPixmap,0,0,x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,
405 if (previewAvailable) {
406 updateRect.x = PREVIEWSTARTX+dx+x1;
407 updateRect.y = PREVIEWSTARTY+dy+y1;
408 updateRect.width = x2-x1+1;
409 updateRect.height = y2-y1+1;
410 gtk_widget_draw(previewArea,&updateRect);
413 updateRect.x = x1*(POINTSIZE+1);
414 updateRect.y = y1*(POINTSIZE+1);
415 updateRect.width = (x2-x1+1)*(POINTSIZE+1)+1;
416 updateRect.height = (y2-y1+1)*(POINTSIZE+1)+1;
417 gtk_widget_draw(drawingArea,&updateRect);
420 void UpdatePoints(GtkWidget *widget) {
421 UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
424 /* this redraw all logo points in previewArea, NO DRAWING AREA */
425 void UpdatePreviewPoints (void) {
426 GdkRectangle updateRect;
427 int x, y, dx = 0, dy = 0;
429 if (!previewPixmap || !previewAvailable) return;
431 if (bitmap.type != GSM_StartupLogo) {
436 for (y = 0;y < bitmap.height;y++)
437 for (x = 0;x < bitmap.width;x++) {
439 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
440 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
442 gdk_draw_pixmap(previewPixmap,
443 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
444 greenPixelPixmap,0,0,
445 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,1,1);
451 updateRect.width = bitmap.width;
452 updateRect.height = bitmap.height;
453 gtk_widget_draw(previewArea,&updateRect);
456 /* ******************************************************
457 * **** DRAWING TOOLS ***********************************
458 * ******************************************************
462 void ToolBrush(GtkWidget *widget, int column, int row, int button) {
463 /* only this tool directly update bitmap & screen */
465 ClearPoint(widget,column,row,1);
467 SetPoint(widget,column,row,1);
472 /* this function clear or draw a line on the screen USED BY TOOLLINEUPDATE */
473 void ToolLine(GtkWidget *widget, int x1, int y1, int x2, int y2, int draw) {
474 int udx, udy, dx, dy, error, loop, xadd, yadd;
476 dx = x2 - x1; /* x delta */
477 dy = y2 - y1; /* y delta */
479 udx = abs(dx); /* unsigned x delta */
480 udy = abs(dy); /* unsigned y delta */
482 if (dx < 0) { xadd = -1; } else { xadd = 1; } /* set directions */
483 if (dy < 0) { yadd = -1; } else { yadd = 1; }
487 if (udx > udy) { /* delta X > delta Y */
491 if (error >= udx) { /* is time to move up or down? */
497 SetPoint(widget,x1,y1,0);
499 /* now clearing line before drawing new one, we must check */
500 /* if there is a point in oldBitmap which saves bitmap before */
501 /* we starting drawing new line */
502 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
503 ClearPoint(widget,x1,y1,0);
506 x1 += xadd; /* move horizontally */
507 } while (loop < udx); /* repeat for x length */
511 if (error >= udy) { /* is time to move left or right? */
517 SetPoint(widget,x1,y1,0);
519 /* check comment in delta X > delta Y */
520 if (!GSM_IsPointBitmap(&oldBitmap,x1,y1)) {
521 ClearPoint(widget,x1,y1,0);
524 y1 += yadd; /* move vertically */
525 } while (loop < udy); /* repeat for y length */
529 /* going to rewrite to Bresenham algorithm */
530 void ToolLineUpdate(GtkWidget *widget, int column, int row) {
532 ToolLine(widget,toolStartX,toolStartY,toolLastX,toolLastY,0);
534 ToolLine(widget,toolStartX,toolStartY,column,row,1);
537 /* TOOL - FILLED RECT */
539 /* FIXME - going to rewrite for optimalized version, clearing and */
540 /* drawing new parts only before clearing and drawing whole */
541 /* filled rectangle - it's too slow on diskless terminal ;(( */
542 void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
543 int i, j, x1, y1, x2, y2;
545 /* swap Xs to x1 < x2 */
546 if (toolStartX > toolLastX) {
554 /* swap Ys to y1 < y2 */
555 if (toolStartY > toolLastY) {
564 for (j = y1;j <= y2;j++)
565 for (i = x1;i <= x2;i++)
566 if (!GSM_IsPointBitmap(&oldBitmap,i,j)) ClearPoint(widget,i,j,0);
568 /* swap Xs to x1 < x2 */
569 if (toolStartX > column) {
577 /* swap Ys to y1 < y2 */
578 if (toolStartY > row) {
587 for (j = y1;j <= y2;j++)
588 for (i = x1;i <= x2;i++)
589 SetPoint(widget,i,j,0);
592 /* TOOL - RECTANGLE */
593 void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
594 int i, j, x1, y1, x2, y2;
596 /* clear old rectangle */
597 /* swap Xs to x1 < x2 */
598 if (toolStartX > toolLastX) {
606 /* swap Ys to y1 < y2 */
607 if (toolStartY > toolLastY) {
616 for (i = x1;i <= x2;i++) {
617 if (!GSM_IsPointBitmap(&oldBitmap,i,y1)) ClearPoint(widget,i,y1,0);
618 if (!GSM_IsPointBitmap(&oldBitmap,i,y2)) ClearPoint(widget,i,y2,0);
621 for (j = y1;j <= y2;j++) {
622 if (!GSM_IsPointBitmap(&oldBitmap,x1,j)) ClearPoint(widget,x1,j,0);
623 if (!GSM_IsPointBitmap(&oldBitmap,x2,j)) ClearPoint(widget,x2,j,0);
626 /* draw new rectangle */
627 /* swap Xs to x1 < x2 */
628 if (toolStartX > column) {
636 /* swap Ys to y1 < y2 */
637 if (toolStartY > row) {
646 for (i = x1;i <= x2;i++) {
647 if (!IsPoint(i,y1)) SetPoint(widget,i,y1,0);
648 if (!IsPoint(i,y2)) SetPoint(widget,i,y2,0);
651 for (j = y1;j <= y2;j++) {
652 if (!IsPoint(x1,j)) SetPoint(widget,x1,j,0);
653 if (!IsPoint(x2,j)) SetPoint(widget,x2,j,0);
657 /* this update tools actions on the screen - this is for optimalization */
658 /* eg. for faster redrawing tools actions - we do not need redraw pixel */
659 /* by pixel. Faster is redraw whole rectangle which contains all changes */
660 void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
661 GdkRectangle updateRect;
663 /* update preview area */
664 if (previewAvailable) {
665 updateRect.x = PREVIEWSTARTX+x1;
666 updateRect.y = PREVIEWSTARTY+y1;
667 if (bitmap.type != GSM_StartupLogo) {
668 updateRect.x += PREVIEWJUMPX;
669 updateRect.y += PREVIEWJUMPY;
671 updateRect.width = x2-x1+1;
672 updateRect.height = y2-y1+1;
673 gtk_widget_draw(previewArea,&updateRect);
676 /* update drawing area */
677 updateRect.x = x1 * (POINTSIZE+1);
678 updateRect.y = y1 * (POINTSIZE+1);
679 updateRect.width = (x2-x1+1)*(POINTSIZE+2);
680 updateRect.height = (y2-y1+1)*(POINTSIZE+2);
681 gtk_widget_draw(drawingArea,&updateRect);
684 /* *************************************
685 * ** PREVIEW AREA EVENTS **************
686 * *************************************
689 gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
690 previewPixmapNumber = (previewPixmapNumber % 8) + 1;
692 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
693 previewPixmapWidth,previewPixmapHeight);
698 gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
699 if (previewPixmap) gdk_pixmap_unref(previewPixmap);
700 previewPixmap = GetPreviewPixmap(widget);
702 UpdatePreviewPoints();
707 gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
708 /* got previewPixmap? */
710 /* yes - simply redraw some rectangle */
711 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
712 previewPixmap,event->area.x,event->area.y,event->area.x,
713 event->area.y,event->area.width,event->area.height);
718 /* ********************************
719 * ** DRAWING AREA EVENTS *********
720 * ********************************
723 gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
724 /* got drawingPixmap? */
725 if (drawingPixmap == NULL) return TRUE;
727 if (!mouseButtonPushed) {
728 if ((event->button == 1 && activeTool != TOOL_BRUSH) ||
729 (activeTool == TOOL_BRUSH)) {
730 /* position from we starting drawing */
731 toolStartX = event->x / (POINTSIZE+1);
732 if (toolStartX < 0) toolStartX = 0;
733 if (toolStartX > bitmap.width-1) toolStartX = bitmap.width-1;
735 toolStartY = event->y / (POINTSIZE+1);
736 if (toolStartY < 0) toolStartY = 0;
737 if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
739 toolLastX = toolStartX;
740 toolLastY = toolStartY;
742 /* store old bitmap for drawing, resp. for moving, resizing primitive */
743 memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
746 if (event->button == 1) mouseButtonPushed = 1;
748 switch (activeTool) {
750 ToolBrush(widget,toolStartX,toolStartY,event->button);
754 if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
759 /* user is drawing some tool other than TOOL_BRUSH and pushed mouse button
760 * another than first => cancel tool and redraw to oldBitmap (bitmap when
761 * user start drawing)
763 if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
764 int lowestX, lowestY, highestX, highestY;
767 lowestX = GetMinFrom3(toolStartX,toolLastX,toolLastX);
768 lowestY = GetMinFrom3(toolStartY,toolLastY,toolLastY);
769 highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
770 highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
772 for (j = lowestY;j <= highestY;j++)
773 for (i = lowestX;i <= highestX;i++)
774 if (GSM_IsPointBitmap(&oldBitmap,i,j))
775 SetPoint(widget,i,j,0);
777 ClearPoint(widget,i,j,0);
778 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
780 mouseButtonPushed = 0;
786 gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
787 if (event->button == 1)
788 mouseButtonPushed = 0;
793 gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
795 GdkModifierType state;
797 if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
800 gdk_window_get_pointer(event->window,&x,&y,&state);
804 state = event->state;
807 x = x / (POINTSIZE+1);
808 y = y / (POINTSIZE+1);
811 if (x > bitmap.width-1) x = bitmap.width-1;
812 if (y > bitmap.height-1) y = bitmap.height-1;
814 if (y == toolLastY && x == toolLastX) return TRUE;
816 switch (activeTool) {
818 if (state & GDK_BUTTON1_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,1);
819 if (state & GDK_BUTTON2_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,2);
820 if (state & GDK_BUTTON3_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,3);
823 if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
825 case TOOL_FILLED_RECTANGLE:
826 if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
829 if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
834 * it's simple, above tools updates only bitmap in memory and this
835 * function update from bitmap to screen, it's made as non-blinking
836 * drawing functions with this, simply draw everything we need and
837 * after that, redraw to screen rectangle in which we made changes
838 * it's not redrawing pixel by pixel (blinking)
840 if (activeTool != TOOL_BRUSH) {
841 int lowestX, lowestY, highestX, highestY;
843 lowestX = GetMinFrom3(toolStartX,toolLastX,x);
844 lowestY = GetMinFrom3(toolStartY,toolLastY,y);
845 highestX = GetMaxFrom3(toolStartX,toolLastX,x);
846 highestY = GetMaxFrom3(toolStartY,toolLastY,y);
848 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
856 /* configureEvent? -> event when someone resize windows, ... */
857 gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
859 /* got drawingPixmap? */
860 if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
862 /* make a new pixmap */
863 drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
864 drawingAreaHeight,-1);
866 /* draw grid into pixmap */
867 for (y = 0;y < bitmap.height;y++)
868 for (x = 0;x < bitmap.width;x++)
870 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
871 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
873 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
874 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
879 gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
880 /* got drawingPixmap? */
883 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
885 event->area.x,event->area.y,event->area.x,event->area.y,
886 event->area.width,event->area.height);
890 /* *****************************************
891 * ** TOOLBAR & MENU EVENTS ****************
892 * *****************************************
895 void GetNetworkInfoEvent(GtkWidget *widget) {
897 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
898 D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
900 /* prepare data for event */
901 data->info = &networkInfo;
902 e->event = Event_GetNetworkInfo;
905 /* launch event and wait for result */
907 pthread_mutex_lock(&getNetworkInfoMutex);
908 pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
909 pthread_mutex_unlock(&getNetworkInfoMutex);
910 error = data->status;
913 /* watch for errors */
914 if (error != GE_NONE) {
915 gchar *buf = g_strdup_printf(_("Error getting network info\n(error=%d)"),error);
916 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
917 gtk_widget_show(errorDialog.dialog);
921 /* set new operator name to combo */
922 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
923 GSM_GetNetworkName(networkInfo.NetworkCode));
926 void GetLogoEvent(GtkWidget *widget) {
929 PhoneEvent *e = (PhoneEvent *) g_malloc(sizeof(PhoneEvent));
930 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
931 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
933 /* prepare data for event */
934 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
935 data->bitmap = &bitmap;
936 e->event = Event_GetBitmap;
938 if (phoneMonitor.supported & PM_CALLERGROUP) {
939 for (i = 0;i < 6;i++)
940 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
941 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
944 /* launch event and wait for result */
946 pthread_mutex_lock(&getBitmapMutex);
947 pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
948 pthread_mutex_unlock(&getBitmapMutex);
949 error = data->status;
952 /* watch for errors */
953 if (error != GE_NONE) {
954 gchar *buf = g_strdup_printf(_("Error getting bitmap\n(error=%d)"),error);
955 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
956 gtk_widget_show(errorDialog.dialog);
959 /* no error, draw logo from phone */
960 UpdatePoints(drawingArea);
964 void SetLogoEvent(GtkWidget *widget) {
966 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
967 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
968 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
972 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
974 if (bitmap.type == GSM_CallerLogo) {
975 /* above condition must be there, because if you launch logos before
976 * callerGroups are available, you will see segfault - callerGroups not initialized
978 if (phoneMonitor.supported & PM_CALLERGROUP) {
979 for (i = 0;i < 6;i++)
980 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
981 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
985 data->bitmap = &bitmap;
986 e->event = Event_SetBitmap;
989 /* launch event and wait for result */
991 pthread_mutex_lock(&setBitmapMutex);
992 pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
993 pthread_mutex_unlock(&setBitmapMutex);
994 error = data->status;
997 /* watch for errors */
998 if (error != GE_NONE) {
999 gchar *buf = g_strdup_printf(_("Error setting bitmap\n(error=%d)"),error);
1000 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1001 gtk_widget_show(errorDialog.dialog);
1006 static void ClearLogoEvent(GtkWidget *widget) {
1008 // bitmap.size=bitmap.width*bitmap.height/8;
1010 GSM_ClearBitmap(&bitmap);
1012 UpdatePoints(widget);
1015 void InvertLogoEvent(GtkWidget *widget) {
1018 for (column = 0;column < bitmap.width;column++)
1019 for (row = 0;row < bitmap.height;row++)
1020 if (IsPoint(column,row))
1021 GSM_ClearPointBitmap(&bitmap,column,row);
1023 GSM_SetPointBitmap(&bitmap,column,row);
1025 UpdatePoints(widget);
1028 void UpLogoEvent(GtkWidget *widget) {
1033 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1035 for (row = 0;row < bitmap.height-1;row++)
1036 for (column = 0;column < bitmap.width;column++)
1037 if (IsPoint(column,row+1))
1038 GSM_SetPointBitmap(&bitmap,column,row);
1040 GSM_ClearPointBitmap(&bitmap,column,row);
1042 for (column = 0;column < bitmap.width;column++)
1043 if (GSM_IsPointBitmap(&tbitmap,column,0))
1044 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1);
1046 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1);
1048 UpdatePoints(widget);
1051 void DownLogoEvent(GtkWidget *widget) {
1056 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1058 for (row = bitmap.height-1;row > 0;row--)
1059 for (column = 0;column < bitmap.width;column++)
1060 if (IsPoint(column,row-1))
1061 GSM_SetPointBitmap(&bitmap,column,row);
1063 GSM_ClearPointBitmap(&bitmap,column,row);
1065 for (column = 0;column < bitmap.width;column++)
1066 if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
1067 GSM_SetPointBitmap(&bitmap,column,0);
1069 GSM_ClearPointBitmap(&bitmap,column,0);
1071 UpdatePoints(widget);
1074 void LeftLogoEvent(GtkWidget *widget) {
1079 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1081 for (column = 0; column < bitmap.width-1;column++)
1082 for (row = 0;row < bitmap.height;row++)
1083 if (IsPoint(column+1,row))
1084 GSM_SetPointBitmap(&bitmap,column,row);
1086 GSM_ClearPointBitmap(&bitmap,column,row);
1088 for (row = 0;row < bitmap.height;row++)
1089 if (GSM_IsPointBitmap(&tbitmap,0,row))
1090 GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
1092 GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
1094 UpdatePoints(widget);
1097 void RightLogoEvent(GtkWidget *widget) {
1102 memcpy(&tbitmap,&bitmap,sizeof(GSM_Bitmap));
1104 for (column = bitmap.width-1;column > 0;column--)
1105 for (row = 0;row < bitmap.height;row++)
1106 if (IsPoint(column-1,row))
1107 GSM_SetPointBitmap(&bitmap,column,row);
1109 GSM_ClearPointBitmap(&bitmap,column,row);
1111 for (row = 0;row < bitmap.height;row++)
1112 if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
1113 GSM_SetPointBitmap(&bitmap,0,row);
1115 GSM_ClearPointBitmap(&bitmap,0,row);
1117 UpdatePoints(widget);
1120 void FlipVerticalLogoEvent(GtkWidget *widget) {
1121 int row, column, temp;
1123 for (row = 0;row < (bitmap.height/2);row++)
1124 for (column = 0;column < bitmap.width;column++) {
1125 temp = IsPoint(column,row);
1126 if (IsPoint(column,bitmap.height-1-row))
1127 GSM_SetPointBitmap(&bitmap,column,row);
1129 GSM_ClearPointBitmap(&bitmap,column,row);
1132 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
1134 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
1137 UpdatePoints(widget);
1140 void FlipHorizontalLogoEvent(GtkWidget *widget) {
1141 int row, column, temp;
1143 for (row = 0;row < bitmap.height;row++)
1144 for (column = 0;column < (bitmap.width/2);column++) {
1145 temp = IsPoint(column,row);
1147 if (IsPoint(bitmap.width-1-column,row))
1148 GSM_SetPointBitmap(&bitmap,column,row);
1150 GSM_ClearPointBitmap(&bitmap,column,row);
1153 GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
1155 GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
1158 UpdatePoints(widget);
1161 /* this is launched when tool was changed */
1162 gint ToolTypeEvent(GtkWidget *widget) {
1163 if (GTK_TOGGLE_BUTTON(buttonBrush)->active) activeTool = TOOL_BRUSH; else
1164 if (GTK_TOGGLE_BUTTON(buttonLine)->active) activeTool = TOOL_LINE; else
1165 if (GTK_TOGGLE_BUTTON(buttonRectangle)->active) activeTool = TOOL_RECTANGLE; else
1166 if (GTK_TOGGLE_BUTTON(buttonFilledRectangle)->active)
1167 activeTool = TOOL_FILLED_RECTANGLE;
1172 /* this is launched when logo type was change by buttons on toolbar */
1173 gint LogoTypeEvent(GtkWidget *widget) {
1176 /* is startupLogo? */
1177 /* Resize and clear anyway - CK */
1178 if (GTK_TOGGLE_BUTTON(buttonStartup)->active) {
1179 /* look for old bitmap type, clean if another */
1181 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo, &statemachine.Phone.Info);
1184 /* has phone support for callerGroups? */
1185 if (phoneMonitor.supported & PM_CALLERGROUP) {
1186 if (GTK_TOGGLE_BUTTON(buttonCaller)->active && bitmap.type != GSM_CallerLogo) {
1187 /* previous was startup? clear and draw batteries, signal, ... */
1188 /* Clear anyway for 7110...CK */
1190 GSM_ResizeBitmap(&bitmap,GSM_CallerLogo, &statemachine.Phone.Info);
1194 /* is new type operatorLogo? */
1195 if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo) {
1196 /* previous startup? clear and draw batteries, signal, ... */
1197 /* Clear anyway for 7110..CK */
1199 GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo, &statemachine.Phone.Info);
1204 if (previewAvailable) {
1205 /* configure event reload pixmap from disk and redraws */
1206 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1207 previewPixmapWidth,previewPixmapHeight);
1210 /* change new drawingArea size */
1211 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1212 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1214 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1215 drawingAreaWidth,drawingAreaHeight);
1221 inline void CloseLogosWindow (void) {
1222 gtk_widget_hide(GUI_LogosWindow);
1225 void ExportLogoFileMain(gchar *name)
1232 strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
1234 error=GSM_SaveBitmapFile(name,&tbitmap);
1235 if (error!=GE_NONE) {
1236 gchar *buf = g_strdup_printf(_("Error saving file\n(error=%d)"),error);
1237 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1238 gtk_widget_show(errorDialog.dialog);
1243 static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
1245 gtk_widget_hide (GTK_WIDGET (data));
1246 ExportLogoFileMain(exportDialogData.fileName);
1249 static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
1251 static YesNoDialog dialog = { NULL, NULL};
1255 exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1256 gtk_widget_hide (GTK_WIDGET (fs));
1258 if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
1261 if (dialog.dialog == NULL)
1263 CreateYesNoDialog (&dialog, YesLogoFileExportDialog, CancelDialog, GUI_LogosWindow);
1264 gtk_window_set_title (GTK_WINDOW (dialog.dialog), _("Overwrite file?"));
1265 g_snprintf ( err, 80, _("File %s already exist.\nOverwrite?"), exportDialogData.fileName);
1266 gtk_label_set_text (GTK_LABEL(dialog.text), err);
1268 gtk_widget_show (dialog.dialog);
1271 ExportLogoFileMain(exportDialogData.fileName);
1274 void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
1282 fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1283 gtk_widget_hide (GTK_WIDGET (fs));
1285 if ((f = fopen (fileName, "r")) == NULL) {
1286 gchar *buf = g_strdup_printf(_("Can't open file %s for reading !"),fileName);
1287 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1288 gtk_widget_show(errorDialog.dialog);
1293 error=GSM_ReadBitmapFile(fileName,&tbitmap);
1294 if (error!=GE_NONE) {
1295 gchar *buf = g_strdup_printf(_("Error reading file\n(error=%d)"),error);
1296 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1297 gtk_widget_show(errorDialog.dialog);
1302 exportDialogData.fileName=fileName;
1304 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),false);
1305 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),false);
1306 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),false);
1308 if (tbitmap.type==GSM_OperatorLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),true);
1309 if (tbitmap.type==GSM_StartupLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),true);
1310 if (tbitmap.type==GSM_CallerLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),true);
1312 memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
1314 UpdatePoints(drawingArea);
1317 void SaveLogoAs(GtkWidget *widget)
1319 FileSelection=gtk_file_selection_new (_("Save logo as ..."));
1321 gtk_signal_connect (
1322 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1323 "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
1325 gtk_signal_connect_object (
1326 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1327 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1328 GTK_OBJECT (FileSelection));
1330 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1332 gtk_widget_show(FileSelection);
1335 void SaveLogo(GtkWidget *widget)
1337 if (exportDialogData.fileName==NULL) {
1340 ExportLogoFileMain(exportDialogData.fileName);
1344 void OpenLogo(GtkWidget *widget)
1346 FileSelection=gtk_file_selection_new (_("Open logo..."));
1348 gtk_signal_connect (
1349 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1350 "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
1352 gtk_signal_connect_object (
1353 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1354 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1355 GTK_OBJECT (FileSelection));
1357 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1359 gtk_widget_show(FileSelection);
1362 static GtkItemFactoryEntry logosMenuItems[] = {
1363 { NULL, NULL, NULL, 0, "<Branch>"},
1364 { NULL, "<control>O", OpenLogo, 0, NULL},
1365 { NULL, "<control>S", SaveLogo, 0, NULL},
1366 { NULL, NULL, SaveLogoAs, 0, NULL},
1367 { NULL, NULL, NULL, 0, "<Separator>"},
1368 { NULL, "<control>G", GetNetworkInfoEvent, 0, NULL},
1369 { NULL, NULL, GetLogoEvent, 0, NULL},
1370 { NULL, "<control>T", SetLogoEvent, 0, NULL},
1371 { NULL, NULL, NULL, 0, "<Separator>"},
1372 { NULL, "<control>W", CloseLogosWindow, 0, NULL},
1373 { NULL, NULL, NULL, 0, "<Branch>"},
1374 { NULL, "<control>C", ClearLogoEvent, 0, NULL},
1375 { NULL, "<control>I", InvertLogoEvent, 0, NULL},
1376 { NULL, NULL, NULL, 0, "<Separator>"},
1377 { NULL, "<control>U", UpLogoEvent, 0, NULL},
1378 { NULL, "<control>D", DownLogoEvent, 0, NULL},
1379 { NULL, "<control>L", LeftLogoEvent, 0, NULL},
1380 { NULL, "<control>R", RightLogoEvent, 0, NULL},
1381 { NULL, NULL, NULL, 0, "<Separator>"},
1382 { NULL, "<control>H", FlipHorizontalLogoEvent, 0, NULL},
1383 { NULL, "<control>V", FlipVerticalLogoEvent, 0, NULL},
1386 void InitLogosMenu (void) {
1387 logosMenuItems[0].path = g_strdup(_("/_File"));
1388 logosMenuItems[1].path = g_strdup(_("/File/_Open"));
1389 logosMenuItems[2].path = g_strdup(_("/File/_Save"));
1390 logosMenuItems[3].path = g_strdup(_("/File/Save _as ..."));
1391 logosMenuItems[4].path = g_strdup(_("/File/Sep1"));
1392 logosMenuItems[5].path = g_strdup(_("/File/_Get operator"));
1393 logosMenuItems[6].path = g_strdup(_("/File/Get _logo"));
1394 logosMenuItems[7].path = g_strdup(_("/File/Se_t logo"));
1395 logosMenuItems[8].path = g_strdup(_("/File/Sep2"));
1396 logosMenuItems[9].path = g_strdup(_("/File/_Close"));
1397 logosMenuItems[10].path = g_strdup(_("/_Edit"));
1398 logosMenuItems[11].path = g_strdup(_("/Edit/_Clear"));
1399 logosMenuItems[12].path = g_strdup(_("/Edit/_Invert"));
1400 logosMenuItems[13].path = g_strdup(_("/Edit/Sep3"));
1401 logosMenuItems[14].path = g_strdup(_("/Edit/_Up logo"));
1402 logosMenuItems[15].path = g_strdup(_("/Edit/_Down logo"));
1403 logosMenuItems[16].path = g_strdup(_("/Edit/_Left logo"));
1404 logosMenuItems[17].path = g_strdup(_("/Edit/_Right logo"));
1405 logosMenuItems[18].path = g_strdup(_("/Edit/Sep4"));
1406 logosMenuItems[19].path = g_strdup(_("/Edit/Flip _horizontal"));
1407 logosMenuItems[20].path = g_strdup(_("/Edit/Flip _vertical"));
1410 void GUI_CreateLogosWindow (void) {
1411 int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
1412 GtkAccelGroup *accelGroup;
1413 GtkItemFactory *itemFactory;
1415 GtkWidget *toolBar, *vertToolBar;
1418 GtkWidget *drawingBox;
1419 GtkWidget *separator;
1422 GList *glistNetwork = NULL;
1426 previewPixmapWidth = PREVIEWWIDTH;
1427 previewPixmapHeight = PREVIEWHEIGHT;
1431 /* realize top level window for logos */
1432 GUI_LogosWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1433 gtk_window_set_wmclass(GTK_WINDOW(GUI_LogosWindow), "LogosWindow", "Xgnokii");
1434 gtk_window_set_policy(GTK_WINDOW(GUI_LogosWindow), 1, 1, 1);
1435 gtk_window_set_title(GTK_WINDOW(GUI_LogosWindow), _("Logos"));
1436 gtk_signal_connect(GTK_OBJECT(GUI_LogosWindow), "delete_event",
1437 GTK_SIGNAL_FUNC(DeleteEvent), NULL);
1438 gtk_widget_realize(GUI_LogosWindow);
1440 CreateErrorDialog(&errorDialog, GUI_LogosWindow);
1441 CreateInfoDialog(&infoDialog, GUI_LogosWindow);
1443 accelGroup = gtk_accel_group_new();
1444 gtk_accel_group_attach(accelGroup, GTK_OBJECT(GUI_LogosWindow));
1446 /* create main vbox */
1447 vbox = gtk_vbox_new(FALSE, 1);
1448 gtk_container_add(GTK_CONTAINER(GUI_LogosWindow), vbox);
1449 gtk_widget_show(vbox);
1451 itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR, "<main>", accelGroup);
1452 gtk_item_factory_create_items(itemFactory, nMenuItems, logosMenuItems, NULL);
1453 menuBar = gtk_item_factory_get_widget(itemFactory, "<main>");
1455 gtk_box_pack_start(GTK_BOX(vbox), menuBar, FALSE, FALSE, 0);
1456 gtk_widget_show(menuBar);
1459 toolBar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL, GTK_TOOLBAR_ICONS);
1460 gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolBar), GTK_RELIEF_NORMAL);
1461 gtk_toolbar_set_style(GTK_TOOLBAR(toolBar), GTK_TOOLBAR_ICONS);
1463 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Clear logo"), NULL,
1464 NewPixmap(New_xpm, GUI_LogosWindow->window,
1465 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1466 (GtkSignalFunc)ClearLogoEvent, toolBar);
1468 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1470 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Get logo"), NULL,
1471 NewPixmap(Read_xpm, GUI_LogosWindow->window,
1472 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1473 (GtkSignalFunc)GetLogoEvent, toolBar);
1475 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar), NULL, _("Set logo"), NULL,
1476 NewPixmap(Send_xpm, GUI_LogosWindow->window,
1477 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1478 (GtkSignalFunc)SetLogoEvent, toolBar);
1480 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1482 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Import from file"), NULL,
1483 NewPixmap(Open_xpm, GUI_LogosWindow->window,
1484 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1485 (GtkSignalFunc) OpenLogo, NULL);
1486 gtk_toolbar_append_item (GTK_TOOLBAR (toolBar), NULL, _("Export to file"), NULL,
1487 NewPixmap(Save_xpm, GUI_LogosWindow->window,
1488 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1489 (GtkSignalFunc) SaveLogo, NULL);
1491 gtk_toolbar_append_space (GTK_TOOLBAR (toolBar));
1493 buttonStartup = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1494 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Startup logo"),
1495 "", NewPixmap(Startup_logo_xpm, GUI_LogosWindow->window,
1496 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1497 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1499 buttonOperator = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1500 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonStartup, NULL, _("Operator logo"),
1501 "", NewPixmap(Operator_logo_xpm, GUI_LogosWindow->window,
1502 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1503 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1505 buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1506 GTK_TOOLBAR_CHILD_RADIOBUTTON,
1508 NULL, _("Caller logo"),
1509 "", NewPixmap(Caller_logo_xpm, GUI_LogosWindow->window,
1510 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1511 GTK_SIGNAL_FUNC(LogoTypeEvent), NULL);
1513 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1515 networkCombo = gtk_combo_new();
1516 gtk_combo_set_use_arrows_always(GTK_COMBO(networkCombo), 1);
1517 while (strcmp(GSM_Networks[i].Name, "unknown"))
1518 glistNetwork = g_list_insert_sorted(glistNetwork, GSM_Networks[i++].Name,
1519 (GCompareFunc)strcmp);
1520 gtk_combo_set_popdown_strings(GTK_COMBO(networkCombo), glistNetwork);
1521 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(networkCombo)->entry), FALSE);
1522 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), networkCombo, "", "");
1523 gtk_widget_show(networkCombo);
1524 g_list_free(glistNetwork);
1526 callerCombo = gtk_combo_new();
1527 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(callerCombo)->entry), FALSE);
1528 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar), callerCombo, "", "");
1529 gtk_widget_show(callerCombo);
1531 gtk_box_pack_start(GTK_BOX(vbox), toolBar, FALSE, FALSE, 0);
1532 gtk_widget_show(toolBar);
1534 /* vertical separator */
1535 separator = gtk_hseparator_new();
1536 gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
1538 /* create horizontal box for preview and drawing areas */
1539 hbox = gtk_hbox_new(FALSE,5);
1540 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
1541 gtk_widget_show(hbox);
1543 /* set GSM_Bitmap width,height needed for creating drawinArea
1544 * we are starting, default is startupLogo
1546 bitmap.type = GSM_StartupLogo;
1549 bitmap.size = bitmap.height * bitmap.width / 8;
1550 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1551 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1554 previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
1556 if (previewPixmap != NULL) {
1557 previewArea = gtk_drawing_area_new();
1558 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1559 previewPixmapWidth,previewPixmapHeight);
1561 greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1562 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
1565 gtk_signal_connect(GTK_OBJECT(previewArea),"expose_event",
1566 (GtkSignalFunc)PreviewAreaExposeEvent,NULL);
1567 gtk_signal_connect(GTK_OBJECT(previewArea),"configure_event",
1568 (GtkSignalFunc)PreviewAreaConfigureEvent,NULL);
1569 gtk_signal_connect(GTK_OBJECT(previewArea),"button_press_event",
1570 (GtkSignalFunc)PreviewAreaButtonPressEvent,NULL);
1572 gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
1574 gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
1575 gtk_widget_show(previewArea);
1577 /* clear battery, signal, menu & names from preview phone */
1578 UpdatePreviewPoints ();
1580 } else previewAvailable = 0;
1583 greenPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1584 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Green_point_xpm);
1585 blackPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1586 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Black_point_xpm);
1588 drawingBox = gtk_vbox_new(FALSE,3);
1589 gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
1590 gtk_widget_show(drawingBox);
1592 drawingArea = gtk_drawing_area_new();
1593 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1594 drawingAreaWidth,drawingAreaHeight);
1596 gtk_signal_connect(GTK_OBJECT(drawingArea),"configure_event",
1597 (GtkSignalFunc)DrawingAreaConfigureEvent,NULL);
1598 gtk_signal_connect(GTK_OBJECT(drawingArea),"expose_event",
1599 (GtkSignalFunc)DrawingAreaExposeEvent,NULL);
1600 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_press_event",
1601 (GtkSignalFunc)DrawingAreaButtonPressEvent,NULL);
1602 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_release_event",
1603 (GtkSignalFunc)DrawingAreaButtonReleaseEvent,NULL);
1604 gtk_signal_connect(GTK_OBJECT(drawingArea),"motion_notify_event",
1605 (GtkSignalFunc)DrawingAreaMotionNotifyEvent,NULL);
1607 gtk_widget_set_events(drawingArea,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
1608 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1609 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
1611 gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
1612 gtk_widget_show(drawingArea);
1614 /* vertical tool bar */
1615 vertToolBar = gtk_toolbar_new(GTK_ORIENTATION_VERTICAL,GTK_TOOLBAR_ICONS);
1616 gtk_toolbar_set_button_relief(GTK_TOOLBAR(vertToolBar),GTK_RELIEF_NORMAL);
1617 gtk_toolbar_set_style(GTK_TOOLBAR(vertToolBar),GTK_TOOLBAR_ICONS);
1619 buttonBrush = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1620 GTK_TOOLBAR_CHILD_RADIOBUTTON, NULL, NULL, _("Brush tool"),
1621 "", NewPixmap(Tool_brush_xpm, GUI_LogosWindow->window,
1622 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1623 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1625 buttonLine = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1626 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonBrush, NULL, _("Line tool"),
1627 "", NewPixmap(Tool_line_xpm, GUI_LogosWindow->window,
1628 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1629 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1631 buttonRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1632 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonLine, NULL, _("Rectangle tool"),
1633 "", NewPixmap(Tool_rectangle_xpm, GUI_LogosWindow->window,
1634 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1635 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1637 buttonFilledRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1638 GTK_TOOLBAR_CHILD_RADIOBUTTON, buttonRectangle, NULL,
1639 _("Filled rectangle tool"),
1640 "", NewPixmap(Tool_filled_rectangle_xpm,
1641 GUI_LogosWindow->window,
1642 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1643 GTK_SIGNAL_FUNC(ToolTypeEvent), NULL);
1645 gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
1647 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Invert logo"), NULL,
1648 NewPixmap(Edit_invert_xpm, GUI_LogosWindow->window,
1649 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1650 (GtkSignalFunc)InvertLogoEvent, vertToolBar);
1652 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Horizontal flip"), NULL,
1653 NewPixmap(Edit_flip_horizontal_xpm, GUI_LogosWindow->window,
1654 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1655 (GtkSignalFunc)FlipHorizontalLogoEvent, vertToolBar);
1657 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar), NULL, _("Vertical flip"), NULL,
1658 NewPixmap(Edit_flip_vertical_xpm, GUI_LogosWindow->window,
1659 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1660 (GtkSignalFunc)FlipVerticalLogoEvent, vertToolBar);
1663 gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
1664 gtk_widget_show(vertToolBar);
1666 GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
1669 void GUI_RefreshLogosGroupsCombo (void) {
1670 GList *callerList = NULL;
1673 for (i = 0;i < 6;i++)
1674 callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
1676 gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
1677 g_list_free(callerList);
1679 if (!callersGroupsInitialized) callersGroupsInitialized = 1;
1682 void GUI_ShowLogosWindow (void) {
1683 /* Set network name taken from the phone */
1684 GetNetworkInfoEvent(NULL);
1685 /* if phone support caller groups, read callerGroups names */
1686 if (phoneMonitor.supported & PM_CALLERGROUP) {
1687 if (xgnokiiConfig.callerGroups[0] == NULL) {
1689 GUI_InitCallerGroupsInf ();
1691 if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
1692 gtk_widget_show(buttonCaller);
1693 gtk_widget_show(callerCombo);
1695 /* if not supported, hide widget for handling callerGroups */
1696 gtk_widget_hide(buttonCaller);
1697 gtk_widget_hide(callerCombo);
1700 /* Call to reset Startup logo size */
1701 LogoTypeEvent(GUI_LogosWindow);
1703 gtk_widget_show(GUI_LogosWindow);
1705 if (!previewAvailable && showPreviewErrorDialog) {
1706 gchar *buf = g_strdup(_("Load preview pixmap error, feature disabled."));
1707 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1708 gtk_widget_show(errorDialog.dialog);
1711 showPreviewErrorDialog = 0;