Question

I have two windows: mainwindow.ui and dialog.ui. In the mainwindow.cpp I initialise some objects on the heap of another class for Ethernet-communication and use functions of these objects to read date from the bus and show the values in the mainwindow.ui. In dialog.ui I would like to set the values on the bus, but the problem is to access the communication-functions and objects in mainwindow.cpp.
I wanted to define dialog.cpp as friend class, but I make something wrong. Here is some code:

mainwindow.h

class MainWindow : public QMainWindow 
{protected: DateReg *myPosReg;...}

mainwindow.cpp

...   
myPosReg = new DateReg(DateValue->AddReg());
...
myPosReg->GetValue(a,b,c);
myPosReg->setValue(a,b,c);
    ...

Can I somehow access setValue() function in dialog.cpp? Should I allways use dialog.cpp for the dialog.ui or there is some possibility work with dialog.ui-date in mainwindow.cpp? To set the values in dialog.ui I use QDoubleSpinBox.
In the mainwindow.ui I call dialog.ui.
Excuse me for my English.

Answer 1

As far as I understand, you have two classes: MainWindow and Dialog. As MainWindow::myPosReg is protected, you can only access it in Dialog, if Dialog derives from MainWindow or if it is a friend.

The following design should work:

class MainWindow : public QMainWindow 
{
    [...]
  protected: 
    DateReg *myPosReg; 
    friend class Dialog; 
};

class Dialog
{
    [...]
    MainWindow* myMainWindow;

    void someFunction()
    {
        myMainWindow->myPosReg->setValue([...]);
    }
};

As an alternative, I would suggest a more Qt-ish way by using signals and slots. When the spin-boxes in Dialog change, emit a signal to which MainWindow listens.

We start with the dialog:

class Dialog : public QDialog
{
    [...]
    Dialog()
    {
        [...init ui...]
        connect(ui->spinBoxA, SIGNAL(valueChanged(int)),
                this, SLOT(onSpinBoxValueChanged()));
        connect(ui->spinBoxB, SIGNAL(valueChanged(int)),
                this, SLOT(onSpinBoxValueChanged()));
        connect(ui->spinBoxC, SIGNAL(valueChanged(int)),
                this, SLOT(onSpinBoxValueChanged()));
    }

  signals:
    void valuesChanged(int a, int b, int c);

  private slots:
    void onSpinBoxValueChanged()
    {
        emit valuesChanged(ui->spinBoxA->value(), ui->spinBoxB->value(),
                           ui->spinBoxC->value());
    }
};

So the dialog has an internal slot onSpinBoxValueChanged(), which is called when
one of the spinboxes changes its value. The sole purpose of this slot is to emit
another signal valuesChanged to which we’ll connect the main window (i.e. the
dialog’s internal slot combines three values into one signal).

The main window could be the following:

class MainWindow : public QMainWindow
{
    [...]
    DateReg *myPosReg;
  public slots:
    void setValues(int a, int b, int c)
    {
        myPosReg->setValues(a, b, c);
    }
};

And the code, which connects both

int main()
{
    [...]
    MainWindow* mainWindow = new MainWindow;
    Dialog* dialog = new Dialog;
    connect(dialog, SIGNAL(valuesChanged(int,int,int)),
            mainWindow, SLOT(setValues(int,int,int)));
}

When the user changes the value in a spinbox, the following chain-reaction happens:

QSpinBox::valueChanged(int) -> Dialog::onSpinBoxValueChanged() 
  -> Dialog::valuesChanged() -> MainWindow::setValues() -> DateReg::setValues()

The advantage is that you decouple MainWindow and Dialog: Dialog just signals that the values have changed but does not care what happens with them and MainWindow changes its myPosReg but does not care, where the values are coming from.