How to access to a var in the main window (QWidget) from an other window (QWidget)???

In my project i have this 4 classes in separated .h and .cpp file:

Code:

---

MainWindow::MainWindow(QWidget *parent): QWidget (parent){   
    built_sphere_window   = new BuiltSphere;
    built_cylinder_window = new BuiltCylinder;
    glWidgetWindow = new GlWidget;
....}
 
BuiltCylinder::BuiltCylinder(QWidget *parent) : QWidget(parent){
    glWidgetCylinder = new GlWidget;
....}
 
BuiltSphere::BuiltSphere(QWidget *parent) : QWidget(parent)
{
    glWidgetSphere = new GlWidget;
....}
 
GlWidget::GlWidget(QWidget *parent) : QGLWidget(QGLFormat(/* Additional format options */), parent){
    alpha = 0;      //previous =>25
    beta = 0;       //previous =>-25
    distance = 6;   //previous =>2.5
    initializeWindow();
....}

---

from the "mainwindow" i do this calls:

Code:

---

void MainWindow::built_sphere(){
    built_sphere_window->setWindowTitle("Built Sphere");
    built_sphere_window->setWindowModality(Qt::ApplicationModal);
    built_sphere_window->num_sphere = num_element_inserted->at(1)+1;
    built_sphere_window->show();
}
void MainWindow::built_cylinder(){
    built_cylinder_window->setWindowTitle("Built Cylinder");
    built_cylinder_window->setWindowModality(Qt::ApplicationModal);
    built_cylinder_window->num_cyl = num_element_inserted->at(0)+1;
    built_cylinder_window->show();
}

---

I have several object to build but at this time just the previous 2.
when i open one of this window i to read the data from the respective var & i'm right to visualize the number of the new object that i want to build.
My question is:
how i can set correctly the signal to send to mainwindow the number that i want only at push to ok button in the build window?
in mainwindow.cpp i think i have to set (i write the call for one build element):

Code:

---

connect (built_sphere_window, SIGNAL (sig_update_num(const int)), this, SLOT (update_value(const float)));

---

and in the respective slot update the num_element_inserted.
in builtsphere.h:

Code:

---

signals:
     void sig_update_num(const int);

---

in builtsphere.cpp:

Code:

---

emit sig_update_num(num_sphere+1)

---

I think that the code write like this work, my finally question is:
if i want to read/write a value that is stored in a variable in the main window or in all of other classes from one of it is better do a "QSharedMemory+signal in a class like shareddata.h" to do the job or with the code that i write above?
At this time i do my application in one thread (i want to test it first that run correctly & do the job that i want), next step is do multithread to optimize the performance in multicore processor; so i think that in multithread is better to build a class shareddata.h where i can use the lock() & unlock() functions, is the right way to do the job?

[QUOTE=andreaQt;308744]In my project i have this 4 classes in separated .h and .cpp file:

Code:

---

MainWindow::MainWindow(QWidget *parent): QWidget (parent){   
    built_sphere_window   = new BuiltSphere;
    built_cylinder_window = new BuiltCylinder;
    glWidgetWindow = new GlWidget;
....}
 
BuiltCylinder::BuiltCylinder(QWidget *parent) : QWidget(parent){
    glWidgetCylinder = new GlWidget;
....}
 
BuiltSphere::BuiltSphere(QWidget *parent) : QWidget(parent)
{
    glWidgetSphere = new GlWidget;
....}
 
GlWidget::GlWidget(QWidget *parent) : QGLWidget(QGLFormat(/* Additional format options */), parent){
    alpha = 0;      //previous =>25
    beta = 0;       //previous =>-25
    distance = 6;   //previous =>2.5
    initializeWindow();
....}

---

from the "mainwindow" i do this calls:

Code:

---

void MainWindow::built_sphere(){
    built_sphere_window->setWindowTitle("Built Sphere");
    built_sphere_window->setWindowModality(Qt::ApplicationModal);
    built_sphere_window->num_sphere = num_element_inserted->at(1)+1;
    built_sphere_window->show();
}
void MainWindow::built_cylinder(){
    built_cylinder_window->setWindowTitle("Built Cylinder");
    built_cylinder_window->setWindowModality(Qt::ApplicationModal);
    built_cylinder_window->num_cyl = num_element_inserted->at(0)+1;
    built_cylinder_window->show();
}

---

I have several object to build but at this time just the previous 2.
when i open one of this window i to read the data from the respective var & i'm right to visualize the number of the new object that i want to build.
My question is:
how i can set correctly the signal to send to mainwindow the number that i want only at push to ok button in the build window?
in mainwindow.cpp i think i have to set (i write the call for one build element):

Code:

---

connect (built_sphere_window, SIGNAL (sig_update_num(const int)), this, SLOT (update_value(const float)));

---

and in the respective slot update the num_element_inserted.
in builtsphere.h:

Code:

---

signals:
     void sig_update_num(const int);

---

in builtsphere.cpp:

Code:

---

emit sig_update_num(num_sphere+1)

---

I think that the code write like this work, my finally question is:
if i want to read/write a value that is stored in a variable in the main window or in all of other classes from one of it is better do a "QSharedMemory+signal in a class like shareddata.h" to do the job or with the code that i write above?
At this time i do my application in one thread (i want to test it first that run correctly & do the job that i want), next step is do multithread to optimize the performance in multicore processor; so i think that in multithread is better to build a class shareddata.h where i can use the lock() & unlock() functions, is the right way to do the job?

After some test i have integrated this code & its work:

Code:

---

void MainWindow::built_sphere(){
    built_sphere_window->setWindowTitle("Built Sphere");
    built_sphere_window->setWindowModality(Qt::ApplicationModal);
    built_sphere_window->num_sphere = num_element_inserted.at(0)+1;
    built_sphere_window->num_sphere_label->setText(tr("Sphere %1").arg(QString::number(built_Sphere_window->num_cyl)));
    built_sphere_window->show();
}

---

I still waiting for an answer about "QSharedMemory+signal in a class like shareddata.h"

It is almost impossible to understand from your description what it is that you actually want to do. Forget the "build_this", "build_that" code and all of the other irrelevant stuff. What is the design problem you are trying to solve?

1 - What is the purpose of the variable in the main window class? What kind of value does it hold?
2 - Why is it necessary for other class instances to know what its value is?
3 - Do these other class instances need to read the value, or do they need read -and- write access?
4 - Do all of the class instances need to know when the value changes?

Until you can answer these questions and understand how to implement a general solution, you should stay away from any thoughts of multithreading, shared data, smart pointers or anything even close to that. You need to have a basic understanding first because if you don't have that, you will fail when you try to implement something more complex.

Note: when i write like read/write i want to say: do one of the action or both the actions

This is the flow o my action:
1 - From mainwindow i select to build some object by select it in a toolbar => is open the respective built_OBJ_window=> for example built_sphere_window, so when it is opened i have to
understood how many of this object is builted previously; for do this i have in mainwindow a "QVector<int> num_element_inserted;" to take trace about it.
So when i open a new built_sphere_window i want to know with obj i'm going to work & view it in the dedicate label ->num_sphere_label, only at pressing at OK button i update
"QVector<int> num_element_inserted" by calling "num_element_inserted.operator[](0) = num_cyl_inserted+1;" in a dedicated slot after i build the obj; if i press on a CANCEL
button no update is done, no obj is builded. This is my 1st goal.
2 - Next i have buided a obj & stored the data in (on glWidgetWindow):

Code:

---

struct OBJ_draw {
          QString   name;
          int          color;
          int          type_elements;
          QVector<QVector3D> draws_elements;
          };
QList<OBJ_draw>  list_draws_elements;

---

