/* Test al_ustr_append_chr. */
static void t20(void)
{
ALLEGRO_USTR *us = al_ustr_new("");
CHECK(al_ustr_append_chr(us, 'a') == 1);
CHECK(al_ustr_append_chr(us, U_ae) == 2);
CHECK(al_ustr_append_chr(us, U_euro) == 3);
CHECK(0 == strcmp(al_cstr(us), "aæ€"));
/* Invalid code points. */
CHECK(al_ustr_append_chr(us, -1) == 0);
CHECK(al_ustr_append_chr(us, 0x110000) == 0);
al_ustr_free(us);
}
static ALLEGRO_USTR *create_filter_string(const ALLEGRO_USTR *patterns)
{
ALLEGRO_USTR *filter = al_ustr_new("");
bool filter_all = false;
int start, end;
if (0 == strcmp(al_cstr(patterns), "*.*")) {
filter_all = true;
}
else {
al_ustr_append_cstr(filter, "All Supported Files");
al_ustr_append_chr(filter, '\0');
start = al_ustr_size(filter);
al_ustr_append(filter, patterns);
/* Remove all instances of "*.*", which will be added separately. */
for (;;) {
int pos = al_ustr_find_cstr(filter, start, "*.*;");
if (pos == -1)
break;
if (pos == start || al_ustr_get(filter, pos - 1) == ';') {
filter_all = true;
al_ustr_remove_range(filter, pos, pos + 4);
start = pos;
}
else {
start = pos + 4;
}
}
while (al_ustr_has_suffix_cstr(filter, ";*.*")) {
filter_all = true;
end = al_ustr_size(filter);
al_ustr_remove_range(filter, end - 4, end);
}
al_ustr_append_chr(filter, '\0');
}
if (filter_all) {
al_ustr_append_cstr(filter, "All Files");
al_ustr_append_chr(filter, '\0');
al_ustr_append_cstr(filter, "*.*");
al_ustr_append_chr(filter, '\0');
}
al_ustr_append_chr(filter, '\0');
return filter;
}
static void ensure_trailing_slash(ALLEGRO_USTR *us)
{
int pos = al_ustr_size(us);
if (al_ustr_prev_get(us, &pos) != '/') {
al_ustr_append_chr(us, '/');
}
}
static void path_to_ustr(const ALLEGRO_PATH *path, int32_t delim,
ALLEGRO_USTR *str)
{
unsigned i;
al_ustr_assign(str, path->drive);
for (i = 0; i < _al_vector_size(&path->segments); i++) {
al_ustr_append(str, get_segment(path, i));
al_ustr_append_chr(str, delim);
}
al_ustr_append(str, path->filename);
}
bool InputField::Input(ALLEGRO_EVENT &ev, float &scalex, float &scaley)
{
int unichar = 0;
detectingbutton->Input(ev, scalex, scaley);
if(detectingbutton->is_button_clicked() == true && detectingbutton->is_mouse_in_it() == false &&
ev.type == ALLEGRO_EVENT_MOUSE_BUTTON_DOWN && ev.mouse.button == 1)
{
detectingbutton->unclick();
}
else if(detectingbutton->is_button_clicked() == true)
{
if(ev.type == ALLEGRO_EVENT_KEY_CHAR && (ev.keyboard.keycode == ALLEGRO_KEY_BACKSPACE || ev.keyboard.keycode == ALLEGRO_KEY_ENTER))
{
switch(ev.keyboard.keycode)
{
case ALLEGRO_KEY_BACKSPACE :
if(al_ustr_length(al_text) > 0)
{
al_ustr_remove_chr(al_text, al_ustr_length(al_text)-1);
}
break;
case ALLEGRO_KEY_ENTER :
detectingbutton->unclick();
break;
}
}
else if(ev.type == ALLEGRO_EVENT_KEY_CHAR)
{
if(lenght_limit == true && (int)text.size() >= max_lenght)
{
return true;
}
unichar = ev.keyboard.unichar;
if(unichar >= 32)
{
al_ustr_append_chr(al_text, unichar);
}
}
}
text = al_cstr_dup(al_text);
text_width = al_get_text_width(font, text.c_str()) + 7;
return true;
}
/* Event callbacks
* */
void allua_keyboard_event_callback(lua_State * L, ALLEGRO_EVENT * event)
{
Set_literal("keycode", event->keyboard.keycode, -3);
allua_pushdisplay(L, event->keyboard.display);
lua_setfield(L, -2, "display");
if (event->type == ALLEGRO_EVENT_KEY_CHAR) {
const char *cstr;
ALLEGRO_USTR *us = al_ustr_new("");
al_ustr_append_chr(us, event->keyboard.unichar);
cstr = al_cstr(us);
lua_pushstring(L, cstr);
lua_setfield(L, -2, "string");
Set_literal("unichar", event->keyboard.unichar, -3);
Set_literal("modifiers", event->keyboard.modifiers, -3);
lua_pushboolean(L, event->keyboard.repeat);
lua_setfield(L, -2, "repeated");
}
}
void TextEdit::EventOccured( Event* e )
{
UString keyname;
Control::EventOccured( e );
if( e->Type == EVENT_FORM_INTERACTION )
{
if( e->Data.Forms.RaisedBy == this )
{
if( e->Data.Forms.EventFlag == FormEventType::GotFocus || e->Data.Forms.EventFlag == FormEventType::MouseClick || e->Data.Forms.EventFlag == FormEventType::KeyDown )
{
editting = true;
//e->Handled = true;
}
if( e->Data.Forms.EventFlag == FormEventType::LostFocus )
{
editting = false;
RaiseEvent( FormEventType::TextEditFinish );
//e->Handled = true;
}
} else if( e->Data.Forms.EventFlag == FormEventType::MouseClick ) {
editting = false;
RaiseEvent( FormEventType::TextEditFinish );
}
if( e->Data.Forms.EventFlag == FormEventType::KeyPress && editting )
{
switch( e->Data.Forms.KeyInfo.KeyCode )
{
case ALLEGRO_KEY_BACKSPACE:
if( SelectionStart > 0 )
{
text.remove(SelectionStart, 1);
SelectionStart--;
RaiseEvent( FormEventType::TextChanged );
}
e->Handled = true;
break;
case ALLEGRO_KEY_DELETE:
if( SelectionStart < text.length() )
{
text.remove(SelectionStart+1, 1);
RaiseEvent( FormEventType::TextChanged );
}
e->Handled = true;
break;
case ALLEGRO_KEY_LEFT:
if( SelectionStart > 0 )
{
SelectionStart--;
}
e->Handled = true;
break;
case ALLEGRO_KEY_RIGHT:
if( SelectionStart < text.length() )
{
SelectionStart++;
}
e->Handled = true;
break;
case ALLEGRO_KEY_LSHIFT:
case ALLEGRO_KEY_RSHIFT:
editShift = true;
break;
case ALLEGRO_KEY_ALTGR:
editAltGr = true;
break;
case ALLEGRO_KEY_HOME:
SelectionStart = 0;
e->Handled = true;
break;
case ALLEGRO_KEY_END:
SelectionStart = text.length();
e->Handled = true;
break;
case ALLEGRO_KEY_ENTER:
editting = false;
RaiseEvent( FormEventType::TextEditFinish );
break;
default:
ALLEGRO_USTR* convert = al_ustr_new("");
al_ustr_append_chr( convert, e->Data.Forms.KeyInfo.UniChar );
if( convert->slen == 1 && al_cstr(convert)[0] != 0 )
{
text.insert( SelectionStart, al_cstr(convert) );
SelectionStart++;
RaiseEvent( FormEventType::TextChanged );
}
}
}
if( e->Data.Forms.EventFlag == FormEventType::KeyUp && editting )
{
switch( e->Data.Forms.KeyInfo.KeyCode )
{
case ALLEGRO_KEY_LSHIFT:
case ALLEGRO_KEY_RSHIFT:
editShift = false;
e->Handled = true;
break;
case ALLEGRO_KEY_ALTGR:
editAltGr = false;
e->Handled = true;
break;
}
}
}
}
int main(int argc, char **argv)
{
InitAllegro();
ALLEGRO_KEYBOARD_STATE klawiatura;
ALLEGRO_MOUSE_STATE mysz;
ALLEGRO_EVENT_QUEUE* event_queue = al_create_event_queue();
ALLEGRO_EVENT_QUEUE* key_queue = al_create_event_queue();
ALLEGRO_DISPLAY* okno = al_create_display(WINDOW_WIDTH, WINDOW_HEIGHT);
ALLEGRO_FONT* defaultFont = al_create_builtin_font();
ALLEGRO_TIMER* timer = al_create_timer(1.0 / 60.0);
al_register_event_source(key_queue, al_get_display_event_source(okno));
al_register_event_source(event_queue, al_get_display_event_source(okno));
al_register_event_source(key_queue, al_get_keyboard_event_source());
al_register_event_source(event_queue, al_get_timer_event_source(timer));
al_set_window_title(okno, "Fraktale");
al_set_target_bitmap(al_get_backbuffer(okno));
Menu* menu = new Menu(WINDOW_WIDTH, WINDOW_HEIGHT);
Mandelbrot* mandelbrot = new Mandelbrot(WINDOW_WIDTH, WINDOW_HEIGHT, defaultFont);
Julia* julia = new Julia(WINDOW_WIDTH, WINDOW_HEIGHT, defaultFont);
Window* window = new Window(menu, mandelbrot, julia);
menu->SetWindow(window);
mandelbrot->SetWindow(window);
julia->SetWindow(window);
const ALLEGRO_COLOR backgroundColor = al_map_rgb(255, 255, 255);
const ALLEGRO_COLOR frameColor = al_map_rgb(255, 255, 255);
const int frameThickness = 2;
ALLEGRO_USTR* str = al_ustr_new("");
int pos = (int)al_ustr_size(str);
ALLEGRO_EVENT ev;
double blokadaKlikniecia = al_get_time();
int poczX = -1, poczY = -1, poprzedniStan = window->stanOkna;
bool petla = true, klikniecieMyszy = false, klawiszWcisniety = false, wpisywanieIteracji = false;
double screenRatio = static_cast<double>(WINDOW_HEIGHT) / static_cast<double>(WINDOW_WIDTH);
while (petla)
{
if (poprzedniStan != window->stanOkna)
{
blokadaKlikniecia = al_get_time();
}
poprzedniStan = window->stanOkna;
al_get_next_event(event_queue, &ev);
al_get_mouse_state(&mysz);
int mx = mysz.x;
int my = mysz.y;
bool koniecKlikniecia = false;
if (mysz.buttons & 1 && klikniecieMyszy == false && al_get_time() > blokadaKlikniecia + 0.3)
{
klikniecieMyszy = true;
if (window->CzyFraktal())
{
poczX = mx;
poczY = my;
}
}
else if (!(mysz.buttons & 1) && klikniecieMyszy == true && al_get_time() > blokadaKlikniecia + 0.3)
{
klikniecieMyszy = false;
int pp = window->stanOkna;
int respond = window->Click(mx, my);
if (respond == Responds_t::RESPOND_CLOSE_WINDOW)
petla = false;
if (window->CzyFraktal() && (pp == WINDOWSTATE_MANDELBROT || pp == WINDOWSTATE_JULIA))
{
koniecKlikniecia = true;
}
if (pp == WINDOWSTATE_MENU && window->CzyFraktal())
{
window->ZaladujFraktal();
}
}
if (koniecKlikniecia)
{
if (window->CzyFraktal())
{
Fraktal* fraktal = window->AktualnyFraktal();
fraktal->Powieksz(poczX, mx, poczY, SkalujY(poczY, screenRatio, poczX, mx));
}
poczX = -1, poczY = -1;
}
al_get_next_event(key_queue, &ev);
if (ev.type == ALLEGRO_EVENT_KEY_DOWN && klawiszWcisniety == false && window->CzyFraktal())
{
int kod = ev.keyboard.keycode;
klawiszWcisniety = true;
if (kod == 9)
{
wpisywanieIteracji = true;
}
else if (kod == 10)
{
Fraktal* fraktal = window->AktualnyFraktal();
fraktal->Resetuj();
}
else if (kod >= 27 && kod <= 36 && wpisywanieIteracji)
{
pos += al_ustr_append_chr(str, kod + 21);
}
else if (kod == ALLEGRO_KEY_ENTER)
{
if (wpisywanieIteracji == true)
wpisywanieIteracji = false;
unsigned char* tmp = str->data;
int t = atoi((const char*)tmp);
window->SetIteracje(t);
}
else if (kod == ALLEGRO_KEY_BACKSPACE)
{
if (al_ustr_prev(str, &pos))
al_ustr_truncate(str, pos);
}
else if (kod == ALLEGRO_KEY_ESCAPE)
{
window->stanOkna = WINDOWSTATE_MENU;
}
}
else if (ev.type == ALLEGRO_EVENT_KEY_UP)
{
klawiszWcisniety = false;
}
al_clear_to_color(backgroundColor);
if (wpisywanieIteracji)
window->Draw(str);
else
window->Draw(NULL);
if(poczX != -1)
al_draw_rectangle(poczX, poczY, mx, SkalujY(poczY, screenRatio, poczX, mx), frameColor, frameThickness);
al_flip_display();
}
al_destroy_display(okno);
return 0;
}
//down arrow up arrow per vector items....enter to submit or esc to leave menu/submenu so (menutype - 1)...title = 0, options = 1 dunno yet
STATES Menu::KeyPress(ALLEGRO_EVENT *ev)
{
BOOL doneflag = false;
STATES val = STATES::NONE;
if (ev->type == ALLEGRO_EVENT_KEY_DOWN)
{
switch (ev->keyboard.keycode)
{
case ALLEGRO_KEY_UP://choose later....
currentSelection_--;
while (doneflag == false)//helps to loop and to not select untarGetable items
{
if (currentSelection_ < 0)
{
currentSelection_ = GetMenuItems().size() - 1;
}
//////////////////////Check this maybe refucktor the while and if
//Matt-TODO:
if (GetMenuItems()[currentSelection_]->GetMenuItemTargetable() == true)
{
doneflag = true;
}
while (GetMenuItems()[currentSelection_]->GetMenuItemTargetable() == false)
{
currentSelection_--;
if (currentSelection_ < 0)
{
currentSelection_ = GetMenuItems().size() - 1;
}
}
}
break;
case ALLEGRO_KEY_DOWN://choose later....
currentSelection_++;
while (doneflag == false)//helps to loop and to not select untarGetable items
{
if (currentSelection_ >= GetMenuItems().size())
{
currentSelection_ = 0;
}
if (GetMenuItems()[currentSelection_]->GetMenuItemTargetable() == true)
{
doneflag = true;
}
while (GetMenuItems()[currentSelection_]->GetMenuItemTargetable() == false)
{
currentSelection_++;
if (currentSelection_ >= GetMenuItems().size())
{
currentSelection_ = 0;
}
}
}
break;
case ALLEGRO_KEY_ENTER://choose later....
val = GetMenuItems()[currentSelection_]->GetId();
break;
default:
break;
}
}
else if (ev->type == ALLEGRO_EVENT_KEY_CHAR)
{
if (GetMenuItems()[currentSelection_]->GetMenuItemProperty() != nullptr && ev->keyboard.unichar > 0)
{
ALLEGRO_USTR *test = al_ustr_new("");
al_ustr_append_chr(test, ev->keyboard.unichar);
GetMenuItems()[currentSelection_]->SetMenuItemProperty(test);
al_ustr_free(test);
}
}
if (ev->type == ALLEGRO_EVENT_KEY_UP)
{
switch (ev->keyboard.keycode)
{
case ALLEGRO_KEY_ESCAPE:
//quit
val = STATES::RETURN;
break;
}
}
return val;
}
