radiant/texwindow.cpp

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