/* Copyright (C) 1999-2007 id Software, Inc. and contributors. For a list of contributors, see the accompanying CONTRIBUTORS file. This file is part of GtkRadiant. GtkRadiant is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. GtkRadiant is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GtkRadiant; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */ // // Surface Dialog Module // // // Nurail: Implemented to Module from the main Radiant Surface Dialog code // #include #include #include #include "surfdlg_plugin.h" #ifdef _DEBUG //#define DBG_SI 1 #endif #include "gtkr_vector.h" vector g_texdef_face_vector; inline texdef_to_face_t* get_texdef_face_list(){ return &( *g_texdef_face_vector.begin() ); } inline unsigned int texdef_face_list_empty(){ return g_texdef_face_vector.empty(); } inline unsigned int texdef_face_list_size(){ return g_texdef_face_vector.size(); } // For different faces having different values bool is_HShift_conflicting; bool is_VShift_conflicting; bool is_HScale_conflicting; bool is_VScale_conflicting; bool is_Rotate_conflicting; bool is_TextureName_conflicting; void ShowDlg(); void HideDlg(); void SetTexMods(); void GetTexMods( bool b_SetUndoPoint = FALSE ); void BuildDialog(); void FitAll(); void InitDefaultIncrement( texdef_t * ); void DoSnapTToGrid( float hscale, float vscale ); // called to perform a fitting from the outside (shortcut key) void SurfaceDialogFitAll(); // UFOAI Flags Functions void SetFlagButtons_UFOAI( texdef_to_face_t *texdef_face_list, bool b_isListEmpty ); void SetChangeInFlags_Face_UFOAI( texdef_to_face_t *texdef_face_list ); GtkWidget* Create_UFOAIFlagsDialog( GtkWidget* surfacedialog_widget ); // Dialog Data int m_nHeight; int m_nWidth; // 0 is invalid, otherwise it's the Id of the last 'do' we are responsible for int m_nUndoId; texturewin_t *texturewin; texdef_t *l_pIncrement; texdef_t texdef_offset; texdef_t texdef_SI_values; // For Texture Entry, activate only on entry change char old_texture_entry[128]; // the texdef to switch back to when the OnCancel is called texdef_t g_old_texdef; // when TRUE, this thing means the surface inspector is currently being displayed bool g_surfwin = FALSE; // turn on/off processing of the "changed" "value_changed" messages // (need to turn off when we are feeding data in) bool g_bListenChanged = true; // turn on/off listening of the update messages bool g_bListenUpdate = true; GtkWidget* create_SurfaceInspector( void ); GtkWidget *SurfaceInspector = NULL; GtkWidget *m_pWidget; GtkWidget *GetWidget() { return SurfaceInspector; } GtkWidget *Get_SI_Module_Widget() { return SurfaceInspector; } void SetWidget( GtkWidget *new_widget ) { m_pWidget = new_widget; } GtkWidget *GetDlgWidget( const char* name ) { return GTK_WIDGET( g_object_get_data( G_OBJECT( SurfaceInspector ), name ) ); } // Spins for FitTexture GtkWidget *spin_width; GtkWidget *spin_height; GtkWidget *texture_combo; GtkWidget *texture_combo_entry; GtkWidget *match_grid_button; GtkWidget *lock_valuechange_togglebutton; GtkObject *hshift_value_spinbutton_adj; GtkWidget *hshift_value_spinbutton; GtkObject *vshift_value_spinbutton_adj; GtkWidget *vshift_value_spinbutton; GtkObject *hscale_value_spinbutton_adj; GtkWidget *hscale_value_spinbutton; GtkObject *vscale_value_spinbutton_adj; GtkWidget *vscale_value_spinbutton; GtkObject *rotate_value_spinbutton_adj; GtkWidget *rotate_value_spinbutton; GtkObject *hshift_offset_spinbutton_adj; GtkWidget *hshift_offset_spinbutton; GtkObject *vshift_offset_spinbutton_adj; GtkWidget *vshift_offset_spinbutton; GtkObject *hscale_offset_spinbutton_adj; GtkWidget *hscale_offset_spinbutton; GtkObject *vscale_offset_spinbutton_adj; GtkWidget *vscale_offset_spinbutton; GtkObject *rotate_offset_spinbutton_adj; GtkWidget *rotate_offset_spinbutton; GtkObject *hshift_step_spinbutton_adj; GtkWidget *hshift_step_spinbutton; GtkObject *vshift_step_spinbutton_adj; GtkWidget *vshift_step_spinbutton; GtkObject *hscale_step_spinbutton_adj; GtkWidget *hscale_step_spinbutton; GtkObject *vscale_step_spinbutton_adj; GtkWidget *vscale_step_spinbutton; GtkObject *rotate_step_spinbutton_adj; GtkWidget *rotate_step_spinbutton; GtkObject *fit_width_spinbutton_adj; GtkWidget *fit_width_spinbutton; GtkObject *fit_height_spinbutton_adj; GtkWidget *fit_height_spinbutton; GtkWidget *fit_button; GtkWidget *axial_button; GtkWidget *done_button; GtkWidget *apply_button; GtkWidget *cancel_button; // Callbacks gboolean on_texture_combo_entry_key_press_event( GtkWidget *widget, GdkEventKey *event, gpointer user_data ); void on_texture_combo_entry_activate( GtkEntry *entry, gpointer user_data ); static void on_match_grid_button_clicked( GtkButton *button, gpointer user_data ); static void on_lock_valuechange_togglebutton_toggled( GtkToggleButton *togglebutton, gpointer user_data ); static void on_hshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_hscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_rotate_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_hshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_hscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_rotate_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_hshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_hscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_vscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_rotate_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_fit_width_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_fit_height_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); static void on_fit_button_clicked( GtkButton *button, gpointer user_data ); static void on_axial_button_clicked( GtkButton *button, gpointer user_data ); static void on_done_button_clicked( GtkButton *button, gpointer user_data ); static void on_apply_button_clicked( GtkButton *button, gpointer user_data ); static void on_cancel_button_clicked( GtkButton *button, gpointer user_data ); /* =================================================== SURFACE INSPECTOR =================================================== */ void IsFaceConflicting(){ texdef_t* tmp_texdef; texdef_to_face_t* temp_texdef_face_list; char buf[12]; char texture_name[128]; if ( texdef_face_list_empty() ) { gtk_entry_set_text( GTK_ENTRY( hshift_value_spinbutton ), "" ); gtk_entry_set_text( GTK_ENTRY( vshift_value_spinbutton ), "" ); gtk_entry_set_text( GTK_ENTRY( hscale_value_spinbutton ), "" ); gtk_entry_set_text( GTK_ENTRY( vscale_value_spinbutton ), "" ); gtk_entry_set_text( GTK_ENTRY( rotate_value_spinbutton ), "" ); gtk_entry_set_text( GTK_ENTRY( texture_combo_entry ), "" ); return; } g_bListenChanged = FALSE; tmp_texdef = &get_texdef_face_list()->texdef; strcpy( texture_name, tmp_texdef->GetName() ); texdef_SI_values.shift[0] = tmp_texdef->shift[0]; texdef_SI_values.shift[1] = tmp_texdef->shift[1]; texdef_SI_values.scale[0] = tmp_texdef->scale[0]; texdef_SI_values.scale[1] = tmp_texdef->scale[1]; texdef_SI_values.rotate = tmp_texdef->rotate; texdef_SI_values.SetName( texture_name ); is_HShift_conflicting = FALSE; is_VShift_conflicting = FALSE; is_HScale_conflicting = FALSE; is_VScale_conflicting = FALSE; is_Rotate_conflicting = FALSE; is_TextureName_conflicting = FALSE; if ( texdef_face_list_size() > 1 ) { temp_texdef_face_list = get_texdef_face_list()->next; for (; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = &temp_texdef_face_list->texdef; if ( texdef_SI_values.shift[0] != tmp_texdef->shift[0] ) { is_HShift_conflicting = TRUE; } if ( texdef_SI_values.shift[1] != tmp_texdef->shift[1] ) { is_VShift_conflicting = TRUE; } if ( texdef_SI_values.scale[0] != tmp_texdef->scale[0] ) { is_HScale_conflicting = TRUE; } if ( texdef_SI_values.scale[1] != tmp_texdef->scale[1] ) { is_VScale_conflicting = TRUE; } if ( texdef_SI_values.rotate != tmp_texdef->rotate ) { is_Rotate_conflicting = TRUE; } if ( strcmp( texture_name, tmp_texdef->GetName() ) ) { is_TextureName_conflicting = TRUE; } } } if ( is_HShift_conflicting ) { gtk_entry_set_text( GTK_ENTRY( hshift_value_spinbutton ), "" ); } else{ gtk_spin_button_set_value( GTK_SPIN_BUTTON( hshift_value_spinbutton ), texdef_SI_values.shift[0] ); } if ( is_VShift_conflicting ) { gtk_entry_set_text( GTK_ENTRY( vshift_value_spinbutton ), "" ); } else{ gtk_spin_button_set_value( GTK_SPIN_BUTTON( vshift_value_spinbutton ), texdef_SI_values.shift[1] ); } if ( is_HScale_conflicting ) { gtk_entry_set_text( GTK_ENTRY( hscale_value_spinbutton ), "" ); } else{ gtk_spin_button_set_value( GTK_SPIN_BUTTON( hscale_value_spinbutton ), texdef_SI_values.scale[0] ); } if ( is_VScale_conflicting ) { gtk_entry_set_text( GTK_ENTRY( vscale_value_spinbutton ), "" ); } else{ gtk_spin_button_set_value( GTK_SPIN_BUTTON( vscale_value_spinbutton ), texdef_SI_values.scale[1] ); } if ( is_Rotate_conflicting ) { gtk_entry_set_text( GTK_ENTRY( rotate_value_spinbutton ), "" ); } else{ gtk_spin_button_set_value( GTK_SPIN_BUTTON( rotate_value_spinbutton ), texdef_SI_values.rotate ); } g_bListenChanged = TRUE; } #define MAX_NUM_LIST_ITEMS 15 static void PopulateTextureComboList(){ texdef_t* tmp_texdef; texdef_to_face_t* temp_texdef_face_list; char blank[1]; GList *items = NULL; GList *tmp_item; int num_of_list_items = 0; blank[0] = 0; if ( texdef_face_list_empty() ) { items = g_list_append( items, (gpointer) blank ); // For Texture Entry, activate only on entry change strcpy( old_texture_entry, blank ); } else if ( !is_TextureName_conflicting ) { temp_texdef_face_list = get_texdef_face_list(); tmp_texdef = (texdef_t *) &get_texdef_face_list()->texdef; items = g_list_append( items, (gpointer) tmp_texdef->GetName() ); // For Texture Entry, activate only on entry change strcpy( old_texture_entry, tmp_texdef->GetName() ); } else { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; // Need to do a string compare, hence the custom search if ( !( g_list_find_custom( items, tmp_texdef->GetName(), (GCompareFunc) strcmp ) ) ) { items = g_list_append( items, (gpointer) tmp_texdef->GetName() ); num_of_list_items++; } // Make sure the combo list isn't too long if ( num_of_list_items >= MAX_NUM_LIST_ITEMS ) { break; } } // If this isn't added last (to the top of the list), g_list_find freaks. items = g_list_prepend( items, (gpointer) blank ); // For Texture Entry, activate only on entry change strcpy( old_texture_entry, blank ); } gtk_combo_set_popdown_strings( GTK_COMBO( texture_combo ), items ); g_list_free( items ); } static void ZeroOffsetValues(){ texdef_offset.shift[0] = 0.0; texdef_offset.shift[1] = 0.0; texdef_offset.scale[0] = 0.0; texdef_offset.scale[1] = 0.0; texdef_offset.rotate = 0.0; } static void GetTexdefInfo_from_Radiant(){ g_texdef_face_vector.clear(); unsigned int count = GetSelectedFaceCountfromBrushes(); if ( count == 0 ) { count = GetSelectedFaceCount(); } g_texdef_face_vector.resize( count ); if ( !texdef_face_list_empty() ) { texdef_to_face_t* p = get_texdef_face_list(); GetSelFacesTexdef( get_texdef_face_list() ); } IsFaceConflicting(); PopulateTextureComboList(); ZeroOffsetValues(); if ( texdef_face_list_empty() ) { SetFlagButtons_UFOAI( get_texdef_face_list(), TRUE ); } else{ SetFlagButtons_UFOAI( get_texdef_face_list(), FALSE ); } } static gint delete_event_callback( GtkWidget *widget, GdkEvent* event, gpointer data ){ HideDlg(); return TRUE; } // make the shift increments match the grid settings // the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size // this depends on a scale value if you have selected a particular texture on which you want it to work: // we move the textures in pixels, not world units. (i.e. increment values are in pixel) // depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize // increment * scale = gridsize // hscale and vscale are optional parameters, if they are zero they will be set to the default scale // NOTE: the default scale depends if you are using BP mode or regular. // For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f // see fenris #2810 void DoSnapTToGrid( float hscale, float vscale ){ l_pIncrement = Get_SI_Inc(); if ( hscale == 0.0f ) { hscale = 0.5f; } if ( vscale == 0.0f ) { vscale = 0.5f; } #ifdef _DEBUG Sys_Printf( "DoSnapTToGrid: hscale %g vscale %g\n", hscale, vscale ); #endif l_pIncrement->shift[0] = GridSize() / hscale; l_pIncrement->shift[1] = GridSize() / vscale; // now some update work // FIXME: doesn't look good here, seems to be called several times SetTexMods(); } void UpdateSurfaceDialog(){ if ( !g_bListenUpdate ) { return; } if ( !SurfaceInspector ) { return; } // avoid long delays on slow computers while ( gtk_events_pending() ) gtk_main_iteration(); if ( g_surfwin ) { #ifdef DBG_SI Sys_Printf( "UpdateSurfaceDialog\n" ); #endif GetTexdefInfo_from_Radiant(); SetTexMods(); } } // DoSurface will always try to show the surface inspector // or update it because something new has been selected void DoSurface( void ){ #ifdef DBG_SI Sys_Printf( "DoSurface\n" ); #endif if ( !SurfaceInspector ) { create_SurfaceInspector(); } ShowDlg(); SetTexMods(); } void ToggleSurface(){ #ifdef DBG_SI Sys_Printf( "ToggleSurface Module\n" ); #endif if ( !g_surfwin ) { DoSurface(); } else{ on_cancel_button_clicked( NULL, NULL ); } } // NOTE: will raise and show the Surface inspector and exec fit for patches and brushes void SurfaceDlgFitAll(){ DoSurface(); FitAll(); } // ============================================================================= // SurfaceDialog class void ShowDlg(){ if ( !SurfaceInspector ) { create_SurfaceInspector(); } else{ gtk_widget_show( SurfaceInspector ); } GetTexdefInfo_from_Radiant(); GetTexMods( TRUE ); // Set Initial Undo Point g_surfwin = TRUE; } void HideDlg(){ g_surfwin = FALSE; gtk_widget_hide( SurfaceInspector ); } // set default values for increments (shift scale and rot) // this is called by the prefs code if can't find the values void InitDefaultIncrement( texdef_t *tex ){ tex->SetName( "foo" ); tex->shift[0] = 8; tex->shift[1] = 8; tex->scale[0] = 0.25; tex->scale[1] = 0.25; tex->rotate = 10; } void BuildDialog(){ if ( !SurfaceInspector ) { create_SurfaceInspector(); } } /* ============== SetTexMods Set the fields to the current texdef (i.e. map/texdef -> dialog widgets) =============== */ void SetTexMods(){ texdef_t *pt; GtkSpinButton *spin; GtkAdjustment *adjust; texturewin = Texturewin(); l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "SurfaceDlg SetTexMods\n" ); #endif if ( !g_surfwin ) { return; } pt = &texturewin->texdef; g_bListenChanged = false; if ( strncmp( pt->GetName(), "textures/", 9 ) != 0 ) { texdef_offset.SetName( SHADER_NOT_FOUND ); } spin = GTK_SPIN_BUTTON( hshift_offset_spinbutton ); gtk_spin_button_set_value( spin, texdef_offset.shift[0] ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->shift[0]; gtk_spin_button_set_value( GTK_SPIN_BUTTON( hshift_step_spinbutton ), l_pIncrement->shift[0] ); spin = GTK_SPIN_BUTTON( hshift_value_spinbutton ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->shift[0]; spin = GTK_SPIN_BUTTON( vshift_offset_spinbutton ); gtk_spin_button_set_value( spin, texdef_offset.shift[1] ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->shift[1]; gtk_spin_button_set_value( GTK_SPIN_BUTTON( vshift_step_spinbutton ), l_pIncrement->shift[1] ); spin = GTK_SPIN_BUTTON( vshift_value_spinbutton ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->shift[1]; spin = GTK_SPIN_BUTTON( hscale_offset_spinbutton ); gtk_spin_button_set_value( spin, texdef_offset.scale[0] ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->scale[0]; gtk_spin_button_set_value( GTK_SPIN_BUTTON( hscale_step_spinbutton ), l_pIncrement->scale[0] ); spin = GTK_SPIN_BUTTON( hscale_value_spinbutton ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->scale[0]; spin = GTK_SPIN_BUTTON( vscale_offset_spinbutton ); gtk_spin_button_set_value( spin, texdef_offset.scale[1] ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->scale[1]; gtk_spin_button_set_value( GTK_SPIN_BUTTON( vscale_step_spinbutton ), l_pIncrement->scale[1] ); spin = GTK_SPIN_BUTTON( vscale_value_spinbutton ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->scale[1]; spin = GTK_SPIN_BUTTON( rotate_offset_spinbutton ); gtk_spin_button_set_value( spin, texdef_offset.rotate ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->rotate; gtk_spin_button_set_value( GTK_SPIN_BUTTON( rotate_step_spinbutton ), l_pIncrement->rotate ); spin = GTK_SPIN_BUTTON( rotate_value_spinbutton ); adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); adjust->step_increment = l_pIncrement->rotate; g_bListenChanged = true; // store the current texdef as our escape route if user hits OnCancel g_old_texdef = texturewin->texdef; } /* ============== GetTexMods Shows any changes to the main Radiant windows =============== */ void GetTexMods( bool b_SetUndoPoint ){ #ifdef DBG_SI Sys_Printf( "SurfaceDlg GetTexMods\n" ); #endif if ( !texdef_face_list_empty() ) { g_bListenUpdate = FALSE; SetChangeInFlags_Face_UFOAI( get_texdef_face_list() ); SetTexdef_FaceList( get_texdef_face_list(), b_SetUndoPoint, false ); g_bListenUpdate = TRUE; if ( b_SetUndoPoint ) { m_nUndoId = Undo_GetUndoId(); } } } void FitAll(){ on_fit_button_clicked( NULL, NULL ); } //////////////////////////////////////////////////////////////////// // // GUI Section // //////////////////////////////////////////////////////////////////// GtkWidget* create_SurfaceInspector( void ){ GtkWidget *label; GtkWidget *hseparator; GtkWidget *eventbox; GtkWidget *viewport8; GtkWidget *viewport9; GtkWidget *viewport2; GtkWidget *viewport7; GtkWidget *viewport5; GtkWidget *viewport6; GtkWidget *viewport10; GtkWidget *table1; GtkWidget *table4; GtkWidget *table5; GtkWidget *table7; GtkWidget *alignment1; GtkWidget *alignment2; GtkWidget *alignment3; GtkWidget *vbox7; GtkWidget *hbox1; GtkWidget *hbox2; GtkWidget *hbox3; GtkWidget *hbox4; GtkWidget *image1; GtkWidget *image2; GtkWidget *image3; GtkWidget *hbuttonbox1; SurfaceInspector = gtk_window_new( GTK_WINDOW_TOPLEVEL ); gtk_container_set_border_width( GTK_CONTAINER( SurfaceInspector ), 4 ); gtk_window_set_title( GTK_WINDOW( SurfaceInspector ), "Surface Inspector" ); SetWinPos_from_Prefs( SurfaceInspector ); viewport8 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport8 ); gtk_container_add( GTK_CONTAINER( SurfaceInspector ), viewport8 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport8 ), GTK_SHADOW_NONE ); vbox7 = gtk_vbox_new( FALSE, 0 ); gtk_widget_show( vbox7 ); gtk_container_add( GTK_CONTAINER( viewport8 ), vbox7 ); viewport9 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport9 ); gtk_box_pack_start( GTK_BOX( vbox7 ), viewport9, FALSE, FALSE, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport9 ), 2 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport9 ), GTK_SHADOW_ETCHED_IN ); hbox1 = gtk_hbox_new( FALSE, 0 ); gtk_widget_show( hbox1 ); gtk_container_add( GTK_CONTAINER( viewport9 ), hbox1 ); gtk_container_set_border_width( GTK_CONTAINER( hbox1 ), 4 ); label = gtk_label_new( "Texture: " ); gtk_widget_show( label ); gtk_box_pack_start( GTK_BOX( hbox1 ), label, FALSE, FALSE, 0 ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); texture_combo = gtk_combo_new(); g_object_set_data( G_OBJECT( GTK_COMBO( texture_combo )->popwin ), "KeepMeAround", texture_combo ); gtk_combo_disable_activate( (GtkCombo*) texture_combo ); gtk_widget_show( texture_combo ); gtk_box_pack_start( GTK_BOX( hbox1 ), texture_combo, TRUE, TRUE, 0 ); texture_combo_entry = GTK_COMBO( texture_combo )->entry; gtk_widget_show( texture_combo_entry ); gtk_entry_set_max_length( GTK_ENTRY( texture_combo_entry ), 128 ); viewport2 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport2 ); gtk_box_pack_start( GTK_BOX( vbox7 ), viewport2, FALSE, TRUE, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport2 ), 2 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport2 ), GTK_SHADOW_ETCHED_IN ); table1 = gtk_table_new( 13, 4, FALSE ); gtk_widget_show( table1 ); gtk_container_add( GTK_CONTAINER( viewport2 ), table1 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 3, 4, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 3, 4, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 3, 4, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 5, 6, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 5, 6, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 5, 6, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 7, 8, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 7, 8, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 7, 8, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 9, 10, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 9, 10, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 9, 10, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 11, 12, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 11, 12, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 11, 12, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( "Offset" ); gtk_widget_show( label ); gtk_table_attach( GTK_TABLE( table1 ), label, 2, 3, 0, 1, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); label = gtk_label_new( "Step" ); gtk_widget_show( label ); gtk_table_attach( GTK_TABLE( table1 ), label, 3, 4, 0, 1, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 3, 4, 12, 13, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); match_grid_button = gtk_button_new_with_mnemonic( "Match Grid" ); gtk_widget_show( match_grid_button ); gtk_container_add( GTK_CONTAINER( eventbox ), match_grid_button ); label = gtk_label_new( "Value" ); gtk_widget_show( label ); gtk_table_attach( GTK_TABLE( table1 ), label, 1, 2, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 3, 4, (GtkAttachOptions) ( GTK_SHRINK | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 5, 6, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 7, 8, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 9, 10, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 11, 12, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 4, 5, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( "V Shift: " ); gtk_widget_show( label ); gtk_container_add( GTK_CONTAINER( eventbox ), label ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 6, 7, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( " H Scale: " ); gtk_widget_show( label ); gtk_container_add( GTK_CONTAINER( eventbox ), label ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 8, 9, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( "V Scale: " ); gtk_widget_show( label ); gtk_container_add( GTK_CONTAINER( eventbox ), label ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 10, 11, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( "Rotate: " ); gtk_widget_show( label ); gtk_container_add( GTK_CONTAINER( eventbox ), label ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 2, 3, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); label = gtk_label_new( "H Shift: " ); gtk_widget_show( label ); gtk_container_add( GTK_CONTAINER( eventbox ), label ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); hseparator = gtk_hseparator_new(); gtk_widget_show( hseparator ); gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 1, 2, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 1, 2, 12, 13, (GtkAttachOptions) ( GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); lock_valuechange_togglebutton = gtk_toggle_button_new_with_mnemonic( "UNLOCK" ); gtk_widget_show( lock_valuechange_togglebutton ); gtk_container_add( GTK_CONTAINER( eventbox ), lock_valuechange_togglebutton ); // Value Spins hshift_value_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); hshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_value_spinbutton_adj ), 1, 2 ); gtk_widget_show( hshift_value_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hshift_value_spinbutton, 1, 2, 2, 3, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_value_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_value_spinbutton ), TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), FALSE ); vshift_value_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); vshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_value_spinbutton_adj ), 1, 2 ); gtk_widget_show( vshift_value_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vshift_value_spinbutton, 1, 2, 4, 5, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_value_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_value_spinbutton ), TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), FALSE ); hscale_value_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); hscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_value_spinbutton_adj ), 1, 4 ); gtk_widget_show( hscale_value_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hscale_value_spinbutton, 1, 2, 6, 7, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_value_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_value_spinbutton ), TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), FALSE ); vscale_value_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); vscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_value_spinbutton_adj ), 1, 4 ); gtk_widget_show( vscale_value_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vscale_value_spinbutton, 1, 2, 8, 9, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_value_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vscale_value_spinbutton ), TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), FALSE ); rotate_value_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); rotate_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_value_spinbutton_adj ), 1, 0 ); gtk_widget_show( rotate_value_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), rotate_value_spinbutton, 1, 2, 10, 11, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_value_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_value_spinbutton ), TRUE ); gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), FALSE ); // Offset Spins hshift_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); hshift_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_offset_spinbutton_adj ), 0, 2 ); gtk_widget_show( hshift_offset_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hshift_offset_spinbutton, 2, 3, 2, 3, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 4, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), TRUE ); vshift_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); vshift_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_offset_spinbutton_adj ), 0, 2 ); gtk_widget_show( vshift_offset_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vshift_offset_spinbutton, 2, 3, 4, 5, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 4, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), TRUE ); hscale_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); hscale_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_offset_spinbutton_adj ), 0, 4 ); gtk_widget_show( hscale_offset_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hscale_offset_spinbutton, 2, 3, 6, 7, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 4, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), TRUE ); vscale_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); vscale_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_offset_spinbutton_adj ), 0, 4 ); gtk_widget_show( vscale_offset_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vscale_offset_spinbutton, 2, 3, 8, 9, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 4, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), TRUE ); rotate_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); rotate_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_offset_spinbutton_adj ), 0, 2 ); gtk_widget_show( rotate_offset_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), rotate_offset_spinbutton, 2, 3, 10, 11, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 4, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), GTK_UPDATE_IF_VALID ); gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), TRUE ); // Step Spins hshift_step_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); hshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_step_spinbutton_adj ), 1, 2 ); gtk_widget_show( hshift_step_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hshift_step_spinbutton, 3, 4, 2, 3, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_step_spinbutton ), GTK_UPDATE_IF_VALID ); vshift_step_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); vshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_step_spinbutton_adj ), 1, 2 ); gtk_widget_show( vshift_step_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vshift_step_spinbutton, 3, 4, 4, 5, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_step_spinbutton ), GTK_UPDATE_IF_VALID ); hscale_step_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); hscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_step_spinbutton_adj ), 1, 4 ); gtk_widget_show( hscale_step_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), hscale_step_spinbutton, 3, 4, 6, 7, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_step_spinbutton ), GTK_UPDATE_IF_VALID ); vscale_step_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); vscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_step_spinbutton_adj ), 1, 4 ); gtk_widget_show( vscale_step_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), vscale_step_spinbutton, 3, 4, 8, 9, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_step_spinbutton ), GTK_UPDATE_IF_VALID ); rotate_step_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); rotate_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_step_spinbutton_adj ), 1, 2 ); gtk_widget_show( rotate_step_spinbutton ); gtk_table_attach( GTK_TABLE( table1 ), rotate_step_spinbutton, 3, 4, 10, 11, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_step_spinbutton ), GTK_UPDATE_IF_VALID ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 2, 3, 12, 13, (GtkAttachOptions) ( 0 ), (GtkAttachOptions) ( 0 ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 12, 13, (GtkAttachOptions) ( 0 ), (GtkAttachOptions) ( 0 ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 0, 1, (GtkAttachOptions) ( 0 ), (GtkAttachOptions) ( 0 ), 0, 0 ); viewport7 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport7 ); gtk_box_pack_start( GTK_BOX( vbox7 ), viewport7, FALSE, TRUE, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport7 ), 2 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport7 ), GTK_SHADOW_ETCHED_IN ); table4 = gtk_table_new( 4, 7, FALSE ); gtk_widget_show( table4 ); gtk_container_add( GTK_CONTAINER( viewport7 ), table4 ); viewport5 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport5 ); gtk_table_attach( GTK_TABLE( table4 ), viewport5, 1, 7, 0, 4, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport5 ), 6 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport5 ), GTK_SHADOW_ETCHED_OUT ); table5 = gtk_table_new( 2, 3, FALSE ); gtk_widget_show( table5 ); gtk_container_add( GTK_CONTAINER( viewport5 ), table5 ); gtk_container_set_border_width( GTK_CONTAINER( table5 ), 5 ); gtk_table_set_col_spacings( GTK_TABLE( table5 ), 2 ); label = gtk_label_new( "Height" ); gtk_widget_show( label ); gtk_table_attach( GTK_TABLE( table5 ), label, 2, 3, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); label = gtk_label_new( "Width" ); gtk_widget_show( label ); gtk_table_attach( GTK_TABLE( table5 ), label, 1, 2, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); fit_width_spinbutton_adj = gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ); fit_width_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( fit_width_spinbutton_adj ), 1, 0 ); gtk_widget_show( fit_width_spinbutton ); gtk_table_attach( GTK_TABLE( table5 ), fit_width_spinbutton, 1, 2, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_width_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_width_spinbutton ), GTK_UPDATE_IF_VALID ); fit_height_spinbutton_adj = gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ); fit_height_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( fit_height_spinbutton_adj ), 1, 0 ); gtk_widget_show( fit_height_spinbutton ); gtk_table_attach( GTK_TABLE( table5 ), fit_height_spinbutton, 2, 3, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 3, 0 ); gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_height_spinbutton ), TRUE ); gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_height_spinbutton ), GTK_UPDATE_IF_VALID ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table5 ), eventbox, 0, 1, 0, 1, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table5 ), eventbox, 0, 1, 1, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_FILL ), 4, 0 ); fit_button = gtk_button_new_with_mnemonic( " Fit " ); gtk_widget_show( fit_button ); gtk_container_add( GTK_CONTAINER( eventbox ), fit_button ); viewport6 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport6 ); gtk_table_attach( GTK_TABLE( table4 ), viewport6, 0, 1, 0, 4, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( 0 ), 0, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport6 ), 4 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport6 ), GTK_SHADOW_NONE ); table7 = gtk_table_new( 2, 1, FALSE ); gtk_widget_show( table7 ); gtk_container_add( GTK_CONTAINER( viewport6 ), table7 ); eventbox = gtk_event_box_new(); gtk_widget_show( eventbox ); gtk_table_attach( GTK_TABLE( table7 ), eventbox, 0, 1, 0, 2, (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), 0, 0 ); axial_button = gtk_button_new_with_mnemonic( "Axial" ); gtk_widget_show( axial_button ); gtk_container_add( GTK_CONTAINER( eventbox ), axial_button ); gtk_widget_set_size_request( axial_button, 56, 29 ); gtk_container_set_border_width( GTK_CONTAINER( axial_button ), 4 ); // Fit in Flags sub-dialog Create_UFOAIFlagsDialog( vbox7 ); viewport10 = gtk_viewport_new( NULL, NULL ); gtk_widget_show( viewport10 ); gtk_box_pack_start( GTK_BOX( vbox7 ), viewport10, FALSE, TRUE, 0 ); gtk_container_set_border_width( GTK_CONTAINER( viewport10 ), 2 ); gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport10 ), GTK_SHADOW_ETCHED_IN ); hbuttonbox1 = gtk_hbutton_box_new(); gtk_widget_show( hbuttonbox1 ); gtk_container_add( GTK_CONTAINER( viewport10 ), hbuttonbox1 ); gtk_container_set_border_width( GTK_CONTAINER( hbuttonbox1 ), 4 ); gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ), GTK_BUTTONBOX_SPREAD ); done_button = gtk_button_new(); gtk_widget_show( done_button ); gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), done_button ); GTK_WIDGET_SET_FLAGS( done_button, GTK_CAN_DEFAULT ); alignment1 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); gtk_widget_show( alignment1 ); gtk_container_add( GTK_CONTAINER( done_button ), alignment1 ); hbox2 = gtk_hbox_new( FALSE, 2 ); gtk_widget_show( hbox2 ); gtk_container_add( GTK_CONTAINER( alignment1 ), hbox2 ); image1 = gtk_image_new_from_stock( "gtk-yes", GTK_ICON_SIZE_BUTTON ); gtk_widget_show( image1 ); gtk_box_pack_start( GTK_BOX( hbox2 ), image1, FALSE, FALSE, 0 ); label = gtk_label_new_with_mnemonic( "Done" ); gtk_widget_show( label ); gtk_box_pack_start( GTK_BOX( hbox2 ), label, FALSE, FALSE, 0 ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); apply_button = gtk_button_new(); gtk_widget_show( apply_button ); gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), apply_button ); GTK_WIDGET_SET_FLAGS( apply_button, GTK_CAN_DEFAULT ); alignment3 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); gtk_widget_show( alignment3 ); gtk_container_add( GTK_CONTAINER( apply_button ), alignment3 ); hbox4 = gtk_hbox_new( FALSE, 2 ); gtk_widget_show( hbox4 ); gtk_container_add( GTK_CONTAINER( alignment3 ), hbox4 ); image3 = gtk_image_new_from_stock( "gtk-apply", GTK_ICON_SIZE_BUTTON ); gtk_widget_show( image3 ); gtk_box_pack_start( GTK_BOX( hbox4 ), image3, FALSE, FALSE, 0 ); label = gtk_label_new_with_mnemonic( "Apply" ); gtk_widget_show( label ); gtk_box_pack_start( GTK_BOX( hbox4 ), label, FALSE, FALSE, 0 ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); cancel_button = gtk_button_new(); gtk_widget_show( cancel_button ); gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), cancel_button ); GTK_WIDGET_SET_FLAGS( cancel_button, GTK_CAN_DEFAULT ); alignment2 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); gtk_widget_show( alignment2 ); gtk_container_add( GTK_CONTAINER( cancel_button ), alignment2 ); hbox3 = gtk_hbox_new( FALSE, 2 ); gtk_widget_show( hbox3 ); gtk_container_add( GTK_CONTAINER( alignment2 ), hbox3 ); image2 = gtk_image_new_from_stock( "gtk-no", GTK_ICON_SIZE_BUTTON ); gtk_widget_show( image2 ); gtk_box_pack_start( GTK_BOX( hbox3 ), image2, FALSE, FALSE, 0 ); label = gtk_label_new_with_mnemonic( "Cancel" ); gtk_widget_show( label ); gtk_box_pack_start( GTK_BOX( hbox3 ), label, FALSE, FALSE, 0 ); gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); g_signal_connect( (gpointer) SurfaceInspector, "delete_event", G_CALLBACK( delete_event_callback ), NULL ); g_signal_connect( (gpointer) SurfaceInspector, "destroy", G_CALLBACK( gtk_widget_destroy ), NULL ); g_signal_connect( (gpointer) texture_combo_entry, "key_press_event", G_CALLBACK( on_texture_combo_entry_key_press_event ), NULL ); g_signal_connect( (gpointer) texture_combo_entry, "activate", G_CALLBACK( on_texture_combo_entry_activate ), NULL ); g_signal_connect( (gpointer) hshift_offset_spinbutton, "value_changed", G_CALLBACK( on_hshift_offset_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vshift_offset_spinbutton, "value_changed", G_CALLBACK( on_vshift_offset_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) hscale_offset_spinbutton, "value_changed", G_CALLBACK( on_hscale_offset_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vscale_offset_spinbutton, "value_changed", G_CALLBACK( on_vscale_offset_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) rotate_offset_spinbutton, "value_changed", G_CALLBACK( on_rotate_offset_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) hshift_value_spinbutton, "value_changed", G_CALLBACK( on_hshift_value_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vshift_value_spinbutton, "value_changed", G_CALLBACK( on_vshift_value_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) hscale_value_spinbutton, "value_changed", G_CALLBACK( on_hscale_value_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vscale_value_spinbutton, "value_changed", G_CALLBACK( on_vscale_value_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) rotate_value_spinbutton, "value_changed", G_CALLBACK( on_rotate_value_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) hshift_step_spinbutton, "value_changed", G_CALLBACK( on_hshift_step_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vshift_step_spinbutton, "value_changed", G_CALLBACK( on_vshift_step_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) hscale_step_spinbutton, "value_changed", G_CALLBACK( on_hscale_step_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) vscale_step_spinbutton, "value_changed", G_CALLBACK( on_vscale_step_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) rotate_step_spinbutton, "value_changed", G_CALLBACK( on_rotate_step_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) match_grid_button, "clicked", G_CALLBACK( on_match_grid_button_clicked ), NULL ); g_signal_connect( (gpointer) lock_valuechange_togglebutton, "toggled", G_CALLBACK( on_lock_valuechange_togglebutton_toggled ), NULL ); g_signal_connect( (gpointer) fit_width_spinbutton, "value_changed", G_CALLBACK( on_fit_width_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) fit_height_spinbutton, "value_changed", G_CALLBACK( on_fit_height_spinbutton_value_changed ), NULL ); g_signal_connect( (gpointer) fit_button, "clicked", G_CALLBACK( on_fit_button_clicked ), NULL ); g_signal_connect( (gpointer) axial_button, "clicked", G_CALLBACK( on_axial_button_clicked ), NULL ); g_signal_connect( (gpointer) done_button, "clicked", G_CALLBACK( on_done_button_clicked ), NULL ); g_signal_connect( (gpointer) apply_button, "clicked", G_CALLBACK( on_apply_button_clicked ), NULL ); g_signal_connect( (gpointer) cancel_button, "clicked", G_CALLBACK( on_cancel_button_clicked ), NULL ); return SurfaceInspector; } // Texture Combo gboolean on_texture_combo_entry_key_press_event( GtkWidget *widget, GdkEventKey *event, gpointer user_data ){ // Have Tab activate selection as well as Return if ( event->keyval == GDK_Tab ) { g_signal_emit_by_name( texture_combo_entry, "activate" ); } return FALSE; } void on_texture_combo_entry_activate( GtkEntry *entry, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; char text[128] = { 0 }; if ( !texdef_face_list_empty() && g_bListenChanged ) { // activate only on entry change strcpy( text, gtk_entry_get_text( entry ) ); if ( strcmp( old_texture_entry, text ) ) { // Check for spaces in shader name if ( text[0] <= ' ' || strchr( text, ' ' ) ) { Sys_FPrintf( SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text ); } else { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; strcpy( old_texture_entry, text ); tmp_texdef->SetName( text ); } GetTexMods(); } } } } // Offset Spins static void on_hshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_offset.shift[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_offset_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; if ( is_HShift_conflicting ) { tmp_texdef->shift[0] = tmp_orig_texdef->shift[0] + texdef_offset.shift[0]; } else{ tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0]; } } GetTexMods(); } } static void on_vshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_offset.shift[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_offset_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; if ( is_VShift_conflicting ) { tmp_texdef->shift[1] = tmp_orig_texdef->shift[1] + texdef_offset.shift[1]; } else{ tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1]; } } GetTexMods(); } } static void on_hscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_offset.scale[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_offset_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; if ( is_HScale_conflicting ) { tmp_texdef->scale[0] = tmp_orig_texdef->scale[0] + texdef_offset.scale[0]; } else{ tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0]; } } GetTexMods(); } } static void on_vscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_offset.scale[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_offset_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; if ( is_VScale_conflicting ) { tmp_texdef->scale[1] = tmp_orig_texdef->scale[1] + texdef_offset.scale[1]; } else{ tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1]; } } GetTexMods(); } } static void on_rotate_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_offset.rotate = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_offset_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; if ( is_Rotate_conflicting ) { tmp_texdef->rotate = tmp_orig_texdef->rotate + texdef_offset.rotate; } else{ tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate; } } GetTexMods(); } } // Match Grid static void on_match_grid_button_clicked( GtkButton *button, gpointer user_data ){ float hscale, vscale; if ( !strcmp( gtk_entry_get_text( GTK_ENTRY( hscale_value_spinbutton ) ), "" ) ) { hscale = 0.0; } else{ hscale = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); } if ( !strcmp( gtk_entry_get_text( GTK_ENTRY( vscale_value_spinbutton ) ), "" ) ) { vscale = 0.0; } else{ vscale = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); } DoSnapTToGrid( hscale, vscale ); } // Lock out changes to Value static void on_lock_valuechange_togglebutton_toggled( GtkToggleButton *togglebutton, gpointer user_data ){ bool is_Locked; is_Locked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( lock_valuechange_togglebutton ) ); gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), is_Locked ); gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), is_Locked ); gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), is_Locked ); gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), is_Locked ); gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), is_Locked ); } // Value Spins static void on_hshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_SI_values.shift[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_value_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0]; is_HShift_conflicting = FALSE; } GetTexMods(); } } static void on_vshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_SI_values.shift[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_value_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1]; is_VShift_conflicting = FALSE; } GetTexMods(); } } static void on_hscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_SI_values.scale[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0]; is_HScale_conflicting = FALSE; } GetTexMods(); } } static void on_vscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_SI_values.scale[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1]; is_VScale_conflicting = FALSE; } GetTexMods(); } } static void on_rotate_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; texdef_SI_values.rotate = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_value_spinbutton ) ); if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate; is_Rotate_conflicting = FALSE; } GetTexMods(); } } // Step Spins static void on_hshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ gfloat val; GtkAdjustment * adjust; if ( !g_bListenChanged ) { return; } l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "OnIncrementChanged HShift\n" ); #endif val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_step_spinbutton ) ) ; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hshift_offset_spinbutton ) ); adjust->step_increment = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hshift_value_spinbutton ) ); adjust->step_increment = val; l_pIncrement->shift[0] = val; } static void on_vshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ gfloat val; GtkAdjustment * adjust; if ( !g_bListenChanged ) { return; } l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "OnIncrementChanged VShift\n" ); #endif val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_step_spinbutton ) ) ; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vshift_offset_spinbutton ) ); adjust->step_increment = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vshift_value_spinbutton ) ); adjust->step_increment = val; l_pIncrement->shift[1] = val; } static void on_hscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ gfloat val; GtkAdjustment * adjust; if ( !g_bListenChanged ) { return; } l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "OnIncrementChanged HShift\n" ); #endif val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_step_spinbutton ) ) ; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hscale_offset_spinbutton ) ); adjust->step_increment = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); adjust->step_increment = val; l_pIncrement->scale[0] = val; } static void on_vscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ gfloat val; GtkAdjustment * adjust; if ( !g_bListenChanged ) { return; } l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "OnIncrementChanged HShift\n" ); #endif val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_step_spinbutton ) ) ; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vscale_offset_spinbutton ) ); adjust->step_increment = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); adjust->step_increment = val; l_pIncrement->scale[1] = val; } static void on_rotate_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ gfloat val; GtkAdjustment * adjust; if ( !g_bListenChanged ) { return; } l_pIncrement = Get_SI_Inc(); #ifdef DBG_SI Sys_Printf( "OnIncrementChanged HShift\n" ); #endif val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_step_spinbutton ) ) ; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( rotate_offset_spinbutton ) ); adjust->step_increment = val; adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( rotate_value_spinbutton ) ); adjust->step_increment = val; l_pIncrement->rotate = val; } // Fit Texture static void on_fit_width_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ m_nWidth = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( fit_width_spinbutton ) ); } static void on_fit_height_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ m_nHeight = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( fit_height_spinbutton ) ); } static void on_fit_button_clicked( GtkButton *button, gpointer user_data ){ FaceList_FitTexture( get_texdef_face_list(), m_nHeight, m_nWidth ); Sys_UpdateWindows( W_ALL ); } // Axial Button static void on_axial_button_clicked( GtkButton *button, gpointer user_data ){ texdef_t* tmp_texdef; texdef_t* tmp_orig_texdef; texdef_to_face_t* temp_texdef_face_list; if ( !texdef_face_list_empty() && g_bListenChanged ) { for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) { tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; tmp_texdef->shift[0] = 0.0; tmp_texdef->shift[1] = 0.0; tmp_texdef->scale[0] = 0.5; tmp_texdef->scale[1] = 0.5; tmp_texdef->rotate = 0.0; } } SetTexdef_FaceList( get_texdef_face_list(), FALSE, TRUE ); Sys_UpdateWindows( W_ALL ); } // Action Buttons static void on_done_button_clicked( GtkButton *button, gpointer user_data ){ if ( !texdef_face_list_empty() ) { GetTexMods( TRUE ); } HideDlg(); Sys_UpdateWindows( W_ALL ); } static void on_apply_button_clicked( GtkButton *button, gpointer user_data ){ if ( !g_bListenChanged ) { return; } if ( !texdef_face_list_empty() ) { GetTexMods( TRUE ); Sys_UpdateWindows( W_CAMERA ); GetTexdefInfo_from_Radiant(); SetTexMods(); } } static void on_cancel_button_clicked( GtkButton *button, gpointer user_data ){ texturewin = Texturewin(); texturewin->texdef = g_old_texdef; // cancel the last do if we own it if ( ( m_nUndoId == Undo_GetUndoId() ) && ( m_nUndoId != 0 ) ) { #ifdef DBG_SI Sys_Printf( "OnCancel calling Undo_Undo\n" ); #endif g_bListenUpdate = false; Undo_Undo( TRUE ); g_bListenUpdate = true; m_nUndoId = 0; } HideDlg(); }