Habenwill!

• für die Ausführung wird Flask benötigt

• Download und Entpacken des Quellcodes von GitHub

• kbgen.py ausführen, dies startet den internen Flask-Server

• 127.0.0.1:5000 aufrufen

• Workout generieren

• Werte können per Spinner geändert werden

Konfiguration

In der kbgen.py gibt es 3 Variablen für individuelle Einstellungen:

1. `REPS_PRESET`: Tupel mit 2 Werten (int) für die Preset-Buttons, Gesamtwiederholungen

2. `KB_EX`: Liste von Übungen, die bei der Kettlebattle zur Auswahl stehen sollen, ein Listeneintrag ist ein Tupel nach dem Muster (Name, Minimum bei Preset 1, Minimum bei Preset 2)

3. `MAX_EX`: Maximale Anzahl (int) von Übungen, die aus der Liste durchgeführt werden sollen, Minimumwerte werden immer gezählt

GtkSourceView

Die SourceView-Widgets befinden sich unterhalb einer eigenen gleichnamigen Hauptkategorie in der Seitenleiste.

• GtkSourceView: das eigentliche Editorwidget, das in einem ScrolledWindow platziert wird

• GtkSourceMap: Miniaturansicht und Unterklasse von SourceView

• GtkSourceStyleSchemeChooserWidget: Widget zur Auswahl eines StyleSchemes

In Glade lassen sich bereits viele Eigenschaften des Editorbereichs festlegen wie die Anzeige der Zeilennummern, Einrückung, Umbruchverhalten usw., die sich natürlich auch über set_property festlegen oder ändern lassen.

Beim StyleChooser-Widget wird das Signal button-release-event belegt, um das ausgewählte StyleScheme auf die SourceView-Widgets anzuwenden.

SourceMap

Das Widget muss mit der anzuzeigenden Quelle, einem SourceView-Widget, verknüpft werden (über "Allgemein > View"). Es wird dann der Inhalt des SourceView-Widgets verkleinert (standardmäßig mit Schriftgröße in 1pt) angezeigt. Durch scrollen in SourceMap verändert man gleichzeitig die Anzeige in SourceView.

Headerbar

Die Headerbar enthält verschiedene Buttons zum Laden, Suchen und Speichern:

• "Python file" und "Glade file" laden die entsprechenden Dateien dieses Beispieles in den Editor (Signal clicked)

• Die Sucheingabe ist ein Gtk.SearchEntry-Widget (Signale search-changed und activate)

• "Save .bak" und "Save" speichern die Dateien (Signal clicked)

SourceView

GObject.type_register(GtkSource.View)

self.buffer = self.view.get_buffer()

self.sourcefile = GtkSource.File()
self.lang_manager = GtkSource.LanguageManager()

sourcefile.set_location(Gio.File.new_for_path("file"))
buffer.set_language(self.lang_manager.get_language("language"))
loader = GtkSource.FileLoader.new(buffer, sourcefile)
loader.load_async(0, None, None, None, None, None)

# bestehende Datei überschreiben
saver = GtkSource.FileSaver.new(buffer, sourcefile)
# Datei unter anderem Namen speichern
saver = GtkSource.FileSaver.new_with_target(buffer, sourcefile, targetfile)
# Speichern ausführen
saver.save_async(0, None, None, None, None, None)

settings = GtkSource.SearchSettings()
search_context = GtkSource.SearchContext.new(buffer, settings)

builder.get_object("search_entry").bind_property('text', settings, 'search-text')

def find_text(self, start_offset=1):
    buf = self.buffer
    insert = buf.get_iter_at_mark(buf.get_insert())
    start, end = buf.get_bounds()
    insert.forward_chars(start_offset)
    match, start_iter, end_iter, wrapped = self.search_context.forward2(insert)

    if match:
        buf.place_cursor(start_iter)
        buf.move_mark(buf.get_selection_bound(), end_iter)
        self.view.scroll_to_mark(buf.get_insert(), 0.25, True, 0.5, 0.5)
        return True
    else:
        buf.place_cursor(buf.get_iter_at_mark(buf.get_insert()))

StyleChooser

