merge branch work back into trunk
[xonotic/netradiant.git] / radiant / mainframe.cpp
index cd9f24810db27def886e140004131c6337bae736..402d89d44480ccf81f82c40d96e8243c51d77ddd 100644 (file)
@@ -28,12 +28,13 @@ Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 #include "stdafx.h"
 #ifdef _WIN32
 extern "C" {
-#include <gdk/gdkwin32.h> 
+#include <gdk/gdkwin32.h>
 #define COMPILE_MULTIMON_STUBS
 #include <multimon.h>
 }
 #endif
 #include <gtk/gtk.h>
+#include <glib/gi18n.h>
 #include <gdk/gdkkeysyms.h>
 #include <gdk/gdkprivate.h>
 #include <sys/stat.h>
@@ -53,9 +54,6 @@ extern "C" {
 // globals
 CString g_strAppPath;                   ///< holds the full path of the executable
 CString g_strDTDPath;                   ///< path to the DTD files
-/*!
-see http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=297 for the two below
-*/
 CString g_pidFile;                      ///< the global .pid file (only for global part of the startup)
 CString g_pidGameFile;                  ///< the game-specific .pid file
 CString g_strBitmapsPath;               // directory where the bitmaps are stored
@@ -305,7 +303,7 @@ SKeyInfo g_Keys[] =
   {"F11", GDK_F11},
   {"F12", GDK_F12},
   {"Tab", GDK_Tab},
-  {"Return", GDK_Return},                           
+  {"Return", GDK_Return},
   {"Comma", GDK_comma},
   {"Period", GDK_period},
   {"Plus", GDK_KP_Add},
@@ -335,7 +333,7 @@ int g_nKeyCount = sizeof(g_Keys) / sizeof(SKeyInfo);
 void WINAPI Sys_UpdateWindows (int nBits)
 {
   g_nUpdateBits |= nBits;
-} 
+}
 
 // =============================================================================
 // Static functions
@@ -347,10 +345,10 @@ void HandleKeyUp (GtkWidget *widget, gpointer data)
 #ifdef DBG_KBD
   Sys_Printf("HandleKeyUp: %d\n", id);
 #endif
-  
+
   if(g_bIgnoreCommands)
     return;
