[SOLUCIONADO] Qt.QTableView. Varias dudas

[dehm]

Hola de nuevo:

Estaba trasteando de nuevo (es lo malo de retomar proyectos después de un año, aunque por otro lado uno se acerca con otras perspectivas y hay cosas que ahora se ven muy claras) con QTableView, y me ha surgido una batería de dudas:

1.- Como quiero que haya algunos comportamientos especiales a la hora de manejar el tabulador y cursores, entiendo que tengo que manejar esas teclas con eventos del teclado, lo que me obliga a hacer uso de la función installEventFilter() para la tabla.
Hasta ahí bien, sin embargo ahora me encuentro que la tecla F2 ya no activa el modo de edición, y no sé cómo hacer para que vuelva a tener esa funcionalidad.
Por otro lado, me gustaría que la tecla Supr eliminara la fila entera si ésta está seleccionada, o solo el contenido de la celda actual. No veo en QTableView ni en QAbstractItemView ninguna función que indique si hay una fila seleccionada.

2.- Me gustaría que cuando cambiase el contenido de una celda se activase una función o señal que llamase a una función que se encargara de hacer alguna función asociada (realmente sería actualizar el dato en la fuente original, más allá del modelo)
Mi intento ha sido crear un delegado, y dentro de la función createEditor(), a la hora de crear el widget de edición, añadir una señal, algo así como:

Código C++:

class DelegadoCiudades : public QStyledItemDelegate
{
 
public:
    DelegadoCiudades(QObject* parent);
    QWidget * createEditor(QWidget * parent, const QStyleOptionViewItem&option, const QModelIndex&index) const;
    void setEditorData(QWidget * editor, const QModelIndex&index)const;
    void setModelData(QWidget * editor, QAbstractItemModel * model, const QModelIndex&index) const;
 
public slots:
    void CambiarAlgo(int n);
};
 

Y luego en la función createEditor():

Código C++:

QWidget *DelegadoCiudades::createEditor(QWidget *parent,
                                        const QStyleOptionViewItem &option,
                                        const QModelIndex &index) const
{
    const QAbstractItemModel * model = index.model();
    if (!model) return QStyledItemDelegate::createEditor(parent,option, index);
    QComboBox * box = new QComboBox(parent);
    box->setEditable(true);
    box->setAutoCompletion(true);
    box->setModel(const_cast<QAbstractItemModel* >(model));
    box->setModelColumn(index.column());
    box->installEventFilter(const_cast<DelegadoCiudades * >(this));
    connect(box,SIGNAL(currentIndexChanged(int)),this,SLOT(CambiarAlgo(int)));//<--Aquí el invento
    return box;
}
 

Código C++:

void DelegadoCiudades::CambiarAlgo(int n)
{
    qDebug()<<"Cambiar Algo: "<<n;
 
}
 

Pero no me funciona la señal, cuando el editor (un QComboBox) cambia el índice me sale el error de que la función CambiarAlgo() no es un slot.

3.- Esta la pregunté hace un año, pero no fui capaz de resolver el tema incluso con la ayuda que recibí del foro (gracias @eferion )
El caso es que una de las columnas es un QComboBox donde se pide/muestra el sexo de una persona, pero en lugar de poner texto sale un pequeño icono de un niño o una niña (es para los sobrinos, je je). Pero para que me mantenga el índice actual cuando paso por esa celda en modo de edición, he de enviar junto al icono, el índice asociado, y entonces se me ve el icono junto a un número (0 niños, 1 niñas). Y me gustaría que no se viera el número pero que no se perdiera el índice.

Bueno, me ha salido un post largo y me explico como un libro cerrado, así que me disculpo de antemano.

Saludos
(voy a ver si consigo poner el ejemplo completo en github), si lo hago, actualizo el hilo

[eferion]

Iniciado por dehm

ahora me encuentro que la tecla F2 ya no activa el modo de edición

Con eso ahora mismo no puedo ayudarte. Quiero decir, no se qué cambios has realizado por lo que no puedo deducir qué tienes que cambiar para que vuelva a funcionar.

Publicar el código del filtro de eventos así como de su uso sería un buen punto de partida.

Iniciado por dehm

No veo en QTableView ni en QAbstractItemView ninguna función que indique si hay una fila seleccionada.

La selección corre a cargo de QItemSelectionModel. Mira en QTableView::selectionModel().

Iniciado por dehm

Me gustaría que cuando cambiase el contenido de una celda se activase una función o señal que llamase a una función que se encargara de hacer alguna función asociada (realmente sería actualizar el dato en la fuente original, más allá del modelo)

El modelo tiene un método llamado setData que es llamado cuando se realizan cambios en el modelo... prueba a colocar ahí la lógica correspondiente.

Código C++:

bool Modelo::setData(const QModelIndex &index, const QVariant &value, int role)
{
  if( role == Qt::EditRole )
    emit HaCambiadoElModelo();
}
 

Iniciado por dehm

El caso es que una de las columnas es un QComboBox donde se pide/muestra el sexo de una persona, pero en lugar de poner texto sale un pequeño icono de un niño o una niña (es para los sobrinos, je je). Pero para que me mantenga el índice actual cuando paso por esa celda en modo de edición, he de enviar junto al icono, el índice asociado, y entonces se me ve el icono junto a un número (0 niños, 1 niñas). Y me gustaría que no se viera el número pero que no se perdiera el índice.

Los modelos gestionan la información en base a roles. DisplayRole se llama cuando se quiere visualizar el contenido de la celda mientras que DecorationRole se usa para mostrar una imagen junto al contenido de la celda... por poner un par de ejemplos.

Siguiendo esa dinámica encuentras UserRole que sirve como punto de partida para definir roles personalizados. La idea es definir un rol personalizado para recuperar el identificador asociado a una imagen. La vista nunca va a preguntar por ese rol porque no sabe ni que existe ni tampoco qué hacer con el. Es un rol para tus usos propios:

Código C++:

const int ImageIndexRole = Qt::UserRole+1;
 
QVariant Modelo::data(const QModelIndex &index, int role) const
{
  switch( role )
  {
    case ImageIndexRole:
      // Devuelves el índice de la imagen
      break;
   }
}
 

Y para preguntar por este dato:

Código C++:

Modelo model;
QModelIndex index = model.index(0,0);
qDebug() << model->data(index,ImageIndexRole);
 

Un saludo.

[dehm]

Hola eferion:

Bueno, pues el tema del borrado ya está resuelto, usando ahora el método selectionModel() de la tabla (el borrado de la celda no está implementado pero vamos, que la duda principal era que al pulsar la tecla hubiera dos comportamientos, en función de si está la fila seleccionada o no)

Voy ahora a corregir lo de los iconos.

Adjunto cómo tengo resuelto el filtro de eventos (todavía me peleo con github y la verdad es que cualquiera de estos ejemplillos es demasiado extenso para pegar aquí el código completo).

Código C++:

bool Widget::eventFilter(QObject *watched, QEvent *e)
{
    if (e->type() == QEvent::KeyPress)
    {
        QModelIndex indice = tabla->currentIndex();        
        QKeyEvent *ke =static_cast<QKeyEvent*>(e);
        switch (ke->key())
        {
        case (Qt::Key_F5):
        {
            modelo->insertRow(indice.row());
            break;
 
        }
        case (Qt::Key_Delete):
        {           
            if (tabla->selectionModel()->isRowSelected(indice.row(),QModelIndex()))
            {
                modelo->removeRow(indice.row());
            }
            else
            {
                qDebug()<<"Borrar celda";
            }
            break;
        }
        case (Qt::Key_Tab):
        {          
            QModelIndex ind;
            if (indice.column() < modelo->columnCount(QModelIndex())-1)
            {
                ind = modelo->index(indice.row(), indice.column()+1);
            }
            else if (indice.row() == modelo->rowCount(QModelIndex())-1
                     && indice.column() == modelo->columnCount(QModelIndex())-1
                     && !NombreVacio())
            {
                modelo->insertRow(modelo->rowCount(QModelIndex()));
                ind = modelo->index(indice.row()+1,0);
 
            }
            else if (indice.row() == modelo->rowCount(QModelIndex())-1
                     && indice.column() == modelo->columnCount(QModelIndex())-1
                     && NombreVacio())
            {
                ind = modelo->index(indice.row(),indice.column());
            }
            else if (indice.column() == modelo->columnCount(QModelIndex())-1)
            {
                ind = modelo->index(indice.row()+1,0);
            }
            tabla->setCurrentIndex(ind);
            break;
        }
        case (Qt::Key_Up):
        {
            if (indice.row()>0)
            {
                QModelIndex ind = modelo->index(indice.row()-1,indice.column(), QModelIndex());
                tabla->setCurrentIndex(ind);
            }
            break;
        }
        case (Qt::Key_Down):
        {
            if (indice.row() < modelo->rowCount(QModelIndex())-1)
            {
                QModelIndex ind = modelo->index(indice.row()+1,indice.column(), QModelIndex());
                tabla->setCurrentIndex(ind);
            }
            else if (indice.row() == modelo->rowCount(QModelIndex())-1 && !NombreVacio())
            {
                modelo->insertRow(modelo->rowCount(QModelIndex()));
                QModelIndex ind = modelo->index(indice.row()+1,indice.column(), QModelIndex());
                tabla->setCurrentIndex(ind);                
            }
            break;
        }
        case (Qt::Key_Left):
        {
            if (indice.column()>0)
            {
                QModelIndex ind = modelo->index(indice.row(),indice.column()-1, QModelIndex());
                tabla->setCurrentIndex(ind);
            }
            break;
        }
        case (Qt::Key_Right):
        {
            if (indice.column() < modelo->columnCount(QModelIndex())-1)
            {
                QModelIndex ind = modelo->index(indice.row(),indice.column()+1, QModelIndex());
                tabla->setCurrentIndex(ind);
            }
            break;
        }
        case (Qt::Key_F2):
        {
            qDebug()<<"Editar";
            break;
        }
        default:
        {
            break;
        }
        }
        return true;
    }
    return QWidget::eventFilter(watched, e);
}
 

La idea es que si estoy situado en la última fila y le doy a la tecla hacia abajo, o estoy situado en la última fila y ultima columna, y le doy al tabulador, se cree una fila vacía que permita que sea rellenada. Pero si esa fila no tiene al menos el nombre relleno, no se seguirán creando más filas vacías al final.
Por otro lado, si lo que queremos es insertar una fila en cualquier otro sitio, se pulsaría la tecla F5.

[eferion]

El filtro de eventos debería retornar false para las teclas no procesadas. Tal y como está implementado tu filtro hará que qt entienda que tu filtro proceda todas las teclas. El efecto será que no le llegarán teclas a la tabla.

[dehm]

Iniciado por eferion

El filtro de eventos debería retornar false para las teclas no procesadas. Tal y como está implementado tu filtro hará que qt entienda que tu filtro proceda todas las teclas. El efecto será que no le llegarán teclas a la tabla.

Vaya metedura de pata la mía. Así podía estar definiendo todas y cada una de las teclas que quería que tuvieran efecto en la tabla!

[dehm]

Bueno, sigo con otra pega, que no sabía si ponerla en hilo aparte, pero bueno, como ha surgido a raíz de este ejercicio, la pongo aquí.

La cosa viene por el tema de no tener los iconos de la tabla duplicados, y que en cualquier parte del programa se acceda a una única instancia de ellos*. Así que he intentado implementar una clase con el patrón Singleton. Cuando hago ejemplos con la clase sola no tengo problemas, pero cuando intento usar un miembro de esa clase dentro de otra, me salen dos errores:
1.- Que la instancia de la clase no está inicializada
2.- Que el constructor copia es privado, así como la sobrecarga del operador =

Esta es la implementación (típica y copiada de las muchas que hay):

Código C++:

#include <QIcon>
 
 
class IconoSexo
{
 
private:
     IconoSexo();
     ~IconoSexo();
    IconoSexo(const IconoSexo& I);
    const IconoSexo& operator=(const IconoSexo& I);
    QIcon imagen[2];
 
 
public:
    static IconoSexo& getIcon();
    int male();
    int female();
 
};
 

Código C++:

#include "iconsexo.h"
 
IconoSexo::IconoSexo()
{
    icono[0].addFile(QStringLiteral(":./iconos/niño.png"), QSize(), QIcon::Normal, QIcon::Off);
    icono[1].addFile(QStringLiteral(":./iconos/niña.png"), QSize(), QIcon::Normal, QIcon::Off);
}
 
IconoSexo::~IconoSexo()
{
 
}
 
IconoSexo& IconoSexo::getIcon()
{
    static IconoSexo instance;
    return instance;
}
 
int IconoSexo::male()
{
    return imagen[0];
}
 
int IconoSexo::female()
{
    return imagen[1];
}
 

Y ahora intento hacer uso de ellos, por ejemplo en el modelo:

mimodelo.h:

Código C++:

class MiModel : public QAbstractTableModel
{
    //Q_OBJECT
 
public:
    MiModel(QObject *parent=0);
    int rowCount(const QModelIndex &parent)const;
    int columnCount(const QModelIndex &parent)const;
    QVariant headerData(int section, Qt::Orientation orientation, int role)const;
    QVariant data(const QModelIndex &index, int role)const;
    Qt::ItemFlags flags(const QModelIndex&index) const;
    bool setData(const QModelIndex &index, const QVariant &value, int role);
    bool insertRows(int row, int count, const QModelIndex &parent);
    bool removeRows(int row,int count, const QModelIndex&parent);
 
    void rellenarLista();
 
signals:
    void HaCambiadoElModelo(const QModelIndex &index, const QVariant &value);
 
private:
 
    const int ImageIndexRole = Qt::UserRole+1;
    QList<QStringList>lista;
    IconoSexo &icono;
};
 

Código C++:

MiModel::MiModel(QObject *parent):QAbstractTableModel(parent)
{
    icono = IconoSexo::getIcon();
    rellenarLista();
}
 

Y aquí aparece el problema

*sugerencia de eferion en este otro hilo que abrí, que ahora he remirado y que ya estaba preguntando muchas de las cosas que pregunto ahora, y que encima veo que hace un año sabía más que ahora :(
http://www.forosdelweb.com/f96/qt-de...strar-1123072/

[eferion]

Código C++:

class IconoSexo
{
  public:
    static IconoSexo& getIcon();
    int male();
    int female();
 
};
 

Con esa interfaz es imposible recuperar los iconos ya que no hay ningún método público que devuelva un QIcon.

Por otro lado es poco práctico tener un método exclusivo para cada icono a devolver. En su lugar es mejor declarar un enumerado:

Código C++:

enum class IconosSexo
{
  Undefined,
  Male,
  Female
};
 
class IconoSexo
{
  public:
    static IconoSexo& getIcon();
 
    QIcon GetIcon(IconosSexo tipo);
};
 

Aunque quizás sería más adecuado disponer de un único reservorio de iconos en vez de ir creando clases como si fuesen champiñones. Además para este uso no veo necesario crear un singletone. A mi modo de ver es más práctico tener una clase estática.

Código C++:

enum IconType
{
  Undefined,
  Male,
  Female,
  AnotherOne,
};
 
class IconWareHouse
{
  public:
    static QIcon GetIcon(IconType type)
    {
      auto it = _icons.find(type);
      if( it == _icons.end() )
      {
        // algoritmo para cargar el icono
        // ...
 
        // Se añade el icono a la caché
        it = _icons.insert(std::make_pair(type,icon));
      }
 
      return it->second;
    }
 
  private:
 
    static std::map<IconType,QIcon> _icons;
};
 

En cuanto al fallo que comentas al usar el singletone, el problema es que estás intentando hacer una copia de la clase, cosa que al ser singleton no está permitido.

Deberías recuperar una referencia en ese caso.

Eso sí, nota que las variables creadas como referencia únicamente se pueden asignar una vez y que la misma ha de realizarse en la creación de la variable. Necesitarías algo así:

Código C++:

class MiModel
{
  IconosSexo& icono;
 
    MiModel::MiModel(QObject *parent):QAbstractTableModel(parent)
      : icono(IconoSexo::getIcon())
    {
        rellenarLista();
    }
};
 

Aunque quizás lo más recomendable sería crear una variable local cuando la necesites:

Código C++:

void MiModel::rellenarLista()
{
  auto& icon = IconoSexo::getIcon();
  // ...
}
 

Todo esto suponiendo que no optas por convertir el repositorio de iconos en una clase estática... en ese caso no será necesario almacenar referencias en ningún sitio.

PD.: También podrías almacenar un puntero a la instancia, aunque no es una acción recomendable:

Código C++:

IconoSexo* ptr = &IconoSexo::getIcon();
 

Un saludo.

[dehm]

Hola eferion:

Con esa interfaz es imposible recuperar los iconos ya que no hay ningún método público que devuelva un QIcon.

La verdad es que las pruebas las hago en CodeBlocks, y para no andar configurándolo para que funcione con Qt, la clase que estaba haciendo devolvía un int en lugar de un QIcon, suficiente para mis pruebas. Luego he intentado adaptarla en el mensaje y se me pasó corregir eso

Pero bueno, al lío. La cosa es que no he pillado la idea de la clase que planteas. Es decir, estas líneas, qué han de hacer?:

Código C++:

if( it == _icons.end() )
            {
            // algoritmo para cargar el icono
            // ...
 
            // Se añade el icono a la caché
            it = _icons.insert(std::make_pair(type,icon));
 

Yo por ahora he hecho esto, pero creo que no es para nada la idea que me estás planteando:

Código C++:

#include <iostream>
#include <map>
 
using namespace std;
 
enum class Sexo
{
    undefined, male, female
};
 
std::map<Sexo,string>init()
{
    std::map<Sexo,string>temp;
    temp.insert(std::pair<Sexo, string>(Sexo::undefined,"No definido"));
    temp.insert(std::pair<Sexo, string>(Sexo::male,"Niño"));
    temp.insert(std::pair<Sexo, string>(Sexo::female,"Niña"));
    return temp;
}
 
class IconoWareHouse
{
    private:
        static std::map<Sexo,string>_icons;
 
    public:
        IconoWareHouse() {}
        static string GetIcon(Sexo type)
        {
            auto it = _icons.find(type);
            cout<<&it->second<<endl;//compruebo que es la misma variable
            if( it == _icons.end() )
            {
            // algoritmo para cargar el icono
            // ...
 
            // Se añade el icono a la caché
            //it = _icons.insert(std::make_pair(type,icon));
            }
            cout<<(int)it->first<<endl;
            return it->second;
        }
};
 
std::map<Sexo,string> IconoWareHouse::_icons(init());
 
//Funcion principal
int main()
{
    IconoWareHouse I;
    cout<<I.GetIcon(Sexo::female)<<endl;
    IconoWareHouse II;
    cout<<II.GetIcon(Sexo::female)<<endl;
 
    return 0;
}
 

Como ves, en este caso he sustituido el

[eferion]

Iniciado por dehm

La cosa es que no he pillado la idea de la clase que planteas. Es decir, estas líneas, qué han de hacer?:

Código C++:

if( it == _icons.end() )
{
  // algoritmo para cargar el icono
  // ...
 
  // Se añade el icono a la caché
  it = _icons.insert(std::make_pair(type,icon));
}
 

se supone que la clase que actua como proveedor de iconos debe inicializar la colección en algún momento.

La colección puedes inicializarla bajo demanda o completa del tirón y cada opción se programa de una forma diferente.

En el caso de cargar todos los iconos de una vez podría ser algo tal que (aprovechando el código que has hecho):

Código C++:

enum class Sexo
{
    undefined, male, female
};
 
class IconoWareHouse
{
    // Clase estática. No debe tener constructores disponibles
    IconoWareHouse() = delete;
 
  public:
    static std::string GetIcon(Sexo type)
    {
      auto it = _icons.find(type);
 
      if( it == _icons.end() )
        it = _icons.find(Sexo::undefined);
 
      return it->second;
    }
 
  private:
    static std::map<Sexo,std::string>_icons;
 
    static decltype(_icons) InitMap()
    {
      // Opción con inicializadores de lista
      return decltype(_icons){ std::make_pair(Sexo::undefined,"error"),
                               std::make_pair(Sexo::male,"niño"),
                               std::make_pair(Sexo::female,"niña") };
    }
};
 
std::map<Sexo,string> IconoWareHouse::_icons(InitMap());
 

Nota el uso de decltype para evitar repetir todo el rato la declaración del mapa. Piensa que no suele ser adecuado repetir un tipo cada dos por tres porque luego al intentar portar la solución a Qt te obliga a hacer demasiados cambios.

También puedes usar typedef o using (typedef sirve para estándares anteriores a C++11):

Código C++:

class IconoWareHouse
{
    // Clase estática. No debe tener constructores disponibles
    IconoWareHouse() = delete;
 
  public:
 
    // Alias declarado con typedef
    typedef std::map<Sexo,std::string> IconsMap;
 
    // Alias declarado con using
    using IconsMap = std::map<Sexo,std::string>;
 
    static std::string GetIcon(Sexo type)
    {
      auto it = _icons.find(type);
 
      if( it == _icons.end() )
        it = _icons.find(Sexo::undefined);
 
      return it->second;
    }
 
  private:
    static IconsMap_icons;
 
    static IconsMap InitMap()
    {
      // Opción con inicializadores de lista
      return IconsMap{ std::make_pair(Sexo::undefined,"error"),
                       std::make_pair(Sexo::male,"niño"),
                       std::make_pair(Sexo::female,"niña") };
    }
};
 

Por cierto, nota que make_pair es más cómodo y limpio que tener que hacer una declaración explícita de pair cada vez que insertas un elemento en el mapa.

Un saludo.

[dehm]

Hola eferion:

Interesante el uso de decltype. Ya me has tenido un rato leyendo acerca del tema .Al final vas a conseguir que aprenda cosas del estandar C++11 en adelante!

Y si que es verdad que teniendo esas buenas prácticas bien interiorizadas, luego uno se facilita mucho la vida, realmente. Aún así he optado por la opción de "using" (no sabía que typedef ya estaba obsoleto).

Pero el caso es que el código que me has puesto no me compila. Me da dos errores.
1.-Al estar la función encargada de llenar el map dentro de la clase, al llamarla desde fuera me dice que:

Código C++:

std::map<Sexo,std::string> IconoWareHouse::_icons(initMap());//llamada a la función
 

error: cannot call member function ‘std::map<Sexo, std::basic_string<char> > IconoWareHouse::initMap()’ without object

Soslayo provisionalmente ese error sacando la función otra vez de la clase. Y ahora me da este error:
error: use of deleted function ‘IconoWareHouse::IconoWareHouse()’

Y ya puestos, si quito delete del constructor....
referencia a `IconoWareHouse::IconoWareHouse()' sin definir

[dehm]

Perdón, los errores del constructor ya sé que son debidos a que no he de crear ningún objeto del tipo IconoWareHouse, sino sólo llamar a los miembros estáticos, que no pertenecen a ninguna instancia de la clase.

Eso ya lo he arreglado.(quiero decir que no instancio la clase, sino que sólo llamo al método)
Esto:

Código C++:

std::cout<<IconoWareHouse::GetIcon(Sexo::female)<<std::endl;
 

en lugar de esto:

Código C++:

IconoWareHouse I;
    std::cout<<I.GetIcon(Sexo::female)<<std::endl;
 

Ahora entiendo el por qué de usar el delete de forma expresa.

Pero sigo sin poder usar la función que rellena el map dentro de la clase. Sólo me funciona si es una función externa.

[eferion]

Iniciado por dehm

Pero sigo sin poder usar la función que rellena el map dentro de la clase. Sólo me funciona si es una función externa.

Pon un ejemplo del código que reproduzca el problema :)

[dehm]

Iniciado por eferion

Pon un ejemplo del código que reproduzca el problema :)

Perdón, no lo había puesto porque prácticamente es una copia de lo que mas puesto:

Esto me funciona:

Código C++:

#include <iostream>
#include <map>
 
 
enum class Sexo
{
    undefined, male, female
};
 
using IconsMap = std::map<Sexo,std::string>;
 
IconsMap initMap()
{
    return
    {
        std::make_pair(Sexo::undefined,"No definido"),
        std::make_pair(Sexo::male,"Niño"),
        std::make_pair(Sexo::female,"Niña")
    };
}
 
class IconoWareHouse
{
 
private:
    static IconsMap _icons;
 
public:
    IconoWareHouse()=delete;//no debe haber constructor disponible al ser clase estática
    static std::string GetIcon(Sexo type)
    {
        auto it = _icons.find(type);
        if(it == _icons.end())
        {
            it = _icons.find(Sexo::undefined);
        }
        return it->second;
    }
};
 
IconsMap IconoWareHouse::_icons(initMap());
 
 
int main()
{
    std::cout<<IconoWareHouse::GetIcon(Sexo::female)<<std::endl;
    return 0;
}
 

Pero esto no:

Código C++:

#include <iostream>
#include <map>
 
 
enum class Sexo
{
    undefined, male, female
};
 
using IconsMap = std::map<Sexo,std::string>;
 
class IconoWareHouse
{
 
private:
    static IconsMap _icons;
 
public:
    IconoWareHouse()=delete;//no debe haber constructor disponible al ser clase estática
    static std::string GetIcon(Sexo type)
    {
        auto it = _icons.find(type);
        if(it == _icons.end())
        {
            it = _icons.find(Sexo::undefined);
        }
        return it->second;
    }
    IconsMap initMap()
    {
        return
        {
            std::make_pair(Sexo::undefined,"No definido"),
            std::make_pair(Sexo::male,"Niño"),
            std::make_pair(Sexo::female,"Niña")
        };
    }
};
 
IconsMap IconoWareHouse::_icons(initMap());
 
 
int main()
{
    std::cout<<IconoWareHouse::GetIcon(Sexo::female)<<std::endl;
    return 0;
}
 

En este segundo caso me da este error:

error: cannot call member function ‘IconsMap IconoWareHouse::initMap()’ without object

[eferion]

El problema en el segundo caso es que InitMap no está etiquetado como estático, por lo que para llamarlo necesitarías disponer de una instancia ya creada de IconoWareHouse.

Prueba a ponerle static al método y verás como ya si funciona.

Por cierto, lo suyo es que ese método sea privado.

Un saludo.

[dehm]

Iniciado por eferion

El problema en el segundo caso es que InitMap no está etiquetado como estático, por lo que para llamarlo necesitarías disponer de una instancia ya creada de IconoWareHouse.

Prueba a ponerle static al método y verás como ya si funciona.

Por cierto, lo suyo es que ese método sea privado.

Un saludo.

Los chicos del forosdelweb tendrían que ponerte un sueldo
Pues subtema solucionado. Ya he puesto el método static (y privado).
Cierro este paréntesis y voy a llevarme el tinglado a la QTableView.
Aunque sospecho que todavía tendré algún que otro problema, a ver si este fin de semana fuera capaz de resolverlo sólo. Espero no tener que molestarte de nuevo.
Saludos y gracias!

[dehm]

Al final la cosa no esta tan clara.
Al crear la clase "bien", con elementos QIcon y ya dentro del proyecto en Qt, me arroja este error:
QPixmap: Must construct a QGuiApplication before a QPixmap

Por lo que veo en Google, se ve que un objeto de la clase Pixmap no puede tener vida fuera de una Applicatión, y esa es la causa del error.

Este es el código:

//h

Código C++:

#ifndef RECURSOS_H
#define RECURSOS_H
 
#include <map>
#include <QIcon>
 
enum class Sexo
{
    undefined, male, female
};
 
using IconsMap = std::map<Sexo,QIcon>;
 
class RepoIconos
{    
 
private:
    static IconsMap _iconos;
    static IconsMap initMap()
    {
        return
        {
            std::make_pair(Sexo::undefined, QIcon(QStringLiteral("../Primos/iconos/undefined.png"))),
            std::make_pair(Sexo::male, QIcon(QStringLiteral("../Primos/iconos/niño.png"))),
            std::make_pair(Sexo::female, QIcon(QStringLiteral("../Primos/iconos/niña.png")))
        };
    }
 
 
public:
    RepoIconos()=delete;//no debe haber constructor disponible al ser clase estática
    static QIcon GetIcon(Sexo type)
    {
        auto it = _iconos.find(type);
        if(it == _iconos.end())
        {
            it = _iconos.find(Sexo::undefined);
        }
        return it->second;
    }
};
 
namespace DatosGenerales
{
    enum Columnas{Nombre,Ciudad,Color,Sexo};
}
 
 
#endif // RECURSOS_H
 

Código C++:

//cpp
#include "recursos.h"
 
IconsMap RepoIconos::_iconos(initMap());
 

¿Sugerencias?¿Debería abandonar este diseño?

[eferion]

Tienes que crear una aplicación gráfica para poder usar los QIcon.

Yo de ti crearía el proyecto desde el qt creator para que te aparezca ya configurado.

Un saludo

[dehm]

Hola eferion:

La cosa es que el fichero de recursos lo añadí al proyecto de la tabla, desde qtcreator.

Al final lo he subido a sourceforge (sé que no es muy correcto usar estos servicios como almacenes personales de proyectos sin interés...en unos días lo borro)

https://sourceforge.net/projects/tabla-primos/

Si te apetece echarle un vistazo, aunque sólo sea para ver cómo está organizado el proyecto o si hay que tocar el archivo .pro, te lo agradeceré.

[eferion]

¿sería mucho pedir que incluyeses un fichero comprimido con todo el proyecto para no tener que bajar fichero a fichero? :)

[dehm]

Debería haber un botón para clonar el proyecto al disco duro...estos de SF están anticuados

Bueno, pues ya está subido el zip. Si lo ves con un poco de detalle, verás que a las miles de barbaridades se le suma que no hay fuente de datos como tal, el modelo bebe directamente de una QStringList que no está respaldada por nada. Eso es porque la cosa empezó al revés (la tabla), y los datos son sólo una herramienta sólo para controlar la visualización de los mismos dentro de dicha tabla.

Bueno, pues saludos y gracias de nuevo!

[eferion]

vale, como suponía, el problema está en la inicialización de la clase estática:

Código C++:

IconsMap RepoIconos::_iconos(initMap());
 

Las clases estáticas se inicializan antes de ejecutar nada de código del main, luego con la inicialización que tienes actualmente se intentan cargar los iconos antes de tener inicializada la librería de Qt.

Solución: muy sencila.

1. Deja la inicialización vacía

Código C++:

IconsMap RepoIconos::_iconos;
 

2. Inicializa el mapa con el primer uso:

Código C++:

static QIcon GetIcon(Sexo type)
{
  if( _iconos.empty() )
    _iconos = initMap();
 
  // ...
}
 

Un saludo

[dehm]

Perfecto, era eso.

Bueno, ahora sí que cierro el paréntesis de los iconos. A ver si soy capaz de sincronizarlos con los índices del QComboBox

Gracias de nuevo!

[dehm]

Bueno, pues doy la tabla por terminada.

Mas o menos hace todo lo que estaba buscando. Sólo se me ha quedado la espinita de que el desplegable de ciudades no funciona con Tab la primera vez que se introduce una nueva ciudad.

Por otro lado, el diseño me ha obligado a usar por primera vez la palabra mutable, en la función void setModelData() const de uno de los delegados.

Pero bueno, creo que me ha quedado una cosa bastante flexible y fácilmente reutilizable para otra fuente de datos.

En fin, marco como solucionado, y aunque pensaba copiar el código aquí, es demasiado extenso, así que lo mantendré en sourceforge. https://sourceforge.net/projects/tabla-primos/

Gracias a todos, y en especial a eferion