Neues YouTube-Video – Qt-Tutorial 013: Signals und Slots

Wir beschäftigen uns heute damit, wie die Signalverarbeitung, also Callbacks, in Qt mittels Signal und Slots funktioniert.

Qt-Tutorial: Signals und Slots
Qt-Tutorial: Signals und Slots

Normalerweise ist es so, dass man in C++ zum Aufruf von Methoden Methodenzeiger nutzt. Qt will da flexibler und einfacher sein und hat somit das Signal-Slots-Konzept eingeführt. Auf ein Signal können sich mehrere Slots verbinden.

Diese Konzept kommt aber nicht nur in der GUI-Entwicklung zum Tragen, sondern es wird auch bei GUI-losen Komponenten wie der Netzwerkprogrammierung eingesetzt.

Hier geht es zum Video.

Neues YouTube-Video – Qt-Tutorial 012: Unser erstes Programm layouten

Nachdem wir einfach ein paar Komponenten in unser Programm gezogen haben, sollten wir beginnen, mit Layouts zu arbeiten. Ich zeige kurz, wie man das bei unserem Programm macht. Dabei zeige ich auch, wie man Spacer benutzt.

Unser erstes Programm layouten
Unser erstes Programm layouten

Wir beschäftigen uns mit ganz einfachen Layouts. Die ersten Erfolge kommen schnell: der Inhalt des Formulars wächst und schrumpft beim Vergrößern oder Verkleinern des Dialogs.

Hier geht es zum Video.

Redmine-Reihe 2 von 3: Redmine für Administratoren

Willkommen zum dreiteiligen Workshop: Redmine 4. In diesem zweiten Teil geht es um „Redmine für Administratoren“.

Das Video erklärt einige grundsätzliche Informationen auf der administrativen Seite im Backend von Redmine.

Redmine für Administratoren

Folgende Dinge werden erklärt:

  • Adminkonto bearbeiten
  • Projekte erstellen, konfigurieren und verwalten
  • Benutzerverwaltung
  • Gruppenverwaltung
  • Rollen und Rechte
  • Trackerverwaltung
  • Ticket-Status-Verwaltung
  • Workflow
  • Benutzerdefinierte Felder
  • Aufzählungen
  • Redmine konfigurieren

Hier geht es zum Video.

Hier geht es zur Playlist.

Hier geht es zu Redmine installieren.

KooKooK 0003: Redmine-Projekt einrichten

Als Projektmanagementtool setze ich seit einiger Zeit bereits Redmine ein und ich bin immer noch begeistert davon, weswegen wir es auch in diesem Projekt benutzen werden. In diesem Video zeige ich, wie ich das KooKooK-Projekt in Redmine anlege.

KooKooK 0003: Redmine-Projekt einrichten
KooKooK 0003: Redmine-Projekt einrichten

Hier geht es zum Video.

Hier geht es zur Playlist.

Hier geht es zur Website.

Hier geht es zum GitHub-Repository.

Hier geht es zum Redmine-Projekt.

Redmine-Reihe 1 von 3: Redmine 4 installieren (auf FreeBSD 13)

Willkommen zum dreiteiligen Workshop: Redmine 4. Ich habe mir überlegt, ich mache einen kleinen Redmine-Einsteigerkurs. Dieser geht über drei Kapitel:

  • Redmine 4 installieren (in meinem Fall auf FreeBSD 13)
  • Redmine 4 für Administratoren (GUI)
  • Redmine 4 für Benutzer (GUI)
Redmine - Installation
Redmine – Installation

In diesem Video und Blog-Artikel geht es darum, wie man Redmine einfach installieren kann. Ich setze dafür folgendes voraus:

  • Du hast ein lauffähiges und vollständig gepatchtes FreeBSD 13 (oder neuer)
  • Du hast einen lauffähigen PostgreSQL-Server (wie das geht, erfährst du hier und hier)
  • Nameservereinträge sind bereits vorhanden (in meinem Fall heißt mein Host redmine.gug-it.gg, welchen ich hier auch in der Beschreibung überall nutze. Das musst du natürlich anpassen!)

So wird es gemacht

Erstelle einen Datenbankbenutzer. Wie das bei deiner PostgreSQL-Version geht, entnimmst du den Manuals. Achte darauf, dem Benutzer ein verschlüsseltes Kennwort zu geben. Ich habe noch ein (uraltes) PostgreSQL 9.5 auf meiner Testmaschine laufen (du solltest hoffentlich was neueres haben), und da geht es so:

createuser -E -P redmine

Dann erstellst du noch die Datenbank, was bei mir so geht:

createdb -E unicode -O redmine redmine

und vergisst natürlich nicht den Eintrag in der pg_hba.conf

host redmine redmine 192.168.0.168/24 password

Denke daran, Datenbanknamen, Datenbankbenutzer und IP anzupassen!

Ich nutze Apache in der Version 2.4. Wenn du was anderes benutzt, dann musst du leider schauen, wie du es ans Rennen bekommst. Ich installiere also alle benötigten Pakete:

pkg install redmine4 apache24 ap24-mod_fastcgi fcgi-devkit postgresql14-client

