filter non-shader texture paths at the same place
[xonotic/netradiant.git] / radiant / texwindow.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 //
23 // Texture Window
24 //
25 // Leonardo Zide (leo@lokigames.com)
26 //
27
28 #include "texwindow.h"
29
30 #include <gtk/gtk.h>
31
32 #include "debugging/debugging.h"
33 #include "warnings.h"
34
35 #include "ifilesystem.h"
36 #include "iundo.h"
37 #include "igl.h"
38 #include "iarchive.h"
39 #include "moduleobserver.h"
40
41 #include <set>
42 #include <string>
43 #include <vector>
44
45 #include <uilib/uilib.h>
46
47 #include "signal/signal.h"
48 #include "math/vector.h"
49 #include "texturelib.h"
50 #include "string/string.h"
51 #include "shaderlib.h"
52 #include "os/file.h"
53 #include "os/path.h"
54 #include "stream/memstream.h"
55 #include "stream/textfilestream.h"
56 #include "stream/stringstream.h"
57 #include "cmdlib.h"
58 #include "texmanip.h"
59 #include "textures.h"
60 #include "convert.h"
61
62 #include "gtkutil/menu.h"
63 #include "gtkutil/nonmodal.h"
64 #include "gtkutil/cursor.h"
65 #include "gtkutil/widget.h"
66 #include "gtkutil/glwidget.h"
67 #include "gtkutil/messagebox.h"
68
69 #include "error.h"
70 #include "map.h"
71 #include "qgl.h"
72 #include "select.h"
73 #include "brush_primit.h"
74 #include "brushmanip.h"
75 #include "patchmanip.h"
76 #include "plugin.h"
77 #include "qe3.h"
78 #include "gtkdlgs.h"
79 #include "gtkmisc.h"
80 #include "mainframe.h"
81 #include "findtexturedialog.h"
82 #include "surfacedialog.h"
83 #include "patchdialog.h"
84 #include "groupdialog.h"
85 #include "preferences.h"
86 #include "shaders.h"
87 #include "commands.h"
88
89 #define NOTEX_BASENAME "notex"
90 #define SHADERNOTEX_BASENAME "shadernotex"
91
92 bool TextureBrowser_showWads()
93 {
94     return !string_empty(g_pGameDescription->getKeyValue("show_wads"));
95 }
96
97 void TextureBrowser_queueDraw(TextureBrowser &textureBrowser);
98
99 bool string_equal_start(const char *string, StringRange start)
100 {
101     return string_equal_n(string, start.first, start.last - start.first);
102 }
103
104 typedef std::set<CopiedString> TextureGroups;
105
106 void TextureGroups_addWad(TextureGroups &groups, const char *archive)
107 {
108     if (extension_equal(path_get_extension(archive), "wad")) {
109 #if 1
110         groups.insert(archive);
111 #else
112                                                                                                                                 CopiedString archiveBaseName( path_get_filename_start( archive ), path_get_filename_base_end( archive ) );
113                 groups.insert( archiveBaseName );
114 #endif
115     }
116 }
117
118 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addWad> TextureGroupsAddWadCaller;
119
120 namespace {
121     bool g_TextureBrowser_shaderlistOnly = false;
122     bool g_TextureBrowser_fixedSize = true;
123     bool g_TextureBrowser_filterMissing = false;
124     bool g_TextureBrowser_filterFallback = true;
125     bool g_TextureBrowser_enableAlpha = true;
126 }
127
128 CopiedString g_notex;
129 CopiedString g_shadernotex;
130
131 bool isMissing(const char *name);
132
133 bool isNotex(const char *name);
134
135 bool isMissing(const char *name)
136 {
137     if (string_equal(g_notex.c_str(), name)) {
138         return true;
139     }
140     if (string_equal(g_shadernotex.c_str(), name)) {
141         return true;
142     }
143     return false;
144 }
145
146 bool isNotex(const char *name)
147 {
148     if (string_equal_suffix(name, "/" NOTEX_BASENAME)) {
149         return true;
150     }
151     if (string_equal_suffix(name, "/" SHADERNOTEX_BASENAME)) {
152         return true;
153     }
154     return false;
155 }
156
157 void TextureGroups_addShader(TextureGroups &groups, const char *shaderName)
158 {
159     const char *texture = path_make_relative(shaderName, "textures/");
160
161     // hide notex / shadernotex images
162     if (g_TextureBrowser_filterFallback) {
163         if (isNotex(shaderName)) {
164             return;
165         }
166         if (isNotex(texture)) {
167             return;
168         }
169     }
170
171     if (texture != shaderName) {
172         const char *last = path_remove_directory(texture);
173         if (!string_empty(last)) {
174             groups.insert(CopiedString(StringRange(texture, --last)));
175         }
176     }
177 }
178
179 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addShader> TextureGroupsAddShaderCaller;
180
181 void TextureGroups_addDirectory(TextureGroups &groups, const char *directory)
182 {
183     groups.insert(directory);
184 }
185
186 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addDirectory> TextureGroupsAddDirectoryCaller;
187
188 class DeferredAdjustment {
189     gdouble m_value;
190     guint m_handler;
191
192     typedef void ( *ValueChangedFunction )(void *data, gdouble value);
193
194     ValueChangedFunction m_function;
195     void *m_data;
196
197     static gboolean deferred_value_changed(gpointer data)
198     {
199         reinterpret_cast<DeferredAdjustment *>( data )->m_function(
200                 reinterpret_cast<DeferredAdjustment *>( data )->m_data,
201                 reinterpret_cast<DeferredAdjustment *>( data )->m_value
202         );
203         reinterpret_cast<DeferredAdjustment *>( data )->m_handler = 0;
204         reinterpret_cast<DeferredAdjustment *>( data )->m_value = 0;
205         return FALSE;
206     }
207
208 public:
209     DeferredAdjustment(ValueChangedFunction function, void *data) : m_value(0), m_handler(0), m_function(function),
210                                                                     m_data(data)
211     {
212     }
213
214     void flush()
215     {
216         if (m_handler != 0) {
217             g_source_remove(m_handler);
218             deferred_value_changed(this);
219         }
220     }
221
222     void value_changed(gdouble value)
223     {
224         m_value = value;
225         if (m_handler == 0) {
226             m_handler = g_idle_add(deferred_value_changed, this);
227         }
228     }
229
230     static void adjustment_value_changed(ui::Adjustment adjustment, DeferredAdjustment *self)
231     {
232         self->value_changed(gtk_adjustment_get_value(adjustment));
233     }
234 };
235
236
237 class TextureBrowser;
238
239 typedef ReferenceCaller<TextureBrowser, void(), TextureBrowser_queueDraw> TextureBrowserQueueDrawCaller;
240
241 void TextureBrowser_scrollChanged(void *data, gdouble value);
242
243
244 enum StartupShaders {
245     STARTUPSHADERS_NONE = 0,
246     STARTUPSHADERS_COMMON,
247 };
248
249 void TextureBrowser_hideUnusedExport(const Callback<void(bool)> &importer);
250
251 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
252
253 void TextureBrowser_showShadersExport(const Callback<void(bool)> &importer);
254
255 typedef FreeCaller<void(
256         const Callback<void(bool)> &), TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
257
258 void TextureBrowser_showShaderlistOnly(const Callback<void(bool)> &importer);
259
260 typedef FreeCaller<void(
261         const Callback<void(bool)> &), TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
262
263 void TextureBrowser_fixedSize(const Callback<void(bool)> &importer);
264
265 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_fixedSize> TextureBrowserFixedSizeExport;
266
267 void TextureBrowser_filterMissing(const Callback<void(bool)> &importer);
268
269 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_filterMissing> TextureBrowserFilterMissingExport;
270
271 void TextureBrowser_filterFallback(const Callback<void(bool)> &importer);
272
273 typedef FreeCaller<void(
274         const Callback<void(bool)> &), TextureBrowser_filterFallback> TextureBrowserFilterFallbackExport;
275
276 void TextureBrowser_enableAlpha(const Callback<void(bool)> &importer);
277
278 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_enableAlpha> TextureBrowserEnableAlphaExport;
279
280 class TextureBrowser {
281 public:
282     int width, height;
283     int originy;
284     int m_nTotalHeight;
285
286     CopiedString shader;
287
288     ui::Window m_parent{ui::null};
289     ui::GLArea m_gl_widget{ui::null};
290     ui::Widget m_texture_scroll{ui::null};
291     ui::TreeView m_treeViewTree{ui::New};
292     ui::TreeView m_treeViewTags{ui::null};
293     ui::Frame m_tag_frame{ui::null};
294     ui::ListStore m_assigned_store{ui::null};
295     ui::ListStore m_available_store{ui::null};
296     ui::TreeView m_assigned_tree{ui::null};
297     ui::TreeView m_available_tree{ui::null};
298     ui::Widget m_scr_win_tree{ui::null};
299     ui::Widget m_scr_win_tags{ui::null};
300     ui::Widget m_tag_notebook{ui::null};
301     ui::Button m_search_button{ui::null};
302     ui::Widget m_shader_info_item{ui::null};
303
304     std::set<CopiedString> m_all_tags;
305     ui::ListStore m_all_tags_list{ui::null};
306     std::vector<CopiedString> m_copied_tags;
307     std::set<CopiedString> m_found_shaders;
308
309     ToggleItem m_hideunused_item;
310     ToggleItem m_hidenotex_item;
311     ToggleItem m_showshaders_item;
312     ToggleItem m_showshaderlistonly_item;
313     ToggleItem m_fixedsize_item;
314     ToggleItem m_filternotex_item;
315     ToggleItem m_enablealpha_item;
316
317     guint m_sizeHandler;
318     guint m_exposeHandler;
319
320     bool m_heightChanged;
321     bool m_originInvalid;
322
323     DeferredAdjustment m_scrollAdjustment;
324     FreezePointer m_freezePointer;
325
326     Vector3 color_textureback;
327 // the increment step we use against the wheel mouse
328     std::size_t m_mouseWheelScrollIncrement;
329     std::size_t m_textureScale;
330 // make the texture increments match the grid changes
331     bool m_showShaders;
332     bool m_showTextureScrollbar;
333     StartupShaders m_startupShaders;
334 // if true, the texture window will only display in-use shaders
335 // if false, all the shaders in memory are displayed
336     bool m_hideUnused;
337     bool m_rmbSelected;
338     bool m_searchedTags;
339     bool m_tags;
340 // The uniform size (in pixels) that textures are resized to when m_resizeTextures is true.
341     int m_uniformTextureSize;
342
343 // Return the display width of a texture in the texture browser
344     int getTextureWidth(qtexture_t *tex)
345     {
346         int width;
347         if (!g_TextureBrowser_fixedSize) {
348             // Don't use uniform size
349             width = (int) (tex->width * ((float) m_textureScale / 100));
350         } else if
351                 (tex->width >= tex->height) {
352             // Texture is square, or wider than it is tall
353             width = m_uniformTextureSize;
354         } else {
355             // Otherwise, preserve the texture's aspect ratio
356             width = (int) (m_uniformTextureSize * ((float) tex->width / tex->height));
357         }
358         return width;
359     }
360
361 // Return the display height of a texture in the texture browser
362     int getTextureHeight(qtexture_t *tex)
363     {
364         int height;
365         if (!g_TextureBrowser_fixedSize) {
366             // Don't use uniform size
367             height = (int) (tex->height * ((float) m_textureScale / 100));
368         } else if (tex->height >= tex->width) {
369             // Texture is square, or taller than it is wide
370             height = m_uniformTextureSize;
371         } else {
372             // Otherwise, preserve the texture's aspect ratio
373             height = (int) (m_uniformTextureSize * ((float) tex->height / tex->width));
374         }
375         return height;
376     }
377
378     TextureBrowser() :
379             m_texture_scroll(ui::null),
380             m_hideunused_item(TextureBrowserHideUnusedExport()),
381             m_hidenotex_item(TextureBrowserFilterFallbackExport()),
382             m_showshaders_item(TextureBrowserShowShadersExport()),
383             m_showshaderlistonly_item(TextureBrowserShowShaderlistOnlyExport()),
384             m_fixedsize_item(TextureBrowserFixedSizeExport()),
385             m_filternotex_item(TextureBrowserFilterMissingExport()),
386             m_enablealpha_item(TextureBrowserEnableAlphaExport()),
387             m_heightChanged(true),
388             m_originInvalid(true),
389             m_scrollAdjustment(TextureBrowser_scrollChanged, this),
390             color_textureback(0.25f, 0.25f, 0.25f),
391             m_mouseWheelScrollIncrement(64),
392             m_textureScale(50),
393             m_showShaders(true),
394             m_showTextureScrollbar(true),
395             m_startupShaders(STARTUPSHADERS_NONE),
396             m_hideUnused(false),
397             m_rmbSelected(false),
398             m_searchedTags(false),
399             m_tags(false),
400             m_uniformTextureSize(96)
401     {
402     }
403 };
404
405 void ( *TextureBrowser_textureSelected )(const char *shader);
406
407
408 void TextureBrowser_updateScroll(TextureBrowser &textureBrowser);
409
410
411 const char *TextureBrowser_getComonShadersName()
412 {
413     const char *value = g_pGameDescription->getKeyValue("common_shaders_name");
414     if (!string_empty(value)) {
415         return value;
416     }
417     return "Common";
418 }
419
420 const char *TextureBrowser_getComonShadersDir()
421 {
422     const char *value = g_pGameDescription->getKeyValue("common_shaders_dir");
423     if (!string_empty(value)) {
424         return value;
425     }
426     return "common/";
427 }
428
429 inline int TextureBrowser_fontHeight(TextureBrowser &textureBrowser)
430 {
431     return GlobalOpenGL().m_font->getPixelHeight();
432 }
433
434 const char *TextureBrowser_GetSelectedShader(TextureBrowser &textureBrowser)
435 {
436     return textureBrowser.shader.c_str();
437 }
438
439 void TextureBrowser_SetStatus(TextureBrowser &textureBrowser, const char *name)
440 {
441     IShader *shader = QERApp_Shader_ForName(name);
442     qtexture_t *q = shader->getTexture();
443     StringOutputStream strTex(256);
444     strTex << name << " W: " << Unsigned(q->width) << " H: " << Unsigned(q->height);
445     shader->DecRef();
446     g_pParentWnd->SetStatusText(g_pParentWnd->m_texture_status, strTex.c_str());
447 }
448
449 void TextureBrowser_Focus(TextureBrowser &textureBrowser, const char *name);
450
451 void TextureBrowser_SetSelectedShader(TextureBrowser &textureBrowser, const char *shader)
452 {
453     textureBrowser.shader = shader;
454     TextureBrowser_SetStatus(textureBrowser, shader);
455     TextureBrowser_Focus(textureBrowser, shader);
456
457     if (FindTextureDialog_isOpen()) {
458         FindTextureDialog_selectTexture(shader);
459     }
460
461     // disable the menu item "shader info" if no shader was selected
462     IShader *ishader = QERApp_Shader_ForName(shader);
463     CopiedString filename = ishader->getShaderFileName();
464
465     if (filename.empty()) {
466         if (textureBrowser.m_shader_info_item != NULL) {
467             gtk_widget_set_sensitive(textureBrowser.m_shader_info_item, FALSE);
468         }
469     } else {
470         gtk_widget_set_sensitive(textureBrowser.m_shader_info_item, TRUE);
471     }
472
473     ishader->DecRef();
474 }
475
476
477 CopiedString g_TextureBrowser_currentDirectory;
478
479 /*
480    ============================================================================
481
482    TEXTURE LAYOUT
483
484    TTimo: now based on a rundown through all the shaders
485    NOTE: we expect the Active shaders count doesn't change during a Texture_StartPos .. Texture_NextPos cycle
486    otherwise we may need to rely on a list instead of an array storage
487    ============================================================================
488  */
489
490 class TextureLayout {
491 public:
492 // texture layout functions
493 // TTimo: now based on shaders
494     int current_x, current_y, current_row;
495 };
496
497 void Texture_StartPos(TextureLayout &layout)
498 {
499     layout.current_x = 8;
500     layout.current_y = -8;
501     layout.current_row = 0;
502 }
503
504 void Texture_NextPos(TextureBrowser &textureBrowser, TextureLayout &layout, qtexture_t *current_texture, int *x, int *y)
505 {
506     qtexture_t *q = current_texture;
507
508     int nWidth = textureBrowser.getTextureWidth(q);
509     int nHeight = textureBrowser.getTextureHeight(q);
510     if (layout.current_x + nWidth > textureBrowser.width - 8 &&
511         layout.current_row) { // go to the next row unless the texture is the first on the row
512         layout.current_x = 8;
513         layout.current_y -= layout.current_row + TextureBrowser_fontHeight(textureBrowser) + 4;
514         layout.current_row = 0;
515     }
516
517     *x = layout.current_x;
518     *y = layout.current_y;
519
520     // Is our texture larger than the row? If so, grow the
521     // row height to match it
522
523     if (layout.current_row < nHeight) {
524         layout.current_row = nHeight;
525     }
526
527     // never go less than 96, or the names get all crunched up
528     layout.current_x += nWidth < 96 ? 96 : nWidth;
529     layout.current_x += 8;
530 }
531
532 bool TextureSearch_IsShown(const char *name)
533 {
534     std::set<CopiedString>::iterator iter;
535
536     iter = GlobalTextureBrowser().m_found_shaders.find(name);
537
538     if (iter == GlobalTextureBrowser().m_found_shaders.end()) {
539         return false;
540     } else {
541         return true;
542     }
543 }
544
545 // if texture_showinuse jump over non in-use textures
546 bool Texture_IsShown(IShader *shader, bool show_shaders, bool hideUnused)
547 {
548     // filter missing shaders
549     // ugly: filter on built-in fallback name after substitution
550     if (g_TextureBrowser_filterMissing) {
551         if (isMissing(shader->getTexture()->name)) {
552             return false;
553         }
554     }
555     // filter the fallback (notex/shadernotex) for missing shaders or editor image
556     if (g_TextureBrowser_filterFallback) {
557         if (isNotex(shader->getName())) {
558             return false;
559         }
560         if (isNotex(shader->getTexture()->name)) {
561             return false;
562         }
563     }
564
565     if (g_TextureBrowser_currentDirectory == "Untagged") {
566         std::set<CopiedString>::iterator iter;
567
568         iter = GlobalTextureBrowser().m_found_shaders.find(shader->getName());
569
570         if (iter == GlobalTextureBrowser().m_found_shaders.end()) {
571             return false;
572         } else {
573             return true;
574         }
575     }
576
577     if (!shader_equal_prefix(shader->getName(), "textures/")) {
578         return false;
579     }
580
581     if (!show_shaders && !shader->IsDefault()) {
582         return false;
583     }
584
585     if (hideUnused && !shader->IsInUse()) {
586         return false;
587     }
588
589     if (GlobalTextureBrowser().m_searchedTags) {
590         if (!TextureSearch_IsShown(shader->getName())) {
591             return false;
592         } else {
593             return true;
594         }
595     } else {
596         if (!shader_equal_prefix(shader_get_textureName(shader->getName()),
597                                  g_TextureBrowser_currentDirectory.c_str())) {
598             return false;
599         }
600     }
601
602     return true;
603 }
604
605 void TextureBrowser_heightChanged(TextureBrowser &textureBrowser)
606 {
607     textureBrowser.m_heightChanged = true;
608
609     TextureBrowser_updateScroll(textureBrowser);
610     TextureBrowser_queueDraw(textureBrowser);
611 }
612
613 void TextureBrowser_evaluateHeight(TextureBrowser &textureBrowser)
614 {
615     if (textureBrowser.m_heightChanged) {
616         textureBrowser.m_heightChanged = false;
617
618         textureBrowser.m_nTotalHeight = 0;
619
620         TextureLayout layout;
621         Texture_StartPos(layout);
622         for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
623             IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
624
625             if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
626                 continue;
627             }
628
629             int x, y;
630             Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
631             textureBrowser.m_nTotalHeight = std::max(textureBrowser.m_nTotalHeight,
632                                                      abs(layout.current_y) + TextureBrowser_fontHeight(textureBrowser) +
633                                                      textureBrowser.getTextureHeight(shader->getTexture()) + 4);
634         }
635     }
636 }
637
638 int TextureBrowser_TotalHeight(TextureBrowser &textureBrowser)
639 {
640     TextureBrowser_evaluateHeight(textureBrowser);
641     return textureBrowser.m_nTotalHeight;
642 }
643
644 inline const int &min_int(const int &left, const int &right)
645 {
646     return std::min(left, right);
647 }
648
649 void TextureBrowser_clampOriginY(TextureBrowser &textureBrowser)
650 {
651     if (textureBrowser.originy > 0) {
652         textureBrowser.originy = 0;
653     }
654     int lower = min_int(textureBrowser.height - TextureBrowser_TotalHeight(textureBrowser), 0);
655     if (textureBrowser.originy < lower) {
656         textureBrowser.originy = lower;
657     }
658 }
659
660 int TextureBrowser_getOriginY(TextureBrowser &textureBrowser)
661 {
662     if (textureBrowser.m_originInvalid) {
663         textureBrowser.m_originInvalid = false;
664         TextureBrowser_clampOriginY(textureBrowser);
665         TextureBrowser_updateScroll(textureBrowser);
666     }
667     return textureBrowser.originy;
668 }
669
670 void TextureBrowser_setOriginY(TextureBrowser &textureBrowser, int originy)
671 {
672     textureBrowser.originy = originy;
673     TextureBrowser_clampOriginY(textureBrowser);
674     TextureBrowser_updateScroll(textureBrowser);
675     TextureBrowser_queueDraw(textureBrowser);
676 }
677
678
679 Signal0 g_activeShadersChangedCallbacks;
680
681 void TextureBrowser_addActiveShadersChangedCallback(const SignalHandler &handler)
682 {
683     g_activeShadersChangedCallbacks.connectLast(handler);
684 }
685
686 void TextureBrowser_constructTreeStore();
687
688 class ShadersObserver : public ModuleObserver {
689     Signal0 m_realiseCallbacks;
690 public:
691     void realise()
692     {
693         m_realiseCallbacks();
694         TextureBrowser_constructTreeStore();
695     }
696
697     void unrealise()
698     {
699     }
700
701     void insert(const SignalHandler &handler)
702     {
703         m_realiseCallbacks.connectLast(handler);
704     }
705 };
706
707 namespace {
708     ShadersObserver g_ShadersObserver;
709 }
710
711 void TextureBrowser_addShadersRealiseCallback(const SignalHandler &handler)
712 {
713     g_ShadersObserver.insert(handler);
714 }
715
716 void TextureBrowser_activeShadersChanged(TextureBrowser &textureBrowser)
717 {
718     TextureBrowser_heightChanged(textureBrowser);
719     textureBrowser.m_originInvalid = true;
720
721     g_activeShadersChangedCallbacks();
722 }
723
724 struct TextureBrowser_ShowScrollbar {
725     static void Export(const TextureBrowser &self, const Callback<void(bool)> &returnz)
726     {
727         returnz(self.m_showTextureScrollbar);
728     }
729
730     static void Import(TextureBrowser &self, bool value)
731     {
732         self.m_showTextureScrollbar = value;
733         if (self.m_texture_scroll) {
734             self.m_texture_scroll.visible(self.m_showTextureScrollbar);
735             TextureBrowser_updateScroll(self);
736         }
737     }
738 };
739
740
741 /*
742    ==============
743    TextureBrowser_ShowDirectory
744    relies on texture_directory global for the directory to use
745    1) Load the shaders for the given directory
746    2) Scan the remaining texture, load them and assign them a default shader (the "noshader" shader)
747    NOTE: when writing a texture plugin, or some texture extensions, this function may need to be overriden, and made
748    available through the IShaders interface
749    NOTE: for texture window layout:
750    all shaders are stored with alphabetical order after load
751    previously loaded and displayed stuff is hidden, only in-use and newly loaded is shown
752    ( the GL textures are not flushed though)
753    ==============
754  */
755
756 bool endswith(const char *haystack, const char *needle)
757 {
758     size_t lh = strlen(haystack);
759     size_t ln = strlen(needle);
760     if (lh < ln) {
761         return false;
762     }
763     return !memcmp(haystack + (lh - ln), needle, ln);
764 }
765
766 bool texture_name_ignore(const char *name)
767 {
768     StringOutputStream strTemp(string_length(name));
769     strTemp << LowerCase(name);
770
771     return
772             endswith(strTemp.c_str(), ".specular") ||
773             endswith(strTemp.c_str(), ".glow") ||
774             endswith(strTemp.c_str(), ".bump") ||
775             endswith(strTemp.c_str(), ".diffuse") ||
776             endswith(strTemp.c_str(), ".blend") ||
777             endswith(strTemp.c_str(), ".alpha") ||
778             endswith(strTemp.c_str(), "_alpha") ||
779             /* Quetoo */
780             endswith(strTemp.c_str(), "_h") ||
781             endswith(strTemp.c_str(), "_local") ||
782             endswith(strTemp.c_str(), "_nm") ||
783             endswith(strTemp.c_str(), "_s") ||
784             /* DarkPlaces */
785             endswith(strTemp.c_str(), "_bump") ||
786             endswith(strTemp.c_str(), "_glow") ||
787             endswith(strTemp.c_str(), "_gloss") ||
788             endswith(strTemp.c_str(), "_luma") ||
789             endswith(strTemp.c_str(), "_norm") ||
790             endswith(strTemp.c_str(), "_pants") ||
791             endswith(strTemp.c_str(), "_shirt") ||
792             endswith(strTemp.c_str(), "_reflect") ||
793             /* Unvanquished */
794             endswith(strTemp.c_str(), "_d") ||
795             endswith(strTemp.c_str(), "_n") ||
796             endswith(strTemp.c_str(), "_p") ||
797             endswith(strTemp.c_str(), "_g") ||
798             endswith(strTemp.c_str(), "_a") ||
799             0;
800 }
801
802 class LoadShaderVisitor : public Archive::Visitor {
803 public:
804     void visit(const char *name)
805     {
806         IShader *shader = QERApp_Shader_ForName(
807                 CopiedString(StringRange(name, path_get_filename_base_end(name))).c_str());
808         shader->DecRef();
809     }
810 };
811
812 void TextureBrowser_SetHideUnused(TextureBrowser &textureBrowser, bool hideUnused);
813
814 ui::Widget g_page_textures{ui::null};
815
816 void TextureBrowser_toggleShow()
817 {
818     GroupDialog_showPage(g_page_textures);
819 }
820
821
822 void TextureBrowser_updateTitle()
823 {
824     GroupDialog_updatePageTitle(g_page_textures);
825 }
826
827
828 class TextureCategoryLoadShader {
829     const char *m_directory;
830     std::size_t &m_count;
831 public:
832     using func = void(const char *);
833
834     TextureCategoryLoadShader(const char *directory, std::size_t &count)
835             : m_directory(directory), m_count(count)
836     {
837         m_count = 0;
838     }
839
840     void operator()(const char *name) const
841     {
842         if (shader_equal_prefix(name, "textures/")
843             && shader_equal_prefix(name + string_length("textures/"), m_directory)) {
844             ++m_count;
845             // request the shader, this will load the texture if needed
846             // this Shader_ForName call is a kind of hack
847             IShader *pFoo = QERApp_Shader_ForName(name);
848             pFoo->DecRef();
849         }
850     }
851 };
852
853 void TextureDirectory_loadTexture(const char *directory, const char *texture)
854 {
855     StringOutputStream name(256);
856     name << directory << StringRange(texture, path_get_filename_base_end(texture));
857
858     if (texture_name_ignore(name.c_str())) {
859         return;
860     }
861
862     if (!shader_valid(name.c_str())) {
863         globalOutputStream() << "Skipping invalid texture name: [" << name.c_str() << "]\n";
864         return;
865     }
866
867     // if a texture is already in use to represent a shader, ignore it
868     IShader *shader = QERApp_Shader_ForName(name.c_str());
869     shader->DecRef();
870 }
871
872 typedef ConstPointerCaller<char, void(const char *), TextureDirectory_loadTexture> TextureDirectoryLoadTextureCaller;
873
874 class LoadTexturesByTypeVisitor : public ImageModules::Visitor {
875     const char *m_dirstring;
876 public:
877     LoadTexturesByTypeVisitor(const char *dirstring)
878             : m_dirstring(dirstring)
879     {
880     }
881
882     void visit(const char *minor, const _QERPlugImageTable &table) const
883     {
884         GlobalFileSystem().forEachFile(m_dirstring, minor, TextureDirectoryLoadTextureCaller(m_dirstring));
885     }
886 };
887
888 void TextureBrowser_ShowDirectory(TextureBrowser &textureBrowser, const char *directory)
889 {
890     if (TextureBrowser_showWads()) {
891         Archive *archive = GlobalFileSystem().getArchive(directory);
892         ASSERT_NOTNULL(archive);
893         LoadShaderVisitor visitor;
894         archive->forEachFile(Archive::VisitorFunc(visitor, Archive::eFiles, 0), "textures/");
895     } else {
896         g_TextureBrowser_currentDirectory = directory;
897         TextureBrowser_heightChanged(textureBrowser);
898
899         std::size_t shaders_count;
900         GlobalShaderSystem().foreachShaderName(makeCallback(TextureCategoryLoadShader(directory, shaders_count)));
901         globalOutputStream() << "Showing " << Unsigned(shaders_count) << " shaders.\n";
902
903         if (g_pGameDescription->mGameType != "doom3") {
904             // load remaining texture files
905
906             StringOutputStream dirstring(64);
907             dirstring << "textures/" << directory;
908
909             Radiant_getImageModules().foreachModule(LoadTexturesByTypeVisitor(dirstring.c_str()));
910         }
911     }
912
913     // we'll display the newly loaded textures + all the ones already in use
914     TextureBrowser_SetHideUnused(textureBrowser, false);
915
916     TextureBrowser_updateTitle();
917 }
918
919 void TextureBrowser_ShowTagSearchResult(TextureBrowser &textureBrowser, const char *directory)
920 {
921     g_TextureBrowser_currentDirectory = directory;
922     TextureBrowser_heightChanged(textureBrowser);
923
924     std::size_t shaders_count;
925     GlobalShaderSystem().foreachShaderName(makeCallback(TextureCategoryLoadShader(directory, shaders_count)));
926     globalOutputStream() << "Showing " << Unsigned(shaders_count) << " shaders.\n";
927
928     if (g_pGameDescription->mGameType != "doom3") {
929         // load remaining texture files
930         StringOutputStream dirstring(64);
931         dirstring << "textures/" << directory;
932
933         {
934             LoadTexturesByTypeVisitor visitor(dirstring.c_str());
935             Radiant_getImageModules().foreachModule(visitor);
936         }
937     }
938
939     // we'll display the newly loaded textures + all the ones already in use
940     TextureBrowser_SetHideUnused(textureBrowser, false);
941 }
942
943
944 bool TextureBrowser_hideUnused();
945
946 void TextureBrowser_hideUnusedExport(const Callback<void(bool)> &importer)
947 {
948     importer(TextureBrowser_hideUnused());
949 }
950
951 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
952
953 void TextureBrowser_showShadersExport(const Callback<void(bool)> &importer)
954 {
955     importer(GlobalTextureBrowser().m_showShaders);
956 }
957
958 typedef FreeCaller<void(
959         const Callback<void(bool)> &), TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
960
961 void TextureBrowser_showShaderlistOnly(const Callback<void(bool)> &importer)
962 {
963     importer(g_TextureBrowser_shaderlistOnly);
964 }
965
966 typedef FreeCaller<void(
967         const Callback<void(bool)> &), TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
968
969 void TextureBrowser_fixedSize(const Callback<void(bool)> &importer)
970 {
971     importer(g_TextureBrowser_fixedSize);
972 }
973
974 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_fixedSize> TextureBrowser_FixedSizeExport;
975
976 void TextureBrowser_filterMissing(const Callback<void(bool)> &importer)
977 {
978     importer(g_TextureBrowser_filterMissing);
979 }
980
981 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_filterMissing> TextureBrowser_filterMissingExport;
982
983 void TextureBrowser_filterFallback(const Callback<void(bool)> &importer)
984 {
985     importer(g_TextureBrowser_filterFallback);
986 }
987
988 typedef FreeCaller<void(
989         const Callback<void(bool)> &), TextureBrowser_filterFallback> TextureBrowser_filterFallbackExport;
990
991 void TextureBrowser_enableAlpha(const Callback<void(bool)> &importer)
992 {
993     importer(g_TextureBrowser_enableAlpha);
994 }
995
996 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_enableAlpha> TextureBrowser_enableAlphaExport;
997
998 void TextureBrowser_SetHideUnused(TextureBrowser &textureBrowser, bool hideUnused)
999 {
1000     if (hideUnused) {
1001         textureBrowser.m_hideUnused = true;
1002     } else {
1003         textureBrowser.m_hideUnused = false;
1004     }
1005
1006     textureBrowser.m_hideunused_item.update();
1007
1008     TextureBrowser_heightChanged(textureBrowser);
1009     textureBrowser.m_originInvalid = true;
1010 }
1011
1012 void TextureBrowser_ShowStartupShaders(TextureBrowser &textureBrowser)
1013 {
1014     if (textureBrowser.m_startupShaders == STARTUPSHADERS_COMMON) {
1015         TextureBrowser_ShowDirectory(textureBrowser, TextureBrowser_getComonShadersDir());
1016     }
1017 }
1018
1019
1020 //++timo NOTE: this is a mix of Shader module stuff and texture explorer
1021 // it might need to be split in parts or moved out .. dunno
1022 // scroll origin so the specified texture is completely on screen
1023 // if current texture is not displayed, nothing is changed
1024 void TextureBrowser_Focus(TextureBrowser &textureBrowser, const char *name)
1025 {
1026     TextureLayout layout;
1027     // scroll origin so the texture is completely on screen
1028     Texture_StartPos(layout);
1029
1030     for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1031         IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1032
1033         if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1034             continue;
1035         }
1036
1037         int x, y;
1038         Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1039         qtexture_t *q = shader->getTexture();
1040         if (!q) {
1041             break;
1042         }
1043
1044         // we have found when texdef->name and the shader name match
1045         // NOTE: as everywhere else for our comparisons, we are not case sensitive
1046         if (shader_equal(name, shader->getName())) {
1047             int textureHeight = (int) (q->height * ((float) textureBrowser.m_textureScale / 100))
1048                                 + 2 * TextureBrowser_fontHeight(textureBrowser);
1049
1050             int originy = TextureBrowser_getOriginY(textureBrowser);
1051             if (y > originy) {
1052                 originy = y;
1053             }
1054
1055             if (y - textureHeight < originy - textureBrowser.height) {
1056                 originy = (y - textureHeight) + textureBrowser.height;
1057             }
1058
1059             TextureBrowser_setOriginY(textureBrowser, originy);
1060             return;
1061         }
1062     }
1063 }
1064
1065 IShader *Texture_At(TextureBrowser &textureBrowser, int mx, int my)
1066 {
1067     my += TextureBrowser_getOriginY(textureBrowser) - textureBrowser.height;
1068
1069     TextureLayout layout;
1070     Texture_StartPos(layout);
1071     for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1072         IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1073
1074         if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1075             continue;
1076         }
1077
1078         int x, y;
1079         Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1080         qtexture_t *q = shader->getTexture();
1081         if (!q) {
1082             break;
1083         }
1084
1085         int nWidth = textureBrowser.getTextureWidth(q);
1086         int nHeight = textureBrowser.getTextureHeight(q);
1087         if (mx > x && mx - x < nWidth
1088             && my < y && y - my < nHeight + TextureBrowser_fontHeight(textureBrowser)) {
1089             return shader;
1090         }
1091     }
1092
1093     return 0;
1094 }
1095
1096 /*
1097    ==============
1098    SelectTexture
1099
1100    By mouse click
1101    ==============
1102  */
1103 void SelectTexture(TextureBrowser &textureBrowser, int mx, int my, bool bShift)
1104 {
1105     IShader *shader = Texture_At(textureBrowser, mx, my);
1106     if (shader != 0) {
1107         if (bShift) {
1108             if (shader->IsDefault()) {
1109                 globalOutputStream() << "ERROR: " << shader->getName() << " is not a shader, it's a texture.\n";
1110             } else {
1111                 ViewShader(shader->getShaderFileName(), shader->getName());
1112             }
1113         } else {
1114             TextureBrowser_SetSelectedShader(textureBrowser, shader->getName());
1115             TextureBrowser_textureSelected(shader->getName());
1116
1117             if (!FindTextureDialog_isOpen() && !textureBrowser.m_rmbSelected) {
1118                 UndoableCommand undo("textureNameSetSelected");
1119                 Select_SetShader(shader->getName());
1120             }
1121         }
1122     }
1123 }
1124
1125 /*
1126    ============================================================================
1127
1128    MOUSE ACTIONS
1129
1130    ============================================================================
1131  */
1132
1133 void TextureBrowser_trackingDelta(int x, int y, unsigned int state, void *data)
1134 {
1135     TextureBrowser &textureBrowser = *reinterpret_cast<TextureBrowser *>( data );
1136     if (y != 0) {
1137         int scale = 1;
1138
1139         if (state & GDK_SHIFT_MASK) {
1140             scale = 4;
1141         }
1142
1143         int originy = TextureBrowser_getOriginY(textureBrowser);
1144         originy += y * scale;
1145         TextureBrowser_setOriginY(textureBrowser, originy);
1146     }
1147 }
1148
1149 void TextureBrowser_Tracking_MouseDown(TextureBrowser &textureBrowser)
1150 {
1151     textureBrowser.m_freezePointer.freeze_pointer(textureBrowser.m_parent, TextureBrowser_trackingDelta,
1152                                                   &textureBrowser);
1153 }
1154
1155 void TextureBrowser_Tracking_MouseUp(TextureBrowser &textureBrowser)
1156 {
1157     textureBrowser.m_freezePointer.unfreeze_pointer(textureBrowser.m_parent);
1158 }
1159
1160 void TextureBrowser_Selection_MouseDown(TextureBrowser &textureBrowser, guint32 flags, int pointx, int pointy)
1161 {
1162     SelectTexture(textureBrowser, pointx, textureBrowser.height - 1 - pointy, (flags & GDK_SHIFT_MASK) != 0);
1163 }
1164
1165 /*
1166    ============================================================================
1167
1168    DRAWING
1169
1170    ============================================================================
1171  */
1172
1173 /*
1174    ============
1175    Texture_Draw
1176    TTimo: relying on the shaders list to display the textures
1177    we must query all qtexture_t* to manage and display through the IShaders interface
1178    this allows a plugin to completely override the texture system
1179    ============
1180  */
1181 void Texture_Draw(TextureBrowser &textureBrowser)
1182 {
1183     int originy = TextureBrowser_getOriginY(textureBrowser);
1184
1185     glClearColor(textureBrowser.color_textureback[0],
1186                  textureBrowser.color_textureback[1],
1187                  textureBrowser.color_textureback[2],
1188                  0);
1189     glViewport(0, 0, textureBrowser.width, textureBrowser.height);
1190     glMatrixMode(GL_PROJECTION);
1191     glLoadIdentity();
1192
1193     glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1194     glDisable(GL_DEPTH_TEST);
1195     if (g_TextureBrowser_enableAlpha) {
1196         glEnable(GL_BLEND);
1197         glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1198     } else {
1199         glDisable(GL_BLEND);
1200     }
1201     glOrtho(0, textureBrowser.width, originy - textureBrowser.height, originy, -100, 100);
1202     glEnable(GL_TEXTURE_2D);
1203
1204     glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1205
1206     int last_y = 0, last_height = 0;
1207
1208     TextureLayout layout;
1209     Texture_StartPos(layout);
1210     for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1211         IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1212
1213         if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1214             continue;
1215         }
1216
1217         int x, y;
1218         Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1219         qtexture_t *q = shader->getTexture();
1220         if (!q) {
1221             break;
1222         }
1223
1224         int nWidth = textureBrowser.getTextureWidth(q);
1225         int nHeight = textureBrowser.getTextureHeight(q);
1226
1227         if (y != last_y) {
1228             last_y = y;
1229             last_height = 0;
1230         }
1231         last_height = std::max(nHeight, last_height);
1232
1233         // Is this texture visible?
1234         if ((y - nHeight - TextureBrowser_fontHeight(textureBrowser) < originy)
1235             && (y > originy - textureBrowser.height)) {
1236             // borders rules:
1237             // if it's the current texture, draw a thick red line, else:
1238             // shaders have a white border, simple textures don't
1239             // if !texture_showinuse: (some textures displayed may not be in use)
1240             // draw an additional square around with 0.5 1 0.5 color
1241             if (shader_equal(TextureBrowser_GetSelectedShader(textureBrowser), shader->getName())) {
1242                 glLineWidth(3);
1243                 if (textureBrowser.m_rmbSelected) {
1244                     glColor3f(0, 0, 1);
1245                 } else {
1246                     glColor3f(1, 0, 0);
1247                 }
1248                 glDisable(GL_TEXTURE_2D);
1249
1250                 glBegin(GL_LINE_LOOP);
1251                 glVertex2i(x - 4, y - TextureBrowser_fontHeight(textureBrowser) + 4);
1252                 glVertex2i(x - 4, y - TextureBrowser_fontHeight(textureBrowser) - nHeight - 4);
1253                 glVertex2i(x + 4 + nWidth, y - TextureBrowser_fontHeight(textureBrowser) - nHeight - 4);
1254                 glVertex2i(x + 4 + nWidth, y - TextureBrowser_fontHeight(textureBrowser) + 4);
1255                 glEnd();
1256
1257                 glEnable(GL_TEXTURE_2D);
1258                 glLineWidth(1);
1259             } else {
1260                 glLineWidth(1);
1261                 // shader border:
1262                 if (!shader->IsDefault()) {
1263                     glColor3f(1, 1, 1);
1264                     glDisable(GL_TEXTURE_2D);
1265
1266                     glBegin(GL_LINE_LOOP);
1267                     glVertex2i(x - 1, y + 1 - TextureBrowser_fontHeight(textureBrowser));
1268                     glVertex2i(x - 1, y - nHeight - 1 - TextureBrowser_fontHeight(textureBrowser));
1269                     glVertex2i(x + 1 + nWidth, y - nHeight - 1 - TextureBrowser_fontHeight(textureBrowser));
1270                     glVertex2i(x + 1 + nWidth, y + 1 - TextureBrowser_fontHeight(textureBrowser));
1271                     glEnd();
1272                     glEnable(GL_TEXTURE_2D);
1273                 }
1274
1275                 // highlight in-use textures
1276                 if (!textureBrowser.m_hideUnused && shader->IsInUse()) {
1277                     glColor3f(0.5, 1, 0.5);
1278                     glDisable(GL_TEXTURE_2D);
1279                     glBegin(GL_LINE_LOOP);
1280                     glVertex2i(x - 3, y + 3 - TextureBrowser_fontHeight(textureBrowser));
1281                     glVertex2i(x - 3, y - nHeight - 3 - TextureBrowser_fontHeight(textureBrowser));
1282                     glVertex2i(x + 3 + nWidth, y - nHeight - 3 - TextureBrowser_fontHeight(textureBrowser));
1283                     glVertex2i(x + 3 + nWidth, y + 3 - TextureBrowser_fontHeight(textureBrowser));
1284                     glEnd();
1285                     glEnable(GL_TEXTURE_2D);
1286                 }
1287             }
1288
1289             // draw checkerboard for transparent textures
1290             if (g_TextureBrowser_enableAlpha) {
1291                 glDisable(GL_TEXTURE_2D);
1292                 glBegin(GL_QUADS);
1293                 int font_height = TextureBrowser_fontHeight(textureBrowser);
1294                 for (int i = 0; i < nHeight; i += 8) {
1295                     for (int j = 0; j < nWidth; j += 8) {
1296                         unsigned char color = (i + j) / 8 % 2 ? 0x66 : 0x99;
1297                         glColor3ub(color, color, color);
1298                         int left = j;
1299                         int right = std::min(j + 8, nWidth);
1300                         int top = i;
1301                         int bottom = std::min(i + 8, nHeight);
1302                         glVertex2i(x + right, y - nHeight - font_height + top);
1303                         glVertex2i(x + left, y - nHeight - font_height + top);
1304                         glVertex2i(x + left, y - nHeight - font_height + bottom);
1305                         glVertex2i(x + right, y - nHeight - font_height + bottom);
1306                     }
1307                 }
1308                 glEnd();
1309                 glEnable(GL_TEXTURE_2D);
1310             }
1311
1312             // Draw the texture
1313             glBindTexture(GL_TEXTURE_2D, q->texture_number);
1314             GlobalOpenGL_debugAssertNoErrors();
1315             glColor3f(1, 1, 1);
1316             glBegin(GL_QUADS);
1317             glTexCoord2i(0, 0);
1318             glVertex2i(x, y - TextureBrowser_fontHeight(textureBrowser));
1319             glTexCoord2i(1, 0);
1320             glVertex2i(x + nWidth, y - TextureBrowser_fontHeight(textureBrowser));
1321             glTexCoord2i(1, 1);
1322             glVertex2i(x + nWidth, y - TextureBrowser_fontHeight(textureBrowser) - nHeight);
1323             glTexCoord2i(0, 1);
1324             glVertex2i(x, y - TextureBrowser_fontHeight(textureBrowser) - nHeight);
1325             glEnd();
1326
1327             // draw the texture name
1328             glDisable(GL_TEXTURE_2D);
1329             glColor3f(1, 1, 1);
1330
1331             glRasterPos2i(x, y - TextureBrowser_fontHeight(textureBrowser) + 5);
1332
1333             // don't draw the directory name
1334             const char *name = shader->getName();
1335             name += strlen(name);
1336             while (name != shader->getName() && *(name - 1) != '/' && *(name - 1) != '\\') {
1337                 name--;
1338             }
1339
1340             GlobalOpenGL().drawString(name);
1341             glEnable(GL_TEXTURE_2D);
1342         }
1343
1344         //int totalHeight = abs(y) + last_height + TextureBrowser_fontHeight(textureBrowser) + 4;
1345     }
1346
1347
1348     // reset the current texture
1349     glBindTexture(GL_TEXTURE_2D, 0);
1350     //qglFinish();
1351 }
1352
1353 void TextureBrowser_queueDraw(TextureBrowser &textureBrowser)
1354 {
1355     if (textureBrowser.m_gl_widget) {
1356         gtk_widget_queue_draw(textureBrowser.m_gl_widget);
1357     }
1358 }
1359
1360
1361 void TextureBrowser_setScale(TextureBrowser &textureBrowser, std::size_t scale)
1362 {
1363     textureBrowser.m_textureScale = scale;
1364
1365     TextureBrowser_queueDraw(textureBrowser);
1366 }
1367
1368 void TextureBrowser_setUniformSize(TextureBrowser &textureBrowser, std::size_t scale)
1369 {
1370     textureBrowser.m_uniformTextureSize = scale;
1371
1372     TextureBrowser_queueDraw(textureBrowser);
1373 }
1374
1375
1376 void TextureBrowser_MouseWheel(TextureBrowser &textureBrowser, bool bUp)
1377 {
1378     int originy = TextureBrowser_getOriginY(textureBrowser);
1379
1380     if (bUp) {
1381         originy += int(textureBrowser.m_mouseWheelScrollIncrement);
1382     } else {
1383         originy -= int(textureBrowser.m_mouseWheelScrollIncrement);
1384     }
1385
1386     TextureBrowser_setOriginY(textureBrowser, originy);
1387 }
1388
1389 XmlTagBuilder TagBuilder;
1390
1391 enum {
1392     TAG_COLUMN,
1393     N_COLUMNS
1394 };
1395
1396 void BuildStoreAssignedTags(ui::ListStore store, const char *shader, TextureBrowser *textureBrowser)
1397 {
1398     GtkTreeIter iter;
1399
1400     store.clear();
1401
1402     std::vector<CopiedString> assigned_tags;
1403     TagBuilder.GetShaderTags(shader, assigned_tags);
1404
1405     for (size_t i = 0; i < assigned_tags.size(); i++) {
1406         store.append(TAG_COLUMN, assigned_tags[i].c_str());
1407     }
1408 }
1409
1410 void BuildStoreAvailableTags(ui::ListStore storeAvailable,
1411                              ui::ListStore storeAssigned,
1412                              const std::set<CopiedString> &allTags,
1413                              TextureBrowser *textureBrowser)
1414 {
1415     GtkTreeIter iterAssigned;
1416     GtkTreeIter iterAvailable;
1417     std::set<CopiedString>::const_iterator iterAll;
1418     gchar *tag_assigned;
1419
1420     storeAvailable.clear();
1421
1422     bool row = gtk_tree_model_get_iter_first(storeAssigned, &iterAssigned) != 0;
1423
1424     if (!row) { // does the shader have tags assigned?
1425         for (iterAll = allTags.begin(); iterAll != allTags.end(); ++iterAll) {
1426             storeAvailable.append(TAG_COLUMN, (*iterAll).c_str());
1427         }
1428     } else {
1429         while (row) // available tags = all tags - assigned tags
1430         {
1431             gtk_tree_model_get(storeAssigned, &iterAssigned, TAG_COLUMN, &tag_assigned, -1);
1432
1433             for (iterAll = allTags.begin(); iterAll != allTags.end(); ++iterAll) {
1434                 if (strcmp((char *) tag_assigned, (*iterAll).c_str()) != 0) {
1435                     storeAvailable.append(TAG_COLUMN, (*iterAll).c_str());
1436                 } else {
1437                     row = gtk_tree_model_iter_next(storeAssigned, &iterAssigned) != 0;
1438
1439                     if (row) {
1440                         gtk_tree_model_get(storeAssigned, &iterAssigned, TAG_COLUMN, &tag_assigned, -1);
1441                     }
1442                 }
1443             }
1444         }
1445     }
1446 }
1447
1448 gboolean TextureBrowser_button_press(ui::Widget widget, GdkEventButton *event, TextureBrowser *textureBrowser)
1449 {
1450     if (event->type == GDK_BUTTON_PRESS) {
1451         if (event->button == 3) {
1452             if (GlobalTextureBrowser().m_tags) {
1453                 textureBrowser->m_rmbSelected = true;
1454                 TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>( event->x ),
1455                                                    static_cast<int>( event->y ));
1456
1457                 BuildStoreAssignedTags(textureBrowser->m_assigned_store, textureBrowser->shader.c_str(),
1458                                        textureBrowser);
1459                 BuildStoreAvailableTags(textureBrowser->m_available_store, textureBrowser->m_assigned_store,
1460                                         textureBrowser->m_all_tags, textureBrowser);
1461                 textureBrowser->m_heightChanged = true;
1462                 textureBrowser->m_tag_frame.show();
1463
1464                 ui::process();
1465
1466                 TextureBrowser_Focus(*textureBrowser, textureBrowser->shader.c_str());
1467             } else {
1468                 TextureBrowser_Tracking_MouseDown(*textureBrowser);
1469             }
1470         } else if (event->button == 1) {
1471             TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>( event->x ),
1472                                                static_cast<int>( event->y ));
1473
1474             if (GlobalTextureBrowser().m_tags) {
1475                 textureBrowser->m_rmbSelected = false;
1476                 textureBrowser->m_tag_frame.hide();
1477             }
1478         }
1479     }
1480     return FALSE;
1481 }
1482
1483 gboolean TextureBrowser_button_release(ui::Widget widget, GdkEventButton *event, TextureBrowser *textureBrowser)
1484 {
1485     if (event->type == GDK_BUTTON_RELEASE) {
1486         if (event->button == 3) {
1487             if (!GlobalTextureBrowser().m_tags) {
1488                 TextureBrowser_Tracking_MouseUp(*textureBrowser);
1489             }
1490         }
1491     }
1492     return FALSE;
1493 }
1494
1495 gboolean TextureBrowser_motion(ui::Widget widget, GdkEventMotion *event, TextureBrowser *textureBrowser)
1496 {
1497     return FALSE;
1498 }
1499
1500 gboolean TextureBrowser_scroll(ui::Widget widget, GdkEventScroll *event, TextureBrowser *textureBrowser)
1501 {
1502     if (event->direction == GDK_SCROLL_UP) {
1503         TextureBrowser_MouseWheel(*textureBrowser, true);
1504     } else if (event->direction == GDK_SCROLL_DOWN) {
1505         TextureBrowser_MouseWheel(*textureBrowser, false);
1506     }
1507     return FALSE;
1508 }
1509
1510 void TextureBrowser_scrollChanged(void *data, gdouble value)
1511 {
1512     //globalOutputStream() << "vertical scroll\n";
1513     TextureBrowser_setOriginY(*reinterpret_cast<TextureBrowser *>( data ), -(int) value);
1514 }
1515
1516 static void TextureBrowser_verticalScroll(ui::Adjustment adjustment, TextureBrowser *textureBrowser)
1517 {
1518     textureBrowser->m_scrollAdjustment.value_changed(gtk_adjustment_get_value(adjustment));
1519 }
1520
1521 void TextureBrowser_updateScroll(TextureBrowser &textureBrowser)
1522 {
1523     if (textureBrowser.m_showTextureScrollbar) {
1524         int totalHeight = TextureBrowser_TotalHeight(textureBrowser);
1525
1526         totalHeight = std::max(totalHeight, textureBrowser.height);
1527
1528         auto vadjustment = gtk_range_get_adjustment(GTK_RANGE(textureBrowser.m_texture_scroll));
1529
1530         gtk_adjustment_set_value(vadjustment, -TextureBrowser_getOriginY(textureBrowser));
1531         gtk_adjustment_set_page_size(vadjustment, textureBrowser.height);
1532         gtk_adjustment_set_page_increment(vadjustment, textureBrowser.height / 2);
1533         gtk_adjustment_set_step_increment(vadjustment, 20);
1534         gtk_adjustment_set_lower(vadjustment, 0);
1535         gtk_adjustment_set_upper(vadjustment, totalHeight);
1536
1537         g_signal_emit_by_name(G_OBJECT(vadjustment), "changed");
1538     }
1539 }
1540
1541 gboolean TextureBrowser_size_allocate(ui::Widget widget, GtkAllocation *allocation, TextureBrowser *textureBrowser)
1542 {
1543     textureBrowser->width = allocation->width;
1544     textureBrowser->height = allocation->height;
1545     TextureBrowser_heightChanged(*textureBrowser);
1546     textureBrowser->m_originInvalid = true;
1547     TextureBrowser_queueDraw(*textureBrowser);
1548     return FALSE;
1549 }
1550
1551 gboolean TextureBrowser_expose(ui::Widget widget, GdkEventExpose *event, TextureBrowser *textureBrowser)
1552 {
1553     if (glwidget_make_current(textureBrowser->m_gl_widget) != FALSE) {
1554         GlobalOpenGL_debugAssertNoErrors();
1555         TextureBrowser_evaluateHeight(*textureBrowser);
1556         Texture_Draw(*textureBrowser);
1557         GlobalOpenGL_debugAssertNoErrors();
1558         glwidget_swap_buffers(textureBrowser->m_gl_widget);
1559     }
1560     return FALSE;
1561 }
1562
1563
1564 TextureBrowser g_TextureBrowser;
1565
1566 TextureBrowser &GlobalTextureBrowser()
1567 {
1568     return g_TextureBrowser;
1569 }
1570
1571 bool TextureBrowser_hideUnused()
1572 {
1573     return g_TextureBrowser.m_hideUnused;
1574 }
1575
1576 void TextureBrowser_ToggleHideUnused()
1577 {
1578     if (g_TextureBrowser.m_hideUnused) {
1579         TextureBrowser_SetHideUnused(g_TextureBrowser, false);
1580     } else {
1581         TextureBrowser_SetHideUnused(g_TextureBrowser, true);
1582     }
1583 }
1584
1585 void TextureGroups_constructTreeModel(TextureGroups groups, ui::TreeStore store)
1586 {
1587     // put the information from the old textures menu into a treeview
1588     GtkTreeIter iter, child;
1589
1590     TextureGroups::const_iterator i = groups.begin();
1591     while (i != groups.end()) {
1592         const char *dirName = (*i).c_str();
1593         const char *firstUnderscore = strchr(dirName, '_');
1594         StringRange dirRoot(dirName, (firstUnderscore == 0) ? dirName : firstUnderscore + 1);
1595
1596         TextureGroups::const_iterator next = i;
1597         ++next;
1598         if (firstUnderscore != 0
1599             && next != groups.end()
1600             && string_equal_start((*next).c_str(), dirRoot)) {
1601             gtk_tree_store_append(store, &iter, NULL);
1602             gtk_tree_store_set(store, &iter, 0, CopiedString(StringRange(dirName, firstUnderscore)).c_str(), -1);
1603
1604             // keep going...
1605             while (i != groups.end() && string_equal_start((*i).c_str(), dirRoot)) {
1606                 gtk_tree_store_append(store, &child, &iter);
1607                 gtk_tree_store_set(store, &child, 0, (*i).c_str(), -1);
1608                 ++i;
1609             }
1610         } else {
1611             gtk_tree_store_append(store, &iter, NULL);
1612             gtk_tree_store_set(store, &iter, 0, dirName, -1);
1613             ++i;
1614         }
1615     }
1616 }
1617
1618 TextureGroups TextureGroups_constructTreeView()
1619 {
1620     TextureGroups groups;
1621
1622     if (TextureBrowser_showWads()) {
1623         GlobalFileSystem().forEachArchive(TextureGroupsAddWadCaller(groups));
1624     } else {
1625         // scan texture dirs and pak files only if not restricting to shaderlist
1626         if (g_pGameDescription->mGameType != "doom3" && !g_TextureBrowser_shaderlistOnly) {
1627             GlobalFileSystem().forEachDirectory("textures/", TextureGroupsAddDirectoryCaller(groups));
1628         }
1629
1630         GlobalShaderSystem().foreachShaderName(TextureGroupsAddShaderCaller(groups));
1631     }
1632
1633     return groups;
1634 }
1635
1636 void TextureBrowser_constructTreeStore()
1637 {
1638     TextureGroups groups = TextureGroups_constructTreeView();
1639     auto store = ui::TreeStore::from(gtk_tree_store_new(1, G_TYPE_STRING));
1640     TextureGroups_constructTreeModel(groups, store);
1641
1642     gtk_tree_view_set_model(g_TextureBrowser.m_treeViewTree, store);
1643
1644     g_object_unref(G_OBJECT(store));
1645 }
1646
1647 void TextureBrowser_constructTreeStoreTags()
1648 {
1649     TextureGroups groups;
1650     auto store = ui::TreeStore::from(gtk_tree_store_new(1, G_TYPE_STRING));
1651     auto model = g_TextureBrowser.m_all_tags_list;
1652
1653     gtk_tree_view_set_model(g_TextureBrowser.m_treeViewTags, model);
1654
1655     g_object_unref(G_OBJECT(store));
1656 }
1657
1658 void TreeView_onRowActivated(ui::TreeView treeview, ui::TreePath path, ui::TreeViewColumn col, gpointer userdata)
1659 {
1660     GtkTreeIter iter;
1661
1662     auto model = gtk_tree_view_get_model(treeview);
1663
1664     if (gtk_tree_model_get_iter(model, &iter, path)) {
1665         gchar dirName[1024];
1666
1667         gchar *buffer;
1668         gtk_tree_model_get(model, &iter, 0, &buffer, -1);
1669         strcpy(dirName, buffer);
1670         g_free(buffer);
1671
1672         g_TextureBrowser.m_searchedTags = false;
1673
1674         if (!TextureBrowser_showWads()) {
1675             strcat(dirName, "/");
1676         }
1677
1678         ScopeDisableScreenUpdates disableScreenUpdates(dirName, "Loading Textures");
1679         TextureBrowser_ShowDirectory(GlobalTextureBrowser(), dirName);
1680         TextureBrowser_queueDraw(GlobalTextureBrowser());
1681     }
1682 }
1683
1684 void TextureBrowser_createTreeViewTree()
1685 {
1686     gtk_tree_view_set_enable_search(g_TextureBrowser.m_treeViewTree, FALSE);
1687
1688     gtk_tree_view_set_headers_visible(g_TextureBrowser.m_treeViewTree, FALSE);
1689     g_TextureBrowser.m_treeViewTree.connect("row-activated", (GCallback) TreeView_onRowActivated, NULL);
1690
1691     auto renderer = ui::CellRendererText(ui::New);
1692     gtk_tree_view_insert_column_with_attributes(g_TextureBrowser.m_treeViewTree, -1, "", renderer, "text", 0, NULL);
1693
1694     TextureBrowser_constructTreeStore();
1695 }
1696
1697 void TextureBrowser_addTag();
1698
1699 void TextureBrowser_renameTag();
1700
1701 void TextureBrowser_deleteTag();
1702
1703 void TextureBrowser_createContextMenu(ui::Widget treeview, GdkEventButton *event)
1704 {
1705     ui::Widget menu = ui::Menu(ui::New);
1706
1707     ui::Widget menuitem = ui::MenuItem("Add tag");
1708     menuitem.connect("activate", (GCallback) TextureBrowser_addTag, treeview);
1709     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1710
1711     menuitem = ui::MenuItem("Rename tag");
1712     menuitem.connect("activate", (GCallback) TextureBrowser_renameTag, treeview);
1713     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1714
1715     menuitem = ui::MenuItem("Delete tag");
1716     menuitem.connect("activate", (GCallback) TextureBrowser_deleteTag, treeview);
1717     gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1718
1719     gtk_widget_show_all(menu);
1720
1721     gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
1722                    (event != NULL) ? event->button : 0,
1723                    gdk_event_get_time((GdkEvent *) event));
1724 }
1725
1726 gboolean TreeViewTags_onButtonPressed(ui::TreeView treeview, GdkEventButton *event)
1727 {
1728     if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
1729         GtkTreePath *path;
1730         auto selection = gtk_tree_view_get_selection(treeview);
1731
1732         if (gtk_tree_view_get_path_at_pos(treeview, event->x, event->y, &path, NULL, NULL, NULL)) {
1733             gtk_tree_selection_unselect_all(selection);
1734             gtk_tree_selection_select_path(selection, path);
1735             gtk_tree_path_free(path);
1736         }
1737
1738         TextureBrowser_createContextMenu(treeview, event);
1739         return TRUE;
1740     }
1741     return FALSE;
1742 }
1743
1744 void TextureBrowser_createTreeViewTags()
1745 {
1746     g_TextureBrowser.m_treeViewTags = ui::TreeView(ui::New);
1747     gtk_tree_view_set_enable_search(g_TextureBrowser.m_treeViewTags, FALSE);
1748
1749     g_TextureBrowser.m_treeViewTags.connect("button-press-event", (GCallback) TreeViewTags_onButtonPressed, NULL);
1750
1751     gtk_tree_view_set_headers_visible(g_TextureBrowser.m_treeViewTags, FALSE);
1752
1753     auto renderer = ui::CellRendererText(ui::New);
1754     gtk_tree_view_insert_column_with_attributes(g_TextureBrowser.m_treeViewTags, -1, "", renderer, "text", 0, NULL);
1755
1756     TextureBrowser_constructTreeStoreTags();
1757 }
1758
1759 ui::MenuItem TextureBrowser_constructViewMenu(ui::Menu menu)
1760 {
1761     ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("_View"));
1762
1763     if (g_Layout_enableDetachableMenus.m_value) {
1764         menu_tearoff(menu);
1765     }
1766
1767     create_check_menu_item_with_mnemonic(menu, "Hide _Unused", "ShowInUse");
1768     if (string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1769         create_check_menu_item_with_mnemonic(menu, "Hide Image Missing", "FilterMissing");
1770     }
1771
1772     // hide notex and shadernotex on texture browser: no one wants to apply them
1773     create_check_menu_item_with_mnemonic(menu, "Hide Fallback", "FilterFallback");
1774
1775     menu_separator(menu);
1776
1777     create_menu_item_with_mnemonic(menu, "Show All", "ShowAllTextures");
1778
1779     // we always want to show shaders but don't want a "Show Shaders" menu for doom3 and .wad file games
1780     if (g_pGameDescription->mGameType == "doom3" || !string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1781         g_TextureBrowser.m_showShaders = true;
1782     } else {
1783         create_check_menu_item_with_mnemonic(menu, "Show shaders", "ToggleShowShaders");
1784     }
1785
1786     if (g_pGameDescription->mGameType != "doom3" && string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1787         create_check_menu_item_with_mnemonic(menu, "Shaders Only", "ToggleShowShaderlistOnly");
1788     }
1789     if (g_TextureBrowser.m_tags) {
1790         create_menu_item_with_mnemonic(menu, "Show Untagged", "ShowUntagged");
1791     }
1792
1793     menu_separator(menu);
1794     create_check_menu_item_with_mnemonic(menu, "Fixed Size", "FixedSize");
1795     create_check_menu_item_with_mnemonic(menu, "Transparency", "EnableAlpha");
1796
1797     if (string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1798         menu_separator(menu);
1799         g_TextureBrowser.m_shader_info_item = ui::Widget(
1800                 create_menu_item_with_mnemonic(menu, "Shader Info", "ShaderInfo"));
1801         gtk_widget_set_sensitive(g_TextureBrowser.m_shader_info_item, FALSE);
1802     }
1803
1804
1805     return textures_menu_item;
1806 }
1807
1808 ui::MenuItem TextureBrowser_constructToolsMenu(ui::Menu menu)
1809 {
1810     ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("_Tools"));
1811
1812     if (g_Layout_enableDetachableMenus.m_value) {
1813         menu_tearoff(menu);
1814     }
1815
1816     create_menu_item_with_mnemonic(menu, "Flush & Reload Shaders", "RefreshShaders");
1817     create_menu_item_with_mnemonic(menu, "Find / Replace...", "FindReplaceTextures");
1818
1819     return textures_menu_item;
1820 }
1821
1822 ui::MenuItem TextureBrowser_constructTagsMenu(ui::Menu menu)
1823 {
1824     ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("T_ags"));
1825
1826     if (g_Layout_enableDetachableMenus.m_value) {
1827         menu_tearoff(menu);
1828     }
1829
1830     create_menu_item_with_mnemonic(menu, "Add tag", "AddTag");
1831     create_menu_item_with_mnemonic(menu, "Rename tag", "RenameTag");
1832     create_menu_item_with_mnemonic(menu, "Delete tag", "DeleteTag");
1833     menu_separator(menu);
1834     create_menu_item_with_mnemonic(menu, "Copy tags from selected", "CopyTag");
1835     create_menu_item_with_mnemonic(menu, "Paste tags to selected", "PasteTag");
1836
1837     return textures_menu_item;
1838 }
1839
1840 gboolean TextureBrowser_tagMoveHelper(ui::TreeModel model, ui::TreePath path, GtkTreeIter iter, GSList **selected)
1841 {
1842     g_assert(selected != NULL);
1843
1844     auto rowref = gtk_tree_row_reference_new(model, path);
1845     *selected = g_slist_append(*selected, rowref);
1846
1847     return FALSE;
1848 }
1849
1850 void TextureBrowser_assignTags()
1851 {
1852     GSList *selected = NULL;
1853     GSList *node;
1854     gchar *tag_assigned;
1855
1856     auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
1857
1858     gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1859                                         &selected);
1860
1861     if (selected != NULL) {
1862         for (node = selected; node != NULL; node = node->next) {
1863             auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1864
1865             if (path) {
1866                 GtkTreeIter iter;
1867
1868                 if (gtk_tree_model_get_iter(g_TextureBrowser.m_available_store, &iter, path)) {
1869                     gtk_tree_model_get(g_TextureBrowser.m_available_store, &iter, TAG_COLUMN, &tag_assigned, -1);
1870                     if (!TagBuilder.CheckShaderTag(g_TextureBrowser.shader.c_str())) {
1871                         // create a custom shader/texture entry
1872                         IShader *ishader = QERApp_Shader_ForName(g_TextureBrowser.shader.c_str());
1873                         CopiedString filename = ishader->getShaderFileName();
1874
1875                         if (filename.empty()) {
1876                             // it's a texture
1877                             TagBuilder.AddShaderNode(g_TextureBrowser.shader.c_str(), CUSTOM, TEXTURE);
1878                         } else {
1879                             // it's a shader
1880                             TagBuilder.AddShaderNode(g_TextureBrowser.shader.c_str(), CUSTOM, SHADER);
1881                         }
1882                         ishader->DecRef();
1883                     }
1884                     TagBuilder.AddShaderTag(g_TextureBrowser.shader.c_str(), (char *) tag_assigned, TAG);
1885
1886                     gtk_list_store_remove(g_TextureBrowser.m_available_store, &iter);
1887                     g_TextureBrowser.m_assigned_store.append(TAG_COLUMN, tag_assigned);
1888                 }
1889             }
1890         }
1891
1892         g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1893
1894         // Save changes
1895         TagBuilder.SaveXmlDoc();
1896     }
1897     g_slist_free(selected);
1898 }
1899
1900 void TextureBrowser_removeTags()
1901 {
1902     GSList *selected = NULL;
1903     GSList *node;
1904     gchar *tag;
1905
1906     auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_assigned_tree);
1907
1908     gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1909                                         &selected);
1910
1911     if (selected != NULL) {
1912         for (node = selected; node != NULL; node = node->next) {
1913             auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1914
1915             if (path) {
1916                 GtkTreeIter iter;
1917
1918                 if (gtk_tree_model_get_iter(g_TextureBrowser.m_assigned_store, &iter, path)) {
1919                     gtk_tree_model_get(g_TextureBrowser.m_assigned_store, &iter, TAG_COLUMN, &tag, -1);
1920                     TagBuilder.DeleteShaderTag(g_TextureBrowser.shader.c_str(), tag);
1921                     gtk_list_store_remove(g_TextureBrowser.m_assigned_store, &iter);
1922                 }
1923             }
1924         }
1925
1926         g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1927
1928         // Update the "available tags list"
1929         BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
1930                                 g_TextureBrowser.m_all_tags, &g_TextureBrowser);
1931
1932         // Save changes
1933         TagBuilder.SaveXmlDoc();
1934     }
1935     g_slist_free(selected);
1936 }
1937
1938 void TextureBrowser_buildTagList()
1939 {
1940     g_TextureBrowser.m_all_tags_list.clear();
1941
1942     std::set<CopiedString>::iterator iter;
1943
1944     for (iter = g_TextureBrowser.m_all_tags.begin(); iter != g_TextureBrowser.m_all_tags.end(); ++iter) {
1945         g_TextureBrowser.m_all_tags_list.append(TAG_COLUMN, (*iter).c_str());
1946     }
1947 }
1948
1949 void TextureBrowser_searchTags()
1950 {
1951     GSList *selected = NULL;
1952     GSList *node;
1953     gchar *tag;
1954     char buffer[256];
1955     char tags_searched[256];
1956
1957     auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
1958
1959     gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1960                                         &selected);
1961
1962     if (selected != NULL) {
1963         strcpy(buffer, "/root/*/*[tag='");
1964         strcpy(tags_searched, "[TAGS] ");
1965
1966         for (node = selected; node != NULL; node = node->next) {
1967             auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1968
1969             if (path) {
1970                 GtkTreeIter iter;
1971
1972                 if (gtk_tree_model_get_iter(g_TextureBrowser.m_all_tags_list, &iter, path)) {
1973                     gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iter, TAG_COLUMN, &tag, -1);
1974
1975                     strcat(buffer, tag);
1976                     strcat(tags_searched, tag);
1977                     if (node != g_slist_last(node)) {
1978                         strcat(buffer, "' and tag='");
1979                         strcat(tags_searched, ", ");
1980                     }
1981                 }
1982             }
1983         }
1984
1985         strcat(buffer, "']");
1986
1987         g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1988
1989         g_TextureBrowser.m_found_shaders.clear(); // delete old list
1990         TagBuilder.TagSearch(buffer, g_TextureBrowser.m_found_shaders);
1991
1992         if (!g_TextureBrowser.m_found_shaders.empty()) { // found something
1993             size_t shaders_found = g_TextureBrowser.m_found_shaders.size();
1994
1995             globalOutputStream() << "Found " << (unsigned int) shaders_found << " textures and shaders with "
1996                                  << tags_searched << "\n";
1997             ScopeDisableScreenUpdates disableScreenUpdates("Searching...", "Loading Textures");
1998
1999             std::set<CopiedString>::iterator iter;
2000
2001             for (iter = g_TextureBrowser.m_found_shaders.begin();
2002                  iter != g_TextureBrowser.m_found_shaders.end(); iter++) {
2003                 std::string path = (*iter).c_str();
2004                 size_t pos = path.find_last_of("/", path.size());
2005                 std::string name = path.substr(pos + 1, path.size());
2006                 path = path.substr(0, pos + 1);
2007                 TextureDirectory_loadTexture(path.c_str(), name.c_str());
2008             }
2009         }
2010         g_TextureBrowser.m_searchedTags = true;
2011         g_TextureBrowser_currentDirectory = tags_searched;
2012
2013         g_TextureBrowser.m_nTotalHeight = 0;
2014         TextureBrowser_setOriginY(g_TextureBrowser, 0);
2015         TextureBrowser_heightChanged(g_TextureBrowser);
2016         TextureBrowser_updateTitle();
2017     }
2018     g_slist_free(selected);
2019 }
2020
2021 void TextureBrowser_toggleSearchButton()
2022 {
2023     gint page = gtk_notebook_get_current_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook));
2024
2025     if (page == 0) { // tag page
2026         gtk_widget_show_all(g_TextureBrowser.m_search_button);
2027     } else {
2028         g_TextureBrowser.m_search_button.hide();
2029     }
2030 }
2031
2032 void TextureBrowser_constructTagNotebook()
2033 {
2034     g_TextureBrowser.m_tag_notebook = ui::Widget::from(gtk_notebook_new());
2035     ui::Widget labelTags = ui::Label("Tags");
2036     ui::Widget labelTextures = ui::Label("Textures");
2037
2038     gtk_notebook_append_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook), g_TextureBrowser.m_scr_win_tree,
2039                              labelTextures);
2040     gtk_notebook_append_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook), g_TextureBrowser.m_scr_win_tags, labelTags);
2041
2042     g_TextureBrowser.m_tag_notebook.connect("switch-page", G_CALLBACK(TextureBrowser_toggleSearchButton), NULL);
2043
2044     gtk_widget_show_all(g_TextureBrowser.m_tag_notebook);
2045 }
2046
2047 void TextureBrowser_constructSearchButton()
2048 {
2049     auto image = ui::Widget::from(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_SMALL_TOOLBAR));
2050     g_TextureBrowser.m_search_button = ui::Button(ui::New);
2051     g_TextureBrowser.m_search_button.connect("clicked", G_CALLBACK(TextureBrowser_searchTags), NULL);
2052     gtk_widget_set_tooltip_text(g_TextureBrowser.m_search_button, "Search with selected tags");
2053     g_TextureBrowser.m_search_button.add(image);
2054 }
2055
2056 void TextureBrowser_checkTagFile()
2057 {
2058     const char SHADERTAG_FILE[] = "shadertags.xml";
2059     CopiedString default_filename, rc_filename;
2060     StringOutputStream stream(256);
2061
2062     stream << LocalRcPath_get();
2063     stream << SHADERTAG_FILE;
2064     rc_filename = stream.c_str();
2065
2066     if (file_exists(rc_filename.c_str())) {
2067         g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc(rc_filename.c_str());
2068
2069         if (g_TextureBrowser.m_tags) {
2070             globalOutputStream() << "Loading tag file " << rc_filename.c_str() << ".\n";
2071         }
2072     } else {
2073         // load default tagfile
2074         stream.clear();
2075         stream << g_pGameDescription->mGameToolsPath.c_str();
2076         stream << SHADERTAG_FILE;
2077         default_filename = stream.c_str();
2078
2079         if (file_exists(default_filename.c_str())) {
2080             g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc(default_filename.c_str(), rc_filename.c_str());
2081
2082             if (g_TextureBrowser.m_tags) {
2083                 globalOutputStream() << "Loading default tag file " << default_filename.c_str() << ".\n";
2084             }
2085         } else {
2086             globalErrorStream() << "Unable to find default tag file " << default_filename.c_str()
2087                                 << ". No tag support.\n";
2088         }
2089     }
2090 }
2091
2092 void TextureBrowser_SetNotex()
2093 {
2094     StringOutputStream name(256);
2095     name << GlobalRadiant().getAppPath() << "bitmaps/" NOTEX_BASENAME ".png";
2096     g_notex = name.c_str();
2097
2098     name = StringOutputStream(256);
2099     name << GlobalRadiant().getAppPath() << "bitmaps/" SHADERNOTEX_BASENAME " .png";
2100     g_shadernotex = name.c_str();
2101 }
2102
2103 ui::Widget TextureBrowser_constructWindow(ui::Window toplevel)
2104 {
2105     // The gl_widget and the tag assignment frame should be packed into a GtkVPaned with the slider
2106     // position stored in local.pref. gtk_paned_get_position() and gtk_paned_set_position() don't
2107     // seem to work in gtk 2.4 and the arrow buttons don't handle GTK_FILL, so here's another thing
2108     // for the "once-the-gtk-libs-are-updated-TODO-list" :x
2109
2110     TextureBrowser_checkTagFile();
2111     TextureBrowser_SetNotex();
2112
2113     GlobalShaderSystem().setActiveShadersChangedNotify(
2114             ReferenceCaller<TextureBrowser, void(), TextureBrowser_activeShadersChanged>(g_TextureBrowser));
2115
2116     g_TextureBrowser.m_parent = toplevel;
2117
2118     auto table = ui::Table(3, 3, FALSE);
2119     auto vbox = ui::VBox(FALSE, 0);
2120     table.attach(vbox, {0, 1, 1, 3}, {GTK_FILL, GTK_FILL});
2121     vbox.show();
2122
2123     ui::Widget menu_bar{ui::null};
2124
2125     { // menu bar
2126         menu_bar = ui::Widget::from(gtk_menu_bar_new());
2127         auto menu_view = ui::Menu(ui::New);
2128         auto view_item = TextureBrowser_constructViewMenu(menu_view);
2129         gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_item), menu_view);
2130         gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view_item);
2131
2132         auto menu_tools = ui::Menu(ui::New);
2133         auto tools_item = TextureBrowser_constructToolsMenu(menu_tools);
2134         gtk_menu_item_set_submenu(GTK_MENU_ITEM(tools_item), menu_tools);
2135         gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tools_item);
2136
2137         table.attach(menu_bar, {0, 3, 0, 1}, {GTK_FILL, GTK_SHRINK});
2138         menu_bar.show();
2139     }
2140     { // Texture TreeView
2141         g_TextureBrowser.m_scr_win_tree = ui::ScrolledWindow(ui::New);
2142         gtk_container_set_border_width(GTK_CONTAINER(g_TextureBrowser.m_scr_win_tree), 0);
2143
2144         // vertical only scrolling for treeview
2145         gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tree), GTK_POLICY_NEVER,
2146                                        GTK_POLICY_ALWAYS);
2147
2148         g_TextureBrowser.m_scr_win_tree.show();
2149
2150         TextureBrowser_createTreeViewTree();
2151
2152         gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tree),
2153                                               g_TextureBrowser.m_treeViewTree);
2154         g_TextureBrowser.m_treeViewTree.show();
2155     }
2156     { // gl_widget scrollbar
2157         auto w = ui::Widget::from(gtk_vscrollbar_new(ui::Adjustment(0, 0, 0, 1, 1, 0)));
2158         table.attach(w, {2, 3, 1, 2}, {GTK_SHRINK, GTK_FILL});
2159         w.show();
2160         g_TextureBrowser.m_texture_scroll = w;
2161
2162         auto vadjustment = ui::Adjustment::from(gtk_range_get_adjustment(GTK_RANGE(g_TextureBrowser.m_texture_scroll)));
2163         vadjustment.connect("value_changed", G_CALLBACK(TextureBrowser_verticalScroll), &g_TextureBrowser);
2164
2165         g_TextureBrowser.m_texture_scroll.visible(g_TextureBrowser.m_showTextureScrollbar);
2166     }
2167     { // gl_widget
2168         g_TextureBrowser.m_gl_widget = glwidget_new(FALSE);
2169         g_object_ref(g_TextureBrowser.m_gl_widget._handle);
2170
2171         gtk_widget_set_events(g_TextureBrowser.m_gl_widget,
2172                               GDK_DESTROY | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
2173                               GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
2174         gtk_widget_set_can_focus(g_TextureBrowser.m_gl_widget, true);
2175
2176         table.attach(g_TextureBrowser.m_gl_widget, {1, 2, 1, 2});
2177         g_TextureBrowser.m_gl_widget.show();
2178
2179         g_TextureBrowser.m_sizeHandler = g_TextureBrowser.m_gl_widget.connect("size_allocate",
2180                                                                               G_CALLBACK(TextureBrowser_size_allocate),
2181                                                                               &g_TextureBrowser);
2182         g_TextureBrowser.m_exposeHandler = g_TextureBrowser.m_gl_widget.on_render(G_CALLBACK(TextureBrowser_expose),
2183                                                                                   &g_TextureBrowser);
2184
2185         g_TextureBrowser.m_gl_widget.connect("button_press_event", G_CALLBACK(TextureBrowser_button_press),
2186                                              &g_TextureBrowser);
2187         g_TextureBrowser.m_gl_widget.connect("button_release_event", G_CALLBACK(TextureBrowser_button_release),
2188                                              &g_TextureBrowser);
2189         g_TextureBrowser.m_gl_widget.connect("motion_notify_event", G_CALLBACK(TextureBrowser_motion),
2190                                              &g_TextureBrowser);
2191         g_TextureBrowser.m_gl_widget.connect("scroll_event", G_CALLBACK(TextureBrowser_scroll), &g_TextureBrowser);
2192     }
2193
2194     // tag stuff
2195     if (g_TextureBrowser.m_tags) {
2196         { // fill tag GtkListStore
2197             g_TextureBrowser.m_all_tags_list = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2198             auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_all_tags_list);
2199             gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2200
2201             TagBuilder.GetAllTags(g_TextureBrowser.m_all_tags);
2202             TextureBrowser_buildTagList();
2203         }
2204         { // tag menu bar
2205             auto menu_tags = ui::Menu(ui::New);
2206             auto tags_item = TextureBrowser_constructTagsMenu(menu_tags);
2207             gtk_menu_item_set_submenu(GTK_MENU_ITEM(tags_item), menu_tags);
2208             gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tags_item);
2209         }
2210         { // Tag TreeView
2211             g_TextureBrowser.m_scr_win_tags = ui::ScrolledWindow(ui::New);
2212             gtk_container_set_border_width(GTK_CONTAINER(g_TextureBrowser.m_scr_win_tags), 0);
2213
2214             // vertical only scrolling for treeview
2215             gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tags), GTK_POLICY_NEVER,
2216                                            GTK_POLICY_ALWAYS);
2217
2218             TextureBrowser_createTreeViewTags();
2219
2220             auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2221             gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2222
2223             gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tags),
2224                                                   g_TextureBrowser.m_treeViewTags);
2225             g_TextureBrowser.m_treeViewTags.show();
2226         }
2227         { // Texture/Tag notebook
2228             TextureBrowser_constructTagNotebook();
2229             vbox.pack_start(g_TextureBrowser.m_tag_notebook, TRUE, TRUE, 0);
2230         }
2231         { // Tag search button
2232             TextureBrowser_constructSearchButton();
2233             vbox.pack_end(g_TextureBrowser.m_search_button, FALSE, FALSE, 0);
2234         }
2235         auto frame_table = ui::Table(3, 3, FALSE);
2236         { // Tag frame
2237
2238             g_TextureBrowser.m_tag_frame = ui::Frame("Tag assignment");
2239             gtk_frame_set_label_align(GTK_FRAME(g_TextureBrowser.m_tag_frame), 0.5, 0.5);
2240             gtk_frame_set_shadow_type(GTK_FRAME(g_TextureBrowser.m_tag_frame), GTK_SHADOW_NONE);
2241
2242             table.attach(g_TextureBrowser.m_tag_frame, {1, 3, 2, 3}, {GTK_FILL, GTK_SHRINK});
2243
2244             frame_table.show();
2245
2246             g_TextureBrowser.m_tag_frame.add(frame_table);
2247         }
2248         { // assigned tag list
2249             ui::Widget scrolled_win = ui::ScrolledWindow(ui::New);
2250             gtk_container_set_border_width(GTK_CONTAINER(scrolled_win), 0);
2251             gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
2252
2253             g_TextureBrowser.m_assigned_store = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2254
2255             auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_assigned_store);
2256             gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2257
2258             auto renderer = ui::CellRendererText(ui::New);
2259
2260             g_TextureBrowser.m_assigned_tree = ui::TreeView(
2261                     ui::TreeModel::from(g_TextureBrowser.m_assigned_store._handle));
2262             g_TextureBrowser.m_assigned_store.unref();
2263             g_TextureBrowser.m_assigned_tree.connect("row-activated", (GCallback) TextureBrowser_removeTags, NULL);
2264             gtk_tree_view_set_headers_visible(g_TextureBrowser.m_assigned_tree, FALSE);
2265
2266             auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_assigned_tree);
2267             gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2268
2269             auto column = ui::TreeViewColumn("", renderer, {{"text", TAG_COLUMN}});
2270             gtk_tree_view_append_column(g_TextureBrowser.m_assigned_tree, column);
2271             g_TextureBrowser.m_assigned_tree.show();
2272
2273             scrolled_win.show();
2274             gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), g_TextureBrowser.m_assigned_tree);
2275
2276             frame_table.attach(scrolled_win, {0, 1, 1, 3}, {GTK_FILL, GTK_FILL});
2277         }
2278         { // available tag list
2279             ui::Widget scrolled_win = ui::ScrolledWindow(ui::New);
2280             gtk_container_set_border_width(GTK_CONTAINER(scrolled_win), 0);
2281             gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
2282
2283             g_TextureBrowser.m_available_store = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2284             auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_available_store);
2285             gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2286
2287             auto renderer = ui::CellRendererText(ui::New);
2288
2289             g_TextureBrowser.m_available_tree = ui::TreeView(
2290                     ui::TreeModel::from(g_TextureBrowser.m_available_store._handle));
2291             g_TextureBrowser.m_available_store.unref();
2292             g_TextureBrowser.m_available_tree.connect("row-activated", (GCallback) TextureBrowser_assignTags, NULL);
2293             gtk_tree_view_set_headers_visible(g_TextureBrowser.m_available_tree, FALSE);
2294
2295             auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
2296             gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2297
2298             auto column = ui::TreeViewColumn("", renderer, {{"text", TAG_COLUMN}});
2299             gtk_tree_view_append_column(g_TextureBrowser.m_available_tree, column);
2300             g_TextureBrowser.m_available_tree.show();
2301
2302             scrolled_win.show();
2303             gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), g_TextureBrowser.m_available_tree);
2304
2305             frame_table.attach(scrolled_win, {2, 3, 1, 3}, {GTK_FILL, GTK_FILL});
2306         }
2307         { // tag arrow buttons
2308             auto m_btn_left = ui::Button(ui::New);
2309             auto m_btn_right = ui::Button(ui::New);
2310             auto m_arrow_left = ui::Widget::from(gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_OUT));
2311             auto m_arrow_right = ui::Widget::from(gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT));
2312             m_btn_left.add(m_arrow_left);
2313             m_btn_right.add(m_arrow_right);
2314
2315             // workaround. the size of the tag frame depends of the requested size of the arrow buttons.
2316             m_arrow_left.dimensions(-1, 68);
2317             m_arrow_right.dimensions(-1, 68);
2318
2319             frame_table.attach(m_btn_left, {1, 2, 1, 2}, {GTK_SHRINK, GTK_EXPAND});
2320             frame_table.attach(m_btn_right, {1, 2, 2, 3}, {GTK_SHRINK, GTK_EXPAND});
2321
2322             m_btn_left.connect("clicked", G_CALLBACK(TextureBrowser_assignTags), NULL);
2323             m_btn_right.connect("clicked", G_CALLBACK(TextureBrowser_removeTags), NULL);
2324
2325             m_btn_left.show();
2326             m_btn_right.show();
2327             m_arrow_left.show();
2328             m_arrow_right.show();
2329         }
2330         { // tag fram labels
2331             ui::Widget m_lbl_assigned = ui::Label("Assigned");
2332             ui::Widget m_lbl_unassigned = ui::Label("Available");
2333
2334             frame_table.attach(m_lbl_assigned, {0, 1, 0, 1}, {GTK_EXPAND, GTK_SHRINK});
2335             frame_table.attach(m_lbl_unassigned, {2, 3, 0, 1}, {GTK_EXPAND, GTK_SHRINK});
2336
2337             m_lbl_assigned.show();
2338             m_lbl_unassigned.show();
2339         }
2340     } else { // no tag support, show the texture tree only
2341         vbox.pack_start(g_TextureBrowser.m_scr_win_tree, TRUE, TRUE, 0);
2342     }
2343
2344     // TODO do we need this?
2345     //gtk_container_set_focus_chain(GTK_CONTAINER(hbox_table), NULL);
2346
2347     return table;
2348 }
2349
2350 void TextureBrowser_destroyWindow()
2351 {
2352     GlobalShaderSystem().setActiveShadersChangedNotify(Callback<void()>());
2353
2354     g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_sizeHandler);
2355     g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_exposeHandler);
2356
2357     g_TextureBrowser.m_gl_widget.unref();
2358 }
2359
2360 const Vector3 &TextureBrowser_getBackgroundColour(TextureBrowser &textureBrowser)
2361 {
2362     return textureBrowser.color_textureback;
2363 }
2364
2365 void TextureBrowser_setBackgroundColour(TextureBrowser &textureBrowser, const Vector3 &colour)
2366 {
2367     textureBrowser.color_textureback = colour;
2368     TextureBrowser_queueDraw(textureBrowser);
2369 }
2370
2371 void TextureBrowser_selectionHelper(ui::TreeModel model, ui::TreePath path, GtkTreeIter *iter, GSList **selected)
2372 {
2373     g_assert(selected != NULL);
2374
2375     gchar *name;
2376     gtk_tree_model_get(model, iter, TAG_COLUMN, &name, -1);
2377     *selected = g_slist_append(*selected, name);
2378 }
2379
2380 void TextureBrowser_shaderInfo()
2381 {
2382     const char *name = TextureBrowser_GetSelectedShader(g_TextureBrowser);
2383     IShader *shader = QERApp_Shader_ForName(name);
2384
2385     DoShaderInfoDlg(name, shader->getShaderFileName(), "Shader Info");
2386
2387     shader->DecRef();
2388 }
2389
2390 void TextureBrowser_addTag()
2391 {
2392     CopiedString tag;
2393
2394     EMessageBoxReturn result = DoShaderTagDlg(&tag, "Add shader tag");
2395
2396     if (result == eIDOK && !tag.empty()) {
2397         GtkTreeIter iter;
2398         g_TextureBrowser.m_all_tags.insert(tag.c_str());
2399         gtk_list_store_append(g_TextureBrowser.m_available_store, &iter);
2400         gtk_list_store_set(g_TextureBrowser.m_available_store, &iter, TAG_COLUMN, tag.c_str(), -1);
2401
2402         // Select the currently added tag in the available list
2403         auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
2404         gtk_tree_selection_select_iter(selection, &iter);
2405
2406         g_TextureBrowser.m_all_tags_list.append(TAG_COLUMN, tag.c_str());
2407     }
2408 }
2409
2410 void TextureBrowser_renameTag()
2411 {
2412     /* WORKAROUND: The tag treeview is set to GTK_SELECTION_MULTIPLE. Because
2413            gtk_tree_selection_get_selected() doesn't work with GTK_SELECTION_MULTIPLE,
2414            we need to count the number of selected rows first and use
2415            gtk_tree_selection_selected_foreach() then to go through the list of selected
2416            rows (which always containins a single row).
2417          */
2418
2419     GSList *selected = NULL;
2420
2421     auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2422     gtk_tree_selection_selected_foreach(selection, GtkTreeSelectionForeachFunc(TextureBrowser_selectionHelper),
2423                                         &selected);
2424
2425     if (g_slist_length(selected) == 1) { // we only rename a single tag
2426         CopiedString newTag;
2427         EMessageBoxReturn result = DoShaderTagDlg(&newTag, "Rename shader tag");
2428
2429         if (result == eIDOK && !newTag.empty()) {
2430             GtkTreeIter iterList;
2431             gchar *rowTag;
2432             gchar *oldTag = (char *) selected->data;
2433
2434             bool row = gtk_tree_model_get_iter_first(g_TextureBrowser.m_all_tags_list, &iterList) != 0;
2435
2436             while (row) {
2437                 gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iterList, TAG_COLUMN, &rowTag, -1);
2438
2439                 if (strcmp(rowTag, oldTag) == 0) {
2440                     gtk_list_store_set(g_TextureBrowser.m_all_tags_list, &iterList, TAG_COLUMN, newTag.c_str(), -1);
2441                 }
2442                 row = gtk_tree_model_iter_next(g_TextureBrowser.m_all_tags_list, &iterList) != 0;
2443             }
2444
2445             TagBuilder.RenameShaderTag(oldTag, newTag.c_str());
2446
2447             g_TextureBrowser.m_all_tags.erase((CopiedString) oldTag);
2448             g_TextureBrowser.m_all_tags.insert(newTag);
2449
2450             BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(),
2451                                    &g_TextureBrowser);
2452             BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2453                                     g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2454         }
2455     } else {
2456         ui::alert(g_TextureBrowser.m_parent, "Select a single tag for renaming.");
2457     }
2458 }
2459
2460 void TextureBrowser_deleteTag()
2461 {
2462     GSList *selected = NULL;
2463
2464     auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2465     gtk_tree_selection_selected_foreach(selection, GtkTreeSelectionForeachFunc(TextureBrowser_selectionHelper),
2466                                         &selected);
2467
2468     if (g_slist_length(selected) == 1) { // we only delete a single tag
2469         auto result = ui::alert(g_TextureBrowser.m_parent, "Are you sure you want to delete the selected tag?",
2470                                 "Delete Tag", ui::alert_type::YESNO, ui::alert_icon::Question);
2471
2472         if (result == ui::alert_response::YES) {
2473             GtkTreeIter iterSelected;
2474             gchar *rowTag;
2475
2476             gchar *tagSelected = (char *) selected->data;
2477
2478             bool row = gtk_tree_model_get_iter_first(g_TextureBrowser.m_all_tags_list, &iterSelected) != 0;
2479
2480             while (row) {
2481                 gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iterSelected, TAG_COLUMN, &rowTag, -1);
2482
2483                 if (strcmp(rowTag, tagSelected) == 0) {
2484                     gtk_list_store_remove(g_TextureBrowser.m_all_tags_list, &iterSelected);
2485                     break;
2486                 }
2487                 row = gtk_tree_model_iter_next(g_TextureBrowser.m_all_tags_list, &iterSelected) != 0;
2488             }
2489
2490             TagBuilder.DeleteTag(tagSelected);
2491             g_TextureBrowser.m_all_tags.erase((CopiedString) tagSelected);
2492
2493             BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(),
2494                                    &g_TextureBrowser);
2495             BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2496                                     g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2497         }
2498     } else {
2499         ui::alert(g_TextureBrowser.m_parent, "Select a single tag for deletion.");
2500     }
2501 }
2502
2503 void TextureBrowser_copyTag()
2504 {
2505     g_TextureBrowser.m_copied_tags.clear();
2506     TagBuilder.GetShaderTags(g_TextureBrowser.shader.c_str(), g_TextureBrowser.m_copied_tags);
2507 }
2508
2509 void TextureBrowser_pasteTag()
2510 {
2511     IShader *ishader = QERApp_Shader_ForName(g_TextureBrowser.shader.c_str());
2512     CopiedString shader = g_TextureBrowser.shader.c_str();
2513
2514     if (!TagBuilder.CheckShaderTag(shader.c_str())) {
2515         CopiedString shaderFile = ishader->getShaderFileName();
2516         if (shaderFile.empty()) {
2517             // it's a texture
2518             TagBuilder.AddShaderNode(shader.c_str(), CUSTOM, TEXTURE);
2519         } else {
2520             // it's a shader
2521             TagBuilder.AddShaderNode(shader.c_str(), CUSTOM, SHADER);
2522         }
2523
2524         for (size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i) {
2525             TagBuilder.AddShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG);
2526         }
2527     } else {
2528         for (size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i) {
2529             if (!TagBuilder.CheckShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str())) {
2530                 // the tag doesn't exist - let's add it
2531                 TagBuilder.AddShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG);
2532             }
2533         }
2534     }
2535
2536     ishader->DecRef();
2537
2538     TagBuilder.SaveXmlDoc();
2539     BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, shader.c_str(), &g_TextureBrowser);
2540     BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2541                             g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2542 }
2543
2544 void TextureBrowser_RefreshShaders()
2545 {
2546     ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Shaders");
2547     GlobalShaderSystem().refresh();
2548     UpdateAllWindows();
2549     auto selection = gtk_tree_view_get_selection(GlobalTextureBrowser().m_treeViewTree);
2550     GtkTreeModel *model = NULL;
2551     GtkTreeIter iter;
2552     if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
2553         gchar dirName[1024];
2554
2555         gchar *buffer;
2556         gtk_tree_model_get(model, &iter, 0, &buffer, -1);
2557         strcpy(dirName, buffer);
2558         g_free(buffer);
2559         if (!TextureBrowser_showWads()) {
2560             strcat(dirName, "/");
2561         }
2562         TextureBrowser_ShowDirectory(GlobalTextureBrowser(), dirName);
2563         TextureBrowser_queueDraw(GlobalTextureBrowser());
2564     }
2565 }
2566
2567 void TextureBrowser_ToggleShowShaders()
2568 {
2569     g_TextureBrowser.m_showShaders ^= 1;
2570     g_TextureBrowser.m_showshaders_item.update();
2571     TextureBrowser_queueDraw(g_TextureBrowser);
2572 }
2573
2574 void TextureBrowser_ToggleShowShaderListOnly()
2575 {
2576     g_TextureBrowser_shaderlistOnly ^= 1;
2577     g_TextureBrowser.m_showshaderlistonly_item.update();
2578
2579     TextureBrowser_constructTreeStore();
2580 }
2581
2582 void TextureBrowser_showAll()
2583 {
2584     g_TextureBrowser_currentDirectory = "";
2585     g_TextureBrowser.m_searchedTags = false;
2586     TextureBrowser_heightChanged(g_TextureBrowser);
2587     TextureBrowser_updateTitle();
2588 }
2589
2590 void TextureBrowser_showUntagged()
2591 {
2592     auto result = ui::alert(g_TextureBrowser.m_parent,
2593                             "WARNING! This function might need a lot of memory and time. Are you sure you want to use it?",
2594                             "Show Untagged", ui::alert_type::YESNO, ui::alert_icon::Warning);
2595
2596     if (result == ui::alert_response::YES) {
2597         g_TextureBrowser.m_found_shaders.clear();
2598         TagBuilder.GetUntagged(g_TextureBrowser.m_found_shaders);
2599         std::set<CopiedString>::iterator iter;
2600
2601         ScopeDisableScreenUpdates disableScreenUpdates("Searching untagged textures...", "Loading Textures");
2602
2603         for (iter = g_TextureBrowser.m_found_shaders.begin(); iter != g_TextureBrowser.m_found_shaders.end(); iter++) {
2604             std::string path = (*iter).c_str();
2605             size_t pos = path.find_last_of("/", path.size());
2606             std::string name = path.substr(pos + 1, path.size());
2607             path = path.substr(0, pos + 1);
2608             TextureDirectory_loadTexture(path.c_str(), name.c_str());
2609             globalErrorStream() << path.c_str() << name.c_str() << "\n";
2610         }
2611
2612         g_TextureBrowser_currentDirectory = "Untagged";
2613         TextureBrowser_queueDraw(GlobalTextureBrowser());
2614         TextureBrowser_heightChanged(g_TextureBrowser);
2615         TextureBrowser_updateTitle();
2616     }
2617 }
2618
2619 void TextureBrowser_FixedSize()
2620 {
2621     g_TextureBrowser_fixedSize ^= 1;
2622     GlobalTextureBrowser().m_fixedsize_item.update();
2623     TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2624 }
2625
2626 void TextureBrowser_FilterMissing()
2627 {
2628     g_TextureBrowser_filterMissing ^= 1;
2629     GlobalTextureBrowser().m_filternotex_item.update();
2630     TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2631     TextureBrowser_RefreshShaders();
2632 }
2633
2634 void TextureBrowser_FilterFallback()
2635 {
2636     g_TextureBrowser_filterFallback ^= 1;
2637     GlobalTextureBrowser().m_hidenotex_item.update();
2638     TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2639     TextureBrowser_RefreshShaders();
2640 }
2641
2642 void TextureBrowser_EnableAlpha()
2643 {
2644     g_TextureBrowser_enableAlpha ^= 1;
2645     GlobalTextureBrowser().m_enablealpha_item.update();
2646     TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2647 }
2648
2649 void TextureBrowser_exportTitle(const Callback<void(const char *)> &importer)
2650 {
2651     StringOutputStream buffer(64);
2652     buffer << "Textures: ";
2653     if (!string_empty(g_TextureBrowser_currentDirectory.c_str())) {
2654         buffer << g_TextureBrowser_currentDirectory.c_str();
2655     } else {
2656         buffer << "all";
2657     }
2658     importer(buffer.c_str());
2659 }
2660
2661 struct TextureScale {
2662     static void Export(const TextureBrowser &self, const Callback<void(int)> &returnz)
2663     {
2664         switch (self.m_textureScale) {
2665             case 10:
2666                 returnz(0);
2667                 break;
2668             case 25:
2669                 returnz(1);
2670                 break;
2671             case 50:
2672                 returnz(2);
2673                 break;
2674             case 100:
2675                 returnz(3);
2676                 break;
2677             case 200:
2678                 returnz(4);
2679                 break;
2680         }
2681     }
2682
2683     static void Import(TextureBrowser &self, int value)
2684     {
2685         switch (value) {
2686             case 0:
2687                 TextureBrowser_setScale(self, 10);
2688                 break;
2689             case 1:
2690                 TextureBrowser_setScale(self, 25);
2691                 break;
2692             case 2:
2693                 TextureBrowser_setScale(self, 50);
2694                 break;
2695             case 3:
2696                 TextureBrowser_setScale(self, 100);
2697                 break;
2698             case 4:
2699                 TextureBrowser_setScale(self, 200);
2700                 break;
2701         }
2702     }
2703 };
2704
2705 struct UniformTextureSize {
2706     static void Export(const TextureBrowser &self, const Callback<void(int)> &returnz)
2707     {
2708         returnz(g_TextureBrowser.m_uniformTextureSize);
2709     }
2710
2711     static void Import(TextureBrowser &self, int value)
2712     {
2713         if (value > 16) {
2714             TextureBrowser_setUniformSize(self, value);
2715         }
2716     }
2717 };
2718
2719 void TextureBrowser_constructPreferences(PreferencesPage &page)
2720 {
2721     page.appendCheckBox(
2722             "", "Texture scrollbar",
2723             make_property<TextureBrowser_ShowScrollbar>(GlobalTextureBrowser())
2724     );
2725     {
2726         const char *texture_scale[] = {"10%", "25%", "50%", "100%", "200%"};
2727         page.appendCombo(
2728                 "Texture Thumbnail Scale",
2729                 STRING_ARRAY_RANGE(texture_scale),
2730                 make_property<TextureScale>(GlobalTextureBrowser())
2731         );
2732     }
2733     page.appendSpinner(
2734             "Texture Thumbnail Size",
2735             GlobalTextureBrowser().m_uniformTextureSize,
2736             GlobalTextureBrowser().m_uniformTextureSize,
2737             16, 8192
2738     );
2739     page.appendEntry("Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement);
2740     {
2741         const char *startup_shaders[] = {"None", TextureBrowser_getComonShadersName()};
2742         page.appendCombo("Load Shaders at Startup", reinterpret_cast<int &>( GlobalTextureBrowser().m_startupShaders ),
2743                          STRING_ARRAY_RANGE(startup_shaders));
2744     }
2745 }
2746
2747 void TextureBrowser_constructPage(PreferenceGroup &group)
2748 {
2749     PreferencesPage page(group.createPage("Texture Browser", "Texture Browser Preferences"));
2750     TextureBrowser_constructPreferences(page);
2751 }
2752
2753 void TextureBrowser_registerPreferencesPage()
2754 {
2755     PreferencesDialog_addSettingsPage(makeCallbackF(TextureBrowser_constructPage));
2756 }
2757
2758
2759 #include "preferencesystem.h"
2760 #include "stringio.h"
2761
2762
2763 void TextureClipboard_textureSelected(const char *shader);
2764
2765 void TextureBrowser_Construct()
2766 {
2767     GlobalCommands_insert("ShaderInfo", makeCallbackF(TextureBrowser_shaderInfo));
2768     GlobalCommands_insert("ShowUntagged", makeCallbackF(TextureBrowser_showUntagged));
2769     GlobalCommands_insert("AddTag", makeCallbackF(TextureBrowser_addTag));
2770     GlobalCommands_insert("RenameTag", makeCallbackF(TextureBrowser_renameTag));
2771     GlobalCommands_insert("DeleteTag", makeCallbackF(TextureBrowser_deleteTag));
2772     GlobalCommands_insert("CopyTag", makeCallbackF(TextureBrowser_copyTag));
2773     GlobalCommands_insert("PasteTag", makeCallbackF(TextureBrowser_pasteTag));
2774     GlobalCommands_insert("RefreshShaders", makeCallbackF(VFS_Refresh));
2775     GlobalToggles_insert("ShowInUse", makeCallbackF(TextureBrowser_ToggleHideUnused),
2776                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_hideunused_item), Accelerator('U'));
2777     GlobalCommands_insert("ShowAllTextures", makeCallbackF(TextureBrowser_showAll),
2778                           Accelerator('A', (GdkModifierType) GDK_CONTROL_MASK));
2779     GlobalCommands_insert("ToggleTextures", makeCallbackF(TextureBrowser_toggleShow), Accelerator('T'));
2780     GlobalToggles_insert("ToggleShowShaders", makeCallbackF(TextureBrowser_ToggleShowShaders),
2781                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_showshaders_item));
2782     GlobalToggles_insert("ToggleShowShaderlistOnly", makeCallbackF(TextureBrowser_ToggleShowShaderListOnly),
2783                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_showshaderlistonly_item));
2784     GlobalToggles_insert("FixedSize", makeCallbackF(TextureBrowser_FixedSize),
2785                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_fixedsize_item));
2786     GlobalToggles_insert("FilterMissing", makeCallbackF(TextureBrowser_FilterMissing),
2787                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_filternotex_item));
2788     GlobalToggles_insert("FilterFallback", makeCallbackF(TextureBrowser_FilterFallback),
2789                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_hidenotex_item));
2790     GlobalToggles_insert("EnableAlpha", makeCallbackF(TextureBrowser_EnableAlpha),
2791                          ToggleItem::AddCallbackCaller(g_TextureBrowser.m_enablealpha_item));
2792
2793     GlobalPreferenceSystem().registerPreference("TextureScale", make_property_string<TextureScale>(g_TextureBrowser));
2794     GlobalPreferenceSystem().registerPreference("UniformTextureSize",
2795                                                 make_property_string<UniformTextureSize>(g_TextureBrowser));
2796     GlobalPreferenceSystem().registerPreference("TextureScrollbar", make_property_string<TextureBrowser_ShowScrollbar>(
2797             GlobalTextureBrowser()));
2798     GlobalPreferenceSystem().registerPreference("ShowShaders",
2799                                                 make_property_string(GlobalTextureBrowser().m_showShaders));
2800     GlobalPreferenceSystem().registerPreference("ShowShaderlistOnly",
2801                                                 make_property_string(g_TextureBrowser_shaderlistOnly));
2802     GlobalPreferenceSystem().registerPreference("FixedSize", make_property_string(g_TextureBrowser_fixedSize));
2803     GlobalPreferenceSystem().registerPreference("FilterMissing", make_property_string(g_TextureBrowser_filterMissing));
2804     GlobalPreferenceSystem().registerPreference("EnableAlpha", make_property_string(g_TextureBrowser_enableAlpha));
2805     GlobalPreferenceSystem().registerPreference("LoadShaders", make_property_string(
2806             reinterpret_cast<int &>( GlobalTextureBrowser().m_startupShaders )));
2807     GlobalPreferenceSystem().registerPreference("WheelMouseInc", make_property_string(
2808             GlobalTextureBrowser().m_mouseWheelScrollIncrement));
2809     GlobalPreferenceSystem().registerPreference("SI_Colors0",
2810                                                 make_property_string(GlobalTextureBrowser().color_textureback));
2811
2812     g_TextureBrowser.shader = texdef_name_default();
2813
2814     Textures_setModeChangedNotify(ReferenceCaller<TextureBrowser, void(), TextureBrowser_queueDraw>(g_TextureBrowser));
2815
2816     TextureBrowser_registerPreferencesPage();
2817
2818     GlobalShaderSystem().attach(g_ShadersObserver);
2819
2820     TextureBrowser_textureSelected = TextureClipboard_textureSelected;
2821 }
2822
2823 void TextureBrowser_Destroy()
2824 {
2825     GlobalShaderSystem().detach(g_ShadersObserver);
2826
2827     Textures_setModeChangedNotify(Callback<void()>());
2828 }