[Delphi] design-time form designer zelf bouwen

[Tomatoman]

In de IDE zijn tenminste twee form designers ingebouwd: die voor een standaard form en die voor data modules. Via de open tools API kun je zelf je eigen designers bouwen (die de IDesigner interface implementeren), maar ik kan nergens vinden hoe je je zelfgebouwde designer oproept in de IDE. Heeft iemand ervaring met zelfgemaakte form designers?

[LordLarry]

Ik ken geen voorbeelden van waar dat gedaan zou moeten zijn, behalve Delphi zelf natuurlijk. Ik heb niet goed gezocht, maar ik verwacht dat Delphi de source daarvan niet meeleverd. Ik ben er ook niet zo zeker van dat je dat zelf zou kunnen doen. Waar zou je je eigengemaakte form designer aanmelden bij Delphi?

Je kan wel heel veel zaken via de OpenTools API regelen, zoals je zelf ook al had gevonden. Waaronder je eigen forms met properties. Bepalen welke componenten er op een form gemikt mogen worden. Acties ondernemen op het plaatsen van componenten. Items toevoegen bij File -> New en dan specifieke code uitvoeren. En nog veel meer. Waarschijnlijk ken je de url al, maar het is een goed beginpunt voor veel informatie over de OTA: http://www.gexperts.org/opentools/

Wat is je doel? Misschien kan het ook op een andere manier opgelost worden.

/edit
De functie RegisterCustomModule komt, denk ik, het dichtste in de buurt van wat jij wilt.

[ Voor 6% gewijzigd door LordLarry op 22-11-2003 17:21 ]

[Tomatoman]

Mijn doel is een form designer bouwen voor een wizard. Voorbeeldje: hier. In de wizard is niet het hele vensteroppervlak beschikbaar, want een deel wordt door Windows getekend. Nou zou ik er gewoon een TForm met een vast formaat voor kunnen gebruiken (waarvoor de IDE uiteraard al een standaard designer heeft), maar dan heb je geen idee hoe de wizardpagina's er runtime uit gaat zien. Ik wil daarom mijn eigen designer bouwen, zodat je al in design time ziet hoe het eindresultaat wordt. Hoe de wizardpagina's worden opgeslagen - iedere pagina als een aparte unit of alles in een component - maakt me niet zoveel uit, zolang ik maar design-time support heb.

De OpenTools API publiceert wel hoe de IDesigner interface eruit ziet, maar niet hoe die voor TForm, TDataModule en TFrame geïmplementeerd is. Daar kom ik helaas niet verder mee. Ook die website die je noemt had ik al doorgespit, maar daar vond ik niets bruikbaars.

[Verwijderd]

Kijk 's naar DreamDesigner, die kan je wel integreren in je component denk ik. MOet je er ff een property editor om heen wrappen.
http://www.dream-com.com/designer.html

[ Voor 17% gewijzigd door Verwijderd op 22-11-2003 20:22 ]

[alienfruit]

Mail Erik Berry zou ik zeggen...

[_Thanatos_]

Ik heb ook es zo'n zelfde idee gehad, maar ik los het nu maar op met frames. Bij de Execute() methode van m'n wizard geef ik een TCustomFrameClass mee en het eigenlijke wizard dialoog maakt dan dat frame aan. Dan vereis ik alleen dat mijn zelfgemaakte TWizardPageSet (een soort TNotebook) op het frame staat.

Zie ook [rml][ delphi] Iets heel moeilijks met property editors[/rml]

[Tomatoman]

_Thanatos_ schreef op 23 november 2003 @ 00:06:
Ik heb ook es zo'n zelfde idee gehad, maar ik los het nu maar op met frames. Bij de Execute() methode van m'n wizard geef ik een TCustomFrameClass mee en het eigenlijke wizard dialoog maakt dan dat frame aan. Dan vereis ik alleen dat mijn zelfgemaakte TWizardPageSet (een soort TNotebook) op het frame staat.

Zie ook [rml][ delphi] Iets heel moeilijks met property editors[/rml]

Dat is zoals ik het nu ook doe, maar ik ben er niet echt tevreden mee. Ik ben er inmiddels achter dat je dat misschien met TCustomModule (unit DesignEditors) kunt doen, maar er is nergens een voorbeeld te vinden.

