--- /dev/null
+#include <stdlib.h>
+#include <fcntl.h>
+#include <signal.h>
+#include <sys/types.h>
+#include <string.h>
+#include <gtk/gtk.h>
+#include <stdio.h>
+
+#include "misc.h"
+#include "gsm-common.h"
+#include "gsm-api.h"
+#include "gsm-networks.h"
+#include "files/gsm-filetypes.h"
+#include "gsm-bitmaps.h"
+
+#include "xgnokii_logos.h"
+#include "xgnokii_common.h"
+#include "xgnokii_lowlevel.h"
+#include "xgnokii.h"
+
+#include "xpm/Operator_logo.xpm"
+#include "xpm/Startup_logo.xpm"
+#include "xpm/Caller_logo.xpm"
+
+#include "xpm/Black_point.xpm"
+#include "xpm/Green_point.xpm"
+#include "xpm/Green_pixel.xpm"
+
+#include "xpm/New.xpm"
+#include "xpm/Send.xpm"
+#include "xpm/Read.xpm"
+
+#include "xpm/Edit_invert.xpm"
+#include "xpm/Edit_flip_horizontal.xpm"
+#include "xpm/Edit_flip_vertical.xpm"
+
+#include "xpm/Tool_brush.xpm"
+#include "xpm/Tool_line.xpm"
+#include "xpm/Tool_rectangle.xpm"
+#include "xpm/Tool_filled_rectangle.xpm"
+
+extern GSM_Network GSM_Networks[];
+
+static GtkWidget *GUI_LogosWindow;
+
+static ErrorDialog errorDialog = {NULL, NULL};
+static InfoDialog infoDialog = {NULL, NULL};
+
+/* stuff for drawingArea */
+static GtkWidget *drawingArea = NULL;
+static GdkPixmap *drawingPixmap = NULL;
+static GdkPixmap *greenPointPixmap, *blackPointPixmap;
+static int drawingAreaWidth, drawingAreaHeight; /* in pixels */
+static int mouseButtonPushed = 0;
+
+/* stuff for previewArea */
+static GtkWidget *previewArea = NULL;
+static GdkPixmap *previewPixmap = NULL;
+static GdkPixmap *greenPixelPixmap;
+static int previewPixmapWidth, previewPixmapHeight;
+static int previewAvailable = 1, showPreviewErrorDialog = 1;
+static int previewPixmapNumber = 0;
+
+static GSM_Bitmap bitmap, oldBitmap;
+static GSM_NetworkInfo networkInfo;
+
+/* widgets for toolbar - some, need global variables */
+static GtkWidget *buttonStartup, *buttonOperator, *buttonCaller, *buttonPicture;
+static GtkWidget *networkCombo, *callerCombo;
+
+static int activeTool = TOOL_BRUSH;
+static int toolStartX, toolStartY, toolLastX, toolLastY;
+
+/* tools for drawing */
+static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
+static GtkWidget *buttonFilledRectangle;
+
+/* Contains fileName for Export dialog. */
+typedef struct {
+ gchar *fileName;
+} ExportDialogData;
+
+static ExportDialogData exportDialogData = {NULL};
+
+GtkWidget *FileSelection;
+
+static int callersGroupsInitialized = 0;
+
+/* returns lowest number from three numbers */
+int GetMinFrom3(int a, int b, int c) {
+ if (a > b) {
+ if (b > c)
+ return c;
+ else
+ return b;
+ } else {
+ if (a > c)
+ return c;
+ else
+ return a;
+ }
+}
+
+/* returns highest number from three numbers */
+int GetMaxFrom3(int a, int b, int c) {
+ if (a > b) {
+ if (c > a)
+ return c;
+ else
+ return a;
+ } else {
+ if (c > b)
+ return c;
+ else
+ return b;
+ }
+}
+
+/* load preview pixmap from file */
+GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
+ GdkPixmap *pixmap;
+ GdkBitmap *mask;
+ gchar *file;
+
+ if (previewPixmapNumber == 0)
+ {
+ if (!strcmp (xgnokiiConfig.model, "6110") ||
+ !strcmp (xgnokiiConfig.model, "6120"))
+ {
+ file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6110.xpm");
+ previewPixmapNumber = 1;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "6130") ||
+ !strcmp (xgnokiiConfig.model, "6150") ||
+ !strcmp (xgnokiiConfig.model, "616x") ||
+ !strcmp (xgnokiiConfig.model, "6185") ||
+ !strcmp (xgnokiiConfig.model, "6190"))
+ {
+ file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6150.xpm");
+ previewPixmapNumber = 2;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "3210"))
+ {
+ file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_3210.xpm");
+ previewPixmapNumber = 3;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "3310") ||
+ !strcmp (xgnokiiConfig.model, "3330"))
+ {
+ file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_3310.xpm");
+ previewPixmapNumber = 4;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "5110") ||
+ !strcmp (xgnokiiConfig.model, "5130"))
+ {
+ file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_5110.xpm");
+ previewPixmapNumber = 5;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "6250"))
+ {
+ file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6250.xpm");
+ previewPixmapNumber = 6;
+ }
+ else if (!strcmp (xgnokiiConfig.model, "7110"))
+ {
+ file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_7110.xpm");
+ previewPixmapNumber = 7;
+ }
+ else
+ {
+ file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6210.xpm");
+ previewPixmapNumber = 8;
+ }
+ }
+ else
+ switch (previewPixmapNumber)
+ {
+ case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6110.xpm");
+ break;
+ case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6150.xpm");
+ break;
+ case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_3210.xpm");
+ break;
+ case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_3310.xpm");
+ break;
+ case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_5110.xpm");
+ break;
+ case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6250.xpm");
+ break;
+ case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_7110.xpm");
+ break;
+ default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
+ "/xpm/Preview_6210.xpm");
+ break;
+ }
+
+ pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
+ &widget->style->bg[GTK_STATE_NORMAL],
+ file);
+ g_free(file);
+
+ return pixmap;
+}
+
+/* ********************************************************
+ * ** SET/CLEAR POINTS ************************************
+ * ********************************************************
+ */
+void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
+ if (!previewAvailable) return;
+
+ /* there is difference between positiong of startupLogo and others */
+ if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
+ bitmap.type != GSM_6210StartupLogo) {
+ x += PREVIEWJUMPX;
+ y += PREVIEWJUMPY;
+ }
+
+ /* draw point to pixmap */
+ if (previewPixmap)
+ gdk_draw_point(previewPixmap,widget->style->black_gc,
+ x+PREVIEWSTARTX,y+PREVIEWSTARTY);
+
+ if (update) {
+ GdkRectangle updateRect;
+
+ /* update point on screen */
+ updateRect.width = 1;
+ updateRect.height = 1;
+ updateRect.x = PREVIEWSTARTX+x;
+ updateRect.y = PREVIEWSTARTY+y;
+
+ gtk_widget_draw(previewArea,&updateRect);
+ }
+}
+
+void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
+ if (!previewAvailable) return;
+
+ /* there is difference between positiong of startupLogo and others */
+ if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
+ bitmap.type != GSM_6210StartupLogo) {
+ x += PREVIEWJUMPX;
+ y += PREVIEWJUMPY;
+ }
+
+ /* clean point from pixmap - any idea how to draw green point without pixmap? */
+ if (previewPixmap)
+ gdk_draw_pixmap(previewPixmap,
+ widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
+ if (update) {
+ GdkRectangle updateRect;
+
+ /* clean from screen too */
+ updateRect.width = 1;
+ updateRect.height = 1;
+ updateRect.x = PREVIEWSTARTX+x;
+ updateRect.y = PREVIEWSTARTY+y;
+
+ gtk_widget_draw(previewArea,&updateRect);
+ }
+}
+
+int IsPoint(int x, int y) {
+ return GSM_IsPointBitmap(&bitmap,x,y);
+}
+
+void SetPoint(GtkWidget *widget, int x, int y, int update) {
+
+ GSM_SetPointBitmap(&bitmap,x,y);
+
+ /* draw point to pixmap */
+ gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+
+ if (update) {
+ GdkRectangle updateRect;
+
+ /* calculate update rectangle */
+ updateRect.width = POINTSIZE+2;
+ updateRect.height = POINTSIZE+2;
+ updateRect.x = x * (POINTSIZE+1);
+ updateRect.y = y * (POINTSIZE+1);
+
+ /* update on screen */
+ gtk_widget_draw(drawingArea,&updateRect);
+ }
+
+ /* draw preview point too */
+ if (previewAvailable) SetPreviewPoint(widget,x,y,update);
+}
+
+void ClearPoint(GtkWidget *widget, int x, int y, int update) {
+
+ GSM_ClearPointBitmap(&bitmap,x,y);
+
+ /* clear point from pixmap */
+ gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+
+ if (update) {
+ GdkRectangle updateRect;
+
+ /* calculate update rectangle */
+ updateRect.width = POINTSIZE+2;
+ updateRect.height = POINTSIZE+2;
+ updateRect.x = x * (POINTSIZE+1);
+ updateRect.y = y * (POINTSIZE+1);
+
+ /* update on screen */
+ gtk_widget_draw(drawingArea,&updateRect);
+ }
+
+ /* clear point from previewArea too */
+ if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
+}
+
+/* ****************************************************
+ * *** UPDATES - PREVIEW & DRAWING AREAS **************
+ * ****************************************************
+ */
+
+/* this redraw all logo points - preview & drawing area */
+void UpdatePointsRectangle(GtkWidget *widget, int x1, int y1, int x2, int y2) {
+ GdkRectangle updateRect;
+ int x, y, dx = 0, dy = 0;
+
+ if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
+ bitmap.type != GSM_6210StartupLogo) {
+ dx = PREVIEWJUMPX;
+ dy = PREVIEWJUMPY;
+ }
+
+ if (x1 > x2) {
+ x = x1;
+ x1 = x2;
+ x2 = x;
+ }
+
+ if (y1 > y2) {
+ y = y1;
+ y1 = y2;
+ y2 = y;
+ }
+
+ for (y = y1;y <= y2;y++)
+ for (x = x1;x <= x2;x++) {
+ if (IsPoint(x,y)) {
+ /* set on drawing area */
+ gdk_draw_pixmap(drawingPixmap,
+ drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
+ blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+
+ /* set on preview */
+ if (previewAvailable && previewPixmap)
+ gdk_draw_point(previewPixmap,previewArea->style->black_gc,
+ x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
+ } else {
+ /* clear from drawing */
+ gdk_draw_pixmap(drawingPixmap,
+ drawingArea->style->fg_gc[GTK_WIDGET_STATE(drawingArea)],
+ greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+
+ /* clear from preview */
+ if (previewAvailable && previewPixmap)
+ gdk_draw_pixmap(previewPixmap,
+ previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
+ greenPixelPixmap,0,0,x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,
+ 1,1);
+ }
+ }
+
+ if (previewAvailable) {
+ updateRect.x = PREVIEWSTARTX+dx+x1;
+ updateRect.y = PREVIEWSTARTY+dy+y1;
+ updateRect.width = x2-x1+1;
+ updateRect.height = y2-y1+1;
+ gtk_widget_draw(previewArea,&updateRect);
+ }
+
+ updateRect.x = x1*(POINTSIZE+1);
+ updateRect.y = y1*(POINTSIZE+1);
+ updateRect.width = (x2-x1+1)*(POINTSIZE+1)+1;
+ updateRect.height = (y2-y1+1)*(POINTSIZE+1)+1;
+ gtk_widget_draw(drawingArea,&updateRect);
+}
+
+void UpdatePoints(GtkWidget *widget) {
+ UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
+}
+
+/* this redraw all logo points in previewArea, NO DRAWING AREA */
+void UpdatePreviewPoints (void) {
+ GdkRectangle updateRect;
+ int x, y, dx = 0, dy = 0;
+
+ if (!previewPixmap || !previewAvailable) return;
+
+ if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
+ bitmap.type != GSM_6210StartupLogo) {
+ dx = PREVIEWJUMPX;
+ dy = PREVIEWJUMPY;
+ }
+
+ for (y = 0;y < bitmap.height;y++)
+ for (x = 0;x < bitmap.width;x++) {
+ if (IsPoint(x,y)) {
+ gdk_draw_point(previewPixmap,previewArea->style->black_gc,
+ x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
+ } else {
+ gdk_draw_pixmap(previewPixmap,
+ previewArea->style->fg_gc[GTK_WIDGET_STATE(previewArea)],
+ greenPixelPixmap,0,0,
+ x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy,1,1);
+ }
+ }
+
+ updateRect.x = dx;
+ updateRect.y = dy;
+ updateRect.width = bitmap.width;
+ updateRect.height = bitmap.height;
+ gtk_widget_draw(previewArea,&updateRect);
+}
+
+/* ******************************************************
+ * **** DRAWING TOOLS ***********************************
+ * ******************************************************
+ */
+
+/* TOOL - BRUSH */
+void ToolBrush(GtkWidget *widget, int column, int row, int button) {
+ /* only this tool directly update bitmap & screen */
+ if (button > 1)
+ ClearPoint(widget,column,row,1);
+ else
+ SetPoint(widget,column,row,1);
+}
+
+/* TOOL - LINE */
+/* going to rewrite to Bresenham algorithm */
+static void ToolLineUpdate(GtkWidget *widget, int column, int row) {
+ double delta, y, x;
+ int i, x1, y1, x2, y2;
+
+ if (abs(toolStartX-toolLastX) >= abs(toolStartY-toolLastY)) {
+ if (toolStartX > toolLastX) {
+ x1 = toolLastX;
+ x2 = toolStartX;
+ y1 = toolLastY;
+ y2 = toolStartY;
+ } else {
+ x1 = toolStartX;
+ x2 = toolLastX;
+ y1 = toolStartY;
+ y2 = toolLastY;
+ }
+
+ delta = ((double)(y2-y1))/((double)(x2-x1));
+ y = (double)y1;
+ for (i = x1;i <= x2;i++) {
+ if (!GSM_IsPointBitmap(&oldBitmap,i,(int)y)) ClearPoint(widget,i,(int)y,0);
+ y += delta;
+ }
+ } else {
+ if (toolStartY > toolLastY) {
+ x1 = toolLastX;
+ x2 = toolStartX;
+ y1 = toolLastY;
+ y2 = toolStartY;
+ } else {
+ x1 = toolStartX;
+ x2 = toolLastX;
+ y1 = toolStartY;
+ y2 = toolLastY;
+ }
+ delta = ((double)(x2-x1))/((double)(y2-y1));
+
+ x = (double)x1;
+ for (i = y1;i <= y2;i++) {
+ if (!GSM_IsPointBitmap(&oldBitmap,(int)x,i)) ClearPoint(widget,(int)x,i,0);
+ x += delta;
+ }
+ }
+
+ if (abs(toolStartX-column) >= abs(toolStartY-row)) {
+ if (toolStartX > column) {
+ x1 = column;
+ x2 = toolStartX;
+ y1 = row;
+ y2 = toolStartY;
+ } else {
+ x1 = toolStartX;
+ x2 = column;
+ y1 = toolStartY;
+ y2 = row;
+ }
+
+ delta = ((double)(y2-y1))/((double)(x2-x1));
+ y = (double)y1;
+ for (i = x1;i <= x2;i++) {
+ SetPoint(widget,i,(int)y,0);
+ y += delta;
+ }
+ } else {
+ if (toolStartY > row) {
+ x1 = column;
+ x2 = toolStartX;
+ y1 = row;
+ y2 = toolStartY;
+ } else {
+ x1 = toolStartX;
+ x2 = column;
+ y1 = toolStartY;
+ y2 = row;
+ }
+
+ delta = ((double)(x2-x1))/((double)(y2-y1));
+
+ x = (double)x1;
+ for (i = y1;i <= y2;i++) {
+ SetPoint(widget,(int)x,i,0);
+ x += delta;
+ }
+ }
+}
+
+/* TOOL - FILLED RECT */
+static void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
+ int i, j, x1, y1, x2, y2;
+
+ if (toolStartX > toolLastX) {
+ x1 = toolLastX;
+ x2 = toolStartX;
+ } else {
+ x1 = toolStartX;
+ x2 = toolLastX;
+ }
+
+ if (toolStartY > toolLastY) {
+ y1 = toolLastY;
+ y2 = toolStartY;
+ } else {
+ y1 = toolStartY;
+ y2 = toolLastY;
+ }
+
+ for (j = y1;j <= y2;j++)
+ for (i = x1;i <= x2;i++)
+ if (!GSM_IsPointBitmap(&oldBitmap,i,j)) ClearPoint(widget,i,j,0);
+
+ if (toolStartX > column) {
+ x1 = column;
+ x2 = toolStartX;
+ } else {
+ x1 = toolStartX;
+ x2 = column;
+ }
+
+ if (toolStartY > row) {
+ y1 = row;
+ y2 = toolStartY;
+ } else {
+ y1 = toolStartY;
+ y2 = row;
+ }
+
+ for (j = y1;j <= y2;j++)
+ for (i = x1;i <= x2;i++)
+ SetPoint(widget,i,j,0);
+}
+
+/* TOOL - RECTANGLE */
+static void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
+ int i, j, x1, y1, x2, y2;
+
+ /* clear old rectangle */
+ if (toolStartX > toolLastX) {
+ x1 = toolLastX;
+ x2 = toolStartX;
+ } else {
+ x1 = toolStartX;
+ x2 = toolLastX;
+ }
+
+ if (toolStartY > toolLastY) {
+ y1 = toolLastY;
+ y2 = toolStartY;
+ } else {
+ y1 = toolStartY;
+ y2 = toolLastY;
+ }
+
+ for (i = x1;i <= x2;i++) {
+ if (!GSM_IsPointBitmap(&oldBitmap,i,y1)) ClearPoint(widget,i,y1,0);
+ if (!GSM_IsPointBitmap(&oldBitmap,i,y2)) ClearPoint(widget,i,y2,0);
+ }
+
+ for (j = y1;j <= y2;j++) {
+ if (!GSM_IsPointBitmap(&oldBitmap,x1,j)) ClearPoint(widget,x1,j,0);
+ if (!GSM_IsPointBitmap(&oldBitmap,x2,j)) ClearPoint(widget,x2,j,0);
+ }
+
+ /* draw new rectangle */
+ if (toolStartX > column) {
+ x1 = column;
+ x2 = toolStartX;
+ } else {
+ x1 = toolStartX;
+ x2 = column;
+ }
+
+ if (toolStartY > row) {
+ y1 = row;
+ y2 = toolStartY;
+ } else {
+ y1 = toolStartY;
+ y2 = row;
+ }
+
+ for (i = x1;i <= x2;i++) {
+ if (!IsPoint(i,y1)) SetPoint(widget,i,y1,0);
+ if (!IsPoint(i,y2)) SetPoint(widget,i,y2,0);
+ }
+
+ for (j = y1;j <= y2;j++) {
+ if (!IsPoint(x1,j)) SetPoint(widget,x1,j,0);
+ if (!IsPoint(x2,j)) SetPoint(widget,x2,j,0);
+ }
+}
+
+static void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
+ GdkRectangle updateRect;
+
+ /* update preview area */
+ updateRect.x = PREVIEWSTARTX+x1;
+ updateRect.y = PREVIEWSTARTY+y1;
+ if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
+ bitmap.type != GSM_6210StartupLogo) {
+ updateRect.x += PREVIEWJUMPX;
+ updateRect.y += PREVIEWJUMPY;
+ }
+ updateRect.width = x2-x1+1;
+ updateRect.height = y2-y1+1;
+ gtk_widget_draw(previewArea,&updateRect);
+
+ /* update drawing area */
+ updateRect.x = x1 * (POINTSIZE+1);
+ updateRect.y = y1 * (POINTSIZE+1);
+ updateRect.width = (x2-x1+1)*(POINTSIZE+2);
+ updateRect.height = (y2-y1+1)*(POINTSIZE+2);
+ gtk_widget_draw(drawingArea,&updateRect);
+}
+
+/* *************************************
+ * ** PREVIEW AREA EVENTS **************
+ * *************************************
+ */
+
+static gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
+ previewPixmapNumber = (previewPixmapNumber % 8) + 1;
+
+ gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
+ previewPixmapWidth,previewPixmapHeight);
+
+ return TRUE;
+}
+
+static gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
+ if (previewPixmap) gdk_pixmap_unref(previewPixmap);
+ previewPixmap = GetPreviewPixmap(widget);
+
+ UpdatePreviewPoints();
+
+ return TRUE;
+}
+
+static gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
+ /* got previewPixmap? */
+ if (previewPixmap)
+ /* yes - simply redraw some rectangle */
+ gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ previewPixmap,event->area.x,event->area.y,event->area.x,
+ event->area.y,event->area.width,event->area.height);
+
+ return FALSE;
+}
+
+/* ********************************
+ * ** DRAWING AREA EVENTS *********
+ * ********************************
+ */
+
+static gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
+ /* got drawingPixmap? */
+ if (drawingPixmap == NULL) return TRUE;
+
+ if (!mouseButtonPushed) {
+ if ((event->button == 1 && activeTool != TOOL_BRUSH) ||
+ (activeTool == TOOL_BRUSH)) {
+ /* position from we starting drawing */
+ toolStartX = event->x / (POINTSIZE+1);
+ if (toolStartX < 0) toolStartX = 0;
+ if (toolStartX > bitmap.width-1) toolStartX = bitmap.width-1;
+
+ toolStartY = event->y / (POINTSIZE+1);
+ if (toolStartY < 0) toolStartY = 0;
+ if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
+
+ toolLastX = toolStartX;
+ toolLastY = toolStartY;
+
+ /* store old bitmap for drawing, resp. for moving, resizing primitive */
+ memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
+ }
+
+ if (event->button == 1) mouseButtonPushed = 1;
+
+ switch (activeTool) {
+ case TOOL_BRUSH:
+ ToolBrush(widget,toolStartX,toolStartY,event->button);
+ break;
+ case TOOL_LINE:
+ case TOOL_RECTANGLE:
+ if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
+ break;
+ }
+ }
+
+ /* user is drawing some tool other than TOOL_BRUSH and pushed mouse button
+ * another than first => cancel tool and redraw to oldBitmap (bitmap when
+ * user start drawing)
+ */
+ if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
+ int lowestX, lowestY, highestX, highestY;
+ int i, j;
+
+ lowestX = GetMinFrom3(toolStartX,toolLastX,toolLastX);
+ lowestY = GetMinFrom3(toolStartY,toolLastY,toolLastY);
+ highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
+ highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
+
+ for (j = lowestY;j <= highestY;j++)
+ for (i = lowestX;i <= highestX;i++)
+ if (GSM_IsPointBitmap(&oldBitmap,i,j))
+ SetPoint(widget,i,j,0);
+ else
+ ClearPoint(widget,i,j,0);
+ UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
+
+ mouseButtonPushed = 0;
+ }
+
+ return TRUE;
+}
+
+static gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
+ if (event->button == 1)
+ mouseButtonPushed = 0;
+
+ return TRUE;
+}
+
+static gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
+ int x,y;
+ GdkModifierType state;
+
+ if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
+
+ if (event->is_hint)
+ gdk_window_get_pointer(event->window,&x,&y,&state);
+ else {
+ x = event->x;
+ y = event->y;
+ state = event->state;
+ }
+
+ x = x / (POINTSIZE+1);
+ y = y / (POINTSIZE+1);
+ if (x < 0) x = 0;
+ if (y < 0) y = 0;
+ if (x > bitmap.width-1) x = bitmap.width-1;
+ if (y > bitmap.height-1) y = bitmap.height-1;
+
+ if (y == toolLastY && x == toolLastX) return TRUE;
+
+ switch (activeTool) {
+ case TOOL_BRUSH:
+ if (state & GDK_BUTTON1_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,1);
+ if (state & GDK_BUTTON2_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,2);
+ if (state & GDK_BUTTON3_MASK && drawingPixmap != NULL) ToolBrush(widget,x,y,3);
+ break;
+ case TOOL_RECTANGLE:
+ if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
+ break;
+ case TOOL_FILLED_RECTANGLE:
+ if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
+ break;
+ case TOOL_LINE:
+ if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
+ break;
+ }
+
+ /* what is this?
+ * it's simple, above tools updates only bitmap in memory and this
+ * function update from bitmap to screen, it's made as non-blinking
+ * drawing functions with this, simply draw everything we need and
+ * after that, redraw to screen rectangle in which we made changes
+ * it's not redrawing pixel by pixel (blinking)
+ */
+ if (activeTool != TOOL_BRUSH) {
+ int lowestX, lowestY, highestX, highestY;
+
+ lowestX = GetMinFrom3(toolStartX,toolLastX,x);
+ lowestY = GetMinFrom3(toolStartY,toolLastY,y);
+ highestX = GetMaxFrom3(toolStartX,toolLastX,x);
+ highestY = GetMaxFrom3(toolStartY,toolLastY,y);
+
+ UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
+ }
+
+ toolLastX = x;
+ toolLastY = y;
+ return TRUE;
+}
+
+/* configureEvent? -> event when someone resize windows, ... */
+static gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
+ int x, y;
+ /* got drawingPixmap? */
+ if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
+
+ /* make a new pixmap */
+ drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
+ drawingAreaHeight,-1);
+
+ /* draw grid into pixmap */
+ for (y = 0;y < bitmap.height;y++)
+ for (x = 0;x < bitmap.width;x++)
+ if (IsPoint(x,y))
+ gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ blackPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+ else
+ gdk_draw_pixmap(drawingPixmap,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ greenPointPixmap,0,0,x*(POINTSIZE+1),y*(POINTSIZE+1),-1,-1);
+
+ return TRUE;
+}
+
+static gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
+ /* got drawingPixmap? */
+ if (drawingPixmap)
+ /* got - draw it */
+ gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
+ drawingPixmap,
+ event->area.x,event->area.y,event->area.x,event->area.y,
+ event->area.width,event->area.height);
+ return FALSE;
+}
+
+/* *****************************************
+ * ** TOOLBAR & MENU EVENTS ****************
+ * *****************************************
+ */
+
+static void GetNetworkInfoEvent(GtkWidget *widget) {
+ GSM_Error error;
+ PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
+ D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
+
+ /* prepare data for event */
+ data->info = &networkInfo;
+ e->event = Event_GetNetworkInfo;
+ e->data = data;
+
+ /* launch event and wait for result */
+ GUI_InsertEvent(e);
+ pthread_mutex_lock(&getNetworkInfoMutex);
+ pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
+ pthread_mutex_unlock(&getNetworkInfoMutex);
+ error = data->status;
+ g_free(data);
+
+ /* watch for errors */
+ if (error != GE_NONE) {
+ gchar *buf = g_strdup_printf(_("Error getting network info\n(error=%d)"),error);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ }
+
+ /* set new operator name to combo */
+ gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
+ GSM_GetNetworkName(networkInfo.NetworkCode));
+}
+
+static void GetLogoEvent(GtkWidget *widget) {
+ int i;
+ GSM_Error error;
+ PhoneEvent *e = (PhoneEvent *) g_malloc(sizeof(PhoneEvent));
+ D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
+ char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
+
+ /* prepare data for event */
+ strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
+ data->bitmap = &bitmap;
+ e->event = Event_GetBitmap;
+ e->data = data;
+ if (GetModelFeature(FN_CALLERGROUPS)!=0) {
+ for (i = 0;i < 6;i++)
+ if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
+ xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
+ }
+
+ /* launch event and wait for result */
+ GUI_InsertEvent(e);
+ pthread_mutex_lock(&getBitmapMutex);
+ pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
+ pthread_mutex_unlock(&getBitmapMutex);
+ error = data->status;
+ g_free(data);
+
+ /* watch for errors */
+ if (error != GE_NONE) {
+ gchar *buf = g_strdup_printf(_("Error getting bitmap\n(error=%d)"),error);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ } else {
+ /* no error, draw logo from phone */
+ UpdatePoints(drawingArea);
+ }
+}
+
+static void SetLogoEvent(GtkWidget *widget) {
+ GSM_Error error;
+ PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
+ D_Bitmap *data = (D_Bitmap *)g_malloc(sizeof(D_Bitmap));
+ char *operator = gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry));
+ int i;
+
+ /* prepare data */
+ strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
+
+ if (bitmap.type == GSM_CallerLogo) {
+ /* above condition must be there, because if you launch logos before
+ * callerGroups are available, you will see segfault - callerGroups not initialized
+ */
+ if (GetModelFeature(FN_CALLERGROUPS)!=0) {
+ for (i = 0;i < 6;i++)
+ if (strcmp(gtk_entry_get_text(GTK_ENTRY(GTK_COMBO(callerCombo)->entry)),
+ xgnokiiConfig.callerGroups[i]) == 0) bitmap.number = i;
+ }
+ }
+ if (bitmap.type == GSM_StartupLogo) {
+ bitmap.number=0;
+ }
+
+ data->bitmap = &bitmap;
+ e->event = Event_SetBitmap;
+ e->data = data;
+
+ /* launch event and wait for result */
+ GUI_InsertEvent(e);
+ pthread_mutex_lock(&setBitmapMutex);
+ pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
+ pthread_mutex_unlock(&setBitmapMutex);
+ error = data->status;
+ g_free(data);
+
+ /* watch for errors */
+ if (error != GE_NONE) {
+ gchar *buf = g_strdup_printf(_("Error setting bitmap\n(error=%d)"),error);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ }
+}
+
+static void ClearLogoEvent(GtkWidget *widget) {
+
+ bitmap.size=GSM_GetBitmapSize(&bitmap);
+
+ GSM_ClearBitmap(&bitmap);
+
+ UpdatePoints(widget);
+}
+
+static void InvertLogoEvent(GtkWidget *widget) {
+ int column, row;
+
+ for (column = 0;column < bitmap.width;column++)
+ for (row = 0;row < bitmap.height;row++)
+ if (IsPoint(column,row))
+ GSM_ClearPointBitmap(&bitmap,column,row);
+ else
+ GSM_SetPointBitmap(&bitmap,column,row);
+
+ UpdatePoints(widget);
+}
+
+static void UpLogoEvent(GtkWidget *widget) {
+ int column, row;
+
+ GSM_Bitmap tbitmap;
+
+ tbitmap=bitmap;
+
+ for (row = 0;row < bitmap.height-1;row++)
+ for (column = 0;column < bitmap.width;column++)
+ if (IsPoint(column,row+1))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ for (column = 0;column < bitmap.width;column++)
+ if (GSM_IsPointBitmap(&tbitmap,column,0))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ UpdatePoints(widget);
+}
+
+static void DownLogoEvent(GtkWidget *widget) {
+ int column, row;
+
+ GSM_Bitmap tbitmap;
+
+ tbitmap=bitmap;
+
+ for (row = bitmap.height-1;row > 0;row--)
+ for (column = 0;column < bitmap.width;column++)
+ if (IsPoint(column,row-1))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ for (column = 0;column < bitmap.width;column++)
+ if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
+ GSM_SetPointBitmap(&bitmap,column,0);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,0);
+
+ UpdatePoints(widget);
+}
+
+static void LeftLogoEvent(GtkWidget *widget) {
+ int column, row;
+
+ GSM_Bitmap tbitmap;
+
+ tbitmap=bitmap;
+
+ for (column = 0; column < bitmap.width-1;column++)
+ for (row = 0;row < bitmap.height;row++)
+ if (IsPoint(column+1,row))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ for (row = 0;row < bitmap.height;row++)
+ if (GSM_IsPointBitmap(&tbitmap,0,row))
+ GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
+
+ UpdatePoints(widget);
+}
+
+static void RightLogoEvent(GtkWidget *widget) {
+ int column, row;
+
+ GSM_Bitmap tbitmap;
+
+ tbitmap=bitmap;
+
+ for (column = bitmap.width-1;column > 0;column--)
+ for (row = 0;row < bitmap.height;row++)
+ if (IsPoint(column-1,row))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ for (row = 0;row < bitmap.height;row++)
+ if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
+ GSM_SetPointBitmap(&bitmap,0,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,0,row);
+
+ UpdatePoints(widget);
+}
+
+static void FlipVerticalLogoEvent(GtkWidget *widget) {
+ int row, column, temp;
+
+ for (row = 0;row < (bitmap.height/2);row++)
+ for (column = 0;column < bitmap.width;column++) {
+ temp = IsPoint(column,row);
+ if (IsPoint(column,bitmap.height-1-row))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ if (temp)
+ GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
+ }
+
+ UpdatePoints(widget);
+}
+
+static void FlipHorizontalLogoEvent(GtkWidget *widget) {
+ int row, column, temp;
+
+ for (row = 0;row < bitmap.height;row++)
+ for (column = 0;column < (bitmap.width/2);column++) {
+ temp = IsPoint(column,row);
+
+ if (IsPoint(bitmap.width-1-column,row))
+ GSM_SetPointBitmap(&bitmap,column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,column,row);
+
+ if (temp)
+ GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
+ else
+ GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
+ }
+
+ UpdatePoints(widget);
+}
+
+/* this is launched when tool was changed */
+static gint ToolTypeEvent(GtkWidget *widget) {
+ if (GTK_TOGGLE_BUTTON(buttonBrush)->active) activeTool = TOOL_BRUSH; else
+ if (GTK_TOGGLE_BUTTON(buttonLine)->active) activeTool = TOOL_LINE; else
+ if (GTK_TOGGLE_BUTTON(buttonRectangle)->active) activeTool = TOOL_RECTANGLE; else
+ if (GTK_TOGGLE_BUTTON(buttonFilledRectangle)->active)
+ activeTool = TOOL_FILLED_RECTANGLE;
+
+ return 0;
+}
+
+/* this is launched when logo type was change by buttons on toolbar */
+static gint LogoTypeEvent(GtkWidget *widget) {
+ int clear = 0;
+
+ /* is startupLogo? */
+ if (GTK_TOGGLE_BUTTON(buttonStartup)->active &&
+ bitmap.type != GSM_StartupLogo && bitmap.type != GSM_6210StartupLogo &&
+ bitmap.type != GSM_7110StartupLogo) {
+ /* look for old bitmap type, clean if another */
+ clear = 1;
+
+ if (!strcmp(xgnokiiConfig.model,"7110")) {
+ GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
+ } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) {
+ GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
+ } else {
+ GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
+ }
+ }
+
+ /* new type is PictureImage */
+ if (GTK_TOGGLE_BUTTON(buttonPicture)->active && bitmap.type != GSM_PictureImage) {
+ /* look for old bitmap type, clean if another */
+ clear = 1;
+ GSM_ResizeBitmap(&bitmap,GSM_PictureImage);
+ }
+
+ /* new type is callerLogo */
+ if (GTK_TOGGLE_BUTTON(buttonCaller)->active && bitmap.type != GSM_CallerLogo) {
+ /* previous was startup or Picture ? clear and draw batteries, signal, ... */
+ if (bitmap.type != GSM_OperatorLogo) clear = 1;
+ GSM_ResizeBitmap(&bitmap,GSM_CallerLogo);
+ }
+
+ /* is new type operatorLogo? */
+ if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo &&
+ bitmap.type != GSM_7110OperatorLogo) {
+
+ /* previous startup or Picture ? clear and draw batteries, signal, ... */
+ if (bitmap.type != GSM_CallerLogo) clear = 1;
+
+ if (!strcmp(xgnokiiConfig.model,"7110")) {
+ GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
+ } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) {
+ GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
+ } else {
+ GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo);
+ }
+ }
+
+ /* must clear? */
+ if (clear) {
+ if (previewAvailable) {
+ /* configure event reload pixmap from disk and redraws */
+ gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
+ previewPixmapWidth,previewPixmapHeight);
+ }
+
+ /* change new drawingArea size */
+ drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
+ drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
+
+ gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
+ drawingAreaWidth,drawingAreaHeight);
+ }
+
+ return 0;
+}
+
+static inline void CloseLogosWindow (void) {
+ gtk_widget_hide(GUI_LogosWindow);
+}
+
+void ExportLogoFileMain(gchar *name)
+{
+ GSM_Bitmap tbitmap;
+ GSM_Error error;
+
+ tbitmap=bitmap;
+
+ strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
+
+ error=GSM_SaveBitmapFile(name,&tbitmap);
+ if (error!=GE_NONE) {
+ gchar *buf = g_strdup_printf(_("Error saving file\n(error=%d)"),error);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ }
+}
+
+static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
+{
+ gtk_widget_hide (GTK_WIDGET (data));
+ ExportLogoFileMain(exportDialogData.fileName);
+}
+
+static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
+{
+ static YesNoDialog dialog = { NULL, NULL};
+ FILE *f;
+ gchar err[80];
+
+ exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
+ gtk_widget_hide (GTK_WIDGET (fs));
+
+ if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
+ {
+ fclose (f);
+ if (dialog.dialog == NULL)
+ {
+ CreateYesNoDialog (&dialog, YesLogoFileExportDialog, CancelDialog, GUI_LogosWindow);
+ gtk_window_set_title (GTK_WINDOW (dialog.dialog), _("Overwrite file?"));
+ g_snprintf ( err, 80, _("File %s already exist.\nOverwrite?"), exportDialogData.fileName);
+ gtk_label_set_text (GTK_LABEL(dialog.text), err);
+ }
+ gtk_widget_show (dialog.dialog);
+ }
+ else
+ ExportLogoFileMain(exportDialogData.fileName);
+}
+
+void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
+{
+ GSM_Bitmap tbitmap;
+ GSM_Error error=0;
+
+ gchar *fileName;
+ FILE *f;
+
+ fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
+ gtk_widget_hide (GTK_WIDGET (fs));
+
+ if ((f = fopen (fileName, "r")) == NULL) {
+ gchar *buf = g_strdup_printf(_("Can't open file %s for reading !"),fileName);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ return;
+ }
+
+ error=GSM_ReadBitmapFile(fileName,&tbitmap);
+ if (error!=GE_NONE) {
+ gchar *buf = g_strdup_printf(_("Error reading file\n(error=%d)"),error);
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+ return;
+ }
+
+ exportDialogData.fileName=fileName;
+
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),false);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),false);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),false);
+ gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonPicture),false);
+
+ if (tbitmap.type==GSM_OperatorLogo || tbitmap.type==GSM_7110OperatorLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonOperator),true);
+ if (tbitmap.type==GSM_StartupLogo || tbitmap.type==GSM_7110StartupLogo || tbitmap.type==GSM_6210StartupLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonStartup),true);
+ if (tbitmap.type==GSM_CallerLogo) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonCaller),true);
+ if (tbitmap.type==GSM_PictureImage) gtk_toggle_button_set_state(GTK_TOGGLE_BUTTON(buttonPicture),true);
+
+ memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
+
+ if (!strcmp(xgnokiiConfig.model,"7110")) { //7110
+ if (bitmap.type==GSM_StartupLogo || bitmap.type==GSM_6210StartupLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
+
+ if (bitmap.type==GSM_OperatorLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
+
+ } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) { //6210,6250
+ if (bitmap.type==GSM_StartupLogo || bitmap.type==GSM_7110StartupLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
+
+ if (bitmap.type==GSM_OperatorLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
+
+ } else {
+ if (bitmap.type==GSM_6210StartupLogo || bitmap.type==GSM_7110StartupLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
+ if (bitmap.type==GSM_7110OperatorLogo)
+ GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo);
+ }
+
+ UpdatePoints(drawingArea);
+}
+
+void SaveLogoAs(GtkWidget *widget)
+{
+ FileSelection=gtk_file_selection_new ("Save logo as ...");
+
+ gtk_signal_connect (
+ GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
+ "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
+
+ gtk_signal_connect_object (
+ GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
+ "clicked", (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT (FileSelection));
+
+ gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
+
+ gtk_widget_show(FileSelection);
+}
+
+void SaveLogo(GtkWidget *widget)
+{
+ if (exportDialogData.fileName==NULL) {
+ SaveLogoAs(widget);
+ } else {
+ ExportLogoFileMain(exportDialogData.fileName);
+ }
+}
+
+void OpenLogo(GtkWidget *widget)
+{
+ FileSelection=gtk_file_selection_new ("Open logo...");
+
+ gtk_signal_connect (
+ GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
+ "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
+
+ gtk_signal_connect_object (
+ GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
+ "clicked", (GtkSignalFunc) gtk_widget_destroy,
+ GTK_OBJECT (FileSelection));
+
+ gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
+
+ gtk_widget_show(FileSelection);
+}
+
+static GtkItemFactoryEntry logosMenuItems[] = {
+ { NULL, NULL, NULL, 0, "<Branch>"},
+ { NULL, "<control>O", OpenLogo, 0, NULL},
+ { NULL, "<control>S", SaveLogo, 0, NULL},
+ { NULL, NULL, SaveLogoAs, 0, NULL},
+ { NULL, NULL, NULL, 0, "<Separator>"},
+ { NULL, "<control>G", GetNetworkInfoEvent, 0, NULL},
+ { NULL, NULL, GetLogoEvent, 0, NULL},
+ { NULL, "<control>T", SetLogoEvent, 0, NULL},
+ { NULL, NULL, NULL, 0, "<Separator>"},
+ { NULL, "<control>W", CloseLogosWindow, 0, NULL},
+ { NULL, NULL, NULL, 0, "<Branch>"},
+ { NULL, "<control>C", ClearLogoEvent, 0, NULL},
+ { NULL, "<control>I", InvertLogoEvent, 0, NULL},
+ { NULL, NULL, NULL, 0, "<Separator>"},
+ { NULL, "<control>U", UpLogoEvent, 0, NULL},
+ { NULL, "<control>D", DownLogoEvent, 0, NULL},
+ { NULL, "<control>L", LeftLogoEvent, 0, NULL},
+ { NULL, "<control>R", RightLogoEvent, 0, NULL},
+ { NULL, NULL, NULL, 0, "<Separator>"},
+ { NULL, "<control>H", FlipHorizontalLogoEvent, 0, NULL},
+ { NULL, "<control>V", FlipVerticalLogoEvent, 0, NULL},
+};
+
+static void InitLogosMenu (void) {
+ logosMenuItems[0].path = g_strdup(_("/_File"));
+ logosMenuItems[1].path = g_strdup(_("/File/_Open"));
+ logosMenuItems[2].path = g_strdup(_("/File/_Save"));
+ logosMenuItems[3].path = g_strdup(_("/File/Save _as ..."));
+ logosMenuItems[4].path = g_strdup(_("/File/Sep1"));
+ logosMenuItems[5].path = g_strdup(_("/File/_Get operator"));
+ logosMenuItems[6].path = g_strdup(_("/File/Get _logo"));
+ logosMenuItems[7].path = g_strdup(_("/File/Se_t logo"));
+ logosMenuItems[8].path = g_strdup(_("/File/Sep2"));
+ logosMenuItems[9].path = g_strdup(_("/File/_Close"));
+ logosMenuItems[10].path = g_strdup(_("/_Edit"));
+ logosMenuItems[11].path = g_strdup(_("/Edit/_Clear"));
+ logosMenuItems[12].path = g_strdup(_("/Edit/_Invert"));
+ logosMenuItems[13].path = g_strdup(_("/Edit/Sep3"));
+ logosMenuItems[14].path = g_strdup(_("/Edit/_Up logo"));
+ logosMenuItems[15].path = g_strdup(_("/Edit/_Down logo"));
+ logosMenuItems[16].path = g_strdup(_("/Edit/_Left logo"));
+ logosMenuItems[17].path = g_strdup(_("/Edit/_Right logo"));
+ logosMenuItems[18].path = g_strdup(_("/Edit/Sep4"));
+ logosMenuItems[19].path = g_strdup(_("/Edit/Flip _horizontal"));
+ logosMenuItems[20].path = g_strdup(_("/Edit/Flip _vertical"));
+}
+
+void GUI_CreateLogosWindow (void) {
+ int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
+ GtkAccelGroup *accelGroup;
+ GtkItemFactory *itemFactory;
+ GtkWidget *menuBar;
+ GtkWidget *toolBar, *vertToolBar;
+ GtkWidget *vbox;
+ GtkWidget *hbox;
+ GtkWidget *drawingBox;
+ GtkWidget *separator;
+ GdkBitmap *mask;
+
+ GList *glistNetwork = NULL;
+
+ int i = 0;
+
+ previewPixmapWidth = PREVIEWWIDTH;
+ previewPixmapHeight = PREVIEWHEIGHT;
+
+ InitLogosMenu();
+
+ /* realize top level window for logos */
+ GUI_LogosWindow = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+ gtk_window_set_policy(GTK_WINDOW(GUI_LogosWindow),1,1,1);
+ gtk_window_set_title(GTK_WINDOW(GUI_LogosWindow),_("Logos"));
+ gtk_signal_connect(GTK_OBJECT(GUI_LogosWindow),"delete_event",
+ GTK_SIGNAL_FUNC(DeleteEvent),NULL);
+ gtk_widget_realize(GUI_LogosWindow);
+
+ CreateErrorDialog(&errorDialog,GUI_LogosWindow);
+ CreateInfoDialog(&infoDialog,GUI_LogosWindow);
+
+ accelGroup = gtk_accel_group_new();
+ gtk_accel_group_attach(accelGroup,GTK_OBJECT(GUI_LogosWindow));
+
+ /* create main vbox */
+ vbox = gtk_vbox_new(FALSE,1);
+ gtk_container_add(GTK_CONTAINER(GUI_LogosWindow),vbox);
+ gtk_widget_show(vbox);
+
+ itemFactory = gtk_item_factory_new(GTK_TYPE_MENU_BAR,"<main>",accelGroup);
+ gtk_item_factory_create_items(itemFactory,nMenuItems,logosMenuItems,NULL);
+ menuBar = gtk_item_factory_get_widget(itemFactory,"<main>");
+
+ gtk_box_pack_start(GTK_BOX(vbox),menuBar,FALSE,FALSE,0);
+ gtk_widget_show(menuBar);
+
+ /* toolbar */
+ toolBar = gtk_toolbar_new(GTK_ORIENTATION_HORIZONTAL,GTK_TOOLBAR_ICONS);
+ gtk_toolbar_set_button_relief(GTK_TOOLBAR(toolBar),GTK_RELIEF_NORMAL);
+ gtk_toolbar_set_style(GTK_TOOLBAR(toolBar),GTK_TOOLBAR_ICONS);
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Clear logo",NULL,
+ NewPixmap(New_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)ClearLogoEvent,toolBar);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Get logo",NULL,
+ NewPixmap(Read_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)GetLogoEvent,toolBar);
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(toolBar),NULL,"Set logo",NULL,
+ NewPixmap(Send_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)SetLogoEvent,toolBar);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
+
+ buttonStartup = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,NULL,"Startup logo",
+ "",NewPixmap(Startup_logo_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
+
+ buttonOperator = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonStartup,NULL,"Operator logo",
+ "",NewPixmap(Operator_logo_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
+
+ buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,
+ buttonOperator,
+ NULL,"Caller logo",
+ "",NewPixmap(Caller_logo_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
+
+ buttonPicture = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,
+ buttonOperator,
+ NULL,"Picture image",
+ "",NewPixmap(Caller_logo_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
+
+ networkCombo = gtk_combo_new();
+ gtk_combo_set_use_arrows_always(GTK_COMBO(networkCombo),1);
+ while (strcmp(GSM_Networks[i].Name,"unknown"))
+ glistNetwork = g_list_insert_sorted(glistNetwork,GSM_Networks[i++].Name,
+ (GCompareFunc)strcmp);
+ gtk_combo_set_popdown_strings(GTK_COMBO(networkCombo),glistNetwork);
+ gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),FALSE);
+ gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar),networkCombo,"","");
+ gtk_widget_show(networkCombo);
+ g_list_free(glistNetwork);
+
+ callerCombo = gtk_combo_new();
+ gtk_entry_set_editable(GTK_ENTRY(GTK_COMBO(callerCombo)->entry),FALSE);
+ gtk_toolbar_append_widget(GTK_TOOLBAR(toolBar),callerCombo,"","");
+ gtk_widget_show(callerCombo);
+
+ gtk_box_pack_start(GTK_BOX(vbox),toolBar,FALSE,FALSE,0);
+ gtk_widget_show(toolBar);
+
+ /* vertical separator */
+ separator = gtk_hseparator_new();
+ gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
+
+ /* create horizontal box for preview and drawing areas */
+ hbox = gtk_hbox_new(FALSE,5);
+ gtk_box_pack_start(GTK_BOX(vbox),hbox,FALSE,FALSE,0);
+ gtk_widget_show(hbox);
+
+ /* set GSM_Bitmap width,height needed for creating drawinArea
+ * we are starting, default is startupLogo
+ */
+ bitmap.type = GSM_7110StartupLogo;
+ bitmap.height = 65;
+ bitmap.width = 96;
+ bitmap.size = bitmap.height * bitmap.width / 8;
+ if (!strcmp(xgnokiiConfig.model,"7110")) { //7110
+ GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
+ } else if (!strcmp(xgnokiiConfig.model,"6210") || !strcmp(xgnokiiConfig.model,"6250")) { //6210,6250
+ GSM_ResizeBitmap(&bitmap,GSM_6210StartupLogo);
+ } else {
+ GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
+ }
+ drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
+ drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
+
+ /* previewArea */
+ previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
+
+ if (previewPixmap != NULL) {
+ previewArea = gtk_drawing_area_new();
+ gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
+ previewPixmapWidth,previewPixmapHeight);
+
+ greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
+ &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
+ Green_pixel_xpm);
+
+ gtk_signal_connect(GTK_OBJECT(previewArea),"expose_event",
+ (GtkSignalFunc)PreviewAreaExposeEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(previewArea),"configure_event",
+ (GtkSignalFunc)PreviewAreaConfigureEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(previewArea),"button_press_event",
+ (GtkSignalFunc)PreviewAreaButtonPressEvent,NULL);
+
+ gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
+
+ gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
+ gtk_widget_show(previewArea);
+
+ /* clear battery, signal, menu & names from preview phone */
+ UpdatePreviewPoints ();
+
+ } else previewAvailable = 0;
+
+ /* drawingArea */
+ greenPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
+ &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Green_point_xpm);
+ blackPointPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
+ &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],Black_point_xpm);
+
+ drawingBox = gtk_vbox_new(FALSE,3);
+ gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
+ gtk_widget_show(drawingBox);
+
+ drawingArea = gtk_drawing_area_new();
+ gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
+ drawingAreaWidth,drawingAreaHeight);
+
+ gtk_signal_connect(GTK_OBJECT(drawingArea),"configure_event",
+ (GtkSignalFunc)DrawingAreaConfigureEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(drawingArea),"expose_event",
+ (GtkSignalFunc)DrawingAreaExposeEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(drawingArea),"button_press_event",
+ (GtkSignalFunc)DrawingAreaButtonPressEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(drawingArea),"button_release_event",
+ (GtkSignalFunc)DrawingAreaButtonReleaseEvent,NULL);
+ gtk_signal_connect(GTK_OBJECT(drawingArea),"motion_notify_event",
+ (GtkSignalFunc)DrawingAreaMotionNotifyEvent,NULL);
+
+ gtk_widget_set_events(drawingArea,GDK_EXPOSURE_MASK | GDK_LEAVE_NOTIFY_MASK |
+ GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
+ GDK_POINTER_MOTION_MASK | GDK_POINTER_MOTION_HINT_MASK);
+
+ gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
+ gtk_widget_show(drawingArea);
+
+ /* vertical tool bar */
+ vertToolBar = gtk_toolbar_new(GTK_ORIENTATION_VERTICAL,GTK_TOOLBAR_ICONS);
+ gtk_toolbar_set_button_relief(GTK_TOOLBAR(vertToolBar),GTK_RELIEF_NORMAL);
+ gtk_toolbar_set_style(GTK_TOOLBAR(vertToolBar),GTK_TOOLBAR_ICONS);
+
+ buttonBrush = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,NULL,NULL,"Brush tool",
+ "",NewPixmap(Tool_brush_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
+
+ buttonLine = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonBrush,NULL,"Line tool",
+ "",NewPixmap(Tool_line_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
+
+ buttonRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonLine,NULL,"Rectangle tool",
+ "",NewPixmap(Tool_rectangle_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
+
+ buttonFilledRectangle = gtk_toolbar_append_element(GTK_TOOLBAR(vertToolBar),
+ GTK_TOOLBAR_CHILD_RADIOBUTTON,buttonRectangle,NULL,
+ "Filled rectangle tool",
+ "",NewPixmap(Tool_filled_rectangle_xpm,
+ GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ GTK_SIGNAL_FUNC(ToolTypeEvent),NULL);
+
+ gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Invert logo",NULL,
+ NewPixmap(Edit_invert_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)InvertLogoEvent,vertToolBar);
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Horizontal flip",NULL,
+ NewPixmap(Edit_flip_horizontal_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)FlipHorizontalLogoEvent,vertToolBar);
+
+ gtk_toolbar_append_item(GTK_TOOLBAR(vertToolBar),NULL,"Vertical flip",NULL,
+ NewPixmap(Edit_flip_vertical_xpm,GUI_LogosWindow->window,
+ &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
+ (GtkSignalFunc)FlipVerticalLogoEvent,vertToolBar);
+
+
+ gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
+ gtk_widget_show(vertToolBar);
+
+ GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
+}
+
+void GUI_RefreshLogosGroupsCombo (void) {
+ GList *callerList = NULL;
+ int i;
+
+ for (i = 0;i < 6;i++)
+ callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
+
+ gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
+ g_list_free(callerList);
+
+ if (!callersGroupsInitialized) callersGroupsInitialized = 1;
+}
+
+void GUI_ShowLogosWindow (void) {
+
+ gtk_widget_show(buttonCaller);
+ gtk_widget_show(callerCombo);
+
+ if (xgnokiiConfig.callerGroups[0] == NULL) {
+ GUI_Refresh();
+ GUI_InitCallerGroupsInf ();
+ }
+
+ if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
+
+ gtk_widget_show(GUI_LogosWindow);
+
+ if (!previewAvailable && showPreviewErrorDialog) {
+ gchar *buf = g_strdup(_("Load preview pixmap error, feature disabled."));
+ gtk_label_set_text(GTK_LABEL(errorDialog.text),buf);
+ gtk_widget_show(errorDialog.dialog);
+ g_free(buf);
+
+ showPreviewErrorDialog = 0;
+ }
+}
git://git.jankratochvil.net / gnokii.git / blobdiff