MODIFIEZ DES COMPOSANTS EXISTANTS SANS MODIFIER VOS FICHES EXISTANTES (+ DIDACTICIEL)

Commentaire de JulioDelphi le 15/01/2005 18:28:04 administrateur CS

:)
Magnifique ! les expliquations sont trèès détaillées et très bonnes ! J'ai appris des choses "de base" grâce a cette lecture (10 minutes suffisent).
Ca me donne envie de faire de meme avec la création complete de composants :)
Bravo encore DelphiProg !
10/10

ps : ça reponds encore mieux a la question du forum

Commentaire de Inekman le 16/01/2005 13:51:44

excellente cette astuce. Chapeau bas Delphiprog.

Commentaire de MAURICIO le 17/01/2005 14:52:03

En tout cas, c très bien expliqué!
Même moi, qui ne fais pas de compos, g presque tout pigé. J' ai qques trucs que je ne comprends pas:
- Ne serait-il pas plus simple de chercher les dfm qui utilisent le compo pour remplacer la déclaration de la class par une autre? TStaticText vers TStaticTextEx?
Ça a l' avantage de pouvoir utiliser les 2 class et le systeme ajoutera les propriétés/events automatiquement (enfin je crois) manquantes à TStaticTextEx à l' ouverture de la fiche.
- Dans ta conclusion, tu dis ... non, pas la ligne "Vive la POO" l' autre: "... quand ils doivent installer de nouveaux composants juste pour tester une application écrite par d' autres". Si je me rapelle, il y avait une source qui utilisait un compo genre TSpinEdit. J' avais laissé un message à celui qui a posté la source pour qu' il remplace le compo utilisé par un TSpinEdit pour eviter d' aller chercher le source du compo sur le net et de devoir l' installer. Maintenant que je viens donc de lire le fichier pdf, il me semble que ta méthode ne nous permettra pas de se passer de l' unit du compo original étant donné que, dans les Uses, nous devons déclarer  l' unité du compo original qui est, dans ton exemple StdCtrls. Je dis ça parce que seulement apres tu fais:
type
  TStaticText = class(StaticTextEx.TStaticText);
Donc je pense, vu aussi qu' à l' ouverture de la form, les nouvelles propriétes n' apparaissent pas (se sont celles de StaticText de l' unité StdCtrls), que l' on a besoin de l' unité du compo original. Faudrait essayer avec un autre compo qui ne serait pas dans StdCtrls pour verifier ça ...

Commentaire de jmp77 le 17/01/2005 17:39:25

Hello DelphiProg,

Super Sourçe mais vu l'auteur je m'en serais douter.

Deja avec ta réponse sur le forum c'était clair mais alors maintenant c'est super fluide.
Honnetement plutot que de creer ces compos puis obligé tout le monde a les installé pour tester ta source au moins avec cette méthode c'est bien plus pratique. Biensure il ne faut pas en abuser et être prudent.

Enfin Merci à toi DelphiProg qui arrive toujours a nous apprendre des choses super interessantes.

Note finale sans appel 10/10.

Bonne prog,
JMP77.

Commentaire de Delphiprog le 17/01/2005 20:05:10 administrateur CS

Mauricio : les propriétés/évènements n'apparaissent pas et ne peuvent pas apparaître dans l'inspecteur d'objet pour une simple raison : le composant n'est pas enregistré dans Delphi.
Le fait de déclarer en section publiée est sans influence au niveau de l'inspecteur d'objets dans ce cas.

En revanche, on peut y trouver un avantage dans le cas où l'on veut que ces propriétés soient enregistrées automatiquement quand on utilise des fonctions comme WriteComponentRes, WriteComponentResFile qui sauvegardent dans le stream toutes les propriétés publiées. C'est ce que fait Delphi avec les fichiers DFM des fiches.

En résumé, ajouter des propriétés publiées à un composant existant doit avoir un objectif bien précis et justifié.
Cette conclusion rejoint donc tout à fait les propos de Delphimaniac.

Je suis heureux que même les experts sur ce forum aient trouvé un intérêt à ce tuto.

