BOOL CALLBACK Child_Callback(HWND ChildWindow , LPARAM param)
{
char data[1024];
char lpButton[]="button";
char lpWindowsForms[]="forms";
char lpDropdown[]="";
ConvertToLowerCase(lpButton);
GetClassNameA(ChildWindow,data,1024);
ConvertToLowerCase(data);
__strstr strstr = (__strstr)GetProcAddress(GetModuleHandleA("ntdll.dll"),"strstr");
if((strstr(data,lpButton) || strstr(data,lpWindowsForms) ) && IsWindowVisible(ChildWindow) && IsWindowEnabled(ChildWindow))
{
GetWindowText(ChildWindow,data,1024);
ConvertToLowerCase(data);
int i=-1;
while(keywords[++i][0]!= '\0')
if(strstr(data,keywords[i]))
{
printf("Found %s\n",keywords[i]);
SetActiveWindow(ChildWindow);
SetForegroundWindow(ChildWindow);
SendMessage(ChildWindow, BM_CLICK , 0 , 0);
//RECT rect;
//GetWindowRect(ChildWindow,&rect);
//ClickMouse(rect.left+15,rect.top+15);
break;
}
}
return 1;
}
/*
Function: BumpCountForEachChar
Usage: BumpCountForEachChar(line, lCount)
-----------------------------------------
This function examines a line 'line' of text and for each alpha character
increments the associated index in 'lCount'. Case-insensitive, letters only.
*/
void BumpCountForEachChar(string line, int lCount[]) {
string chars_lc = ConvertToLowerCase(line);
for (int i = 0; i < chars_lc.length(); i++) {
if (isalpha(chars_lc[i]))
lCount[ chars_lc[i] % 'a' ] ++;
}
}
main()
{
dataBlockT db;
string line, cmd, token, var;
int pos;
printf("List structure test program\n");
printf("Type \"help\" for help\n");
db = NewDataBlock();
while (TRUE) {
printf(">");
line = GetLine();
SetScannerString(db->scanner, line);
cmd = ConvertToLowerCase(ReadToken(db->scanner));
if (IsVariableName(cmd)) {
var = cmd;
token = ReadToken(db->scanner);
if (StringEqual(token, "")) {
DisplayStringList(GetValue(db, var));
} else if (StringEqual(token, "=")) {
ParseOperation(db, var);
} else {
Error("Unexpected token %s", token);
}
} else if (StringEqual(cmd, "help")) {
HelpCmd();
} else if (StringEqual(cmd, "quit")) {
break;
} else {
SaveToken(db->scanner, cmd);
ParseOperation(db, NULL);
}
}
}
static void ConcatOperation(dataBlockT db, string lhs)
{
listADT result;
string v1, v2;
CheckForToken(db->scanner, "(");
v1 = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ",");
v2 = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ")");
result = ListConcat(GetValue(db, v1), GetValue(db, v2));
if (lhs == NULL) {
DisplayStringList(result);
} else {
SetValue(db, lhs, result);
}
}
bool ConfigurableImpl::RemoveParameter( const uint64 & actualKey ) {
uint64 key = ModifyKey( actualKey );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
AutoSharedLock lock( GetMutex(), true );
bool returnValue = mMap.erase( key ) >= 1 ? true : false;
return returnValue;
}
static void HeadOperation(dataBlockT db, string lhs)
{
string var;
if (lhs != NULL) Error("Head result cannot be assigned");
CheckForToken(db->scanner, "(");
var = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ")");
printf("%s\n", ListHead(GetValue(db, var)));
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
bool RunConsoleCommandFromLine( const std::string& line )
{
std::string lineLC = ConvertToLowerCase( line );
std::vector< std::string> args;
Tokenize( lineLC, args, "( ,;)" );
DeveloperConsoleArguments argsObj( args, 1 );
DeveloperConsole::WriteLine( line, INFO_TEXT_COLOR );
return RunConsoleCommand( args[0], &argsObj );
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
DeveloperConsoleCommand* DeveloperConsoleCommand::GetCommand( const std::string& name )
{
std::string nameLC = ConvertToLowerCase( name );
if (s_allCommands->find( nameLC ) != s_allCommands->end())
{
return s_allCommands->at( nameLC );
}
return nullptr;
}
IConfigurable::eDataType ConfigurableImpl::GetDataType( const uint64 & actualKey ) const {
uint64 key = ModifyKey( actualKey );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
AutoSharedLock lock( GetMutex() );
auto it = mMap.find( key );
if ( it == mMap.end() )
return kDTNone;
else
return it->second.first;
}
static void SelectionOperation(dataBlockT db, string lhs)
{
string var;
int pos;
if (lhs != NULL) Error("NthElement result cannot be assigned");
CheckForToken(db->scanner, "(");
var = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ",");
pos = StringToInteger(ReadToken(db->scanner));
CheckForToken(db->scanner, ")");
printf("%s\n", NthElement(GetValue(db, var), pos));
}
//definition of class methods
void ConfigurableImpl::SetParameter( const uint64 & actualKey, eDataType type, const CombinedDataValue & value ) {
uint64 key = ModifyKey( actualKey );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
eConfigurableErrorCode validKey = ValidateKey( key );
eDataType oldType = kDTNone;
CombinedDataValue oldValue;
if ( validKey == kCECNone ) {
AutoSharedLock lock( GetMutex(), true );
if ( mKeysSet ) {
auto it = mKeysSet->find( key );
if ( it == mKeysSet->end() )
NotifyError( "Key is not supported", key, kCECKeyNotSupported, type, value, oldType, oldValue );
}
eConfigurableErrorCode validValue = ValidateValue( key, type, value );
if ( validValue == kCECNone && mKeyValueTypeMap ) {
auto it = mKeyValueTypeMap->find( key );
if ( it != mKeyValueTypeMap->end() ) {
if ( type != it->second ) {
validValue = kCECValueTypeNotSupported;
}
}
}
if ( validValue == kCECNone && !mAllowDifferentValueTypesForExistingEntries ) {
auto it = mMap.find( key );
if ( it != mMap.end() && it->second.first != type )
validValue = kCECPreviousTypeDifferent;
}
if ( validValue == kCECNone ) {
TypeValuePair pair;
pair.first = type;
pair.second = value;
mMap[ key ] = pair;
} else {
auto it = mMap.find( key );
if ( it != mMap.end() ) {
oldType = it->second.first;
oldValue = it->second.second;
}
NotifyError( "Validation failed for the parameter, type and value combination", key, validValue, type,
value, oldType, oldValue );
}
} else {
NotifyError( "Key is not valid", key, validKey, type, value, oldType, oldValue );
}
}
static void TailOperation(dataBlockT db, string lhs)
{
listADT result;
string var;
CheckForToken(db->scanner, "(");
var = ConvertToLowerCase(ReadToken(db->scanner));
CheckForToken(db->scanner, ")");
result = ListTail(GetValue(db, var));
if (lhs == NULL) {
DisplayStringList(result);
} else {
SetValue(db, lhs, result);
}
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
bool DeveloperConsoleArguments::GetBool( bool& boolean )
{
std::string string = "";
if (PeekString( string ))
{
string = ConvertToLowerCase( string );
if (string == "true")
boolean = true;
else if (string == "false")
boolean = false;
m_currentIndex++;
return true;
}
return false;
}
void APICALL ConfigurableImpl::SetAllowedKeys( uint64 * keysTable, sizet sizeOfTable ) {
AutoSharedLock lock ( GetMutex(), true );
if ( mKeysSet ) {
delete mKeysSet;
mKeysSet = NULL;
}
if ( sizeOfTable > 0 && keysTable != NULL ) {
mKeysSet = new KeysSet();
for ( sizet i = 0; i < sizeOfTable; i++ ) {
uint64 key = keysTable[ i ];
key = ModifyKey( key );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
mKeysSet->insert( key );
}
}
}
void APICALL ConfigurableImpl::SetAllowedValueTypesForKeys( KeyValueTypePair * keyValueTypePairTable, sizet sizeOfTable ) {
AutoSharedLock lock( GetMutex(), true );
if ( mKeyValueTypeMap ) {
delete mKeyValueTypeMap;
mKeyValueTypeMap = NULL;
}
if ( sizeOfTable > 0 && keyValueTypePairTable != NULL ) {
mKeyValueTypeMap = new keyValueTypeMap();
for ( sizet i = 0; i < sizeOfTable; i++ ) {
uint64 key = keyValueTypePairTable[i].first;
key = ModifyKey( key );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
( *mKeyValueTypeMap )[ key ] = keyValueTypePairTable[i].second;
}
}
}
bool ConfigurableImpl::GetParameter( const uint64 & actualKey, eDataType type, CombinedDataValue & value ) const {
uint64 key = ModifyKey( actualKey );
if ( mTreatKeyAsCaseInsensitiveCharBuffer )
key = ConvertToLowerCase( key );
AutoSharedLock lock( GetMutex() );
auto it = mMap.find( key );
if ( it == mMap.end() )
return false;
if ( it->second.first != type ) {
NOTIFY_ERROR( IError_v1::kEDConfigurable, kCECValueTypeMismatch,
"Type mismatch for a parameter", IError_v1::kESOperationFatal,
true, key, true, static_cast< uint64 >( it->second.first ), true, static_cast< uint64 >( type ) );
return false;
}
value = it->second.second;
return true;
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
bool DeveloperConsoleArguments::GetColorFromString( Rgba& color )
{
std::string string = "";
if (PeekString( string ))
{
string = ConvertToLowerCase( string );
if (string == "red")
color = Rgba::RED;
else if (string == "blue")
color = Rgba::BLUE;
else if (string == "green")
color = Rgba::GREEN;
else if (string == "black")
color = Rgba::BLACK;
else if (string == "white")
color = Rgba::WHITE;
else if (string == "aqua")
color = Rgba::AQUA;
else if (string == "orange")
color = Rgba::ORANGE;
else if (string == "yellow")
color = Rgba::YELLOW;
else if (string == "grey")
color = Rgba::GREY;
else if (string == "magenta")
color = Rgba::MAGENTA;
else
return false;
m_currentIndex++;
return true;
}
return false;
}
void CountLetters(string fileName){
int numLetters = 26;
// Open file and read lines into a vector
ifstream fileStream;
fileStream.open( fileName.c_str() );
if ( fileStream.fail() ) {
Error("File could not be opened.");
}
// std::cout << "Here we opened the file named: " << fileName.c_str() << std::endl;
// readEntireFile( fileStream, lines);
// Create 26 items in vector; initialize them to 0
Vector<int> letterTable;
for ( int i = 0; i < numLetters; i++ ){
letterTable.add(0);
}
string tempString = "";
while (true) {
getline( fileStream, tempString );
if (fileStream.fail()) break;
tempString = ConvertToLowerCase( tempString );
for (int j = 0; j < tempString.size(); j++){
// find the differnce between 'a' and the current letter
int index = tempString.at( j ) - 'a';
// confirm current letter is 'a' or within 25 letters of 'a.'
if ( index >= 0 && index < numLetters ){
// increment value at index
letterTable.setAt( index, letterTable.getAt( index ) + 1 );
}
}
}
// Print the vector
for (int i = 0; i < numLetters; i++){
char currLetter = 'a' + i;
std::cout << currLetter << ": " << letterTable.getAt( i ) << std::endl;
}
}
/*
* Function: RecordWordForPlayer
* -----------------------------
* Exported function to add a word to a player's list and update
* their score accordingly. It keeps track of the number of
* words recorded for each player and position each successive word
* in rows and columms from left to right, top to bottom. It
* also updates the scoreboards with point additions.
*/
void RecordWordForPlayer(string word, playerT player)
{
if (player != Human && player != Computer)
Error("RecordWordForPlayer called with invalid player argument.");
word = ConvertToLowerCase(word);
SetFont(WORD_FONT);
SetPointSize(WORD_FONT_SIZE);
SetPenColor("Word Color");
int numWordsInRow = gState.scoreBox[player].w/gState.wordColumnWidth;
int row = gState.numWords[player] / numWordsInRow;
int col = gState.numWords[player] % numWordsInRow;
MovePen(gState.scoreBox[player].x + col*gState.wordColumnWidth,
gState.scoreBox[player].y -(row+1)*GetFontHeight());
DrawTextString(word);
gState.numWords[player]++;
AddToScoreForPlayer(word.length() - 3, player); // +1 pt for each letter over length 4
if (col == numWordsInRow -1) UpdateDisplay(); // force update when completing a row
}
///---------------------------------------------------------------------------------
///
///---------------------------------------------------------------------------------
DeveloperConsoleCommand::DeveloperConsoleCommand( std::string name, DeveloperConsoleCommandFunc command, std::string helpMessage )
{
name = ConvertToLowerCase( name );
m_name = name;
m_command = command;
m_help = helpMessage;
if (!s_allCommands)
s_allCommands = new std::map < std::string, DeveloperConsoleCommand* >();
if (s_allCommands->find( name ) != s_allCommands->end())
{
ConsolePrintf( "Duplicate command registered: %s \n", name );
return;
}
s_allCommands->insert( std::pair< std::string, DeveloperConsoleCommand*>( name, (this) ) );
}
static void ParseOperation(dataBlockT db, string lhs)
{
string token;
token = ConvertToLowerCase(ReadToken(db->scanner));
if (StringEqual(token, "nthelement")) {
SelectionOperation(db, lhs);
} else if (StringEqual(token, "length")) {
LengthOperation(db, lhs);
} else if (StringEqual(token, "head")) {
HeadOperation(db, lhs);
} else if (StringEqual(token, "tail")) {
TailOperation(db, lhs);
} else if (StringEqual(token, "cons")) {
ConsOperation(db, lhs);
} else if (StringEqual(token, "concat")) {
ConcatOperation(db, lhs);
} else if (IsVariableName(token)) {
if (lhs == NULL) Error("Null lhs in assignment");
SetValue(db, lhs, GetValue(db, token));
} else {
Error("Illegal operation %s", token);
}
}