src/Hage1/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
  22
  23 class ThreadListModel(gtk.GenericTreeModel):
  24     column_types = (str, int, str, int, int, int, int)
  25     column_names = ["id", "num", "title", "res", "lineCount",
  26                     "lastModified", "average"]
  27
  28     def __init__(self, list=None, sort_column_name="num", sort_reverse=False,
  29                  filter_func=None):
  30         gtk.GenericTreeModel.__init__(self)
  31         if list:
  32             self.original_list = list[:]
  33         else:
  34             self.original_list = []
  35
  36         self.sort_column_name = sort_column_name
  37         self.sort_reverse = sort_reverse
  38         self.filter_func = filter_func
  39
  40         self.do_filter()
  41         self.do_sort(self.sort_column_name, self.sort_reverse)
  42
  43     def modify_row(self, dict):
  44         id = dict["id"]
  45         if id in self.order_dict:
  46             index = self.order_dict[id]
  47             target_dict = self.list[index]
  48             for name in self.column_names:
  49                 if name in dict:
  50                     target_dict[name] = dict[name]
  51             self.row_changed(index, self.get_iter(index))
  52
  53     def refilter(self):
  54         before_size = len(self.list)
  55         self.do_filter()
  56         after_size = len(self.list)
  57         self.do_sort(self.sort_column_name, self.sort_reverse)
  58         self.list_modified(before_size, after_size)
  59
  60     def set_list(self, newlist):
  61         self.original_list = newlist[:]
  62         self.refilter()
  63
  64     def set_filter_func(func):
  65         self.filter_func = func
  66
  67     def build_order_dict(self):
  68         # key: thread id, value: index in self.list
  69         self.order_dict = dict(
  70             [(item["id"], index) for index, item in enumerate(self.list)])
  71
  72     def list_modified(self, before_size, after_size):
  73         if before_size > after_size:
  74             print "remove", before_size-after_size, "threads"
  75             for i in range(before_size - after_size):
  76                 self.row_deleted(after_size)
  77         elif after_size > before_size:
  78             print "insert", after_size-before_size, "threads"
  79             for i in range(before_size, after_size):
  80                 self.row_inserted(i, self.get_iter(i))
  81
  82     def do_filter(self):
  83         if not self.filter_func:
  84             self.list = self.original_list[:]
  85             return
  86
  87         self.list = []
  88         for item in self.original_list:
  89             if self.filter_func(self, item):
  90                 self.list.append(item)
  91
  92     def compare(self, v1, v2, reverse):
  93         if not reverse:
  94             if v1 == 0 and v2 == 0:
  95                 return 0
  96             elif v1 == 0:
  97                 return 1
  98             elif v2 == 0:
  99                 return -1
 100         return v1 - v2
 101
 102     def get_sort(self):
 103         return self.sort_column_name, self.sort_reverse
 104
 105     def do_sort(self, column_name, reverse):
 106         if self.column_types[self.column_names.index(column_name)] == str:
 107             self.list.sort(None, lambda dic: dic[column_name], reverse)
 108         else:
 109             h = lambda x, y: self.compare(x, y, reverse)
 110             self.list.sort(h, lambda dic: dic[column_name], reverse)
 111         self.build_order_dict()
 112
 113     def sort(self, column_name):
 114         old_order_dict = self.order_dict
 115
 116         if column_name == self.sort_column_name:
 117             # sort reverse
 118             self.sort_reverse = not self.sort_reverse
 119         else:
 120             self.sort_column_name = column_name
 121             self.sort_reverse = False
 122
 123         self.do_sort(self.sort_column_name, self.sort_reverse)
 124
 125         neworder = [old_order_dict[item["id"]] for item in self.list]
 126         self.rows_reordered(None, None, neworder)
 127
 128     def on_get_flags(self):
 129         return gtk.TREE_MODEL_LIST_ONLY
 130
 131     def on_get_n_columns(self):
 132         return len(self.column_types)
 133
 134     def on_get_column_type(self, n):
 135         return self.column_types[n]
 136
 137     def on_get_iter(self, path):
 138         try:
 139             return self.list[path[0]]
 140         except IndexError:
 141             return None
 142
 143     def on_get_path(self, rowref):
 144         return self.order_dict[rowref["id"]]
 145
 146     def on_get_value(self, rowref, column):
 147         return rowref[self.column_names[column]]
 148
 149     def on_iter_next(self, rowref):
 150         try:
 151             i = self.order_dict[rowref["id"]] + 1
 152             return self.list[i]
 153         except IndexError:
 154             return None
 155
 156     def on_iter_children(self, rowref):
 157         if rowref:
 158             return None
 159         return self.list[0]
 160
 161     def on_iter_has_child(self, rowref):
 162         return False
 163
 164     def on_iter_n_children(self, rowref):
 165         if rowref:
 166             return 0
 167         return len(self.list)
 168
 169     def on_iter_nth_child(self, rowref, n):
 170         if rowref:
 171             return None
 172         try:
 173             return self.list[n]
 174         except IndexError:
 175             return None
 176
 177     def on_iter_parent(self, child):
 178         return None