Das Widget zeigt die verfügbaren Stile an. Es ist nicht möglich, lokale Stile anzugeben oder sie zu verändern.

Der angewählte Style lässt sich dann einfach auf den gewünschten Buffer anwenden:

def on_signal_emitted(self, widget, event):
    buffer.set_style_scheme(widget.get_style_scheme())

Initialisierung

Nach der Installation erstellt man das Projektverzeichnis und initialisiert mit

$ sphinx-quickstart

das Grundgerüst. Fast alle Fragen können auf der Voreinstellung belassen werden. Im Projektverzeichnis befindet sich nun die Konfigurationsdatei conf.py sowie das Root-Dokument index.rst.

Die Dateien lassen sich nach dem Muster make Builder erzeugen, die in den Unterverzeichnissen _build/builder befinden:

$ make epub
$ make latexpdf

conf.py

#HTML-Dateien vor dem Inhalt der index.rst einfügen
epub_pre_files = [('info.xhtml', 'Info')]
html_additional_pages = {'info': 'info.html'}

#Titel erzeugen
epub_cover = ('_static/cover.png', 'epub-cover.html')

#Stichwortverzeichnis auslassen
epub_use_index = False

#Bezeichnung der Ausgabedatei
epub_basename = output_basename

#für die Generierung der info.xhtml benötigt, da sonst None
html_last_updated_fmt = '%d. %B %Y'

#Papierformat (Standard ist US-Letter), leere Seiten vermeiden
latex_elements = {
    'papersize': 'a4paper',
    'classoptions': 'oneside,openany'
}

#Logo auf der Titelseite
latex_logo = '_static/logo.png'

pygments_style = 'borland'
output_basename = 'gladepytutorial'

_static

In diesem Ordner befinden sich Stylesheets, Bilder und Skripte, die nach den vorgegebenen Dateien geladen werden. So kann man lokale individuelle Stylesheet-Anpassungen vornehmen, ohne das Theme selbst zu modifizieren. Hier befinden sich eine angepasste pygments.css, cover.png (Epub) und logo.png (PDF).

_templates

Analog zu _static befinden sich hier individuelle Templates. Diese werden standardmäßig mit der Template-Engine Jinja2 betrieben. Hier befindet sich info.html, die in der Epub-Ausgabe Verwendung findet.

Epub: zusätzliche Dateien einfügen

Sphinx bietet mit epub_pre_files (und analog epub_post_files) die Option, zusätzliche und nicht zur eigentlichen Dokumentation gehörenden (X)HTML-Dateien zum Epub hinzuzufügen. Diese müssen allerdings zunächst als zusätzliche HTML-Seiten generiert werden. Dafür wird in der conf.py die Variable html_additional_pages entsprechend gesetzt 1.

1

Es hat mich einen (EINEN!) Tag gekostet dies herauszufinden...

index.rst

Dies ist das Hauptdokument, das von jedem Sphinx-Builder geparst wird. Die Bezeichnung wird in der conf.py in der Variable master_doc festgelegt.

Als reguläre reST-Datei kann sie beliebig viel Inhalt aufnehmen. Es ist allerdings zu empfehlen und im Normalfall vermutlich sowieso bereits der Fall, das Dokument in mehrere Dateien aufzuteilen. Sphinx stellt dafür die eigene toctree-Directive zur Verfügung.

.. toctree::
    :maxdepth: 1
    :numbered:
    :caption: Inhalt

    teildokument1
    teildokument2
    ...

Dateien außerhalb von toctree werden per include-Directive hinzugefügt.

Es ist auch möglich, Inhalte nur von bestimmten Buildern berücksichtigen zu lassen:

.. only:: latex

    .. include:: info.rst

KindleGen

Amazon möchte zwar keine Epubs 2 unterstützen, aber sie bieten mit KindleGen ein Tool an, welches diese in die eigenen Formate (KF8, Mobi) überführt.

Auf diese Weise lässt sich mit

$ kindlegen input.epub

eine Mobi-Datei erzeugen.

2

oder Google-Apps...

Problem: Encoding

Das aus dem Epub erstellte E-Book im Mobi-Format hat ein Darstellungsproblem mit einigen (Sonder-)Zeichen.

