← Back to branch summary

~ubuntu-branches/debian/sid/jokosher/sid

« back to all changes in this revision

Viewing changes to Jokosher/PreferencesDialog.py

  • Committer: Bazaar Package Importer
  • Author(s): Luca Falavigna, Luca Falavigna, Piotr Ożarowski
  • Date: 2009-05-12 00:37:15 UTC
  • mfrom: (1.3.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20090512003715-3hp2ycoqjlzwfnlv
Tags: 0.11.2-1
http://bugs.debian.org/517234
http://bugs.debian.org/443788
http://bugs.debian.org/523167
http://bugs.debian.org/468728
[ Luca Falavigna ]
* New upstream release (Closes: #517234).
  - Jokosher now appears under Sound & Video (Closes: #443788).
* New Maintainer (Closes: #523167).
* Add Python Applications Packaging Team to Uploaders.
* Add Vcs-* fields in source stanza.
* Adjust copyright informations:
  - Refresh upstream authors and copyright holders.
  - Link to /usr/share/common-licenses/GPL-2.
  - Adjust copyright holders for Debian packaging.
  - Replace (c) with ©.
* Apply changes from Ubuntu by Daniel Holbach (thanks!):
  - Drop scrollkeeper from Build-Depends.
  - Drop useless dependencies: python-alsaaudio, gstreamer0.10-gnomevfs,
    librsvg2-common, python-gnome2.
  - Bump gstreamer0.10-plugins-good requirement to >= 0.10.9.
  - Drop debian/jokosher.sh, useless.
  - Provide debian/watch file.
* Switch to debhelper 7.
* Install Jokosher module in private directory.
* Unpack egg files to let python-support handle them.
* Drop python-dev from Build-Depends, use python (>= 2.4) instead.
* Depend on python-gobject.
* Switch dependency from python-setuptools to python-pkg-resources
  because of package rename (Closes: #468728).
* debian/patches/10_update_mime_database.dpatch:
  - Refresh for new upstream release.
* debian/patches/20_LevelList_IOError.dpatch:
  - Fix IOError exception trying to add an audio file to a project.
* debian/patches/30_desktop_file.dpatch:
  - Adhere to Freedesktop.org standards by removing deprecated entries.
* debian/patches/50_CreateNewProject_return.dpatch:
  - Return class while creating a new project.
* Provide a simple man page for jokosher.
* Bump Standards-Version to 3.8.1:
  - Provide Homepage field in source stanza.
  - Provide debian/README.source to document dpatch usage.

[ Piotr Ożarowski ]
* Add 40_load_extensions_from_unpacked_eggs patch so that extensions in
  unzipped Eggs are recognized as well

Show diffs side-by-side

added added

removed removed

Lines of Context:
Jokosher/PreferencesDialog.py
10
10
 
11
11
import gtk.glade
12
12
import Globals
13
 
import AlsaDevices
 
13
import AudioBackend
14
14
import pygst
15
15
pygst.require("0.10")
16
16
import gst
47
47
                self.signals = {
48
48
                        "on_Setting_changed" : self.OnSettingChanged,
49
49
                        "on_playbackSink_changed" : self.OnPlaybackSinkChanged,
 
50
                        "on_recordingSoundSystem_changed" : self.OnRecordingSystemChanged,
50
51
                        "on_Close_clicked" : self.OnClose,
51
52
                }
52
53
 
54
55
                self.dlg = self.res.get_widget("PreferencesDialog")
55
56
                self.dlg.set_icon(icon)
56
57
                self.recordingFileFormat = self.res.get_widget("recordingFileFormat")
 
58
                self.recordingCustomPipeline = self.res.get_widget("recordingCustomPipeline")
 
59
                self.recordingSoundSystem = self.res.get_widget("recordingSoundSystem")
57
60
                self.samplingRate = self.res.get_widget("samplingRate")
58
61
                self.playbackDevice = self.res.get_widget("playbackDevice")
59
62
                self.playbackSink = self.res.get_widget("playbackSink")
65
68
                #Load settings - set to True to make sure data isn't saved to file until everything is loaded
66
69
                self.loadingSettings = True
67
70
                
 
71
                ## Load recording sound system
 
72
                audioSrcSetting = Globals.settings.recording["audiosrc"]
 
73
                self.recordingCustomPipeline.set_text(audioSrcSetting)
 
74
                
 
75
                self.recordingSoundSystem.append_text(_("Custom"))
 
76
                self.recordingSoundSystem.set_active(0)
 
77
                
 
78
                for name, element in Globals.CAPTURE_BACKENDS:
 
79
                        self.recordingSoundSystem.append_text(name)
 
80
                        if audioSrcSetting == element:
 
81
                                index = len(self.recordingSoundSystem.get_model()) - 1
 
82
                                self.recordingSoundSystem.set_active(index)
 
83
                                
 
84
                if self.recordingSoundSystem.get_active() == 0:
 
85
                        self.recordingCustomPipeline.set_sensitive(True)
 
86
                else:
 
87
                        self.recordingCustomPipeline.set_sensitive(False)
 
88
                
 
89
                ## Load playback sound system
68
90
                audioSinkSetting = Globals.settings.playback["audiosink"]
69
 
                if audioSinkSetting == "autoaudiosink":
70
 
                        self.playbackSink.set_active(0)
71
 
                        self.customSink.set_sensitive(False)
72
 
                        self.playbackDevice.set_sensitive(False)
73
 
                elif audioSinkSetting == "alsasink":
74
 
                        self.playbackSink.set_active(1)
75
 
                        self.customSink.set_sensitive(False)
76
 
                        self.playbackDevice.set_sensitive(True)
 
91
                self.customSink.set_text(audioSinkSetting)
 
92
                
 
93
                self.playbackSink.append_text(_("Custom"))
 
94
                self.playbackSink.set_active(0)
 
95
                
 
96
                for name, element in Globals.PLAYBACK_BACKENDS:
 
97
                        self.playbackSink.append_text(name)
 
98
                        if audioSinkSetting == element:
 
99
                                index = len(self.playbackSink.get_model()) - 1
 
100
                                self.playbackSink.set_active(index)
 
101
                                
 
102
                if self.playbackSink.get_active() == 0:
 
103
                        self.customSink.set_sensitive(True)
77
104
                else:
78
 
                        self.playbackSink.set_active(2)
79
 
                        self.customSink.set_sensitive(True)
80
 
                        self.customSink.set_text(audioSinkSetting)
81
 
                        self.playbackDevice.set_sensitive(False)
 
105
                        self.customSink.set_sensitive(False)
82
106
                
83
 
                #Find all ALSA devices
84
 
                self.playbacks = [] #Map combobox entries to ALSA devices
85
 
                for device, playback in AlsaDevices.GetAlsaList("playback").items():
86
 
                        self.playbacks.append(device)
87
 
                        self.playbackDevice.append_text(playback)
88
 
                self.LoadSetting(self.playbackDevice, Globals.settings.playback, "device")
 
107
                self.ProbeBackendDevices()
89
108
                        
90
109
                #Get available sample rates from ALSA
91
 
                sample_values = AlsaDevices.GetRecordingSampleRate()
92
 
                sampleRateSetting = Globals.settings.recording["samplerate"]
93
 
                sampleRateSettingIndex = 0
 
110
                sample_values = AudioBackend.GetRecordingSampleRate()
 
111
                i18nText = "%(sample rate)d Hz"
 
112
                #add tuple of (display string, rate value)
 
113
                self.sampleRateList = [( _("Autodetect"), 0)]
94
114
                if type(sample_values) == int:
95
 
                        self.samplingRate.append_text("%d %s" % (sample_values, _("Hz")))
 
115
                        text = i18nText % {"sample rate" : sample_values}
 
116
                        self.sampleRateList.append( (text, sample_values) )
96
117
                elif type(sample_values) == list:
97
118
                        for i, rate in enumerate (sample_values):
98
 
                                self.samplingRate.append_text("%d %s" % (rate, _("Hz")))
99
 
                                if str(rate) == sampleRateSetting:
100
 
                                        sampleRateSettingIndex = i
101
 
                                
 
119
                                text = i18nText % {"sample rate" : rate}
 
120
                                self.sampleRateList.append( (text, rate) )
 
121
                #check if it is an IntRange
102
122
                elif hasattr(sample_values, "low") and hasattr(sample_values, "high"):
103
 
                        try:
104
 
                                #try to convert the setting string to an int
105
 
                                rate = int(sampleRateSetting)
106
 
                        except ValueError:
107
 
                                pass
108
 
                        else:
109
 
                                #since the card supports a range of samples rates, the saved preference
110
 
                                #might not be in Globals.SAMPLE_RATES
111
 
                                if rate not in Globals.SAMPLE_RATES:
112
 
                                        if sample_values.low <= rate <= sample_values.high:
113
 
                                                self.samplingRate.append_text("%d %s" % (rate, _("Hz")))
114
 
 
115
 
                        #add the rest of the default sample rates if they are within the supported range
116
 
                        index = 0
 
123
                        #add the default sample rates if they are within the supported range
117
124
                        for rate in Globals.SAMPLE_RATES:
118
125
                                if sample_values.low <= rate <= sample_values.high:
119
 
                                        self.samplingRate.append_text("%d %s" % (rate, _("Hz")))
120
 
                                        if str(rate) == sampleRateSetting:
121
 
                                                sampleRateSettingIndex = index
122
 
                                        index += 1
 
126
                                        text = i18nText % {"sample rate" : rate}
 
127
                                        self.sampleRateList.append( (text, rate) )
123
128
                                        
 
129
                sampleRateSetting = 0
 
130
                sampleRateSettingIndex = 0
 
131
                try:
 
132
                        #try to convert the setting string to an int
 
133
                        sampleRateSetting = int( Globals.settings.recording["samplerate"] )
 
134
                except ValueError:
 
135
                        pass
 
136
                else:
 
137
                        #if they have put in a custom preference which is not ordinarily detected, add it to the list
 
138
                        if sampleRateSetting not in [y for x,y in self.sampleRateList]:
 
139
                                text = i18nText % {"sample rate" : sampleRateSetting}
 
140
                                self.sampleRateList.append( (text, sampleRateSetting) )
 
141
                
 
142
                for text, value in self.sampleRateList:
 
143
                        self.samplingRate.append_text(text)
 
144
                        if value == sampleRateSetting:
 
145
                                sampleRateSettingIndex = self.sampleRateList.index( (text, value) )
124
146
                self.samplingRate.set_active(sampleRateSettingIndex)
125
 
 
 
147
                
 
148
                
126
149
                fileFormatSetting = Globals.settings.recording["fileformat"]
127
150
                fileFormatSettingIndex = 0
128
151
                #get all the encoders from Globals
143
166
                        self.radioWelcome.set_active(True)
144
167
                        
145
168
                self.loadingSettings = False
 
169
 
 
170
                self.dlg.show_all()
146
171
                
147
172
        #_____________________________________________________________________
148
173
                
198
223
                
199
224
                exportDict = Globals.EXPORT_FORMATS[self.recordingFileFormat.get_active()]
200
225
                Globals.settings.recording["fileformat"] = exportDict["pipeline"]
 
226
                Globals.settings.recording["file_extension"] = exportDict["extension"]
201
227
                #only get the number from "44100 Hz", not the whole string
202
 
                Globals.settings.recording["samplerate"] = self.samplingRate.get_active_text().split(" ")[0]
203
 
                Globals.settings.playback["device"] = self.playbackDevice.get_active_text()
204
 
                Globals.settings.playback["devicecardnum"] = self.playbacks[self.playbackDevice.get_active()]
 
228
                sampleRateIndex = self.samplingRate.get_active()
 
229
                Globals.settings.recording["samplerate"] = self.sampleRateList[sampleRateIndex][1]
 
230
                if self.playbackDevice.get_active() >= 0:
 
231
                        Globals.settings.playback["devicename"] = self.playbackDevice.get_active_text()
 
232
                        Globals.settings.playback["device"] = self.playbacks[self.playbackDevice.get_active()]
 
233
                else:
 
234
                        Globals.settings.playback["devicename"] = ""
 
235
                        Globals.settings.playback["device"] = ""
205
236
                
206
237
                if self.radioWelcome.get_active():
207
238
                        Globals.settings.general["startupaction"] = STARTUP_WELCOME_DIALOG
211
242
                        Globals.settings.general["startupaction"] = STARTUP_NOTHING
212
243
                        
213
244
                Globals.settings.write()
214
 
                
215
 
                self.mainwindow.UpdateDisplay()
216
245
 
217
246
        #_____________________________________________________________________
218
247
 
227
256
                if self.loadingSettings:
228
257
                        return
229
258
        
230
 
                # First in the list is Autodetect
231
259
                if self.playbackSink.get_active() == 0:
232
 
                        self.customSink.set_sensitive(False)
233
 
                        self.playbackDevice.set_sensitive(False)
234
 
                        Globals.settings.playback["audiosink"] = "autoaudiosink"
235
 
                # Second is ALSA
236
 
                elif self.playbackSink.get_active() == 1:
237
 
                        self.customSink.set_sensitive(False)
238
 
                        self.playbackDevice.set_sensitive(True)
239
 
                        Globals.settings.playback["audiosink"] = "alsasink"
240
 
                # Third is Custom
241
 
                elif self.playbackSink.get_active() == 2:
242
260
                        self.customSink.set_sensitive(True)
243
 
                        self.playbackDevice.set_sensitive(False)
244
261
                        Globals.settings.playback["audiosink"] = self.customSink.get_text()
245
 
                        
246
 
                Globals.settings.write()
247
 
                self.project.SetProjectSink()
 
262
                else:
 
263
                        self.customSink.set_sensitive(False)
 
264
                        index = self.playbackSink.get_active() - 1
 
265
                        name, element = Globals.PLAYBACK_BACKENDS[index]
 
266
                        Globals.settings.playback["audiosink"] = element
 
267
                        self.customSink.set_text(element)
 
268
                        
 
269
                self.ProbeBackendDevices()
 
270
                        
 
271
                Globals.settings.write()
 
272
                if self.project:
 
273
                        self.project.SetProjectSink()
 
274
        
 
275
        #_____________________________________________________________________
 
276
        
 
277
        def OnRecordingSystemChanged(self, widget=None, event=None):
 
278
                """
 
279
                Updates the selected playback audio device from the comboBox selection.
 
280
                It then writes an updated settings file.
 
281
                
 
282
                Parameters:
 
283
                        comboBox -- reserved for GTK callbacks, don't use it explicitly.
 
284
                """
 
285
                if self.loadingSettings:
 
286
                        return
 
287
        
 
288
                if self.recordingSoundSystem.get_active() == 0:
 
289
                        self.recordingCustomPipeline.set_sensitive(True)
 
290
                        Globals.settings.recording["audiosrc"] = self.recordingCustomPipeline.get_text()
 
291
                else:
 
292
                        self.recordingCustomPipeline.set_sensitive(False)
 
293
                        index = self.recordingSoundSystem.get_active() - 1
 
294
                        name, element = Globals.CAPTURE_BACKENDS[index]
 
295
                        Globals.settings.recording["audiosrc"] = element
 
296
                        self.recordingCustomPipeline.set_text(element)
 
297
                        
 
298
                Globals.settings.write()
 
299
                if self.project:
 
300
                        self.project.OnCaptureBackendChange()
248
301
        
249
302
        #_____________________________________________________________________
250
303
        
270
323
                        self.mixdownFormat.append_text(enc.get_longname())
271
324
        
272
325
        #_____________________________________________________________________
 
326
 
 
327
        def ProbeBackendDevices(self):
 
328
                #Find all playback devices
 
329
                self.playbacks = [] # Map combobox entries to property names instead of human readable names).
 
330
                self.playbackDevice.get_model().clear() # clear combo box
 
331
                for index, (device, deviceName) in enumerate(AudioBackend.ListPlaybackDevices()):
 
332
                        if len(self.playbacks) == 0 and not deviceName:
 
333
                                deviceName = _("Default")
 
334
                        self.playbacks.append(device)
 
335
                        if deviceName:
 
336
                                self.playbackDevice.append_text(deviceName)
 
337
                        elif device:
 
338
                                self.playbackDevice.append_text(device)
 
339
                        else:
 
340
                                self.playbackDevice.append_text(_("Device %d") % index)
 
341
                        
 
342
                if not self.playbacks:
 
343
                        self.playbackDevice.set_sensitive(False)
 
344
                else:
 
345
                        self.playbackDevice.set_sensitive(True)
 
346
                        self.LoadSetting(self.playbackDevice, Globals.settings.playback, "devicename")
 
347
        
 
348
        #_____________________________________________________________________