INSTRUCTION
stringlengths 1
46.3k
| RESPONSE
stringlengths 75
80.2k
|
|---|---|
Returns xls workbook object with everything from code_array | def from_code_array(self):
"""Returns xls workbook object with everything from code_array"""
worksheets = []
self._shape2xls(worksheets)
self._code2xls(worksheets)
self._row_heights2xls(worksheets)
self._col_widths2xls(worksheets)
return self.workbook |
Replaces everything in code_array from xls_file | def to_code_array(self):
"""Replaces everything in code_array from xls_file"""
self._xls2shape()
worksheets = self.workbook.sheet_names()
for tab, worksheet_name in enumerate(worksheets):
worksheet = self.workbook.sheet_by_name(worksheet_name)
self._xls2code(worksheet, tab)
self._xls2attributes(worksheet, tab)
self._xls2row_heights(worksheet, tab)
self._xls2col_widths(worksheet, tab) |
Rstrips string for \n and splits string for \t | def _split_tidy(self, string, maxsplit=None):
"""Rstrips string for \n and splits string for \t"""
if maxsplit is None:
return string.rstrip("\n").split("\t")
else:
return string.rstrip("\n").split("\t", maxsplit) |
Asserts pys file version | def _pys_assert_version(self, line):
"""Asserts pys file version"""
if float(line.strip()) > 1.0:
# Abort if file version not supported
msg = _("File version {version} unsupported (>1.0).").format(
version=line.strip())
raise ValueError(msg) |
Writes shape to pys file
Format: <rows>\t<cols>\t<tabs>\n | def _shape2pys(self):
"""Writes shape to pys file
Format: <rows>\t<cols>\t<tabs>\n
"""
shape_line = u"\t".join(map(unicode, self.code_array.shape)) + u"\n"
self.pys_file.write(shape_line) |
Updates shape in code_array | def _pys2shape(self, line):
"""Updates shape in code_array"""
self.code_array.shape = self._get_key(*self._split_tidy(line)) |
Writes code to pys file
Format: <row>\t<col>\t<tab>\t<code>\n | def _code2pys(self):
"""Writes code to pys file
Format: <row>\t<col>\t<tab>\t<code>\n
"""
for key in self.code_array:
key_str = u"\t".join(repr(ele) for ele in key)
code_str = self.code_array(key)
if code_str is not None:
out_str = key_str + u"\t" + code_str + u"\n"
self.pys_file.write(out_str.encode("utf-8")) |
Updates code in pys code_array | def _pys2code(self, line):
"""Updates code in pys code_array"""
row, col, tab, code = self._split_tidy(line, maxsplit=3)
key = self._get_key(row, col, tab)
self.code_array.dict_grid[key] = unicode(code, encoding='utf-8') |
Writes attributes to pys file
Format:
<selection[0]>\t[...]\t<tab>\t<key>\t<value>\t[...]\n | def _attributes2pys(self):
"""Writes attributes to pys file
Format:
<selection[0]>\t[...]\t<tab>\t<key>\t<value>\t[...]\n
"""
# Remove doublettes
purged_cell_attributes = []
purged_cell_attributes_keys = []
for selection, tab, attr_dict in self.code_array.cell_attributes:
if purged_cell_attributes_keys and \
(selection, tab) == purged_cell_attributes_keys[-1]:
purged_cell_attributes[-1][2].update(attr_dict)
else:
purged_cell_attributes_keys.append((selection, tab))
purged_cell_attributes.append([selection, tab, attr_dict])
for selection, tab, attr_dict in purged_cell_attributes:
sel_list = [selection.block_tl, selection.block_br,
selection.rows, selection.cols, selection.cells]
tab_list = [tab]
attr_dict_list = []
for key in attr_dict:
attr_dict_list.append(key)
attr_dict_list.append(attr_dict[key])
if config["font_save_enabled"] and key == 'textfont':
self.fonts_used.append(attr_dict[key])
line_list = map(repr, sel_list + tab_list + attr_dict_list)
self.pys_file.write(u"\t".join(line_list) + u"\n") |
Updates attributes in code_array | def _pys2attributes(self, line):
"""Updates attributes in code_array"""
splitline = self._split_tidy(line)
selection_data = map(ast.literal_eval, splitline[:5])
selection = Selection(*selection_data)
tab = int(splitline[5])
attrs = {}
for col, ele in enumerate(splitline[6:]):
if not (col % 2):
# Odd entries are keys
key = ast.literal_eval(ele)
else:
# Even cols are values
attrs[key] = ast.literal_eval(ele)
self.code_array.cell_attributes.append((selection, tab, attrs)) |
Writes row_heights to pys file
Format: <row>\t<tab>\t<value>\n | def _row_heights2pys(self):
"""Writes row_heights to pys file
Format: <row>\t<tab>\t<value>\n
"""
for row, tab in self.code_array.dict_grid.row_heights:
if row < self.code_array.shape[0] and \
tab < self.code_array.shape[2]:
height = self.code_array.dict_grid.row_heights[(row, tab)]
height_strings = map(repr, [row, tab, height])
self.pys_file.write(u"\t".join(height_strings) + u"\n") |
Updates row_heights in code_array | def _pys2row_heights(self, line):
"""Updates row_heights in code_array"""
# Split with maxsplit 3
split_line = self._split_tidy(line)
key = row, tab = self._get_key(*split_line[:2])
height = float(split_line[2])
shape = self.code_array.shape
try:
if row < shape[0] and tab < shape[2]:
self.code_array.row_heights[key] = height
except ValueError:
pass |
Writes col_widths to pys file
Format: <col>\t<tab>\t<value>\n | def _col_widths2pys(self):
"""Writes col_widths to pys file
Format: <col>\t<tab>\t<value>\n
"""
for col, tab in self.code_array.dict_grid.col_widths:
if col < self.code_array.shape[1] and \
tab < self.code_array.shape[2]:
width = self.code_array.dict_grid.col_widths[(col, tab)]
width_strings = map(repr, [col, tab, width])
self.pys_file.write(u"\t".join(width_strings) + u"\n") |
Updates col_widths in code_array | def _pys2col_widths(self, line):
"""Updates col_widths in code_array"""
# Split with maxsplit 3
split_line = self._split_tidy(line)
key = col, tab = self._get_key(*split_line[:2])
width = float(split_line[2])
shape = self.code_array.shape
try:
if col < shape[1] and tab < shape[2]:
self.code_array.col_widths[key] = width
except ValueError:
pass |
Writes macros to pys file
Format: <macro code line>\n | def _macros2pys(self):
"""Writes macros to pys file
Format: <macro code line>\n
"""
macros = self.code_array.dict_grid.macros
pys_macros = macros.encode("utf-8")
self.pys_file.write(pys_macros) |
Updates macros in code_array | def _pys2macros(self, line):
"""Updates macros in code_array"""
if self.code_array.dict_grid.macros and \
self.code_array.dict_grid.macros[-1] != "\n":
# The last macro line does not end with \n
# Therefore, if not new line is inserted, the codeis broken
self.code_array.dict_grid.macros += "\n"
self.code_array.dict_grid.macros += line.decode("utf-8") |
Writes fonts to pys file | def _fonts2pys(self):
"""Writes fonts to pys file"""
# Get mapping from fonts to fontfiles
system_fonts = font_manager.findSystemFonts()
font_name2font_file = {}
for sys_font in system_fonts:
font_name = font_manager.FontProperties(fname=sys_font).get_name()
if font_name in self.fonts_used:
font_name2font_file[font_name] = sys_font
# Only include fonts that have been used in the attributes
for font_name in font_name2font_file:
# Serialize font
with open(font_name2font_file[font_name]) as fontfile:
font_data = fontfile.read()
ascii_font_data = base64.b64encode(font_data)
# Store font in pys file
font_line_list = [font_name, ascii_font_data]
self.pys_file.write(u"\t".join(font_line_list) + u"\n") |
Updates custom font list | def _pys2fonts(self, line):
"""Updates custom font list"""
font_name, ascii_font_data = self._split_tidy(line)
font_data = base64.b64decode(ascii_font_data)
# Get system font names
system_fonts = font_manager.findSystemFonts()
system_font_names = []
for sys_font in system_fonts:
system_font_names.append(
font_manager.FontProperties(fname=sys_font).get_name()
)
# Use the system font if applicable
if font_name not in system_font_names:
self.code_array.custom_fonts[font_name] = font_data
with open(self.temp_fontdir + os.sep + font_name, "wb") as font_file:
font_file.write(font_data)
with tempfile.NamedTemporaryFile() as fontsconf_tmpfile:
fontsconf_tmpfile_name = fontsconf_tmpfile.name
fontsconf_tmpfile.write(self.temp_fontdir)
os.environ["FONTCONFIG_FILE"] = fontsconf_tmpfile_name |
Replaces everything in pys_file from code_array | def from_code_array(self):
"""Replaces everything in pys_file from code_array"""
for key in self._section2writer:
self.pys_file.write(key)
self._section2writer[key]()
try:
if self.pys_file.aborted:
break
except AttributeError:
# pys_file is not opened via fileio.BZAopen
pass
if config["font_save_enabled"]:
# Clean up fonts used info
self.fonts_used = [] |
Replaces everything in code_array from pys_file | def to_code_array(self):
"""Replaces everything in code_array from pys_file"""
state = None
# Check if version section starts with first line
first_line = True
# Reset pys_file to start to enable multiple calls of this method
self.pys_file.seek(0)
for line in self.pys_file:
if first_line:
# If Version section does not start with first line then
# the file is invalid.
if line == "[Pyspread save file version]\n":
first_line = False
else:
raise ValueError(_("File format unsupported."))
if line in self._section2reader:
state = line
elif state is not None:
self._section2reader[state](line) |
Set editor style | def _style(self):
"""Set editor style"""
self.fold_symbols = 2
"""
Fold symbols
------------
The following styles are pre-defined:
"arrows" Arrow pointing right for contracted folders,
arrow pointing down for expanded
"plusminus" Plus for contracted folders, minus for expanded
"circletree" Like a flattened tree control using circular headers
and curved joins
"squaretree" Like a flattened tree control using square headers
"""
self.faces = {
'times': 'Times',
'mono': 'Courier',
'helv': wx.SystemSettings.GetFont(
wx.SYS_DEFAULT_GUI_FONT).GetFaceName(),
'other': 'new century schoolbook',
'size': 10,
'size2': 8,
}
white = "white"
gray = "#404040"
# Fold circle tree symbol style from demo.py
self.fold_symbol_style = [
(stc.STC_MARKNUM_FOLDEROPEN,
stc.STC_MARK_CIRCLEMINUS, white, gray),
(stc.STC_MARKNUM_FOLDER,
stc.STC_MARK_CIRCLEPLUS, white, gray),
(stc.STC_MARKNUM_FOLDERSUB,
stc.STC_MARK_VLINE, white, gray),
(stc.STC_MARKNUM_FOLDERTAIL,
stc.STC_MARK_LCORNERCURVE, white, gray),
(stc.STC_MARKNUM_FOLDEREND,
stc.STC_MARK_CIRCLEPLUSCONNECTED, white, gray),
(stc.STC_MARKNUM_FOLDEROPENMID,
stc.STC_MARK_CIRCLEMINUSCONNECTED, white, gray),
(stc.STC_MARKNUM_FOLDERMIDTAIL,
stc.STC_MARK_TCORNERCURVE, white, gray),
]
"""
Text styles
-----------
The lexer defines what each style is used for, we just have to define
what each style looks like. The Python style set is adapted from
Scintilla sample property files.
"""
self.text_styles = [
(stc.STC_STYLE_DEFAULT,
"face:%(helv)s,size:%(size)d" % self.faces),
(stc.STC_STYLE_LINENUMBER,
"back:#C0C0C0,face:%(helv)s,size:%(size2)d" % self.faces),
(stc.STC_STYLE_CONTROLCHAR,
"face:%(other)s" % self.faces),
(stc.STC_STYLE_BRACELIGHT,
"fore:#FFFFFF,back:#0000FF,bold"),
(stc.STC_STYLE_BRACEBAD,
"fore:#000000,back:#FF0000,bold"),
# Python styles
# -------------
# Default
(stc.STC_P_DEFAULT,
"fore:#000000,face:%(helv)s,size:%(size)d" % self.faces),
# Comments
(stc.STC_P_COMMENTLINE,
"fore:#007F00,face:%(other)s,size:%(size)d" % self.faces),
# Number
(stc.STC_P_NUMBER,
"fore:#007F7F,size:%(size)d" % self.faces),
# String
(stc.STC_P_STRING,
"fore:#7F007F,face:%(helv)s,size:%(size)d" % self.faces),
# Single quoted string
(stc.STC_P_CHARACTER,
"fore:#7F007F,face:%(helv)s,size:%(size)d" % self.faces),
# Keyword
(stc.STC_P_WORD,
"fore:#00007F,bold,size:%(size)d" % self.faces),
# Triple quotes
(stc.STC_P_TRIPLE,
"fore:#7F0000,size:%(size)d" % self.faces),
# Triple double quotes
(stc.STC_P_TRIPLEDOUBLE,
"fore:#7F0000,size:%(size)d" % self.faces),
# Class name definition
(stc.STC_P_CLASSNAME,
"fore:#0000FF,bold,underline,size:%(size)d" % self.faces),
# Function or method name definition
(stc.STC_P_DEFNAME,
"fore:#007F7F,bold,size:%(size)d" % self.faces),
# Operators
(stc.STC_P_OPERATOR, "bold,size:%(size)d" % self.faces),
# Identifiers
(stc.STC_P_IDENTIFIER,
"fore:#000000,face:%(helv)s,size:%(size)d" % self.faces),
# Comment-blocks
(stc.STC_P_COMMENTBLOCK,
"fore:#7F7F7F,size:%(size)d" % self.faces),
# End of line where string is not closed
(stc.STC_P_STRINGEOL,
"fore:#000000,face:%(mono)s,back:#E0C0E0,eol,size:%(size)d"
% self.faces),
] |
Syntax highlighting while editing | def OnUpdateUI(self, evt):
"""Syntax highlighting while editing"""
# check for matching braces
brace_at_caret = -1
brace_opposite = -1
char_before = None
caret_pos = self.GetCurrentPos()
if caret_pos > 0:
char_before = self.GetCharAt(caret_pos - 1)
style_before = self.GetStyleAt(caret_pos - 1)
# check before
if char_before and chr(char_before) in "[]{}()" and \
style_before == stc.STC_P_OPERATOR:
brace_at_caret = caret_pos - 1
# check after
if brace_at_caret < 0:
char_after = self.GetCharAt(caret_pos)
style_after = self.GetStyleAt(caret_pos)
if char_after and chr(char_after) in "[]{}()" and \
style_after == stc.STC_P_OPERATOR:
brace_at_caret = caret_pos
if brace_at_caret >= 0:
brace_opposite = self.BraceMatch(brace_at_caret)
if brace_at_caret != -1 and brace_opposite == -1:
self.BraceBadLight(brace_at_caret)
else:
self.BraceHighlight(brace_at_caret, brace_opposite) |
When clicked, old and unfold as needed | def OnMarginClick(self, evt):
"""When clicked, old and unfold as needed"""
if evt.GetMargin() == 2:
if evt.GetShift() and evt.GetControl():
self.fold_all()
else:
line_clicked = self.LineFromPosition(evt.GetPosition())
if self.GetFoldLevel(line_clicked) & \
stc.STC_FOLDLEVELHEADERFLAG:
if evt.GetShift():
self.SetFoldExpanded(line_clicked, True)
self.expand(line_clicked, True, True, 1)
elif evt.GetControl():
if self.GetFoldExpanded(line_clicked):
self.SetFoldExpanded(line_clicked, False)
self.expand(line_clicked, False, True, 0)
else:
self.SetFoldExpanded(line_clicked, True)
self.expand(line_clicked, True, True, 100)
else:
self.ToggleFold(line_clicked) |
Folds/unfolds all levels in the editor | def fold_all(self):
"""Folds/unfolds all levels in the editor"""
line_count = self.GetLineCount()
expanding = True
# find out if we are folding or unfolding
for line_num in range(line_count):
if self.GetFoldLevel(line_num) & stc.STC_FOLDLEVELHEADERFLAG:
expanding = not self.GetFoldExpanded(line_num)
break
line_num = 0
while line_num < line_count:
level = self.GetFoldLevel(line_num)
if level & stc.STC_FOLDLEVELHEADERFLAG and \
(level & stc.STC_FOLDLEVELNUMBERMASK) == stc.STC_FOLDLEVELBASE:
if expanding:
self.SetFoldExpanded(line_num, True)
line_num = self.expand(line_num, True)
line_num = line_num - 1
else:
last_child = self.GetLastChild(line_num, -1)
self.SetFoldExpanded(line_num, False)
if last_child > line_num:
self.HideLines(line_num + 1, last_child)
line_num = line_num + 1 |
Multi-purpose expand method from original STC class | def expand(self, line, do_expand, force=False, vislevels=0, level=-1):
"""Multi-purpose expand method from original STC class"""
lastchild = self.GetLastChild(line, level)
line += 1
while line <= lastchild:
if force:
if vislevels > 0:
self.ShowLines(line, line)
else:
self.HideLines(line, line)
elif do_expand:
self.ShowLines(line, line)
if level == -1:
level = self.GetFoldLevel(line)
if level & stc.STC_FOLDLEVELHEADERFLAG:
if force:
self.SetFoldExpanded(line, vislevels - 1)
line = self.expand(line, do_expand, force, vislevels - 1)
else:
expandsub = do_expand and self.GetFoldExpanded(line)
line = self.expand(line, expandsub, force, vislevels - 1)
else:
line += 1
return line |
Called for drawing the background area of each item
Overridden from OwnerDrawnComboBox | def OnDrawBackground(self, dc, rect, item, flags):
"""Called for drawing the background area of each item
Overridden from OwnerDrawnComboBox
"""
# If the item is selected, or its item is even,
# or if we are painting the combo control itself
# then use the default rendering.
if (item & 1 == 0 or flags & (wx.combo.ODCB_PAINTING_CONTROL |
wx.combo.ODCB_PAINTING_SELECTED)):
try:
wx.combo.OwnerDrawnComboBox.OnDrawBackground(self, dc,
rect, item, flags)
finally:
return
# Otherwise, draw every other background with
# different color.
bg_color = get_color(config["label_color"])
dc.SetBrush(wx.Brush(bg_color))
dc.SetPen(wx.Pen(bg_color))
dc.DrawRectangleRect(rect) |
Returns code for given label string
Inverse of get_code
Parameters
----------
label: String
\tLlabel string, field 0 of style tuple | def get_style_code(self, label):
"""Returns code for given label string
Inverse of get_code
Parameters
----------
label: String
\tLlabel string, field 0 of style tuple
"""
for style in self.styles:
if style[0] == label:
return style[1]
msg = _("Label {label} is invalid.").format(label=label)
raise ValueError(msg) |
Returns string label for given code string
Inverse of get_code
Parameters
----------
code: String
\tCode string, field 1 of style tuple | def get_label(self, code):
"""Returns string label for given code string
Inverse of get_code
Parameters
----------
code: String
\tCode string, field 1 of style tuple
"""
for style in self.styles:
if style[1] == code:
return style[0]
msg = _("Code {code} is invalid.").format(code=code)
raise ValueError(msg) |
Returns the height of the items in the popup | def OnMeasureItem(self, item):
"""Returns the height of the items in the popup"""
item_name = self.GetItems()[item]
return icons[item_name].GetHeight() |
Returns the height of the items in the popup | def OnMeasureItemWidth(self, item):
"""Returns the height of the items in the popup"""
item_name = self.GetItems()[item]
return icons[item_name].GetWidth() |
Toggles state to next bitmap | def toggle(self, event):
"""Toggles state to next bitmap"""
if self.state < len(self.bitmap_list) - 1:
self.state += 1
else:
self.state = 0
self.SetBitmapLabel(self.bitmap_list[self.state])
try:
event.Skip()
except AttributeError:
pass
"""For compatibility with toggle buttons"""
setattr(self, "GetToolState", lambda x: self.state) |
Toggle button event handler | def OnToggle(self, event):
"""Toggle button event handler"""
if self.selection_toggle_button.GetValue():
self.entry_line.last_selection = self.entry_line.GetSelection()
self.entry_line.last_selection_string = \
self.entry_line.GetStringSelection()
self.entry_line.last_table = self.main_window.grid.current_table
self.entry_line.Disable()
post_command_event(self, self.EnterSelectionModeMsg)
else:
self.entry_line.Enable()
post_command_event(self, self.GridActionTableSwitchMsg,
newtable=self.entry_line.last_table)
post_command_event(self, self.ExitSelectionModeMsg) |
Event handler for updating the content | def OnContentChange(self, event):
"""Event handler for updating the content"""
self.ignore_changes = True
self.SetValue(u"" if event.text is None else event.text)
self.ignore_changes = False
event.Skip() |
Event handler for grid selection in selection mode adds text | def OnGridSelection(self, event):
"""Event handler for grid selection in selection mode adds text"""
current_table = copy(self.main_window.grid.current_table)
post_command_event(self, self.GridActionTableSwitchMsg,
newtable=self.last_table)
if is_gtk():
try:
wx.Yield()
except:
pass
sel_start, sel_stop = self.last_selection
shape = self.main_window.grid.code_array.shape
selection_string = event.selection.get_access_string(shape,
current_table)
self.Replace(sel_start, sel_stop, selection_string)
self.last_selection = sel_start, sel_start + len(selection_string)
post_command_event(self, self.GridActionTableSwitchMsg,
newtable=current_table) |
Text event method evals the cell and updates the grid | def OnText(self, event):
"""Text event method evals the cell and updates the grid"""
if not self.ignore_changes:
post_command_event(self, self.CodeEntryMsg, code=event.GetString())
self.main_window.grid.grid_renderer.cell_cache.clear()
event.Skip() |
Key event method
* Forces grid update on <Enter> key
* Handles insertion of cell access code | def OnChar(self, event):
"""Key event method
* Forces grid update on <Enter> key
* Handles insertion of cell access code
"""
if not self.ignore_changes:
# Handle special keys
keycode = event.GetKeyCode()
if keycode == 13 and not self.GetStringSelection():
# <Enter> pressed and no selection --> Focus on grid
self.main_window.grid.SetFocus()
# Ignore <Ctrl> + <Enter> and Quote content
if event.ControlDown():
self.SetValue(quote(self.GetValue()))
# Do not process <Enter>
return
elif keycode == 13 and self.GetStringSelection():
# <Enter> pressed and selection
# --> Place cursor at end of selection and clear selection
selection_start, selection_stop = self.Selection
self.SetSelection(selection_stop, selection_stop)
# Do not process <Enter>
return
elif keycode == 9 and jedi is None:
# Ignore the <Tab>
return
elif keycode == 9 and jedi is not None:
# If auto completion library jedi is present
# <Tab> pressed --> show docstring tooltip
tiptext = ""
code = "".join(self.GetValue().split("\n"))
position = self.GetInsertionPoint()
# Get the docstring
code_array = self.parent.parent.parent.grid.code_array
env = code_array.get_globals()
try:
script = jedi.Interpreter(code, [env], line=1,
column=position)
except ValueError:
# Jedi has thrown an error
event.Skip()
return
completions = script.completions()
completes = [completion.complete for completion in completions]
complete = common_start(completes)
if complete and \
not self.GetSelection()[1] > self.GetSelection()[0]:
# There is a non-empty completion
insertion_point = self.GetInsertionPoint()
self.write(complete)
if len(completes) > 1:
self.SetSelection(insertion_point,
insertion_point + len(complete))
words = [completion.name for completion in completions]
docs = []
for completion in completions:
doc = completion.docstring(fast=False)
if not doc and code:
# Is the completion part of a module?
code_segment = \
code[:position+1].split()[-1]
module_name = code_segment.rsplit(".", 1)[0]
try:
module = env[module_name]
doc = getattr(module, completion.name).__doc__
except (KeyError, AttributeError):
pass
if not doc:
name = completion.name
try:
# Is the completion a builtin?
doc = getattr(__builtin__, name).__doc__
except AttributeError:
pass
docs.append(doc)
try:
dws = [": ".join([w, d]) for w, d in zip(words, docs)]
tiptext = "\n \n".join(dws)
except TypeError:
pass
# Cut tiptext length because Tooltip fails for long strings
self.SetToolTip(wx.ToolTip(tiptext[:MAX_TOOLTIP_LENGTH]))
# Do not process <Tab>
return
event.Skip() |
Table changed event handler | def OnTableChanged(self, event):
"""Table changed event handler"""
if hasattr(event, 'updated_cell'):
# Event posted by cell edit widget. Even more up to date
# than the current cell's contents
self.ignore_changes = True
try:
self.SetValue(event.updated_cell)
except TypeError:
# None instead of string present
pass
self.ignore_changes = False
else:
current_cell = self.main_window.grid.actions.cursor
current_cell_code = self.main_window.grid.code_array(current_cell)
if current_cell_code is None:
self.SetValue(u"")
else:
self.SetValue(current_cell_code)
event.Skip() |
Reposition the checkbox | def Reposition(self):
"""Reposition the checkbox"""
rect = self.GetFieldRect(1)
self.safemode_staticbmp.SetPosition((rect.x, rect.y))
self.size_changed = False |
Updates to a new number of tables
Fixes current table if out of bounds.
Parameters
----------
no_tabs: Integer
\tNumber of tables for choice | def change_max(self, no_tabs):
"""Updates to a new number of tables
Fixes current table if out of bounds.
Parameters
----------
no_tabs: Integer
\tNumber of tables for choice
"""
self.no_tabs = no_tabs
if self.GetValue() >= no_tabs:
self.SetValue(no_tabs - 1) |
Conversion function used in getting the value of the control. | def _fromGUI(self, value):
"""
Conversion function used in getting the value of the control.
"""
# One or more of the underlying text control implementations
# issue an intermediate EVT_TEXT when replacing the control's
# value, where the intermediate value is an empty string.
# So, to ensure consistency and to prevent spurious ValueErrors,
# we make the following test, and react accordingly:
#
if value == '':
if not self.IsNoneAllowed():
return 0
else:
return
else:
try:
return int(value)
except ValueError:
if self.IsLongAllowed():
try:
return long(value)
except ValueError:
wx.TextCtrl.SetValue(self, "0")
return 0
else:
raise |
IntCtrl event method that updates the current table | def OnInt(self, event):
"""IntCtrl event method that updates the current table"""
value = event.GetValue()
current_time = time.clock()
if current_time < self.last_change_s + 0.01:
return
self.last_change_s = current_time
self.cursor_pos = wx.TextCtrl.GetInsertionPoint(self) + 1
if event.GetValue() > self.no_tabs - 1:
value = self.no_tabs - 1
self.switching = True
post_command_event(self, self.GridActionTableSwitchMsg, newtable=value)
self.switching = False |
Mouse wheel event handler | def OnMouseWheel(self, event):
"""Mouse wheel event handler"""
# Prevent lost IntCtrl changes
if self.switching:
time.sleep(0.1)
return
value = self.GetValue()
current_time = time.clock()
if current_time < self.last_change_s + 0.01:
return
if event.GetWheelRotation() >= event.GetWheelDelta():
self.SetValue(min(value+1, self.no_tabs-1))
elif event.GetWheelRotation() <= -event.GetWheelDelta():
self.SetValue(max(value-1, 0)) |
Table changed event handler | def OnTableChanged(self, event):
"""Table changed event handler"""
if hasattr(event, 'table'):
self.SetValue(event.table)
wx.TextCtrl.SetInsertionPoint(self, self.cursor_pos)
event.Skip() |
Item selection event handler | def OnItemSelected(self, event):
"""Item selection event handler"""
value = event.m_itemIndex
self.startIndex = value
self.switching = True
post_command_event(self, self.GridActionTableSwitchMsg, newtable=value)
self.switching = False
event.Skip() |
Event handler for grid resizing | def OnResizeGrid(self, event):
"""Event handler for grid resizing"""
shape = min(event.shape[2], 2**30)
self.SetItemCount(shape)
event.Skip() |
Table changed event handler | def OnTableChanged(self, event):
"""Table changed event handler"""
if hasattr(event, 'table'):
self.Select(event.table)
self.EnsureVisible(event.table)
event.Skip() |
Generate a dropIndex.
Process: check self.IsInControl, check self.IsDrag, HitTest,
compare HitTest value
The mouse can end up in 5 different places:
Outside the Control
On itself
Above its starting point and on another item
Below its starting point and on another item
Below its starting point and not on another item | def OnMouseUp(self, event):
"""Generate a dropIndex.
Process: check self.IsInControl, check self.IsDrag, HitTest,
compare HitTest value
The mouse can end up in 5 different places:
Outside the Control
On itself
Above its starting point and on another item
Below its starting point and on another item
Below its starting point and not on another item
"""
if not self.IsInControl: # 1. Outside the control : Do Nothing
self.IsDrag = False
elif self.IsDrag:
if not self.IsDrag:
# In control and is a drag event : Determine Location
self.hitIndex = self.HitTest(event.GetPosition())
self.dropIndex = self.hitIndex[0]
# Drop index indicates where the drop location is;
# what index number
# Determine dropIndex and its validity
# 2. On itself or below control : Do Nothing
if not (self.dropIndex == self.startIndex or
self.dropIndex == -1):
# Now that dropIndex has been established do 3 things
# 1. gather item data
# 2. delete item in list
# 3. insert item & it's data into the list at the new index
# dropList is a list of field values from the list control
dropList = []
thisItem = self.GetItem(self.startIndex)
for x in xrange(self.GetColumnCount()):
dropList.append(
self.GetItem(self.startIndex, x).GetText())
thisItem.SetId(self.dropIndex)
self.DeleteItem(self.startIndex)
self.InsertItem(thisItem)
for x in range(self.GetColumnCount()):
self.SetStringItem(self.dropIndex, x, dropList[x])
# If in control but not a drag event : Do Nothing
self.IsDrag = False
event.Skip() |
Setup title, icon, size, scale, statusbar, main grid | def _set_properties(self):
"""Setup title, icon, size, scale, statusbar, main grid"""
self.set_icon(icons["PyspreadLogo"])
# Without minimum size, initial size is minimum size in wxGTK
self.minSizeSet = False
# Leave save mode
post_command_event(self, self.SafeModeExitMsg) |
Enable menu bar view item checkmarks | def _set_menu_toggles(self):
"""Enable menu bar view item checkmarks"""
toggles = [
(self.main_toolbar, "main_window_toolbar", _("Main toolbar")),
(self.macro_toolbar, "macro_toolbar", _("Macro toolbar")),
(self.macro_panel, "macro_panel", _("Macro panel")),
(self.attributes_toolbar, "attributes_toolbar",
_("Format toolbar")),
(self.find_toolbar, "find_toolbar", _("Find toolbar")),
(self.widget_toolbar, "widget_toolbar", _("Widget toolbar")),
(self.entry_line_panel, "entry_line_panel", _("Entry line")),
(self.table_list_panel, "table_list_panel", _("Table list")),
]
for toolbar, pane_name, toggle_label in toggles:
# Get pane from aui manager
pane = self._mgr.GetPane(pane_name)
# Get menu item to toggle
toggle_id = self.menubar.FindMenuItem(_("View"), toggle_label)
if toggle_id != -1:
# Check may fail if translation is incomplete
toggle_item = self.menubar.FindItemById(toggle_id)
# Adjust toggle to pane visibility
toggle_item.Check(pane.IsShown()) |
Adds widgets to the aui manager and controls the layout | def _do_layout(self):
"""Adds widgets to the aui manager and controls the layout"""
# Set background color for the toolbar via the manager
ap = self._mgr.GetArtProvider()
ap.SetColour(aui.AUI_DOCKART_BACKGROUND_GRADIENT_COLOUR,
get_color(config["background_color"]))
# Add the toolbars to the manager
self._mgr.AddPane(self.main_toolbar, aui.AuiPaneInfo().
Name("main_window_toolbar").
Caption(_("Main toolbar")).
ToolbarPane().Top().Row(0))
self._mgr.AddPane(self.find_toolbar, aui.AuiPaneInfo().
Name("find_toolbar").Caption(_("Find toolbar")).
ToolbarPane().Top().Row(0))
self._mgr.AddPane(self.attributes_toolbar, aui.AuiPaneInfo().
Name("attributes_toolbar").
Caption(_("Format toolbar")).
ToolbarPane().Top().Row(1))
self._mgr.AddPane(self.macro_toolbar, aui.AuiPaneInfo().
Name("macro_toolbar").Caption(_("Macro toolbar")).
Gripper(True).ToolbarPane().Top().Row(1))
self._mgr.AddPane(self.widget_toolbar, aui.AuiPaneInfo().
Name("widget_toolbar").Caption(_("Widget toolbar")).
Gripper(True).ToolbarPane().Top().Row(1))
self._mgr.AddPane(self.entry_line_panel, aui.AuiPaneInfo().
Name("entry_line_panel").Caption(_("Entry line")).
Gripper(False).CenterPane().Top().Row(2).
BestSize(400, 30).PaneBorder(False))
self._mgr.AddPane(self.table_list_panel, aui.AuiPaneInfo().
Name("table_list_panel").Caption(_("Table")).
CenterPane().Left().BestSize(50, 300))
self._mgr.AddPane(self.macro_panel, aui.AuiPaneInfo().
Name("macro_panel").Caption(_("Macro panel")).
Gripper(False).CenterPane().Right().
BestSize(200, 200))
# Load perspective from config
window_layout = config["window_layout"]
if window_layout:
self._mgr.LoadPerspective(window_layout)
# Add the main grid
self._mgr.AddPane(self.grid, aui.AuiPaneInfo().
Name("grid").Caption(_("Main grid")).CentrePane())
# Tell the manager to 'commit' all the changes just made
self._mgr.Update()
self._mgr.GetPane("attributes_toolbar")
self._mgr.Update()
self._set_menu_toggles()
# Set initial size to config value
self.SetInitialSize(config["window_size"])
self.SetMinSize((10, 10))
# TODO: Set window position fix --> different positions for
# different window managers prevent this
self.SetPosition(config["window_position"]) |
Bind events to handlers | def _bind(self):
"""Bind events to handlers"""
handlers = self.handlers
# Main window events
self.Bind(wx.EVT_MOVE, handlers.OnMove)
self.Bind(wx.EVT_SIZE, handlers.OnSize)
self.Bind(self.EVT_CMD_FULLSCREEN, handlers.OnToggleFullscreen)
# Content changed event, adjusts title bar with star
self.Bind(self.EVT_CONTENT_CHANGED, handlers.OnContentChanged)
# Program state events
self.Bind(self.EVT_CMD_TITLE, handlers.OnTitle)
self.Bind(self.EVT_CMD_SAFE_MODE_ENTRY, handlers.OnSafeModeEntry)
self.Bind(self.EVT_CMD_SAFE_MODE_EXIT, handlers.OnSafeModeExit)
self.Bind(wx.EVT_CLOSE, handlers.OnClose)
self.Bind(self.EVT_CMD_CLOSE, handlers.OnClose)
self.Bind(self.EVT_SPELL_CHECK, handlers.OnSpellCheckToggle)
# Preferences events
self.Bind(self.EVT_CMD_PREFERENCES, handlers.OnPreferences)
self.Bind(self.EVT_CMD_NEW_GPG_KEY, handlers.OnNewGpgKey)
# Toolbar toggle events
self.Bind(self.EVT_CMD_MAINTOOLBAR_TOGGLE,
handlers.OnMainToolbarToggle)
self.Bind(self.EVT_CMD_MACROTOOLBAR_TOGGLE,
handlers.OnMacroToolbarToggle)
self.Bind(self.EVT_CMD_WIDGETTOOLBAR_TOGGLE,
handlers.OnWidgetToolbarToggle)
self.Bind(self.EVT_CMD_ATTRIBUTESTOOLBAR_TOGGLE,
handlers.OnAttributesToolbarToggle)
self.Bind(self.EVT_CMD_FIND_TOOLBAR_TOGGLE,
handlers.OnFindToolbarToggle)
self.Bind(self.EVT_CMD_ENTRYLINE_TOGGLE,
handlers.OnEntryLineToggle)
self.Bind(self.EVT_CMD_MACROPANEL_TOGGLE,
handlers.OnMacroPanelToggle)
self.Bind(self.EVT_CMD_TABLELIST_TOGGLE,
handlers.OnTableListToggle)
self.Bind(aui.EVT_AUI_PANE_CLOSE, handlers.OnPaneClose)
# File events
self.Bind(self.EVT_CMD_NEW, handlers.OnNew)
self.Bind(self.EVT_CMD_OPEN, handlers.OnOpen)
self.Bind(self.EVT_CMD_SAVE, handlers.OnSave)
self.Bind(self.EVT_CMD_SAVEAS, handlers.OnSaveAs)
self.Bind(self.EVT_CMD_IMPORT, handlers.OnImport)
self.Bind(self.EVT_CMD_EXPORT, handlers.OnExport)
self.Bind(self.EVT_CMD_EXPORT_PDF, handlers.OnExportPDF)
self.Bind(self.EVT_CMD_APPROVE, handlers.OnApprove)
self.Bind(self.EVT_CMD_CLEAR_GLOBALS, handlers.OnClearGlobals)
# Find events
self.Bind(self.EVT_CMD_FOCUSFIND, handlers.OnFocusFind)
# Format events
self.Bind(self.EVT_CMD_FONTDIALOG, handlers.OnFontDialog)
self.Bind(self.EVT_CMD_TEXTCOLORDIALOG, handlers.OnTextColorDialog)
self.Bind(self.EVT_CMD_BGCOLORDIALOG, handlers.OnBgColorDialog)
# Print events
self.Bind(self.EVT_CMD_PAGE_SETUP, handlers.OnPageSetup)
self.Bind(self.EVT_CMD_PRINT_PREVIEW, handlers.OnPrintPreview)
self.Bind(self.EVT_CMD_PRINT, handlers.OnPrint)
# Edit Events
self.Bind(self.EVT_CMD_SELECT_ALL, handlers.OnSelectAll)
# Clipboard events
self.Bind(self.EVT_CMD_CUT, handlers.OnCut)
self.Bind(self.EVT_CMD_COPY, handlers.OnCopy)
self.Bind(self.EVT_CMD_COPY_RESULT, handlers.OnCopyResult)
self.Bind(self.EVT_CMD_PASTE, handlers.OnPaste)
self.Bind(self.EVT_CMD_PASTE_AS, handlers.OnPasteAs)
# Help events
self.Bind(self.EVT_CMD_MANUAL, handlers.OnManual)
self.Bind(self.EVT_CMD_TUTORIAL, handlers.OnTutorial)
self.Bind(self.EVT_CMD_FAQ, handlers.OnFaq)
self.Bind(self.EVT_CMD_PYTHON_TURORIAL, handlers.OnPythonTutorial)
self.Bind(self.EVT_CMD_DEPENDENCIES, handlers.OnDependencies)
self.Bind(self.EVT_CMD_ABOUT, handlers.OnAbout)
self.Bind(self.EVT_CMD_MACROREPLACE, handlers.OnMacroReplace)
self.Bind(self.EVT_CMD_MACROEXECUTE, handlers.OnMacroExecute)
self.Bind(self.EVT_CMD_MACROLOAD, handlers.OnMacroListLoad)
self.Bind(self.EVT_CMD_MACROSAVE, handlers.OnMacroListSave) |
Sets main window icon to given wx.Bitmap | def set_icon(self, bmp):
"""Sets main window icon to given wx.Bitmap"""
_icon = wx.EmptyIcon()
_icon.CopyFromBitmap(bmp)
self.SetIcon(_icon) |
Main window move event | def OnMove(self, event):
"""Main window move event"""
# Store window position in config
position = self.main_window.GetScreenPositionTuple()
config["window_position"] = repr(position) |
Main window move event | def OnSize(self, event):
"""Main window move event"""
# Store window size in config
size = event.GetSize()
config["window_size"] = repr((size.width, size.height)) |
Fullscreen event handler | def OnToggleFullscreen(self, event):
"""Fullscreen event handler"""
is_full_screen = self.main_window.IsFullScreen()
# Make sure that only the grid is shown in fullscreen mode
if is_full_screen:
try:
self.main_window.grid.SetRowLabelSize(self.row_label_size)
self.main_window.grid.SetColLabelSize(self.col_label_size)
except AttributeError:
pass
# Restore toolbars from before fullscreen mode
try:
self.main_window._mgr.LoadPerspective(self.aui_windowed)
except AttributeError:
pass
else:
# Save the perspective of the AUI manager
self.aui_windowed = self.main_window._mgr.SavePerspective()
# Hide toolbars
for pane in self.main_window._mgr.GetAllPanes():
if pane.name != "grid":
pane.Hide()
self.main_window._mgr.Update()
self.row_label_size = self.main_window.grid.GetRowLabelSize()
self.col_label_size = self.main_window.grid.GetColLabelSize()
self.main_window.grid.SetRowLabelSize(0)
self.main_window.grid.SetColLabelSize(0)
self.main_window.ShowFullScreen(not is_full_screen) |
Titlebar star adjustment event handler | def OnContentChanged(self, event):
"""Titlebar star adjustment event handler"""
self.main_window.grid.update_attribute_toolbar()
title = self.main_window.GetTitle()
if undo.stack().haschanged():
# Put * in front of title
if title[:2] != "* ":
new_title = "* " + title
post_command_event(self.main_window, self.main_window.TitleMsg,
text=new_title)
elif title[:2] == "* ":
# Remove * in front of title
new_title = title[2:]
post_command_event(self.main_window, self.main_window.TitleMsg,
text=new_title) |
Safe mode entry event handler | def OnSafeModeEntry(self, event):
"""Safe mode entry event handler"""
# Enable menu item for leaving safe mode
self.main_window.main_menu.enable_file_approve(True)
self.main_window.grid.Refresh()
event.Skip() |
Safe mode exit event handler | def OnSafeModeExit(self, event):
"""Safe mode exit event handler"""
# Run macros
# self.MainGrid.model.pysgrid.sgrid.execute_macros(safe_mode=False)
# Disable menu item for leaving safe mode
self.main_window.main_menu.enable_file_approve(False)
self.main_window.grid.Refresh()
event.Skip() |
Program exit event handler | def OnClose(self, event):
"""Program exit event handler"""
# If changes have taken place save of old grid
if undo.stack().haschanged():
save_choice = self.interfaces.get_save_request_from_user()
if save_choice is None:
# Cancelled close operation
return
elif save_choice:
# User wants to save content
post_command_event(self.main_window, self.main_window.SaveMsg)
# Save the AUI state
config["window_layout"] = repr(self.main_window._mgr.SavePerspective())
# Uninit the AUI stuff
self.main_window._mgr.UnInit()
# Save config
config.save()
# Close main_window
self.main_window.Destroy()
# Set file mode to 600 to protect GPG passwd a bit
sp = wx.StandardPaths.Get()
pyspreadrc_path = sp.GetUserConfigDir() + "/." + config.config_filename
try:
os.chmod(pyspreadrc_path, 0600)
except OSError:
dummyfile = open(pyspreadrc_path, "w")
dummyfile.close()
os.chmod(pyspreadrc_path, 0600) |
Spell checking toggle event handler | def OnSpellCheckToggle(self, event):
"""Spell checking toggle event handler"""
spelltoolid = self.main_window.main_toolbar.label2id["CheckSpelling"]
self.main_window.main_toolbar.ToggleTool(spelltoolid,
not config["check_spelling"])
config["check_spelling"] = repr(not config["check_spelling"])
self.main_window.grid.grid_renderer.cell_cache.clear()
self.main_window.grid.ForceRefresh() |
Preferences event handler that launches preferences dialog | def OnPreferences(self, event):
"""Preferences event handler that launches preferences dialog"""
preferences = self.interfaces.get_preferences_from_user()
if preferences:
for key in preferences:
if type(config[key]) in (type(u""), type("")):
config[key] = preferences[key]
else:
config[key] = ast.literal_eval(preferences[key])
self.main_window.grid.grid_renderer.cell_cache.clear()
self.main_window.grid.ForceRefresh() |
New GPG key event handler.
Launches GPG choice and creation dialog | def OnNewGpgKey(self, event):
"""New GPG key event handler.
Launches GPG choice and creation dialog
"""
if gnupg is None:
return
if genkey is None:
# gnupg is not present
self.interfaces.display_warning(
_("Python gnupg not found. No key selected."),
_("Key selection failed."))
else:
# gnupg is present
genkey() |
Toggles visibility of given aui pane
Parameters
----------
pane: String
\tPane name | def _toggle_pane(self, pane):
"""Toggles visibility of given aui pane
Parameters
----------
pane: String
\tPane name
"""
if pane.IsShown():
pane.Hide()
else:
pane.Show()
self.main_window._mgr.Update() |
Main window toolbar toggle event handler | def OnMainToolbarToggle(self, event):
"""Main window toolbar toggle event handler"""
self.main_window.main_toolbar.SetGripperVisible(True)
main_toolbar_info = \
self.main_window._mgr.GetPane("main_window_toolbar")
self._toggle_pane(main_toolbar_info)
event.Skip() |
Macro toolbar toggle event handler | def OnMacroToolbarToggle(self, event):
"""Macro toolbar toggle event handler"""
self.main_window.macro_toolbar.SetGripperVisible(True)
macro_toolbar_info = self.main_window._mgr.GetPane("macro_toolbar")
self._toggle_pane(macro_toolbar_info)
event.Skip() |
Widget toolbar toggle event handler | def OnWidgetToolbarToggle(self, event):
"""Widget toolbar toggle event handler"""
self.main_window.widget_toolbar.SetGripperVisible(True)
widget_toolbar_info = self.main_window._mgr.GetPane("widget_toolbar")
self._toggle_pane(widget_toolbar_info)
event.Skip() |
Format toolbar toggle event handler | def OnAttributesToolbarToggle(self, event):
"""Format toolbar toggle event handler"""
self.main_window.attributes_toolbar.SetGripperVisible(True)
attributes_toolbar_info = \
self.main_window._mgr.GetPane("attributes_toolbar")
self._toggle_pane(attributes_toolbar_info)
event.Skip() |
Search toolbar toggle event handler | def OnFindToolbarToggle(self, event):
"""Search toolbar toggle event handler"""
self.main_window.find_toolbar.SetGripperVisible(True)
find_toolbar_info = self.main_window._mgr.GetPane("find_toolbar")
self._toggle_pane(find_toolbar_info)
event.Skip() |
Entry line toggle event handler | def OnEntryLineToggle(self, event):
"""Entry line toggle event handler"""
entry_line_panel_info = \
self.main_window._mgr.GetPane("entry_line_panel")
self._toggle_pane(entry_line_panel_info)
event.Skip() |
Table list toggle event handler | def OnTableListToggle(self, event):
"""Table list toggle event handler"""
table_list_panel_info = \
self.main_window._mgr.GetPane("table_list_panel")
self._toggle_pane(table_list_panel_info)
event.Skip() |
Pane close toggle event handler (via close button) | def OnPaneClose(self, event):
"""Pane close toggle event handler (via close button)"""
toggle_label = event.GetPane().caption
# Get menu item to toggle
menubar = self.main_window.menubar
toggle_id = menubar.FindMenuItem(_("View"), toggle_label)
toggle_item = menubar.FindItemById(toggle_id)
# Adjust toggle to pane visibility
toggle_item.Check(False)
menubar.UpdateMenus()
self.main_window._mgr.Update()
event.Skip() |
New grid event handler | def OnNew(self, event):
"""New grid event handler"""
# If changes have taken place save of old grid
if undo.stack().haschanged():
save_choice = self.interfaces.get_save_request_from_user()
if save_choice is None:
# Cancelled close operation
return
elif save_choice:
# User wants to save content
post_command_event(self.main_window, self.main_window.SaveMsg)
# Get grid dimensions
shape = self.interfaces.get_dimensions_from_user(no_dim=3)
if shape is None:
return
# Set new filepath and post it to the title bar
self.main_window.filepath = None
post_command_event(self.main_window, self.main_window.TitleMsg,
text="pyspread")
# Clear globals
self.main_window.grid.actions.clear_globals_reload_modules()
# Create new grid
post_command_event(self.main_window, self.main_window.GridActionNewMsg,
shape=shape)
# Update TableChoiceIntCtrl
post_command_event(self.main_window, self.main_window.ResizeGridMsg,
shape=shape)
if is_gtk():
try:
wx.Yield()
except:
pass
self.main_window.grid.actions.change_grid_shape(shape)
self.main_window.grid.GetTable().ResetView()
self.main_window.grid.ForceRefresh()
# Display grid creation in status bar
msg = _("New grid with dimensions {dim} created.").format(dim=shape)
post_command_event(self.main_window, self.main_window.StatusBarMsg,
text=msg)
self.main_window.grid.ForceRefresh()
if is_gtk():
try:
wx.Yield()
except:
pass
# Update undo stack savepoint and clear undo stack
undo.stack().clear()
undo.stack().savepoint()
# Update content changed state
try:
post_command_event(self.main_window, self.ContentChangedMsg)
except TypeError:
# The main window does not exist any more
pass |
File open event handler | def OnOpen(self, event):
"""File open event handler"""
# If changes have taken place save of old grid
if undo.stack().haschanged():
save_choice = self.interfaces.get_save_request_from_user()
if save_choice is None:
# Cancelled close operation
return
elif save_choice:
# User wants to save content
post_command_event(self.main_window, self.main_window.SaveMsg)
# Get filepath from user
f2w = get_filetypes2wildcards(
["pys", "pysu", "xls", "xlsx", "ods", "all"])
filetypes = f2w.keys()
wildcards = f2w.values()
wildcard = "|".join(wildcards)
message = _("Choose file to open.")
style = wx.OPEN
default_filetype = config["default_open_filetype"]
try:
default_filterindex = filetypes.index(default_filetype)
except ValueError:
# Be graceful if the user has entered an unkown filetype
default_filterindex = 0
get_fp_fidx = self.interfaces.get_filepath_findex_from_user
filepath, filterindex = get_fp_fidx(wildcard, message, style,
filterindex=default_filterindex)
if filepath is None:
return
filetype = filetypes[filterindex]
# Change the main window filepath state
self.main_window.filepath = filepath
# Load file into grid
post_command_event(self.main_window,
self.main_window.GridActionOpenMsg,
attr={"filepath": filepath, "filetype": filetype})
# Set Window title to new filepath
title_text = filepath.split("/")[-1] + " - pyspread"
post_command_event(self.main_window,
self.main_window.TitleMsg, text=title_text)
self.main_window.grid.ForceRefresh()
if is_gtk():
try:
wx.Yield()
except:
pass
# Update savepoint and clear the undo stack
undo.stack().clear()
undo.stack().savepoint()
# Update content changed state
try:
post_command_event(self.main_window, self.ContentChangedMsg)
except TypeError:
# The main window does not exist any more
pass |
File save event handler | def OnSave(self, event):
"""File save event handler"""
try:
filetype = event.attr["filetype"]
except (KeyError, AttributeError):
filetype = None
filepath = self.main_window.filepath
if filepath is None:
filetype = config["default_save_filetype"]
if filetype is None:
f2w = get_filetypes2wildcards(["pys", "pysu", "xls", "all"])
__filetypes = f2w.keys()
# Check if the file extension matches any valid save filetype
for __filetype in __filetypes:
if splitext(filepath)[-1][1:] == __filetype:
filetype = __filetype
break
# If there is no filepath or no filetype is found then jump to save as
if self.main_window.filepath is None or filetype is None:
post_command_event(self.main_window,
self.main_window.SaveAsMsg)
return
# Save the grid
post_command_event(self.main_window,
self.main_window.GridActionSaveMsg,
attr={"filepath": self.main_window.filepath,
"filetype": filetype})
# Update undo stack savepoint
undo.stack().savepoint()
# Display file save in status bar
statustext = self.main_window.filepath.split("/")[-1] + " saved."
post_command_event(self.main_window,
self.main_window.StatusBarMsg,
text=statustext) |
File save as event handler | def OnSaveAs(self, event):
"""File save as event handler"""
# Get filepath from user
f2w = get_filetypes2wildcards(["pys", "pysu", "xls", "all"])
filetypes = f2w.keys()
wildcards = f2w.values()
wildcard = "|".join(wildcards)
message = _("Choose filename for saving.")
style = wx.SAVE
default_filetype = config["default_save_filetype"]
try:
default_filterindex = filetypes.index(default_filetype)
except ValueError:
# Be graceful if the user has entered an unkown filetype
default_filterindex = 0
get_fp_fidx = self.interfaces.get_filepath_findex_from_user
filepath, filterindex = get_fp_fidx(wildcard, message, style,
filterindex=default_filterindex)
if filepath is None:
return 0
filetype = filetypes[filterindex]
# Look if path is already present
if os.path.exists(filepath):
if not os.path.isfile(filepath):
# There is a directory with the same path
statustext = _("Directory present. Save aborted.")
post_command_event(self.main_window,
self.main_window.StatusBarMsg,
text=statustext)
return 0
# There is a file with the same path
message = \
_("The file {filepath} is already present.\nOverwrite?")\
.format(filepath=filepath)
short_msg = _("File collision")
if not self.main_window.interfaces.get_warning_choice(message,
short_msg):
statustext = _("File present. Save aborted by user.")
post_command_event(self.main_window,
self.main_window.StatusBarMsg,
text=statustext)
return 0
# Put pys suffix if wildcard choice is 0
if filterindex == 0 and filepath[-4:] != ".pys":
filepath += ".pys"
# Set the filepath state
self.main_window.filepath = filepath
# Set Window title to new filepath
title_text = filepath.split("/")[-1] + " - pyspread"
post_command_event(self.main_window, self.main_window.TitleMsg,
text=title_text)
# Now jump to save
post_command_event(self.main_window, self.main_window.SaveMsg,
attr={"filetype": filetype}) |
File import event handler | def OnImport(self, event):
"""File import event handler"""
# Get filepath from user
wildcards = get_filetypes2wildcards(["csv", "txt"]).values()
wildcard = "|".join(wildcards)
message = _("Choose file to import.")
style = wx.OPEN
filepath, filterindex = \
self.interfaces.get_filepath_findex_from_user(wildcard, message,
style)
if filepath is None:
return
# Get generator of import data
import_data = self.main_window.actions.import_file(filepath,
filterindex)
if import_data is None:
return
# Paste import data to grid
grid = self.main_window.grid
tl_cell = grid.GetGridCursorRow(), grid.GetGridCursorCol()
grid.actions.paste(tl_cell, import_data)
self.main_window.grid.ForceRefresh() |
File export event handler
Currently, only CSV export is supported | def OnExport(self, event):
"""File export event handler
Currently, only CSV export is supported
"""
code_array = self.main_window.grid.code_array
tab = self.main_window.grid.current_table
selection = self.main_window.grid.selection
# Check if no selection is present
selection_bbox = selection.get_bbox()
f2w = get_filetypes2wildcards(["csv", "pdf", "svg"])
filters = f2w.keys()
wildcards = f2w.values()
wildcard = "|".join(wildcards)
if selection_bbox is None:
# No selection --> Use smallest filled area for bottom right edge
maxrow, maxcol, __ = code_array.get_last_filled_cell(tab)
(top, left), (bottom, right) = (0, 0), (maxrow, maxcol)
else:
(top, left), (bottom, right) = selection_bbox
# Generator of row and column keys in correct order
__top = 0 if top is None else top
__bottom = code_array.shape[0] if bottom is None else bottom + 1
__left = 0 if left is None else left
__right = code_array.shape[1] if right is None else right + 1
def data_gen(top, bottom, left, right):
for row in xrange(top, bottom):
yield (code_array[row, col, tab]
for col in xrange(left, right))
data = data_gen(__top, __bottom, __left, __right)
preview_data = data_gen(__top, __bottom, __left, __right)
# Get target filepath from user
# No selection --> Provide svg export of current cell
# if current cell is a matplotlib figure
if selection_bbox is None:
cursor = self.main_window.grid.actions.cursor
figure = code_array[cursor]
if Figure is not None and isinstance(figure, Figure):
wildcard += \
"|" + _("SVG of current cell") + " (*.svg)|*.svg" + \
"|" + _("EPS of current cell") + " (*.eps)|*.eps" + \
"|" + _("PS of current cell") + " (*.ps)|*.ps" + \
"|" + _("PDF of current cell") + " (*.pdf)|*.pdf" + \
"|" + _("PNG of current cell") + " (*.png)|*.png"
filters.append("cell_svg")
filters.append("cell_eps")
filters.append("cell_ps")
filters.append("cell_pdf")
filters.append("cell_png")
message = _("Choose filename for export.")
style = wx.SAVE
path, filterindex = \
self.interfaces.get_filepath_findex_from_user(wildcard, message,
style)
if path is None:
return
# If an single cell is exported then the selection bbox
# has to be changed to the current cell
if filters[filterindex].startswith("cell_"):
data = figure
# Export file
# -----------
self.main_window.actions.export_file(path, filters[filterindex], data,
preview_data) |
Export PDF event handler | def OnExportPDF(self, event):
"""Export PDF event handler"""
wildcards = get_filetypes2wildcards(["pdf"]).values()
if not wildcards:
return
wildcard = "|".join(wildcards)
# Get filepath from user
message = _("Choose file path for PDF export.")
style = wx.SAVE
filepath, filterindex = \
self.interfaces.get_filepath_findex_from_user(wildcard, message,
style)
if filepath is None:
return
self.main_window.actions.export_cairo(filepath, "pdf")
event.Skip() |
File approve event handler | def OnApprove(self, event):
"""File approve event handler"""
if not self.main_window.safe_mode:
return
msg = _(u"You are going to approve and trust a file that\n"
u"you have not created yourself.\n"
u"After proceeding, the file is executed.\n \n"
u"It may harm your system as any program can.\n"
u"Please check all cells thoroughly before\nproceeding.\n \n"
u"Proceed and sign this file as trusted?")
short_msg = _("Security warning")
if self.main_window.interfaces.get_warning_choice(msg, short_msg):
# Leave safe mode
self.main_window.grid.actions.leave_safe_mode()
# Display safe mode end in status bar
statustext = _("Safe mode deactivated.")
post_command_event(self.main_window, self.main_window.StatusBarMsg,
text=statustext) |
Clear globals event handler | def OnClearGlobals(self, event):
"""Clear globals event handler"""
msg = _("Deleting globals and reloading modules cannot be undone."
" Proceed?")
short_msg = _("Really delete globals and modules?")
choice = self.main_window.interfaces.get_warning_choice(msg, short_msg)
if choice:
self.main_window.grid.actions.clear_globals_reload_modules()
statustext = _("Globals cleared and base modules reloaded.")
post_command_event(self.main_window, self.main_window.StatusBarMsg,
text=statustext) |
Page setup handler for printing framework | def OnPageSetup(self, event):
"""Page setup handler for printing framework"""
print_data = self.main_window.print_data
new_print_data = \
self.main_window.interfaces.get_print_setup(print_data)
self.main_window.print_data = new_print_data |
Returns selection bounding box or visible area | def _get_print_area(self):
"""Returns selection bounding box or visible area"""
# Get print area from current selection
selection = self.main_window.grid.selection
print_area = selection.get_bbox()
# If there is no selection use the visible area on the screen
if print_area is None:
print_area = self.main_window.grid.actions.get_visible_area()
return print_area |
Print event handler | def OnPrint(self, event):
"""Print event handler"""
print_area = self._get_print_area()
print_data = self.main_window.print_data
self.main_window.actions.printout(print_area, print_data) |
Clipboard cut event handler | def OnCut(self, event):
"""Clipboard cut event handler"""
entry_line = \
self.main_window.entry_line_panel.entry_line_panel.entry_line
if wx.Window.FindFocus() != entry_line:
selection = self.main_window.grid.selection
with undo.group(_("Cut")):
data = self.main_window.actions.cut(selection)
self.main_window.clipboard.set_clipboard(data)
self.main_window.grid.ForceRefresh()
else:
entry_line.Cut()
event.Skip() |
Clipboard copy event handler | def OnCopy(self, event):
"""Clipboard copy event handler"""
focus = self.main_window.FindFocus()
if isinstance(focus, wx.TextCtrl):
# Copy selection from TextCtrl if in focus
focus.Copy()
else:
selection = self.main_window.grid.selection
data = self.main_window.actions.copy(selection)
self.main_window.clipboard.set_clipboard(data)
event.Skip() |
Clipboard copy results event handler | def OnCopyResult(self, event):
"""Clipboard copy results event handler"""
selection = self.main_window.grid.selection
data = self.main_window.actions.copy_result(selection)
# Check if result is a bitmap
if type(data) is wx._gdi.Bitmap:
# Copy bitmap to clipboard
self.main_window.clipboard.set_clipboard(data, datatype="bitmap")
else:
# Copy string representation of result to clipboard
self.main_window.clipboard.set_clipboard(data, datatype="text")
event.Skip() |
Clipboard paste event handler | def OnPaste(self, event):
"""Clipboard paste event handler"""
data = self.main_window.clipboard.get_clipboard()
focus = self.main_window.FindFocus()
if isinstance(focus, wx.TextCtrl):
# Paste into TextCtrl if in focus
focus.WriteText(data)
else:
# We got a grid selection
key = self.main_window.grid.actions.cursor
with undo.group(_("Paste")):
self.main_window.actions.paste(key, data)
self.main_window.grid.ForceRefresh()
event.Skip() |
Clipboard paste as event handler | def OnPasteAs(self, event):
"""Clipboard paste as event handler"""
data = self.main_window.clipboard.get_clipboard()
key = self.main_window.grid.actions.cursor
with undo.group(_("Paste As...")):
self.main_window.actions.paste_as(key, data)
self.main_window.grid.ForceRefresh()
event.Skip() |
Select all cells event handler | def OnSelectAll(self, event):
"""Select all cells event handler"""
entry_line = \
self.main_window.entry_line_panel.entry_line_panel.entry_line
if wx.Window.FindFocus() != entry_line:
self.main_window.grid.SelectAll()
else:
entry_line.SelectAll() |
Event handler for launching font dialog | def OnFontDialog(self, event):
"""Event handler for launching font dialog"""
# Get current font data from current cell
cursor = self.main_window.grid.actions.cursor
attr = self.main_window.grid.code_array.cell_attributes[cursor]
size, style, weight, font = \
[attr[name] for name in ["pointsize", "fontstyle", "fontweight",
"textfont"]]
current_font = wx.Font(int(size), -1, style, weight, 0, font)
# Get Font from dialog
fontdata = wx.FontData()
fontdata.EnableEffects(True)
fontdata.SetInitialFont(current_font)
dlg = wx.FontDialog(self.main_window, fontdata)
if dlg.ShowModal() == wx.ID_OK:
fontdata = dlg.GetFontData()
font = fontdata.GetChosenFont()
post_command_event(self.main_window, self.main_window.FontMsg,
font=font.FaceName)
post_command_event(self.main_window, self.main_window.FontSizeMsg,
size=font.GetPointSize())
post_command_event(self.main_window, self.main_window.FontBoldMsg,
weight=font.GetWeightString())
post_command_event(self.main_window,
self.main_window.FontItalicsMsg,
style=font.GetStyleString())
if is_gtk():
try:
wx.Yield()
except:
pass
self.main_window.grid.update_attribute_toolbar() |
Event handler for launching text color dialog | def OnTextColorDialog(self, event):
"""Event handler for launching text color dialog"""
dlg = wx.ColourDialog(self.main_window)
# Ensure the full colour dialog is displayed,
# not the abbreviated version.
dlg.GetColourData().SetChooseFull(True)
if dlg.ShowModal() == wx.ID_OK:
# Fetch color data
data = dlg.GetColourData()
color = data.GetColour().GetRGB()
post_command_event(self.main_window, self.main_window.TextColorMsg,
color=color)
dlg.Destroy() |
Macro list load event handler | def OnMacroListLoad(self, event):
"""Macro list load event handler"""
# Get filepath from user
wildcards = get_filetypes2wildcards(["py", "all"]).values()
wildcard = "|".join(wildcards)
message = _("Choose macro file.")
style = wx.OPEN
filepath, filterindex = \
self.interfaces.get_filepath_findex_from_user(wildcard, message,
style)
if filepath is None:
return
# Enter safe mode because macro file could be harmful
post_command_event(self.main_window, self.main_window.SafeModeEntryMsg)
# Load macros from file
self.main_window.actions.open_macros(filepath)
event.Skip() |
Macro list save event handler | def OnMacroListSave(self, event):
"""Macro list save event handler"""
# Get filepath from user
wildcards = get_filetypes2wildcards(["py", "all"]).values()
wildcard = "|".join(wildcards)
message = _("Choose macro file.")
style = wx.SAVE
filepath, filterindex = \
self.interfaces.get_filepath_findex_from_user(wildcard, message,
style)
if filepath is None:
return
# Save macros to file
macros = self.main_window.grid.code_array.macros
self.main_window.actions.save_macros(filepath, macros)
event.Skip() |
Display dependency dialog | def OnDependencies(self, event):
"""Display dependency dialog"""
dlg = DependencyDialog(self.main_window)
dlg.ShowModal()
dlg.Destroy() |
Adds items in data as a submenu to parent | def _add_submenu(self, parent, data):
"""Adds items in data as a submenu to parent"""
for item in data:
obj = item[0]
if obj == wx.Menu:
try:
__, menuname, submenu, menu_id = item
except ValueError:
__, menuname, submenu = item
menu_id = -1
menu = obj()
self._add_submenu(menu, submenu)
if parent == self:
self.menubar.Append(menu, menuname)
else:
parent.AppendMenu(menu_id, menuname, menu)
elif obj == wx.MenuItem:
try:
msgtype, shortcut, helptext, item_id = item[1]
except ValueError:
msgtype, shortcut, helptext = item[1]
item_id = wx.NewId()
try:
style = item[2]
except IndexError:
style = wx.ITEM_NORMAL
menuitem = obj(parent, item_id, shortcut, helptext, style)
self.shortcut2menuitem[shortcut] = menuitem
self.id2menuitem[item_id] = menuitem
parent.AppendItem(menuitem)
self.ids_msgs[item_id] = msgtype
self.parent.Bind(wx.EVT_MENU, self.OnMenu, id=item_id)
elif obj == "Separator":
parent.AppendSeparator()
else:
raise TypeError(_("Menu item unknown")) |
Menu event handler | def OnMenu(self, event):
"""Menu event handler"""
msgtype = self.ids_msgs[event.GetId()]
post_command_event(self.parent, msgtype) |
Menu state update | def OnUpdate(self, event):
"""Menu state update"""
if wx.ID_UNDO in self.id2menuitem:
undo_item = self.id2menuitem[wx.ID_UNDO]
undo_item.Enable(undo.stack().canundo())
if wx.ID_REDO in self.id2menuitem:
redo_item = self.id2menuitem[wx.ID_REDO]
redo_item.Enable(undo.stack().canredo())
event.Skip() |
Enables or disables menu item (for entering/leaving save mode) | def enable_file_approve(self, enable=True):
"""Enables or disables menu item (for entering/leaving save mode)"""
approve_item = self.shortcut2menuitem[_("&Approve file")]
approve_item.Enable(enable) |
Sets widget from code string
Parameters
----------
code: String
\tCode representation of bool value | def set_code(self, code):
"""Sets widget from code string
Parameters
----------
code: String
\tCode representation of bool value
"""
# If string representations of False are in the code
# then it has to be converted explicitly
if code == "False" or code == "0":
code = False
self.SetValue(bool(code)) |
Binds events to handlers | def __bindings(self):
"""Binds events to handlers"""
self.textctrl.Bind(wx.EVT_TEXT, self.OnText)
self.fontbutton.Bind(wx.EVT_BUTTON, self.OnFont)
self.Bind(csel.EVT_COLOURSELECT, self.OnColor) |
Subsets and Splits