Datasets:

kloodia

/

raw_github

like 0

Text color choice event handler

def OnTextColor(self, event): """Text color choice event handler""" color = event.GetValue().GetRGB() post_command_event(self, self.TextColorMsg, color=color)

Text font choice event handler

def OnTextFont(self, event): """Text font choice event handler""" fontchoice_combobox = event.GetEventObject() idx = event.GetInt() try: font_string = fontchoice_combobox.GetString(idx) except AttributeError: font_string = event.GetString() post_command_event(self, self.FontMsg, font=font_string)

Text size combo text event handler

def OnTextSize(self, event): """Text size combo text event handler""" try: size = int(event.GetString()) except Exception: size = get_default_font().GetPointSize() post_command_event(self, self.FontSizeMsg, size=size)

Sets code of cell key, marks grid as changed

def set_code(self, key, code): """Sets code of cell key, marks grid as changed""" old_code = self.grid.code_array(key) try: old_code = unicode(old_code, encoding="utf-8") except TypeError: pass if code == old_code: return if not (old_code is None and not code) and code != old_code: # Mark content as changed post_command_event(self.main_window, self.ContentChangedMsg) # Set cell code self.grid.code_array.__setitem__(key, code)

Returns string quoted code

def quote_code(self, key): """Returns string quoted code """ code = self.grid.code_array(key) quoted_code = quote(code) if quoted_code is not None: self.set_code(key, quoted_code)

Deletes key cell

def delete_cell(self, key): """Deletes key cell""" try: self.code_array.pop(key) except KeyError: pass self.grid.code_array.result_cache.clear()

Returns absolute reference code for key.

def _get_absolute_reference(self, ref_key): """Returns absolute reference code for key.""" key_str = u", ".join(map(str, ref_key)) return u"S[" + key_str + u"]"

Returns absolute reference code for key. Parameters ---------- cursor: 3-tuple of Integer \tCurrent cursor position ref_key: 3-tuple of Integer \tAbsolute reference key

def _get_relative_reference(self, cursor, ref_key): """Returns absolute reference code for key. Parameters ---------- cursor: 3-tuple of Integer \tCurrent cursor position ref_key: 3-tuple of Integer \tAbsolute reference key """ magics = ["X", "Y", "Z"] # mapper takes magic, key, ref_key to build string def get_rel_key_ele(cursor_ele, ref_key_ele): """Returns relative key suffix for given key and reference key""" # cursor is current cursor position # ref_key is absolute target position diff_key_ele = ref_key_ele - cursor_ele if diff_key_ele == 0: return u"" elif diff_key_ele < 0: return u"-" + str(abs(diff_key_ele)) elif diff_key_ele > 0: return u"+" + str(diff_key_ele) else: msg = _("{key} seems to be no Integer") msg = msg.format(key=diff_key_ele) raise ValueError(msg) key_strings = [] for magic, cursor_ele, ref_key_ele in zip(magics, cursor, ref_key): key_strings.append(magic + get_rel_key_ele(cursor_ele, ref_key_ele)) key_string = u", ".join(key_strings) return u"S[" + key_string + u"]"

Appends reference code to cell code. Replaces existing reference. Parameters ---------- key: 3-tuple of Integer \tKey of cell that gets the reference ref_key: 3-tuple of Integer \tKey of cell that is referenced ref_type: Sting in ["absolute", "relative"] \tAn absolute or a relative reference is added

def append_reference_code(self, key, ref_key, ref_type="absolute"): """Appends reference code to cell code. Replaces existing reference. Parameters ---------- key: 3-tuple of Integer \tKey of cell that gets the reference ref_key: 3-tuple of Integer \tKey of cell that is referenced ref_type: Sting in ["absolute", "relative"] \tAn absolute or a relative reference is added """ if ref_type == "absolute": code = self._get_absolute_reference(ref_key) elif ref_type == "relative": code = self._get_relative_reference(key, ref_key) else: raise ValueError(_('ref_type has to be "absolute" or "relative".')) old_code = self.grid.code_array(key) if old_code is None: old_code = u"" if "S" in old_code and old_code[-1] == "]": old_code_left, __ = old_code.rsplit("S", 1) new_code = old_code_left + code else: new_code = old_code + code post_command_event(self.grid.main_window, self.EntryLineMsg, text=new_code) return new_code

Sets cell attr for key cell and mark grid content as changed Parameters ---------- attr: dict \tContains cell attribute keys \tkeys in ["borderwidth_bottom", "borderwidth_right", \t"bordercolor_bottom", "bordercolor_right", \t"bgcolor", "textfont", \t"pointsize", "fontweight", "fontstyle", "textcolor", "underline", \t"strikethrough", "angle", "column-width", "row-height", \t"vertical_align", "justification", "frozen", "merge_area"]

def _set_cell_attr(self, selection, table, attr): """Sets cell attr for key cell and mark grid content as changed Parameters ---------- attr: dict \tContains cell attribute keys \tkeys in ["borderwidth_bottom", "borderwidth_right", \t"bordercolor_bottom", "bordercolor_right", \t"bgcolor", "textfont", \t"pointsize", "fontweight", "fontstyle", "textcolor", "underline", \t"strikethrough", "angle", "column-width", "row-height", \t"vertical_align", "justification", "frozen", "merge_area"] """ # Mark content as changed post_command_event(self.main_window, self.ContentChangedMsg) if selection is not None: self.code_array.cell_attributes.append((selection, table, attr))

Sets attr of current selection to value

def set_attr(self, attr, value, selection=None): """Sets attr of current selection to value""" if selection is None: selection = self.grid.selection if not selection: # Add current cell to selection so that it gets changed selection.cells.append(self.grid.actions.cursor[:2]) attrs = {attr: value} table = self.grid.current_table # Change model self._set_cell_attr(selection, table, attrs)

Sets border attribute by adjusting selection to borders Parameters ---------- attr: String in ["borderwidth", "bordercolor"] \tBorder attribute that shall be changed value: wx.Colour or Integer \tAttribute value dependent on attribute type borders: Iterable over "top", "bottom", "left", "right", "inner" \tSpecifies to which borders of the selection the attr is applied

def set_border_attr(self, attr, value, borders): """Sets border attribute by adjusting selection to borders Parameters ---------- attr: String in ["borderwidth", "bordercolor"] \tBorder attribute that shall be changed value: wx.Colour or Integer \tAttribute value dependent on attribute type borders: Iterable over "top", "bottom", "left", "right", "inner" \tSpecifies to which borders of the selection the attr is applied """ selection = self.grid.selection if not selection: selection.cells.append(self.grid.actions.cursor[:2]) # determine selection for core cells and selection for border cells # Then apply according to inner and outer # A cell is inner iif it is not at the edge of the selection bbox if "inner" in borders: if "top" in borders: adj_selection = selection + (-1, 0) self.set_attr(attr + "_bottom", value, adj_selection) if "bottom" in borders: self.set_attr(attr + "_bottom", value) if "left" in borders: adj_selection = selection + (0, -1) self.set_attr(attr + "_right", value, adj_selection) if "right" in borders: self.set_attr(attr + "_right", value) else: # Adjust selection so that only bounding box edge is in selection bbox_tl, bbox_lr = selection.get_bbox() if "top" in borders: adj_selection = Selection([bbox_tl], [(bbox_tl[0], bbox_lr[1])], [], [], []) + (-1, 0) self.set_attr(attr + "_bottom", value, adj_selection) if "bottom" in borders: adj_selection = Selection([(bbox_lr[0], bbox_tl[1])], [bbox_lr], [], [], []) self.set_attr(attr + "_bottom", value, adj_selection) if "left" in borders: adj_selection = Selection([bbox_tl], [(bbox_lr[0], bbox_tl[1])], [], [], []) + (0, -1) self.set_attr(attr + "_right", value, adj_selection) if "right" in borders: adj_selection = Selection([(bbox_tl[0], bbox_lr[1])], [bbox_lr], [], [], []) self.set_attr(attr + "_right", value, adj_selection)

Toggles an attribute attr for current selection

def toggle_attr(self, attr): """Toggles an attribute attr for current selection""" selection = self.grid.selection # Selection or single cell access? if selection: value = self.get_new_selection_attr_state(selection, attr) else: value = self.get_new_cell_attr_state(self.grid.actions.cursor, attr) # Set the toggled value self.set_attr(attr, value)

Changes frozen state of cell if there is no selection

def change_frozen_attr(self): """Changes frozen state of cell if there is no selection""" # Selections are not supported if self.grid.selection: statustext = _("Freezing selections is not supported.") post_command_event(self.main_window, self.StatusBarMsg, text=statustext) cursor = self.grid.actions.cursor frozen = self.grid.code_array.cell_attributes[cursor]["frozen"] if frozen: # We have an frozen cell that has to be unfrozen # Delete frozen cache content self.grid.code_array.frozen_cache.pop(repr(cursor)) else: # We have an non-frozen cell that has to be frozen # Add frozen cache content res_obj = self.grid.code_array[cursor] self.grid.code_array.frozen_cache[repr(cursor)] = res_obj # Set the new frozen state / code selection = Selection([], [], [], [], [cursor[:2]]) self.set_attr("frozen", not frozen, selection=selection)

Unmerges all cells in unmerge_area

