Context Navigation

source: src/mlx/gui/prefs.py@ 392:ddb312cb8a3d

Visit:

Last change on this file since 392:ddb312cb8a3d was 392:ddb312cb8a3d, checked in by István Váradi <ivaradi@…>, 11 years ago
Implemented the configuration of automatic PIREP saving (re #163)
File size: 35.0 KB

Rev	Line
[123]	1
	2	from common import *
	3
	4	from mlx.i18n import xstr
	5	import mlx.const as const
[166]	6	import mlx.config as config
[123]	7
	8	import urlparse
	9
	10	#------------------------------------------------------------------------------
	11
[300]	12	## @package mlx.gui.prefs
	13	#
	14	# The preferences dialog.
	15	#
	16	# This module implements the preferences dialog, allowing the editing of the
	17	# configuration of the program. The preferences are grouped into tabs, each
	18	# containing the necessary controls to set the various options.
	19
	20	#------------------------------------------------------------------------------
	21
[166]	22	class Hotkey(gtk.HBox):
	23	"""A widget to handle a hotkey."""
[167]	24
	25	# Constant to denote that the status of the Ctrl modifier is changed
	26	CHANGED_CTRL = 1
[392]	27
[167]	28	# Constant to denote that the status of the Shift modifier is changed
	29	CHANGED_SHIFT = 2
[392]	30
[167]	31	# Constant to denote that the value of the key is changed
	32	CHANGED_KEY = 3
[392]	33
[166]	34	def __init__(self, labelText, tooltips):
	35	"""Construct the hotkey widget.
	36
	37	labelText is the text for the label before the hotkey.
	38
	39	The tooltips parameter is an array of the tooltips for:
	40	- the hotkey combo box,
	41	- the control check box, and
	42	- the shift check box."""
	43	super(Hotkey, self).__init__()
[392]	44
[166]	45	label = gtk.Label(labelText)
	46	label.set_use_underline(True)
	47	labelAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
	48	xscale = 0.0, yscale = 0.0)
[168]	49	labelAlignment.set_padding(padding_top = 0, padding_bottom = 0,
	50	padding_left = 0, padding_right = 4)
[166]	51	labelAlignment.add(label)
[168]	52	self.pack_start(labelAlignment, False, False, 0)
[166]	53
	54	self._ctrl = gtk.CheckButton("Ctrl")
	55	self._ctrl.set_tooltip_text(tooltips[1])
[167]	56	self._ctrl.connect("toggled", self._ctrlToggled)
[166]	57	self.pack_start(self._ctrl, False, False, 4)
[392]	58
[166]	59	self._shift = gtk.CheckButton("Shift")
	60	self._shift.set_tooltip_text(tooltips[2])
[167]	61	self._shift.connect("toggled", self._shiftToggled)
[166]	62	self.pack_start(self._shift, False, False, 4)
	63
	64	self._hotkeyModel = gtk.ListStore(str)
[168]	65	for keyCode in range(ord("0"), ord("9")+1) + range(ord("A"), ord("Z")+1):
[166]	66	self._hotkeyModel.append([chr(keyCode)])
	67
	68	self._hotkey = gtk.ComboBox(model = self._hotkeyModel)
	69	cell = gtk.CellRendererText()
	70	self._hotkey.pack_start(cell, True)
	71	self._hotkey.add_attribute(cell, 'text', 0)
	72	self._hotkey.set_tooltip_text(tooltips[0])
[167]	73	self._hotkey.connect("changed", self._keyChanged)
[166]	74	self.pack_start(self._hotkey, False, False, 4)
	75
[174]	76	label.set_mnemonic_widget(self._hotkey)
	77
[166]	78	self._setting = False
	79
[167]	80	@property
	81	def ctrl(self):
	82	"""Get whether the Ctrl modifier is selected."""
	83	return self._ctrl.get_active()
	84
	85	@ctrl.setter
	86	def ctrl(self, ctrl):
	87	"""Get whether the Ctrl modifier is selected."""
[166]	88	self._setting = True
[167]	89	self._ctrl.set_active(ctrl)
	90	self._setting = False
[166]	91
[167]	92	@property
	93	def shift(self):
	94	"""Get whether the Shift modifier is selected."""
	95	return self._shift.get_active()
	96
	97	@shift.setter
	98	def shift(self, shift):
	99	"""Get whether the Shift modifier is selected."""
	100	self._setting = True
	101	self._shift.set_active(shift)
	102	self._setting = False
	103
	104	@property
	105	def key(self):
	106	"""Get the value of the key."""
	107	return self._hotkeyModel.get_value(self._hotkey.get_active_iter(), 0)
	108
	109	@key.setter
	110	def key(self, key):
	111	"""Set the value of the key."""
	112	self._setting = True
[166]	113
	114	hotkeyModel = self._hotkeyModel
	115	iter = hotkeyModel.get_iter_first()
	116	while iter is not None and \
[167]	117	hotkeyModel.get_value(iter, 0)!=key:
[166]	118	iter = hotkeyModel.iter_next(iter)
	119
	120	if iter is None:
	121	iter = hotkeyModel.get_iter_first()
	122
[392]	123	self._hotkey.set_active_iter(iter)
[167]	124
[166]	125	self._setting = False
	126
