Wrap more GTK
[xonotic/netradiant.git] / contrib / sunplug / sunplug.cpp
1 /*
2    Sunplug plugin for GtkRadiant
3    Copyright (C) 2004 Topsun
4    Thanks to SPoG for help!
5
6    This library is free software; you can redistribute it and/or
7    modify it under the terms of the GNU Lesser General Public
8    License as published by the Free Software Foundation; either
9    version 2.1 of the License, or (at your option) any later version.
10
11    This library is distributed in the hope that it will be useful,
12    but WITHOUT ANY WARRANTY; without even the implied warranty of
13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14    Lesser General Public License for more details.
15
16    You should have received a copy of the GNU Lesser General Public
17    License along with this library; if not, write to the Free Software
18    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 #include "sunplug.h"
22 #include "globaldefs.h"
23
24 #include "debugging/debugging.h"
25
26 #include "iplugin.h"
27
28 #include "string/string.h"
29 #include "modulesystem/singletonmodule.h"
30
31 #include "iundo.h"       // declaration of undo system
32 #include "ientity.h"     // declaration of entity system
33 #include "iscenegraph.h" // declaration of datastructure of the map
34
35 #include "scenelib.h"    // declaration of datastructure of the map
36 #include "qerplugin.h"   // declaration to use other interfaces as a plugin
37
38 #include <gtk/gtk.h>     // to display something with gtk (windows, buttons etc.), the whole package might not be necessary
39
40 void about_plugin_window();
41 void MapCoordinator();
42
43 #if !GDEF_OS_WINDOWS
44 // linux itoa implementation
45 char* itoa( int value, char* result, int base ){
46         // check that the base if valid
47         if ( base < 2 || base > 16 ) {
48                 *result = 0;
49                 return result;
50         }
51
52         char* out = result;
53         int quotient = value;
54
55         do
56         {
57                 *out = "0123456789abcdef"[abs( quotient % base )];
58                 ++out;
59
60                 quotient /= base;
61         } while ( quotient );
62
63         // Only apply negative sign for base 10
64         if ( value < 0 && base == 10 ) {
65                 *out++ = '-';
66         }
67
68         std::reverse( result, out );
69
70         *out = 0;
71         return result;
72 }
73 #endif
74
75 typedef struct _mapcoord_setting_packet {
76         GtkSpinButton *spinner1, *spinner2, *spinner3, *spinner4;
77         Entity* worldspawn;
78 } mapcoord_setting_packet;
79
80 static int map_minX, map_maxX, map_minY, map_maxY;
81 static int minX, maxX, minY, maxY;
82 mapcoord_setting_packet msp;
83
84 //  **************************
85 // ** find entities by class **  from radiant/map.cpp
86 //  **************************
87 class EntityFindByClassname : public scene::Graph::Walker
88 {
89 const char* m_name;
90 Entity*& m_entity;
91 public:
92 EntityFindByClassname( const char* name, Entity*& entity ) : m_name( name ), m_entity( entity ){
93         m_entity = 0;
94 }
95 bool pre( const scene::Path& path, scene::Instance& instance ) const {
96         if ( m_entity == 0 ) {
97                 Entity* entity = Node_getEntity( path.top() );
98                 if ( entity != 0
99                          && string_equal( m_name, entity->getKeyValue( "classname" ) ) ) {
100                         m_entity = entity;
101                 }
102         }
103         return true;
104 }
105 };
106
107 Entity* Scene_FindEntityByClass( const char* name ){
108         Entity* entity;
109         GlobalSceneGraph().traverse( EntityFindByClassname( name, entity ) );
110         return entity;
111 }
112
113 //  **************************
114 // ** GTK callback functions **
115 //  **************************
116
117 static gboolean delete_event( GtkWidget *widget, GdkEvent *event, gpointer data ){
118         /* If you return FALSE in the "delete_event" signal handler,
119          * GTK will emit the "destroy" signal. Returning TRUE means
120          * you don't want the window to be destroyed.
121          * This is useful for popping up 'are you sure you want to quit?'
122          * type dialogs. */
123
124         return FALSE;
125 }
126
127 // destroy widget if destroy signal is passed to widget
128 static void destroy( ui::Widget widget, gpointer data ){
129         widget.destroy();
130 }
131
132 // function for close button to destroy the toplevel widget
133 static void close_window( ui::Widget widget, gpointer data ){
134         widget.window().destroy();
135 }
136
137 // callback function to assign the optimal mapcoords to the spinboxes
138 static void input_optimal( GtkWidget *widget, gpointer data ){
139         gtk_spin_button_set_value( msp.spinner1, minX );
140         gtk_spin_button_set_value( msp.spinner2, maxY );
141         gtk_spin_button_set_value( msp.spinner3, maxX );
142         gtk_spin_button_set_value( msp.spinner4, minY );
143 }
144
145 // Spinner return value function
146 gint grab_int_value( GtkSpinButton *a_spinner, gpointer user_data ) {
147         return gtk_spin_button_get_value_as_int( a_spinner );
148 }
149
150 // write the values of the Spinner-Boxes to the worldspawn
151 static void set_coordinates( ui::Widget widget, gpointer data ){
152         //Str str_min, str_max;
153         char buffer[10], str_min[20], str_max[20];
154
155         itoa( gtk_spin_button_get_value_as_int( msp.spinner1 ), str_min, 10 );
156         itoa( gtk_spin_button_get_value_as_int( msp.spinner2 ), buffer, 10 );
157         strcat( str_min, " " );
158         strcat( str_min, buffer );
159         msp.worldspawn->setKeyValue( "mapcoordsmins", str_min );
160
161         itoa( gtk_spin_button_get_value_as_int( msp.spinner3 ), str_max, 10 );
162         itoa( gtk_spin_button_get_value_as_int( msp.spinner4 ), buffer, 10 );
163         strcat( str_max, " " );
164         strcat( str_max, buffer );
165         UndoableCommand undo( "SunPlug.entitySetMapcoords" );
166         msp.worldspawn->setKeyValue( "mapcoordsmaxs", str_max );
167
168         close_window( widget, NULL );
169 }
170
171 class SunPlugPluginDependencies :
172         public GlobalRadiantModuleRef,  // basic class for all other module refs
173         public GlobalUndoModuleRef,     // used to say radiant that something has changed and to undo that
174         public GlobalSceneGraphModuleRef, // necessary to handle data in the mapfile (change, retrieve data)
175         public GlobalEntityModuleRef    // to access and modify the entities
176 {
177 public:
178 SunPlugPluginDependencies() :
179         GlobalEntityModuleRef( GlobalRadiant().getRequiredGameDescriptionKeyValue( "entities" ) ){ //,
180 }
181 };
182
183 //  *************************
184 // ** standard plugin stuff **
185 //  *************************
186 namespace SunPlug
187 {
188 ui::Window main_window{ui::null};
189 char MenuList[100] = "";
190
191 const char* init( void* hApp, void* pMainWidget ){
192         main_window = ui::Window::from(pMainWidget);
193         return "Initializing SunPlug for GTKRadiant";
194 }
195 const char* getName(){
196         return "SunPlug"; // name that is shown in the menue
197 }
198 const char* getCommandList(){
199         const char about[] = "About...";
200         const char etMapCoordinator[] = ";ET-MapCoordinator";
201
202         strcat( MenuList, about );
203         if ( strncmp( GlobalRadiant().getGameName(), "etmain", 6 ) == 0 ) {
204                 strcat( MenuList, etMapCoordinator );
205         }
206         return (const char*)MenuList;
207 }
208 const char* getCommandTitleList(){
209         return "";
210 }
211 void dispatch( const char* command, float* vMin, float* vMax, bool bSingleBrush ){ // message processing
212         if ( string_equal( command, "About..." ) ) {
213                 about_plugin_window();
214         }
215         if ( string_equal( command, "ET-MapCoordinator" ) ) {
216                 MapCoordinator();
217         }
218 }
219 } // namespace
220
221 class SunPlugModule : public TypeSystemRef
222 {
223 _QERPluginTable m_plugin;
224 public:
225 typedef _QERPluginTable Type;
226 STRING_CONSTANT( Name, "SunPlug" );
227
228 SunPlugModule(){
229         m_plugin.m_pfnQERPlug_Init = &SunPlug::init;
230         m_plugin.m_pfnQERPlug_GetName = &SunPlug::getName;
231         m_plugin.m_pfnQERPlug_GetCommandList = &SunPlug::getCommandList;
232         m_plugin.m_pfnQERPlug_GetCommandTitleList = &SunPlug::getCommandTitleList;
233         m_plugin.m_pfnQERPlug_Dispatch = &SunPlug::dispatch;
234 }
235 _QERPluginTable* getTable(){
236         return &m_plugin;
237 }
238 };
239
240 typedef SingletonModule<SunPlugModule, SunPlugPluginDependencies> SingletonSunPlugModule;
241
242 SingletonSunPlugModule g_SunPlugModule;
243
244
245 extern "C" void RADIANT_DLLEXPORT Radiant_RegisterModules( ModuleServer& server ){
246         initialiseModule( server );
247
248         g_SunPlugModule.selfRegister();
249 }
250
251 //  ************
252 // ** my stuff **
253 //  ************
254
255 // About dialog
256 void about_plugin_window(){
257         auto window = ui::Window( ui::window_type::TOP ); // create a window
258         gtk_window_set_transient_for( window, SunPlug::main_window ); // make the window to stay in front of the main window
259         window.connect( "delete_event", G_CALLBACK( delete_event ), NULL ); // connect the delete event
260         window.connect( "destroy", G_CALLBACK( destroy ), NULL ); // connect the destroy event for the window
261         gtk_window_set_title( window, "About SunPlug" ); // set the title of the window for the window
262         gtk_window_set_resizable( window, FALSE ); // don't let the user resize the window
263         gtk_window_set_modal( window, TRUE ); // force the user not to do something with the other windows
264         gtk_container_set_border_width( GTK_CONTAINER( window ), 10 ); // set the border of the window
265
266         auto vbox = ui::VBox( FALSE, 10 ); // create a box to arrange new objects vertically
267         window.add(vbox);
268
269         auto label = ui::Label( "SunPlug v1.0 for NetRadiant 1.5\nby Topsun" ); // create a label
270         gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // text align left
271         vbox.pack_start( label, FALSE, FALSE, 2 ); // insert the label in the box
272
273         auto button = ui::Button( "OK" ); // create a button with text
274         g_signal_connect_swapped( G_OBJECT( button ), "clicked", G_CALLBACK( gtk_widget_destroy ), (void *) window ); // connect the click event to close the window
275         vbox.pack_start( button, FALSE, FALSE, 2 ); // insert the button in the box
276
277         gtk_window_set_position( window, GTK_WIN_POS_CENTER ); // center the window on screen
278
279         gtk_widget_show_all( window ); // show the window and all subelements
280 }
281
282 // get the current bounding box and return the optimal coordinates
283 void GetOptimalCoordinates( AABB *levelBoundingBox ){
284         int half_width, half_heigth, center_x, center_y;
285
286         half_width = levelBoundingBox->extents.x();
287         half_heigth = levelBoundingBox->extents.y();
288         center_x = levelBoundingBox->origin.x();
289         center_y = levelBoundingBox->origin.y();
290
291         if ( half_width > 175 || half_heigth > 175 ) { // the square must be at least 350x350 units
292                 // the wider side is the indicator for the square
293                 if ( half_width >= half_heigth ) {
294                         minX = center_x - half_width;
295                         maxX = center_x + half_width;
296                         minY = center_y - half_width;
297                         maxY = center_y + half_width;
298                 }
299                 else {
300                         minX = center_x - half_heigth;
301                         maxX = center_x + half_heigth;
302                         minY = center_y - half_heigth;
303                         maxY = center_y + half_heigth;
304                 }
305         }
306         else {
307                 minX = center_x - 175;
308                 maxX = center_x + 175;
309                 minY = center_y - 175;
310                 maxY = center_y + 175;
311         }
312 }
313
314 // MapCoordinator dialog window
315 void MapCoordinator(){
316         GtkWidget *spinnerMinX, *spinnerMinY, *spinnerMaxX, *spinnerMaxY;
317         Entity *theWorldspawn = NULL;
318         const char *buffer;
319         char line[20];
320
321         // in any case we need a window to show the user what to do
322         auto window = ui::Window( ui::window_type::TOP ); // create the window
323         gtk_window_set_transient_for( window, SunPlug::main_window ); // make the window to stay in front of the main window
324         window.connect( "delete_event", G_CALLBACK( delete_event ), NULL ); // connect the delete event for the window
325         window.connect( "destroy", G_CALLBACK( destroy ), NULL ); // connect the destroy event for the window
326         gtk_window_set_title( window, "ET-MapCoordinator" ); // set the title of the window for the window
327         gtk_window_set_resizable( window, FALSE ); // don't let the user resize the window
328         gtk_window_set_modal( window, TRUE ); // force the user not to do something with the other windows
329         gtk_container_set_border_width( GTK_CONTAINER( window ), 10 ); // set the border of the window
330
331         auto vbox = ui::VBox( FALSE, 10 ); // create a box to arrange new objects vertically
332         window.add(vbox);
333
334         scene::Path path = makeReference( GlobalSceneGraph().root() ); // get the path to the root element of the graph
335         scene::Instance* instance = GlobalSceneGraph().find( path ); // find the instance to the given path
336         AABB levelBoundingBox = instance->worldAABB(); // get the bounding box of the level
337
338         theWorldspawn = Scene_FindEntityByClass( "worldspawn" ); // find the entity worldspawn
339         if ( theWorldspawn != 0 ) { // need to have a worldspawn otherwise setting a value crashes the radiant
340                 // next two if's: get the current values of the mapcoords
341                 buffer = theWorldspawn->getKeyValue( "mapcoordsmins" ); // upper left corner
342                 if ( strlen( buffer ) > 0 ) {
343                         strncpy( line, buffer, 19 );
344                         map_minX = atoi( strtok( line, " " ) ); // minimum of x value
345                         map_minY = atoi( strtok( NULL, " " ) ); // maximum of y value
346                 }
347                 else {
348                         map_minX = 0;
349                         map_minY = 0;
350                 }
351                 buffer = theWorldspawn->getKeyValue( "mapcoordsmaxs" ); // lower right corner
352                 if ( strlen( buffer ) > 0 ) {
353                         strncpy( line, buffer, 19 );
354                         map_maxX = atoi( strtok( line, " " ) ); // maximum of x value
355                         map_maxY = atoi( strtok( NULL, " " ) ); // minimum of y value
356                 }
357                 else {
358                         map_maxX = 0;
359                         map_maxY = 0;
360                 }
361
362                 globalOutputStream() << "SunPlug: calculating optimal coordinates\n"; // write to console that we are calculating the coordinates
363                 GetOptimalCoordinates( &levelBoundingBox ); // calculate optimal mapcoords with the dimensions of the level bounding box
364                 globalOutputStream() << "SunPlug: adviced mapcoordsmins=" << minX << " " << maxY << "\n"; // console info about mapcoordsmins
365                 globalOutputStream() << "SunPlug: adviced mapcoordsmaxs=" << maxX << " " << minY << "\n"; // console info about mapcoordsmaxs
366
367                 auto spinner_adj_MinX = ui::Adjustment( map_minX, -65536.0, 65536.0, 1.0, 5.0, 0 ); // create adjustment for value and range of minimum x value
368                 auto spinner_adj_MinY = ui::Adjustment( map_minY, -65536.0, 65536.0, 1.0, 5.0, 0 ); // create adjustment for value and range of minimum y value
369                 auto spinner_adj_MaxX = ui::Adjustment( map_maxX, -65536.0, 65536.0, 1.0, 5.0, 0 ); // create adjustment for value and range of maximum x value
370                 auto spinner_adj_MaxY = ui::Adjustment( map_maxY, -65536.0, 65536.0, 1.0, 5.0, 0 ); // create adjustment for value and range of maximum y value
371
372                 auto button = ui::Button( "Get optimal mapcoords" ); // create button with text
373                 button.connect( "clicked", G_CALLBACK( input_optimal ), NULL ); // connect button with callback function
374                 vbox.pack_start( button, FALSE, FALSE, 2 ); // insert button into vbox
375
376                 vbox.pack_start( ui::Widget(gtk_hseparator_new()), FALSE, FALSE, 2 ); // insert separator into vbox
377
378                 auto table = ui::Table( 4, 3, TRUE ); // create table
379                 gtk_table_set_row_spacings( GTK_TABLE( table ), 8 ); // set row spacings
380                 gtk_table_set_col_spacings( GTK_TABLE( table ), 8 ); // set column spacings
381                 vbox.pack_start( table, FALSE, FALSE, 2 ); // insert table into vbox
382
383                 auto label = ui::Label( "x" ); // create label
384                 gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // align text to the left side
385                 gtk_table_attach_defaults( GTK_TABLE( table ), label, 1, 2, 0, 1 ); // insert label into table
386
387                 label = ui::Label( "y" ); // create label
388                 gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // align text to the left side
389                 gtk_table_attach_defaults( GTK_TABLE( table ), label, 2, 3, 0, 1 ); // insert label into table
390
391                 label = ui::Label( "mapcoordsmins" ); // create label
392                 gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // align text to the left side
393                 gtk_table_attach_defaults( GTK_TABLE( table ), label, 0, 1, 1, 2 ); // insert label into table
394
395                 spinnerMinX = ui::SpinButton( spinner_adj_MinX, 1.0, 0 ); // create textbox wiht value spin, value and value range
396                 gtk_table_attach_defaults( GTK_TABLE( table ), spinnerMinX, 1, 2, 1, 2 ); // insert spinbox into table
397
398                 spinnerMinY = ui::SpinButton( spinner_adj_MinY, 1.0, 0 ); // create textbox wiht value spin, value and value range
399                 gtk_table_attach_defaults( GTK_TABLE( table ), spinnerMinY, 2, 3, 1, 2 ); // insert spinbox into table
400
401                 label = ui::Label( "mapcoordsmaxs" ); // create label
402                 gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // align text to the left side
403                 gtk_table_attach_defaults( GTK_TABLE( table ), label, 0, 1, 2, 3 ); // insert label into table
404
405                 spinnerMaxX = ui::SpinButton( spinner_adj_MaxX, 1.0, 0 ); // create textbox wiht value spin, value and value range
406                 gtk_table_attach_defaults( GTK_TABLE( table ), spinnerMaxX, 1, 2, 2, 3 ); // insert spinbox into table
407
408                 spinnerMaxY = ui::SpinButton( spinner_adj_MaxY, 1.0, 0 ); // create textbox wiht value spin, value and value range
409                 gtk_table_attach_defaults( GTK_TABLE( table ), spinnerMaxY, 2, 3, 2, 3 ); // insert spinbox into table
410
411                 // put the references to the spinboxes and the worldspawn into the global exchange
412                 msp.spinner1 = GTK_SPIN_BUTTON( spinnerMinX );
413                 msp.spinner2 = GTK_SPIN_BUTTON( spinnerMinY );
414                 msp.spinner3 = GTK_SPIN_BUTTON( spinnerMaxX );
415                 msp.spinner4 = GTK_SPIN_BUTTON( spinnerMaxY );
416                 msp.worldspawn = theWorldspawn;
417
418                 button = ui::Button( "Set" ); // create button with text
419                 button.connect( "clicked", G_CALLBACK( set_coordinates ), NULL ); // connect button with callback function
420                 gtk_table_attach_defaults( GTK_TABLE( table ), button, 1, 2, 3, 4 ); // insert button into table
421
422                 button = ui::Button( "Cancel" ); // create button with text
423                 button.connect( "clicked", G_CALLBACK( close_window ), NULL ); // connect button with callback function
424                 gtk_table_attach_defaults( GTK_TABLE( table ), button, 2, 3, 3, 4 ); // insert button into table
425         }
426         else {
427                 globalOutputStream() << "SunPlug: no worldspawn found!\n"; // output error to console
428
429                 auto label = ui::Label( "ERROR: No worldspawn was found in the map!\nIn order to use this tool the map must have at least one brush in the worldspawn. " ); // create a label
430                 gtk_label_set_justify( GTK_LABEL( label ), GTK_JUSTIFY_LEFT ); // text align left
431                 vbox.pack_start( label, FALSE, FALSE, 2 ); // insert the label in the box
432
433                 auto button = ui::Button( "OK" ); // create a button with text
434                 button.connect( "clicked", G_CALLBACK( close_window ), NULL ); // connect the click event to close the window
435                 vbox.pack_start( button, FALSE, FALSE, 2 ); // insert the button in the box
436         }
437
438         gtk_window_set_position( window, GTK_WIN_POS_CENTER ); // center the window
439         gtk_widget_show_all( window ); // show the window and all subelements
440 }