¿existe un evento OnScrollBoxPositionScrollBarChange?

[ecfisa]

Hola.

Si escafandra, si se va a aplicar eventualmente a un control, esta última opción que mencionas la considero mas práctica por lo sencilla de implementar .

header

Código PHP:

...
class TForm1 : public TForm {
...
private:    
   TWndMethod OldWndProc;
   void __fastcall NewWndProc(TMessage& Message);
   void __fastcall vertScroll(TObject *Sender);
   void __fastcall horzScroll(TObject *Sender);
   ...
}; 


code

Código PHP:

..
void __fastcall TForm1::FormCreate(TObject *Sender)
{
  OldWndProc = ScrollBox1->WindowProc;
  ScrollBox1->WindowProc = NewWndProc;
}

void __fastcall TForm1::NewWndProc(TMessage& Message)
{
  if(Message.Msg == WM_VSCROLL)
    vertScroll(ScrollBox1);
  else if( Message.Msg == WM_HSCROLL)
    horzScroll(ScrollBox1);
  OldWndProc(Message);
}

void __fastcall TForm1::vertScroll(TObject *Sender) {
  Caption = "Scroll vertical";
}

void __fastcall TForm1::horzScroll(TObject *Sender) {
  Caption = "Scroll horizontal";
}

void __fastcall TForm1::FormDestroy(TObject *Sender)
{
  ScrollBox1->WindowProc = OldWndProc;
} 


En cambio, optaría por la primera si se justificara por la reutilización del código (como en el caso de un componente).

Es decir, si voy a usar algo una vez en una aplicación y muy rara vez nuevamente, escribiría el código mas corto y simple si con él obtengo el mismo resultado (pero es mi humilde opinion).

Saludos

[[escafandra]]

ecfisa, no hablo de cambiar la función sino de sobreescribir la función virtual WndProc del control que estamos creando, derivado de un descendente TWinControl. Es mi técnica preferida.

Saludos.

[aguml]

interesante, ¿Como seria eso amigo? ¿Puedes crear un ejemplo básico?

[ecfisa]

Empezado por escafandra

ecfisa, no hablo de cambiar la función sino de sobreescribir la función virtual WndProc del control que estamos creando...

Ha, te entendí mal entonces... Yo hablaba de evitar derivar la clase para un uso casual.

Empezado por aguml

interesante, ¿Como seria eso amigo? ¿Puedes crear un ejemplo básico?

No veo en línea al amigo escafandra, pero te pongo un ejemplo muy básico de lo que creo a que se refiere (luego me corregirá si me equivoco):

header:

Código PHP:

class TForm1 : public TForm {
__published:
private:
  void __fastcall FMouseDown(TMessage& msg);
protected:
  virtual void __fastcall WndProc(TMessage& msg);
public:
  __fastcall TForm1(TComponent* Owner);
}; 


code:

Código PHP:

void __fastcall TForm1::FMouseDown(TMessage& msg) {

    Caption = Format("Click en: (%3d, %3d)",
      ARRAYOFCONST(((int)msg.LParamLo, (int)msg.LParamHi)));
}

void __fastcall TForm1::WndProc(TMessage& msg) {

  if (msg.Msg == WM_LBUTTONDOWN)
    FMouseDown(msg);
  TForm::WndProc(msg);
} 


Saludos

[aguml]

mmmm es muy similar a la de sustituir la funcion. En el ejemplo que pusiste, al ser un form, ¿Cmo harias para cear un form y que sea el unico form del proyecto? Cuando creas una aplicacion el c++builder ya te añade el form pero si quieres que use el tuyo modificado en vez del estandar ¿Como lo haces? Ya se que no tiene nada que ver y que es un ejemplo pero me dio curiosidad.

[aguml]

bien, lo he vuelto a ver y me di cuenta que no creas ninguna clase sino que modificas la que hay. En ese caso es muy facil porque es la unidad .cpp y .h del form1 pero si fuese por ejemplo de un timage no está el .cpp ni el .h por lo que para hacer eso mismo tendrias que crear una derivada ¿No? Ademas ¿Que ventaja tiene sobreescribir la funcion contra reemplazarla? Supongo que se obtiene exactamente el mismo resultado ¿No?

[[escafandra]]

ecfisa, a eso me refería.

Pongo un ejemplo sobre el control de aguml:

//---------------------------------------------------------------------------

#ifndef NewScrollBoxH
#define NewScrollBoxH
//---------------------------------------------------------------------------
#include <SysUtils.hpp>
#include <Classes.hpp>
#include <Controls.hpp>
#include <Forms.hpp>
//---------------------------------------------------------------------------
class PACKAGE TNewScrollBox : public TScrollBox
{
   public:
        __fastcall TNewScrollBox(TComponent* Owner);

   private:
        TNotifyEvent FOnVerticalScroll;
        TNotifyEvent FOnHorizontalScroll;

   protected:
        virtual void __fastcall WndProc(TMessage& msg);

   __published:
        __property TNotifyEvent OnVerticalScroll =
        {read=FOnVerticalScroll,
        write=FOnVerticalScroll};
        __property TNotifyEvent OnHorizontalScroll =
        {read=FOnHorizontalScroll,
        write=FOnHorizontalScroll};
};
//---------------------------------------------------------------------------
#endif

//---------------------------------------------------------------------------

#include <vcl.h>

#pragma hdrstop

#include "NewScrollBox.h"
#pragma package(smart_init)
//---------------------------------------------------------------------------
// ValidCtrCheck is used to assure that the components created do not have
// any pure virtual functions.
//

static inline void ValidCtrCheck(TNewScrollBox *)
{
        new TNewScrollBox(NULL);
}

//---------------------------------------------------------------------------
__fastcall TNewScrollBox::TNewScrollBox(TComponent* Owner)
        : TScrollBox(Owner)
{
  FOnHorizontalScroll = 0;
  FOnVerticalScroll = 0;
}

void __fastcall TNewScrollBox::WndProc(TMessage& msg)
{
  if(msg.Msg == WM_HSCROLL && FOnHorizontalScroll) FOnHorizontalScroll(this);
  if(msg.Msg == WM_VSCROLL && FOnVerticalScroll) FOnVerticalScroll(this);
  TScrollBox::WndProc(msg);
}

//---------------------------------------------------------------------------
namespace Newscrollbox
{
        void __fastcall PACKAGE Register()
        {
                 TComponentClass classes[1] = {__classid(TNewScrollBox)};
                 RegisterComponents("Samples", classes, 0);
        }
}
//---------------------------------------------------------------------------

aguml, ecfisa si crea una nueva clase puesto que TForm1 ya es derivada de TForm, lo que pasa es que la crea Builder.
Una explicación sencilla de una función virtual: una función virtual tiene la característica que se hereda, como todas, pero si la sobreescribes funciona la de la clase hija, incluso si la llamas desde un puntero a la clase hija pero del tipo clase madre. El compilador averigua a quién te refieres y aplica la función correcta. En este caso la función WinProc es virtual desde TWinControl y es la encargada del tratamiento de mensajes de Windows. En este caso, la sobreescritura debe terminar llamando a la función de la clase madre para que trate el resto de mensajes.

Fíjate en esto:

TNewScrollBox *SC = new TNewScrollBox(this);
TWinControl *WC = SC;
SC->WndProc(msg);  // LLama a la función WinProc de TNewScrollBox porque SC lo es.

Saludos.