+void TreeView_onRowActivated( GtkTreeView* treeview, GtkTreePath* path, GtkTreeViewColumn* col, gpointer userdata ){
+ GtkTreeIter iter;
+
+ GtkTreeModel* model = gtk_tree_view_get_model( GTK_TREE_VIEW( treeview ) );
+
+ if ( gtk_tree_model_get_iter( model, &iter, path ) ) {
+ gchar dirName[1024];
+
+ gchar* buffer;
+ gtk_tree_model_get( model, &iter, 0, &buffer, -1 );
+ strcpy( dirName, buffer );
+ g_free( buffer );
+
+ g_TextureBrowser.m_searchedTags = false;
+
+ if ( !TextureBrowser_showWads() ) {
+ strcat( dirName, "/" );
+ }
+
+ ScopeDisableScreenUpdates disableScreenUpdates( dirName, "Loading Textures" );
+ TextureBrowser_ShowDirectory( GlobalTextureBrowser(), dirName );
+ TextureBrowser_queueDraw( GlobalTextureBrowser() );
+ }
+}
+
+void TextureBrowser_createTreeViewTree(){
+ g_TextureBrowser.m_treeViewTree = ui::TreeView();
+ gtk_tree_view_set_enable_search( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTree ), FALSE );
+
+ gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTree ), FALSE );
+ g_TextureBrowser.m_treeViewTree.connect( "row-activated", (GCallback) TreeView_onRowActivated, NULL );
+
+ auto renderer = ui::CellRendererText();
+ gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTree ), -1, "", renderer, "text", 0, NULL );
+
+ TextureBrowser_constructTreeStore();
+}
+
+void TextureBrowser_addTag();
+void TextureBrowser_renameTag();
+void TextureBrowser_deleteTag();
+
+void TextureBrowser_createContextMenu( ui::Widget treeview, GdkEventButton *event ){
+ ui::Widget menu = ui::Menu();
+
+ ui::Widget menuitem = ui::MenuItem( "Add tag" );
+ menuitem.connect( "activate", (GCallback)TextureBrowser_addTag, treeview );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu ), menuitem );
+
+ menuitem = ui::MenuItem( "Rename tag" );
+ menuitem.connect( "activate", (GCallback)TextureBrowser_renameTag, treeview );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu ), menuitem );
+
+ menuitem = ui::MenuItem( "Delete tag" );
+ menuitem.connect( "activate", (GCallback)TextureBrowser_deleteTag, treeview );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu ), menuitem );
+
+ gtk_widget_show_all( menu );
+
+ gtk_menu_popup( GTK_MENU( menu ), NULL, NULL, NULL, NULL,
+ ( event != NULL ) ? event->button : 0,
+ gdk_event_get_time( (GdkEvent*)event ) );
+}
+
+gboolean TreeViewTags_onButtonPressed( ui::Widget treeview, GdkEventButton *event ){
+ if ( event->type == GDK_BUTTON_PRESS && event->button == 3 ) {
+ GtkTreePath *path;
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( treeview ) );
+
+ if ( gtk_tree_view_get_path_at_pos( GTK_TREE_VIEW( treeview ), event->x, event->y, &path, NULL, NULL, NULL ) ) {
+ gtk_tree_selection_unselect_all( selection );
+ gtk_tree_selection_select_path( selection, path );
+ gtk_tree_path_free( path );
+ }
+
+ TextureBrowser_createContextMenu( treeview, event );
+ return TRUE;
+ }
+ return FALSE;
+}
+
+void TextureBrowser_createTreeViewTags(){
+ g_TextureBrowser.m_treeViewTags = ui::TreeView();
+ gtk_tree_view_set_enable_search( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ), FALSE );
+
+ g_TextureBrowser.m_treeViewTags.connect( "button-press-event", (GCallback)TreeViewTags_onButtonPressed, NULL );
+
+ gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ), FALSE );
+
+ auto renderer = ui::CellRendererText();
+ gtk_tree_view_insert_column_with_attributes( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ), -1, "", renderer, "text", 0, NULL );
+
+ TextureBrowser_constructTreeStoreTags();
+}
+
+ui::MenuItem TextureBrowser_constructViewMenu( ui::Menu menu ){
+ ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic( "_View" ));
+
+ if ( g_Layout_enableDetachableMenus.m_value ) {
+ menu_tearoff( menu );
+ }
+
+ create_check_menu_item_with_mnemonic( menu, "Hide _Unused", "ShowInUse" );
+ if ( string_empty( g_pGameDescription->getKeyValue( "show_wads" ) ) ) {
+ create_check_menu_item_with_mnemonic( menu, "Hide Image Missing", "FilterMissing" );
+ }
+
+ // hide notex and shadernotex on texture browser: no one wants to apply them
+ create_check_menu_item_with_mnemonic( menu, "Hide Fallback", "FilterFallback" );
+
+ menu_separator( menu );
+
+ create_menu_item_with_mnemonic( menu, "Show All", "ShowAllTextures" );
+
+ // we always want to show shaders but don't want a "Show Shaders" menu for doom3 and .wad file games
+ if ( g_pGameDescription->mGameType == "doom3" || !string_empty( g_pGameDescription->getKeyValue( "show_wads" ) ) ) {
+ g_TextureBrowser.m_showShaders = true;
+ }
+ else
+ {
+ create_check_menu_item_with_mnemonic( menu, "Show shaders", "ToggleShowShaders" );
+ }
+
+ if ( g_pGameDescription->mGameType != "doom3" && string_empty( g_pGameDescription->getKeyValue( "show_wads" ) ) ) {
+ create_check_menu_item_with_mnemonic( menu, "Shaders Only", "ToggleShowShaderlistOnly" );
+ }
+ if ( g_TextureBrowser.m_tags ) {
+ create_menu_item_with_mnemonic( menu, "Show Untagged", "ShowUntagged" );
+ }
+
+ menu_separator( menu );
+ create_check_menu_item_with_mnemonic( menu, "Fixed Size", "FixedSize" );
+ create_check_menu_item_with_mnemonic( menu, "Transparency", "EnableAlpha" );
+
+ if ( string_empty( g_pGameDescription->getKeyValue( "show_wads" ) ) ) {
+ menu_separator( menu );
+ g_TextureBrowser.m_shader_info_item = ui::Widget(GTK_WIDGET( create_menu_item_with_mnemonic( menu, "Shader Info", "ShaderInfo" ) ));
+ gtk_widget_set_sensitive( g_TextureBrowser.m_shader_info_item, FALSE );
+ }
+
+
+ return textures_menu_item;
+}
+
+ui::MenuItem TextureBrowser_constructToolsMenu( ui::Menu menu ){
+ ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic( "_Tools" ));
+
+ if ( g_Layout_enableDetachableMenus.m_value ) {
+ menu_tearoff( menu );
+ }
+
+ create_menu_item_with_mnemonic( menu, "Flush & Reload Shaders", "RefreshShaders" );
+ create_menu_item_with_mnemonic( menu, "Find / Replace...", "FindReplaceTextures" );
+
+ return textures_menu_item;
+}
+
+ui::MenuItem TextureBrowser_constructTagsMenu( ui::Menu menu ){
+ ui::MenuItem textures_menu_item = ui::MenuItem(new_sub_menu_item_with_mnemonic( "T_ags" ));
+
+ if ( g_Layout_enableDetachableMenus.m_value ) {
+ menu_tearoff( menu );
+ }
+
+ create_menu_item_with_mnemonic( menu, "Add tag", "AddTag" );
+ create_menu_item_with_mnemonic( menu, "Rename tag", "RenameTag" );
+ create_menu_item_with_mnemonic( menu, "Delete tag", "DeleteTag" );
+ menu_separator( menu );
+ create_menu_item_with_mnemonic( menu, "Copy tags from selected", "CopyTag" );
+ create_menu_item_with_mnemonic( menu, "Paste tags to selected", "PasteTag" );
+
+ return textures_menu_item;
+}
+
+gboolean TextureBrowser_tagMoveHelper( GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, GSList** selected ){
+ g_assert( selected != NULL );
+
+ GtkTreeRowReference* rowref = gtk_tree_row_reference_new( model, path );
+ *selected = g_slist_append( *selected, rowref );
+
+ return FALSE;
+}
+
+void TextureBrowser_assignTags(){
+ GSList* selected = NULL;
+ GSList* node;
+ gchar* tag_assigned;
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_available_tree ) );
+
+ gtk_tree_selection_selected_foreach( selection, (GtkTreeSelectionForeachFunc)TextureBrowser_tagMoveHelper, &selected );
+
+ if ( selected != NULL ) {
+ for ( node = selected; node != NULL; node = node->next )
+ {
+ GtkTreePath* path = gtk_tree_row_reference_get_path( (GtkTreeRowReference*)node->data );
+
+ if ( path ) {
+ GtkTreeIter iter;
+
+ if ( gtk_tree_model_get_iter( GTK_TREE_MODEL( g_TextureBrowser.m_available_store ), &iter, path ) ) {
+ gtk_tree_model_get( GTK_TREE_MODEL( g_TextureBrowser.m_available_store ), &iter, TAG_COLUMN, &tag_assigned, -1 );
+ if ( !TagBuilder.CheckShaderTag( g_TextureBrowser.shader.c_str() ) ) {
+ // create a custom shader/texture entry
+ IShader* ishader = QERApp_Shader_ForName( g_TextureBrowser.shader.c_str() );
+ CopiedString filename = ishader->getShaderFileName();
+
+ if ( filename.empty() ) {
+ // it's a texture
+ TagBuilder.AddShaderNode( g_TextureBrowser.shader.c_str(), CUSTOM, TEXTURE );
+ }
+ else {
+ // it's a shader
+ TagBuilder.AddShaderNode( g_TextureBrowser.shader.c_str(), CUSTOM, SHADER );
+ }
+ ishader->DecRef();
+ }
+ TagBuilder.AddShaderTag( g_TextureBrowser.shader.c_str(), (char*)tag_assigned, TAG );
+
+ gtk_list_store_remove( g_TextureBrowser.m_available_store, &iter );
+ gtk_list_store_append( g_TextureBrowser.m_assigned_store, &iter );
+ gtk_list_store_set( g_TextureBrowser.m_assigned_store, &iter, TAG_COLUMN, (char*)tag_assigned, -1 );
+ }
+ }
+ }
+
+ g_slist_foreach( selected, (GFunc)gtk_tree_row_reference_free, NULL );
+
+ // Save changes
+ TagBuilder.SaveXmlDoc();
+ }
+ g_slist_free( selected );
+}
+
+void TextureBrowser_removeTags(){
+ GSList* selected = NULL;
+ GSList* node;
+ gchar* tag;
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_assigned_tree ) );
+
+ gtk_tree_selection_selected_foreach( selection, (GtkTreeSelectionForeachFunc)TextureBrowser_tagMoveHelper, &selected );
+
+ if ( selected != NULL ) {
+ for ( node = selected; node != NULL; node = node->next )
+ {
+ GtkTreePath* path = gtk_tree_row_reference_get_path( (GtkTreeRowReference*)node->data );
+
+ if ( path ) {
+ GtkTreeIter iter;
+
+ if ( gtk_tree_model_get_iter( GTK_TREE_MODEL( g_TextureBrowser.m_assigned_store ), &iter, path ) ) {
+ gtk_tree_model_get( GTK_TREE_MODEL( g_TextureBrowser.m_assigned_store ), &iter, TAG_COLUMN, &tag, -1 );
+ TagBuilder.DeleteShaderTag( g_TextureBrowser.shader.c_str(), tag );
+ gtk_list_store_remove( g_TextureBrowser.m_assigned_store, &iter );
+ }
+ }
+ }
+
+ g_slist_foreach( selected, (GFunc)gtk_tree_row_reference_free, NULL );
+
+ // Update the "available tags list"
+ BuildStoreAvailableTags( g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store, g_TextureBrowser.m_all_tags, &g_TextureBrowser );
+
+ // Save changes
+ TagBuilder.SaveXmlDoc();
+ }
+ g_slist_free( selected );
+}
+
+void TextureBrowser_buildTagList(){
+ GtkTreeIter treeIter;
+ gtk_list_store_clear( g_TextureBrowser.m_all_tags_list );
+
+ std::set<CopiedString>::iterator iter;
+
+ for ( iter = g_TextureBrowser.m_all_tags.begin(); iter != g_TextureBrowser.m_all_tags.end(); ++iter )
+ {
+ gtk_list_store_append( g_TextureBrowser.m_all_tags_list, &treeIter );
+ gtk_list_store_set( g_TextureBrowser.m_all_tags_list, &treeIter, TAG_COLUMN, ( *iter ).c_str(), -1 );
+ }
+}
+
+void TextureBrowser_searchTags(){
+ GSList* selected = NULL;
+ GSList* node;
+ gchar* tag;
+ char buffer[256];
+ char tags_searched[256];
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ) );
+
+ gtk_tree_selection_selected_foreach( selection, (GtkTreeSelectionForeachFunc)TextureBrowser_tagMoveHelper, &selected );
+
+ if ( selected != NULL ) {
+ strcpy( buffer, "/root/*/*[tag='" );
+ strcpy( tags_searched, "[TAGS] " );
+
+ for ( node = selected; node != NULL; node = node->next )
+ {
+ GtkTreePath* path = gtk_tree_row_reference_get_path( (GtkTreeRowReference*)node->data );
+
+ if ( path ) {
+ GtkTreeIter iter;
+
+ if ( gtk_tree_model_get_iter( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iter, path ) ) {
+ gtk_tree_model_get( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iter, TAG_COLUMN, &tag, -1 );
+
+ strcat( buffer, tag );
+ strcat( tags_searched, tag );
+ if ( node != g_slist_last( node ) ) {
+ strcat( buffer, "' and tag='" );
+ strcat( tags_searched, ", " );
+ }
+ }
+ }
+ }
+
+ strcat( buffer, "']" );
+
+ g_slist_foreach( selected, (GFunc)gtk_tree_row_reference_free, NULL );
+
+ g_TextureBrowser.m_found_shaders.clear(); // delete old list
+ TagBuilder.TagSearch( buffer, g_TextureBrowser.m_found_shaders );
+
+ if ( !g_TextureBrowser.m_found_shaders.empty() ) { // found something
+ size_t shaders_found = g_TextureBrowser.m_found_shaders.size();
+
+ globalOutputStream() << "Found " << (unsigned int)shaders_found << " textures and shaders with " << tags_searched << "\n";
+ ScopeDisableScreenUpdates disableScreenUpdates( "Searching...", "Loading Textures" );
+
+ std::set<CopiedString>::iterator iter;
+
+ for ( iter = g_TextureBrowser.m_found_shaders.begin(); iter != g_TextureBrowser.m_found_shaders.end(); iter++ )
+ {
+ std::string path = ( *iter ).c_str();
+ size_t pos = path.find_last_of( "/", path.size() );
+ std::string name = path.substr( pos + 1, path.size() );
+ path = path.substr( 0, pos + 1 );
+ TextureDirectory_loadTexture( path.c_str(), name.c_str() );
+ }
+ }
+ g_TextureBrowser.m_searchedTags = true;
+ g_TextureBrowser_currentDirectory = tags_searched;
+
+ g_TextureBrowser.m_nTotalHeight = 0;
+ TextureBrowser_setOriginY( g_TextureBrowser, 0 );
+ TextureBrowser_heightChanged( g_TextureBrowser );
+ TextureBrowser_updateTitle();
+ }
+ g_slist_free( selected );
+}
+
+void TextureBrowser_toggleSearchButton(){
+ gint page = gtk_notebook_get_current_page( GTK_NOTEBOOK( g_TextureBrowser.m_tag_notebook ) );
+
+ if ( page == 0 ) { // tag page
+ gtk_widget_show_all( g_TextureBrowser.m_search_button );
+ }
+ else {
+ gtk_widget_hide( g_TextureBrowser.m_search_button );
+ }
+}
+
+void TextureBrowser_constructTagNotebook(){
+ g_TextureBrowser.m_tag_notebook = ui::Widget(gtk_notebook_new());
+ ui::Widget labelTags = ui::Label( "Tags" );
+ ui::Widget labelTextures = ui::Label( "Textures" );
+
+ gtk_notebook_append_page( GTK_NOTEBOOK( g_TextureBrowser.m_tag_notebook ), g_TextureBrowser.m_scr_win_tree, labelTextures );
+ gtk_notebook_append_page( GTK_NOTEBOOK( g_TextureBrowser.m_tag_notebook ), g_TextureBrowser.m_scr_win_tags, labelTags );
+
+ g_TextureBrowser.m_tag_notebook.connect( "switch-page", G_CALLBACK( TextureBrowser_toggleSearchButton ), NULL );
+
+ gtk_widget_show_all( g_TextureBrowser.m_tag_notebook );
+}
+
+void TextureBrowser_constructSearchButton(){
+ ui::Widget image = ui::Widget(gtk_image_new_from_stock( GTK_STOCK_FIND, GTK_ICON_SIZE_SMALL_TOOLBAR ));
+ g_TextureBrowser.m_search_button = ui::Button();
+ g_TextureBrowser.m_search_button.connect( "clicked", G_CALLBACK( TextureBrowser_searchTags ), NULL );
+ gtk_widget_set_tooltip_text(g_TextureBrowser.m_search_button, "Search with selected tags");
+ g_TextureBrowser.m_search_button.add(image);
+}
+
+void TextureBrowser_checkTagFile(){
+ const char SHADERTAG_FILE[] = "shadertags.xml";
+ CopiedString default_filename, rc_filename;
+ StringOutputStream stream( 256 );
+
+ stream << LocalRcPath_get();
+ stream << SHADERTAG_FILE;
+ rc_filename = stream.c_str();
+
+ if ( file_exists( rc_filename.c_str() ) ) {
+ g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc( rc_filename.c_str() );
+
+ if ( g_TextureBrowser.m_tags ) {
+ globalOutputStream() << "Loading tag file " << rc_filename.c_str() << ".\n";
+ }
+ }
+ else
+ {
+ // load default tagfile
+ stream.clear();
+ stream << g_pGameDescription->mGameToolsPath.c_str();
+ stream << SHADERTAG_FILE;
+ default_filename = stream.c_str();
+
+ if ( file_exists( default_filename.c_str() ) ) {
+ g_TextureBrowser.m_tags = TagBuilder.OpenXmlDoc( default_filename.c_str(), rc_filename.c_str() );
+
+ if ( g_TextureBrowser.m_tags ) {
+ globalOutputStream() << "Loading default tag file " << default_filename.c_str() << ".\n";
+ }
+ }
+ else
+ {
+ globalErrorStream() << "Unable to find default tag file " << default_filename.c_str() << ". No tag support.\n";
+ }
+ }
+}
+
+void TextureBrowser_SetNotex(){
+ StringOutputStream name( 256 );
+ name << GlobalRadiant().getAppPath() << "bitmaps/" NOTEX_BASENAME ".png";
+ g_notex = name.c_str();
+
+ name = StringOutputStream(256);
+ name << GlobalRadiant().getAppPath() << "bitmaps/" SHADERNOTEX_BASENAME " .png";
+ g_shadernotex = name.c_str();
+}
+
+ui::Widget TextureBrowser_constructWindow( ui::Window toplevel ){
+ // The gl_widget and the tag assignment frame should be packed into a GtkVPaned with the slider
+ // position stored in local.pref. gtk_paned_get_position() and gtk_paned_set_position() don't
+ // seem to work in gtk 2.4 and the arrow buttons don't handle GTK_FILL, so here's another thing
+ // for the "once-the-gtk-libs-are-updated-TODO-list" :x
+
+ TextureBrowser_checkTagFile();
+ TextureBrowser_SetNotex();
+
+ GlobalShaderSystem().setActiveShadersChangedNotify( ReferenceCaller<TextureBrowser, TextureBrowser_activeShadersChanged>( g_TextureBrowser ) );
+
+ g_TextureBrowser.m_parent = toplevel;
+
+ ui::Widget table = ui::Table( 3, 3, FALSE );
+ ui::Widget frame_table;
+ ui::Widget vbox = ui::VBox( FALSE, 0 );
+ gtk_table_attach( GTK_TABLE( table ), vbox, 0, 1, 1, 3, GTK_FILL, GTK_FILL, 0, 0 );
+ vbox.show();
+
+ ui::Widget menu_bar;
+
+ { // menu bar
+ menu_bar = ui::Widget(gtk_menu_bar_new());
+ auto menu_view = ui::Menu();
+ auto view_item = TextureBrowser_constructViewMenu( menu_view );
+ gtk_menu_item_set_submenu( GTK_MENU_ITEM( view_item ), menu_view );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu_bar ), view_item );
+
+ auto menu_tools = ui::Menu();
+ auto tools_item = TextureBrowser_constructToolsMenu( menu_tools );
+ gtk_menu_item_set_submenu( GTK_MENU_ITEM( tools_item ), menu_tools );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu_bar ), tools_item );
+
+ gtk_table_attach( GTK_TABLE( table ), menu_bar, 0, 3, 0, 1, GTK_FILL, GTK_SHRINK, 0, 0 );
+ menu_bar.show();
+ }
+ { // Texture TreeView
+ g_TextureBrowser.m_scr_win_tree = ui::ScrolledWindow();
+ gtk_container_set_border_width( GTK_CONTAINER( g_TextureBrowser.m_scr_win_tree ), 0 );
+
+ // vertical only scrolling for treeview
+ gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( g_TextureBrowser.m_scr_win_tree ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
+
+ g_TextureBrowser.m_scr_win_tree.show();
+
+ TextureBrowser_createTreeViewTree();
+
+ gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( g_TextureBrowser.m_scr_win_tree ), GTK_WIDGET( g_TextureBrowser.m_treeViewTree ) );
+ g_TextureBrowser.m_treeViewTree.show();
+ }
+ { // gl_widget scrollbar
+ ui::Widget w = ui::Widget(gtk_vscrollbar_new( ui::Adjustment( 0,0,0,1,1,0 ) ));
+ gtk_table_attach( GTK_TABLE( table ), w, 2, 3, 1, 2, GTK_SHRINK, GTK_FILL, 0, 0 );
+ w.show();
+ g_TextureBrowser.m_texture_scroll = w;
+
+ auto vadjustment = ui::Adjustment(gtk_range_get_adjustment( GTK_RANGE( g_TextureBrowser.m_texture_scroll ) ));
+ vadjustment.connect( "value_changed", G_CALLBACK( TextureBrowser_verticalScroll ), &g_TextureBrowser );
+
+ widget_set_visible( g_TextureBrowser.m_texture_scroll, g_TextureBrowser.m_showTextureScrollbar );
+ }
+ { // gl_widget
+ g_TextureBrowser.m_gl_widget = glwidget_new( FALSE );
+ g_object_ref( g_TextureBrowser.m_gl_widget._handle );
+
+ 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 );
+ gtk_widget_set_can_focus( g_TextureBrowser.m_gl_widget, true );
+
+ gtk_table_attach_defaults( GTK_TABLE( table ), g_TextureBrowser.m_gl_widget, 1, 2, 1, 2 );
+ g_TextureBrowser.m_gl_widget.show();
+
+ g_TextureBrowser.m_sizeHandler = g_TextureBrowser.m_gl_widget.connect( "size_allocate", G_CALLBACK( TextureBrowser_size_allocate ), &g_TextureBrowser );
+ g_TextureBrowser.m_exposeHandler = g_TextureBrowser.m_gl_widget.on_render( G_CALLBACK( TextureBrowser_expose ), &g_TextureBrowser );
+
+ g_TextureBrowser.m_gl_widget.connect( "button_press_event", G_CALLBACK( TextureBrowser_button_press ), &g_TextureBrowser );
+ g_TextureBrowser.m_gl_widget.connect( "button_release_event", G_CALLBACK( TextureBrowser_button_release ), &g_TextureBrowser );
+ g_TextureBrowser.m_gl_widget.connect( "motion_notify_event", G_CALLBACK( TextureBrowser_motion ), &g_TextureBrowser );
+ g_TextureBrowser.m_gl_widget.connect( "scroll_event", G_CALLBACK( TextureBrowser_scroll ), &g_TextureBrowser );
+ }
+
+ // tag stuff
+ if ( g_TextureBrowser.m_tags ) {
+ { // fill tag GtkListStore
+ g_TextureBrowser.m_all_tags_list = ui::ListStore(gtk_list_store_new( N_COLUMNS, G_TYPE_STRING ));
+ GtkTreeSortable* sortable = GTK_TREE_SORTABLE( g_TextureBrowser.m_all_tags_list );
+ gtk_tree_sortable_set_sort_column_id( sortable, TAG_COLUMN, GTK_SORT_ASCENDING );
+
+ TagBuilder.GetAllTags( g_TextureBrowser.m_all_tags );
+ TextureBrowser_buildTagList();
+ }
+ { // tag menu bar
+ auto menu_tags = ui::Menu();
+ auto tags_item = TextureBrowser_constructTagsMenu( menu_tags );
+ gtk_menu_item_set_submenu( GTK_MENU_ITEM( tags_item ), menu_tags );
+ gtk_menu_shell_append( GTK_MENU_SHELL( menu_bar ), tags_item );
+ }
+ { // Tag TreeView
+ g_TextureBrowser.m_scr_win_tags = ui::ScrolledWindow();
+ gtk_container_set_border_width( GTK_CONTAINER( g_TextureBrowser.m_scr_win_tags ), 0 );
+
+ // vertical only scrolling for treeview
+ gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( g_TextureBrowser.m_scr_win_tags ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
+
+ TextureBrowser_createTreeViewTags();
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ) );
+ gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
+
+ gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( g_TextureBrowser.m_scr_win_tags ), GTK_WIDGET( g_TextureBrowser.m_treeViewTags ) );
+ g_TextureBrowser.m_treeViewTags.show();
+ }
+ { // Texture/Tag notebook
+ TextureBrowser_constructTagNotebook();
+ gtk_box_pack_start( GTK_BOX( vbox ), g_TextureBrowser.m_tag_notebook, TRUE, TRUE, 0 );
+ }
+ { // Tag search button
+ TextureBrowser_constructSearchButton();
+ gtk_box_pack_end( GTK_BOX( vbox ), g_TextureBrowser.m_search_button, FALSE, FALSE, 0 );
+ }
+ { // Tag frame
+ frame_table = ui::Table( 3, 3, FALSE );
+
+ g_TextureBrowser.m_tag_frame = ui::Frame( "Tag assignment" );
+ gtk_frame_set_label_align( GTK_FRAME( g_TextureBrowser.m_tag_frame ), 0.5, 0.5 );
+ gtk_frame_set_shadow_type( GTK_FRAME( g_TextureBrowser.m_tag_frame ), GTK_SHADOW_NONE );
+
+ gtk_table_attach( GTK_TABLE( table ), g_TextureBrowser.m_tag_frame, 1, 3, 2, 3, GTK_FILL, GTK_SHRINK, 0, 0 );
+
+ frame_table.show();
+
+ g_TextureBrowser.m_tag_frame.add(frame_table);
+ }
+ { // assigned tag list
+ ui::Widget scrolled_win = ui::ScrolledWindow();
+ gtk_container_set_border_width( GTK_CONTAINER( scrolled_win ), 0 );
+ gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_win ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
+
+ g_TextureBrowser.m_assigned_store = ui::ListStore(gtk_list_store_new( N_COLUMNS, G_TYPE_STRING ));
+
+ GtkTreeSortable* sortable = GTK_TREE_SORTABLE( g_TextureBrowser.m_assigned_store );
+ gtk_tree_sortable_set_sort_column_id( sortable, TAG_COLUMN, GTK_SORT_ASCENDING );
+
+ auto renderer = ui::CellRendererText();
+
+ g_TextureBrowser.m_assigned_tree = ui::TreeView(ui::TreeModel( GTK_TREE_MODEL( g_TextureBrowser.m_assigned_store ) ));
+ g_TextureBrowser.m_assigned_store.unref();
+ g_TextureBrowser.m_assigned_tree.connect( "row-activated", (GCallback) TextureBrowser_removeTags, NULL );
+ gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( g_TextureBrowser.m_assigned_tree ), FALSE );
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_assigned_tree ) );
+ gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
+
+ GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", TAG_COLUMN}} );
+ gtk_tree_view_append_column( GTK_TREE_VIEW( g_TextureBrowser.m_assigned_tree ), column );
+ g_TextureBrowser.m_assigned_tree.show();
+
+ scrolled_win.show();
+ gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( scrolled_win ), GTK_WIDGET( g_TextureBrowser.m_assigned_tree ) );
+
+ gtk_table_attach( GTK_TABLE( frame_table ), scrolled_win, 0, 1, 1, 3, GTK_FILL, GTK_FILL, 0, 0 );
+ }
+ { // available tag list
+ ui::Widget scrolled_win = ui::ScrolledWindow();
+ gtk_container_set_border_width( GTK_CONTAINER( scrolled_win ), 0 );
+ gtk_scrolled_window_set_policy( GTK_SCROLLED_WINDOW( scrolled_win ), GTK_POLICY_NEVER, GTK_POLICY_ALWAYS );
+
+ g_TextureBrowser.m_available_store = ui::ListStore(gtk_list_store_new( N_COLUMNS, G_TYPE_STRING ));
+ GtkTreeSortable* sortable = GTK_TREE_SORTABLE( g_TextureBrowser.m_available_store );
+ gtk_tree_sortable_set_sort_column_id( sortable, TAG_COLUMN, GTK_SORT_ASCENDING );
+
+ auto renderer = ui::CellRendererText();
+
+ g_TextureBrowser.m_available_tree = ui::TreeView(ui::TreeModel( GTK_TREE_MODEL( g_TextureBrowser.m_available_store ) ));
+ g_TextureBrowser.m_available_store.unref();
+ g_TextureBrowser.m_available_tree.connect( "row-activated", (GCallback) TextureBrowser_assignTags, NULL );
+ gtk_tree_view_set_headers_visible( GTK_TREE_VIEW( g_TextureBrowser.m_available_tree ), FALSE );
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_available_tree ) );
+ gtk_tree_selection_set_mode( selection, GTK_SELECTION_MULTIPLE );
+
+ GtkTreeViewColumn* column = ui::TreeViewColumn( "", renderer, {{"text", TAG_COLUMN}} );
+ gtk_tree_view_append_column( GTK_TREE_VIEW( g_TextureBrowser.m_available_tree ), column );
+ g_TextureBrowser.m_available_tree.show();
+
+ scrolled_win.show();
+ gtk_scrolled_window_add_with_viewport( GTK_SCROLLED_WINDOW( scrolled_win ), GTK_WIDGET( g_TextureBrowser.m_available_tree ) );
+
+ gtk_table_attach( GTK_TABLE( frame_table ), scrolled_win, 2, 3, 1, 3, GTK_FILL, GTK_FILL, 0, 0 );
+ }
+ { // tag arrow buttons
+ auto m_btn_left = ui::Button();
+ auto m_btn_right = ui::Button();
+ auto m_arrow_left = ui::Widget(gtk_arrow_new( GTK_ARROW_LEFT, GTK_SHADOW_OUT ));
+ auto m_arrow_right = ui::Widget(gtk_arrow_new( GTK_ARROW_RIGHT, GTK_SHADOW_OUT ));
+ m_btn_left.add(m_arrow_left);
+ m_btn_right.add(m_arrow_right);
+
+ // workaround. the size of the tag frame depends of the requested size of the arrow buttons.
+ gtk_widget_set_size_request( m_arrow_left, -1, 68 );
+ gtk_widget_set_size_request( m_arrow_right, -1, 68 );
+
+ gtk_table_attach( GTK_TABLE( frame_table ), m_btn_left, 1, 2, 1, 2, GTK_SHRINK, GTK_EXPAND, 0, 0 );
+ gtk_table_attach( GTK_TABLE( frame_table ), m_btn_right, 1, 2, 2, 3, GTK_SHRINK, GTK_EXPAND, 0, 0 );
+
+ m_btn_left.connect( "clicked", G_CALLBACK( TextureBrowser_assignTags ), NULL );
+ m_btn_right.connect( "clicked", G_CALLBACK( TextureBrowser_removeTags ), NULL );
+
+ m_btn_left.show();
+ m_btn_right.show();
+ m_arrow_left.show();
+ m_arrow_right.show();
+ }
+ { // tag fram labels
+ ui::Widget m_lbl_assigned = ui::Label( "Assigned" );
+ ui::Widget m_lbl_unassigned = ui::Label( "Available" );
+
+ gtk_table_attach( GTK_TABLE( frame_table ), m_lbl_assigned, 0, 1, 0, 1, GTK_EXPAND, GTK_SHRINK, 0, 0 );
+ gtk_table_attach( GTK_TABLE( frame_table ), m_lbl_unassigned, 2, 3, 0, 1, GTK_EXPAND, GTK_SHRINK, 0, 0 );
+
+ m_lbl_assigned.show();
+ m_lbl_unassigned.show();
+ }
+ }
+ else { // no tag support, show the texture tree only
+ gtk_box_pack_start( GTK_BOX( vbox ), g_TextureBrowser.m_scr_win_tree, TRUE, TRUE, 0 );
+ }
+
+ // TODO do we need this?
+ //gtk_container_set_focus_chain(GTK_CONTAINER(hbox_table), NULL);
+
+ return table;
+}
+
+void TextureBrowser_destroyWindow(){
+ GlobalShaderSystem().setActiveShadersChangedNotify( Callback() );
+
+ g_signal_handler_disconnect( G_OBJECT( g_TextureBrowser.m_gl_widget ), g_TextureBrowser.m_sizeHandler );
+ g_signal_handler_disconnect( G_OBJECT( g_TextureBrowser.m_gl_widget ), g_TextureBrowser.m_exposeHandler );
+
+ g_TextureBrowser.m_gl_widget.unref();
+}
+
+const Vector3& TextureBrowser_getBackgroundColour( TextureBrowser& textureBrowser ){
+ return textureBrowser.color_textureback;
+}
+
+void TextureBrowser_setBackgroundColour( TextureBrowser& textureBrowser, const Vector3& colour ){
+ textureBrowser.color_textureback = colour;
+ TextureBrowser_queueDraw( textureBrowser );
+}
+
+void TextureBrowser_selectionHelper( GtkTreeModel* model, GtkTreePath* path, GtkTreeIter* iter, GSList** selected ){
+ g_assert( selected != NULL );
+
+ gchar* name;
+ gtk_tree_model_get( model, iter, TAG_COLUMN, &name, -1 );
+ *selected = g_slist_append( *selected, name );
+}
+
+void TextureBrowser_shaderInfo(){
+ const char* name = TextureBrowser_GetSelectedShader( g_TextureBrowser );
+ IShader* shader = QERApp_Shader_ForName( name );
+
+ DoShaderInfoDlg( name, shader->getShaderFileName(), "Shader Info" );
+
+ shader->DecRef();
+}
+
+void TextureBrowser_addTag(){
+ CopiedString tag;
+
+ EMessageBoxReturn result = DoShaderTagDlg( &tag, "Add shader tag" );
+
+ if ( result == eIDOK && !tag.empty() ) {
+ GtkTreeIter iter, iter2;
+ g_TextureBrowser.m_all_tags.insert( tag.c_str() );
+ gtk_list_store_append( g_TextureBrowser.m_available_store, &iter );
+ gtk_list_store_set( g_TextureBrowser.m_available_store, &iter, TAG_COLUMN, tag.c_str(), -1 );
+
+ // Select the currently added tag in the available list
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_available_tree ) );
+ gtk_tree_selection_select_iter( selection, &iter );
+
+ gtk_list_store_append( g_TextureBrowser.m_all_tags_list, &iter2 );
+ gtk_list_store_set( g_TextureBrowser.m_all_tags_list, &iter2, TAG_COLUMN, tag.c_str(), -1 );
+ }
+}
+
+void TextureBrowser_renameTag(){
+ /* WORKAROUND: The tag treeview is set to GTK_SELECTION_MULTIPLE. Because
+ gtk_tree_selection_get_selected() doesn't work with GTK_SELECTION_MULTIPLE,
+ we need to count the number of selected rows first and use
+ gtk_tree_selection_selected_foreach() then to go through the list of selected
+ rows (which always containins a single row).
+ */
+
+ GSList* selected = NULL;
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ) );
+ gtk_tree_selection_selected_foreach( selection, GtkTreeSelectionForeachFunc( TextureBrowser_selectionHelper ), &selected );
+
+ if ( g_slist_length( selected ) == 1 ) { // we only rename a single tag
+ CopiedString newTag;
+ EMessageBoxReturn result = DoShaderTagDlg( &newTag, "Rename shader tag" );
+
+ if ( result == eIDOK && !newTag.empty() ) {
+ GtkTreeIter iterList;
+ gchar* rowTag;
+ gchar* oldTag = (char*)selected->data;
+
+ bool row = gtk_tree_model_get_iter_first( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterList ) != 0;
+
+ while ( row )
+ {
+ gtk_tree_model_get( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterList, TAG_COLUMN, &rowTag, -1 );
+
+ if ( strcmp( rowTag, oldTag ) == 0 ) {
+ gtk_list_store_set( g_TextureBrowser.m_all_tags_list, &iterList, TAG_COLUMN, newTag.c_str(), -1 );
+ }
+ row = gtk_tree_model_iter_next( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterList ) != 0;
+ }
+
+ TagBuilder.RenameShaderTag( oldTag, newTag.c_str() );
+
+ g_TextureBrowser.m_all_tags.erase( (CopiedString)oldTag );
+ g_TextureBrowser.m_all_tags.insert( newTag );
+
+ BuildStoreAssignedTags( g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(), &g_TextureBrowser );
+ BuildStoreAvailableTags( g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store, g_TextureBrowser.m_all_tags, &g_TextureBrowser );
+ }
+ }
+ else
+ {
+ ui::Widget(GTK_WIDGET( g_TextureBrowser.m_parent )).alert( "Select a single tag for renaming." );
+ }
+}
+
+void TextureBrowser_deleteTag(){
+ GSList* selected = NULL;
+
+ GtkTreeSelection* selection = gtk_tree_view_get_selection( GTK_TREE_VIEW( g_TextureBrowser.m_treeViewTags ) );
+ gtk_tree_selection_selected_foreach( selection, GtkTreeSelectionForeachFunc( TextureBrowser_selectionHelper ), &selected );
+
+ if ( g_slist_length( selected ) == 1 ) { // we only delete a single tag
+ auto result = ui::Widget(GTK_WIDGET( g_TextureBrowser.m_parent )).alert( "Are you sure you want to delete the selected tag?", "Delete Tag", ui::alert_type::YESNO, ui::alert_icon::Question );
+
+ if ( result == ui::alert_response::YES ) {
+ GtkTreeIter iterSelected;
+ gchar *rowTag;
+
+ gchar* tagSelected = (char*)selected->data;
+
+ bool row = gtk_tree_model_get_iter_first( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterSelected ) != 0;
+
+ while ( row )
+ {
+ gtk_tree_model_get( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterSelected, TAG_COLUMN, &rowTag, -1 );
+
+ if ( strcmp( rowTag, tagSelected ) == 0 ) {
+ gtk_list_store_remove( g_TextureBrowser.m_all_tags_list, &iterSelected );
+ break;
+ }
+ row = gtk_tree_model_iter_next( GTK_TREE_MODEL( g_TextureBrowser.m_all_tags_list ), &iterSelected ) != 0;
+ }
+
+ TagBuilder.DeleteTag( tagSelected );
+ g_TextureBrowser.m_all_tags.erase( (CopiedString)tagSelected );
+
+ BuildStoreAssignedTags( g_TextureBrowser.m_assigned_store, g_TextureBrowser.shader.c_str(), &g_TextureBrowser );
+ BuildStoreAvailableTags( g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store, g_TextureBrowser.m_all_tags, &g_TextureBrowser );
+ }
+ }
+ else {
+ ui::Widget(GTK_WIDGET( g_TextureBrowser.m_parent )).alert( "Select a single tag for deletion." );
+ }
+}
+
+void TextureBrowser_copyTag(){
+ g_TextureBrowser.m_copied_tags.clear();
+ TagBuilder.GetShaderTags( g_TextureBrowser.shader.c_str(), g_TextureBrowser.m_copied_tags );
+}
+
+void TextureBrowser_pasteTag(){
+ IShader* ishader = QERApp_Shader_ForName( g_TextureBrowser.shader.c_str() );
+ CopiedString shader = g_TextureBrowser.shader.c_str();
+
+ if ( !TagBuilder.CheckShaderTag( shader.c_str() ) ) {
+ CopiedString shaderFile = ishader->getShaderFileName();
+ if ( shaderFile.empty() ) {
+ // it's a texture
+ TagBuilder.AddShaderNode( shader.c_str(), CUSTOM, TEXTURE );
+ }
+ else
+ {
+ // it's a shader
+ TagBuilder.AddShaderNode( shader.c_str(), CUSTOM, SHADER );
+ }
+
+ for ( size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i )
+ {
+ TagBuilder.AddShaderTag( shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG );
+ }
+ }
+ else
+ {
+ for ( size_t i = 0; i < g_TextureBrowser.m_copied_tags.size(); ++i )
+ {
+ if ( !TagBuilder.CheckShaderTag( shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str() ) ) {
+ // the tag doesn't exist - let's add it
+ TagBuilder.AddShaderTag( shader.c_str(), g_TextureBrowser.m_copied_tags[i].c_str(), TAG );
+ }
+ }
+ }
+
+ ishader->DecRef();
+
+ TagBuilder.SaveXmlDoc();
+ BuildStoreAssignedTags( g_TextureBrowser.m_assigned_store, shader.c_str(), &g_TextureBrowser );
+ BuildStoreAvailableTags( g_TextureBrowser.m_available_store, g_TextureBrowser.m_assigned_store, g_TextureBrowser.m_all_tags, &g_TextureBrowser );
+}
+
+void TextureBrowser_RefreshShaders(){
+ ScopeDisableScreenUpdates disableScreenUpdates( "Processing...", "Loading Shaders" );
+ GlobalShaderSystem().refresh();
+ UpdateAllWindows();
+ GtkTreeSelection* selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(GlobalTextureBrowser().m_treeViewTree));
+ GtkTreeModel* model = NULL;
+ GtkTreeIter iter;
+ if ( gtk_tree_selection_get_selected (selection, &model, &iter) )
+ {
+ gchar dirName[1024];
+
+ gchar* buffer;
+ gtk_tree_model_get( model, &iter, 0, &buffer, -1 );
+ strcpy( dirName, buffer );
+ g_free( buffer );
+ if ( !TextureBrowser_showWads() ) {
+ strcat( dirName, "/" );
+ }
+ TextureBrowser_ShowDirectory( GlobalTextureBrowser(), dirName );
+ TextureBrowser_queueDraw( GlobalTextureBrowser() );
+ }
+}
+
+void TextureBrowser_ToggleShowShaders(){
+ g_TextureBrowser.m_showShaders ^= 1;
+ g_TextureBrowser.m_showshaders_item.update();
+ TextureBrowser_queueDraw( g_TextureBrowser );
+}
+
+void TextureBrowser_ToggleShowShaderListOnly(){
+ g_TextureBrowser_shaderlistOnly ^= 1;
+ g_TextureBrowser.m_showshaderlistonly_item.update();
+
+ TextureBrowser_constructTreeStore();
+}
+
+void TextureBrowser_showAll(){
+ g_TextureBrowser_currentDirectory = "";
+ g_TextureBrowser.m_searchedTags = false;
+ TextureBrowser_heightChanged( g_TextureBrowser );
+ TextureBrowser_updateTitle();
+}
+
+void TextureBrowser_showUntagged(){
+ auto result = ui::Widget(GTK_WIDGET( g_TextureBrowser.m_parent )).alert( "WARNING! This function might need a lot of memory and time. Are you sure you want to use it?", "Show Untagged", ui::alert_type::YESNO, ui::alert_icon::Warning );
+
+ if ( result == ui::alert_response::YES ) {
+ g_TextureBrowser.m_found_shaders.clear();
+ TagBuilder.GetUntagged( g_TextureBrowser.m_found_shaders );
+ std::set<CopiedString>::iterator iter;
+
+ ScopeDisableScreenUpdates disableScreenUpdates( "Searching untagged textures...", "Loading Textures" );
+
+ for ( iter = g_TextureBrowser.m_found_shaders.begin(); iter != g_TextureBrowser.m_found_shaders.end(); iter++ )
+ {
+ std::string path = ( *iter ).c_str();
+ size_t pos = path.find_last_of( "/", path.size() );
+ std::string name = path.substr( pos + 1, path.size() );
+ path = path.substr( 0, pos + 1 );
+ TextureDirectory_loadTexture( path.c_str(), name.c_str() );
+ globalErrorStream() << path.c_str() << name.c_str() << "\n";
+ }
+
+ g_TextureBrowser_currentDirectory = "Untagged";
+ TextureBrowser_queueDraw( GlobalTextureBrowser() );
+ TextureBrowser_heightChanged( g_TextureBrowser );
+ TextureBrowser_updateTitle();
+ }
+}
+
+void TextureBrowser_FixedSize(){
+ g_TextureBrowser_fixedSize ^= 1;
+ GlobalTextureBrowser().m_fixedsize_item.update();
+ TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+}
+
+void TextureBrowser_FilterMissing(){
+ g_TextureBrowser_filterMissing ^= 1;
+ GlobalTextureBrowser().m_filternotex_item.update();
+ TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+ TextureBrowser_RefreshShaders();
+}
+
+void TextureBrowser_FilterFallback(){
+ g_TextureBrowser_filterFallback ^= 1;
+ GlobalTextureBrowser().m_hidenotex_item.update();
+ TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+ TextureBrowser_RefreshShaders();
+}
+
+void TextureBrowser_EnableAlpha(){
+ g_TextureBrowser_enableAlpha ^= 1;
+ GlobalTextureBrowser().m_enablealpha_item.update();
+ TextureBrowser_activeShadersChanged( GlobalTextureBrowser() );
+}
+
+void TextureBrowser_exportTitle( const StringImportCallback& importer ){
+ StringOutputStream buffer( 64 );
+ buffer << "Textures: ";
+ if ( !string_empty( g_TextureBrowser_currentDirectory.c_str() ) ) {
+ buffer << g_TextureBrowser_currentDirectory.c_str();
+ }
+ else
+ {
+ buffer << "all";
+ }
+ importer( buffer.c_str() );
+}
+
+
+void TextureScaleImport( TextureBrowser& textureBrowser, int value ){
+ switch ( value )
+ {
+ case 0:
+ TextureBrowser_setScale( textureBrowser, 10 );
+ break;
+ case 1:
+ TextureBrowser_setScale( textureBrowser, 25 );
+ break;
+ case 2:
+ TextureBrowser_setScale( textureBrowser, 50 );
+ break;
+ case 3:
+ TextureBrowser_setScale( textureBrowser, 100 );
+ break;
+ case 4:
+ TextureBrowser_setScale( textureBrowser, 200 );
+ break;
+ }
+}
+typedef ReferenceCaller1<TextureBrowser, int, TextureScaleImport> TextureScaleImportCaller;
+
+void TextureScaleExport( TextureBrowser& textureBrowser, const IntImportCallback& importer ){
+ switch ( textureBrowser.m_textureScale )
+ {
+ case 10:
+ importer( 0 );
+ break;
+ case 25:
+ importer( 1 );
+ break;
+ case 50:
+ importer( 2 );
+ break;
+ case 100:
+ importer( 3 );
+ break;
+ case 200:
+ importer( 4 );
+ break;
+ }
+}
+typedef ReferenceCaller1<TextureBrowser, const IntImportCallback&, TextureScaleExport> TextureScaleExportCaller;
+
+
+void UniformTextureSizeImport( TextureBrowser& textureBrowser, int value ){
+
+ if ( value > 16 )
+ TextureBrowser_setUniformSize( textureBrowser, value );
+}
+typedef ReferenceCaller1<TextureBrowser, int, UniformTextureSizeImport> UniformTextureSizeImportCaller;
+
+void TextureBrowser_constructPreferences( PreferencesPage& page ){
+ page.appendCheckBox(
+ "", "Texture scrollbar",
+ TextureBrowserImportShowScrollbarCaller( GlobalTextureBrowser() ),
+ BoolExportCaller( GlobalTextureBrowser().m_showTextureScrollbar )
+ );
+ {
+ const char* texture_scale[] = { "10%", "25%", "50%", "100%", "200%" };
+ page.appendCombo(
+ "Texture Thumbnail Scale",
+ STRING_ARRAY_RANGE( texture_scale ),
+ IntImportCallback( TextureScaleImportCaller( GlobalTextureBrowser() ) ),
+ IntExportCallback( TextureScaleExportCaller( GlobalTextureBrowser() ) )
+ );
+ }
+ page.appendSpinner(
+ "Texture Thumbnail Size",
+ GlobalTextureBrowser().m_uniformTextureSize,
+ GlobalTextureBrowser().m_uniformTextureSize,
+ 16, 8192
+ );
+ page.appendEntry( "Mousewheel Increment", GlobalTextureBrowser().m_mouseWheelScrollIncrement );
+ {
+ const char* startup_shaders[] = { "None", TextureBrowser_getComonShadersName() };
+ page.appendCombo( "Load Shaders at Startup", reinterpret_cast<int&>( GlobalTextureBrowser().m_startupShaders ), STRING_ARRAY_RANGE( startup_shaders ) );
+ }
+}
+void TextureBrowser_constructPage( PreferenceGroup& group ){
+ PreferencesPage page( group.createPage( "Texture Browser", "Texture Browser Preferences" ) );
+ TextureBrowser_constructPreferences( page );
+}
+void TextureBrowser_registerPreferencesPage(){
+ PreferencesDialog_addSettingsPage( FreeCaller1<PreferenceGroup&, TextureBrowser_constructPage>() );
+}
+
+
+#include "preferencesystem.h"
+#include "stringio.h"
+
+typedef ReferenceCaller1<TextureBrowser, std::size_t, TextureBrowser_setScale> TextureBrowserSetScaleCaller;
+
+
+
+void TextureClipboard_textureSelected( const char* shader );
+
+void TextureBrowser_Construct(){
+ GlobalCommands_insert( "ShaderInfo", FreeCaller<TextureBrowser_shaderInfo>() );
+ GlobalCommands_insert( "ShowUntagged", FreeCaller<TextureBrowser_showUntagged>() );
+ GlobalCommands_insert( "AddTag", FreeCaller<TextureBrowser_addTag>() );
+ GlobalCommands_insert( "RenameTag", FreeCaller<TextureBrowser_renameTag>() );
+ GlobalCommands_insert( "DeleteTag", FreeCaller<TextureBrowser_deleteTag>() );
+ GlobalCommands_insert( "CopyTag", FreeCaller<TextureBrowser_copyTag>() );
+ GlobalCommands_insert( "PasteTag", FreeCaller<TextureBrowser_pasteTag>() );
+ GlobalCommands_insert( "RefreshShaders", FreeCaller<VFS_Refresh>() );
+ GlobalToggles_insert( "ShowInUse", FreeCaller<TextureBrowser_ToggleHideUnused>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_hideunused_item ), Accelerator( 'U' ) );
+ GlobalCommands_insert( "ShowAllTextures", FreeCaller<TextureBrowser_showAll>(), Accelerator( 'A', (GdkModifierType)GDK_CONTROL_MASK ) );
+ GlobalCommands_insert( "ToggleTextures", FreeCaller<TextureBrowser_toggleShow>(), Accelerator( 'T' ) );
+ GlobalToggles_insert( "ToggleShowShaders", FreeCaller<TextureBrowser_ToggleShowShaders>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_showshaders_item ) );
+ GlobalToggles_insert( "ToggleShowShaderlistOnly", FreeCaller<TextureBrowser_ToggleShowShaderListOnly>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_showshaderlistonly_item ) );
+ GlobalToggles_insert( "FixedSize", FreeCaller<TextureBrowser_FixedSize>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_fixedsize_item ) );
+ GlobalToggles_insert( "FilterMissing", FreeCaller<TextureBrowser_FilterMissing>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_filternotex_item ) );
+ GlobalToggles_insert( "FilterFallback", FreeCaller<TextureBrowser_FilterFallback>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_hidenotex_item ) );
+ GlobalToggles_insert( "EnableAlpha", FreeCaller<TextureBrowser_EnableAlpha>(), ToggleItem::AddCallbackCaller( g_TextureBrowser.m_enablealpha_item ) );
+
+ GlobalPreferenceSystem().registerPreference( "TextureScale",
+ makeSizeStringImportCallback( TextureBrowserSetScaleCaller( g_TextureBrowser ) ),
+ SizeExportStringCaller( g_TextureBrowser.m_textureScale )
+ );
+ GlobalPreferenceSystem().registerPreference( "UniformTextureSize",
+ makeIntStringImportCallback(UniformTextureSizeImportCaller(g_TextureBrowser)),
+ IntExportStringCaller(g_TextureBrowser.m_uniformTextureSize) );
+ GlobalPreferenceSystem().registerPreference( "TextureScrollbar",
+ makeBoolStringImportCallback( TextureBrowserImportShowScrollbarCaller( g_TextureBrowser ) ),
+ BoolExportStringCaller( GlobalTextureBrowser().m_showTextureScrollbar )
+ );
+ GlobalPreferenceSystem().registerPreference( "ShowShaders", BoolImportStringCaller( GlobalTextureBrowser().m_showShaders ), BoolExportStringCaller( GlobalTextureBrowser().m_showShaders ) );
+ GlobalPreferenceSystem().registerPreference( "ShowShaderlistOnly", BoolImportStringCaller( g_TextureBrowser_shaderlistOnly ), BoolExportStringCaller( g_TextureBrowser_shaderlistOnly ) );
+ GlobalPreferenceSystem().registerPreference( "FixedSize", BoolImportStringCaller( g_TextureBrowser_fixedSize ), BoolExportStringCaller( g_TextureBrowser_fixedSize ) );
+ GlobalPreferenceSystem().registerPreference( "FilterMissing", BoolImportStringCaller( g_TextureBrowser_filterMissing ), BoolExportStringCaller( g_TextureBrowser_filterMissing ) );
+ GlobalPreferenceSystem().registerPreference( "EnableAlpha", BoolImportStringCaller( g_TextureBrowser_enableAlpha ), BoolExportStringCaller( g_TextureBrowser_enableAlpha ) );
+ GlobalPreferenceSystem().registerPreference( "LoadShaders", IntImportStringCaller( reinterpret_cast<int&>( GlobalTextureBrowser().m_startupShaders ) ), IntExportStringCaller( reinterpret_cast<int&>( GlobalTextureBrowser().m_startupShaders ) ) );
+ GlobalPreferenceSystem().registerPreference( "WheelMouseInc", SizeImportStringCaller( GlobalTextureBrowser().m_mouseWheelScrollIncrement ), SizeExportStringCaller( GlobalTextureBrowser().m_mouseWheelScrollIncrement ) );
+ GlobalPreferenceSystem().registerPreference( "SI_Colors0", Vector3ImportStringCaller( GlobalTextureBrowser().color_textureback ), Vector3ExportStringCaller( GlobalTextureBrowser().color_textureback ) );
+
+ g_TextureBrowser.shader = texdef_name_default();
+
+ Textures_setModeChangedNotify( ReferenceCaller<TextureBrowser, TextureBrowser_queueDraw>( g_TextureBrowser ) );
+
+ TextureBrowser_registerPreferencesPage();
+
+ GlobalShaderSystem().attach( g_ShadersObserver );
+
+ TextureBrowser_textureSelected = TextureClipboard_textureSelected;
+}
+void TextureBrowser_Destroy(){
+ GlobalShaderSystem().detach( g_ShadersObserver );
+
+ Textures_setModeChangedNotify( Callback() );