CommandLine::CommandLine(int argc, char* const argv[],
const char* user, const char* pass, const char* usage_extra) :
CommandLineBase(argc, argv, "hm:p:s:u:D?"),
dtest_mode_(false),
run_mode_(0),
server_(0),
user_(user && *user ? user : 0),
pass_(pass && *pass ? pass : ""),
usage_extra_(usage_extra)
{
int ch;
while (successful() && ((ch = parse_next()) != EOF)) {
switch (ch) {
case 'm': run_mode_ = atoi(option_argument()); break;
case 'p': pass_ = option_argument(); break;
case 's': server_ = option_argument(); break;
case 'u': user_ = option_argument(); break;
case 'D': dtest_mode_ = true; break;
default:
parse_error();
return;
}
}
finish_parse();
}
// ---------------------------------------------------------------------------------
success Action::assign_query_values_to_entity ( QSqlQuery &query, dp::Action &a ) const
{
QUuid const& task_id = query.value ( 1 ).toString();
a.setTask ( task_id );
QUuid const& project_id = query.value ( 2 ).toString();
a.setProject ( project_id );
QDateTime _start, _end;
QUuid const& collaboration_id = query.value ( 3 ).toString();
a.setCollaborationType(collaboration_id);
a.setName ( query.value ( 4 ).toString() );
a.setComment ( query.value ( 5 ).toString() );
uint starttime = query.value ( 6 ).toUInt();
if(starttime > 0)
{
_start.setTime_t ( starttime );
}
a.setStartTime ( _start );
uint endtime = query.value ( 7 ).toUInt();
if(endtime>0)
{
_end.setTime_t ( endtime );
}
a.setEndTime ( _end );
a.setReviewed ( query.value ( 8 ).toBool() );
a.setBilled ( query.value ( 9 ).toBool() );
return successful();
}
void ProcessListChain::slotProcessChainSuccessful()
{
if ( m_processOptionsList.isEmpty() )
{
emit successful();
return;
}
ProcessOptionsList::iterator it = m_processOptionsList.begin();
ProcessOptions po = *it;
m_processOptionsList.erase(it);
ProcessChain * pc = LanguageManager::self()->compile(po);
connect( pc, SIGNAL(successful()), this, SLOT(slotProcessChainSuccessful()) );
connect( pc, SIGNAL(failed()), this, SLOT(slotProcessChainFailed()) );
}
// ---------------------------------------------------------------------------------
success Project::remove(dp::Project const& _project) const
{
if ( _project.id().isNull())
{
return error();
}
if(!exists(_project))
{
return successful();
}
QSqlQuery query;
query.prepare(REMOVE_PROJECT);
query.addBindValue(_project.id().toString());
if(execute(query).has_failed())
{
return error();
}
return successful();
}
// ---------------------------------------------------------------------------------
success Sqlite::open_database_connection() const
{
if ( prepare_storage_directory().has_failed() )
{
return error();
}
QSqlDatabase db = QSqlDatabase::addDatabase ( "QSQLITE" );
db.setDatabaseName ( database_name() );
if ( db.open() )
{
return successful();
}
return error();
}
// ---------------------------------------------------------------------------------
success ActionTemplate::assign_query_values_to_entity ( QSqlQuery &query, dp::ActionTemplate &a ) const
{
//QUuid const& id = query.value ( 0 ).toString();
QUuid const& task_id = query.value ( 1 ).toString();
a.setTask ( task_id );
QUuid const& project_id = query.value ( 2 ).toString();
a.setProject ( project_id );
QUuid const& collaboration_id = query.value ( 3 ).toString();
a.setCollaborationType(collaboration_id);
a.setName ( query.value ( 4 ).toString() );
a.setComment ( query.value ( 5 ).toString() );
a.setIcon ( query.value ( 6 ).toString() );
return successful();
}
// ---------------------------------------------------------------------------------
success Project::findAll(dp::ProjectList &l) const
{
QSqlQuery query;
query.prepare(SELECT_ALL_PROJECTS);
if ( execute ( query ).has_failed() )
{
return error();
}
while ( query.next() )
{
dp::Project _p(QUuid(query.value(0).toString()));
assign_query_values_to_entity(query, _p);
l.append(_p);
}
return successful();
}
void GpsimProcessor::compileMicrobe( const QString &filename, QObject *receiver, const char * successMember, const char * failMember )
{
ProcessOptions o;
o.b_addToProject = false;
o.setTargetFile( QString(filename).replace(".microbe",".hex") );
o.setInputFiles(filename);
o.setMethod( ProcessOptions::Method::Forget );
o.setProcessPath( ProcessOptions::ProcessPath::Microbe_Program );
ProcessChain * pc = new ProcessChain(o);
if (receiver)
{
if (successMember)
connect( pc, SIGNAL(successful()), receiver, successMember );
if (failMember)
connect( pc, SIGNAL(failed()), receiver, failMember );
}
}
// ---------------------------------------------------------------------------------
success Project::insert ( dp::Project const& _p ) const
{
if ( _p.id().isNull())
{
return error();
}
QSqlQuery query;
query.prepare ( INSERT_PROJECT );
query.addBindValue ( _p.id().toString() );
query.addBindValue ( _p.name() );
query.addBindValue ( _p.creationDate() );
query.addBindValue( _p.comment() );
if ( execute ( query ).has_failed() )
{
return error();
}
return successful();
}
bool MainWindow::loginWithPassword(MojangAccountPtr account, const QString &errorMsg)
{
EditAccountDialog passDialog(errorMsg, this, EditAccountDialog::PasswordField);
if (passDialog.exec() == QDialog::Accepted)
{
// To refresh the token, we just create an authenticate task with the given account and
// the user's password.
ProgressDialog progDialog(this);
auto task = account->login(passDialog.password());
progDialog.exec(task.get());
if (task->successful())
return true;
else
{
// If the authentication task failed, recurse with the task's error message.
return loginWithPassword(account, task->failReason());
}
}
return false;
}
bool operator ! () const { return !successful(); }
void MainWindow::doLaunch(bool online, BaseProfilerFactory *profiler)
{
if (!m_selectedInstance)
return;
// Find an account to use.
std::shared_ptr<MojangAccountList> accounts = MMC->accounts();
MojangAccountPtr account = accounts->activeAccount();
if (accounts->count() <= 0)
{
// Tell the user they need to log in at least one account in order to play.
auto reply = CustomMessageBox::selectable(
this, tr("No Accounts"),
tr("In order to play Minecraft, you must have at least one Mojang or Minecraft "
"account logged in to MultiMC."
"Would you like to open the account manager to add an account now?"),
QMessageBox::Information, QMessageBox::Yes | QMessageBox::No)->exec();
if (reply == QMessageBox::Yes)
{
// Open the account manager.
on_actionManageAccounts_triggered();
}
}
else if (account.get() == nullptr)
{
// If no default account is set, ask the user which one to use.
AccountSelectDialog selectDialog(tr("Which account would you like to use?"),
AccountSelectDialog::GlobalDefaultCheckbox, this);
selectDialog.exec();
// Launch the instance with the selected account.
account = selectDialog.selectedAccount();
// If the user said to use the account as default, do that.
if (selectDialog.useAsGlobalDefault() && account.get() != nullptr)
accounts->setActiveAccount(account->username());
}
// if no account is selected, we bail
if (!account.get())
return;
// we try empty password first :)
QString password;
// we loop until the user succeeds in logging in or gives up
bool tryagain = true;
// the failure. the default failure.
QString failReason = tr("Your account is currently not logged in. Please enter "
"your password to log in again.");
while (tryagain)
{
AuthSessionPtr session(new AuthSession());
session->wants_online = online;
auto task = account->login(session, password);
if (task)
{
// We'll need to validate the access token to make sure the account
// is still logged in.
ProgressDialog progDialog(this);
if (online)
progDialog.setSkipButton(true, tr("Play Offline"));
progDialog.exec(task.get());
if (!task->successful())
{
failReason = task->failReason();
}
}
switch (session->status)
{
case AuthSession::Undetermined:
{
QLOG_ERROR() << "Received undetermined session status during login. Bye.";
tryagain = false;
break;
}
case AuthSession::RequiresPassword:
{
EditAccountDialog passDialog(failReason, this, EditAccountDialog::PasswordField);
if (passDialog.exec() == QDialog::Accepted)
{
password = passDialog.password();
}
else
{
tryagain = false;
}
break;
}
case AuthSession::PlayableOffline:
{
// we ask the user for a player name
bool ok = false;
QString usedname = session->player_name;
QString name = QInputDialog::getText(this, tr("Player name"),
tr("Choose your offline mode player name."),
QLineEdit::Normal, session->player_name, &ok);
if (!ok)
{
tryagain = false;
break;
}
if (name.length())
{
usedname = name;
}
session->MakeOffline(usedname);
// offline flavored game from here :3
}
case AuthSession::PlayableOnline:
{
// update first if the server actually responded
if (session->auth_server_online)
{
updateInstance(m_selectedInstance, session, profiler);
}
else
{
launchInstance(m_selectedInstance, session, profiler);
}
tryagain = false;
}
}
}
}
QString GpsimProcessor::generateSymbolFile( const QString &fileName, QObject *receiver, const char *successMember, const char * failMember )
{
if ( !isValidProgramFile(fileName) )
return QString::null;
QString extension = fileName.right(
fileName.length() - fileName.lastIndexOf('.') - 1
).toLower();
if ( extension == "cod" )
{
QTimer::singleShot( 0, receiver, successMember );
return fileName;
}
if ( extension == "hex" )
{
QTimer::singleShot( 0, receiver, successMember );
// We've already checked for the existance of the ".cod" file in GpsimProcessor::isValidProgramFile
return QString(fileName).replace(".hex",".cod");
}
else if ( extension == "basic" || extension == "microbe" )
{
compileMicrobe( fileName, receiver, successMember, failMember );
return QString(fileName).replace( "."+extension, ".cod" );
}
else if ( extension == "flowcode" )
{
const QString hexFile = QTemporaryFile( "tmpXXXXXX.hex" ).fileName();
ProcessOptions o;
o.b_addToProject = false;
o.setTargetFile( hexFile );
o.setInputFiles( QStringList(fileName) );
o.setMethod( ProcessOptions::Method::Forget );
o.setProcessPath( ProcessOptions::ProcessPath::FlowCode_Program );
ProcessChain * pc = new ProcessChain(o);
if (receiver)
{
if (successMember)
connect( pc, SIGNAL(successful()), receiver, successMember );
if (failMember)
connect( pc, SIGNAL(failed()), receiver, failMember );
}
return QString(hexFile).replace( ".hex", ".cod" );
}
else if ( extension == "asm" )
{
ProcessOptions o;
o.b_addToProject = false;
o.setTargetFile( QString(fileName).replace(".asm",".hex"));
o.setInputFiles(QStringList(fileName));
o.setMethod( ProcessOptions::Method::Forget );
o.setProcessPath( ProcessOptions::ProcessPath::path( ProcessOptions::guessMediaType(fileName), ProcessOptions::ProcessPath::Program ) );
ProcessChain *pc = new ProcessChain(o);
if (receiver)
{
if (successMember)
connect( pc, SIGNAL(successful()), receiver, successMember );
if (failMember)
connect( pc, SIGNAL(failed()), receiver, failMember );
}
return QString(fileName).replace(".asm",".cod");
}
else if ( extension == "c" )
{
ProcessOptions o;
o.b_addToProject = false;
o.setTargetFile( QString(fileName).replace(".c",".hex"));
o.setInputFiles(QStringList(fileName));
o.setMethod( ProcessOptions::Method::Forget );
o.setProcessPath( ProcessOptions::ProcessPath::C_Program );
ProcessChain *pc = new ProcessChain(o);
if (receiver)
{
if (successMember)
connect( pc, SIGNAL(successful()), receiver, successMember );
if (failMember)
connect( pc, SIGNAL(failed()), receiver, failMember );
}
return QString(fileName).replace(".c",".cod");
}
if ( failMember )
QTimer::singleShot( 0, receiver, failMember );
return QString::null;
}
bool DoublePoleBalancing::terminalState() const
{
return successful() || std::fabs(state(0)) > maxCartPosition
|| std::fabs(state(2)) > maxPoleAngularPosition1
|| std::fabs(state(4)) > maxPoleAngularPosition2;
}
void MainWindow::doLaunch()
{
if (!m_selectedInstance)
return;
// Find an account to use.
std::shared_ptr<MojangAccountList> accounts = MMC->accounts();
MojangAccountPtr account = accounts->activeAccount();
if (accounts->count() <= 0)
{
// Tell the user they need to log in at least one account in order to play.
auto reply = CustomMessageBox::selectable(
this, tr("No Accounts"),
tr("In order to play Minecraft, you must have at least one Mojang or Minecraft "
"account logged in to MultiMC."
"Would you like to open the account manager to add an account now?"),
QMessageBox::Information, QMessageBox::Yes | QMessageBox::No)->exec();
if (reply == QMessageBox::Yes)
{
// Open the account manager.
on_actionManageAccounts_triggered();
}
}
else if (account.get() == nullptr)
{
// If no default account is set, ask the user which one to use.
AccountSelectDialog selectDialog(tr("Which account would you like to use?"),
AccountSelectDialog::GlobalDefaultCheckbox, this);
selectDialog.exec();
// Launch the instance with the selected account.
account = selectDialog.selectedAccount();
// If the user said to use the account as default, do that.
if (selectDialog.useAsGlobalDefault() && account.get() != nullptr)
accounts->setActiveAccount(account->username());
}
// if no account is selected, we bail
if (!account.get())
return;
QString failReason = tr("Your account is currently not logged in. Please enter "
"your password to log in again.");
// do the login. if the account has an access token, try to refresh it first.
if (account->accountStatus() != NotVerified)
{
// We'll need to validate the access token to make sure the account is still logged in.
ProgressDialog progDialog(this);
progDialog.setSkipButton(true, tr("Play Offline"));
auto task = account->login();
progDialog.exec(task.get());
auto status = account->accountStatus();
if (status != NotVerified)
{
updateInstance(m_selectedInstance, account);
}
else
{
if (!task->successful())
{
failReason = task->failReason();
}
if (loginWithPassword(account, failReason))
updateInstance(m_selectedInstance, account);
}
// in any case, revert from online to verified.
account->downgrade();
}
else
{
if (loginWithPassword(account, failReason))
{
updateInstance(m_selectedInstance, account);
account->downgrade();
}
// in any case, revert from online to verified.
account->downgrade();
}
}
operator bool () const { return successful(); }
void ProcessChain::slotFinishedCompile(Language *language)
{
ProcessOptions options = language->processOptions();
if ( options.b_addToProject && ProjectManager::self()->currentProject() )
ProjectManager::self()->currentProject()->addFile( KUrl(options.targetFile()) );
ProcessOptions::ProcessPath::MediaType typeTo = ProcessOptions::ProcessPath::to( m_processOptions.processPath() );
TextDocument * editor = 0l;
if ( KTLConfig::reuseSameViewForOutput() )
{
editor = options.textOutputTarget();
if ( editor && (!editor->url().isEmpty() || editor->isModified()) )
editor = 0l;
}
switch (typeTo)
{
case ProcessOptions::ProcessPath::AssemblyAbsolute:
case ProcessOptions::ProcessPath::AssemblyRelocatable:
case ProcessOptions::ProcessPath::C:
case ProcessOptions::ProcessPath::Disassembly:
case ProcessOptions::ProcessPath::Library:
case ProcessOptions::ProcessPath::Microbe:
case ProcessOptions::ProcessPath::Object:
case ProcessOptions::ProcessPath::Program:
{
switch ( options.method() )
{
case ProcessOptions::Method::LoadAsNew:
{
if ( !editor )
editor = DocManager::self()->createTextDocument();
if ( !editor )
break;
QString text;
QFile f( options.targetFile() );
if ( !f.open( QIODevice::ReadOnly ) )
{
editor->deleteLater();
editor = 0l;
break;
}
QTextStream stream(&f);
while ( !stream.atEnd() )
text += stream.readLine()+'\n';
f.close();
editor->setText( text, true );
break;
}
case ProcessOptions::Method::Load:
{
editor = dynamic_cast<TextDocument*>( DocManager::self()->openURL(options.targetFile()) );
break;
}
case ProcessOptions::Method::Forget:
break;
}
}
case ProcessOptions::ProcessPath::FlowCode:
case ProcessOptions::ProcessPath::Pic:
case ProcessOptions::ProcessPath::Unknown:
break;
}
if (editor)
{
switch (typeTo)
{
case ProcessOptions::ProcessPath::AssemblyAbsolute:
case ProcessOptions::ProcessPath::AssemblyRelocatable:
{
if ( KTLConfig::autoFormatMBOutput() )
editor->formatAssembly();
editor->slotInitLanguage( TextDocument::ct_asm );
break;
}
case ProcessOptions::ProcessPath::C:
editor->slotInitLanguage( TextDocument::ct_c );
break;
case ProcessOptions::ProcessPath::Disassembly:
break;
case ProcessOptions::ProcessPath::Library:
case ProcessOptions::ProcessPath::Object:
case ProcessOptions::ProcessPath::Program:
editor->slotInitLanguage( TextDocument::ct_hex );
break;
case ProcessOptions::ProcessPath::Microbe:
editor->slotInitLanguage( TextDocument::ct_microbe );
break;
case ProcessOptions::ProcessPath::FlowCode:
case ProcessOptions::ProcessPath::Pic:
case ProcessOptions::ProcessPath::Unknown:
break;
}
DocManager::self()->giveDocumentFocus( editor );
}
options.setTextOutputtedTo( editor );
emit successful(options);
emit successful();
}
CommandLine::CommandLine(int argc, char* const argv[]) :
CommandLineBase(argc, argv, "hi:o:p:s:t:u:1:?"),
input_(0),
output_(0),
pass_(""),
server_(0),
user_(0),
input_source_(ss_unknown),
output_sink_(ss_unknown)
{
// Parse the command line
int ch;
while (successful() && ((ch = parse_next()) != EOF)) {
switch (ch) {
case 'i':
case 't':
case '1':
if (input_) {
std::cerr << "Warning: overriding previous input "
"source! Only last -i, -t or -1 is "
"effective.\n";
}
input_ = option_argument();
input_source_ =
(ch == '1' ? ss_ssqls1 :
ch == 'i' ? ss_ssqls2 :
ss_table);
break;
case 'o':
output_ = option_argument();
output_sink_ = ss_ssqls2;
break;
case 'p':
pass_ = option_argument();
break;
case 's':
server_ = option_argument();
break;
case 'u':
user_ = option_argument();
break;
default:
parse_error();
}
}
finish_parse();
// Figure out whether command line makes sense, and if not, tell
// user about it.
if (successful()) {
if (input_source_ == ss_unknown) {
parse_error("No input source given! Need -i, -t or -1.");
}
else if ((input_source_ != ss_ssqls2) && !output_) {
parse_error("Need -o if you give -t or -1!");
}
}
}