def unmerge(self, unmerge_area, tab): """Unmerges all cells in unmerge_area""" top, left, bottom, right = unmerge_area selection = Selection([(top, left)], [(bottom, right)], [], [], []) attr = {"merge_area": None, "locked": False} self._set_cell_attr(selection, tab, attr)

Merges top left cell with all cells until bottom_right

def merge(self, merge_area, tab): """Merges top left cell with all cells until bottom_right""" top, left, bottom, right = merge_area cursor = self.grid.actions.cursor top_left_code = self.code_array((top, left, cursor[2])) selection = Selection([(top, left)], [(bottom, right)], [], [], []) # Check if the merge area overlaps another merge area error_msg = _("Overlapping merge area at {} prevents merge.") for row in xrange(top, bottom + 1): for col in xrange(left, right + 1): key = row, col, tab if self.code_array.cell_attributes[key]["merge_area"]: post_command_event(self.main_window, self.StatusBarMsg, text=error_msg.format(str(key))) return self.delete_selection(selection) self.set_code((top, left, cursor[2]), top_left_code) attr = {"merge_area": merge_area, "locked": True} self._set_cell_attr(selection, tab, attr) tl_selection = Selection([], [], [], [], [(top, left)]) attr = {"locked": False} self._set_cell_attr(tl_selection, tab, attr)

Merges or unmerges cells that are in the selection bounding box Parameters ---------- selection: Selection object \tSelection for which attr toggle shall be returned

def merge_selected_cells(self, selection): """Merges or unmerges cells that are in the selection bounding box Parameters ---------- selection: Selection object \tSelection for which attr toggle shall be returned """ tab = self.grid.current_table # Get the selection bounding box bbox = selection.get_bbox() if bbox is None: row, col, tab = self.grid.actions.cursor (bb_top, bb_left), (bb_bottom, bb_right) = (row, col), (row, col) else: (bb_top, bb_left), (bb_bottom, bb_right) = bbox merge_area = bb_top, bb_left, bb_bottom, bb_right # Check if top-left cell is already merged cell_attributes = self.grid.code_array.cell_attributes tl_merge_area = cell_attributes[(bb_top, bb_left, tab)]["merge_area"] if tl_merge_area is not None and tl_merge_area[:2] == merge_area[:2]: self.unmerge(tl_merge_area, tab) else: self.merge(merge_area, tab)

Returns new attr cell state for toggles Parameters ---------- key: 3-Tuple \tCell for which attr toggle shall be returned attr_key: Hashable \tAttribute key

def get_new_cell_attr_state(self, key, attr_key): """Returns new attr cell state for toggles Parameters ---------- key: 3-Tuple \tCell for which attr toggle shall be returned attr_key: Hashable \tAttribute key """ cell_attributes = self.grid.code_array.cell_attributes attr_values = self.attr_toggle_values[attr_key] # Map attr_value to next attr_value attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1])) # Return next value from attr_toggle_values value list return attr_map[cell_attributes[key][attr_key]]

Toggles new attr selection state and returns it Parameters ---------- selection: Selection object \tSelection for which attr toggle shall be returned attr_key: Hashable \tAttribute key

def get_new_selection_attr_state(self, selection, attr_key): """Toggles new attr selection state and returns it Parameters ---------- selection: Selection object \tSelection for which attr toggle shall be returned attr_key: Hashable \tAttribute key """ cell_attributes = self.grid.code_array.cell_attributes attr_values = self.attr_toggle_values[attr_key] # Map attr_value to next attr_value attr_map = dict(zip(attr_values, attr_values[1:] + attr_values[:1])) selection_attrs = \ (attr for attr in cell_attributes if attr[0] == selection) attrs = {} for selection_attr in selection_attrs: attrs.update(selection_attr[2]) if attr_key in attrs: return attr_map[attrs[attr_key]] else: # Default next value return self.attr_toggle_values[attr_key][1]

Refreshes a frozen cell

def refresh_frozen_cell(self, key): """Refreshes a frozen cell""" code = self.grid.code_array(key) result = self.grid.code_array._eval_cell(key, code) self.grid.code_array.frozen_cache[repr(key)] = result

Refreshes content of frozen cells that are currently selected If there is no selection, the cell at the cursor is updated. Parameters ---------- selection: Selection, defaults to None \tIf not None then use this selection instead of the grid selection

def refresh_selected_frozen_cells(self, selection=None): """Refreshes content of frozen cells that are currently selected If there is no selection, the cell at the cursor is updated. Parameters ---------- selection: Selection, defaults to None \tIf not None then use this selection instead of the grid selection """ if selection is None: selection = self.grid.selection # Add cursor to empty selection if not selection: selection.cells.append(self.grid.actions.cursor[:2]) cell_attributes = self.grid.code_array.cell_attributes refreshed_keys = [] for attr_selection, tab, attr_dict in cell_attributes: if tab == self.grid.actions.cursor[2] and \ "frozen" in attr_dict and attr_dict["frozen"]: # Only single cells are allowed for freezing skey = attr_selection.cells[0] if skey in selection: key = tuple(list(skey) + [tab]) if key not in refreshed_keys and \ cell_attributes[key]["frozen"]: self.refresh_frozen_cell(key) refreshed_keys.append(key) cell_attributes._attr_cache.clear() cell_attributes._table_cache.clear()

CSV import workflow

def _import_csv(self, path): """CSV import workflow""" # If path is not set, do nothing if not path: return # Get csv info try: dialect, has_header, digest_types, encoding = \ self.main_window.interfaces.get_csv_import_info(path) except IOError: msg = _("Error opening file {filepath}.").format(filepath=path) post_command_event(self.main_window, self.StatusBarMsg, text=msg) return except TypeError: return # Import is aborted or empty return CsvInterface(self.main_window, path, dialect, digest_types, has_header, encoding)

Imports external file Parameters ---------- filepath: String \tPath of import file filterindex: Integer \tIndex for type of file, 0: csv, 1: tab-delimited text file

def import_file(self, filepath, filterindex): """Imports external file Parameters ---------- filepath: String \tPath of import file filterindex: Integer \tIndex for type of file, 0: csv, 1: tab-delimited text file """ # Mark content as changed post_command_event(self.main_window, self.ContentChangedMsg) if filterindex == 0: # CSV import option choice return self._import_csv(filepath) elif filterindex == 1: # TXT import option choice return self._import_txt(filepath) else: msg = _("Unknown import choice {choice}.") msg = msg.format(choice=filterindex) short_msg = _('Error reading CSV file') self.main_window.interfaces.display_warning(msg, short_msg)

CSV export of code_array results Parameters ---------- filepath: String \tPath of export file data: Object \tCode array result object slice, i. e. one object or iterable of \tsuch objects

def _export_csv(self, filepath, data, preview_data): """CSV export of code_array results Parameters ---------- filepath: String \tPath of export file data: Object \tCode array result object slice, i. e. one object or iterable of \tsuch objects """ # Get csv info csv_info = \ self.main_window.interfaces.get_csv_export_info(preview_data) if csv_info is None: return try: dialect, digest_types, has_header = csv_info except TypeError: return # Export CSV file csv_interface = CsvInterface(self.main_window, filepath, dialect, digest_types, has_header) try: csv_interface.write(data) except IOError, err: msg = _("The file {filepath} could not be fully written\n \n" "Error message:\n{msg}") msg = msg.format(filepath=filepath, msg=err) short_msg = _('Error writing CSV file') self.main_window.interfaces.display_warning(msg, short_msg)

Export of single cell that contains a matplotlib figure Parameters ---------- filepath: String \tPath of export file data: Matplotlib Figure \tMatplotlib figure that is eported format: String in ["png", "pdf", "ps", "eps", "svg"]

def _export_figure(self, filepath, data, format): """Export of single cell that contains a matplotlib figure Parameters ---------- filepath: String \tPath of export file data: Matplotlib Figure \tMatplotlib figure that is eported format: String in ["png", "pdf", "ps", "eps", "svg"] """ formats = ["svg", "eps", "ps", "pdf", "png"] assert format in formats data = fig2x(data, format) try: outfile = open(filepath, "wb") outfile.write(data) except IOError, err: msg = _("The file {filepath} could not be fully written\n \n" "Error message:\n{msg}") msg = msg.format(filepath=filepath, msg=err) short_msg = _('Error writing SVG file') self.main_window.interfaces.display_warning(msg, short_msg) finally: outfile.close()

Export data for other applications Parameters ---------- filepath: String \tPath of export file __filter: String \tImport filter data: Object \tCode array result object slice, i. e. one object or iterable of \tsuch objects

def export_file(self, filepath, __filter, data, preview_data=None): """Export data for other applications Parameters ---------- filepath: String \tPath of export file __filter: String \tImport filter data: Object \tCode array result object slice, i. e. one object or iterable of \tsuch objects """ if __filter.startswith("cell_"): self._export_figure(filepath, data, __filter[5:]) elif __filter == "csv": self._export_csv(filepath, data, preview_data=preview_data) elif __filter in ["pdf", "svg"]: self.export_cairo(filepath, __filter)

Returns wx.Rect that is correctly positioned on the print canvas

def get_print_rect(self, grid_rect): """Returns wx.Rect that is correctly positioned on the print canvas""" grid = self.grid rect_x = grid_rect.x - \ grid.GetScrollPos(wx.HORIZONTAL) * grid.GetScrollLineX() rect_y = grid_rect.y - \ grid.GetScrollPos(wx.VERTICAL) * grid.GetScrollLineY() return wx.Rect(rect_x, rect_y, grid_rect.width, grid_rect.height)

