Aplicación con múltiples 'dialogs'.

[Carlos Diaz]

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

[juanki]

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

[Carlos Diaz]

@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));
}

[juanki]

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