Pympress package¶
This page contains the inline documentation, generated from the code using sphinx.
The code is documented in the source using the Google style for docstrings. Sphinx has gathered a set of examples which serves as a better crash course than the full style reference.
Retructured text (rst) can be used inside the comments and docstrings.
Modules¶
pympress.__main__
– The entry point of pympress¶
- pympress.__main__.uncaught_handler(*exc_info)[source]¶
Exception handler, to log uncaught exceptions to our log file.
- pympress.__main__.main(argv=['/usr/lib/python3/dist-packages/sphinx/__main__.py', '-N', '-bhtml', 'docs/', 'build/html', '-t', 'api_doc', '-t', 'install_instructions'])[source]¶
Entry point of pympress. Parse command line arguments, instantiate the UI, and start the main loop.
pympress.app
– The Gtk.Application managing the lifetime and CLI¶
- class pympress.app.Pympress[source]¶
Bases:
Application
Class representing the single pympress Gtk application.
- action_startup_queue = []¶
list
of actions to be passsed to the GUI that were queued before GUI was created
- auto_log_level = True¶
bool
to automatically upgrade log level (DEBUG / INFO at init, then ERROR), False if user set log level
- options = {'blank': (98, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'first': (102, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'last': (108, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'log': (0, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_STRING of type GLib.OptionArg>), 'next': (110, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'notes': (78, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_STRING of type GLib.OptionArg>), 'pause': (80, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'prev': (112, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'quit': (113, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'reset': (114, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>), 'talk-time': (116, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_STRING of type GLib.OptionArg>), 'version': (118, <flags 0 of type GLib.OptionFlags>, <enum G_OPTION_ARG_NONE of type GLib.OptionArg>)}¶
- option_descriptions = {'blank': ('Blank/unblank content screen', None), 'first': ('First slide', None), 'last': ('Last slide', None), 'log': ('Set level of verbosity in log file: DEBUG, INFO, WARNING, ERROR, or CRITICAL', '<level>'), 'next': ('Next slide', None), 'notes': ('Set the position of notes on the pdf page (none, left, right, top, bottom, after, odd, or prefix). Overrides the detection from the file.', '<position>'), 'pause': ('Toggle pause of talk timer', None), 'prev': ('Previous slide', None), 'quit': ('Close opened pympress instance', None), 'reset': ('Reset talk timer', None), 'talk-time': ('The estimated (intended) talk time in minutes (and optionally seconds)', 'mm[:ss]'), 'version': ('Print version and exit', None)}¶
- version_string = 'Pympress: 1.8.5 ; Python: 3.13.3 ; OS: Linux 6.1.0-33-amd64 #1 SMP PREEMPT_DYNAMIC Debian 6.1.133-1 (2025-04-10) ; Gtk 3.24.49 ; GLib 2.84.1 ; Poppler 25.03.0 cairo ; Cairo 1.18.4 , pycairo 1.27.0'¶
- do_startup()[source]¶
Common start-up tasks for primary and remote instances.
NB. super(self) causes segfaults, Gtk.Application needs to be used as base.
- do_activate(timestamp=1744851614.613229)[source]¶
Activate: show UI windows.
Build them if they do not exist, otherwise bring to front.
- set_action_enabled(name, value)[source]¶
Parse an action name and set its enabled state to True or False.
- get_action_state(name)[source]¶
Parse an action name and return its unwrapped state from the
Variant
.
- activate_action(name, parameter=None)[source]¶
Parse an action name and activate it, with parameter wrapped in a
Variant
if it is not None.- Parameters:
name (
str
) – the name of the stateful actionparameter – an object or None to pass as a parameter to the action, wrapped in a GLib.Variant
- do_open(files, n_files, hint)[source]¶
Handle opening files. In practice we only open once, the last one.
pympress.ui
– GUI management¶
This module contains the whole graphical user interface of pympress, which is made of two separate windows: the Content window, which displays only the current page in full size, and the Presenter window, which displays both the current and the next page, as well as a time counter and a clock.
Both windows are managed by the UI
class.
- class pympress.ui.UI(app, config)[source]¶
Bases:
Builder
Pympress GUI management.
- c_win = None¶
Content window, as a
Window
instance.
- c_frame = None¶
AspectFrame
for the Content window.
- c_da = None¶
DrawingArea
for the Content window.
- p_win = None¶
Presenter window, as a
Window
instance.
- p_central = None¶
Box
for the Presenter window.
- p_frame_notes = None¶
AspectFrame
for the current slide in the Presenter window.
- p_da_notes = None¶
DrawingArea
for the current slide in the Presenter window.
- grid_next = None¶
Grid
for the next slide(s) in the Presenter window.
- p_das_next = None¶
DrawingArea
for the next slide in the Presenter window.
- next_frames_count = 16¶
int
the number of next slides currently on display in the “Next slides” pane, initialized to the maximal number
- p_da_cur = None¶
DrawingArea
for the current slide copy in the Presenter window.
- p_frame_annot = None¶
Frame
for the annotations in the Presenter window.
- resize_panes = False¶
Indicates whether we should delay redraws on some drawing areas to fluidify resizing gtk.paned
- redraw_timeout = 0¶
Tracks return values of GLib.timeout_add to cancel gtk.paned’s redraw callbacks
- notes_mode = 0¶
Whether to use notes mode or not
- prev_button = None¶
ToolButton
big button for touch screens, go to previous slide
- next_button = None¶
ToolButton
big button for touch screens, go to next slide
- laser_button = None¶
ToolButton
big button for touch screens, go toggle the pointer
- highlight_button = None¶
ToolButton
big button for touch screens, go to scribble on screen
- current_page = -1¶
number of page currently displayed in Content window’s miniatures
- preview_page = -1¶
number of page currently displayed in Presenter window’s miniatures
- shortcuts_window = None¶
A
ShortcutsWindow
to show the shortcuts
- accel_group = None¶
A
AccelGroup
to store the shortcuts
- blanked = False¶
track whether we blank the screen
- show_annotations = True¶
Whether to display annotations or not
- chosen_notes_mode = 4¶
Current choice of mode to toggle notes
- show_bigbuttons = True¶
Whether to display big buttons or not
- cache = None¶
SurfaceCache
instance.
A
Menu
to display the recent files to open
- scribbler = None¶
Class
Scribble
managing drawing by the user on top of the current slide.
- annotations = None¶
Class
Annotations
managing the display of annotations
- est_time = None¶
EstimatedTalkTime
to set estimated/remaining talk time
- page_number = None¶
PageNumber
displaying and setting current page numbers
- timing = None¶
TimingReport
popup to show how much time was spent on which part
- talk_time = None¶
TimeCounter
clock tracking talk time (elapsed, and remaining)
- layout_editor = None¶
LayoutEditor
popup to configure the layouts of the presenter window
- file_watcher = None¶
A
FileWatcher
object to reload modified files
- placeable_widgets = {}¶
Dictionary of
Widget
from the presenter window that can be dynamically rearranged
- reconfigure_next_frames(gaction, param)[source]¶
Callback to set the number of next frames to preview the the “next slides” panel
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the number of slides as a GVariant
- reflow_next_frames(n_frames=None)[source]¶
Set the number of next frames to preview the the “next slides” panel
- Parameters:
n_frames (
int
) – the number of frames
- compute_frame_grid(grid_ar, n_frames)[source]¶
Determine the arragement of frames in a grid to maximise their size given respective aspect ratios
- screens_changed(screen)[source]¶
Handle ::monitors-changed events
- Parameters:
screen (
Screen
) – the screen
- setup_screens(screen, event_name='')[source]¶
If multiple monitors, fullscreen windows on monitors according to config.
- Parameters:
screen (
Screen
) – the screenevent_name (
str
) – a description of what caused the screen setup event, for debugging
- move_window(win, from_bounds, to_bounds)[source]¶
Move window from monitor number from_monitor to monitor to_monitor.
- on_configure_da(widget, event)[source]¶
Manage “configure” events for all drawing areas, e.g. resizes.
We tell the local
SurfaceCache
cache about it, so that it can invalidate its internal cache for the specified widget and pre-render next pages at a correct size.Warning: Some not-explicitly sent signals contain wrong values! Just don’t resize in that case, since these always seem to happen after a correct signal that was sent explicitly.
- Parameters:
widget (
Widget
) – the widget which has been resizedevent (
Event
) – the GTK event, which contains the new dimensions of the widget
- on_configure_win(widget, event)[source]¶
Manage “configure” events for both window widgets.
- Parameters:
widget (
Widget
) – the window which has been moved or resizedevent (
Event
) – the GTK event, which contains the new dimensions of the widget
- adjust_bottom_bar_font()[source]¶
Scale baseline font size of bottom bar, clipped to 6px..13px. Fonts are then scaled by CSS em indications.
- redraw_panes()[source]¶
Handler for
Paned
’s resizing signal.Used for delayed drawing events of drawing areas inside the panes.
This is very useful on windows where resizing gets sluggish if we try to redraw while resizing.
- on_pane_event(widget, evt)[source]¶
Signal handler for gtk.paned events.
This function allows one to delay drawing events when resizing, and to speed up redrawing when moving the middle pane is done (which happens at the end of a mouse resize)
- Parameters:
widget (
Widget
) – the widget in which the event occurred (ignored)evt (
Event
) – the event that occurred
Display the “About pympress” dialog.
Handles clicks on the “about” menu.
- swap_document(doc_uri, page=0, reloading=False)[source]¶
Replace the currently open document with a new one.
The new document is possibly and EmptyDocument if doc_uri is None. The state of the ui and cache are updated accordingly.
Callback for the recent document menu.
Gets the URI and requests the document swap.
- Parameters:
gaction (
Action
) – the action triggering the callis_opening (
Variant
) – a wrapped boolean indicating whether the menu is opening or closing.
- on_drag_drop(widget, drag_context, x, y, data, info, time)[source]¶
Receive the drag-drops (as text only). If a file is dropped, open it.
- Parameters:
widget (
Widget
) – The widget on which the dragged item was droppeddrag_context (
DragContext
) – Context object of the draggingx (
float
) – position of the dropy (
float
) – position of the dropdata (
SelectionData
) – container for the dropped datainfo (
int
) – info on the targettime (
int
) – time of the drop
- unsaved_changes(reload=False)[source]¶
Prompt the user about what to do with changes in the document: save, discard, or cancel action
- error_opening_file(uri)[source]¶
Remove the current document.
- Parameters:
uri (
str
) – the URI of the document
- open_file(gaction, target)[source]¶
Open a document.
- Parameters:
gaction (
Action
) – the action triggering the calltarget (
Variant
) – the file to open as a string variant
- get_notes_mode()[source]¶
Simple getter.
- Returns:
Truthy when we split slides in content + notes
- Return type:
- on_page_change(widget, event=None)[source]¶
Signal handler for current page editing.
- Parameters:
widget (
Widget
) – the editable widget which has received the event.event (
Event
) – the GTK event.
- doc_goto_prev(gaction=None, param=None)[source]¶
Handle going to the next page.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_goto_next(gaction=None, param=None)[source]¶
Handle going to the previous page.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_label_next(gaction=None, param=None)[source]¶
Handle going to the next page with a different label.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_label_prev(gaction=None, param=None)[source]¶
Handle going to the previous page with a different label.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_hist_prev(gaction=None, param=None)[source]¶
Handle going to the previous page in the history of visited pages
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_hist_next(gaction=None, param=None)[source]¶
Handle going to the next page in the history of visited pages
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_goto_home(gaction=None, param=None)[source]¶
Handle going to the start of the document
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- doc_goto_end(gaction=None, param=None)[source]¶
Handle going to the end of the document
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- do_page_change(unpause=True, autoplay=False)[source]¶
Switch to another page and display it.
This is a kind of event which is supposed to be called only from the
Document
class.
- on_draw(widget, cairo_context)[source]¶
Manage draw events for both windows.
This callback may be called either directly on a page change or as an event handler by GTK. In both cases, it determines which widget needs to be updated, and updates it, using the
SurfaceCache
if possible.
- validate_current_input(gaction, param=None)[source]¶
Handle the action validating the input, if applicable.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- on_key_input(widget, event)[source]¶
Handle key strokes at top level, only for when editing needs to bypass action accelerators
- Parameters:
widget (
Widget
) – the widget which has received the key strokeevent (
Event
) – the GTK event, which contains the key stroke details
- cancel_current_input(gaction, param=None)[source]¶
Handle the action cancelling the input, if applicable.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- on_scroll(widget, event)[source]¶
Manage scroll events.
- Parameters:
widget (
Widget
) – the widget in which the event occurred (ignored)event (
Event
) – the event that occurred
- Returns:
whether the event was consumed
- Return type:
- track_motions(widget, event)[source]¶
Track mouse motion events.
Handles mouse motions on the “about” menu.
- Parameters:
widget (
Widget
) – the widget that received the mouse motionevent (
Event
) – the GTK event containing the mouse position
- Returns:
whether the event was consumed
- Return type:
- track_clicks(widget, event)[source]¶
Track mouse press and release events.
Handles clicks on the slides.
- Parameters:
widget (
Widget
) – the widget that received the clickevent (
Event
) – the GTK event containing the click position
- Returns:
whether the event was consumed
- Return type:
- click_link(widget, event)[source]¶
Check whether a link was clicked and follow it.
Handles a click on a slide.
- Parameters:
widget (
Widget
) – the widget in which the event occurredevent (
Event
) – the event that occurred
- Returns:
whether the event was consumed
- Return type:
- hover_link(widget, event)[source]¶
Manage events related to hyperlinks, setting the cursor to a pointer if the hovered region is clickable.
- Parameters:
widget (
Widget
) – the widget in which the event occurredevent (
Event
) – the event that occurred
- Returns:
whether the event was consumed
- Return type:
- switch_fullscreen(gaction, target)[source]¶
Switch the Content window to fullscreen (if in normal mode) or to normal mode (if fullscreen).
Screensaver will be disabled when entering fullscreen mode, and enabled when leaving fullscreen mode.
- Parameters:
widget (
Widget
) – the widget in which the event occurred- Returns:
whether some window’s full screen status got toggled
- Return type:
- update_frame_position(widget, user_data)[source]¶
Callback to preview the frame alignment, called from the Gtk.SpinButton.
- Parameters:
widget (
SpinButton
) – The button updating the slide alignment in the drawing area widgetuser_data (
str
) – The property being set, either the x or y alignment (resp. xalign and yalign).
- swap_screens(*args)[source]¶
Swap the monitors on which each window is displayed (if there are 2 monitors at least).
- switch_blanked(gaction, param)[source]¶
Switch the blanked mode of the content screen.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- Returns:
whether the notes blanking has been toggled.
- Return type:
- change_notes_pos(gaction, target, force=False)[source]¶
Switch the position of the nodes in the slide.
- switch_mode(gaction, target_mode=None, force=False)[source]¶
Switch the display mode to “Notes mode” or “Normal mode” (without notes).
pympress.document
– document handling¶
This module contains several classes that are used for managing documents (only PDF documents are supported at the moment, but other formats may be added in the future).
An important point is that this module is completely independent from the GUI: there should not be any GUI-related code here, except for page rendering (and only rendering itself: the preparation of the target surface must be done elsewhere).
- pympress.document.get_extension(mime_type)[source]¶
Returns a valid filename extension (recognized by python) for a given mime type.
- class pympress.document.PdfPage(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]¶
Bases:
IntEnum
Represents the part of a PDF page that we want to draw.
- NONE = 0¶
No notes on PDF page, only falsy value
- FULL = 1¶
Full PDF page (without notes)
- BOTTOM = 2¶
Bottom half of PDF page
- TOP = 3¶
Top half of PDF page
- RIGHT = 4¶
Right half of PDF page
- LEFT = 5¶
Left half of PDF page
- AFTER = 6¶
Full page + draw another page for notes, which is after the slides
- BEFORE = 7¶
for a notes page, the slide page is BEFORE by half a document
- Type:
Complementary of AFTER
- ODD = 8¶
Slides on even pages (0-indexed), notes on uneven pages
- EVEN = 9¶
Complementary of ODD
- MAP = 10¶
An arbitrary mapping of notes pages to slide pages
- RMAP = 11¶
Reverse the arbitrary mapping MAP
- direction()[source]¶
Returns whether the pdf page/notes mode is horizontal or vertical.
- Returns:
a string representing the direction that can be used as the key in the config section
- Return type:
- from_screen(x, y, x2=None, y2=None)[source]¶
Transform visible part of the page coordinates to full page coordinates.
Pass 2 floats to transform coordinates, 4 to transform margins, i.e. the second pair of coordinates is taken from the opposite corner.
- class pympress.document.Link(x1, y1, x2, y2, action)[source]¶
Bases:
object
This class encapsulates one hyperlink of the document.
- Parameters:
- follow(**kwargs)¶
function
, action to be perform to follow this link
- class pympress.document.Media(relative_margins, filename, autoplay, repeat, poster, show_controls, type, start_pos, duration)¶
Bases:
tuple
A class that holds all the properties for media files
- autoplay¶
Alias for field number 2
- duration¶
Alias for field number 8
- filename¶
Alias for field number 1
- poster¶
Alias for field number 4
- relative_margins¶
Alias for field number 0
- repeat¶
Alias for field number 3
- show_controls¶
Alias for field number 5
- start_pos¶
Alias for field number 7
- type¶
Alias for field number 6
- class pympress.document.Page(page, number, parent)[source]¶
Bases:
object
Class representing a single page.
It provides several methods used by the GUI for preparing windows for displaying pages, managing hyperlinks, etc.
- Parameters:
- page = None¶
Page handled by this class (instance of
Page
)
- annotations = []¶
All text annotations
- get_link_action(link_type, action)[source]¶
Get the function to be called when the link is followed.
- Parameters:
link_type (
ActionType
) – The type of action to be performedaction (
Action
) – The atcion to be performed
- Returns:
The function to be called to follow the link
- Return type:
function
- get_annot_action(link_type, action, rect)[source]¶
Get the function to be called when the link is followed.
- Parameters:
link_type (
ActionType
) – The link typeaction (
Action
) – The action to be performed when the link is clickedrect (
Rectangle
) – The region of the page where the link is
- Returns:
The function to be called to follow the link
- Return type:
function
- get_link_at(x, y, dtype=PdfPage.FULL)[source]¶
Get the
Link
corresponding to the given position.Returns
None
if there is no link at this position.
- get_size(dtype=PdfPage.FULL)[source]¶
Get the page size.
- Parameters:
dtype (
PdfPage
) – the type of document to consider- Returns:
page size
- Return type:
(float, float)
- remove_annotation(pos)[source]¶
Remove an annotation from this page
- Parameters:
pos (
int
) – The number of the annotation
- get_media()[source]¶
Get the list of medias this page might want to play.
- Returns:
medias in this page
- Return type:
- class pympress.document.Document(builder, pop_doc, uri)[source]¶
Bases:
object
This is the main document handling class.
The page numbering starts as 0 and is aware of notes (i.e. number of pages may change to account for note pages). The document page numbers are the same as in Poppler, and also start at 0 but do not depend on notes.
- Parameters:
builder (
pympress.builder.Builder
) – A builder to load callbackspop_doc (
Document
) – Instance of the Poppler document that this class will wrapuri (
str
) – URI of the PDF file to openpage (
int
) – page number to which the file should be opened
- history = []¶
History of pages we have visited, using note-aware page numbers
- hist_pos = -1¶
Our position in the history
- notes_mapping = None¶
list
of (slide’s document page number, notes’ document page number) tuples, orNone
if there are no notes
callback, to be connected to
goto_page()
- start_editing_page_number()¶
callback, to be connected to
start_editing()
- doc = None¶
Current PDF document (
Document
instance)
- nb_pages = -1¶
Number of pages in the document
- pages_cache = {}¶
Pages cache (
dict
ofPage
). This makes navigation in the document faster by avoiding calls to Poppler when loading a page that has already been loaded.
- get_structure(index_iter=None)[source]¶
Gets the structure of the document from its index.
Recursive, pass the iterator.
- static create(builder, uri)[source]¶
Initializes a Document by passing it a
Document
.- Parameters:
builder (
pympress.builder.Builder
) – A builder to load callbacksuri (
str
) – URI to the PDF file to openpage (
int
) – page number to which the file should be opened
- Returns:
The initialized document
- Return type:
- guess_notes(horizontal, vertical, current_page=0)[source]¶
Get our best guess for the document mode.
- set_notes_pos(notes_direction)[source]¶
Set whether where the notes pages are relative to normal pages
Valid values are returned by
direction()
- page number (aka Libreoffice notes mode) - page parity (can not be detected automatically, where every other page contains notes) - page mapping (where labels of notes pages are corresponding slide labels prefixed with “notes:”)- Parameters:
notes_direction (
str
) – Where the notes pages are
- pages_number()[source]¶
Get the number of pages in the document.
- Returns:
the number of pages in the document
- Return type:
- has_labels()[source]¶
Return whether this document has useful labels.
- Returns:
False iff there are no labels or they are just the page numbers
- Return type:
- get_last_label_pages()[source]¶
Return the last page number for each consecutively distinct page label
In other words, squash together consecutive same labels
- goto(number)[source]¶
Switch to another page. Validates the number and returns one in the correct range. Also updates history.
- Parameters:
number (
int
) – number of the destination page
- label_after(page)[source]¶
Switch to the next page with different label.
If we’re within a set of pages with the same label we want to go to the last one.
- label_before(page)[source]¶
Switch to the previous page with different label.
If we’re within a set of pages with the same label we want to go before the first one.
- get_uri()[source]¶
Gives access to the URI, rather than the path, of this document.
- Returns:
the URI to the file currently opened.
- Return type:
- get_full_path(filename)[source]¶
Returns full path, extrapolated from a path relative to this document or to the current directory.
- class pympress.document.EmptyPage(parent)[source]¶
Bases:
Page
A dummy page, placeholder for when there are no valid pages around.
This page is a non-notes page with an aspect ratio of 1.3 and nothing else inside. Also, it has no “rendering” capability, and is made harmless by overriding its render function.
- class pympress.document.EmptyDocument[source]¶
Bases:
Document
A dummy document, placeholder for when no document is open.
pympress.ui_builder
– abstract GUI management¶
This module contains the tools to load the graphical user interface of pympress, building the widgets/objects from XML (glade) files, applying translation “manually” to avoid dealing with all the mess of C/GNU gettext’s bad portability.
- class pympress.builder.Builder[source]¶
Bases:
Builder
GUI builder, inherits from
Builder
to read XML descriptions of GUIs and load them.- pending_pane_resizes = {}¶
dict
mappingPaned
names to atuple
of (handler id of the size-allocate signal, remaining number of times we allow this signal to run), and we run the signal 2 * (depth + 1) for each pane. This is because size allocation is done bottom-up but each pane sets a top-down constraint.
- get_callback_handler(handler_name)[source]¶
Returns the handler from its name, searching in target.
Parse handler names and split on ‘.’ to use recursion.
- signal_connector(builder, obj, signal_name, handler_name, connect_object, flags, *user_data)[source]¶
Callback for signal connection. Implements the
BuilderConnectFunc
function interface.- Parameters:
builder (
Builder
) – The builder, unusedobj (
Object
) – The object (usually a wiget) that has a signal to be connectedsignal_name (
str
) – The name of the signalhandler_name (
str
) – The name of the function to be connected to the signalconnect_object (
Object
) – unusedflags (
ConnectFlags
) – unuseduser_data (
tuple
) – supplementary positional arguments to be passed to the handler
- connect_signals(base_target)[source]¶
Signal connector connecting to properties of
base_target
, or properties of its properties, etc.- Parameters:
base_target (
Builder
) – The target object, that has functions to be connected tobuilder. (signals loaded in this)
- load_ui(resource_name, **kwargs)[source]¶
Loads the UI defined in the file named resource_name using the builder.
- Parameters:
resource_name (
str
) – the basename of the glade file (without extension), identifying the resource to load.
- list_attributes(target)[source]¶
List the None-valued attributes of target.
- Parameters:
target (
dict
) – An object with None-valued attributes
- load_widgets(target)[source]¶
Fill in target with the missing elements introspectively.
This means that all attributes of
target
that are None now must exist under the same name in the builder.- Parameters:
target (
dict
) – An object with None-valued properties whose names correspond to ids of built widgets.
- replace_layout(layout, top_widget, leaf_widgets, pane_resize_handler=None)[source]¶
Remix the layout below top_widget with the layout configuration given in ‘layout’ (assumed to be valid!).
- Parameters:
layout (
dict
) – the json-parsed config string, thus a hierarchy of lists/dicts, with strings as leavestop_widget (
Container
) – The top-level widget under which we build the hierachyyleaf_widgets (
dict
) – the map of valid leaf identifiers (strings) to the correspondingWidget
pane_resize_handler (function) – callback function to be called when the panes are resized
- Returns:
The mapping of the used
Paned
widgets to their relative handle position (in 0..1).- Return type:
- resize_paned(paned, rect, relpos)[source]¶
Resize
paned
to have its handle atrelpos
, then disconnect this signal handler.Called from the
Gtk.Widget.signals.size_allocate()
signal.
- static setup_actions(actions, action_map=None)[source]¶
Sets up actions with a given prefix, using the Application as the ActionMap.
- Parameters:
actions (
dict
) – Maps the action names to dictionaries containing their parameters.action_map (
ActionMap
) – The object implementing the action map interface to register actions
pympress.surfacecache
– pages prerendering and caching¶
This modules contains stuff needed for caching pages and prerendering them. This
is done by the SurfaceCache
class, using several
dict
of ImageSurface
for storing rendered pages.
The problem is, neither Gtk+ nor Poppler are particularly threadsafe. Hence the prerendering isn’t really done in parallel in another thread, but scheduled on the main thread at idle times using GLib.idle_add().
- class pympress.surfacecache.SurfaceCache(doc, max_pages)[source]¶
Bases:
object
Pages caching and prerendering made (almost) easy.
- surface_cache = {}¶
The actual cache. The
dict`s keys are widget names and its values are :class:`~collections.OrderedDict
, whose keys are page numbers and values are instances ofImageSurface
. In eachOrderedDict
keys are ordered by Least Recently Used (get or set), when the size is beyondmax_pages
, pages are popped from the start of the cache.
- surface_factory = {}¶
dict
containing functions that return aSurface
given aFormat
, widthint
and heightint
, seecreate_similar_image_surface()
- surface_type = {}¶
its keys are widget names and its values are document types from ui.
- Type:
Type of document handled by each widget. It is a
dict
- locks = {}¶
Dictionary of
Lock
used for managing conccurent accesses tosurface_cache
andsurface_size
- unlimited = {}¶
Set of widgets for which we ignore the max
- active_widgets = {}¶
Set of active widgets
- max_pages = 200¶
maximum number fo pages we keep in cache
- add_widget(widget, wtype, prerender_enabled=True, zoomed=False, ignore_max=False)[source]¶
Add a widget to the list of widgets that have to be managed (for caching and prerendering).
This creates new entries for
widget_name
in the needed internal data structures, and creates a new thread for prerendering pages for this widget.- Parameters:
widget (
Widget
) – The widget for which we need to cachewtype (
int
) – type of document handled by the widget (seesurface_type
)prerender_enabled (
bool
) – whether this widget is initially in the list of widgets to prerenderzoomed (
bool
) – whether we will cache a zoomed portion of the widgetignore_max (
bool
) – whether we will cache an unlimited number of slides
- swap_document(new_doc)[source]¶
Replaces the current document for which to cache slides with a new one.
This function also clears the cached pages, since they now belong to an outdated document.
- Parameters:
new_doc (
Document
) – the new document
- disable_prerender(widget_name)[source]¶
Remove a widget from the ones to be prerendered.
- Parameters:
widget_name (
str
) – string used to identify a widget
- enable_prerender(widget_name)[source]¶
Add a widget to the ones to be prerendered.
- Parameters:
widget_name (
str
) – string used to identify a widget
- set_widget_type(widget_name, wtype)[source]¶
Set the document type of a widget.
- Parameters:
widget_name (
str
) – string used to identify a widgetwtype (
int
) – type of document handled by the widget (seesurface_type
)
- get_widget_type(widget_name)[source]¶
Get the document type of a widget.
- Parameters:
widget_name (
str
) – string used to identify a widget- Returns:
type of document handled by the widget (see
surface_type
)- Return type:
- clear_cache(widget_name=None)[source]¶
Remove all cached values for a given widget. Useful for zoomed views.
- resize_widget(widget_name, width, height)[source]¶
Change the size of a registered widget, thus invalidating all the cached pages.
- get(widget_name, page_nb)[source]¶
Fetch a cached, prerendered page for the specified widget.
- Parameters:
- Returns:
the cached page if available, or
None
otherwise- Return type:
- put(widget_name, page_nb, val)[source]¶
Store a rendered page in the cache.
- Parameters:
widget_name (
str
) – name of the concerned widgetpage_nb (
int
) – number of the page to store in the cacheval (
ImageSurface
) – content to store in the cache
- prerender(page_nb)[source]¶
Queue a page for prerendering.
The specified page will be prerendered for all the registered widgets.
- Parameters:
page_nb (
int
) – number of the page to be prerendered
- renderer(widget_name, page_nb)[source]¶
Rendering function.
This function is meant to be scheduled on the GLib main loop. When run, it will go through the following steps:
check if the job’s result is not already available in the cache
render it in a new
ImageSurface
if necessarystore it in the cache if it was not added there since the beginning of the process and the widget configuration is still valid
pympress.scribble
– Manage user drawings on the current slide¶
- class pympress.scribble.Scribbler(config, builder, notes_mode)[source]¶
Bases:
Builder
UI that allows to draw free-hand on top of the current slide.
- Parameters:
- scribbling_mode = False¶
Whether we are displaying the interface to scribble on screen and the overlays containing said scribbles
- scribble_list = []¶
list
of scribbles to be drawn, as tuples of colorRGBA
, widthint
, alist
of points, and alist
of pressure values.
- scribble_drawing = False¶
Whether the current mouse movements are drawing strokes or should be ignored
- scribble_color = Gdk.RGBA(red=1.000000, green=1.000000, blue=1.000000, alpha=1.000000)¶
RGBA
current color of the scribbling tool
- scribble_overlay = None¶
HBox
that replaces normal panes when scribbling is on, contains buttons and scribble drawing area.
- scribble_p_da = None¶
DrawingArea
for the scribbles in the Presenter window. Actually redraws the slide.
- scribble_c_eb = None¶
EventBox
for the scribbling in the Content window, captures freehand drawing
- scribble_p_eb = None¶
EventBox
for the scribbling in the Presenter window, captures freehand drawing
- scribble_p_frame = None¶
AspectFrame
for the slide in the Presenter’s highlight mode
- c_da = None¶
The
DrawingArea
in the content window
- scribble_color_selector = None¶
The
ColorButton
selecting the color of the pen
- scribble_width_selector = None¶
The
Scale
selecting the size of the pen
- next_render = 0¶
The next scribble to render (i.e. that is not rendered in cache)
- scribble_undo = None¶
Button
for removing the last drawn scribble
- scribble_redo = None¶
Button
for drawing the last removed scribble
- scribble_clear = None¶
Button
for removing all drawn scribbles
- scribble_off_render = None¶
A
OffscreenWindow
where we render the scribbling interface when it’s not shown
- p_central = None¶
Box
in the Presenter window, where we insert scribbling.
- zoom_stop_button = None¶
Button
that is clicked to stop zooming, unsensitive when there is no zooming
- toggle_erase_source = None¶
str
orNone
that indicates whether a modifier + click or a held shortcut is toggling the eraser
- highlight_mode = 'single-page'¶
- preset_toolbar = None¶
Box
containing the presets
- scribble_toolbar = None¶
Box
containing the scribble buttons
- scribble_color_toolbox = None¶
Box
containing the scribble color and width selectors
- track_motions()¶
callback, to be connected to
track_motions()
- track_clicks()¶
callback, to be connected to
track_clicks()
- load_layout()¶
callback, to be connected to
load_layout()
- redraw_current_slide()¶
callback, to be connected to
redraw_current_slide()
- resize_cache()¶
callback, to be connected to
resize_widget()
- get_slide_point()¶
callback, to be connected to
get_slide_point()
- start_zooming()¶
callback, to be connected to
start_zooming()
- stop_zooming()¶
callback, to be connected to
stop_zooming()
- toggle_erase_modifiers = []¶
list
that contains the modifiers which, when held on scribble start, toggle the eraser
- toggle_erase_shortcuts = []¶
list
that contains the non-modifier shortcuts which, when held on scribble start, toggle the eraser
- pen_action = None¶
The
Action
that contains the currently selected pen
- page_change_action(gaction, param)[source]¶
Change whether we exit or stay in highlighting mode on page changes
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the new mode as a string wrapped in a GLib.Variant
- set_mode(gaction, param)[source]¶
Change the mode of clearing and restoring highlights
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the new mode as a string wrapped in a GLib.Variant
- static parse_color(text)[source]¶
Transform a string to a Gdk object in a single function call
- Parameters:
text (
str
) – A string describing a color- Returns:
A new color object parsed from the string
- Return type:
RGBA
- points_to_curves(points)[source]¶
Transform a list of points from scribbles to bezier curves
- Returns:
control points of a bezier curves to draw
- Return type:
- track_scribble(widget, event)[source]¶
Draw the scribble following the mouse’s moves.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- key_event(widget, event)[source]¶
Handle key events to activate the eraser while the shortcut is held
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- toggle_scribble(widget, event)[source]¶
Start/stop drawing scribbles.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- render_scribble(cairo_context, color, width, points, pressures)[source]¶
Draw a single scribble, i.e. a bezier curve, on the cairo context
- Parameters:
cairo_context (
Context
) – The canvas on which to render the drawingscolor (
RGBA
) – The color of the scribblewidth (
float
) – The width of the curvepoints (
list
) – The control points of the curve, scaled to the surface.pressures (
list
) – The relative line width at each point asfloat
values in 0..1
- draw_scribble(widget, cairo_context)[source]¶
Perform the drawings by user.
- Parameters:
widget (
DrawingArea
) – The widget where to draw the scribbles.cairo_context (
Context
) – The canvas on which to render the drawings
- update_color(widget)[source]¶
Callback for the color chooser button, to set scribbling color.
- Parameters:
widget (
ColorButton
) – the clicked button to trigger this event, if any
- update_width(widget, event, value)[source]¶
Callback for the width chooser slider, to set scribbling width.
- Parameters:
widget (
Scale
) – The slider control used to select the scribble widthevent (
Event
) – the GTK event triggering this update.value (
int
) – the width of the scribbles to be drawn
- update_active_color_width()[source]¶
Update modifications to the active scribble color and width, on the pen button and config object
- page_change(page_number, page_label)[source]¶
Called when we change pages, to clear or restore scribbles
- on_configure_da(widget, event)[source]¶
Transfer configure resize to the cache.
- Parameters:
widget (
Widget
) – the widget which has been resizedevent (
Event
) – the GTK event, which contains the new dimensions of the widget
- set_tools_orientation(gaction, target)[source]¶
Changes the orientation of the highlighting tool box.
- Parameters:
gaction (
Action
) – the action triggering the calltarget (
Variant
) – the new orientation to set, as a string wrapped in a GLib.Variant
- Returns:
whether the preset was loaded
- Return type:
- adjust_tools_orientation()[source]¶
Actually change the highlight tool elements orientations according to self.tools_orientation
- switch_scribbling(gaction, target=None)[source]¶
Starts the mode where one can read on top of the screen.
Args:
- Returns:
whether the event was consumed
- Return type:
- enable_scribbling()[source]¶
Enable the scribbling mode.
- Returns:
whether it was possible to enable (thus if it was not enabled already)
- Return type:
- disable_scribbling()[source]¶
Disable the scribbling mode.
- Returns:
whether it was possible to disable (thus if it was not disabled already)
- Return type:
- load_preset(gaction=None, target=None)[source]¶
Loads the preset color of a given number or designed by a given widget, as an event handler.
- Parameters:
gaction (
Action
) – the action triggering the calltarget (
Variant
) – the new preset to load, as a string wrapped in a GLib.Variant
- Returns:
whether the preset was loaded
- Return type:
pympress.pointer
– Manage when and where to draw a software-emulated laser pointer on screen¶
- class pympress.pointer.PointerMode(value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None)[source]¶
Bases:
Enum
Possible values for the pointer.
- CONTINUOUS = 2¶
Pointer switched on continuously
- MANUAL = 1¶
Pointer switched on only manual
- DISABLED = 0¶
Pointer never switched on
- class pympress.pointer.Pointer(config, builder)[source]¶
Bases:
object
Manage and draw the software “laser pointer” to point at the slide.
Displays a pointer of chosen color on the current slide (in both windows), either on all the time or only when clicking while ctrl pressed.
- Parameters:
- pointer = <GdkPixbuf.Pixbuf object at 0x7fa0cc1b6540 (GdkPixbuf at 0x13844600)>¶
Pixbuf
to read XML descriptions of GUIs and load them.
- pointer_pos = (0.5, 0.5)¶
(float, float)
of position relative to slide, where the pointer should appear
- pointer_mode = 1¶
PointerMode
indicating the pointer mode
- old_pointer_mode = 2¶
The
PointerMode
to which we toggle back
- p_da_cur = None¶
DrawingArea
Slide in the Presenter window, used to reliably set cursors.
- c_da = None¶
DrawingArea
Slide in the Contents window, used to reliably set cursors.
- c_frame = None¶
AspectFrame
Frame of the Contents window, used to reliably set cursors.
- redraw_current_slide()¶
callback, to be connected to
redraw_current_slide()
- set_action_state = None¶
callback, to be connected to
set_action_state()
- load_pointer(name)[source]¶
Perform the change of pointer using its color name.
- Parameters:
name (
str
) – Name of the pointer to load
- change_pointercolor(action, target)[source]¶
Callback for a radio item selection as pointer mode (continuous, manual, none).
- Parameters:
action (
Action
) – The action activatdtarget (
Variant
) – The selected mode
- activate_pointermode(mode=None)[source]¶
Activate the pointer as given by mode.
Depending on the given mode, shows or hides the laser pointer and the normal mouse pointer.
- Parameters:
mode (
PointerMode
) – The mode to activate
- change_pointermode(action, target)[source]¶
Callback for a radio item selection as pointer mode (continuous, manual, none).
- Parameters:
action (
Action
) – The action activatdtarget (
Variant
) – The selected mode
- track_pointer(widget, event)[source]¶
Move the laser pointer at the mouse location.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- track_enter_leave(widget, event)[source]¶
Switches laser off/on in continuous mode on leave/enter slides.
In continuous mode, the laser pointer is switched off when the mouse leaves the slide (otherwise the laser pointer “sticks” to the edge of the slide). It is switched on again when the mouse reenters the slide.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
pympress.editable_label
– A label that can be swapped out for an editable entry¶
- class pympress.editable_label.EditableLabel[source]¶
Bases:
object
A label that can switch between simply displaying a value, and allowing user input to edit this value.
- event_box = None¶
EventBox
around the label, used to sense clicks
- on_label_event(widget_or_action, event=None)[source]¶
Manage events on the current slide label/entry.
This function triggers replacing the label with an entry when clicked or otherwise toggled.
- Parameters:
widget (
Widget
) – the widget in which the event occurredevent (
Event
or None) – the event that occurred, None if tf we called from a menu item
- Returns:
whether the event was consumed
- Return type:
- on_keypress(widget, event)[source]¶
Manage key presses for the editable label. Needs to be reimplemented by children classes.
If we are editing the label, intercept some key presses (to validate or cancel editing or other specific behaviour), otherwise pass the key presses on to the button for normal behaviour.
- class pympress.editable_label.PageNumber(builder, page_num_scroll)[source]¶
Bases:
EditableLabel
A label that displays “current page / max page”, that can be edited to select a page to which to go.
- Parameters:
builder (
Builder
) – A builder from which to load widgets
- label_cur = None¶
Slide counter
Label
for the current slide.
- label_last = None¶
Slide counter
Label
for the last slide.
- eb_cur = None¶
EventBox
associated with the slide counter label in the Presenter window.
- hb_cur = None¶
HBox
containing the slide counter label in the Presenter window.
- spin_cur = None¶
SpinButton
used to switch to another slide by typing its number.
- edit_label = None¶
Entry
used to switch to another slide by typing its label.
- label_sep = None¶
Label
separatingspin_cur
andedit_label
- find_label()¶
callback, to be connected to
lookup_label()
- label_before()¶
callback, to be connected to
label_after()
- label_after()¶
callback, to be connected to
label_before()
- page_change()¶
callback, to be connected to
do_page_change()
- setup_doc_callbacks(doc)[source]¶
Callbacks that need to be setup again at every new document
- Parameters:
doc (
Document
) – The new document that got loaded
- set_last(num_pages)[source]¶
Set the max number of pages, both on display and as the range of values for the spinner.
- Parameters:
num_pages (
int
) – The maximum page number
- enable_labels(enable)[source]¶
Allow one to use or ignore labels.
- Parameters:
enable (
bool
) – Whether to enable labels
- cancel(gaction=None, param=None)[source]¶
Make the UI re-display the pages from before editing the current page.
- on_keypress(widget, event)[source]¶
Implement directions (left/right/home/end) keystrokes.
Otherwise pass on to
do_key_press_event()
.
- on_scroll(widget, event)[source]¶
Scroll event. Pass it on to the spin button if we’re currently editing the page number.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- class pympress.editable_label.EstimatedTalkTime(builder)[source]¶
Bases:
EditableLabel
A label that displays the time elapsed since the start of the talk, that can be edited to select talk duration.
The duration of the talk will cause the label to blink and change colour as the elapsed time gets closer to the targeted talk duration.
- Parameters:
builder (builder.Builder) – The builder from which to load widgets.
- label_time = None¶
Elapsed time
Label
.
- label_ett = None¶
Estimated talk time
Label
for the talk.
- eb_ett = None¶
EventBox
associated with the estimated talk time.
- stop_editing_page_number()¶
callback, to be connected to
stop_editing()
- entry_ett = None¶
Entry
used to set the estimated talk time.
pympress.talk_time
– Manages the clock of elapsed talk time¶
- class pympress.talk_time.TimeLabelColorer(label_time)[source]¶
Bases:
object
Manage the colors of a label with a set of colors between which to fade, based on how much time remains.
Times are given in seconds (<0 has run out of time). In between timestamps the color will interpolated linearly, outside of the intervals the closest color will be used.
- Parameters:
label_time (
Gtk.Label
) – the label where the talk time is displayed
- label_time = None¶
The
Gtk.Label
whose colors need updating
- color_override = None¶
CssProvider
affecting the style context of the labels
- label_color_default = None¶
RGBA
The default color of the info labels
- color_map = []¶
list
of tuples (int
,RGBA
), which are the desired colors at the corresponding timestamps. Sorted on the timestamps.
- class pympress.talk_time.TimeCounter(builder, ett, timing_tracker, autoplay)[source]¶
Bases:
object
A double counter, that displays the time elapsed in the talk and a clock.
- Parameters:
builder (builder.Builder) – The builder from which to load widgets.
ett (
int
) – the estimated time for the talk, in seconds.timing_tracker – (
TimingReport
): to inform when the slides changeautoplay – (
AutoPlay
): to adjust the timer display if we’re auto-playing/looping slides
- label_time = None¶
Elapsed time
Label
- label_clock = None¶
Clock
Label
- label_colorer = None¶
TimeLabelColorer
that handles setting the colors oflabel_time
- ett = None¶
EstimatedTalkTime
that handles changing the ett
- timing_tracker = None¶
The
TimingReport
, needs to know when the slides change
- pause_action = None¶
The pause-timer
Action
- switch_pause(gaction, param=None)[source]¶
Switch the timer between paused mode and running (normal) mode.
- Returns:
whether the clock’s pause was toggled.
- Return type:
- pause()[source]¶
Pause the timer if it is not paused, otherwise do nothing.
- Returns:
whether the clock’s pause was toggled.
- Return type:
- unpause()[source]¶
Unpause the timer if it is paused, otherwise do nothing.
- Returns:
whether the clock’s pause was toggled.
- Return type:
pympress.config
– Configuration¶
- class pympress.config.Config[source]¶
Bases:
ConfigParser
,object
Manage configuration :Get the configuration from its file and store its back.
- placeable_widgets = {'annotations': 'p_frame_annot', 'current': 'p_frame_cur', 'highlight': 'scribble_overlay', 'next': 'grid_next', 'notes': 'p_frame_notes'}¶
dict
of strings that are the valid representations of widgets from the presenter window that can be dynamically rearranged, mapping to their names
- widget_reqs = {'highlight': ({'highlight'}, {'annotations', 'current', 'next', 'notes'}), 'highlight_notes': ({'highlight'}, {'annotations', 'current', 'next', 'notes'}), 'note_pages': ({'annotations', 'next', 'notes'},), 'notes': ({'current', 'next', 'notes'}, {'annotations'}), 'plain': ({'annotations', 'current', 'next'},)}¶
dict
mapping layout ids to tuples of their expected and optional widgets
- static path_to_config(search_legacy_locations=False)[source]¶
Return the path to the currently used configuration file.
- static toggle_portable_config(gaction, param=None)[source]¶
Create or remove a configuration file for portable installs.
The portable install file will be used by default, and deleting it causes the config to fall back to the user profile location.
No need to populate the new config file, this will be done on pympress exit.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- register_actions(builder)[source]¶
Register actions that impact the config file only.
- Parameters:
builder (
pympress.builder.Builder
) – a builder to setup the actions
- getlist(*args)[source]¶
Parse a config value and return the list by splitting the value on commas.
i.e. bar = foo,qux returns the list [‘foo’, ‘qux’]
- Returns:
a config value split into a list.
- Return type:
- getint(*args, **kwargs)[source]¶
Wrapper for configparser’s getint to handle parsing errors when a fallback is given.
See
getint()
- getfloat(*args, **kwargs)[source]¶
Wrapper for configparser’s to handle parsing errors when a fallback is given.
See
getfloat()
- getboolean(*args, **kwargs)[source]¶
Wrapper for configparser’s getboolean to handle parsing errors when a fallback is given.
getboolean()
- toggle_start(gaction, param=None)[source]¶
Generic function to toggle some boolean startup configuration.
- Parameters:
gaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- validate_layout(layout, expected_widgets, optional_widgets={})[source]¶
Validate layout: check whether the layout of widgets built from the config string is valid.
- Parameters:
Layout must have all self.placeable_widgets (leaves of the tree, as
str
) and only allowed properties on the nodes of the tree (asdict
).Constraints on the only allowed properties of the nodes are: - resizeable:
bool
(optional, defaults to no), - orientation:str
, either “vertical” or “horizontal” (mandatory) - children:list
of size >= 2, containingstr`s or `dict`s (mandatory) - proportions: `list
offloat
with sum = 1, length == len(children), representing the relative sizes of all the resizeable items (if and only if resizeable).
- update_layout_tree(layout_name, layout)[source]¶
Update the layout named
layout_name
. Throws ValueError on invalid layouts.
- load_window_layouts()[source]¶
Parse and validate layouts loaded from config, with fallbacks if needed.
- widget_layout_to_tree(widget, pane_handle_pos)[source]¶
Build a tree representing a widget hierarchy, leaves are strings and nodes are
dict
.Recursive function. See validate_layout() for more info on the tree structure.
pympress.extras
– Manages the display of fancy extras such as annotations, videos and cursors¶
- class pympress.dialog.TimingReport(parent)[source]¶
Bases:
Builder
Widget tracking and displaying hierachically how much time was spent in each page/section of the presentation.
- timing_treeview = None¶
The
TreeView
containing the timing data to display in the dialog
- time_report_dialog = None¶
A
Dialog
to contain the timing to show
- clear_on_next_transition = False¶
bool
marking whether next page transition should reset the history of page timings
- reset(reset_time)[source]¶
A timer reset. Clear the history as soon as we start changing pages again.
- static format_time(secs)[source]¶
Formats a number of seconds as
minutes:seconds
.- Returns:
The formatted time, with 2+ digits for minutes and 2 digits for seconds.
- Return type:
- class pympress.dialog.LayoutEditor(parent, config)[source]¶
Bases:
Builder
Widget tracking and displaying hierachically how much time was spent in each page/section of the presentation.
- layout_treeview = None¶
The
TreeView
displaying the hierarchical layouts
- layout_treemodel = None¶
The
TreeModel
containing the model of the layouts to view in the treeview
- orientations_model = None¶
The
ListModel
containing the possible orientations
- layout_dialog = None¶
A
Dialog
to contain the layout edition dialog
- layout_description = None¶
A
Label
to contain the description of the layout
- layout_selector = None¶
A
ComboBoxText
to select the layout to edit
- next_frames_action = None¶
Action
containing the number of next frames
- hltools_orientation_action = None¶
Action
containing the orientation
- layout_descriptions = {'highlight': 'Layout to draw on the current slide', 'highlight_notes': 'Layout to draw on the current slide with notes displayed', 'note_pages': 'Layout for libreoffice notes on separate pages (with current slide preview in notes)', 'notes': 'Layout for beamer notes on second screen (no current slide preview in notes)', 'plain': 'Plain layout, without note slides'}¶
- ui_load_layout()¶
callback, to be connected to
load_layout()
- load_layout()[source]¶
Load the given layout in the treemodel for display and manipulation in the treeview
- set_current_layout(layout)[source]¶
Update which is the layout currently used by the UI
- Parameters:
layout (
str
) – the layout id
- layout_selected(widget, event=None)[source]¶
Manage events for the layout selector drop-down menu
- Parameters:
widget (
ComboBox
) – the widget which has been modifiedevent (
Event
) – the GTK event
- get_info(path)[source]¶
Given a path string, look up the appropriate item in both the actual and GtkStore models
- resizeable_toggled(widget, path)[source]¶
Handle when box’ resizeable value is toggled
- Parameters:
widget (
ComboBox
) – the widget which has been modifiedpath (
str
) – A string representing the path to the modfied item
- orientation_changed(widget, path, orient_it)[source]¶
Handle when the orientation of a box is changed
- Parameters:
widget (
ComboBox
) – the widget which has been modifiedpath (
str
) – A string representing the path to the modfied itemorient_it (
TreeIter
) – the row of the newly selected value in the orientations liststore model
- treemodel_to_tree(iterator, parent_horizontal=False, parent_resizeable=False)[source]¶
Recursive function to transform the treemodel back into our dict-based representation of the layout
- normalize_layout(widget=None, drag_context=None, reload=True)[source]¶
Handler at the end of a drag-and-drop in the treeview
Here we transform the listmodel modified by drag-and-drop back to a valid
dict
andstr
hierarchy, and then trigger the loading of the layout again to display the corrected layout.- Parameters:
widget (
Widget
) – The object which received the signaldrag_context (
DragContext
) – the drag contextreload (
bool
) – whether to reload the layout into the treemodel
- class pympress.dialog.AutoPlay(parent)[source]¶
Bases:
Builder
Widget and machinery to setup and play slides automatically, optionally in a loop
- autoplay_dialog = None¶
A
Dialog
to contain the layout edition dialog
- autoplay_spin_lower = None¶
The
SpinButton
for the lower page
- autoplay_spin_upper = None¶
The
SpinButton
for the upper page
- autoplay_spin_time = None¶
The
SpinButton
for the transition between slides
- autoplay_button_loop = None¶
The
CheckButton
to loop
- source = None¶
Source
which is the source id of the periodic slide transition, orNone
if there is no autoplay
- remain = None¶
if the timeout has been paused,
int
which represents the number of milliseconds until the next page slide
- goto_page()¶
callback, to be connected to
goto_page()
- set_doc_pages(n_pages)[source]¶
Callback for when a document number of pages changes
- Parameters:
n_pages (
int
) – the number of pages of the loaded document
- page_changed(spin_button, scroll_direction)[source]¶
Callback for when a page spin button is modified, maintains a delta of at least 2 pages between first and last page of the intended loop. (No loops needed to loop a single slide.)
- Parameters:
spin_button (
SpinButton
) – The button whose value was changedscroll_direction (
ScrollType
) – The speed and amount of change
pympress.extras
– Manages the display of fancy extras such as annotations, videos and cursors¶
- class pympress.extras.Annotations(builder)[source]¶
Bases:
object
Widget displaying a PDF’s text annotations.
- annotations_treeview = None¶
The containing
TreeView
widget for the annotations
- annotations_liststore = None¶
The containing
ListStore
storing the annotations to be displayed
- annotation_column = None¶
The
TreeViewColumn
where the text is rendered
- annotation_renderer = None¶
The
CellRendererText
defining how text is rendered
- editing = None¶
The
Entry
in which we are currently editing an annotation, or None
- new_doc_annotation()¶
- set_doc_annotation()¶
- remove_doc_annotation()¶
- load_annotations(annot_page)[source]¶
Add annotations to be displayed (typically on going to a new slide).
- Parameters:
annot_page (
Page
) – The page object that contains the annotations
- try_cancel()[source]¶
Try to cancel editing
- Returns:
whether editing was enabled and thus canceled
- Return type:
- rewrap_annotations()[source]¶
Update the wrap-width of the annotation column to fit its actual width
- key_event(widget, event)[source]¶
Handle a key (press/release) event.
Needed to forward events directly to the
Entry
, bypassing the global action accelerators.- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- editing_started(cell_renderer, widget, entry_number)[source]¶
Handle edit start
- Parameters:
cell_renderer (
CellRenderer
) – The renderer which received the signalwidget (
CellEditable
) – the Gtk entry editing the annotation entryentry_number (
str
) – the string representation of the path identifying the edited cell
- editing_validated(cell_renderer, entry_number, new_content)[source]¶
Handle successful edit: store the new cell value in the model and the document
- editing_finished(cell_renderer)[source]¶
Handle the end of editing
- Parameters:
cell_renderer (
CellRenderer
) – The renderer which received the signal
- class pympress.extras.Media(builder, conf)[source]¶
Bases:
object
Class managing statically the medias and media player backends, to enable play/pause callbacks.
- Parameters:
- c_overlay = None¶
Overlay
for the Content window.
- p_overlay = None¶
Overlay
for the Presenter window.
- types_list = {}¶
dict
containing backends and their mappings to mime type lists for which they are enabled. A default backend is marked by an empty list.
- toggle(gaction, param=None)[source]¶
Toggle a backend (if it was loaded correctly)
- Parameters:
gaction (
Action
) – the action triggering the call, which identifies which backendparam (
Variant
) – an optional parameter
- replace_media_overlays(current_page, page_type)[source]¶
Remove current media overlays, add new ones if page contains media.
- adjust_margins_for_mode(page_type)[source]¶
Adjust the relative margins of child widgets for notes mode update.
- Parameters:
page_type (
PdfPage
) – The part of the page to display
- play(media_id, gaction=None, param=None)[source]¶
Starts playing a media. Used as a callback.
- Parameters:
media_id (
int
) – A unique identifier of the media to start playinggaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- hide(media_id, gaction=None, param=None)[source]¶
Stops playing a media and hides the player. Used as a callback.
- Parameters:
media_id (
int
) – A unique identifier of the media to start playinggaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- play_pause(media_id, gaction=None, param=None)[source]¶
Toggles playing and pausing a media. Used as a callback.
- Parameters:
media_id (
int
) – A unique idientifier of the media to start playinggaction (
Action
) – the action triggering the callparam (
Variant
) – the parameter as a variant, or None
- set_time(media_id, gaction=None, param=None)[source]¶
Set the player of a given media at time t. Used as a callback.
- Parameters:
media_id (
int
) – A unique idientifier of the media to start playinggaction (
Action
) – the action triggering the callparam (
Variant
) – A wrapped float containing the time to which we have to go.
- class pympress.extras.Cursor[source]¶
Bases:
object
Class managing cursors statically for displays, so we can select the mouse cursor with a simple string.
- class pympress.extras.Zoom(builder)[source]¶
Bases:
object
Manage the zoom level (using a cairo matrix), draw area that will be zoomed while it is being selected.
- Parameters:
builder (
Builder
) – A builder from which to load widgets
- zoom_selecting = False¶
Whether we are displaying the interface to scribble on screen and the overlays containing said scribbles
- zoom_points = None¶
- scale = 1.0¶
- shift = (0, 0)¶
- p_central = None¶
Box
in the Presenter window, used to reliably set cursors.
- redraw_current_slide()¶
callback, to be connected to
redraw_current_slide()
- clear_cache()¶
callback, to be connected to
clear_cache()
- set_action_enabled = None¶
callback, to be connected to
set_action_enabled()
- start_zooming(*args)[source]¶
Setup for the user to select the zooming area.
- Returns:
whether the event was consumed
- Return type:
- stop_zooming(*args)[source]¶
Cancel the zooming, reset the zoom level to full page.
- Returns:
whether the event was consumed
- Return type:
- get_slide_point(widget, event)[source]¶
Gets the point on the slide on a scale (0..1, 0..1), from its position in the widget.
- get_matrix(ww, wh)[source]¶
Returns the
Matrix
used to perform the zoom for the widget of size ww x wh.
- track_zoom_target(widget, event)[source]¶
Draw the zoom’s target rectangle.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- toggle_zoom_target(widget, event)[source]¶
Start/stop drawing the zoom’s target rectangle.
- Parameters:
widget (
Widget
) – the widget which has received the event.event (
Event
) – the GTK event.
- Returns:
whether the event was consumed
- Return type:
- class pympress.extras.FileWatcher[source]¶
Bases:
object
A class that wraps watchdog objects, to trigger callbacks when a file changes.
- timeout = 0¶
- callback()¶
Callback to be called on file changes, usually connected to
reload_document()
- observer = None¶
A
Observer
to watch when the file changes
- monitor = None¶
A
FileSystemEventHandler
to get notified when the file changes
- watch_file(uri, callback, *args, **kwargs)[source]¶
Watches a new file with a new callback. Removes any precedent watched files.
If the optional watchdog dependency is missing, does nothing.
- Parameters:
uri (
str
) – URI of the file to watchcallback (
function
) – callback to call with all the further arguments when the file changes
pympress.deck
– Manage user drawings on the current slide¶
- class pympress.deck.Overview(config, builder, notes_mode)[source]¶
Bases:
Builder
UI that allows to draw free-hand on top of the current slide.
- Parameters:
- deck_mode = False¶
Whether we are displaying the deck overview on screen
- deck_viewport = None¶
Viewport
that replaces normal panes when deck is shown
- deck_grid = None¶
Grid
that displays all the slides of the overview
- deck0 = None¶
The
DrawingArea
for the first slide
- deck_off_render = None¶
A
OffscreenWindow
where we render the deck interface when it’s not shown
- p_central = None¶
Box
in the Presenter window, where we insert deck.
- resize_cache()¶
callback, to be connected to
resize_widget()
- c_da = None¶
The
DrawingArea
in the content window
- cache = None¶
SurfaceCache
instance.
- load_layout()¶
callback, to be connected to
load_layout()
- goto_page()¶
callback, to be connected to
goto_page()
- compute_frame_grid()¶
callback, to be connected to
compute_frame_grid()
- all_pages = False¶
bool
whether we show all pages or remove consecutive identically labeled pages, keeping only the last
- setup_doc_callbacks(doc)[source]¶
Callbacks that need to be setup again at every new document
- Parameters:
doc (
Document
) – The new document that got loaded
- prerender(da)[source]¶
Perform in-cache rendering
- Parameters:
da (
DrawingArea
) – the widget for which we’re rendering
- on_deck_draw(widget, cairo_context)[source]¶
Actually draw the deck slide – only do this from cache, to limit overhead
- on_deck_click(widget, event)[source]¶
A slide has been clicked, go to it
- Parameters:
widget (
Widget
) – the widget which has received the key strokeevent (
Event
) – the GTK event, which contains the key stroke details
- switch_deck_overview(gaction, target=None)[source]¶
Starts the mode where one can read on top of the screen.
Args:
- Returns:
whether the event was consumed
- Return type:
pympress.util
– various utility functions¶
- pympress.util.get_pympress_meta()[source]¶
Get metadata (version, etc) from pympress’ __init__.py or git describe.
- Returns:
metadata properties (version, contributors) mapped to their values
- Return type:
- pympress.util.close_opened_resources()[source]¶
Close all importlib context managers for resources that we needed over the program lifetime.
- pympress.util.get_translation(domain)[source]¶
Returns a gettext translation object.
This re-implements gettext’s translation() and find() to allow using a python 3.9 Traversable as localedir
- Returns:
A gettext translation object with the strings for the domain loaded
- Return type:
- pympress.util.get_portable_config()[source]¶
Returns the path to the configuration file for a portable install (i.e. in the install root).
May return None if the install root is not a real directory (e.g. in a zip file).
- pympress.util.get_default_config()[source]¶
Returns the path to the configuration file containing the defaults.
- Returns:
The path to the portable configuration file.
- Return type:
- pympress.util.get_user_config()[source]¶
Returns the path to the configuration file in the user config directory
- Returns:
path to the user configuration file.
- Return type:
- pympress.util.load_style_provider(style_provider)[source]¶
Load the css and in a style provider
- Parameters:
style_provider (
CssProvider
) – The style provider in which to load CSS- Returns:
The style provider with CSS loaded
- Return type:
CssProvider
- pympress.util.get_ui_resource_file(name, ext='.glade')[source]¶
Load an UI definition file from pympress’ resources
- pympress.util.get_log_path()[source]¶
Returns the appropriate path to the log file in the user app dirs.
- Returns:
path to the log file.
- Return type:
- pympress.util.fileopen(f)[source]¶
Call the right function to open files, based on the platform.
- Parameters:
f (path-like) – path to the file to open
- pympress.util.introspect_flag_value(flags_class, nick, fallback)[source]¶
Get the value of a flag from its class, given a value’s name (or nick)
Introspection technique (in particular __flags_values__ dict) inspired from pygtkcompat. This is needed because there is no typelib for libgstplayback.
- exception pympress.util.NoMonitorPositions[source]¶
Bases:
Exception
The Exception we raise when there is no way of figuring out the monitor position of windows
- class pympress.util.ScreenArea(obj)[source]¶
Bases:
object
Convenience class to represent monitors or windows in terms of the area (position and size) they use on screen
This is similar to
Monitor
, but necessary as we want to handle “mirrored” monitors as if they were a single monitor, and only use “extended” monitors as target for content window position and/or fullscreening.- most_intersection(candidates)[source]¶
Find the rectangle that intersects most with
rect
incandidates
- Parameters:
candidates (iterable of `ScreenArea`s) – The monitor areas to check for intersection
- Returns:
The best candidate screen area, i.e. that has the largest intersection
- Return type:
- least_intersection(candidates)[source]¶
Find the rectangle that intersects least with
rect
incandidates
- Parameters:
candidates (iterable of `ScreenArea`s) – The monitor areas to check for intersection
- Returns:
The best candidate screen area, i.e. that has the smallest intersection
- Return type:
- intersection(other)[source]¶
Compute the intersection of 2 screen areas
- Parameters:
other (
ScreenArea
) – The screen area to compare with- Returns:
An area representing the intersection, or
None
if there is no intersection- Return type:
ScreenArea
orNone
- equal(other)[source]¶
Check whether 2 areas cover the exact same space
- Parameters:
other (
ScreenArea
) – The screen area to compare with- Returns:
True
iff the areas are identical- Return type:
- contains(other)[source]¶
Check whether this area contains
other
- Parameters:
other (
ScreenArea
) – The screen area to compare with- Returns:
True
iff the area is contained- Return type:
- intersects(other)[source]¶
Check whether this area intersects
other
- Parameters:
other (
ScreenArea
) – The screen area to compare with- Returns:
True
iff the areas have an intersection- Return type:
- class pympress.util.Monitor(obj, id_=None, num=None)[source]¶
Bases:
ScreenArea
A specialised
ScreenArea
representing a monitor, with an descriptive string and a monitor number
- pympress.util.make_windows_dpi_aware()[source]¶
Set to avoid blurriness issues on High-DPI resolutions with scaling.
pympress.media_overlays.base
– base widget to play videos with an unspecified backend¶
- class pympress.media_overlays.base.VideoOverlay(container, page_type, action_map, media)[source]¶
Bases:
Builder
Simple Video widget.
All do_X() functions are meant to be called from the main thread, through e.g.
idle_add()
, for thread-safety in the handling of video backends.- Parameters:
container (
Overlay
) – The container with the slide, at the top of which we add the movie areapage_type (
PdfPage
) – the part of the page to displayaction_map (
ActionMap
) – the action map that contains the actions for this mediamedia (
Media
) – the object defining the properties of the video such as position etc.
- media_overlay = None¶
VBox
that contains all the elements to be overlayed.
- progress = None¶
Scale
that is the progress bar in the controls toolbar - if we have one.
- movie_zone = None¶
DrawingArea
where the media is rendered.
- relative_margins = None¶
tuple
containing the left/top/right/bottom space around the drawing area in the visible slide
- dragging_paused = False¶
bool
that tracks whether the playback was paused when the user started dragging the position
- time_format = '{:01}:{:02}'¶
ss / m:ss when the max time is known
- Type:
Format of the video time, defaults to m
- Type:
ss, changed to m
- parent = None¶
Overlay
that is the parent of the VideoOverlay widget.
- relative_page_margins = None¶
tuple
containing the left/top/right/bottom space around the drawing area in the PDF page
- action_map = None¶
ActionMap
containing the actios for this video overlay
- handle_embed(mapped_widget)[source]¶
Handler to embed the video player in the window, connected to the
map
signal.
- format_millis(sc, prog)[source]¶
Callback to format the current timestamp (in milliseconds) as minutes:seconds.
- Parameters:
sc (
Scale
) – The scale whose position we are formattingprog (
float
) – The position of theScale
, i.e. the number of seconds elapsed
- update_range(max_time)[source]¶
Update the toolbar slider size.
- Parameters:
max_time (
float
) – The maximum time in this video in s
- update_progress(time)[source]¶
Update the toolbar slider to the current time.
- Parameters:
time (
float
) – The time in this video in s
- progress_moved(rng, sc, val)[source]¶
Callback to update the position of the video when the user moved the progress bar.
- Parameters:
rng (
Range
) – The range corresponding to the scale whose position we are formattingsc (
Scale
) – The scale whose position we are updatingval (
float
) – The position of theScale
, which is the number of seconds elapsed in the video
- update_margins_for_page(page_type)[source]¶
Recalculate the margins around the media in the event of a page type change.
- Parameters:
page_type (
PdfPage
) – the part of the page to display
- is_shown()[source]¶
Returns whether the media overlay is currently added to the overlays, or hidden.
- do_play()[source]¶
Start playing the media file.
Should run on the main thread to ensure we avoid reentrency problems.
pympress.media_overlays.gif
– widget to play gif images as videos¶
- class pympress.media_overlays.gif_backend.GifOverlay(*args, **kwargs)[source]¶
Bases:
VideoOverlay
A simple overlay mimicking the functionality of showing videos, but showing gifs instead.
- anim = None¶
A
PixbufAnimation
containing all the frames and their timing for the displayed gif
- draw(widget, ctx)[source]¶
Simple resized drawing: get the pixbuf, set the transform, draw the image.
- advance_gif()[source]¶
Advance the gif, queue redrawing if the frame changed, and schedule the next frame.
- do_set_time(t)[source]¶
Set the player at time t.
Should run on the main thread to ensure we avoid reentrency problems.
- do_play()[source]¶
Start playing the media file.
Should run on the main thread to ensure we avoid reentrency problems.
pympress.media_overlays.gst
– widget to play videos using Gstreamer’s Gst¶
- class pympress.media_overlays.gst_backend.GstOverlay(*args, **kwargs)[source]¶
Bases:
VideoOverlay
Simple Gstramer widget.
Wraps a simple gstreamer playbin.
- playbin = None¶
A
Playbin
to be play videos
- sink = None¶
A
Sink
to display video content
- on_state_changed(bus, msg)[source]¶
Callback triggered by playbin state changes.
- Parameters:
bus (
Bus
) – the bus that we are connected tomsg (
Message
) – the “state-changed” message
- do_update_duration(*args)[source]¶
Transmit the change of file duration to the UI to adjust the scroll bar.
- do_play_pause()[source]¶
Toggle pause mode of the media.
Should run on the main thread to ensure we avoid reentrency problems.
pympress.media_overlays.vlc
– widget to play videos using VLC¶
- pympress.media_overlays.vlc_backend.get_window_handle(window)[source]¶
Uses ctypes to call gdk_win32_window_get_handle which is not available in python gobject introspection porting.
Solution from http://stackoverflow.com/a/27236258/1387346
- Parameters:
window (
Window
) – The window for which we want to get the handle- Returns:
The handle to the win32 window
- class pympress.media_overlays.vlc_backend.VlcOverlay(*args, **kwargs)[source]¶
Bases:
VideoOverlay
Simple VLC widget.
Its player can be controlled through the ‘player’ attribute, which is a
MediaPlayer
instance.- handle_embed(mapped_widget)[source]¶
Handler to embed the VLC player in the window, connected to the
map
signal.
- handle_end()[source]¶
End of the stream reached: restart if looping, otherwise hide overlay
Overrided because, to implement looping, vlc plugin needs to be told to start on stream end, not to seek
- do_play()[source]¶
Start playing the media file.
Should run on the main thread to ensure we avoid vlc plugins’ reentrency problems.
- show()[source]¶
Bring the widget to the top of the overlays if necessary − also force redraw of movie zone
- do_play_pause()[source]¶
Toggle pause mode of the media.
Should run on the main thread to ensure we avoid vlc plugins’ reentrency problems.
- time_changed(event)[source]¶
Handle time passing
- Parameters:
event (
Event
) – The event that triggered the handler