/****************************************************************
* *
* affiche une boŒte de dialogue des caractŠres ASCII *
* *
****************************************************************/
boolean m_ascii_box_proc(t_dialog *dialog, int exit)
{
int mx, my, bx, dummy;
char car;
switch (exit)
{
case ASCII_OK:
return TRUE;
default:
mouse(&mx, &my);
/* position de la premiŠre ligne */
objc_offset(dialog -> tree, ASCII_LIGNE_1, &bx, &dummy);
/* d‚termination du caractŠre */
car = (char)((exit - ASCII_LIGNE_1)*32 + (mx - bx)/8);
if (car == 0)
car = ' ';
sprintf(dialog -> tree[ASCII_CARACTERE].ob_spec.tedinfo -> te_ptext, "%c, x%02X, %3d", car, car, car);
ob_draw(dialog -> info, ASCII_CARACTERE);
break;
}
return FALSE;
} /* m_ascii_box_proc */
void do_walk(WORD wh, LONG tree, WORD obj, WORD depth, GRECT *pc)
{
register ORECT *po;
GRECT t;
if ( wh == NIL )
return;
/* clip to screen */
if (pc)
rc_intersect(&gl_rfull, pc);
else
pc = &gl_rfull;
/* walk owner rect list */
for(po=D.w_win[wh].w_rlist; po; po=po->o_link)
{
t.g_x = po->o_x;
t.g_y = po->o_y;
t.g_w = po->o_w;
t.g_h = po->o_h;
/* intersect owner rect */
/* with clip rect's */
if ( rc_intersect(pc, &t) )
{
/* set clip and draw */
gsx_sclip(&t);
ob_draw(tree, obj, depth);
}
}
}
/****************************************************************
* *
* affiche une boŒte de dialogue des caractŠres ASCII *
* *
****************************************************************/
char m_ascii_box(char car, int modal)
{
DIAINFO *info;
int exit, dc;
int mx, my, bx, dummy;
sprintf(Dialog[ASCII].tree[ASCII_CARACTERE].ob_spec.tedinfo -> te_ptext, "%c, x%02X, %3d", car, car, car);
if (modal)
{
info = open_dialog(Dialog[ASCII].tree, NULL, NULL, NULL, TRUE, TRUE, AUTO_DIAL|MODAL|NO_ICONIFY, 0, NULL, NULL);
do
{
exit = X_Form_Do(NULL);
/* enlŠve le flag double clic */
dc = exit & DOUBLE_CLICK;
exit &= NO_CLICK;
if (exit == ASCII_OK)
break;
mouse(&mx, &my);
/* position de la premiŠre ligne */
objc_offset(Dialog[ASCII].tree, ASCII_LIGNE_1, &bx, &dummy);
/* d‚termination du caractŠre */
car = (char)((exit - ASCII_LIGNE_1)*32 + (mx - bx)/8);
if (car == 0)
car = ' ';
sprintf(Dialog[ASCII].tree[ASCII_CARACTERE].ob_spec.tedinfo -> te_ptext, "%c, x%02X, %3d", car, car, car);
ob_draw(info, ASCII_CARACTERE);
if (dc) /* on sort aussi avec un double clic */
break;
} while (TRUE);
if (exit!=W_ABANDON && exit!=W_CLOSED)
{
exit &= 0x7fff;
ob_undostate(Dialog[ASCII].tree, exit, SELECTED);
}
close_dialog(info, TRUE);
}
else
{
Dialog[ASCII].proc = m_ascii_box_proc;
my_open_dialog(&Dialog[ASCII], AUTO_DIAL, FAIL);
}
return car;
} /* m_ascii_box */
static WORD fs_newdir(BYTE *fpath,
BYTE *pspec,
LONG tree,
WORD *pcount)
{
const BYTE *ptmp;
BYTE *ftitle;
OBJECT *obj;
TEDINFO *tedinfo;
WORD len, len_ftitle, i, fill;
/* load the filenames matching pspec, */
/* sort them, and insert the names in */
/* the file selector scroll box */
ob_draw(tree, FSDIRECT, MAX_DEPTH);
fs_active(fpath, pspec, pcount);
fs_format(tree, 0, *pcount);
/* ensure that mask fits within */
/* FTITLE, surround it with */
/* spaces, and centre it */
obj = ((OBJECT *)tree) + FTITLE;
tedinfo = (TEDINFO *)obj->ob_spec;
ftitle = (BYTE *)tedinfo->te_ptext;
len_ftitle = tedinfo->te_txtlen - 1;
len = strlen(pspec);
if (len > len_ftitle)
len = len_ftitle;
fill = len_ftitle - len;
for (i = 0; i < fill/2; i++)
*ftitle++ = ' ';
memcpy(ftitle, pspec, len);
ftitle += len;
for ( ; i < fill; i++)
*ftitle++ = ' ';
*ftitle = '\0';
ptmp = &gl_fsobj[0]; /* redraw file selector objects */
while(*ptmp)
ob_draw(tree, *ptmp++, MAX_DEPTH);
return(TRUE);
}
/*
* Routine to handle scrolling the directory window a certain number
* of file names.
*/
static WORD fs_nscroll(LONG tree, WORD *psel, WORD curr, WORD count,
WORD touchob, WORD n)
{
register WORD i, newcurr, diffcurr;
WORD sy, dy, neg;
GRECT r[2];
/* single scroll n times*/
newcurr = curr;
for (i=0; i<n; i++)
newcurr = fs_1scroll(newcurr, count, touchob);
/* if things changed */
/* then redraw */
diffcurr = newcurr - curr;
if (diffcurr)
{
curr = newcurr;
fs_sel(*psel, NORMAL);
*psel = 0;
fs_format(tree, curr, count);
gsx_gclip(&r[1]);
ob_actxywh(tree, F1NAME, &r[0]);
if (( neg = (diffcurr < 0)) != 0 )
diffcurr = -diffcurr;
if (diffcurr < NM_NAMES)
{
sy = r[0].g_y + (r[0].g_h * diffcurr);
dy = r[0].g_y;
if (neg)
{
dy = sy;
sy = r[0].g_y;
}
bb_screen(S_ONLY, r[0].g_x, sy, r[0].g_x, dy, r[0].g_w,
r[0].g_h * (NM_NAMES - diffcurr) );
if ( !neg )
r[0].g_y += r[0].g_h * (NM_NAMES - diffcurr);
}
else
diffcurr = NM_NAMES;
r[0].g_h *= diffcurr;
for(i=0; i<2; i++)
{
gsx_sclip(&r[i]);
ob_draw(tree, ((i) ? FSVSLID : FILEBOX), MAX_DEPTH);
}
}
return(curr);
}
static void sh_draw(const BYTE *lcmd, WORD start, WORD depth)
{
LONG tree;
if (gl_shgem)
{
tree = ad_stdesk;
gsx_sclip(&gl_rscreen);
LLSET(ad_pfile, (LONG)lcmd);
ob_draw(tree, start, depth);
}
}
/*
* Marks object corresponding to specified drive as selected,
* and all others as deselected. Optionally, if the selected
* drive has changed, the affected drive buttons are redrawn.
*/
static void select_drive(LONG treeaddr, WORD drive, WORD redraw)
{
WORD i, olddrive = -1;
OBJECT *obj, *start = (OBJECT *)treeaddr+DRIVE_OFFSET;
for (i = 0, obj = start; i < NM_DRIVES; i++, obj++)
{
if (obj->ob_state & SELECTED)
{
obj->ob_state &= ~SELECTED;
olddrive = i;
}
}
(start+drive)->ob_state |= SELECTED;
if (redraw && (drive != olddrive))
{
if (olddrive >= 0)
ob_draw(treeaddr,olddrive+DRIVE_OFFSET,MAX_DEPTH);
ob_draw(treeaddr,drive+DRIVE_OFFSET,MAX_DEPTH);
}
}
WORD fm_alert(WORD defbut, LONG palstr)
{
register WORD i;
WORD inm, nummsg, mlenmsg, numbut, mlenbut, image;
LONG tree;
GRECT d, t;
OBJECT *obj;
/* init tree pointer */
tree = (LONG) rs_trees[DIALERT];
gsx_mfset(ad_armice);
fm_parse(tree, palstr, &inm, &nummsg, &mlenmsg, &numbut, &mlenbut);
fm_build(tree, (inm != 0), nummsg, mlenmsg, numbut, mlenbut);
if (defbut)
{
obj = ((OBJECT *)tree) + BUTOFF + defbut - 1;
obj->ob_flags |= DEFAULT;
}
obj = ((OBJECT *)tree) + 1;
if (inm != 0)
{
switch(inm) {
case 1:
image = NOTEBB;
break;
case 2:
image = QUESTBB;
break;
default:
image = STOPBB;
break;
}
obj->ob_spec = (LONG) &rs_bitblk[image];
}
/* convert to pixels */
for(i=0; i<NUM_ALOBJS; i++)
rs_obfix(tree, i);
/* fix up icon, 32x32 */
obj->ob_type = G_IMAGE;
obj->ob_width = obj->ob_height = 32;
/* center tree on screen*/
ob_center(tree, &d);
/* Fix 2003-09-25: Limit drawing to the screen! */
rc_intersect(&gl_rscreen, &d);
/* save screen under- */
/* neath the alert */
wm_update(TRUE);
gsx_gclip(&t);
bb_save(&d);
/* draw the alert */
gsx_sclip(&d);
ob_draw(tree, ROOT, MAX_DEPTH);
/* turn on the mouse */
ct_mouse(TRUE);
/* let user pick button */
i = fm_do(tree, 0);
/* turn off mouse if necessary */
ct_mouse(FALSE);
/* restore saved screen */
gsx_sclip(&d);
bb_restore(&d);
gsx_sclip(&t);
wm_update(FALSE);
/* return selection */
return( i - BUTOFF + 1 );
}
/*
* File Selector input routine that takes control of the mouse
* and keyboard, searchs and sort the directory, draws the file
* selector, interacts with the user to determine a selection
* or change of path, and returns to the application with
* the selected path, filename, and exit button.
*/
WORD fs_input(BYTE *pipath, BYTE *pisel, WORD *pbutton, BYTE *pilabel)
{
register WORD touchob, value, fnum;
WORD curr, count, sel;
WORD mx, my;
LONG tree;
ULONG bitmask;
BYTE *ad_fpath, *ad_fname, *ad_ftitle;
WORD drive;
WORD dclkret, cont, newlist, newsel, newdrive;
register BYTE *pstr;
GRECT pt;
BYTE locstr[LEN_ZPATH+1], mask[LEN_ZFNAME+1], selname[LEN_FSNAME];
OBJECT *obj;
TEDINFO *tedinfo;
curr = 0;
count = 0;
/* get out quick if path is */
/* nullptr or if pts to null. */
if (pipath == NULL)
return(FALSE);
/* if path string is empty, */
/* set reasonable default */
if (*pipath == '\0') {
strcpy(pipath,"A:\\*.*");
*pipath += dos_gdrv();
}
/* get memory for the filename buffer */
/* & the array that points to it */
for (nm_files = MAX_NM_FILES; nm_files >= MIN_NM_FILES; nm_files /= 2)
{
ad_fsnames = (BYTE *)dos_alloc(nm_files*(LEN_FSNAME+sizeof(BYTE *)));
if (ad_fsnames)
break;
}
if (!ad_fsnames)
return(FALSE);
g_fslist = (LONG *)(ad_fsnames+nm_files*LEN_FSNAME);
strcpy(locstr, pipath);
tree = ad_fstree;
/* init strings in form */
obj = ((OBJECT *)tree) + FTITLE;
tedinfo = (TEDINFO *)obj->ob_spec;
ad_ftitle = (BYTE *)tedinfo->te_ptext;
set_mask(mask, locstr); /* save caller's mask */
strcpy(ad_ftitle, mask); /* & copy to title line */
obj = ((OBJECT *)tree) + FSDIRECT;
tedinfo = (TEDINFO *)obj->ob_spec;
ad_fpath = (BYTE *)tedinfo->te_ptext;
inf_sset(tree, FSDIRECT, locstr);
obj = ((OBJECT *)tree) + FSSELECT;
tedinfo = (TEDINFO *)obj->ob_spec;
ad_fname = (BYTE *)tedinfo->te_ptext;
fmt_str(pisel, selname); /* selname[] is without dot */
inf_sset(tree, FSSELECT, selname);
obj = ((OBJECT *)tree) + FSTITLE;
obj->ob_spec = pilabel ? (LONG)pilabel : (LONG)rs_str(ITEMSLCT);
/* set drive buttons */
obj = ((OBJECT *)tree) + DRIVE_OFFSET;
for (drive = 0, bitmask = 1; drive < NM_DRIVES; drive++, bitmask <<= 1, obj++)
{
if (drvbits & bitmask)
obj->ob_state &= ~DISABLED;
else
obj->ob_state |= DISABLED;
}
select_drive(tree,locstr[0]-'A',0);
/* set clip and start */
/* form fill-in by */
/* drawing the form */
gsx_sclip(&gl_rfs);
fm_dial(FMD_START, &gl_rfs);
ob_draw(tree, ROOT, 2);
/* init for while loop */
/* by forcing initial */
/* fs_newdir call */
sel = 0;
newsel = FALSE;
cont = newlist = TRUE;
while( cont )
{
touchob = (newlist) ? 0x0 : fm_do(tree, FSSELECT);
gsx_mxmy(&mx, &my);
if ( newlist )
{
fs_sel(sel, NORMAL);
if ( (touchob == FSOK) ||
(touchob == FSCANCEL) )
ob_change(tree, touchob, NORMAL, TRUE);
inf_sset(tree, FSDIRECT, locstr);
pstr = fs_pspec(locstr, NULL);
strcpy(pstr, mask);
fs_newdir(locstr, mask, tree, &count);
curr = 0;
sel = touchob = 0;
newlist = FALSE;
}
value = 0;
dclkret = ((touchob & 0x8000) != 0);
switch( (touchob &= 0x7fff) )
{
case FSOK:
case FSCANCEL:
cont = FALSE;
break;
case FUPAROW:
case FDNAROW:
value = 1;
break;
case FSVSLID:
ob_actxywh(tree, FSVELEV, &pt);
/* anemic slidebars
pt.g_x -= 3;
pt.g_w += 6;
*/
if ( !inside(mx, my, &pt) )
{
touchob = (my <= pt.g_y) ? FUPAROW : FDNAROW;
value = NM_NAMES;
break;
}
/* drop through */
case FSVELEV:
fm_own(TRUE);
value = gr_slidebox(tree, FSVSLID, FSVELEV, TRUE);
fm_own(FALSE);
value = curr - mul_div(value, count-NM_NAMES, 1000);
if (value >= 0)
touchob = FUPAROW;
else
{
touchob = FDNAROW;
value = -value;
}
break;
case F1NAME:
case F2NAME:
case F3NAME:
case F4NAME:
case F5NAME:
case F6NAME:
case F7NAME:
case F8NAME:
case F9NAME:
fnum = touchob - F1NAME + 1;
if ( fnum > count )
break;
if ( (sel) && (sel != fnum) )
fs_sel(sel, NORMAL);
if ( sel != fnum)
{
sel = fnum;
fs_sel(sel, SELECTED);
}
/* get string and see */
/* if file or folder */
inf_sget(tree, touchob, selname);
if (selname[0] == ' ') /* a file was selected */
{ /* copy to selection */
newsel = TRUE;
if (dclkret)
cont = FALSE;
}
else /* a folder was selected: */
{ /* insert name before mask */
pstr = fs_pspec(locstr, NULL);
unfmt_str(selname+1, pstr);
pstr += strlen(pstr);
*pstr++ = '\\';
strcpy(pstr, mask);
newlist = TRUE;
}
break;
case FCLSBOX:
pstr = fs_back(locstr, NULL);
if (*pstr-- != '\\') /* ignore strange path string */
break;
if (*pstr != ':') /* not at root of drive, so back up */
{
pstr = fs_back(locstr, pstr);
if (*pstr == '\\') /* we must have at least X:\ */
strcpy(pstr+1, mask);
}
newlist = TRUE;
break;
default:
drive = touchob - DRIVE_OFFSET;
if ((drive < 0) || (drive >= NM_DRIVES))/* not for us */
break;
if (drive == locstr[0] - 'A') /* no change */
break;
obj = ((OBJECT *)tree) + touchob;
if (obj->ob_state & DISABLED) /* non-existent drive */
break;
strcpy(locstr, "A:\\*.*");
locstr[0] += drive;
newdrive = TRUE;
break;
}
if (!newlist && !newdrive
&& path_changed(locstr)) /* path changed manually */
{
if (ad_fpath[0] != locstr[0]) /* drive has changed */
newdrive = TRUE;
else
newlist = TRUE;
strcpy(locstr, ad_fpath);
}
if (newdrive)
{
select_drive(tree, touchob-DRIVE_OFFSET,1);
newdrive = FALSE;
newlist = TRUE;
}
if (newlist)
{
inf_sset(tree, FSDIRECT, locstr);
set_mask(mask, locstr); /* set mask */
selname[1] = '\0'; /* selected is empty */
newsel = TRUE;
}
if (newsel)
{
strcpy(ad_fname, selname + 1);
ob_draw(tree, FSSELECT, MAX_DEPTH);
if (!cont)
ob_change(tree, FSOK, SELECTED, TRUE);
newsel = FALSE;
}
if (value)
curr = fs_nscroll(tree, &sel, curr, count, touchob, value);
}
/* return path and */
/* file name to app */
strcpy(pipath, locstr);
unfmt_str(ad_fname, selname);
strcpy(pisel, selname);
/* start the redraw */
fm_dial(FMD_FINISH, &gl_rfs);
/* return exit button */
*pbutton = inf_what(tree, FSOK, FSCANCEL);
dos_free((LONG)ad_fsnames);
return( TRUE );
}
/********************************************************************
* *
* cherche une chaŒne (gestion) *
* *
********************************************************************/
boolean search_proc(t_dialog *dialog, int exit)
{
char *text;
int c, i;
switch (exit)
{
case SEARCH_ANNULER:
return TRUE;
case ASCII_ACTIF:
ob_set_cursor(dialog -> info, SEARCH_ASCII, MAX_EDIT, TRUE);
break;
case HEXA_ACTIF:
ob_set_cursor(dialog -> info, SEARCH_HEXA, MAX_EDIT, TRUE);
break;
case SEARCH_CALC:
if (dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext[0] == '\0' && dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext[0] == '\0')
break;
if (ob_isstate(dialog -> tree, ASCII_ACTIF, SELECTED) && dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext[0] == '\0')
{
ob_dostate(dialog -> tree, HEXA_ACTIF, SELECTED);
ob_undostate(dialog -> tree, ASCII_ACTIF, SELECTED);
ob_set_cursor(dialog -> info, SEARCH_HEXA, MAX_EDIT, TRUE);
ob_draw_chg(dialog -> info, ASCII_ACTIF, NULL, FAIL);
ob_draw_chg(dialog -> info, HEXA_ACTIF, NULL, FAIL);
}
else
if (ob_isstate(dialog -> tree, HEXA_ACTIF, SELECTED) && dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext[0] == '\0')
{
ob_undostate(dialog -> tree, HEXA_ACTIF, SELECTED);
ob_dostate(dialog -> tree, ASCII_ACTIF, SELECTED);
ob_set_cursor(dialog -> info, SEARCH_ASCII, MAX_EDIT, TRUE);
ob_draw_chg(dialog -> info, ASCII_ACTIF, NULL, FAIL);
ob_draw_chg(dialog -> info, HEXA_ACTIF, NULL, FAIL);
}
if (ob_isstate(dialog -> tree, ASCII_ACTIF, SELECTED))
{
strcpy(SearchString, dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext);
SearchLength = (int)strlen(SearchString);
}
else
{
text = dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext;
for (i=0; i<SEARCH_PATTERN_SIZE && text[i*2]; i++)
{
sscanf(&text[i*2], "%02x", &c);
SearchString[i] = c;
}
SearchString[i] = '\0';
SearchLength = i;
}
text = dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext;
for (i=0; i<SearchLength; i++)
if (SearchString[i])
text[i] = (unsigned char)SearchString[i];
else
text[i] = '.';
text[i] = '\0';
text = dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext;
for (i=0; i<min(20, SearchLength); i++)
sprintf(&text[i*2], "%02X", (unsigned char)SearchString[i]);
text[2*i] = '\0';
ob_draw(dialog -> info, SEARCH_ASCII);
ob_draw(dialog -> info, SEARCH_HEXA);
/* Exit-Objekt selektiert? */
if (ob_isstate(dialog -> tree, exit, SELECTED))
{
/* angew„hltes Objekt deselektieren und neu zeichnen */
ob_undostate(dialog -> tree, exit, SELECTED);
ob_draw_chg(dialog -> info, exit, NULL, FAIL);
}
break;
}
if (exit == SEARCH_GO)
{
/* Exit-Objekt selektiert? */
if (ob_isstate(dialog -> tree, exit, SELECTED))
{
/* angew„hltes Objekt deselektieren und neu zeichnen */
ob_undostate(dialog -> tree, exit, SELECTED);
ob_draw_chg(dialog -> info, exit, NULL, FAIL);
}
my_close_dialog(dialog);
/* attend la fin des redessins */
Event_Timer(0, 0, TRUE);
if (dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext[0] == '\0' && dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext[0] == '\0')
{
menu_ienable(Menu, CHERCHER_NOUVEAU, 0);
my_alert(1, FAIL, X_ICN_STOP, Messages(SEARCH_4), NULL);
return TRUE;
}
if (ob_isstate(dialog -> tree, ASCII_ACTIF, SELECTED) && dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext[0] == '\0')
{
ob_dostate(dialog -> tree, HEXA_ACTIF, SELECTED);
ob_undostate(dialog -> tree, ASCII_ACTIF, SELECTED);
ob_set_cursor(dialog -> info, SEARCH_HEXA, MAX_EDIT, TRUE);
ob_draw_chg(dialog -> info, ASCII_ACTIF, NULL, FAIL);
ob_draw_chg(dialog -> info, HEXA_ACTIF, NULL, FAIL);
}
else
if (ob_isstate(dialog -> tree, HEXA_ACTIF, SELECTED) && dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext[0] == '\0')
{
ob_undostate(dialog -> tree, HEXA_ACTIF, SELECTED);
ob_dostate(dialog -> tree, ASCII_ACTIF, SELECTED);
ob_set_cursor(dialog -> info, SEARCH_ASCII, MAX_EDIT, TRUE);
ob_draw_chg(dialog -> info, ASCII_ACTIF, NULL, FAIL);
ob_draw_chg(dialog -> info, HEXA_ACTIF, NULL, FAIL);
}
if (ob_isstate(dialog -> tree, ASCII_ACTIF, SELECTED))
{
strcpy(SearchString, dialog -> tree[SEARCH_ASCII].ob_spec.tedinfo -> te_ptext);
SearchLength = (int)strlen(SearchString);
}
else
{
text = dialog -> tree[SEARCH_HEXA].ob_spec.tedinfo -> te_ptext;
for (i=0; i<20 && text[i*2]; i++)
{
sscanf(&text[i*2], "%02x", &c);
SearchString[i] = c;
}
SearchString[i] = '\0';
SearchLength = i;
}
menu_ienable(Menu, CHERCHER_NOUVEAU, 1);
switch (dialog -> thewin -> type)
{
case SECTEUR:
if (SavePos)
marquer_position(dialog -> thewin);
search_secteur(dialog -> thewin, ob_isstate(dialog -> tree, DIFF_MAJ_MIN, SELECTED), TRUE);
if (dialog -> thewin -> fonction.secteur.fichier)
print_secteur_file(dialog -> thewin);
break;
case FICHIER:
case FICHIER_FS:
case RAW_FLOPPY:
case RAW_HARD:
if (SavePos)
marquer_position(dialog -> thewin);
search_secteur(dialog -> thewin, ob_isstate(dialog -> tree, DIFF_MAJ_MIN, SELECTED), TRUE);
break;
case TAMPON:
search_tampon(dialog -> thewin, ob_isstate(dialog -> tree, DIFF_MAJ_MIN, SELECTED));
}
return TRUE;
}
return FALSE;
} /* search_proc */
/****************************************************************
* *
* cherche une chaŒne *
* *
****************************************************************/
void search_secteur(windowptr thewin, boolean diff_majmin, boolean start_to_end)
{
char *buffer, *buffer_frontiere;
OBJECT *search = Dialog[WAIT].tree;
int taille, start;
long secteur = thewin -> fonction.secteur.secteur, max = thewin -> fonction.secteur.max;
int width, i;
char *secteur_text;
char pattern[SEARCH_PATTERN_SIZE];
long offset;
int size_buff_sect;
int dummy;
#ifndef TEST_VERSION
if (thewin -> fonction.secteur.dirty && write_secteur(thewin, MENU_DEPLACEMENT))
return;
#endif
thewin -> fonction.secteur.dirty = FALSE;
/* attend la fin des redessins */
Event_Timer(0, 0, TRUE);
search[WAIT_MESSAGE].ob_spec.free_string = Messages(SEARCH_2);
search[WAIT_INFO].ob_spec.tedinfo -> te_ptext = Messages(REORG_14);
width = search[SLIDE_PERE].ob_width -3;
search[SLIDE_FILS].ob_width = (int)((long)width * secteur / max) +3;
secteur_text = search[INDICATEUR_WAIT].ob_spec.tedinfo -> te_ptext;
sprintf(secteur_text, "%ld", secteur);
sprintf(search[MAX_WAIT].ob_spec.free_string, "/%ld", max);
my_open_dialog(&Dialog[WAIT], AUTO_DIAL|NO_ICONIFY|MODAL, FAIL);
/* attend la fin des redessins */
Event_Timer(0, 0, TRUE);
/* allocation des buffers, on d‚passe un peu … cause de l'approximation de la taille dans and_buffer() */
buffer = malloc(20L+ 512L * (thewin -> fonction.secteur.device < 2 ? SIZEBUFFLOP : SIZEBUFHARD));
if (buffer == NULL)
{
error_msg(Z_NOT_ENOUGH_MEMORY);
return;
}
if ((buffer_frontiere = malloc(20L+ SEARCH_PATTERN_SIZE*2L + 16L)) == NULL)
{
free(buffer);
error_msg(Z_NOT_ENOUGH_MEMORY);
return;
}
/* mise … z‚ro */
memset(buffer_frontiere, 0, 20L+ SEARCH_PATTERN_SIZE*2L + 16L);
/* pr‚pare le pattern */
if (diff_majmin)
for (i=0; i<SearchLength; i++)
pattern[i] = SearchString[i];
else
for (i=0; i<SearchLength; i++)
pattern[i] = SearchString[i] & ~('a'-'A');
/* octet de d‚part */
start = thewin -> fonction.secteur.curseur_x < 0 ? thewin -> fonction.secteur.page *512 : thewin -> fonction.secteur.page *512 + thewin -> fonction.secteur.curseur_y*32 + thewin -> fonction.secteur.curseur_x/2 +1;
/* recherche d'abord dans le secteur en m‚moire */
memcpy(buffer, thewin -> fonction.secteur.secteurBin, thewin -> fonction.secteur.sector_size*512L);
if ((offset = search_pattern(buffer + start, thewin -> fonction.secteur.sector_size*512L - start, pattern, diff_majmin, start_to_end)) >= 0)
{
my_close_dialog(&Dialog[WAIT]);
free(buffer_frontiere);
free(buffer);
search_found(thewin, secteur, offset + start);
return;
}
/* remplis de n'importe quoi sauf du motif recherch‚ */
memset(buffer_frontiere, SearchString[0] ^ 0xAA, (long)SEARCH_PATTERN_SIZE);
/* nombre max de secteurs … lire */
size_buff_sect = (thewin -> fonction.secteur.device < 2 ? SIZEBUFFLOP : SIZEBUFHARD) / thewin -> fonction.secteur.sector_size;
/* taille du bloc … lire */
if (max - secteur > (long)size_buff_sect)
taille = size_buff_sect;
else
taille = (int)(max - secteur);
while (taille > 0)
{
/* charge le buffer */
if ((taille = load_buffer(thewin, buffer, secteur, taille, start_to_end)) < 0)
{ /* erreur */
my_close_dialog(&Dialog[WAIT]);
free(buffer);
return;
}
/* recherche sur la frontiŠre */
memcpy(buffer_frontiere + SEARCH_PATTERN_SIZE, buffer, (long)SEARCH_PATTERN_SIZE);
if ((offset = search_pattern(buffer_frontiere, SEARCH_PATTERN_SIZE, pattern, diff_majmin, start_to_end)) >= 0)
{
my_close_dialog(&Dialog[WAIT]);
free(buffer_frontiere);
free(buffer);
search_found(thewin, secteur-taille, offset + (thewin -> fonction.secteur.device < 2 ? SIZEBUFFLOP*512L - SEARCH_PATTERN_SIZE : SIZEBUFHARD*512L - SEARCH_PATTERN_SIZE));
return;
}
/* recherche en cours */
if ((offset = search_pattern(buffer+start, taille * thewin -> fonction.secteur.sector_size * 512L - start, pattern, diff_majmin, start_to_end)) >= 0)
{
my_close_dialog(&Dialog[WAIT]);
free(buffer_frontiere);
free(buffer);
search_found(thewin, secteur, offset+start);
return;
}
/* on n'a un d‚calage que la premiŠre fois */
start = 0;
/* copie la fin du bloc pour la frontiŠre */
memcpy(buffer_frontiere, buffer + (thewin -> fonction.secteur.device < 2 ? SIZEBUFFLOP*512L - SEARCH_PATTERN_SIZE : SIZEBUFHARD*512L - SEARCH_PATTERN_SIZE), (long)SEARCH_PATTERN_SIZE);
/* on avance */
secteur += taille;
/* taille du bloc … lire */
if (max - secteur > (long)size_buff_sect)
taille = size_buff_sect;
else
taille = (int)(max - secteur);
/* test les boutons */
if (evnt_multi(MU_TIMER | MU_BUTTON,
256+1, 3, 0, /* button */
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* mouse */
NULL, /* message */
1, 0, /* timer */
&dummy, &dummy, &dummy, &dummy, &dummy, &dummy) == MU_BUTTON
&& my_alert(1, 2, X_ICN_QUESTION, Messages(SEARCH_3), Messages(BOOT_32)) == 0)
{ /* on n'a pas trouv‚ mais on s'arrˆte */
my_close_dialog(&Dialog[WAIT]);
free(buffer_frontiere);
free(buffer);
search_found(thewin, secteur, -1L);
return;
}
/* met … jour la barre */
search[SLIDE_FILS].ob_width = (int)((long)width * secteur / max) +3;
ob_draw(Dialog[WAIT].info, SLIDE_FILS);
/* met … jour le compteur */
sprintf(secteur_text, "%ld", secteur);
ob_draw(Dialog[WAIT].info, INDICATEUR_WAIT);
/* attend la fin des redessins */
Event_Timer(0, 0, TRUE);
}
free(buffer_frontiere);
free(buffer);
my_close_dialog(&Dialog[WAIT]);
/* un petit bruit */
if (Sound)
Cconout(7);
} /* search_secteur */
static UWORD crysbind(WORD opcode, LONG pglobal, WORD control[], WORD int_in[], WORD int_out[], LONG addr_in[])
{
LONG maddr;
LONG tree;
WORD mouse, ret;
WORD unsupported = FALSE;
maddr = 0;
ret = TRUE;
switch(opcode)
{
/* Application Manager */
case APPL_INIT:
#if DBG_GEMSUPER
aestrace("appl_init()");
#endif
LWSET(pglobal, AES_VERSION); /* version number */
LWSET(pglobal+2, 0x0001); /* num of concurrent procs*/
/* LLSET(pglobal, 0x00010200L);
*/
LWSET(pglobal+4, rlr->p_pid);
sh_deskf(0, pglobal+6);
LWSET(pglobal+20, gl_nplanes);
LLSET(pglobal+22, ADDR(&D));
/* reset dispatcher */
/* count to let the app*/
/* run a while. */
dspcnt = 0;
ret = ap_init();
break;
case APPL_READ:
case APPL_WRITE:
ap_rdwr(opcode == APPL_READ ? MU_MESAG : MU_SDMSG,
fpdnm(NULLPTR, AP_RWID), AP_LENGTH, AP_PBUFF);
break;
case APPL_FIND:
ret = ap_find( AP_PNAME );
break;
case APPL_TPLAY:
ap_tplay(AP_TBUFFER, AP_TLENGTH, AP_TSCALE);
break;
case APPL_TRECORD:
ret = ap_trecd(AP_TBUFFER, AP_TLENGTH);
break;
#if CONF_WITH_PCGEM
case APPL_YIELD:
dsptch();
break;
#endif
case APPL_EXIT:
#if DBG_GEMSUPER
aestrace("appl_exit()");
#endif
ap_exit();
break;
/* Event Manager */
case EVNT_KEYBD:
ret = ev_block(MU_KEYBD, 0x0L);
break;
case EVNT_BUTTON:
ret = ev_button(B_CLICKS, B_MASK, B_STATE, &EV_MX);
break;
case EVNT_MOUSE:
ret = ev_mouse((MOBLK *)&MO_FLAGS, &EV_MX);
break;
case EVNT_MESAG:
#if DBG_GEMSUPER
aestrace("evnt_mesag()");
#endif
ap_rdwr(MU_MESAG, rlr, 16, ME_PBUFF);
break;
case EVNT_TIMER:
ev_timer( HW(T_HICOUNT) + LW(T_LOCOUNT) );
break;
case EVNT_MULTI:
#if DBG_GEMSUPER
aestrace("evnt_multi()");
#endif
if (MU_FLAGS & MU_TIMER)
maddr = HW(MT_HICOUNT) + LW(MT_LOCOUNT);
tree = HW(MB_CLICKS) | LW((MB_MASK << 8) | MB_STATE);
ret = ev_multi(MU_FLAGS, (MOBLK *)&MMO1_FLAGS, (MOBLK *)&MMO2_FLAGS,
maddr, tree, MME_PBUFF, &EV_MX);
break;
case EVNT_DCLICK:
ret = ev_dclick(EV_DCRATE, EV_DCSETIT);
break;
/* Menu Manager */
case MENU_BAR:
if (gl_mnppd == rlr || gl_mnppd == NULL)
mn_bar(MM_ITREE, SHOW_IT, rlr->p_pid);
else
menu_tree[rlr->p_pid] = (SHOW_IT) ? MM_ITREE : 0x0L;
break;
case MENU_ICHECK:
do_chg(MM_ITREE, ITEM_NUM, CHECKED, CHECK_IT, FALSE, FALSE);
break;
case MENU_IENABLE:
do_chg(MM_ITREE, (ITEM_NUM & 0x7fff), DISABLED,
!ENABLE_IT, ((ITEM_NUM & 0x8000) != 0x0), FALSE);
break;
case MENU_TNORMAL:
if (gl_mntree == menu_tree[rlr->p_pid])
do_chg(MM_ITREE, TITLE_NUM, SELECTED, !NORMAL_IT,
TRUE, TRUE);
break;
case MENU_TEXT:
tree = MM_ITREE;
strcpy((char *)LLGET(OB_SPEC(ITEM_NUM)),
(char *)MM_PTEXT);
break;
case MENU_REGISTER:
ret = mn_register(MM_PID, MM_PSTR);
break;
case MENU_UNREGISTER:
#if CONF_WITH_PCGEM
/* distinguish between menu_unregister() and menu_popup() */
if (IN_LEN == 1)
mn_unregister( MM_MID );
else
#endif
unsupported = TRUE;
break;
case MENU_CLICK:
/* distinguish between menu_click() and menu_attach() */
/*
* although menu_click() is PC-GEM only, it's always
* enabled because the desktop uses it.
*/
if (IN_LEN == 2) {
if (MN_SETIT)
gl_mnclick = MN_CLICK;
ret = gl_mnclick;
} else
unsupported = TRUE;
break;
/* Object Manager */
case OBJC_ADD:
ob_add(OB_TREE, OB_PARENT, OB_CHILD);
break;
case OBJC_DELETE:
ob_delete(OB_TREE, OB_DELOB);
break;
case OBJC_DRAW:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_draw(OB_TREE, OB_DRAWOB, OB_DEPTH);
break;
case OBJC_FIND:
ret = ob_find(OB_TREE, OB_STARTOB, OB_DEPTH,
OB_MX, OB_MY);
break;
case OBJC_OFFSET:
ob_offset(OB_TREE, OB_OBJ, &OB_XOFF, &OB_YOFF);
break;
case OBJC_ORDER:
ob_order(OB_TREE, OB_OBJ, OB_NEWPOS);
break;
case OBJC_EDIT:
gsx_sclip(&gl_rfull);
OB_ODX = OB_IDX;
ret = ob_edit(OB_TREE, OB_OBJ, OB_CHAR, &OB_ODX, OB_KIND);
break;
case OBJC_CHANGE:
gsx_sclip((GRECT *)&OB_XCLIP);
ob_change(OB_TREE, OB_DRAWOB, OB_NEWSTATE, OB_REDRAW);
break;
/* Form Manager */
case FORM_DO:
ret = fm_do(FM_FORM, FM_START);
break;
case FORM_DIAL:
ret = fm_dial(FM_TYPE, (GRECT *)&FM_X);
break;
case FORM_ALERT:
ret = fm_alert(FM_DEFBUT, FM_ASTRING);
break;
case FORM_ERROR:
ret = fm_error(FM_ERRNUM);
break;
case FORM_CENTER:
ob_center(FM_FORM, (GRECT *)&FM_XC);
break;
case FORM_KEYBD:
gsx_sclip(&gl_rfull);
FM_OCHAR = FM_ICHAR;
FM_ONXTOB = FM_INXTOB;
ret = fm_keybd(FM_FORM, FM_OBJ, &FM_OCHAR, &FM_ONXTOB);
break;
case FORM_BUTTON:
gsx_sclip(&gl_rfull);
ret = fm_button(FM_FORM, FM_OBJ, FM_CLKS, &FM_ONXTOB);
break;
/* Graphics Manager */
case GRAF_RUBBOX:
gr_rubbox(GR_I1, GR_I2, GR_I3, GR_I4,
&GR_O1, &GR_O2);
break;
case GRAF_DRAGBOX:
gr_dragbox(GR_I1, GR_I2, GR_I3, GR_I4, (GRECT *)&GR_I5,
&GR_O1, &GR_O2);
break;
case GRAF_MBOX:
gr_movebox(GR_I1, GR_I2, GR_I3, GR_I4, GR_I5, GR_I6);
break;
case GRAF_GROWBOX:
gr_growbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_SHRINKBOX:
gr_shrinkbox((GRECT *)&GR_I1, (GRECT *)&GR_I5);
break;
case GRAF_WATCHBOX:
ret = gr_watchbox(GR_TREE, GR_OBJ, GR_INSTATE, GR_OUTSTATE);
break;
case GRAF_SLIDEBOX:
ret = gr_slidebox(GR_TREE, GR_PARENT, GR_OBJ, GR_ISVERT);
break;
case GRAF_HANDLE:
GR_WCHAR = gl_wchar;
GR_HCHAR = gl_hchar;
GR_WBOX = gl_wbox;
GR_HBOX = gl_hbox;
ret = gl_handle;
break;
case GRAF_MOUSE:
if (GR_MNUMBER > 255)
{
if (GR_MNUMBER == M_OFF)
gsx_moff();
if (GR_MNUMBER == M_ON)
gsx_mon();
}
else
{
if (GR_MNUMBER != 255)
{
switch(GR_MNUMBER) {
case 1:
mouse = MICE01;
break;
case 2:
mouse = MICE02;
break;
case 3:
mouse = MICE03;
break;
case 4:
mouse = MICE04;
break;
case 5:
mouse = MICE05;
break;
case 6:
mouse = MICE06;
break;
case 7:
mouse = MICE07;
break;
default:
mouse = MICE00;
break;
}
maddr = *(LONG *) &rs_bitblk[mouse];
}
else
maddr = GR_MADDR;
gsx_mfset(maddr);
}
break;
case GRAF_MKSTATE:
gr_mkstate(&GR_MX, &GR_MY, &GR_MSTATE, &GR_KSTATE);
break;
/* Scrap Manager */
case SCRP_READ:
ret = sc_read((BYTE*)SC_PATH);
break;
case SCRP_WRITE:
ret = sc_write((const BYTE*)SC_PATH);
break;
#if CONF_WITH_PCGEM
case SCRP_CLEAR:
ret = sc_clear();
break;
#endif
/* File Selector Manager */
case FSEL_INPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, NULL);
break;
case FSEL_EXINPUT:
ret = fs_input((BYTE*)FS_IPATH, (BYTE*)FS_ISEL, &FS_BUTTON, (BYTE *)FS_ILABEL);
break;
/* Window Manager */
case WIND_CREATE:
ret = wm_create(WM_KIND, (GRECT *)&WM_WX);
break;
case WIND_OPEN:
wm_open(WM_HANDLE, (GRECT *)&WM_WX);
break;
case WIND_CLOSE:
wm_close(WM_HANDLE);
break;
case WIND_DELETE:
wm_delete(WM_HANDLE);
break;
case WIND_GET:
wm_get(WM_HANDLE, WM_WFIELD, &WM_OX);
break;
case WIND_SET:
wm_set(WM_HANDLE, WM_WFIELD, &WM_IX);
break;
case WIND_FIND:
ret = wm_find(WM_MX, WM_MY);
break;
case WIND_UPDATE:
wm_update(WM_BEGUP);
break;
case WIND_CALC:
wm_calc(WM_WCTYPE, WM_WCKIND, WM_WCIX, WM_WCIY,
WM_WCIW, WM_WCIH, &WM_WCOX, &WM_WCOY,
&WM_WCOW, &WM_WCOH);
break;
case WIND_NEW:
wm_new();
break;
/* Resource Manager */
case RSRC_LOAD:
ret = rs_load(pglobal, RS_PFNAME);
break;
case RSRC_FREE:
ret = rs_free(pglobal);
break;
case RSRC_GADDR:
ret = rs_gaddr(pglobal, RS_TYPE, RS_INDEX, &ad_rso);
break;
case RSRC_SADDR:
ret = rs_saddr(pglobal, RS_TYPE, RS_INDEX, RS_INADDR);
break;
case RSRC_OBFIX:
rs_obfix(RS_TREE, RS_OBJ);
break;
/* Shell Manager */
case SHEL_READ:
sh_read((BYTE*)SH_PCMD, (BYTE*)SH_PTAIL);
break;
case SHEL_WRITE:
ret = sh_write(SH_DOEX, SH_ISGR, SH_ISCR, (const BYTE*)SH_PCMD, (const BYTE*)SH_PTAIL);
break;
case SHEL_GET:
sh_get((void*)SH_PBUFFER, SH_LEN);
break;
case SHEL_PUT:
sh_put((const void *)SH_PDATA, SH_LEN);
break;
case SHEL_FIND:
ret = sh_find((BYTE*)SH_PATH);
break;
case SHEL_ENVRN:
sh_envrn((BYTE**)SH_PATH, (const BYTE*)SH_SRCH);
break;
#if CONF_WITH_PCGEM
case SHEL_RDEF:
sh_rdef((BYTE*)SH_LPCMD, (BYTE*)SH_LPDIR);
break;
case SHEL_WDEF:
sh_wdef((const BYTE*)SH_LPCMD, (const BYTE*)SH_LPDIR);
break;
#endif
default:
unsupported = TRUE;
break;
}
if (unsupported) {
kprintf("Bad AES function %d\n", opcode);
if (opcode != 0) /* Ignore the 0 since some PRGs are this call */
fm_show(ALNOFUNC, &opcode, 1);
ret = -1;
}
return(ret);
}
