7 Controles check y radio

Los controles de check, encapsulados en la clase wxCheckBox se usan para capturar datos booleanos, que sólo pueden tener dos valores. Cuando la etiqueta que acompaña al control es verdadera el usuario activará la marca y cuando sea falsa la desactivará.

Existe la posibilidad de un tercer estado que permite no elegir uno de esos valores: marcado o no marcado, dejando el control en un estado indeterminado. Se puede usar cuando el valor de otro de los controles del formulario hace innecesario capturar este valor concreto, o por si el usuario no puede o no quiere establecer un valor concreto.

Si tenemos que crear un formulario con múltiples controles check podemos usar la clase wxCheckListBox que nos permite crear y manejar un grupo de controles check usando una única clase.

También disponemos de la clase wxToggleButton, que es el mismo control, pero con la apariencia de un botón. Un botón normal se comporta como un pulsador, cuando el usuario deja de pulsar el botón del ratón sobre él, vuelve a su estado desactivado. Un wxToggleButton se comporta como un interruptor de tecla, cuando se activa pasa del estado no pulsado a pulsado o de pulsado a no pulsado, permaneciendo en ese estado final indefinidamente.

El control wxBitmapToggleButton es igual, pero contiene un mapa de bits en lugar de un texto.

Por otra parte, los controles radio, encapsulados en la clase wxRadioButton aunque sólo pueden tener dos estados, marcado o no marcado, están pensados para capturar una opción entre varias. Están diseñados para trabajar en grupos, de modo que sólo uno de ellos tiene que estar marcado. Cuando el usuario marca uno de los controles de radio, el que tenía la marca previamente en su mismo grupo, la perderá.

Trabajar con wxRadioButton es un poco incómodo, ya que nos obliga a crear los grupos añadiendo los controles de uno en uno, y a marcar los inicios de grupo. wxWidgets nos ofrece la clase wxRadioBox, que nos permite crear un grupo entero con una única clase.

Control CheckBox

Estos controles son muy sencillos, ya que su dominio de valores posibles es muy pequeño.

Como en todos los controles que hemos visto hasta ahora, los primeros seis parámetros del constructor son siempre los mismos: ventana padre, identificador, etiqueta, posición, tamaño y estilo.

Estilos

Para estos controles disponemos de varios estilos interesantes:

• wxCHK_2STATE es el estilo por defecto, que crea un control de dos estados.
• wxCHK_3STATE que permite crear un control de tres estados.
• wxCHK_ALLOW_3RD_STATE_FOR_USER, que combinado con el estilo anterior, además de crear un control de tres estados, permite al usuario establecer los tres estados. Por defecto, para establecer el tercer estado se debe hacer por código. El usuario siempre puede activar un checkbox desactivado, pero no podrá desactivar un control de tres estados si no se usa este estilo.

Además, para controles checkbox de dos estados podemos usar en el séptimo parámetro un validador genérico, lo que nos ahorra tiempo a la hora de establecer valores iniciales y recuperar su valor:

    wxGenericValidator val1(&data.check1);
...
    m_checkBox1 = new wxCheckBox(this, idCheckBox, _T("Opción 1"), wxDefaultPosition, wxSize(200, wxDefaultCoord), wxCHK_2STATE, val1);
...

Establecer y recuperar valor

Si durante el programa tenemos que modificar el estado del control podemos usar el método SetValue.

    m_activar->SetValue(false);

Por supuesto, siempre podemos obtener el estado de un control checkbox de dos estados mediante el método GetValue, que devuelve un booleano con valor true si el checkbox está marcado.

También se puede usar el método IsChecked, que también devolverá true si el checkbox está marcado.

Para los checkboxes de tres estados no podemos usar validadores predefinidos, ni tampoco los dos métodos anteriores, de modo que tendremos que optar por obtener sus valores al cerrar el cuadro de diálogo, o bien procesar los eventos EVT_CHECKBOX que producen cuando cambia su valor.

