def test_progress_column():
from traitsui.extras.progress_column import ProgressColumn
progress_view = View(
Item(
'values',
show_label=False,
editor=TableEditor(
columns=[
ObjectColumn(name='value'),
ProgressColumn(name='other_value'),
],
)
),
buttons=['OK'],
)
gui = GUI()
object_list = ObjectList(
values=[ListItem(value=str(i**2)) for i in range(10)]
)
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=progress_view)
gui.process_events()
press_ok_button(ui)
gui.process_events()
def test_tabular_editor_multi_selection_items_changed(self):
gui = GUI()
view = get_view(multi_select=True)
with store_exceptions_on_all_threads(), \
self.report_and_editor(view) as (report, editor):
gui.process_events()
people = report.people
self.assertEqual(get_selected_rows(editor), [])
report.selected_rows.extend([0, 1])
gui.process_events()
self.assertEqual(get_selected_rows(editor), [0, 1])
self.assertEqual(report.multi_selected, people[:2])
report.selected_rows[1] = 2
gui.process_events()
self.assertEqual(get_selected_rows(editor), [0, 2])
self.assertEqual(report.multi_selected, people[0:3:2])
report.multi_selected[0] = people[1]
gui.process_events()
self.assertEqual(sorted(get_selected_rows(editor)), [1, 2])
self.assertEqual(sorted(report.selected_rows), [1, 2])
# If there's a single invalid value, nothing is updated
report.multi_selected[0] = Person(name="invalid", age=-1)
gui.process_events()
self.assertEqual(sorted(get_selected_rows(editor)), [1, 2])
self.assertEqual(sorted(report.selected_rows), [1, 2])
def test_table_editor_select_cells():
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)]
)
object_list.selected_cells = [
(object_list.values[5], 'value'),
(object_list.values[6], 'other value'),
(object_list.values[8], 'value'),
]
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=select_cells_view)
editor = ui.get_editors('values')[0]
gui.process_events()
if is_current_backend_qt4():
selected = editor.selected
elif is_current_backend_wx():
selected = editor.selected_cells
press_ok_button(ui)
gui.process_events()
assert selected == [
(object_list.values[5], 'value'),
(object_list.values[6], 'other value'),
(object_list.values[8], 'value'),
]
def test_table_editor_select_cells(self):
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
object_list.selected_cells = [
(object_list.values[5], "value"),
(object_list.values[6], "other value"),
(object_list.values[8], "value"),
]
with store_exceptions_on_all_threads(), \
create_ui(object_list, dict(view=select_cells_view)) as ui:
editor = ui.get_editors("values")[0]
gui.process_events()
if is_current_backend_qt4():
selected = editor.selected
elif is_current_backend_wx():
selected = editor.selected_cells
press_ok_button(ui)
gui.process_events()
self.assertEqual(selected, [
(object_list.values[5], "value"),
(object_list.values[6], "other value"),
(object_list.values[8], "value"),
])
def test_progress_column():
from traitsui.extras.progress_column import ProgressColumn
progress_view = View(
Item(
'values',
show_label=False,
editor=TableEditor(
columns=[
ObjectColumn(name='value'),
ProgressColumn(name='other_value'),
],
)
),
buttons=['OK'],
)
gui = GUI()
object_list = ObjectList(
values=[ListItem(value=str(i**2)) for i in range(10)]
)
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=progress_view)
gui.process_events()
press_ok_button(ui)
gui.process_events()
def test_tabular_editor_single_selection_changed(self):
gui = GUI()
with store_exceptions_on_all_threads(), \
self.report_and_editor(get_view()) as (report, editor):
gui.process_events()
people = report.people
self.assertEqual(get_selected_rows(editor), [])
report.selected_row = 1
gui.process_events()
self.assertEqual(get_selected_rows(editor), [1])
self.assertEqual(report.selected, people[1])
report.selected = people[2]
gui.process_events()
self.assertEqual(get_selected_rows(editor), [2])
self.assertEqual(report.selected_row, 2)
# Selected set to invalid value doesn't change anything
report.selected = Person(name="invalid", age=-1)
gui.process_events()
self.assertEqual(get_selected_rows(editor), [2])
self.assertEqual(report.selected_row, 2)
# -1 clears selection
report.selected_row = -1
gui.process_events()
self.assertEqual(get_selected_rows(editor), [])
self.assertEqual(report.selected, None)
def test_styles(self):
# simple smoke test of buttons
gui = GUI()
button_text_edit = ButtonTextEdit()
with store_exceptions_on_all_threads():
ui = button_text_edit.edit_traits()
self.addCleanup(ui.dispose)
gui.process_events()
def test_styles(self):
# simple smoke test of buttons
gui = GUI()
button_text_edit = ButtonTextEdit()
with store_exceptions_on_all_threads():
ui = button_text_edit.edit_traits()
self.addCleanup(ui.dispose)
gui.process_events()
def setup_gui(self, model, view):
gui = GUI()
ui = model.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor = ui.get_editors("value")[0]
return gui, editor
def test_table_editor():
gui = GUI()
object_list = ObjectList(values=[ListItem(value=str(i ** 2)) for i in range(10)])
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=simple_view)
gui.process_events()
press_ok_button(ui)
gui.process_events()
def setUpClass(cls):
app = QtGui.QApplication.instance() or QtGui.QApplication([])
person_view = View(body_html=body_html)
fred = Person(name='Fred', age=42)
person_view.show(model=fred)
GUI.process_events()
cls.person_view = person_view
cls.fred = fred
cls.app = app
def test_table_editor(self):
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
with store_exceptions_on_all_threads(), \
create_ui(object_list, dict(view=simple_view)) as ui:
gui.process_events()
press_ok_button(ui)
gui.process_events()
def test_table_editor():
gui = GUI()
object_list = ObjectList(
values=[ListItem(value=str(i**2)) for i in range(10)])
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=simple_view)
gui.process_events()
press_ok_button(ui)
gui.process_events()
def test_tabular_editor_multi_selection(self):
gui = GUI()
view = get_view(multi_select=True)
with store_exceptions_on_all_threads(), \
self.report_and_editor(view) as (report, editor):
gui.process_events()
people = report.people
self.assertEqual(report.selected_rows, [])
self.assertEqual(report.multi_selected, [])
set_selected_multiple(editor, [0, 1])
gui.process_events()
self.assertEqual(report.selected_rows, [0, 1])
self.assertEqual(report.multi_selected, people[:2])
set_selected_multiple(editor, [2])
gui.process_events()
self.assertEqual(report.selected_rows, [2])
self.assertEqual(report.multi_selected, [people[2]])
clear_selection(editor)
gui.process_events()
self.assertEqual(report.selected_rows, [])
self.assertEqual(report.multi_selected, [])
def test_filtered_table_editor():
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=filtered_view)
gui.process_events()
filter = ui.get_editors("values")[0].filter
press_ok_button(ui)
gui.process_events()
assert filter is not None
def setup_gui(self, model, view):
gui = GUI()
ui = model.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor = ui.get_editors("value")[0]
line_edit = editor.control
# FIXME issue enthought/traitsui#851
if is_current_backend_wx():
import wx
self.addCleanup(line_edit.Unbind, wx.EVT_KILL_FOCUS)
return gui, editor, line_edit
def test_filtered_table_editor(self):
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
with store_exceptions_on_all_threads(), \
create_ui(object_list, dict(view=filtered_view)) as ui:
gui.process_events()
filter = ui.get_editors("values")[0].filter
press_ok_button(ui)
gui.process_events()
self.assertIsNotNone(filter)
def check_button_text_update(self, view):
gui = GUI()
button_text_edit = ButtonTextEdit()
with store_exceptions_on_all_threads():
ui = button_text_edit.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor, = ui.get_editors("play_button")
button = editor.control
self.assertEqual(get_button_text(button), "I'm a play button")
button_text_edit.play_button_label = "New Label"
self.assertEqual(get_button_text(button), "New Label")
def test_filtered_table_editor():
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)]
)
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=filtered_view)
gui.process_events()
filter = ui.get_editors('values')[0].filter
press_ok_button(ui)
gui.process_events()
assert filter is not None
def check_button_text_update(self, view):
gui = GUI()
button_text_edit = ButtonTextEdit()
with store_exceptions_on_all_threads():
ui = button_text_edit.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor, = ui.get_editors("play_button")
button = editor.control
self.assertEqual(get_button_text(button), "I'm a play button")
button_text_edit.play_button_label = "New Label"
self.assertEqual(get_button_text(button), "New Label")
def test_list_str_editor_item_count(self):
gui = GUI()
model = ListStrModel()
# Without auto_add
with store_exceptions_on_all_threads(), \
create_ui(model, dict(view=get_view())) as ui:
gui.process_events()
editor = ui.get_editors("value")[0]
self.assertEqual(editor.item_count, 3)
# With auto_add
with store_exceptions_on_all_threads(), \
create_ui(model, dict(view=get_view(auto_add=True))) as ui:
gui.process_events()
editor = ui.get_editors("value")[0]
self.assertEqual(editor.item_count, 3)
def check_enum_text_update(self, view):
gui = GUI()
enum_edit = EnumModel()
with store_exceptions_on_all_threads():
ui = enum_edit.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor = ui.get_editors("value")[0]
combobox = editor.control
self.assertEqual(get_combobox_text(combobox), "one")
enum_edit.value = "two"
gui.process_events()
self.assertEqual(get_combobox_text(combobox), "two")
def check_enum_text_update(self, view):
gui = GUI()
enum_edit = EnumModel()
with store_exceptions_on_all_threads():
ui = enum_edit.edit_traits(view=view)
self.addCleanup(ui.dispose)
gui.process_events()
editor = ui.get_editors("value")[0]
combobox = editor.control
self.assertEqual(get_combobox_text(combobox), "one")
enum_edit.value = "two"
gui.process_events()
self.assertEqual(get_combobox_text(combobox), "two")
def test_table_editor_select_cell_indices():
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
object_list.selected_cell_indices = [(5, 0), (6, 1), (8, 0)]
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=select_cell_indices_view)
editor = ui.get_editors("values")[0]
gui.process_events()
if is_current_backend_qt4():
selected = editor.selected_indices
elif is_current_backend_wx():
selected = editor.selected_cell_indices
press_ok_button(ui)
gui.process_events()
assert selected == [(5, 0), (6, 1), (8, 0)]
def test_table_editor_select_row_index(self):
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)])
object_list.selected_index = 5
with store_exceptions_on_all_threads(), \
create_ui(object_list, dict(view=select_row_index_view)) as ui:
editor = ui.get_editors("values")[0]
gui.process_events()
if is_current_backend_qt4():
selected = editor.selected_indices
elif is_current_backend_wx():
selected = editor.selected_row_index
press_ok_button(ui)
gui.process_events()
self.assertEqual(selected, 5)
def test_table_editor_select_column_index():
gui = GUI()
object_list = ObjectListWithSelection(
values=[ListItem(value=str(i**2)) for i in range(10)]
)
object_list.selected_index = 1
with store_exceptions_on_all_threads():
ui = object_list.edit_traits(view=select_column_index_view)
editor = ui.get_editors('values')[0]
gui.process_events()
if is_current_backend_qt4():
selected = editor.selected_indices
elif is_current_backend_wx():
selected = editor.selected_column_index
press_ok_button(ui)
gui.process_events()
assert selected == 1
def test_progress_column(self):
from traitsui.extras.progress_column import ProgressColumn
progress_view = View(
Item(
"values",
show_label=False,
editor=TableEditor(columns=[
ObjectColumn(name="value"),
ProgressColumn(name="other_value"),
]),
),
buttons=["OK"],
)
gui = GUI()
object_list = ObjectList(
values=[ListItem(value=str(i**2)) for i in range(10)])
with store_exceptions_on_all_threads(), \
create_ui(object_list, dict(view=progress_view)) as ui:
gui.process_events()
press_ok_button(ui)
gui.process_events()
def test_tabular_editor_multi_selection_changed(self):
gui = GUI()
view = get_view(multi_select=True)
with store_exceptions_on_all_threads(), \
self.report_and_editor(view) as (report, editor):
gui.process_events()
people = report.people
self.assertEqual(get_selected_rows(editor), [])
report.selected_rows = [0, 1]
gui.process_events()
self.assertEqual(get_selected_rows(editor), [0, 1])
self.assertEqual(report.multi_selected, people[:2])
report.multi_selected = [people[2], people[0]]
gui.process_events()
self.assertEqual(sorted(get_selected_rows(editor)), [0, 2])
self.assertEqual(sorted(report.selected_rows), [0, 2])
# If there's a single invalid value, nothing is updated
invalid_person = Person(name="invalid", age=-1)
report.multi_selected = [people[2], invalid_person]
gui.process_events()
self.assertEqual(sorted(get_selected_rows(editor)), [0, 2])
self.assertEqual(sorted(report.selected_rows), [0, 2])
# Empty list clears selection
report.selected_rows = []
gui.process_events()
self.assertEqual(get_selected_rows(editor), [])
self.assertEqual(report.multi_selected, [])
def test_tabular_editor_single_selection(self):
gui = GUI()
with store_exceptions_on_all_threads(), \
self.report_and_editor(get_view()) as (report, editor):
gui.process_events()
people = report.people
self.assertEqual(report.selected_row, -1)
self.assertIsNone(report.selected)
set_selected_single(editor, 1)
gui.process_events()
self.assertEqual(report.selected_row, 1)
self.assertEqual(report.selected, people[1])
set_selected_single(editor, 2)
gui.process_events()
self.assertEqual(report.selected_row, 2)
self.assertEqual(report.selected, people[2])
class TestFieldAction(unittest.TestCase):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
def _destroy_parent(self):
self.parent.destroy()
self.parent = None
def test_combo_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=ComboField,
field_defaults={
'values': ['a', 'b', 'c'],
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_text_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=TextField,
field_defaults={
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_spin_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=SpinField,
field_defaults={
'value': 1,
'bounds': (0, 100),
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 5
self.gui.process_events()
self.assertEqual(memo, [5])
finally:
control._field.destroy()
class DockPaneToggleGroupTestCase(unittest.TestCase):
@unittest.skipIf(USING_WX, "TaskWindowBackend is not implemented in WX")
def setUp(self):
self.gui = GUI()
# Set up the bogus task with its window.
self.task = BogusTask()
self.window = window = TaskWindow()
window.add_task(self.task)
self.task_state = window._get_state(self.task)
# Fish the dock pane toggle group from the menu bar manager.
dock_pane_toggle_group = []
def find_doc_pane_toggle(item):
if item.id == "tests.bogus_task.DockPaneToggleGroup":
dock_pane_toggle_group.append(item)
self.task_state.menu_bar_manager.walk(find_doc_pane_toggle)
self.dock_pane_toggle_group = dock_pane_toggle_group[0]
def tearDown(self):
del self.task
del self.task_state
del self.dock_pane_toggle_group
if self.window.control is not None:
self.window.destroy()
self.gui.process_events()
del self.window
del self.gui
def get_dock_pane_toggle_action_names(self):
names = [
action_item.action.name
for action_item in self.dock_pane_toggle_group.items
]
return names
# Tests ----------------------------------------------------------------
def test_group_content_at_startup(self):
# Check that there are 2 dock panes in the group at the beginning.
self.assertEqual(2, len(self.dock_pane_toggle_group.items))
# Names are sorted by the group.
names = self.get_dock_pane_toggle_action_names()
expected_names = ["Dock Pane 1", "Dock Pane 2"]
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
def test_react_to_dock_pane_added(self):
# Add a dock pane to the task.
self.task_state.dock_panes.append(
DockPane(id="tests.bogus_task.dock_pane_0", name="Dock Pane 0")
)
# Check that there are 3 dock panes in the group.
self.assertEqual(3, len(self.dock_pane_toggle_group.items))
# Names are sorted by the group.
names = self.get_dock_pane_toggle_action_names()
expected_names = ["Dock Pane 0", "Dock Pane 1", "Dock Pane 2"]
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
def test_react_to_dock_pane_removed(self):
# Remove a dock pane from the task.
self.task_state.dock_panes.remove(self.task.dock_panes[0])
# Check that there is only 1 dock pane left in the group.
self.assertEqual(1, len(self.dock_pane_toggle_group.items))
names = self.get_dock_pane_toggle_action_names()
expected_names = ["Dock Pane 1"]
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(Item('value'))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'b')
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item('value'))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum('a', 'b', 'c')
view = View(
HGroup(
Item('value'),
Item('action.value'),
)
)
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors('value')[0]
with self.assertTraitChanges(model, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == 'wx':
import wx
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('b')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, 'b')
editor = control._ui.get_editors('value')[1]
with self.assertTraitChanges(action, 'value', count=1):
if toolkit.toolkit in {'qt', 'qt4'}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == 'wx':
event = wx.CommandEvent(wx.EVT_CHOICE.typeId,
editor.control.GetId())
event.SetString('c')
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, 'c')
class TestWindow(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.window = SplashScreen()
def test_destroy(self):
# test that destroy works even when no control
self.window.destroy()
def test_open_close(self):
# test that opening and closing works as expected
with self.assertTraitChanges(self.window, 'opening', count=1):
with self.assertTraitChanges(self.window, 'opened', count=1):
self.window.open()
self.gui.process_events()
with self.assertTraitChanges(self.window, 'closing', count=1):
with self.assertTraitChanges(self.window, 'closed', count=1):
self.window.close()
self.gui.process_events()
def test_show(self):
# test that show works as expected
self.window._create()
self.window.show(True)
self.gui.process_events()
self.window.show(False)
self.gui.process_events()
self.window.destroy()
def test_image(self):
# test that images work
self.window.image = ImageResource('core')
with self.assertTraitChanges(self.window, 'opening', count=1):
with self.assertTraitChanges(self.window, 'opened', count=1):
self.window.open()
self.gui.process_events()
with self.assertTraitChanges(self.window, 'closing', count=1):
with self.assertTraitChanges(self.window, 'closed', count=1):
self.window.close()
self.gui.process_events()
def test_text(self):
# test that images work
self.window.text = "Splash screen"
with self.assertTraitChanges(self.window, 'opening', count=1):
with self.assertTraitChanges(self.window, 'opened', count=1):
self.window.open()
self.gui.process_events()
with self.assertTraitChanges(self.window, 'closing', count=1):
with self.assertTraitChanges(self.window, 'closed', count=1):
self.window.close()
self.gui.process_events()
def test_text_changed(self):
# test that images work
# XXX this throws a non-failing exception on wx
# - probably the way the test is written.
with self.assertTraitChanges(self.window, 'opening', count=1):
with self.assertTraitChanges(self.window, 'opened', count=1):
self.window.open()
self.gui.process_events()
self.window.text = "Splash screen"
self.gui.process_events()
with self.assertTraitChanges(self.window, 'closing', count=1):
with self.assertTraitChanges(self.window, 'closed', count=1):
self.window.close()
self.gui.process_events()
class TestDialog(unittest.TestCase):
def setUp(self):
self.gui = GUI()
self.dialog = ProgressDialog()
def test_create(self):
# test that creation and destruction works as expected
self.dialog._create()
self.gui.process_events()
self.assertIsNotNone(self.dialog.control)
self.assertIsNotNone(self.dialog.progress_bar)
self.assertIsNotNone(self.dialog._message_control)
self.assertIsNone(self.dialog._elapsed_control)
self.assertIsNone(self.dialog._estimated_control)
self.assertIsNone(self.dialog._remaining_control)
self.dialog.destroy()
def test_show_time(self):
# test that creation works with show_time
self.dialog.show_time = True
self.dialog._create()
self.gui.process_events()
self.assertIsNotNone(self.dialog._elapsed_control)
self.assertIsNotNone(self.dialog._estimated_control)
self.assertIsNotNone(self.dialog._remaining_control)
self.dialog.destroy()
def test_show_percent(self):
# test that creation works with show_percent
self.dialog.show_percent = True
self.dialog._create()
self.gui.process_events()
self.assertEqual(self.dialog.progress_bar.format(), "%p%")
self.dialog.destroy()
def test_update(self):
self.dialog.min = 0
self.dialog.max = 10
self.dialog.open()
for i in range(11):
result = self.dialog.update(i)
self.gui.process_events()
self.assertEqual(result, (True, False))
if i < 10:
self.assertEqual(self.dialog.progress_bar.value(), i)
self.assertIsNone(self.dialog.control)
def test_update_no_control(self):
# note: inconsistent implementation with Wx
self.dialog.min = 0
self.dialog.max = 10
result = self.dialog.update(1)
self.assertEqual(result, (None, None))
def test_change_message(self):
self.dialog.min = 0
self.dialog.max = 10
self.dialog.open()
for i in range(11):
self.dialog.change_message('Updating {}'.format(i))
result = self.dialog.update(i)
self.gui.process_events()
self.assertEqual(result, (True, False))
self.assertEqual(self.dialog.message, 'Updating {}'.format(i))
self.assertEqual(self.dialog._message_control.text(),
'Updating {}'.format(i))
self.assertIsNone(self.dialog.control)
def test_change_message_trait(self):
self.dialog.min = 0
self.dialog.max = 10
self.dialog.open()
for i in range(11):
self.dialog.message = 'Updating {}'.format(i)
result = self.dialog.update(i)
self.gui.process_events()
self.assertEqual(result, (True, False))
self.assertEqual(self.dialog.message, 'Updating {}'.format(i))
self.assertEqual(self.dialog._message_control.text(),
'Updating {}'.format(i))
self.assertIsNone(self.dialog.control)
def test_update_show_time(self):
self.dialog.min = 0
self.dialog.max = 10
self.dialog.show_time = True
self.dialog.open()
for i in range(11):
result = self.dialog.update(i)
self.gui.process_events()
self.assertEqual(result, (True, False))
self.assertNotEqual(self.dialog._elapsed_control.text(), "")
self.assertNotEqual(self.dialog._estimated_control.text(), "")
self.assertNotEqual(self.dialog._remaining_control.text(), "")
self.assertIsNone(self.dialog.control)
class TestTraitsUIWidgetAction(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.parent.open()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def create_model(self):
from traitsui.api import View, Item
class SimpleEnum(HasTraits):
value = Enum("a", "b", "c")
view = View(Item("value"))
return SimpleEnum()
def test_traitsui_widget_action(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(Item("value"))
action = SimpleEnumAction(name="Simple")
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "b")
def test_traitsui_widget_action_model(self):
from traitsui.api import View, Item
class SimpleEnumAction(TraitsUIWidgetAction):
view = View(Item("value"))
model = self.create_model()
action = SimpleEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
def test_traitsui_widget_action_model_view(self):
from traitsui.api import HGroup, View, Item
class ComplexEnumAction(TraitsUIWidgetAction):
value = Enum("a", "b", "c")
view = View(HGroup(Item("value"), Item("action.value")))
model = self.create_model()
action = ComplexEnumAction(name="Simple", model=model)
control = action.create_control(self.parent.control)
self.gui.process_events()
editor = control._ui.get_editors("value")[0]
with self.assertTraitChanges(model, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(1)
editor.control.activated.emit(1)
elif toolkit.toolkit == "wx":
import wx
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("b")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(model.value, "b")
editor = control._ui.get_editors("value")[1]
with self.assertTraitChanges(action, "value", count=1):
if toolkit.toolkit in {"qt", "qt4"}:
editor.control.setCurrentIndex(2)
editor.control.activated.emit(2)
elif toolkit.toolkit == "wx":
event = wx.CommandEvent(
wx.EVT_CHOICE.typeId, editor.control.GetId()
)
event.SetString("c")
wx.PostEvent(editor.control.GetEventHandler(), event)
else:
self.skipTest("Unknown toolkit")
self.gui.process_events()
self.assertEqual(action.value, "c")
def execute_js(self, js):
GUI.process_events()
result = self.bridge.widget.execute_js(js)
GUI.process_events()
return result
class WidgetMixin(UnittestTools):
""" Mixin which provides standard methods for all widgets. """
def setUp(self):
self.gui = GUI()
self.parent = self._create_parent()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_parent(self):
return Window()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_widget_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_widget_tooltip_cleanup(self):
widget = self._create_widget()
with patch.object(widget, '_tooltip_updated',
return_value=None) as updated:
widget._create()
try:
widget.show(True)
self.gui.process_events()
finally:
widget.destroy()
self.gui.process_events()
widget.tooltip = "New tooltip."
updated.assert_not_called()
widget = None
def test_widget_menu(self):
self._create_widget_control()
self.widget.context_menu = MenuManager(Action(name="Test"),
name="Test")
self.gui.process_events()
def test_widget_context_menu_cleanup(self):
widget = self._create_widget()
with patch.object(widget, '_context_menu_updated',
return_value=None) as updated:
widget._create()
try:
widget.show(True)
self.gui.process_events()
finally:
widget.destroy()
self.gui.process_events()
widget.context_menu = MenuManager(Action(name="Test"), name="Test")
updated.assert_not_called()
widget = None
class ScrollBarTest(unittest.TestCase):
def setUp(self):
if NativeScrollBar is None:
raise unittest.SkipTest("Qt4 NativeScrollbar not available.")
self.gui = GUI()
self.container = Container(position=[0, 0], bounds=[600, 600])
self.window = Window(None, size=(600, 600), component=self.container)
@contextmanager
def setup_window(self, window):
window.control.show()
window._size = window._get_control_size()
self.gui.process_events()
try:
yield
finally:
window.control.destroy()
@contextmanager
def setup_scrollbar(self, scrollbar, window):
scrollbar._draw_mainlayer(window._gc)
try:
yield
finally:
scrollbar.destroy()
def test_scroll_position_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='horizontal',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 0)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 200)
def test_scroll_position_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='vertical',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 600-375)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 600-375-100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 600-375-200)
def test_minumum_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='horizontal',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 100)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar
scrollbar._control.setValue(200)
self.assertEqual(scrollbar.scroll_position, 200)
# set the scroll & redraw
scrollbar.scroll_position = 300
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 300)
def test_minimum_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='vertical',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
# control should be at top
self.assertEqual(scrollbar._control.value(), 700-375)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar to the bottom
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 700-375)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 700-375-(200-100))
class TestFieldAction(unittest.TestCase):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
def _destroy_parent(self):
self.parent.destroy()
self.parent = None
def test_combo_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=ComboField,
field_defaults={
'values': ['a', 'b', 'c'],
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_text_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=TextField,
field_defaults={
'value': 'a',
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 'b'
self.gui.process_events()
self.assertEqual(memo, ['b'])
finally:
control._field.destroy()
def test_spin_field_action(self):
# test whether function is called by updating list
# XXX should really use mock
memo = []
def perform(value):
memo.append(value)
action = FieldAction(
name="Dummy",
field_type=SpinField,
field_defaults={
'value': 1,
'bounds': (0, 100),
'tooltip': 'Dummy',
},
on_perform=perform,
)
control = action.create_control(self.parent.control)
try:
self.gui.process_events()
control._field.value = 5
self.gui.process_events()
self.assertEqual(memo, [5])
finally:
control._field.destroy()
class ScrollBarTest(unittest.TestCase):
def setUp(self):
from pyface.qt.QtGui import QApplication
from pyface.ui.qt4.util.event_loop_helper import EventLoopHelper
qt_app = QApplication.instance()
if qt_app is None:
qt_app = QApplication([])
self.qt_app = qt_app
if NativeScrollBar is None:
raise unittest.SkipTest("Qt4 NativeScrollbar not available.")
self.gui = GUI()
self.event_loop_helper = EventLoopHelper(gui=self.gui, qt_app=qt_app)
self.container = Container(position=[0, 0], bounds=[600, 600])
self.window = Window(None, size=(600, 600), component=self.container)
@contextmanager
def setup_window(self, window):
window.control.show()
window._size = window._get_control_size()
self.gui.process_events()
try:
yield
finally:
self.gui.process_events()
with self.event_loop_helper.delete_widget(window.control, timeout=1.0):
window.control.deleteLater()
@contextmanager
def setup_scrollbar(self, scrollbar, window):
scrollbar._draw_mainlayer(window._gc)
try:
yield
finally:
scrollbar.destroy()
def test_scroll_position_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(orientation="horizontal", bounds=bounds, position=position, range=range)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 0)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 200)
def test_scroll_position_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(orientation="vertical", bounds=bounds, position=position, range=range)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 600 - 375)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 600 - 375 - 100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 600 - 375 - 200)
def test_minumum_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(orientation="horizontal", bounds=bounds, position=position, range=range)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 100)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar
scrollbar._control.setValue(200)
self.assertEqual(scrollbar.scroll_position, 200)
# set the scroll & redraw
scrollbar.scroll_position = 300
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 300)
def test_minimum_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(orientation="vertical", bounds=bounds, position=position, range=range)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
# control should be at top
self.assertEqual(scrollbar._control.value(), 700 - 375)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar to the bottom
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 700 - 375)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 700 - 375 - (200 - 100))
class TestWidget(unittest.TestCase, UnittestTools):
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
self.data = np.arange(120.0).reshape(4, 5, 6)
self.model = ArrayDataModel(data=self.data, value_type=FloatValue())
return DataViewWidget(parent=self.parent.control,
data_model=self.model)
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.parent.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
def test_defaults(self):
self.assertTrue(self.widget.header_visible)
def test_lifecycle(self):
self._create_widget_control()
def test_header_visible(self):
self._create_widget_control()
self.assertTrue(self.widget._get_control_header_visible())
self.widget.header_visible = False
self.gui.process_events()
self.assertFalse(self.widget._get_control_header_visible())
def test_header_visible_before_control(self):
self.widget.header_visible = False
self._create_widget_control()
self.assertFalse(self.widget._get_control_header_visible())
def test_init_selection(self):
self.widget.selection = [((1, ), ())]
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection(), [((1, ), ())])
def test_selection_mode_change(self):
self._create_widget_control()
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.widget.selection_mode = "single"
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.assertEqual(self.widget.selection, [])
self.widget.selection = [((1, 4), ())]
if "none" in selection_modes:
self.widget.selection_mode = "none"
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.assertEqual(self.widget.selection, [])
self.widget.selection_mode = "extended"
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
len(selection_types) <= 1,
"Changing selection types not supported",
)
def test_selection_type_change(self):
self._create_widget_control()
if "column" in selection_types:
self.widget.selection_type = "column"
self.assertEqual(
self.widget._get_control_selection_type(),
"column",
)
self.assertEqual(self.widget.selection, [])
if "item" in selection_types:
self.widget.selection_type = "item"
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.assertEqual(self.widget.selection, [])
if "row" in selection_types:
self.widget.selection_type = "row"
self.assertEqual(self.widget._get_control_selection_type(), "row")
self.assertEqual(self.widget.selection, [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none(self):
self.widget.selection_mode = "none"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "none")
self.widget.selection = []
self.gui.process_events()
self.assertEqual(self.widget.selection, [])
self.assertEqual(self.widget._get_control_selection(), [])
@unittest.skipIf(
"none" not in selection_modes,
"Selection mode 'none' not supported",
)
def test_selection_mode_none_invalid(self):
self.widget.selection_mode = "none"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
def test_selection_mode_single(self):
self.widget.selection_mode = "single"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "single")
self.widget.selection = [((1, 4), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(self.widget._get_control_selection(), [((1, 4), ())])
def test_selection_mode_single_invalid(self):
self.widget.selection_mode = "single"
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4), ()), (2, 1), ()]
@unittest.skipIf(
is_wx and is_linux,
"Selection mode 'extended' not working on Linux",
)
def test_selection_mode_extended(self):
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_mode(), "extended")
self.widget.selection = [((1, 4), ()), ((2, 0), ())]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ()), ((2, 0), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ()), ((2, 0), ())],
)
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column(self):
self.widget.selection_type = "column"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "column")
self.widget.selection = [((0, ), (2, )), ((1, ), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((0, ), (2, )),
((1, ), (4, ))])
self.assertEqual(self.widget._get_control_selection(),
[((0, ), (2, )), ((1, ), (4, ))])
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'item' not supported",
)
def test_selection_type_item(self):
self.widget.selection_type = "item"
self._create_widget_control()
self.assertEqual(self.widget._get_control_selection_type(), "item")
self.widget.selection = [((1, 4), (2, )), ((2, 0), (4, ))]
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), (2, )),
((2, 0), (4, ))])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), (2, )), ((2, 0), (4, ))],
)
def test_selection_type_row_invalid_row_big(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), ())]
def test_selection_type_row_invalid_row_long(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 1, 1), ())]
def test_selection_type_row_invalid_column(self):
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_big(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 10), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_row_too_long(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'item' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_item_invalid_column(self):
self.widget.selection_type = 'item'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (10, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_long(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 4, 5, 6), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_too_big(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((10, ), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_row_not_parent(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((1, 2), (2, ))]
@unittest.skipIf(
'column' not in selection_types,
"Selection type 'column' not supported",
)
def test_selection_type_column_invalid_column(self):
self.widget.selection_type = 'column'
self._create_widget_control()
with self.assertRaises(TraitError):
self.widget.selection = [((), (10, ))]
def test_selection_updated(self):
self._create_widget_control()
with self.assertTraitChanges(self.widget, 'selection'):
self.widget._set_control_selection([((1, 4), ())])
self.gui.process_events()
self.assertEqual(self.widget.selection, [((1, 4), ())])
self.assertEqual(
self.widget._get_control_selection(),
[((1, 4), ())],
)
def test_selection_updating_context_manager(self):
self.assertFalse(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
with self.widget._selection_updating():
self.assertTrue(self.widget._selection_updating_flag)
self.assertTrue(self.widget._selection_updating_flag)
self.assertFalse(self.widget._selection_updating_flag)
def test_selection_updating_context_manager_exception(self):
with self.assertRaises(ZeroDivisionError):
with self.widget._selection_updating():
with self.widget._selection_updating():
1 / 0
self.assertFalse(self.widget._selection_updating_flag)
class ScrollBarTest(unittest.TestCase):
def setUp(self):
from pyface.qt.QtGui import QApplication
from pyface.ui.qt4.util.event_loop_helper import EventLoopHelper
qt_app = QApplication.instance()
if qt_app is None:
qt_app = QApplication([])
self.qt_app = qt_app
if NativeScrollBar is None:
raise unittest.SkipTest("Qt4 NativeScrollbar not available.")
self.gui = GUI()
self.event_loop_helper = EventLoopHelper(gui=self.gui, qt_app=qt_app)
self.container = Container(position=[0, 0], bounds=[600, 600])
self.window = Window(None, size=(600, 600), component=self.container)
@contextmanager
def setup_window(self, window):
window.control.show()
window._size = window._get_control_size()
self.gui.process_events()
try:
yield
finally:
self.gui.process_events()
with self.event_loop_helper.delete_widget(window.control,
timeout=1.0):
window.control.deleteLater()
@contextmanager
def setup_scrollbar(self, scrollbar, window):
scrollbar._draw_mainlayer(window._gc)
try:
yield
finally:
scrollbar.destroy()
def test_scroll_position_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='horizontal',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 0)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 200)
def test_scroll_position_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [600, 0.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='vertical',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 600 - 375)
self.assertEqual(scrollbar.scroll_position, 0)
# move the scrollbar
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 600 - 375 - 100)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 600 - 375 - 200)
def test_minumum_horizontal(self):
bounds = [600.0, 30.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='horizontal',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
self.assertEqual(scrollbar._control.value(), 100)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar
scrollbar._control.setValue(200)
self.assertEqual(scrollbar.scroll_position, 200)
# set the scroll & redraw
scrollbar.scroll_position = 300
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(), 300)
def test_minimum_vertical(self):
bounds = [30.0, 600.0]
position = [0.0, 0.0]
range = [700, 100.0, 375.0, 20.454545454545453]
scrollbar = NativeScrollBar(
orientation='vertical',
bounds=bounds,
position=position,
range=range,
)
self.container.add(scrollbar)
with self.setup_window(self.window):
with self.setup_scrollbar(scrollbar, self.window):
# control should be at top
self.assertEqual(scrollbar._control.value(), 700 - 375)
self.assertEqual(scrollbar.scroll_position, 100)
# move the scrollbar to the bottom
scrollbar._control.setValue(100)
self.assertEqual(scrollbar.scroll_position, 700 - 375)
# set the scroll & redraw
scrollbar.scroll_position = 200
scrollbar._draw_mainlayer(self, self.window._gc)
self.assertEqual(scrollbar._control.value(),
700 - 375 - (200 - 100))
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name="Test"), name="Test")
self.gui.process_events()
class DockPaneToggleGroupTestCase(unittest.TestCase):
@unittest.skipIf(USING_WX, "TaskWindowBackend is not implemented in WX")
def setUp(self):
self.gui = GUI()
# Set up the bogus task with its window.
self.task = BogusTask()
self.window = window = TaskWindow()
window.add_task(self.task)
self.task_state = window._get_state(self.task)
# Fish the dock pane toggle group from the menu bar manager.
dock_pane_toggle_group = []
def find_doc_pane_toggle(item):
if item.id == 'tests.bogus_task.DockPaneToggleGroup':
dock_pane_toggle_group.append(item)
self.task_state.menu_bar_manager.walk(find_doc_pane_toggle)
self.dock_pane_toggle_group = dock_pane_toggle_group[0]
def tearDown(self):
del self.task
del self.task_state
del self.dock_pane_toggle_group
if self.window.control is not None:
self.window.destroy()
self.gui.process_events()
del self.window
del self.gui
def get_dock_pane_toggle_action_names(self):
names = [
action_item.action.name
for action_item in self.dock_pane_toggle_group.items
]
return names
#### Tests ################################################################
def test_group_content_at_startup(self):
# Check that there are 2 dock panes in the group at the beginning.
self.assertEqual(2, len(self.dock_pane_toggle_group.items))
# Names are sorted by the group.
names = self.get_dock_pane_toggle_action_names()
expected_names = ['Dock Pane 1', 'Dock Pane 2']
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
def test_react_to_dock_pane_added(self):
# Add a dock pane to the task.
self.task_state.dock_panes.append(
DockPane(id='tests.bogus_task.dock_pane_0', name='Dock Pane 0')
)
# Check that there are 3 dock panes in the group.
self.assertEqual(3, len(self.dock_pane_toggle_group.items))
# Names are sorted by the group.
names = self.get_dock_pane_toggle_action_names()
expected_names = ['Dock Pane 0', 'Dock Pane 1', 'Dock Pane 2']
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
def test_react_to_dock_pane_removed(self):
# Remove a dock pane from the task.
self.task_state.dock_panes.remove(self.task.dock_panes[0])
# Check that there is only 1 dock pane left in the group.
self.assertEqual(1, len(self.dock_pane_toggle_group.items))
names = self.get_dock_pane_toggle_action_names()
expected_names = ['Dock Pane 1']
self.assertEqual(list(sorted(expected_names)), list(sorted(names)))
class FieldMixin(UnittestTools):
""" Mixin which provides standard methods for all fields. """
def setUp(self):
self.gui = GUI()
self.parent = Window()
self.parent._create()
self.addCleanup(self._destroy_parent)
self.gui.process_events()
self.widget = self._create_widget()
self.parent.open()
self.gui.process_events()
def _create_widget(self):
raise NotImplementedError()
def _create_widget_control(self):
self.widget._create()
self.addCleanup(self._destroy_widget)
self.widget.show(True)
self.gui.process_events()
def _destroy_parent(self):
self.parent.destroy()
self.gui.process_events()
self.parent = None
def _destroy_widget(self):
self.widget.destroy()
self.gui.process_events()
self.widget = None
# Tests ------------------------------------------------------------------
def test_field_tooltip(self):
self._create_widget_control()
self.widget.tooltip = "New tooltip."
self.gui.process_events()
self.assertEqual(self.widget._get_control_tooltip(), "New tooltip.")
def test_field_menu(self):
self._create_widget_control()
self.widget.menu = MenuManager(Action(name='Test'), name='Test')
self.gui.process_events()
