/*
   Copyright (C) 1999-2006 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
//
// Leonardo Zide (leo@lokigames.com)
//

#include "surfacedialog.h"

#include "debugging/debugging.h"
#include "warnings.h"

#include "iscenegraph.h"
#include "itexdef.h"
#include "iundo.h"
#include "iselection.h"

#include <gtk/gtkhbox.h>
#include <gtk/gtkvbox.h>
#include <gtk/gtkframe.h>
#include <gtk/gtklabel.h>
#include <gtk/gtktable.h>
#include <gtk/gtkbutton.h>
#include <gtk/gtkspinbutton.h>
#include <gdk/gdkkeysyms.h>
#include <gtk/gtkcheckbutton.h> //Shamus: For Textool

#include "signal/isignal.h"
#include "generic/object.h"
#include "math/vector.h"
#include "texturelib.h"
#include "shaderlib.h"
#include "stringio.h"

#include "gtkutil/idledraw.h"
#include "gtkutil/dialog.h"
#include "gtkutil/entry.h"
#include "gtkutil/nonmodal.h"
#include "gtkutil/pointer.h"
#include "gtkutil/glwidget.h"           //Shamus: For Textool
#include "gtkutil/button.h"
#include "map.h"
#include "select.h"
#include "patchmanip.h"
#include "brushmanip.h"
#include "patchdialog.h"
#include "preferences.h"
#include "brush_primit.h"
#include "xywindow.h"
#include "mainframe.h"
#include "gtkdlgs.h"
#include "dialog.h"
#include "brush.h"              //Shamus: for Textool
#include "patch.h"
#include "commands.h"
#include "stream/stringstream.h"
#include "grid.h"
#include "textureentry.h"

//NOTE: Proper functioning of Textool currently requires that the "#if 1" lines in
//      brush_primit.h be changed to "#if 0". add/removeScale screws this up ATM. :-)
//      Plus, Radiant seems to work just fine without that stuff. ;-)

#define TEXTOOL_ENABLED 0

#if TEXTOOL_ENABLED

namespace TexTool
{

//Shamus: Textool function prototypes
gboolean size_allocate( GtkWidget *, GtkAllocation *, gpointer );
gboolean expose( GtkWidget *, GdkEventExpose *, gpointer );
gboolean button_press( GtkWidget *, GdkEventButton *, gpointer );
gboolean button_release( GtkWidget *, GdkEventButton *, gpointer );
gboolean motion( GtkWidget *, GdkEventMotion *, gpointer );
void flipX( GtkToggleButton *, gpointer );
void flipY( GtkToggleButton *, gpointer );

//End Textool function prototypes

//Shamus: Textool globals
GtkWidget * g_textoolWin;
//End Textool globals

void queueDraw(){
	gtk_widget_queue_draw( g_textoolWin );
}

}

#endif

inline void spin_button_set_step( GtkSpinButton* spin, gfloat step ){
#if 1
	gtk_spin_button_get_adjustment( spin )->step_increment = step;
#else
	GValue gvalue = GValue_default();
	g_value_init( &gvalue, G_TYPE_DOUBLE );
	g_value_set_double( &gvalue, step );
	g_object_set( G_OBJECT( gtk_spin_button_get_adjustment( spin ) ), "step-increment", &gvalue, NULL );
#endif
}

class Increment
{
float& m_f;
public:
GtkSpinButton* m_spin;
GtkEntry* m_entry;
Increment( float& f ) : m_f( f ), m_spin( 0 ), m_entry( 0 ){
}
void cancel(){
	entry_set_float( m_entry, m_f );
}
typedef MemberCaller<Increment, &Increment::cancel> CancelCaller;
void apply(){
	m_f = static_cast<float>( entry_get_float( m_entry ) );
	spin_button_set_step( m_spin, m_f );
}
typedef MemberCaller<Increment, &Increment::apply> ApplyCaller;
};

void SurfaceInspector_GridChange();

class SurfaceInspector : public Dialog
{
GtkWindow* BuildDialog();

NonModalEntry m_textureEntry;
NonModalSpinner m_hshiftSpinner;
NonModalEntry m_hshiftEntry;
NonModalSpinner m_vshiftSpinner;
NonModalEntry m_vshiftEntry;
NonModalSpinner m_hscaleSpinner;
NonModalEntry m_hscaleEntry;
NonModalSpinner m_vscaleSpinner;
NonModalEntry m_vscaleEntry;
NonModalSpinner m_rotateSpinner;
NonModalEntry m_rotateEntry;

IdleDraw m_idleDraw;

GtkCheckButton* m_surfaceFlags[32];
GtkCheckButton* m_contentFlags[32];

NonModalEntry m_valueEntry;
GtkEntry* m_valueEntryWidget;
public:
WindowPositionTracker m_positionTracker;
WindowPositionTrackerImportStringCaller m_importPosition;
WindowPositionTrackerExportStringCaller m_exportPosition;

// Dialog Data
float m_fitHorizontal;
float m_fitVertical;

Increment m_hshiftIncrement;
Increment m_vshiftIncrement;
Increment m_hscaleIncrement;
Increment m_vscaleIncrement;
Increment m_rotateIncrement;
GtkEntry* m_texture;

SurfaceInspector() :
	m_textureEntry( ApplyShaderCaller( *this ), UpdateCaller( *this ) ),
	m_hshiftSpinner( ApplyTexdefCaller( *this ), UpdateCaller( *this ) ),
	m_hshiftEntry( Increment::ApplyCaller( m_hshiftIncrement ), Increment::CancelCaller( m_hshiftIncrement ) ),
	m_vshiftSpinner( ApplyTexdefCaller( *this ), UpdateCaller( *this ) ),
	m_vshiftEntry( Increment::ApplyCaller( m_vshiftIncrement ), Increment::CancelCaller( m_vshiftIncrement ) ),
	m_hscaleSpinner( ApplyTexdefCaller( *this ), UpdateCaller( *this ) ),
	m_hscaleEntry( Increment::ApplyCaller( m_hscaleIncrement ), Increment::CancelCaller( m_hscaleIncrement ) ),
	m_vscaleSpinner( ApplyTexdefCaller( *this ), UpdateCaller( *this ) ),
	m_vscaleEntry( Increment::ApplyCaller( m_vscaleIncrement ), Increment::CancelCaller( m_vscaleIncrement ) ),
	m_rotateSpinner( ApplyTexdefCaller( *this ), UpdateCaller( *this ) ),
	m_rotateEntry( Increment::ApplyCaller( m_rotateIncrement ), Increment::CancelCaller( m_rotateIncrement ) ),
	m_idleDraw( UpdateCaller( *this ) ),
	m_valueEntry( ApplyFlagsCaller( *this ), UpdateCaller( *this ) ),
	m_importPosition( m_positionTracker ),
	m_exportPosition( m_positionTracker ),
	m_hshiftIncrement( g_si_globals.shift[0] ),
	m_vshiftIncrement( g_si_globals.shift[1] ),
	m_hscaleIncrement( g_si_globals.scale[0] ),
	m_vscaleIncrement( g_si_globals.scale[1] ),
	m_rotateIncrement( g_si_globals.rotate ){
	m_fitVertical = 1;
	m_fitHorizontal = 1;
	m_positionTracker.setPosition( c_default_window_pos );
}

void constructWindow( GtkWindow* main_window ){
	m_parent = main_window;
	Create();
	AddGridChangeCallback( FreeCaller<SurfaceInspector_GridChange>() );
}
void destroyWindow(){
	Destroy();
}
bool visible() const {
	return GTK_WIDGET_VISIBLE( const_cast<GtkWindow*>( GetWidget() ) );
}
void queueDraw(){
	if ( visible() ) {
		m_idleDraw.queueDraw();
	}
}

void Update();
typedef MemberCaller<SurfaceInspector, &SurfaceInspector::Update> UpdateCaller;
void ApplyShader();
typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyShader> ApplyShaderCaller;
void ApplyTexdef();
typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyTexdef> ApplyTexdefCaller;
void ApplyFlags();
typedef MemberCaller<SurfaceInspector, &SurfaceInspector::ApplyFlags> ApplyFlagsCaller;
};

namespace
{
SurfaceInspector* g_SurfaceInspector;

inline SurfaceInspector& getSurfaceInspector(){
	ASSERT_NOTNULL( g_SurfaceInspector );
	return *g_SurfaceInspector;
}
}

void SurfaceInspector_constructWindow( GtkWindow* main_window ){
	getSurfaceInspector().constructWindow( main_window );
}
void SurfaceInspector_destroyWindow(){
	getSurfaceInspector().destroyWindow();
}

void SurfaceInspector_queueDraw(){
	getSurfaceInspector().queueDraw();
}

namespace
{
CopiedString g_selectedShader;
TextureProjection g_selectedTexdef;
ContentsFlagsValue g_selectedFlags;
size_t g_selectedShaderSize[2];
}

void SurfaceInspector_SetSelectedShader( const char* shader ){
	g_selectedShader = shader;
	SurfaceInspector_queueDraw();
}

void SurfaceInspector_SetSelectedTexdef( const TextureProjection& projection ){
	g_selectedTexdef = projection;
	SurfaceInspector_queueDraw();
}

void SurfaceInspector_SetSelectedFlags( const ContentsFlagsValue& flags ){
	g_selectedFlags = flags;
	SurfaceInspector_queueDraw();
}

static bool s_texture_selection_dirty = false;

void SurfaceInspector_updateSelection(){
	s_texture_selection_dirty = true;
	SurfaceInspector_queueDraw();

#if TEXTOOL_ENABLED
	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
		TexTool::queueDraw();
		//globalOutputStream() << "textool texture changed..\n";
	}
#endif
}

void SurfaceInspector_SelectionChanged( const Selectable& selectable ){
	SurfaceInspector_updateSelection();
}

void SurfaceInspector_SetCurrent_FromSelected(){
	if ( s_texture_selection_dirty == true ) {
		s_texture_selection_dirty = false;
		if ( !g_SelectedFaceInstances.empty() ) {
			TextureProjection projection;
//This *may* be the point before it fucks up... Let's see!
//Yep, there was a call to removeScale in there...
			Scene_BrushGetTexdef_Component_Selected( GlobalSceneGraph(), projection );

			SurfaceInspector_SetSelectedTexdef( projection );

			Scene_BrushGetShaderSize_Component_Selected( GlobalSceneGraph(), g_selectedShaderSize[0], g_selectedShaderSize[1] );
			g_selectedTexdef.m_brushprimit_texdef.coords[0][2] = float_mod( g_selectedTexdef.m_brushprimit_texdef.coords[0][2], (float)g_selectedShaderSize[0] );
			g_selectedTexdef.m_brushprimit_texdef.coords[1][2] = float_mod( g_selectedTexdef.m_brushprimit_texdef.coords[1][2], (float)g_selectedShaderSize[1] );

			CopiedString name;
			Scene_BrushGetShader_Component_Selected( GlobalSceneGraph(), name );
			if ( string_not_empty( name.c_str() ) ) {
				SurfaceInspector_SetSelectedShader( name.c_str() );
			}

			ContentsFlagsValue flags;
			Scene_BrushGetFlags_Component_Selected( GlobalSceneGraph(), flags );
			SurfaceInspector_SetSelectedFlags( flags );
		}
		else
		{
			TextureProjection projection;
			Scene_BrushGetTexdef_Selected( GlobalSceneGraph(), projection );
			SurfaceInspector_SetSelectedTexdef( projection );

			CopiedString name;
			Scene_BrushGetShader_Selected( GlobalSceneGraph(), name );
			if ( string_empty( name.c_str() ) ) {
				Scene_PatchGetShader_Selected( GlobalSceneGraph(), name );
			}
			if ( string_not_empty( name.c_str() ) ) {
				SurfaceInspector_SetSelectedShader( name.c_str() );
			}

			ContentsFlagsValue flags( 0, 0, 0, false );
			Scene_BrushGetFlags_Selected( GlobalSceneGraph(), flags );
			SurfaceInspector_SetSelectedFlags( flags );
		}
	}
}

const char* SurfaceInspector_GetSelectedShader(){
	SurfaceInspector_SetCurrent_FromSelected();
	return g_selectedShader.c_str();
}

const TextureProjection& SurfaceInspector_GetSelectedTexdef(){
	SurfaceInspector_SetCurrent_FromSelected();
	return g_selectedTexdef;
}

const ContentsFlagsValue& SurfaceInspector_GetSelectedFlags(){
	SurfaceInspector_SetCurrent_FromSelected();
	return g_selectedFlags;
}



/*
   ===================================================

   SURFACE INSPECTOR

   ===================================================
 */

