geometrize::dialog::LaunchWindow::LaunchWindowImpl Class Reference

Collaboration diagram for geometrize::dialog::LaunchWindow::LaunchWindowImpl:

Public Member Functions
	LaunchWindowImpl (LaunchWindow *pQ)
LaunchWindowImpl	operator= (const LaunchWindowImpl &)=delete
	LaunchWindowImpl (const LaunchWindowImpl &)=delete
	~LaunchWindowImpl ()=default
void	handleCommand (const geometrize::script::Command &command)
std::string	getCommandHandlerName () const
void	setCommandHandlerName (const std::string &name)
void	setConsoleVisibility (const bool visible)
void	loadConsoleHistory ()
void	saveConsoleHistory ()
void	loadGlobalSettingsTemplate ()
void	saveGlobalSettingsTemplate () const
void	onLanguageChange ()

Static Public Member Functions
static std::vector< LaunchWindow * >	getTopLevelLaunchWindows ()

Private Member Functions
void	populateUi ()
void	updateLogoTaskProgress ()
void	setupLogo ()

Private Attributes
std::unique_ptr< Ui::LaunchWindow >	ui
LaunchWindow *	q
std::unique_ptr< chaiscript::ChaiScript >	m_engine
std::unique_ptr< task::ImageTask >	m_logoTask
const std::size_t	m_maxLogoTaskSteps {300ULL}
std::size_t	m_logoTaskSteps {0}

Constructor & Destructor Documentation

LaunchWindowImpl() [1/2]

geometrize::dialog::LaunchWindow::LaunchWindowImpl::LaunchWindowImpl ( LaunchWindow *  pQ )

inline

                                       : ui{std::make_unique<Ui::LaunchWindow>()}, q{pQ}, m_engine{script::createLaunchWindowEngine()}
    {
        q->setAttribute(Qt::WA_DeleteOnClose);
        ui->setupUi(q);
        populateUi();
 
        // Hide the run script button by default (it's not useful to casual users at the moment, the task queue is better)
        ui->runScriptButton->setHidden(true);
 
        // Set up recent items list
        if(preferences::getGlobalPreferences().shouldPopulateRecentItemsOnLaunch()) {
            ui->recentsList->setRecentItems(&geometrize::getRecentItems());
        }
 
        // Set up console widget
        ui->consoleWidget->setEngine(m_engine.get());
 
        loadConsoleHistory();
 
        if(preferences::getGlobalPreferences().shouldShowLaunchConsoleByDefault()) {
            setConsoleVisibility(true);
        } else {
            setConsoleVisibility(false);
        }
 
        connect(ui->actionScript_Console, &QAction::toggled, [this](const bool checked) {
            setConsoleVisibility(checked);
        });
 
        // Set up templates search and grid
        connect(ui->templateGrid, &dialog::TemplateGrid::signal_templateLoaded, [this](const QString& templateFolder, const bool /*success*/) {
            ui->templatesSearchEdit->addToCompletionList(QString::fromStdString(util::getTemplateManifest(templateFolder.toStdString()).getName()));
        });
        connect(ui->templatesSearchEdit, &dialog::CompletionBox::textChanged, [this](const QString& text) {
            ui->templateGrid->setItemFilter(text);
        });
 
        if(preferences::getGlobalPreferences().shouldPopulateTemplatesOnLaunch()) {
            ui->templateGrid->loadTemplates();
        }
 
        // Set up the logo
        setupLogo();
    }

LaunchWindowImpl() [2/2]

geometrize::dialog::LaunchWindow::LaunchWindowImpl::LaunchWindowImpl ( const LaunchWindowImpl &  )

delete

~LaunchWindowImpl()

geometrize::dialog::LaunchWindow::LaunchWindowImpl::~LaunchWindowImpl ( )

default

Member Function Documentation

getCommandHandlerName()

std::string geometrize::dialog::LaunchWindow::LaunchWindowImpl::getCommandHandlerName ( ) const

inline

    {
        return q->objectName().toStdString();
    }

getTopLevelLaunchWindows()

static std::vector<LaunchWindow*> geometrize::dialog::LaunchWindow::LaunchWindowImpl::getTopLevelLaunchWindows ( )

inlinestatic

    {
        std::vector<LaunchWindow*> windows;
 
        QWidgetList topLevelWidgets{QApplication::topLevelWidgets()};
        for(QWidget* w : topLevelWidgets) {
            if(LaunchWindow* lw = dynamic_cast<LaunchWindow*>(w)) {
                windows.push_back(lw);
            }
        }
 
        return windows;
    }

