3. Zugriff auf UI elemente in anderer Klasse

Zugriff auf UI elemente in anderer Klasse

  • N

    Hallo,

    Ich habe ein Zugriffsproblem auf UI-Elementen in einer anderen Klasse. In meinem Programm habe ich ein zweites QMainWindow (initialziert in secondWindow.h), in der secondWindow.cxx Klasse kann ich auf alle GUI-Elemente problemlos zugreifen aber wenn ich in der "read.cxx" Klasse auf UI-Elemente zugreifen will, bekomme ich segmentation fault. Wo könnte mein Fehler liegen? Danke im voraus.

    -----------------------------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

----------------------------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(){}

---------------------------------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:
};

---------------------------------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
}
    0
  • N

    Vielleicht solltest du m_readUI auch initialisieren, bevor du es verwendest...

    0
  • N

    Nathan schrieb:

    Vielleicht solltest du m_readUI auch initialisieren, bevor du es verwendest...

    protected: 
     secondWindow    *m_readUI;

    Ist es somit nicht initializiert? verstehe nicht. Beim indexieren (ctrl+space) in eclipse sind alle UI elemente sichtbar.

    0
  • N

    Nein. Der Zeiger ist definiert.
    Beim Erzeugen des Objektes (via Konstruktor) wird die rohe sizeof(zeiger) lange Bitfolge als Adresse interpretiert auf das der Zeiger nun zeigt.
    Wenn du ihn nun verwendest wird das Objekt, was auch immer auf dieser Adresse ist, als secondWindow interpretiert und die rohe Bytefolge evtl. verändert. Das ergibt einen segmentation fault (schutzverletzung), weil dein Programm Werte verändert, die es nicht veränden dürfte (z.B. Variablen von anderen Programmen oder so).
    Deshalb solltest du den Zeiger im Konstruktor initialisieren, sprich, er soll auf ein Objekt zeigen, was dir auch gehört.

    Edit: Das, was du auskommentiert hattest, war schon richtig.

    0
  • N

    Hallo,

    Tut mir leid für verspätete Antwort. segmentation fault habe ich jetzt hinter mir, in mein Programm habe ich zusätzlich eine neue Klasse "app" hinzugefügt, in der ich benötighte Initialisierungen vornehme. Aber dieses Mal habe ich ein anderes Problem. Wenn ich auf dem "secondWindow" aufs "pushButton2" klicke, passiert gar nichts, keine reaktion. Vllt. sollte ich mein ganzes Programm posten, damit Sie mir weiter helfen können.

    Danke im Voraus.

    -----------------------------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, es funktioniert
}

-----------------------------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, es funktioniert
}

    -----------------------------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, es funktioniert
}

-----------------------------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"); //FEHLER, es passiert nichts
}

    -----------------------------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();
}
    0
Anmelden zum Antworten