si_globals_t g_si_globals;


// 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 GetGridSize()
// 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 ){
	g_si_globals.shift[0] = static_cast<float>( float_to_integer( static_cast<float>( GetGridSize() ) / hscale ) );
	g_si_globals.shift[1] = static_cast<float>( float_to_integer( static_cast<float>( GetGridSize() ) / vscale ) );
	getSurfaceInspector().queueDraw();
}

void SurfaceInspector_GridChange(){
	if ( g_si_globals.m_bSnapTToGrid ) {
		DoSnapTToGrid( Texdef_getDefaultTextureScale(), Texdef_getDefaultTextureScale() );
	}
}

// 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 the current texture scale used?
// 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 GetGridSize()
// increment * scale = gridsize
static void OnBtnMatchGrid( GtkWidget *widget, gpointer data ){
	float hscale, vscale;
	hscale = static_cast<float>( gtk_spin_button_get_value_as_float( getSurfaceInspector().m_hscaleIncrement.m_spin ) );
	vscale = static_cast<float>( gtk_spin_button_get_value_as_float( getSurfaceInspector().m_vscaleIncrement.m_spin ) );

	if ( hscale == 0.0f || vscale == 0.0f ) {
		globalOutputStream() << "ERROR: unexpected scale == 0.0f\n";
		return;
	}

	DoSnapTToGrid( hscale, vscale );
}

// DoSurface will always try to show the surface inspector
// or update it because something new has been selected
// Shamus: It does get called when the SI is hidden, but not when you select something new. ;-)
void DoSurface( void ){
	if ( getSurfaceInspector().GetWidget() == 0 ) {
		getSurfaceInspector().Create();

	}
	getSurfaceInspector().Update();
	getSurfaceInspector().importData();
	getSurfaceInspector().ShowDlg();
}

void SurfaceInspector_toggleShown(){
	if ( getSurfaceInspector().visible() ) {
		getSurfaceInspector().HideDlg();
	}
	else
	{
		DoSurface();
	}
}

void SurfaceInspector_FitTexture(){
	UndoableCommand undo( "textureAutoFit" );
	Select_FitTexture( getSurfaceInspector().m_fitHorizontal, getSurfaceInspector().m_fitVertical );
}

static void OnBtnPatchdetails( GtkWidget *widget, gpointer data ){
	Scene_PatchCapTexture_Selected( GlobalSceneGraph() );
}

static void OnBtnPatchnatural( GtkWidget *widget, gpointer data ){
	Scene_PatchNaturalTexture_Selected( GlobalSceneGraph() );
}

static void OnBtnPatchreset( GtkWidget *widget, gpointer data ){
	float fx, fy;

	if ( DoTextureLayout( &fx, &fy ) == eIDOK ) {
		Scene_PatchTileTexture_Selected( GlobalSceneGraph(), fx, fy );
	}
}

static void OnBtnPatchFit( GtkWidget *widget, gpointer data ){
	Scene_PatchTileTexture_Selected( GlobalSceneGraph(), 1, 1 );
}

static void OnBtnAxial( GtkWidget *widget, gpointer data ){
//globalOutputStream() << "--> [OnBtnAxial]...\n";
	UndoableCommand undo( "textureDefault" );
	TextureProjection projection;
//globalOutputStream() << "    TexDef_Construct_Default()...\n";
	TexDef_Construct_Default( projection );
//globalOutputStream() << "    Select_SetTexdef()...\n";

#if TEXTOOL_ENABLED

	//Shamus:
	if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
		// Scale up texture width/height if in BP mode...
//NOTE: This may not be correct any more! :-P
		if ( !g_SelectedFaceInstances.empty() ) {
			Face & face = g_SelectedFaceInstances.last().getFace();
			float x = face.getShader().m_state->getTexture().width;
			float y = face.getShader().m_state->getTexture().height;
			projection.m_brushprimit_texdef.coords[0][0] /= x;
			projection.m_brushprimit_texdef.coords[0][1] /= y;
			projection.m_brushprimit_texdef.coords[1][0] /= x;
			projection.m_brushprimit_texdef.coords[1][1] /= y;
		}
	}
#endif

	Select_SetTexdef( projection );
}

static void OnBtnFaceFit( GtkWidget *widget, gpointer data ){
	getSurfaceInspector().exportData();
	SurfaceInspector_FitTexture();
}

typedef const char* FlagName;

const FlagName surfaceflagNamesDefault[32] = {
	"surf1",
	"surf2",
	"surf3",
	"surf4",
	"surf5",
	"surf6",
	"surf7",
	"surf8",
	"surf9",
	"surf10",
	"surf11",
	"surf12",
	"surf13",
	"surf14",
	"surf15",
	"surf16",
	"surf17",
	"surf18",
	"surf19",
	"surf20",
	"surf21",
	"surf22",
	"surf23",
	"surf24",
	"surf25",
	"surf26",
	"surf27",
	"surf28",
	"surf29",
	"surf30",
	"surf31",
	"surf32"
};

const FlagName contentflagNamesDefault[32] = {
	"cont1",
	"cont2",
	"cont3",
	"cont4",
	"cont5",
	"cont6",
	"cont7",
	"cont8",
	"cont9",
	"cont10",
	"cont11",
	"cont12",
	"cont13",
	"cont14",
	"cont15",
	"cont16",
	"cont17",
	"cont18",
	"cont19",
	"cont20",
	"cont21",
	"cont22",
	"cont23",
	"cont24",
	"cont25",
	"cont26",
	"cont27",
	"cont28",
	"cont29",
	"cont30",
	"cont31",
	"cont32"
};

const char* getSurfaceFlagName( std::size_t bit ){
	const char* value = g_pGameDescription->getKeyValue( surfaceflagNamesDefault[bit] );
	if ( string_empty( value ) ) {
		return surfaceflagNamesDefault[bit];
	}
	return value;
}

const char* getContentFlagName( std::size_t bit ){
	const char* value = g_pGameDescription->getKeyValue( contentflagNamesDefault[bit] );
	if ( string_empty( value ) ) {
		return contentflagNamesDefault[bit];
	}
	return value;
}


// =============================================================================
// SurfaceInspector class

guint togglebutton_connect_toggled( GtkToggleButton* button, const Callback& callback ){
	return g_signal_connect_swapped( G_OBJECT( button ), "toggled", G_CALLBACK( callback.getThunk() ), callback.getEnvironment() );
}

