mirror of
https://github.com/reactos/reactos.git
synced 2024-11-01 12:26:32 +00:00
81345fd691
next few weeks. I'm going through the DFLAT api doc and fixing the export names and then going to try to build a simple hello dflat application. svn path=/trunk/; revision=2844
718 lines
22 KiB
C
718 lines
22 KiB
C
/* ------------ helpbox.c ----------- */
|
|
|
|
#include "dflat32/dflat.h"
|
|
#include "dflat32/htree.h"
|
|
|
|
extern DBOX HelpBox;
|
|
|
|
/* -------- strings of D-Flat classes for calling default
|
|
help text collections -------- */
|
|
char *ClassNames[] = {
|
|
#undef ClassDef
|
|
#define ClassDef(c,b,p,a) #c,
|
|
#include "dflat32/classes.h"
|
|
NULL
|
|
};
|
|
|
|
#define MAXHEIGHT (DfGetScreenHeight()-10)
|
|
|
|
/* --------- linked list of help text collections -------- */
|
|
struct helps {
|
|
char *hname;
|
|
char *NextName;
|
|
char *PrevName;
|
|
long hptr;
|
|
int bit;
|
|
int hheight;
|
|
int hwidth;
|
|
DFWINDOW hwnd;
|
|
struct helps *NextHelp;
|
|
};
|
|
static struct helps *FirstHelp;
|
|
static struct helps *LastHelp;
|
|
static struct helps *ThisHelp;
|
|
|
|
/* --- linked stack of help windows that have beed used --- */
|
|
struct HelpStack {
|
|
char *hname;
|
|
struct HelpStack *PrevStack;
|
|
};
|
|
static struct HelpStack *LastStack;
|
|
static struct HelpStack *ThisStack;
|
|
|
|
/* --- linked list of keywords in the current help
|
|
text collection (listhead is in window) -------- */
|
|
struct keywords {
|
|
char *hname;
|
|
int lineno;
|
|
int off1, off2, off3;
|
|
int isDefinition;
|
|
struct keywords *nextword;
|
|
struct keywords *prevword;
|
|
};
|
|
|
|
static FILE *helpfp;
|
|
static char hline [160];
|
|
static BOOL Helping;
|
|
|
|
static void SelectHelp(DFWINDOW, char *);
|
|
static void ReadHelp(DFWINDOW);
|
|
static void FindHelp(char *);
|
|
static void FindHelpWindow(DFWINDOW);
|
|
static void DisplayDefinition(DFWINDOW, char *);
|
|
static void BestFit(DFWINDOW, DIALOGWINDOW *);
|
|
|
|
/* ------------- CREATE_WINDOW message ------------ */
|
|
static void CreateWindowMsg(DFWINDOW wnd)
|
|
{
|
|
Helping = TRUE;
|
|
GetClass(wnd) = HELPBOX;
|
|
InitWindowColors(wnd);
|
|
if (ThisHelp != NULL)
|
|
ThisHelp->hwnd = wnd;
|
|
}
|
|
|
|
/* ------------- COMMAND message ------------ */
|
|
static BOOL CommandMsg(DFWINDOW wnd, PARAM p1)
|
|
{
|
|
switch ((int)p1) {
|
|
case ID_CANCEL:
|
|
ThisStack = LastStack;
|
|
while (ThisStack != NULL) {
|
|
LastStack = ThisStack->PrevStack;
|
|
if (ThisStack->hname != NULL)
|
|
free(ThisStack->hname);
|
|
free(ThisStack);
|
|
ThisStack = LastStack;
|
|
}
|
|
break;
|
|
case ID_PREV:
|
|
FindHelpWindow(wnd);
|
|
if (ThisHelp != NULL)
|
|
SelectHelp(wnd, ThisHelp->PrevName);
|
|
return TRUE;
|
|
case ID_NEXT:
|
|
FindHelpWindow(wnd);
|
|
if (ThisHelp != NULL)
|
|
SelectHelp(wnd, ThisHelp->NextName);
|
|
return TRUE;
|
|
case ID_BACK:
|
|
if (LastStack != NULL) {
|
|
if (LastStack->PrevStack != NULL) {
|
|
ThisStack = LastStack->PrevStack;
|
|
if (LastStack->hname != NULL)
|
|
free(LastStack->hname);
|
|
free(LastStack);
|
|
LastStack = ThisStack;
|
|
SelectHelp(wnd, ThisStack->hname);
|
|
}
|
|
}
|
|
return TRUE;
|
|
default:
|
|
break;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/* ------------- KEYBOARD message ------------ */
|
|
static BOOL KeyboardMsg(DFWINDOW wnd, PARAM p1)
|
|
{
|
|
DFWINDOW cwnd;
|
|
struct keywords *thisword;
|
|
static char HelpName[50];
|
|
|
|
cwnd = ControlWindow(wnd->extension, ID_HELPTEXT);
|
|
if (cwnd == NULL || inFocus != cwnd)
|
|
return FALSE;
|
|
thisword = cwnd->thisword;
|
|
switch ((int)p1) {
|
|
case '\r':
|
|
if (thisword != NULL) {
|
|
if (thisword->isDefinition)
|
|
DisplayDefinition(GetParent(wnd),
|
|
thisword->hname);
|
|
else {
|
|
strncpy(HelpName, thisword->hname,
|
|
sizeof HelpName);
|
|
SelectHelp(wnd, HelpName);
|
|
}
|
|
}
|
|
return TRUE;
|
|
case '\t':
|
|
if (thisword == NULL)
|
|
thisword = cwnd->firstword;
|
|
else {
|
|
if (thisword->nextword == NULL)
|
|
thisword = cwnd->firstword;
|
|
else
|
|
thisword = thisword->nextword;
|
|
}
|
|
break;
|
|
case SHIFT_HT:
|
|
if (thisword == NULL)
|
|
thisword = cwnd->lastword;
|
|
else {
|
|
if (thisword->prevword == NULL)
|
|
thisword = cwnd->lastword;
|
|
else
|
|
thisword = thisword->prevword;
|
|
}
|
|
break;
|
|
default:
|
|
thisword = NULL;
|
|
break;
|
|
}
|
|
if (thisword != NULL) {
|
|
cwnd->thisword = thisword;
|
|
if (thisword->lineno < cwnd->wtop ||
|
|
thisword->lineno >=
|
|
cwnd->wtop + ClientHeight(cwnd)) {
|
|
int distance = ClientHeight(cwnd)/2;
|
|
do {
|
|
cwnd->wtop = thisword->lineno-distance;
|
|
distance /= 2;
|
|
}
|
|
while (cwnd->wtop < 0);
|
|
}
|
|
DfSendMessage(cwnd, PAINT, 0, 0);
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/* ---- window processing module for the HELPBOX ------- */
|
|
int HelpBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
|
|
{
|
|
DBOX *db = wnd->extension;
|
|
|
|
switch (msg) {
|
|
case CREATE_WINDOW:
|
|
CreateWindowMsg(wnd);
|
|
break;
|
|
case INITIATE_DIALOG:
|
|
ReadHelp(wnd);
|
|
break;
|
|
case DFM_COMMAND:
|
|
if (p2 != 0)
|
|
break;
|
|
if (CommandMsg(wnd, p1))
|
|
return TRUE;
|
|
break;
|
|
case KEYBOARD:
|
|
if (WindowMoving)
|
|
break;
|
|
if (KeyboardMsg(wnd, p1))
|
|
return TRUE;
|
|
break;
|
|
case CLOSE_WINDOW:
|
|
if (db != NULL) {
|
|
if (db->dwnd.title != NULL) {
|
|
free(db->dwnd.title);
|
|
db->dwnd.title = NULL;
|
|
}
|
|
}
|
|
FindHelpWindow(wnd);
|
|
if (ThisHelp != NULL)
|
|
ThisHelp->hwnd = NULL;
|
|
Helping = FALSE;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return BaseWndProc(HELPBOX, wnd, msg, p1, p2);
|
|
}
|
|
|
|
/* ----- select a new help window from its name ----- */
|
|
static void SelectHelp(DFWINDOW wnd, char *hname)
|
|
{
|
|
if (hname != NULL) {
|
|
DFWINDOW pwnd = GetParent(wnd);
|
|
DfPostMessage(wnd, ENDDIALOG, 0, 0);
|
|
DfPostMessage(pwnd, DISPLAY_HELP, (PARAM) hname, 0);
|
|
}
|
|
}
|
|
|
|
/* ---- PAINT message for the helpbox text editbox ---- */
|
|
static int PaintMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
|
|
{
|
|
struct keywords *thisword;
|
|
int rtn;
|
|
if (wnd->thisword != NULL) {
|
|
DFWINDOW pwnd = GetParent(wnd);
|
|
char *cp;
|
|
thisword = wnd->thisword;
|
|
cp = TextLine(wnd, thisword->lineno);
|
|
cp += thisword->off1;
|
|
*(cp+1) =
|
|
(pwnd->WindowColors[SELECT_COLOR][FG] & 255) | 0x80;
|
|
*(cp+2) =
|
|
(pwnd->WindowColors[SELECT_COLOR][BG] & 255) | 0x80;
|
|
rtn = DefaultWndProc(wnd, PAINT, p1, p2);
|
|
*(cp+1) =
|
|
(pwnd->WindowColors[HILITE_COLOR][FG] & 255) | 0x80;
|
|
*(cp+2) =
|
|
(pwnd->WindowColors[HILITE_COLOR][BG] & 255) | 0x80;
|
|
return rtn;
|
|
}
|
|
return DefaultWndProc(wnd, PAINT, p1, p2);
|
|
}
|
|
|
|
/* ---- LEFT_BUTTON message for the helpbox text editbox ---- */
|
|
static int LeftButtonMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
|
|
{
|
|
struct keywords *thisword;
|
|
int rtn, mx, my;
|
|
|
|
rtn = DefaultWndProc(wnd, LEFT_BUTTON, p1, p2);
|
|
mx = (int)p1 - GetClientLeft(wnd);
|
|
my = (int)p2 - GetClientTop(wnd);
|
|
my += wnd->wtop;
|
|
thisword = wnd->firstword;
|
|
while (thisword != NULL) {
|
|
if (my == thisword->lineno) {
|
|
if (mx >= thisword->off2 &&
|
|
mx < thisword->off3) {
|
|
wnd->thisword = thisword;
|
|
DfSendMessage(wnd, PAINT, 0, 0);
|
|
if (thisword->isDefinition) {
|
|
DFWINDOW pwnd = GetParent(wnd);
|
|
if (pwnd != NULL)
|
|
DisplayDefinition(GetParent(pwnd),
|
|
thisword->hname);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
thisword = thisword->nextword;
|
|
}
|
|
return rtn;
|
|
}
|
|
|
|
/* --- window processing module for HELPBOX's text EDITBOX -- */
|
|
int HelpTextProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
|
|
{
|
|
struct keywords *thisword;
|
|
switch (msg) {
|
|
case PAINT:
|
|
return PaintMsg(wnd, p1, p2);
|
|
case LEFT_BUTTON:
|
|
return LeftButtonMsg(wnd, p1, p2);
|
|
case DOUBLE_CLICK:
|
|
DfPostMessage(wnd, KEYBOARD, '\r', 0);
|
|
break;
|
|
case CLOSE_WINDOW:
|
|
thisword = wnd->firstword;
|
|
while (thisword != NULL) {
|
|
struct keywords *nextword = thisword->nextword;
|
|
if (thisword->hname != NULL)
|
|
free(thisword->hname);
|
|
free(thisword);
|
|
thisword = nextword;
|
|
}
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return DefaultWndProc(wnd, msg, p1, p2);
|
|
}
|
|
|
|
/* -------- read the help text into the editbox ------- */
|
|
static void ReadHelp(DFWINDOW wnd)
|
|
{
|
|
DFWINDOW cwnd = ControlWindow(wnd->extension, ID_HELPTEXT);
|
|
int linectr = 0;
|
|
if (cwnd == NULL)
|
|
return;
|
|
cwnd->wndproc = HelpTextProc;
|
|
/* ----- read the help text ------- */
|
|
while (TRUE) {
|
|
unsigned char *cp = hline, *cp1;
|
|
int colorct = 0;
|
|
if (GetHelpLine(hline) == NULL)
|
|
break;
|
|
if (*hline == '<')
|
|
break;
|
|
hline[strlen(hline)-1] = '\0';
|
|
/* --- add help text to the help window --- */
|
|
while (cp != NULL) {
|
|
if ((cp = strchr(cp, '[')) != NULL) {
|
|
/* ----- hit a new key word ----- */
|
|
struct keywords *thisword;
|
|
if (*(cp+1) != '.' && *(cp+1) != '*') {
|
|
cp++;
|
|
continue;
|
|
}
|
|
thisword = DFcalloc(1, sizeof(struct keywords));
|
|
if (cwnd->firstword == NULL)
|
|
cwnd->firstword = thisword;
|
|
if (cwnd->lastword != NULL) {
|
|
((struct keywords *)
|
|
(cwnd->lastword))->nextword = thisword;
|
|
thisword->prevword = cwnd->lastword;
|
|
}
|
|
cwnd->lastword = thisword;
|
|
thisword->lineno = cwnd->wlines;
|
|
thisword->off1 = (int) ((int)cp - (int)hline);
|
|
thisword->off2 = thisword->off1 - colorct * 4;
|
|
thisword->isDefinition = *(cp+1) == '*';
|
|
colorct++;
|
|
*cp++ = CHANGECOLOR;
|
|
*cp++ =
|
|
(wnd->WindowColors [HILITE_COLOR] [FG] & 255) | 0x80;
|
|
*cp++ =
|
|
(wnd->WindowColors [HILITE_COLOR] [BG] & 255) | 0x80;
|
|
cp1 = cp;
|
|
if ((cp = strchr(cp, ']')) != NULL) {
|
|
if (thisword != NULL)
|
|
thisword->off3 =
|
|
thisword->off2 + (int) (cp - cp1);
|
|
*cp++ = RESETCOLOR;
|
|
}
|
|
if ((cp = strchr(cp, '<')) != NULL) {
|
|
char *cp1 = strchr(cp, '>');
|
|
if (cp1 != NULL) {
|
|
int len = (int) ((int)cp1 - (int)cp);
|
|
thisword->hname = DFcalloc(1, len);
|
|
strncpy(thisword->hname, cp+1, len-1);
|
|
memmove(cp, cp1+1, strlen(cp1));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
PutItemText(wnd, ID_HELPTEXT, hline);
|
|
/* -- display help text as soon as window is full -- */
|
|
if (++linectr == ClientHeight(cwnd))
|
|
DfSendMessage(cwnd, PAINT, 0, 0);
|
|
if (linectr > ClientHeight(cwnd) &&
|
|
!TestAttribute(cwnd, VSCROLLBAR)) {
|
|
AddAttribute(cwnd, VSCROLLBAR);
|
|
DfSendMessage(cwnd, BORDER, 0, 0);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ---- compute the displayed length of a help text line --- */
|
|
static int HelpLength(char *s)
|
|
{
|
|
int len = strlen(s);
|
|
char *cp = strchr(s, '[');
|
|
while (cp != NULL) {
|
|
len -= 4;
|
|
cp = strchr(cp+1, '[');
|
|
}
|
|
cp = strchr(s, '<');
|
|
while (cp != NULL) {
|
|
char *cp1 = strchr(cp, '>');
|
|
if (cp1 != NULL)
|
|
len -= (int) (cp1-cp)+1;
|
|
cp = strchr(cp1, '<');
|
|
}
|
|
return len;
|
|
}
|
|
|
|
/* ----------- load the help text file ------------ */
|
|
void LoadHelpFile()
|
|
{
|
|
char *cp;
|
|
|
|
if (Helping)
|
|
return;
|
|
UnLoadHelpFile();
|
|
if ((helpfp = OpenHelpFile()) == NULL)
|
|
return;
|
|
*hline = '\0';
|
|
while (*hline != '<') {
|
|
if (GetHelpLine(hline) == NULL) {
|
|
fclose(helpfp);
|
|
return;
|
|
}
|
|
}
|
|
while (*hline == '<') {
|
|
if (strncmp(hline, "<end>", 5) == 0)
|
|
break;
|
|
|
|
/* -------- parse the help window's text name ----- */
|
|
if ((cp = strchr(hline, '>')) != NULL) {
|
|
ThisHelp = DFcalloc(1, sizeof(struct helps));
|
|
if (FirstHelp == NULL)
|
|
FirstHelp = ThisHelp;
|
|
*cp = '\0';
|
|
ThisHelp->hname=DFmalloc(strlen(hline+1)+1);
|
|
strcpy(ThisHelp->hname, hline+1);
|
|
|
|
HelpFilePosition(&ThisHelp->hptr, &ThisHelp->bit);
|
|
|
|
if (GetHelpLine(hline) == NULL)
|
|
break;
|
|
|
|
/* ------- build the help linked list entry --- */
|
|
while (*hline == '[') {
|
|
HelpFilePosition(&ThisHelp->hptr,
|
|
&ThisHelp->bit);
|
|
/* ---- parse the <<prev button pointer ---- */
|
|
if (strncmp(hline, "[<<]", 4) == 0) {
|
|
char *cp = strchr(hline+4, '<');
|
|
if (cp != NULL) {
|
|
char *cp1 = strchr(cp, '>');
|
|
if (cp1 != NULL) {
|
|
int len = (int) (cp1-cp);
|
|
ThisHelp->PrevName=DFcalloc(1,len);
|
|
strncpy(ThisHelp->PrevName,
|
|
cp+1,len-1);
|
|
}
|
|
}
|
|
if (GetHelpLine(hline) == NULL)
|
|
break;
|
|
continue;
|
|
}
|
|
/* ---- parse the next>> button pointer ---- */
|
|
else if (strncmp(hline, "[>>]", 4) == 0) {
|
|
char *cp = strchr(hline+4, '<');
|
|
if (cp != NULL) {
|
|
char *cp1 = strchr(cp, '>');
|
|
if (cp1 != NULL) {
|
|
int len = (int) (cp1-cp);
|
|
ThisHelp->NextName=DFcalloc(1,len);
|
|
strncpy(ThisHelp->NextName,
|
|
cp+1,len-1);
|
|
}
|
|
}
|
|
if (GetHelpLine(hline) == NULL)
|
|
break;
|
|
continue;
|
|
}
|
|
else
|
|
break;
|
|
}
|
|
ThisHelp->hheight = 0;
|
|
ThisHelp->hwidth = 0;
|
|
ThisHelp->NextHelp = NULL;
|
|
|
|
/* ------ append entry to the linked list ------ */
|
|
if (LastHelp != NULL)
|
|
LastHelp->NextHelp = ThisHelp;
|
|
LastHelp = ThisHelp;
|
|
}
|
|
/* -------- move to the next <helpname> token ------ */
|
|
if (GetHelpLine(hline) == NULL)
|
|
strcpy(hline, "<end>");
|
|
while (*hline != '<') {
|
|
ThisHelp->hwidth =
|
|
max(ThisHelp->hwidth, HelpLength(hline));
|
|
ThisHelp->hheight++;
|
|
if (GetHelpLine(hline) == NULL)
|
|
strcpy(hline, "<end>");
|
|
}
|
|
}
|
|
fclose(helpfp);
|
|
}
|
|
|
|
/* ------ free the memory used by the help file table ------ */
|
|
void UnLoadHelpFile(void)
|
|
{
|
|
while (FirstHelp != NULL) {
|
|
ThisHelp = FirstHelp;
|
|
if (ThisHelp->hname != NULL)
|
|
free(ThisHelp->hname);
|
|
if (ThisHelp->PrevName != NULL)
|
|
free(ThisHelp->PrevName);
|
|
if (ThisHelp->NextName != NULL)
|
|
free(ThisHelp->NextName);
|
|
FirstHelp = ThisHelp->NextHelp;
|
|
free(ThisHelp);
|
|
}
|
|
ThisHelp = LastHelp = NULL;
|
|
free(HelpTree);
|
|
HelpTree = NULL;
|
|
}
|
|
|
|
/* ---------- display a specified help text ----------- */
|
|
BOOL DisplayHelp(DFWINDOW wnd, char *Help)
|
|
{
|
|
BOOL rtn = FALSE;
|
|
if (Helping)
|
|
return TRUE;
|
|
wnd->isHelping++;
|
|
FindHelp(Help);
|
|
if (ThisHelp != NULL) {
|
|
if (LastStack == NULL ||
|
|
stricmp(Help, LastStack->hname)) {
|
|
/* ---- add the window to the history stack ---- */
|
|
ThisStack = DFcalloc(1,sizeof(struct HelpStack));
|
|
ThisStack->hname = DFmalloc(strlen(Help)+1);
|
|
if (ThisStack->hname != NULL)
|
|
strcpy(ThisStack->hname, Help);
|
|
ThisStack->PrevStack = LastStack;
|
|
LastStack = ThisStack;
|
|
}
|
|
if ((helpfp = OpenHelpFile()) != NULL) {
|
|
DBOX *db;
|
|
int offset, i;
|
|
|
|
db = DFcalloc(1,sizeof HelpBox);
|
|
memcpy(db, &HelpBox, sizeof HelpBox);
|
|
/* -- seek to the first line of the help text -- */
|
|
SeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
|
|
/* ----- read the title ----- */
|
|
GetHelpLine(hline);
|
|
hline[strlen(hline)-1] = '\0';
|
|
db->dwnd.title = DFmalloc(strlen(hline)+1);
|
|
strcpy(db->dwnd.title, hline);
|
|
/* ----- set the height and width ----- */
|
|
db->dwnd.h = min(ThisHelp->hheight, MAXHEIGHT)+7;
|
|
db->dwnd.w = max(45, ThisHelp->hwidth+6);
|
|
/* ------ position the help window ----- */
|
|
BestFit(wnd, &db->dwnd);
|
|
/* ------- position the command buttons ------ */
|
|
db->ctl[0].dwnd.w = max(40, ThisHelp->hwidth+2);
|
|
db->ctl[0].dwnd.h =
|
|
min(ThisHelp->hheight, MAXHEIGHT)+2;
|
|
offset = (db->dwnd.w-40) / 2;
|
|
for (i = 1; i < 5; i++) {
|
|
db->ctl[i].dwnd.y =
|
|
min(ThisHelp->hheight, MAXHEIGHT)+3;
|
|
db->ctl[i].dwnd.x += offset;
|
|
}
|
|
/* ---- disable ineffective buttons ---- */
|
|
if (ThisStack != NULL)
|
|
if (ThisStack->PrevStack == NULL)
|
|
DisableButton(db, ID_BACK);
|
|
if (ThisHelp->NextName == NULL)
|
|
DisableButton(db, ID_NEXT);
|
|
if (ThisHelp->PrevName == NULL)
|
|
DisableButton(db, ID_PREV);
|
|
/* ------- display the help window ----- */
|
|
DfDialogBox(NULL, db, TRUE, HelpBoxProc);
|
|
free(db);
|
|
fclose(helpfp);
|
|
rtn = TRUE;
|
|
}
|
|
}
|
|
--wnd->isHelping;
|
|
return rtn;
|
|
}
|
|
|
|
/* ------- display a definition window --------- */
|
|
static void DisplayDefinition(DFWINDOW wnd, char *def)
|
|
{
|
|
DFWINDOW dwnd;
|
|
DFWINDOW hwnd = wnd;
|
|
int y;
|
|
|
|
if (GetClass(wnd) == POPDOWNMENU)
|
|
hwnd = GetParent(wnd);
|
|
y = GetClass(hwnd) == MENUBAR ? 2 : 1;
|
|
FindHelp(def);
|
|
if (ThisHelp != NULL) {
|
|
if ((helpfp = OpenHelpFile()) != NULL) {
|
|
dwnd = DfCreateWindow(
|
|
TEXTBOX,
|
|
NULL,
|
|
GetClientLeft(hwnd),
|
|
GetClientTop(hwnd)+y,
|
|
min(ThisHelp->hheight, MAXHEIGHT)+3,
|
|
ThisHelp->hwidth+2,
|
|
NULL,
|
|
wnd,
|
|
NULL,
|
|
HASBORDER | NOCLIP | SAVESELF);
|
|
if (dwnd != NULL) {
|
|
/* ----- read the help text ------- */
|
|
SeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
|
|
while (TRUE) {
|
|
if (GetHelpLine(hline) == NULL)
|
|
break;
|
|
if (*hline == '<')
|
|
break;
|
|
hline[strlen(hline)-1] = '\0';
|
|
DfSendMessage(dwnd,ADDTEXT,(PARAM)hline,0);
|
|
}
|
|
DfSendMessage(dwnd, SHOW_WINDOW, 0, 0);
|
|
DfSendMessage(NULL, WAITKEYBOARD, 0, 0);
|
|
DfSendMessage(NULL, WAITMOUSE, 0, 0);
|
|
DfSendMessage(dwnd, CLOSE_WINDOW, 0, 0);
|
|
}
|
|
fclose(helpfp);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* ------ compare help names with wild cards ----- */
|
|
static BOOL wildcmp(char *s1, char *s2)
|
|
{
|
|
while (*s1 || *s2) {
|
|
if (tolower(*s1) != tolower(*s2))
|
|
if (*s1 != '?' && *s2 != '?')
|
|
return TRUE;
|
|
s1++, s2++;
|
|
}
|
|
return FALSE;
|
|
}
|
|
|
|
/* --- ThisHelp = the help window matching specified name --- */
|
|
static void FindHelp(char *Help)
|
|
{
|
|
ThisHelp = FirstHelp;
|
|
while (ThisHelp != NULL) {
|
|
if (wildcmp(Help, ThisHelp->hname) == FALSE)
|
|
break;
|
|
ThisHelp = ThisHelp->NextHelp;
|
|
}
|
|
}
|
|
|
|
/* --- ThisHelp = the help window matching specified wnd --- */
|
|
static void FindHelpWindow(DFWINDOW wnd)
|
|
{
|
|
ThisHelp = FirstHelp;
|
|
while (ThisHelp != NULL) {
|
|
if (wnd == ThisHelp->hwnd)
|
|
break;
|
|
ThisHelp = ThisHelp->NextHelp;
|
|
}
|
|
}
|
|
|
|
static int OverLap(int a, int b)
|
|
{
|
|
int ov = a - b;
|
|
if (ov < 0)
|
|
ov = 0;
|
|
return ov;
|
|
}
|
|
|
|
/* ----- compute the best location for a help dialogbox ----- */
|
|
static void BestFit(DFWINDOW wnd, DIALOGWINDOW *dwnd)
|
|
{
|
|
int above, below, right, left;
|
|
if (GetClass(wnd) == MENUBAR ||
|
|
GetClass(wnd) == APPLICATION) {
|
|
dwnd->x = dwnd->y = -1;
|
|
return;
|
|
}
|
|
/* --- compute above overlap ---- */
|
|
above = OverLap(dwnd->h, GetTop(wnd));
|
|
/* --- compute below overlap ---- */
|
|
below = OverLap(GetBottom(wnd), DfGetScreenHeight()-dwnd->h);
|
|
/* --- compute right overlap ---- */
|
|
right = OverLap(GetRight(wnd), DfGetScreenWidth()-dwnd->w);
|
|
/* --- compute left overlap ---- */
|
|
left = OverLap(dwnd->w, GetLeft(wnd));
|
|
|
|
if (above < below)
|
|
dwnd->y = max(0, GetTop(wnd)-dwnd->h-2);
|
|
else
|
|
dwnd->y = min(DfGetScreenHeight()-dwnd->h, GetBottom(wnd)+2);
|
|
if (right < left)
|
|
dwnd->x = min(GetRight(wnd)+2, DfGetScreenWidth()-dwnd->w);
|
|
else
|
|
dwnd->x = max(0, GetLeft(wnd)-dwnd->w-2);
|
|
|
|
if (dwnd->x == GetRight(wnd)+2 ||
|
|
dwnd->x == GetLeft(wnd)-dwnd->w-2)
|
|
dwnd->y = -1;
|
|
if (dwnd->y ==GetTop(wnd)-dwnd->h-2 ||
|
|
dwnd->y == GetBottom(wnd)+2)
|
|
dwnd->x = -1;
|
|
}
|
|
|
|
/* EOF */
|