Access to UI elements from another class c++

Hello,

I have a problem with accessing to ui elements from another class(with instance). I have a second QMainWindow in my application, I can access in secondWindow.cxx class all ui elements but not in read.cxx class. My code looks like following. Where is my mistake? Thank you for your help.

Code:

---

//-------------------------------secondWindow.h------------------------------------
    #ifndef __secondWindow_h
    #define __secondWindow_h
 
    #include "ui_secondwindow.h"
 
    class secondWindow : public QMainWindow
    {
        friend class read;
        igstkStandardClassBasicTraitsMacro(secondWindow, QMainWindow);
        Q_OBJECT
 
    public:
        igstkStateMachineMacro();
 
        secondWindow();
        virtual ~secondWindow();
        void createSignalAndSlots();
 
    public slots:
        void secondWindowTest();
 
    protected:
 
    private:
        Ui::secondMainWindow m_secondWindowUI;
    };
    #endif

---

Code:

---

//-------------------------------secondWindow.cxx------------------------------------
    #include "secondWindow.moc"
    #include "secondWindow.h"
    #include "read.h"
 
    secondWindow::secondWindow() :m_StateMachine(this)
    {
        m_secondWindowUI.setupUi(this);
        createSignalAndSlots();
    }
 
    void secondWindow::createSignalAndSlots()
    {
        connect(m_secondWindowUI.pushButton1, SIGNAL(clicked()),this, SLOT(secondWindowTest()));
 
        connect(m_secondWindowUI.pushButton2, SIGNAL(clicked()), read::instance(), SLOT(readTest()));
    }
 
    void secondWindow::secondWindowTest()
    {
        m_secondWindowUI.pushButton1->setEnabled(true); //OK
    }
 
    secondWindow::~secondWindow(){}

---

Code:

---

//---------------------------------read.h--------------------------------------
    #pragma once
 
    #include "secondWindow.h"
 
    class read : public QObject
    {
        Q_OBJECT
 
    public:
        static read *instance();
        read();
        virtual ~read() {}
 
    public slots:
        void readTest();
 
    protected:
        secondWindow	*m_readUI;
        static read 	*m_read;
 
    private:
    };

---

Code:

---

//---------------------------------read.cxx--------------------------------------
    #include <read.moc>
    #include "secondWindow.h"
    #include "read.h"
 
    read *read::m_read= NULL;
 
    read::read()
    {
        m_readUI = dynamic_cast<secondWindow*>( QApplication::instance() );
    }
 
    read *read::instance()
    {
        if(m_read == NULL)
        m_read = new read();
 
        return m_read;
    }
 
    void read::readTest()
    {
        m_readUI->m_secondWindowUI.qlabelTest->setText("test"); //segmentation fault
    }

---

That dynamic cast will fail because main window is not related to qapplication. You should pass secondwindow ptr into read constructor. You shouldn't need to use statics.

sorry, how can I do this?

Quote:

---

Originally Posted by amleto

That dynamic cast will fail because main window is not related to qapplication. You should pass secondwindow ptr into read constructor. You shouldn't need to use statics.

---

Hello,

Sorry for late reply. now segmentation fault does not occur. I have insert also a new class "app", in which I needed initializations (pointers of UI's) doing. But this time I have another problem. When I click on "pushButton2" on the "secondWindow", nothing happens, no reaction. Probably. should I post my whole program so you can help me further.

Thank you.

Code:

---

-----------------------------mainWindow.h----------------------------------
#ifndef __mainWindow_h
#define __mainWindow_h
 
#include "ui_mainWindow.h"
#include "app.h"
 
class mainWindow : public QMainWindow
{
	friend class app;
	friend class write;
	igstkStandardClassBasicTraitsMacro(mainWindow, QMainWindow);
	Q_OBJECT
 
public:
	igstkStateMachineMacro();
 
	mainWindow();
	virtual ~mainWindow();
	void createSignalAndSlots();
 
public slots:
	void openSecondWindow();
	void mainWindowTest();
 
private:
	Ui::mainWindow	m_mainWindowUI;
};
#endif
 
-----------------------------mainWindow.cxx----------------------------------
#include "mainWindow.moc"
#include "mainWindow.h"
#include "secondWindow.h"
#include "read.h"
#include "write.h"
 
mainWindow::mainWindow() : m_StateMachine(this)
{
	m_mainWindowUI.setupUi(this);
	createSignalAndSlots();
}
 
mainWindow::~mainWindow(){}
 
 
void mainWindow::createSignalAndSlots()
{
	connect(m_mainWindowUI.menuOpenAction, SIGNAL(triggered()), this, SLOT(openSecondWindow()));
	connect(m_mainWindowUI.pushButton1, SIGNAL(clicked()), this, SLOT((mainWindowTest()));
	connect(m_mainWindowUI.pushButton2, SIGNAL(clicked()), write::instance(), SLOT((writeTest()));
}
 
void mainWindow::openSecondWindow()
{
	secondWindow  *secondWin = new secondWindow(); 
	secondWin->show();
}
 
 
void mainWindow::mainWindowTest()
{
   m_mainWindowUI.pushButton1->setEnabled(true); //OK, it works
}
 
-----------------------------write.h----------------------------------
#pragma once
 
#include "mainWindow.h"
 
class write : public QObject
{
    Q_OBJECT
 
public:
    static write *instance();
    write();
    virtual ~write() {}
 
public slots:
    void writeTest();
 
protected:
    app		*m_writeUI;
    static write 	*m_write;
 
private:
};
 
-----------------------------write.cxx----------------------------------
#include <write.moc>
#include "mainWindow.h"
#include "write.h"
 
write *write::m_write= NULL;
 
write::write()
{
	m_writeUI = dynamic_cast<app*>(QApplication::instance());
}
 
write *write::instance()
{
    if(m_write == NULL)
    m_write = new write();
 
    return m_write;
}
 
void write::writeTest()
{
    m_writeUI->m_mainWindowUI.mainQLabelTest->setText("main label test"); //OK, it works
}

---

Code:

---

-----------------------------secondWindow.h----------------------------------
#ifndef __secondWindow_h
#define __secondWindow_h
 
#include "ui_secondWindow.h"
#include "app.h"
 
class secondWindow : public QMainWindow
{
    friend class read;
	friend class app;
    igstkStandardClassBasicTraitsMacro(secondWindow, QMainWindow);
    Q_OBJECT
 
public:
    igstkStateMachineMacro();
 
    secondWindow(QWidget *parent= 0);
    virtual ~secondWindow();
    void createSignalAndSlots();
 
public slots:
    void secondWindowTest();
 
private:
    Ui::secondWindow	m_secondWindowUI;
};
#endif
 
-----------------------------secondWindow.cxx----------------------------------
#include "secondWindow.moc"
#include "secondWindow.h"
#include "read.h"
 
secondWindow::secondWindow(QWidget *parent) :m_StateMachine(this)
{
    m_secondWindowUI.setupUi(this);
    createSignalAndSlots();
}
 
secondWindow::~secondWindow(){}
 
void secondWindow::createSignalAndSlots()
{
    connect(m_secondWindowUI.pushButton1, SIGNAL(clicked()),this, SLOT(secondWindowTest()));
    connect(m_secondWindowUI.pushButton2, SIGNAL(clicked()), read::instance(), SLOT(readTest()));
}
 
void secondWindow::secondWindowTest()
{
    m_secondWindowUI.pushButton1->setEnabled(true); //OK, it works
}
 
-----------------------------read.h----------------------------------
#pragma once
 
#include "secondWindow.h"
 
class read : public QObject
{
    Q_OBJECT
 
public:
    static read *instance();
    read();
    virtual ~read() {}
 
public slots:
    void readTest();
 
protected:
    app		*m_readUI;
    static read 	*m_read;
 
private:
};
 
-----------------------------read.cxx----------------------------------
#include <read.moc>
#include "secondWindow.h"
#include "read.h"
 
read *read::m_read= NULL;
 
read::read()
{
    m_readUI = dynamic_cast<app*>(QApplication::instance());
}
 
read *read::instance()
{
    if(m_read == NULL)
    m_read = new read();
 
    return m_read;
}
 
void read::readTest()
{
    m_readUI->m_secondWindowUI.secondQLabelTest->setText("second label test"); //ERROR, it works but no reaction 
}

---

Code:

---

-----------------------------app.h----------------------------------
#pragma once
 
class mainWindow; 
class secondWindow;
 
class app : public QApplication
{
  Q_OBJECT
  igstkStandardClassBasicTraitsMacro(app, QApplication);
 
  friend class read;
  friend class write;
  friend class mainWindow;
  friend class secondWindow;
 
public:
  app(int& argc, char **argv);
  virtual ~app() {}
 
protected:
	mainWindow	*m_mainWin;
	secondWindow	*m_secondWin;
 
	void setMainWindow(mainWindow *mainWindow)
	{
		m_mainWin = mainWindow;
	}
 
	void setSecondWindow(secondWindow *secondWindow)
	{
		m_secondWin = secondWindow;
	}
private:
};
 
-----------------------------app.cxx----------------------------------
#include "app.moc"
#include "app.h"
 
app::app(int& argc, char **argv): QApplication(argc, argv), m_StateMachine(this){
}
 
-----------------------------main.cxx----------------------------------
#include "mainWindow.h"
#include "secondWindow.h"
#include "app.h"
 
int main(int argc, char** argv)
{ 
	app app(argc, argv);
 
	mainWindow main;
	secondWindow second;
 
	app.setMainWindow(&main);
	app.setSecondWindow(&second);
 
	main.showMaximized();
 
	return app.exec();
}

---