GtkWindow* SurfaceInspector::BuildDialog(){
	GtkWindow* window = create_floating_window( "Surface Inspector", m_parent );

	m_positionTracker.connect( window );

	global_accel_connect_window( window );

	window_connect_focus_in_clear_focus_widget( window );


	{
		// replaced by only the vbox:
		GtkWidget* vbox = gtk_vbox_new( FALSE, 5 );
		gtk_widget_show( vbox );
		gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( vbox ) );
		gtk_container_set_border_width( GTK_CONTAINER( vbox ), 5 );

		{
			GtkWidget* hbox2 = gtk_hbox_new( FALSE, 5 );
			gtk_widget_show( hbox2 );
			gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( hbox2 ), FALSE, FALSE, 0 );

			{
				GtkWidget* label = gtk_label_new( "Texture" );
				gtk_widget_show( label );
				gtk_box_pack_start( GTK_BOX( hbox2 ), label, FALSE, TRUE, 0 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_box_pack_start( GTK_BOX( hbox2 ), GTK_WIDGET( entry ), TRUE, TRUE, 0 );
				m_texture = entry;
				m_textureEntry.connect( entry );
				GlobalTextureEntryCompletion::instance().connect( entry );
			}
		}


		{
			GtkWidget* table = gtk_table_new( 6, 4, FALSE );
			gtk_widget_show( table );
			gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( table ), FALSE, FALSE, 0 );
			gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
			gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
			{
				GtkWidget* label = gtk_label_new( "Horizontal shift" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkSpinButton* spin = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 0 ) ), 0, 2 ) );
				m_hshiftIncrement.m_spin = spin;
				m_hshiftSpinner.connect( spin );
				gtk_widget_show( GTK_WIDGET( spin ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( spin ), 1, 2, 0, 1,
								  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( spin ), 60, -2 );
			}
			{
				GtkWidget* label = gtk_label_new( "Step" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 0, 1,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( entry ), 3, 4, 0, 1,
								  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( entry ), 50, -2 );
				m_hshiftIncrement.m_entry = entry;
				m_hshiftEntry.connect( entry );
			}
			{
				GtkWidget* label = gtk_label_new( "Vertical shift" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 1, 2,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkSpinButton* spin = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 0 ) ), 0, 2 ) );
				m_vshiftIncrement.m_spin = spin;
				m_vshiftSpinner.connect( spin );
				gtk_widget_show( GTK_WIDGET( spin ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( spin ), 1, 2, 1, 2,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( spin ), 60, -2 );
			}
			{
				GtkWidget* label = gtk_label_new( "Step" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 1, 2,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( entry ), 3, 4, 1, 2,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( entry ), 50, -2 );
				m_vshiftIncrement.m_entry = entry;
				m_vshiftEntry.connect( entry );
			}
			{
				GtkWidget* label = gtk_label_new( "Horizontal stretch" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 2, 3,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkSpinButton* spin = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 0 ) ), 0, 5 ) );
				m_hscaleIncrement.m_spin = spin;
				m_hscaleSpinner.connect( spin );
				gtk_widget_show( GTK_WIDGET( spin ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( spin ), 1, 2, 2, 3,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( spin ), 60, -2 );
			}
			{
				GtkWidget* label = gtk_label_new( "Step" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 2, 3,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 2, 3 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( entry ), 3, 4, 2, 3,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 2, 3 );
				gtk_widget_set_usize( GTK_WIDGET( entry ), 50, -2 );
				m_hscaleIncrement.m_entry = entry;
				m_hscaleEntry.connect( entry );
			}
			{
				GtkWidget* label = gtk_label_new( "Vertical stretch" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 3, 4,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkSpinButton* spin = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 0 ) ), 0, 5 ) );
				m_vscaleIncrement.m_spin = spin;
				m_vscaleSpinner.connect( spin );
				gtk_widget_show( GTK_WIDGET( spin ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( spin ), 1, 2, 3, 4,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( spin ), 60, -2 );
			}
			{
				GtkWidget* label = gtk_label_new( "Step" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 3, 4,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( entry ), 3, 4, 3, 4,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( entry ), 50, -2 );
				m_vscaleIncrement.m_entry = entry;
				m_vscaleEntry.connect( entry );
			}
			{
				GtkWidget* label = gtk_label_new( "Rotate" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 4, 5,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkSpinButton* spin = GTK_SPIN_BUTTON( gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 0, -8192, 8192, 2, 8, 0 ) ), 0, 2 ) );
				m_rotateIncrement.m_spin = spin;
				m_rotateSpinner.connect( spin );
				gtk_widget_show( GTK_WIDGET( spin ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( spin ), 1, 2, 4, 5,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( spin ), 60, -2 );
				gtk_spin_button_set_wrap( spin, TRUE );
			}
			{
				GtkWidget* label = gtk_label_new( "Step" );
				gtk_widget_show( label );
				gtk_misc_set_alignment( GTK_MISC( label ), 0, 0 );
				gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 4, 5,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
			}
			{
				GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
				gtk_widget_show( GTK_WIDGET( entry ) );
				gtk_table_attach( GTK_TABLE( table ), GTK_WIDGET( entry ), 3, 4, 4, 5,
								  (GtkAttachOptions) ( GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				gtk_widget_set_usize( GTK_WIDGET( entry ), 50, -2 );
				m_rotateIncrement.m_entry = entry;
				m_rotateEntry.connect( entry );
			}
			{
				// match grid button
				GtkWidget* button = gtk_button_new_with_label( "Match Grid" );
				gtk_widget_show( button );
				gtk_table_attach( GTK_TABLE( table ), button, 2, 4, 5, 6,
								  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
								  (GtkAttachOptions) ( 0 ), 0, 0 );
				g_signal_connect( G_OBJECT( button ), "clicked", G_CALLBACK( OnBtnMatchGrid ), 0 );
			}
		}

		{
			GtkWidget* frame = gtk_frame_new( "Texturing" );
			gtk_widget_show( frame );
			gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( frame ), FALSE, FALSE, 0 );
			{
				GtkWidget* table = gtk_table_new( 4, 4, FALSE );
				gtk_widget_show( table );
				gtk_container_add( GTK_CONTAINER( frame ), table );
				gtk_table_set_row_spacings( GTK_TABLE( table ), 5 );
				gtk_table_set_col_spacings( GTK_TABLE( table ), 5 );
				gtk_container_set_border_width( GTK_CONTAINER( table ), 5 );
				{
					GtkWidget* label = gtk_label_new( "Brush" );
					gtk_widget_show( label );
					gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 0, 1,
									  (GtkAttachOptions) ( GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
				}
				{
					GtkWidget* label = gtk_label_new( "Patch" );
					gtk_widget_show( label );
					gtk_table_attach( GTK_TABLE( table ), label, 0, 1, 2, 3,
									  (GtkAttachOptions) ( GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
				}
				{
					GtkWidget* label = gtk_label_new( "Width" );
					gtk_widget_show( label );
					gtk_table_attach( GTK_TABLE( table ), label, 2, 3, 0, 1,
									  (GtkAttachOptions) ( GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
				}
				{
					GtkWidget* label = gtk_label_new( "Height" );
					gtk_widget_show( label );
					gtk_table_attach( GTK_TABLE( table ), label, 3, 4, 0, 1,
									  (GtkAttachOptions) ( GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "Axial" );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 1, 2,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnAxial ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "Fit" );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 1, 2, 1, 2,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnFaceFit ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "CAP" );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 0, 1, 3, 4,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnPatchdetails ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "Set..." );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 1, 2, 3, 4,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnPatchreset ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "Natural" );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 2, 3, 3, 4,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnPatchnatural ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* button = gtk_button_new_with_label( "Fit" );
					gtk_widget_show( button );
					gtk_table_attach( GTK_TABLE( table ), button, 3, 4, 3, 4,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					g_signal_connect( G_OBJECT( button ), "clicked",
									  G_CALLBACK( OnBtnPatchFit ), 0 );
					gtk_widget_set_usize( button, 60, -2 );
				}
				{
					GtkWidget* spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 1, 0, 1 << 16, 1, 10, 0 ) ), 0, 6 );
					gtk_widget_show( spin );
					gtk_table_attach( GTK_TABLE( table ), spin, 2, 3, 1, 2,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					gtk_widget_set_usize( spin, 60, -2 );
					AddDialogData( *GTK_SPIN_BUTTON( spin ), m_fitHorizontal );
				}
				{
					GtkWidget* spin = gtk_spin_button_new( GTK_ADJUSTMENT( gtk_adjustment_new( 1, 0, 1 << 16, 1, 10, 0 ) ), 0, 6 );
					gtk_widget_show( spin );
					gtk_table_attach( GTK_TABLE( table ), spin, 3, 4, 1, 2,
									  (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
									  (GtkAttachOptions) ( 0 ), 0, 0 );
					gtk_widget_set_usize( spin, 60, -2 );
					AddDialogData( *GTK_SPIN_BUTTON( spin ), m_fitVertical );
				}
			}
		}
		if ( !string_empty( g_pGameDescription->getKeyValue( "si_flags" ) ) ) {
			{
				GtkFrame* frame = GTK_FRAME( gtk_frame_new( "Surface Flags" ) );
				gtk_widget_show( GTK_WIDGET( frame ) );
				gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( frame ), TRUE, TRUE, 0 );
				{
					GtkVBox* vbox3 = GTK_VBOX( gtk_vbox_new( FALSE, 4 ) );
					//gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
					gtk_widget_show( GTK_WIDGET( vbox3 ) );
					gtk_container_add( GTK_CONTAINER( frame ), GTK_WIDGET( vbox3 ) );
					{
						GtkTable* table = GTK_TABLE( gtk_table_new( 8, 4, FALSE ) );
						gtk_widget_show( GTK_WIDGET( table ) );
						gtk_box_pack_start( GTK_BOX( vbox3 ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
						gtk_table_set_row_spacings( table, 0 );
						gtk_table_set_col_spacings( table, 0 );

						GtkCheckButton** p = m_surfaceFlags;

						for ( int c = 0; c != 4; ++c )
						{
							for ( int r = 0; r != 8; ++r )
							{
								GtkCheckButton* check = GTK_CHECK_BUTTON( gtk_check_button_new_with_label( getSurfaceFlagName( c * 8 + r ) ) );
								gtk_widget_show( GTK_WIDGET( check ) );
								gtk_table_attach( table, GTK_WIDGET( check ), c, c + 1, r, r + 1,
												  (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
												  (GtkAttachOptions)( 0 ), 0, 0 );
								*p++ = check;
								guint handler_id = togglebutton_connect_toggled( GTK_TOGGLE_BUTTON( check ), ApplyFlagsCaller( *this ) );
								g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( handler_id ) );
							}
						}
					}
				}
			}
			{
				GtkFrame* frame = GTK_FRAME( gtk_frame_new( "Content Flags" ) );
				gtk_widget_show( GTK_WIDGET( frame ) );
				gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( frame ), TRUE, TRUE, 0 );
				{
					GtkVBox* vbox3 = GTK_VBOX( gtk_vbox_new( FALSE, 4 ) );
					//gtk_container_set_border_width(GTK_CONTAINER(vbox3), 4);
					gtk_widget_show( GTK_WIDGET( vbox3 ) );
					gtk_container_add( GTK_CONTAINER( frame ), GTK_WIDGET( vbox3 ) );
					{

						GtkTable* table = GTK_TABLE( gtk_table_new( 8, 4, FALSE ) );
						gtk_widget_show( GTK_WIDGET( table ) );
						gtk_box_pack_start( GTK_BOX( vbox3 ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
						gtk_table_set_row_spacings( table, 0 );
						gtk_table_set_col_spacings( table, 0 );

						GtkCheckButton** p = m_contentFlags;

						for ( int c = 0; c != 4; ++c )
						{
							for ( int r = 0; r != 8; ++r )
							{
								GtkCheckButton* check = GTK_CHECK_BUTTON( gtk_check_button_new_with_label( getContentFlagName( c * 8 + r ) ) );
								gtk_widget_show( GTK_WIDGET( check ) );
								gtk_table_attach( table, GTK_WIDGET( check ), c, c + 1, r, r + 1,
												  (GtkAttachOptions)( GTK_EXPAND | GTK_FILL ),
												  (GtkAttachOptions)( 0 ), 0, 0 );
								*p++ = check;
								guint handler_id = togglebutton_connect_toggled( GTK_TOGGLE_BUTTON( check ), ApplyFlagsCaller( *this ) );
								g_object_set_data( G_OBJECT( check ), "handler", gint_to_pointer( handler_id ) );
							}
						}

						// not allowed to modify detail flag using Surface Inspector
						gtk_widget_set_sensitive( GTK_WIDGET( m_contentFlags[BRUSH_DETAIL_FLAG] ), FALSE );
					}
				}
			}
			{
				GtkFrame* frame = GTK_FRAME( gtk_frame_new( "Value" ) );
				gtk_widget_show( GTK_WIDGET( frame ) );
				gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( frame ), TRUE, TRUE, 0 );
				{
					GtkVBox* vbox3 = GTK_VBOX( gtk_vbox_new( FALSE, 4 ) );
					gtk_container_set_border_width( GTK_CONTAINER( vbox3 ), 4 );
					gtk_widget_show( GTK_WIDGET( vbox3 ) );
					gtk_container_add( GTK_CONTAINER( frame ), GTK_WIDGET( vbox3 ) );

					{
						GtkEntry* entry = GTK_ENTRY( gtk_entry_new() );
						gtk_widget_show( GTK_WIDGET( entry ) );
						gtk_box_pack_start( GTK_BOX( vbox3 ), GTK_WIDGET( entry ), TRUE, TRUE, 0 );
						m_valueEntryWidget = entry;
						m_valueEntry.connect( entry );
					}
				}
			}
		}

#if TEXTOOL_ENABLED
		if ( g_bp_globals.m_texdefTypeId == TEXDEFTYPEID_BRUSHPRIMITIVES ) {
// Shamus: Textool goodies...
			GtkWidget * frame = gtk_frame_new( "Textool" );
			gtk_widget_show( frame );
			gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( frame ), FALSE, FALSE, 0 );
			{
				//Prolly should make this a member or global var, so the SI can draw on it...
				TexTool::g_textoolWin = glwidget_new( FALSE );
				// --> Dunno, but this stuff may be necessary... (Looks like it!)
				gtk_widget_ref( TexTool::g_textoolWin );
				gtk_widget_set_events( TexTool::g_textoolWin, GDK_DESTROY | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK );
				GTK_WIDGET_SET_FLAGS( TexTool::g_textoolWin, GTK_CAN_FOCUS );
				// <-- end stuff...
				gtk_widget_show( TexTool::g_textoolWin );
				gtk_widget_set_usize( TexTool::g_textoolWin, -1, 240 ); //Yeah!
				gtk_container_add( GTK_CONTAINER( frame ), TexTool::g_textoolWin );

				g_signal_connect( G_OBJECT( TexTool::g_textoolWin ), "size_allocate", G_CALLBACK( TexTool::size_allocate ), NULL );
				g_signal_connect( G_OBJECT( TexTool::g_textoolWin ), "expose_event", G_CALLBACK( TexTool::expose ), NULL );
				g_signal_connect( G_OBJECT( TexTool::g_textoolWin ), "button_press_event", G_CALLBACK( TexTool::button_press ), NULL );
				g_signal_connect( G_OBJECT( TexTool::g_textoolWin ), "button_release_event", G_CALLBACK( TexTool::button_release ), NULL );
				g_signal_connect( G_OBJECT( TexTool::g_textoolWin ), "motion_notify_event", G_CALLBACK( TexTool::motion ), NULL );
			}
			{
				GtkWidget * hbox = gtk_hbox_new( FALSE, 5 );
				gtk_widget_show( hbox );
				gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( hbox ), FALSE, FALSE, 0 );
				// Checkboxes go here... (Flip X/Y)
				GtkWidget * flipX = gtk_check_button_new_with_label( "Flip X axis" );
				GtkWidget * flipY = gtk_check_button_new_with_label( "Flip Y axis" );
				gtk_widget_show( flipX );
				gtk_widget_show( flipY );
				gtk_box_pack_start( GTK_BOX( hbox ), flipX, FALSE, FALSE, 0 );
				gtk_box_pack_start( GTK_BOX( hbox ), flipY, FALSE, FALSE, 0 );

//Instead of this, we probably need to create a vbox to put into the frame, then the
//window, then the hbox. !!! FIX !!!
//        gtk_container_add(GTK_CONTAINER(frame), hbox);

//Hmm. Do we really need g_object_set_data? Mebbe not... And we don't! :-)
//        g_object_set_data(G_OBJECT(flipX), "handler", gint_to_pointer(g_signal_connect(G_OBJECT(flipX), "toggled", G_CALLBACK(TexTool::flipX), 0)));
//        g_object_set_data(G_OBJECT(flipY), "handler", gint_to_pointer(g_signal_connect(G_OBJECT(flipY), "toggled", G_CALLBACK(TexTool::flipY), 0)));
//Instead, just do:
				g_signal_connect( G_OBJECT( flipX ), "toggled", G_CALLBACK( TexTool::flipX ), NULL );
				g_signal_connect( G_OBJECT( flipY ), "toggled", G_CALLBACK( TexTool::flipY ), NULL );
			}
		}
#endif
	}

	return window;
}

