{

const std::string GetReleaseFeed(const std::string releasesName) override

{

std::string releasesFile = std::string(RELEASES_DIR) + "\\" + releasesName;

std::ifstream t(releasesFile);

std::stringstream buffer;

buffer << t.rdbuf();

return buffer.str();

}

bool DownloadReleaseEntry(const VelopackAsset& asset, const std::string localFilePath, vpkc_progress_send_t progress) override

{

using namespace std::chrono_literals;

std::string path = std::string(RELEASES_DIR) + "\\" + asset.FileName;

std::filesystem::copy_file(path, localFilePath);

// simulate the download taking some time...

std::this_thread::sleep_for(1s);

progress(25);

std::this_thread::sleep_for(1s);

progress(50);

std::this_thread::sleep_for(1s);

progress(75);

std::this_thread::sleep_for(1s);

progress(100);

return true;

}

{

~MyFrame()

{

vpkc_set_logger(nullptr, nullptr);

}

MyFrame() : wxFrame(nullptr, wxID_ANY, "VelopackCppWidgetsSample", wxDefaultPosition, wxSize(600, 600))

{

vpkc_set_logger(&MyFrame::HandleVpkcLogStatic, this);

// Set background color to white

// SetBackgroundColour(*wxWHITE);

// Main vertical sizer

wxBoxSizer* mainSizer = new wxBoxSizer(wxVERTICAL);

// Auto-wrapping text

topText = new wxStaticText(this, wxID_ANY,

"This is a sample text that will automatically wrap based on the width of the window. "

"Resize the window to see the text wrap around.");

topText->Wrap(380); // Set wrap width close to the window width

mainSizer->Add(topText, 0, wxALL | wxEXPAND, 10);

// Create a horizontal sizer for the buttons

wxBoxSizer* buttonSizer = new wxBoxSizer(wxHORIZONTAL);

wxButton* button1 = new wxButton(this, wxID_ANY, "Check for Updates");

wxButton* button2 = new wxButton(this, wxID_ANY, "Download Update");

wxButton* button3 = new wxButton(this, wxID_ANY, "Restart & Apply");

button1->Bind(wxEVT_BUTTON, &MyFrame::OnCheckForUpdates, this);

button2->Bind(wxEVT_BUTTON, &MyFrame::OnDownloadUpdates, this);

button3->Bind(wxEVT_BUTTON, &MyFrame::OnApplyUpdates, this);

// Add buttons to the button sizer

buttonSizer->Add(button1, 0, wxALL, 5);

buttonSizer->Add(button2, 0, wxALL, 5);

buttonSizer->Add(button3, 0, wxALL, 5);

// Add the button sizer to the main sizer

mainSizer->Add(buttonSizer, 0, wxALIGN_CENTER);

// Add a large, scrollable text area

textArea = new wxTextCtrl(this, wxID_ANY, "", wxDefaultPosition, wxSize(600, 400),

wxTE_MULTILINE | wxTE_RICH2 | wxTE_READONLY | wxTE_AUTO_URL);

mainSizer->Add(textArea, 1, wxALL | wxEXPAND, 10);

// Set the sizer for the frame

SetSizer(mainSizer);

mainSizer->Fit(this);

// initialise velopack

try

{

updateManager = std::make_unique<UpdateManager>(std::make_unique<MyExampleUpdateSource>());

topText->SetLabel("Current Version: " + updateManager->GetCurrentVersion());

}

catch (std::exception& ex)

{

std::string message = ex.what() + std::string("\n");

textArea->AppendText(message);

topText->SetLabel(message);

}

}

wxStaticText* topText;

wxTextCtrl* textArea;

std::unique_ptr<UpdateManager> updateManager;

std::optional<UpdateInfo> updateInfo;

bool downloaded = false;

void OnCheckForUpdates(wxCommandEvent& event)

{

if (!updateManager)

{

textArea->AppendText("Cannot check for updates. Install the app first.\n");

return;

}

downloaded = false;

try

{

updateInfo = updateManager->CheckForUpdates();

if (updateInfo.has_value())

{

topText->SetLabel("Update Found: " + updateInfo.value().TargetFullRelease.Version);

}

else

{

topText->SetLabel("No Update Found.");

}

}

catch (...) { /* exception will print in log */ }

}

void OnDownloadUpdates(wxCommandEvent& event)

{

if (!updateManager || !updateInfo.has_value())

{

textArea->AppendText("Cannot download updates. Check for updates first.\n");

return;

}

// start download on new thread

std::thread([this]()

{

try

{

updateManager->DownloadUpdates(updateInfo.value(), &MyFrame::HandleProgressCallbackStatic, this);

downloaded = true;

wxTheApp->CallAfter([this]()

{

topText->SetLabel("Download Complete.");

});

}

catch (...) { /* exception will print in log */ }

}).detach();

}

void OnApplyUpdates(wxCommandEvent& event)

{

if (!updateManager || !downloaded)

{

textArea->AppendText("Cannot apply updates. Download updates first.\n");

return;

}

try

{

updateManager->WaitExitThenApplyUpdates(updateInfo.value());

wxTheApp->ExitMainLoop();

}

catch (...) { /* exception will print in log */ }

}

void HandleVpkcLog(const char* pszLevel, const char* pszMessage)

{

std::string level(pszLevel);

std::string message(pszMessage);

wxTheApp->CallAfter([this, level, message]() {

if (textArea) { // Ensure textArea is valid.

textArea->AppendText(level + ": " + message + "\n");

}

});

}

static void HandleVpkcLogStatic(void* context, const char* pszLevel, const char* pszMessage)

{

MyFrame* instance = static_cast<MyFrame*>(context);

instance->HandleVpkcLog(pszLevel, pszMessage);

}

void HandleProgressCallback(size_t progress)

{

wxTheApp->CallAfter([this, progress]()

{

topText->SetLabel("Download Progress: " + std::to_string(progress));

});

}

static void HandleProgressCallbackStatic(void* pUserData, size_t progress)

{

MyFrame* instance = static_cast<MyFrame*>(pUserData);

instance->HandleProgressCallback(progress);

}

{

virtual bool OnInit()

{

// Velopack should be the first thing to run in app startup, before any UI

// has been shown. Velopack may need to quit/restart the application at this point.

VelopackApp::Build().Run();

MyFrame* frame = new MyFrame();

frame->Show(true);

return true;

}