bool GatherInfoTask::handleInvalidBranch() { MCFBranch branch = getMcfBranch(); if (m_bCanceled || (m_pGIHH && !m_pGIHH->selectBranch(branch))) { completeStage(); return false; } if (branch == UINT_MAX) { //means the item was set as a link and needs to be launched getItemHandle()->getInternal()->goToStageLaunch(); return false; } else { if (branch.isGlobal()) branch = getItemInfo()->getInternal()->getBestBranch(branch); UserCore::Item::BranchInfoI* branchInfo = getItemInfo()->getBranchById(branch); checkNullBranch(branchInfo); } m_uiMcfBranch = branch; return true; }
bool VSCheckInstall::checkInstallComplex(bool completeMcf) { if (HasAnyFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX) == false) return false; auto pItem = getItemInfo(); auto pParent = getParentItemInfo(); if (pParent) { if (!pParent->getInstalledModId().isOk() || pParent->getInstalledModId() != pItem->getId()) { if (completeMcf) setResult(RES_COMPLETE); else setResult(RES_DOWNLOADMISSING); return true; } } else if (pItem->getInstalledModId().isOk()) { setResult(RES_COMPLETE); return true; } return false; }
bool UIUpdateServiceTask::initService() { if (!UIBaseServiceTask::initService()) { onComplete(); return false; } gcString oldBranchMcf = getBranchMcf(getItemInfo()->getId(), getItemInfo()->getInstalledBranch(), getMcfBuild()); m_pIPCIM = getServiceMain()->newUninstallBranch(); if (!m_pIPCIM) { gcException eFailCrtBrnch(ERR_NULLHANDLE, "Failed to create uninstall update mcf service!\n"); onErrorEvent(eFailCrtBrnch); return false; } m_pIPCIM->onCompleteEvent += delegate(this, &UIUpdateServiceTask::onComplete); m_pIPCIM->onProgressEvent += delegate(&onMcfProgressEvent); m_pIPCIM->onErrorEvent += delegate((UIBaseServiceTask*)this, &UIBaseServiceTask::onServiceError); m_pIPCIM->start(oldBranchMcf.c_str(), m_szPath.c_str(), getItemInfo()->getPath(), ""); return true; }
bool VSInstallMissing::doTask() { const char* val = getUserCore()->getCVarValue("gc_corecount"); gcException errFailMCFServ(ERR_NULLHANDLE, "Failed to create uninstall MCF service!\n"); m_pIPCIM = getUserCore()->getServiceMain()->newInstallMcf(); if (!m_pIPCIM) { onErrorEvent(errFailMCFServ); return false; } uint8 workers = 1; if (val) workers = atoi(val); if (workers == 0) workers = 1; m_pIPCIM->onCompleteEvent += delegate(this, &VSInstallMissing::onComplete); m_pIPCIM->onProgressEvent += delegate(&onProgressEvent); m_pIPCIM->onErrorEvent += delegate(&onErrorEvent); m_pIPCIM->start(m_hMcf->getFile(), getItemInfo()->getPath(), getItemInfo()->getInstallScriptPath(), workers); m_WaitCond.wait(); m_bFinished = true; return isStopped() == false; }
void VerifyServiceTask::checkHooks() { refreshInfo(); const char* hookPath = getItemInfo()->getInstallScriptPath(); const char* insPath = getItemInfo()->getPath(); if (hookPath && UTIL::FS::isValidFile(hookPath)) getUserCore()->getServiceMain()->runInstallScript(hookPath, insPath, "PostInstall"); }
void VerifyServiceTask::finishVerify(UserCore::Misc::VerifyComplete::VSTATUS status, const char* installpath, bool endStage) { if (m_bError) return; MCFCore::Misc::ProgressInfo prog; prog.percent = 100; onMcfProgressEvent(prog); UserCore::Item::ItemInfo* pItem = getItemInfo(); if (pItem) { pItem->delSFlag(UserCore::Item::ItemInfoI::STATUS_VERIFING); if (status == UserCore::Misc::VerifyComplete::V_COMPLETE) pItem->addSFlag(UserCore::Item::ItemInfoI::STATUS_READY); if (status == UserCore::Misc::VerifyComplete::V_RESET) { uint32 flags = UserCore::Item::ItemInfoI::STATUS_ONCOMPUTER|UserCore::Item::ItemInfoI::STATUS_DOWNLOADING|UserCore::Item::ItemInfoI::STATUS_INSTALLING|UserCore::Item::ItemInfoI::STATUS_UPDATING|UserCore::Item::ItemInfoI::STATUS_INSTALLED|UserCore::Item::ItemInfoI::STATUS_UPDATEAVAL; pItem->resetInstalledMcf(); pItem->delSFlag(flags); } } UserCore::Misc::VerifyComplete vInstallPath(status, installpath); onVerifyCompleteEvent(vInstallPath); if (status == UserCore::Misc::VerifyComplete::V_INSTALL) { getItemInfo()->addToAccount(); getItemHandle()->goToStageInstall(installpath, getMcfBranch()); } else if (status == UserCore::Misc::VerifyComplete::V_DOWNLOAD) { getItemInfo()->addToAccount(); if (installpath) getItemHandle()->goToStageDownload(installpath); else getItemHandle()->goToStageDownload(getItemInfo()->getCurrentBranch()->getBranchId(), m_McfBuild); } else if (status == UserCore::Misc::VerifyComplete::V_SWITCHBRANCH) { getItemInfo()->addToAccount(); getItemHandle()->switchBranch(m_McfBranch); } else if (endStage) { getItemHandle()->completeStage(true); } }
bool VerifyServiceTask::checkFiles() { if (HasAnyFlags(m_uiOldStatus, UserCore::Item::ItemInfoI::STATUS_DOWNLOADING)) { gcString path; if (checkMcfDownload(path)) finishVerify(UserCore::Misc::VerifyComplete::V_DOWNLOAD, path.c_str()); else finishVerify(UserCore::Misc::VerifyComplete::V_DOWNLOAD); return false; } else if (HasAnyFlags(m_uiOldStatus, (UserCore::Item::ItemInfoI::STATUS_INSTALLED|UserCore::Item::ItemInfoI::STATUS_INSTALLING))) { m_hMcf->getProgEvent() += delegate(this, &VerifyServiceTask::onProgress); m_hMcf->getErrorEvent() += delegate(this, &VerifyServiceTask::onError); bool completeMcf = false; if (m_McfBuild == 0) m_McfBuild = getItemInfo()->getInstalledBuild(); setTier(VERIFYMCF); if (!checkMcf(completeMcf)) return false; setTier(VERIFYINSTALL); if (!checkInstall(completeMcf)) return false; setTier(DOWNLOADMISSINGFILES); if (completeMcf == false && !downloadMissingFiles()) return false; setTier(INSTALLMISSINGFILES); if (!installMissingFiles()) return false; } else { getItemInfo()->delSFlag(UserCore::Item::ItemInfoI::STATUS_READY); finishVerify(UserCore::Misc::VerifyComplete::V_RESET); return false; } return true; }
void UIComplexModServiceTask::onComplete() { if (HasAllFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX)) { UserCore::MCFManager *mm = UserCore::GetMCFManager(); mm->delMcfBackup(getItemInfo()->getParentId(), m_idLastInstalledMod); } if (HasAllFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_LINK)) { if (m_uiCompleteAction == CA_LAUNCH) getItemHandle()->goToStageLaunch(); } else { switch (m_uiCompleteAction) { case CA_INSTALL: getItemHandle()->goToStageInstallComplex(getMcfBranch(), getMcfBuild()); break; case CA_UNINSTALL_BRANCH: getItemHandle()->goToStageUninstallBranch(getMcfBranch(), getMcfBuild()); break; case CA_UNINSTALL: getItemInfo()->delSFlag( UserCore::Item::ItemInfoI::STATUS_INSTALLED| UserCore::Item::ItemInfoI::STATUS_READY| UserCore::Item::ItemInfoI::STATUS_DOWNLOADING| UserCore::Item::ItemInfoI::STATUS_VERIFING| UserCore::Item::ItemInfoI::STATUS_INSTALLING| UserCore::Item::ItemInfoI::STATUS_UPDATING| UserCore::Item::ItemInfoI::STATUS_ONCOMPUTER| UserCore::Item::ItemInfoI::STATUS_PAUSED| UserCore::Item::ItemInfoI::STATUS_PAUSABLE); completeUninstall(m_bRemoveAll, m_bRemoveAcc); break; case CA_UIPATCH: getItemHandle()->goToStageUninstallPatch(getMcfBranch(), getMcfBuild()); break; }; } if (m_bEndStage) getItemHandle()->completeStage(true); UIBaseServiceTask::onComplete(); }
bool VerifyServiceTask::checkItem() { gcException eBadItem(ERR_BADITEM); gcException eBrchNull(ERR_BADITEM, "Item branch is null"); UserCore::Item::ItemInfo* pItem = getItemInfo(); if (!pItem) { onError(eBadItem); return true; } if (!pItem->isDownloadable()) { finishVerify(UserCore::Misc::VerifyComplete::V_COMPLETE); return true; } if (!pItem->getCurrentBranch()) { if (HasAnyFlags(pItem->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLED|UserCore::Item::ItemInfoI::STATUS_DOWNLOADING|UserCore::Item::ItemInfoI::STATUS_INSTALLING)) onError(eBrchNull); else finishVerify(UserCore::Misc::VerifyComplete::V_RESET); return true; } return false; }
SimObject* SimTreeView::getObject( HTREEITEM hItem ) { TV_ITEM *tvi; SimObject *obj=NULL; if ( hItem ) if ( (tvi = getItemInfo( hItem )) != NULL ) obj = targetManager->findObject(tvi->lParam); return obj; }
UserCore::Item::ItemInfo* BaseItemTask::getParentItemInfo() { UserCore::Item::ItemInfo* item = getItemInfo(); if (!m_pUserCore || !item) return NULL; return dynamic_cast<UserCore::Item::ItemInfo*>(m_pUserCore->getItemManager()->findItemInfo(item->getParentId())); }
void CDKInfo::onButtonClicked(wxCommandEvent& event) { if (event.GetId() == m_butClose->GetId()) { GetParent()->Close(); } else if (event.GetId() == m_imgCopyAll->GetId() || (m_vSplitKey.size() == 0 && event.GetId() == m_imgCopyPart->GetId())) { if (wxTheClipboard->Open()) { wxTheClipboard->SetData(new wxTextDataObject(m_tbCdKey->GetValue())); wxTheClipboard->Close(); } m_tbCdKey->SetSelection(-1,-1); } else if (event.GetId() == m_imgCopyPart->GetId()) { SplitInfo *info = m_vSplitKey[m_uiCurIndex]; m_uiCurIndex++; if (m_uiCurIndex >= m_vSplitKey.size()) m_uiCurIndex = 0; if (wxTheClipboard->Open()) { wxTheClipboard->SetData(new wxTextDataObject(info->text)); wxTheClipboard->Close(); } m_tbCdKey->SetSelection(info->start,info->end); gcString label(Managers::GetString("#CDK_COPYPART")); if (m_uiCurIndex != 0) label = gcString(Managers::GetString("#CDK_COPYPART_X"), m_uiCurIndex+1); m_imgCopyPart->SetToolTip(label); } else if (m_butLaunch && m_butLaunch->GetId() == event.GetId()) { g_pMainApp->handleInternalLink(getItemId(), ACTION_LAUNCH, FormatArgs("cdkey", std::string("exe=") + m_szExe)); GetParent()->Close(); } else if (m_butActivate && m_butActivate->GetId() == event.GetId()) { UserCore::Item::ItemInfoI* info = getItemInfo(); if (info && info->isLaunchable()) info->addSFlag(UserCore::Item::ItemInfoI::STATUS_LAUNCHED); #ifdef WIN32 UTIL::WIN::runAs("steam://open/activateproduct"); #endif } }
void DownloadToolTask::validateTools() { std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return; auto pToolManager = getUserCore()->getToolManager(); if (pToolManager->areAllToolsValid(toolList)) return; pToolManager->reloadTools(getItemId()); getItemInfo()->getCurrentBranch()->getToolList(toolList); if (!pToolManager->areAllToolsValid(toolList)) throw gcException(ERR_INVALID, "Tool ids cannot be resolved into tools."); }
void DownloadToolTask::onDLProgress(UserCore::Misc::ToolProgress &p) { MCFCore::Misc::ProgressInfo m; m.doneAmmount = p.done; m.totalAmmount = p.total; m.percent = p.percent; onMcfProgressEvent(m); getItemInfo()->setPercent(p.percent); }
bool VSDownloadMissing::checkComplex() { if (HasAnyFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX)) { UserCore::Item::ItemInfoI* par = getParentItemInfo(); if (par && (!par->getInstalledModId().isOk() || par->getInstalledModId() != getItemId())) { setResult(RES_COMPLETE); } else if (getItemInfo()->getInstalledModId().isOk()) { setResult(RES_COMPLETE); } return false; } return true; }
bool VSCheckInstall::doTask(bool completeMcf) { if (HasAnyFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLED)) { if (checkInstallComplex(completeMcf)) { return true; } else { bool res = checkInstall(); if (isStopped()) return false; if (res) { setResult(RES_COMPLETE); } else { setResult(RES_DOWNLOADMISSING); m_hMcf->saveMCFHeader(); } } } else if (HasAnyFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLING)) { //continue installing if (!completeMcf) setResult(RES_DOWNLOAD); else setResult(RES_INSTALL); } else { return false; } return true; }
void CreateMCFThread::waitForItemInfo() { m_pUserCore->getItemManager()->retrieveItemInfoAsync(getItemId()); size_t count = 0; while (!isStopped() && !getItemInfo() && count < 100) { count++; gcSleep(500); } }
bool VSCheckInstall::checkInstall() { try { return m_hMcf->verifyInstall(getItemInfo()->getPath(), true); } catch (gcException &except) { onErrorEvent(except); return false; } }
void InstallVerifyInfoPage::init() { UserCore::Item::ItemInfoI *info = getItemInfo(); if (!info) { Close(); return; } m_labInfo->SetLabel(gcWString(Managers::GetString(L"#IF_VERIFYCONFIRM"), info->getName())); m_labInfo->Wrap( 360 ); }
void DownloadToolTask::doRun() { uint32 per = 0; getItemInfo()->setPercent(per); if (m_ToolTTID == UINT_MAX) validateTools(); std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); UserCore::Misc::ToolTransaction* tt = new UserCore::Misc::ToolTransaction(); tt->onCompleteEvent += delegate(this, &DownloadToolTask::onDLComplete); tt->onErrorEvent += delegate(this, &DownloadToolTask::onDLError); tt->onProgressEvent += delegate(this, &DownloadToolTask::onDLProgress); tt->toolsList = toolList; if (m_ToolTTID != UINT_MAX) { bool res = getUserCore()->getToolManager()->updateTransaction(m_ToolTTID, tt); if (!res) //must be complete { onComplete(); return; } } else { m_ToolTTID = getUserCore()->getToolManager()->downloadTools(tt); } if (m_ToolTTID != UINT_MAX) m_WaitCond.wait(); onComplete(); }
void DownloadToolTask::onComplete() { bool notComplete = isStopped() || m_bCancelled; getUserCore()->getToolManager()->removeTransaction(m_ToolTTID, notComplete); m_ToolTTID = UINT_MAX; std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (!m_bCancelled && !getUserCore()->getToolManager()->areAllToolsDownloaded(toolList)) { gcException e(ERR_INVALID, "Failed to download tools."); onErrorEvent(e); notComplete = true; } if (notComplete) { getItemHandle()->completeStage(true); return; } uint32 blank = 0; onCompleteEvent(blank); if (m_bInstallAfter) { getItemHandle()->goToStageInstallTools(m_bLaunch); } else { if (HasAllFlags(getItemInfo()->getStatus(), UserCore::Item::ItemInfoI::STATUS_INSTALLCOMPLEX)) getItemHandle()->goToStageInstallComplex(getMcfBranch(), getMcfBuild()); else getItemHandle()->goToStageInstall(m_szDownloadPath.c_str(), getMcfBranch()); } }
void ItemHandle::doLaunch(Helper::ItemLaunchHelperI* helper) { preLaunchCheck(); bool needElevation = false; size_t x=0; while (g_ElevatedGames[x].isOk()) { if (getItemInfo()->getId() == g_ElevatedGames[x] || getItemInfo()->getParentId() == g_ElevatedGames[x]) { needElevation = true; break; } x++; } UserCore::Item::Misc::ExeInfoI* ei = getItemInfo()->getActiveExe(); gcString args; gcString ea(ei->getExeArgs()); gcString ua(ei->getUserArgs()); if (ea.size() > 0) args += " " + ea; if (ua.size() > 0) args += " " + ua; m_pUserCore->getItemManager()->setRecent(getItemInfo()->getId()); bool res = UTIL::WIN::launchExe(ei->getExe(), args.c_str(), needElevation, m_pUserCore->getMainWindowHandle()); if (!res) throw gcException(ERR_LAUNCH, GetLastError(), gcString("Failed to create {0} process. [{1}: {2}].\n", getItemInfo()->getName(), GetLastError(), ei->getExe())); }
void DownloadToolTask::validateTools() { std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return; if (!getUserCore()->getToolManager()->areAllToolsValid(toolList)) { //missing tools. Gather info again TiXmlDocument doc; getWebCore()->getItemInfo(getItemId(), doc, MCFBranch(), MCFBuild()); TiXmlNode *uNode = doc.FirstChild("iteminfo"); if (!uNode) throw gcException(ERR_BADXML); TiXmlNode *toolNode = uNode->FirstChild("toolinfo"); if (toolNode) getUserCore()->getToolManager()->parseXml(toolNode); TiXmlNode *gameNode = uNode->FirstChild("games"); if (!gameNode) throw gcException(ERR_BADXML); getItemInfo()->getCurrentBranch()->getToolList(toolList); } if (!getUserCore()->getToolManager()->areAllToolsValid(toolList)) throw gcException(ERR_INVALID, "Tool ids cannot be resolved into tools."); }
void CSIM_ext::MeasureItem(LPMEASUREITEMSTRUCT lpmis) { if (lpmis->CtlType != ODT_MENU) return; ItemInfo info = getItemInfo(lpmis->itemID); if (info.icon == NULL) return; HDC hDC = CreateCompatibleDC(NULL); SelectObject(hDC, GetStockObject(DEFAULT_GUI_FONT)); SIZE s; GetTextExtentPoint32(hDC, info.text.c_str(), info.text.length(), &s); lpmis->itemWidth = s.cx + GetSystemMetrics(SM_CXMENUCHECK) + GetSystemMetrics(SM_CXFRAME) * 2; lpmis->itemHeight = GetSystemMetrics(SM_CYMENU); DeleteDC(hDC); }
void CDKeyTask::doTask() { if (!getItemInfo() || !getWebCore()) { CDKeyEventInfo<gcException> cdei; cdei.task = this; cdei.t = gcException(ERR_NULLHANDLE, "Item info or web core are null"); cdei.id = getItemId(); onErrorEvent(cdei); return; } MCFBranch branch = getItemInfo()->getInstalledBranch(); try { gcString key = getWebCore()->getCDKey(getItemId(), branch); CDKeyEventInfo<gcString> cdei; cdei.task = this; cdei.t = key; cdei.id = getItemId(); onCompleteEvent(cdei); } catch (gcException &e) { CDKeyEventInfo<gcException> cdei; cdei.task = this; cdei.t = e; cdei.id = getItemId(); onErrorEvent(cdei); } }
void VerifyServiceTask::onProgress(MCFCore::Misc::ProgressInfo& prog) { if (m_pCurTask) m_pCurTask->onProgress(prog); MCFCore::Misc::ProgressInfo p(&prog); uint32 percent = 0; switch (m_iTier) { case START: percent = 00 + ((uint32)prog.percent/20); p.flag = 0; break; case VERIFYMCF: percent = 20 + ((uint32)prog.percent/20); p.flag = 1; break; case VERIFYINSTALL: percent = 40 + ((uint32)prog.percent/20); p.flag = 2; break; case DOWNLOADMISSINGFILES: percent = 60 + ((uint32)prog.percent/20); p.flag = 3; break; case INSTALLMISSINGFILES: percent = 80 + ((uint32)prog.percent/20); p.flag = 4; break; } if (m_uiLastPercent != percent || p.doneAmmount > 0) { p.percent = percent; onMcfProgressEvent(p); getItemInfo()->setPercent(percent); m_uiLastPercent = percent; } }
void ItemHandle::doLaunch(Helper::ItemLaunchHelperI* helper) { char magicBytes[5] = {0}; UserCore::Item::Misc::ExeInfoI* ei = getItemInfo()->getActiveExe(); const char* exe = ei->getExe(); const char* args = getUserCore()->getCVarValue("gc_linux_launch_globalargs"); gcString globalExe = getUserCore()->getCVarValue("gc_linux_launch_globalbin"); if (globalExe.size() > 0) { if (!UTIL::FS::isValidFile(globalExe.c_str())) { Warning(gcString("Couldn't find global exe [{0}], ignoring.\n", globalExe)); globalExe = ""; exe = ei->getExe(); } else { exe = globalExe.c_str(); } } try { UTIL::FS::FileHandle fh(exe, UTIL::FS::FILE_READ); fh.read(magicBytes, 5); } catch (gcException& e) { throw gcException(ERR_LAUNCH, e.getSecErrId(), gcString("Failed to read [{0}]: {1}\n", exe, e)); } UTIL::LIN::BinType type = UTIL::LIN::getFileType(magicBytes, 5); if (type == UTIL::LIN::BT_WIN && helper) helper->showWinLaunchDialog(); //if we are not using globalExe set exe to Null so that we use the proper exe if (globalExe.size() == 0 || type == UTIL::LIN::BT_UNKNOWN) exe = NULL; doLaunch(type == UTIL::LIN::BT_UNKNOWN, exe, args); }
void CreateProgPage::run() { if (!getItemInfo() && !GetUserCore()->isAdmin()) return; Show(true); Raise(); if (m_pThread) return; m_pThread = GetThreadManager()->newCreateMCFThread(getItemId(), m_szFolderPath.c_str()); *m_pThread->getMcfProgressEvent() += guiDelegate(this, &CreateProgPage::onProgress); *m_pThread->getErrorEvent() += guiDelegate(this, &CreateProgPage::onError); *m_pThread->getCompleteStringEvent() += guiDelegate(this, &CreateProgPage::onComplete); m_pThread->start(); }
void VerifyServiceTask::updateStatus() { UserCore::Item::ItemInfo* pItem = getItemInfo(); m_uiOldStatus = pItem->getStatus(); uint32 addFlags = UserCore::Item::ItemInfoI::STATUS_ONCOMPUTER|UserCore::Item::ItemInfoI::STATUS_VERIFING; uint32 delFlags = UserCore::Item::ItemInfoI::STATUS_READY|UserCore::Item::ItemInfoI::STATUS_PAUSED|UserCore::Item::ItemInfoI::STATUS_PAUSABLE|UserCore::Item::ItemInfoI::STATUS_LINK|UserCore::Item::ItemInfoI::STATUS_DELETED; UserCore::Item::ItemInfo* parent = getParentItemInfo(); if (parent) parent->delSFlag(UserCore::Item::ItemInfoI::STATUS_DELETED); pItem->addSFlag(addFlags); pItem->delSFlag(delFlags); pItem->setPercent(0); }
bool VerifyServiceTask::checkTools() { refreshInfo(); std::vector<DesuraId> toolList; getItemInfo()->getCurrentBranch()->getToolList(toolList); if (toolList.size() == 0) return false; getUserCore()->getToolManager()->invalidateTools(toolList); if (!getUserCore()->getToolManager()->areAllToolsDownloaded(toolList)) getItemHandle()->goToStageDownloadTools(false); else getItemHandle()->goToStageInstallTools(false); return true; }