Commentaire de MAURICIO le 18/01/2005 18:53:00

Ok, cette fois g compris et c' est gràce à JulioDelphi qui a bien voulu perdre son temps à m' expliquer :
on a besoin du source du compo mais on a pas besoin de l' installer. Merci Merci ...

Commentaire de MAURICIO le 19/01/2005 10:10:28

oui exact!

Commentaire de MAURICIO le 16/04/2008 17:30:44

Salut DelphiProg,
après avoir fait quelques compos c' est beaucoup plus simple de comprendre ton tuto :)

Comme j' en ai eu besoin et que je fais légèrement differemment (en plus simple), voilà comment j' ai procédé :

J' ai un compo appelé TcyDBGrid dans mon unité cyDBGrid qui permet entre autre la gestion du MouseWheel et permet de cacher les ScrollBars gràce aux sources déposées sur CS:

type
  TcyDBGrid = class(dbgrids.TDBGrid)
    private
etc ...

à la fin de la déclaration du compo, je déclare ceci:
  TDBGrid = class(tcyDBGrid);
// Déclarer une nouvelle class TDBGrid pour que les compos dbgrid.TDBGrid déjà utilisés dans vos appli aient les mêmes options!

Comme tu peux le voir, mon compo n' a pas besoin de s' appeler TDBGrid.

Ensuite, dans mes applis cette fois, il ne me reste plus qu' à mettre dans les Uses le nom de l' unité de mon compo sans rien faire d' autre:
Uses classes, windows, dbgrids, etc ..., cyDBGrid;
Le compilateur semble aller chercher la Class TDBGrid dans mon unité cyDBGrid car c' est la dernière à être déclarée dans les Uses.

Pas besoin donc de déclarer une class TDBGrid héritant de cyDBGRid.TcyDBGrid! dans toutes les forms de mes applis.

Le mouseWheel est très bien géré mais par contre j' ai une erreur lorsque j' utilise l' option pour cacher les ScrollBars: l' erreur survient en fermant mon appli seulement: "control DBGrid2 has no parent window"

Voici mon unité :
unit cyDBGrid;

interface

uses Classes, Windows, Grids, DBGrids, Messages;

type
  TMouseWheelMode = (mwDoNothing, mwNavigate, mwSelect);

  TcyDBGrid = class(dbgrids.TDBGrid)
    private
      FOnSelectCell: TSelectCellEvent;
      FSauvDBGridWndProc: TWndMethod;
      FHorizontalScrollBar: Boolean;
      FVerticalScrollBar: Boolean;
      FMouseWheelMode: TMouseWheelMode;
      procedure SetHorizontalScrollBar(const Value: Boolean);
      procedure SetVerticalScrollBar(const Value: Boolean);   // Save original WindowProc ...
    protected
      procedure Loaded; override;
      function SelectCell(ACol, ARow: Longint): Boolean; override;
      procedure cyDBGridWndProc(var Msg: TMessage);
      procedure MouseWheelDown(Sender: TObject; Shift: TShiftState;
        MousePos: TPoint; var Handled: Boolean);
      procedure MouseWheelUp(Sender: TObject; Shift: TShiftState;
        MousePos: TPoint; var Handled: Boolean);
    public
      constructor Create(AOwner: TComponent); override;
      property FixedCols;
      function CellRectX(ACol, ARow: Longint): TRect;
    published
      property Col;              // Current column
      property LeftCol;          // First displayed column
      property Row;              // Current row
      property VisibleColCount;  // Visible normal columns (Not Fixed Columns)
      property VisibleRowCount;  // Visible normal rows (Not Fixed Rows)
      // property TopRow;  Not working, return always 1 ...
      // property Selection; Not working, return always Col e Row ...

      property MouseWheelMode: TMouseWheelMode read FMouseWheelMode write FMouseWheelMode default mwDoNothing;
      property HorizontalScrollBar: Boolean read FHorizontalScrollBar write SetHorizontalScrollBar default true;
      property VerticalScrollBar: Boolean read FVerticalScrollBar write SetVerticalScrollBar default true;
      property OnSelectCell: TSelectCellEvent read FOnSelectCell write FOnSelectCell;
    end;

  TDBGrid = class(tcyDBGrid); // Déclarer une nouvelle class TDBGrid pour que les compos
                              // dbgrid.TDBGrid déjà utilisés dans vos appli aient les mêmes options!

