class KeywordEditor(with_metaclass(classmaker(), GridEditor,
RideEventHandler)):
_no_cell = (-1, -1)
_popup_menu_shown = False
dirty = property(lambda self: self._controller.dirty)
update_value = lambda *args: None
_popup_items = [
'Create Keyword', 'Extract Keyword', 'Extract Variable',
'Rename Keyword', 'Find Where Used', 'JSON Editor\tCtrl-Shift-J',
'---', 'Make Variable\tCtrl-1', 'Make List Variable\tCtrl-2',
'Make Dict Variable\tCtrl-5', '---', 'Go to Definition\tCtrl-B', '---'
] + GridEditor._popup_items
def __init__(self, parent, controller, tree):
GridEditor.__init__(self, parent,
len(controller.steps) + 5,
max((controller.max_columns + 1), 5),
parent.plugin._grid_popup_creator)
self.settings = parent.plugin.global_settings['Grid']
self._parent = parent
self._plugin = parent.plugin
self._cell_selected = False
self._colorizer = Colorizer(self, controller)
self._controller = controller
self._configure_grid()
self._updating_namespace = False
self._controller.datafile_controller.register_for_namespace_updates(
self._namespace_updated)
self._tooltips = GridToolTips(self)
self._marked_cell = None
self._make_bindings()
self._write_steps(self._controller)
self.autosize()
self._tree = tree
self._has_been_clicked = False
self._counter = 0 # Workaround for double delete actions
self._dcells = None # Workaround for double delete actions
self._icells = None # Workaround for double insert actions
PUBLISHER.subscribe(self._before_saving, RideBeforeSaving)
PUBLISHER.subscribe(self._data_changed, RideItemStepsChanged)
PUBLISHER.subscribe(self.OnSettingsChanged, RideSettingsChanged)
PUBLISHER.subscribe(self._resize_grid, RideSaved)
def _namespace_updated(self):
if not self._updating_namespace:
self._updating_namespace = True
# See following issue for history of the next line:
# http://code.google.com/p/robotframework-ride/issues/detail?id=1108
wx.CallAfter(wx.CallLater, 200,
self._update_based_on_namespace_change)
def _update_based_on_namespace_change(self):
try:
self._colorize_grid()
finally:
self._updating_namespace = False
@requires_focus
def _resize_grid(self, event=None):
if self.settings.get("auto size cols", True):
self.AutoSizeColumns(False)
if self.settings.get("word wrap", True):
self.AutoSizeRows(False)
def _set_cells(self):
col_size = self.settings.get("col size", 150)
max_col_size = self.settings.get("max col size", 450)
auto_col_size = self.settings.get("auto size cols", False)
word_wrap = self.settings.get("word wrap", True)
self.SetDefaultRenderer(
CellRenderer(col_size, max_col_size, auto_col_size, word_wrap))
self.SetRowLabelSize(wx.grid.GRID_AUTOSIZE)
self.SetColLabelSize(0)
if auto_col_size:
self.SetDefaultColSize(wx.grid.GRID_AUTOSIZE,
resizeExistingCols=True)
else:
self.SetDefaultColSize(col_size, resizeExistingCols=True)
self.SetColMinimalAcceptableWidth(col_size)
if auto_col_size:
self.Bind(grid.EVT_GRID_CMD_COL_SIZE, self.OnCellColSizeChanged)
else:
self.Unbind(grid.EVT_GRID_CMD_COL_SIZE)
if word_wrap:
self.SetDefaultRowSize(wx.grid.GRID_AUTOSIZE)
self.SetDefaultCellOverflow(False) # DEBUG
def _configure_grid(self):
self._set_cells()
self.SetDefaultEditor(
ContentAssistCellEditor(self._plugin, self._controller))
self._set_fonts()
def _set_fonts(self, update_cells=False):
font_size = self.settings.get('font size', _DEFAULT_FONT_SIZE)
font_family = wx.FONTFAMILY_MODERN if self.settings['fixed font'] \
else wx.FONTFAMILY_DEFAULT
font_face = self.settings.get('font face', None)
if font_face is None:
font = wx.Font(font_size, font_family, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL)
self.settings.set('font face', font.GetFaceName())
else:
font = wx.Font(font_size, font_family, wx.FONTSTYLE_NORMAL,
wx.FONTWEIGHT_NORMAL, False, font_face)
self.SetDefaultCellFont(font)
for row in range(self.NumberRows):
for col in range(self.NumberCols):
self.SetCellFont(row, col, font)
self.ForceRefresh()
def _make_bindings(self):
self.Bind(grid.EVT_GRID_EDITOR_SHOWN, self.OnEditor)
self.Bind(wx.EVT_KEY_DOWN, self.OnKeyDown)
self.Bind(wx.EVT_CHAR, self.OnChar)
self.Bind(wx.EVT_KEY_UP, self.OnKeyUp)
self.Bind(grid.EVT_GRID_CELL_LEFT_CLICK, self.OnCellLeftClick)
self.Bind(grid.EVT_GRID_CELL_LEFT_DCLICK, self.OnCellLeftDClick)
self.Bind(grid.EVT_GRID_LABEL_RIGHT_CLICK, self.OnLabelRightClick)
self.Bind(grid.EVT_GRID_LABEL_LEFT_CLICK, self.OnLabelLeftClick)
self.Bind(wx.EVT_KILL_FOCUS, self.OnKillFocus)
def get_tooltip_content(self):
_iscelleditcontrolshown = self.IsCellEditControlShown()
if _iscelleditcontrolshown or self._popup_menu_shown:
return ''
cell = self.cell_under_cursor
cell_info = self._controller.get_cell_info(cell.Row, cell.Col)
return TipMessage(cell_info)
def OnSettingsChanged(self, data):
'''Redraw the colors if the color settings are modified'''
section, setting = data.keys
if section == 'Grid':
if 'font' in setting:
self._set_fonts(update_cells=True)
elif ('col size' in setting or 'max col size' in setting
or 'auto size cols' in setting or 'word wrap' in setting):
self._set_cells()
self.autosize()
self._colorize_grid()
def OnSelectCell(self, event):
self._cell_selected = True
GridEditor.OnSelectCell(self, event)
self._colorize_grid()
event.Skip()
def OnKillFocus(self, event):
self._tooltips.hide()
self._hide_link_if_necessary()
self.save()
event.Skip()
def _execute(self, command):
return self._controller.execute(command)
def _toggle_underlined(self, cell):
font = self.GetCellFont(cell.Row, cell.Col)
font.SetUnderlined(not font.Underlined)
self.SetCellFont(cell.Row, cell.Col, font)
self.Refresh()
def OnLabelRightClick(self, event):
if event.Col == -1:
self._row_label_right_click(event)
else:
self._col_label_right_click(event)
def _row_label_right_click(self, event):
selected_row = event.GetRow()
selected_rows = self.selection.rows()
if selected_row not in selected_rows:
self.SelectRow(selected_row, addToSelected=False)
self.SetGridCursor(event.Row, 0)
popupitems = [
'Insert Rows\tCtrl-I', 'Delete Rows\tCtrl-D',
'Comment Rows\tCtrl-3', 'Uncomment Rows\tCtrl-4',
'Move Rows Up\tAlt-Up', 'Move Rows Down\tAlt-Down'
]
PopupMenu(self, PopupMenuItems(self, popupitems))
event.Skip()
def _col_label_right_click(self, event):
pass
def OnLabelLeftClick(self, event):
if event.Col == -1:
self._row_label_left_click(event)
else:
self._col_label_left_click(event)
def _row_label_left_click(self, event):
if event.ShiftDown() or event.ControlDown():
self.ClearSelection()
cursor_row = self.GetGridCursorRow()
event_row = event.Row
start, end = (cursor_row, event_row) \
if cursor_row < event_row else (event_row, cursor_row)
for row in range(start, end + 1):
self.SelectRow(row, addToSelected=True)
else:
self.SelectRow(event.Row, addToSelected=False)
self.SetGridCursor(event.Row, 0)
def _col_label_left_click(self, event):
pass
def OnInsertRows(self, event):
self._execute(AddRows(self.selection.rows()))
self.ClearSelection()
self._resize_grid()
self._skip_except_on_mac(event)
def _skip_except_on_mac(self, event): # TODO Do we still need this?
if event is not None and not IS_MAC:
# print("DEBUG skip!")
event.Skip()
def OnInsertCells(self, event=None):
# TODO remove below workaround for double actions
if self._counter == 1:
if self._icells == (self.selection.topleft,
self.selection.bottomright):
self._counter = 0
self._icells = None
return
else:
self._counter = 1
self._icells = (self.selection.topleft, self.selection.bottomright)
self._execute(
InsertCells(self.selection.topleft, self.selection.bottomright))
self._resize_grid()
self._skip_except_on_mac(event)
def OnDeleteCells(self, event=None):
# TODO remove below workaround for double actions
if self._counter == 1:
if self._dcells == (self.selection.topleft,
self.selection.bottomright):
self._counter = 0
self._dcells = None
return
else:
self._counter = 1
self._dcells = (self.selection.topleft, self.selection.bottomright)
self._execute(
DeleteCells(self.selection.topleft, self.selection.bottomright))
self._resize_grid()
self._skip_except_on_mac(event)
# DEBUG @requires_focus
def OnCommentRows(self, event=None):
self._execute(CommentRows(self.selection.rows()))
self._resize_grid()
self._skip_except_on_mac(event)
# DEBUG @requires_focus
def OnUncommentRows(self, event=None):
self._execute(UncommentRows(self.selection.rows()))
self._resize_grid()
self._skip_except_on_mac(event)
def OnMoveRowsUp(self, event=None):
self._row_move(MoveRowsUp, -1)
def OnMoveRowsDown(self, event=None):
self._row_move(MoveRowsDown, 1)
def _row_move(self, command, change):
# Workaround for double actions, see issue #2048
if self._counter == 1:
if IS_MAC:
row = self.GetGridCursorRow() + change
col = self.GetGridCursorCol()
if row >= 0:
self.SetGridCursor(row, col)
self._counter = 0
return
else:
self._counter += 1
rows = self.selection.rows()
if self._execute(command(rows)):
wx.CallAfter(self._select_rows, [r + change for r in rows])
self._resize_grid()
def _select_rows(self, rows):
self.ClearSelection()
for r in rows:
self.SelectRow(r, True)
def OnMotion(self, event):
pass
def _before_saving(self, data):
if self.IsCellEditControlShown():
# Fix: cannot save modifications in edit mode
# Exit edit mode before saving
self.HideCellEditControl()
self.SaveEditControlValue()
self.SetFocus()
def _data_changed(self, data):
if self._controller == data.item:
self._write_steps(data.item)
def _write_steps(self, controller):
data = []
self._write_headers(controller)
for step in controller.steps:
data.append(self._format_comments(step.as_list()))
self.ClearGrid()
self._write_data(data, update_history=False)
self._colorize_grid()
def _write_headers(self, controller):
headers = controller.data.parent.header[1:]
if not headers:
self.SetColLabelSize(0)
return
self.SetColLabelSize(wx.grid.GRID_AUTOSIZE) # DEBUG
for col, header in enumerate(headers):
self.SetColLabelValue(col, header)
for empty_col in range(col + 1, self.NumberCols + 1):
self.SetColLabelValue(empty_col, '')
def _colorize_grid(self):
selection_content = \
self._get_single_selection_content_or_none_on_first_call()
if selection_content is None:
self.highlight(None)
else:
self._parent.highlight(selection_content, expand=False)
def highlight(self, text, expand=True):
# Below CallAfter was causing C++ assertions(objects not found)
# When calling Preferences Grid Colors change
wx.CallLater(100, self._colorizer.colorize, text)
def autosize(self):
wx.CallAfter(self.AutoSizeColumns, False)
wx.CallAfter(self.AutoSizeRows, False)
def _get_single_selection_content_or_none_on_first_call(self):
if self._cell_selected:
return self.get_single_selection_content()
def _format_comments(self, data):
# TODO: This should be moved to robot.model
in_comment = False
ret = []
for cell in data:
if cell.strip().startswith('#'):
in_comment = True
if in_comment:
cell = cell.replace(' |', '')
ret.append(cell)
return ret
def cell_value_edited(self, row, col, value):
self._execute(ChangeCellValue(row, col, value))
wx.CallAfter(self.AutoSizeColumn, col, False)
wx.CallAfter(self.AutoSizeRow, row, False)
def get_selected_datafile_controller(self):
return self._controller.datafile_controller
# DEBUG @requires_focus
def OnCopy(self, event=None):
# print("DEBUG: OnCopy called event %s\n" % str(event))
self.copy()
# DEBUG @requires_focus
def OnCut(self, event=None):
self._clipboard_handler.cut()
self.OnDelete(event)
def OnDelete(self, event=None):
self._execute(
ClearArea(self.selection.topleft, self.selection.bottomright))
self._resize_grid()
# DEBUG @requires_focus
def OnPaste(self, event=None):
if self.IsCellEditControlShown():
self.paste()
else:
self._execute_clipboard_command(PasteArea)
self._resize_grid()
def _execute_clipboard_command(self, command_class):
_iscelleditcontrolshown = self.IsCellEditControlShown()
if not _iscelleditcontrolshown:
data = self._clipboard_handler.clipboard_content()
if data:
data = [[data]] if isinstance(data, str) else data
self._execute(command_class(self.selection.topleft, data))
# DEBUG @requires_focus
def OnInsert(self, event=None):
self._execute_clipboard_command(InsertArea)
self._resize_grid()
def OnDeleteRows(self, event):
self._execute(DeleteRows(self.selection.rows()))
self.ClearSelection()
self._resize_grid()
self._skip_except_on_mac(event)
# DEBUG @requires_focus
def OnUndo(self, event=None):
_iscelleditcontrolshown = self.IsCellEditControlShown()
if not _iscelleditcontrolshown:
self._execute(Undo())
else:
self.GetCellEditor(*self.selection.cell).Reset()
self._resize_grid()
# DEBUG @requires_focus
def OnRedo(self, event=None):
self._execute(Redo())
self._resize_grid()
def close(self):
self._colorizer.close()
self.save()
PUBLISHER.unsubscribe(self._before_saving, RideBeforeSaving)
PUBLISHER.unsubscribe(self._data_changed, RideItemStepsChanged)
if self._namespace_updated:
# Prevent re-entry to unregister method
self._controller.datafile_controller.unregister_namespace_updates(
self._namespace_updated)
self._namespace_updated = None
def save(self):
self._tooltips.hide()
_iscelleditcontrolshown = self.IsCellEditControlShown()
if _iscelleditcontrolshown:
cell_editor = self.GetCellEditor(*self.selection.cell)
cell_editor.EndEdit(self.selection.topleft.row,
self.selection.topleft.col, self)
def show_content_assist(self):
_iscelleditcontrolshown = self.IsCellEditControlShown()
if _iscelleditcontrolshown:
self.GetCellEditor(*self.selection.cell).show_content_assist(
self.selection.cell)
def refresh_datafile(self, item, event):
self._tree.refresh_datafile(item, event)
def _calculate_position(self):
x, y = wx.GetMousePosition()
return x, y + 20
def OnEditor(self, event):
self._tooltips.hide()
row_height = self.GetRowSize(self.selection.topleft.row)
self.GetCellEditor(*self.selection.cell).SetHeight(row_height)
event.Skip()
def _move_cursor_down(self, event):
self.DisableCellEditControl()
self.MoveCursorDown(event.ShiftDown())
def OnKeyDown(self, event):
keycode = event.GetUnicodeKey()
specialkcode = event.GetKeyCode()
if event.ControlDown():
if event.ShiftDown():
if keycode == ord('I'):
self.OnInsertCells()
elif keycode == ord('J'):
self.OnJsonEditor(event)
elif keycode == ord('D'):
self.OnDeleteCells()
else:
if keycode == wx.WXK_SPACE:
self._open_cell_editor_with_content_assist()
elif keycode == ord('C'):
self.OnCopy(event)
elif keycode == ord('X'):
self.OnCut(event)
elif keycode == ord('V'):
self.OnPaste(event)
elif keycode == ord('Z'):
self.OnUndo(event)
elif keycode == ord('A'):
self.OnSelectAll(event)
elif keycode == ord('B'):
self._navigate_to_matching_user_keyword(
self.GetGridCursorRow(), self.GetGridCursorCol())
elif keycode == ord('F'):
if not self.has_focus():
self.SetFocus() # Avoiding Search field on Text Edit
elif keycode in (ord('1'), ord('2'), ord('5')):
self._open_cell_editor_and_execute_variable_creator(
list_variable=(keycode == ord('2')),
dict_variable=(keycode == ord('5')))
else:
self.show_cell_information()
elif event.AltDown():
if keycode == wx.WXK_SPACE:
self._open_cell_editor_with_content_assist() # Mac CMD
elif specialkcode in [wx.WXK_DOWN, wx.WXK_UP]:
self._skip_except_on_mac(event)
self._move_rows(specialkcode)
elif specialkcode == wx.WXK_RETURN:
self._move_cursor_down(event)
else:
event.Skip()
else:
if specialkcode == wx.WXK_WINDOWS_MENU:
self.OnCellRightClick(event)
elif specialkcode in [wx.WXK_RETURN, wx.WXK_BACK]:
self.save()
self._move_grid_cursor(event, specialkcode)
elif specialkcode == wx.WXK_F2:
self._open_cell_editor()
else:
event.Skip()
if specialkcode != wx.WXK_RETURN:
event.Skip()
def OnChar(self, event):
keychar = event.GetUnicodeKey()
if keychar < ord(' '):
return
if keychar in [
ord('['),
ord('{'),
ord('('),
ord("'"),
ord('\"'),
ord('`')
]:
self._open_cell_editor().execute_enclose_text(chr(keychar))
else:
event.Skip()
def OnGoToDefinition(self, event):
self._navigate_to_matching_user_keyword(self.GetGridCursorRow(),
self.GetGridCursorCol())
def show_cell_information(self):
cell = self.cell_under_cursor
value = self._cell_value(cell)
if value:
self._show_user_keyword_link(cell, value)
self._show_keyword_details(cell, value)
def _cell_value(self, cell):
if cell == self._no_cell:
return None
return self.GetCellValue(cell.Row, cell.Col)
def _show_user_keyword_link(self, cell, value):
if cell != self._marked_cell and self._plugin.get_user_keyword(value):
self._toggle_underlined(cell)
self._marked_cell = cell
def _show_keyword_details(self, cell, value):
details = self._plugin.get_keyword_details(value)
if not details:
info = self._controller.get_cell_info(cell.Row, cell.Col)
if info.cell_type == CellType.KEYWORD and info.content_type == \
ContentType.STRING:
details = """\
<b>Keyword was not detected by RIDE</b>
<br>Possible corrections:<br>
<ul>
<li>Import library or resource file containing the keyword.</li>
<li>For library import errors: Consider importing library spec XML
(Tools / Import Library Spec XML or by adding the XML file with the
correct name to PYTHONPATH) to enable keyword completion
for example for Java libraries.
Library spec XML can be created using libdoc tool from Robot Frame\
work.</li>
</ul>"""
if details:
self._tooltips.show_info_at(details, value,
self._cell_to_screen_coordinates(cell))
def _cell_to_screen_coordinates(self, cell):
point = self.CellToRect(cell.Row, cell.Col).GetTopRight()
point.x += self.GetRowLabelSize() + 5
return self.ClientToScreen(self.CalcScrolledPosition(point))
def _move_rows(self, keycode):
if keycode == wx.WXK_UP:
self.OnMoveRowsUp()
else:
self.OnMoveRowsDown()
def _move_grid_cursor(self, event, keycode):
self.DisableCellEditControl()
if keycode == wx.WXK_RETURN:
self.MoveCursorRight(event.ShiftDown())
else:
self.MoveCursorLeft(event.ShiftDown())
def OnKeyUp(self, event):
event.Skip() # DEBUG seen this skip as soon as possible
self._tooltips.hide()
self._hide_link_if_necessary()
# event.Skip()
def _open_cell_editor(self):
if not self.IsCellEditControlEnabled():
self.EnableCellEditControl()
row = self.GetGridCursorRow()
celleditor = self.GetCellEditor(self.GetGridCursorCol(), row)
celleditor.Show(True)
return celleditor
def _open_cell_editor_with_content_assist(self):
wx.CallAfter(self._open_cell_editor().show_content_assist)
def _open_cell_editor_and_execute_variable_creator(self,
list_variable=False,
dict_variable=False):
wx.CallAfter(self._open_cell_editor().execute_variable_creator,
list_variable, dict_variable)
def OnMakeVariable(self, event):
self._open_cell_editor_and_execute_variable_creator(
list_variable=False)
def OnMakeListVariable(self, event):
self._open_cell_editor_and_execute_variable_creator(list_variable=True)
def OnMakeDictVariable(self, event):
self._open_cell_editor_and_execute_variable_creator(dict_variable=True)
def OnCellRightClick(self, event):
self._tooltips.hide()
self._popup_menu_shown = True
GridEditor.OnCellRightClick(self, event)
self._popup_menu_shown = False
def OnSelectAll(self, event):
self.SelectAll()
def OnCellColSizeChanged(self, event):
wx.CallAfter(self.AutoSizeRows, False)
event.Skip()
def OnCellLeftClick(self, event):
self._tooltips.hide()
if event.ControlDown():
if self._navigate_to_matching_user_keyword(event.Row, event.Col):
return
if not self._has_been_clicked:
self.SetGridCursor(event.Row, event.Col)
self._has_been_clicked = True
else:
event.Skip()
def OnCellLeftDClick(self, event):
self._tooltips.hide()
if not self._navigate_to_matching_user_keyword(event.Row, event.Col):
event.Skip()
def _navigate_to_matching_user_keyword(self, row, col):
value = self.GetCellValue(row, col)
uk = self._plugin.get_user_keyword(value)
if uk:
self._toggle_underlined((grid.GridCellCoords(row, col)))
self._marked_cell = None
wx.CallAfter(self._tree.select_user_keyword_node, uk)
return True
return False
def _is_active_window(self):
return self.IsShownOnScreen() and self.FindFocus()
def _hide_link_if_necessary(self):
if not self._marked_cell:
return
self._toggle_underlined(self._marked_cell)
self._marked_cell = None
def OnCreateKeyword(self, event):
cells = self._data_cells_from_current_row()
if not cells:
return
try:
self._execute(AddKeywordFromCells(cells))
except ValueError as err:
wx.MessageBox(str(err))
def _data_cells_from_current_row(self):
currow, curcol = self.selection.cell
rowdata = self._row_data(currow)[curcol:]
return self._strip_trailing_empty_cells(self._remove_comments(rowdata))
def _remove_comments(self, data):
for index, cell in enumerate(data):
if cell.strip().startswith('#'):
return data[:index]
return data
def OnExtractKeyword(self, event):
dlg = UserKeywordNameDialog(self._controller)
if dlg.ShowModal() == wx.ID_OK:
name, args = dlg.get_value()
rows = self.selection.topleft.row, self.selection.bottomright.row
self._execute(ExtractKeyword(name, args, rows))
def OnExtractVariable(self, event):
cells = self.selection.cells()
if len(cells) == 1:
self._extract_scalar(cells[0])
elif min(row for row, _ in cells) == max(row for row, _ in cells):
self._extract_list(cells)
self._resize_grid()
def OnFindWhereUsed(self, event):
is_variable, searchstring = self._get_is_variable_and_searchstring()
if searchstring:
self._execute_find_where_used(is_variable, searchstring)
def _get_is_variable_and_searchstring(self):
cellvalue = self.GetCellValue(*self.selection.cells()[0])
if self._cell_value_contains_multiple_search_items(cellvalue):
choice_dialog = ChooseUsageSearchStringDialog(cellvalue)
choice_dialog.ShowModal()
is_var, value = choice_dialog.GetStringSelection()
choice_dialog.Destroy()
return is_var, value
else:
return variablematcher.is_variable(cellvalue), cellvalue
def _execute_find_where_used(self, is_variable, searchstring):
usages_dialog_class = VariableUsages if is_variable else Usages
usages_dialog_class(self._controller, self._tree.highlight,
searchstring).show()
def _cell_value_contains_multiple_search_items(self, value):
variables = variablematcher.find_variable_basenames(value)
return variables and variables[0] != value
def _extract_scalar(self, cell):
var = robotapi.Variable(self._controller.datafile.variable_table, '',
self.GetCellValue(*cell), '')
dlg = ScalarVariableDialog(
self._controller.datafile_controller.variables, var)
if dlg.ShowModal() == wx.ID_OK:
name, value = dlg.get_value()
comment = dlg.get_comment()
self._execute(ExtractScalar(name, value, comment, cell))
def _extract_list(self, cells):
var = robotapi.Variable(self._controller.datafile.variable_table, '',
[self.GetCellValue(*cell) for cell in cells],
'')
dlg = ListVariableDialog(
self._controller.datafile_controller.variables, var, self._plugin)
if dlg.ShowModal() == wx.ID_OK:
name, value = dlg.get_value()
comment = dlg.get_comment()
self._execute(ExtractList(name, value, comment, cells))
def OnRenameKeyword(self, event):
old_name = self._current_cell_value()
if not old_name.strip() or variablematcher.is_variable(old_name):
return
new_name = wx.GetTextFromUser('New name',
'Rename Keyword',
default_value=old_name)
if new_name:
self._execute(
RenameKeywordOccurrences(
old_name, new_name,
RenameProgressObserver(self.GetParent())))
# Add one new Dialog to edit pretty json String
def OnJsonEditor(self, event=None):
if event:
event.Skip()
dialog = Dialog()
dialog.SetTitle('JSON Editor')
dialog.SetSizer(wx.BoxSizer(wx.HORIZONTAL))
okBtn = wx.Button(dialog, wx.ID_OK, "Save")
cnlBtn = wx.Button(dialog, wx.ID_CANCEL, "Cancel")
richText = wx.TextCtrl(dialog,
wx.ID_ANY, "If supported by the native "
"control, this is reversed, "
"and this is a different "
"font.",
size=(400, 475),
style=wx.HSCROLL | wx.TE_MULTILINE
| wx.TE_NOHIDESEL)
dialog.Sizer.Add(richText, flag=wx.GROW, proportion=1)
dialog.Sizer.Add(okBtn, flag=wx.ALIGN_RIGHT | wx.ALL)
dialog.Sizer.Add(cnlBtn, flag=wx.ALL)
# Get cell value of parent grid
if self.is_json(self._current_cell_value()):
jsonStr = json.loads(self._current_cell_value())
richText.SetValue(json.dumps(jsonStr, indent=4,
ensure_ascii=False))
else:
richText.SetValue(self._current_cell_value())
dialog.SetSize((650, 550))
# If click Save, then save the value in richText into the original
# grid cell, and clear all indent.
if dialog.ShowModal() == wx.ID_OK:
try:
strJson = json.loads(richText.GetValue())
self.cell_value_edited(self.selection.cell[0],
self.selection.cell[1],
json.dumps(strJson, ensure_ascii=False))
except ValueError or json.JSONDecodeError as e:
res = wx.MessageDialog(
dialog, "Error in JSON: {}\n\n"
"Save anyway?".format(e), "Validation Error!",
wx.YES_NO).ShowModal()
if res == wx.ID_YES:
self.cell_value_edited(self.selection.cell[0],
self.selection.cell[1],
richText.GetValue())
else:
pass
# If the jsonStr is json format, then return True
def is_json(self, jsonStr):
try:
json.loads(jsonStr)
except ValueError:
return False
return True
class Tree(
with_metaclass(classmaker(), treemixin.DragAndDrop,
customtreectrl.CustomTreeCtrl, utils.RideEventHandler)):
_RESOURCES_NODE_LABEL = 'External Resources'
def __init__(self, parent, action_registerer, settings=None):
self._checkboxes_for_tests = False
self._test_selection_controller = \
self._create_test_selection_controller()
self._controller = TreeController(
self,
action_registerer,
settings=settings,
test_selection=self._test_selection_controller)
treemixin.DragAndDrop.__init__(self, parent, **_TREE_ARGS)
self._controller.register_tree_actions()
self._bind_tree_events()
self._images = TreeImageList()
self._animctrl = None
self._silent_mode = False
self.SetImageList(self._images)
self.label_editor = TreeLabelEditListener(self, action_registerer)
self._controller.bind_keys()
self._subscribe_to_messages()
self._popup_creator = PopupCreator()
self._dragging = False
self._clear_tree_data()
self._editor = None
self._execution_results = None
self._resources = []
self.SetBackgroundColour('white') # TODO get background color from def
if not hasattr(self, 'OnCancelEdit'):
self.OnCancelEdit = self._on_cancel_edit
def _create_test_selection_controller(self):
tsc = TestSelectionController()
PUBLISHER.subscribe(tsc.clear_all, RideOpenSuite)
PUBLISHER.subscribe(tsc.clear_all, RideNewProject)
return tsc
def _on_cancel_edit(self, item):
le = customtreectrl.TreeEvent(customtreectrl.wxEVT_TREE_END_LABEL_EDIT,
self.GetId())
le._item = item
le.SetEventObject(self)
le._label = ""
le._editCancelled = True
self.GetEventHandler().ProcessEvent(le)
def _bind_tree_events(self):
self.Bind(wx.EVT_LEFT_DCLICK, self.OnDoubleClick)
self.Bind(wx.EVT_TREE_SEL_CHANGED, self.OnSelChanged)
self.Bind(wx.EVT_TREE_ITEM_EXPANDING, self.OnTreeItemExpanding)
self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnRightClick)
self.Bind(wx.EVT_TREE_ITEM_ACTIVATED, self.OnItemActivated)
self.Bind(customtreectrl.EVT_TREE_ITEM_CHECKED, self.OnTreeItemChecked)
self.Bind(wx.EVT_TREE_ITEM_COLLAPSING, self.OnTreeItemCollapsing)
self.Bind(wx.EVT_CLOSE, self.OnClose)
def OnDoubleClick(self, event):
item, pos = self.HitTest(self.ScreenToClient(wx.GetMousePosition()))
if item:
handler = self._controller.get_handler(item)
handler.double_clicked()
event.Skip()
def set_editor(self, editor):
self._editor = editor
def StartDragging(self):
self._dragging = True
treemixin.DragAndDrop.StartDragging(self)
def OnEndDrag(self, event):
self._dragging = False
treemixin.DragAndDrop.OnEndDrag(self, event)
def register_context_menu_hook(self, callable):
self._popup_creator.add_hook(callable)
def unregister_context_menu_hook(self, callable):
self._popup_creator.remove_hook(callable)
def _subscribe_to_messages(self):
subscriptions = [
(self._item_changed, RideItem),
(self._resource_added, RideOpenResource),
(self._select_resource, RideSelectResource),
(self._suite_added, RideSuiteAdded),
(self._keyword_added, RideUserKeywordAdded),
(self._test_added, RideTestCaseAdded),
(self._variable_added, RideVariableAdded),
(self._leaf_item_removed, RideUserKeywordRemoved),
(self._leaf_item_removed, RideTestCaseRemoved),
(self._leaf_item_removed, RideVariableRemoved),
(self._datafile_removed, RideDataFileRemoved),
(self._datafile_set, RideDataFileSet),
(self._data_dirty, RideDataChangedToDirty),
(self._data_undirty, RideDataDirtyCleared),
(self._variable_moved_up, RideVariableMovedUp),
(self._variable_moved_down, RideVariableMovedDown),
(self._variable_updated, RideVariableUpdated),
(self._filename_changed, RideFileNameChanged),
(self._testing_started, RideTestExecutionStarted),
(self._test_result, RideTestRunning),
(self._test_result, RideTestPaused),
(self._test_result, RideTestPassed),
(self._test_result, RideTestFailed),
(self._handle_import_setting_message, RideImportSetting),
(self._mark_excludes, RideExcludesChanged),
(self._mark_excludes, RideIncludesChanged),
]
for listener, topic in subscriptions:
PUBLISHER.subscribe(listener, topic)
def _mark_excludes(self, message):
tree = self._controller.find_node_by_controller(message.old_controller)
self._render_datafile(self.GetItemParent(tree), message.new_controller)
self._remove_datafile_node(tree)
def _set_item_excluded(self, node):
self.SetItemTextColour(node, wx.TheColourDatabase.Find("GRAY"))
self.SetItemItalic(node, True)
self.SetItemText(node, "%s (excluded)" % self.GetItemText(node))
def _handle_import_setting_message(self, message):
if message.is_resource():
self._set_resource_color(
message.import_controller.get_imported_controller())
self._set_resource_color(
message.import_controller.get_previous_imported_controller())
def _set_resource_color(self, resource_controller):
if not resource_controller:
return
node = self._controller.find_node_by_controller(resource_controller)
if node:
self.SetItemTextColour(
node, self._get_resource_text_color(resource_controller))
def _get_resource_text_color(self, resource_controller):
if resource_controller.is_used():
return self.GetDefaultAttributes().colFg
else:
return wx.LIGHT_GREY
def _testing_started(self, message):
self._for_all_drawn_tests(
self._root, lambda t: self.SetItemImage(t, ROBOT_IMAGE_INDEX))
self._execution_results = message.results
self._images.set_execution_results(message.results)
def _test_result(self, message):
wx.CallAfter(self._set_icon_from_execution_results, message.item)
def _set_icon_from_execution_results(self, controller):
node = self._controller.find_node_by_controller(controller)
if not node:
return
img_index = self._get_icon_index_for(controller)
# Always set the static icon
self.SetItemImage(node, img_index)
if self._animctrl:
self._animctrl.Stop()
self._animctrl.Animation.Destroy()
self._animctrl.Destroy()
self._animctrl = None
self.DeleteItemWindow(node)
if img_index in (RUNNING_IMAGE_INDEX, PAUSED_IMAGE_INDEX):
from wx.adv import Animation, AnimationCtrl
import os
_BASE = os.path.join(os.path.dirname(__file__), '..', 'widgets')
if img_index == RUNNING_IMAGE_INDEX:
img = os.path.join(_BASE, 'robot-running.gif')
else:
img = os.path.join(_BASE, 'robot-pause.gif')
ani = Animation(img)
obj = self
rect = (node.GetX() + 20, node.GetY()) # Overlaps robot icon
self._animctrl = AnimationCtrl(obj, -1, ani, rect)
self._animctrl.SetBackgroundColour(obj.GetBackgroundColour())
self.SetItemWindow(node, self._animctrl, False)
self._animctrl.Play()
# Make visible the running or paused test
self.EnsureVisible(node)
def _get_icon_index_for(self, controller):
if not self._execution_results:
return ROBOT_IMAGE_INDEX
if self._execution_results.is_paused(controller):
return PAUSED_IMAGE_INDEX
if self._execution_results.is_running(controller):
return RUNNING_IMAGE_INDEX
if self._execution_results.has_passed(controller):
return PASSED_IMAGE_INDEX
if self._execution_results.has_failed(controller):
return FAILED_IMAGE_INDEX
return ROBOT_IMAGE_INDEX
def populate(self, model):
self._clear_tree_data()
self._populate_model(model)
self._refresh_view()
self.SetFocus() # Needed for keyboard shortcuts
def _clear_tree_data(self):
self.DeleteAllItems()
self._root = self.AddRoot('')
self._resource_root = self._create_resource_root()
self._datafile_nodes = []
self._resources = []
def _create_resource_root(self):
return self._create_node(self._root, self._RESOURCES_NODE_LABEL,
self._images.directory)
def _populate_model(self, model):
handler = ResourceRootHandler(model, self, self._resource_root,
self._controller.settings)
self.SetPyData(self._resource_root, handler)
if model.data:
self._render_datafile(self._root, model.data, 0)
for res in model.external_resources:
if not res.parent:
self._render_datafile(self._resource_root, res)
def _resource_added(self, message):
ctrl = message.datafile
if self._controller.find_node_by_controller(ctrl):
return
parent = None
if ctrl.parent:
parent = self._get_dir_node(ctrl.parent)
else:
parent = self._resource_root
self._render_datafile(parent, ctrl)
def _get_dir_node(self, ctrl):
if ctrl is None:
return self._root
dir_node = self._get_datafile_node(ctrl.data)
if dir_node is None:
parent = self._get_dir_node(ctrl.parent)
self._render_datafile(parent, ctrl)
dir_node = self._get_datafile_node(ctrl.data)
return dir_node
def _select_resource(self, message):
self.select_controller_node(message.item)
def select_controller_node(self, controller):
self.SelectItem(self._controller.find_node_by_controller(controller))
def _suite_added(self, message):
self.add_datafile(message.parent, message.suite)
def _refresh_view(self):
self.Refresh()
if self._resource_root:
self.Expand(self._resource_root)
if self._datafile_nodes:
self.SelectItem(self._datafile_nodes[0])
self._expand_and_render_children(self._datafile_nodes[0])
def _render_datafile(self, parent_node, controller, index=None):
node = self._create_node_with_handler(parent_node, controller, index)
if not node:
return None
if controller.dirty:
self._controller.mark_node_dirty(node)
self._datafile_nodes.append(node)
self.SetItemHasChildren(node, True)
for child in controller.children:
self._render_datafile(node, child)
return node
def _normalize(self, path):
return os.path.normcase(os.path.normpath(os.path.abspath(path)))
def _create_node_with_handler(self, parent_node, controller, index=None):
if IS_WINDOWS and isinstance(controller, ResourceFileController):
resourcefile = self._normalize(controller.filename)
pname = parent_node.GetText()
self._resources.append((pname, resourcefile))
if IS_WINDOWS:
count = 0
for (p, r) in self._resources:
if (p, r) == (pname, resourcefile):
count += 1
if count > 3:
return None
handler_class = action_handler_class(controller)
with_checkbox = (handler_class == TestCaseHandler
and self._checkboxes_for_tests)
node = self._create_node(parent_node,
controller.display_name,
self._images[controller],
index,
with_checkbox=with_checkbox)
if isinstance(controller,
ResourceFileController) and not controller.is_used():
self.SetItemTextColour(node, TREETEXTCOLOUR) # wxPython3 hack
action_handler = handler_class(controller, self, node,
self._controller.settings)
self.SetPyData(node, action_handler)
# if we have a TestCase node we have to make sure that
# we retain the checked state
if (handler_class == TestCaseHandler and self._checkboxes_for_tests) \
and self._test_selection_controller.is_test_selected(controller):
self.CheckItem(node, True)
if controller.is_excluded():
self._set_item_excluded(node)
return node
def set_checkboxes_for_tests(self):
self._checkboxes_for_tests = True
def _expand_and_render_children(self, node):
assert node is not None
self._render_children(node)
self.Expand(node)
def _render_children(self, node):
handler = self._controller.get_handler(node)
if not handler or not handler.can_be_rendered:
return
self._create_child_nodes(node, handler,
lambda item: item.is_test_suite)
handler.set_rendered()
def _create_child_nodes(self, node, handler, predicate):
for childitem in self._children_of(handler):
index = self._get_insertion_index(node, predicate)
self._create_node_with_handler(node, childitem, index)
def _children_of(self, handler):
return [v for v in handler.variables if v.has_data()] + \
list(handler.tests) + list(handler.keywords)
def _create_node(self,
parent_node,
label,
img,
index=None,
with_checkbox=False):
node = self._wx_node(parent_node, index, label, with_checkbox)
self.SetItemImage(node, img.normal, wx.TreeItemIcon_Normal)
self.SetItemImage(node, img.expanded, wx.TreeItemIcon_Expanded)
return node
def _wx_node(self, parent_node, index, label, with_checkbox):
ct_type = 1 if with_checkbox else 0
if index is not None:
# blame wxPython for this ugliness
if isinstance(index, int):
return self.InsertItemByIndex(parent_node,
index,
label,
ct_type=ct_type)
else:
return self.InsertItem(parent_node,
index,
label,
ct_type=ct_type)
return self.AppendItem(parent_node, label, ct_type=ct_type)
def add_datafile(self, parent, suite):
snode = self._render_datafile(self._get_datafile_node(parent.data),
suite)
self.SelectItem(snode)
def add_test(self, parent_node, test):
self._add_dataitem(parent_node, test,
lambda item: item.is_user_keyword)
def add_keyword(self, parent_node, kw):
self._add_dataitem(parent_node, kw, lambda item: item.is_test_suite)
def _add_dataitem(self, parent_node, dataitem, predicate):
node = self._get_or_create_node(parent_node, dataitem, predicate)
self._select(node)
self._controller.mark_node_dirty(parent_node)
def _get_or_create_node(self, parent_node, dataitem, predicate):
if not self.IsExpanded(parent_node):
self._expand_and_render_children(parent_node)
return self._controller.find_node_with_label(
parent_node, dataitem.display_name)
index = self._get_insertion_index(parent_node, predicate)
return self._create_node_with_handler(parent_node, dataitem, index)
def _select(self, node):
if node:
wx.CallAfter(self.SelectItem, node)
def _get_insertion_index(self, parent_node, predicate):
if not predicate:
return None
item, cookie = self.GetFirstChild(parent_node)
while item:
if predicate(self._controller.get_handler(item)):
index = self.GetPrevSibling(item)
if not index:
index = 0
return index
item, cookie = self.GetNextChild(parent_node, cookie)
return None
def _keyword_added(self, message):
self.add_keyword(self._get_datafile_node(self.get_selected_datafile()),
message.item)
def _variable_added(self, message):
self._get_or_create_node(
self._get_datafile_node(self.get_selected_datafile()),
message.item,
lambda item: not item.is_variable or item.index > message.index)
def _leaf_item_removed(self, message):
node = self._controller.find_node_by_controller(message.item)
parent_node = self._get_datafile_node(message.datafile)
# DEBUG The below call causes not calling delete_node
# self._test_selection_controller.select(message.item, False)
self._controller.mark_node_dirty(parent_node)
self.delete_node(node)
def _test_added(self, message):
self.add_test(self._get_datafile_node(self.get_selected_datafile()),
message.item)
def _datafile_removed(self, message):
dfnode = self._get_datafile_node(message.datafile.data)
self._datafile_nodes.remove(dfnode)
self.DeleteChildren(dfnode)
self.Delete(dfnode)
def _datafile_set(self, message):
wx.CallAfter(self._refresh_datafile_when_file_set, message.item)
def _filename_changed(self, message):
df = message.datafile
node = self._controller.find_node_by_controller(df)
if not node:
raise AssertionError('No node found with controller "%s"' % df)
wx.CallAfter(self.SetItemText, node, df.display_name)
def add_keyword_controller(self, controller):
parent = self._get_datafile_node(self.get_selected_datafile())
self.add_keyword(parent, controller)
def delete_node(self, node):
if node is None:
return
parent = self.GetItemParent(node)
self._controller.mark_node_dirty(parent)
if self.IsSelected(node):
wx.CallAfter(self.SelectItem, parent)
wx.CallAfter(self.Delete, node)
def _data_dirty(self, message):
self._controller.mark_controller_dirty(message.datafile)
def _data_undirty(self, message):
self.unset_dirty()
def unset_dirty(self):
for node in self._datafile_nodes:
text = self.GetItemText(node)
handler = self._controller.get_handler(node)
if text.startswith('*') and not handler.controller.dirty:
self.SetItemText(node, text[1:])
def select_node_by_data(self, controller):
"""Find and select the tree item associated with the given controller.
Controller can be any of the controllers that are represented in the
tree."""
parent_node = self._get_datafile_node(controller.datafile)
if not parent_node:
return None
if not self.IsExpanded(parent_node):
self._expand_and_render_children(parent_node)
node = self._controller.find_node_by_controller(controller)
if node != self.GetSelection():
self.SelectItem(node)
return node
def select_user_keyword_node(self, uk):
parent_node = self._get_datafile_node(uk.parent.parent)
if not parent_node:
return
if not self.IsExpanded(parent_node):
self._expand_and_render_children(parent_node)
node = self._controller.find_node_with_label(parent_node,
utils.normalize(uk.name))
if node != self.GetSelection():
self.SelectItem(node)
def _get_datafile_node(self, datafile):
for node in self._datafile_nodes:
if self._controller.get_handler(node).item == datafile:
return node
return None
def get_selected_datafile(self):
"""Returns currently selected data file.
If a test or user keyword node is selected, returns parent of that
item."""
datafile = self._get_selected_datafile_node()
if not datafile:
return None
return self._controller.get_handler(datafile).item
def get_selected_datafile_controller(self):
"""Returns controller associated with currently active data file.
If a test or user keyword node is selected, returns parent of that
item."""
dfnode = self._get_selected_datafile_node()
if dfnode:
return self._controller.get_handler(dfnode).controller
else:
return None
def _get_selected_datafile_node(self):
node = self.GetSelection()
if not node or node in (self._resource_root, self._root):
return None
while node not in self._datafile_nodes:
node = self.GetItemParent(node)
return node
def get_selected_item(self):
"""Returns model object associated with currently selected tree node.
"""
selection = self.GetSelection()
if not selection:
return None
handler = self._controller.get_handler(selection)
return handler and handler.controller or None
def move_up(self, node):
prev = self.GetPrevSibling(node)
if prev.IsOk():
self._switch_items(prev, node, node)
def move_down(self, node):
next = self.GetNextSibling(node)
if next.IsOk():
self._switch_items(node, next, node)
def _switch_items(self, first, second, currently_selected):
"""Changes the order of given items, first is expected to be directly
above the second"""
selection = self.GetItemPyData(currently_selected).controller
controller = self._controller.get_handler(first).controller
self.Delete(first)
self._create_node_with_handler(self.GetItemParent(second), controller,
second)
self.select_node_by_data(selection)
def _refresh_datafile_when_file_set(self, controller):
# Prevent tab selections based on tree item selected events
self._start_silent_mode()
current = self.get_selected_datafile_controller()
if not current: # If tree is not yet in use - do not expand anything.
self._end_silent_mode()
return
item = self.GetSelection()
current_txt = self.GetItemText(item) if item.IsOk() else ''
# after refresh current and current_txt might have been changed
node = self._refresh_datafile(controller)
if node is None:
# TODO: Find out why this sometimes happens
return
self._expand_and_render_children(node)
if current == controller:
select_item = self._controller.find_node_with_label(
node, current_txt)
if select_item is None:
select_item = node
wx.CallAfter(self.SelectItem, select_item)
wx.CallAfter(self._end_silent_mode)
else:
self._end_silent_mode()
def _uncheck_tests(self, controller):
self._test_selection_controller.unselect_all(controller.tests)
def _start_silent_mode(self):
self._silent_mode = True
def _end_silent_mode(self):
self._silent_mode = False
def refresh_datafile(self, controller, event):
to_be_selected = self._get_pending_selection(event)
new_node = self._refresh_datafile(controller)
self._handle_pending_selection(to_be_selected, new_node)
def _refresh_datafile(self, controller):
orig_node = self._get_data_controller_node(controller)
if orig_node is not None:
insertion_index = self._get_datafile_index(orig_node)
parent = self.GetItemParent(orig_node)
self._remove_datafile_node(orig_node)
return self._render_datafile(parent, controller, insertion_index)
def _get_pending_selection(self, event):
if hasattr(event, 'Item'):
item = event.GetItem()
event.Veto()
elif hasattr(event, 'Position'):
item, flags = self.HitTest(event.Position)
if not self._click_on_item(item, flags):
return
else:
return
return self.GetItemText(item)
def _get_data_controller_node(self, controller):
for node in self._datafile_nodes:
if self.GetItemPyData(node).controller == controller:
return node
return None
def _click_on_item(self, item, flags):
return item is not None and item.IsOk() and \
flags & wx.TREE_HITTEST_ONITEM
def _get_datafile_index(self, node):
insertion_index = self.GetPrevSibling(node)
if not insertion_index:
insertion_index = 0
return insertion_index
def _remove_datafile_node(self, node):
for child in self.GetItemChildren(node):
if child in self._datafile_nodes:
self._remove_datafile_node(child)
self._datafile_nodes.remove(node)
self.Delete(node)
def _handle_pending_selection(self, to_be_selected, parent_node):
if to_be_selected:
self._expand_and_render_children(parent_node)
select_item = self._controller.find_node_with_label(
parent_node, to_be_selected)
wx.CallAfter(self.SelectItem, select_item)
def OnSelChanged(self, event):
node = event.GetItem()
if not node.IsOk() or self._dragging:
event.Skip()
return
self._controller.add_to_history(node)
handler = self._controller.get_handler(node)
if handler and handler.item:
RideTreeSelection(node=node,
item=handler.controller,
silent=self._silent_mode).publish()
self.SetFocus()
def OnTreeItemExpanding(self, event):
node = event.GetItem()
if node.IsOk():
self._render_children(node)
# This exists because CustomTreeItem does not remove animations
def OnTreeItemCollapsing(self, event):
item = event.GetItem()
self._hide_item(item)
event.Skip()
def _hide_item(self, item):
for item in item.GetChildren():
itemwindow = item.GetWindow()
if itemwindow:
itemwindow.Hide()
if self.ItemHasChildren(item):
self._hide_item(item)
def SelectAllTests(self, item):
self._for_all_tests(item, lambda t: self.CheckItem(t))
def SelectTests(self, tests):
def foo(t):
if self.GetPyData(t).controller in tests:
self.CheckItem(t)
self._for_all_tests(self._root, foo)
def ExpandAllSubNodes(self, item):
self._expand_or_collapse_nodes(item, self.Expand)
def CollapseAllSubNodes(self, item):
self._expand_or_collapse_nodes(item, self.Collapse)
def _expand_or_collapse_nodes(self, item, callback):
if not self.HasAGWFlag(customtreectrl.TR_HIDE_ROOT) or \
item != self.GetRootItem():
callback(item)
for child in item.GetChildren():
self._expand_or_collapse_nodes(child, callback)
def _for_all_tests(self, item, func):
item_was_expanded = self.IsExpanded(item)
if not self.HasAGWFlag(customtreectrl.TR_HIDE_ROOT) or \
item != self.GetRootItem():
if isinstance(item.GetData(), ResourceRootHandler
or ResourceFileHandler):
return
is_item_expanded = self.IsExpanded(item)
if not is_item_expanded:
self.Expand(item)
if self._is_test_node(item):
func(item)
if not self.IsExpanded(item):
return
for child in item.GetChildren():
self._for_all_tests(child, func)
if not item_was_expanded:
self.Collapse(item)
def _for_all_drawn_tests(self, item, func):
if self._is_test_node(item):
func(item)
for child in item.GetChildren():
self._for_all_drawn_tests(child, func)
def _is_test_node(self, node):
return node.GetType() == 1
def DeselectAllTests(self, item):
self._for_all_tests(item, lambda t: self.CheckItem(t, checked=False))
def DeselectTests(self, tests):
def foo(t):
if self.GetPyData(t).controller in tests:
self.CheckItem(t, checked=False)
self._for_all_tests(self._root, foo)
def SelectFailedTests(self, item):
def func(t):
# FIXME: This information should be in domain model!
is_checked = self.GetItemImage(t) == FAILED_IMAGE_INDEX
self.CheckItem(t, checked=is_checked)
self._for_all_tests(item, func)
def SelectPassedTests(self, item):
def func(t):
is_checked = self.GetItemImage(t) == PASSED_IMAGE_INDEX
self.CheckItem(t, checked=is_checked)
self._for_all_tests(item, func)
def OnClose(self, event):
print("DEBUG: Tree OnClose hidding")
self.Hide()
def OnTreeItemChecked(self, event):
node = event.GetItem()
handler = self._controller.get_handler(node=node)
self._test_selection_controller.select(handler.controller,
node.IsChecked())
def OnItemActivated(self, event):
node = event.GetItem()
if self.IsExpanded(node):
self.Collapse(node)
elif self.ItemHasChildren(node):
self._expand_and_render_children(node)
def OnLeftArrow(self, event):
node = self.GetSelection()
if self.IsExpanded(node):
self.Collapse(node)
else:
event.Skip()
def OnRightClick(self, event):
handler = None
if hasattr(event, 'GetItem'):
handler = self._controller.get_handler(event.GetItem())
if handler:
if not self.IsExpanded(handler.node):
self.Expand(handler.node)
handler.show_popup()
def OnNewTestCase(self, event):
handler = self._controller.get_handler()
if handler:
handler.OnNewTestCase(event)
def OnDrop(self, target, dragged):
dragged = self._controller.get_handler(dragged)
target = self._controller.get_handler(target)
if target and target.accepts_drag(dragged):
dragged.controller.execute(MoveTo(target.controller))
self.Refresh() # DEBUG Always refresh
def IsValidDragItem(self, item):
return self._controller.get_handler(item).is_draggable
def OnMoveUp(self, event):
handler = self._controller.get_handler()
if handler.is_draggable:
handler.OnMoveUp(event)
def OnMoveDown(self, event):
handler = self._controller.get_handler()
if handler.is_draggable:
handler.OnMoveDown(event)
def _item_changed(self, data):
controller = data.item
node = self._controller.find_node_by_controller(controller)
if node:
self.SetItemText(node, data.item.name)
self._test_selection_controller.send_selection_changed_message()
if controller.dirty:
self._controller.mark_node_dirty(
self._get_datafile_node(controller.datafile))
def _variable_moved_up(self, data):
if self._should_update_variable_positions(data):
self._do_action_if_datafile_node_is_expanded(self.move_up, data)
def _variable_moved_down(self, data):
if self._should_update_variable_positions(data):
self._do_action_if_datafile_node_is_expanded(self.move_down, data)
def _should_update_variable_positions(self, message):
return message.item != message.other and message.item.has_data() and \
message.other.has_data()
def _do_action_if_datafile_node_is_expanded(self, action, data):
if self.IsExpanded(self._get_datafile_node(data.item.datafile)):
node = self._controller.find_node_by_controller(data.item)
action(node)
def _variable_updated(self, data):
self._item_changed(data)
def highlight(self, data, text):
self.select_node_by_data(data)
self._editor.highlight(text)
def node_is_resource_file(self, node):
return self._controller.get_handler(node).__class__ == \
ResourceFileHandler
class RideFrame(with_metaclass(classmaker(), wx.Frame, RideEventHandler)):
def __init__(self, application, controller):
size = application.settings.get('mainframe size', (1100, 700))
wx.Frame.__init__(self,
parent=None,
id=wx.ID_ANY,
title='RIDE',
pos=application.settings.get('mainframe position',
(50, 30)),
size=size,
style=wx.DEFAULT_FRAME_STYLE | wx.SUNKEN_BORDER)
# set Left to Right direction (while we don't have localization)
self.SetLayoutDirection(wx.Layout_LeftToRight)
# self.SetLayoutDirection(wx.Layout_RightToLeft)
self._mgr = aui.AuiManager()
# tell AuiManager to manage this frame
self._mgr.SetManagedWindow(self)
# set frame icon
# self.SetIcon(Icon('widgets/robot.ico')) # Maybe is not needed
# self.SetMinSize(size)
self.SetMinSize(wx.Size(400, 300))
self.ensure_on_screen()
if application.settings.get('mainframe maximized', False):
self.Maximize()
self._application = application
self._controller = controller
self.favicon = Icon(
os.path.join(os.path.dirname(__file__), "..", "widgets",
"robot.ico"), wx.BITMAP_TYPE_ICO, 256, 256)
self.SetIcon(self.favicon) #TODO use SetIcons for all sizes
self._init_ui()
self._plugin_manager = PluginManager(self.notebook)
self._review_dialog = None
self._view_all_tags_dialog = None
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_MOVE, self.OnMove)
self.Bind(wx.EVT_MAXIMIZE, self.OnMaximize)
self.Bind(wx.EVT_DIRCTRL_FILEACTIVATED, self.OnOpenFile)
self.Bind(wx.EVT_TREE_ITEM_RIGHT_CLICK, self.OnMenuOpenFile)
self._subscribe_messages()
wx.CallAfter(self.actions.register_tools) # DEBUG
def _subscribe_messages(self):
for listener, topic in [
(lambda msg: self.SetStatusText('Saved %s' % msg.path), RideSaved),
(lambda msg: self.SetStatusText('Saved all files'), RideSaveAll),
(self._set_label, RideTreeSelection),
(self._show_validation_error, RideInputValidationError),
(self._show_modification_prevented_error,
RideModificationPrevented)
]:
PUBLISHER.subscribe(listener, topic)
def _set_label(self, message):
self.SetTitle(self._create_title(message))
def _create_title(self, message):
title = 'RIDE'
if message:
item = message.item
title += ' - ' + item.datafile.name
if not item.is_modifiable():
title += ' (READ ONLY)'
return title
def _show_validation_error(self, message):
wx.MessageBox(message.message, 'Validation Error', style=wx.ICON_ERROR)
def _show_modification_prevented_error(self, message):
wx.MessageBox("\"%s\" is read only" %
message.controller.datafile_controller.filename,
"Modification prevented",
style=wx.ICON_ERROR)
def _init_ui(self):
# self._mgr.AddPane(wx.Panel(self), aui.AuiPaneInfo().CenterPane())
##### self.splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
# self._mgr.AddPane(wx.Panel(self), aui.AuiPaneInfo().CenterPane())
# set up default notebook style
self._notebook_style = aui.AUI_NB_DEFAULT_STYLE | \
aui.AUI_NB_TAB_EXTERNAL_MOVE | wx.NO_BORDER
# TODO self._notebook_theme = 0 (allow to select themes for notebooks)
# self.notebook = NoteBook(self.splitter, self._application,
# self._notebook_style)
self.notebook = NoteBook(self, self._application, self._notebook_style)
self._mgr.AddPane(
self.notebook,
aui.AuiPaneInfo().Name("notebook_editors").CenterPane().PaneBorder(
False))
################ Test
# self._mgr.AddPane(self.CreateTextCtrl(),
# aui.AuiPaneInfo().Name("text_content").
# CenterPane().Hide().MinimizeButton(True))
#
# self._mgr.AddPane(self.CreateHTMLCtrl(),
# aui.AuiPaneInfo().Name("html_content").
# CenterPane().Hide().MinimizeButton(True))
#
# self._mgr.AddPane(self.CreateNotebook(),
# aui.AuiPaneInfo().Name("notebook_content").
# CenterPane().PaneBorder(False))
####################
# self._mgr.AddPane(self.CreateSizeReportCtrl(), aui.AuiPaneInfo().
# Name("test1").Caption(
# "Pane Caption").Top().MinimizeButton(True))
mb = MenuBar(self)
self.toolbar = ToolBar(self)
self.toolbar.SetMinSize(wx.Size(100, 60))
# self.SetToolBar(self.toolbar.GetToolBar())
self._mgr.AddPane(
self.toolbar,
aui.AuiPaneInfo().Name("maintoolbar").ToolbarPane().Top())
self.actions = ActionRegisterer(self._mgr, mb, self.toolbar,
ShortcutRegistry(self))
"""
##### Test
tb3 = self.testToolbar()
self._mgr.AddPane(tb3,
aui.AuiPaneInfo().Name("tb3").Caption("Toolbar 3").
ToolbarPane().Top().Row(1).Position(1))
##### End Test
"""
# self._mgr.AddPane(self.CreateTreeControl(),
# aui.AuiPaneInfo().Name("tree_content").
# CenterPane().Hide().MinimizeButton(True))
###### self.tree = Tree(self.splitter, self.actions, self._application.settings)
self.tree = Tree(self, self.actions, self._application.settings)
#self.tree.SetMinSize(wx.Size(100, 200))
self.tree.SetMinSize(wx.Size(120, 200))
self._mgr.AddPane(
self.tree,
aui.AuiPaneInfo().Name("tree_content").Caption(
"Test Suites").LeftDockable(True).CloseButton(False))
# MaximizeButton(True).MinimizeButton(True))
self.actions.register_actions(
ActionInfoCollection(_menudata, self, self.tree))
###### File explorer pane
self.filemgr = wx.GenericDirCtrl(self,
-1,
size=(200, 225),
style=wx.DIRCTRL_3D_INTERNAL)
self.filemgr.SetMinSize(wx.Size(120, 200))
# wx.CallAfter(self.filemgr.SetPath(self.tree.get_selected_datafile()))
self._mgr.AddPane(
self.filemgr,
aui.AuiPaneInfo().Name("file_manager").Caption(
"Files").LeftDockable(True).CloseButton(True))
mb.take_menu_bar_into_use()
#### self.splitter.SetMinimumPaneSize(100)
#### self.splitter.SplitVertically(self.tree, self.notebook, 300)
self.CreateStatusBar()
self.SetIcons(ImageProvider().PROGICONS)
# tell the manager to "commit" all the changes just made
self._mgr.Update()
def testToolbar(self):
#### More testing
prepend_items, append_items = [], []
item = aui.AuiToolBarItem()
item.SetKind(wx.ITEM_SEPARATOR)
append_items.append(item)
item = aui.AuiToolBarItem()
item.SetKind(wx.ITEM_NORMAL)
item.SetId(ID_CustomizeToolbar)
item.SetLabel("Customize...")
append_items.append(item)
tb3 = aui.AuiToolBar(self,
-1,
wx.DefaultPosition,
wx.DefaultSize,
agwStyle=aui.AUI_TB_DEFAULT_STYLE
| aui.AUI_TB_OVERFLOW)
tb3.SetToolBitmapSize(wx.Size(16, 16))
tb3_bmp1 = wx.ArtProvider.GetBitmap(wx.ART_FOLDER, wx.ART_OTHER,
wx.Size(16, 16))
tb3.AddSimpleTool(ID_SampleItem + 16, "Check 1", tb3_bmp1, "Check 1",
aui.ITEM_CHECK)
tb3.AddSimpleTool(ID_SampleItem + 17, "Check 2", tb3_bmp1, "Check 2",
aui.ITEM_CHECK)
tb3.AddSimpleTool(ID_SampleItem + 18, "Check 3", tb3_bmp1, "Check 3",
aui.ITEM_CHECK)
tb3.AddSimpleTool(ID_SampleItem + 19, "Check 4", tb3_bmp1, "Check 4",
aui.ITEM_CHECK)
tb3.AddSeparator()
tb3.AddSimpleTool(ID_SampleItem + 20, "Radio 1", tb3_bmp1, "Radio 1",
aui.ITEM_RADIO)
tb3.AddSimpleTool(ID_SampleItem + 21, "Radio 2", tb3_bmp1, "Radio 2",
aui.ITEM_RADIO)
tb3.AddSimpleTool(ID_SampleItem + 22, "Radio 3", tb3_bmp1, "Radio 3",
aui.ITEM_RADIO)
tb3.AddSeparator()
tb3.AddSimpleTool(ID_SampleItem + 23, "Radio 1 (Group 2)", tb3_bmp1,
"Radio 1 (Group 2)", aui.ITEM_RADIO)
tb3.AddSimpleTool(ID_SampleItem + 24, "Radio 2 (Group 2)", tb3_bmp1,
"Radio 2 (Group 2)", aui.ITEM_RADIO)
tb3.AddSimpleTool(ID_SampleItem + 25, "Radio 3 (Group 2)", tb3_bmp1,
"Radio 3 (Group 2)", aui.ITEM_RADIO)
tb3.SetCustomOverflowItems(prepend_items, append_items)
tb3.Realize()
return tb3
def get_selected_datafile(self):
return self.tree.get_selected_datafile()
def get_selected_datafile_controller(self):
return self.tree.get_selected_datafile_controller()
def OnClose(self, event):
if self._allowed_to_exit():
PUBLISHER.unsubscribe(self._set_label, RideTreeSelection)
RideClosing().publish()
# deinitialize the frame manager
self._mgr.UnInit()
self.Destroy()
else:
wx.CloseEvent.Veto(event)
def OnSize(self, event):
if not self.IsMaximized():
self._application.settings['mainframe maximized'] = False
self._application.settings['mainframe size'] = self.DoGetSize()
event.Skip()
def OnMove(self, event):
# When the window is Iconized, a move event is also raised, but we
# don't want to update the position in the settings file
if not self.IsIconized() and not self.IsMaximized():
self._application.settings['mainframe position'] =\
self.DoGetPosition()
event.Skip()
def OnMaximize(self, event):
self._application.settings['mainframe maximized'] = True
event.Skip()
def OnReleasenotes(self, event):
pass
def _allowed_to_exit(self):
if self.has_unsaved_changes():
ret = wx.MessageBox(
"There are unsaved modifications.\n"
"Do you want to save your changes before "
"exiting?", "Warning", wx.ICON_WARNING | wx.CANCEL | wx.YES_NO)
if ret == wx.CANCEL:
return False
if ret == wx.YES:
self.save()
return True
def has_unsaved_changes(self):
return self._controller.is_dirty()
def OnNewProject(self, event):
if not self.check_unsaved_modifications():
return
NewProjectDialog(self._controller).execute()
self._populate_tree()
def _populate_tree(self):
self.tree.populate(self._controller)
if len(self._controller.data.directory) > 1:
self.filemgr.SelectPath(self._controller.data.source)
try:
self.filemgr.ExpandPath(self._controller.data.source)
except Exception:
pass
self.filemgr.Update()
def OnOpenFile(self, event):
if not self.filemgr:
return
# EVT_DIRCTRL_FILEACTIVATED
from os.path import splitext
robottypes = self._application.settings.get(
'robot types', ['robot', 'resource'
'txt', 'tsv', 'html'])
path = self.filemgr.GetFilePath()
ext = ''
if len(path) > 0:
ext = splitext(path)
ext = ext[1].replace('.', '')
# print("DEBUG: path %s ext %s" % (path, ext))
if len(ext) > 0 and ext in robottypes:
if not self.check_unsaved_modifications():
return
if self.open_suite(path):
return
from robotide.editor import customsourceeditor
customsourceeditor.main(path)
def OnMenuOpenFile(self, event):
if not self.filemgr:
return
# TODO: Use widgets/popupmenu tools
path = self.filemgr.GetFilePath()
if len(path) > 0:
self.OnOpenFile(event)
else:
path = self.filemgr.GetPath()
if not self.check_unsaved_modifications():
return
self.open_suite(path) # It is a directory, do not edit
event.Skip()
def OnOpenTestSuite(self, event):
if not self.check_unsaved_modifications():
return
path = RobotFilePathDialog(self, self._controller,
self._application.settings).execute()
if path:
if self.open_suite(path):
return
from robotide.editor import customsourceeditor
customsourceeditor.main(path)
def check_unsaved_modifications(self):
if self.has_unsaved_changes():
ret = wx.MessageBox(
"There are unsaved modifications.\n"
"Do you want to proceed without saving?", "Warning",
wx.ICON_WARNING | wx.YES_NO)
return ret == wx.YES
return True
def open_suite(self, path):
self._controller.update_default_dir(path)
try:
err = self._controller.load_datafile(path,
LoadProgressObserver(self))
finally:
if isinstance(err, UserWarning):
# raise err # Just leave message in Parser Log
return False
self._populate_tree()
return True
def refresh_datafile(self, item, event):
self.tree.refresh_datafile(item, event)
if self.filemgr:
self.filemgr.ReCreateTree()
def OnOpenDirectory(self, event):
if self.check_unsaved_modifications():
path = wx.DirSelector(message="Choose a directory containing Robot"
" files",
default_path=self._controller.default_dir)
if path:
self.open_suite(path)
def OnSave(self, event):
self.save()
def OnSaveAll(self, event):
self.save_all()
def save_all(self):
self._show_dialog_for_files_without_format()
self._controller.execute(SaveAll())
def save(self, controller=None):
if controller is None:
controller = self.get_selected_datafile_controller()
if controller is not None:
if not controller.has_format():
self._show_dialog_for_files_without_format(controller)
else:
controller.execute(SaveFile())
def _show_dialog_for_files_without_format(self, controller=None):
files_without_format = self._controller.get_files_without_format(
controller)
for f in files_without_format:
self._show_format_dialog_for(f)
def _show_format_dialog_for(self, file_controller_without_format):
InitFileFormatDialog(file_controller_without_format).execute()
def OnExit(self, event):
self.Close()
def OnManagePlugins(self, event):
self._plugin_manager.show(self._application.get_plugins())
def OnViewAllTags(self, event):
if self._view_all_tags_dialog is None:
self._view_all_tags_dialog = ViewAllTagsDialog(
self._controller, self)
self._view_all_tags_dialog.show_dialog()
def OnSearchUnusedKeywords(self, event):
if self._review_dialog is None:
self._review_dialog = ReviewDialog(self._controller, self)
self._review_dialog.show_dialog()
def OnPreferences(self, event):
dlg = PreferenceEditor(self,
"RIDE - Preferences",
self._application.preferences,
style='tree')
# I would prefer that this not be modal, but making it non-
# modal opens up a can of worms. We don't want to have to deal
# with settings getting changed out from under us while the
# dialog is open.
dlg.ShowModal()
dlg.Destroy()
def OnAbout(self, event):
dlg = AboutDialog()
dlg.ShowModal()
dlg.Destroy()
def OnShortcutkeys(self, event):
dialog = ShortcutKeysDialog()
dialog.Show()
def OnReportaProblem(self, event):
wx.LaunchDefaultBrowser("https://github.com/robotframework/RIDE/issues"
"?utf8=%E2%9C%93&q=is%3Aissue+%22search"
"%20your%20problem%22")
def OnUserGuide(self, event):
wx.LaunchDefaultBrowser("http://robotframework.org/robotframework/"
"#user-guide")
def OnWiki(self, event):
wx.LaunchDefaultBrowser("https://github.com/robotframework/RIDE/wiki")
def _has_data(self):
return self._controller.data is not None
def _refresh(self):
self._controller.update_namespace()
# This code is copied from http://wiki.wxpython.org/EnsureFrameIsOnScreen,
# and adapted to fit our code style.
def ensure_on_screen(self):
try:
display_id = wx.Display.GetFromWindow(self)
except NotImplementedError:
display_id = 0
if display_id == -1:
display_id = 0
geometry = wx.Display(display_id).GetGeometry()
position = self.GetPosition()
if position.x < geometry.x:
position.x = geometry.x
if position.y < geometry.y:
position.y = geometry.y
size = self.GetSize()
if size.width > geometry.width:
size.width = geometry.width
position.x = geometry.x
elif position.x + size.width > geometry.x + geometry.width:
position.x = geometry.x + geometry.width - size.width
if size.height > geometry.height:
size.height = geometry.height
position.y = geometry.y
elif position.y + size.height > geometry.y + geometry.height:
position.y = geometry.y + geometry.height - size.height
self.SetPosition(position)
self.SetSize(size)
# DEBUG just some testing
def CreateSizeReportCtrl(self, width=80, height=80):
ctrl = SizeReportCtrl(self, -1, wx.DefaultPosition,
wx.Size(width, height), self._mgr)
return ctrl
class ListEditor(ListEditorBase, RideEventHandler):
__metaclass__ = classmaker()
pass
class RideFrame(wx.Frame, RideEventHandler):
__metaclass__ = classmaker()
def __init__(self, application, controller):
wx.Frame.__init__(self,
parent=None,
title='RIDE',
pos=application.settings.get('mainframe position',
(50, 30)),
size=application.settings.get(
'mainframe size', (1100, 700)))
self.ensure_on_screen()
if application.settings.get('mainframe maximized', False):
self.Maximize()
self._application = application
self._controller = controller
self._init_ui()
self._plugin_manager = PluginManager(self.notebook)
self._review_dialog = None
self._view_all_tags_dialog = None
self.Bind(wx.EVT_CLOSE, self.OnClose)
self.Bind(wx.EVT_SIZE, self.OnSize)
self.Bind(wx.EVT_MOVE, self.OnMove)
self.Bind(wx.EVT_MAXIMIZE, self.OnMaximize)
self._subscribe_messages()
# print("DEBUG: Call Show")
self.Show()
#print("DEBUG: Call register_tools, actions: %s" % self.actions.__repr__())
if PY2:
wx.CallLater(100, self.actions.register_tools) # DEBUG
else:
wx.CallAfter(self.actions.register_tools) # DEBUG
def _subscribe_messages(self):
for listener, topic in [
(lambda msg: self.SetStatusText('Saved %s' % msg.path), RideSaved),
(lambda msg: self.SetStatusText('Saved all files'), RideSaveAll),
(self._set_label, RideTreeSelection),
(self._show_validation_error, RideInputValidationError),
(self._show_modification_prevented_error,
RideModificationPrevented)
]:
PUBLISHER.subscribe(listener, topic)
def _set_label(self, message):
self.SetTitle(self._create_title(message))
def _create_title(self, message):
title = 'RIDE'
if message:
item = message.item
title += ' - ' + item.datafile.name
if not item.is_modifiable():
title += ' (READ ONLY)'
return title
def _show_validation_error(self, message):
wx.MessageBox(message.message, 'Validation Error', style=wx.ICON_ERROR)
def _show_modification_prevented_error(self, message):
wx.MessageBox("\"%s\" is read only" %
message.controller.datafile_controller.filename,
"Modification prevented",
style=wx.ICON_ERROR)
def _init_ui(self):
splitter = wx.SplitterWindow(self, style=wx.SP_LIVE_UPDATE)
self.notebook = NoteBook(splitter, self._application)
mb = MenuBar(self)
self.toolbar = ToolBar(self)
self.actions = ActionRegisterer(mb, self.toolbar,
ShortcutRegistry(self))
self.tree = Tree(splitter, self.actions, self._application.settings)
self.actions.register_actions(
ActionInfoCollection(_menudata, self, self.tree))
mb.take_menu_bar_into_use()
splitter.SetMinimumPaneSize(100)
splitter.SplitVertically(self.tree, self.notebook, 300)
self.CreateStatusBar()
self.SetIcons(ImageProvider().PROGICONS)
def get_selected_datafile(self):
return self.tree.get_selected_datafile()
def get_selected_datafile_controller(self):
return self.tree.get_selected_datafile_controller()
def OnClose(self, event):
if self._allowed_to_exit():
PUBLISHER.unsubscribe(self._set_label, RideTreeSelection)
RideClosing().publish()
self.Destroy()
else:
wx.CloseEvent.Veto(event)
def OnSize(self, event):
if not self.IsMaximized():
self._application.settings['mainframe maximized'] = False
self._application.settings['mainframe size'] = self.MyGetSize()
# DEBUG wxPhoenix .GetSizeTuple()
event.Skip()
def OnMove(self, event):
# When the window is Iconized, a move event is also raised, but we
# don't want to update the position in the settings file
if not self.IsIconized() and not self.IsMaximized():
# DEBUG wxPhoenix writes wx.Point(50, 30) instead of just (50, 30)
self._application.settings['mainframe position'] = \
self.MyGetPosition()
# DEBUG wxPhoenix self.GetPositionTuple()
event.Skip()
def OnMaximize(self, event):
self._application.settings['mainframe maximized'] = True
event.Skip()
def OnReleasenotes(self, event):
pass
def MyGetSize(self):
if wx.VERSION >= (3, 0, 3, ''): # DEBUG wxPhoenix
return self.DoGetSize()
else:
return self.GetSizeTuple()
def MyGetPosition(self):
if wx.VERSION >= (3, 0, 3, ''): # DEBUG wxPhoenix
return self.DoGetPosition()
else:
return self.GetPositionTuple()
def _allowed_to_exit(self):
if self.has_unsaved_changes():
ret = wx.MessageBox(
"There are unsaved modifications.\n"
"Do you want to save your changes before "
"exiting?", "Warning", wx.ICON_WARNING | wx.CANCEL | wx.YES_NO)
if ret == wx.CANCEL:
return False
if ret == wx.YES:
self.save()
return True
def has_unsaved_changes(self):
return self._controller.is_dirty()
def OnNewProject(self, event):
if not self.check_unsaved_modifications():
return
NewProjectDialog(self._controller).execute()
self._populate_tree()
def _populate_tree(self):
self.tree.populate(self._controller)
def OnOpenTestSuite(self, event):
if not self.check_unsaved_modifications():
return
path = RobotFilePathDialog(self, self._controller,
self._application.settings).execute()
if path:
self.open_suite(path)
def check_unsaved_modifications(self):
if self.has_unsaved_changes():
ret = wx.MessageBox(
"There are unsaved modifications.\n"
"Do you want to proceed without saving?", "Warning",
wx.ICON_WARNING | wx.YES_NO)
return ret == wx.YES
return True
def open_suite(self, path):
self._controller.update_default_dir(path)
self._controller.load_datafile(path, LoadProgressObserver(self))
self._populate_tree()
def refresh_datafile(self, item, event):
self.tree.refresh_datafile(item, event)
def OnOpenDirectory(self, event):
if self.check_unsaved_modifications():
if wx.VERSION >= (3, 0, 3, ''): # DEBUG wxPhoenix
path = wx.DirSelector(
message="Choose a directory containing "
"Robot files",
default_path=self._controller.default_dir)
else:
path = wx.DirSelector(message="Choose a directory containing "
"Robot files",
defaultPath=self._controller.default_dir)
if path:
self.open_suite(path)
def OnSave(self, event):
self.save()
def OnSaveAll(self, event):
self.save_all()
def save_all(self):
self._show_dialog_for_files_without_format()
self._controller.execute(SaveAll())
def save(self, controller=None):
if controller is None:
controller = self.get_selected_datafile_controller()
if controller is not None:
if not controller.has_format():
self._show_dialog_for_files_without_format(controller)
else:
controller.execute(SaveFile())
def _show_dialog_for_files_without_format(self, controller=None):
files_without_format = self._controller.get_files_without_format(
controller)
for f in files_without_format:
self._show_format_dialog_for(f)
def _show_format_dialog_for(self, file_controller_without_format):
InitFileFormatDialog(file_controller_without_format).execute()
def OnExit(self, event):
self.Close()
def OnManagePlugins(self, event):
self._plugin_manager.show(self._application.get_plugins())
def OnViewAllTags(self, event):
if self._view_all_tags_dialog is None:
self._view_all_tags_dialog = ViewAllTagsDialog(
self._controller, self)
self._view_all_tags_dialog.show_dialog()
def OnSearchUnusedKeywords(self, event):
if self._review_dialog is None:
self._review_dialog = ReviewDialog(self._controller, self)
self._review_dialog.show_dialog()
def OnPreferences(self, event):
dlg = PreferenceEditor(self,
"RIDE - Preferences",
self._application.preferences,
style='tree')
# I would prefer that this not be modal, but making it non-
# modal opens up a can of worms. We don't want to have to deal
# with settings getting changed out from under us while the
# dialog is open.
dlg.ShowModal()
dlg.Destroy()
def OnAbout(self, event):
dlg = AboutDialog()
dlg.ShowModal()
dlg.Destroy()
def OnShortcutkeys(self, event):
dialog = ShortcutKeysDialog()
dialog.Show()
def OnReportaProblem(self, event):
wx.LaunchDefaultBrowser(
"https://github.com/robotframework/RIDE/issues")
def OnUserGuide(self, event):
wx.LaunchDefaultBrowser("http://robotframework.org/robotframework/"
"#user-guide")
def _has_data(self):
return self._controller.data is not None
def _refresh(self):
self._controller.update_namespace()
# This code is copied from http://wiki.wxpython.org/EnsureFrameIsOnScreen,
# and adapted to fit our code style.
def ensure_on_screen(self):
try:
display_id = wx.Display.GetFromWindow(self)
except NotImplementedError:
display_id = 0
if display_id == -1:
display_id = 0
geometry = wx.Display(display_id).GetGeometry()
position = self.GetPosition()
if position.x < geometry.x:
position.x = geometry.x
if position.y < geometry.y:
position.y = geometry.y
size = self.GetSize()
if size.width > geometry.width:
size.width = geometry.width
position.x = geometry.x
elif position.x + size.width > geometry.x + geometry.width:
position.x = geometry.x + geometry.width - size.width
if size.height > geometry.height:
size.height = geometry.height
position.y = geometry.y
elif position.y + size.height > geometry.y + geometry.height:
position.y = geometry.y + geometry.height - size.height
self.SetPosition(position)
self.SetSize(size)
class SettingEditor(
with_metaclass(classmaker(), wx.Panel, utils.RideEventHandler)):
def __init__(self, parent, controller, plugin, tree):
wx.Panel.__init__(self, parent)
self._controller = controller
self.plugin = plugin
self._datafile = controller.datafile
self._create_controls()
self._tree = tree
self._editing = False
self.plugin.subscribe(self.update_value, RideImportSetting)
def _create_controls(self):
sizer = wx.BoxSizer(wx.HORIZONTAL)
sizer.Add((5, 0))
sizer.Add(
Label(self,
label=self._controller.label,
size=(context.SETTING_LABEL_WIDTH,
context.SETTING_ROW_HEIGTH)))
self._value_display = self._create_value_display()
self.update_value()
self._tooltip = self._get_tooltip()
sizer.Add(self._value_display, 1, wx.EXPAND)
self._add_edit(sizer)
sizer.Add(ButtonWithHandler(self, 'Clear'))
sizer.Layout()
self.SetSizer(sizer)
def _add_edit(self, sizer):
sizer.Add(ButtonWithHandler(self, 'Edit'),
flag=wx.LEFT | wx.RIGHT,
border=5)
def _create_value_display(self):
display = self._value_display_control()
display.Bind(wx.EVT_ENTER_WINDOW, self.OnEnterWindow)
display.Bind(wx.EVT_LEAVE_WINDOW, self.OnLeaveWindow)
display.Bind(wx.EVT_WINDOW_DESTROY, self.OnWindowDestroy)
display.Bind(wx.EVT_MOTION, self.OnDisplayMotion)
return display
def _value_display_control(self):
ctrl = SettingValueDisplay(self)
ctrl.Bind(wx.EVT_LEFT_UP, self.OnLeftUp)
ctrl.Bind(wx.EVT_KEY_DOWN, self.OnKey)
return ctrl
def _get_tooltip(self):
return HtmlPopupWindow(self, (500, 350))
def OnKey(self, event):
self._tooltip.hide()
event.Skip()
def OnDisplayMotion(self, event):
self._tooltip.hide()
def refresh(self, controller):
self._controller = controller
self.update_value()
def refresh_datafile(self, item, event):
self._tree.refresh_datafile(item, event)
def OnEdit(self, event=None):
self._hide_tooltip()
self._editing = True
dlg = self._crete_editor_dialog()
if dlg.ShowModal() == wx.ID_OK:
self._set_value(dlg.get_value(), dlg.get_comment())
self._update_and_notify()
dlg.Destroy()
self._editing = False
def _crete_editor_dialog(self):
dlg_class = EditorDialog(self._controller)
return dlg_class(self._datafile, self._controller, self.plugin)
def _set_value(self, value_list, comment):
self._controller.execute(SetValues(value_list, comment))
def _hide_tooltip(self):
self._stop_popup_timer()
self._tooltip.hide()
def _stop_popup_timer(self):
if hasattr(self, 'popup_timer'):
self.popup_timer.Stop()
def OnEnterWindow(self, event):
if self._mainframe_has_focus():
self.popup_timer = wx.CallLater(500, self.OnPopupTimer, event)
def _mainframe_has_focus(self):
return wx.GetTopLevelParent(self.FindFocus()) == \
wx.GetTopLevelParent(self)
def OnWindowDestroy(self, event):
self._stop_popup_timer()
self._tooltip.hide()
event.Skip()
def OnLeaveWindow(self, event):
self._stop_popup_timer()
self._tooltip.hide()
event.Skip()
def OnPopupTimer(self, event):
_tooltipallowed = False
# TODO This prevents tool tip for ex. Template edit field in wxPhoenix
try: # DEBUG wxPhoenix
_tooltipallowed = self.Parent.tooltip_allowed(self._tooltip)
#_tooltipallowed = self._get_tooltip()
except AttributeError:
# print("DEBUG: There was an attempt to show a Tool Tip.\n")
pass
if _tooltipallowed:
details, title = self._get_details_for_tooltip()
if details:
self._tooltip.set_content(details, title)
self._tooltip.show_at(self._tooltip_position())
def _get_details_for_tooltip(self):
kw = self._controller.keyword_name
return self.plugin.get_keyword_details(kw), kw
def _tooltip_position(self):
ms = wx.GetMouseState()
# ensure that the popup gets focus immediately
return ms.x - 3, ms.y - 3
def OnLeftUp(self, event):
if event.ControlDown() or event.CmdDown():
self._navigate_to_user_keyword()
else:
if self._has_selected_area() and not self._editing:
wx.CallAfter(self.OnEdit, event)
event.Skip()
def _has_selected_area(self):
selection = self._value_display.GetSelection()
if selection is None:
return False
return selection[0] == selection[1]
def _navigate_to_user_keyword(self):
uk = self.plugin.get_user_keyword(self._controller.keyword_name)
if uk:
self._tree.select_user_keyword_node(uk)
def _update_and_notify(self):
self.update_value()
def OnClear(self, event):
self._controller.execute(ClearSetting())
self._update_and_notify()
def update_value(self, event=None):
if self._controller is None:
return
if self._controller.is_set:
self._value_display.set_value(self._controller, self.plugin)
else:
self._value_display.clear()
def get_selected_datafile_controller(self):
return self._controller.datafile_controller
def close(self):
self._controller = None
self.plugin.unsubscribe(self.update_value, RideImportSetting)
def highlight(self, text):
return self._value_display.highlight(text)
def clear_highlight(self):
return self._value_display.clear_highlight()
def contains(self, text):
return self._value_display.contains(text)
class ListEditor(with_metaclass(classmaker(), ListEditorBase,
RideEventHandler)):
pass
