layui.open 弹出页面后怎么用parent调用父页面得方法，父页面的方法是class内声明的static函数

在弹出页面中，可以使用 `parent` 属性来获取父页面的 window 对象，然后通过类名来调用其中的静态方法。

例如，假设在父页面中定义了一个名为 `MyClass` 的类，并且其中有一个名为 `myStaticMethod` 的静态方法，可以通过以下方式在弹出页面中调用该方法：

// 弹出页面中调用父页面的静态方法
parent.MyClass.myStaticMethod();

其中，`parent` 属性可以获取父页面的 window 对象；`MyClass` 是父页面中定义的类名；`myStaticMethod` 是该类中定义的静态方法名。通过这种方式，就可以在弹出页面中调用父页面的静态方法了。

相关问题

layui.open 弹出页面后怎么用parent调用父页面得方法，父页面的方法是class内static对象下的函数

如果父页面的方法是类内 `static` 对象下的函数，可以通过以下方式在弹出页面中调用：

// 弹出页面中调用父页面的静态方法
parent.MyClass.myStaticObj.myStaticMethod();

其中，`parent` 属性可以获取父页面的 window 对象；`MyClass` 是父页面中定义的类名；`myStaticObj` 是该类中的静态对象，`myStaticMethod` 是该对象下的函数名。

需要注意的是，如果 `myStaticObj` 是在类的构造函数中初始化的，则需要先创建类的实例，才能通过实例来访问 `myStaticObj` 下的函数。例如：

// 父页面中定义的类
class MyClass {
  static myStaticObj = {
    myStaticMethod() {
      console.log('调用父页面的静态方法');
    }
  }
}

// 创建类的实例
const myClassInstance = new MyClass();

// 弹出页面中调用父页面的静态方法
parent.myClassInstance.constructor.myStaticObj.myStaticMethod();

这里，我们通过 `myClassInstance.constructor` 来获取 `MyClass` 的构造函数，然后通过 `myStaticObj` 和 `myStaticMethod` 访问静态对象下的函数。

非常非常非常详细地教我用Qt5.14.2制作一个函数图像绘制器。要求如下：1.有一个函数输入框，用户可以自行输入函数表达式。2.有一个确认键，点击之后会生成此时函数输入框内的函数的图像。3.图像的绘制用QCustomPlot来实现。4.有一个清除键，点击后可以清除生成的所有函数图像。5.有一个保存键，点击后可以保存此时的图像为jpg格式，并且可以自行选择保存地址。6.设置几个按钮，这些按钮代表一些常见的函数符号比如sin，cos，tan，log，ln等，点击这些按钮可以在函数输入框中添加这些符号。7.在每个文件下要写上什么代码，完整清楚地告诉我（包括头文件），以便我复制粘贴就能用。8.代码一定要完整且可用。9.一些Qt不自带的库的添加或者使用方法要清楚准确地告诉我。

好的，下面是详细的教程：

1. 首先，我们需要新建一个Qt Widgets Application项目。在新建项目的窗口中，勾选“Main Window”和“Qt Widgets”选项，然后点击“Choose”按钮。

2. 在新建项目的窗口中填写项目名称和保存路径，然后点击“Next”按钮。

3. 在选择类的窗口中，勾选“Create form”和“Main Window Form”，然后点击“Finish”按钮。

4. 接下来，我们需要添加QCustomPlot库。首先，在Qt Creator中打开项目文件夹，然后新建一个名为“libs”的文件夹。在这个文件夹中，新建一个名为“QCustomPlot”的文件夹。

5. 下载QCustomPlot库并解压到刚刚新建的QCustomPlot文件夹中。可以从官网https://www.qcustomplot.com/下载最新版的QCustomPlot库。

6. 在Qt Creator中，打开.pro项目文件，然后添加以下内容：

INCLUDEPATH += $$PWD/libs/QCustomPlot
LIBS += -L$$PWD/libs/QCustomPlot -lqcustomplot

7. 然后，在主窗口的.ui文件中，添加一个QLineEdit控件和一个QCustomPlot控件。在左侧的控件栏中，拖拽LineEdit和QCustomPlot到主窗口的中心位置。

8. 为了方便起见，我们将LineEdit控件和QCustomPlot控件分别命名为lineEdit和customPlot。在右侧的对象检查器中，选中lineEdit控件，然后在“属性编辑器”中将其命名为lineEdit。同样地，选中customPlot控件，然后在“属性编辑器”中将其命名为customPlot。

9. 接下来，我们需要在主窗口的.h文件中添加头文件和变量声明。打开MainWindow.h文件，在头文件部分添加以下内容：

#include <QMainWindow>
#include <QLineEdit>
#include "qcustomplot.h"

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    MainWindow(QWidget *parent = nullptr);
    ~MainWindow();

private slots:
    void onConfirmBtnClicked();
    void onClearBtnClicked();
    void onSaveBtnClicked();
    void onSinBtnClicked();
    void onCosBtnClicked();
    void onTanBtnClicked();
    void onLogBtnClicked();
    void onLnBtnClicked();

private:
    QLineEdit* lineEdit;
    QCustomPlot* customPlot;
};

10. 在MainWindow.h文件中，我们声明了一个MainWindow类，并添加了一些头文件。此外，我们还声明了一些私有变量lineEdit和customPlot，以及一些私有函数，这些函数将在稍后实现。

11. 接下来，我们需要在主窗口的.cpp文件中实现函数。打开MainWindow.cpp文件，在构造函数中添加以下内容：

MainWindow::MainWindow(QWidget *parent)
    : QMainWindow(parent)
{
    lineEdit = new QLineEdit(this);
    lineEdit->setGeometry(QRect(50, 50, 200, 25));

    customPlot = new QCustomPlot(this);
    customPlot->setGeometry(QRect(50, 100, 500, 300));

    QPushButton* confirmBtn = new QPushButton("Confirm", this);
    confirmBtn->setGeometry(QRect(300, 50, 75, 25));
    connect(confirmBtn, SIGNAL(clicked()), this, SLOT(onConfirmBtnClicked()));

    QPushButton* clearBtn = new QPushButton("Clear", this);
    clearBtn->setGeometry(QRect(400, 50, 75, 25));
    connect(clearBtn, SIGNAL(clicked()), this, SLOT(onClearBtnClicked()));

    QPushButton* saveBtn = new QPushButton("Save", this);
    saveBtn->setGeometry(QRect(500, 50, 75, 25));
    connect(saveBtn, SIGNAL(clicked()), this, SLOT(onSaveBtnClicked()));

    QPushButton* sinBtn = new QPushButton("sin", this);
    sinBtn->setGeometry(QRect(50, 425, 75, 25));
    connect(sinBtn, SIGNAL(clicked()), this, SLOT(onSinBtnClicked()));

    QPushButton* cosBtn = new QPushButton("cos", this);
    cosBtn->setGeometry(QRect(150, 425, 75, 25));
    connect(cosBtn, SIGNAL(clicked()), this, SLOT(onCosBtnClicked()));

    QPushButton* tanBtn = new QPushButton("tan", this);
    tanBtn->setGeometry(QRect(250, 425, 75, 25));
    connect(tanBtn, SIGNAL(clicked()), this, SLOT(onTanBtnClicked()));

    QPushButton* logBtn = new QPushButton("log", this);
    logBtn->setGeometry(QRect(350, 425, 75, 25));
    connect(logBtn, SIGNAL(clicked()), this, SLOT(onLogBtnClicked()));

    QPushButton* lnBtn = new QPushButton("ln", this);
    lnBtn->setGeometry(QRect(450, 425, 75, 25));
    connect(lnBtn, SIGNAL(clicked()), this, SLOT(onLnBtnClicked()));
}