/*
   ==============
   Update

   Set the fields to the current texdef (i.e. map/texdef -> dialog widgets)
   if faces selected (instead of brushes) -> will read this face texdef, else current texdef
   if only patches selected, will read the patch texdef
   ===============
 */

void spin_button_set_value_no_signal( GtkSpinButton* spin, gdouble value ){
	guint handler_id = gpointer_to_int( g_object_get_data( G_OBJECT( spin ), "handler" ) );
	g_signal_handler_block( G_OBJECT( gtk_spin_button_get_adjustment( spin ) ), handler_id );
	gtk_spin_button_set_value( spin, value );
	g_signal_handler_unblock( G_OBJECT( gtk_spin_button_get_adjustment( spin ) ), handler_id );
}

void spin_button_set_step_increment( GtkSpinButton* spin, gdouble value ){
	GtkAdjustment* adjust = gtk_spin_button_get_adjustment( spin );
	adjust->step_increment = value;
}

void SurfaceInspector::Update(){
	const char * name = SurfaceInspector_GetSelectedShader();

	if ( shader_is_texture( name ) ) {
		gtk_entry_set_text( m_texture, shader_get_textureName( name ) );
	}
	else
	{
		gtk_entry_set_text( m_texture, "" );
	}

	texdef_t shiftScaleRotate;
//Shamus: This is where we get into trouble--the BP code tries to convert to a "faked"
//shift, rotate & scale values from the brush face, which seems to screw up for some reason.
//!!! FIX !!!
/*globalOutputStream() << "--> SI::Update. About to do ShiftScaleRotate_fromFace()...\n";
   SurfaceInspector_GetSelectedBPTexdef();
   globalOutputStream() << "BP: (" << g_selectedBrushPrimitTexdef.coords[0][0] << ", " << g_selectedBrushPrimitTexdef.coords[0][1] << ")("
    << g_selectedBrushPrimitTexdef.coords[1][0] << ", " << g_selectedBrushPrimitTexdef.coords[1][1] << ")("
    << g_selectedBrushPrimitTexdef.coords[0][2] << ", " << g_selectedBrushPrimitTexdef.coords[1][2] << ") SurfaceInspector::Update\n";//*/
//Ok, it's screwed up *before* we get here...
	ShiftScaleRotate_fromFace( shiftScaleRotate, SurfaceInspector_GetSelectedTexdef() );

	// normalize again to hide the ridiculously high scale values that get created when using texlock
	shiftScaleRotate.shift[0] = float_mod( shiftScaleRotate.shift[0], (float)g_selectedShaderSize[0] );
	shiftScaleRotate.shift[1] = float_mod( shiftScaleRotate.shift[1], (float)g_selectedShaderSize[1] );

	{
		spin_button_set_value_no_signal( m_hshiftIncrement.m_spin, shiftScaleRotate.shift[0] );
		spin_button_set_step_increment( m_hshiftIncrement.m_spin, g_si_globals.shift[0] );
		entry_set_float( m_hshiftIncrement.m_entry, g_si_globals.shift[0] );
	}

	{
		spin_button_set_value_no_signal( m_vshiftIncrement.m_spin, shiftScaleRotate.shift[1] );
		spin_button_set_step_increment( m_vshiftIncrement.m_spin, g_si_globals.shift[1] );
		entry_set_float( m_vshiftIncrement.m_entry, g_si_globals.shift[1] );
	}

	{
		spin_button_set_value_no_signal( m_hscaleIncrement.m_spin, shiftScaleRotate.scale[0] );
		spin_button_set_step_increment( m_hscaleIncrement.m_spin, g_si_globals.scale[0] );
		entry_set_float( m_hscaleIncrement.m_entry, g_si_globals.scale[0] );
	}

	{
		spin_button_set_value_no_signal( m_vscaleIncrement.m_spin, shiftScaleRotate.scale[1] );
		spin_button_set_step_increment( m_vscaleIncrement.m_spin, g_si_globals.scale[1] );
		entry_set_float( m_vscaleIncrement.m_entry, g_si_globals.scale[1] );
	}

	{
		spin_button_set_value_no_signal( m_rotateIncrement.m_spin, shiftScaleRotate.rotate );
		spin_button_set_step_increment( m_rotateIncrement.m_spin, g_si_globals.rotate );
		entry_set_float( m_rotateIncrement.m_entry, g_si_globals.rotate );
	}

	if ( !string_empty( g_pGameDescription->getKeyValue( "si_flags" ) ) ) {
		ContentsFlagsValue flags( SurfaceInspector_GetSelectedFlags() );

		entry_set_int( m_valueEntryWidget, flags.m_value );

		for ( GtkCheckButton** p = m_surfaceFlags; p != m_surfaceFlags + 32; ++p )
		{
			toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( *p ), flags.m_surfaceFlags & ( 1 << ( p - m_surfaceFlags ) ) );
		}

		for ( GtkCheckButton** p = m_contentFlags; p != m_contentFlags + 32; ++p )
		{
			toggle_button_set_active_no_signal( GTK_TOGGLE_BUTTON( *p ), flags.m_contentFlags & ( 1 << ( p - m_contentFlags ) ) );
		}
	}
}

/*
   ==============
   Apply

   Reads the fields to get the current texdef (i.e. widgets -> MAP)
   in brush primitive mode, grab the fake shift scale rot and compute a new texture matrix
   ===============
 */
void SurfaceInspector::ApplyShader(){
	StringOutputStream name( 256 );
	name << GlobalTexturePrefix_get() << gtk_entry_get_text( m_texture );

	// TTimo: detect and refuse invalid texture names (at least the ones with spaces)
	if ( !texdef_name_valid( name.c_str() ) ) {
		globalErrorStream() << "invalid texture name '" << name.c_str() << "'\n";
		SurfaceInspector_queueDraw();
		return;
	}

	UndoableCommand undo( "textureNameSetSelected" );
	Select_SetShader( name.c_str() );
}

void SurfaceInspector::ApplyTexdef(){
	texdef_t shiftScaleRotate;

	shiftScaleRotate.shift[0] = static_cast<float>( gtk_spin_button_get_value_as_float( m_hshiftIncrement.m_spin ) );
	shiftScaleRotate.shift[1] = static_cast<float>( gtk_spin_button_get_value_as_float( m_vshiftIncrement.m_spin ) );
	shiftScaleRotate.scale[0] = static_cast<float>( gtk_spin_button_get_value_as_float( m_hscaleIncrement.m_spin ) );
	shiftScaleRotate.scale[1] = static_cast<float>( gtk_spin_button_get_value_as_float( m_vscaleIncrement.m_spin ) );
	shiftScaleRotate.rotate = static_cast<float>( gtk_spin_button_get_value_as_float( m_rotateIncrement.m_spin ) );

	TextureProjection projection;
//Shamus: This is the other place that screws up, it seems, since it doesn't seem to do the
//conversion from the face (I think) and so bogus values end up in the thing... !!! FIX !!!
//This is actually OK. :-P
	ShiftScaleRotate_toFace( shiftScaleRotate, projection );

	UndoableCommand undo( "textureProjectionSetSelected" );
	Select_SetTexdef( projection );
}

void SurfaceInspector::ApplyFlags(){
	unsigned int surfaceflags = 0;
	for ( GtkCheckButton** p = m_surfaceFlags; p != m_surfaceFlags + 32; ++p )
	{
		if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( *p ) ) ) {
			surfaceflags |= ( 1 << ( p - m_surfaceFlags ) );
		}
	}

	unsigned int contentflags = 0;
	for ( GtkCheckButton** p = m_contentFlags; p != m_contentFlags + 32; ++p )
	{
		if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( *p ) ) ) {
			contentflags |= ( 1 << ( p - m_contentFlags ) );
		}
	}

	int value = entry_get_int( m_valueEntryWidget );

	UndoableCommand undo( "flagsSetSelected" );
	Select_SetFlags( ContentsFlagsValue( surfaceflags, contentflags, value, true ) );
}


void Face_getTexture( Face& face, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags ){
	shader = face.GetShader();
	face.GetTexdef( projection );
	flags = face.getShader().m_flags;
}
typedef Function4<Face&, CopiedString&, TextureProjection&, ContentsFlagsValue&, void, Face_getTexture> FaceGetTexture;

void Face_setTexture( Face& face, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags ){
	face.SetShader( shader );
	face.SetTexdef( projection );
	face.SetFlags( flags );
}
typedef Function4<Face&, const char*, const TextureProjection&, const ContentsFlagsValue&, void, Face_setTexture> FaceSetTexture;


void Patch_getTexture( Patch& patch, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags ){
	shader = patch.GetShader();
	projection = TextureProjection( texdef_t(), brushprimit_texdef_t(), Vector3( 0, 0, 0 ), Vector3( 0, 0, 0 ) );
	flags = ContentsFlagsValue( 0, 0, 0, false );
}
typedef Function4<Patch&, CopiedString&, TextureProjection&, ContentsFlagsValue&, void, Patch_getTexture> PatchGetTexture;

void Patch_setTexture( Patch& patch, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags ){
	patch.SetShader( shader );
}
typedef Function4<Patch&, const char*, const TextureProjection&, const ContentsFlagsValue&, void, Patch_setTexture> PatchSetTexture;


typedef Callback3<CopiedString&, TextureProjection&, ContentsFlagsValue&> GetTextureCallback;
typedef Callback3<const char*, const TextureProjection&, const ContentsFlagsValue&> SetTextureCallback;

struct Texturable
{
	GetTextureCallback getTexture;
	SetTextureCallback setTexture;
};


