How to create a record at runtime in delphi - delphi

Question

I want to create a record that I call TSprite at runtime.
TSprite is a image and 8 selection points that im using in a level editor I'm building.
type
TSprite = record
Image: TImage;
Selection: TSelection;
SelectionPointTL: TSelectionPoint; // top-left
SelectionPointTM: TSelectionPoint; // top-middle
SelectionPointTR: TSelectionPoint; // top-right
SelectionPointML: TSelectionPoint; // middle-left
SelectionPointMR: TSelectionPoint; // middle-right
SelectionPointBL: TSelectionPoint; // bottom-left
SelectionPointBM: TSelectionPoint; // bottom-middle
SelectionPointBR: TSelectionPoint; // bottom-right
end;
Now i want to store it in a array.
arrSprites: array[0..1000] of TSprite;
And now the creation (the part im struggling with)
This is what I have so far:
arrSprites[i].Image.Position.X := frmMainUI.CurrentMouseX;
arrSprites[i].Image.Position.Y := frmMainUI.CurrentMouseY;
arrSprites[i].Image.Bitmap.LoadFromFile('1.png');
arrSprites[i].Image.Visible := True;
arrSprites[i].Image.WrapMode := TImageWrapMode.iwStretch;
So what this code is supposed to do is to create an image with a selection around it inside a scrollbox i names : fsbcanvas.
Just to be clear I'm asking for the code that creates an instance of TSprite.
Thanks

Answer 1

Records don't need to be created. They are value types and you should think of them the same way that you think about other value types, e.g. Integer. Declare a local variable or a class field that is a value type and that's all you need to do. Similarly, a constant sized array is a value type.
So, the answer to your question, is that arrSprites does not need any special allocation. What does need allocation and initialization are the contents of your record. So if any of the fields in your record are class instances, then they need instantiating. So, consider this record:
type
TMyRecord = record
i: Integer;
obj: TObject;
end;
You can declare one like this:
var
rec: TMyRecord;
and the record itself is allocated. But you need to initialise its members:
rec.i := 42; // or some other initial value
rec.obj := TObject.Create; // instantiate the object
And when you are done with the record, you'd need to destroy the object.
rec.obj.Free;
This is easy to get wrong and so in general your records should contain only value types, or managed types (e.g. strings, interfaces, dynamic arrays etc.)
Now, I can't tell what your code is all about from what's in the question, but I suspect that your record has some class instances. Which immediately makes record a dubious choice of data structure. I'd hold these in a class which has constructor and destructor that manage the lifetime of the objects within.
And I'd also avoid using a constant length array. They are very inflexible. Instead I suggest you hold your sprite objects in a generic list, TList<T>. Or, perhaps even better, TObjectList<T> and that way you can let the list look after the life time of its members.

Answer 2

I was typing an answer as David Heffernan just beat me to it.
Still while at it i would like to add;
Realize that in your first code example you are using a record (TSprite) to hold an object (TImage). TImage is a visual component actually, but ultimately it descends from TObject.
A record is like most variables (such as Integer) in that it does not have to be instantiated and can be copied at will.
An object however is a pointer to an instance, and must be created/destroyed by following these steps
rec.Image := TImage.Create(nil);
// do other things..
rec.Image.Free;
And thus may result in memory leaks or Access Violation errors if not done properly. (for example while copying a TSprite..)
There is a lot of things that can go wrong in this setup, so therefore i say;
Using objects in records can get tricky. Consider keeping objects in objects:
A simple solution (if you indeed want to keep an instance or pointer reference of TImage inside a TSprite) would be to make TSprite also an object. It could keep track of of creating/destroying automatically by using its constructor and destructor:
TSpriteObject = class(TObject)
public
Image : TImage;
constructor Create;
destructor Destroy; override;
end;
and its implemenation:
constructor TSpriteObject.Create;
begin
Image := TImage.Create(nil);
// ^ TImage is a component and expects an Owner component that would also
// destroy it, so we use a nil value to disable that behavior.
end;
destructor TSpriteObject.Destroy;
begin
Image.Free;
end;
You can then have a TObjectList keep track of many instances of TSprite, and it'll destroy any TSprite (which destroys its TImage) when the list is cleared or destroyed.
(this is my first ever stackoverflow post attempt, please bear with me while i find out what i'm doing wrong here)

Answer 3

As David Heffernan said a class may be a better data structure for this situation. But if you decided to use records instead, you can declare methods in your record to refactor the instantiating and destroying parts:
type
TSprite = record
Image: TImage;
Selection: TSelection;
SelectionPointTL: TSelectionPoint; // top-left
SelectionPointTM: TSelectionPoint; // top-middle
SelectionPointTR: TSelectionPoint; // top-right
SelectionPointML: TSelectionPoint; // middle-left
SelectionPointMR: TSelectionPoint; // middle-right
SelectionPointBL: TSelectionPoint; // bottom-left
SelectionPointBM: TSelectionPoint; // bottom-middle
SelectionPointBR: TSelectionPoint; // bottom-right
procedure Create(aImageOwner: TComponent);
procedure Destroy;
end;
{ TSprite }
procedure TSprite.Create(aImageOwner: TComponent);
begin
Image := TImage.Create(aImageOwner);
end;
procedure TSprite.Destroy;
begin
Image.Free;
end;
// ...
var
Rec: TSprite;
begin
Rec.Create(Form1);
// ...
Rec.Destroy;
end;
Notice that it's not a real class instantiation so Rec := TSprite.Create(Form1); whould be meaningless, unless you want to define and implement TSprite.Create in that way.