diff --git a/config.py b/config.py index c2bf1f56..95dd0f47 100644 --- a/config.py +++ b/config.py @@ -113,6 +113,7 @@ class Config: 'plugins/mapxml/mapxml.vcproj', 'plugins/shaders/shaders.vcproj', 'plugins/surface/surface.vcproj', + 'plugins/surface_ufoai/surface_ufoai.vcproj', 'plugins/surface_quake2/surface_quake2.vcproj', 'plugins/surface_heretic2/surface_heretic2.vcproj', 'contrib/camera/camera.vcproj', @@ -120,6 +121,7 @@ class Config: 'contrib/hydratoolz/hydratoolz.vcproj', 'contrib/bobtoolz/bobtoolz.vcproj', 'contrib/gtkgensurf/gtkgensurf.vcproj', + 'contrib/ufoai/ufoai.vcproj', 'contrib/bkgrnd2d/bkgrnd2d.vcproj' ]: ( libpath, libname ) = os.path.split( project ) diff --git a/contrib/ufoai/plugin.cpp b/contrib/ufoai/plugin.cpp new file mode 100644 index 00000000..7248bf60 --- /dev/null +++ b/contrib/ufoai/plugin.cpp @@ -0,0 +1,271 @@ +/* + 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 + */ + +#include "plugin.h" +#include "ufoai_filters.h" + +#define CMD_SEP "-" +#define CMD_ABOUT "About..." +// ============================================================================= +// Globals + +// function tables +_QERFuncTable_1 g_FuncTable; +_QERQglTable g_QglTable; +_QERFileSystemTable g_FileSystemTable; +_QEREntityTable g_EntityTable; +_QERAppDataTable g_DataTable; + +// the gtk widget +void *g_pMainWidget; + +// ============================================================================= +// plugin implementation + +#define PLUGIN_NAME "UFO:AI plugin" +#define PLUGIN_VERSION "0.1" + +//backwards for some reason +static const char *PLUGIN_COMMANDS = CMD_ABOUT ";" CMD_SEP; +static const char *PLUGIN_ABOUT = _( "UFO: Alien Invasion plugin " PLUGIN_VERSION "\nby Martin Gerhardy" ); + +#define NUM_TOOLBAR_BUTTONS FILTER_MAX +typedef struct toolbar_button_info_s +{ + const char *image; + const char *text; + const char *tip; + void ( *func )(); + IToolbarButton::EType type; +} toolbar_button_info_t; + +static const toolbar_button_info_t toolbar_buttons[NUM_TOOLBAR_BUTTONS] = +{ + { + "ufoai_actorclip.bmp", + _( "Filter actorclip" ), + _( "Actorclip" ), + DoActorClipFiltering, + IToolbarButton::eToggleButton + }, + { + "ufoai_weaponclip.bmp", + _( "Filter weaponclip" ), + _( "Weaponclip" ), + DoWeaponClipFiltering, + IToolbarButton::eToggleButton + }, + { + "ufoai_nodraw.bmp", + _( "Filter nodraw" ), + _( "NoDraw" ), + DoNoDrawFiltering, + IToolbarButton::eToggleButton + }, + { + "ufoai_stepon.bmp", + _( "Filter stepon" ), + _( "Stepon" ), + DoSteponFiltering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level1.bmp", + _( "Filter level1" ), + _( "Level 1" ), + DoLevel1Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level2.bmp", + _( "Filter level2" ), + _( "Level 2" ), + DoLevel2Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level3.bmp", + _( "Filter level3" ), + _( "Level 3" ), + DoLevel3Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level4.bmp", + _( "Filter level4" ), + _( "Level 4" ), + DoLevel4Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level5.bmp", + _( "Filter level5" ), + _( "Level 5" ), + DoLevel5Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level6.bmp", + _( "Filter level6" ), + _( "Level 6" ), + DoLevel6Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level7.bmp", + _( "Filter level7" ), + _( "Level 7" ), + DoLevel7Filtering, + IToolbarButton::eToggleButton + }, + { + "ufoai_level8.bmp", + _( "Filter level8" ), + _( "Level 8" ), + DoLevel8Filtering, + IToolbarButton::eToggleButton + }, +}; + +class UFOAIButton : public IToolbarButton +{ +public: +const toolbar_button_info_s *bi; +virtual const char* getImage() const { + return bi->image; +} +virtual const char* getText() const { + return bi->text; +} +virtual const char* getTooltip() const { + return bi->tip; +} +virtual void activate() const { + bi->func(); + return ; +} +virtual EType getType() const { + return bi->type; +} +}; + +UFOAIButton g_ufoaibuttons[NUM_TOOLBAR_BUTTONS]; + +unsigned int ToolbarButtonCount( void ){ + return NUM_TOOLBAR_BUTTONS; +} + +const IToolbarButton* GetToolbarButton( unsigned int index ){ + g_ufoaibuttons[index].bi = &toolbar_buttons[index]; + return &g_ufoaibuttons[index]; +} + +extern "C" const char* QERPlug_Init( void *hApp, void* pMainWidget ){ + g_pMainWidget = pMainWidget; + + UFOAIFilterInit(); + + return PLUGIN_NAME; +} + +extern "C" const char* QERPlug_GetName( void ){ + return (char *) PLUGIN_NAME; +} + +extern "C" const char* QERPlug_GetCommandList( void ){ + return (char *) PLUGIN_COMMANDS; +} + +extern "C" void QERPlug_Dispatch( const char *p, vec3_t vMin, vec3_t vMax, bool bSingleBrush ){ + if ( !strcmp( p, CMD_ABOUT ) ) { + g_FuncTable.m_pfnMessageBox( NULL, PLUGIN_ABOUT, _( "About" ), MB_OK, NULL ); + } + else { + Sys_Printf( "Message: %s\n", p ); + } +} + +// ============================================================================= +// SYNAPSE + +CSynapseServer* g_pSynapseServer = NULL; +CSynapseClientUFOAI g_SynapseClient; + +#if __GNUC__ >= 4 +#pragma GCC visibility push(default) +#endif +extern "C" CSynapseClient * SYNAPSE_DLL_EXPORT Synapse_EnumerateInterfaces( const char *version, CSynapseServer *pServer ){ +#if __GNUC__ >= 4 +#pragma GCC visibility pop +#endif + if ( strcmp( version, SYNAPSE_VERSION ) ) { + Syn_Printf( "ERROR: synapse API version mismatch: should be '" SYNAPSE_VERSION "', got '%s'\n", version ); + return NULL; + } + g_pSynapseServer = pServer; + g_pSynapseServer->IncRef(); + Set_Syn_Printf( g_pSynapseServer->Get_Syn_Printf() ); + + g_SynapseClient.AddAPI( TOOLBAR_MAJOR, UFOAI_MINOR, sizeof( _QERPlugToolbarTable ) ); + g_SynapseClient.AddAPI( PLUGIN_MAJOR, UFOAI_MINOR, sizeof( _QERPluginTable ) ); + + g_SynapseClient.AddAPI( RADIANT_MAJOR, NULL, sizeof( g_FuncTable ), SYN_REQUIRE, &g_FuncTable ); + g_SynapseClient.AddAPI( QGL_MAJOR, NULL, sizeof( g_QglTable ), SYN_REQUIRE, &g_QglTable ); + g_SynapseClient.AddAPI( VFS_MAJOR, "*", sizeof( g_FileSystemTable ), SYN_REQUIRE, &g_FileSystemTable ); + // get worldspawn + g_SynapseClient.AddAPI( ENTITY_MAJOR, NULL, sizeof( g_EntityTable ), SYN_REQUIRE, &g_EntityTable ); + // selected brushes + g_SynapseClient.AddAPI( DATA_MAJOR, NULL, sizeof( g_DataTable ), SYN_REQUIRE, &g_DataTable ); + + return &g_SynapseClient; +} + +bool CSynapseClientUFOAI::RequestAPI( APIDescriptor_t *pAPI ){ + if ( !strcmp( pAPI->major_name, PLUGIN_MAJOR ) ) { + _QERPluginTable* pTable = static_cast<_QERPluginTable*>( pAPI->mpTable ); + + pTable->m_pfnQERPlug_Init = QERPlug_Init; + pTable->m_pfnQERPlug_GetName = QERPlug_GetName; + pTable->m_pfnQERPlug_GetCommandList = QERPlug_GetCommandList; + pTable->m_pfnQERPlug_Dispatch = QERPlug_Dispatch; + return true; + } + else if ( !strcmp( pAPI->major_name, TOOLBAR_MAJOR ) ) { + _QERPlugToolbarTable* pTable = static_cast<_QERPlugToolbarTable*>( pAPI->mpTable ); + + pTable->m_pfnToolbarButtonCount = &ToolbarButtonCount; + pTable->m_pfnGetToolbarButton = &GetToolbarButton; + return true; + } + + Syn_Printf( "ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo() ); + return false; +} + +#include "version.h" + +const char* CSynapseClientUFOAI::GetInfo(){ + return PLUGIN_NAME " plugin built " __DATE__ " " RADIANT_VERSION; +} + +const char* CSynapseClientUFOAI::GetName(){ + return PLUGIN_NAME; +} diff --git a/contrib/ufoai/plugin.h b/contrib/ufoai/plugin.h new file mode 100644 index 00000000..68096758 --- /dev/null +++ b/contrib/ufoai/plugin.h @@ -0,0 +1,68 @@ +/* + 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 + */ + +#ifndef _PLUGIN_H_ +#define _PLUGIN_H_ + +/*! + \todo need general notice about lib purpose etc. + and the external dependencies (such as GLib, STL, mathlib etc.) + */ + +#include +// for CPtrArray for idata.h +#include "missing.h" + +#include "synapse.h" +#include "iplugin.h" +#include "itoolbar.h" +#define USE_QERTABLE_DEFINE +#include "qerplugin.h" +#include "igl.h" +#include "ifilesystem.h" +#include "ientity.h" +#include "idata.h" +#include + +extern _QERFuncTable_1 g_FuncTable; +extern _QERQglTable g_QglTable; +extern _QERFileSystemTable g_FileSystemTable; +extern _QEREntityTable g_EntityTable; +extern _QERAppDataTable g_DataTable; +extern void *g_pMainWidget; + +extern CSynapseServer* g_pSynapseServer; + +class CSynapseClientUFOAI : public CSynapseClient +{ +public: +// CSynapseClient API +bool RequestAPI( APIDescriptor_t *pAPI ); +const char* GetInfo(); +const char* GetName(); + +CSynapseClientUFOAI() { } +virtual ~CSynapseClientUFOAI() { } +}; + +#define UFOAI_MINOR "ufo:ai" + +#endif // _PLUGIN_H_ diff --git a/contrib/ufoai/ufoai.def b/contrib/ufoai/ufoai.def new file mode 100644 index 00000000..9b54378b --- /dev/null +++ b/contrib/ufoai/ufoai.def @@ -0,0 +1,7 @@ +; ufoai.def : Declares the module parameters for the DLL. + +LIBRARY "UFOAI" + +EXPORTS + ; Explicit exports can go here + Synapse_EnumerateInterfaces @1 diff --git a/contrib/ufoai/ufoai.vcproj b/contrib/ufoai/ufoai.vcproj new file mode 100644 index 00000000..296e26bb --- /dev/null +++ b/contrib/ufoai/ufoai.vcproj @@ -0,0 +1,191 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/contrib/ufoai/ufoai.vcxproj b/contrib/ufoai/ufoai.vcxproj new file mode 100644 index 00000000..72e09e19 --- /dev/null +++ b/contrib/ufoai/ufoai.vcxproj @@ -0,0 +1,176 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {850DD97C-B457-497D-B5F5-DA1904FAC5F9} + Win32Proj + + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>11.0.60315.1 + + + $(SolutionDir)\install\modules\ + $(SolutionDir)\build\intermediate\$(Configuration)\$(ProjectName)\ + + + + $(SolutionDir)\install\modules\ + $(SolutionDir)\build\intermediate\$(Configuration)\$(ProjectName)\ + + + + + Disabled + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;_USRDLL;UFOAI_EXPORTS;%(PreprocessorDefinitions) + true + EnableFastChecks + MultiThreadedDebugDLL + + Level3 + EditAndContinue + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + ufoai.def + true + Windows + MachineX86 + + + + + Disabled + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;_USRDLL;UFOAI_EXPORTS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + ufoai.def + true + Windows + + + + + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_WINDOWS;_USRDLL;UFOAI_EXPORTS;%(PreprocessorDefinitions) + MultiThreadedDLL + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + ufoai.def + true + Windows + true + true + MachineX86 + + + + + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_WINDOWS;_USRDLL;UFOAI_EXPORTS;%(PreprocessorDefinitions) + MultiThreadedDLL + + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + ufoai.def + true + Windows + true + true + + + + + + + + + + + + {e13ccfb0-a366-4ef3-a66f-c374b563e4df} + false + + + + + + \ No newline at end of file diff --git a/contrib/ufoai/ufoai.vcxproj.filters b/contrib/ufoai/ufoai.vcxproj.filters new file mode 100644 index 00000000..e135aa45 --- /dev/null +++ b/contrib/ufoai/ufoai.vcxproj.filters @@ -0,0 +1,22 @@ + + + + + {f3cd758b-8b56-44e2-9155-0613b20b6fad} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + + + src + + + src + + + + + src + + + \ No newline at end of file diff --git a/contrib/ufoai/ufoai_filters.cpp b/contrib/ufoai/ufoai_filters.cpp new file mode 100644 index 00000000..7be6623f --- /dev/null +++ b/contrib/ufoai/ufoai_filters.cpp @@ -0,0 +1,95 @@ + +#include "plugin.h" +#include "ufoai_filters.h" +#include "ifilters.h" + +#define FilterAdd g_FuncTable.m_pfnFilterAdd +#define FiltersActivate g_FuncTable.m_pfnFiltersActivate + +static bfilter_t* filters[FILTER_MAX]; + +void UFOAIFilterInit( void ){ + // texture name filters + filters[FILTER_ACTORCLIP] = FilterAdd( 1, 0, "actorclip", 0 ); + filters[FILTER_WEAPONCLIP] = FilterAdd( 1, 0, "weaponclip", 0 ); + filters[FILTER_NODRAW] = FilterAdd( 1, 0, "nodraw", 0 ); + filters[FILTER_STEPON] = FilterAdd( 1, 0, "stepon", 0 ); + + // content flag filters + filters[FILTER_LEVEL1] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_1, "level1", 0 ); + filters[FILTER_LEVEL2] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_2, "level2", 0 ); + filters[FILTER_LEVEL3] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_3, "level3", 0 ); + filters[FILTER_LEVEL4] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_4, "level4", 0 ); + filters[FILTER_LEVEL5] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_5, "level5", 0 ); + filters[FILTER_LEVEL6] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_6, "level6", 0 ); + filters[FILTER_LEVEL7] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_7, "level7", 0 ); + filters[FILTER_LEVEL8] = FilterAdd( 7, UFOAI_CONTENTS_LEVEL_8, "level8", 0 ); + + Sys_Printf( "UFO:AI Filters initialized\n" ); +} + +void PerformFiltering( int type ){ + if ( !filters[type] ) { + Sys_Printf( "filters are not yet initialized\n" ); + return; + } + + if ( filters[type]->active ) { + filters[type]->active = false; + //Sys_Printf("filter %i deactivated (mask %i 0x%x)\n", type, filters[type]->mask, filters[type]->mask); + } + else { + filters[type]->active = true; + //Sys_Printf("filter %i activated (mask %i 0x%x)\n", type, filters[type]->mask, filters[type]->mask); + } + + FiltersActivate(); +} + +void DoSteponFiltering( void ){ + PerformFiltering( FILTER_STEPON ); +} + +void DoWeaponClipFiltering( void ){ + PerformFiltering( FILTER_WEAPONCLIP ); +} + +void DoActorClipFiltering( void ){ + PerformFiltering( FILTER_ACTORCLIP ); +} + +void DoNoDrawFiltering( void ){ + PerformFiltering( FILTER_NODRAW ); +} + +void DoLevel1Filtering( void ){ + PerformFiltering( FILTER_LEVEL1 ); +} + +void DoLevel2Filtering( void ){ + PerformFiltering( FILTER_LEVEL2 ); +} + +void DoLevel3Filtering( void ){ + PerformFiltering( FILTER_LEVEL3 ); +} + +void DoLevel4Filtering( void ){ + PerformFiltering( FILTER_LEVEL4 ); +} + +void DoLevel5Filtering( void ){ + PerformFiltering( FILTER_LEVEL5 ); +} + +void DoLevel6Filtering( void ){ + PerformFiltering( FILTER_LEVEL6 ); +} + +void DoLevel7Filtering( void ){ + PerformFiltering( FILTER_LEVEL7 ); +} + +void DoLevel8Filtering( void ){ + PerformFiltering( FILTER_LEVEL8 ); +} diff --git a/contrib/ufoai/ufoai_filters.h b/contrib/ufoai/ufoai_filters.h new file mode 100644 index 00000000..ddab2d2a --- /dev/null +++ b/contrib/ufoai/ufoai_filters.h @@ -0,0 +1,49 @@ + +enum FILTERS { + FILTER_ACTORCLIP, + FILTER_WEAPONCLIP, + FILTER_NODRAW, + FILTER_STEPON, + FILTER_LEVEL1, + FILTER_LEVEL2, + FILTER_LEVEL3, + FILTER_LEVEL4, + FILTER_LEVEL5, + FILTER_LEVEL6, + FILTER_LEVEL7, + FILTER_LEVEL8, + + FILTER_MAX +}; + +#define UFOAI_CONTENTS_LEVEL_1 0x0100 +#define UFOAI_CONTENTS_LEVEL_2 0x0200 +#define UFOAI_CONTENTS_LEVEL_3 0x0400 +#define UFOAI_CONTENTS_LEVEL_4 0x0800 +#define UFOAI_CONTENTS_LEVEL_5 0x1000 +#define UFOAI_CONTENTS_LEVEL_6 0x2000 +#define UFOAI_CONTENTS_LEVEL_7 0x4000 +#define UFOAI_CONTENTS_LEVEL_8 0x8000 + +#define UFOAI_CONTENTS_ACTORCLIP 0x00010000 +#define UFOAI_CONTENTS_WEAPONCLIP 0x02000000 +#define UFOAI_CONTENTS_STEPON 0x40000000 + +#define UFOAI_SURF_NODRAW 0x00000080 + + +void DoSteponFiltering( void ); +void DoWeaponClipFiltering( void ); +void DoActorClipFiltering( void ); +void DoNoDrawFiltering( void ); +void DoLevel1Filtering( void ); +void DoLevel2Filtering( void ); +void DoLevel3Filtering( void ); +void DoLevel4Filtering( void ); +void DoLevel5Filtering( void ); +void DoLevel6Filtering( void ); +void DoLevel7Filtering( void ); +void DoLevel8Filtering( void ); + +// add the ufoai filters +void UFOAIFilterInit( void ); diff --git a/plugins/surface_ufoai/surface_ufoai.def b/plugins/surface_ufoai/surface_ufoai.def new file mode 100644 index 00000000..588ea289 --- /dev/null +++ b/plugins/surface_ufoai/surface_ufoai.def @@ -0,0 +1,7 @@ +; surface_ufoai.def : Declares the module parameters for the DLL. + +LIBRARY "SURFACE_UFOAI" + +EXPORTS + ; Explicit exports can go here + Synapse_EnumerateInterfaces @1 diff --git a/plugins/surface_ufoai/surface_ufoai.vcproj b/plugins/surface_ufoai/surface_ufoai.vcproj new file mode 100644 index 00000000..49269385 --- /dev/null +++ b/plugins/surface_ufoai/surface_ufoai.vcproj @@ -0,0 +1,195 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/plugins/surface_ufoai/surface_ufoai.vcxproj b/plugins/surface_ufoai/surface_ufoai.vcxproj new file mode 100644 index 00000000..ea78e15a --- /dev/null +++ b/plugins/surface_ufoai/surface_ufoai.vcxproj @@ -0,0 +1,177 @@ + + + + + Debug + Win32 + + + Debug + x64 + + + Release + Win32 + + + Release + x64 + + + + {F400371F-455F-4B6C-9F13-A2E57110E725} + Win32Proj + + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + DynamicLibrary + v110 + + + + + + + + + + + + + + + + + + + <_ProjectFileVersion>11.0.60315.1 + + + $(SolutionDir)\install\modules\ + $(SolutionDir)\build\intermediate\$(Configuration)\$(ProjectName)\ + + + + $(SolutionDir)\install\modules\ + $(SolutionDir)\build\intermediate\$(Configuration)\$(ProjectName)\ + + + + + Disabled + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;_USRDLL;SURFACE_UFOAI_EXPORTS;%(PreprocessorDefinitions) + true + EnableFastChecks + MultiThreadedDebugDLL + + Level3 + EditAndContinue + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + surface_ufoai.def + true + Windows + MachineX86 + + + + + Disabled + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;_DEBUG;_WINDOWS;_USRDLL;SURFACE_UFOAI_EXPORTS;%(PreprocessorDefinitions) + EnableFastChecks + MultiThreadedDebugDLL + + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + surface_ufoai.def + true + Windows + + + + + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_WINDOWS;_USRDLL;SURFACE_UFOAI_EXPORTS;%(PreprocessorDefinitions) + MultiThreadedDLL + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + surface_ufoai.def + true + Windows + true + true + MachineX86 + + + + + $(SolutionDir)\libs;$(SolutionDir)\include;$(SolutionDir)\..\STLport-5.2.1\stlport;$(SolutionDir)\..\gtk-2.24.10\include\glib-2.0;$(SolutionDir)\..\gtk-2.24.10\include\gdk-pixbuf-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\glib-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include;$(SolutionDir)\..\gtk-2.24.10\include\gtk-2.0;$(SolutionDir)\..\gtk-2.24.10\lib\gtk-2.0\include;$(SolutionDir)\..\gtk-2.24.10\include\cairo;$(SolutionDir)\..\gtk-2.24.10\include\pango-1.0;$(SolutionDir)\..\gtk-2.24.10\include\atk-1.0;$(SolutionDir)\..\libxml2-2.9.1\include;%(AdditionalIncludeDirectories) + WIN32;NDEBUG;_WINDOWS;_USRDLL;SURFACE_UFOAI_EXPORTS;%(PreprocessorDefinitions) + MultiThreadedDLL + + + Level3 + ProgramDatabase + 4996;4244;4101;4800;%(DisableSpecificWarnings) + + + /STACK:8388608 %(AdditionalOptions) + ws2_32.lib;glib-2.0.lib;gobject-2.0.lib;intl.lib;gtk-win32-2.0.lib;libxml2.lib;synapse.lib;%(AdditionalDependencies) + $(SolutionDir)\..\gtk-2.24.10\lib;$(SolutionDir)\..\libxml2-2.9.1\lib\$(Configuration)\$(Platform);$(SolutionDir)\build\$(Configuration)\libs;%(AdditionalLibraryDirectories) + surface_ufoai.def + true + Windows + true + true + + + + + + + + + + + + + {e13ccfb0-a366-4ef3-a66f-c374b563e4df} + false + + + + + + \ No newline at end of file diff --git a/plugins/surface_ufoai/surface_ufoai.vcxproj.filters b/plugins/surface_ufoai/surface_ufoai.vcxproj.filters new file mode 100644 index 00000000..862974d9 --- /dev/null +++ b/plugins/surface_ufoai/surface_ufoai.vcxproj.filters @@ -0,0 +1,25 @@ + + + + + {8d3e9596-a105-4ce1-8cfb-7b02c906b270} + cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx + + + + + src + + + + + src + + + src + + + src + + + \ No newline at end of file diff --git a/plugins/surface_ufoai/surfacedialog.cpp b/plugins/surface_ufoai/surfacedialog.cpp new file mode 100644 index 00000000..5e0eebc2 --- /dev/null +++ b/plugins/surface_ufoai/surfacedialog.cpp @@ -0,0 +1,1916 @@ +/* + Copyright (C) 1999-2007 id Software, Inc. and contributors. + For a list of contributors, see the accompanying CONTRIBUTORS file. + + This file is part of GtkRadiant. + + GtkRadiant is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + GtkRadiant is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with GtkRadiant; if not, write to the Free Software + Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA + */ + +// +// Surface Dialog Module +// + +// +// Nurail: Implemented to Module from the main Radiant Surface Dialog code +// + + +#include +#include +#include + +#include "surfdlg_plugin.h" + + + +#ifdef _DEBUG +//#define DBG_SI 1 +#endif + +#include "gtkr_vector.h" + +vector g_texdef_face_vector; + +inline texdef_to_face_t* get_texdef_face_list(){ + return &( *g_texdef_face_vector.begin() ); +} + +inline unsigned int texdef_face_list_empty(){ + return g_texdef_face_vector.empty(); +} + +inline unsigned int texdef_face_list_size(){ + return g_texdef_face_vector.size(); +} + +// For different faces having different values +bool is_HShift_conflicting; +bool is_VShift_conflicting; +bool is_HScale_conflicting; +bool is_VScale_conflicting; +bool is_Rotate_conflicting; +bool is_TextureName_conflicting; + +void ShowDlg(); +void HideDlg(); +void SetTexMods(); +void GetTexMods( bool b_SetUndoPoint = FALSE ); +void BuildDialog(); +void FitAll(); +void InitDefaultIncrement( texdef_t * ); +void DoSnapTToGrid( float hscale, float vscale ); +// called to perform a fitting from the outside (shortcut key) +void SurfaceDialogFitAll(); + +// UFOAI Flags Functions +void SetFlagButtons_UFOAI( texdef_to_face_t *texdef_face_list, bool b_isListEmpty ); +void SetChangeInFlags_Face_UFOAI( texdef_to_face_t *texdef_face_list ); +GtkWidget* Create_UFOAIFlagsDialog( GtkWidget* surfacedialog_widget ); + + +// Dialog Data +int m_nHeight; +int m_nWidth; + +// 0 is invalid, otherwise it's the Id of the last 'do' we are responsible for +int m_nUndoId; + + +texturewin_t *texturewin; +texdef_t *l_pIncrement; +texdef_t texdef_offset; +texdef_t texdef_SI_values; + +// For Texture Entry, activate only on entry change +char old_texture_entry[128]; + +// the texdef to switch back to when the OnCancel is called +texdef_t g_old_texdef; + +// when TRUE, this thing means the surface inspector is currently being displayed +bool g_surfwin = FALSE; +// turn on/off processing of the "changed" "value_changed" messages +// (need to turn off when we are feeding data in) +bool g_bListenChanged = true; +// turn on/off listening of the update messages +bool g_bListenUpdate = true; + +GtkWidget* create_SurfaceInspector( void ); +GtkWidget *SurfaceInspector = NULL; + +GtkWidget *m_pWidget; +GtkWidget *GetWidget() { return SurfaceInspector; } +GtkWidget *Get_SI_Module_Widget() { return SurfaceInspector; } +void SetWidget( GtkWidget *new_widget ) { m_pWidget = new_widget; } +GtkWidget *GetDlgWidget( const char* name ) +{ return GTK_WIDGET( g_object_get_data( G_OBJECT( SurfaceInspector ), name ) ); } + +// Spins for FitTexture +GtkWidget *spin_width; +GtkWidget *spin_height; + + +GtkWidget *texture_combo; +GtkWidget *texture_combo_entry; + +GtkWidget *match_grid_button; +GtkWidget *lock_valuechange_togglebutton; + +GtkObject *hshift_value_spinbutton_adj; +GtkWidget *hshift_value_spinbutton; +GtkObject *vshift_value_spinbutton_adj; +GtkWidget *vshift_value_spinbutton; +GtkObject *hscale_value_spinbutton_adj; +GtkWidget *hscale_value_spinbutton; +GtkObject *vscale_value_spinbutton_adj; +GtkWidget *vscale_value_spinbutton; +GtkObject *rotate_value_spinbutton_adj; +GtkWidget *rotate_value_spinbutton; + +GtkObject *hshift_offset_spinbutton_adj; +GtkWidget *hshift_offset_spinbutton; +GtkObject *vshift_offset_spinbutton_adj; +GtkWidget *vshift_offset_spinbutton; +GtkObject *hscale_offset_spinbutton_adj; +GtkWidget *hscale_offset_spinbutton; +GtkObject *vscale_offset_spinbutton_adj; +GtkWidget *vscale_offset_spinbutton; +GtkObject *rotate_offset_spinbutton_adj; +GtkWidget *rotate_offset_spinbutton; + +GtkObject *hshift_step_spinbutton_adj; +GtkWidget *hshift_step_spinbutton; +GtkObject *vshift_step_spinbutton_adj; +GtkWidget *vshift_step_spinbutton; +GtkObject *hscale_step_spinbutton_adj; +GtkWidget *hscale_step_spinbutton; +GtkObject *vscale_step_spinbutton_adj; +GtkWidget *vscale_step_spinbutton; +GtkObject *rotate_step_spinbutton_adj; +GtkWidget *rotate_step_spinbutton; + +GtkObject *fit_width_spinbutton_adj; +GtkWidget *fit_width_spinbutton; +GtkObject *fit_height_spinbutton_adj; +GtkWidget *fit_height_spinbutton; +GtkWidget *fit_button; +GtkWidget *axial_button; + +GtkWidget *done_button; +GtkWidget *apply_button; +GtkWidget *cancel_button; + +// Callbacks +gboolean on_texture_combo_entry_key_press_event( GtkWidget *widget, GdkEventKey *event, gpointer user_data ); +void on_texture_combo_entry_activate( GtkEntry *entry, gpointer user_data ); + +static void on_match_grid_button_clicked( GtkButton *button, gpointer user_data ); +static void on_lock_valuechange_togglebutton_toggled( GtkToggleButton *togglebutton, gpointer user_data ); + +static void on_hshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_hscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_rotate_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); + +static void on_hshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_hscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_rotate_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); + +static void on_hshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_hscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_vscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_rotate_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); + +static void on_fit_width_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_fit_height_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ); +static void on_fit_button_clicked( GtkButton *button, gpointer user_data ); +static void on_axial_button_clicked( GtkButton *button, gpointer user_data ); + +static void on_done_button_clicked( GtkButton *button, gpointer user_data ); +static void on_apply_button_clicked( GtkButton *button, gpointer user_data ); +static void on_cancel_button_clicked( GtkButton *button, gpointer user_data ); + + +/* + =================================================== + + SURFACE INSPECTOR + + =================================================== + */ + + +void IsFaceConflicting(){ + texdef_t* tmp_texdef; + texdef_to_face_t* temp_texdef_face_list; + char 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; + 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() ) { + GetSelFacesTexdef( get_texdef_face_list() ); + } + + IsFaceConflicting(); + PopulateTextureComboList(); + ZeroOffsetValues(); + if ( texdef_face_list_empty() ) { + SetFlagButtons_UFOAI( get_texdef_face_list(), TRUE ); + } + else{ + SetFlagButtons_UFOAI( get_texdef_face_list(), FALSE ); + } +} + +static gint delete_event_callback( GtkWidget *widget, GdkEvent* event, gpointer data ){ + HideDlg(); + return TRUE; +} + +// make the shift increments match the grid settings +// the objective being that the shift+arrows shortcuts move the texture by the corresponding grid size +// this depends on a scale value if you have selected a particular texture on which you want it to work: +// we move the textures in pixels, not world units. (i.e. increment values are in pixel) +// depending on the texture scale it doesn't take the same amount of pixels to move of g_qeglobals.d_gridsize +// increment * scale = gridsize +// hscale and vscale are optional parameters, if they are zero they will be set to the default scale +// NOTE: the default scale depends if you are using BP mode or regular. +// For regular it's 0.5f (128 pixels cover 64 world units), for BP it's simply 1.0f +// see fenris #2810 +void DoSnapTToGrid( float hscale, float vscale ){ + l_pIncrement = Get_SI_Inc(); + + if ( hscale == 0.0f ) { + hscale = 0.5f; + } + if ( vscale == 0.0f ) { + vscale = 0.5f; + } +#ifdef _DEBUG + Sys_Printf( "DoSnapTToGrid: hscale %g vscale %g\n", hscale, vscale ); +#endif + l_pIncrement->shift[0] = GridSize() / hscale; + l_pIncrement->shift[1] = GridSize() / vscale; + // now some update work + // FIXME: doesn't look good here, seems to be called several times + SetTexMods(); +} + +void UpdateSurfaceDialog(){ + if ( !g_bListenUpdate ) { + return; + } + + if ( !SurfaceInspector ) { + return; + } + + // avoid long delays on slow computers + while ( gtk_events_pending() ) + gtk_main_iteration(); + + if ( g_surfwin ) { +#ifdef DBG_SI + Sys_Printf( "UpdateSurfaceDialog\n" ); +#endif + GetTexdefInfo_from_Radiant(); + SetTexMods(); + } + +} + +// DoSurface will always try to show the surface inspector +// or update it because something new has been selected +void DoSurface( void ){ +#ifdef DBG_SI + Sys_Printf( "DoSurface\n" ); +#endif + if ( !SurfaceInspector ) { + create_SurfaceInspector(); + } + + ShowDlg(); + SetTexMods(); +} + +void ToggleSurface(){ +#ifdef DBG_SI + Sys_Printf( "ToggleSurface Module\n" ); +#endif + if ( !g_surfwin ) { + DoSurface(); + } + else{ + on_cancel_button_clicked( NULL, NULL ); + } +} + +// NOTE: will raise and show the Surface inspector and exec fit for patches and brushes +void SurfaceDlgFitAll(){ + DoSurface(); + FitAll(); +} + +// ============================================================================= +// SurfaceDialog class + +void ShowDlg(){ + + if ( !SurfaceInspector ) { + create_SurfaceInspector(); + } + else{ + gtk_widget_show( SurfaceInspector ); + } + + GetTexdefInfo_from_Radiant(); + GetTexMods( TRUE ); // Set Initial Undo Point + g_surfwin = TRUE; +} + +void HideDlg(){ + g_surfwin = FALSE; + gtk_widget_hide( SurfaceInspector ); +} + + +// set default values for increments (shift scale and rot) +// this is called by the prefs code if can't find the values +void InitDefaultIncrement( texdef_t *tex ){ + tex->SetName( "foo" ); + tex->shift[0] = 8; + tex->shift[1] = 8; + tex->scale[0] = 0.25; + tex->scale[1] = 0.25; + tex->rotate = 10; +} + +void BuildDialog(){ + if ( !SurfaceInspector ) { + create_SurfaceInspector(); + } +} + +/* + ============== + SetTexMods + + Set the fields to the current texdef (i.e. map/texdef -> dialog widgets) + =============== + */ + +void SetTexMods(){ + texdef_t *pt; + GtkSpinButton *spin; + GtkAdjustment *adjust; + + texturewin = Texturewin(); + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "SurfaceDlg SetTexMods\n" ); +#endif + + if ( !g_surfwin ) { + return; + } + + pt = &texturewin->texdef; + + g_bListenChanged = false; + + if ( strncmp( pt->GetName(), "textures/", 9 ) != 0 ) { + texdef_offset.SetName( SHADER_NOT_FOUND ); + } + + + spin = GTK_SPIN_BUTTON( hshift_offset_spinbutton ); + gtk_spin_button_set_value( spin, texdef_offset.shift[0] ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->shift[0]; + gtk_spin_button_set_value( GTK_SPIN_BUTTON( hshift_step_spinbutton ), l_pIncrement->shift[0] ); + + spin = GTK_SPIN_BUTTON( hshift_value_spinbutton ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->shift[0]; + + + spin = GTK_SPIN_BUTTON( vshift_offset_spinbutton ); + gtk_spin_button_set_value( spin, texdef_offset.shift[1] ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->shift[1]; + gtk_spin_button_set_value( GTK_SPIN_BUTTON( vshift_step_spinbutton ), l_pIncrement->shift[1] ); + + spin = GTK_SPIN_BUTTON( vshift_value_spinbutton ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->shift[1]; + + + spin = GTK_SPIN_BUTTON( hscale_offset_spinbutton ); + gtk_spin_button_set_value( spin, texdef_offset.scale[0] ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->scale[0]; + gtk_spin_button_set_value( GTK_SPIN_BUTTON( hscale_step_spinbutton ), l_pIncrement->scale[0] ); + + spin = GTK_SPIN_BUTTON( hscale_value_spinbutton ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->scale[0]; + + + spin = GTK_SPIN_BUTTON( vscale_offset_spinbutton ); + gtk_spin_button_set_value( spin, texdef_offset.scale[1] ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->scale[1]; + gtk_spin_button_set_value( GTK_SPIN_BUTTON( vscale_step_spinbutton ), l_pIncrement->scale[1] ); + + spin = GTK_SPIN_BUTTON( vscale_value_spinbutton ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->scale[1]; + + + spin = GTK_SPIN_BUTTON( rotate_offset_spinbutton ); + gtk_spin_button_set_value( spin, texdef_offset.rotate ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->rotate; + gtk_spin_button_set_value( GTK_SPIN_BUTTON( rotate_step_spinbutton ), l_pIncrement->rotate ); + + spin = GTK_SPIN_BUTTON( rotate_value_spinbutton ); + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( spin ) ); + adjust->step_increment = l_pIncrement->rotate; + + + g_bListenChanged = true; + + // store the current texdef as our escape route if user hits OnCancel + g_old_texdef = texturewin->texdef; +} + +/* + ============== + GetTexMods + + Shows any changes to the main Radiant windows + =============== + */ +void GetTexMods( bool b_SetUndoPoint ){ + +#ifdef DBG_SI + Sys_Printf( "SurfaceDlg GetTexMods\n" ); +#endif + + if ( !texdef_face_list_empty() ) { + g_bListenUpdate = FALSE; + SetChangeInFlags_Face_UFOAI( get_texdef_face_list() ); + SetTexdef_FaceList( get_texdef_face_list(), b_SetUndoPoint, false ); + g_bListenUpdate = TRUE; + + if ( b_SetUndoPoint ) { + m_nUndoId = Undo_GetUndoId(); + } + } +} + +void FitAll(){ + on_fit_button_clicked( NULL, NULL ); +} + + +//////////////////////////////////////////////////////////////////// +// +// GUI Section +// +//////////////////////////////////////////////////////////////////// + +GtkWidget* create_SurfaceInspector( void ){ + + GtkWidget *label; + GtkWidget *hseparator; + GtkWidget *eventbox; + + GtkWidget *viewport8; + GtkWidget *viewport9; + GtkWidget *viewport2; + GtkWidget *viewport7; + GtkWidget *viewport5; + GtkWidget *viewport6; + GtkWidget *viewport10; + + GtkWidget *table1; + GtkWidget *table4; + GtkWidget *table5; + GtkWidget *table7; + + GtkWidget *alignment1; + GtkWidget *alignment2; + GtkWidget *alignment3; + + GtkWidget *vbox7; + + GtkWidget *hbox1; + GtkWidget *hbox2; + GtkWidget *hbox3; + GtkWidget *hbox4; + + GtkWidget *image1; + GtkWidget *image2; + GtkWidget *image3; + + GtkWidget *hbuttonbox1; + + SurfaceInspector = gtk_window_new( GTK_WINDOW_TOPLEVEL ); + gtk_container_set_border_width( GTK_CONTAINER( SurfaceInspector ), 4 ); + gtk_window_set_title( GTK_WINDOW( SurfaceInspector ), "Surface Inspector" ); + + SetWinPos_from_Prefs( SurfaceInspector ); + + viewport8 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport8 ); + gtk_container_add( GTK_CONTAINER( SurfaceInspector ), viewport8 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport8 ), GTK_SHADOW_NONE ); + + vbox7 = gtk_vbox_new( FALSE, 0 ); + gtk_widget_show( vbox7 ); + gtk_container_add( GTK_CONTAINER( viewport8 ), vbox7 ); + + viewport9 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport9 ); + gtk_box_pack_start( GTK_BOX( vbox7 ), viewport9, FALSE, FALSE, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport9 ), 2 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport9 ), GTK_SHADOW_ETCHED_IN ); + + hbox1 = gtk_hbox_new( FALSE, 0 ); + gtk_widget_show( hbox1 ); + gtk_container_add( GTK_CONTAINER( viewport9 ), hbox1 ); + gtk_container_set_border_width( GTK_CONTAINER( hbox1 ), 4 ); + + label = gtk_label_new( "Texture: " ); + gtk_widget_show( label ); + gtk_box_pack_start( GTK_BOX( hbox1 ), label, FALSE, FALSE, 0 ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + texture_combo = gtk_combo_new(); + g_object_set_data( G_OBJECT( GTK_COMBO( texture_combo )->popwin ), + "KeepMeAround", texture_combo ); + gtk_combo_disable_activate( (GtkCombo*) texture_combo ); + gtk_widget_show( texture_combo ); + gtk_box_pack_start( GTK_BOX( hbox1 ), texture_combo, TRUE, TRUE, 0 ); + + texture_combo_entry = GTK_COMBO( texture_combo )->entry; + gtk_widget_show( texture_combo_entry ); + gtk_entry_set_max_length( GTK_ENTRY( texture_combo_entry ), 128 ); + + viewport2 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport2 ); + gtk_box_pack_start( GTK_BOX( vbox7 ), viewport2, FALSE, TRUE, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport2 ), 2 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport2 ), GTK_SHADOW_ETCHED_IN ); + + table1 = gtk_table_new( 13, 4, FALSE ); + gtk_widget_show( table1 ); + gtk_container_add( GTK_CONTAINER( viewport2 ), table1 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 3, 4, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 3, 4, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 3, 4, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 5, 6, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 5, 6, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 5, 6, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 7, 8, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 7, 8, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 7, 8, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 9, 10, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 9, 10, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 9, 10, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 1, 2, 11, 12, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 2, 3, 11, 12, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 3, 4, 11, 12, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( "Offset" ); + gtk_widget_show( label ); + gtk_table_attach( GTK_TABLE( table1 ), label, 2, 3, 0, 1, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + + label = gtk_label_new( "Step" ); + gtk_widget_show( label ); + gtk_table_attach( GTK_TABLE( table1 ), label, 3, 4, 0, 1, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 3, 4, 12, 13, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + match_grid_button = gtk_button_new_with_mnemonic( "Match Grid" ); + gtk_widget_show( match_grid_button ); + gtk_container_add( GTK_CONTAINER( eventbox ), match_grid_button ); + + label = gtk_label_new( "Value" ); + gtk_widget_show( label ); + gtk_table_attach( GTK_TABLE( table1 ), label, 1, 2, 0, 1, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 3, 4, + (GtkAttachOptions) ( GTK_SHRINK | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 5, 6, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 7, 8, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 9, 10, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 11, 12, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 4, 5, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( "V Shift: " ); + gtk_widget_show( label ); + gtk_container_add( GTK_CONTAINER( eventbox ), label ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 6, 7, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( " H Scale: " ); + gtk_widget_show( label ); + gtk_container_add( GTK_CONTAINER( eventbox ), label ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 8, 9, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( "V Scale: " ); + gtk_widget_show( label ); + gtk_container_add( GTK_CONTAINER( eventbox ), label ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 10, 11, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( "Rotate: " ); + gtk_widget_show( label ); + gtk_container_add( GTK_CONTAINER( eventbox ), label ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 2, 3, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + label = gtk_label_new( "H Shift: " ); + gtk_widget_show( label ); + gtk_container_add( GTK_CONTAINER( eventbox ), label ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 1, 0.5 ); + + hseparator = gtk_hseparator_new(); + gtk_widget_show( hseparator ); + gtk_table_attach( GTK_TABLE( table1 ), hseparator, 0, 1, 1, 2, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 1, 2, 12, 13, + (GtkAttachOptions) ( GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + lock_valuechange_togglebutton = gtk_toggle_button_new_with_mnemonic( "UNLOCK" ); + gtk_widget_show( lock_valuechange_togglebutton ); + gtk_container_add( GTK_CONTAINER( eventbox ), lock_valuechange_togglebutton ); + + // Value Spins + hshift_value_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + hshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_value_spinbutton_adj ), 1, 2 ); + gtk_widget_show( hshift_value_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hshift_value_spinbutton, 1, 2, 2, 3, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_value_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_value_spinbutton ), TRUE ); + gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), FALSE ); + + vshift_value_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + vshift_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_value_spinbutton_adj ), 1, 2 ); + gtk_widget_show( vshift_value_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vshift_value_spinbutton, 1, 2, 4, 5, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_value_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_value_spinbutton ), TRUE ); + gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), FALSE ); + + hscale_value_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + hscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_value_spinbutton_adj ), 1, 4 ); + gtk_widget_show( hscale_value_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hscale_value_spinbutton, 1, 2, 6, 7, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_value_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_value_spinbutton ), TRUE ); + gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), FALSE ); + + vscale_value_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + vscale_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_value_spinbutton_adj ), 1, 4 ); + gtk_widget_show( vscale_value_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vscale_value_spinbutton, 1, 2, 8, 9, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_value_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vscale_value_spinbutton ), TRUE ); + gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), FALSE ); + + rotate_value_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); + rotate_value_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_value_spinbutton_adj ), 1, 0 ); + gtk_widget_show( rotate_value_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), rotate_value_spinbutton, 1, 2, 10, 11, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_value_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_value_spinbutton ), TRUE ); + gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), FALSE ); + + // Offset Spins + hshift_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + hshift_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_offset_spinbutton_adj ), 0, 2 ); + gtk_widget_show( hshift_offset_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hshift_offset_spinbutton, 2, 3, 2, 3, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 4, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hshift_offset_spinbutton ), TRUE ); + + vshift_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + vshift_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_offset_spinbutton_adj ), 0, 2 ); + gtk_widget_show( vshift_offset_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vshift_offset_spinbutton, 2, 3, 4, 5, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 4, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vshift_offset_spinbutton ), TRUE ); + + hscale_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + hscale_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_offset_spinbutton_adj ), 0, 4 ); + gtk_widget_show( hscale_offset_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hscale_offset_spinbutton, 2, 3, 6, 7, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 4, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( hscale_offset_spinbutton ), TRUE ); + + vscale_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + vscale_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_offset_spinbutton_adj ), 0, 4 ); + gtk_widget_show( vscale_offset_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vscale_offset_spinbutton, 2, 3, 8, 9, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 4, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( vscale_offset_spinbutton ), TRUE ); + + rotate_offset_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); + rotate_offset_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_offset_spinbutton_adj ), 0, 2 ); + gtk_widget_show( rotate_offset_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), rotate_offset_spinbutton, 2, 3, 10, 11, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 4, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), GTK_UPDATE_IF_VALID ); + gtk_spin_button_set_wrap( GTK_SPIN_BUTTON( rotate_offset_spinbutton ), TRUE ); + + // Step Spins + hshift_step_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + hshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hshift_step_spinbutton_adj ), 1, 2 ); + gtk_widget_show( hshift_step_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hshift_step_spinbutton, 3, 4, 2, 3, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hshift_step_spinbutton ), GTK_UPDATE_IF_VALID ); + + vshift_step_spinbutton_adj = gtk_adjustment_new( 0.0, -8192.0, 8192.0, 2.0, 8.0, 8.0 ); + vshift_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vshift_step_spinbutton_adj ), 1, 2 ); + gtk_widget_show( vshift_step_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vshift_step_spinbutton, 3, 4, 4, 5, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vshift_step_spinbutton ), GTK_UPDATE_IF_VALID ); + + hscale_step_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + hscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( hscale_step_spinbutton_adj ), 1, 4 ); + gtk_widget_show( hscale_step_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), hscale_step_spinbutton, 3, 4, 6, 7, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( hscale_step_spinbutton ), GTK_UPDATE_IF_VALID ); + + vscale_step_spinbutton_adj = gtk_adjustment_new( 0.0, -1024.0, 1024.0, 1.0, 4.0, 4.0 ); + vscale_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( vscale_step_spinbutton_adj ), 1, 4 ); + gtk_widget_show( vscale_step_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), vscale_step_spinbutton, 3, 4, 8, 9, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( vscale_step_spinbutton ), GTK_UPDATE_IF_VALID ); + + rotate_step_spinbutton_adj = gtk_adjustment_new( 0.0, -360.0, 360.0, 1.0, 10.0, 10.0 ); + rotate_step_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( rotate_step_spinbutton_adj ), 1, 2 ); + gtk_widget_show( rotate_step_spinbutton ); + gtk_table_attach( GTK_TABLE( table1 ), rotate_step_spinbutton, 3, 4, 10, 11, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( rotate_step_spinbutton ), GTK_UPDATE_IF_VALID ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 2, 3, 12, 13, + (GtkAttachOptions) ( 0 ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 12, 13, + (GtkAttachOptions) ( 0 ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table1 ), eventbox, 0, 1, 0, 1, + (GtkAttachOptions) ( 0 ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + + viewport7 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport7 ); + gtk_box_pack_start( GTK_BOX( vbox7 ), viewport7, FALSE, TRUE, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport7 ), 2 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport7 ), GTK_SHADOW_ETCHED_IN ); + + table4 = gtk_table_new( 4, 7, FALSE ); + gtk_widget_show( table4 ); + gtk_container_add( GTK_CONTAINER( viewport7 ), table4 ); + + viewport5 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport5 ); + gtk_table_attach( GTK_TABLE( table4 ), viewport5, 1, 7, 0, 4, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport5 ), 6 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport5 ), GTK_SHADOW_ETCHED_OUT ); + + table5 = gtk_table_new( 2, 3, FALSE ); + gtk_widget_show( table5 ); + gtk_container_add( GTK_CONTAINER( viewport5 ), table5 ); + gtk_container_set_border_width( GTK_CONTAINER( table5 ), 5 ); + gtk_table_set_col_spacings( GTK_TABLE( table5 ), 2 ); + + label = gtk_label_new( "Height" ); + gtk_widget_show( label ); + gtk_table_attach( GTK_TABLE( table5 ), label, 2, 3, 0, 1, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); + + label = gtk_label_new( "Width" ); + gtk_widget_show( label ); + gtk_table_attach( GTK_TABLE( table5 ), label, 1, 2, 0, 1, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + gtk_misc_set_alignment( GTK_MISC( label ), 0.5, 1 ); + + fit_width_spinbutton_adj = gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ); + fit_width_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( fit_width_spinbutton_adj ), 1, 0 ); + gtk_widget_show( fit_width_spinbutton ); + gtk_table_attach( GTK_TABLE( table5 ), fit_width_spinbutton, 1, 2, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_width_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_width_spinbutton ), GTK_UPDATE_IF_VALID ); + + fit_height_spinbutton_adj = gtk_adjustment_new( 1, 1, 32, 1, 10, 10 ); + fit_height_spinbutton = gtk_spin_button_new( GTK_ADJUSTMENT( fit_height_spinbutton_adj ), 1, 0 ); + gtk_widget_show( fit_height_spinbutton ); + gtk_table_attach( GTK_TABLE( table5 ), fit_height_spinbutton, 2, 3, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 3, 0 ); + gtk_spin_button_set_numeric( GTK_SPIN_BUTTON( fit_height_spinbutton ), TRUE ); + gtk_spin_button_set_update_policy( GTK_SPIN_BUTTON( fit_height_spinbutton ), GTK_UPDATE_IF_VALID ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table5 ), eventbox, 0, 1, 0, 1, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 0, 0 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table5 ), eventbox, 0, 1, 1, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_FILL ), 4, 0 ); + + fit_button = gtk_button_new_with_mnemonic( " Fit " ); + gtk_widget_show( fit_button ); + gtk_container_add( GTK_CONTAINER( eventbox ), fit_button ); + + viewport6 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport6 ); + gtk_table_attach( GTK_TABLE( table4 ), viewport6, 0, 1, 0, 4, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( 0 ), 0, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport6 ), 4 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport6 ), GTK_SHADOW_NONE ); + + table7 = gtk_table_new( 2, 1, FALSE ); + gtk_widget_show( table7 ); + gtk_container_add( GTK_CONTAINER( viewport6 ), table7 ); + + eventbox = gtk_event_box_new(); + gtk_widget_show( eventbox ); + gtk_table_attach( GTK_TABLE( table7 ), eventbox, 0, 1, 0, 2, + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), 0, 0 ); + + axial_button = gtk_button_new_with_mnemonic( "Axial" ); + gtk_widget_show( axial_button ); + gtk_container_add( GTK_CONTAINER( eventbox ), axial_button ); + gtk_widget_set_size_request( axial_button, 56, 29 ); + gtk_container_set_border_width( GTK_CONTAINER( axial_button ), 4 ); + + // Fit in Flags sub-dialog + Create_UFOAIFlagsDialog( vbox7 ); + + viewport10 = gtk_viewport_new( NULL, NULL ); + gtk_widget_show( viewport10 ); + gtk_box_pack_start( GTK_BOX( vbox7 ), viewport10, FALSE, TRUE, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( viewport10 ), 2 ); + gtk_viewport_set_shadow_type( GTK_VIEWPORT( viewport10 ), GTK_SHADOW_ETCHED_IN ); + + hbuttonbox1 = gtk_hbutton_box_new(); + gtk_widget_show( hbuttonbox1 ); + gtk_container_add( GTK_CONTAINER( viewport10 ), hbuttonbox1 ); + gtk_container_set_border_width( GTK_CONTAINER( hbuttonbox1 ), 4 ); + gtk_button_box_set_layout( GTK_BUTTON_BOX( hbuttonbox1 ), GTK_BUTTONBOX_SPREAD ); + + done_button = gtk_button_new(); + gtk_widget_show( done_button ); + gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), done_button ); + GTK_WIDGET_SET_FLAGS( done_button, GTK_CAN_DEFAULT ); + + alignment1 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); + gtk_widget_show( alignment1 ); + gtk_container_add( GTK_CONTAINER( done_button ), alignment1 ); + + hbox2 = gtk_hbox_new( FALSE, 2 ); + gtk_widget_show( hbox2 ); + gtk_container_add( GTK_CONTAINER( alignment1 ), hbox2 ); + + image1 = gtk_image_new_from_stock( "gtk-yes", GTK_ICON_SIZE_BUTTON ); + gtk_widget_show( image1 ); + gtk_box_pack_start( GTK_BOX( hbox2 ), image1, FALSE, FALSE, 0 ); + + label = gtk_label_new_with_mnemonic( "Done" ); + gtk_widget_show( label ); + gtk_box_pack_start( GTK_BOX( hbox2 ), label, FALSE, FALSE, 0 ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + + apply_button = gtk_button_new(); + gtk_widget_show( apply_button ); + gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), apply_button ); + GTK_WIDGET_SET_FLAGS( apply_button, GTK_CAN_DEFAULT ); + + alignment3 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); + gtk_widget_show( alignment3 ); + gtk_container_add( GTK_CONTAINER( apply_button ), alignment3 ); + + hbox4 = gtk_hbox_new( FALSE, 2 ); + gtk_widget_show( hbox4 ); + gtk_container_add( GTK_CONTAINER( alignment3 ), hbox4 ); + + image3 = gtk_image_new_from_stock( "gtk-apply", GTK_ICON_SIZE_BUTTON ); + gtk_widget_show( image3 ); + gtk_box_pack_start( GTK_BOX( hbox4 ), image3, FALSE, FALSE, 0 ); + + label = gtk_label_new_with_mnemonic( "Apply" ); + gtk_widget_show( label ); + gtk_box_pack_start( GTK_BOX( hbox4 ), label, FALSE, FALSE, 0 ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + + cancel_button = gtk_button_new(); + gtk_widget_show( cancel_button ); + gtk_container_add( GTK_CONTAINER( hbuttonbox1 ), cancel_button ); + GTK_WIDGET_SET_FLAGS( cancel_button, GTK_CAN_DEFAULT ); + + alignment2 = gtk_alignment_new( 0.5, 0.5, 0, 0 ); + gtk_widget_show( alignment2 ); + gtk_container_add( GTK_CONTAINER( cancel_button ), alignment2 ); + + hbox3 = gtk_hbox_new( FALSE, 2 ); + gtk_widget_show( hbox3 ); + gtk_container_add( GTK_CONTAINER( alignment2 ), hbox3 ); + + image2 = gtk_image_new_from_stock( "gtk-no", GTK_ICON_SIZE_BUTTON ); + gtk_widget_show( image2 ); + gtk_box_pack_start( GTK_BOX( hbox3 ), image2, FALSE, FALSE, 0 ); + + label = gtk_label_new_with_mnemonic( "Cancel" ); + gtk_widget_show( label ); + gtk_box_pack_start( GTK_BOX( hbox3 ), label, FALSE, FALSE, 0 ); + gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); + + + g_signal_connect( (gpointer) SurfaceInspector, + "delete_event", + G_CALLBACK( delete_event_callback ), + NULL ); + g_signal_connect( (gpointer) SurfaceInspector, "destroy", + G_CALLBACK( gtk_widget_destroy ), + NULL ); + + g_signal_connect( (gpointer) texture_combo_entry, "key_press_event", + G_CALLBACK( on_texture_combo_entry_key_press_event ), + NULL ); + g_signal_connect( (gpointer) texture_combo_entry, "activate", + G_CALLBACK( on_texture_combo_entry_activate ), + NULL ); + + + g_signal_connect( (gpointer) hshift_offset_spinbutton, "value_changed", + G_CALLBACK( on_hshift_offset_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vshift_offset_spinbutton, "value_changed", + G_CALLBACK( on_vshift_offset_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) hscale_offset_spinbutton, "value_changed", + G_CALLBACK( on_hscale_offset_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vscale_offset_spinbutton, "value_changed", + G_CALLBACK( on_vscale_offset_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) rotate_offset_spinbutton, "value_changed", + G_CALLBACK( on_rotate_offset_spinbutton_value_changed ), + NULL ); + + g_signal_connect( (gpointer) hshift_value_spinbutton, "value_changed", + G_CALLBACK( on_hshift_value_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vshift_value_spinbutton, "value_changed", + G_CALLBACK( on_vshift_value_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) hscale_value_spinbutton, "value_changed", + G_CALLBACK( on_hscale_value_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vscale_value_spinbutton, "value_changed", + G_CALLBACK( on_vscale_value_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) rotate_value_spinbutton, "value_changed", + G_CALLBACK( on_rotate_value_spinbutton_value_changed ), + NULL ); + + g_signal_connect( (gpointer) hshift_step_spinbutton, "value_changed", + G_CALLBACK( on_hshift_step_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vshift_step_spinbutton, "value_changed", + G_CALLBACK( on_vshift_step_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) hscale_step_spinbutton, "value_changed", + G_CALLBACK( on_hscale_step_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) vscale_step_spinbutton, "value_changed", + G_CALLBACK( on_vscale_step_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) rotate_step_spinbutton, "value_changed", + G_CALLBACK( on_rotate_step_spinbutton_value_changed ), + NULL ); + + g_signal_connect( (gpointer) match_grid_button, "clicked", + G_CALLBACK( on_match_grid_button_clicked ), + NULL ); + g_signal_connect( (gpointer) lock_valuechange_togglebutton, "toggled", + G_CALLBACK( on_lock_valuechange_togglebutton_toggled ), + NULL ); + + g_signal_connect( (gpointer) fit_width_spinbutton, "value_changed", + G_CALLBACK( on_fit_width_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) fit_height_spinbutton, "value_changed", + G_CALLBACK( on_fit_height_spinbutton_value_changed ), + NULL ); + g_signal_connect( (gpointer) fit_button, "clicked", + G_CALLBACK( on_fit_button_clicked ), + NULL ); + + g_signal_connect( (gpointer) axial_button, "clicked", + G_CALLBACK( on_axial_button_clicked ), + NULL ); + + g_signal_connect( (gpointer) done_button, "clicked", + G_CALLBACK( on_done_button_clicked ), + NULL ); + g_signal_connect( (gpointer) apply_button, "clicked", + G_CALLBACK( on_apply_button_clicked ), + NULL ); + g_signal_connect( (gpointer) cancel_button, "clicked", + G_CALLBACK( on_cancel_button_clicked ), + NULL ); + + + return SurfaceInspector; +} + + +// Texture Combo +gboolean on_texture_combo_entry_key_press_event( GtkWidget *widget, GdkEventKey *event, + gpointer user_data ){ + // Have Tab activate selection as well as Return + if ( event->keyval == GDK_Tab ) { + g_signal_emit_by_name( texture_combo_entry, "activate" ); + } + + return FALSE; +} + +void on_texture_combo_entry_activate( GtkEntry *entry, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + char text[128] = { 0 }; + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + // activate only on entry change + strcpy( text, gtk_entry_get_text( entry ) ); + if ( strcmp( old_texture_entry, text ) ) { + // Check for spaces in shader name + if ( text[0] <= ' ' || strchr( text, ' ' ) ) { + Sys_FPrintf( SYS_WRN, "WARNING: spaces in shader names are not allowed, ignoring '%s'\n", text ); + } + else + { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + strcpy( old_texture_entry, text ); + tmp_texdef->SetName( text ); + } + GetTexMods(); + } + } + } +} + +// Offset Spins +static void on_hshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_offset.shift[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_offset_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + if ( is_HShift_conflicting ) { + tmp_texdef->shift[0] = tmp_orig_texdef->shift[0] + texdef_offset.shift[0]; + } + else{ + tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0]; + } + } + GetTexMods(); + } +} + +static void on_vshift_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_offset.shift[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_offset_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + if ( is_VShift_conflicting ) { + tmp_texdef->shift[1] = tmp_orig_texdef->shift[1] + texdef_offset.shift[1]; + } + else{ + tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1]; + } + } + GetTexMods(); + } + +} + +static void on_hscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_offset.scale[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_offset_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + if ( is_HScale_conflicting ) { + tmp_texdef->scale[0] = tmp_orig_texdef->scale[0] + texdef_offset.scale[0]; + } + else{ + tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0]; + } + } + GetTexMods(); + } + + +} + +static void on_vscale_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_offset.scale[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_offset_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + if ( is_VScale_conflicting ) { + tmp_texdef->scale[1] = tmp_orig_texdef->scale[1] + texdef_offset.scale[1]; + } + else{ + tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1]; + } + } + GetTexMods(); + } + +} + +static void on_rotate_offset_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_offset.rotate = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_offset_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + if ( is_Rotate_conflicting ) { + tmp_texdef->rotate = tmp_orig_texdef->rotate + texdef_offset.rotate; + } + else{ + tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate; + } + } + GetTexMods(); + } + +} + + +// Match Grid +static void on_match_grid_button_clicked( GtkButton *button, gpointer user_data ){ + float hscale, vscale; + + if ( !strcmp( gtk_entry_get_text( GTK_ENTRY( hscale_value_spinbutton ) ), "" ) ) { + hscale = 0.0; + } + else{ + hscale = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); + } + + if ( !strcmp( gtk_entry_get_text( GTK_ENTRY( vscale_value_spinbutton ) ), "" ) ) { + vscale = 0.0; + } + else{ + vscale = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); + } + DoSnapTToGrid( hscale, vscale ); +} + + +// Lock out changes to Value +static void on_lock_valuechange_togglebutton_toggled( GtkToggleButton *togglebutton, gpointer user_data ){ + bool is_Locked; + + is_Locked = gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( lock_valuechange_togglebutton ) ); + + gtk_widget_set_sensitive( GTK_WIDGET( hscale_value_spinbutton ), is_Locked ); + gtk_widget_set_sensitive( GTK_WIDGET( vscale_value_spinbutton ), is_Locked ); + gtk_widget_set_sensitive( GTK_WIDGET( hshift_value_spinbutton ), is_Locked ); + gtk_widget_set_sensitive( GTK_WIDGET( vshift_value_spinbutton ), is_Locked ); + gtk_widget_set_sensitive( GTK_WIDGET( rotate_value_spinbutton ), is_Locked ); +} + + +// Value Spins +static void on_hshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_SI_values.shift[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_value_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + tmp_texdef->shift[0] = texdef_SI_values.shift[0] + texdef_offset.shift[0]; + is_HShift_conflicting = FALSE; + } + GetTexMods(); + } +} + +static void on_vshift_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_SI_values.shift[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_value_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + tmp_texdef->shift[1] = texdef_SI_values.shift[1] + texdef_offset.shift[1]; + is_VShift_conflicting = FALSE; + } + GetTexMods(); + } +} + +static void on_hscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_SI_values.scale[0] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + tmp_texdef->scale[0] = texdef_SI_values.scale[0] + texdef_offset.scale[0]; + is_HScale_conflicting = FALSE; + } + GetTexMods(); + } +} + +static void on_vscale_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_SI_values.scale[1] = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + tmp_texdef->scale[1] = texdef_SI_values.scale[1] + texdef_offset.scale[1]; + is_VScale_conflicting = FALSE; + } + GetTexMods(); + } +} + +static void on_rotate_value_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_t* tmp_orig_texdef; + texdef_to_face_t* temp_texdef_face_list; + + texdef_SI_values.rotate = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_value_spinbutton ) ); + + if ( !texdef_face_list_empty() && g_bListenChanged ) { + for ( temp_texdef_face_list = get_texdef_face_list(); temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = (texdef_t *) &temp_texdef_face_list->texdef; + tmp_orig_texdef = (texdef_t *) &temp_texdef_face_list->orig_texdef; + tmp_texdef->rotate = texdef_SI_values.rotate + texdef_offset.rotate; + is_Rotate_conflicting = FALSE; + } + GetTexMods(); + } +} + + +// Step Spins +static void on_hshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + gfloat val; + GtkAdjustment * adjust; + + if ( !g_bListenChanged ) { + return; + } + + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "OnIncrementChanged HShift\n" ); +#endif + + val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hshift_step_spinbutton ) ) ; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hshift_offset_spinbutton ) ); + adjust->step_increment = val; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hshift_value_spinbutton ) ); + adjust->step_increment = val; + l_pIncrement->shift[0] = val; +} + +static void on_vshift_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + gfloat val; + GtkAdjustment * adjust; + + if ( !g_bListenChanged ) { + return; + } + + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "OnIncrementChanged VShift\n" ); +#endif + + val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vshift_step_spinbutton ) ) ; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vshift_offset_spinbutton ) ); + adjust->step_increment = val; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vshift_value_spinbutton ) ); + adjust->step_increment = val; + l_pIncrement->shift[1] = val; +} + +static void on_hscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + gfloat val; + GtkAdjustment * adjust; + + if ( !g_bListenChanged ) { + return; + } + + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "OnIncrementChanged HShift\n" ); +#endif + + val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( hscale_step_spinbutton ) ) ; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hscale_offset_spinbutton ) ); + adjust->step_increment = val; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( hscale_value_spinbutton ) ); + adjust->step_increment = val; + l_pIncrement->scale[0] = val; +} + +static void on_vscale_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + gfloat val; + GtkAdjustment * adjust; + + if ( !g_bListenChanged ) { + return; + } + + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "OnIncrementChanged HShift\n" ); +#endif + + val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( vscale_step_spinbutton ) ) ; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vscale_offset_spinbutton ) ); + adjust->step_increment = val; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( vscale_value_spinbutton ) ); + adjust->step_increment = val; + l_pIncrement->scale[1] = val; +} + +static void on_rotate_step_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + gfloat val; + GtkAdjustment * adjust; + + if ( !g_bListenChanged ) { + return; + } + + l_pIncrement = Get_SI_Inc(); + +#ifdef DBG_SI + Sys_Printf( "OnIncrementChanged HShift\n" ); +#endif + + val = gtk_spin_button_get_value( GTK_SPIN_BUTTON( rotate_step_spinbutton ) ) ; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( rotate_offset_spinbutton ) ); + adjust->step_increment = val; + adjust = gtk_spin_button_get_adjustment( GTK_SPIN_BUTTON( rotate_value_spinbutton ) ); + adjust->step_increment = val; + l_pIncrement->rotate = val; +} + + +// Fit Texture +static void on_fit_width_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + m_nWidth = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( fit_width_spinbutton ) ); +} + +static void on_fit_height_spinbutton_value_changed( GtkSpinButton *spinbutton, gpointer user_data ){ + m_nHeight = gtk_spin_button_get_value_as_int( GTK_SPIN_BUTTON( fit_height_spinbutton ) ); +} + +static void on_fit_button_clicked( GtkButton *button, gpointer user_data ){ + FaceList_FitTexture( get_texdef_face_list(), m_nHeight, m_nWidth ); + Sys_UpdateWindows( W_ALL ); +} + + +// Axial Button +static void on_axial_button_clicked( GtkButton *button, gpointer user_data ){ + texdef_t* tmp_texdef; + texdef_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(); +} diff --git a/plugins/surface_ufoai/surfacedialog.h b/plugins/surface_ufoai/surfacedialog.h new file mode 100644 index 00000000..23b7ec9d --- /dev/null +++ b/plugins/surface_ufoai/surfacedialog.h @@ -0,0 +1,31 @@ +/* + 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 + */ + +#ifndef _SURFACEDIALOG_H_ +#define _SURFACEDIALOG_H_ + +void UpdateSurfaceDialog(); +void DoSurface(); +void ToggleSurface(); +void SurfaceDlgFitAll(); +GtkWidget *Get_SI_Module_Widget(); + +#endif // _SURFACEDIALOG_H_ diff --git a/plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp new file mode 100644 index 00000000..cbfad923 --- /dev/null +++ b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.cpp @@ -0,0 +1,406 @@ +/* + 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 + */ + +#include +#include +#include +#include + +#include "surfdlg_plugin.h" + +#include "surfaceflagsdialog_ufoai.h" + +GtkWidget *notebook1; + +// 32 bit is the max +#define MAX_BUTTONS 32 + +#ifdef _WIN32 +// TTimo: THIS IS UGLY +#define snprintf _snprintf +#endif + +GtkWidget *surface_buttons[MAX_BUTTONS]; +GtkWidget *content_buttons[MAX_BUTTONS]; + +GtkWidget *value_entry; +gboolean setup_buttons = TRUE; + +int working_surface_flags; +int surface_mask; +int working_content_flags; +int content_mask; +int working_value; + +inline void set_inconsistent( GtkWidget *toggle_button ){ + gtk_toggle_button_set_inconsistent( GTK_TOGGLE_BUTTON( toggle_button ), TRUE ); +} + +inline void clear_inconsistent( GtkWidget *toggle_button ){ + if ( gtk_toggle_button_get_inconsistent( GTK_TOGGLE_BUTTON( toggle_button ) ) ) { + gtk_toggle_button_set_inconsistent( GTK_TOGGLE_BUTTON( toggle_button ), FALSE ); + } +} + +void clear_all_inconsistent( void ){ + int i; + + for ( i = 0; i < MAX_BUTTONS; i++ ) { + clear_inconsistent( surface_buttons[i] ); + clear_inconsistent( content_buttons[i] ); + } +} + +void clear_all_buttons_and_values(){ + int i; + + for ( i = 0; i < MAX_BUTTONS; i++ ) { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( surface_buttons[i] ), FALSE ); + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( content_buttons[i] ), FALSE ); + } + + gtk_entry_set_text( (GtkEntry *)value_entry, "" ); +} + +void SetFlagButtons_UFOAI( texdef_to_face_t *texdef_face_list, bool b_isListEmpty ){ + int contents = 0; + int flags = 0; + int value = 0; + int diff_contents = 0; + int diff_flags = 0; + gboolean diff_value = FALSE; + char tex_buff[11]; + texdef_t* tmp_texdef; + texdef_to_face_t* temp_texdef_face_list; + int i; + + setup_buttons = TRUE; + working_surface_flags = 0; + surface_mask = 0; + working_content_flags = 0; + content_mask = 0; + working_value = 0; + + if ( !b_isListEmpty ) { + tmp_texdef = &texdef_face_list->texdef; + contents = tmp_texdef->contents; + flags = tmp_texdef->flags; + value = tmp_texdef->value; + + Sys_Printf( "Surface: %d\tContents: %d\tValue: %d\ttmp_texdef\n",tmp_texdef->flags,tmp_texdef->contents,tmp_texdef->value ); + Sys_Printf( "Surface: %d\tContents: %d\tValue: %d\n",flags,contents,value ); + + for ( temp_texdef_face_list = texdef_face_list->next; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = &temp_texdef_face_list->texdef; + diff_contents |= contents ^ tmp_texdef->contents; // Figure out which buttons are inconsistent + diff_flags |= flags ^ tmp_texdef->flags; + if ( tmp_texdef->value != value ) { + diff_value = TRUE; + } + + Sys_Printf( "Surface: %d\tContents: %d\tValue: %d\ttmp_texdef\n",tmp_texdef->flags,tmp_texdef->contents,tmp_texdef->value ); + Sys_Printf( "Surface: %d\tContents: %d\tValue: %d\n",flags,contents,value ); + } + } + + clear_all_inconsistent(); + + // If no faces/brushes are selected, clear everything and bail + if ( b_isListEmpty ) { + clear_all_buttons_and_values(); + setup_buttons = FALSE; + return; + } + + for ( i = 0; i < MAX_BUTTONS; i++ ) { + // Set surface buttons to reflect brush/face flags, contents, and values + if ( diff_flags & ( 1 << i ) ) { + set_inconsistent( surface_buttons[i] ); + } + else if ( flags & ( 1 << i ) ) { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( surface_buttons[i] ), TRUE ); + } + else{ + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( surface_buttons[i] ), FALSE ); + } + + if ( diff_contents & ( 1 << i ) ) { + set_inconsistent( content_buttons[i] ); + } + else if ( contents & ( 1 << i ) ) { + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( content_buttons[i] ), TRUE ); + } + else{ + gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( content_buttons[i] ), FALSE ); + } + } + + // Set Value + if ( diff_value ) { + gtk_entry_set_text( (GtkEntry *)value_entry, "" ); + } + else { + working_value = value; + sprintf( tex_buff, "%d", value ); + gtk_entry_set_text( (GtkEntry *)value_entry, tex_buff ); + } + + setup_buttons = FALSE; +} + +void SetChangeInFlags_Face_UFOAI( texdef_to_face_t *texdef_face_list ){ + texdef_to_face_t *temp_texdef_face_list; + texdef_t *tmp_texdef; + + for ( temp_texdef_face_list = texdef_face_list; temp_texdef_face_list; temp_texdef_face_list = temp_texdef_face_list->next ) + { + tmp_texdef = &temp_texdef_face_list->texdef; + tmp_texdef->flags = ( tmp_texdef->flags & ~surface_mask ) | working_surface_flags; + tmp_texdef->contents = ( tmp_texdef->contents & ~content_mask ) | working_content_flags; + tmp_texdef->value = working_value; + Sys_Printf( "content_flag: %d content_mask: %d\n",working_content_flags,content_mask ); + Sys_Printf( "content: %d\n",tmp_texdef->contents ); + } +} + +inline void change_surfaceflag( GtkWidget *togglebutton, int sur_flag, gboolean change_flag_to ){ + if ( !setup_buttons ) { // If we're setting up the buttons, we really don't need to + // set flags that are already set + if ( gtk_toggle_button_get_inconsistent( GTK_TOGGLE_BUTTON( togglebutton ) ) ) { // Clear out inconsistent, if set + clear_inconsistent( GTK_WIDGET( togglebutton ) ); + } + + surface_mask |= sur_flag; + + if ( change_flag_to ) { + working_surface_flags |= sur_flag; + } + else{ + working_surface_flags &= ~sur_flag; + } + } +} + +inline void change_contentflag( GtkWidget *togglebutton, int content_flag, gboolean change_flag_to ){ + if ( ( !setup_buttons ) ) { // If we're setting up the buttons, we really don't need to + // set flags that are already set + if ( gtk_toggle_button_get_inconsistent( GTK_TOGGLE_BUTTON( togglebutton ) ) ) { + clear_inconsistent( togglebutton ); + } + //if (g_ptrSelectedFaces.GetSize() == 0) // Only changing content flags on whole brushes, not faces. + //{ + content_mask |= content_flag; + + if ( change_flag_to ) { + working_content_flags |= content_flag; + } + else{ + working_content_flags &= ~content_flag; + } + //} + Sys_Printf( "content_flag: %d content_mask: %d\n",content_flag,content_mask ); + } +} + +// Surface Flags Callbacks +void on_surface_button_toggled( GtkToggleButton *togglebutton, gpointer user_data ){ + int flag = GPOINTER_TO_INT( user_data ); + change_surfaceflag( GTK_WIDGET( togglebutton ), flag, ( GTK_TOGGLE_BUTTON( togglebutton )->active ) ); +} + +// Content Flags Callbacks +void on_content_button_toggled( GtkToggleButton *togglebutton, gpointer user_data ){ + int flag = GPOINTER_TO_INT( user_data ); + change_contentflag( GTK_WIDGET( togglebutton ), flag, ( GTK_TOGGLE_BUTTON( togglebutton )->active ) ); +} + +// Value Entry Callback +void on_value_entry_changed( GtkEditable *editable, gpointer user_data ){ + if ( ( !setup_buttons ) ) { // If we're setting up the buttons, don't change value + working_value = atoi( gtk_entry_get_text( (GtkEntry*)editable ) ); + } +} + +void on_value_entry_insert_text( GtkEditable *editable, gchar *new_text, gint new_text_length, gint *position, gpointer user_data ){ + int i, count = 0; + gchar *result; + + // Limit input to digits, throwing out anything else + // Modified from Gtk FAQ for text filtering of GtkEntry + result = g_new( gchar, new_text_length ); + + for ( i = 0; i < new_text_length; i++ ) { + if ( !isdigit( new_text[i] ) ) { + continue; + } + result[count++] = new_text[i]; + } + + if ( count > 0 ) { + gtk_signal_handler_block_by_func( GTK_OBJECT( editable ), + GTK_SIGNAL_FUNC( on_value_entry_insert_text ), + user_data ); + gtk_editable_insert_text( editable, result, count, position ); + gtk_signal_handler_unblock_by_func( GTK_OBJECT( editable ), + GTK_SIGNAL_FUNC( on_value_entry_insert_text ), + user_data ); + } + gtk_signal_emit_stop_by_name( GTK_OBJECT( editable ), "insert_text" ); + + g_free( result ); +} + +void on_surfacebutton_clicked( GtkButton *button, gpointer user_data ){ + gtk_notebook_set_page( GTK_NOTEBOOK( notebook1 ), 0 ); +} + +void on_contentbutton_clicked( GtkButton *button, gpointer user_data ){ + gtk_notebook_set_page( GTK_NOTEBOOK( notebook1 ), 1 ); +} + +#define UFOAI_FLAG_BUTTON_BORDER 3 + +GtkWidget* Create_UFOAIFlagsDialog( GtkWidget* surfacedialog_widget ){ + GtkWidget *frame1; + GtkWidget *vbox1; + GtkWidget *vbox2; + GtkWidget *vbox3; + GtkWidget *vbox4; + GtkWidget *table4; + GtkWidget *hbox2; + GtkWidget *hbox3; + GtkWidget *hseparator1; + GtkWidget *value_label; + GtkWidget *label5; + GtkWidget *table3; + GtkWidget *label6; + int i, x, y; + const char *buttonLabel; + char buffer[8]; + + frame1 = gtk_frame_new( _( "Flags" ) ); + gtk_widget_show( frame1 ); + gtk_container_add( GTK_CONTAINER( surfacedialog_widget ), frame1 ); + + vbox1 = gtk_vbox_new( FALSE, 0 ); + gtk_widget_show( vbox1 ); + gtk_container_add( GTK_CONTAINER( frame1 ), vbox1 ); + + notebook1 = gtk_notebook_new(); + gtk_widget_show( notebook1 ); + gtk_box_pack_start( GTK_BOX( vbox1 ), notebook1, TRUE, TRUE, 0 ); + gtk_notebook_set_show_tabs( GTK_NOTEBOOK( notebook1 ), TRUE ); + gtk_container_set_border_width( GTK_CONTAINER( notebook1 ), 5 ); + + vbox2 = gtk_vbox_new( FALSE, 0 ); + gtk_widget_show( vbox2 ); + gtk_container_add( GTK_CONTAINER( notebook1 ), vbox2 ); + + table4 = gtk_table_new( 8, 4, FALSE ); + gtk_widget_show( table4 ); + gtk_box_pack_start( GTK_BOX( vbox2 ), table4, TRUE, TRUE, 0 ); + + y = -1; + for ( i = 0; i < MAX_BUTTONS; i++ ) { + if ( !( i % 4 ) ) { + y++; + } + x = i % 4; + snprintf( buffer, sizeof( buffer ) - 1, "surf%i", i + 1 ); + buttonLabel = g_FuncTable.m_pfnReadProjectKey( buffer ); + Sys_Printf( "%s: %s\n", buffer, buttonLabel ); + surface_buttons[i] = gtk_toggle_button_new_with_label( buttonLabel ); + gtk_signal_connect( GTK_OBJECT( surface_buttons[i] ), "toggled", GTK_SIGNAL_FUNC( on_surface_button_toggled ), GINT_TO_POINTER( 1 << i ) ); + gtk_widget_show( surface_buttons[i] ); + gtk_table_attach( GTK_TABLE( table4 ), surface_buttons[i], 0 + x, 1 + x, ( 0 + y ), ( 1 + y ), + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), 0, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( surface_buttons[i] ), UFOAI_FLAG_BUTTON_BORDER ); + } + + hseparator1 = gtk_hseparator_new(); + gtk_widget_show( hseparator1 ); + gtk_box_pack_start( GTK_BOX( vbox2 ), hseparator1, FALSE, FALSE, 0 ); + gtk_widget_set_usize( hseparator1, -2, 5 ); + + hbox2 = gtk_hbox_new( FALSE, 0 ); + gtk_widget_show( hbox2 ); + gtk_box_pack_start( GTK_BOX( vbox2 ), hbox2, FALSE, FALSE, 0 ); + + hbox3 = gtk_hbox_new( FALSE, 0 ); + gtk_widget_show( hbox3 ); + gtk_box_pack_start( GTK_BOX( hbox2 ), hbox3, TRUE, TRUE, 0 ); + + vbox4 = gtk_vbox_new( FALSE, 0 ); + gtk_widget_show( vbox4 ); + gtk_box_pack_start( GTK_BOX( hbox3 ), vbox4, TRUE, TRUE, 0 ); + + value_label = gtk_label_new( " Value: " ); + gtk_widget_show( value_label ); + gtk_box_pack_start( GTK_BOX( hbox3 ), value_label, FALSE, FALSE, 0 ); + + value_entry = gtk_entry_new(); + gtk_signal_connect( GTK_OBJECT( value_entry ), "changed", + GTK_SIGNAL_FUNC( on_value_entry_changed ), + NULL ); + gtk_signal_connect( GTK_OBJECT( value_entry ), "insert_text", + GTK_SIGNAL_FUNC( on_value_entry_insert_text ), + NULL ); + gtk_entry_set_max_length( (GtkEntry *)value_entry, 11 ); + gtk_widget_show( value_entry ); + gtk_box_pack_start( GTK_BOX( hbox3 ), value_entry, TRUE, TRUE, 0 ); + + vbox3 = gtk_vbox_new( FALSE, 0 ); + gtk_widget_show( vbox3 ); + gtk_box_pack_start( GTK_BOX( hbox3 ), vbox3, TRUE, TRUE, 0 ); + + label5 = gtk_label_new( "Surface Flags" ); + gtk_widget_show( label5 ); + gtk_notebook_set_tab_label( GTK_NOTEBOOK( notebook1 ), gtk_notebook_get_nth_page( GTK_NOTEBOOK( notebook1 ), 0 ), label5 ); + + table3 = gtk_table_new( 8, 4, FALSE ); + gtk_widget_show( table3 ); + gtk_container_add( GTK_CONTAINER( notebook1 ), table3 ); + + y = -1; + for ( i = 0; i < MAX_BUTTONS; i++ ) { + if ( !( i % 4 ) ) { + y++; + } + x = i % 4; + snprintf( buffer, sizeof( buffer ) - 1, "cont%i", i + 1 ); + buttonLabel = g_FuncTable.m_pfnReadProjectKey( buffer ); + content_buttons[i] = gtk_toggle_button_new_with_label( buttonLabel ); + gtk_signal_connect( GTK_OBJECT( content_buttons[i] ), "toggled", GTK_SIGNAL_FUNC( on_content_button_toggled ), GINT_TO_POINTER( 1 << i ) ); + gtk_widget_show( content_buttons[i] ); + gtk_table_attach( GTK_TABLE( table3 ), content_buttons[i], 0 + x, 1 + x, ( 0 + y ), ( 1 + y ), + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), + (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ), 0, 0 ); + gtk_container_set_border_width( GTK_CONTAINER( content_buttons[i] ), UFOAI_FLAG_BUTTON_BORDER ); + } + + label6 = gtk_label_new( "Content Flags" ); + gtk_widget_show( label6 ); + gtk_notebook_set_tab_label( GTK_NOTEBOOK( notebook1 ), gtk_notebook_get_nth_page( GTK_NOTEBOOK( notebook1 ), 1 ), label6 ); + + return frame1; +} diff --git a/plugins/surface_ufoai/surfaceflagsdialog_ufoai.h b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.h new file mode 100644 index 00000000..210bb4a1 --- /dev/null +++ b/plugins/surface_ufoai/surfaceflagsdialog_ufoai.h @@ -0,0 +1,25 @@ +/* + 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 + */ + +#ifndef _SURFACEFLAGSDIALOG_UFOAI_H +#define _SURFACEFLAGSDIALOG_UFOAI_H + +#endif // _SURFACEFLAGSDIALOG_UFOAI_H diff --git a/plugins/surface_ufoai/surfdlg_plugin.cpp b/plugins/surface_ufoai/surfdlg_plugin.cpp new file mode 100644 index 00000000..a73aa0ca --- /dev/null +++ b/plugins/surface_ufoai/surfdlg_plugin.cpp @@ -0,0 +1,120 @@ +/* + Copyright (c) 2001, Loki software, inc. + All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list + of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + + Neither the name of Loki software nor the names of its contributors may be used + to endorse or promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY + DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#include +#include "surfdlg_plugin.h" +#include "surfacedialog.h" + +#include "synapse.h" + +class CSynapseClient_SurfDLG : public CSynapseClient +{ +public: +// CSynapseClient API +bool RequestAPI( APIDescriptor_t *pAPI ); +const char* GetInfo(); +const char* GetName(); +bool OnActivate(); + +CSynapseClient_SurfDLG() { } +virtual ~CSynapseClient_SurfDLG() { } +}; + +// ============================================================================= +// SYNAPSE + +_QERFuncTable_1 g_FuncTable; +_QERUndoTable g_UndoTable; +_QERAppSurfaceTable g_AppSurfaceTable; +_QERSelectedFaceTable g_SelectedFaceTable; +_QERShadersTable g_ShadersTable; +_QERAppShadersTable g_AppShadersTable; +_QERAppDataTable g_AppDataTable; + +CSynapseServer* g_pSynapseServer = NULL; +CSynapseClient_SurfDLG g_SynapseClient; + +#if __GNUC__ >= 4 +#pragma GCC visibility push(default) +#endif +extern "C" CSynapseClient * SYNAPSE_DLL_EXPORT Synapse_EnumerateInterfaces( const char *version, CSynapseServer *pServer ) { +#if __GNUC__ >= 4 +#pragma GCC visibility pop +#endif + if ( strcmp( version, SYNAPSE_VERSION ) ) { + Syn_Printf( "ERROR: synapse API version mismatch: should be '" SYNAPSE_VERSION "', got '%s'\n", version ); + return NULL; + } + g_pSynapseServer = pServer; + g_pSynapseServer->IncRef(); + Set_Syn_Printf( g_pSynapseServer->Get_Syn_Printf() ); + + g_SynapseClient.AddAPI( SURFACEDIALOG_MAJOR, "ufoai", sizeof( _QERPlugSurfaceTable ) ); + g_SynapseClient.AddAPI( RADIANT_MAJOR, NULL, sizeof( _QERFuncTable_1 ), SYN_REQUIRE, &g_FuncTable ); + g_SynapseClient.AddAPI( UNDO_MAJOR, NULL, sizeof( _QERUndoTable ), SYN_REQUIRE, &g_UndoTable ); + g_SynapseClient.AddAPI( APPSURFACEDIALOG_MAJOR, NULL, sizeof( _QERAppSurfaceTable ), SYN_REQUIRE, &g_AppSurfaceTable ); + g_SynapseClient.AddAPI( SELECTEDFACE_MAJOR, NULL, sizeof( _QERSelectedFaceTable ), SYN_REQUIRE, &g_SelectedFaceTable ); + g_SynapseClient.AddAPI( SHADERS_MAJOR, "ufoai", sizeof( _QERShadersTable ), SYN_REQUIRE, &g_ShadersTable ); + g_SynapseClient.AddAPI( APPSHADERS_MAJOR, NULL, sizeof( _QERAppShadersTable ), SYN_REQUIRE, &g_AppShadersTable ); + g_SynapseClient.AddAPI( DATA_MAJOR, NULL, sizeof( _QERAppDataTable ), SYN_REQUIRE, &g_AppDataTable ); + + return &g_SynapseClient; +} + +bool CSynapseClient_SurfDLG::RequestAPI( APIDescriptor_t *pAPI ){ + if ( !strcmp( pAPI->major_name, SURFACEDIALOG_MAJOR ) ) { + _QERPlugSurfaceTable* pSurfDialogTable = static_cast<_QERPlugSurfaceTable*>( pAPI->mpTable ); + if ( !strcmp( pAPI->minor_name, "ufoai" ) ) { + pSurfDialogTable->m_pfnToggleSurface = &ToggleSurface; + pSurfDialogTable->m_pfnDoSurface = &DoSurface; + pSurfDialogTable->m_pfnUpdateSurfaceDialog = &UpdateSurfaceDialog; + pSurfDialogTable->m_pfnSurfaceDlgFitAll = &SurfaceDlgFitAll; + pSurfDialogTable->m_pfnGet_SI_Module_Widget = &Get_SI_Module_Widget; + return true; + } + } + + Syn_Printf( "ERROR: RequestAPI( '%s' ) not found in '%s'\n", pAPI->major_name, GetInfo() ); + return false; +} + +#include "version.h" + +const char* CSynapseClient_SurfDLG::GetInfo(){ + return "Surface Dialog (UFO: Alien Invasion) module built " __DATE__ " " RADIANT_VERSION; +} + +const char* CSynapseClient_SurfDLG::GetName(){ + return "surface"; +} + +bool CSynapseClient_SurfDLG::OnActivate(){ + return true; +} diff --git a/plugins/surface_ufoai/surfdlg_plugin.h b/plugins/surface_ufoai/surfdlg_plugin.h new file mode 100644 index 00000000..b90020d5 --- /dev/null +++ b/plugins/surface_ufoai/surfdlg_plugin.h @@ -0,0 +1,97 @@ +/* + Copyright (c) 2001, Loki software, inc. + All rights reserved. + + Redistribution and use in source and binary forms, with or without modification, + are permitted provided that the following conditions are met: + + Redistributions of source code must retain the above copyright notice, this list + of conditions and the following disclaimer. + + Redistributions in binary form must reproduce the above copyright notice, this + list of conditions and the following disclaimer in the documentation and/or + other materials provided with the distribution. + + Neither the name of Loki software nor the names of its contributors may be used + to endorse or promote products derived from this software without specific prior + written permission. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS'' + AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE + IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE + DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE FOR ANY + DIRECT,INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES + (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; + LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON + ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT + (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS + SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + +#ifndef _SURFDLG_PLUGIN_H_ +#define _SURFDLG_PLUGIN_H_ + +#ifdef __linux__ + +typedef void* HMODULE; +typedef void* LPVOID; +typedef char* LPCSTR; + +#endif // __linux__ + +#include "qerplugin.h" +#include "synapse.h" +#include "iselectedface.h" +#include "iundo.h" +#include "ishaders.h" +#include "mathlib.h" +#include "missing.h" +#include "idata.h" + +#include "isurfaceplugin.h" + +class SurfaceDialog : public IPluginTexdef +{ +int refCount; +public: +// Increment the number of references to this object +void IncRef() { refCount++; } +// Decrement the reference count +void DecRef() { + if ( --refCount <= 0 ) { + delete this; + } +} +}; + +extern _QERFuncTable_1 g_FuncTable; +extern _QERUndoTable g_UndoTable; +extern _QERAppSurfaceTable g_AppSurfaceTable; +extern _QERSelectedFaceTable g_SelectedFaceTable; +extern _QERShadersTable g_ShadersTable; +extern _QERAppShadersTable g_AppShadersTable; +extern _QERAppDataTable g_AppDataTable; + +#define GetSelectedFaceCount g_SelectedFaceTable.m_pfnGetSelectedFaceCount + +#define Undo_Undo g_UndoTable.m_pfnUndo_Undo +#define Undo_GetUndoId g_UndoTable.m_pfnUndo_GetUndoId + +#define Sys_Printf g_FuncTable.m_pfnSysPrintf +#define Sys_FPrintf g_FuncTable.m_pfnSysFPrintf +#define Sys_UpdateWindows g_FuncTable.m_pfnSysUpdateWindows + + +#define Select_FitTexture g_AppSurfaceTable.m_pfnSelect_FitTexture +#define Get_SI_Inc g_AppSurfaceTable.m_pfnQERApp_QeglobalsSavedinfo_SIInc +#define GridSize g_AppSurfaceTable.m_pfnQeglobalsGetGridSize +#define FaceList_FitTexture g_AppSurfaceTable.m_pfnFaceList_FitTexture +#define GetMainWindow g_AppSurfaceTable.m_pfnGetMainWindow +#define GetSelectedFaceCountfromBrushes g_AppSurfaceTable.m_pfnGetSelectedFaceCountfromBrushes +#define GetSelFacesTexdef g_AppSurfaceTable.m_pfnGetSelFacesTexdef +#define SetTexdef_FaceList g_AppSurfaceTable.m_pfnSetTexdef_FaceList +#define SetWinPos_from_Prefs g_AppSurfaceTable.m_pfnSetWinPos_From_Prefs + +#define Texturewin g_AppShadersTable.m_pfnQeglobalsTexturewin + +#endif // _SURFDLG_PLUGIN_H_