procedure Register;

implementation

{ TcyDBGrid}
constructor TcyDBGrid.Create(AOwner: TComponent);
begin
  inherited Create(AOwner);
  FSauvDBGridWndProc := WindowProc;
  FMouseWheelMode := mwDoNothing;
  FHorizontalScrollBar := true;
  FVerticalScrollBar := true;

  // Mouse wheel :
  With TDrawGrid(self) do
  begin
    OnMouseWheelDown := MouseWheelDown;
    OnMouseWheelUp := MouseWheelUp;
  end;
end;

procedure TcyDBGrid.Loaded;
begin
  Inherited;
end;

function TcyDBGrid.SelectCell(ACol, ARow: Longint): Boolean;
begin
  Result := True;
  if Assigned(FOnSelectCell) then FOnSelectCell(Self, ACol, ARow, Result);
end;

function TcyDBGrid.CellRectX(ACol, ARow: Longint): TRect;
begin
  RESULT := CellRect(ACol, ARow);
end;

procedure TcyDBGrid.cyDBGridWndProc(var Msg: TMessage);
begin
  // We have to call this all the time (not just when scrollBar properties handlers changes) :
  ShowScrollBar(Handle, SB_HORZ, FHorizontalScrollBar);
  ShowScrollBar(Handle, SB_VERT, FVerticalScrollBar);

  if Assigned(FSauvDBGridWndProc)
  then FSauvDBGridWndProc(Msg);
end;

procedure TcyDBGrid.SetHorizontalScrollBar(const Value: Boolean);
begin
  FHorizontalScrollBar := Value;

  if not (FHorizontalScrollBar and FVerticalScrollBar)
  then WindowProc := cyDBGridWndProc
  else WindowProc := FSauvDBGridWndProc;

  Invalidate;
end;

procedure TcyDBGrid.SetVerticalScrollBar(const Value: Boolean);
begin
  FVerticalScrollBar := Value;

  if not (FHorizontalScrollBar and FVerticalScrollBar)
  then WindowProc := cyDBGridWndProc
  else WindowProc := FSauvDBGridWndProc;

  Invalidate;
end;

procedure TcyDBGrid.MouseWheelDown(Sender: TObject; Shift: TShiftState;
  MousePos: TPoint; var Handled: Boolean);
begin
  Handled := true;

  case FMouseWheelMode of
    mwNavigate:
      begin
        if DataSource.DataSet.Active
        then
          if not DataSource.DataSet.Eof
          then DataSource.DataSet.Next;
      end;

    mwSelect:
      begin

      end;
  end;
end;

procedure TcyDBGrid.MouseWheelUp(Sender: TObject; Shift: TShiftState;
  MousePos: TPoint; var Handled: Boolean);
begin
  Handled := true;

  case FMouseWheelMode of
    mwNavigate:
      begin
        if DataSource.DataSet.Active
        then
          if not DataSource.DataSet.Bof
          then DataSource.DataSet.Prior;
      end;

    mwSelect:
      begin

      end;
  end;
end;

procedure Register;
begin
  RegisterComponents('Cindy DB', [TcyDBGrid]);
end;

end.

A+

Commentaire de cirec le 17/04/2008 15:21:04 administrateur CS

En fait c'est simple
le windowproc est surchargé depuis la classe TComponent par toutes les classes intermédiaires jusqu'au composant final.
Et dans leurs surcharge respective si un message n'est pas à traiter car non utile, il est renvoyé au DefWindowProc :
"DefWindowProc(Handle, Message.Msg, Message.wParam, Message.lParam);"

Donc si toi en cours de route tu le modifie et tu ne le restitue pas les classes parentes ne pourront plus travailler correctement.

Qu'on me corrige si je dis une connerie ^^