-  
+
   switch (id)
   {
     case ID_CAMERA_FORWARD: g_pParentWnd->OnCameraForward (FALSE); break;
@@ -483,7 +481,7 @@ gint HandleCommand (GtkWidget *widget, gpointer data)
     case ID_SELECTION_CSGSUBTRACT: g_pParentWnd->OnSelectionCsgsubtract (); break;
     case ID_SELECTION_CSGMERGE: g_pParentWnd->OnSelectionCsgmerge (); break;
     case ID_SELECTION_NOOUTLINE: g_pParentWnd->OnSelectionNoOutline (); break;
-    case ID_SELECTION_OUTLINESTYLE: g_pParentWnd->OnSelectionOutlineStyle (); break;      
+    case ID_SELECTION_OUTLINESTYLE: g_pParentWnd->OnSelectionOutlineStyle (); break;
     case ID_SELECTION_SELECTCOMPLETETALL: g_pParentWnd->OnSelectionSelectcompletetall (); break;
     case ID_SELECTION_SELECTTOUCHING: g_pParentWnd->OnSelectionSelecttouching (); break;
     case ID_SELECTION_SELECTPARTIALTALL: g_pParentWnd->OnSelectionSelectpartialtall (); break;
@@ -512,7 +510,7 @@ gint HandleCommand (GtkWidget *widget, gpointer data)
     case ID_TEXTURES_LOAD: g_pParentWnd->OnTexturesLoad (); break;
     case ID_TEXTURES_RELOADSHADERS: g_pParentWnd->OnTexturesReloadshaders (); break;
     case ID_TEXTURES_SHADERS_SHOW: g_pParentWnd->OnTexturesShadersShow (); break;
-    case ID_TEXTURES_TEXTUREWINDOWSCALE_200: 
+    case ID_TEXTURES_TEXTUREWINDOWSCALE_200:
     case ID_TEXTURES_TEXTUREWINDOWSCALE_100:
     case ID_TEXTURES_TEXTUREWINDOWSCALE_50:
     case ID_TEXTURES_TEXTUREWINDOWSCALE_25:
@@ -721,14 +719,14 @@ static void mainframe_destroy (GtkWidget *widget, gpointer data)
   // NOTE TTimo this is very clumsy, in MainFrame::OnDestroy we might call SavePrefs again
   //   we will do more stuff in OnDestroy for window position saving too, so I guess this call is still relevant?
   g_PrefsDlg.SavePrefs ();
-  
+
   wnd->OnDestroy ();
-  
+
   // shutdown modules
   // NOTE: I've decided to do this before SavePrefs in case we broadcast some shutdown info
   // and modules / plugins decide to save some stuff
   g_pParentWnd->GetPlugInMgr().Shutdown();
-    
+
   delete wnd;
 
   QGL_Shutdown();
@@ -744,16 +742,14 @@ static gint mainframe_keypress (GtkWidget* widget, GdkEventKey* event, gpointer
 {
   unsigned int code = gdk_keyval_to_upper(event->keyval);
 
-  // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=924
   if(code == GDK_ISO_Left_Tab) {
     code = GDK_Tab;
   }
-  
+
 #ifdef DBG_KBD
   Sys_Printf("key: %d (keyval: %d) (ctrl: %d)\n", code, event->keyval, event->state & GDK_CONTROL_MASK);
 #endif
 
-  // BUG: http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=865
   // return only if Texture Viewport  is in main window, otherwise if Tex viewport is in it's own window
   // the Filter GtkEntry won't release focus
   if ( g_pParentWnd->GetTexWnd()->m_pFilter == gtk_window_get_focus(GTK_WINDOW(widget)) )
@@ -790,10 +786,10 @@ static gint mainframe_keypress (GtkWidget* widget, GdkEventKey* event, gpointer
 static gint mainframe_keyrelease (GtkWidget* widget, GdkEventKey* event, gpointer data)
 {
   unsigned int code = gdk_keyval_to_upper(event->keyval);
-  
+
   if (gtk_accelerator_valid (event->keyval, (GdkModifierType)0))
     return TRUE;
-  
+
   for (int i = 0; i < g_nCommandCount; i++)
   {
     if (g_Commands[i].m_nKey == code)    // find a match?
@@ -851,7 +847,7 @@ void HandleHelpCommand (GtkWidget *widget, gpointer data)
   g_pParentWnd->handle_help_command(id);
 }
 
-void MainFrame::process_xlink (Str &FileName, char *menu_name, const char *base_url, GtkWidget *menu, GtkAccelGroup *accel)
+void MainFrame::process_xlink (Str &FileName, const char *menu_name, const char *base_url, GtkWidget *menu, GtkAccelGroup *accel)
 {
   xmlDocPtr pDoc;
   pDoc = xmlParseFile(FileName.GetBuffer());
@@ -928,7 +924,7 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   global_accel = accel;
   gtk_window_add_accel_group (GTK_WINDOW (window), accel);
 
-  handle_box = gtk_handle_box_new ();  
+  handle_box = gtk_handle_box_new ();
   gtk_box_pack_start (GTK_BOX (vbox), handle_box, FALSE, FALSE, 0);
   gtk_widget_show (handle_box);
 
@@ -937,49 +933,49 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   gtk_widget_show (menu_bar);
 
   // File menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_File");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_File"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  create_menu_item_with_mnemonic (menu, "_New Map",
+  create_menu_item_with_mnemonic (menu, _("_New Map"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_NEW);
   menu_separator (menu);
 
   //++timo temporary experimental stuff for sleep mode..
-  item = create_menu_item_with_mnemonic (menu, "_Sleep",
+  item = create_menu_item_with_mnemonic (menu, _("_Sleep"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_SLEEP);
   g_object_set_data (G_OBJECT (window), "menu_file_sleep", item );
   menu_separator (menu);
   // end experimental
 
-  item = create_menu_item_with_mnemonic (menu, "_Open...",
+  item = create_menu_item_with_mnemonic (menu, _("_Open..."),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_OPEN);
   g_object_set_data (G_OBJECT (window), "menu_file_open", item);
-  create_menu_item_with_mnemonic (menu, "_Import...", // Hydra: give it it's proper name
+  create_menu_item_with_mnemonic (menu, _("_Import..."), // Hydra: give it it's proper name
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_IMPORTMAP);
-  item = create_menu_item_with_mnemonic (menu, "_Save",
+  item = create_menu_item_with_mnemonic (menu, _("_Save"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_SAVE);
   g_object_set_data (G_OBJECT (window), "menu_file_save", item);
-  create_menu_item_with_mnemonic (menu, "Save _as...",
+  create_menu_item_with_mnemonic (menu, _("Save _as..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_SAVEAS);
-  create_menu_item_with_mnemonic (menu, "Save s_elected...",
+  create_menu_item_with_mnemonic (menu, _("Save s_elected..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_EXPORTMAP);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "Save re_gion...",
+  item = create_menu_item_with_mnemonic (menu, _("Save re_gion..."),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_SAVEREGION);
   g_object_set_data (G_OBJECT (window), "menu_file_saveregion", item);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "New p_roject...",
+  create_menu_item_with_mnemonic (menu, _("New p_roject..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_NEWPROJECT);
-  create_menu_item_with_mnemonic (menu, "Load _project...",
+  create_menu_item_with_mnemonic (menu, _("Load _project..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_LOADPROJECT);
-  create_menu_item_with_mnemonic (menu, "Pro_ject settings...",
+  create_menu_item_with_mnemonic (menu, _("Pro_ject settings..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_PROJECTSETTINGS);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "_Pointfile...",
+  create_menu_item_with_mnemonic (menu, _("_Pointfile..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_POINTFILE);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "Recent Files",
+  item = create_menu_item_with_mnemonic (menu, _("Recent Files"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_RECENT1);
   g_object_set_data (G_OBJECT (item), "accel", accel);
   gtk_widget_set_sensitive (item, FALSE);
@@ -997,376 +993,378 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   gtk_widget_hide (item);
   MRU_AddWidget (item, 3);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Check for GtkRadiant update (web)",
+  item = create_menu_item_with_mnemonic (menu, _("Check for GtkRadiant update (web)"),
     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_CHECKUPDATE);
-  
-  create_menu_item_with_mnemonic (menu, "E_xit",
+  // disable, the functionality is no longer available
+  gtk_widget_set_sensitive( item, FALSE );
+
+  create_menu_item_with_mnemonic (menu, _("E_xit"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FILE_EXIT);
 
   // Edit menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Edit");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Edit"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
-  item = create_menu_item_with_mnemonic (menu, "_Undo",
+  item = create_menu_item_with_mnemonic (menu, _("_Undo"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_UNDO);
   g_object_set_data (G_OBJECT (window), "menu_edit_undo", item);
-  item = create_menu_item_with_mnemonic (menu, "_Redo",
+  item = create_menu_item_with_mnemonic (menu, _("_Redo"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_REDO);
   g_object_set_data (G_OBJECT (window), "menu_edit_redo", item);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "_Copy", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_COPYBRUSH);
-  item = create_menu_item_with_mnemonic (menu, "_Paste", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_PASTEBRUSH);
-  item = create_menu_item_with_mnemonic (menu, "P_aste To Camera", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_PASTEBRUSHTOCAMERA);
-  item = create_menu_item_with_mnemonic (menu, "_Delete", GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DELETE);
+  item = create_menu_item_with_mnemonic (menu, _("_Copy"), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_COPYBRUSH);
+  item = create_menu_item_with_mnemonic (menu, _("_Paste"), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_PASTEBRUSH);
+  item = create_menu_item_with_mnemonic (menu, _("P_aste To Camera"), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_PASTEBRUSHTOCAMERA);
+  item = create_menu_item_with_mnemonic (menu, _("_Delete"), GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DELETE);
   g_object_set_data (G_OBJECT (window), "menu_selection_delete", item);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Map Info...", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_MAPINFO);
-  create_menu_item_with_mnemonic (menu, "Entity Info...", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_ENTITYINFO);
+  create_menu_item_with_mnemonic (menu, _("Map Info..."), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_MAPINFO);
+  create_menu_item_with_mnemonic (menu, _("Entity Info..."), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_ENTITYINFO);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Brush Scripts...", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_SCRIPTS);
+  create_menu_item_with_mnemonic (menu, _("Brush Scripts..."), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_SCRIPTS);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Load Pre_fab...", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_LOADPREFAB);
-  create_menu_item_with_mnemonic (menu, "Save Selection as Prefab...", GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_SAVEPREFAB);
+  create_menu_item_with_mnemonic (menu, _("Load Pre_fab..."), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_LOADPREFAB);
+  create_menu_item_with_mnemonic (menu, _("Save Selection as Prefab..."), GTK_SIGNAL_FUNC (HandleCommand), ID_EDIT_SAVEPREFAB);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Preferences...", GTK_SIGNAL_FUNC (HandleCommand), ID_PREFS);
+  create_menu_item_with_mnemonic (menu, _("Preferences..."), GTK_SIGNAL_FUNC (HandleCommand), ID_PREFS);
 
   // View menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_View");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_View"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Toggle");
-  create_menu_item_with_mnemonic (menu_in_menu, "Camera View", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLECAMERA);
-  create_menu_item_with_mnemonic (menu_in_menu, "Console View", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLECONSOLE);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "Entity View", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITY);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Toggle"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Camera View"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLECAMERA);
+  create_menu_item_with_mnemonic (menu_in_menu, _("Console View"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLECONSOLE);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("Entity View"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITY);
   g_object_set_data (G_OBJECT (window), "menu_view_entity", item);
   //  create_menu_item_with_mnemonic (menu_in_menu, "Groups View", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_GROUPS);
-  create_menu_item_with_mnemonic (menu_in_menu, "XY (Top)", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW);
-  create_menu_item_with_mnemonic (menu_in_menu, "YZ (Side)", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW_YZ);
-  create_menu_item_with_mnemonic (menu_in_menu, "XZ (Front)", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW_XZ);
-  create_menu_item_with_mnemonic (menu_in_menu, "Z View", GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEZ);
+  create_menu_item_with_mnemonic (menu_in_menu, _("XY (Top)"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW);
+  create_menu_item_with_mnemonic (menu_in_menu, _("YZ (Side)"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW_YZ);
+  create_menu_item_with_mnemonic (menu_in_menu, _("XZ (Front)"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEVIEW_XZ);
+  create_menu_item_with_mnemonic (menu_in_menu, _("Z View"), GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLEZ);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "_Center", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CENTER);
-  item = create_menu_item_with_mnemonic (menu, "_Center 2d", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CENTERVIEW);
-  item = create_menu_item_with_mnemonic (menu, "_Up Floor", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_UPFLOOR);
-  item = create_menu_item_with_mnemonic (menu, "_Down Floor", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_DOWNFLOOR);
+  item = create_menu_item_with_mnemonic (menu, _("_Center"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CENTER);
+  item = create_menu_item_with_mnemonic (menu, _("_Center 2d"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CENTERVIEW);
+  item = create_menu_item_with_mnemonic (menu, _("_Up Floor"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_UPFLOOR);
+  item = create_menu_item_with_mnemonic (menu, _("_Down Floor"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_DOWNFLOOR);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "_Next (XY, YZ, XY)", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_NEXTVIEW);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Layout");
-  create_menu_item_with_mnemonic (menu_in_menu, "XY (Top)", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_XY);
-  create_menu_item_with_mnemonic (menu_in_menu, "YZ", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SIDE);
-  create_menu_item_with_mnemonic (menu_in_menu, "XZ", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_FRONT);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Zoom");
-  create_menu_item_with_mnemonic (menu_in_menu, "_XY 100%", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_100);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "XY Zoom _In", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZOOMIN);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "XY Zoom _Out", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZOOMOUT);
+  item = create_menu_item_with_mnemonic (menu, _("_Next (XY, YZ, XY)"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_NEXTVIEW);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Layout"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("XY (Top)"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_XY);
+  create_menu_item_with_mnemonic (menu_in_menu, _("YZ"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SIDE);
+  create_menu_item_with_mnemonic (menu_in_menu, _("XZ"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_FRONT);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Zoom"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("_XY 100%"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_100);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("XY Zoom _In"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZOOMIN);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("XY Zoom _Out"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZOOMOUT);
   menu_separator (menu_in_menu);
-  create_menu_item_with_mnemonic (menu_in_menu, "_Z 100%", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_Z100);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "Z Zoo_m In", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZZOOMIN);
+  create_menu_item_with_mnemonic (menu_in_menu, _("_Z 100%"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_Z100);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("Z Zoo_m In"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZZOOMIN);
   g_object_set_data (G_OBJECT (window), "menu_view_zzoomin", item);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "Z Zoom O_ut", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZZOOMOUT);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("Z Zoom O_ut"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ZZOOMOUT);
   g_object_set_data (G_OBJECT (window), "menu_view_zzoomout", item);
   menu_separator (menu_in_menu);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "Cubic Clip Zoom In", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CUBEIN);
-  item = create_menu_item_with_mnemonic (menu_in_menu, "Cubic Clip Zoom Out", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CUBEOUT);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("Cubic Clip Zoom In"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CUBEIN);
+  item = create_menu_item_with_mnemonic (menu_in_menu, _("Cubic Clip Zoom Out"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CUBEOUT);
   menu_separator (menu);
 
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Show");
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show _Angles", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWANGLES, FALSE);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Show"));
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show _Angles"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWANGLES, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_showangles", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show _Names", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWNAMES, TRUE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show _Names"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWNAMES, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_view_shownames", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show Blocks", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWBLOCKS, FALSE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show Blocks"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWBLOCKS, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_showblocks", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show C_oordinates", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWCOORDINATES, TRUE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show C_oordinates"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWCOORDINATES, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_view_showcoordinates", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show Window Outline", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWOUTLINE, TRUE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show Window Outline"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWOUTLINE, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_view_showoutline", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show ZBuffered Outline", GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_NOOUTLINE, TRUE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show ZBuffered Outline"), GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_NOOUTLINE, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_selection_nooutline", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show Axes", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWAXES, TRUE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show Axes"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWAXES, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_view_showaxes", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Show Workzone", GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWWORKZONE, FALSE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Show Workzone"), GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_SHOWWORKZONE, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_showworkzone", item);
 
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Filter");
-  create_check_menu_item_with_mnemonic (menu_in_menu, "World", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_WORLD, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Entities", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_ENTITIES, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Areaportals", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_AREAPORTALS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Translucent", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_TRANSLUCENT, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Liquids", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIQUIDS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Caulk", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CAULK, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Clips", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CLIPS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Paths", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_PATHS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Clusterportals", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CLUSTERPORTALS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Lights", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIGHTS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Structural", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_STRUCTURAL, FALSE);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Lightgrid", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIGHTGRID, FALSE);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Filter"));
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("World"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_WORLD, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Entities"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_ENTITIES, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Areaportals"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_AREAPORTALS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Translucent"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_TRANSLUCENT, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Liquids"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIQUIDS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Caulk"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CAULK, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Clips"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CLIPS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Paths"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_PATHS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Clusterportals"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_CLUSTERPORTALS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Lights"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIGHTS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Structural"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_STRUCTURAL, FALSE);
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Lightgrid"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_LIGHTGRID, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_filter_lightgrid", item);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Patches", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_PATCHES, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Details", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_DETAILS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Hints", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_HINTSSKIPS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Models", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_MODELS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Triggers", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_TRIGGERS, FALSE);
-  create_check_menu_item_with_mnemonic (menu_in_menu, "Botclips", GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_BOTCLIPS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Patches"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_PATCHES, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Details"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_DETAILS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Hints"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_HINTSSKIPS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Models"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_MODELS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Triggers"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_TRIGGERS, FALSE);
+  create_check_menu_item_with_mnemonic (menu_in_menu, _("Botclips"), GTK_SIGNAL_FUNC (HandleCommand), ID_FILTER_BOTCLIPS, FALSE);
 
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Hide/Show");
-  create_menu_item_with_mnemonic (menu_in_menu, "Hide Selected",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Hide/Show"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Hide Selected"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_HIDESHOW_HIDESELECTED);
-  create_menu_item_with_mnemonic (menu_in_menu, "Show Hidden",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Show Hidden"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_HIDESHOW_SHOWHIDDEN);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Entities as");
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Entities as"));
   g_object_set_data (G_OBJECT (window), "view_entitiesas_menu", menu_in_menu);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, "Bounding box",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, _("Bounding box"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITIESAS_BOUNDINGBOX,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_boundingbox", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Wireframe",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Wireframe"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITIESAS_WIREFRAME,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_wireframe", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Selected Wireframe",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Selected Wireframe"),
                                  GTK_SIGNAL_FUNC (HandleCommand),ID_VIEW_ENTITIESAS_SELECTEDWIREFRAME,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_selectedwireframe", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Selected Skinned",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Selected Skinned"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITIESAS_SELECTEDSKINNED,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_selectedskinned", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Skinned",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Skinned"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITIESAS_SKINNED,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_skinned", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Skinned and Boxed",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Skinned and Boxed"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_ENTITIESAS_SKINNEDANDBOXED,FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_entitiesas_skinnedandboxed", item);
   menu_separator (menu);
-  item = create_check_menu_item_with_mnemonic (menu, "Cubic Clipping",
+  item = create_check_menu_item_with_mnemonic (menu, _("Cubic Clipping"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CUBICCLIPPING, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_view_cubicclipping", item);
   menu_separator (menu);
-  item = create_check_menu_item_with_mnemonic (menu, "OpenGL Lighting",
+  item = create_check_menu_item_with_mnemonic (menu, _("OpenGL Lighting"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_OPENGLLIGHTING, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_opengllighting", item);
 
   // Selection menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Selection");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Selection"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Drag");
-  create_menu_item_with_mnemonic (menu_in_menu, "Drag _Edges",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Drag"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Drag _Edges"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DRAGEDGES);
-  create_menu_item_with_mnemonic (menu_in_menu, "Drag _Vertices",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Drag _Vertices"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DRAGVERTECIES);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "_Clone",
+  create_menu_item_with_mnemonic (menu, _("_Clone"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_CLONE);
-  item = create_menu_item_with_mnemonic (menu, "Deselect",
+  item = create_menu_item_with_mnemonic (menu, _("Deselect"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DESELECT);
-  item = create_menu_item_with_mnemonic (menu, "Invert",
+  item = create_menu_item_with_mnemonic (menu, _("Invert"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_INVERT);
 #ifndef QUAKE3
-  create_menu_item_with_mnemonic (menu, "_Delete",
+  create_menu_item_with_mnemonic (menu, _("_Delete"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_DELETE);
 #endif
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Flip");
-  create_menu_item_with_mnemonic (menu_in_menu, "Flip _X",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Flip"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Flip _X"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_FLIPX);
-  create_menu_item_with_mnemonic (menu_in_menu, "Flip _Y",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Flip _Y"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_FLIPY);
-  create_menu_item_with_mnemonic (menu_in_menu, "Flip _Z",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Flip _Z"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_FLIPZ);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Rotate");
-  create_menu_item_with_mnemonic (menu_in_menu, "Rotate X",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Rotate"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Rotate X"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_ROTATEX);
-  create_menu_item_with_mnemonic (menu_in_menu, "Rotate Y",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Rotate Y"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_ROTATEY);
-  create_menu_item_with_mnemonic (menu_in_menu, "Rotate Z",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Rotate Z"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_ROTATEZ);
-  create_menu_item_with_mnemonic (menu_in_menu, "Arbitrary rotation...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Arbitrary rotation..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_ARBITRARYROTATION);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Scale...", GTK_SIGNAL_FUNC (HandleCommand), ID_SELECT_SCALE);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "CSG");
-  create_menu_item_with_mnemonic (menu_in_menu, "Make _Hollow",
+  create_menu_item_with_mnemonic (menu, _("Scale..."), GTK_SIGNAL_FUNC (HandleCommand), ID_SELECT_SCALE);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("CSG"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Make _Hollow"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_MAKEHOLLOW);
-  create_menu_item_with_mnemonic (menu_in_menu, "CSG _Subtract",
+  create_menu_item_with_mnemonic (menu_in_menu, _("CSG _Subtract"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_CSGSUBTRACT);
-  create_menu_item_with_mnemonic (menu_in_menu, "CSG _Merge",
+  create_menu_item_with_mnemonic (menu_in_menu, _("CSG _Merge"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_CSGMERGE);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Select");
-  create_menu_item_with_mnemonic (menu_in_menu, "Select Complete _Tall",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Select"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Select Complete _Tall"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECTCOMPLETETALL);
-  create_menu_item_with_mnemonic (menu_in_menu, "Select T_ouching",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Select T_ouching"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECTTOUCHING);
-  create_menu_item_with_mnemonic (menu_in_menu, "Select _Partial Tall",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Select _Partial Tall"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECTPARTIALTALL);
-  create_menu_item_with_mnemonic (menu_in_menu, "Select _Inside",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Select _Inside"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECTINSIDE);
   create_menu_item_with_mnemonic (menu_in_menu, "Select Func _Group", GTK_SIGNAL_FUNC (HandleCommand), ID_SELECT_FUNC_GROUP);
 #ifndef QUAKE3
-  create_menu_item_with_mnemonic (menu_in_menu, "Nudge Left",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Nudge Left"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECT_NUDGELEFT);
-  create_menu_item_with_mnemonic (menu_in_menu, "Nudge Right",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Nudge Right"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECT_NUDGERIGHT);
-  create_menu_item_with_mnemonic (menu_in_menu, "Nudge Up",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Nudge Up"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECT_NUDGEUP);
-  create_menu_item_with_mnemonic (menu_in_menu, "Nudge Down",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Nudge Down"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_SELECT_NUDGEDOWN);
 #endif
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Clipper");
-  create_menu_item_with_mnemonic (menu_in_menu, "Toggle Clipper",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Clipper"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Toggle Clipper"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_CLIPPER);
   menu_separator (menu_in_menu);
-  create_menu_item_with_mnemonic (menu_in_menu, "Clip selection",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Clip selection"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_CLIP_SELECTED);
-  create_menu_item_with_mnemonic (menu_in_menu, "Split selection",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Split selection"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SPLIT_SELECTED);
-  create_menu_item_with_mnemonic (menu_in_menu, "Flip Clip orientation",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Flip Clip orientation"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_FLIP_CLIP);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Connect entities",
+  create_menu_item_with_mnemonic (menu, _("Connect entities"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_CONNECT);
-  create_menu_item_with_mnemonic (menu, "Ungroup entity",
+  create_menu_item_with_mnemonic (menu, _("Ungroup entity"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_UNGROUPENTITY);
-  create_menu_item_with_mnemonic (menu, "Make detail",
+  create_menu_item_with_mnemonic (menu, _("Make detail"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_MAKE_DETAIL);
-  create_menu_item_with_mnemonic (menu, "Make structural",
+  create_menu_item_with_mnemonic (menu, _("Make structural"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_SELECTION_MAKE_STRUCTURAL);
 
   // BSP menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Bsp");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Bsp"));
 
   menu_separator (menu);
   g_object_set_data (G_OBJECT (window), "menu_bsp", menu);
 
   // Grid menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Grid");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Grid"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  item = create_radio_menu_item_with_mnemonic (menu, NULL, "Grid0.25",
+  item = create_radio_menu_item_with_mnemonic (menu, NULL, _("Grid0.25"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_025, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_025", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid0.5",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid0.5"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_05, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_05", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid1",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid1"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_1, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_1", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid2",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid2"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_2, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_2", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid4",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid4"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_4, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_4", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid8",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid8"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_8, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_grid_8", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid16",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid16"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_16, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_16", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid32",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid32"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_32, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_32", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid64",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid64"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_64, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_64", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid128",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid128"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_128, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_128", item);
-  item = create_radio_menu_item_with_mnemonic (menu, item, "Grid256",
+  item = create_radio_menu_item_with_mnemonic (menu, item, _("Grid256"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_GRID_256, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_grid_256", item);
   menu_separator (menu);
-  item = create_check_menu_item_with_mnemonic (menu, "Snap to grid",
+  item = create_check_menu_item_with_mnemonic (menu, _("Snap to grid"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_SNAPTOGRID, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_snaptogrid", item);
 
   // Textures menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Textures");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Textures"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  item = create_check_menu_item_with_mnemonic (menu, "Show In _Use",
+  item = create_check_menu_item_with_mnemonic (menu, _("Show In _Use"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_SHOWINUSE, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_showinuse", item);
-  item = create_check_menu_item_with_mnemonic (menu, "Show _All",
+  item = create_check_menu_item_with_mnemonic (menu, _("Show _All"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_SHOWALL, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_showall", item);
   menu_separator (menu);
-  item = create_check_menu_item_with_mnemonic (menu, "Show shaders",
+  item = create_check_menu_item_with_mnemonic (menu, _("Show shaders"),
                                  GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_SHADERS_SHOW, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_shaders_show", item);
-  item = create_menu_item_with_mnemonic (menu, "Flush & Reload Shaders",
+  item = create_menu_item_with_mnemonic (menu, _("Flush & Reload Shaders"),
                           GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_RELOADSHADERS);
   g_object_set_data (G_OBJECT (window), "menu_textures_reloadshaders", item);
-  item = create_menu_item_with_mnemonic (menu, "Load directory...",
+  item = create_menu_item_with_mnemonic (menu, _("Load directory..."),
                           GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_LOAD);
   g_object_set_data (G_OBJECT (window), "menu_textures_load", item);
-  item = create_menu_item_with_mnemonic (menu, "Directory list...",
+  item = create_menu_item_with_mnemonic (menu, _("Directory list..."),
                           GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_LOADLIST);
   menu_separator (menu);
 
-  item = create_menu_item_with_mnemonic (menu, "_Surface Inspector",
+  item = create_menu_item_with_mnemonic (menu, _("_Surface Inspector"),
                           GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_INSPECTOR);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Render Quality");
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Render Quality"));
   g_object_set_data (G_OBJECT (window), "render_quality_menu", menu_in_menu);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, "_Wireframe",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, _("_Wireframe"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_WIREFRAME, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_wireframe", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "_Flat shade",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("_Flat shade"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_FLATSHADE, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_flatshade", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "_Nearest",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("_Nearest"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_NEAREST, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_nearest", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "Nearest _Mipmap",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("Nearest _Mipmap"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_NEARESTMIPMAP, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_nearestmipmap", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "_Linear",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("_Linear"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_LINEAR, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_linear", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "_Bilinear",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("_Bilinear"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_BILINEAR, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_bilinear", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "B_ilinear Mipmap",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("B_ilinear Mipmap"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_BILINEARMIPMAP, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_bilinearmipmap", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "T_rilinear",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("T_rilinear"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_VIEW_TRILINEAR, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_view_trilinear", item);
-  create_menu_item_with_mnemonic (menu, "Find / Replace...",
+  create_menu_item_with_mnemonic (menu, _("Find / Replace..."),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURE_REPLACEALL);
 
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Texture Lock");
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Moves",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Texture Lock"));
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Moves"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLE_LOCK, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_toggle_lock", item);
-  item = create_check_menu_item_with_mnemonic (menu_in_menu, "Rotations",
+  item = create_check_menu_item_with_mnemonic (menu_in_menu, _("Rotations"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TOGGLE_ROTATELOCK, TRUE);
   g_object_set_data (G_OBJECT (window), "menu_toggle_rotatelock", item);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Texture Window Scale");
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, "200%",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Texture Window Scale"));
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, NULL, _("200%"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_TEXTUREWINDOWSCALE_200, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_texturewindowscale_200", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "100%",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("100%"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_TEXTUREWINDOWSCALE_100, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_texturewindowscale_100", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "50%",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("50%"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_TEXTUREWINDOWSCALE_50, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_texturewindowscale_50", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "25%",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("25%"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_TEXTUREWINDOWSCALE_25, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_texturewindowscale_25", item);
-  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, "10%",
+  item = create_radio_menu_item_with_mnemonic (menu_in_menu, item, _("10%"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_TEXTUREWINDOWSCALE_10, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_texturewindowscale_10", item);
   item = menu_separator (menu);
-  item = create_check_menu_item_with_mnemonic (menu, "shaderlist.txt only",
+  item = create_check_menu_item_with_mnemonic (menu, _("shaderlist.txt only"),
                                 GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTURES_SHADERLISTONLY, FALSE);
   g_object_set_data (G_OBJECT (window), "menu_textures_shaderlistonly", item);
   item = menu_separator (menu);
@@ -1374,179 +1372,178 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   g_object_set_data (G_OBJECT (window), "menu_textures", menu);
 
   // Misc menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Misc");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Misc"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  create_menu_item_with_mnemonic (menu, "_Benchmark", GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_BENCHMARK);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Colors");
-  menu_3 = create_menu_in_menu_with_mnemonic (menu_in_menu, "Themes");
-  create_menu_item_with_mnemonic (menu_3, "QE4 Original", GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETORIGINAL);
-  create_menu_item_with_mnemonic (menu_3, "Q3Radiant Original", GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETQER);
-  create_menu_item_with_mnemonic (menu_3, "Black and Green", GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETBLACK);
-  create_menu_item_with_mnemonic (menu_3, "Maya/Max/Lightwave Emulation", GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETYDNAR);
+  create_menu_item_with_mnemonic (menu, _("_Benchmark"), GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_BENCHMARK);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Colors"));
+  menu_3 = create_menu_in_menu_with_mnemonic (menu_in_menu, _("Themes"));
+  create_menu_item_with_mnemonic (menu_3, _("QE4 Original"), GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETORIGINAL);
+  create_menu_item_with_mnemonic (menu_3, _("Q3Radiant Original"), GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETQER);
+  create_menu_item_with_mnemonic (menu_3, _("Black and Green"), GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETBLACK);
+  create_menu_item_with_mnemonic (menu_3, _("Maya/Max/Lightwave Emulation"), GTK_SIGNAL_FUNC (HandleCommand), ID_COLOR_SETYDNAR);
 
   menu_separator (menu_in_menu);
-  create_menu_item_with_mnemonic (menu_in_menu, "_Texture Background...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("_Texture Background..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_TEXTUREBK);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Background...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Background..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_XYBK);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Major...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Major..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_MAJOR);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Minor...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Minor..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_MINOR);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Major Small...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Major Small..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_MAJOR_ALT);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Minor Small...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Minor Small..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_MINOR_ALT);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Text...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Text..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_GRIDTEXT);
-  create_menu_item_with_mnemonic (menu_in_menu, "Grid Block...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Grid Block..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_GRIDBLOCK);
-  create_menu_item_with_mnemonic (menu_in_menu, "Default Brush...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Default Brush..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_BRUSH);
-  create_menu_item_with_mnemonic (menu_in_menu, "Camera Background...",
-                    GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_CAMERABACK);    
-  create_menu_item_with_mnemonic (menu_in_menu, "Selected Brush...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Camera Background..."),
+                    GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_CAMERABACK);
+  create_menu_item_with_mnemonic (menu_in_menu, _("Selected Brush..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_SELECTEDBRUSH);
-  create_menu_item_with_mnemonic (menu_in_menu, "Selected Brush (Camera)...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Selected Brush (Camera)..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_SELECTEDBRUSH3D);
-  create_menu_item_with_mnemonic (menu_in_menu, "Clipper...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Clipper..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_CLIPPER);
-  create_menu_item_with_mnemonic (menu_in_menu, "Active View name...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Active View name..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_COLORS_VIEWNAME);
 
-  create_menu_item_with_mnemonic (menu, "_Gamma...",
+  create_menu_item_with_mnemonic (menu, _("_Gamma..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_GAMMA);
-  create_menu_item_with_mnemonic (menu, "Find brush...",
+  create_menu_item_with_mnemonic (menu, _("Find brush..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_FINDBRUSH);
-  item = create_menu_item_with_mnemonic (menu, "Next leak spot",
+  item = create_menu_item_with_mnemonic (menu, _("Next leak spot"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_NEXTLEAKSPOT);
-  item = create_menu_item_with_mnemonic (menu, "Previous leak spot",
+  item = create_menu_item_with_mnemonic (menu, _("Previous leak spot"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_PREVIOUSLEAKSPOT);
-  // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=394
-//  create_menu_item_with_mnemonic (menu, "_Print XY View", GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_PRINTXY);
-  item = create_menu_item_with_mnemonic (menu, "_Select Entity Color...",
+  create_menu_item_with_mnemonic (menu, _("_Print XY View"), GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_PRINTXY);
+  item = create_menu_item_with_mnemonic (menu, _("_Select Entity Color..."),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_MISC_SELECTENTITYCOLOR);
   g_object_set_data (G_OBJECT (window), "menu_misc_selectentitycolor", item);
 
   // Region menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Region");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Region"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  create_menu_item_with_mnemonic (menu, "_Off",
+  create_menu_item_with_mnemonic (menu, _("_Off"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_REGION_OFF);
-  create_menu_item_with_mnemonic (menu, "_Set XY",
+  create_menu_item_with_mnemonic (menu, _("_Set XY"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_REGION_SETXY);
-  create_menu_item_with_mnemonic (menu, "Set _Tall Brush",
+  create_menu_item_with_mnemonic (menu, _("Set _Tall Brush"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_REGION_SETTALLBRUSH);
-  create_menu_item_with_mnemonic (menu, "Set _Brush",
+  create_menu_item_with_mnemonic (menu, _("Set _Brush"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_REGION_SETBRUSH);
-  create_menu_item_with_mnemonic (menu, "Set Se_lected Brushes",
+  create_menu_item_with_mnemonic (menu, _("Set Se_lected Brushes"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_REGION_SETSELECTION);
 
   // Brush menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Brush");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Brush"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  item = create_menu_item_with_mnemonic (menu, "3 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_3SIDED);
-  item = create_menu_item_with_mnemonic (menu, "4 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_4SIDED);
-  item = create_menu_item_with_mnemonic (menu, "5 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_5SIDED);
-  item = create_menu_item_with_mnemonic (menu, "6 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_6SIDED);
-  item = create_menu_item_with_mnemonic (menu, "7 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_7SIDED);
-  item = create_menu_item_with_mnemonic (menu, "8 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_8SIDED);
-  item = create_menu_item_with_mnemonic (menu, "9 sided", GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_9SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("3 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_3SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("4 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_4SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("5 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_5SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("6 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_6SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("7 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_7SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("8 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_8SIDED);
+  item = create_menu_item_with_mnemonic (menu, _("9 sided"), GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_9SIDED);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Arbitrary sided...",
+  create_menu_item_with_mnemonic (menu, _("Arbitrary sided..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_ARBITRARYSIDED);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Primitives");
-  create_menu_item_with_mnemonic (menu_in_menu, "Cone...",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Primitives"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Cone..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_MAKECONE);
-  create_menu_item_with_mnemonic (menu_in_menu, "Sphere...",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Sphere..."),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_BRUSH_PRIMITIVES_SPHERE);
 
   // Curve menu
   if (!g_pGameDescription->mNoPatch)
   {
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Curve");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Curve"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  create_menu_item_with_mnemonic (menu, "Cylinder", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHTUBE);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "More Cylinders");
-  create_menu_item_with_mnemonic (menu_in_menu, "Dense Cylinder",
+  create_menu_item_with_mnemonic (menu, _("Cylinder"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHTUBE);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("More Cylinders"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Dense Cylinder"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHDENSETUBE);
-  create_menu_item_with_mnemonic (menu_in_menu, "Very Dense Cylinder",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Very Dense Cylinder"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHVERYDENSETUBE);
-  create_menu_item_with_mnemonic (menu_in_menu, "Square Cylinder",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Square Cylinder"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHSQUARE);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "End cap", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHENDCAP);
-  create_menu_item_with_mnemonic (menu, "Bevel", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHBEVEL);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "More End caps, Bevels");
-  create_menu_item_with_mnemonic (menu_in_menu, "Square Endcap",
+  create_menu_item_with_mnemonic (menu, _("End cap"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHENDCAP);
+  create_menu_item_with_mnemonic (menu, _("Bevel"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHBEVEL);
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("More End caps, Bevels"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Square Endcap"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_MOREENDCAPSBEVELS_SQUAREBEVEL);
-  create_menu_item_with_mnemonic (menu_in_menu, "Square Bevel",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Square Bevel"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_MOREENDCAPSBEVELS_SQUAREENDCAP);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Cone", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHCONE);
-  item = create_menu_item_with_mnemonic (menu, "Sphere",
+  create_menu_item_with_mnemonic (menu, _("Cone"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PATCHCONE);
+  item = create_menu_item_with_mnemonic (menu, _("Sphere"),
                           GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_PRIMITIVES_SPHERE);
   gtk_widget_set_sensitive (item, FALSE);
   menu_separator (menu);
-  item = create_menu_item_with_mnemonic (menu, "Simple Patch Mesh...",
+  item = create_menu_item_with_mnemonic (menu, _("Simple Patch Mesh..."),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_SIMPLEPATCHMESH);
   g_object_set_data (G_OBJECT (window), "menu_simplepatchmesh", item);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Insert");
-  create_menu_item_with_mnemonic (menu_in_menu, "Insert (2) Columns",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Insert"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Insert (2) Columns"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_INSERT_INSERTCOLUMN);
-  create_menu_item_with_mnemonic (menu_in_menu, "Add (2) Columns",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Add (2) Columns"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_INSERT_ADDCOLUMN);
   menu_separator (menu_in_menu);
-  create_menu_item_with_mnemonic (menu_in_menu, "Insert (2) Rows",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Insert (2) Rows"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_INSERT_INSERTROW);
-  create_menu_item_with_mnemonic (menu_in_menu, "Add (2) Rows",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Add (2) Rows"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_INSERT_ADDROW);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Delete");
-  create_menu_item_with_mnemonic (menu_in_menu, "First (2) Columns",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Delete"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("First (2) Columns"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_DELETE_FIRSTCOLUMN);
-  create_menu_item_with_mnemonic (menu_in_menu, "Last (2) Columns",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Last (2) Columns"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_DELETE_LASTCOLUMN);
   menu_separator (menu_in_menu);
-  create_menu_item_with_mnemonic (menu_in_menu, "First (2) Rows",
+  create_menu_item_with_mnemonic (menu_in_menu, _("First (2) Rows"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_DELETE_FIRSTROW);
-  create_menu_item_with_mnemonic (menu_in_menu, "Last (2) Rows",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Last (2) Rows"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_DELETE_LASTROW);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Matrix");
-  create_menu_item_with_mnemonic (menu_in_menu, "Invert",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Matrix"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Invert"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_NEGATIVE);
-  menu_3 = create_menu_in_menu_with_mnemonic (menu_in_menu, "Re-disperse");
-  create_menu_item_with_mnemonic (menu_3, "Rows", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_ROWS);
-  create_menu_item_with_mnemonic (menu_3, "Cols (Intermediate)", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_INTERMEDIATE_COLS);
-  create_menu_item_with_mnemonic (menu_3, "Rows (Intermediate)", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_INTERMEDIATE_ROWS);
-  create_menu_item_with_mnemonic (menu_in_menu, "Transpose",
+  menu_3 = create_menu_in_menu_with_mnemonic (menu_in_menu, _("Re-disperse"));
+  create_menu_item_with_mnemonic (menu_3, _("Rows"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_ROWS);
+  create_menu_item_with_mnemonic (menu_3, _("Cols (Intermediate)"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_INTERMEDIATE_COLS);
+  create_menu_item_with_mnemonic (menu_3, _("Rows (Intermediate)"), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_REDISPERSE_INTERMEDIATE_ROWS);
+  create_menu_item_with_mnemonic (menu_in_menu, _("Transpose"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_MATRIX_TRANSPOSE);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Cap Selection",
+  create_menu_item_with_mnemonic (menu, _("Cap Selection"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_CAP);
-  create_menu_item_with_mnemonic (menu, "Cycle Cap Texture",
+  create_menu_item_with_mnemonic (menu, _("Cycle Cap Texture"),
                        GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_CYCLECAP);
   menu_separator (menu);
-  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, "Overlay");
-  create_menu_item_with_mnemonic (menu_in_menu, "Set",
+  menu_in_menu = create_menu_in_menu_with_mnemonic (menu, _("Overlay"));
+  create_menu_item_with_mnemonic (menu_in_menu, _("Set"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_OVERLAY_SET);
-  create_menu_item_with_mnemonic (menu_in_menu, "Clear",
+  create_menu_item_with_mnemonic (menu_in_menu, _("Clear"),
                    GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_OVERLAY_CLEAR);
   menu_separator (menu);
-  create_menu_item_with_mnemonic (menu, "Thicken...", GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_THICKEN);
+  create_menu_item_with_mnemonic (menu, _("Thicken..."), GTK_SIGNAL_FUNC (HandleCommand), ID_CURVE_THICKEN);
   }
   // Plugins menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Plugins");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Plugins"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
@@ -1559,11 +1556,11 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   g_object_set_data (G_OBJECT (window), "menu_plugin", menu);
 
   // Help menu
-  menu = create_sub_menu_with_mnemonic (menu_bar, "_Help");
+  menu = create_sub_menu_with_mnemonic (menu_bar, _("_Help"));
   if (g_PrefsDlg.m_bDetachableMenus)
     menu_tearoff (menu);
 
-  item = create_menu_item_with_mnemonic (menu, "Manual",
+  item = create_menu_item_with_mnemonic (menu, _("Manual"),
                            GTK_SIGNAL_FUNC (HandleCommand), ID_HELP);
   gtk_widget_add_accelerator (item, "activate", accel, GDK_F1, (GdkModifierType)0, GTK_ACCEL_VISIBLE);
 
@@ -1574,11 +1571,11 @@ void MainFrame::create_main_menu (GtkWidget *window, GtkWidget *vbox)
   // TTimo: this is in global.xlink now
   //create_menu_item_with_mnemonic (menu, "Links",
   //                  GTK_SIGNAL_FUNC (HandleCommand), ID_HELP_LINKS);
-  create_menu_item_with_mnemonic (menu, "Bug report",
+  create_menu_item_with_mnemonic (menu, _("Bug report"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_HELP_BUGREPORT);
-  create_menu_item_with_mnemonic (menu, "Shortcuts list",
+  create_menu_item_with_mnemonic (menu, _("Shortcuts list"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_HELP_COMMANDLIST);
-  create_menu_item_with_mnemonic (menu, "_About",
+  create_menu_item_with_mnemonic (menu, _("_About"),
                     GTK_SIGNAL_FUNC (HandleCommand), ID_HELP_ABOUT);
 
 
@@ -1665,36 +1662,36 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
 
   gtk_widget_show (toolbar);
 
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Open", "Open an existing map", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Open"), _("Open an existing map"), "",
                                new_pixmap (window, "file_open.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_FILE_OPEN));
   g_object_set_data (G_OBJECT (window), "tb_file_open", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "Save", "Save the active map", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), _("Save"), _("Save the active map"), "",
                                new_pixmap (window, "file_save.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_FILE_SAVE));
   g_object_set_data (G_OBJECT (window), "tb_file_save", w);
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "x-axis Flip", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("x-axis Flip"), "",
                                new_pixmap (window, "brush_flipx.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_FLIPX));
   g_object_set_data (G_OBJECT (window), "tb_brush_flipx", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "x-axis Rotate", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("x-axis Rotate"), "",
                                new_pixmap (window, "brush_rotatex.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_ROTATEX));
   g_object_set_data (G_OBJECT (window), "tb_brush_rotatex", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "y-axis Flip", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("y-axis Flip"), "",
                                new_pixmap (window, "brush_flipy.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_FLIPY));
   g_object_set_data (G_OBJECT (window), "tb_brush_flipy", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "y-axis Rotate", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("y-axis Rotate"), "",
                                new_pixmap (window, "brush_rotatey.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_ROTATEY));
   g_object_set_data (G_OBJECT (window), "tb_brush_rotatey", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "z-axis Flip", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("z-axis Flip"), "",
                                new_pixmap (window, "brush_flipz.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_FLIPZ));
   g_object_set_data (G_OBJECT (window), "tb_brush_flipz", w);
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "z-axis Rotate", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("z-axis Rotate"), "",
                                new_pixmap (window, "brush_rotatez.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_BRUSH_ROTATEZ));
   g_object_set_data (G_OBJECT (window), "tb_brush_rotatez", w);
@@ -1702,45 +1699,45 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
 
   if (g_PrefsDlg.m_bWideToolbar)
   {
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Complete Tall", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Complete Tall"), "",
                                  new_pixmap (window, "selection_selectcompletetall.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                  GINT_TO_POINTER (ID_SELECTION_SELECTCOMPLETETALL));
     g_object_set_data (G_OBJECT (window), "tb_selection_selectcompletetall", w);
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Select Touching", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Select Touching"), "",
                                  new_pixmap (window, "selection_selecttouching.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                  GINT_TO_POINTER (ID_SELECTION_SELECTTOUCHING));
     g_object_set_data (G_OBJECT (window), "tb_selection_selecttouching", w);
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Select Partial Tall", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Select Partial Tall"), "",
                                  new_pixmap (window, "selection_selectpartialtall.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                  GINT_TO_POINTER (ID_SELECTION_SELECTPARTIALTALL));
     g_object_set_data (G_OBJECT (window), "tb_selection_selectpartialtall", w);
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Select Inside", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Select Inside"), "",
                                  new_pixmap (window, "selection_selectinside.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                  GINT_TO_POINTER (ID_SELECTION_SELECTINSIDE));
     g_object_set_data (G_OBJECT (window), "tb_selection_selectinside", w);
   } else
   {
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Selection", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Selection"), "",
                                  new_pixmap (window, "popup_selection.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                  GINT_TO_POINTER (ID_POPUP_SELECTION));
     g_object_set_data (G_OBJECT (window), "tb_popup_selection", w);
   }
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "CSG Subtract", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("CSG Subtract"), "",
                                new_pixmap (window, "selection_csgsubtract.bmp"),
                                GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SELECTION_CSGSUBTRACT));
   g_object_set_data (G_OBJECT (window), "tb_selection_csgsubtract", w);
 
   if (g_PrefsDlg.m_bWideToolbar)
   {
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "CSG Merge", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("CSG Merge"), "",
                                  new_pixmap (window, "selection_csgmerge.bmp"),
                                  GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SELECTION_CSGMERGE));
     g_object_set_data (G_OBJECT (window), "tb_selection_csgmerge", w);
   }
 
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Hollow", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Hollow"), "",
                                new_pixmap (window, "selection_makehollow.bmp"),
                                GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SELECTION_MAKEHOLLOW));
   g_object_set_data (G_OBJECT (window), "tb_selection_makehollow", w);
@@ -1748,14 +1745,14 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   if (g_PrefsDlg.m_bWideToolbar)
   {
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                    "", "Clipper", "", new_pixmap (window, "view_clipper.bmp"),
+                                    "", _("Clipper"), "", new_pixmap (window, "view_clipper.bmp"),
                                     GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_CLIPPER));
     g_object_set_data (G_OBJECT (window), "tb_view_clipper", w);
   }
 
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
 
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Change views", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Change views"), "",
                                new_pixmap (window, "view_change.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_VIEW_CHANGE));
   g_object_set_data (G_OBJECT (window), "tb_view_change", w);
@@ -1765,7 +1762,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
   }
 
-  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Texture view mode", "",
+  w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Texture view mode"), "",
                                new_pixmap (window, "textures_popup.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                GINT_TO_POINTER (ID_TEXTURES_POPUP));
   g_object_set_data (G_OBJECT (window), "tb_textures_popup", w);
@@ -1773,7 +1770,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   if (g_PrefsDlg.m_bWideToolbar)
   {
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                    "", "Cubic clip the camera view", "",
+                                    "", _("Cubic clip the camera view"), "",
                                     new_pixmap (window, "view_cubicclipping.bmp"),
                                     GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_CUBICCLIPPING));
     g_object_set_data (G_OBJECT (window), "tb_view_cubicclipping", w);
@@ -1784,7 +1781,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   if (!g_PrefsDlg.m_bWideToolbar)
   {
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                               "", "Camera preview", "", new_pixmap (window, "view_cameratoggle.bmp"),
+                               "", _("Camera preview"), "", new_pixmap (window, "view_cameratoggle.bmp"),
                                GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_CAMERATOGGLE));
     g_object_set_data (G_OBJECT (window), "tb_view_cameratoggle", w);
     w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Update Camera", "",
@@ -1792,42 +1789,42 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
                             GINT_TO_POINTER (ID_VIEW_CAMERAUPDATE));
     g_object_set_data (G_OBJECT (window), "tb_view_cameraupdate", w);
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                               "", "Cubic clip the camera view", "",
+                               "", _("Cubic clip the camera view"), "",
                                new_pixmap (window, "view_cubicclipping.bmp"),
                                GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_CUBICCLIPPING));
     g_object_set_data (G_OBJECT (window), "tb_view_cubicclipping", w);
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                   "", "Entity inspector", "", new_pixmap (window, "view_entity.bmp"),
+                                   "", _("Entity inspector"), "", new_pixmap (window, "view_entity.bmp"),
                                    GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_ENTITY));
     g_object_set_data (G_OBJECT (window), "tb_view_entity", w);
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                   "", "Clipper", "", new_pixmap (window, "view_clipper.bmp"),
+                                   "", _("Clipper"), "", new_pixmap (window, "view_clipper.bmp"),
                                    GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_VIEW_CLIPPER));
     g_object_set_data (G_OBJECT (window), "tb_view_clipper", w);
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
   }
 
   w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                             "", "Free Rotation", "", new_pixmap (window, "select_mouserotate.bmp"),
+                             "", _("Free Rotation"), "", new_pixmap (window, "select_mouserotate.bmp"),
                              GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SELECT_MOUSEROTATE));
   g_object_set_data (G_OBJECT (window), "tb_select_mouserotate", w);
   gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
   w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                             "", "Free Scaling", "", new_pixmap (window, "select_mousescale.bmp"),
+                             "", _("Free Scaling"), "", new_pixmap (window, "select_mousescale.bmp"),
                              GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SELECT_MOUSESCALE));
   g_object_set_data (G_OBJECT (window), "tb_select_mousescale", w);
   w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                 "", "Scale X", "", new_pixmap (window, "scalelockx.bmp"),
+                                 "", _("Scale X"), "", new_pixmap (window, "scalelockx.bmp"),
                                  GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SCALELOCKX));
   g_object_set_data (G_OBJECT (window), "tb_scalelockx", w);
   w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                 "", "Scale Y", "", new_pixmap (window, "scalelocky.bmp"),
+                                 "", _("Scale Y"), "", new_pixmap (window, "scalelocky.bmp"),
                                  GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SCALELOCKY));
   g_object_set_data (G_OBJECT (window), "tb_scalelocky", w);
   w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                 "", "Scale Z", "", new_pixmap (window, "scalelockz.bmp"),
+                                 "", _("Scale Z"), "", new_pixmap (window, "scalelockz.bmp"),
                                  GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_SCALELOCKZ));
   g_object_set_data (G_OBJECT (window), "tb_scalelockz", w);
 
@@ -1835,7 +1832,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   {
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                            "", "Don't select model brushes", "",
+                            "", _("Don't select model brushes"), "",
                              new_pixmap (window, "dontselectmodel.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_DONTSELECTMODEL));
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
@@ -1844,7 +1841,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
     if (!g_pGameDescription->mNoPatch)
     {
       w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                            "", "Don't select curved brushes", "",
+                            "", _("Don't select curved brushes"), "",
                              new_pixmap (window, "dontselectcurve.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_DONTSELECTCURVE));
       g_object_set_data (G_OBJECT (window), "tb_dontselectcurve", w);
@@ -1855,31 +1852,31 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   if (g_PrefsDlg.m_bPatchToolbar)
   {
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                            "", "Show patch bounding box", "",
+                            "", _("Show patch bounding box"), "",
                             new_pixmap (window, "patch_showboundingbox.bmp"),
                             GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_PATCH_SHOWBOUNDINGBOX));
     g_object_set_data (G_OBJECT (window), "tb_patch_showboundingbox", w);
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                   "", "Show patches as wireframes", "",
+                                   "", _("Show patches as wireframes"), "",
                                    new_pixmap (window, "patch_wireframe.bmp"),
                                    GTK_SIGNAL_FUNC (HandleCommand), GINT_TO_POINTER (ID_PATCH_WIREFRAME));
     g_object_set_data (G_OBJECT (window), "tb_patch_wireframe", w);
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                             "", "Patch Bend mode", "",
+                             "", _("Patch Bend mode"), "",
                             new_pixmap (window, "patch_bend.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_PATCH_BEND));
     g_object_set_data (G_OBJECT (window), "tb_patch_bend", w);
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Put caps on the current patch", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Put caps on the current patch"), "",
                             new_pixmap (window, "curve_cap.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_CURVE_CAP));
     g_object_set_data (G_OBJECT (window), "tb_curve_cap", w);
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                                "", "Welds equal patch points during moves", "",
+                                "", _("Welds equal patch points during moves"), "",
                                 new_pixmap (window, "patch_weld.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                                 GINT_TO_POINTER (ID_PATCH_WELD));
     g_object_set_data (G_OBJECT (window), "tb_patch_weld", w);
     w = gtk_toolbar_append_element (GTK_TOOLBAR (toolbar), GTK_TOOLBAR_CHILD_TOGGLEBUTTON, NULL,
-                             "", "Selects drill down rows and columns", "",
+                             "", _("Selects drill down rows and columns"), "",
                             new_pixmap (window, "patch_drilldown.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_PATCH_DRILLDOWN));
     g_object_set_data (G_OBJECT (window), "tb_patch_drilldown", w);
@@ -1888,7 +1885,7 @@ void MainFrame::create_main_toolbar (GtkWidget *window, GtkWidget *vbox)
   if (g_PrefsDlg.m_bWideToolbar)
   {
     gtk_toolbar_append_space (GTK_TOOLBAR (toolbar));
-    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", "Show Entities as", "",
+    w = gtk_toolbar_append_item (GTK_TOOLBAR (toolbar), "", _("Show Entities as"), "",
                             new_pixmap (window, "show_entities.bmp"), GTK_SIGNAL_FUNC (HandleCommand),
                             GINT_TO_POINTER (ID_SHOW_ENTITIES));
     g_object_set_data (G_OBJECT (window), "tb_show_entities", w);
@@ -1953,7 +1950,7 @@ void MainFrame::create_main_statusbar (GtkWidget *window, GtkWidget *vbox)
   gtk_container_border_width (GTK_CONTAINER (hbox1), 0);
   gtk_widget_show (hbox1);
 
-  label = gtk_label_new (" Label ");
+  label = gtk_label_new (_(" Label "));
   gtk_widget_show (label);
   gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, TRUE, 0);
   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
@@ -1967,7 +1964,7 @@ void MainFrame::create_main_statusbar (GtkWidget *window, GtkWidget *vbox)
     gtk_box_pack_start (GTK_BOX (hbox), frame, FALSE, TRUE, 0);
     gtk_frame_set_shadow_type (GTK_FRAME (frame), GTK_SHADOW_IN);
 
-    label = gtk_label_new (" Label ");
+    label = gtk_label_new (_(" Label "));
     gtk_widget_show (label);
     gtk_container_add (GTK_CONTAINER (frame), label);
     m_pStatusLabel[i] = label;
@@ -2060,7 +2057,7 @@ void console_populate_popup(GtkTextView* textview, GtkMenu* menu, gpointer user_
 {
   menu_separator(GTK_WIDGET(menu));
 
-  GtkWidget* item = gtk_menu_item_new_with_label ("Clear");
+  GtkWidget* item = gtk_menu_item_new_with_label (_("Clear"));
   gtk_signal_connect (GTK_OBJECT (item), "activate", GTK_SIGNAL_FUNC (Sys_ClearPrintf), NULL);
   gtk_widget_show (item);
   gtk_menu_append (GTK_MENU (menu), item);
@@ -2260,7 +2257,7 @@ BOOL CALLBACK m_pCountMonitor (HMONITOR hMonitor, HDC hdcMonitor, LPRECT lprcMon
   return TRUE;
 }
 
-struct monitorInfo_s { 
+struct monitorInfo_s {
   GdkRectangle *win_monitors;
   int i_win_mon;
 };
@@ -2396,7 +2393,7 @@ static ZWnd *create_floating_zwnd(MainFrame *mainframe)
 
   gtk_widget_realize (wnd);
 
-  // turn OFF minimize and maximize boxes. 
+  // turn OFF minimize and maximize boxes.
   // Must be *after* realize, or wnd->window is NULL
   // should do the right thing on *nix, need to verify.
   gdk_window_set_decorations ( wnd->window,
@@ -2406,7 +2403,7 @@ static ZWnd *create_floating_zwnd(MainFrame *mainframe)
     GdkGeometry geometry;
     geometry.min_width = 50;
     //we only care about width, but have to set this too, or get nasty bugs
-    geometry.min_height = 10; 
+    geometry.min_height = 10;
     gdk_window_set_geometry_hints( wnd->window,&geometry,GDK_HINT_MIN_SIZE);
   }
 
@@ -2484,7 +2481,7 @@ void MainFrame::Create ()
 
     screen = gdk_display_get_screen( display, 1 );
     n_gdk_monitors = gdk_screen_get_n_monitors( screen );
-      
+
     Sys_Printf( "GDK detects that screen 1 has %d monitors\n", n_gdk_monitors );
 
     for( i_mon = 0; i_mon < n_gdk_monitors; i_mon++ ) {
@@ -2500,9 +2497,9 @@ void MainFrame::Create ()
     PositionWindowOnPrimaryScreen( g_PrefsDlg.mWindowInfo.position );
   }
   else {
-    primaryMonitorRect.x = primaryMonitorRect.y = 0; 
+    primaryMonitorRect.x = primaryMonitorRect.y = 0;
     primaryMonitorRect.width = gdk_screen_width ();
-    primaryMonitorRect.height = gdk_screen_height (); 
+    primaryMonitorRect.height = gdk_screen_height ();
   }
 
 #endif
@@ -2735,7 +2732,7 @@ void MainFrame::Create ()
 
     {
       GtkWidget* wnd = create_floating (this);
-      gtk_window_set_title (GTK_WINDOW (wnd), "XZ View");
+      gtk_window_set_title (GTK_WINDOW (wnd), _("XZ View"));
 
 #ifdef _WIN32
       if( g_PrefsDlg.m_bStartOnPrimMon ) {
@@ -2759,7 +2756,7 @@ void MainFrame::Create ()
 
     {
       GtkWidget* wnd = create_floating (this);
-      gtk_window_set_title (GTK_WINDOW (wnd), "YZ View");
+      gtk_window_set_title (GTK_WINDOW (wnd), _("YZ View"));
 
 #ifdef _WIN32
       if( g_PrefsDlg.m_bStartOnPrimMon ) {
@@ -2787,7 +2784,7 @@ void MainFrame::Create ()
       m_pTexWnd->m_pParent = g_pGroupDlg->m_pWidget;
 
       {
-        GtkWidget* w = gtk_label_new ("Textures");
+        GtkWidget* w = gtk_label_new (_("Textures"));
         gtk_widget_show (w);
         gtk_notebook_insert_page (GTK_NOTEBOOK (g_pGroupDlg->m_pNotebook), frame, w, 1);
       }
@@ -2852,7 +2849,7 @@ void MainFrame::Create ()
       GtkWidget* frame = create_framed_texwnd(m_pTexWnd);
 
       {
-        GtkWidget* w = gtk_label_new ("Textures");
+        GtkWidget* w = gtk_label_new (_("Textures"));
         gtk_widget_show (w);
         gtk_notebook_insert_page (GTK_NOTEBOOK (g_pGroupDlg->m_pNotebook), frame, w, 1);
       }
@@ -2921,7 +2918,7 @@ void MainFrame::Create ()
 
   SetActiveXY(m_pXYWnd);
 
-  s_idle_id = gtk_timeout_add (25, mainframe_idle, this);  
+  s_idle_id = gtk_timeout_add (25, mainframe_idle, this);
 
   QGL_InitExtensions ();
 
@@ -2932,7 +2929,7 @@ void MainFrame::Create ()
   }
 
   // remove the pid file
-  remove (g_pidGameFile.GetBuffer ());  
+  remove (g_pidGameFile.GetBuffer ());
 
   Sys_Printf ("Entering message loop\n");
 
@@ -3017,8 +3014,8 @@ static void Sys_Iconify (GtkWidget *w)
     return;
 
 #if defined (__linux__) || defined (__APPLE__)
-  Sys_FPrintf(SYS_WRN, "FIXME: Sys_Iconify\n");  
-#if 0  
+  Sys_FPrintf(SYS_WRN, "FIXME: Sys_Iconify\n");
+#if 0
   XWindowAttributes xattr;
   GdkWindowPrivate *Private;
 
@@ -3127,7 +3124,7 @@ void MainFrame::OnSleep()
     if (CurrentStyle() == eSplit)
       Sys_Iconify (m_pZWnd->m_pParent);
 
-    Sys_Iconify (m_pWidget);  
+    Sys_Iconify (m_pWidget);
     Select_Deselect();
     QERApp_FreeShaders ();
     g_bScreenUpdates = false;
@@ -3666,15 +3663,15 @@ void MainFrame::CreateQEChildren()
     char buf[PATH_MAX];
     const char *r;
     bool bTriedTemplate = false;
-    
+
     if (g_PrefsDlg.m_nLastProjectVer != 0 && g_PrefsDlg.m_nLastProjectVer != PROJECT_VERSION) {
       // we need to regenerate from template
       Sys_Printf("last project has version %d, this binary wants version %d - regenerating from the template\n", g_PrefsDlg.m_nLastProjectVer, PROJECT_VERSION);
       g_PrefsDlg.m_strLastProject = "";
     }
-    
-    r = g_PrefsDlg.m_strLastProject.GetBuffer();    
-    
+
+    r = g_PrefsDlg.m_strLastProject.GetBuffer();
+
     while(r == NULL || *r == '\0' || access(r, R_OK) != 0 || !QE_LoadProject(r))
     {
       if(!bTriedTemplate)
@@ -3690,9 +3687,9 @@ void MainFrame::CreateQEChildren()
       }
       else
       {
-        gtk_MessageBox (NULL, "Failed to load project file.\nPlease enter a valid project file.", "Load Project");
+        gtk_MessageBox (NULL, _("Failed to load project file.\nPlease enter a valid project file."), _("Load Project"));
 
-        filename = file_dialog (m_pWidget, TRUE, "Choose Project File", buf, "project");
+        filename = file_dialog (m_pWidget, TRUE, _("Choose Project File"), buf, "project");
         if (filename != NULL)
           r = filename;
         else
@@ -3704,7 +3701,7 @@ void MainFrame::CreateQEChildren()
   QE_Init ();
 }
 
-void MainFrame::OnTimer() 
+void MainFrame::OnTimer()
 {
   GdkModifierType mask;
 
@@ -3766,7 +3763,7 @@ void MainFrame::SetButtonMenuStates()
                                   (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CLUSTERPORTALS) != 0);
   item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_lightgrid"));
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
-                                  (g_qeglobals.d_savedinfo.exclude & EXCLUDE_LIGHTGRID) != 0);  
+                                  (g_qeglobals.d_savedinfo.exclude & EXCLUDE_LIGHTGRID) != 0);
   item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_world"));
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
                                   (g_qeglobals.d_savedinfo.exclude & EXCLUDE_WORLD) != 0);
@@ -3790,7 +3787,7 @@ void MainFrame::SetButtonMenuStates()
                                   (g_qeglobals.d_savedinfo.exclude & EXCLUDE_CLIP) != 0);
   item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_botclips"));
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
-                                  (g_qeglobals.d_savedinfo.exclude & EXCLUDE_BOTCLIP) != 0);   
+                                  (g_qeglobals.d_savedinfo.exclude & EXCLUDE_BOTCLIP) != 0);
   item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_structural"));
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
                                   (g_qeglobals.d_savedinfo.exclude & EXCLUDE_STRUCTURAL) != 0);
@@ -3830,7 +3827,7 @@ void MainFrame::SetButtonMenuStates()
   item  = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_opengllighting"));
   gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), (g_PrefsDlg.m_bGLLighting) ? TRUE : FALSE);
   item  = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_snaptogrid"));
-  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), (!g_PrefsDlg.m_bNoClamp) ? TRUE : FALSE);
+  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), (g_PrefsDlg.m_bSnap) ? TRUE : FALSE);
 
   item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_view_cubicclipping"));
   gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (item), (g_PrefsDlg.m_bCubicClipping) ? TRUE : FALSE);
@@ -3865,7 +3862,7 @@ void MainFrame::SetButtonMenuStates()
 /*
   if (g_qeglobals.d_project_entity)
   {
-    FillTextureMenu();      // redundant but i'll clean it up later.. yeah right.. 
+    FillTextureMenu();      // redundant but i'll clean it up later.. yeah right..
     FillBSPMenu();
   }
   */
@@ -4107,26 +4104,26 @@ void SignalToolbarButton(GtkWidget *widget, gpointer data)
 
 void MainFrame::AddPlugInToolbarButton(const IToolbarButton* button)
 {
-  GtkWidget*const toolbar = GTK_WIDGET(g_object_get_data (G_OBJECT (m_pWidget), "toolbar_plugin"));    
+  GtkWidget*const toolbar = GTK_WIDGET(g_object_get_data (G_OBJECT (m_pWidget), "toolbar_plugin"));
   toolbar_insert(toolbar, button->getImage(), button->getText(), button->getTooltip(), button->getType(), GTK_SIGNAL_FUNC(SignalToolbarButton), reinterpret_cast<gpointer>(const_cast<IToolbarButton*>(button)));
 }
 
-void MainFrame::OnSelectionSelectNudgedown() 
+void MainFrame::OnSelectionSelectNudgedown()
 {
   NudgeSelection(3, g_qeglobals.d_gridsize);
 }
 
-void MainFrame::OnSelectionSelectNudgeleft() 
+void MainFrame::OnSelectionSelectNudgeleft()
 {
   NudgeSelection(0, g_qeglobals.d_gridsize);
 }
 
-void MainFrame::OnSelectionSelectNudgeright() 
+void MainFrame::OnSelectionSelectNudgeright()
 {
   NudgeSelection(2, g_qeglobals.d_gridsize);
 }
 
-void MainFrame::OnSelectionSelectNudgeup() 
+void MainFrame::OnSelectionSelectNudgeup()
 {
   NudgeSelection(1, g_qeglobals.d_gridsize);
 }
@@ -4214,10 +4211,10 @@ void MainFrame::Nudge(int nDim, float fNudge)
   vec3_t vMove;
   vMove[0] = vMove[1] = vMove[2] = 0;
   vMove[nDim] = fNudge;
-  
-  if((g_qeglobals.d_select_mode == sel_vertex || 
-      g_qeglobals.d_select_mode == sel_curvepoint) 
-      && g_qeglobals.d_num_move_points) 
+
+  if((g_qeglobals.d_select_mode == sel_vertex ||
+      g_qeglobals.d_select_mode == sel_curvepoint)
+      && g_qeglobals.d_num_move_points)
     Select_NudgePoint(vMove, true);
   else
     Select_Move(vMove, true);
@@ -4250,13 +4247,13 @@ void MainFrame::UpdatePatchToolbarButtons()
 // =============================================================================
 // Command handlers
 
-void MainFrame::OnFileNew() 
+void MainFrame::OnFileNew()
 {
   if (ConfirmModified())
     Map_New ();
 }
 
-void MainFrame::OnFileOpen() 
+void MainFrame::OnFileOpen()
 {
   if (!ConfirmModified())
     return;
@@ -4264,10 +4261,14 @@ void MainFrame::OnFileOpen()
   const char *str;
        char buf[NAME_MAX];
 
-  strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
-  strcat(buf, "maps/");
+       if (!g_pGameDescription->noMapsInHome) {
+               strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
+               strcat(buf, "maps/");
+       } else {
+               buf[0] = '\0';
+       }
 
-  str = file_dialog (m_pWidget, TRUE, "Open Map", buf, MAP_MAJOR);
+  str = file_dialog (m_pWidget, TRUE, _("Open Map"), buf, MAP_MAJOR, "maps/");
 
   if (str != NULL)
   {
@@ -4277,15 +4278,19 @@ void MainFrame::OnFileOpen()
   }
 }
 
-void MainFrame::OnFileImportmap() 
+void MainFrame::OnFileImportmap()
 {
   const char *str;
        char buf[NAME_MAX];
 
-  strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
-  strcat(buf, "maps/");
+       if (!g_pGameDescription->noMapsInHome) {
+               strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
+               strcat(buf, "maps/");
+       } else {
+               buf[0] = '\0';
+       }
 
-  str = file_dialog (m_pWidget, TRUE, "Import Map", buf, MAP_MAJOR);
+  str = file_dialog (m_pWidget, TRUE, _("Import Map"), buf, MAP_MAJOR, "maps/");
 
   if (str != NULL)
   {
@@ -4293,7 +4298,7 @@ void MainFrame::OnFileImportmap()
   }
 }
 
-void MainFrame::OnFileSave() 
+void MainFrame::OnFileSave()
 {
   if (!strcmp(currentmap, "unnamed.map"))
     OnFileSaveas();
@@ -4301,16 +4306,20 @@ void MainFrame::OnFileSave()
     Map_SaveFile (currentmap, false);
 }
 
-void MainFrame::OnFileSaveas() 
+void MainFrame::OnFileSaveas()
 {
   const char* str;
        char buf[NAME_MAX];
-  
-  strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
-  strcat(buf, "maps/");
 
-  str = file_dialog (g_pParentWnd->m_pWidget, FALSE, "Save Map", buf, MAP_MAJOR);
-    
+       if (!g_pGameDescription->noMapsInHome) {
+               strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
+               strcat(buf, "maps/");
+       } else {
+               buf[0] = '\0';
+       }
+
+  str = file_dialog (g_pParentWnd->m_pWidget, FALSE, _("Save Map"), buf, MAP_MAJOR, "maps/");
+
   if (str != NULL)
   {
     strcpy (currentmap, str);
@@ -4319,15 +4328,19 @@ void MainFrame::OnFileSaveas()
   }
 }
 
-void MainFrame::OnFileExportmap() 
+void MainFrame::OnFileExportmap()
 {
   const char* str;
        char buf[NAME_MAX];
 
-  strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
-  strcat(buf, "maps/");
+       if (!g_pGameDescription->noMapsInHome) {
+               strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
+               strcat(buf, "maps/");
+       } else {
+               buf[0] = '\0';
+       }
 
-  str = file_dialog (m_pWidget, FALSE, "Export Selection", buf, MAP_MAJOR);
+  str = file_dialog (m_pWidget, FALSE, _("Export Selection"), buf, MAP_MAJOR, "maps/");
 
   if (str != NULL)
   {
@@ -4335,23 +4348,27 @@ void MainFrame::OnFileExportmap()
   }
 }
 
-void MainFrame::OnFileSaveregion() 
+void MainFrame::OnFileSaveregion()
 {
   const char* str;
        char buf[NAME_MAX];
 
-  strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
-  strcat(buf, "maps/");
+       if (!g_pGameDescription->noMapsInHome) {
+               strcpy(buf, g_qeglobals.m_strHomeMaps.GetBuffer());
+               strcat(buf, "maps/");
+       } else {
+               buf[0] = '\0';
+       }
+
+  str = file_dialog (g_pParentWnd->m_pWidget, FALSE, _("Export Region"), buf, MAP_MAJOR, "maps/");
 
-  str = file_dialog (g_pParentWnd->m_pWidget, FALSE, "Export Region", buf, MAP_MAJOR);
-    
   if (str != NULL)
   {
     Map_SaveFile (str, true);  // ignore region
   }
 }
 
-void MainFrame::OnFileNewproject() 
+void MainFrame::OnFileNewproject()
 {
   char* name = DoNewProjectDlg ();
 
@@ -4370,21 +4387,21 @@ void MainFrame::OnFileNewproject()
 
     CString strProjToLoad;
     CString strMapToLoad;
-    
+
     // if the dir exists, ask the user if they want to continue anyway
     if (Q_mkdir (strNewBasePath.GetBuffer(), 0755) != 0)
     {
       CString strMsg;
       strMsg.Format("The directory name %s already exists\nContinue anyway ?\n", strNewBasePath.GetBuffer ());
       Sys_Printf(strMsg);
-      if (gtk_MessageBox(m_pWidget, strMsg, "Error", MB_YESNO) != IDYES)
+      if (gtk_MessageBox(m_pWidget, _(strMsg), _("Error"), MB_YESNO) != IDYES)
       {
         Sys_Printf("New Project cancelled, directory already exists for project\n");
         free (name);
         return;
       }
     }
-    
+
     CString strDir;
     strDir = strNewBasePath;
     strDir += "maps/";
@@ -4401,13 +4418,13 @@ void MainFrame::OnFileNewproject()
     // print a warning for total conversions, since setting the basepath when required files are
     // not there _will_ break things (ie; textures/radiant/notex.tga, scripts/entities.def)
     Sys_FPrintf(SYS_WRN, "*** Note: basepath unchanged\n");
-    
+
     SetKeyValue( g_qeglobals.d_project_entity, "gamename", name);
-    
-    strDir = strNewBasePath; 
+
+    strDir = strNewBasePath;
     strDir += "maps/autosave.map";
     SetKeyValue( g_qeglobals.d_project_entity, "autosave", strDir.GetBuffer() );
-    
+
     // state that this is a user project file, no templating
     SetKeyValue( g_qeglobals.d_project_entity, "user_project", "1" );
     // create the project file
@@ -4415,19 +4432,19 @@ void MainFrame::OnFileNewproject()
     strProjToLoad += "scripts/";
                strProjToLoad += name;
                strProjToLoad += ".";
-               strProjToLoad += PROJECT_FILETYPE;    
+               strProjToLoad += PROJECT_FILETYPE;
     QE_SaveProject(strProjToLoad.GetBuffer());
     free (name);
   }
 }
 
-void MainFrame::OnFileLoadproject() 
+void MainFrame::OnFileLoadproject()
 {
   if (ConfirmModified())
     ProjectDialog ();
 }
 
-void MainFrame::OnFileProjectsettings() 
+void MainFrame::OnFileProjectsettings()
 {
   DoProjectSettings();
 }
@@ -4440,13 +4457,13 @@ void MainFrame::OnFilePointfile()
     Pointfile_Check ();
 }
 
-void MainFrame::OnMru(unsigned int nID) 
+void MainFrame::OnMru(unsigned int nID)
 {
   if (ConfirmModified())
     MRU_Activate (nID - ID_FILE_RECENT1);
 }
 
-void MainFrame::OnFileExit() 
+void MainFrame::OnFileExit()
 {
   if (ConfirmModified())
   {
@@ -4469,29 +4486,29 @@ void MainFrame::OnFileCheckUpdate()
 #ifdef _WIN32
   URL += "&OS_dlup=1";
 #else
-  URL += "&OS_dlup=2";  
+  URL += "&OS_dlup=2";
 #endif
   URL += "&Version_dlup=" RADIANT_VERSION;
   g_PrefsDlg.mGamesDialog.AddPacksURL(URL);
   OpenURL(URL.GetBuffer());
 }
 
-void MainFrame::OnEditUndo() 
+void MainFrame::OnEditUndo()
 {
   Undo_Undo();
 }
 
-void MainFrame::OnEditRedo() 
+void MainFrame::OnEditRedo()
 {
   Undo_Redo();
 }
 
-void MainFrame::OnEditCopybrush() 
+void MainFrame::OnEditCopybrush()
 {
   Copy();
 }
 
-void MainFrame::OnEditPastebrush() 
+void MainFrame::OnEditPastebrush()
 {
   Select_Deselect();
 
@@ -4505,7 +4522,7 @@ void MainFrame::OnEditPastebrush()
 
 void MainFrame::OnEditPastebrushToCamera()
 {
-  Select_Deselect();   
+  Select_Deselect();
   if (ActiveXY())
   {
     vec3_t mid, camorigin, delta;
@@ -4532,7 +4549,7 @@ void MainFrame::OnEditPastebrushToCamera()
   }
 }
 
-void MainFrame::OnSelectionDelete() 
+void MainFrame::OnSelectionDelete()
 {
   brush_t *brush;
   //if (ActiveXY())
@@ -4550,22 +4567,22 @@ void MainFrame::OnSelectionDelete()
   Undo_End();
 }
 
-void MainFrame::OnEditMapinfo() 
+void MainFrame::OnEditMapinfo()
 {
   DoMapInfo ();
 }
 
-void MainFrame::OnEditEntityinfo() 
+void MainFrame::OnEditEntityinfo()
 {
   DoEntityList ();
 }
 
-void MainFrame::OnBrushScripts() 
+void MainFrame::OnBrushScripts()
 {
   DoScriptsDlg ();
 }
 
-void MainFrame::OnEditLoadprefab() 
+void MainFrame::OnEditLoadprefab()
 {
   const char *filename;
   CString CurPath;
@@ -4576,7 +4593,7 @@ void MainFrame::OnEditLoadprefab()
     AddSlash (CurPath);
   }
 
-  filename = file_dialog (m_pWidget, TRUE, "Import Prefab", CurPath.GetBuffer(), MAP_MAJOR);
+  filename = file_dialog (m_pWidget, TRUE, _("Import Prefab"), CurPath.GetBuffer(), MAP_MAJOR, "prefabs/");
 
   if (filename != NULL)
   {
@@ -4584,7 +4601,7 @@ void MainFrame::OnEditLoadprefab()
   }
 }
 
-void MainFrame::OnEditSaveprefab() 
+void MainFrame::OnEditSaveprefab()
 {
   const char *filename;
   CString CurPath;
@@ -4600,23 +4617,23 @@ void MainFrame::OnEditSaveprefab()
   }
   AddSlash (CurPath);
 
-  filename = file_dialog (m_pWidget, FALSE, "Export Prefab", CurPath.GetBuffer(), MAP_MAJOR);
+  filename = file_dialog (m_pWidget, FALSE, _("Export Prefab"), CurPath.GetBuffer(), MAP_MAJOR, "prefabs/");
   if (filename != NULL)
   {
     Map_SaveSelected(filename);
   }
 }
 
-void MainFrame::OnPrefs() 
+void MainFrame::OnPrefs()
 {
   int nView = g_PrefsDlg.m_nView;
   bool bToolbar = g_PrefsDlg.m_bWideToolbar;
   bool bPluginToolbar = g_PrefsDlg.m_bPluginToolbar;
   int nShader = g_PrefsDlg.m_nShader;
   int nTextureQuality = g_PrefsDlg.m_nTextureQuality;
-  int nLightRadiuses = g_PrefsDlg.m_nLightRadiuses;
+//  int nLightRadiuses = g_PrefsDlg.m_nLightRadiuses;
   g_PrefsDlg.LoadPrefs();
-  
+
   if (g_PrefsDlg.DoModal() == IDOK)
   {
     if ((g_PrefsDlg.m_nLatchedView != nView) ||
@@ -4625,10 +4642,10 @@ void MainFrame::OnPrefs()
         (g_PrefsDlg.m_bLatchedPatchToolbar != bToolbar) ||
         (g_PrefsDlg.m_bLatchedPluginToolbar != bPluginToolbar) ||
         (g_PrefsDlg.m_nLatchedShader != nShader) ||
-        (g_PrefsDlg.m_nLatchedTextureQuality != nTextureQuality) 
+        (g_PrefsDlg.m_nLatchedTextureQuality != nTextureQuality)
         || (g_PrefsDlg.m_bLatchedFloatingZ != g_PrefsDlg.m_bFloatingZ)
         )
-      gtk_MessageBox(m_pWidget, "You must restart Radiant for the changes to take effect.");
+      gtk_MessageBox(m_pWidget, _("You must restart Radiant for the changes to take effect."));
 
     // if the view mode was switched to floating, set the Z window on by default
     // this was originally intended as a bug fix, but the fix is elsewhere .. anyway making sure we force Z on each time is good
@@ -4644,12 +4661,12 @@ void MainFrame::OnPrefs()
     GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_snaptogrid"));
     g_bIgnoreCommands++;
     gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item),
-                                    (!g_PrefsDlg.m_bNoClamp) ? TRUE : FALSE);
+                                    (g_PrefsDlg.m_bSnap) ? TRUE : FALSE);
     g_bIgnoreCommands--;
   }
 }
 
-void MainFrame::OnTogglecamera() 
+void MainFrame::OnTogglecamera()
 {
   if (CurrentStyle() == eFloating) // floating views
   {
@@ -4669,7 +4686,7 @@ void MainFrame::OnTogglecamera()
   }
 }
 
-void MainFrame::OnToggleconsole() 
+void MainFrame::OnToggleconsole()
 {
   if (FloatingGroupDialog()) // QE4 style
   {
@@ -4693,7 +4710,7 @@ void MainFrame::OnViewEntity()
   // make sure we're working with the current selection (bugzilla #436)
   if( ! GTK_WIDGET_VISIBLE (g_qeglobals_gui.d_entity))
     Select_Reselect();
-  
+
   if (!FloatingGroupDialog())
   {
     if (GTK_WIDGET_VISIBLE (g_qeglobals_gui.d_entity) && inspector_mode == W_ENTITY)
@@ -4746,7 +4763,7 @@ void MainFrame::OnViewGroups()
   }
 }
 
-void MainFrame::OnToggleview() 
+void MainFrame::OnToggleview()
 {
   if (CurrentStyle() == eFloating) // QE4 style
   {
@@ -4760,7 +4777,7 @@ void MainFrame::OnToggleview()
   }
 }
 
-void MainFrame::OnToggleviewXz() 
+void MainFrame::OnToggleviewXz()
 {
   if (CurrentStyle() == eFloating) // QE4 style
   {
@@ -4778,7 +4795,7 @@ void MainFrame::OnToggleviewXz()
   }
 }
 
-void MainFrame::OnToggleviewYz() 
+void MainFrame::OnToggleviewYz()
 {
   if (CurrentStyle() == eFloating) // QE4 style
   {
@@ -4795,7 +4812,7 @@ void MainFrame::OnToggleviewYz()
   }
 }
 
-void MainFrame::OnTogglez() 
+void MainFrame::OnTogglez()
 {
   if ( g_pParentWnd->FloatingGroupDialog() ) // QE4 style
   {
@@ -4813,19 +4830,19 @@ void MainFrame::OnTogglez()
   }
 }
 
-void MainFrame::OnViewCenter() 
+void MainFrame::OnViewCenter()
 {
   m_pCamWnd->Camera()->angles[ROLL] = m_pCamWnd->Camera()->angles[PITCH] = 0;
   m_pCamWnd->Camera()->angles[YAW] = 22.5 * floor((m_pCamWnd->Camera()->angles[YAW]+11)/22.5);
   Sys_UpdateWindows (W_CAMERA | W_XY_OVERLAY);
 }
 
-void MainFrame::OnViewUpfloor() 
+void MainFrame::OnViewUpfloor()
 {
   m_pCamWnd->Cam_ChangeFloor (true);
 }
 
-void MainFrame::OnViewDownfloor() 
+void MainFrame::OnViewDownfloor()
 {
   m_pCamWnd->Cam_ChangeFloor (false);
 }
@@ -4845,7 +4862,7 @@ void MainFrame::OnViewCenterview()
   }
 }
 
-void MainFrame::OnViewNextview() 
+void MainFrame::OnViewNextview()
 {
   if (CurrentStyle() == eSplit)
   {
@@ -4867,7 +4884,7 @@ void MainFrame::OnViewNextview()
   }
 }
 
-void MainFrame::OnViewXy() 
+void MainFrame::OnViewXy()
 {
   if(!FloatingGroupDialog())
   {
@@ -4877,7 +4894,7 @@ void MainFrame::OnViewXy()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewSide() 
+void MainFrame::OnViewSide()
 {
   if (!FloatingGroupDialog())
   {
@@ -4887,7 +4904,7 @@ void MainFrame::OnViewSide()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewFront() 
+void MainFrame::OnViewFront()
 {
   if (!FloatingGroupDialog())
   {
@@ -4897,7 +4914,7 @@ void MainFrame::OnViewFront()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnView100() 
+void MainFrame::OnView100()
 {
   if (m_pXYWnd)
     m_pXYWnd->SetScale(1);
@@ -4908,7 +4925,7 @@ void MainFrame::OnView100()
   Sys_UpdateWindows (W_XY|W_XY_OVERLAY);
 }
 
-void MainFrame::OnViewZoomin() 
+void MainFrame::OnViewZoomin()
 {
   if (m_pXYWnd && m_pXYWnd->Active())
   {
@@ -4937,7 +4954,7 @@ void MainFrame::OnViewZoomin()
 // NOTE: the zoom out factor is 4/5, we could think about customizing it
 //  we don't go below a zoom factor corresponding to 10% of the max world size
 //  (this has to be computed against the window size)
-void MainFrame::OnViewZoomout() 
+void MainFrame::OnViewZoomout()
 {
   float min_scale;
   if (m_pXYWnd && m_pXYWnd->Active())
@@ -4963,13 +4980,13 @@ void MainFrame::OnViewZoomout()
   Sys_UpdateWindows (W_XY|W_XY_OVERLAY);
 }
 
-void MainFrame::OnViewZ100() 
+void MainFrame::OnViewZ100()
 {
   z.scale = 1;
   Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
 }
 
-void MainFrame::OnViewZzoomin() 
+void MainFrame::OnViewZzoomin()
 {
   z.scale *= 5.0/4;
   if (z.scale > 4)
@@ -4977,7 +4994,7 @@ void MainFrame::OnViewZzoomin()
   Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
 }
 
-void MainFrame::OnViewZzoomout() 
+void MainFrame::OnViewZzoomout()
 {
   z.scale *= 4.0f/5;
   if (z.scale < 0.125)
@@ -4985,7 +5002,7 @@ void MainFrame::OnViewZzoomout()
   Sys_UpdateWindows (W_Z|W_Z_OVERLAY);
 }
 
-void MainFrame::OnViewCubein() 
+void MainFrame::OnViewCubein()
 {
   g_PrefsDlg.m_nCubicScale--;
   if (g_PrefsDlg.m_nCubicScale < 1)
@@ -4995,7 +5012,7 @@ void MainFrame::OnViewCubein()
   SetGridStatus();
 }
 
-void MainFrame::OnViewCubeout() 
+void MainFrame::OnViewCubeout()
 {
   g_PrefsDlg.m_nCubicScale++;
   if (g_PrefsDlg.m_nCubicScale > 22)
@@ -5005,7 +5022,7 @@ void MainFrame::OnViewCubeout()
   SetGridStatus();
 }
 
-void MainFrame::OnViewShownames() 
+void MainFrame::OnViewShownames()
 {
   g_qeglobals.d_savedinfo.show_names = !g_qeglobals.d_savedinfo.show_names;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_shownames"));
@@ -5016,7 +5033,7 @@ void MainFrame::OnViewShownames()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewShowAngles() 
+void MainFrame::OnViewShowAngles()
 {
   g_qeglobals.d_savedinfo.show_angles = !g_qeglobals.d_savedinfo.show_angles;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_showangles"));
@@ -5027,7 +5044,7 @@ void MainFrame::OnViewShowAngles()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewShowblocks() 
+void MainFrame::OnViewShowblocks()
 {
   g_qeglobals.show_blocks ^= 1;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_showblocks"));
@@ -5037,7 +5054,7 @@ void MainFrame::OnViewShowblocks()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewShowcoordinates() 
+void MainFrame::OnViewShowcoordinates()
 {
   g_qeglobals.d_savedinfo.show_coordinates ^= 1;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_showcoordinates"));
@@ -5087,21 +5104,21 @@ void MainFrame::OnViewShowWorkzone()
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnViewHideshowHideselected() 
+void MainFrame::OnViewHideshowHideselected()
 {
   Select_Hide();
   Select_Deselect();
 }
 
-void MainFrame::OnViewHideshowShowhidden() 
+void MainFrame::OnViewHideshowShowhidden()
 {
   Select_ShowAllHidden();
 }
 
-/** 
+/**
 sets the view mode for the entities
 called upon LoadPrefs too
-NOTE TTimo previous implementation had a SavePrefs call 
+NOTE TTimo previous implementation had a SavePrefs call
   .. I don't think it is relevant, removed (the prefs are saved upon exit)
 NOTE TTimo we activate the menu item, this is only needed when we are called upon a prefs load
   (otherwise we are always called following user action on the widget)
@@ -5182,7 +5199,7 @@ void MainFrame::OnEntitiesSetViewAs(int mode)
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnViewCubicclipping() 
+void MainFrame::OnViewCubicclipping()
 {
   GtkWidget *w;
 
@@ -5198,7 +5215,7 @@ void MainFrame::OnViewCubicclipping()
   Sys_UpdateWindows(W_CAMERA);
 }
 
-void MainFrame::OnViewOpengllighting() 
+void MainFrame::OnViewOpengllighting()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_view_opengllighting"));
   g_PrefsDlg.m_bGLLighting ^= 1;
@@ -5209,7 +5226,7 @@ void MainFrame::OnViewOpengllighting()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnSelectionDragedges() 
+void MainFrame::OnSelectionDragedges()
 {
   if (g_qeglobals.d_select_mode == sel_edge)
   {
@@ -5224,7 +5241,7 @@ void MainFrame::OnSelectionDragedges()
   }
 }
 
-void MainFrame::OnSelectionDragvertecies() 
+void MainFrame::OnSelectionDragvertecies()
 {
   if (g_qeglobals.d_select_mode == sel_vertex || g_qeglobals.d_select_mode == sel_curvepoint)
   {
@@ -5246,13 +5263,13 @@ void MainFrame::OnSelectionDragvertecies()
   }
 }
 
-void MainFrame::OnSelectionClone() 
+void MainFrame::OnSelectionClone()
 {
   Select_Clone();
 }
 
 // called when the escape key is used (either on the main window or on an inspector)
-void MainFrame::OnSelectionDeselect() 
+void MainFrame::OnSelectionDeselect()
 {
   if (g_bClipMode)
     OnViewClipper();
@@ -5281,7 +5298,7 @@ void MainFrame::OnSelectionDeselect()
   }
 }
 
-void MainFrame::OnBrushFlipx() 
+void MainFrame::OnBrushFlipx()
 {
   Undo_Start("flip X");
   Undo_AddBrushList(&selected_brushes);
@@ -5306,7 +5323,7 @@ void MainFrame::OnBrushFlipx()
   Undo_End();
 }
 
-void MainFrame::OnBrushFlipy() 
+void MainFrame::OnBrushFlipy()
 {
   Undo_Start("flip Y");
   Undo_AddBrushList(&selected_brushes);
@@ -5339,14 +5356,14 @@ void MainFrame::OnBrushFlipy()
       SetKeyValue(b->owner, "angle", buf);
       Brush_Build(b,true,true,false,false); // don't filter
     }
-  
+
   }
   */
   Undo_EndBrushList(&selected_brushes);
   Undo_End();
 }
 
-void MainFrame::OnBrushFlipz() 
+void MainFrame::OnBrushFlipz()
 {
   Undo_Start("flip Z");
   Undo_AddBrushList(&selected_brushes);
@@ -5355,7 +5372,7 @@ void MainFrame::OnBrushFlipz()
   Undo_End();
 }
 
-void MainFrame::OnBrushRotatex() 
+void MainFrame::OnBrushRotatex()
 {
   Undo_Start("rotate X");
   Undo_AddBrushList(&selected_brushes);
@@ -5364,7 +5381,7 @@ void MainFrame::OnBrushRotatex()
   Undo_End();
 }
 
-void MainFrame::OnBrushRotatey() 
+void MainFrame::OnBrushRotatey()
 {
   Undo_Start("rotate Y");
   Undo_AddBrushList(&selected_brushes);
@@ -5373,7 +5390,7 @@ void MainFrame::OnBrushRotatey()
   Undo_End();
 }
 
-void MainFrame::OnBrushRotatez() 
+void MainFrame::OnBrushRotatez()
 {
   Undo_Start("rotate Z");
   Undo_AddBrushList(&selected_brushes);
@@ -5382,7 +5399,7 @@ void MainFrame::OnBrushRotatez()
   Undo_End();
 }
 
-void MainFrame::OnSelectionArbitraryrotation() 
+void MainFrame::OnSelectionArbitraryrotation()
 {
   Undo_Start("arbitrary rotation");
   Undo_AddBrushList(&selected_brushes);
@@ -5393,7 +5410,7 @@ void MainFrame::OnSelectionArbitraryrotation()
   Undo_End();
 }
 
-void MainFrame::OnSelectScale() 
+void MainFrame::OnSelectScale()
 {
   Undo_Start("scale");
   Undo_AddBrushList(&selected_brushes);
@@ -5402,7 +5419,7 @@ void MainFrame::OnSelectScale()
   Undo_End();
 }
 
-void MainFrame::OnSelectionMakehollow() 
+void MainFrame::OnSelectionMakehollow()
 {
   //if (ActiveXY())
   //   ActiveXY()->UndoCopy();
@@ -5413,7 +5430,7 @@ void MainFrame::OnSelectionMakehollow()
   Undo_End();
 }
 
-void MainFrame::OnSelectionCsgsubtract() 
+void MainFrame::OnSelectionCsgsubtract()
 {
   Undo_Start("CSG subtract");
   CSG_Subtract();
@@ -5457,29 +5474,29 @@ void MainFrame::OnSelectionOutlineStyle()
   Sys_UpdateWindows (W_CAMERA);
 }
 
-void MainFrame::OnSelectionSelectcompletetall() 
+void MainFrame::OnSelectionSelectcompletetall()
 {
   if (ActiveXY())
     ActiveXY()->UndoCopy();
   Select_CompleteTall ();
 }
 
-void MainFrame::OnSelectionSelecttouching() 
+void MainFrame::OnSelectionSelecttouching()
 {
   Select_Touching();
 }
 
-void MainFrame::OnSelectionSelectpartialtall() 
+void MainFrame::OnSelectionSelectpartialtall()
 {
   Select_PartialTall();
 }
 
-void MainFrame::OnSelectionSelectinside() 
+void MainFrame::OnSelectionSelectinside()
 {
   Select_Inside ();
 }
 
-void MainFrame::OnViewClipper() 
+void MainFrame::OnViewClipper()
 {
   GtkWidget *w = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_view_clipper"));
   g_bIgnoreCommands++;
@@ -5501,7 +5518,7 @@ void MainFrame::OnViewClipper()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnClipSelected() 
+void MainFrame::OnClipSelected()
 {
   if (m_pActiveXY && m_pActiveXY->ClipMode())
   {
@@ -5519,7 +5536,7 @@ void MainFrame::OnClipSelected()
   }
 }
 
-void MainFrame::OnSplitSelected() 
+void MainFrame::OnSplitSelected()
 {
   if (m_pActiveXY)
   {
@@ -5531,13 +5548,13 @@ void MainFrame::OnSplitSelected()
   }
 }
 
-void MainFrame::OnFlipClip() 
+void MainFrame::OnFlipClip()
 {
   if (m_pActiveXY)
     m_pActiveXY->FlipClip();
 }
 
-void MainFrame::OnSelectionConnect() 
+void MainFrame::OnSelectionConnect()
 {
   Undo_Start("connect selected entities");
   Undo_AddBrushList(&selected_brushes);
@@ -5546,7 +5563,7 @@ void MainFrame::OnSelectionConnect()
   Undo_End();
 }
 
-void MainFrame::OnSelectionUngroupentity() 
+void MainFrame::OnSelectionUngroupentity()
 {
   Undo_Start("ungroup selected entities");
   Undo_AddBrushList(&selected_brushes);
@@ -5555,7 +5572,7 @@ void MainFrame::OnSelectionUngroupentity()
   Undo_End();
 }
 
-void MainFrame::OnSelectionMergeentity() 
+void MainFrame::OnSelectionMergeentity()
 {
   Undo_Start("merge entity");
   Undo_AddBrushList(&selected_brushes);
@@ -5564,7 +5581,7 @@ void MainFrame::OnSelectionMergeentity()
   Undo_End();
 }
 
-void MainFrame::OnSelectionGroupworld() 
+void MainFrame::OnSelectionGroupworld()
 {
   Undo_Start("group world");
   Undo_AddBrushList(&selected_brushes);
@@ -5573,7 +5590,7 @@ void MainFrame::OnSelectionGroupworld()
   Undo_End();
 }
 
-void MainFrame::OnSelectionMakeDetail() 
+void MainFrame::OnSelectionMakeDetail()
 {
   Undo_Start("make detail");
   Undo_AddBrushList(&selected_brushes);
@@ -5582,7 +5599,7 @@ void MainFrame::OnSelectionMakeDetail()
   Undo_End();
 }
 
-void MainFrame::OnSelectionMakeStructural() 
+void MainFrame::OnSelectionMakeStructural()
 {
   Undo_Start("make structural");
   Undo_AddBrushList(&selected_brushes);
@@ -5591,18 +5608,17 @@ void MainFrame::OnSelectionMakeStructural()
   Undo_End();
 }
 
-void MainFrame::OnBspCommand (unsigned int nID) 
+void MainFrame::OnBspCommand (unsigned int nID)
 {
-  // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=503
   // make sure we don't attempt to region compile a map with the camera outside the region
   if (region_active)
   {
     vec3_t vOrig;
     VectorSet(vOrig,
       (int)g_pParentWnd->GetCamWnd()->Camera()->origin[0],
-      (int)g_pParentWnd->GetCamWnd()->Camera()->origin[1], 
+      (int)g_pParentWnd->GetCamWnd()->Camera()->origin[1],
       (int)g_pParentWnd->GetCamWnd()->Camera()->origin[2]);
-    
+
     int i;
     for (i=0 ; i<3 ; i++)
     {
@@ -5633,7 +5649,7 @@ void MainFrame::OnBspCommand (unsigned int nID)
   }
 }
 
-void MainFrame::OnGrid (unsigned int nID) 
+void MainFrame::OnGrid (unsigned int nID)
 {
   if (nID == ID_GRID_025)
   {
@@ -5671,18 +5687,18 @@ void MainFrame::OnGrid (unsigned int nID)
   Sys_UpdateWindows (W_XY|W_Z);
 }
 
-void MainFrame::OnSnaptogrid() 
+void MainFrame::OnSnaptogrid()
 {
-  g_PrefsDlg.m_bNoClamp ^= 1;
+  g_PrefsDlg.m_bSnap ^= 1;
   g_PrefsDlg.SavePrefs ();
 
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_snaptogrid"));
   g_bIgnoreCommands++;
-  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), g_PrefsDlg.m_bNoClamp ? FALSE : TRUE);
+  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (item), g_PrefsDlg.m_bSnap ? TRUE : FALSE);
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnTexturesShowinuse() 
+void MainFrame::OnTexturesShowinuse()
 {
   Sys_BeginWait ();
   Texture_ShowInuse ();
@@ -5694,28 +5710,28 @@ void MainFrame::OnTexturesShowinuse()
   Sys_EndWait ();
 }
 
-void MainFrame::OnTexturesShowall() 
+void MainFrame::OnTexturesShowall()
 {
   Texture_ShowAll();
 }
 
 // do some triggering on/off, if the inspector is already up then hide it
-void MainFrame::OnTexturesInspector() 
+void MainFrame::OnTexturesInspector()
 {
   ToggleSurface();
 }
 
-void MainFrame::OnViewNearest(unsigned int nID) 
+void MainFrame::OnViewNearest(unsigned int nID)
 {
   Texture_SetMode(nID);
 }
 
-void MainFrame::OnTextureReplaceall() 
+void MainFrame::OnTextureReplaceall()
 {
   FindTextureDialog::show();
 }
 
-void MainFrame::OnToggleLock() 
+void MainFrame::OnToggleLock()
 {
   g_PrefsDlg.m_bTextureLock = !g_PrefsDlg.m_bTextureLock;
 
@@ -5727,7 +5743,7 @@ void MainFrame::OnToggleLock()
   SetGridStatus();
 }
 
-void MainFrame::OnToggleRotatelock() 
+void MainFrame::OnToggleRotatelock()
 {
   g_PrefsDlg.m_bRotateLock ^= 1;
 
@@ -5741,19 +5757,18 @@ void MainFrame::OnToggleRotatelock()
 
 // use a dialog for direct selection of a texture menu
 // the API is a bit crappy, we need to set texture_directory to the directory name in <basepath>/textures/
-void MainFrame::OnTexturesLoad() 
+void MainFrame::OnTexturesLoad()
 {
   char def_path[NAME_MAX];
 
        // FIXME
        // check if that works with fs_game (I suspect some more design is needed)
        // see how this is done in 1.2?
-       // http://zerowing.idsoftware.com/bugzilla/show_bug.cgi?id=507
   strcpy (def_path, g_pGameDescription->mEnginePath.GetBuffer());
   strcat (def_path, g_pGameDescription->mBaseGame.GetBuffer());
   strcat (def_path, "/");
 
-  char *dir = dir_dialog (m_pWidget, "Load textures from path", def_path);
+  char *dir = dir_dialog (m_pWidget, _("Load textures from path"), def_path);
 
   if (dir != NULL)
   {
@@ -5777,7 +5792,7 @@ void MainFrame::OnTexturesLoad()
     Sys_FPrintf(SYS_WRN, "texture load dialog cancelled\n");
 }
 
-void MainFrame::OnTexturesReloadshaders() 
+void MainFrame::OnTexturesReloadshaders()
 {
   Sys_BeginWait ();
   QERApp_ReloadShaders();
@@ -5788,7 +5803,7 @@ void MainFrame::OnTexturesReloadshaders()
   Sys_EndWait();
 }
 
-void MainFrame::OnTexturesShadersShow() 
+void MainFrame::OnTexturesShadersShow()
 {
   g_PrefsDlg.m_bShowShaders ^= 1;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_textures_shaders_show"));
@@ -5833,7 +5848,7 @@ void MainFrame::SetTextureScale(int id)
   Texture_ResetPosition();
 }
 
-void MainFrame::OnTexturewindowScaleup() 
+void MainFrame::OnTexturewindowScaleup()
 {
   switch(g_PrefsDlg.m_nTextureScale) {
   // 200, all the way in, don't do anything
@@ -5852,7 +5867,7 @@ void MainFrame::OnTexturewindowScaleup()
   }
 }
 
-void MainFrame::OnTexturewindowScaledown() 
+void MainFrame::OnTexturewindowScaledown()
 {
   switch(g_PrefsDlg.m_nTextureScale) {
   case 200:
@@ -5871,12 +5886,12 @@ void MainFrame::OnTexturewindowScaledown()
   }
 }
 
-void MainFrame::OnTexturesLoadlist() 
+void MainFrame::OnTexturesLoadlist()
 {
   DoTextureListDlg ();
 }
 
-void MainFrame::OnTexturesShaderlistonly() 
+void MainFrame::OnTexturesShaderlistonly()
 {
   g_PrefsDlg.m_bTexturesShaderlistOnly ^= 1;
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget),"menu_textures_shaderlistonly"));
@@ -5886,7 +5901,7 @@ void MainFrame::OnTexturesShaderlistonly()
   FillTextureMenu();
 }
 
-void MainFrame::OnTextureWad(unsigned int nID) 
+void MainFrame::OnTextureWad(unsigned int nID)
 {
   Sys_BeginWait ();
   Texture_ShowDirectory (nID);
@@ -5894,12 +5909,12 @@ void MainFrame::OnTextureWad(unsigned int nID)
   Sys_EndWait ();
 }
 
-void MainFrame::OnMiscBenchmark() 
+void MainFrame::OnMiscBenchmark()
 {
   m_pCamWnd->BenchMark();
 }
 
-void MainFrame::OnColorSetoriginal() 
+void MainFrame::OnColorSetoriginal()
 {
   for (int i=0 ; i<3 ; i++)
   {
@@ -5951,7 +5966,7 @@ void MainFrame::OnColorSetoriginal()
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorSetqer() 
+void MainFrame::OnColorSetqer()
 {
   for (int i=0 ; i<3 ; i++)
   {
@@ -5993,7 +6008,7 @@ void MainFrame::OnColorSetqer()
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorSetblack() 
+void MainFrame::OnColorSetblack()
 {
   for (int i=0 ; i<3 ; i++)
   {
@@ -6039,7 +6054,7 @@ void MainFrame::OnColorSetblack()
 }
 
 /* ydnar: to emulate maya/max/lightwave color schemes */
-void MainFrame::OnColorSetydnar() 
+void MainFrame::OnColorSetydnar()
 {
   for (int i=0 ; i<3 ; i++)
   {
@@ -6081,120 +6096,120 @@ void MainFrame::OnColorSetydnar()
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnTexturebk() 
+void MainFrame::OnTexturebk()
 {
   DoColor(COLOR_TEXTUREBACK);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsXybk() 
+void MainFrame::OnColorsXybk()
 {
   DoColor(COLOR_GRIDBACK);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsMajor() 
+void MainFrame::OnColorsMajor()
 {
   DoColor(COLOR_GRIDMAJOR);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsMinor() 
+void MainFrame::OnColorsMinor()
 {
   DoColor(COLOR_GRIDMINOR);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsMajor_Alt() 
+void MainFrame::OnColorsMajor_Alt()
 {
   DoColor(COLOR_GRIDMAJOR_ALT);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsMinor_Alt() 
+void MainFrame::OnColorsMinor_Alt()
 {
   DoColor(COLOR_GRIDMINOR_ALT);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsGridtext() 
+void MainFrame::OnColorsGridtext()
 {
   DoColor(COLOR_GRIDTEXT);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsGridblock() 
+void MainFrame::OnColorsGridblock()
 {
   DoColor(COLOR_GRIDBLOCK);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsCameraBack() 
+void MainFrame::OnColorsCameraBack()
 {
   DoColor(COLOR_CAMERABACK);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsBrush() 
+void MainFrame::OnColorsBrush()
 {
   DoColor(COLOR_BRUSHES);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsSelectedbrush() 
+void MainFrame::OnColorsSelectedbrush()
 {
   DoColor(COLOR_SELBRUSHES);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsSelectedbrush3D() 
+void MainFrame::OnColorsSelectedbrush3D()
 {
   DoColor(COLOR_SELBRUSHES3D);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsClipper() 
+void MainFrame::OnColorsClipper()
 {
   DoColor(COLOR_CLIPPER);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnColorsViewname() 
+void MainFrame::OnColorsViewname()
 {
   DoColor(COLOR_VIEWNAME);
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnMiscGamma() 
+void MainFrame::OnMiscGamma()
 {
   float fSave = g_qeglobals.d_savedinfo.fGamma;
   DoGamma();
   if (fSave != g_qeglobals.d_savedinfo.fGamma)
   {
-    gtk_MessageBox(m_pWidget, "You must restart Radiant for Gamma settings to take effect.");
+    gtk_MessageBox(m_pWidget, _("You must restart Radiant for Gamma settings to take effect."));
   }
 }
-void MainFrame::OnMiscFindbrush() 
+void MainFrame::OnMiscFindbrush()
 {
   DoFind();
 }
 
-void MainFrame::OnMiscNextleakspot() 
+void MainFrame::OnMiscNextleakspot()
 {
   Pointfile_Next();
 }
 
-void MainFrame::OnMiscPreviousleakspot() 
+void MainFrame::OnMiscPreviousleakspot()
 {
   Pointfile_Prev();
 }
 
-void MainFrame::OnMiscPrintxy() 
+void MainFrame::OnMiscPrintxy()
 {
-//  WXY_Print();
+  WXY_Print();
 }
 
-void MainFrame::OnMiscSelectentitycolor() 
+void MainFrame::OnMiscSelectentitycolor()
 {
   if (edit_entity)
   {
@@ -6230,7 +6245,7 @@ void MainFrame::OnMiscSelectentitycolor()
   }
 }
 
-void MainFrame::OnConvertcurves() 
+void MainFrame::OnConvertcurves()
 {
 #if 0
   Select_Deselect();
@@ -6252,32 +6267,32 @@ void MainFrame::OnConvertcurves()
 #endif
 }
 
-void MainFrame::OnRegionOff() 
+void MainFrame::OnRegionOff()
 {
   Map_RegionOff ();
 }
 
-void MainFrame::OnRegionSetxy() 
+void MainFrame::OnRegionSetxy()
 {
   Map_RegionXY ();
 }
 
-void MainFrame::OnRegionSettallbrush() 
+void MainFrame::OnRegionSettallbrush()
 {
   Map_RegionTallBrush ();
 }
 
-void MainFrame::OnRegionSetbrush() 
+void MainFrame::OnRegionSetbrush()
 {
   Map_RegionBrush ();
 }
 
-void MainFrame::OnRegionSetselection() 
+void MainFrame::OnRegionSetselection()
 {
   Map_RegionSelectedBrushes ();
 }
 
-void MainFrame::OnBrush3sided() 
+void MainFrame::OnBrush3sided()
 {
   Undo_Start("3 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6286,7 +6301,7 @@ void MainFrame::OnBrush3sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush4sided() 
+void MainFrame::OnBrush4sided()
 {
   Undo_Start("4 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6295,7 +6310,7 @@ void MainFrame::OnBrush4sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush5sided() 
+void MainFrame::OnBrush5sided()
 {
   Undo_Start("5 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6304,7 +6319,7 @@ void MainFrame::OnBrush5sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush6sided() 
+void MainFrame::OnBrush6sided()
 {
   Undo_Start("6 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6313,7 +6328,7 @@ void MainFrame::OnBrush6sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush7sided() 
+void MainFrame::OnBrush7sided()
 {
   Undo_Start("7 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6322,7 +6337,7 @@ void MainFrame::OnBrush7sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush8sided() 
+void MainFrame::OnBrush8sided()
 {
   Undo_Start("8 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6331,7 +6346,7 @@ void MainFrame::OnBrush8sided()
   Undo_End();
 }
 
-void MainFrame::OnBrush9sided() 
+void MainFrame::OnBrush9sided()
 {
   Undo_Start("9 sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6340,7 +6355,7 @@ void MainFrame::OnBrush9sided()
   Undo_End();
 }
 
-void MainFrame::OnBrushArbitrarysided() 
+void MainFrame::OnBrushArbitrarysided()
 {
   Undo_Start("arbitrary sided");
   Undo_AddBrushList(&selected_brushes);
@@ -6349,7 +6364,7 @@ void MainFrame::OnBrushArbitrarysided()
   Undo_End();
 }
 
-void MainFrame::OnBrushMakecone() 
+void MainFrame::OnBrushMakecone()
 {
   Undo_Start("make cone");
   Undo_AddBrushList(&selected_brushes);
@@ -6358,7 +6373,7 @@ void MainFrame::OnBrushMakecone()
   Undo_End();
 }
 
-void MainFrame::OnBrushPrimitivesSphere() 
+void MainFrame::OnBrushPrimitivesSphere()
 {
   Undo_Start("make sphere");
   Undo_AddBrushList(&selected_brushes);
@@ -6369,7 +6384,7 @@ void MainFrame::OnBrushPrimitivesSphere()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchtube() 
+void MainFrame::OnCurvePatchtube()
 {
   Undo_Start("make curve cylinder");
   Undo_AddBrushList(&selected_brushes);
@@ -6379,7 +6394,7 @@ void MainFrame::OnCurvePatchtube()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchdensetube() 
+void MainFrame::OnCurvePatchdensetube()
 {
   Undo_Start("dense cylinder");
   Undo_AddBrushList(&selected_brushes);
@@ -6392,7 +6407,7 @@ void MainFrame::OnCurvePatchdensetube()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchverydensetube() 
+void MainFrame::OnCurvePatchverydensetube()
 {
   Undo_Start("very dense cylinder");
   Undo_AddBrushList(&selected_brushes);
@@ -6407,7 +6422,7 @@ void MainFrame::OnCurvePatchverydensetube()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchsquare() 
+void MainFrame::OnCurvePatchsquare()
 {
   Undo_Start("square cylinder");
   Undo_AddBrushList(&selected_brushes);
@@ -6419,7 +6434,7 @@ void MainFrame::OnCurvePatchsquare()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchendcap() 
+void MainFrame::OnCurvePatchendcap()
 {
   Undo_Start("make end cap");
   Undo_AddBrushList(&selected_brushes);
@@ -6429,7 +6444,7 @@ void MainFrame::OnCurvePatchendcap()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchbevel() 
+void MainFrame::OnCurvePatchbevel()
 {
   Undo_Start("make bevel");
   Undo_AddBrushList(&selected_brushes);
@@ -6439,7 +6454,7 @@ void MainFrame::OnCurvePatchbevel()
   Undo_End();
 }
 
-void MainFrame::OnCurveMoreendcapsbevelsSquarebevel() 
+void MainFrame::OnCurveMoreendcapsbevelsSquarebevel()
 {
   Undo_Start("square bevel");
   Undo_AddBrushList(&selected_brushes);
@@ -6451,7 +6466,7 @@ void MainFrame::OnCurveMoreendcapsbevelsSquarebevel()
   Undo_End();
 }
 
-void MainFrame::OnCurveMoreendcapsbevelsSquareendcap() 
+void MainFrame::OnCurveMoreendcapsbevelsSquareendcap()
 {
   Undo_Start("square endcap");
   Undo_AddBrushList(&selected_brushes);
@@ -6463,7 +6478,7 @@ void MainFrame::OnCurveMoreendcapsbevelsSquareendcap()
   Undo_End();
 }
 
-void MainFrame::OnCurvePatchcone() 
+void MainFrame::OnCurvePatchcone()
 {
   Undo_Start("make curve cone");
   Undo_AddBrushList(&selected_brushes);
@@ -6473,7 +6488,7 @@ void MainFrame::OnCurvePatchcone()
   Undo_End();
 }
 
-void MainFrame::OnCurveSimplepatchmesh() 
+void MainFrame::OnCurveSimplepatchmesh()
 {
   Undo_Start("make simpe patch mesh");
   Undo_AddBrushList(&selected_brushes);
@@ -6482,7 +6497,7 @@ void MainFrame::OnCurveSimplepatchmesh()
   Undo_End();
 }
 
-void MainFrame::OnCurveInsertInsertcolumn() 
+void MainFrame::OnCurveInsertInsertcolumn()
 {
   Undo_Start("insert (2) columns");
   Undo_AddBrushList(&selected_brushes);
@@ -6492,7 +6507,7 @@ void MainFrame::OnCurveInsertInsertcolumn()
   Undo_End();
 }
 
-void MainFrame::OnCurveInsertAddcolumn() 
+void MainFrame::OnCurveInsertAddcolumn()
 {
   Undo_Start("add (2) columns");
   Undo_AddBrushList(&selected_brushes);
@@ -6502,7 +6517,7 @@ void MainFrame::OnCurveInsertAddcolumn()
   Undo_End();
 }
 
-void MainFrame::OnCurveInsertInsertrow() 
+void MainFrame::OnCurveInsertInsertrow()
 {
   Undo_Start("insert (2) rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6512,7 +6527,7 @@ void MainFrame::OnCurveInsertInsertrow()
   Undo_End();
 }
 
-void MainFrame::OnCurveInsertAddrow() 
+void MainFrame::OnCurveInsertAddrow()
 {
   Undo_Start("add (2) rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6522,7 +6537,7 @@ void MainFrame::OnCurveInsertAddrow()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeleteFirstcolumn() 
+void MainFrame::OnCurveDeleteFirstcolumn()
 {
   Undo_Start("delete first (2) columns");
   Undo_AddBrushList(&selected_brushes);
@@ -6532,7 +6547,7 @@ void MainFrame::OnCurveDeleteFirstcolumn()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeleteLastcolumn() 
+void MainFrame::OnCurveDeleteLastcolumn()
 {
   Undo_Start("delete last (2) columns");
   Undo_AddBrushList(&selected_brushes);
@@ -6542,7 +6557,7 @@ void MainFrame::OnCurveDeleteLastcolumn()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeleteFirstrow() 
+void MainFrame::OnCurveDeleteFirstrow()
 {
   Undo_Start("delete first (2) rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6552,7 +6567,7 @@ void MainFrame::OnCurveDeleteFirstrow()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeleteLastrow() 
+void MainFrame::OnCurveDeleteLastrow()
 {
   Undo_Start("delete last (2) rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6562,13 +6577,13 @@ void MainFrame::OnCurveDeleteLastrow()
   Undo_End();
 }
 
-void MainFrame::OnCurveNegative() 
+void MainFrame::OnCurveNegative()
 {
   Patch_ToggleInverted();
   //Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnCurveRedisperseRows() 
+void MainFrame::OnCurveRedisperseRows()
 {
   Undo_Start("redisperse rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6578,7 +6593,7 @@ void MainFrame::OnCurveRedisperseRows()
   Undo_End();
 }
 
-void MainFrame::OnCurveRedisperseIntermediateCols() 
+void MainFrame::OnCurveRedisperseIntermediateCols()
 {
   Undo_Start("redisperse im cols");
   Undo_AddBrushList(&selected_brushes);
@@ -6588,7 +6603,7 @@ void MainFrame::OnCurveRedisperseIntermediateCols()
   Undo_End();
 }
 
-void MainFrame::OnCurveRedisperseIntermediateRows() 
+void MainFrame::OnCurveRedisperseIntermediateRows()
 {
   Undo_Start("redisperse im rows");
   Undo_AddBrushList(&selected_brushes);
@@ -6598,37 +6613,37 @@ void MainFrame::OnCurveRedisperseIntermediateRows()
   Undo_End();
 }
 
-void MainFrame::OnCurveMatrixTranspose() 
+void MainFrame::OnCurveMatrixTranspose()
 {
   Patch_Transpose();
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnCurveCap() 
+void MainFrame::OnCurveCap()
 {
   Patch_CapCurrent();
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnCurveCyclecap() 
+void MainFrame::OnCurveCyclecap()
 {
   Patch_CycleCapSelected();
   Sys_UpdateWindows (W_ALL);
 }
 
-void MainFrame::OnCurveOverlaySet() 
+void MainFrame::OnCurveOverlaySet()
 {
   Patch_SetOverlays();
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnCurveOverlayClear() 
+void MainFrame::OnCurveOverlayClear()
 {
   Patch_ClearOverlays();
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnCurveThicken() 
+void MainFrame::OnCurveThicken()
 {
   Undo_Start("curve thicken");
   Undo_AddBrushList(&selected_brushes);
@@ -6641,14 +6656,14 @@ void MainFrame::OnCurveThicken()
 this can no longer be trigger manually from the menu
 happens only once at startup
 */
-void MainFrame::OnPluginsRefresh() 
+void MainFrame::OnPluginsRefresh()
 {
   CleanPlugInMenu();
   m_PlugInMgr.Init();
 }
 
 // open the Q3Rad manual
-void MainFrame::OnHelp() 
+void MainFrame::OnHelp()
 {
   // at least on win32, g_strGameToolsPath + "Q3Rad_Manual/index.htm"
   Str help;
@@ -6658,7 +6673,7 @@ void MainFrame::OnHelp()
 }
 
 // FIXME: we'll go towards a unified help thing soon
-void MainFrame::OnHelpLinks() 
+void MainFrame::OnHelpLinks()
 {
   Str link;
   link = g_strAppPath;
@@ -6666,25 +6681,25 @@ void MainFrame::OnHelpLinks()
   OpenURL(link.GetBuffer());
 }
 
-void MainFrame::OnHelpBugreport() 
+void MainFrame::OnHelpBugreport()
 {
   OpenURL("http://www.qeradiant.com/faq/fom-serve/cache/138.html");
 }
 
-void MainFrame::OnHelpCommandlist() 
+void MainFrame::OnHelpCommandlist()
 {
   DoCommandListDlg ();
 }
 
-void MainFrame::OnHelpAbout() 
+void MainFrame::OnHelpAbout()
 {
   DoAbout();
 }
 
-void MainFrame::OnPopupSelection() 
+void MainFrame::OnPopupSelection()
 {
   GtkWidget *menu, *item;
-  char *labels[] = { "Select Complete Tall", "Select Touching", "Select Partial Tall", "Select Inside"};
+  const gchar *labels[] = { _("Select Complete Tall"), _("Select Touching"), _("Select Partial Tall"), _("Select Inside")};
   int ids[] = { ID_SELECTION_SELECTCOMPLETETALL, ID_SELECTION_SELECTTOUCHING,
     ID_SELECTION_SELECTPARTIALTALL, ID_SELECTION_SELECTINSIDE};
 
@@ -6702,13 +6717,13 @@ void MainFrame::OnPopupSelection()
   gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
 }
 
-void MainFrame::OnViewChange() 
+void MainFrame::OnViewChange()
 {
   OnViewNextview();
-  //HandlePopup(this, IDR_POPUP_VIEW); 
+  //HandlePopup(this, IDR_POPUP_VIEW);
 }
 
-void MainFrame::OnTexturesPopup() 
+void MainFrame::OnTexturesPopup()
 {
   gpointer item = g_object_get_data (G_OBJECT (m_pWidget), "render_quality_menu");
   gtk_menu_popup (GTK_MENU (item), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
@@ -6722,12 +6737,12 @@ void MainFrame::ToggleCamera()
     m_bCamPreview = true;
 }
 
-void MainFrame::OnViewCameraupdate() 
+void MainFrame::OnViewCameraupdate()
 {
   Sys_UpdateWindows(W_CAMERA);
 }
 
-void MainFrame::OnSelectMouserotate() 
+void MainFrame::OnSelectMouserotate()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_select_mouserotate"));
   g_bIgnoreCommands++;
@@ -6754,7 +6769,7 @@ void MainFrame::OnSelectMouserotate()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnSelectMousescale() 
+void MainFrame::OnSelectMousescale()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_select_mousescale"));
   g_bIgnoreCommands++;
@@ -6782,7 +6797,7 @@ void MainFrame::OnSelectMousescale()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnScalelockx() 
+void MainFrame::OnScalelockx()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_scalelockx"));
   g_bIgnoreCommands++;
@@ -6799,7 +6814,7 @@ void MainFrame::OnScalelockx()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnScalelocky() 
+void MainFrame::OnScalelocky()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_scalelocky"));
   g_bIgnoreCommands++;
@@ -6816,7 +6831,7 @@ void MainFrame::OnScalelocky()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnScalelockz() 
+void MainFrame::OnScalelockz()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_scalelockz"));
   g_bIgnoreCommands++;
@@ -6833,7 +6848,7 @@ void MainFrame::OnScalelockz()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnDontselectcurve() 
+void MainFrame::OnDontselectcurve()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_dontselectcurve"));
   g_bIgnoreCommands++;
@@ -6852,7 +6867,7 @@ void MainFrame::OnPatchToggleBox()
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnPatchWireframe() 
+void MainFrame::OnPatchWireframe()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_patch_wireframe"));
   g_bIgnoreCommands++;
@@ -6862,7 +6877,7 @@ void MainFrame::OnPatchWireframe()
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnPatchBend() 
+void MainFrame::OnPatchBend()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_patch_bend"));
   g_bIgnoreCommands++;
@@ -6872,7 +6887,7 @@ void MainFrame::OnPatchBend()
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnPatchWeld() 
+void MainFrame::OnPatchWeld()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_patch_weld"));
   g_bIgnoreCommands++;
@@ -6882,7 +6897,7 @@ void MainFrame::OnPatchWeld()
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnPatchDrilldown() 
+void MainFrame::OnPatchDrilldown()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_patch_drilldown"));
   g_bIgnoreCommands++;
@@ -6892,13 +6907,13 @@ void MainFrame::OnPatchDrilldown()
   Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnShowEntities() 
+void MainFrame::OnShowEntities()
 {
   gpointer item = g_object_get_data (G_OBJECT (m_pWidget), "view_entitiesas_menu"); // use pointer to existing menu object
   gtk_menu_popup (GTK_MENU (item), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME);
 }
 
-void MainFrame::OnDropGroupName() 
+void MainFrame::OnDropGroupName()
 {
   /*
   char* name = DoNameDlg ("Name Selection");
@@ -6912,12 +6927,12 @@ void MainFrame::OnDropGroupName()
   */
 }
 
-void MainFrame::OnDropGroupNewgroup() 
+void MainFrame::OnDropGroupNewgroup()
 {
 
 }
 
-void MainFrame::OnDropGroupRemove() 
+void MainFrame::OnDropGroupRemove()
 {
   /*
   Select_AddToGroup("World");
@@ -6931,7 +6946,7 @@ void MainFrame::OnFaceFit()
   SurfaceDlgFitAll();
 }
 
-void MainFrame::OnDontselectmodel() 
+void MainFrame::OnDontselectmodel()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "tb_dontselectmodel"));
   g_bIgnoreCommands++;
@@ -6940,7 +6955,7 @@ void MainFrame::OnDontselectmodel()
   g_bIgnoreCommands--;
 }
 
-void MainFrame::OnViewTexture() 
+void MainFrame::OnViewTexture()
 {
   if (FloatingGroupDialog()) // QE4 style
   {
@@ -6963,13 +6978,13 @@ void MainFrame::OnPatchInspector()
   TogglePatchInspector();
 }
 
-void MainFrame::OnCurveNegativeTextureX() 
+void MainFrame::OnCurveNegativeTextureX()
 {
   Patch_InvertTexture(false);
   //Sys_UpdateWindows(W_ALL);
 }
 
-void MainFrame::OnCurveNegativeTextureY() 
+void MainFrame::OnCurveNegativeTextureY()
 {
   Patch_InvertTexture(true);
   //Sys_UpdateWindows(W_ALL);
@@ -7001,7 +7016,7 @@ void MainFrame::OnCurveInsertrow()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeletecolumn() 
+void MainFrame::OnCurveDeletecolumn()
 {
   if (&selected_brushes == selected_brushes.next)
     return;
@@ -7013,7 +7028,7 @@ void MainFrame::OnCurveDeletecolumn()
   Undo_End();
 }
 
-void MainFrame::OnCurveDeleterow() 
+void MainFrame::OnCurveDeleterow()
 {
   if (&selected_brushes == selected_brushes.next)
     return;
@@ -7025,7 +7040,7 @@ void MainFrame::OnCurveDeleterow()
   Undo_End();
 }
 
-void MainFrame::OnPatchTab() 
+void MainFrame::OnPatchTab()
 {
   if (g_bPatchBendMode)
     Patch_BendHandleTAB();
@@ -7034,7 +7049,7 @@ void MainFrame::OnPatchTab()
   else
   {
     // check to see if the selected brush is part of a func group
-    // if it is, deselect everything and reselect the next brush 
+    // if it is, deselect everything and reselect the next brush
     // in the group
     brush_t *b2, *b = selected_brushes.next;
     entity_t * e;
@@ -7098,7 +7113,7 @@ void MainFrame::OnCameraForward(bool keydown)
   }
 }
 
-void MainFrame::OnCameraBack(bool keydown) 
+void MainFrame::OnCameraBack(bool keydown)
 {
   if (g_PrefsDlg.m_bCamDiscrete && (m_pCamWnd && !m_pCamWnd->m_bFreeMove) )
   {
@@ -7117,7 +7132,7 @@ void MainFrame::OnCameraBack(bool keydown)
   }
 }
 
-void MainFrame::OnCameraLeft(bool keydown) 
+void MainFrame::OnCameraLeft(bool keydown)
 {
   if (m_pCamWnd)
   {
@@ -7145,7 +7160,7 @@ void MainFrame::OnCameraLeft(bool keydown)
   }
 }
 
-void MainFrame::OnCameraRight(bool keydown) 
+void MainFrame::OnCameraRight(bool keydown)
 {
   if (m_pCamWnd)
   {
@@ -7173,21 +7188,21 @@ void MainFrame::OnCameraRight(bool keydown)
   }
 }
 
-void MainFrame::OnCameraUp() 
+void MainFrame::OnCameraUp()
 {
   m_pCamWnd->Camera()->origin[2] += SPEED_MOVE;
   int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY | W_Z) : (W_CAMERA);
   Sys_UpdateWindows (nUpdate);
 }
 
-void MainFrame::OnCameraDown() 
+void MainFrame::OnCameraDown()
 {
   m_pCamWnd->Camera()->origin[2] -= SPEED_MOVE;
   int nUpdate = (g_PrefsDlg.m_bCamXYUpdate) ? (W_CAMERA | W_XY | W_Z) : (W_CAMERA);
   Sys_UpdateWindows (nUpdate);
 }
 
-void MainFrame::OnCameraAngleup() 
+void MainFrame::OnCameraAngleup()
 {
   m_pCamWnd->Camera()->angles[0] += SPEED_TURN;
   if (m_pCamWnd->Camera()->angles[0] > 85)
@@ -7195,7 +7210,7 @@ void MainFrame::OnCameraAngleup()
   Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY);
 }
 
-void MainFrame::OnCameraAngledown() 
+void MainFrame::OnCameraAngledown()
 {
   m_pCamWnd->Camera()->angles[0] -= SPEED_TURN;
   if (m_pCamWnd->Camera()->angles[0] < -85)
@@ -7203,7 +7218,7 @@ void MainFrame::OnCameraAngledown()
   Sys_UpdateWindows (W_CAMERA|W_XY_OVERLAY);
 }
 
-void MainFrame::OnCameraStrafeleft(bool keydown) 
+void MainFrame::OnCameraStrafeleft(bool keydown)
 {
   // FIXME: as soon as gtk supports proper keyup/down support, remove this bit
   if (m_pCamWnd)
@@ -7226,7 +7241,7 @@ void MainFrame::OnCameraStrafeleft(bool keydown)
     m_pCamWnd->Camera()->movementflags &= ~MOVE_STRAFELEFT;
 }
 
-void MainFrame::OnCameraStraferight(bool keydown) 
+void MainFrame::OnCameraStraferight(bool keydown)
 {
   // FIXME: as soon as gtk supports proper keyup/down support, remove this bit
   if (m_pCamWnd)
@@ -7249,69 +7264,69 @@ void MainFrame::OnCameraStraferight(bool keydown)
     m_pCamWnd->Camera()->movementflags &= ~MOVE_STRAFERIGHT;
 }
 
-void MainFrame::OnGridToggle() 
+void MainFrame::OnGridToggle()
 {
   g_qeglobals.d_showgrid = !g_qeglobals.d_showgrid;
   Sys_UpdateWindows (W_XY|W_Z);
 }
 
-void MainFrame::OnViewCrosshair() 
+void MainFrame::OnViewCrosshair()
 {
-  g_bCrossHairs ^= 1; 
+  g_bCrossHairs ^= 1;
   Sys_UpdateWindows (W_XY);
 }
 
-void MainFrame::OnSelectionTextureRotateclock() 
+void MainFrame::OnSelectionTextureRotateclock()
 {
   Select_RotateTexture(abs(g_PrefsDlg.m_nRotation));
 }
 
-void MainFrame::OnSelectionTextureRotatecounter() 
+void MainFrame::OnSelectionTextureRotatecounter()
 {
   Select_RotateTexture(-abs(g_PrefsDlg.m_nRotation));
 }
 
-void MainFrame::OnSelectionTextureScaleup() 
+void MainFrame::OnSelectionTextureScaleup()
 {
   Select_ScaleTexture(0, g_qeglobals.d_savedinfo.m_SIIncrement.scale[1]);
 }
 
-void MainFrame::OnSelectionTextureScaledown() 
+void MainFrame::OnSelectionTextureScaledown()
 {
   Select_ScaleTexture(0, -g_qeglobals.d_savedinfo.m_SIIncrement.scale[1]);
 }
 
-void MainFrame::OnSelectionTextureScaleLeft() 
+void MainFrame::OnSelectionTextureScaleLeft()
 {
   Select_ScaleTexture(-g_qeglobals.d_savedinfo.m_SIIncrement.scale[0],0);
 }
 
-void MainFrame::OnSelectionTextureScaleRight() 
+void MainFrame::OnSelectionTextureScaleRight()
 {
   Select_ScaleTexture(g_qeglobals.d_savedinfo.m_SIIncrement.scale[0],0);
 }
 
-void MainFrame::OnSelectionTextureShiftleft() 
+void MainFrame::OnSelectionTextureShiftleft()
 {
   Select_ShiftTexture((int)-g_qeglobals.d_savedinfo.m_SIIncrement.shift[0], 0);
 }
 
-void MainFrame::OnSelectionTextureShiftright() 
+void MainFrame::OnSelectionTextureShiftright()
 {
   Select_ShiftTexture((int)g_qeglobals.d_savedinfo.m_SIIncrement.shift[0], 0);
 }
 
-void MainFrame::OnSelectionTextureShiftup() 
+void MainFrame::OnSelectionTextureShiftup()
 {
   Select_ShiftTexture(0, (int)g_qeglobals.d_savedinfo.m_SIIncrement.shift[1]);
 }
 
-void MainFrame::OnSelectionTextureShiftdown() 
+void MainFrame::OnSelectionTextureShiftdown()
 {
   Select_ShiftTexture(0, (int)-g_qeglobals.d_savedinfo.m_SIIncrement.shift[1]);
 }
 
-void MainFrame::OnGridPrev() 
+void MainFrame::OnGridPrev()
 {
   GtkWidget *item;
   if (g_qeglobals.d_gridsize == 1)
@@ -7358,7 +7373,7 @@ void MainFrame::OnGridPrev()
   Sys_UpdateWindows(W_XY | W_Z);
 }
 
-void MainFrame::OnGridNext() 
+void MainFrame::OnGridNext()
 {
   GtkWidget *item;
   if (g_qeglobals.d_gridsize == 0.25)
@@ -7387,6 +7402,7 @@ void MainFrame::OnGridNext()
     case  64: item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_grid_64")); break;
     case 128: item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_grid_128")); break;
     case 256: item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_grid_256")); break;
+       default:  item = NULL;
     }
 
   } else
@@ -7405,7 +7421,7 @@ void MainFrame::OnGridNext()
   Sys_UpdateWindows(W_XY | W_Z);
 }
 
-void MainFrame::OnSelectionMovedown() 
+void MainFrame::OnSelectionMovedown()
 {
   if (&selected_brushes == selected_brushes.next)
     return;
@@ -7422,7 +7438,7 @@ void MainFrame::OnSelectionMovedown()
   Undo_End();
 }
 
-void MainFrame::OnSelectionMoveup() 
+void MainFrame::OnSelectionMoveup()
 {
   if (&selected_brushes == selected_brushes.next)
     return;
@@ -7439,13 +7455,13 @@ void MainFrame::OnSelectionMoveup()
   Undo_End();
 }
 
-void MainFrame::OnSelectionPrint() 
+void MainFrame::OnSelectionPrint()
 {
   for (brush_t* b=selected_brushes.next ; b != &selected_brushes ; b=b->next)
     Brush_Print(b);
 }
 
-void MainFrame::OnSelectionTogglesizepaint() 
+void MainFrame::OnSelectionTogglesizepaint()
 {
   g_PrefsDlg.m_bSizePaint = !g_PrefsDlg.m_bSizePaint;
   Sys_UpdateWindows(W_XY);
@@ -7492,10 +7508,14 @@ void PerformFiltering ()
 {
   brush_t *brush;
 
+  // mattn - this should be removed - otherwise the filters from the
+  // plugins are wiped away with each update
+#if 0
   // spog - deletes old filters list and creates new one when
   // g_qeglobals.d_savedinfo.exclude is updated
   g_qeglobals.d_savedinfo.filters = FilterListDelete(g_qeglobals.d_savedinfo.filters);
   g_qeglobals.d_savedinfo.filters = FilterUpdate(g_qeglobals.d_savedinfo.filters);
+#endif
 
   for ( brush = active_brushes.next; brush != &active_brushes; brush = brush->next )
     brush->bFiltered = FilterBrush( brush );
@@ -7504,7 +7524,7 @@ void PerformFiltering ()
     brush->bFiltered = FilterBrush( brush );
 }
 
-void MainFrame::OnFilterAreaportals() 
+void MainFrame::OnFilterAreaportals()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_areaportals"));
   g_bIgnoreCommands++;
@@ -7517,7 +7537,7 @@ void MainFrame::OnFilterAreaportals()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterCaulk() 
+void MainFrame::OnFilterCaulk()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_caulk"));
   g_bIgnoreCommands++;
@@ -7530,7 +7550,7 @@ void MainFrame::OnFilterCaulk()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterClips() 
+void MainFrame::OnFilterClips()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_clips"));
   g_bIgnoreCommands++;
@@ -7556,7 +7576,7 @@ void MainFrame::OnFilterBotClips()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterStructural() 
+void MainFrame::OnFilterStructural()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_structural"));
   g_bIgnoreCommands++;
@@ -7569,7 +7589,7 @@ void MainFrame::OnFilterStructural()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterDetails() 
+void MainFrame::OnFilterDetails()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_details"));
   g_bIgnoreCommands++;
@@ -7582,7 +7602,7 @@ void MainFrame::OnFilterDetails()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterEntities() 
+void MainFrame::OnFilterEntities()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_entities"));
   g_bIgnoreCommands++;
@@ -7595,7 +7615,7 @@ void MainFrame::OnFilterEntities()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterHintsskips() 
+void MainFrame::OnFilterHintsskips()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_hintsskips"));
   g_bIgnoreCommands++;
@@ -7608,7 +7628,7 @@ void MainFrame::OnFilterHintsskips()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterLights() 
+void MainFrame::OnFilterLights()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_lights"));
   g_bIgnoreCommands++;
@@ -7621,7 +7641,7 @@ void MainFrame::OnFilterLights()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterLiquids() 
+void MainFrame::OnFilterLiquids()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_liquids"));
   g_bIgnoreCommands++;
@@ -7634,7 +7654,7 @@ void MainFrame::OnFilterLiquids()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterModels() 
+void MainFrame::OnFilterModels()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_models"));
   g_bIgnoreCommands++;
@@ -7647,7 +7667,7 @@ void MainFrame::OnFilterModels()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterPatches() 
+void MainFrame::OnFilterPatches()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_patches"));
   g_bIgnoreCommands++;
@@ -7660,7 +7680,7 @@ void MainFrame::OnFilterPatches()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterPaths() 
+void MainFrame::OnFilterPaths()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_paths"));
   g_bIgnoreCommands++;
@@ -7673,7 +7693,7 @@ void MainFrame::OnFilterPaths()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterClusterportals() 
+void MainFrame::OnFilterClusterportals()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_clusterportals"));
   g_bIgnoreCommands++;
@@ -7699,7 +7719,7 @@ void MainFrame::OnFilterLightgrid()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterTranslucent() 
+void MainFrame::OnFilterTranslucent()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_translucent"));
   g_bIgnoreCommands++;
@@ -7712,7 +7732,7 @@ void MainFrame::OnFilterTranslucent()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterTriggers() 
+void MainFrame::OnFilterTriggers()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_triggers"));
   g_bIgnoreCommands++;
@@ -7725,7 +7745,7 @@ void MainFrame::OnFilterTriggers()
   Sys_UpdateWindows (W_XY|W_CAMERA);
 }
 
-void MainFrame::OnFilterWorld() 
+void MainFrame::OnFilterWorld()
 {
   GtkWidget *item = GTK_WIDGET (g_object_get_data (G_OBJECT (m_pWidget), "menu_filter_world"));
   g_bIgnoreCommands++;
@@ -7748,7 +7768,7 @@ void MainFrame::OnFilterWorld()
 // =============================================================================
 // leo: Unused functions, not called anywhere from the code (need to check)
 
-void MainFrame::OnViewConsole() 
+void MainFrame::OnViewConsole()
 {
   if (FloatingGroupDialog()) // QE4 style
   {
@@ -7796,7 +7816,7 @@ void MainFrame::OnPatchEnter()
 
 }
 
-void MainFrame::OnDropGroupAddtoWorld() 
+void MainFrame::OnDropGroupAddtoWorld()
 {
   /*
   Select_AddToGroup("World");