xgnokii/xgnokii_logos.c

   1 #include <stdlib.h>
   2 #include <fcntl.h>
   3 #include <signal.h>
   4 #include <sys/types.h>
   5 #include <string.h>
   6 #include <gtk/gtk.h>
   7 #include <stdio.h>
   8
   9 #include "misc.h"
  10 #include "gsm-common.h"
  11 #include "gsm-api.h"
  12 #include "gsm-networks.h"
  13 #include "files/gsm-filetypes.h"
  14 #include "gsm-bitmaps.h"
  15
  16 #include "xgnokii_logos.h"
  17 #include "xgnokii_common.h"
  18 #include "xgnokii_lowlevel.h"
  19 #include "xgnokii.h"
  20
  21 #include "xpm/Operator_logo.xpm"
  22 #include "xpm/Startup_logo.xpm"
  23 #include "xpm/Caller_logo.xpm"
  24
  25 #include "xpm/Black_point.xpm"
  26 #include "xpm/Green_point.xpm"
  27 #include "xpm/Green_pixel.xpm"
  28
  29 #include "xpm/New.xpm"
  30 #include "xpm/Send.xpm"
  31 #include "xpm/Read.xpm"
  32
  33 #include "xpm/Edit_invert.xpm"
  34 #include "xpm/Edit_flip_horizontal.xpm"
  35 #include "xpm/Edit_flip_vertical.xpm"
  36
  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"
  41
  42 extern GSM_Network GSM_Networks[];
  43
  44 static GtkWidget *GUI_LogosWindow;
  45
  46 static ErrorDialog errorDialog = {NULL, NULL};
  47 static InfoDialog infoDialog = {NULL, NULL};
  48
  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;
  55
  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;
  63
  64 static GSM_Bitmap bitmap, oldBitmap;
  65 static GSM_NetworkInfo networkInfo;
  66
  67 /* widgets for toolbar - some, need global variables */
  68 static GtkWidget *buttonStartup, *buttonOperator, *buttonCaller, *buttonPicture;
  69 static GtkWidget *networkCombo, *callerCombo;
  70
  71 static int activeTool = TOOL_BRUSH;
  72 static int toolStartX, toolStartY, toolLastX, toolLastY;
  73
  74 /* tools for drawing */
  75 static GtkWidget *buttonBrush, *buttonLine, *buttonRectangle;
  76 static GtkWidget *buttonFilledRectangle;
  77
  78 /* Contains fileName for Export dialog. */
  79 typedef struct {
  80   gchar *fileName;
  81 } ExportDialogData;
  82
  83 static ExportDialogData exportDialogData = {NULL};
  84
  85 GtkWidget *FileSelection;
  86
  87 static int callersGroupsInitialized = 0;
  88
  89 /* returns lowest number from three numbers */
  90 int GetMinFrom3(int a, int b, int c) {
  91   if (a > b) {
  92     if (b > c)
  93       return c;
  94     else
  95       return b;
  96   } else {
  97     if (a > c)
  98       return c;
  99     else
 100       return a;
 101   }
 102 }
 103
 104 /* returns highest number from three numbers */
 105 int GetMaxFrom3(int a, int b, int c) {
 106   if (a > b) {
 107     if (c > a)
 108       return c;
 109     else
 110       return a;
 111   } else {
 112     if (c > b)
 113       return c;
 114     else
 115       return b;
 116   }
 117 }
 118
 119 /* load preview pixmap from file */
 120 GdkPixmap *GetPreviewPixmap (GtkWidget *widget) {
 121   GdkPixmap *pixmap;
 122   GdkBitmap *mask;
 123   gchar *file;
 124
 125   if (previewPixmapNumber == 0)
 126   {
 127     if (!strcmp (xgnokiiConfig.model, "6110") ||
 128         !strcmp (xgnokiiConfig.model, "6120"))
 129     {
 130       file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 131                              "/xpm/Preview_6110.xpm");
 132       previewPixmapNumber = 1;
 133     }
 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"))
 139     {
 140       file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 141                              "/xpm/Preview_6150.xpm");
 142       previewPixmapNumber = 2;
 143     }
 144     else if (!strcmp (xgnokiiConfig.model, "3210"))
 145     {
 146       file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
 147                              "/xpm/Preview_3210.xpm");
 148       previewPixmapNumber = 3;
 149     }
 150     else if (!strcmp (xgnokiiConfig.model, "3310") ||
 151              !strcmp (xgnokiiConfig.model, "3330"))
 152     {
 153       file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
 154                              "/xpm/Preview_3310.xpm");
 155       previewPixmapNumber = 4;
 156     }
 157     else if (!strcmp (xgnokiiConfig.model, "5110") ||
 158              !strcmp (xgnokiiConfig.model, "5130"))
 159     {
 160       file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
 161                              "/xpm/Preview_5110.xpm");
 162       previewPixmapNumber = 5;
 163     }
 164     else if (!strcmp (xgnokiiConfig.model, "6250"))
 165     {
 166       file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
 167                              "/xpm/Preview_6250.xpm");
 168       previewPixmapNumber = 6;
 169     }
 170     else if (!strcmp (xgnokiiConfig.model, "7110"))
 171     {
 172       file = g_strdup_printf("%s%s", xgnokiiConfig.xgnokiidir,
 173                              "/xpm/Preview_7110.xpm");
 174       previewPixmapNumber = 7;
 175     }
 176     else
 177     {
 178       file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 179                              "/xpm/Preview_6210.xpm");
 180       previewPixmapNumber = 8;
 181     }
 182   }
 183   else
 184     switch (previewPixmapNumber)
 185     {
 186       case 1: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 187                                      "/xpm/Preview_6110.xpm");
 188               break;
 189       case 2: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 190                                      "/xpm/Preview_6150.xpm");
 191               break;
 192       case 3: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 193                                      "/xpm/Preview_3210.xpm");
 194               break;
 195       case 4: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 196                                      "/xpm/Preview_3310.xpm");
 197               break;
 198       case 5: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 199                                      "/xpm/Preview_5110.xpm");
 200               break;
 201       case 6: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 202                                      "/xpm/Preview_6250.xpm");
 203               break;
 204       case 7: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 205                                      "/xpm/Preview_7110.xpm");
 206               break;
 207       default: file = g_strdup_printf("%s%s",xgnokiiConfig.xgnokiidir,
 208                                       "/xpm/Preview_6210.xpm");
 209               break;
 210     }
 211
 212   pixmap = gdk_pixmap_create_from_xpm(widget->window,&mask,
 213                                       &widget->style->bg[GTK_STATE_NORMAL],
 214                                       file);
 215   g_free(file);
 216
 217   return pixmap;
 218 }
 219
 220 /* ********************************************************
 221  * ** SET/CLEAR POINTS ************************************
 222  * ********************************************************
 223  */
 224 void SetPreviewPoint(GtkWidget *widget, int x, int y, int update) {
 225   if (!previewAvailable) return;
 226
 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) {
 230     x += PREVIEWJUMPX;
 231     y += PREVIEWJUMPY;
 232   }
 233
 234   /* draw point to pixmap */
 235   if (previewPixmap)
 236     gdk_draw_point(previewPixmap,widget->style->black_gc,
 237                    x+PREVIEWSTARTX,y+PREVIEWSTARTY);
 238
 239   if (update) {
 240     GdkRectangle updateRect;
 241
 242     /* update point on screen */
 243     updateRect.width = 1;
 244     updateRect.height = 1;
 245     updateRect.x = PREVIEWSTARTX+x;
 246     updateRect.y = PREVIEWSTARTY+y;
 247
 248     gtk_widget_draw(previewArea,&updateRect);
 249   }
 250 }
 251
 252 void ClearPreviewPoint(GtkWidget *widget, int x, int y, int update) {
 253   if (!previewAvailable) return;
 254
 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) {
 258     x += PREVIEWJUMPX;
 259     y += PREVIEWJUMPY;
 260   }
 261
 262   /* clean point from pixmap - any idea how to draw green point without pixmap? */
 263   if (previewPixmap)
 264     gdk_draw_pixmap(previewPixmap,
 265                     widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 266                     greenPixelPixmap,0,0,x+PREVIEWSTARTX,y+PREVIEWSTARTY,1,1);
 267   if (update) {
 268     GdkRectangle updateRect;
 269
 270     /* clean from screen too */
 271     updateRect.width = 1;
 272     updateRect.height = 1;
 273     updateRect.x = PREVIEWSTARTX+x;
 274     updateRect.y = PREVIEWSTARTY+y;
 275
 276     gtk_widget_draw(previewArea,&updateRect);
 277   }
 278 }
 279
 280 int IsPoint(int x, int y) {
 281   return GSM_IsPointBitmap(&bitmap,x,y);
 282 }
 283
 284 void SetPoint(GtkWidget *widget, int x, int y, int update) {
 285
 286   GSM_SetPointBitmap(&bitmap,x,y);
 287
 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);
 291
 292   if (update) {
 293     GdkRectangle updateRect;
 294
 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);
 300
 301     /* update on screen */
 302     gtk_widget_draw(drawingArea,&updateRect);
 303   }
 304
 305   /* draw preview point too */
 306   if (previewAvailable) SetPreviewPoint(widget,x,y,update);
 307 }
 308
 309 void ClearPoint(GtkWidget *widget, int x, int y, int update) {
 310
 311   GSM_ClearPointBitmap(&bitmap,x,y);
 312
 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);
 316
 317   if (update) {
 318     GdkRectangle updateRect;
 319
 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);
 325
 326     /* update on screen */
 327     gtk_widget_draw(drawingArea,&updateRect);
 328   }
 329
 330   /* clear point from previewArea too */
 331   if (previewAvailable) ClearPreviewPoint(widget,x,y,update);
 332 }
 333
 334 /* ****************************************************
 335  * *** UPDATES - PREVIEW & DRAWING AREAS **************
 336  * ****************************************************
 337  */
 338
 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;
 343
 344   if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
 345       bitmap.type != GSM_6210StartupLogo) {
 346     dx = PREVIEWJUMPX;
 347     dy = PREVIEWJUMPY;
 348   }
 349
 350   if (x1 > x2) {
 351     x = x1;
 352     x1 = x2;
 353     x2 = x;
 354   }
 355
 356   if (y1 > y2) {
 357     y = y1;
 358     y1 = y2;
 359     y2 = y;
 360   }
 361
 362   for (y = y1;y <= y2;y++)
 363     for (x = x1;x <= x2;x++) {
 364       if (IsPoint(x,y)) {
 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);
 369
 370         /* set on preview */
 371         if (previewAvailable && previewPixmap)
 372           gdk_draw_point(previewPixmap,previewArea->style->black_gc,
 373                          x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
 374       } else {
 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);
 379
 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,
 385                           1,1);
 386       }
 387     }
 388
 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);
 395   }
 396
 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);
 402 }
 403
 404 void UpdatePoints(GtkWidget *widget) {
 405   UpdatePointsRectangle(widget,0,0,bitmap.width-1,bitmap.height-1);
 406 }
 407
 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;
 412
 413   if (!previewPixmap || !previewAvailable) return;
 414
 415   if (bitmap.type != GSM_StartupLogo && bitmap.type != GSM_7110StartupLogo &&
 416       bitmap.type != GSM_6210StartupLogo) {
 417     dx = PREVIEWJUMPX;
 418     dy = PREVIEWJUMPY;
 419   }
 420
 421   for (y = 0;y < bitmap.height;y++)
 422     for (x = 0;x < bitmap.width;x++) {
 423       if (IsPoint(x,y)) {
 424         gdk_draw_point(previewPixmap,previewArea->style->black_gc,
 425                        x+PREVIEWSTARTX+dx,y+PREVIEWSTARTY+dy);
 426       } else {
 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);
 431       }
 432     }
 433
 434   updateRect.x = dx;
 435   updateRect.y = dy;
 436   updateRect.width = bitmap.width;
 437   updateRect.height = bitmap.height;
 438   gtk_widget_draw(previewArea,&updateRect);
 439 }
 440
 441 /* ******************************************************
 442  * **** DRAWING TOOLS ***********************************
 443  * ******************************************************
 444  */
 445
 446 /* TOOL - BRUSH */
 447 void ToolBrush(GtkWidget *widget, int column, int row, int button) {
 448   /* only this tool directly update bitmap & screen */
 449   if (button > 1)
 450     ClearPoint(widget,column,row,1);
 451   else
 452     SetPoint(widget,column,row,1);
 453 }
 454
 455 /* TOOL - LINE */
 456 /* going to rewrite to Bresenham algorithm */
 457 static void ToolLineUpdate(GtkWidget *widget, int column, int row) {
 458   double delta, y, x;
 459   int i, x1, y1, x2, y2;
 460
 461   if (abs(toolStartX-toolLastX) >= abs(toolStartY-toolLastY)) {
 462     if (toolStartX > toolLastX) {
 463       x1 = toolLastX;
 464       x2 = toolStartX;
 465       y1 = toolLastY;
 466       y2 = toolStartY;
 467     } else {
 468       x1 = toolStartX;
 469       x2 = toolLastX;
 470       y1 = toolStartY;
 471       y2 = toolLastY;
 472     }
 473
 474     delta = ((double)(y2-y1))/((double)(x2-x1));
 475     y = (double)y1;
 476     for (i = x1;i <= x2;i++) {
 477       if (!GSM_IsPointBitmap(&oldBitmap,i,(int)y)) ClearPoint(widget,i,(int)y,0);
 478       y += delta;
 479     }
 480   } else {
 481     if (toolStartY > toolLastY) {
 482       x1 = toolLastX;
 483       x2 = toolStartX;
 484       y1 = toolLastY;
 485       y2 = toolStartY;
 486     } else {
 487       x1 = toolStartX;
 488       x2 = toolLastX;
 489       y1 = toolStartY;
 490       y2 = toolLastY;
 491     }
 492     delta = ((double)(x2-x1))/((double)(y2-y1));
 493
 494     x = (double)x1;
 495     for (i = y1;i <= y2;i++) {
 496       if (!GSM_IsPointBitmap(&oldBitmap,(int)x,i)) ClearPoint(widget,(int)x,i,0);
 497       x += delta;
 498     }
 499   }
 500
 501   if (abs(toolStartX-column) >= abs(toolStartY-row)) {
 502     if (toolStartX > column) {
 503       x1 = column;
 504       x2 = toolStartX;
 505       y1 = row;
 506       y2 = toolStartY;
 507     } else {
 508       x1 = toolStartX;
 509       x2 = column;
 510       y1 = toolStartY;
 511       y2 = row;
 512     }
 513
 514     delta = ((double)(y2-y1))/((double)(x2-x1));
 515     y = (double)y1;
 516     for (i = x1;i <= x2;i++) {
 517       SetPoint(widget,i,(int)y,0);
 518       y += delta;
 519     }
 520   } else {
 521     if (toolStartY > row) {
 522       x1 = column;
 523       x2 = toolStartX;
 524       y1 = row;
 525       y2 = toolStartY;
 526     } else {
 527       x1 = toolStartX;
 528       x2 = column;
 529       y1 = toolStartY;
 530       y2 = row;
 531     }
 532
 533     delta = ((double)(x2-x1))/((double)(y2-y1));
 534
 535     x = (double)x1;
 536     for (i = y1;i <= y2;i++) {
 537       SetPoint(widget,(int)x,i,0);
 538       x += delta;
 539     }
 540   }
 541 }
 542
 543 /* TOOL - FILLED RECT */
 544 static void ToolFilledRectangleUpdate(GtkWidget *widget, int column, int row) {
 545   int i, j, x1, y1, x2, y2;
 546
 547   if (toolStartX > toolLastX) {
 548     x1 = toolLastX;
 549     x2 = toolStartX;
 550   } else {
 551     x1 = toolStartX;
 552     x2 = toolLastX;
 553   }
 554
 555   if (toolStartY > toolLastY) {
 556     y1 = toolLastY;
 557     y2 = toolStartY;
 558   } else {
 559     y1 = toolStartY;
 560     y2 = toolLastY;
 561   }
 562
 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);
 566
 567   if (toolStartX > column) {
 568     x1 = column;
 569     x2 = toolStartX;
 570   } else {
 571     x1 = toolStartX;
 572     x2 = column;
 573   }
 574
 575   if (toolStartY > row) {
 576     y1 = row;
 577     y2 = toolStartY;
 578   } else {
 579     y1 = toolStartY;
 580     y2 = row;
 581   }
 582
 583   for (j = y1;j <= y2;j++)
 584     for (i = x1;i <= x2;i++)
 585       SetPoint(widget,i,j,0);
 586 }
 587
 588 /* TOOL - RECTANGLE */
 589 static void ToolRectangleUpdate(GtkWidget *widget, int column, int row) {
 590   int i, j, x1, y1, x2, y2;
 591
 592   /* clear old rectangle */
 593   if (toolStartX > toolLastX) {
 594     x1 = toolLastX;
 595     x2 = toolStartX;
 596   } else {
 597     x1 = toolStartX;
 598     x2 = toolLastX;
 599   }
 600
 601   if (toolStartY > toolLastY) {
 602     y1 = toolLastY;
 603     y2 = toolStartY;
 604   } else {
 605     y1 = toolStartY;
 606     y2 = toolLastY;
 607   }
 608
 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);
 612   }
 613
 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);
 617   }
 618
 619   /* draw new rectangle */
 620   if (toolStartX > column) {
 621     x1 = column;
 622     x2 = toolStartX;
 623   } else {
 624     x1 = toolStartX;
 625     x2 = column;
 626   }
 627
 628   if (toolStartY > row) {
 629     y1 = row;
 630     y2 = toolStartY;
 631   } else {
 632     y1 = toolStartY;
 633     y2 = row;
 634   }
 635
 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);
 639   }
 640
 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);
 644   }
 645 }
 646
 647 static void UpdateToolScreen(GtkWidget *widget, int x1, int y1, int x2, int y2) {
 648   GdkRectangle updateRect;
 649
 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;
 657   }
 658   updateRect.width = x2-x1+1;
 659   updateRect.height = y2-y1+1;
 660   gtk_widget_draw(previewArea,&updateRect);
 661
 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);
 668 }
 669
 670 /* *************************************
 671  * ** PREVIEW AREA EVENTS **************
 672  * *************************************
 673  */
 674
 675 static gint PreviewAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
 676   previewPixmapNumber = (previewPixmapNumber % 8) + 1;
 677
 678   gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
 679                         previewPixmapWidth,previewPixmapHeight);
 680
 681   return TRUE;
 682 }
 683
 684 static gint PreviewAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
 685   if (previewPixmap) gdk_pixmap_unref(previewPixmap);
 686   previewPixmap = GetPreviewPixmap(widget);
 687
 688   UpdatePreviewPoints();
 689
 690   return TRUE;
 691 }
 692
 693 static gint PreviewAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
 694   /* got previewPixmap? */
 695   if (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);
 700
 701   return FALSE;
 702 }
 703
 704 /* ********************************
 705  * ** DRAWING AREA EVENTS *********
 706  * ********************************
 707  */
 708
 709 static gint DrawingAreaButtonPressEvent(GtkWidget *widget, GdkEventButton *event) {
 710   /* got drawingPixmap? */
 711   if (drawingPixmap == NULL) return TRUE;
 712
 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;
 720
 721       toolStartY = event->y / (POINTSIZE+1);
 722       if (toolStartY < 0) toolStartY = 0;
 723       if (toolStartY > bitmap.height-1) toolStartY = bitmap.height-1;
 724
 725       toolLastX = toolStartX;
 726       toolLastY = toolStartY;
 727
 728       /* store old bitmap for drawing, resp. for moving, resizing primitive */
 729       memcpy(&oldBitmap,&bitmap,sizeof(oldBitmap));
 730     }
 731
 732     if (event->button == 1) mouseButtonPushed = 1;
 733
 734     switch (activeTool) {
 735       case TOOL_BRUSH:
 736         ToolBrush(widget,toolStartX,toolStartY,event->button);
 737         break;
 738       case TOOL_LINE:
 739       case TOOL_RECTANGLE:
 740         if (event->button == 1) ToolBrush(widget,toolStartX,toolStartY,event->button);
 741         break;
 742     }
 743   }
 744
 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)
 748    */
 749   if (mouseButtonPushed && activeTool != TOOL_BRUSH && event->button != 1) {
 750     int lowestX, lowestY, highestX, highestY;
 751     int i, j;
 752
 753     lowestX  = GetMinFrom3(toolStartX,toolLastX,toolLastX);
 754     lowestY  = GetMinFrom3(toolStartY,toolLastY,toolLastY);
 755     highestX = GetMaxFrom3(toolStartX,toolLastX,toolLastX);
 756     highestY = GetMaxFrom3(toolStartY,toolLastY,toolLastY);
 757
 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);
 762         else
 763           ClearPoint(widget,i,j,0);
 764     UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
 765
 766     mouseButtonPushed = 0;
 767   }
 768
 769   return TRUE;
 770 }
 771
 772 static gint DrawingAreaButtonReleaseEvent(GtkWidget *widget, GdkEventButton *event) {
 773   if (event->button == 1)
 774     mouseButtonPushed = 0;
 775
 776   return TRUE;
 777 }
 778
 779 static gint DrawingAreaMotionNotifyEvent(GtkWidget *widget, GdkEventMotion *event) {
 780   int x,y;
 781   GdkModifierType state;
 782
 783   if (!mouseButtonPushed && activeTool != TOOL_BRUSH) return TRUE;
 784
 785   if (event->is_hint)
 786     gdk_window_get_pointer(event->window,&x,&y,&state);
 787   else {
 788     x = event->x;
 789     y = event->y;
 790     state = event->state;
 791   }
 792
 793   x = x / (POINTSIZE+1);
 794   y = y / (POINTSIZE+1);
 795   if (x < 0) x = 0;
 796   if (y < 0) y = 0;
 797   if (x > bitmap.width-1) x = bitmap.width-1;
 798   if (y > bitmap.height-1) y = bitmap.height-1;
 799
 800   if (y == toolLastY && x == toolLastX) return TRUE;
 801
 802   switch (activeTool) {
 803     case TOOL_BRUSH:
 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);
 807       break;
 808     case TOOL_RECTANGLE:
 809       if (drawingPixmap != NULL) ToolRectangleUpdate(widget,x,y);
 810       break;
 811     case TOOL_FILLED_RECTANGLE:
 812       if (drawingPixmap != NULL) ToolFilledRectangleUpdate(widget,x,y);
 813       break;
 814     case TOOL_LINE:
 815       if (drawingPixmap != NULL) ToolLineUpdate(widget,x,y);
 816       break;
 817   }
 818
 819   /* what is this?
 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)
 825    */
 826   if (activeTool != TOOL_BRUSH) {
 827     int lowestX, lowestY, highestX, highestY;
 828
 829     lowestX  = GetMinFrom3(toolStartX,toolLastX,x);
 830     lowestY  = GetMinFrom3(toolStartY,toolLastY,y);
 831     highestX = GetMaxFrom3(toolStartX,toolLastX,x);
 832     highestY = GetMaxFrom3(toolStartY,toolLastY,y);
 833
 834     UpdateToolScreen(widget,lowestX,lowestY,highestX,highestY);
 835   }
 836
 837   toolLastX = x;
 838   toolLastY = y;
 839   return TRUE;
 840 }
 841
 842 /* configureEvent? -> event when someone resize windows, ... */
 843 static gint DrawingAreaConfigureEvent(GtkWidget *widget, GdkEventConfigure *event) {
 844   int x, y;
 845   /* got drawingPixmap? */
 846   if (drawingPixmap) gdk_pixmap_unref(drawingPixmap); /* got, erase it */
 847
 848   /* make a new pixmap */
 849   drawingPixmap = gdk_pixmap_new(widget->window,drawingAreaWidth,
 850                   drawingAreaHeight,-1);
 851
 852   /* draw grid into pixmap */
 853   for (y = 0;y < bitmap.height;y++)
 854     for (x = 0;x < bitmap.width;x++)
 855       if (IsPoint(x,y))
 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);
 858       else
 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);
 861
 862   return TRUE;
 863 }
 864
 865 static gint DrawingAreaExposeEvent(GtkWidget *widget, GdkEventExpose *event) {
 866   /* got drawingPixmap? */
 867   if (drawingPixmap)
 868     /* got - draw it */
 869     gdk_draw_pixmap(widget->window,widget->style->fg_gc[GTK_WIDGET_STATE(widget)],
 870                     drawingPixmap,
 871                     event->area.x,event->area.y,event->area.x,event->area.y,
 872                     event->area.width,event->area.height);
 873   return FALSE;
 874 }
 875
 876 /* *****************************************
 877  * ** TOOLBAR & MENU EVENTS ****************
 878  * *****************************************
 879  */
 880
 881 static void GetNetworkInfoEvent(GtkWidget *widget) {
 882   GSM_Error error;
 883   PhoneEvent *e = (PhoneEvent *)g_malloc(sizeof(PhoneEvent));
 884   D_NetworkInfo *data = (D_NetworkInfo *)g_malloc(sizeof(D_NetworkInfo));
 885
 886   /* prepare data for event */
 887   data->info = &networkInfo;
 888   e->event = Event_GetNetworkInfo;
 889   e->data = data;
 890
 891   /* launch event and wait for result */
 892   GUI_InsertEvent(e);
 893   pthread_mutex_lock(&getNetworkInfoMutex);
 894   pthread_cond_wait(&getNetworkInfoCond,&getNetworkInfoMutex);
 895   pthread_mutex_unlock(&getNetworkInfoMutex);
 896   error = data->status;
 897   g_free(data);
 898
 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);
 904     g_free(buf);
 905   }
 906
 907   /* set new operator name to combo */
 908   gtk_entry_set_text(GTK_ENTRY(GTK_COMBO(networkCombo)->entry),
 909                GSM_GetNetworkName(networkInfo.NetworkCode));
 910 }
 911
 912 static void GetLogoEvent(GtkWidget *widget) {
 913   int i;
 914   GSM_Error error;
 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));
 918
 919   /* prepare data for event */
 920   strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
 921   data->bitmap = &bitmap;
 922   e->event = Event_GetBitmap;
 923   e->data = data;
 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;
 928   }
 929
 930   /* launch event and wait for result */
 931   GUI_InsertEvent(e);
 932   pthread_mutex_lock(&getBitmapMutex);
 933   pthread_cond_wait(&getBitmapCond,&getBitmapMutex);
 934   pthread_mutex_unlock(&getBitmapMutex);
 935   error = data->status;
 936   g_free(data);
 937
 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);
 943     g_free(buf);
 944   } else {
 945     /* no error, draw logo from phone */
 946     UpdatePoints(drawingArea);
 947   }
 948 }
 949
 950 static void SetLogoEvent(GtkWidget *widget) {
 951   GSM_Error error;
 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));
 955   int i;
 956
 957   /* prepare data */
 958   strncpy(bitmap.netcode,GSM_GetNetworkCode(operator),7);
 959
 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
 963      */
 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;
 968     }
 969   }
 970   if (bitmap.type == GSM_StartupLogo) {
 971     bitmap.number=0;
 972   }
 973
 974   data->bitmap = &bitmap;
 975   e->event = Event_SetBitmap;
 976   e->data = data;
 977
 978   /* launch event and wait for result */
 979   GUI_InsertEvent(e);
 980   pthread_mutex_lock(&setBitmapMutex);
 981   pthread_cond_wait(&setBitmapCond,&setBitmapMutex);
 982   pthread_mutex_unlock(&setBitmapMutex);
 983   error = data->status;
 984   g_free(data);
 985
 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);
 991     g_free(buf);
 992   }
 993 }
 994
 995 static void ClearLogoEvent(GtkWidget *widget) {
 996
 997   bitmap.size=GSM_GetBitmapSize(&bitmap);
 998
 999   GSM_ClearBitmap(&bitmap);
1000
1001   UpdatePoints(widget);
1002 }
1003
1004 static void InvertLogoEvent(GtkWidget *widget) {
1005   int column, row;
1006
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);
1011       else
1012         GSM_SetPointBitmap(&bitmap,column,row);
1013
1014   UpdatePoints(widget);
1015 }
1016
1017 static void UpLogoEvent(GtkWidget *widget) {
1018   int column, row;
1019
1020   GSM_Bitmap tbitmap;
1021
1022   tbitmap=bitmap;
1023
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);
1028       else
1029         GSM_ClearPointBitmap(&bitmap,column,row);
1030
1031   for (column = 0;column < bitmap.width;column++)
1032     if (GSM_IsPointBitmap(&tbitmap,column,0))
1033       GSM_SetPointBitmap(&bitmap,column,row);
1034     else
1035       GSM_ClearPointBitmap(&bitmap,column,row);
1036
1037   UpdatePoints(widget);
1038 }
1039
1040 static void DownLogoEvent(GtkWidget *widget) {
1041   int column, row;
1042
1043   GSM_Bitmap tbitmap;
1044
1045   tbitmap=bitmap;
1046
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);
1051       else
1052         GSM_ClearPointBitmap(&bitmap,column,row);
1053
1054   for (column = 0;column < bitmap.width;column++)
1055     if (GSM_IsPointBitmap(&tbitmap,column,bitmap.height-1))
1056       GSM_SetPointBitmap(&bitmap,column,0);
1057     else
1058       GSM_ClearPointBitmap(&bitmap,column,0);
1059
1060   UpdatePoints(widget);
1061 }
1062
1063 static void LeftLogoEvent(GtkWidget *widget) {
1064   int column, row;
1065
1066   GSM_Bitmap tbitmap;
1067
1068   tbitmap=bitmap;
1069
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);
1074       else
1075         GSM_ClearPointBitmap(&bitmap,column,row);
1076
1077   for (row = 0;row < bitmap.height;row++)
1078     if (GSM_IsPointBitmap(&tbitmap,0,row))
1079       GSM_SetPointBitmap(&bitmap,bitmap.width-1,row);
1080     else
1081       GSM_ClearPointBitmap(&bitmap,bitmap.width-1,row);
1082
1083   UpdatePoints(widget);
1084 }
1085
1086 static void RightLogoEvent(GtkWidget *widget) {
1087   int column, row;
1088
1089   GSM_Bitmap tbitmap;
1090
1091   tbitmap=bitmap;
1092
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);
1097       else
1098         GSM_ClearPointBitmap(&bitmap,column,row);
1099
1100   for (row = 0;row < bitmap.height;row++)
1101     if (GSM_IsPointBitmap(&tbitmap,bitmap.width-1,row))
1102       GSM_SetPointBitmap(&bitmap,0,row);
1103     else
1104       GSM_ClearPointBitmap(&bitmap,0,row);
1105
1106   UpdatePoints(widget);
1107 }
1108
1109 static void FlipVerticalLogoEvent(GtkWidget *widget) {
1110   int row, column, temp;
1111
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);
1117       else
1118         GSM_ClearPointBitmap(&bitmap,column,row);
1119
1120       if (temp)
1121         GSM_SetPointBitmap(&bitmap,column,bitmap.height-1-row);
1122       else
1123         GSM_ClearPointBitmap(&bitmap,column,bitmap.height-1-row);
1124     }
1125
1126   UpdatePoints(widget);
1127 }
1128
1129 static void FlipHorizontalLogoEvent(GtkWidget *widget) {
1130   int row, column, temp;
1131
1132   for (row = 0;row < bitmap.height;row++)
1133     for (column = 0;column < (bitmap.width/2);column++) {
1134       temp = IsPoint(column,row);
1135
1136       if (IsPoint(bitmap.width-1-column,row))
1137         GSM_SetPointBitmap(&bitmap,column,row);
1138       else
1139         GSM_ClearPointBitmap(&bitmap,column,row);
1140
1141       if (temp)
1142         GSM_SetPointBitmap(&bitmap,bitmap.width-1-column,row);
1143       else
1144         GSM_ClearPointBitmap(&bitmap,bitmap.width-1-column,row);
1145     }
1146
1147   UpdatePoints(widget);
1148 }
1149
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;
1157
1158   return 0;
1159 }
1160
1161 /* this is launched when logo type was change by buttons on toolbar */
1162 static gint LogoTypeEvent(GtkWidget *widget) {
1163   int clear = 0;
1164
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 */
1170     clear = 1;
1171
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);
1176     } else {
1177       GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
1178     }
1179   }
1180
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 */
1184     clear = 1;
1185     GSM_ResizeBitmap(&bitmap,GSM_PictureImage);
1186   }
1187
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);
1193   }
1194
1195   /* is new type operatorLogo? */
1196   if (GTK_TOGGLE_BUTTON(buttonOperator)->active && bitmap.type != GSM_OperatorLogo &&
1197       bitmap.type != GSM_7110OperatorLogo) {
1198
1199     /* previous startup or Picture ? clear and draw batteries, signal, ... */
1200     if (bitmap.type != GSM_CallerLogo) clear = 1;
1201
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);
1206     } else {
1207       GSM_ResizeBitmap(&bitmap,GSM_OperatorLogo);
1208     }
1209   }
1210
1211   /* must clear? */
1212   if (clear) {
1213     if (previewAvailable) {
1214       /* configure event reload pixmap from disk and redraws */
1215       gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1216                             previewPixmapWidth,previewPixmapHeight);
1217     }
1218
1219     /* change new drawingArea size */
1220     drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1221     drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1222
1223     gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1224                           drawingAreaWidth,drawingAreaHeight);
1225   }
1226
1227   return 0;
1228 }
1229
1230 static inline void CloseLogosWindow (void) {
1231   gtk_widget_hide(GUI_LogosWindow);
1232 }
1233
1234 void ExportLogoFileMain(gchar *name)
1235 {
1236   GSM_Bitmap tbitmap;
1237   GSM_Error error;
1238
1239   tbitmap=bitmap;
1240
1241   strncpy(tbitmap.netcode,GSM_GetNetworkCode(networkInfo.NetworkCode),7);
1242
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);
1248     g_free(buf);
1249   }
1250 }
1251
1252 static void YesLogoFileExportDialog (GtkWidget *w, gpointer data)
1253 {
1254   gtk_widget_hide (GTK_WIDGET (data));
1255   ExportLogoFileMain(exportDialogData.fileName);
1256 }
1257
1258 static void ExportFileSelected (GtkWidget *w, GtkFileSelection *fs)
1259 {
1260   static YesNoDialog dialog = { NULL, NULL};
1261   FILE *f;
1262   gchar err[80];
1263
1264   exportDialogData.fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1265   gtk_widget_hide (GTK_WIDGET (fs));
1266
1267   if ((f = fopen (exportDialogData.fileName, "r")) != NULL)
1268   {
1269     fclose (f);
1270     if (dialog.dialog == NULL)
1271     {
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);
1276     }
1277     gtk_widget_show (dialog.dialog);
1278   }
1279   else
1280     ExportLogoFileMain(exportDialogData.fileName);
1281 }
1282
1283 void ImportFileSelected(GtkWidget *w, GtkFileSelection *fs)
1284 {
1285   GSM_Bitmap tbitmap;
1286   GSM_Error error=0;
1287
1288   gchar *fileName;
1289   FILE *f;
1290
1291   fileName = gtk_file_selection_get_filename (GTK_FILE_SELECTION (fs));
1292   gtk_widget_hide (GTK_WIDGET (fs));
1293
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);
1298     g_free(buf);
1299     return;
1300   }
1301
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);
1307     g_free(buf);
1308     return;
1309   }
1310
1311   exportDialogData.fileName=fileName;
1312
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);
1317
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);
1322
1323   memcpy(&bitmap,&tbitmap,sizeof(GSM_Bitmap));
1324
1325   if (!strcmp(xgnokiiConfig.model,"7110")) { //7110
1326     if (bitmap.type==GSM_StartupLogo || bitmap.type==GSM_6210StartupLogo)
1327       GSM_ResizeBitmap(&bitmap,GSM_7110StartupLogo);
1328
1329     if (bitmap.type==GSM_OperatorLogo)
1330       GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1331
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);
1335
1336     if (bitmap.type==GSM_OperatorLogo)
1337       GSM_ResizeBitmap(&bitmap,GSM_7110OperatorLogo);
1338
1339   } else {
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);
1344   }
1345
1346   UpdatePoints(drawingArea);
1347 }
1348
1349 void SaveLogoAs(GtkWidget *widget)
1350 {
1351   FileSelection=gtk_file_selection_new ("Save logo as ...");
1352
1353   gtk_signal_connect (
1354         GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1355         "clicked", (GtkSignalFunc) ExportFileSelected, FileSelection);
1356
1357   gtk_signal_connect_object (
1358         GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1359         "clicked", (GtkSignalFunc) gtk_widget_destroy,
1360         GTK_OBJECT (FileSelection));
1361
1362   gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1363
1364   gtk_widget_show(FileSelection);
1365 }
1366
1367 void SaveLogo(GtkWidget *widget)
1368 {
1369   if (exportDialogData.fileName==NULL) {
1370     SaveLogoAs(widget);
1371   } else {
1372     ExportLogoFileMain(exportDialogData.fileName);
1373   }
1374 }
1375
1376 void OpenLogo(GtkWidget *widget)
1377 {
1378   FileSelection=gtk_file_selection_new ("Open logo...");
1379
1380   gtk_signal_connect (
1381         GTK_OBJECT (GTK_FILE_SELECTION (FileSelection)->ok_button),
1382         "clicked", (GtkSignalFunc) ImportFileSelected, FileSelection);
1383
1384   gtk_signal_connect_object (
1385         GTK_OBJECT(GTK_FILE_SELECTION(FileSelection)->cancel_button),
1386         "clicked", (GtkSignalFunc) gtk_widget_destroy,
1387         GTK_OBJECT (FileSelection));
1388
1389   gtk_file_selection_hide_fileop_buttons(GTK_FILE_SELECTION(FileSelection));
1390
1391   gtk_widget_show(FileSelection);
1392 }
1393
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},
1416 };
1417
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"));
1440 }
1441
1442 void GUI_CreateLogosWindow (void) {
1443   int nMenuItems = sizeof (logosMenuItems) / sizeof (logosMenuItems[0]);
1444   GtkAccelGroup *accelGroup;
1445   GtkItemFactory *itemFactory;
1446   GtkWidget *menuBar;
1447   GtkWidget *toolBar, *vertToolBar;
1448   GtkWidget *vbox;
1449   GtkWidget *hbox;
1450   GtkWidget *drawingBox;
1451   GtkWidget *separator;
1452   GdkBitmap *mask;
1453
1454   GList *glistNetwork = NULL;
1455
1456   int i = 0;
1457
1458   previewPixmapWidth = PREVIEWWIDTH;
1459   previewPixmapHeight = PREVIEWHEIGHT;
1460
1461   InitLogosMenu();
1462
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);
1470
1471   CreateErrorDialog(&errorDialog,GUI_LogosWindow);
1472   CreateInfoDialog(&infoDialog,GUI_LogosWindow);
1473
1474   accelGroup = gtk_accel_group_new();
1475   gtk_accel_group_attach(accelGroup,GTK_OBJECT(GUI_LogosWindow));
1476
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);
1481
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>");
1485
1486   gtk_box_pack_start(GTK_BOX(vbox),menuBar,FALSE,FALSE,0);
1487   gtk_widget_show(menuBar);
1488
1489   /* toolbar */
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);
1493
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);
1498
1499   gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1500
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);
1505
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);
1510
1511   gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1512
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);
1518
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);
1524
1525   buttonCaller = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1526                  GTK_TOOLBAR_CHILD_RADIOBUTTON,
1527                  buttonOperator,
1528                  NULL,"Caller logo",
1529                  "",NewPixmap(Caller_logo_xpm,GUI_LogosWindow->window,
1530                  &GUI_LogosWindow->style->bg[GTK_STATE_NORMAL]),
1531                  GTK_SIGNAL_FUNC(LogoTypeEvent),NULL);
1532
1533   buttonPicture = gtk_toolbar_append_element(GTK_TOOLBAR(toolBar),
1534                   GTK_TOOLBAR_CHILD_RADIOBUTTON,
1535                   buttonOperator,
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);
1540
1541   gtk_toolbar_append_space(GTK_TOOLBAR(toolBar));
1542
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);
1553
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);
1558
1559   gtk_box_pack_start(GTK_BOX(vbox),toolBar,FALSE,FALSE,0);
1560   gtk_widget_show(toolBar);
1561
1562   /* vertical separator */
1563   separator = gtk_hseparator_new();
1564   gtk_box_pack_start(GTK_BOX(vbox),GTK_WIDGET(separator),FALSE,FALSE,0);
1565
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);
1570
1571   /* set GSM_Bitmap width,height needed for creating drawinArea
1572    * we are starting, default is startupLogo
1573    */
1574   bitmap.type = GSM_7110StartupLogo;
1575   bitmap.height = 65;
1576   bitmap.width = 96;
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);
1582   } else {
1583     GSM_ResizeBitmap(&bitmap,GSM_StartupLogo);
1584   }
1585   drawingAreaWidth = bitmap.width * (POINTSIZE+1)+1;
1586   drawingAreaHeight = bitmap.height * (POINTSIZE+1)+1;
1587
1588   /* previewArea */
1589   previewPixmap = GetPreviewPixmap(GUI_LogosWindow);
1590
1591   if (previewPixmap != NULL) {
1592     previewArea = gtk_drawing_area_new();
1593     gtk_drawing_area_size(GTK_DRAWING_AREA(previewArea),
1594                           previewPixmapWidth,previewPixmapHeight);
1595
1596     greenPixelPixmap = gdk_pixmap_create_from_xpm_d(GUI_LogosWindow->window,
1597                        &mask,&GUI_LogosWindow->style->bg[GTK_STATE_NORMAL],
1598                        Green_pixel_xpm);
1599
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);
1606
1607     gtk_widget_set_events(previewArea,GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK );
1608
1609     gtk_box_pack_start(GTK_BOX(hbox),previewArea,FALSE,FALSE,0);
1610     gtk_widget_show(previewArea);
1611
1612     /* clear battery, signal, menu & names from preview phone */
1613     UpdatePreviewPoints ();
1614
1615   } else previewAvailable = 0;
1616
1617   /* drawingArea */
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);
1622
1623   drawingBox = gtk_vbox_new(FALSE,3);
1624   gtk_box_pack_start(GTK_BOX(hbox),drawingBox,FALSE,FALSE,0);
1625   gtk_widget_show(drawingBox);
1626
1627   drawingArea = gtk_drawing_area_new();
1628   gtk_drawing_area_size(GTK_DRAWING_AREA(drawingArea),
1629                   drawingAreaWidth,drawingAreaHeight);
1630
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);
1641
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);
1645
1646   gtk_box_pack_start(GTK_BOX(drawingBox),drawingArea,FALSE,FALSE,0);
1647   gtk_widget_show(drawingArea);
1648
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);
1653
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);
1659
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);
1665
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);
1671
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);
1679
1680   gtk_toolbar_append_space(GTK_TOOLBAR(vertToolBar));
1681
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);
1686
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);
1691
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);
1696
1697
1698   gtk_box_pack_start(GTK_BOX(hbox),vertToolBar,FALSE,FALSE,0);
1699   gtk_widget_show(vertToolBar);
1700
1701   GUIEventAdd(GUI_EVENT_CALLERS_GROUPS_CHANGED,&GUI_RefreshLogosGroupsCombo);
1702 }
1703
1704 void GUI_RefreshLogosGroupsCombo (void) {
1705   GList *callerList = NULL;
1706   int i;
1707
1708   for (i = 0;i < 6;i++)
1709     callerList = g_list_insert(callerList,xgnokiiConfig.callerGroups[i],i);
1710
1711   gtk_combo_set_popdown_strings(GTK_COMBO(callerCombo),callerList);
1712   g_list_free(callerList);
1713
1714   if (!callersGroupsInitialized) callersGroupsInitialized = 1;
1715 }
1716
1717 void GUI_ShowLogosWindow (void) {
1718
1719   gtk_widget_show(buttonCaller);
1720   gtk_widget_show(callerCombo);
1721
1722   if (xgnokiiConfig.callerGroups[0] == NULL) {
1723     GUI_Refresh();
1724     GUI_InitCallerGroupsInf ();
1725   }
1726
1727   if (!callersGroupsInitialized) GUI_RefreshLogosGroupsCombo ();
1728
1729   gtk_widget_show(GUI_LogosWindow);
1730
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);
1735     g_free(buf);
1736
1737     showPreviewErrorDialog = 0;
1738   }
1739 }