Abhilfe schafft hier die Zeile

<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />

an Stelle von

<meta charset="utf-8" />

innerhalb des HTML-Heads. Sphinx bietet dafür die meta-Directive, die allerdings für jede Datei gesetzt werden muss:

.. meta::
    :http-equiv=Content-Type: text/html; charset=UTF-8

Waypoints

Manual scrolling

Scrolling through route waypoints is accomplished by pressing the N/S buttons. If you reach the last waypoint you can end your ride by confirming the "Arrived?" question.

There still is no information on waypoint progress on the device but it is shown in the app.

App: waypoint status

Button assignment

As already said skipping through waypoints is done by pressing the top or bottom button. Pressing and holding the bottom button switches the integrated lamp on and off. The right and left buttons let you flip through

Compass <-> Speed <-> Time <-> Battery status (phone and BeeLine) <-> Compass

It did not happen anymore that I accidentally finished a ride, so this problem vanished.

Route import (whoop, whoop)

Not only can a route be created via BeeLine app but also be imported from a GPX file. In doing so the track will be simplified and (significant) changes of direction will be converted into waypoints. Two waypoints are always connected by a straight line (beeline).

Left: imported simplified route with waypoints. Right: original GPS track in Locus app

As you can see this works pretty nice. This route conversion provides waypoints for relevant route details (important changes of direction, crossroads, bridges) without determining a certain track layout.

Only few waypoints necessary to outline route

Ride routes in opposite direction

This would save some work for creating routes in reverse order.

Waypoint progress

I'd like to have that waypoint progress status shown on the device like it is displayed in the app ("Waypoint 6/20"). Yes, I know that this is unrelated to distances. That information does not have to be permanently present, I can imagine it to be integrated as a page on the right/left button page scroll function.

Pause ride

A funtion to pause/continue routes instead of finishing them would be helpful (for example to proceed on long tours or when spontaneously jumping into a nearby supermarket).

Calibration

We all hate it: the horseshoe symbol on the Beeline - bar left, bar right, front wheel up and agein. This is easy with the racing bike but a torture with the pannier packed trucker.

I don't really have a constructive suggestion here. The calibration horseshoe often appears during a ride and disappears after a while (sometimes within seconds). I mostly ignore it now.

Me vs. me

1. I often ride the same routes.

2. Everybody likes statistics.

So why not show a route summary with some information (frequency, duration, distance, speed)?

Stack

Stacks can be found in the sidebar's 'Container' section. Pages are easily created and edited via Glade. Sub-widgets in the example file are Gtk.Image, Vte.Terminal and Gtk.Notebook.

The stack switcher widget can be obtained from 'Controls and Display' and is placed to the headerbar. It's also possible to put it into a regular container widget like boxes. Pages can be shown in vertical or horizontal order. In "General > Stack" a stack element must be assigned to the widget. The page name shown by the stack switcher widget can be edited via "Packing > Title" of the sub-widget. This sub-widget has to be created in the first place, a new created stack has empty pages.

Notebook

Notebook can also be found in the 'Container' section. The tab's control unit is an integrated label child widget automatically generated on page creation. Gtk.ScrolledWindows are used here as the pages' container widgets. These are also required for displaying (long) tables (see also List-/TreeStore articles No. 1 und No. 2).

The tab bar of a notebook provides reserved space for additional widgets like fixed buttons ("General > Start/End Action"). In the example there will be created a "Home" button in the start area.

WebKit2

The webpages in the example are rendered by WebKit2. The essential module to use is WebKit2.WebView. A new WebView object itself already is a scrollable Gtk+ widget within a Gtk.Viewport element. According to the API reference it does not have to be placed in a Gtk.ScrolledWindow container widget. Having tested this that works for Gtk.Stack but not for Gtk.Notebook. That's why in the example there is used a ScrolledWindow as underlying container widget.

The following pattern is used to create a WebView widget:

#create new WebView widget
webview = WebKit2.WebView()
#send URL to widget
webview.load_uri("http://google.com")
#add webview to notebook
notebook.add(webview)
#add webview to stack
stack.add_titled(webview, name, "StackSwitcher title")

webview.show()

Read more…