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