Source Code for Module cell_renderer_image

  1  # -*- coding:utf-8 -*- 
  2  ## src/cell_renderer_image.py 
  3  ## 
  4  ## Copyright (C) 2003-2010 Yann Leboulanger <asterix AT lagaule.org> 
  5  ## Copyright (C) 2005 Vincent Hanquez <tab AT snarc.org> 
  6  ## Copyright (C) 2005-2007 Nikos Kouremenos <kourem AT gmail.com> 
  7  ## Copyright (C) 2006 Travis Shirk <travis AT pobox.com> 
  8  ## 
  9  ## This file is part of Gajim. 
 10  ## 
 11  ## Gajim is free software; you can redistribute it and/or modify 
 12  ## it under the terms of the GNU General Public License as published 
 13  ## by the Free Software Foundation; version 3 only. 
 14  ## 
 15  ## Gajim is distributed in the hope that it will be useful, 
 16  ## but WITHOUT ANY WARRANTY; without even the implied warranty of 
 17  ## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 
 18  ## GNU General Public License for more details. 
 19  ## 
 20  ## You should have received a copy of the GNU General Public License 
 21  ## along with Gajim. If not, see <http://www.gnu.org/licenses/>. 
 22  ## 
 23   
 24   
 25  import gtk 
 26  import gobject 
 27   
 28 -class CellRendererImage(gtk.GenericCellRenderer): 
 29   
 30      __gproperties__ = { 
 31              'image': (gobject.TYPE_OBJECT, 'Image', 
 32                      'Image', gobject.PARAM_READWRITE), 
 33      } 
 34   
 35 -    def __init__(self, col_index, tv_index): 
 36          self.__gobject_init__() 
 37          self.image = None 
 38          self.col_index = col_index 
 39          self.tv_index = tv_index 
 40          self.iters = {} 
 41   
 42 -    def do_set_property(self, pspec, value): 
 43          setattr(self, pspec.name, value) 
 44   
 45 -    def do_get_property(self, pspec): 
 46          return getattr(self, pspec.name) 
 47   
 48 -    def func(self, model, path, iter_, image_tree): 
 49          image, tree = image_tree 
 50          if model.get_value(iter_, self.tv_index) != image: 
 51              return 
 52          self.redraw = 1 
 53          col = tree.get_column(self.col_index) 
 54          cell_area = tree.get_cell_area(path, col) 
 55   
 56          tree.queue_draw_area(cell_area.x, cell_area.y, 
 57                                  cell_area.width, cell_area.height) 
 58   
 59 -    def animation_timeout(self, tree, image): 
 60          if image.get_storage_type() != gtk.IMAGE_ANIMATION: 
 61              return 
 62          self.redraw = 0 
 63          iter_ = self.iters[image] 
 64          iter_.advance() 
 65          model = tree.get_model() 
 66          if model: 
 67              model.foreach(self.func, (image, tree)) 
 68          if self.redraw: 
 69              gobject.timeout_add(iter_.get_delay_time(), 
 70                              self.animation_timeout, tree, image) 
 71          elif image in self.iters: 
 72              del self.iters[image] 
 73   
 74 -    def on_render(self, window, widget, background_area, cell_area, 
 75                                      expose_area, flags): 
 76          if not self.image: 
 77              return 
 78          pix_rect = gtk.gdk.Rectangle() 
 79          pix_rect.x, pix_rect.y, pix_rect.width, pix_rect.height = \ 
 80                  self.on_get_size(widget, cell_area) 
 81   
 82          pix_rect.x += cell_area.x 
 83          pix_rect.y += cell_area.y 
 84          pix_rect.width -= 2 * self.get_property('xpad') 
 85          pix_rect.height -= 2 * self.get_property('ypad') 
 86   
 87          draw_rect = cell_area.intersect(pix_rect) 
 88          draw_rect = expose_area.intersect(draw_rect) 
 89   
 90          if self.image.get_storage_type() == gtk.IMAGE_ANIMATION: 
 91              if self.image not in self.iters: 
 92                  if not isinstance(widget, gtk.TreeView): 
 93                      return 
 94                  animation = self.image.get_animation() 
 95                  iter_ = animation.get_iter() 
 96                  self.iters[self.image] = iter_ 
 97                  gobject.timeout_add(iter_.get_delay_time(), 
 98                          self.animation_timeout, widget, self.image) 
 99   
100              pix = self.iters[self.image].get_pixbuf() 
101          elif self.image.get_storage_type() == gtk.IMAGE_PIXBUF: 
102              pix = self.image.get_pixbuf() 
103          else: 
104              return 
105          if draw_rect.x < 1: 
106              return 
107          window.draw_pixbuf(widget.style.black_gc, pix, 
108                                  draw_rect.x - pix_rect.x, 
109                                  draw_rect.y - pix_rect.y, 
110                                  draw_rect.x, draw_rect.y, 
111                                  draw_rect.width, draw_rect.height, 
112                                  gtk.gdk.RGB_DITHER_NONE, 0, 0) 
113   
114 -    def on_get_size(self, widget, cell_area): 
115          if not self.image: 
116              return 0, 0, 0, 0 
117          if self.image.get_storage_type() == gtk.IMAGE_ANIMATION: 
118              animation = self.image.get_animation() 
119              pix = animation.get_iter().get_pixbuf() 
120          elif self.image.get_storage_type() == gtk.IMAGE_PIXBUF: 
121              pix = self.image.get_pixbuf() 
122          else: 
123              return 0, 0, 0, 0 
124          pixbuf_width = pix.get_width() 
125          pixbuf_height = pix.get_height() 
126          calc_width = self.get_property('xpad') * 2 + pixbuf_width 
127          calc_height = self.get_property('ypad') * 2 + pixbuf_height 
128          x_offset = 0 
129          y_offset = 0 
130          if cell_area and pixbuf_width > 0 and pixbuf_height > 0: 
131              x_offset = self.get_property('xalign') * \ 
132                              (cell_area.width - calc_width - \ 
133                              self.get_property('xpad')) 
134              y_offset = self.get_property('yalign') * \ 
135                              (cell_area.height - calc_height - \ 
136                              self.get_property('ypad')) 
137          return x_offset, y_offset, calc_width, calc_height 
138