source: src/mlx/gui/prefs.py@ 132:92f78dc5b965

Last change on this file since 132:92f78dc5b965 was 132:92f78dc5b965, checked in by István Váradi <ivaradi@…>, 12 years ago

Added support for enabling/disabling message types
File size: 12.9 KB
Line 
1# Module for the preferences dialog
2
3#------------------------------------------------------------------------------
4
5from common import *
6
7from mlx.i18n import xstr
8import mlx.const as const
9
10import urlparse
11
12#------------------------------------------------------------------------------
13
14class Preferences(gtk.Dialog):
15 """The preferences dialog."""
16 def __init__(self, gui):
17 """Construct the dialog."""
18 super(Preferences, self).__init__(WINDOW_TITLE_BASE + " " +
19 xstr("prefs_title"),
20 gui.mainWindow,
21 DIALOG_MODAL)
22
23 self.add_button(xstr("button_cancel"), RESPONSETYPE_REJECT)
24 self.add_button(xstr("button_ok"), RESPONSETYPE_ACCEPT)
25
26 self._gui = gui
27
28 contentArea = self.get_content_area()
29
30 notebook = gtk.Notebook()
31 contentArea.pack_start(notebook, True, True, 4)
32
33 general = self._buildGeneral()
34 label = gtk.Label(xstr("prefs_tab_general"))
35 label.set_use_underline(True)
36 label.set_tooltip_text(xstr("prefs_tab_general_tooltip"))
37 notebook.append_page(general, label)
38
39 messages = self._buildMessages()
40 label = gtk.Label(xstr("prefs_tab_messages"))
41 label.set_use_underline(True)
42 label.set_tooltip_text(xstr("prefs_tab_message_tooltip"))
43 notebook.append_page(messages, label)
44
45 advanced = self._buildAdvanced()
46 label = gtk.Label(xstr("prefs_tab_advanced"))
47 label.set_use_underline(True)
48 label.set_tooltip_text(xstr("prefs_tab_advanced_tooltip"))
49 notebook.append_page(advanced, label)
50
51 def run(self, config):
52 """Run the preferences dialog.
53
54 The dialog will be set up from data in the given configuration. If the
55 changes are accepted by the user, the configuration is updated and saved."""
56 self._fromConfig(config)
57
58 self.show_all()
59 response = super(Preferences, self).run()
60 self.hide()
61
62 if response==RESPONSETYPE_ACCEPT:
63 self._toConfig(config)
64 config.save()
65
66 def _fromConfig(self, config):
67 """Setup the dialog from the given configuration."""
68 self._setLanguage(config.language)
69 self._flareTimeFromFS.set_active(config.flareTimeFromFS)
70
71 for messageType in const.messageTypes:
72 level = config.getMessageTypeLevel(messageType)
73 button = self._msgFSCheckButtons[messageType]
74 button.set_active(level == const.MESSAGELEVEL_FS or
75 level == const.MESSAGELEVEL_BOTH)
76 button = self._msgSoundCheckButtons[messageType]
77 button.set_active(level == const.MESSAGELEVEL_SOUND or
78 level == const.MESSAGELEVEL_BOTH)
79
80 self._togglingAutoUpdate = True
81 self._autoUpdate.set_active(config.autoUpdate)
82 self._togglingAutoUpdate = False
83 if not config.autoUpdate:
84 self._warnedAutoUpdate = True
85
86 self._updateURL.set_text(config.updateURL)
87
88 def _toConfig(self, config):
89 """Setup the given config from the settings in the dialog."""
90 config.language = self._getLanguage()
91 config.flareTimeFromFS = self._flareTimeFromFS.get_active()
92
93 for messageType in const.messageTypes:
94 fsButtonActive = self._msgFSCheckButtons[messageType].get_active()
95 soundButtonActive = self._msgSoundCheckButtons[messageType].get_active()
96 if fsButtonActive:
97 level = const.MESSAGELEVEL_BOTH if soundButtonActive \
98 else const.MESSAGELEVEL_FS
99 elif soundButtonActive:
100 level = const.MESSAGELEVEL_SOUND
101 else:
102 level = const.MESSAGELEVEL_NONE
103 config.setMessageTypeLevel(messageType, level)
104
105 config.autoUpdate = self._autoUpdate.get_active()
106 config.updateURL = self._updateURL.get_text()
107
108 def _buildGeneral(self):
109 """Build the page for the general settings."""
110 mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
111 xscale = 0.0, yscale = 0.0)
112 mainAlignment.set_padding(padding_top = 16, padding_bottom = 32,
113 padding_left = 4, padding_right = 48)
114 mainBox = gtk.VBox()
115 mainAlignment.add(mainBox)
116
117 languageBox = gtk.HBox()
118 mainBox.pack_start(languageBox, False, False, 4)
119
120 label = gtk.Label(xstr("prefs_language"))
121 label.set_use_underline(True)
122
123 languageBox.pack_start(label, False, False, 4)
124
125 self._languageList = gtk.ListStore(str, str)
126 for language in const.languages:
127 self._languageList.append([xstr("prefs_lang_" + language),
128 language])
129
130 self._languageComboBox = languageComboBox = \
131 gtk.ComboBox(model = self._languageList)
132 cell = gtk.CellRendererText()
133 languageComboBox.pack_start(cell, True)
134 languageComboBox.add_attribute(cell, 'text', 0)
135 languageComboBox.set_tooltip_text(xstr("prefs_language_tooltip"))
136 languageComboBox.connect("changed", self._languageChanged)
137 languageBox.pack_start(languageComboBox, False, False, 4)
138
139 label.set_mnemonic_widget(languageComboBox)
140
141 self._changingLanguage = False
142 self._warnedRestartNeeded = False
143
144 self._flareTimeFromFS = gtk.CheckButton(xstr("prefs_flaretimeFromFS"))
145 self._flareTimeFromFS.set_use_underline(True)
146 self._flareTimeFromFS.set_tooltip_text(xstr("prefs_flaretimeFromFS_tooltip"))
147
148 mainBox.pack_start(self._flareTimeFromFS, False, False, 4)
149
150 return mainAlignment
151
152 def _setLanguage(self, language):
153 """Set the language to the given one."""
154 iter = self._languageList.get_iter_first()
155 while iter is not None:
156 (lang,) = self._languageList.get(iter, 1)
157 if (not language and lang=="$system") or \
158 lang==language:
159 self._changingLanguage = True
160 self._languageComboBox.set_active_iter(iter)
161 self._changingLanguage = False
162 break
163 else:
164 iter = self._languageList.iter_next(iter)
165
166 def _getLanguage(self):
167 """Get the language selected by the user."""
168 iter = self._languageComboBox.get_active_iter()
169 (lang,) = self._languageList.get(iter, 1)
170 return "" if lang=="$system" else lang
171
172 def _languageChanged(self, comboBox):
173 """Called when the language has changed."""
174 if not self._changingLanguage and not self._warnedRestartNeeded:
175 dialog = gtk.MessageDialog(parent = self,
176 type = MESSAGETYPE_INFO,
177 message_format = xstr("prefs_restart"))
178 dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
179 dialog.set_title(self.get_title())
180 dialog.format_secondary_markup(xstr("prefs_language_restart_sec"))
181 dialog.run()
182 dialog.hide()
183 self._warnedRestartNeeded = True
184
185 def _buildMessages(self):
186 """Build the page for the message settings."""
187
188 mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
189 xscale = 0.0, yscale = 0.0)
190 mainAlignment.set_padding(padding_top = 16, padding_bottom = 8,
191 padding_left = 4, padding_right = 4)
192 mainBox = gtk.VBox()
193 mainAlignment.add(mainBox)
194
195 table = gtk.Table(len(const.messageTypes) + 1, 3)
196 table.set_row_spacings(8)
197 table.set_col_spacings(32)
198 table.set_homogeneous(False)
199 mainBox.pack_start(table, False, False, 4)
200
201 label = gtk.Label(xstr("prefs_msgs_fs"))
202 label.set_justify(JUSTIFY_CENTER)
203 label.set_alignment(0.5, 1.0)
204 table.attach(label, 1, 2, 0, 1)
205
206 label = gtk.Label(xstr("prefs_msgs_sound"))
207 label.set_justify(JUSTIFY_CENTER)
208 label.set_alignment(0.5, 1.0)
209 table.attach(label, 2, 3, 0, 1)
210
211 self._msgFSCheckButtons = {}
212 self._msgSoundCheckButtons = {}
213 row = 1
214 for messageType in const.messageTypes:
215 messageTypeStr = const.messageType2string(messageType)
216 label = gtk.Label(xstr("prefs_msgs_type_" + messageTypeStr))
217 label.set_justify(JUSTIFY_CENTER)
218 label.set_use_underline(True)
219 label.set_alignment(0.5, 0.5)
220 table.attach(label, 0, 1, row, row+1)
221
222 fsCheckButton = gtk.CheckButton()
223 alignment = gtk.Alignment(xscale = 0.0, yscale = 0.0,
224 xalign = 0.5, yalign = 0.5)
225 alignment.add(fsCheckButton)
226 table.attach(alignment, 1, 2, row, row+1)
227 self._msgFSCheckButtons[messageType] = fsCheckButton
228
229 soundCheckButton = gtk.CheckButton()
230 alignment = gtk.Alignment(xscale = 0.0, yscale = 0.0,
231 xalign = 0.5, yalign = 0.5)
232 alignment.add(soundCheckButton)
233 table.attach(alignment, 2, 3, row, row+1)
234 self._msgSoundCheckButtons[messageType] = soundCheckButton
235
236 mnemonicWidget = gtk.Label("")
237 table.attach(mnemonicWidget, 3, 4, row, row+1)
238 label.set_mnemonic_widget(mnemonicWidget)
239 mnemonicWidget.connect("mnemonic-activate",
240 self._msgLabelActivated,
241 messageType)
242
243 row += 1
244
245 return mainAlignment
246
247 def _msgLabelActivated(self, button, cycle_group, messageType):
248 """Called when the mnemonic of a label is activated.
249
250 It cycles the corresponding options."""
251 fsCheckButton = self._msgFSCheckButtons[messageType]
252 soundCheckButton = self._msgSoundCheckButtons[messageType]
253
254 num = 1 if fsCheckButton.get_active() else 0
255 num += 2 if soundCheckButton.get_active() else 0
256 num += 1
257
258 fsCheckButton.set_active((num&0x01)==0x01)
259 soundCheckButton.set_active((num&0x02)==0x02)
260
261 return True
262
263 def _buildAdvanced(self):
264 """Build the page for the advanced settings."""
265
266 mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
267 xscale = 0.0, yscale = 0.0)
268 mainAlignment.set_padding(padding_top = 16, padding_bottom = 32,
269 padding_left = 4, padding_right = 48)
270 mainBox = gtk.VBox()
271 mainAlignment.add(mainBox)
272
273 self._autoUpdate = gtk.CheckButton(xstr("prefs_update_auto"))
274 mainBox.pack_start(self._autoUpdate, False, False, 4)
275
276 self._autoUpdate.set_use_underline(True)
277 self._autoUpdate.connect("toggled", self._autoUpdateToggled)
278 self._autoUpdate.set_tooltip_text(xstr("prefs_update_auto_tooltip"))
279 self._warnedAutoUpdate = False
280 self._togglingAutoUpdate = False
281
282 updateURLBox = gtk.HBox()
283 mainBox.pack_start(updateURLBox, False, False, 4)
284 label = gtk.Label(xstr("prefs_update_url"))
285 label.set_use_underline(True)
286 updateURLBox.pack_start(label, False, False, 4)
287
288 self._updateURL = gtk.Entry()
289 label.set_mnemonic_widget(self._updateURL)
290 self._updateURL.set_width_chars(40)
291 self._updateURL.set_tooltip_text(xstr("prefs_update_url_tooltip"))
292 self._updateURL.connect("changed", self._updateURLChanged)
293 updateURLBox.pack_start(self._updateURL, False, False, 4)
294
295 return mainAlignment
296
297 def _setOKButtonSensitivity(self):
298 """Set the sensitive state of the OK button."""
299 sensitive = False
300 try:
301 result = urlparse.urlparse(self._updateURL.get_text())
302 sensitive = result.scheme!="" and (result.netloc + result.path)!=""
303 except:
304 pass
305
306 okButton = self.get_widget_for_response(RESPONSETYPE_ACCEPT)
307 okButton.set_sensitive(sensitive)
308
309 def _autoUpdateToggled(self, button):
310 """Called when the auto update check button is toggled."""
311 if not self._togglingAutoUpdate and not self._warnedAutoUpdate and \
312 not self._autoUpdate.get_active():
313 dialog = gtk.MessageDialog(parent = self,
314 type = MESSAGETYPE_INFO,
315 message_format = xstr("prefs_update_auto_warning"))
316 dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
317 dialog.set_title(self.get_title())
318 dialog.run()
319 dialog.hide()
320 self._warnedAutoUpdate = True
321
322 def _updateURLChanged(self, entry):
323 """Called when the update URL is changed."""
324 self._setOKButtonSensitivity()
325
326
Note: See TracBrowser for help on using the repository browser.