KurzeTipps – Fensterverteilung über die Maus aktivieren

Wer unter dem Unity Desktop die Funktion Fensterverteilung (SUPER + W) einmal ausprobiert hat, findet hier einen kleinen Tipp. Um nicht immer über das Tastaturkürzel die Funktion aufzurufen, sondern ähnlich wie bei Gnome die obere linke Ecke zu nutzen, kann der folgenden Befehl im Terminal ausgeführt werden.

gsettings set org.compiz.scale:/org/compiz/profiles/unity/plugins/scale/ initiate-edge '[EDGE]'

Für [EDGE] können folgende Werte eingesetzt werden (Groß- und Kleinschreibung beachten):

Wert Beschreibung
Top Obere Seite
TopLeft Obere linke Ecke
TopRight Obere rechte Ecke
Bottom Untere Seite
BottomLeft Untere linke Ecke
BottomRight Untere rechte Ecke
Left Linke Seite
Right Rechte Seite

KurzeTipps – Kalender Widget per Skript

Ich habe mich heute per Zufall mit dem Thema Widgets beschäftigt. Da ich jedoch nicht noch irgendwelche Software wie beispielsweise Conky dafür installieren möchte, habe ich mir ein kleines Skript geschrieben. Das Skript ist recht simple aufgebaut und besteht im Grunde nur aus dem Ersetzen des Icon-Pfades. Ich habe im folgenden die Vorgehensweise anhand eines Kalenders beschrieben.

Verwendung

Als erstes erstellt man für den Kalender die entsprechenden Zahlen für Tag und Monat als Bild. (Hier ist ein Archiv in der sowohl das Skript als auch die Bilder enthalten sind.)

Nun ruft man das Skript auf und es werden zwei neue Icons auf dem Desktop erstellt. Nachdem man im Kontextmenü (Rechte Maustaste) die Eigenschaften („Properties„) des Icons aufgerufen hat, setzt man in dem Reiter Berechtigungen („Permissions„) die Erlaubnis zum Ausführen der Datei. Das Icon sollte nach dem Schließen zu sehen sein.

Nachdem man für beide Icons (Tag, Monat) die Berechtigung gesetzt hat, kann man das Skript zu den Autostart-Programmen hinzufügen. Von nun an ist nach jedem Einloggen das aktuelle Datum auf dem Desktop zu sehen.

Tipp: Wem die Icons zu klein sind, der kann im Kontextmenü die Größe der Icons verändern.

Gegebenenfalls bitte die Pfade an die eigenen anpassen.

#!/bin/bash
# Copyright 2015 Marc Volker Dickmann
# A simple script to use icons as widgets

# CONFIG
# This script.
scriptfile="Bilder/calendar_flat_two/calendar_flat_two.sh"

# The icon for the day
iconfile_day="Schreibtisch/calendar_day.desktop"

# The icon for the month
iconfile_month="Schreibtisch/calendar_month.desktop"

# Path to the image files
imgfiles="Bilder/calendar_flat_two/png"

# For using other file formats
imgfileending="png"

# The dateformat for the day file
dateformat_day="+%d"

# The dateformat for the month
dateformat_month="+%m"

# DAY
currentday=$(date "$dateformat_day")

echo "#!/usr/bin/env xdg-open

[Desktop Entry]
Name=.
TryExec=$HOME/$scriptfile
Exec=$HOME/$scriptfile
Icon=$HOME/$imgfiles/$currentday-white.$imgfileending
Type=Application
StartupNotify=true
OnlyShowIn=GNOME;Unity;" > "$HOME/$iconfile_day"

# MONTH
currentmonth=$(date "$dateformat_month")

echo "#!/usr/bin/env xdg-open

[Desktop Entry]
Name=.
TryExec=$HOME/$scriptfile
Exec=$HOME/$scriptfile
Icon=$HOME/$imgfiles/$currentmonth-orange.$imgfileending
Type=Application
StartupNotify=true
OnlyShowIn=GNOME;Unity;" > "$HOME/$iconfile_month"

KurzeTipps – Icons automatisch positionieren

Ich habe mich heute per Zufall mit dem Thema Icons automatisch anordnen beschäftigt und dabei ist ein kleines Skript entstanden. Das Skript ist recht simple gehalten und positioniert automatisch alle Icons nebeneinander, ähnlich eines Docks. Für den Fall das jemand diese Funktion noch gebrauchen kann, stelle ich es hier jedem zur Verfügung.

Achtung: Bitte statt USERNAME den eigenen Nutzernamen eintragen und die anderen Werte anpassen.

#!/bin/bash
# Copyright 2015 Marc Volker Dickmann
# Positions the icons like a dock

width="1920"
height="1080"
icons="0"
iconswidth="128"
iconsheight="128"
iconsheightadd="64"
desktoppath="/home/USERNAME/Schreibtisch"

for iconfile in ./*.desktop ; do 
	icons=$(($icons+1))
done

width=$((($width/2)+($iconswidth * ($icons/2))))

for iconfile in ./*.desktop ; do 
	iconname=$(basename "$iconfile")
	posx=$(($width - ($iconswidth *$icons)))
	posy=$((($height-$iconsheightadd) - $iconsheight))
	gvfs-set-attribute "$desktoppath/$iconname" metadata::nautilus-icon-position "$posx,$posy"
	icons=$(($icons-1))
done

KurzeTipps – Multimonitor Gaming

Ich besitze momentan mehrere Monitore, genauer gesagt drei, und bis auf wenige Ausnahmen gibt es kaum Spiele die problemlos die Auflösung von 5760×1080 unterstützen. Viele Spiele übernehmen für die Größe des Fensters bzw. des Vollbildes die Auflösung von Compiz welcher derzeit unter Unity unter anderem für die Komposition verantwortlich ist. Vor ein paar Tagen kam ich auf eine Lösung, welche die Liste von Unterstützen Spielen etwas länger macht.

Über ein Skript setze ich die Variable outputs auf einen Screen mit der Auflösung von allen Monitoren zusammen (5760×1080) und deaktiviere vorher die automatische Erkennung von outputs. Dann werden beim Maximieren oder dem Vollbild die Anwendungen über alle Monitore gestreckt.

#!/bin/bash
gsettings set "org.compiz.core:/org/compiz/profiles/unity/plugins/core/" "detect-outputs" false 
gsettings set "org.compiz.core:/org/compiz/profiles/unity/plugins/core/" "outputs" "['5760x1080+0+0']"

Bei dem Spiel Shadow of Mordor zum Beispiel lässt sich so im Fenstermodus das Spiel über drei Monitore spielen. Bei Vollbildanwendungen wird nebenbei auch die volle Auflösung genommen, erkennbar durch das kurze Auftauchen des Steam Notifikation ganz rechts, jedoch stellt nicht jedes Spiel die Auflösung dar und bleibt beim linken Monitor in dessen Auflösung.

Um wieder zum normalen Modus zu kommen, führt man folgendes Skript aus. Der Modus erlaubt es wieder, dass Fenster beim Maximieren auf die Größe von einem Monitor gestreckt werden. Das Skript setzt dafür die Einstellungen wieder auf die festgelegten Werte zurück. Hier habe ich die Werte für drei 1080p Monitore festgelegt.

#!/bin/bash
gsettings set "org.compiz.core:/org/compiz/profiles/unity/plugins/core/" "detect-outputs" true
gsettings set "org.compiz.core:/org/compiz/profiles/unity/plugins/core/" "outputs" "['1920x1080+0+0', '1920x1080+1920+0', '1920x1080+3840+0']"

KurzeTipps – Backups von den Steam Spielen

Da ich öfters mal mein Betriebssystem neu installiere und dabei auch die Spiele auf Steam erneut heruntergeladen werden müssen, habe ich mir einen Plan ausgedacht, um in Zukunft etwas Zeit zu sparen. Da ich mehrere Festplatten habe und davon auch eine für meine Backups zuständig ist, werde ich dort in einem extra Ordner die Backups von den Spielen platzieren.

Anleitung

Zunächst installiert man die jeweiligen Spiele erst einmal wie gewohnt in dem Verzeichnis der Standard Spielbibliothek von Steam. Danach wird ein Backup von dem Spiel angelegt. Die Option dazu findet man über das Kontextmenü des Spieles unter dem Punkt „Backup Game Files“. Nachdem dies erledigt ist, öffnet man den Ordner in dem die Backups von Steam abgelegt werden und kopiert diese auf die Festplatte die für Backups zuständig ist.

Bei einer Neuinstallation des Betriebssystems können, nachdem Steam installiert wurde, nun die Spiele aus den Backups wiederhergestellt werden. Natürlich könnte man auch eine Backup Software wie zum Beispiel DeJa Dup so konfigurieren dass automatisch ein Backup von diesen Dateien auf einem externen Medium angelegt werden soll. So erspart man sich mit Backups nicht nur eine menge Zeit, sondern entlastet auch sein Netzwerk.

KurzeTipps – GDB

Wenn man Programmiert kommt es immer mal wieder vor dass dass Programm welches man gerade entwickelt abstürzt und man aufwendig Fehler im Quelltext suchen darf.
Dies ist nicht wirklich beliebt und um dies zu vereinfachen gibt es sogenannte Debugger, sie führen die Software im Grunde aus und beim Absturz zeigen sie auf die jeweilige stelle im Code und geben ein paar Informationen zu der Ursache.
Dies verkürzt häufig extrem die Zeit und den Aufwand um ein Problem zu lösen.
Dass Open Source Programm GDB ist so ein Debugger und entstammt dem Gnu Projekt und ist über die Jahre bei vielen zum Standard-Werkzeug geworden.

Installation

GDB ist in der Distribution Ubuntu bereits enthalten, falls nicht kann mit dem jeweiligen Paketmanager dass Paket GDB nachträglich installiert werden.
Für den Paketmanager APT kann beispielsweise folgender Befehl genutzt werden.

sudo apt-get install gdb

Um bei anderen Programmen noch hinweise zu bekommen gibt es inzwischen für viele Programme Pakete die solche Informationen für GDB bereitstellen.
In der Regel werden diese Paket nach dem Schema <Paketname>-dbg benannt wobei die Abkürzung dbg für Debug steht.
Für die Informationen von der Sprache Python installiert man zum Beispiel dass Paket python-dbg.

Quelle - Eigene Grafik
Quelle – Eigene Grafik

Programm Debuggen

Um ein Programm zu Debuggen ruft man als erstes dieses Kommando in dem Ordner in dem dass bereits fertig kompilierte Programm sich befindet.
Dabei ist nach dem Aufruf von gdb der Name der kompilierten Datei anzuhängen.

gdb Programm

Danach startet GDB und man kommt in eine Art Befehlszeile über die man den Debugger steuert.
Um dass Programm jetzt zu starten genügt der Befehl run und ein druck auf die Eingabetaste.
Dass Programm startet nun ganz normal und ist benutzbar bis es Abstürzt, ab da wird es quasi eingefroren und man kann über dass Kommando c in dem Programm jeweils Aktion für Aktion weiterspringen bis es völlig abstürzt.
Bei jedem Sprung werden Informationen zu der jeweiligen Zeile und dem Fehler ausgegeben.

Um dem Programm noch Argumente zu übergeben kann auch dieser Weg benutzt werden.
Dazu fügt man dem Befehl run noch die Argumente für das jeweilige Programm an.

(gdb) run „arg1“

Steuerung

Es gibt natürlich noch weitere hilfreiche Befehle innerhalb von GDB.
Um die Ausführung eines Programms zum Beispiel abzubrechen genügt die Eingabe von kill innerhalb der Befehlszeile von dem Debugger.

(gdb) kill

Damit man die Befehlszeile von GDB verlässt und den Debugger beendet nutzt man dass Kommando quit.

(gdb) quit
Quelle - Eigene Grafik
Quelle – Eigene Grafik

Mach mal Pause

Um während der Laufzeit eines Programms eine Pause einzulegen gibt es die Möglichkeit mit dem Kommando break in GDB.
Ebenfalls funktioniert auch die Tastenkombination STRG + C sodass man keinen bestimmten Haltepunkt angeben muss.

Befehl Beispiel Beschreibung
break [<Datei>:]<Zeile> (gdb) break main.c:5 Stoppt dass Programm bei der angegebenen Zeile (5). Für den Fall dass das Projekt nur aus einer Quelldatei besteht kann der Dateiname (main.c) weggelassen werden.
break <Funktion> (gdb) break main Beim Aufruf der angegebenen Funktion (main) wird der Programmablauf unterbrochen. (Nur bei Verwendung von der Programmiersprache C)
break <member/Funktion>(<Argumenttypen>) (gdb) break widget::init(int, int) Bei C++ muss immer die volle Signatur angegeben werden, selbst wenn die Funktion nicht überladen ist.

Programmablauf beeinflussen

Normalerweise brauchen Menschen Anhaltspunkte welches meiner Meinung nach auch einer der Gründe für die weite Verbreitung von Zeilenangaben bei Entwicklern ist.
In den meisten Fällen kann man dadurch vielleicht Indirekte Fehler, solche die zu dem eigentlichen Fehler führen, finden wobei dort die von GDB ausgegebene Zeile aus dem Quelltext wenig hilft.
Mithilfe von list gibt GDB 10 Zeilen des aktuellen halt von dem Quellcode aus, so lassen sich Problemquellen schneller identifizieren.

(gdb) list

Um dass Programm bis zum nächsten Unterbruch weiterlaufen zu lassen kann der Befehl continue verwendet werden.

(gdb) continue

Damit nur eine Zeile weiter gesprungen wird benutzt man dass Kommando next, dabei bleibt man auch in der aktuellen Ebene.
Dass bedeutet dass nicht zwischen im Quellcode aufgerufene Funktionen hin und her gesprungen wird.
Um diese Regel zu ignorieren und damit Funktionen nutzbar machen kann wird der Befehl step verwendet.
Jetzt kann der Befehl finish hilfreich sein, er beendet die derzeitige Funktion und kehrt zu der Funktion zurück aus der diese aufgerufen wurde.

Zeit sparen durch Manipulation

Um nicht jedes mal eine Variable im Quelltext zu ändern, zu kompilieren um dann wieder einen Fehler festzustellen gibt es die Möglichkeit Variablen während der Ausführung eines Programms über den Debugger zu verändern.
Dies ist besonders hilfreich bei Funktionen die auf den Berechnungen vorheriger aufbauen und so schnell Fehleranfällig werden.

Werte von Variablen können über den print-Befehl ausgegeben und mithilfe von set verändert werden.

(gdb) print i
$1 = 10
(gdb) set var i = 1
(gdb) print i
$4 = 1

Abschließend sei noch anzumerken dass ich hier selbstverständlich nicht alle Funktionen des freien Debuggers GDB zeigen konnte.
Wer mehr darüber erfahren möchte kann sich den Eintrag zu GDB im Ubuntuusers Wiki mal anschauen und die man-page von GDB durchstöbern.

KurzeTipps – Make

Ein bei mir recht häufig zum Einsatz kommendes Werkzeug ist Make.
Es ermöglicht über einen Befehl (make) ein Programm vollkommen automatisch zu kompilieren ohne Ellen lange Parameter und Dateinamen eingeben zu müssen.

Make kann bereits auf eine lange Geschichte zurückblicken und ist bei vielen Entwicklern beliebt.
Unter den vielen Implementierungen sind wohl die bekanntesten die Gnu und die BSD Varianten.
Jedoch sind die Implementierungen untereinander nicht immer Kompatibel zu einander.
In diesem Artikel gehe ich auf das in den Standard Quellen von Ubuntu bereits enthaltene Gnu make ein.

Installation:

Um make auf dem eigenem Rechner zu installieren kann beispielsweise dass Paketverwaltungssystem apt verwendet werden.

sudo apt-get install make

Das Regelwerk: Makefiles

Gesteuert wird dass Programm über sogenannte Makefiles die in dem jeweiligen Verzeichnis gespeichert sind.
Diese sind im Grunde einfache Textdateien in denen Konfigurationen angeben und Regeln aufgestellt werden.

CC = gcc

In der ersten Zeile definiert man meist den Compiler den man verwenden möchte, in diesem Beispiel wird gcc verwendet.
Dabei funktioniert die Zeile in etwa so wie eine Definition (define) in der Programmiersprache C.
Von nun an kann CC überall da eingesetzt werden wo der Compiler angeben werden soll.

OBJECTS = cbg.o

In dieser Zeile werden die zu Kompilierenden Quelldateien angegeben.
Bei diesem Beispiel wird der Dateiname und anschließend .o statt .c angeben, genauer soll der Quellcode aus der Datei cbg.c kompiliert werden.

%.o: %.c
        $(CC) -c $(CFLAGS) $<

Später kommen solche Regeln zum Einsatz, sie geben an wie etwas geschehen soll.
In diesem Fall beschreibt die Regel wie aus einer .c Quelldatei eine .o Objektdatei erstellt wird.
$< wird als alias für den jeweiligen Dateinamen verwendet, vergleichbar ist dieses Konstrukt mit einer for Schleife wobei $< dann z.B. die Variable i darstellt.

Hier ein Beispiel wie ein komplettes Makefile aussehen kann:

CC = gcc
OBJECTS = cbg.o
LIBS = -lglib-2.0
CFLAGS = -Wall -O2
BINDIR = $(DESTDIR)/usr/bin
NAME = cbg

cbg: $(OBJECTS)
        $(CC) -o $(NAME) $(OBJECTS) $(LIBS)

%.o: %.c
        $(CC) -c $(CFLAGS) $<

install:
        install --mode=755 $(NAME) $(BINDIR)/

clean:
        rm *.o $(NAME)

uninstall:
        rm $(BINDIR)/$(NAME)

Auf mein Kommando : make

Um den Vorgang zu starten genügt der Befehl make welcher, in dem selben Verzeichnis in dem auch dass Makefile liegt, ausgeführt wird.

Wird nur der Befehl make ohne weitere Argumente verwendet wird dass Programm einfach nur erstellt.

In dem oben stehenden Beispiel gibt es noch weitere Möglichkeiten, so kann etwa mit make clean automatisch Aufgeräumt werden.
Beim Aufräumen werden dann alle Objektdateien und die Binärdatei gelöscht, dies ist beispielsweise bei der Verwendung eines Versionsverwaltungssystem, wie Git, recht nützlich.

Abschließend sei noch anzumerken dass make noch vieles mehr kann als ich in diesem Artikel beschrieben habe.
Wer interessiert ist kann sich einmal die manpage zu make anschauen.

KurzeTipps – arecord

Manchmal braucht man nur ein kleines Tool dass eine einzige Aufgabe zu erledigen hat, dieses Werkzeug sollte aber immer zur Verfügung stehen sodass man nicht viel Aufwand betreiben muss um es zu benutzen.
Ein solches Tool habe ich letztens benötigt als es darum ging Audioaufnahmen für mein derzeit in Entwicklung befindliches Spiel zu machen.

Dabei bin ich im Ubuntuusers Wiki auf „arecord“ gestoßen welches zu ALSA gehört und daher auf allen Ubuntu-Installationen bereits vorinstalliert ist.

Aufnehmen

Um mit „arecord“ aufzunehmen genügt dieser kleine Befehl:

arecord -D default -f cd foo.wav 

Damit wird aus dem in den Audioeinstellungen ausgewählten Mikrofon in eine WAV Datei mit 44.1 KHz und 16-Bit-Auflösung (das Format einer Audio-CD) aufgenommen.
Es lassen sich noch weitere Anpassungen vornehmen, mehr dazu in der jeweiligen manpage.

KurzeTipps – Die Befehle diff und patch

Wer sich mit Programmieren beschäftigt stößt garantiert irgendwann auf dass Thema Versionskontrolle.
Die nützliche Methode ermöglicht eine leichte Verwaltung von Quellcode und wird über kurz oder lang zu eines der Standard Werkzeuge eines jeden Programmierers.
Neben der Möglichkeit sich Systeme wie Git, Bzr und weite zu installieren ist aber jeder Linux-Standardinstallation schon die Basis für die Quellcodeverwaltung schon enthalten.

Die Befehle diff und patch ermöglichen die Änderungen von einer modifizierten Version der Originaldatei in dass Original zu übernehmen.
Dabei können bei jedem Vorgang auch Backups angelegt werden und Änderungen auch wieder rückgängig gemacht werden.

Schritt 1

Als erstes muss eine diff Datei über den Befehl diff angelegt werden.
Dazu benutzt man den folgenden Befehl und ändert die Namen in diesem auf die eigenen.

diff -uNr „main.c“ „main_patch.c“ > „main_patch.diff“

Argumente

Argument Beschreibung
-u (unified) Es werden NUM (Standard 3) von unveränderten Zeilen ausgeben.
-N (New) Die fehlenden Dateien werden erstellt.
-r (rekursiv) falls vorhanden werden die Unterverzeichnisse verglichen.

Der Befehl bewirkt dass die Änderungen von der Datei „main_patch.c“ gegenüber der Ursprungsdatei „main.c“ in „main_patch.diff“ geschrieben werden.

Schritt 2

Nun wird die Originaldatei mithilfe der diff Datei gepatcht.
Dazu wird der Befehl patch verwendet wobei auch hier die Dateinamen auf die eigenen abgeändert werden müssen.

patch -p1 „main.c“ < „main_patch.diff“

Argumente

Argument Beschreibung
-pNUM Zieht von dem Dateinahmen NUM führende Komponenten ab.
-R Macht ein zuvor angewendeten Patch wieder rückgängig.

Nun werden die Änderungen welche in der Datei „main_patch.diff“ protokolliert wurden in die Ursprungsdatei „main.c“ übernommen.

Schritt 3

Um dass ganze wieder rückgängig zu machen braucht man nur die Ursprungsdatei und die jeweilige diff Datei.
Die Befehlsstruktur ist ähnlich der von Schritt 2 und hat vor der Angabe der Anzahl von Striplevel (-p1) noch dass Argument „-R“.

patch -R -p1 „main.c“ < „main_patch.diff“

Nun wird genau dass Gegenteil von Schritt 2 gemacht und z.b. alle Änderungen die in der diff Datei stehen und etwas hinzufügen sollen gelöscht.

KurzeTipps – Markdown Syntax Übersicht

Letztens wollte ich mir ein Paar Dinge aufschreiben und hatte vor dafür den Markdown Syntax zu verwenden.
Da ich diesen jedoch nicht im Kopf hatte habe ich mir gedacht dass eine Übersicht auf meinem Blog nützlich wäre und so eine kleine Übersicht des
Markdown Syntax ausgearbeitet.
Dabei habe ich mich an dem Wikipedia Beitrag von Markdown orientiert.

Hier die Übersicht:

# Markdown Syntax

* Absatz
* Zeilenumbruch
* Schrift verändern
		* Kursiv
		* Fett
		* Fett kursiv
* Text markieren
* Listen
		* Ungeordnete Liste
		* Geordnete Liste
* Überschriften
		* HTML-Überschriften
		* Alternativen
* Zitate
* Links
* Bilder

Absatz
======

Markdown ist ein einfacher Weg Notizen übersichtlich zu gestalten.

Eine Leerzeile erzeugt dabei einen Absatz.

Zeilenumbruch
=============

Zwei oder mehr Lehrzeichen am Ende der Zeile  
erzeugen eine Zeilenumbruch.

Schrift verändern
=================

Kursiv
------

*Kursiv* oder _Kursiv_

Fett
----

**Fett** oder __Fett__

Fett kursiv
-----------

***Fett kursiv*** oder ___Fett kursiv___

Text markieren
==============

Markierter `Quelltext`

Listen
======

Ungeordnete Liste
-----------------

* Ein Punkt in einer ungeordneten Liste.
		* Ein unterpunkt von dem Punkt über diesem.
* Ein weiterer Punkt.

Geordnete Liste
---------------

1. Punkt eins in einer geordneten Liste.
2. Punkt zwei.

Überschriften
=============

HTML-Überschriften
------------------

# Überschrift von der ersten Ebene
## Überschrift der zweiten Ebene

Alternativen
------------

Überschrift der ersten Ebene
============================

Überschrift der zweiten Ebene
-----------------------------

Zitate
======

> Ein Zitat welches in ein HTML-Blockquote-Element gepackt wird.

Links
=====

[Beschriftung des Links](http://devdiary.org/ "Titel, der beim überfahren mit der Maus angezeigt wird")

Bilder
======

![Alternativtext](Bild-URL "Bildtitel")