GAMBAS BOOK 3.14

Often there is a desire to pass on a Gambas program. Two approaches are possible:

• Passing on the Gambas project in a source code archive. Required prerequisite: Gambas is also completely installed on the target computer in a relevant version.
• Transfer of the program as an installation package (archive) for selected Linux distributions. An installation package consists of several files. Required prerequisite: On the target computer, the Gambas packages can be installed in a version whose version number is equal to or greater than that on the development computer.

Gambas provides suitable export dialogs for both variants in the IDE. This → chapter 11.10 explains how to generate an installation package for a target distribution.

The description of how to put together an installation package and install it on a target computer is based on a concrete objective with narrowly defined boundary conditions - implemented in the StructDB project. In my opinion, the note is necessary because there will be no general, promising description for every Linux distribution and for every (stable) version of Gambas.

Objective:

• Developer E develops and tests the StructDB project (StructDB program as a simple database application) under Ubuntu 12.04 LTS (support until 2017), deploys a stable Gambas from the project sources and finally shuts down the Gambas installation package for the target distribution Ubuntu/Mint.
• User B uses Mint 17.1 (Rebecca) on the target computer and all Gambas packages from the (stable) Ubuntu-PPA can be installed. The Gambas development environment (IDE) is not installed there because it is not needed to install the Gambas installation package - stored in the ~/IP_StructDB folder on the target computer - from B (with root privileges) and to use the StructDB program.

Figure 11.10.0.1.1: GUI for the program StructDB

These previews are the result of many attempts to successfully compile an installation package and reflect the experience with the wizard for generating an installation package (? packer wizard). Success is considered successful if the installation package can be installed by user B with root privileges on the target computer without any problems and user B can use the installed program as specified in the program specification.

As soon as you create the project whose program you want to pass on, you should be sure about the type of project and the options to be selected, and choose the type and the appropriate options. For programs with a GUI, you can choose:

• Graphic application
• QT-GUI application
• GTK+ Graphic application

If you select 'Graphical application', the component gb.gui will be loaded at development time and the Packer Wizard will load both the gb.gtk packages and the gb.qt4 packages to the dependencies list. As a result, you will find 3 different *.deb files in the package:

• StructDB_1.2.12-0ubuntu1_all.deb.
• StructDB_gtk_1.2.12-0ubuntu1_all.deb.
• StructDB_qt4_1.2.12-0ubuntu1_all.deb

and leads to the question: Which Debian package is used on the target machine?

You can install the StructDB_gtk_1.2.12-0ubuntu1_all.deb package or the StructDB_qt4_1.2.12-0ubuntu1_all.deb package, or both. However, since these two packages depend on the Debian package StructDB_1.2.12-0ubuntu1_all.deb, which is the project without GUI dependencies, the StructDB_1.2.12-0ubuntu1_all.deb package is also installed in any case.

• When creating a new project, select the same names for the project name and the project title in the project information. For example, if you select' StructDB' as the project name and' StructDataBase' as the project title, then the project title' StructDataBase' appears in the menu on the target computer, while you have to call the program in the console with' StructDB'.
• Since later on the development computer in the packer wizard in step 1 essential information from the basic settings of Gambas are automatically transferred into the installation package and are also displayed on the target computer during the program installation, you should enter the information about the editor in time under Tools> Settings> Identity.
• In step 9, the Packer Wizard prompts you to specify the folder in which the wizard should store the generated installation package. Here it is advantageous if this (empty) folder already exists.

(F1) Defining program configurations (configuration file)
(F2) Multilingual application
(F3) Using a program help ( → function key F1)
(F4) Sharing of files that can only be read by all users
(F5) Sharing of files that require a user's write and read rights
(F6) Starting the program with and without argument
(F7) Creating your own MIME type for program-specific data files

The following sections and further chapters describe how to successfully implement the above requirements using the StructDB project as an example. At suitable places, some extracts from the source code of the project support the description.

The component gb.settings is used to define program configurations in a configuration file (→ Chapter 19.1). The window coordinates of the program window are stored in the configuration file in the standard path in the StructDB project.

Only at the first start the program window is centered. The values that were saved in the configuration file when the program window was closed then apply:

Public Sub Form_Open()
…
  If IsNull(structSettings["Window/Top"]) And IsNull(structSettings["Window/Left"]) Then 
     FMain.Center
  Else
     FMain.Top = structSettings["Window/Top", FMain.Top] 
     FMain.Left = structSettings["Window/Left", FMain.Left] 
  Endif