Exports grid to the PDF file filepath Parameters ---------- filepath: String \tPath of file to export filetype in ["pdf", "svg"] \tType of file to export

def export_cairo(self, filepath, filetype): """Exports grid to the PDF file filepath Parameters ---------- filepath: String \tPath of file to export filetype in ["pdf", "svg"] \tType of file to export """ if cairo is None: return export_info = \ self.main_window.interfaces.get_cairo_export_info(filetype) if export_info is None: # Dialog has been canceled return top_row = max(0, export_info["top_row"]) bottom_row = min(self.grid.code_array.shape[0] - 1, export_info["bottom_row"]) left_col = max(0, export_info["left_col"]) right_col = min(self.grid.code_array.shape[1] - 1, export_info["right_col"]) first_tab = max(0, export_info["first_tab"]) last_tab = min(self.grid.code_array.shape[2] - 1, export_info["last_tab"]) width = export_info["paper_width"] height = export_info["paper_height"] orientation = export_info["orientation"] if orientation == "landscape": width, height = height, width if filetype == "pdf": surface = cairo.PDFSurface(filepath, width, height) elif filetype == "svg": surface = cairo.SVGSurface(filepath, width, height) else: msg = "Export filetype {filtype} not supported.".format( filetype=filetype) raise ValueError(msg) context = cairo.Context(surface) grid_cairo_renderer = GridCairoRenderer( context, self.code_array, (top_row, bottom_row + 1), (left_col, right_col + 1), (first_tab, last_tab + 1), width, height, orientation, view_frozen=self.grid._view_frozen, ) grid_cairo_renderer.draw() # Finish is required for matplotlib figures surface.finish()

Launch print preview

def print_preview(self, print_area, print_data): """Launch print preview""" if cairo is None: return print_info = \ self.main_window.interfaces.get_cairo_export_info("Print") if print_info is None: # Dialog has been canceled return printout_preview = Printout(self.grid, print_data, print_info) printout_printing = Printout(self.grid, print_data, print_info) preview = wx.PrintPreview(printout_preview, printout_printing, print_data) if not preview.Ok(): # Printout preview failed return pfrm = wx.PreviewFrame(preview, self.main_window, _("Print preview")) pfrm.Initialize() pfrm.SetPosition(self.main_window.GetPosition()) pfrm.SetSize(self.main_window.GetSize()) pfrm.Show(True)

Print out print area See: http://aspn.activestate.com/ASPN/Mail/Message/wxpython-users/3471083

def printout(self, print_area, print_data): """Print out print area See: http://aspn.activestate.com/ASPN/Mail/Message/wxpython-users/3471083 """ print_info = \ self.main_window.interfaces.get_cairo_export_info("Print") if print_info is None: # Dialog has been canceled return pdd = wx.PrintDialogData(print_data) printer = wx.Printer(pdd) printout = Printout(self.grid, print_data, print_info) if printer.Print(self.main_window, printout, True): self.print_data = \ wx.PrintData(printer.GetPrintDialogData().GetPrintData()) printout.Destroy()

Returns code for given key (one cell) Parameters ---------- key: 3-Tuple of Integer \t Cell key

def _get_code(self, key): """Returns code for given key (one cell) Parameters ---------- key: 3-Tuple of Integer \t Cell key """ data = self.grid.code_array(key) self.grid.code_array.result_cache.clear() return data

Returns code from selection in a tab separated string Cells that are not in selection are included as empty. Parameters ---------- selection: Selection object \tSelection of cells in current table that shall be copied getter: Function, defaults to _get_code \tGetter function for copy content delete: Bool \tDeletes all cells inside selection

def copy(self, selection, getter=None, delete=False): """Returns code from selection in a tab separated string Cells that are not in selection are included as empty. Parameters ---------- selection: Selection object \tSelection of cells in current table that shall be copied getter: Function, defaults to _get_code \tGetter function for copy content delete: Bool \tDeletes all cells inside selection """ if getter is None: getter = self._get_code tab = self.grid.current_table selection_bbox = selection.get_bbox() if not selection_bbox: # There is no selection bb_top, bb_left = self.grid.actions.cursor[:2] bb_bottom, bb_right = bb_top, bb_left else: replace_none = self.main_window.grid.actions._replace_bbox_none (bb_top, bb_left), (bb_bottom, bb_right) = \ replace_none(selection.get_bbox()) data = [] for __row in xrange(bb_top, bb_bottom + 1): data.append([]) for __col in xrange(bb_left, bb_right + 1): # Only copy content if cell is in selection or # if there is no selection if (__row, __col) in selection or not selection_bbox: content = getter((__row, __col, tab)) # Delete cell if delete flag is set if delete: try: self.grid.code_array.pop((__row, __col, tab)) except KeyError: pass # Store data if content is None: data[-1].append(u"") else: data[-1].append(content) else: data[-1].append(u"") return "\n".join("\t".join(line) for line in data)

Returns unicode string of result for given key (one cell) Parameters ---------- key: 3-Tuple of Integer \t Cell key

def _get_result_string(self, key): """Returns unicode string of result for given key (one cell) Parameters ---------- key: 3-Tuple of Integer \t Cell key """ row, col, tab = key result_obj = self.grid.code_array[row, col, tab] try: # Numpy object arrays are converted because of numpy repr bug result_obj = result_obj.tolist() except AttributeError: pass return unicode(result_obj)

Returns result If selection consists of one cell only and result is a bitmap then the bitmap is returned. Otherwise the method returns string representations of the result for the given selection in a tab separated string.

def copy_result(self, selection): """Returns result If selection consists of one cell only and result is a bitmap then the bitmap is returned. Otherwise the method returns string representations of the result for the given selection in a tab separated string. """ bbox = selection.get_bbox() if not bbox: # There is no selection bb_top, bb_left = self.grid.actions.cursor[:2] bb_bottom, bb_right = bb_top, bb_left else: # Thereis a selection (bb_top, bb_left), (bb_bottom, bb_right) = bbox if bb_top == bb_bottom and bb_left == bb_right: # We have a single selection tab = self.grid.current_table result = self.grid.code_array[bb_top, bb_left, tab] if isinstance(result, wx._gdi.Bitmap): # The result is a wx.Bitmap. Return it. return result elif Figure is not None and isinstance(result, Figure): # The result is a matplotlib figure # Therefore, a wx.Bitmap is returned key = bb_top, bb_left, tab rect = self.grid.CellToRect(bb_top, bb_left) merged_rect = self.grid.grid_renderer.get_merged_rect( self.grid, key, rect) dpi = float(wx.ScreenDC().GetPPI()[0]) zoom = self.grid.grid_renderer.zoom return fig2bmp(result, merged_rect.width, merged_rect.height, dpi, zoom) # So we have result strings to be returned getter = self._get_result_string return self.copy(selection, getter=getter)

Generator for paste data Can be used in grid.actions.paste

def _get_paste_data_gen(self, key, data): """Generator for paste data Can be used in grid.actions.paste """ if type(data) is wx._gdi.Bitmap: code_str = self.bmp2code(key, data) return [[code_str]] else: return (line.split("\t") for line in data.split("\n"))

Pastes wx.Image into single cell

def img2code(self, key, img): """Pastes wx.Image into single cell""" code_template = \ "wx.ImageFromData({width}, {height}, " + \ "bz2.decompress(base64.b64decode('{data}'))).ConvertToBitmap()" code_alpha_template = \ "wx.ImageFromDataWithAlpha({width}, {height}, " + \ "bz2.decompress(base64.b64decode('{data}')), " + \ "bz2.decompress(base64.b64decode('{alpha}'))).ConvertToBitmap()" data = base64.b64encode(bz2.compress(img.GetData(), 9)) if img.HasAlpha(): alpha = base64.b64encode(bz2.compress(img.GetAlphaData(), 9)) code_str = code_alpha_template.format( width=img.GetWidth(), height=img.GetHeight(), data=data, alpha=alpha) else: code_str = code_template.format(width=img.GetWidth(), height=img.GetHeight(), data=data) return code_str

Pastes data into grid Parameters ---------- key: 2-Tuple of Integer \tTop left cell data: String or wx.Bitmap \tTab separated string of paste data \tor paste data image

def paste(self, key, data): """Pastes data into grid Parameters ---------- key: 2-Tuple of Integer \tTop left cell data: String or wx.Bitmap \tTab separated string of paste data \tor paste data image """ data_gen = self._get_paste_data_gen(key, data) self.grid.actions.paste(key[:2], data_gen, freq=1000) self.main_window.grid.ForceRefresh()

Returns list of lists of obj than has dimensionality dim Parameters ---------- dim: Integer \tDimensionality of obj obj: Object \tIterable object of dimensionality dim

def _get_pasteas_data(self, dim, obj): """Returns list of lists of obj than has dimensionality dim Parameters ---------- dim: Integer \tDimensionality of obj obj: Object \tIterable object of dimensionality dim """ if dim == 0: return [[repr(obj)]] elif dim == 1: return [[repr(o)] for o in obj] elif dim == 2: return [map(repr, o) for o in obj]

Paste and transform data Data may be given as a Python code as well as a tab separated multi-line strings similar to paste.

