qt5/c++ - trying to access a QmainWindow control from another class

[jimbo]

Hello,

class 1
Its a QMainWindow called mainwindow, the form contains a QComboBox (myCombo - its populated).

class 2
I'm trying to access a control in class 1 from class 2.
QString where = mainwindow::myCombo->currentText();

myCombo is private.
error: 'QComboBox* mainwindow::myCombo' is private

I make the QComboBox public.
error: invalid use of member 'mainwindow::myCombo' in static member function

I make the QComobox static.
error: undefined reference to `mainwindow::myCombo'

I obviously don't understand the access method.
The internet hasn't helped me.

Is this something to do with declaring 'extern' or maybe use signals & slots.
Can somebody please help. Thanks in advance.

Regards

[d_stranz]

Do you know C++? Is "mainwindow" that name of the class or is it the name of a variable of type QMainWindow? If it is the name of a class, then mainwindow::myCombo is telling the compiler you want to access a static member variable called "myCombo" of the mainwindow class.

You first need to make the instance of your mainwindow class visible to "class2", then if you have made the myCombo variable public (a dumb thing to do), you access it via "myMainWindow->myCombo->whatever()"

The smarter way to do it is to implement a public member function in your mainwindow class that returns the combobox text:

mainwindow.h:
class mainwindow : public QMainWindow
{
 //...
public:
  const QString & getCurrentText() const { return myCombo->currentText(); }
//...
];

mainwindow.h:
class mainwindow : public QMainWindow
{
 //...
public:
  const QString & getCurrentText() const { return myCombo->currentText(); }
//...
];

To copy to clipboard, switch view to plain text mode 

Then you don't have to make "myCombo" a public variable, and in fact you can replace the QComboBox with a QFooBarBazStringWidget and the rest of your program won't know the difference. All your program needs to know is that it can ask a mainwindow instance for the current text through a method call. It doesn't need to know where that text comes from.

[jimbo]

Hello d_stranz,

Thanks for your reply.

Do you know C++?

A little, I'm trying to learn (Albeit, very slowly).

I will have a play with your suggestion and see how far I get.
I've got to check out the meaning of (make the instance of your mainwindow class visible to "class2").

I will post, how I get on.

Regards

myHeaderName.h:
class mainwindow : public QMainWindow
{
    Q_OBJECT
 
public:
    mainwindow(QWidget *parent = 0);
    ~mainwindow();
    const QString & getCurrentText() const { return myCombo->currentText(); }
    //,,,
};

myHeaderName.h:
class mainwindow : public QMainWindow
{
    Q_OBJECT

public:
    mainwindow(QWidget *parent = 0);
    ~mainwindow();
    const QString & getCurrentText() const { return myCombo->currentText(); }
    //,,,
};

To copy to clipboard, switch view to plain text mode 

[d_stranz]

I've got to check out the meaning of (make the instance of your mainwindow class visible to "class2").

In the main() method of your app, you should have something like this, right?

#include <QApplication>
 
#include "mainwindow.h"
 
int main(int argc, char *argv[])
{
     QApplication app(argc, argv);
 
    mainWindow mainWin;
    mainWin.show();
    return app.exec();
}

#include <QApplication>

#include "mainwindow.h"

int main(int argc, char *argv[])
{
     QApplication app(argc, argv);
    
    mainWindow mainWin;
    mainWin.show();
    return app.exec();
}

To copy to clipboard, switch view to plain text mode 

"mainWin" is an instance of the mainwindow class. In this case, there is only one instance of it in your application. You need to make a pointer to this instance visible to "class2" if you want to be able to call any of the mainwindow methods.

You don't explain what "class2" is or how you create an instance of it. If it is being created within some method of mainwindow (like the constructor, maybe), then you can simply give the instance of class2 a pointer to the mainwindow instalce when you create it:

// class2.h
 
#include "mainwindow.h"
 
class class2 : public QSomeWidget
{
  Q_OBJECT
 
public:
   class2( QWidget * parent ) : QSomeWidget( parent ), mpMainWind( 0 ) {}
 
   void setMainWindowPointer( mainwindow * pMW ) { mpMainWind = pMW; }
 
private:
  mainwindow * mpMainWind;
}
 
// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   pClass2->setMainWindowPointer( this );
   return pClass2;
}

// class2.h

#include "mainwindow.h"

class class2 : public QSomeWidget
{
  Q_OBJECT

public:
   class2( QWidget * parent ) : QSomeWidget( parent ), mpMainWind( 0 ) {}

   void setMainWindowPointer( mainwindow * pMW ) { mpMainWind = pMW; }

private:
  mainwindow * mpMainWind;
}

// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   pClass2->setMainWindowPointer( this );
   return pClass2;
}

To copy to clipboard, switch view to plain text mode 

This is redundant, though - the parent QWidget of the class2 instance is already the mainwindow instance, so you don't need to store an extra pointer to it. However, if class2 is being created as a child of some other widget, then you will need to store the pointer as shown.

But this stinks as far as a design goes. Widgets in a program shouldn't really have to know that much about each other or keep pointers to each other as part of their data. Qt's signals and slots mechanism was designed to allow different parts of a program to communicate information between them without the parts having to know very much about each other.

So instead of class2 "pulling" the text from mainwindow, you could connect a slot in class2 (like, setCurrentText( const QString & )) to the QComboBox::currentTextChanged() signal from the combobox in the mainwindow UI. You do this when you create your instance of class2:

// class2.h
 
#include <QString>
 
class class2 : public QSomeWidget
{
  Q_OBJECT
 
public:
   class2( QWidget * parent ) : QSomeWidget( parent ) {}
 
public slots:
   void setCurrentText( const QString & text ) { mCurrentText = text; }
 
private:
  QString mCurrentText;
}
 
// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   connect ( myCombo, SIGNAL( currentTextChanged( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );
 
   // If you want the class2 text to be updated any time the combobox is clicked, not just when the selection changes, then:
   connect ( myCombo, SIGNAL( activated( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );
 
   return pClass2;
}

// class2.h

#include <QString>

class class2 : public QSomeWidget
{
  Q_OBJECT

public:
   class2( QWidget * parent ) : QSomeWidget( parent ) {}

public slots:
   void setCurrentText( const QString & text ) { mCurrentText = text; }

private:
  QString mCurrentText;
}

// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   connect ( myCombo, SIGNAL( currentTextChanged( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );

   // If you want the class2 text to be updated any time the combobox is clicked, not just when the selection changes, then:
   connect ( myCombo, SIGNAL( activated( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );

   return pClass2;
}

To copy to clipboard, switch view to plain text mode 

[jimbo]

Hello d_stranz,

Thanks for your reply.

In the main() method of your app, you should have something like this, right?

Yes.

You don't explain what "class2" is

Class2 is a set of functions (only) to do with I/O and disk/file manipulation.

You've given me somewhere to start. If the worst comes to the worst, I can revert to placing all these functions back into class1.
They were only separated to clean things up a little.

Regards

[d_stranz]

Class2 is a set of functions (only) to do with I/O and disk/file manipulation.

OK, so they need to know something about which file to open or something like that based on a choice made in a combo box on the main window form? And presumably you are creating a class2 instance from within your mainwindow class somewhere?

Then I would derive class2 from QObject (making sure not to forget to add the Q_OBJECT macro at the top of the class definition). When you create it, you can choose to make the mainwindow instance the parent or not. In any case, if you need only one of them, be sure you implement the creation in such a way that you don't end up creating a new one on every button click or whatever. It's basically the same as the last code snippet I posted, changing the base class for class2:

// class2.h
 
#include <QObject>
#include <QString>
 
class class2 : public QObject
{
  Q_OBJECT
 
public:
   class2( QObject * parent ) : QObject( parent ) {}
 
public slots:
   void setCurrentText( const QString & text ) { mCurrentText = text; }
 
private:
  QString mCurrentText;
}
 
// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   connect ( myCombo, SIGNAL( currentTextChanged( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );
 
   // If you want the class2 text to be updated any time the combobox is clicked, not just when the selection changes, then:
   connect ( myCombo, SIGNAL( activated( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );
 
   return pClass2;
}

// class2.h

#include <QObject>
#include <QString>

class class2 : public QObject
{
  Q_OBJECT

public:
   class2( QObject * parent ) : QObject( parent ) {}

public slots:
   void setCurrentText( const QString & text ) { mCurrentText = text; }

private:
  QString mCurrentText;
}

// mainwindow.cpp 
class2 * mainwindow::createClass2()
{
   class2 * pClass2 = new class2( this );
   connect ( myCombo, SIGNAL( currentTextChanged( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );

   // If you want the class2 text to be updated any time the combobox is clicked, not just when the selection changes, then:
   connect ( myCombo, SIGNAL( activated( const QString & ) ), pClass2, SLOT( setCurrentText( const QString & ) ) );

   return pClass2;
}

To copy to clipboard, switch view to plain text mode 

You still retain the encapsulation of your I/O methods in class2, plus you add some encapsulation and separation of the mainwindow UI objects. All mainwindow needs to know about class2 is that it has a setCurrentText slot, and class2 doesn't know anything at all about mainwindow. If class2 needs to notify mainwindow when it has finished some I/O operation, then give it a signal to pass information that mainwindow can also connect up to .

This one of the great things about Qt's signals and slots mechanism. You could completely replace the internals of class2 while retaining the signals and slots, and mainwindow wouldn't have a clue (or need to know). Likewise, *anything* that has a signal with a const QString & argument could be connected to class2's slot, and it wouldn't know or care.