…
End ' Form_Open()
Public Sub Form_Close()
  structSettings["Window/Top"] = FMain.Top 
  structSettings["Window/Left"] = FMain.Left 
  If FHelp.Closed = False Then FHelp.Close
End ' Form_Close()

In the Options tab of the project settings, the default language English (UK) is selected in the Options tab after the Project can be translated question has been answered with Yes. Further information on the internationalization (I18N) of a project can be found in? chapter 20.1.3 Message and I18N and in? chapter 11.11 Project I18N.

The quickest way to start the translation of the individual texts into the German language is to use CTRL+T or start it in the menu under Project> Translate - you only have to translate it yourself.

Give the program StructDB and all future users a program help. The help in the main program is called with the function key F1 and the event Form_KeyPress() is evaluated in the main program. In response, a further form - FHelp in this case - is displayed with the help text which is closed with the escape key (ESC):

Public Sub Form_KeyPress()
  If Key.Code = Key.F1 Then 
     FHelp.Show
  Endif 
  If Key.Code = Key.ESC And FHelp.Closed = False Then 
     FHelp.Delete
  Endif 
End ' Form_KeyPress()
 
Public Sub Form_Show()
  FHelp.Border = 1
  FHelp.Arrangement = Arrange.Fill
  TextArea1.Background = &H00FFFFDF&
  TextArea1.Text = File.Load("help.txt") ' → Relative path!
End ' Form_Show()

The help text is only read from a file help.txt, since it does not have to be changed for the current program version. The help file is located in the IDE in the logical folder “Data”, which corresponds to the physical project folder.

Note: All files in the physical project directory are included in the “Gambas executable” when the StructDB.gambas executable file is generated. You can't find them anywhere in the file system of the target computer; but you can't reach them under “Application. Path” either! Details about this freely selected classification of folders (logical/physical) in a Gambas project can be found in the next paragraph.

The following explanations are generally necessary - also for understanding the transfer of files in the installation project:

On a data carrier, which will often be the computer hard disk, the Gambas project StructDB is located in a certain directory structure. If you switch on the display of hidden files/folders in your file browser, you will see some hidden folders that Gambas uses for control files as well as files and folders (marked red) that you have copied or created into the project directory.

Figure 11.10.0.7.7.1: Directory structure project directory (file browser)

If you edit the StructDB project in the Gambas IDE, you will surely notice the difference to the directory structure in → figure 11.10.0.7.1:

Figure 11.10.0.7.7.2: Directory Structure (Project Folder) Gambas IDE

If you also want to use the installation package to install files system-wide on the target computer, but to protect files from writing access by regular (non-root) users, then copy these files to the physical folder. hidden at the time of development or create them in the logical folder “Project” in the IDE, for example!

Figure 11.10.0.8.8.1: Files in hidden folder.hidden

• For example, select /usr/share/doc/StructDB as the destination folder in step 8 of the Packer Wizard, under usr/share/doc/StructDB you will normally find the read-only (data) files of installed programs.
• When installing the installation package on the target computer, the selected files from the logical folder “Project” are automatically copied to the specified target paths!
• Note that you must define the paths in good time, as they will not be used when coding and testing the application. Therefore, make sure that the program. txt file is also located in the logical folder “Data”. This is necessary if you test the program on the development computer. You should separate from the idea to create a folder /usr/share/doc/StructDB and copy the program. txt file there, because you need root privileges to create the folder in the specified system path!
• In addition to the (short) documentation program. txt, the icon file structdb_dfi.png in the project StructDB is also exported from the folder 'Symbol' and the file structdb.xml from the folder 'XML'.

User-specific files, on the other hand, are stored in user B's home directory on the target computer. Here, the content can only be read and edited by user B, unlike all other users. These user-specific files must be located in the IDE folder structure in the logical folder “Data” - that is, in the physical project folder. Such a file is in the project StructDB example. sdb (→ Figure 11.10.0.7.1), which is given to the program StructDB as a sample database and requires read and write permissions from user B. This file is called StructDB example. sdb (→ Figure 11.10.0.7.1).

But pay attention: You cannot install the user-specific file example.sdb with a Debian package, because the Debian Installer will always start as root and cannot recognize that you are, for example, the system user B with the sonorous name gambanix. Therefore, when the program is started for the first time, the selected user-specific file example. sdb is copied to the StructDB folder in user B's home directory. The folder whose name you can freely choose will be created if it does not exist - which is to be checked:

