apply misc fixes from Markus Fischer and Rambetter
[xonotic/netradiant.git] / radiant / gtkmisc.cpp
1 /*
2 Copyright (c) 2001, Loki software, inc.
3 All rights reserved.
4
5 Redistribution and use in source and binary forms, with or without modification,
6 are permitted provided that the following conditions are met:
7
8 Redistributions of source code must retain the above copyright notice, this list
9 of conditions and the following disclaimer.
10
11 Redistributions in binary form must reproduce the above copyright notice, this
12 list of conditions and the following disclaimer in the documentation and/or
13 other materials provided with the distribution.
14
15 Neither the name of Loki software nor the names of its contributors may be used
16 to endorse or promote products derived from this software without specific prior
17 written permission.
18
19 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
20 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
23 DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
24 (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
25 LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
26 ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
28 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29 */
30
31 //
32 // Small functions to help with GTK
33 //
34
35 #include <gdk/gdkkeysyms.h>
36 #include <glib/gi18n.h>
37
38 #if defined (__linux__) || defined (__APPLE__)
39 #include <unistd.h>
40 #endif
41
42 #include <gtk/gtk.h>
43
44 #ifdef _WIN32
45 #include <gdk/gdkwin32.h>
46 #define WIN32_LEAN_AND_MEAN
47 #include <windows.h>
48 #endif
49
50
51
52 #ifdef _WIN32
53 #include <io.h>
54 #include <direct.h>
55 #define R_OK 04
56 #endif
57 #include "stdafx.h"
58
59 // =============================================================================
60 // Misc stuff
61
62 // NOTE TTimo window position saving has always been tricky
63 //   it doesn't work the same between win32 and linux .. see below that code is fairly different
64 //   it's also very poorly done, the save calls are a bit randomly disctributed in the OnDestroy
65
66 void save_window_pos (GtkWidget *wnd, window_position_t& pos)
67 {
68   if ((wnd == NULL) || (wnd->window == NULL))
69     return;
70
71   get_window_pos(wnd, &pos.x, &pos.y);
72
73   pos.w = wnd->allocation.width;
74   pos.h = wnd->allocation.height;
75
76 #ifdef DBG_WINDOWPOS
77   //Sys_Printf("save_window_pos 'Window %s'\n",buf);
78 #endif
79 }
80
81 #ifdef _WIN32
82 void win32_get_window_pos(GtkWidget *widget, gint *x, gint *y)
83 {
84   if ( g_PrefsDlg.m_bStartOnPrimMon ) {
85     RECT rc;
86     POINT point;
87     HWND xwnd = (HWND)GDK_WINDOW_HWND (widget->window);
88     const GdkRectangle primaryMonitorRect = g_pParentWnd->GetPrimaryMonitorRect();
89
90     GetClientRect(xwnd,&rc);
91     point.x=rc.left;
92     point.y=rc.top;
93     ClientToScreen(xwnd,&point);
94
95     *x=point.x;
96     *y=point.y;
97
98     *x=max(*x,-widget->allocation.width+10);
99     *x=min(*x,primaryMonitorRect.width-10);
100     *y=max(*y,-widget->allocation.height+10);
101     *y=min(*y,primaryMonitorRect.height-10);
102   } else {
103     // this is the same as the unix version of get_window_pos
104     gdk_window_get_root_origin (widget->window, x, y);
105   }
106 #ifdef DBG_WINDOWPOS
107   Sys_Printf("win32_get_window_pos %p %d,%d\n",widget,*x,*y);
108 #endif
109 }
110 #endif
111
112 void load_window_pos (GtkWidget *wnd, window_position_t& pos)
113 {
114 #ifdef _WIN32
115   const GdkRectangle primaryMonitorRect = g_pParentWnd->GetPrimaryMonitorRect();
116
117   if(pos.x < primaryMonitorRect.x
118     || pos.y < primaryMonitorRect.y
119     || pos.x > primaryMonitorRect.x + primaryMonitorRect.width
120     || pos.y > primaryMonitorRect.y + primaryMonitorRect.height)
121     gtk_window_set_position(GTK_WINDOW(wnd), GTK_WIN_POS_CENTER_ON_PARENT);
122 #else
123   // FIXME: not multihead safe
124   if(pos.x < 0
125     || pos.y < 0
126     || pos.x > gdk_screen_width ()
127     || pos.y > gdk_screen_height ())
128     gtk_window_set_position(GTK_WINDOW(wnd), GTK_WIN_POS_CENTER_ON_PARENT);
129 #endif
130   else
131     gtk_window_move(GTK_WINDOW(wnd), pos.x, pos.y);
132
133   gtk_window_set_default_size (GTK_WINDOW (wnd), pos.w, pos.h);
134 #ifdef DBG_WINDOWPOS
135   Sys_Printf("load_window_pos %p 'Window,%s'\n",wnd,windowData);
136 #endif
137 }
138
139 gint widget_delete_hide (GtkWidget *widget)
140 {
141   gtk_widget_hide (widget);
142
143   return TRUE;
144 }
145
146
147 // Thanks to Mercury, Fingolfin - ETG
148 int readLongLE(FILE *file, unsigned long *m_bytesRead, int *value)
149 {
150   byte buf[4];
151   int len = fread(buf, 4, 1, file);
152   *m_bytesRead += 4;
153   if (len != 1)
154     return -1;
155
156   *value = buf[0] | buf[1] << 8 | buf[2] << 16 | buf[3] << 24;
157   return 0;
158 }
159
160 short readShortLE(FILE *file, unsigned long *m_bytesRead, short unsigned *value)
161 {
162   byte buf[2];
163   int len = fread(buf, 2, 1, file);
164   *m_bytesRead += 2;
165   if (len != 1)
166     return -1;
167
168   *value = buf[0] | buf[1] << 8;
169   return 0;
170 }
171
172 unsigned char *load_bitmap_file (const char* filename, guint16 *width, guint16 *height)
173 {
174   int bmWidth, bmHeight;
175   short unsigned bmPlanes, bmBitsPixel;
176   typedef struct {
177     unsigned char rgbBlue;
178     unsigned char rgbGreen;
179     unsigned char rgbRed;
180     unsigned char rgbReserved;
181   } RGBQUAD;
182   unsigned char m1,m2;
183   int sizeimage;
184   short unsigned res1,res2;
185   int filesize, pixoff;
186   int bmisize, compression;
187   int xscale, yscale;
188   int colors, impcol;
189   unsigned long m_bytesRead = 0;
190   unsigned char *imagebits = NULL;
191   FILE *fp;
192
193   *width = *height = 0;
194
195   fp = fopen(filename,"rb");
196   if (fp == NULL)
197   {
198         return NULL;
199   }
200
201   size_t rc;
202   rc = fread(&m1, 1, 1, fp);
203   m_bytesRead++;
204   if (rc == -1)
205   {
206       fclose(fp);
207       return NULL;
208   }
209
210   rc = fread(&m2, 1, 1, fp);
211   m_bytesRead++;
212   if ((m1!='B') || (m2!='M'))
213   {
214       fclose(fp);
215       return NULL;
216   }
217
218   if (readLongLE(fp,&m_bytesRead,&filesize)) {
219         fclose(fp);
220         return NULL;
221   }
222
223   if (readShortLE(fp,&m_bytesRead,&res1)) {
224         fclose(fp);
225         return NULL;
226   }
227
228   if (readShortLE(fp,&m_bytesRead,&res2)) {
229         fclose(fp);
230         return NULL;
231   }
232
233   if (readLongLE(fp,&m_bytesRead,&pixoff)) {
234         fclose(fp);
235         return NULL;
236   }
237
238   if (readLongLE(fp,&m_bytesRead,&bmisize)) {
239         fclose(fp);
240         return NULL;
241   }
242
243   if (readLongLE(fp,&m_bytesRead,&bmWidth)) {
244         fclose(fp);
245         return NULL;
246   }
247
248   if (readLongLE(fp,&m_bytesRead,&bmHeight)) {
249         fclose(fp);
250         return NULL;
251   }
252
253   if (readShortLE(fp,&m_bytesRead,&bmPlanes)) {
254         fclose(fp);
255         return NULL;
256   }
257
258   if (readShortLE(fp,&m_bytesRead,&bmBitsPixel)) {
259         fclose(fp);
260         return NULL;
261   }
262
263   if (readLongLE(fp,&m_bytesRead,&compression)) {
264         fclose(fp);
265         return NULL;
266   }
267
268   if (readLongLE(fp,&m_bytesRead,&sizeimage)) {
269         fclose(fp);
270         return NULL;
271   }
272
273   if (readLongLE(fp,&m_bytesRead,&xscale)) {
274         fclose(fp);
275         return NULL;
276   }
277
278   if (readLongLE(fp,&m_bytesRead,&yscale)) {
279         fclose(fp);
280         return NULL;
281   }
282
283   if (readLongLE(fp,&m_bytesRead,&colors)) {
284         fclose(fp);
285         return NULL;
286   }
287
288   if (readLongLE(fp,&m_bytesRead,&impcol)) {
289         fclose(fp);
290         return NULL;
291   }
292
293   if (colors == 0)
294     colors = 1 << bmBitsPixel;
295
296   RGBQUAD *colormap = NULL;
297   if (bmBitsPixel != 24)
298   {
299         colormap = new RGBQUAD[colors];
300         if (colormap == NULL)
301         {
302           fclose(fp);
303           return NULL;
304         }
305
306         int i;
307         for (i = 0; i < colors; i++)
308         {
309           unsigned char r ,g, b, dummy;
310
311           rc = fread(&b, 1, 1, fp);
312           m_bytesRead++;
313           if (rc!=1)
314           {
315                 delete [] colormap;
316                 fclose(fp);
317                 return NULL;
318           }
319
320           rc = fread(&g, 1, 1, fp);
321           m_bytesRead++;
322           if (rc!=1)
323           {
324                 delete [] colormap;
325                 fclose(fp);
326                 return NULL;
327           }
328
329           rc = fread(&r, 1, 1, fp);
330           m_bytesRead++;
331           if (rc != 1)
332           {
333                 delete [] colormap;
334                 fclose(fp);
335                 return NULL;
336           }
337
338           rc = fread(&dummy, 1, 1, fp);
339           m_bytesRead++;
340           if (rc != 1)
341           {
342                 delete [] colormap;
343                 fclose(fp);
344                 return NULL;
345           }
346
347           colormap[i].rgbRed=r;
348           colormap[i].rgbGreen=g;
349           colormap[i].rgbBlue=b;
350     }
351   }
352
353   if ((long)m_bytesRead > pixoff)
354   {
355         delete [] colormap;
356         fclose(fp);
357         return NULL;
358   }
359
360   while ((long)m_bytesRead < pixoff)
361   {
362         char dummy;
363         fread(&dummy,1,1,fp);
364         m_bytesRead++;
365   }
366
367   int w = bmWidth;
368   int h = bmHeight;
369
370   // set the output params
371   imagebits = (unsigned char *)malloc(w * h * 3);
372   long row_size = w * 3;
373
374   if (imagebits != NULL)
375   {
376           *width = w;
377           *height = h;
378           unsigned char *outbuf = imagebits;
379           long row = 0;
380           long rowOffset = 0;
381
382           if (compression == 0) // BI_RGB
383     {
384             // read rows in reverse order
385             for (row = bmHeight - 1; row >= 0; row--)
386             {
387                     // which row are we working on?
388                     rowOffset = (long unsigned)row * row_size;
389
390                     if (bmBitsPixel == 24)
391                     {
392                       for (int col=0;col<w;col++)
393                       {
394                             long offset = col * 3;
395                             char pixel[3];
396
397                             if (fread((void *)(pixel),1,3,fp) == 3)
398                             {
399                               // we swap red and blue here
400                               *(outbuf + rowOffset + offset + 0) = pixel[2];  // r
401                               *(outbuf + rowOffset + offset + 1) = pixel[1];  // g
402                               *(outbuf + rowOffset + offset + 2) = pixel[0];  // b
403                             }
404               }
405                       m_bytesRead += row_size;
406
407                       // read DWORD padding
408                       while ((m_bytesRead - pixoff) & 3)
409                       {
410                               char dummy;
411                               if (fread(&dummy,1,1,fp) != 1)
412             {
413                           free(imagebits);
414                           fclose(fp);
415                           return NULL;
416             }
417                               m_bytesRead++;
418           }
419         }
420         else
421         {
422                       // pixels are packed as 1 , 4 or 8 bit vals. need to unpack them
423                       int bit_count = 0;
424                       unsigned long mask = (1 << bmBitsPixel) - 1;
425                       unsigned char inbyte = 0;
426
427                       for (int col = 0; col < w; col++)
428           {
429                         int pix = 0;
430
431                         // if we need another byte
432                         if (bit_count <= 0)
433                               {
434                                 bit_count = 8;
435                                 if (fread(&inbyte,1,1,fp) != 1)
436                                 {
437                                         free(imagebits);
438                                         delete [] colormap;
439                                         fclose(fp);
440                                         return NULL;
441                                 }
442                                 m_bytesRead++;
443                               }
444
445                               // keep track of where we are in the bytes
446                               bit_count -= bmBitsPixel;
447                               pix = ( inbyte >> bit_count) & mask;
448
449                               // lookup the color from the colormap - stuff it in our buffer
450                               // swap red and blue
451                               *(outbuf + rowOffset + col * 3 + 2) = colormap[pix].rgbBlue;
452                               *(outbuf + rowOffset + col * 3 + 1) = colormap[pix].rgbGreen;
453                               *(outbuf + rowOffset + col * 3 + 0) = colormap[pix].rgbRed;
454           }
455
456                       // read DWORD padding
457                       while ((m_bytesRead - pixoff) & 3)
458           {
459             char dummy;
460             if (fread(&dummy,1,1,fp)!=1)
461             {
462               free(imagebits);
463               if (colormap)
464                 delete [] colormap;
465               fclose(fp);
466               return NULL;
467             }
468             m_bytesRead++;
469           }
470         }
471       }
472     }
473           else
474           {
475             int i, x = 0;
476             unsigned char c, c1 = 0, *pp;
477             row = 0;
478             pp = outbuf + (bmHeight - 1) * bmWidth * 3;
479
480             if (bmBitsPixel == 8)
481             {
482                     while (row < bmHeight)
483                     {
484                       c = getc(fp);
485
486                       if (c)
487                       {
488                               // encoded mode
489                               c1 = getc(fp);
490                               for (i = 0; i < c; x++, i++)
491                               {
492                                 *pp = colormap[c1].rgbRed; pp++;
493                                 *pp = colormap[c1].rgbGreen; pp++;
494                                 *pp = colormap[c1].rgbBlue; pp++;
495                               }
496                       }
497                       else
498                       {
499                               // c==0x00,  escape codes
500                               c = getc(fp);
501                               if (c == 0x00) // end of line
502                               {
503                                 row++;
504                                 x = 0;
505                                 pp = outbuf + (bmHeight - row - 1) * bmWidth * 3;
506                               }
507                               else if (c == 0x01)
508                                 break; // end of pic
509                               else if (c == 0x02) // delta
510                               {
511                                 c = getc(fp);
512                                 x += c;
513                                 c = getc(fp);
514                                 row += c;
515                                 pp = outbuf + x*3 + (bmHeight - row - 1) * bmWidth * 3;
516                               }
517                               else // absolute mode
518                               {
519                                 for (i = 0; i < c; x++, i++)
520                                 {
521                                         c1 = getc(fp);
522                                         *pp = colormap[c1].rgbRed; pp++;
523                                         *pp = colormap[c1].rgbGreen; pp++;
524                                         *pp = colormap[c1].rgbBlue; pp++;
525                                 }
526
527                                 if (c & 1)
528                                       getc(fp); // odd length run: read an extra pad byte
529                               }
530                       }
531                     }
532             }
533             else if (bmBitsPixel == 4)
534             {
535                     while (row < bmHeight)
536                     {
537                       c = getc(fp);
538
539                       if (c)
540                       {
541                               // encoded mode
542                               c1 = getc(fp);
543                               for (i = 0; i < c; x++, i++)
544                               {
545                                 *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbRed; pp++;
546                                 *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbGreen; pp++;
547                                 *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbBlue; pp++;
548                               }
549                       }
550                       else
551                       {
552                               // c==0x00,  escape codes
553                               c = getc(fp);
554
555                               if (c == 0x00) // end of line
556                               {
557                                 row++;
558                                 x = 0;
559                                 pp = outbuf + (bmHeight - row - 1) * bmWidth * 3;
560                               }
561                               else if (c == 0x01)
562                                 break; // end of pic
563                               else if (c == 0x02) // delta
564                               {
565                                 c = getc(fp);
566                                 x += c;
567                                 c = getc(fp);
568                                 row += c;
569                                 pp = outbuf + x * 3 + (bmHeight - row - 1) * bmWidth * 3;
570                               }
571                               else // absolute mode
572                               {
573                                 for (i = 0; i < c; x++, i++)
574                                 {
575                                         if ((i&1) == 0)
576                                           c1 = getc(fp);
577                                         *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbRed; pp++;
578                                         *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbGreen; pp++;
579                                         *pp = colormap[(i&1) ? (c1 & 0x0f) : ((c1>>4)&0x0f)].rgbBlue; pp++;
580                                 }
581
582                                 if (((c & 3) == 1) || ((c & 3) == 2))
583                                       getc(fp); // odd length run: read an extra pad byte
584             }
585           }
586                     }
587             }
588           }
589           if (colormap)
590             delete [] colormap;
591
592           fclose(fp);
593   }
594   return imagebits;
595 }
596
597 void bmp_to_pixmap (const char* filename, GdkPixmap **pixmap, GdkBitmap **mask)
598 {
599   guint16 width, height;
600   unsigned char *buf;
601   GdkWindow *window = gdk_get_default_root_window();
602   GdkColormap *colormap;
603   GdkGC* gc = gdk_gc_new (window);
604   int i, j;
605   bool hasMask = false;
606
607   *pixmap = *mask = NULL;
608   buf = load_bitmap_file (filename, &width, &height);
609   if (!buf)
610     return;
611
612   colormap = gdk_drawable_get_colormap (window);
613   *pixmap = gdk_pixmap_new (window, width, height, -1);
614
615   typedef struct
616   {
617     GdkColor c;
618     unsigned char *p;
619   } PAL;
620
621   for (i = 0; i < height; i++)
622   {
623     for (j = 0; j < width; j++)
624     {
625       unsigned char *p = &buf[(i * width + j) * 3];
626       PAL pe;
627
628       pe.c.red = (gushort)(p[0] * 0xFF);
629       pe.c.green = (gushort)(p[1] * 0xFF);
630       pe.c.blue = (gushort)(p[2] * 0xFF);
631       gdk_colormap_alloc_color(colormap, &pe.c, FALSE, TRUE);
632       gdk_gc_set_foreground(gc, &pe.c);
633       gdk_draw_point(*pixmap, gc, j, i);
634
635       if (p[0] == 0xFF && p[1] == 0x00 && p[2] == 0xFF)
636         hasMask = true;
637     }
638   }
639
640   gdk_gc_unref (gc);
641   *mask = gdk_pixmap_new (window, width, height, 1);
642   gc = gdk_gc_new (*mask);
643   if (hasMask)
644   {
645     for (i = 0; i < height; i++)
646     {
647       for (j = 0; j < width; j++)
648       {
649               GdkColor mask_pattern;
650
651               // pink is transparent
652               if ((buf[(i*width+j)*3] == 0xff) &&
653                       (buf[(i*width+j)*3+1] == 0x00) &&
654                       (buf[(i*width+j)*3+2] == 0xff))
655                       mask_pattern.pixel = 0;
656         else
657                       mask_pattern.pixel = 1;
658
659         gdk_gc_set_foreground (gc, &mask_pattern);
660         // possible Win32 Gtk bug here
661         //gdk_draw_point (*mask, gc, j, i);
662         gdk_draw_line (*mask, gc, j, i, j + 1, i);
663       }
664     }
665   }
666   else
667   {
668     GdkColor mask_pattern;
669     mask_pattern.pixel = 1;
670     gdk_gc_set_foreground (gc, &mask_pattern);
671     gdk_draw_rectangle (*mask, gc, 1, 0, 0, width, height);
672   }
673   gdk_gc_unref(gc);
674   free (buf);
675 }
676
677 void load_pixmap (const char* filename, GtkWidget* widget, GdkPixmap **gdkpixmap, GdkBitmap **mask)
678 {
679   CString str;
680
681   str = g_strBitmapsPath;
682   str += filename;
683
684   bmp_to_pixmap (str.GetBuffer (), gdkpixmap, mask);
685   if (*gdkpixmap == NULL)
686   {
687     printf("gdkpixmap was null\n");
688     gchar *dummy[] = { "1 1 1 1", "  c None", " " };
689     printf("calling gdk_pixmap_create_from_xpm_d\n");
690     *gdkpixmap = gdk_pixmap_create_from_xpm_d (gdk_get_default_root_window(), mask, NULL, dummy);
691   }
692 }
693
694 // this is the same as above but used by the plugins
695 // GdkPixmap **gdkpixmap, GdkBitmap **mask
696 bool WINAPI load_plugin_bitmap (const char* filename, void **gdkpixmap, void **mask)
697 {
698   CString str;
699
700   str = g_strGameToolsPath;
701   str += g_strPluginsDir;
702   str += "bitmaps/";
703   str += filename;
704   bmp_to_pixmap (str.GetBuffer (), (GdkPixmap **)gdkpixmap, (GdkBitmap **)mask);
705
706   if (*gdkpixmap == NULL)
707   {
708     // look in the core plugins
709     str = g_strAppPath;
710     str += g_strPluginsDir;
711     str += "bitmaps/";
712     str += filename;
713     bmp_to_pixmap (str.GetBuffer (), (GdkPixmap **)gdkpixmap, (GdkBitmap **)mask);
714
715     if (*gdkpixmap == NULL)
716     {
717
718       // look in core modules
719       str = g_strAppPath;
720       str += g_strModulesDir;
721       str += "bitmaps/";
722       str += filename;
723       bmp_to_pixmap (str.GetBuffer (), (GdkPixmap **)gdkpixmap, (GdkBitmap **)mask);
724
725       if (*gdkpixmap == NULL)
726       {
727         gchar *dummy[] = { "1 1 1 1", "  c None", " " };
728         *gdkpixmap = gdk_pixmap_create_from_xpm_d (gdk_get_default_root_window(), (GdkBitmap **)mask, NULL, dummy);
729         return false;
730       }
731     }
732   }
733   return true;
734 }
735
736 // Load a xpm file and return a pixmap widget.
737 GtkWidget* new_pixmap (GtkWidget* widget, const char* filename)
738 {
739   GdkPixmap *gdkpixmap;
740   GdkBitmap *mask;
741   GtkWidget *pixmap;
742
743   load_pixmap (filename, widget, &gdkpixmap, &mask);
744   pixmap = gtk_pixmap_new (gdkpixmap, mask);
745
746   gdk_drawable_unref (gdkpixmap);
747   gdk_drawable_unref (mask);
748
749   return pixmap;
750 }
751
752 // =============================================================================
753 // Menu stuff
754
755 GtkWidget* menu_separator (GtkWidget *menu)
756 {
757   GtkWidget *menu_item = gtk_menu_item_new ();
758   gtk_menu_append (GTK_MENU (menu), menu_item);
759   gtk_widget_set_sensitive (menu_item, FALSE);
760   gtk_widget_show (menu_item);
761   return menu_item;
762 }
763
764 GtkWidget* menu_tearoff (GtkWidget *menu)
765 {
766   GtkWidget *menu_item = gtk_tearoff_menu_item_new ();
767   gtk_menu_append (GTK_MENU (menu), menu_item);
768 // gtk_widget_set_sensitive (menu_item, FALSE); -- controls whether menu is detachable
769   gtk_widget_show (menu_item);
770   return menu_item;
771 }
772
773 GtkWidget* create_sub_menu_with_mnemonic (GtkWidget *bar, const gchar *mnemonic)
774 {
775   GtkWidget *item, *sub_menu;
776
777   item = gtk_menu_item_new_with_mnemonic (mnemonic);
778   gtk_widget_show (item);
779   gtk_container_add (GTK_CONTAINER (bar), item);
780
781   sub_menu = gtk_menu_new ();
782   gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), sub_menu);
783
784   return sub_menu;
785 }
786
787 extern void AddMenuItem (GtkWidget* menu, unsigned int id);
788
789 GtkWidget* create_menu_item_with_mnemonic (GtkWidget *menu, const gchar *mnemonic, GtkSignalFunc func, int id)
790 {
791   GtkWidget *item;
792
793   item = gtk_menu_item_new_with_mnemonic (mnemonic);
794
795   gtk_widget_show (item);
796   gtk_container_add (GTK_CONTAINER (menu), item);
797   gtk_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (func), GINT_TO_POINTER (id));
798
799   AddMenuItem (item, id);
800   return item;
801 }
802
803 GtkWidget* create_check_menu_item_with_mnemonic (GtkWidget *menu, const gchar *mnemonic, GtkSignalFunc func, int id, gboolean active)
804 {
805   GtkWidget *item;
806
807   item = gtk_check_menu_item_new_with_mnemonic(mnemonic);
808
809   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), active);
810   gtk_widget_show (item);
811   gtk_container_add (GTK_CONTAINER (menu), item);
812   gtk_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (func), GINT_TO_POINTER (id));
813
814   AddMenuItem (item, id);
815   return item;
816 }
817
818 GtkWidget* create_radio_menu_item_with_mnemonic (GtkWidget *menu, GtkWidget *last, const gchar *mnemonic, GtkSignalFunc func, int id, gboolean state)
819 {
820   GtkWidget *item;
821   GSList *group = (GSList*)NULL;
822
823   if (last != NULL)
824     group = gtk_radio_menu_item_group (GTK_RADIO_MENU_ITEM (last));
825   item = gtk_radio_menu_item_new_with_mnemonic (group, mnemonic);
826   gtk_check_menu_item_set_state (GTK_CHECK_MENU_ITEM (item), state);
827
828   gtk_widget_show (item);
829   gtk_container_add (GTK_CONTAINER (menu), item);
830   gtk_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (func), GINT_TO_POINTER (id));
831
832   AddMenuItem (item, id);
833   return item;
834 }
835
836 GtkWidget* create_menu_in_menu_with_mnemonic (GtkWidget *menu, const gchar *mnemonic)
837 {
838   GtkWidget *item, *submenu;
839
840   item = gtk_menu_item_new_with_mnemonic(mnemonic);
841   gtk_widget_show (item);
842   gtk_container_add (GTK_CONTAINER (menu), item);
843
844   submenu = gtk_menu_new ();
845   gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), submenu);
846
847   return submenu;
848 }
849
850 // =============================================================================
851 // Message Boxes
852
853 void dialog_button_callback( GtkWidget *widget, gpointer data ) {
854   GtkWidget *parent;
855   int *loop, *ret;
856
857   parent = gtk_widget_get_toplevel( widget );
858   loop = (int*)g_object_get_data( G_OBJECT( parent ), "loop" );
859   ret = (int*)g_object_get_data( G_OBJECT( parent ), "ret" );
860
861   *loop = 0;
862   *ret = GPOINTER_TO_INT (data);
863 }
864
865 gint dialog_delete_callback (GtkWidget *widget, GdkEvent* event, gpointer data)
866 {
867   int *loop;
868
869   gtk_widget_hide (widget);
870   loop = (int*)g_object_get_data (G_OBJECT (widget), "loop");
871   *loop = 0;
872
873   return TRUE;
874 }
875
876 gint dialog_url_callback (GtkWidget *widget, GdkEvent* event, gpointer data)
877 {
878   OpenURL((const char *)g_object_get_data (G_OBJECT (widget), "URL"));
879
880   return TRUE;
881 }
882
883 int WINAPI gtk_MessageBox (void *parent, const char* lpText, const char* lpCaption, guint32 uType, const char* URL)
884 {
885   GtkWidget *window, *w, *vbox, *hbox;
886   GtkAccelGroup *accel;
887   int mode = (uType & MB_TYPEMASK), ret, loop = 1;
888
889   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
890   gtk_signal_connect (GTK_OBJECT (window), "delete_event",
891                       GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
892   gtk_signal_connect (GTK_OBJECT (window), "destroy",
893                       GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
894   gtk_window_set_title (GTK_WINDOW (window), lpCaption);
895   gtk_container_border_width (GTK_CONTAINER (window), 10);
896   g_object_set_data (G_OBJECT (window), "loop", &loop);
897   g_object_set_data (G_OBJECT (window), "ret", &ret);
898   gtk_widget_realize (window);
899
900   gtk_window_set_policy(GTK_WINDOW (window),FALSE,FALSE,TRUE);
901
902   if (parent != NULL)
903     gtk_window_set_transient_for (GTK_WINDOW (window), GTK_WINDOW (parent));
904
905   accel = gtk_accel_group_new ();
906   gtk_window_add_accel_group (GTK_WINDOW (window), accel);
907
908   vbox = gtk_vbox_new (FALSE, 10);
909   gtk_container_add (GTK_CONTAINER (window), vbox);
910   gtk_widget_show (vbox);
911
912   w = gtk_label_new (lpText);
913   gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 2);
914   gtk_label_set_justify (GTK_LABEL (w), GTK_JUSTIFY_LEFT);
915   gtk_widget_show (w);
916
917   w = gtk_hseparator_new ();
918   gtk_box_pack_start (GTK_BOX (vbox), w, FALSE, FALSE, 2);
919   gtk_widget_show (w);
920
921   hbox = gtk_hbox_new (FALSE, 10);
922   gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 2);
923   gtk_widget_show (hbox);
924
925   if (mode == MB_OK)
926   {
927     w = gtk_button_new_with_label (_("Ok"));
928     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
929     gtk_signal_connect (GTK_OBJECT (w), "clicked",
930                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDOK));
931     gtk_widget_add_accelerator (w, "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
932     gtk_widget_add_accelerator (w, "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
933     GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
934     gtk_widget_grab_default (w);
935     gtk_widget_show (w);
936     ret = IDOK;
937   }
938   else if (mode ==  MB_OKCANCEL)
939   {
940     w = gtk_button_new_with_label (_("Ok"));
941     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
942     gtk_signal_connect (GTK_OBJECT (w), "clicked",
943                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDOK));
944     gtk_widget_add_accelerator (w, "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0);
945     GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
946     gtk_widget_grab_default (w);
947     gtk_widget_show (w);
948
949     w = gtk_button_new_with_label (_("Cancel"));
950     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
951     gtk_signal_connect (GTK_OBJECT (w), "clicked",
952                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDCANCEL));
953     gtk_widget_add_accelerator (w, "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0);
954     gtk_widget_show (w);
955     ret = IDCANCEL;
956   }
957   else if (mode == MB_YESNOCANCEL)
958   {
959     w = gtk_button_new_with_label (_("Yes"));
960     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
961     gtk_signal_connect (GTK_OBJECT (w), "clicked",
962                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDYES));
963     GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
964     gtk_widget_grab_default (w);
965     gtk_widget_show (w);
966
967     w = gtk_button_new_with_label (_("No"));
968     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
969     gtk_signal_connect (GTK_OBJECT (w), "clicked",
970                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDNO));
971     gtk_widget_show (w);
972
973     w = gtk_button_new_with_label (_("Cancel"));
974     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
975     gtk_signal_connect (GTK_OBJECT (w), "clicked",
976                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDCANCEL));
977     gtk_widget_show (w);
978     ret = IDCANCEL;
979   }
980   else /* if (mode == MB_YESNO) */
981   {
982     w = gtk_button_new_with_label (_("Yes"));
983     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
984     gtk_signal_connect (GTK_OBJECT (w), "clicked",
985                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDYES));
986     GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
987     gtk_widget_grab_default (w);
988     gtk_widget_show (w);
989
990     w = gtk_button_new_with_label (_("No"));
991     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
992     gtk_signal_connect (GTK_OBJECT (w), "clicked",
993                         GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDNO));
994     gtk_widget_show (w);
995     ret = IDNO;
996   }
997
998   if (URL)
999   {
1000     w = gtk_button_new_with_label (_("Go to URL"));
1001     gtk_box_pack_start (GTK_BOX (hbox), w, TRUE, TRUE, 0);
1002     gtk_signal_connect (GTK_OBJECT (w), "clicked",
1003                         GTK_SIGNAL_FUNC (dialog_url_callback), NULL);
1004     g_object_set_data (G_OBJECT (w), "URL", (void *)URL);
1005     GTK_WIDGET_SET_FLAGS (w, GTK_CAN_DEFAULT);
1006     gtk_widget_grab_default (w);
1007     gtk_widget_show (w);
1008   }
1009
1010
1011   gtk_widget_show (window);
1012   gtk_grab_add (window);
1013
1014   while (loop)
1015     gtk_main_iteration ();
1016
1017   gtk_grab_remove (window);
1018   gtk_widget_destroy (window);
1019
1020   return ret;
1021 }
1022
1023 // =============================================================================
1024 // File dialog
1025
1026 // fenris #3078 WHENHELLISFROZENOVER
1027
1028 //#define FILEDLG_DBG
1029
1030 static void file_sel_callback (GtkWidget *widget, gpointer data)
1031 {
1032   GtkWidget *parent;
1033   int *loop;
1034   bool *success;
1035
1036   parent = gtk_widget_get_toplevel (widget);
1037   loop = (int*)g_object_get_data (G_OBJECT (parent), "loop");
1038   success = (bool*)g_object_get_data (G_OBJECT (parent), "success");
1039
1040   if (GPOINTER_TO_INT (data) == IDOK)
1041     *success = true;
1042
1043 #ifdef FILEDLG_DBG
1044   else
1045     Sys_Printf("file_sel_callback != IDOK\n");
1046 #endif
1047
1048   *loop = 0;
1049 }
1050
1051 #ifdef _WIN32
1052 #include <commdlg.h>
1053 static OPENFILENAME ofn;       /* common dialog box structure   */
1054 static char szDirName[MAX_PATH];    /* directory string              */
1055 static char szFile[MAX_PATH];       /* filename string               */
1056 static char szFileTitle[MAX_PATH];  /* file title string             */
1057 static int i, cbString;        /* integer count variables       */
1058 static HANDLE hf;              /* file handle                   */
1059 #else
1060 static char szFile[QER_MAX_NAMELEN];
1061 #endif
1062
1063 #define FILEDLG_CUSTOM_FILTER_LENGTH 64
1064 // to be used with the advanced file selector
1065
1066 class CFileType : public IFileTypeList
1067 {
1068   struct filetype_copy_t
1069   {
1070     void operator=(const filetype_t& other)
1071     {
1072       m_name = other.name;
1073       m_pattern = other.pattern;
1074     }
1075     string_t m_name;
1076     string_t m_pattern;
1077   };
1078 public:
1079   CFileType()
1080   {
1081     m_nTypes = 0;
1082     m_pTypes = NULL;
1083     m_strWin32Filters = NULL;
1084     m_pstrGTKMasks = NULL;
1085   }
1086
1087   virtual ~CFileType()
1088   {
1089     delete[] m_pTypes;
1090     DestroyWin32Filters();
1091     DestroyGTKMasks();
1092   }
1093
1094   void addType(filetype_t type)
1095   {
1096     filetype_copy_t* newTypes = new filetype_copy_t [m_nTypes+1];
1097     if(m_nTypes > 0)
1098     {
1099       for(int i=0; i<m_nTypes; i++)
1100         newTypes[i] = m_pTypes[i];
1101       delete[] m_pTypes;
1102     }
1103     m_pTypes = newTypes;
1104     m_pTypes[m_nTypes] = type;
1105     m_nTypes++;
1106     ConstructGTKMasks();
1107     ConstructWin32Filters();
1108   }
1109
1110   filetype_t GetTypeForWin32Filter(const char *filter) const
1111   {
1112     for(int i=0; i<m_nTypes; i++)
1113       if(strcmp(m_pTypes[i].m_pattern.c_str(), filter)==0)
1114         return filetype_t(m_pTypes[i].m_name.c_str(), m_pTypes[i].m_pattern.c_str());
1115     return filetype_t();
1116   }
1117
1118   filetype_t GetTypeForGTKMask(const char *mask) const
1119   {
1120     for(int i=0; i<m_nTypes; i++)
1121       if(strcmp(m_pstrGTKMasks[i],mask)==0)
1122         return filetype_t(m_pTypes[i].m_name.c_str(), m_pTypes[i].m_pattern.c_str());
1123     return filetype_t();
1124   }
1125
1126   char *m_strWin32Filters;
1127   char **m_pstrGTKMasks;
1128 private:
1129   int m_nTypes;
1130   filetype_copy_t *m_pTypes;
1131
1132   void DestroyWin32Filters()
1133   {
1134     delete[] m_strWin32Filters;
1135   }
1136
1137   void ConstructWin32Filters()
1138   {
1139     const char *r;
1140     char *w;
1141     int i;
1142     int len = 0;
1143     DestroyWin32Filters();
1144     for(i=0; i<m_nTypes; i++)
1145       len = len + strlen(m_pTypes[i].m_name.c_str()) + strlen(m_pTypes[i].m_pattern.c_str())*2 + 5;
1146     m_strWin32Filters = new char[len+1]; // length + null char
1147     for(i=0, w = m_strWin32Filters; i<m_nTypes; i++)
1148     {
1149       for(r = m_pTypes[i].m_name.c_str(); *r!='\0'; r++, w++)
1150         *w = *r;
1151       *w++ = ' ';
1152       *w++ = '(';
1153       for(r = m_pTypes[i].m_pattern.c_str(); *r!='\0'; r++, w++)
1154         *w = *r;
1155       *w++ = ')';
1156       *w++ = '\0';
1157       for(r = m_pTypes[i].m_pattern.c_str(); *r!='\0'; r++, w++)
1158         *w = (*r == ',') ? ';' : *r;
1159       *w++ = '\0';
1160     }
1161     m_strWin32Filters[len] = '\0';
1162   }
1163
1164   void DestroyGTKMasks()
1165   {
1166     if(m_pstrGTKMasks != NULL)
1167       for(char **p = m_pstrGTKMasks; *p != NULL; p++)
1168         delete[] *p;
1169     delete[] m_pstrGTKMasks;
1170   }
1171
1172   void ConstructGTKMasks()
1173   {
1174     const char *r;
1175     char *w;
1176     int i;
1177     int len = 0;
1178     DestroyGTKMasks();
1179     m_pstrGTKMasks = new char*[m_nTypes+1];
1180     for(i=0; i<m_nTypes; i++)
1181     {
1182       len = strlen(m_pTypes[i].m_name.c_str()) + strlen(m_pTypes[i].m_pattern.c_str()) + 3;
1183       m_pstrGTKMasks[i] = new char[len+1]; // length + null char
1184       w = m_pstrGTKMasks[i];
1185       for(r = m_pTypes[i].m_name.c_str(); *r!='\0'; r++, w++)
1186         *w = *r;
1187       *w++ = ' ';
1188       *w++ = '<';
1189       for(r = m_pTypes[i].m_pattern.c_str(); *r!='\0'; r++, w++)
1190         *w = *r;
1191       *w++ = '>';
1192       *w++ = '\0';
1193     }
1194     m_pstrGTKMasks[m_nTypes] = NULL;
1195   }
1196
1197 };
1198
1199 /**
1200  * @param[in] baseSubDir should have a trailing slash if not @c NULL
1201  */
1202 const char* file_dialog (void *parent, gboolean open, const char* title, const char* path, const char* pattern, const char *baseSubDir)
1203 {
1204   // Gtk dialog
1205   GtkWidget* file_sel;
1206   int loop = 1;
1207   char *new_path = NULL;
1208
1209   const char* r;
1210   char* w;
1211   filetype_t type;
1212   CFileType typelist;
1213   if(pattern != NULL)
1214     GetFileTypeRegistry()->getTypeList(pattern, &typelist);
1215
1216 #ifdef FILEDLG_DBG
1217   Sys_Printf("file_dialog: open = %d title = %s path = %s\n", open, title, path);
1218   if (pattern)
1219   {
1220     Sys_Printf("Patterns:\n");
1221     char** p = typelist.m_pstrGTKMasks;
1222     while(*p!=NULL)
1223       Sys_Printf("%s\n", *p++);
1224   }
1225   else
1226     Sys_Printf("no patterns\n");
1227 #endif
1228
1229 #ifdef _WIN32
1230   // win32 dialog stores the selected "save as type" extension in the second null-terminated string
1231   char customfilter[FILEDLG_CUSTOM_FILTER_LENGTH];
1232
1233   if (g_PrefsDlg.m_bNativeGUI)
1234   {
1235 #ifdef FILEDLG_DBG
1236     Sys_Printf("Doing win32 file dialog...");
1237 #endif
1238     // do that the native way
1239     /* Place the terminating null character in the szFile. */
1240     szFile[0] = '\0';
1241     customfilter[0] = customfilter[1] = customfilter[2] = '\0';
1242
1243     /* Set the members of the OPENFILENAME structure. */
1244     ofn.lStructSize = sizeof(OPENFILENAME);
1245     ofn.hwndOwner = (HWND)GDK_WINDOW_HWND (g_pParentWnd->m_pWidget->window);
1246     if (pattern)
1247     {
1248       ofn.nFilterIndex = 0;
1249       ofn.lpstrFilter = typelist.m_strWin32Filters;
1250     }
1251     else ofn.nFilterIndex = 1;
1252     ofn.lpstrCustomFilter = customfilter;
1253     ofn.nMaxCustFilter = sizeof(customfilter);
1254     ofn.lpstrFile = szFile;
1255     ofn.nMaxFile = sizeof(szFile);
1256     ofn.lpstrFileTitle = NULL; // we don't need to get the name of the file
1257     if(path)
1258     {
1259       // szDirName: Radiant uses unix convention for paths internally
1260       //   Win32 (of course) and Gtk (who would have thought) expect the '\\' convention
1261       // copy path, replacing dir separators as appropriate
1262       for(r=path, w=szDirName; *r!='\0'; r++)
1263         *w++ = (*r=='/') ? '\\' : *r;
1264       // terminate string
1265       *w = '\0';
1266       ofn.lpstrInitialDir = szDirName;
1267     }
1268     else ofn.lpstrInitialDir = NULL;
1269     ofn.lpstrTitle = title;
1270     ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY;
1271
1272     /* Display the Open dialog box. */
1273     // it's open or close depending on 'open' parameter
1274     if (open)
1275     {
1276       if (!GetOpenFileName(&ofn))
1277         return NULL;    // canceled
1278     }
1279     else
1280     {
1281       if (!GetSaveFileName(&ofn))
1282         return NULL;    // canceled
1283     }
1284
1285     if(pattern != NULL)
1286       type = typelist.GetTypeForWin32Filter(customfilter+1);
1287
1288 #ifdef FILEDLG_DBG
1289     Sys_Printf("Done.\n");
1290 #endif
1291   }
1292   else
1293   {
1294 #endif
1295         char buf[PATH_MAX];
1296     // do that the Gtk way
1297     if (title == NULL)
1298       title = open ? _("Open File") : _("Save File");
1299
1300 #ifdef FILEDLG_DBG
1301     Sys_Printf("Doing Gtk file dialog:\nBuilding new_path..");
1302 #endif
1303     // we expect an actual path below, if the path is NULL we might crash
1304     if (!path || path[0] == '\0')
1305     {
1306                 strcpy(buf, g_pGameDescription->mEnginePath.GetBuffer());
1307                 strcat(buf, g_pGameDescription->mBaseGame.GetBuffer());
1308                 strcat(buf, "/");
1309                 if (baseSubDir)
1310                         strcat(buf, baseSubDir);
1311                 path = buf;
1312         }
1313
1314     // alloc new path with extra char for dir separator
1315     new_path = new char[strlen(path)+1+1];
1316     // copy path, replacing dir separators as appropriate
1317     for(r=path, w=new_path; *r!='\0'; r++)
1318       *w++ = (*r=='/') ? G_DIR_SEPARATOR : *r;
1319     // add dir separator to end of path if required
1320     if(*(w-1) != G_DIR_SEPARATOR) *w++ = G_DIR_SEPARATOR;
1321     // terminate string
1322     *w = '\0';
1323
1324 #ifdef FILEDLG_DBG
1325         Sys_Printf("Done.\n");
1326         Sys_Printf("Calling gtk_file_selection_new with title: %s...", title);
1327 #endif
1328     file_sel = gtk_file_selection_new (title);
1329 #ifdef FILEDLG_DBG
1330         Sys_Printf("Done.\n");
1331         Sys_Printf("Set the masks...");
1332 #endif
1333
1334 #if 0 //!\todo Add masks to GtkFileSelection in gtk-2.0
1335     // set the masks
1336     if (pattern)
1337     {
1338       gtk_file_selection_clear_masks (GTK_FILE_SELECTION (file_sel));
1339       gtk_file_selection_set_masks (GTK_FILE_SELECTION (file_sel), const_cast<const char**>(typelist.m_pstrGTKMasks));
1340     }
1341 #endif
1342
1343 #ifdef FILEDLG_DBG
1344     Sys_Printf("Done.\n");
1345 #endif
1346
1347     gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button), "clicked",
1348       GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDOK));
1349     gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->cancel_button), "clicked",
1350       GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDCANCEL));
1351     gtk_signal_connect (GTK_OBJECT (file_sel), "delete_event",
1352       GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
1353     gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (file_sel));
1354
1355     if (parent != NULL)
1356       gtk_window_set_transient_for (GTK_WINDOW (file_sel), GTK_WINDOW (parent));
1357
1358 #ifdef FILEDLG_DBG
1359     Sys_Printf("set_data...");
1360 #endif
1361     bool success = false;
1362     g_object_set_data (G_OBJECT (file_sel), "loop", &loop);
1363     g_object_set_data (G_OBJECT (file_sel), "success", &success);
1364 #ifdef FILEDLG_DBG
1365     Sys_Printf("Done.\n");
1366 #endif
1367
1368     if (!open)
1369     {
1370 #ifdef FILEDLG_DBG
1371       Sys_Printf("set_data \"overwrite\" ...");
1372 #endif
1373       g_object_set_data (G_OBJECT (file_sel), "overwrite", GINT_TO_POINTER (1));
1374 #ifdef FILEDLG_DBG
1375       Sys_Printf("Done.\n");
1376 #endif
1377     }
1378
1379     if (new_path != NULL)
1380     {
1381 #ifdef FILEDLG_DBG
1382       Sys_Printf("gtk_file_selection_set_filename... %p (%s)", file_sel, new_path);
1383 #endif
1384       gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_sel), new_path);
1385       delete[] new_path;
1386 #ifdef FILEDLG_DBG
1387       Sys_Printf("Done.\n");
1388 #endif
1389     }
1390
1391     gtk_grab_add (file_sel);
1392 #ifdef FILEDLG_DBG
1393     Sys_Printf("gtk_widget_show... %p", file_sel);
1394 #endif
1395     gtk_widget_show (file_sel);
1396 #ifdef FILEDLG_DBG
1397     Sys_Printf("Done.\n");
1398 #endif
1399
1400 #ifdef FILEDLG_DBG
1401     Sys_Printf("gtk_main_iteration...");
1402 #endif
1403     while (loop)
1404       gtk_main_iteration ();
1405     if(success)
1406     {
1407 #if 0 //!\todo Add masks to GtkFileSelection in gtk2
1408       if(pattern!=NULL)
1409         type = typelist.GetTypeForGTKMask(GTK_FILE_SELECTION (file_sel)->mask);
1410 #endif
1411       strcpy(szFile, gtk_file_selection_get_filename (GTK_FILE_SELECTION (file_sel)));
1412     }
1413 #ifdef FILEDLG_DBG
1414     Sys_Printf("Done.\n");
1415 #endif
1416
1417     gtk_grab_remove (file_sel);
1418     gtk_widget_destroy (file_sel);
1419 #ifdef _WIN32
1420   }
1421 #endif
1422
1423   // don't return an empty filename
1424   if(szFile[0] == '\0') return NULL;
1425
1426   // convert back to unix format
1427   for(w=szFile; *w!='\0'; w++)
1428     if(*w=='\\')
1429       *w = '/';
1430
1431 #if defined(WIN32)
1432   if (g_PrefsDlg.m_bNativeGUI) // filetype mask not supported in gtk dialog yet
1433   {
1434     // when saving, force an extension depending on filetype
1435     /* \todo SPoG - file_dialog should return filetype information separately.. not force file extension.. */
1436     if(!open && pattern != NULL)
1437     {
1438       // last ext separator
1439       w = strrchr(szFile, '.');
1440       // no extension
1441       w = (w!=NULL) ? w : szFile+strlen(szFile);
1442       strcpy(w, type.pattern+1);
1443     }
1444   }
1445 #endif
1446
1447   // prompt to overwrite existing files
1448   if (!open)
1449     if (access (szFile, R_OK) == 0)
1450       if (gtk_MessageBox (parent, "File already exists.\nOverwrite?", "GtkRadiant", MB_YESNO) == IDNO)
1451         return NULL;
1452
1453 #ifdef FILEDLG_DBG
1454   // ... let's use a static filename
1455   Sys_Printf("filename: %p\n", szFile);
1456 #endif
1457
1458   return szFile;
1459 }
1460
1461 char* WINAPI dir_dialog (void *parent, const char* title, const char* path)
1462 {
1463   GtkWidget* file_sel;
1464   char* filename = (char*)NULL;
1465   int loop = 1;
1466   bool success = false;
1467
1468   file_sel = gtk_file_selection_new (title);
1469   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->ok_button), "clicked",
1470                       GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDOK));
1471   gtk_signal_connect (GTK_OBJECT (GTK_FILE_SELECTION (file_sel)->cancel_button), "clicked",
1472                       GTK_SIGNAL_FUNC (file_sel_callback), GINT_TO_POINTER (IDCANCEL));
1473   gtk_signal_connect (GTK_OBJECT (file_sel), "delete_event",
1474                       GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
1475   gtk_file_selection_hide_fileop_buttons (GTK_FILE_SELECTION (file_sel));
1476
1477         if ( parent != NULL ) {
1478                 gtk_window_set_transient_for( GTK_WINDOW( file_sel ), GTK_WINDOW( parent ) );
1479         }
1480
1481   gtk_widget_hide (GTK_FILE_SELECTION (file_sel)->file_list->parent);
1482
1483   g_object_set_data (G_OBJECT (file_sel), "loop", &loop);
1484   g_object_set_data (G_OBJECT (file_sel), "success", &success);
1485
1486   if (path != NULL)
1487     gtk_file_selection_set_filename (GTK_FILE_SELECTION (file_sel), path);
1488
1489   gtk_grab_add (file_sel);
1490   gtk_widget_show (file_sel);
1491
1492   while (loop)
1493     gtk_main_iteration ();
1494
1495   filename = g_strdup( gtk_file_selection_get_filename( GTK_FILE_SELECTION( file_sel ) ) );
1496
1497   gtk_grab_remove( file_sel );
1498   gtk_widget_destroy( file_sel );
1499
1500   return filename;
1501 }
1502
1503 bool WINAPI color_dialog (void *parent, float *color, const char* title)
1504 {
1505   GtkWidget* dlg;
1506   double clr[3];
1507   int loop = 1, ret = IDCANCEL;
1508
1509   clr[0] = color[0];
1510   clr[1] = color[1];
1511   clr[2] = color[2];
1512
1513   dlg = gtk_color_selection_dialog_new (title);
1514   gtk_color_selection_set_color (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dlg)->colorsel), clr);
1515   gtk_signal_connect (GTK_OBJECT (dlg), "delete_event",
1516                       GTK_SIGNAL_FUNC (dialog_delete_callback), NULL);
1517   gtk_signal_connect (GTK_OBJECT (dlg), "destroy",
1518                       GTK_SIGNAL_FUNC (gtk_widget_destroy), NULL);
1519   gtk_signal_connect (GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (dlg)->ok_button), "clicked",
1520                       GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDOK));
1521   gtk_signal_connect (GTK_OBJECT (GTK_COLOR_SELECTION_DIALOG (dlg)->cancel_button), "clicked",
1522                       GTK_SIGNAL_FUNC (dialog_button_callback), GINT_TO_POINTER (IDCANCEL));
1523   g_object_set_data (G_OBJECT (dlg), "loop", &loop);
1524   g_object_set_data (G_OBJECT (dlg), "ret", &ret);
1525
1526   if (parent != NULL)
1527     gtk_window_set_transient_for (GTK_WINDOW (dlg), GTK_WINDOW (parent));
1528
1529   gtk_widget_show (dlg);
1530   gtk_grab_add (dlg);
1531
1532   while (loop)
1533     gtk_main_iteration ();
1534
1535   GdkColor gdkcolor;
1536   gtk_color_selection_get_current_color (GTK_COLOR_SELECTION (GTK_COLOR_SELECTION_DIALOG (dlg)->colorsel), &gdkcolor);
1537   clr[0] = gdkcolor.red / 65535.0;
1538   clr[1] = gdkcolor.green / 65535.0;
1539   clr[2] = gdkcolor.blue / 65535.0;
1540
1541   gtk_grab_remove (dlg);
1542   gtk_widget_destroy (dlg);
1543
1544   if (ret == IDOK)
1545   {
1546     color[0] = (float)clr[0];
1547     color[1] = (float)clr[1];
1548     color[2] = (float)clr[2];
1549
1550     return true;
1551   }
1552
1553   return false;
1554 }
1555
1556 void OpenURL(const char *url)
1557 {
1558   // let's put a little comment
1559   Sys_Printf("OpenURL: %s\n", url);
1560 #ifdef __linux__
1561   // \todo FIXME: the way we open URLs on *nix should be improved. A script is good (see how I do on RTCW)
1562   char command[2*PATH_MAX];
1563   snprintf( command, sizeof(command), "%s/openurl.sh \"%s\" &", g_strAppPath.GetBuffer(), url );
1564   if (system (command) != 0)
1565     gtk_MessageBox (g_pParentWnd->m_pWidget, "Failed to launch Netscape!");
1566 #endif
1567 #ifdef __APPLE__
1568   char command[2*PATH_MAX];
1569   snprintf (command, sizeof(command),
1570             "open \"%s\" &", url, url);
1571   if (system (command) != 0)
1572     gtk_MessageBox (g_pParentWnd->m_pWidget, "Unable to launch browser!");
1573 #endif
1574 #ifdef _WIN32
1575   ShellExecute( (HWND)GDK_WINDOW_HWND (g_pParentWnd->m_pWidget->window), "open", url, NULL, NULL, SW_SHOW );
1576 #endif
1577 }
1578
1579 void CheckMenuSplitting (GtkWidget *&menu)
1580 {
1581   GtkWidget *item,*menu2;
1582
1583   GtkRequisition requisition;
1584   gint screen_height;
1585
1586   gtk_widget_size_request (GTK_WIDGET (menu), &requisition);
1587   screen_height = gdk_screen_height ();
1588
1589   if ((screen_height - requisition.height) < 20)
1590   {
1591     menu2 = gtk_menu_new ();
1592
1593     // move the last 2 items to a submenu (3 because of win32)
1594     for (int i = 0; i < 3; i++)
1595     {
1596       item = GTK_WIDGET (g_list_last (gtk_container_children (GTK_CONTAINER (menu)))->data);
1597       gtk_widget_ref (item);
1598       gtk_container_remove (GTK_CONTAINER (menu), item);
1599       gtk_menu_append (GTK_MENU (menu2), item);
1600       gtk_widget_unref (item);
1601     }
1602
1603     item = gtk_menu_item_new_with_label ("--------");
1604     gtk_widget_show (item);
1605     gtk_container_add (GTK_CONTAINER (menu), item);
1606     gtk_menu_item_set_submenu (GTK_MENU_ITEM (item), menu2);
1607     menu = menu2;
1608   }
1609 }