ubergames/gtkradiant
0
0
Fork 0
mirror of https://github.com/UberGames/GtkRadiant.git synced 2024-11-25 21:31:12 +00:00
Code Issues Projects Releases Packages Wiki Activity
gtkradiant/plugins/surface/surfacedialog.cpp
mattn 995f6a1011 * divVerent's patch for the brush primitives surface dialog (fixed segfault due to NULL pointer) 
* Quote http://zerowing.idsoftware.com/pipermail/gtkradiant/2008-July/011094.html : Attached to this message is a patch for a "somewhat working" brush
primitives surface dialog. It is an ugly hack, as it converts between
fake texdef notations and brush primitives whenever values are needed.
Had to fix an accuracy bug: the surface dialog rounded all rotation
values to integer angles, which SEVERELY broke things for me (changed
the Gtk spin object to use 4 digits, which is enough for me).

Also, I changed the fake texdef / brush primitives conversions to use
long double internally, as float's roundoff errors were quite visible to
me when testing.

Hope the remaining roundoff errors from converting back and forth won't
kill me, but it worked for a simple map example.

Also, I had to separate out "Snap to grid" and "Don't clamp" into two
separare options. They now mean:

- Snap to grid: snaps drag/etc. actions to the grid
- Don't clamp: disable brush point snapping during many operations, like
  merely shifting brushes, editing texturing parameters, map loading,
  etc.

The reason is that I do need the grid, but I don't want to get my
objects messed up by the snapping in my map. As I am using free
rotations, this DOES change quite much.

The config.py change is needed for compilation on Debian stable;
Debian's scons does not use the CFLAGS variable, but just CCFLAGS and
CXXFLAGS. In newer scons versions, CFLAGS is _shared_ flags for C and
C++, so if you want to require these, you don't need to include the
CFLAGS in CXXFLAGS too.


git-svn-id: svn://svn.icculus.org/gtkradiant/GtkRadiant/trunk@301 8a3a26a2-13c4-0310-b231-cf6edde360e5
2008-07-10 08:30:47 +00:00

1925 lines
70 KiB
C++
Raw Blame History

/*
Copyright (C) 1999-2007 id Software, Inc. and contributors.
For a list of contributors, see the accompanying CONTRIBUTORS file.
This file is part of GtkRadiant.
GtkRadiant is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
GtkRadiant is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with GtkRadiant; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*/
//
// Surface Dialog Module
//
//
// Nurail: Implemented to Module from the main Radiant Surface Dialog code
//
#include <gtk/gtk.h>
#include <gdk/gdkkeysyms.h>
#include "surfdlg_plugin.h"
#ifdef _DEBUG
//#define DBG_SI 1
#endif
#include "gtkr_vector.h"
vector<texdef_to_face_t> g_texdef_face_vector;
inline texdef_to_face_t* get_texdef_face_list()
{
return &(*g_texdef_face_vector.begin());
}
inline unsigned int texdef_face_list_empty()
{
return g_texdef_face_vector.empty();
}
inline unsigned int texdef_face_list_size()
{
return g_texdef_face_vector.size();
}
// For different faces having different values
bool is_HShift_conflicting;
bool is_VShift_conflicting;
bool is_HScale_conflicting;
bool is_VScale_conflicting;
bool is_Rotate_conflicting;
bool is_TextureName_conflicting;
void ShowDlg();
void HideDlg();
void SetTexMods();
void GetTexMods(bool b_SetUndoPoint = FALSE);
void BuildDialog();
void FitAll();
void InitDefaultIncrement(texdef_t *);
void DoSnapTToGrid(float hscale, float vscale);
// called to perform a fitting from the outside (shortcut key)
void SurfaceDialogFitAll();
// 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();
}
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;
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, 4);
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, 4);
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, 4);
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);
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();
}
Reference in a new issue View git blame Copy permalink