[167]	127	def set(self, hotkey):
	128	"""Set the hotkey widget from the given hotkey."""
	129	self.ctrl = hotkey.ctrl
	130	self.shift = hotkey.shift
	131	self.key = hotkey.key
	132
[166]	133	def get(self):
	134	"""Get a hotkey corresponding to the settings in the widghet."""
	135
	136	key = self._hotkeyModel.get_value(self._hotkey.get_active_iter(), 0)
	137
[167]	138	return config.Hotkey(ctrl = self.ctrl, shift = self.shift,
	139	key = self.key)
	140
	141	def _ctrlToggled(self, checkButton):
	142	"""Called when the status of the Ctrl modifier has changed."""
	143	if not self._setting:
	144	self.emit("hotkey-changed", Hotkey.CHANGED_CTRL)
	145
	146	def _shiftToggled(self, checkButton):
	147	"""Called when the status of the Shift modifier has changed."""
	148	if not self._setting:
	149	self.emit("hotkey-changed", Hotkey.CHANGED_SHIFT)
	150
	151	def _keyChanged(self, comboBox):
	152	"""Called when the value of the key has changed."""
	153	if not self._setting:
	154	self.emit("hotkey-changed", Hotkey.CHANGED_KEY)
	155
	156	def __eq__(self, other):
	157	"""Determine if the two hotkeys are equal."""
	158	return self.ctrl==other.ctrl and self.shift==other.shift and \
	159	self.key==other.key
	160
	161	#------------------------------------------------------------------------------
	162
	163	gobject.signal_new("hotkey-changed", Hotkey, gobject.SIGNAL_RUN_FIRST,
	164	None, (int,))
[166]	165
	166	#------------------------------------------------------------------------------
	167
[123]	168	class Preferences(gtk.Dialog):
	169	"""The preferences dialog."""
	170	def __init__(self, gui):
	171	"""Construct the dialog."""
	172	super(Preferences, self).__init__(WINDOW_TITLE_BASE + " " +
	173	xstr("prefs_title"),
	174	gui.mainWindow,
[124]	175	DIALOG_MODAL)
	176
	177	self.add_button(xstr("button_cancel"), RESPONSETYPE_REJECT)
	178	self.add_button(xstr("button_ok"), RESPONSETYPE_ACCEPT)
[202]	179	self.set_resizable(False)
[392]	180
[123]	181	self._gui = gui
[166]	182	self._settingFromConfig = False
[123]	183
	184	contentArea = self.get_content_area()
	185
	186	notebook = gtk.Notebook()
	187	contentArea.pack_start(notebook, True, True, 4)
	188
	189	general = self._buildGeneral()
	190	label = gtk.Label(xstr("prefs_tab_general"))
	191	label.set_use_underline(True)
	192	label.set_tooltip_text(xstr("prefs_tab_general_tooltip"))
	193	notebook.append_page(general, label)
	194
[132]	195	messages = self._buildMessages()
	196	label = gtk.Label(xstr("prefs_tab_messages"))
	197	label.set_use_underline(True)
	198	label.set_tooltip_text(xstr("prefs_tab_message_tooltip"))
	199	notebook.append_page(messages, label)
	200
[166]	201	sounds = self._buildSounds()
	202	label = gtk.Label(xstr("prefs_tab_sounds"))
	203	label.set_use_underline(True)
	204	label.set_tooltip_text(xstr("prefs_tab_sounds_tooltip"))
	205	notebook.append_page(sounds, label)
	206
[123]	207	advanced = self._buildAdvanced()
	208	label = gtk.Label(xstr("prefs_tab_advanced"))
	209	label.set_use_underline(True)
	210	label.set_tooltip_text(xstr("prefs_tab_advanced_tooltip"))
	211	notebook.append_page(advanced, label)
	212
	213	def run(self, config):
	214	"""Run the preferences dialog.
	215
	216	The dialog will be set up from data in the given configuration. If the
	217	changes are accepted by the user, the configuration is updated and saved."""
	218	self._fromConfig(config)
	219
	220	self.show_all()
	221	response = super(Preferences, self).run()
	222	self.hide()
	223
	224	if response==RESPONSETYPE_ACCEPT:
	225	self._toConfig(config)
	226	config.save()
	227
	228	def _fromConfig(self, config):
	229	"""Setup the dialog from the given configuration."""
[166]	230	self._settingFromConfig = True
	231
[123]	232	self._setLanguage(config.language)
[147]	233	self._hideMinimizedWindow.set_active(config.hideMinimizedWindow)
[249]	234	self._quitOnClose.set_active(config.quitOnClose)
[136]	235	self._onlineGateSystem.set_active(config.onlineGateSystem)
[139]	236	self._onlineACARS.set_active(config.onlineACARS)
[131]	237	self._flareTimeFromFS.set_active(config.flareTimeFromFS)
[148]	238	self._syncFSTime.set_active(config.syncFSTime)
[183]	239	self._usingFS2Crew.set_active(config.usingFS2Crew)
[392]	240
[197]	241	self._setSmoothing(self._iasSmoothingEnabled, self._iasSmoothingLength,
	242	config.iasSmoothingLength)
	243	self._setSmoothing(self._vsSmoothingEnabled, self._vsSmoothingLength,
	244	config.vsSmoothingLength)
