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