zeroinstall/0launch-gui/iface_browser.py

   1 # Copyright (C) 2008, Thomas Leonard
   2 # See the README file for details, or visit http://0install.net.
   3
   4 import gtk, gobject, pango
   5
   6 from zeroinstall.support import basedir, tasks, pretty_size
   7 from zeroinstall.injector.iface_cache import iface_cache
   8 from zeroinstall.injector import model
   9 import properties
  10 from treetips import TreeTips
  11 from zeroinstall import support
  12 from logging import warn
  13 import utils
  14
  15 def _stability(impl):
  16         assert impl
  17         if impl.user_stability is None:
  18                 return impl.upstream_stability
  19         return _("%s (was %s)") % (impl.user_stability, impl.upstream_stability)
  20
  21 ICON_SIZE = 20.0
  22 CELL_TEXT_INDENT = int(ICON_SIZE) + 4
  23
  24 class InterfaceTips(TreeTips):
  25         mainwindow = None
  26
  27         def __init__(self, mainwindow):
  28                 self.mainwindow = mainwindow
  29
  30         def get_tooltip_text(self, item):
  31                 interface, model_column = item
  32                 assert interface
  33                 if model_column == InterfaceBrowser.INTERFACE_NAME:
  34                         return _("Full name: %s") % interface.uri
  35                 elif model_column == InterfaceBrowser.SUMMARY:
  36                         if not interface.description:
  37                                 return None
  38                         first_para = interface.description.split('\n\n', 1)[0]
  39                         return first_para.replace('\n', ' ')
  40                 elif model_column is None:
  41                         return _("Click here for more options...")
  42
  43                 impl = self.mainwindow.policy.implementation.get(interface, None)
  44                 if not impl:
  45                         return _("No suitable implementation was found. Check the "
  46                                  "interface properties to find out why.")
  47
  48                 if model_column == InterfaceBrowser.VERSION:
  49                         text = _("Currently preferred version: %s (%s)") % \
  50                                         (impl.get_version(), _stability(impl))
  51                         old_impl = self.mainwindow.original_implementation.get(interface, None)
  52                         if old_impl is not None and old_impl is not impl:
  53                                 text += _('\nPreviously preferred version: %s (%s)') % \
  54                                         (old_impl.get_version(), _stability(old_impl))
  55                         return text
  56
  57                 assert model_column == InterfaceBrowser.DOWNLOAD_SIZE
  58
  59                 if self.mainwindow.policy.get_cached(impl):
  60                         return _("This version is already stored on your computer.")
  61                 else:
  62                         src = self.mainwindow.policy.fetcher.get_best_source(impl)
  63                         if not src:
  64                                 return _("No downloads available!")
  65                         return _("Need to download %s (%s bytes)") % \
  66                                         (support.pretty_size(src.size), src.size)
  67
  68 class MenuIconRenderer(gtk.GenericCellRenderer):
  69         def __init__(self):
  70                 gtk.GenericCellRenderer.__init__(self)
  71                 self.set_property('mode', gtk.CELL_RENDERER_MODE_ACTIVATABLE)
  72
  73         def do_set_property(self, prop, value):
  74                 setattr(self, prop.name, value)
  75
  76         def on_get_size(self, widget, cell_area, layout = None):
  77                 return (0, 0, 20, 20)
  78
  79         def on_render(self, window, widget, background_area, cell_area, expose_area, flags):
  80                 if flags & gtk.CELL_RENDERER_PRELIT:
  81                         state = gtk.STATE_PRELIGHT
  82                 else:
  83                         state = gtk.STATE_NORMAL
  84
  85                 widget.style.paint_box(window, state, gtk.SHADOW_OUT, expose_area, widget, None,
  86                                         cell_area.x, cell_area.y, cell_area.width, cell_area.height)
  87                 widget.style.paint_arrow(window, state, gtk.SHADOW_NONE, expose_area, widget, None,
  88                                         gtk.ARROW_RIGHT, True,
  89                                         cell_area.x + 5, cell_area.y + 5, cell_area.width - 10, cell_area.height - 10)
  90
  91 class IconAndTextRenderer(gtk.GenericCellRenderer):
  92         __gproperties__ = {
  93                 "image": (gobject.TYPE_OBJECT, "Image", "Image", gobject.PARAM_READWRITE),
  94                 "text": (gobject.TYPE_STRING, "Text", "Text", "-", gobject.PARAM_READWRITE),
  95         }
  96
  97         def do_set_property(self, prop, value):
  98                 setattr(self, prop.name, value)
  99
 100         def on_get_size(self, widget, cell_area, layout = None):
 101                 if not layout:
 102                         layout = widget.create_pango_layout(self.text)
 103                 a, rect = layout.get_pixel_extents()
 104
 105                 pixmap_height = self.image.get_height()
 106
 107                 both_height = max(rect[1] + rect[3], pixmap_height)
 108
 109                 return (0, 0,
 110                         rect[0] + rect[2] + CELL_TEXT_INDENT,
 111                         both_height)
 112
 113         def on_render(self, window, widget, background_area, cell_area, expose_area, flags):
 114                 layout = widget.create_pango_layout(self.text)
 115                 a, rect = layout.get_pixel_extents()
 116
 117                 if flags & gtk.CELL_RENDERER_SELECTED:
 118                         state = gtk.STATE_SELECTED
 119                 elif flags & gtk.CELL_RENDERER_PRELIT:
 120                         state = gtk.STATE_PRELIGHT
 121                 else:
 122                         state = gtk.STATE_NORMAL
 123
 124                 image_y = int(0.5 * (cell_area.height - self.image.get_height()))
 125                 window.draw_pixbuf(widget.style.white_gc, self.image, 0, 0,
 126                                 cell_area.x,
 127                                 cell_area.y + image_y)
 128
 129                 text_y = int(0.5 * (cell_area.height - (rect[1] + rect[3])))
 130
 131                 widget.style.paint_layout(window, state, True,
 132                         expose_area, widget, "cellrenderertext",
 133                         cell_area.x + CELL_TEXT_INDENT,
 134                         cell_area.y + text_y,
 135                         layout)
 136
 137 if gtk.pygtk_version < (2, 8, 0):
 138         # Note sure exactly which versions need this.
 139         # 2.8.0 gives a warning if you include it, though.
 140         gobject.type_register(IconAndTextRenderer)
 141         gobject.type_register(MenuIconRenderer)
 142
 143 class InterfaceBrowser:
 144         model = None
 145         root = None
 146         cached_icon = None
 147         policy = None
 148         original_implementation = None
 149
 150         INTERFACE = 0
 151         INTERFACE_NAME = 1
 152         VERSION = 2
 153         SUMMARY = 3
 154         DOWNLOAD_SIZE = 4
 155         ICON = 5
 156
 157         columns = [(_('Component'), INTERFACE_NAME),
 158                    (_('Version'), VERSION),
 159                    (_('Fetch'), DOWNLOAD_SIZE),
 160                    (_('Description'), SUMMARY),
 161                    ('', None)]
 162
 163         def __init__(self, policy, widgets):
 164                 tips = InterfaceTips(self)
 165
 166                 tree_view = widgets.get_widget('components')
 167
 168                 self.policy = policy
 169                 self.cached_icon = {}   # URI -> GdkPixbuf
 170                 self.default_icon = tree_view.style.lookup_icon_set(gtk.STOCK_EXECUTE).render_icon(tree_view.style,
 171                         gtk.TEXT_DIR_NONE, gtk.STATE_NORMAL, gtk.ICON_SIZE_SMALL_TOOLBAR, tree_view, None)
 172
 173                 self.model = gtk.TreeStore(object, str, str, str, str, gtk.gdk.Pixbuf)
 174                 self.tree_view = tree_view
 175                 tree_view.set_model(self.model)
 176
 177                 column_objects = []
 178
 179                 text = gtk.CellRendererText()
 180
 181                 for name, model_column in self.columns:
 182                         if model_column == InterfaceBrowser.INTERFACE_NAME:
 183                                 column = gtk.TreeViewColumn(name, IconAndTextRenderer(),
 184                                                 text = model_column,
 185                                                 image = InterfaceBrowser.ICON)
 186                         elif model_column == None:
 187                                 menu_column = column = gtk.TreeViewColumn('', MenuIconRenderer())
 188                         else:
 189                                 if model_column == InterfaceBrowser.SUMMARY:
 190                                         text_ellip = gtk.CellRendererText()
 191                                         try:
 192                                                 text_ellip.set_property('ellipsize', pango.ELLIPSIZE_END)
 193                                         except:
 194                                                 pass
 195                                         column = gtk.TreeViewColumn(name, text_ellip, text = model_column)
 196                                         column.set_expand(True)
 197                                 else:
 198                                         column = gtk.TreeViewColumn(name, text, text = model_column)
 199                         tree_view.append_column(column)
 200                         column_objects.append(column)
 201
 202                 tree_view.set_enable_search(True)
 203
 204                 selection = tree_view.get_selection()
 205
 206                 def motion(tree_view, ev):
 207                         if ev.window is not tree_view.get_bin_window():
 208                                 return False
 209                         pos = tree_view.get_path_at_pos(int(ev.x), int(ev.y))
 210                         if pos:
 211                                 path = pos[0]
 212                                 try:
 213                                         col_index = column_objects.index(pos[1])
 214                                 except ValueError:
 215                                         tips.hide()
 216                                 else:
 217                                         col = self.columns[col_index][1]
 218                                         row = self.model[path]
 219                                         item = (row[InterfaceBrowser.INTERFACE], col)
 220                                         if item != tips.item:
 221                                                 tips.prime(tree_view, item)
 222                         else:
 223                                 tips.hide()
 224
 225                 tree_view.connect('motion-notify-event', motion)
 226                 tree_view.connect('leave-notify-event', lambda tv, ev: tips.hide())
 227
 228                 def button_press(tree_view, bev):
 229                         pos = tree_view.get_path_at_pos(int(bev.x), int(bev.y))
 230                         if not pos:
 231                                 return False
 232                         path, col, x, y = pos
 233
 234                         if (bev.button == 3 or (bev.button < 4 and col is menu_column)) \
 235                            and bev.type == gtk.gdk.BUTTON_PRESS:
 236                                 selection.select_path(path)
 237                                 iface = self.model[path][InterfaceBrowser.INTERFACE]
 238                                 self.show_popup_menu(iface, bev)
 239                                 return True
 240                         if bev.button != 1 or bev.type != gtk.gdk._2BUTTON_PRESS:
 241                                 return False
 242                         properties.edit(policy, self.model[path][InterfaceBrowser.INTERFACE])
 243                 tree_view.connect('button-press-event', button_press)
 244
 245                 tree_view.connect('destroy', lambda s: policy.watchers.remove(self.build_tree))
 246                 policy.watchers.append(self.build_tree)
 247
 248         def set_root(self, root):
 249                 assert isinstance(root, model.Interface)
 250                 self.root = root
 251
 252         def get_icon(self, iface):
 253                 """Get an icon for this interface. If the icon is in the cache, use that.
 254                 If not, start a download. If we already started a download (successful or
 255                 not) do nothing. Returns None if no icon is currently available."""
 256                 try:
 257                         return self.cached_icon[iface.uri]
 258                 except KeyError:
 259                         path = iface_cache.get_icon_path(iface)
 260                         if path:
 261                                 try:
 262                                         loader = gtk.gdk.PixbufLoader('png')
 263                                         try:
 264                                                 loader.write(file(path).read())
 265                                         finally:
 266                                                 loader.close()
 267                                         icon = loader.get_pixbuf()
 268                                         assert icon, "Failed to load cached PNG icon data"
 269                                 except Exception, ex:
 270                                         warn("Failed to load cached PNG icon: %s", ex)
 271                                         return None
 272                                 w = icon.get_width()
 273                                 h = icon.get_height()
 274                                 scale = max(w, h, 1) / ICON_SIZE
 275                                 icon = icon.scale_simple(int(w / scale),
 276                                                          int(h / scale),
 277                                                          gtk.gdk.INTERP_BILINEAR)
 278                                 self.cached_icon[iface.uri] = icon
 279                                 return icon
 280                         else:
 281                                 # Try to download the icon
 282                                 fetcher = self.policy.download_icon(iface)
 283                                 if fetcher:
 284                                         @tasks.async
 285                                         def update_display():
 286                                                 yield fetcher
 287                                                 try:
 288                                                         tasks.check(fetcher)
 289                                                         self.build_tree()
 290                                                 except Exception, ex:
 291                                                         import traceback
 292                                                         traceback.print_exc()
 293                                                         self.policy.handler.report_error(ex)
 294                                         update_display()
 295
 296                 return None
 297
 298         def build_tree(self):
 299                 if self.original_implementation is None:
 300                         self.set_original_implementations()
 301
 302                 done = {}       # Detect cycles
 303
 304                 self.model.clear()
 305                 parent = None
 306                 def add_node(parent, iface):
 307                         if iface in done:
 308                                 return
 309                         done[iface] = True
 310
 311                         iter = self.model.append(parent)
 312                         self.model[iter][InterfaceBrowser.INTERFACE] = iface
 313                         self.model[iter][InterfaceBrowser.INTERFACE_NAME] = iface.get_name()
 314                         self.model[iter][InterfaceBrowser.SUMMARY] = iface.summary
 315                         self.model[iter][InterfaceBrowser.ICON] = self.get_icon(iface) or self.default_icon
 316
 317                         impl = self.policy.implementation.get(iface, None)
 318                         if impl:
 319                                 old_impl = self.original_implementation.get(iface, None)
 320                                 version_str = impl.get_version()
 321                                 if old_impl is not None and old_impl is not impl:
 322                                         version_str += " (was " + old_impl.get_version() + ")"
 323                                 self.model[iter][InterfaceBrowser.VERSION] = version_str
 324
 325                                 self.model[iter][InterfaceBrowser.DOWNLOAD_SIZE] = utils.get_fetch_info(self.policy, impl)
 326                                 if hasattr(impl, 'requires'):
 327                                         children = impl.requires
 328                                 else:
 329                                         children = impl.dependencies
 330
 331                                 for child in children:
 332                                         if isinstance(child, model.InterfaceDependency):
 333                                                 add_node(iter, iface_cache.get_interface(child.interface))
 334                                         else:
 335                                                 child_iter = self.model.append(parent)
 336                                                 self.model[child_iter][InterfaceBrowser.INTERFACE_NAME] = '?'
 337                                                 self.model[child_iter][InterfaceBrowser.SUMMARY] = \
 338                                                         'Unknown dependency type : %s' % child
 339                                                 self.model[child_iter][InterfaceBrowser.ICON] = self.default_icon
 340                         else:
 341                                 self.model[iter][InterfaceBrowser.VERSION] = '(choose)'
 342                 add_node(None, self.root)
 343                 self.tree_view.expand_all()
 344
 345         def show_popup_menu(self, iface, bev):
 346                 import bugs
 347
 348                 if properties.have_source_for(self.policy, iface):
 349                         def compile_cb():
 350                                 import compile
 351                                 compile.compile(self.policy, iface)
 352                 else:
 353                         compile_cb = None
 354
 355                 menu = gtk.Menu()
 356                 for label, cb in [(_('Show Feeds'), lambda: properties.edit(self.policy, iface)),
 357                                   (_('Show Versions'), lambda: properties.edit(self.policy, iface, show_versions = True)),
 358                                   (_('Report a Bug...'), lambda: bugs.report_bug(self.policy, iface)),
 359                                   (_('Compile...'), compile_cb)]:
 360                         item = gtk.MenuItem(label)
 361                         if cb:
 362                                 item.connect('activate', lambda item, cb=cb: cb())
 363                         else:
 364                                 item.set_sensitive(False)
 365                         item.show()
 366                         menu.append(item)
 367                 menu.popup(None, None, None, bev.button, bev.time)
 368
 369         def set_original_implementations(self):
 370                 assert self.original_implementation is None
 371                 self.original_implementation = self.policy.implementation.copy()
 372
 373         def update_download_status(self):
 374                 """Called at regular intervals while there are downloads in progress,
 375                 and once at the end. Also called when things are added to the store.
 376                 Update the TreeView with the interfaces."""
 377                 hints = {}
 378                 for dl in self.policy.handler.monitored_downloads.values():
 379                         if dl.hint:
 380                                 if dl.hint not in hints:
 381                                         hints[dl.hint] = []
 382                                 hints[dl.hint].append(dl)
 383
 384                 selections = self.policy.solver.selections
 385
 386                 def walk(it):
 387                         while it:
 388                                 yield self.model[it]
 389                                 for x in walk(self.model.iter_children(it)): yield x
 390                                 it = self.model.iter_next(it)
 391
 392                 for row in walk(self.model.get_iter_root()):
 393                         iface = row[InterfaceBrowser.INTERFACE]
 394
 395                         # Is this interface the download's hint?
 396                         downloads = hints.get(iface, [])        # The interface itself
 397                         downloads += hints.get(iface.uri, [])   # The main feed
 398                         for feed in iface.feeds:
 399                                 downloads += hints.get(feed.uri, []) # Other feeds
 400                         impl = selections.get(iface, None)
 401                         if impl:
 402                                 downloads += hints.get(impl, []) # The chosen implementation
 403
 404                         if downloads:
 405                                 so_far = 0
 406                                 expected = None
 407                                 for dl in downloads:
 408                                         if dl.expected_size:
 409                                                 expected = (expected or 0) + dl.expected_size
 410                                         so_far += dl.get_bytes_downloaded_so_far()
 411                                 if expected:
 412                                         fraction = "%s [%.2f%%]" % (pretty_size(expected), 100 * so_far / float(expected))
 413                                 else:
 414                                         fraction = "unknown"
 415                                 if len(downloads) > 1:
 416                                         fraction += " in %d downloads" % len(downloads)
 417                                 row[InterfaceBrowser.SUMMARY] = "(downloading %s/%s)" % (pretty_size(so_far), fraction)
 418                         else:
 419                                 row[InterfaceBrowser.DOWNLOAD_SIZE] = utils.get_fetch_info(self.policy, impl)
 420                                 row[InterfaceBrowser.SUMMARY] = iface.summary