def paste_as(self, key, data): """Paste and transform data Data may be given as a Python code as well as a tab separated multi-line strings similar to paste. """ def error_msg(err): msg = _("Error evaluating data: ") + str(err) post_command_event(self.main_window, self.StatusBarMsg, text=msg) interfaces = self.main_window.interfaces key = self.main_window.grid.actions.cursor try: obj = ast.literal_eval(data) except (SyntaxError, AttributeError): # This is no Python code so te try to interpret it as paste data try: obj = [map(ast.literal_eval, line.split("\t")) for line in data.split("\n")] except Exception, err: # This must just be text. try: obj = [line.split('\t') for line in data.split('\n')] except Exception, err: # Now I really have no idea error_msg(err) return except ValueError, err: error_msg(err) return parameters = interfaces.get_pasteas_parameters_from_user(obj) if parameters is None: # Dialog aborted return paste_data = self._get_pasteas_data(parameters["dim"], obj) if parameters["transpose"]: paste_data = zip(*paste_data) self.main_window.grid.actions.paste(key, paste_data, freq=1000)

Executes macros and marks grid as changed

def execute_macros(self): """Executes macros and marks grid as changed""" # Mark content as changed post_command_event(self.main_window, self.ContentChangedMsg) (result, err) = self.grid.code_array.execute_macros() # Post event to macro dialog post_command_event(self.main_window, self.MacroErrorMsg, msg=result, err=err)

Loads macros from file and marks grid as changed Parameters ---------- filepath: String \tPath to macro file

def open_macros(self, filepath): """Loads macros from file and marks grid as changed Parameters ---------- filepath: String \tPath to macro file """ try: wx.BeginBusyCursor() self.main_window.grid.Disable() with open(filepath) as macro_infile: # Enter safe mode self.main_window.grid.actions.enter_safe_mode() post_command_event(self.main_window, self.SafeModeEntryMsg) # Mark content as changed post_command_event(self.main_window, self.ContentChangedMsg) macrocode = macro_infile.read() self.grid.code_array.macros += "\n" + macrocode.strip("\n") self.grid.main_window.macro_panel.codetext_ctrl.SetText( self.grid.code_array.macros) except IOError: msg = _("Error opening file {filepath}.").format(filepath=filepath) post_command_event(self.main_window, self.StatusBarMsg, text=msg) return False finally: self.main_window.grid.Enable() wx.EndBusyCursor() # Mark content as changed try: post_command_event(self.main_window, self.ContentChangedMsg) except TypeError: # The main window does not exist any more pass

Saves macros to file Parameters ---------- filepath: String \tPath to macro file macros: String \tMacro code

def save_macros(self, filepath, macros): """Saves macros to file Parameters ---------- filepath: String \tPath to macro file macros: String \tMacro code """ io_error_text = _("Error writing to file {filepath}.") io_error_text = io_error_text.format(filepath=filepath) # Make sure that old macro file does not get lost on abort save tmpfile = filepath + "~" try: wx.BeginBusyCursor() self.main_window.grid.Disable() with open(tmpfile, "w") as macro_outfile: macro_outfile.write(macros) # Move save file from temp file to filepath try: os.rename(tmpfile, filepath) except OSError: # No tmp file present pass except IOError: try: post_command_event(self.main_window, self.StatusBarMsg, text=io_error_text) except TypeError: # The main window does not exist any more pass return False finally: self.main_window.grid.Enable() wx.EndBusyCursor()

Generic help launcher Launches HTMLWindow that shows content of filename or the Internet page with the filename url Parameters ---------- filename: String \thtml file or url

def launch_help(self, helpname, filename): """Generic help launcher Launches HTMLWindow that shows content of filename or the Internet page with the filename url Parameters ---------- filename: String \thtml file or url """ # Set up window position = config["help_window_position"] size = config["help_window_size"] self.help_window = wx.Frame(self.main_window, -1, helpname, position, size) self.help_htmlwindow = wx.html.HtmlWindow(self.help_window, -1, (0, 0), size) self.help_window.Bind(wx.EVT_MOVE, self.OnHelpMove) self.help_window.Bind(wx.EVT_SIZE, self.OnHelpSize) self.help_htmlwindow.Bind(wx.EVT_RIGHT_DOWN, self.OnHelpBack) self.help_htmlwindow.Bind(wx.html.EVT_HTML_LINK_CLICKED, lambda e: self.open_external_links(e)) self.help_htmlwindow.Bind(wx.EVT_MOUSEWHEEL, lambda e: self.zoom_html(e)) # Get help data current_path = os.getcwd() os.chdir(get_help_path()) try: if os.path.isfile(filename): self.help_htmlwindow.LoadFile(filename) else: self.help_htmlwindow.LoadPage(filename) except IOError: self.help_htmlwindow.LoadPage(filename) # Show tutorial window self.help_window.Show() os.chdir(current_path)

Help window move event handler stores position in config

def OnHelpMove(self, event): """Help window move event handler stores position in config""" position = event.GetPosition() config["help_window_position"] = repr((position.x, position.y)) event.Skip()

Help window size event handler stores size in config

def OnHelpSize(self, event): """Help window size event handler stores size in config""" size = event.GetSize() config["help_window_size"] = repr((size.width, size.height)) event.Skip()

Returns a VLCPanel class Parameters ---------- filepath: String \tFile path of video volume: Float, optional \tSound volume

def vlcpanel_factory(filepath, volume=None): """Returns a VLCPanel class Parameters ---------- filepath: String \tFile path of video volume: Float, optional \tSound volume """ vlc_panel_cls = VLCPanel VLCPanel.filepath = filepath if volume is not None: VLCPanel.volume = volume return vlc_panel_cls

Positions and resizes video panel Parameters ---------- rect: 4-tuple of Integer \tRect area of video panel

def SetClientRect(self, rect): """Positions and resizes video panel Parameters ---------- rect: 4-tuple of Integer \tRect area of video panel """ panel_posx = rect[0] + self.grid.GetRowLabelSize() panel_posy = rect[1] + self.grid.GetColLabelSize() panel_scrolled_pos = self.grid.CalcScrolledPosition(panel_posx, panel_posy) # If the scrolled position is inside the grid labels then hide self.SetPosition(panel_scrolled_pos) wx.Panel.SetClientRect(self, wx.Rect(0, 0, rect[2], rect[3])) # Handle videos that are partly visible or that become invisible row_label_size = self.grid.GetRowLabelSize() col_label_size = self.grid.GetColLabelSize() if panel_scrolled_pos[0] < row_label_size or \ panel_scrolled_pos[1] < col_label_size: self.Hide() else: self.Show()

Toggles the video status between play and hold

def OnTogglePlay(self, event): """Toggles the video status between play and hold""" if self.player.get_state() == vlc.State.Playing: self.player.pause() else: self.player.play() event.Skip()

Mouse wheel event handler

def OnMouseWheel(self, event): """Mouse wheel event handler""" if event. ShiftDown(): self.OnShiftVideo(event) else: self.OnAdjustVolume(event)

Shifts through the video

def OnShiftVideo(self, event): """Shifts through the video""" length = self.player.get_length() time = self.player.get_time() if event.GetWheelRotation() < 0: target_time = max(0, time-length/100.0) elif event.GetWheelRotation() > 0: target_time = min(length, time+length/100.0) self.player.set_time(int(target_time))

Changes video volume

def OnAdjustVolume(self, event): """Changes video volume""" self.volume = self.player.audio_get_volume() if event.GetWheelRotation() < 0: self.volume = max(0, self.volume-10) elif event.GetWheelRotation() > 0: self.volume = min(200, self.volume+10) self.player.audio_set_volume(self.volume)

Loads configuration file

def load(self): """Loads configuration file""" # Config files prior to 0.2.4 dor not have config version keys old_config = not self.cfg_file.Exists("config_version") # Reset data self.data.__dict__.update(self.defaults.__dict__) for key in self.defaults.__dict__: if self.cfg_file.Exists(key): setattr(self.data, key, self.cfg_file.Read(key)) # Reset keys that should be reset on version upgrades if old_config or self.version != self.data.config_version: for key in self.reset_on_version_change: setattr(self.data, key, getattr(DefaultConfig(), key)) self.data.config_version = self.version # Delete gpg_key_uid and insert fingerprint key if hasattr(self.data, "gpg_key_uid"): oldkey = "gpg_key_uid" delattr(self.data, oldkey) newkey = "gpg_key_fingerprint" setattr(self.data, newkey, getattr(DefaultConfig(), newkey))

(INTERNAL) New ctypes function binding.

def _Cfunction(name, flags, errcheck, *types): """(INTERNAL) New ctypes function binding. """ if hasattr(dll, name) and name in _Globals: p = ctypes.CFUNCTYPE(*types) f = p((name, dll), flags) if errcheck is not None: f.errcheck = errcheck # replace the Python function # in this module, but only when # running as python -O or -OO if __debug__: _Cfunctions[name] = f else: _Globals[name] = f return f raise NameError('no function %r' % (name,))

Saves configuration file

def save(self): """Saves configuration file""" for key in self.defaults.__dict__: data = getattr(self.data, key) self.cfg_file.Write(key, data)

(INTERNAL) New instance from ctypes.

def _Cobject(cls, ctype): """(INTERNAL) New instance from ctypes. """ o = object.__new__(cls) o._as_parameter_ = ctype return o

(INTERNAL) New wrapper from ctypes.

