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