Newsgroup: it.comp.lang.delphi
Titolo: [OOP] Problemi migrazione....

Ciao a tutt sperando che mi rispondiate vi pongo questo quesito:
Allora io ho scritto una unit (e poi una DLL) e tutto funziona.
Ora che so come asegnare un metodo di una classe a un puntatore volevo
passare al OOP... riscivo  la unit (per la DLL ci pensero in seguito)
e mi ritrovo che non funziona +...
mi da errore quando vado a richiamare un API di Window:
WindowCreateEx
che mi restituisce 0 invece di quello che mi deve restituire...
ora visto che il codice e essatamente lo stesso perche mi fa storie?
Forse non gli piacciono le classi?
la "classe" della finestra da creare è stata registrata
corettamente...
visto che la classe e un bel po' lungetta vorei evitare di postare
tutto il codice se qualcuno ha qualche idea vi prego di farvi sotto...
se proprio devo poi sendero il codice
Il Razziatore,
The Only Good Windows in an uninstalled Windows
-----------------------------------------------
E-MAILs : IlRazziat...@NOSPAMnetscape.net
WEB     : 
http://www.razziatore.dns2go.com/
ICQ     : 67552596

 Forse non gli piacciono le classi?
Se questo fosse il caso, D non avrebbe mai funzionato, da TWinControl in
giu' (in realta' anche TControl ha la sua brava WndProc).
Cio' che personalmente non capisco e' se il tuo scopo e' avere un
oggetto che gestisca la finestra o una finestra che gestisca l'oggetto.
Se vuoi solo gestire una WndProc e' sufficiente l'esempio che vedi
sotto; se invece vuoi crearti una finestra con caratteristiche
Win-specifiche credo che dovresti o derivare da TWinControl e fare
l'override di CreateParams o dare un occhio ai sorgenti di quella classe
(unit controls.pas).
Saluti
Paolo Arosio
const
  WM_FRST_CUST_MSG = WM_USER + 1;
  WM_SCND_CUST_MSG = WM_USER + 2;
type
  TMySkelWinObj = class(TObject)
  private
    FWndHandle: THandle;
    FMsgs: Cardinal;
  protected
    procedure WndProc(var Msg: TMessage); virtual;
  public
    constructor Create; virtual;
    destructor Destroy; override;
    property Handle: THandle read FWndHandle;
  end;
implementation
{ TMySkelWinObj }
constructor TMySkelWinObj.Create;
begin
  inherited Create;
  FWndHandle := AllocateHWnd(WndProc);
end;
destructor TMySkelWinObj.Destroy;
begin
  if FWndHandle <> 0 then
    DeallocateHWnd(FWndHandle);
  inherited;
end;
procedure TMySkelWinObj.WndProc(var Msg: TMessage);
begin
  try
    inc(FMsgs);
    case Msg.Msg of
      WM_NULL: ;
      WM_FRST_CUST_MSG: Beep;
      WM_SCND_CUST_MSG: Msg.Result := FMsgs;
      else Msg.Result := DefWindowProc(FWndHandle,
        Msg.Msg, Msg.WParam, Msg.LParam);
    end;
  except
    Application.HandleException(Self);
        // Application suppongo esista
        // se non e' vero, gestire l'eccezione altrimenti
  end;
end;

oggetto che gestisca la finestra o una finestra che gestisca l'oggetto.
Io volgio fare un oggetto che crei e gestisca una finetra e che lancia
delle mie procedure quando sucede un X evento (per esempio quando
viene premuto un tasto).
Ripero ho gia fatto sia un Unit che una DLL ma non erano OOP e si
faceno molti macelli....
Ti spedisco la classe:
  Type
    TProcedure    = Procedure;
    TShiftState   = Set of (ssShift, ssAlt, ssCtrl, ssLeft, ssRight,
ssMiddle, ssDouble);
    TOnKeyUp      = Procedure(Key : Word; Shift: TShiftState);
    TOnKeyDown    = Procedure(Key : Word; Shift: TShiftState);
    TOnReSize     = Procedure(NewWidth, NewHeight: GLsizei);
    TOnClose      = Procedure(Var Close : Boolean);
    TOnActive     = Procedure(Flag : Boolean);
    TOnInitGL     = Procedure;
    TOnDraw       = Procedure(FPS : Integer; Lag : Integer);
    TGLWindowData = Record
      Handle      : Record
        Istance   : HINST;
        Window    : HWND;
        RC        : HGLRC;
        DC        : HDC;
        End;
      Caption     : PChar;
      Cursor      : hCursor;
      Icon        : hIcon;
      FullScreen  : Boolean;
      Bits        : GLSizei;
      Height      : GLSizei;
      Width       : GLSizei;
      dwExStyle   : DWORD;
      dwStyle     : DWORD;
      Active      : Boolean;
      End;
    TGLWindow       = Class
      Public// Private
        Data        : TGLWindowData;
        ActionSet   : Record
          OnKeyUp   : TOnKeyUp;
          OnKeyDown : TOnKeyDown;
          OnReSize  : TOnReSize;
          OnClose   : TOnClose;
          OnActive  : TOnActive;
          OnInitGL  : TOnInitGL;
          OnDraw    : TOnDraw;
          End;
        Function WndProc (hWnd : HWND; message : UINT; wParam  :
WPARAM; lParam  : LPARAM ): LRESULT; StdCall;
      Public
        Done        : Boolean;
        Constructor Create;
        Function    Make : Boolean;
        Procedure   Run;
        Function    Kill : Boolean;
      Private
        Function  IsActive               : Boolean;
        Procedure SetOnKeyUp  (NewAction : TOnKeyUp);
        Function  GetOnKeyUp             : TOnKeyUp;
        Procedure KeyUp(Key : Word);
        Procedure SetOnKeyDown(NewAction : TOnKeyDown);
        Function  GetOnKeyDown           : TOnKeyDown;
        Procedure KeyDown(Key : Word);
        Procedure SetOnReSize (NewAction : TOnReSize);
        Function  GetOnReSize            : TOnReSize;
        Procedure ReSize(NewWidth, NewHeight: GLsizei);
        Procedure SetOnClose  (NewAction : TOnClose);
        Function  GetOnClose             : TOnClose;
        Procedure Close;
        Procedure SetOnActive (NewAction : TOnActive);
        Function  GetOnActive            : TOnActive;
        Procedure Active(Flag : Boolean);
        Procedure SetOnInitGL (NewAction : TOnInitGL);
        Function  GetOnInitGL            : TOnInitGL;
        Procedure InitGL;
        Procedure SetOnDraw   (NewAction : TOnDraw);
        Function  GetOnDraw              : TOnDraw;
        Procedure Draw;
      Public
        // Property FullScreen
        Property ActiveFlag : Boolean    Read IsActive;
        Property OnKeyUp    : TOnKeyUp   Read GetOnKeyUp   Write
SetOnKeyUp;
        Property OnKeyDown  : TOnKeyDown Read GetOnKeyDown Write
SetOnKeyDown;
        Property OnReSize   : TOnReSize  Read GetOnReSize  Write
SetOnReSize;
        Property OnClose    : TOnClose   Read GetOnClose   Write
SetOnClose;
        Property OnActive   : TOnActive  Read GetOnActive  Write
SetOnActive;
        Property OnInitGL   : TOnInitGL  Read GetOnInitGL  Write
SetOnInitGL;
        Property OnDraw     : TOnDraw    Read GetOnDraw    Write
SetOnDraw;
      End;
il problema lo da sulla make:
  Function TGLWindow.Make : Boolean;
  Var
    Pixelformat      : GLuint;
    WC               : TWndClass;
    dmScreenSettings : DevMode;
    PFD              : PIXELFORMATDESCRIPTOR;
  Begin
    Result:= True;
    Data.Active:= True;
    With WC
      Do Begin
        style         := CS_HREDRAW OR CS_VREDRAW OR CS_OWNDC;
        lpfnWndProc   := MethodPointer(WndProc);
        cbClsExtra    := 0;
        cbWndExtra    := 0;
        hInstance     := Data.Handle.Istance;
        hIcon         := Data.Icon;
        hCursor       := Data.Cursor;
        hbrBackground := 0;
        lpszMenuName  := NIL;
        lpszClassName := 'OpenGl';
        End;
    If RegisterClass(WC) = 0
      Then Begin
        LastErrorID := Failed_Register_Class;
        Result      := False;
        Exit;
        End;
    If Data.FullScreen
      Then Begin
        ZeroMemory( @dmScreenSettings, sizeof(dmScreenSettings) );
        With dmScreensettings
          Do Begin
            dmSize := sizeof(dmScreenSettings);
            dmPelsWidth   := Data.Width;
            dmPelsHeight  := Data.height;
            dmBitsPerPel  := Data.bits;
            dmFields      := DM_BITSPERPEL OR DM_PELSWIDTH OR
DM_PELSHEIGHT;
            End;
        If ChangeDisplaySettings(dmScreenSettings, CDS_FullScreen) =
DISP_CHANGE_SUCCESSFUL
          Then Begin
            Data.dwExStyle := WS_EX_APPWINDOW;
            Data.dwStyle   := WS_popup OR WS_CLIPSIBLINGS OR
WS_CLIPCHILDREN;
            ShowCursor(False);
            End
          Else Begin
            LastErrorID:= Failed_FullScreen;
            Result := False;
            Exit;
            End;
          End
      Else Begin
        Data.dwExStyle := WS_EX_APPWINDOW or WS_EX_WINDOWEDGE;
//Extended Window Style
        Data.dwStyle   := WS_OVERLAPPEDWINDOW or WS_CLIPSIBLINGS or
WS_CLIPCHILDREN; //Windows Style
        End;
    With Data
// qui da l'errore...
      Do Handle.Window:=
CreateWindowEx(dwExStyle,'OpenGl',Caption,dwStyle,0,0,Width,Height,0,0,Handle.Istance,
nil);
    If Data.Handle.Window = 0
      Then Begin
        Kill;
        LastErrorID := Window_Creation_error;
        Result      := False;
        ShowMessage(SysErrorMessage(GetLastError));
        Exit;
        End;
    With PFD
      Do Begin
        nSize:= SizeOf( PIXELFORMATDESCRIPTOR );
        nVersion:= 1;
        dwFlags:= PFD_DRAW_TO_WINDOW
        or PFD_SUPPORT_OPENGL
        or PFD_DOUBLEBUFFER;
        iPixelType:= PFD_TYPE_RGBA;
        cColorBits:= dmScreenSettings.dmBitsPerPel;
        cRedBits:= 0;
        cRedShift:= 0;
        cGreenBits:= 0;
        cBlueBits:= 0;
        cBlueShift:= 0;
        cAlphaBits:= 0;
        cAlphaShift:= 0;
        cAccumBits:= 0;
        cAccumRedBits:= 0;
        cAccumGreenBits:= 0;
        cAccumBlueBits:= 0;
        cAccumAlphaBits:= 0;
        cDepthBits:= 16;
        cStencilBits:= 0;
        cAuxBuffers:= 0;
        iLayerType:= PFD_MAIN_PLANE;
        bReserved:= 0;
        dwLayerMask:= 0;
        dwVisibleMask:= 0;
        dwDamageMask:= 0;
        End;
    Data.Handle.DC := GetDC(Data.Handle.Window);
    If Data.Handle.DC = 0
      Then Begin
        Kill;
        LastErrorID:= Failed_HDC_Creation;
        Result     := False;
        Exit;
        End;
    PixelFormat := ChoosePixelFormat(Data.Handle.DC, @pfd);
    If (PixelFormat = 0)
      Then Begin
        Kill;
        LastErrorID := Suitable_PixelFormat;
        Result      := False;
        Exit;
        End;
    If (NOT SetPixelFormat(Data.handle.DC, PixelFormat, @pfd))
      Then Begin
        Kill;
        LastErrorID := Error_Set_PixelFormat;
        Result      := False;
        Exit;
        End;
    Data.Handle.RC := wglCreateContext(Data.Handle.DC);
    If Data.Handle.RC = 0
      Then Begin
        Kill;
        LastErrorID := Error_Creating_RC;
        Result      := False;
        Exit;
        End;
    If (NOT wglMakeCurrent(Data.Handle.DC, Data.Handle.RC))
      Then Begin
        Kill;
        LastErrorID := Error_Active_RC;
        Result      := False;
        exit;
        End;
    With Data
      Do Begin
        With Handle
          Do Begin
          ShowWindow(Window, SW_SHOW);
          SetForegroundWindow(Window);
          SetFocus(Window);
          End;
        ActionSet.OnResize(Width, Height);
        End;
    InitGL;
  End;


dislessic forever ;}

 nil);
se l'errore che ti da' e' invalid parameter si suppone che uno dei
parametri che passi a CreateWindowEx non sia valido. Quel With Data e' a
mio parere molto sospetto. Width e Height ad esempio sono definiti come
GLSizei, che non mi risulta sia un tipo di Win (in quella posizione
vuole un int). Inoltre, hai valorizzato correttamente Instance?
Saluti
Paolo Arosio


Il codice cosi come è funziona in una unit non OOP... cioè le stesse
varibili  tutto uguali.... l'unica differenza e che c'è quel wndproc
dentro la stuttura dati... per GLSizei è definito dentro OpenGL (GL.H
e GLU.H dentro C) in pratica è una ridifinizione per integer, infatti
dentro alla unit c'è scritto:
Type
  GLsizei = Integer;
  {$EXTERNALSYM GLsizei}