next step i have to build in the toolbar (at first it but next a procedure to save/load data & so on) in mainwindow a edit call that open a window where i edit one or more obj (like his
color or its position, ecc.) so i have to access on "QVector<QVector3D> draws_elements" to do the job (i'm building an opportune class) - so i have to share some data that is stored
in glWidgetWindow with some other classes.

My 2nd goal is to know in general cases if is it better to build "QSharedMemory+signal in a class like shareddata.h" when i have to share lot of data => so in all the class that i will
built i have just to include shareddata.h to access to the data that i want, and in general in a multithread application when i have a lot of data shared by more of one thread is better to
share the data in a shared memory & use the mechanism on lock/unlock to do a right job

Quote:

---

"QVector<int> num_element_inserted" by calling "num_element_inserted.operator[](0) = num_cyl_inserted+1;"

---

Why are you using a QVector when you are only updating element 0? I think you are confusing counting the number of elements with the index (label) of the element.

It does not sound like you are actually sharing any data at all. What you seem to be doing is trying to tell another dialog or widget that constructs the object what the next index is so it can set the proper label on the object. For that, all you need to do it to pass the number before you show() the window. And then you need to add signals to the widget that get emitted when the OK or Cancel buttons are clicked, and add slots for those signals to your MainWindow.

Code:

---

MainWindow::MainWindow(QWidget *parent): QWidget (parent){   
    built_sphere_window   = new BuiltSphere;
    built_cylinder_window = new BuiltCylinder;
    glWidgetWindow = new GlWidget;
 
    connect( build_sphere_window, &BuiltSphere::okClicked, this, &MainWindow::buildSphereOKClicked );
    connect( build_sphere_window, &BuiltSphere::cancelClicked, this, &MainWindow::buildSphereCancelClicked );
 
    // same for BuiltCylinder, etc.
....}
 
void MainWindow::built_sphere(){
    built_sphere_window->setWindowTitle("Built Sphere");
    built_sphere_window->setWindowModality(Qt::ApplicationModal);
 //   built_sphere_window->num_sphere = num_element_inserted->at(1)+1;  // NO.  --Never-- expose member variables.  Use method calls.
    build_sphere_window->setSphereIndex( num_element_inserted->at(1) + 1 );
    built_sphere_window->show();
}
 
void MainWindow::buildSphereOKClicked()
{
    build_sphere_window->hide();
    num_element_inserted->at(1) += 1;
}
 
void MainWindow::buildSphereCancelClicked()
{
    build_sphere_window->hide();
}

---

Quote:

---

My 2nd goal is to know in general cases if is it better to build "QSharedMemory+signal in a class like shareddata.h" when i have to share lot of data

---

As I said, you aren't sharing data. There is a difference between telling another class instance what the value of some piece of data is when that other class instance needs to know it, and actually sharing access to the same data location. You are not sharing the variable itself, you are sharing its value. These are different things.

You are making a common mistake in assuming that the only way to share the value of variables among different classes is to share the variables themselves. That's wrong.

Look at the way Qt classes themselves are implemented. There are "getter / setter" methods for almost every property of a widget that is exposed to the application. If you want to set the title of a window, you do not assign the variable that holds the title string, you call a method with a string argument, and that method (inside QWidget) sets the title. That is, you are doing this:

Code:

---

// getter
QString currentTitle = myWidget->windowTitle();

---

Code:

---

// setter
myWidget->setWindowTitle( "This is My Widget" );

---

and not:

Code:

---

// wrong
myWidget->windowTitle = "This is My Widget";

---

You should be doing the same in your application. I have been programming in C++ for 40 years, and have been using Qt for 12 years, and I have never had to use shared memory of any sort in an ordinary application. Even in multithreaded applications, there is never shared memory. There is shared access to the values of variables, always through getter/setter methods, and always protected by mutexes or other multithread locking methods.

If you think you have to use shared memory, then you have a bad design which is only going to get you into trouble. Your application should be designed in a way that only one class has control (ownership) of any piece of data, and other classes have methods they call to ask for the current value of the data or ask the owner of the data to change its value.