void Face_getClosest( Face& face, SelectionTest& test, SelectionIntersection& bestIntersection, Texturable& texturable ){
	SelectionIntersection intersection;
	face.testSelect( test, intersection );
	if ( intersection.valid()
		 && SelectionIntersection_closer( intersection, bestIntersection ) ) {
		bestIntersection = intersection;
		texturable.setTexture = makeCallback3( FaceSetTexture(), face );
		texturable.getTexture = makeCallback3( FaceGetTexture(), face );
	}
}


class OccludeSelector : public Selector
{
SelectionIntersection& m_bestIntersection;
bool& m_occluded;
public:
OccludeSelector( SelectionIntersection& bestIntersection, bool& occluded ) : m_bestIntersection( bestIntersection ), m_occluded( occluded ){
	m_occluded = false;
}
void pushSelectable( Selectable& selectable ){
}
void popSelectable(){
}
void addIntersection( const SelectionIntersection& intersection ){
	if ( SelectionIntersection_closer( intersection, m_bestIntersection ) ) {
		m_bestIntersection = intersection;
		m_occluded = true;
	}
}
};

class BrushGetClosestFaceVisibleWalker : public scene::Graph::Walker
{
SelectionTest& m_test;
Texturable& m_texturable;
mutable SelectionIntersection m_bestIntersection;
public:
BrushGetClosestFaceVisibleWalker( SelectionTest& test, Texturable& texturable ) : m_test( test ), m_texturable( texturable ){
}
bool pre( const scene::Path& path, scene::Instance& instance ) const {
	if ( path.top().get().visible() ) {
		BrushInstance* brush = Instance_getBrush( instance );
		if ( brush != 0 ) {
			m_test.BeginMesh( brush->localToWorld() );

			for ( Brush::const_iterator i = brush->getBrush().begin(); i != brush->getBrush().end(); ++i )
			{
				Face_getClosest( *( *i ), m_test, m_bestIntersection, m_texturable );
			}
		}
		else
		{
			SelectionTestable* selectionTestable = Instance_getSelectionTestable( instance );
			if ( selectionTestable ) {
				bool occluded;
				OccludeSelector selector( m_bestIntersection, occluded );
				selectionTestable->testSelect( selector, m_test );
				if ( occluded ) {
					Patch* patch = Node_getPatch( path.top() );
					if ( patch != 0 ) {
						m_texturable.setTexture = makeCallback3( PatchSetTexture(), *patch );
						m_texturable.getTexture = makeCallback3( PatchGetTexture(), *patch );
					}
					else
					{
						m_texturable = Texturable();
					}
				}
			}
		}
	}
	return true;
}
};

Texturable Scene_getClosestTexturable( scene::Graph& graph, SelectionTest& test ){
	Texturable texturable;
	graph.traverse( BrushGetClosestFaceVisibleWalker( test, texturable ) );
	return texturable;
}

bool Scene_getClosestTexture( scene::Graph& graph, SelectionTest& test, CopiedString& shader, TextureProjection& projection, ContentsFlagsValue& flags ){
	Texturable texturable = Scene_getClosestTexturable( graph, test );
	if ( texturable.getTexture != GetTextureCallback() ) {
		texturable.getTexture( shader, projection, flags );
		return true;
	}
	return false;
}

void Scene_setClosestTexture( scene::Graph& graph, SelectionTest& test, const char* shader, const TextureProjection& projection, const ContentsFlagsValue& flags ){
	Texturable texturable = Scene_getClosestTexturable( graph, test );
	if ( texturable.setTexture != SetTextureCallback() ) {
		texturable.setTexture( shader, projection, flags );
	}
}


class FaceTexture
{
public:
TextureProjection m_projection;
ContentsFlagsValue m_flags;
};

FaceTexture g_faceTextureClipboard;

void FaceTextureClipboard_setDefault(){
	g_faceTextureClipboard.m_flags = ContentsFlagsValue( 0, 0, 0, false );
	TexDef_Construct_Default( g_faceTextureClipboard.m_projection );
}

void TextureClipboard_textureSelected( const char* shader ){
	FaceTextureClipboard_setDefault();
}

class TextureBrowser;
extern TextureBrowser g_TextureBrowser;
void TextureBrowser_SetSelectedShader( TextureBrowser& textureBrowser, const char* shader );
const char* TextureBrowser_GetSelectedShader( TextureBrowser& textureBrowser );

void Scene_copyClosestTexture( SelectionTest& test ){
	CopiedString shader;
	if ( Scene_getClosestTexture( GlobalSceneGraph(), test, shader, g_faceTextureClipboard.m_projection, g_faceTextureClipboard.m_flags ) ) {
		TextureBrowser_SetSelectedShader( g_TextureBrowser, shader.c_str() );
	}
}

void Scene_applyClosestTexture( SelectionTest& test ){
	UndoableCommand command( "facePaintTexture" );

	Scene_setClosestTexture( GlobalSceneGraph(), test, TextureBrowser_GetSelectedShader( g_TextureBrowser ), g_faceTextureClipboard.m_projection, g_faceTextureClipboard.m_flags );

	SceneChangeNotify();
}





void SelectedFaces_copyTexture(){
	if ( !g_SelectedFaceInstances.empty() ) {
		Face& face = g_SelectedFaceInstances.last().getFace();
		face.GetTexdef( g_faceTextureClipboard.m_projection );
		g_faceTextureClipboard.m_flags = face.getShader().m_flags;

		TextureBrowser_SetSelectedShader( g_TextureBrowser, face.getShader().getShader() );
	}
}

void FaceInstance_pasteTexture( FaceInstance& faceInstance ){
	faceInstance.getFace().SetTexdef( g_faceTextureClipboard.m_projection );
	faceInstance.getFace().SetShader( TextureBrowser_GetSelectedShader( g_TextureBrowser ) );
	faceInstance.getFace().SetFlags( g_faceTextureClipboard.m_flags );
	SceneChangeNotify();
}

bool SelectedFaces_empty(){
	return g_SelectedFaceInstances.empty();
}

void SelectedFaces_pasteTexture(){
	UndoableCommand command( "facePasteTexture" );
	g_SelectedFaceInstances.foreach( FaceInstance_pasteTexture );
}



void SurfaceInspector_constructPreferences( PreferencesPage& page ){
	page.appendCheckBox( "", "Surface Inspector Increments Match Grid", g_si_globals.m_bSnapTToGrid );
}
void SurfaceInspector_constructPage( PreferenceGroup& group ){
	PreferencesPage page( group.createPage( "Surface Inspector", "Surface Inspector Preferences" ) );
	SurfaceInspector_constructPreferences( page );
}
void SurfaceInspector_registerPreferencesPage(){
	PreferencesDialog_addSettingsPage( FreeCaller1<PreferenceGroup&, SurfaceInspector_constructPage>() );
}

void SurfaceInspector_registerCommands(){
	GlobalCommands_insert( "FitTexture", FreeCaller<SurfaceInspector_FitTexture>(), Accelerator( 'B', (GdkModifierType)GDK_SHIFT_MASK ) );
	GlobalCommands_insert( "SurfaceInspector", FreeCaller<SurfaceInspector_toggleShown>(), Accelerator( 'S' ) );

	GlobalCommands_insert( "FaceCopyTexture", FreeCaller<SelectedFaces_copyTexture>() );
	GlobalCommands_insert( "FacePasteTexture", FreeCaller<SelectedFaces_pasteTexture>() );
}


#include "preferencesystem.h"


void SurfaceInspector_Construct(){
	g_SurfaceInspector = new SurfaceInspector;

	SurfaceInspector_registerCommands();

	FaceTextureClipboard_setDefault();

	GlobalPreferenceSystem().registerPreference( "SurfaceWnd", getSurfaceInspector().m_importPosition, getSurfaceInspector().m_exportPosition );
	GlobalPreferenceSystem().registerPreference( "SI_SurfaceTexdef_Scale1", FloatImportStringCaller( g_si_globals.scale[0] ), FloatExportStringCaller( g_si_globals.scale[0] ) );
	GlobalPreferenceSystem().registerPreference( "SI_SurfaceTexdef_Scale2", FloatImportStringCaller( g_si_globals.scale[1] ), FloatExportStringCaller( g_si_globals.scale[1] ) );
	GlobalPreferenceSystem().registerPreference( "SI_SurfaceTexdef_Shift1", FloatImportStringCaller( g_si_globals.shift[0] ), FloatExportStringCaller( g_si_globals.shift[0] ) );
	GlobalPreferenceSystem().registerPreference( "SI_SurfaceTexdef_Shift2", FloatImportStringCaller( g_si_globals.shift[1] ), FloatExportStringCaller( g_si_globals.shift[1] ) );
	GlobalPreferenceSystem().registerPreference( "SI_SurfaceTexdef_Rotate", FloatImportStringCaller( g_si_globals.rotate ), FloatExportStringCaller( g_si_globals.rotate ) );
	GlobalPreferenceSystem().registerPreference( "SnapTToGrid", BoolImportStringCaller( g_si_globals.m_bSnapTToGrid ), BoolExportStringCaller( g_si_globals.m_bSnapTToGrid ) );

	typedef FreeCaller1<const Selectable&, SurfaceInspector_SelectionChanged> SurfaceInspectorSelectionChangedCaller;
	GlobalSelectionSystem().addSelectionChangeCallback( SurfaceInspectorSelectionChangedCaller() );
	typedef FreeCaller<SurfaceInspector_updateSelection> SurfaceInspectorUpdateSelectionCaller;
	Brush_addTextureChangedCallback( SurfaceInspectorUpdateSelectionCaller() );
	Patch_addTextureChangedCallback( SurfaceInspectorUpdateSelectionCaller() );

	SurfaceInspector_registerPreferencesPage();
}
void SurfaceInspector_Destroy(){
	delete g_SurfaceInspector;
}



#if TEXTOOL_ENABLED

