Sfcdelphilite(avec cette librairie vous pouvez créer une application windows avec seulement quelques kilo octets !!!)

Soyez le premier à donner votre avis sur cette source.

Vue 8 120 fois - Téléchargée 1 514 fois

Description

DelphiLite se veut une petite librairie de remplacement de la VCL de delphi et ce afin de créer des softwares "lite", avec un poids qui devrait-être considérablement réduit, outre le challenge, ce projet permet de mieux comprendre lorsqu'on dissèque le fonctionnement des Api's, Experts, le fonctionnement interne de Delphi, toute fois DelphiLite n'a aucune prétention révolutionnaire et le code n'est pas très propre, par ailleurs cette librairie reste pour le moment incomplète mais permet dors et déjà bien des choses ..., Menu, TEdit, TMemo, TLabel, TListbox, il suffit d'un clique depuis la palette et le positionnement des composants se fait comme d'habitude via le Form Designer de Delphi.

Source / Exemple :


all in zip.

Conclusion :


comme promis voici les archives de DelphiLite, je m'excuse pour le retard, surtout que ce projet a pris pas mal de poussières !!!.

veuillez lire attentivement le fichier d'aide s.v.p avant installation.

Codes Sources

A voir également

Ajouter un commentaire Commentaires
Messages postés
304
Date d'inscription
lundi 30 décembre 2002
Statut
Membre
Dernière intervention
10 mars 2012

Salut,
mdr oui effectivement ce projet a pris de la poussière !!!
il faut dire que partant de cette base je me suis dit pourquoi pas se lancer dans un compilateur pascal objet(en cours),
sinon je vais quand même publié l'ancienne mise à jour pour ceux qui sont curieux de voir comment marche le Schmilblick, euhh de tête il est possible de lire directement le flux depuis le ressource de l'exécutable, autrement dit plus besoin de faire des créations dynamiques des objets, de plus la fiche est personnalisée, en peut créé une application DelphiLite depuis l'onglet "nouveau", enfin bref je poste ça dès que possible
et encore pardon pour le retard(collossal).
@+
Messages postés
6
Date d'inscription
mercredi 8 juin 2005
Statut
Membre
Dernière intervention
29 février 2008

Bonjour je revient sur un vieux sujet mais ou est passé la dernière mise a jour du 06/12/2006 avec FormDesigner etc....

Merci pour toute réponse
Messages postés
304
Date d'inscription
lundi 30 décembre 2002
Statut
Membre
Dernière intervention
10 mars 2012

Salut et merci RT15 pour ces précisions,

En effet mettre le Callback de windows dans une classe de type Object ce n'est pas chose aisé, parfois on est obliger de passer par l'assembleur !!!, bon effectivement j'ai choisis une méthode à la Conan le Barbare lol, mais c'était où ça ou 50 lignes de code asm pour ce qui revient presque à la même chose !!!, sauf que l'options lourde en asm va légèrement faire perdre du temps car n'oublions pas que à chaque fois qu'un événement aura lieu windows va passer par cette étape afin de rediriger les messages hors il se passe des milliers de messages à la seconde !!!, mais en passant par la méthode lourde en asm on aura l'avantage de créer une seule instance d'un objet et que ce soit avec ma méthode barbare ou la méthode du GWL_USERDATA celà ne résoud hélas en rien ce petit désagrément !!!

pour le moment ce projet est mis de côté par manque de temps mais entre temps une nouvelle mise à jour vient d'être effectuée.
dont voici les caractéristiques:

- Désormais on pourra se servir du FormDesigner de l'IDE pour la mise en forme de notre projet, donc bien plus pratique que de faire soi-même le calcul des coordonnées de tel ou tel objet !!!.

- Un Expert se charge de definir une nouvelle fiche pour le FormDesigner, la nouvelle fiche aura la classe TLForm.

- Un Expert se charge de la création d'un nouveau projet DelphiLite, pour ce faire il suffit de cliquer
sur la barre outils de l'IDE "Nouveau" puis de choisir l'onglet "DELPHI LITE", puis "Application", il en est de même pour l'ajout d'une nouvelle fiche !!!, c'est tout aussi simple que celà

- Un Expert se charge de la reception des événements "Before Compile" et "After Compile", pratique dès que l'on compile un projet, avant même la compilation du projet, l'IDE va lire quelques informations qui seront inscritent dans un fichier portant le même nom que le projet avec une extension différente, en faite des options du projet seront paramètrable depuis l'IDE de delphi au travers du menu Projet->Options avancées, par exemple si le projet qui va être compilé est un projet DelphiLite, il suffit de cocher la case adéquate, on peut aussi ensivager que dans ces options dès la reception de l'événement "After Compile" de détruire les fichiers dcu's du projet, où bien avant la compilation que l'on puisse integré de nouvelles resources, car il est prevu d'ajouter un gestionnaire de resources via un Expert intégré à l'IDE !!!.

Ensuite la partie initialisation des objets sera créer automatiquement par l'Expert, avec la position de l'objet sur la fiche ainsi que toutes les données disponible depuis l'inspecteur d'objet. (hauteur, longueur, couleur ect..)

ça c'était pour les avantages

*** les inconveniants maintenant ***
- Création des objets en dynamique ce qui n'affecte en rien la vitesse d'execution du code mais alourdit un peut plus le poids de l'executable, mais comme il n'ya pas de gestion de mémoire pour le moment(Stream, MemoryStream), donc impossible de créer un gestionnaire de type TReader/TWriter, le compilateur integre les données de la fiche dans l'executable dans la section RC_DATA hors on en a pas besoin pour le moment !!!

