10 #include "gsm-common.h"
12 #include "gsm-networks.h"
13 #include "files/gsm-filetypes.h"
14 #include "gsm-bitmaps.h"
16 #include "xgnokii_logos.h"
17 #include "xgnokii_common.h"
18 #include "xgnokii_lowlevel.h"
21 #include "xpm/Operator_logo.xpm"
22 #include "xpm/Startup_logo.xpm"
23 #include "xpm/Caller_logo.xpm"
25 #include "xpm/Black_point.xpm"
26 #include "xpm/Green_point.xpm"
27 #include "xpm/Green_pixel.xpm"
29 #include "xpm/New.xpm"
30 #include "xpm/Send.xpm"
31 #include "xpm/Read.xpm"
33 #include "xpm/Edit_invert.xpm"
34 #include "xpm/Edit_flip_horizontal.xpm"
35 #include "xpm/Edit_flip_vertical.xpm"
37 #include "xpm/Tool_brush.xpm"
38 #include "xpm/Tool_line.xpm"
39 #include "xpm/Tool_rectangle.xpm"
40 #include "xpm/Tool_filled_rectangle.xpm"
42 extern GSM_Network GSM_Networks[];
44 static GtkWidget *GUI_LogosWindow;
46 static ErrorDialog errorDialog = {NULL, NULL};
47 static InfoDialog infoDialog = {NULL, NULL};
49 /* stuff for drawingArea */
50 static GtkWidget *drawingArea = NULL;
51 static GdkPixmap *drawingPixmap = NULL;
52 static GdkPixmap *greenPointPixmap, *blackPointPixmap;
53 static int drawingAreaWidth, drawingAreaHeight; /* in pixels */
54 static int mouseButtonPushed = 0;
56 /* stuff for previewArea */
57 static GtkWidget *previewArea = NULL;
58 static GdkPixmap *previewPixmap = NULL;
59 static GdkPixmap *greenPixelPixmap;
60 static int previewPixmapWidth, previewPixmapHeight;
61 static int previewAvailable = 1, showPreviewErrorDialog = 1;
62 static int previewPixmapNumber = 0;
64 static GSM_Bitmap bitmap, oldBitmap;
65 static GSM_NetworkInfo networkInfo;
67 /* widgets for toolbar - some, need global variables */
68 static GtkWidget *buttonStartup, *buttonOperator, *buttonCaller, *buttonPicture;
69 static GtkWidget *networkCombo, *callerCombo;
71 static int activeTool = TOOL_BRUSH;
72 static int toolStartX, toolStartY, toolLastX, toolLastY;
74 /* tools for drawing */
75 static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
76 static GtkWidget *buttonFilledRectangle;
78 /* Contains fileName for Export dialog. */
83 static ExportDialogData exportDialogData = {NULL};
85 GtkWidget *FileSelection;
87 static int callersGroupsInitialized = 0;
89 /* returns lowest number from three numbers */
90 int GetMinFrom3(int a, int b, int c) {
104 /* returns highest number from three numbers */
105 int GetMaxFrom3(int a, int b, int c) {
119 /* load preview pixmap from file */
120 GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
125 if (previewPixmapNumber == 0)
127 if (!strcmp (xgnokiiConfig.model, "6110") ||
128 !strcmp (xgnokiiConfig.model, "6120"))
130 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
131 "/xpm/Preview_6110.xpm");
132 previewPixmapNumber = 1;
134 else if (!strcmp (xgnokiiConfig.model, "6130") ||
135 !strcmp (xgnokiiConfig.model, "6150") ||
136 !strcmp (xgnokiiConfig.model, "616x") ||
137 !strcmp (xgnokiiConfig.model, "6185") ||
138 !strcmp (xgnokiiConfig.model, "6190"))
140 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
141 "/xpm/Preview_6150.xpm");
142 previewPixmapNumber = 2;
144 else if (!strcmp (xgnokiiConfig.model, "3210"))
146 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
147 "/xpm/Preview_3210.xpm");
148 previewPixmapNumber = 3;
150 else if (!strcmp (xgnokiiConfig.model, "3310") ||
151 !strcmp (xgnokiiConfig.model, "3330"))
153 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
154 "/xpm/Preview_3310.xpm");
155 previewPixmapNumber = 4;
157 else if (!strcmp (xgnokiiConfig.model, "5110") ||
158 !strcmp (xgnokiiConfig.model, "5130"))
160 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
161 "/xpm/Preview_5110.xpm");
162 previewPixmapNumber = 5;
164 else if (!strcmp (xgnokiiConfig.model, "6250"))
166 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
167 "/xpm/Preview_6250.xpm");
168 previewPixmapNumber = 6;
170 else if (!strcmp (xgnokiiConfig.model, "7110"))
172 file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
173 "/xpm/Preview_7110.xpm");
174 previewPixmapNumber = 7;
178 file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
179 "/xpm/Preview_6210.xpm");
180 previewPixmapNumber = 8;
184 switch (previewPixmapNumber)
186 case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
187 "/xpm/Preview_6110.xpm");
189 case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
190 "/xpm/Preview_6150.xpm");
192 case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
193 "/xpm/Preview_3210.xpm");
195 case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
196 "/xpm/Preview_3310.xpm");
198 case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
199 "/xpm/Preview_5110.xpm");
201 case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
202 "/xpm/Preview_6250.xpm");
204 case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
205 "/xpm/Preview_7110.xpm");
207 default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
208 "/xpm/Preview_6210.xpm");
212 pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
213 &widget->style->bg[GTK_STATE_NORMAL],
220 /* ********************************************************
221 * ** SET/CLEAR POINTS ************************************
222 * ********************************************************
224 void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
225 if (!previewAvailable) return;
227 /* there is difference between positiong of startupLogo and others */
228 if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
229 bitmap.type != GSM_6210StartupLogo) {
234 /* draw point to pixmap */
236 gdk_draw_point(previewPixmap,widget->style->black_gc,
237 x+PREVIEWSTARTX,y+PREVIEWSTARTY);
240 GdkRectangle updateRect;
242 /* update point on screen */
243 updateRect.width = 1;
244 updateRect.height = 1;
245 updateRect.x = PREVIEWSTARTX+x;
246 updateRect.y = PREVIEWSTARTY+y;
248 gtk_widget_draw(previewArea,&updateRect);
252 void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
253 if (!previewAvailable) return;
255 /* there is difference between positiong of startupLogo and others */
256 if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
257 bitmap.type != GSM_6210StartupLogo) {
262 /* clean point from pixmap - any idea how to draw green point without pixmap? */
264 gdk_draw_pixmap(previewPixmap,
265 widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
266 greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
268 GdkRectangle updateRect;
270 /* clean from screen too */
271 updateRect.width = 1;
272 updateRect.height = 1;
273 updateRect.x = PREVIEWSTARTX+x;
274 updateRect.y = PREVIEWSTARTY+y;
276 gtk_widget_draw(previewArea,&updateRect);
280 int IsPoint(int x, int y) {
281 return GSM_IsPointBitmap(&bitmap,x,y);
284 void SetPoint(GtkWidget *widget, int x, int y, int update) {
286 GSM_SetPointBitmap(&bitmap,x,y);
288 /* draw point to pixmap */
289 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
290 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
293 GdkRectangle updateRect;
295 /* calculate update rectangle */
296 updateRect.width = POINTSIZE+2;
297 updateRect.height = POINTSIZE+2;
298 updateRect.x = x * (POINTSIZE+1);
299 updateRect.y = y * (POINTSIZE+1);
301 /* update on screen */
302 gtk_widget_draw(drawingArea,&updateRect);
305 /* draw preview point too */
306 if (previewAvailable) SetPreviewPoint(widget,x,y,update);
309 void ClearPoint(GtkWidget *widget, int x, int y, int update) {
311 GSM_ClearPointBitmap(&bitmap,x,y);
313 /* clear point from pixmap */
314 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
315 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
318 GdkRectangle updateRect;
320 /* calculate update rectangle */
321 updateRect.width = POINTSIZE+2;
322 updateRect.height = POINTSIZE+2;
323 updateRect.x = x * (POINTSIZE+1);
324 updateRect.y = y * (POINTSIZE+1);
326 /* update on screen */
327 gtk_widget_draw(drawingArea,&updateRect);
330 /* clear point from previewArea too */
331 if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
334 /* ****************************************************
335 * *** UPDATES - PREVIEW & DRAWING AREAS **************
336 * ****************************************************
339 /* this redraw all logo points - preview & drawing area */
340 void UpdatePointsRectangle(GtkWidget *widget, int x1, int y1, int x2, int y2) {
341 GdkRectangle updateRect;
342 int x, y, dx = 0, dy = 0;
344 if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
345 bitmap.type != GSM_6210StartupLogo) {
362 for (y = y1;y <= y2;y++)
363 for (x = x1;x <= x2;x++) {
365 /* set on drawing area */
366 gdk_draw_pixmap(drawingPixmap,
367 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
368 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
371 if (previewAvailable && previewPixmap)
372 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
373 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
375 /* clear from drawing */
376 gdk_draw_pixmap(drawingPixmap,
377 drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
378 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
380 /* clear from preview */
381 if (previewAvailable && previewPixmap)
382 gdk_draw_pixmap(previewPixmap,
383 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
384 greenPixelPixmap,0,0,x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,
389 if (previewAvailable) {
390 updateRect.x = PREVIEWSTARTX+dx+x1;
391 updateRect.y = PREVIEWSTARTY+dy+y1;
392 updateRect.width = x2-x1+1;
393 updateRect.height = y2-y1+1;
394 gtk_widget_draw(previewArea,&updateRect);
397 updateRect.x = x1*(POINTSIZE+1);
398 updateRect.y = y1*(POINTSIZE+1);
399 updateRect.width = (x2-x1+1)*(POINTSIZE+1)+1;
400 updateRect.height = (y2-y1+1)*(POINTSIZE+1)+1;
401 gtk_widget_draw(drawingArea,&updateRect);
404 void UpdatePoints(GtkWidget *widget) {
405 UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
408 /* this redraw all logo points in previewArea, NO DRAWING AREA */
409 void UpdatePreviewPoints (void) {
410 GdkRectangle updateRect;
411 int x, y, dx = 0, dy = 0;
413 if (!previewPixmap || !previewAvailable) return;
415 if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
416 bitmap.type != GSM_6210StartupLogo) {
421 for (y = 0;y < bitmap.height;y++)
422 for (x = 0;x < bitmap.width;x++) {
424 gdk_draw_point(previewPixmap,previewArea->style->black_gc,
425 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
427 gdk_draw_pixmap(previewPixmap,
428 previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
429 greenPixelPixmap,0,0,
430 x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,1,1);
436 updateRect.width = bitmap.width;
437 updateRect.height = bitmap.height;
438 gtk_widget_draw(previewArea,&updateRect);
441 /* ******************************************************
442 * **** DRAWING TOOLS ***********************************
443 * ******************************************************
447 void ToolBrush(GtkWidget *widget, int column, int row, int button) {
448 /* only this tool directly update bitmap & screen */
450 ClearPoint(widget,column,row,1);
452 SetPoint(widget,column,row,1);
456 /* going to rewrite to Bresenham algorithm */
457 static void ToolLineUpdate(GtkWidget *widget, int column, int row) {
459 int i, x1, y1, x2, y2;
461 if (abs(toolStartX-toolLastX) >= abs(toolStartY-toolLastY)) {
462 if (toolStartX > toolLastX) {
474 delta = ((double)(y2-y1))/((double)(x2-x1));
476 for (i = x1;i <= x2;i++) {
477 if (!GSM_IsPointBitmap(&oldBitmap,i,(int)y)) ClearPoint(widget,i,(int)y,0);
481 if (toolStartY > toolLastY) {
492 delta = ((double)(x2-x1))/((double)(y2-y1));
495 for (i = y1;i <= y2;i++) {
496 if (!GSM_IsPointBitmap(&oldBitmap,(int)x,i)) ClearPoint(widget,(int)x,i,0);
501 if (abs(toolStartX-column) >= abs(toolStartY-row)) {
502 if (toolStartX > column) {
514 delta = ((double)(y2-y1))/((double)(x2-x1));
516 for (i = x1;i <= x2;i++) {
517 SetPoint(widget,i,(int)y,0);
521 if (toolStartY > row) {
533 delta = ((double)(x2-x1))/((double)(y2-y1));
536 for (i = y1;i <= y2;i++) {
537 SetPoint(widget,(int)x,i,0);
543 /* TOOL - FILLED RECT */
544 static void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
545 int i, j, x1, y1, x2, y2;
547 if (toolStartX > toolLastX) {
555 if (toolStartY > toolLastY) {
563 for (j = y1;j <= y2;j++)
564 for (i = x1;i <= x2;i++)
565 if (!GSM_IsPointBitmap(&oldBitmap,i,j)) ClearPoint(widget,i,j,0);
567 if (toolStartX > column) {
575 if (toolStartY > row) {
583 for (j = y1;j <= y2;j++)
584 for (i = x1;i <= x2;i++)
585 SetPoint(widget,i,j,0);
588 /* TOOL - RECTANGLE */
589 static void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
590 int i, j, x1, y1, x2, y2;
592 /* clear old rectangle */
593 if (toolStartX > toolLastX) {
601 if (toolStartY > toolLastY) {
609 for (i = x1;i <= x2;i++) {
610 if (!GSM_IsPointBitmap(&oldBitmap,i,y1)) ClearPoint(widget,i,y1,0);
611 if (!GSM_IsPointBitmap(&oldBitmap,i,y2)) ClearPoint(widget,i,y2,0);
614 for (j = y1;j <= y2;j++) {
615 if (!GSM_IsPointBitmap(&oldBitmap,x1,j)) ClearPoint(widget,x1,j,0);
616 if (!GSM_IsPointBitmap(&oldBitmap,x2,j)) ClearPoint(widget,x2,j,0);
619 /* draw new rectangle */
620 if (toolStartX > column) {
628 if (toolStartY > row) {
636 for (i = x1;i <= x2;i++) {
637 if (!IsPoint(i,y1)) SetPoint(widget,i,y1,0);
638 if (!IsPoint(i,y2)) SetPoint(widget,i,y2,0);
641 for (j = y1;j <= y2;j++) {
642 if (!IsPoint(x1,j)) SetPoint(widget,x1,j,0);
643 if (!IsPoint(x2,j)) SetPoint(widget,x2,j,0);
647 static void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
648 GdkRectangle updateRect;
650 /* update preview area */
651 updateRect.x = PREVIEWSTARTX+x1;
652 updateRect.y = PREVIEWSTARTY+y1;
653 if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
654 bitmap.type != GSM_6210StartupLogo) {
655 updateRect.x += PREVIEWJUMPX;
656 updateRect.y += PREVIEWJUMPY;
658 updateRect.width = x2-x1+1;
659 updateRect.height = y2-y1+1;
660 gtk_widget_draw(previewArea,&updateRect);
662 /* update drawing area */
663 updateRect.x = x1 * (POINTSIZE+1);
664 updateRect.y = y1 * (POINTSIZE+1);
665 updateRect.width = (x2-x1+1)*(POINTSIZE+2);
666 updateRect.height = (y2-y1+1)*(POINTSIZE+2);
667 gtk_widget_draw(drawingArea,&updateRect);
670 /* *************************************
671 * ** PREVIEW AREA EVENTS **************
672 * *************************************
675 static gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
676 previewPixmapNumber = (previewPixmapNumber % 8) + 1;
678 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
679 previewPixmapWidth,previewPixmapHeight);
684 static gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
685 if (previewPixmap) gdk_pixmap_unref(previewPixmap);
686 previewPixmap = GetPreviewPixmap(widget);
688 UpdatePreviewPoints();
693 static gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
694 /* got previewPixmap? */
696 /* yes - simply redraw some rectangle */
697 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
698 previewPixmap,event->area.x,event->area.y,event->area.x,
699 event->area.y,event->area.width,event->area.height);
704 /* ********************************
705 * ** DRAWING AREA EVENTS *********
706 * ********************************
709 static gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
710 /* got drawingPixmap? */
711 if (drawingPixmap == NULL) return TRUE;
713 if (!mouseButtonPushed) {
714 if ((event->button == 1 && activeTool != TOOL_BRUSH) ||
715 (activeTool == TOOL_BRUSH)) {
716 /* position from we starting drawing */
717 toolStartX = event->x / (POINTSIZE+1);
718 if (toolStartX < 0) toolStartX = 0;
719 if (toolStartX > bitmap.width-1) toolStartX = bitmap.width-1;
721 toolStartY = event->y / (POINTSIZE+1);
722 if (toolStartY < 0) toolStartY = 0;
723 if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
725 toolLastX = toolStartX;
726 toolLastY = toolStartY;
728 /* store old bitmap for drawing, resp. for moving, resizing primitive */
729 memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
732 if (event->button == 1) mouseButtonPushed = 1;
734 switch (activeTool) {
736 ToolBrush(widget,toolStartX,toolStartY,event->button);
740 if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
745 /* user is drawing some tool other than TOOL_BRUSH and pushed mouse button
746 * another than first => cancel tool and redraw to oldBitmap (bitmap when
747 * user start drawing)
749 if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
750 int lowestX, lowestY, highestX, highestY;
753 lowestX = GetMinFrom3(toolStartX,toolLastX,toolLastX);
754 lowestY = GetMinFrom3(toolStartY,toolLastY,toolLastY);
755 highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
756 highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
758 for (j = lowestY;j <= highestY;j++)
759 for (i = lowestX;i <= highestX;i++)
760 if (GSM_IsPointBitmap(&oldBitmap,i,j))
761 SetPoint(widget,i,j,0);
763 ClearPoint(widget,i,j,0);
764 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
766 mouseButtonPushed = 0;
772 static gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
773 if (event->button == 1)
774 mouseButtonPushed = 0;
779 static gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
781 GdkModifierType state;
783 if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
786 gdk_window_get_pointer(event->window,&x,&y,&state);
790 state = event->state;
793 x = x / (POINTSIZE+1);
794 y = y / (POINTSIZE+1);
797 if (x > bitmap.width-1) x = bitmap.width-1;
798 if (y > bitmap.height-1) y = bitmap.height-1;
800 if (y == toolLastY && x == toolLastX) return TRUE;
802 switch (activeTool) {
804 if (state & GDK_BUTTON1_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,1);
805 if (state & GDK_BUTTON2_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,2);
806 if (state & GDK_BUTTON3_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,3);
809 if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
811 case TOOL_FILLED_RECTANGLE:
812 if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
815 if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
820 * it's simple, above tools updates only bitmap in memory and this
821 * function update from bitmap to screen, it's made as non-blinking
822 * drawing functions with this, simply draw everything we need and
823 * after that, redraw to screen rectangle in which we made changes
824 * it's not redrawing pixel by pixel (blinking)
826 if (activeTool != TOOL_BRUSH) {
827 int lowestX, lowestY, highestX, highestY;
829 lowestX = GetMinFrom3(toolStartX,toolLastX,x);
830 lowestY = GetMinFrom3(toolStartY,toolLastY,y);
831 highestX = GetMaxFrom3(toolStartX,toolLastX,x);
832 highestY = GetMaxFrom3(toolStartY,toolLastY,y);
834 UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
842 /* configureEvent? -> event when someone resize windows, ... */
843 static gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
845 /* got drawingPixmap? */
846 if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
848 /* make a new pixmap */
849 drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
850 drawingAreaHeight,-1);
852 /* draw grid into pixmap */
853 for (y = 0;y < bitmap.height;y++)
854 for (x = 0;x < bitmap.width;x++)
856 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
857 blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
859 gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
860 greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
865 static gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
866 /* got drawingPixmap? */
869 gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
871 event->area.x,event->area.y,event->area.x,event->area.y,
872 event->area.width,event->area.height);
876 /* *****************************************
877 * ** TOOLBAR & MENU EVENTS ****************
878 * *****************************************
881 static void GetNetworkInfoEvent(GtkWidget *widget) {
883 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
884 D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
886 /* prepare data for event */
887 data->info = &networkInfo;
888 e->event = Event_GetNetworkInfo;
891 /* launch event and wait for result */
893 pthread_mutex_lock(&getNetworkInfoMutex);
894 pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
895 pthread_mutex_unlock(&getNetworkInfoMutex);
896 error = data->status;
899 /* watch for errors */
900 if (error != GE_NONE) {
901 gchar *buf = g_strdup_printf(_("Error getting network info\n(error=%d)"),error);
902 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
903 gtk_widget_show(errorDialog.dialog);
907 /* set new operator name to combo */
908 gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
909 GSM_GetNetworkName(networkInfo.NetworkCode));
912 static void GetLogoEvent(GtkWidget *widget) {
915 PhoneEvent *e = (PhoneEvent *) g_malloc(sizeof(PhoneEvent));
916 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
917 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
919 /* prepare data for event */
920 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
921 data->bitmap = &bitmap;
922 e->event = Event_GetBitmap;
924 if (GetModelFeature(FN_CALLERGROUPS)!=0) {
925 for (i = 0;i < 6;i++)
926 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
927 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
930 /* launch event and wait for result */
932 pthread_mutex_lock(&getBitmapMutex);
933 pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
934 pthread_mutex_unlock(&getBitmapMutex);
935 error = data->status;
938 /* watch for errors */
939 if (error != GE_NONE) {
940 gchar *buf = g_strdup_printf(_("Error getting bitmap\n(error=%d)"),error);
941 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
942 gtk_widget_show(errorDialog.dialog);
945 /* no error, draw logo from phone */
946 UpdatePoints(drawingArea);
950 static void SetLogoEvent(GtkWidget *widget) {
952 PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
953 D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
954 char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
958 strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
960 if (bitmap.type == GSM_CallerLogo) {
961 /* above condition must be there, because if you launch logos before
962 * callerGroups are available, you will see segfault - callerGroups not initialized
964 if (GetModelFeature(FN_CALLERGROUPS)!=0) {
965 for (i = 0;i < 6;i++)
966 if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
967 xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
970 if (bitmap.type == GSM_StartupLogo) {
974 data->bitmap = &bitmap;
975 e->event = Event_SetBitmap;
978 /* launch event and wait for result */
980 pthread_mutex_lock(&setBitmapMutex);
981 pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
982 pthread_mutex_unlock(&setBitmapMutex);
983 error = data->status;
986 /* watch for errors */
987 if (error != GE_NONE) {
988 gchar *buf = g_strdup_printf(_("Error setting bitmap\n(error=%d)"),error);
989 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
990 gtk_widget_show(errorDialog.dialog);
995 static void ClearLogoEvent(GtkWidget *widget) {
997 bitmap.size=bitmap.width*bitmap.height/8;
999 GSM_ClearBitmap(&bitmap);
1001 UpdatePoints(widget);
1004 static void InvertLogoEvent(GtkWidget *widget) {
1007 for (column = 0;column < bitmap.width;column++)
1008 for (row = 0;row < bitmap.height;row++)
1009 if (IsPoint(column,row))
1010 GSM_ClearPointBitmap(&bitmap,column,row);
1012 GSM_SetPointBitmap(&bitmap,column,row);
1014 UpdatePoints(widget);
1017 static void UpLogoEvent(GtkWidget *widget) {
1024 for (row = 0;row < bitmap.height-1;row++)
1025 for (column = 0;column < bitmap.width;column++)
1026 if (IsPoint(column,row+1))
1027 GSM_SetPointBitmap(&bitmap,column,row);
1029 GSM_ClearPointBitmap(&bitmap,column,row);
1031 for (column = 0;column < bitmap.width;column++)
1032 if (GSM_IsPointBitmap(&tbitmap,column,0))
1033 GSM_SetPointBitmap(&bitmap,column,row);
1035 GSM_ClearPointBitmap(&bitmap,column,row);
1037 UpdatePoints(widget);
1040 static void DownLogoEvent(GtkWidget *widget) {
1047 for (row = bitmap.height-1;row > 0;row--)
1048 for (column = 0;column < bitmap.width;column++)
1049 if (IsPoint(column,row-1))
1050 GSM_SetPointBitmap(&bitmap,column,row);
1052 GSM_ClearPointBitmap(&bitmap,column,row);
1054 for (column = 0;column < bitmap.width;column++)
1055 if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
1056 GSM_SetPointBitmap(&bitmap,column,0);
1058 GSM_ClearPointBitmap(&bitmap,column,0);
1060 UpdatePoints(widget);
1063 static void LeftLogoEvent(GtkWidget *widget) {
1070 for (column = 0; column < bitmap.width-1;column++)
1071 for (row = 0;row < bitmap.height;row++)
1072 if (IsPoint(column+1,row))
1073 GSM_SetPointBitmap(&bitmap,column,row);
1075 GSM_ClearPointBitmap(&bitmap,column,row);
1077 for (row = 0;row < bitmap.height;row++)
1078 if (GSM_IsPointBitmap(&tbitmap,0,row))
1079 GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
1081 GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
1083 UpdatePoints(widget);
1086 static void RightLogoEvent(GtkWidget *widget) {
1093 for (column = bitmap.width-1;column > 0;column--)
1094 for (row = 0;row < bitmap.height;row++)
1095 if (IsPoint(column-1,row))
1096 GSM_SetPointBitmap(&bitmap,column,row);
1098 GSM_ClearPointBitmap(&bitmap,column,row);
1100 for (row = 0;row < bitmap.height;row++)
1101 if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
1102 GSM_SetPointBitmap(&bitmap,0,row);
1104 GSM_ClearPointBitmap(&bitmap,0,row);
1106 UpdatePoints(widget);
1109 static void FlipVerticalLogoEvent(GtkWidget *widget) {
1110 int row, column, temp;
1112 for (row = 0;row < (bitmap.height/2);row++)
1113 for (column = 0;column < bitmap.width;column++) {
1114 temp = IsPoint(column,row);
1115 if (IsPoint(column,bitmap.height-1-row))
1116 GSM_SetPointBitmap(&bitmap,column,row);
1118 GSM_ClearPointBitmap(&bitmap,column,row);
1121 GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
1123 GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
1126 UpdatePoints(widget);
1129 static void FlipHorizontalLogoEvent(GtkWidget *widget) {
1130 int row, column, temp;
1132 for (row = 0;row < bitmap.height;row++)
1133 for (column = 0;column < (bitmap.width/2);column++) {
1134 temp = IsPoint(column,row);
1136 if (IsPoint(bitmap.width-1-column,row))
1137 GSM_SetPointBitmap(&bitmap,column,row);
1139 GSM_ClearPointBitmap(&bitmap,column,row);
1142 GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
1144 GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
1147 UpdatePoints(widget);
1150 /* this is launched when tool was changed */
1151 static gint ToolTypeEvent(GtkWidget *widget) {
1152 if (GTK_TOGGLE_BUTTON(buttonBrush)->active) activeTool = TOOL_BRUSH; else
1153 if (GTK_TOGGLE_BUTTON(buttonLine)->active) activeTool = TOOL_LINE; else
1154 if (GTK_TOGGLE_BUTTON(buttonRectangle)->active) activeTool = TOOL_RECTANGLE; else
1155 if (GTK_TOGGLE_BUTTON(buttonFilledRectangle)->active)
1156 activeTool = TOOL_FILLED_RECTANGLE;
1161 /* this is launched when logo type was change by buttons on toolbar */
1162 static gint LogoTypeEvent(GtkWidget *widget) {
1165 /* is startupLogo? */
1166 if (GTK_TOGGLE_BUTTON(buttonStartup)->active &&
1167 bitmap.type != GSM_StartupLogo && bitmap.type != GSM_6210StartupLogo &&
1168 bitmap.type != GSM_7110StartupLogo) {
1169 /* look for old bitmap type, clean if another */
1172 if (!strcmp(xgnokiiConfig.model,"7110")) {
1173 GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
1174 } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) {
1175 GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
1177 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
1181 /* new type is PictureImage */
1182 if (GTK_TOGGLE_BUTTON(buttonPicture)->active && bitmap.type != GSM_PictureImage) {
1183 /* look for old bitmap type, clean if another */
1185 GSM_ResizeBitmap(&bitmap,GSM_PictureImage);
1188 /* new type is callerLogo */
1189 if (GTK_TOGGLE_BUTTON(buttonCaller)->active && bitmap.type != GSM_CallerLogo) {
1190 /* previous was startup or Picture ? clear and draw batteries, signal, ... */
1191 if (bitmap.type != GSM_OperatorLogo) clear = 1;
1192 GSM_ResizeBitmap(&bitmap,GSM_CallerLogo);
1195 /* is new type operatorLogo? */
1196 if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo &&
1197 bitmap.type != GSM_7110OperatorLogo) {
1199 /* previous startup or Picture ? clear and draw batteries, signal, ... */
1200 if (bitmap.type != GSM_CallerLogo) clear = 1;
1202 if (!strcmp(xgnokiiConfig.model,"7110")) {
1203 GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1204 } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) {
1205 GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1207 GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo);
1213 if (previewAvailable) {
1214 /* configure event reload pixmap from disk and redraws */
1215 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1216 previewPixmapWidth,previewPixmapHeight);
1219 /* change new drawingArea size */
1220 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1221 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1223 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1224 drawingAreaWidth,drawingAreaHeight);
1230 static inline void CloseLogosWindow (void) {
1231 gtk_widget_hide(GUI_LogosWindow);
1234 void ExportLogoFileMain(gchar *name)
1241 strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
1243 error=GSM_SaveBitmapFile(name,&tbitmap);
1244 if (error!=GE_NONE) {
1245 gchar *buf = g_strdup_printf(_("Error saving file\n(error=%d)"),error);
1246 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1247 gtk_widget_show(errorDialog.dialog);
1252 static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
1254 gtk_widget_hide (GTK_WIDGET (data));
1255 ExportLogoFileMain(exportDialogData.fileName);
1258 static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
1260 static YesNoDialog dialog = { NULL, NULL};
1264 exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1265 gtk_widget_hide (GTK_WIDGET (fs));
1267 if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
1270 if (dialog.dialog == NULL)
1272 CreateYesNoDialog (&dialog, YesLogoFileExportDialog, CancelDialog, GUI_LogosWindow);
1273 gtk_window_set_title (GTK_WINDOW (dialog.dialog), _("Overwrite file?"));
1274 g_snprintf ( err, 80, _("File %s already exist.\nOverwrite?"), exportDialogData.fileName);
1275 gtk_label_set_text (GTK_LABEL(dialog.text), err);
1277 gtk_widget_show (dialog.dialog);
1280 ExportLogoFileMain(exportDialogData.fileName);
1283 void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
1291 fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1292 gtk_widget_hide (GTK_WIDGET (fs));
1294 if ((f = fopen (fileName, "r")) == NULL) {
1295 gchar *buf = g_strdup_printf(_("Can't open file %s for reading !"),fileName);
1296 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1297 gtk_widget_show(errorDialog.dialog);
1302 error=GSM_ReadBitmapFile(fileName,&tbitmap);
1303 if (error!=GE_NONE) {
1304 gchar *buf = g_strdup_printf(_("Error reading file\n(error=%d)"),error);
1305 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1306 gtk_widget_show(errorDialog.dialog);
1311 exportDialogData.fileName=fileName;
1313 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),false);
1314 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),false);
1315 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),false);
1316 gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonPicture),false);
1318 if (tbitmap.type==GSM_OperatorLogo || tbitmap.type==GSM_7110OperatorLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),true);
1319 if (tbitmap.type==GSM_StartupLogo || tbitmap.type==GSM_7110StartupLogo || tbitmap.type==GSM_6210StartupLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),true);
1320 if (tbitmap.type==GSM_CallerLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),true);
1321 if (tbitmap.type==GSM_PictureImage) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonPicture),true);
1323 memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
1325 if (!strcmp(xgnokiiConfig.model,"7110")) { //7110
1326 if (bitmap.type==GSM_StartupLogo || bitmap.type==GSM_6210StartupLogo)
1327 GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
1329 if (bitmap.type==GSM_OperatorLogo)
1330 GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1332 } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) { //6210,6250
1333 if (bitmap.type==GSM_StartupLogo || bitmap.type==GSM_7110StartupLogo)
1334 GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
1336 if (bitmap.type==GSM_OperatorLogo)
1337 GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1340 if (bitmap.type==GSM_6210StartupLogo || bitmap.type==GSM_7110StartupLogo)
1341 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
1342 if (bitmap.type==GSM_7110OperatorLogo)
1343 GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo);
1346 UpdatePoints(drawingArea);
1349 void SaveLogoAs(GtkWidget *widget)
1351 FileSelection=gtk_file_selection_new ("Save logo as ...");
1353 gtk_signal_connect (
1354 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1355 "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
1357 gtk_signal_connect_object (
1358 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1359 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1360 GTK_OBJECT (FileSelection));
1362 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1364 gtk_widget_show(FileSelection);
1367 void SaveLogo(GtkWidget *widget)
1369 if (exportDialogData.fileName==NULL) {
1372 ExportLogoFileMain(exportDialogData.fileName);
1376 void OpenLogo(GtkWidget *widget)
1378 FileSelection=gtk_file_selection_new ("Open logo...");
1380 gtk_signal_connect (
1381 GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1382 "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
1384 gtk_signal_connect_object (
1385 GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1386 "clicked", (GtkSignalFunc) gtk_widget_destroy,
1387 GTK_OBJECT (FileSelection));
1389 gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1391 gtk_widget_show(FileSelection);
1394 static GtkItemFactoryEntry logosMenuItems[] = {
1395 { NULL, NULL, NULL, 0, "<Branch>"},
1396 { NULL, "<control>O", OpenLogo, 0, NULL},
1397 { NULL, "<control>S", SaveLogo, 0, NULL},
1398 { NULL, NULL, SaveLogoAs, 0, NULL},
1399 { NULL, NULL, NULL, 0, "<Separator>"},
1400 { NULL, "<control>G", GetNetworkInfoEvent, 0, NULL},
1401 { NULL, NULL, GetLogoEvent, 0, NULL},
1402 { NULL, "<control>T", SetLogoEvent, 0, NULL},
1403 { NULL, NULL, NULL, 0, "<Separator>"},
1404 { NULL, "<control>W", CloseLogosWindow, 0, NULL},
1405 { NULL, NULL, NULL, 0, "<Branch>"},
1406 { NULL, "<control>C", ClearLogoEvent, 0, NULL},
1407 { NULL, "<control>I", InvertLogoEvent, 0, NULL},
1408 { NULL, NULL, NULL, 0, "<Separator>"},
1409 { NULL, "<control>U", UpLogoEvent, 0, NULL},
1410 { NULL, "<control>D", DownLogoEvent, 0, NULL},
1411 { NULL, "<control>L", LeftLogoEvent, 0, NULL},
1412 { NULL, "<control>R", RightLogoEvent, 0, NULL},
1413 { NULL, NULL, NULL, 0, "<Separator>"},
1414 { NULL, "<control>H", FlipHorizontalLogoEvent, 0, NULL},
1415 { NULL, "<control>V", FlipVerticalLogoEvent, 0, NULL},
1418 static void InitLogosMenu (void) {
1419 logosMenuItems[0].path = g_strdup(_("/_File"));
1420 logosMenuItems[1].path = g_strdup(_("/File/_Open"));
1421 logosMenuItems[2].path = g_strdup(_("/File/_Save"));
1422 logosMenuItems[3].path = g_strdup(_("/File/Save _as ..."));
1423 logosMenuItems[4].path = g_strdup(_("/File/Sep1"));
1424 logosMenuItems[5].path = g_strdup(_("/File/_Get operator"));
1425 logosMenuItems[6].path = g_strdup(_("/File/Get _logo"));
1426 logosMenuItems[7].path = g_strdup(_("/File/Se_t logo"));
1427 logosMenuItems[8].path = g_strdup(_("/File/Sep2"));
1428 logosMenuItems[9].path = g_strdup(_("/File/_Close"));
1429 logosMenuItems[10].path = g_strdup(_("/_Edit"));
1430 logosMenuItems[11].path = g_strdup(_("/Edit/_Clear"));
1431 logosMenuItems[12].path = g_strdup(_("/Edit/_Invert"));
1432 logosMenuItems[13].path = g_strdup(_("/Edit/Sep3"));
1433 logosMenuItems[14].path = g_strdup(_("/Edit/_Up logo"));
1434 logosMenuItems[15].path = g_strdup(_("/Edit/_Down logo"));
1435 logosMenuItems[16].path = g_strdup(_("/Edit/_Left logo"));
1436 logosMenuItems[17].path = g_strdup(_("/Edit/_Right logo"));
1437 logosMenuItems[18].path = g_strdup(_("/Edit/Sep4"));
1438 logosMenuItems[19].path = g_strdup(_("/Edit/Flip _horizontal"));
1439 logosMenuItems[20].path = g_strdup(_("/Edit/Flip _vertical"));
1442 void GUI_CreateLogosWindow (void) {
1443 int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
1444 GtkAccelGroup *accelGroup;
1445 GtkItemFactory *itemFactory;
1447 GtkWidget *toolBar, *vertToolBar;
1450 GtkWidget *drawingBox;
1451 GtkWidget *separator;
1454 GList *glistNetwork = NULL;
1458 previewPixmapWidth = PREVIEWWIDTH;
1459 previewPixmapHeight = PREVIEWHEIGHT;
1463 /* realize top level window for logos */
1464 GUI_LogosWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
1465 gtk_window_set_policy(GTK_WINDOW(GUI_LogosWindow),1,1,1);
1466 gtk_window_set_title(GTK_WINDOW(GUI_LogosWindow),_("Logos"));
1467 gtk_signal_connect(GTK_OBJECT(GUI_LogosWindow),"delete_event",
1468 GTK_SIGNAL_FUNC(DeleteEvent),NULL);
1469 gtk_widget_realize(GUI_LogosWindow);
1471 CreateErrorDialog(&errorDialog,GUI_LogosWindow);
1472 CreateInfoDialog(&infoDialog,GUI_LogosWindow);
1474 accelGroup = gtk_accel_group_new();
1475 gtk_accel_group_attach(accelGroup,GTK_OBJECT(GUI_LogosWindow));
1477 /* create main vbox */
1478 vbox = gtk_vbox_new(FALSE,1);
1479 gtk_container_add(GTK_CONTAINER(GUI_LogosWindow),vbox);
1480 gtk_widget_show(vbox);
1482 itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR,"<main>",accelGroup);
1483 gtk_item_factory_create_items(itemFactory,nMenuItems,logosMenuItems,NULL);
1484 menuBar = gtk_item_factory_get_widget(itemFactory,"<main>");
1486 gtk_box_pack_start(GTK_BOX(vbox),menuBar,FALSE,FALSE,0);
1487 gtk_widget_show(menuBar);
1490 toolBar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,GTK_TOOLBAR_ICONS);
1491 gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolBar),GTK_RELIEF_NORMAL);
1492 gtk_toolbar_set_style(GTK_TOOLBAR(toolBar),GTK_TOOLBAR_ICONS);
1494 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Clear logo",NULL,
1495 NewPixmap(New_xpm,GUI_LogosWindow->window,
1496 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1497 (GtkSignalFunc)ClearLogoEvent,toolBar);
1499 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1501 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Get logo",NULL,
1502 NewPixmap(Read_xpm,GUI_LogosWindow->window,
1503 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1504 (GtkSignalFunc)GetLogoEvent,toolBar);
1506 gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Set logo",NULL,
1507 NewPixmap(Send_xpm,GUI_LogosWindow->window,
1508 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1509 (GtkSignalFunc)SetLogoEvent,toolBar);
1511 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1513 buttonStartup = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1514 GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,NULL,"Startup logo",
1515 "",NewPixmap(Startup_logo_xpm,GUI_LogosWindow->window,
1516 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1517 GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
1519 buttonOperator = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1520 GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonStartup,NULL,"Operator logo",
1521 "",NewPixmap(Operator_logo_xpm,GUI_LogosWindow->window,
1522 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1523 GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
1525 buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1526 GTK_TOOLBAR_CHILD_RADIOBUTTON,
1529 "",NewPixmap(Caller_logo_xpm,GUI_LogosWindow->window,
1530 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1531 GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
1533 buttonPicture = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1534 GTK_TOOLBAR_CHILD_RADIOBUTTON,
1536 NULL,"Picture image",
1537 "",NewPixmap(Caller_logo_xpm,GUI_LogosWindow->window,
1538 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1539 GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
1541 gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1543 networkCombo = gtk_combo_new();
1544 gtk_combo_set_use_arrows_always(GTK_COMBO(networkCombo),1);
1545 while (strcmp(GSM_Networks[i].Name,"unknown"))
1546 glistNetwork = g_list_insert_sorted(glistNetwork,GSM_Networks[i++].Name,
1547 (GCompareFunc)strcmp);
1548 gtk_combo_set_popdown_strings(GTK_COMBO(networkCombo),glistNetwork);
1549 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),FALSE);
1550 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar),networkCombo,"","");
1551 gtk_widget_show(networkCombo);
1552 g_list_free(glistNetwork);
1554 callerCombo = gtk_combo_new();
1555 gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(callerCombo)->entry),FALSE);
1556 gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar),callerCombo,"","");
1557 gtk_widget_show(callerCombo);
1559 gtk_box_pack_start(GTK_BOX(vbox),toolBar,FALSE,FALSE,0);
1560 gtk_widget_show(toolBar);
1562 /* vertical separator */
1563 separator = gtk_hseparator_new();
1564 gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
1566 /* create horizontal box for preview and drawing areas */
1567 hbox = gtk_hbox_new(FALSE,5);
1568 gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
1569 gtk_widget_show(hbox);
1571 /* set GSM_Bitmap width,height needed for creating drawinArea
1572 * we are starting, default is startupLogo
1574 bitmap.type = GSM_7110StartupLogo;
1577 bitmap.size = bitmap.height * bitmap.width / 8;
1578 if (!strcmp(xgnokiiConfig.model,"7110")) { //7110
1579 GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
1580 } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) { //6210,6250
1581 GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
1583 GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
1585 drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1586 drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1589 previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
1591 if (previewPixmap != NULL) {
1592 previewArea = gtk_drawing_area_new();
1593 gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1594 previewPixmapWidth,previewPixmapHeight);
1596 greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1597 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
1600 gtk_signal_connect(GTK_OBJECT(previewArea),"expose_event",
1601 (GtkSignalFunc)PreviewAreaExposeEvent,NULL);
1602 gtk_signal_connect(GTK_OBJECT(previewArea),"configure_event",
1603 (GtkSignalFunc)PreviewAreaConfigureEvent,NULL);
1604 gtk_signal_connect(GTK_OBJECT(previewArea),"button_press_event",
1605 (GtkSignalFunc)PreviewAreaButtonPressEvent,NULL);
1607 gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
1609 gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
1610 gtk_widget_show(previewArea);
1612 /* clear battery, signal, menu & names from preview phone */
1613 UpdatePreviewPoints ();
1615 } else previewAvailable = 0;
1618 greenPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1619 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Green_point_xpm);
1620 blackPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1621 &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Black_point_xpm);
1623 drawingBox = gtk_vbox_new(FALSE,3);
1624 gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
1625 gtk_widget_show(drawingBox);
1627 drawingArea = gtk_drawing_area_new();
1628 gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1629 drawingAreaWidth,drawingAreaHeight);
1631 gtk_signal_connect(GTK_OBJECT(drawingArea),"configure_event",
1632 (GtkSignalFunc)DrawingAreaConfigureEvent,NULL);
1633 gtk_signal_connect(GTK_OBJECT(drawingArea),"expose_event",
1634 (GtkSignalFunc)DrawingAreaExposeEvent,NULL);
1635 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_press_event",
1636 (GtkSignalFunc)DrawingAreaButtonPressEvent,NULL);
1637 gtk_signal_connect(GTK_OBJECT(drawingArea),"button_release_event",
1638 (GtkSignalFunc)DrawingAreaButtonReleaseEvent,NULL);
1639 gtk_signal_connect(GTK_OBJECT(drawingArea),"motion_notify_event",
1640 (GtkSignalFunc)DrawingAreaMotionNotifyEvent,NULL);
1642 gtk_widget_set_events(drawingArea,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
1643 GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
1644 GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
1646 gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
1647 gtk_widget_show(drawingArea);
1649 /* vertical tool bar */
1650 vertToolBar = gtk_toolbar_new(GTK_ORIENTATION_VERTICAL,GTK_TOOLBAR_ICONS);
1651 gtk_toolbar_set_button_relief(GTK_TOOLBAR(vertToolBar),GTK_RELIEF_NORMAL);
1652 gtk_toolbar_set_style(GTK_TOOLBAR(vertToolBar),GTK_TOOLBAR_ICONS);
1654 buttonBrush = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1655 GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,NULL,"Brush tool",
1656 "",NewPixmap(Tool_brush_xpm,GUI_LogosWindow->window,
1657 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1658 GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
1660 buttonLine = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1661 GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonBrush,NULL,"Line tool",
1662 "",NewPixmap(Tool_line_xpm,GUI_LogosWindow->window,
1663 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1664 GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
1666 buttonRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1667 GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonLine,NULL,"Rectangle tool",
1668 "",NewPixmap(Tool_rectangle_xpm,GUI_LogosWindow->window,
1669 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1670 GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
1672 buttonFilledRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
1673 GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonRectangle,NULL,
1674 "Filled rectangle tool",
1675 "",NewPixmap(Tool_filled_rectangle_xpm,
1676 GUI_LogosWindow->window,
1677 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1678 GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
1680 gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
1682 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Invert logo",NULL,
1683 NewPixmap(Edit_invert_xpm,GUI_LogosWindow->window,
1684 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1685 (GtkSignalFunc)InvertLogoEvent,vertToolBar);
1687 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Horizontal flip",NULL,
1688 NewPixmap(Edit_flip_horizontal_xpm,GUI_LogosWindow->window,
1689 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1690 (GtkSignalFunc)FlipHorizontalLogoEvent,vertToolBar);
1692 gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Vertical flip",NULL,
1693 NewPixmap(Edit_flip_vertical_xpm,GUI_LogosWindow->window,
1694 &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1695 (GtkSignalFunc)FlipVerticalLogoEvent,vertToolBar);
1698 gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
1699 gtk_widget_show(vertToolBar);
1701 GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
1704 void GUI_RefreshLogosGroupsCombo (void) {
1705 GList *callerList = NULL;
1708 for (i = 0;i < 6;i++)
1709 callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
1711 gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
1712 g_list_free(callerList);
1714 if (!callersGroupsInitialized) callersGroupsInitialized = 1;
1717 void GUI_ShowLogosWindow (void) {
1719 gtk_widget_show(buttonCaller);
1720 gtk_widget_show(callerCombo);
1722 if (xgnokiiConfig.callerGroups[0] == NULL) {
1724 GUI_InitCallerGroupsInf ();
1727 if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
1729 gtk_widget_show(GUI_LogosWindow);
1731 if (!previewAvailable && showPreviewErrorDialog) {
1732 gchar *buf = g_strdup(_("Load preview pixmap error, feature disabled."));
1733 gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
1734 gtk_widget_show(errorDialog.dialog);
1737 showPreviewErrorDialog = 0;