void UndoBuffer::redo()
{
if (locked)
return;
if (history_position >= history.size())
{
set_status("Nothing to redo");
return;
}
StatusDelay delay("Redoing " + redo_action());
// Redo next command and restore state
bool have_command = history[history_position].has_command();
process_state(history_position);
if (!have_command)
process_frame(history_position);
process_pos(history_position);
bool ok = process_command(history_position);
if (!ok)
delay.outcome = "failed";
history_position++;
done(&delay);
}
/**
* @brief Login::do_login
* Sets all UI parameters and calls a function to proceed according to the state of the login.
* @param username
* @param password
* @param proxy_hostname
* @param proxy_hostport
* @param proxy_username
* @param proxy_password
* @date
* Created: Filipe, 2 Jan 2014
* Modified: Filipe, 7 Mar 2014
*/
void Login::do_login(const QVariantHash &options)
{
//Password or user change, the process has to be repeted.
if(username != options.value("username").toString() || password != options.value("password").toString())
{
state = persistent;
username = options.value("username").toString();
password = options.value("password").toString();
}
//Set proxy settings.
if(options.value("proxy_hostname", "").toString() != "" || options.value("proxy_hostport", "").toString() != "")
{
network_manager->set_proxy(Helper::proxy_type(options.value("proxy_type").toString()),
options.value("proxy_hostname").toString(),
options.value("proxy_hostport").toInt(),
options.value("proxy_username").toString(),
options.value("proxy_password").toString());
}
else
{
network_manager->set_proxy(QNetworkProxy::NoProxy);
}
output(network_manager->print(), 3);
//Set captcha and steamguard code.
captcha_text = options.value("captcha").toString();
guard_code = options.value("guard_code").toString();
guard_name = options.value("guard_name").toString();
remember_login = options.value("remember_login").toBool();
//Proceed acording to state.
process_state();
}
// Undo and redo commands
void UndoBuffer::undo()
{
if (locked)
return;
if (history_position == 0)
{
set_status("Nothing to undo");
return;
}
StatusDelay delay("Undoing " + undo_action());
// Undo most recent command
bool have_command = history[history_position - 1].has_command();
bool ok = process_command(history_position - 1);
if (ok && history_position > 1)
{
if (!have_command)
process_frame(history_position - 2);
process_pos(history_position - 2);
process_state(history_position - 2);
}
if (!ok)
delay.outcome = "failed";
history_position--;
done(&delay);
}
// the loop routine runs over and over again forever:
void loop() {
//digitalClockDisplay(hour(), minute());
time_2 = millis();
last_st = key_state;
read_state();
st = key_state;
if (st != last_st) {
process_state();
process_display();
time_1 = millis();
} else if (menu_state == Menu0_MainMenu) {
process_display(); // If Menu0, update display event without key_State
}
time = time_2 - time_1;
time = time / 1000;
if (time >= 10) {
turnOffDisplay();
resetKeyState();
//pinMode(LCDBacklight_pin, OUTPUT);
//DisplayLCD_State = false;
} else {
turnOnDisplay();
//pinMode(LCDBacklight_pin, INPUT);
//DisplayLCD_State = true;
}
Alarm.delay(90); // wait one second between clock display
}
/////////////////////////////////////////////////////
//WINHOLDEM RUNTIME ENTRY POINT
/////////////////////////////////////////////////////
OHUSER_API double process_message (const char* pmessage, const void* param) {
if (pmessage==NULL) { return 0; }
if (param==NULL) { return 0; }
if (strcmp(pmessage,"state")==0) {
holdem_state *state = (holdem_state*) param;
if (ClientStarted != true){ initClient(); }
return process_state( (holdem_state*)param );
}
if (strcmp(pmessage,"query")==0) {
// MessageBox(NULL, (LPCSTR) param, "query", MB_OK);
return process_query( (const char*)param );
}
//pfgws is outdated now, use exportable functions like GetSymbolFromDll etc
if (strcmp(pmessage,"pfgws")==0) {
// MessageBox(NULL, "pfgws", "MESSAGE", MB_OK);
m_pget_winholdem_symbol = (pfgws_t)param;
return 0;
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0) {
if (ClientStarted != true){ initClient(); }
// MessageBox(NULL, "event-load", "MESSAGE", MB_OK);
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0) {
// MessageBox(NULL, "event-unload", "MESSAGE", MB_OK);
}
return 0;
}
/* called for each full received packet from the touchpad */
static void read_input(InputInfoPtr local)
{
struct mtev_mtouch *mt = local->private;
while (mtouch_read_synchronized_event(mt, local->fd)) {
process_state(local, mt);
}
}
/////////////////////////////////////////////////////
// user.dll entry point
/////////////////////////////////////////////////////
USERDLL_API double process_message (const char* pmessage, const void* param)
{
if (pmessage==NULL) { return 0; }
if (param==NULL) { return 0; }
if (strcmp(pmessage,"state")==0)
{
holdem_state *state = (holdem_state*) param;
// CString s;
// s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d",
// state->m_title,
// state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4],
// state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9],
// state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4],
// state->m_is_playing, state->m_is_posting, state->m_dealer_chair,
// state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known);
// MessageBox(NULL, s, "state", MB_OK);
return process_state( (holdem_state*)param );
}
if (strcmp(pmessage,"query")==0)
{
// MessageBox(NULL, (LPCSTR) param, "query", MB_OK);
return process_query( (const char*)param );
}
if (strcmp(pmessage,"pfgws")==0)
{
// MessageBox(NULL, "pfgws", "MESSAGE", MB_OK);
p_get_symbol = (p_getsym_t)param;
return 0;
}
if (strcmp(pmessage,"p_send_chat_message")==0)
{
// MessageBox(NULL, "p_send_chat_message", "MESSAGE", MB_OK);
p_send_chat = (p_send_chat_t)param;
return 0;
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0)
{
// MessageBox(NULL, "event-load", "MESSAGE", MB_OK);
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0)
{
// MessageBox(NULL, "event-unload", "MESSAGE", MB_OK);
}
return 0;
}
int preprocess_B(Instruction *out, Emulator *emul)
{
SignExtend_plgtab(&out->imm);
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
return 0;
}
int preprocess_pop_push(Instruction *out, Emulator *emul)
{
if(out->encoding != 3)
preprocess_reglist(out);
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
return 0;
}
bool UndoBuffer::process_state(int entry)
{
assert(OK());
locked = true;
current_entry = entry;
bool ok = process_state(history[entry]);
locked = false;
return ok;
}
/////////////////////////////////////////////////////
// user.dll entry point
/////////////////////////////////////////////////////
USERDLL_API double process_message (const char* pmessage, const void* param)
{
if (pmessage==NULL) { return 0; }
if (param==NULL) { return 0; }
if (strcmp(pmessage,"state")==0)
{
holdem_state *state = (holdem_state*) param;
#ifdef OPT_DEMO_OUTPUT
CString s;
s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d",
state->m_title,
state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4],
state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9],
state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4],
state->m_is_playing, state->m_is_posting, state->m_dealer_chair,
state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known);
MessageBox(NULL, s, "state", MB_OK);
#endif OPT_DEMO_OUTPUT
return process_state( (holdem_state*)param );
}
if (strcmp(pmessage,"query")==0)
{
#ifdef OPT_DEMO_OUTPUT
MessageBox(NULL, (LPCSTR) param, "query", MB_OK);
#endif OPT_DEMO_OUTPUT
return process_query( (const char*)param );
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0)
{
#ifdef OPT_DEMO_OUTPUT
MessageBox(NULL, "event-load", "MESSAGE", MB_OK);
#endif OPT_DEMO_OUTPUT
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0)
{
#ifdef OPT_DEMO_OUTPUT
MessageBox(NULL, "event-unload", "MESSAGE", MB_OK);
#endif OPT_DEMO_OUTPUT
}
return 0;
}
int preprocess_sub_sp(Instruction *out, Emulator *emul)
{
ZeroExtend_plgtab(&out->imm);
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
if(out->encoding == 1)
out->imm.plages->value <<= 2; // décalage de 2 bits, cf spécifications
return 0;
}
int preprocess_ldr(Instruction *out, Emulator *emul)
{
ZeroExtend_plgtab(&out->imm);
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
if(out->encoding == 1 || out->encoding == 2)
out->imm.plages->value <<= 2;
return 0;
}
static void reset_clocks(void)
{
/* 4MHz MSI raw range 2*/
struct rcc_clock_scale myclock_config = {
.hpre = RCC_CFGR_HPRE_SYSCLK_NODIV,
.ppre1 = RCC_CFGR_PPRE1_HCLK_NODIV,
.ppre2 = RCC_CFGR_PPRE2_HCLK_NODIV,
.voltage_scale = PWR_SCALE2,
.flash_waitstates = FLASH_ACR_LATENCY_0WS,
.apb1_frequency = 4194000,
.apb2_frequency = 4194000,
.msi_range = RCC_ICSCR_MSIRANGE_4MHZ,
};
rcc_clock_setup_msi(&myclock_config);
/* buttons and uarts */
rcc_periph_clock_enable(RCC_GPIOA);
/* user feedback leds */
rcc_periph_clock_enable(RCC_GPIOB);
/* Enable clocks for USART2. */
rcc_periph_clock_enable(RCC_USART2);
/* And a timers for button presses */
rcc_periph_clock_enable(RCC_TIM7);
}
int main(void)
{
reset_clocks();
gpio_setup();
usart_setup();
setup_buttons();
setup_button_press_timer();
printf("we're awake!\n");
setup_rtc();
setup_rtc_wakeup(1);
while (1) {
PWR_CR |= PWR_CR_LPSDSR;
pwr_set_stop_mode();
__WFI();
reset_clocks();
process_state(&state);
}
return 0;
}
int preprocess_BL(Instruction *out, Emulator *emul)
{
// Ji = not(S xor Ii)
out->imm.plages[1].value = (~ (out->imm.plages[0].value ^ out->imm.plages[1].value) ) & 1;
out->imm.plages[2].value = (~ (out->imm.plages[0].value ^ out->imm.plages[2].value) ) & 1;
SignExtend_plgtab(&out->imm);
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
return 0;
}
void CStateMachine::Clock()
{
t_sm_state old_state;
t_sm_event event;
bool state_entry;
old_state = m_state;
/* Process state change acording to event */
if (!m_queue.empty()) {
event = m_queue.front();
m_queue.pop();
} else {
event = 0;
}
/* State changes can only happen here */
wxMutexLocker lock(m_stateMutex);
m_state = next_state( event );
//#if 0
/* Debug */
++m_clockCounter;
state_entry = ( m_state != old_state ) || ( m_clockCounter == 1 );
if( state_entry )
{
m_clocksInCurrentState = 0;
printf( "%s(%04d): %d -> %d\n",
(const char *)unicode2char(m_name),
m_clockCounter, old_state, m_state);
}
++m_clocksInCurrentState;
//#endif
/* Process new state entry */
if( m_state < m_maxStates )
{
/* It should be ok to call Clock() recursively inside this
* procedure because state change has already happened. Also
* the m_state mutex is recursive. */
process_state(m_state, state_entry);
}
}
/////////////////////////////////////////////////////
//WINHOLDEM RUNTIME ENTRY POINT
/////////////////////////////////////////////////////
WHUSER_API double process_message(const char* pmessage, const void* param)
{
/*
*
*/
if(pmessage==NULL)
{
gLog.WriteLog(eSeverityError, eCatOHMessages, "pmessage==NULL.. \n");
return 0;
}
if(param==NULL)
{
gLog.WriteLog(eSeverityError, eCatOHMessages, "param==NULL.. \n");
return 0;
}
gLog.WriteLogNoHeading(eSeverityInfo, eCatGeneral, "PROCESS Message.. %s, Param: %s\n", pmessage, (const char*)param);
if(strcmp(pmessage,"state")==0)
{
gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS STATE..\n\tParam: %s\n", (const char*)param);
double ret = process_state( (holdem_state*)param );
gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS STATE FINISHED.. %.2f\n", ret);
return ret;
}
if(strcmp(pmessage,"query")==0)
{
gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "RUN QUERY..\nParam: %s\n", (const char*)param);
double ret = process_query((const char*)param);
gLog.WriteLogNoHeading(eSeverityInfo, eCatOHMessages, "PROCESS QUERY FINISHED.. %.2f\n", ret);
return ret;
}
if(strcmp(pmessage,"pfgws")==0)
{
gVars.m_pget_winholdem_symbol = (pfgws_t)param;
return 0;
}
return 0;
}
// Restore current program state
void UndoBuffer::restore_current_state()
{
if (locked)
return;
assert(OK());
if (!showing_earlier_state())
return;
StatusDelay delay("Restoring state");
clear_after_position();
if (history.size() > 0)
process_state(history.size() - 1);
history_position = history.size();
done(&delay);
}
bool gui_theme::load_ui_object(const string& type, const string& obj_filename) {
xml::xml_doc ui_object_doc = x->process_file(oclraster::data_path(obj_filename), false); // TODO: DTD!
if(!ui_object_doc.valid) {
oclr_error("couldn't process ui object file %s!", obj_filename);
return false;
}
const size_t obj_version = ui_object_doc.get<size_t>("a2e_ui_object.version");
if(obj_version != A2E_UI_OBJECT_VERSION) {
oclr_error("invalid ui object version: %u (should be %u)!",
obj_version, A2E_UI_OBJECT_VERSION);
return false;
}
//
const xml::xml_node* obj_node = ui_object_doc.get_node("a2e_ui_object");
if(obj_node == nullptr || obj_node->children.empty()) {
oclr_error("ui object \"%s\" is empty!", obj_filename);
return false;
}
// process nodes
gui_ui_object* obj { new gui_ui_object(type) };
for(const auto& node : obj_node->children) {
if(node.first == "state" && (*node.second)["type"] != "INVALID") {
gui_ui_object::state* st = new gui_ui_object::state();
process_state(st, node.second);
obj->states.insert(make_pair((*node.second)["type"], unique_ptr<gui_ui_object::state>(st)));
}
else if(node.first[0] != '#') {
oclr_error("unknown node \"%s\" in ui object \"%s\"!", node.first, obj_filename);
}
}
ui_objects.insert(make_pair(type, unique_ptr<gui_ui_object>(obj)));
return true;
}
int preprocess_add_reg_16(Instruction *out, Emulator *emul)
{
Plgtab rdntab;
plgtabdup(&rdntab, &out->reg);
rdntab.size = 2; // il ne doit pas prendre en compte la dernière case
ZeroExtend_plgtab(&rdntab); // met la taille à 1 et concatène les valeurs binaires
rdntab.plages = realloc(rdntab.plages, 2 * sizeof(Plage));
if(rdntab.plages == NULL)
return 2;
rdntab.size = 2;
rdntab.plages[1] = out->reg.plages[2];
free(out->reg.plages);
out->reg = rdntab;
if(InITBlock(emul->it_state))
{
process_state(&emul->it_state, out->name_in, emul->dic->states_tab);
out->it_flag = IN;
}
return 0;
}
int main(int argc, char *argv[], char *envp[]) {
process_state();
return 0;
}
/////////////////////////////////////////////////////
// user.dll entry point
/////////////////////////////////////////////////////
USERDLL_API double process_message (const char* pmessage, const void* param)
{
if (pmessage==NULL) { return 0; }
inHandMsgNum++;
isAllInMsg = false;
//ensure files open
if (!dumpOutFile.is_open()) {
//read config
getConfigValue("dumpOutFileName", dumpOutFileName);
getConfigValue("testfilesDir", testfilesDir);
dumpOutFile.open(dumpOutFileName.c_str());
initTestFilenameList();
}
if (strcmp(pmessage,"state")==0)
{
std::cout << "process_message called with state" << std::endl;
holdem_state *state = (holdem_state*) param;
// CString s;
// s.Format("<%s>\nPOTS: %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f %.2f\nCOMMON: %d %d %d %d %d\n%d %d %d\n<%s> %d %.2f %d",
// state->m_title,
// state->m_pot[0], state->m_pot[1], state->m_pot[2], state->m_pot[3], state->m_pot[4],
// state->m_pot[5], state->m_pot[6], state->m_pot[7], state->m_pot[8], state->m_pot[9],
// state->m_cards[0], state->m_cards[1], state->m_cards[2], state->m_cards[3], state->m_cards[4],
// state->m_is_playing, state->m_is_posting, state->m_dealer_chair,
// state->m_player[4].m_name, state->m_player[4].m_name_known, state->m_player[4].m_balance, state->m_player[4].m_balance_known);
// MessageBox(NULL, s, "state", MB_OK);
return process_state( (holdem_state*)param );
}
if (strcmp(pmessage,"query")==0)
{
std::cout << "process_message called with query " << (const char*) param << std::endl;
// MessageBox(NULL, (LPCSTR) param, "query", MB_OK);
return process_query( (const char*)param );
}
if (strcmp(pmessage,"pfgws")==0)
{
// MessageBox(NULL, "pfgws", "MESSAGE", MB_OK);
p_get_symbol = (p_getsym_t)param;
return 0;
}
if (strcmp(pmessage,"p_send_chat_message")==0)
{
// MessageBox(NULL, "p_send_chat_message", "MESSAGE", MB_OK);
p_send_chat = (p_send_chat_t)param;
return 0;
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "load")==0)
{
// MessageBox(NULL, "event-load", "MESSAGE", MB_OK);
}
if (strcmp(pmessage,"event")==0 && strcmp((const char *) param, "unload")==0)
{
// MessageBox(NULL, "event-unload", "MESSAGE", MB_OK);
}
return 0;
}