[123]	245
[149]	246	pirepDirectory = config.pirepDirectory
	247	self._pirepDirectory.set_text("" if pirepDirectory is None
	248	else pirepDirectory)
[392]	249	self._pirepAutoSave.set_active(config.pirepAutoSave)
	250	if not pirepDirectory:
	251	self._pirepAutoSave.set_sensitive(False)
[149]	252
[132]	253	for messageType in const.messageTypes:
	254	level = config.getMessageTypeLevel(messageType)
	255	button = self._msgFSCheckButtons[messageType]
	256	button.set_active(level == const.MESSAGELEVEL_FS or
	257	level == const.MESSAGELEVEL_BOTH)
	258	button = self._msgSoundCheckButtons[messageType]
	259	button.set_active(level == const.MESSAGELEVEL_SOUND or
	260	level == const.MESSAGELEVEL_BOTH)
	261
[166]	262	self._enableSounds.set_active(config.enableSounds)
	263	self._pilotControlsSounds.set_active(config.pilotControlsSounds)
	264	self._pilotHotkey.set(config.pilotHotkey)
[270]	265	self._enableApproachCallouts.set_active(config.enableApproachCallouts)
[166]	266	self._speedbrakeAtTD.set_active(config.speedbrakeAtTD)
	267
[392]	268	self._enableChecklists.set_active(config.enableChecklists)
[166]	269	self._checklistHotkey.set(config.checklistHotkey)
	270
[123]	271	self._autoUpdate.set_active(config.autoUpdate)
	272	if not config.autoUpdate:
	273	self._warnedAutoUpdate = True
	274
	275	self._updateURL.set_text(config.updateURL)
	276
[166]	277	self._settingFromConfig = False
	278
[123]	279	def _toConfig(self, config):
	280	"""Setup the given config from the settings in the dialog."""
	281	config.language = self._getLanguage()
[147]	282	config.hideMinimizedWindow = self._hideMinimizedWindow.get_active()
[249]	283	config.quitOnClose = self._quitOnClose.get_active()
[136]	284	config.onlineGateSystem = self._onlineGateSystem.get_active()
[139]	285	config.onlineACARS = self._onlineACARS.get_active()
[131]	286	config.flareTimeFromFS = self._flareTimeFromFS.get_active()
[148]	287	config.syncFSTime = self._syncFSTime.get_active()
[183]	288	config.usingFS2Crew = self._usingFS2Crew.get_active()
[197]	289	config.iasSmoothingLength = self._getSmoothing(self._iasSmoothingEnabled,
	290	self._iasSmoothingLength)
	291	config.vsSmoothingLength = self._getSmoothing(self._vsSmoothingEnabled,
	292	self._vsSmoothingLength)
[164]	293	config.pirepDirectory = text2unicode(self._pirepDirectory.get_text())
[392]	294	config.pirepAutoSave = self._pirepAutoSave.get_active()
[132]	295
	296	for messageType in const.messageTypes:
	297	fsButtonActive = self._msgFSCheckButtons[messageType].get_active()
	298	soundButtonActive = self._msgSoundCheckButtons[messageType].get_active()
	299	if fsButtonActive:
	300	level = const.MESSAGELEVEL_BOTH if soundButtonActive \
	301	else const.MESSAGELEVEL_FS
	302	elif soundButtonActive:
	303	level = const.MESSAGELEVEL_SOUND
	304	else:
	305	level = const.MESSAGELEVEL_NONE
	306	config.setMessageTypeLevel(messageType, level)
	307
[166]	308	config.enableSounds = self._enableSounds.get_active()
	309	config.pilotControlsSounds = self._pilotControlsSounds.get_active()
	310	config.pilotHotkey = self._pilotHotkey.get()
[270]	311	config.enableApproachCallouts = self._enableApproachCallouts.get_active()
[166]	312	config.speedbrakeAtTD = self._speedbrakeAtTD.get_active()
	313
	314	config.enableChecklists = self._enableChecklists.get_active()
	315	config.checklistHotkey = self._checklistHotkey.get()
	316
[123]	317	config.autoUpdate = self._autoUpdate.get_active()
	318	config.updateURL = self._updateURL.get_text()
	319
	320	def _buildGeneral(self):
	321	"""Build the page for the general settings."""
	322	mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
[149]	323	xscale = 1.0, yscale = 0.0)
[186]	324	mainAlignment.set_padding(padding_top = 0, padding_bottom = 8,
[149]	325	padding_left = 4, padding_right = 4)
[123]	326	mainBox = gtk.VBox()
	327	mainAlignment.add(mainBox)
	328
[186]	329	guiBox = self._createFrame(mainBox, xstr("prefs_frame_gui"))
[392]	330
[123]	331	languageBox = gtk.HBox()
[186]	332	guiBox.pack_start(languageBox, False, False, 4)
[123]	333
	334	label = gtk.Label(xstr("prefs_language"))
	335	label.set_use_underline(True)
	336
	337	languageBox.pack_start(label, False, False, 4)
	338
	339	self._languageList = gtk.ListStore(str, str)
	340	for language in const.languages:
	341	self._languageList.append([xstr("prefs_lang_" + language),
	342	language])
	343
	344	self._languageComboBox = languageComboBox = \
