SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const QString& commandId,
const SmartPointer<IHandler>& handler)
{
const IHandlerActivation::Pointer localActivation(
new HandlerActivation(commandId, handler, defaultExpression, IHandlerActivation::ROOT_DEPTH, this));
return DoActivation(localActivation);
}
SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const QString& commandId,
const SmartPointer<IHandler>& handler,
const SmartPointer<Expression>& expression,
bool global)
{
if (global)
{
const IHandlerActivation::Pointer activation = parent->ActivateHandler(
commandId, handler, expression, global);
parentActivations.insert(activation);
return activation;
}
Expression::Pointer aExpression = defaultExpression;
if (expression.IsNotNull() && defaultExpression.IsNotNull())
{
const AndExpression::Pointer andExpression(new AndExpression());
andExpression->Add(expression);
andExpression->Add(defaultExpression);
aExpression = andExpression;
}
else if (expression.IsNotNull())
{
aExpression = expression;
}
const IHandlerActivation::Pointer localActivation(
new HandlerActivation(commandId, handler, aExpression, IHandlerActivation::ROOT_DEPTH, this));
return DoActivation(localActivation);
}
SmartPointer<IHandlerActivation> SlaveHandlerService::ActivateHandler(const SmartPointer<IHandlerActivation>& childActivation)
{
const QString commandId = childActivation->GetCommandId();
const IHandler::Pointer handler = childActivation->GetHandler();
const Expression::Pointer childExpression = childActivation->GetExpression();
Expression::Pointer expression = defaultExpression;
if (childExpression.IsNotNull() && defaultExpression.IsNotNull())
{
const AndExpression::Pointer andExpression(new AndExpression());
andExpression->Add(childExpression);
andExpression->Add(defaultExpression);
expression = andExpression;
}
else if (childExpression.IsNotNull())
{
expression = childExpression;
}
const int depth = childActivation->GetDepth() + 1;
const IHandlerActivation::Pointer localActivation(
new HandlerActivation(commandId, handler, expression, depth, this));
return DoActivation(localActivation);
}
void AtomicTool::Start()
{
// Subscribe to events
SubscribeToEvent(E_COMMANDERROR, HANDLER(AtomicTool, HandleCommandError));
SubscribeToEvent(E_COMMANDFINISHED, HANDLER(AtomicTool, HandleCommandFinished));
SubscribeToEvent(E_LICENSE_EULAREQUIRED, HANDLER(AtomicTool, HandleLicenseEulaRequired));
SubscribeToEvent(E_LICENSE_ACTIVATIONREQUIRED, HANDLER(AtomicTool, HandleLicenseActivationRequired));
SubscribeToEvent(E_LICENSE_ERROR, HANDLER(AtomicTool, HandleLicenseError));
SubscribeToEvent(E_LICENSE_SUCCESS, HANDLER(AtomicTool, HandleLicenseSuccess));
const Vector<String>& arguments = GetArguments();
ToolSystem* tsystem = new ToolSystem(context_);
context_->RegisterSubsystem(tsystem);
ToolEnvironment* env = new ToolEnvironment(context_);
context_->RegisterSubsystem(env);
//#ifdef ATOMIC_DEV_BUILD
if (!env->InitFromJSON())
{
ErrorExit(ToString("Unable to initialize tool environment from %s", env->GetDevConfigFilename().CString()));
return;
}
if (!cliDataPath_.Length())
{
cliDataPath_ = env->GetRootSourceDir() + "/Resources/";
}
//#endif
tsystem->SetCLI();
tsystem->SetDataPath(cliDataPath_);
if (activationKey_.Length())
{
DoActivation();
return;
} else if (deactivate_)
{
DoDeactivation();
return;
}
BuildSystem* buildSystem = GetSubsystem<BuildSystem>();
SharedPtr<CommandParser> parser(new CommandParser(context_));
SharedPtr<Command> cmd(parser->Parse(arguments));
if (!cmd)
{
String error = "No command found";
if (parser->GetErrorMessage().Length())
error = parser->GetErrorMessage();
ErrorExit(error);
return;
}
if (cmd->RequiresProjectLoad())
{
FileSystem* fileSystem = GetSubsystem<FileSystem>();
String projectDirectory = fileSystem->GetCurrentDir();
Vector<String> projectFiles;
fileSystem->ScanDir(projectFiles, projectDirectory, "*.atomic", SCAN_FILES, false);
if (!projectFiles.Size())
{
ErrorExit(ToString("No .atomic project file in %s", projectDirectory.CString()));
return;
}
else if (projectFiles.Size() > 1)
{
ErrorExit(ToString("Multiple .atomic project files found in %s", projectDirectory.CString()));
return;
}
String projectFile = projectDirectory + "/" + projectFiles[0];
if (!tsystem->LoadProject(projectFile))
{
//ErrorExit(ToString("Failed to load project: %s", projectFile.CString()));
//return;
}
// Set the build path
String buildFolder = projectDirectory + "/" + "Build";
buildSystem->SetBuildPath(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
fileSystem->CreateDir(buildFolder);
if (!fileSystem->DirExists(buildFolder))
{
ErrorExit(ToString("Failed to create build folder: %s", buildFolder.CString()));
return;
}
}
}
command_ = cmd;
// BEGIN LICENSE MANAGEMENT
if (cmd->RequiresLicenseValidation())
{
GetSubsystem<LicenseSystem>()->Initialize();
}
else
{
if (command_.Null())
{
GetSubsystem<Engine>()->Exit();
return;
}
command_->Run();
}
// END LICENSE MANAGEMENT
}