def _Constructor(cls, ptr=_internal_guard): """(INTERNAL) New wrapper from ctypes. """ if ptr == _internal_guard: raise VLCException("(INTERNAL) ctypes class. You should get references for this class through methods of the LibVLC API.") if ptr is None or ptr == 0: return None return _Cobject(cls, ctypes.c_void_p(ptr))

Errcheck function. Returns a string and frees the original pointer. It assumes the result is a char *.

def string_result(result, func, arguments): """Errcheck function. Returns a string and frees the original pointer. It assumes the result is a char *. """ if result: # make a python string copy s = bytes_to_str(ctypes.string_at(result)) # free original string ptr libvlc_free(result) return s return None

Errcheck function. Returns a function that creates the specified class.

def class_result(classname): """Errcheck function. Returns a function that creates the specified class. """ def wrap_errcheck(result, func, arguments): if result is None: return None return classname(result) return wrap_errcheck

Convert a TrackDescription linked list to a Python list (and release the former).

def track_description_list(head): """Convert a TrackDescription linked list to a Python list (and release the former). """ r = [] if head: item = head while item: item = item.contents r.append((item.id, item.name)) item = item.next try: libvlc_track_description_release(head) except NameError: libvlc_track_description_list_release(head) return r

Convert a ModuleDescription linked list to a Python list (and release the former).

def module_description_list(head): """Convert a ModuleDescription linked list to a Python list (and release the former). """ r = [] if head: item = head while item: item = item.contents r.append((item.name, item.shortname, item.longname, item.help)) item = item.next libvlc_module_description_list_release(head) return r

Sets the LibVLC error status and message for the current thread. Any previous error is overridden. @param fmt: the format string. @param ap: the arguments. @return: a nul terminated string in any case.

def libvlc_vprinterr(fmt, ap): '''Sets the LibVLC error status and message for the current thread. Any previous error is overridden. @param fmt: the format string. @param ap: the arguments. @return: a nul terminated string in any case. ''' f = _Cfunctions.get('libvlc_vprinterr', None) or \ _Cfunction('libvlc_vprinterr', ((1,), (1,),), None, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_void_p) return f(fmt, ap)

Create and initialize a libvlc instance. This functions accept a list of "command line" arguments similar to the main(). These arguments affect the LibVLC instance default configuration. @param argc: the number of arguments (should be 0). @param argv: list of arguments (should be NULL). @return: the libvlc instance or NULL in case of error. @version Arguments are meant to be passed from the command line to LibVLC, just like VLC media player does. The list of valid arguments depends on the LibVLC version, the operating system and platform, and set of available LibVLC plugins. Invalid or unsupported arguments will cause the function to fail (i.e. return NULL). Also, some arguments may alter the behaviour or otherwise interfere with other LibVLC functions. @warning There is absolutely no warranty or promise of forward, backward and cross-platform compatibility with regards to L{libvlc_new}() arguments. We recommend that you do not use them, other than when debugging.

def libvlc_new(argc, argv): '''Create and initialize a libvlc instance. This functions accept a list of "command line" arguments similar to the main(). These arguments affect the LibVLC instance default configuration. @param argc: the number of arguments (should be 0). @param argv: list of arguments (should be NULL). @return: the libvlc instance or NULL in case of error. @version Arguments are meant to be passed from the command line to LibVLC, just like VLC media player does. The list of valid arguments depends on the LibVLC version, the operating system and platform, and set of available LibVLC plugins. Invalid or unsupported arguments will cause the function to fail (i.e. return NULL). Also, some arguments may alter the behaviour or otherwise interfere with other LibVLC functions. @warning There is absolutely no warranty or promise of forward, backward and cross-platform compatibility with regards to L{libvlc_new}() arguments. We recommend that you do not use them, other than when debugging. ''' f = _Cfunctions.get('libvlc_new', None) or \ _Cfunction('libvlc_new', ((1,), (1,),), class_result(Instance), ctypes.c_void_p, ctypes.c_int, ListPOINTER(ctypes.c_char_p)) return f(argc, argv)

Try to start a user interface for the libvlc instance. @param p_instance: the instance. @param name: interface name, or NULL for default. @return: 0 on success, -1 on error.

def libvlc_add_intf(p_instance, name): '''Try to start a user interface for the libvlc instance. @param p_instance: the instance. @param name: interface name, or NULL for default. @return: 0 on success, -1 on error. ''' f = _Cfunctions.get('libvlc_add_intf', None) or \ _Cfunction('libvlc_add_intf', ((1,), (1,),), None, ctypes.c_int, Instance, ctypes.c_char_p) return f(p_instance, name)

Sets the application name. LibVLC passes this as the user agent string when a protocol requires it. @param p_instance: LibVLC instance. @param name: human-readable application name, e.g. "FooBar player 1.2.3". @param http: HTTP User Agent, e.g. "FooBar/1.2.3 Python/2.6.0". @version: LibVLC 1.1.1 or later.

def libvlc_set_user_agent(p_instance, name, http): '''Sets the application name. LibVLC passes this as the user agent string when a protocol requires it. @param p_instance: LibVLC instance. @param name: human-readable application name, e.g. "FooBar player 1.2.3". @param http: HTTP User Agent, e.g. "FooBar/1.2.3 Python/2.6.0". @version: LibVLC 1.1.1 or later. ''' f = _Cfunctions.get('libvlc_set_user_agent', None) or \ _Cfunction('libvlc_set_user_agent', ((1,), (1,), (1,),), None, None, Instance, ctypes.c_char_p, ctypes.c_char_p) return f(p_instance, name, http)

Sets some meta-information about the application. See also L{libvlc_set_user_agent}(). @param p_instance: LibVLC instance. @param id: Java-style application identifier, e.g. "com.acme.foobar". @param version: application version numbers, e.g. "1.2.3". @param icon: application icon name, e.g. "foobar". @version: LibVLC 2.1.0 or later.

def libvlc_set_app_id(p_instance, id, version, icon): '''Sets some meta-information about the application. See also L{libvlc_set_user_agent}(). @param p_instance: LibVLC instance. @param id: Java-style application identifier, e.g. "com.acme.foobar". @param version: application version numbers, e.g. "1.2.3". @param icon: application icon name, e.g. "foobar". @version: LibVLC 2.1.0 or later. ''' f = _Cfunctions.get('libvlc_set_app_id', None) or \ _Cfunction('libvlc_set_app_id', ((1,), (1,), (1,), (1,),), None, None, Instance, ctypes.c_char_p, ctypes.c_char_p, ctypes.c_char_p) return f(p_instance, id, version, icon)

Frees an heap allocation returned by a LibVLC function. If you know you're using the same underlying C run-time as the LibVLC implementation, then you can call ANSI C free() directly instead. @param ptr: the pointer.

def libvlc_free(ptr): '''Frees an heap allocation returned by a LibVLC function. If you know you're using the same underlying C run-time as the LibVLC implementation, then you can call ANSI C free() directly instead. @param ptr: the pointer. ''' f = _Cfunctions.get('libvlc_free', None) or \ _Cfunction('libvlc_free', ((1,),), None, None, ctypes.c_void_p) return f(ptr)

Register for an event notification. @param p_event_manager: the event manager to which you want to attach to. Generally it is obtained by vlc_my_object_event_manager() where my_object is the object you want to listen to. @param i_event_type: the desired event to which we want to listen. @param f_callback: the function to call when i_event_type occurs. @param user_data: user provided data to carry with the event. @return: 0 on success, ENOMEM on error.

def libvlc_event_attach(p_event_manager, i_event_type, f_callback, user_data): '''Register for an event notification. @param p_event_manager: the event manager to which you want to attach to. Generally it is obtained by vlc_my_object_event_manager() where my_object is the object you want to listen to. @param i_event_type: the desired event to which we want to listen. @param f_callback: the function to call when i_event_type occurs. @param user_data: user provided data to carry with the event. @return: 0 on success, ENOMEM on error. ''' f = _Cfunctions.get('libvlc_event_attach', None) or \ _Cfunction('libvlc_event_attach', ((1,), (1,), (1,), (1,),), None, ctypes.c_int, EventManager, ctypes.c_uint, Callback, ctypes.c_void_p) return f(p_event_manager, i_event_type, f_callback, user_data)

Unregister an event notification. @param p_event_manager: the event manager. @param i_event_type: the desired event to which we want to unregister. @param f_callback: the function to call when i_event_type occurs. @param p_user_data: user provided data to carry with the event.

def libvlc_event_detach(p_event_manager, i_event_type, f_callback, p_user_data): '''Unregister an event notification. @param p_event_manager: the event manager. @param i_event_type: the desired event to which we want to unregister. @param f_callback: the function to call when i_event_type occurs. @param p_user_data: user provided data to carry with the event. ''' f = _Cfunctions.get('libvlc_event_detach', None) or \ _Cfunction('libvlc_event_detach', ((1,), (1,), (1,), (1,),), None, None, EventManager, ctypes.c_uint, Callback, ctypes.c_void_p) return f(p_event_manager, i_event_type, f_callback, p_user_data)

Get an event's type name. @param event_type: the desired event.

def libvlc_event_type_name(event_type): '''Get an event's type name. @param event_type: the desired event. ''' f = _Cfunctions.get('libvlc_event_type_name', None) or \ _Cfunction('libvlc_event_type_name', ((1,),), None, ctypes.c_char_p, ctypes.c_uint) return f(event_type)

