Aplicación con múltiples 'dialogs'.



  • Hola,

    Estoy estudiando la posibilidad de desarrollar una aplicación que trabaja con múltiples dialogs. Mi primer prueba consiste en tener un main_widget, este tiene un botón que cuando genera la señal clicked abra un segundo dialogo (child). Hasta aquí todo bien, parece que funciona correctamente.

    El problema que tengo es que al cerrar el main_widget, esperaría que también se cerrara el child_widget pero no es así, el child widget se mantiene abierto. Me parece que me falta hacer un paso, vincular ambos widgets, estableciendo uno como padre del otro, pero no se como hacerlo ni si esto sea lo correcto, ¿algún consejo?

    Estoy usando pyside2 y fbs, mi código de prueba es el siguiente:

    #!/usr/bin/env python3
     
    from fbs_runtime.application_context import ApplicationContext
     
    from PySide2.QtCore import *
    from PySide2.QtWidgets import *
     
    from PySide2.QtUiTools import QUiLoader
     
    import sys
     
    class child_form(QObject):
     
        def __init__(self, ui_resource):
            QObject.__init__(self)
     
            self.ui_file = QFile(ui_resource)
            self.ui_file.open(QFile.ReadOnly)
     
            loader = QUiLoader()
     
            self.window = loader.load(self.ui_file)
            self.ui_file.close()
     
            self.window.pushButton.clicked.connect(self.on_push_button_clicked)
     
        @Slot()
        def on_push_button_clicked(self):
            print('Hi from child')
     
    class AppContext(ApplicationContext):
        def run(self):
     
            self.app.setStyle('Fusion')
     
            main_window_ui = self.get_resource('main_window.ui')
     
            child_ui = self.get_resource('child_widget.ui')
            self.child = child_form(child_ui)
     
            self.loader = QUiLoader()
           
            self.window_file = QFile(main_window_ui)
            self.window_file.open(QFile.ReadOnly)
     
            self.window = self.loader.load(self.window_file)
            self.window_file.close()
     
            self.window.pushButton.clicked.connect(self.on_push_button_clicked)
     
            self.window.show()
            return self.app.exec_()
     
        @Slot()
        def on_push_button_clicked(self):
            self.child.window.show()
     
    if __name__ == '__main__':
        appctxt = AppContext()
        exit_code = appctxt.run()
        sys.exit(exit_code)
    

    Saludos.
    Carlos Diaz


  • Moderators

    Hola

    Mirando tu código no me entero, no me gusta phyton.

    Dices que tienes una ventana principal que abre una ventana secundaria, tu quieres que al cerrar la ventana principal se cierre la secundaria.

    Si le pasas al constructor de la ventana secundaria como parent la ventana principal, creo que debe cerrarse.

    También puedes abrir la secundaria como modal, así no podrás interactuar con la principal hasta que se cierre la secundaria.

    Creo que armé un buen lío :P espero que más o menos lo entiendas.

    Un saludo



  • @juanki Hola, si, en teoría pasándole la ventana principal como parent a la hija debería hacer lo que pretendo, pero no lo he logrado. Voy a intentar abriendo la ventana secundaria como modal.

    Hice lo mismo en C++, y aquí si sucede lo esperado, abre la ventana 'principal', en el slot on_button_clicked muestro al dialogo hijo y tengo comunicación entre los dos diálogos, si cierro la ventana principal también se cierra el dialogo hijo.

    mainwindow.h

    #ifndef MAINWINDOW_H
    #define MAINWINDOW_H
    
    #include <QMainWindow>
    
    #include "dialog.h"
    
    namespace Ui {
    class MainWindow;
    }
    
    class MainWindow : public QMainWindow
    {
        Q_OBJECT
    
    public:
        explicit MainWindow(QWidget *parent = nullptr);
        ~MainWindow();
    
    public slots:
        void on_button_clicked();
    
    private:
        Ui::MainWindow *ui;
        Dialog *dial = nullptr;
    };
    
    #endif // MAINWINDOW_H
    
    

    mainwindow.cpp

    #include "mainwindow.h"
    #include "ui_mainwindow.h"
    
    MainWindow::MainWindow(QWidget *parent) :
        QMainWindow(parent),
        ui(new Ui::MainWindow)
    {
        ui->setupUi(this);
    
        this->dial = new Dialog(this);
    
        connect(ui->btn,
                &QPushButton::clicked,
                this,
                &MainWindow::on_button_clicked);
    
        connect(ui->inc,
                &QPushButton::clicked,
                this->dial,
                &Dialog::on_inc_number);
    }
    
    MainWindow::~MainWindow()
    {
        delete ui;
    }
    
    void MainWindow::on_button_clicked()
    {
        this->dial->show();
    }
    
    

    dialog.h

    #ifndef DIALOG_H
    #define DIALOG_H
    
    #include <QDialog>
    
    namespace Ui {
    class Dialog;
    }
    
    class Dialog : public QDialog
    {
        Q_OBJECT
    
    public:
        explicit Dialog(QWidget *parent = nullptr);
        ~Dialog();
    
        void on_inc_number();
    
    private:
        Ui::Dialog *ui;
        unsigned int count;
    };
    
    #endif // DIALOG_H
    

    dialog.cpp

    #include "dialog.h"
    #include "ui_dialog.h"
    
    Dialog::Dialog(QWidget *parent) :
        QDialog(parent),
        ui(new Ui::Dialog)
    {
        ui->setupUi(this);
    
        count = 0;
    }
    
    Dialog::~Dialog()
    {
        delete ui;
    }
    
    void Dialog::on_inc_number()
    {
        count++;
    
        ui->label->setText(QString::number(count));
    }
    

  • Moderators

    Hola

    Si con C++ funciona como esperas y no con python, debe ser cosa de la versión de Qt para phyton o del propio phyton, ahí no te puedo ayudar, quizás en la documentación haya algo.

    No sé si en phyton hay el concepto de destructor o algo similar, podrías usarlo para cerrar desde ahí las ventanas que tengas abiertas. Y si no lo hay, podrías usar el evento CloseEvent para cerrar las ventanas que te queden abiertas.

    Un saludo


 

Looks like your connection to Qt Forum was lost, please wait while we try to reconnect.