Cuadros de diálogo - University of the Basque Country ...ehu.eus/mrodriguez/archivos/csharppdf/WinForms/CuadrosDialogo.pdf · Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo

1/27

Cuadros de diálogo En general, las cuadros de diálogo se utilizan para pedir datos o configurar variables desde una aplicación. La plataforma .NET proporciona cuadros de diálogo predefinidos pero también permite que el programador configure cuadros de diálogo según sus necesidades. A continuación se estudian estos últimos y posteriormente se verán los que proporciona la plataforma.

Cuadros de diálogo definidos por el usuario En C# no existe una clase Dialog o DialogBox. Las cajas de diálogo son formularios con unas propiedades predeterminadas:

a) Tiene tamaño fijo. La propiedad FormBorderStyle debe ser FixedDialog. b) No suelen tener los tres botones de la parte superior derecha de las ventanas

comunes de Windows –Minimizar, Maximizar y Control- . Por eso, sus propiedades MinimizedBox, MaximizedBox y ControlBox deben ser false.

Un cuadro de diálogo puede ser modal -cuando la propia aplicación o formulario que lo ha llamado no puede recibir ningún evento hasta que se ha cerrado el cuadro de diálogo- o no modal –el caso contrario-. Para ejecutar un cuadro de dialogo modal se siguen los siguientes pasos:

• Se crea y diseña el formulario correspondiente al cuadro de diálogo. Dicho formulario tendrá en cuenta lo dicho anteriormente en los apartados a y b. En general, el cuadro tendrá, al menos, un botón Aceptar y un botón Cancelar, con la función de cerrar el cuadro y de informar a la aplicación que se aceptan los datos que se han introducido o que se desea anular la introducción de dichos datos. También se diseñan cuadros de diálogo con solo el botón de Aceptar.

• En el método de la aplicación que llama al cuadro de diálogo modal se crea un objeto de la clase del cuadro de diálogo y dicho objeto invoca al método ShowDialog(). En ese momento la aplicación detiene su ejecución hasta que se haya cerrado el cuadro de diálogo que le informa de cuál ha sido el botón pulsado. El código podría ser algo así: Dialogo dlg = new Dialogo(); dlg.ShowDialog(); MetodoQueHaceAlgo(); En este ejemplo, el método MetodoQueHaceAlgo() no se ejecuta hasta que

se ha cerrado el cuadro de diálogo. Si se llama a un cuadro de diálogo no modal habría que llamar al método Show() en lugar de ShowDialog(). Se abre entonces el cuadro de diálogo y se ejecutaría el método MetodoQueHaceAlgo() sin esperar a que se cierre el cuadro. El control de este tipo de cuadros es mucho más complejo.


2/27

Ejemplo: trabajando con cuadros de diálogo definidos por el usuario

Esta aplicación tiene un formulario llamado FormularioPrincipal, y un cuadro de diálogo modal. El FormularioPrincipal puede abrir el cuadro de diálogo para solicitar un dato -en este caso una frase- que se introduce en una caja de texto y se devuelve como una cadena al propio formulario (figura 18.1).

El formulario FormularioPrincipal tiene una etiqueta para recoger la cadena desde el cuadro de dialogo y dos botones btnDefinirFrase y btnSalir. El cuadro de diálogo Dialogo tiene una caja de texto texto y dos botones btnOk y btnCancelar. FormularioPrincipal llama al cuadro de diálogo desde btnDefinirFrase.

Figura 18.1. Se llama desde formulario principal a un cuadro de diálogo. Una vez que se despliega el cuadro de diálogo, el usuario debe rellenar la caja de texto. Posteriormente, si pulsa el btnOk, la cadena de la caja de texto debe pasar a la etiqueta del FormularioPrincipal. Si se pulsase btnCancelar, se debe cancelar la operación. El botón btnOk del diálogo en realidad significa: “Estoy de acuerdo con la elección. Por favor, utiliza este valor en el programa y cierra el cuadro de diálogo”. Y el btnCancelar : ”Anula la elección, vuelve al estado anterior y cierra el cuadro de diálogo”. Para asignar esta funcionalidad a los botones del formulario, deben utilizarse las propiedades DialogResult de los botones btnOk y btnCancelar. Se le asigna el valor DialogResult.Ok al primero y DialogResult.Cancel al segundo. Pero, ¿qué significa exactamente asignar un valor a la propiedad DialogResult de un botón?.


