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