[392]	345	gtk.ComboBox(model = self._languageList)
[123]	346	cell = gtk.CellRendererText()
	347	languageComboBox.pack_start(cell, True)
	348	languageComboBox.add_attribute(cell, 'text', 0)
	349	languageComboBox.set_tooltip_text(xstr("prefs_language_tooltip"))
	350	languageComboBox.connect("changed", self._languageChanged)
	351	languageBox.pack_start(languageComboBox, False, False, 4)
	352
[131]	353	label.set_mnemonic_widget(languageComboBox)
	354
[123]	355	self._changingLanguage = False
	356	self._warnedRestartNeeded = False
	357
[147]	358	self._hideMinimizedWindow = gtk.CheckButton(xstr("prefs_hideMinimizedWindow"))
	359	self._hideMinimizedWindow.set_use_underline(True)
	360	self._hideMinimizedWindow.set_tooltip_text(xstr("prefs_hideMinimizedWindow_tooltip"))
[186]	361	guiBox.pack_start(self._hideMinimizedWindow, False, False, 4)
	362
[249]	363	self._quitOnClose = gtk.CheckButton(xstr("prefs_quitOnClose"))
	364	self._quitOnClose.set_use_underline(True)
	365	self._quitOnClose.set_tooltip_text(xstr("prefs_quitOnClose_tooltip"))
	366	guiBox.pack_start(self._quitOnClose, False, False, 4)
	367
[392]	368	onlineBox = self._createFrame(mainBox, xstr("prefs_frame_online"))
[147]	369
[136]	370	self._onlineGateSystem = gtk.CheckButton(xstr("prefs_onlineGateSystem"))
	371	self._onlineGateSystem.set_use_underline(True)
	372	self._onlineGateSystem.set_tooltip_text(xstr("prefs_onlineGateSystem_tooltip"))
[186]	373	onlineBox.pack_start(self._onlineGateSystem, False, False, 4)
[136]	374
[139]	375	self._onlineACARS = gtk.CheckButton(xstr("prefs_onlineACARS"))
	376	self._onlineACARS.set_use_underline(True)
	377	self._onlineACARS.set_tooltip_text(xstr("prefs_onlineACARS_tooltip"))
[186]	378	onlineBox.pack_start(self._onlineACARS, False, False, 4)
	379
	380	simulatorBox = self._createFrame(mainBox, xstr("prefs_frame_simulator"))
[139]	381
[131]	382	self._flareTimeFromFS = gtk.CheckButton(xstr("prefs_flaretimeFromFS"))
	383	self._flareTimeFromFS.set_use_underline(True)
	384	self._flareTimeFromFS.set_tooltip_text(xstr("prefs_flaretimeFromFS_tooltip"))
[186]	385	simulatorBox.pack_start(self._flareTimeFromFS, False, False, 4)
[392]	386
[148]	387	self._syncFSTime = gtk.CheckButton(xstr("prefs_syncFSTime"))
	388	self._syncFSTime.set_use_underline(True)
	389	self._syncFSTime.set_tooltip_text(xstr("prefs_syncFSTime_tooltip"))
[186]	390	simulatorBox.pack_start(self._syncFSTime, False, False, 4)
[149]	391
[183]	392	self._usingFS2Crew = gtk.CheckButton(xstr("prefs_usingFS2Crew"))
	393	self._usingFS2Crew.set_use_underline(True)
	394	self._usingFS2Crew.set_tooltip_text(xstr("prefs_usingFS2Crew_tooltip"))
[186]	395	simulatorBox.pack_start(self._usingFS2Crew, False, False, 4)
[392]	396
[197]	397	(iasSmoothingBox, self._iasSmoothingEnabled,
	398	self._iasSmoothingLength) = \
	399	self._createSmoothingBox(xstr("prefs_iasSmoothingEnabled"),
	400	xstr("prefs_iasSmoothingEnabledTooltip"))
	401	simulatorBox.pack_start(iasSmoothingBox, False, False, 4)
	402
	403	(vsSmoothingBox, self._vsSmoothingEnabled,
	404	self._vsSmoothingLength) = \
	405	self._createSmoothingBox(xstr("prefs_vsSmoothingEnabled"),
	406	xstr("prefs_vsSmoothingEnabledTooltip"))
	407	simulatorBox.pack_start(vsSmoothingBox, False, False, 4)
[183]	408
[149]	409	pirepBox = gtk.HBox()
[186]	410	mainBox.pack_start(pirepBox, False, False, 8)
[149]	411
	412	label = gtk.Label(xstr("prefs_pirepDirectory"))
	413	label.set_use_underline(True)
	414	pirepBox.pack_start(label, False, False, 4)
	415
	416	self._pirepDirectory = gtk.Entry()
	417	self._pirepDirectory.set_tooltip_text(xstr("prefs_pirepDirectory_tooltip"))
[392]	418	self._pirepDirectory.connect("changed", self._pirepDirectoryChanged)
[149]	419	label.set_mnemonic_widget(self._pirepDirectory)
	420	pirepBox.pack_start(self._pirepDirectory, True, True, 4)
	421
	422	self._pirepDirectoryButton = gtk.Button(xstr("button_browse"))
	423	self._pirepDirectoryButton.connect("clicked",
	424	self._pirepDirectoryButtonClicked)
	425	pirepBox.pack_start(self._pirepDirectoryButton, False, False, 4)