MainWindow::~MainWindow()
{
    delete lineEdit;
    delete customPlot;
}

void MainWindow::onConfirmBtnClicked()
{
    // 实现函数图像的绘制
}

void MainWindow::onClearBtnClicked()
{
    customPlot->clearPlottables();
    customPlot->replot();
}

void MainWindow::onSaveBtnClicked()
{
    // 实现图像保存
}

void MainWindow::onSinBtnClicked()
{
    lineEdit->insert("sin()");
}

void MainWindow::onCosBtnClicked()
{
    lineEdit->insert("cos()");
}

void MainWindow::onTanBtnClicked()
{
    lineEdit->insert("tan()");
}

void MainWindow::onLogBtnClicked()
{
    lineEdit->insert("log()");
}

void MainWindow::onLnBtnClicked()
{
    lineEdit->insert("ln()");
}

12. 在MainWindow.cpp文件中，我们实现了MainWindow的构造函数和析构函数，以及一些槽函数，这些槽函数将在按钮被点击时被调用。

13. 接下来，我们需要实现onConfirmBtnClicked()槽函数，这个函数将绘制函数图像。在MainWindow.cpp文件中，添加以下代码：

void MainWindow::onConfirmBtnClicked()
{
    QString expression = lineEdit->text();
    QCPGraph* graph = customPlot->addGraph();
    graph->setPen(QPen(Qt::blue));

    QVector<double> x, y;
    for (double i = -10; i <= 10; i += 0.1)
    {
        double value = 0;
        std::string str = expression.toStdString();
        for (int j = 0; j < str.length(); j++)
        {
            if (str[j] == 'x')
            {
                str.replace(j, 1, std::to_string(i));
            }
        }
        value = Parser::parse(str);
        x.push_back(i);
        y.push_back(value);
    }

    graph->setData(x, y);
    customPlot->rescaleAxes();
    customPlot->replot();
}

14. 在onConfirmBtnClicked()槽函数中，我们首先获取lineEdit控件中的函数表达式。然后，我们创建一个QCPGraph对象，设置其颜色为蓝色。接下来，我们用循环计算出每个x坐标对应的y坐标，并将结果存储在一个QVector中。最后，我们将x和y数据设置给QCPGraph对象，并调用rescaleAxes()和replot()函数显示图像。

15. 在上面的代码中，我们使用了一个名为Parser的类，这个类可以将字符串表达式转换为计算结果。我们需要在项目中添加一个名为Parser.h的头文件，并将以下内容复制到其中：

#ifndef PARSER_H
#define PARSER_H

#include <string>
#include <stack>
#include <cmath>

class Parser
{
public:
    static double parse(std::string expression);

private:
    static double calculate(double op1, double op2, char op);
};

