home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2006 November (DVD) / PCWELT_11_2006.ISO / casper / filesystem.squashfs / usr / lib / python2.4 / site-packages / serpentine / preferences.pyc (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2006-08-31  |  10.7 KB  |  294 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.4)
  3.  
  4. import nautilusburn
  5. import os
  6. import gconf
  7. import gtk
  8. from gtk import glade
  9. from os import path
  10. from types import StringType
  11. from gettext import gettext as _
  12. import gaw
  13. import xspf
  14. import gtkutil
  15. import release
  16. import urlutil
  17. from converting import GvfsMusicPool
  18. from common import SafeFileWrite
  19. GCONF_DIR = '/apps/serpentine'
  20. RAT_GCONF_DIR = '/apps/rat'
  21. NCB_GCONF_DIR = '/apps/nautilus-cd-burner'
  22. for gconf_dir in (GCONF_DIR, RAT_GCONF_DIR, NCB_GCONF_DIR):
  23.     gconf.client_get_default().add_dir(gconf_dir, gconf.CLIENT_PRELOAD_NONE)
  24.  
  25.  
  26. def recordingPreferencesWindow(preferences):
  27.     prefs_widget = gtkutil.find_child_widget(preferences.dialog, 'preferences')
  28.     prefs_widget.show()
  29.     if not prefs_widget is not None:
  30.         raise AssertionError
  31.     parent = prefs_widget.get_parent()
  32.     parent.remove(prefs_widget)
  33.     win = gtk.Window(gtk.WINDOW_TOPLEVEL)
  34.     win.set_border_width(12)
  35.     win.set_title(_('Serpentine Preferences'))
  36.     vbox = gtk.VBox()
  37.     vbox.set_spacing(18)
  38.     vbox.show()
  39.     win.add(vbox)
  40.     vbox.pack_start(prefs_widget)
  41.     bbox = gtk.HButtonBox()
  42.     bbox.set_layout(gtk.BUTTONBOX_END)
  43.     bbox.show()
  44.     vbox.add(bbox)
  45.     close_btn = gtk.Button(stock = 'gtk-close')
  46.     close_btn.show()
  47.     close_btn.connect('clicked', gtk.main_quit)
  48.     bbox.add(close_btn)
  49.     return win
  50.  
  51.  
  52. class HideCloseButton:
  53.     """
  54.     Monitors the 'rat' key for showing/hiding the close button.
  55.     """
  56.     
  57.     def __init__(self, close_button):
  58.         self.button = close_button
  59.         self.use_button = gaw.GConfValue(key = RAT_GCONF_DIR + '/use_close_button', data_spec = gaw.Spec.BOOL, default = True)
  60.         self.use_button.set_callback(self.on_update)
  61.         self.on_update()
  62.  
  63.     
  64.     def on_update(self, *args):
  65.         if not self.use_button.data:
  66.             self.button.hide()
  67.         else:
  68.             self.button.show()
  69.  
  70.  
  71.  
  72. class WriteSpeed:
  73.     '''
  74.     Handles and monitors writing speed related widgets state.
  75.     '''
  76.     
  77.     def __init__(self, g, get_drive):
  78.         self.get_drive = get_drive
  79.         self._WriteSpeed__speed = gaw.data_spin_button(g.get_widget('speed'), GCONF_DIR + '/write_speed')
  80.         self._WriteSpeed__specify_speed = g.get_widget('specify_speed_wrapper')
  81.         specify_speed = g.get_widget('specify_speed')
  82.         self._WriteSpeed__speed_select = gaw.RadioButtonData(widgets = dict(specify_speed = specify_speed, use_max_speed = g.get_widget('use_max_speed')), key = GCONF_DIR + '/speed_select')
  83.         self._WriteSpeed__speed_select.seleted_by_default = 'use_max_speed'
  84.         specify_speed.connect('toggled', self._WriteSpeed__on_specify_speed)
  85.         g.get_widget('refresh_speed').connect('clicked', self._WriteSpeed__on_refresh_speed)
  86.         self._WriteSpeed__on_specify_speed(specify_speed)
  87.         if self._WriteSpeed__speed.data == 0:
  88.             self._WriteSpeed__speed.data = 99
  89.         
  90.         self._WriteSpeed__update_speed()
  91.         self._WriteSpeed__speed.sync_widget()
  92.         self._WriteSpeed__speed.widget.set_sensitive(specify_speed.get_active())
  93.  
  94.     
  95.     def get(self):
  96.         if not self.get_drive() is not None:
  97.             raise AssertionError
  98.         self._WriteSpeed__update_speed()
  99.         if self._WriteSpeed__speed_select.data == 'use_max_speed':
  100.             return self.get_drive().get_max_speed_write()
  101.         
  102.         return self._WriteSpeed__speed.data
  103.  
  104.     
  105.     def __on_refresh_speed(self, *args):
  106.         self._WriteSpeed__update_speed()
  107.  
  108.     
  109.     def __update_speed(self):
  110.         drive = self.get_drive()
  111.         if drive is None:
  112.             self._WriteSpeed__speed.widget.set_sensitive(False)
  113.             return None
  114.         
  115.         speed = drive.get_max_speed_write()
  116.         if not speed >= 0:
  117.             raise AssertionError, speed
  118.         val = self._WriteSpeed__speed.data
  119.         self._WriteSpeed__speed.widget.set_range(1, speed)
  120.         self._WriteSpeed__speed.data = val
  121.  
  122.     
  123.     def __on_specify_speed(self, widget, *args):
  124.         self._WriteSpeed__specify_speed.set_sensitive(widget.get_active())
  125.  
  126.  
  127.  
  128. class RecordingPreferences(object):
  129.     debug = False
  130.     overburn = False
  131.     simulate = False
  132.     
  133.     def __init__(self, locations):
  134.         self._RecordingPreferences__write_flags = nautilusburn.RECORDER_WRITE_BURNPROOF
  135.         self.version = release.version
  136.         filename = locations.get_data_file('serpentine.glade')
  137.         g = glade.XML(filename, 'preferences_dialog')
  138.         self._RecordingPreferences__dialog = g.get_widget('preferences_dialog')
  139.         self.dialog.connect('destroy-event', self._RecordingPreferences__on_destroy)
  140.         self.dialog.set_title('')
  141.         drv = g.get_widget('drive')
  142.         cmb_drv = nautilusburn.DriveSelection()
  143.         cmb_drv.set_property('show-recorders-only', True)
  144.         cmb_drv.show()
  145.         self._RecordingPreferences__drive_selection = cmb_drv
  146.         drv.pack_start(cmb_drv, False, False)
  147.         self._RecordingPreferences__speed = WriteSpeed(g, self._RecordingPreferences__drive_selection.get_drive)
  148.         self._RecordingPreferences__eject = gaw.data_toggle_button(g.get_widget('eject'), GCONF_DIR + '/eject')
  149.         self._RecordingPreferences__use_gap = gaw.data_toggle_button(g.get_widget('use_gap'), GCONF_DIR + '/use_gap', default = True)
  150.         ncb_temp_dir = NCB_GCONF_DIR + '/temp_iso_dir'
  151.         gconf.client_get_default().add_dir(ncb_temp_dir, gconf.CLIENT_PRELOAD_NONE)
  152.         self._RecordingPreferences__tmp = gaw.GConfValue(key = ncb_temp_dir, data_spec = gaw.Spec.STRING, default = 'file:///tmp')
  153.         self._RecordingPreferences__debug = gaw.GConfValue(key = GCONF_DIR + '/debug_mode', data_spec = gaw.Spec.BOOL, default = False)
  154.         self._RecordingPreferences__pool = GvfsMusicPool()
  155.         self._RecordingPreferences__close_button_handler = HideCloseButton(g.get_widget('close_btn'))
  156.  
  157.     __config_dir = path.join(path.expanduser('~'), '.serpentine')
  158.     
  159.     def getConfigDir(self):
  160.         return self._RecordingPreferences__config_dir
  161.  
  162.     configDir = property((lambda self: self._RecordingPreferences__config_dir))
  163.     
  164.     def getDialog(self):
  165.         return self._RecordingPreferences__dialog
  166.  
  167.     dialog = property(getDialog)
  168.     
  169.     def setVersion(self, version):
  170.         if not isinstance(version, StringType):
  171.             raise AssertionError
  172.         self._RecordingPreferences__version = version
  173.  
  174.     
  175.     def getVersion(self):
  176.         return self._RecordingPreferences__version
  177.  
  178.     version = property(getVersion, setVersion)
  179.     
  180.     def getDrive(self):
  181.         return self._RecordingPreferences__drive_selection.get_drive()
  182.  
  183.     drive = property(getDrive)
  184.     
  185.     def getUseGnomeVfs(self):
  186.         return self._RecordingPreferences__pool.use_gnomevfs
  187.  
  188.     
  189.     def setUseGnomeVfs(self, use_gnomevfs):
  190.         self._RecordingPreferences__pool.use_gnomevfs = use_gnomevfs
  191.  
  192.     useGnomeVfs = property(getUseGnomeVfs, setUseGnomeVfs)
  193.     
  194.     def getTemporaryDir(self):
  195.         tmp = self._RecordingPreferences__tmp.data
  196.         url = urlutil.UrlParse(tmp)
  197.         if url.is_local:
  198.             return url.path
  199.         
  200.  
  201.     temporaryDir = property(getTemporaryDir)
  202.     
  203.     def getUseGap(self):
  204.         return self._RecordingPreferences__use_gap.data
  205.  
  206.     useGap = property(getUseGap)
  207.     
  208.     def getPool(self):
  209.         return self._RecordingPreferences__pool
  210.  
  211.     pool = property(getPool)
  212.     
  213.     def getSpeedWrite(self):
  214.         return self._RecordingPreferences__speed.get()
  215.  
  216.     speedWrite = property(getSpeedWrite)
  217.     
  218.     def getWriteFlags(self):
  219.         ret = self._RecordingPreferences__write_flags
  220.         if not self._RecordingPreferences__use_gap.data:
  221.             ret |= nautilusburn.RECORDER_WRITE_DISC_AT_ONCE
  222.         
  223.         if self._RecordingPreferences__eject.data:
  224.             ret |= nautilusburn.RECORDER_WRITE_EJECT
  225.         
  226.         if self.debug:
  227.             ret |= nautilusburn.RECORDER_WRITE_DEBUG
  228.         
  229.         if self.overburn:
  230.             ret |= nautilusburn.RECORDER_WRITE_OVERBURN
  231.         
  232.         if self.simulate:
  233.             ret |= nautilusburn.RECORDER_WRITE_DUMMY_WRITE
  234.         
  235.         return ret
  236.  
  237.     writeFlags = property(getWriteFlags)
  238.     
  239.     def getTemporaryDirIsOk(self):
  240.         tmp = self.temporaryDir
  241.         
  242.         try:
  243.             if path.isdir(tmp):
  244.                 pass
  245.             is_ok = os.access(tmp, os.W_OK)
  246.         except OSError:
  247.             err = None
  248.             print err
  249.             is_ok = False
  250.  
  251.         return is_ok
  252.  
  253.     temporaryDirIsOk = property(getTemporaryDirIsOk, doc = 'Tests if temporary directory exists and has write permissions.')
  254.     
  255.     def __on_destroy(self, *args):
  256.         self.dialog.hide()
  257.         return False
  258.  
  259.     
  260.     def savePlaylist(self, source):
  261.         if not path.exists(self.configDir):
  262.             os.makedirs(self.configDir)
  263.         
  264.         p = xspf.Playlist(title = _("Serpentine's playlist"), creator = 'Serpentine ' + self.version)
  265.         source.to_playlist(p)
  266.         doc = p.toxml()
  267.         out = SafeFileWrite(path.join(self.configDir, 'playlist.xml'))
  268.         
  269.         try:
  270.             doc.writexml(out, addindent = '\t', newl = '\n')
  271.             del p
  272.             out.close()
  273.         except:
  274.             out.abort()
  275.             return False
  276.  
  277.         return True
  278.  
  279.     
  280.     def loadPlaylist(self, source):
  281.         if not path.exists(self.configDir):
  282.             os.makedirs(self.configDir)
  283.         
  284.         p = xspf.Playlist(title = _("Serpentine's playlist"), creator = 'Serpentine ' + self.version)
  285.         
  286.         try:
  287.             p.parse(path.join(self.configDir, 'playlist.xml'))
  288.         except IOError:
  289.             return None
  290.  
  291.         source.from_playlist(p)
  292.  
  293.  
  294.