src/FukuiNoNamari/threadlistmodel.py

   1 # Copyright (C) 2006 by Aiwota Programmer
   2 # aiwotaprog@tetteke.tk
   3 #
   4 # This program is free software; you can redistribute it and/or modify
   5 # it under the terms of the GNU General Public License as published by
   6 # the Free Software Foundation; either version 2 of the License, or
   7 # (at your option) any later version.
   8 #
   9 # This program is distributed in the hope that it will be useful,
  10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 # GNU General Public License for more details.
  13 #
  14 # You should have received a copy of the GNU General Public License
  15 # along with this program; if not, write to the Free Software
  16 # Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  17
  18 import pygtk
  19 pygtk.require('2.0')
  20 import gtk
  21 import itertools
  22
  23
  24 class ThreadListModel(gtk.GenericTreeModel):
  25     column_types = (str, int, str, int, int, int, float, int)
  26     column_names = ["id", "num", "title", "res", "lineCount",
  27                     "lastModified", "average", "oldRes"]
  28
  29     def __init__(self):
  30         gtk.GenericTreeModel.__init__(self)
  31         self.original_list = []
  32         self.list = []
  33         self.order_dict = {}
  34         self.sort_column_name = "num"
  35         self.sort_reverse = False
  36         self.filter_func = None
  37         self.compare_func = {}
  38
  39         self.set_list([])
  40
  41     def set_compare_func(self, name, func, key=None):
  42         self.compare_func[name] = (func, key)
  43
  44     def del_compare_func(self, name):
  45         try:
  46             del self.filter_func[name]
  47         except:
  48             pass
  49
  50     def get_dict(self, iter):
  51         path = self.get_path(iter)
  52         return self.list[path[0]]
  53
  54     def modify_row(self, dict):
  55         id = dict["id"]
  56         if id in self.order_dict:
  57             index = self.order_dict[id]
  58             target_dict = self.list[index]
  59             for name in self.column_names:
  60                 if name in dict:
  61                     target_dict[name] = dict[name]
  62             self.row_changed(index, self.get_iter(index))
  63
  64     def refilter(self, filter_func):
  65         before_size = len(self.list)
  66         self.do_filter(filter_func)
  67         after_size = len(self.list)
  68         self.do_sort(self.sort_column_name, self.sort_reverse)
  69         self.list_modified(before_size, after_size)
  70
  71     def set_list(self, newlist):
  72         self.original_list = newlist[:]
  73         self.refilter(self.filter_func)
  74
  75     def build_order_dict(self):
  76         # key: thread id, value: index in self.list
  77         self.order_dict = dict(
  78             [(item["id"], index) for index, item in enumerate(self.list)])
  79
  80     def list_modified(self, before_size, after_size):
  81         if before_size > after_size:
  82             print "remove", before_size-after_size, "threads"
  83             for i in range(before_size - after_size):
  84                 self.row_deleted(after_size)
  85         elif after_size > before_size:
  86             print "insert", after_size-before_size, "threads"
  87             for i in range(before_size, after_size):
  88                 self.row_inserted(i, self.get_iter(i))
  89
  90     def do_filter(self, filter_func):
  91         # Set filter_func to self.filter_func after successful filtering.
  92         # successful means no exception.
  93
  94         if not filter_func:
  95             self.list = self.original_list[:]
  96             self.filter_func = filter_func
  97             return
  98
  99         predicate = lambda item: filter_func(self, item)
 100         iterable = itertools.ifilter(predicate, self.original_list)
 101         self.list = [item for item in iterable]
 102         self.filter_func = filter_func
 103
 104     def compare(self, v1, v2, reverse):
 105         if not reverse:
 106             if v1 == 0 and v2 == 0:
 107                 return 0
 108             elif v1 == 0:
 109                 return 1
 110             elif v2 == 0:
 111                 return -1
 112         if v1 > v2:
 113             return 1
 114         elif v1 < v2:
 115             return -1
 116         else:
 117             return 0
 118
 119     def get_sort(self):
 120         return self.sort_column_name, self.sort_reverse
 121
 122     def do_sort(self, column_name, reverse):
 123         sort_list = self.list[:]
 124         if column_name in self.compare_func:
 125             h = self.compare_func[column_name][0]
 126             key = self.compare_func[column_name][1]
 127             if not h:
 128                 h = self.compare
 129             sort_list.sort(lambda x, y: h(x, y, reverse), key, reverse)
 130         else:
 131             if self.column_types[self.column_names.index(column_name)] == str:
 132                 sort_list.sort(None, lambda dic: dic[column_name], reverse)
 133             else:
 134                 h = lambda x, y: self.compare(x, y, reverse)
 135                 sort_list.sort(h, lambda dic: dic[column_name], reverse)
 136         self.list = sort_list
 137         self.build_order_dict()
 138
 139     def sort(self, column_name, order_specified=False, reverse=False):
 140         old_order_dict = self.order_dict
 141
 142         if order_specified:
 143             sort_reverse = reverse
 144         else:
 145             if column_name == self.sort_column_name:
 146                 # sort reverse
 147                 sort_reverse = not self.sort_reverse
 148             else:
 149                 sort_reverse = False
 150
 151         self.do_sort(column_name, sort_reverse)
 152         self.sort_column_name = column_name
 153         self.sort_reverse = sort_reverse
 154
 155         neworder = [old_order_dict[item["id"]] for item in self.list]
 156         self.rows_reordered(None, None, neworder)
 157
 158     def on_get_flags(self):
 159         return gtk.TREE_MODEL_LIST_ONLY
 160
 161     def on_get_n_columns(self):
 162         return len(self.column_types)
 163
 164     def on_get_column_type(self, n):
 165         return self.column_types[n]
 166
 167     def on_get_iter(self, path):
 168         try:
 169             return self.list[path[0]]
 170         except IndexError:
 171             return None
 172
 173     def on_get_path(self, rowref):
 174         return self.order_dict[rowref["id"]]
 175
 176     def on_get_value(self, rowref, column):
 177         return rowref[self.column_names[column]]
 178
 179     def on_iter_next(self, rowref):
 180         try:
 181             i = self.order_dict[rowref["id"]] + 1
 182             return self.list[i]
 183         except IndexError:
 184             return None
 185
 186     def on_iter_children(self, rowref):
 187         if rowref:
 188             return None
 189         return self.list[0]
 190
 191     def on_iter_has_child(self, rowref):
 192         return False
 193
 194     def on_iter_n_children(self, rowref):
 195         if rowref:
 196             return 0
 197         return len(self.list)
 198
 199     def on_iter_nth_child(self, rowref, n):
 200         if rowref:
 201             return None
 202         try:
 203             return self.list[n]
 204         except IndexError:
 205             return None
 206
 207     def on_iter_parent(self, child):
 208         return None