c++ - अपने खुद के क्यूटी अनुप्रयोग को कैसे आरंभ करना है?




qt qt4 (6)

मैं खुद से पूछ रहा हूं कि कैसे अपना खुद का क्यूटी अनुप्रयोग पुनः आरंभ करें?

क्या कोई मुझे एक उदाहरण दिखा सकता है?


Qtcentre.org पर एक एप्लिकेशन थ्रेड को पुनरारंभ करने के तरीके पर एक नज़र डालें, जहां मूवी इस कोड को देते हैं

#define RESTART_CODE 1000
int main(int argc, char *argv[])
{
  int return_from_event_loop_code;
  QPointer<QApplication> app;
  QPointer<MainWindow> main_window;
  do
  {
    if(app) delete app;
    if(main_window) delete main_window;

    app = new QApplication(argc, argv);
    main_window = new MainWindow(app);
    return_from_event_loop_code = app->exec();
  }
  while(return_from_event_loop_code==RESTART_CODE)

  return return_from_event_loop_code;
}

मैं अन्य उत्तर समाधान ले रहा हूं, लेकिन बेहतर है पॉइंटर्स के लिए कोई ज़रूरत नहीं है, लेकिन इसकी आवश्यकता है ; एक कब के while बयान के बाद do { ... } while( ... ); निर्माण।

int main(int argc, char *argv[])
{
    const int RESTART_CODE = 1000;

    do
    {
        QApplication app(argc, argv);
        MainWindow main_window(app);
    } while( app.exec() == RESTART_CODE);

    return return_from_event_loop_code;
}

एप्लिकेशन को पुनरारंभ करने के लिए, कोशिश करें:

#include <QApplication>
#include <QProcess>

...

// restart:
qApp->quit();
QProcess::startDetached(qApp->arguments()[0], qApp->arguments());

रूबेविन के विचार पर यह मामूली बदलाव PyQt के साथ काम करता है। clearSettings को clearSettings करने वाली विधि है।

class GuiMain

    #Most of implementation missing

    def clearSettings(self):
        #Clearing the settings missing
        QApplication.exit(GuiMain.restart_code)

    restart_code = 1000

    @staticmethod
    def application_main():
        """
        The application's main function. 
        Create application and main window and run them.
        """
        while True:
            app = QApplication(sys.argv)
            window = GuiMain()
            window.show()
            ret = app.exec_()
            if ret != GuiMain.restart_code:
                break
            del window
            del app

यहां कोड है:

main.cpp:

int main(int argc, char *argv[])
{
    int currentExitCode = 0;

    do {
     QApplication a(argc, argv);
     MainWindow w;
     w.show();
     currentExitCode = a.exec();
    } while( currentExitCode == MainWindow::EXIT_CODE_REBOOT );

    return currentExitCode;

}

mainwindow.h

    class MainWindow : public QMainWindow
    {
        Q_OBJECT

    public:
        explicit MainWindow(QWidget *parent = 0);
        static int const EXIT_CODE_REBOOT;//THIS IS THE IMPORTANT THING TO ADD TO YOUR CODE
        ~MainWindow();
    private slots:
        void slotReboot();//AND THIS ALSO

    //ALL THE OTHER VARIABLES
    }

स्लॉट slotReboot() स्लॉट है जो कि मुख्य QActionQAction में QAction होने वाले QAction के संकेत प्राप्त करेगा I

mainwindow.cpp

सबसे पहले EXIT_CODE_REBOOT आरंभ EXIT_CODE_REBOOT :

int const MainWindow::EXIT_CODE_REBOOT = -123456789;

और एक QAction पॉइंटर घोषित करें:

QAction* actionReboot;

फिर मुख्य MainWindow निर्माता में:

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow)
{
    ui->setupUi(this);

     actionReboot = new QAction( this );
     actionReboot->setText( tr("Restart") );
     actionReboot->setStatusTip( tr("Restarts the application") );
     connect( actionReboot, SIGNAL (triggered()),this, SLOT (slotReboot()));
}

और अंत में आपको सिग्नल भेजने की जरूरत है (इस कोड में आपको अपने कोड के ज़रिये), इस तरह से:

actionReboot->trigger();

मैंने इन निर्देशों का पालन करते हुए मैंने जो कोड दिखाया है: एक आवेदन पुनरारंभ करने के लिए कैसे - क्यू टी विकी


उप-क्लासिंग के बिना एक वास्तविक प्रक्रिया को पुनरारंभ करना:

QCoreApplication a(argc, argv);
int returncode = a.exec();
if (returncode == -1)
{
  QProcess* proc = new QProcess();
  proc->start(QCoreApplication::applicationFilePath());
}
return returncode;

मैक ओएस जैसे पहले उदाहरण के लिए संपादित करें

कॉल को पुनः आरंभ करने के लिए

QCoreApplication::exit(-1);

कहीं आपके कोड में








application-restart