array in array

[Jens Kallup]

Hallo,

ich habe einen Array:

type
recordMyIconsStructure = record
p: String; // picture
c: String; // design class
h: String; // hint
end;

kann ich diesen Array, also Instanzen von diesen in einen
weiteren Array speichern ?

recordMyIcons_Std : Array[0..22] of recordMyIconsStructure = (
(p: 'tmouse'; c: 'TMouse'; h: 'Mouse Cursor /
Selector'),
(p: 'tmainmenu'; c: 'TMainMenu'; h: 'Create / Edit the
application main menu.'),
...


also den Array recordMyIcons_std in einen Array ?


ptrArray : Array[0..2] of TObject = (
recordMyIcons_Std
);

das geht irgendwie nicht

Jens

[stefan]

Das hier lässt sich zumindest compilieren:

...

type
MyIcons = record

p: String; // picture
c: String; // design class
h: String; // hint
end;

...

var
pArr : Array[0..2] of MyIcons;

implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
pArr[0].p := 'aa';
pArr[0].c := 'cc';
pArr[0].h := 'hh';
end;


Die Wertzuweisung direkt bei der Deklaration funktioniert bei
Konstanten. Ob es auch bei Variablen möglich ist weiss ich nicht.

Am 19.02.2022 um 11:24 schrieb Jens Kallup:
> Hallo,
>
> ich habe einen Array:
>
> type
>   recordMyIconsStructure = record
>     p: String;  // picture
>     c: String;  // design class
>     h: String;  // hint
>   end;

Das ist kein Array, sondern ein Record, also eine Struktur bestehend aus
mehreren Variablen die auch unterschiedliche Typen haben können.

> recordMyIcons_Std : Array[0..22] of recordMyIconsStructure = (
>     (p: 'tmouse';         c: 'TMouse';        h: 'Mouse Cursor /
> Selector'),
>     (p: 'tmainmenu';      c: 'TMainMenu';     h: 'Create / Edit the
> application main menu.'),
> ...

siehe oben, wenn man es als Konstantendeklaration macht könnte das so
ähnlich klappen (?)

[Jens Kallup]

Hallo Stefan,

kann man nicht irgendwie was mit Pointern machen ?
die direkte Angabe der Klasse geht nicht in einen
Array.

Ich will aber auch ungern Klassen verwenden, da diese
weiteren Speicher in Beschlag nehmen.

Jens

[stefan]

Klassen bzw. Objekte sind sowas ähnliches wie Records, haben aber im
Gegensatz zu Records auch Methoden. Wenn ich das richtig sehe, brauchst
du das aber nicht. Die Frage wäre sogar, ob du überhaupt Records
brauchst. Man könnte auch einfach ein zweidimensionales Array nehmen.

Ich bin da jetzt nicht ganz so fit was das Thema angeht. Ich denke noch
in Strukturen die es schon in Turbo-Pascal gab ;-)

Du müsstest mal erklären, was du eigentlich erreichen willst.

[Jens Kallup]

Am 19.02.2022 um 13:11 schrieb stefan:

> Du müsstest mal erklären, was du eigentlich erreichen willst.

Also:
ich habe ein Programm, das so wenig CODE + DATA + BSS einnimmt.
Weil das letzenends auch eine Frage der Wartbarkeit betrifft.

Der übliche "kindliche" Weg wäre Spagetty Code, bei dem jeder
(ich sag jetzt mal TButton) einzeln erzeugt, und bearbeitet werden
muss, wenn Änderungen am Programm vorgenommen werden.

Besser erscheint mir, der etwas kompliziertere Weg, die TComponent
Objekte während der Laufzeit zu erstellen, anstelle die Ressourcen
aka .dfm in die .exe mit aufzunehmen.

Das ginge auch, aber Windows ist dann etwas eigen was Ressourcen
anbelangt (sind zwar manchmal schneller als die direkte Speicher
Allokation - nehmen aber auch manchmal doppelt zuviel Arbeitsspeicher
weg).

Also habe ich versucht bestimmte Teile meines Programmes innerhalb
von Records auszulagern.

Daraus ist dann folgendes geworden:

type
recordMyIconsStructure = record
p: String; // picture
c: String; // design class
h: String; // hint
end;

var
// --------------------
// standard palette :
// --------------------

recordMyIcons_Std : Array[0..22] of recordMyIconsStructure = (
(p: 'tmouse'; c: 'TMouse'; h: 'Mouse Cursor /
Selector'),
(p: 'tmainmenu'; c: 'TMainMenu'; h: 'Create / Edit the
application main menu.'),

(p: 'tpopupmenu'; c: 'TPopupMenu'; h: 'Create / Edit the
application popup menu.'),
(p: 'tlabel'; c: 'TLabel'; h: 'Label for Text.'),
(p: 'tbutton'; c: 'TButton'; h: 'Button that can be
click per mouse.'),
(p: 'tedit'; c: 'TEdit'; h: 'Add Entryfield for
text input.'),
(p: 'tmemo'; c: 'TMemo'; h: 'Editor/Memo for Edit
multiple line Texts.'),
(p: 'tlistbox'; c: 'TListBox'; h: 'List of Strings in a
box.'),
(p: 'ttreeview'; c: 'TTreeView'; h: 'List of Node Texts as
Tree view.'),
(p: 'tcombobox'; c: 'TComboBox'; h: 'Combobox - a one line
List of Text.'),
(p: 'tstringgrid'; c: 'TStringGrid'; h: 'String Grid like
Edits in tabular form.'),
(p: 'tradiobutton'; c: 'TRadioButton'; h: 'A single Radio button.'),
(p: 'tgroupbox'; c: 'TGroupBox'; h: 'Groupbox for Radio
buttons.'),
(p: 'timage'; c: 'TImage'; h: 'Display
Images/Pictures.'),
(p: 'tspinedit'; c: 'TSpinEdit'; h: 'Value Spinner with
up/down Buttons.'),
(p: 'tdatecombobox'; c: 'TDateComboBox'; h: 'Date changer ComboBox-'),
(p: 'tprogressbar'; c: 'TProgressBar'; h: 'A Progess Bar
Component.'),
(p: 'tsplitter'; c: 'TSplitter'; h: 'Splitter for
Components.'),
(p: 'tpanel'; c: 'TPanel'; h: 'Panel container.'),
(p: 'tpagecontrol'; c: 'TPageControl'; h: 'Multiple Page
Container.'),
(p: 'tstatusbar'; c: 'TStatusBar'; h: 'Place a Status-Bar at
Bottom of Window.'),
(p: 'tpaintBox'; c: 'TPaintBox'; h: 'Paint Box Drawer
Component.'),
(p: 'tshape'; c: 'TShape'; h: 'A Shape Drawer
Component.')
);

// ----------------------------
// database controls palette :
// ----------------------------
recordMyIcons_db : Array[0..6] of recordMyIconsStructure = (

(p: 'tmouse'; c: 'TMouse'; h: 'Mouse Cursor / Selector'),

(p: 'tdbedit'; c: 'TDBEdit'; h: 'db-Entryfield for
Text-Input.'),
(p: 'tdbmemo'; c: 'TDBMemo'; h: 'db-Editor/Memo for huge
Text.'),
(p: 'tdbimage'; c: 'TDBImage'; h: 'db-Image.'),
(p: 'tdbgrid'; c: 'TDBGrid'; h: 'db-Table Grid.'),
(p: 'tdblistbox'; c: 'TDBListBox'; h: 'db-ListBox.'),
(p: 'tdbcombobox'; c: 'TDBComboBox'; h: 'db-ComboBox.')
);

// --------------------------
// database access palette :
// --------------------------
recordMyIcons_dbSrc : Array[0..5] of recordMyIconsStructure = (

(p: 'tmouse'; c: 'TMouse'; h: 'Mouse Cursor / Selector'),

(p: 'dbsrc'; c: 'TDataSource'; h: 'data source distributer.'),
(p: 'dbsrcdbase'; c: 'TTable'; h: 'DBF-Table data source.'),
(p: 'dbsrcsql'; c: 'TSQL'; h: 'SQL-Query data source.'),
(p: 'dbsrcmysql'; c: 'TMySQL'; h: 'MySQL-Connection.'),
(p: 'dbsrcodbc'; c: 'TODBC'; h: 'ODBC-Connection.')
);

// --------------------------
// database access palette :
// --------------------------
recordMyIcons_dbNav : Array[0..10] of recordMyIconsStructure = (

(p: 'tmouse'; c: 'TMouse'; h: 'Mouse Cursor / Selector'),

(p: 'dbnavedit'; c: 'TDBnavEdit'; h: 'Select record for
editing.'),
(p: 'dbnavapply'; c: 'TDBnavApply'; h: 'Apply darabase record
changes.'),
(p: 'dbnavfirst'; c: 'TDBnavFirst'; h: 'Jump to first record
for editing.'),
(p: 'dbnavprev'; c: 'TDBnavPrev'; h: 'Goto prev record for
editing.'),
(p: 'dbnavnext'; c: 'TDBnavNext'; h: 'Goto next record in
database.'),
(p: 'dbnavlast'; c: 'TDBnavLast'; h: 'Jump tp last record.'),
(p: 'dbnavadd'; c: 'TDBnavAdd'; h: 'Appemd a record in
database.'),
(p: 'dbnavdel'; c: 'TDBnavDel'; h: 'Delete a record in
database.'),
(p: 'dbnavcancel'; c: 'TDBnavCancel'; h: 'Cancel/Abort
changes/editing.'),
(p: 'dbnavrefresh'; c: 'TDBnavRefresh'; h: 'Refresh record set.')
);



diese records verwende ich, um TabSheet's und Button's darzustellen,
die dann auch gleich ohne Mausklickerriki zu verwenden gleiche Werte
haben.

// ----------------------------------------
// add controls to the control-palette ...
// ----------------------------------------
procedure AddControlPalette(
page: TPageControl;
name: String;
carr: Array of recordMyIconsStructure);
var
left: Integer;
tabSh: TTabSheet;
tabTool: TToolBar;
pageScr: TPageScroller;
itemArr: Array of TrecordMyIcons;
i: Integer;
begin
tabSh := TTabSheet.Create(page);
tabSh.PageControl := page;
tabSh.Align := alClient;
tabSh.Caption := name;
tabSh.Visible := true;

pageScr := TPageScroller.Create(tabSh);
pageScr.Parent := tabSh;
pageScr.Align := alClient;
pageScr.AutoScroll := false;
pageScr.Visible := true;

tabTool := TToolBar.Create(pageScr);
tabTool.Parent := pageScr;
tabTool.AutoSize := true;
tabTool.Visible := true;

tabTool.Align := alNone;
tabTool.Left := 0;
tabTool.Top := 0;

tabTool.ButtonWidth := 55;
tabTool.ButtonHeight := 48;

// create standard palette icons:
SetLength(itemArr,High(carr)+1);
left := 0;
for i := High(itemArr) downto 0 do begin
itemArr[i] := TrecordMyIcons.Create(tabTool);
tabTool.InsertComponent(itemArr[i]);
with itemArr[i] do begin
Parent := tabTool;
Align := alLeft;
GroupIndex := 1;
Width := 55;
Height := 48;
Top := 0;
Left := left;
Caption := '';
Hint := carr[i].h;
Glyph := TBitmap.Create;
Glyph.LoadFromFile(imageAssetsDir + carr[i].c + '_150.bmp');
end;
inc(left,55);
end;
itemArr[0].Down := true;
end;


im weiteren Verlauf des Codes verwende ich dann:

AddControlPalette(PageControl1, 'Stsndard',
recordMyIcons_Std );
AddControlPalette(PageControl1, 'DataBase Controls',
recordMyIcons_db );
AddControlPalette(PageControl1, 'DataBase Source',
recordMyIcons_dbSrc );
AddControlPalette(PageControl1, 'DataBase Navigator',
recordMyIcons_dbNav );


was mir dann die Buttons in der jeweiligen Kategorie erstellt.

Jetzt ddachte ich mir aber, das man ggf. das "AddControlPalettte"
innerhalb einer Schleife verwenden kann, innerhalb dieser dann auf ein
Array zugegriffen wird.
Dann hätte man einen noch dynamischener Programmcode.

Jens

[stefan]

...

Wie schon geschrieben: Ich bin da mehr auf einer altmodischen Schiene,
deshalb überblicke ich das momentan nicht im Detail und bin da
vielleicht auch der falsche Diskussionspartner.

Aber das was du da entworfen hast scheint mir etwas chaotisch zu sein.

Du willst also verschiedene visuelle Komponenten zur Laufzeit erzeugen
und mit Parametern versehen.

Wäre es da nicht besser, von diesen Komponenten neue Komponenten
abzuleiten und diesen jeweils eine Methode zur Parametrierung mitzugeben?
Die Parameter kann man dann aus einer anderen Datenstruktur auslesen,
oder auch aus einer Datei.

Man könnte auch die Komponenten einmal anlegen und dann einfach
umparametrieren und bei denen, die man gerade nicht braucht "visible :=
false" machen.

...

> Jetzt ddachte ich mir aber, das man ggf. das "AddControlPalettte"
> innerhalb einer Schleife verwenden kann, innerhalb dieser dann auf ein
> Array zugegriffen wird.
> Dann hätte man einen noch dynamischener Programmcode.

Man könnte mit Findcomponent einzelne Komponenten finden, also z.B.
"Button1", "Button2" usw.
Da könnte man die laufende Nummer in einer Schleife erzeugen und so
diese Komponenten nacheinander ansprechen.

Also wenn ich 20 Buttons auf dem Form habe und jedem Butten eine Caption
aus einer Liste zuweisen will, oder auch eine Position und/oder Größe.







>
> Jens

[Jens Kallup]

Hallo,

hast Du Lust auf Kooperation ?

Gruß, Jens

[Michael Landenberger]

"Jens Kallup" schrieb am 19.02.2022 um 11:24:22:

> Hallo,
>
> ich habe einen Array:

> type
> recordMyIconsStructure = record
> p: String; // picture
> c: String; // design class
> h: String; // hint
> end;

Das ist kein Array, das ist ein Record. Ein Array wäre es dann, wenn die
Deklaration so aussähe:

type

TMyIconsStructure = array [0..2] of string;

Wenn du für ein solches Array aussagekräftigere Indices haben möchtest,
könntest du folgendes deklarieren:

type

TIconStructureStrings = (picture,class,hint);

TMyIconsStructure = array [TIconStructureStrings] of string;

Ein (vorbelegtes) Array aus solchen Arrays sähe dann so aus:

var

recordMyIcons_Std : array [0..22] of TMyIconsStructure =
(('tmouse','TMouse','Mouse Cursor Selector),
('tmainmenu','TMainMenu','Create / Edit the application main menu'),
... (21 weitere Zuweisungen) ...
);

Gruß

Michael

[Alfred Gemsa]

Am 19.02.2022 um 13:30 schrieb Jens Kallup:

> ich habe ein Programm, das so wenig CODE + DATA + BSS einnimmt.

Was ist denn BSS?

> Der übliche "kindliche" Weg wäre Spagetty Code, bei dem jeder
> (ich sag jetzt mal TButton) einzeln erzeugt, und bearbeitet werden
> muss, wenn Änderungen am Programm vorgenommen werden.

Zeig das keinem Italiener, er erdrosselt dich mit Spaghetti!!! ;-)

> Besser erscheint mir, der etwas kompliziertere Weg, die TComponent
> Objekte während der Laufzeit zu erstellen, anstelle die Ressourcen
> aka .dfm in die .exe mit aufzunehmen.

Wenn du z.B. 22 Buttons oder was auch immer benötigst, kannst du die im
Entwurf auf das Formular pflastern oder zur Laufzeit über den
Konstruktor. Das Ergebnis ist m.M.n. dasselbe.

> Das ginge auch, aber Windows ist dann etwas eigen was Ressourcen
> anbelangt (sind zwar manchmal schneller als die direkte Speicher
> Allokation - nehmen aber auch manchmal doppelt zuviel Arbeitsspeicher
> weg).

Und weshalb du sagst, dass Windows etwas eigen ist, erschließt sich mit
nicht. Und seit wann ist Arbeitspeicherbeklegung ein Problem?

> Also habe ich versucht bestimmte Teile meines Programmes innerhalb
> von Records auszulagern.

Hmm, sehr merkwürdige Formulierung, was meinst du damit?

> Daraus ist dann folgendes geworden:
>
> type
>   recordMyIconsStructure = record
>     p: String;  // picture
>     c: String;  // design class
>     h: String;  // hint
>   end;
> var
>   // --------------------
>   // standard palette :
>   // --------------------

...<snip>

Den Rest lasse ich mal unkommentiert.

Alfred.

[stefan]

wie ist das gemeint?

Ich bin eigentlich ganz gut ausgelastet ;-)

[Jens Kallup]

Hallo Alfred,

Am 19.02.2022 um 22:00 schrieb Alfred Gemsa:
> Am 19.02.2022 um 13:30 schrieb Jens Kallup:
>
>> ich habe ein Programm, das so wenig CODE + DATA + BSS einnimmt.
>
> Was ist denn BSS?

ich nehme mal an, das diese Frage ironisch daher kommt.

BSS ist eigentlich eine Sektion im binary Kode (.exe), die als - tjor,
Platzhalter für Speicher von Variablen dient.
Diese Sektion ist statisch.

Wenn man also statische Daten/Varialben einsetzt, dann wird in der .exe
entsprechend der Größe der Variablen Platz reserviert.
Wenn Du also sehr viele statische Variablen einsetzt, umso größer wird
die .exe

Der Platz f+r den Speicher wird während der Erstellzeit eingerichtet.
Statischen Speicher kann man nicht löschen.

Das Gegenteil von statisch ist dynamische Speicherallokalisation, bei
der während der Laufzeit Speicher angefordert wird, und wieder
freigegeben werden kann (siehe .Create und .Free).

>> Der übliche "kindliche" Weg wäre Spagetty Code, bei dem jeder
>> (ich sag jetzt mal TButton) einzeln erzeugt, und bearbeitet werden
>> muss, wenn Änderungen am Programm vorgenommen werden.
>
> Zeig das keinem Italiener, er erdrosselt dich mit Spaghetti!!! ;-)

ja, genau.
Ihr Anruf wird gezählt, schön das Sie mitgemacht haben.
Ne, Spaß ... :-)

> Und weshalb du sagst, dass Windows etwas eigen ist, erschließt sich mit
> nicht. Und seit wann ist Arbeitspeicherbeklegung ein Problem?

nun.
viele ältere Programme - gerade von SHAREIT oder dergleichen wurden von
Kindern, Jugendlichen oder Krautern entwickelt, die schnelles Geld
machen wollten, dabei aber die Qualität der Programme vergessen haben.
Dann werden mal schnell alle Bitmap Bilder in die Ressourcen Datei
gestöpft (am besten noch 24-bit Bildtiefe), und dann wird sich gewundert
wenn der BlueScreen kommt (okay, in neueren Windosen ist das etwas
anders, dort stürzen die Programme ab, oder der Defender meldet dann
Trojaner-Einfall).

Hobbyprogrammierer, die ihre Arbeit lieben, und Verständnis für den Code
und den Computer selbst haben, produzieren ganz anderen Code.
Der ist dann vielleicht auch Fehlerbehaftet.
Aber qualitativ höherwertig.

Ich bin auch nur Hobbyprogrammierer.
Aber ich will kein Profit aus den Softwares machen, die ich erstelle.
Da sind dann sicherlich auch noch 100 Fehler drinn an 10 Stellen, aber
ich gebe mir Mühe, dies so gut ich kann zu vermeiden.

>> Also habe ich versucht bestimmte Teile meines Programmes innerhalb
>> von Records auszulagern.
>
> Hmm, sehr merkwürdige Formulierung, was meinst du damit?

nu,
wie Du schon bemerkt hast, habe ich ein Programm, das an mehreren
Stellen wiederkehrende Arbeiten und Code verursacht.
Um dies zu vermeiden, und das Warten des Programmcodes so niedrig wie
möglich zu halten, habe ich records aufgebaut, die dann in einer
Schleife abgearbeitet werden.

Jens

[Jens Kallup]

nu,
ich werkle hier an ein Open Software Projekt.

[Michael Landenberger]

"Jens Kallup" schrieb am 20.02.2022 um 14:49:05:

> viele ältere Programme - gerade von SHAREIT oder dergleichen wurden von
> Kindern, Jugendlichen oder Krautern entwickelt, die schnelles Geld
> machen wollten, dabei aber die Qualität der Programme vergessen haben.
> Dann werden mal schnell alle Bitmap Bilder in die Ressourcen Datei
> gestöpft (am besten noch 24-bit Bildtiefe), und dann wird sich gewundert
> wenn der BlueScreen kommt (okay, in neueren Windosen ist das etwas
> anders, dort stürzen die Programme ab, oder der Defender meldet dann
> Trojaner-Einfall).

Wie würdest du denn Bilder in einer .exe unterbringen? Ich meine Bilder, auf
die das Programm angewiesen ist, wie z. B. Symbole oder Hintergründe.

Ich habe mir eine Unit geschrieben, die Routinen zum Zeichnen häufig
benötigter Symbole (z. B. für Dateioperationen wie Öffnen oder Speichern, für
Clipboard-Operationen und andere häufig vorkommende Aktionen) enthalten. Die
Routinen in der Unit ergänze ich dann um entsprechende Routinen, die
programmspezifische Symbole zeichnen. Das Programm ruft diese Routinen
einmalig beim Start auf und legt die erstellten Symbole dann im Speicher ab.
Hinzu kommen Bilder, die ich für grafische Controls brauche, z. B. Diagramme
und Koordinatensysteme. Auch die zeichnen meine Programme zur Laufzeit, wobei
die dabei entstehenden Bildobjekte ebenfalls Speicherplatz belegen. Sowas
beansprucht natürlich wenig Platz in der .exe, aber die fertig gezeichneten
Grafiken belegen Platz im Arbeitsspeicher (manche sogar mehrfach, denn im
Interesse einer flackerfreien Darstellung erstelle bzw. aktualisiere ich die
Grafiken im Hintergrund und kopiere sie erst nach der Fertigstellung in eine
andere Bitmap, die dann in einem Rutsch auf dem Bildschirm gezeichnet wird).
Sowas geht aber eigentlich nur mit grafischen Symbolen. Bilder o. ä. lassen
sich auf diese Weise kaum zur Laufzeit erstellen. Davon abgesehen, habe ich
diese Vorgehensweise nicht gewählt, um die .exes klein zu halten, sondern
damit das Programm beim Erstellen der Grafiken die Bildschirmauflösung
berücksichtigen kann, so dass die Grafiken auf hochauflösenden Displays
ungefähr gleich groß erscheinen wie auf niedriger auflösenden. Mittelfristig
werde ich auf ein Verfahren umsteigen, das extern erstellte Vektorgrafiken im
SVG-Format zeichnen kann. Aber auch die SVGs werde ich voraussichtlich nicht
aus externen Dateien laden, sondern als Ressource ins Programm einbinden.
Wartbar ist das ganze trotzdem, denn als Programmierer muss ich ja bei
Änderungen an den Grafiken nicht an der .exe 'rumschrauben. Stattdessen
editiere ich .svg- und .res-Dateien mit dafür jeweils vorgesehenen speziellen
Editoren, was relativ unkompliziert ist.

> Hobbyprogrammierer, die ihre Arbeit lieben, und Verständnis für den Code
> und den Computer selbst haben, produzieren ganz anderen Code.
> Der ist dann vielleicht auch Fehlerbehaftet.
> Aber qualitativ höherwertig.

Das ist so pauschal nicht richtig. Ein Profi, der seine Sache gut macht,
produziert in der Regel hochwertigeren Code als ein Amateur, es sei denn, er
wird z. B. durch Termindruck oder andere Widrigkeiten daran gehindert, seinen
Job gut zu machen. Der Amateur hat in der Regel keinen Termindruck und kann
schon deshalb mehr Sorgfalt walten lassen. Nutzt aber nicht viel, wenn ihm
dafür die Fähigkeiten und Kenntnisse des Profis fehlen. Davon abgesehen, ist
Fehlerfreiheit nur eine der Anforderungen an ein Programm. Andere
Anforderungen wären z. B. Performance oder intuitive Benutzbarkeit (samt der
Notwendigkeit zum Entwurf einer ausgeklügelten Benutzeroberfläche). Auch auf
diesem Gebiet sind Profis den Amateuren häufig überlegen. Ausnahmen bestätigen
natürlich wie immer die Regel.

> wie Du schon bemerkt hast, habe ich ein Programm, das an mehreren
> Stellen wiederkehrende Arbeiten und Code verursacht.
> Um dies zu vermeiden, und das Warten des Programmcodes so niedrig wie
> möglich zu halten, habe ich records aufgebaut, die dann in einer
> Schleife abgearbeitet werden.

Damit hast du aber nicht das Programm in Records ausgelagert, sondern nur die
Daten, mit denen das Programm arbeiten soll. Das ist aber keine sonderlich
exotische Vorgehensweise.

Gruß

Michael

[Jens Kallup]

Am 22.02.2022 um 15:44 schrieb Michael Landenberger:
> Änderungen an den Grafiken nicht an der .exe 'rumschrauben. Stattdessen
> editiere ich .svg- und .res-Dateien mit dafür jeweils vorgesehenen speziellen
> Editoren, was relativ unkompliziert ist.

Hallo Michael,

schon seit Delphi 7 (ich kenne nur diese Version, mit der ich Delphi
Programme zum ersten mal programmiert habe), gibt es ja die Möglichkeit
Packages und Ressourcen .dll Dateien anzulegen.

Ich verwende zum Beispiel resource strings, die mit den eingebauten
Translator verwendet werden können, wenn man seine Programme für mehr
als nur eine Sprache ausrichtet.

Man schreibt eine (const) Variable, die dann aber jeweils durch die vom
Translator geladene .dll, unterschiedliche Werte einnehmen kann.
Diese Variable ist dann der Platzhalter.

Das macht man sicherlich erst nach der groben Programm-Logik
Programmierung - hat aber dann den Nachteil, das man sämtliche Label
Eigenschaften danach ändern, und durch den Platzhalter ersetzen muss.

Eine andere Alternative ist natürlich die Verwendung von Datenbanken.
Zur Zeit verwende ich in diesen Falle, Dateipfade, die ich in der DB
abspeichere, die als Link-Platzhalter dienen, und dann auf Datenspeicher
adressen zeigen.

Dann kann man die Bilder jederzeit austauschen, falls ein Neues oder
besser erkennbares Bildmotiv vorliegt.
Zum anderen hat das dann den Vorteil, das man die Datenbank nicht mit
Bilddaten zustöpselt, was die Suche und Bearbeitung natürlich
verlangsamt.

In älteren Datenbanksystemen habe ich festgestellt, dass, wenn es zu
einen Crash kommt, die Bilddaten in den Blob-Feldern einfach nicht mehr
existieren, weil die DB-Engine wärend des schreibens der Materialien
nicht mehr dazu kommt, die eigentlichen Daten zu verbinden, und in eine
.dbt Datei temporär zwar speichert, diese aber bei Programmbeginn dann
durch die Initalization Routine löscht, und die Datenbank dann auch noch
unbrauchbar wird, weil die Indices nicht mehr stimmen.

Eine weitere Alternative, die ich verwende ist, das ich mir das Material
per www Komponenten aus einen Server hole, der entweder In-House - also
im LAN, oder aber auch in der Cloud stehen kann.

Das verursacht natürlich weitere Ladezeiten, man hat aber bei guten
Veraussetzungen den Vorteil, zügig und - tjor ich sag mal: tagesaktueles
Material zu haben.

Das ist dann natürlich nicht nur auf reine Bilddaten begrenzt.

Jens