double Parser::parse(std::string expression)
{
    std::stack<double> nums;
    std::stack<char> ops;

    for (int i = 0; i < expression.length(); i++)
    {
        if (expression[i] == ' ')
            continue;

        if (expression[i] >= '0' && expression[i] <= '9')
        {
            double num = 0;
            while (i < expression.length() && ((expression[i] >= '0' && expression[i] <= '9') || expression[i] == '.'))
            {
                if (expression[i] == '.')
                {
                    i++;
                    int k = 1;
                    while (i < expression.length() && expression[i] >= '0' && expression[i] <= '9')
                    {
                        num += (expression[i] - '0') * pow(10, -k);
                        k++;
                        i++;
                    }
                }
                else
                {
                    num *= 10;
                    num += (expression[i] - '0');
                    i++;
                }
            }
            i--;
            nums.push(num);
        }
        else if (expression[i] == '(')
        {
            ops.push(expression[i]);
        }
        else if (expression[i] == ')')
        {
            while (ops.top() != '(')
            {
                double op2 = nums.top();
                nums.pop();
                double op1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                nums.push(calculate(op1, op2, op));
            }
            ops.pop();
        }
        else if (expression[i] == '+' || expression[i] == '-' || expression[i] == '*' || expression[i] == '/')
        {
            while (!ops.empty() && (ops.top() == '*' || ops.top() == '/'))
            {
                double op2 = nums.top();
                nums.pop();
                double op1 = nums.top();
                nums.pop();
                char op = ops.top();
                ops.pop();
                nums.push(calculate(op1, op2, op));
            }
            ops.push(expression[i]);
        }
        else if (expression[i] == 's' && i < expression.length() - 2 && expression[i+1] == 'i' && expression[i+2] == 'n')
        {
            ops.push('s');
            i += 2;
        }
        else if (expression[i] == 'c' && i < expression.length() - 2 && expression[i+1] == 'o' && expression[i+2] == 's')
        {
            ops.push('c');
            i += 2;
        }
        else if (expression[i] == 't' && i < expression.length() - 2 && expression[i+1] == 'a' && expression[i+2] == 'n')
        {
            ops.push('t');
            i += 2;
        }
        else if (expression[i] == 'l' && i < expression.length() - 1 && expression[i+1] == 'n')
        {
            ops.push('l');
            i += 1;
        }
        else if (expression[i] == 'l' && i < expression.length() - 2 && expression[i+1] == 'o' && expression[i+2] == 'g')
        {
            ops.push('g');
            i += 2;
        }
    }

    while (!ops.empty())
    {
        double op2 = nums.top();
        nums.pop();
        double op1 = nums.top();
        nums.pop();
        char op = ops.top();
        ops.pop();
        nums.push(calculate(op1, op2, op));
    }

    return nums.top();
}

double Parser::calculate(double op1, double op2, char op)
{
    double result = 0;
    switch (op)
    {
    case '+': result = op1 + op2; break;
    case '-': result = op1 - op2; break;
    case '*': result = op1 * op2; break;
    case '/': result = op1 / op2; break;
    case 's': result = sin(op2); break;
    case 'c': result = cos(op2); break;
    case 't': result = tan(op2); break;
    case 'l': result = log(op2); break;
    case 'g': result = log10(op2); break;
    }
    return result;
}

#endif // PARSER_H

16. 这个Parser类可以将一个字符串表达式转换为计算结果。Parser::parse()函数接受一个字符串表达式，返回一个double类型的结果。我们使用了两个栈，分别存储数字和运算符。对于每个字符，我们判断它是数字还是运算符，并进行相应的操作。比如，如果是数字，我们将它转换为double类型的数字，并将其压入数字栈中；如果是运算符，我们将它压入运算符栈中。当遇到括号时，我们需要将栈中的数字和运算符进行相应的计算。最后，当所有字符都处理完毕时，我们将栈中的数字和运算符进行相应的计算，得到最终结果。

17. 最后，我们需要实现onSaveBtnClicked()槽函数，这个函数将保存图像为jpg格式。在MainWindow.cpp文件中，添加以下代码：

void MainWindow::onSaveBtnClicked()
{
    QString filePath = QFileDialog::getSaveFileName(this, "Save Image", "", "JPEG (*.jpg)");
    if (!filePath.isEmpty())
    {
        QFile file(filePath);
        if (file.open(QIODevice::WriteOnly))
        {
            QPixmap pixmap = customPlot->toPixmap();
            pixmap.save(&file, "JPEG");
            file.close();
        }
    }
}

18. 在onSaveBtnClicked()槽函数中，我们首先打开一个文件对话框，让用户选择保存路径和文件名。然后，如果用户选择了一个有效的文件路径，我们使用QPixmap::toPixmap()函数将图像转换为QPixmap对象，并将其保存为jpg格式的文件。

19. 至此，我们的函数图像绘制器就完成了。可以编译运行程序，试着输入一些简单的函数表达式，比如“x^2”或“sin(x)”等，然后点击确认按钮查看图像。