[392]	426
	427	self._pirepAutoSave = gtk.CheckButton(xstr("prefs_pirepAutoSave"))
	428	self._pirepAutoSave.set_use_underline(True)
	429	self._pirepAutoSave.set_tooltip_text(xstr("prefs_pirepAutoSave_tooltip"))
	430	mainBox.pack_start(self._pirepAutoSave, False, False, 0)
	431
[123]	432	return mainAlignment
	433
[186]	434	def _createFrame(self, mainBox, label):
	435	"""Create a frame with an inner alignment and VBox.
	436
	437	Return the vbox."""
	438	frame = gtk.Frame(label = label)
	439	mainBox.pack_start(frame, False, False, 4)
	440	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
	441	xscale = 1.0, yscale = 0.0)
	442	alignment.set_padding(padding_top = 4, padding_bottom = 0,
	443	padding_left = 0, padding_right = 0)
	444	frame.add(alignment)
	445	vbox = gtk.VBox()
	446	alignment.add(vbox)
	447
	448	return vbox
	449
[197]	450	def _createSmoothingBox(self, checkBoxLabel, checkBoxTooltip,
	451	maxSeconds = 10):
	452	"""Create a HBox that contains entry fields for smoothing some value."""
	453	smoothingBox = gtk.HBox()
	454
	455	smoothingEnabled = gtk.CheckButton(checkBoxLabel)
	456	smoothingEnabled.set_use_underline(True)
	457	smoothingEnabled.set_tooltip_text(checkBoxTooltip)
	458
	459	smoothingBox.pack_start(smoothingEnabled, False, False, 0)
	460
	461	smoothingLength = gtk.SpinButton()
	462	smoothingLength.set_numeric(True)
	463	smoothingLength.set_range(2, maxSeconds)
	464	smoothingLength.set_increments(1, 1)
	465	smoothingLength.set_alignment(1.0)
	466	smoothingLength.set_width_chars(2)
	467
	468	smoothingBox.pack_start(smoothingLength, False, False, 0)
	469
	470	smoothingBox.pack_start(gtk.Label(xstr("prefs_smoothing_seconds")),
	471	False, False, 4)
	472
	473	smoothingEnabled.connect("toggled", self._smoothingToggled,
	474	smoothingLength)
	475	smoothingLength.set_sensitive(False)
	476
	477	return (smoothingBox, smoothingEnabled, smoothingLength)
	478
[123]	479	def _setLanguage(self, language):
	480	"""Set the language to the given one."""
	481	iter = self._languageList.get_iter_first()
	482	while iter is not None:
	483	(lang,) = self._languageList.get(iter, 1)
	484	if (not language and lang=="$system") or \
	485	lang==language:
	486	self._changingLanguage = True
	487	self._languageComboBox.set_active_iter(iter)
	488	self._changingLanguage = False
	489	break
	490	else:
	491	iter = self._languageList.iter_next(iter)
	492
	493	def _getLanguage(self):
[392]	494	"""Get the language selected by the user."""
[123]	495	iter = self._languageComboBox.get_active_iter()
	496	(lang,) = self._languageList.get(iter, 1)
	497	return "" if lang=="$system" else lang
	498
	499	def _languageChanged(self, comboBox):
	500	"""Called when the language has changed."""
	501	if not self._changingLanguage and not self._warnedRestartNeeded:
	502	dialog = gtk.MessageDialog(parent = self,
	503	type = MESSAGETYPE_INFO,
	504	message_format = xstr("prefs_restart"))
[124]	505	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
[123]	506	dialog.set_title(self.get_title())
	507	dialog.format_secondary_markup(xstr("prefs_language_restart_sec"))
	508	dialog.run()
	509	dialog.hide()
	510	self._warnedRestartNeeded = True
[197]	511
	512	def _smoothingToggled(self, smoothingEnabled, smoothingLength):
	513	"""Called when a smoothing enabled check box is toggled."""
	514	sensitive = smoothingEnabled.get_active()
	515	smoothingLength.set_sensitive(sensitive)
	516	if sensitive:
	517	smoothingLength.grab_focus()
	518
	519	def _setSmoothing(self, smoothingEnabled, smoothingLength, smoothing):
	520	"""Set the smoothing controls from the given value.
	521
	522	If the value is less than 2, smoothing is disabled. The smoothing
	523	length is the absolute value of the value."""
	524	smoothingEnabled.set_active(smoothing>=2)
	525	smoothingLength.set_value(abs(smoothing))
[392]	526
[197]	527	def _getSmoothing(self, smoothingEnabled, smoothingLength):
	528	"""Get the smoothing value from the given controls.
	529
	530	The returned value is the value of smoothingLength multiplied by -1, if
	531	smoothing is disabled."""
	532	value = smoothingLength.get_value_as_int()
	533	if not smoothingEnabled.get_active():
	534	value *= -1
	535	return value
