tworu/dzgui
1
0 Fork 0
mirror of https://github.com/aclist/dztui.git synced 2026-10-31 07:02:50 +01:00
Code Issues Actions 1 Packages Projects Releases Wiki Activity

feat: attach FilterManager to each ServerTreeView

Browse Source
This commit is contained in:
aclist committed 2026-02-23 22:57:59 +09:00
1 parent 5bcb2b279d
commit ed7f803d47
8 files changed
+121 -159
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

dzgui/controllers/mc.py
+9 -40
View File
@@ -204,8 +204,10 @@ class Controller(GObject.GObject):
self.toggle_config(Preferences.DEBUG) self.toggle_config(Preferences.DEBUG)
def get_active_context(self) -> Gtk.TreeView: def get_active_context(self) -> Gtk.TreeView:
tv = self.get_active_treeview() return self.get_active_treeview().get_enum()
return tv.get_enum()
def get_active_filterman(self) -> "FilterManager":
return self.get_active_treeview().get_filter_man()
def get_active_treeview(self) -> "ServerTreeView": def get_active_treeview(self) -> "ServerTreeView":
return self.mediator.notebook.servers.get_active_treeview() return self.mediator.notebook.servers.get_active_treeview()
@@ -596,10 +598,6 @@ class Controller(GObject.GObject):
def get_proxy_man(self) -> "ProxyModelManager": def get_proxy_man(self) -> "ProxyModelManager":
return self.proxy_man return self.proxy_man
# def set_proxy_man(self, proxy_man: "ProxyModelManager") -> None:
# # TODO: used when staging filter man outside of thread
# self.proxy_man = proxy_man
def populate_model(self, tv: Gtk.TreeView) -> None: def populate_model(self, tv: Gtk.TreeView) -> None:
# NOTE: skip on previously loaded tabs # NOTE: skip on previously loaded tabs
if tv.is_loaded(): if tv.is_loaded():
@@ -607,26 +605,13 @@ class Controller(GObject.GObject):
return return
ServerModelManager(self, tv).load() ServerModelManager(self, tv).load()
def get_favorite(self) -> tuple[str, str] | tuple[None, None]:
fav = str(self.query_config(Preferences.FAV_LBL))
if len(fav) < 1:
return None, None
ip = str(self.query_config(Preferences.FAV_SRV))
addr = ip.split(":")
return fav, f"{addr[0]}:{addr[2]}"
def get_dist_cache(self) -> dict[str, "Haversine", "ServerTab"]: def get_dist_cache(self) -> dict[str, "Haversine", "ServerTab"]:
return self.dist_cache return self.dist_cache
def get_filters(self) -> list: def get_filters(self) -> list:
return self.mediator.filters.get_filters() return self.mediator.filters.get_filters()
# TODO: filterman calls back to here, gets convoluted # TODO: clean up routes between controller and filter panel
def get_keyword(self) -> str:
tv = self.get_active_treeview()
proxy_man = tv.get_proxy_man()
return proxy_man.get_keyword_filter()
def get_map_store(self) -> Gtk.ListStore: def get_map_store(self) -> Gtk.ListStore:
filter_man = self.get_filter_man() filter_man = self.get_filter_man()
return filter_man.get_map_store() return filter_man.get_map_store()
@@ -639,16 +624,7 @@ class Controller(GObject.GObject):
filter_man = self.get_filter_man() filter_man = self.get_filter_man()
return filter_man.get_filters() return filter_man.get_filters()
def get_prior_map(self) -> str: # TODO: rename
filter_man = self.get_filter_man()
return filter_man.get_prior_map()
def get_active_map(self) -> None:
return self.get_filter_man().get_active_map()
def set_active_map(self, ind: int) -> None:
self.get_filter_man().set_active_map(ind)
def _on_servers_loaded_init(self, emitter: "Emitter") -> None: def _on_servers_loaded_init(self, emitter: "Emitter") -> None:
# FIXME: wipe maps store when changing tabs if model is none # FIXME: wipe maps store when changing tabs if model is none
tv = self.get_active_treeview() tv = self.get_active_treeview()
@@ -661,23 +637,16 @@ class Controller(GObject.GObject):
treeview = self.get_active_treeview() treeview = self.get_active_treeview()
return treeview.get_model() is not None return treeview.get_model() is not None
# TODO: this could be internal to filter panel now
def _on_check_toggled(self, emitter: Emitter, label: str, state: bool) -> None: def _on_check_toggled(self, emitter: Emitter, label: str, state: bool) -> None:
filter_man = self.get_filter_man() filter_man = self.get_filter_man()
filter_man.set_filter(label, state) filter_man.set_filter(label, state)
if state: mode = FilterMode.TOGGLE_ON if state else FilterMODE.TOGGLE_OFF
mode = FilterMode.TOGGLE_ON
else:
mode = FilterMode.TOGGLE_OFF
ServerModelManager(self, self.get_active_treeview()).refilter(mode, label) ServerModelManager(self, self.get_active_treeview()).refilter(mode, label)
# TODO: map man should be consolidated into filter man
def _on_map_selection_changed(self, emitter: Emitter, selection: str) -> None: def _on_map_selection_changed(self, emitter: Emitter, selection: str) -> None:
filter_man = self.get_filter_man() smm = ServerModelManager(self, self.get_active_treeview())
filter_man.set_selected_map(selection) smm.refilter(FilterMode.MAP, selection)
# FIXME: label should not be mandatory
ServerModelManager(self, self.get_active_treeview()).refilter(FilterMode.MAP, selection)
def get_notebook(self) -> "Notebook": def get_notebook(self) -> "Notebook":
return self.mediator.notebook return self.mediator.notebook
dzgui/managers/config.py
+8
View File
@@ -54,6 +54,14 @@ class ConfigManager:
def get_favorites(self) -> list[str]: def get_favorites(self) -> list[str]:
return self.lookup(Preferences.IP_LIST) return self.lookup(Preferences.IP_LIST)
def get_favorite(self) -> tuple[str, str] | tuple[None, None]:
fav = str(self.lookup(Preferences.FAV_LBL))
if len(fav) < 1:
return None, None
ip = str(self.lookup(Preferences.FAV_SRV))
addr = ip.split(":")
return fav, f"{addr[0]}:{addr[2]}"
def is_in_favs(self, record: str) -> bool: def is_in_favs(self, record: str) -> bool:
favs = self.get_favorites() favs = self.get_favorites()
if record in favs: if record in favs:
dzgui/managers/filter_man.py
+36 -21
View File
@@ -12,8 +12,6 @@ class FilterManager:
def __init__(self) -> None: def __init__(self) -> None:
self.map_store = ModelFactory().make_map_store() self.map_store = ModelFactory().make_map_store()
self.prior_map: str
self.selected_map = all_maps
# TODO: namespace under strings.filters # TODO: namespace under strings.filters
self.default_filters = { self.default_filters = {
@@ -30,18 +28,37 @@ class FilterManager:
strings.filter_unofficial: True, strings.filter_unofficial: True,
strings.filter_modded: True, strings.filter_modded: True,
} }
self.active_map = 0
self.active_keyword = ""
self.active_map = (0, all_maps)
self.prior_map = all_maps
self.filters: list self.filters: list
self.enabled_filters = dict(self.default_filters) self.enabled_filters = dict(self.default_filters)
def reinit_filters(self) -> None: # def reinit_filters(self) -> None:
self.enabled_filters = dict(self.default_filters) # self.enabled_filters = dict(self.default_filters)
def get_prior_map(self) -> str:
return self.prior_map
def set_prior_map(self, name: str) -> None:
self.prior_map = name
def get_active_map_name(self) -> str:
return self.active_map[1]
def get_active_map(self) -> int: def get_active_map(self) -> int:
return self.active_map return self.active_map
def set_active_map(self, ind: int) -> None: def set_active_map(self, ind: int, name: str) -> None:
self.active_map = ind self.active_map = (ind, name)
def get_active_keyword(self) -> str:
return self.active_keyword
def set_active_keyword(self, word: str) -> None:
self.active_keyword = word
def get_default_filters(self) -> dict: def get_default_filters(self) -> dict:
"""Deep copy of defaults""" """Deep copy of defaults"""
@@ -60,24 +77,14 @@ class FilterManager:
model = ModelFactory().make_map_store() model = ModelFactory().make_map_store()
model.append([all_maps]) model.append([all_maps])
self.map_store = model self.map_store = model
self.selected_map = all_maps self.active_map = (0, all_maps)
def get_prior_map(self) -> str: def get_prior_map(self) -> str:
return self.prior_map return self.prior_map
def get_selected_map(self) -> str:
return self.selected_map
def set_selected_map(self, selection: str) -> str:
self.prior_map = self.selected_map
self.selected_map = selection
def append_map(self, row: list[str]) -> None: def append_map(self, row: list[str]) -> None:
self.map_store.append(row) self.map_store.append(row)
def clear_map_store(self) -> None:
self.map_store.clear()
def set_unique_maps(self, maps: list) -> None: def set_unique_maps(self, maps: list) -> None:
if maps is None: if maps is None:
return return
@@ -88,6 +95,14 @@ class FilterManager:
for m in maps: for m in maps:
self.append_map([m]) self.append_map([m])
# when switching views, just grab the map store, active keyword, active map, and selected checks def get_all_filters(self) -> tuple:
# for that view and apply them to filter panel outside of thread map_name = self.get_active_map_name()
# initialize proxyman with access to filterman enabled = self.get_filters()
kw = self.get_active_keyword()
filters = []
filters.append(map_name)
filters.append(kw)
for filt in enabled:
if enabled[filt] is False:
filters.append(filt)
return tuple(filters)
dzgui/model/proxy_model.py
+37 -40
View File
@@ -1,55 +1,57 @@
import re import re
from typing import Optional, TYPE_CHECKING from typing import Optional, TYPE_CHECKING
from warnings import deprecated
from dzgui.const.enum import FilterMode from dzgui.const.enum import FilterMode
from dzgui.model.model_factory import ModelFactory from dzgui.model.model_factory import ModelFactory
from dzgui.util import strings from dzgui.util import strings
import gi # import gi
#
gi.require_version("Gtk", "3.0") # gi.require_version("Gtk", "3.0")
from gi.repository.Gtk import ListStore # noqa E402 # from gi.repository.Gtk import ListStore # noqa E402
from gi.repository import GObject, GLib # noqa E402 # from gi.repository import GObject, GLib # noqa E402
if TYPE_CHECKING: if TYPE_CHECKING:
from dzgui.controllers.mc import Controller # from dzgui.controllers.mc import Controller
from dzgui.controllers.emitter import Emitter # from dzgui.controllers.emitter import Emitter
from dzgui.managers.filter_man import FilterManager
from dzgui.model.model_factory import FastInsertListStore
class ProxyModelManager: class ProxyModelManager:
""" """
Manages access to cached ListStore resources and Manages access to cached FastInsertListStore resources and
performs filtering on behalf of atomic TreeViews, performs filtering on behalf of atomic TreeViews,
which share the same column structure. which share the same column structure.
A ProxyModelManager is attached to each ServerTreeView. A ProxyModelManager is attached to each ServerTreeView.
Raw data is cached before being packed into a ListStore, see get_control() Raw data is cached before being packed into a FastInsertListStore, see get_control()
Filtration creates a proxy of the TreeView's model, see get_proxy_model() Filtration creates a proxy of the TreeView's model, see get_proxy_model()
""" """
def __init__(self, controller: "Controller") -> None: def __init__(self, filter_man: "FilterManager") -> None:
self.controller = controller # self.emitter = controller.get_emitter()
self.emitter = controller.get_emitter() # self.emitter.connect("keyword_set", self._on_keyword_set)
self.emitter.connect("keyword_set", self._on_keyword_set)
self.filter_cache = {} self.filter_cache = {}
self.ping_cache: dict[str, int] = {} self.ping_cache: dict[str, int] = {}
self.proxy_model: ListStore = None self.proxy_model: "FastInsertListStore" = None
self.filter_man = filter_man
self.control_model: list = None self.control_model: list = None
self.filtered: list = None self.filtered: list = None
self.success = True self.success = True
self.keyword_filter = ""
def get_keyword_filter(self) -> str: # def get_keyword_filter(self) -> str:
return self.keyword_filter # return self.keyword_filter
def _on_keyword_set(self, emitter: "Emitter", keyword: str) -> None: # def _on_keyword_set(self, emitter: "Emitter", keyword: str) -> None:
self.keyword_filter = keyword # self.keyword_filter = keyword
def append_row(self, row: list) -> None: def append_row(self, row: list) -> None:
self.proxy_model.append(row) self.proxy_model.append(row)
@@ -57,19 +59,19 @@ class ProxyModelManager:
def clear_proxy_model(self) -> None: def clear_proxy_model(self) -> None:
self.proxy_model.clear() self.proxy_model.clear()
def get_proxy_model(self) -> ListStore: def get_proxy_model(self) -> "FastInsertListStore":
return self.proxy_model return self.proxy_model
def new_model_from_class(self, cls: type) -> ListStore: # def new_model_from_class(self, cls: type) -> ListStore:
store = ListStore(*[ftype for field, ftype in cls.__annotations__.items()]) # store = ListStore(*[ftype for field, ftype in cls.__annotations__.items()])
return store # return store
#
def filter(self, mode: FilterMode, *args, **kwargs) -> None: def filter(self, mode: FilterMode, *args, **kwargs) -> None:
""" """
Native Gtk.TreeView.refilter() method was not performant enough Native Gtk.TreeView.refilter() method was not performant enough
when running in the main loop with 40k+ records when running in the main loop with 40k+ records
""" """
filters = self.controller.get_filters() filters = self.filter_man.get_all_filters()
if filters in self.filter_cache: if filters in self.filter_cache:
cache = self.filter_cache[filters] cache = self.filter_cache[filters]
@@ -82,7 +84,7 @@ class ProxyModelManager:
rows = self.filter_initial(filters) rows = self.filter_initial(filters)
case FilterMode.MAP: case FilterMode.MAP:
prior_map = self.controller.get_prior_map() prior_map = self.filter_man.get_prior_map()
if prior_map == strings.all_maps: if prior_map == strings.all_maps:
rows = self.filter_map(filters) rows = self.filter_map(filters)
@@ -107,7 +109,7 @@ class ProxyModelManager:
# if row[7] in self.ping_cache: # if row[7] in self.ping_cache:
# row[9] = self.ping_cache[row[7]] # row[9] = self.ping_cache[row[7]]
# NOTE: this ListStore manipulation must remain local to the thread # NOTE: this FastInsertListStore manipulation must remain local to the thread
clone = ModelFactory().make_server_store() clone = ModelFactory().make_server_store()
if len(rows) > 0: if len(rows) > 0:
rows = self.sort_rows(rows) rows = self.sort_rows(rows)
@@ -135,7 +137,7 @@ class ProxyModelManager:
Multi-filtration for any context starts by narrowing by map Multi-filtration for any context starts by narrowing by map
""" """
rows = self.filtered rows = self.filtered
sel_map = self.controller.get_selected_map() sel_map = self.filter_man.get_active_map_name()
if sel_map == strings.all_maps: if sel_map == strings.all_maps:
return rows return rows
@@ -144,7 +146,7 @@ class ProxyModelManager:
return rows return rows
def filter_keyword(self, filters: tuple) -> list: def filter_keyword(self, filters: tuple) -> list:
keyword = self.keyword_filter keyword = self.filter_man.get_active_keyword()
rows = self.filtered rows = self.filtered
if keyword == "": if keyword == "":
@@ -219,7 +221,7 @@ class ProxyModelManager:
self.set_filtered(self.filter_toggle_off(filters, f)) self.set_filtered(self.filter_toggle_off(filters, f))
return self.filtered return self.filtered
def set_cache(self, filters: tuple, model: ListStore | None, rows: list) -> None: def set_cache(self, filters: tuple, model: Optional["FastInsertListStore"], rows: list) -> None:
self.filter_cache[filters] = (model, rows) self.filter_cache[filters] = (model, rows)
def resync_model(self, addr: str, qport: int) -> None: def resync_model(self, addr: str, qport: int) -> None:
@@ -233,11 +235,12 @@ class ProxyModelManager:
self.control_model.remove(row) self.control_model.remove(row)
self.wipe_cache() self.wipe_cache()
filters = self.controller.get_filters() filters = self.get_filters()
refiltered = self.filter_toggle_on(filters) refiltered = self.filter_toggle_on(filters)
self.set_filtered(refiltered) self.set_filtered(refiltered)
def convert_model_to_list(self, model: ListStore) -> list: @deprecated("Currently unused")
def convert_model_to_list(self, model: "FastInsertListStore") -> list:
return [[el for el in row] for row in model] return [[el for el in row] for row in model]
def set_filtered(self, rows: Optional[list]) -> None: def set_filtered(self, rows: Optional[list]) -> None:
@@ -248,9 +251,9 @@ class ProxyModelManager:
def get_filtered(self) -> list: def get_filtered(self) -> list:
return self.filtered return self.filtered
def set_proxy_model(self, model: ListStore | None) -> None: def set_proxy_model(self, model: Optional["FastInsertListStore"]) -> None:
""" """
ListStore representation of the raw model after filtration FastInsertListStore representation of the raw model after filtration
""" """
self.proxy_model = model self.proxy_model = model
@@ -282,9 +285,3 @@ class ProxyModelManager:
self.ping_cache = {} self.ping_cache = {}
# if full: # if full:
# self.control_model = None # self.control_model = None
def set_active_map(self, _map: str) -> None:
self.active_map = _map
def get_active_map(self) -> str:
return self.active_map
dzgui/model/servers.py
+1 -2
View File
@@ -304,10 +304,9 @@ class ServerModelManager:
# if data is None: # if data is None:
# self.to_insert = None # self.to_insert = None
# else: # else:
# FIXME: filterman calls GTK methods in thread
# if mode == FilterMode.INITIAL:
manager = self._get_proxy_man() manager = self._get_proxy_man()
# TODO: consolidate these methods
manager.wipe_cache() manager.wipe_cache()
manager.set_control(data) manager.set_control(data)
manager.filter(FilterMode.INITIAL) manager.filter(FilterMode.INITIAL)
dzgui/views/components/connect_panel.py
+2 -1
View File
@@ -123,7 +123,7 @@ class FavPanel(Gtk.Frame):
emitter = self.controller.get_emitter() emitter = self.controller.get_emitter()
emitter.connect("fav_server_changed", self._on_fav_server_changed) emitter.connect("fav_server_changed", self._on_fav_server_changed)
self.server_name, self.server_ip = self.controller.get_favorite() self.server_name, self.server_ip = self.controller.get_config_man().get_favorite() #self.controller.get_favorite()
server_name = ( server_name = (
f"{self.server_name} ({self.server_ip})" f"{self.server_name} ({self.server_ip})"
if self.server_name is not None if self.server_name is not None
@@ -207,6 +207,7 @@ class AddPanel(Gtk.Frame):
def _submit_query(self) -> None: def _submit_query(self) -> None:
text = self.entry.get_text() text = self.entry.get_text()
# TODO: grabs ServerTab.SAVED ServerTreeView
saved = self.controller.get_servers().get_saved() saved = self.controller.get_servers().get_saved()
ServerModelManager(self.controller, saved)._add_by_id_or_ip(text) ServerModelManager(self.controller, saved)._add_by_id_or_ip(text)
dzgui/views/components/filter_panel.py
+23 -50
View File
@@ -4,6 +4,7 @@ from typing import Literal, TYPE_CHECKING
from dzgui.const.enum import FilterMode from dzgui.const.enum import FilterMode
from dzgui.const.constants import EXPAND, NO_EXPAND, NO_FILL, NO_PADDING, SEARCH_ICON from dzgui.const.constants import EXPAND, NO_EXPAND, NO_FILL, NO_PADDING, SEARCH_ICON
from dzgui.model.servers import ServerModelManager from dzgui.model.servers import ServerModelManager
from dzgui.util.strings import all_maps
from dzgui.views.components.labels import BoldLabel from dzgui.views.components.labels import BoldLabel
import gi import gi
@@ -82,6 +83,7 @@ class KeywordEntry(Gtk.Entry):
# TODO :strings # TODO :strings
super().__init__(placeholder_text="Filter by keyword") super().__init__(placeholder_text="Filter by keyword")
self.keyword = ""
self.controller = controller self.controller = controller
self.emitter = controller.get_emitter() self.emitter = controller.get_emitter()
self.connect("activate", self._on_activated) self.connect("activate", self._on_activated)
@@ -112,13 +114,18 @@ class KeywordEntry(Gtk.Entry):
# self.controller.mediator.window.set_keep_below(False) # self.controller.mediator.window.set_keep_below(False)
keyword = entry.get_text().lower() keyword = entry.get_text().lower()
if keyword == self.controller.get_keyword(): if keyword == self.keyword:
return return
if keyword.isspace(): if keyword.isspace():
return return
self.keyword = keyword
# TODO: delegate to controller
tv = self.controller.get_active_treeview()
filter_man = tv.get_filter_man()
filter_man.set_active_keyword(keyword)
logger.info(f"User filtered by keyword '{keyword}'") logger.info(f"User filtered by keyword '{keyword}'")
self.emitter.emit("keyword_set", keyword)
ServerModelManager( ServerModelManager(
self.controller, self.controller.get_active_treeview() self.controller, self.controller.get_active_treeview()
@@ -141,15 +148,8 @@ class FilterPanel(Gtk.Box):
self.controller.register_widget("filters", self) self.controller.register_widget("filters", self)
self.emitter = self.controller.get_emitter() self.emitter = self.controller.get_emitter()
# TODO: strings self.sel_map = all_maps
self.sel_map = "All maps"
# TODO: each treeview for that tab context has its own filter manager, independent of this
# self.selected_map: str = strings.all_maps
# self.prior_map: str = strings.all_maps
# self.set_orientation(Gtk.Orientation.VERTICAL)
# TODO: initialize to empty
filter_man = self.controller.get_filter_man() filter_man = self.controller.get_filter_man()
defaults = filter_man.get_default_filters() defaults = filter_man.get_default_filters()
self.map_store = filter_man.get_map_store() self.map_store = filter_man.get_map_store()
@@ -191,9 +191,6 @@ class FilterPanel(Gtk.Box):
self.maps_combo.connect("changed", self._on_map_changed) self.maps_combo.connect("changed", self._on_map_changed)
self.maps_combo.connect("key-press-event", self._on_combo_keypress) self.maps_combo.connect("key-press-event", self._on_combo_keypress)
# FIXME: should be a property of treeview's meta manager
self.active_map = 0
for el in ( for el in (
self.filters_label, self.filters_label,
self.keyword_entry, self.keyword_entry,
@@ -212,38 +209,15 @@ class FilterPanel(Gtk.Box):
for i, row in enumerate(model): for i, row in enumerate(model):
if text == row[0]: if text == row[0]:
self.maps_combo.set_active(i) self.maps_combo.set_active(i)
# self.controller.set_active_map(i)
# print("HERE3")
# TODO: use same sort of signal to reinitialize keyword and checks
def _on_maps_loaded(self, emitter: "Emitter", store: Gtk.ListStore) -> None: def _on_maps_loaded(self, emitter: "Emitter", store: Gtk.ListStore) -> None:
self.maps_combo.set_model(store) self.maps_combo.set_model(store)
ind = self.controller.get_active_map() tv = self.controller.get_active_treeview()
ind, name = tv.filter_man.get_active_map()
self.maps_combo.set_active(ind) self.maps_combo.set_active(ind)
self.button_grid.reload_filters() self.button_grid.reload_filters()
# TODO: move into metamanager
def get_filters(self) -> tuple:
selected = self.controller.get_selected_map()
enabled = self.controller.get_enabled_filters()
filters = []
filters.append(selected)
filters.append(self.controller.get_keyword())
for filt in enabled:
if enabled[filt] is False:
filters.append(filt)
return tuple(filters)
# TODO: should be used when switching ServerTab contexts
# use signals here
# def reinit_panel(self) -> None:
# self.keyword_entry.set_text("")
# self.keyword_filter = ""
# self.reinit_filters()
# self.set_visible(False)
# sel_panel = self.controller.mediator.grid.sel_panel
# if sel_panel.is_visible():
# sel_panel.set_visible(False)
# TODO: this chiefly applies when clicking refresh button, etc. # TODO: this chiefly applies when clicking refresh button, etc.
# and setting filters to default state # and setting filters to default state
# def reinit_filters(self) -> None: # def reinit_filters(self) -> None:
@@ -296,12 +270,6 @@ class FilterPanel(Gtk.Box):
case _: case _:
return False return False
# def get_active_combo(self) -> int:
# return self.maps_combo.get_active()
#
# def set_active_combo(self, row: int) -> None:
# self.maps_combo.set_active(row)
def toggle_check_by_key(self, emitter: "Emitter", keyval: int) -> bool: def toggle_check_by_key(self, emitter: "Emitter", keyval: int) -> bool:
mappings = { mappings = {
Gdk.KEY_1: 0, Gdk.KEY_1: 0,
@@ -333,10 +301,15 @@ class FilterPanel(Gtk.Box):
ind = combo.get_active() ind = combo.get_active()
if ind < 0: if ind < 0:
return return
selection = self.maps_entry.get_text() name = self.maps_entry.get_text()
self.sel_map = selection self.prior_map = self.sel_map
self.emitter.emit("map_selection_changed", selection) self.sel_map = name
# TODO: abstraction into controller:
# pass ind, name
tv = self.controller.get_active_treeview() tv = self.controller.get_active_treeview()
proxy_man = tv.get_proxy_man() filter_man = tv.get_filter_man()
proxy_man.set_active_map(selection) filter_man.set_prior_map(name)
filter_man.set_active_map(ind, name)
self.emitter.emit("map_selection_changed", name)
dzgui/views/trees/tree_servers.py
+5 -5
View File
@@ -45,12 +45,11 @@ class ServerTreeView(ContextMixin, TreeView):
self.loaded = False self.loaded = False
self.proxy_man = ProxyModelManager(controller) self.filter_man = FilterManager()
self.proxy_man = ProxyModelManager(self.filter_man)
model = self.proxy_man.get_proxy_model() model = self.proxy_man.get_proxy_model()
self.set_model(model) self.set_model(model)
self.filter_man = FilterManager()
self.set_fixed_height_mode(True) self.set_fixed_height_mode(True)
# NOTE: headers become visible on model load # NOTE: headers become visible on model load
self.set_headers_visible(False) self.set_headers_visible(False)
@@ -125,7 +124,7 @@ class ServerTreeView(ContextMixin, TreeView):
# TODO: why is this being saved? # TODO: why is this being saved?
self.thread = None self.thread = None
def start_timeout(self) -> None: def start_queue_checker(self) -> None:
self.queue_id = GLib.timeout_add(QUEUE_CHECK_DELAY, self._check_result_queue) self.queue_id = GLib.timeout_add(QUEUE_CHECK_DELAY, self._check_result_queue)
def get_filter_man(self) -> FilterManager: def get_filter_man(self) -> FilterManager:
@@ -165,10 +164,11 @@ class ServerTreeView(ContextMixin, TreeView):
self.emitter.emit("lan_tab_toggled", True) self.emitter.emit("lan_tab_toggled", True)
store = self.filter_man.get_map_store() store = self.filter_man.get_map_store()
# FIXME: if model is none, wipe maps # FIXME: if model is none, wipe maps
self.emitter.emit("load_maps", store) self.emitter.emit("load_maps", store)
self.handler_id = self.emitter.connect("statusbar_loaded", self.start_distcalc) self.handler_id = self.emitter.connect("statusbar_loaded", self.start_distcalc)
self.start_timeout() self.start_queue_checker()
self.start_distcalc() self.start_distcalc()
def _on_unmap(self, a) -> None: def _on_unmap(self, a) -> None: