src/lib/Event.py

   1 """ Event.py
   2
   3 Module for dispatching Straw-related events.
   4 """
   5 __copyright__ = "Copyright (c) 2002-2005 Free Software Foundation, Inc."
   6 __license__ = """ GNU General Public License
   7
   8 This program is free software; you can redistribute it and/or modify it under the
   9 terms of the GNU General Public License as published by the Free Software
  10 Foundation; either version 2 of the License, or (at your option) any later
  11 version.
  12
  13 This program is distributed in the hope that it will be useful, but WITHOUT
  14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
  15 FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License along with
  18 this program; if not, write to the Free Software Foundation, Inc., 59 Temple
  19 Place - Suite 330, Boston, MA 02111-1307, USA. """
  20
  21 import traceback
  22 import sys
  23 import error
  24
  25
  26 _base_cache = dict()
  27
  28 def find_bases(klass):
  29     def _find_bases(klass, d = None):
  30         if d is None:
  31             d = dict()
  32         for b in klass.__bases__:
  33             if issubclass(b, BaseSignal):
  34                 d[b] = 1
  35                 _find_bases(b, d)
  36         return tuple(d.keys())
  37     bases = _base_cache.get(klass, None)
  38     if bases is not None:
  39         return bases
  40     bases = _find_bases(klass)
  41     _base_cache[klass] = bases
  42     return bases
  43
  44 class BaseSignal:
  45     def __init__(self, sender):
  46         self.sender = sender
  47         return
  48
  49 import pycallgraph
  50 filterpy = pycallgraph.GlobbingFilter(exclude=['pycallgraph.*','*.emit_signal'])
  51
  52 class SignalEmitter:
  53     recorder = None
  54
  55     """Base class for signal emitters"""
  56     def __init__(self):
  57         self._slots = dict()
  58
  59     def initialize_slots(self, *signals):
  60         """Initialize signal slots.
  61         signals should be a list of signals this emitter is going to send."""
  62         for s in signals:
  63             self._slots[s] = dict()
  64             bs = find_bases(s)
  65             for k in bs:
  66                 self._slots[k] = dict()
  67
  68     def signal_connect(self, signal, handler, data=None):
  69         """Connect a handler to a signal in this emitter, and associate
  70         data with the callback. This will override previous bindings of
  71         signal to handler."""
  72         self._slots[signal][handler] = data
  73         return
  74
  75     def signal_disconnect(self, signal, handler):
  76         """Disconnect handler from signal."""
  77         self._slots[signal][handler] = None
  78         del self._slots[signal][handler]
  79         return
  80
  81     def emit_signal(self, signal):
  82         """Emit a signal object. Signal should be an instance of BaseSignal or
  83         a subclass."""
  84         global filterpy
  85         sclasses = find_bases(signal.__class__)
  86         for sc in sclasses + (signal.__class__,):
  87             for handler, data in self._slots.get(sc, {}).items():
  88                 if data is not None:
  89                     args = (signal, data)
  90                 else:
  91                     args = (signal,)
  92                 try:
  93                     #if self.recorder is not None:
  94                     #    self.recorder.record(sc, handler)
  95                     pycallgraph.start_trace(filter=filterpy)
  96                     apply(handler, args)
  97                     pycallgraph.stop_trace()
  98                     pycallgraph.make_dot_graph('event.png')
  99                 except:
 100                     error.log_exc("Caught an exception when trying to "
 101                                   "call a signal handler for "
 102                                   "signal %s\n" %
 103                                   str(signal))
 104                     traceback.print_exc()
 105
 106     """
 107     def start_recording(klass, recorder):
 108         klass.recorder = recorder
 109     start_recording = classmethod(start_recording)
 110
 111     def stop_recording(klass):
 112         if klass.recorder is not None:
 113             klass.recorder.stop()
 114             klass.recorder = None
 115     stop_recording = classmethod(stop_recording)
 116     """
 117
 118 # Feed creation and feed list management events
 119
 120 class FeedsChangedSignal(BaseSignal):
 121     def __init__(self, sender, feed=None):
 122         BaseSignal.__init__(self, sender)
 123         self.feed = feed
 124
 125 class FeedsEmptySignal(BaseSignal):
 126     pass
 127
 128 class FeedsImportedSignal(FeedsChangedSignal):
 129     """
 130     A signal for importing huge amount of feeds from OPML.
 131     """
 132     def __init__(self, sender, feeds,
 133                  parent=None, from_sub=False):
 134         FeedsChangedSignal.__init__(self, sender)
 135         self.feeds = feeds
 136         self.category = parent
 137         self.from_sub = from_sub
 138
 139 class FeedDeletedSignal(FeedsChangedSignal):
 140     def __init__(self, sender, feed):
 141         FeedsChangedSignal.__init__(self, sender, feed)
 142         self.feed = feed
 143
 144 class FeedCreatedSignal(FeedsChangedSignal):
 145     def __init__(self, sender, feed, category=None, index=None):
 146         FeedsChangedSignal.__init__(self, sender)
 147         self.feed = feed
 148         self.category = category
 149         self.index = index
 150
 151 # Feed detail Specific
 152 class FeedDetailChangedSignal(BaseSignal):
 153     def __init__(self, sender):
 154         BaseSignal.__init__(self, sender)
 155
 156 class ItemOrderChangedSignal(FeedDetailChangedSignal):
 157     pass
 158
 159 class FeedPollFrequencyChangedSignal(FeedDetailChangedSignal):
 160     def __init__(self, sender):
 161         BaseSignal.__init__(self, sender)
 162
 163 class FeedNumOfItemsStoredChangedSignal(FeedDetailChangedSignal):
 164     def __init__(self, sender):
 165         BaseSignal.__init__(self, sender)
 166
 167 class FeedErrorStatusChangedSignal(FeedDetailChangedSignal):
 168     pass
 169
 170 class FeedInfoUpdatedSignal(FeedDetailChangedSignal):
 171     """
 172     Feed information like title, description, copyright, etc...
 173     """
 174     def __init__(self, sender):
 175         BaseSignal.__init__(self, sender)
 176
 177 class FeedUnreadChangedSignal(FeedDetailChangedSignal):
 178     def __init__(self, sender):
 179         BaseSignal.__init__(self, sender)
 180
 181
 182 # Feed category specific
 183
 184 class FeedCategoriesChangedSignal(BaseSignal):
 185     pass
 186
 187 class FeedCategoryListChangedSignal(FeedCategoriesChangedSignal):
 188     pass
 189
 190 class FeedCategoryListLoadedSignal(FeedCategoriesChangedSignal):
 191     pass
 192
 193 class FeedCategoryAddedSignal(FeedCategoryListChangedSignal):
 194     def __init__(self, sender, category):
 195         FeedCategoryListChangedSignal.__init__(self, sender)
 196         self.category = category
 197
 198 class FeedCategoryRemovedSignal(FeedCategoryListChangedSignal):
 199     def __init__(self, sender, category):
 200         FeedCategoryListChangedSignal.__init__(self, sender)
 201         self.category = category
 202
 203 class FeedCategoryChangedSignal(FeedCategoriesChangedSignal):
 204     """ Called when a Feed Category was modified (i.e. feed added, feed
 205     removed, category title changed, etc...
 206     """
 207     def __init__(self, sender, feed=None):
 208         FeedCategoriesChangedSignal.__init__(self, sender)
 209         self.feed = feed
 210
 211 class FeedCategorySortedSignal(FeedCategoryChangedSignal):
 212     """ Called when a Feed Category has been sorted. """
 213     def __init__(self, sender, reverse=False):
 214         FeedCategoryChangedSignal.__init__(self, sender)
 215         self.descending = reverse
 216
 217 class SubscriptionContentsUpdatedSignal(BaseSignal):
 218     pass
 219
 220 # Item specific
 221 class ItemsAddedSignal(BaseSignal):
 222     def __init__(self, sender, items):
 223         BaseSignal.__init__(self, sender)
 224         self.items = items
 225
 226 class ItemDeletedSignal(BaseSignal):
 227     def __init__(self, sender, item):
 228         BaseSignal.__init__(self, sender)
 229         self.item = item
 230
 231 class NewItemsSignal(BaseSignal):
 232     def __init__(self, sender, items):
 233         BaseSignal.__init__(self, sender)
 234         self.items = items
 235
 236 class ItemStickySignal(BaseSignal):
 237     def __init__(self, sender, item=None):
 238         BaseSignal.__init__(self, sender)
 239         if item is None:
 240             item = sender
 241         self.item = item
 242
 243 class AllItemsReadSignal(BaseSignal):
 244     def __init__(self, sender, changed):
 245         BaseSignal.__init__(self, sender)
 246         self.changed = changed
 247
 248
 249 # Other events ...
 250
 251 class FeedLastPollChangedSignal(BaseSignal):
 252     pass
 253
 254 class PollChangedSignal(BaseSignal):
 255     def __init__(self, sender):
 256         BaseSignal.__init__(self, sender)
 257
 258 class FeedPolledSignal(BaseSignal):
 259     pass
 260
 261 class FeedStatusChangedSignal(BaseSignal):
 262     """
 263     Provides a signal for denoting that the polling process
 264     has begun or finished.
 265     """
 266     pass
 267
 268 class ImageUpdatedSignal(BaseSignal):
 269     def __init__(self, sender, url, data):
 270         BaseSignal.__init__(self, sender)
 271         self.url = url
 272         self.data = data
 273
 274 class NumberOfItemsStoredChangedSignal(BaseSignal):
 275     pass
 276
 277 class PollFrequencyChangedSignal(PollChangedSignal):
 278     """ Global poll frequency """
 279     def __init__(self, sender, value):
 280         PollChangedSignal.__init__(self, sender)
 281         self.value = value
 282
 283 class PollingStoppedSignal(BaseSignal):
 284     pass
 285
 286 class FeedSelectionChangedSignal(BaseSignal):
 287     """
 288     Emitted when a feed has been selected in the feeds tree view.
 289     """
 290     def __init__(self, sender, old, new):
 291         BaseSignal.__init__(self, sender)
 292         self.old = old
 293         self.new = new
 294
 295 class ItemSelectionChangedSignal(BaseSignal):
 296     """ Called when an item has been selected in the item list.
 297     Normally this should display the content of the item
 298     """
 299     def __init__(self, sender, item):
 300         BaseSignal.__init__(self, sender)
 301         self.item = item
 302
 303 class ItemReadSignal(BaseSignal):
 304     """ Called when an item's 'seen' property has been changed
 305     (i.e. marked as read)
 306     """
 307     def __init__(self, sender, item=None):
 308         BaseSignal.__init__(self, sender)
 309         if item is None:
 310             item = sender
 311         self.item = item
 312
 313 class CategorySelectionChangedSignal(BaseSignal):
 314     """
 315     Emitted when a the user changes categories
 316     """
 317     def __init__(self, sender, newcat):
 318         BaseSignal.__init__(self, sender)
 319         self.current = newcat
 320
 321 class OfflineModeChangedSignal(BaseSignal):
 322     pass
 323
 324 class RefreshFeedDisplaySignal(BaseSignal):
 325     pass
 326
 327 class StatusDisplaySignal(BaseSignal):
 328     pass
 329
 330 class FindInterruptSignal(BaseSignal):
 331     pass
 332
 333
 334 if __name__ == '__main__':
 335     print find_bases(ItemReadSignal)