void menu_select_patches()
{
#if MAX_CAKES > MAX_SELECTED_OPTIONS
#error "This function needs MAX_CAKES to be <= MAX_SELECTED_OPTIONS"
#endif
if (cake_count <= 0) {
draw_message("No cakes loaded", "No cakes have been loaded.\nPlease copy them to: " PATH_PATCHES);
return;
}
char *options[cake_count];
for (unsigned int i = 0; i < cake_count; i++) {
options[i] = cake_list[i].description;
}
int *result = draw_selection_menu("Select your cakes", cake_count, options, cake_selected);
patches_modified |= memcmp(cake_selected, result, sizeof(cake_selected));
// The result location will be reused for other selection menus, so we memcpy it.
memcpy(cake_selected, result, cake_count * sizeof(int));
}
/* draws the entire view */
void draw_view()
{
int SCREEN_W = al_get_display_width();
int SCREEN_H = al_get_display_height();
int (*project)(float *f, int *i, int c);
int r, g, b;
ALLEGRO_COLOR c;
int i, n, x, y;
float point[6];
int ipoint[6];
al_clear_to_color(makecol(0, 0, 0));
al_set_blender(ALLEGRO_ADD, ALLEGRO_ONE, ALLEGRO_ONE, al_map_rgba_f(1, 1, 1, 1));
for (i=0; i<4; i++) {
view_left = viewinfo[i].pos[0] * SCREEN_W;
view_top = viewinfo[i].pos[1] * SCREEN_H;
view_right = viewinfo[i].pos[2] * SCREEN_W;
view_bottom = viewinfo[i].pos[3] * SCREEN_H;
if ((view_right > view_left) && (view_bottom > view_top) &&
(view_right > 0) && (view_bottom > 0) &&
(view_left < SCREEN_W) && (view_top < SCREEN_H)) {
switch (i) {
case 0:
/* flat projection, green */
project = project_flat;
r = 0;
g = 255;
b = 0;
break;
case 1:
/* spherical coordinates, yellow */
project = project_spherical;
r = 255;
g = 255;
b = 0;
break;
case 2:
/* inside a tube, blue */
project = project_tube;
r = 0;
g = 0;
b = 255;
break;
case 3:
/* surface of cylinder, red */
project = project_cylinder;
r = 255;
g = 0;
b = 0;
break;
default:
/* oops! */
assert(FALSE);
return;
}
if (!no_grid) {
c = makecol(r/5, g/5, b/5);
n = (low_detail) ? 8 : 16;
for (x=0; x<=n; x++) {
for (y=0; y<=n; y++) {
point[0] = (float)x / n;
point[1] = (float)y / n;
point[2] = (float)(x+1) / n;
point[3] = (float)y / n;
point[4] = (float)x / n;
point[5] = (float)(y+1) / n;
if (project(point, ipoint, 6)) {
if (x < n)
line(ipoint[0], ipoint[1], ipoint[2], ipoint[3], c);
if ((y < n) && ((x < n) || (i == 0)))
line(ipoint[0], ipoint[1], ipoint[4], ipoint[5], c);
}
}
}
}
draw_player(r, g, b, project);
draw_badguys(r, g, b, project);
draw_bullets(r, g, b, project);
draw_explode(r, g, b, project);
}
}
solid_mode();
draw_message();
textprintf(font, 4, 4, makecol(128, 128, 128), "Lives: %d", lives);
textprintf(font, 4, 16, makecol(128, 128, 128), "Score: %d", score);
textprintf(font, 4, 28, makecol(128, 128, 128), "Hiscore: %d", get_hiscore());
al_flip_display();
}
void display_menu(MENU *m)
{
SDL_Rect b;
int i;
MENU_ITEM *item=m->item;
b.x=MENUX-2;
b.y=MENUY-2;
b.w=wl*21+3;
b.h=hl*10+3;
draw_border(back,SHADOW_OUT,&b);
b.x=MENUX;
b.y=MENUY+hl*2-hl/2;
b.w=wl*21-2;
b.h=hl*8;
draw_border(back,SHADOW_ETCHED_IN,&b);
if (!item) return;
for(i=0;i<m->begin;i++)
item=item->next;
draw_message(MENUX,MENUY,m->title);
for(i=m->begin;i<=m->end;i++) {
if (i==m->id) {
b.x=MENUX+3;
b.y=MENUY+(i-m->begin+2)*hl;
b.w=wl*21-8;
b.h=hl;
SDL_FillRect(back,&b,COL32_TO_16(0xeaeaea));
if (item->draw_info && item->draw_type==DRAW_WHEN_ACTIVE)
item->draw_info(item,i-m->begin+2);
}
if (item->type==TOGGLE) {
b.x=135;
b.y=MENUY+(i-m->begin+2)*hl+2;
SDL_BlitSurface((item->state?toggle_on:toggle_off),NULL,back,&b);
}
if (item->type==RADIO) {
b.x=135;
b.y=MENUY+(i-m->begin+2)*hl+2;
SDL_BlitSurface((item->radio==radio_group[item->group]?radio_on:radio_off),NULL,back,&b);
}
draw_message(MENUX+wl,MENUY+(i-m->begin+2)*hl,item->name);
if (item->draw_info && item->draw_type==DRAW_ALWAYS)
item->draw_info(item,i-m->begin+2);
item=item->next;
}
if (m->end!=m->size-1) {
b.x=75;
b.y=MENUY+(MAX_ITEM+1)*hl+hl/2+24;
b.w=b.h=9;
SDL_BlitSurface(arrow_down,NULL,back,&b);
}
if (m->begin!=0) {
b.x=75;
b.y=22;
SDL_BlitSurface(arrow_up,NULL,back,&b);
}
}
void WDL_CursesEditor::runSearch()
{
if (s_search_string[0])
{
int wrapflag=0,found=0;
int line;
int numlines = m_text.GetSize();
int startx=m_curs_x+1;
const int srchlen=strlen(s_search_string);
for (line = m_curs_y; line < numlines && !found; line ++)
{
WDL_FastString *tl = m_text.Get(line);
const char *p;
if (tl && (p=tl->Get()))
{
const int linelen = tl->GetLength();
for (; startx <= linelen-srchlen; startx++)
if (!strnicmp(p+startx,s_search_string,srchlen))
{
m_select_y1=m_select_y2=m_curs_y=line;
m_select_x1=m_curs_x=startx;
m_select_x2=startx+srchlen;
m_selecting=1;
found=1;
break;
}
}
startx=0;
}
if (!found && (m_curs_y>0 || m_curs_x > 0))
{
wrapflag=1;
numlines = min(m_curs_y+1,numlines);
for (line = 0; line < numlines && !found; line ++)
{
WDL_FastString *tl = m_text.Get(line);
const char *p;
if (tl && (p=tl->Get()))
{
const int linelen = tl->GetLength();
for (; startx <= linelen-srchlen; startx++)
if (!strnicmp(p+startx,s_search_string,srchlen))
{
m_select_y1=m_select_y2=m_curs_y=line;
m_select_x1=m_curs_x=startx;
m_select_x2=startx+srchlen;
m_selecting=1;
found=1;
break;
}
}
startx=0;
}
}
if (found)
{
draw();
setCursor();
char buf[512];
snprintf(buf,sizeof(buf),"Found %s'%s' Ctrl+G:next",wrapflag?"(wrapped) ":"",s_search_string);
draw_message(buf);
return;
}
}
draw();
setCursor();
char buf[512];
if (s_search_string[0]) snprintf(buf,sizeof(buf),"String '%s' not found",s_search_string);
else lstrcpyn_safe(buf,"No search string",sizeof(buf));
draw_message(buf);
}
int WDL_CursesEditor::onChar(int c)
{
if (m_state == -3 || m_state == -4)
{
switch (c)
{
case '\r': case '\n':
m_state=0;
runSearch();
break;
case 27:
m_state=0;
draw();
setCursor();
draw_message("Find cancelled.");
break;
case KEY_BACKSPACE: if (s_search_string[0]) s_search_string[strlen(s_search_string)-1]=0; m_state=-4; break;
default:
if (VALIDATE_TEXT_CHAR(c))
{
int l=m_state == -3 ? 0 : strlen(s_search_string);
m_state = -4;
if (l < (int)sizeof(s_search_string)-1) { s_search_string[l]=c; s_search_string[l+1]=0; }
}
break;
}
if (m_state)
{
attrset(m_color_message);
bkgdset(m_color_message);
mvaddstr(LINES-1,29,s_search_string);
clrtoeol();
attrset(0);
bkgdset(0);
}
return 0;
}
if (c==KEY_DOWN || c==KEY_UP || c==KEY_PPAGE||c==KEY_NPAGE || c==KEY_RIGHT||c==KEY_LEFT||c==KEY_HOME||c==KEY_END)
{
if (SHIFT_KEY_DOWN)
{
if (!m_selecting)
{
m_select_x2=m_select_x1=m_curs_x; m_select_y2=m_select_y1=m_curs_y;
m_selecting=1;
}
}
else if (m_selecting) { m_selecting=0; draw(); }
}
switch(c)
{
case 'O'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
if (m_pane_div <= 0.0 || m_pane_div >= 1.0)
{
onChar('P'-'A'+1);
}
if (m_pane_div > 0.0 && m_pane_div < 1.0)
{
m_curpane=!m_curpane;
draw();
draw_status_state();
int paney[2], paneh[2];
GetPaneDims(paney, paneh);
if (m_curs_y-m_paneoffs_y[m_curpane] < 0) m_curs_y=m_paneoffs_y[m_curpane];
else if (m_curs_y-m_paneoffs_y[m_curpane] >= paneh[m_curpane]) m_curs_y=paneh[m_curpane]+m_paneoffs_y[m_curpane]-1;
setCursor();
}
}
break;
case 'P'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
if (m_pane_div <= 0.0 || m_pane_div >= 1.0)
{
m_pane_div=0.5;
m_paneoffs_y[1]=m_paneoffs_y[0];
}
else
{
m_pane_div=1.0;
if (m_curpane) m_paneoffs_y[0]=m_paneoffs_y[1];
m_curpane=0;
}
draw();
draw_status_state();
int paney[2], paneh[2];
const int pane_divy=GetPaneDims(paney, paneh);
setCursor();
}
break;
case 407:
case 'Z'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
if (m_undoStack_pos > 0)
{
m_undoStack_pos--;
loadUndoState(m_undoStack.Get(m_undoStack_pos));
draw();
setCursor();
char buf[512];
snprintf(buf,sizeof(buf),"Undid action - %d items in undo buffer",m_undoStack_pos);
draw_message(buf);
}
else
{
draw_message("Can't Undo");
}
break;
}
// fall through
case 'Y'-'A'+1:
if ((c == 'Z'-'A'+1 || !SHIFT_KEY_DOWN) && !ALT_KEY_DOWN)
{
if (m_undoStack_pos < m_undoStack.GetSize()-1)
{
m_undoStack_pos++;
loadUndoState(m_undoStack.Get(m_undoStack_pos));
draw();
setCursor();
char buf[512];
snprintf(buf,sizeof(buf),"Redid action - %d items in redo buffer",m_undoStack.GetSize()-m_undoStack_pos-1);
draw_message(buf);
}
else
{
draw_message("Can't Redo");
}
}
break;
case KEY_IC:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
s_overwrite=!s_overwrite;
setCursor();
break;
}
// fqll through
case 'V'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
// generate a m_clipboard using win32 clipboard data
WDL_PtrList<const char> lines;
WDL_String buf;
#ifdef WDL_IS_FAKE_CURSES
if (CURSES_INSTANCE)
{
OpenClipboard(CURSES_INSTANCE->m_hwnd);
HANDLE h=GetClipboardData(CF_TEXT);
if (h)
{
char *t=(char *)GlobalLock(h);
int s=GlobalSize(h);
buf.Set(t,s);
GlobalUnlock(t);
}
CloseClipboard();
}
else
#endif
{
buf.Set(s_fake_clipboard.Get());
}
if (buf.Get() && buf.Get()[0])
{
char *src=buf.Get();
while (*src)
{
char *seek=src;
while (*seek && *seek != '\r' && *seek != '\n') seek++;
char hadclr=*seek;
if (*seek) *seek++=0;
lines.Add(src);
if (hadclr == '\r' && *seek == '\n') seek++;
if (hadclr && !*seek)
{
lines.Add("");
}
src=seek;
}
}
if (lines.GetSize())
{
removeSelect();
// insert lines at m_curs_y,m_curs_x
if (m_curs_y >= m_text.GetSize()) m_curs_y=m_text.GetSize()-1;
if (m_curs_y < 0) m_curs_y=0;
preSaveUndoState();
WDL_FastString poststr;
int x;
int indent_to_pos = -1;
for (x = 0; x < lines.GetSize(); x ++)
{
WDL_FastString *str=m_text.Get(m_curs_y);
const char *tstr=lines.Get(x);
if (!tstr) tstr="";
if (!x)
{
if (str)
{
if (m_curs_x < 0) m_curs_x=0;
int tmp=str->GetLength();
if (m_curs_x > tmp) m_curs_x=tmp;
poststr.Set(str->Get()+m_curs_x);
str->SetLen(m_curs_x);
const char *p = str->Get();
while (*p == ' ' || *p == '\t') p++;
if (!*p && p > str->Get())
{
if (lines.GetSize()>1)
{
while (*tstr == ' ' || *tstr == '\t') tstr++;
}
indent_to_pos = m_curs_x;
}
str->Append(tstr);
}
else
{
m_text.Insert(m_curs_y,(str=new WDL_FastString(tstr)));
}
if (lines.GetSize() > 1)
{
m_curs_y++;
}
else
{
m_curs_x = str->GetLength();
str->Append(poststr.Get());
}
}
else if (x == lines.GetSize()-1)
{
WDL_FastString *s=newIndentedFastString(tstr,indent_to_pos);
m_curs_x = s->GetLength();
s->Append(poststr.Get());
m_text.Insert(m_curs_y,s);
}
else
{
m_text.Insert(m_curs_y,newIndentedFastString(tstr,indent_to_pos));
m_curs_y++;
}
}
draw();
setCursor();
draw_message("Pasted");
saveUndoState();
}
else
{
setCursor();
draw_message("Clipboard empty");
}
}
break;
case KEY_DC:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
WDL_FastString *s;
if (m_selecting)
{
preSaveUndoState();
removeSelect();
draw();
saveUndoState();
setCursor();
}
else if ((s=m_text.Get(m_curs_y)))
{
if (m_curs_x < s->GetLength())
{
preSaveUndoState();
bool hadCom = LineCanAffectOtherLines(s->Get(),m_curs_x,1);
s->DeleteSub(m_curs_x,1);
if (!hadCom) hadCom = LineCanAffectOtherLines(s->Get(),-1,-1);
draw(hadCom ? -1 : m_curs_y);
saveUndoState();
setCursor();
}
else // append next line to us
{
if (m_curs_y < m_text.GetSize()-1)
{
preSaveUndoState();
WDL_FastString *nl=m_text.Get(m_curs_y+1);
if (nl)
{
s->Append(nl->Get());
}
m_text.Delete(m_curs_y+1,true);
draw();
saveUndoState();
setCursor();
}
}
}
break;
}
case 'C'-'A'+1:
case 'X'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && m_selecting)
{
if (c!= 'C'-'A'+1) m_selecting=0;
int miny,maxy,minx,maxx;
int x;
getselectregion(minx,miny,maxx,maxy);
const char *status="";
char statusbuf[512];
if (minx != maxx|| miny != maxy)
{
int bytescopied=0;
s_fake_clipboard.Set("");
int lht=0,fht=0;
if (c != 'C'-'A'+1) preSaveUndoState();
for (x = miny; x <= maxy; x ++)
{
WDL_FastString *s=m_text.Get(x);
if (s)
{
const char *str=s->Get();
int sx,ex;
if (x == miny) sx=max(minx,0);
else sx=0;
int tmp=s->GetLength();
if (sx > tmp) sx=tmp;
if (x == maxy) ex=min(maxx,tmp);
else ex=tmp;
bytescopied += ex-sx + (x!=maxy);
if (s_fake_clipboard.Get() && s_fake_clipboard.Get()[0]) s_fake_clipboard.Append("\r\n");
s_fake_clipboard.Append(ex-sx?str+sx:"",ex-sx);
if (c != 'C'-'A'+1)
{
if (sx == 0 && ex == tmp) // remove entire line
{
m_text.Delete(x,true);
if (x==miny) miny--;
x--;
maxy--;
}
else { if (x==miny) fht=1; if (x == maxy) lht=1; s->DeleteSub(sx,ex-sx); }
}
}
}
if (fht && lht && miny+1 == maxy)
{
m_text.Get(miny)->Append(m_text.Get(maxy)->Get());
m_text.Delete(maxy,true);
}
if (c != 'C'-'A'+1)
{
m_curs_y=miny;
if (m_curs_y < 0) m_curs_y=0;
m_curs_x=minx;
saveUndoState();
snprintf(statusbuf,sizeof(statusbuf),"Cut %d bytes",bytescopied);
}
else
snprintf(statusbuf,sizeof(statusbuf),"Copied %d bytes",bytescopied);
#ifdef WDL_IS_FAKE_CURSES
if (CURSES_INSTANCE)
{
int l=s_fake_clipboard.GetLength()+1;
HANDLE h=GlobalAlloc(GMEM_MOVEABLE,l);
void *t=GlobalLock(h);
memcpy(t,s_fake_clipboard.Get(),l);
GlobalUnlock(h);
OpenClipboard(CURSES_INSTANCE->m_hwnd);
EmptyClipboard();
SetClipboardData(CF_TEXT,h);
CloseClipboard();
}
#endif
status=statusbuf;
}
else status="No selection";
draw();
setCursor();
draw_message(status);
}
break;
case 'A'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
m_selecting=1;
m_select_x1=0;
m_select_y1=0;
m_select_y2=m_text.GetSize()-1;
m_select_x2=0;
if (m_text.Get(m_select_y2))
m_select_x2=m_text.Get(m_select_y2)->GetLength();
draw();
setCursor();
}
break;
case 27:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && m_selecting)
{
m_selecting=0;
draw();
setCursor();
break;
}
break;
case KEY_F3:
case 'G'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN && s_search_string[0])
{
runSearch();
return 0;
}
// fall through
case 'F'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
draw_message("");
attrset(m_color_message);
bkgdset(m_color_message);
mvaddstr(LINES-1,0,"Find string (ESC to cancel): ");
if (m_selecting && m_select_y1==m_select_y2)
{
WDL_FastString* s=m_text.Get(m_select_y1);
if (s)
{
const char* p=s->Get();
int xlo=min(m_select_x1, m_select_x2);
int xhi=max(m_select_x1, m_select_x2);
int i;
for (i=xlo; i < xhi; ++i)
{
if (!isalnum(p[i]) && p[i] != '_') break;
}
if (i == xhi && xhi > xlo && xhi-xlo < sizeof(s_search_string))
{
lstrcpyn(s_search_string, p+xlo, xhi-xlo+1);
}
}
}
addstr(s_search_string);
clrtoeol();
attrset(0);
bkgdset(0);
m_state=-3; // find, initial (m_state=4 when we've typed something)
}
break;
case KEY_DOWN:
{
if (CTRL_KEY_DOWN)
{
int paney[2], paneh[2];
GetPaneDims(paney, paneh);
int maxscroll=m_text.GetSize()-paneh[m_curpane]+4;
if (m_paneoffs_y[m_curpane] < maxscroll-1)
{
m_paneoffs_y[m_curpane]++;
if (m_curs_y < m_paneoffs_y[m_curpane]) m_curs_y=m_paneoffs_y[m_curpane];
draw();
}
}
else
{
m_curs_y++;
if (m_curs_y>=m_text.GetSize()) m_curs_y=m_text.GetSize()-1;
if (m_curs_y < 0) m_curs_y=0;
}
if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor(1);
}
break;
case KEY_UP:
{
if (CTRL_KEY_DOWN)
{
if (m_paneoffs_y[m_curpane] > 0)
{
int paney[2], paneh[2];
GetPaneDims(paney, paneh);
m_paneoffs_y[m_curpane]--;
if (m_curs_y > m_paneoffs_y[m_curpane]+paneh[m_curpane]-1) m_curs_y = m_paneoffs_y[m_curpane]+paneh[m_curpane]-1;
if (m_curs_y < 0) m_curs_y=0;
draw();
}
}
else
{
if(m_curs_y>0) m_curs_y--;
}
if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor(1);
}
break;
case KEY_PPAGE:
{
if (m_curs_y > m_paneoffs_y[m_curpane])
{
m_curs_y=m_paneoffs_y[m_curpane];
if (m_curs_y < 0) m_curs_y=0;
}
else
{
int paney[2], paneh[2];
GetPaneDims(paney, paneh);
m_curs_y -= paneh[m_curpane];
if (m_curs_y < 0) m_curs_y=0;
m_paneoffs_y[m_curpane]=m_curs_y;
}
if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; }
draw();
setCursor(1);
}
break;
case KEY_NPAGE:
{
int paney[2], paneh[2];
GetPaneDims(paney, paneh);
if (m_curs_y >= m_paneoffs_y[m_curpane]+paneh[m_curpane]-1) m_paneoffs_y[m_curpane]=m_curs_y-1;
m_curs_y = m_paneoffs_y[m_curpane]+paneh[m_curpane]-1;
if (m_curs_y >= m_text.GetSize()) m_curs_y=m_text.GetSize()-1;
if (m_curs_y < 0) m_curs_y=0;
if (m_selecting) { setCursor(1); m_select_x2=m_curs_x; m_select_y2=m_curs_y; }
draw();
setCursor(1);
}
break;
case KEY_RIGHT:
{
if (1) // wrap across lines
{
WDL_FastString *s = m_text.Get(m_curs_y);
if (s && m_curs_x >= s->GetLength() && m_curs_y < m_text.GetSize()) { m_curs_y++; m_curs_x = -1; }
}
if(m_curs_x<0)
{
m_curs_x=0;
}
else
{
if (CTRL_KEY_DOWN)
{
WDL_FastString *s = m_text.Get(m_curs_y);
if (!s||m_curs_x >= s->GetLength()) break;
int lastType = categorizeCharForWordNess(s->Get()[m_curs_x++]);
while (m_curs_x < s->GetLength())
{
int thisType = categorizeCharForWordNess(s->Get()[m_curs_x]);
if (thisType != lastType && thisType != 0) break;
lastType=thisType;
m_curs_x++;
}
}
else
{
m_curs_x++;
}
}
if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor();
}
break;
case KEY_LEFT:
{
bool doMove=true;
if (1) // wrap across lines
{
WDL_FastString *s = m_text.Get(m_curs_y);
if (s && m_curs_y>0 && m_curs_x == 0)
{
s = m_text.Get(--m_curs_y);
if (s)
{
m_curs_x = s->GetLength();
doMove=false;
}
}
}
if(m_curs_x>0 && doMove)
{
if (CTRL_KEY_DOWN)
{
WDL_FastString *s = m_text.Get(m_curs_y);
if (!s) break;
if (m_curs_x > s->GetLength()) m_curs_x = s->GetLength();
m_curs_x--;
int lastType = categorizeCharForWordNess(s->Get()[m_curs_x--]);
while (m_curs_x >= 0)
{
int thisType = categorizeCharForWordNess(s->Get()[m_curs_x]);
if (thisType != lastType && lastType != 0) break;
lastType=thisType;
m_curs_x--;
}
m_curs_x++;
}
else
{
m_curs_x--;
}
}
if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor();
}
break;
case KEY_HOME:
{
m_curs_x=0;
if (CTRL_KEY_DOWN) m_curs_y=0;
if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor();
}
break;
case KEY_END:
{
if (m_text.Get(m_curs_y)) m_curs_x=m_text.Get(m_curs_y)->GetLength();
if (CTRL_KEY_DOWN) m_curs_y=m_text.GetSize();
if (m_selecting) { setCursor(); m_select_x2=m_curs_x; m_select_y2=m_curs_y; draw(); }
setCursor();
}
break;
case KEY_BACKSPACE: // backspace, baby
if (m_selecting)
{
preSaveUndoState();
removeSelect();
draw();
saveUndoState();
setCursor();
}
else if (m_curs_x > 0)
{
WDL_FastString *tl=m_text.Get(m_curs_y);
if (tl)
{
preSaveUndoState();
bool hadCom = LineCanAffectOtherLines(tl->Get(), m_curs_x-1,1);
tl->DeleteSub(--m_curs_x,1);
if (!hadCom) hadCom = LineCanAffectOtherLines(tl->Get(),-1,-1);
draw(hadCom?-1:m_curs_y);
saveUndoState();
setCursor();
}
}
else // append current line to previous line
{
WDL_FastString *fl=m_text.Get(m_curs_y-1), *tl=m_text.Get(m_curs_y);
if (!tl)
{
m_curs_y--;
if (fl) m_curs_x=fl->GetLength();
draw();
saveUndoState();
setCursor();
}
else if (fl)
{
preSaveUndoState();
m_curs_x=fl->GetLength();
fl->Append(tl->Get());
m_text.Delete(m_curs_y--,true);
draw();
saveUndoState();
setCursor();
}
}
break;
case 'L'-'A'+1:
if (!SHIFT_KEY_DOWN && !ALT_KEY_DOWN)
{
draw();
setCursor();
}
break;
case 13: //KEY_ENTER:
//insert newline
preSaveUndoState();
if (m_selecting) { removeSelect(); draw(); setCursor(); }
if (m_curs_y >= m_text.GetSize())
{
m_curs_y=m_text.GetSize();
m_text.Add(new WDL_FastString);
}
if (s_overwrite)
{
WDL_FastString *s = m_text.Get(m_curs_y);
int plen=0;
const char *pb=NULL;
if (s)
{
pb = s->Get();
while (plen < m_curs_x && (pb[plen]== ' ' || pb[plen] == '\t')) plen++;
}
if (++m_curs_y >= m_text.GetSize())
{
m_curs_y = m_text.GetSize();
WDL_FastString *ns=new WDL_FastString;
if (plen>0) ns->Set(pb,plen);
m_text.Insert(m_curs_y,ns);
}
s = m_text.Get(m_curs_y);
if (s && plen > s->GetLength()) plen=s->GetLength();
m_curs_x=plen;
}
else
{
WDL_FastString *s = m_text.Get(m_curs_y);
if (s)
{
if (m_curs_x > s->GetLength()) m_curs_x = s->GetLength();
WDL_FastString *nl = new WDL_FastString();
int plen=0;
const char *pb = s->Get();
while (plen < m_curs_x && (pb[plen]== ' ' || pb[plen] == '\t')) plen++;
if (plen>0) nl->Set(pb,plen);
nl->Append(pb+m_curs_x);
m_text.Insert(++m_curs_y,nl);
s->SetLen(m_curs_x);
m_curs_x=plen;
}
}
m_offs_x=0;
draw();
saveUndoState();
setCursor();
break;
case '\t':
if (m_selecting)
{
preSaveUndoState();
bool isRev = !!(GetAsyncKeyState(VK_SHIFT)&0x8000);
indentSelect(isRev?-m_indent_size:m_indent_size);
// indent selection:
draw();
setCursor();
saveUndoState();
break;
}
default:
//insert char
if(VALIDATE_TEXT_CHAR(c))
{
preSaveUndoState();
if (m_selecting) { removeSelect(); draw(); setCursor(); }
if (!m_text.Get(m_curs_y)) m_text.Insert(m_curs_y,new WDL_FastString);
WDL_FastString *ss;
if ((ss=m_text.Get(m_curs_y)))
{
char str[64];
int slen ;
if (c == '\t')
{
slen = min(m_indent_size,64);
if (slen<1) slen=1;
int x;
for(x=0;x<slen;x++) str[x]=' ';
}
else
{
str[0]=c;
slen = 1;
}
bool hadCom = LineCanAffectOtherLines(ss->Get(),-1,-1);
if (s_overwrite)
{
if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),m_curs_x,slen);
ss->DeleteSub(m_curs_x,slen);
}
ss->Insert(str,m_curs_x,slen);
if (!hadCom) hadCom = LineCanAffectOtherLines(ss->Get(),m_curs_x,slen);
m_curs_x += slen;
draw(hadCom ? -1 : m_curs_y);
}
saveUndoState();
setCursor();
}
break;
}
return 0;
}
/* ***********************************************************/
void open_tuxchess_window (void)
{
tuxchess_gc = pz_get_gc(1); /* Get the graphics context */
is_mini = (screen_info.cols == 138);
if (is_mini) {
/* Open the window for the board: */
tuxchess_wid = pz_new_window(0, 2,
104,
screen_info.rows,
tuxchess_do_draw,
tuxchess_handle_event);
/* Open the window for the message on the left : */
message_wid = pz_new_window(104, 0,
screen_info.cols,
screen_info.rows,
tuxchess_do_draw,
tuxchess_handle_event);
GrSelectEvents(tuxchess_wid, GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP);
GrSelectEvents(message_wid, GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP);
}
else {
/* Open the window for the board: */
tuxchess_wid = pz_new_window(0, HEADER_TOPLINE + 1,
104,
screen_info.rows - HEADER_TOPLINE - 1,
tuxchess_do_draw,
tuxchess_handle_event);
/* Open the window for the historic : */
historic_wid = pz_new_window(104, HEADER_TOPLINE + 1,
screen_info.cols,
screen_info.rows - HEADER_TOPLINE - 1,
tuxchess_do_draw,
tuxchess_handle_event);
GrSelectEvents(tuxchess_wid, GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP);
GrSelectEvents(historic_wid, GR_EVENT_MASK_KEY_DOWN |
GR_EVENT_MASK_KEY_UP);
}
/* Display the windows : */
if (is_mini) {
GrMapWindow(message_wid);
draw_message("A1-","Play");
}
else {
GrMapWindow(historic_wid);
}
GrMapWindow(tuxchess_wid);
tuxchess_do_draw();
/* Clear the window */
GrClearWindow(tuxchess_wid, GR_FALSE);
gen_moves();
max_time = 100000;//1 << 25;
max_depth = 1;
end = 0;
print_board();
if (!is_mini) {
draw_historic();
}
/* make sure the right window has focus so we get input events */
// GrSetFocus(tuxchess_wid);
}
/* print_result() checks to see if the game is over */
void print_result()
{
int i;
/* is there a legal move? */
for (i = 0; i < first_move[1]; ++i) {
if (makemove(gen_dat[i].m.b)) {
takeback();
break;
}
}
if (i == first_move[1]) {
if (in_check(side)) {
if (side == LIGHT) {
printf("GR_RGB(0,0,0) mates");
if (is_mini) {
draw_message("GR_RGB(0,0,0)","Mates");
}
else {
pz_draw_header("GR_RGB(0,0,0) mates");
}
draw_end('b');
}
else {
printf("GR_RGB(255,255,255) mates");
if (is_mini) {
draw_message("GR_RGB(255,255,255)","Mates");
}
else {
pz_draw_header("GR_RGB(255,255,255) mates");
}
draw_end('w');
}
}
else {
printf("Stalemate");
if (is_mini) {
draw_message("Stale","Mate");
}
else {
pz_draw_header("Stalemate");
}
draw_end('d');
}
}
/*
else if (reps() == 3)
{
printf("Draw by repetition");
if (is_mini == 0)
pz_draw_header("Draw by repetition");
draw_end('d');
}
*/
else if (fifty >= 100) {
printf("Draw by fifty move rule");
if (is_mini == 0) {
pz_draw_header("Draw : fifty moves");
}
draw_end('d');
}
}
/* Open all the available joystick */
for (i=0;i<conf.nb_joy;i++) {
conf.joy[i]=SDL_JoystickOpen(i);
printf("joy \"%s\", axe:%d, button:%d\n",
SDL_JoystickName(i),
SDL_JoystickNumAxes(conf.joy[i])+ (SDL_JoystickNumHats(conf.joy[i]) * 2),
SDL_JoystickNumButtons(conf.joy[i]));
jmap->jbutton[i]=calloc(SDL_JoystickNumButtons(conf.joy[i]),sizeof(struct BUT_MAP));
jmap->jaxe[i]=calloc(SDL_JoystickNumAxes(conf.joy[i]),sizeof(struct BUT_MAPJAXIS));
jmap->jhat[i]=calloc(SDL_JoystickNumHats(conf.joy[i]),sizeof(struct BUT_MAP));
}
}
create_joymap_from_string(1,cf_get_string_by_name("p1control"));
create_joymap_from_string(2,cf_get_string_by_name("p2control"));
return true;
}
#ifdef GP2X
int handle_pdep_event(SDL_Event *event) {
static int snd_volume=75;
char volbuf[21];
int i;
switch (event->type) {
case SDL_JOYBUTTONDOWN:
//printf("Event %d %d\n",event->jbutton.which,event->jbutton.button);
if (event->jbutton.which==0) {
if (event->jbutton.button==GP2X_VOL_UP && conf.sound) {
if (snd_volume<100) snd_volume+=5; else snd_volume=100;
gp2x_sound_volume_set(snd_volume,snd_volume);
for (i=0;i<snd_volume/5;i++) volbuf[i]='|';
for (i=snd_volume/5;i<20;i++) volbuf[i]='-';
volbuf[20]=0;
draw_message(MSGSLOT_SYSTEM,0,-1,volbuf,75);
}
if (event->jbutton.button==GP2X_VOL_DOWN && conf.sound) {
if (snd_volume>0) snd_volume-=5; else snd_volume=0;
gp2x_sound_volume_set(snd_volume,snd_volume);
for (i=0;i<snd_volume/5;i++) volbuf[i]='|';
for (i=snd_volume/5;i<20;i++) volbuf[i]='-';
volbuf[20]=0;
draw_message(MSGSLOT_SYSTEM,0,-1,volbuf,75);
}
}
break;
}
return 0;
}
#elif DEVKIT8000_
int handle_pdep_event(SDL_Event *event) {
switch (event->type) {
case SDL_MOUSEBUTTONDOWN:
case SDL_MOUSEBUTTONUP:
printf("MouseDown %d %d %d\n",event->button.state,event->button.x,event->button.y);
break;
}
}
#else /* Default */
int handle_pdep_event(SDL_Event *event)
{
if (event->type == SDL_KEYDOWN)
{
//Keys that mean something to the emulator
switch (event->key.keysym.sym)
{
case SDLK_ESCAPE:
return EV_MENU;
break;
case SDLK_F1:
return EV_RESET_EMU;
break;
case SDLK_F2:
return EV_SCREENSHOT;
break;
case SDLK_F3:
return EV_TEST_SWITCH;
break;
case SDLK_F4:
//we handle this here, because this .c file is where the keysyms come in
show_keysym = 1 - show_keysym;
if (show_keysym) draw_message(MSGSLOT_SYSTEM,0,-1,"Show keysym code : ON",75);
else draw_message(MSGSLOT_SYSTEM,0,-1,"Show keysym code : OFF",75);
return EV_SHOW_KEYSYM;
break;
case SDLK_F5:
return EV_SHOW_FPS;
break;
case SDLK_F6:
return EV_SLOW_MOTION;
break;
case SDLK_F7:
return EV_CYCLE_MSG;
break;
case SDLK_F10:
return EV_AUTOFRAMESKIP;
break;
case SDLK_F11:
return EV_SLEEPIDLE;
break;
case SDLK_F12:
return EV_FULLSCREEN;
break;
default:
break;
}
}
return 0;
}
void event_loop (void (*act_on_button) (float x, float y),
void (*drawscreen) (void)) {
/* The program's main event loop. Must be passed a user routine *
* drawscreen which redraws the screen. It handles all window resizing *
* zooming etc. itself. If the user clicks a button in the graphics *
* (toplevel) area, the act_on_button routine passed in is called. */
XEvent report;
int bnum;
float x, y;
#define OFF 1
#define ON 0
turn_on_off (ON);
while (1) {
XNextEvent (display, &report);
switch (report.type) {
case Expose:
#ifdef VERBOSE
printf("Got an expose event.\n");
printf("Count is: %d.\n",report.xexpose.count);
printf("Window ID is: %d.\n",report.xexpose.window);
#endif
if (report.xexpose.count != 0)
break;
if (report.xexpose.window == menu)
drawmenu();
else if (report.xexpose.window == toplevel)
drawscreen();
else if (report.xexpose.window == textarea)
draw_message();
break;
case ConfigureNotify:
top_width = report.xconfigure.width;
top_height = report.xconfigure.height;
update_transform();
#ifdef VERBOSE
printf("Got a ConfigureNotify.\n");
printf("New width: %d New height: %d.\n",top_width,top_height);
#endif
break;
case ButtonPress:
#ifdef VERBOSE
printf("Got a buttonpress.\n");
printf("Window ID is: %d.\n",report.xbutton.window);
#endif
if (report.xbutton.window == toplevel) {
x = XTOWORLD(report.xbutton.x);
y = YTOWORLD(report.xbutton.y);
act_on_button (x, y);
}
else { /* A menu button was pressed. */
bnum = which_button(report.xbutton.window);
#ifdef VERBOSE
printf("Button number is %d\n",bnum);
#endif
button[bnum].ispressed = 1;
drawbut(bnum);
XFlush(display); /* Flash the button */
button[bnum].fcn(bnum, drawscreen);
button[bnum].ispressed = 0;
drawbut(bnum);
if (button[bnum].fcn == proceed) {
turn_on_off(OFF);
flushinput ();
return; /* Rather clumsy way of returning *
* control to the simulator */
}
}
break;
}
}
}
int init_postscript (char *fname) {
/* Opens a file for PostScript output. The header information, *
* clipping path, etc. are all dumped out. If the file could *
* not be opened, the routine returns 0; otherwise it returns 1. */
ps = fopen (fname,"w");
if (ps == NULL) {
printf("Error: could not open %s for PostScript output.\n",fname);
printf("Drawing to screen instead.\n");
return (0);
}
disp_type = POSTSCRIPT; /* Graphics go to postscript file now. */
/* Header for minimal conformance with the Adobe structuring convention */
fprintf(ps,"%%!PS-Adobe-1.0\n");
fprintf(ps,"%%%%DocumentFonts: Helvetica\n");
fprintf(ps,"%%%%Pages: 1\n");
/* Set up postscript transformation macros and page boundaries */
update_ps_transform();
/* Bottom margin is at ps_bot - 15. to leave room for the on-screen message. */
fprintf(ps,"%%%%BoundingBox: %.2f %.2f %.2f %.2f\n",
ps_left, ps_bot - 15., ps_right, ps_top);
fprintf(ps,"%%%%EndComments\n");
fprintf(ps,"/censhow %%draw a centered string\n");
fprintf(ps," { moveto %% move to proper spot\n");
fprintf(ps," dup stringwidth pop %% get x length of string\n");
fprintf(ps," -2 div %% Proper left start\n");
fprintf(ps," yoff rmoveto %% Move left that much and down half font height\n");
fprintf(ps," show newpath } def %% show the string\n\n");
fprintf(ps,"/setfontsize %% set font to desired size and compute "
"centering yoff\n");
fprintf(ps," { /Helvetica findfont\n");
fprintf(ps," exch scalefont\n");
fprintf(ps," setfont %% Font size set ...\n\n");
fprintf(ps," 0 0 moveto %% Get vertical centering offset\n");
fprintf(ps," (Xg) true charpath\n");
fprintf(ps," flattenpath pathbbox\n");
fprintf(ps," /ascent exch def pop -1 mul /descent exch def pop\n");
fprintf(ps," newpath\n");
fprintf(ps," descent ascent sub 2 div /yoff exch def } def\n\n");
fprintf(ps,"%% Next two lines for debugging only.\n");
fprintf(ps,"/str 20 string def\n");
fprintf(ps,"/pnum {str cvs print ( ) print} def\n");
fprintf(ps,"/drawline %% draw a line from (x2,y2) to (x1,y1)\n");
fprintf(ps," { moveto lineto stroke } def\n\n");
fprintf(ps,"/rect %% outline a rectangle \n");
fprintf(ps," { /y2 exch def /x2 exch def /y1 exch def /x1 exch def\n");
fprintf(ps," x1 y1 moveto\n");
fprintf(ps," x2 y1 lineto\n");
fprintf(ps," x2 y2 lineto\n");
fprintf(ps," x1 y2 lineto\n");
fprintf(ps," closepath } def\n\n");
fprintf(ps,"/drawrect %% draw outline of a rectanagle\n");
fprintf(ps," { rect stroke } def\n\n");
fprintf(ps,"/fillrect %% fill in a rectanagle\n");
fprintf(ps," { rect fill } def\n\n");
fprintf (ps,"/drawarc { arc stroke } def %% draw an arc\n");
fprintf (ps,"/drawarcn { arcn stroke } def "
" %% draw an arc in the opposite direction\n\n");
fprintf (ps,"%%Fill a counterclockwise or clockwise arc sector, "
"respectively.\n");
fprintf (ps,"/fillarc { moveto currentpoint 5 2 roll arc closepath fill } "
"def\n");
fprintf (ps,"/fillarcn { moveto currentpoint 5 2 roll arcn closepath fill } "
"def\n\n");
fprintf (ps,"/fillpoly { 3 1 roll moveto %% move to first point\n"
" 2 exch 1 exch {pop lineto} for %% line to all other points\n"
" closepath fill } def\n\n");
fprintf(ps,"%%Color Definitions:\n");
fprintf(ps,"/white { 1 setgray } def\n");
fprintf(ps,"/black { 0 setgray } def\n");
fprintf(ps,"/grey55 { .55 setgray } def\n");
fprintf(ps,"/grey75 { .75 setgray } def\n");
fprintf(ps,"/blue { 0 0 1 setrgbcolor } def\n");
fprintf(ps,"/green { 0 1 0 setrgbcolor } def\n");
fprintf(ps,"/yellow { 1 1 0 setrgbcolor } def\n");
fprintf(ps,"/cyan { 0 1 1 setrgbcolor } def\n");
fprintf(ps,"/red { 1 0 0 setrgbcolor } def\n");
fprintf(ps,"/darkgreen { 0 0.5 0 setrgbcolor } def\n");
fprintf(ps,"\n%%Solid and dashed line definitions:\n");
fprintf(ps,"/linesolid {[] 0 setdash} def\n");
fprintf(ps,"/linedashed {[3 3] 0 setdash} def\n");
fprintf(ps,"\n%%%%EndProlog\n");
fprintf(ps,"%%%%Page: 1 1\n\n");
/* Set up PostScript graphics state to match current one. */
force_setcolor (currentcolor);
force_setlinestyle (currentlinestyle);
force_setlinewidth (currentlinewidth);
force_setfontsize (currentfontsize);
/* Draw this in the bottom margin -- must do before the clippath is set */
draw_message ();
/* Set clipping on page. */
fprintf(ps,"%.2f %.2f %.2f %.2f rect ",ps_left, ps_bot,ps_right,ps_top);
fprintf(ps,"clip newpath\n\n");
return (1);
}
static void adjustwin (int bnum, void (*drawscreen) (void)) {
/* The window button was pressed. Let the user click on the two *
* diagonally opposed corners, and zoom in on this area. */
XEvent report;
int corner, xold, yold, x[2], y[2];
corner = 0;
xold = -1;
yold = -1; /* Don't need to init yold, but stops compiler warning. */
while (corner<2) {
XNextEvent (display, &report);
switch (report.type) {
case Expose:
#ifdef VERBOSE
printf("Got an expose event.\n");
printf("Count is: %d.\n",report.xexpose.count);
printf("Window ID is: %d.\n",report.xexpose.window);
#endif
if (report.xexpose.count != 0)
break;
if (report.xexpose.window == menu)
drawmenu();
else if (report.xexpose.window == toplevel) {
drawscreen();
xold = -1; /* No rubber band on screen */
}
else if (report.xexpose.window == textarea)
draw_message();
break;
case ConfigureNotify:
top_width = report.xconfigure.width;
top_height = report.xconfigure.height;
update_transform();
#ifdef VERBOSE
printf("Got a ConfigureNotify.\n");
printf("New width: %d New height: %d.\n",top_width,top_height);
#endif
break;
case ButtonPress:
#ifdef VERBOSE
printf("Got a buttonpress.\n");
printf("Window ID is: %d.\n",report.xbutton.window);
printf("Location (%d, %d).\n", report.xbutton.x,
report.xbutton.y);
#endif
if (report.xbutton.window != toplevel) break;
x[corner] = report.xbutton.x;
y[corner] = report.xbutton.y;
if (corner == 0) {
XSelectInput (display, toplevel, ExposureMask |
StructureNotifyMask | ButtonPressMask | PointerMotionMask);
}
else {
update_win(x,y,drawscreen);
}
corner++;
break;
case MotionNotify:
#ifdef VERBOSE
printf("Got a MotionNotify Event.\n");
printf("x: %d y: %d\n",report.xmotion.x,report.xmotion.y);
#endif
if (xold >= 0) { /* xold set -ve before we draw first box */
XDrawRectangle(display,toplevel,gcxor,min(x[0],xold),
min(y[0],yold),abs(x[0]-xold),abs(y[0]-yold));
}
/* Don't allow user to window under menu region */
xold = min(report.xmotion.x,top_width-1-MWIDTH);
yold = report.xmotion.y;
XDrawRectangle(display,toplevel,gcxor,min(x[0],xold),
min(y[0],yold),abs(x[0]-xold),abs(y[0]-yold));
break;
}
}
XSelectInput (display, toplevel, ExposureMask | StructureNotifyMask
| ButtonPressMask);
}
int MultiTab_Editor::onChar(int c)
{
if (!m_state && !SHIFT_KEY_DOWN && !ALT_KEY_DOWN && c =='W'-'A'+1)
{
if (GetTab(0) == this) return 0; // first in list = do nothing
if (IsDirty())
{
m_state=UI_STATE_SAVE_ON_CLOSE;
attrset(m_color_message);
bkgdset(m_color_message);
mvaddstr(LINES-1,0,"Save file before closing (y/N)? ");
clrtoeol();
attrset(0);
bkgdset(0);
}
else
{
CloseCurrentTab();
delete this;
// context no longer valid!
return 1;
}
return 0;
}
if (m_state == UI_STATE_SAVE_ON_CLOSE)
{
if (isalnum(c) || isprint(c) || c==27)
{
if (c == 27)
{
m_state=0;
draw();
draw_message("Cancelled close of file.");
setCursor();
return 0;
}
if (toupper(c) == 'N' || toupper(c) == 'Y')
{
if (toupper(c) == 'Y')
{
if(updateFile())
{
m_state=0;
draw();
draw_message("Error writing file, changes not saved!");
setCursor();
return 0;
}
}
CloseCurrentTab();
delete this;
// this no longer valid, return 1 to avoid future calls in onChar()
return 1;
}
}
return 0;
}
else if (m_state == UI_STATE_SAVE_AS_NEW)
{
if (isalnum(c) || isprint(c) || c==27 || c == '\r' || c=='\n')
{
if (toupper(c) == 'N' || c == 27)
{
m_state=0;
draw();
draw_message("Cancelled create new file.");
setCursor();
return 0;
}
m_state=0;
AddTab(m_newfn.Get());
}
return 0;
}
if ((c==27 || c==29 || (c >= KEY_F1 && c<=KEY_F10)) && CTRL_KEY_DOWN)
{
int idx=c-KEY_F1;
bool rel=true;
if (c==27) idx=-1;
else if (c==29) idx=1;
else rel=false;
SwitchTab(idx,rel);
return 1;
}
return WDL_CursesEditor::onChar(c);
}
void main_loop(void)
{
int neo_emu_done = 0;
int overclk=CF_VAL(cf_get_item_by_name("overclock"));
Uint32 cpu_68k_timeslice = (overclk==0?200000:200000+(overclk*200000/100.0));
Uint32 cpu_68k_timeslice_scanline = cpu_68k_timeslice/262.0;
// Uint32 cpu_z80_timeslice = 100000;
Uint32 cpu_z80_timeslice = 73333;
Uint32 tm_cycle=0;
/* Uint32 cpu_z80_timeslice=66666; // is it 4Mhz or 6Mhz ???? 4 seems to work fine....
UPDATE: it's clear now that it's 6Mhz -> kof96 presentation */
Uint32 cpu_z80_timeslice_interlace = cpu_z80_timeslice / (float) nb_interlace;
char ksym_code[5];
SDL_Event event;
Uint16 scancode, i, a;
char input_buf[20];
Uint8 show_keysym=0;
CONF_ITEM* item = cf_get_item_by_name("invertjoy");
int invert_joy = 0;
if (item)
invert_joy=CF_BOOL(item);
reset_frame_skip();
my_timer();
//printf("Cpuspeed: %d\n",cpu_68k_timeslice);
/*
printf("%s\n",&memory.cpu[0x100]);
printf("NGH = %04x\n",READ_WORD(&memory.cpu[0x108]));
printf("SSN = %04x\n",READ_WORD(&memory.cpu[0x114]));
*/
while (!neo_emu_done) {
if (conf.test_switch == 1)
conf.test_switch = 0;
while (SDL_PollEvent(&event)) {
switch (event.type) {
case SDL_JOYAXISMOTION:
joy_axe[event.jaxis.which][event.jaxis.axis] = event.jaxis.value;
if (show_keysym) {
sprintf(ksym_code, "%d", event.jaxis.axis);
draw_message(ksym_code);
}
break;
case SDL_JOYHATMOTION:
switch (event.jhat.value) {
case SDL_HAT_CENTERED:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 0;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 0;
break;
case SDL_HAT_UP:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = -32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 0;
break;
case SDL_HAT_DOWN:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 0;
break;
case SDL_HAT_LEFT:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = -32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 0;
break;
case SDL_HAT_RIGHT:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 0;
break;
case SDL_HAT_RIGHTUP:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = -32767;
break;
case SDL_HAT_RIGHTDOWN:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = 32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 32767;
break;
case SDL_HAT_LEFTUP:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = -32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = -32767;
break;
case SDL_HAT_LEFTDOWN:
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which]] = -32767;
joy_axe[event.jhat.which][(event.jhat.hat * 2) + joy_numaxes[event.jhat.which] + 1] = 32767;
break;
}
if (show_keysym) {
sprintf(ksym_code, "%d", event.jhat.hat);
draw_message(ksym_code);
}
break;
case SDL_JOYBUTTONDOWN:
joy_button[event.jbutton.which][event.jbutton.button] = 1;
if (show_keysym) {
sprintf(ksym_code, "%d", event.jbutton.button);
draw_message(ksym_code);
}
break;
case SDL_JOYBUTTONUP:
joy_button[event.jbutton.which][event.jbutton.button] = 0;
break;
case SDL_KEYUP:
if (player)
{
switch(event.key.keysym.sym)
{
case 273:
key[264] = 0;
break;
case 275:
key[274] = 0;
break;
case 274:
key[261] = 0;
break;
case 276:
key[260] = 0;
break;
case 122:
key[108] = 0;
break;
case 120:
key[59] = 0;
break;
case 97:
key[111] = 0;
break;
case 115:
key[112] = 0;
break;
case 49:
key[50] = 0;
break;
case 51:
key[52] = 0;
break;
default:
key[event.key.keysym.sym] = 0;
break;
}
}
else
key[event.key.keysym.sym] = 0;
break;
case SDL_KEYDOWN:
scancode = event.key.keysym.sym;
if (show_keysym) {
sprintf(ksym_code, "%d", scancode);
draw_message(ksym_code);
}
if (player)
{
switch(scancode)
{
case 273:
key[264] = 1;
break;
case 275:
key[274] = 1;
break;
case 274:
key[261] = 1;
break;
case 276:
key[260] = 1;
break;
case 122:
key[108] = 1;
break;
case 120:
key[59] = 1;
break;
case 97:
key[111] = 1;
break;
case 115:
key[112] = 1;
break;
case 49:
key[50] = 1;
break;
case 51:
key[52] = 1;
break;
default:
key[scancode] = 1;
break;
}
}
else
key[scancode] = 1;
switch (scancode) {
case SDLK_ESCAPE:
neo_emu_done = 1;
#ifdef __QNXNTO__
shutdown = 1;
#endif
break; // ESC
/*
case SDLK_TAB:
main_gngeo_gui();
break;
*/
case SDLK_F1:
draw_message("Reset");
//neogeo_init();
cpu_68k_reset();
break;
case SDLK_F2:
take_screenshot();
draw_message("Screenshot saved");
break;
case SDLK_F3:
draw_message("Test Switch ON");
conf.test_switch = 1;
break;
case SDLK_F5:
show_fps ^= SDL_TRUE;
break;
case SDLK_F4:
show_keysym = 1 - show_keysym;
if (show_keysym)
draw_message("Show keysym code : ON");
else
draw_message("Show keysym code : OFF");
break;
case SDLK_F6:
slow_motion = 1 - slow_motion;
if (slow_motion)
draw_message("SlowMotion : ON");
else {
draw_message("SlowMotion : OFF");
reset_frame_skip();
}
break;
case SDLK_F7:
//screen_set_effect("scanline");
if (conf.debug) {
dbg_step = 1;
}
break;
case SDLK_F8:
{
int val;
char *endptr;
text_input("Save to slot [0-999]? ",16,227,input_buf,3);
val=strtol(input_buf,&endptr,10);
if (input_buf != endptr) {
pending_save_state=val+1;
}
}
break;
case SDLK_F9:
{
int val;
char *endptr;
text_input("Load from slot [0-999]? ",16,227,input_buf,3);
val=strtol(input_buf,&endptr,10);
if (input_buf != endptr) {
pending_load_state=val+1;
}
}
break;
case SDLK_F10:
autoframeskip ^= SDL_TRUE;
if (autoframeskip) {
reset_frame_skip();
draw_message("AutoFrameSkip : ON");
} else
draw_message("AutoFrameSkip : OFF");
break;
case SDLK_F11:
sleep_idle ^= SDL_TRUE;
if (sleep_idle)
draw_message("Sleep idle : ON");
else
draw_message("Sleep idle : OFF");
break;
case SDLK_F12:
screen_fullscreen();
break;
#ifdef __QNXNTO__
case SDLK_F13:
neo_emu_done = 1;
break;
case SDLK_F14:
if (player)
{
key[52] = 0;
key[50] = 0;
key[112] = 0;
key[111] = 0;
key[59] = 0;
key[108] = 0;
key[260] = 0;
key[261] = 0;
key[274] = 0;
key[264] = 0;
}
player = !player;
break;
#endif
}
break;
case SDL_VIDEORESIZE:
conf.res_x=event.resize.w;
conf.res_y=event.resize.h;
screen_resize(event.resize.w, event.resize.h);
break;
case SDL_ACTIVEEVENT:
if (event.active.state & SDL_APPINPUTFOCUS)
{
if (!event.active.gain)
{
int J;
SDL_PauseAudio(1);
while (1)
{
usleep(10000);
if (SDL_PollEvent(&event))
{
if (event.type == SDL_ACTIVEEVENT)
{
if (event.active.state & SDL_APPINPUTFOCUS)
{
if (event.active.gain)
break;
}
}
else if (event.type == SDL_QUIT)
{
neo_emu_done = 1;
break;
}
}
}
SDL_PauseAudio(0);
reset_frame_skip();
}
}
break;
case SDL_USEREVENT:
reset_frame_skip();
break;
case SDL_QUIT:
neo_emu_done = 1;
#ifdef __QNXNTO__
shutdown = 1;
#endif
break;
default:
break;
}
}
/* update the internal representation of keyslot */
update_p1_key();
update_p2_key();
update_start();
update_coin();
if (slow_motion)
SDL_Delay(100);
if (conf.sound) {
PROFILER_START(PROF_Z80);
for (i = 0; i < nb_interlace; i++) {
cpu_z80_run(cpu_z80_timeslice_interlace);
my_timer();
}
PROFILER_STOP(PROF_Z80);
} /*
else
my_timer();*/
if (!conf.debug) {
if (conf.raster) {
for (i = 0; i < 261; i++) {
tm_cycle=cpu_68k_run(cpu_68k_timeslice_scanline-tm_cycle);
if (update_scanline())
cpu_68k_interrupt(2);
}
tm_cycle=cpu_68k_run(cpu_68k_timeslice_scanline-tm_cycle);
state_handling(pending_save_state,pending_load_state);
update_screen();
cpu_68k_interrupt(1);
} else {
PROFILER_START(PROF_68K);
tm_cycle=cpu_68k_run(cpu_68k_timeslice-tm_cycle);
PROFILER_STOP(PROF_68K);
a = neo_interrupt();
/* state handling (we save/load before interrupt) */
state_handling(pending_save_state,pending_load_state);
if (a) {
cpu_68k_interrupt(a);
}
}
} else {
/* we arre in debug mode -> we are just here for event handling */
neo_emu_done=1;
}
#ifdef ENABLE_PROFILER
profiler_show_stat();
#endif
PROFILER_START(PROF_ALL);
}
}
int patch_firm(char *filename)
{
if (read_file(firm_patch_temp, filename, FCRAM_SPACING) != 0) {
print("Failed to load patch");
draw_message("Failed to load patch", "Please make sure all the patches you want\n to apply actually exist on the SD card.");
return 1;
}
print("Applying patch:");
print(firm_patch_temp->name);
firm_h *firm = NULL;
switch (firm_patch_temp->type) {
case NATIVE_FIRM:
firm = firm_loc;
break;
case AGB_FIRM:
firm = agb_firm_loc;
break;
default:
print("Unsupported patch type");
draw_message("Unsupported patch type", "This patch is of an unsupported type.\nPlease make sure it's supported if you wish to use it");
return 1;
}
struct patch *patches = (void *)firm_patch_temp + firm_patch_temp->patches_offset;
firm_section_h *sections = firm->section;
firm_section_h process9;
memset(&process9, 0, sizeof(firm_section_h));
// Assuming Process9 is in section 2
for (int x = 0; x < 4; x++) {
if (sections[x].address == 0) {
break;
} else if (sections[x].type != FIRM_TYPE_ARM9) {
continue;
}
uint32_t *arm9section = (uint32_t *)((void *)firm + sections[x].offset);
for (uint32_t i = 0; i < (sections[x].size / sizeof(uint32_t)); i += 2) {
// 'Process9' <- this will be in exheader
if (arm9section[i] == 0x636F7250 && arm9section[i + 1] == 0x39737365) {
ncch_h *ncch = (ncch_h *)((uint8_t *)arm9section + (i * 4)
- sizeof(ncch_h));
if (ncch->magic == NCCH_MAGIC) {
ncch_ex_h *p9exheader = (ncch_ex_h *)&ncch[1];
exefs_h* p9exefs = (exefs_h *)&p9exheader[1];
process9.address = (void *)p9exheader->sci.textCodeSet.address;
process9.size = p9exefs->fileHeaders[0].size;
process9.offset = ((uint32_t)ncch - (uint32_t)firm)
+ sizeof(ncch_h) + sizeof(ncch_ex_h) + sizeof(exefs_h);
goto found_process9;
}
}
}
}
// Can't find process9
return 1;
found_process9:
for (uint8_t i = 0; i < firm_patch_temp->count; i++) {
if (patches[i].address >= process9.address &&
patches[i].address < process9.address + process9.size) {
void *offset = (void *)firm + (uintptr_t)(process9.offset + (patches[i].address - process9.address));
memcpy(offset, (uintptr_t)firm_patch_temp + patches[i].offset, patches[i].size);
if (patches[i].options) {
if (patch_options(offset, patches[i].size, patches[i].options, firm_patch_temp->type) != 0) {
return 1;
}
}
continue;
}
for (int x = 0; x < 4; x++) {
if (sections[x].address == 0) {
break;
}
if (patches[i].address >= sections[x].address &&
patches[i].address < sections[x].address + sections[x].size) {
void *offset = (void *)firm + (uintptr_t)(sections[x].offset + (patches[i].address - sections[x].address));
memcpy(offset, (uintptr_t)firm_patch_temp + patches[i].offset, patches[i].size);
if (patches[i].options) {
if (patch_options(offset, patches[i].size, patches[i].options, firm_patch_temp->type) != 0) {
return 1;
}
}
break;
}
}
}
return 0;
}
