Qt. Duda sobre promoted widgets

[dehm]

Bueno, después de mas de un mes sin tener oportunidad de retomar Qt, ahora toca preguntar una duda.

Es una duda un poco tonta, pero es por aclarar un concepto que no termino de ver.

La duda es: ¿cual es la diferencia entre crear una clase heredándola de otra con código, a crear un widget en el Designer y por medio de la opción "promote to..." personalizarle sus propiedades?...(si es que hay alguna)

Gracias

[eferion]

"Promote" no permite editar las propiedades de un widget. Únicamente te permite usar en el designer un widget propio que no esta instalado en el editor. Al usar "promote", se genera código que permite crear el widget, pero el designer únicamente conoce las propiedades de la clase que has definido como base, por lo que no podrás acceder a las características propias del widget.

[dehm]

Gracias eferion.

Vaya, entonces creo que he entendido el tema del promote peor de lo que pensaba

Digamos que tengo este widget personalizado:

Código C++:

#ifndef MIWIDGET_H
#define MIWIDGET_H
 
#include <QSpinBox>
 
class MiWidget : public QSpinBox
{
    Q_OBJECT
 
public:
    explicit MiWidget(QWidget *parent = 0);
 
    //mis funciones necesarias para personalizar "MiWidget" como un spinbox "adhoc"
};
 
#endif // MIWIDGET_H
 

(Ahora implemento las funciones necesarias para tener un flamante SpìnBox personalizado)

Ahora entro en otro proyecto, y por medio del Designer creo un formulario en el que por ejemplo quiero tener mi SpinBox personalizado y un QLabel.
Así que añado un QSpinbox y un QLabel.
Luego (creo) copio los archivos *.h y *.cpp de mi SpinBox personalizado en el mismo sitio donde están el resto de archivos de mi nuevo proyecto.
Finalmente hago promote to... en el SpìnBox y le señalo mi clase personalizada.

Y me da error.....me estoy desviando de la duda original (es que creo que no tenía claras las ideas al hacerla), pero entonces, ¿cómo hago uso de un widget personalizado?

Gracias de nuevo

[eferion]

Al usar promote le estas diciendo al editor "voy a usar un widget que no conoces. El widget es de este tipo, fiate de mi".

Al hacer prommote has tenido que indicar la ruta del fichero de cabecera. Cuando compilas, se ejecuta el moc, que lee el fichero ui y genera el código C++ que representa la ventana que has compuesto. Después llega el compilador, incorpora el fichero recién creado al proyecto y trata de generar código ejecutable.

Si el compilador no encuentra el archivo de cabecera de tu widget... O el proyecto no compila el cpp del widget, se producirá un error.

Solución:

* verifica que tanto la cabecera como la implementación del widget están correctamente añadidas al proyecto

* verifica que la ruta y nombre del fichero de cabecera es correcta en la configuración del promote

[dehm]

Gracias una vez más, eferion:
El compilador se quejaba de que no encontraba el archivo de implementación del widget personalizado.
Lo he añadido en el archivo *.pro y ya funciona correctamente

Una última pregunta. Esta historia viene porque se supone que un QMainWindow tiene un widget central.
Pero mi proyecto tiene tres widget en el mainwindows.
Entonces....¿se supone que he de crear toda la composición, guardarla como un widget, y luego hacer uso de "promote to" para definir esa composición como el widget central?

Saludos y gracias!

[eferion]

QMainWindow no tiene un "widget central". Lo que sucede es que QMainWindow es un diálogo especial que viene preparado para soportar barras de menús y de herramientas. Si bien es cierto que este tipo de elementos también se pueden incluir en un QDialog, en QMainWindow es más sencillo integrar estos elementos.

En un QMainWindow puedes añadir en "el espacio central" tantos widgets como quieras. Eso si, si quieres que éstos widgets sean sensibles al tamaño de la ventana no te olvides de usar corretamente los layouts :)

[dehm]

Vaya, pues tampoco tenía las ideas muy claras sobre el pretendido "widget central".

Si bien es cierto que este tipo de elementos también se pueden incluir en un QDialog

Y también tu respuesta me ha adelantado la siguiente que tenía en mente.
Y es que iba a preguntar si era posible integrar un QMainWindow dentro de otro. El motivo es que me gustaría que uno de los widgets tuviera una barra de tareas. En concreto me gustaría que uno de los widgets fuera un editor de texto muy básico, pero que me permitiera lo típico -fuentes, alineados y poco más- pero que tuviera su botonera y su combinación de teclas que fuera específica cuando estuviera sobre ese widget.

Entonces, por lo que dices, ¿la forma de conseguir esto es mediante un QDialog?

Gracias como siempre

[eferion]

No he entendido muy bien lo que intentas hacer.

Si tu idea es tener dos configuraciones diferentes nada te impide crear la configuracion "completa" en la ventana y, al activar la vista "básica", ocultar todos los elementos que dejan de estar disponibles.

Entonces únicamente tienes una ventana, has reducido el código necesario para ponerla en funcionamiento y has conseguido que la ventana sea más versátil.

[jc_moj]

Hola

Al igual que @eferion, tampoco entinedo muy bien lo que pretendes.