[392]	536
[149]	537	def _pirepDirectoryButtonClicked(self, button):
	538	"""Called when the PIREP directory button is clicked."""
	539	dialog = gtk.FileChooserDialog(title = WINDOW_TITLE_BASE + " - " +
	540	xstr("prefs_pirepDirectory_browser_title"),
	541	action = FILE_CHOOSER_ACTION_SELECT_FOLDER,
	542	buttons = (gtk.STOCK_CANCEL, RESPONSETYPE_CANCEL,
[151]	543	gtk.STOCK_OK, RESPONSETYPE_OK),
	544	parent = self)
	545	dialog.set_modal(True)
	546	dialog.set_transient_for(self)
[123]	547
[149]	548	directory = self._pirepDirectory.get_text()
	549	if directory:
	550	dialog.select_filename(directory)
[392]	551
[149]	552	result = dialog.run()
	553	dialog.hide()
	554
	555	if result==RESPONSETYPE_OK:
[233]	556	self._pirepDirectory.set_text(text2unicode(dialog.get_filename()))
[392]	557
	558	def _pirepDirectoryChanged(self, entry):
	559	"""Called when the PIREP directory is changed."""
	560	if self._pirepDirectory.get_text():
	561	self._pirepAutoSave.set_sensitive(True)
	562	else:
	563	self._pirepAutoSave.set_active(False)
	564	self._pirepAutoSave.set_sensitive(False)
	565
[132]	566	def _buildMessages(self):
	567	"""Build the page for the message settings."""
	568
	569	mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
	570	xscale = 0.0, yscale = 0.0)
	571	mainAlignment.set_padding(padding_top = 16, padding_bottom = 8,
	572	padding_left = 4, padding_right = 4)
	573	mainBox = gtk.VBox()
	574	mainAlignment.add(mainBox)
	575
	576	table = gtk.Table(len(const.messageTypes) + 1, 3)
	577	table.set_row_spacings(8)
	578	table.set_col_spacings(32)
	579	table.set_homogeneous(False)
	580	mainBox.pack_start(table, False, False, 4)
[392]	581
[132]	582	label = gtk.Label(xstr("prefs_msgs_fs"))
	583	label.set_justify(JUSTIFY_CENTER)
	584	label.set_alignment(0.5, 1.0)
	585	table.attach(label, 1, 2, 0, 1)
[392]	586
[132]	587	label = gtk.Label(xstr("prefs_msgs_sound"))
	588	label.set_justify(JUSTIFY_CENTER)
	589	label.set_alignment(0.5, 1.0)
	590	table.attach(label, 2, 3, 0, 1)
	591
	592	self._msgFSCheckButtons = {}
[392]	593	self._msgSoundCheckButtons = {}
[132]	594	row = 1
	595	for messageType in const.messageTypes:
	596	messageTypeStr = const.messageType2string(messageType)
	597	label = gtk.Label(xstr("prefs_msgs_type_" + messageTypeStr))
	598	label.set_justify(JUSTIFY_CENTER)
	599	label.set_use_underline(True)
	600	label.set_alignment(0.5, 0.5)
	601	table.attach(label, 0, 1, row, row+1)
	602
	603	fsCheckButton = gtk.CheckButton()
	604	alignment = gtk.Alignment(xscale = 0.0, yscale = 0.0,
	605	xalign = 0.5, yalign = 0.5)
	606	alignment.add(fsCheckButton)
	607	table.attach(alignment, 1, 2, row, row+1)
	608	self._msgFSCheckButtons[messageType] = fsCheckButton
[392]	609
[132]	610	soundCheckButton = gtk.CheckButton()
	611	alignment = gtk.Alignment(xscale = 0.0, yscale = 0.0,
	612	xalign = 0.5, yalign = 0.5)
	613	alignment.add(soundCheckButton)
[392]	614	table.attach(alignment, 2, 3, row, row+1)
[132]	615	self._msgSoundCheckButtons[messageType] = soundCheckButton
	616
	617	mnemonicWidget = gtk.Label("")
	618	table.attach(mnemonicWidget, 3, 4, row, row+1)
	619	label.set_mnemonic_widget(mnemonicWidget)
	620	mnemonicWidget.connect("mnemonic-activate",
	621	self._msgLabelActivated,
	622	messageType)
	623
	624	row += 1
	625
	626	return mainAlignment
	627
	628	def _msgLabelActivated(self, button, cycle_group, messageType):
	629	"""Called when the mnemonic of a label is activated.
	630
	631	It cycles the corresponding options."""
	632	fsCheckButton = self._msgFSCheckButtons[messageType]
	633	soundCheckButton = self._msgSoundCheckButtons[messageType]
	634
	635	num = 1 if fsCheckButton.get_active() else 0
	636	num += 2 if soundCheckButton.get_active() else 0
	637	num += 1
	638
	639	fsCheckButton.set_active((num&0x01)==0x01)
	640	soundCheckButton.set_active((num&0x02)==0x02)
	641
	642	return True
