Programmierung

Oberflächenprogrammierung mit wiederverwendbaren Aktionen

Softwareentwicklung kostet Zeit, und Zeit ist ja bekanntlich Geld. Aus diesem Grund versucht der Entwickler oder derjenige der den Entwickler bezahlt, die Zeit, die für die Entwicklung von Software benötigt wird, möglichst kurz zu halten. Um dieser Anforderung gerecht zu werden, werden zahlreiche Bedingungen an Software gestellt: Wiederverwendbarkeit (Reusability, Don’t repeat yourself; DRY), Erweiterbarkeit und Wartbarkeit sind nur einige davon. In diesem Artikel möchte ich Ihnen ein Modul vorstellen, mit dem Sie dem Ziel Zeitersparnis ein ganzes Stück näher kommen, und zwar bei der Programmierung von Oberflächen in CONZEPT 16.

Oberflächen, also Benutzerschnittstellen (User interfaces; UI), stellen für gewöhnlich Funktionen zur Verfügung mit denen der Benutzer die Software benutzen kann. Dies sind zum Beispiel das Aktualisieren einer Anzeige oder das Anlegen, Bearbeiten und Löschen von Daten. Damit der Anwender diese Funktionen nutzen kann, müssen sie ihm zugänglich gemacht werden. Meist geschieht dies über weitere Oberflächenelemente wie Menüs, Kontextmenüs, Werkzeugleisten oder Schaltflächen, aber auch die Verknüpfung mit bestimmten Tastatur- und Mauseingaben, wie der Taste “F5” oder einem Doppelklick, sind typisch.
Die Implementierung solcher zusätzlichen Oberflächenelemente und die Verknüpfung der Oberfläche mit Eingaben über Tastatur oder Maus sind umfangreiche und zeitaufwändige Arbeiten. Um diese immer wiederkehrende Arbeit zu bewältigen, können Sie das Modul SysAct verwenden.
Mit dem Modul SysAct kann der Entwickler Aktionen definieren, steuern und Oberflächenobjekten zuordnen. Die Anpassung der einzelnen Oberflächenelemente, die Verarbeitung der Ereignisse und das Auslösen der Aktionen nimmt das Modul dem Entwickler ab. Intern verwendet das Modul SysAct weitere Module, unter anderem das Modul SysEvt, das ich im Rahmen des Entwurfsmusters Observer bereits vorgestellt habe.
Mit der Funktion Act.Create() wird eine Aktion erzeugt und definiert:

Act.Create
(
  aActParent     : handle; // Übergeordnete Aktion oder 0
  opt aID        : int;    // ID
  opt aStatus    : int;    // Status (_Act...)
  opt aCaption   : alpha;  // Titel
  opt aIcon      : int;    // Symbol (_WinImg...)
  opt aMaskBoard : int;    // Tastaturaktion (_WinKey...)
  opt aMaskMouse : int;    // Mausaktion (_WinMouse...)
  opt aItemMouse : int;    // Mauselement (Spaltennummer)
)
: handle;                  // Aktion

Eine Aktion definiert sich aus einer selbstdefinierbaren ID, Status, Titel und Symbol. Darüber hinaus kann jeder Aktion eine Tastatur- und eine Mausaktion zugeordnet werden, durch die die Aktion ausgelöst werden soll.

Beispiel
// Elternaktion erzeugen
gAct # Act.Create(0);

// Aktion erzeugen:
// Bearbeiten per [Eingabe] oder Doppelklick
gActModify # gAct->Act.Create(0, 0,
  'Bearbeiten', _WinImgEdit, _WinKeyReturn,
  _WinMouseLeft | _WinMouseDouble);

Mit der Funktion Act.Destroy() wird eine nicht mehr benötigte Aktion zerstört, das heißt wieder freigegeben.

Act.Destroy
(
  aAct           : handle; // Aktion
)
Beispiel
// Aktion freigeben
gAct->Act.Destroy();

Über die Funktion Act.EventSet() kann eine Callback-Funktion gesetzt werden, die aufgerufen wird, wenn eine Aktion ausgelöst wird.

Beispiel
// [...]

  gAct->Act.EventSet(_Sys->spProcCurrent + ':' + 'Action');

// [...]

sub Action
(
  aAct : handle;
)
{
  // ...
}

Nach der Definition der Aktionen können diese mit der Oberfläche verknüpft werden, und zwar indem sie einem oder sogar mehreren Oberflächenobjekten zugeordnet werden.

Beispiel
// [...]

  // Aktionen einem Fenster zuordnen (Menü)
  tWinFrame->Act.Relate(gAct);
  // Aktionen einer Werkzeugleiste zuordnen
  tWinToolBar->Act.Relate(gAct);
  // Aktionen einem Baum zuordnen (Kontextmenü)
  tWinTreeView->Act.Relate(gAct);
  // Aktion einer Schaltfläche zuordnen
  tWinButton->Act.Relate(gActModify);

// [...]

  // Zuordnungen aufheben
  tWinFrame->Act.Relate(0);
  tWinToolBar->Act.Relate(0);
  tWinTreeView->Act.Relate(0);
  tWinButton->Act.Relate(0);

Damit ist die Minimalimplementierung dieses Moduls bereits realisiert, aber das ist selbstverständlich noch nicht alles, was dieses Modul leisten kann ;). Beispielsweise können Sie die einzelnen Eigenschaften einer Aktion, wie den Status, zu jeder Zeit ändern. Dies ist dann sinnvoll, wenn sich die Auswahl auf die sich die Aktion bezieht ändert, also zum Beispiel beim Selektieren eines Baumknotens.

Beispiel
// Bearbeiten deaktivieren
gActModify->Act.StatusSet(_Act.Disabled);

Diese Änderungen werden sogar automatisch in die Oberflächenobjekte übernommen. Bei Menüs und Kontextmenüs passiert dies sofort, da Menüpunkte bei jedem Aufklappen angepasst werden. Für Werkzeugleisten und Schaltflächen können die Änderungen mit der Funktion Act.Adjust() übernommen werden.

Beispiel
// Änderungen übernehmen
gActModify->Act.Adjust();

Auf den nachfolgenden Bildern können Sie anhand eines Beispiels sehen, wie sich die Oberflächenobjekte anpassen. Das Menü, die Werkzeugleiste, die Schaltflächen und das Kontextmenü werden abhängig von der Auswahl aktiviert, angezeigt und angehakt.

Auswahl “Ordner”: Bearbeiten und Löschen deaktiviert.
Auswahl “Dokument A”: Anlegen unsichtbar, Bearbeiten und Löschen aktiviert.
Auswahl “Dokument B”: Anlegen unsichtbar, Bearbeiten und Löschen deaktivert, Sperren sichtbar.
Auswahl “Dokument B”: Anlegen unsichtbar, Bearbeiten und Löschen deaktivert, Entsperren sichtbar und anghakt.

Sie finden alle benötigten Ressourcen des Moduls sowie das ausführliche und ganzheitliche Beispiel zur Verwendung des Moduls als Download am Ende des Artikels.

Download

Zum downloaden hier klicken SysAct-2.2.zip (17.95 KB)
Sie müssen angemeldet sein, um die Datei herunterladen zu können.

Keine Kommentare

Kommentar abgeben