void xmodem_init() {
addCommand("rx", &rx);
}
void cMenu::addTilePic( uint32_t x, uint32_t y, uint32_t tile, uint32_t hue )
{
addCommand( "{tilepic %d %d %d %d}", x, y, tile, hue );
}
void cMenu::addCheckbox( uint32_t x, uint32_t y, uint32_t off, uint32_t on, uint32_t checked, int32_t result )
{
rc_checkbox.insert( make_pair( result, rc_serialCurrent ) );
addCommand( "{checkbox %d %d %d %d %d %d}", x, y, off, on, checked, rc_serialCurrent++ );
}
void cMenu::addCheckertrans( uint32_t x, uint32_t y, uint32_t width, uint32_t height )
{
addCommand( "{checkertrans %d %d %d %d}", x, y, width, height );
}
void cMenu::addText( uint32_t x, uint32_t y, unistring data, uint32_t hue )
{
addCommand( "{text %d %d %d %d}", x, y, hue, addString(data) ); //text <Spaces from Left> <Space from top> <Length, Color?> <# in order>
}
void cMenu::addGump( uint32_t x, uint32_t y, uint32_t gump, uint32_t hue )
{
addCommand( "{gumppic %d %d %d hue=%d}", x, y, gump, hue );
}
void cMenu::addHtmlGump( uint32_t x, uint32_t y, uint32_t width, uint32_t height, unistring html, uint32_t hasBack, uint32_t canScroll )
{
addCommand( "{htmlgump %d %d %d %d %d %d %d}", x, y, width, height, addString(html), hasBack, canScroll );
}
void PyQtProjectItem::installCommands()
{
// get plugins
CLIToolPlugin* ip = interpreter();
// temp command
pCommand cmd;
// build command
if ( ip ) {
cmd = ip->command();
}
cmd.setProject( this );
cmd.setSkipOnError( false );
const pCommand cmdInterpret = cmd;
// available commands
if ( ip ) {
// execute project
cmd = cmdInterpret;
cmd.setName( "run" );
cmd.setText( tr( "Run" ) );
cmd.setCommand( QString( "%1 $target$" ).arg( cmd.command() ) );
cmd.setParsers( QStringList() );
cmd.setTryAllParsers( false );
addCommand( "mInterpreter", cmd );
}
pyQtBinaryFilePath( PyQtProjectItem::Python );
// pyuic4 on current file
cmd = cmdInterpret;
cmd.setName( "generate_form" );
cmd.setText( tr( "Generate current form implementation" ) );
cmd.setCommand( QString( "%1 $cf$ -o $cf$.py" ).arg( pyQtBinaryFilePath( PyQtProjectItem::Uic ) ) );
cmd.setWorkingDirectory( "$cfp$" );
cmd.setParsers( QStringList() );
cmd.setSkipOnError( false );
cmd.setTryAllParsers( false );
addCommand( "mInterpreter", cmd );
// pyrcc4 on current file
cmd = cmdInterpret;
cmd.setName( "generate_resource" );
cmd.setText( tr( "Generate current resource implementation" ) );
cmd.setCommand( QString( "%1 $cf$ -o $cf$.py" ).arg( pyQtBinaryFilePath( PyQtProjectItem::Rcc ) ) );
cmd.setWorkingDirectory( "$cfp$" );
cmd.setParsers( QStringList() );
cmd.setSkipOnError( false );
cmd.setTryAllParsers( false );
addCommand( "mInterpreter", cmd );
// pylupdate4 on current source file
cmd = cmdInterpret;
cmd.setName( "update_translation" );
cmd.setText( tr( "Update current source translation file" ) );
cmd.setCommand( QString( "%1 $cf$ -ts translations.ts" ).arg( pyQtBinaryFilePath( PyQtProjectItem::LUpdate ) ) );
cmd.setWorkingDirectory( "$cpp$" );
cmd.setParsers( QStringList() );
cmd.setSkipOnError( false );
cmd.setTryAllParsers( false );
addCommand( "mInterpreter", cmd );
// lrelease on current file
cmd = cmdInterpret;
cmd.setName( "generate_translation" );
cmd.setText( tr( "Generate current translation qm file" ) );
cmd.setCommand( QString( "%1 $cf$ -qm translation.qm" ).arg( pyQtBinaryFilePath( PyQtProjectItem::LRelease ) ) );
cmd.setWorkingDirectory( "$cpp$" );
cmd.setParsers( QStringList() );
cmd.setSkipOnError( false );
cmd.setTryAllParsers( false );
addCommand( "mInterpreter", cmd );
// install defaults commands
XUPProjectItem::installCommands();
}
void Renderer::addCommand(RenderCommand* command)
{
int renderQueue =_commandGroupStack.top();
addCommand(command, renderQueue);
}
Scheduler::Scheduler(Command *masterCommand) {
addCommand(masterCommand);
}
void KPrDocument::removePages(QList<KoPAPageBase *> &pages)
{
KPrDeleteSlidesCommand *command = new KPrDeleteSlidesCommand(this, pages);
addCommand(command);
}
command_stream* evaluatePostfix(token* finalTokenStream)
{
/*
notes on structures and types declared above
typedef enum
{
WORD_TOKEN, //ls foo
SEMICOLON_TOKEN, // ;
PIPE_TOKEN, // |
AND_TOKEN, // &&
OR_TOKEN, // ||
LEFT_PAREN_TOKEN, // ( //not relevant at this point
RIGHT_PAREN_TOKEN, // )//not relevant at this point
GREATER_TOKEN, // >
LESS_TOKEN, // <
NEWLINE_TOKEN, // \n //not relevant at this point
NULL_TOKEN, // //not relevant at this point
} tokentype;
enum command_type
{
AND_COMMAND, // A && B
SEQUENCE_COMMAND, // A ; B
OR_COMMAND, // A || B
PIPE_COMMAND, // A | B
SIMPLE_COMMAND, // a simple command
SUBSHELL_COMMAND, // ( A )
};
typedef struct command_stream
{
struct command_stream* next;
struct command_stream* prev;
struct command* root;
} command_stream;
struct command
{
command* prev;
command* next; //for linked list before tree conversion
enum command_type type;
// Exit status, or -1 if not known (e.g., because it has not exited yet).
int status;
// I/O redirections, or 0 if none.
char *input;
char *output;
union
{
// for AND_COMMAND, SEQUENCE_COMMAND, OR_COMMAND, PIPE_COMMAND:
struct command *command[2];
// for SIMPLE_COMMAND:
char **word;
// for SUBSHELL_COMMAND:
struct command *subshell_command;
} u;
};
*/
command* cmd_start = NULL;
command* cmd_end = NULL;
command_stream* str_start = NULL;
command_stream* str_end = NULL;
command_stream* firststream = malloc(sizeof(command_stream));
addStream(&str_start, &str_end, firststream);
token* curr;
for (curr = finalTokenStream; curr != NULL; curr = curr->next)
if (curr->t == WORD_TOKEN) //add simple command to command stack
{
command* newcommand = malloc(sizeof(command));
newcommand->type = SIMPLE_COMMAND;
newcommand->status = -1;
newcommand->input = newcommand->output = 0;
newcommand->u.word = curr->words;
if (curr->prev && curr->prev->sub > 1 && curr->sub == 1) //if we just ended a subshell, then make what was there a subshell command on itself
{
command* prevcmd = malloc(sizeof(command));
prevcmd->type = SUBSHELL_COMMAND;
prevcmd->input = prevcmd->output = 0;
prevcmd->status = -1;
prevcmd->u.subshell_command = popCommand(&cmd_start, &cmd_end);
addCommand(&cmd_start, &cmd_end, prevcmd);
}
addCommand(&cmd_start, &cmd_end, newcommand);
}
else if (curr->t == SEMICOLON_TOKEN && curr->sub == 1) //stop working on the current stream and instead make a new stream if no subshell, otherwise make a sequence command
{
if (curr->prev && curr->prev->sub > 1) //if we just ended a subshell, then make cmd_start a subshell command on itself
{
command* newcommand = malloc(sizeof(command));
newcommand->type = SUBSHELL_COMMAND;
newcommand->input = newcommand->output = 0;
newcommand->status = -1;
newcommand->u.subshell_command = cmd_start;
cmd_start = newcommand;
}
str_end->root=cmd_start;
cmd_start = cmd_end = NULL;
command_stream* newstream = malloc(sizeof(command_stream));
addStream(&str_start, &str_end, newstream);
}
else if (curr->t == LESS_TOKEN || curr->t == GREATER_TOKEN) //change the input based on what command you are redirecting
{
//remove two last commands and make them a subtree with correct depth level and add subtree back to command list
command* dest = popCommand(&cmd_start, &cmd_end); //where to redirect
command* operation = popCommand(&cmd_start, &cmd_end); //what to do, assume always simple command
command* newcommand = malloc(sizeof(command));
newcommand->type = SIMPLE_COMMAND;
newcommand->status = -1;
if (curr->t == LESS_TOKEN)
{
newcommand->input = concat(dest->u.word[0], dest->u.word[1]);
newcommand->output= operation->output;
}
else
{
newcommand->output= concat(dest->u.word[0], dest->u.word[1]);
newcommand->input = operation->input;
}
newcommand->u.word = operation->u.word;
addCommand(&cmd_start, &cmd_end, newcommand);
}
else //an operation that needs to be made into a tree
{
command* operand2 = popCommand(&cmd_start, &cmd_end), *operand1 = popCommand(&cmd_start, &cmd_end);
if ((curr->prev && curr->prev->sub > 1 && curr->sub == 1) || operand2->type == SEQUENCE_COMMAND) //if we just ended a subshell, then make operand2 a subshell command on itself
{
command* newcommand = malloc(sizeof(command));
newcommand->type = SUBSHELL_COMMAND;
newcommand->input = newcommand->output = 0;
newcommand->status = -1;
newcommand->u.subshell_command = operand2;
operand2 = newcommand;
}
if (operand1->type == SEQUENCE_COMMAND) //convert operand1 into subshell if it was a sequence, as sequences are only possible in subshells
{
command* newcommand = malloc(sizeof(command));
newcommand->type = SUBSHELL_COMMAND;
newcommand->input = newcommand->output = 0;
newcommand->status = -1;
newcommand->u.subshell_command = operand1;
operand1 = newcommand;
}
command* newcommand = malloc(sizeof(command));
newcommand->type = tokenToCommandType(curr->t);
newcommand->status = -1;
newcommand->input = newcommand->output = 0;
newcommand->u.command[0] = operand1;
newcommand->u.command[1] = operand2;
addCommand(&cmd_start, &cmd_end, newcommand);
}
str_end->root=cmd_start;
return str_start;
}
command_stream_t
make_command_stream (int (*get_next_byte) (void *),
void *get_next_byte_argument)
{
if ( DEBUG == 1 )
printf("make_command_stream: Starting!\n");
//create return command_stream
struct command_stream *c_stream = (struct command_stream *) checked_malloc(sizeof(struct command_stream));
//read line from script
char *c_line = (char *) checked_malloc(sizeof(char *) * SIZE_BUFFER);
c_line = pullBytes(*get_next_byte, get_next_byte_argument);
//create token list and initialize to NULL
struct token_list *t_list = (struct token_list *) checked_malloc(sizeof(struct token_list));
t_list->start = NULL;
t_list->end = NULL;
int c_line_pos = 0;
int start_pos = 0;
int num_lines = 1;
int num_parens = 0;
bool new_word = false;
bool line_empty = true;
bool line_ignore = false;
bool line_NULL = true;
bool special_token_finished = false;
while( c_line != NULL )
{
if ( DEBUG == 1 )
printf("make_command_stream: current line:%d contents: %s\n", num_lines, c_line);
line_NULL = false;
while ( true )
{
//check if line is a comment or null byte and go to next lin
if ( c_line[0] == '#' || c_line[0] == '\0')
{
num_lines++;
line_ignore = true;
break;
}
//check for special tokens
if ( specialToken(c_line[c_line_pos]) )
{
if ( DEBUG == 1 )
printf("make_command_stream: is special token\n");
if ( c_line_pos == 0 && c_line[c_line_pos] != '(' )
printError(num_lines);
if ( new_word )
{
char *word_string = getString(c_line, start_pos, c_line_pos-1);
struct token *new_token = (struct token *) checked_malloc(sizeof(struct token));
new_token->word = word_string;
new_token->next = NULL;
addToken(new_token, t_list);
if ( DEBUG == 1 )
{
printf("make_command_stream: new token added\n");
}
}
start_pos = c_line_pos;
//make special token to add to list
struct token *token_special = (struct token *) checked_malloc(sizeof(struct token));
token_special->next = NULL;
// OR "||" operator and PIPE '|' operator
if ( c_line[c_line_pos] == '|' ) //PIPE token
{
if ( c_line[c_line_pos + 1] == '|' ) // OR token
{
token_special->word = getString(c_line, start_pos, c_line_pos + 1);
if ( DEBUG == 1 )
printf("make_command_stream: added token is OR operator\n");
c_line_pos += 2;
}
else
{
if ( DEBUG == 1 )
printf("make_command_stream: token is PIPE operator\n");
token_special->word = getString(c_line, start_pos, c_line_pos);
c_line_pos++;
}
special_token_finished = true;
}
else if ( c_line[c_line_pos] == '&' )
{
if ( c_line[c_line_pos + 1] == '&' )
{
token_special->word = getString(c_line, start_pos, c_line_pos + 1);
c_line_pos += 2;
special_token_finished = true;
if ( DEBUG == 1 )
printf("make_command_stream: token is AND operator\n");
}
else
printError(num_lines);
}
else if ( c_line[c_line_pos] == '(' )
{
token_special->word = getString(c_line, start_pos, c_line_pos);
num_parens++;
if ( DEBUG == 1 )
printf("make_command_stream: added token is LEFT_PAREN operator\n");
c_line_pos++;
special_token_finished = true;
}
else if ( c_line[c_line_pos] == ')' )
{
num_parens--;
if ( num_parens == 0 )
special_token_finished = false;
else
special_token_finished = true;
if ( num_parens < 0 )
printError(num_lines);
token_special->word = getString(c_line, start_pos, c_line_pos);
if ( DEBUG == 1 )
printf("make_command_stream: added token is a RIGHT_PAREN operator\n");
c_line_pos++;
}
else if ( c_line[c_line_pos] == ';' )
{
if ( DEBUG == 1 )
printf("make_command_stream: added token is a SEMI operator\n");
token_special->word = getString(c_line, start_pos, c_line_pos);
special_token_finished = false;
c_line_pos++;
}
else
{
token_special->word = getString(c_line, start_pos, c_line_pos);
c_line_pos++;
if ( DEBUG == 1 )
printf("make_command_stream: added token is a %s operator", token_special->word);
}
start_pos = c_line_pos;
addToken(token_special, t_list);
new_word = false;
line_empty = false;
}
else //not a special token
{
if ( validWord(c_line[c_line_pos]) || c_line[c_line_pos] == ' ' )
{
if ( c_line[c_line_pos] != ' ' )
if ( new_word == false )
{
new_word = true;
line_empty = false;
}
}
else
{
printError(num_lines);
}
c_line_pos++;
}
if ( c_line[c_line_pos] == '#' || c_line[c_line_pos] == '\0' )
{
if ( new_word )
{
char *word_string = getString(c_line, start_pos, c_line_pos - 1);
struct token *token_simple = (struct token *) checked_malloc(sizeof(struct token));
token_simple->word = word_string;
token_simple->next = NULL;
addToken(token_simple, t_list);
special_token_finished = false;
line_empty = false;
}
if ( (c_line[c_line_pos] == '\0' && special_token_finished) || (num_parens > 0) || line_empty)
{
if ( DEBUG == 1 )
printf("make_command_stream: Last token reached\n");
line_ignore = true;
if ( num_parens > 0 ) //newline in between sub-shell commands
{
struct token *semi_token = (struct token *) checked_malloc(sizeof(struct token));
semi_token->next = NULL;
char *s_colon = (char *) checked_malloc(sizeof(char *) * 2);
s_colon[0] = ';';
s_colon[1] = '\0';
semi_token->word = s_colon;
addToken(semi_token, t_list);
if ( DEBUG == 1 )
printf("make_command_stream: semi colon token created from newline\n");
}
}
break;
}
}
if ( DEBUG == 1 )
{
printf("make_command_stream: Tokens created and put into t_list\n");
int i = 0;
struct token *t_list_h = t_list->start;
struct token *t_list_t = t_list->end;
while ( t_list->start != NULL )
{
printf("make_command_stream: Word %d:%s\n", i, t_list->start->word);
t_list->start = t_list->start->next;
i++;
}
t_list->start = t_list_h;
t_list->end = t_list_t;
printf("\n\n");
}
// c_line is not empty/ignored
if ( line_ignore == false )
{
struct node_list *n_list = tokensToNodes(t_list);
if ( n_list == NULL )
printError(num_lines);
// create stack tree from our node list and add command
struct command *command_root = create_stack_tree(n_list);
if ( command_root == NULL )
{
if ( DEBUG == 1 )
printf("make_command_stream: command_root is NULL\n");
printError(num_lines);
}
addCommand(c_stream, command_root);
}
free(c_line);
c_line = pullBytes(*get_next_byte, get_next_byte_argument);
num_lines++;
c_line_pos = 0;
start_pos = 0;
new_word = false;
line_ignore = false;
line_empty = true;
line_NULL = true;
if ( DEBUG == 1 )
printf("make_command_stream: Iterations completed\n");
}
if ( num_parens > 0 && line_NULL )
{
printError(num_lines);
}
if ( special_token_finished && line_NULL )
{
printError(num_lines);
}
if ( DEBUG == 1 )
printf("make_command_stream: Reached end of function\n");
return c_stream;
}
void TestController::addConsoleAutoTest()
{
auto console = Director::getInstance()->getConsole();
static struct Console::Command autotest = {
"autotest",
"testcpp autotest command, use -h to list available tests",
[](int fd, const std::string& args)
{
Scheduler *sched = Director::getInstance()->getScheduler();
if(args == "help" || args == "-h")
{
const char msg[] = "usage: autotest ActionsTest\n\tavailable tests: ";
send(fd, msg, sizeof(msg),0);
send(fd, "\n",1,0);
for(int i = 0; i < g_testCount; i++)
{
send(fd, "\t",1,0);
send(fd, g_aTestNames[i].test_name, strlen(g_aTestNames[i].test_name)+1,0);
send(fd, "\n",1,0);
}
const char help_main[] = "\tmain, return to main menu\n";
send(fd, help_main, sizeof(help_main),0);
const char help_next[] = "\tnext, run next test\n";
send(fd, help_next, sizeof(help_next),0);
const char help_back[] = "\tback, run prev test\n";
send(fd, help_back, sizeof(help_back),0);
const char help_restart[] = "\trestart, restart current test\n";
send(fd, help_restart, sizeof(help_restart),0);
return;
}
if(args == "main")
{
sched->performFunctionInCocosThread( [&]()
{
auto scene = Scene::create();
auto layer = new TestController();
scene->addChild(layer);
layer->release();
Director::getInstance()->replaceScene(scene);
cocostudio::ArmatureDataManager::destroyInstance();
} );
return;
}
const char msg_notest[] = "autotest: can't detect running test.\n";
AppDelegate* app = (AppDelegate *)Application::getInstance();
BaseTest* currentTest = app->getCurrentTest();
if(args == "next")
{
if(currentTest != nullptr)
{
//currentTest->nextCallback(nullptr);
sched->performFunctionInCocosThread( [&](){
currentTest->nextCallback(nullptr);
} );
}
else
{
send(fd, msg_notest, sizeof(msg_notest),0);
}
return;
}
if(args == "back")
{
if(currentTest != nullptr)
{
sched->performFunctionInCocosThread( [&](){
currentTest->backCallback(nullptr);
} );
}
else
{
send(fd, msg_notest, sizeof(msg_notest),0);
}
return;
}
if(args == "restart")
{
if(currentTest != nullptr)
{
sched->performFunctionInCocosThread( [&](){
currentTest->restartCallback(nullptr);
} );
}
else
{
send(fd, msg_notest, sizeof(msg_notest),0);
}
return;
}
if(args == "run")
{
for (int i = 0; i < g_testCount; i++)
{
// create the test scene and run it
std::string msg("autotest: running test:");
msg += g_aTestNames[i].test_name;
send(fd, msg.c_str(), strlen(msg.c_str()),0);
send(fd, "\n",1,0);
currentController = &g_aTestNames[i];
sched->performFunctionInCocosThread( [&](){
auto scene = currentController->callback();
if(scene)
{
scene->runThisTest();
scene->release();
}
} );
wait(1);
BaseTest* firstTest = app->getCurrentTest();
if(firstTest == nullptr)
{
continue;
}
std::string t1("");
t1 += firstTest->subtitle();
send(fd, t1.c_str(), strlen(t1.c_str()),0);
send(fd, "\n",1,0);
wait(2);
while(1)
{
//currentTest->nextCallback(nullptr);
sched->performFunctionInCocosThread( [&](){
BaseTest *t = app->getCurrentTest();
if(t != nullptr)
{
t->nextCallback(nullptr);
}
} );
wait(1);
BaseTest * curTest = app->getCurrentTest();
if(curTest == nullptr)
{
break;
}
std::string title("");
title += curTest->subtitle();
send(fd, title.c_str(), strlen(title.c_str()),0);
send(fd, "\n",1,0);
wait(2);
if(t1 == title)
{
break;
}
}
}
std::string msg("autotest run successfully!");
send(fd, msg.c_str(), strlen(msg.c_str()),0);
send(fd, "\n",1,0);
return;
}
for(int i = 0; i < g_testCount; i++)
{
if(args == g_aTestNames[i].test_name)
{
currentController = &g_aTestNames[i];
std::string msg("autotest: running test:");
msg += args;
send(fd, msg.c_str(), strlen(msg.c_str()),0);
send(fd, "\n",1,0);
sched->performFunctionInCocosThread( [&](){
auto scene = currentController->callback();
if(scene)
{
scene->runThisTest();
scene->release();
}
} );
return;
}
}
//no match found,print warning message
std::string msg("autotest: could not find test:");
msg += args;
send(fd, msg.c_str(), strlen(msg.c_str()),0);
send(fd, "\n",1,0);
}
};
console->addCommand(autotest);
}
HProject::HProject()
{
// TODO: is it appropriate to add commands in the constructor or should they be registered somewhere else?
addCommand(new CProjectCreateClass());
}
void KoEnhancedPathShape::addCommand( const QString &command )
{
addCommand( command, true );
}
void cMenu::addButton( uint32_t x, uint32_t y, uint32_t up, uint32_t down, int32_t returnCode, bool pressable )
{
rc_button.insert( make_pair( rc_serialCurrent, returnCode ) );
addCommand( "{button %d %d %d %d %d %d %d}", x, y, up, down, pressable, pageCurrent, rc_serialCurrent++ );
}
//Does the assembly code verification, counting the instructions and data number.
int checksAssembly()
{
FILE *file = NULL;
char *line;
char aux[300];
//Number of lines
int lineNumber = 1;
//Counts the program lines(only instructions, directives and labels)
int lineCount = 0;
//Tells which part of the reader program is
int module = 0, end = 0, pseg = 0, dseg = 0;
//Save the directive code
int directiveCode = -2;
int instructionState = 0;
file = fopen(urlInputFile, "r");
while(fgets(aux, sizeof(aux), file)!= NULL)
{
//Verifies the line
line = verifyLine(aux);
//If is anything
if(line!=NULL)
{
//Reads the directive code
directiveCode = getDirective(line);
//Asserts that the first instructions are the .module
if(lineCount == 0 && directiveCode != 0){
informError(1, lineNumber);
fclose(file);
return 1;
}
//If is .module
if(directiveCode == 0){
module = 1;
end = 0;
}
//If is .pseg
else if(directiveCode == 1){
pseg = 1;
dseg = 0;
}
//If is .dseg
else if(directiveCode == 2){
if(pseg == 0){
informError(6, lineNumber);
fclose(file);
return 1;
}
pseg = 0;
dseg = 1;
}
//If is .end
else if(directiveCode == 4){
module = 0;
end = 1;
lineCount = 0;
}
//If is a wrong directive
else if(directiveCode == -2){
informError(3, lineNumber);
fclose(file);
return 1;
}
//If is a instruction increments the number of instruction
if(pseg == 1 && module == 1 && line[0] != '.' && directiveCode != 3){
addCommand(line, lineNumber);
numberOfInstructions++;
}
else if(pseg == 1 && module == 1 && line[0] == '.' && directiveCode == 3){
informError(4, lineNumber);
fclose(file);
return 1;
}
//If is a word increments the number of instruction
if(dseg == 1 && module == 1 && directiveCode == 3){
addCommand(line, lineNumber);
numberOfData++;
}
else if(dseg == 1 && module == 1 && directiveCode == -1){
informError(5, lineNumber);
fclose(file);
return 1;
}
//Checks if the memory(64KB -> 16384 32-bits address) was exceeded
if((numberOfData + numberOfInstructions) > 16384){
informError(2, lineNumber);
fclose(file);
return 1;
}
if(end != 1)
lineCount++;
}
lineNumber++;
}
fclose(file);
return 0;
}
void cMenu::addTiledGump( uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint32_t gump, uint32_t hue )
{
addCommand( "{gumppictiled %d %d %d %d %d %d}", x, y, width, height, gump, hue );
}
Sprite *HelloWorld::spriteWithColor1(Color4F color1, Color4F color2, float texWidth, float texHeight, int nStripes)
{
RenderTexture *rt = RenderTexture::create(texWidth, texHeight);
rt->beginWithClear(color1.r, color1.g, color1.b, color1.a);
// 3: Draw into the texture
// You'll add this later
setGLProgramState(cocos2d::GLProgramState::getOrCreateWithGLProgramName(cocos2d::GLProgram::SHADER_NAME_POSITION_TEXTURE_COLOR_NO_MVP));
_customCommand.init(_globalZOrder);
_customCommand.func = [texWidth, texHeight, nStripes, color2, this]() {
Vec2 *vertices = new Vec2[6*nStripes];
Color4F *colors = new Color4F[6*nStripes];
int nVertices = 0;
float x1 = -texHeight;
float x2;
float y1 = texHeight;
float y2 = 0;
float dx = texWidth / nStripes * 2;
float stripeWidth = dx/2;
for (int i=0; i<nStripes; i++) {
x2 = x1 + texHeight;
vertices[nVertices] = Vec2 {x1, y1};
colors[nVertices++] = Color4F{color2.r, color2.g, color2.b, color2.a};
vertices[nVertices] = Vec2 {x1+stripeWidth, y1};
colors[nVertices++] = Color4F {color2.r, color2.g, color2.b, color2.a};
vertices[nVertices] = Vec2 {x2, y2};
colors[nVertices++] = Color4F {color2.r, color2.g, color2.b, color2.a};
vertices[nVertices] = vertices[nVertices-2];
colors[nVertices++] = Color4F {color2.r, color2.g, color2.b, color2.a};
vertices[nVertices] = vertices[nVertices-2];
colors[nVertices++] = Color4F {color2.r, color2.g, color2.b, color2.a};
vertices[nVertices] = Vec2 {x2+stripeWidth, y2};
colors[nVertices++] = Color4F {color2.r, color2.g, color2.b, color2.a};
x1 += dx;
}
getGLProgram()->use();
getGLProgram()->setUniformsForBuiltins();
cocos2d::GL::enableVertexAttribs(cocos2d::GL::VERTEX_ATTRIB_FLAG_POSITION | cocos2d::GL::VERTEX_ATTRIB_FLAG_COLOR);
// glBindBuffer(GL_ARRAY_BUFFER, 0);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_TRUE, 0, colors);
glDrawArrays(GL_TRIANGLES, 0, (GLsizei)nVertices);
float gradientAlpha = 0.7f;
nVertices = 0;
vertices[nVertices] = Vec2 {0, 0};
colors[nVertices++] = Color4F {0, 0, 0, 0 };
vertices[nVertices] = Vec2 {texWidth, 0};
colors[nVertices++] = Color4F {0, 0, 0, 0};
vertices[nVertices] = Vec2 {0, texHeight};
colors[nVertices++] = Color4F {0, 0, 0, gradientAlpha};
vertices[nVertices] = Vec2 {texWidth, texHeight};
colors[nVertices++] = Color4F {0, 0, 0, gradientAlpha};
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, colors);
// glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);
cocos2d::GL::blendFunc(CC_BLEND_SRC, CC_BLEND_DST);
glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)nVertices);
// layer 3: top highlight
float borderHeight = texHeight/16;
float borderAlpha = 0.3f;
nVertices = 0;
vertices[nVertices] = Vec2 {0, 0};
colors[nVertices++] = Color4F {1, 1, 1, borderAlpha};
vertices[nVertices] = Vec2 {texWidth, 0};
colors[nVertices++] = Color4F {1, 1, 1, borderAlpha};
vertices[nVertices] = Vec2 {0, borderHeight};
colors[nVertices++] = Color4F {0, 0, 0, 0};
vertices[nVertices] = Vec2 {texWidth, borderHeight};
colors[nVertices++] = Color4F {0, 0, 0, 0};
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_POSITION, 2, GL_FLOAT, GL_FALSE, 0, vertices);
glVertexAttribPointer(cocos2d::GLProgram::VERTEX_ATTRIB_COLOR, 4, GL_FLOAT, GL_FALSE, 0, colors);
glBlendFunc(CC_BLEND_SRC, CC_BLEND_DST);
glDrawArrays(GL_TRIANGLE_STRIP, 0, (GLsizei)nVertices);
CC_SAFE_DELETE_ARRAY(vertices);
CC_SAFE_DELETE_ARRAY(colors);
};
auto renderer = Director::getInstance()->getRenderer();
renderer->addCommand(&_customCommand);
Sprite *noise = Sprite::create("Noise-iphone5hd.png");
noise->setBlendFunc(BlendFunc {GL_DST_COLOR, GL_ZERO});
noise->setPosition(texWidth/2, texHeight/2);
noise->visit();
rt->end();
return Sprite::createWithTexture(rt->getSprite()->getTexture());
}
void cMenu::addXmfHtmlGump( uint32_t x, uint32_t y, uint32_t width, uint32_t height, unistring clilocid, uint32_t hasBack , uint32_t canScroll )
{
addCommand( "{xmfhtmlgump %d %d %d %d %s %d %d}", x, y, width, height, addString(clilocid), hasBack, canScroll );
}
QxPreferences::QxPreferences(Ref<CharcoalDirectory> charcoalDirectory, QWidget* parent)
: QxDialog(parent),
charcoalDirectory_(charcoalDirectory),
themeManager_(charcoalDirectory->themeManager()),
paletteManager_(charcoalDirectory->paletteManager())
{
setWindowTitle(qApp->applicationName() + " - Preferences");
#ifdef Q_WS_MAC
#ifndef QT_MAC_USE_COCOA
setAttribute(Qt::WA_MacShowFocusRect, false);
#endif // QT_MAC_USE_COCOA
#endif // Q_WS_MAC
QGridLayout* grid = new QGridLayout(this);
{
tabs_ = new QTabWidget(this);
tabs_->setElideMode(Qt::ElideNone);
tabs_->setUsesScrollButtons(false);
grid->addWidget(tabs_, 0, 0);
// grid->setMargin(12);
}
{
editor_ = new QxEditorPreferences(tabs_);
tabs_->insertTab(tabs_->count(), editor_, tr("Editor"));
editor_->fontSize_->setRange(8, 32);
editor_->lineSpacing_->setRange(0, 32);
editor_->tabWidth_->setRange(2, 32);
editor_->indentWidth_->setRange(1, 32);
connect(editor_->tabIndentMode_, SIGNAL(toggled(bool)), editor_->indentWidth_, SLOT(setDisabled(bool)));
editor_->tabIndentMode_->setChecked(true);
connect(editor_->font_, SIGNAL(currentFontChanged(const QFont&)), this, SLOT(updateEditorFontOption(const QFont&)));
connect(editor_->fontSize_, SIGNAL(valueChanged(int)), this, SLOT(updateEditorIntOption(int)));
connect(editor_->fontAntialiasing_, SIGNAL(toggled(bool)), this, SLOT(updateEditorBoolOption(bool)));
connect(editor_->subpixelAntialiasing_, SIGNAL(toggled(bool)), this, SLOT(updateEditorBoolOption(bool)));
connect(editor_->lineSpacing_, SIGNAL(valueChanged(int)), this, SLOT(updateEditorIntOption(int)));
connect(editor_->showLineNumbers_, SIGNAL(toggled(bool)), this, SLOT(updateEditorBoolOption(bool)));
connect(editor_->showWhitespace_, SIGNAL(toggled(bool)), this, SLOT(updateEditorBoolOption(bool)));
connect(editor_->tabWidth_, SIGNAL(valueChanged(int)), this, SLOT(updateEditorIntOption(int)));
connect(editor_->autoIndent_, SIGNAL(toggled(bool)), this, SIGNAL(editorAutoIndentChanged(bool)));
connect(editor_->tabIndentMode_, SIGNAL(toggled(bool)), this, SLOT(updateEditorIndent(bool)));
connect(editor_->indentWidth_, SIGNAL(valueChanged(int)), this, SLOT(updateEditorIndent(int)));
}
{
terminal_ = new QxTerminalPreferences;
tabs_->insertTab(tabs_->count(), terminal_, tr("Terminal"));
terminal_->fontSize_->setRange(8, 32);
terminal_->lineSpacing_->setRange(0, 32);
terminal_->numberOfLines_->setRange(100000, 1000000);
terminal_->numberOfLines_->setSingleStep(100000);
terminal_->title_->addItems(
QString(
"$TITLE,"
"$FG,"
"$USER@$HOST,"
"$USER@$FQHOST,"
"$USER@$HOST:$CWD,"
"$FG [$USER@$HOST],"
"$FG [$USER@$HOST]:$CWD"
).split(",")
);
terminal_->title_->setCurrentIndex(5);
connect(terminal_->font_, SIGNAL(currentFontChanged(const QFont&)), this, SLOT(updateTerminalFontOption(const QFont&)));
connect(terminal_->fontSize_, SIGNAL(valueChanged(int)), this, SLOT(updateTerminalIntOption(int)));
connect(terminal_->fontAntialiasing_, SIGNAL(toggled(bool)), this, SLOT(updateTerminalBoolOption(bool)));
connect(terminal_->subpixelAntialiasing_, SIGNAL(toggled(bool)), this, SLOT(updateTerminalBoolOption(bool)));
connect(terminal_->lineSpacing_, SIGNAL(valueChanged(int)), this, SLOT(updateTerminalIntOption(int)));
connect(terminal_->endlessLogging_, SIGNAL(toggled(bool)), this, SLOT(updateTerminalEndlessLogging(bool)));
connect(terminal_->numberOfLines_, SIGNAL(valueChanged(int)), this, SIGNAL(terminalNumberOfLinesChanged(int)));
connect(terminal_->endlessLogging_, SIGNAL(toggled(bool)), terminal_->numberOfLines_, SLOT(setDisabled(bool)));
connect(terminal_->title_, SIGNAL(activated(const QString&)), this, SIGNAL(terminalTitleChanged(const QString&)));
QStringList paletteNames;
for (int i = 0, n = paletteManager_->numPalette(); i < n; ++i) {
Ref<Palette> palette = paletteManager_->paletteByIndex(i);
if (palette->numColors() >= QxVideoTerminal::NumColors) {
paletteNames << paletteManager_->paletteByIndex(i)->displayName();
paletteIndices_.append(i);
}
}
QStringListModel* model = new QStringListModel(paletteNames, terminal_->palette_);
terminal_->palette_->setModel(model);
connect(terminal_->palette_, SIGNAL(activated(int)), this, SLOT(terminalPaletteActivated(int)));
}
{
printing_ = new QxPrintingPreferences(tabs_);
tabs_->insertTab(tabs_->count(), printing_, tr("Printing"));
printing_->fontSize_->setRange(8, 32);
printing_->lineSpacing_->setRange(0, 32);
}
/*
{
// performance HACK to reduce application launch time
editor_->font_->setDisabled(true);
terminal_->font_->setDisabled(true);
printing_->font_->setDisabled(true);
#ifdef Q_WS_MAC
// visual HACK
editor_->font_->setFixedWidth(editor_->font_->sizeHint().width());
#endif
#if 0
editor_->font_->setMinimumContentsLength(20);
editor_->font_->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
terminal_->font_->setMinimumContentsLength(20);
terminal_->font_->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
printing_->font_->setMinimumContentsLength(20);
printing_->font_->setSizeAdjustPolicy(QComboBox::AdjustToMinimumContentsLength);
#endif
QTimer::singleShot(0, this, SLOT(startFontFilter()));
}
*/
{
themesView_ = new QListView(tabs_);
themesView_->setViewMode(QListView::IconMode);
themesView_->setMovement(QListView::Static);
themesView_->setResizeMode(QListView::Adjust);
themesView_->setFlow(QListView::LeftToRight);
// themesView_->setSpacing(10);
tabs_->insertTab(tabs_->count(), themesView_, tr("Theme"));
themesView_->setModel(new QxThemesModel(charcoalDirectory_, themesView_));
connect(
themesView_->selectionModel(), SIGNAL(currentRowChanged(const QModelIndex&, const QModelIndex&)),
this, SLOT(themeActivate(const QModelIndex&, const QModelIndex&))
);
}
{
commands_ = new QxCommandsPreferences(tabs_);
tabs_->insertTab(tabs_->count(), commands_, tr("Commands"));
connect(commands_->add_, SIGNAL(clicked()), this, SLOT(addCommand()));
connect(commands_->edit_, SIGNAL(clicked()), this, SLOT(editCommand()));
connect(commands_->del_, SIGNAL(clicked()), this, SLOT(delCommand()));
connect(commands_->import_, SIGNAL(clicked()), this, SLOT(importConfig()));
connect(commands_->export_, SIGNAL(clicked()), this, SLOT(exportConfig()));
commandsList_ = new QxCommandsList;
commandsModel_ = new QxCommandsModel(commandsList_);
commands_->view_->setModel(commandsModel_);
commands_->view_->setHeaderHidden(false);
}
{
codetips_ = new QxCodetipsPreferences(this, tabs_);
tabs_->insertTab(tabs_->count(), codetips_, tr("Code Tips"));
}
{
misc_ = new QxMiscPreferences(tabs_);
tabs_->insertTab(tabs_->count(), misc_, tr("Misc"));
misc_->scrollingSpeed_->setRange(1, 6);
misc_->scrollingSpeed_->setValue(3);
misc_->kinematicScrolling_->setChecked(true);
misc_->scrollingSpeed_->setEnabled(false);
connect(misc_->kinematicScrolling_, SIGNAL(toggled(bool)), misc_->scrollingSpeed_, SLOT(setDisabled(bool)));
connect(misc_->kinematicScrolling_, SIGNAL(toggled(bool)), this, SLOT(updateEditorBoolOption(bool)));
connect(misc_->kinematicScrolling_, SIGNAL(toggled(bool)), this, SLOT(updateTerminalBoolOption(bool)));
connect(misc_->scrollingSpeed_, SIGNAL(valueChanged(int)), this, SLOT(updateEditorIntOption(int)));
connect(misc_->scrollingSpeed_, SIGNAL(valueChanged(int)), this, SLOT(updateTerminalIntOption(int)));
connect(misc_->scrollingSpeed_, SIGNAL(valueChanged(int)), this, SLOT(setWheelScrollLines(int)));
}
/*{
config_ = new QxImportExportPreferences(tabs_);
tabs_->insertTab(5, config_, tr("Import/Export"));
config_->commands_->setChecked(true);
connect(config_->import_, SIGNAL(pressed()), this, SLOT(importConfig()));
connect(config_->export_, SIGNAL(pressed()), this, SLOT(exportConfig()));
}*/
QFontComboBox::FontFilters filters = QFontComboBox::MonospacedFonts|QFontComboBox::ScalableFonts;
editor_->font_->setFontFilters(filters);
terminal_->font_->setFontFilters(filters);
printing_->font_->setFontFilters(filters);
#ifndef QT_MAC_USE_COCOA
resize(524, 390); // visual HACK
#else
resize(599, 421); // visual HACK
#endif
}
void cMenu::addCroppedText( uint32_t x, uint32_t y, uint32_t width, uint32_t height, unistring text, uint32_t hue )
{
addCommand( "{croppedtext %d %d %d %d %d %d}", x, y, width, height, hue, addString(text) );
}
HSceneHandlerItem::HSceneHandlerItem()
{
// TODO: is it appropriate to add commands in the constructor or should they be registered somewhere else?
addCommand(new CSceneHandlerItemExit());
}
void cMenu::addResizeGump( uint32_t x, uint32_t y, uint32_t gump, uint32_t width, uint32_t height )
{
addCommand( "{resizepic %d %d %d %d %d}", x, y, gump, width, height );
}
virtual void HandleMessage(const pp::Var& var_message) {
// Receive a message from javascript.
if (var_message.is_string()) {
SkString msg(var_message.AsString().c_str());
if (msg.startsWith("init")) {
} else if (msg.startsWith("LoadSKP")) {
size_t startIndex = strlen("LoadSKP");
size_t dataSize = msg.size()/sizeof(char) - startIndex;
SkBase64 decodedData;
decodedData.decode(msg.c_str() + startIndex, dataSize);
size_t decodedSize = 3 * (dataSize / 4);
SkDebugf("Got size: %d\n", decodedSize);
if (!decodedData.getData()) {
SkDebugf("Failed to decode SKP\n");
return;
}
SkMemoryStream pictureStream(decodedData.getData(), decodedSize);
SkPicture* picture = SkPicture::CreateFromStream(&pictureStream);
if (NULL == picture) {
SkDebugf("Failed to create SKP.\n");
return;
}
fDebugger.loadPicture(picture);
picture->unref();
// Set up the command list.
SkTArray<SkString>* commands = fDebugger.getDrawCommandsAsStrings();
PostMessage("ClearCommands");
for (int i = 0; i < commands->count(); ++i) {
SkString addCommand("AddCommand:");
addCommand.append((*commands)[i]);
PostMessage(addCommand.c_str());
}
PostMessage("UpdateCommands");
// Set the overview text.
SkString overviewText;
fDebugger.getOverviewText(NULL, 0.0, &overviewText, 1);
overviewText.prepend("SetOverview:");
PostMessage(overviewText.c_str());
// Draw the SKP.
if (!fFlushLoopRunning) {
Paint();
}
} else if (msg.startsWith("CommandSelected:")) {
size_t startIndex = strlen("CommandSelected:");
int index = atoi(msg.c_str() + startIndex);
fDebugger.setIndex(index);
if (!fFlushLoopRunning) {
Paint();
}
} else if (msg.startsWith("Rewind")) {
fCanvas->clear(SK_ColorWHITE);
fDebugger.setIndex(0);
if (!fFlushLoopRunning) {
Paint();
}
} else if (msg.startsWith("StepBack")) {
fCanvas->clear(SK_ColorWHITE);
int currentIndex = fDebugger.index();
if (currentIndex > 1) {
fDebugger.setIndex(currentIndex - 1);
if (!fFlushLoopRunning) {
Paint();
}
}
} else if (msg.startsWith("Pause")) {
// TODO(borenet)
} else if (msg.startsWith("StepForward")) {
int currentIndex = fDebugger.index();
if (currentIndex < fDebugger.getSize() -1) {
fDebugger.setIndex(currentIndex + 1);
if (!fFlushLoopRunning) {
Paint();
}
}
} else if (msg.startsWith("Play")) {
fDebugger.setIndex(fDebugger.getSize() - 1);
if (!fFlushLoopRunning) {
Paint();
}
}
}
}
void cMenu::addInputField( uint32_t x, uint32_t y, uint32_t width, uint32_t height, uint16_t textId, unistring data, uint32_t hue )
{
rc_edit.insert( make_pair( textId, rc_serialCurrent ) );
addCommand( "{textentry %d %d %d %d %d %d %d}", x, y, width, height, hue, rc_serialCurrent++, addString(data) );
}
void luConsoleEdit::OnKeyDown(wxKeyEvent& event)
{
int ch = event.GetKeyCode();
wxString str;
if (ch == WXK_UP)
{
pasteCommand(-1);
return;
}
else if (ch == WXK_DOWN)
{
pasteCommand(+1);
return;
}
else if (ch == WXK_ESCAPE)
{
pasteCommand(0);
replaceCommand("");
return;
}
else if (ch == WXK_LEFT || ch == WXK_BACK)
{
long x = 0, y = 0;
if (PositionToXY(GetInsertionPoint(), &x, &y))
{
if (x <= (int)m_prompt.Length())
return;
}
}
else if (ch == WXK_HOME)
{
long x = 0, y = 0;
if (PositionToXY(GetInsertionPoint(), &x, &y))
{
x = m_prompt.Length();
long pos = XYToPosition(x, y);
SetSelection(pos, pos);
}
return;
}
if (ch == WXK_RETURN)
{
str = GetLineText(GetNumberOfLines() - 1);
str.Replace(m_prompt, "");
}
else
{
event.Skip();
}
if (ch == WXK_RETURN)
{
writeLine("\n");
str.Trim().Trim(false);
if (!str.IsEmpty())
{
runCmd(str, false, false);
addCommand(str);
}
writeLine(m_prompt);
pasteCommand(0);
}
}
void cMenu::addRadioButton( uint32_t x, uint32_t y, uint32_t off, uint32_t on, uint32_t checked, int32_t result )
{
rc_radio.insert( make_pair( result, rc_serialCurrent ) );
addCommand( "{radio %d %d %d %d %d %d}", x, y, off, on, checked, rc_serialCurrent++ );
}
BattleChoiceWindow::BattleChoiceWindow() : CommandWindow(0, 0, GameWindow::main->width(), true, true) {
addCommand(_t("Fight"));
addCommand(_t("Escape"));
m_columnMax = 2;
}