In der httpd.conf (/usr/local/etc/apache24) setzt du, wenn du es noch nicht getan hast, den Servernamen sowie die E-Mail-Adresse (wobei die auch im VHost eingerichtet wird). Weiterhin entfernst du bei den Zeilen:

LoadModule rewrite_module libexec/apache24/mod_rewrite.so
LoadModule fastcgi_module libexec/apache24/mod_fastcgi.so
Include etc/apache24/extra/httpd-vhosts.conf

die Raute (#) vorne, so dass die Zeilen genutzt werden innerhalb der Konfiguation. Und der aufmerksame Leser weiß es: ich nutze hier jetzt im Beispiel kein SSL! Bitte mache das, und mache das auf jeden Fall, wenn Redmine im Internet hängt! Das wäre jetzt einfach nur zu aufwendig für das Tutorial.

Server-Kram liegt bei mir unter /server. Web-Kram dementsprechend unter /server/web/<sld>/<t(hird)ld>. Passe die Konfiguration bei dir an. Dementsprechend richte ich das Verzeichnis folgendermaßen ein:

mkdir -p /server/web/gug-it && chown -R www:www /server/web/gug-it
ln -s /usr/local/www/redmine /server/web/gug-it/

Dann bearbeite ich die Datei /usr/local/etc/apache24/extra/httpd-vhosts.conf (du hoffentlich /usr/local/etc/apache24/extra/httpd-ssl.conf). Da füge ich folgenden Eintrag hinzu:

<VirtualHost *:80>
        ServerName redmine.gug-it.gg
        ServerAdmin thorsten@tgeppert.de

        DocumentRoot "/server/web/gug-it/redmine/public"

        FastCgiServer /server/web/gug-it/redmine/public/dispatch.fcgi -idle-timeout 120 -initial-env RAILS_ENV=production -initial-env PATH=/usr/local/bin -processes 2

        <Directory /server/web/gug-it/redmine/public>
                AddHandler fastcgi-script fcgi
                Require all granted
                AllowOverride all
                Options +FollowSymLinks +ExecCGI
                RewriteEngine On
                RewriteCond %{REQUEST_FILENAME} !-f
                RewriteRule ^(.*)$ dispatch.fcgi
        </Directory>

        ErrorLog "/var/log/redmine.gug-it.gg-error_log"
        CustomLog "/var/log/redmine.gug-it.gg-access_log" common
</VirtualHost>

Dann kopiere ich noch die dispatch.fcgi (wir nutzen FastCGI) an die richtige Stelle und mache sie ausführbar:

cp /usr/local/www/redmine/public/dispatch.fcgi.example /usr/local/www/redmine/public/dispatch.fcgi
chmod +x /usr/local/www/redmine/public/dispatch.fcgi

Jetzt geht es an die Netzwerkkonfiguration. Die Daten dazu liegen dir hoffentlich vor.

cp /usr/local/www/redmine/config/database.yml.sample /usr/local/www/redmine/config/database.yml

Die bearbeiten wir dann mit dem Editor unserer Wahl und geben die richtigen Daten ein:

production:
  adapter: postgresql
  database: redmine
  host: thorsten.jails.gug-it.gg
  username: redmine
  password: "redmine"
  # Use "utf8" instead of "utfmb4" for MySQL prior to 5.7.7
  encoding: utf8

Nicht vergessen, ich nutze PostgreSQL. Wenn du MySQL oder anderes nutzt, musst du das natürlich beachten! Mein Datenbankserver liegt auf „thorsten.jails.gug-it.gg“.

Als nächstes müssen wir noch ein paar Module zu unserem Redmine hinzufügen. Wir erstellen im Verzeichnis /usr/local/www/redmine die Datei Gemfile.local mit folgendem Inhalt:

gem 'pg'
gem 'fcgi'

und führen dann folgende Befehle aus:

bundle install
rake generate_secret_token
setenv RAILS_ENV production
rake db:migrate
rake redmine:load_default_data

Um Dateiuploads durchführen zu können, müssen wir noch die Datei configuration.yml anlegen. Dazu kopieren wir die Example-Datei einfach:

cp /usr/local/www/redmine/config/configuration.yml.example /usr/local/www/redmine/config/configuration.yml

und setzen dort den attachments_storage_path auf ein sinnvolles Verzeichnis, in meinem Fall „/server/files/redmine“. Ich lege das Verzeichnis an:

mkdir -p /server/files/redmine
chown -R www:www /server/files/redmine

und trage dann in usr/local/www/redmine/config/configuration.yml folgendes ein:

attachments_storage_path: /server/files/redmin

Ich lasse an dieser Stelle die E-Mail-Konfiguration mal aus, weil das recht spezifisch ist. Kommt ganz darauf an, was du brauchst, aber schau dir die Konfigurationsdatei einmal an und du wirst schnell verstehen, wie das funktioniert.

Wenn wir dann Apache starten (oder neustarten), können wir auf Redmine zugreifen. Die Standardzugangsdaten lauten:

Benutzername: admin, Kennwort: admin

Du wirst direkt aufgefordert, dein Kennwort zu ändern. Jetzt kannst du direkt loslegen.

Hier geht es zum Video.

Hier geht es zur Playlist.

Hier geht es zu Redmine für Administratoren.