namespace TexTool { // namespace hides these symbols from other object-files
//
//Shamus: Textool functions, including GTK+ callbacks
//

//NOTE: Black screen when TT first comes up is caused by an uninitialized Extent... !!! FIX !!!
//      But... You can see down below that it *is* initialized! WTF?
struct Extent
{
	float minX, minY, maxX, maxY;
	float width( void ) { return fabs( maxX - minX ); }
	float height( void ) { return fabs( maxY - minY ); }
};

//This seems to control the texture scale... (Yep! ;-)
Extent extents = { -2.0f, -2.0f, +2.0f, +2.0f };
brushprimit_texdef_t tm;                        // Texture transform matrix
Vector2 pts[c_brush_maxFaces];
Vector2 center;
int numPts;
int textureNum;
Vector2 textureSize;
Vector2 windowSize;
#define VP_PADDING  1.2
#define PI          3.14159265358979
bool lButtonDown = false;
bool rButtonDown = false;
//int dragPoint;
//int anchorPoint;
bool haveAnchor = false;
brushprimit_texdef_t currentBP;
brushprimit_texdef_t origBP;                    // Original brush primitive (before we muck it up)
float controlRadius = 5.0f;
float rotationAngle = 0.0f;
float rotationAngle2 = 0.0f;
float oldRotationAngle;
Vector2 rotationPoint;
bool translatingX = false;                      // Widget state variables
bool translatingY = false;
bool scalingX = false;
bool scalingY = false;
bool rotating = false;
bool resizingX = false;                         // Not sure what this means... :-/
bool resizingY = false;
float origAngle, origScaleX, origScaleY;
Vector2 oldCenter;


// Function prototypes (move up to top later...)

void DrawCircularArc( Vector2 ctr, float startAngle, float endAngle, float radius );


void CopyPointsFromSelectedFace( void ){
	// Make sure that there's a face and winding to get!

	if ( g_SelectedFaceInstances.empty() ) {
		numPts = 0;
		return;
	}

	Face & face = g_SelectedFaceInstances.last().getFace();
	textureNum = face.getShader().m_state->getTexture().texture_number;
	textureSize.x() = face.getShader().m_state->getTexture().width;
	textureSize.y() = face.getShader().m_state->getTexture().height;
//globalOutputStream() << "--> Texture #" << textureNum << ": " << textureSize.x() << " x " << textureSize.y() << "...\n";

	currentBP = SurfaceInspector_GetSelectedTexdef().m_brushprimit_texdef;

	face.EmitTextureCoordinates();
	Winding & w = face.getWinding();
	int count = 0;

	for ( Winding::const_iterator i = w.begin(); i != w.end(); i++ )
	{
		//globalOutputStream() << (*i).texcoord.x() << " " << (*i).texcoord.y() << ", ";
		pts[count].x() = ( *i ).texcoord.x();
		pts[count].y() = ( *i ).texcoord.y();
		count++;
	}

	numPts = count;

	//globalOutputStream() << " ..copied points\n";
}

brushprimit_texdef_t bp;
//This approach is probably wrongheaded and just not right anyway. So, !!! FIX !!! [DONE]
void CommitChanges( void ){
	texdef_t t;                                 // Throwaway, since this is BP only

	bp.coords[0][0] = tm.coords[0][0] * origBP.coords[0][0] + tm.coords[0][1] * origBP.coords[1][0];
	bp.coords[0][1] = tm.coords[0][0] * origBP.coords[0][1] + tm.coords[0][1] * origBP.coords[1][1];
	bp.coords[0][2] = tm.coords[0][0] * origBP.coords[0][2] + tm.coords[0][1] * origBP.coords[1][2] + tm.coords[0][2];
//Ok, this works for translation...
//	bp.coords[0][2] = tm.coords[0][0] * origBP.coords[0][2] + tm.coords[0][1] * origBP.coords[1][2] + tm.coords[0][2] * textureSize.x();
	bp.coords[1][0] = tm.coords[1][0] * origBP.coords[0][0] + tm.coords[1][1] * origBP.coords[1][0];
	bp.coords[1][1] = tm.coords[1][0] * origBP.coords[0][1] + tm.coords[1][1] * origBP.coords[1][1];
	bp.coords[1][2] = tm.coords[1][0] * origBP.coords[0][2] + tm.coords[1][1] * origBP.coords[1][2] + tm.coords[1][2];
//	bp.coords[1][2] = tm.coords[1][0] * origBP.coords[0][2] + tm.coords[1][1] * origBP.coords[1][2] + tm.coords[1][2] * textureSize.y();

//This doesn't work:	g_brush_texture_changed();
// Let's try this:
//Note: We should only set an undo *after* the button has been released... !!! FIX !!!
//Definitely *should* have an undo, though!
//  UndoableCommand undo("textureProjectionSetSelected");
	Select_SetTexdef( TextureProjection( t, bp, Vector3( 0, 0, 0 ), Vector3( 0, 0, 0 ) ) );
//This is working, but for some reason the translate is causing the rest of the SI
//widgets to yield bad readings... !!! FIX !!!
//I.e., click on textool window, translate face wireframe, then controls go crazy. Dunno why.
//It's because there were some uncommented out add/removeScale functions in brush.h and a
//removeScale in brushmanip.cpp... :-/
//Translate isn't working at all now... :-(
//It's because we need to multiply in some scaling factor (prolly the texture width/height)
//Yep. :-P
}

void UpdateControlPoints( void ){
	CommitChanges();

	// Init texture transform matrix

	tm.coords[0][0] = 1.0f; tm.coords[0][1] = 0.0f; tm.coords[0][2] = 0.0f;
	tm.coords[1][0] = 0.0f; tm.coords[1][1] = 1.0f; tm.coords[1][2] = 0.0f;
}


/*
   For shifting we have:
 */
/*
   The code that should provide reasonable defaults, but doesn't for some reason:
   It's scaling the BP by 128 for some reason, between the time it's created and the
   time we get back to the SI widgets:

   static void OnBtnAxial(GtkWidget *widget, gpointer data)
   {
   UndoableCommand undo("textureDefault");
   TextureProjection projection;
   TexDef_Construct_Default(projection);
   Select_SetTexdef(projection);
   }

   Select_SetTexdef() calls Scene_BrushSetTexdef_Component_Selected(GlobalSceneGraph(), projection)
   which is in brushmanip.h: This eventually calls
   Texdef_Assign(m_texdef, texdef, m_brushprimit_texdef, brushprimit_texdef) in class Face...
   which just copies from brushpr to m_brushpr...
 */

//Small problem with this thing: It's scaled to the texture which is all screwed up... !!! FIX !!! [DONE]
//Prolly should separate out the grid drawing so that we can draw it behind the polygon.
const float gridWidth = 1.3f; // Let's try an absolute height... WORKS!!!
// NOTE that 2.0 is the height of the viewport. Dunno why... Should make collision
//      detection easier...
const float gridRadius = gridWidth * 0.5f;

typedef const float WidgetColor[3];
const WidgetColor widgetColor[10] = {
	{ 1.0000f, 0.2000f, 0.0000f },          // Red
	{ 0.9137f, 0.9765f, 0.4980f },          // Yellow
	{ 0.0000f, 0.6000f, 0.3216f },          // Green
	{ 0.6157f, 0.7726f, 0.8196f },          // Cyan
	{ 0.4980f, 0.5000f, 0.4716f },          // Grey

	// Highlight colors
	{ 1.0000f, 0.6000f, 0.4000f },          // Light Red
	{ 1.0000f, 1.0000f, 0.8980f },          // Light Yellow
	{ 0.4000f, 1.0000f, 0.7216f },          // Light Green
	{ 1.0000f, 1.0000f, 1.0000f },          // Light Cyan
	{ 0.8980f, 0.9000f, 0.8716f }           // Light Grey
};

#define COLOR_RED           0
#define COLOR_YELLOW        1
#define COLOR_GREEN         2
#define COLOR_CYAN          3
#define COLOR_GREY          4
#define COLOR_LT_RED        5
#define COLOR_LT_YELLOW     6
#define COLOR_LT_GREEN      7
#define COLOR_LT_CYAN       8
#define COLOR_LT_GREY       9

void DrawControlWidgets( void ){
//Note that the grid should go *behind* the face outline... !!! FIX !!!
	// Grid
	float xStart = center.x() - ( gridWidth / 2.0f );
	float yStart = center.y() - ( gridWidth / 2.0f );
	float xScale = ( extents.height() / extents.width() ) * ( textureSize.y() / textureSize.x() );

	glPushMatrix();
//Small problem with this approach: Changing the center point in the TX code doesn't seem to
//change anything here--prolly because we load a new identity matrix. A couple of ways to fix
//this would be to get rid of that code, or change the center to a new point by taking into
//account the transforms that we toss with the new identity matrix. Dunno which is better.
	glLoadIdentity();
	glScalef( xScale, 1.0, 1.0 );           // Will that square it up? Yup.
	glRotatef( static_cast<float>( radians_to_degrees( atan2( -currentBP.coords[0][1], currentBP.coords[0][0] ) ) ), 0.0, 0.0, -1.0 );
	glTranslatef( -center.x(), -center.y(), 0.0 );

	// Circle
	glColor3fv( translatingX && translatingY ? widgetColor[COLOR_LT_YELLOW] : widgetColor[COLOR_YELLOW] );
	glBegin( GL_LINE_LOOP );
	DrawCircularArc( center, 0, 2.0f * PI, gridRadius * 0.16 );

	glEnd();

	// Axes
	glBegin( GL_LINES );
	glColor3fv( translatingY && !translatingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN] );
	glVertex2f( center.x(), center.y() + ( gridRadius * 0.16 ) );
	glVertex2f( center.x(), center.y() + ( gridRadius * 1.00 ) );
	glColor3fv( translatingX && !translatingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED] );
	glVertex2f( center.x() + ( gridRadius * 0.16 ), center.y() );
	glVertex2f( center.x() + ( gridRadius * 1.00 ), center.y() );
	glEnd();

	// Arrowheads
	glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
	glBegin( GL_TRIANGLES );
	glColor3fv( translatingY && !translatingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN] );
	glVertex2f( center.x(), center.y() + ( gridRadius * 1.10 ) );
	glVertex2f( center.x() + ( gridRadius * 0.06 ), center.y() + ( gridRadius * 0.94 ) );
	glVertex2f( center.x() - ( gridRadius * 0.06 ), center.y() + ( gridRadius * 0.94 ) );
	glColor3fv( translatingX && !translatingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED] );
	glVertex2f( center.x() + ( gridRadius * 1.10 ), center.y() );
	glVertex2f( center.x() + ( gridRadius * 0.94 ), center.y() + ( gridRadius * 0.06 ) );
	glVertex2f( center.x() + ( gridRadius * 0.94 ), center.y() - ( gridRadius * 0.06 ) );
	glEnd();

	// Arc
	glBegin( GL_LINE_STRIP );
	glColor3fv( rotating ? widgetColor[COLOR_LT_CYAN] : widgetColor[COLOR_CYAN] );
	DrawCircularArc( center, 0.03f * PI, 0.47f * PI, gridRadius * 0.90 );
	glEnd();

	// Boxes
	glColor3fv( scalingY && !scalingX ? widgetColor[COLOR_LT_GREEN] : widgetColor[COLOR_GREEN] );
	glBegin( GL_LINES );
	glVertex2f( center.x() + ( gridRadius * 0.20 ), center.y() + ( gridRadius * 1.50 ) );
	glVertex2f( center.x() - ( gridRadius * 0.20 ), center.y() + ( gridRadius * 1.50 ) );
	glEnd();
	glBegin( GL_LINE_LOOP );
	glVertex2f( center.x() + ( gridRadius * 0.10 ), center.y() + ( gridRadius * 1.40 ) );
	glVertex2f( center.x() - ( gridRadius * 0.10 ), center.y() + ( gridRadius * 1.40 ) );
	glVertex2f( center.x() - ( gridRadius * 0.10 ), center.y() + ( gridRadius * 1.20 ) );
	glVertex2f( center.x() + ( gridRadius * 0.10 ), center.y() + ( gridRadius * 1.20 ) );
	glEnd();

	glColor3fv( scalingX && !scalingY ? widgetColor[COLOR_LT_RED] : widgetColor[COLOR_RED] );
	glBegin( GL_LINES );
	glVertex2f( center.x() + ( gridRadius * 1.50 ), center.y() + ( gridRadius * 0.20 ) );
	glVertex2f( center.x() + ( gridRadius * 1.50 ), center.y() - ( gridRadius * 0.20 ) );
	glEnd();
	glBegin( GL_LINE_LOOP );
	glVertex2f( center.x() + ( gridRadius * 1.40 ), center.y() + ( gridRadius * 0.10 ) );
	glVertex2f( center.x() + ( gridRadius * 1.40 ), center.y() - ( gridRadius * 0.10 ) );
	glVertex2f( center.x() + ( gridRadius * 1.20 ), center.y() - ( gridRadius * 0.10 ) );
	glVertex2f( center.x() + ( gridRadius * 1.20 ), center.y() + ( gridRadius * 0.10 ) );
	glEnd();

	glColor3fv( scalingX && scalingY ? widgetColor[COLOR_LT_CYAN] : widgetColor[COLOR_CYAN] );
	glBegin( GL_LINE_STRIP );
	glVertex2f( center.x() + ( gridRadius * 1.50 ), center.y() + ( gridRadius * 1.10 ) );
	glVertex2f( center.x() + ( gridRadius * 1.50 ), center.y() + ( gridRadius * 1.50 ) );
	glVertex2f( center.x() + ( gridRadius * 1.10 ), center.y() + ( gridRadius * 1.50 ) );
	glEnd();
	glBegin( GL_LINE_LOOP );
	glVertex2f( center.x() + ( gridRadius * 1.40 ), center.y() + ( gridRadius * 1.40 ) );
	glVertex2f( center.x() + ( gridRadius * 1.40 ), center.y() + ( gridRadius * 1.20 ) );
	glVertex2f( center.x() + ( gridRadius * 1.20 ), center.y() + ( gridRadius * 1.20 ) );
	glVertex2f( center.x() + ( gridRadius * 1.20 ), center.y() + ( gridRadius * 1.40 ) );
	glEnd();

	glPopMatrix();
}

void DrawControlPoints( void ){
	glColor3f( 1, 1, 1 );
	glBegin( GL_LINE_LOOP );

	for ( int i = 0; i < numPts; i++ )
		glVertex2f( pts[i].x(), pts[i].y() );

	glEnd();
}

// Note: Setup and all that jazz must be done by the caller!

void DrawCircularArc( Vector2 ctr, float startAngle, float endAngle, float radius ){
	float stepSize = ( 2.0f * PI ) / 200.0f;

	for ( float angle = startAngle; angle <= endAngle; angle += stepSize )
		glVertex2f( ctr.x() + radius * cos( angle ), ctr.y() + radius * sin( angle ) );
}


void focus(){
	if ( numPts == 0 ) {
		return;
	}

	// Find selected texture's extents...

	extents.minX = extents.maxX = pts[0].x(),
	extents.minY = extents.maxY = pts[0].y();

	for ( int i = 1; i < numPts; i++ )
	{
		if ( pts[i].x() < extents.minX ) {
			extents.minX = pts[i].x();
		}
		if ( pts[i].x() > extents.maxX ) {
			extents.maxX = pts[i].x();
		}
		if ( pts[i].y() < extents.minY ) {
			extents.minY = pts[i].y();
		}
		if ( pts[i].y() > extents.maxY ) {
			extents.maxY = pts[i].y();
		}
	}

	// Do some viewport fitting stuff...

//globalOutputStream() << "--> Center: " << center.x() << ", " << center.y() << "\n";
//globalOutputStream() << "--> Extents (stage 1): " << extents.minX << ", "
//	<< extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";
	// TTimo: Apply a ratio to get the area we'll draw.
	center.x() = 0.5f * ( extents.minX + extents.maxX ),
		center.y() = 0.5f * ( extents.minY + extents.maxY );
	extents.minX = center.x() + VP_PADDING * ( extents.minX - center.x() ),
	extents.minY = center.y() + VP_PADDING * ( extents.minY - center.y() ),
	extents.maxX = center.x() + VP_PADDING * ( extents.maxX - center.x() ),
	extents.maxY = center.y() + VP_PADDING * ( extents.maxY - center.y() );
//globalOutputStream() << "--> Extents (stage 2): " << extents.minX << ", "
//	<< extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";

	// TTimo: We want a texture with the same X / Y ratio.
	// TTimo: Compute XY space / window size ratio.
	float SSize = extents.width(), TSize = extents.height();
	float ratioX = textureSize.x() * extents.width() / windowSize.x(),
		  ratioY = textureSize.y() * extents.height() / windowSize.y();
//globalOutputStream() << "--> Texture size: " << textureSize.x() << ", " << textureSize.y() << "\n";
//globalOutputStream() << "--> Window size: " << windowSize.x() << ", " << windowSize.y() << "\n";

	if ( ratioX > ratioY ) {
		TSize = ( windowSize.y() * ratioX ) / textureSize.y();
//		TSize = extents.width() * (windowSize.y() / windowSize.x()) * (textureSize.x() / textureSize.y());
	}
	else
	{
		SSize = ( windowSize.x() * ratioY ) / textureSize.x();
//		SSize = extents.height() * (windowSize.x() / windowSize.y()) * (textureSize.y() / textureSize.x());
	}

	extents.minX = center.x() - 0.5f * SSize, extents.maxX = center.x() + 0.5f * SSize,
	extents.minY = center.y() - 0.5f * TSize, extents.maxY = center.y() + 0.5f * TSize;
//globalOutputStream() << "--> Extents (stage 3): " << extents.minX << ", "
//	<< extents.maxX << ", " << extents.minY << ", " << extents.maxY << "\n";
}

gboolean size_allocate( GtkWidget * win, GtkAllocation * a, gpointer ){
	windowSize.x() = a->width;
	windowSize.y() = a->height;
	queueDraw();
	return false;
}

gboolean expose( GtkWidget * win, GdkEventExpose * e, gpointer ){
//	globalOutputStream() << "--> Textool Window was exposed!\n";
//	globalOutputStream() << "    (window width/height: " << cc << "/" << e->area.height << ")\n";

//	windowSize.x() = e->area.width, windowSize.y() = e->area.height;
//This needs to go elsewhere...
//	InitTextool();

	if ( glwidget_make_current( win ) == FALSE ) {
		globalOutputStream() << "    FAILED to make current! Oh, the agony! :-(\n";
		return true;
	}

	CopyPointsFromSelectedFace();

	if ( !lButtonDown ) {
		focus();
	}

	// Probably should init button/anchor states here as well...
//	rotationAngle = 0.0f;
	glClearColor( 0, 0, 0, 0 );
	glViewport( 0, 0, e->area.width, e->area.height );
	glMatrixMode( GL_PROJECTION );
	glLoadIdentity();

//???
	glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT );
	glDisable( GL_DEPTH_TEST );
	glDisable( GL_BLEND );

	glOrtho( extents.minX, extents.maxX, extents.maxY, extents.minY, -1, 1 );

	glColor3f( 1, 1, 1 );
	// draw the texture background
	glPolygonMode( GL_FRONT_AND_BACK, GL_FILL );
	glBindTexture( GL_TEXTURE_2D, textureNum );

	glEnable( GL_TEXTURE_2D );
	glBegin( GL_QUADS );
	glTexCoord2f( extents.minX, extents.minY );
	glVertex2f( extents.minX, extents.minY );
	glTexCoord2f( extents.maxX, extents.minY );
	glVertex2f( extents.maxX, extents.minY );
	glTexCoord2f( extents.maxX, extents.maxY );
	glVertex2f( extents.maxX, extents.maxY );
	glTexCoord2f( extents.minX, extents.maxY );
	glVertex2f( extents.minX, extents.maxY );
	glEnd();
	glDisable( GL_TEXTURE_2D );

	// draw the texture-space grid
	glColor3fv( widgetColor[COLOR_GREY] );
	glBegin( GL_LINES );

	const int gridSubdivisions = 8;
	const float gridExtents = 4.0f;

	for ( int i = 0; i < gridSubdivisions + 1; ++i )
	{
		float y = i * ( gridExtents / float(gridSubdivisions) );
		float x = i * ( gridExtents / float(gridSubdivisions) );
		glVertex2f( 0, y );
		glVertex2f( gridExtents, y );
		glVertex2f( x, 0 );
		glVertex2f( x, gridExtents );
	}

	glEnd();

	DrawControlPoints();
	DrawControlWidgets();
//???
	// reset the current texture
//  glBindTexture(GL_TEXTURE_2D, 0);
//  glFinish();
	glwidget_swap_buffers( win );

	return false;
}

/*int FindSelectedPoint(int x, int y)
   {
    for(int i=0; i<numPts; i++)
    {
        int nx = (int)(windowSize.x() * (pts[i].x() - extents.minX) / extents.width());
        int ny = (int)(windowSize.y() * (pts[i].y() - extents.minY) / extents.height());

        if (abs(nx - x) <= 3 && abs(ny - y) <= 3)
            return i;
    }

    return -1;
   }//*/

Vector2 trans;
Vector2 trans2;
Vector2 dragPoint;  // Defined in terms of window space (+x/-y)
Vector2 oldTrans;
gboolean button_press( GtkWidget * win, GdkEventButton * e, gpointer ){
//	globalOutputStream() << "--> Textool button press...\n";

	if ( e->button == 1 ) {
		lButtonDown = true;
		GlobalUndoSystem().start();

		origBP = currentBP;

		//globalOutputStream() << "--> Original BP: [" << origBP.coords[0][0] << "][" << origBP.coords[0][1] << "][" << origBP.coords[0][2] << "]\n";
		//globalOutputStream() << "                 [" << origBP.coords[1][0] << "][" << origBP.coords[1][1] << "][" << origBP.coords[1][2] << "]\n";
		//float angle = atan2(origBP.coords[0][1], origBP.coords[0][0]) * 180.0f / 3.141592653589f;
		origAngle = ( origBP.coords[0][1] > 0 ? PI : -PI ); // Could also be -PI... !!! FIX !!! [DONE]

		if ( origBP.coords[0][0] != 0.0f ) {
			origAngle = atan( origBP.coords[0][1] / origBP.coords[0][0] );
		}

		origScaleX = origBP.coords[0][0] / cos( origAngle );
		origScaleY = origBP.coords[1][1] / cos( origAngle );
		rotationAngle = origAngle;
		oldCenter[0] = oldCenter[1] = 0;

		//globalOutputStream() << "--> BP stats: ang=" << origAngle * RAD_TO_DEG << ", scale=" << origScaleX << "/" << origScaleY << "\n";
		//Should also set the Flip X/Y checkboxes here as well... !!! FIX !!!
		//Also: should reverse texture left/right up/down instead of flipping the points...

//disnowok
//float nx = windowSize.x() * (e->x - extents.minX) / (extents.maxX - extents.minX);
//float ny = windowSize.y() * (e->y - extents.minY) / (extents.maxY - extents.minY);
//disdoes...
//But I want it to scroll the texture window, not the points... !!! FIX !!!
//Actually, should scroll the texture window only when mouse is down on no widgets...
		float nx = e->x / windowSize.x() * extents.width() + extents.minX;
		float ny = e->y / windowSize.y() * extents.height() + extents.minY;
		trans.x() = -tm.coords[0][0] * nx - tm.coords[0][1] * ny;
		trans.y() = -tm.coords[1][0] * nx - tm.coords[1][1] * ny;

		dragPoint.x() = e->x, dragPoint.y() = e->y;
		trans2.x() = nx, trans2.y() = ny;
		oldRotationAngle = rotationAngle;
//		oldTrans.x() = tm.coords[0][2] - nx * textureSize.x();
//		oldTrans.y() = tm.coords[1][2] - ny * textureSize.y();
		oldTrans.x() = tm.coords[0][2];
		oldTrans.y() = tm.coords[1][2];
		oldCenter.x() = center.x();
		oldCenter.y() = center.y();

		queueDraw();

		return true;
	}
/*	else if (e->button == 3)
    {
        rButtonDown = true;
    }//*/

//globalOutputStream() << "(" << (haveAnchor ? "anchor" : "released") << ")\n";

	return false;
}

gboolean button_release( GtkWidget * win, GdkEventButton * e, gpointer ){
//	globalOutputStream() << "--> Textool button release...\n";

	if ( e->button == 1 ) {
/*		float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
        float pty = e->y / windowSize.y() * extents.height() + extents.minY;

   //This prolly should go into the mouse move code...
   //Doesn't work correctly anyway...
        if (translatingX || translatingY)
            center.x() = ptx, center.y() = pty;//*/

		lButtonDown = false;

		if ( translatingX || translatingY ) {
			GlobalUndoSystem().finish( "translateTexture" );
		}
		else if ( rotating ) {
			GlobalUndoSystem().finish( "rotateTexture" );
		}
		else if ( scalingX || scalingY ) {
			GlobalUndoSystem().finish( "scaleTexture" );
		}
		else if ( resizingX || resizingY ) {
			GlobalUndoSystem().finish( "resizeTexture" );
		}
		else
		{
			GlobalUndoSystem().finish( "textoolUnknown" );
		}

		rotating = translatingX = translatingY = scalingX = scalingY
																= resizingX = resizingY = false;

		queueDraw();
	}
	else if ( e->button == 3 ) {
		rButtonDown = false;
	}

	return true;
}

/*
   void C2DView::GridForWindow( float c[2], int x, int y)
   {
   SpaceForWindow( c, x, y );
   if ( !m_bDoGrid )
    return;
   c[0] /= m_GridStep[0];
   c[1] /= m_GridStep[1];
   c[0] = (float)floor( c[0] + 0.5f );
   c[1] = (float)floor( c[1] + 0.5f );
   c[0] *= m_GridStep[0];
   c[1] *= m_GridStep[1];
   }
   void C2DView::SpaceForWindow( float c[2], int x, int y)
   {
   c[0] = ((float)(x))/((float)(m_rect.right-m_rect.left))*(m_Maxs[0]-m_Mins[0])+m_Mins[0];
   c[1] = ((float)(y))/((float)(m_rect.bottom-m_rect.top))*(m_Maxs[1]-m_Mins[1])+m_Mins[1];
   }
 */
gboolean motion( GtkWidget * win, GdkEventMotion * e, gpointer ){
//	globalOutputStream() << "--> Textool motion...\n";

	if ( lButtonDown ) {
		if ( translatingX || translatingY ) {
			float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
			float pty = e->y / windowSize.y() * extents.height() + extents.minY;

//Need to fix this to take the rotation angle into account, so that it moves along
//the rotated X/Y axis...
			if ( translatingX ) {
//				tm.coords[0][2] = (trans.x() + ptx) * textureSize.x();
//This works, but only when the angle is zero. !!! FIX !!! [DONE]
//				tm.coords[0][2] = oldCenter.x() + (ptx * textureSize.x());
				tm.coords[0][2] = oldTrans.x() + ( ptx - trans2.x() ) * textureSize.x();
//				center.x() = oldCenter.x() + (ptx - trans2.x());
			}

			if ( translatingY ) {
//				tm.coords[1][2] = (trans.y() + pty) * textureSize.y();
//				tm.coords[1][2] = oldCenter.y() + (pty * textureSize.y());
				tm.coords[1][2] = oldTrans.y() + ( pty - trans2.y() ) * textureSize.y();
//				center.y() = oldCenter.y() + (pty - trans2.y());
			}

//Need to update center.x/y() so that the widget translates as well. Also, oldCenter
//is badly named... Should be oldTrans or something like that... !!! FIX !!!
//Changing center.x/y() here doesn't seem to change anything... :-/
			UpdateControlPoints();
		}
		else if ( rotating ) {
			// Shamus: New rotate code
			int cx = (int)( windowSize.x() * ( center.x() - extents.minX ) / extents.width() );
			int cy = (int)( windowSize.y() * ( center.y() - extents.minY ) / extents.height() );
			Vector3 v1( dragPoint.x() - cx, dragPoint.y() - cy, 0 ), v2( e->x - cx, e->y - cy, 0 );

			vector3_normalise( v1 );
			vector3_normalise( v2 );
			float c = vector3_dot( v1, v2 );
			Vector3 cross = vector3_cross( v1, v2 );
			float s = vector3_length( cross );

			if ( cross[2] > 0 ) {
				s = -s;
			}

// Problem with this: arcsin/cos seems to only return -90 to 90 and 0 to 180...
// Can't derive angle from that!

//rotationAngle = asin(s);// * 180.0f / 3.141592653589f;
			rotationAngle = acos( c );
//rotationAngle2 = asin(s);
			if ( cross[2] < 0 ) {
				rotationAngle = -rotationAngle;
			}

//NO! DOESN'T WORK! rotationAngle -= 45.0f * DEG_TO_RAD;
//Let's try this:
//No wok.
/*c = cos(rotationAngle - oldRotationAngle);
   s = sin(rotationAngle - oldRotationAngle);
   rotationAngle += oldRotationAngle;
   //c += cos(oldRotationAngle);
   //s += sin(oldRotationAngle);
   //rotationAngle += oldRotationAngle;
   //c %= 2.0 * PI;
   //s %= 2.0 * PI;
   //rotationAngle %= 2.0 * PI;//*/

//This is wrong... Hmm...
//It seems to shear the texture instead of rotating it... !!! FIX !!!
// Now it rotates correctly. Seems TTimo was overcomplicating things here... ;-)

// Seems like what needs to happen here is multiplying these rotations by tm... !!! FIX !!!

// See brush_primit.cpp line 244 (Texdef_EmitTextureCoordinates()) for where texcoords come from...

			tm.coords[0][0] =  c;
			tm.coords[0][1] =  s;
			tm.coords[1][0] = -s;
			tm.coords[1][1] =  c;
//It doesn't work anymore... Dunno why...
//tm.coords[0][2] = -trans.x();			// This works!!! Yeah!!!
//tm.coords[1][2] = -trans.y();
//nope.
//tm.coords[0][2] = rotationPoint.x();	// This works, but strangely...
//tm.coords[1][2] = rotationPoint.y();
//tm.coords[0][2] = 0;// center.x() / 2.0f;
//tm.coords[1][2] = 0;// center.y() / 2.0f;
//No.
//tm.coords[0][2] = -(center.x() * textureSize.x());
//tm.coords[1][2] = -(center.y() * textureSize.y());
//Eh? No, but seems to be getting closer...
/*float ptx = e->x / windowSize.x() * extents.width() + extents.minX;
   float pty = e->y / windowSize.y() * extents.height() + extents.minY;
   tm.coords[0][2] = -c * center.x() - s * center.y() + ptx;
   tm.coords[1][2] =  s * center.x() - c * center.x() + pty;//*/
//Kinda works, but center drifts around on non-square textures...
/*tm.coords[0][2] = (-c * center.x() - s * center.y()) * textureSize.x();
   tm.coords[1][2] = ( s * center.x() - c * center.y()) * textureSize.y();//*/
//Rotates correctly, but not around the actual center of the face's points...
/*tm.coords[0][2] = -c * center.x() * textureSize.x() - s * center.y() * textureSize.y();
   tm.coords[1][2] =  s * center.x() * textureSize.x() - c * center.y() * textureSize.y();//*/
//Yes!!!
			tm.coords[0][2] = ( -c * center.x() * textureSize.x() - s * center.y() * textureSize.y() ) + center.x() * textureSize.x();
			tm.coords[1][2] = ( s * center.x() * textureSize.x() - c * center.y() * textureSize.y() ) + center.y() * textureSize.y(); //*/
//This doesn't work...
//And this is the wrong place for this anyway (I'm pretty sure).
/*tm.coords[0][2] += oldCenter.x();
   tm.coords[1][2] += oldCenter.y();//*/
			UpdateControlPoints(); // will cause a redraw
		}

		return true;
	}
	else                                    // Check for widget mouseovers
	{
		Vector2 tran;
		float nx = e->x / windowSize.x() * extents.width() + extents.minX;
		float ny = e->y / windowSize.y() * extents.height() + extents.minY;
		// Translate nx/y to the "center" point...
		nx -= center.x();
		ny -= center.y();
		ny = -ny;   // Flip Y-axis so that increasing numbers move up

		tran.x() = tm.coords[0][0] * nx + tm.coords[0][1] * ny;
		tran.y() = tm.coords[1][0] * nx + tm.coords[1][1] * ny;
//This doesn't seem to generate a valid distance from the center--for some reason it
//calculates a fixed number every time
//Look at nx/y above: they're getting fixed there! !!! FIX !!! [DONE]
		float dist = sqrt( ( nx * nx ) + ( ny * ny ) );
		// Normalize to the 2.0 = height standard (for now)
//globalOutputStream() << "--> Distance before: " << dist;
		dist = dist * 2.0f / extents.height();
//globalOutputStream() << ". After: " << dist;
		tran.x() = tran.x() * 2.0f / extents.height();
		tran.y() = tran.y() * 2.0f / extents.height();
//globalOutputStream() << ". Trans: " << tran.x() << ", " << tran.y() << "\n";

//Let's try this instead...
//Interesting! It seems that e->x/y are rotated
//(no, they're not--the TM above is what's doing it...)
		nx = ( ( e->x / windowSize.y() ) * 2.0f ) - ( windowSize.x() / windowSize.y() );
		ny = ( ( e->y / windowSize.y() ) * 2.0f ) - ( windowSize.y() / windowSize.y() );
		ny = -ny;
//Cool! It works! Now just need to do rotation...

		rotating = translatingX = translatingY = scalingX = scalingY
																= resizingX = resizingY = false;

		if ( dist < ( gridRadius * 0.16f ) ) {
			translatingX = translatingY = true;
		}
		else if ( dist > ( gridRadius * 0.16f ) && dist < ( gridRadius * 1.10f )
				  && fabs( ny ) < ( gridRadius * 0.05f ) && nx > 0 ) {
			translatingX = true;
		}
		else if ( dist > ( gridRadius * 0.16f ) && dist < ( gridRadius * 1.10f )
				  && fabs( nx ) < ( gridRadius * 0.05f ) && ny > 0 ) {
			translatingY = true;
		}
		// Should tighten up the angle on this, or put this test after the axis tests...
		else if ( tran.x() > 0 && tran.y() > 0
				  && ( dist > ( gridRadius * 0.82f ) && dist < ( gridRadius * 0.98f ) ) ) {
			rotating = true;
		}

		queueDraw();

		return true;
	}

	return false;
}

//It seems the fake tex coords conversion is screwing this stuff up... !!! FIX !!!
//This is still wrong... Prolly need to do something with the oldScaleX/Y stuff...
void flipX( GtkToggleButton *, gpointer ){
//	globalOutputStream() << "--> Flip X...\n";
	//Shamus:
//	SurfaceInspector_GetSelectedBPTexdef();		// Refresh g_selectedBrushPrimitTexdef...
//	tm.coords[0][0] = -tm.coords[0][0];
//	tm.coords[1][0] = -tm.coords[1][0];
//	tm.coords[0][0] = -tm.coords[0][0];			// This should be correct now...Nope.
//	tm.coords[1][1] = -tm.coords[1][1];
	tm.coords[0][0] = -tm.coords[0][0];         // This should be correct now...
	tm.coords[1][0] = -tm.coords[1][0];
//	tm.coords[2][0] = -tm.coords[2][0];//wil wok? no.
	UpdateControlPoints();
}

void flipY( GtkToggleButton *, gpointer ){
//	globalOutputStream() << "--> Flip Y...\n";
//	tm.coords[0][1] = -tm.coords[0][1];
//	tm.coords[1][1] = -tm.coords[1][1];
//	tm.coords[0][1] = -tm.coords[0][1];			// This should be correct now...Nope.
//	tm.coords[1][0] = -tm.coords[1][0];
	tm.coords[0][1] = -tm.coords[0][1];         // This should be correct now...
	tm.coords[1][1] = -tm.coords[1][1];
//	tm.coords[2][1] = -tm.coords[2][1];//wil wok? no.
	UpdateControlPoints();
}

} // end namespace TexTool

#endif