04476866c241560e748ca109b5ef007b9ee25386
[xonotic/netradiant.git] / radiant / texwindow.cpp
1 /*
2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
4
5 This file is part of GtkRadiant.
6
7 GtkRadiant is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
11
12 GtkRadiant is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GtkRadiant; if not, write to the Free Software
19 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
20 */
21
22 //
23 // Texture Window
24 //
25 // Leonardo Zide (leo@lokigames.com)
26 //
27
28 #include "texwindow.h"
29
30 #include "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 (!shader_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) const
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       Radiant_getImageModules().foreachModule(LoadTexturesByTypeVisitor(dirstring.c_str()));
923     }
924   }
925
926   // we'll display the newly loaded textures + all the ones already in use
927   TextureBrowser_SetHideUnused(textureBrowser, false);
928
929   TextureBrowser_updateTitle();
930 }
931
932
933 bool TextureBrowser_hideUnused();
934
935 void TextureBrowser_hideUnusedExport(const BoolImportCallback& importer)
936 {
937   importer(TextureBrowser_hideUnused());
938 }
939 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
940
941 void TextureBrowser_showShadersExport(const BoolImportCallback& importer)
942 {
943   importer(GlobalTextureBrowser().m_showShaders);
944 }
945 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
946
947 void TextureBrowser_showShaderlistOnly(const BoolImportCallback& importer)
948 {
949   importer(g_TexturesMenu_shaderlistOnly);
950 }
951 typedef FreeCaller1<const BoolImportCallback&, TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
952
953 class TexturesMenu
954 {
955 public:
956   ToggleItem m_hideunused_item;
957   ToggleItem m_showshaders_item;
958   ToggleItem m_showshaderlistonly_item;
959
960   TexturesMenu() :
961     m_hideunused_item(TextureBrowserHideUnusedExport()),
962     m_showshaders_item(TextureBrowserShowShadersExport()),
963     m_showshaderlistonly_item(TextureBrowserShowShaderlistOnlyExport())
964   {
965   }
966 };
967
968 TexturesMenu g_TexturesMenu;
969
970 void TextureBrowser_SetHideUnused(TextureBrowser& textureBrowser, bool hideUnused)
971 {
972   if(hideUnused)
973   {
974     textureBrowser.m_hideUnused = true;
975   }
976   else
977   {
978     textureBrowser.m_hideUnused = false;
979   }
980
981   g_TexturesMenu.m_hideunused_item.update();
982
983   TextureBrowser_heightChanged(textureBrowser);
984   textureBrowser.m_originInvalid = true;
985 }
986
987 void TextureBrowser_ShowStartupShaders(TextureBrowser& textureBrowser)
988 {
989   if(textureBrowser.m_startupShaders == STARTUPSHADERS_COMMON)
990   {
991     TextureBrowser_ShowDirectory(textureBrowser, TextureBrowser_getComonShadersDir());
992   }
993   else if(textureBrowser.m_startupShaders == STARTUPSHADERS_ALL)
994   {
995     for(TextureMenuNames::const_iterator i = texture_menunames.begin(); i != texture_menunames.end(); ++i)
996     {
997       TextureBrowser_ShowDirectory(textureBrowser, (*i).c_str());
998     }
999   }
1000 }
1001
1002
1003 //++timo NOTE: this is a mix of Shader module stuff and texture explorer
1004 // it might need to be split in parts or moved out .. dunno
1005 // scroll origin so the specified texture is completely on screen
1006 // if current texture is not displayed, nothing is changed
1007 void TextureBrowser_Focus(TextureBrowser& textureBrowser, const char* name)
1008 {
1009   TextureLayout layout;
1010   // scroll origin so the texture is completely on screen
1011   Texture_StartPos(layout);
1012   
1013   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1014   {
1015     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1016
1017     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1018       continue;
1019
1020     int x, y;
1021     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1022     qtexture_t* q = shader->getTexture();
1023     if (!q)
1024       break;
1025
1026     // we have found when texdef->name and the shader name match
1027     // NOTE: as everywhere else for our comparisons, we are not case sensitive
1028     if (shader_equal(name, shader->getName()))
1029     {
1030       int textureHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100))
1031         + 2 * TextureBrowser_fontHeight(textureBrowser);
1032
1033       int originy = TextureBrowser_getOriginY(textureBrowser);
1034       if (y > originy)
1035       {
1036         originy = y;
1037       }
1038
1039       if (y - textureHeight < originy - textureBrowser.height)
1040       {
1041         originy = (y - textureHeight) + textureBrowser.height;
1042       }
1043
1044       TextureBrowser_setOriginY(textureBrowser, originy);
1045       return;
1046     }
1047   }
1048 }
1049
1050 IShader* Texture_At(TextureBrowser& textureBrowser, int mx, int my)
1051 {
1052   my += TextureBrowser_getOriginY(textureBrowser) - textureBrowser.height;
1053
1054   TextureLayout layout;
1055   Texture_StartPos(layout);
1056   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1057   {
1058     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1059
1060     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1061       continue;
1062
1063     int   x, y;
1064     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1065     qtexture_t  *q = shader->getTexture();
1066     if (!q)
1067       break;
1068
1069     int nWidth = (int)(q->width * ((float)textureBrowser.m_textureScale / 100));
1070     int nHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100));
1071     if (mx > x && mx - x < nWidth
1072       && my < y && y - my < nHeight + TextureBrowser_fontHeight(textureBrowser))
1073     {
1074       return shader;
1075     }
1076   }
1077
1078   return 0;
1079 }
1080
1081 /*
1082 ==============
1083 SelectTexture
1084
1085   By mouse click
1086 ==============
1087 */
1088 void SelectTexture(TextureBrowser& textureBrowser, int mx, int my, bool bShift)
1089 {
1090   IShader* shader = Texture_At(textureBrowser, mx, my);
1091   if(shader != 0)
1092   {
1093     if (bShift)
1094     {
1095       if (shader->IsDefault())
1096         globalOutputStream() << "ERROR: " << shader->getName() << " is not a shader, it's a texture.\n";
1097       else
1098         ViewShader( shader->getShaderFileName(), shader->getName() );
1099     }
1100     else
1101     {
1102       TextureBrowser_SetSelectedShader(textureBrowser, shader->getName());
1103       TextureBrowser_textureSelected(shader->getName());
1104
1105       if (!FindTextureDialog_isOpen())
1106       {
1107         UndoableCommand undo("textureNameSetSelected");
1108         Select_SetShader(shader->getName());
1109       }
1110     }
1111   }
1112 }
1113
1114 /*
1115 ============================================================================
1116
1117   MOUSE ACTIONS
1118
1119 ============================================================================
1120 */
1121
1122 void TextureBrowser_trackingDelta(int x, int y, unsigned int state, void* data)
1123 {
1124   TextureBrowser& textureBrowser = *reinterpret_cast<TextureBrowser*>(data);
1125   if(y != 0)
1126   {
1127     int scale = 1;
1128
1129     if(state & GDK_SHIFT_MASK)
1130       scale = 4;
1131
1132     int originy = TextureBrowser_getOriginY(textureBrowser);
1133     originy += y * scale;
1134     TextureBrowser_setOriginY(textureBrowser, originy);
1135   }
1136 }
1137
1138 void TextureBrowser_Tracking_MouseDown(TextureBrowser& textureBrowser)
1139 {
1140   textureBrowser.m_freezePointer.freeze_pointer(textureBrowser.m_parent, TextureBrowser_trackingDelta, &textureBrowser);
1141 }
1142
1143 void TextureBrowser_Tracking_MouseUp(TextureBrowser& textureBrowser)
1144 {
1145   textureBrowser.m_freezePointer.unfreeze_pointer(textureBrowser.m_parent);
1146 }
1147
1148 void TextureBrowser_Selection_MouseDown(TextureBrowser& textureBrowser, guint32 flags, int pointx, int pointy)
1149 {
1150   SelectTexture(textureBrowser, pointx, textureBrowser.height - 1 - pointy, (flags & GDK_SHIFT_MASK) != 0);
1151 }
1152
1153 /*
1154 ============================================================================
1155
1156 DRAWING
1157
1158 ============================================================================
1159 */
1160
1161 /*
1162 ============
1163 Texture_Draw
1164 TTimo: relying on the shaders list to display the textures
1165 we must query all qtexture_t* to manage and display through the IShaders interface
1166 this allows a plugin to completely override the texture system
1167 ============
1168 */
1169 void Texture_Draw(TextureBrowser& textureBrowser)
1170 {
1171   int originy = TextureBrowser_getOriginY(textureBrowser);
1172
1173   glClearColor(textureBrowser.color_textureback[0],
1174     textureBrowser.color_textureback[1],
1175     textureBrowser.color_textureback[2],
1176     0);
1177   glViewport(0, 0, textureBrowser.width, textureBrowser.height);
1178   glMatrixMode(GL_PROJECTION);
1179   glLoadIdentity();
1180
1181   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1182   glDisable (GL_DEPTH_TEST);
1183   glDisable(GL_BLEND);
1184   glOrtho (0, textureBrowser.width, originy-textureBrowser.height, originy, -100, 100);
1185   glEnable (GL_TEXTURE_2D);
1186
1187   glPolygonMode (GL_FRONT_AND_BACK, GL_FILL);
1188
1189   int last_y = 0, last_height = 0;
1190
1191   TextureLayout layout;
1192   Texture_StartPos(layout);
1193   for(QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement())
1194   {
1195     IShader* shader = QERApp_ActiveShaders_IteratorCurrent();
1196
1197     if(!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused, TextureBrowser_getFilter(textureBrowser)))
1198       continue;
1199
1200     int x, y;
1201     Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1202     qtexture_t *q = shader->getTexture();
1203     if (!q)
1204       break;
1205
1206     int nWidth = (int)(q->width * ((float)textureBrowser.m_textureScale / 100));
1207     int nHeight = (int)(q->height * ((float)textureBrowser.m_textureScale / 100));
1208
1209     if (y != last_y)
1210     {
1211       last_y = y;
1212       last_height = 0;
1213     }
1214     last_height = std::max (nHeight, last_height);
1215
1216     // Is this texture visible?
1217     if ((y-nHeight-TextureBrowser_fontHeight(textureBrowser) < originy)
1218         && (y > originy - textureBrowser.height))
1219     {
1220       // borders rules:
1221       // if it's the current texture, draw a thick red line, else:
1222       // shaders have a white border, simple textures don't
1223       // if !texture_showinuse: (some textures displayed may not be in use)
1224       // draw an additional square around with 0.5 1 0.5 color
1225       if (shader_equal(TextureBrowser_GetSelectedShader(textureBrowser), shader->getName()))
1226       {
1227               glLineWidth (3);
1228               glColor3f (1,0,0);
1229               glDisable (GL_TEXTURE_2D);
1230
1231               glBegin (GL_LINE_LOOP);
1232               glVertex2i (x-4,y-TextureBrowser_fontHeight(textureBrowser)+4);
1233               glVertex2i (x-4,y-TextureBrowser_fontHeight(textureBrowser)-nHeight-4);
1234               glVertex2i (x+4+nWidth,y-TextureBrowser_fontHeight(textureBrowser)-nHeight-4);
1235               glVertex2i (x+4+nWidth,y-TextureBrowser_fontHeight(textureBrowser)+4);
1236               glEnd();
1237
1238               glEnable (GL_TEXTURE_2D);
1239               glLineWidth (1);
1240       }
1241       else
1242       {
1243               glLineWidth (1);
1244               // shader border:
1245               if (!shader->IsDefault())
1246               {
1247                 glColor3f (1,1,1);
1248                 glDisable (GL_TEXTURE_2D);
1249
1250                 glBegin (GL_LINE_LOOP);
1251                 glVertex2i (x-1,y+1-TextureBrowser_fontHeight(textureBrowser));
1252                 glVertex2i (x-1,y-nHeight-1-TextureBrowser_fontHeight(textureBrowser));
1253                 glVertex2i (x+1+nWidth,y-nHeight-1-TextureBrowser_fontHeight(textureBrowser));
1254                 glVertex2i (x+1+nWidth,y+1-TextureBrowser_fontHeight(textureBrowser));
1255                 glEnd();
1256                 glEnable (GL_TEXTURE_2D);
1257               }
1258
1259               // highlight in-use textures
1260               if (!textureBrowser.m_hideUnused && shader->IsInUse())
1261               {
1262                 glColor3f (0.5,1,0.5);
1263                 glDisable (GL_TEXTURE_2D);
1264                 glBegin (GL_LINE_LOOP);
1265                 glVertex2i (x-3,y+3-TextureBrowser_fontHeight(textureBrowser));
1266                 glVertex2i (x-3,y-nHeight-3-TextureBrowser_fontHeight(textureBrowser));
1267                 glVertex2i (x+3+nWidth,y-nHeight-3-TextureBrowser_fontHeight(textureBrowser));
1268                 glVertex2i (x+3+nWidth,y+3-TextureBrowser_fontHeight(textureBrowser));
1269                 glEnd();
1270                 glEnable (GL_TEXTURE_2D);
1271               }
1272       }
1273
1274       // Draw the texture
1275       glBindTexture (GL_TEXTURE_2D, q->texture_number);
1276       GlobalOpenGL_debugAssertNoErrors();
1277       glColor3f (1,1,1);
1278       glBegin (GL_QUADS);
1279       glTexCoord2i (0,0);
1280       glVertex2i (x,y-TextureBrowser_fontHeight(textureBrowser));
1281       glTexCoord2i (1,0);
1282       glVertex2i (x+nWidth,y-TextureBrowser_fontHeight(textureBrowser));
1283       glTexCoord2i (1,1);
1284       glVertex2i (x+nWidth,y-TextureBrowser_fontHeight(textureBrowser)-nHeight);
1285       glTexCoord2i (0,1);
1286       glVertex2i (x,y-TextureBrowser_fontHeight(textureBrowser)-nHeight);
1287       glEnd();
1288
1289       // draw the texture name
1290       glDisable (GL_TEXTURE_2D);
1291       glColor3f (1,1,1);
1292
1293       glRasterPos2i (x, y-TextureBrowser_fontHeight(textureBrowser)+2);
1294
1295       // don't draw the directory name
1296       const char* name = shader->getName();
1297       name += strlen(name);
1298       while(name != shader->getName() && *(name-1) != '/' && *(name-1) != '\\')
1299         name--;
1300
1301       GlobalOpenGL().drawString(name);
1302       glEnable (GL_TEXTURE_2D);
1303     }
1304
1305     //int totalHeight = abs(y) + last_height + TextureBrowser_fontHeight(textureBrowser) + 4;
1306   }
1307
1308
1309   // reset the current texture
1310   glBindTexture(GL_TEXTURE_2D, 0);
1311   //qglFinish();
1312 }
1313
1314 void TextureBrowser_queueDraw(TextureBrowser& textureBrowser)
1315 {
1316   if(textureBrowser.m_gl_widget != 0)
1317   {
1318     gtk_widget_queue_draw(textureBrowser.m_gl_widget);
1319   }
1320 }
1321
1322
1323 void TextureBrowser_setScale(TextureBrowser& textureBrowser, std::size_t scale)
1324 {
1325   textureBrowser.m_textureScale = scale;
1326
1327   TextureBrowser_queueDraw(textureBrowser);
1328 }
1329
1330
1331 void TextureBrowser_MouseWheel(TextureBrowser& textureBrowser, bool bUp)
1332 {
1333   int originy = TextureBrowser_getOriginY(textureBrowser);
1334
1335   if (bUp)
1336   {
1337     originy += int(textureBrowser.m_mouseWheelScrollIncrement);
1338   }
1339   else
1340   {
1341     originy -= int(textureBrowser.m_mouseWheelScrollIncrement);
1342   }
1343
1344   TextureBrowser_setOriginY(textureBrowser, originy);
1345 }
1346
1347
1348
1349 gboolean TextureBrowser_button_press(GtkWidget* widget, GdkEventButton* event, TextureBrowser* textureBrowser)
1350 {
1351   if(event->type == GDK_BUTTON_PRESS)
1352   {
1353     if(event->button == 3)
1354     {
1355       TextureBrowser_Tracking_MouseDown(*textureBrowser);
1356     }
1357     else if(event->button == 1)
1358     {
1359       TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>(event->x), static_cast<int>(event->y));
1360     }
1361   }
1362   return FALSE;
1363 }
1364
1365 gboolean TextureBrowser_button_release(GtkWidget* widget, GdkEventButton* event, TextureBrowser* textureBrowser)
1366 {
1367   if(event->type == GDK_BUTTON_RELEASE)
1368   {
1369     if(event->button == 3)
1370     {
1371       TextureBrowser_Tracking_MouseUp(*textureBrowser);
1372     }
1373   }
1374   return FALSE;
1375 }
1376
1377 gboolean TextureBrowser_motion(GtkWidget *widget, GdkEventMotion *event, TextureBrowser* textureBrowser)
1378 {
1379   return FALSE;
1380 }
1381
1382 gboolean TextureBrowser_scroll(GtkWidget* widget, GdkEventScroll* event, TextureBrowser* textureBrowser)
1383 {
1384   if(event->direction == GDK_SCROLL_UP)
1385   {
1386     TextureBrowser_MouseWheel(*textureBrowser, true);
1387   }
1388   else if(event->direction == GDK_SCROLL_DOWN)
1389   {
1390     TextureBrowser_MouseWheel(*textureBrowser, false);
1391   }
1392   return FALSE;
1393 }
1394
1395 void TextureBrowser_scrollChanged(void* data, gdouble value)
1396 {
1397   //globalOutputStream() << "vertical scroll\n";
1398   TextureBrowser_setOriginY(*reinterpret_cast<TextureBrowser*>(data), -(int)value);
1399 }
1400
1401 static void TextureBrowser_verticalScroll(GtkAdjustment *adjustment, TextureBrowser* textureBrowser)
1402 {
1403   textureBrowser->m_scrollAdjustment.value_changed(adjustment->value);
1404 }
1405
1406 void TextureBrowser_updateScroll(TextureBrowser& textureBrowser)
1407 {
1408   if(textureBrowser.m_showTextureScrollbar)
1409   {
1410     int totalHeight = TextureBrowser_TotalHeight(textureBrowser);
1411
1412     totalHeight = std::max(totalHeight, textureBrowser.height);
1413
1414     GtkAdjustment *vadjustment = gtk_range_get_adjustment(GTK_RANGE(textureBrowser.m_texture_scroll));
1415
1416     vadjustment->value = -TextureBrowser_getOriginY(textureBrowser);
1417     vadjustment->page_size = textureBrowser.height;
1418     vadjustment->page_increment = textureBrowser.height/2;
1419     vadjustment->step_increment = 20;
1420     vadjustment->lower = 0;
1421     vadjustment->upper = totalHeight;
1422
1423     g_signal_emit_by_name(G_OBJECT (vadjustment), "changed");
1424   }
1425 }
1426
1427 gboolean TextureBrowser_size_allocate(GtkWidget* widget, GtkAllocation* allocation, TextureBrowser* textureBrowser)
1428 {
1429   textureBrowser->width = allocation->width;
1430   textureBrowser->height = allocation->height;
1431   TextureBrowser_heightChanged(*textureBrowser);
1432   textureBrowser->m_originInvalid = true;
1433   TextureBrowser_queueDraw(*textureBrowser);
1434   return FALSE;
1435 }
1436
1437 gboolean TextureBrowser_expose(GtkWidget* widget, GdkEventExpose* event, TextureBrowser* textureBrowser)
1438 {
1439   if(glwidget_make_current(textureBrowser->m_gl_widget) != FALSE)
1440   {
1441     GlobalOpenGL_debugAssertNoErrors();
1442     TextureBrowser_evaluateHeight(*textureBrowser);
1443     Texture_Draw(*textureBrowser);
1444     GlobalOpenGL_debugAssertNoErrors();
1445     glwidget_swap_buffers(textureBrowser->m_gl_widget);
1446   }
1447   return FALSE;
1448 }
1449
1450
1451 TextureBrowser g_TextureBrowser;
1452
1453 TextureBrowser& GlobalTextureBrowser()
1454 {
1455   return g_TextureBrowser;
1456 }
1457
1458 bool TextureBrowser_hideUnused()
1459 {
1460   return g_TextureBrowser.m_hideUnused;
1461 }
1462
1463 void TextureBrowser_ToggleHideUnused()
1464 {
1465   if(g_TextureBrowser.m_hideUnused)
1466   {
1467     TextureBrowser_SetHideUnused(g_TextureBrowser, false);
1468   }
1469   else
1470   {
1471     TextureBrowser_SetHideUnused(g_TextureBrowser, true);
1472   }
1473 }
1474
1475 GtkWidget* TextureBrowser_constructWindow(GtkWindow* toplevel)
1476 {
1477   GlobalShaderSystem().setActiveShadersChangedNotify(ReferenceCaller<TextureBrowser, TextureBrowser_activeShadersChanged>(g_TextureBrowser));
1478
1479   GtkWidget* hbox = gtk_hbox_new (FALSE, 0);
1480
1481   g_TextureBrowser.m_parent = toplevel;
1482
1483   {
1484           GtkWidget* w = gtk_vscrollbar_new (GTK_ADJUSTMENT (gtk_adjustment_new (0,0,0,1,1,1)));
1485           gtk_widget_show (w);
1486           gtk_box_pack_end (GTK_BOX (hbox), w, FALSE, TRUE, 0);
1487           g_TextureBrowser.m_texture_scroll = w;
1488
1489     GtkAdjustment *vadjustment = gtk_range_get_adjustment (GTK_RANGE (g_TextureBrowser.m_texture_scroll));
1490     g_signal_connect(G_OBJECT(vadjustment), "value_changed", G_CALLBACK(TextureBrowser_verticalScroll), &g_TextureBrowser);
1491
1492     widget_set_visible(g_TextureBrowser.m_texture_scroll, g_TextureBrowser.m_showTextureScrollbar);
1493   }
1494   {
1495           GtkWidget* texbox = gtk_vbox_new (FALSE, 0);
1496           gtk_widget_show(texbox);
1497           gtk_box_pack_start(GTK_BOX(hbox), texbox, TRUE, TRUE, 0);
1498
1499           {
1500                   GtkEntry* entry = GTK_ENTRY(gtk_entry_new());
1501                   gtk_box_pack_start(GTK_BOX(texbox), GTK_WIDGET(entry), FALSE, FALSE, 0);
1502
1503                   g_TextureBrowser.m_filter = entry;
1504       if(g_TextureBrowser.m_showTextureFilter)
1505       {
1506         gtk_widget_show(GTK_WIDGET(g_TextureBrowser.m_filter));
1507       }
1508
1509       g_TextureBrowser.m_filterEntry.connect(entry);
1510           }
1511
1512           {
1513       g_TextureBrowser.m_gl_widget = glwidget_new(FALSE);
1514       gtk_widget_ref(g_TextureBrowser.m_gl_widget);
1515
1516       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);
1517       GTK_WIDGET_SET_FLAGS(g_TextureBrowser.m_gl_widget, GTK_CAN_FOCUS);
1518
1519                   gtk_box_pack_start(GTK_BOX(texbox), g_TextureBrowser.m_gl_widget, TRUE, TRUE, 0);
1520                   gtk_widget_show(g_TextureBrowser.m_gl_widget);
1521
1522       g_TextureBrowser.m_sizeHandler = g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "size_allocate", G_CALLBACK(TextureBrowser_size_allocate), &g_TextureBrowser);
1523       g_TextureBrowser.m_exposeHandler = g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "expose_event", G_CALLBACK(TextureBrowser_expose), &g_TextureBrowser);
1524
1525       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "button_press_event", G_CALLBACK(TextureBrowser_button_press), &g_TextureBrowser);
1526       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "button_release_event", G_CALLBACK(TextureBrowser_button_release), &g_TextureBrowser);
1527       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "motion_notify_event", G_CALLBACK(TextureBrowser_motion), &g_TextureBrowser);
1528       g_signal_connect(G_OBJECT(g_TextureBrowser.m_gl_widget), "scroll_event", G_CALLBACK(TextureBrowser_scroll), &g_TextureBrowser);
1529           }
1530         }
1531   TextureBrowser_updateScroll(g_TextureBrowser);
1532
1533   gtk_container_set_focus_chain(GTK_CONTAINER(hbox), NULL);
1534
1535   return hbox;
1536 }
1537
1538 void TextureBrowser_destroyWindow()
1539 {
1540   GlobalShaderSystem().setActiveShadersChangedNotify(Callback());
1541
1542   g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_sizeHandler);
1543   g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_exposeHandler);
1544
1545   gtk_widget_unref(g_TextureBrowser.m_gl_widget);
1546 }
1547
1548 const Vector3& TextureBrowser_getBackgroundColour(TextureBrowser& textureBrowser)
1549 {
1550   return textureBrowser.color_textureback;
1551 }
1552
1553 void TextureBrowser_setBackgroundColour(TextureBrowser& textureBrowser, const Vector3& colour)
1554 {
1555   textureBrowser.color_textureback = colour;
1556   TextureBrowser_queueDraw(textureBrowser);
1557 }
1558
1559
1560 void TextureBrowser_ToggleShowShaders() 
1561 {
1562   g_TextureBrowser.m_showShaders ^= 1;
1563   g_TexturesMenu.m_showshaders_item.update();
1564   TextureBrowser_queueDraw(g_TextureBrowser);
1565 }
1566
1567 void TextureBrowser_ToggleShowShaderListOnly() 
1568 {
1569   g_TexturesMenu_shaderlistOnly ^= 1;
1570   g_TexturesMenu.m_showshaderlistonly_item.update();
1571   TextureGroupsMenu_Destroy();
1572   TextureGroupsMenu_Construct();
1573 }
1574
1575 void TextureBrowser_showAll()
1576 {
1577   g_TextureBrowser_currentDirectory = "";
1578   TextureBrowser_heightChanged(g_TextureBrowser);
1579   TextureBrowser_updateTitle();
1580 }
1581
1582 void TextureBrowser_exportTitle(const StringImportCallback& importer)
1583 {
1584   StringOutputStream buffer(64);
1585   buffer << "Textures: ";
1586   if(!string_empty(g_TextureBrowser_currentDirectory.c_str()))
1587   {
1588     buffer << g_TextureBrowser_currentDirectory.c_str();
1589   }
1590   else
1591   {
1592     buffer << "all";
1593   }
1594   importer(buffer.c_str());
1595 }
1596
1597
1598 void TextureScaleImport(TextureBrowser& textureBrowser, int value)
1599 {
1600   switch(value)
1601   {
1602   case 0:
1603     TextureBrowser_setScale(textureBrowser, 10);
1604     break;
1605   case 1:
1606     TextureBrowser_setScale(textureBrowser, 25);
1607     break;
1608   case 2:
1609     TextureBrowser_setScale(textureBrowser, 50);
1610     break;
1611   case 3:
1612     TextureBrowser_setScale(textureBrowser, 100);
1613     break;
1614   case 4:
1615     TextureBrowser_setScale(textureBrowser, 200);
1616     break;
1617   }
1618 }
1619 typedef ReferenceCaller1<TextureBrowser, int, TextureScaleImport> TextureScaleImportCaller;
1620
1621 void TextureScaleExport(TextureBrowser& textureBrowser, const IntImportCallback& importer)
1622 {
1623   switch(textureBrowser.m_textureScale)
1624   {
1625   case 10:
1626     importer(0);
1627     break;
1628   case 25:
1629     importer(1);
1630     break;
1631   case 50:
1632     importer(2);
1633     break;
1634   case 100:
1635     importer(3);
1636     break;
1637   case 200:
1638     importer(4);
1639     break;
1640   }
1641 }
1642 typedef ReferenceCaller1<TextureBrowser, const IntImportCallback&, TextureScaleExport> TextureScaleExportCaller;
1643
1644 void TextureBrowser_constructPreferences(PreferencesPage& page)
1645 {
1646   page.appendCheckBox(
1647     "", "Texture subsets",
1648     TextureBrowserImportShowFilterCaller(GlobalTextureBrowser()),
1649     BoolExportCaller(GlobalTextureBrowser().m_showTextureFilter)
1650   );
1651   page.appendCheckBox(
1652     "", "Texture scrollbar",
1653     TextureBrowserImportShowScrollbarCaller(GlobalTextureBrowser()),
1654     BoolExportCaller(GlobalTextureBrowser().m_showTextureScrollbar)
1655   );
1656   {
1657     const char* texture_scale[] = { "10%", "25%", "50%", "100%", "200%" };
1658     page.appendCombo(
1659       "Texture Thumbnail Scale",
1660       STRING_ARRAY_RANGE(texture_scale),
1661       IntImportCallback(TextureScaleImportCaller(GlobalTextureBrowser())),
1662       IntExportCallback(TextureScaleExportCaller(GlobalTextureBrowser()))
1663     );
1664   }
1665   page.appendEntry("Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement);
1666   {
1667     const char* startup_shaders[] = { "None", TextureBrowser_getComonShadersName(), "All" };
1668     page.appendCombo("Load Shaders at Startup", reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders), STRING_ARRAY_RANGE(startup_shaders));
1669   }
1670 }
1671 void TextureBrowser_constructPage(PreferenceGroup& group)
1672 {
1673   PreferencesPage page(group.createPage("Texture Browser", "Texture Browser Preferences"));
1674   TextureBrowser_constructPreferences(page);
1675 }
1676 void TextureBrowser_registerPreferencesPage()
1677 {
1678   PreferencesDialog_addSettingsPage(FreeCaller1<PreferenceGroup&, TextureBrowser_constructPage>());
1679 }
1680
1681
1682 #include "preferencesystem.h"
1683 #include "stringio.h"
1684
1685 typedef ReferenceCaller1<TextureBrowser, std::size_t, TextureBrowser_setScale> TextureBrowserSetScaleCaller;
1686
1687
1688
1689 void TextureClipboard_textureSelected(const char* shader);
1690
1691 void TextureBrowser_Construct()
1692 {
1693   GlobalToggles_insert("ShowInUse", FreeCaller<TextureBrowser_ToggleHideUnused>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_hideunused_item), Accelerator('U'));
1694   GlobalCommands_insert("ShowAllTextures", FreeCaller<TextureBrowser_showAll>(), Accelerator('A', (GdkModifierType)GDK_CONTROL_MASK));
1695   GlobalCommands_insert("ViewTextures", FreeCaller<TextureBrowser_toggleShown>(), Accelerator('T'));
1696   GlobalToggles_insert("ToggleShowShaders", FreeCaller<TextureBrowser_ToggleShowShaders>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_showshaders_item));
1697   GlobalToggles_insert("ToggleShowShaderlistOnly", FreeCaller<TextureBrowser_ToggleShowShaderListOnly>(), ToggleItem::AddCallbackCaller(g_TexturesMenu.m_showshaderlistonly_item));
1698
1699   GlobalPreferenceSystem().registerPreference("TextureScale",
1700     makeSizeStringImportCallback(TextureBrowserSetScaleCaller(g_TextureBrowser)),
1701     SizeExportStringCaller(g_TextureBrowser.m_textureScale)
1702   );
1703   GlobalPreferenceSystem().registerPreference("NewTextureWindowStuff",
1704     makeBoolStringImportCallback(TextureBrowserImportShowFilterCaller(g_TextureBrowser)),
1705     BoolExportStringCaller(GlobalTextureBrowser().m_showTextureFilter)
1706   );
1707   GlobalPreferenceSystem().registerPreference("TextureScrollbar",
1708     makeBoolStringImportCallback(TextureBrowserImportShowScrollbarCaller(g_TextureBrowser)),
1709     BoolExportStringCaller(GlobalTextureBrowser().m_showTextureScrollbar)
1710   );
1711   GlobalPreferenceSystem().registerPreference("ShowShaders", BoolImportStringCaller(GlobalTextureBrowser().m_showShaders), BoolExportStringCaller(GlobalTextureBrowser().m_showShaders));
1712   GlobalPreferenceSystem().registerPreference("ShowShaderlistOnly", BoolImportStringCaller(g_TexturesMenu_shaderlistOnly), BoolExportStringCaller(g_TexturesMenu_shaderlistOnly));
1713   GlobalPreferenceSystem().registerPreference("LoadShaders", IntImportStringCaller(reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders)), IntExportStringCaller(reinterpret_cast<int&>(GlobalTextureBrowser().m_startupShaders)));
1714   GlobalPreferenceSystem().registerPreference("WheelMouseInc", SizeImportStringCaller(GlobalTextureBrowser().m_mouseWheelScrollIncrement), SizeExportStringCaller(GlobalTextureBrowser().m_mouseWheelScrollIncrement));
1715   GlobalPreferenceSystem().registerPreference("SI_Colors0", Vector3ImportStringCaller(GlobalTextureBrowser().color_textureback), Vector3ExportStringCaller(GlobalTextureBrowser().color_textureback));
1716
1717   g_TextureBrowser.shader = texdef_name_default();
1718
1719   Textures_setModeChangedNotify(ReferenceCaller<TextureBrowser, TextureBrowser_queueDraw>(g_TextureBrowser));
1720
1721   TextureBrowser_registerPreferencesPage();
1722
1723   GlobalShaderSystem().attach(g_ShadersObserver);
1724   GlobalShaderSystem().attach(g_TextureGroupsMenu);
1725   GlobalFileSystem().attach(g_TextureGroupsMenu);
1726
1727   TextureBrowser_textureSelected = TextureClipboard_textureSelected;
1728 }
1729 void TextureBrowser_Destroy()
1730 {
1731   GlobalFileSystem().detach(g_TextureGroupsMenu);
1732   GlobalShaderSystem().detach(g_TextureGroupsMenu);
1733   GlobalShaderSystem().detach(g_ShadersObserver);
1734
1735   Textures_setModeChangedNotify(Callback());
1736 }