Google Takeout

Zunächst benötigt man die Daten aus dem Takeout. Da sich hier große Datenmengen ansammeln, ist es ratsam, keine weiteren außer Googe+-relevanten Produkte auszuwählen:

• Button "Nichts auswählen", dann "Stream in Google+" aktivieren

• Als Dateiformat HTML wählen

• Als Archivformat zip wählen, bei tar.gz kann es Encodingprobleme geben

• Nach Fertigstellung kann das/die Archiv/e heruntergeladen und entpackt werden

• die index.html gibt Hinweise auf Fehler bei der Archiverstellung

Nikola

1. Installation:

   Nikola kann über pip oder je nach verwendeter Distribution über die Paketverwaltung installiert werden: Getting Started.

2. Initialisierung:

   Das Plugin kann in einer bestehenden mit Nikola verwalteten Webseite erstellt werden. Es ist aber auch möglich, für diesen Verwendungszweck eine neue leere Seite zu erstellen, die dann später wieder gelöscht wird:

$ nikola init gplus_dummy_site

3. Plugin installieren:

   Zuerst das Plugin als Archiv herunterladen und entpacken oder das Repository klonen: encarsia/gplus_nikola_import. Anschließend muss man noch den Ordner in die im vorigen Schritt angelegten Seite in den noch anzulegenden plugins-Ordner kopieren.

4. Optional: Um die Übersicht zu behalten, kann man auch den Takeout-Ordner in die Nikola-Seite verschieben.

Dateistruktur

Vor dem Ausführen des Imports öffnet man zunächst die Konfigurationsdatei config.yaml. Hier lassen sich zum Beispiel Filteroptionen einstellen.

Die Ordnerbezeichnungen entsprechen der deutschen Spracheinstellung des Takeouts, bei abweichender Spracheinstellung muss man hier die entsprechenden Bezeichnungen der Dateistruktur anpassen.

Es werden Beiträge nach Verteilungsstatus unterschieden:

1. Öffentlich geteilt

2. Mit Meinen Kreisen geteilt

3. Mit Erweiterten Kreisen geteilt

4. Mit bestimmten Kreisen oder Personen/Profilen geteilt

5. Beiträge in Communites

6. Beiträge in Sammlungen

$ nikola import_gplus_html -s takeout
[...]
************************************************
*                                              *
* Share information of your G+ Takeout archive *
*                                              *
************************************************

=======
General
=======

(edit the "shared" section of your config.yaml)

Geteilt mit: Öffentlich (1832)
Shared to the community (704)
Shared to the collection (429)
[...]

===========
Communities
===========

(edit the "import" section of your config.yaml:
    > set "com" to True to include communities
    > exclude communities by listing them in "com_filter")

E-Book (275)
Das Gruselkabinett des Dr. Goo (196)
Deleted community (65)
[...]

===========
Collections
===========

(collections are considered public so this is FYI only)

Zapping (66)
Street|p|arts (61)
Unterwegs (54)
[...]

Beiträge filtern

Mit der Option import_private lässt sich einstellen, ob mit bestimmten Kreisen oder Personen/Profilen geteilte Beiträge importiert werden sollen.

Die Option import_com schaltet den Import von Communitybeträgen ein oder aus. Dabei wird nicht nach öffentlichen oder geschlossenen Communities unterschieden.

Albrecht-Daniel-Thaer-Saal

Bilddateien markieren

Falls man sein Archiv öffentlich zur Verfügung stellen möchte, mag es hilfreich oder erwünscht sein, Bilddateien mit einem Wasserzeichen oder Hinweis auf den Ursprung zu versehen.

Dafür setzt man watermark auf True und legt eine Textzeile fest (watermark_text). Dies erzeugt mit Hilfe von ImageMagick ein horizontales Textbanner für alle Bilder.

Die Dateien werden in einem separaten Ordner erstellt, ohne die Originaldateien zu überschreiben. Das bedeutet, man kann den Build-Prozess beliebig für beide Optionen laufen lassen, ohne den Import erneut ausführen zu müssen.

conf.py

Nun wechselt man in das Verzeichnis der neuen Nikola-Instanz (standardmäßig "new_site").

Dort befindet sich die Konfigurationsdatei conf.py. In dieser lassen sich nun Anpassungen vornehmen. Da im Beispiel das Thema hyde verwendet wird, wird dieses hier gleich angepasst, außerdem die Auslieferung des RSS-Feeds deaktiviert:

THEME = "hyde"
GENERATE_RSS = False

Thema

Hyde ist ein persönlicher Favorit und wird deshalb hier installiiert:

$ nikola theme -i hyde

Im Pluginordner befindet sich eine CSS-Datei custom.css, die einige optische Anpassungen für diesen Anwendungsfall enthält, diese einfach in das Verzeichnis themes/hyde/assets/css kopieren.

Grundsätzlich funktioniert die Seite mit jeden Theme. Eine Liste der verfügbaren Themes erhält man folgendermaßen:

$ nikola theme -l   # installierbar
$ nikola theme --list-installed     # installiert

Um ein Thema zu verwenden, muss es in der conf.py angegeben und die Seite neu gebaut werden. Ein erneuter Datenimport ist natürlich nicht notwendig.

Bilder

Möchte man die Bilddateien mit Textbanner verwenden, muss in der conf.py noch der entsprechende Ordner zugewiesen werden:

IMAGE_FOLDERS = {"images_wm": "images"}

Bei einem größeren Bildervolumen ist es eventuell sinnvoll, die Bild- und Thumbnailgröße einzuschränken:

MAX_IMAGE_SIZE = 800  # default 1280
IMAGE_THUMBNAIL_SIZE = 200   # default 400

Build

Die eigentliche Generierung der Seite erfolgt zum Schluss mit

$ nikola build

Den lokalen Server startet man mit

$ nikola serve
[2018-10-18T09:57:02Z] INFO: serve: Serving on http://127.0.0.1:8000/ ...

Videosink einrichten

self.sink = Gst.ElementFactory.make("gtksink")

Widget einrichten

video_widget = self.sink.get_property("widget")
builder.get_object("video_box").add(video_widget)

Python

23_gtksink_simpleplayer.py (Source)

#!/usr/bin/env python
# -*- coding: utf-8 -*-

import os
import time

import gi
gi.require_version("Gtk", "3.0")
gi.require_version("Gst", "1.0")
from gi.repository import Gst, Gtk, GLib


class GenericException(Exception):
    pass


class Handler:

    def on_window_destroy(self, *args):
        Gtk.main_quit()

    def on_playpause_togglebutton_toggled(self, widget):
        if app.playpause_button.get_active():
            img = Gtk.Image.new_from_icon_name(Gtk.STOCK_MEDIA_PLAY,
                                               Gtk.IconSize.BUTTON)
            widget.set_property("image", img)
            app.pause()
        else:
            img = Gtk.Image.new_from_icon_name(Gtk.STOCK_MEDIA_PAUSE,
                                               Gtk.IconSize.BUTTON)
            widget.set_property("image", img)
            app.play()

    def on_forward_clicked(self, widget):
        app.skip_time()

    def on_backward_clicked(self, widget):
        app.skip_time(-1)

    def on_progress_value_changed(self, widget):
        app.on_slider_seek

    def on_vbutton_clicked(self, widget):
        app.clear_playbin()
        app.setup_player("mediaplayer.avi")
        if app.playpause_button.get_active() is True:
            app.playpause_button.set_active(False)
        else:
            app.play()

    def on_ibutton_clicked(self, widget):
        app.clear_playbin()
        app.setup_player("mediaplayer.jpg")
        app.pause()


class GstPlayer:

    def __init__(self):

        # init GStreamer
        Gst.init(None)

        # setting up builder
        builder = Gtk.Builder()
        builder.add_from_file("23_gtksink_player.glade")
        builder.connect_signals(Handler())

        #self.movie_window = builder.get_object("play_here")
        self.playpause_button = builder.get_object("playpause_togglebutton")
        self.slider = builder.get_object("progress")
        self.slider_handler_id = self.slider.connect("value-changed", self.on_slider_seek)

        # setting up videoplayer
        self.player = Gst.ElementFactory.make("playbin", "player")
        self.sink = Gst.ElementFactory.make("gtksink")

        # setting up media widget
        video_widget = self.sink.get_property("widget")
        builder.get_object("video_box").add(video_widget)

        window = builder.get_object("window")
        window.show_all()

    def setup_player(self, f):
        # file to play must be transmitted as uri
        uri = "file://" + os.path.abspath(f)
        self.player.set_property("uri", uri)
        self.player.set_property("video-sink", self.sink)

    def play(self):
        self.is_playing = True
        self.player.set_state(Gst.State.PLAYING)
        # starting up a timer to check on the current playback value
        GLib.timeout_add(1000, self.update_slider)

    def pause(self):
        self.is_playing = False
        self.player.set_state(Gst.State.PAUSED)

    def current_position(self):
        status,position = self.player.query_position(Gst.Format.TIME)
        return position

    def skip_time(self, direction=1):
        # skip 20 seconds on forward/backward button
        app.player.seek_simple(Gst.Format.TIME,
                               Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT,
                               self.current_position() + float(20) * Gst.SECOND * direction,
                               )

    def update_slider(self):
        if not self.is_playing:
            return False # cancel timeout
        else:
            success, self.duration = self.player.query_duration(Gst.Format.TIME)
            # adjust duration and position relative to absolute scale of 100
            self.mult = 100 / (self.duration / Gst.SECOND)
            if not success:
                raise GenericException("Couldn't fetch duration")
            # fetching the position, in nanosecs
            success, position = self.player.query_position(Gst.Format.TIME)
            if not success:
                raise GenericException("Couldn't fetch current position to update slider")

            # block seek handler so we don't seek when we set_value()
            self.slider.handler_block(self.slider_handler_id)
            self.slider.set_value(float(position) / Gst.SECOND * self.mult)
            self.slider.handler_unblock(self.slider_handler_id)
        return True # continue calling every x milliseconds

    def on_slider_seek(self, widget):
        seek_time = app.slider.get_value()
        self.player.seek_simple(Gst.Format.TIME,  Gst.SeekFlags.FLUSH | Gst.SeekFlags.KEY_UNIT, seek_time * Gst.SECOND / self.mult)

    def clear_playbin(self):
        try:
            self.player.set_state(Gst.State.NULL)
        except:
            pass

    def main(self):
        Gtk.main()


app = GstPlayer()
app.main()

Glade

23_gtksink_player.glade (Source)

<?xml version="1.0" encoding="UTF-8"?>
<!-- Generated with glade 3.22.1 -->
<interface>
  <requires lib="gtk+" version="3.16"/>
  <object class="GtkAdjustment" id="adjustment">
    <property name="upper">100</property>
    <property name="step_increment">1</property>
    <property name="page_increment">10</property>
  </object>
  <object class="GtkImage" id="image1">
    <property name="visible">True</property>
    <property name="can_focus">False</property>
    <property name="stock">gtk-media-rewind</property>
  </object>
  <object class="GtkImage" id="image2">
    <property name="visible">True</property>
    <property name="can_focus">False</property>
    <property name="stock">gtk-media-forward</property>
  </object>
  <object class="GtkImage" id="image3">
    <property name="visible">True</property>
    <property name="can_focus">False</property>
    <property name="stock">gtk-media-pause</property>
  </object>
  <object class="GtkApplicationWindow" id="window">
    <property name="can_focus">False</property>
    <signal name="destroy" handler="on_window_destroy" swapped="no"/>
    <child type="titlebar">
      <object class="GtkHeaderBar">
        <property name="visible">True</property>
        <property name="can_focus">False</property>
        <property name="show_close_button">True</property>
        <child>
          <object class="GtkButton" id="vbutton">
            <property name="label" translatable="yes">Play video</property>
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="receives_default">True</property>
            <signal name="clicked" handler="on_vbutton_clicked" swapped="no"/>
          </object>
        </child>
        <child>
          <object class="GtkButton" id="ibutton">
            <property name="label" translatable="yes">Show image</property>
            <property name="visible">True</property>
            <property name="can_focus">True</property>
            <property name="receives_default">True</property>
            <signal name="clicked" handler="on_ibutton_clicked" swapped="no"/>
          </object>
          <packing>
            <property name="position">1</property>
          </packing>
        </child>
      </object>
    </child>
    <child>
      <object class="GtkBox">
        <property name="visible">True</property>
        <property name="can_focus">False</property>
        <property name="orientation">vertical</property>
        <child>
          <object class="GtkBox" id="video_box">
            <property name="height_request">300</property>
            <property name="visible">True</property>
            <property name="can_focus">False</property>
            <property name="orientation">vertical</property>
            <child>
              <placeholder/>
            </child>
          </object>
          <packing>
            <property name="expand">True</property>
            <property name="fill">True</property>
            <property name="position">0</property>
          </packing>
        </child>
        <child>
          <object class="GtkSeparator">
            <property name="visible">True</property>
            <property name="can_focus">False</property>
          </object>
          <packing>
            <property name="expand">False</property>
            <property name="fill">True</property>
            <property name="position">1</property>
          </packing>
        </child>
        <child>
          <object class="GtkBox">
            <property name="visible">True</property>
            <property name="can_focus">False</property>
            <child>
              <object class="GtkButtonBox">
                <property name="visible">True</property>
                <property name="can_focus">False</property>
                <property name="layout_style">start</property>
                <child>
                  <object class="GtkButton" id="backward">
                    <property name="visible">True</property>
                    <property name="can_focus">True</property>
                    <property name="receives_default">True</property>
                    <property name="image">image1</property>
                    <property name="always_show_image">True</property>
                    <signal name="clicked" handler="on_backward_clicked" swapped="no"/>
                  </object>
                  <packing>
                    <property name="expand">True</property>
                    <property name="fill">True</property>
                    <property name="position">0</property>
                  </packing>
                </child>
                <child>
                  <object class="GtkButton" id="forward">
                    <property name="visible">True</property>
                    <property name="can_focus">True</property>
                    <property name="receives_default">True</property>
                    <property name="image">image2</property>
                    <property name="always_show_image">True</property>
                    <signal name="clicked" handler="on_forward_clicked" swapped="no"/>
                  </object>
                  <packing>
                    <property name="expand">True</property>
                    <property name="fill">True</property>
                    <property name="position">1</property>
                  </packing>
                </child>
                <child>
                  <object class="GtkToggleButton" id="playpause_togglebutton">
                    <property name="visible">True</property>
                    <property name="can_focus">True</property>
                    <property name="receives_default">True</property>
                    <property name="image">image3</property>
                    <signal name="toggled" handler="on_playpause_togglebutton_toggled" swapped="no"/>
                  </object>
                  <packing>
                    <property name="expand">True</property>
                    <property name="fill">True</property>
                    <property name="position">2</property>
                  </packing>
                </child>
              </object>
              <packing>
                <property name="expand">False</property>
                <property name="fill">False</property>
                <property name="position">0</property>
              </packing>
            </child>
            <child>
              <object class="GtkScale" id="progress">
                <property name="width_request">300</property>
                <property name="visible">True</property>
                <property name="can_focus">True</property>
                <property name="halign">center</property>
                <property name="margin_left">5</property>
                <property name="margin_right">5</property>
                <property name="adjustment">adjustment</property>
                <property name="fill_level">100</property>
                <property name="round_digits">1</property>
                <property name="draw_value">False</property>
              </object>
              <packing>
                <property name="expand">False</property>
                <property name="fill">False</property>
                <property name="position">1</property>
              </packing>
            </child>
          </object>
          <packing>
            <property name="expand">False</property>
            <property name="fill">True</property>
            <property name="position">2</property>
          </packing>
        </child>
      </object>
    </child>
  </object>
</interface>

Beispieldateien

• Video (13,7 MB)

• Image (553 kB)

.desktop

In der Desktopdatei muss das Attribut StartupWMClass definiert werden.

Um die WM_CLASS-Bezeichnung eines Fensters herauszufinden, kann man in einem Terminal

$ xprop | grep WM_CLASS

aufrufen und das gewünschte Fenster anklicken.

Gtk+-Python-Anwendung

Setzt man den Programmnamen mit der Funktion GLib.set_prgname("appname"), so entspricht dies dem Attribut WM_CLASS. In der Desktopdatei muss demzufolge StartupWMClass=appname definiert sein.

Die bisher für diese Aufgabe verwendete Funktion set_wmclass(wmclass_name, wmclass_class) von Gtk.Window ist seit Version 3.22 veraltet. Sie funktioniert zwar noch, sollte aber nicht mehr verwendet werden.

Icon

First things first: we have an icon. This is my way of coping with pedantry and an attempt to keep up the illusion of competence. I found it at The Noun Project.

GtkApplication

The application now runs as generic Gtk.Application which includes

• starting/faving from the GNOME shell

• identify/kill the process by name (no more random "Python" task)

• commandline options are available

• cleaner code, p.e. avoid starting the main loop manually

Application window

Since v0.3 there is a second main application window available with media data information and a preview widget realized with GStreamer.

These two windows are now merged into one providing a StackSwitcher to switch between these alternative views. This now is the default application window.

Not convinced to drop the "single view" windows I decided to keep them for now. You can launch the application using by executing the run script passing one of these options:

$ # compact/list view
$ python run.py -c
$ python run.py --alt-gui-compact
$ # preview window
$ python run.py -e
$ python run.py --alt-gui-ext

If you want to use the old commandline interface, you can do so by running

$ python run.py --cli

Run the script with --help option to show all available options.

Fixed issues

• importing from "other" places should do as planned now

• the GStreamer preview now uses the gtksink playbin (this story may be told another time)

• timelapse generation should not freeze the main loop

Burn the widge(t)

I replaced several widgets for modern looks and better desktop integration:

• all dialogs are Gtk.MessageDialogs now

• the dropdown menu is a Gtk.PopoverMenu instead of a Gtk.Menu

Logs and configuration

The output of logging and the configuration file have moved to ~/.config/gpt. You may have to set your working directory again if you have used GPT before.

Installation

$ sudo pacman -S python-gobject python-yaml python-setuptools python-lxml python-setproctitle mediainfo ffmpeg

$ sudo apt-get install python3-gi python3-setuptools python3-lxml gir1.2-gtk-3.0 gir1.2-gstreamer-1.0 gstreamer1.0-gtk3 mediainfo ffmpeg

$ python setup.py install --user  # or
$ sudo python setup.py install

Desktop file

Setuptools will also install a desktop file so you can launch GPT from the GNOME shell or menu. All alternative interface options are available via desktop action so you can start these on right click from the activities overview or dash if GPT is running or added as favourite.

Bits and pieces

• code improvements (formatting, readability, PEP8 compliance, removal of deprecated code, file structure)

• updated and detailed README

• updated localization files

Consult the README for details.

Extensions

Multi-monitor wallpaper

It's $CURRENT_YEAR and it's still an issue. While you can configure a multi-monitor setup in the preferences conveniently you still have to glue images together with ImageMagick to get different backgrounds on your screens like a caveman.

I highly recommend the application HydraPaper for this task.

Getting things to work the GNOME Shell way

/usr/share/icons/[theme]/places/[size]
~/.local/share/icons/[theme]/places/[size]

/usr/share/icons/[theme]/places/symbolic
~/.local/share/icons/[theme]/places/symbolic

Drop down terminal

I used Tilda on the GNOME 2 desktop so why not return to a long-serving application?

Even though the application is set to launch at session start in the preferences I had to add it to the startup applications manually.

Unrolled Tilda terminal on MATE, Plank dock

Screenshots

If you press [Print] you might be informed that "mate-screenshot" could not be found.

You can either install the mate-utils package which "mate-screenshot" is a part of or use the "gnome-screenshot" tool by editing the dconf entries org.mate.Marco.keybinding-commands.command-screenshot and org.mate.Marco.keybinding-commands.command-window-screenshot to the value gnome-screenshot.

Empty GNOME Shell

Beware of fraud! This is MATE.

What does not work

Hot corner

The Hot Corner probably is the most symptomatic feature of the GNOME 3 desktop. By moving the mouse to the top left corner or clicking on "Activities" or by pressing the [Super] key you activate the Activities Overview which shows open windows, the dash, workspaces and the application search/launch bar.

This functionality cannot be fully emulated on the MATE desktop.

Using the Brisk menu or a keyboard launcher (or both) to get the search bar function seems like a valid compromise. This is probably the common use case when pressing the [Super] key.

What's still missing is a good way of showing running application windows. I have the habit of kicking the mouse into the corner to get to the windows overview (I realize when doing that occasionally on other desktop systems) and the old [Alt]``+``[Tab] is not a replacement.

Activities Overview showing open windows