plugins/surface_quake2/surfacedialog.cpp

   1 /*
   2 Copyright (C) 1999-2007 id Software, Inc. and contributors.
   3 For a list of contributors, see the accompanying CONTRIBUTORS file.
   4
   5 This file is part of GtkRadiant.
   6
   7 GtkRadiant is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2 of the License, or
  10 (at your option) any later version.
  11
  12 GtkRadiant is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GtkRadiant; if not, write to the Free Software
  19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  20 */
  21
  22 //
  23 // Surface Dialog Module
  24 //
  25
  26 //
  27 // Nurail: Implemented to Module from the main Radiant Surface Dialog code
  28 //
  29
  30
  31 #include <gtk/gtk.h>
  32 #include <gdk/gdkkeysyms.h>
  33
  34 #include "surfdlg_plugin.h"
  35
  36
  37
  38 #ifdef _DEBUG
  39 //#define DBG_SI 1
  40 #endif
  41
  42 #include "gtkr_vector.h"
  43
  44 std::vector<texdef_to_face_t> g_texdef_face_vector;
  45
  46 inline texdef_to_face_t* get_texdef_face_list()
  47 {
  48   return &(*g_texdef_face_vector.begin());
  49 }
  50
  51 inline unsigned int texdef_face_list_empty()
  52 {
  53   return g_texdef_face_vector.empty();
  54 }
  55
  56 inline unsigned int texdef_face_list_size()
  57 {
  58   return g_texdef_face_vector.size();
  59 }
  60
  61 // For different faces having different values
  62 bool is_HShift_conflicting;
  63 bool is_VShift_conflicting;
  64 bool is_HScale_conflicting;
  65 bool is_VScale_conflicting;
  66 bool is_Rotate_conflicting;
  67 bool is_TextureName_conflicting;
  68
  69 void ShowDlg();
  70 void HideDlg();
  71 void SetTexMods();
  72 void GetTexMods(bool b_SetUndoPoint = FALSE);
  73 void BuildDialog();
  74 void FitAll();
  75 void InitDefaultIncrement(texdef_t *);
  76 void DoSnapTToGrid(float hscale, float vscale);
  77 // called to perform a fitting from the outside (shortcut key)
  78 void SurfaceDialogFitAll();
  79
  80 // Quake2 Flags Functions
  81 void SetFlagButtons_Quake2(texdef_to_face_t *texdef_face_list,  bool b_isListEmpty);
  82 void SetChangeInFlags_Face_Quake2 (texdef_to_face_t *texdef_face_list);
  83 GtkWidget* Create_Quake2FlagsDialog (GtkWidget* surfacedialog_widget);
  84
  85
  86 // Dialog Data
  87 int m_nHeight;
  88 int m_nWidth;
  89
  90 // 0 is invalid, otherwise it's the Id of the last 'do' we are responsible for
  91 int m_nUndoId;
  92
  93
  94 texturewin_t *texturewin;
  95 texdef_t *l_pIncrement;
  96 texdef_t texdef_offset;
  97 texdef_t texdef_SI_values;
  98
  99 // For Texture Entry, activate only on entry change
 100 char old_texture_entry[128];
 101
 102 // the texdef to switch back to when the OnCancel is called
 103 texdef_t        g_old_texdef;
 104
 105 // when TRUE, this thing means the surface inspector is currently being displayed
 106 bool  g_surfwin = FALSE;
 107 // turn on/off processing of the "changed" "value_changed" messages
 108 // (need to turn off when we are feeding data in)
 109 bool g_bListenChanged = true;
 110 // turn on/off listening of the update messages
 111 bool g_bListenUpdate = true;
 112
 113 GtkWidget* create_SurfaceInspector (void);
 114 GtkWidget *SurfaceInspector = NULL;
 115
 116 GtkWidget *m_pWidget;
 117 GtkWidget *GetWidget () { return SurfaceInspector; }
 118 GtkWidget *Get_SI_Module_Widget () { return SurfaceInspector; }
 119 void SetWidget(GtkWidget *new_widget) { m_pWidget = new_widget; }
 120 GtkWidget *GetDlgWidget (const char* name)
 121   { return GTK_WIDGET (g_object_get_data (G_OBJECT (SurfaceInspector), name)); }
 122
 123 // Spins for FitTexture
 124 GtkWidget *spin_width;
 125 GtkWidget *spin_height;
 126
 127
 128 GtkWidget *texture_combo;
 129 GtkWidget *texture_combo_entry;
 130
 131 GtkWidget *match_grid_button;
 132 GtkWidget *lock_valuechange_togglebutton;
 133
 134 GtkObject *hshift_value_spinbutton_adj;
 135 GtkWidget *hshift_value_spinbutton;
 136 GtkObject *vshift_value_spinbutton_adj;
 137 GtkWidget *vshift_value_spinbutton;
 138 GtkObject *hscale_value_spinbutton_adj;
 139 GtkWidget *hscale_value_spinbutton;
 140 GtkObject *vscale_value_spinbutton_adj;
 141 GtkWidget *vscale_value_spinbutton;
 142 GtkObject *rotate_value_spinbutton_adj;
 143 GtkWidget *rotate_value_spinbutton;
 144
 145 GtkObject *hshift_offset_spinbutton_adj;
 146 GtkWidget *hshift_offset_spinbutton;
 147 GtkObject *vshift_offset_spinbutton_adj;
 148 GtkWidget *vshift_offset_spinbutton;
 149 GtkObject *hscale_offset_spinbutton_adj;
 150 GtkWidget *hscale_offset_spinbutton;
 151 GtkObject *vscale_offset_spinbutton_adj;
 152 GtkWidget *vscale_offset_spinbutton;
 153 GtkObject *rotate_offset_spinbutton_adj;
 154 GtkWidget *rotate_offset_spinbutton;
 155
 156 GtkObject *hshift_step_spinbutton_adj;
 157 GtkWidget *hshift_step_spinbutton;
 158 GtkObject *vshift_step_spinbutton_adj;
 159 GtkWidget *vshift_step_spinbutton;
 160 GtkObject *hscale_step_spinbutton_adj;
 161 GtkWidget *hscale_step_spinbutton;
 162 GtkObject *vscale_step_spinbutton_adj;
 163 GtkWidget *vscale_step_spinbutton;
 164 GtkObject *rotate_step_spinbutton_adj;
 165 GtkWidget *rotate_step_spinbutton;
 166
 167 GtkObject *fit_width_spinbutton_adj;
 168 GtkWidget *fit_width_spinbutton;
 169 GtkObject *fit_height_spinbutton_adj;
 170 GtkWidget *fit_height_spinbutton;
 171 GtkWidget *fit_button;
 172 GtkWidget *axial_button;
 173
 174 GtkWidget *done_button;
 175 GtkWidget *apply_button;
 176 GtkWidget *cancel_button;
 177
 178 // Callbacks
 179 gboolean on_texture_combo_entry_key_press_event (GtkWidget *widget, GdkEventKey *event, gpointer user_data);
 180 void on_texture_combo_entry_activate (GtkEntry *entry, gpointer user_data);
 181
 182 static void on_match_grid_button_clicked (GtkButton *button, gpointer user_data);
 183 static void on_lock_valuechange_togglebutton_toggled (GtkToggleButton *togglebutton, gpointer user_data);
 184
 185 static void on_hshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 186 static void on_vshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 187 static void on_hscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 188 static void on_vscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 189 static void on_rotate_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 190
 191 static void on_hshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 192 static void on_vshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 193 static void on_hscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 194 static void on_vscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 195 static void on_rotate_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 196
 197 static void on_hshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 198 static void on_vshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 199 static void on_hscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 200 static void on_vscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 201 static void on_rotate_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 202
 203 static void on_fit_width_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 204 static void on_fit_height_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data);
 205 static void on_fit_button_clicked (GtkButton *button, gpointer user_data);
 206 static void on_axial_button_clicked (GtkButton *button, gpointer user_data);
 207
 208 static void on_done_button_clicked (GtkButton *button, gpointer user_data);
 209 static void on_apply_button_clicked (GtkButton *button, gpointer user_data);
 210 static void on_cancel_button_clicked (GtkButton *button, gpointer user_data);
 211
 212
 213 /*
 214 ===================================================
 215
 216   SURFACE INSPECTOR
 217
 218 ===================================================
 219 */
 220
 221
 222 void IsFaceConflicting()
 223 {
 224   texdef_t* tmp_texdef;
 225   texdef_to_face_t* temp_texdef_face_list;
 226 //  char buf[12];
 227   char texture_name[128];
 228
 229   if (texdef_face_list_empty())
 230   {
 231     gtk_entry_set_text( GTK_ENTRY (hshift_value_spinbutton), "");
 232     gtk_entry_set_text( GTK_ENTRY (vshift_value_spinbutton), "");
 233     gtk_entry_set_text( GTK_ENTRY (hscale_value_spinbutton), "");
 234     gtk_entry_set_text( GTK_ENTRY (vscale_value_spinbutton), "");
 235     gtk_entry_set_text( GTK_ENTRY (rotate_value_spinbutton), "");
 236     gtk_entry_set_text( GTK_ENTRY (texture_combo_entry), "");
 237     return;
 238   }
 239
 240   g_bListenChanged = FALSE;
 241
 242   tmp_texdef = &get_texdef_face_list()->texdef;
 243
 244   strcpy(texture_name, tmp_texdef->GetName() );
 245
 246   texdef_SI_values.shift[0] = tmp_texdef->shift[0];
 247   texdef_SI_values.shift[1] = tmp_texdef->shift[1];
 248   texdef_SI_values.scale[0] = tmp_texdef->scale[0];
 249   texdef_SI_values.scale[1] = tmp_texdef->scale[1];
 250   texdef_SI_values.rotate = tmp_texdef->rotate;
 251   texdef_SI_values.SetName( texture_name );
 252
 253   is_HShift_conflicting = FALSE;
 254   is_VShift_conflicting = FALSE;
 255   is_HScale_conflicting = FALSE;
 256   is_VScale_conflicting = FALSE;
 257   is_Rotate_conflicting = FALSE;
 258   is_TextureName_conflicting = FALSE;
 259
 260   if (texdef_face_list_size() > 1)
 261   {
 262     temp_texdef_face_list = get_texdef_face_list()->next;
 263
 264     for (; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
 265     {
 266       tmp_texdef = &temp_texdef_face_list->texdef;
 267       if ( texdef_SI_values.shift[0] != tmp_texdef->shift[0] )
 268         is_HShift_conflicting = TRUE;
 269
 270       if ( texdef_SI_values.shift[1] != tmp_texdef->shift[1] )
 271         is_VShift_conflicting = TRUE;
 272
 273       if ( texdef_SI_values.scale[0] != tmp_texdef->scale[0] )
 274         is_HScale_conflicting = TRUE;
 275
 276       if ( texdef_SI_values.scale[1] != tmp_texdef->scale[1] )
 277         is_VScale_conflicting = TRUE;
 278
 279       if ( texdef_SI_values.rotate != tmp_texdef->rotate )
 280         is_Rotate_conflicting = TRUE;
 281
 282       if ( strcmp( texture_name, tmp_texdef->GetName() ) )
 283         is_TextureName_conflicting = TRUE;
 284     }
 285   }
 286
 287   if(is_HShift_conflicting)
 288     gtk_entry_set_text( GTK_ENTRY (hshift_value_spinbutton), "");
 289   else
 290     gtk_spin_button_set_value( GTK_SPIN_BUTTON(hshift_value_spinbutton) , texdef_SI_values.shift[0] );
 291
 292   if(is_VShift_conflicting)
 293     gtk_entry_set_text( GTK_ENTRY (vshift_value_spinbutton), "");
 294   else
 295     gtk_spin_button_set_value( GTK_SPIN_BUTTON(vshift_value_spinbutton) , texdef_SI_values.shift[1] );
 296
 297   if(is_HScale_conflicting)
 298     gtk_entry_set_text( GTK_ENTRY (hscale_value_spinbutton), "");
 299   else
 300     gtk_spin_button_set_value( GTK_SPIN_BUTTON(hscale_value_spinbutton) , texdef_SI_values.scale[0] );
 301
 302   if(is_VScale_conflicting)
 303     gtk_entry_set_text( GTK_ENTRY (vscale_value_spinbutton), "");
 304   else
 305     gtk_spin_button_set_value( GTK_SPIN_BUTTON(vscale_value_spinbutton) , texdef_SI_values.scale[1] );
 306
 307   if(is_Rotate_conflicting)
 308     gtk_entry_set_text( GTK_ENTRY (rotate_value_spinbutton), "");
 309   else
 310     gtk_spin_button_set_value( GTK_SPIN_BUTTON(rotate_value_spinbutton) , texdef_SI_values.rotate );
 311
 312   g_bListenChanged = TRUE;
 313 }
 314
 315 #define MAX_NUM_LIST_ITEMS 15
 316 static void PopulateTextureComboList()
 317 {
 318   texdef_t* tmp_texdef;
 319   texdef_to_face_t* temp_texdef_face_list;
 320   char blank[1];
 321   GList *items = NULL;
 322 //  GList *tmp_item;
 323   int num_of_list_items = 0;
 324
 325   blank[0] = 0;
 326
 327   if (texdef_face_list_empty())
 328   {
 329     items = g_list_append (items, (gpointer) blank);
 330     // For Texture Entry, activate only on entry change
 331     strcpy (old_texture_entry, blank);
 332   }
 333   else if ( !is_TextureName_conflicting )
 334   {
 335     temp_texdef_face_list = get_texdef_face_list();
 336     tmp_texdef = (texdef_t *) &get_texdef_face_list()->texdef;
 337     items = g_list_append( items, (gpointer) tmp_texdef->GetName() );
 338     // For Texture Entry, activate only on entry change
 339     strcpy (old_texture_entry, tmp_texdef->GetName());
 340   }
 341   else
 342   {
 343     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
 344     {
 345       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
 346       // Need to do a string compare, hence the custom search
 347       if (!( g_list_find_custom (items, tmp_texdef->GetName(), (GCompareFunc) strcmp ) ))
 348       {
 349         items = g_list_append( items, (gpointer) tmp_texdef->GetName() );
 350         num_of_list_items++;
 351       }
 352       // Make sure the combo list isn't too long
 353       if (num_of_list_items >= MAX_NUM_LIST_ITEMS)
 354         break;
 355     }
 356     // If this isn't added last (to the top of the list), g_list_find freaks.
 357     items = g_list_prepend (items, (gpointer) blank);
 358     // For Texture Entry, activate only on entry change
 359     strcpy (old_texture_entry, blank);
 360   }
 361
 362   gtk_combo_set_popdown_strings (GTK_COMBO (texture_combo), items);
 363   g_list_free(items);
 364
 365 }
 366
 367 static void ZeroOffsetValues()
 368 {
 369   texdef_offset.shift[0] = 0.0;
 370   texdef_offset.shift[1] = 0.0;
 371   texdef_offset.scale[0] = 0.0;
 372   texdef_offset.scale[1] = 0.0;
 373   texdef_offset.rotate = 0.0;
 374 }
 375
 376 static void GetTexdefInfo_from_Radiant()
 377 {
 378   g_texdef_face_vector.clear();
 379
 380   unsigned int count = GetSelectedFaceCountfromBrushes();
 381   if(count == 0)
 382     count = GetSelectedFaceCount();
 383
 384   g_texdef_face_vector.resize(count);
 385
 386   if (!texdef_face_list_empty())
 387   {
 388 //    texdef_to_face_t* p = get_texdef_face_list();
 389     GetSelFacesTexdef( get_texdef_face_list() );
 390   }
 391
 392   IsFaceConflicting();
 393   PopulateTextureComboList();
 394   ZeroOffsetValues();
 395   if ( texdef_face_list_empty() )
 396     SetFlagButtons_Quake2( get_texdef_face_list() , TRUE);
 397   else
 398     SetFlagButtons_Quake2( get_texdef_face_list() , FALSE);
 399 }
 400
 401 static gint delete_event_callback(GtkWidget *widget, GdkEvent* event, gpointer data)
 402 {
 403   HideDlg();
 404   return TRUE;
 405 }
 406
 407 // make the shift increments match the grid settings
 408 // the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size
 409 // this depends on a scale value if you have selected a particular texture on which you want it to work:
 410 // we move the textures in pixels, not world units. (i.e. increment values are in pixel)
 411 // depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize
 412 // increment * scale = gridsize
 413 // hscale and vscale are optional parameters, if they are zero they will be set to the default scale
 414 // NOTE: the default scale depends if you are using BP mode or regular.
 415 // For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f
 416 // see fenris #2810
 417 void DoSnapTToGrid(float hscale, float vscale)
 418 {
 419   l_pIncrement = Get_SI_Inc();
 420
 421   if (hscale == 0.0f)
 422   {
 423     hscale = 0.5f;
 424   }
 425   if (vscale == 0.0f)
 426   {
 427      vscale = 0.5f;
 428   }
 429 #ifdef _DEBUG
 430   Sys_Printf ("DoSnapTToGrid: hscale %g vscale %g\n", hscale, vscale);
 431 #endif
 432   l_pIncrement->shift[0] = GridSize() / hscale;
 433   l_pIncrement->shift[1] = GridSize() / vscale;
 434   // now some update work
 435   // FIXME: doesn't look good here, seems to be called several times
 436   SetTexMods();
 437 }
 438
 439 void UpdateSurfaceDialog()
 440 {
 441   if (!g_bListenUpdate)
 442     return;
 443
 444   if (!SurfaceInspector)
 445     return;
 446
 447   // avoid long delays on slow computers
 448   while (gtk_events_pending ())
 449     gtk_main_iteration ();
 450
 451   if (g_surfwin)
 452   {
 453 #ifdef DBG_SI
 454     Sys_Printf("UpdateSurfaceDialog\n");
 455 #endif
 456     GetTexdefInfo_from_Radiant();
 457     SetTexMods();
 458   }
 459
 460 }
 461
 462 // DoSurface will always try to show the surface inspector
 463 // or update it because something new has been selected
 464 void DoSurface (void)
 465 {
 466 #ifdef DBG_SI
 467   Sys_Printf("DoSurface\n");
 468 #endif
 469   if (!SurfaceInspector)
 470     create_SurfaceInspector ();
 471
 472   ShowDlg();
 473   SetTexMods ();
 474 }
 475
 476 void ToggleSurface()
 477 {
 478 #ifdef DBG_SI
 479   Sys_Printf("ToggleSurface Module\n");
 480 #endif
 481   if (!g_surfwin)
 482     DoSurface ();
 483   else
 484     on_cancel_button_clicked(NULL, NULL);
 485 }
 486
 487 // NOTE: will raise and show the Surface inspector and exec fit for patches and brushes
 488 void SurfaceDlgFitAll()
 489 {
 490   DoSurface();
 491   FitAll();
 492 }
 493
 494 // =============================================================================
 495 // SurfaceDialog class
 496
 497 void ShowDlg()
 498 {
 499
 500   if(!SurfaceInspector)
 501     create_SurfaceInspector();
 502   else
 503     gtk_widget_show (SurfaceInspector);
 504
 505   GetTexdefInfo_from_Radiant();
 506   GetTexMods(TRUE); // Set Initial Undo Point
 507   g_surfwin = TRUE;
 508 }
 509
 510 void HideDlg()
 511 {
 512   g_surfwin = FALSE;
 513   gtk_widget_hide (SurfaceInspector);
 514 }
 515
 516
 517 // set default values for increments (shift scale and rot)
 518 // this is called by the prefs code if can't find the values
 519 void InitDefaultIncrement(texdef_t *tex)
 520 {
 521   tex->SetName("foo");
 522   tex->shift[0] = 8;
 523   tex->shift[1] = 8;
 524   tex->scale[0] = 0.25;
 525   tex->scale[1] = 0.25;
 526   tex->rotate = 10;
 527 }
 528
 529 void BuildDialog ()
 530 {
 531    if ( !SurfaceInspector )
 532     create_SurfaceInspector();
 533 }
 534
 535 /*
 536 ==============
 537 SetTexMods
 538
 539 Set the fields to the current texdef (i.e. map/texdef -> dialog widgets)
 540 ===============
 541 */
 542
 543 void SetTexMods()
 544 {
 545   texdef_t *pt;
 546   GtkSpinButton *spin;
 547   GtkAdjustment *adjust;
 548
 549   texturewin = Texturewin ();
 550   l_pIncrement = Get_SI_Inc();
 551
 552 #ifdef DBG_SI
 553   Sys_Printf("SurfaceDlg SetTexMods\n");
 554 #endif
 555
 556   if (!g_surfwin)
 557     return;
 558
 559   pt = &texturewin->texdef;
 560
 561   g_bListenChanged = false;
 562
 563   if(strncmp(pt->GetName(), "textures/", 9) != 0)
 564     texdef_offset.SetName(SHADER_NOT_FOUND);
 565
 566
 567   spin = GTK_SPIN_BUTTON (hshift_offset_spinbutton);
 568   gtk_spin_button_set_value (spin, texdef_offset.shift[0]);
 569   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 570   adjust->step_increment = l_pIncrement->shift[0];
 571   gtk_spin_button_set_value (GTK_SPIN_BUTTON(hshift_step_spinbutton), l_pIncrement->shift[0]);
 572
 573   spin = GTK_SPIN_BUTTON (hshift_value_spinbutton);
 574   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 575   adjust->step_increment = l_pIncrement->shift[0];
 576
 577
 578   spin = GTK_SPIN_BUTTON (vshift_offset_spinbutton);
 579   gtk_spin_button_set_value (spin, texdef_offset.shift[1]);
 580   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 581   adjust->step_increment = l_pIncrement->shift[1];
 582   gtk_spin_button_set_value (GTK_SPIN_BUTTON(vshift_step_spinbutton), l_pIncrement->shift[1]);
 583
 584   spin = GTK_SPIN_BUTTON (vshift_value_spinbutton);
 585   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 586   adjust->step_increment = l_pIncrement->shift[1];
 587
 588
 589   spin = GTK_SPIN_BUTTON (hscale_offset_spinbutton);
 590   gtk_spin_button_set_value (spin, texdef_offset.scale[0]);
 591   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 592   adjust->step_increment = l_pIncrement->scale[0];
 593   gtk_spin_button_set_value (GTK_SPIN_BUTTON(hscale_step_spinbutton), l_pIncrement->scale[0]);
 594
 595   spin = GTK_SPIN_BUTTON (hscale_value_spinbutton);
 596   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 597   adjust->step_increment = l_pIncrement->scale[0];
 598
 599
 600   spin = GTK_SPIN_BUTTON (vscale_offset_spinbutton);
 601   gtk_spin_button_set_value (spin, texdef_offset.scale[1]);
 602   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 603   adjust->step_increment = l_pIncrement->scale[1];
 604   gtk_spin_button_set_value (GTK_SPIN_BUTTON(vscale_step_spinbutton), l_pIncrement->scale[1]);
 605
 606   spin = GTK_SPIN_BUTTON (vscale_value_spinbutton);
 607   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 608   adjust->step_increment = l_pIncrement->scale[1];
 609
 610
 611   spin = GTK_SPIN_BUTTON (rotate_offset_spinbutton);
 612   gtk_spin_button_set_value (spin, texdef_offset.rotate);
 613   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 614   adjust->step_increment = l_pIncrement->rotate;
 615   gtk_spin_button_set_value (GTK_SPIN_BUTTON(rotate_step_spinbutton), l_pIncrement->rotate);
 616
 617   spin = GTK_SPIN_BUTTON (rotate_value_spinbutton);
 618   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON (spin));
 619   adjust->step_increment = l_pIncrement->rotate;
 620
 621
 622   g_bListenChanged = true;
 623
 624   // store the current texdef as our escape route if user hits OnCancel
 625   g_old_texdef = texturewin->texdef;
 626 }
 627
 628 /*
 629 ==============
 630 GetTexMods
 631
 632 Shows any changes to the main Radiant windows
 633 ===============
 634 */
 635 void GetTexMods(bool b_SetUndoPoint)
 636 {
 637
 638 #ifdef DBG_SI
 639   Sys_Printf("SurfaceDlg GetTexMods\n");
 640 #endif
 641
 642   if ( !texdef_face_list_empty() )
 643   {
 644     g_bListenUpdate=FALSE;
 645     SetChangeInFlags_Face_Quake2 ( get_texdef_face_list() );
 646     SetTexdef_FaceList( get_texdef_face_list(), b_SetUndoPoint, false );
 647     g_bListenUpdate=TRUE;
 648
 649     if (b_SetUndoPoint)
 650       m_nUndoId = Undo_GetUndoId();
 651   }
 652 }
 653
 654 void FitAll()
 655 {
 656   on_fit_button_clicked(NULL, NULL);
 657 }
 658
 659
 660 ////////////////////////////////////////////////////////////////////
 661 //
 662 //  GUI Section
 663 //
 664 ////////////////////////////////////////////////////////////////////
 665
 666 GtkWidget* create_SurfaceInspector (void)
 667 {
 668
 669   GtkWidget *label;
 670   GtkWidget *hseparator;
 671   GtkWidget *eventbox;
 672
 673   GtkWidget *viewport8;
 674   GtkWidget *viewport9;
 675   GtkWidget *viewport2;
 676   GtkWidget *viewport7;
 677   GtkWidget *viewport5;
 678   GtkWidget *viewport6;
 679   GtkWidget *viewport10;
 680
 681   GtkWidget *table1;
 682   GtkWidget *table4;
 683   GtkWidget *table5;
 684   GtkWidget *table7;
 685
 686   GtkWidget *alignment1;
 687   GtkWidget *alignment2;
 688   GtkWidget *alignment3;
 689
 690   GtkWidget *vbox7;
 691
 692   GtkWidget *hbox1;
 693   GtkWidget *hbox2;
 694   GtkWidget *hbox3;
 695   GtkWidget *hbox4;
 696
 697   GtkWidget *image1;
 698   GtkWidget *image2;
 699   GtkWidget *image3;
 700
 701   GtkWidget *hbuttonbox1;
 702
 703   SurfaceInspector = gtk_window_new (GTK_WINDOW_TOPLEVEL);
 704   gtk_container_set_border_width (GTK_CONTAINER (SurfaceInspector), 4);
 705   gtk_window_set_title (GTK_WINDOW (SurfaceInspector), "Surface Inspector");
 706
 707   SetWinPos_from_Prefs(SurfaceInspector);
 708
 709   viewport8 = gtk_viewport_new (NULL, NULL);
 710   gtk_widget_show (viewport8);
 711   gtk_container_add (GTK_CONTAINER (SurfaceInspector), viewport8);
 712   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport8), GTK_SHADOW_NONE);
 713
 714   vbox7 = gtk_vbox_new (FALSE, 0);
 715   gtk_widget_show (vbox7);
 716   gtk_container_add (GTK_CONTAINER (viewport8), vbox7);
 717
 718   viewport9 = gtk_viewport_new (NULL, NULL);
 719   gtk_widget_show (viewport9);
 720   gtk_box_pack_start (GTK_BOX (vbox7), viewport9, FALSE, FALSE, 0);
 721   gtk_container_set_border_width (GTK_CONTAINER (viewport9), 2);
 722   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport9), GTK_SHADOW_ETCHED_IN);
 723
 724   hbox1 = gtk_hbox_new (FALSE, 0);
 725   gtk_widget_show (hbox1);
 726   gtk_container_add (GTK_CONTAINER (viewport9), hbox1);
 727   gtk_container_set_border_width (GTK_CONTAINER (hbox1), 4);
 728
 729   label = gtk_label_new ("Texture: ");
 730   gtk_widget_show (label);
 731   gtk_box_pack_start (GTK_BOX (hbox1), label, FALSE, FALSE, 0);
 732   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 733
 734   texture_combo = gtk_combo_new ();
 735   g_object_set_data (G_OBJECT (GTK_COMBO (texture_combo)->popwin),
 736                      "KeepMeAround", texture_combo);
 737   gtk_combo_disable_activate ( (GtkCombo*) texture_combo);
 738   gtk_widget_show (texture_combo);
 739   gtk_box_pack_start (GTK_BOX (hbox1), texture_combo, TRUE, TRUE, 0);
 740
 741   texture_combo_entry = GTK_COMBO (texture_combo)->entry;
 742   gtk_widget_show (texture_combo_entry);
 743   gtk_entry_set_max_length (GTK_ENTRY (texture_combo_entry), 128);
 744
 745   viewport2 = gtk_viewport_new (NULL, NULL);
 746   gtk_widget_show (viewport2);
 747   gtk_box_pack_start (GTK_BOX (vbox7), viewport2, FALSE, TRUE, 0);
 748   gtk_container_set_border_width (GTK_CONTAINER (viewport2), 2);
 749   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport2), GTK_SHADOW_ETCHED_IN);
 750
 751   table1 = gtk_table_new (13, 4, FALSE);
 752   gtk_widget_show (table1);
 753   gtk_container_add (GTK_CONTAINER (viewport2), table1);
 754
 755   hseparator = gtk_hseparator_new ();
 756   gtk_widget_show (hseparator);
 757   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 1, 2,
 758                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 759                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 760
 761   hseparator = gtk_hseparator_new ();
 762   gtk_widget_show (hseparator);
 763   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 1, 2,
 764                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 765                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 766
 767   hseparator = gtk_hseparator_new ();
 768   gtk_widget_show (hseparator);
 769   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 1, 2,
 770                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 771                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 772
 773   hseparator = gtk_hseparator_new ();
 774   gtk_widget_show (hseparator);
 775   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 3, 4,
 776                     (GtkAttachOptions) (GTK_FILL),
 777                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 778
 779   hseparator = gtk_hseparator_new ();
 780   gtk_widget_show (hseparator);
 781   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 3, 4,
 782                     (GtkAttachOptions) (GTK_FILL),
 783                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 784
 785   hseparator = gtk_hseparator_new ();
 786   gtk_widget_show (hseparator);
 787   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 3, 4,
 788                     (GtkAttachOptions) (GTK_FILL),
 789                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 790
 791   hseparator = gtk_hseparator_new ();
 792   gtk_widget_show (hseparator);
 793   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 5, 6,
 794                     (GtkAttachOptions) (GTK_FILL),
 795                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 796
 797   hseparator = gtk_hseparator_new ();
 798   gtk_widget_show (hseparator);
 799   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 5, 6,
 800                     (GtkAttachOptions) (GTK_FILL),
 801                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 802
 803   hseparator = gtk_hseparator_new ();
 804   gtk_widget_show (hseparator);
 805   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 5, 6,
 806                     (GtkAttachOptions) (GTK_FILL),
 807                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 808
 809   hseparator = gtk_hseparator_new ();
 810   gtk_widget_show (hseparator);
 811   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 7, 8,
 812                     (GtkAttachOptions) (GTK_FILL),
 813                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 814
 815   hseparator = gtk_hseparator_new ();
 816   gtk_widget_show (hseparator);
 817   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 7, 8,
 818                     (GtkAttachOptions) (GTK_FILL),
 819                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 820
 821   hseparator = gtk_hseparator_new ();
 822   gtk_widget_show (hseparator);
 823   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 7, 8,
 824                     (GtkAttachOptions) (GTK_FILL),
 825                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 826
 827   hseparator = gtk_hseparator_new ();
 828   gtk_widget_show (hseparator);
 829   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 9, 10,
 830                     (GtkAttachOptions) (GTK_FILL),
 831                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 832
 833   hseparator = gtk_hseparator_new ();
 834   gtk_widget_show (hseparator);
 835   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 9, 10,
 836                     (GtkAttachOptions) (GTK_FILL),
 837                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 838
 839   hseparator = gtk_hseparator_new ();
 840   gtk_widget_show (hseparator);
 841   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 9, 10,
 842                     (GtkAttachOptions) (GTK_FILL),
 843                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 844
 845   hseparator = gtk_hseparator_new ();
 846   gtk_widget_show (hseparator);
 847   gtk_table_attach (GTK_TABLE (table1), hseparator, 1, 2, 11, 12,
 848                     (GtkAttachOptions) (GTK_FILL),
 849                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 850
 851   hseparator = gtk_hseparator_new ();
 852   gtk_widget_show (hseparator);
 853   gtk_table_attach (GTK_TABLE (table1), hseparator, 2, 3, 11, 12,
 854                     (GtkAttachOptions) (GTK_FILL),
 855                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 856
 857   hseparator = gtk_hseparator_new ();
 858   gtk_widget_show (hseparator);
 859   gtk_table_attach (GTK_TABLE (table1), hseparator, 3, 4, 11, 12,
 860                     (GtkAttachOptions) (GTK_FILL),
 861                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 862
 863   label = gtk_label_new ("Offset");
 864   gtk_widget_show (label);
 865   gtk_table_attach (GTK_TABLE (table1), label, 2, 3, 0, 1,
 866                     (GtkAttachOptions) (GTK_FILL),
 867                     (GtkAttachOptions) (0), 0, 0);
 868
 869   label = gtk_label_new ("Step");
 870   gtk_widget_show (label);
 871   gtk_table_attach (GTK_TABLE (table1), label, 3, 4, 0, 1,
 872                     (GtkAttachOptions) (GTK_FILL),
 873                     (GtkAttachOptions) (0), 0, 0);
 874
 875   eventbox = gtk_event_box_new ();
 876   gtk_widget_show (eventbox);
 877   gtk_table_attach (GTK_TABLE (table1), eventbox, 3, 4, 12, 13,
 878                     (GtkAttachOptions) (GTK_FILL),
 879                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 880
 881   match_grid_button = gtk_button_new_with_mnemonic ("Match Grid");
 882   gtk_widget_show (match_grid_button);
 883   gtk_container_add (GTK_CONTAINER (eventbox), match_grid_button);
 884
 885   label = gtk_label_new ("Value");
 886   gtk_widget_show (label);
 887   gtk_table_attach (GTK_TABLE (table1), label, 1, 2, 0, 1,
 888                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
 889                     (GtkAttachOptions) (0), 0, 0);
 890   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
 891
 892   hseparator = gtk_hseparator_new ();
 893   gtk_widget_show (hseparator);
 894   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 3, 4,
 895                     (GtkAttachOptions) (GTK_SHRINK | GTK_FILL),
 896                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 897
 898   hseparator = gtk_hseparator_new ();
 899   gtk_widget_show (hseparator);
 900   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 5, 6,
 901                     (GtkAttachOptions) (GTK_FILL),
 902                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 903
 904   hseparator = gtk_hseparator_new ();
 905   gtk_widget_show (hseparator);
 906   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 7, 8,
 907                     (GtkAttachOptions) (GTK_FILL),
 908                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 909
 910   hseparator = gtk_hseparator_new ();
 911   gtk_widget_show (hseparator);
 912   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 9, 10,
 913                     (GtkAttachOptions) (GTK_FILL),
 914                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 915
 916   hseparator = gtk_hseparator_new ();
 917   gtk_widget_show (hseparator);
 918   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 11, 12,
 919                     (GtkAttachOptions) (GTK_FILL),
 920                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 921
 922   eventbox = gtk_event_box_new ();
 923   gtk_widget_show (eventbox);
 924   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 4, 5,
 925                     (GtkAttachOptions) (GTK_FILL),
 926                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 927
 928   label = gtk_label_new ("V Shift: ");
 929   gtk_widget_show (label);
 930   gtk_container_add (GTK_CONTAINER (eventbox), label);
 931   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 932   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 933
 934   eventbox = gtk_event_box_new ();
 935   gtk_widget_show (eventbox);
 936   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 6, 7,
 937                     (GtkAttachOptions) (GTK_FILL),
 938                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 939
 940   label = gtk_label_new (" H Scale: ");
 941   gtk_widget_show (label);
 942   gtk_container_add (GTK_CONTAINER (eventbox), label);
 943   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 944   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 945
 946   eventbox = gtk_event_box_new ();
 947   gtk_widget_show (eventbox);
 948   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 8, 9,
 949                     (GtkAttachOptions) (GTK_FILL),
 950                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 951
 952   label = gtk_label_new ("V Scale: ");
 953   gtk_widget_show (label);
 954   gtk_container_add (GTK_CONTAINER (eventbox), label);
 955   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 956   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 957
 958   eventbox = gtk_event_box_new ();
 959   gtk_widget_show (eventbox);
 960   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 10, 11,
 961                     (GtkAttachOptions) (GTK_FILL),
 962                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 963
 964   label = gtk_label_new ("Rotate: ");
 965   gtk_widget_show (label);
 966   gtk_container_add (GTK_CONTAINER (eventbox), label);
 967   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 968   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 969
 970   eventbox = gtk_event_box_new ();
 971   gtk_widget_show (eventbox);
 972   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 2, 3,
 973                     (GtkAttachOptions) (GTK_FILL),
 974                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 975
 976   label = gtk_label_new ("H Shift: ");
 977   gtk_widget_show (label);
 978   gtk_container_add (GTK_CONTAINER (eventbox), label);
 979   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
 980   gtk_misc_set_alignment (GTK_MISC (label), 1, 0.5);
 981
 982   hseparator = gtk_hseparator_new ();
 983   gtk_widget_show (hseparator);
 984   gtk_table_attach (GTK_TABLE (table1), hseparator, 0, 1, 1, 2,
 985                     (GtkAttachOptions) (GTK_FILL),
 986                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 987
 988   eventbox = gtk_event_box_new ();
 989   gtk_widget_show (eventbox);
 990   gtk_table_attach (GTK_TABLE (table1), eventbox, 1, 2, 12, 13,
 991                     (GtkAttachOptions) (GTK_FILL),
 992                     (GtkAttachOptions) (GTK_FILL), 0, 0);
 993
 994   lock_valuechange_togglebutton = gtk_toggle_button_new_with_mnemonic ("UNLOCK");
 995   gtk_widget_show (lock_valuechange_togglebutton);
 996   gtk_container_add (GTK_CONTAINER (eventbox), lock_valuechange_togglebutton);
 997
 998   // Value Spins
 999   hshift_value_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1000   hshift_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_value_spinbutton_adj), 1, 2);
1001   gtk_widget_show (hshift_value_spinbutton);
1002   gtk_table_attach (GTK_TABLE (table1), hshift_value_spinbutton, 1, 2, 2, 3,
1003                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1004                     (GtkAttachOptions) (0), 0, 0);
1005   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_value_spinbutton), GTK_UPDATE_IF_VALID);
1006   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hshift_value_spinbutton), TRUE);
1007   gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), FALSE );
1008
1009   vshift_value_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1010   vshift_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_value_spinbutton_adj), 1, 2);
1011   gtk_widget_show (vshift_value_spinbutton);
1012   gtk_table_attach (GTK_TABLE (table1), vshift_value_spinbutton, 1, 2, 4, 5,
1013                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1014                     (GtkAttachOptions) (0), 0, 0);
1015   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_value_spinbutton), GTK_UPDATE_IF_VALID);
1016   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vshift_value_spinbutton), TRUE);
1017   gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), FALSE );
1018
1019   hscale_value_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1020   hscale_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_value_spinbutton_adj), 1, 4);
1021   gtk_widget_show (hscale_value_spinbutton);
1022   gtk_table_attach (GTK_TABLE (table1), hscale_value_spinbutton, 1, 2, 6, 7,
1023                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1024                     (GtkAttachOptions) (0), 0, 0);
1025   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_value_spinbutton), GTK_UPDATE_IF_VALID);
1026   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hscale_value_spinbutton), TRUE);
1027   gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), FALSE );
1028
1029   vscale_value_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1030   vscale_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_value_spinbutton_adj), 1, 4);
1031   gtk_widget_show (vscale_value_spinbutton);
1032   gtk_table_attach (GTK_TABLE (table1), vscale_value_spinbutton, 1, 2, 8, 9,
1033                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1034                     (GtkAttachOptions) (0), 0, 0);
1035   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_value_spinbutton), GTK_UPDATE_IF_VALID);
1036   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vscale_value_spinbutton), TRUE);
1037   gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), FALSE );
1038
1039   rotate_value_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
1040   rotate_value_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_value_spinbutton_adj), 1, 0);
1041   gtk_widget_show (rotate_value_spinbutton);
1042   gtk_table_attach (GTK_TABLE (table1), rotate_value_spinbutton, 1, 2, 10, 11,
1043                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1044                     (GtkAttachOptions) (0), 0, 0);
1045   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_value_spinbutton), GTK_UPDATE_IF_VALID);
1046   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (rotate_value_spinbutton), TRUE);
1047   gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), FALSE );
1048
1049   // Offset Spins
1050   hshift_offset_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1051   hshift_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_offset_spinbutton_adj), 0, 2);
1052   gtk_widget_show (hshift_offset_spinbutton);
1053   gtk_table_attach (GTK_TABLE (table1), hshift_offset_spinbutton, 2, 3, 2, 3,
1054                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1055                     (GtkAttachOptions) (0), 4, 0);
1056   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (hshift_offset_spinbutton), TRUE);
1057   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_offset_spinbutton), GTK_UPDATE_IF_VALID);
1058   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hshift_offset_spinbutton), TRUE);
1059
1060   vshift_offset_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1061   vshift_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_offset_spinbutton_adj), 0, 2);
1062   gtk_widget_show (vshift_offset_spinbutton);
1063   gtk_table_attach (GTK_TABLE (table1), vshift_offset_spinbutton, 2, 3, 4, 5,
1064                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1065                     (GtkAttachOptions) (0), 4, 0);
1066   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (vshift_offset_spinbutton), TRUE);
1067   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_offset_spinbutton), GTK_UPDATE_IF_VALID);
1068   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vshift_offset_spinbutton), TRUE);
1069
1070   hscale_offset_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1071   hscale_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_offset_spinbutton_adj), 0, 4);
1072   gtk_widget_show (hscale_offset_spinbutton);
1073   gtk_table_attach (GTK_TABLE (table1), hscale_offset_spinbutton, 2, 3, 6, 7,
1074                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1075                     (GtkAttachOptions) (0), 4, 0);
1076   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (hscale_offset_spinbutton), TRUE);
1077   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_offset_spinbutton), GTK_UPDATE_IF_VALID);
1078   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (hscale_offset_spinbutton), TRUE);
1079
1080   vscale_offset_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1081   vscale_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_offset_spinbutton_adj), 0, 4);
1082   gtk_widget_show (vscale_offset_spinbutton);
1083   gtk_table_attach (GTK_TABLE (table1), vscale_offset_spinbutton, 2, 3, 8, 9,
1084                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1085                     (GtkAttachOptions) (0), 4, 0);
1086   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (vscale_offset_spinbutton), TRUE);
1087   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_offset_spinbutton), GTK_UPDATE_IF_VALID);
1088   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (vscale_offset_spinbutton), TRUE);
1089
1090   rotate_offset_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
1091   rotate_offset_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_offset_spinbutton_adj), 0, 2);
1092   gtk_widget_show (rotate_offset_spinbutton);
1093   gtk_table_attach (GTK_TABLE (table1), rotate_offset_spinbutton, 2, 3, 10, 11,
1094                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1095                     (GtkAttachOptions) (0), 4, 0);
1096   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (rotate_offset_spinbutton), TRUE);
1097   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_offset_spinbutton), GTK_UPDATE_IF_VALID);
1098   gtk_spin_button_set_wrap (GTK_SPIN_BUTTON (rotate_offset_spinbutton), TRUE);
1099
1100     // Step Spins
1101   hshift_step_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1102   hshift_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hshift_step_spinbutton_adj), 1, 2);
1103   gtk_widget_show (hshift_step_spinbutton);
1104   gtk_table_attach (GTK_TABLE (table1), hshift_step_spinbutton, 3, 4, 2, 3,
1105                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1106                     (GtkAttachOptions) (0), 0, 0);
1107   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hshift_step_spinbutton), GTK_UPDATE_IF_VALID);
1108
1109   vshift_step_spinbutton_adj = gtk_adjustment_new (0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0);
1110   vshift_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vshift_step_spinbutton_adj), 1, 2);
1111   gtk_widget_show (vshift_step_spinbutton);
1112   gtk_table_attach (GTK_TABLE (table1), vshift_step_spinbutton, 3, 4, 4, 5,
1113                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1114                     (GtkAttachOptions) (0), 0, 0);
1115   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vshift_step_spinbutton), GTK_UPDATE_IF_VALID);
1116
1117   hscale_step_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1118   hscale_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (hscale_step_spinbutton_adj), 1, 4);
1119   gtk_widget_show (hscale_step_spinbutton);
1120   gtk_table_attach (GTK_TABLE (table1), hscale_step_spinbutton, 3, 4, 6, 7,
1121                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1122                     (GtkAttachOptions) (0), 0, 0);
1123   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (hscale_step_spinbutton), GTK_UPDATE_IF_VALID);
1124
1125   vscale_step_spinbutton_adj = gtk_adjustment_new (0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0);
1126   vscale_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (vscale_step_spinbutton_adj), 1, 4);
1127   gtk_widget_show (vscale_step_spinbutton);
1128   gtk_table_attach (GTK_TABLE (table1), vscale_step_spinbutton, 3, 4, 8, 9,
1129                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1130                     (GtkAttachOptions) (0), 0, 0);
1131   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (vscale_step_spinbutton), GTK_UPDATE_IF_VALID);
1132
1133   rotate_step_spinbutton_adj = gtk_adjustment_new (0.0, -360.0, 360.0, 1.0, 10.0, 10.0);
1134   rotate_step_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (rotate_step_spinbutton_adj), 1, 2);
1135   gtk_widget_show (rotate_step_spinbutton);
1136   gtk_table_attach (GTK_TABLE (table1), rotate_step_spinbutton, 3, 4, 10, 11,
1137                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1138                     (GtkAttachOptions) (0), 0, 0);
1139   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (rotate_step_spinbutton), GTK_UPDATE_IF_VALID);
1140
1141   eventbox = gtk_event_box_new ();
1142   gtk_widget_show (eventbox);
1143   gtk_table_attach (GTK_TABLE (table1), eventbox, 2, 3, 12, 13,
1144                     (GtkAttachOptions) (0),
1145                     (GtkAttachOptions) (0), 0, 0);
1146
1147   eventbox = gtk_event_box_new ();
1148   gtk_widget_show (eventbox);
1149   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 12, 13,
1150                     (GtkAttachOptions) (0),
1151                     (GtkAttachOptions) (0), 0, 0);
1152
1153   eventbox = gtk_event_box_new ();
1154   gtk_widget_show (eventbox);
1155   gtk_table_attach (GTK_TABLE (table1), eventbox, 0, 1, 0, 1,
1156                     (GtkAttachOptions) (0),
1157                     (GtkAttachOptions) (0), 0, 0);
1158
1159   viewport7 = gtk_viewport_new (NULL, NULL);
1160   gtk_widget_show (viewport7);
1161   gtk_box_pack_start (GTK_BOX (vbox7), viewport7, FALSE, TRUE, 0);
1162   gtk_container_set_border_width (GTK_CONTAINER (viewport7), 2);
1163   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport7), GTK_SHADOW_ETCHED_IN);
1164
1165   table4 = gtk_table_new (4, 7, FALSE);
1166   gtk_widget_show (table4);
1167   gtk_container_add (GTK_CONTAINER (viewport7), table4);
1168
1169   viewport5 = gtk_viewport_new (NULL, NULL);
1170   gtk_widget_show (viewport5);
1171   gtk_table_attach (GTK_TABLE (table4), viewport5, 1, 7, 0, 4,
1172                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1173                     (GtkAttachOptions) (0), 0, 0);
1174   gtk_container_set_border_width (GTK_CONTAINER (viewport5), 6);
1175   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport5), GTK_SHADOW_ETCHED_OUT);
1176
1177   table5 = gtk_table_new (2, 3, FALSE);
1178   gtk_widget_show (table5);
1179   gtk_container_add (GTK_CONTAINER (viewport5), table5);
1180   gtk_container_set_border_width (GTK_CONTAINER (table5), 5);
1181   gtk_table_set_col_spacings (GTK_TABLE (table5), 2);
1182
1183   label = gtk_label_new ("Height");
1184   gtk_widget_show (label);
1185   gtk_table_attach (GTK_TABLE (table5), label, 2, 3, 0, 1,
1186                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1187                     (GtkAttachOptions) (GTK_FILL), 0, 0);
1188   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1189   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
1190
1191   label = gtk_label_new ("Width");
1192   gtk_widget_show (label);
1193   gtk_table_attach (GTK_TABLE (table5), label, 1, 2, 0, 1,
1194                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1195                     (GtkAttachOptions) (GTK_FILL), 0, 0);
1196   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1197   gtk_misc_set_alignment (GTK_MISC (label), 0.5, 1);
1198
1199   fit_width_spinbutton_adj = gtk_adjustment_new (1, 1, 32, 1, 10, 10);
1200   fit_width_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fit_width_spinbutton_adj), 1, 0);
1201   gtk_widget_show (fit_width_spinbutton);
1202   gtk_table_attach (GTK_TABLE (table5), fit_width_spinbutton, 1, 2, 1, 2,
1203                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1204                     (GtkAttachOptions) (GTK_FILL), 0, 0);
1205   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fit_width_spinbutton), TRUE);
1206   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (fit_width_spinbutton), GTK_UPDATE_IF_VALID);
1207
1208   fit_height_spinbutton_adj = gtk_adjustment_new (1, 1, 32, 1, 10, 10);
1209   fit_height_spinbutton = gtk_spin_button_new (GTK_ADJUSTMENT (fit_height_spinbutton_adj), 1, 0);
1210   gtk_widget_show (fit_height_spinbutton);
1211   gtk_table_attach (GTK_TABLE (table5), fit_height_spinbutton, 2, 3, 1, 2,
1212                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1213                     (GtkAttachOptions) (GTK_FILL), 3, 0);
1214   gtk_spin_button_set_numeric (GTK_SPIN_BUTTON (fit_height_spinbutton), TRUE);
1215   gtk_spin_button_set_update_policy (GTK_SPIN_BUTTON (fit_height_spinbutton), GTK_UPDATE_IF_VALID);
1216
1217   eventbox = gtk_event_box_new ();
1218   gtk_widget_show (eventbox);
1219   gtk_table_attach (GTK_TABLE (table5), eventbox, 0, 1, 0, 1,
1220                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1221                     (GtkAttachOptions) (GTK_FILL), 0, 0);
1222
1223   eventbox = gtk_event_box_new ();
1224   gtk_widget_show (eventbox);
1225   gtk_table_attach (GTK_TABLE (table5), eventbox, 0, 1, 1, 2,
1226                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1227                     (GtkAttachOptions) (GTK_FILL), 4, 0);
1228
1229   fit_button = gtk_button_new_with_mnemonic ("    Fit    ");
1230   gtk_widget_show (fit_button);
1231   gtk_container_add (GTK_CONTAINER (eventbox), fit_button);
1232
1233   viewport6 = gtk_viewport_new (NULL, NULL);
1234   gtk_widget_show (viewport6);
1235   gtk_table_attach (GTK_TABLE (table4), viewport6, 0, 1, 0, 4,
1236                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1237                     (GtkAttachOptions) (0), 0, 0);
1238   gtk_container_set_border_width (GTK_CONTAINER (viewport6), 4);
1239   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport6), GTK_SHADOW_NONE);
1240
1241   table7 = gtk_table_new (2, 1, FALSE);
1242   gtk_widget_show (table7);
1243   gtk_container_add (GTK_CONTAINER (viewport6), table7);
1244
1245   eventbox = gtk_event_box_new ();
1246   gtk_widget_show (eventbox);
1247   gtk_table_attach (GTK_TABLE (table7), eventbox, 0, 1, 0, 2,
1248                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL),
1249                     (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), 0, 0);
1250
1251   axial_button = gtk_button_new_with_mnemonic ("Axial");
1252   gtk_widget_show (axial_button);
1253   gtk_container_add (GTK_CONTAINER (eventbox), axial_button);
1254   gtk_widget_set_size_request (axial_button, 56, 29);
1255   gtk_container_set_border_width (GTK_CONTAINER (axial_button), 4);
1256
1257   // Fit in Flags sub-dialog
1258   Create_Quake2FlagsDialog(vbox7);
1259
1260   viewport10 = gtk_viewport_new (NULL, NULL);
1261   gtk_widget_show (viewport10);
1262   gtk_box_pack_start (GTK_BOX (vbox7), viewport10, FALSE, TRUE, 0);
1263   gtk_container_set_border_width (GTK_CONTAINER (viewport10), 2);
1264   gtk_viewport_set_shadow_type (GTK_VIEWPORT (viewport10), GTK_SHADOW_ETCHED_IN);
1265
1266   hbuttonbox1 = gtk_hbutton_box_new ();
1267   gtk_widget_show (hbuttonbox1);
1268   gtk_container_add (GTK_CONTAINER (viewport10), hbuttonbox1);
1269   gtk_container_set_border_width (GTK_CONTAINER (hbuttonbox1), 4);
1270   gtk_button_box_set_layout (GTK_BUTTON_BOX (hbuttonbox1), GTK_BUTTONBOX_SPREAD);
1271
1272   done_button = gtk_button_new ();
1273   gtk_widget_show (done_button);
1274   gtk_container_add (GTK_CONTAINER (hbuttonbox1), done_button);
1275   GTK_WIDGET_SET_FLAGS (done_button, GTK_CAN_DEFAULT);
1276
1277   alignment1 = gtk_alignment_new (0.5, 0.5, 0, 0);
1278   gtk_widget_show (alignment1);
1279   gtk_container_add (GTK_CONTAINER (done_button), alignment1);
1280
1281   hbox2 = gtk_hbox_new (FALSE, 2);
1282   gtk_widget_show (hbox2);
1283   gtk_container_add (GTK_CONTAINER (alignment1), hbox2);
1284
1285   image1 = gtk_image_new_from_stock ("gtk-yes", GTK_ICON_SIZE_BUTTON);
1286   gtk_widget_show (image1);
1287   gtk_box_pack_start (GTK_BOX (hbox2), image1, FALSE, FALSE, 0);
1288
1289   label = gtk_label_new_with_mnemonic ("Done");
1290   gtk_widget_show (label);
1291   gtk_box_pack_start (GTK_BOX (hbox2), label, FALSE, FALSE, 0);
1292   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1293
1294   apply_button = gtk_button_new ();
1295   gtk_widget_show (apply_button);
1296   gtk_container_add (GTK_CONTAINER (hbuttonbox1), apply_button);
1297   GTK_WIDGET_SET_FLAGS (apply_button, GTK_CAN_DEFAULT);
1298
1299   alignment3 = gtk_alignment_new (0.5, 0.5, 0, 0);
1300   gtk_widget_show (alignment3);
1301   gtk_container_add (GTK_CONTAINER (apply_button), alignment3);
1302
1303   hbox4 = gtk_hbox_new (FALSE, 2);
1304   gtk_widget_show (hbox4);
1305   gtk_container_add (GTK_CONTAINER (alignment3), hbox4);
1306
1307   image3 = gtk_image_new_from_stock ("gtk-apply", GTK_ICON_SIZE_BUTTON);
1308   gtk_widget_show (image3);
1309   gtk_box_pack_start (GTK_BOX (hbox4), image3, FALSE, FALSE, 0);
1310
1311   label = gtk_label_new_with_mnemonic ("Apply");
1312   gtk_widget_show (label);
1313   gtk_box_pack_start (GTK_BOX (hbox4), label, FALSE, FALSE, 0);
1314   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1315
1316   cancel_button = gtk_button_new ();
1317   gtk_widget_show (cancel_button);
1318   gtk_container_add (GTK_CONTAINER (hbuttonbox1), cancel_button);
1319   GTK_WIDGET_SET_FLAGS (cancel_button, GTK_CAN_DEFAULT);
1320
1321   alignment2 = gtk_alignment_new (0.5, 0.5, 0, 0);
1322   gtk_widget_show (alignment2);
1323   gtk_container_add (GTK_CONTAINER (cancel_button), alignment2);
1324
1325   hbox3 = gtk_hbox_new (FALSE, 2);
1326   gtk_widget_show (hbox3);
1327   gtk_container_add (GTK_CONTAINER (alignment2), hbox3);
1328
1329   image2 = gtk_image_new_from_stock ("gtk-no", GTK_ICON_SIZE_BUTTON);
1330   gtk_widget_show (image2);
1331   gtk_box_pack_start (GTK_BOX (hbox3), image2, FALSE, FALSE, 0);
1332
1333   label = gtk_label_new_with_mnemonic ("Cancel");
1334   gtk_widget_show (label);
1335   gtk_box_pack_start (GTK_BOX (hbox3), label, FALSE, FALSE, 0);
1336   gtk_label_set_justify (GTK_LABEL (label), GTK_JUSTIFY_LEFT);
1337
1338
1339   g_signal_connect ( (gpointer) SurfaceInspector,
1340                       "delete_event",
1341                       G_CALLBACK (delete_event_callback),
1342                       NULL );
1343   g_signal_connect ((gpointer) SurfaceInspector, "destroy",
1344                     G_CALLBACK (gtk_widget_destroy),
1345                     NULL);
1346
1347   g_signal_connect ((gpointer) texture_combo_entry, "key_press_event",
1348                     G_CALLBACK (on_texture_combo_entry_key_press_event),
1349                     NULL);
1350   g_signal_connect ((gpointer) texture_combo_entry, "activate",
1351                     G_CALLBACK (on_texture_combo_entry_activate),
1352                     NULL);
1353
1354
1355   g_signal_connect ((gpointer) hshift_offset_spinbutton, "value_changed",
1356                     G_CALLBACK (on_hshift_offset_spinbutton_value_changed),
1357                     NULL);
1358   g_signal_connect ((gpointer) vshift_offset_spinbutton, "value_changed",
1359                     G_CALLBACK (on_vshift_offset_spinbutton_value_changed),
1360                     NULL);
1361   g_signal_connect ((gpointer) hscale_offset_spinbutton, "value_changed",
1362                     G_CALLBACK (on_hscale_offset_spinbutton_value_changed),
1363                     NULL);
1364   g_signal_connect ((gpointer) vscale_offset_spinbutton, "value_changed",
1365                     G_CALLBACK (on_vscale_offset_spinbutton_value_changed),
1366                     NULL);
1367   g_signal_connect ((gpointer) rotate_offset_spinbutton, "value_changed",
1368                     G_CALLBACK (on_rotate_offset_spinbutton_value_changed),
1369                     NULL);
1370
1371   g_signal_connect ((gpointer) hshift_value_spinbutton, "value_changed",
1372                     G_CALLBACK (on_hshift_value_spinbutton_value_changed),
1373                     NULL);
1374   g_signal_connect ((gpointer) vshift_value_spinbutton, "value_changed",
1375                     G_CALLBACK (on_vshift_value_spinbutton_value_changed),
1376                     NULL);
1377   g_signal_connect ((gpointer) hscale_value_spinbutton, "value_changed",
1378                     G_CALLBACK (on_hscale_value_spinbutton_value_changed),
1379                     NULL);
1380   g_signal_connect ((gpointer) vscale_value_spinbutton, "value_changed",
1381                     G_CALLBACK (on_vscale_value_spinbutton_value_changed),
1382                     NULL);
1383   g_signal_connect ((gpointer) rotate_value_spinbutton, "value_changed",
1384                     G_CALLBACK (on_rotate_value_spinbutton_value_changed),
1385                     NULL);
1386
1387   g_signal_connect ((gpointer) hshift_step_spinbutton, "value_changed",
1388                     G_CALLBACK (on_hshift_step_spinbutton_value_changed),
1389                     NULL);
1390   g_signal_connect ((gpointer) vshift_step_spinbutton, "value_changed",
1391                     G_CALLBACK (on_vshift_step_spinbutton_value_changed),
1392                     NULL);
1393   g_signal_connect ((gpointer) hscale_step_spinbutton, "value_changed",
1394                     G_CALLBACK (on_hscale_step_spinbutton_value_changed),
1395                     NULL);
1396   g_signal_connect ((gpointer) vscale_step_spinbutton, "value_changed",
1397                     G_CALLBACK (on_vscale_step_spinbutton_value_changed),
1398                     NULL);
1399   g_signal_connect ((gpointer) rotate_step_spinbutton, "value_changed",
1400                     G_CALLBACK (on_rotate_step_spinbutton_value_changed),
1401                     NULL);
1402
1403   g_signal_connect ((gpointer) match_grid_button, "clicked",
1404                     G_CALLBACK (on_match_grid_button_clicked),
1405                     NULL);
1406   g_signal_connect ((gpointer) lock_valuechange_togglebutton, "toggled",
1407                     G_CALLBACK (on_lock_valuechange_togglebutton_toggled),
1408                     NULL);
1409
1410   g_signal_connect ((gpointer) fit_width_spinbutton, "value_changed",
1411                     G_CALLBACK (on_fit_width_spinbutton_value_changed),
1412                     NULL);
1413   g_signal_connect ((gpointer) fit_height_spinbutton, "value_changed",
1414                     G_CALLBACK (on_fit_height_spinbutton_value_changed),
1415                     NULL);
1416   g_signal_connect ((gpointer) fit_button, "clicked",
1417                     G_CALLBACK (on_fit_button_clicked),
1418                     NULL);
1419
1420   g_signal_connect ((gpointer) axial_button, "clicked",
1421                     G_CALLBACK (on_axial_button_clicked),
1422                     NULL);
1423
1424   g_signal_connect ((gpointer) done_button, "clicked",
1425                     G_CALLBACK (on_done_button_clicked),
1426                     NULL);
1427   g_signal_connect ((gpointer) apply_button, "clicked",
1428                     G_CALLBACK (on_apply_button_clicked),
1429                     NULL);
1430   g_signal_connect ((gpointer) cancel_button, "clicked",
1431                     G_CALLBACK (on_cancel_button_clicked),
1432                     NULL);
1433
1434
1435   return SurfaceInspector;
1436 }
1437
1438
1439 // Texture Combo
1440 gboolean on_texture_combo_entry_key_press_event (GtkWidget *widget, GdkEventKey *event,
1441                                                  gpointer user_data)
1442 {
1443   // Have Tab activate selection as well as Return
1444   if (event->keyval == GDK_Tab)
1445     g_signal_emit_by_name ( texture_combo_entry, "activate" );
1446
1447   return FALSE;
1448 }
1449
1450 void on_texture_combo_entry_activate (GtkEntry *entry, gpointer user_data)
1451 {
1452   texdef_t* tmp_texdef;
1453   texdef_t* tmp_orig_texdef;
1454   texdef_to_face_t* temp_texdef_face_list;
1455   char text[128] = { 0 };
1456
1457   if (!texdef_face_list_empty() && g_bListenChanged)
1458   {
1459     // activate only on entry change
1460     strcpy( text, gtk_entry_get_text(entry));
1461     if ( strcmp( old_texture_entry, text ))
1462     {
1463       // Check for spaces in shader name
1464       if (text[0] <= ' ' || strchr(text, ' '))
1465         Sys_FPrintf(SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text);
1466       else
1467       {
1468         for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1469         {
1470           tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1471           tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1472           strcpy( old_texture_entry, text );
1473           tmp_texdef->SetName( text );
1474         }
1475         GetTexMods();
1476       }
1477     }
1478   }
1479 }
1480
1481 // Offset Spins
1482 static void on_hshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1483 {
1484   texdef_t* tmp_texdef;
1485   texdef_t* tmp_orig_texdef;
1486   texdef_to_face_t* temp_texdef_face_list;
1487
1488   texdef_offset.shift[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_offset_spinbutton) );
1489
1490   if (!texdef_face_list_empty() && g_bListenChanged)
1491   {
1492     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1493     {
1494       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1495       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1496       if (is_HShift_conflicting)
1497         tmp_texdef->shift[0] = tmp_orig_texdef->shift[0] + texdef_offset.shift[0];
1498       else
1499         tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0];
1500     }
1501     GetTexMods();
1502   }
1503 }
1504
1505 static void on_vshift_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1506 {
1507   texdef_t* tmp_texdef;
1508   texdef_t* tmp_orig_texdef;
1509   texdef_to_face_t* temp_texdef_face_list;
1510
1511   texdef_offset.shift[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_offset_spinbutton) );
1512
1513   if (!texdef_face_list_empty() && g_bListenChanged)
1514   {
1515     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1516     {
1517       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1518       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1519       if (is_VShift_conflicting)
1520         tmp_texdef->shift[1] = tmp_orig_texdef->shift[1] + texdef_offset.shift[1];
1521       else
1522         tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1];
1523     }
1524     GetTexMods();
1525   }
1526
1527 }
1528
1529 static void on_hscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1530 {
1531   texdef_t* tmp_texdef;
1532   texdef_t* tmp_orig_texdef;
1533   texdef_to_face_t* temp_texdef_face_list;
1534
1535   texdef_offset.scale[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_offset_spinbutton) );
1536
1537   if (!texdef_face_list_empty() && g_bListenChanged)
1538   {
1539     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1540     {
1541       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1542       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1543       if (is_HScale_conflicting)
1544         tmp_texdef->scale[0] = tmp_orig_texdef->scale[0] + texdef_offset.scale[0];
1545       else
1546         tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0];
1547     }
1548     GetTexMods();
1549   }
1550
1551
1552 }
1553
1554 static void on_vscale_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1555 {
1556   texdef_t* tmp_texdef;
1557   texdef_t* tmp_orig_texdef;
1558   texdef_to_face_t* temp_texdef_face_list;
1559
1560   texdef_offset.scale[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_offset_spinbutton) );
1561
1562   if (!texdef_face_list_empty() && g_bListenChanged)
1563   {
1564     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1565     {
1566       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1567       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1568       if (is_VScale_conflicting)
1569         tmp_texdef->scale[1] = tmp_orig_texdef->scale[1] + texdef_offset.scale[1];
1570       else
1571         tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1];
1572     }
1573     GetTexMods();
1574   }
1575
1576 }
1577
1578 static void on_rotate_offset_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1579 {
1580   texdef_t* tmp_texdef;
1581   texdef_t* tmp_orig_texdef;
1582   texdef_to_face_t* temp_texdef_face_list;
1583
1584   texdef_offset.rotate = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_offset_spinbutton) );
1585
1586   if (!texdef_face_list_empty() && g_bListenChanged)
1587   {
1588     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1589     {
1590       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1591       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1592       if (is_Rotate_conflicting)
1593         tmp_texdef->rotate = tmp_orig_texdef->rotate + texdef_offset.rotate;
1594       else
1595         tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate;
1596     }
1597     GetTexMods();
1598   }
1599
1600 }
1601
1602
1603 // Match Grid
1604 static void on_match_grid_button_clicked (GtkButton *button, gpointer user_data)
1605 {
1606   float hscale, vscale;
1607
1608   if( !strcmp(gtk_entry_get_text (GTK_ENTRY (hscale_value_spinbutton)), "") )
1609     hscale = 0.0;
1610   else
1611     hscale = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_value_spinbutton) );
1612
1613   if( !strcmp( gtk_entry_get_text (GTK_ENTRY (vscale_value_spinbutton)), "") )
1614     vscale = 0.0;
1615   else
1616     vscale = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_value_spinbutton) );
1617   DoSnapTToGrid (hscale, vscale);
1618 }
1619
1620
1621 // Lock out changes to Value
1622 static void on_lock_valuechange_togglebutton_toggled (GtkToggleButton *togglebutton, gpointer user_data)
1623 {
1624   bool is_Locked;
1625
1626   is_Locked = gtk_toggle_button_get_active(GTK_TOGGLE_BUTTON(lock_valuechange_togglebutton));
1627
1628   gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), is_Locked );
1629   gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), is_Locked );
1630   gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), is_Locked );
1631   gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), is_Locked );
1632   gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), is_Locked );
1633 }
1634
1635
1636 // Value Spins
1637 static void on_hshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1638 {
1639   texdef_t* tmp_texdef;
1640   texdef_t* tmp_orig_texdef;
1641   texdef_to_face_t* temp_texdef_face_list;
1642
1643   texdef_SI_values.shift[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_value_spinbutton) );
1644
1645   if (!texdef_face_list_empty() && g_bListenChanged)
1646   {
1647     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1648     {
1649       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1650       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1651       tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0];
1652       is_HShift_conflicting = FALSE;
1653     }
1654     GetTexMods();
1655   }
1656 }
1657
1658 static void on_vshift_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1659 {
1660   texdef_t* tmp_texdef;
1661   texdef_t* tmp_orig_texdef;
1662   texdef_to_face_t* temp_texdef_face_list;
1663
1664   texdef_SI_values.shift[1]  = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_value_spinbutton) );
1665
1666   if (!texdef_face_list_empty() && g_bListenChanged)
1667   {
1668     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1669     {
1670       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1671       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1672       tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1];
1673       is_VShift_conflicting = FALSE;
1674     }
1675     GetTexMods();
1676   }
1677 }
1678
1679 static void on_hscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1680 {
1681   texdef_t* tmp_texdef;
1682   texdef_t* tmp_orig_texdef;
1683   texdef_to_face_t* temp_texdef_face_list;
1684
1685   texdef_SI_values.scale[0] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_value_spinbutton) );
1686
1687   if (!texdef_face_list_empty() && g_bListenChanged)
1688   {
1689     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1690     {
1691       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1692       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1693       tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0];
1694       is_HScale_conflicting = FALSE;
1695     }
1696     GetTexMods();
1697   }
1698 }
1699
1700 static void on_vscale_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1701 {
1702   texdef_t* tmp_texdef;
1703   texdef_t* tmp_orig_texdef;
1704   texdef_to_face_t* temp_texdef_face_list;
1705
1706   texdef_SI_values.scale[1] = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_value_spinbutton) );
1707
1708   if (!texdef_face_list_empty() && g_bListenChanged)
1709   {
1710     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1711     {
1712       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1713       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1714       tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1];
1715       is_VScale_conflicting = FALSE;
1716     }
1717     GetTexMods();
1718   }
1719 }
1720
1721 static void on_rotate_value_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1722 {
1723   texdef_t* tmp_texdef;
1724   texdef_t* tmp_orig_texdef;
1725   texdef_to_face_t* temp_texdef_face_list;
1726
1727   texdef_SI_values.rotate = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_value_spinbutton) );
1728
1729   if (!texdef_face_list_empty() && g_bListenChanged)
1730   {
1731     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1732     {
1733       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1734       tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef;
1735       tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate;
1736       is_Rotate_conflicting = FALSE;
1737     }
1738     GetTexMods();
1739   }
1740 }
1741
1742
1743 // Step Spins
1744 static void on_hshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1745 {
1746   gfloat val;
1747   GtkAdjustment * adjust;
1748
1749   if (!g_bListenChanged)
1750     return;
1751
1752   l_pIncrement = Get_SI_Inc();
1753
1754 #ifdef DBG_SI
1755   Sys_Printf("OnIncrementChanged HShift\n");
1756 #endif
1757
1758   val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hshift_step_spinbutton) ) ;
1759   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hshift_offset_spinbutton ));
1760   adjust->step_increment = val;
1761   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hshift_value_spinbutton ));
1762   adjust->step_increment = val;
1763   l_pIncrement->shift[0] = val;
1764 }
1765
1766 static void on_vshift_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1767 {
1768   gfloat val;
1769   GtkAdjustment * adjust;
1770
1771   if (!g_bListenChanged)
1772     return;
1773
1774   l_pIncrement = Get_SI_Inc();
1775
1776 #ifdef DBG_SI
1777   Sys_Printf("OnIncrementChanged VShift\n");
1778 #endif
1779
1780   val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vshift_step_spinbutton) ) ;
1781   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vshift_offset_spinbutton ));
1782   adjust->step_increment = val;
1783   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vshift_value_spinbutton ));
1784   adjust->step_increment = val;
1785   l_pIncrement->shift[1] = val;
1786 }
1787
1788 static void on_hscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1789 {
1790   gfloat val;
1791   GtkAdjustment * adjust;
1792
1793   if (!g_bListenChanged)
1794     return;
1795
1796   l_pIncrement = Get_SI_Inc();
1797
1798 #ifdef DBG_SI
1799   Sys_Printf("OnIncrementChanged HShift\n");
1800 #endif
1801
1802   val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(hscale_step_spinbutton) ) ;
1803   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hscale_offset_spinbutton ));
1804   adjust->step_increment = val;
1805   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( hscale_value_spinbutton ));
1806   adjust->step_increment = val;
1807   l_pIncrement->scale[0] = val;
1808 }
1809
1810 static void on_vscale_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1811 {
1812   gfloat val;
1813   GtkAdjustment * adjust;
1814
1815   if (!g_bListenChanged)
1816     return;
1817
1818   l_pIncrement = Get_SI_Inc();
1819
1820 #ifdef DBG_SI
1821   Sys_Printf("OnIncrementChanged HShift\n");
1822 #endif
1823
1824   val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(vscale_step_spinbutton) ) ;
1825   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vscale_offset_spinbutton ));
1826   adjust->step_increment = val;
1827   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( vscale_value_spinbutton ));
1828   adjust->step_increment = val;
1829   l_pIncrement->scale[1] = val;
1830 }
1831
1832 static void on_rotate_step_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1833 {
1834   gfloat val;
1835   GtkAdjustment * adjust;
1836
1837   if (!g_bListenChanged)
1838     return;
1839
1840   l_pIncrement = Get_SI_Inc();
1841
1842 #ifdef DBG_SI
1843   Sys_Printf("OnIncrementChanged HShift\n");
1844 #endif
1845
1846   val = gtk_spin_button_get_value ( GTK_SPIN_BUTTON(rotate_step_spinbutton) ) ;
1847   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( rotate_offset_spinbutton ));
1848   adjust->step_increment = val;
1849   adjust = gtk_spin_button_get_adjustment (GTK_SPIN_BUTTON ( rotate_value_spinbutton ));
1850   adjust->step_increment = val;
1851   l_pIncrement->rotate = val;
1852 }
1853
1854
1855 // Fit Texture
1856 static void on_fit_width_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1857 {
1858   m_nWidth = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(fit_width_spinbutton) );
1859 }
1860
1861 static void on_fit_height_spinbutton_value_changed (GtkSpinButton *spinbutton, gpointer user_data)
1862 {
1863   m_nHeight = gtk_spin_button_get_value_as_int ( GTK_SPIN_BUTTON(fit_height_spinbutton) );
1864 }
1865
1866 static void on_fit_button_clicked (GtkButton *button, gpointer user_data)
1867 {
1868   FaceList_FitTexture(get_texdef_face_list(), m_nHeight, m_nWidth);
1869   Sys_UpdateWindows(W_ALL);
1870 }
1871
1872
1873 // Axial Button
1874 static void on_axial_button_clicked (GtkButton *button, gpointer user_data)
1875 {
1876   texdef_t* tmp_texdef;
1877 //  texdef_t* tmp_orig_texdef;
1878   texdef_to_face_t* temp_texdef_face_list;
1879
1880   if (!texdef_face_list_empty() && g_bListenChanged)
1881   {
1882     for (temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next)
1883     {
1884       tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef;
1885       tmp_texdef->shift[0] = 0.0;
1886       tmp_texdef->shift[1] = 0.0;
1887       tmp_texdef->scale[0] = 0.5;
1888       tmp_texdef->scale[1] = 0.5;
1889       tmp_texdef->rotate = 0.0;
1890     }
1891   }
1892
1893   SetTexdef_FaceList( get_texdef_face_list(), FALSE, TRUE );
1894   Sys_UpdateWindows(W_ALL);
1895 }
1896
1897
1898 // Action Buttons
1899 static void on_done_button_clicked (GtkButton *button, gpointer user_data)
1900 {
1901   if ( !texdef_face_list_empty() )
1902     GetTexMods(TRUE);
1903   HideDlg();
1904   Sys_UpdateWindows(W_ALL);
1905 }
1906
1907 static void on_apply_button_clicked (GtkButton *button, gpointer user_data)
1908 {
1909   if (!g_bListenChanged)
1910     return;
1911
1912   if ( !texdef_face_list_empty() )
1913   {
1914     GetTexMods (TRUE);
1915     Sys_UpdateWindows(W_CAMERA);
1916     GetTexdefInfo_from_Radiant();
1917     SetTexMods();
1918   }
1919 }
1920
1921 static void on_cancel_button_clicked (GtkButton *button, gpointer user_data)
1922 {
1923   texturewin = Texturewin ();
1924   texturewin->texdef = g_old_texdef;
1925   // cancel the last do if we own it
1926   if ( (m_nUndoId == Undo_GetUndoId()) && ( m_nUndoId != 0 ))
1927   {
1928 #ifdef DBG_SI
1929     Sys_Printf("OnCancel calling Undo_Undo\n");
1930 #endif
1931     g_bListenUpdate = false;
1932     Undo_Undo(TRUE);
1933     g_bListenUpdate = true;
1934     m_nUndoId = 0;
1935   }
1936   HideDlg();
1937 }
1938
1939