Here is the caller graph for this function:

handleCommand()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::handleCommand ( const geometrize::script::Command &  command )

inline

    {
        const QString s = QString::fromStdString(command.getCommand());
        if(s == "search_sample_images") {
            ui->templatesSearchEdit->setText(QString::fromStdString(command.getStringArg("search_term")));
        }
 
        // File menu options
        if(s == "show_file_menu") {
            ui->menuFile->exec(q->mapToGlobal(ui->menuBar->pos()));
        }
        if(s == "file_menu_clear_recent_items") {
            q->on_actionClear_Recents_triggered();
        }
        if(s == "file_menu_open_global_preferences") {
            q->on_actionGlobal_Preferences_triggered();
        }
        if(s == "file_menu_load_global_preferences") {
            q->on_actionLoad_Global_Preferences_triggered();
        }
        if(s == "file_menu_save_global_preferences") {
            q->on_actionSave_Global_Preferences_triggered();
        }
        if(s == "file_menu_exit") {
            q->on_actionExit_triggered();
        }
 
        if(s == "show_view_menu") {
            ui->menuView->exec(q->mapToGlobal(ui->menuBar->pos()));
        }
        if(s == "view_menu_toggle_script_console") {
            ui->actionScript_Console->toggle();
        }
        if(s == "view_menu_show_script_console") {
            ui->actionScript_Console->setChecked(true);
        }
        if(s == "view_menu_hide_script_console") {
            ui->actionScript_Console->setChecked(false);
        }
 
        if(s == "show_help_menu") {
            ui->menuHelp->popup(q->mapToGlobal(ui->menuBar->pos()));
        }
        if(s == "help_menu_show_tutorials") {
            ui->actionTutorials->trigger();
        }
        if(s == "help_menu_show_support") {
            ui->actionSupport->trigger();
        }
        if(s == "help_menu_show_about") {
            ui->actionAbout->trigger();
        }
 
        if(s == "click_open_image") {
            ui->openImageButton->click();
        }
        if(s == "click_open_link") {
            ui->openLinkButton->click();
        }
        if(s == "click_open_task_queue") {
            ui->openTaskQueueButton->click();
        }
    }

Here is the call graph for this function:

loadConsoleHistory()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::loadConsoleHistory ( )

inline

    {
        std::vector<std::string> history{util::readStringVector(util::getAppDataLocation().append("/").append(geometrize::dialog::ScriptConsole::launchConsoleHistoryFilename))};
        ui->consoleWidget->setHistory(history);
    }

Here is the call graph for this function:

loadGlobalSettingsTemplate()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::loadGlobalSettingsTemplate ( )

inline

    {
        const QString path{common::ui::openLoadGlobalSettingsDialog(q)};
        if(path.isEmpty()) {
            return;
        }
        geometrize::preferences::getGlobalPreferences().load(path.toStdString());
    }

Here is the call graph for this function:

onLanguageChange()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::onLanguageChange ( )

inline

    {
        ui->retranslateUi(q);
        populateUi();
    }

Here is the call graph for this function:

operator=()

LaunchWindowImpl geometrize::dialog::LaunchWindow::LaunchWindowImpl::operator= ( const LaunchWindowImpl &  )

delete

populateUi()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::populateUi ( )

inlineprivate

    {
        const QString windowTitle{geometrize::strings::Strings::getApplicationName()
                    .append(" ")
                    .append(geometrize::version::getApplicationVersionString())};
 
        q->setWindowTitle(windowTitle);
 
        const QString moreResourcesLabel{tr("Get more online", "Text on a button the user presses to open a page containing more resources for using the app, such as extra images, information and help")};
        ui->moreResourcesLink->setText(R"(<a href=")" + constants::MORE_RESOURCES_URL + R"(" style="text-decoration:none;">)" + moreResourcesLabel + R"(</a>)");
 
        const QString tutorialsLabel{tr("Video tutorials", "Text on a button the user presses to open a page containing video tutorials explaining how to use the app")};
        ui->tutorialsLink->setText(R"(<a href=")" + constants::VIDEO_TUTORIAL_URL + R"(" style="text-decoration:none;">)" + tutorialsLabel + R"(</a>)");
 
        updateLogoTaskProgress();
    }

Here is the call graph for this function:

Here is the caller graph for this function:

saveConsoleHistory()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::saveConsoleHistory ( )