Gets debugging information about a log message: the name of the VLC module emitting the message and the message location within the source code. The returned module name and file name will be NULL if unknown. The returned line number will similarly be zero if unknown. @param ctx: message context (as passed to the @ref libvlc_log_cb callback). @return: module module name storage (or NULL), file source code file name storage (or NULL), line source code file line number storage (or NULL). @version: LibVLC 2.1.0 or later.

def libvlc_log_get_context(ctx): '''Gets debugging information about a log message: the name of the VLC module emitting the message and the message location within the source code. The returned module name and file name will be NULL if unknown. The returned line number will similarly be zero if unknown. @param ctx: message context (as passed to the @ref libvlc_log_cb callback). @return: module module name storage (or NULL), file source code file name storage (or NULL), line source code file line number storage (or NULL). @version: LibVLC 2.1.0 or later. ''' f = _Cfunctions.get('libvlc_log_get_context', None) or \ _Cfunction('libvlc_log_get_context', ((1,), (2,), (2,), (2,),), None, None, Log_ptr, ListPOINTER(ctypes.c_char_p), ListPOINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_uint)) return f(ctx)

Gets VLC object information about a log message: the type name of the VLC object emitting the message, the object header if any and a temporaly-unique object identifier. This information is mainly meant for B{manual} troubleshooting. The returned type name may be "generic" if unknown, but it cannot be NULL. The returned header will be NULL if unset; in current versions, the header is used to distinguish for VLM inputs. The returned object ID will be zero if the message is not associated with any VLC object. @param ctx: message context (as passed to the @ref libvlc_log_cb callback). @return: name object name storage (or NULL), header object header (or NULL), line source code file line number storage (or NULL). @version: LibVLC 2.1.0 or later.

def libvlc_log_get_object(ctx, id): '''Gets VLC object information about a log message: the type name of the VLC object emitting the message, the object header if any and a temporaly-unique object identifier. This information is mainly meant for B{manual} troubleshooting. The returned type name may be "generic" if unknown, but it cannot be NULL. The returned header will be NULL if unset; in current versions, the header is used to distinguish for VLM inputs. The returned object ID will be zero if the message is not associated with any VLC object. @param ctx: message context (as passed to the @ref libvlc_log_cb callback). @return: name object name storage (or NULL), header object header (or NULL), line source code file line number storage (or NULL). @version: LibVLC 2.1.0 or later. ''' f = _Cfunctions.get('libvlc_log_get_object', None) or \ _Cfunction('libvlc_log_get_object', ((1,), (2,), (2,), (1,),), None, None, Log_ptr, ListPOINTER(ctypes.c_char_p), ListPOINTER(ctypes.c_char_p), ctypes.POINTER(ctypes.c_uint)) return f(ctx, id)

Sets the logging callback for a LibVLC instance. This function is thread-safe: it will wait for any pending callbacks invocation to complete. @param cb: callback function pointer. @param data: opaque data pointer for the callback function @note Some log messages (especially debug) are emitted by LibVLC while is being initialized. These messages cannot be captured with this interface. @warning A deadlock may occur if this function is called from the callback. @param p_instance: libvlc instance. @version: LibVLC 2.1.0 or later.

def libvlc_log_set(cb, data, p_instance): '''Sets the logging callback for a LibVLC instance. This function is thread-safe: it will wait for any pending callbacks invocation to complete. @param cb: callback function pointer. @param data: opaque data pointer for the callback function @note Some log messages (especially debug) are emitted by LibVLC while is being initialized. These messages cannot be captured with this interface. @warning A deadlock may occur if this function is called from the callback. @param p_instance: libvlc instance. @version: LibVLC 2.1.0 or later. ''' f = _Cfunctions.get('libvlc_log_set', None) or \ _Cfunction('libvlc_log_set', ((1,), (1,), (1,),), None, None, Instance, LogCb, ctypes.c_void_p) return f(cb, data, p_instance)

Sets up logging to a file. @param p_instance: libvlc instance. @param stream: FILE pointer opened for writing (the FILE pointer must remain valid until L{libvlc_log_unset}()). @version: LibVLC 2.1.0 or later.

def libvlc_log_set_file(p_instance, stream): '''Sets up logging to a file. @param p_instance: libvlc instance. @param stream: FILE pointer opened for writing (the FILE pointer must remain valid until L{libvlc_log_unset}()). @version: LibVLC 2.1.0 or later. ''' f = _Cfunctions.get('libvlc_log_set_file', None) or \ _Cfunction('libvlc_log_set_file', ((1,), (1,),), None, None, Instance, FILE_ptr) return f(p_instance, stream)

Release a list of module descriptions. @param p_list: the list to be released.

def libvlc_module_description_list_release(p_list): '''Release a list of module descriptions. @param p_list: the list to be released. ''' f = _Cfunctions.get('libvlc_module_description_list_release', None) or \ _Cfunction('libvlc_module_description_list_release', ((1,),), None, None, ctypes.POINTER(ModuleDescription)) return f(p_list)

Returns a list of audio filters that are available. @param p_instance: libvlc instance. @return: a list of module descriptions. It should be freed with L{libvlc_module_description_list_release}(). In case of an error, NULL is returned. See L{ModuleDescription} See L{libvlc_module_description_list_release}.

def libvlc_audio_filter_list_get(p_instance): '''Returns a list of audio filters that are available. @param p_instance: libvlc instance. @return: a list of module descriptions. It should be freed with L{libvlc_module_description_list_release}(). In case of an error, NULL is returned. See L{ModuleDescription} See L{libvlc_module_description_list_release}. ''' f = _Cfunctions.get('libvlc_audio_filter_list_get', None) or \ _Cfunction('libvlc_audio_filter_list_get', ((1,),), None, ctypes.POINTER(ModuleDescription), Instance) return f(p_instance)

Create a media with a certain given media resource location, for instance a valid URL. @note: To refer to a local file with this function, the file://... URI syntax B{must} be used (see IETF RFC3986). We recommend using L{libvlc_media_new_path}() instead when dealing with local files. See L{libvlc_media_release}. @param p_instance: the instance. @param psz_mrl: the media location. @return: the newly created media or NULL on error.

def libvlc_media_new_location(p_instance, psz_mrl): '''Create a media with a certain given media resource location, for instance a valid URL. @note: To refer to a local file with this function, the file://... URI syntax B{must} be used (see IETF RFC3986). We recommend using L{libvlc_media_new_path}() instead when dealing with local files. See L{libvlc_media_release}. @param p_instance: the instance. @param psz_mrl: the media location. @return: the newly created media or NULL on error. ''' f = _Cfunctions.get('libvlc_media_new_location', None) or \ _Cfunction('libvlc_media_new_location', ((1,), (1,),), class_result(Media), ctypes.c_void_p, Instance, ctypes.c_char_p) return f(p_instance, psz_mrl)

Create a media for a certain file path. See L{libvlc_media_release}. @param p_instance: the instance. @param path: local filesystem path. @return: the newly created media or NULL on error.

def libvlc_media_new_path(p_instance, path): '''Create a media for a certain file path. See L{libvlc_media_release}. @param p_instance: the instance. @param path: local filesystem path. @return: the newly created media or NULL on error. ''' f = _Cfunctions.get('libvlc_media_new_path', None) or \ _Cfunction('libvlc_media_new_path', ((1,), (1,),), class_result(Media), ctypes.c_void_p, Instance, ctypes.c_char_p) return f(p_instance, path)

Create a media for an already open file descriptor. The file descriptor shall be open for reading (or reading and writing). Regular file descriptors, pipe read descriptors and character device descriptors (including TTYs) are supported on all platforms. Block device descriptors are supported where available. Directory descriptors are supported on systems that provide fdopendir(). Sockets are supported on all platforms where they are file descriptors, i.e. all except Windows. @note: This library will B{not} automatically close the file descriptor under any circumstance. Nevertheless, a file descriptor can usually only be rendered once in a media player. To render it a second time, the file descriptor should probably be rewound to the beginning with lseek(). See L{libvlc_media_release}. @param p_instance: the instance. @param fd: open file descriptor. @return: the newly created media or NULL on error. @version: LibVLC 1.1.5 and later.

def libvlc_media_new_fd(p_instance, fd): '''Create a media for an already open file descriptor. The file descriptor shall be open for reading (or reading and writing). Regular file descriptors, pipe read descriptors and character device descriptors (including TTYs) are supported on all platforms. Block device descriptors are supported where available. Directory descriptors are supported on systems that provide fdopendir(). Sockets are supported on all platforms where they are file descriptors, i.e. all except Windows. @note: This library will B{not} automatically close the file descriptor under any circumstance. Nevertheless, a file descriptor can usually only be rendered once in a media player. To render it a second time, the file descriptor should probably be rewound to the beginning with lseek(). See L{libvlc_media_release}. @param p_instance: the instance. @param fd: open file descriptor. @return: the newly created media or NULL on error. @version: LibVLC 1.1.5 and later. ''' f = _Cfunctions.get('libvlc_media_new_fd', None) or \ _Cfunction('libvlc_media_new_fd', ((1,), (1,),), class_result(Media), ctypes.c_void_p, Instance, ctypes.c_int) return f(p_instance, fd)

Create a media with custom callbacks to read the data from. @param instance: LibVLC instance. @param open_cb: callback to open the custom bitstream input media. @param read_cb: callback to read data (must not be NULL). @param seek_cb: callback to seek, or NULL if seeking is not supported. @param close_cb: callback to close the media, or NULL if unnecessary. @param opaque: data pointer for the open callback. @return: the newly created media or NULL on error @note If open_cb is NULL, the opaque pointer will be passed to read_cb, seek_cb and close_cb, and the stream size will be treated as unknown. @note The callbacks may be called asynchronously (from another thread). A single stream instance need not be reentrant. However the open_cb needs to be reentrant if the media is used by multiple player instances. @warning The callbacks may be used until all or any player instances that were supplied the media item are stopped. See L{libvlc_media_release}. @version: LibVLC 3.0.0 and later.

def libvlc_media_new_callbacks(instance, open_cb, read_cb, seek_cb, close_cb, opaque): '''Create a media with custom callbacks to read the data from. @param instance: LibVLC instance. @param open_cb: callback to open the custom bitstream input media. @param read_cb: callback to read data (must not be NULL). @param seek_cb: callback to seek, or NULL if seeking is not supported. @param close_cb: callback to close the media, or NULL if unnecessary. @param opaque: data pointer for the open callback. @return: the newly created media or NULL on error @note If open_cb is NULL, the opaque pointer will be passed to read_cb, seek_cb and close_cb, and the stream size will be treated as unknown. @note The callbacks may be called asynchronously (from another thread). A single stream instance need not be reentrant. However the open_cb needs to be reentrant if the media is used by multiple player instances. @warning The callbacks may be used until all or any player instances that were supplied the media item are stopped. See L{libvlc_media_release}. @version: LibVLC 3.0.0 and later. ''' f = _Cfunctions.get('libvlc_media_new_callbacks', None) or \ _Cfunction('libvlc_media_new_callbacks', ((1,), (1,), (1,), (1,), (1,), (1,),), class_result(Media), ctypes.c_void_p, Instance, MediaOpenCb, MediaReadCb, MediaSeekCb, MediaCloseCb, ctypes.c_void_p) return f(instance, open_cb, read_cb, seek_cb, close_cb, opaque)

Create a media as an empty node with a given name. See L{libvlc_media_release}. @param p_instance: the instance. @param psz_name: the name of the node. @return: the new empty media or NULL on error.

def libvlc_media_new_as_node(p_instance, psz_name): '''Create a media as an empty node with a given name. See L{libvlc_media_release}. @param p_instance: the instance. @param psz_name: the name of the node. @return: the new empty media or NULL on error. ''' f = _Cfunctions.get('libvlc_media_new_as_node', None) or \ _Cfunction('libvlc_media_new_as_node', ((1,), (1,),), class_result(Media), ctypes.c_void_p, Instance, ctypes.c_char_p) return f(p_instance, psz_name)

Add an option to the media. This option will be used to determine how the media_player will read the media. This allows to use VLC's advanced reading/streaming options on a per-media basis. @note: The options are listed in 'vlc --long-help' from the command line, e.g. "-sout-all". Keep in mind that available options and their semantics vary across LibVLC versions and builds. @warning: Not all options affects L{Media} objects: Specifically, due to architectural issues most audio and video options, such as text renderer options, have no effects on an individual media. These options must be set through L{libvlc_new}() instead. @param p_md: the media descriptor. @param psz_options: the options (as a string).

def libvlc_media_add_option(p_md, psz_options): '''Add an option to the media. This option will be used to determine how the media_player will read the media. This allows to use VLC's advanced reading/streaming options on a per-media basis. @note: The options are listed in 'vlc --long-help' from the command line, e.g. "-sout-all". Keep in mind that available options and their semantics vary across LibVLC versions and builds. @warning: Not all options affects L{Media} objects: Specifically, due to architectural issues most audio and video options, such as text renderer options, have no effects on an individual media. These options must be set through L{libvlc_new}() instead. @param p_md: the media descriptor. @param psz_options: the options (as a string). ''' f = _Cfunctions.get('libvlc_media_add_option', None) or \ _Cfunction('libvlc_media_add_option', ((1,), (1,),), None, None, Media, ctypes.c_char_p) return f(p_md, psz_options)

Add an option to the media with configurable flags. This option will be used to determine how the media_player will read the media. This allows to use VLC's advanced reading/streaming options on a per-media basis. The options are detailed in vlc --long-help, for instance "--sout-all". Note that all options are not usable on medias: specifically, due to architectural issues, video-related options such as text renderer options cannot be set on a single media. They must be set on the whole libvlc instance instead. @param p_md: the media descriptor. @param psz_options: the options (as a string). @param i_flags: the flags for this option.

def libvlc_media_add_option_flag(p_md, psz_options, i_flags): '''Add an option to the media with configurable flags. This option will be used to determine how the media_player will read the media. This allows to use VLC's advanced reading/streaming options on a per-media basis. The options are detailed in vlc --long-help, for instance "--sout-all". Note that all options are not usable on medias: specifically, due to architectural issues, video-related options such as text renderer options cannot be set on a single media. They must be set on the whole libvlc instance instead. @param p_md: the media descriptor. @param psz_options: the options (as a string). @param i_flags: the flags for this option. ''' f = _Cfunctions.get('libvlc_media_add_option_flag', None) or \ _Cfunction('libvlc_media_add_option_flag', ((1,), (1,), (1,),), None, None, Media, ctypes.c_char_p, ctypes.c_uint) return f(p_md, psz_options, i_flags)

Get the media resource locator (mrl) from a media descriptor object. @param p_md: a media descriptor object. @return: string with mrl of media descriptor object.

def libvlc_media_get_mrl(p_md): '''Get the media resource locator (mrl) from a media descriptor object. @param p_md: a media descriptor object. @return: string with mrl of media descriptor object. ''' f = _Cfunctions.get('libvlc_media_get_mrl', None) or \ _Cfunction('libvlc_media_get_mrl', ((1,),), string_result, ctypes.c_void_p, Media) return f(p_md)

Duplicate a media descriptor object. @param p_md: a media descriptor object.

def libvlc_media_duplicate(p_md): '''Duplicate a media descriptor object. @param p_md: a media descriptor object. ''' f = _Cfunctions.get('libvlc_media_duplicate', None) or \ _Cfunction('libvlc_media_duplicate', ((1,),), class_result(Media), ctypes.c_void_p, Media) return f(p_md)

Read the meta of the media. If the media has not yet been parsed this will return NULL. This methods automatically calls L{libvlc_media_parse_async}(), so after calling it you may receive a libvlc_MediaMetaChanged event. If you prefer a synchronous version ensure that you call L{libvlc_media_parse}() before get_meta(). See L{libvlc_media_parse} See L{libvlc_media_parse_async} See libvlc_MediaMetaChanged. @param p_md: the media descriptor. @param e_meta: the meta to read. @return: the media's meta.

def libvlc_media_get_meta(p_md, e_meta): '''Read the meta of the media. If the media has not yet been parsed this will return NULL. This methods automatically calls L{libvlc_media_parse_async}(), so after calling it you may receive a libvlc_MediaMetaChanged event. If you prefer a synchronous version ensure that you call L{libvlc_media_parse}() before get_meta(). See L{libvlc_media_parse} See L{libvlc_media_parse_async} See libvlc_MediaMetaChanged. @param p_md: the media descriptor. @param e_meta: the meta to read. @return: the media's meta. ''' f = _Cfunctions.get('libvlc_media_get_meta', None) or \ _Cfunction('libvlc_media_get_meta', ((1,), (1,),), string_result, ctypes.c_void_p, Media, Meta) return f(p_md, e_meta)

Set the meta of the media (this function will not save the meta, call L{libvlc_media_save_meta} in order to save the meta). @param p_md: the media descriptor. @param e_meta: the meta to write. @param psz_value: the media's meta.

def libvlc_media_set_meta(p_md, e_meta, psz_value): '''Set the meta of the media (this function will not save the meta, call L{libvlc_media_save_meta} in order to save the meta). @param p_md: the media descriptor. @param e_meta: the meta to write. @param psz_value: the media's meta. ''' f = _Cfunctions.get('libvlc_media_set_meta', None) or \ _Cfunction('libvlc_media_set_meta', ((1,), (1,), (1,),), None, None, Media, Meta, ctypes.c_char_p) return f(p_md, e_meta, psz_value)

Save the meta previously set. @param p_md: the media desriptor. @return: true if the write operation was successful.

def libvlc_media_save_meta(p_md): '''Save the meta previously set. @param p_md: the media desriptor. @return: true if the write operation was successful. ''' f = _Cfunctions.get('libvlc_media_save_meta', None) or \ _Cfunction('libvlc_media_save_meta', ((1,),), None, ctypes.c_int, Media) return f(p_md)

Get current state of media descriptor object. Possible media states are defined in libvlc_structures.c ( libvlc_NothingSpecial=0, libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused, libvlc_Stopped, libvlc_Ended, libvlc_Error). See libvlc_state_t. @param p_md: a media descriptor object. @return: state of media descriptor object.

def libvlc_media_get_state(p_md): '''Get current state of media descriptor object. Possible media states are defined in libvlc_structures.c ( libvlc_NothingSpecial=0, libvlc_Opening, libvlc_Buffering, libvlc_Playing, libvlc_Paused, libvlc_Stopped, libvlc_Ended, libvlc_Error). See libvlc_state_t. @param p_md: a media descriptor object. @return: state of media descriptor object. ''' f = _Cfunctions.get('libvlc_media_get_state', None) or \ _Cfunction('libvlc_media_get_state', ((1,),), None, State, Media) return f(p_md)

Get subitems of media descriptor object. This will increment the reference count of supplied media descriptor object. Use L{libvlc_media_list_release}() to decrement the reference counting. @param p_md: media descriptor object. @return: list of media descriptor subitems or NULL.

def libvlc_media_subitems(p_md): '''Get subitems of media descriptor object. This will increment the reference count of supplied media descriptor object. Use L{libvlc_media_list_release}() to decrement the reference counting. @param p_md: media descriptor object. @return: list of media descriptor subitems or NULL. ''' f = _Cfunctions.get('libvlc_media_subitems', None) or \ _Cfunction('libvlc_media_subitems', ((1,),), class_result(MediaList), ctypes.c_void_p, Media) return f(p_md)

Get the current statistics about the media. @param p_md:: media descriptor object. @param p_stats:: structure that contain the statistics about the media (this structure must be allocated by the caller). @return: true if the statistics are available, false otherwise \libvlc_return_bool.

def libvlc_media_get_stats(p_md, p_stats): '''Get the current statistics about the media. @param p_md:: media descriptor object. @param p_stats:: structure that contain the statistics about the media (this structure must be allocated by the caller). @return: true if the statistics are available, false otherwise \libvlc_return_bool. ''' f = _Cfunctions.get('libvlc_media_get_stats', None) or \ _Cfunction('libvlc_media_get_stats', ((1,), (1,),), None, ctypes.c_int, Media, ctypes.POINTER(MediaStats)) return f(p_md, p_stats)

Get event manager from media descriptor object. NOTE: this function doesn't increment reference counting. @param p_md: a media descriptor object. @return: event manager object.

def libvlc_media_event_manager(p_md): '''Get event manager from media descriptor object. NOTE: this function doesn't increment reference counting. @param p_md: a media descriptor object. @return: event manager object. ''' f = _Cfunctions.get('libvlc_media_event_manager', None) or \ _Cfunction('libvlc_media_event_manager', ((1,),), class_result(EventManager), ctypes.c_void_p, Media) return f(p_md)

Get duration (in ms) of media descriptor object item. @param p_md: media descriptor object. @return: duration of media item or -1 on error.

def libvlc_media_get_duration(p_md): '''Get duration (in ms) of media descriptor object item. @param p_md: media descriptor object. @return: duration of media item or -1 on error. ''' f = _Cfunctions.get('libvlc_media_get_duration', None) or \ _Cfunction('libvlc_media_get_duration', ((1,),), None, ctypes.c_longlong, Media) return f(p_md)

Parse the media asynchronously with options. This fetches (local or network) art, meta data and/or tracks information. This method is the extended version of L{libvlc_media_parse_async}(). To track when this is over you can listen to libvlc_MediaParsedChanged event. However if this functions returns an error, you will not receive this event. It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All these flags can be combined. By default, media is parsed if it's a local file. See libvlc_MediaParsedChanged See L{libvlc_media_get_meta} See L{libvlc_media_tracks_get} See libvlc_media_parse_flag_t. @param p_md: media descriptor object. @param parse_flag: parse options: @return: -1 in case of error, 0 otherwise. @version: LibVLC 3.0.0 or later.

def libvlc_media_parse_with_options(p_md, parse_flag): '''Parse the media asynchronously with options. This fetches (local or network) art, meta data and/or tracks information. This method is the extended version of L{libvlc_media_parse_async}(). To track when this is over you can listen to libvlc_MediaParsedChanged event. However if this functions returns an error, you will not receive this event. It uses a flag to specify parse options (see libvlc_media_parse_flag_t). All these flags can be combined. By default, media is parsed if it's a local file. See libvlc_MediaParsedChanged See L{libvlc_media_get_meta} See L{libvlc_media_tracks_get} See libvlc_media_parse_flag_t. @param p_md: media descriptor object. @param parse_flag: parse options: @return: -1 in case of error, 0 otherwise. @version: LibVLC 3.0.0 or later. ''' f = _Cfunctions.get('libvlc_media_parse_with_options', None) or \ _Cfunction('libvlc_media_parse_with_options', ((1,), (1,),), None, ctypes.c_int, Media, MediaParseFlag) return f(p_md, parse_flag)

Sets media descriptor's user_data. user_data is specialized data accessed by the host application, VLC.framework uses it as a pointer to an native object that references a L{Media} pointer. @param p_md: media descriptor object. @param p_new_user_data: pointer to user data.

def libvlc_media_set_user_data(p_md, p_new_user_data): '''Sets media descriptor's user_data. user_data is specialized data accessed by the host application, VLC.framework uses it as a pointer to an native object that references a L{Media} pointer. @param p_md: media descriptor object. @param p_new_user_data: pointer to user data. ''' f = _Cfunctions.get('libvlc_media_set_user_data', None) or \ _Cfunction('libvlc_media_set_user_data', ((1,), (1,),), None, None, Media, ctypes.c_void_p) return f(p_md, p_new_user_data)

Get media descriptor's user_data. user_data is specialized data accessed by the host application, VLC.framework uses it as a pointer to an native object that references a L{Media} pointer. @param p_md: media descriptor object.

def libvlc_media_get_user_data(p_md): '''Get media descriptor's user_data. user_data is specialized data accessed by the host application, VLC.framework uses it as a pointer to an native object that references a L{Media} pointer. @param p_md: media descriptor object. ''' f = _Cfunctions.get('libvlc_media_get_user_data', None) or \ _Cfunction('libvlc_media_get_user_data', ((1,),), None, ctypes.c_void_p, Media) return f(p_md)

Get codec description from media elementary stream. @param i_type: i_type from L{MediaTrack}. @param i_codec: i_codec or i_original_fourcc from L{MediaTrack}. @return: codec description. @version: LibVLC 3.0.0 and later. See L{MediaTrack}.

def libvlc_media_get_codec_description(i_type, i_codec): '''Get codec description from media elementary stream. @param i_type: i_type from L{MediaTrack}. @param i_codec: i_codec or i_original_fourcc from L{MediaTrack}. @return: codec description. @version: LibVLC 3.0.0 and later. See L{MediaTrack}. ''' f = _Cfunctions.get('libvlc_media_get_codec_description', None) or \ _Cfunction('libvlc_media_get_codec_description', ((1,), (1,),), None, ctypes.c_char_p, TrackType, ctypes.c_uint32) return f(i_type, i_codec)

Release media descriptor's elementary streams description array. @param p_tracks: tracks info array to release. @param i_count: number of elements in the array. @version: LibVLC 2.1.0 and later.

def libvlc_media_tracks_release(p_tracks, i_count): '''Release media descriptor's elementary streams description array. @param p_tracks: tracks info array to release. @param i_count: number of elements in the array. @version: LibVLC 2.1.0 and later. ''' f = _Cfunctions.get('libvlc_media_tracks_release', None) or \ _Cfunction('libvlc_media_tracks_release', ((1,), (1,),), None, None, ctypes.POINTER(MediaTrack), ctypes.c_uint) return f(p_tracks, i_count)

Get the media type of the media descriptor object. @param p_md: media descriptor object. @return: media type. @version: LibVLC 3.0.0 and later. See libvlc_media_type_t.

def libvlc_media_get_type(p_md): '''Get the media type of the media descriptor object. @param p_md: media descriptor object. @return: media type. @version: LibVLC 3.0.0 and later. See libvlc_media_type_t. ''' f = _Cfunctions.get('libvlc_media_get_type', None) or \ _Cfunction('libvlc_media_get_type', ((1,),), None, MediaType, Media) return f(p_md)

Create a media discoverer object by name. After this object is created, you should attach to events in order to be notified of the discoverer state. You should also attach to media_list events in order to be notified of new items discovered. You need to call L{libvlc_media_discoverer_start}() in order to start the discovery. See L{libvlc_media_discoverer_media_list} See L{libvlc_media_discoverer_event_manager} See L{libvlc_media_discoverer_start}. @param p_inst: libvlc instance. @param psz_name: service name. @return: media discover object or NULL in case of error. @version: LibVLC 3.0.0 or later.

def libvlc_media_discoverer_new(p_inst, psz_name): '''Create a media discoverer object by name. After this object is created, you should attach to events in order to be notified of the discoverer state. You should also attach to media_list events in order to be notified of new items discovered. You need to call L{libvlc_media_discoverer_start}() in order to start the discovery. See L{libvlc_media_discoverer_media_list} See L{libvlc_media_discoverer_event_manager} See L{libvlc_media_discoverer_start}. @param p_inst: libvlc instance. @param psz_name: service name. @return: media discover object or NULL in case of error. @version: LibVLC 3.0.0 or later. ''' f = _Cfunctions.get('libvlc_media_discoverer_new', None) or \ _Cfunction('libvlc_media_discoverer_new', ((1,), (1,),), class_result(MediaDiscoverer), ctypes.c_void_p, Instance, ctypes.c_char_p) return f(p_inst, psz_name)

Get media service discover object its localized name. @param p_mdis: media discover object. @return: localized name.

def libvlc_media_discoverer_localized_name(p_mdis): '''Get media service discover object its localized name. @param p_mdis: media discover object. @return: localized name. ''' f = _Cfunctions.get('libvlc_media_discoverer_localized_name', None) or \ _Cfunction('libvlc_media_discoverer_localized_name', ((1,),), string_result, ctypes.c_void_p, MediaDiscoverer) return f(p_mdis)