wxBEGIN_EVENT_TABLE(checkBoxes, wxDialog)
...
    EVT_CHECKBOX(id3Estados2, On3Estados2)
...
wxEND_EVENT_TABLE()
...
void checkBoxes::On3Estados2(wxCommandEvent& event) {
    data.check4 = m_3estados2->Get3StateValue();
}

Para crear un checkbox de tres estados prescindiremos del validador y usaremos el estilo wxCHK_3STATE y opcionalmente wxCHK_ALLOW_3RD_STATE_FOR_USER.

Como no podemos usar un validador, tendremos que asignar el valor mediante el método Set3StateValue, indicando como parámetro es estado, del tipo enumerado wxCheckBoxState.

Este tipo enumerado define el valor wxCHK_UNCHECKED como 0, de modo que se puede usar este valor y wxCHK_CHECKED también con el método SetValue, ya que esos valores se convierten implícitamente a bool correctamente.

    m_3estados1 = new wxCheckBox(this, id3Estados1, _T("3 estados auto"), wxDefaultPosition, wxSize(200, wxDefaultCoord), wxCHK_3STATE);
    m_3estados1->Set3StateValue(data.check3);

El método adecuado para obtener el estado de un checkbox de tres estados es Get3StateValue, que devuelve un valor del enumerado wxCheckBoxState.

Otros dos métodos que pueden resultar útiles durante la ejecución son Is3State, que nos indicará si un control checkbox es de tres estados, es decir, si tiene el estilo wxCHK_3STATE, y Is3rdStateAllowedForUser, que nos indicará si el usuario puede desactivar un control de tres estados, es decir, si tiene el estilo wxCHK_ALLOW_3RD_STATE_FOR_USER.

Nota: En capítulos avanzados veremos cómo crear nuestros propios validadores, derivados de la clase abstracta wxValidator.

Control CheckListBox

Un wxCheckListBox es básicamente un control de tipo lista, cuyos elementos tienen una marca de selección. Podemos usarlos para crear listas de chequeo de una forma más sencilla y rápida que crear varios controles wxCheckBox.

El constructor para estos controles difiere un poco en el número y tipo de parámetros. Requiere un puntero a la ventana padre, un identificador, la posición y tamaño, el número de elementos, un array con las cadenas con las etiquetas de cada uno de los elementos, estilos, un validador y una cadena con el nombre del control.

No hay estilos propios para este control, pero se pueden usar los de wxListBox y el resto de clases de las que se deriva.

Validador para listbox

El constructor admite un validador, pero no existen validadores específicos para este tipo de controles, y el genérico no nos proporciona mucho control sobre ellos. De modo que es una buena oportunidad para crear nuestro propia clase validadora.

Como estos controles no requieren una validación específica, ya que cada opción sólo puede tomar dos valores, nuestro método Validate no requiere código, y bastará con que retorne true. En situaciones donde ciertos valores de alguna de las opciones condicionen los valores de otras opciones podemos derivar de esta primera clase, sobrecargando el método Validate.

Limitaremos la funcionalidad de nuestro validador a transferir datos a y desde el control.

Nuestra clase para validar controles CheckListBox quedará asi:

class clValidator : public wxValidator {
public:
    clValidator(std::vector<bool> *v=nullptr);
    virtual wxObject* Clone() const { return new clValidator(*this); }
    virtual bool TransferFromWindow();
    virtual bool TransferToWindow();
    virtual bool Validate(wxWindow * parent);
private:
    std::vector<bool> *m_valores;
    DECLARE_DYNAMIC_CLASS( clValidator )
    DECLARE_EVENT_TABLE()
};

Para almacenar los valores de cada una de las opciones del control usaremos un vector de valores booleanos. Y el validador almacenará un puntero a ese vector.

La implementación es bastante simple:

IMPLEMENT_DYNAMIC_CLASS( clValidator, wxValidator )
BEGIN_EVENT_TABLE( clValidator, wxValidator )
END_EVENT_TABLE()

clValidator::clValidator(std::vector *v) : wxValidator(), m_valores(v) {}

bool clValidator::TransferFromWindow()
{
    try {
        wxCheckListBox *clb = dynamic_cast<wxCheckListBox*>(m_validatorWindow);
        for(size_t i=0; i<m_valores->size(); i++)
            m_valores->at(i) = clb->IsChecked(i);
    }
    catch (...) {
        wxFAIL_MSG( _T("clValidator sólo funciona con wxCheckListBox"));
        return false;
    }
    return true;
}

bool clValidator::TransferToWindow()
{
    try {
        wxCheckListBox *clb = dynamic_cast<wxCheckListBox*>(m_validatorWindow);
        for(size_t i=0; i<m_valores->size(); i++) {
            clb->Check(i, m_valores->at(i));
        }
    }
    catch(...) {
        wxFAIL_MSG( _T("clValidator sólo funciona con wxCheckListBox"));
        return false;
    }
    return true;
}

bool clValidator::Validate(wxWindow* parent)
{
    return true;
}

De este modo se simplifica mucho la inicialización y recuperación del estado de cada elemento de la lista.

Ahora podemos crear el control:

    wxString cads[] = {
        _T("Opción 1"),
        _T("Opción 2"),
        _T("Opción 3"),
        _T("Opción 4")
    };

    m_checkListBox = new wxCheckListBox(this, idCheckList, wxDefaultPosition, wxSize(200, wxDefaultCoord), 
        sizeof(cads)/sizeof(cads[0]), cads, 0, clValidator(&data.check));

Disponemos de otro constructor que en lugar del número de cadenas y el array usa un wxArrayString que contiene las cadenas con las opciones.

Esta clase disponemos de otros métodos interesantes, algunos los hemos usado para crear nuestra clase validadora.

Activar opciones

El método Check activa o desactiva la marca de una de las opciones. Requiere dos parámetros, el primero es el índice de la opción a modificar, y el segundo es un bool que si es true (por defecto) activa la marca, y si es false la desactiva.

El método IsChecked devuelve el estado de la marca para un elemento. En el parámetro indicaremos el índice del elemento cuyo estado queremos recuperar.

Al método GetCheckedItems le pasamos una referencia a un array, de la clase wxArrayInt, de enteros que nos será devuelva con los índices de los elementos cuya marca esté activa.

Eventos

Otra alternativa para manejar estos controles es procesar el evento EVT_CHECKLISTBOX. El método GetInt de la referencia al objeto wxCommandEvent recibido por el método asociado contendrá el índice cuyo estado de marca haya cambiado:

wxBEGIN_EVENT_TABLE(checklist, wxDialog)
    EVT_CLOSE(checklist::OnClose)
    EVT_CHECKLISTBOX(idCheckList, OnChecklist)
wxEND_EVENT_TABLE()
...
void checklist::OnChecklist(wxCommandEvent& event) {

    int indice = event.GetInt();
    bool estado = m_checkListBox->IsChecked(indice);
    wxString cad;
    cad << _T("Indice: ") << indice << _T(" ") << (estado ? _T("marcado") : _T("no marcado"));
    wxMessageBox(cad, _T("Respuesta"));
}

Controle ToggleButton y BitmapToggleButton

Un wxToggleButton es un wxCheckBox con la apariencia de un botón. Funciona como un botón, pero al contrario que estos, cuando se hace click sobre él se mantiene pulsado, y al hacer clic de nuevo vuelve a su estado normal. De modo que el control puede tener dos posibles estados: pulsado o no pulsado.

El constructor es bastante genérico en cuanto a parámetros: ventana padre, identificador, etiqueta, posición, tamaño, estilo, validador y nombre.

Al igual que en el caso de los wxCheckListBox, podríamos crear una clase validadora, pero son controles sencillos que se suelen usar dentro del propio diálogo o ventana en la que se añaden. En cualquier caso, podemos usar un wxGenericValidator para las tareas de obtener y establecer el estado del control.

Sólo dispone de dos métodos, además de constructores y destructores:

    m_toggleButton = new wxToggleButton(this, idtoggleButton, "Pulsa", wxDefaultPosition, 
        wxSize(200, wxDefaultCoord), 0, wxGenericValidator(&data.valor));

Valores

GetValue que devuelve true si el botón está pulsado y false si no lo está.

SetValue que permite establecer el estado mediante un parámetro con valor true para que esté pulsado y false para no pulsado.

Eventos

También responde al evento EVT_TOGGLEBUTTON, que se envía cada vez que el usuario activa el control.

wxBEGIN_EVENT_TABLE(toggleButton, wxDialog)
    EVT_CLOSE(toggleButton::OnClose)
    EVT_TOGGLEBUTTON(idtoggleButton, OnClick)
    EVT_TOGGLEBUTTON(idtoggleNotificar, OnNotificar)
wxEND_EVENT_TABLE()
...
void toggleButton::OnNotificar(wxCommandEvent& event) {
    notificar = m_toggleNotificar->GetValue();
}

Los wxBitmapToggleButton son similares, pero en lugar de un texto para la etiqueta muestran un mapa de bits.

La única diferencia en cuanto a métodos y eventos es que el constructor, en su tercer parámetro contiene una referencia a un wxBitmapBundle en lugar de una referencia a una wxString.

En el futuro trataremos los wxBitmapBundle con más detalle, por ahora nos basta con crearlos a partir de un mapa de bits, usando un objeto wxBitmap.

Ya hemos usado anteriormente este mecanismo, en el capítulo 1, cuando hablamos de los menús con imágenes.

Usaremos un fichero de recursos, al que añadiremos nuestro mapa de bits:

bell    RCDATA  "bell.png"

También tendremos que incluir el fichero de cabecera "imagpng.h" en este caso, ya que nuestra imagen tiene formato png.

Hay que añadir el manipulador para ficheros png a nuestro constructor de clase y crear los objetos wxBitmap y wxBitmapBundle:

    wxImage::AddHandler(new wxPNGHandler);
    wxBitmap bm = wxBITMAP_PNG(bell);
    wxBitmapBundle bitmap(bm);

Finalmente podemos usar el mapa de bits para crear el botón:

    m_toggleNotificar = new wxBitmapToggleButton(this, idtoggleNotificar, bitmap, wxDefaultPosition, wxSize(200, wxDefaultCoord));

Control RadioButton

Los controles wxRadioButton se usan para que el usuario pueda elegir una única opción entre varias mutuamente excluyentes.

Esto significa que nunca los encontraremos aislados, sino que siempre formarán parte de un grupo. Al seleccionar una de las opciones, la que estuviese previamente seleccionada perderá la marca.

Por lo tanto, estos controles deben poseer algún mecanismo que permitan determinar a qué grupo pertenecen, ya que ese comportamiento es automático.

Aunque en realidad esto no es siempre cierto, ya que tenemos la opción de crear controles wxRadioButton aislados, que no pertenecen a ningún grupo, y que no tienen un comportamiento automático para quitar la marca a otros controles. De modo que tendremos que decidir cómo se comportarán en nuestros programas.

Estilos

Para distinguir los controles que forman parte de un grupo de los aislados disponemos de dos estilos:

El estilo wxRB_GROUP se usa en el primer control de radio de un grupo, los siguientes controles para los que no se especifique este estilo formarán parte del mismo grupo.

El estilo wxRB_SINGLE crea un botón aislado, aunque no todas las plataformas lo soportan. Su utilidad es, por lo tanto, limitada.

El constructor tiene el formato habitual: ventana padre, identificador, etiqueta, posición, tamaño, estilo, validador y nombre.

En este caso tampoco disponemos de un validador específico para este tipo de controles, así que podríamos crear uno propio para inicializar y recuperar su estado.

Para crear los controles RadioButton de un grupo usaremos identificadores correlativos. Aunque esto no es obligatorio, siempre es recomendable, ya que puede facilitar mucho las tareas de crear validadores, inicializar valores o recuperarlos.

El primer control tendrá el estilo wxRB_GROUP, y el resto no.

    wxString cads[] = {
        _T("Opción 1"),
        _T("Opción 2"),
        _T("Opción 3"),
        _T("Opción 4")
    };
    rbValidator validator(&data.opcion);

    m_radioButton = new wxRadioButton(this, idRadioButton, cads[0], wxDefaultPosition, wxSize(200, wxDefaultCoord), 
        wxRB_GROUP, validator);

    for(size_t i = 1; i<sizeof(cads)/sizeof(cads[0]); i++) {
        m_radioButton = new wxRadioButton(this, idRadioButton+i, cads[i], wxDefaultPosition, wxSize(200, wxDefaultCoord), 
            0, validator);
    }

Validador

Una de las formas de inicializar y recuperar los datos es usar un validador a medida. Un validador útil para grupos de controles RadioButtons puede ser:

class rbValidator : public wxValidator {
public:
    rbValidator(int *v=nullptr);
    virtual wxObject* Clone() const { return new rbValidator(*this); }
    virtual bool TransferFromWindow();
    virtual bool TransferToWindow();
    virtual bool Validate(wxWindow * parent);
private:
    int *m_opcion;
    DECLARE_DYNAMIC_CLASS( rbValidator )
    DECLARE_EVENT_TABLE()
};

Y la implementación:

IMPLEMENT_DYNAMIC_CLASS( rbValidator, wxValidator ) BEGIN_EVENT_TABLE( rbValidator, wxValidator ) END_EVENT_TABLE() rbValidator::rbValidator(int *v) : wxValidator(), m_opcion(v) {}

El constructor sólo necesita un puntero a un entero. Para almacenar el valor de un grupo de RadioButtons sólo necesitamos un entero, que almacenará el índice del control activo.

bool rbValidator::TransferFromWindow()
{
    try {
        wxRadioButton *crb = dynamic_cast<wxRadioButton*>(m_validatorWindow);
        if(crb->GetValue()) {
            wxRadioButton *primero = crb->GetFirstInGroup();
            *m_opcion = crb->GetId()-primero->GetId();
        }
    }
    catch (...) {
        wxFAIL_MSG( _T("rbValidator sólo funciona con wxRadioButton"));
        return false;
    }
    return true;
}

Como hemos usado el mismo validador para todos los controles RadioButton, este método será invocado para cada elemento del grupo, pero a la hora de obtener el valor de la opción tenemos que tener en cuenta que sólo nos interesa detectar el control que tiene la marca. Por eso obtenemos el valor del control, mediante GetValue, y si es true buscamos el primer control del grupo, con GetFirstInGroup, y como los identificadores tienen valores correlativos, la diferencia entre identificadores será el índice del RadioButton marcado.

El método GetId de la clase base wxWindow nos devuelve el identificador del control.

bool rbValidator::TransferToWindow()
{
    try {
        wxRadioButton *crb = dynamic_cast<wxRadioButton*>(m_validatorWindow);
        wxRadioButton *primero = crb->GetFirstInGroup();
        if(crb->GetId()-primero->GetId() == *m_opcion) crb->SetValue(true);
    }
    catch(...) {
        wxFAIL_MSG( _T("rbValidator sólo funciona con wxRadioButton"));
        return false;
    }
    return true;
}

Para marcar el control correspondiente al índice activaremos el control con el valor de identificador correspondiente al del primer control más el valor de la opción. Localizamos el primer control del grupo mediante GetFirstInGroup.

bool rbValidator::Validate(wxWindow* parent)
{
    return true;
}

Activación

Otra forma de iniciar controles RadioButton, sin usar validadores, es simplemente buscar el control correspondiente y activarlo:

    wxRadioButton* activo = (wxRadioButton*)wxWindow::FindWindowById(idRadioButton+data.opcion, this);
    activo->SetValue(true);

El método FindWindowById localiza la ventana con el identificador indicado en el primer parámetro cuyo padre se indica en el segundo parámetro. Una vez localizado, solo tenemos que activarlo.

Para recuperar el valor tenemos dos opciones. O bien procesamos el evento producido al pulsar el botón de aceptar:

void radioButton::OnOk(wxCommandEvent& event) {
     wxRadioButton* activo = (wxRadioButton*)wxWindow::FindWindowById(idRadioButton, this);
     while(activo && !activo->GetValue()) activo = activo->GetNextInGroup();
     data.opcion = activo->GetId()-idRadioButton;
     EndModal(wxID_OK);
}

Localizamos el primer RadioButton del grupo mediante el método anterior, mediante su identificador, después recorremos los controles hasta que encontremos el activo usando el método GetNextInGroup. Una vez localizado, asignamos al dato la diferencia entre el identificador del control activo y el del primero.

Además de los métodos ya vistos, estos controles disponen de varios métodos útiles:

• GetLastInGroup: localiza el último control del grupo a partir de uno de los controles del grupo.
• GetPreviousInGroup: localiza el control anterior a partir de uno de los controles del grupo.

Eventos

Estos controles emiten eventos EVT_RADIOBUTTON cuando son activados. En general, las notificaciones de eventos EVT_RADIOBUTTON se usan para personalizar el funcionamiento del diálogo, y deberemos activar una notificación para cada control que queramos monitorizar.

Para generalizar un sistema para conjuntos de RadioButtons de cualquier número de elementos, en este caso puede ser interesante usar el método Connect para añadir notificaciones dinámicamente, en lugar de usar la tabla, que debe ser generada antes de la compilación.

    Connect(idRadioButton, wxEVT_RADIOBUTTON, (wxObjectEventFunction)&radioButton::OnRadioButton);
    Connect(idRadioButton+1, wxEVT_RADIOBUTTON, (wxObjectEventFunction)&radioButton::OnRadioButton);
...

De este modo, cada vez que se active una de las opciones que hemos conectado con el evento se invocará al método indicado, que puede ser el mismo para todos, o uno para cada opción que queramos tratar. Una vez ahí, podemos recuperar el identificador del control que ha generado el evento mediante el método GetId.

void radioButton::OnRadioButton(wxCommandEvent& event) {
    int sel = event.GetId();
    wxString cad;
    cad << _T("Opción: ") << sel - idRadioButton + 1;
    wxMessageBox(cad, _T("Seleccionada"));
}

Control RadioBox

Todo lo anterior es la forma "artesanal" de trabajar con RadioButtons. wxWingets nos proporciona otra clase, wxRadioBox para trabajar con conjuntos de RadioButtons de una forma más cómoda.

Los wxRadioBox tienen muchas ventajas con respecto a los wxRadioButtons.

• Crean un control estático de la clase wxStaticBox, con una etiqueta. Aunque nada nos impide añadir uno de estos controles estáticos a nuestros CheckBox o RadioButtons, esta clase lo hace por nosotros automáticamente.
• Admite el validador wxGenericValidator para inicializar y recuperar los datos del control, evitando la necesidad de crear nuestro propio validador o procesar botones e inicializar controles.
• Dispone de métodos para añadir textos de ayuda y tooltips, habilitar o deshabilitar y mostrar u ocultar opciones. De nuevo, esto es algo que podíamos hacer también con wxRadioButtons, pero acudiendo a métodos de las clases base wxWindow ywxControl.

En resumen, nos facilitan la vida.

Esta clase dispone de varios constructores. Además del constructor por defecto, tenemos dos más, uno en el que podemos especificar las cadenas de las opciones mediante un array C, y otro que admite un array de cadenas de la clase wxArrayString. Esto es similar a lo que ocurre con los controles wxCheckListBox, en este caso comentaremos la segunda forma.

En este caso, el constructor requiere los siguientes parámetros: ventana padre, identificador, etiqueta, posición, tamaño, el array con las opciones, un parámetro relacionado con la distribución de los controles en la ventana (majorDimension), estilo, validador y nombre.

El otro constructor sustituye el parámetro del array de opciones por dos parámetros, el número de opciones y el array C de cadenas de opciones.

Disponemos de dos estilos propios de este control:

• wxRA_SPECIFY_ROWS: El parámetro majorDimension indica el número máximo de filas de controles.
• wxRA_SPECIFY_COLS: El parámetro majorDimension indica el número máximo de columnas.

Esto permite distribuir los controles en una tabla, dando prioridad al orden por filas, e indicando un valor n para majorDimension, los controles se colocarán en orden en la primera fila, cuando se llegue a n se seguirán en la siguiente fila, etc.

Dando prioridad al orden por columnas, e indicando un valor m para majorDimension, los controles se colocarán en orden en la primera columna, cuando se llegue a m se seguirán en la siguiente columna, etc.

Un valor de cero para majorDimension mostrará una única fila o columna para el estilo wxRA_SPECIFY_ROWS, y una única fila para el estilo wxRA_SPECIFY_COLS.

   wxArrayString Opciones;
    Opciones.Add(_T("Opción 1"));
    Opciones.Add(_T("Opción 2"));
    Opciones.Add(_T("Opción 3"));
    Opciones.Add(_T("Opción 4"));
    Opciones.Add(_T("Opción 5"));
    Opciones.Add(_T("Opción 6"));

    m_radioBox = new wxRadioBox(this, idRadioBox, _T("Selecciona una"), wxDefaultPosition, wxDefaultSize, 
        Opciones, 3, wxRA_SPECIFY_ROWS, wxGenericValidator(&data.opcion));

Inhibir opciones

Se pueden inhibir opciones individuales mediante el método Enable, indicando en el primer parámetro el índice de la opción, y en el segundo un booleano, con valor true para activar y false para inhibir.

El método IsItemEnabled nos dice si una opción está activa o no. Indicaremos en el parámetro el índice de la opción a consultar. El valor de retorno nos dice si la opción está activa con valor true.

Asignar y recuperar valor

Además de validador, siempre podemos modificar la selección del control mediante el método SetSelection, indicando en el parámetro la opción que queremos seleccionar.

Para recuperar el valor de la opción seleccionada disponemos del método GetSelection.

Mostrar y ocultar opciones

Para ocultar o mostrar opciones se usa el método Show, indicando en el primero parámetro el índice de la opción y en el segundo un booleano, con valor true para mostrar y false para ocultar la opción.

Para averiguar si una opción está oculta usaremos el método IsItemShown, indicando el índice de la opción. El valor de retorno será true si la opción es visible.

Texto de ayuda

Para cada opción también podemos asignar un texto de ayuda, análogo a los textos de ayuda de las opciones de menú, que se mostrará en la barra de estado si está activada. Para establecer un texto de ayuda se usa el método SetItemHelpText, y como parámetros el índice y la cadena de ayuda asociada.

Puede que en general resulte más útil para esta tarea usar tooltips. También podemos asignar un tooltip a cada opción del control mediante el método SetItemToolTip, con los mismos parámetros.

Eventos

Los controles wxRadioBox generan eventos EVT_RADIOBOX cuando cambia la selección de opción. El método GetInt de wxCommandEvent nos devuelve el índice de la opción seleccionada.

Ejemplo 7

Nombre	Fichero	Fecha	Tamaño	Contador	Descarga
Ejemplo 7	wx007.zip	2024-12-02	13903 bytes	6