2 Copyright (C) 1999-2006 Id Software, Inc. and contributors.
3 For a list of contributors, see the accompanying CONTRIBUTORS file.
5 This file is part of GtkRadiant.
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.
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.
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
25 // Leonardo Zide (leo@lokigames.com)
28 #include "texwindow.h"
32 #include "debugging/debugging.h"
35 #include "ifilesystem.h"
39 #include "moduleobserver.h"
45 #include <uilib/uilib.h>
47 #include "signal/signal.h"
48 #include "math/vector.h"
49 #include "texturelib.h"
50 #include "string/string.h"
51 #include "shaderlib.h"
54 #include "stream/memstream.h"
55 #include "stream/textfilestream.h"
56 #include "stream/stringstream.h"
62 #include "gtkutil/menu.h"
63 #include "gtkutil/nonmodal.h"
64 #include "gtkutil/cursor.h"
65 #include "gtkutil/widget.h"
66 #include "gtkutil/glwidget.h"
67 #include "gtkutil/messagebox.h"
73 #include "brush_primit.h"
74 #include "brushmanip.h"
75 #include "patchmanip.h"
80 #include "mainframe.h"
81 #include "findtexturedialog.h"
82 #include "surfacedialog.h"
83 #include "patchdialog.h"
84 #include "groupdialog.h"
85 #include "preferences.h"
89 #define NOTEX_BASENAME "notex"
90 #define SHADERNOTEX_BASENAME "shadernotex"
92 bool TextureBrowser_showWads()
94 return !string_empty(g_pGameDescription->getKeyValue("show_wads"));
97 void TextureBrowser_queueDraw(TextureBrowser &textureBrowser);
99 bool string_equal_start(const char *string, StringRange start)
101 return string_equal_n(string, start.first, start.last - start.first);
104 typedef std::set<CopiedString> TextureGroups;
106 void TextureGroups_addWad(TextureGroups &groups, const char *archive)
108 if (extension_equal(path_get_extension(archive), "wad")) {
110 groups.insert(archive);
112 CopiedString archiveBaseName( path_get_filename_start( archive ), path_get_filename_base_end( archive ) );
113 groups.insert( archiveBaseName );
118 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addWad> TextureGroupsAddWadCaller;
121 bool g_TextureBrowser_shaderlistOnly = false;
122 bool g_TextureBrowser_fixedSize = true;
123 bool g_TextureBrowser_filterMissing = false;
124 bool g_TextureBrowser_filterFallback = true;
125 bool g_TextureBrowser_enableAlpha = true;
128 CopiedString g_notex;
129 CopiedString g_shadernotex;
131 bool isMissing(const char *name);
133 bool isNotex(const char *name);
135 bool isMissing(const char *name)
137 if (string_equal(g_notex.c_str(), name)) {
140 if (string_equal(g_shadernotex.c_str(), name)) {
146 bool isNotex(const char *name)
148 if (string_equal_suffix(name, "/" NOTEX_BASENAME)) {
151 if (string_equal_suffix(name, "/" SHADERNOTEX_BASENAME)) {
157 void TextureGroups_addShader(TextureGroups &groups, const char *shaderName)
159 const char *texture = path_make_relative(shaderName, "textures/");
161 // hide notex / shadernotex images
162 if (g_TextureBrowser_filterFallback) {
163 if (isNotex(shaderName)) {
166 if (isNotex(texture)) {
171 if (texture != shaderName) {
172 const char *last = path_remove_directory(texture);
173 if (!string_empty(last)) {
174 groups.insert(CopiedString(StringRange(texture, --last)));
179 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addShader> TextureGroupsAddShaderCaller;
181 void TextureGroups_addDirectory(TextureGroups &groups, const char *directory)
183 groups.insert(directory);
186 typedef ReferenceCaller<TextureGroups, void(const char *), TextureGroups_addDirectory> TextureGroupsAddDirectoryCaller;
188 class DeferredAdjustment {
192 typedef void ( *ValueChangedFunction )(void *data, gdouble value);
194 ValueChangedFunction m_function;
197 static gboolean deferred_value_changed(gpointer data)
199 reinterpret_cast<DeferredAdjustment *>( data )->m_function(
200 reinterpret_cast<DeferredAdjustment *>( data )->m_data,
201 reinterpret_cast<DeferredAdjustment *>( data )->m_value
203 reinterpret_cast<DeferredAdjustment *>( data )->m_handler = 0;
204 reinterpret_cast<DeferredAdjustment *>( data )->m_value = 0;
209 DeferredAdjustment(ValueChangedFunction function, void *data) : m_value(0), m_handler(0), m_function(function),
216 if (m_handler != 0) {
217 g_source_remove(m_handler);
218 deferred_value_changed(this);
222 void value_changed(gdouble value)
225 if (m_handler == 0) {
226 m_handler = g_idle_add(deferred_value_changed, this);
230 static void adjustment_value_changed(ui::Adjustment adjustment, DeferredAdjustment *self)
232 self->value_changed(gtk_adjustment_get_value(adjustment));
237 class TextureBrowser;
239 typedef ReferenceCaller<TextureBrowser, void(), TextureBrowser_queueDraw> TextureBrowserQueueDrawCaller;
241 void TextureBrowser_scrollChanged(void *data, gdouble value);
244 enum StartupShaders {
245 STARTUPSHADERS_NONE = 0,
246 STARTUPSHADERS_COMMON,
249 void TextureBrowser_hideUnusedExport(const Callback<void(bool)> &importer);
251 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
253 void TextureBrowser_showShadersExport(const Callback<void(bool)> &importer);
255 typedef FreeCaller<void(
256 const Callback<void(bool)> &), TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
258 void TextureBrowser_showShaderlistOnly(const Callback<void(bool)> &importer);
260 typedef FreeCaller<void(
261 const Callback<void(bool)> &), TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
263 void TextureBrowser_fixedSize(const Callback<void(bool)> &importer);
265 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_fixedSize> TextureBrowserFixedSizeExport;
267 void TextureBrowser_filterMissing(const Callback<void(bool)> &importer);
269 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_filterMissing> TextureBrowserFilterMissingExport;
271 void TextureBrowser_filterFallback(const Callback<void(bool)> &importer);
273 typedef FreeCaller<void(
274 const Callback<void(bool)> &), TextureBrowser_filterFallback> TextureBrowserFilterFallbackExport;
276 void TextureBrowser_enableAlpha(const Callback<void(bool)> &importer);
278 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_enableAlpha> TextureBrowserEnableAlphaExport;
280 class TextureBrowser {
288 ui::Window m_parent{ui::null};
289 ui::GLArea m_gl_widget{ui::null};
290 ui::Widget m_texture_scroll{ui::null};
291 ui::TreeView m_treeViewTree{ui::New};
292 ui::TreeView m_treeViewTags{ui::null};
293 ui::Frame m_tag_frame{ui::null};
294 ui::ListStore m_assigned_store{ui::null};
295 ui::ListStore m_available_store{ui::null};
296 ui::TreeView m_assigned_tree{ui::null};
297 ui::TreeView m_available_tree{ui::null};
298 ui::Widget m_scr_win_tree{ui::null};
299 ui::Widget m_scr_win_tags{ui::null};
300 ui::Widget m_tag_notebook{ui::null};
301 ui::Button m_search_button{ui::null};
302 ui::Widget m_shader_info_item{ui::null};
304 std::set<CopiedString> m_all_tags;
305 ui::ListStore m_all_tags_list{ui::null};
306 std::vector<CopiedString> m_copied_tags;
307 std::set<CopiedString> m_found_shaders;
309 ToggleItem m_hideunused_item;
310 ToggleItem m_hidenotex_item;
311 ToggleItem m_showshaders_item;
312 ToggleItem m_showshaderlistonly_item;
313 ToggleItem m_fixedsize_item;
314 ToggleItem m_filternotex_item;
315 ToggleItem m_enablealpha_item;
318 guint m_exposeHandler;
320 bool m_heightChanged;
321 bool m_originInvalid;
323 DeferredAdjustment m_scrollAdjustment;
324 FreezePointer m_freezePointer;
326 Vector3 color_textureback;
327 // the increment step we use against the wheel mouse
328 std::size_t m_mouseWheelScrollIncrement;
329 std::size_t m_textureScale;
330 // make the texture increments match the grid changes
332 bool m_showTextureScrollbar;
333 StartupShaders m_startupShaders;
334 // if true, the texture window will only display in-use shaders
335 // if false, all the shaders in memory are displayed
340 // The uniform size (in pixels) that textures are resized to when m_resizeTextures is true.
341 int m_uniformTextureSize;
343 // Return the display width of a texture in the texture browser
344 int getTextureWidth(qtexture_t *tex)
347 if (!g_TextureBrowser_fixedSize) {
348 // Don't use uniform size
349 width = (int) (tex->width * ((float) m_textureScale / 100));
351 (tex->width >= tex->height) {
352 // Texture is square, or wider than it is tall
353 width = m_uniformTextureSize;
355 // Otherwise, preserve the texture's aspect ratio
356 width = (int) (m_uniformTextureSize * ((float) tex->width / tex->height));
361 // Return the display height of a texture in the texture browser
362 int getTextureHeight(qtexture_t *tex)
365 if (!g_TextureBrowser_fixedSize) {
366 // Don't use uniform size
367 height = (int) (tex->height * ((float) m_textureScale / 100));
368 } else if (tex->height >= tex->width) {
369 // Texture is square, or taller than it is wide
370 height = m_uniformTextureSize;
372 // Otherwise, preserve the texture's aspect ratio
373 height = (int) (m_uniformTextureSize * ((float) tex->height / tex->width));
379 m_texture_scroll(ui::null),
380 m_hideunused_item(TextureBrowserHideUnusedExport()),
381 m_hidenotex_item(TextureBrowserFilterFallbackExport()),
382 m_showshaders_item(TextureBrowserShowShadersExport()),
383 m_showshaderlistonly_item(TextureBrowserShowShaderlistOnlyExport()),
384 m_fixedsize_item(TextureBrowserFixedSizeExport()),
385 m_filternotex_item(TextureBrowserFilterMissingExport()),
386 m_enablealpha_item(TextureBrowserEnableAlphaExport()),
387 m_heightChanged(true),
388 m_originInvalid(true),
389 m_scrollAdjustment(TextureBrowser_scrollChanged, this),
390 color_textureback(0.25f, 0.25f, 0.25f),
391 m_mouseWheelScrollIncrement(64),
394 m_showTextureScrollbar(true),
395 m_startupShaders(STARTUPSHADERS_NONE),
397 m_rmbSelected(false),
398 m_searchedTags(false),
400 m_uniformTextureSize(96)
405 void ( *TextureBrowser_textureSelected )(const char *shader);
408 void TextureBrowser_updateScroll(TextureBrowser &textureBrowser);
411 const char *TextureBrowser_getComonShadersName()
413 const char *value = g_pGameDescription->getKeyValue("common_shaders_name");
414 if (!string_empty(value)) {
420 const char *TextureBrowser_getComonShadersDir()
422 const char *value = g_pGameDescription->getKeyValue("common_shaders_dir");
423 if (!string_empty(value)) {
429 inline int TextureBrowser_fontHeight(TextureBrowser &textureBrowser)
431 return GlobalOpenGL().m_font->getPixelHeight();
434 const char *TextureBrowser_GetSelectedShader(TextureBrowser &textureBrowser)
436 return textureBrowser.shader.c_str();
439 void TextureBrowser_SetStatus(TextureBrowser &textureBrowser, const char *name)
441 IShader *shader = QERApp_Shader_ForName(name);
442 qtexture_t *q = shader->getTexture();
443 StringOutputStream strTex(256);
444 strTex << name << " W: " << Unsigned(q->width) << " H: " << Unsigned(q->height);
446 g_pParentWnd->SetStatusText(g_pParentWnd->m_texture_status, strTex.c_str());
449 void TextureBrowser_Focus(TextureBrowser &textureBrowser, const char *name);
451 void TextureBrowser_SetSelectedShader(TextureBrowser &textureBrowser, const char *shader)
453 textureBrowser.shader = shader;
454 TextureBrowser_SetStatus(textureBrowser, shader);
455 TextureBrowser_Focus(textureBrowser, shader);
457 if (FindTextureDialog_isOpen()) {
458 FindTextureDialog_selectTexture(shader);
461 // disable the menu item "shader info" if no shader was selected
462 IShader *ishader = QERApp_Shader_ForName(shader);
463 CopiedString filename = ishader->getShaderFileName();
465 if (filename.empty()) {
466 if (textureBrowser.m_shader_info_item != NULL) {
467 gtk_widget_set_sensitive(textureBrowser.m_shader_info_item, FALSE);
470 gtk_widget_set_sensitive(textureBrowser.m_shader_info_item, TRUE);
477 CopiedString g_TextureBrowser_currentDirectory;
480 ============================================================================
484 TTimo: now based on a rundown through all the shaders
485 NOTE: we expect the Active shaders count doesn't change during a Texture_StartPos .. Texture_NextPos cycle
486 otherwise we may need to rely on a list instead of an array storage
487 ============================================================================
490 class TextureLayout {
492 // texture layout functions
493 // TTimo: now based on shaders
494 int current_x, current_y, current_row;
497 void Texture_StartPos(TextureLayout &layout)
499 layout.current_x = 8;
500 layout.current_y = -8;
501 layout.current_row = 0;
504 void Texture_NextPos(TextureBrowser &textureBrowser, TextureLayout &layout, qtexture_t *current_texture, int *x, int *y)
506 qtexture_t *q = current_texture;
508 int nWidth = textureBrowser.getTextureWidth(q);
509 int nHeight = textureBrowser.getTextureHeight(q);
510 if (layout.current_x + nWidth > textureBrowser.width - 8 &&
511 layout.current_row) { // go to the next row unless the texture is the first on the row
512 layout.current_x = 8;
513 layout.current_y -= layout.current_row + TextureBrowser_fontHeight(textureBrowser) + 4;
514 layout.current_row = 0;
517 *x = layout.current_x;
518 *y = layout.current_y;
520 // Is our texture larger than the row? If so, grow the
521 // row height to match it
523 if (layout.current_row < nHeight) {
524 layout.current_row = nHeight;
527 // never go less than 96, or the names get all crunched up
528 layout.current_x += nWidth < 96 ? 96 : nWidth;
529 layout.current_x += 8;
532 bool TextureSearch_IsShown(const char *name)
534 std::set<CopiedString>::iterator iter;
536 iter = GlobalTextureBrowser().m_found_shaders.find(name);
538 if (iter == GlobalTextureBrowser().m_found_shaders.end()) {
545 // if texture_showinuse jump over non in-use textures
546 bool Texture_IsShown(IShader *shader, bool show_shaders, bool hideUnused)
548 // filter missing shaders
549 // ugly: filter on built-in fallback name after substitution
550 if (g_TextureBrowser_filterMissing) {
551 if (isMissing(shader->getTexture()->name)) {
555 // filter the fallback (notex/shadernotex) for missing shaders or editor image
556 if (g_TextureBrowser_filterFallback) {
557 if (isNotex(shader->getName())) {
560 if (isNotex(shader->getTexture()->name)) {
565 if (g_TextureBrowser_currentDirectory == "Untagged") {
566 std::set<CopiedString>::iterator iter;
568 iter = GlobalTextureBrowser().m_found_shaders.find(shader->getName());
570 if (iter == GlobalTextureBrowser().m_found_shaders.end()) {
577 if (!shader_equal_prefix(shader->getName(), "textures/")) {
581 if (!show_shaders && !shader->IsDefault()) {
585 if (hideUnused && !shader->IsInUse()) {
589 if (GlobalTextureBrowser().m_searchedTags) {
590 if (!TextureSearch_IsShown(shader->getName())) {
596 if (!shader_equal_prefix(shader_get_textureName(shader->getName()),
597 g_TextureBrowser_currentDirectory.c_str())) {
605 void TextureBrowser_heightChanged(TextureBrowser &textureBrowser)
607 textureBrowser.m_heightChanged = true;
609 TextureBrowser_updateScroll(textureBrowser);
610 TextureBrowser_queueDraw(textureBrowser);
613 void TextureBrowser_evaluateHeight(TextureBrowser &textureBrowser)
615 if (textureBrowser.m_heightChanged) {
616 textureBrowser.m_heightChanged = false;
618 textureBrowser.m_nTotalHeight = 0;
620 TextureLayout layout;
621 Texture_StartPos(layout);
622 for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
623 IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
625 if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
630 Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
631 textureBrowser.m_nTotalHeight = std::max(textureBrowser.m_nTotalHeight,
632 abs(layout.current_y) + TextureBrowser_fontHeight(textureBrowser) +
633 textureBrowser.getTextureHeight(shader->getTexture()) + 4);
638 int TextureBrowser_TotalHeight(TextureBrowser &textureBrowser)
640 TextureBrowser_evaluateHeight(textureBrowser);
641 return textureBrowser.m_nTotalHeight;
644 inline const int &min_int(const int &left, const int &right)
646 return std::min(left, right);
649 void TextureBrowser_clampOriginY(TextureBrowser &textureBrowser)
651 if (textureBrowser.originy > 0) {
652 textureBrowser.originy = 0;
654 int lower = min_int(textureBrowser.height - TextureBrowser_TotalHeight(textureBrowser), 0);
655 if (textureBrowser.originy < lower) {
656 textureBrowser.originy = lower;
660 int TextureBrowser_getOriginY(TextureBrowser &textureBrowser)
662 if (textureBrowser.m_originInvalid) {
663 textureBrowser.m_originInvalid = false;
664 TextureBrowser_clampOriginY(textureBrowser);
665 TextureBrowser_updateScroll(textureBrowser);
667 return textureBrowser.originy;
670 void TextureBrowser_setOriginY(TextureBrowser &textureBrowser, int originy)
672 textureBrowser.originy = originy;
673 TextureBrowser_clampOriginY(textureBrowser);
674 TextureBrowser_updateScroll(textureBrowser);
675 TextureBrowser_queueDraw(textureBrowser);
679 Signal0 g_activeShadersChangedCallbacks;
681 void TextureBrowser_addActiveShadersChangedCallback(const SignalHandler &handler)
683 g_activeShadersChangedCallbacks.connectLast(handler);
686 void TextureBrowser_constructTreeStore();
688 class ShadersObserver : public ModuleObserver {
689 Signal0 m_realiseCallbacks;
693 m_realiseCallbacks();
694 TextureBrowser_constructTreeStore();
701 void insert(const SignalHandler &handler)
703 m_realiseCallbacks.connectLast(handler);
708 ShadersObserver g_ShadersObserver;
711 void TextureBrowser_addShadersRealiseCallback(const SignalHandler &handler)
713 g_ShadersObserver.insert(handler);
716 void TextureBrowser_activeShadersChanged(TextureBrowser &textureBrowser)
718 TextureBrowser_heightChanged(textureBrowser);
719 textureBrowser.m_originInvalid = true;
721 g_activeShadersChangedCallbacks();
724 struct TextureBrowser_ShowScrollbar {
725 static void Export(const TextureBrowser &self, const Callback<void(bool)> &returnz)
727 returnz(self.m_showTextureScrollbar);
730 static void Import(TextureBrowser &self, bool value)
732 self.m_showTextureScrollbar = value;
733 if (self.m_texture_scroll) {
734 self.m_texture_scroll.visible(self.m_showTextureScrollbar);
735 TextureBrowser_updateScroll(self);
743 TextureBrowser_ShowDirectory
744 relies on texture_directory global for the directory to use
745 1) Load the shaders for the given directory
746 2) Scan the remaining texture, load them and assign them a default shader (the "noshader" shader)
747 NOTE: when writing a texture plugin, or some texture extensions, this function may need to be overriden, and made
748 available through the IShaders interface
749 NOTE: for texture window layout:
750 all shaders are stored with alphabetical order after load
751 previously loaded and displayed stuff is hidden, only in-use and newly loaded is shown
752 ( the GL textures are not flushed though)
756 bool endswith(const char *haystack, const char *needle)
758 size_t lh = strlen(haystack);
759 size_t ln = strlen(needle);
763 return !memcmp(haystack + (lh - ln), needle, ln);
766 bool texture_name_ignore(const char *name)
768 StringOutputStream strTemp(string_length(name));
769 strTemp << LowerCase(name);
772 endswith(strTemp.c_str(), ".specular") ||
773 endswith(strTemp.c_str(), ".glow") ||
774 endswith(strTemp.c_str(), ".bump") ||
775 endswith(strTemp.c_str(), ".diffuse") ||
776 endswith(strTemp.c_str(), ".blend") ||
777 endswith(strTemp.c_str(), ".alpha") ||
778 endswith(strTemp.c_str(), "_alpha") ||
780 endswith(strTemp.c_str(), "_h") ||
781 endswith(strTemp.c_str(), "_local") ||
782 endswith(strTemp.c_str(), "_nm") ||
783 endswith(strTemp.c_str(), "_s") ||
785 endswith(strTemp.c_str(), "_bump") ||
786 endswith(strTemp.c_str(), "_glow") ||
787 endswith(strTemp.c_str(), "_gloss") ||
788 endswith(strTemp.c_str(), "_luma") ||
789 endswith(strTemp.c_str(), "_norm") ||
790 endswith(strTemp.c_str(), "_pants") ||
791 endswith(strTemp.c_str(), "_shirt") ||
792 endswith(strTemp.c_str(), "_reflect") ||
794 endswith(strTemp.c_str(), "_d") ||
795 endswith(strTemp.c_str(), "_n") ||
796 endswith(strTemp.c_str(), "_p") ||
797 endswith(strTemp.c_str(), "_g") ||
798 endswith(strTemp.c_str(), "_a") ||
802 class LoadShaderVisitor : public Archive::Visitor {
804 void visit(const char *name)
806 IShader *shader = QERApp_Shader_ForName(
807 CopiedString(StringRange(name, path_get_filename_base_end(name))).c_str());
812 void TextureBrowser_SetHideUnused(TextureBrowser &textureBrowser, bool hideUnused);
814 ui::Widget g_page_textures{ui::null};
816 void TextureBrowser_toggleShow()
818 GroupDialog_showPage(g_page_textures);
822 void TextureBrowser_updateTitle()
824 GroupDialog_updatePageTitle(g_page_textures);
828 class TextureCategoryLoadShader {
829 const char *m_directory;
830 std::size_t &m_count;
832 using func = void(const char *);
834 TextureCategoryLoadShader(const char *directory, std::size_t &count)
835 : m_directory(directory), m_count(count)
840 void operator()(const char *name) const
842 if (shader_equal_prefix(name, "textures/")
843 && shader_equal_prefix(name + string_length("textures/"), m_directory)) {
845 // request the shader, this will load the texture if needed
846 // this Shader_ForName call is a kind of hack
847 IShader *pFoo = QERApp_Shader_ForName(name);
853 void TextureDirectory_loadTexture(const char *directory, const char *texture)
855 StringOutputStream name(256);
856 name << directory << StringRange(texture, path_get_filename_base_end(texture));
858 if (texture_name_ignore(name.c_str())) {
862 if (!shader_valid(name.c_str())) {
863 globalOutputStream() << "Skipping invalid texture name: [" << name.c_str() << "]\n";
867 // if a texture is already in use to represent a shader, ignore it
868 IShader *shader = QERApp_Shader_ForName(name.c_str());
872 typedef ConstPointerCaller<char, void(const char *), TextureDirectory_loadTexture> TextureDirectoryLoadTextureCaller;
874 class LoadTexturesByTypeVisitor : public ImageModules::Visitor {
875 const char *m_dirstring;
877 LoadTexturesByTypeVisitor(const char *dirstring)
878 : m_dirstring(dirstring)
882 void visit(const char *minor, const _QERPlugImageTable &table) const
884 GlobalFileSystem().forEachFile(m_dirstring, minor, TextureDirectoryLoadTextureCaller(m_dirstring));
888 void TextureBrowser_ShowDirectory(TextureBrowser &textureBrowser, const char *directory)
890 if (TextureBrowser_showWads()) {
891 Archive *archive = GlobalFileSystem().getArchive(directory);
892 ASSERT_NOTNULL(archive);
893 LoadShaderVisitor visitor;
894 archive->forEachFile(Archive::VisitorFunc(visitor, Archive::eFiles, 0), "textures/");
896 g_TextureBrowser_currentDirectory = directory;
897 TextureBrowser_heightChanged(textureBrowser);
899 std::size_t shaders_count;
900 GlobalShaderSystem().foreachShaderName(makeCallback(TextureCategoryLoadShader(directory, shaders_count)));
901 globalOutputStream() << "Showing " << Unsigned(shaders_count) << " shaders.\n";
903 if (g_pGameDescription->mGameType != "doom3") {
904 // load remaining texture files
906 StringOutputStream dirstring(64);
907 dirstring << "textures/" << directory;
909 Radiant_getImageModules().foreachModule(LoadTexturesByTypeVisitor(dirstring.c_str()));
913 // we'll display the newly loaded textures + all the ones already in use
914 TextureBrowser_SetHideUnused(textureBrowser, false);
916 TextureBrowser_updateTitle();
919 void TextureBrowser_ShowTagSearchResult(TextureBrowser &textureBrowser, const char *directory)
921 g_TextureBrowser_currentDirectory = directory;
922 TextureBrowser_heightChanged(textureBrowser);
924 std::size_t shaders_count;
925 GlobalShaderSystem().foreachShaderName(makeCallback(TextureCategoryLoadShader(directory, shaders_count)));
926 globalOutputStream() << "Showing " << Unsigned(shaders_count) << " shaders.\n";
928 if (g_pGameDescription->mGameType != "doom3") {
929 // load remaining texture files
930 StringOutputStream dirstring(64);
931 dirstring << "textures/" << directory;
934 LoadTexturesByTypeVisitor visitor(dirstring.c_str());
935 Radiant_getImageModules().foreachModule(visitor);
939 // we'll display the newly loaded textures + all the ones already in use
940 TextureBrowser_SetHideUnused(textureBrowser, false);
944 bool TextureBrowser_hideUnused();
946 void TextureBrowser_hideUnusedExport(const Callback<void(bool)> &importer)
948 importer(TextureBrowser_hideUnused());
951 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_hideUnusedExport> TextureBrowserHideUnusedExport;
953 void TextureBrowser_showShadersExport(const Callback<void(bool)> &importer)
955 importer(GlobalTextureBrowser().m_showShaders);
958 typedef FreeCaller<void(
959 const Callback<void(bool)> &), TextureBrowser_showShadersExport> TextureBrowserShowShadersExport;
961 void TextureBrowser_showShaderlistOnly(const Callback<void(bool)> &importer)
963 importer(g_TextureBrowser_shaderlistOnly);
966 typedef FreeCaller<void(
967 const Callback<void(bool)> &), TextureBrowser_showShaderlistOnly> TextureBrowserShowShaderlistOnlyExport;
969 void TextureBrowser_fixedSize(const Callback<void(bool)> &importer)
971 importer(g_TextureBrowser_fixedSize);
974 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_fixedSize> TextureBrowser_FixedSizeExport;
976 void TextureBrowser_filterMissing(const Callback<void(bool)> &importer)
978 importer(g_TextureBrowser_filterMissing);
981 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_filterMissing> TextureBrowser_filterMissingExport;
983 void TextureBrowser_filterFallback(const Callback<void(bool)> &importer)
985 importer(g_TextureBrowser_filterFallback);
988 typedef FreeCaller<void(
989 const Callback<void(bool)> &), TextureBrowser_filterFallback> TextureBrowser_filterFallbackExport;
991 void TextureBrowser_enableAlpha(const Callback<void(bool)> &importer)
993 importer(g_TextureBrowser_enableAlpha);
996 typedef FreeCaller<void(const Callback<void(bool)> &), TextureBrowser_enableAlpha> TextureBrowser_enableAlphaExport;
998 void TextureBrowser_SetHideUnused(TextureBrowser &textureBrowser, bool hideUnused)
1001 textureBrowser.m_hideUnused = true;
1003 textureBrowser.m_hideUnused = false;
1006 textureBrowser.m_hideunused_item.update();
1008 TextureBrowser_heightChanged(textureBrowser);
1009 textureBrowser.m_originInvalid = true;
1012 void TextureBrowser_ShowStartupShaders(TextureBrowser &textureBrowser)
1014 if (textureBrowser.m_startupShaders == STARTUPSHADERS_COMMON) {
1015 TextureBrowser_ShowDirectory(textureBrowser, TextureBrowser_getComonShadersDir());
1020 //++timo NOTE: this is a mix of Shader module stuff and texture explorer
1021 // it might need to be split in parts or moved out .. dunno
1022 // scroll origin so the specified texture is completely on screen
1023 // if current texture is not displayed, nothing is changed
1024 void TextureBrowser_Focus(TextureBrowser &textureBrowser, const char *name)
1026 TextureLayout layout;
1027 // scroll origin so the texture is completely on screen
1028 Texture_StartPos(layout);
1030 for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1031 IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1033 if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1038 Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1039 qtexture_t *q = shader->getTexture();
1044 // we have found when texdef->name and the shader name match
1045 // NOTE: as everywhere else for our comparisons, we are not case sensitive
1046 if (shader_equal(name, shader->getName())) {
1047 int textureHeight = (int) (q->height * ((float) textureBrowser.m_textureScale / 100))
1048 + 2 * TextureBrowser_fontHeight(textureBrowser);
1050 int originy = TextureBrowser_getOriginY(textureBrowser);
1055 if (y - textureHeight < originy - textureBrowser.height) {
1056 originy = (y - textureHeight) + textureBrowser.height;
1059 TextureBrowser_setOriginY(textureBrowser, originy);
1065 IShader *Texture_At(TextureBrowser &textureBrowser, int mx, int my)
1067 my += TextureBrowser_getOriginY(textureBrowser) - textureBrowser.height;
1069 TextureLayout layout;
1070 Texture_StartPos(layout);
1071 for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1072 IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1074 if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1079 Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1080 qtexture_t *q = shader->getTexture();
1085 int nWidth = textureBrowser.getTextureWidth(q);
1086 int nHeight = textureBrowser.getTextureHeight(q);
1087 if (mx > x && mx - x < nWidth
1088 && my < y && y - my < nHeight + TextureBrowser_fontHeight(textureBrowser)) {
1103 void SelectTexture(TextureBrowser &textureBrowser, int mx, int my, bool bShift)
1105 IShader *shader = Texture_At(textureBrowser, mx, my);
1108 if (shader->IsDefault()) {
1109 globalOutputStream() << "ERROR: " << shader->getName() << " is not a shader, it's a texture.\n";
1111 ViewShader(shader->getShaderFileName(), shader->getName());
1114 TextureBrowser_SetSelectedShader(textureBrowser, shader->getName());
1115 TextureBrowser_textureSelected(shader->getName());
1117 if (!FindTextureDialog_isOpen() && !textureBrowser.m_rmbSelected) {
1118 UndoableCommand undo("textureNameSetSelected");
1119 Select_SetShader(shader->getName());
1126 ============================================================================
1130 ============================================================================
1133 void TextureBrowser_trackingDelta(int x, int y, unsigned int state, void *data)
1135 TextureBrowser &textureBrowser = *reinterpret_cast<TextureBrowser *>( data );
1139 if (state & GDK_SHIFT_MASK) {
1143 int originy = TextureBrowser_getOriginY(textureBrowser);
1144 originy += y * scale;
1145 TextureBrowser_setOriginY(textureBrowser, originy);
1149 void TextureBrowser_Tracking_MouseDown(TextureBrowser &textureBrowser)
1151 textureBrowser.m_freezePointer.freeze_pointer(textureBrowser.m_parent, TextureBrowser_trackingDelta,
1155 void TextureBrowser_Tracking_MouseUp(TextureBrowser &textureBrowser)
1157 textureBrowser.m_freezePointer.unfreeze_pointer(textureBrowser.m_parent);
1160 void TextureBrowser_Selection_MouseDown(TextureBrowser &textureBrowser, guint32 flags, int pointx, int pointy)
1162 SelectTexture(textureBrowser, pointx, textureBrowser.height - 1 - pointy, (flags & GDK_SHIFT_MASK) != 0);
1166 ============================================================================
1170 ============================================================================
1176 TTimo: relying on the shaders list to display the textures
1177 we must query all qtexture_t* to manage and display through the IShaders interface
1178 this allows a plugin to completely override the texture system
1181 void Texture_Draw(TextureBrowser &textureBrowser)
1183 int originy = TextureBrowser_getOriginY(textureBrowser);
1185 glClearColor(textureBrowser.color_textureback[0],
1186 textureBrowser.color_textureback[1],
1187 textureBrowser.color_textureback[2],
1189 glViewport(0, 0, textureBrowser.width, textureBrowser.height);
1190 glMatrixMode(GL_PROJECTION);
1193 glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
1194 glDisable(GL_DEPTH_TEST);
1195 if (g_TextureBrowser_enableAlpha) {
1197 glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
1199 glDisable(GL_BLEND);
1201 glOrtho(0, textureBrowser.width, originy - textureBrowser.height, originy, -100, 100);
1202 glEnable(GL_TEXTURE_2D);
1204 glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
1206 int last_y = 0, last_height = 0;
1208 TextureLayout layout;
1209 Texture_StartPos(layout);
1210 for (QERApp_ActiveShaders_IteratorBegin(); !QERApp_ActiveShaders_IteratorAtEnd(); QERApp_ActiveShaders_IteratorIncrement()) {
1211 IShader *shader = QERApp_ActiveShaders_IteratorCurrent();
1213 if (!Texture_IsShown(shader, textureBrowser.m_showShaders, textureBrowser.m_hideUnused)) {
1218 Texture_NextPos(textureBrowser, layout, shader->getTexture(), &x, &y);
1219 qtexture_t *q = shader->getTexture();
1224 int nWidth = textureBrowser.getTextureWidth(q);
1225 int nHeight = textureBrowser.getTextureHeight(q);
1231 last_height = std::max(nHeight, last_height);
1233 // Is this texture visible?
1234 if ((y - nHeight - TextureBrowser_fontHeight(textureBrowser) < originy)
1235 && (y > originy - textureBrowser.height)) {
1237 // if it's the current texture, draw a thick red line, else:
1238 // shaders have a white border, simple textures don't
1239 // if !texture_showinuse: (some textures displayed may not be in use)
1240 // draw an additional square around with 0.5 1 0.5 color
1241 if (shader_equal(TextureBrowser_GetSelectedShader(textureBrowser), shader->getName())) {
1243 if (textureBrowser.m_rmbSelected) {
1248 glDisable(GL_TEXTURE_2D);
1250 glBegin(GL_LINE_LOOP);
1251 glVertex2i(x - 4, y - TextureBrowser_fontHeight(textureBrowser) + 4);
1252 glVertex2i(x - 4, y - TextureBrowser_fontHeight(textureBrowser) - nHeight - 4);
1253 glVertex2i(x + 4 + nWidth, y - TextureBrowser_fontHeight(textureBrowser) - nHeight - 4);
1254 glVertex2i(x + 4 + nWidth, y - TextureBrowser_fontHeight(textureBrowser) + 4);
1257 glEnable(GL_TEXTURE_2D);
1262 if (!shader->IsDefault()) {
1264 glDisable(GL_TEXTURE_2D);
1266 glBegin(GL_LINE_LOOP);
1267 glVertex2i(x - 1, y + 1 - TextureBrowser_fontHeight(textureBrowser));
1268 glVertex2i(x - 1, y - nHeight - 1 - TextureBrowser_fontHeight(textureBrowser));
1269 glVertex2i(x + 1 + nWidth, y - nHeight - 1 - TextureBrowser_fontHeight(textureBrowser));
1270 glVertex2i(x + 1 + nWidth, y + 1 - TextureBrowser_fontHeight(textureBrowser));
1272 glEnable(GL_TEXTURE_2D);
1275 // highlight in-use textures
1276 if (!textureBrowser.m_hideUnused && shader->IsInUse()) {
1277 glColor3f(0.5, 1, 0.5);
1278 glDisable(GL_TEXTURE_2D);
1279 glBegin(GL_LINE_LOOP);
1280 glVertex2i(x - 3, y + 3 - TextureBrowser_fontHeight(textureBrowser));
1281 glVertex2i(x - 3, y - nHeight - 3 - TextureBrowser_fontHeight(textureBrowser));
1282 glVertex2i(x + 3 + nWidth, y - nHeight - 3 - TextureBrowser_fontHeight(textureBrowser));
1283 glVertex2i(x + 3 + nWidth, y + 3 - TextureBrowser_fontHeight(textureBrowser));
1285 glEnable(GL_TEXTURE_2D);
1289 // draw checkerboard for transparent textures
1290 if (g_TextureBrowser_enableAlpha) {
1291 glDisable(GL_TEXTURE_2D);
1293 int font_height = TextureBrowser_fontHeight(textureBrowser);
1294 for (int i = 0; i < nHeight; i += 8) {
1295 for (int j = 0; j < nWidth; j += 8) {
1296 unsigned char color = (i + j) / 8 % 2 ? 0x66 : 0x99;
1297 glColor3ub(color, color, color);
1299 int right = std::min(j + 8, nWidth);
1301 int bottom = std::min(i + 8, nHeight);
1302 glVertex2i(x + right, y - nHeight - font_height + top);
1303 glVertex2i(x + left, y - nHeight - font_height + top);
1304 glVertex2i(x + left, y - nHeight - font_height + bottom);
1305 glVertex2i(x + right, y - nHeight - font_height + bottom);
1309 glEnable(GL_TEXTURE_2D);
1313 glBindTexture(GL_TEXTURE_2D, q->texture_number);
1314 GlobalOpenGL_debugAssertNoErrors();
1318 glVertex2i(x, y - TextureBrowser_fontHeight(textureBrowser));
1320 glVertex2i(x + nWidth, y - TextureBrowser_fontHeight(textureBrowser));
1322 glVertex2i(x + nWidth, y - TextureBrowser_fontHeight(textureBrowser) - nHeight);
1324 glVertex2i(x, y - TextureBrowser_fontHeight(textureBrowser) - nHeight);
1327 // draw the texture name
1328 glDisable(GL_TEXTURE_2D);
1331 glRasterPos2i(x, y - TextureBrowser_fontHeight(textureBrowser) + 5);
1333 // don't draw the directory name
1334 const char *name = shader->getName();
1335 name += strlen(name);
1336 while (name != shader->getName() && *(name - 1) != '/' && *(name - 1) != '\\') {
1340 GlobalOpenGL().drawString(name);
1341 glEnable(GL_TEXTURE_2D);
1344 //int totalHeight = abs(y) + last_height + TextureBrowser_fontHeight(textureBrowser) + 4;
1348 // reset the current texture
1349 glBindTexture(GL_TEXTURE_2D, 0);
1353 void TextureBrowser_queueDraw(TextureBrowser &textureBrowser)
1355 if (textureBrowser.m_gl_widget) {
1356 gtk_widget_queue_draw(textureBrowser.m_gl_widget);
1361 void TextureBrowser_setScale(TextureBrowser &textureBrowser, std::size_t scale)
1363 textureBrowser.m_textureScale = scale;
1365 TextureBrowser_queueDraw(textureBrowser);
1368 void TextureBrowser_setUniformSize(TextureBrowser &textureBrowser, std::size_t scale)
1370 textureBrowser.m_uniformTextureSize = scale;
1372 TextureBrowser_queueDraw(textureBrowser);
1376 void TextureBrowser_MouseWheel(TextureBrowser &textureBrowser, bool bUp)
1378 int originy = TextureBrowser_getOriginY(textureBrowser);
1381 originy += int(textureBrowser.m_mouseWheelScrollIncrement);
1383 originy -= int(textureBrowser.m_mouseWheelScrollIncrement);
1386 TextureBrowser_setOriginY(textureBrowser, originy);
1389 XmlTagBuilder TagBuilder;
1396 void BuildStoreAssignedTags(ui::ListStore store, const char *shader, TextureBrowser *textureBrowser)
1402 std::vector<CopiedString> assigned_tags;
1403 TagBuilder.GetShaderTags(shader, assigned_tags);
1405 for (size_t i = 0; i < assigned_tags.size(); i++) {
1406 store.append(TAG_COLUMN, assigned_tags[i].c_str());
1410 void BuildStoreAvailableTags(ui::ListStore storeAvailable,
1411 ui::ListStore storeAssigned,
1412 const std::set<CopiedString> &allTags,
1413 TextureBrowser *textureBrowser)
1415 GtkTreeIter iterAssigned;
1416 GtkTreeIter iterAvailable;
1417 std::set<CopiedString>::const_iterator iterAll;
1418 gchar *tag_assigned;
1420 storeAvailable.clear();
1422 bool row = gtk_tree_model_get_iter_first(storeAssigned, &iterAssigned) != 0;
1424 if (!row) { // does the shader have tags assigned?
1425 for (iterAll = allTags.begin(); iterAll != allTags.end(); ++iterAll) {
1426 storeAvailable.append(TAG_COLUMN, (*iterAll).c_str());
1429 while (row) // available tags = all tags - assigned tags
1431 gtk_tree_model_get(storeAssigned, &iterAssigned, TAG_COLUMN, &tag_assigned, -1);
1433 for (iterAll = allTags.begin(); iterAll != allTags.end(); ++iterAll) {
1434 if (strcmp((char *) tag_assigned, (*iterAll).c_str()) != 0) {
1435 storeAvailable.append(TAG_COLUMN, (*iterAll).c_str());
1437 row = gtk_tree_model_iter_next(storeAssigned, &iterAssigned) != 0;
1440 gtk_tree_model_get(storeAssigned, &iterAssigned, TAG_COLUMN, &tag_assigned, -1);
1448 gboolean TextureBrowser_button_press(ui::Widget widget, GdkEventButton *event, TextureBrowser *textureBrowser)
1450 if (event->type == GDK_BUTTON_PRESS) {
1451 if (event->button == 3) {
1452 if (GlobalTextureBrowser().m_tags) {
1453 textureBrowser->m_rmbSelected = true;
1454 TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>( event->x ),
1455 static_cast<int>( event->y ));
1457 BuildStoreAssignedTags(textureBrowser->m_assigned_store, textureBrowser->shader.c_str(),
1459 BuildStoreAvailableTags(textureBrowser->m_available_store, textureBrowser->m_assigned_store,
1460 textureBrowser->m_all_tags, textureBrowser);
1461 textureBrowser->m_heightChanged = true;
1462 textureBrowser->m_tag_frame.show();
1466 TextureBrowser_Focus(*textureBrowser, textureBrowser->shader.c_str());
1468 TextureBrowser_Tracking_MouseDown(*textureBrowser);
1470 } else if (event->button == 1) {
1471 TextureBrowser_Selection_MouseDown(*textureBrowser, event->state, static_cast<int>( event->x ),
1472 static_cast<int>( event->y ));
1474 if (GlobalTextureBrowser().m_tags) {
1475 textureBrowser->m_rmbSelected = false;
1476 textureBrowser->m_tag_frame.hide();
1483 gboolean TextureBrowser_button_release(ui::Widget widget, GdkEventButton *event, TextureBrowser *textureBrowser)
1485 if (event->type == GDK_BUTTON_RELEASE) {
1486 if (event->button == 3) {
1487 if (!GlobalTextureBrowser().m_tags) {
1488 TextureBrowser_Tracking_MouseUp(*textureBrowser);
1495 gboolean TextureBrowser_motion(ui::Widget widget, GdkEventMotion *event, TextureBrowser *textureBrowser)
1500 gboolean TextureBrowser_scroll(ui::Widget widget, GdkEventScroll *event, TextureBrowser *textureBrowser)
1502 if (event->direction == GDK_SCROLL_UP) {
1503 TextureBrowser_MouseWheel(*textureBrowser, true);
1504 } else if (event->direction == GDK_SCROLL_DOWN) {
1505 TextureBrowser_MouseWheel(*textureBrowser, false);
1510 void TextureBrowser_scrollChanged(void *data, gdouble value)
1512 //globalOutputStream() << "vertical scroll\n";
1513 TextureBrowser_setOriginY(*reinterpret_cast<TextureBrowser *>( data ), -(int) value);
1516 static void TextureBrowser_verticalScroll(ui::Adjustment adjustment, TextureBrowser *textureBrowser)
1518 textureBrowser->m_scrollAdjustment.value_changed(gtk_adjustment_get_value(adjustment));
1521 void TextureBrowser_updateScroll(TextureBrowser &textureBrowser)
1523 if (textureBrowser.m_showTextureScrollbar) {
1524 int totalHeight = TextureBrowser_TotalHeight(textureBrowser);
1526 totalHeight = std::max(totalHeight, textureBrowser.height);
1528 auto vadjustment = gtk_range_get_adjustment(GTK_RANGE(textureBrowser.m_texture_scroll));
1530 gtk_adjustment_set_value(vadjustment, -TextureBrowser_getOriginY(textureBrowser));
1531 gtk_adjustment_set_page_size(vadjustment, textureBrowser.height);
1532 gtk_adjustment_set_page_increment(vadjustment, textureBrowser.height / 2);
1533 gtk_adjustment_set_step_increment(vadjustment, 20);
1534 gtk_adjustment_set_lower(vadjustment, 0);
1535 gtk_adjustment_set_upper(vadjustment, totalHeight);
1537 g_signal_emit_by_name(G_OBJECT(vadjustment), "changed");
1541 gboolean TextureBrowser_size_allocate(ui::Widget widget, GtkAllocation *allocation, TextureBrowser *textureBrowser)
1543 textureBrowser->width = allocation->width;
1544 textureBrowser->height = allocation->height;
1545 TextureBrowser_heightChanged(*textureBrowser);
1546 textureBrowser->m_originInvalid = true;
1547 TextureBrowser_queueDraw(*textureBrowser);
1551 gboolean TextureBrowser_expose(ui::Widget widget, GdkEventExpose *event, TextureBrowser *textureBrowser)
1553 if (glwidget_make_current(textureBrowser->m_gl_widget) != FALSE) {
1554 GlobalOpenGL_debugAssertNoErrors();
1555 TextureBrowser_evaluateHeight(*textureBrowser);
1556 Texture_Draw(*textureBrowser);
1557 GlobalOpenGL_debugAssertNoErrors();
1558 glwidget_swap_buffers(textureBrowser->m_gl_widget);
1564 TextureBrowser g_TextureBrowser;
1566 TextureBrowser &GlobalTextureBrowser()
1568 return g_TextureBrowser;
1571 bool TextureBrowser_hideUnused()
1573 return g_TextureBrowser.m_hideUnused;
1576 void TextureBrowser_ToggleHideUnused()
1578 if (g_TextureBrowser.m_hideUnused) {
1579 TextureBrowser_SetHideUnused(g_TextureBrowser, false);
1581 TextureBrowser_SetHideUnused(g_TextureBrowser, true);
1585 void TextureGroups_constructTreeModel(TextureGroups groups, ui::TreeStore store)
1587 // put the information from the old textures menu into a treeview
1588 GtkTreeIter iter, child;
1590 TextureGroups::const_iterator i = groups.begin();
1591 while (i != groups.end()) {
1592 const char *dirName = (*i).c_str();
1593 const char *firstUnderscore = strchr(dirName, '_');
1594 StringRange dirRoot(dirName, (firstUnderscore == 0) ? dirName : firstUnderscore + 1);
1596 TextureGroups::const_iterator next = i;
1598 if (firstUnderscore != 0
1599 && next != groups.end()
1600 && string_equal_start((*next).c_str(), dirRoot)) {
1601 gtk_tree_store_append(store, &iter, NULL);
1602 gtk_tree_store_set(store, &iter, 0, CopiedString(StringRange(dirName, firstUnderscore)).c_str(), -1);
1605 while (i != groups.end() && string_equal_start((*i).c_str(), dirRoot)) {
1606 gtk_tree_store_append(store, &child, &iter);
1607 gtk_tree_store_set(store, &child, 0, (*i).c_str(), -1);
1611 gtk_tree_store_append(store, &iter, NULL);
1612 gtk_tree_store_set(store, &iter, 0, dirName, -1);
1618 TextureGroups TextureGroups_constructTreeView()
1620 TextureGroups groups;
1622 if (TextureBrowser_showWads()) {
1623 GlobalFileSystem().forEachArchive(TextureGroupsAddWadCaller(groups));
1625 // scan texture dirs and pak files only if not restricting to shaderlist
1626 if (g_pGameDescription->mGameType != "doom3" && !g_TextureBrowser_shaderlistOnly) {
1627 GlobalFileSystem().forEachDirectory("textures/", TextureGroupsAddDirectoryCaller(groups));
1630 GlobalShaderSystem().foreachShaderName(TextureGroupsAddShaderCaller(groups));
1636 void TextureBrowser_constructTreeStore()
1638 TextureGroups groups = TextureGroups_constructTreeView();
1639 auto store = ui::TreeStore::from(gtk_tree_store_new(1, G_TYPE_STRING));
1640 TextureGroups_constructTreeModel(groups, store);
1642 gtk_tree_view_set_model(g_TextureBrowser.m_treeViewTree, store);
1644 g_object_unref(G_OBJECT(store));
1647 void TextureBrowser_constructTreeStoreTags()
1649 TextureGroups groups;
1650 auto store = ui::TreeStore::from(gtk_tree_store_new(1, G_TYPE_STRING));
1651 auto model = g_TextureBrowser.m_all_tags_list;
1653 gtk_tree_view_set_model(g_TextureBrowser.m_treeViewTags, model);
1655 g_object_unref(G_OBJECT(store));
1658 void TreeView_onRowActivated(ui::TreeView treeview, ui::TreePath path, ui::TreeViewColumn col, gpointer userdata)
1662 auto model = gtk_tree_view_get_model(treeview);
1664 if (gtk_tree_model_get_iter(model, &iter, path)) {
1665 gchar dirName[1024];
1668 gtk_tree_model_get(model, &iter, 0, &buffer, -1);
1669 strcpy(dirName, buffer);
1672 g_TextureBrowser.m_searchedTags = false;
1674 if (!TextureBrowser_showWads()) {
1675 strcat(dirName, "/");
1678 ScopeDisableScreenUpdates disableScreenUpdates(dirName, "Loading Textures");
1679 TextureBrowser_ShowDirectory(GlobalTextureBrowser(), dirName);
1680 TextureBrowser_queueDraw(GlobalTextureBrowser());
1684 void TextureBrowser_createTreeViewTree()
1686 gtk_tree_view_set_enable_search(g_TextureBrowser.m_treeViewTree, FALSE);
1688 gtk_tree_view_set_headers_visible(g_TextureBrowser.m_treeViewTree, FALSE);
1689 g_TextureBrowser.m_treeViewTree.connect("row-activated", (GCallback) TreeView_onRowActivated, NULL);
1691 auto renderer = ui::CellRendererText(ui::New);
1692 gtk_tree_view_insert_column_with_attributes(g_TextureBrowser.m_treeViewTree, -1, "", renderer, "text", 0, NULL);
1694 TextureBrowser_constructTreeStore();
1697 void TextureBrowser_addTag();
1699 void TextureBrowser_renameTag();
1701 void TextureBrowser_deleteTag();
1703 void TextureBrowser_createContextMenu(ui::Widget treeview, GdkEventButton *event)
1705 ui::Widget menu = ui::Menu(ui::New);
1707 ui::Widget menuitem = ui::MenuItem("Add tag");
1708 menuitem.connect("activate", (GCallback) TextureBrowser_addTag, treeview);
1709 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1711 menuitem = ui::MenuItem("Rename tag");
1712 menuitem.connect("activate", (GCallback) TextureBrowser_renameTag, treeview);
1713 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1715 menuitem = ui::MenuItem("Delete tag");
1716 menuitem.connect("activate", (GCallback) TextureBrowser_deleteTag, treeview);
1717 gtk_menu_shell_append(GTK_MENU_SHELL(menu), menuitem);
1719 gtk_widget_show_all(menu);
1721 gtk_menu_popup(GTK_MENU(menu), NULL, NULL, NULL, NULL,
1722 (event != NULL) ? event->button : 0,
1723 gdk_event_get_time((GdkEvent *) event));
1726 gboolean TreeViewTags_onButtonPressed(ui::TreeView treeview, GdkEventButton *event)
1728 if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
1730 auto selection = gtk_tree_view_get_selection(treeview);
1732 if (gtk_tree_view_get_path_at_pos(treeview, event->x, event->y, &path, NULL, NULL, NULL)) {
1733 gtk_tree_selection_unselect_all(selection);
1734 gtk_tree_selection_select_path(selection, path);
1735 gtk_tree_path_free(path);
1738 TextureBrowser_createContextMenu(treeview, event);
1744 void TextureBrowser_createTreeViewTags()
1746 g_TextureBrowser.m_treeViewTags = ui::TreeView(ui::New);
1747 gtk_tree_view_set_enable_search(g_TextureBrowser.m_treeViewTags, FALSE);
1749 g_TextureBrowser.m_treeViewTags.connect("button-press-event", (GCallback) TreeViewTags_onButtonPressed, NULL);
1751 gtk_tree_view_set_headers_visible(g_TextureBrowser.m_treeViewTags, FALSE);
1753 auto renderer = ui::CellRendererText(ui::New);
1754 gtk_tree_view_insert_column_with_attributes(g_TextureBrowser.m_treeViewTags, -1, "", renderer, "text", 0, NULL);
1756 TextureBrowser_constructTreeStoreTags();
1759 ui::MenuItem TextureBrowser_constructViewMenu(ui::Menu menu)
1761 ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("_View"));
1763 if (g_Layout_enableDetachableMenus.m_value) {
1767 create_check_menu_item_with_mnemonic(menu, "Hide _Unused", "ShowInUse");
1768 if (string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1769 create_check_menu_item_with_mnemonic(menu, "Hide Image Missing", "FilterMissing");
1772 // hide notex and shadernotex on texture browser: no one wants to apply them
1773 create_check_menu_item_with_mnemonic(menu, "Hide Fallback", "FilterFallback");
1775 menu_separator(menu);
1777 create_menu_item_with_mnemonic(menu, "Show All", "ShowAllTextures");
1779 // we always want to show shaders but don't want a "Show Shaders" menu for doom3 and .wad file games
1780 if (g_pGameDescription->mGameType == "doom3" || !string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1781 g_TextureBrowser.m_showShaders = true;
1783 create_check_menu_item_with_mnemonic(menu, "Show shaders", "ToggleShowShaders");
1786 if (g_pGameDescription->mGameType != "doom3" && string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1787 create_check_menu_item_with_mnemonic(menu, "Shaders Only", "ToggleShowShaderlistOnly");
1789 if (g_TextureBrowser.m_tags) {
1790 create_menu_item_with_mnemonic(menu, "Show Untagged", "ShowUntagged");
1793 menu_separator(menu);
1794 create_check_menu_item_with_mnemonic(menu, "Fixed Size", "FixedSize");
1795 create_check_menu_item_with_mnemonic(menu, "Transparency", "EnableAlpha");
1797 if (string_empty(g_pGameDescription->getKeyValue("show_wads"))) {
1798 menu_separator(menu);
1799 g_TextureBrowser.m_shader_info_item = ui::Widget(
1800 create_menu_item_with_mnemonic(menu, "Shader Info", "ShaderInfo"));
1801 gtk_widget_set_sensitive(g_TextureBrowser.m_shader_info_item, FALSE);
1805 return textures_menu_item;
1808 ui::MenuItem TextureBrowser_constructToolsMenu(ui::Menu menu)
1810 ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("_Tools"));
1812 if (g_Layout_enableDetachableMenus.m_value) {
1816 create_menu_item_with_mnemonic(menu, "Flush & Reload Shaders", "RefreshShaders");
1817 create_menu_item_with_mnemonic(menu, "Find / Replace...", "FindReplaceTextures");
1819 return textures_menu_item;
1822 ui::MenuItem TextureBrowser_constructTagsMenu(ui::Menu menu)
1824 ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic("T_ags"));
1826 if (g_Layout_enableDetachableMenus.m_value) {
1830 create_menu_item_with_mnemonic(menu, "Add tag", "AddTag");
1831 create_menu_item_with_mnemonic(menu, "Rename tag", "RenameTag");
1832 create_menu_item_with_mnemonic(menu, "Delete tag", "DeleteTag");
1833 menu_separator(menu);
1834 create_menu_item_with_mnemonic(menu, "Copy tags from selected", "CopyTag");
1835 create_menu_item_with_mnemonic(menu, "Paste tags to selected", "PasteTag");
1837 return textures_menu_item;
1840 gboolean TextureBrowser_tagMoveHelper(ui::TreeModel model, ui::TreePath path, GtkTreeIter iter, GSList **selected)
1842 g_assert(selected != NULL);
1844 auto rowref = gtk_tree_row_reference_new(model, path);
1845 *selected = g_slist_append(*selected, rowref);
1850 void TextureBrowser_assignTags()
1852 GSList *selected = NULL;
1854 gchar *tag_assigned;
1856 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
1858 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1861 if (selected != NULL) {
1862 for (node = selected; node != NULL; node = node->next) {
1863 auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1868 if (gtk_tree_model_get_iter(g_TextureBrowser.m_available_store, &iter, path)) {
1869 gtk_tree_model_get(g_TextureBrowser.m_available_store, &iter, TAG_COLUMN, &tag_assigned, -1);
1870 if (!TagBuilder.CheckShaderTag(g_TextureBrowser.shader.c_str())) {
1871 // create a custom shader/texture entry
1872 IShader *ishader = QERApp_Shader_ForName(g_TextureBrowser.shader.c_str());
1873 CopiedString filename = ishader->getShaderFileName();
1875 if (filename.empty()) {
1877 TagBuilder.AddShaderNode(g_TextureBrowser.shader.c_str(), CUSTOM, TEXTURE);
1880 TagBuilder.AddShaderNode(g_TextureBrowser.shader.c_str(), CUSTOM, SHADER);
1884 TagBuilder.AddShaderTag(g_TextureBrowser.shader.c_str(), (char *) tag_assigned, TAG);
1886 gtk_list_store_remove(g_TextureBrowser.m_available_store, &iter);
1887 g_TextureBrowser.m_assigned_store.append(TAG_COLUMN, tag_assigned);
1892 g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1895 TagBuilder.SaveXmlDoc();
1897 g_slist_free(selected);
1900 void TextureBrowser_removeTags()
1902 GSList *selected = NULL;
1906 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_assigned_tree);
1908 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1911 if (selected != NULL) {
1912 for (node = selected; node != NULL; node = node->next) {
1913 auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1918 if (gtk_tree_model_get_iter(g_TextureBrowser.m_assigned_store, &iter, path)) {
1919 gtk_tree_model_get(g_TextureBrowser.m_assigned_store, &iter, TAG_COLUMN, &tag, -1);
1920 TagBuilder.DeleteShaderTag(g_TextureBrowser.shader.c_str(), tag);
1921 gtk_list_store_remove(g_TextureBrowser.m_assigned_store, &iter);
1926 g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1928 // Update the "available tags list"
1929 BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
1930 g_TextureBrowser.m_all_tags, &g_TextureBrowser);
1933 TagBuilder.SaveXmlDoc();
1935 g_slist_free(selected);
1938 void TextureBrowser_buildTagList()
1940 g_TextureBrowser.m_all_tags_list.clear();
1942 std::set<CopiedString>::iterator iter;
1944 for (iter = g_TextureBrowser.m_all_tags.begin(); iter != g_TextureBrowser.m_all_tags.end(); ++iter) {
1945 g_TextureBrowser.m_all_tags_list.append(TAG_COLUMN, (*iter).c_str());
1949 void TextureBrowser_searchTags()
1951 GSList *selected = NULL;
1955 char tags_searched[256];
1957 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
1959 gtk_tree_selection_selected_foreach(selection, (GtkTreeSelectionForeachFunc) TextureBrowser_tagMoveHelper,
1962 if (selected != NULL) {
1963 strcpy(buffer, "/root/*/*[tag='");
1964 strcpy(tags_searched, "[TAGS] ");
1966 for (node = selected; node != NULL; node = node->next) {
1967 auto path = gtk_tree_row_reference_get_path((GtkTreeRowReference *) node->data);
1972 if (gtk_tree_model_get_iter(g_TextureBrowser.m_all_tags_list, &iter, path)) {
1973 gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iter, TAG_COLUMN, &tag, -1);
1975 strcat(buffer, tag);
1976 strcat(tags_searched, tag);
1977 if (node != g_slist_last(node)) {
1978 strcat(buffer, "' and tag='");
1979 strcat(tags_searched, ", ");
1985 strcat(buffer, "']");
1987 g_slist_foreach(selected, (GFunc) gtk_tree_row_reference_free, NULL);
1989 g_TextureBrowser.m_found_shaders.clear(); // delete old list
1990 TagBuilder.TagSearch(buffer, g_TextureBrowser.m_found_shaders);
1992 if (!g_TextureBrowser.m_found_shaders.empty()) { // found something
1993 size_t shaders_found = g_TextureBrowser.m_found_shaders.size();
1995 globalOutputStream() << "Found " << (unsigned int) shaders_found << " textures and shaders with "
1996 << tags_searched << "\n";
1997 ScopeDisableScreenUpdates disableScreenUpdates("Searching...", "Loading Textures");
1999 std::set<CopiedString>::iterator iter;
2001 for (iter = g_TextureBrowser.m_found_shaders.begin();
2002 iter != g_TextureBrowser.m_found_shaders.end(); iter++) {
2003 std::string path = (*iter).c_str();
2004 size_t pos = path.find_last_of("/", path.size());
2005 std::string name = path.substr(pos + 1, path.size());
2006 path = path.substr(0, pos + 1);
2007 TextureDirectory_loadTexture(path.c_str(), name.c_str());
2010 g_TextureBrowser.m_searchedTags = true;
2011 g_TextureBrowser_currentDirectory = tags_searched;
2013 g_TextureBrowser.m_nTotalHeight = 0;
2014 TextureBrowser_setOriginY(g_TextureBrowser, 0);
2015 TextureBrowser_heightChanged(g_TextureBrowser);
2016 TextureBrowser_updateTitle();
2018 g_slist_free(selected);
2021 void TextureBrowser_toggleSearchButton()
2023 gint page = gtk_notebook_get_current_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook));
2025 if (page == 0) { // tag page
2026 gtk_widget_show_all(g_TextureBrowser.m_search_button);
2028 g_TextureBrowser.m_search_button.hide();
2032 void TextureBrowser_constructTagNotebook()
2034 g_TextureBrowser.m_tag_notebook = ui::Widget::from(gtk_notebook_new());
2035 ui::Widget labelTags = ui::Label("Tags");
2036 ui::Widget labelTextures = ui::Label("Textures");
2038 gtk_notebook_append_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook), g_TextureBrowser.m_scr_win_tree,
2040 gtk_notebook_append_page(GTK_NOTEBOOK(g_TextureBrowser.m_tag_notebook), g_TextureBrowser.m_scr_win_tags, labelTags);
2042 g_TextureBrowser.m_tag_notebook.connect("switch-page", G_CALLBACK(TextureBrowser_toggleSearchButton), NULL);
2044 gtk_widget_show_all(g_TextureBrowser.m_tag_notebook);
2047 void TextureBrowser_constructSearchButton()
2049 auto image = ui::Widget::from(gtk_image_new_from_stock(GTK_STOCK_FIND, GTK_ICON_SIZE_SMALL_TOOLBAR));
2050 g_TextureBrowser.m_search_button = ui::Button(ui::New);
2051 g_TextureBrowser.m_search_button.connect("clicked", G_CALLBACK(TextureBrowser_searchTags), NULL);
2052 gtk_widget_set_tooltip_text(g_TextureBrowser.m_search_button, "Search with selected tags");
2053 g_TextureBrowser.m_search_button.add(image);
2056 void TextureBrowser_checkTagFile()
2058 const char SHADERTAG_FILE[] = "shadertags.xml";
2059 CopiedString default_filename, rc_filename;
2060 StringOutputStream stream(256);
2062 stream << LocalRcPath_get();
2063 stream << SHADERTAG_FILE;
2064 rc_filename = stream.c_str();
2066 if (file_exists(rc_filename.c_str())) {
2067 g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc(rc_filename.c_str());
2069 if (g_TextureBrowser.m_tags) {
2070 globalOutputStream() << "Loading tag file " << rc_filename.c_str() << ".\n";
2073 // load default tagfile
2075 stream << g_pGameDescription->mGameToolsPath.c_str();
2076 stream << SHADERTAG_FILE;
2077 default_filename = stream.c_str();
2079 if (file_exists(default_filename.c_str())) {
2080 g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc(default_filename.c_str(), rc_filename.c_str());
2082 if (g_TextureBrowser.m_tags) {
2083 globalOutputStream() << "Loading default tag file " << default_filename.c_str() << ".\n";
2086 globalErrorStream() << "Unable to find default tag file " << default_filename.c_str()
2087 << ". No tag support.\n";
2092 void TextureBrowser_SetNotex()
2094 StringOutputStream name(256);
2095 name << GlobalRadiant().getAppPath() << "bitmaps/" NOTEX_BASENAME ".png";
2096 g_notex = name.c_str();
2098 name = StringOutputStream(256);
2099 name << GlobalRadiant().getAppPath() << "bitmaps/" SHADERNOTEX_BASENAME " .png";
2100 g_shadernotex = name.c_str();
2103 ui::Widget TextureBrowser_constructWindow(ui::Window toplevel)
2105 // The gl_widget and the tag assignment frame should be packed into a GtkVPaned with the slider
2106 // position stored in local.pref. gtk_paned_get_position() and gtk_paned_set_position() don't
2107 // seem to work in gtk 2.4 and the arrow buttons don't handle GTK_FILL, so here's another thing
2108 // for the "once-the-gtk-libs-are-updated-TODO-list" :x
2110 TextureBrowser_checkTagFile();
2111 TextureBrowser_SetNotex();
2113 GlobalShaderSystem().setActiveShadersChangedNotify(
2114 ReferenceCaller<TextureBrowser, void(), TextureBrowser_activeShadersChanged>(g_TextureBrowser));
2116 g_TextureBrowser.m_parent = toplevel;
2118 auto table = ui::Table(3, 3, FALSE);
2119 auto vbox = ui::VBox(FALSE, 0);
2120 table.attach(vbox, {0, 1, 1, 3}, {GTK_FILL, GTK_FILL});
2123 ui::Widget menu_bar{ui::null};
2126 menu_bar = ui::Widget::from(gtk_menu_bar_new());
2127 auto menu_view = ui::Menu(ui::New);
2128 auto view_item = TextureBrowser_constructViewMenu(menu_view);
2129 gtk_menu_item_set_submenu(GTK_MENU_ITEM(view_item), menu_view);
2130 gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), view_item);
2132 auto menu_tools = ui::Menu(ui::New);
2133 auto tools_item = TextureBrowser_constructToolsMenu(menu_tools);
2134 gtk_menu_item_set_submenu(GTK_MENU_ITEM(tools_item), menu_tools);
2135 gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tools_item);
2137 table.attach(menu_bar, {0, 3, 0, 1}, {GTK_FILL, GTK_SHRINK});
2140 { // Texture TreeView
2141 g_TextureBrowser.m_scr_win_tree = ui::ScrolledWindow(ui::New);
2142 gtk_container_set_border_width(GTK_CONTAINER(g_TextureBrowser.m_scr_win_tree), 0);
2144 // vertical only scrolling for treeview
2145 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tree), GTK_POLICY_NEVER,
2148 g_TextureBrowser.m_scr_win_tree.show();
2150 TextureBrowser_createTreeViewTree();
2152 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tree),
2153 g_TextureBrowser.m_treeViewTree);
2154 g_TextureBrowser.m_treeViewTree.show();
2156 { // gl_widget scrollbar
2157 auto w = ui::Widget::from(gtk_vscrollbar_new(ui::Adjustment(0, 0, 0, 1, 1, 0)));
2158 table.attach(w, {2, 3, 1, 2}, {GTK_SHRINK, GTK_FILL});
2160 g_TextureBrowser.m_texture_scroll = w;
2162 auto vadjustment = ui::Adjustment::from(gtk_range_get_adjustment(GTK_RANGE(g_TextureBrowser.m_texture_scroll)));
2163 vadjustment.connect("value_changed", G_CALLBACK(TextureBrowser_verticalScroll), &g_TextureBrowser);
2165 g_TextureBrowser.m_texture_scroll.visible(g_TextureBrowser.m_showTextureScrollbar);
2168 g_TextureBrowser.m_gl_widget = glwidget_new(FALSE);
2169 g_object_ref(g_TextureBrowser.m_gl_widget._handle);
2171 gtk_widget_set_events(g_TextureBrowser.m_gl_widget,
2172 GDK_DESTROY | GDK_EXPOSURE_MASK | GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
2173 GDK_POINTER_MOTION_MASK | GDK_SCROLL_MASK);
2174 gtk_widget_set_can_focus(g_TextureBrowser.m_gl_widget, true);
2176 table.attach(g_TextureBrowser.m_gl_widget, {1, 2, 1, 2});
2177 g_TextureBrowser.m_gl_widget.show();
2179 g_TextureBrowser.m_sizeHandler = g_TextureBrowser.m_gl_widget.connect("size_allocate",
2180 G_CALLBACK(TextureBrowser_size_allocate),
2182 g_TextureBrowser.m_exposeHandler = g_TextureBrowser.m_gl_widget.on_render(G_CALLBACK(TextureBrowser_expose),
2185 g_TextureBrowser.m_gl_widget.connect("button_press_event", G_CALLBACK(TextureBrowser_button_press),
2187 g_TextureBrowser.m_gl_widget.connect("button_release_event", G_CALLBACK(TextureBrowser_button_release),
2189 g_TextureBrowser.m_gl_widget.connect("motion_notify_event", G_CALLBACK(TextureBrowser_motion),
2191 g_TextureBrowser.m_gl_widget.connect("scroll_event", G_CALLBACK(TextureBrowser_scroll), &g_TextureBrowser);
2195 if (g_TextureBrowser.m_tags) {
2196 { // fill tag GtkListStore
2197 g_TextureBrowser.m_all_tags_list = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2198 auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_all_tags_list);
2199 gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2201 TagBuilder.GetAllTags(g_TextureBrowser.m_all_tags);
2202 TextureBrowser_buildTagList();
2205 auto menu_tags = ui::Menu(ui::New);
2206 auto tags_item = TextureBrowser_constructTagsMenu(menu_tags);
2207 gtk_menu_item_set_submenu(GTK_MENU_ITEM(tags_item), menu_tags);
2208 gtk_menu_shell_append(GTK_MENU_SHELL(menu_bar), tags_item);
2211 g_TextureBrowser.m_scr_win_tags = ui::ScrolledWindow(ui::New);
2212 gtk_container_set_border_width(GTK_CONTAINER(g_TextureBrowser.m_scr_win_tags), 0);
2214 // vertical only scrolling for treeview
2215 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tags), GTK_POLICY_NEVER,
2218 TextureBrowser_createTreeViewTags();
2220 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2221 gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2223 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(g_TextureBrowser.m_scr_win_tags),
2224 g_TextureBrowser.m_treeViewTags);
2225 g_TextureBrowser.m_treeViewTags.show();
2227 { // Texture/Tag notebook
2228 TextureBrowser_constructTagNotebook();
2229 vbox.pack_start(g_TextureBrowser.m_tag_notebook, TRUE, TRUE, 0);
2231 { // Tag search button
2232 TextureBrowser_constructSearchButton();
2233 vbox.pack_end(g_TextureBrowser.m_search_button, FALSE, FALSE, 0);
2235 auto frame_table = ui::Table(3, 3, FALSE);
2238 g_TextureBrowser.m_tag_frame = ui::Frame("Tag assignment");
2239 gtk_frame_set_label_align(GTK_FRAME(g_TextureBrowser.m_tag_frame), 0.5, 0.5);
2240 gtk_frame_set_shadow_type(GTK_FRAME(g_TextureBrowser.m_tag_frame), GTK_SHADOW_NONE);
2242 table.attach(g_TextureBrowser.m_tag_frame, {1, 3, 2, 3}, {GTK_FILL, GTK_SHRINK});
2246 g_TextureBrowser.m_tag_frame.add(frame_table);
2248 { // assigned tag list
2249 ui::Widget scrolled_win = ui::ScrolledWindow(ui::New);
2250 gtk_container_set_border_width(GTK_CONTAINER(scrolled_win), 0);
2251 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
2253 g_TextureBrowser.m_assigned_store = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2255 auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_assigned_store);
2256 gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2258 auto renderer = ui::CellRendererText(ui::New);
2260 g_TextureBrowser.m_assigned_tree = ui::TreeView(
2261 ui::TreeModel::from(g_TextureBrowser.m_assigned_store._handle));
2262 g_TextureBrowser.m_assigned_store.unref();
2263 g_TextureBrowser.m_assigned_tree.connect("row-activated", (GCallback) TextureBrowser_removeTags, NULL);
2264 gtk_tree_view_set_headers_visible(g_TextureBrowser.m_assigned_tree, FALSE);
2266 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_assigned_tree);
2267 gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2269 auto column = ui::TreeViewColumn("", renderer, {{"text", TAG_COLUMN}});
2270 gtk_tree_view_append_column(g_TextureBrowser.m_assigned_tree, column);
2271 g_TextureBrowser.m_assigned_tree.show();
2273 scrolled_win.show();
2274 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), g_TextureBrowser.m_assigned_tree);
2276 frame_table.attach(scrolled_win, {0, 1, 1, 3}, {GTK_FILL, GTK_FILL});
2278 { // available tag list
2279 ui::Widget scrolled_win = ui::ScrolledWindow(ui::New);
2280 gtk_container_set_border_width(GTK_CONTAINER(scrolled_win), 0);
2281 gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scrolled_win), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS);
2283 g_TextureBrowser.m_available_store = ui::ListStore::from(gtk_list_store_new(N_COLUMNS, G_TYPE_STRING));
2284 auto sortable = GTK_TREE_SORTABLE(g_TextureBrowser.m_available_store);
2285 gtk_tree_sortable_set_sort_column_id(sortable, TAG_COLUMN, GTK_SORT_ASCENDING);
2287 auto renderer = ui::CellRendererText(ui::New);
2289 g_TextureBrowser.m_available_tree = ui::TreeView(
2290 ui::TreeModel::from(g_TextureBrowser.m_available_store._handle));
2291 g_TextureBrowser.m_available_store.unref();
2292 g_TextureBrowser.m_available_tree.connect("row-activated", (GCallback) TextureBrowser_assignTags, NULL);
2293 gtk_tree_view_set_headers_visible(g_TextureBrowser.m_available_tree, FALSE);
2295 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
2296 gtk_tree_selection_set_mode(selection, GTK_SELECTION_MULTIPLE);
2298 auto column = ui::TreeViewColumn("", renderer, {{"text", TAG_COLUMN}});
2299 gtk_tree_view_append_column(g_TextureBrowser.m_available_tree, column);
2300 g_TextureBrowser.m_available_tree.show();
2302 scrolled_win.show();
2303 gtk_scrolled_window_add_with_viewport(GTK_SCROLLED_WINDOW(scrolled_win), g_TextureBrowser.m_available_tree);
2305 frame_table.attach(scrolled_win, {2, 3, 1, 3}, {GTK_FILL, GTK_FILL});
2307 { // tag arrow buttons
2308 auto m_btn_left = ui::Button(ui::New);
2309 auto m_btn_right = ui::Button(ui::New);
2310 auto m_arrow_left = ui::Widget::from(gtk_arrow_new(GTK_ARROW_LEFT, GTK_SHADOW_OUT));
2311 auto m_arrow_right = ui::Widget::from(gtk_arrow_new(GTK_ARROW_RIGHT, GTK_SHADOW_OUT));
2312 m_btn_left.add(m_arrow_left);
2313 m_btn_right.add(m_arrow_right);
2315 // workaround. the size of the tag frame depends of the requested size of the arrow buttons.
2316 m_arrow_left.dimensions(-1, 68);
2317 m_arrow_right.dimensions(-1, 68);
2319 frame_table.attach(m_btn_left, {1, 2, 1, 2}, {GTK_SHRINK, GTK_EXPAND});
2320 frame_table.attach(m_btn_right, {1, 2, 2, 3}, {GTK_SHRINK, GTK_EXPAND});
2322 m_btn_left.connect("clicked", G_CALLBACK(TextureBrowser_assignTags), NULL);
2323 m_btn_right.connect("clicked", G_CALLBACK(TextureBrowser_removeTags), NULL);
2327 m_arrow_left.show();
2328 m_arrow_right.show();
2330 { // tag fram labels
2331 ui::Widget m_lbl_assigned = ui::Label("Assigned");
2332 ui::Widget m_lbl_unassigned = ui::Label("Available");
2334 frame_table.attach(m_lbl_assigned, {0, 1, 0, 1}, {GTK_EXPAND, GTK_SHRINK});
2335 frame_table.attach(m_lbl_unassigned, {2, 3, 0, 1}, {GTK_EXPAND, GTK_SHRINK});
2337 m_lbl_assigned.show();
2338 m_lbl_unassigned.show();
2340 } else { // no tag support, show the texture tree only
2341 vbox.pack_start(g_TextureBrowser.m_scr_win_tree, TRUE, TRUE, 0);
2344 // TODO do we need this?
2345 //gtk_container_set_focus_chain(GTK_CONTAINER(hbox_table), NULL);
2350 void TextureBrowser_destroyWindow()
2352 GlobalShaderSystem().setActiveShadersChangedNotify(Callback<void()>());
2354 g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_sizeHandler);
2355 g_signal_handler_disconnect(G_OBJECT(g_TextureBrowser.m_gl_widget), g_TextureBrowser.m_exposeHandler);
2357 g_TextureBrowser.m_gl_widget.unref();
2360 const Vector3 &TextureBrowser_getBackgroundColour(TextureBrowser &textureBrowser)
2362 return textureBrowser.color_textureback;
2365 void TextureBrowser_setBackgroundColour(TextureBrowser &textureBrowser, const Vector3 &colour)
2367 textureBrowser.color_textureback = colour;
2368 TextureBrowser_queueDraw(textureBrowser);
2371 void TextureBrowser_selectionHelper(ui::TreeModel model, ui::TreePath path, GtkTreeIter *iter, GSList **selected)
2373 g_assert(selected != NULL);
2376 gtk_tree_model_get(model, iter, TAG_COLUMN, &name, -1);
2377 *selected = g_slist_append(*selected, name);
2380 void TextureBrowser_shaderInfo()
2382 const char *name = TextureBrowser_GetSelectedShader(g_TextureBrowser);
2383 IShader *shader = QERApp_Shader_ForName(name);
2385 DoShaderInfoDlg(name, shader->getShaderFileName(), "Shader Info");
2390 void TextureBrowser_addTag()
2394 EMessageBoxReturn result = DoShaderTagDlg(&tag, "Add shader tag");
2396 if (result == eIDOK && !tag.empty()) {
2398 g_TextureBrowser.m_all_tags.insert(tag.c_str());
2399 gtk_list_store_append(g_TextureBrowser.m_available_store, &iter);
2400 gtk_list_store_set(g_TextureBrowser.m_available_store, &iter, TAG_COLUMN, tag.c_str(), -1);
2402 // Select the currently added tag in the available list
2403 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_available_tree);
2404 gtk_tree_selection_select_iter(selection, &iter);
2406 g_TextureBrowser.m_all_tags_list.append(TAG_COLUMN, tag.c_str());
2410 void TextureBrowser_renameTag()
2412 /* WORKAROUND: The tag treeview is set to GTK_SELECTION_MULTIPLE. Because
2413 gtk_tree_selection_get_selected() doesn't work with GTK_SELECTION_MULTIPLE,
2414 we need to count the number of selected rows first and use
2415 gtk_tree_selection_selected_foreach() then to go through the list of selected
2416 rows (which always containins a single row).
2419 GSList *selected = NULL;
2421 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2422 gtk_tree_selection_selected_foreach(selection, GtkTreeSelectionForeachFunc(TextureBrowser_selectionHelper),
2425 if (g_slist_length(selected) == 1) { // we only rename a single tag
2426 CopiedString newTag;
2427 EMessageBoxReturn result = DoShaderTagDlg(&newTag, "Rename shader tag");
2429 if (result == eIDOK && !newTag.empty()) {
2430 GtkTreeIter iterList;
2432 gchar *oldTag = (char *) selected->data;
2434 bool row = gtk_tree_model_get_iter_first(g_TextureBrowser.m_all_tags_list, &iterList) != 0;
2437 gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iterList, TAG_COLUMN, &rowTag, -1);
2439 if (strcmp(rowTag, oldTag) == 0) {
2440 gtk_list_store_set(g_TextureBrowser.m_all_tags_list, &iterList, TAG_COLUMN, newTag.c_str(), -1);
2442 row = gtk_tree_model_iter_next(g_TextureBrowser.m_all_tags_list, &iterList) != 0;
2445 TagBuilder.RenameShaderTag(oldTag, newTag.c_str());
2447 g_TextureBrowser.m_all_tags.erase((CopiedString) oldTag);
2448 g_TextureBrowser.m_all_tags.insert(newTag);
2450 BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(),
2452 BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2453 g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2456 ui::alert(g_TextureBrowser.m_parent, "Select a single tag for renaming.");
2460 void TextureBrowser_deleteTag()
2462 GSList *selected = NULL;
2464 auto selection = gtk_tree_view_get_selection(g_TextureBrowser.m_treeViewTags);
2465 gtk_tree_selection_selected_foreach(selection, GtkTreeSelectionForeachFunc(TextureBrowser_selectionHelper),
2468 if (g_slist_length(selected) == 1) { // we only delete a single tag
2469 auto result = ui::alert(g_TextureBrowser.m_parent, "Are you sure you want to delete the selected tag?",
2470 "Delete Tag", ui::alert_type::YESNO, ui::alert_icon::Question);
2472 if (result == ui::alert_response::YES) {
2473 GtkTreeIter iterSelected;
2476 gchar *tagSelected = (char *) selected->data;
2478 bool row = gtk_tree_model_get_iter_first(g_TextureBrowser.m_all_tags_list, &iterSelected) != 0;
2481 gtk_tree_model_get(g_TextureBrowser.m_all_tags_list, &iterSelected, TAG_COLUMN, &rowTag, -1);
2483 if (strcmp(rowTag, tagSelected) == 0) {
2484 gtk_list_store_remove(g_TextureBrowser.m_all_tags_list, &iterSelected);
2487 row = gtk_tree_model_iter_next(g_TextureBrowser.m_all_tags_list, &iterSelected) != 0;
2490 TagBuilder.DeleteTag(tagSelected);
2491 g_TextureBrowser.m_all_tags.erase((CopiedString) tagSelected);
2493 BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(),
2495 BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2496 g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2499 ui::alert(g_TextureBrowser.m_parent, "Select a single tag for deletion.");
2503 void TextureBrowser_copyTag()
2505 g_TextureBrowser.m_copied_tags.clear();
2506 TagBuilder.GetShaderTags(g_TextureBrowser.shader.c_str(), g_TextureBrowser.m_copied_tags);
2509 void TextureBrowser_pasteTag()
2511 IShader *ishader = QERApp_Shader_ForName(g_TextureBrowser.shader.c_str());
2512 CopiedString shader = g_TextureBrowser.shader.c_str();
2514 if (!TagBuilder.CheckShaderTag(shader.c_str())) {
2515 CopiedString shaderFile = ishader->getShaderFileName();
2516 if (shaderFile.empty()) {
2518 TagBuilder.AddShaderNode(shader.c_str(), CUSTOM, TEXTURE);
2521 TagBuilder.AddShaderNode(shader.c_str(), CUSTOM, SHADER);
2524 for (size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i) {
2525 TagBuilder.AddShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG);
2528 for (size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i) {
2529 if (!TagBuilder.CheckShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str())) {
2530 // the tag doesn't exist - let's add it
2531 TagBuilder.AddShaderTag(shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG);
2538 TagBuilder.SaveXmlDoc();
2539 BuildStoreAssignedTags(g_TextureBrowser.m_assigned_store, shader.c_str(), &g_TextureBrowser);
2540 BuildStoreAvailableTags(g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store,
2541 g_TextureBrowser.m_all_tags, &g_TextureBrowser);
2544 void TextureBrowser_RefreshShaders()
2546 ScopeDisableScreenUpdates disableScreenUpdates("Processing...", "Loading Shaders");
2547 GlobalShaderSystem().refresh();
2549 auto selection = gtk_tree_view_get_selection(GlobalTextureBrowser().m_treeViewTree);
2550 GtkTreeModel *model = NULL;
2552 if (gtk_tree_selection_get_selected(selection, &model, &iter)) {
2553 gchar dirName[1024];
2556 gtk_tree_model_get(model, &iter, 0, &buffer, -1);
2557 strcpy(dirName, buffer);
2559 if (!TextureBrowser_showWads()) {
2560 strcat(dirName, "/");
2562 TextureBrowser_ShowDirectory(GlobalTextureBrowser(), dirName);
2563 TextureBrowser_queueDraw(GlobalTextureBrowser());
2567 void TextureBrowser_ToggleShowShaders()
2569 g_TextureBrowser.m_showShaders ^= 1;
2570 g_TextureBrowser.m_showshaders_item.update();
2571 TextureBrowser_queueDraw(g_TextureBrowser);
2574 void TextureBrowser_ToggleShowShaderListOnly()
2576 g_TextureBrowser_shaderlistOnly ^= 1;
2577 g_TextureBrowser.m_showshaderlistonly_item.update();
2579 TextureBrowser_constructTreeStore();
2582 void TextureBrowser_showAll()
2584 g_TextureBrowser_currentDirectory = "";
2585 g_TextureBrowser.m_searchedTags = false;
2586 TextureBrowser_heightChanged(g_TextureBrowser);
2587 TextureBrowser_updateTitle();
2590 void TextureBrowser_showUntagged()
2592 auto result = ui::alert(g_TextureBrowser.m_parent,
2593 "WARNING! This function might need a lot of memory and time. Are you sure you want to use it?",
2594 "Show Untagged", ui::alert_type::YESNO, ui::alert_icon::Warning);
2596 if (result == ui::alert_response::YES) {
2597 g_TextureBrowser.m_found_shaders.clear();
2598 TagBuilder.GetUntagged(g_TextureBrowser.m_found_shaders);
2599 std::set<CopiedString>::iterator iter;
2601 ScopeDisableScreenUpdates disableScreenUpdates("Searching untagged textures...", "Loading Textures");
2603 for (iter = g_TextureBrowser.m_found_shaders.begin(); iter != g_TextureBrowser.m_found_shaders.end(); iter++) {
2604 std::string path = (*iter).c_str();
2605 size_t pos = path.find_last_of("/", path.size());
2606 std::string name = path.substr(pos + 1, path.size());
2607 path = path.substr(0, pos + 1);
2608 TextureDirectory_loadTexture(path.c_str(), name.c_str());
2609 globalErrorStream() << path.c_str() << name.c_str() << "\n";
2612 g_TextureBrowser_currentDirectory = "Untagged";
2613 TextureBrowser_queueDraw(GlobalTextureBrowser());
2614 TextureBrowser_heightChanged(g_TextureBrowser);
2615 TextureBrowser_updateTitle();
2619 void TextureBrowser_FixedSize()
2621 g_TextureBrowser_fixedSize ^= 1;
2622 GlobalTextureBrowser().m_fixedsize_item.update();
2623 TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2626 void TextureBrowser_FilterMissing()
2628 g_TextureBrowser_filterMissing ^= 1;
2629 GlobalTextureBrowser().m_filternotex_item.update();
2630 TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2631 TextureBrowser_RefreshShaders();
2634 void TextureBrowser_FilterFallback()
2636 g_TextureBrowser_filterFallback ^= 1;
2637 GlobalTextureBrowser().m_hidenotex_item.update();
2638 TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2639 TextureBrowser_RefreshShaders();
2642 void TextureBrowser_EnableAlpha()
2644 g_TextureBrowser_enableAlpha ^= 1;
2645 GlobalTextureBrowser().m_enablealpha_item.update();
2646 TextureBrowser_activeShadersChanged(GlobalTextureBrowser());
2649 void TextureBrowser_exportTitle(const Callback<void(const char *)> &importer)
2651 StringOutputStream buffer(64);
2652 buffer << "Textures: ";
2653 if (!string_empty(g_TextureBrowser_currentDirectory.c_str())) {
2654 buffer << g_TextureBrowser_currentDirectory.c_str();
2658 importer(buffer.c_str());
2661 struct TextureScale {
2662 static void Export(const TextureBrowser &self, const Callback<void(int)> &returnz)
2664 switch (self.m_textureScale) {
2683 static void Import(TextureBrowser &self, int value)
2687 TextureBrowser_setScale(self, 10);
2690 TextureBrowser_setScale(self, 25);
2693 TextureBrowser_setScale(self, 50);
2696 TextureBrowser_setScale(self, 100);
2699 TextureBrowser_setScale(self, 200);
2705 struct UniformTextureSize {
2706 static void Export(const TextureBrowser &self, const Callback<void(int)> &returnz)
2708 returnz(g_TextureBrowser.m_uniformTextureSize);
2711 static void Import(TextureBrowser &self, int value)
2714 TextureBrowser_setUniformSize(self, value);
2719 void TextureBrowser_constructPreferences(PreferencesPage &page)
2721 page.appendCheckBox(
2722 "", "Texture scrollbar",
2723 make_property<TextureBrowser_ShowScrollbar>(GlobalTextureBrowser())
2726 const char *texture_scale[] = {"10%", "25%", "50%", "100%", "200%"};
2728 "Texture Thumbnail Scale",
2729 STRING_ARRAY_RANGE(texture_scale),
2730 make_property<TextureScale>(GlobalTextureBrowser())
2734 "Texture Thumbnail Size",
2735 GlobalTextureBrowser().m_uniformTextureSize,
2736 GlobalTextureBrowser().m_uniformTextureSize,
2739 page.appendEntry("Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement);
2741 const char *startup_shaders[] = {"None", TextureBrowser_getComonShadersName()};
2742 page.appendCombo("Load Shaders at Startup", reinterpret_cast<int &>( GlobalTextureBrowser().m_startupShaders ),
2743 STRING_ARRAY_RANGE(startup_shaders));
2747 void TextureBrowser_constructPage(PreferenceGroup &group)
2749 PreferencesPage page(group.createPage("Texture Browser", "Texture Browser Preferences"));
2750 TextureBrowser_constructPreferences(page);
2753 void TextureBrowser_registerPreferencesPage()
2755 PreferencesDialog_addSettingsPage(makeCallbackF(TextureBrowser_constructPage));
2759 #include "preferencesystem.h"
2760 #include "stringio.h"
2763 void TextureClipboard_textureSelected(const char *shader);
2765 void TextureBrowser_Construct()
2767 GlobalCommands_insert("ShaderInfo", makeCallbackF(TextureBrowser_shaderInfo));
2768 GlobalCommands_insert("ShowUntagged", makeCallbackF(TextureBrowser_showUntagged));
2769 GlobalCommands_insert("AddTag", makeCallbackF(TextureBrowser_addTag));
2770 GlobalCommands_insert("RenameTag", makeCallbackF(TextureBrowser_renameTag));
2771 GlobalCommands_insert("DeleteTag", makeCallbackF(TextureBrowser_deleteTag));
2772 GlobalCommands_insert("CopyTag", makeCallbackF(TextureBrowser_copyTag));
2773 GlobalCommands_insert("PasteTag", makeCallbackF(TextureBrowser_pasteTag));
2774 GlobalCommands_insert("RefreshShaders", makeCallbackF(VFS_Refresh));
2775 GlobalToggles_insert("ShowInUse", makeCallbackF(TextureBrowser_ToggleHideUnused),
2776 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_hideunused_item), Accelerator('U'));
2777 GlobalCommands_insert("ShowAllTextures", makeCallbackF(TextureBrowser_showAll),
2778 Accelerator('A', (GdkModifierType) GDK_CONTROL_MASK));
2779 GlobalCommands_insert("ToggleTextures", makeCallbackF(TextureBrowser_toggleShow), Accelerator('T'));
2780 GlobalToggles_insert("ToggleShowShaders", makeCallbackF(TextureBrowser_ToggleShowShaders),
2781 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_showshaders_item));
2782 GlobalToggles_insert("ToggleShowShaderlistOnly", makeCallbackF(TextureBrowser_ToggleShowShaderListOnly),
2783 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_showshaderlistonly_item));
2784 GlobalToggles_insert("FixedSize", makeCallbackF(TextureBrowser_FixedSize),
2785 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_fixedsize_item));
2786 GlobalToggles_insert("FilterMissing", makeCallbackF(TextureBrowser_FilterMissing),
2787 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_filternotex_item));
2788 GlobalToggles_insert("FilterFallback", makeCallbackF(TextureBrowser_FilterFallback),
2789 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_hidenotex_item));
2790 GlobalToggles_insert("EnableAlpha", makeCallbackF(TextureBrowser_EnableAlpha),
2791 ToggleItem::AddCallbackCaller(g_TextureBrowser.m_enablealpha_item));
2793 GlobalPreferenceSystem().registerPreference("TextureScale", make_property_string<TextureScale>(g_TextureBrowser));
2794 GlobalPreferenceSystem().registerPreference("UniformTextureSize",
2795 make_property_string<UniformTextureSize>(g_TextureBrowser));
2796 GlobalPreferenceSystem().registerPreference("TextureScrollbar", make_property_string<TextureBrowser_ShowScrollbar>(
2797 GlobalTextureBrowser()));
2798 GlobalPreferenceSystem().registerPreference("ShowShaders",
2799 make_property_string(GlobalTextureBrowser().m_showShaders));
2800 GlobalPreferenceSystem().registerPreference("ShowShaderlistOnly",
2801 make_property_string(g_TextureBrowser_shaderlistOnly));
2802 GlobalPreferenceSystem().registerPreference("FixedSize", make_property_string(g_TextureBrowser_fixedSize));
2803 GlobalPreferenceSystem().registerPreference("FilterMissing", make_property_string(g_TextureBrowser_filterMissing));
2804 GlobalPreferenceSystem().registerPreference("EnableAlpha", make_property_string(g_TextureBrowser_enableAlpha));
2805 GlobalPreferenceSystem().registerPreference("LoadShaders", make_property_string(
2806 reinterpret_cast<int &>( GlobalTextureBrowser().m_startupShaders )));
2807 GlobalPreferenceSystem().registerPreference("WheelMouseInc", make_property_string(
2808 GlobalTextureBrowser().m_mouseWheelScrollIncrement));
2809 GlobalPreferenceSystem().registerPreference("SI_Colors0",
2810 make_property_string(GlobalTextureBrowser().color_textureback));
2812 g_TextureBrowser.shader = texdef_name_default();
2814 Textures_setModeChangedNotify(ReferenceCaller<TextureBrowser, void(), TextureBrowser_queueDraw>(g_TextureBrowser));
2816 TextureBrowser_registerPreferencesPage();
2818 GlobalShaderSystem().attach(g_ShadersObserver);
2820 TextureBrowser_textureSelected = TextureClipboard_textureSelected;
2823 void TextureBrowser_Destroy()
2825 GlobalShaderSystem().detach(g_ShadersObserver);
2827 Textures_setModeChangedNotify(Callback<void()>());