[166]	643
	644	def _buildSounds(self):
	645	"""Build the page for the sounds."""
	646	mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
	647	xscale = 1.0, yscale = 1.0)
	648	mainAlignment.set_padding(padding_top = 8, padding_bottom = 8,
	649	padding_left = 4, padding_right = 4)
	650
	651	mainBox = gtk.VBox()
	652	mainAlignment.add(mainBox)
	653
	654	backgroundFrame = gtk.Frame(label = xstr("prefs_sounds_frame_bg"))
	655	mainBox.pack_start(backgroundFrame, False, False, 4)
	656
	657	backgroundAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
	658	xscale = 1.0, yscale = 0.0)
	659	backgroundAlignment.set_padding(padding_top = 4, padding_bottom = 4,
	660	padding_left = 4, padding_right = 4)
	661	backgroundFrame.add(backgroundAlignment)
	662
	663	backgroundBox = gtk.VBox()
	664	backgroundAlignment.add(backgroundBox)
	665
	666	self._enableSounds = gtk.CheckButton(xstr("prefs_sounds_enable"))
	667	self._enableSounds.set_use_underline(True)
	668	self._enableSounds.set_tooltip_text(xstr("prefs_sounds_enable_tooltip"))
	669	self._enableSounds.connect("toggled", self._enableSoundsToggled)
	670	alignment = gtk.Alignment(xalign = 0.0, yalign = 0.5,
	671	xscale = 1.0, yscale = 0.0)
	672	alignment.add(self._enableSounds)
	673	backgroundBox.pack_start(alignment, False, False, 4)
	674
	675	self._pilotControlsSounds = gtk.CheckButton(xstr("prefs_sounds_pilotControls"))
	676	self._pilotControlsSounds.set_use_underline(True)
	677	self._pilotControlsSounds.set_tooltip_text(xstr("prefs_sounds_pilotControls_tooltip"))
[169]	678	self._pilotControlsSounds.connect("toggled", self._pilotControlsSoundsToggled)
[166]	679	backgroundBox.pack_start(self._pilotControlsSounds, False, False, 4)
	680
	681	self._pilotHotkey = Hotkey(xstr("prefs_sounds_pilotHotkey"),
	682	[xstr("prefs_sounds_pilotHotkey_tooltip"),
	683	xstr("prefs_sounds_pilotHotkeyCtrl_tooltip"),
	684	xstr("prefs_sounds_pilotHotkeyShift_tooltip")])
[392]	685
[166]	686	backgroundBox.pack_start(self._pilotHotkey, False, False, 4)
	687
[270]	688	self._enableApproachCallouts = gtk.CheckButton(xstr("prefs_sounds_approachCallouts"))
	689	self._enableApproachCallouts.set_use_underline(True)
	690	self._enableApproachCallouts.set_tooltip_text(xstr("prefs_sounds_approachCallouts_tooltip"))
	691	backgroundBox.pack_start(self._enableApproachCallouts, False, False, 4)
[392]	692
[166]	693	self._speedbrakeAtTD = gtk.CheckButton(xstr("prefs_sounds_speedbrakeAtTD"))
	694	self._speedbrakeAtTD.set_use_underline(True)
	695	self._speedbrakeAtTD.set_tooltip_text(xstr("prefs_sounds_speedbrakeAtTD_tooltip"))
	696	backgroundBox.pack_start(self._speedbrakeAtTD, False, False, 4)
	697
	698	checklistFrame = gtk.Frame(label = xstr("prefs_sounds_frame_checklists"))
	699	mainBox.pack_start(checklistFrame, False, False, 4)
	700
	701	checklistAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
	702	xscale = 1.0, yscale = 0.0)
	703	checklistAlignment.set_padding(padding_top = 4, padding_bottom = 4,
	704	padding_left = 4, padding_right = 4)
	705	checklistFrame.add(checklistAlignment)
	706
	707	checklistBox = gtk.VBox()
	708	checklistAlignment.add(checklistBox)
[392]	709
[166]	710	self._enableChecklists = gtk.CheckButton(xstr("prefs_sounds_enableChecklists"))
	711	self._enableChecklists.set_use_underline(True)
	712	self._enableChecklists.set_tooltip_text(xstr("prefs_sounds_enableChecklists_tooltip"))
	713	self._enableChecklists.connect("toggled", self._enableChecklistsToggled)
	714	checklistBox.pack_start(self._enableChecklists, False, False, 4)
	715
	716	self._checklistHotkey = Hotkey(xstr("prefs_sounds_checklistHotkey"),
	717	[xstr("prefs_sounds_checklistHotkey_tooltip"),
	718	xstr("prefs_sounds_checklistHotkeyCtrl_tooltip"),
	719	xstr("prefs_sounds_checklistHotkeyShift_tooltip")])
	720
	721	checklistBox.pack_start(self._checklistHotkey, False, False, 4)
	722
	723	self._enableSoundsToggled(self._enableSounds)
	724	self._enableChecklistsToggled(self._enableChecklists)
	725
[167]	726	self._pilotHotkey.connect("hotkey-changed", self._reconcileHotkeys,
	727	self._checklistHotkey)
	728	self._checklistHotkey.connect("hotkey-changed", self._reconcileHotkeys,
	729	self._pilotHotkey)
	730
[166]	731	return mainAlignment
	732
	733	def _enableSoundsToggled(self, button):
	734	"""Called when the enable sounds button is toggled."""
	735	active = button.get_active()
	736	self._pilotControlsSounds.set_sensitive(active)
