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