3/27

Para contestar a esta pregunta es necesario saber que cuando se pulsa un botón del diálogo suceden las siguientes cosas:

a) Se ejecuta el código asociado al botón. b) Inmediatamente después, se cierra el cuadro de diálogo. c) Se asigna a la propiedad DialogResult del cuadro de diálogo el valor de la

propiedad DialogResult del botón que se ha pulsado.

El código del botón btnDefinirFrase del formulario principal es:

//Se crea un objeto de la clase del Cuadro de Dialogo Dialogo dlg = new Dialogo(); //Cuando se cierre dlg se asigna a la propiedad DialogResult del //formulario, la propiedad DialogResult del botón //correspondiente al botón pulsado dlg.ShowDialog(this); //Si se pulsa btnOk if(dlg.DialogResult == DialogResult.Ok) // CodigoQueSeEjecutaDespuesDePulsarOk() //si se pulsa btnCancelar else if(dlg.DialogResult == DialogResult.Cancel)

// CodigoQueSeEjecutaDespuesDePulsarCancel()

MetodoQueHaceMasCosas();

DialogResult es una enumeración pública. Su definición es: public enum DialogResult; Los valores que puede tomar DialogResult son:

DialogResult.Abort DialogResult.Cancel DialogResult.Ignore DialogResult.No DialogResult. OK DialogResult.Retry DialogResult.Yes None El método ShowDialog() devuelve un objeto de tipo DialogResult que se asigna a la propiedad DialogResult del cuadro de diálogo. Su estructura es:

public DialogResult ShowDialog(); Para construir esta aplicación siga los siguientes pasos:

• Comience creando una nueva aplicación y llámele CuadroDeDialogo • Propiedades del formulario:

Text = Formulario Principal


4/27

Name = FormularioPrincipal

• A continuación añada dos botones al formulario principal. Asigne las propiedades siguientes:

Name = btnIrCuadroDialogo Text = Ir al cuadro de dialogo Name = btnSalir Text = Salir

• Se añade una etiqueta con las propiedades siguientes: Name = etiqueta

Text = (sin texto) El resultado del diseño debe ser parecido al de la figura 18.2:

Figura 18.2. Diseño de la aplicación

• Este es un buen momento para guardar el proyecto. • A continuación, cree el cuadro de diálogo:

a) Añada un formulario al proyecto (Proyecto/Agregar formulario de Windows) o bien, en la ventana Explorador de Soluciones pulse –como indica la figura 18.3- con el botón derecho del ratón sobre el nombre del proyecto, elegir Agregar/Agregar formulario de Windows... , y asigne al fichero el nombre MiDialogo.cs (figuras 18.3 y 18.4)


5/27

Figura 18.3. Añadiendo un nuevo formulario a la aplicación.

Figura 18.4. Cuadro de diálogo para configurar el nuevo formulario.


6/27

Al pulsar Abrir se añadirá un nuevo formulario a la aplicación.

b) En la ventana de propiedades del formulario MiDialogo:

BorderStyle = FixedDialog. (No puede cambiarse el tamaño) ControlBox = false (No aparece el botón control ) MinimizeBox = false (No aparece el botón minimizar ) MaximizeBox = false. (No aparece el botón maximizar )

c) Añada una caja de texto al cuadro de diálogo: Name = texto Text = (sin texto)

d) Añada una etiqueta al cuadro de diálogo, para “etiquetarlo”:

Text = Escriba el fichero con su path completo Autosize = True (optimiza su tamaño automáticamente)

e) Añada dos botones al cuadro de diálogo, btnOK y btnCancelar. Cuando se pulse btnOK, se debe cerrar el cuadro de diálogo y el texto de la caja de texto, debe ser “recogido” por el cuadro de diálogo y enviado al formulario principal. Sin embargo, si se pulsa el botón btnCancelar, simplemente se sale del cuadro de diálogo y se cancela la operación. Propiedades de los botones: Name = btnOK Text = Aceptar DialogResult = Ok Name = btnCancelar Text = Cancelar DialogResult = cancel

El aspecto final del cuadro de diálogo es el de la figura 18.5:

Figura 18.5: Diseño final del cuadro de diálogo f) La misión de los dos botones es cerrar el cuadro de diálogo y asignar

a la propiedad DialogResult del cuadro de diálogo el valor correspondiente de la propiedad ModalResult del botón pulsado–en


7/27

este caso ModalResult.OK o ModalResult.Cancel- . Además, esos botones pueden ejecutar un código, si se desea, antes de que se cierre el cuadro. En este caso, el botón btnCancelar no ejecutará nada y el btnOk asignará la cadena de la caja de texto a una variable privada de la clase MiDialogo.

Para hacer esto de manera correcta, defina un campo privado nombreFichero de tipo string, para almacenar o recoger el texto de la caja de texto texto en la clase MiDialogo. Añada la línea siguiente en la zona de la clase MiDialogo reservada para los campos de la clase:

private string nombreFichero;

Para poder acceder a este campo de modo sencillo defina una propiedad pública, de nombre NombreFichero para leer y almacenar un string en el campo nombreFichero.

Para ello, en la ventana Vista de clases pulse con botón derecho sobre el nombre de la clase –MiDialogo- y seleccione la opción Agregar/Agregar Propiedad, como se indica en la figura 18.6)

Figura 18.6. Forma de agregar visualmente una propiedad a una clase Aparece el cuadro de diálogo de la figura 18.7:


8/27

Figura 18.7. Cuadro de diálogo de definición de una propiedad. Rellene los datos correspondientes: tipo devuelto –será un string- y el nombre

de la propiedad, que además será de lectura/escritura (figura 18.7). Visual Studio escribe el código siguiente:

public string NombreFichero {

get { return nombreFichero; } set { nombreFichero = value; }

} El botón btnOk debe cerrar el cuadro, pero también asignar la cadena

introducida a la variable nombreFichero. Por eso, en su evento Click se le asocia el código siguiente:

NombreFichero=texto.Text; Sólo resta llamar al diálogo como modal desde el FormularioPrincipal y

asignar código a los eventos Click de ambos botones: MiDialogo dlg = new MiDialogo(); dlg.ShowDialog(this);


9/27

//Si se pulsa btnOk if(dlg.DialogResult == DialogResult.OK) etiqueta.Text = dlg.NombreFichero; //si se pulsa btnCancelar else if(dlg.DialogResult == DialogResult.Cancel) // No hacer nada ; Guarde la aplicación y ejecútela.

Figura 18.8. Aspecto final de la aplicación. El código completo de los dos formularios es el siguiente: //*************FormularioPrincipal.cs******************** using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; using System.Data; namespace CuadroDialogo { public class FormularioPrincipal : System.Windows.Forms.Form { private System.Windows.Forms.Button btnIrCuadroDialogo; private System.Windows.Forms.Button btnSalir; private System.Windows.Forms.Label etiqueta; private System.ComponentModel.Container components = null; public FormularioPrincipal() {


10/27

InitializeComponent(); } protected override void Dispose( bool disposing ) { if( disposing ) { if (components != null) { components.Dispose(); } } base.Dispose( disposing ); } #region Windows Form Designer generated code private void InitializeComponent() { this.btnSalir = new System.Windows.Forms.Button(); this.etiqueta = new System.Windows.Forms.Label(); this.btnIrCuadroDialogo = new Button(); this.SuspendLayout(); // // btnSalir // this.btnSalir.Location = new Point(176, 152); this.btnSalir.Name = "btnSalir"; this.btnSalir.TabIndex = 1; this.btnSalir.Text = "Salir"; // this.AutoScaleBaseSize = new Size(5, 13); this.ClientSize = new System.Drawing.Size(292, 273); this.Controls.AddRange(new Control[] { this.etiqueta, this.btnSalir, this.btnIrCuadroDialogo}); this.Name = "FormularioPrincipal"; this.Text = "Formulario Principal"; // etiqueta // this.etiqueta.Location = new Point(48, 72); this.etiqueta.Name = "etiqueta"; this.etiqueta.Size=new System.Drawing.Size(184, 23); this.etiqueta.TabIndex = 2; // // btnIrCuadroDialogo // this.btnIrCuadroDialogo.Location=new Point(32, 152); this.btnIrCuadroDialogo.Name = "btnIrCuadroDialogo"; this.btnIrCuadroDialogo.Size = new Size(128, 23); this.btnIrCuadroDialogo.TabIndex = 0; this.btnIrCuadroDialogo.Text =

"Ir al cuadro de diálogo"; this.btnIrCuadroDialogo.Click +=

new System.EventHandler(this.btnIrCuadroDialogo_Click);

// // FormularioPrincipal // this.ResumeLayout(false);


11/27

} #endregion [STAThread] static void Main() { Application.Run(new FormularioPrincipal()); } private void btnIrCuadroDialogo_Click(object sender,

System.EventArgs e) { MiDialogo dlg = new MiDialogo(); dlg.ShowDialog(this); //Si se pulsa btnOk if(dlg.DialogResult == DialogResult.OK) etiqueta.Text = dlg.NombreFichero; //si se pulsa btnCancelar else if(dlg.DialogResult == DialogResult.Cancel) // No hacer nada ; } } } //***************MiDialogo.cs************************** using System; using System.Drawing; using System.Collections; using System.ComponentModel; using System.Windows.Forms; namespace CuadroDialogo { public class MiDialogo : System.Windows.Forms.Form { private System.Windows.Forms.TextBox texto; private System.Windows.Forms.Button btnOk; private System.Windows.Forms.Button btnCancelar; private System.Windows.Forms.Label label1; private System.ComponentModel.Container components = null; //Mis variables private string nombreFichero; public string NombreFichero { get { return nombreFichero; } set { nombreFichero=value; } } public MiDialogo() {


12/27

InitializeComponent(); } protected override void Dispose( bool disposing ) { if( disposing ) { if(components != null) { components.Dispose(); } } base.Dispose( disposing ); } #region Windows Form Designer generated code private void InitializeComponent() { this.texto = new System.Windows.Forms.TextBox(); this.btnOk = new System.Windows.Forms.Button(); this.btnCancelar = new System.Windows.Forms.Button(); this.label1 = new System.Windows.Forms.Label(); this.SuspendLayout(); // // texto // this.texto.Location=new System.Drawing.Point(56,56); this.texto.Name = "texto"; this.texto.Size = new System.Drawing.Size(184, 20); this.texto.TabIndex = 0; this.texto.Text = ""; // // btnOk // this.btnOk.DialogResult = DialogResult.OK; this.btnOk.Location = new Point(56, 104); this.btnOk.Name = "btnOk"; this.btnOk.TabIndex = 1; this.btnOk.Text = "Ok"; this.btnOk.Click +=

new System.EventHandler(this.btnOk_Click); // // btnCancelar // this.btnCancelar.DialogResult = DialogResult.Cancel; this.btnCancelar.Location = new Point(160, 104); this.btnCancelar.Name = "btnCancelar"; this.btnCancelar.TabIndex = 2; this.btnCancelar.Text = "Cancelar"; // // label1 // this.label1.AutoSize = true; this.label1.Location = new Point(40, 24); this.label1.Name = "label1"; this.label1.Size = new Size(201, 13); this.label1.TabIndex = 3; this.label1.Text =

“Escriba el fichero con su path completo"; // // MiDialogo // this.AutoScaleBaseSize = new Size(5, 13);


13/27

this.ClientSize = new Size(292, 157); this.Controls.AddRange(new Control[] { this.label1, this.btnCancelar, this.btnOk, this.texto}); this.Name = "MiDialogo"; this.Text = "MiDialogo"; this.ResumeLayout(false); } #endregion private void btnOk_Click(object sender, System.EventArgs e) { //Asignamos el valor introducido

//en la caja de texto al campo nombreFichero //Podría escribirse también

// nombreFichero=texto.Text; NombreFichero=texto.Text; } } } Por último y aunque no se ha indicado, el código correspondiente al botón btnSalir es: private void btnSalir_Click(object sender, System.EventArgs e) { Application.Exit(); }

Cuadros de dialogo proporcionados por .NET Todos los cuadros de diálogo que se estudian a continuación son proporcionados por la librería .NET. El programador no los diseña. Sólo define algunas de sus propiedades

La clase MessageBox

Presenta un cuadro de diálogo muy simple por pantalla. Un cuadro de diálogo MessageBox es un cuadro de diálogo modal que, en general, se utiliza para informar o avisar al usuario de algo que ha ocurrido pero no para introducir datos.

No tiene constructor público, por lo que no es posible crear un objeto o instancia de esta clase. Para visualizar un MessageBox se invoca al método estático Show().

El aspecto de un MessageBox es el de la figura 18.9.


14/27

Figura 18.9

Se puede definir el título, el mensaje, los botones e iconos del MessageBox determinando los parámetros que se pasan en el método Show().

Si, por ejemplo, en un formulario se ha situado un botón y una caja de texto y se desea que si se pulsa el botón estando la caja de texto vacía, se avise al usuario con un MessageBox que le indique que la caja de texto debe rellenarse con algún dato, el código del botón sería algo parecido al siguiente: protected void button1_Click(object sender, System.EventArgs e) { if(textBox1.Text == "") { MessageBox.Show("Introduce tu nombre", "Error al introducir el nombre”, MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } else { // Código en caso de que se haya introducido algo. } } Esta clase hereda directamente de la clase Object y sólo tiene un método que no sea heredado que es precisamente Show(). Devuelve el valor de la propiedad DialogResult del botón pulsado. Show() está sobrecargado y tiene muchas maneras de ser invocado: Desde el simple:

public static DialogResult Show(string mensaje);

hasta

public static DialogResult Show(IWin32Window ventana, string mensaje, string titulo, MessageBoxButtons botones, MessageBoxIcon icono, MessageBoxDefaultButton btn, MessageBoxOptions op);

La enumeración MessageBoxButtons es:

AbortRetryIgnore La ventana contiene los botones Anular, Reintentar y Omitir. OK La ventana contiene el boton Aceptar. OKCancel La ventana contiene los botones Aceptar y Cancelar. RetryCancel La ventana contiene los botones Reintentar y Cancelar. YesNo La ventana contiene los botones Sí, No


15/27

YesNoCancel La ventana contiene los botones Sí, No y Cancelar.

La enumeración MessageBoxIcon es:

Asterisk El icono es una interrogación (una letra “i” en un signo de interrogación).

Error El icono es una X blanca sobre un cículo de fondo rojo Exclamation El icono es una exclamación en un triángulo de fondo amarillo Hand El icono es una X blanca sobre un cículo de fondo rojo. Information El icono es una interrogación (una letra “i” en un signo de

interrogación). None No hay icono. Question El icono es una interrogación en un círculo. Stop El icono es una X blanca sobre un cículo de fondo rojo. Warning El icono es una exclamación en un triángulo de fondo amarillo.

Enumeración correspondiente a MessageBoxDefaultButton

Button1 El botón por defecto es el primero. Button2 Idem el segundo. Button3 Idem el tercero. Enumeración correspondiente a MessageBoxOptions DefaultDesktopOnly, ServiceNotification

Se visualiza el mensaje en la ventana activa.

RightAlign, RtlReading Formas de alinear el texto

A continuación se destacan varios ejemplos y se representa la salida de esas líneas de código.

a) MessageBox.Show(this,"Hola"); b) MessageBox.Show("Hola");

Figura 18.10


16/27

b) MessageBox.Show(this,"Hola","Este es el título del mensaje");

Figura 18.11

c) MessageBox.Show(this,"Hola","Título mensaje",MessageBoxButtons.OK);

Figura 18.12

c) MessageBox.Show(this, "Hola", "Título mensaje", MessageBoxButtons.YesNoCancel);

Figura 18.13

d) MessageBox.Show(this, "Hola", "Título mensaje", MessageBoxButtons.AbortRetryIgnore);

Figura 18.14

e) MessageBox.Show(this,


17/27

"Hola", "Título mensaje", MessageBoxButtons.AbortRetryIgnore, MessageBoxIcon.Asterisk);

Figura 18.15

f) MessageBox.Show(this, "Hola", "Título mensaje", MessageBoxButtons.OKCancel, MessageBoxIcon.Stop, MessageBoxDefaultButton.Button2);

Figura 18.16

Cuadros de diálogo estándar proporcionados por .NET El Framework .NET proporciona otras clases para algunos cuadros de diálogo predefinidos para abrir y guardar ficheros, imprimir, para la elegir de la fuente, etc. Cada uno de estos cuadros de diálogo se corresponde con una clase del Framework. La jerarquía de dichas clases es la que se representa en la figura 18.17.

CommonDialog

Component

Object


18/27

Figura 18.17. Jerarquía de las clases correspondientes a los cuadros de diálogo estándar. Todas estas clases derivan de la clase CommonDialog, excepto la clase PrintPreviewDialog que deriva directamente de la clase Form.

La clase CommonDialog

Esta clase base define los siguientes métodos y eventos, que son comunes a todas las clases que derivan de ella (Figura 18.17). Los más importantes son: DialogResult ShowDialog()

Este método despliega el cuadro de diálogo

void Reset() Pone los valores predeterminados. EventHandler HelpRequest

Este evento se lanza cuando el usuario pulsa el botón de ayuda en el cuadro de diálogo

El método más importante de CommonDialog es ShowDialog() que devuelve un objeto de tipo DialogResult que en estos cuadros de diálogo puede tomar dos valores: DialogResult.OK si el usuario pulsa el botón Ok en el cuadro de diálogo. DialogResult.CANCEL, en cualquier otro caso.

Cómo utilizar los cuadros de diálogo estándar

En general, todas las clases que corresponden a cuadros de diálogo estándar son muy parecidas. Para presentar en pantalla el cuadro de diálogo se invoca el método ShowDialog() y éste, a su vez, invoca al método RunDialog(). Una vez que se ha cerrado el cuadro, ShowDialog() devuelve un objeto de tipo DialogResult que encapsula la información acerca de cómo el usuario ha interactuiado con la caja de diálogo.


19/27

En general, los pasos a seguir para utilizar un cuadro de diálogo estándar son:

• Crear una instancia del cuadro de diálogo. • Definir las propiedades y estado del cuadro de diálogo. Este paso puede

también hacerse en tiempo de diseño. • Llamar al método ShowDialog() y esperar la actuación del usuario.

Suponga, por ejemplo que se desea llamar al cuadro de diálogo correspondiente a abrir un fichero. Después de haber realizado los tres pasos anteriores, el usuario selecciona un fichero y pulsa el botón OK. Se asocia a la propiedad FileName el nombre del fichero que se ha selecionado, se cierra el cuadro y se chequea si el valor devuelto por el método ShowDialog() es DialogResult.Ok. Después se leen las propiedades que se necesiten del cuadro de diálogo. El código podría ser:

string nombreFichero; OpenFileDialog dlg=new OpenFileDialog(); dlg.Title= "Cuadro de dialogo Abrir"; if(dlg.ShowDialog()==DialogResult.OK) nombreFichero = dlg.FileName; else //OtroMetodo();

Realmente, para abrir el cuadro de diálogo, sólo son necesarias estas dos líneas de código: OpenFileDialog dlg=new OpenFileDialog(); dlg.ShowDialog(); Observe que el cuadro de diálogo sólo selecciona el fichero y no lo abre. Para ello. el programador debe escribir un determinado código. El resto de los cuadros de dialogo estándar funcionan de una manera muy parecida pero cada uno de ellos tiene una funcionalidad específica y pueden seleccionar de manera visual un fichero, una fuente, un color, etc... y lo asignan a la propiedad correspondiente. Si se ejecuta el código anterior, por ejemplo, desde un botón, se despliega en la pantalla el formulario de la figura 18.18:


20/27

Figura 18.18. Cuadro de diálogo estándar para abrir ficheros. A continuación, se estudian con cierto detalle algunas de las clases correspondientes a los distintos cuadros de diálogo.

La clase FileDialog

FileDialog es una clase abstracta y no puede ser instanciada directamente. De esta clase heredan las clases OpenFileDialog y SaveFileDialog.

FileDialog es un cuadro de diálogo modal.

Propiedades

bool AddExtension Indica si se añade una extensión de un tipo de fichero si el usuario omite la extensión.

bool CheckFileExists Indica si se presenta un cuadro de diálogo de aviso si el usuario especifica un nombre de fichero que no existe.

bool CheckPathExists Indica si se presenta un cuadro de diálogo de aviso si el usuario especifica un path que no existe.

string DefaultExt La extensión por defecto. Por defecto, si no se ha especificado ninguna, se añade esta extensión a los ficheros cuando el usuario guarda el fichero.

string FileName Es un string con el nombre del fichero seleccionado en el cuadro de diálogo.

string[] FileNames Obtiene todos los ficheros seleccionados en el cuadro de diálogo.

string Filter Determina el “filtro” que determina los tipos de ficheros que aparecen en las cajas de texto “Guardar como tipo


21/27

…” o “Tipo de archivo….” int FilterIndex El índice del filtro actualmente seleccionado. El primer

índice es el 1. string InitialDirectory Directorio inicial al abrirse el cuadro de diálogo. bool RestoreDirectory Especifica si se restaura los valores del cuadro de diálogo

antes de cerrarlo. bool ShowHelp Indica si se despliega el botón Help en el cuadro de

diálogo. string Title Título del cuadro de diálogo.

Eventos

CancelEventhandler FileOk Ocurre cuando el usuario pulsa el botón Abrir o Guardar del cuadro de diálogo.

Las clases OpenFileDialog y SaveFileDialog

El objetivo final de estos controles es proporcionar el nombre de un fichero de forma segura y visual. El nombre del archivo viene especificado en la propiedad FileName del diálogo.

Representan dos cuadros de diálogo que presentan en pantalla controles que permiten seleccionar un fichero, abrirlo o salvarlo chequeando si el fichero existe o no. La propiedad ShowReadOnly determina si aparece un CheckBox en el cuadro para indicar la opción de sólo lectura. La propiedad ReadOnlyChecked indica el estado del CheckBox de sólo lectura.

Ambas clases tienen miembros muy parecidos, por lo que se estudiarán juntas. La mayor parte de la funcionalidad de estas clases la proporciona la clase FileDialog. A continuación se estudian los miembros de FileDialog.

Propiedades

bool Multiselect Indica si puede hacerse una selección múltiple o no. bool ReadOnlyChecked Indica si el CheckBox está seleccionado o no. bool ShowReadOnly Indica si el cuadro de diálogo contiene una opción –un

CheckBox- de sólo lectura.

Métodos

Stream OpenFile() Abre el fichero especificado en la propiedad FileNameseleccionado por el usuario con permiso de sólo lectura.

Por ejemplo, éste podía ser un código para este control:

Stream miStream; OpenFileDialog openDialog = new OpenFileDialog(); openDialog.InitialDirectory = "c:\\" ;


22/27

openDialog.Filter = "txt files (*.txt)|*.txt|All files (*.*)|*.*" ; openDialog.FilterIndex = 2 ; openDialog.RestoreDirectory = true ; if(openDialog.ShowDialog() == DialogResult.OK) { if((miStream = openDialog.OpenFile())!= null) { // Código para leer el Stream. miStream.Close(); } } Las dos siguientes propiedades son específicas de la clase SaveFileDialog. bool CreatePrompt Indica si el usuario puede crear un fichero que no existe. bool OverwritePrompt Indica si el cuadro de diálogo Guardar como despliega un

aviso especificando el fichero que ya existe.

La clase ColorDialog

Esta clase se utiliza para seleccionar un color mediante un cuadro de diálogo. Su aspecto es el de la figura 18.19.

Figura 18.19. Cuadro de dialogo Color

Propiedades.

bool AllowFullOpen Indica si el usuario puede utilizar el cuadro de diálogo para definir colores personalizados.


23/27

bool AnyColor Indica si el cuadro de diálogo presenta todos los colores disponibles del juego básico de colores.

Color Color Color actual o color seleccionado por el usuario. bool CustomColors Indica si se pueden definir colores personalizados. bool FullOpen Indica si se enseña el cuadro de diálogo completo, es decir,

con la parte de los colores personalizados. bool ShowHelp Indica si hay botón de ayuda en el cuadro de diálogo.

La clase FontDialog

Esta clase se utiliza para la selección de una fuente. Su aspecto es el de la figura 20.

Figura 18.20. Cuadro de diálogo Fuente

Propiedades

Color Color Indica el color de la fuente seleccionada. Font Font Indica la fuente actual o la fuente seleccionada por el usuario. int MaxSize Indica el valor de tamaño máximo de la fuente. int MinSize Idem, mínimo. bool ShowApply Indica si el cuadro de diálogo tiene botón Aplicar. bool ShowColor Indica si el cuadro de diálogo proporciona la opción de color de la

letra. bool ShowEffects Indica si el cuadro de diálogo contiene controles que permitan

especificar las características de tachado, subrayado y color del texto.

bool ShowHelp Indica si se presenta en el cuadro de diálogo un botón de ayuda.


24/27

Ejemplo: trabajando con cuadros de diálogo estándar y el control RichTextBox: Un sencillo editor de textos.

A continuación se implementa un sencillo editor de textos con una serie de menús que permite cambiar la fuente y el color, así como abrir y salvar ficheros de texto. Se utiliza un control que no ha sido estudiado, RichTextBox, que es una caja de texto enriquecido. Dicho control tiene dos métodos para leer y guardar un fichero en formato RTF o de texto La estructura de estos dos métodos es la siguiente:

public void LoadFile(string nombreDelFichero);

public void SaveFile(string nombreDelFichero); El aspecto final de la aplicación es el de la figura 21. Los pasos necesarios para implementar la aplicación son los siguientes:

a) Cree un nuevo proyecto y llámelo ProyectoDialogosEstandar. b) Cambie el nombre del fichero Form1.cs a ProcesadorDeTextos.cs. c) Cambie las siguientes propiedades del formulario:

Name: ProcesadorDeTextos Text: Procesador de Textos Cambie la línea del método Main() Application.Run(new Form1()); por la línea: Application.Run(new ProcesadorDeTextos()); OJO con esto que puede ser sólo para la versión beta

d) Sitúe un control RichTextBox en el formulario con las siguientes propiedades: Name: texto

Text: (Vacío) Dock: Fill Con esta última propiedad se asegura que siempre que se redimensione la ventana del formulario también se redimensiona la superficie del control para ocupar toda la superficie del formulario.

e) Añada un control MainMenu al formulario con las propiedades siguientes: Name: menu Opciones de Menu: Diseñe el menú con dos opciones principales, Archivo y Formato y en cada una de ellas las siguienetes opciones de menú: Menu Propiedades Propiedad Text


25/27

Archivo mArchivo Archivo

Nuevo mNuevo Nuevo

Abrir mAbrir Abrir

Guardar mGuardar Guardar

- (Signo -) mSeparador -

Salir mSalir Salir

Formato mFormato Formato

Fuente mFuente Fuente

Color de fondo mColorFondo Color de fondo

f) Añada los cuatro controles siguientes con las propiedades que se indican:

• OpenFileDialog Name: dlgAbrir Filter: Documentos de text (*.txt)|*.txt|Todos (*.*)|*.* Default Ext: txt ShowHelp: True ShowReadOnly: False Title: Diálogo Abrir fichero

• SaveFileDialog Name: dlgGuardar AddExtension: true Filter: Documentos de text (*.txt)|*.txt|Todos (*.*)|*.* FileName: doc1 Default Ext: txt RestoreDirectory: False ShowHelp: True Title: Diálogo Guardar fichero

• ColorDialog Name: dlgColor AllowFullOpen: True FullOpen: False ShowHelp: True SolidColorOnly: False

• FontDialog Name: dlgFuente ShowApply: True ShowColor: True ShowEffects: True ShowHelp: True


26/27

Figura 18.21. Editor de textos g) Cree un miembro privado, denominado nombreFichero de tipo string, e

inícielo en el constructor del formulario de la siguiente manera: //miembro private string nombreFichero; //constructor public ProcesadorDeTextos() { InitializeComponent(); nombreFichero="Sintitulo"; this.Text=nombreFichero; }

h) Escriba, para cada una de las opciones de menú, el siguiente código:

Menú Nuevo:

private void mNuevo_Click(object sender, System.EventArgs e) { nombreFichero="Sintitulo"; texto.Clear(); this.Text=nombreFichero; } Menú Abrir: private void mAbrir_Click(object sender, System.EventArgs e) { if(dlgAbrir.ShowDialog() == DialogResult.OK){ nombreFichero=dlgAbrir.FileName; texto.LoadFile(nombreFichero); this.Text=nombreFichero; } } Menú Guardar private void mGuardar_Click(object sender, System.EventArgs e) { if(dlgGuardar.ShowDialog() == DialogResult.OK)


27/27

{ nombreFichero=dlgAbrir.FileName;

texto.SaveFile(nombreFichero); this.Text=nombreFichero;

} } Menú Salir private void mSalir_Click(object sender, System.EventArgs e) { Application.Exit(); } Menú Fuente private void mFuente_Click(object sender, System.EventArgs e) { if(dlgFuente.ShowDialog() == DialogResult.OK) { texto.Font=dlgFuente.Font; texto.ForeColor=dlgFuente.Color; } } Menú Color de Fondo: private void mColorFondo_Click(object sender, System.EventArgs e) { if(dlgColor.ShowDialog() == DialogResult.OK) texto.BackColor=dlgColor.Color; }

Guarde, compile y ejecute la aplicación. Compruebe las distintas posibilidades del programa. Observe que en el título de la aplicación se escribe el nombre completo del fichero (Figura 18.21).

Documents

Cuadros de diálogo - University of the Basque Country ...ehu.eus/mrodriguez/archivos/csharppdf/WinForms/CuadrosDialogo.pdf · Marco Besteiro y Miguel Rodríguez Cuadros de Diálogo