MessageDlg

Existe un principio básico de la programación orientada a objetos que dice "programar contra la interfaz" y que tiene como objetivo hacer que lo que se programe sea lo más reutilizable posible.
Me surge la siguiente pregunta: ¿Y si en lugar de cambiar MessageDlg nos creamos un "componente" con las opciones que deseamos?. Uppsss, vamos a ver un poco más de que va esto que pienso.
Tu pregunta es si podías cambiar el texto de los botones que aparecen en un MessageDlg. Para responder a la pregunta veamos de donde viene el texto de dichos botones... La función MessageDlg se define de la siguiente manera:
function MessageDlg(const Msg: string; AType: TMsgDlgType;
AButtons: TMsgDlgButtons; HelpCtx: Longint): Word;
Y nos vamos a fijar en la parte que nos concierne. El parámetro AButtons determina qué botones aparecerán en la caja del mensaje. Como nos indica, este parámetro es de "tipo" TMsgDlgButtons
que está definido de la siguiente manera:
type
TMsgDlgBtn = (mbYes, mbNo, mbOK, mbCancel, mbAbort, mbRetry, mbIgnore, mbAll, mbHelp);
TMsgDlgButtons = set of TMsgDlgBtn;
Donde cada mbXXX significa un "objeto" button con ciertas características, por ejemplo, mbYes significa un button con una marca y el texto 'Yes' en su cara. El código que implementa dicha función así como la definición de los botones está en la unit Dialog y a menos que disponga del
código fuente para cambiar el texto, por ejemplo de Yes a Si o a HolaMundo o a lo que quieras, no podrás hacerlo. Pero...¿y si en lugar de programar contra la implementación programamos contra la interfaz?, es decir, vamos a dejar la unit Dialog tal como está y creemos una nueva "interfaz" que poseea un nuevo método MiMessageDlg(...) y así podremos especificar que queremos que haga y la implementación de este nuevo método nos proporcionará un nuevo MessageDlg que se ajuste a nuestras necesidades. Vamos al lio...
El método MiMessageDlg lo definimos de la siguiente manera:
function MiMessageDlg(const Msg: string; AType: TMsgDlgType;
AButtons: TMsgDlgButtons; Captions: array of string): Integer;
Al que le pasamos 4 arámetros. Le he puesto los mismos nombres a los tres primeros para que veas la similitud con MessageDlg y en lugar del parámetro HelpCtx incluimos un parámetro Captions del tipo array of string (parece que se descubre para qué nos servirá, ¿verdad?). Vista la definición
de la función para la "interfaz" veamos su "implementación" (Delphi incluye la interfaz de
usuario y la implementación en un solo fichero si estamos haciendo una unit pero lo mejor es trabajar con interfaces por un lado y con la implementación para dicha interfaz por otra -> "
componentes?"):
function MiMessageDlg(const Msg: string; AType: TMsgDlgType;
AButtons: TMsgDlgButtons; Captions: array of string): Integer;
var
{La Form para MiMessageDlg}
unMsgDlg: TForm;
{Un iterador para los bucles}
i: Integer;
{Una variable para almacenar temporalmente cada uno de los botones que pongamos}
dlgButton: TButton;
{Un índice que usaremos para ir recorriendo los botones que pongamos}
captionIndex: Integer;
begin
{Creación del diálogo. La unit Dialogs implementa la función CreateMessageDialog, que devuelve un Form del tipo 'Atype' con un mensaje 'Msg' y con los botones 'AButtons' }
unMsgDlg := CreateMessageDialog(Msg,AType,AButtons);
{Ponemos el índice a 0}
captionIndex := 0;
{Recorremos los "objetos" de nuestro diálogo. Para ello usamos el método ComponentCount de TComponent que aplicaremos a nuestro unMsgDlg que lógicamente tambien deriva de TComponent}
for i := 0 to unMsgDlg.ComponentCount - 1 do
begin
{Si el "objeto" es de tipo TButton, entonces}
if (unMsgDlg.Components is TButton) then
begin
{Colocamos el "objeto" en la variable dlgButton}
dlgButton := TButton(uMsgDlg.Components);
{La función High aplicada a un array (en nuestro caso el parámetro Captions) devuelve el íncice más alto que podemos tener con dicho array. Lo comparamos con nuestro índice. Si el nuestro es mayor entonces terminamos}
if CaptionIndex > High(Captions) then Break;
{Le ponemos al botón correspondiente el texto correspondiente que hemos pasado en el array de string}
dlgButton.Caption := Captions[CaptionIndex];
{Incrementamos el índice para procesar siguiente botón}
Inc(CaptionIndex);
end;
end;
{Devolvemos nuestro diálogo de forma Modal}
Result := uMsgDlg.ShowModal;
end;
Bueno, y esta es la función. Está por internet yo te la he sacado y te la he comentado. Lo único que nos queda es poner un ejemplo de cómo la llamamos. Por ejemplo, un "objeto" Form llamado "
TForm1" con un solo "objeto" button llamado Button1 y que al ser pulsado genera un MiMessageDlg
con un texto 'Hola Lina, este es nuestro MiMessageDlg' y dos botones con el texto 'Boton1' y 'Boton2' respectivamente y al pulsarlos mostramos los mensaje 'Boton1 Pulsado' o 'Boton2 Pulsado'.
procedure TForm1.Button1Click(Sender: TObject);
begin
if MiMessageDialog('Hola Lina, este es nuestro MessageDlg', mtConfirmation, mbOKCancel,
['Boton1', 'Boton2']) = mrOk then
ShowMessage('"Boton1" Pulsado')
else
ShowMessage('"Boton2" Pulsado');
end;
Nota final: fíjate que tanto los mtXXXXX como los mbXXXXXX siguen siendo los mismos que en MessageDlg, lo único que hemos hecho es incorporar la funcionalidad de cambiar el texto de los botones.