Public Sub Form_Open()
…
  If Not Exist(User.Home &/ "StructDB") Then
     Try Mkdir User.Home &/ "StructDB"
 
     If Error Then 
        Message.Error(Subst$(("Couldn't create the directory &1"), User.Home &/ "StructDB" & Error.Code))
        Quit
     Else
        Try Copy "example.sdb" To User.Home &/ "StructDB/example.sdb"
        If Error Then
           Message.Error(Subst$(("Couldn't copy the file &1"), User.Home &/ "StructDB/example.sdb"))
        Endif
        Wait
     Endif
 
  Endif ' Not Exist(User.Home &/ "StructDB")
…
 
End ' Form_Open()

The program start of StructDB on a target computer (Mint 17.1 with German language package) is done either via the menu or by a created starter on the desktop or by calling it in the console - in the first case without argument:

hans@linuxmint:~$ /usr/bin/StructDB 
hans@linuxmint:~$ StructDB 

Figure 11.10.0.10.1: Program start without argument

In the second case, the (pseudo) database file example.sdb is passed as argument at program startup:

hans@linuxmint:~$ StructDB -- ~/Kursdaten/example.sdb

Figure 11.10.0.10.10.2: Program start with file as argument

In the source code there is a small section in the procedure Form_Open(), which opens the program safely with and without argument when starting the program:

Public sOpenProjectPath As String
 
Dim sArgsString As String
Dim bOpenByArgs As Boolean
 
  Args.Begin()
  Args.End()
  For Each sArgsString In Args.End()
    If Not IsNull(sArgsString) Then
       sOpenProjectPath = sArgsString
       Import(sOpenProjectPath)
       tlblRecords.Foreground = Color.Red
       bOpenByArgs = True
    Endif
  Next
 
  If bOpenByArgs = False Then
     cmbDWC1.Text = cmbDWC1[0].Text  
     cmbDWC2.Text = cmbDWC2[1].Text
     tlblRecords.Visible = False
     tlblRecords.Foreground = Color.Red
     Status(False)
     btnUpdate.Enabled = False
     btnSave.Enabled = False
     txbLastname.SetFocus    
  Endif ' bOpenByArgs = False ?

2 methods of the component gb.args are used. A detailed description of this component can be found in chapter 5.8.0 Gambas programs with options and arguments.

More elegant would be the possibility that after double-clicking on a *.sdb file, the database program StructDB opens, the records from the selected *.sdb file are read and displayed. To achieve this, you must

• either explore the MIME type of the *.sdb files and pass this MIME type to the installation package in the 6th step of the Packer Wizard or
• of the installation package to create and register a program-specific MIME type on the target computer → chapter 11.10.1. This requires entries in steps 6 and 8 in the Packer Wizard.

Oft besteht der Wunsch, ein Gambas-Programm weiterzugeben. Zwei Ansätze kommen dafür in Betracht:

• Weitergabe des Gambas-Projekts in einem Quelltext-Archiv. Notwendige Voraussetzung: Auch auf dem Ziel-Rechner ist Gambas in einer relevanten Version vollständig installiert.
• Weitergabe des Programms als Installationspaket (Archiv) für ausgewählte Linux-Distributionen. Ein Installationspaket besteht aus mehreren Dateien. Notwendige Voraussetzung: Auf dem Ziel-Rechner sind die Gambas-Pakete über den Paket-Manager in einer Version installierbar, deren Versionsnummer gleich oder größer ist als die auf dem Entwicklungsrechner.

Gambas stellt für beide Varianten in der IDE geeignete Export-Dialoge zur Verfügung. In diesem → Kapitel 11.10 erfahren Sie, wie Sie ein Installationspaket für eine Ziel-Distribution generieren.

Basis der Beschreibung, wie man ein Installationspaket schnürt und auf einem Ziel-Rechner installiert, ist eine konkrete Zielstellung mit eng gefassten Randbedingungen – umgesetzt im Projekt StructDB. Der Hinweis ist m.E. notwendig, weil es keine allgemeine, Erfolg versprechende Beschreibung für jede Linux-Distribution und für jede (stabile) Gambas-Version geben wird.

Zielstellung:

• Der Entwickler E entwickelt und testet das Projekt StructDB (Programm StructDB als einfache Datenbankanwendung) unter Ubuntu 12.04 LTS (Support bis 2017), setzt ein stabiles Gambas aus den Projekt-Quellen ein und schnürt abschließend das Gambas-Installationspaket für die Ziel-Distribution Ubuntu/Mint.
• Der Benutzer B setzt auf dem Ziel-Rechner Mint 17.1 (Rebecca) ein und es sind alle Gambas-Pakete aus dem (stabilen) Ubuntu-PPA installierbar. Die Gambas-Entwicklungsumgebung (IDE) ist dort nicht installiert, weil sie nicht benötigt wird, um das Gambas-Installationspaket – gespeichert im Ordner ~/IP_StructDB auf dem Zielrechner – von B (mit Root-Rechten) zu installieren und um das Programm StructDB zu verwenden.

Abbildung 11.10.0.1.1: GUI für das Programm StructDB

Diese Vorbetrachtungen sind das Resultat vieler Versuche, ein Installationspaket erfolgreich zu schnüren und widerspiegeln die Erfahrungen im Umgang mit dem Assistenten für das Generieren eines Installationspakets (→ Packer-Assistent). Als Erfolg gilt, wenn das Installationspaket vom Benutzer B mit Root-Rechten auf dem Ziel-Rechner ohne Probleme installiert werden kann und der Benutzer B das installierte Programm so nutzen kann, wie es die Programm-Spezifikation vorsieht.

Schon bei der Anlage des Projekts, dessen Programm weitergegeben werden soll, sollten Sie sich vor allem beim Projekt-Typ und bei den auszuwählenden Optionen sicher sein und den vorgesehenen Typ und die passenden Optionen auswählen. Bei den Programmen mit einer GUI können Sie wählen:

• Grafische Anwendung
• QT-GUI-Anwendung
• GTK+ Grafische Anwendung

Wenn Sie 'Grafische Anwendung' wählen, so wird zur Entwicklungszeit die Komponente gb.gui geladen und der Packer-Assistent wird sowohl die gb.gtk-Pakete als auch die gb.qt4-Pakete in die Liste der Abhängigkeiten aufnehmen. Das hätte zur Folge, dass Sie dann u.a. 3 verschiedene *.deb-Dateien im Paket finden:

* StructDB_1.2.12-0ubuntu1_all.deb
* StructDB_gtk_1.2.12-0ubuntu1_all.deb
* StructDB_qt4_1.2.12-0ubuntu1_all.deb

und führt zu der Frage: Welches Debian-Paket wird auf dem Ziel-Rechner verwendet?

Sie können das StructDB_gtk_1.2.12-0ubuntu1_all.deb-Paket oder das StructDB_qt4_1.2.12-0ubuntu1_all.deb-Paket installieren oder beide. Da diese beiden Pakete aber vom Debian-Paket StructDB_1.2.12-0ubuntu1_all.deb abhängen, welches das Projekt ohne GUI-Abhängigkeiten ist, wird das StructDB_1.2.12-0ubuntu1_all.deb-Paket in jedem Fall auch (mit-)installiert.

• Wählen Sie beim Anlegen eines neuen Projekts bei den Projekt-Informationen gleiche Bezeichnungen für den Projektnamen und den Projekttitel. Wählten Sie zum Beispiel als Projektname 'StructDB' und als Projekttitel 'StructDataBase', dann erscheint im Menü auf dem Ziel-Rechner der Projekttitel 'StructDataBase', während Sie das Programm in der Konsole mit 'StructDB' aufrufen müssen.
• Da später auf dem Entwicklungsrechner im Packer-Assistenten im Schritt 1 wesentliche Angaben aus den Grund-Einstellungen von Gambas automatisch in das Installationspaket übernommen werden und bei der Programm-Installation auf dem Ziel-Rechner auch angezeigt werden, sollte man die Angaben zum Bearbeiter unter Tools> Einstellungen> Identity bereits rechtzeitig eintragen.
• Der Packer-Assistent fordert Sie im 9. Schritt auf den Ordner anzugeben, in dem der Assistent das generierte Installationspaket ablegen soll. Hier ist es von Vorteil, wenn dieser (leere) Ordner bereits existiert.

Das getestete Projekt StructDB setzt einige Forderungen um, die im Zusammenhang mit der Weitergabe von Gambas-Programmen häufig gestellt werden:

(F1) Festlegung von Programm-Konfigurationen (Konfigurationsdatei)
(F2) Mehrsprachige Anwendung
(F3) Einsatz einer Programm-Hilfe (→ Funktionstaste F1)
(F4) Weitergabe von Dateien, die von allen Nutzern nur gelesen werden können
(F5) Weitergabe von Dateien, die von einem Benutzer Schreib- und Lese-Rechte erfordern
(F6) Programmstart mit und ohne Argument
(F7) Erzeugen eines eigenen MIME-Typs für programm-spezifische Daten-Dateien

In den folgenden Abschnitten und weiteren Kapiteln wird am Beispiel des Projekts StructDB beschrieben, wie Sie die o.a. Forderungen erfolgreich umsetzen. An geeigneten Stellen unterstützen einige Ausschnitte aus dem Quelltext des Projekts die Beschreibung.

Für die Festlegung von Programm-Konfigurationen in einer Konfigurationsdatei wird die Komponente gb.settings eingesetzt (→ Kapitel 19.1). In der Konfigurationsdatei im Standardpfad werden im Projekt StructDB die Fenster-Koordinaten des Programmfensters gespeichert.

Einzig beim ersten Start wird das Programm-Fenster zentriert ausgegeben. Danach gelten die Werte, die beim Schließen des Programmfensters in der Konfigurationsdatei gespeichert wurden:

Public Sub Form_Open()
…
  If IsNull(structSettings["Window/Top"]) And IsNull(structSettings["Window/Left"]) Then 
     FMain.Center
  Else
     FMain.Top = structSettings["Window/Top", FMain.Top] 
     FMain.Left = structSettings["Window/Left", FMain.Left] 
  Endif
…
End ' Form_Open()
Public Sub Form_Close()
  structSettings["Window/Top"] = FMain.Top 
  structSettings["Window/Left"] = FMain.Left 
  If FHelp.Closed = False Then FHelp.Close
End ' Form_Close()

In den Projekteinstellungen wird im Reiter Optionen als Standardsprache Englisch (UK) ausgewählt, nachdem die Frage Projekt kann übersetzt werden mit Ja beantwortet wurde. Weitere Informationen zur Internationalisierung (I18N) eines Projekts finden Sie im → Kapitel 20.1.3 Message und I18N und im → Kapitel 11.11 Projekt I18N.

Die Übersetzung der einzelnen Texte in die deutsche Sprache starten Sie am schnellsten mit CTRL+T oder starten im Menü unter Projekt> Übersetzen – nur übersetzen müssen Sie dann selbst.

Spendieren Sie dem Programm StructDB und damit allen zukünftigen Nutzern eine Programm-Hilfe. Die Hilfe im Hauptprogramm wird mit der Funktionstaste F1 aufgerufen und im Hauptprogramm das Ereignis Form_KeyPress() ausgewertet. Als Reaktion wird ein weiteres Formular – hier FHelp – mit dem Hilfetext angezeigt, das mit der Escape-Taste (ESC) geschlossen wird:

Public Sub Form_KeyPress()
  If Key.Code = Key.F1 Then 
     FHelp.Show
  Endif 
  If Key.Code = Key.ESC And FHelp.Closed = False Then 
     FHelp.Delete
  Endif 
End ' Form_KeyPress()
 
Public Sub Form_Show()
  FHelp.Border = 1
  FHelp.Arrangement = Arrange.Fill
  TextArea1.Background = &H00FFFFDF&
  TextArea1.Text = File.Load("help.txt") ' → Relativer Pfad!
End ' Form_Show()

Der Hilfetext wird aus einer Datei help.txt nur ausgelesen, da er für die aktuelle Programm-Version nicht geändert werden muss. Die Hilfe-Datei liegt in der IDE im logischen Ordner “Daten”, was dem physischen Projekt-Ordner entspricht.

Beachten Sie: Alle Dateien im physischen Projektverzeichnis werden beim Generieren der ausführbaren Datei StructDB.gambas in die “Gambas-Executable” eingebunden. Sie sind nirgendwo im Dateisystem des Ziel-Rechners zu finden; aber auch nicht unter “Application.Path” erreichbar! Details zu dieser frei gewählten Klassifizierung von Ordnern (logisch/physisch) in einem Gambas-Projekt finden Sie im nächsten Absatz.

Die folgenden Ausführungen sind generell – auch für das Verständnis der Weitergabe von Dateien im Installationsprojekt – notwendig:

Auf einem Datenträger, das wird häufig die Rechner-Festplatte sein, liegt das Gambas-Projekt StructDB in einer bestimmten Verzeichnis-Struktur vor. Schalten Sie in Ihrem Datei-Browser die Anzeige versteckter Dateien/Ordner ein, so sehen Sie neben einigen versteckten Dateien auch versteckte Ordner, die Gambas für Steuerdateien verwendet sowie Dateien und Ordner (rot markiert), die Sie selbst in das Projekt-Verzeichnis kopiert oder dort angelegt haben.

Abbildung 11.10.0.7.1: Verzeichnis-Struktur Projekt-Verzeichnis (Datei-Browser)

Bearbeiten Sie das Projekt StructDB in der IDE von Gambas, so fällt Ihnen dort sicher der Unterschied zur Verzeichnis-Struktur in der → Abbildung 11.10.0.7.1 auf:

Abbildung 11.10.0.7.2: Verzeichnis-Struktur (Projekt-Ordner) Gambas-IDE

Um den Unterschied klar herauszuarbeiten, wird ein Ordner im folgenden “physisch” genannt, wenn er auf einem Datenträger liegt und Sie ihn mit dem Datei-Browser betrachten können. Ein Ordner dagegen ist vom Typ “logisch”, wenn die Gambas-IDE einem bestimmten physischen Ordner eine besondere Bedeutung beimisst. Im Dateibrowser sehen Sie nur physische Ordner, in der Gambas-IDE vorwiegend logische. Der physische Ordner .hidden entspricht dem logischen Ordner “Projekt”. Nur Dateien, die Sie in den versteckten Ordner .hidden legen, werden in der IDE im Ordner “Projekt” angezeigt und einzig Dateien aus diesem Ordner können Sie im Schritt 8 des Packer-Assistenten auswählen und in einen Ordner Ihrer Wahl auf dem Ziel-Rechner kopieren. Dateien und Ordner (→ Abbildung 11.10.0.7.1; rot markiert), die Sie in das physische Projekt-Verzeichnis kopiert oder dort angelegt haben, sehen Sie in der IDE im logischen Ordner “Daten”. Diese Ordner und Dateien werden beim Kompilieren in die ausführbare Datei StructDB.gambas aufgenommen.

Wenn Sie das Installationspaket auch nutzen möchten, um Dateien auf dem Ziel-Rechner system-weit zu installieren, aber vor schreibendem Zugriff regulärer (nicht Root-)Benutzer zu schützen, dann kopieren Sie diese Dateien zur Entwicklungszeit in den physischen Ordner .hidden oder legen diese zum Beispiel in der IDE im logischen Ordner “Projekt” an!

Abbildung 11.10.0.8.1: Dateien im versteckten Ordner .hidden

• Als Ziel-Ordner wählen Sie zum Beispiel /usr/share/doc/StructDB im Packer-Assistenten im Schritt 8. Unter /usr/share/ befinden sich normalerweise die read-only-(Daten)-Dateien installierter Programme.
• Beim Installieren des Installationspakets auf dem Ziel-Rechner werden die ausgewählten Dateien aus dem logischen Ordner “Projekt” automatisch in die angegebenen Ziel-Pfade kopiert!
• Beachten Sie, dass Sie die Pfade rechtzeitig festlegen, denn diese werden Sie beim Kodieren und Erproben der Anwendung nicht nutzen. Achten Sie deshalb darauf, dass die Datei program.txt auch im logischen Ordner “Daten” liegt. Das ist notwendig, wenn Sie das Programm auf dem Entwicklungsrechner erproben. Von der Idee, beim ersten Programm-Start einen Ordner /usr/share/doc/StructDB anzulegen und dorthin die Datei program.txt zu kopieren, sollten Sie sich trennen, denn Sie benötigen Root-Rechte für das Anlegen des Ordners im angegebenen System-Pfad!
• Neben der (Kurz-)Dokumentation program.txt werden im Projekt StructDB auch die Icon-Datei structdb_dfi.png aus dem Ordner 'Symbol' und die Datei structdb.xml aus dem Ordner 'XML' exportiert.

Nutzer-spezifische Dateien dagegen sind im Home-Verzeichnis des Benutzers B auf dem Ziel-Rechner bestens aufgehoben. Dort kann der Inhalt nur vom Benutzer B gelesen und bearbeitet werden; im Gegensatz zu allen anderen Benutzern. Diese nutzer-spezifischen Dateien müssen in der IDE-Order-Struktur im logischen Ordner “Daten” liegen – also im physischen Projekt-Ordner. So eine Datei ist im Projekt StructDB example.sdb (→ Abbildung 11.10.0.7.1), die als Muster-Datenbank dem Programm StructDB mitgegeben wird und vom Benutzer B Lese- sowie Schreibrechte erfordert.

