static void output_matching_key_name(unsigned char c) {
char *name = key_name(c);
if (name) {
printf("Sequence matches bind key name \"%s\"\n", name);
free(name);
}
}
main(int argc, char *argv[]){
/** Check the number of parameters */
if (argc < 3) {
/** Tell the user how to run the program */
cerr << "Usage: " << argv[0] << " num_col key_file" << endl;
return 1;
}
mr_init_threading();
PFC pfc(AES_SECURITY);
SecureSelect *db=NULL;
int m=atoi(argv[1]);
string key_name(argv[2]);
db = new SecureSelect(m,&pfc,pfc.order());
#ifdef VERBOSE
int start = getMilliCount();
#endif
db->KeyGen(key_name);
#ifdef VERBOSE
int milliSecondsElapsed = getMilliSpan(start);
cout << "\texec time " << milliSecondsElapsed << endl;
#endif
}
int Document::decrypt(lua_State* L)
{
// use the provided arg to look up the crypto keys.
lua_getglobal(L, "get_crypto_key");
lua_pushvalue(L, -2);
lua_call(L, 1, 1);
// Get the returned value. nil will cause an error bumping us out.
Bson_ro* val = Lunar<Bson_ro>::check(L, -1);
std::string key_name(as_string(L, -2));
// Create a copy of the data. It is possible that the pop below
// will cause the returned value to GC.
lj::bson::Binary_type bt;
uint32_t key_sz;
const uint8_t* key_data = lj::bson::as_binary(val->node(), &bt, &key_sz);
std::unique_ptr<uint8_t[], lj::Wiper<uint8_t[]> > key_ptr(new uint8_t[key_sz]);
key_ptr.get_deleter().set_count(key_sz);
memcpy(key_ptr.get(), key_data, key_sz);
lua_pop(L, 2);
try
{
doc_->decrypt(key_ptr.get(),
key_sz,
key_name);
}
catch (lj::Exception& ex)
{
lua_pushstring(L, ex.str().c_str());
lua_error(L);
}
return 0;
}
static char *
var_value(register struct variable_defs * var, char *tag)
{
static char ival[16];
register char *str = NULL;
register int b;
if (tag != NULL)
*tag = var_on_stack(var) ? '>' :
(var->var_flags & V_LOCKED) ? '!' :
(var->var_flags & V_MODIFIED) ? '*' : ' ';
switch (VAR_TYPE) {
case V_STRING:
str = (VAR_OP == 1) ? CBUF_VAR : STR_VAR;
break;
case V_BOOLEAN:
b = BOOL_VAR;
if (VAR_OP == 2 || VAR_OP == 4)
b = !b;
str = b ? "on" : "off";
break;
case V_INTEGER:
sprintf(ival, "%d", INT_VAR);
str = ival;
break;
case V_KEY:
str = key_name(KEY_VAR);
break;
case V_SPECIAL:
str = "UNDEF";
switch (VAR_OP) {
case 2:
if (!also_read_articles)
break;
sprintf(ival, "%d", article_limit);
str = ival;
break;
case 3:
str = curchset->cs_name;
break;
}
break;
case V_CODES:
str = code_strings[VAR_OP];
break;
}
if (str == NULL)
str = "NULL";
return str;
}
int Document::encrypt(lua_State* L)
{
int top = lua_gettop(L);
// Every arg except the first is a path to encrypt
std::vector<std::string> paths;
if (top > 1)
{
paths.resize(top - 1);
while (top > 1)
{
// This code moves the item at lua index 2 and puts it
// in C index 0.
paths[top - 2] = as_string(L, -1);
lua_pop(L, 1);
top = lua_gettop(L);
}
}
// use the provided arg to look up the crypto keys.
lua_getglobal(L, "get_crypto_key");
lua_pushvalue(L, -2);
lua_call(L, 1, 1);
// Get the returned value. nil will cause an error bumping us out.
Bson_ro* val = Lunar<Bson_ro>::check(L, -1);
std::string key_name(as_string(L, -2));
// Create a copy of the data. It is possible that the pop below
// will cause the returned value to GC.
lj::bson::Binary_type bt;
uint32_t key_sz;
const uint8_t* key_data = lj::bson::as_binary(val->node(), &bt, &key_sz);
std::unique_ptr<uint8_t[], lj::Wiper<uint8_t[]> > key_ptr(new uint8_t[key_sz]);
key_ptr.get_deleter().set_count(key_sz);
memcpy(key_ptr.get(), key_data, key_sz);
lua_pop(L, 2);
try
{
// XXX Change this to get the server from somewhere.
doc_->encrypt(lj::Uuid::k_nil,
key_ptr.get(),
key_sz,
key_name,
paths);
}
catch (lj::Exception& ex)
{
lua_pushstring(L, ex.str().c_str());
lua_error(L);
}
return 0;
}
bool KeystoreClientImpl::listKeys(const std::string& prefix,
std::vector<std::string>* key_name_list) {
String16 prefix16(prefix.data(), prefix.size());
android::Vector<String16> matches;
auto error_code = keystore_->list(prefix16, kDefaultUID, &matches);
if (error_code.isOk()) {
for (const auto& match : matches) {
android::String8 key_name(match);
key_name_list->push_back(prefix + std::string(key_name.string(), key_name.size()));
}
return true;
}
return false;
}
LONG set_hotkey(HWND editbox, LONG newhotkey)
{
char buf[BUFSIZE];
LONG oldhotkey;
oldhotkey = SetWindowLong(editbox, GWL_USERDATA, newhotkey);
if (newhotkey) {
key_name(LOWORD(newhotkey), HIWORD(newhotkey), buf, BUFSIZE);
SendMessage(editbox, WM_SETTEXT, 0, (LPARAM) buf);
} else
SendMessage(editbox, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
return oldhotkey;
};
unsigned int make_hotkey(HWND editbox, LONG defhotkey)
{
char buf[BUFSIZE];
oldwindowproc =
(WNDPROC) SetWindowLong(editbox, GWL_WNDPROC,
(LONG) HotKeyControlProc);
SetWindowLong(editbox, GWL_USERDATA, defhotkey);
if (defhotkey) {
key_name(LOWORD(defhotkey), HIWORD(defhotkey), buf, BUFSIZE);
SendMessage(editbox, WM_SETTEXT, 0, (LPARAM) buf);
} else
SendMessage(editbox, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
return TRUE;
};
//##############################################################################
//##############################################################################
bool
BerkeleyDBCXXDb::commit_record(change_t change)
{
RANGE_LOG_TIMED_FUNCTION();
std::string key, data;
record_type type;
uint64_t object_version;
std::tie(type, key, object_version, data) = change;
std::string fullkey = key_name(type, key);
auto lck = boost::dynamic_pointer_cast<BerkeleyDBCXXLock>(this->write_lock(type, key));
DbTxn * dbtxn = BerkeleyDBCXXLockTxnGetter(lck).txn();
Dbt dbkey { (void*) fullkey.c_str(), (uint32_t) fullkey.size() };
Dbt dbdata { (void*) data.c_str(), (uint32_t) data.size() };
int dbrval = 0;
try {
dbrval = inst_->put(dbtxn, &dbkey, &dbdata, 0);
}
catch (DbException &e) {
THROW_STACK(DatabaseEnvironmentException(std::string("Unable to read record") + e.what()));
}
catch (std::exception &e) {
THROW_STACK(DatabaseEnvironmentException(std::string("Unable to read record") + e.what()));
}
switch(dbrval) {
case 0:
return true;
break;
case DB_LOCK_DEADLOCK:
THROW_STACK(DatabaseEnvironmentException("A transactional database environment operation was selected to resolve a deadlock."));
break;
case DB_LOCK_NOTGRANTED:
THROW_STACK(DatabaseEnvironmentException("unable to grant a lock in the allowed time."));
break;
case DB_REP_HANDLE_DEAD:
THROW_STACK(DatabaseEnvironmentException("Dead handle"));
break;
case EACCES:
THROW_STACK(DatabaseEnvironmentException("Database read-only"));
break;
default:
LOG(error, "unknown_rval_from_Db_put") << dbrval;
return false;
}
}
void table_key_process(fn_name_pair * table, Object * obj)
{
if (!kbhit())
return;
char *name = key_name(getch());
for (int i = 0; i < 100; i++) {
if (table[i].name == 0)
continue;
if (!strcmp(table[i].name, name)) {
if (table[i].fn == 0)
return;
table[i].fn(obj);
return;
}
}
}
std::string Keybinding_pool::describe_bindings_for(Interface_action action)
{
std::vector<long> bindings = keys_bound_to(action);
if (bindings.empty()) {
return "nothing assigned";
}
std::stringstream ret;
for (int i = 0; i < bindings.size(); i++) {
ret << key_name(bindings[i]);
if (i + 2 < bindings.size()) {
ret << ", ";
} else if (i + 1 < bindings.size()) {
ret << " or ";
}
}
return ret.str();
}
static HKEY OpenKey(LPCTSTR preset_name, bool const bWriteElseRead)
{
HKEY hkRet = NULL;
HKEY hkey = 0;
DWORD dwDisposition = 0;
std::basic_string<TCHAR> key_name(s_WeirdMetRegKeyRoot);
if(preset_name != NULL)
{
key_name += _T("\\");
key_name += preset_name;
}
RegCreateKeyEx(HKEY_CURRENT_USER, key_name.c_str(), 0, NULL, 0,
bWriteElseRead?KEY_WRITE:KEY_READ, NULL, &hkRet, &dwDisposition);
return hkRet;
}
//
// Get the keycode for the string 'str'
// Returns -1 for an invalid key code
//
int get_keycode(char const *str)
{
if( !str[0] )
{
return -1;
}
else if( !str[1] )
{
return str[0];
}
else
{
int j;
char buf[20];
for( j = 256; j < JK_MAX_KEY; j++ )
{
key_name( j, buf );
char *c = buf;
for( ; *c; c++ )
{
if( *c == ' ' )
{
*c = '_';
}
else
{
*c = tolower( *c );
}
}
if( strcmp( str, buf ) == 0 )
{
return j;
}
}
}
return -1;
}
/// Process the characters we receive as the user presses keys.
void process_input(bool continuous_mode) {
bool first_char_seen = false;
while (true) {
wchar_t wc = input_common_readch(first_char_seen && !continuous_mode);
if (wc == WEOF) {
return;
}
if (wc > 255) {
printf("\nUnexpected wide character from input_common_readch(): %lld / 0x%llx\n",
(long long)wc, (long long)wc);
return;
}
long long int curr_tstamp, delta_tstamp;
timeval char_tstamp;
gettimeofday(&char_tstamp, NULL);
curr_tstamp = char_tstamp.tv_sec * 1000000 + char_tstamp.tv_usec;
delta_tstamp = curr_tstamp - prev_tstamp;
if (delta_tstamp >= 1000000) delta_tstamp = 999999;
if (delta_tstamp >= 200000 && continuous_mode) {
printf("\n");
printf("Type 'exit' or 'quit' to terminate this program.\n");
printf("\n");
}
prev_tstamp = curr_tstamp;
unsigned char c = wc;
if (c < 32) {
// Control characters.
if (ctrl_equivalents[c]) {
printf("%6lld usec dec: %3u hex: %2x char: %s (aka \\c%c)\n", delta_tstamp, c, c,
ctrl_equivalents[c], c + 64);
} else {
printf("%6lld usec dec: %3u hex: %2x char: \\c%c\n", delta_tstamp, c, c, c + 64);
}
} else if (c == 32) {
// The space character.
printf("%6lld usec dec: %3u hex: %2x char: <space>\n", delta_tstamp, c, c);
} else if (c == 127) {
// The "del" character.
printf("%6lld usec dec: %3u hex: %2x char: \\x7f (aka del)\n", delta_tstamp, c, c);
} else if (c >= 128) {
// Non-ASCII characters (i.e., those with bit 7 set).
printf("%6lld usec dec: %3u hex: %2x char: non-ASCII\n", delta_tstamp, c, c);
} else {
// ASCII characters that are not control characters.
printf("%6lld usec dec: %3u hex: %2x char: %c\n", delta_tstamp, c, c, c);
}
char *const name = key_name(c);
if (name) {
printf("FYI: Saw sequence for bind key name \"%s\"\n", name);
free(name);
}
if (should_exit(c)) {
printf("\nExiting at your request.\n");
break;
}
first_char_seen = true;
}
}
void instr(SgGlobal* global) {
// Create the lock and key variables in global scope.
// In main:
// EnterScope();
// lock = getTopLock();
// key = getTopKey();
// .... rest of main
// ExitScope();
// return;
// FIXME: Add case where we handle arbitrary exits from main
// This can be handled similar to the way returns are handled
// for basic blocks.
SgScopeStatement* scope = isSgScopeStatement(global);
// Insert lock and key variables at the top of the global scope
// lock variable
std::cout << "VarCounter: " << Util::VarCounter << std::endl;
SgName lock_name("lock_var" + boost::lexical_cast<std::string>(Util::VarCounter));
SgVariableDeclaration* lock_var = Util::createLocalVariable(lock_name, getLockType(), NULL, scope);
// Add declaration at the top of the scope
scope->prepend_statement(lock_var);
// key variable
// **** IMPORTANT: Using same counter value for lock and key
SgName key_name("key_var" + boost::lexical_cast<std::string>(Util::VarCounter));
Util::VarCounter++;
SgVariableDeclaration* key_var = Util::createLocalVariable(key_name, getKeyType(), NULL, scope);
// Insert this key decl after the lock decl
SI::insertStatementAfter(lock_var, key_var);
// Now, find the main function and insert...
// EnterScope();
// lock = getTopLock();
// key = getTopKey();
// .... rest of main
// ExitScope()
// return; -- this already exists...
// see FIXME above
// find main function...
SgFunctionDeclaration* MainFn = SI::findMain(global);
if(!MainFn) {
#ifdef HANDLE_GLOBAL_SCOPE_DEBUG
printf("Can't find Main function. Not inserting Global Enter and Exit Scopes\n");
#endif
return;
}
SgBasicBlock *bb = Util::getBBForFn(MainFn);
// insert EnterScope()
#if 0
SgExpression* overload = buildOverloadFn("EnterScope", NULL, NULL, SgTypeVoid::createType(), scope,
GEFD(bb));
#endif
SgExpression* overload = buildMultArgOverloadFn("EnterScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope,
GEFD(bb));
SgStatement* enter_scope = SB::buildExprStatement(overload);
Util::insertAtTopOfBB(bb, enter_scope);
// insert lock = getTopLock();
//overload = buildOverloadFn("getTopLock", NULL, NULL, getLockType(), scope, GEFD(bb));
overload = buildMultArgOverloadFn("getTopLock", SB::buildExprListExp(), getLockType(), scope, GEFD(bb));
//SgStatement* lock_assign = SB::buildExprStatement(SB::buildAssignOp(SB::buildVarRefExp(lock_var), overload));
//SI::insertStatementAfter(enter_scope, lock_assign); //RMM COMMENTED OUT
// insert key = getTopKey();
// overload = buildOverloadFn("getTopKey", NULL, NULL, getKeyType(), scope, GEFD(bb));
overload = buildMultArgOverloadFn("getTopKey", SB::buildExprListExp(), getKeyType(), scope, GEFD(bb));
//SgStatement* key_assign = SB::buildExprStatement(SB::buildAssignOp(SB::buildVarRefExp(key_var), overload));
//SI::insertStatementAfter(lock_assign, key_assign); //RMM COMMENTED OUT
// add to scope -> lock and key map... SLKM
LockKeyPair lock_key = std::make_pair(lock_var, key_var);
scopeLockMap[scope] = lock_key;
ROSE_ASSERT(existsInSLKM(scope));
// Insert ExitScope if last stmt is not return.
SgStatementPtrList& stmts = bb->get_statements();
SgStatementPtrList::iterator it = stmts.begin();
it += (stmts.size() - 1);
// A little iffy on the scope part here... lets check that.
if(!isSgReturnStmt(*it)) {
// Last statement is not return. So, add exit scope...
// If its a break/continue statement, insert statement before,
// otherwise, add exit_scope afterwards.
//SgExpression* overload = buildOverloadFn("ExitScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb));
SgExpression* overload = buildMultArgOverloadFn("ExitScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb));
// check if its break/continue
if(isSgBreakStmt(*it) || isSgContinueStmt(*it)) {
SI::insertStatementBefore(*it, SB::buildExprStatement(overload));
}
else {
SI::insertStatementAfter(*it, SB::buildExprStatement(overload));
}
}
}
void KDesktopConfig::load( bool useDefaults )
{
// get number of desktops
NETRootInfo info( qt_xdisplay(), NET::NumberOfDesktops | NET::DesktopNames );
int n = info.numberOfDesktops();
int konq_screen_number = 0;
if (qt_xdisplay())
konq_screen_number = DefaultScreen(qt_xdisplay());
QCString groupname;
if (konq_screen_number == 0)
groupname = "Desktops";
else
groupname.sprintf("Desktops-screen-%d", konq_screen_number);
KConfig * kwinconfig = new KConfig("kwinrc");
kwinconfig->setReadDefaults( useDefaults );
kwinconfig->setGroup("Desktops");
for(int i = 1; i <= maxDesktops; i++)
{
QString key_name(QString("Name_") + QString::number(i));
QString name = QString::fromUtf8(info.desktopName(i));
if (name.isEmpty()) // Get name from configuration if none is set in the WM.
{
name = kwinconfig->readEntry(key_name, i18n("Desktop %1").arg(i));
}
_nameInput[i-1]->setText(name);
// Is this entry immutable or not in the range of configured desktops?
_labelImmutable[i - 1] = kwinconfig->entryIsImmutable(key_name);
_nameInput[i-1]->setEnabled(i <= n && !_labelImmutable[i - 1]);
}
_numInput->setEnabled(!kwinconfig->entryIsImmutable("Number"));
delete kwinconfig;
kwinconfig = 0;
QString configfile;
if (konq_screen_number == 0)
configfile = "kdesktoprc";
else
configfile.sprintf("kdesktop-screen-%drc", konq_screen_number);
KConfig *config = new KConfig(configfile, false, false);
config->setReadDefaults( useDefaults );
config->setGroup("Mouse Buttons");
_wheelOption->setChecked(config->readBoolEntry("WheelSwitchesWorkspace",false));
_wheelOptionImmutable = config->entryIsImmutable("WheelSwitchesWorkspace");
if (_wheelOptionImmutable || n<2)
_wheelOption->setEnabled( false );
delete config;
config = 0;
_numInput->setValue(n);
emit changed( useDefaults );
}
//##############################################################################
//##############################################################################
std::string
BerkeleyDBCXXDb::get_record(record_type type, const std::string& key) const
{
RANGE_LOG_TIMED_FUNCTION();
std::string fullkey = key_name(type, key);
auto txn = current_txn_.lock();
if(txn) {
std::string data;
if(txn->get_record(type, key, data)) {
return data;
}
}
auto lck = boost::dynamic_pointer_cast<BerkeleyDBCXXLock>(this->read_lock(type, key));
DbTxn * dbtxn = BerkeleyDBCXXLockTxnGetter(lck).txn();
Dbt dbkey { (void*) fullkey.c_str(), (uint32_t) fullkey.size() };
size_t bufsize = 131072;
std::unique_ptr<char[]> buf { nullptr };
Dbt dbdata;
int dbrval = 0;
do {
if(buf) { LOG(debug0, "resizing_record_buffer") << bufsize; }
buf = std::unique_ptr<char[]>(new char[bufsize]);
if(!buf) {
std::stringstream s;
s << "Unable to allocate buffer of size: " << bufsize;
THROW_STACK(DatabaseEnvironmentException(s.str()));
}
dbdata = Dbt(buf.get(), bufsize);
dbdata.set_ulen(bufsize);
dbdata.set_flags(DB_DBT_USERMEM);
bufsize *= 2;
int flags = lck->readonly() ? 0 : DB_RMW;
try {
dbrval = inst_->get(dbtxn, &dbkey, &dbdata, flags);
}
catch (DbException &e) {
if(e.get_errno() == DB_BUFFER_SMALL) { continue; }
THROW_STACK(DatabaseEnvironmentException(std::string("Unable to read record") + e.what()));
}
catch (std::exception &e) {
THROW_STACK(DatabaseEnvironmentException(std::string("Unable to read record") + e.what()));
}
} while(dbrval == DB_BUFFER_SMALL);
switch(dbrval) {
case 0:
break;
case DB_NOTFOUND:
return std::string();
case DB_BUFFER_SMALL:
THROW_STACK(DatabaseEnvironmentException("The requested item could not be returned due to undersized buffer."));
break;
case DB_LOCK_DEADLOCK:
THROW_STACK(DatabaseEnvironmentException("A transactional database environment operation was selected to resolve a deadlock."));
break;
case DB_LOCK_NOTGRANTED:
THROW_STACK(DatabaseEnvironmentException("unable to grant a lock in the allowed time."));
break;
case DB_REP_HANDLE_DEAD:
THROW_STACK(DatabaseEnvironmentException("Dead handle"));
break;
default:
LOG(error, "unknown dbrval") << dbrval;
}
std::string rval { (char *) dbdata.get_data(), dbdata.get_size() };
return rval;
}
// Draw the menu
void draw_menu(int menu_id, int menu_item, int place, float fade, HISCORE_LIST *list) {
glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
//glClear(GL_DEPTH_BUFFER_BIT);
// Set up the viewport
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
gluPerspective(30.0f, 1.333333f, 1, 100);
glTranslatef(0,0,-32);
// Draw the background
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
BIND_TEXTURE(menu_bg);
glDepthMask(GL_FALSE);
float bx = bx_roll;
float by = by_roll;
glBegin(GL_TRIANGLE_STRIP);
glColor3f(.1f,1,1);
glTexCoord2f(-bx + 1,-by + 1); glVertex3f(14, 14, -2);
glTexCoord2f(-bx + 0,-by + 1); glVertex3f(-14, 14, -2);
glColor3f(0,0.4f,0.7f);
glTexCoord2f(-bx + 1,-by + 0); glVertex3f(14, -14, -2);
glTexCoord2f(-bx + 0,-by + 0); glVertex3f(-14, -14, -2);
glEnd();
float rot = -5.0f;
glEnable(GL_BLEND);
for(int f=0; f<5; f++) {
glRotatef(rot * SIN(back_anim), 0,0,1);
glBegin(GL_TRIANGLE_STRIP);
glColor4f(0.1f,1,1,.25f);
glTexCoord2f(-bx + 1,-by + 1); glVertex3f(14, 14, -2);
glTexCoord2f(-bx + 0,-by + 1); glVertex3f(-14, 14, -2);
glColor4f(0,0.4f,0.7f,.25f);
glTexCoord2f(-bx + 1,-by + 0); glVertex3f(14, -14, -2);
glTexCoord2f(-bx + 0,-by + 0); glVertex3f(-14, -14, -2);
glEnd();
rot += (1.0f * COS(back_anim));
}
glDepthMask(GL_TRUE);
// Begin font drawing
begin_fonts();
glLoadIdentity();
// Draw the logo
glEnable(GL_BLEND);
BIND_TEXTURE(logo_tex);
glPushMatrix();
glTranslatef(0,4.5f,-13);
glRotatef(20.0f * COS(back_anim), 1,0,0);
glColor3f(1,1,1);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,1); glVertex3f( 4, .5f, 0);
glTexCoord2f(0,1); glVertex3f(-4, .5f, 0);
glTexCoord2f(1,0); glVertex3f( 4,-.5f, 0);
glTexCoord2f(0,0); glVertex3f(-4,-.5f, 0);
glEnd();
glPopMatrix();
// Draw the hiscores/credits
if(menu_id == MENU_ID_MAIN || menu_id == MENU_ID_START) {
if(mid_state == 1)
hiscore_1.draw(-1, mid_fade_amount);
else if(mid_state == 2)
hiscore_2.draw(-1, mid_fade_amount);
else if(mid_state == 3)
draw_credits(mid_fade_amount);
}
// Draw the version number
set_font_scale(0.3f, 0.3f);
glColor4f(1,1,1,0.3f);
glprintf(font1, 0, -7.0f, -5.3f, -13, VERSION);
set_font_scale(1,1);
// Draw the hilighted hiscore list if we're typing a name
if(place != -1 && list != NULL)
list->draw(place, 1.0f);
// Draw the menuitem background stripe
BIND_TEXTURE(0);
glColor4f(0,0,0,0.1f);
glPushMatrix();
glTranslatef(0,-4.0f, -13);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(10,.57f,0);
glVertex3f(-10,.57f,0);
glVertex3f(10,-.57f,0);
glVertex3f(-10,-.57f,0);
glEnd();
glPopMatrix();
// Draw the menuitems
if(menu_id == MENU_ID_MAIN) {
// START
if(menu_item == MENU_START)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
BIND_TEXTURE(button_tex);
glPushMatrix();
glTranslatef(-4.0f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,1); glVertex3f( 2, .5f, 0);
glTexCoord2f(0,1); glVertex3f(-2, .5f, 0);
glTexCoord2f(1,.75f); glVertex3f( 2,-.5f, 0);
glTexCoord2f(0,.75f); glVertex3f(-2,-.5f, 0);
glEnd();
glPopMatrix();
// OPTIONS
if(menu_item == MENU_OPTIONS)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
glPushMatrix();
glTranslatef(0, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,.75f); glVertex3f( 2, .5f, 0);
glTexCoord2f(0,.75f); glVertex3f(-2, .5f, 0);
glTexCoord2f(1,.5f); glVertex3f( 2,-.5f, 0);
glTexCoord2f(0,.5f); glVertex3f(-2,-.5f, 0);
glEnd();
glPopMatrix();
// EXIT
if(menu_item == MENU_EXIT)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
glPushMatrix();
glTranslatef(4.0f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,.5f); glVertex3f( 2, .5f, 0);
glTexCoord2f(0,.5f); glVertex3f(-2, .5f, 0);
glTexCoord2f(1,.25f); glVertex3f( 2,-.5f, 0);
glTexCoord2f(0,.25f); glVertex3f(-2,-.5f, 0);
glEnd();
glPopMatrix();
}
else if(menu_id == MENU_ID_START) {
// SINGLE PLAYER
if(menu_item == MENU_SINGLEPLAY)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
BIND_TEXTURE(button_tex2);
glPushMatrix();
glTranslatef(-2.0f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,1); glVertex3f( 2, .85f, 0);
glTexCoord2f(0,1); glVertex3f(-2, .85f, 0);
glTexCoord2f(1,.5f); glVertex3f( 2,-.85f, 0);
glTexCoord2f(0,.5f); glVertex3f(-2,-.85f, 0);
glEnd();
glPopMatrix();
// TWO PLAYERS
if(menu_item == MENU_MULTIPLAY)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
glPushMatrix();
glTranslatef(2.0f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,.5f); glVertex3f( 2, .85f, 0);
glTexCoord2f(0,.5f); glVertex3f(-2, .85f, 0);
glTexCoord2f(1,0); glVertex3f( 2,-.85f, 0);
glTexCoord2f(0,0); glVertex3f(-2,-.85f, 0);
glEnd();
glPopMatrix();
}
else if(menu_id == MENU_ID_OPTIONS) {
int who = whose_keys;
// Settings for ...
set_font_scale(0.6f, 0.5f);
if(menu_item == MENU_WHOSEKEYS)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, 3.0f, -13, "Settings for: %s", (whose_keys == 0) ? "PLAYER ONE" : "PLAYER TWO");
// Moving style
if(menu_item == MENU_MOVSTYLE)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, 2.5f, -13, "Moving style: %s", (config.moving_style[who] == 1) ? "RELATIVE" : "ABSOLUTE");
// Key up
if(menu_item == MENU_KEYUP)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
if(config.moving_style[who] == 1)
glprintf(font1, 0, -5.0f, 2.0f, -13, "Move forward: %s", key_name(config.key_up[who]));
else
glprintf(font1, 0, -5.0f, 2.0f, -13, "Move up: %s", key_name(config.key_up[who]));
// Key down
if(menu_item == MENU_KEYDOWN)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
if(config.moving_style[who] == 1)
glprintf(font1, 0, -5.0f, 1.5f, -13, "Turn around: %s", key_name(config.key_down[who]));
else
glprintf(font1, 0, -5.0f, 1.5f, -13, "Move down: %s", key_name(config.key_down[who]));
// Key left
if(menu_item == MENU_KEYLEFT)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
if(config.moving_style[who] == 1)
glprintf(font1, 0, -5.0f, 1.0f, -13, "Turn left: %s", key_name(config.key_left[who]));
else
glprintf(font1, 0, -5.0f, 1.0f, -13, "Move left: %s", key_name(config.key_left[who]));
// Key right
if(menu_item == MENU_KEYRIGHT)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
if(config.moving_style[who] == 1)
glprintf(font1, 0, -5.0f, 0.5f, -13, "Turn right: %s", key_name(config.key_right[who]));
else
glprintf(font1, 0, -5.0f, 0.5f, -13, "Move right: %s", key_name(config.key_right[who]));
// Key bomb
if(menu_item == MENU_KEYBOMB)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, 0.0f, -13, "Throw a bomb: %s", key_name(config.key_shoot[who]));
// Key special
if(menu_item == MENU_KEYSPECIAL)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, -0.5f, -13, "Use a special: %s", key_name(config.key_special[who]));
// Sound volume slider
if(menu_item == MENU_SOUNDVOL)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, -1.5f, -13, "Sound volume:");
glPushMatrix();
glTranslatef(2.0f, -1.5f, -13);
glColor3f(0,0,0.5f);
BIND_TEXTURE(0);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0,0,0);
glVertex2f(3, 0.55f);
glVertex2f(0, 0.55f);
glColor3f(0,0,0.5f);
glVertex2f(3, 0.0f);
glVertex2f(0, 0.0f);
glEnd();
glColor3f(0.5f,0.5f,1);
float vol = (float)config.sound_vol / 255.0f;
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0.5f,0.5f,1);
glVertex2f(2.95f * vol, 0.50f);
glVertex2f(0.05f, 0.50f);
glColor3f(0.25f,0.25f,0.5f);
glVertex2f(2.95f * vol, 0.05f);
glVertex2f(0.05f, 0.05f);
glEnd();
glPopMatrix();
// Music volume slider
if(menu_item == MENU_MUSICVOL)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, -2.0f, -13, "Music volume:");
glPushMatrix();
glTranslatef(2.0f, -2.0f, -13);
BIND_TEXTURE(0);
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0,0,0);
glVertex2f(3, 0.55f);
glVertex2f(0, 0.55f);
glColor3f(0,0,0.5f);
glVertex2f(3, 0.0f);
glVertex2f(0, 0.0f);
glEnd();
vol = (float)config.music_vol / 255.0f;
glBegin(GL_TRIANGLE_STRIP);
glColor3f(0.5f,0.5f,1);
glVertex2f(2.95f * vol, 0.50f);
glVertex2f(0.05f, 0.50f);
glColor3f(0.25f,0.25f,0.5f);
glVertex2f(2.95f * vol, 0.05f);
glVertex2f(0.05f, 0.05f);
glEnd();
glPopMatrix();
// Toggle perspective mode
if(menu_item == MENU_PERSPECTIVE)
glColor3fv(col_selected2);
else
glColor3fv(col_normal2);
glprintf(font1, 0, -5.0f, -3.0f, -13, "Perspective mode: %s", (config.perspective_mode) ? "ON" : "OFF");
set_font_scale(1,1);
// OK
if(menu_item == MENU_OK)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
BIND_TEXTURE(button_tex);
glPushMatrix();
glTranslatef(-2.25f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(.25f,.25f); glVertex3f( .5f, .5f, 0);
glTexCoord2f(0,.25f); glVertex3f(-.5f, .5f, 0);
glTexCoord2f(.25f,0); glVertex3f( .5f,-.5f, 0);
glTexCoord2f(0,0); glVertex3f(-.5f,-.5f, 0);
glEnd();
glPopMatrix();
// CANCEL
if(menu_item == MENU_CANCEL)
glColor3fv(col_selected);
else
glColor3fv(col_normal);
glPushMatrix();
glTranslatef(2.25f, -4.0f, -13);
glRotatef(20.0f * SIN(back_anim), 1,0,0);
glBegin(GL_TRIANGLE_STRIP);
glTexCoord2f(1,.25f); glVertex3f( 1.5f, .5f, 0);
glTexCoord2f(.25f,.25f); glVertex3f(-1.5f, .5f, 0);
glTexCoord2f(1,0); glVertex3f( 1.5f,-.5f, 0);
glTexCoord2f(.25f,0); glVertex3f(-1.5f,-.5f, 0);
glEnd();
glPopMatrix();
}
// Draw the fade
if(fade != 0.0f) {
glLoadIdentity();
BIND_TEXTURE(0);
glColor4f(0,0,0,fade_amount);
glBegin(GL_TRIANGLE_STRIP);
glVertex3f(4, 3, -2);
glVertex3f(-4, 3, -2);
glVertex3f(4,-3,-2);
glVertex3f(-4,-3,-2);
glEnd();
}
end_fonts();
}
void instr(SgBasicBlock* bb) {
// 1. Add Enter Scope -- This will be removed when RTED ScopeGuard is used
// 2. Insert lock and key variables at the top of stack.
// 3. Create a map for lock and key with each scope
// 4. Insert ExitScope statement if the last statement in the list isn't
// a return stmt. Return stmts are handled in handleReturnStmts
SgScopeStatement* scope = isSgScopeStatement(bb);
// 1. Add Enter Scope
#if 0
SgExpression* overload = buildOverloadFn("EnterScope", NULL, NULL, SgTypeVoid::createType(), scope,
GEFD(bb));
#endif
SgExpression* overload = buildMultArgOverloadFn("EnterScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope,
GEFD(bb));
SgStatement* enter_scope = SB::buildExprStatement(overload);
Util::insertAtTopOfBB(bb, enter_scope);
// 2. Insert lock and key variables
// lock calls "getTopLock"
// key calls "getTopKey"
#if 0
overload = buildOverloadFn("getTopLock", NULL, NULL, getLockType(), scope,
GEFD(bb));
#endif
overload = buildMultArgOverloadFn("getTopLock", SB::buildExprListExp(), getLockType(), scope,
GEFD(bb));
// **** IMPORTANT: Using same counter value for lock and key
SgName lock_name("lock_var" + boost::lexical_cast<std::string>(Util::VarCounter));
//SgVariableDeclaration* lock_var = Util::createLocalVariable(lock_name, getLockType(), overload, scope);
// Insert this lock declaration after the EnterScope
//SI::insertStatementAfter(enter_scope, lock_var); //RMM COMMENTED OUT
// For the key...
#if 0
overload = buildOverloadFn("getTopKey", NULL, NULL, getKeyType(), scope,
GEFD(bb));
#endif
overload = buildMultArgOverloadFn("getTopKey", SB::buildExprListExp(), getKeyType(), scope,
GEFD(bb));
// **** IMPORTANT: Using same counter value for lock and key
SgName key_name("key_var" + boost::lexical_cast<std::string>(Util::VarCounter++));
//SgVariableDeclaration* key_var = Util::createLocalVariable(key_name, getKeyType(), overload, scope);
// Insert this key decl after the lock decl
//SI::insertStatementAfter(lock_var, key_var); //RMM COMMENTED OUT
// Add to scope -> lock and key map
//LockKeyPair lock_key = std::make_pair(lock_var, key_var);
//SLKM[scope] = lock_key;
//ROSE_ASSERT(existsInSLKM(scope));
// 4. Insert ExitScope if last stmt is not return.
SgStatementPtrList& stmts = bb->get_statements();
SgStatementPtrList::iterator it = stmts.begin();
it += (stmts.size() - 1);
if(!isSgReturnStmt(*it)) {
// Last statement is not return. So, add exit scope...
// If its a break/continue statement, insert statement before,
// otherwise, add exit_scope afterwards.
//SgExpression* overload = buildOverloadFn("ExitScope", NULL, NULL, SgTypeVoid::createType(), scope, GEFD(bb));
SgExpression* overload = buildMultArgOverloadFn("ExitScope", SB::buildExprListExp(), SgTypeVoid::createType(), scope, GEFD(bb));
// check if its break/continue
if(isSgBreakStmt(*it) || isSgContinueStmt(*it)) {
SI::insertStatementBefore(*it, SB::buildExprStatement(overload));
}
else {
SI::insertStatementAfter(*it, SB::buildExprStatement(overload));
}
}
return;
}
static int CALLBACK HotKeyControlProc(HWND hwnd, UINT msg,
WPARAM wParam, LPARAM lParam)
{
LONG hotkey;
static LONG oldhotkey = 0;
static unsigned int firstmessage = FALSE;
switch (msg) {
case WM_GETDLGCODE:
return DLGC_WANTALLKEYS;
case WM_CHAR:
case WM_DEADCHAR:
case WM_SYSDEADCHAR:
case WM_SYSCHAR:
return FALSE;
case WM_KEYDOWN:
case WM_SYSKEYDOWN:
{
UINT modifiers, vkey;
char buf[BUFSIZE];
firstmessage = TRUE;
modifiers = 0;
vkey = wParam;
if (GetAsyncKeyState(VK_SHIFT))
modifiers |= MOD_SHIFT;
if (GetAsyncKeyState(VK_CONTROL))
modifiers |= MOD_CONTROL;
if (GetAsyncKeyState(VK_MENU))
modifiers |= MOD_ALT;
if (GetAsyncKeyState(VK_LWIN) || GetAsyncKeyState(VK_RWIN))
modifiers |= MOD_WIN;
if (!modifiers ||
(((modifiers == MOD_CONTROL) ||
(modifiers == MOD_ALT) ||
(modifiers == MOD_SHIFT)) &&
(vkey >= 0x30 && vkey <= 0x5a)))
return TRUE;
oldhotkey = GetWindowLong(hwnd, GWL_USERDATA);
key_name(modifiers, vkey, buf, BUFSIZE);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) buf);
return FALSE;
};
case WM_KEYUP:
case WM_SYSKEYUP:
{
UINT modifiers, vkey;
char buf[BUFSIZE];
unsigned int modf = 0;
if (!firstmessage)
return FALSE;
else
firstmessage = FALSE;
modifiers = 0;
vkey = wParam;
switch (vkey) {
case VK_BACK:
case VK_CLEAR:
hotkey = 0;
SetWindowLong(hwnd, GWL_USERDATA, hotkey);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) TRUE, 0);
SendMessage(GetParent(hwnd), WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hwnd), HK_CHANGE),
(LPARAM) hwnd);
return FALSE;
case VK_TAB:
hotkey = GetWindowLong(hwnd, GWL_USERDATA);
if (hotkey) {
modifiers = LOWORD(hotkey);
vkey = HIWORD(hotkey);
key_name(modifiers, vkey, buf, BUFSIZE);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) buf);
} else
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) TRUE, 0);
SetFocus(GetNextDlgTabItem(GetParent(hwnd),
hwnd,
GetAsyncKeyState(VK_SHIFT)));
return FALSE;
case VK_RETURN:
PostMessage(GetParent(hwnd), WM_COMMAND, (WPARAM) IDOK, 0);
return FALSE;
case VK_ESCAPE:
hotkey = GetWindowLong(hwnd, GWL_USERDATA);
if (hotkey) {
modifiers = LOWORD(hotkey);
vkey = HIWORD(hotkey);
key_name(modifiers, vkey, buf, BUFSIZE);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) buf);
} else
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) TRUE, 0);
PostMessage(GetParent(hwnd), WM_COMMAND, (WPARAM) IDCANCEL,
0);
return FALSE;
};
if (GetAsyncKeyState(VK_SHIFT)) {
modifiers |= MOD_SHIFT;
modf++;
};
if (GetAsyncKeyState(VK_CONTROL)) {
modifiers |= MOD_CONTROL;
modf++;
};
if (GetAsyncKeyState(VK_MENU)) {
modifiers |= MOD_ALT;
modf++;
};
if (GetAsyncKeyState(VK_LWIN) || GetAsyncKeyState(VK_RWIN)) {
modifiers |= MOD_WIN;
modf++;
};
if (!modifiers ||
((modf < 2) && !(modifiers & MOD_WIN)) ||
!((vkey >= 0x30 && vkey <= 0x5a) ||
(vkey >= VK_F1 && vkey <= VK_F24))) {
SetWindowLong(hwnd, GWL_USERDATA, oldhotkey);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) HOTKEY_NONE);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) FALSE, 0);
return TRUE;
};
if (RegisterHotKey(hwnd, 0, modifiers, vkey)) {
hotkey = MAKELPARAM(modifiers, vkey);
SetWindowLong(hwnd, GWL_USERDATA, hotkey);
key_name(modifiers, vkey, buf, BUFSIZE);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) buf);
UnregisterHotKey(hwnd, 0);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) TRUE, 0);
SendMessage(GetParent(hwnd),
WM_COMMAND,
MAKEWPARAM(GetDlgCtrlID(hwnd), HK_CHANGE),
(LPARAM) hwnd);
} else {
SetWindowLong(hwnd, GWL_USERDATA, oldhotkey);
SendMessage(hwnd, WM_SETTEXT, 0, (LPARAM) HOTKEY_INVALID);
SendMessage(hwnd, EM_SETMODIFY, (WPARAM) TRUE, 0);
};
return FALSE;
};
};
return CallWindowProc(oldwindowproc, hwnd, msg, wParam, lParam);
};
