Mostrando entradas con la etiqueta Cursos. Mostrar todas las entradas
Mostrando entradas con la etiqueta Cursos. Mostrar todas las entradas

lunes, 21 de noviembre de 2016

1.2.2 ToggleButton - GTK#

11/21/2016
Los botones biestado derivan de los botones normales, como su nombre lo indica pueden tomar dos estados representados en un estado 'normal' y otro 'oprimido', permitiéndonos asociar esto con una variable booleana que requiramos en nuestros formularios.

//Constructores de los botones biestado

boton_biestado1 = new ToggleButton ();
boton_biestado2 = new ToggleButton (string);

La propiedad Active de los ToggleButton nos permite forzar el estado del botón a uno preciso, u obtener el valor de este., la manera más sencilla de hacer esto sería con una retrollamada parecidada a:

//Añadido al evento Clicked o Toggled

private void OnButtonToggled(object obj, EventArgs args)
{ 
   ToggleButton boton_biestado1 = (ToggleButton) obj;
  
   if (boton_biestado1.Active) {
      //Botón oprimido
   } else {
      //Estado normal
   }
}

Tener en cuenta que si se cambia el estado del ToggleButton se hace una llamada a los eventos Clicked y Toggled.

Ejemplo.

El ejemplo que se muestra a continuación corresponde a la imagen del inicio de la entrada, el programa funciona de manera muy sencilla, solo modificando el string del Label del ToggleButton, haciendo que el mensaje desplegado sea "Activo" si el Active es true, o "Inactivo" en caso contrario.


public class VentanaPrincipal : Window
{
   HBox conGen;
   ToggleButton botonBiestado;
   
   public VentanaPrincipal () : base ("ToggleButton - GTK#")
   {
      SetSizeRequest (300, 300);
      BorderWidth = 90;
      WindowPosition = WindowPosition.CenterAlways;
      DeleteEvent += delegate {
         Application.Quit ();
      };

      botonBiestado = new ToggleButton ("Estado");
      botonBiestado.Toggled += new EventHandler (OnButtonToggled);

      conGen = new HBox (false, 0);
      conGen.PackStart (botonBiestado);

      Add (conGen);
      ShowAll ();

   }
   
   private void OnButtonToggled(object obj, EventArgs args)
   { 
      ToggleButton boton_biestado1 = (ToggleButton) obj;
      
      if (boton_biestado1.Active) {
         botonBiestado.Label = "Activo";
      } else {
         botonBiestado.Label = "Inactivo";
      }
   }
}

martes, 15 de noviembre de 2016

1.2.1 Button - GTK#

11/15/2016
Explicar el funcionamiento de un botón normal no tiene caso, todos sabemos su funcionamiento, así que pasemos a los constructores básicos, dotados de una capacidad de personalización básica muy útiles:

//Constructores de los botones biestado

boton_normal1 = new Button ();
boton_normal2 = new Button (string);
boton_normal3 = new Button (Widget);

El primer constructor crea un botón por defecto sin ninguna etiqueta, el segundo constructor nos permite incluir un string que si es un texto cualquiera, definirá el texto de la etiqueta del botón, a la cual podremos acceder mediante el propiedad Label que nos permite obtener y establecer dicho texto, o también podremos utilizar en lugar de un string una propiedad Stock podremos elegir un ícono del stock y un texto. El último constructor nos da la mayor posibilidad de personalización permitiéndonos usar los botones como contenedores, y así es pues los botones derivan de esto, pudiendo utilizar este recurso para darle nuestro toque, la mejor manera es la mostrada en el ejemplo.



Ejemplo

En el ejemplo se muestra la programación de un botón sencillo con una imagen y un texto personalizados. Dando como resultado lo siguiente (lo mostrado en la enterior imagen):


public class VentanaPrincipal : Window
{
   HBox conGen;
   Button botonNormal;
   HBox box;
   Label labelButton;
   Image imageButton;

   public VentanaPrincipal () : base ("Button - GTK#")
   { 
      //Se cambia el tamaño de la ventana
      SetSizeRequest (300, 300);
      //Se establece el padding de la ventana en 60px
      BorderWidth = 60;
      //Se centra la ventana
      WindowPosition = WindowPosition.CenterAlways;
      //Se añade el evente de cierre a la ventana
      DeleteEvent += delegate {
         Application.Quit ();
      };

      //Se crea la 'caja' del botón
      box = new HBox(true, 0);
      box.BorderWidth = 2;

      //Se crea la imagen del botón y se asigna
      imageButton = new Image();
      imageButton.File = "imagen.png";

      //Se crea el label del botón
      labelButton = new Label("Texto");
     
      // Empaquetamos la imagen y la etiqueta en la caja
      box.PackStart(imageButton, false, false, 3);
      box.PackStart(labelButton, false, false, 3);

      //Creamos el botón, pasándole el contenedor
      botonNormal = new Button (box);

      //Creamos un contenedor general y añadimos nuestro botón
      conGen = new HBox (false, 0);
      conGen.PackStart (botonNormal);
      //Añadimos el contenedor general a la ventana
      Add (conGen);
      //Mostramos todo
      ShowAll ();
   }
}

lunes, 14 de noviembre de 2016

1.1.1 Box y ButtonBox - GTK#

11/14/2016

Los Box serán los contenedores destinados a ordenar que más utilizaremos, de esta clase derivan tres clases importantes para este fin: HBox, VBox, ButtonBox. Esta última deriva en otras dos VButtonBox y HButtonBox.

La diferencia entre un Box y un ButtonBox es que el segundo se usa para empaquetar un tipo específico de control. Siendo muy utilizado para crear menús de botones de una manera rápida. La diferencia entre un VBox y un HBox y entre un VButtonBox y un HButtonBox es la misma: los que empiezan por V hacen referencia a un Box vertical, y los que empiezan por H hacen referencia a un Box horizontal.

Funcionan de cierta manera como una lista, permitiéndonos manejar su tamaño dinámicamente añadiendo y eliminando controles según lo necesitemos. Las dos maneras más usadas de añadir son los métodos PackStart y PackEnd agregando el control al inicio o al final del contenedor respectivamente.


contenedor.PackStart (widget);
contenedor.PackStart (widget, bool, bool, uint);

contenedor.PackEnd (widget);

contenedor.PackEnd (widget, bool, bool, uint);



Como primer parámetro se pasará el control que queremos empaquetar, el segundo parámetro establece el valor de expand: si es true, el espacio que ocupe el control dentro del contenedor será el mayor que pueda utilizar, si es false, el control ocupará solo el espacio necesario; el tercer parámetro corresponde al valor de fill: si es true, el control 'llenará' el excedente de la caja, el parámetro fill en true solo surge efecto si el parámetro expand es true. El tercer parámetro corresponde al padding del control dentro del contenedor, está definicdo por un entero no negativo (uint).

Todas las combinaciones de los bool expand y fill.

Con esta información aún no podemos hacer mucho, pues antes de decidirnos a usar un Box o un ButtonBox tendremos que definir si lo que necesitamos es uno horizontal o vertical, explicados posteriormente por separado.


Anterior: Contenedores
Siguiente: VBox y VButtonBox

domingo, 13 de noviembre de 2016

1.1 Contenedores - GTK#

11/13/2016
Los contenedores nos permiten empaquetar nuestros widgets para ordenarlos dentro de la ventana y que sean desplegados de la mejor manera posible al usuario del programa. Gtk usa un sistema de contenedores que hace la parte de ordenar de manera simple, pero suele costar acostumbrarse al uso de estos contenedores, pues tienen su propia lógica, no difícil, pero si diferente a otros métodos de posicionamiento a los que, por lo menos yo, estaba acostumbrado antes de utilizar GTK#.

Un contenedor, entonces, no es más que un tipo especial de control, dentro del cual podremos añadir otros controles, para ordenarlos dentro de éste llamado contenedor padre, pues dentro de un contenedor podemos empaquetar otro u otros contenedores, jugando con esto es que se consigue interfaces bien ordenadas de una manera rápida.

Pese a esta definición no se debe pensar que los contenedores son solo cajas donde ordenar, pues también los botones derivan de la clase Container permitiéndonos, por ejemplo, añadir en el botón una imagen (Image); también son contenedores las ventanas (Window). Dentro de una ventana o un botón solo se puede añadir un widget. Aunque tanto botones como ventanas, y otros controles, se cataloguen como contenedores, no se hablará de ellos en esta sección, si no en otras más específicas que describan mejor sus usos. En esta sección se tratará, sobre todo, los contenedores invisibles para empaquetar y ordenar nuestro otros controles.

Mediante el método Add() de la clase Container se puede añadir un widget al cotenedor

container.Add (widget);

Los tipos más utilizados de contenedores son:

  • Box
  • ButtonBox
  • Frame
  • Table

Cada uno de estos contenedores se tratan individualmente en posteriores entregas.

Anterior: Controles

sábado, 12 de noviembre de 2016

1. Controles - GTK#

11/12/2016
La librería Gtk es la que nos provee de las clases necesarias para desarrollar las interfaces gráficas de nuestros programas, de aquí nos proveeremos de los 'controles' que nos permitirán ir dándole forma, algo que será mucho más claro conforme avancen los cursos.

Los controles, también llamado widgets, son todos aquellos elementos que conforman nuestra GUI, siendo estos los botones, las ventanas, las etiquetas, las entradas de texto, y un largo etc...

Decir también que en el curso se utilizará indistintamente tanto las palabras control como widget, para referirse a lo mismo.

Un control es una clase, por lo tanto está dotado de una seria de atributos, métodos y eventos, que nos darán control sobre cualquier aspecto de la interacción del usuario con nuestro programa, como pulsar una tecla, cerrar una ventana o quitar el focus de una entrada de texto. Estos son aspectos importantes que se tratan por separado en cada control.

Todos los controles derivan de la clase object. Hay controles especiales llamados Contenedores, que derivan de container y se tratarán en la siguiente página, imprescindibles a la hora de ordenar nuestros controles, en GTK no se utilizan coordenas ni locales ni globales para movernos en dentro de un control, es decir, no pondremos algo del tipo

control.x = 0;
control.y = 0;



ó

control.SetPosition (0, 0);


en cambio se utilizan los contenedores, que, bien utilizados, nos facilitan la tarea de ordenar los controles en la ventana de manera de cierta forma responsiva, tema tratado en la próxima entrega.

Anterior: ¿Qué es GTK#?

viernes, 11 de noviembre de 2016

0.1 ¿Qué es GTK#? - GTK#

11/11/2016
GTK+ o The GIMP Toolkit es un conjunto de bibliotecas multiplataforma para desarrollar interfaces gráficas de usuario (GUI), principalmente para los entornos gráficos GNOME, XFCE y ROX aunque también se puede usar en el escritorio de Windows, Mac OS y otros. "  Wikipedia

 El texto anterior, extraído del artículo de GTK+ de Wikipedia, describe perfecta y sencillamente lo que es GTK+, y GTK# es lo mismo, solo que es la librería para programar con el lenguaje de programación orientada a objetos C#.

De manera breve la historia de GTK+ nos cuenta que surgió después de ser utilizado para la creación de GIMP, un programa de edición de imágenes en Linux, pasando a ser de uso libro libre y multiplataforma.



Tiene licencia LGPL premitiendo crear tanto software libre como propietario.

GTK+ se basa en las siguientes bibliotecas:

  • GLib: Biblioteca de bajo nivel estructura básica de GTK+ y GNOME. Proporciona manejo de estructura de datos para C, portabilidad, interfaces para funcionalidades de tiempo de ejecución como ciclos, hilos, carga dinámica o un sistema de objetos.
  • GTK: Biblioteca la cual realmente contiene los objetos y funciones para crear la interfaz de usuario. Maneja widgets como ventanas, botones, menús, etiquetas, deslizadores, pestañas, etc. Es en esta en la que se basa el curso, en su mayoría.
  • GDK: Biblioteca que actúa como intermediario entre gráficos de bajo nivel y gráficos de alto nivel.
  • ATK: Biblioteca para crear interfaces con características de una gran accesibilidad muy importante para personas discapacitadas o minusválidos. Pueden usarse utilerías como lupas de aumento, lectores de pantalla, o entradas de datos alternativas al clásico teclado o ratón.
  • Pango: Biblioteca para el diseño y renderizado de texto, hace hincapié especialmente en la internacionalización. Es el núcleo para manejar las fuentes y el texto de GTK+2.
  • Cairo: Biblioteca de renderizado avanzado de controles de aplicación.

Las librerías que utilizaremos en el curso serán Glib, Gtk, Gdk y Pango; en mayor o menor medida.



jueves, 10 de noviembre de 2016

0. Introducción al curso - GTK#

11/10/2016
En este punto inicia el curso de GTK#, concepto en el que ahondaremos en la siguiente entrada, pero por ahora lo definiremos como una librería para crear interfaces gráficas de usuario (GUI) en lenguaje C#. Primero dejar claro que el posterior curso no es de GTK+, es de su derivado usado exclusivamente para programar con C#: GTK#.

Lo más importante a definir en este momento es los conocimientos previos recomendados para quienes quieran seguir el curso:

  • Fundamentos de programación
  • POO (Programación orientada a objetos)
  • C# básico

Hay que dejar claro otro punto: con este curso no pretendo hacer un 'paso a paso' de lo que yo hago para que sea imitado por quien lo lea; más bien quiero brindar la documentación, los ejemplos y lo más útil para crear mejores GUI's para nuestros programas, por esto se hablara menos de otros complementos de GTK como Glib o Pango.
No es un curso de programación, por lo que no se hará énfasis en las palabras reservadas del lenguaje de programación utilizado (C#) ni del entorno de desarrollo utilizado (Monodevelop).

Cualquier comentario será gratamente recibido. Sin más, aquí empieza el curso.




Lo último

recentposts

Random

randomposts