Aber aufgepasst: Sie können die nutzer-spezifische Datei example.sdb nicht mit einem Debian-Paket installieren, da der Debian-Installer immer als Root gestartet wird und nicht erkennen kann, dass Sie beispielsweise der System-Benutzer B mit dem klangvollen Namen gambanix sind. Deshalb wird beim ersten Start des Programms die ausgewählte nutzer-spezifische Datei example.sdb in den Ordner 'StructDB' im Home-Verzeichnis von Benutzer B kopiert. Der Ordner, dessen Namen Sie frei wählen können, wird angelegt, wenn er nicht existiert - was zu prüfen ist:

Public Sub Form_Open()
…
  If Not Exist(User.Home &/ "StructDB") Then
     Try Mkdir User.Home &/ "StructDB"
 
     If Error Then 
        Message.Error(Subst$(("Couldn't create the directory &1"), User.Home &/ "StructDB" & Error.Code))
        Quit
     Else
        Try Copy "example.sdb" To User.Home &/ "StructDB/example.sdb"
        If Error Then
           Message.Error(Subst$(("Couldn't copy the file &1"), User.Home &/ "StructDB/example.sdb"))
        Endif
        Wait
     Endif
 
  Endif ' Not Exist(User.Home &/ "StructDB")
…
 
End ' Form_Open()

Der Programmstart von StructDB auf einem Ziel-Rechner (Mint 17.1 mit deutschem Sprachpaket) erfolgt entweder über das Menü oder durch einen angelegten Starter auf dem Desktop oder durch den Aufruf in der Konsole – im ersten Fall ohne Argument:

hans@linuxmint:~$ /usr/bin/StructDB 
hans@linuxmint:~$ StructDB 

Abbildung 11.10.0.10.1: Programm-Start ohne Argument

Im 2. Fall wird beim Programm-Start die (Pseudo-)Datenbank-Datei example.sdb als Argument übergeben:

hans@linuxmint:~$ StructDB -- ~/Kursdaten/example.sdb

Abbildung 11.10.0.10.2: Programm-Start mit Datei als Argument

Im Quelltext findet sich in der Prozedur Form_Open() ein kleiner Abschnitt, der beim Programm-Start das Programm sicher mit und ohne Argument öffnet:

Public sOpenProjectPath As String
 
Dim sArgsString As String
Dim bOpenByArgs As Boolean
 
  Args.Begin()
  Args.End()
  For Each sArgsString In Args.End()
    If Not IsNull(sArgsString) Then
       sOpenProjectPath = sArgsString
       Import(sOpenProjectPath)
       tlblRecords.Foreground = Color.Red
       bOpenByArgs = True
    Endif
  Next
 
  If bOpenByArgs = False Then
     cmbDWC1.Text = cmbDWC1[0].Text  
     cmbDWC2.Text = cmbDWC2[1].Text
     tlblRecords.Visible = False
     tlblRecords.Foreground = Color.Red
     Status(False)
     btnUpdate.Enabled = False
     btnSave.Enabled = False
     txbLastname.SetFocus    
  Endif ' bOpenByArgs = False ?

Eingesetzt werden 2 Methoden der Komponente gb.args. Eine detaillierte Beschreibung dieser Komponente finden Sie im → Kapitel 5.8.0 Gambas-Programme mit Optionen und Argumenten.

Eleganter wäre die Möglichkeit, dass sich nach einem Doppel-Klick auf eine *.sdb-Datei das Datenbank-Programm StructDB öffnet, die Datensätze aus der ausgewählten *.sdb-Datei eingelesen und angezeigt werden. Um das zu realisieren, müssen Sie

• entweder den MIME-Typ der *.sdb-Dateien erkunden und diesen MIME-Typ im Packer-Assistenten im 6. Schritt dem Installationspaket mitgeben oder
• vom Installationspaket einen programm-spezifischen MIME-Typ auf dem Ziel-Rechner erzeugen und registrieren lassen → Kapitel 11.10.1. Dazu sind Eintragungen in den Schritten 6 und 8 im Packer-Assistenten notwendig.