[alienfruit]

In principe zou je een OT (of property editor) kunnen maken waarbij je een eigen dialoog gebruikt, zodoende ook je eigen custom designer maakt. Als je wil kan ik het wel uitzoeken

[_Thanatos_]

Ik denk dat eigenlijk het grootste probleem is dat je de IDE zover krijgt dat ie een nieuwe unit met bijbehorende DFM aanmaakt. Ik heb werkelijk waar in mijn 7 jaar dat ik met delphi werk, nog nooit gezien hoe je de designer ook maar in de buurt van zoiets kan krijgen (maar zoooooveel heb ik ook nog niet met designtime dingen gerommeld...)

Misschien kun je dit probleem overkomen door het frame (of wat je ook wilt gebruiken) een child van het owner form te laten worden en de code ook in de unit van het owner form te zetten. Maar dat laatste kan dus weleens erg lastig gaan worden. En dan rest nog steeds het probleem dat je de designer van het frame wilt oproepen...

Either way, ik denk dat het meer loont om naar een eenvoudiger alternatief te kijken, dan een misschien onnodig aantal uren gaat stoppen in iets als dit. Maarja, zelf weten natuurlijk

[LordLarry]

Verwijderd schreef op 22 november 2003 @ 20:21:
Kijk 's naar DreamDesigner, die kan je wel integreren in je component denk ik. MOet je er ff een property editor om heen wrappen.
http://www.dream-com.com/designer.html

Dat is runtime. Wij praten hier over designtime. Je zou dit component wel in je designtime code kunnen gooien, maar ik neem aan dat tomatoman gewoon de Delphi IDE dingen wil gebruiken en niet twee object inspectors en twee component pallettes.

[Varienaja]

Op ons bedrijf hebben we een zelfgebouwde tool waarmee we delphi forms kunnen designen. Het is precies Delphi zelf, je kunt alleen wat minder verschillende componentjes droppen.

Wij zijn geen open-source bedrijf, maar als je het heel graag wilt kan ik even de directie vragen. Dan vraag ik of ik een voorbeeldje mag posten.

[LordLarry]

Maar is dat runtime of ook echt designtime in de Delphi IDE?

[Varienaja]

LordLarry schreef op 23 november 2003 @ 18:00:
Maar is dat runtime of ook echt designtime in de Delphi IDE?

Runtime natuurlijk.

Wil je dan design-time je een design maken in je designer-component? Is dat nou echt nodig? (Ik kan me namelijk niet voorstellen dat tekstverwerker-programmeurs design time in hun tekstverwerker willen typen. ) Nouja.. eigenlijk willen ze dat wel: dan hoef je niet steeds te compileren :-D Maar ga met dit soort wensen niet richting een ge-interpreteerde taal?

[LordLarry]

How can I add published properties to a TForm descendent?
- Add published properties to a regular TForm
- Add the form to the Object Repository (Project menu)
- Add the form to an existing design time package (such as Borland User Components) or to a new design-time package.
- Add DsgnIntf/DesignIntf to the implementation uses clause of some unit in the package, and add a register procedure as follows:

Delphi:

procedure Register;
begin
  RegisterCustomModule(TMyForm, TCustomModule);
end;

- Finally, inherit from your form in the repository inside a project and the new published properties will show up.

Met deze methode is het mogelijk om een afgeleide te maken van TDataModule of TForm en zelf je eigen DesignTime gedrag, properties en events toe te voegen.

Wellicht dat je idd ook van TCustomModule zou kunnen afleiden, maar dan moet je wel eerst zien te achterhalen welke functies wat doen en welke je kan overriden. Het is namelijk ongedocumenteerd gebied

[LordLarry]

Varienaja schreef op 23 november 2003 @ 18:22:
Runtime natuurlijk.

Wil je dan design-time je een design maken in je designer-component? Is dat nou echt nodig? (Ik kan me namelijk niet voorstellen dat tekstverwerker-programmeurs design time in hun tekstverwerker willen typen. ) Nouja.. eigenlijk willen ze dat wel: dan hoef je niet steeds te compileren :-D Maar ga met dit soort wensen niet richting een ge-interpreteerde taal?

