Now that the dialog has the flip buttons, the menu is no longer needed
[xonotic/netradiant.git] / radiant / patchmanip.cpp
1 /*
2    Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3    For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5    This file is part of GtkRadiant.
6
7    GtkRadiant is free software; you can redistribute it and/or modify
8    it under the terms of the GNU General Public License as published by
9    the Free Software Foundation; either version 2 of the License, or
10    (at your option) any later version.
11
12    GtkRadiant is distributed in the hope that it will be useful,
13    but WITHOUT ANY WARRANTY; without even the implied warranty of
14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15    GNU General Public License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GtkRadiant; if not, write to the Free Software
19    Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20  */
21
22 #include "patchmanip.h"
23
24 #include "debugging/debugging.h"
25
26
27 #include "iselection.h"
28 #include "ipatch.h"
29
30 #include "math/vector.h"
31 #include "math/aabb.h"
32 #include "generic/callback.h"
33
34 #include "gtkutil/menu.h"
35 #include "gtkutil/image.h"
36 #include "map.h"
37 #include "mainframe.h"
38 #include "commands.h"
39 #include "gtkmisc.h"
40 #include "gtkdlgs.h"
41 #include "texwindow.h"
42 #include "xywindow.h"
43 #include "select.h"
44 #include "patch.h"
45 #include "grid.h"
46
47 PatchCreator* g_patchCreator = 0;
48
49 void Scene_PatchConstructPrefab( scene::Graph& graph, const AABB aabb, const char* shader, EPatchPrefab eType, int axis, std::size_t width = 3, std::size_t height = 3 ){
50         Select_Delete();
51         GlobalSelectionSystem().setSelectedAll( false );
52
53         NodeSmartReference node( g_patchCreator->createPatch() );
54         Node_getTraversable( Map_FindOrInsertWorldspawn( g_map ) )->insert( node );
55
56         Patch* patch = Node_getPatch( node );
57         patch->SetShader( shader );
58
59         patch->ConstructPrefab( aabb, eType, axis, width, height );
60         patch->controlPointsChanged();
61
62         {
63                 scene::Path patchpath( makeReference( GlobalSceneGraph().root() ) );
64                 patchpath.push( makeReference( *Map_GetWorldspawn( g_map ) ) );
65                 patchpath.push( makeReference( node.get() ) );
66                 Instance_getSelectable( *graph.find( patchpath ) )->setSelected( true );
67         }
68 }
69
70
71 void Patch_makeCaps( Patch& patch, scene::Instance& instance, EPatchCap type, const char* shader ){
72         if ( ( type == eCapEndCap || type == eCapIEndCap )
73                  && patch.getWidth() != 5 ) {
74                 globalErrorStream() << "cannot create end-cap - patch width != 5\n";
75                 return;
76         }
77         if ( ( type == eCapBevel || type == eCapIBevel )
78                  && patch.getWidth() != 3 && patch.getWidth() != 5 ) {
79                 globalErrorStream() << "cannot create bevel-cap - patch width != 3\n";
80                 return;
81         }
82         if ( type == eCapCylinder
83                  && patch.getWidth() != 9 ) {
84                 globalErrorStream() << "cannot create cylinder-cap - patch width != 9\n";
85                 return;
86         }
87
88         {
89                 NodeSmartReference cap( g_patchCreator->createPatch() );
90                 Node_getTraversable( instance.path().parent() )->insert( cap );
91
92                 patch.MakeCap( Node_getPatch( cap ), type, ROW, true );
93                 Node_getPatch( cap )->SetShader( shader );
94
95                 scene::Path path( instance.path() );
96                 path.pop();
97                 path.push( makeReference( cap.get() ) );
98                 selectPath( path, true );
99         }
100
101         {
102                 NodeSmartReference cap( g_patchCreator->createPatch() );
103                 Node_getTraversable( instance.path().parent() )->insert( cap );
104
105                 patch.MakeCap( Node_getPatch( cap ), type, ROW, false );
106                 Node_getPatch( cap )->SetShader( shader );
107
108                 scene::Path path( instance.path() );
109                 path.pop();
110                 path.push( makeReference( cap.get() ) );
111                 selectPath( path, true );
112         }
113 }
114
115 typedef std::vector<scene::Instance*> InstanceVector;
116
117 class PatchStoreInstance
118 {
119 InstanceVector& m_instances;
120 public:
121 PatchStoreInstance( InstanceVector& instances ) : m_instances( instances ){
122 }
123 void operator()( PatchInstance& patch ) const {
124         m_instances.push_back( &patch );
125 }
126 };
127
128 enum ECapDialog {
129         PATCHCAP_BEVEL = 0,
130         PATCHCAP_ENDCAP,
131         PATCHCAP_INVERTED_BEVEL,
132         PATCHCAP_INVERTED_ENDCAP,
133         PATCHCAP_CYLINDER
134 };
135
136 EMessageBoxReturn DoCapDlg( ECapDialog *type );
137
138 void Scene_PatchDoCap_Selected( scene::Graph& graph, const char* shader ){
139         ECapDialog nType;
140
141         if ( DoCapDlg( &nType ) == eIDOK ) {
142                 EPatchCap eType;
143                 switch ( nType )
144                 {
145                 case PATCHCAP_INVERTED_BEVEL:
146                         eType = eCapIBevel;
147                         break;
148                 case PATCHCAP_BEVEL:
149                         eType = eCapBevel;
150                         break;
151                 case PATCHCAP_INVERTED_ENDCAP:
152                         eType = eCapIEndCap;
153                         break;
154                 case PATCHCAP_ENDCAP:
155                         eType = eCapEndCap;
156                         break;
157                 case PATCHCAP_CYLINDER:
158                         eType = eCapCylinder;
159                         break;
160                 default:
161                         ERROR_MESSAGE( "invalid patch cap type" );
162                         return;
163                 }
164
165                 InstanceVector instances;
166                 Scene_forEachVisibleSelectedPatchInstance( PatchStoreInstance( instances ) );
167                 for ( InstanceVector::const_iterator i = instances.begin(); i != instances.end(); ++i )
168                 {
169                         Patch_makeCaps( *Node_getPatch( ( *i )->path().top() ), *( *i ), eType, shader );
170                 }
171         }
172 }
173
174 Patch* Scene_GetUltimateSelectedVisiblePatch(){
175         if ( GlobalSelectionSystem().countSelected() != 0 ) {
176                 scene::Node& node = GlobalSelectionSystem().ultimateSelected().path().top();
177                 if ( node.visible() ) {
178                         return Node_getPatch( node );
179                 }
180         }
181         return 0;
182 }
183
184
185 class PatchCapTexture
186 {
187 public:
188 void operator()( Patch& patch ) const {
189         patch.ProjectTexture( Patch::m_CycleCapIndex );
190 }
191 };
192
193 void Scene_PatchCapTexture_Selected( scene::Graph& graph ){
194         Scene_forEachVisibleSelectedPatch( PatchCapTexture() );
195         Patch::m_CycleCapIndex = ( Patch::m_CycleCapIndex == 0 ) ? 1 : ( Patch::m_CycleCapIndex == 1 ) ? 2 : 0;
196         SceneChangeNotify();
197 }
198
199 class PatchFlipTexture
200 {
201 int m_axis;
202 public:
203 PatchFlipTexture( int axis ) : m_axis( axis ){
204 }
205 void operator()( Patch& patch ) const {
206         patch.FlipTexture( m_axis );
207 }
208 };
209
210 void Scene_PatchFlipTexture_Selected( scene::Graph& graph, int axis ){
211         Scene_forEachVisibleSelectedPatch( PatchFlipTexture( axis ) );
212 }
213
214 class PatchNaturalTexture
215 {
216 public:
217 void operator()( Patch& patch ) const {
218         patch.NaturalTexture();
219 }
220 };
221
222 void Scene_PatchNaturalTexture_Selected( scene::Graph& graph ){
223         Scene_forEachVisibleSelectedPatch( PatchNaturalTexture() );
224         SceneChangeNotify();
225 }
226
227
228 class PatchInsertRemove
229 {
230 bool m_insert, m_column, m_first;
231 public:
232 PatchInsertRemove( bool insert, bool column, bool first ) : m_insert( insert ), m_column( column ), m_first( first ){
233 }
234 void operator()( Patch& patch ) const {
235         patch.InsertRemove( m_insert, m_column, m_first );
236 }
237 };
238
239 void Scene_PatchInsertRemove_Selected( scene::Graph& graph, bool bInsert, bool bColumn, bool bFirst ){
240         Scene_forEachVisibleSelectedPatch( PatchInsertRemove( bInsert, bColumn, bFirst ) );
241 }
242
243 class PatchInvertMatrix
244 {
245 public:
246 void operator()( Patch& patch ) const {
247         patch.InvertMatrix();
248 }
249 };
250
251 void Scene_PatchInvert_Selected( scene::Graph& graph ){
252         Scene_forEachVisibleSelectedPatch( PatchInvertMatrix() );
253 }
254
255 class PatchRedisperse
256 {
257 EMatrixMajor m_major;
258 public:
259 PatchRedisperse( EMatrixMajor major ) : m_major( major ){
260 }
261 void operator()( Patch& patch ) const {
262         patch.Redisperse( m_major );
263 }
264 };
265
266 void Scene_PatchRedisperse_Selected( scene::Graph& graph, EMatrixMajor major ){
267         Scene_forEachVisibleSelectedPatch( PatchRedisperse( major ) );
268 }
269
270 class PatchSmooth
271 {
272 EMatrixMajor m_major;
273 public:
274 PatchSmooth( EMatrixMajor major ) : m_major( major ){
275 }
276 void operator()( Patch& patch ) const {
277         patch.Smooth( m_major );
278 }
279 };
280
281 void Scene_PatchSmooth_Selected( scene::Graph& graph, EMatrixMajor major ){
282         Scene_forEachVisibleSelectedPatch( PatchSmooth( major ) );
283 }
284
285 class PatchTransposeMatrix
286 {
287 public:
288 void operator()( Patch& patch ) const {
289         patch.TransposeMatrix();
290 }
291 };
292
293 void Scene_PatchTranspose_Selected( scene::Graph& graph ){
294         Scene_forEachVisibleSelectedPatch( PatchTransposeMatrix() );
295 }
296
297 class PatchSetShader
298 {
299 const char* m_name;
300 public:
301 PatchSetShader( const char* name )
302         : m_name( name ){
303 }
304 void operator()( Patch& patch ) const {
305         patch.SetShader( m_name );
306 }
307 };
308
309 void Scene_PatchSetShader_Selected( scene::Graph& graph, const char* name ){
310         Scene_forEachVisibleSelectedPatch( PatchSetShader( name ) );
311         SceneChangeNotify();
312 }
313
314 void Scene_PatchGetShader_Selected( scene::Graph& graph, CopiedString& name ){
315         Patch* patch = Scene_GetUltimateSelectedVisiblePatch();
316         if ( patch != 0 ) {
317                 name = patch->GetShader();
318         }
319 }
320
321 class PatchSelectByShader
322 {
323 const char* m_name;
324 public:
325 inline PatchSelectByShader( const char* name )
326         : m_name( name ){
327 }
328 void operator()( PatchInstance& patch ) const {
329         if ( shader_equal( patch.getPatch().GetShader(), m_name ) ) {
330                 patch.setSelected( true );
331         }
332 }
333 };
334
335 void Scene_PatchSelectByShader( scene::Graph& graph, const char* name ){
336         Scene_forEachVisiblePatchInstance( PatchSelectByShader( name ) );
337 }
338
339
340 class PatchFindReplaceShader
341 {
342 const char* m_find;
343 const char* m_replace;
344 public:
345 PatchFindReplaceShader( const char* find, const char* replace ) : m_find( find ), m_replace( replace ){
346 }
347 void operator()( Patch& patch ) const {
348         if ( shader_equal( patch.GetShader(), m_find ) ) {
349                 patch.SetShader( m_replace );
350         }
351 }
352 };
353
354 void Scene_PatchFindReplaceShader( scene::Graph& graph, const char* find, const char* replace ){
355         Scene_forEachVisiblePatch( PatchFindReplaceShader( find, replace ) );
356 }
357
358 void Scene_PatchFindReplaceShader_Selected( scene::Graph& graph, const char* find, const char* replace ){
359         Scene_forEachVisibleSelectedPatch( PatchFindReplaceShader( find, replace ) );
360 }
361
362
363 AABB PatchCreator_getBounds(){
364         AABB aabb( aabb_for_minmax( Select_getWorkZone().d_work_min, Select_getWorkZone().d_work_max ) );
365
366         float gridSize = GetGridSize();
367
368         if ( aabb.extents[0] == 0 ) {
369                 aabb.extents[0] = gridSize;
370         }
371         if ( aabb.extents[1] == 0 ) {
372                 aabb.extents[1] = gridSize;
373         }
374         if ( aabb.extents[2] == 0 ) {
375                 aabb.extents[2] = gridSize;
376         }
377
378         if ( aabb_valid( aabb ) ) {
379                 return aabb;
380         }
381         return AABB( Vector3( 0, 0, 0 ), Vector3( 64, 64, 64 ) );
382 }
383
384 void DoNewPatchDlg( EPatchPrefab prefab, int minrows, int mincols, int defrows, int defcols, int maxrows, int maxcols );
385
386 void Patch_XactCylinder(){
387         UndoableCommand undo( "patchCreateXactCylinder" );
388
389         DoNewPatchDlg( eXactCylinder, 3, 7, 3, 13, 0, 0 );
390 }
391
392 void Patch_XactSphere(){
393         UndoableCommand undo( "patchCreateXactSphere" );
394
395         DoNewPatchDlg( eXactSphere, 5, 7, 7, 13, 0, 0 );
396 }
397
398 void Patch_XactCone(){
399         UndoableCommand undo( "patchCreateXactCone" );
400
401         DoNewPatchDlg( eXactCone, 3, 7, 3, 13, 0, 0 );
402 }
403
404 void Patch_Cylinder(){
405         UndoableCommand undo( "patchCreateCylinder" );
406
407         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eCylinder, GlobalXYWnd_getCurrentViewType() );
408 }
409
410 void Patch_DenseCylinder(){
411         UndoableCommand undo( "patchCreateDenseCylinder" );
412
413         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eDenseCylinder, GlobalXYWnd_getCurrentViewType() );
414 }
415
416 void Patch_VeryDenseCylinder(){
417         UndoableCommand undo( "patchCreateVeryDenseCylinder" );
418
419         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eVeryDenseCylinder, GlobalXYWnd_getCurrentViewType() );
420 }
421
422 void Patch_SquareCylinder(){
423         UndoableCommand undo( "patchCreateSquareCylinder" );
424
425         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eSqCylinder, GlobalXYWnd_getCurrentViewType() );
426 }
427
428 void Patch_Endcap(){
429         UndoableCommand undo( "patchCreateCaps" );
430
431         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eEndCap, GlobalXYWnd_getCurrentViewType() );
432 }
433
434 void Patch_Bevel(){
435         UndoableCommand undo( "patchCreateBevel" );
436
437         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eBevel, GlobalXYWnd_getCurrentViewType() );
438 }
439
440 void Patch_Sphere(){
441         UndoableCommand undo( "patchCreateSphere" );
442
443         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eSphere, GlobalXYWnd_getCurrentViewType() );
444 }
445
446 void Patch_SquareBevel(){
447 }
448
449 void Patch_SquareEndcap(){
450 }
451
452 void Patch_Cone(){
453         UndoableCommand undo( "patchCreateCone" );
454
455         Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), eCone, GlobalXYWnd_getCurrentViewType() );
456 }
457
458 void Patch_Plane(){
459         UndoableCommand undo( "patchCreatePlane" );
460
461         DoNewPatchDlg( ePlane, 3, 3, 3, 3, 0, 0 );
462 }
463
464 void Patch_InsertInsertColumn(){
465         UndoableCommand undo( "patchInsertColumns" );
466
467         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), true, true, false );
468 }
469
470 void Patch_InsertAddColumn(){
471         UndoableCommand undo( "patchAddColumns" );
472
473         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), true, true, true );
474 }
475
476 void Patch_InsertInsertRow(){
477         UndoableCommand undo( "patchInsertRows" );
478
479         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), true, false, false );
480 }
481
482 void Patch_InsertAddRow(){
483         UndoableCommand undo( "patchAddRows" );
484
485         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), true, false, true );
486 }
487
488 void Patch_DeleteFirstColumn(){
489         UndoableCommand undo( "patchDeleteFirstColumns" );
490
491         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), false, true, true );
492 }
493
494 void Patch_DeleteLastColumn(){
495         UndoableCommand undo( "patchDeleteLastColumns" );
496
497         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), false, true, false );
498 }
499
500 void Patch_DeleteFirstRow(){
501         UndoableCommand undo( "patchDeleteFirstRows" );
502
503         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), false, false, true );
504 }
505
506 void Patch_DeleteLastRow(){
507         UndoableCommand undo( "patchDeleteLastRows" );
508
509         Scene_PatchInsertRemove_Selected( GlobalSceneGraph(), false, false, false );
510 }
511
512 void Patch_Invert(){
513         UndoableCommand undo( "patchInvert" );
514
515         Scene_PatchInvert_Selected( GlobalSceneGraph() );
516 }
517
518 void Patch_RedisperseRows(){
519         UndoableCommand undo( "patchRedisperseRows" );
520
521         Scene_PatchRedisperse_Selected( GlobalSceneGraph(), ROW );
522 }
523
524 void Patch_RedisperseCols(){
525         UndoableCommand undo( "patchRedisperseColumns" );
526
527         Scene_PatchRedisperse_Selected( GlobalSceneGraph(), COL );
528 }
529
530 void Patch_SmoothRows(){
531         UndoableCommand undo( "patchSmoothRows" );
532
533         Scene_PatchSmooth_Selected( GlobalSceneGraph(), ROW );
534 }
535
536 void Patch_SmoothCols(){
537         UndoableCommand undo( "patchSmoothColumns" );
538
539         Scene_PatchSmooth_Selected( GlobalSceneGraph(), COL );
540 }
541
542 void Patch_Transpose(){
543         UndoableCommand undo( "patchTranspose" );
544
545         Scene_PatchTranspose_Selected( GlobalSceneGraph() );
546 }
547
548 void Patch_Cap(){
549         // FIXME: add support for patch cap creation
550         // Patch_CapCurrent();
551         UndoableCommand undo( "patchCreateCaps" );
552
553         Scene_PatchDoCap_Selected( GlobalSceneGraph(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ) );
554 }
555
556 void Patch_CycleProjection(){
557         UndoableCommand undo( "patchCycleUVProjectionAxis" );
558
559         Scene_PatchCapTexture_Selected( GlobalSceneGraph() );
560 }
561
562 ///\todo Unfinished.
563 void Patch_OverlayOn(){
564 }
565
566 ///\todo Unfinished.
567 void Patch_OverlayOff(){
568 }
569
570 void Patch_FlipTextureX(){
571         UndoableCommand undo( "patchFlipTextureU" );
572
573         Scene_PatchFlipTexture_Selected( GlobalSceneGraph(), 0 );
574 }
575
576 void Patch_FlipTextureY(){
577         UndoableCommand undo( "patchFlipTextureV" );
578
579         Scene_PatchFlipTexture_Selected( GlobalSceneGraph(), 1 );
580 }
581
582 void Patch_NaturalTexture(){
583         UndoableCommand undo( "patchNaturalTexture" );
584
585         Scene_PatchNaturalTexture_Selected( GlobalSceneGraph() );
586 }
587
588 void Patch_CapTexture(){
589         UndoableCommand command( "patchCapTexture" );
590
591         Scene_PatchCapTexture_Selected( GlobalSceneGraph() );
592 }
593
594 void Patch_ResetTexture(){
595         float fx, fy;
596         if ( DoTextureLayout( &fx, &fy ) == eIDOK ) {
597                 UndoableCommand command( "patchTileTexture" );
598                 Scene_PatchTileTexture_Selected( GlobalSceneGraph(), fx, fy );
599         }
600 }
601
602 void Patch_FitTexture(){
603         UndoableCommand command( "patchFitTexture" );
604
605         Scene_PatchTileTexture_Selected( GlobalSceneGraph(), 1, 1 );
606 }
607
608 #include "ifilter.h"
609
610
611 class filter_patch_all : public PatchFilter
612 {
613 public:
614 bool filter( const Patch& patch ) const {
615         return true;
616 }
617 };
618
619 class filter_patch_shader : public PatchFilter
620 {
621 const char* m_shader;
622 public:
623 filter_patch_shader( const char* shader ) : m_shader( shader ){
624 }
625 bool filter( const Patch& patch ) const {
626         return shader_equal( patch.GetShader(), m_shader );
627 }
628 };
629
630 class filter_patch_flags : public PatchFilter
631 {
632 int m_flags;
633 public:
634 filter_patch_flags( int flags ) : m_flags( flags ){
635 }
636 bool filter( const Patch& patch ) const {
637         return ( patch.getShaderFlags() & m_flags ) != 0;
638 }
639 };
640
641
642 filter_patch_all g_filter_patch_all;
643 filter_patch_shader g_filter_patch_clip( "textures/common/clip" );
644 filter_patch_shader g_filter_patch_weapclip( "textures/common/weapclip" );
645 filter_patch_flags g_filter_patch_translucent( QER_TRANS );
646
647 void PatchFilters_construct(){
648         add_patch_filter( g_filter_patch_all, EXCLUDE_CURVES );
649         add_patch_filter( g_filter_patch_clip, EXCLUDE_CLIP );
650         add_patch_filter( g_filter_patch_weapclip, EXCLUDE_CLIP );
651         add_patch_filter( g_filter_patch_translucent, EXCLUDE_TRANSLUCENT );
652 }
653
654
655 #include "preferences.h"
656
657 void Patch_constructPreferences( PreferencesPage& page ){
658         page.appendEntry( "Patch Subdivide Threshold", g_PatchSubdivideThreshold );
659 }
660 void Patch_constructPage( PreferenceGroup& group ){
661         PreferencesPage page( group.createPage( "Patches", "Patch Display Preferences" ) );
662         Patch_constructPreferences( page );
663 }
664 void Patch_registerPreferencesPage(){
665         PreferencesDialog_addDisplayPage( FreeCaller1<PreferenceGroup&, Patch_constructPage>() );
666 }
667
668
669 #include "preferencesystem.h"
670
671 void PatchPreferences_construct(){
672         GlobalPreferenceSystem().registerPreference( "Subdivisions", IntImportStringCaller( g_PatchSubdivideThreshold ), IntExportStringCaller( g_PatchSubdivideThreshold ) );
673 }
674
675
676 #include "generic/callback.h"
677
678 void Patch_registerCommands(){
679         GlobalCommands_insert( "InvertCurveTextureX", FreeCaller<Patch_FlipTextureX>(), Accelerator( 'I', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
680         GlobalCommands_insert( "InvertCurveTextureY", FreeCaller<Patch_FlipTextureY>(), Accelerator( 'I', (GdkModifierType)GDK_SHIFT_MASK ) );
681         GlobalCommands_insert( "NaturalizePatch", FreeCaller<Patch_NaturalTexture>(), Accelerator( 'N', (GdkModifierType)GDK_CONTROL_MASK ) );
682         GlobalCommands_insert( "PatchCylinder", FreeCaller<Patch_Cylinder>() );
683         GlobalCommands_insert( "PatchDenseCylinder", FreeCaller<Patch_DenseCylinder>() );
684         GlobalCommands_insert( "PatchVeryDenseCylinder", FreeCaller<Patch_VeryDenseCylinder>() );
685         GlobalCommands_insert( "PatchSquareCylinder", FreeCaller<Patch_SquareCylinder>() );
686         GlobalCommands_insert( "PatchXactCylinder", FreeCaller<Patch_XactCylinder>() );
687         GlobalCommands_insert( "PatchXactSphere", FreeCaller<Patch_XactSphere>() );
688         GlobalCommands_insert( "PatchXactCone", FreeCaller<Patch_XactCone>() );
689         GlobalCommands_insert( "PatchEndCap", FreeCaller<Patch_Endcap>() );
690         GlobalCommands_insert( "PatchBevel", FreeCaller<Patch_Bevel>() );
691         GlobalCommands_insert( "PatchSquareBevel", FreeCaller<Patch_SquareBevel>() );
692         GlobalCommands_insert( "PatchSquareEndcap", FreeCaller<Patch_SquareEndcap>() );
693         GlobalCommands_insert( "PatchCone", FreeCaller<Patch_Cone>() );
694         GlobalCommands_insert( "PatchSphere", FreeCaller<Patch_Sphere>() );
695         GlobalCommands_insert( "SimplePatchMesh", FreeCaller<Patch_Plane>(), Accelerator( 'P', (GdkModifierType)GDK_SHIFT_MASK ) );
696         GlobalCommands_insert( "PatchInsertInsertColumn", FreeCaller<Patch_InsertInsertColumn>(), Accelerator( GDK_KP_Add, (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
697         GlobalCommands_insert( "PatchInsertAddColumn", FreeCaller<Patch_InsertAddColumn>() );
698         GlobalCommands_insert( "PatchInsertInsertRow", FreeCaller<Patch_InsertInsertRow>(), Accelerator( GDK_KP_Add, (GdkModifierType)GDK_CONTROL_MASK ) );
699         GlobalCommands_insert( "PatchInsertAddRow", FreeCaller<Patch_InsertAddRow>() );
700         GlobalCommands_insert( "PatchDeleteFirstColumn", FreeCaller<Patch_DeleteFirstColumn>() );
701         GlobalCommands_insert( "PatchDeleteLastColumn", FreeCaller<Patch_DeleteLastColumn>(), Accelerator( GDK_KP_Subtract, (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
702         GlobalCommands_insert( "PatchDeleteFirstRow", FreeCaller<Patch_DeleteFirstRow>(), Accelerator( GDK_KP_Subtract, (GdkModifierType)GDK_CONTROL_MASK ) );
703         GlobalCommands_insert( "PatchDeleteLastRow", FreeCaller<Patch_DeleteLastRow>() );
704         GlobalCommands_insert( "InvertCurve", FreeCaller<Patch_Invert>(), Accelerator( 'I', (GdkModifierType)GDK_CONTROL_MASK ) );
705         GlobalCommands_insert( "RedisperseRows", FreeCaller<Patch_RedisperseRows>(), Accelerator( 'E', (GdkModifierType)GDK_CONTROL_MASK ) );
706         GlobalCommands_insert( "RedisperseCols", FreeCaller<Patch_RedisperseCols>(), Accelerator( 'E', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
707         GlobalCommands_insert( "SmoothRows", FreeCaller<Patch_SmoothRows>(), Accelerator( 'W', (GdkModifierType)GDK_CONTROL_MASK ) );
708         GlobalCommands_insert( "SmoothCols", FreeCaller<Patch_SmoothCols>(), Accelerator( 'W', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
709         GlobalCommands_insert( "MatrixTranspose", FreeCaller<Patch_Transpose>(), Accelerator( 'M', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
710         GlobalCommands_insert( "CapCurrentCurve", FreeCaller<Patch_Cap>(), Accelerator( 'C', (GdkModifierType)GDK_SHIFT_MASK ) );
711         GlobalCommands_insert( "CycleCapTexturePatch", FreeCaller<Patch_CycleProjection>(), Accelerator( 'N', (GdkModifierType)( GDK_SHIFT_MASK | GDK_CONTROL_MASK ) ) );
712         GlobalCommands_insert( "MakeOverlayPatch", FreeCaller<Patch_OverlayOn>(), Accelerator( 'Y' ) );
713         GlobalCommands_insert( "ClearPatchOverlays", FreeCaller<Patch_OverlayOff>(), Accelerator( 'L', (GdkModifierType)GDK_CONTROL_MASK ) );
714 }
715
716 void Patch_constructToolbar( GtkToolbar* toolbar ){
717         toolbar_append_button( toolbar, "Put caps on the current patch (SHIFT + C)", "curve_cap.bmp", "CapCurrentCurve" );
718 }
719
720 void Patch_constructMenu( GtkMenu* menu ){
721         create_menu_item_with_mnemonic( menu, "Cylinder", "PatchCylinder" );
722         {
723                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "More Cylinders" );
724                 if ( g_Layout_enableDetachableMenus.m_value ) {
725                         menu_tearoff( menu_in_menu );
726                 }
727                 create_menu_item_with_mnemonic( menu_in_menu, "Dense Cylinder", "PatchDenseCylinder" );
728                 create_menu_item_with_mnemonic( menu_in_menu, "Very Dense Cylinder", "PatchVeryDenseCylinder" );
729                 create_menu_item_with_mnemonic( menu_in_menu, "Square Cylinder", "PatchSquareCylinder" );
730                 create_menu_item_with_mnemonic( menu_in_menu, "Exact Cylinder...", "PatchXactCylinder" );
731         }
732         menu_separator( menu );
733         create_menu_item_with_mnemonic( menu, "End cap", "PatchEndCap" );
734         create_menu_item_with_mnemonic( menu, "Bevel", "PatchBevel" );
735         {
736                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "More End caps, Bevels" );
737                 if ( g_Layout_enableDetachableMenus.m_value ) {
738                         menu_tearoff( menu_in_menu );
739                 }
740                 create_menu_item_with_mnemonic( menu_in_menu, "Square Endcap", "PatchSquareBevel" );
741                 create_menu_item_with_mnemonic( menu_in_menu, "Square Bevel", "PatchSquareEndcap" );
742         }
743         menu_separator( menu );
744         create_menu_item_with_mnemonic( menu, "Cone", "PatchCone" );
745         create_menu_item_with_mnemonic( menu, "Exact Cone...", "PatchXactCone" );
746         menu_separator( menu );
747         create_menu_item_with_mnemonic( menu, "Sphere", "PatchSphere" );
748         create_menu_item_with_mnemonic( menu, "Exact Sphere...", "PatchXactSphere" );
749         menu_separator( menu );
750         create_menu_item_with_mnemonic( menu, "Simple Patch Mesh...", "SimplePatchMesh" );
751         menu_separator( menu );
752         {
753                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Insert" );
754                 if ( g_Layout_enableDetachableMenus.m_value ) {
755                         menu_tearoff( menu_in_menu );
756                 }
757                 create_menu_item_with_mnemonic( menu_in_menu, "Insert (2) Columns", "PatchInsertInsertColumn" );
758                 create_menu_item_with_mnemonic( menu_in_menu, "Add (2) Columns", "PatchInsertAddColumn" );
759                 menu_separator( menu_in_menu );
760                 create_menu_item_with_mnemonic( menu_in_menu, "Insert (2) Rows", "PatchInsertInsertRow" );
761                 create_menu_item_with_mnemonic( menu_in_menu, "Add (2) Rows", "PatchInsertAddRow" );
762         }
763         {
764                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Delete" );
765                 if ( g_Layout_enableDetachableMenus.m_value ) {
766                         menu_tearoff( menu_in_menu );
767                 }
768                 create_menu_item_with_mnemonic( menu_in_menu, "First (2) Columns", "PatchDeleteFirstColumn" );
769                 create_menu_item_with_mnemonic( menu_in_menu, "Last (2) Columns", "PatchDeleteLastColumn" );
770                 menu_separator( menu_in_menu );
771                 create_menu_item_with_mnemonic( menu_in_menu, "First (2) Rows", "PatchDeleteFirstRow" );
772                 create_menu_item_with_mnemonic( menu_in_menu, "Last (2) Rows", "PatchDeleteLastRow" );
773         }
774         menu_separator( menu );
775         {
776                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Matrix" );
777                 if ( g_Layout_enableDetachableMenus.m_value ) {
778                         menu_tearoff( menu_in_menu );
779                 }
780                 create_menu_item_with_mnemonic( menu_in_menu, "Invert", "InvertCurve" );
781                 GtkMenu* menu_3 = create_sub_menu_with_mnemonic( menu_in_menu, "Re-disperse" );
782                 if ( g_Layout_enableDetachableMenus.m_value ) {
783                         menu_tearoff( menu_3 );
784                 }
785                 create_menu_item_with_mnemonic( menu_3, "Rows", "RedisperseRows" );
786                 create_menu_item_with_mnemonic( menu_3, "Columns", "RedisperseCols" );
787                 GtkMenu* menu_4 = create_sub_menu_with_mnemonic( menu_in_menu, "Smooth" );
788                 if ( g_Layout_enableDetachableMenus.m_value ) {
789                         menu_tearoff( menu_4 );
790                 }
791                 create_menu_item_with_mnemonic( menu_4, "Rows", "SmoothRows" );
792                 create_menu_item_with_mnemonic( menu_4, "Columns", "SmoothCols" );
793                 create_menu_item_with_mnemonic( menu_in_menu, "Transpose", "MatrixTranspose" );
794         }
795         menu_separator( menu );
796         create_menu_item_with_mnemonic( menu, "Cap Selection", "CapCurrentCurve" );
797         create_menu_item_with_mnemonic( menu, "Cycle Cap Texture", "CycleCapTexturePatch" );
798         menu_separator( menu );
799         {
800                 GtkMenu* menu_in_menu = create_sub_menu_with_mnemonic( menu, "Overlay" );
801                 if ( g_Layout_enableDetachableMenus.m_value ) {
802                         menu_tearoff( menu_in_menu );
803                 }
804                 create_menu_item_with_mnemonic( menu_in_menu, "Set", "MakeOverlayPatch" );
805                 create_menu_item_with_mnemonic( menu_in_menu, "Clear", "ClearPatchOverlays" );
806         }
807 }
808
809
810 #include <gtk/gtkbox.h>
811 #include <gtk/gtktable.h>
812 #include <gtk/gtktogglebutton.h>
813 #include <gtk/gtkradiobutton.h>
814 #include <gtk/gtkcombobox.h>
815 #include <gtk/gtklabel.h>
816 #include "gtkutil/dialog.h"
817 #include "gtkutil/widget.h"
818
819 void DoNewPatchDlg( EPatchPrefab prefab, int minrows, int mincols, int defrows, int defcols, int maxrows, int maxcols ){
820         ModalDialog dialog;
821         GtkComboBox* width;
822         GtkComboBox* height;
823
824         GtkWindow* window = create_dialog_window( MainFrame_getWindow(), "Patch density", G_CALLBACK( dialog_delete_callback ), &dialog );
825
826         GtkAccelGroup* accel = gtk_accel_group_new();
827         gtk_window_add_accel_group( window, accel );
828
829         {
830                 GtkHBox* hbox = create_dialog_hbox( 4, 4 );
831                 gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( hbox ) );
832                 {
833                         GtkTable* table = create_dialog_table( 2, 2, 4, 4 );
834                         gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
835                         {
836                                 GtkLabel* label = GTK_LABEL( gtk_label_new( "Width:" ) );
837                                 gtk_widget_show( GTK_WIDGET( label ) );
838                                 gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 0, 1,
839                                                                   (GtkAttachOptions) ( GTK_FILL ),
840                                                                   (GtkAttachOptions) ( 0 ), 0, 0 );
841                                 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
842                         }
843                         {
844                                 GtkLabel* label = GTK_LABEL( gtk_label_new( "Height:" ) );
845                                 gtk_widget_show( GTK_WIDGET( label ) );
846                                 gtk_table_attach( table, GTK_WIDGET( label ), 0, 1, 1, 2,
847                                                                   (GtkAttachOptions) ( GTK_FILL ),
848                                                                   (GtkAttachOptions) ( 0 ), 0, 0 );
849                                 gtk_misc_set_alignment( GTK_MISC( label ), 0, 0.5 );
850                         }
851
852                         {
853                                 GtkComboBox* combo = GTK_COMBO_BOX( gtk_combo_box_new_text() );
854 #define D_ITEM( x ) if ( x >= mincols && ( !maxcols || x <= maxcols ) ) gtk_combo_box_append_text( combo, # x )
855                                 D_ITEM( 3 );
856                                 D_ITEM( 5 );
857                                 D_ITEM( 7 );
858                                 D_ITEM( 9 );
859                                 D_ITEM( 11 );
860                                 D_ITEM( 13 );
861                                 D_ITEM( 15 );
862                                 D_ITEM( 17 );
863                                 D_ITEM( 19 );
864                                 D_ITEM( 21 );
865                                 D_ITEM( 23 );
866                                 D_ITEM( 25 );
867                                 D_ITEM( 27 );
868                                 D_ITEM( 29 );
869                                 D_ITEM( 31 ); // MAX_PATCH_SIZE is 32, so we should be able to do 31...
870 #undef D_ITEM
871                                 gtk_widget_show( GTK_WIDGET( combo ) );
872                                 gtk_table_attach( table, GTK_WIDGET( combo ), 1, 2, 0, 1,
873                                                                   (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
874                                                                   (GtkAttachOptions) ( 0 ), 0, 0 );
875
876                                 width = combo;
877                         }
878                         {
879                                 GtkComboBox* combo = GTK_COMBO_BOX( gtk_combo_box_new_text() );
880 #define D_ITEM( x ) if ( x >= minrows && ( !maxrows || x <= maxrows ) ) gtk_combo_box_append_text( combo, # x )
881                                 D_ITEM( 3 );
882                                 D_ITEM( 5 );
883                                 D_ITEM( 7 );
884                                 D_ITEM( 9 );
885                                 D_ITEM( 11 );
886                                 D_ITEM( 13 );
887                                 D_ITEM( 15 );
888                                 D_ITEM( 17 );
889                                 D_ITEM( 19 );
890                                 D_ITEM( 21 );
891                                 D_ITEM( 23 );
892                                 D_ITEM( 25 );
893                                 D_ITEM( 27 );
894                                 D_ITEM( 29 );
895                                 D_ITEM( 31 ); // MAX_PATCH_SIZE is 32, so we should be able to do 31...
896 #undef D_ITEM
897                                 gtk_widget_show( GTK_WIDGET( combo ) );
898                                 gtk_table_attach( table, GTK_WIDGET( combo ), 1, 2, 1, 2,
899                                                                   (GtkAttachOptions) ( GTK_EXPAND | GTK_FILL ),
900                                                                   (GtkAttachOptions) ( 0 ), 0, 0 );
901
902                                 height = combo;
903                         }
904                 }
905
906                 {
907                         GtkVBox* vbox = create_dialog_vbox( 4 );
908                         gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( vbox ), TRUE, TRUE, 0 );
909                         {
910                                 GtkButton* button = create_dialog_button( "OK", G_CALLBACK( dialog_button_ok ), &dialog );
911                                 gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
912                                 widget_make_default( GTK_WIDGET( button ) );
913                                 gtk_widget_grab_focus( GTK_WIDGET( button ) );
914                                 gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Return, (GdkModifierType)0, (GtkAccelFlags)0 );
915                         }
916                         {
917                                 GtkButton* button = create_dialog_button( "Cancel", G_CALLBACK( dialog_button_cancel ), &dialog );
918                                 gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
919                                 gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel, GDK_Escape, (GdkModifierType)0, (GtkAccelFlags)0 );
920                         }
921                 }
922         }
923
924         // Initialize dialog
925         gtk_combo_box_set_active( width, ( defcols - mincols ) / 2 );
926         gtk_combo_box_set_active( height, ( defrows - minrows ) / 2 );
927
928         if ( modal_dialog_show( window, dialog ) == eIDOK ) {
929                 int w = gtk_combo_box_get_active( width ) * 2 + mincols;
930                 int h = gtk_combo_box_get_active( height ) * 2 + minrows;
931
932                 Scene_PatchConstructPrefab( GlobalSceneGraph(), PatchCreator_getBounds(), TextureBrowser_GetSelectedShader( GlobalTextureBrowser() ), prefab, GlobalXYWnd_getCurrentViewType(), w, h );
933         }
934
935         gtk_widget_destroy( GTK_WIDGET( window ) );
936 }
937
938
939
940
941 EMessageBoxReturn DoCapDlg( ECapDialog* type ){
942         ModalDialog dialog;
943         ModalDialogButton ok_button( dialog, eIDOK );
944         ModalDialogButton cancel_button( dialog, eIDCANCEL );
945         GtkWidget* bevel;
946         GtkWidget* ibevel;
947         GtkWidget* endcap;
948         GtkWidget* iendcap;
949         GtkWidget* cylinder;
950
951         GtkWindow* window = create_modal_dialog_window( MainFrame_getWindow(), "Cap", dialog );
952
953         GtkAccelGroup *accel_group = gtk_accel_group_new();
954         gtk_window_add_accel_group( window, accel_group );
955
956         {
957                 GtkHBox* hbox = create_dialog_hbox( 4, 4 );
958                 gtk_container_add( GTK_CONTAINER( window ), GTK_WIDGET( hbox ) );
959
960                 {
961                         // Gef: Added a vbox to contain the toggle buttons
962                         GtkVBox* radio_vbox = create_dialog_vbox( 4 );
963                         gtk_container_add( GTK_CONTAINER( hbox ), GTK_WIDGET( radio_vbox ) );
964
965                         {
966                                 GtkTable* table = GTK_TABLE( gtk_table_new( 5, 2, FALSE ) );
967                                 gtk_widget_show( GTK_WIDGET( table ) );
968                                 gtk_box_pack_start( GTK_BOX( radio_vbox ), GTK_WIDGET( table ), TRUE, TRUE, 0 );
969                                 gtk_table_set_row_spacings( table, 5 );
970                                 gtk_table_set_col_spacings( table, 5 );
971
972                                 {
973                                         GtkImage* image = new_local_image( "cap_bevel.bmp" );
974                                         gtk_widget_show( GTK_WIDGET( image ) );
975                                         gtk_table_attach( table, GTK_WIDGET( image ), 0, 1, 0, 1,
976                                                                           (GtkAttachOptions) ( GTK_FILL ),
977                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
978                                 }
979                                 {
980                                         GtkImage* image = new_local_image( "cap_endcap.bmp" );
981                                         gtk_widget_show( GTK_WIDGET( image ) );
982                                         gtk_table_attach( table, GTK_WIDGET( image ), 0, 1, 1, 2,
983                                                                           (GtkAttachOptions) ( GTK_FILL ),
984                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
985                                 }
986                                 {
987                                         GtkImage* image = new_local_image( "cap_ibevel.bmp" );
988                                         gtk_widget_show( GTK_WIDGET( image ) );
989                                         gtk_table_attach( table, GTK_WIDGET( image ), 0, 1, 2, 3,
990                                                                           (GtkAttachOptions) ( GTK_FILL ),
991                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
992                                 }
993                                 {
994                                         GtkImage* image = new_local_image( "cap_iendcap.bmp" );
995                                         gtk_widget_show( GTK_WIDGET( image ) );
996                                         gtk_table_attach( table, GTK_WIDGET( image ), 0, 1, 3, 4,
997                                                                           (GtkAttachOptions) ( GTK_FILL ),
998                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
999                                 }
1000                                 {
1001                                         GtkImage* image = new_local_image( "cap_cylinder.bmp" );
1002                                         gtk_widget_show( GTK_WIDGET( image ) );
1003                                         gtk_table_attach( table, GTK_WIDGET( image ), 0, 1, 4, 5,
1004                                                                           (GtkAttachOptions) ( GTK_FILL ),
1005                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1006                                 }
1007
1008                                 GSList* group = 0;
1009                                 {
1010                                         GtkWidget* button = gtk_radio_button_new_with_label( group, "Bevel" );
1011                                         gtk_widget_show( button );
1012                                         gtk_table_attach( table, button, 1, 2, 0, 1,
1013                                                                           (GtkAttachOptions) ( GTK_FILL | GTK_EXPAND ),
1014                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1015                                         group = gtk_radio_button_group( GTK_RADIO_BUTTON( button ) );
1016
1017                                         bevel = button;
1018                                 }
1019                                 {
1020                                         GtkWidget* button = gtk_radio_button_new_with_label( group, "Endcap" );
1021                                         gtk_widget_show( button );
1022                                         gtk_table_attach( table, button, 1, 2, 1, 2,
1023                                                                           (GtkAttachOptions) ( GTK_FILL | GTK_EXPAND ),
1024                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1025                                         group = gtk_radio_button_group( GTK_RADIO_BUTTON( button ) );
1026
1027                                         endcap = button;
1028                                 }
1029                                 {
1030                                         GtkWidget* button = gtk_radio_button_new_with_label( group, "Inverted Bevel" );
1031                                         gtk_widget_show( button );
1032                                         gtk_table_attach( table, button, 1, 2, 2, 3,
1033                                                                           (GtkAttachOptions) ( GTK_FILL | GTK_EXPAND ),
1034                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1035                                         group = gtk_radio_button_group( GTK_RADIO_BUTTON( button ) );
1036
1037                                         ibevel = button;
1038                                 }
1039                                 {
1040                                         GtkWidget* button = gtk_radio_button_new_with_label( group, "Inverted Endcap" );
1041                                         gtk_widget_show( button );
1042                                         gtk_table_attach( table, button, 1, 2, 3, 4,
1043                                                                           (GtkAttachOptions) ( GTK_FILL | GTK_EXPAND ),
1044                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1045                                         group = gtk_radio_button_group( GTK_RADIO_BUTTON( button ) );
1046
1047                                         iendcap = button;
1048                                 }
1049                                 {
1050                                         GtkWidget* button = gtk_radio_button_new_with_label( group, "Cylinder" );
1051                                         gtk_widget_show( button );
1052                                         gtk_table_attach( table, button, 1, 2, 4, 5,
1053                                                                           (GtkAttachOptions) ( GTK_FILL | GTK_EXPAND ),
1054                                                                           (GtkAttachOptions) ( 0 ), 0, 0 );
1055                                         group = gtk_radio_button_group( GTK_RADIO_BUTTON( button ) );
1056
1057                                         cylinder = button;
1058                                 }
1059                         }
1060                 }
1061
1062                 {
1063                         GtkVBox* vbox = create_dialog_vbox( 4 );
1064                         gtk_box_pack_start( GTK_BOX( hbox ), GTK_WIDGET( vbox ), FALSE, FALSE, 0 );
1065                         {
1066                                 GtkButton* button = create_modal_dialog_button( "OK", ok_button );
1067                                 gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
1068                                 widget_make_default( GTK_WIDGET( button ) );
1069                                 gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel_group, GDK_Return, (GdkModifierType)0, GTK_ACCEL_VISIBLE );
1070                         }
1071                         {
1072                                 GtkButton* button = create_modal_dialog_button( "Cancel", cancel_button );
1073                                 gtk_box_pack_start( GTK_BOX( vbox ), GTK_WIDGET( button ), FALSE, FALSE, 0 );
1074                                 gtk_widget_add_accelerator( GTK_WIDGET( button ), "clicked", accel_group, GDK_Escape, (GdkModifierType)0, GTK_ACCEL_VISIBLE );
1075                         }
1076                 }
1077         }
1078
1079         // Initialize dialog
1080         gtk_toggle_button_set_active( GTK_TOGGLE_BUTTON( bevel ), TRUE );
1081
1082         EMessageBoxReturn ret = modal_dialog_show( window, dialog );
1083         if ( ret == eIDOK ) {
1084                 if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( bevel ) ) ) {
1085                         *type = PATCHCAP_BEVEL;
1086                 }
1087                 else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( endcap ) ) ) {
1088                         *type = PATCHCAP_ENDCAP;
1089                 }
1090                 else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( ibevel ) ) ) {
1091                         *type = PATCHCAP_INVERTED_BEVEL;
1092                 }
1093                 else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( iendcap ) ) ) {
1094                         *type = PATCHCAP_INVERTED_ENDCAP;
1095                 }
1096                 else if ( gtk_toggle_button_get_active( GTK_TOGGLE_BUTTON( cylinder ) ) ) {
1097                         *type = PATCHCAP_CYLINDER;
1098                 }
1099         }
1100
1101         gtk_widget_destroy( GTK_WIDGET( window ) );
1102
1103         return ret;
1104 }