class BaseEditor(BaseEditorSlave, RunnableView):
""" Base class for editor dialogs. It offers methods of
BaseEditorSlave, a windows title and OK/Cancel buttons.
"""
#: the model type name of the model we are editing.
#: This value will be showed in the title of the editor and can not
#: be merely the attribute __name__ of the object for usability reasons.
#: Call sites will decide what could be the best name applicable in each
#: situation.
model_name = None
header = ''
size = ()
title = None
hide_footer = False
#: a list of widget names that when activated will confirm the dialog
confirm_widgets = ()
help_section = None
form_holder_name = 'toplevel'
def __init__(self, store, model=None, visual_mode=False):
if store is not None and isinstance(store, StoqlibStore):
store.needs_retval = True
self._confirm_disabled = False
# FIXME:
# BasicEditor should inheirt from BasicDialog and instantiate
# the slave inside here, but it requires some major surgery
BaseEditorSlave.__init__(self, store, model,
visual_mode=visual_mode)
self.main_dialog = BasicDialog(title=self.get_title(self.model),
header_text=self.header,
help_section=self.help_section,
size=self.size)
# Do not close the dialog if re return False on self.confirm
self.main_dialog.enable_confirm_validation = True
self.main_dialog.attach_slave("main", self)
self.main_dialog.connect('confirm', self._on_main_dialog__confirm)
self.main_dialog.connect('cancel', self._on_main_dialog__cancel)
# This helps kiwis ui test, set the name of ourselves to
# the classname of the slave, which is much more helpful than
# just "BasicDialog"
self.main_dialog.get_toplevel().set_name(self.__class__.__name__)
if self.hide_footer or self.visual_mode:
self.main_dialog.hide_footer()
for name in self.confirm_widgets:
self.set_confirm_widget(getattr(self, name))
self.register_validate_function(self._validation_function)
self.force_validation()
def _get_title_format(self):
if self.visual_mode:
return _(u"Details of %s")
if self.edit_mode:
return _(u'Edit Details of "%s"')
return _(u"Add %s")
def get_title(self, model):
if self.title:
return self.title
if not model:
raise ValueError("A model should be defined at this point")
title_format = self._get_title_format()
if self.model_name:
model_name = self.model_name
else:
# Fallback to the name of the class
model_name = type(self.model).__name__
return title_format % model_name
def enable_window_controls(self):
"""Enables the window controls
See :class:`kiwi.ui.views.BaseView.enable_window_controls`.
"""
self.main_dialog.enable_window_controls()
def set_description(self, description):
"""Sets the description of the model object which is used by the editor
:param description:
"""
format = self._get_title_format()
self.main_dialog.set_title(format % description)
def refresh_ok(self, validation_value):
""" Refreshes ok button sensitivity according to widget validators
status """
if self._confirm_disabled:
return
self.main_dialog.ok_button.set_sensitive(validation_value)
def add_button(self, label=None, stock=None):
"""
Adds a button to editor. The added button is returned which you
can use to connect signals on.
:param label: label of the button
:param stock: stock label of the button
:param returns: the button added
:rtype: gtk.Button
"""
if label is None and stock is None:
raise TypeError("You need to provide a label or a stock argument")
button = gtk.Button(label=label, stock=stock)
button.props.can_focus = True
self.main_dialog.action_area.pack_start(button, False, False)
self.main_dialog.action_area.reorder_child(button, 0)
button.show()
return button
def cancel(self):
"""
Cancel the dialog.
"""
# set this before runing BaseEditorSlave.cancel so
# on_cancel can modify self.retval, if needed
self.retval = False
BaseEditorSlave.cancel(self)
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (cancelled), retval=%r" % (
self.__class__.__name__, self.retval))
def confirm(self):
"""
Confirm the dialog.
"""
# set this before runing BaseEditorSlave.confirm so
# on_confirm can modify self.retval, if needed
self.retval = self.model
if self._confirm_disabled:
return False
if not BaseEditorSlave.confirm(self):
return False
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (confirmed), retval=%r" % (
self.__class__.__name__, self.retval))
return True
def enable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.enable_ok()
self._confirm_disabled = False
def disable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.disable_ok()
self._confirm_disabled = True
def enable_normal_window(self):
"""
Enable the dialog as a normal window.
This tells the window manager that the window
should behave as a normal window instead of a dialog.
"""
toplevel = self.main_dialog.get_toplevel()
toplevel.set_type_hint(gdk.WINDOW_TYPE_HINT_NORMAL)
def set_confirm_widget(self, widget_name):
"""
Make a widget confirmable, eg activating that widget would
close the dialog.
:param widget_name: name of the widget to be confirmable
"""
self.main_dialog.set_confirm_widget(widget_name)
def set_message(self, message, message_type=gtk.MESSAGE_INFO):
"""Sets a message for this editor
:param message: message to add
:param message_type: type of message to add
"""
self.main_dialog.set_message(message, message_type)
# RunnableView
# This delegate everything to self.main_dialog
def close(self):
self.main_dialog.close()
def run(self):
self.main_dialog.run()
def get_current_toplevel(self):
return self.main_dialog.get_current_toplevel()
def destroy(self):
self.main_dialog.destroy()
def set_transient_for(self, window):
self.main_dialog.set_transient_for(window)
# Callbacks
def _on_main_dialog__cancel(self, dialog, retval):
self.cancel()
def _on_main_dialog__confirm(self, dialog, retval):
return self.confirm()
def _validation_function(self, is_valid):
self.refresh_ok(is_valid)
class BaseEditor(BaseEditorSlave, RunnableView):
""" Base class for editor dialogs. It offers methods of
BaseEditorSlave, a windows title and OK/Cancel buttons.
"""
#: the model type name of the model we are editing.
#: This value will be showed in the title of the editor and can not
#: be merely the attribute __name__ of the object for usability reasons.
#: Call sites will decide what could be the best name applicable in each
#: situation.
model_name = None
header = ''
size = ()
title = None
hide_footer = False
#: if we need to ask the user if he really wants to cancel the dialog if
#: there are any changes done that would be lost otherwise
need_cancel_confirmation = False
#: a list of widget names that when activated will confirm the dialog
confirm_widgets = ()
help_section = None
form_holder_name = 'toplevel'
def __init__(self, store, model=None, visual_mode=False):
self._confirm_disabled = False
# FIXME:
# BasicEditor should inheirt from BasicDialog and instantiate
# the slave inside here, but it requires some major surgery
BaseEditorSlave.__init__(self, store, model,
visual_mode=visual_mode)
self.main_dialog = BasicDialog(title=self.get_title(self.model),
header_text=self.header,
help_section=self.help_section,
size=self.size)
# Do not close the dialog if re return False on self.confirm
self.main_dialog.enable_confirm_validation = True
self.main_dialog.attach_slave("main", self)
self.main_dialog.connect('confirm', self._on_main_dialog__confirm)
self.main_dialog.connect('cancel', self._on_main_dialog__cancel)
dialog_toplevel = self.main_dialog.get_toplevel()
dialog_toplevel.connect('response', self._on_toplevel__response)
dialog_toplevel.connect('delete-event', self._on_toplevel__delete_event)
# This helps kiwis ui test, set the name of ourselves to
# the classname of the slave, which is much more helpful than
# just "BasicDialog"
self.main_dialog.get_toplevel().set_name(self.__class__.__name__)
if self.hide_footer or self.visual_mode:
self.main_dialog.hide_footer()
for name in self.confirm_widgets:
self.set_confirm_widget(getattr(self, name))
self.register_validate_function(self._validation_function)
self.force_validation()
# We need to use self.model instead of model, since BaseEditorSlave
# will create one if its None
EditorCreateEvent.emit(self, self.model, store, visual_mode)
if store is not None:
# This needs to be the last thing done on __init__ since we don't want
# to consider things like self.create_model as a change
self._store_pending_count = store.get_pending_count()
#
# Private
#
def _get_title_format(self):
if self.visual_mode:
return _(u"Details of %s")
if self.edit_mode:
return _(u'Edit Details of "%s"')
return _(u"Add %s")
def _need_cancel_confirmation(self):
return self.need_cancel_confirmation and self.has_changes()
#
# Public
#
def has_changes(self):
"""Check if there are changes on this editor
By default we will check if there're any pending changes on
:obj:`.store` and that information will be used by
:attr:`.need_cancel_confirmation`
"""
if self.store is None:
return False
return self.store.get_pending_count() > self._store_pending_count
def get_title(self, model):
if self.title:
return self.title
if not model:
raise ValueError("A model should be defined at this point")
title_format = self._get_title_format()
if self.model_name:
model_name = self.model_name
else:
# Fallback to the name of the class
model_name = type(self.model).__name__
return title_format % model_name
def enable_window_controls(self):
"""Enables the window controls
See :class:`kiwi.ui.views.BaseView.enable_window_controls`.
"""
self.main_dialog.enable_window_controls()
def set_description(self, description):
"""Sets the description of the model object which is used by the editor
:param description:
"""
format = self._get_title_format()
self.main_dialog.set_title(format % description)
def refresh_ok(self, validation_value):
""" Refreshes ok button sensitivity according to widget validators
status """
if self._confirm_disabled:
return
self.main_dialog.ok_button.set_sensitive(validation_value)
def add_button(self, label=None, stock=None):
"""
Adds a button to editor. The added button is returned which you
can use to connect signals on.
:param label: label of the button
:param stock: stock label of the button
:param returns: the button added
:rtype: gtk.Button
"""
if label is None and stock is None:
raise TypeError("You need to provide a label or a stock argument")
button = gtk.Button(label=label, stock=stock)
button.props.can_focus = True
self.main_dialog.action_area.pack_start(button, False, False)
self.main_dialog.action_area.reorder_child(button, 0)
button.show()
return button
def cancel(self):
"""
Cancel the dialog.
"""
if (self._need_cancel_confirmation() and
not yesno(_("If you cancel this dialog all changes will be lost. "
"Are you sure?"), gtk.RESPONSE_NO,
_("Cancel"), _("Don't cancel"))):
return False
# set this before runing BaseEditorSlave.cancel so
# on_cancel can modify self.retval, if needed
self.retval = False
BaseEditorSlave.cancel(self)
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (cancelled), retval=%r" % (
self.__class__.__name__, self.retval))
return True
def confirm(self):
"""
Confirm the dialog.
"""
# set this before runing BaseEditorSlave.confirm so
# on_confirm can modify self.retval, if needed
self.retval = self.model
if self._confirm_disabled:
return False
if not BaseEditorSlave.confirm(self):
return False
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (confirmed), retval=%r" % (
self.__class__.__name__, self.retval))
return True
def enable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.enable_ok()
self._confirm_disabled = False
def disable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.disable_ok()
self._confirm_disabled = True
def enable_normal_window(self):
"""
Enable the dialog as a normal window.
This tells the window manager that the window
should behave as a normal window instead of a dialog.
"""
toplevel = self.main_dialog.get_toplevel()
toplevel.set_type_hint(gdk.WINDOW_TYPE_HINT_NORMAL)
def set_confirm_widget(self, widget_name):
"""
Make a widget confirmable, eg activating that widget would
close the dialog.
:param widget_name: name of the widget to be confirmable
"""
self.main_dialog.set_confirm_widget(widget_name)
def set_message(self, message, message_type=None):
"""Sets a message for this editor
:param message: message to add
:param message_type: type of message to add
"""
if message_type is None:
message_type = gtk.MESSAGE_INFO
self.main_dialog.set_message(message, message_type)
# RunnableView
# This delegate everything to self.main_dialog
def close(self):
self.main_dialog.close()
def run(self):
self.main_dialog.run()
def get_current_toplevel(self):
return self.main_dialog.get_current_toplevel()
def destroy(self):
self.main_dialog.destroy()
def set_transient_for(self, window):
self.main_dialog.set_transient_for(window)
# Callbacks
def _on_main_dialog__cancel(self, dialog, retval):
return self.cancel()
def _on_main_dialog__confirm(self, dialog, retval):
return self.confirm()
def _validation_function(self, is_valid):
self.refresh_ok(is_valid)
def _on_toplevel__delete_event(self, widget, *args, **kwargs):
# Avoid the dialog being closed when hitting 'Esc' and we would need
# confirm the cancelation.
if self._need_cancel_confirmation():
return True
def _on_toplevel__response(self, dialog, response, *args, **kwargs):
# FIXME: For the delete-event to really stops from destroying the
# dialog, we also need to stop the response event emission. See
# http://faq.pygtk.org/index.py?req=show&file=faq10.013.htp
# for more details
if (self._need_cancel_confirmation() and
response == gtk.RESPONSE_DELETE_EVENT):
dialog.emit_stop_by_name('response')
class BaseEditor(BaseEditorSlave, RunnableView):
""" Base class for editor dialogs. It offers methods of
BaseEditorSlave, a windows title and OK/Cancel buttons.
"""
#: the model type name of the model we are editing.
#: This value will be showed in the title of the editor and can not
#: be merely the attribute __name__ of the object for usability reasons.
#: Call sites will decide what could be the best name applicable in each
#: situation.
model_name = None
header = ''
size = ()
title = None
hide_footer = False
#: a list of widget names that when activated will confirm the dialog
confirm_widgets = ()
help_section = None
form_holder_name = 'toplevel'
def __init__(self, store, model=None, visual_mode=False):
if store is not None and isinstance(store, StoqlibStore):
store.needs_retval = True
self._confirm_disabled = False
# FIXME:
# BasicEditor should inheirt from BasicDialog and instantiate
# the slave inside here, but it requires some major surgery
BaseEditorSlave.__init__(self, store, model, visual_mode=visual_mode)
self.main_dialog = BasicDialog(title=self.get_title(self.model),
header_text=self.header,
help_section=self.help_section,
size=self.size)
# Do not close the dialog if re return False on self.confirm
self.main_dialog.enable_confirm_validation = True
self.main_dialog.attach_slave("main", self)
self.main_dialog.connect('confirm', self._on_main_dialog__confirm)
self.main_dialog.connect('cancel', self._on_main_dialog__cancel)
# This helps kiwis ui test, set the name of ourselves to
# the classname of the slave, which is much more helpful than
# just "BasicDialog"
self.main_dialog.get_toplevel().set_name(self.__class__.__name__)
if self.hide_footer or self.visual_mode:
self.main_dialog.hide_footer()
for name in self.confirm_widgets:
self.set_confirm_widget(getattr(self, name))
self.register_validate_function(self._validation_function)
self.force_validation()
def _get_title_format(self):
if self.visual_mode:
return _(u"Details of %s")
if self.edit_mode:
return _(u'Edit Details of "%s"')
return _(u"Add %s")
def get_title(self, model):
if self.title:
return self.title
if not model:
raise ValueError("A model should be defined at this point")
title_format = self._get_title_format()
if self.model_name:
model_name = self.model_name
else:
# Fallback to the name of the class
model_name = type(self.model).__name__
return title_format % model_name
def enable_window_controls(self):
"""Enables the window controls
See :class:`kiwi.ui.views.BaseView.enable_window_controls`.
"""
self.main_dialog.enable_window_controls()
def set_description(self, description):
"""Sets the description of the model object which is used by the editor
:param description:
"""
format = self._get_title_format()
self.main_dialog.set_title(format % description)
def refresh_ok(self, validation_value):
""" Refreshes ok button sensitivity according to widget validators
status """
if self._confirm_disabled:
return
self.main_dialog.ok_button.set_sensitive(validation_value)
def add_button(self, label=None, stock=None):
"""
Adds a button to editor. The added button is returned which you
can use to connect signals on.
:param label: label of the button
:param stock: stock label of the button
:param returns: the button added
:rtype: gtk.Button
"""
if label is None and stock is None:
raise TypeError("You need to provide a label or a stock argument")
button = gtk.Button(label=label, stock=stock)
button.props.can_focus = True
self.main_dialog.action_area.pack_start(button, False, False)
self.main_dialog.action_area.reorder_child(button, 0)
button.show()
return button
def cancel(self):
"""
Cancel the dialog.
"""
# set this before runing BaseEditorSlave.cancel so
# on_cancel can modify self.retval, if needed
self.retval = False
BaseEditorSlave.cancel(self)
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (cancelled), retval=%r" %
(self.__class__.__name__, self.retval))
def confirm(self):
"""
Confirm the dialog.
"""
# set this before runing BaseEditorSlave.confirm so
# on_confirm can modify self.retval, if needed
self.retval = self.model
if self._confirm_disabled:
return False
if not BaseEditorSlave.confirm(self):
return False
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (confirmed), retval=%r" %
(self.__class__.__name__, self.retval))
return True
def enable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.enable_ok()
self._confirm_disabled = False
def disable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.disable_ok()
self._confirm_disabled = True
def enable_normal_window(self):
"""
Enable the dialog as a normal window.
This tells the window manager that the window
should behave as a normal window instead of a dialog.
"""
toplevel = self.main_dialog.get_toplevel()
toplevel.set_type_hint(gdk.WINDOW_TYPE_HINT_NORMAL)
def set_confirm_widget(self, widget_name):
"""
Make a widget confirmable, eg activating that widget would
close the dialog.
:param widget_name: name of the widget to be confirmable
"""
self.main_dialog.set_confirm_widget(widget_name)
def set_message(self, message, message_type=gtk.MESSAGE_INFO):
"""Sets a message for this editor
:param message: message to add
:param message_type: type of message to add
"""
self.main_dialog.set_message(message, message_type)
# RunnableView
# This delegate everything to self.main_dialog
def close(self):
self.main_dialog.close()
def run(self):
self.main_dialog.run()
def get_current_toplevel(self):
return self.main_dialog.get_current_toplevel()
def destroy(self):
self.main_dialog.destroy()
def set_transient_for(self, window):
self.main_dialog.set_transient_for(window)
# Callbacks
def _on_main_dialog__cancel(self, dialog, retval):
self.cancel()
def _on_main_dialog__confirm(self, dialog, retval):
return self.confirm()
def _validation_function(self, is_valid):
self.refresh_ok(is_valid)
class BaseEditor(BaseEditorSlave, RunnableView):
""" Base class for editor dialogs. It offers methods of
BaseEditorSlave, a windows title and OK/Cancel buttons.
"""
#: the model type name of the model we are editing.
#: This value will be showed in the title of the editor and can not
#: be merely the attribute __name__ of the object for usability reasons.
#: Call sites will decide what could be the best name applicable in each
#: situation.
model_name = None
header = ''
size = ()
title = None
hide_footer = False
#: if we need to ask the user if he really wants to cancel the dialog if
#: there are any changes done that would be lost otherwise
need_cancel_confirmation = False
#: a list of widget names that when activated will confirm the dialog
confirm_widgets = ()
help_section = None
form_holder_name = 'toplevel'
def __init__(self, store, model=None, visual_mode=False):
self._confirm_disabled = False
# FIXME:
# BasicEditor should inheirt from BasicDialog and instantiate
# the slave inside here, but it requires some major surgery
BaseEditorSlave.__init__(self, store, model, visual_mode=visual_mode)
self.main_dialog = BasicDialog(title=self.get_title(self.model),
header_text=self.header,
help_section=self.help_section,
size=self.size)
# Do not close the dialog if re return False on self.confirm
self.main_dialog.enable_confirm_validation = True
self.main_dialog.attach_slave("main", self)
self.main_dialog.connect('confirm', self._on_main_dialog__confirm)
self.main_dialog.connect('cancel', self._on_main_dialog__cancel)
dialog_toplevel = self.main_dialog.get_toplevel()
dialog_toplevel.connect('response', self._on_toplevel__response)
dialog_toplevel.connect('delete-event',
self._on_toplevel__delete_event)
# This helps kiwis ui test, set the name of ourselves to
# the classname of the slave, which is much more helpful than
# just "BasicDialog"
self.main_dialog.get_toplevel().set_name(self.__class__.__name__)
if self.hide_footer or self.visual_mode:
self.main_dialog.hide_footer()
for name in self.confirm_widgets:
self.set_confirm_widget(getattr(self, name))
self.register_validate_function(self._validation_function)
self.force_validation()
# We need to use self.model instead of model, since BaseEditorSlave
# will create one if its None
EditorCreateEvent.emit(self, self.model, store, visual_mode)
if store is not None:
# This needs to be the last thing done on __init__ since we don't want
# to consider things like self.create_model as a change
self._store_pending_count = store.get_pending_count()
#
# Private
#
def _get_title_format(self):
if self.visual_mode:
return _(u"Details of %s")
if self.edit_mode:
return _(u'Edit Details of "%s"')
return _(u"Add %s")
def _need_cancel_confirmation(self):
return self.need_cancel_confirmation and self.has_changes()
#
# Public
#
def has_changes(self):
"""Check if there are changes on this editor
By default we will check if there're any pending changes on
:obj:`.store` and that information will be used by
:attr:`.need_cancel_confirmation`
"""
if self.store is None:
return False
return self.store.get_pending_count() > self._store_pending_count
def get_title(self, model):
if self.title:
return self.title
if not model:
raise ValueError("A model should be defined at this point")
title_format = self._get_title_format()
if self.model_name:
model_name = self.model_name
else:
# Fallback to the name of the class
model_name = type(self.model).__name__
return title_format % model_name
def enable_window_controls(self):
"""Enables the window controls
See :class:`kiwi.ui.views.BaseView.enable_window_controls`.
"""
self.main_dialog.enable_window_controls()
def set_description(self, description):
"""Sets the description of the model object which is used by the editor
:param description:
"""
format = self._get_title_format()
self.main_dialog.set_title(format % description)
def refresh_ok(self, validation_value):
""" Refreshes ok button sensitivity according to widget validators
status """
if self._confirm_disabled:
return
self.main_dialog.ok_button.set_sensitive(validation_value)
def add_button(self, label=None, stock=None):
"""
Adds a button to editor. The added button is returned which you
can use to connect signals on.
:param label: label of the button
:param stock: stock label of the button
:param returns: the button added
:rtype: Gtk.Button
"""
if label is None and stock is None:
raise TypeError("You need to provide a label or a stock argument")
button = Gtk.Button(label=label, stock=stock)
button.props.can_focus = True
self.main_dialog.action_area.pack_start(button, False, False, 0)
self.main_dialog.action_area.reorder_child(button, 0)
button.show()
return button
def cancel(self):
"""
Cancel the dialog.
"""
if (self._need_cancel_confirmation() and not yesno(
_("If you cancel this dialog all changes will be lost. "
"Are you sure?"), Gtk.ResponseType.NO, _("Cancel"),
_("Don't cancel"))):
return False
# set this before runing BaseEditorSlave.cancel so
# on_cancel can modify self.retval, if needed
self.retval = False
BaseEditorSlave.cancel(self)
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (cancelled), retval=%r" %
(self.__class__.__name__, self.retval))
return True
def confirm(self):
"""
Confirm the dialog.
"""
# set this before runing BaseEditorSlave.confirm so
# on_confirm can modify self.retval, if needed
self.retval = self.model
if self._confirm_disabled:
return False
if not BaseEditorSlave.confirm(self):
return False
self.main_dialog.close()
if isinstance(self.store, StoqlibStore):
self.store.retval = self.retval
log.info("%s: Closed (confirmed), retval=%r" %
(self.__class__.__name__, self.retval))
return True
def enable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.enable_ok()
self._confirm_disabled = False
def disable_ok(self):
"""
Enable the ok button of the dialog, eg makes it possible
to close/confirm the dialog.
"""
self.main_dialog.disable_ok()
self._confirm_disabled = True
def enable_normal_window(self):
"""
Enable the dialog as a normal window.
This tells the window manager that the window
should behave as a normal window instead of a dialog.
"""
toplevel = self.main_dialog.get_toplevel()
toplevel.set_type_hint(Gdk.WindowTypeHint.NORMAL)
def set_confirm_widget(self, widget_name):
"""
Make a widget confirmable, eg activating that widget would
close the dialog.
:param widget_name: name of the widget to be confirmable
"""
self.main_dialog.set_confirm_widget(widget_name)
def set_message(self, message, message_type=None):
"""Sets a message for this editor
:param message: message to add
:param message_type: type of message to add
"""
if message_type is None:
message_type = Gtk.MessageType.INFO
self.main_dialog.set_message(message, message_type)
# RunnableView
# This delegate everything to self.main_dialog
def close(self):
self.main_dialog.close()
def run(self):
self.main_dialog.run()
def get_current_toplevel(self):
return self.main_dialog.get_current_toplevel()
def destroy(self):
self.main_dialog.destroy()
def set_transient_for(self, window):
self.main_dialog.set_transient_for(window)
# Callbacks
def _on_main_dialog__cancel(self, dialog, retval):
return self.cancel()
def _on_main_dialog__confirm(self, dialog, retval):
return self.confirm()
def _validation_function(self, is_valid):
self.refresh_ok(is_valid)
def _on_toplevel__delete_event(self, widget, *args, **kwargs):
# Avoid the dialog being closed when hitting 'Esc' and we would need
# confirm the cancelation.
if self._need_cancel_confirmation():
return True
def _on_toplevel__response(self, dialog, response, *args, **kwargs):
# FIXME: For the delete-event to really stops from destroying the
# dialog, we also need to stop the response event emission. See
# http://faq.pyGtk.org/index.py?req=show&file=faq10.013.htp
# for more details
if (self._need_cancel_confirmation()
and response == Gtk.ResponseType.DELETE_EVENT):
dialog.emit_stop_by_name('response')
