* UFO: Alien Invasion surface plugin
authormattn <mattn>
Tue, 4 Mar 2008 16:51:36 +0000 (16:51 +0000)
committermattn <mattn>
Tue, 4 Mar 2008 16:51:36 +0000 (16:51 +0000)
git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/branches/ZeroRadiant@201 8a3a26a2-13c4-0310-b231-cf6edde360e5

plugins/surface_ufoai/surface_ufoai.def [new file with mode: 0644]
plugins/surface_ufoai/surface_ufoai.vcproj [new file with mode: 0644]
plugins/surface_ufoai/surfacedialog.cpp [new file with mode: 0644]
plugins/surface_ufoai/surfacedialog.h [new file with mode: 0644]
plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp [new file with mode: 0644]
plugins/surface_ufoai/surfaceflagsdialog_ufoai.h [new file with mode: 0644]
plugins/surface_ufoai/surfdlg_plugin.cpp [new file with mode: 0644]
plugins/surface_ufoai/surfdlg_plugin.h [new file with mode: 0644]

diff --git a/plugins/surface_ufoai/surface_ufoai.def b/plugins/surface_ufoai/surface_ufoai.def
new file mode 100644 (file)
index 0000000..23669a7
--- /dev/null
@@ -0,0 +1,8 @@
+; surface_ufoai.def : Declares the module parameters for the DLL.
+
+LIBRARY      "SURFACE_UFOAI"
+DESCRIPTION  'SURFACE_UFOAI Windows Dynamic Link Library'
+
+EXPORTS
+    ; Explicit exports can go here
+       Synapse_EnumerateInterfaces @1
diff --git a/plugins/surface_ufoai/surface_ufoai.vcproj b/plugins/surface_ufoai/surface_ufoai.vcproj
new file mode 100644 (file)
index 0000000..3bb8479
--- /dev/null
@@ -0,0 +1,75 @@
+<?xml version="1.0" ?><VisualStudioProject Name="surface_ufoai" ProjectGUID="{65D02375-63EE-4A8A-9F8E-504B1D5A1D02}" ProjectType="Visual C++" RootNamespace="surface_ufoai" Version="8.00">\r
+       <Platforms>\r
+               <Platform Name="Win32"/>\r
+       </Platforms>\r
+       <ToolFiles>\r
+       </ToolFiles>\r
+       <Configurations>\r
+               <Configuration CharacterSet="2" ConfigurationType="1" IntermediateDirectory="$(ConfigurationName)" Name="Debug|Win32" OutputDirectory="$(SolutionDir)$(ConfigurationName)">\r
+                       <Tool Name="VCPreBuildEventTool"/>\r
+                       <Tool Name="VCCustomBuildTool"/>\r
+                       <Tool Name="VCXMLDataGeneratorTool"/>\r
+                       <Tool Name="VCWebServiceProxyGeneratorTool"/>\r
+                       <Tool Name="VCMIDLTool"/>\r
+                       <Tool AdditionalIncludeDirectories="&quot;$(SolutionDir)\include&quot;;&quot;$(SolutionDir)\libs&quot;;&quot;$(SolutionDir)\..\STLPort\stlport&quot;;&quot;$(SolutionDir)\..\gtk2\include&quot;;&quot;$(SolutionDir)\..\gtk2\include\glib-2.0&quot;;&quot;$(SolutionDir)\..\gtk2\lib\glib-2.0\include&quot;;&quot;$(SolutionDir)\..\libxml2\include&quot;" BasicRuntimeChecks="3" DebugInformationFormat="4" Detect64BitPortabilityProblems="true" DisableSpecificWarnings="4996;4244;4267" MinimalRebuild="true" Name="VCCLCompilerTool" Optimization="0" PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS" RuntimeLibrary="3" WarningLevel="3"/>\r
+                       <Tool Name="VCManagedResourceCompilerTool"/>\r
+                       <Tool Name="VCResourceCompilerTool"/>\r
+                       <Tool Name="VCPreLinkEventTool"/>\r
+                       <Tool GenerateDebugInformation="true" Name="VCLinkerTool" TargetMachine="1"/>\r
+                       <Tool Name="VCALinkTool"/>\r
+                       <Tool Name="VCManifestTool"/>\r
+                       <Tool Name="VCXDCMakeTool"/>\r
+                       <Tool Name="VCBscMakeTool"/>\r
+                       <Tool Name="VCFxCopTool"/>\r
+                       <Tool Name="VCAppVerifierTool"/>\r
+                       <Tool Name="VCWebDeploymentTool"/>\r
+                       <Tool Name="VCPostBuildEventTool"/>\r
+               </Configuration>\r
+               <Configuration CharacterSet="2" ConfigurationType="1" IntermediateDirectory="$(ConfigurationName)" Name="Release|Win32" OutputDirectory="$(SolutionDir)$(ConfigurationName)" WholeProgramOptimization="1">\r
+                       <Tool Name="VCPreBuildEventTool"/>\r
+                       <Tool Name="VCCustomBuildTool"/>\r
+                       <Tool Name="VCXMLDataGeneratorTool"/>\r
+                       <Tool Name="VCWebServiceProxyGeneratorTool"/>\r
+                       <Tool Name="VCMIDLTool"/>\r
+                       <Tool AdditionalIncludeDirectories="&quot;$(SolutionDir)\include&quot;;&quot;$(SolutionDir)\libs&quot;;&quot;$(SolutionDir)\..\STLPort\stlport&quot;;&quot;$(SolutionDir)\..\gtk2\include&quot;;&quot;$(SolutionDir)\..\gtk2\include\glib-2.0&quot;;&quot;$(SolutionDir)\..\gtk2\lib\glib-2.0\include&quot;;&quot;$(SolutionDir)\..\libxml2\include&quot;" DebugInformationFormat="3" Detect64BitPortabilityProblems="true" DisableSpecificWarnings="4996;4244;4267" Name="VCCLCompilerTool" PreprocessorDefinitions="_CRT_SECURE_NO_WARNINGS" RuntimeLibrary="2" WarningLevel="3"/>\r
+                       <Tool Name="VCManagedResourceCompilerTool"/>\r
+                       <Tool Name="VCResourceCompilerTool"/>\r
+                       <Tool Name="VCPreLinkEventTool"/>\r
+                       <Tool EnableCOMDATFolding="2" GenerateDebugInformation="true" Name="VCLinkerTool" OptimizeReferences="2" TargetMachine="1"/>\r
+                       <Tool Name="VCALinkTool"/>\r
+                       <Tool Name="VCManifestTool"/>\r
+                       <Tool Name="VCXDCMakeTool"/>\r
+                       <Tool Name="VCBscMakeTool"/>\r
+                       <Tool Name="VCFxCopTool"/>\r
+                       <Tool Name="VCAppVerifierTool"/>\r
+                       <Tool Name="VCWebDeploymentTool"/>\r
+                       <Tool Name="VCPostBuildEventTool"/>\r
+               </Configuration>\r
+       </Configurations>\r
+       <References>\r
+       </References>\r
+       <Files>\r
+               <Filter Filter="cpp;c;cxx;rc;def;r;odl;idl;hpj;bat" Name="Source Files">\r
+                       <File RelativePath=".\surface_ufoai.def">\r
+                       </File>\r
+                       <File RelativePath=".\surfacedialog.cpp">\r
+                       </File>\r
+                       <File RelativePath=".\surfaceflagsdialog_ufoai.cpp">\r
+                       </File>\r
+                       <File RelativePath=".\surfdlg_plugin.cpp">\r
+                       </File>\r
+               </Filter>\r
+               <Filter Filter="h;hpp;hxx;hm;inl" Name="Header Files">\r
+                       <File RelativePath=".\surfacedialog.h">\r
+                       </File>\r
+                       <File RelativePath=".\surfaceflagsdialog_ufoai.h">\r
+                       </File>\r
+                       <File RelativePath=".\surfdlg_plugin.h">\r
+                       </File>\r
+               </Filter>\r
+               <Filter Filter="ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe" Name="Resource Files">\r
+               </Filter>\r
+       </Files>\r
+       <Globals>\r
+       </Globals>\r
+</VisualStudioProject>
\ No newline at end of file
diff --git a/plugins/surface_ufoai/surfacedialog.cpp b/plugins/surface_ufoai/surfacedialog.cpp
new file mode 100644 (file)
index 0000000..f5e3d0e
--- /dev/null
@@ -0,0 +1,1939 @@
+/*
+Copyright (C) 1999-2007 id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+//
+// Surface Dialog Module
+//
+
+//
+// Nurail: Implemented to Module from the main Radiant Surface Dialog code
+//
+
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "surfdlg_plugin.h"
+
+
+
+#ifdef _DEBUG
+//#define DBG_SI 1
+#endif
+
+#include "gtkr_vector.h"
+
+std::vector<texdef_to_face_t> g_texdef_face_vector;
+
+inline texdef_to_face_t* get_texdef_face_list()
+{
+       return &(*g_texdef_face_vector.begin());
+}
+
+inline unsigned int texdef_face_list_empty()
+{
+       return g_texdef_face_vector.empty();
+}
+
+inline unsigned int texdef_face_list_size()
+{
+       return g_texdef_face_vector.size();
+}
+
+// For different faces having different values
+bool is_HShift_conflicting;
+bool is_VShift_conflicting;
+bool is_HScale_conflicting;
+bool is_VScale_conflicting;
+bool is_Rotate_conflicting;
+bool is_TextureName_conflicting;
+
+void ShowDlg();
+void HideDlg();
+void SetTexMods();
+void GetTexMods(bool b_SetUndoPoint = FALSE);
+void BuildDialog();
+void FitAll();
+void InitDefaultIncrement(texdef_t *);
+void DoSnapTToGrid(float hscale, float vscale);
+// called to perform a fitting from the outside (shortcut key)
+void SurfaceDialogFitAll();
+
+// UFOAI Flags Functions
+void SetFlagButtons_UFOAI(texdef_to_face_t *texdef_face_list,  bool b_isListEmpty);
+void SetChangeInFlags_Face_UFOAI(texdef_to_face_t *texdef_face_list);
+GtkWidget* Create_UFOAIFlagsDialog(GtkWidget* surfacedialog_widget);
+
+
+// Dialog Data
+int m_nHeight;
+int m_nWidth;
+
+// 0 is invalid, otherwise it's the Id of the last 'do' we are responsible for
+int m_nUndoId;
+
+
+texturewin_t *texturewin;
+texdef_t *l_pIncrement;
+texdef_t texdef_offset;
+texdef_t texdef_SI_values;
+
+// For Texture Entry, activate only on entry change
+char old_texture_entry[128];
+
+// the texdef to switch back to when the OnCancel is called
+texdef_t       g_old_texdef;
+
+// when TRUE, this thing means the surface inspector is currently being displayed
+bool  g_surfwin = FALSE;
+// turn on/off processing of the "changed" "value_changed" messages
+// (need to turn off when we are feeding data in)
+bool g_bListenChanged = true;
+// turn on/off listening of the update messages
+bool g_bListenUpdate = true;
+
+GtkWidget* create_SurfaceInspector (void);
+GtkWidget *SurfaceInspector = NULL;
+
+GtkWidget *m_pWidget;
+GtkWidget *GetWidget () { return SurfaceInspector; }
+GtkWidget *Get_SI_Module_Widget () { return SurfaceInspector; }
+void SetWidget(GtkWidget *new_widget) { m_pWidget = new_widget; }
+GtkWidget *GetDlgWidget (const char* name)
+  { return GTK_WIDGET (g_object_get_data (G_OBJECT (SurfaceInspector), name)); }
+
+// Spins for FitTexture
+GtkWidget *spin_width;
+GtkWidget *spin_height;
+
+
+GtkWidget *texture_combo;
+GtkWidget *texture_combo_entry;
+
+GtkWidget *match_grid_button;
+GtkWidget *lock_valuechange_togglebutton;
+
+GtkObject *hshift_value_spinbutton_adj;
+GtkWidget *hshift_value_spinbutton;
+GtkObject *vshift_value_spinbutton_adj;
+GtkWidget *vshift_value_spinbutton;
+GtkObject *hscale_value_spinbutton_adj;
+GtkWidget *hscale_value_spinbutton;
+GtkObject *vscale_value_spinbutton_adj;
+GtkWidget *vscale_value_spinbutton;
+GtkObject *rotate_value_spinbutton_adj;
+GtkWidget *rotate_value_spinbutton;
+
+GtkObject *hshift_offset_spinbutton_adj;
+GtkWidget *hshift_offset_spinbutton;
+GtkObject *vshift_offset_spinbutton_adj;
+GtkWidget *vshift_offset_spinbutton;
+GtkObject *hscale_offset_spinbutton_adj;
+GtkWidget *hscale_offset_spinbutton;
+GtkObject *vscale_offset_spinbutton_adj;
+GtkWidget *vscale_offset_spinbutton;
+GtkObject *rotate_offset_spinbutton_adj;
+GtkWidget *rotate_offset_spinbutton;
+
+GtkObject *hshift_step_spinbutton_adj;
+GtkWidget *hshift_step_spinbutton;
+GtkObject *vshift_step_spinbutton_adj;
+GtkWidget *vshift_step_spinbutton;
+GtkObject *hscale_step_spinbutton_adj;
+GtkWidget *hscale_step_spinbutton;
+GtkObject *vscale_step_spinbutton_adj;
+GtkWidget *vscale_step_spinbutton;
+GtkObject *rotate_step_spinbutton_adj;
+GtkWidget *rotate_step_spinbutton;
+
+GtkObject *fit_width_spinbutton_adj;
+GtkWidget *fit_width_spinbutton;
+GtkObject *fit_height_spinbutton_adj;
+GtkWidget *fit_height_spinbutton;
+GtkWidget *fit_button;
+GtkWidget *axial_button;
+
+GtkWidget *done_button;
+GtkWidget *apply_button;
+GtkWidget *cancel_button;
+
+// Callbacks
+gboolean on_texture_combo_entry_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data);
+void on_texture_combo_entry_activate (GtkEntry *entry, gpointer user_data);
+
+static void on_match_grid_button_clicked (GtkButton *button, gpointer user_data);
+static void on_lock_valuechange_togglebutton_toggled (GtkToggleButton *togglebutton, gpointer user_data);
+
+static void on_hshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_hscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_rotate_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+
+static void on_hshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_hscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_rotate_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+
+static void on_hshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_hscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_vscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_rotate_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+
+static void on_fit_width_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_fit_height_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
+static void on_fit_button_clicked (GtkButton *button, gpointer user_data);
+static void on_axial_button_clicked (GtkButton *button, gpointer user_data);
+
+static void on_done_button_clicked (GtkButton *button, gpointer user_data);
+static void on_apply_button_clicked (GtkButton *button, gpointer user_data);
+static void on_cancel_button_clicked (GtkButton *button, gpointer user_data);
+
+
+/*
+===================================================
+
+  SURFACE INSPECTOR
+
+===================================================
+*/
+
+
+void IsFaceConflicting()
+{
+  texdef_t* tmp_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+  char buf[12];
+  char texture_name[128];
+
+  if (texdef_face_list_empty())
+  {
+    gtk_entry_set_text( GTK_ENTRY (hshift_value_spinbutton), "");
+    gtk_entry_set_text( GTK_ENTRY (vshift_value_spinbutton), "");
+    gtk_entry_set_text( GTK_ENTRY (hscale_value_spinbutton), "");
+    gtk_entry_set_text( GTK_ENTRY (vscale_value_spinbutton), "");
+    gtk_entry_set_text( GTK_ENTRY (rotate_value_spinbutton), "");
+    gtk_entry_set_text( GTK_ENTRY (texture_combo_entry), "");
+    return;
+  }
+
+  g_bListenChanged = FALSE;
+
+  tmp_texdef = &get_texdef_face_list()->texdef;
+
+  strcpy(texture_name, tmp_texdef->GetName() );
+
+  texdef_SI_values.shift[0] = tmp_texdef->shift[0];
+  texdef_SI_values.shift[1] = tmp_texdef->shift[1];
+  texdef_SI_values.scale[0] = tmp_texdef->scale[0];
+  texdef_SI_values.scale[1] = tmp_texdef->scale[1];
+  texdef_SI_values.rotate = tmp_texdef->rotate;
+  texdef_SI_values.SetName( texture_name );
+
+  is_HShift_conflicting = FALSE;
+  is_VShift_conflicting = FALSE;
+  is_HScale_conflicting = FALSE;
+  is_VScale_conflicting = FALSE;
+  is_Rotate_conflicting = FALSE;
+  is_TextureName_conflicting = FALSE;
+
+  if (texdef_face_list_size() > 1)
+  {
+    temp_texdef_face_list = get_texdef_face_list()->next;
+
+    for (temp_texdef_face_list; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = &temp_texdef_face_list->texdef;
+      if ( texdef_SI_values.shift[0] != tmp_texdef->shift[0] )
+        is_HShift_conflicting = TRUE;
+
+      if ( texdef_SI_values.shift[1] != tmp_texdef->shift[1] )
+        is_VShift_conflicting = TRUE;
+
+      if ( texdef_SI_values.scale[0] != tmp_texdef->scale[0] )
+        is_HScale_conflicting = TRUE;
+
+      if ( texdef_SI_values.scale[1] != tmp_texdef->scale[1] )
+        is_VScale_conflicting = TRUE;
+
+      if ( texdef_SI_values.rotate != tmp_texdef->rotate )
+        is_Rotate_conflicting = TRUE;
+
+      if ( strcmp( texture_name, tmp_texdef->GetName() ) )
+        is_TextureName_conflicting = TRUE;
+    }
+  }
+
+  if(is_HShift_conflicting)
+    gtk_entry_set_text( GTK_ENTRY (hshift_value_spinbutton), "");
+  else
+    gtk_spin_button_set_value( GTK_SPIN_BUTTON(hshift_value_spinbutton) , texdef_SI_values.shift[0] );
+
+  if(is_VShift_conflicting)
+    gtk_entry_set_text( GTK_ENTRY (vshift_value_spinbutton), "");
+  else
+    gtk_spin_button_set_value( GTK_SPIN_BUTTON(vshift_value_spinbutton) , texdef_SI_values.shift[1] );
+
+  if(is_HScale_conflicting)
+    gtk_entry_set_text( GTK_ENTRY (hscale_value_spinbutton), "");
+  else
+    gtk_spin_button_set_value( GTK_SPIN_BUTTON(hscale_value_spinbutton) , texdef_SI_values.scale[0] );
+
+  if(is_VScale_conflicting)
+    gtk_entry_set_text( GTK_ENTRY (vscale_value_spinbutton), "");
+  else
+    gtk_spin_button_set_value( GTK_SPIN_BUTTON(vscale_value_spinbutton) , texdef_SI_values.scale[1] );
+
+  if(is_Rotate_conflicting)
+    gtk_entry_set_text( GTK_ENTRY (rotate_value_spinbutton), "");
+  else
+    gtk_spin_button_set_value( GTK_SPIN_BUTTON(rotate_value_spinbutton) , texdef_SI_values.rotate );
+
+  g_bListenChanged = TRUE;
+}
+
+#define MAX_NUM_LIST_ITEMS 15
+static void PopulateTextureComboList()
+{
+  texdef_t* tmp_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+  char blank[1];
+  GList *items = NULL;
+  GList *tmp_item;
+  int num_of_list_items = 0;
+
+  blank[0] = 0;
+
+  if (texdef_face_list_empty())
+  {
+    items = g_list_append (items, (gpointer) blank);
+    // For Texture Entry, activate only on entry change
+    strcpy (old_texture_entry, blank);
+  }
+  else if ( !is_TextureName_conflicting )
+  {
+    temp_texdef_face_list = get_texdef_face_list();
+    tmp_texdef = (texdef_t *) &get_texdef_face_list()->texdef;
+    items = g_list_append( items, (gpointer) tmp_texdef->GetName() );
+    // For Texture Entry, activate only on entry change
+    strcpy (old_texture_entry, tmp_texdef->GetName());
+  }
+  else
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      // Need to do a string compare, hence the custom search
+      if (!( g_list_find_custom (items, tmp_texdef->GetName(), (GCompareFunc) strcmp ) ))
+      {
+        items = g_list_append( items, (gpointer) tmp_texdef->GetName() );
+       num_of_list_items++;
+      }
+      // Make sure the combo list isn't too long
+      if (num_of_list_items >= MAX_NUM_LIST_ITEMS)
+        break;
+    }
+    // If this isn't added last (to the top of the list), g_list_find freaks.
+    items = g_list_prepend (items, (gpointer) blank);
+    // For Texture Entry, activate only on entry change
+    strcpy (old_texture_entry, blank);
+  }
+
+  gtk_combo_set_popdown_strings (GTK_COMBO (texture_combo), items);
+  g_list_free(items);
+
+}
+
+static void ZeroOffsetValues()
+{
+  texdef_offset.shift[0] = 0.0;
+  texdef_offset.shift[1] = 0.0;
+  texdef_offset.scale[0] = 0.0;
+  texdef_offset.scale[1] = 0.0;
+  texdef_offset.rotate = 0.0;
+}
+
+static void GetTexdefInfo_from_Radiant()
+{
+  g_texdef_face_vector.clear();
+
+  unsigned int count = GetSelectedFaceCountfromBrushes();
+  if(count == 0)
+    count = GetSelectedFaceCount();
+
+  g_texdef_face_vector.resize(count);
+
+  if (!texdef_face_list_empty())
+  {
+    texdef_to_face_t* p = get_texdef_face_list();
+    GetSelFacesTexdef( get_texdef_face_list() );
+  }
+
+  IsFaceConflicting();
+  PopulateTextureComboList();
+  ZeroOffsetValues();
+  if ( texdef_face_list_empty() )
+    SetFlagButtons_UFOAI( get_texdef_face_list() , TRUE);
+  else
+    SetFlagButtons_UFOAI( get_texdef_face_list() , FALSE);
+}
+
+static gint delete_event_callback(GtkWidget *widget, GdkEvent* event, gpointer data)
+{
+  HideDlg();
+  return TRUE;
+}
+
+// make the shift increments match the grid settings
+// the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
+// this depends on a scale value if you have selected a particular texture on which you want it to work:
+// we move the textures in pixels, not world units. (i.e. increment values are in pixel)
+// depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize
+// increment * scale = gridsize
+// hscale and vscale are optional parameters, if they are zero they will be set to the default scale
+// NOTE: the default scale depends if you are using BP mode or regular.
+// For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f
+// see fenris #2810
+void DoSnapTToGrid(float hscale, float vscale)
+{
+  l_pIncrement = Get_SI_Inc();
+
+  if (hscale == 0.0f)
+  {
+    hscale = 0.5f;
+  }
+  if (vscale == 0.0f)
+  {
+     vscale = 0.5f;
+  }
+#ifdef _DEBUG
+  Sys_Printf ("DoSnapTToGrid: hscale %g vscale %g\n", hscale, vscale);
+#endif
+  l_pIncrement->shift[0] = GridSize() / hscale;
+  l_pIncrement->shift[1] = GridSize() / vscale;
+  // now some update work
+  // FIXME: doesn't look good here, seems to be called several times
+  SetTexMods();
+}
+
+void UpdateSurfaceDialog()
+{
+  if (!g_bListenUpdate)
+    return;
+
+  if (!SurfaceInspector)
+    return;
+
+  // avoid long delays on slow computers
+  while (gtk_events_pending ())
+    gtk_main_iteration ();
+
+  if (g_surfwin)
+  {
+#ifdef DBG_SI
+    Sys_Printf("UpdateSurfaceDialog\n");
+#endif
+    GetTexdefInfo_from_Radiant();
+    SetTexMods();
+  }
+
+}
+
+// DoSurface will always try to show the surface inspector
+// or update it because something new has been selected
+void DoSurface (void)
+{
+#ifdef DBG_SI
+  Sys_Printf("DoSurface\n");
+#endif
+  if (!SurfaceInspector)
+    create_SurfaceInspector ();
+
+  ShowDlg();
+  SetTexMods ();
+}
+
+void ToggleSurface()
+{
+#ifdef DBG_SI
+  Sys_Printf("ToggleSurface Module\n");
+#endif
+  if (!g_surfwin)
+    DoSurface ();
+  else
+    on_cancel_button_clicked(NULL, NULL);
+}
+
+// NOTE: will raise and show the Surface inspector and exec fit for patches and brushes
+void SurfaceDlgFitAll()
+{
+  DoSurface();
+  FitAll();
+}
+
+// =============================================================================
+// SurfaceDialog class
+
+void ShowDlg()
+{
+
+  if(!SurfaceInspector)
+    create_SurfaceInspector();
+  else
+    gtk_widget_show (SurfaceInspector);
+
+  GetTexdefInfo_from_Radiant();
+  GetTexMods(TRUE); // Set Initial Undo Point
+  g_surfwin = TRUE;
+}
+
+void HideDlg()
+{
+  g_surfwin = FALSE;
+  gtk_widget_hide (SurfaceInspector);
+}
+
+
+// set default values for increments (shift scale and rot)
+// this is called by the prefs code if can't find the values
+void InitDefaultIncrement(texdef_t *tex)
+{
+  tex->SetName("foo");
+  tex->shift[0] = 8;
+  tex->shift[1] = 8;
+  tex->scale[0] = 0.25;
+  tex->scale[1] = 0.25;
+  tex->rotate = 10;
+}
+
+void BuildDialog ()
+{
+   if ( !SurfaceInspector )
+    create_SurfaceInspector();
+}
+
+/*
+==============
+SetTexMods
+
+Set the fields to the current texdef (i.e. map/texdef -> dialog widgets)
+===============
+*/
+
+void SetTexMods()
+{
+  texdef_t *pt;
+  GtkSpinButton *spin;
+  GtkAdjustment *adjust;
+
+  texturewin = Texturewin ();
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("SurfaceDlg SetTexMods\n");
+#endif
+
+  if (!g_surfwin)
+    return;
+
+  pt = &texturewin->texdef;
+
+  g_bListenChanged = false;
+
+  if(strncmp(pt->GetName(), "textures/", 9) != 0)
+    texdef_offset.SetName(SHADER_NOT_FOUND);
+
+
+  spin = GTK_SPIN_BUTTON (hshift_offset_spinbutton);
+  gtk_spin_button_set_value (spin, texdef_offset.shift[0]);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->shift[0];
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON(hshift_step_spinbutton), l_pIncrement->shift[0]);
+
+  spin = GTK_SPIN_BUTTON (hshift_value_spinbutton);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->shift[0];
+
+
+  spin = GTK_SPIN_BUTTON (vshift_offset_spinbutton);
+  gtk_spin_button_set_value (spin, texdef_offset.shift[1]);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->shift[1];
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON(vshift_step_spinbutton), l_pIncrement->shift[1]);
+
+  spin = GTK_SPIN_BUTTON (vshift_value_spinbutton);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->shift[1];
+
+
+  spin = GTK_SPIN_BUTTON (hscale_offset_spinbutton);
+  gtk_spin_button_set_value (spin, texdef_offset.scale[0]);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->scale[0];
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON(hscale_step_spinbutton), l_pIncrement->scale[0]);
+
+  spin = GTK_SPIN_BUTTON (hscale_value_spinbutton);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->scale[0];
+
+
+  spin = GTK_SPIN_BUTTON (vscale_offset_spinbutton);
+  gtk_spin_button_set_value (spin, texdef_offset.scale[1]);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->scale[1];
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON(vscale_step_spinbutton), l_pIncrement->scale[1]);
+
+  spin = GTK_SPIN_BUTTON (vscale_value_spinbutton);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->scale[1];
+
+
+  spin = GTK_SPIN_BUTTON (rotate_offset_spinbutton);
+  gtk_spin_button_set_value (spin, texdef_offset.rotate);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->rotate;
+  gtk_spin_button_set_value (GTK_SPIN_BUTTON(rotate_step_spinbutton), l_pIncrement->rotate);
+
+  spin = GTK_SPIN_BUTTON (rotate_value_spinbutton);
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
+  adjust->step_increment = l_pIncrement->rotate;
+
+
+  g_bListenChanged = true;
+
+  // store the current texdef as our escape route if user hits OnCancel
+  g_old_texdef = texturewin->texdef;
+}
+
+/*
+==============
+GetTexMods
+
+Shows any changes to the main Radiant windows
+===============
+*/
+void GetTexMods(bool b_SetUndoPoint)
+{
+
+#ifdef DBG_SI
+  Sys_Printf("SurfaceDlg GetTexMods\n");
+#endif
+
+  if ( !texdef_face_list_empty() )
+  {
+    g_bListenUpdate=FALSE;
+    SetChangeInFlags_Face_UFOAI ( get_texdef_face_list() );
+    SetTexdef_FaceList( get_texdef_face_list(), b_SetUndoPoint, false );
+    g_bListenUpdate=TRUE;
+
+    if (b_SetUndoPoint)
+      m_nUndoId = Undo_GetUndoId();
+  }
+}
+
+void FitAll()
+{
+  on_fit_button_clicked(NULL, NULL);
+}
+
+
+////////////////////////////////////////////////////////////////////
+//
+//  GUI Section
+//
+////////////////////////////////////////////////////////////////////
+
+GtkWidget* create_SurfaceInspector (void)
+{
+
+  GtkWidget *label;
+  GtkWidget *hseparator;
+  GtkWidget *eventbox;
+
+  GtkWidget *viewport8;
+  GtkWidget *viewport9;
+  GtkWidget *viewport2;
+  GtkWidget *viewport7;
+  GtkWidget *viewport5;
+  GtkWidget *viewport6;
+  GtkWidget *viewport10;
+
+  GtkWidget *table1;
+  GtkWidget *table4;
+  GtkWidget *table5;
+  GtkWidget *table7;
+
+  GtkWidget *alignment1;
+  GtkWidget *alignment2;
+  GtkWidget *alignment3;
+
+  GtkWidget *vbox7;
+
+  GtkWidget *hbox1;
+  GtkWidget *hbox2;
+  GtkWidget *hbox3;
+  GtkWidget *hbox4;
+
+  GtkWidget *image1;
+  GtkWidget *image2;
+  GtkWidget *image3;
+
+  GtkWidget *hbuttonbox1;
+
+  SurfaceInspector = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  gtk_container_set_border_width (GTK_CONTAINER (SurfaceInspector), 4);
+  gtk_window_set_title (GTK_WINDOW (SurfaceInspector), "Surface Inspector");
+
+  SetWinPos_from_Prefs(SurfaceInspector);
+
+  viewport8 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport8);
+  gtk_container_add (GTK_CONTAINER (SurfaceInspector), viewport8);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport8), GTK_SHADOW_NONE);
+
+  vbox7 = gtk_vbox_new (FALSE, 0);
+  gtk_widget_show (vbox7);
+  gtk_container_add (GTK_CONTAINER (viewport8), vbox7);
+
+  viewport9 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport9);
+  gtk_box_pack_start (GTK_BOX (vbox7), viewport9, FALSE, FALSE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport9), 2);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport9), GTK_SHADOW_ETCHED_IN);
+
+  hbox1 = gtk_hbox_new (FALSE, 0);
+  gtk_widget_show (hbox1);
+  gtk_container_add (GTK_CONTAINER (viewport9), hbox1);
+  gtk_container_set_border_width (GTK_CONTAINER (hbox1), 4);
+
+  label = gtk_label_new ("Texture: ");
+  gtk_widget_show (label);
+  gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  texture_combo = gtk_combo_new ();
+  g_object_set_data (G_OBJECT (GTK_COMBO (texture_combo)->popwin),
+                     "KeepMeAround", texture_combo);
+  gtk_combo_disable_activate ( (GtkCombo*) texture_combo);
+  gtk_widget_show (texture_combo);
+  gtk_box_pack_start (GTK_BOX (hbox1), texture_combo, TRUE, TRUE, 0);
+
+  texture_combo_entry = GTK_COMBO (texture_combo)->entry;
+  gtk_widget_show (texture_combo_entry);
+  gtk_entry_set_max_length (GTK_ENTRY (texture_combo_entry), 128);
+
+  viewport2 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport2);
+  gtk_box_pack_start (GTK_BOX (vbox7), viewport2, FALSE, TRUE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport2), 2);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport2), GTK_SHADOW_ETCHED_IN);
+
+  table1 = gtk_table_new (13, 4, FALSE);
+  gtk_widget_show (table1);
+  gtk_container_add (GTK_CONTAINER (viewport2), table1);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 3, 4,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 3, 4,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 3, 4,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 5, 6,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 5, 6,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 5, 6,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 7, 8,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 7, 8,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 7, 8,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 9, 10,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 9, 10,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 9, 10,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 11, 12,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 11, 12,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 11, 12,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new ("Offset");
+  gtk_widget_show (label);
+  gtk_table_attach (GTK_TABLE (table1), label, 2, 3, 0, 1,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  label = gtk_label_new ("Step");
+  gtk_widget_show (label);
+  gtk_table_attach (GTK_TABLE (table1), label, 3, 4, 0, 1,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 3, 4, 12, 13,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  match_grid_button = gtk_button_new_with_mnemonic ("Match Grid");
+  gtk_widget_show (match_grid_button);
+  gtk_container_add (GTK_CONTAINER (eventbox), match_grid_button);
+
+  label = gtk_label_new ("Value");
+  gtk_widget_show (label);
+  gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 0, 1,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 3, 4,
+                    (GtkAttachOptions) (GTK_SHRINK | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 5, 6,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 7, 8,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 9, 10,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 11, 12,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 4, 5,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new ("V Shift: ");
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (eventbox), label);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 6, 7,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new (" H Scale: ");
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (eventbox), label);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 8, 9,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new ("V Scale: ");
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (eventbox), label);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 10, 11,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new ("Rotate: ");
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (eventbox), label);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 2, 3,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  label = gtk_label_new ("H Shift: ");
+  gtk_widget_show (label);
+  gtk_container_add (GTK_CONTAINER (eventbox), label);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
+
+  hseparator = gtk_hseparator_new ();
+  gtk_widget_show (hseparator);
+  gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 1, 2,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 1, 2, 12, 13,
+                    (GtkAttachOptions) (GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  lock_valuechange_togglebutton = gtk_toggle_button_new_with_mnemonic ("UNLOCK");
+  gtk_widget_show (lock_valuechange_togglebutton);
+  gtk_container_add (GTK_CONTAINER (eventbox), lock_valuechange_togglebutton);
+
+  // Value Spins
+  hshift_value_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  hshift_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_value_spinbutton_adj), 1, 2);
+  gtk_widget_show (hshift_value_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hshift_value_spinbutton, 1, 2, 2, 3,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_value_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hshift_value_spinbutton), TRUE);
+  gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), FALSE );
+
+  vshift_value_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  vshift_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_value_spinbutton_adj), 1, 2);
+  gtk_widget_show (vshift_value_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vshift_value_spinbutton, 1, 2, 4, 5,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_value_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vshift_value_spinbutton), TRUE);
+  gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), FALSE );
+
+  hscale_value_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  hscale_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_value_spinbutton_adj), 1, 4);
+  gtk_widget_show (hscale_value_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hscale_value_spinbutton, 1, 2, 6, 7,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_value_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hscale_value_spinbutton), TRUE);
+  gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), FALSE );
+
+  vscale_value_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  vscale_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_value_spinbutton_adj), 1, 4);
+  gtk_widget_show (vscale_value_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vscale_value_spinbutton, 1, 2, 8, 9,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_value_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vscale_value_spinbutton), TRUE);
+  gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), FALSE );
+
+  rotate_value_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
+  rotate_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_value_spinbutton_adj), 1, 0);
+  gtk_widget_show (rotate_value_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), rotate_value_spinbutton, 1, 2, 10, 11,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_value_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (rotate_value_spinbutton), TRUE);
+  gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), FALSE );
+
+  // Offset Spins
+  hshift_offset_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  hshift_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_offset_spinbutton_adj), 0, 2);
+  gtk_widget_show (hshift_offset_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hshift_offset_spinbutton, 2, 3, 2, 3,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 4, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (hshift_offset_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_offset_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hshift_offset_spinbutton), TRUE);
+
+  vshift_offset_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  vshift_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_offset_spinbutton_adj), 0, 2);
+  gtk_widget_show (vshift_offset_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vshift_offset_spinbutton, 2, 3, 4, 5,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 4, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (vshift_offset_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_offset_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vshift_offset_spinbutton), TRUE);
+
+  hscale_offset_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  hscale_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_offset_spinbutton_adj), 0, 4);
+  gtk_widget_show (hscale_offset_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hscale_offset_spinbutton, 2, 3, 6, 7,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 4, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (hscale_offset_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_offset_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hscale_offset_spinbutton), TRUE);
+
+  vscale_offset_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  vscale_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_offset_spinbutton_adj), 0, 4);
+  gtk_widget_show (vscale_offset_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vscale_offset_spinbutton, 2, 3, 8, 9,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 4, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (vscale_offset_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_offset_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vscale_offset_spinbutton), TRUE);
+
+  rotate_offset_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
+  rotate_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_offset_spinbutton_adj), 0, 2);
+  gtk_widget_show (rotate_offset_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), rotate_offset_spinbutton, 2, 3, 10, 11,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 4, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (rotate_offset_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_offset_spinbutton), GTK_UPDATE_IF_VALID);
+  gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (rotate_offset_spinbutton), TRUE);
+
+    // Step Spins
+  hshift_step_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  hshift_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_step_spinbutton_adj), 1, 2);
+  gtk_widget_show (hshift_step_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hshift_step_spinbutton, 3, 4, 2, 3,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_step_spinbutton), GTK_UPDATE_IF_VALID);
+
+  vshift_step_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
+  vshift_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_step_spinbutton_adj), 1, 2);
+  gtk_widget_show (vshift_step_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vshift_step_spinbutton, 3, 4, 4, 5,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_step_spinbutton), GTK_UPDATE_IF_VALID);
+
+  hscale_step_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  hscale_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_step_spinbutton_adj), 1, 4);
+  gtk_widget_show (hscale_step_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), hscale_step_spinbutton, 3, 4, 6, 7,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_step_spinbutton), GTK_UPDATE_IF_VALID);
+
+  vscale_step_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
+  vscale_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_step_spinbutton_adj), 1, 4);
+  gtk_widget_show (vscale_step_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), vscale_step_spinbutton, 3, 4, 8, 9,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_step_spinbutton), GTK_UPDATE_IF_VALID);
+
+  rotate_step_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
+  rotate_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_step_spinbutton_adj), 1, 2);
+  gtk_widget_show (rotate_step_spinbutton);
+  gtk_table_attach (GTK_TABLE (table1), rotate_step_spinbutton, 3, 4, 10, 11,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_step_spinbutton), GTK_UPDATE_IF_VALID);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 2, 3, 12, 13,
+                    (GtkAttachOptions) (0),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 12, 13,
+                    (GtkAttachOptions) (0),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 0, 1,
+                    (GtkAttachOptions) (0),
+                    (GtkAttachOptions) (0), 0, 0);
+
+  viewport7 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport7);
+  gtk_box_pack_start (GTK_BOX (vbox7), viewport7, FALSE, TRUE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport7), 2);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport7), GTK_SHADOW_ETCHED_IN);
+
+  table4 = gtk_table_new (4, 7, FALSE);
+  gtk_widget_show (table4);
+  gtk_container_add (GTK_CONTAINER (viewport7), table4);
+
+  viewport5 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport5);
+  gtk_table_attach (GTK_TABLE (table4), viewport5, 1, 7, 0, 4,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport5), 6);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport5), GTK_SHADOW_ETCHED_OUT);
+
+  table5 = gtk_table_new (2, 3, FALSE);
+  gtk_widget_show (table5);
+  gtk_container_add (GTK_CONTAINER (viewport5), table5);
+  gtk_container_set_border_width (GTK_CONTAINER (table5), 5);
+  gtk_table_set_col_spacings (GTK_TABLE (table5), 2);
+
+  label = gtk_label_new ("Height");
+  gtk_widget_show (label);
+  gtk_table_attach (GTK_TABLE (table5), label, 2, 3, 0, 1,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
+
+  label = gtk_label_new ("Width");
+  gtk_widget_show (label);
+  gtk_table_attach (GTK_TABLE (table5), label, 1, 2, 0, 1,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+  gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
+
+  fit_width_spinbutton_adj = gtk_adjustment_new (1, 1, 32, 1, 10, 10);
+  fit_width_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fit_width_spinbutton_adj), 1, 0);
+  gtk_widget_show (fit_width_spinbutton);
+  gtk_table_attach (GTK_TABLE (table5), fit_width_spinbutton, 1, 2, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fit_width_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (fit_width_spinbutton), GTK_UPDATE_IF_VALID);
+
+  fit_height_spinbutton_adj = gtk_adjustment_new (1, 1, 32, 1, 10, 10);
+  fit_height_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fit_height_spinbutton_adj), 1, 0);
+  gtk_widget_show (fit_height_spinbutton);
+  gtk_table_attach (GTK_TABLE (table5), fit_height_spinbutton, 2, 3, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 3, 0);
+  gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fit_height_spinbutton), TRUE);
+  gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (fit_height_spinbutton), GTK_UPDATE_IF_VALID);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table5), eventbox, 0, 1, 0, 1,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 0, 0);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table5), eventbox, 0, 1, 1, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_FILL), 4, 0);
+
+  fit_button = gtk_button_new_with_mnemonic ("    Fit    ");
+  gtk_widget_show (fit_button);
+  gtk_container_add (GTK_CONTAINER (eventbox), fit_button);
+
+  viewport6 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport6);
+  gtk_table_attach (GTK_TABLE (table4), viewport6, 0, 1, 0, 4,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (0), 0, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport6), 4);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport6), GTK_SHADOW_NONE);
+
+  table7 = gtk_table_new (2, 1, FALSE);
+  gtk_widget_show (table7);
+  gtk_container_add (GTK_CONTAINER (viewport6), table7);
+
+  eventbox = gtk_event_box_new ();
+  gtk_widget_show (eventbox);
+  gtk_table_attach (GTK_TABLE (table7), eventbox, 0, 1, 0, 2,
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                    (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+
+  axial_button = gtk_button_new_with_mnemonic ("Axial");
+  gtk_widget_show (axial_button);
+  gtk_container_add (GTK_CONTAINER (eventbox), axial_button);
+  gtk_widget_set_size_request (axial_button, 56, 29);
+  gtk_container_set_border_width (GTK_CONTAINER (axial_button), 4);
+
+  // Fit in Flags sub-dialog
+  Create_UFOAIFlagsDialog(vbox7);
+
+  viewport10 = gtk_viewport_new (NULL, NULL);
+  gtk_widget_show (viewport10);
+  gtk_box_pack_start (GTK_BOX (vbox7), viewport10, FALSE, TRUE, 0);
+  gtk_container_set_border_width (GTK_CONTAINER (viewport10), 2);
+  gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport10), GTK_SHADOW_ETCHED_IN);
+
+  hbuttonbox1 = gtk_hbutton_box_new ();
+  gtk_widget_show (hbuttonbox1);
+  gtk_container_add (GTK_CONTAINER (viewport10), hbuttonbox1);
+  gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 4);
+  gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_SPREAD);
+
+  done_button = gtk_button_new ();
+  gtk_widget_show (done_button);
+  gtk_container_add (GTK_CONTAINER (hbuttonbox1), done_button);
+  GTK_WIDGET_SET_FLAGS (done_button, GTK_CAN_DEFAULT);
+
+  alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
+  gtk_widget_show (alignment1);
+  gtk_container_add (GTK_CONTAINER (done_button), alignment1);
+
+  hbox2 = gtk_hbox_new (FALSE, 2);
+  gtk_widget_show (hbox2);
+  gtk_container_add (GTK_CONTAINER (alignment1), hbox2);
+
+  image1 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_BUTTON);
+  gtk_widget_show (image1);
+  gtk_box_pack_start (GTK_BOX (hbox2), image1, FALSE, FALSE, 0);
+
+  label = gtk_label_new_with_mnemonic ("Done");
+  gtk_widget_show (label);
+  gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+
+  apply_button = gtk_button_new ();
+  gtk_widget_show (apply_button);
+  gtk_container_add (GTK_CONTAINER (hbuttonbox1), apply_button);
+  GTK_WIDGET_SET_FLAGS (apply_button, GTK_CAN_DEFAULT);
+
+  alignment3 = gtk_alignment_new (0.5, 0.5, 0, 0);
+  gtk_widget_show (alignment3);
+  gtk_container_add (GTK_CONTAINER (apply_button), alignment3);
+
+  hbox4 = gtk_hbox_new (FALSE, 2);
+  gtk_widget_show (hbox4);
+  gtk_container_add (GTK_CONTAINER (alignment3), hbox4);
+
+  image3 = gtk_image_new_from_stock ("gtk-apply", GTK_ICON_SIZE_BUTTON);
+  gtk_widget_show (image3);
+  gtk_box_pack_start (GTK_BOX (hbox4), image3, FALSE, FALSE, 0);
+
+  label = gtk_label_new_with_mnemonic ("Apply");
+  gtk_widget_show (label);
+  gtk_box_pack_start (GTK_BOX (hbox4), label, FALSE, FALSE, 0);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+
+  cancel_button = gtk_button_new ();
+  gtk_widget_show (cancel_button);
+  gtk_container_add (GTK_CONTAINER (hbuttonbox1), cancel_button);
+  GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
+
+  alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
+  gtk_widget_show (alignment2);
+  gtk_container_add (GTK_CONTAINER (cancel_button), alignment2);
+
+  hbox3 = gtk_hbox_new (FALSE, 2);
+  gtk_widget_show (hbox3);
+  gtk_container_add (GTK_CONTAINER (alignment2), hbox3);
+
+  image2 = gtk_image_new_from_stock ("gtk-no", GTK_ICON_SIZE_BUTTON);
+  gtk_widget_show (image2);
+  gtk_box_pack_start (GTK_BOX (hbox3), image2, FALSE, FALSE, 0);
+
+  label = gtk_label_new_with_mnemonic ("Cancel");
+  gtk_widget_show (label);
+  gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
+  gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
+
+
+  g_signal_connect ( (gpointer) SurfaceInspector,
+                      "delete_event",
+                      G_CALLBACK (delete_event_callback),
+                     NULL );
+  g_signal_connect ((gpointer) SurfaceInspector, "destroy",
+                    G_CALLBACK (gtk_widget_destroy),
+                    NULL);
+
+  g_signal_connect ((gpointer) texture_combo_entry, "key_press_event",
+                    G_CALLBACK (on_texture_combo_entry_key_press_event),
+                    NULL);
+  g_signal_connect ((gpointer) texture_combo_entry, "activate",
+                    G_CALLBACK (on_texture_combo_entry_activate),
+                    NULL);
+
+
+  g_signal_connect ((gpointer) hshift_offset_spinbutton, "value_changed",
+                    G_CALLBACK (on_hshift_offset_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vshift_offset_spinbutton, "value_changed",
+                    G_CALLBACK (on_vshift_offset_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) hscale_offset_spinbutton, "value_changed",
+                    G_CALLBACK (on_hscale_offset_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vscale_offset_spinbutton, "value_changed",
+                    G_CALLBACK (on_vscale_offset_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) rotate_offset_spinbutton, "value_changed",
+                    G_CALLBACK (on_rotate_offset_spinbutton_value_changed),
+                    NULL);
+
+  g_signal_connect ((gpointer) hshift_value_spinbutton, "value_changed",
+                    G_CALLBACK (on_hshift_value_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vshift_value_spinbutton, "value_changed",
+                    G_CALLBACK (on_vshift_value_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) hscale_value_spinbutton, "value_changed",
+                    G_CALLBACK (on_hscale_value_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vscale_value_spinbutton, "value_changed",
+                    G_CALLBACK (on_vscale_value_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) rotate_value_spinbutton, "value_changed",
+                    G_CALLBACK (on_rotate_value_spinbutton_value_changed),
+                    NULL);
+
+  g_signal_connect ((gpointer) hshift_step_spinbutton, "value_changed",
+                    G_CALLBACK (on_hshift_step_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vshift_step_spinbutton, "value_changed",
+                    G_CALLBACK (on_vshift_step_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) hscale_step_spinbutton, "value_changed",
+                    G_CALLBACK (on_hscale_step_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) vscale_step_spinbutton, "value_changed",
+                    G_CALLBACK (on_vscale_step_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) rotate_step_spinbutton, "value_changed",
+                    G_CALLBACK (on_rotate_step_spinbutton_value_changed),
+                    NULL);
+
+  g_signal_connect ((gpointer) match_grid_button, "clicked",
+                    G_CALLBACK (on_match_grid_button_clicked),
+                    NULL);
+  g_signal_connect ((gpointer) lock_valuechange_togglebutton, "toggled",
+                    G_CALLBACK (on_lock_valuechange_togglebutton_toggled),
+                    NULL);
+
+  g_signal_connect ((gpointer) fit_width_spinbutton, "value_changed",
+                    G_CALLBACK (on_fit_width_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) fit_height_spinbutton, "value_changed",
+                    G_CALLBACK (on_fit_height_spinbutton_value_changed),
+                    NULL);
+  g_signal_connect ((gpointer) fit_button, "clicked",
+                    G_CALLBACK (on_fit_button_clicked),
+                    NULL);
+
+  g_signal_connect ((gpointer) axial_button, "clicked",
+                    G_CALLBACK (on_axial_button_clicked),
+                    NULL);
+
+  g_signal_connect ((gpointer) done_button, "clicked",
+                    G_CALLBACK (on_done_button_clicked),
+                    NULL);
+  g_signal_connect ((gpointer) apply_button, "clicked",
+                    G_CALLBACK (on_apply_button_clicked),
+                    NULL);
+  g_signal_connect ((gpointer) cancel_button, "clicked",
+                    G_CALLBACK (on_cancel_button_clicked),
+                    NULL);
+
+
+  return SurfaceInspector;
+}
+
+
+// Texture Combo
+gboolean on_texture_combo_entry_key_press_event (GtkWidget *widget, GdkEventKey *event,
+                                                 gpointer user_data)
+{
+  // Have Tab activate selection as well as Return
+  if (event->keyval == GDK_Tab)
+    g_signal_emit_by_name ( texture_combo_entry, "activate" );
+
+  return FALSE;
+}
+
+void on_texture_combo_entry_activate (GtkEntry *entry, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+  char text[128] = { 0 };
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    // activate only on entry change
+    strcpy( text, gtk_entry_get_text(entry));
+    if ( strcmp( old_texture_entry, text ))
+    {
+      // Check for spaces in shader name
+      if (text[0] <= ' ' || strchr(text, ' '))
+        Sys_FPrintf(SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text);
+      else
+      {
+        for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+        {
+          tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+          tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+          strcpy( old_texture_entry, text );
+          tmp_texdef->SetName( text );
+        }
+        GetTexMods();
+      }
+    }
+  }
+}
+
+// Offset Spins
+static void on_hshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_offset.shift[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_offset_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      if (is_HShift_conflicting)
+        tmp_texdef->shift[0] = tmp_orig_texdef->shift[0] + texdef_offset.shift[0];
+      else
+        tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0];
+    }
+    GetTexMods();
+  }
+}
+
+static void on_vshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_offset.shift[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_offset_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      if (is_VShift_conflicting)
+        tmp_texdef->shift[1] = tmp_orig_texdef->shift[1] + texdef_offset.shift[1];
+      else
+        tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1];
+    }
+    GetTexMods();
+  }
+
+}
+
+static void on_hscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_offset.scale[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_offset_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      if (is_HScale_conflicting)
+        tmp_texdef->scale[0] = tmp_orig_texdef->scale[0] + texdef_offset.scale[0];
+      else
+        tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0];
+    }
+    GetTexMods();
+  }
+
+
+}
+
+static void on_vscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_offset.scale[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_offset_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      if (is_VScale_conflicting)
+        tmp_texdef->scale[1] = tmp_orig_texdef->scale[1] + texdef_offset.scale[1];
+      else
+        tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1];
+    }
+    GetTexMods();
+  }
+
+}
+
+static void on_rotate_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_offset.rotate = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_offset_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      if (is_Rotate_conflicting)
+        tmp_texdef->rotate = tmp_orig_texdef->rotate + texdef_offset.rotate;
+      else
+        tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate;
+    }
+    GetTexMods();
+  }
+
+}
+
+
+// Match Grid
+static void on_match_grid_button_clicked (GtkButton *button, gpointer user_data)
+{
+  float hscale, vscale;
+
+  if( !strcmp(gtk_entry_get_text (GTK_ENTRY (hscale_value_spinbutton)), "") )
+    hscale = 0.0;
+  else
+    hscale = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_value_spinbutton) );
+
+  if( !strcmp( gtk_entry_get_text (GTK_ENTRY (vscale_value_spinbutton)), "") )
+    vscale = 0.0;
+  else
+    vscale = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_value_spinbutton) );
+  DoSnapTToGrid (hscale, vscale);
+}
+
+
+// Lock out changes to Value
+static void on_lock_valuechange_togglebutton_toggled (GtkToggleButton *togglebutton, gpointer user_data)
+{
+  bool is_Locked;
+
+  is_Locked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lock_valuechange_togglebutton));
+
+  gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), is_Locked );
+  gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), is_Locked );
+  gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), is_Locked );
+  gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), is_Locked );
+  gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), is_Locked );
+}
+
+
+// Value Spins
+static void on_hshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_SI_values.shift[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_value_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0];
+      is_HShift_conflicting = FALSE;
+    }
+    GetTexMods();
+  }
+}
+
+static void on_vshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_SI_values.shift[1]  = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_value_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1];
+      is_VShift_conflicting = FALSE;
+    }
+    GetTexMods();
+  }
+}
+
+static void on_hscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_SI_values.scale[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_value_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0];
+      is_HScale_conflicting = FALSE;
+    }
+    GetTexMods();
+  }
+}
+
+static void on_vscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_SI_values.scale[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_value_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1];
+      is_VScale_conflicting = FALSE;
+    }
+    GetTexMods();
+  }
+}
+
+static void on_rotate_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  texdef_SI_values.rotate = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_value_spinbutton) );
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
+      tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate;
+      is_Rotate_conflicting = FALSE;
+    }
+    GetTexMods();
+  }
+}
+
+
+// Step Spins
+static void on_hshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  gfloat val;
+  GtkAdjustment * adjust;
+
+  if (!g_bListenChanged)
+    return;
+
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("OnIncrementChanged HShift\n");
+#endif
+
+  val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_step_spinbutton) ) ;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hshift_offset_spinbutton ));
+  adjust->step_increment = val;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hshift_value_spinbutton ));
+  adjust->step_increment = val;
+  l_pIncrement->shift[0] = val;
+}
+
+static void on_vshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  gfloat val;
+  GtkAdjustment * adjust;
+
+  if (!g_bListenChanged)
+    return;
+
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("OnIncrementChanged VShift\n");
+#endif
+
+  val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_step_spinbutton) ) ;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vshift_offset_spinbutton ));
+  adjust->step_increment = val;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vshift_value_spinbutton ));
+  adjust->step_increment = val;
+  l_pIncrement->shift[1] = val;
+}
+
+static void on_hscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  gfloat val;
+  GtkAdjustment * adjust;
+
+  if (!g_bListenChanged)
+    return;
+
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("OnIncrementChanged HShift\n");
+#endif
+
+  val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_step_spinbutton) ) ;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hscale_offset_spinbutton ));
+  adjust->step_increment = val;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hscale_value_spinbutton ));
+  adjust->step_increment = val;
+  l_pIncrement->scale[0] = val;
+}
+
+static void on_vscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  gfloat val;
+  GtkAdjustment * adjust;
+
+  if (!g_bListenChanged)
+    return;
+
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("OnIncrementChanged HShift\n");
+#endif
+
+  val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_step_spinbutton) ) ;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vscale_offset_spinbutton ));
+  adjust->step_increment = val;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vscale_value_spinbutton ));
+  adjust->step_increment = val;
+  l_pIncrement->scale[1] = val;
+}
+
+static void on_rotate_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  gfloat val;
+  GtkAdjustment * adjust;
+
+  if (!g_bListenChanged)
+    return;
+
+  l_pIncrement = Get_SI_Inc();
+
+#ifdef DBG_SI
+  Sys_Printf("OnIncrementChanged HShift\n");
+#endif
+
+  val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_step_spinbutton) ) ;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( rotate_offset_spinbutton ));
+  adjust->step_increment = val;
+  adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( rotate_value_spinbutton ));
+  adjust->step_increment = val;
+  l_pIncrement->rotate = val;
+}
+
+
+// Fit Texture
+static void on_fit_width_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  m_nWidth = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(fit_width_spinbutton) );
+}
+
+static void on_fit_height_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
+{
+  m_nHeight = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(fit_height_spinbutton) );
+}
+
+static void on_fit_button_clicked (GtkButton *button, gpointer user_data)
+{
+  FaceList_FitTexture(get_texdef_face_list(), m_nHeight, m_nWidth);
+  Sys_UpdateWindows(W_ALL);
+}
+
+
+// Axial Button
+static void on_axial_button_clicked (GtkButton *button, gpointer user_data)
+{
+  texdef_t* tmp_texdef;
+  texdef_t* tmp_orig_texdef;
+  texdef_to_face_t* temp_texdef_face_list;
+
+  if (!texdef_face_list_empty() && g_bListenChanged)
+  {
+    for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+    {
+      tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
+      tmp_texdef->shift[0] = 0.0;
+      tmp_texdef->shift[1] = 0.0;
+      tmp_texdef->scale[0] = 0.5;
+      tmp_texdef->scale[1] = 0.5;
+      tmp_texdef->rotate = 0.0;
+    }
+  }
+
+  SetTexdef_FaceList( get_texdef_face_list(), FALSE, TRUE );
+  Sys_UpdateWindows(W_ALL);
+}
+
+
+// Action Buttons
+static void on_done_button_clicked (GtkButton *button, gpointer user_data)
+{
+  if ( !texdef_face_list_empty() )
+    GetTexMods(TRUE);
+  HideDlg();
+  Sys_UpdateWindows(W_ALL);
+}
+
+static void on_apply_button_clicked (GtkButton *button, gpointer user_data)
+{
+  if (!g_bListenChanged)
+    return;
+
+  if ( !texdef_face_list_empty() )
+  {
+    GetTexMods (TRUE);
+    Sys_UpdateWindows(W_CAMERA);
+    GetTexdefInfo_from_Radiant();
+    SetTexMods();
+  }
+}
+
+static void on_cancel_button_clicked (GtkButton *button, gpointer user_data)
+{
+  texturewin = Texturewin ();
+  texturewin->texdef = g_old_texdef;
+  // cancel the last do if we own it
+  if ( (m_nUndoId == Undo_GetUndoId()) && ( m_nUndoId != 0 ))
+  {
+#ifdef DBG_SI
+    Sys_Printf("OnCancel calling Undo_Undo\n");
+#endif
+    g_bListenUpdate = false;
+    Undo_Undo(TRUE);
+    g_bListenUpdate = true;
+    m_nUndoId = 0;
+  }
+  HideDlg();
+}
+
+
diff --git a/plugins/surface_ufoai/surfacedialog.h b/plugins/surface_ufoai/surfacedialog.h
new file mode 100644 (file)
index 0000000..4a5b815
--- /dev/null
@@ -0,0 +1,31 @@
+/*
+Copyright (C) 1999-2007 id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _SURFACEDIALOG_H_
+#define _SURFACEDIALOG_H_
+
+void UpdateSurfaceDialog ();
+void DoSurface ();
+void ToggleSurface ();
+void SurfaceDlgFitAll ();
+GtkWidget *Get_SI_Module_Widget ();
+
+#endif // _SURFACEDIALOG_H_
diff --git a/plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp
new file mode 100644 (file)
index 0000000..d8febe4
--- /dev/null
@@ -0,0 +1,465 @@
+/*
+Copyright (C) 1999-2007 id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#include <gtk/gtk.h>
+#include <gdk/gdkkeysyms.h>
+
+#include "surfdlg_plugin.h"
+
+#include "surfaceflagsdialog_ufoai.h"
+
+GtkWidget *notebook1;
+
+// 32 bit is the max
+#define MAX_BUTTONS 32
+
+GtkWidget *surface_buttons[MAX_BUTTONS];
+GtkWidget *content_buttons[MAX_BUTTONS];
+
+GtkWidget *value_entry;
+gboolean setup_buttons = TRUE;
+
+int working_surface_flags;
+int surface_mask;
+int working_content_flags;
+int content_mask;
+int working_value;
+
+inline void set_inconsistent(GtkWidget *toggle_button)
+{
+       gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON (toggle_button), TRUE);
+}
+
+inline void clear_inconsistent(GtkWidget *toggle_button)
+{
+       if ( gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON (toggle_button)) )
+       {
+               gtk_toggle_button_set_inconsistent(GTK_TOGGLE_BUTTON (toggle_button), FALSE);
+       }
+}
+
+void clear_all_inconsistent(void)
+{
+       int i;
+
+       for (i = 0; i < MAX_BUTTONS; i++) {
+               clear_inconsistent( surface_buttons[i] );
+               clear_inconsistent( content_buttons[i] );
+       }
+}
+
+void clear_all_buttons_and_values()
+{
+       int i;
+
+       for (i = 0; i < MAX_BUTTONS; i++) {
+               gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON ( surface_buttons[i] ), FALSE);
+               gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON ( content_buttons[i] ), FALSE);
+       }
+
+       gtk_entry_set_text( (GtkEntry *)value_entry, "");
+}
+
+void SetFlagButtons_UFOAI(texdef_to_face_t *texdef_face_list, bool b_isListEmpty)
+{
+       int contents = 0;
+       int flags = 0;
+       int value = 0;
+       int diff_contents = 0;
+       int diff_flags = 0;
+       gboolean diff_value = FALSE;
+       char tex_buff[11];
+       texdef_t* tmp_texdef;
+       texdef_to_face_t* temp_texdef_face_list;
+       int i;
+
+       setup_buttons = TRUE;
+       working_surface_flags = 0;
+       surface_mask = 0;
+       working_content_flags = 0;
+       content_mask = 0;
+       working_value = 0;
+
+       if (!b_isListEmpty) {
+               tmp_texdef = &texdef_face_list->texdef;
+               contents = tmp_texdef->contents;
+               flags = tmp_texdef->flags;
+               value = tmp_texdef->value;
+
+               Sys_Printf("Surface: %d\tContents: %d\tValue: %d\ttmp_texdef\n",tmp_texdef->flags,tmp_texdef->contents,tmp_texdef->value);
+               Sys_Printf("Surface: %d\tContents: %d\tValue: %d\n",flags,contents,value);
+
+               for (temp_texdef_face_list = texdef_face_list->next; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+               {
+                       tmp_texdef = &temp_texdef_face_list->texdef;
+                       diff_contents |= contents ^ tmp_texdef->contents;  // Figure out which buttons are inconsistent
+                       diff_flags |= flags ^ tmp_texdef->flags;
+                       if (tmp_texdef->value != value)
+                               diff_value = TRUE;
+
+                       Sys_Printf("Surface: %d\tContents: %d\tValue: %d\ttmp_texdef\n",tmp_texdef->flags,tmp_texdef->contents,tmp_texdef->value);
+                       Sys_Printf("Surface: %d\tContents: %d\tValue: %d\n",flags,contents,value);
+               }
+       }
+
+       clear_all_inconsistent();
+
+       // If no faces/brushes are selected, clear everything and bail
+       if (b_isListEmpty) {
+               clear_all_buttons_and_values();
+               setup_buttons = FALSE;
+               return;
+       }
+
+       for (i = 0; i < MAX_BUTTONS; i++) {
+               // Set surface buttons to reflect brush/face flags, contents, and values
+               if(diff_flags & (1 << i))
+                       set_inconsistent(surface_buttons[i]);
+               else if(flags & (1 << i))
+                       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (surface_buttons[i]), TRUE);
+               else
+                       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (surface_buttons[i]), FALSE);
+
+               if(diff_contents & (1 << i))
+                       set_inconsistent(content_buttons[i]);
+               else if(contents & (1 << i))
+                       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (content_buttons[i]), TRUE);
+               else
+                       gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON (content_buttons[i]), FALSE);
+       }
+
+       // Set Value
+       if (diff_value)
+               gtk_entry_set_text( (GtkEntry *)value_entry, "");
+       else {
+               working_value = value;
+               sprintf( tex_buff, "%d", value);
+               gtk_entry_set_text( (GtkEntry *)value_entry, tex_buff);
+       }
+
+       setup_buttons = FALSE;
+}
+
+void SetChangeInFlags_Face_UFOAI (texdef_to_face_t *texdef_face_list)
+{
+       texdef_to_face_t *temp_texdef_face_list;
+       texdef_t *tmp_texdef;
+
+       for (temp_texdef_face_list = texdef_face_list; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
+       {
+               tmp_texdef = &temp_texdef_face_list->texdef;
+               tmp_texdef->flags = (tmp_texdef->flags & ~surface_mask) | working_surface_flags;
+               tmp_texdef->contents = (tmp_texdef->contents & ~content_mask) | working_content_flags;
+               tmp_texdef->value = working_value;
+               Sys_Printf("content_flag: %d     content_mask: %d\n",working_content_flags,content_mask);
+               Sys_Printf("content: %d\n",tmp_texdef->contents);
+       }
+}
+
+inline void change_surfaceflag (GtkWidget *togglebutton, int sur_flag, gboolean change_flag_to)
+{
+       if (!setup_buttons) // If we're setting up the buttons, we really don't need to
+       {                   // set flags that are already set
+               if (gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON (togglebutton))) // Clear out inconsistent, if set
+                       clear_inconsistent(GTK_WIDGET (togglebutton));
+
+               surface_mask |= sur_flag;
+
+               if (change_flag_to)
+                       working_surface_flags |= sur_flag;
+               else
+                       working_surface_flags &= ~sur_flag;
+       }
+}
+
+inline void change_contentflag (GtkWidget *togglebutton, int content_flag, gboolean change_flag_to)
+{
+       if ( (!setup_buttons) )  // If we're setting up the buttons, we really don't need to
+       {                        // set flags that are already set
+               if (gtk_toggle_button_get_inconsistent(GTK_TOGGLE_BUTTON (togglebutton)))
+                       clear_inconsistent(togglebutton);
+               //if (g_ptrSelectedFaces.GetSize() == 0)  // Only changing content flags on whole brushes, not faces.
+               //{
+               content_mask |= content_flag;
+
+               if (change_flag_to)
+                       working_content_flags |= content_flag;
+               else
+                       working_content_flags &= ~content_flag;
+               //}
+               Sys_Printf("content_flag: %d     content_mask: %d\n",content_flag,content_mask);
+       }
+}
+
+// Surface Flags Callbacks
+void on_surface_button_toggled (GtkToggleButton *togglebutton, gpointer user_data)
+{
+       int flag = *(int*)user_data;
+       change_surfaceflag(GTK_WIDGET (togglebutton), flag, (GTK_TOGGLE_BUTTON (togglebutton)->active));
+}
+
+// Content Flags Callbacks
+void on_content_button_toggled (GtkToggleButton *togglebutton, gpointer user_data)
+{
+       int flag = *(int*)user_data;
+       change_contentflag(GTK_WIDGET (togglebutton), flag, (GTK_TOGGLE_BUTTON (togglebutton)->active));
+}
+
+// Value Entry Callback
+void on_value_entry_changed (GtkEditable *editable, gpointer user_data)
+{
+       if ( (!setup_buttons) )  // If we're setting up the buttons, don't change value
+       working_value = atoi( gtk_entry_get_text( (GtkEntry*)editable) );
+}
+
+void on_value_entry_insert_text (GtkEditable *editable, gchar *new_text, gint new_text_length, gint *position, gpointer user_data)
+{
+       int i, count=0;
+       gchar *result;
+
+       // Limit input to digits, throwing out anything else
+       // Modified from Gtk FAQ for text filtering of GtkEntry
+       result = g_new (gchar, new_text_length);
+
+       for (i=0; i < new_text_length; i++) {
+               if (!isdigit(new_text[i]))
+                       continue;
+               result[count++] = new_text[i];
+       }
+
+       if (count > 0) {
+               gtk_signal_handler_block_by_func (GTK_OBJECT (editable),
+                                               GTK_SIGNAL_FUNC (on_value_entry_insert_text),
+                                               user_data);
+               gtk_editable_insert_text (editable, result, count, position);
+               gtk_signal_handler_unblock_by_func (GTK_OBJECT (editable),
+                                               GTK_SIGNAL_FUNC (on_value_entry_insert_text),
+                                               user_data);
+       }
+       gtk_signal_emit_stop_by_name (GTK_OBJECT (editable), "insert_text");
+
+       g_free (result);
+}
+
+void on_surfacebutton_clicked (GtkButton *button, gpointer user_data)
+{
+       gtk_notebook_set_page (GTK_NOTEBOOK(notebook1), 0);
+}
+
+void on_contentbutton_clicked (GtkButton *button, gpointer user_data)
+{
+       gtk_notebook_set_page (GTK_NOTEBOOK(notebook1), 1);
+}
+
+// FIXME: This should be in the ufoai.game
+static const char *surfaceFlags[] = {
+       "light",
+       "slick",
+       "",
+       "warp",
+       "trans33",
+       "trans66",
+       "flow",
+       "nodraw",
+       "hint",
+       "skip",
+       "phong",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "alphatest",
+       "",
+       "",
+       "",
+       "",
+       "",
+       ""
+};
+
+static const char *contentFlags[] = {
+       "solid",
+       "window",
+       "",
+       "fireaffected",
+       "",
+       "water",
+       "",
+       "",
+       "level1",
+       "level2",
+       "level3",
+       "level4",
+       "level5",
+       "level6",
+       "level7",
+       "level8",
+       "actorclip",
+       "passable",
+       "footstep",
+       "",
+       "",
+       "",
+       "",
+       "",
+       "origin",
+       "weaponclip",
+       "",
+       "detail",
+       "",
+       "",
+       "stepon",
+       ""
+};
+
+#define UFOAI_FLAG_BUTTON_BORDER 3
+
+GtkWidget* Create_UFOAIFlagsDialog (GtkWidget* surfacedialog_widget)
+{
+       GtkWidget *frame1;
+       GtkWidget *vbox1;
+       GtkWidget *vbox2;
+       GtkWidget *vbox3;
+       GtkWidget *vbox4;
+       GtkWidget *table4;
+       GtkWidget *hbox2;
+       GtkWidget *hbox3;
+       GtkWidget *hseparator1;
+       GtkWidget *value_label;
+       GtkWidget *label5;
+       GtkWidget *table3;
+       GtkWidget *label6;
+       int flag = 0;
+       int i, x, y;
+
+       frame1 = gtk_frame_new ("Flags");
+       gtk_widget_show (frame1);
+       gtk_container_add (GTK_CONTAINER (surfacedialog_widget), frame1);
+
+       vbox1 = gtk_vbox_new (FALSE, 0);
+       gtk_widget_show (vbox1);
+       gtk_container_add (GTK_CONTAINER (frame1), vbox1);
+
+       notebook1 = gtk_notebook_new ();
+       gtk_widget_show (notebook1);
+       gtk_box_pack_start (GTK_BOX (vbox1), notebook1, TRUE, TRUE, 0);
+       gtk_notebook_set_show_tabs (GTK_NOTEBOOK (notebook1), TRUE);
+       gtk_container_set_border_width (GTK_CONTAINER (notebook1), 5);
+
+       vbox2 = gtk_vbox_new (FALSE, 0);
+       gtk_widget_show (vbox2);
+       gtk_container_add (GTK_CONTAINER (notebook1), vbox2);
+
+       table4 = gtk_table_new (8, 4, FALSE);
+       gtk_widget_show (table4);
+       gtk_box_pack_start (GTK_BOX (vbox2), table4, TRUE, TRUE, 0);
+
+       y = -1;
+       for (i = 0; i < MAX_BUTTONS; i++) {
+               if (!(i % 4))
+                       y++;
+               x = i % 4;
+               flag = (1 << i);
+               surface_buttons[i] = gtk_toggle_button_new_with_label (surfaceFlags[i]);
+               gtk_signal_connect(GTK_OBJECT (surface_buttons[i]), "toggled", GTK_SIGNAL_FUNC(on_surface_button_toggled), &flag);
+               gtk_widget_show(surface_buttons[i]);
+               gtk_table_attach(GTK_TABLE (table4), surface_buttons[i], 0 + x, 1 + x, (0 + y), (1 + y),
+                                                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                                                       (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+               gtk_container_set_border_width (GTK_CONTAINER (surface_buttons[i]), UFOAI_FLAG_BUTTON_BORDER);
+       }
+
+       hseparator1 = gtk_hseparator_new ();
+       gtk_widget_show (hseparator1);
+       gtk_box_pack_start (GTK_BOX (vbox2), hseparator1, FALSE, FALSE, 0);
+       gtk_widget_set_usize (hseparator1, -2, 5);
+
+       hbox2 = gtk_hbox_new (FALSE, 0);
+       gtk_widget_show (hbox2);
+       gtk_box_pack_start (GTK_BOX (vbox2), hbox2, FALSE, FALSE, 0);
+
+       hbox3 = gtk_hbox_new (FALSE, 0);
+       gtk_widget_show (hbox3);
+       gtk_box_pack_start (GTK_BOX (hbox2), hbox3, TRUE, TRUE, 0);
+
+       vbox4 = gtk_vbox_new (FALSE, 0);
+       gtk_widget_show (vbox4);
+       gtk_box_pack_start (GTK_BOX (hbox3), vbox4, TRUE, TRUE, 0);
+
+       value_label = gtk_label_new (" Value: ");
+       gtk_widget_show (value_label);
+       gtk_box_pack_start (GTK_BOX (hbox3), value_label, FALSE, FALSE, 0);
+
+       value_entry = gtk_entry_new ();
+       gtk_signal_connect (GTK_OBJECT (value_entry), "changed",
+                                               GTK_SIGNAL_FUNC (on_value_entry_changed),
+                                               NULL);
+       gtk_signal_connect (GTK_OBJECT (value_entry), "insert_text",
+                                               GTK_SIGNAL_FUNC (on_value_entry_insert_text),
+                                               NULL);
+       gtk_entry_set_max_length( (GtkEntry *)value_entry, 11);
+       gtk_widget_show (value_entry);
+       gtk_box_pack_start (GTK_BOX (hbox3), value_entry, TRUE, TRUE, 0);
+
+       vbox3 = gtk_vbox_new (FALSE, 0);
+       gtk_widget_show (vbox3);
+       gtk_box_pack_start (GTK_BOX (hbox3), vbox3, TRUE, TRUE, 0);
+
+       label5 = gtk_label_new ("Surface Flags");
+       gtk_widget_show (label5);
+       gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 0), label5);
+
+       table3 = gtk_table_new (8, 4, FALSE);
+       gtk_widget_show (table3);
+       gtk_container_add (GTK_CONTAINER (notebook1), table3);
+
+       y = -1;
+       for (i = 0; i < MAX_BUTTONS; i++) {
+               if (!(i % 4))
+                       y++;
+               x = i % 4;
+               flag = (1 << i);
+               content_buttons[i] = gtk_toggle_button_new_with_label(contentFlags[i]);
+               gtk_signal_connect(GTK_OBJECT (content_buttons[i]), "toggled", GTK_SIGNAL_FUNC (on_content_button_toggled), &flag);
+               gtk_widget_show(content_buttons[i]);
+               gtk_table_attach(GTK_TABLE (table3), content_buttons[i], 0 + x, 1 + x, (0 + y), (1 + y),
+                                               (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
+                                               (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
+               gtk_container_set_border_width (GTK_CONTAINER (content_buttons[i]), UFOAI_FLAG_BUTTON_BORDER);
+       }
+
+       label6 = gtk_label_new ("Content Flags");
+       gtk_widget_show (label6);
+       gtk_notebook_set_tab_label (GTK_NOTEBOOK (notebook1), gtk_notebook_get_nth_page (GTK_NOTEBOOK (notebook1), 1), label6);
+
+       return frame1;
+}
+
diff --git a/plugins/surface_ufoai/surfaceflagsdialog_ufoai.h b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.h
new file mode 100644 (file)
index 0000000..a6de646
--- /dev/null
@@ -0,0 +1,25 @@
+/*
+Copyright (C) 1999-2007 id Software, Inc. and contributors.
+For a list of contributors, see the accompanying CONTRIBUTORS file.
+
+This file is part of GtkRadiant.
+
+GtkRadiant is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation; either version 2 of the License, or
+(at your option) any later version.
+
+GtkRadiant is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with GtkRadiant; if not, write to the Free Software
+Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+*/
+
+#ifndef _SURFACEFLAGSDIALOG_UFOAI_H
+#define _SURFACEFLAGSDIALOG_UFOAI_H
+
+#endif // _SURFACEFLAGSDIALOG_UFOAI_H
diff --git a/plugins/surface_ufoai/surfdlg_plugin.cpp b/plugins/surface_ufoai/surfdlg_plugin.cpp
new file mode 100644 (file)
index 0000000..694b052
--- /dev/null
@@ -0,0 +1,127 @@
+/*
+Copyright (c) 2001, Loki software, inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list
+of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+Neither the name of Loki software nor the names of its contributors may be used
+to endorse or promote products derived from this software without specific prior
+written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY
+DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdio.h>
+#include "surfdlg_plugin.h"
+#include "surfacedialog.h"
+
+#include "synapse.h"
+
+class CSynapseClient_SurfDLG : public CSynapseClient
+{
+public:
+  // CSynapseClient API
+  bool RequestAPI(APIDescriptor_t *pAPI);
+  const char* GetInfo();
+  const char* GetName();
+  bool OnActivate();
+
+  CSynapseClient_SurfDLG() { }
+  virtual ~CSynapseClient_SurfDLG() { }
+};
+
+// =============================================================================
+// SYNAPSE
+
+_QERFuncTable_1        g_FuncTable;
+_QERUndoTable g_UndoTable;
+_QERAppSurfaceTable g_AppSurfaceTable;
+_QERSelectedFaceTable g_SelectedFaceTable;
+_QERShadersTable g_ShadersTable;
+_QERAppShadersTable g_AppShadersTable;
+_QERAppDataTable g_AppDataTable;
+
+CSynapseServer* g_pSynapseServer = NULL;
+CSynapseClient_SurfDLG g_SynapseClient;
+
+#if __GNUC__ >= 4
+#pragma GCC visibility push(default)
+#endif
+extern "C" CSynapseClient* SYNAPSE_DLL_EXPORT Synapse_EnumerateInterfaces( const char *version, CSynapseServer *pServer ) {
+#if __GNUC__ >= 4
+#pragma GCC visibility pop
+#endif
+  if (strcmp(version, SYNAPSE_VERSION))
+  {
+    Syn_Printf("ERROR: synapse API version mismatch: should be '" SYNAPSE_VERSION "', got '%s'\n", version);
+    return NULL;
+  }
+  g_pSynapseServer = pServer;
+  g_pSynapseServer->IncRef();
+  Set_Syn_Printf(g_pSynapseServer->Get_Syn_Printf());
+
+  g_SynapseClient.AddAPI(SURFACEDIALOG_MAJOR, "ufoai", sizeof(_QERPlugSurfaceTable));
+  g_SynapseClient.AddAPI(RADIANT_MAJOR, NULL, sizeof(_QERFuncTable_1), SYN_REQUIRE, &g_FuncTable);
+  g_SynapseClient.AddAPI(UNDO_MAJOR, NULL, sizeof(_QERUndoTable), SYN_REQUIRE, &g_UndoTable);
+  g_SynapseClient.AddAPI(APPSURFACEDIALOG_MAJOR, NULL, sizeof(_QERAppSurfaceTable), SYN_REQUIRE, &g_AppSurfaceTable);
+  g_SynapseClient.AddAPI(SELECTEDFACE_MAJOR, NULL, sizeof(_QERSelectedFaceTable), SYN_REQUIRE, &g_SelectedFaceTable);
+  g_SynapseClient.AddAPI(SHADERS_MAJOR, "ufoai", sizeof(_QERShadersTable), SYN_REQUIRE, &g_ShadersTable);
+  g_SynapseClient.AddAPI(APPSHADERS_MAJOR, NULL, sizeof(_QERAppShadersTable), SYN_REQUIRE, &g_AppShadersTable);
+  g_SynapseClient.AddAPI(DATA_MAJOR, NULL, sizeof(_QERAppDataTable), SYN_REQUIRE, &g_AppDataTable);
+
+  return &g_SynapseClient;
+}
+
+bool CSynapseClient_SurfDLG::RequestAPI(APIDescriptor_t *pAPI)
+{
+  if (!strcmp(pAPI->major_name, SURFACEDIALOG_MAJOR))
+  {
+    _QERPlugSurfaceTable* pSurfDialogTable= static_cast<_QERPlugSurfaceTable*>(pAPI->mpTable);
+    if (!strcmp(pAPI->minor_name, "ufoai"))
+    {
+      pSurfDialogTable->m_pfnToggleSurface = &ToggleSurface;
+      pSurfDialogTable->m_pfnDoSurface = &DoSurface;
+      pSurfDialogTable->m_pfnUpdateSurfaceDialog = &UpdateSurfaceDialog;
+      pSurfDialogTable->m_pfnSurfaceDlgFitAll = &SurfaceDlgFitAll;
+      pSurfDialogTable->m_pfnGet_SI_Module_Widget = &Get_SI_Module_Widget;
+      return true;
+    }
+  }
+
+  Syn_Printf("ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo());
+  return false;
+}
+
+#include "version.h"
+
+const char* CSynapseClient_SurfDLG::GetInfo()
+{
+       return "Surface Dialog (UFO: Alien Invasion) module built " __DATE__ " " RADIANT_VERSION;
+}
+
+const char* CSynapseClient_SurfDLG::GetName()
+{
+  return "surface";
+}
+
+bool CSynapseClient_SurfDLG::OnActivate()
+{
+  return true;
+}
diff --git a/plugins/surface_ufoai/surfdlg_plugin.h b/plugins/surface_ufoai/surfdlg_plugin.h
new file mode 100644 (file)
index 0000000..f539134
--- /dev/null
@@ -0,0 +1,94 @@
+/*
+Copyright (c) 2001, Loki software, inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, 
+are permitted provided that the following conditions are met:
+
+Redistributions of source code must retain the above copyright notice, this list 
+of conditions and the following disclaimer.
+
+Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+Neither the name of Loki software nor the names of its contributors may be used 
+to endorse or promote products derived from this software without specific prior 
+written permission. 
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' 
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
+DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY 
+DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES 
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; 
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON 
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS 
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
+*/
+
+#ifndef _SURFDLG_PLUGIN_H_
+#define _SURFDLG_PLUGIN_H_
+
+#ifdef __linux__
+
+typedef void* HMODULE;
+typedef void* LPVOID;
+typedef char* LPCSTR;
+
+#endif // __linux__
+
+#include "qerplugin.h"
+#include "synapse.h"
+#include "iselectedface.h"
+#include "iundo.h"
+#include "ishaders.h"
+#include "mathlib.h"
+#include "missing.h"
+#include "idata.h"
+
+#include "isurfaceplugin.h"
+
+class SurfaceDialog : public IPluginTexdef
+{
+       int refCount;
+public:
+       // Increment the number of references to this object
+       void IncRef () { refCount++; }
+       // Decrement the reference count
+       void DecRef () { if ( --refCount <= 0 ) delete this; }
+};
+
+extern _QERFuncTable_1         g_FuncTable;
+extern _QERUndoTable g_UndoTable;
+extern _QERAppSurfaceTable g_AppSurfaceTable;
+extern _QERSelectedFaceTable g_SelectedFaceTable;
+extern _QERShadersTable g_ShadersTable;
+extern _QERAppShadersTable g_AppShadersTable;
+extern _QERAppDataTable g_AppDataTable;
+
+#define GetSelectedFaceCount g_SelectedFaceTable.m_pfnGetSelectedFaceCount
+
+#define Undo_Undo g_UndoTable.m_pfnUndo_Undo
+#define Undo_GetUndoId g_UndoTable.m_pfnUndo_GetUndoId
+
+#define Sys_Printf g_FuncTable.m_pfnSysPrintf
+#define Sys_FPrintf g_FuncTable.m_pfnSysFPrintf
+#define Sys_UpdateWindows g_FuncTable.m_pfnSysUpdateWindows
+
+
+#define Select_FitTexture g_AppSurfaceTable.m_pfnSelect_FitTexture
+#define Get_SI_Inc g_AppSurfaceTable.m_pfnQERApp_QeglobalsSavedinfo_SIInc
+#define GridSize g_AppSurfaceTable.m_pfnQeglobalsGetGridSize
+#define FaceList_FitTexture g_AppSurfaceTable.m_pfnFaceList_FitTexture
+#define GetMainWindow g_AppSurfaceTable.m_pfnGetMainWindow
+#define GetSelectedFaceCountfromBrushes g_AppSurfaceTable.m_pfnGetSelectedFaceCountfromBrushes
+#define GetSelFacesTexdef g_AppSurfaceTable.m_pfnGetSelFacesTexdef
+#define SetTexdef_FaceList g_AppSurfaceTable.m_pfnSetTexdef_FaceList
+#define SetWinPos_from_Prefs g_AppSurfaceTable.m_pfnSetWinPos_From_Prefs
+
+#define Texturewin g_AppShadersTable.m_pfnQeglobalsTexturewin
+
+#endif // _SURFDLG_PLUGIN_H_
+