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 "iimage.h"
  34 #include "ifilesystem.h"
  35 #include "ishaders.h"
  36 #include "iscriplib.h"
  37 #include "iselection.h"
  38 #include "iscenegraph.h"
  39 #include "itextures.h"
  40 #include "irender.h"
  41 #include "iundo.h"
  42 #include "igl.h"
  43 #include "iarchive.h"
  44 #include "moduleobserver.h"
  45
  46 #include <set>
  47
  48 #include <gtk/gtkmenuitem.h>
  49 #include <gtk/gtkrange.h>
  50 #include <gtk/gtkframe.h>
  51 #include <gtk/gtkhbox.h>
  52 #include <gtk/gtkvbox.h>
  53 #include <gtk/gtkvscrollbar.h>
  54 #include <gtk/gtkmenu.h>
  55
  56 #include "signal/signal.h"
  57 #include "math/vector.h"
  58 #include "texturelib.h"
  59 #include "string/string.h"
  60 #include "shaderlib.h"
  61 #include "os/path.h"
  62 #include "stream/memstream.h"
  63 #include "stream/textfilestream.h"
  64 #include "stream/stringstream.h"
  65 #include "cmdlib.h"
  66 #include "texmanip.h"
  67 #include "textures.h"
  68 #include "convert.h"
  69
  70 #include "gtkutil/menu.h"
  71 #include "gtkutil/nonmodal.h"
  72 #include "gtkutil/cursor.h"
  73 #include "gtkutil/widget.h"
  74 #include "gtkutil/glwidget.h"
  75
  76 #include "error.h"
  77 #include "map.h"
  78 #include "qgl.h"
  79 #include "select.h"
  80 #include "brush_primit.h"
  81 #include "brushmanip.h"
  82 #include "patchmanip.h"
  83 #include "plugin.h"
  84 #include "qe3.h"
  85 #include "gtkdlgs.h"
  86 #include "gtkmisc.h"
  87 #include "mainframe.h"
  88 #include "findtexturedialog.h"
  89 #include "surfacedialog.h"
  90 #include "patchdialog.h"
  91 #include "groupdialog.h"
  92 #include "preferences.h"
  93 #include "shaders.h"
  94 #include "commands.h"
  95
  96
  97
  98 bool TextureGroupsMenu_showWads()
  99 {
 100   return !string_empty(g_pGameDescription->getKeyValue("show_wads"));
 101 }
 102
 103 // globals for textures
 104 class TextureMenuName
 105 {
 106   enum { c_menuNameLength = 64 };
 107   char m_name[c_menuNameLength];
 108 public:
 109   TextureMenuName(const char* name)
 110   {
 111     strncpy(m_name, name, c_menuNameLength - 1);
 112     m_name[c_menuNameLength - 1] = '\0';
 113   }
 114   const char* c_str() const
 115   {
 116     return m_name;
 117   }
 118 };
 119
 120 typedef std::vector<TextureMenuName> TextureMenuNames;
 121 TextureMenuNames texture_menunames;
 122
 123 const char* TextureGroupsMenu_GetName(std::size_t menunum)
 124 {
 125   return texture_menunames[menunum].c_str();
 126 }
 127
 128 void TextureGroupsMenu_ListItems(GSList*& items)
 129 {
 130   for(TextureMenuNames::const_iterator i = texture_menunames.begin(); i != texture_menunames.end(); ++i)
 131   {
 132     items = g_slist_append(items, const_cast<char*>((*i).c_str()));
 133   }
 134 }
 135
 136 void TextureBrowser_queueDraw(TextureBrowser& textureBrower);
 137
 138 class TextureGroupLoader
 139 {
 140   std::size_t m_id;
 141 public:
 142   TextureGroupLoader(std::size_t id)
 143     : m_id(id)
 144   {
 145   }
 146   void loadGroup()
 147   {
 148     ScopeDisableScreenUpdates disableScreenUpdates(TextureGroupsMenu_GetName(m_id), "Loading Textures");
 149
 150     TextureBrowser_ShowDirectory(GlobalTextureBrowser(), TextureGroupsMenu_GetName(m_id));
 151     TextureBrowser_queueDraw(GlobalTextureBrowser());
 152   }
 153 };
 154
 155 std::list<TextureGroupLoader> g_texture_group_loaders;
 156
 157 void texturegroup_activated(GtkWidget* widget, gpointer data)
 158 {
 159   reinterpret_cast<TextureGroupLoader*>(data)->loadGroup();
 160 }
 161
 162 bool string_equal_start(const char* string, StringRange start)
 163 {
 164   return string_equal_n(string, start.first, start.last - start.first);
 165 }
 166
 167 GtkMenuItem* MenuItem_create(const char* name)
 168 {
 169   StringOutputStream buffer(64);
 170   buffer << ConvertLocaleToUTF8(name);
 171   return GTK_MENU_ITEM(gtk_menu_item_new_with_label(buffer.c_str()));
 172 }
 173
 174 GtkMenuItem* Menu_addItem(GtkMenu* menu, const char* name)
 175 {
 176   GtkMenuItem* item = MenuItem_create(name);
 177   gtk_widget_show(GTK_WIDGET(item));
 178   menu_add_item(menu, item);
 179   return item;
 180 }
 181
 182 void TextureGroupsMenu_addItem(GtkMenu* menu, const char* dirName)
 183 {
 184   GtkMenuItem* item = Menu_addItem(menu, dirName);
 185
 186   g_texture_group_loaders.push_back(TextureGroupLoader(texture_menunames.size()));
 187         g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(texturegroup_activated), &g_texture_group_loaders.back());
 188
 189   if(TextureGroupsMenu_showWads())
 190   {
 191     texture_menunames.push_back(dirName);
 192   }
 193   else
 194   {
 195     char buffer[1024];
 196     strcpy(buffer, dirName);
 197     strcat(buffer, "/");
 198     texture_menunames.push_back(buffer);
 199   }
 200 }
 201
 202 typedef std::set<CopiedString> TextureGroups;
 203
 204 void TextureGroupsMenu_Construct(GtkMenu* menu, const TextureGroups& groups)
 205 {
 206   texture_menunames.clear();
 207
 208   TextureGroups::const_iterator i = groups.begin();
 209   while(i != groups.end())
 210   {
 211     const char* dirName = (*i).c_str();
 212     const char* firstUnderscore = strchr(dirName, '_');
 213     StringRange dirRoot(dirName, (firstUnderscore == 0) ? dirName : firstUnderscore + 1);
 214
 215     // do we shrink the menus?
 216     // we shrink only if we have at least two things to shrink :-)
 217     TextureGroups::const_iterator next = i;
 218     ++next;
 219     if(firstUnderscore != 0
 220       && next != groups.end()
 221       && string_equal_start((*next).c_str(), dirRoot))
 222     {
 223             GtkMenuItem* item = Menu_addItem(menu, CopiedString(StringRange(dirName, firstUnderscore)).c_str());
 224
 225             GtkMenu *pSubMenu = GTK_MENU(gtk_menu_new());
 226       gtk_menu_item_set_submenu(item, GTK_WIDGET(pSubMenu));
 227
 228             // keep going...
 229             while(i != groups.end() && string_equal_start((*i).c_str(), dirRoot))
 230             {
 231               TextureGroupsMenu_addItem(pSubMenu, (*i).c_str());
 232
 233               ++i;
 234             }
 235     }
 236     else
 237     {
 238       TextureGroupsMenu_addItem(menu, dirName);
 239
 240       ++i;
 241     }
 242   }
 243 }
 244
 245
 246 void TextureGroups_addWad(TextureGroups& groups, const char* archive)
 247 {
 248   if(extension_equal(path_get_extension(archive), "wad"))
 249   {
 250 #if 1
 251     groups.insert(archive);
 252 #else
 253     CopiedString archiveBaseName(path_get_filename_start(archive), path_get_filename_base_end(archive));
 254     groups.insert(archiveBaseName);
 255 #endif
 256   }
 257 }
 258 typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addWad> TextureGroupsAddWadCaller;
 259
 260 void TextureGroups_addShader(TextureGroups& groups, const char* shaderName)
 261 {
 262   const char* texture = path_make_relative(shaderName, "textures/");
 263   if(texture != shaderName)
 264   {
 265     const char* last = path_remove_directory(texture);
 266     if(!string_empty(last))
 267     {
 268       groups.insert(CopiedString(StringRange(texture, --last)));
 269     }
 270   }
 271 }
 272 typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addShader> TextureGroupsAddShaderCaller;
 273
 274 void TextureGroups_addDirectory(TextureGroups& groups, const char* directory)
 275 {
 276   groups.insert(directory);
 277 }
 278 typedef ReferenceCaller1<TextureGroups, const char*, TextureGroups_addDirectory> TextureGroupsAddDirectoryCaller;
 279
 280 GtkMenu* g_textures_menu = 0;
 281 GtkMenuItem* g_textures_menu_separator = 0;
 282 namespace
 283 {
 284   bool g_TexturesMenu_shaderlistOnly = false;
 285 }
 286 void TextureGroupsMenu_Construct()
 287 {
 288   TextureGroups groups;
 289
 290   if(TextureGroupsMenu_showWads())
 291   {
 292     GlobalFileSystem().forEachArchive(TextureGroupsAddWadCaller(groups));
 293   }
 294   else
 295   {
 296     // scan texture dirs and pak files only if not restricting to shaderlist
 297     if(g_pGameDescription->mGameType != "doom3" && !g_TexturesMenu_shaderlistOnly)
 298     {
 299       GlobalFileSystem().forEachDirectory("textures/", TextureGroupsAddDirectoryCaller(groups));
 300     }
 301
 302     GlobalShaderSystem().foreachShaderName(TextureGroupsAddShaderCaller(groups));
 303   }
 304
 305   TextureGroupsMenu_Construct(g_textures_menu, groups);
 306 }
 307
 308 void TextureGroupsMenu_Destroy()
 309 {
 310   // delete everything
 311   GtkMenu* menu = g_textures_menu;
 312   GtkMenuItem* sep = g_textures_menu_separator;
 313   GList* lst = g_list_find(gtk_container_children(GTK_CONTAINER(menu)), GTK_WIDGET(sep));
 314   while(lst->next)
 315   {
 316     // these delete functions are recursive, it's gonna free all submenus
 317     gtk_widget_destroy(GTK_WIDGET (lst->next->data));
 318     // lst is no longer relevant, need to get it again
 319     lst = g_list_find(gtk_container_children(GTK_CONTAINER(menu)), GTK_WIDGET(sep));
 320   }
 321 }
 322
 323
 324 class TextureGroupsMenu : public ModuleObserver
 325 {
 326   std::size_t m_unrealised;
 327 public:
 328   TextureGroupsMenu() : m_unrealised(2)
 329   {
 330   }
 331   void realise()
 332   {
 333     if(--m_unrealised == 0)
 334     {
 335       if(g_textures_menu != 0)
 336       {
 337         TextureGroupsMenu_Construct();
 338       }
 339     }
 340   }
 341   void unrealise()
 342   {
 343     if(++m_unrealised == 1)
 344     {
 345       if(g_textures_menu != 0)
 346       {
 347         TextureGroupsMenu_Destroy();
 348       }
 349     }
 350   }
 351 };
 352
 353 TextureGroupsMenu g_TextureGroupsMenu;
 354
 355 class DeferredAdjustment
 356 {
 357   gdouble m_value;
 358   guint m_handler;
 359   typedef void (*ValueChangedFunction)(void* data, gdouble value);
 360   ValueChangedFunction m_function;
 361   void* m_data;
 362
 363   static gboolean deferred_value_changed(gpointer data)
 364   {
 365     reinterpret_cast<DeferredAdjustment*>(data)->m_function(
 366       reinterpret_cast<DeferredAdjustment*>(data)->m_data,
 367       reinterpret_cast<DeferredAdjustment*>(data)->m_value
 368     );
 369     reinterpret_cast<DeferredAdjustment*>(data)->m_handler = 0;
 370     reinterpret_cast<DeferredAdjustment*>(data)->m_value = 0;
 371     return FALSE;
 372   }
 373 public:
 374   DeferredAdjustment(ValueChangedFunction function, void* data) : m_value(0), m_handler(0), m_function(function), m_data(data)
 375   {
 376   }
 377   void flush()
 378   {
 379     if(m_handler != 0)
 380     {
 381       g_source_remove(m_handler);
 382       deferred_value_changed(this);
 383     }
 384   }
 385   void value_changed(gdouble value)
 386   {
 387     m_value = value;
 388     if(m_handler == 0)
 389     {
 390       m_handler = g_idle_add(deferred_value_changed, this);
 391     }
 392   }
 393   static void adjustment_value_changed(GtkAdjustment *adjustment, DeferredAdjustment* self)
 394   {
 395     self->value_changed(adjustment->value);
 396   }
 397 };
 398
 399
 400
 401 class TextureBrowser;
 402
 403 typedef ReferenceCaller<TextureBrowser, TextureBrowser_queueDraw> TextureBrowserQueueDrawCaller;
 404
 405 void TextureBrowser_scrollChanged(void* data, gdouble value);
 406
 407
 408 enum StartupShaders
 409 {
 410   STARTUPSHADERS_NONE = 0,
 411   STARTUPSHADERS_COMMON,
 412   STARTUPSHADERS_ALL,
 413 };
 414
 415 class TextureBrowser
 416 {
 417 public:
 418         int width, height;
 419         int originy;
 420         int m_nTotalHeight;
 421
 422   CopiedString shader;
 423
 424   GtkEntry* m_filter;
 425   NonModalEntry m_filterEntry;
 426
 427   GtkWindow* m_parent;
 428   GtkWidget* m_gl_widget;
 429
 430   guint m_sizeHandler;
 431   guint m_exposeHandler;
 432
 433   GtkWidget* m_texture_scroll;
 434
 435   bool m_heightChanged;
 436   bool m_originInvalid;
 437
 438   DeferredAdjustment m_scrollAdjustment;
 439   FreezePointer m_freezePointer;
 440
 441   Vector3 color_textureback;
 442   // the increment step we use against the wheel mouse
 443   std::size_t m_mouseWheelScrollIncrement;
 444   std::size_t m_textureScale;
 445   bool m_showTextureFilter;
 446   // make the texture increments match the grid changes
 447   bool m_showShaders;
 448   bool m_showTextureScrollbar;
 449   StartupShaders m_startupShaders;
 450   // if true, the texture window will only display in-use shaders
 451   // if false, all the shaders in memory are displayed
 452   bool m_hideUnused;
 453
 454
 455   void clearFilter()
 456   {
 457     gtk_entry_set_text(m_filter, "");
 458     TextureBrowser_queueDraw(*this);
 459   }
 460   typedef MemberCaller<TextureBrowser, &TextureBrowser::clearFilter> ClearFilterCaller;
 461
 462   TextureBrowser() :
 463     m_filter(0),
 464     m_filterEntry(TextureBrowserQueueDrawCaller(*this), ClearFilterCaller(*this)),
 465     m_texture_scroll(0),
 466     m_heightChanged(true),
 467     m_originInvalid(true),
 468     m_scrollAdjustment(TextureBrowser_scrollChanged, this),
 469     color_textureback(0.25f, 0.25f, 0.25f),
 470     m_mouseWheelScrollIncrement(64),
 471     m_textureScale(50),
 472     m_showTextureFilter(false),
 473     m_showShaders(true),
 474     m_showTextureScrollbar(true),
 475     m_startupShaders(STARTUPSHADERS_NONE),
 476     m_hideUnused(false)
 477   {
 478   }
 479 };
 480
 481 void(*TextureBrowser_textureSelected)(const char* shader);
 482
 483
 484 void TextureBrowser_updateScroll(TextureBrowser& textureBrowser);
 485
 486
 487 const char* TextureBrowser_getComonShadersName()
 488 {
 489   const char* value = g_pGameDescription->getKeyValue("common_shaders_name");
 490   if(!string_empty(value))
 491   {
 492     return value;
 493   }
 494   return "Common";
 495 }
 496
 497 const char* TextureBrowser_getComonShadersDir()
 498 {
 499   const char* value = g_pGameDescription->getKeyValue("common_shaders_dir");
 500   if(!string_empty(value))
 501   {
 502     return value;
 503   }
 504   return "common/";
 505 }
 506
 507
 508 void TextureBrowser_setShowFilter(TextureBrowser& textureBrowser, bool show)
 509 {
 510   widget_set_visible(GTK_WIDGET(textureBrowser.m_filter), show);
 511 }
 512
 513 const char* TextureBrowser_getFilter(TextureBrowser& textureBrowser)
 514 {
 515   if(textureBrowser.m_showTextureFilter)
 516   {
 517     return gtk_entry_get_text(textureBrowser.m_filter);
 518   }
 519   return 0;
 520 }
 521
 522 inline int TextureBrowser_fontHeight(TextureBrowser& textureBrowser)
 523 {
 524   return GlobalOpenGL().m_fontHeight;
 525 }
 526
 527 const char* TextureBrowser_GetSelectedShader(TextureBrowser& textureBrowser)
 528 {
 529   return textureBrowser.shader.c_str();
 530 }
 531
 532 void TextureBrowser_SetStatus(TextureBrowser& textureBrowser, const char* name)
 533 {
 534   IShader* shader = QERApp_Shader_ForName( name);
 535   qtexture_t* q = shader->getTexture();
 536   StringOutputStream strTex(256);
 537   strTex << name << " W: " << Unsigned(q->width) << " H: " << Unsigned(q->height);
 538   shader->DecRef();
 539   g_pParentWnd->SetStatusText(g_pParentWnd->m_texture_status, strTex.c_str());
 540 }
 541
 542 void TextureBrowser_Focus(TextureBrowser& textureBrowser, const char* name);
 543
 544 void TextureBrowser_SetSelectedShader(TextureBrowser& textureBrowser, const char* shader)
 545 {
 546   textureBrowser.shader = shader;
 547   TextureBrowser_SetStatus(textureBrowser, shader);
 548   TextureBrowser_Focus(textureBrowser, shader);
 549
 550   if(FindTextureDialog_isOpen())
 551   {
 552     FindTextureDialog_selectTexture(shader);
 553   }
 554 }
 555
 556
 557 CopiedString g_TextureBrowser_currentDirectory;
 558
 559 /*
 560 ============================================================================
 561
 562 TEXTURE LAYOUT
 563
 564 TTimo: now based on a rundown through all the shaders
 565 NOTE: we expect the Active shaders count doesn't change during a Texture_StartPos .. Texture_NextPos cycle
 566   otherwise we may need to rely on a list instead of an array storage
 567 ============================================================================
 568 */
 569
 570 class TextureLayout
 571 {
 572 public:
 573   // texture layout functions
 574   // TTimo: now based on shaders
 575   int current_x, current_y, current_row;
 576 };
 577
 578 void Texture_StartPos(TextureLayout& layout)
 579 {
 580   layout.current_x = 8;
 581   layout.current_y = -8;
 582   layout.current_row = 0;
 583 }
 584
 585 void Texture_NextPos(TextureBrowser& textureBrowser, TextureLayout& layout, qtexture_t* current_texture, int *x, int *y)
 586 {
 587   qtexture_t* q = current_texture;
 588
 589   int nWidth = (int)(q->width * ((float)textureBrowser.m_textureScale / 100));
 590   int nHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100));
 591   if (layout.current_x + nWidth > textureBrowser.width-8 && layout.current_row)
 592   { // go to the next row unless the texture is the first on the row
 593     layout.current_x = 8;
 594     layout.current_y -= layout.current_row + TextureBrowser_fontHeight(textureBrowser) + 4;
 595     layout.current_row = 0;
 596   }
 597
 598   *x = layout.current_x;
 599   *y = layout.current_y;
 600
 601   // Is our texture larger than the row? If so, grow the
 602   // row height to match it
 603
 604   if (layout.current_row < nHeight)
 605     layout.current_row = nHeight;
 606
 607   // never go less than 64, or the names get all crunched up
 608   layout.current_x += nWidth < 64 ? 64 : nWidth;
 609   layout.current_x += 8;
 610 }
 611
 612 // if texture_showinuse jump over non in-use textures
 613 bool Texture_IsShown(IShader* shader, bool show_shaders, bool hideUnused, const char* filter)
 614 {
 615   if(!shader_equal_prefix(shader->getName(), "textures/"))
 616     return false;
 617
 618   if (!show_shaders && !shader->IsDefault())
 619     return false;
 620
 621   if(hideUnused && !shader->IsInUse())
 622     return false;
 623
 624   if(!string_empty(g_TextureBrowser_currentDirectory.c_str()))
 625   {
 626     if(!shader_equal_prefix(shader_get_textureName(shader->getName()), g_TextureBrowser_currentDirectory.c_str()))
 627     {
 628       return false;
 629     }
 630   }
 631
 632   if (filter != 0)
 633   {
 634     // some basic filtering
 635     if (strstr( shader_get_textureName(shader->getName()), filter ) == 0)
 636       return false;
 637   }
 638
 639   return true;
 640 }
 641
 642 void TextureBrowser_heightChanged(TextureBrowser& textureBrowser)
 643 {
 644   textureBrowser.m_heightChanged = true;
 645
 646   TextureBrowser_updateScroll(textureBrowser);
 647   TextureBrowser_queueDraw(textureBrowser);
 648 }
 649
 650 void TextureBrowser_evaluateHeight(TextureBrowser& textureBrowser)
 651 {
 652   if(textureBrowser.m_heightChanged)
 653   {
 654     textureBrowser.m_heightChanged = false;
 655
 656     textureBrowser.m_nTotalHeight = 0;
 657
 658     TextureLayout layout;
 659     Texture_StartPos(layout);
 660     for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
 661     {
 662       IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
 663
 664       if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
 665         continue;
 666
 667       int   x, y;
 668       Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
 669       textureBrowser.m_nTotalHeight = std::max(textureBrowser.m_nTotalHeight, abs(layout.current_y) + TextureBrowser_fontHeight(textureBrowser) + (int)(shader->getTexture()->height * ((float)textureBrowser.m_textureScale / 100)) + 4);
 670     }
 671   }
 672 }
 673
 674 int TextureBrowser_TotalHeight(TextureBrowser& textureBrowser)
 675 {
 676   TextureBrowser_evaluateHeight(textureBrowser);
 677   return textureBrowser.m_nTotalHeight;
 678 }
 679
 680 inline const int& min_int(const int& left, const int& right)
 681 {
 682   return std::min(left, right);
 683 }
 684
 685 void TextureBrowser_clampOriginY(TextureBrowser& textureBrowser)
 686 {
 687   if(textureBrowser.originy > 0)
 688   {
 689     textureBrowser.originy = 0;
 690   }
 691   int lower = min_int(textureBrowser.height - TextureBrowser_TotalHeight(textureBrowser), 0);
 692   if(textureBrowser.originy < lower)
 693   {
 694     textureBrowser.originy = lower;
 695   }
 696 }
 697
 698 int TextureBrowser_getOriginY(TextureBrowser& textureBrowser)
 699 {
 700   if(textureBrowser.m_originInvalid)
 701   {
 702     textureBrowser.m_originInvalid = false;
 703     TextureBrowser_clampOriginY(textureBrowser);
 704     TextureBrowser_updateScroll(textureBrowser);
 705   }
 706   return textureBrowser.originy;
 707 }
 708
 709 void TextureBrowser_setOriginY(TextureBrowser& textureBrowser, int originy)
 710 {
 711   textureBrowser.originy = originy;
 712   TextureBrowser_clampOriginY(textureBrowser);
 713   TextureBrowser_updateScroll(textureBrowser);
 714   TextureBrowser_queueDraw(textureBrowser);
 715 }
 716
 717
 718 Signal0 g_activeShadersChangedCallbacks;
 719
 720 void TextureBrowser_addActiveShadersChangedCallback(const SignalHandler& handler)
 721 {
 722   g_activeShadersChangedCallbacks.connectLast(handler);
 723 }
 724
 725 class ShadersObserver : public ModuleObserver
 726 {
 727   Signal0 m_realiseCallbacks;
 728 public:
 729   void realise()
 730   {
 731     m_realiseCallbacks();
 732   }
 733   void unrealise()
 734   {
 735   }
 736   void insert(const SignalHandler& handler)
 737   {
 738     m_realiseCallbacks.connectLast(handler);
 739   }
 740 };
 741
 742 namespace
 743 {
 744   ShadersObserver g_ShadersObserver;
 745 }
 746
 747 void TextureBrowser_addShadersRealiseCallback(const SignalHandler& handler)
 748 {
 749   g_ShadersObserver.insert(handler);
 750 }
 751
 752 void TextureBrowser_activeShadersChanged(TextureBrowser& textureBrowser)
 753 {
 754   TextureBrowser_heightChanged(textureBrowser);
 755   textureBrowser.m_originInvalid = true;
 756
 757   g_activeShadersChangedCallbacks();
 758 }
 759
 760 void TextureBrowser_importShowScrollbar(TextureBrowser& textureBrowser, bool value)
 761 {
 762   textureBrowser.m_showTextureScrollbar = value;
 763   if(textureBrowser.m_texture_scroll != 0)
 764   {
 765     widget_set_visible(textureBrowser.m_texture_scroll, textureBrowser.m_showTextureScrollbar);
 766     TextureBrowser_updateScroll(textureBrowser);
 767   }
 768 }
 769 typedef ReferenceCaller1<TextureBrowser, bool, TextureBrowser_importShowScrollbar> TextureBrowserImportShowScrollbarCaller;
 770
 771 void TextureBrowser_importShowFilter(TextureBrowser& textureBrowser, bool value)
 772 {
 773   textureBrowser.m_showTextureFilter = value;
 774   if(textureBrowser.m_filter != 0)
 775   {
 776     TextureBrowser_setShowFilter(textureBrowser, textureBrowser.m_showTextureFilter);
 777   }
 778 }
 779 typedef ReferenceCaller1<TextureBrowser, bool, TextureBrowser_importShowFilter> TextureBrowserImportShowFilterCaller;
 780
 781 /*
 782 ==============
 783 TextureBrowser_ShowDirectory
 784 relies on texture_directory global for the directory to use
 785 1) Load the shaders for the given directory
 786 2) Scan the remaining texture, load them and assign them a default shader (the "noshader" shader)
 787 NOTE: when writing a texture plugin, or some texture extensions, this function may need to be overriden, and made
 788   available through the IShaders interface
 789 NOTE: for texture window layout:
 790   all shaders are stored with alphabetical order after load
 791   previously loaded and displayed stuff is hidden, only in-use and newly loaded is shown
 792   ( the GL textures are not flushed though)
 793 ==============
 794 */
 795 bool texture_name_ignore(const char* name)
 796 {
 797   StringOutputStream strTemp(string_length(name));
 798   strTemp << LowerCase(name);
 799
 800   return strstr(strTemp.c_str(), ".specular") != 0 ||
 801     strstr(strTemp.c_str(), ".glow") != 0 ||
 802     strstr(strTemp.c_str(), ".bump") != 0 ||
 803     strstr(strTemp.c_str(), ".diffuse") != 0 ||
 804     strstr(strTemp.c_str(), ".blend") != 0 ||
 805           strstr(strTemp.c_str(), ".alpha") != 0;
 806 }
 807
 808 class LoadShaderVisitor : public Archive::Visitor
 809 {
 810 public:
 811   void visit(const char* name)
 812   {
 813     IShader* shader = QERApp_Shader_ForName(CopiedString(StringRange(name, path_get_filename_base_end(name))).c_str());
 814     shader->DecRef();
 815   }
 816 };
 817
 818 void TextureBrowser_SetHideUnused(TextureBrowser& textureBrowser, bool hideUnused);
 819
 820 GtkWidget* g_page_textures;
 821
 822 void TextureBrowser_toggleShown()
 823 {
 824   GroupDialog_showPage(g_page_textures);
 825 }
 826
 827
 828 void TextureBrowser_updateTitle()
 829 {
 830   GroupDialog_updatePageTitle(g_page_textures);
 831 }
 832
 833
 834
 835 class TextureCategoryLoadShader
 836 {
 837   const char* m_directory;
 838   std::size_t& m_count;
 839 public:
 840   typedef const char* first_argument_type;
 841
 842   TextureCategoryLoadShader(const char* directory, std::size_t& count)
 843     : m_directory(directory), m_count(count)
 844   {
 845     m_count = 0;
 846   }
 847   void operator()(const char* name) const
 848   {
 849     if(shader_equal_prefix(name, "textures/")
 850       && shader_equal_prefix(name + string_length("textures/"), m_directory))
 851     {
 852       ++m_count;
 853       // request the shader, this will load the texture if needed
 854       // this Shader_ForName call is a kind of hack
 855       IShader *pFoo = QERApp_Shader_ForName(name);
 856       pFoo->DecRef();
 857     }
 858   }
 859 };
 860
 861 void TextureDirectory_loadTexture(const char* directory, const char* texture)
 862 {
 863   StringOutputStream name(256);
 864   name << directory << StringRange(texture, path_get_filename_base_end(texture));
 865
 866   if(texture_name_ignore(name.c_str()))
 867   {
 868     return;
 869   }
 870
 871   if (!texdef_name_valid(name.c_str()))
 872   {
 873     globalOutputStream() << "Skipping invalid texture name: [" << name.c_str() << "]\n";
 874     return;
 875   }
 876
 877   // if a texture is already in use to represent a shader, ignore it
 878   IShader* shader = QERApp_Shader_ForName(name.c_str());
 879   shader->DecRef();
 880 }
 881 typedef ConstPointerCaller1<char, const char*, TextureDirectory_loadTexture> TextureDirectoryLoadTextureCaller;
 882
 883 class LoadTexturesByTypeVisitor : public ImageModules::Visitor
 884 {
 885   const char* m_dirstring;
 886 public:
 887   LoadTexturesByTypeVisitor(const char* dirstring)
 888     : m_dirstring(dirstring)
 889   {
 890   }
 891   void visit(const char* minor, const _QERPlugImageTable& table)
 892   {
 893     GlobalFileSystem().forEachFile(m_dirstring, minor, TextureDirectoryLoadTextureCaller(m_dirstring));
 894   }
 895 };
 896
 897 void TextureBrowser_ShowDirectory(TextureBrowser& textureBrowser, const char* directory)
 898 {
 899   if(TextureGroupsMenu_showWads())
 900   {
 901     Archive* archive = GlobalFileSystem().getArchive(directory);
 902     ASSERT_NOTNULL(archive);
 903     LoadShaderVisitor visitor;
 904     archive->forEachFile(Archive::VisitorFunc(visitor, Archive::eFiles, 0), "textures/");
 905   }
 906   else
 907   {
 908     g_TextureBrowser_currentDirectory = directory;
 909     TextureBrowser_heightChanged(textureBrowser);
 910
 911     std::size_t shaders_count;
 912     GlobalShaderSystem().foreachShaderName(makeCallback1(TextureCategoryLoadShader(directory, shaders_count)));
 913     globalOutputStream() << "Showing " << Unsigned(shaders_count) << " shaders.\n";
 914
 915     if(g_pGameDescription->mGameType != "doom3")
 916     {
 917       // load remaining texture files
 918
 919       StringOutputStream dirstring(64);
 920       dirstring << "textures/" << directory;
 921
 922       {
 923         LoadTexturesByTypeVisitor visitor(dirstring.c_str());
 924         Radiant_getImageModules().foreachModule(visitor);
 925       }
 926     }
 927   }
 928
 929   // we'll display the newly loaded textures + all the ones already in use
 930   TextureBrowser_SetHideUnused(textureBrowser, false);
 931
 932   TextureBrowser_updateTitle();
 933 }
 934
 935
 936 bool TextureBrowser_hideUnused();
 937
 938 void TextureBrowser_hideUnusedExport(const BoolImportCallback& importer)
 939 {
 940   importer(TextureBrowser_hideUnused());
 941 }
 942 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
 943
 944 void TextureBrowser_showShadersExport(const BoolImportCallback& importer)
 945 {
 946   importer(GlobalTextureBrowser().m_showShaders);
 947 }
 948 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
 949
 950 void TextureBrowser_showShaderlistOnly(const BoolImportCallback& importer)
 951 {
 952   importer(g_TexturesMenu_shaderlistOnly);
 953 }
 954 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
 955
 956 class TexturesMenu
 957 {
 958 public:
 959   ToggleItem m_hideunused_item;
 960   ToggleItem m_showshaders_item;
 961   ToggleItem m_showshaderlistonly_item;
 962
 963   TexturesMenu() :
 964     m_hideunused_item(TextureBrowserHideUnusedExport()),
 965     m_showshaders_item(TextureBrowserShowShadersExport()),
 966     m_showshaderlistonly_item(TextureBrowserShowShaderlistOnlyExport())
 967   {
 968   }
 969 };
 970
 971 TexturesMenu g_TexturesMenu;
 972
 973 void TextureBrowser_SetHideUnused(TextureBrowser& textureBrowser, bool hideUnused)
 974 {
 975   if(hideUnused)
 976   {
 977     textureBrowser.m_hideUnused = true;
 978   }
 979   else
 980   {
 981     textureBrowser.m_hideUnused = false;
 982   }
 983
 984   g_TexturesMenu.m_hideunused_item.update();
 985
 986   TextureBrowser_heightChanged(textureBrowser);
 987   textureBrowser.m_originInvalid = true;
 988 }
 989
 990 void TextureBrowser_ShowStartupShaders(TextureBrowser& textureBrowser)
 991 {
 992   if(textureBrowser.m_startupShaders == STARTUPSHADERS_COMMON)
 993   {
 994     TextureBrowser_ShowDirectory(textureBrowser, TextureBrowser_getComonShadersDir());
 995   }
 996   else if(textureBrowser.m_startupShaders == STARTUPSHADERS_ALL)
 997   {
 998     for(TextureMenuNames::const_iterator i = texture_menunames.begin(); i != texture_menunames.end(); ++i)
 999     {
1000       TextureBrowser_ShowDirectory(textureBrowser, (*i).c_str());
1001     }
1002   }
1003 }
1004
1005
1006 //++timo NOTE: this is a mix of Shader module stuff and texture explorer
1007 // it might need to be split in parts or moved out .. dunno
1008 // scroll origin so the specified texture is completely on screen
1009 // if current texture is not displayed, nothing is changed
1010 void TextureBrowser_Focus(TextureBrowser& textureBrowser, const char* name)
1011 {
1012   TextureLayout layout;
1013   // scroll origin so the texture is completely on screen
1014   Texture_StartPos(layout);
1015
1016   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1017   {
1018     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1019
1020     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1021       continue;
1022
1023     int x, y;
1024     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1025     qtexture_t* q = shader->getTexture();
1026     if (!q)
1027       break;
1028
1029     // we have found when texdef->name and the shader name match
1030     // NOTE: as everywhere else for our comparisons, we are not case sensitive
1031     if (shader_equal(name, shader->getName()))
1032     {
1033       int textureHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100))
1034         + 2 * TextureBrowser_fontHeight(textureBrowser);
1035
1036       int originy = TextureBrowser_getOriginY(textureBrowser);
1037       if (y > originy)
1038       {
1039         originy = y;
1040       }
1041
1042       if (y - textureHeight < originy - textureBrowser.height)
1043       {
1044         originy = (y - textureHeight) + textureBrowser.height;
1045       }
1046
1047       TextureBrowser_setOriginY(textureBrowser, originy);
1048       return;
1049     }
1050   }
1051 }
1052
1053 IShader* Texture_At(TextureBrowser& textureBrowser, int mx, int my)
1054 {
1055   my += TextureBrowser_getOriginY(textureBrowser) - textureBrowser.height;
1056
1057   TextureLayout layout;
1058   Texture_StartPos(layout);
1059   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1060   {
1061     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1062
1063     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1064       continue;
1065
1066     int   x, y;
1067     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1068     qtexture_t  *q = shader->getTexture();
1069     if (!q)
1070       break;
1071
1072     int nWidth = (int)(q->width * ((float)textureBrowser.m_textureScale / 100));
1073     int nHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100));
1074     if (mx > x && mx - x < nWidth
1075       && my < y && y - my < nHeight + TextureBrowser_fontHeight(textureBrowser))
1076     {
1077       return shader;
1078     }
1079   }
1080
1081   return 0;
1082 }
1083
1084 /*
1085 ==============
1086 SelectTexture
1087
1088   By mouse click
1089 ==============
1090 */
1091 void SelectTexture(TextureBrowser& textureBrowser, int mx, int my, bool bShift)
1092 {
1093   IShader* shader = Texture_At(textureBrowser, mx, my);
1094   if(shader != 0)
1095   {
1096     if (bShift)
1097     {
1098       if (shader->IsDefault())
1099         globalOutputStream() << "ERROR: " << shader->getName() << " is not a shader, it's a texture.\n";
1100       else
1101         ViewShader( shader->getShaderFileName(), shader->getName() );
1102     }
1103     else
1104     {
1105       TextureBrowser_SetSelectedShader(textureBrowser, shader->getName());
1106       TextureBrowser_textureSelected(shader->getName());
1107
1108       if (!FindTextureDialog_isOpen())
1109       {
1110         UndoableCommand undo("textureNameSetSelected");
1111         Select_SetShader(shader->getName());
1112       }
1113     }
1114   }
1115 }
1116
1117 /*
1118 ============================================================================
1119
1120   MOUSE ACTIONS
1121
1122 ============================================================================
1123 */
1124
1125 void TextureBrowser_trackingDelta(int x, int y, unsigned int state, void* data)
1126 {
1127   TextureBrowser& textureBrowser = *reinterpret_cast<TextureBrowser*>(data);
1128   if(y != 0)
1129   {
1130     int scale = 1;
1131
1132     if(state & GDK_SHIFT_MASK)
1133       scale = 4;
1134
1135     int originy = TextureBrowser_getOriginY(textureBrowser);
1136     originy += y * scale;
1137     TextureBrowser_setOriginY(textureBrowser, originy);
1138   }
1139 }
1140
1141 void TextureBrowser_Tracking_MouseDown(TextureBrowser& textureBrowser)
1142 {
1143   textureBrowser.m_freezePointer.freeze_pointer(textureBrowser.m_parent, TextureBrowser_trackingDelta, &textureBrowser);
1144 }
1145
1146 void TextureBrowser_Tracking_MouseUp(TextureBrowser& textureBrowser)
1147 {
1148   textureBrowser.m_freezePointer.unfreeze_pointer(textureBrowser.m_parent);
1149 }
1150
1151 void TextureBrowser_Selection_MouseDown(TextureBrowser& textureBrowser, guint32 flags, int pointx, int pointy)
1152 {
1153   SelectTexture(textureBrowser, pointx, textureBrowser.height - 1 - pointy, (flags & GDK_SHIFT_MASK) != 0);
1154 }
1155
1156 /*
1157 ============================================================================
1158
1159 DRAWING
1160
1161 ============================================================================
1162 */
1163
1164 /*
1165 ============
1166 Texture_Draw
1167 TTimo: relying on the shaders list to display the textures
1168 we must query all qtexture_t* to manage and display through the IShaders interface
1169 this allows a plugin to completely override the texture system
1170 ============
1171 */
1172 void Texture_Draw(TextureBrowser& textureBrowser)
1173 {
1174   int originy = TextureBrowser_getOriginY(textureBrowser);
1175
1176   glClearColor(textureBrowser.color_textureback[0],
1177     textureBrowser.color_textureback[1],
1178     textureBrowser.color_textureback[2],
1179     0);
1180   glViewport(0, 0, textureBrowser.width, textureBrowser.height);
1181   glMatrixMode(GL_PROJECTION);
1182   glLoadIdentity();
1183
1184   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1185   glDisable (GL_DEPTH_TEST);
1186   glDisable(GL_BLEND);
1187   glOrtho (0, textureBrowser.width, originy-textureBrowser.height, originy, -100, 100);
1188   glEnable (GL_TEXTURE_2D);
1189
1190   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1191
1192   int last_y = 0, last_height = 0;
1193
1194   TextureLayout layout;
1195   Texture_StartPos(layout);
1196   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1197   {
1198     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1199
1200     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1201       continue;
1202
1203     int x, y;
1204     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1205     qtexture_t *q = shader->getTexture();
1206     if (!q)
1207       break;
1208
1209     int nWidth = (int)(q->width * ((float)textureBrowser.m_textureScale / 100));
1210     int nHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100));
1211
1212     if (y != last_y)
1213     {
1214       last_y = y;
1215       last_height = 0;
1216     }
1217     last_height = std::max (nHeight, last_height);
1218
1219     // Is this texture visible?
1220     if ((y-nHeight-TextureBrowser_fontHeight(textureBrowser) < originy)
1221         && (y > originy - textureBrowser.height))
1222     {
1223       // borders rules:
1224       // if it's the current texture, draw a thick red line, else:
1225       // shaders have a white border, simple textures don't
1226       // if !texture_showinuse: (some textures displayed may not be in use)
1227       // draw an additional square around with 0.5 1 0.5 color
1228       if (shader_equal(TextureBrowser_GetSelectedShader(textureBrowser), shader->getName()))
1229       {
1230               glLineWidth (3);
1231               glColor3f (1,0,0);
1232               glDisable (GL_TEXTURE_2D);
1233
1234               glBegin (GL_LINE_LOOP);
1235               glVertex2i (x-4,y-TextureBrowser_fontHeight(textureBrowser)+4);
1236               glVertex2i (x-4,y-TextureBrowser_fontHeight(textureBrowser)-nHeight-4);
1237               glVertex2i (x+4+nWidth,y-TextureBrowser_fontHeight(textureBrowser)-nHeight-4);
1238               glVertex2i (x+4+nWidth,y-TextureBrowser_fontHeight(textureBrowser)+4);
1239               glEnd();
1240
1241               glEnable (GL_TEXTURE_2D);
1242               glLineWidth (1);
1243       }
1244       else
1245       {
1246               glLineWidth (1);
1247               // shader border:
1248               if (!shader->IsDefault())
1249               {
1250                 glColor3f (1,1,1);
1251                 glDisable (GL_TEXTURE_2D);
1252
1253                 glBegin (GL_LINE_LOOP);
1254                 glVertex2i (x-1,y+1-TextureBrowser_fontHeight(textureBrowser));
1255                 glVertex2i (x-1,y-nHeight-1-TextureBrowser_fontHeight(textureBrowser));
1256                 glVertex2i (x+1+nWidth,y-nHeight-1-TextureBrowser_fontHeight(textureBrowser));
1257                 glVertex2i (x+1+nWidth,y+1-TextureBrowser_fontHeight(textureBrowser));
1258                 glEnd();
1259                 glEnable (GL_TEXTURE_2D);
1260               }
1261
1262               // highlight in-use textures
1263               if (!textureBrowser.m_hideUnused && shader->IsInUse())
1264               {
1265                 glColor3f (0.5,1,0.5);
1266                 glDisable (GL_TEXTURE_2D);
1267                 glBegin (GL_LINE_LOOP);
1268                 glVertex2i (x-3,y+3-TextureBrowser_fontHeight(textureBrowser));
1269                 glVertex2i (x-3,y-nHeight-3-TextureBrowser_fontHeight(textureBrowser));
1270                 glVertex2i (x+3+nWidth,y-nHeight-3-TextureBrowser_fontHeight(textureBrowser));
1271                 glVertex2i (x+3+nWidth,y+3-TextureBrowser_fontHeight(textureBrowser));
1272                 glEnd();
1273                 glEnable (GL_TEXTURE_2D);
1274               }
1275       }
1276
1277       // Draw the texture
1278       glBindTexture (GL_TEXTURE_2D, q->texture_number);
1279       GlobalOpenGL_debugAssertNoErrors();
1280       glColor3f (1,1,1);
1281       glBegin (GL_QUADS);
1282       glTexCoord2i (0,0);
1283       glVertex2i (x,y-TextureBrowser_fontHeight(textureBrowser));
1284       glTexCoord2i (1,0);
1285       glVertex2i (x+nWidth,y-TextureBrowser_fontHeight(textureBrowser));
1286       glTexCoord2i (1,1);
1287       glVertex2i (x+nWidth,y-TextureBrowser_fontHeight(textureBrowser)-nHeight);
1288       glTexCoord2i (0,1);
1289       glVertex2i (x,y-TextureBrowser_fontHeight(textureBrowser)-nHeight);
1290       glEnd();
1291
1292       // draw the texture name
1293       glDisable (GL_TEXTURE_2D);
1294       glColor3f (1,1,1);
1295
1296       glRasterPos2i (x, y-TextureBrowser_fontHeight(textureBrowser)+2);
1297
1298       // don't draw the directory name
1299       const char* name = shader->getName();
1300       name += strlen(name);
1301       while(name != shader->getName() && *(name-1) != '/' && *(name-1) != '\\')
1302         name--;
1303
1304       GlobalOpenGL().drawString(name);
1305       glEnable (GL_TEXTURE_2D);
1306     }
1307
1308     //int totalHeight = abs(y) + last_height + TextureBrowser_fontHeight(textureBrowser) + 4;
1309   }
1310
1311
1312   // reset the current texture
1313   glBindTexture(GL_TEXTURE_2D, 0);
1314   //qglFinish();
1315 }
1316
1317 void TextureBrowser_queueDraw(TextureBrowser& textureBrowser)
1318 {
1319   if(textureBrowser.m_gl_widget != 0)
1320   {
1321     gtk_widget_queue_draw(textureBrowser.m_gl_widget);
1322   }
1323 }
1324
1325
1326 void TextureBrowser_setScale(TextureBrowser& textureBrowser, std::size_t scale)
1327 {
1328   textureBrowser.m_textureScale = scale;
1329
1330   TextureBrowser_queueDraw(textureBrowser);
1331 }
1332
1333
1334 void TextureBrowser_MouseWheel(TextureBrowser& textureBrowser, bool bUp)
1335 {
1336   int originy = TextureBrowser_getOriginY(textureBrowser);
1337
1338   if (bUp)
1339   {
1340     originy += int(textureBrowser.m_mouseWheelScrollIncrement);
1341   }
1342   else
1343   {
1344     originy -= int(textureBrowser.m_mouseWheelScrollIncrement);
1345   }
1346
1347   TextureBrowser_setOriginY(textureBrowser, originy);
1348 }
1349
1350
1351
1352 gboolean TextureBrowser_button_press(GtkWidget* widget, GdkEventButton* event, TextureBrowser* textureBrowser)
1353 {
1354   if(event->type == GDK_BUTTON_PRESS)
1355   {
1356     if(event->button == 3)
1357     {
1358       TextureBrowser_Tracking_MouseDown(*textureBrowser);
1359     }
1360     else if(event->button == 1)
1361     {
1362       TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>(event->x), static_cast<int>(event->y));
1363     }
1364   }
1365   return FALSE;
1366 }
1367
1368 gboolean TextureBrowser_button_release(GtkWidget* widget, GdkEventButton* event, TextureBrowser* textureBrowser)
1369 {
1370   if(event->type == GDK_BUTTON_RELEASE)
1371   {
1372     if(event->button == 3)
1373     {
1374       TextureBrowser_Tracking_MouseUp(*textureBrowser);
1375     }
1376   }
1377   return FALSE;
1378 }
1379
1380 gboolean TextureBrowser_motion(GtkWidget *widget, GdkEventMotion *event, TextureBrowser* textureBrowser)
1381 {
1382   return FALSE;
1383 }
1384
1385 gboolean TextureBrowser_scroll(GtkWidget* widget, GdkEventScroll* event, TextureBrowser* textureBrowser)
1386 {
1387   if(event->direction == GDK_SCROLL_UP)
1388   {
1389     TextureBrowser_MouseWheel(*textureBrowser, true);
1390   }
1391   else if(event->direction == GDK_SCROLL_DOWN)
1392   {
1393     TextureBrowser_MouseWheel(*textureBrowser, false);
1394   }
1395   return FALSE;
1396 }
1397
1398 void TextureBrowser_scrollChanged(void* data, gdouble value)
1399 {
1400   //globalOutputStream() << "vertical scroll\n";
1401   TextureBrowser_setOriginY(*reinterpret_cast<TextureBrowser*>(data), -(int)value);
1402 }
1403
1404 static void TextureBrowser_verticalScroll(GtkAdjustment *adjustment, TextureBrowser* textureBrowser)
1405 {
1406   textureBrowser->m_scrollAdjustment.value_changed(adjustment->value);
1407 }
1408
1409 void TextureBrowser_updateScroll(TextureBrowser& textureBrowser)
1410 {
1411   if(textureBrowser.m_showTextureScrollbar)
1412   {
1413     int totalHeight = TextureBrowser_TotalHeight(textureBrowser);
1414
1415     totalHeight = std::max(totalHeight, textureBrowser.height);
1416
1417     GtkAdjustment *vadjustment = gtk_range_get_adjustment(GTK_RANGE(textureBrowser.m_texture_scroll));
1418
1419     vadjustment->value = -TextureBrowser_getOriginY(textureBrowser);
1420     vadjustment->page_size = textureBrowser.height;
1421     vadjustment->page_increment = textureBrowser.height/2;
1422     vadjustment->step_increment = 20;
1423     vadjustment->lower = 0;
1424     vadjustment->upper = totalHeight;
1425
1426     g_signal_emit_by_name(G_OBJECT (vadjustment), "changed");
1427   }
1428 }
1429
1430 gboolean TextureBrowser_size_allocate(GtkWidget* widget, GtkAllocation* allocation, TextureBrowser* textureBrowser)
1431 {
1432   textureBrowser->width = allocation->width;
1433   textureBrowser->height = allocation->height;
1434   TextureBrowser_heightChanged(*textureBrowser);
1435   textureBrowser->m_originInvalid = true;
1436   TextureBrowser_queueDraw(*textureBrowser);
1437   return FALSE;
1438 }
1439
1440 gboolean TextureBrowser_expose(GtkWidget* widget, GdkEventExpose* event, TextureBrowser* textureBrowser)
1441 {
1442   if(glwidget_make_current(textureBrowser->m_gl_widget) != FALSE)
1443   {
1444     GlobalOpenGL_debugAssertNoErrors();
1445     TextureBrowser_evaluateHeight(*textureBrowser);
1446     Texture_Draw(*textureBrowser);
1447     GlobalOpenGL_debugAssertNoErrors();
1448     glwidget_swap_buffers(textureBrowser->m_gl_widget);
1449   }
1450   return FALSE;
1451 }
1452
1453
1454 TextureBrowser g_TextureBrowser;
1455
1456 TextureBrowser& GlobalTextureBrowser()
1457 {
1458   return g_TextureBrowser;
1459 }
1460
1461 bool TextureBrowser_hideUnused()
1462 {
1463   return g_TextureBrowser.m_hideUnused;
1464 }
1465
1466 void TextureBrowser_ToggleHideUnused()
1467 {
1468   if(g_TextureBrowser.m_hideUnused)
1469   {
1470     TextureBrowser_SetHideUnused(g_TextureBrowser, false);
1471   }
1472   else
1473   {
1474     TextureBrowser_SetHideUnused(g_TextureBrowser, true);
1475   }
1476 }
1477
1478 GtkWidget* TextureBrowser_constructWindow(GtkWindow* toplevel)
1479 {
1480   GlobalShaderSystem().setActiveShadersChangedNotify(ReferenceCaller<TextureBrowser, TextureBrowser_activeShadersChanged>(g_TextureBrowser));
1481
1482   GtkWidget* hbox = gtk_hbox_new (FALSE, 0);
1483
1484   g_TextureBrowser.m_parent = toplevel;
1485
1486   {
1487           GtkWidget* w = gtk_vscrollbar_new (GTK_ADJUSTMENT (gtk_adjustment_new (0,0,0,1,1,1)));
1488           gtk_widget_show (w);
1489           gtk_box_pack_end (GTK_BOX (hbox), w, FALSE, TRUE, 0);
1490           g_TextureBrowser.m_texture_scroll = w;
1491
1492     GtkAdjustment *vadjustment = gtk_range_get_adjustment (GTK_RANGE (g_TextureBrowser.m_texture_scroll));
1493     g_signal_connect(G_OBJECT(vadjustment), "value_changed", G_CALLBACK(TextureBrowser_verticalScroll), &g_TextureBrowser);
1494
1495     widget_set_visible(g_TextureBrowser.m_texture_scroll, g_TextureBrowser.m_showTextureScrollbar);
1496   }
1497   {
1498           GtkWidget* texbox = gtk_vbox_new (FALSE, 0);
1499           gtk_widget_show(texbox);
1500           gtk_box_pack_start(GTK_BOX(hbox), texbox, TRUE, TRUE, 0);
1501
1502           {
1503                   GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
1504                   gtk_box_pack_start(GTK_BOX(texbox), GTK_WIDGET(entry), FALSE, FALSE, 0);
1505
1506                   g_TextureBrowser.m_filter = entry;
1507       if(g_TextureBrowser.m_showTextureFilter)
1508       {
1509         gtk_widget_show(GTK_WIDGET(g_TextureBrowser.m_filter));
1510       }
1511
1512       g_TextureBrowser.m_filterEntry.connect(entry);
1513           }
1514
1515           {
1516       g_TextureBrowser.m_gl_widget = glwidget_new(FALSE);
1517       gtk_widget_ref(g_TextureBrowser.m_gl_widget);
1518
1519       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);
1520       GTK_WIDGET_SET_FLAGS(g_TextureBrowser.m_gl_widget, GTK_CAN_FOCUS);
1521
1522                   gtk_box_pack_start(GTK_BOX(texbox), g_TextureBrowser.m_gl_widget, TRUE, TRUE, 0);
1523                   gtk_widget_show(g_TextureBrowser.m_gl_widget);
1524
1525       g_TextureBrowser.m_sizeHandler = g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "size_allocate", G_CALLBACK(TextureBrowser_size_allocate), &g_TextureBrowser);
1526       g_TextureBrowser.m_exposeHandler = g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "expose_event", G_CALLBACK(TextureBrowser_expose), &g_TextureBrowser);
1527
1528       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "button_press_event", G_CALLBACK(TextureBrowser_button_press), &g_TextureBrowser);
1529       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "button_release_event", G_CALLBACK(TextureBrowser_button_release), &g_TextureBrowser);
1530       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "motion_notify_event", G_CALLBACK(TextureBrowser_motion), &g_TextureBrowser);
1531       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "scroll_event", G_CALLBACK(TextureBrowser_scroll), &g_TextureBrowser);
1532           }
1533         }
1534   TextureBrowser_updateScroll(g_TextureBrowser);
1535
1536   gtk_container_set_focus_chain(GTK_CONTAINER(hbox), NULL);
1537
1538   return hbox;
1539 }
1540
1541 void TextureBrowser_destroyWindow()
1542 {
1543   GlobalShaderSystem().setActiveShadersChangedNotify(Callback());
1544
1545   g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_sizeHandler);
1546   g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_exposeHandler);
1547
1548   gtk_widget_unref(g_TextureBrowser.m_gl_widget);
1549 }
1550
1551 const Vector3& TextureBrowser_getBackgroundColour(TextureBrowser& textureBrowser)
1552 {
1553   return textureBrowser.color_textureback;
1554 }
1555
1556 void TextureBrowser_setBackgroundColour(TextureBrowser& textureBrowser, const Vector3& colour)
1557 {
1558   textureBrowser.color_textureback = colour;
1559   TextureBrowser_queueDraw(textureBrowser);
1560 }
1561
1562
1563 void TextureBrowser_ToggleShowShaders()
1564 {
1565   g_TextureBrowser.m_showShaders ^= 1;
1566   g_TexturesMenu.m_showshaders_item.update();
1567   TextureBrowser_queueDraw(g_TextureBrowser);
1568 }
1569
1570 void TextureBrowser_ToggleShowShaderListOnly()
1571 {
1572   g_TexturesMenu_shaderlistOnly ^= 1;
1573   g_TexturesMenu.m_showshaderlistonly_item.update();
1574   TextureGroupsMenu_Destroy();
1575   TextureGroupsMenu_Construct();
1576 }
1577
1578 void TextureBrowser_showAll()
1579 {
1580   g_TextureBrowser_currentDirectory = "";
1581   TextureBrowser_heightChanged(g_TextureBrowser);
1582   TextureBrowser_updateTitle();
1583 }
1584
1585 void TextureBrowser_exportTitle(const StringImportCallback& importer)
1586 {
1587   StringOutputStream buffer(64);
1588   buffer << "Textures: ";
1589   if(!string_empty(g_TextureBrowser_currentDirectory.c_str()))
1590   {
1591     buffer << g_TextureBrowser_currentDirectory.c_str();
1592   }
1593   else
1594   {
1595     buffer << "all";
1596   }
1597   importer(buffer.c_str());
1598 }
1599
1600
1601 void TextureScaleImport(TextureBrowser& textureBrowser, int value)
1602 {
1603   switch(value)
1604   {
1605   case 0:
1606     TextureBrowser_setScale(textureBrowser, 10);
1607     break;
1608   case 1:
1609     TextureBrowser_setScale(textureBrowser, 25);
1610     break;
1611   case 2:
1612     TextureBrowser_setScale(textureBrowser, 50);
1613     break;
1614   case 3:
1615     TextureBrowser_setScale(textureBrowser, 100);
1616     break;
1617   case 4:
1618     TextureBrowser_setScale(textureBrowser, 200);
1619     break;
1620   }
1621 }
1622 typedef ReferenceCaller1<TextureBrowser, int, TextureScaleImport> TextureScaleImportCaller;
1623
1624 void TextureScaleExport(TextureBrowser& textureBrowser, const IntImportCallback& importer)
1625 {
1626   switch(textureBrowser.m_textureScale)
1627   {
1628   case 10:
1629     importer(0);
1630     break;
1631   case 25:
1632     importer(1);
1633     break;
1634   case 50:
1635     importer(2);
1636     break;
1637   case 100:
1638     importer(3);
1639     break;
1640   case 200:
1641     importer(4);
1642     break;
1643   }
1644 }
1645 typedef ReferenceCaller1<TextureBrowser, const IntImportCallback&, TextureScaleExport> TextureScaleExportCaller;
1646
1647 void TextureBrowser_constructPreferences(PreferencesPage& page)
1648 {
1649   page.appendCheckBox(
1650     "", "Texture subsets",
1651     TextureBrowserImportShowFilterCaller(GlobalTextureBrowser()),
1652     BoolExportCaller(GlobalTextureBrowser().m_showTextureFilter)
1653   );
1654   page.appendCheckBox(
1655     "", "Texture scrollbar",
1656     TextureBrowserImportShowScrollbarCaller(GlobalTextureBrowser()),
1657     BoolExportCaller(GlobalTextureBrowser().m_showTextureScrollbar)
1658   );
1659   {
1660     const char* texture_scale[] = { "10%", "25%", "50%", "100%", "200%" };
1661     page.appendCombo(
1662       "Texture Thumbnail Scale",
1663       STRING_ARRAY_RANGE(texture_scale),
1664       IntImportCallback(TextureScaleImportCaller(GlobalTextureBrowser())),
1665       IntExportCallback(TextureScaleExportCaller(GlobalTextureBrowser()))
1666     );
1667   }
1668   page.appendEntry("Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement);
1669   {
1670     const char* startup_shaders[] = { "None", TextureBrowser_getComonShadersName(), "All" };
1671     page.appendCombo("Load Shaders at Startup", reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders), STRING_ARRAY_RANGE(startup_shaders));
1672   }
1673 }
1674 void TextureBrowser_constructPage(PreferenceGroup& group)
1675 {
1676   PreferencesPage page(group.createPage("Texture Browser", "Texture Browser Preferences"));
1677   TextureBrowser_constructPreferences(page);
1678 }
1679 void TextureBrowser_registerPreferencesPage()
1680 {
1681   PreferencesDialog_addSettingsPage(FreeCaller1<PreferenceGroup&, TextureBrowser_constructPage>());
1682 }
1683
1684
1685 #include "preferencesystem.h"
1686 #include "stringio.h"
1687
1688 typedef ReferenceCaller1<TextureBrowser, std::size_t, TextureBrowser_setScale> TextureBrowserSetScaleCaller;
1689
1690
1691
1692 void TextureClipboard_textureSelected(const char* shader);
1693
1694 void TextureBrowser_Construct()
1695 {
1696   GlobalToggles_insert("ShowInUse", FreeCaller<TextureBrowser_ToggleHideUnused>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_hideunused_item), Accelerator('U'));
1697   GlobalCommands_insert("ShowAllTextures", FreeCaller<TextureBrowser_showAll>(), Accelerator('A', (GdkModifierType)GDK_CONTROL_MASK));
1698   GlobalCommands_insert("ViewTextures", FreeCaller<TextureBrowser_toggleShown>(), Accelerator('T'));
1699   GlobalToggles_insert("ToggleShowShaders", FreeCaller<TextureBrowser_ToggleShowShaders>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_showshaders_item));
1700   GlobalToggles_insert("ToggleShowShaderlistOnly", FreeCaller<TextureBrowser_ToggleShowShaderListOnly>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_showshaderlistonly_item));
1701
1702   GlobalPreferenceSystem().registerPreference("TextureScale",
1703     makeSizeStringImportCallback(TextureBrowserSetScaleCaller(g_TextureBrowser)),
1704     SizeExportStringCaller(g_TextureBrowser.m_textureScale)
1705   );
1706   GlobalPreferenceSystem().registerPreference("NewTextureWindowStuff",
1707     makeBoolStringImportCallback(TextureBrowserImportShowFilterCaller(g_TextureBrowser)),
1708     BoolExportStringCaller(GlobalTextureBrowser().m_showTextureFilter)
1709   );
1710   GlobalPreferenceSystem().registerPreference("TextureScrollbar",
1711     makeBoolStringImportCallback(TextureBrowserImportShowScrollbarCaller(g_TextureBrowser)),
1712     BoolExportStringCaller(GlobalTextureBrowser().m_showTextureScrollbar)
1713   );
1714   GlobalPreferenceSystem().registerPreference("ShowShaders", BoolImportStringCaller(GlobalTextureBrowser().m_showShaders), BoolExportStringCaller(GlobalTextureBrowser().m_showShaders));
1715   GlobalPreferenceSystem().registerPreference("ShowShaderlistOnly", BoolImportStringCaller(g_TexturesMenu_shaderlistOnly), BoolExportStringCaller(g_TexturesMenu_shaderlistOnly));
1716   GlobalPreferenceSystem().registerPreference("LoadShaders", IntImportStringCaller(reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders)), IntExportStringCaller(reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders)));
1717   GlobalPreferenceSystem().registerPreference("WheelMouseInc", SizeImportStringCaller(GlobalTextureBrowser().m_mouseWheelScrollIncrement), SizeExportStringCaller(GlobalTextureBrowser().m_mouseWheelScrollIncrement));
1718   GlobalPreferenceSystem().registerPreference("SI_Colors0", Vector3ImportStringCaller(GlobalTextureBrowser().color_textureback), Vector3ExportStringCaller(GlobalTextureBrowser().color_textureback));
1719
1720   g_TextureBrowser.shader = texdef_name_default();
1721
1722   Textures_setModeChangedNotify(ReferenceCaller<TextureBrowser, TextureBrowser_queueDraw>(g_TextureBrowser));
1723
1724   TextureBrowser_registerPreferencesPage();
1725
1726   GlobalShaderSystem().attach(g_ShadersObserver);
1727   GlobalShaderSystem().attach(g_TextureGroupsMenu);
1728   GlobalFileSystem().attach(g_TextureGroupsMenu);
1729
1730   TextureBrowser_textureSelected = TextureClipboard_textureSelected;
1731 }
1732 void TextureBrowser_Destroy()
1733 {
1734   GlobalFileSystem().detach(g_TextureGroupsMenu);
1735   GlobalShaderSystem().detach(g_TextureGroupsMenu);
1736   GlobalShaderSystem().detach(g_ShadersObserver);
1737
1738   Textures_setModeChangedNotify(Callback());
1739 }