Iniciado por dehm

...En concreto me gustaría que uno de los widgets fuera un editor de texto
muy básico, pero que me permitiera lo típico -fuentes, alineados y poco más- pero que tuviera su botonera y su combinación de teclas que fuera específica cuando estuviera sobre ese widget.

¿Te refieres a poder tener varios documentos abiertos a la vez?

Saludos

[dehm]

Bueno, gracias a ambos por el interés.


La idea es (hasta ahora tampoco me he explicado muy bien porque no lo tenía claro del todo):

Tengo mi MainWindow. Dentro de él debería de haber un tabWidget. La idea es que cada documento nuevo que se abra o cree, implique la creación de una nueva pestaña. Al estilo Firefox. Siempre manteniendo una con un "+" como nueva pestaña.

Luego, lo que debe de haber dentro de cada pestaña del tabWidget, serían dos tablas y un editor de texto, uno muy basico, pero con su barra de tareas y sus combinaciones de teclas, de forma por ejemplo de que un "Ctrl+N" dentro del editor signifique Negritas, y fuera de él signifique Nuevo

Bueno, pongo un pantallazo mas o menos de lo que pretendo:

[eferion]

Para la botonera del editor la puedes simular con varios botones puestos en fila con un QHBoxLayout y, justo debajo, el editor.

Si tu idea es ocultar la botonera a placer, puedes meter los botones dentro de un QWidget y así puedes controlar la visibilidad de todos los botones únicamente cambiando la visibilidad del QWidget.

[dehm]

Iniciado por eferion

Para la botonera del editor la puedes simular con varios botones puestos en fila con un QHBoxLayout y, justo debajo, el editor.

Si tu idea es ocultar la botonera a placer, puedes meter los botones dentro de un QWidget y así puedes controlar la visibilidad de todos los botones únicamente cambiando la visibilidad del QWidget.

Hola eferion:
Uno de mis planteamientos era ese e hice algo en ese sentido. Pero temas estéticos aparte, la idea era reciclar un QmainWindow y aprovechar sus acciones y barra de tareas.

Finalmente, ya he leído que le podemos cambiar el flag a un QMainWindow para que pase de Qt::Window a Qt::Widget, y poder usarlo normalmente como tal.

Ahora la duda es que no sé hacerlo de modo gráfico. Miraré a ver, porque la idea es usar en la medida de lo posible los formularios. Creo que es mejor y mas mantenible.

Por si a alguien le vale, pongo el ejemplo:

El editor, que es un QMainWindow (sacado del libro The Book of Qt 4_ The Art of Building Qt Applications):

editor.h

Código C++:

#ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QFileDialog>
#include <QMessageBox>
#include "ui_mainwindow.h"
#include <QStatusBar>
#include <QLabel>
 
class QLabel;
 
class MainWindow :  public QMainWindow,
            private Ui::MainWindow
{
    Q_OBJECT
    public:
    MainWindow (QWidget* parent=0); 
    //~MainWindow();
 
    protected:
    void setupActions();
    void mayDiscardDocument();
    void saveFile(const QString&);
 
    protected slots:
    void newFile();
    void loadFile();
    void saveFile();
    void saveFileAs();
    void undo();
    void redo();
    void copy();
    void cut();
    void paste();
    void about();
    void updateStats();
    
    private:
    QString mFilePath;
    QLabel *mStatLabel;
};
 
#endif
 

editor.cpp

Código C++:

#include <QtGui>
#include "mainwindow.h"
 
MainWindow::MainWindow(QWidget *parent): QMainWindow(parent)
{
    setupUi(this);  
    setupActions();
    mFilePath="";
    mStatLabel = new QLabel;
    estatusBar->addPermanentWidget(mStatLabel);
    connect (textEdit, SIGNAL(textChanged()), this, SLOT(updateStats()));
    updateStats();  
}
 
void MainWindow::setupActions()
{
    connect(action_Quit, SIGNAL(triggered(bool)),qApp, SLOT(quit()));
    connect(action_Open, SIGNAL(triggered(bool)),this, SLOT(loadFile()));
    connect(action_Save, SIGNAL(triggered(bool)),this, SLOT(saveFile()));
    connect(action_Save_as, SIGNAL(triggered(bool)),this, SLOT(saveFileAs()));
    connect(action_New, SIGNAL(triggered(bool)),this,SLOT(newFile()));
 
    connect(textEdit, SIGNAL(copyAvailable(bool)),action_Copiar, SLOT(setEnabled(bool)));
    connect(textEdit, SIGNAL(undoAvailable(bool)),action_Undo, SLOT(setEnabled(bool)));
    connect(textEdit, SIGNAL(redoAvailable(bool)),actionRedo, SLOT(setEnabled(bool)));
 
    connect(action_Copiar, SIGNAL(triggered(bool)),this, SLOT(copy()));
    connect(actionCut, SIGNAL(triggered(bool)),this, SLOT(cut()));
    connect(actionPaste, SIGNAL(triggered(bool)),this, SLOT(paste()));
    
    connect(action_Undo, SIGNAL(triggered(bool)),this, SLOT(undo()));
    connect(actionRedo, SIGNAL(triggered(bool)),this, SLOT(redo()));
    connect(actionInfo, SIGNAL(triggered(bool)),this, SLOT(about()));
}
 
