Skip to content
TheChatArchiveThe Chat Archive
Claudeclaude-3-7-sonnet-20250219· AnthropicHugging Face LMArena Human Preference 140K

C++, wxwidgets версия 3.2.1, GUI. Проблема: в программе несколько xrc-файлов в которых…

From a Chatbot Arena battleThe same person sent this prompt to two anonymous models at once. Compare it with Claudeclaude-sonnet-4-20250514’s answer.
  1. User

    C++, wxwidgets версия 3.2.1, GUI. Проблема: в программе несколько xrc-файлов в которых много диалогов. При старте все это грузится, что замедляет запуск. Предлагается следующее решение. Весь фрагмент загрузки xrc-файлов выносится в отдельный тред. В программе нужно также добавить индикатор загрузки в статусную строку. Он будет отображать имена загружаемых файлов. Если к моменту вызова какого-то диалога вся загрузка не завершена, то должно быть реализовано ожидание. Можешь написать пример такой программы?

  2. Claude Assistant

    Я могу написать пример программы, которая реализует загрузку XRC-файлов в отдельном потоке с индикацией процесса в статусной строке. Вот пример:

    #include <wx/wx.h>
    #include <wx/xrc/xmlres.h>
    #include <wx/thread.h>
    #include <wx/statusbr.h>
    #include <wx/event.h>
    #include <vector>
    #include <mutex>
    #include <condition_variable>
    #include <atomic>
    
    // Пользовательское событие для обновления статусной строки
    wxDECLARE_EVENT(wxEVT_STATUS_UPDATE, wxCommandEvent);
    wxDEFINE_EVENT(wxEVT_STATUS_UPDATE, wxCommandEvent);
    
    // Пользовательское событие для сигнализации о завершении загрузки
    wxDECLARE_EVENT(wxEVT_LOADING_COMPLETE, wxCommandEvent);
    wxDEFINE_EVENT(wxEVT_LOADING_COMPLETE, wxCommandEvent);
    
    // Класс для загрузки XRC-файлов в отдельном потоке
    class XRCLoaderThread : public wxThread
    {
    public:
        XRCLoaderThread(wxEvtHandler* handler, const std::vector<wxString>& xrcFiles)
            : wxThread(wxTHREAD_JOINABLE), m_handler(handler), m_xrcFiles(xrcFiles), m_isComplete(false)
        {
        }
    
        bool IsLoadingComplete() const
        {
            return m_isComplete;
        }
    
        void WaitForCompletion()
        {
            std::unique_lock<std::mutex> lock(m_mutex);
            if (!m_isComplete)
            {
                m_condition.wait(lock, [this] { return m_isComplete; });
            }
        }
    
    protected:
        wxThread::ExitCode Entry() override
        {
            // Инициализация обработчика ресурсов
            wxXmlResource::Get()->InitAllHandlers();
    
            for (const auto& file : m_xrcFiles)
            {
                // Отправляем сообщение о текущем загружаемом файле
                wxCommandEvent event(wxEVT_STATUS_UPDATE);
                event.SetString(wxString::Format("Загрузка: %s", file));
                wxPostEvent(m_handler, event);
    
                // Имитация длительной загрузки
                wxMilliSleep(500);
    
                // Загрузка XRC-файла
                wxXmlResource::Get()->Load(file);
            }
    
            // Сигнализируем о завершении загрузки
            {
                std::lock_guard<std::mutex> lock(m_mutex);
                m_isComplete = true;
                m_condition.notify_all();
            }
    
            wxCommandEvent completeEvent(wxEVT_LOADING_COMPLETE);
            wxPostEvent(m_handler, completeEvent);
    
            return nullptr;
        }
    
    private:
        wxEvtHandler* m_handler;
        std::vector<wxString> m_xrcFiles;
        std::atomic<bool> m_isComplete;
        std::mutex m_mutex;
        std::condition_variable m_condition;
    };
    
    // Главное окно приложения
    class MainFrame : public wxFrame
    {
    public:
        MainFrame() : wxFrame(nullptr, wxID_ANY, "XRC Loader Example", wxDefaultPosition, wxSize(800, 600))
        {
            // Создаем статусную строку
            CreateStatusBar();
            SetStatusText("Запуск приложения...");
    
            // Создаем меню
            wxMenu* menuFile = new wxMenu;
            menuFile->Append(ID_ShowDialog1, "Показать диалог 1");
            menuFile->Append(ID_ShowDialog2, "Показать диалог 2");
            menuFile->AppendSeparator();
            menuFile->Append(wxID_EXIT, "Выход");
    
            wxMenuBar* menuBar = new wxMenuBar;
            menuBar->Append(menuFile, "Файл");
            SetMenuBar(menuBar);
    
            // Список XRC-файлов для загрузки
            std::vector<wxString> xrcFiles = {
                "dialog1.xrc",
                "dialog2.xrc",
                "dialog3.xrc",
                "dialog4.xrc",
                "dialog5.xrc"
            };
    
            // Запускаем поток загрузки XRC-файлов
            m_loaderThread = new XRCLoaderThread(this, xrcFiles);
            if (m_loaderThread->Run() != wxTHREAD_NO_ERROR)
            {
                wxLogError("Не удалось запустить поток загрузки XRC-файлов");
                delete m_loaderThread;
                m_loaderThread = nullptr;
            }
    
            // Привязываем обработчики событий
            Bind(wxEVT_STATUS_UPDATE, &MainFrame::OnStatusUpdate, this);
            Bind(wxEVT_LOADING_COMPLETE, &MainFrame::OnLoadingComplete, this);
            Bind(wxEVT_MENU, &MainFrame::OnShowDialog1, this, ID_ShowDialog1);
            Bind(wxEVT_MENU, &MainFrame::OnShowDialog2, this, ID_ShowDialog2);
            Bind(wxEVT_MENU, &MainFrame::OnExit, this, wxID_EXIT);
        }
    
        ~MainFrame()
        {
            if (m_loaderThread)
            {
                m_loaderThread->Wait();
                delete m_loaderThread;
            }
        }
    
    private:
        void OnStatusUpdate(wxCommandEvent& event)
        {
            SetStatusText(event.GetString());
        }
    
        void OnLoadingComplete(wxCommandEvent& event)
        {
            SetStatusText("Загрузка XRC-файлов завершена");
        }
    
        void OnShowDialog1(wxCommandEvent& event)
        {
            ShowDialog("dialog1");
        }
    
        void OnShowDialog2(wxCommandEvent& event)
        {
            ShowDialog("dialog2");
        }
    
        void ShowDialog(const wxString& dialogName)
        {
            // Проверяем, завершена ли загрузка XRC-файлов
            if (m_loaderThread && !m_loaderThread->IsLoadingComplete())
            {
                SetStatusText("Ожидание завершения загрузки XRC-файлов...");
                
                // Ожидаем завершения загрузки
                m_loaderThread->WaitForCompletion();
                
                SetStatusText("Загрузка XRC-файлов завершена");
            }
    
            // Теперь можно безопасно создать и показать диалог
            wxDialog* dialog = nullptr;
            
            try {
                dialog = wxXmlResource::Get()->LoadDialog(this, dialogName);
                if (dialog)
                {
                    dialog->ShowModal();
                    dialog->Destroy();
                }
                else
                {
                    wxMessageBox(wxString::Format("Не удалось загрузить диалог '%s'", dialogName),
                                 "Ошибка", wxICON_ERROR);
                }
            }
            catch (const std::exception& e)
            {
                wxMessageBox(wxString::Format("Ошибка при загрузке диалога: %s", e.what()),
                             "Ошибка", wxICON_ERROR);
            }
        }
    
        void OnExit(wxCommandEvent& event)
        {
            Close();
        }
    
        enum
        {
            ID_ShowDialog1 = wxID_HIGHEST + 1,
            ID_ShowDialog2
        };
    
        XRCLoaderThread* m_loaderThread;
    };
    
    // Класс приложения
    class MyApp : public wxApp
    {
    public:
        bool OnInit() override
        {
            MainFrame* frame = new MainFrame();
            frame->Show(true);
            return true;
        }
    };
    
    wxIMPLEMENT_APP(MyApp);
    

    Хотите, чтобы я объяснил или разбил этот код на части?

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.