inline

    {
        const std::vector<std::string> history{ui->consoleWidget->getHistory()};
        util::writeStringVector(history, util::getAppDataLocation().append("/").append(geometrize::dialog::ScriptConsole::launchConsoleHistoryFilename));
    }

Here is the call graph for this function:

saveGlobalSettingsTemplate()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::saveGlobalSettingsTemplate ( ) const

inline

    {
        const QString path{common::ui::openSaveGlobalSettingsDialog(q)};
        if(path.isEmpty()) {
            return;
        }
        geometrize::preferences::getGlobalPreferences().save(path.toStdString());
    }

Here is the call graph for this function:

setCommandHandlerName()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::setCommandHandlerName ( const std::string &  name )

inline

    {
        q->setObjectName(QString::fromStdString(name));
    }

setConsoleVisibility()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::setConsoleVisibility ( const bool  visible )

inline

    {
        if(ui->actionScript_Console->isChecked() != visible) {
            ui->actionScript_Console->setChecked(visible);
        }
        ui->consoleWidget->setVisible(visible);
    }

setupLogo()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::setupLogo ( )

inlineprivate

    {
        const QString logoPath{":/logos/logo_small.png"};
 
        if(!geometrize::preferences::getGlobalPreferences().shouldGeometrizeAppLogoOnLaunch()) {
            ui->logoLabel->setPixmap(logoPath);
        } else {
            QImage image(logoPath);
            image = image.convertToFormat(QImage::Format_RGBA8888); // Note doing this to guarantee format is RGBA8888
 
            geometrize::Bitmap logoBitmap{image::createBitmap(image)};
            geometrize::Bitmap initialBitmap{logoBitmap.getWidth(), logoBitmap.getHeight(), geometrize::rgba{0, 0, 0, 0}};
            m_logoTask = std::make_unique<task::ImageTask>(logoBitmap, initialBitmap, Qt::QueuedConnection);
            m_logoTask->getPreferences().setShapeTypes(geometrize::ShapeTypes::RECTANGLE);
            m_logoTask->getPreferences().setShapeAlpha(255U);
 
            ui->logoLabel->setPixmap(image::createPixmap(m_logoTask->getCurrent()));
 
            connect(m_logoTask.get(), &task::ImageTask::signal_modelDidStep, [this](std::vector<geometrize::ShapeResult> /*results*/) {
                const QPixmap pixmap{image::createPixmap(m_logoTask->getCurrent())};
                ui->logoLabel->setPixmap(pixmap);
 
                updateLogoTaskProgress();
 
                m_logoTaskSteps++;
                if(m_logoTaskSteps <= m_maxLogoTaskSteps) {
                    m_logoTask->stepModel();
                }
            });
            m_logoTask->stepModel();
        }
    }

Here is the call graph for this function:

updateLogoTaskProgress()

void geometrize::dialog::LaunchWindow::LaunchWindowImpl::updateLogoTaskProgress ( )

inlineprivate

    {
        if(!geometrize::preferences::getGlobalPreferences().shouldGeometrizeAppLogoOnLaunch()) {
            ui->logoLabel->setToolTip("");
            return;
        }
 
        const QString logoToolTip{tr("%1/%2 shapes", "Text showing the number of shapes that have been created to replicate an image so far e.g. 230/300 shapes")
                    .arg(QLocale().toString(static_cast<qlonglong>(m_logoTaskSteps))).arg(QLocale().toString(static_cast<qlonglong>(m_maxLogoTaskSteps)))};
        ui->logoLabel->setToolTip(logoToolTip);
    }

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

m_engine

std::unique_ptr<chaiscript::ChaiScript> geometrize::dialog::LaunchWindow::LaunchWindowImpl::m_engine

private

m_logoTask

std::unique_ptr<task::ImageTask> geometrize::dialog::LaunchWindow::LaunchWindowImpl::m_logoTask

private

m_logoTaskSteps

std::size_t geometrize::dialog::LaunchWindow::LaunchWindowImpl::m_logoTaskSteps {0}

private

m_maxLogoTaskSteps

const std::size_t geometrize::dialog::LaunchWindow::LaunchWindowImpl::m_maxLogoTaskSteps {300ULL}

private

q

LaunchWindow* geometrize::dialog::LaunchWindow::LaunchWindowImpl::q

private

ui

std::unique_ptr<Ui::LaunchWindow> geometrize::dialog::LaunchWindow::LaunchWindowImpl::ui

private

---

The documentation for this class was generated from the following file:

• /home/appveyor/projects/geometrize-docs/geometrize/geometrize/dialog/launchwindow.cpp