void MainWindow::loadFile()
{
    mayDiscardDocument();
    
        QString filename = QFileDialog::getOpenFileName(
                            this,
                            "Selecciona un fichero para abrir",
                            "",
                            "Texto (*.txt *.h *.cpp)");
        QFile file(filename);
    if (file.open(QIODevice::ReadOnly|QIODevice::Text))
    {
        textEdit->setPlainText(QString::fromUtf8(file.readAll()));
        mFilePath = filename;
        estatusBar->showMessage(tr("File successfully loaded."), 3000);
    }
 
}
 
void MainWindow::saveFile()
{
    if (mFilePath.isEmpty())
    {
        saveFileAs();
    }
    else
    {
        saveFile(mFilePath);
    }
}
 
void MainWindow::saveFile(const QString& name)
{
    QFile file(name);
    if (file.open(QIODevice::WriteOnly|QIODevice::Text))
    {
        file.write(textEdit->toPlainText().toUtf8());
        estatusBar->showMessage(tr("File save succesfully."),3000);
        textEdit->document()->setModified(false);
    }
}
 
void MainWindow::saveFileAs()
{
    mFilePath = QFileDialog::getSaveFileName(this);
    if(mFilePath.isEmpty())
    {
        return;
    }
    saveFile(mFilePath);
}
 
void MainWindow::mayDiscardDocument()
{
    if (textEdit->document()->isModified())
    {
        QString filename = mFilePath;
        if (filename.isEmpty()) filename = tr("Unnamed");
        if (QMessageBox::question(this, tr("Save Document?"),tr("You want to create a new document, but the "
            "changes in the current document %1 have not "
            "been saved. How do you want to proceed?").arg(filename),
            tr("Discard Changes"), tr("Save Document") ))
        {
            saveFile();
        }
    }
}
 
void MainWindow::newFile()
{
    mayDiscardDocument();
    textEdit->setPlainText("");
    mFilePath = "";
}
 
void MainWindow::undo()
{
    textEdit->document()->undo();
}
 
void MainWindow::redo()
{
    textEdit->document()->redo();
}
 
void MainWindow::copy()
{
    textEdit->copy();
}
 
void MainWindow::cut()
{
    textEdit->cut();
}
 
void MainWindow::paste()
{
textEdit->paste();
}
 
 
void MainWindow::about()
{
    QMessageBox::about(this, tr("About CuteEdit"),
        tr("CuteEdit 1.0\nA Qt application example.\n"
        "(c) 2006 Daniel Molkentin, Open Source Press"));
}
 
void MainWindow::updateStats()
{
    QString text = textEdit->document()->toPlainText();
    int chars = text.length();
    text = text.simplified();
    int words = 0;
    words = text.count(" ");
    if (!text.isEmpty())
    {
        words++;
    }
    QString output = tr("Characters : %1, Words: %2").arg(chars).arg(words);
    mStatLabel->setText(output);
}
 

Un Widget compuesto por dos QTableView y el editor:
miwidget.h

Código C++:

#ifndef MIWIDGET_H
#define MIWIDGET_H
 
#include <QVBoxLayout>
#include <QLabel>
#include <QTableView>
#include "./Editor/mainwindow.h"
 
class MiWidget : public QWidget
{
    Q_OBJECT
public:
    explicit MiWidget(QWidget *parent = 0);
 
signals:
 
public slots:
 
private:
    QVBoxLayout* lienzo;
    MainWindow* editor;
    QTableView* tabla1;
    QTableView* tabla2;
 
};
 
#endif // MIWIDGET_H
 

miwidget.cpp

Código C++:

#include "miwidget.h"
 
MiWidget::MiWidget(QWidget *parent) :
    QWidget(parent)
{
    lienzo = new QVBoxLayout;
    editor= new MainWindow;
    tabla1= new QTableView;
    tabla2= new QTableView;
    editor->setWindowFlags(editor->windowFlags() & ~Qt::Window); //opcionalmente editor->setWindowFlags(Qt::Widget) ?
    lienzo->addWidget(tabla1);
    lienzo->addWidget(tabla2);
    lienzo->addWidget(editor);
    this->setLayout(lienzo);
}
 

El MainWindow "padre":

Código C++:

#ifndef MAINMAINWINDOW_H
#define MAINMAINWINDOW_H
 
#include "ui_mainmainwindow.h"
#include "miwidget.h"
 
class MainMainWindow : public QMainWindow, private Ui::MainMainWindow
{
    Q_OBJECT
 
public:
    explicit MainMainWindow(QWidget *parent = 0);
 
private:
    MiWidget* central;
};
 
#endif // MAINMAINWINDOW_H
 

Código C++:

#include "mainmainwindow.h"
 
MainMainWindow::MainMainWindow(QWidget *parent) :
    QMainWindow(parent)
{
    setupUi(this);
    central = new MiWidget(this);
 
    this->setCentralWidget(central);
 
 
}
 

Y el resultado: