gui.py

   1 import gtk, os, gobject, sys
   2
   3 from zeroinstall.injector.policy import Policy
   4 from zeroinstall.injector import download
   5 from zeroinstall.injector.model import SafeException
   6 from zeroinstall.injector.reader import InvalidInterface
   7 import dialog
   8 from checking import CheckingBox
   9
  10 version = '0.14'
  11
  12 # Singleton Policy
  13 policy = None
  14
  15 class GUIPolicy(Policy):
  16         window = None
  17         pulse = None
  18         monitored_downloads = None
  19         checking = None         # GtkDialog ("Checking for updates...")
  20         original_implementation = None
  21         download_only = None
  22         prog_args = None
  23         main_exec = None
  24
  25         def __init__(self, interface, prog_args, download_only, refresh, main):
  26                 Policy.__init__(self, interface)
  27                 global policy
  28                 assert policy is None
  29                 policy = self
  30                 self.main_exec = main
  31                 self.prog_args = prog_args
  32                 self.download_only = download_only
  33                 self.monitored_downloads = []
  34
  35                 import mainwindow
  36                 self.window = mainwindow.MainWindow(prog_args, download_only)
  37                 root = policy.get_interface(policy.root)
  38                 self.window.browser.set_root(root)
  39
  40                 if refresh:
  41                         if root.name is not None:
  42                                 self.checking = CheckingBox(root)
  43
  44                         self.refresh_all(force = False)
  45
  46         def show_details(self):
  47                 """The checking box has disappeared. Should we show the details window, or
  48                 just run the program right now?"""
  49                 if self.checking.show_details:
  50                         return True             # User clicked on the Details button
  51                 if not self.ready:
  52                         return True             # Not ready to start (can't find an implementation)
  53                 if self.versions_changed():
  54                         return True             # Confirm that the new version should be used
  55                 if self.get_uncached_implementations():
  56                         return True             # Need to download something; check first
  57                 return False
  58
  59         def monitor_download(self, dl):
  60                 self.monitored_downloads.append(dl)
  61
  62                 error_stream = dl.start()
  63                 def error_ready(src, cond):
  64                         got = os.read(src.fileno(), 100)
  65                         if not got:
  66                                 error_stream.close()
  67                                 self.monitored_downloads.remove(dl)
  68                                 if len(self.monitored_downloads) == 0:
  69                                         gobject.source_remove(self.pulse)
  70                                         self.window.progress.hide()
  71                                         self.pulse = None
  72                                 try:
  73                                         data = dl.error_stream_closed()
  74                                         self.check_signed_data(dl, data)
  75                                 except download.DownloadError, ex:
  76                                         dialog.alert(self.window,
  77                                                 "Error downloading interface '%s':\n\n%s" %
  78                                                 (dl.interface.uri, ex))
  79                                 except InvalidInterface, ex:
  80                                         dialog.alert(self.window,
  81                                                 "Syntax error in downloaded interface '%s':\n\n%s" %
  82                                                 (dl.interface.uri, ex))
  83                                 except SafeException, ex:
  84                                         dialog.alert(self.window,
  85                                                 "Error updating interface '%s':\n\n%s" %
  86                                                 (dl.interface.uri, ex))
  87
  88                                 if len(self.monitored_downloads) == 0 and self.checking:
  89                                         self.checking.updates_done(self.versions_changed())
  90                                 return False
  91                         dl.error_stream_data(got)
  92                         return True
  93
  94                 gobject.io_add_watch(error_stream,
  95                                      gobject.IO_IN | gobject.IO_HUP,
  96                                      error_ready)
  97
  98                 if self.pulse is None:
  99                         def pulse():
 100                                 if self.checking:
 101                                         self.checking.progress.pulse()
 102                                 else:
 103                                         self.window.progress.pulse()
 104                                 return True
 105                         self.pulse = gobject.timeout_add(50, pulse)
 106                         self.window.progress.show()
 107
 108         def recalculate(self):
 109                 Policy.recalculate(self)
 110                 try:
 111                         self.ready
 112                 except:
 113                         self.ready = True
 114                         print >>sys.stderr, "Your version of the injector is very old. " \
 115                                 "Try upgrading (http://0install.net/injector.html)"
 116                 else:
 117                         self.window.set_response_sensitive(gtk.RESPONSE_OK, self.ready)
 118
 119         def confirm_trust_keys(self, interface, sigs, iface_xml):
 120                 import trust_box
 121                 trust_box.confirm_trust(interface, sigs, iface_xml)
 122
 123         def main(self):
 124                 if self.checking:
 125                         self.checking.show()
 126                         if not self.monitored_downloads:
 127                                 self.checking.updates_done(self.versions_changed())
 128                         dialog.wait_for_no_windows()
 129                         show_details = self.show_details()
 130                         self.checking = None
 131                         if show_details:
 132                                 self.window.show()
 133                                 gtk.main()
 134                         else:
 135                                 import download_box
 136                                 download_box.download_with_gui(self.window, self.prog_args, main = self.main_exec,
 137                                                         run_afterwards = not self.download_only)
 138                 else:
 139                         self.window.show()
 140                         gtk.main()
 141
 142         def get_best_source(self, impl):
 143                 """Return the best download source for this implementation."""
 144                 if impl.download_sources:
 145                         return impl.download_sources[0]
 146                 return None
 147
 148         # XXX: Remove this. Moved to Policy.
 149         def refresh_all(self, force = True):
 150                 for x in self.walk_interfaces():
 151                         self.begin_iface_download(x, force)
 152
 153         def abort_all_downloads(self):
 154                 for x in self.monitored_downloads[:]:
 155                         x.abort()
 156
 157         def set_original_implementations(self):
 158                 assert self.original_implementation is None
 159                 self.original_implementation = policy.implementation.copy()
 160
 161         def versions_changed(self):
 162                 """Return whether we have now chosen any different implementations.
 163                 If so, we want to show the dialog to the user to confirm the new ones."""
 164                 if not self.ready:
 165                         return True
 166                 if not self.original_implementation:
 167                         return True             # Shouldn't happen?
 168                 if len(self.original_implementation) != len(self.implementation):
 169                         return True
 170                 for iface in self.original_implementation:
 171                         old = self.original_implementation[iface]
 172                         if old is None:
 173                                 return True
 174                         new = self.implementation.get(iface, None)
 175                         if new is None:
 176                                 return True
 177                         if old.id != new.id:
 178                                 return True
 179                 return False
 180
 181 def pretty_size(size):
 182         if size is None:
 183                 return '?'
 184         if size < 2048:
 185                 return '%d bytes' % size
 186         size = float(size)
 187         for unit in ('Kb', 'Mb', 'Gb', 'Tb'):
 188                 size /= 1024
 189                 if size < 2048:
 190                         break
 191         return '%.1f %s' % (size, unit)