Simpel gezegt wil Tomatoman designtime zijn wizard opmaken alsof je met een gewoon form bezig bent, maar kennelijk kan dat niet als TComponent, maar moet het als TForm.

[Tomatoman]

Volgens mij zijn we er inmiddels achter wat ik wil , design-time ondersteuning voor mijn component. Voor de duidelijkheid: mijn component heet toevallig TWizard, maar dat heeft niets te maken met design-time wizards in Delphi (de IOTAWizard interface en dergelijke).

Voor wie een werkend voorbeeld van de wizard wil zien of de source code wil bekijken: zie hier (316 kB).

De code zit zodanig in elkaar dat de wizard bestaat uit een window dat met een rijtje API calls door Windows wordt gemaakt. Voor iedere wizardpagina zet ik daar een TForm op en op dat form kan weer een frame worden gezet. Op dit moment is de TForm verborgen in de code en kun via property's instellen welke frame class moet worden gebruikt voor een wizardpagina. De pagina wordt dan runtime gecreëerd, uitgaande van de frame class die je via een property hebt ingesteld.

Het voordeel daarvan is dat je in design time een frame kunt bouwen zoals je van Delphi gewend bent. Ik weet alleen niet hoe je in design time een frame class aan een property moet toekennen en al helemaal niet hoe je dan ook nog in design time het eindresultaat in de werkende wizard kunt laten zien.

Op dit moment doe ik het (runtime) als volgt:

Delphi:

{ de volgende code uitvoeren VOORDAT de wizard wordt getoond }
var
  Page: TDialogPage;  // dit is een wizardpagina
begin
  { 1 wizardpagina toevoegen. Let op: Het frame op de wizardpagina
    wordt pas gecreeerd op het moment dat de wizard wordt getoond. }
  with Wizard do
  begin
    Page := Pages.Add;
    Page.PageType := ptWelcome;
    Page.Title := 'Dit is de welkomstpagina';
    Page.FrameClass := TMijnFrame;
  end;
end;

TMijnFrame op regel 13 is een frame dat je op de vertrouwde manier kunt maken in de IDE met File, New, Frame.

• TWizard is een descendant van TComponent.
• TDialogPage (een wizard-pagina) is een TCollectionItem. Alle dialogpages tezamen (een TCollection) zijn een property van TWizard.
• Een TDialogPage heeft onder andere een property FrameClass van het type TCustomFrameClass. Hier zou je in design-time een frame moeten selecteren. Helaas geeft Delphi deze (published) property niet eens weer! Blijkbaar weet de IDE zich hier geen raad mee.

Hier loop ik vast, ik heb geen idee hoe ik een lijstje met beschikbare frames zou moeten verkrijgen in een design-time editor en al helemaal niet hoe ik dat frame dan in de IDE zou moeten weergeven in een werkende sample wizard. Eigenlijk wil ik dat die werkende sample wizard een mooi edit window is, zoiets als dit gefotoshopte plaatje:


Opmerking: eigenlijk zijn die frames niet nodig, want dat frame komt op een TForm te staan. Maar ja, zonder frame verplaatst het probleem zich naar het form.

Sorry voor dit lange verhaal, maar ik ben bang dat het volledig abracadabra wordt als ik het inkort.

[ Voor 1% gewijzigd door Tomatoman op 24-11-2003 02:51 . Reden: ab[i]r[/i]acadabra ]

[LordLarry]

Voor een published TClass property moet je idd zelf wat werk doen. De oplossing is om deze als string te behandelen en intern FindClass te gebruiken om van een string naar een TClass. Om FindClass te kunnen gebruiken moeten de classes wel geregistreerd zijn met RegisterClass. Het wegschrijven zou je kunnen doen in de DefineProperties method.

Ik denk dat je via de OTA wel een lijst van frames kan achterhalen door alle files van het project te doorlopen en te kijken of het een frame is. Als je deze lijst in een combobox wilt tonen in de object inspector zal je een eigen property editor moeten maken. Zie de Source\ToolsAPI dir voor standaard VCL property editor voorbeelden.