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