- on voulant à tout prix garder une hierarchie des classes semblable à delphi le poids atteint desormais les 44 kilos ce qui reste déja largemement supérieur aux compresseurs d'exe mais avec néamoins le début de la gestion des menus

Bref j'espère avoir été un peu clair(j'ai un doute lol)
la prochaine version sera dispo quand dès que j'aurais le temps de m'y plonger dans le code !!!

@+
Messages postés
3874
Date d'inscription
mardi 8 mars 2005
Statut
Modérateur
Dernière intervention
7 novembre 2014
14
Salut,

Tout d'abord, bravo pour ce source qui permet des gains en taille impréssionnants.

Je vais juste revenir sur le bricolage des lignes 123 et suivantes de sfcDL_Forms, et proposer une solution (Pas parfaite certe mais, pas nulle non plus je pense).

Déjà, je vais essayer d'expliquer ta solution, pour ceux qui n'auraient pas fait assez d'assembleur pour la saisir.

Windows a besoin d'une CallBack. Autrement dit, de l'adresse d'une fonction à appeler, auquel il donnerat des arguments précis (Des information sur le
message).

Cette fonction serat appelé à chaque clique de bouton nottement.

Côté applicatif, tu dispose d'une instance de bouton par bouton, et dans chacune de ces instances, tu as un pointeur sur la fonction qui doit être executée en
cas de clique sur cette instance de bouton.

Il faut donc que tu fasse le lien entre le message envoyé par windows, et la bonne instance de bouton.

Un autre problème est que ton code est tout en objet, et que tu n'as donc que des méthodes.

Une méthode diffère d'une instance classique (A prototype équivalent) par l'ajout d'un argument implicite tout a fait caché : l'adresse de la structure
(Stockant les attibuts nottement) de l'instance.

En gros :

a.Msg(b);

est compilé

Msg(a, b);

De là, tu sautes sur l'occasion, tu vas ajouter l'adresse de la structure à la volée.

Le code d'ajout de l'adresse, ne peut par définition se trouver que dans la structure de l'objet lui même, du fait qu'il y a une adresse d'instance par
instance.

Ensuite, il suffit de donner l'adresse de cette attribut, contenant le code d'ajout de l'adresse, à windows (Qui l'appelerat sans se poser de question)

Cette attribut appellerat ensuite une méthode prenant les paramètre envoyés par windows, en plus de l'adresse caché.

Le code de l'attribut revient donc à :

1 pop ebx
2 push adresse strucuture
3 push ebx
4 jmp méthode

1 On récupère en fait l'adresse de retour qui serat executé quand la callback aurat fait son taffe.
2 Puis on pousse l'adresse de la structure de l'instance. (Les arguments sont empilé de droite à gauche, l'argument caché etant situé à gauche).
3 On remet en place l'adresse de retour.
4 On se déroute sur la méthode.

Ce code serat executé dans le tas (Dans les structures des différentes instances) à chaque fois que windows enverrat un message.


Cette astuce est manifique, diaboliquement efficace, et vachement bien trouvé.

Néanmoins, elle est pas franchement lisible, et l'execution de code dans le tas est pas super propre.
Sans compter que des protection empèchant l'execution de code dans le tas existent.

Ma proposition de solution, c'est d'utiliser une valeur sur 32 bits laissé au bon vouloir de l'utilisateur dans les données de la fenêtre gérée par windows.
(Je ne parle pas des données supplémentaire, qui seraient chiante à mettre en place car il faudrait recoder les classes BUTTON et companie).
Mais d'utiliser l'attribut GWL_USERDATA.

Il est affectable via SetWindowLong, et récupérable via GetWindowLong.

L'inconvénient est que l'overhead est plus important qu'avec ta méthode. Mais il n'est pas non plus monstrueux.
Messages postés
304
Date d'inscription
lundi 30 décembre 2002
Statut
Membre
Dernière intervention
10 mars 2012

voilà une réponse pleine de sagesse et de bon sens ;), en fait une chose assez curieuse..., Je me suis posé la question suivante:
comment la Team de lazarus project ont-ils fait pour faire un clone de Delphi sans le code Source hum ??!!???, je crois avoir la réponse, en faisant la comparaison entre le TList de Delphi et le TList de Lazarus j'ai vu qu'il y avait de très grande similitudes !!!, c'est pratiquement la même chose avec cependant une variante dans l'algo, mais les noms des varriables ect.. c'est identique, donc ce projet est basé sur le code source ça ne fait aucun doute !!!, pour ma part j'ai fait en sorte que la hiérarchie des classes soit identique, pour que plus tard l'on puisse rendre compatible le projet avec les vcl à environt 80%, donc pour le moment on laisse tomber la compatibilité, j'ai ajouter AfterConstructor pour pouvoir initialisé les composants avant la création de la fenêtre, de plus mon projet respect un peu près la même technique d'initialisation des fenêtre c'est à dire

CreateWnd fait appel à CreateParams et ensuite CreateWindowHandle
celà permet la surcharge de CreateParams pour une eventuelle modification de style de la fenêtre(voir l'aide de Delphi), par ailleurs toutes les fenêtres TButton, TEdit ect.. doivent surcharger cette fonction avant la création de la fenêtre donc très pratique pour une customisation !!!, la mise à jour sera prochainement disponible patience ...

bon on a quand même le droit de reprendre les constantes ? TColor , TAlignement ect.. ? je suppose que voui lol

@+
Afficher les 16 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.