[169]	737	self._pilotControlsSoundsToggled(self._pilotControlsSounds)
[270]	738	self._enableApproachCallouts.set_sensitive(active)
[169]	739	self._speedbrakeAtTD.set_sensitive(active)
	740
	741	def _pilotControlsSoundsToggled(self, button):
	742	"""Called when the enable sounds button is toggled."""
	743	active = button.get_active() and self._enableSounds.get_active()
[166]	744	self._pilotHotkey.set_sensitive(active)
[167]	745	if active and self._checklistHotkey.get_sensitive():
	746	self._reconcileHotkeys(self._checklistHotkey, Hotkey.CHANGED_SHIFT,
	747	self._pilotHotkey)
[166]	748
	749	def _enableChecklistsToggled(self, button):
	750	"""Called when the enable checklists button is toggled."""
	751	active = button.get_active()
	752	self._checklistHotkey.set_sensitive(active)
[167]	753	if active and self._pilotHotkey.get_sensitive():
	754	self._reconcileHotkeys(self._pilotHotkey, Hotkey.CHANGED_SHIFT,
	755	self._checklistHotkey)
	756
	757	def _reconcileHotkeys(self, changedHotkey, what, otherHotkey):
	758	"""Reconcile the given hotkeys so that they are different.
	759
	760	changedHotkey is the hotkey that has changed. what is one of the
	761	Hotkey.CHANGED_XXX constants denoting what has changed. otherHotkey is
	762	the other hotkey that must be reconciled.
	763
	764	If the other hotkey is not sensitive or is not equal to the changed
	765	one, nothing happens.
	766
	767	Otherwise, if the status of the Ctrl modifier has changed, the status
	768	of the Ctrl modifier on the other hotkey will be negated. Similarly, if
	769	the Shift modifier has changed. If the key has changed, the Shift
	770	modifier is negated in the other hotkey."""
	771	if otherHotkey.get_sensitive() and changedHotkey==otherHotkey:
	772	if what==Hotkey.CHANGED_CTRL:
	773	otherHotkey.ctrl = not changedHotkey.ctrl
	774	elif what==Hotkey.CHANGED_SHIFT or what==Hotkey.CHANGED_KEY:
	775	otherHotkey.shift = not changedHotkey.shift
[166]	776
[123]	777	def _buildAdvanced(self):
	778	"""Build the page for the advanced settings."""
	779
	780	mainAlignment = gtk.Alignment(xalign = 0.0, yalign = 0.0,
[149]	781	xscale = 1.0, yscale = 0.0)
	782	mainAlignment.set_padding(padding_top = 16, padding_bottom = 8,
	783	padding_left = 4, padding_right = 4)
[123]	784	mainBox = gtk.VBox()
	785	mainAlignment.add(mainBox)
	786
	787	self._autoUpdate = gtk.CheckButton(xstr("prefs_update_auto"))
	788	mainBox.pack_start(self._autoUpdate, False, False, 4)
	789
	790	self._autoUpdate.set_use_underline(True)
	791	self._autoUpdate.connect("toggled", self._autoUpdateToggled)
	792	self._autoUpdate.set_tooltip_text(xstr("prefs_update_auto_tooltip"))
	793	self._warnedAutoUpdate = False
[392]	794
[123]	795	updateURLBox = gtk.HBox()
	796	mainBox.pack_start(updateURLBox, False, False, 4)
	797	label = gtk.Label(xstr("prefs_update_url"))
	798	label.set_use_underline(True)
	799	updateURLBox.pack_start(label, False, False, 4)
	800
	801	self._updateURL = gtk.Entry()
	802	label.set_mnemonic_widget(self._updateURL)
	803	self._updateURL.set_width_chars(40)
	804	self._updateURL.set_tooltip_text(xstr("prefs_update_url_tooltip"))
	805	self._updateURL.connect("changed", self._updateURLChanged)
[149]	806	updateURLBox.pack_start(self._updateURL, True, True, 4)
[123]	807
	808	return mainAlignment
	809
	810	def _setOKButtonSensitivity(self):
	811	"""Set the sensitive state of the OK button."""
	812	sensitive = False
	813	try:
	814	result = urlparse.urlparse(self._updateURL.get_text())
	815	sensitive = result.scheme!="" and (result.netloc + result.path)!=""
	816	except:
	817	pass
	818
	819	okButton = self.get_widget_for_response(RESPONSETYPE_ACCEPT)
	820	okButton.set_sensitive(sensitive)
	821
	822	def _autoUpdateToggled(self, button):
	823	"""Called when the auto update check button is toggled."""
[166]	824	if not self._settingFromConfig and not self._warnedAutoUpdate and \
[123]	825	not self._autoUpdate.get_active():
	826	dialog = gtk.MessageDialog(parent = self,
	827	type = MESSAGETYPE_INFO,
	828	message_format = xstr("prefs_update_auto_warning"))
[124]	829	dialog.add_button(xstr("button_ok"), RESPONSETYPE_OK)
[123]	830	dialog.set_title(self.get_title())
	831	dialog.run()
	832	dialog.hide()
	833	self._warnedAutoUpdate = True
[392]	834
[123]	835	def _updateURLChanged(self, entry):
	836	"""Called when the update URL is changed."""
	837	self._setOKButtonSensitivity()
[167]	838

Note: See TracBrowser for help on using the repository browser.

Download in other formats: