ApfelTeeSaft/reactos
1
0
Fork 0
mirror of https://github.com/ApfelTeeSaft/reactos.git synced 2026-09-03 04:13:31 +00:00
Code Issues Packages Projects Releases Wiki Activity

- Remove dflat32. It doesn't start up in Windows XP at all (when launching edit.exe nothing happens).

Browse Source 
- Remove dflat32.dll, no active work on it since 2002.

<[Tycho]>: Fireball ustroil subbotnik.

svn path=/trunk/; revision=40346
This commit is contained in:
Aleksey Bragin
2009-04-03 09:41:09 +00:00
parent f3b33304fe
commit 238cd262d0
107 changed files with 0 additions and 28120 deletions
Download Patch File Download Diff File Expand all files Collapse all files
rosapps/dflat32/applicat.c
-622
View File
@@ -1,622 +0,0 @@
/* ------------- applicat.c ------------- */
#include "dflat.h"
static BOOL DisplayModified = FALSE;
DFWINDOW DfApplicationWindow;
extern DF_DBOX Display;
extern DF_DBOX Windows;
#ifdef INCLUDE_LOGGING
extern DF_DBOX Log;
#endif
#ifdef INCLUDE_SHELLDOS
static void ShellDOS(DFWINDOW);
#endif
static void DfCreateMenu(DFWINDOW);
static void CreateStatusBar(DFWINDOW);
static void SelectColors(DFWINDOW);
#ifdef INCLUDE_WINDOWOPTIONS
static void SelectTexture(void);
static void SelectBorder(DFWINDOW);
static void SelectTitle(DFWINDOW);
static void SelectStatusBar(DFWINDOW);
#endif
static DFWINDOW oldFocus;
#ifdef INCLUDE_MULTI_WINDOWS
static void CloseAll(DFWINDOW, int);
static void MoreWindows(DFWINDOW);
static void ChooseWindow(DFWINDOW, int);
static int WindowSel;
static char Menus[9][26] =
{
"~1. ",
"~2. ",
"~3. ",
"~4. ",
"~5. ",
"~6. ",
"~7. ",
"~8. ",
"~9. "
};
#endif
/* --------------- DFM_CREATE_WINDOW Message -------------- */
static int CreateWindowMsg(DFWINDOW wnd)
{
int rtn;
DfApplicationWindow = wnd;
#ifdef INCLUDE_WINDOWOPTIONS
if (DfCfg.Border)
DfSetCheckBox(&Display, DF_ID_BORDER);
if (DfCfg.Title)
DfSetCheckBox(&Display, DF_ID_TITLE);
if (DfCfg.StatusBar)
DfSetCheckBox(&Display, DF_ID_STATUSBAR);
if (DfCfg.Texture)
DfSetCheckBox(&Display, DF_ID_TEXTURE);
#endif
SelectColors(wnd);
#ifdef INCLUDE_WINDOWOPTIONS
SelectBorder(wnd);
SelectTitle(wnd);
SelectStatusBar(wnd);
#endif
rtn = DfBaseWndProc(DF_APPLICATION, wnd, DFM_CREATE_WINDOW, 0, 0);
if (wnd->extension != NULL)
DfCreateMenu(wnd);
CreateStatusBar(wnd);
return rtn;
}
/* --------- DFM_ADDSTATUS Message ---------- */
static void AddStatusMsg(DFWINDOW wnd, DF_PARAM p1)
{
if (wnd->StatusBar != NULL) {
if (p1 && *(char *)p1)
DfSendMessage(wnd->StatusBar, DFM_SETTEXT, p1, 0);
else
DfSendMessage(wnd->StatusBar, DFM_CLEARTEXT, 0, 0);
DfSendMessage(wnd->StatusBar, DFM_PAINT, 0, 0);
}
}
/* -------- DFM_SETFOCUS Message -------- */
static void SetFocusMsg(DFWINDOW wnd, BOOL p1)
{
if (p1)
DfSendMessage(DfInFocus, DFM_SETFOCUS, FALSE, 0);
DfInFocus = p1 ? wnd : NULL;
if (DfIsVisible(wnd))
DfSendMessage(wnd, DFM_BORDER, 0, 0);
else
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
}
/* ------- SIZE Message -------- */
static void SizeMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
BOOL WasVisible;
WasVisible = DfIsVisible(wnd);
if (WasVisible)
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
if (p1-DfGetLeft(wnd) < 30)
p1 = DfGetLeft(wnd) + 30;
DfBaseWndProc(DF_APPLICATION, wnd, DFM_DFM_SIZE, p1, p2);
DfCreateMenu(wnd);
CreateStatusBar(wnd);
if (WasVisible)
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
}
/* ----------- DFM_KEYBOARD Message ------------ */
static int KeyboardMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
if (DfWindowMoving || DfWindowSizing || (int) p1 == DF_F1)
return DfBaseWndProc(DF_APPLICATION, wnd, DFM_KEYBOARD, p1, p2);
switch ((int) p1) {
case DF_ALT_F4:
DfPostMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
return TRUE;
#ifdef INCLUDE_MULTI_WINDOWS
case DF_ALT_F6:
DfSetNextFocus();
return TRUE;
#endif
case DF_ALT_HYPHEN:
DfBuildSystemMenu(wnd);
return TRUE;
default:
break;
}
DfPostMessage(wnd->MenuBarWnd, DFM_KEYBOARD, p1, p2);
return TRUE;
}
/* --------- DFM_SHIFT_CHANGED Message -------- */
static void ShiftChangedMsg(DFWINDOW wnd, DF_PARAM p1)
{
extern BOOL AltDown;
if ((int)p1 & DF_ALTKEY)
AltDown = TRUE;
else if (AltDown) {
AltDown = FALSE;
if (wnd->MenuBarWnd != DfInFocus)
DfSendMessage(NULL, DFM_HIDE_CURSOR, 0, 0);
DfSendMessage(wnd->MenuBarWnd, DFM_KEYBOARD, DF_F10, 0);
}
}
/* -------- COMMAND Message ------- */
static void CommandMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
switch ((int)p1) {
case DF_ID_HELP:
DfDisplayHelp(wnd, DFlatApplication);
break;
case DF_ID_HELPHELP:
DfDisplayHelp(wnd, "HelpHelp");
break;
case DF_ID_EXTHELP:
DfDisplayHelp(wnd, "ExtHelp");
break;
case DF_ID_KEYSHELP:
DfDisplayHelp(wnd, "KeysHelp");
break;
case DF_ID_HELPINDEX:
DfDisplayHelp(wnd, "HelpIndex");
break;
#ifdef TESTING_DFLAT
case DF_ID_LOADHELP:
DfLoadHelpFile();
break;
#endif
#ifdef INCLUDE_LOGGING
case DF_ID_LOG:
DfMessageLog(wnd);
break;
#endif
#ifdef INCLUDE_SHELLDOS
case DF_ID_DOS:
ShellDOS(wnd);
break;
#endif
case DF_ID_EXIT:
case DF_ID_SYSCLOSE:
DfPostMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
break;
case DF_ID_DISPLAY:
if (DfDialogBox(wnd, &Display, TRUE, NULL)) {
if (DfInFocus == wnd->MenuBarWnd || DfInFocus == wnd->StatusBar)
oldFocus = DfApplicationWindow;
else
oldFocus = DfInFocus;
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
SelectColors(wnd);
#ifdef INCLUDE_WINDOWOPTIONS
SelectBorder(wnd);
SelectTitle(wnd);
SelectStatusBar(wnd);
SelectTexture();
#endif
DfCreateMenu(wnd);
CreateStatusBar(wnd);
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
DfSendMessage(oldFocus, DFM_SETFOCUS, TRUE, 0);
}
break;
case DF_ID_SAVEOPTIONS:
DfSaveConfig();
break;
#ifdef INCLUDE_MULTI_WINDOWS
case DF_ID_WINDOW:
ChooseWindow(wnd, (int)p2-2);
break;
case DF_ID_CLOSEALL:
CloseAll(wnd, FALSE);
break;
case DF_ID_MOREWINDOWS:
MoreWindows(wnd);
break;
#endif
#ifdef INCLUDE_RESTORE
case DF_ID_SYSRESTORE:
#endif
case DF_ID_SYSMOVE:
case DF_ID_SYSSIZE:
#ifdef INCLUDE_MINIMIZE
case DF_ID_SYSMINIMIZE:
#endif
#ifdef INCLUDE_MAXIMIZE
case DF_ID_SYSMAXIMIZE:
#endif
DfBaseWndProc(DF_APPLICATION, wnd, DFM_COMMAND, p1, p2);
break;
default:
if (DfInFocus != wnd->MenuBarWnd && DfInFocus != wnd)
DfPostMessage(DfInFocus, DFM_COMMAND, p1, p2);
break;
}
}
/* --------- DFM_CLOSE_WINDOW Message -------- */
static int CloseWindowMsg(DFWINDOW wnd)
{
int rtn;
#ifdef INCLUDE_MULTI_WINDOWS
CloseAll(wnd, TRUE);
WindowSel = 0;
#endif
DfPostMessage(NULL, DFM_STOP, 0, 0);
rtn = DfBaseWndProc(DF_APPLICATION, wnd, DFM_CLOSE_WINDOW, 0, 0);
DfUnLoadHelpFile();
DisplayModified = FALSE;
DfApplicationWindow = NULL;
return rtn;
}
/* --- DF_APPLICATION Window Class window processing module --- */
int DfApplicationProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg)
{
case DFM_CREATE_WINDOW:
return CreateWindowMsg(wnd);
case DFM_HIDE_WINDOW:
if (wnd == DfInFocus)
DfInFocus = NULL;
break;
case DFM_ADDSTATUS:
AddStatusMsg(wnd, p1);
return TRUE;
case DFM_SETFOCUS:
if ((int)p1 == (DfInFocus != wnd)) {
SetFocusMsg(wnd, (BOOL) p1);
return TRUE;
}
break;
case DFM_DFM_SIZE:
SizeMsg(wnd, p1, p2);
return TRUE;
#ifdef INCLUDE_MINIMIZE
case DFM_MINIMIZE:
return TRUE;
#endif
case DFM_KEYBOARD:
return KeyboardMsg(wnd, p1, p2);
case DFM_SHIFT_CHANGED:
ShiftChangedMsg(wnd, p1);
return TRUE;
case DFM_PAINT:
if (DfIsVisible(wnd)) {
#ifdef INCLUDE_WINDOWOPTIONS
int cl = DfCfg.Texture ? DF_APPLCHAR : ' ';
#else
int cl = DF_APPLCHAR;
#endif
DfClearWindow(wnd, (DFRECT *)p1, cl);
}
return TRUE;
case DFM_COMMAND:
CommandMsg(wnd, p1, p2);
return TRUE;
case DFM_CLOSE_WINDOW:
return CloseWindowMsg(wnd);
default:
break;
}
return DfBaseWndProc(DF_APPLICATION, wnd, msg, p1, p2);
}
#ifdef INCLUDE_SHELLDOS
static void SwitchCursor(void)
{
DfSendMessage(NULL, DFM_SAVE_CURSOR, 0, 0);
DfSwapCursorStack();
DfSendMessage(NULL, DFM_RESTORE_CURSOR, 0, 0);
}
/* ------- Shell out to DOS ---------- */
static void ShellDOS(DFWINDOW wnd)
{
oldFocus = DfInFocus;
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
SwitchCursor();
printf("To return to %s, execute the DOS exit command.",
DFlatApplication);
fflush(stdout);
_spawnl(P_WAIT, getenv("COMSPEC"), " ", NULL);
SwitchCursor();
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
DfSendMessage(oldFocus, DFM_SETFOCUS, TRUE, 0);
}
#endif
/* -------- Create the menu bar -------- */
static void DfCreateMenu(DFWINDOW wnd)
{
DfAddAttribute(wnd, DF_HASMENUBAR);
if (wnd->MenuBarWnd != NULL)
DfSendMessage(wnd->MenuBarWnd, DFM_CLOSE_WINDOW, 0, 0);
wnd->MenuBarWnd = DfDfCreateWindow(DF_MENUBAR,
NULL,
DfGetClientLeft(wnd),
DfGetClientTop(wnd)-1,
1,
DfClientWidth(wnd),
NULL,
wnd,
NULL,
0);
DfSendMessage(wnd->MenuBarWnd,DFM_BUILDMENU,
(DF_PARAM)wnd->extension,0);
DfAddAttribute(wnd->MenuBarWnd, DF_VISIBLE);
}
/* ----------- Create the status bar ------------- */
static void CreateStatusBar(DFWINDOW wnd)
{
if (wnd->StatusBar != NULL) {
DfSendMessage(wnd->StatusBar, DFM_CLOSE_WINDOW, 0, 0);
wnd->StatusBar = NULL;
}
if (DfTestAttribute(wnd, DF_HASSTATUSBAR)) {
wnd->StatusBar = DfDfCreateWindow(DF_STATUSBAR,
NULL,
DfGetClientLeft(wnd),
DfGetBottom(wnd),
1,
DfClientWidth(wnd),
NULL,
wnd,
NULL,
0);
DfAddAttribute(wnd->StatusBar, DF_VISIBLE);
}
}
#ifdef INCLUDE_MULTI_WINDOWS
/* -------- return the name of a document window ------- */
static char *WindowName(DFWINDOW wnd)
{
if (DfGetTitle(wnd) == NULL)
{
if (DfGetClass(wnd) == DF_DIALOG)
return ((DF_DBOX *)(wnd->extension))->HelpName;
else
return "Untitled";
}
else
return DfGetTitle(wnd);
}
/* ----------- Prepare the Window menu ------------ */
void DfPrepWindowMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
struct DfPopDown *p0 = mnu->Selections;
struct DfPopDown *pd = mnu->Selections + 2;
struct DfPopDown *ca = mnu->Selections + 13;
int MenuNo = 0;
DFWINDOW cwnd;
mnu->Selection = 0;
oldFocus = NULL;
if (DfGetClass(wnd) != DF_APPLICATION)
{
oldFocus = wnd;
/* point to the DF_APPLICATION window */
if (DfApplicationWindow == NULL)
return;
cwnd = DfFirstWindow(DfApplicationWindow);
/* get the first 9 document windows */
while (cwnd != NULL && MenuNo < 9)
{
if (DfGetClass(cwnd) != DF_MENUBAR &&
DfGetClass(cwnd) != DF_STATUSBAR)
{
/* add the document window to the menu */
strncpy (Menus[MenuNo]+4, WindowName(cwnd), 20);
pd->SelectionTitle = Menus[MenuNo];
if (cwnd == oldFocus)
{
/* mark the current document */
pd->Attrib |= DF_CHECKED;
mnu->Selection = MenuNo+2;
}
else
pd->Attrib &= ~DF_CHECKED;
pd++;
MenuNo++;
}
cwnd = DfNextWindow(cwnd);
}
}
if (MenuNo)
p0->SelectionTitle = "~Close all";
else
p0->SelectionTitle = NULL;
if (MenuNo >= 9)
{
*pd++ = *ca;
if (mnu->Selection == 0)
mnu->Selection = 11;
}
pd->SelectionTitle = NULL;
}
/* window processing module for the More Windows dialog box */
static int WindowPrep(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
switch (msg) {
case DFM_INITIATE_DIALOG: {
DFWINDOW wnd1;
DFWINDOW cwnd = DfControlWindow(&Windows,DF_ID_WINDOWLIST);
int sel = 0;
if (cwnd == NULL)
return FALSE;
wnd1 = DfFirstWindow(DfApplicationWindow);
while (wnd1 != NULL) {
if (wnd1 != wnd && DfGetClass(wnd1) != DF_MENUBAR &&
DfGetClass(wnd1) != DF_STATUSBAR) {
if (wnd1 == oldFocus)
WindowSel = sel;
DfSendMessage(cwnd, DFM_ADDTEXT,
(DF_PARAM) WindowName(wnd1), 0);
sel++;
}
wnd1 = DfNextWindow(wnd1);
}
DfSendMessage(cwnd, DFM_LB_SETSELECTION, WindowSel, 0);
DfAddAttribute(cwnd, DF_VSCROLLBAR);
DfPostMessage(cwnd, DFM_SHOW_WINDOW, 0, 0);
break;
}
case DFM_COMMAND:
switch ((int) p1) {
case DF_ID_OK:
if ((int)p2 == 0)
WindowSel = DfSendMessage(
DfControlWindow(&Windows,
DF_ID_WINDOWLIST),
DFM_LB_CURRENTSELECTION, 0, 0);
break;
case DF_ID_WINDOWLIST:
if ((int) p2 == DFM_LB_CHOOSE)
DfSendMessage(wnd, DFM_COMMAND, DF_ID_OK, 0);
break;
default:
break;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* ---- the More Windows command on the Window menu ---- */
static void MoreWindows(DFWINDOW wnd)
{
if (DfDialogBox(wnd, &Windows, TRUE, WindowPrep))
ChooseWindow(wnd, WindowSel);
}
/* ----- user chose a window from the Window menu
or the More Window dialog box ----- */
static void ChooseWindow(DFWINDOW wnd, int WindowNo)
{
DFWINDOW cwnd = DfFirstWindow(wnd);
while (cwnd != NULL)
{
if (DfGetClass(cwnd) != DF_MENUBAR &&
DfGetClass(cwnd) != DF_STATUSBAR)
if (WindowNo-- == 0)
break;
cwnd = DfNextWindow(cwnd);
}
if (cwnd != NULL) {
DfSendMessage(cwnd, DFM_SETFOCUS, TRUE, 0);
if (cwnd->condition == DF_ISMINIMIZED)
DfSendMessage(cwnd, DFM_RESTORE, 0, 0);
}
}
/* ----- Close all document windows ----- */
static void CloseAll(DFWINDOW wnd, int closing)
{
DFWINDOW wnd1, wnd2;
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
wnd1 = DfLastWindow(wnd);
while (wnd1 != NULL)
{
wnd2 = DfPrevWindow(wnd1);
if (DfGetClass(wnd1) != DF_MENUBAR && DfGetClass(wnd1) != DF_STATUSBAR)
{
DfClearVisible(wnd1);
DfSendMessage(wnd1, DFM_CLOSE_WINDOW, 0, 0);
}
wnd1 = wnd2;
}
if (!closing)
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
#endif /* #ifdef INCLUDE_MULTI_WINDOWS */
static void DoWindowColors(DFWINDOW wnd)
{
DFWINDOW cwnd;
DfInitWindowColors(wnd);
cwnd = DfFirstWindow(wnd);
while (cwnd != NULL)
{
DoWindowColors(cwnd);
if (DfGetClass(cwnd) == DF_TEXT && DfGetText(cwnd) != NULL)
DfSendMessage(cwnd, DFM_CLEARTEXT, 0, 0);
cwnd = DfNextWindow(cwnd);
}
}
/* set up colors for the application window */
static void SelectColors(DFWINDOW wnd)
{
memcpy(DfCfg.clr, DfColor, sizeof DfColor);
DoWindowColors(wnd);
}
#ifdef INCLUDE_WINDOWOPTIONS
/* ----- select the screen texture ----- */
static void SelectTexture(void)
{
DfCfg.Texture = DfCheckBoxSetting(&Display, DF_ID_TEXTURE);
}
/* -- select whether the application screen has a border -- */
static void SelectBorder(DFWINDOW wnd)
{
DfCfg.Border = DfCheckBoxSetting(&Display, DF_ID_BORDER);
if (DfCfg.Border)
DfAddAttribute(wnd, DF_HASBORDER);
else
DfClearAttribute(wnd, DF_HASBORDER);
}
/* select whether the application screen has a status bar */
static void SelectStatusBar(DFWINDOW wnd)
{
DfCfg.StatusBar = DfCheckBoxSetting(&Display, DF_ID_STATUSBAR);
if (DfCfg.StatusBar)
DfAddAttribute(wnd, DF_HASSTATUSBAR);
else
DfClearAttribute(wnd, DF_HASSTATUSBAR);
}
/* select whether the application screen has a title bar */
static void SelectTitle(DFWINDOW wnd)
{
DfCfg.Title = DfCheckBoxSetting(&Display, DF_ID_TITLE);
if (DfCfg.Title)
DfAddAttribute(wnd, DF_HASTITLEBAR);
else
DfClearAttribute(wnd, DF_HASTITLEBAR);
}
#endif
/* EOF */
rosapps/dflat32/barchart.c
-74
View File
@@ -1,74 +0,0 @@
/* ------------ barchart.c ----------- */
#include "dflat.h"
#define BCHEIGHT 12
#define BCWIDTH 44
#define COLWIDTH 4
static DFWINDOW Bwnd;
/* ------- project schedule array ------- */
static struct ProjChart {
char *prj;
int start, stop;
} projs[] = {
{"Center St", 0,3},
{"City Hall", 0,5},
{"Rt 395 ", 1,4},
{"Sky Condo", 2,3},
{"Out Hs ", 0,4},
{"Bk Palace", 1,5}
};
static char *Title = " PROJECT SCHEDULE";
static char *Months = " Jan Feb Mar Apr May Jun";
static int BarChartProc(DFWINDOW wnd, DFMESSAGE msg,
DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_COMMAND:
if ((int)p1 == DF_ID_HELP) {
DfDisplayHelp(wnd, "BarChart");
return TRUE;
}
break;
case DFM_CLOSE_WINDOW:
Bwnd = NULL;
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
void BarChart(DFWINDOW pwnd)
{
int pct = sizeof projs / sizeof(struct ProjChart);
int i;
if (Bwnd == NULL) {
Bwnd = DfDfCreateWindow(DF_PICTUREBOX,
"BarChart",
-1, -1, BCHEIGHT, BCWIDTH,
NULL, pwnd, BarChartProc,
DF_SHADOW |
DF_CONTROLBOX |
DF_MOVEABLE |
DF_HASBORDER
);
DfSendMessage(Bwnd, DFM_ADDTEXT, (DF_PARAM) Title, 0);
DfSendMessage(Bwnd, DFM_ADDTEXT, (DF_PARAM) "", 0);
for (i = 0; i < pct; i++) {
DfSendMessage(Bwnd,DFM_ADDTEXT,(DF_PARAM)projs[i].prj,0);
DfDrawBar(Bwnd, DF_SOLIDBAR+(i%4),
11+projs[i].start*COLWIDTH, 2+i,
(1 + projs[i].stop-projs[i].start) * COLWIDTH,
TRUE);
}
DfSendMessage(Bwnd, DFM_ADDTEXT, (DF_PARAM) "", 0);
DfSendMessage(Bwnd, DFM_ADDTEXT, (DF_PARAM) Months, 0);
DfDrawBox(Bwnd, 10, 1, pct+2, 25);
}
DfSendMessage(Bwnd, DFM_SETFOCUS, TRUE, 0);
}
rosapps/dflat32/box.c
-44
View File
@@ -1,44 +0,0 @@
/* ----------- box.c ------------ */
#include "dflat.h"
int DfBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DFWINDOW oldFocus;
DF_CTLWINDOW *ct = DfGetControl(wnd);
static BOOL SettingFocus = FALSE;
if (ct != NULL)
{
switch (msg)
{
case DFM_SETFOCUS:
SettingFocus = DfIsVisible(wnd);
rtn = DfBaseWndProc(DF_BOX, wnd, msg, p1, p2);
SettingFocus = FALSE;
return rtn;
case DFM_PAINT:
return FALSE;
case DFM_LEFT_BUTTON:
case DFM_BUTTON_RELEASED:
return DfSendMessage(DfGetParent(wnd), msg, p1, p2);
case DFM_BORDER:
if (SettingFocus)
return TRUE;
oldFocus = DfInFocus;
DfInFocus = NULL;
rtn = DfBaseWndProc(DF_BOX, wnd, msg, p1, p2);
DfInFocus = oldFocus;
if (ct != NULL)
if (ct->itext != NULL)
DfWriteLine(wnd, ct->itext, 1, 0, FALSE);
return rtn;
default:
break;
}
}
return DfBaseWndProc(DF_BOX, wnd, msg, p1, p2);
}
/* EOF */
rosapps/dflat32/button.c
-92
View File
@@ -1,92 +0,0 @@
/* -------------- button.c -------------- */
#include "dflat.h"
void PaintMsg(DFWINDOW wnd, DF_CTLWINDOW *ct, DFRECT *rc)
{
if (DfIsVisible(wnd))
{
if (DfTestAttribute(wnd, DF_SHADOW))
{
/* -------- draw the button's shadow ------- */
int x;
DfBackground = DfWndBackground(DfGetParent(wnd));
DfForeground = BLACK;
for (x = 1; x <= DfWindowWidth(wnd); x++)
DfWPutch(wnd, (char)223, x, 1);
DfWPutch(wnd, (char)220, DfWindowWidth(wnd), 0);
}
if (ct->itext != NULL)
{
char *txt;
txt = DfCalloc(1, strlen(ct->itext)+10);
if (ct->setting == DF_OFF) {
txt[0] = DF_CHANGECOLOR;
txt[1] = wnd->WindowColors
[DF_HILITE_COLOR] [DF_FG] | 0x80;
txt[2] = wnd->WindowColors
[DF_STD_COLOR] [DF_BG] | 0x80;
}
DfCopyCommand(txt+strlen(txt),ct->itext,!ct->setting,
DfWndBackground(wnd));
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM) txt, 0);
free(txt);
}
/* --------- write the button's text ------- */
DfWriteTextLine(wnd, rc, 0, wnd == DfInFocus);
}
}
void LeftButtonMsg(DFWINDOW wnd, DFMESSAGE msg, DF_CTLWINDOW *ct)
{
/* --------- draw a pushed button -------- */
int x;
DfBackground = DfWndBackground(DfGetParent(wnd));
DfForeground = DfWndBackground(wnd);
DfWPutch(wnd, ' ', 0, 0);
for (x = 0; x < DfWindowWidth(wnd); x++)
{
DfWPutch(wnd, (char)220, x+1, 0);
DfWPutch(wnd, (char)223, x+1, 1);
}
if (msg == DFM_LEFT_BUTTON)
DfSendMessage(NULL, DFM_WAITMOUSE, 0, 0);
else
DfSendMessage(NULL, DFM_WAITKEYBOARD, 0, 0);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
if (ct->setting == DF_ON)
DfPostMessage(DfGetParent(wnd), DFM_COMMAND, ct->command, 0);
else
DfBeep();
}
int DfButtonProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
DF_CTLWINDOW *ct = DfGetControl(wnd);
if (ct != NULL) {
switch (msg) {
case DFM_SETFOCUS:
DfBaseWndProc(DF_BUTTON, wnd, msg, p1, p2);
p1 = 0;
/* ------- fall through ------- */
case DFM_PAINT:
PaintMsg(wnd, ct, (DFRECT*)p1);
return TRUE;
case DFM_KEYBOARD:
if (p1 != '\r')
break;
/* ---- fall through ---- */
case DFM_LEFT_BUTTON:
LeftButtonMsg(wnd, msg, ct);
return TRUE;
case DFM_HORIZSCROLL:
return TRUE;
default:
break;
}
}
return DfBaseWndProc(DF_BUTTON, wnd, msg, p1, p2);
}
/* EOF */
rosapps/dflat32/calendar.c
-185
View File
@@ -1,185 +0,0 @@
/* ------------- calendar.c ------------- */
#include "dflat.h"
#define CALHEIGHT 17
#define CALWIDTH 33
static int DyMo[] = {31,28,31,30,31,30,31,31,30,31,30,31};
static struct tm ttm;
static int dys[42];
static DFWINDOW Cwnd;
static void FixDate(void)
{
/* ---- adjust Feb for leap year ---- */
if (ttm.tm_year % 4 == 0)
{
if (ttm.tm_year % 100 == 0)
{
if (ttm.tm_year % 400 == 0)
{
DyMo[1] = 29;
}
else
{
DyMo[1] = 28;
}
}
else
{
DyMo[1] = 29;
}
}
else
{
DyMo[1] = 28;
}
ttm.tm_mday = min(ttm.tm_mday, DyMo[ttm.tm_mon]);
}
/* ---- build calendar dates array ---- */
static void BuildDateArray(void)
{
int offset, dy = 0;
memset(dys, 0, sizeof dys);
FixDate();
/* ----- compute the weekday for the 1st ----- */
offset = ((ttm.tm_mday-1) - ttm.tm_wday) % 7;
if (offset < 0)
offset += 7;
if (offset)
offset = (offset - 7) * -1;
/* ----- build the dates into the array ---- */
for (dy = 1; dy <= DyMo[ttm.tm_mon]; dy++)
dys[offset++] = dy;
}
static void CreateWindowMsg(DFWINDOW wnd)
{
int x, y;
DfDrawBox(wnd, 1, 2, CALHEIGHT-4, CALWIDTH-4);
for (x = 5; x < CALWIDTH-4; x += 4)
DfDrawVector(wnd, x, 2, CALHEIGHT-4, FALSE);
for (y = 4; y < CALHEIGHT-3; y+=2)
DfDrawVector(wnd, 1, y, CALWIDTH-4, TRUE);
}
static void DisplayDates(DFWINDOW wnd)
{
int week, day;
char dyln[10];
int offset;
char banner[CALWIDTH-1];
char banner1[30];
DfSetStandardColor(wnd);
DfPutWindowLine(wnd, "Sun Mon Tue Wed Thu Fri Sat", 2, 1);
memset(banner, ' ', CALWIDTH-2);
strftime(banner1, 16, "%B, %Y", &ttm);
offset = (CALWIDTH-2 - strlen(banner1)) / 2;
strcpy(banner+offset, banner1);
strcat(banner, " ");
DfPutWindowLine(wnd, banner, 0, 0);
BuildDateArray();
for (week = 0; week < 6; week++) {
for (day = 0; day < 7; day++) {
int dy = dys[week*7+day];
if (dy == 0)
strcpy(dyln, " ");
else {
if (dy == ttm.tm_mday)
sprintf(dyln, "%c%c%c%2d %c",
DF_CHANGECOLOR,
DfSelectForeground(wnd)+0x80,
DfSelectBackground(wnd)+0x80,
dy, DF_RESETCOLOR);
else
sprintf(dyln, "%2d ", dy);
}
DfSetStandardColor(wnd);
DfPutWindowLine(wnd, dyln, 2 + day * 4, 3 + week*2);
}
}
}
static int KeyboardMsg(DFWINDOW wnd, DF_PARAM p1)
{
switch ((int)p1) {
case DF_PGUP:
if (ttm.tm_mon == 0) {
ttm.tm_mon = 12;
ttm.tm_year--;
}
ttm.tm_mon--;
FixDate();
mktime(&ttm);
DisplayDates(wnd);
return TRUE;
case DF_PGDN:
ttm.tm_mon++;
if (ttm.tm_mon == 12) {
ttm.tm_mon = 0;
ttm.tm_year++;
}
FixDate();
mktime(&ttm);
DisplayDates(wnd);
return TRUE;
default:
break;
}
return FALSE;
}
static int CalendarProc(DFWINDOW wnd,DFMESSAGE msg,
DF_PARAM p1,DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
DfDefaultWndProc(wnd, msg, p1, p2);
CreateWindowMsg(wnd);
return TRUE;
case DFM_KEYBOARD:
if (KeyboardMsg(wnd, p1))
return TRUE;
break;
case DFM_PAINT:
DfDefaultWndProc(wnd, msg, p1, p2);
DisplayDates(wnd);
return TRUE;
case DFM_COMMAND:
if ((int)p1 == DF_ID_HELP) {
DfDisplayHelp(wnd, "Calendar");
return TRUE;
}
break;
case DFM_CLOSE_WINDOW:
Cwnd = NULL;
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
void Calendar(DFWINDOW pwnd)
{
if (Cwnd == NULL) {
time_t tim = time(NULL);
ttm = *localtime(&tim);
Cwnd = DfDfCreateWindow(DF_PICTUREBOX,
"Calendar",
-1, -1, CALHEIGHT, CALWIDTH,
NULL, pwnd, CalendarProc,
DF_SHADOW |
DF_MINMAXBOX |
DF_CONTROLBOX |
DF_MOVEABLE |
DF_HASBORDER
);
}
DfSendMessage(Cwnd, DFM_SETFOCUS, TRUE, 0);
}
/* EOF */
rosapps/dflat32/checkbox.c
-49
View File
@@ -1,49 +0,0 @@
/* -------------- checkbox.c ------------ */
#include "dflat.h"
int DfCheckBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DF_CTLWINDOW *ct = DfGetControl(wnd);
if (ct != NULL) {
switch (msg) {
case DFM_SETFOCUS:
if (!(int)p1)
DfSendMessage(NULL, DFM_HIDE_CURSOR, 0, 0);
case DFM_MOVE:
rtn = DfBaseWndProc(DF_CHECKBOX, wnd, msg, p1, p2);
DfSetFocusCursor(wnd);
return rtn;
case DFM_PAINT: {
char cb[] = "[ ]";
if (ct->setting)
cb[1] = 'X';
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM) cb, 0);
DfSetFocusCursor(wnd);
break;
}
case DFM_KEYBOARD:
if ((int)p1 != ' ')
break;
case DFM_LEFT_BUTTON:
ct->setting ^= DF_ON;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
default:
break;
}
}
return DfBaseWndProc(DF_CHECKBOX, wnd, msg, p1, p2);
}
BOOL DfCheckBoxSetting(DF_DBOX *db, enum DfCommands cmd)
{
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, DF_CHECKBOX);
if (ct != NULL)
return (ct->isetting == DF_ON);
return FALSE;
}
/* EOF */
rosapps/dflat32/classdef.h
-31
View File
@@ -1,31 +0,0 @@
/* ---------------- classdef.h --------------- */
#ifndef CLASSDEF_H
#define CLASSDEF_H
typedef struct DfClassDefs {
DFCLASS base; /* base window class */
int (*wndproc)(struct DfWindow *,enum DfMessages,DF_PARAM,DF_PARAM);
int attrib;
} DFCLASSDEFS;
extern DFCLASSDEFS DfClassDefs[];
#define DF_SHADOW 0x0001
#define DF_MOVEABLE 0x0002
#define DF_SIZEABLE 0x0004
#define DF_HASMENUBAR 0x0008
#define DF_VSCROLLBAR 0x0010
#define DF_HSCROLLBAR 0x0020
#define DF_VISIBLE 0x0040
#define DF_SAVESELF 0x0080
#define DF_HASTITLEBAR 0x0100
#define DF_CONTROLBOX 0x0200
#define DF_MINMAXBOX 0x0400
#define DF_NOCLIP 0x0800
#define DF_READONLY 0x1000
#define DF_MULTILINE 0x2000
#define DF_HASBORDER 0x4000
#define DF_HASSTATUSBAR 0x8000
#endif
rosapps/dflat32/classes.h
-56
View File
@@ -1,56 +0,0 @@
/* ----------- classes.h ------------ */
/*
* Class definition source file
* Make class changes to this source file
* Other source files will adapt
*
* You must add entries to the DfColor tables in
* DFCONFIG.C for new classes.
*
* Class Name Base Class Processor Attribute
* ------------ --------- --------------- -----------
*/
DfClassDef( DF_NORMAL, -1, DfNormalProc, 0 )
DfClassDef( DF_APPLICATION, DF_NORMAL, DfApplicationProc, DF_VISIBLE |
DF_SAVESELF |
DF_CONTROLBOX )
DfClassDef( DF_TEXTBOX, DF_NORMAL, DfTextBoxProc, 0 )
DfClassDef( DF_LISTBOX, DF_TEXTBOX, DfListBoxProc, 0 )
DfClassDef( DF_EDITBOX, DF_TEXTBOX, DfEditBoxProc, 0 )
DfClassDef( DF_MENUBAR, DF_NORMAL, DfMenuBarProc, DF_NOCLIP )
DfClassDef( DF_POPDOWNMENU, DF_LISTBOX, DfPopDownProc, DF_SAVESELF |
DF_NOCLIP |
DF_HASBORDER )
#ifdef INCLUDE_PICTUREBOX
DfClassDef( DF_PICTUREBOX, DF_TEXTBOX, DfPictureProc, 0 )
#endif
DfClassDef( DF_DIALOG, DF_NORMAL, DfDialogProc, DF_SHADOW |
DF_MOVEABLE |
DF_CONTROLBOX|
DF_HASBORDER |
DF_NOCLIP )
DfClassDef( DF_BOX, DF_NORMAL, DfBoxProc, DF_HASBORDER )
DfClassDef( DF_BUTTON, DF_TEXTBOX, DfButtonProc, DF_SHADOW )
DfClassDef( DF_COMBOBOX, DF_EDITBOX, DfComboProc, 0 )
DfClassDef( DF_TEXT, DF_TEXTBOX, DfTextProc, 0 )
DfClassDef( DF_RADIOBUTTON, DF_TEXTBOX, DfRadioButtonProc, 0 )
DfClassDef( DF_CHECKBOX, DF_TEXTBOX, DfCheckBoxProc, 0 )
DfClassDef( DF_SPINBUTTON, DF_LISTBOX, DfSpinButtonProc, 0 )
DfClassDef( DF_ERRORBOX, DF_DIALOG, NULL, DF_SHADOW |
DF_HASBORDER )
DfClassDef( DF_MESSAGEBOX, DF_DIALOG, NULL, DF_SHADOW |
DF_HASBORDER )
DfClassDef( DF_HELPBOX, DF_DIALOG, DfHelpBoxProc, DF_MOVEABLE |
DF_SAVESELF |
DF_HASBORDER |
DF_NOCLIP |
DF_CONTROLBOX )
DfClassDef( DF_STATUSBAR, DF_TEXTBOX, DfStatusBarProc, DF_NOCLIP )
/*
* ========> Add new classes here <========
*/
/* ---------- pseudo classes to create enums, etc. ---------- */
DfClassDef( DF_TITLEBAR, -1, NULL, 0 )
DfClassDef( DF_DUMMY, -1, NULL, DF_HASBORDER )
rosapps/dflat32/clipbord.c
-54
View File
@@ -1,54 +0,0 @@
/* ----------- clipbord.c ------------ */
#include "dflat.h"
char *DfClipboard;
unsigned DfClipboardLength;
void DfCopyTextToClipboard(char *text)
{
DfClipboardLength = strlen(text);
DfClipboard = DfRealloc(DfClipboard, DfClipboardLength);
memmove(DfClipboard, text, DfClipboardLength);
}
void DfCopyToClipboard(DFWINDOW wnd)
{
if (DfTextBlockMarked(wnd)) {
char *bbl=DfTextLine(wnd,wnd->BlkBegLine)+wnd->BlkBegCol;
char *bel=DfTextLine(wnd,wnd->BlkEndLine)+wnd->BlkEndCol;
DfClipboardLength = (int) (bel - bbl);
DfClipboard = DfRealloc(DfClipboard, DfClipboardLength);
memmove(DfClipboard, bbl, DfClipboardLength);
}
}
void DfClearClipboard(void)
{
if (DfClipboard != NULL) {
free(DfClipboard);
DfClipboard = NULL;
}
}
BOOL DfPasteText(DFWINDOW wnd, char *SaveTo, unsigned len)
{
if (SaveTo != NULL && len > 0) {
unsigned plen = strlen(wnd->text) + len;
if (plen <= wnd->MaxTextLength) {
if (plen+1 > wnd->textlen) {
wnd->text = DfRealloc(wnd->text, plen+3);
wnd->textlen = plen+1;
}
memmove(DfCurrChar+len, DfCurrChar, strlen(DfCurrChar)+1);
memmove(DfCurrChar, SaveTo, len);
DfBuildTextPointers(wnd);
wnd->TextChanged = TRUE;
return TRUE;
}
}
return FALSE;
}
/* EOF */
rosapps/dflat32/combobox.c
-149
View File
@@ -1,149 +0,0 @@
/* -------------- combobox.c -------------- */
#include "dflat.h"
int ListProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfComboProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
wnd->extension = DfDfCreateWindow(
DF_LISTBOX,
NULL,
wnd->rc.lf,wnd->rc.tp+1,
wnd->ht-1, wnd->wd+1,
NULL,
wnd,
ListProc,
DF_HASBORDER | DF_NOCLIP | DF_SAVESELF);
((DFWINDOW)(wnd->extension))->ct->command =
wnd->ct->command;
wnd->ht = 1;
wnd->rc.bt = wnd->rc.tp;
break;
case DFM_PAINT:
DfForeground = DfWndBackground(wnd);
DfBackground = DfWndForeground(wnd);
DfWPutch(wnd, DF_DOWNSCROLLBOX, DfWindowWidth(wnd), 0);
break;
case DFM_KEYBOARD:
if ((int)p1 == DF_DN) {
DfSendMessage(wnd->extension, DFM_SETFOCUS, TRUE, 0);
return TRUE;
}
break;
case DFM_LEFT_BUTTON:
if ((int)p1 == DfGetRight(wnd) + 1)
DfSendMessage(wnd->extension, DFM_SETFOCUS, TRUE, 0);
break;
case DFM_CLOSE_WINDOW:
DfSendMessage(wnd->extension, DFM_CLOSE_WINDOW, 0, 0);
break;
default:
break;
}
return DfBaseWndProc(DF_COMBOBOX, wnd, msg, p1, p2);
}
int ListProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
DFWINDOW pwnd = DfGetParent(DfGetParent(wnd));
DF_DBOX *db = pwnd->extension;
DFWINDOW cwnd;
char text[130];
int rtn;
DFWINDOW currFocus;
switch (msg)
{
case DFM_CREATE_WINDOW:
wnd->ct = DfMalloc(sizeof(DF_CTLWINDOW));
wnd->ct->setting = DF_OFF;
wnd->WindowColors[DF_FRAME_COLOR][DF_FG] =
wnd->WindowColors[DF_STD_COLOR][DF_FG];
wnd->WindowColors[DF_FRAME_COLOR][DF_BG] =
wnd->WindowColors[DF_STD_COLOR][DF_BG];
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
return rtn;
case DFM_SETFOCUS:
if ((int)p1 == FALSE)
{
if (!wnd->isHelping)
{
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
wnd->ct->setting = DF_OFF;
}
}
else
wnd->ct->setting = DF_ON;
break;
case DFM_SHOW_WINDOW:
if (wnd->ct->setting == DF_OFF)
return TRUE;
break;
case DFM_BORDER:
currFocus = DfInFocus;
DfInFocus = NULL;
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfInFocus = currFocus;
return rtn;
case DFM_LB_SELECTION:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, DFM_LB_GETTEXT,
(DF_PARAM) text, wnd->selection);
DfPutItemText(pwnd, wnd->ct->command, text);
cwnd = DfControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, DFM_PAINT, 0, 0);
cwnd->TextChanged = TRUE;
return rtn;
case DFM_KEYBOARD:
switch ((int) p1)
{
case DF_ESC:
case DF_FWD:
case DF_BS:
cwnd = DfControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, DFM_SETFOCUS, TRUE, 0);
return TRUE;
default:
break;
}
break;
case DFM_LB_CHOOSE:
cwnd = DfControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, DFM_SETFOCUS, TRUE, 0);
return TRUE;
case DFM_CLOSE_WINDOW:
if (wnd->ct != NULL)
free(wnd->ct);
wnd->ct = NULL;
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
void DfPutComboListText(DFWINDOW wnd, enum DfCommands cmd, char *text)
{
DF_CTLWINDOW *ct = DfFindCommand(wnd->extension, cmd, DF_COMBOBOX);
if (ct != NULL)
{
DFWINDOW lwnd = ((DFWINDOW)(ct->wnd))->extension;
DfSendMessage(lwnd, DFM_ADDTEXT, (DF_PARAM) text, 0);
}
}
/* EOF */
rosapps/dflat32/commands.h
-121
View File
@@ -1,121 +0,0 @@
/* ---------------- commands.h ----------------- */
/*
* Command values sent as the first parameter
* in the COMMAND message
*
* Add application-specific commands to this enum
*/
#ifndef COMMANDS_H
#define COMMANDS_H
enum DfCommands {
/* --------------- File menu ---------------- */
DF_ID_OPEN,
DF_ID_NEW,
DF_ID_SAVE,
DF_ID_SAVEAS,
DF_ID_DELETEFILE,
DF_ID_PRINT,
DF_ID_PRINTSETUP,
DF_ID_DOS,
DF_ID_EXIT,
/* --------------- Edit menu ---------------- */
DF_ID_UNDO,
DF_ID_CUT,
DF_ID_COPY,
DF_ID_PASTE,
DF_ID_PARAGRAPH,
DF_ID_CLEAR,
DF_ID_DELETETEXT,
/* --------------- Search Menu -------------- */
DF_ID_SEARCH,
DF_ID_REPLACE,
DF_ID_SEARCHNEXT,
/* --------------- Utilities Menu ------------- */
DF_ID_CALENDAR,
DF_ID_BARCHART,
/* -------------- Options menu -------------- */
DF_ID_INSERT,
DF_ID_WRAP,
DF_ID_LOG,
DF_ID_TABS,
DF_ID_DISPLAY,
DF_ID_SAVEOPTIONS,
/* --------------- Window menu -------------- */
DF_ID_CLOSEALL,
DF_ID_WINDOW,
DF_ID_MOREWINDOWS,
/* --------------- Help menu ---------------- */
DF_ID_HELPHELP,
DF_ID_EXTHELP,
DF_ID_KEYSHELP,
DF_ID_HELPINDEX,
DF_ID_ABOUT,
DF_ID_LOADHELP,
/* --------------- System menu -------------- */
#ifdef INCLUDE_RESTORE
DF_ID_SYSRESTORE,
#endif
DF_ID_SYSMOVE,
DF_ID_SYSSIZE,
#ifdef INCLUDE_MINIMIZE
DF_ID_SYSMINIMIZE,
#endif
#ifdef INCLUDE_MAXIMIZE
DF_ID_SYSMAXIMIZE,
#endif
DF_ID_SYSCLOSE,
/* ---- FileOpen and SaveAs dialog boxes ---- */
DF_ID_FILENAME,
DF_ID_FILES,
DF_ID_DRIVE,
DF_ID_PATH,
/* ----- Search and Replace dialog boxes ---- */
DF_ID_SEARCHFOR,
DF_ID_REPLACEWITH,
DF_ID_MATCHCASE,
DF_ID_REPLACEALL,
/* ----------- Windows dialog box ----------- */
DF_ID_WINDOWLIST,
/* --------- generic command buttons -------- */
DF_ID_OK,
DF_ID_CANCEL,
DF_ID_HELP,
/* -------------- TabStops menu ------------- */
DF_ID_TAB2,
DF_ID_TAB4,
DF_ID_TAB6,
DF_ID_TAB8,
/* ------------ Display dialog box ---------- */
DF_ID_BORDER,
DF_ID_TITLE,
DF_ID_STATUSBAR,
DF_ID_TEXTURE,
DF_ID_SNOWY,
DF_ID_COLOR,
DF_ID_MONO,
DF_ID_REVERSE,
DF_ID_25LINES,
DF_ID_43LINES,
DF_ID_50LINES,
/* ------------- Log dialog box ------------- */
DF_ID_LOGLIST,
DF_ID_LOGGING,
/* ------------ HelpBox dialog box ---------- */
DF_ID_HELPTEXT,
DF_ID_BACK,
DF_ID_PREV,
DF_ID_NEXT,
/* ---------- Print Select dialog box --------- */
DF_ID_PRINTERPORT,
DF_ID_LEFTMARGIN,
DF_ID_RIGHTMARGIN,
DF_ID_TOPMARGIN,
DF_ID_BOTTOMMARGIN,
/* ----------- DfInputBox dialog box ------------ */
DF_ID_INPUTTEXT
};
#endif
rosapps/dflat32/config.c
-514
View File
@@ -1,514 +0,0 @@
/* ------------- config.c ------------- */
#include "dflat.h"
/* ----- default colors for DfColor video system ----- */
unsigned char DfColor[DF_CLASSCOUNT] [4] [2] = {
/* ------------ DF_NORMAL ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* DF_HILITE_COLOR */
/* ---------- DF_APPLICATION --------- */
{{LIGHTGRAY, BLUE}, /* DF_STD_COLOR */
{LIGHTGRAY, BLUE}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* DF_HILITE_COLOR */
/* ------------ DF_TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------ DF_LISTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_EDITBOX ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLUE}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_MENUBAR ------------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, CYAN}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{DARKGRAY, RED}}, /* DF_HILITE_COLOR
Inactive, Shortcut (both DF_FG) */
/* ---------- DF_POPDOWNMENU --------- */
{{BLACK, CYAN}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, CYAN}, /* DF_FRAME_COLOR */
{DARKGRAY, RED}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ DF_PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
#endif
/* ------------- DF_DIALOG ----------- */
{{LIGHTGRAY, BLUE}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* DF_HILITE_COLOR */
/* ------------ DF_BOX --------------- */
{{LIGHTGRAY, BLUE}, /* DF_STD_COLOR */
{LIGHTGRAY, BLUE}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* DF_HILITE_COLOR */
/* ------------ DF_BUTTON ------------ */
{{BLACK, CYAN}, /* DF_STD_COLOR */
{WHITE, CYAN}, /* DF_SELECT_COLOR */
{BLACK, CYAN}, /* DF_FRAME_COLOR */
{DARKGRAY, RED}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
/* ------------ DF_COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------- DF_TEXT ----------- */
{{0xff, 0xff}, /* DF_STD_COLOR */
{0xff, 0xff}, /* DF_SELECT_COLOR */
{0xff, 0xff}, /* DF_FRAME_COLOR */
{0xff, 0xff}}, /* DF_HILITE_COLOR */
/* ------------- DF_RADIOBUTTON ----------- */
{{LIGHTGRAY, BLUE}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* DF_HILITE_COLOR */
/* ------------- DF_CHECKBOX ----------- */
{{LIGHTGRAY, BLUE}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* DF_HILITE_COLOR */
/* ------------ DF_SPINBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_ERRORBOX ----------- */
{{YELLOW, RED}, /* DF_STD_COLOR */
{YELLOW, RED}, /* DF_SELECT_COLOR */
{YELLOW, RED}, /* DF_FRAME_COLOR */
{YELLOW, RED}}, /* DF_HILITE_COLOR */
/* ----------- DF_MESSAGEBOX --------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_HELPBOX ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLUE}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_STATUSBAR ------------- */
{{BLACK, CYAN}, /* DF_STD_COLOR */
{BLACK, CYAN}, /* DF_SELECT_COLOR */
{BLACK, CYAN}, /* DF_FRAME_COLOR */
{BLACK, CYAN}}, /* DF_HILITE_COLOR */
/* ---------- DF_TITLEBAR ------------ */
{{BLACK, CYAN}, /* DF_STD_COLOR */
{BLACK, CYAN}, /* DF_SELECT_COLOR */
{BLACK, CYAN}, /* DF_FRAME_COLOR */
{WHITE, CYAN}}, /* DF_HILITE_COLOR */
/* ------------ DF_DUMMY ------------- */
{{GREEN, LIGHTGRAY}, /* DF_STD_COLOR */
{GREEN, LIGHTGRAY}, /* DF_SELECT_COLOR */
{GREEN, LIGHTGRAY}, /* DF_FRAME_COLOR */
{GREEN, LIGHTGRAY}} /* DF_HILITE_COLOR */
};
/* ----- default colors for mono video system ----- */
unsigned char DfBW[DF_CLASSCOUNT] [4] [2] = {
/* ------------ DF_NORMAL ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* DF_HILITE_COLOR */
/* ---------- DF_APPLICATION --------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* DF_HILITE_COLOR */
/* ------------ DF_TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------ DF_LISTBOX ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_EDITBOX ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_MENUBAR ------------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive, Shortcut (both DF_FG) */
/* ---------- DF_POPDOWNMENU --------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ DF_PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
#endif
/* ------------- DF_DIALOG ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ------------ DF_BOX --------------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ------------ DF_BUTTON ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{WHITE, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
/* ------------ DF_COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------- DF_TEXT ----------- */
{{0xff, 0xff}, /* DF_STD_COLOR */
{0xff, 0xff}, /* DF_SELECT_COLOR */
{0xff, 0xff}, /* DF_FRAME_COLOR */
{0xff, 0xff}}, /* DF_HILITE_COLOR */
/* ------------- DF_RADIOBUTTON ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ------------- DF_CHECKBOX ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ------------ DF_SPINBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_ERRORBOX ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* DF_HILITE_COLOR */
/* ----------- DF_MESSAGEBOX --------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* DF_HILITE_COLOR */
/* ----------- DF_HELPBOX ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{WHITE, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_STATUSBAR ------------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_TITLEBAR ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------ DF_DUMMY ------------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}} /* DF_HILITE_COLOR */
};
/* ----- default colors for DfReverse mono video ----- */
unsigned char DfReverse[DF_CLASSCOUNT] [4] [2] = {
/* ------------ DF_NORMAL ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_APPLICATION --------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------ DF_TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------ DF_LISTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_EDITBOX ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_MENUBAR ------------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive, Shortcut (both DF_FG) */
/* ---------- DF_POPDOWNMENU --------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ DF_PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
#endif
/* ------------- DF_DIALOG ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* DF_HILITE_COLOR */
/* ------------ DF_BOX --------------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* DF_HILITE_COLOR */
/* ------------ DF_BUTTON ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{WHITE, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{DARKGRAY, WHITE}}, /* DF_HILITE_COLOR
Inactive ,Shortcut (both DF_FG) */
/* ------------ DF_COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ------------- DF_TEXT ----------- */
{{0xff, 0xff}, /* DF_STD_COLOR */
{0xff, 0xff}, /* DF_SELECT_COLOR */
{0xff, 0xff}, /* DF_FRAME_COLOR */
{0xff, 0xff}}, /* DF_HILITE_COLOR */
/* ------------- DF_RADIOBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* DF_HILITE_COLOR */
/* ------------- DF_CHECKBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* DF_HILITE_COLOR */
/* ------------ DF_SPINBUTTON ----------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_ERRORBOX ----------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* DF_HILITE_COLOR */
/* ----------- DF_MESSAGEBOX --------- */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{BLACK, LIGHTGRAY}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ----------- DF_HELPBOX ------------ */
{{BLACK, LIGHTGRAY}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* DF_FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* DF_HILITE_COLOR */
/* ---------- DF_STATUSBAR ------------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ---------- DF_TITLEBAR ------------ */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* DF_HILITE_COLOR */
/* ------------ DF_DUMMY ------------- */
{{LIGHTGRAY, BLACK}, /* DF_STD_COLOR */
{LIGHTGRAY, BLACK}, /* DF_SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* DF_FRAME_COLOR */
{LIGHTGRAY, BLACK}} /* DF_HILITE_COLOR */
};
/* ------ default configuration values ------- */
DFCONFIG DfCfg = {
DF_VERSION,
TRUE, /* Editor Insert Mode */
4, /* Editor tab stops */
TRUE, /* Editor word wrap */
#ifdef INCLUDE_WINDOWOPTIONS
TRUE, /* Application Border */
TRUE, /* Application Title */
TRUE, /* Status Bar */
TRUE, /* Textured application window */
#endif
// 25, /* Number of screen lines */
"Lpt1", /* Printer Port */
66, /* Lines per printer page */
80, /* characters per printer line */
6, /* Left printer margin */
70, /* Right printer margin */
3, /* Top printer margin */
55 /* Bottom printer margin */
};
void DfBuildFileName(char *path, char *ext)
{
extern char **Argv;
char *cp;
strcpy(path, Argv[0]);
cp = strrchr(path, '\\');
if (cp == NULL)
cp = path;
else
cp++;
strcpy(cp, DFlatApplication);
strcat(cp, ext);
}
FILE *DfOpenConfig(char *mode)
{
char path[64];
DfBuildFileName(path, ".DfCfg");
return fopen(path, mode);
}
/* ------ load a configuration file from disk ------- */
BOOL DfLoadConfig(void)
{
static BOOL ConfigLoaded = FALSE;
if (ConfigLoaded == FALSE) {
FILE *fp = DfOpenConfig("rb");
if (fp != NULL) {
fread(DfCfg.version, sizeof DfCfg.version+1, 1, fp);
if (strcmp(DfCfg.version, DF_VERSION) == 0) {
fseek(fp, 0L, SEEK_SET);
fread(&DfCfg, sizeof(DFCONFIG), 1, fp);
fclose(fp);
}
else {
char path[64];
DfBuildFileName(path, ".DfCfg");
fclose(fp);
_unlink(path);
strcpy(DfCfg.version, DF_VERSION);
}
ConfigLoaded = TRUE;
}
}
return ConfigLoaded;
}
/* ------ save a configuration file to disk ------- */
void DfSaveConfig(void)
{
FILE *fp = DfOpenConfig("wb");
if (fp != NULL) {
fwrite(&DfCfg, sizeof(DFCONFIG), 1, fp);
fclose(fp);
}
}
/* --------- set window colors --------- */
void DfSetStandardColor(DFWINDOW wnd)
{
DfForeground = DfWndForeground(wnd);
DfBackground = DfWndBackground(wnd);
}
void DfSetReverseColor(DFWINDOW wnd)
{
DfForeground = DfSelectForeground(wnd);
DfBackground = DfSelectBackground(wnd);
}
/* EOF */
rosapps/dflat32/config.h
-48
View File
@@ -1,48 +0,0 @@
/* ---------------- config.h -------------- */
#ifndef CONFIG_H
#define CONFIG_H
enum DfColorTypes {
DF_STD_COLOR,
DF_SELECT_COLOR,
DF_FRAME_COLOR,
DF_HILITE_COLOR
};
enum DfGrounds { DF_FG, DF_BG };
/* ----------- configuration parameters ----------- */
typedef struct DfConfig {
char version[sizeof DF_VERSION];
BOOL InsertMode; /* Editor insert mode */
int Tabs; /* Editor tab stops */
BOOL WordWrap; /* True to word wrap editor */
#ifdef INCLUDE_WINDOWOPTIONS
BOOL Border; /* True for application window border */
BOOL Title; /* True for application window title */
BOOL StatusBar; /* True for appl'n window status bar */
BOOL Texture; /* True for textured appl window */
#endif
// int ScreenLines; /* Number of screen lines (25/43/50) */
char PrinterPort[5];
int LinesPage; /* Lines per printer page */
int CharsLine; /* Characters per printer line */
int LeftMargin; /* Printer margins */
int RightMargin;
int TopMargin;
int BottomMargin;
unsigned char clr[DF_CLASSCOUNT] [4] [2]; /* Colors */
} DFCONFIG;
extern DFCONFIG DfCfg;
extern unsigned char DfColor[DF_CLASSCOUNT] [4] [2];
extern unsigned char DfBW[DF_CLASSCOUNT] [4] [2];
extern unsigned char DfReverse[DF_CLASSCOUNT] [4] [2];
BOOL DfLoadConfig(void);
void DfSaveConfig(void);
FILE *DfOpenConfig(char *);
#endif
rosapps/dflat32/console.c
-217
View File
@@ -1,217 +0,0 @@
/* ----------- console.c ---------- */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "dflat.h"
/* ----- table of alt keys for finding shortcut keys ----- */
#if 0
static int altconvert[] = {
DF_ALT_A,DF_ALT_B,DF_ALT_C,DF_ALT_D,DF_ALT_E,DF_ALT_F,DF_ALT_G,DF_ALT_H,
DF_ALT_I,DF_ALT_J,DF_ALT_K,DF_ALT_L,DF_ALT_M,DF_ALT_N,DF_ALT_O,DF_ALT_P,
DF_ALT_Q,DF_ALT_R,DF_ALT_S,DF_ALT_T,DF_ALT_U,DF_ALT_V,DF_ALT_W,DF_ALT_X,
DF_ALT_Y,DF_ALT_Z,DF_ALT_0,DF_ALT_1,DF_ALT_2,DF_ALT_3,DF_ALT_4,DF_ALT_5,
DF_ALT_6,DF_ALT_7,DF_ALT_8,DF_ALT_9
};
#endif
static COORD cursorpos[DF_MAXSAVES];
static CONSOLE_CURSOR_INFO cursorinfo[DF_MAXSAVES];
static int cs = 0;
void DfSwapCursorStack(void)
{
if (cs > 1)
{
COORD coord;
CONSOLE_CURSOR_INFO csi;
coord = cursorpos[cs-2];
cursorpos[cs-2] = cursorpos[cs-1];
cursorpos[cs-1] = coord;
memcpy (&csi,
&cursorinfo[cs-2],
sizeof(CONSOLE_CURSOR_INFO));
memcpy (&cursorinfo[cs-2],
&cursorinfo[cs-1],
sizeof(CONSOLE_CURSOR_INFO));
memcpy (&cursorinfo[cs-1],
&csi,
sizeof(CONSOLE_CURSOR_INFO));
}
}
/* ---- Read a keystroke ---- */
void DfGetKey (PINPUT_RECORD lpBuffer)
{
HANDLE DfInput;
DWORD dwRead;
DfInput = GetStdHandle (STD_INPUT_HANDLE);
do
{
// WaitForSingleObject (DfInput, INFINITE);
ReadConsoleInput (DfInput, lpBuffer, 1, &dwRead);
if ((lpBuffer->EventType == KEY_EVENT) &&
(lpBuffer->Event.KeyEvent.bKeyDown == TRUE))
break;
}
while (TRUE);
}
/* ---------- read the keyboard shift status --------- */
int DfGetShift(void)
{
// regs.h.ah = 2;
// int86(KEYBRD, &regs, &regs);
// return regs.h.al;
/* FIXME */
return 0;
}
/* -------- sound a buzz tone ---------- */
void DfBeep(void)
{
Beep(440, 50);
// MessageBeep (-1);
}
/* ------ position the DfCursor ------ */
void DfCursor(int x, int y)
{
COORD coPos;
coPos.X = (USHORT)x;
coPos.Y = (USHORT)y;
SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), coPos);
}
/* ------- get the current DfCursor position ------- */
void DfCurrCursor(int *x, int *y)
//VOID GetCursorXY (PSHORT x, PSHORT y)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
*x = (int)csbi.dwCursorPosition.X;
*y = (int)csbi.dwCursorPosition.Y;
}
/* ------ save the current DfCursor configuration ------ */
void DfSaveCursor(void)
{
if (cs < DF_MAXSAVES)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
cursorpos[cs].X = csbi.dwCursorPosition.X;
cursorpos[cs].Y = csbi.dwCursorPosition.Y;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&(cursorinfo[cs]));
cs++;
}
}
/* ---- restore the saved DfCursor configuration ---- */
void DfRestoreCursor(void)
{
if (cs)
{
--cs;
SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE),
cursorpos[cs]);
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&(cursorinfo[cs]));
}
}
/* ------ make a normal DfCursor ------ */
void DfNormalCursor(void)
{
CONSOLE_CURSOR_INFO csi;
csi.bVisible = TRUE;
csi.dwSize = 5;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ hide the DfCursor ------ */
void DfHideCursor(void)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
csi.bVisible = FALSE;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ unhide the DfCursor ------ */
void DfUnhideCursor(void)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
csi.bVisible = TRUE;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* set the DfCursor size (in percent) */
void DfSetCursorSize (unsigned t)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
if (t < 2)
csi.dwSize = 2;
else if (t > 90)
csi.dwSize = 90;
else
csi.dwSize = t;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ convert an Alt+ key to its letter equivalent ----- */
int DfAltConvert(int c)
{
return c;
#if 0
int i, a = 0;
for (i = 0; i < 36; i++)
if (c == altconvert[i])
break;
if (i < 26)
a = 'a' + i;
else if (i < 36)
a = '0' + i - 26;
return a;
#endif
}
/* EOF */
rosapps/dflat32/decomp.c
-134
View File
@@ -1,134 +0,0 @@
/* ------------------- decomp.c -------------------- */
/*
* Decompress the application.HLP file
* or load the application.TXT file if the .HLP file
* does not exist
*/
#include "dflat.h"
#include "htree.h"
static int in8;
static int ct8 = 8;
static FILE *fi;
static DF_BYTECOUNTER bytectr;
static int LoadingASCII;
struct DfHTr *DfHelpTree;
static int root;
/* ------- open the help database file -------- */
FILE *DfOpenHelpFile(void)
{
char *cp;
int treect, i;
char helpname[65];
/* -------- get the name of the help file ---------- */
DfBuildFileName(helpname, ".hlp");
LoadingASCII = FALSE;
if ((fi = fopen(helpname, "rb")) == NULL) {
/* ---- no .hlp file, look for .txt file ---- */
if ((cp = strrchr(helpname, '.')) != NULL) {
strcpy(cp, ".TXT");
fi = fopen(helpname, "rt");
}
if (fi == NULL)
return NULL;
LoadingASCII = TRUE;
}
if (!LoadingASCII && DfHelpTree == NULL) {
/* ----- read the byte count ------ */
fread(&bytectr, sizeof bytectr, 1, fi);
/* ----- read the frequency count ------ */
fread(&treect, sizeof treect, 1, fi);
/* ----- read the root offset ------ */
fread(&root, sizeof root, 1, fi);
DfHelpTree = DfCalloc(treect-256, sizeof(struct DfHTr));
/* ---- read in the tree --- */
for (i = 0; i < treect-256; i++) {
fread(&DfHelpTree[i].left, sizeof(int), 1, fi);
fread(&DfHelpTree[i].right, sizeof(int), 1, fi);
}
}
return fi;
}
/* ----- read a line of text from the help database ----- */
void *DfGetHelpLine(char *line)
{
int h;
if (LoadingASCII) {
void *hp;
do
hp = fgets(line, 160, fi);
while (*line == ';');
return hp;
}
*line = '\0';
while (TRUE) {
/* ----- decompress a line from the file ------ */
h = root;
/* ----- walk the Huffman tree ----- */
while (h > 255) {
/* --- h is a node pointer --- */
if (ct8 == 8) {
/* --- read 8 bits of compressed data --- */
if ((in8 = fgetc(fi)) == EOF) {
*line = '\0';
return NULL;
}
ct8 = 0;
}
/* -- point to left or right node based on msb -- */
if (in8 & 0x80)
h = DfHelpTree[h-256].left;
else
h = DfHelpTree[h-256].right;
/* --- shift the next bit in --- */
in8 <<= 1;
ct8++;
}
/* --- h < 255 = decompressed character --- */
if (h == '\r')
continue; /* skip the '\r' character */
/* --- put the character in the buffer --- */
*line++ = h;
/* --- if '\n', end of line --- */
if (h == '\n')
break;
}
*line = '\0'; /* null-terminate the line */
return line;
}
/* --- compute the database file byte and bit position --- */
void DfHelpFilePosition(long *offset, int *bit)
{
*offset = ftell(fi);
if (LoadingASCII)
*bit = 0;
else {
if (ct8 < 8)
--*offset;
*bit = ct8;
}
}
/* -- position the database to the specified byte and bit -- */
void DfSeekHelpLine(long offset, int bit)
{
int i;
fseek(fi, offset, 0);
if (!LoadingASCII) {
ct8 = bit;
if (ct8 < 8) {
in8 = fgetc(fi);
for (i = 0; i < bit; i++)
in8 <<= 1;
}
}
}
rosapps/dflat32/dfalloc.c
-70
View File
@@ -1,70 +0,0 @@
/* ---------- dfalloc.c ---------- */
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "dflat.h"
static void AllocationError(void)
{
static BOOL OnceIn = FALSE;
extern jmp_buf AllocError;
extern BOOL AllocTesting;
static char *ErrMsg[] = {
"ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿",
"³ Out of Memory! ³",
"RÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄU"
};
int x, y;
CHAR_INFO savbuf[54];
DFRECT rc = {30,11,47,13};
INPUT_RECORD ir;
if (!OnceIn)
{
OnceIn = TRUE;
/* ------ close all windows ------ */
DfSendMessage(DfApplicationWindow, DFM_CLOSE_WINDOW, 0, 0);
DfGetVideo(rc, savbuf);
for (x = 0; x < 18; x++)
{
for (y = 0; y < 3; y++)
{
int c = (255 & (*(*(ErrMsg+y)+x))) | 0x7000;
DfPutVideoChar(x+rc.lf, y+rc.tp, c);
}
}
DfGetKey(&ir);
DfStoreVideo(rc, savbuf);
if (AllocTesting)
longjmp(AllocError, 1);
}
}
void *DfCalloc(size_t nitems, size_t size)
{
void *rtn = calloc(nitems, size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
void *DfMalloc(size_t size)
{
void *rtn = malloc(size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
void *DfRealloc(void *block, size_t size)
{
void *rtn;
rtn = realloc(block, size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
/* EOF */
rosapps/dflat32/dflat.doc
-1350
View File
File diff suppressed because it is too large Load Diff
rosapps/dflat32/dflat.h
-487
View File
@@ -1,487 +0,0 @@
/* ------------- dflat.h ----------- */
#ifndef DFLAT_H
#define DFLAT_H
//#ifdef BUILD_FULL_DFLAT
#define INCLUDE_MULTI_WINDOWS
#define INCLUDE_LOGGING
#define INCLUDE_SHELLDOS
#define INCLUDE_WINDOWOPTIONS
#define INCLUDE_PICTUREBOX
#define INCLUDE_MINIMIZE
#define INCLUDE_MAXIMIZE
#define INCLUDE_RESTORE
#define INCLUDE_EXTENDEDSELECTIONS
//#endif
#include <windows.h>
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <dos.h>
#include <process.h>
#include <conio.h>
#include <ctype.h>
#include <io.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <time.h>
#include <setjmp.h>
#ifndef DF_VERSION
#define DF_VERSION "Beta Version 0.3"
#endif
void *DfCalloc(size_t, size_t);
void *DfMalloc(size_t);
void *DfRealloc(void *, size_t);
#define DF_MAXMESSAGES 50
#define DF_DELAYTICKS 1
#define DF_FIRSTDELAY 7
#define DF_DOUBLETICKS 5
#define DF_MAXTEXTLEN 65000U /* maximum text buffer */
#define DF_EDITLEN 1024 /* starting length for multiliner */
#define DF_ENTRYLEN 256 /* starting length for one-liner */
#define DF_GROWLENGTH 64 /* buffers grow by this much */
#include "system.h"
#include "config.h"
#include "rect.h"
#include "menu.h"
#include "keys.h"
#include "commands.h"
#include "dialbox.h"
/* ------ integer type for message parameters ----- */
typedef long DF_PARAM;
enum DfCondition
{
DF_SRESTORED, DF_ISMINIMIZED, DF_ISMAXIMIZED, DF_ISCLOSING
};
typedef struct DfWindow
{
DFCLASS class; /* window class */
char *title; /* window title */
int (*wndproc)(struct DfWindow *, enum DfMessages, DF_PARAM, DF_PARAM);
/* ----------------- window colors -------------------- */
char WindowColors[4][2];
/* ---------------- window dimensions ----------------- */
DFRECT rc; /* window coordinates (0/0 to 79/24) */
int ht, wd; /* window height and width */
DFRECT RestoredRC; /* restored condition rect */
/* -------------- linked list pointers ---------------- */
struct DfWindow *parent; /* parent window */
struct DfWindow *firstchild; /* first child this parent */
struct DfWindow *lastchild; /* last child this parent */
struct DfWindow *nextsibling; /* next sibling */
struct DfWindow *prevsibling; /* previous sibling */
struct DfWindow *childfocus; /* child that ha(s/d) focus */
int attrib; /* Window attributes */
PCHAR_INFO videosave; /* video save buffer */
enum DfCondition condition; /* Restored, Maximized,
Minimized, Closing */
enum DfCondition oldcondition;/* previous condition */
int restored_attrib; /* attributes when restored */
void *extension; /* menus, dialogs, documents, etc */
struct DfWindow *PrevMouse;
struct DfWindow *PrevKeyboard;
struct DfWindow *MenuBarWnd;/* menu bar */
struct DfWindow *StatusBar; /* status bar */
int isHelping; /* > 0 when help is being displayed */
/* ----------------- text box fields ------------------ */
int wlines; /* number of lines of text */
int wtop; /* text line that is on the top display */
char *text; /* window text */
unsigned int textlen; /* text length */
int wleft; /* left position in window viewport */
int textwidth; /* width of longest line in textbox */
int BlkBegLine; /* beginning line of marked block */
int BlkBegCol; /* beginning column of marked block */
int BlkEndLine; /* ending line of marked block */
int BlkEndCol; /* ending column of marked block */
int HScrollBox; /* position of horizontal scroll box */
int VScrollBox; /* position of vertical scroll box */
unsigned int *TextPointers; /* -> list of line offsets */
/* ----------------- list box fields ------------------ */
int selection; /* current selection */
BOOL AddMode; /* adding extended selections mode */
int AnchorPoint;/* anchor point for extended selections */
int SelectCount;/* count of selected items */
/* ----------------- edit box fields ------------------ */
int CurrCol; /* Current column */
int CurrLine; /* Current line */
int WndRow; /* Current window row */
BOOL TextChanged; /* TRUE if text has changed */
char *DeletedText; /* for undo */
unsigned DeletedLength; /* Length of deleted field */
BOOL InsertMode; /* TRUE or FALSE for text insert */
BOOL WordWrapMode; /* TRUE or FALSE for word wrap */
unsigned int MaxTextLength; /* maximum text length */
/* ---------------- dialog box fields ----------------- */
int ReturnCode; /* return code from a dialog box */
BOOL Modal; /* True if a modeless dialog box */
DF_CTLWINDOW *ct; /* control structure */
struct DfWindow *dfocus; /* control window that has focus */
/* -------------- popdownmenu fields ------------------ */
DF_MENU *mnu; /* points to menu structure */
DF_MBAR *holdmenu; /* previous active menu */
struct DfWindow *oldFocus;
/* --------------- help box fields -------------------- */
void *firstword; /* -> first in list of key words */
void *lastword; /* -> last in list of key words */
void *thisword; /* -> current in list of key words */
/* -------------- status bar fields ------------------- */
BOOL TimePosted; /* True if time has been posted */
#ifdef INCLUDE_PICTUREBOX
/* ------------- picture box fields ------------------- */
int VectorCount; /* number of vectors in vector list */
void *VectorList; /* list of picture box vectors */
#endif
} * DFWINDOW;
#include "classdef.h"
#include "video.h"
void DfLogMessages (DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
void DfMessageLog(DFWINDOW);
/* ------- window methods ----------- */
#define DF_ICONHEIGHT 3
#define DF_ICONWIDTH 10
#define DfWindowHeight(w) ((w)->ht)
#define DfWindowWidth(w) ((w)->wd)
#define DfBorderAdj(w) (DfTestAttribute(w,DF_HASBORDER)?1:0)
#define DfBottomBorderAdj(w) (DfTestAttribute(w,DF_HASSTATUSBAR)?1:DfBorderAdj(w))
#define DfTopBorderAdj(w) ((DfTestAttribute(w,DF_HASTITLEBAR) && \
DfTestAttribute(w,DF_HASMENUBAR)) ? \
2 : (DfTestAttribute(w,DF_HASTITLEBAR | \
DF_HASMENUBAR | DF_HASBORDER) ? 1 : 0))
#define DfClientWidth(w) (DfWindowWidth(w)-DfBorderAdj(w)*2)
#define DfClientHeight(w) (DfWindowHeight(w)-DfTopBorderAdj(w)-\
DfBottomBorderAdj(w))
#define DfWindowRect(w) ((w)->rc)
#define DfGetTop(w) (DfRectTop(DfWindowRect(w)))
#define DfGetBottom(w) (DfRectBottom(DfWindowRect(w)))
#define DfGetLeft(w) (DfRectLeft(DfWindowRect(w)))
#define DfGetRight(w) (DfRectRight(DfWindowRect(w)))
#define DfGetClientTop(w) (DfGetTop(w)+DfTopBorderAdj(w))
#define DfGetClientBottom(w) (DfGetBottom(w)-DfBottomBorderAdj(w))
#define DfGetClientLeft(w) (DfGetLeft(w)+DfBorderAdj(w))
#define DfGetClientRight(w) (DfGetRight(w)-DfBorderAdj(w))
#define DfGetTitle(w) ((w)->title)
#define DfGetParent(w) ((w)->parent)
#define DfFirstWindow(w) ((w)->firstchild)
#define DfLastWindow(w) ((w)->lastchild)
#define DfNextWindow(w) ((w)->nextsibling)
#define DfPrevWindow(w) ((w)->prevsibling)
#define DfGetClass(w) ((w)->class)
#define DfGetAttribute(w) ((w)->attrib)
#define DfAddAttribute(w,a) (DfGetAttribute(w) |= a)
#define DfClearAttribute(w,a) (DfGetAttribute(w) &= ~(a))
#define DfTestAttribute(w,a) (DfGetAttribute(w) & (a))
#define isHidden(w) (!(DfGetAttribute(w) & DF_VISIBLE))
#define DfSetVisible(w) (DfGetAttribute(w) |= DF_VISIBLE)
#define DfClearVisible(w) (DfGetAttribute(w) &= ~DF_VISIBLE)
#define DfGotoXY(w,x,y) DfCursor(w->rc.lf+(x)+1,w->rc.tp+(y)+1)
BOOL DfIsVisible(DFWINDOW);
DFWINDOW DfDfCreateWindow(DFCLASS,char *,int,int,int,int,void*,DFWINDOW,
int (*)(struct DfWindow *,enum DfMessages,DF_PARAM,DF_PARAM),int);
void DfAddTitle(DFWINDOW, char *);
void DfInsertTitle(DFWINDOW, char *);
void DfDisplayTitle(DFWINDOW, DFRECT *);
void DfRepaintBorder(DFWINDOW, DFRECT *);
void DfPaintShadow(DFWINDOW);
void DfClearWindow(DFWINDOW, DFRECT *, int);
void DfWriteLine(DFWINDOW, char *, int, int, BOOL);
void DfInitWindowColors(DFWINDOW);
void DfSetNextFocus(void);
void DfSetPrevFocus(void);
void DfRemoveWindow(DFWINDOW);
void DfAppendWindow(DFWINDOW);
void DfReFocus(DFWINDOW);
void DfSkipApplicationControls(void);
BOOL DfCharInView(DFWINDOW, int, int);
void DfCreatePath(char *, char *, int, int);
#define DfSwapVideoBuffer(wnd, ish, fh) swapvideo(wnd, wnd->videosave, ish, fh)
int DfLineLength(char *);
DFRECT DfAdjustRectangle(DFWINDOW, DFRECT);
BOOL DfIsDerivedFrom(DFWINDOW, DFCLASS);
DFWINDOW DfGetAncestor(DFWINDOW);
void DfPutWindowChar(DFWINDOW,char,int,int);
void DfPutWindowLine(DFWINDOW, void *,int,int);
#define DfBaseWndProc(class,wnd,msg,p1,p2) \
(*DfClassDefs[(DfClassDefs[class].base)].wndproc)(wnd,msg,p1,p2)
#define DfDefaultWndProc(wnd,msg,p1,p2) \
(DfClassDefs[wnd->class].wndproc == NULL) ? \
DfBaseWndProc(wnd->class,wnd,msg,p1,p2) : \
(*DfClassDefs[wnd->class].wndproc)(wnd,msg,p1,p2)
struct DfLinkedList {
DFWINDOW DfFirstWindow;
DFWINDOW DfLastWindow;
};
extern DFWINDOW DfApplicationWindow;
extern DFWINDOW DfInFocus;
extern DFWINDOW DfCaptureMouse;
extern DFWINDOW DfCaptureKeyboard;
extern int DfForeground, DfBackground;
extern BOOL DfWindowMoving;
extern BOOL DfWindowSizing;
extern BOOL DfVSliding;
extern BOOL DfHSliding;
extern char DFlatApplication[];
extern char *DfClipboard;
extern unsigned DfClipboardLength;
extern BOOL DfClipString;
/* --------- space between menubar labels --------- */
#define DF_MSPACE 2
/* --------------- border characters ------------- */
#define DF_FOCUS_NW '\xc9'
#define DF_FOCUS_NE '\xbb'
#define DF_FOCUS_SE '\xbc'
#define DF_FOCUS_SW '\xc8'
#define DF_FOCUS_SIDE '\xba'
#define DF_FOCUS_LINE '\xcd'
#define DF_NW '\xda'
#define DF_NE '\xbf'
#define DF_SE '\xd9'
#define DF_SW '\xc0'
#define DF_SIDE '\xb3'
#define DF_LINE '\xc4'
#define DF_LEDGE '\xc3'
#define DF_REDGE '\xb4'
/* ------------- scroll bar characters ------------ */
#define DF_UPSCROLLBOX '\x1e'
#define DF_DOWNSCROLLBOX '\x1f'
#define DF_LEFTSCROLLBOX '\x11'
#define DF_RIGHTSCROLLBOX '\x10'
#define DF_SCROLLBARCHAR '\xb0'
#define DF_SCROLLBOXCHAR '\xb2'
/* ------------------ menu characters --------------------- */
#define DF_CHECKMARK '\x04' //(DF_SCREENHEIGHT==25?251:4)
#define DF_CASCADEPOINTER '\x10'
/* ----------------- title bar characters ----------------- */
#define DF_CONTROLBOXCHAR '\xf0'
#define DF_MAXPOINTER '\x18' /* maximize token */
#define DF_MINPOINTER '\x19' /* minimize token */
#define DF_RESTOREPOINTER '\x12' /* restore token */
/* --------------- text control characters ---------------- */
#define DF_APPLCHAR '\xb0' /* fills application window */
#define DF_SHORTCUTCHAR '~' /* prefix: shortcut key display */
#define DF_CHANGECOLOR '\xae' /* prefix to change colors */
#define DF_RESETCOLOR '\xaf' /* reset colors to default */
#define DF_LISTSELECTOR 4 /* selected list box entry */
/* --------- message prototypes ----------- */
BOOL DfInitialize (void);
void DfTerminate (void);
void DfPostMessage (DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfSendMessage (DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
BOOL DfDispatchMessage (void);
void DfHandshake(void);
SHORT DfGetScreenHeight (void);
SHORT DfGetScreenWidth (void);
/* ---- standard window message processing prototypes ----- */
int DfApplicationProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfNormalProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfTextBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfListBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfEditBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfPictureProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfMenuBarProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfPopDownProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfButtonProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfComboProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfTextProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfRadioButtonProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfCheckBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfSpinButtonProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfDialogProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfSystemMenuProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfHelpBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfMessageBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfCancelBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfErrorBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfYesNoBoxProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfStatusBarProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
int DfWatchIconProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
/* ------------- normal box prototypes ------------- */
void DfSetStandardColor(DFWINDOW);
void DfSetReverseColor(DFWINDOW);
BOOL DfIsAncestor(DFWINDOW, DFWINDOW);
#define DfHitControlBox(wnd, p1, p2) \
(DfTestAttribute(wnd, DF_CONTROLBOX) && \
p1 == 2 && p2 == 0)
#define DfWndForeground(wnd) \
(wnd->WindowColors [DF_STD_COLOR] [DF_FG])
#define DfWndBackground(wnd) \
(wnd->WindowColors [DF_STD_COLOR] [DF_BG])
#define DfFrameForeground(wnd) \
(wnd->WindowColors [DF_FRAME_COLOR] [DF_FG])
#define DfFrameBackground(wnd) \
(wnd->WindowColors [DF_FRAME_COLOR] [DF_BG])
#define DfSelectForeground(wnd) \
(wnd->WindowColors [DF_SELECT_COLOR] [DF_FG])
#define DfSelectBackground(wnd) \
(wnd->WindowColors [DF_SELECT_COLOR] [DF_BG])
#define DfHighlightForeground(wnd) \
(wnd->WindowColors [DF_HILITE_COLOR] [DF_FG])
#define DfHighlightBackground(wnd) \
(wnd->WindowColors [DF_HILITE_COLOR] [DF_BG])
#define DfWindowClientColor(wnd, fg, bg) \
DfWndForeground(wnd) = fg, DfWndBackground(wnd) = bg
#define DfWindowReverseColor(wnd, fg, bg) \
DfSelectForeground(wnd) = fg, DfSelectBackground(wnd) = bg
#define DfWindowFrameColor(wnd, fg, bg) \
DfFrameForeground(wnd) = fg, DfFrameBackground(wnd) = bg
#define DfWindowHighlightColor(wnd, fg, bg) \
DfHighlightForeground(wnd) = fg, DfHighlightBackground(wnd) = bg
/* -------- text box prototypes ---------- */
#define DfTextLine(wnd, sel) \
(wnd->text + *((wnd->TextPointers) + sel))
void DfWriteTextLine(DFWINDOW, DFRECT *, int, BOOL);
#define DfTextBlockMarked(wnd) ( wnd->BlkBegLine || \
wnd->BlkEndLine || \
wnd->BlkBegCol || \
wnd->BlkEndCol)
void DfMarkTextBlock(DFWINDOW, int, int, int, int);
#define DfClearTextBlock(wnd) wnd->BlkBegLine = wnd->BlkEndLine = \
wnd->BlkBegCol = wnd->BlkEndCol = 0;
#define DfGetText(w) ((w)->text)
#define DfGetTextLines(w) ((w)->wlines)
void DfClearTextPointers(DFWINDOW);
void DfBuildTextPointers(DFWINDOW);
int DfTextLineNumber(DFWINDOW, char *);
/* ------------ DfClipboard prototypes ------------- */
void DfCopyTextToClipboard(char *);
void DfCopyToClipboard(DFWINDOW);
#define DfPasteFromClipboard(wnd) DfPasteText(wnd,DfClipboard,DfClipboardLength)
BOOL DfPasteText(DFWINDOW, char *, unsigned);
void DfClearClipboard(void);
/* --------- menu prototypes ---------- */
int DfCopyCommand(char *, char *, int, int);
void DfPrepFileMenu(void *, struct DfMenu *);
void DfPrepEditMenu(void *, struct DfMenu *);
void DfPrepSearchMenu(void *, struct DfMenu *);
void DfPrepWindowMenu(void *, struct DfMenu *);
void DfBuildSystemMenu(DFWINDOW);
BOOL isActive(DF_MBAR *, int);
char *DfGetCommandText(DF_MBAR *, int);
BOOL DfIsCascadedCommand(DF_MBAR *,int);
void DfActivateCommand(DF_MBAR *,int);
void DfDeactivateCommand(DF_MBAR *,int);
BOOL DfGetCommandToggle(DF_MBAR *,int);
void DfSetCommandToggle(DF_MBAR *,int);
void DfClearCommandToggle(DF_MBAR *,int);
void DfInvertCommandToggle(DF_MBAR *,int);
int DfBarSelection(int);
/* ------------- list box prototypes -------------- */
BOOL DfItemSelected(DFWINDOW, int);
/* ------------- edit box prototypes ----------- */
#define DfCurrChar (DfTextLine(wnd, wnd->CurrLine)+wnd->CurrCol)
#define DfWndCol (wnd->CurrCol-wnd->wleft)
#define DfIsMultiLine(wnd) DfTestAttribute(wnd, DF_MULTILINE)
void DfSearchText(DFWINDOW);
void DfReplaceText(DFWINDOW);
void DfSearchNext(DFWINDOW);
/* --------- message box prototypes -------- */
DFWINDOW DfSliderBox(int, char *, char *);
BOOL DfInputBox(DFWINDOW, char *, char *, char *, int);
BOOL DfGenericMessage(DFWINDOW, char *, char *, int,
int (*)(struct DfWindow *, enum DfMessages, DF_PARAM, DF_PARAM),
char *, char *, int, int, int);
#define DfTestErrorMessage(msg) \
DfGenericMessage(NULL, "Error", msg, 2, DfErrorBoxProc, \
DfOk, DfCancel, DF_ID_OK, DF_ID_CANCEL, TRUE)
#define DfErrorMessage(msg) \
DfGenericMessage(NULL, "Error", msg, 1, DfErrorBoxProc, \
DfOk, NULL, DF_ID_OK, 0, TRUE)
#define DfMessageBox(ttl, msg) \
DfGenericMessage(NULL, ttl, msg, 1, DfMessageBoxProc, \
DfOk, NULL, DF_ID_OK, 0, TRUE)
#define DfYesNoBox(msg) \
DfGenericMessage(NULL, NULL, msg, 2, DfYesNoBoxProc, \
DfYes, DfNo, DF_ID_OK, DF_ID_CANCEL, TRUE)
#define DfCancelBox(wnd, msg) \
DfGenericMessage(wnd, "Wait...", msg, 1, DfCancelBoxProc, \
DfCancel, NULL, DF_ID_CANCEL, 0, FALSE)
void DfCloseCancelBox(void);
DFWINDOW DfMomentaryMessage(char *);
int DfMsgHeight(char *);
int DfMsgWidth(char *);
/* ------------- dialog box prototypes -------------- */
BOOL DfDialogBox(DFWINDOW, DF_DBOX *, BOOL,
int (*)(struct DfWindow *, enum DfMessages, DF_PARAM, DF_PARAM));
void DfClearDialogBoxes(void);
BOOL DfOpenFileDialogBox(char *, char *);
BOOL DfSaveAsDialogBox(char *);
void DfGetDlgListText(DFWINDOW, char *, enum DfCommands);
BOOL DfDlgDirList(DFWINDOW, char *, enum DfCommands,
enum DfCommands, unsigned);
BOOL DfRadioButtonSetting(DF_DBOX *, enum DfCommands);
void DfPushRadioButton(DF_DBOX *, enum DfCommands);
void DfPutItemText(DFWINDOW, enum DfCommands, char *);
void DfPutComboListText(DFWINDOW, enum DfCommands, char *);
void DfGetItemText(DFWINDOW, enum DfCommands, char *, int);
char *DfGetDlgTextString(DF_DBOX *, enum DfCommands, DFCLASS);
void DfSetDlgTextString(DF_DBOX *, enum DfCommands, char *, DFCLASS);
BOOL DfCheckBoxSetting(DF_DBOX *, enum DfCommands);
DF_CTLWINDOW *DfFindCommand(DF_DBOX *, enum DfCommands, int);
DFWINDOW DfControlWindow(DF_DBOX *, enum DfCommands);
void DfSetScrollBars(DFWINDOW);
void DfSetRadioButton(DF_DBOX *, DF_CTLWINDOW *);
void DfControlSetting(DF_DBOX *, enum DfCommands, int, int);
void DfSetFocusCursor(DFWINDOW);
#define DfGetControl(wnd) (wnd->ct)
#define DfGetDlgText(db, cmd) DfGetDlgTextString(db, cmd, DF_TEXT)
#define DfGetDlgTextBox(db, cmd) DfGetDlgTextString(db, cmd, DF_TEXTBOX)
#define DfGetEditBoxText(db, cmd) DfGetDlgTextString(db, cmd, DF_EDITBOX)
#define DfGetComboBoxText(db, cmd) DfGetDlgTextString(db, cmd, DF_COMBOBOX)
#define DfSetDlgText(db, cmd, s) DfSetDlgTextString(db, cmd, s, DF_TEXT)
#define DfSetDlgTextBox(db, cmd, s) DfSetDlgTextString(db, cmd, s, DF_TEXTBOX)
#define DfSetEditBoxText(db, cmd, s) DfSetDlgTextString(db, cmd, s, DF_EDITBOX)
#define DfSetComboBoxText(db, cmd, s) DfSetDlgTextString(db, cmd, s, DF_COMBOBOX)
#define DfSetDlgTitle(db, ttl) ((db)->dwnd.title = ttl)
#define DfSetCheckBox(db, cmd) DfControlSetting(db, cmd, DF_CHECKBOX, DF_ON)
#define DfClearCheckBox(db, cmd) DfControlSetting(db, cmd, DF_CHECKBOX, DF_OFF)
#define DfEnableButton(db, cmd) DfControlSetting(db, cmd, DF_BUTTON, DF_ON)
#define DfDisableButton(db, cmd) DfControlSetting(db, cmd, DF_BUTTON, DF_OFF)
/* ---- types of vectors that can be in a picture box ------- */
enum DfVectTypes {DF_VECTOR, DF_SOLIDBAR, DF_HEAVYBAR, DF_CROSSBAR, DF_LIGHTBAR};
/* ------------- picture box prototypes ------------- */
void DfDrawVector(DFWINDOW, int, int, int, int);
void DfDrawBox(DFWINDOW, int, int, int, int);
void DfDrawBar(DFWINDOW, enum DfVectTypes, int, int, int, int);
DFWINDOW DfWatchIcon(void);
/* ------------- help box prototypes ------------- */
void DfLoadHelpFile(void);
void DfUnLoadHelpFile(void);
BOOL DfDisplayHelp(DFWINDOW, char *);
extern char *DfClassNames[];
void DfBuildFileName(char *, char *);
#endif
rosapps/dflat32/dflat32.rbuild
-50
View File
@@ -1,50 +0,0 @@
<module name="dflat32" type="win32cui" installbase="system32" installname="edit.exe">
<include base="ReactOS">include/wine</include>
<include base="dflat32">.</include>
<library>kernel32</library>
<library>gdi32</library>
<file>applicat.c</file>
<file>barchart.c</file>
<file>box.c</file>
<file>button.c</file>
<file>calendar.c</file>
<file>checkbox.c</file>
<file>clipbord.c</file>
<file>combobox.c</file>
<file>config.c</file>
<file>console.c</file>
<file>decomp.c</file>
<file>dfalloc.c</file>
<file>dialbox.c</file>
<file>dialogs.c</file>
<file>direct.c</file>
<file>edit.c</file>
<file>editbox.c</file>
<file>fileopen.c</file>
<file>helpbox.c</file>
<file>htree.c</file>
<file>keys.c</file>
<file>listbox.c</file>
<file>lists.c</file>
<file>log.c</file>
<file>menu.c</file>
<file>menubar.c</file>
<file>menus.c</file>
<file>message.c</file>
<file>msgbox.c</file>
<file>normal.c</file>
<file>pictbox.c</file>
<file>popdown.c</file>
<file>radio.c</file>
<file>rect.c</file>
<file>search.c</file>
<file>slidebox.c</file>
<file>spinbutt.c</file>
<file>statbar.c</file>
<file>sysmenu.c</file>
<file>text.c</file>
<file>textbox.c</file>
<file>video.c</file>
<file>watch.c</file>
<file>window.c</file>
</module>
rosapps/dflat32/dflatmsg.h
-100
View File
@@ -1,100 +0,0 @@
/* ----------- dflatmsg.h ------------ */
/*
* message foundation file
* make message changes here
* other source files will adapt
*/
/* -------------- process communication messages ----------- */
DFlatMsg(DFM_START) /* start message processing */
DFlatMsg(DFM_STOP) /* stop message processing */
DFlatMsg(DFM_COMMAND) /* send a command to a window */
/* -------------- window management messages --------------- */
DFlatMsg(DFM_CREATE_WINDOW) /* create a window */
DFlatMsg(DFM_SHOW_WINDOW) /* show a window */
DFlatMsg(DFM_HIDE_WINDOW) /* hide a window */
DFlatMsg(DFM_CLOSE_WINDOW) /* delete a window */
DFlatMsg(DFM_SETFOCUS) /* set and clear the focus */
DFlatMsg(DFM_PAINT) /* paint the window's data space*/
DFlatMsg(DFM_BORDER) /* paint the window's border */
DFlatMsg(DFM_TITLE) /* display the window's title */
DFlatMsg(DFM_MOVE) /* move the window */
DFlatMsg(DFM_DFM_SIZE) /* change the window's size */
#ifdef INCLUDE_MAXIMIZE
DFlatMsg(DFM_MAXIMIZE) /* maximize the window */
#endif
#ifdef INCLUDE_MINIMIZE
DFlatMsg(DFM_MINIMIZE) /* minimize the window */
#endif
DFlatMsg(DFM_RESTORE) /* restore the window */
DFlatMsg(DFM_INSIDE_WINDOW) /* test x/y inside a window */
/* ---------------- clock messages ------------------------- */
DFlatMsg(DFM_CLOCKTICK) /* the clock ticked */
DFlatMsg(DFM_CAPTURE_CLOCK) /* capture clock into a window */
DFlatMsg(DFM_RELEASE_CLOCK) /* release clock to the system */
/* -------------- keyboard and screen messages ------------- */
DFlatMsg(DFM_KEYBOARD) /* key was pressed */
DFlatMsg(DFM_CAPTURE_KEYBOARD) /* capture keyboard into a window */
DFlatMsg(DFM_RELEASE_KEYBOARD) /* release keyboard to system */
DFlatMsg(DFM_KEYBOARD_CURSOR) /* position the keyboard DfCursor */
DFlatMsg(DFM_CURRENT_KEYBOARD_CURSOR) /*read the DfCursor position */
DFlatMsg(DFM_HIDE_CURSOR) /* hide the keyboard DfCursor */
DFlatMsg(DFM_SHOW_CURSOR) /* display the keyboard DfCursor */
DFlatMsg(DFM_SAVE_CURSOR) /* save the DfCursor's configuration*/
DFlatMsg(DFM_RESTORE_CURSOR) /* restore the saved DfCursor */
DFlatMsg(DFM_SHIFT_CHANGED) /* the shift status changed */
DFlatMsg(DFM_WAITKEYBOARD) /* waits for a key to be released */
/* ---------------- mouse messages ------------------------- */
DFlatMsg(DFM_MOUSE_TRAVEL) /* set the mouse travel */
DFlatMsg(DFM_RIGHT_BUTTON) /* right button pressed */
DFlatMsg(DFM_LEFT_BUTTON) /* left button pressed */
DFlatMsg(DFM_DOUBLE_CLICK) /* left button double-clicked */
DFlatMsg(DFM_MOUSE_MOVED) /* mouse changed position */
DFlatMsg(DFM_BUTTON_RELEASED) /* mouse button released */
DFlatMsg(DFM_WAITMOUSE) /* wait until button released */
DFlatMsg(DFM_TESTMOUSE) /* test any mouse button pressed*/
DFlatMsg(DFM_CAPTURE_MOUSE) /* capture mouse into a window */
DFlatMsg(DFM_RELEASE_MOUSE) /* release the mouse to system */
/* ---------------- text box messages ---------------------- */
DFlatMsg(DFM_ADDTEXT) /* append text to the text box */
DFlatMsg(DFM_INSERTTEXT) /* insert line of text */
DFlatMsg(DFM_DELETETEXT) /* delete line of text */
DFlatMsg(DFM_CLEARTEXT) /* clear the edit box */
DFlatMsg(DFM_SETTEXT) /* copy text to text buffer */
DFlatMsg(DFM_SCROLL) /* vertical line scroll */
DFlatMsg(DFM_HORIZSCROLL) /* horizontal column scroll */
DFlatMsg(DFM_SCROLLPAGE) /* vertical page scroll */
DFlatMsg(DFM_HORIZPAGE) /* horizontal page scroll */
DFlatMsg(DFM_SCROLLDOC) /* scroll to beginning/end */
/* ---------------- edit box messages ---------------------- */
DFlatMsg(DFM_GETTEXT) /* get text from an edit box */
DFlatMsg(DFM_SETTEXTLENGTH) /* set maximum text length */
/* ---------------- menubar messages ----------------------- */
DFlatMsg(DFM_BUILDMENU) /* build the menu display */
DFlatMsg(DFM_MB_SELECTION) /* menubar selection */
/* ---------------- popdown messages ----------------------- */
DFlatMsg(DFM_BUILD_SELECTIONS) /* build the menu display */
DFlatMsg(DFM_CLOSE_POPDOWN) /* tell parent popdown is closing */
/* ---------------- list box messages ---------------------- */
DFlatMsg(DFM_LB_SELECTION) /* sent to parent on selection */
DFlatMsg(DFM_LB_CHOOSE) /* sent when user chooses */
DFlatMsg(DFM_LB_CURRENTSELECTION)/* return the current selection */
DFlatMsg(DFM_LB_GETTEXT) /* return the text of selection */
DFlatMsg(DFM_LB_SETSELECTION) /* sets the listbox selection */
/* ---------------- dialog box messages -------------------- */
DFlatMsg(DFM_INITIATE_DIALOG) /* begin a dialog */
DFlatMsg(DFM_ENTERFOCUS) /* tell DB control got focus */
DFlatMsg(DFM_LEAVEFOCUS) /* tell DB control lost focus */
DFlatMsg(DFM_ENDDIALOG) /* end a dialog */
/* ---------------- help box messages ---------------------- */
DFlatMsg(DFM_DISPLAY_HELP)
/* --------------- application window messages ------------- */
DFlatMsg(DFM_ADDSTATUS)
/* --------------- picture box messages -------------------- */
DFlatMsg(DFM_DRAWVECTOR)
DFlatMsg(DFM_DRAWBOX)
DFlatMsg(DFM_DRAWBAR)
rosapps/dflat32/dialbox.c
-792
View File
@@ -1,792 +0,0 @@
/* ----------------- dialbox.c -------------- */
#include "dflat.h"
static int inFocusCommand(DF_DBOX *);
static void dbShortcutKeys(DF_DBOX *, int);
static int ControlProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void FirstFocus(DF_DBOX *db);
static void NextFocus(DF_DBOX *db);
static void PrevFocus(DF_DBOX *db);
static DF_CTLWINDOW *AssociatedControl(DF_DBOX *, enum DfCommands);
static BOOL SysMenuOpen;
static DF_DBOX **dbs = NULL;
static int dbct = 0;
/* --- clear all heap allocations to control text fields --- */
void DfClearDialogBoxes(void)
{
int i;
for (i = 0; i < dbct; i++)
{
DF_CTLWINDOW *ct = (*(dbs+i))->ctl;
while (ct->class)
{
if ((ct->class == DF_EDITBOX ||
ct->class == DF_COMBOBOX) &&
ct->itext != NULL)
{
free(ct->itext);
}
ct++;
}
}
if (dbs != NULL)
{
free(dbs);
dbs = NULL;
}
dbct = 0;
}
/* -------- DFM_CREATE_WINDOW Message --------- */
static int CreateWindowMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DF_DBOX *db = wnd->extension;
DF_CTLWINDOW *ct = db->ctl;
DFWINDOW cwnd;
int rtn, i;
/* ---- build a table of processed dialog boxes ---- */
for (i = 0; i < dbct; i++)
if (db == dbs[i])
break;
if (i == dbct) {
dbs = DfRealloc(dbs, sizeof(DF_DBOX *) * (dbct+1));
*(dbs + dbct++) = db;
}
rtn = DfBaseWndProc(DF_DIALOG, wnd, DFM_CREATE_WINDOW, p1, p2);
ct = db->ctl;
while (ct->class) {
int attrib = 0;
if (DfTestAttribute(wnd, DF_NOCLIP))
attrib |= DF_NOCLIP;
if (wnd->Modal)
attrib |= DF_SAVESELF;
ct->setting = ct->isetting;
if (ct->class == DF_EDITBOX && ct->dwnd.h > 1)
attrib |= (DF_MULTILINE | DF_HASBORDER);
else if ((ct->class == DF_LISTBOX || ct->class == DF_TEXTBOX) &&
ct->dwnd.h > 2)
attrib |= DF_HASBORDER;
cwnd = DfDfCreateWindow(ct->class,
ct->dwnd.title,
ct->dwnd.x+DfGetClientLeft(wnd),
ct->dwnd.y+DfGetClientTop(wnd),
ct->dwnd.h,
ct->dwnd.w,
ct,
wnd,
ControlProc,
attrib);
if ((ct->class == DF_EDITBOX ||
ct->class == DF_COMBOBOX) &&
ct->itext != NULL)
DfSendMessage(cwnd, DFM_SETTEXT, (DF_PARAM) ct->itext, 0);
ct++;
}
return rtn;
}
/* -------- DFM_LEFT_BUTTON Message --------- */
static BOOL LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DF_DBOX *db = wnd->extension;
DF_CTLWINDOW *ct = db->ctl;
if (DfWindowSizing || DfWindowMoving)
return TRUE;
if (DfHitControlBox(wnd, p1-DfGetLeft(wnd), p2-DfGetTop(wnd))) {
DfPostMessage(wnd, DFM_KEYBOARD, ' ', DF_ALTKEY);
return TRUE;
}
while (ct->class) {
DFWINDOW cwnd = ct->wnd;
if (ct->class == DF_COMBOBOX) {
if (p2 == DfGetTop(cwnd)) {
if (p1 == DfGetRight(cwnd)+1) {
DfSendMessage(cwnd, DFM_LEFT_BUTTON, p1, p2);
return TRUE;
}
}
if (DfGetClass(DfInFocus) == DF_LISTBOX)
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
}
else if (ct->class == DF_SPINBUTTON) {
if (p2 == DfGetTop(cwnd)) {
if (p1 == DfGetRight(cwnd)+1 ||
p1 == DfGetRight(cwnd)+2) {
DfSendMessage(cwnd, DFM_LEFT_BUTTON, p1, p2);
return TRUE;
}
}
}
ct++;
}
return FALSE;
}
/* -------- DFM_KEYBOARD Message --------- */
static BOOL KeyboardMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DF_DBOX *db = wnd->extension;
DF_CTLWINDOW *ct;
if (DfWindowMoving || DfWindowSizing)
return FALSE;
switch ((int)p1) {
case DF_F1:
ct = DfGetControl(DfInFocus);
if (ct != NULL)
if (DfDisplayHelp(wnd, ct->help))
return TRUE;
break;
case DF_SHIFT_HT:
case DF_BS:
case DF_UP:
PrevFocus(db);
break;
case DF_ALT_F6:
case '\t':
case DF_FWD:
case DF_DN:
NextFocus(db);
break;
case ' ':
if (((int)p2 & DF_ALTKEY) &&
DfTestAttribute(wnd, DF_CONTROLBOX)) {
SysMenuOpen = TRUE;
DfBuildSystemMenu(wnd);
}
break;
case DF_CTRL_F4:
case DF_ESC:
DfSendMessage(wnd, DFM_COMMAND, DF_ID_CANCEL, 0);
break;
default:
/* ------ search all the shortcut keys ----- */
dbShortcutKeys(db, (int) p1);
break;
}
return wnd->Modal;
}
/* -------- COMMAND Message --------- */
static BOOL CommandMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DF_DBOX *db = wnd->extension;
switch ((int) p1) {
case DF_ID_OK:
case DF_ID_CANCEL:
if ((int)p2 != 0)
return TRUE;
wnd->ReturnCode = (int) p1;
if (wnd->Modal)
DfPostMessage(wnd, DFM_ENDDIALOG, 0, 0);
else
DfSendMessage(wnd, DFM_CLOSE_WINDOW, TRUE, 0);
return TRUE;
case DF_ID_HELP:
if ((int)p2 != 0)
return TRUE;
return DfDisplayHelp(wnd, db->HelpName);
default:
break;
}
return FALSE;
}
/* ----- window-processing module, DF_DIALOG window class ----- */
int DfDialogProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DF_DBOX *db = wnd->extension;
switch (msg) {
case DFM_CREATE_WINDOW:
return CreateWindowMsg(wnd, p1, p2);
case DFM_SHIFT_CHANGED:
if (wnd->Modal)
return TRUE;
break;
case DFM_LEFT_BUTTON:
if (LeftButtonMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_KEYBOARD:
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_CLOSE_POPDOWN:
SysMenuOpen = FALSE;
break;
case DFM_LB_SELECTION:
case DFM_LB_CHOOSE:
if (SysMenuOpen)
return TRUE;
DfSendMessage(wnd, DFM_COMMAND, inFocusCommand(db), msg);
break;
case DFM_COMMAND:
if (CommandMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_PAINT:
p2 = TRUE;
break;
case DFM_MOVE:
case DFM_DFM_SIZE:
rtn = DfBaseWndProc(DF_DIALOG, wnd, msg, p1, p2);
if (wnd->dfocus != NULL)
DfSendMessage(wnd->dfocus, DFM_SETFOCUS, TRUE, 0);
return rtn;
case DFM_CLOSE_WINDOW:
if (!p1)
{
DfSendMessage(wnd, DFM_COMMAND, DF_ID_CANCEL, 0);
return TRUE;
}
break;
default:
break;
}
return DfBaseWndProc(DF_DIALOG, wnd, msg, p1, p2);
}
/* ------- create and execute a dialog box ---------- */
BOOL DfDialogBox(DFWINDOW wnd, DF_DBOX *db, BOOL Modal,
int (*wndproc)(struct DfWindow *, enum DfMessages, DF_PARAM, DF_PARAM))
{
BOOL rtn;
int x = db->dwnd.x, y = db->dwnd.y;
DFWINDOW DialogWnd;
if (!Modal && wnd != NULL)
{
x += DfGetLeft(wnd);
y += DfGetTop(wnd);
}
DialogWnd = DfDfCreateWindow(DF_DIALOG,
db->dwnd.title,
x, y,
db->dwnd.h,
db->dwnd.w,
db,
wnd,
wndproc,
Modal ? DF_SAVESELF : 0);
DialogWnd->Modal = Modal;
FirstFocus(db);
DfPostMessage(DialogWnd, DFM_INITIATE_DIALOG, 0, 0);
if (Modal)
{
DfSendMessage(DialogWnd, DFM_CAPTURE_MOUSE, 0, 0);
DfSendMessage(DialogWnd, DFM_CAPTURE_KEYBOARD, 0, 0);
while (DfDispatchMessage ())
;
rtn = DialogWnd->ReturnCode == DF_ID_OK;
DfSendMessage(DialogWnd, DFM_RELEASE_MOUSE, 0, 0);
DfSendMessage(DialogWnd, DFM_RELEASE_KEYBOARD, 0, 0);
DfSendMessage(DialogWnd, DFM_CLOSE_WINDOW, TRUE, 0);
return rtn;
}
return FALSE;
}
/* ----- return command code of in-focus control window ---- */
static int inFocusCommand(DF_DBOX *db)
{
DF_CTLWINDOW *ct = db->ctl;
while (ct->class) {
if (ct->wnd == DfInFocus)
return ct->command;
ct++;
}
return -1;
}
/* -------- find a specified control structure ------- */
DF_CTLWINDOW *DfFindCommand(DF_DBOX *db, enum DfCommands cmd, int class)
{
DF_CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->class == class)
if (cmd == ct->command)
return ct;
ct++;
}
return NULL;
}
/* ---- return the window handle of a specified command ---- */
DFWINDOW DfControlWindow(DF_DBOX *db, enum DfCommands cmd)
{
DF_CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->class != DF_TEXT && cmd == ct->command)
return ct->wnd;
ct++;
}
return NULL;
}
/* --- return a pointer to the control structure that matches a window --- */
DF_CTLWINDOW *WindowControl(DF_DBOX *db, DFWINDOW wnd)
{
DF_CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->wnd == wnd)
return ct;
ct++;
}
return NULL;
}
/* ---- set a control DF_ON or DF_OFF ----- */
void DfControlSetting(DF_DBOX *db, enum DfCommands cmd,
int class, int setting)
{
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, class);
if (ct != NULL) {
ct->isetting = setting;
if (ct->wnd != NULL)
ct->setting = setting;
}
}
/* ---- return pointer to the text of a control window ---- */
char *DfGetDlgTextString(DF_DBOX *db,enum DfCommands cmd,DFCLASS class)
{
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, class);
if (ct != NULL)
return ct->itext;
else
return NULL;
}
/* ------- set the text of a control specification ------ */
void DfSetDlgTextString(DF_DBOX *db, enum DfCommands cmd,
char *text, DFCLASS class)
{
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, class);
if (ct != NULL) {
ct->itext = DfRealloc(ct->itext, strlen(text)+1);
strcpy(ct->itext, text);
}
}
/* ------- set the text of a control window ------ */
void DfPutItemText(DFWINDOW wnd, enum DfCommands cmd, char *text)
{
DF_CTLWINDOW *ct = DfFindCommand(wnd->extension, cmd, DF_EDITBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_TEXTBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_COMBOBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_LISTBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_SPINBUTTON);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_TEXT);
if (ct != NULL) {
DFWINDOW cwnd = (DFWINDOW) (ct->wnd);
switch (ct->class) {
case DF_COMBOBOX:
case DF_EDITBOX:
DfSendMessage(cwnd, DFM_CLEARTEXT, 0, 0);
DfSendMessage(cwnd, DFM_ADDTEXT, (DF_PARAM) text, 0);
if (!DfIsMultiLine(cwnd))
DfSendMessage(cwnd, DFM_PAINT, 0, 0);
break;
case DF_LISTBOX:
case DF_TEXTBOX:
case DF_SPINBUTTON:
DfSendMessage(cwnd, DFM_ADDTEXT, (DF_PARAM) text, 0);
break;
case DF_TEXT: {
DfSendMessage(cwnd, DFM_CLEARTEXT, 0, 0);
DfSendMessage(cwnd, DFM_ADDTEXT, (DF_PARAM) text, 0);
DfSendMessage(cwnd, DFM_PAINT, 0, 0);
break;
}
default:
break;
}
}
}
/* ------- get the text of a control window ------ */
void DfGetItemText(DFWINDOW wnd, enum DfCommands cmd,
char *text, int len)
{
DF_CTLWINDOW *ct = DfFindCommand(wnd->extension, cmd, DF_EDITBOX);
char *cp;
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_COMBOBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_TEXTBOX);
if (ct == NULL)
ct = DfFindCommand(wnd->extension, cmd, DF_TEXT);
if (ct != NULL) {
DFWINDOW cwnd = (DFWINDOW) (ct->wnd);
if (cwnd != NULL) {
switch (ct->class) {
case DF_TEXT:
if (DfGetText(cwnd) != NULL) {
cp = strchr(DfGetText(cwnd), '\n');
if (cp != NULL)
len = (int) (cp - DfGetText(cwnd));
strncpy(text, DfGetText(cwnd), len);
*(text+len) = '\0';
}
break;
case DF_TEXTBOX:
if (DfGetText(cwnd) != NULL)
strncpy(text, DfGetText(cwnd), len);
break;
case DF_COMBOBOX:
case DF_EDITBOX:
DfSendMessage(cwnd,DFM_GETTEXT,(DF_PARAM)text,len);
break;
default:
break;
}
}
}
}
/* ------- set the text of a listbox control window ------ */
void DfGetDlgListText(DFWINDOW wnd, char *text, enum DfCommands cmd)
{
DF_CTLWINDOW *ct = DfFindCommand(wnd->extension, cmd, DF_LISTBOX);
int sel = DfSendMessage(ct->wnd, DFM_LB_CURRENTSELECTION, 0, 0);
DfSendMessage(ct->wnd, DFM_LB_GETTEXT, (DF_PARAM) text, sel);
}
/* -- find control structure associated with text control -- */
static DF_CTLWINDOW *AssociatedControl(DF_DBOX *db,enum DfCommands Tcmd)
{
DF_CTLWINDOW *ct = db->ctl;
while (ct->class) {
if (ct->class != DF_TEXT)
if (ct->command == Tcmd)
break;
ct++;
}
return ct;
}
/* --- process dialog box shortcut keys --- */
static void dbShortcutKeys(DF_DBOX *db, int ky)
{
DF_CTLWINDOW *ct;
int ch = DfAltConvert(ky);
if (ch != 0) {
ct = db->ctl;
while (ct->class) {
char *cp = ct->itext;
while (cp && *cp) {
if (*cp == DF_SHORTCUTCHAR &&
tolower(*(cp+1)) == ch) {
if (ct->class == DF_TEXT)
ct = AssociatedControl(db, ct->command);
if (ct->class == DF_RADIOBUTTON)
DfSetRadioButton(db, ct);
else if (ct->class == DF_CHECKBOX) {
ct->setting ^= DF_ON;
DfSendMessage(ct->wnd, DFM_PAINT, 0, 0);
}
else if (ct->class) {
DfSendMessage(ct->wnd, DFM_SETFOCUS, TRUE, 0);
if (ct->class == DF_BUTTON)
DfSendMessage(ct->wnd,DFM_KEYBOARD,'\r',0);
}
return;
}
cp++;
}
ct++;
}
}
}
/* --- dynamically add or remove scroll bars
from a control window ---- */
void DfSetScrollBars(DFWINDOW wnd)
{
int oldattr = DfGetAttribute(wnd);
if (wnd->wlines > DfClientHeight(wnd))
DfAddAttribute(wnd, DF_VSCROLLBAR);
else
DfClearAttribute(wnd, DF_VSCROLLBAR);
if (wnd->textwidth > DfClientWidth(wnd))
DfAddAttribute(wnd, DF_HSCROLLBAR);
else
DfClearAttribute(wnd, DF_HSCROLLBAR);
if (DfGetAttribute(wnd) != oldattr)
DfSendMessage(wnd, DFM_BORDER, 0, 0);
}
/* ------- DFM_CREATE_WINDOW Message (Control) ----- */
static void CtlCreateWindowMsg(DFWINDOW wnd)
{
DF_CTLWINDOW *ct;
ct = wnd->ct = wnd->extension;
wnd->extension = NULL;
if (ct != NULL)
ct->wnd = wnd;
}
/* ------- DFM_KEYBOARD Message (Control) ----- */
static BOOL CtlKeyboardMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DF_CTLWINDOW *ct = DfGetControl(wnd);
switch ((int) p1) {
case DF_F1:
if (DfWindowMoving || DfWindowSizing)
break;
if (!DfDisplayHelp(wnd, ct->help))
DfSendMessage(DfGetParent(wnd),DFM_COMMAND,DF_ID_HELP,0);
return TRUE;
case ' ':
if (!((int)p2 & DF_ALTKEY))
break;
case DF_ALT_F6:
case DF_CTRL_F4:
case DF_ALT_F4:
DfPostMessage(DfGetParent(wnd), DFM_KEYBOARD, p1, p2);
return TRUE;
default:
break;
}
if (DfGetClass(wnd) == DF_EDITBOX)
if (DfIsMultiLine(wnd))
return FALSE;
switch ((int) p1) {
case DF_UP:
if (!DfIsDerivedFrom(wnd, DF_LISTBOX)) {
p1 = DF_CTRL_FIVE;
p2 = DF_LEFTSHIFT;
}
break;
case DF_BS:
if (!DfIsDerivedFrom(wnd, DF_EDITBOX)) {
p1 = DF_CTRL_FIVE;
p2 = DF_LEFTSHIFT;
}
break;
case DF_DN:
if (!DfIsDerivedFrom(wnd, DF_LISTBOX) &&
!DfIsDerivedFrom(wnd, DF_COMBOBOX))
p1 = '\t';
break;
case DF_FWD:
if (!DfIsDerivedFrom(wnd, DF_EDITBOX))
p1 = '\t';
break;
case '\r':
if (DfIsDerivedFrom(wnd, DF_EDITBOX))
if (DfIsMultiLine(wnd))
break;
if (DfIsDerivedFrom(wnd, DF_BUTTON))
break;
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_OK, 0);
return TRUE;
default:
break;
}
return FALSE;
}
/* ------- DFM_CLOSE_WINDOW Message (Control) ----- */
static void CtlCloseWindowMsg(DFWINDOW wnd)
{
DF_CTLWINDOW *ct = DfGetControl(wnd);
if (ct != NULL) {
ct->wnd = NULL;
if (DfGetParent(wnd)->ReturnCode == DF_ID_OK) {
if (ct->class == DF_EDITBOX || ct->class == DF_COMBOBOX) {
if (wnd->TextChanged) {
ct->itext=DfRealloc(ct->itext,strlen(wnd->text)+1);
strcpy(ct->itext, wnd->text);
if (!DfIsMultiLine(wnd)) {
char *cp = ct->itext+strlen(ct->itext)-1;
if (*cp == '\n')
*cp = '\0';
}
}
}
else if (ct->class == DF_RADIOBUTTON || ct->class == DF_CHECKBOX)
ct->isetting = ct->setting;
}
}
}
static void FixColors(DFWINDOW wnd)
{
DF_CTLWINDOW *ct = wnd->ct;
if (ct->class != DF_BUTTON)
{
if (ct->class != DF_SPINBUTTON && ct->class != DF_COMBOBOX)
{
wnd->WindowColors[DF_FRAME_COLOR][DF_FG] =
DfGetParent(wnd)->WindowColors[DF_FRAME_COLOR][DF_FG];
wnd->WindowColors[DF_FRAME_COLOR][DF_BG] =
DfGetParent(wnd)->WindowColors[DF_FRAME_COLOR][DF_BG];
if (ct->class != DF_EDITBOX && ct->class != DF_LISTBOX)
{
wnd->WindowColors[DF_STD_COLOR][DF_FG] =
DfGetParent(wnd)->WindowColors[DF_STD_COLOR][DF_FG];
wnd->WindowColors[DF_STD_COLOR][DF_BG] =
DfGetParent(wnd)->WindowColors[DF_STD_COLOR][DF_BG];
}
}
}
}
/* -- generic window processor used by dialog box controls -- */
static int ControlProc(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
DF_DBOX *db;
if (wnd == NULL)
return FALSE;
db = DfGetParent(wnd) ? DfGetParent(wnd)->extension : NULL;
switch (msg) {
case DFM_CREATE_WINDOW:
CtlCreateWindowMsg(wnd);
break;
case DFM_KEYBOARD:
if (CtlKeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_PAINT:
FixColors(wnd);
if (DfGetClass(wnd) == DF_EDITBOX ||
DfGetClass(wnd) == DF_LISTBOX ||
DfGetClass(wnd) == DF_TEXTBOX)
DfSetScrollBars(wnd);
break;
case DFM_BORDER:
FixColors(wnd);
if (DfGetClass(wnd) == DF_EDITBOX) {
DFWINDOW oldFocus = DfInFocus;
DfInFocus = NULL;
DfDefaultWndProc(wnd, msg, p1, p2);
DfInFocus = oldFocus;
return TRUE;
}
break;
case DFM_SETFOCUS: {
DFWINDOW pwnd = DfGetParent(wnd);
if (p1)
{
DfDefaultWndProc(wnd, msg, p1, p2);
if (pwnd != NULL)
{
pwnd->dfocus = wnd;
DfSendMessage(pwnd, DFM_COMMAND,
inFocusCommand(db), DFM_ENTERFOCUS);
}
return TRUE;
}
else
DfSendMessage(pwnd, DFM_COMMAND,
inFocusCommand(db), DFM_LEAVEFOCUS);
break;
}
case DFM_CLOSE_WINDOW:
CtlCloseWindowMsg(wnd);
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* ---- change the focus to the first control --- */
static void FirstFocus(DF_DBOX *db)
{
DF_CTLWINDOW *ct = db->ctl;
if (ct != NULL)
{
while (ct->class == DF_TEXT || ct->class == DF_BOX) {
ct++;
if (ct->class == 0)
return;
}
DfSendMessage(ct->wnd, DFM_SETFOCUS, TRUE, 0);
}
}
/* ---- change the focus to the next control --- */
static void NextFocus(DF_DBOX *db)
{
DF_CTLWINDOW *ct = WindowControl(db, DfInFocus);
int looped = 0;
if (ct != NULL)
{
do
{
ct++;
if (ct->class == 0)
{
if (looped)
return;
looped++;
ct = db->ctl;
}
} while (ct->class == DF_TEXT || ct->class == DF_BOX);
DfSendMessage(ct->wnd, DFM_SETFOCUS, TRUE, 0);
}
}
/* ---- change the focus to the previous control --- */
static void PrevFocus(DF_DBOX *db)
{
DF_CTLWINDOW *ct = WindowControl(db, DfInFocus);
int looped = 0;
if (ct != NULL)
{
do
{
if (ct == db->ctl)
{
if (looped)
return;
looped++;
while (ct->class)
ct++;
}
--ct;
} while (ct->class == DF_TEXT || ct->class == DF_BOX);
DfSendMessage(ct->wnd, DFM_SETFOCUS, TRUE, 0);
}
}
void DfSetFocusCursor(DFWINDOW wnd)
{
if (wnd == DfInFocus)
{
DfSendMessage(NULL, DFM_SHOW_CURSOR, 0, 0);
DfSendMessage(wnd, DFM_KEYBOARD_CURSOR, 1, 0);
}
}
/* EOF */
rosapps/dflat32/dialbox.h
-55
View File
@@ -1,55 +0,0 @@
/* ----------------- dialbox.h ---------------- */
#ifndef DIALOG_H
#define DIALOG_H
#include <stdio.h>
#define DF_MAXCONTROLS 30
#define DF_MAXRADIOS 20
#define DF_OFF FALSE
#define DF_ON TRUE
/* -------- dialog box and control window structure ------- */
typedef struct {
char *title; /* window title */
int x, y; /* relative coordinates */
int h, w; /* size */
} DF_DIALOGWINDOW;
/* ------ one of these for each control window ------- */
typedef struct {
DF_DIALOGWINDOW dwnd;
DFCLASS class; /* DF_LISTBOX, DF_BUTTON, etc */
char *itext; /* initialized text */
int command; /* command code */
char *help; /* help mnemonic */
BOOL isetting; /* initially DF_ON or DF_OFF */
BOOL setting; /* DF_ON or DF_OFF */
void *wnd; /* window handle */
} DF_CTLWINDOW;
/* --------- one of these for each dialog box ------- */
typedef struct {
char *HelpName;
DF_DIALOGWINDOW dwnd;
DF_CTLWINDOW ctl[DF_MAXCONTROLS+1];
} DF_DBOX;
/* -------- macros for dialog box resource compile -------- */
#define DF_DIALOGBOX(db) DF_DBOX db={ #db,
#define DF_DB_TITLE(ttl,x,y,h,w) {ttl,x,y,h,w},{
#define DF_CONTROL(ty,tx,x,y,h,w,c) \
{{NULL,x,y,h,w},ty, \
(ty==DF_EDITBOX||ty==DF_COMBOBOX?NULL:tx), \
c,#c,(ty==DF_BUTTON?DF_ON:DF_OFF),DF_OFF,NULL},
#define DF_ENDDB {{NULL}} }};
#define DfCancel " Cancel "
#define DfOk " OK "
#define DfYes " Yes "
#define DfNo " No "
#endif
rosapps/dflat32/dialogs.c
-160
View File
@@ -1,160 +0,0 @@
/* ----------- dialogs.c --------------- */
#include "dflat.h"
/* -------------- the File Open dialog box --------------- */
DF_DIALOGBOX( FileOpen )
DF_DB_TITLE( "Open File", -1,-1,19,48)
DF_CONTROL(DF_TEXT, "~Filename", 2, 1, 1, 8, DF_ID_FILENAME)
DF_CONTROL(DF_EDITBOX, NULL, 13, 1, 1,29, DF_ID_FILENAME)
DF_CONTROL(DF_TEXT, "Directory:", 2, 3, 1,10, 0)
DF_CONTROL(DF_TEXT, NULL, 13, 3, 1,28, DF_ID_PATH)
DF_CONTROL(DF_TEXT, "F~iles", 2, 5, 1, 5, DF_ID_FILES)
DF_CONTROL(DF_LISTBOX, NULL, 2, 6,11,16, DF_ID_FILES)
DF_CONTROL(DF_TEXT, "~Directories", 19, 5, 1,11, DF_ID_DRIVE)
DF_CONTROL(DF_LISTBOX, NULL, 19, 6,11,16, DF_ID_DRIVE)
DF_CONTROL(DF_BUTTON, " ~OK ", 36, 7, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 36,10, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 36,13, 1, 8, DF_ID_HELP)
DF_ENDDB
/* -------------- the Save As dialog box --------------- */
DF_DIALOGBOX( SaveAs )
DF_DB_TITLE( "Save As", -1,-1,19,48)
DF_CONTROL(DF_TEXT, "~Filename", 2, 1, 1, 8, DF_ID_FILENAME)
DF_CONTROL(DF_EDITBOX, NULL, 13, 1, 1,29, DF_ID_FILENAME)
DF_CONTROL(DF_TEXT, "Directory:", 2, 3, 1,10, 0)
DF_CONTROL(DF_TEXT, NULL, 13, 3, 1,28, DF_ID_PATH)
DF_CONTROL(DF_TEXT, "~Directories",2, 5, 1,11, DF_ID_DRIVE)
DF_CONTROL(DF_LISTBOX, NULL, 2, 6,11,16, DF_ID_DRIVE)
DF_CONTROL(DF_BUTTON, " ~OK ", 36, 7, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 36,10, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 36,13, 1, 8, DF_ID_HELP)
DF_ENDDB
/* -------------- The Printer Setup dialog box ------------------ */
DF_DIALOGBOX( PrintSetup )
DF_DB_TITLE( "Printer Setup", -1, -1, 17, 32)
DF_CONTROL(DF_BOX, "Margins", 2, 3, 9, 26, 0 )
DF_CONTROL(DF_TEXT, "~Port:", 4, 1, 1, 5, DF_ID_PRINTERPORT)
DF_CONTROL(DF_COMBOBOX, NULL, 12, 1, 8, 9, DF_ID_PRINTERPORT)
DF_CONTROL(DF_TEXT, "~Left:", 6, 4, 1, 5, DF_ID_LEFTMARGIN)
DF_CONTROL(DF_SPINBUTTON, NULL, 17, 4, 1, 6, DF_ID_LEFTMARGIN)
DF_CONTROL(DF_TEXT, "~Right:", 6, 6, 1, 6, DF_ID_RIGHTMARGIN)
DF_CONTROL(DF_SPINBUTTON, NULL, 17, 6, 1, 6, DF_ID_RIGHTMARGIN)
DF_CONTROL(DF_TEXT, "~Top:", 6, 8, 1, 4, DF_ID_TOPMARGIN)
DF_CONTROL(DF_SPINBUTTON, NULL, 17, 8, 1, 6, DF_ID_TOPMARGIN)
DF_CONTROL(DF_TEXT, "~Bottom:", 6, 10, 1, 7, DF_ID_BOTTOMMARGIN)
DF_CONTROL(DF_SPINBUTTON, NULL, 17, 10, 1, 6, DF_ID_BOTTOMMARGIN)
DF_CONTROL(DF_BUTTON, " ~OK ", 1, 13, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 11, 13, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 21, 13, 1, 8, DF_ID_HELP)
DF_ENDDB
/* -------------- the Search Text dialog box --------------- */
DF_DIALOGBOX( SearchTextDB )
DF_DB_TITLE( "Search Text", -1,-1,9,48)
DF_CONTROL(DF_TEXT, "~Search for:", 2, 1, 1, 11, DF_ID_SEARCHFOR)
DF_CONTROL(DF_EDITBOX, NULL, 14, 1, 1, 29, DF_ID_SEARCHFOR)
DF_CONTROL(DF_TEXT, "~Match upper/lower case:", 2, 3, 1, 23, DF_ID_MATCHCASE)
DF_CONTROL(DF_CHECKBOX, NULL, 26, 3, 1, 3, DF_ID_MATCHCASE)
DF_CONTROL(DF_BUTTON, " ~OK ", 7, 5, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 19, 5, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 31, 5, 1, 8, DF_ID_HELP)
DF_ENDDB
/* -------------- the Replace Text dialog box --------------- */
DF_DIALOGBOX( ReplaceTextDB )
DF_DB_TITLE( "Replace Text", -1,-1,12,50)
DF_CONTROL(DF_TEXT, "~Search for:", 2, 1, 1, 11, DF_ID_SEARCHFOR)
DF_CONTROL(DF_EDITBOX, NULL, 16, 1, 1, 29, DF_ID_SEARCHFOR)
DF_CONTROL(DF_TEXT, "~Replace with:", 2, 3, 1, 13, DF_ID_REPLACEWITH)
DF_CONTROL(DF_EDITBOX, NULL, 16, 3, 1, 29, DF_ID_REPLACEWITH)
DF_CONTROL(DF_TEXT, "~Match upper/lower case:", 2, 5, 1, 23, DF_ID_MATCHCASE)
DF_CONTROL(DF_CHECKBOX, NULL, 26, 5, 1, 3, DF_ID_MATCHCASE)
DF_CONTROL(DF_TEXT, "Replace ~Every Match:", 2, 6, 1, 23, DF_ID_REPLACEALL)
DF_CONTROL(DF_CHECKBOX, NULL, 26, 6, 1, 3, DF_ID_REPLACEALL)
DF_CONTROL(DF_BUTTON, " ~OK ", 7, 8, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 20, 8, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 33, 8, 1, 8, DF_ID_HELP)
DF_ENDDB
/* -------------- generic message dialog box --------------- */
DF_DIALOGBOX( MsgBox )
DF_DB_TITLE( NULL, -1,-1, 0, 0)
DF_CONTROL(DF_TEXT, NULL, 1, 1, 0, 0, 0)
DF_CONTROL(DF_BUTTON, NULL, 0, 0, 1, 8, DF_ID_OK)
DF_CONTROL(0, NULL, 0, 0, 1, 8, DF_ID_CANCEL)
DF_ENDDB
/* ----------- DfInputBox Dialog Box ------------ */
DF_DIALOGBOX( InputBoxDB )
DF_DB_TITLE( NULL, -1,-1, 9, 0)
DF_CONTROL(DF_TEXT, NULL, 1, 1, 1, 0, 0)
DF_CONTROL(DF_EDITBOX, NULL, 1, 3, 1, 0, DF_ID_INPUTTEXT)
DF_CONTROL(DF_BUTTON, " ~OK ", 0, 5, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 0, 5, 1, 8, DF_ID_CANCEL)
DF_ENDDB
/* ----------- DfSliderBox Dialog Box ------------- */
DF_DIALOGBOX( SliderBoxDB )
DF_DB_TITLE( NULL, -1,-1, 9, 0)
DF_CONTROL(DF_TEXT, NULL, 0, 1, 1, 0, 0)
DF_CONTROL(DF_TEXT, NULL, 0, 3, 1, 0, 0)
DF_CONTROL(DF_BUTTON, " Cancel ", 0, 5, 1, 8, DF_ID_CANCEL)
DF_ENDDB
/* ------------ Display dialog box -------------- */
DF_DIALOGBOX( Display )
DF_DB_TITLE( "Display", -1, -1, 12, 35)
DF_CONTROL(DF_BOX, "Window", 7, 1, 6,20, 0)
DF_CONTROL(DF_CHECKBOX, NULL, 9, 2, 1, 3, DF_ID_TITLE)
DF_CONTROL(DF_TEXT, "~Title", 15, 2, 1, 5, DF_ID_TITLE)
DF_CONTROL(DF_CHECKBOX, NULL, 9, 3, 1, 3, DF_ID_BORDER)
DF_CONTROL(DF_TEXT, "~Border", 15, 3, 1, 6, DF_ID_BORDER)
DF_CONTROL(DF_CHECKBOX, NULL, 9, 4, 1, 3, DF_ID_STATUSBAR)
DF_CONTROL(DF_TEXT, "~Status bar",15, 4, 1,10, DF_ID_STATUSBAR)
DF_CONTROL(DF_CHECKBOX, NULL, 9, 5, 1, 3, DF_ID_TEXTURE)
DF_CONTROL(DF_TEXT, "Te~xture", 15, 5, 1, 7, DF_ID_TEXTURE)
DF_CONTROL(DF_BUTTON, " ~OK ", 2, 8,1,8,DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 12, 8,1,8,DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 22, 8,1,8,DF_ID_HELP)
DF_ENDDB
/* ------------ Windows dialog box -------------- */
DF_DIALOGBOX( Windows )
DF_DB_TITLE( "Windows", -1, -1, 19, 24)
DF_CONTROL(DF_LISTBOX, NULL, 1, 1,11,20, DF_ID_WINDOWLIST)
DF_CONTROL(DF_BUTTON, " ~OK ", 2, 13, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 12, 13, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 7, 15, 1, 8, DF_ID_HELP)
DF_ENDDB
#ifdef INCLUDE_LOGGING
/* ------------ Message Log dialog box -------------- */
DF_DIALOGBOX( Log )
DF_DB_TITLE( "D-Flat Message Log", -1, -1, 18, 41)
DF_CONTROL(DF_TEXT, "~Messages", 10, 1, 1, 8, DF_ID_LOGLIST)
DF_CONTROL(DF_LISTBOX, NULL, 1, 2, 14, 26, DF_ID_LOGLIST)
DF_CONTROL(DF_TEXT, "~Logging:", 29, 4, 1, 10, DF_ID_LOGGING)
DF_CONTROL(DF_CHECKBOX, NULL, 31, 5, 1, 3, DF_ID_LOGGING)
DF_CONTROL(DF_BUTTON, " ~OK ", 29, 7, 1, 8, DF_ID_OK)
DF_CONTROL(DF_BUTTON, " ~Cancel ", 29, 10, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Help ", 29, 13, 1, 8, DF_ID_HELP)
DF_ENDDB
#endif
/* ------------ the Help window dialog box -------------- */
DF_DIALOGBOX( HelpBox )
DF_DB_TITLE( NULL, -1, -1, 0, 45)
DF_CONTROL(DF_TEXTBOX, NULL, 1, 1, 0, 40, DF_ID_HELPTEXT)
DF_CONTROL(DF_BUTTON, " ~Close ", 0, 0, 1, 8, DF_ID_CANCEL)
DF_CONTROL(DF_BUTTON, " ~Back ", 10, 0, 1, 8, DF_ID_BACK)
DF_CONTROL(DF_BUTTON, "<< ~Prev ", 20, 0, 1, 8, DF_ID_PREV)
DF_CONTROL(DF_BUTTON, " ~Next >>", 30, 0, 1, 8, DF_ID_NEXT)
DF_ENDDB
/* EOF */
rosapps/dflat32/direct.c
-175
View File
@@ -1,175 +0,0 @@
/* ---------- direct.c --------- */
#include <direct.h>
#include <io.h>
#include "dflat.h"
#define DRIVE 1
#define DIRECTORY 2
#define FILENAME 4
#define EXTENSION 8
static char path[MAX_PATH];
static char drive[_MAX_DRIVE] = " :";
static char dir[_MAX_DIR];
static char name[_MAX_FNAME];
static char ext[_MAX_EXT];
/* ----- Create unambiguous path from file spec, filling in the
drive and directory if incomplete. Optionally change to
the new drive and subdirectory ------ */
void DfCreatePath(char *path,char *fspec,int InclName,int Change)
{
int cm = 0;
char currdir[MAX_PATH];
char *cp;
/* save the current directory */
if (!Change)
GetCurrentDirectory (MAX_PATH, currdir);
*drive = *dir = *name = *ext = '\0';
_splitpath(fspec, drive, dir, name, ext);
if (!InclName)
*name = *ext = '\0';
*drive = toupper(*drive);
if (*ext)
cm |= EXTENSION;
if (InclName && *name)
cm |= FILENAME;
if (*dir)
cm |= DIRECTORY;
if (*drive)
cm |= DRIVE;
if (cm & DRIVE)
_chdrive(*drive - '@');
else
{
*drive = _getdrive();
*drive += '@';
}
if (cm & DIRECTORY)
{
cp = dir+strlen(dir)-1;
if (*cp == '\\')
*cp = '\0';
chdir(dir);
}
getcwd(dir, sizeof dir);
memmove(dir, dir+2, strlen(dir+1));
if (InclName) {
if (!(cm & FILENAME))
strcpy(name, "*");
if (!(cm & EXTENSION) && strchr(fspec, '.') != NULL)
strcpy(ext, ".*");
}
else
*name = *ext = '\0';
if (dir[strlen(dir)-1] != '\\')
strcat(dir, "\\");
memset(path, 0, sizeof path);
_makepath(path, drive, dir, name, ext);
if (!Change)
SetCurrentDirectory (currdir);
}
static int dircmp(const void *c1, const void *c2)
{
return _stricmp(*(char **)c1, *(char **)c2);
}
BOOL DfDlgDirList(DFWINDOW wnd, char *fspec,
enum DfCommands nameid, enum DfCommands pathid,
unsigned attrib)
{
int ax, i = 0;
struct _finddata_t ff;
DF_CTLWINDOW *ct = DfFindCommand(wnd->extension,nameid,DF_LISTBOX);
DFWINDOW lwnd;
char **dirlist = NULL;
DfCreatePath(path, fspec, TRUE, TRUE);
if (ct != NULL)
{
lwnd = ct->wnd;
DfSendMessage(ct->wnd, DFM_CLEARTEXT, 0, 0);
if (attrib & 0x8000)
{
DWORD cd, dr;
cd = GetLogicalDrives ();
for (dr = 0; dr < 26; dr++)
{
if (cd & (1 << dr))
{
char drname[15];
sprintf(drname, "[%c:\\]", (char)(dr+'A'));
#if 0
/* ---- test for network or RAM disk ---- */
regs.x.ax = 0x4409; /* IOCTL func 9 */
regs.h.bl = dr+1;
int86(DOS, &regs, &regs);
if (!regs.x.cflag) {
if (regs.x.dx & 0x1000)
strcat(drname, " (Network)");
else if (regs.x.dx == 0x0800)
strcat(drname, " (RAMdisk)");
}
#endif
DfSendMessage(lwnd,DFM_ADDTEXT,(DF_PARAM)drname,0);
}
}
DfSendMessage(lwnd, DFM_PAINT, 0, 0);
}
ax = _findfirst(path, &ff);
if (ax == -1)
return FALSE;
do
{
if (!((attrib & 0x4000) &&
(ff.attrib & (attrib & 0x3f)) == 0) &&
strcmp(ff.name, "."))
{
char fname[MAX_PATH+2];
sprintf(fname, (ff.attrib & FILE_ATTRIBUTE_DIRECTORY) ?
"[%s]" : "%s" , ff.name);
dirlist = DfRealloc(dirlist,
sizeof(char *)*(i+1));
dirlist[i] = DfMalloc(strlen(fname)+1);
if (dirlist[i] != NULL)
strcpy(dirlist[i], fname);
i++;
}
}
while (_findnext(ax, &ff) == 0);
_findclose(ax);
if (dirlist != NULL)
{
int j;
/* -- sort file/drive/directory list box data -- */
qsort(dirlist, i, sizeof(void *), dircmp);
/* ---- send sorted list to list box ---- */
for (j = 0; j < i; j++) {
DfSendMessage(lwnd,DFM_ADDTEXT,(DF_PARAM)dirlist[j],0);
free(dirlist[j]);
}
free(dirlist);
}
DfSendMessage(lwnd, DFM_SHOW_WINDOW, 0, 0);
}
if (pathid)
{
_makepath(path, drive, dir, NULL, NULL);
DfPutItemText(wnd, pathid, path);
}
return TRUE;
}
/* EOF */
rosapps/dflat32/edit.c
-741
View File
@@ -1,741 +0,0 @@
/* --------------- edit.c ----------- */
#include "dflat.h"
extern DF_DBOX PrintSetup;
char DFlatApplication[] = "Edit";
static char Untitled[] = "Untitled";
static int wndpos;
static int MemoPadProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void NewFile(DFWINDOW,char *);
static void SelectFile(DFWINDOW);
static void PadWindow(DFWINDOW, char *);
static void OpenPadWindow(DFWINDOW, char *,char *);
static void LoadFile(DFWINDOW);
static void PrintPad(DFWINDOW);
static void SaveFile(DFWINDOW, int);
static void EditDeleteFile(DFWINDOW);
static int EditorProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static char *NameComponent(char *);
static int PrintSetupProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void FixTabMenu(void);
#ifndef TURBOC
void Calendar(DFWINDOW);
#endif
//void BarChart(DFWINDOW);
char **Argv;
#define CHARSLINE 80
#define LINESPAGE 66
int main (int argc, char *argv[])
{
DFWINDOW wnd;
FILE *fp;
if (DfInitialize () == FALSE)
return 1;
Argv = argv;
DfLoadConfig ();
// if (!DfLoadConfig())
// DfCfg.ScreenLines = DF_SCREENHEIGHT;
wnd = DfDfCreateWindow (DF_APPLICATION,
"FreeDos Edit " DF_VERSION,
0, 0, -1, -1,
&DfMainMenu,
NULL,
MemoPadProc,
// DF_MOVEABLE |
// DF_SIZEABLE |
// DF_HASBORDER |
// DF_MINMAXBOX |
DF_HASSTATUSBAR);
DfLoadHelpFile ();
DfSendMessage (wnd, DFM_SETFOCUS, TRUE, 0);
// Load the files from args - if the file does not exist, open a new window....
while (argc > 1)
{
// check if the file exists....
if (( fp = fopen(argv[1],"r")) == NULL )
{
// file does not exist - create new window
NewFile(wnd,argv[1]);
}
else
PadWindow(wnd, argv[1]);
--argc;
argv++;
}
while (DfDispatchMessage ())
;
DfTerminate ();
return 0;
}
/* ------ open text files and put them into editboxes ----- */
static void PadWindow(DFWINDOW wnd, char *FileName)
{
int ax;
struct _finddata_t ff;
char path[MAX_PATH];
char *cp;
DfCreatePath(path, FileName, FALSE, FALSE);
cp = path+strlen(path);
DfCreatePath(path, FileName, TRUE, FALSE);
ax = _findfirst(path, &ff);
if (ax == -1)
return;
do
{
strcpy(cp, ff.name);
OpenPadWindow(wnd, path,NULL);
}
while (_findnext(ax, &ff) == 0);
_findclose (ax);
}
/* ------- window processing module for the
Edit application window ----- */
static int MemoPadProc(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
int rtn;
switch (msg)
{
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
if (DfCfg.InsertMode)
DfSetCommandToggle(&DfMainMenu, DF_ID_INSERT);
if (DfCfg.WordWrap)
DfSetCommandToggle(&DfMainMenu, DF_ID_WRAP);
FixTabMenu();
return rtn;
case DFM_COMMAND:
switch ((int)p1)
{
case DF_ID_NEW:
NewFile(wnd,NULL);
return TRUE;
case DF_ID_OPEN:
SelectFile(wnd);
return TRUE;
case DF_ID_SAVE:
SaveFile(DfInFocus, FALSE);
return TRUE;
case DF_ID_SAVEAS:
SaveFile(DfInFocus, TRUE);
return TRUE;
case DF_ID_DELETEFILE:
EditDeleteFile(DfInFocus);
return TRUE;
case DF_ID_PRINTSETUP:
DfDialogBox(wnd, &PrintSetup, TRUE, PrintSetupProc);
return TRUE;
case DF_ID_PRINT:
PrintPad(DfInFocus);
return TRUE;
case DF_ID_EXIT:
if (!DfYesNoBox("Exit FreeDos Edit?"))
return FALSE;
break;
case DF_ID_WRAP:
DfCfg.WordWrap = DfGetCommandToggle(&DfMainMenu, DF_ID_WRAP);
return TRUE;
case DF_ID_INSERT:
DfCfg.InsertMode = DfGetCommandToggle(&DfMainMenu, DF_ID_INSERT);
return TRUE;
case DF_ID_TAB2:
DfCfg.Tabs = 2;
FixTabMenu();
return TRUE;
case DF_ID_TAB4:
DfCfg.Tabs = 4;
FixTabMenu();
return TRUE;
case DF_ID_TAB6:
DfCfg.Tabs = 6;
FixTabMenu();
return TRUE;
case DF_ID_TAB8:
DfCfg.Tabs = 8;
FixTabMenu();
return TRUE;
case DF_ID_CALENDAR:
Calendar(wnd);
return TRUE;
// case DF_ID_BARCHART:
// BarChart(wnd);
// return TRUE;
case DF_ID_ABOUT:
DfMessageBox(
"About D-Flat and FreeDos Edit",
" ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
" ³ ÜÜÜ ÜÜÜ Ü ³\n"
" ³ Û Û Û Û Û ³\n"
" ³ Û Û Û Û Û ³\n"
" ³ Û Û Û Û Û Û ³\n"
" ³ ßßß ßßß ßß ³\n"
" RÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄU\n"
"D-Flat implements the SAA/CUA\n"
"interface in a public domain\n"
"C language library originally\n"
"published in Dr. Dobb's Journal\n"
" ------------------------ \n"
"FreeDos Edit is a clone of MSDOS\n"
"editor for the FREEDOS Project");
return TRUE;
default:
break;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* --- The New command. Open an empty editor window --- */
static void NewFile(DFWINDOW wnd, char *FileName)
{
OpenPadWindow(wnd, Untitled,FileName);
}
/* --- The Open... command. Select a file --- */
static void SelectFile(DFWINDOW wnd)
{
char FileName[MAX_PATH];
if (DfOpenFileDialogBox("*.*", FileName))
{
/* see if the document is already in a window */
DFWINDOW wnd1 = DfFirstWindow(wnd);
while (wnd1 != NULL)
{
if (wnd1->extension &&
_stricmp(FileName, wnd1->extension) == 0)
{
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, DFM_RESTORE, 0, 0);
return;
}
wnd1 = DfNextWindow(wnd1);
}
OpenPadWindow(wnd, FileName, NULL);
}
}
/* --- open a document window and load a file --- */
static void OpenPadWindow(DFWINDOW wnd, char *FileName,char *NewFileName)
{
static DFWINDOW wnd1 = NULL;
DFWINDOW wwnd;
struct stat sb;
char *Fname = FileName;
char *ermsg;
if (strcmp(FileName, Untitled))
{
if (stat(FileName, &sb))
{
ermsg = DfMalloc(strlen(FileName)+20);
strcpy(ermsg, "No such file as\n");
strcat(ermsg, FileName);
DfErrorMessage(ermsg);
free(ermsg);
return;
}
Fname = NameComponent(FileName);
// check file size
if (sb.st_size > 64000)
{
ermsg = DfMalloc(strlen(FileName)+20);
strcpy(ermsg, "File too large for this version of Edit\n");
DfErrorMessage(ermsg);
free(ermsg);
return;
}
}
wwnd = DfWatchIcon();
wndpos += 2;
if (NewFileName != NULL)
Fname = NameComponent(NewFileName);
if (wndpos == 20)
wndpos = 2;
wnd1 = DfDfCreateWindow(DF_EDITBOX,
Fname,
(wndpos-1)*2, wndpos, 10, 40,
NULL, wnd, EditorProc,
DF_SHADOW |
DF_MINMAXBOX |
DF_CONTROLBOX |
DF_VSCROLLBAR |
DF_HSCROLLBAR |
DF_MOVEABLE |
DF_HASBORDER |
DF_SIZEABLE |
DF_MULTILINE);
if (strcmp(FileName, Untitled))
{
wnd1->extension = DfMalloc(strlen(FileName)+1);
strcpy(wnd1->extension, FileName);
LoadFile(wnd1);
}
DfSendMessage(wwnd, DFM_CLOSE_WINDOW, 0, 0);
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, DFM_MAXIMIZE, 0, 0);
}
/* --- Load the notepad file into the editor text buffer --- */
static void LoadFile(DFWINDOW wnd)
{
char *Buf = NULL;
int recptr = 0;
FILE *fp;
if ((fp = fopen(wnd->extension, "rt")) != NULL)
{
while (!feof(fp))
{
DfHandshake();
Buf = DfRealloc(Buf, recptr+150);
memset(Buf+recptr, 0, 150);
fgets(Buf+recptr, 150, fp);
recptr += strlen(Buf+recptr);
}
fclose(fp);
if (Buf != NULL)
{
DfSendMessage(wnd, DFM_SETTEXT, (DF_PARAM) Buf, 0);
free(Buf);
}
}
}
static int LineCtr;
static int CharCtr;
/* ------- print a character -------- */
static void PrintChar(FILE *prn, int c)
{
int i;
if (c == '\n' || CharCtr == DfCfg.RightMargin)
{
fputs("\r\n", prn);
LineCtr++;
if (LineCtr == DfCfg.BottomMargin)
{
fputc('\f', prn);
for (i = 0; i < DfCfg.TopMargin; i++)
fputc('\n', prn);
LineCtr = DfCfg.TopMargin;
}
CharCtr = 0;
if (c == '\n')
return;
}
if (CharCtr == 0)
{
for (i = 0; i < DfCfg.LeftMargin; i++)
{
fputc(' ', prn);
CharCtr++;
}
}
CharCtr++;
fputc(c, prn);
}
/* --- print the current notepad --- */
static void PrintPad(DFWINDOW wnd)
{
if (*DfCfg.PrinterPort)
{
FILE *prn;
if ((prn = fopen(DfCfg.PrinterPort, "wt")) != NULL)
{
long percent;
BOOL KeepPrinting = TRUE;
char *text = DfGetText(wnd);
unsigned oldpct = 100, cct = 0, len = strlen(text);
DFWINDOW swnd = DfSliderBox(20, DfGetTitle(wnd), "Printing");
/* ------- print the notepad text --------- */
LineCtr = CharCtr = 0;
while (KeepPrinting && *text)
{
PrintChar(prn, *text++);
percent = ((long) ++cct * 100) / len;
if ((int)percent != (int)oldpct)
{
oldpct = (int) percent;
KeepPrinting = DfSendMessage(swnd, DFM_PAINT, 0, oldpct);
}
}
if (KeepPrinting)
/* ---- user did not cancel ---- */
if (oldpct < 100)
DfSendMessage(swnd, DFM_PAINT, 0, 100);
/* ------- follow with a form feed? --------- */
if (DfYesNoBox("Form Feed?"))
fputc('\f', prn);
fclose(prn);
}
else
DfErrorMessage("Cannot open printer file");
}
else
DfErrorMessage("No printer selected");
}
/* ---------- save a file to disk ------------ */
static void SaveFile(DFWINDOW wnd, int Saveas)
{
FILE *fp;
if (wnd->extension == NULL || Saveas) {
char FileName[MAX_PATH];
if (DfSaveAsDialogBox(FileName)) {
if (wnd->extension != NULL)
free(wnd->extension);
wnd->extension = DfMalloc(strlen(FileName)+1);
strcpy(wnd->extension, FileName);
DfAddTitle(wnd, NameComponent(FileName));
DfSendMessage(wnd, DFM_BORDER, 0, 0);
}
else
return;
}
if (wnd->extension != NULL)
{
DFWINDOW mwnd = DfMomentaryMessage("Saving the file");
if ((fp = fopen(wnd->extension, "wt")) != NULL)
{
fwrite(DfGetText(wnd), strlen(DfGetText(wnd)), 1, fp);
fclose(fp);
wnd->TextChanged = FALSE;
}
DfSendMessage(mwnd, DFM_CLOSE_WINDOW, 0, 0);
}
}
/* -------- delete a file ------------ */
static void EditDeleteFile(DFWINDOW wnd)
{
if (wnd->extension != NULL) {
if (strcmp(wnd->extension, Untitled)) {
char *fn = NameComponent(wnd->extension);
if (fn != NULL) {
char msg[30];
sprintf(msg, "Delete %s?", fn);
if (DfYesNoBox(msg)) {
_unlink(wnd->extension);
DfSendMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
}
}
}
}
}
/* ------ display the row and column in the statusbar ------ */
static void ShowPosition(DFWINDOW wnd)
{
char status[30];
sprintf(status, "Line:%4d Column: %2d",
wnd->CurrLine, wnd->CurrCol);
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, (DF_PARAM) status, 0);
}
/* window processing module for the editboxes */
static int EditorProc(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
int rtn;
switch (msg)
{
case DFM_SETFOCUS:
if ((int)p1)
{
wnd->InsertMode = DfGetCommandToggle(&DfMainMenu, DF_ID_INSERT);
wnd->WordWrapMode = DfGetCommandToggle(&DfMainMenu, DF_ID_WRAP);
}
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
if ((int)p1 == FALSE)
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, 0, 0);
else
ShowPosition(wnd);
return rtn;
case DFM_KEYBOARD_CURSOR:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
ShowPosition(wnd);
return rtn;
case DFM_COMMAND:
switch ((int) p1)
{
case DF_ID_SEARCH:
DfSearchText(wnd);
return TRUE;
case DF_ID_REPLACE:
DfReplaceText(wnd);
return TRUE;
case DF_ID_SEARCHNEXT:
DfSearchNext(wnd);
return TRUE;
case DF_ID_CUT:
DfCopyToClipboard(wnd);
DfSendMessage(wnd, DFM_COMMAND, DF_ID_DELETETEXT, 0);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_COPY:
DfCopyToClipboard(wnd);
DfClearTextBlock(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_PASTE:
DfPasteFromClipboard(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_DELETETEXT:
case DF_ID_CLEAR:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return rtn;
case DF_ID_HELP:
DfDisplayHelp(wnd, "MEMOPADDOC");
return TRUE;
case DF_ID_WRAP:
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_WRAP, 0);
wnd->WordWrapMode = DfCfg.WordWrap;
return TRUE;
case DF_ID_INSERT:
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_INSERT, 0);
wnd->InsertMode = DfCfg.InsertMode;
DfSendMessage(NULL, DFM_SHOW_CURSOR, wnd->InsertMode, 0);
return TRUE;
default:
break;
}
break;
case DFM_CLOSE_WINDOW:
if (wnd->TextChanged)
{
char *cp = DfMalloc(25+strlen(DfGetTitle(wnd)));
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
strcpy(cp, DfGetTitle(wnd));
strcat(cp, "\nText changed. Save it?");
if (DfYesNoBox(cp))
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_SAVE, 0);
free(cp);
}
wndpos = 0;
if (wnd->extension != NULL)
{
free(wnd->extension);
wnd->extension = NULL;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* -- point to the name component of a file specification -- */
static char *NameComponent(char *FileName)
{
char *Fname;
if ((Fname = strrchr(FileName, '\\')) == NULL)
if ((Fname = strrchr(FileName, ':')) == NULL)
Fname = FileName-1;
return Fname + 1;
}
static char *ports[] = {
"Lpt1", "Lpt2", "Lpt3",
"Com1", "Com2", "Com3", "Com4",
NULL
};
static int PrintSetupProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn, i = 0, mar;
char marg[10];
DFWINDOW cwnd;
switch (msg)
{
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfPutItemText(wnd, DF_ID_PRINTERPORT, DfCfg.PrinterPort);
while (ports[i] != NULL)
DfPutComboListText(wnd, DF_ID_PRINTERPORT, ports[i++]);
for (mar = CHARSLINE; mar >= 0; --mar)
{
sprintf(marg, "%3d", mar);
DfPutItemText(wnd, DF_ID_LEFTMARGIN, marg);
DfPutItemText(wnd, DF_ID_RIGHTMARGIN, marg);
}
for (mar = LINESPAGE; mar >= 0; --mar)
{
sprintf(marg, "%3d", mar);
DfPutItemText(wnd, DF_ID_TOPMARGIN, marg);
DfPutItemText(wnd, DF_ID_BOTTOMMARGIN, marg);
}
cwnd = DfControlWindow(&PrintSetup, DF_ID_LEFTMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
CHARSLINE-DfCfg.LeftMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_RIGHTMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
CHARSLINE-DfCfg.RightMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_TOPMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
LINESPAGE-DfCfg.TopMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_BOTTOMMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
LINESPAGE-DfCfg.BottomMargin, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == DF_ID_OK && (int) p2 == 0)
{
DfGetItemText(wnd, DF_ID_PRINTERPORT, DfCfg.PrinterPort, 4);
cwnd = DfControlWindow(&PrintSetup, DF_ID_LEFTMARGIN);
DfCfg.LeftMargin = CHARSLINE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_RIGHTMARGIN);
DfCfg.RightMargin = CHARSLINE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_TOPMARGIN);
DfCfg.TopMargin = LINESPAGE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_BOTTOMMARGIN);
DfCfg.BottomMargin = LINESPAGE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
static void FixTabMenu(void)
{
char *cp = DfGetCommandText(&DfMainMenu, DF_ID_TABS);
char *p;
if (cp != NULL)
{
p = strchr(cp, '(');
if (p != NULL)
{
// *(p+1) = (char)(DfCfg.Tabs + '0');
// if (DfGetClass(DfInFocus) == DF_POPDOWNMENU)
// DfSendMessage(DfInFocus, DFM_PAINT, 0, 0);
}
}
}
void DfPrepFileMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_SAVE);
DfDeactivateCommand(&DfMainMenu, DF_ID_SAVEAS);
DfDeactivateCommand(&DfMainMenu, DF_ID_DELETEFILE);
DfDeactivateCommand(&DfMainMenu, DF_ID_PRINT);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX)
{
if (DfIsMultiLine(wnd))
{
DfActivateCommand(&DfMainMenu, DF_ID_SAVE);
DfActivateCommand(&DfMainMenu, DF_ID_SAVEAS);
DfActivateCommand(&DfMainMenu, DF_ID_DELETEFILE);
DfActivateCommand(&DfMainMenu, DF_ID_PRINT);
}
}
}
void DfPrepSearchMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_SEARCH);
DfDeactivateCommand(&DfMainMenu, DF_ID_REPLACE);
DfDeactivateCommand(&DfMainMenu, DF_ID_SEARCHNEXT);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX)
{
if (DfIsMultiLine(wnd))
{
DfActivateCommand(&DfMainMenu, DF_ID_SEARCH);
DfActivateCommand(&DfMainMenu, DF_ID_REPLACE);
DfActivateCommand(&DfMainMenu, DF_ID_SEARCHNEXT);
}
}
}
void DfPrepEditMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_CUT);
DfDeactivateCommand(&DfMainMenu, DF_ID_COPY);
DfDeactivateCommand(&DfMainMenu, DF_ID_CLEAR);
DfDeactivateCommand(&DfMainMenu, DF_ID_DELETETEXT);
DfDeactivateCommand(&DfMainMenu, DF_ID_PARAGRAPH);
DfDeactivateCommand(&DfMainMenu, DF_ID_PASTE);
DfDeactivateCommand(&DfMainMenu, DF_ID_UNDO);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX)
{
if (DfIsMultiLine(wnd))
{
if (DfTextBlockMarked(wnd))
{
DfActivateCommand(&DfMainMenu, DF_ID_CUT);
DfActivateCommand(&DfMainMenu, DF_ID_COPY);
DfActivateCommand(&DfMainMenu, DF_ID_CLEAR);
DfActivateCommand(&DfMainMenu, DF_ID_DELETETEXT);
}
DfActivateCommand(&DfMainMenu, DF_ID_PARAGRAPH);
if (!DfTestAttribute(wnd, DF_READONLY) && DfClipboard != NULL)
DfActivateCommand(&DfMainMenu, DF_ID_PASTE);
if (wnd->DeletedText != NULL)
DfActivateCommand(&DfMainMenu, DF_ID_UNDO);
}
}
}
/* EOF */
rosapps/dflat32/edit.rc
-9
View File
@@ -1,9 +0,0 @@
/* $Id$ */
#define REACTOS_STR_FILE_DESCRIPTION "FreeDOS/ReactOS Text Editor\0"
#define REACTOS_STR_INTERNAL_NAME "edit\0"
#define REACTOS_STR_ORIGINAL_FILENAME "edit.exe\0"
#define REACTOS_STR_ORIGINAL_COPYRIGHT "FreeDOS Project\0"
#include <reactos/version.rc>
/* EOF */
rosapps/dflat32/edit.txt
-1455
View File
File diff suppressed because it is too large Load Diff
rosapps/dflat32/editbox.c
-1113
View File
File diff suppressed because it is too large Load Diff
rosapps/dflat32/fileopen.c
-259
View File
@@ -1,259 +0,0 @@
/* ----------- fileopen.c ------------- */
#include "dflat.h"
static BOOL DlgFileOpen(char *, char *, DF_DBOX *);
static int DlgFnOpen(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void InitDlgBox(DFWINDOW);
static void StripPath(char *);
static BOOL IncompleteFilename(char *);
static char *OrigSpec;
static char *FileSpec;
static char *FileName;
static char *NewFileName;
static BOOL Saving;
extern DF_DBOX FileOpen;
extern DF_DBOX SaveAs;
/*
* Dialog Box to select a file to open
*/
BOOL DfOpenFileDialogBox(char *Fpath, char *Fname)
{
return DlgFileOpen(Fpath, Fname, &FileOpen);
}
/*
* Dialog Box to select a file to save as
*/
BOOL DfSaveAsDialogBox(char *Fname)
{
return DlgFileOpen(NULL, Fname, &SaveAs);
}
/* --------- generic file open ---------- */
static BOOL DlgFileOpen(char *Fpath, char *Fname, DF_DBOX *db)
{
BOOL rtn;
char savedir[MAX_PATH];
char OSpec[80];
char FSpec[80];
char FName[80];
char NewFName[80];
OrigSpec = OSpec;
FileSpec = FSpec;
FileName = FName;
NewFileName = NewFName;
GetCurrentDirectory (MAX_PATH, savedir);
if (Fpath != NULL) {
strncpy(FileSpec, Fpath, 80);
Saving = FALSE;
}
else {
*FileSpec = '\0';
Saving = TRUE;
}
strcpy(FileName, FileSpec);
strcpy(OrigSpec, FileSpec);
if ((rtn = DfDialogBox(NULL, db, TRUE, DlgFnOpen)) != FALSE)
strcpy(Fname, NewFileName);
else
*Fname = '\0';
SetCurrentDirectory (savedir);
return rtn;
}
/*
* Process dialog box messages
*/
static int DlgFnOpen(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
int rtn;
DF_DBOX *db;
DFWINDOW cwnd;
switch (msg)
{
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
db = wnd->extension;
cwnd = DfControlWindow(db, DF_ID_FILENAME);
DfSendMessage(cwnd, DFM_SETTEXTLENGTH, 64, 0);
return rtn;
case DFM_INITIATE_DIALOG:
InitDlgBox(wnd);
break;
case DFM_COMMAND:
switch ((int) p1)
{
case DF_ID_FILENAME:
if (p2 != DFM_ENTERFOCUS)
{
/* allow user to modify the file spec */
DfGetItemText(wnd, DF_ID_FILENAME,
FileName, 65);
if (IncompleteFilename(FileName) || Saving)
{
strcpy(OrigSpec, FileName);
StripPath(OrigSpec);
}
if (p2 != DFM_LEAVEFOCUS)
DfSendMessage(wnd, DFM_COMMAND, DF_ID_OK, 0);
}
return TRUE;
case DF_ID_OK:
if (p2 != 0)
break;
DfGetItemText(wnd, DF_ID_FILENAME,
FileName, 65);
strcpy(FileSpec, FileName);
if (IncompleteFilename(FileName))
{
/* no file name yet */
InitDlgBox(wnd);
strcpy(OrigSpec, FileSpec);
return TRUE;
}
else {
DfGetItemText(wnd, DF_ID_PATH, FileName, 65);
strcat(FileName, FileSpec);
strcpy(NewFileName, FileName);
}
break;
case DF_ID_FILES:
switch ((int) p2)
{
case DFM_ENTERFOCUS:
case DFM_LB_SELECTION:
/* selected a different filename */
DfGetDlgListText(wnd, FileName,
DF_ID_FILES);
DfPutItemText(wnd, DF_ID_FILENAME,
FileName);
break;
case DFM_LB_CHOOSE:
/* chose a file name */
DfGetDlgListText(wnd, FileName,
DF_ID_FILES);
DfSendMessage(wnd, DFM_COMMAND, DF_ID_OK, 0);
break;
default:
break;
}
return TRUE;
case DF_ID_DRIVE:
switch ((int) p2) {
case DFM_ENTERFOCUS:
if (Saving)
*FileSpec = '\0';
break;
case DFM_LEAVEFOCUS:
if (Saving)
strcpy(FileSpec, FileName);
break;
case DFM_LB_SELECTION:
{
char dd[25];
/* selected different drive/dir */
DfGetDlgListText(wnd, dd, DF_ID_DRIVE);
if (*(dd+2) == ':')
*(dd+3) = '\0';
else
*(dd+strlen(dd)-1) = '\0';
strcpy(FileName, dd+1);
if (*(dd+2) != ':' && *OrigSpec != '\\')
strcat(FileName, "\\");
strcat(FileName, OrigSpec);
if (*(FileName+1) != ':' && *FileName != '.')
{
DfGetItemText(wnd, DF_ID_PATH, FileSpec, 65);
strcat(FileSpec, FileName);
}
else
strcpy(FileSpec, FileName);
}
break;
case DFM_LB_CHOOSE:
/* chose drive/dir */
if (Saving)
DfPutItemText(wnd, DF_ID_FILENAME, "");
InitDlgBox(wnd);
return TRUE;
default:
break;
}
DfPutItemText(wnd, DF_ID_FILENAME, FileSpec);
return TRUE;
default:
break;
}
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/*
* Initialize the dialog box
*/
static void InitDlgBox(DFWINDOW wnd)
{
if (*FileSpec && !Saving)
DfPutItemText(wnd, DF_ID_FILENAME, FileSpec);
if (DfDlgDirList(wnd, FileSpec, DF_ID_FILES, DF_ID_PATH, 0))
{
StripPath(FileSpec);
DfDlgDirList(wnd, "*.*", DF_ID_DRIVE, 0, 0xc010);
}
}
/*
* Strip the drive and path information from a file spec
*/
static void StripPath(char *filespec)
{
char *cp, *cp1;
cp = strchr(filespec, ':');
if (cp != NULL)
cp++;
else
cp = filespec;
while (TRUE) {
cp1 = strchr(cp, '\\');
if (cp1 == NULL)
break;
cp = cp1+1;
}
strcpy(filespec, cp);
}
static BOOL IncompleteFilename(char *s)
{
int lc = strlen(s)-1;
if (strchr(s, '?') || strchr(s, '*') || !*s)
return TRUE;
if (*(s+lc) == ':' || *(s+lc) == '\\')
return TRUE;
return FALSE;
}
/* EOF */
rosapps/dflat32/help.txt
-1
View File
@@ -1 +0,0 @@
help.txt
rosapps/dflat32/helpbox.c
-717
View File
@@ -1,717 +0,0 @@
/* ------------ helpbox.c ----------- */
#include "dflat.h"
#include "htree.h"
extern DF_DBOX HelpBox;
/* -------- strings of D-Flat classes for calling default
help text collections -------- */
char *DfClassNames[] = {
#undef DfClassDef
#define DfClassDef(c,b,p,a) #c,
#include "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, DF_DIALOGWINDOW *);
/* ------------- DFM_CREATE_WINDOW message ------------ */
static void CreateWindowMsg(DFWINDOW wnd)
{
Helping = TRUE;
DfGetClass(wnd) = DF_HELPBOX;
DfInitWindowColors(wnd);
if (ThisHelp != NULL)
ThisHelp->hwnd = wnd;
}
/* ------------- COMMAND message ------------ */
static BOOL CommandMsg(DFWINDOW wnd, DF_PARAM p1)
{
switch ((int)p1) {
case DF_ID_CANCEL:
ThisStack = LastStack;
while (ThisStack != NULL) {
LastStack = ThisStack->PrevStack;
if (ThisStack->hname != NULL)
free(ThisStack->hname);
free(ThisStack);
ThisStack = LastStack;
}
break;
case DF_ID_PREV:
FindHelpWindow(wnd);
if (ThisHelp != NULL)
SelectHelp(wnd, ThisHelp->PrevName);
return TRUE;
case DF_ID_NEXT:
FindHelpWindow(wnd);
if (ThisHelp != NULL)
SelectHelp(wnd, ThisHelp->NextName);
return TRUE;
case DF_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;
}
/* ------------- DFM_KEYBOARD message ------------ */
static BOOL KeyboardMsg(DFWINDOW wnd, DF_PARAM p1)
{
DFWINDOW cwnd;
struct keywords *thisword;
static char HelpName[50];
cwnd = DfControlWindow(wnd->extension, DF_ID_HELPTEXT);
if (cwnd == NULL || DfInFocus != cwnd)
return FALSE;
thisword = cwnd->thisword;
switch ((int)p1) {
case '\r':
if (thisword != NULL) {
if (thisword->isDefinition)
DisplayDefinition(DfGetParent(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 DF_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 + DfClientHeight(cwnd)) {
int distance = DfClientHeight(cwnd)/2;
do {
cwnd->wtop = thisword->lineno-distance;
distance /= 2;
}
while (cwnd->wtop < 0);
}
DfSendMessage(cwnd, DFM_PAINT, 0, 0);
return TRUE;
}
return FALSE;
}
/* ---- window processing module for the DF_HELPBOX ------- */
int DfHelpBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
DF_DBOX *db = wnd->extension;
switch (msg) {
case DFM_CREATE_WINDOW:
CreateWindowMsg(wnd);
break;
case DFM_INITIATE_DIALOG:
ReadHelp(wnd);
break;
case DFM_COMMAND:
if (p2 != 0)
break;
if (CommandMsg(wnd, p1))
return TRUE;
break;
case DFM_KEYBOARD:
if (DfWindowMoving)
break;
if (KeyboardMsg(wnd, p1))
return TRUE;
break;
case DFM_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 DfBaseWndProc(DF_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 = DfGetParent(wnd);
DfPostMessage(wnd, DFM_ENDDIALOG, 0, 0);
DfPostMessage(pwnd, DFM_DISPLAY_HELP, (DF_PARAM) hname, 0);
}
}
/* ---- DFM_PAINT message for the helpbox text editbox ---- */
static int PaintMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
struct keywords *thisword;
int rtn;
if (wnd->thisword != NULL) {
DFWINDOW pwnd = DfGetParent(wnd);
char *cp;
thisword = wnd->thisword;
cp = DfTextLine(wnd, thisword->lineno);
cp += thisword->off1;
*(cp+1) =
(pwnd->WindowColors[DF_SELECT_COLOR][DF_FG] & 255) | 0x80;
*(cp+2) =
(pwnd->WindowColors[DF_SELECT_COLOR][DF_BG] & 255) | 0x80;
rtn = DfDefaultWndProc(wnd, DFM_PAINT, p1, p2);
*(cp+1) =
(pwnd->WindowColors[DF_HILITE_COLOR][DF_FG] & 255) | 0x80;
*(cp+2) =
(pwnd->WindowColors[DF_HILITE_COLOR][DF_BG] & 255) | 0x80;
return rtn;
}
return DfDefaultWndProc(wnd, DFM_PAINT, p1, p2);
}
/* ---- DFM_LEFT_BUTTON message for the helpbox text editbox ---- */
static int LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
struct keywords *thisword;
int rtn, mx, my;
rtn = DfDefaultWndProc(wnd, DFM_LEFT_BUTTON, p1, p2);
mx = (int)p1 - DfGetClientLeft(wnd);
my = (int)p2 - DfGetClientTop(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, DFM_PAINT, 0, 0);
if (thisword->isDefinition) {
DFWINDOW pwnd = DfGetParent(wnd);
if (pwnd != NULL)
DisplayDefinition(DfGetParent(pwnd),
thisword->hname);
}
break;
}
}
thisword = thisword->nextword;
}
return rtn;
}
/* --- window processing module for DF_HELPBOX's text DF_EDITBOX -- */
int HelpTextProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
struct keywords *thisword;
switch (msg) {
case DFM_PAINT:
return PaintMsg(wnd, p1, p2);
case DFM_LEFT_BUTTON:
return LeftButtonMsg(wnd, p1, p2);
case DOUBLE_CLICK:
DfPostMessage(wnd, DFM_KEYBOARD, '\r', 0);
break;
case DFM_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 DfDefaultWndProc(wnd, msg, p1, p2);
}
/* -------- read the help text into the editbox ------- */
static void ReadHelp(DFWINDOW wnd)
{
DFWINDOW cwnd = DfControlWindow(wnd->extension, DF_ID_HELPTEXT);
int linectr = 0;
if (cwnd == NULL)
return;
cwnd->wndproc = HelpTextProc;
/* ----- read the help text ------- */
while (TRUE) {
char *cp = hline, *cp1;
int colorct = 0;
if (DfGetHelpLine(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++ = DF_CHANGECOLOR;
*cp++ =
(wnd->WindowColors [DF_HILITE_COLOR] [DF_FG] & 255) | 0x80;
*cp++ =
(wnd->WindowColors [DF_HILITE_COLOR] [DF_BG] & 255) | 0x80;
cp1 = cp;
if ((cp = strchr(cp, ']')) != NULL) {
if (thisword != NULL)
thisword->off3 =
thisword->off2 + (int) (cp - cp1);
*cp++ = DF_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));
}
}
}
}
DfPutItemText(wnd, DF_ID_HELPTEXT, hline);
/* -- display help text as soon as window is full -- */
if (++linectr == DfClientHeight(cwnd))
DfSendMessage(cwnd, DFM_PAINT, 0, 0);
if (linectr > DfClientHeight(cwnd) &&
!DfTestAttribute(cwnd, DF_VSCROLLBAR)) {
DfAddAttribute(cwnd, DF_VSCROLLBAR);
DfSendMessage(cwnd, DFM_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 DfLoadHelpFile()
{
char *cp;
if (Helping)
return;
DfUnLoadHelpFile();
if ((helpfp = DfOpenHelpFile()) == NULL)
return;
*hline = '\0';
while (*hline != '<') {
if (DfGetHelpLine(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);
DfHelpFilePosition(&ThisHelp->hptr, &ThisHelp->bit);
if (DfGetHelpLine(hline) == NULL)
break;
/* ------- build the help linked list entry --- */
while (*hline == '[') {
DfHelpFilePosition(&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 (DfGetHelpLine(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 (DfGetHelpLine(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 (DfGetHelpLine(hline) == NULL)
strcpy(hline, "<end>");
while (*hline != '<') {
ThisHelp->hwidth =
max(ThisHelp->hwidth, HelpLength(hline));
ThisHelp->hheight++;
if (DfGetHelpLine(hline) == NULL)
strcpy(hline, "<end>");
}
}
fclose(helpfp);
}
/* ------ free the memory used by the help file table ------ */
void DfUnLoadHelpFile(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(DfHelpTree);
DfHelpTree = NULL;
}
/* ---------- display a specified help text ----------- */
BOOL DfDisplayHelp(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 = DfOpenHelpFile()) != NULL) {
DF_DBOX *db;
int offset, i;
db = DfCalloc(1,sizeof HelpBox);
memcpy(db, &HelpBox, sizeof HelpBox);
/* -- seek to the first line of the help text -- */
DfSeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
/* ----- read the title ----- */
DfGetHelpLine(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)
DfDisableButton(db, DF_ID_BACK);
if (ThisHelp->NextName == NULL)
DfDisableButton(db, DF_ID_NEXT);
if (ThisHelp->PrevName == NULL)
DfDisableButton(db, DF_ID_PREV);
/* ------- display the help window ----- */
DfDialogBox(NULL, db, TRUE, DfHelpBoxProc);
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 (DfGetClass(wnd) == DF_POPDOWNMENU)
hwnd = DfGetParent(wnd);
y = DfGetClass(hwnd) == DF_MENUBAR ? 2 : 1;
FindHelp(def);
if (ThisHelp != NULL) {
if ((helpfp = DfOpenHelpFile()) != NULL) {
dwnd = DfDfCreateWindow(
DF_TEXTBOX,
NULL,
DfGetClientLeft(hwnd),
DfGetClientTop(hwnd)+y,
min(ThisHelp->hheight, MAXHEIGHT)+3,
ThisHelp->hwidth+2,
NULL,
wnd,
NULL,
DF_HASBORDER | DF_NOCLIP | DF_SAVESELF);
if (dwnd != NULL) {
/* ----- read the help text ------- */
DfSeekHelpLine(ThisHelp->hptr, ThisHelp->bit);
while (TRUE) {
if (DfGetHelpLine(hline) == NULL)
break;
if (*hline == '<')
break;
hline[strlen(hline)-1] = '\0';
DfSendMessage(dwnd,DFM_ADDTEXT,(DF_PARAM)hline,0);
}
DfSendMessage(dwnd, DFM_SHOW_WINDOW, 0, 0);
DfSendMessage(NULL, DFM_WAITKEYBOARD, 0, 0);
DfSendMessage(NULL, DFM_WAITMOUSE, 0, 0);
DfSendMessage(dwnd, DFM_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, DF_DIALOGWINDOW *dwnd)
{
int above, below, right, left;
if (DfGetClass(wnd) == DF_MENUBAR ||
DfGetClass(wnd) == DF_APPLICATION) {
dwnd->x = dwnd->y = -1;
return;
}
/* --- compute above overlap ---- */
above = OverLap(dwnd->h, DfGetTop(wnd));
/* --- compute below overlap ---- */
below = OverLap(DfGetBottom(wnd), DfGetScreenHeight()-dwnd->h);
/* --- compute right overlap ---- */
right = OverLap(DfGetRight(wnd), DfGetScreenWidth()-dwnd->w);
/* --- compute left overlap ---- */
left = OverLap(dwnd->w, DfGetLeft(wnd));
if (above < below)
dwnd->y = max(0, DfGetTop(wnd)-dwnd->h-2);
else
dwnd->y = min(DfGetScreenHeight()-dwnd->h, DfGetBottom(wnd)+2);
if (right < left)
dwnd->x = min(DfGetRight(wnd)+2, DfGetScreenWidth()-dwnd->w);
else
dwnd->x = max(0, DfGetLeft(wnd)-dwnd->w-2);
if (dwnd->x == DfGetRight(wnd)+2 ||
dwnd->x == DfGetLeft(wnd)-dwnd->w-2)
dwnd->y = -1;
if (dwnd->y ==DfGetTop(wnd)-dwnd->h-2 ||
dwnd->y == DfGetBottom(wnd)+2)
dwnd->x = -1;
}
/* EOF */
rosapps/dflat32/htree.c
-64
View File
@@ -1,64 +0,0 @@
/* ------------------- htree.c -------------------- */
#include "dflat.h"
#include "htree.h"
struct DfHTree *ht;
int root;
int treect;
/* ------ build a Huffman tree from a frequency array ------ */
void DfBuildTree(void)
{
int i;
treect = 256;
/* ---- preset node pointers to -1 ---- */
for (i = 0; i < treect; i++) {
ht[i].parent = -1;
ht[i].right = -1;
ht[i].left = -1;
}
/* ---- build the huffman tree ----- */
while (1) {
int h1 = -1, h2 = -1;
/* ---- find the two lowest frequencies ---- */
for (i = 0; i < treect; i++) {
if (i != h1) {
struct DfHTree *htt = ht+i;
/* --- find a node without a parent --- */
if (htt->cnt > 0 && htt->parent == -1) {
/* ---- h1 & h2 -> lowest nodes ---- */
if (h1 == -1 || htt->cnt < ht[h1].cnt) {
if (h2 == -1 || ht[h1].cnt < ht[h2].cnt)
h2 = h1;
h1 = i;
}
else if (h2 == -1 || htt->cnt < ht[h2].cnt)
h2 = i;
}
}
}
/* --- if only h1 -> a node, that's the root --- */
if (h2 == -1) {
root = h1;
break;
}
/* --- combine two nodes and add one --- */
ht[h1].parent = treect;
ht[h2].parent = treect;
ht = realloc(ht, (treect+1) * sizeof(struct DfHTree));
if (ht == NULL)
break;
/* --- the new node's frequency is the sum of the two
nodes with the lowest frequencies --- */
ht[treect].cnt = ht[h1].cnt + ht[h2].cnt;
/* - the new node points to the two that it combines */
ht[treect].right = h1;
ht[treect].left = h2;
/* --- the new node has no parent (yet) --- */
ht[treect].parent = -1;
treect++;
}
}
rosapps/dflat32/htree.h
-31
View File
@@ -1,31 +0,0 @@
/* ------------------- htree.h -------------------- */
#ifndef HTREE_H
#define HTREE_H
typedef unsigned int DF_BYTECOUNTER;
/* ---- Huffman tree structure for building ---- */
struct DfHTree {
DF_BYTECOUNTER cnt; /* character frequency */
int parent; /* offset to parent node */
int right; /* offset to right child node */
int left; /* offset to left child node */
};
/* ---- Huffman tree structure in compressed file ---- */
struct DfHTr {
int right; /* offset to right child node */
int left; /* offset to left child node */
};
extern struct DfHTr *DfHelpTree;
void DfBuildTree(void);
FILE *DfOpenHelpFile(void);
void DfHelpFilePosition(long *, int *);
void *DfGetHelpLine(char *);
void DfSeekHelpLine(long, int);
#endif
rosapps/dflat32/huffc.c
-118
View File
@@ -1,118 +0,0 @@
/* ------------------- huffc.c -------------------- */
#include "dflat.h"
#include "htree.h"
extern struct DfHTree *ht;
extern int root;
extern int treect;
static int lastchar = '\n';
static void compress(FILE *, int, int);
static void outbit(FILE *fo, int bit);
static int fgetcx(FILE *fi)
{
int c;
/* ------- bypass comments ------- */
if ((c = fgetc(fi)) == ';' && lastchar == '\n')
do {
while (c != '\n' && c != EOF)
c = fgetc(fi);
} while (c == ';');
lastchar = c;
return c;
}
void main(int argc, char *argv[])
{
FILE *fi, *fo;
int c;
DF_BYTECOUNTER bytectr = 0;
if (argc < 3) {
printf("\nusage: huffc infile outfile");
exit(1);
}
if ((fi = fopen(argv[1], "rb")) == NULL) {
printf("\nCannot open %s", argv[1]);
exit(1);
}
if ((fo = fopen(argv[2], "wb")) == NULL) {
printf("\nCannot open %s", argv[2]);
fclose(fi);
exit(1);
}
ht = calloc(256, sizeof(struct DfHTree));
/* - read the input file and count character frequency - */
while ((c = fgetcx(fi)) != EOF) {
c &= 255;
ht[c].cnt++;
bytectr++;
}
/* ---- build the huffman tree ---- */
DfBuildTree();
/* --- write the byte count to the output file --- */
fwrite(&bytectr, sizeof bytectr, 1, fo);
/* --- write the tree count to the output file --- */
fwrite(&treect, sizeof treect, 1, fo);
/* --- write the root offset to the output file --- */
fwrite(&root, sizeof root, 1, fo);
/* -- write the tree to the output file -- */
for (c = 256; c < treect; c++) {
int lf = ht[c].left;
int rt = ht[c].right;
fwrite(&lf, sizeof lf, 1, fo);
fwrite(&rt, sizeof rt, 1, fo);
}
/* ------ compress the file ------ */
fseek(fi, 0L, 0);
while ((c = fgetcx(fi)) != EOF)
compress(fo, (c & 255), 0);
outbit(fo, -1);
fclose(fi);
fclose(fo);
free(ht);
exit(0);
}
/* ---- compress a character value into a bit stream ---- */
static void compress(FILE *fo, int h, int child)
{
if (ht[h].parent != -1)
compress(fo, ht[h].parent, h);
if (child) {
if (child == ht[h].right)
outbit(fo, 0);
else if (child == ht[h].left)
outbit(fo, 1);
}
}
static char out8;
static int ct8;
/* -- collect and write bits to the compressed output file -- */
static void outbit(FILE *fo, int bit)
{
if (ct8 == 8 || bit == -1) {
while (ct8 < 8) {
out8 <<= 1;
ct8++;
}
fputc(out8, fo);
ct8 = 0;
}
out8 = (out8 << 1) | bit;
ct8++;
}
rosapps/dflat32/keys.c
-86
View File
@@ -1,86 +0,0 @@
/* ------------- keys.c ----------- */
#include <stdio.h>
#include "keys.h"
struct DfKeys keys[] = {
{DF_F1, "DF_F1"},
{DF_F2, "DF_F2"},
{DF_F3, "DF_F3"},
{DF_F4, "DF_F4"},
{DF_F5, "DF_F5"},
{DF_F6, "DF_F6"},
{DF_F7, "DF_F7"},
{DF_F8, "DF_F8"},
{DF_F9, "DF_F9"},
{DF_F10, "DF_F10"},
{DF_CTRL_F1, "Ctrl+DF_F1"},
{DF_CTRL_F2, "Ctrl+DF_F2"},
{DF_CTRL_F3, "Ctrl+DF_F3"},
{DF_CTRL_F4, "Ctrl+DF_F4"},
{DF_CTRL_F5, "Ctrl+DF_F5"},
{DF_CTRL_F6, "Ctrl+DF_F6"},
{DF_CTRL_F7, "Ctrl+DF_F7"},
{DF_CTRL_F8, "Ctrl+DF_F8"},
{DF_CTRL_F9, "Ctrl+DF_F9"},
{DF_CTRL_F10, "Ctrl+DF_F10"},
{DF_ALT_F1, "Alt+DF_F1"},
{DF_ALT_F2, "Alt+DF_F2"},
{DF_ALT_F3, "Alt+DF_F3"},
{DF_ALT_F4, "Alt+DF_F4"},
{DF_ALT_F5, "Alt+DF_F5"},
{DF_ALT_F6, "Alt+DF_F6"},
{DF_ALT_F7, "Alt+DF_F7"},
{DF_ALT_F8, "Alt+DF_F8"},
{DF_ALT_F9, "Alt+DF_F9"},
{DF_ALT_F10, "Alt+DF_F10"},
{DF_HOME, "Home"},
{DF_UP, "Up"},
{DF_PGUP, "PgUp"},
{DF_BS, "DF_BS"},
{DF_END, "End"},
{DF_DN, "Dn"},
{DF_PGDN, "PgDn"},
{DF_INS, "Ins"},
{DF_DEL, "Del"},
{DF_CTRL_HOME, "Ctrl+Home"},
{DF_CTRL_PGUP, "Ctrl+PgUp"},
{DF_CTRL_BS, "Ctrl+DF_BS"},
{DF_CTRL_END, "Ctrl+End"},
{DF_CTRL_PGDN, "Ctrl+PgDn"},
{DF_SHIFT_HT, "Shift+Tab"},
{DF_ALT_BS, "Alt+DF_BS"},
{DF_ALT_DEL, "Alt+Del"},
{DF_SHIFT_DEL, "Shift+Del"},
{DF_SHIFT_INS, "Shift+Ins"},
{DF_CTRL_INS, "Ctrl+Ins"},
{DF_ALT_A, "Alt+A"},
{DF_ALT_B, "Alt+B"},
{DF_ALT_C, "Alt+C"},
{DF_ALT_D, "Alt+D"},
{DF_ALT_E, "Alt+E"},
{DF_ALT_F, "Alt+F"},
{DF_ALT_G, "Alt+G"},
{DF_ALT_H, "Alt+H"},
{DF_ALT_I, "Alt+I"},
{DF_ALT_J, "Alt+J"},
{DF_ALT_K, "Alt+K"},
{DF_ALT_L, "Alt+L"},
{DF_ALT_M, "Alt+M"},
{DF_ALT_N, "Alt+N"},
{DF_ALT_O, "Alt+O"},
{DF_ALT_P, "Alt+P"},
{DF_ALT_Q, "Alt+Q"},
{DF_ALT_R, "Alt+R"},
{DF_ALT_S, "Alt+S"},
{DF_ALT_T, "Alt+T"},
{DF_ALT_U, "Alt+U"},
{DF_ALT_V, "Alt+V"},
{DF_ALT_W, "Alt+W"},
{DF_ALT_X, "Alt+X"},
{DF_ALT_Y, "Alt+Y"},
{DF_ALT_Z, "Alt+Z"},
{-1, NULL}
};
/* EOF */
rosapps/dflat32/keys.h
-119
View File
@@ -1,119 +0,0 @@
/* ----------- keys.h ------------ */
#ifndef KEYS_H
#define KEYS_H
#define DF_OFFSET 0x1000
#define DF_RUBOUT 8 /* BACHSPACE KEY */
#define DF_BELL 7
#define DF_ESC 27
#define DF_ALT_BS (197+DF_OFFSET)
#define DF_ALT_DEL (184+DF_OFFSET)
#define DF_SHIFT_DEL (198+DF_OFFSET)
#define DF_CTRL_INS (186+DF_OFFSET)
#define DF_SHIFT_INS (185+DF_OFFSET)
#define DF_SHIFT_F8 (219+DF_OFFSET)
#define DF_F1 (187+DF_OFFSET)
#define DF_F2 (188+DF_OFFSET)
#define DF_F3 (189+DF_OFFSET)
#define DF_F4 (190+DF_OFFSET)
#define DF_F5 (191+DF_OFFSET)
#define DF_F6 (192+DF_OFFSET)
#define DF_F7 (193+DF_OFFSET)
#define DF_F8 (194+DF_OFFSET)
#define DF_F9 (195+DF_OFFSET)
#define DF_F10 (196+DF_OFFSET)
#define DF_CTRL_F1 (222+DF_OFFSET)
#define DF_CTRL_F2 (223+DF_OFFSET)
#define DF_CTRL_F3 (224+DF_OFFSET)
#define DF_CTRL_F4 (225+DF_OFFSET)
#define DF_CTRL_F5 (226+DF_OFFSET)
#define DF_CTRL_F6 (227+DF_OFFSET)
#define DF_CTRL_F7 (228+DF_OFFSET)
#define DF_CTRL_F8 (229+DF_OFFSET)
#define DF_CTRL_F9 (230+DF_OFFSET)
#define DF_CTRL_F10 (231+DF_OFFSET)
#define DF_ALT_F1 (232+DF_OFFSET)
#define DF_ALT_F2 (233+DF_OFFSET)
#define DF_ALT_F3 (234+DF_OFFSET)
#define DF_ALT_F4 (235+DF_OFFSET)
#define DF_ALT_F5 (236+DF_OFFSET)
#define DF_ALT_F6 (237+DF_OFFSET)
#define DF_ALT_F7 (238+DF_OFFSET)
#define DF_ALT_F8 (239+DF_OFFSET)
#define DF_ALT_F9 (240+DF_OFFSET)
#define DF_ALT_F10 (241+DF_OFFSET)
#define DF_HOME (199+DF_OFFSET)
#define DF_UP (200+DF_OFFSET)
#define DF_PGUP (201+DF_OFFSET)
#define DF_BS (203+DF_OFFSET) /* CURSOR LEFT KEY */
#define DF_FWD (205+DF_OFFSET) /* CURSOR RIGHT KEY */
#define DF_END (207+DF_OFFSET)
#define DF_DN (208+DF_OFFSET)
#define DF_PGDN (209+DF_OFFSET)
#define DF_INS (210+DF_OFFSET)
#define DF_DEL (211+DF_OFFSET)
#define DF_CTRL_HOME (247+DF_OFFSET)
#define DF_CTRL_PGUP (132+DF_OFFSET)
#define DF_CTRL_BS (243+DF_OFFSET)
#define DF_CTRL_FIVE (143+DF_OFFSET)
#define DF_CTRL_FWD (244+DF_OFFSET)
#define DF_CTRL_END (245+DF_OFFSET)
#define DF_CTRL_PGDN (246+DF_OFFSET)
#define DF_SHIFT_HT (143+DF_OFFSET)
#define DF_ALT_A (158+DF_OFFSET)
#define DF_ALT_B (176+DF_OFFSET)
#define DF_ALT_C (174+DF_OFFSET)
#define DF_ALT_D (160+DF_OFFSET)
#define DF_ALT_E (146+DF_OFFSET)
#define DF_ALT_F (161+DF_OFFSET)
#define DF_ALT_G (162+DF_OFFSET)
#define DF_ALT_H (163+DF_OFFSET)
#define DF_ALT_I (151+DF_OFFSET)
#define DF_ALT_J (164+DF_OFFSET)
#define DF_ALT_K (165+DF_OFFSET)
#define DF_ALT_L (166+DF_OFFSET)
#define DF_ALT_M (178+DF_OFFSET)
#define DF_ALT_N (177+DF_OFFSET)
#define DF_ALT_O (152+DF_OFFSET)
#define DF_ALT_P (153+DF_OFFSET)
#define DF_ALT_Q (144+DF_OFFSET)
#define DF_ALT_R (147+DF_OFFSET)
#define DF_ALT_S (159+DF_OFFSET)
#define DF_ALT_T (148+DF_OFFSET)
#define DF_ALT_U (150+DF_OFFSET)
#define DF_ALT_V (175+DF_OFFSET)
#define DF_ALT_W (145+DF_OFFSET)
#define DF_ALT_X (173+DF_OFFSET)
#define DF_ALT_Y (149+DF_OFFSET)
#define DF_ALT_Z (172+DF_OFFSET)
#define DF_ALT_1 (0xf8+DF_OFFSET)
#define DF_ALT_2 (0xf9+DF_OFFSET)
#define DF_ALT_3 (0xfa+DF_OFFSET)
#define DF_ALT_4 (0xfb+DF_OFFSET)
#define DF_ALT_5 (0xfc+DF_OFFSET)
#define DF_ALT_6 (0xfd+DF_OFFSET)
#define DF_ALT_7 (0xfe+DF_OFFSET)
#define DF_ALT_8 (0xff+DF_OFFSET)
#define DF_ALT_9 (0x80+DF_OFFSET)
#define DF_ALT_0 (0x81+DF_OFFSET)
#define DF_ALT_HYPHEN (130+DF_OFFSET)
#define DF_RIGHTSHIFT 0x01
#define DF_LEFTSHIFT 0x02
#define DF_CTRLKEY 0x04
#define DF_ALTKEY 0x08
#define DF_SCROLLLOCK 0x10
#define DF_NUMLOCK 0x20
#define DF_CAPSLOCK 0x40
#define DF_INSERTKEY 0x80
struct DfKeys {
int keycode;
char *keylabel;
};
extern struct DfKeys keys[];
#endif
rosapps/dflat32/listbox.c
-469
View File
@@ -1,469 +0,0 @@
/* ------------- listbox.c ------------ */
#include "dflat.h"
#ifdef INCLUDE_EXTENDEDSELECTIONS
static int ExtendSelections(DFWINDOW, int, int);
static void TestExtended(DFWINDOW, DF_PARAM);
static void ClearAllSelections(DFWINDOW);
static void SetSelection(DFWINDOW, int);
static void FlipSelection(DFWINDOW, int);
static void ClearSelection(DFWINDOW, int);
#else
#define TestExtended(w,p) /**/
#endif
static void ChangeSelection(DFWINDOW, int, int);
static void WriteSelection(DFWINDOW, int, int, DFRECT *);
static BOOL SelectionInWindow(DFWINDOW, int);
static int py = -1; /* the previous y mouse coordinate */
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* --------- DF_SHIFT_F8 Key ------------ */
static void AddModeKey(DFWINDOW wnd)
{
if (DfIsMultiLine(wnd)) {
wnd->AddMode ^= TRUE;
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS,
wnd->AddMode ? ((DF_PARAM) "Add Mode") : 0, 0);
}
}
#endif
/* --------- DF_UP (Up Arrow) Key ------------ */
static void UpKey(DFWINDOW wnd, DF_PARAM p2)
{
if (wnd->selection > 0) {
if (wnd->selection == wnd->wtop) {
DfBaseWndProc(DF_LISTBOX, wnd, DFM_KEYBOARD, DF_UP, p2);
DfPostMessage(wnd, DFM_LB_SELECTION, wnd->selection-1,
DfIsMultiLine(wnd) ? p2 : FALSE);
}
else {
int newsel = wnd->selection-1;
if (wnd->wlines == DfClientHeight(wnd))
while (*DfTextLine(wnd, newsel) == DF_LINE)
--newsel;
DfPostMessage(wnd, DFM_LB_SELECTION, newsel,
#ifdef INCLUDE_EXTENDEDSELECTIONS
DfIsMultiLine(wnd) ? p2 :
#endif
FALSE);
}
}
}
/* --------- DF_DN (Down Arrow) Key ------------ */
static void DnKey(DFWINDOW wnd, DF_PARAM p2)
{
if (wnd->selection < wnd->wlines-1) {
if (wnd->selection == wnd->wtop+DfClientHeight(wnd)-1) {
DfBaseWndProc(DF_LISTBOX, wnd, DFM_KEYBOARD, DF_DN, p2);
DfPostMessage(wnd, DFM_LB_SELECTION, wnd->selection+1,
DfIsMultiLine(wnd) ? p2 : FALSE);
}
else {
int newsel = wnd->selection+1;
if (wnd->wlines == DfClientHeight(wnd))
while (*DfTextLine(wnd, newsel) == DF_LINE)
newsel++;
DfPostMessage(wnd, DFM_LB_SELECTION, newsel,
#ifdef INCLUDE_EXTENDEDSELECTIONS
DfIsMultiLine(wnd) ? p2 :
#endif
FALSE);
}
}
}
/* --------- DF_HOME and DF_PGUP Keys ------------ */
static void HomePgUpKey(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
DfBaseWndProc(DF_LISTBOX, wnd, DFM_KEYBOARD, p1, p2);
DfPostMessage(wnd, DFM_LB_SELECTION, wnd->wtop,
#ifdef INCLUDE_EXTENDEDSELECTIONS
DfIsMultiLine(wnd) ? p2 :
#endif
FALSE);
}
/* --------- DF_END and DF_PGDN Keys ------------ */
static void EndPgDnKey(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int bot;
DfBaseWndProc(DF_LISTBOX, wnd, DFM_KEYBOARD, p1, p2);
bot = wnd->wtop+DfClientHeight(wnd)-1;
if (bot > wnd->wlines-1)
bot = wnd->wlines-1;
DfPostMessage(wnd, DFM_LB_SELECTION, bot,
#ifdef INCLUDE_EXTENDEDSELECTIONS
DfIsMultiLine(wnd) ? p2 :
#endif
FALSE);
}
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* --------- Space Bar Key ------------ */
static void SpacebarKey(DFWINDOW wnd, DF_PARAM p2)
{
if (DfIsMultiLine(wnd)) {
int sel = DfSendMessage(wnd, DFM_LB_CURRENTSELECTION, 0, 0);
if (sel != -1) {
if (wnd->AddMode)
FlipSelection(wnd, sel);
if (DfItemSelected(wnd, sel)) {
if (!((int) p2 & (DF_LEFTSHIFT | DF_RIGHTSHIFT)))
wnd->AnchorPoint = sel;
ExtendSelections(wnd, sel, (int) p2);
}
else
wnd->AnchorPoint = -1;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
}
}
#endif
/* --------- Enter ('\r') Key ------------ */
static void EnterKey(DFWINDOW wnd)
{
if (wnd->selection != -1) {
DfSendMessage(wnd, DFM_LB_SELECTION, wnd->selection, TRUE);
DfSendMessage(wnd, DFM_LB_CHOOSE, wnd->selection, 0);
}
}
/* --------- All Other Key Presses ------------ */
static void KeyPress(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int sel = wnd->selection+1;
while (sel < wnd->wlines) {
char *cp = DfTextLine(wnd, sel);
if (cp == NULL)
break;
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (DfIsMultiLine(wnd))
cp++;
#endif
/* --- special for directory list box --- */
if (*cp == '[')
cp++;
if (tolower(*cp) == (int)p1) {
DfSendMessage(wnd, DFM_LB_SELECTION, sel,
DfIsMultiLine(wnd) ? p2 : FALSE);
if (!SelectionInWindow(wnd, sel)) {
wnd->wtop = sel-DfClientHeight(wnd)+1;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
break;
}
sel++;
}
}
/* --------- DFM_KEYBOARD Message ------------ */
static int KeyboardMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
switch ((int) p1) {
#ifdef INCLUDE_EXTENDEDSELECTIONS
case DF_SHIFT_F8:
AddModeKey(wnd);
return TRUE;
#endif
case DF_UP:
TestExtended(wnd, p2);
UpKey(wnd, p2);
return TRUE;
case DF_DN:
TestExtended(wnd, p2);
DnKey(wnd, p2);
return TRUE;
case DF_PGUP:
case DF_HOME:
TestExtended(wnd, p2);
HomePgUpKey(wnd, p1, p2);
return TRUE;
case DF_PGDN:
case DF_END:
TestExtended(wnd, p2);
EndPgDnKey(wnd, p1, p2);
return TRUE;
#ifdef INCLUDE_EXTENDEDSELECTIONS
case ' ':
SpacebarKey(wnd, p2);
break;
#endif
case '\r':
EnterKey(wnd);
return TRUE;
default:
KeyPress(wnd, p1, p2);
break;
}
return FALSE;
}
/* ------- DFM_LEFT_BUTTON Message -------- */
static int LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int my = (int) p2 - DfGetTop(wnd);
if (my >= wnd->wlines-wnd->wtop)
my = wnd->wlines - wnd->wtop;
if (!DfInsideRect(p1, p2, DfClientRect(wnd)))
return FALSE;
if (wnd->wlines && my != py) {
int sel = wnd->wtop+my-1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
int sh = DfGetShift();
if (!(sh & (DF_LEFTSHIFT | DF_RIGHTSHIFT))) {
if (!(sh & DF_CTRLKEY))
ClearAllSelections(wnd);
wnd->AnchorPoint = sel;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
#endif
DfSendMessage(wnd, DFM_LB_SELECTION, sel, TRUE);
py = my;
}
return TRUE;
}
/* ------------- DOUBLE_CLICK Message ------------ */
static int DoubleClickMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
if (DfWindowMoving || DfWindowSizing)
return FALSE;
if (wnd->wlines) {
DFRECT rc = DfClientRect(wnd);
DfBaseWndProc(DF_LISTBOX, wnd, DOUBLE_CLICK, p1, p2);
if (DfInsideRect(p1, p2, rc))
DfSendMessage(wnd, DFM_LB_CHOOSE, wnd->selection, 0);
}
return TRUE;
}
/* ------------ DFM_ADDTEXT Message -------------- */
static int AddTextMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int rtn = DfBaseWndProc(DF_LISTBOX, wnd, DFM_ADDTEXT, p1, p2);
if (wnd->selection == -1)
DfSendMessage(wnd, DFM_LB_SETSELECTION, 0, 0);
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (*(char *)p1 == DF_LISTSELECTOR)
wnd->SelectCount++;
#endif
return rtn;
}
/* --------- DFM_GETTEXT Message ------------ */
static void GetTextMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
if ((int)p2 != -1) {
char *cp1 = (char *)p1;
char *cp2 = DfTextLine(wnd, (int)p2);
while (cp2 && *cp2 && *cp2 != '\n')
*cp1++ = *cp2++;
*cp1 = '\0';
}
}
/* --------- DF_LISTBOX Window Processing Module ------------ */
int DfListBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
DfBaseWndProc(DF_LISTBOX, wnd, msg, p1, p2);
wnd->selection = -1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
wnd->AnchorPoint = -1;
#endif
return TRUE;
case DFM_KEYBOARD:
if (DfWindowMoving || DfWindowSizing)
break;
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_LEFT_BUTTON:
if (LeftButtonMsg(wnd, p1, p2) == TRUE)
return TRUE;
break;
case DOUBLE_CLICK:
if (DoubleClickMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_BUTTON_RELEASED:
if (DfWindowMoving || DfWindowSizing || DfVSliding)
break;
py = -1;
return TRUE;
case DFM_ADDTEXT:
return AddTextMsg(wnd, p1, p2);
case DFM_LB_GETTEXT:
GetTextMsg(wnd, p1, p2);
return TRUE;
case DFM_CLEARTEXT:
wnd->selection = -1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
wnd->AnchorPoint = -1;
#endif
wnd->SelectCount = 0;
break;
case DFM_PAINT:
DfBaseWndProc(DF_LISTBOX, wnd, msg, p1, p2);
WriteSelection(wnd, wnd->selection, TRUE, (DFRECT *)p1);
return TRUE;
case DFM_SCROLL:
case DFM_HORIZSCROLL:
case DFM_SCROLLPAGE:
case DFM_HORIZPAGE:
case DFM_SCROLLDOC:
DfBaseWndProc(DF_LISTBOX, wnd, msg, p1, p2);
WriteSelection(wnd,wnd->selection,TRUE,NULL);
return TRUE;
case DFM_LB_CHOOSE:
DfSendMessage(DfGetParent(wnd), DFM_LB_CHOOSE, p1, p2);
return TRUE;
case DFM_LB_SELECTION:
ChangeSelection(wnd, (int) p1, (int) p2);
DfSendMessage(DfGetParent(wnd), DFM_LB_SELECTION,
wnd->selection, 0);
return TRUE;
case DFM_LB_CURRENTSELECTION:
return wnd->selection;
case DFM_LB_SETSELECTION:
ChangeSelection(wnd, (int) p1, 0);
return TRUE;
#ifdef INCLUDE_EXTENDEDSELECTIONS
case DFM_CLOSE_WINDOW:
if (DfIsMultiLine(wnd) && wnd->AddMode) {
wnd->AddMode = FALSE;
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, 0, 0);
}
break;
#endif
default:
break;
}
return DfBaseWndProc(DF_LISTBOX, wnd, msg, p1, p2);
}
static BOOL SelectionInWindow(DFWINDOW wnd, int sel)
{
return (wnd->wlines && sel >= wnd->wtop &&
sel < wnd->wtop+DfClientHeight(wnd));
}
static void WriteSelection(DFWINDOW wnd, int sel,
int reverse, DFRECT *rc)
{
if (DfIsVisible(wnd))
if (SelectionInWindow(wnd, sel))
DfWriteTextLine(wnd, rc, sel, reverse);
}
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* ----- Test for extended selections in the listbox ----- */
static void TestExtended(DFWINDOW wnd, DF_PARAM p2)
{
if (DfIsMultiLine(wnd) && !wnd->AddMode &&
!((int) p2 & (DF_LEFTSHIFT | DF_RIGHTSHIFT))) {
if (wnd->SelectCount > 1) {
ClearAllSelections(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
}
}
/* ----- Clear selections in the listbox ----- */
static void ClearAllSelections(DFWINDOW wnd)
{
if (DfIsMultiLine(wnd) && wnd->SelectCount > 0) {
int sel;
for (sel = 0; sel < wnd->wlines; sel++)
ClearSelection(wnd, sel);
}
}
/* ----- Invert a selection in the listbox ----- */
static void FlipSelection(DFWINDOW wnd, int sel)
{
if (DfIsMultiLine(wnd)) {
if (DfItemSelected(wnd, sel))
ClearSelection(wnd, sel);
else
SetSelection(wnd, sel);
}
}
static int ExtendSelections(DFWINDOW wnd, int sel, int shift)
{
if (shift & (DF_LEFTSHIFT | DF_RIGHTSHIFT) &&
wnd->AnchorPoint != -1) {
int i = sel;
int j = wnd->AnchorPoint;
int rtn;
if (j > i)
swap(i,j);
rtn = i - j;
while (j <= i)
SetSelection(wnd, j++);
return rtn;
}
return 0;
}
static void SetSelection(DFWINDOW wnd, int sel)
{
if (DfIsMultiLine(wnd) && !DfItemSelected(wnd, sel)) {
char *lp = DfTextLine(wnd, sel);
*lp = DF_LISTSELECTOR;
wnd->SelectCount++;
}
}
static void ClearSelection(DFWINDOW wnd, int sel)
{
if (DfIsMultiLine(wnd) && DfItemSelected(wnd, sel)) {
char *lp = DfTextLine(wnd, sel);
*lp = ' ';
--wnd->SelectCount;
}
}
BOOL DfItemSelected(DFWINDOW wnd, int sel)
{
if (sel != -1 && DfIsMultiLine(wnd) && sel < wnd->wlines) {
char *cp = DfTextLine(wnd, sel);
return (int)((*cp) & 255) == DF_LISTSELECTOR;
}
return FALSE;
}
#endif
static void ChangeSelection(DFWINDOW wnd,int sel,int shift)
{
if (sel != wnd->selection) {
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (DfIsMultiLine(wnd)) {
int sels;
if (!wnd->AddMode)
ClearAllSelections(wnd);
sels = ExtendSelections(wnd, sel, shift);
if (sels > 1)
DfSendMessage(wnd, DFM_PAINT, 0, 0);
if (sels == 0 && !wnd->AddMode) {
ClearSelection(wnd, wnd->selection);
SetSelection(wnd, sel);
wnd->AnchorPoint = sel;
}
}
#endif
WriteSelection(wnd, wnd->selection, FALSE, NULL);
wnd->selection = sel;
WriteSelection(wnd, sel, TRUE, NULL);
}
}
/* EOF */
rosapps/dflat32/lists.c
-149
View File
@@ -1,149 +0,0 @@
/* --------------- lists.c -------------- */
#include "dflat.h"
/* ----- set focus to the next sibling ----- */
void DfSetNextFocus (void)
{
if (DfInFocus != NULL)
{
DFWINDOW wnd1 = DfInFocus, pwnd;
while (TRUE)
{
pwnd = DfGetParent(wnd1);
if (DfNextWindow(wnd1) != NULL)
wnd1 = DfNextWindow(wnd1);
else if (pwnd != NULL)
wnd1 = DfFirstWindow(pwnd);
if (wnd1 == NULL || wnd1 == DfInFocus)
{
wnd1 = pwnd;
break;
}
if (DfGetClass(wnd1) == DF_STATUSBAR || DfGetClass(wnd1) == DF_MENUBAR)
continue;
if (DfIsVisible(wnd1))
break;
}
if (wnd1 != NULL)
{
while (wnd1->childfocus != NULL)
wnd1 = wnd1->childfocus;
if (wnd1->condition != DF_ISCLOSING)
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
}
}
}
/* ----- set focus to the previous sibling ----- */
void DfSetPrevFocus(void)
{
if (DfInFocus != NULL)
{
DFWINDOW wnd1 = DfInFocus, pwnd;
while (TRUE)
{
pwnd = DfGetParent(wnd1);
if (DfPrevWindow(wnd1) != NULL)
wnd1 = DfPrevWindow(wnd1);
else if (pwnd != NULL)
wnd1 = DfLastWindow(pwnd);
if (wnd1 == NULL || wnd1 == DfInFocus)
{
wnd1 = pwnd;
break;
}
if (DfGetClass(wnd1) == DF_STATUSBAR)
continue;
if (DfIsVisible(wnd1))
break;
}
if (wnd1 != NULL)
{
while (wnd1->childfocus != NULL)
wnd1 = wnd1->childfocus;
if (wnd1->condition != DF_ISCLOSING)
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
}
}
}
/* ------- move a window to the end of its parents list ----- */
void DfReFocus(DFWINDOW wnd)
{
if (DfGetParent(wnd) != NULL)
{
DfRemoveWindow(wnd);
DfAppendWindow(wnd);
DfReFocus(DfGetParent(wnd));
}
}
/* ---- remove a window from the linked list ---- */
void DfRemoveWindow(DFWINDOW wnd)
{
if (wnd != NULL)
{
DFWINDOW pwnd = DfGetParent(wnd);
if (DfPrevWindow(wnd) != NULL)
DfNextWindow(DfPrevWindow(wnd)) = DfNextWindow(wnd);
if (DfNextWindow(wnd) != NULL)
DfPrevWindow(DfNextWindow(wnd)) = DfPrevWindow(wnd);
if (pwnd != NULL)
{
if (wnd == DfFirstWindow(pwnd))
DfFirstWindow(pwnd) = DfNextWindow(wnd);
if (wnd == DfLastWindow(pwnd))
DfLastWindow(pwnd) = DfPrevWindow(wnd);
}
}
}
/* ---- append a window to the linked list ---- */
void DfAppendWindow(DFWINDOW wnd)
{
if (wnd != NULL)
{
DFWINDOW pwnd = DfGetParent(wnd);
if (pwnd != NULL)
{
if (DfFirstWindow(pwnd) == NULL)
{
DfFirstWindow(pwnd) = wnd;
DfLastWindow(pwnd) = wnd;
DfPrevWindow(wnd) = NULL;
}
else
{
DfNextWindow(DfLastWindow(pwnd)) = wnd;
DfPrevWindow(wnd) = DfLastWindow(pwnd);
DfLastWindow(pwnd) = wnd;
}
}
DfNextWindow(wnd) = NULL;
}
}
/*
* if document windows and statusbar or menubar get the focus,
* pass it on
*/
void DfSkipApplicationControls(void)
{
BOOL EmptyAppl = FALSE;
int ct = 0;
while (!EmptyAppl && DfInFocus != NULL)
{
DFCLASS cl = DfGetClass(DfInFocus);
if (cl == DF_MENUBAR || cl == DF_STATUSBAR)
{
DfSetPrevFocus();
EmptyAppl = (cl == DF_MENUBAR && ct++);
}
else
break;
}
}
/* EOF */
rosapps/dflat32/log.c
-75
View File
@@ -1,75 +0,0 @@
/* ------------ log .c ------------ */
#include "dflat.h"
#ifdef INCLUDE_LOGGING
static char *message[] = {
#undef DFlatMsg
#define DFlatMsg(m) " " #m,
#include "dflatmsg.h"
NULL
};
static FILE *logfile = NULL;
extern DF_DBOX Log;
void DfLogMessages (DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
if (logfile != NULL && message[msg][0] != ' ')
fprintf(logfile,
"%-20.20s %-12.12s %-20.20s, %5.5ld, %5.5ld\n",
wnd ? (DfGetTitle(wnd) ? DfGetTitle(wnd) : "") : "",
wnd ? DfClassNames[DfGetClass(wnd)] : "",
message[msg]+1, p1, p2);
}
static int LogProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
DFWINDOW cwnd = DfControlWindow(&Log, DF_ID_LOGLIST);
char **mn = message;
switch (msg) {
case DFM_INITIATE_DIALOG:
DfAddAttribute(cwnd, DF_MULTILINE | DF_VSCROLLBAR);
while (*mn) {
DfSendMessage(cwnd, DFM_ADDTEXT, (DF_PARAM) (*mn), 0);
mn++;
}
DfSendMessage(cwnd, DFM_SHOW_WINDOW, 0, 0);
break;
case DFM_COMMAND:
if ((int) p1 == DF_ID_OK) {
int item;
int tl = DfGetTextLines(cwnd);
for (item = 0; item < tl; item++)
if (DfItemSelected(cwnd, item))
mn[item][0] = DF_LISTSELECTOR;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
void DfMessageLog(DFWINDOW wnd)
{
if (DfDialogBox(wnd, &Log, TRUE, LogProc))
{
if (DfCheckBoxSetting(&Log, DF_ID_LOGGING))
{
logfile = fopen("DFLAT.LOG", "wt");
DfSetCommandToggle(&DfMainMenu, DF_ID_LOG);
}
else if (logfile != NULL)
{
fclose(logfile);
logfile = NULL;
DfClearCommandToggle(&DfMainMenu, DF_ID_LOG);
}
}
}
#endif
/* EOF */
rosapps/dflat32/memopad.c
-638
View File
@@ -1,638 +0,0 @@
/* --------------- memopad.c ----------- */
#include "dflat.h"
extern DF_DBOX PrintSetup;
char DFlatApplication[] = "MemoPad";
static char Untitled[] = "Untitled";
static int wndpos;
static int MemoPadProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void NewFile(DFWINDOW);
static void SelectFile(DFWINDOW);
static void PadWindow(DFWINDOW, char *);
static void OpenPadWindow(DFWINDOW, char *);
static void LoadFile(DFWINDOW);
static void PrintPad(DFWINDOW);
static void SaveFile(DFWINDOW, int);
static void MemoPadDeleteFile(DFWINDOW);
static int EditorProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static char *NameComponent(char *);
static int PrintSetupProc(DFWINDOW, DFMESSAGE, DF_PARAM, DF_PARAM);
static void FixTabMenu(void);
#ifndef TURBOC
void Calendar(DFWINDOW);
#endif
//void BarChart(DFWINDOW);
char **Argv;
#define CHARSLINE 80
#define LINESPAGE 66
void main(int argc, char *argv[])
{
DFWINDOW wnd;
if (!init_messages())
return;
Argv = argv;
DfLoadConfig();
// if (!DfLoadConfig())
// DfCfg.ScreenLines = DF_SCREENHEIGHT;
wnd = DfDfCreateWindow(DF_APPLICATION,
"FreeDos Edit " DF_VERSION,
0, 0, -1, -1,
&DfMainMenu,
NULL,
MemoPadProc,
DF_MOVEABLE |
DF_SIZEABLE |
DF_HASBORDER |
DF_MINMAXBOX |
DF_HASSTATUSBAR
);
DfLoadHelpFile();
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
while (argc > 1) {
PadWindow(wnd, argv[1]);
--argc;
argv++;
}
while (dispatch_message())
;
}
/* ------ open text files and put them into editboxes ----- */
static void PadWindow(DFWINDOW wnd, char *FileName)
{
int ax;
struct _finddata_t ff;
char path[64];
char *cp;
DfCreatePath(path, FileName, FALSE, FALSE);
cp = path+strlen(path);
DfCreatePath(path, FileName, TRUE, FALSE);
ax = _findfirst(path, &ff);
if (ax == -1)
return;
do
{
strcpy(cp, ff.name);
OpenPadWindow(wnd, path);
}
while (_findnext (ax, &ff) == 0);
_findclose (ax);
}
/* ------- window processing module for the
memopad application window ----- */
static int MemoPadProc(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
int rtn;
switch (msg) {
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
if (DfCfg.InsertMode)
DfSetCommandToggle(&DfMainMenu, DF_ID_INSERT);
if (DfCfg.WordWrap)
DfSetCommandToggle(&DfMainMenu, DF_ID_WRAP);
FixTabMenu();
return rtn;
case DFM_COMMAND:
switch ((int)p1) {
case DF_ID_NEW:
NewFile(wnd);
return TRUE;
case DF_ID_OPEN:
SelectFile(wnd);
return TRUE;
case DF_ID_SAVE:
SaveFile(DfInFocus, FALSE);
return TRUE;
case DF_ID_SAVEAS:
SaveFile(DfInFocus, TRUE);
return TRUE;
case DF_ID_DELETEFILE:
MemoPadDeleteFile(DfInFocus);
return TRUE;
case DF_ID_PRINTSETUP:
DfDialogBox(wnd, &PrintSetup, TRUE, PrintSetupProc);
return TRUE;
case DF_ID_PRINT:
PrintPad(DfInFocus);
return TRUE;
case DF_ID_EXIT:
if (!DfYesNoBox("Exit Memopad?"))
return FALSE;
break;
case DF_ID_WRAP:
DfCfg.WordWrap = DfGetCommandToggle(&DfMainMenu, DF_ID_WRAP);
return TRUE;
case DF_ID_INSERT:
DfCfg.InsertMode = DfGetCommandToggle(&DfMainMenu, DF_ID_INSERT);
return TRUE;
case DF_ID_TAB2:
DfCfg.Tabs = 2;
FixTabMenu();
return TRUE;
case DF_ID_TAB4:
DfCfg.Tabs = 4;
FixTabMenu();
return TRUE;
case DF_ID_TAB6:
DfCfg.Tabs = 6;
FixTabMenu();
return TRUE;
case DF_ID_TAB8:
DfCfg.Tabs = 8;
FixTabMenu();
return TRUE;
case DF_ID_CALENDAR:
#ifndef TURBOC
Calendar(wnd);
#endif
return TRUE;
// case DF_ID_BARCHART:
// BarChart(wnd);
// return TRUE;
case DF_ID_ABOUT:
DfMessageBox(
"About D-Flat and the MemoPad",
" ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿\n"
" ³ ÜÜÜ ÜÜÜ Ü ³\n"
" ³ Û Û Û Û Û ³\n"
" ³ Û Û Û Û Û ³\n"
" ³ Û Û Û Û Û Û ³\n"
" ³ ßßß ßßß ßß ³\n"
" ÀÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÙ\n"
"D-Flat implements the SAA/CUA\n"
"interface in a public domain\n"
"C language library originally\n"
"published in Dr. Dobb's Journal\n"
" ------------------------ \n"
"MemoPad is a multiple document\n"
"editor that demonstrates D-Flat");
return TRUE;
default:
break;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* --- The New command. Open an empty editor window --- */
static void NewFile(DFWINDOW wnd)
{
OpenPadWindow(wnd, Untitled);
}
/* --- The Open... command. Select a file --- */
static void SelectFile(DFWINDOW wnd)
{
char FileName[64];
if (DfOpenFileDialogBox("*.PAD", FileName)) {
/* --- see if the document is already in a window --- */
DFWINDOW wnd1 = DfFirstWindow(wnd);
while (wnd1 != NULL) {
if (stricmp(FileName, wnd1->extension) == 0) {
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, DFM_RESTORE, 0, 0);
return;
}
wnd1 = DfNextWindow(wnd1);
}
OpenPadWindow(wnd, FileName);
}
}
/* --- open a document window and load a file --- */
static void OpenPadWindow(DFWINDOW wnd, char *FileName)
{
static DFWINDOW wnd1 = NULL;
DFWINDOW wwnd;
struct stat sb;
char *Fname = FileName;
char *ermsg;
if (strcmp(FileName, Untitled)) {
if (stat(FileName, &sb)) {
ermsg = DfMalloc(strlen(FileName)+20);
strcpy(ermsg, "No such file as\n");
strcat(ermsg, FileName);
DfErrorMessage(ermsg);
free(ermsg);
return;
}
Fname = NameComponent(FileName);
}
wwnd = DfWatchIcon();
wndpos += 2;
if (wndpos == 20)
wndpos = 2;
wnd1 = DfDfCreateWindow(DF_EDITBOX,
Fname,
(wndpos-1)*2, wndpos, 10, 40,
NULL, wnd, EditorProc,
DF_SHADOW |
DF_MINMAXBOX |
DF_CONTROLBOX |
DF_VSCROLLBAR |
DF_HSCROLLBAR |
DF_MOVEABLE |
DF_HASBORDER |
DF_SIZEABLE |
DF_MULTILINE
);
if (strcmp(FileName, Untitled)) {
wnd1->extension = DfMalloc(strlen(FileName)+1);
strcpy(wnd1->extension, FileName);
LoadFile(wnd1);
}
DfSendMessage(wwnd, DFM_CLOSE_WINDOW, 0, 0);
DfSendMessage(wnd1, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, DFM_MAXIMIZE, 0, 0);
}
/* --- Load the notepad file into the editor text buffer --- */
static void LoadFile(DFWINDOW wnd)
{
char *Buf = NULL;
int recptr = 0;
FILE *fp;
if ((fp = fopen(wnd->extension, "rt")) != NULL) {
while (!feof(fp)) {
DfHandshake();
Buf = DfRealloc(Buf, recptr+150);
memset(Buf+recptr, 0, 150);
fgets(Buf+recptr, 150, fp);
recptr += strlen(Buf+recptr);
}
fclose(fp);
if (Buf != NULL) {
DfSendMessage(wnd, DFM_SETTEXT, (DF_PARAM) Buf, 0);
free(Buf);
}
}
}
static int LineCtr;
static int CharCtr;
/* ------- print a character -------- */
static void PrintChar(FILE *prn, int c)
{
int i;
if (c == '\n' || CharCtr == DfCfg.RightMargin) {
fputs("\r\n", prn);
LineCtr++;
if (LineCtr == DfCfg.BottomMargin) {
fputc('\f', prn);
for (i = 0; i < DfCfg.TopMargin; i++)
fputc('\n', prn);
LineCtr = DfCfg.TopMargin;
}
CharCtr = 0;
if (c == '\n')
return;
}
if (CharCtr == 0) {
for (i = 0; i < DfCfg.LeftMargin; i++) {
fputc(' ', prn);
CharCtr++;
}
}
CharCtr++;
fputc(c, prn);
}
/* --- print the current notepad --- */
static void PrintPad(DFWINDOW wnd)
{
if (*DfCfg.PrinterPort) {
FILE *prn;
if ((prn = fopen(DfCfg.PrinterPort, "wt")) != NULL) {
long percent;
BOOL KeepPrinting = TRUE;
unsigned char *text = DfGetText(wnd);
unsigned oldpct = 100, cct = 0, len = strlen(text);
DFWINDOW swnd = DfSliderBox(20, DfGetTitle(wnd), "Printing");
/* ------- print the notepad text --------- */
LineCtr = CharCtr = 0;
while (KeepPrinting && *text) {
PrintChar(prn, *text++);
percent = ((long) ++cct * 100) / len;
if ((int)percent != (int)oldpct) {
oldpct = (int) percent;
KeepPrinting = DfSendMessage(swnd, DFM_PAINT, 0, oldpct);
}
}
if (KeepPrinting)
/* ---- user did not cancel ---- */
if (oldpct < 100)
DfSendMessage(swnd, DFM_PAINT, 0, 100);
/* ------- follow with a form feed? --------- */
if (DfYesNoBox("Form Feed?"))
fputc('\f', prn);
fclose(prn);
}
else
DfErrorMessage("Cannot open printer file");
}
else
DfErrorMessage("No printer selected");
}
/* ---------- save a file to disk ------------ */
static void SaveFile(DFWINDOW wnd, int Saveas)
{
FILE *fp;
if (wnd->extension == NULL || Saveas) {
char FileName[64];
if (DfSaveAsDialogBox(FileName)) {
if (wnd->extension != NULL)
free(wnd->extension);
wnd->extension = DfMalloc(strlen(FileName)+1);
strcpy(wnd->extension, FileName);
DfAddTitle(wnd, NameComponent(FileName));
DfSendMessage(wnd, DFM_BORDER, 0, 0);
}
else
return;
}
if (wnd->extension != NULL) {
DFWINDOW mwnd = DfMomentaryMessage("Saving the file");
if ((fp = fopen(wnd->extension, "wt")) != NULL) {
fwrite(DfGetText(wnd), strlen(DfGetText(wnd)), 1, fp);
fclose(fp);
wnd->TextChanged = FALSE;
}
DfSendMessage(mwnd, DFM_CLOSE_WINDOW, 0, 0);
}
}
/* -------- delete a file ------------ */
static void MemoPadDeleteFile(DFWINDOW wnd)
{
if (wnd->extension != NULL) {
if (strcmp(wnd->extension, Untitled)) {
char *fn = NameComponent(wnd->extension);
if (fn != NULL) {
char msg[30];
sprintf(msg, "Delete %s?", fn);
if (DfYesNoBox(msg)) {
unlink(wnd->extension);
DfSendMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
}
}
}
}
}
/* ------ display the row and column in the statusbar ------ */
static void ShowPosition(DFWINDOW wnd)
{
char status[30];
sprintf(status, "Line:%4d Column: %2d",
wnd->CurrLine, wnd->CurrCol);
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, (DF_PARAM) status, 0);
}
/* ----- window processing module for the editboxes ----- */
static int EditorProc(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
int rtn;
switch (msg) {
case DFM_SETFOCUS:
if ((int)p1) {
wnd->InsertMode = DfGetCommandToggle(&DfMainMenu, DF_ID_INSERT);
wnd->WordWrapMode = DfGetCommandToggle(&DfMainMenu, DF_ID_WRAP);
}
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
if ((int)p1 == FALSE)
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, 0, 0);
else
ShowPosition(wnd);
return rtn;
case DFM_KEYBOARD_CURSOR:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
ShowPosition(wnd);
return rtn;
case DFM_COMMAND:
switch ((int) p1) {
case DF_ID_SEARCH:
SearchText(wnd);
return TRUE;
case DF_ID_REPLACE:
ReplaceText(wnd);
return TRUE;
case DF_ID_SEARCHNEXT:
SearchNext(wnd);
return TRUE;
case DF_ID_CUT:
DfCopyToClipboard(wnd);
DfSendMessage(wnd, DFM_COMMAND, DF_ID_DELETETEXT, 0);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_COPY:
DfCopyToClipboard(wnd);
DfClearTextBlock(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_PASTE:
DfPasteFromClipboard(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DF_ID_DELETETEXT:
case DF_ID_CLEAR:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return rtn;
case DF_ID_HELP:
DfDisplayHelp(wnd, "MEMOPADDOC");
return TRUE;
case DF_ID_WRAP:
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_WRAP, 0);
wnd->WordWrapMode = DfCfg.WordWrap;
return TRUE;
case DF_ID_INSERT:
DfSendMessage(DfGetParent(wnd), DFM_COMMAND, DF_ID_INSERT, 0);
wnd->InsertMode = DfCfg.InsertMode;
DfSendMessage(NULL, DFM_SHOW_CURSOR, wnd->InsertMode, 0);
return TRUE;
default:
break;
}
break;
case DFM_CLOSE_WINDOW:
if (wnd->TextChanged) {
char *cp = DfMalloc(25+strlen(DfGetTitle(wnd)));
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
strcpy(cp, DfGetTitle(wnd));
strcat(cp, "\nText changed. Save it?");
if (DfYesNoBox(cp))
DfSendMessage(DfGetParent(wnd),
DFM_COMMAND, DF_ID_SAVE, 0);
free(cp);
}
wndpos = 0;
if (wnd->extension != NULL) {
free(wnd->extension);
wnd->extension = NULL;
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* -- point to the name component of a file specification -- */
static char *NameComponent(char *FileName)
{
char *Fname;
if ((Fname = strrchr(FileName, '\\')) == NULL)
if ((Fname = strrchr(FileName, ':')) == NULL)
Fname = FileName-1;
return Fname + 1;
}
static char *ports[] = {
"Lpt1", "Lpt2", "Lpt3",
"Com1", "Com2", "Com3", "Com4",
NULL
};
static int PrintSetupProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn, i = 0, mar;
char marg[10];
DFWINDOW cwnd;
switch (msg) {
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfPutItemText(wnd, DF_ID_PRINTERPORT, DfCfg.PrinterPort);
while (ports[i] != NULL)
DfPutComboListText(wnd, DF_ID_PRINTERPORT, ports[i++]);
for (mar = CHARSLINE; mar >= 0; --mar) {
sprintf(marg, "%3d", mar);
DfPutItemText(wnd, DF_ID_LEFTMARGIN, marg);
DfPutItemText(wnd, DF_ID_RIGHTMARGIN, marg);
}
for (mar = LINESPAGE; mar >= 0; --mar) {
sprintf(marg, "%3d", mar);
DfPutItemText(wnd, DF_ID_TOPMARGIN, marg);
DfPutItemText(wnd, DF_ID_BOTTOMMARGIN, marg);
}
cwnd = DfControlWindow(&PrintSetup, DF_ID_LEFTMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
CHARSLINE-DfCfg.LeftMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_RIGHTMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
CHARSLINE-DfCfg.RightMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_TOPMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
LINESPAGE-DfCfg.TopMargin, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_BOTTOMMARGIN);
DfSendMessage(cwnd, DFM_LB_SETSELECTION,
LINESPAGE-DfCfg.BottomMargin, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == DF_ID_OK && (int) p2 == 0) {
DfGetItemText(wnd, DF_ID_PRINTERPORT, DfCfg.PrinterPort, 4);
cwnd = DfControlWindow(&PrintSetup, DF_ID_LEFTMARGIN);
DfCfg.LeftMargin = CHARSLINE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_RIGHTMARGIN);
DfCfg.RightMargin = CHARSLINE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_TOPMARGIN);
DfCfg.TopMargin = LINESPAGE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
cwnd = DfControlWindow(&PrintSetup, DF_ID_BOTTOMMARGIN);
DfCfg.BottomMargin = LINESPAGE -
DfSendMessage(cwnd, DFM_LB_CURRENTSELECTION, 0, 0);
}
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
static void FixTabMenu(void)
{
char *cp = DfGetCommandText(&DfMainMenu, DF_ID_TABS);
if (cp != NULL) {
cp = strchr(cp, '(');
if (cp != NULL) {
*(cp+1) = DfCfg.Tabs + '0';
if (DfGetClass(DfInFocus) == DF_POPDOWNMENU)
DfSendMessage(DfInFocus, DFM_PAINT, 0, 0);
}
}
}
void DfPrepFileMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_SAVE);
DfDeactivateCommand(&DfMainMenu, DF_ID_SAVEAS);
DfDeactivateCommand(&DfMainMenu, DF_ID_DELETEFILE);
DfDeactivateCommand(&DfMainMenu, DF_ID_PRINT);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX) {
if (DfIsMultiLine(wnd)) {
DfActivateCommand(&DfMainMenu, DF_ID_SAVE);
DfActivateCommand(&DfMainMenu, DF_ID_SAVEAS);
DfActivateCommand(&DfMainMenu, DF_ID_DELETEFILE);
DfActivateCommand(&DfMainMenu, DF_ID_PRINT);
}
}
}
void DfPrepSearchMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_SEARCH);
DfDeactivateCommand(&DfMainMenu, DF_ID_REPLACE);
DfDeactivateCommand(&DfMainMenu, DF_ID_SEARCHNEXT);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX) {
if (DfIsMultiLine(wnd)) {
DfActivateCommand(&DfMainMenu, DF_ID_SEARCH);
DfActivateCommand(&DfMainMenu, DF_ID_REPLACE);
DfActivateCommand(&DfMainMenu, DF_ID_SEARCHNEXT);
}
}
}
void DfPrepEditMenu(void *w, struct DfMenu *mnu)
{
DFWINDOW wnd = w;
DfDeactivateCommand(&DfMainMenu, DF_ID_CUT);
DfDeactivateCommand(&DfMainMenu, DF_ID_COPY);
DfDeactivateCommand(&DfMainMenu, DF_ID_CLEAR);
DfDeactivateCommand(&DfMainMenu, DF_ID_DELETETEXT);
DfDeactivateCommand(&DfMainMenu, DF_ID_PARAGRAPH);
DfDeactivateCommand(&DfMainMenu, DF_ID_PASTE);
DfDeactivateCommand(&DfMainMenu, DF_ID_UNDO);
if (wnd != NULL && DfGetClass(wnd) == DF_EDITBOX) {
if (DfIsMultiLine(wnd)) {
if (DfTextBlockMarked(wnd)) {
DfActivateCommand(&DfMainMenu, DF_ID_CUT);
DfActivateCommand(&DfMainMenu, DF_ID_COPY);
DfActivateCommand(&DfMainMenu, DF_ID_CLEAR);
DfActivateCommand(&DfMainMenu, DF_ID_DELETETEXT);
}
DfActivateCommand(&DfMainMenu, DF_ID_PARAGRAPH);
if (!DfTestAttribute(wnd, DF_READONLY) &&
DfClipboard != NULL)
DfActivateCommand(&DfMainMenu, DF_ID_PASTE);
if (wnd->DeletedText != NULL)
DfActivateCommand(&DfMainMenu, DF_ID_UNDO);
}
}
}
/* EOF */
rosapps/dflat32/menu.c
-85
View File
@@ -1,85 +0,0 @@
/* ------------- menu.c ------------- */
#include "dflat.h"
static struct DfPopDown *FindCmd(DF_MBAR *mn, int cmd)
{
DF_MENU *mnu = mn->PullDown;
while (mnu->Title != (void *)-1) {
struct DfPopDown *pd = mnu->Selections;
while (pd->SelectionTitle != NULL) {
if (pd->ActionId == cmd)
return pd;
pd++;
}
mnu++;
}
return NULL;
}
char *DfGetCommandText(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return pd->SelectionTitle;
return NULL;
}
BOOL DfIsCascadedCommand(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return pd->Attrib & DF_CASCADED;
return FALSE;
}
void DfActivateCommand(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib &= ~DF_INACTIVE;
}
void DfDeactivateCommand(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib |= DF_INACTIVE;
}
BOOL isActive(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return !(pd->Attrib & DF_INACTIVE);
return FALSE;
}
BOOL DfGetCommandToggle(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return (pd->Attrib & DF_CHECKED) != 0;
return FALSE;
}
void DfSetCommandToggle(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib |= DF_CHECKED;
}
void DfClearCommandToggle(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib &= ~DF_CHECKED;
}
void DfInvertCommandToggle(DF_MBAR *mn, int cmd)
{
struct DfPopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib ^= DF_CHECKED;
}
rosapps/dflat32/menu.h
-63
View File
@@ -1,63 +0,0 @@
/* ------------ menu.h ------------- */
#ifndef MENU_H
#define MENU_H
#define DF_MAXPULLDOWNS 15
#define DF_MAXSELECTIONS 20
#define DF_MAXCASCADES 3 /* nesting level of cascaded menus */
/* ----------- popdown menu selection structure
one for each selection on a popdown menu --------- */
struct DfPopDown {
char *SelectionTitle; /* title of the selection */
int ActionId; /* the command executed */
int Accelerator; /* the accelerator key */
int Attrib; /* DF_INACTIVE | DF_CHECKED | DF_TOGGLE | DF_CASCADED*/
char *help; /* Help mnemonic */
};
/* ----------- popdown menu structure
one for each popdown menu on the menu bar -------- */
typedef struct DfMenu {
char *Title; /* title on the menu bar */
void (*PrepMenu)(void *, struct DfMenu *); /* function */
char *StatusText; /* text for the status bar */
int CascadeId; /* command id of cascading selection */
int Selection; /* most recent selection */
struct DfPopDown Selections[DF_MAXSELECTIONS+1];
} DF_MENU;
/* ----- one for each menu bar ----- */
typedef struct DfMenuBar {
int ActiveSelection;
DF_MENU PullDown[DF_MAXPULLDOWNS+1];
} DF_MBAR;
/* --------- macros to define a menu bar with
popdowns and selections ------------- */
#define DF_SEPCHAR "\xc4"
#define DF_DEFMENU(m) DF_MBAR m = {-1,{
#define DF_POPDOWN(ttl,func,stat) {ttl,func,stat,-1,0,{
#define DF_CASCADED_POPDOWN(id,func) {NULL,func,NULL,id,0,{
#define DF_SELECTION(stxt,acc,id,attr) {stxt,acc,id,attr,#acc},
#define DF_SEPARATOR {DF_SEPCHAR},
#define DF_ENDPOPDOWN {NULL}}},
#define DF_ENDMENU {(void *)-1} }};
/* -------- menu selection attributes -------- */
#define DF_INACTIVE 1
#define DF_CHECKED 2
#define DF_TOGGLE 4
#define DF_CASCADED 8
/* --------- the standard menus ---------- */
extern DF_MBAR DfMainMenu;
extern DF_MBAR DfSystemMenu;
extern DF_MBAR *DfActiveMenuBar;
int DfMenuHeight(struct DfPopDown *);
int DfMenuWidth(struct DfPopDown *);
#endif
rosapps/dflat32/menubar.c
-432
View File
@@ -1,432 +0,0 @@
/* ---------------- menubar.c ------------------ */
#include "dflat.h"
static void reset_menubar(DFWINDOW);
static struct {
int x1, x2; /* position in menu bar */
char sc; /* shortcut key value */
} menu[10];
static int mctr;
DF_MBAR *DfActiveMenuBar;
static DF_MENU *ActiveMenu;
static DFWINDOW mwnd;
static BOOL Selecting;
static DFWINDOW Cascaders[DF_MAXCASCADES];
static int casc;
static DFWINDOW GetDocFocus(void);
/* ----------- DFM_SETFOCUS Message ----------- */
static int SetFocusMsg(DFWINDOW wnd, DF_PARAM p1)
{
int rtn;
rtn = DfBaseWndProc(DF_MENUBAR, wnd, DFM_SETFOCUS, p1, 0);
if (!(int)p1)
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, 0, 0);
return rtn;
}
/* --------- DFM_BUILDMENU Message --------- */
static void BuildMenuMsg(DFWINDOW wnd, DF_PARAM p1)
{
int offset = 3;
reset_menubar(wnd);
mctr = 0;
DfActiveMenuBar = (DF_MBAR *) p1;
ActiveMenu = DfActiveMenuBar->PullDown;
while (ActiveMenu->Title != NULL &&
ActiveMenu->Title != (void*)-1)
{
char *cp;
if (strlen(DfGetText(wnd)+offset) <
strlen(ActiveMenu->Title)+3)
break;
DfGetText(wnd) = DfRealloc(DfGetText(wnd),
strlen(DfGetText(wnd))+5);
memmove(DfGetText(wnd) + offset+4, DfGetText(wnd) + offset,
strlen(DfGetText(wnd))-offset+1);
DfCopyCommand(DfGetText(wnd)+offset,ActiveMenu->Title,FALSE,
wnd->WindowColors [DF_STD_COLOR] [DF_BG]);
menu[mctr].x1 = offset;
offset += strlen(ActiveMenu->Title) + (3+DF_MSPACE);
menu[mctr].x2 = offset-DF_MSPACE;
cp = strchr(ActiveMenu->Title, DF_SHORTCUTCHAR);
if (cp)
menu[mctr].sc = tolower(*(cp+1));
mctr++;
ActiveMenu++;
}
ActiveMenu = DfActiveMenuBar->PullDown;
}
/* ---------- DFM_PAINT Message ---------- */
static void PaintMsg(DFWINDOW wnd)
{
if (Selecting)
return;
if (wnd == DfInFocus)
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS, 0, 0);
DfSetStandardColor(wnd);
DfWPuts(wnd, DfGetText(wnd), 0, 0);
if (DfActiveMenuBar == NULL)
return;
if (DfActiveMenuBar->ActiveSelection != -1 &&
(wnd == DfInFocus || mwnd != NULL)) {
char *sel, *cp;
int offset, offset1;
sel = DfMalloc(200);
offset=menu[DfActiveMenuBar->ActiveSelection].x1;
offset1=menu[DfActiveMenuBar->ActiveSelection].x2;
DfGetText(wnd)[offset1] = '\0';
DfSetReverseColor(wnd);
memset(sel, '\0', 200);
strcpy(sel, DfGetText(wnd)+offset);
cp = strchr(sel, DF_CHANGECOLOR);
if (cp != NULL)
*(cp + 2) = DfBackground | 0x80;
DfWPuts(wnd, sel,
offset-DfActiveMenuBar->ActiveSelection*4, 0);
DfGetText(wnd)[offset1] = ' ';
if (mwnd == NULL && wnd == DfInFocus) {
char *st = ActiveMenu
[DfActiveMenuBar->ActiveSelection].StatusText;
if (st != NULL)
DfSendMessage(DfGetParent(wnd), DFM_ADDSTATUS,
(DF_PARAM)st, 0);
}
free(sel);
}
}
/* ------------ DFM_KEYBOARD Message ------------- */
static void KeyboardMsg(DFWINDOW wnd, DF_PARAM p1)
{
DF_MENU *mnu;
int sel;
if (mwnd == NULL)
{
/* ----- search for menu bar shortcut keys ---- */
int c = tolower((int)p1);
int a = DfAltConvert((int)p1);
int j;
for (j = 0; j < mctr; j++) {
if ((DfInFocus == wnd && menu[j].sc == c) ||
(a && menu[j].sc == a)) {
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd, DFM_MB_SELECTION, j, 0);
return;
}
}
}
/* -------- search for accelerator keys -------- */
mnu = ActiveMenu;
while (mnu->Title != (void *)-1) {
struct DfPopDown *pd = mnu->Selections;
if (mnu->PrepMenu)
(*(mnu->PrepMenu))(GetDocFocus(), mnu);
while (pd->SelectionTitle != NULL) {
if (pd->Accelerator == (int) p1) {
if (pd->Attrib & DF_INACTIVE)
DfBeep();
else {
if (pd->Attrib & DF_TOGGLE)
pd->Attrib ^= DF_CHECKED;
DfSendMessage(GetDocFocus(),
DFM_SETFOCUS, TRUE, 0);
DfPostMessage(DfGetParent(wnd),
DFM_COMMAND, pd->ActionId, 0);
}
return;
}
pd++;
}
mnu++;
}
switch ((int)p1)
{
case DF_F1:
if (ActiveMenu == NULL || DfActiveMenuBar == NULL)
break;
sel = DfActiveMenuBar->ActiveSelection;
if (sel == -1)
{
DfBaseWndProc(DF_MENUBAR, wnd, DFM_KEYBOARD, DF_F1, 0);
return;
}
mnu = ActiveMenu+sel;
if (mwnd == NULL ||
mnu->Selections[0].SelectionTitle == NULL)
{
DfDisplayHelp(wnd,mnu->Title+1);
return;
}
break;
case '\r':
if (mwnd == NULL &&
DfActiveMenuBar->ActiveSelection != -1)
DfSendMessage(wnd, DFM_MB_SELECTION,
DfActiveMenuBar->ActiveSelection, 0);
break;
case DF_F10:
if (wnd != DfInFocus && mwnd == NULL) {
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
if ( DfActiveMenuBar->ActiveSelection == -1)
DfActiveMenuBar->ActiveSelection = 0;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
break;
}
/* ------- fall through ------- */
case DF_ESC:
if (DfInFocus == wnd && mwnd == NULL) {
DfActiveMenuBar->ActiveSelection = -1;
DfSendMessage(GetDocFocus(),DFM_SETFOCUS,TRUE,0);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
break;
case DF_FWD:
DfActiveMenuBar->ActiveSelection++;
if (DfActiveMenuBar->ActiveSelection == mctr)
DfActiveMenuBar->ActiveSelection = 0;
if (mwnd != NULL)
DfSendMessage(wnd, DFM_MB_SELECTION,
DfActiveMenuBar->ActiveSelection, 0);
else
DfSendMessage(wnd, DFM_PAINT, 0, 0);
break;
case DF_BS:
if (DfActiveMenuBar->ActiveSelection == 0 ||
DfActiveMenuBar->ActiveSelection == -1)
DfActiveMenuBar->ActiveSelection = mctr;
--DfActiveMenuBar->ActiveSelection;
if (mwnd != NULL)
DfSendMessage(wnd, DFM_MB_SELECTION,
DfActiveMenuBar->ActiveSelection, 0);
else
DfSendMessage(wnd, DFM_PAINT, 0, 0);
break;
default:
break;
}
}
/* --------------- DFM_LEFT_BUTTON Message ---------- */
static void LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1)
{
int i;
int mx = (int) p1 - DfGetLeft(wnd);
/* --- compute the selection that the left button hit --- */
for (i = 0; i < mctr; i++)
if (mx >= menu[i].x1-4*i &&
mx <= menu[i].x2-4*i-5)
break;
if (i < mctr)
if (i != DfActiveMenuBar->ActiveSelection || mwnd == NULL)
DfSendMessage(wnd, DFM_MB_SELECTION, i, 0);
}
/* -------------- DFM_MB_SELECTION Message -------------- */
static void SelectionMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int wd, mx, my;
DF_MENU *mnu;
if (!p2)
{
DfActiveMenuBar->ActiveSelection = -1;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
Selecting = TRUE;
mnu = ActiveMenu+(int)p1;
if (mnu->PrepMenu != NULL)
(*(mnu->PrepMenu))(GetDocFocus(), mnu);
wd = DfMenuWidth(mnu->Selections);
if (p2)
{
int brd = DfGetRight(wnd);
mx = DfGetLeft(mwnd) + DfWindowWidth(mwnd) - 1;
if (mx + wd > brd)
mx = brd - wd;
my = DfGetTop(mwnd) + mwnd->selection;
}
else
{
int offset = menu[(int)p1].x1 - 4 * (int)p1;
if (mwnd != NULL)
DfSendMessage(mwnd, DFM_CLOSE_WINDOW, 0, 0);
DfActiveMenuBar->ActiveSelection = (int) p1;
if (offset > DfWindowWidth(wnd)-wd)
offset = DfWindowWidth(wnd)-wd;
mx = DfGetLeft(wnd)+offset;
my = DfGetTop(wnd)+1;
}
mwnd = DfDfCreateWindow(DF_POPDOWNMENU, NULL,
mx, my,
DfMenuHeight(mnu->Selections),
wd,
NULL,
wnd,
NULL,
DF_SHADOW);
if (!p2)
{
Selecting = FALSE;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
Selecting = TRUE;
}
if (mnu->Selections[0].SelectionTitle != NULL)
{
DfSendMessage(mwnd, DFM_BUILD_SELECTIONS, (DF_PARAM) mnu, 0);
DfSendMessage(mwnd, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(mwnd, DFM_SHOW_WINDOW, 0, 0);
}
Selecting = FALSE;
}
/* --------- COMMAND Message ---------- */
static void CommandMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
if (p1 == DF_ID_HELP)
{
DfBaseWndProc(DF_MENUBAR, wnd, DFM_COMMAND, p1, p2);
return;
}
if (DfIsCascadedCommand(DfActiveMenuBar, (int)p1))
{
/* find the cascaded menu based on command id in p1 */
DF_MENU *mnu = ActiveMenu+mctr;
while (mnu->Title != (void *)-1) {
if (mnu->CascadeId == (int) p1) {
if (casc < DF_MAXCASCADES) {
Cascaders[casc++] = mwnd;
DfSendMessage(wnd, DFM_MB_SELECTION,
(DF_PARAM)(mnu-ActiveMenu), TRUE);
}
break;
}
mnu++;
}
}
else {
if (mwnd != NULL)
DfSendMessage(mwnd, DFM_CLOSE_WINDOW, 0, 0);
DfSendMessage(GetDocFocus(), DFM_SETFOCUS, TRUE, 0);
DfPostMessage(DfGetParent(wnd), DFM_COMMAND, p1, p2);
}
}
/* --------------- DFM_CLOSE_POPDOWN Message --------------- */
static void ClosePopdownMsg(DFWINDOW wnd)
{
if (casc > 0)
DfSendMessage(Cascaders[--casc], DFM_CLOSE_WINDOW, 0, 0);
else
{
mwnd = NULL;
DfActiveMenuBar->ActiveSelection = -1;
if (!Selecting)
{
DfSendMessage(GetDocFocus(), DFM_SETFOCUS, TRUE, 0);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
}
}
/* ---------------- DFM_CLOSE_WINDOW Message --------------- */
static void CloseWindowMsg(DFWINDOW wnd)
{
if (DfGetText(wnd) != NULL)
{
free(DfGetText(wnd));
DfGetText(wnd) = NULL;
}
mctr = 0;
DfActiveMenuBar->ActiveSelection = -1;
ActiveMenu = NULL;
DfActiveMenuBar = NULL;
}
/* --- Window processing module for DF_MENUBAR window class --- */
int DfMenuBarProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
switch (msg) {
case DFM_CREATE_WINDOW:
reset_menubar(wnd);
break;
case DFM_SETFOCUS:
return SetFocusMsg(wnd, p1);
case DFM_BUILDMENU:
BuildMenuMsg(wnd, p1);
break;
case DFM_PAINT:
if (!DfIsVisible(wnd) || DfGetText(wnd) == NULL)
break;
PaintMsg(wnd);
return FALSE;
case DFM_BORDER:
if (mwnd == NULL)
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
case DFM_KEYBOARD:
KeyboardMsg(wnd, p1);
return TRUE;
case DFM_LEFT_BUTTON:
LeftButtonMsg(wnd, p1);
return TRUE;
case DFM_MB_SELECTION:
SelectionMsg(wnd, p1, p2);
break;
case DFM_COMMAND:
CommandMsg(wnd, p1, p2);
return TRUE;
case DFM_INSIDE_WINDOW:
return DfInsideRect(p1, p2, DfWindowRect(wnd));
case DFM_CLOSE_POPDOWN:
ClosePopdownMsg(wnd);
return TRUE;
case DFM_CLOSE_WINDOW:
CloseWindowMsg(wnd);
rtn = DfBaseWndProc(DF_MENUBAR, wnd, msg, p1, p2);
return rtn;
default:
break;
}
return DfBaseWndProc(DF_MENUBAR, wnd, msg, p1, p2);
}
/* ------------- reset the DF_MENUBAR -------------- */
static void reset_menubar(DFWINDOW wnd)
{
DfGetText(wnd) = DfRealloc(DfGetText(wnd), DfGetScreenWidth()+5);
memset(DfGetText(wnd), ' ', DfGetScreenWidth());
*(DfGetText(wnd)+DfWindowWidth(wnd)) = '\0';
}
static DFWINDOW GetDocFocus(void)
{
DFWINDOW wnd = DfApplicationWindow;
if (wnd != NULL)
{
wnd = DfLastWindow(wnd);
while (wnd != NULL &&
(DfGetClass(wnd) == DF_MENUBAR ||
DfGetClass(wnd) == DF_STATUSBAR))
wnd = DfPrevWindow(wnd);
if (wnd != NULL)
{
while (wnd->childfocus != NULL)
wnd = wnd->childfocus;
}
}
return wnd ? wnd : DfApplicationWindow;
}
/* EOF */
rosapps/dflat32/menus.c
-126
View File
@@ -1,126 +0,0 @@
/* -------------- menus.c ------------- */
#include "dflat.h"
/* --------------------- the main menu --------------------- */
DF_DEFMENU(DfMainMenu)
/* --------------- the File popdown menu ----------------*/
DF_POPDOWN( "~File", DfPrepFileMenu, "Read/write/print files. Go to DOS" )
DF_SELECTION( "~New", DF_ID_NEW, 0, 0 )
DF_SELECTION( "~Open...", DF_ID_OPEN, 0, 0 )
DF_SEPARATOR
DF_SELECTION( "~Save", DF_ID_SAVE, DF_ALT_S, DF_INACTIVE)
DF_SELECTION( "Save ~as...", DF_ID_SAVEAS, 0, DF_INACTIVE)
DF_SELECTION( "D~elete", DF_ID_DELETEFILE, 0, DF_INACTIVE)
DF_SEPARATOR
DF_SELECTION( "~Print", DF_ID_PRINT, 0, DF_INACTIVE)
DF_SELECTION( "P~rinter setup...", DF_ID_PRINTSETUP, 0, 0 )
DF_SEPARATOR
DF_SELECTION( "~DOS", DF_ID_DOS, 0, 0 )
DF_SELECTION( "E~xit", DF_ID_EXIT, DF_ALT_X, 0 )
DF_ENDPOPDOWN
/* --------------- the Edit popdown menu ----------------*/
DF_POPDOWN( "~Edit", DfPrepEditMenu, "DfClipboard, delete text, paragraph" )
DF_SELECTION( "~Undo", DF_ID_UNDO, DF_ALT_BS, DF_INACTIVE)
DF_SEPARATOR
DF_SELECTION( "Cu~t", DF_ID_CUT, DF_SHIFT_DEL, DF_INACTIVE)
DF_SELECTION( "~Copy", DF_ID_COPY, DF_CTRL_INS, DF_INACTIVE)
DF_SELECTION( "~Paste", DF_ID_PASTE, DF_SHIFT_INS, DF_INACTIVE)
DF_SEPARATOR
DF_SELECTION( "Cl~ear", DF_ID_CLEAR, 0, DF_INACTIVE)
DF_SELECTION( "~Delete", DF_ID_DELETETEXT, DF_DEL, DF_INACTIVE)
DF_SEPARATOR
DF_SELECTION( "Pa~ragraph", DF_ID_PARAGRAPH, DF_ALT_P,DF_INACTIVE)
DF_ENDPOPDOWN
/* --------------- the Search popdown menu ----------------*/
DF_POPDOWN( "~Search", DfPrepSearchMenu, "Search and replace" )
DF_SELECTION( "~Search...", DF_ID_SEARCH, 0, DF_INACTIVE)
DF_SELECTION( "~Replace...",DF_ID_REPLACE, 0, DF_INACTIVE)
DF_SELECTION( "~Next", DF_ID_SEARCHNEXT, DF_F3, DF_INACTIVE)
DF_ENDPOPDOWN
/* ------------ the Utilities popdown menu --------------- */
DF_POPDOWN( "~Utilities", NULL, "Utility programs" )
DF_SELECTION( "~Calendar", DF_ID_CALENDAR, 0, 0)
// DF_SELECTION( "~Bar chart", DF_ID_BARCHART, 0, 0)
DF_ENDPOPDOWN
/* ------------- the Options popdown menu ---------------*/
DF_POPDOWN( "~Options", NULL, "Editor and display options" )
DF_SELECTION( "~Display...", DF_ID_DISPLAY, 0, 0 )
DF_SEPARATOR
#ifdef INCLUDE_LOGGING
DF_SELECTION( "~Log messages", DF_ID_LOG, DF_ALT_L, 0 )
DF_SEPARATOR
#endif
DF_SELECTION( "~Insert", DF_ID_INSERT, DF_INS, DF_TOGGLE)
DF_SELECTION( "~Word wrap", DF_ID_WRAP, 0, DF_TOGGLE)
DF_SELECTION( "~Tabs ( )", DF_ID_TABS, 0, DF_CASCADED)
DF_SEPARATOR
DF_SELECTION( "~Save options", DF_ID_SAVEOPTIONS, 0, 0 )
DF_ENDPOPDOWN
/* --------------- the Window popdown menu --------------*/
DF_POPDOWN( "~Window", DfPrepWindowMenu, "Select/close document windows" )
DF_SELECTION( NULL, DF_ID_CLOSEALL, 0, 0)
DF_SEPARATOR
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_SELECTION( "~More Windows...", DF_ID_MOREWINDOWS, 0, 0)
DF_SELECTION( NULL, DF_ID_WINDOW, 0, 0 )
DF_ENDPOPDOWN
/* --------------- the Help popdown menu ----------------*/
DF_POPDOWN( "~Help", NULL, "Get help" )
DF_SELECTION( "~Help for help...", DF_ID_HELPHELP, 0, 0 )
DF_SELECTION( "~Extended help...", DF_ID_EXTHELP, 0, 0 )
DF_SELECTION( "~Keys help...", DF_ID_KEYSHELP, 0, 0 )
DF_SELECTION( "Help ~index...", DF_ID_HELPINDEX, 0, 0 )
DF_SEPARATOR
DF_SELECTION( "~About...", DF_ID_ABOUT, 0, 0 )
#ifdef TESTING_DFLAT
DF_SEPARATOR
DF_SELECTION( "~Reload help database",DF_ID_LOADHELP,0, 0 )
#endif
DF_ENDPOPDOWN
/* ----- cascaded pulldown from Tabs... above ----- */
DF_CASCADED_POPDOWN( DF_ID_TABS, NULL )
DF_SELECTION( "~2 tab stops", DF_ID_TAB2, 0, 0)
DF_SELECTION( "~4 tab stops", DF_ID_TAB4, 0, 0)
DF_SELECTION( "~6 tab stops", DF_ID_TAB6, 0, 0)
DF_SELECTION( "~8 tab stops", DF_ID_TAB8, 0, 0)
DF_ENDPOPDOWN
DF_ENDMENU
/* ------------- the System Menu --------------------- */
DF_DEFMENU(DfSystemMenu)
DF_POPDOWN("System Menu", NULL, NULL)
#ifdef INCLUDE_RESTORE
DF_SELECTION("~Restore", DF_ID_SYSRESTORE, 0, 0 )
#endif
DF_SELECTION("~Move", DF_ID_SYSMOVE, 0, 0 )
DF_SELECTION("~Size", DF_ID_SYSSIZE, 0, 0 )
#ifdef INCLUDE_MINIMIZE
DF_SELECTION("Mi~nimize", DF_ID_SYSMINIMIZE, 0, 0 )
#endif
#ifdef INCLUDE_MAXIMIZE
DF_SELECTION("Ma~ximize", DF_ID_SYSMAXIMIZE, 0, 0 )
#endif
DF_SEPARATOR
DF_SELECTION("~Close", DF_ID_SYSCLOSE, DF_CTRL_F4, 0 )
DF_ENDPOPDOWN
DF_ENDMENU
rosapps/dflat32/message.c
-681
View File
@@ -1,681 +0,0 @@
/* --------- message.c ---------- */
#include "dflat.h"
#include "system.h"
static int handshaking = 0;
BOOL AllocTesting = FALSE;
jmp_buf AllocError;
BOOL AltDown = FALSE;
/* ---------- event queue ---------- */
static struct events
{
DFMESSAGE event;
int mx;
int my;
} EventQueue[DF_MAXMESSAGES];
/* ---------- message queue --------- */
static struct msgs
{
DFWINDOW wnd;
DFMESSAGE msg;
DF_PARAM p1;
DF_PARAM p2;
} MsgQueue[DF_MAXMESSAGES];
static int EventQueueOnCtr;
static int EventQueueOffCtr;
static int EventQueueCtr;
static int MsgQueueOnCtr;
static int MsgQueueOffCtr;
static int MsgQueueCtr;
DFWINDOW DfCaptureMouse;
DFWINDOW DfCaptureKeyboard;
static BOOL NoChildCaptureMouse;
static BOOL NoChildCaptureKeyboard;
//static int doubletimer = -1;
//static int delaytimer = -1;
static int clocktimer = -1;
static DFWINDOW Cwnd;
//static char ermsg[] = "Error accessing drive x";
static void StopMsg(void)
{
DfClearClipboard();
DfClearDialogBoxes();
DfRestoreCursor();
DfUnhideCursor();
}
SHORT DfGetScreenHeight (void)
{
return DfScreenHeight;
}
SHORT DfGetScreenWidth (void)
{
return DfScreenWidth;
}
/* ------------ initialize the message system --------- */
BOOL DfInitialize (VOID)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
AllocTesting = TRUE;
if (setjmp(AllocError) != 0)
{
StopMsg();
return FALSE;
}
/* get input and output handles */
DfInput = GetStdHandle (STD_INPUT_HANDLE);
DfOutput = GetStdHandle (STD_OUTPUT_HANDLE);
/* get screen size */
GetConsoleScreenBufferInfo (DfOutput, &csbi);
DfScreenHeight = (csbi.srWindow.Bottom - csbi.srWindow.Top) + 1;
DfScreenWidth = (csbi.srWindow.Right - csbi.srWindow.Left) + 1;
/* enable mouse events */
SetConsoleMode (DfInput, ENABLE_MOUSE_INPUT);
DfSaveCursor();
DfHideCursor();
DfCaptureMouse = NULL;
DfCaptureKeyboard = NULL;
NoChildCaptureMouse = FALSE;
NoChildCaptureKeyboard = FALSE;
MsgQueueOnCtr = 0;
MsgQueueOffCtr = 0;
MsgQueueCtr = 0;
EventQueueOnCtr = 0;
EventQueueOffCtr = 0;
EventQueueCtr = 0;
DfPostMessage (NULL, DFM_START, 0, 0);
return TRUE;
}
void DfTerminate (void)
{
}
/* ----- post an event and parameters to event queue ---- */
static void PostEvent(DFMESSAGE event, int p1, int p2)
{
if (EventQueueCtr != DF_MAXMESSAGES) {
EventQueue[EventQueueOnCtr].event = event;
EventQueue[EventQueueOnCtr].mx = p1;
EventQueue[EventQueueOnCtr].my = p2;
if (++EventQueueOnCtr == DF_MAXMESSAGES)
EventQueueOnCtr = 0;
EventQueueCtr++;
}
}
/* ------ collect mouse, clock, and keyboard events ----- */
static void collect_events(void)
{
static int OldShiftKeys = 0;
int sk = 0;
#ifdef TIMER_AVAILABLE
static BOOL flipflop = FALSE;
static char timestr[9];
struct tm *now;
int hr;
#endif
HANDLE DfInput = GetStdHandle (STD_INPUT_HANDLE);
INPUT_RECORD ir;
DWORD dwRead;
int c;
#ifdef TIMER_AVAILABLE
/* -------- test for a clock event (one/second) ------- */
if (DfTimedOut(clocktimer))
{
/* ----- get the current time ----- */
time_t t = time(NULL);
now = localtime(&t);
hr = now->tm_hour > 12 ?
now->tm_hour - 12 :
now->tm_hour;
if (hr == 0)
hr = 12;
sprintf(timestr, "%2d:%02d", hr, now->tm_min);
strcpy(timestr+5, now->tm_hour > 11 ? "pm " : "am ");
/* ------- blink the : at one-second intervals ----- */
if (flipflop)
*(timestr+2) = ' ';
flipflop ^= TRUE;
/* -------- reset the timer -------- */
DfSetTimer(clocktimer, 1);
/* -------- post the clock event -------- */
PostEvent(DFM_CLOCKTICK, (DF_PARAM)timestr, 0);
}
#endif
// WaitForSingleObject (DfInput, INFINITE);
ReadConsoleInput (DfInput, &ir, 1, &dwRead);
if ((ir.EventType == KEY_EVENT) &&
(ir.Event.KeyEvent.bKeyDown == TRUE))
{
/* handle key down events */
/* handle shift state changes */
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
{
sk |= DF_ALTKEY;
}
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
{
sk |= DF_CTRLKEY;
}
if (ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED)
{
sk |= DF_LEFTSHIFT + DF_RIGHTSHIFT;
}
if (sk != OldShiftKeys)
{
OldShiftKeys = sk;
/* the shift status changed */
PostEvent(DFM_SHIFT_CHANGED, sk, 0);
#if 0
if (sk & DF_ALTKEY)
AltDown = TRUE;
else
AltDown = FALSE;
#endif
}
if (ir.Event.KeyEvent.uChar.AsciiChar == 0)
{
switch (ir.Event.KeyEvent.wVirtualKeyCode)
{
case VK_F1:
c = DF_F1;
break;
case VK_F4:
if (sk & DF_ALTKEY)
c = DF_ALT_F4;
else if (sk & DF_CTRLKEY)
c = DF_CTRL_F4;
else
c = DF_F4;
case VK_F10:
c = DF_F10;
break;
case VK_UP:
c = DF_UP;
break;
case VK_DOWN:
c = DF_DN;
break;
case VK_LEFT:
c = DF_BS;
break;
case VK_RIGHT:
c = DF_FWD;
break;
case VK_INSERT:
c = DF_INS;
break;
case VK_DELETE:
c = DF_DEL;
break;
case VK_HOME:
c = DF_HOME;
break;
case VK_END:
c = DF_END;
break;
case VK_PRIOR:
c = DF_PGUP;
break;
case VK_NEXT:
c = DF_PGDN;
break;
default:
return;
}
}
else
{
/* special handling of SHIFT+TAB */
if (ir.Event.KeyEvent.uChar.AsciiChar == VK_TAB &&
(ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED))
c = DF_SHIFT_HT;
else
c = ir.Event.KeyEvent.uChar.AsciiChar;
}
PostEvent (DFM_KEYBOARD, c, sk);
}
else if (ir.EventType == MOUSE_EVENT)
{
/* handle mouse events */
if (ir.Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
{
PostEvent (MOUSE_MOVED,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwEventFlags == DOUBLE_CLICK)
{
if (ir.Event.MouseEvent.dwButtonState ==
FROM_LEFT_1ST_BUTTON_PRESSED)
{
PostEvent (DOUBLE_CLICK,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
}
else if (ir.Event.MouseEvent.dwEventFlags == 0)
{
/* single click */
if (ir.Event.MouseEvent.dwButtonState ==
FROM_LEFT_1ST_BUTTON_PRESSED)
{
PostEvent (DFM_LEFT_BUTTON,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwButtonState ==
RIGHTMOST_BUTTON_PRESSED)
{
PostEvent (DFM_RIGHT_BUTTON,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwButtonState == 0)
{
PostEvent (DFM_BUTTON_RELEASED,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
}
}
}
/* ----- post a message and parameters to msg queue ---- */
void DfPostMessage(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
if (msg == DFM_ENDDIALOG)
{
msg++;
--msg;
}
if (MsgQueueCtr != DF_MAXMESSAGES)
{
MsgQueue[MsgQueueOnCtr].wnd = wnd;
MsgQueue[MsgQueueOnCtr].msg = msg;
MsgQueue[MsgQueueOnCtr].p1 = p1;
MsgQueue[MsgQueueOnCtr].p2 = p2;
if (++MsgQueueOnCtr == DF_MAXMESSAGES)
MsgQueueOnCtr = 0;
MsgQueueCtr++;
}
}
/* --------- send a message to a window ----------- */
int DfSendMessage(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn = TRUE, x, y;
#ifdef INCLUDE_LOGGING
DfLogMessages(wnd, msg, p1, p2);
#endif
if (wnd != NULL)
switch (msg) {
case DFM_PAINT:
case DFM_BORDER:
/* ------- don't send these messages unless the
window is visible -------- */
if (DfIsVisible(wnd))
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
case DFM_RIGHT_BUTTON:
case DFM_LEFT_BUTTON:
case DOUBLE_CLICK:
case DFM_BUTTON_RELEASED:
/* --- don't send these messages unless the
window is visible or has captured the mouse -- */
if (DfIsVisible(wnd) || wnd == DfCaptureMouse)
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
case DFM_KEYBOARD:
case DFM_SHIFT_CHANGED:
/* ------- don't send these messages unless the
window is visible or has captured the keyboard -- */
if (!(DfIsVisible(wnd) || wnd == DfCaptureKeyboard))
break;
default:
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
}
/* ----- window processor returned true or the message was sent
to no window at all (NULL) ----- */
if (rtn != FALSE) {
/* --------- process messages that a window sends to the
system itself ---------- */
switch (msg) {
case DFM_STOP:
StopMsg();
break;
/* ------- clock messages --------- */
case DFM_CAPTURE_CLOCK:
Cwnd = wnd;
DfSetTimer(clocktimer, 0);
break;
case DFM_RELEASE_CLOCK:
Cwnd = NULL;
DfDisableTimer(clocktimer);
break;
/* -------- keyboard messages ------- */
case DFM_KEYBOARD_CURSOR:
if (wnd == NULL)
DfCursor((int)p1, (int)p2);
else if (wnd == DfInFocus)
DfCursor(DfGetClientLeft(wnd)+(int)p1,
DfGetClientTop(wnd)+(int)p2);
break;
case DFM_CAPTURE_KEYBOARD:
if (p2)
((DFWINDOW)p2)->PrevKeyboard=DfCaptureKeyboard;
else
wnd->PrevKeyboard = DfCaptureKeyboard;
DfCaptureKeyboard = wnd;
NoChildCaptureKeyboard = (int)p1;
break;
case DFM_RELEASE_KEYBOARD:
if (wnd != NULL)
{
if (DfCaptureKeyboard == wnd || (int)p1)
DfCaptureKeyboard = wnd->PrevKeyboard;
else
{
DFWINDOW twnd = DfCaptureKeyboard;
while (twnd != NULL)
{
if (twnd->PrevKeyboard == wnd)
{
twnd->PrevKeyboard = wnd->PrevKeyboard;
break;
}
twnd = twnd->PrevKeyboard;
}
if (twnd == NULL)
DfCaptureKeyboard = NULL;
}
wnd->PrevKeyboard = NULL;
}
else
DfCaptureKeyboard = NULL;
NoChildCaptureKeyboard = FALSE;
break;
case DFM_CURRENT_KEYBOARD_CURSOR:
DfCurrCursor(&x, &y);
*(int*)p1 = x;
*(int*)p2 = y;
break;
case DFM_SAVE_CURSOR:
DfSaveCursor();
break;
case DFM_RESTORE_CURSOR:
DfRestoreCursor();
break;
case DFM_HIDE_CURSOR:
DfNormalCursor();
DfHideCursor();
break;
case DFM_SHOW_CURSOR:
if (p1)
DfSetCursorSize(100);
else
DfSetCursorSize(5);
DfUnhideCursor();
break;
case DFM_CAPTURE_MOUSE:
if (p2)
((DFWINDOW)p2)->PrevMouse = DfCaptureMouse;
else
wnd->PrevMouse = DfCaptureMouse;
DfCaptureMouse = wnd;
NoChildCaptureMouse = (int)p1;
break;
case DFM_RELEASE_MOUSE:
if (wnd != NULL)
{
if (DfCaptureMouse == wnd || (int)p1)
DfCaptureMouse = wnd->PrevMouse;
else
{
DFWINDOW twnd = DfCaptureMouse;
while (twnd != NULL)
{
if (twnd->PrevMouse == wnd)
{
twnd->PrevMouse = wnd->PrevMouse;
break;
}
twnd = twnd->PrevMouse;
}
if (twnd == NULL)
DfCaptureMouse = NULL;
}
wnd->PrevMouse = NULL;
}
else
DfCaptureMouse = NULL;
NoChildCaptureMouse = FALSE;
break;
default:
break;
}
}
return rtn;
}
static DFRECT VisibleRect(DFWINDOW wnd)
{
DFRECT rc = DfWindowRect(wnd);
if (!DfTestAttribute(wnd, DF_NOCLIP))
{
DFWINDOW pwnd = DfGetParent(wnd);
DFRECT prc;
prc = DfClientRect(pwnd);
while (pwnd != NULL)
{
if (DfTestAttribute(pwnd, DF_NOCLIP))
break;
rc = DfSubRectangle(rc, prc);
if (!DfValidRect(rc))
break;
if ((pwnd = DfGetParent(pwnd)) != NULL)
prc = DfClientRect(pwnd);
}
}
return rc;
}
/* ----- find window that mouse coordinates are in --- */
static DFWINDOW inWindow(DFWINDOW wnd, int x, int y)
{
DFWINDOW Hit = NULL;
while (wnd != NULL) {
if (DfIsVisible(wnd)) {
DFWINDOW wnd1;
DFRECT rc = VisibleRect(wnd);
if (DfInsideRect(x, y, rc))
Hit = wnd;
if ((wnd1 = inWindow(DfLastWindow(wnd), x, y)) != NULL)
Hit = wnd1;
if (Hit != NULL)
break;
}
wnd = DfPrevWindow(wnd);
}
return Hit;
}
static DFWINDOW MouseWindow(int x, int y)
{
/* get the window in which a mouse event occurred */
DFWINDOW Mwnd = inWindow(DfApplicationWindow, x, y);
/* ---- process mouse captures ----- */
if (DfCaptureMouse != NULL)
{
if (NoChildCaptureMouse ||
Mwnd == NULL ||
!DfIsAncestor(Mwnd, DfCaptureMouse))
Mwnd = DfCaptureMouse;
}
return Mwnd;
}
void DfHandshake(void)
{
handshaking++;
DfDispatchMessage ();
--handshaking;
}
/* ---- dispatch messages to the message proc function ---- */
BOOL DfDispatchMessage (void)
{
DFWINDOW Mwnd, Kwnd;
/* -------- collect mouse and keyboard events ------- */
collect_events();
/* --------- dequeue and process events -------- */
while (EventQueueCtr > 0)
{
struct events ev;
ev = EventQueue[EventQueueOffCtr];
if (++EventQueueOffCtr == DF_MAXMESSAGES)
EventQueueOffCtr = 0;
--EventQueueCtr;
/* get the window in which a keyboard event occurred */
Kwnd = DfInFocus;
/* process keyboard captures */
if (DfCaptureKeyboard != NULL)
{
if (Kwnd == NULL ||
NoChildCaptureKeyboard ||
!DfIsAncestor(Kwnd, DfCaptureKeyboard))
Kwnd = DfCaptureKeyboard;
}
/* send mouse and keyboard messages to the
window that should get them */
switch (ev.event)
{
case DFM_SHIFT_CHANGED:
case DFM_KEYBOARD:
if (!handshaking)
DfSendMessage(Kwnd, ev.event, ev.mx, ev.my);
break;
case DFM_LEFT_BUTTON:
if (!handshaking)
{
Mwnd = MouseWindow(ev.mx, ev.my);
if (!DfCaptureMouse ||
(!NoChildCaptureMouse &&
DfIsAncestor(Mwnd, DfCaptureMouse)))
{
if (Mwnd != DfInFocus)
DfSendMessage(Mwnd, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(Mwnd, DFM_LEFT_BUTTON, ev.mx, ev.my);
}
}
break;
case DFM_BUTTON_RELEASED:
case DOUBLE_CLICK:
case DFM_RIGHT_BUTTON:
if (handshaking)
break;
case MOUSE_MOVED:
Mwnd = MouseWindow(ev.mx, ev.my);
DfSendMessage(Mwnd, ev.event, ev.mx, ev.my);
break;
case DFM_CLOCKTICK:
DfSendMessage(Cwnd, ev.event, ev.mx, ev.my);
break;
default:
break;
}
}
/* ------ dequeue and process messages ----- */
while (MsgQueueCtr > 0)
{
struct msgs mq;
mq = MsgQueue[MsgQueueOffCtr];
if (++MsgQueueOffCtr == DF_MAXMESSAGES)
MsgQueueOffCtr = 0;
--MsgQueueCtr;
DfSendMessage (mq.wnd, mq.msg, mq.p1, mq.p2);
if (mq.msg == DFM_ENDDIALOG)
return FALSE;
if (mq.msg == DFM_STOP)
return FALSE;
}
return TRUE;
}
/* EOF */
rosapps/dflat32/msgbox.c
-216
View File
@@ -1,216 +0,0 @@
/* ------------------ msgbox.c ------------------ */
#include "dflat.h"
extern DF_DBOX MsgBox;
extern DF_DBOX InputBoxDB;
DFWINDOW CancelWnd;
static int ReturnValue;
int DfMessageBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
DfGetClass(wnd) = DF_MESSAGEBOX;
DfInitWindowColors(wnd);
DfClearAttribute(wnd, DF_CONTROLBOX);
break;
case DFM_KEYBOARD:
if (p1 == '\r' || p1 == DF_ESC)
ReturnValue = (int)p1;
break;
default:
break;
}
return DfBaseWndProc(DF_MESSAGEBOX, wnd, msg, p1, p2);
}
int DfYesNoBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
DfGetClass(wnd) = DF_MESSAGEBOX;
DfInitWindowColors(wnd);
DfClearAttribute(wnd, DF_CONTROLBOX);
break;
case DFM_KEYBOARD: {
int c = tolower((int)p1);
if (c == 'y')
DfSendMessage(wnd, DFM_COMMAND, DF_ID_OK, 0);
else if (c == 'n')
DfSendMessage(wnd, DFM_COMMAND, DF_ID_CANCEL, 0);
break;
}
default:
break;
}
return DfBaseWndProc(DF_MESSAGEBOX, wnd, msg, p1, p2);
}
int DfErrorBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
DfGetClass(wnd) = DF_ERRORBOX;
DfInitWindowColors(wnd);
break;
case DFM_KEYBOARD:
if (p1 == '\r' || p1 == DF_ESC)
ReturnValue = (int)p1;
break;
default:
break;
}
return DfBaseWndProc(DF_ERRORBOX, wnd, msg, p1, p2);
}
int DfCancelBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
CancelWnd = wnd;
DfSendMessage(wnd, DFM_CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_CAPTURE_KEYBOARD, 0, 0);
break;
case DFM_COMMAND:
if ((int) p1 == DF_ID_CANCEL && (int) p2 == 0)
DfSendMessage(DfGetParent(wnd), msg, p1, p2);
return TRUE;
case DFM_CLOSE_WINDOW:
CancelWnd = NULL;
DfSendMessage(wnd, DFM_RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_RELEASE_KEYBOARD, 0, 0);
p1 = TRUE;
break;
default:
break;
}
return DfBaseWndProc(DF_MESSAGEBOX, wnd, msg, p1, p2);
}
void DfCloseCancelBox(void)
{
if (CancelWnd != NULL)
DfSendMessage(CancelWnd, DFM_CLOSE_WINDOW, 0, 0);
}
static char *InputText;
static int TextLength;
int InputBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
switch (msg) {
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(DfControlWindow(&InputBoxDB,DF_ID_INPUTTEXT),
DFM_SETTEXTLENGTH, TextLength, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == DF_ID_OK && (int) p2 == 0)
DfGetItemText(wnd, DF_ID_INPUTTEXT,
InputText, TextLength);
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
BOOL DfInputBox(DFWINDOW wnd,char *ttl,char *msg,char *text,int len)
{
InputText = text;
TextLength = len;
InputBoxDB.dwnd.title = ttl;
InputBoxDB.dwnd.w = 4 +
max(20, max(len, max((int)strlen(ttl), (int)strlen(msg))));
InputBoxDB.ctl[1].dwnd.x = (InputBoxDB.dwnd.w-2-len)/2;
InputBoxDB.ctl[0].dwnd.w = strlen(msg);
InputBoxDB.ctl[0].itext = msg;
InputBoxDB.ctl[1].dwnd.w = len;
InputBoxDB.ctl[2].dwnd.x = (InputBoxDB.dwnd.w - 20) / 2;
InputBoxDB.ctl[3].dwnd.x = InputBoxDB.ctl[2].dwnd.x + 10;
InputBoxDB.ctl[2].isetting = DF_ON;
InputBoxDB.ctl[3].isetting = DF_ON;
return DfDialogBox(wnd, &InputBoxDB, TRUE, InputBoxProc);
}
BOOL DfGenericMessage(DFWINDOW wnd,char *ttl,char *msg,int buttonct,
int (*wndproc)(struct DfWindow *,enum DfMessages,DF_PARAM,DF_PARAM),
char *b1, char *b2, int c1, int c2, int isModal)
{
BOOL rtn;
MsgBox.dwnd.title = ttl;
MsgBox.ctl[0].dwnd.h = DfMsgHeight(msg);
if (ttl)
MsgBox.ctl[0].dwnd.w = max(max(DfMsgWidth(msg),
(int)(buttonct*8 + buttonct + 2)), (int)strlen(ttl)+2);
else
MsgBox.ctl[0].dwnd.w = max(DfMsgWidth(msg), (int)(buttonct*8 + buttonct + 2));
MsgBox.dwnd.h = MsgBox.ctl[0].dwnd.h+6;
MsgBox.dwnd.w = MsgBox.ctl[0].dwnd.w+4;
if (buttonct == 1)
MsgBox.ctl[1].dwnd.x = (MsgBox.dwnd.w - 10) / 2;
else {
MsgBox.ctl[1].dwnd.x = (MsgBox.dwnd.w - 20) / 2;
MsgBox.ctl[2].dwnd.x = MsgBox.ctl[1].dwnd.x + 10;
MsgBox.ctl[2].class = DF_BUTTON;
}
MsgBox.ctl[1].dwnd.y = MsgBox.dwnd.h - 4;
MsgBox.ctl[2].dwnd.y = MsgBox.dwnd.h - 4;
MsgBox.ctl[0].itext = msg;
MsgBox.ctl[1].itext = b1;
MsgBox.ctl[2].itext = b2;
MsgBox.ctl[1].command = c1;
MsgBox.ctl[2].command = c2;
MsgBox.ctl[1].isetting = DF_ON;
MsgBox.ctl[2].isetting = DF_ON;
rtn = DfDialogBox(wnd, &MsgBox, isModal, wndproc);
MsgBox.ctl[2].class = 0;
return rtn;
}
DFWINDOW DfMomentaryMessage(char *msg)
{
DFWINDOW wnd = DfDfCreateWindow(
DF_TEXTBOX,
NULL,
-1,-1,DfMsgHeight(msg)+2,DfMsgWidth(msg)+2,
NULL,NULL,NULL,
DF_HASBORDER | DF_SHADOW | DF_SAVESELF);
DfSendMessage(wnd, DFM_SETTEXT, (DF_PARAM) msg, 0);
DfWindowClientColor(wnd, WHITE, GREEN);
DfWindowFrameColor(wnd, WHITE, GREEN);
DfSendMessage (wnd, DFM_SHOW_WINDOW, 0, 0);
return wnd;
}
int DfMsgHeight(char *msg)
{
int h = 1;
while ((msg = strchr(msg, '\n')) != NULL)
{
h++;
msg++;
}
return min(h, DfGetScreenHeight ()-10);
}
int DfMsgWidth(char *msg)
{
int w = 0;
char *cp = msg;
while ((cp = strchr(msg, '\n')) != NULL)
{
w = max(w, (int) (cp-msg));
msg = cp+1;
}
return min(max((int)strlen(msg), (int)w), DfGetScreenWidth()-10);
}
/* EOF */
rosapps/dflat32/normal.c
-1088
View File
File diff suppressed because it is too large Load Diff
rosapps/dflat32/pictbox.c
-284
View File
@@ -1,284 +0,0 @@
/* -------------- pictbox.c -------------- */
#include "dflat.h"
typedef struct {
enum DfVectTypes vt;
DFRECT rc;
} VECT;
unsigned char CharInWnd[] = "ijڿÙÀÅôÁÂ";
unsigned char VectCvt[3][11][2][4] = {
{ /* --- first character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"ÚÃÀ"}},
{{"Ú¿"}, {"³³³"}},
{{"ÚÂÂ"}, {"ÚÃÃ"}},
{{"¿¿¿"}, {"¿¿¿"}},
{{"ÙÙÙ"}, {"ÙÙÙ"}},
{{"ÀÁÁ"}, {"ÃÃÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÅÅ"}, {"ÃÃÃ"}},
{{"´´´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÁÁÁ"}},
{{"ÂÂÂ"}, {"ÂÅÅ"}} },
{ /* --- middle character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"ÂÅÁ"}},
{{"ÃÅ´"}, {"³³³"}},
{{"ÚÚÚ"}, {"ÚÚÚ"}},
{{"¿¿¿"}, {"¿¿¿"}},
{{"ÙÙÙ"}, {"ÙÙÙ"}},
{{"ÀÀÀ"}, {"ÀÀÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÃÃ"}, {"ÃÃÃ"}},
{{"ÅÅ´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÅÅÁ"}},
{{"ÂÂÂ"}, {"ÂÂÂ"}} },
{ /* --- last character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"¿´Ù"}},
{{"ÀÁÙ"}, {"³³³"}},
{{"ÚÚÚ"}, {"ÚÚÚ"}},
{{"¿"}, {"¿´´"}},
{{"ÁÁÙ"}, {"´´Ù"}},
{{"ÀÀÀ"}, {"ÀÀÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÃÃ"}, {"ÃÃÃ"}},
{{"ÅÅ´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÅÅÁ"}},
{{"ÂÂÂ"}, {"ÂÂÂ"}} }
};
/* -- compute whether character is first, middle, or last -- */
static int FindVector(DFWINDOW wnd, DFRECT rc, int x, int y)
{
DFRECT rcc;
VECT *vc = wnd->VectorList;
int i, coll = -1;
for (i = 0; i < wnd->VectorCount; i++) {
if ((vc+i)->vt == DF_VECTOR) {
rcc = (vc+i)->rc;
/* --- skip the colliding vector --- */
if (rcc.lf == rc.lf && rcc.rt == rc.rt &&
rcc.tp == rc.tp && rc.bt == rcc.bt)
continue;
if (rcc.tp == rcc.bt) {
/* ---- horizontal vector,
see if character is in it --- */
if (rc.lf+x >= rcc.lf && rc.lf+x <= rcc.rt &&
rc.tp+y == rcc.tp) {
/* --- it is --- */
if (rc.lf+x == rcc.lf)
coll = 0;
else if (rc.lf+x == rcc.rt)
coll = 2;
else
coll = 1;
}
}
else {
/* ---- vertical vector,
see if character is in it --- */
if (rc.tp+y >= rcc.tp && rc.tp+y <= rcc.bt &&
rc.lf+x == rcc.lf) {
/* --- it is --- */
if (rc.tp+y == rcc.tp)
coll = 0;
else if (rc.tp+y == rcc.bt)
coll = 2;
else
coll = 1;
}
}
}
}
return coll;
}
static void PaintVector(DFWINDOW wnd, DFRECT rc)
{
int i, xi, yi, len;
unsigned int ch, nc;
unsigned int newch;
static int cw, fml, vertvect, coll;
if (rc.rt == rc.lf) {
/* ------ vertical vector ------- */
nc = '³';
vertvect = 1;
len = rc.bt-rc.tp+1;
}
else {
/* ------ horizontal vector ------- */
nc = 'Ä';
vertvect = 0;
len = rc.rt-rc.lf+1;
}
for (i = 0; i < len; i++) {
newch = nc;
xi = yi = 0;
if (vertvect)
yi = i;
else
xi = i;
ch = DfVideoChar(DfGetClientLeft(wnd)+rc.lf+xi,
DfGetClientTop(wnd)+rc.tp+yi);
for (cw = 0; cw < sizeof(CharInWnd); cw++) {
if (ch == CharInWnd[cw]) {
/* ---- hit another vector character ---- */
if ((coll=FindVector(wnd, rc, xi, yi)) != -1) {
/* compute first/middle/last subscript */
if (i == len-1)
fml = 2;
else if (i == 0)
fml = 0;
else
fml = 1;
newch = VectCvt[coll][cw][vertvect][fml];
}
}
}
DfPutWindowChar(wnd, newch, rc.lf+xi, rc.tp+yi);
}
}
static void PaintBar(DFWINDOW wnd, DFRECT rc, enum DfVectTypes vt)
{
int i, vertbar, len;
unsigned int tys[] = {219, 178, 177, 176};
/* unsigned int tys[] = {'Û', '²', '±', '°'};
*/
unsigned int nc = tys[vt-1];
if (rc.rt == rc.lf) {
/* ------ vertical bar ------- */
vertbar = 1;
len = rc.bt-rc.tp+1;
}
else {
/* ------ horizontal bar ------- */
vertbar = 0;
len = rc.rt-rc.lf+1;
}
for (i = 0; i < len; i++) {
int xi = 0, yi = 0;
if (vertbar)
yi = i;
else
xi = i;
DfPutWindowChar(wnd, nc, rc.lf+xi, rc.tp+yi);
}
}
static void PaintMsg(DFWINDOW wnd)
{
int i;
VECT *vc = wnd->VectorList;
for (i = 0; i < wnd->VectorCount; i++) {
if (vc->vt == DF_VECTOR)
PaintVector(wnd, vc->rc);
else
PaintBar(wnd, vc->rc, vc->vt);
vc++;
}
}
static void DrawVectorMsg(DFWINDOW wnd,DF_PARAM p1,enum DfVectTypes vt)
{
if (p1) {
VECT vc;
wnd->VectorList = DfRealloc(wnd->VectorList,
sizeof(VECT) * (wnd->VectorCount + 1));
vc.vt = vt;
vc.rc = *(DFRECT *)p1;
*(((VECT *)(wnd->VectorList))+wnd->VectorCount)=vc;
wnd->VectorCount++;
}
}
static void DrawBoxMsg(DFWINDOW wnd, DF_PARAM p1)
{
if (p1) {
DFRECT rc = *(DFRECT *)p1;
rc.bt = rc.tp;
DfSendMessage(wnd, DFM_DRAWVECTOR, (DF_PARAM) &rc, TRUE);
rc = *(DFRECT *)p1;
rc.lf = rc.rt;
DfSendMessage(wnd, DFM_DRAWVECTOR, (DF_PARAM) &rc, FALSE);
rc = *(DFRECT *)p1;
rc.tp = rc.bt;
DfSendMessage(wnd, DFM_DRAWVECTOR, (DF_PARAM) &rc, TRUE);
rc = *(DFRECT *)p1;
rc.rt = rc.lf;
DfSendMessage(wnd, DFM_DRAWVECTOR, (DF_PARAM) &rc, FALSE);
}
}
int DfPictureProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_PAINT:
DfBaseWndProc(DF_PICTUREBOX, wnd, msg, p1, p2);
PaintMsg(wnd);
return TRUE;
case DFM_DRAWVECTOR:
DrawVectorMsg(wnd, p1, DF_VECTOR);
return TRUE;
case DFM_DRAWBOX:
DrawBoxMsg(wnd, p1);
return TRUE;
case DFM_DRAWBAR:
DrawVectorMsg(wnd, p1, (enum DfVectTypes)p2);
return TRUE;
case DFM_CLOSE_WINDOW:
if (wnd->VectorList != NULL)
free(wnd->VectorList);
break;
default:
break;
}
return DfBaseWndProc(DF_PICTUREBOX, wnd, msg, p1, p2);
}
static DFRECT PictureRect(int x, int y, int len, int hv)
{
DFRECT rc;
rc.lf = rc.rt = x;
rc.tp = rc.bt = y;
if (hv)
/* ---- horizontal vector ---- */
rc.rt += len-1;
else
/* ---- vertical vector ---- */
rc.bt += len-1;
return rc;
}
void DfDrawVector(DFWINDOW wnd, int x, int y, int len, int hv)
{
DFRECT rc = PictureRect(x,y,len,hv);
DfSendMessage(wnd, DFM_DRAWVECTOR, (DF_PARAM) &rc, 0);
}
void DfDrawBox(DFWINDOW wnd, int x, int y, int ht, int wd)
{
DFRECT rc;
rc.lf = x;
rc.tp = y;
rc.rt = x+wd-1;
rc.bt = y+ht-1;
DfSendMessage(wnd, DFM_DRAWBOX, (DF_PARAM) &rc, 0);
}
void DfDrawBar(DFWINDOW wnd,enum DfVectTypes vt,
int x,int y,int len,int hv)
{
DFRECT rc = PictureRect(x,y,len,hv);
DfSendMessage(wnd, DFM_DRAWBAR, (DF_PARAM) &rc, (DF_PARAM) vt);
}
/* EOF */
rosapps/dflat32/popdown.c
-395
View File
@@ -1,395 +0,0 @@
/* ------------- popdown.c ----------- */
#include "dflat.h"
static int SelectionWidth(struct DfPopDown *);
static int py = -1;
/* ------------ DFM_CREATE_WINDOW Message ------------- */
static int CreateWindowMsg(DFWINDOW wnd)
{
int rtn, adj;
DfClearAttribute (wnd,
DF_HASTITLEBAR |
DF_VSCROLLBAR |
DF_MOVEABLE |
DF_SIZEABLE |
DF_HSCROLLBAR);
/* ------ adjust to keep popdown on screen ----- */
adj = DfGetScreenHeight()-1-wnd->rc.bt;
if (adj < 0)
{
wnd->rc.tp += adj;
wnd->rc.bt += adj;
}
adj = DfGetScreenWidth()-1-wnd->rc.rt;
if (adj < 0)
{
wnd->rc.lf += adj;
wnd->rc.rt += adj;
}
rtn = DfBaseWndProc(DF_POPDOWNMENU, wnd, DFM_CREATE_WINDOW, 0, 0);
DfSendMessage(wnd, DFM_CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_CAPTURE_KEYBOARD, 0, 0);
DfSendMessage(NULL, DFM_SAVE_CURSOR, 0, 0);
DfSendMessage(NULL, DFM_HIDE_CURSOR, 0, 0);
wnd->oldFocus = DfInFocus;
DfInFocus = wnd;
return rtn;
}
/* --------- DFM_LEFT_BUTTON Message --------- */
static void LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int my = (int) p2 - DfGetTop(wnd);
if (DfInsideRect(p1, p2, DfClientRect(wnd))) {
if (my != py) {
DfSendMessage(wnd, DFM_LB_SELECTION,
(DF_PARAM) wnd->wtop+my-1, TRUE);
py = my;
}
}
else if ((int)p2 == DfGetTop(DfGetParent(wnd)))
if (DfGetClass(DfGetParent(wnd)) == DF_MENUBAR)
DfPostMessage(DfGetParent(wnd), DFM_LEFT_BUTTON, p1, p2);
}
/* -------- BUTTON_RELEASED Message -------- */
static BOOL ButtonReleasedMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
py = -1;
if (DfInsideRect((int)p1, (int)p2, DfClientRect(wnd))) {
int sel = (int)p2 - DfGetClientTop(wnd);
if (*DfTextLine(wnd, sel) != DF_LINE)
DfSendMessage(wnd, DFM_LB_CHOOSE, wnd->selection, 0);
}
else {
DFWINDOW pwnd = DfGetParent(wnd);
if (DfGetClass(pwnd) == DF_MENUBAR && (int)p2==DfGetTop(pwnd))
return FALSE;
if ((int)p1 == DfGetLeft(pwnd)+2)
return FALSE;
DfSendMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
return TRUE;
}
return FALSE;
}
/* --------- DFM_PAINT Message -------- */
static void PaintMsg(DFWINDOW wnd)
{
int wd;
char sep[80], *cp = sep;
char sel[80];
struct DfPopDown *ActivePopDown;
struct DfPopDown *pd1;
ActivePopDown = pd1 = wnd->mnu->Selections;
wd = DfMenuWidth(ActivePopDown)-2;
while (wd--)
*cp++ = DF_LINE;
*cp = '\0';
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
wnd->selection = wnd->mnu->Selection;
while (pd1->SelectionTitle != NULL) {
if (*pd1->SelectionTitle == DF_LINE)
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM) sep, 0);
else {
int len;
memset(sel, '\0', sizeof sel);
if (pd1->Attrib & DF_INACTIVE)
/* ------ inactive menu selection ----- */
sprintf(sel, "%c%c%c",
DF_CHANGECOLOR,
wnd->WindowColors [DF_HILITE_COLOR] [DF_FG]|0x80,
wnd->WindowColors [DF_STD_COLOR] [DF_BG]|0x80);
strcat(sel, " ");
if (pd1->Attrib & DF_CHECKED)
/* ---- paint the toggle checkmark ---- */
sel[strlen(sel)-1] = DF_CHECKMARK;
len=DfCopyCommand(sel+strlen(sel),pd1->SelectionTitle,
pd1->Attrib & DF_INACTIVE,
wnd->WindowColors [DF_STD_COLOR] [DF_BG]);
if (pd1->Accelerator) {
/* ---- paint accelerator key ---- */
int i;
int wd1 = 2+SelectionWidth(ActivePopDown) -
strlen(pd1->SelectionTitle);
for (i = 0; keys[i].keylabel; i++) {
if (keys[i].keycode == pd1->Accelerator) {
while (wd1--)
strcat(sel, " ");
sprintf(sel+strlen(sel), "[%s]",
keys[i].keylabel);
break;
}
}
}
if (pd1->Attrib & DF_CASCADED) {
/* ---- paint cascaded menu token ---- */
if (!pd1->Accelerator) {
wd = DfMenuWidth(ActivePopDown)-len+1;
while (wd--)
strcat(sel, " ");
}
sel[strlen(sel)-1] = DF_CASCADEPOINTER;
}
else
strcat(sel, " ");
strcat(sel, " ");
sel[strlen(sel)-1] = DF_RESETCOLOR;
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM) sel, 0);
}
pd1++;
}
}
/* ---------- DFM_BORDER Message ----------- */
static int BorderMsg(DFWINDOW wnd)
{
int i, rtn = TRUE;
DFWINDOW currFocus;
if (wnd->mnu != NULL) {
currFocus = DfInFocus;
DfInFocus = NULL;
rtn = DfBaseWndProc(DF_POPDOWNMENU, wnd, DFM_BORDER, 0, 0);
DfInFocus = currFocus;
for (i = 0; i < DfClientHeight(wnd); i++) {
if (*DfTextLine(wnd, i) == DF_LINE) {
DfWPutch(wnd, DF_LEDGE, 0, i+1);
DfWPutch(wnd, DF_REDGE, DfWindowWidth(wnd)-1, i+1);
}
}
}
return rtn;
}
/* -------------- DFM_LB_CHOOSE Message -------------- */
static void LBChooseMsg(DFWINDOW wnd, DF_PARAM p1)
{
struct DfPopDown *ActivePopDown = wnd->mnu->Selections;
if (ActivePopDown != NULL) {
int *attr = &(ActivePopDown+(int)p1)->Attrib;
wnd->mnu->Selection = (int)p1;
if (!(*attr & DF_INACTIVE)) {
if (*attr & DF_TOGGLE)
*attr ^= DF_CHECKED;
DfPostMessage(DfGetParent(wnd), DFM_COMMAND,
(ActivePopDown+(int)p1)->ActionId, p1);
}
else
DfBeep();
}
}
/* ---------- DFM_KEYBOARD Message --------- */
static BOOL KeyboardMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
struct DfPopDown *ActivePopDown = wnd->mnu->Selections;
if (wnd->mnu != NULL)
{
if (ActivePopDown != NULL)
{
int c = (int)p1;
int sel = 0;
int a;
struct DfPopDown *pd = ActivePopDown;
if ((c & DF_OFFSET) == 0)
c = tolower(c);
a = DfAltConvert(c);
while (pd->SelectionTitle != NULL)
{
char *cp = strchr(pd->SelectionTitle, DF_SHORTCUTCHAR);
/* FIXME: DfAltConvert bug !! */
if ((cp && tolower(*(cp+1)) == c) ||
// (a && tolower(*(cp+1)) == a) ||
pd->Accelerator == c)
{
DfPostMessage(wnd, DFM_LB_SELECTION, sel, 0);
DfPostMessage(wnd, DFM_LB_CHOOSE, sel, TRUE);
return TRUE;
}
pd++;
sel++;
}
}
}
switch ((int)p1)
{
case DF_F1:
if (ActivePopDown == NULL)
DfSendMessage(DfGetParent(wnd), DFM_KEYBOARD, p1, p2);
else
DfDisplayHelp(wnd,
(ActivePopDown+wnd->selection)->help);
return TRUE;
case DF_ESC:
DfSendMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
return TRUE;
case DF_FWD:
case DF_BS:
if (DfGetClass(DfGetParent(wnd)) == DF_MENUBAR)
DfPostMessage(DfGetParent(wnd), DFM_KEYBOARD, p1, p2);
return TRUE;
case DF_UP:
if (wnd->selection == 0) {
if (wnd->wlines == DfClientHeight(wnd)) {
DfPostMessage(wnd, DFM_LB_SELECTION,
wnd->wlines-1, FALSE);
return TRUE;
}
}
break;
case DF_DN:
if (wnd->selection == wnd->wlines-1) {
if (wnd->wlines == DfClientHeight(wnd)) {
DfPostMessage(wnd, DFM_LB_SELECTION, 0, FALSE);
return TRUE;
}
}
break;
case DF_HOME:
case DF_END:
case '\r':
break;
default:
return TRUE;
}
return FALSE;
}
/* ----------- DFM_CLOSE_WINDOW Message ---------- */
static int CloseWindowMsg(DFWINDOW wnd)
{
int rtn;
DFWINDOW pwnd = DfGetParent(wnd);
DfSendMessage(wnd, DFM_RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_RELEASE_KEYBOARD, 0, 0);
DfSendMessage(NULL, DFM_RESTORE_CURSOR, 0, 0);
DfInFocus = wnd->oldFocus;
rtn = DfBaseWndProc(DF_POPDOWNMENU, wnd, DFM_CLOSE_WINDOW, 0, 0);
DfSendMessage(pwnd, DFM_CLOSE_POPDOWN, 0, 0);
return rtn;
}
/* - Window processing module for DF_POPDOWNMENU window class - */
int DfPopDownProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
return CreateWindowMsg(wnd);
case DFM_LEFT_BUTTON:
LeftButtonMsg(wnd, p1, p2);
return FALSE;
case DOUBLE_CLICK:
return TRUE;
case DFM_LB_SELECTION:
if (*DfTextLine(wnd, (int)p1) == DF_LINE)
return TRUE;
wnd->mnu->Selection = (int)p1;
break;
case DFM_BUTTON_RELEASED:
if (ButtonReleasedMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_BUILD_SELECTIONS:
wnd->mnu = (void *) p1;
wnd->selection = wnd->mnu->Selection;
break;
case DFM_PAINT:
if (wnd->mnu == NULL)
return TRUE;
PaintMsg(wnd);
break;
case DFM_BORDER:
return BorderMsg(wnd);
case DFM_LB_CHOOSE:
LBChooseMsg(wnd, p1);
return TRUE;
case DFM_KEYBOARD:
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_CLOSE_WINDOW:
return CloseWindowMsg(wnd);
default:
break;
}
return DfBaseWndProc(DF_POPDOWNMENU, wnd, msg, p1, p2);
}
/* --------- compute menu height -------- */
int DfMenuHeight(struct DfPopDown *pd)
{
int ht = 0;
while (pd[ht].SelectionTitle != NULL)
ht++;
return ht+2;
}
/* --------- compute menu width -------- */
int DfMenuWidth(struct DfPopDown *pd)
{
int wd = 0, i;
int len = 0;
wd = SelectionWidth(pd);
while (pd->SelectionTitle != NULL) {
if (pd->Accelerator) {
for (i = 0; keys[i].keylabel; i++)
if (keys[i].keycode == pd->Accelerator) {
len = max(len, (int)(2+strlen(keys[i].keylabel)));
break;
}
}
if (pd->Attrib & DF_CASCADED)
len = max(len, 2);
pd++;
}
return wd+5+len;
}
/* ---- compute the maximum selection width in a menu ---- */
static int SelectionWidth(struct DfPopDown *pd)
{
int wd = 0;
while (pd->SelectionTitle != NULL) {
int len = strlen(pd->SelectionTitle)-1;
wd = max(wd, len);
pd++;
}
return wd;
}
/* ----- copy a menu command to a display buffer ---- */
int DfCopyCommand(char *dest, char *src, int skipcolor, int bg)
{
char *d = dest;
while (*src && *src != '\n') {
if (*src == DF_SHORTCUTCHAR) {
src++;
if (!skipcolor) {
*dest++ = DF_CHANGECOLOR;
*dest++ = DfCfg.clr[DF_POPDOWNMENU]
[DF_HILITE_COLOR] [DF_BG] | 0x80;
*dest++ = bg | 0x80;
*dest++ = *src++;
*dest++ = DF_RESETCOLOR;
}
}
else
*dest++ = *src++;
}
return (int) (dest - d);
}
/* EOF */
rosapps/dflat32/radio.c
-116
View File
@@ -1,116 +0,0 @@
/* -------- radio.c -------- */
#include "dflat.h"
static DF_CTLWINDOW *rct[DF_MAXRADIOS];
int DfRadioButtonProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DF_DBOX *db = DfGetParent(wnd)->extension;
DF_CTLWINDOW *ct = DfGetControl(wnd);
if (ct != NULL) {
switch (msg) {
case DFM_SETFOCUS:
if (!(int)p1)
DfSendMessage(NULL, DFM_HIDE_CURSOR, 0, 0);
case DFM_MOVE:
rtn = DfBaseWndProc(DF_RADIOBUTTON,wnd,msg,p1,p2);
DfSetFocusCursor(wnd);
return rtn;
case DFM_PAINT: {
char rb[] = "( )";
if (ct->setting)
rb[1] = 7;
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM) rb, 0);
DfSetFocusCursor(wnd);
break;
}
case DFM_KEYBOARD:
if ((int)p1 != ' ')
break;
case DFM_LEFT_BUTTON:
DfSetRadioButton(db, ct);
break;
default:
break;
}
}
return DfBaseWndProc(DF_RADIOBUTTON, wnd, msg, p1, p2);
}
static BOOL Setting = TRUE;
void DfSetRadioButton(DF_DBOX *db, DF_CTLWINDOW *ct)
{
Setting = FALSE;
DfPushRadioButton(db, ct->command);
Setting = TRUE;
}
void DfPushRadioButton(DF_DBOX *db, enum DfCommands cmd)
{
DF_CTLWINDOW *ctt = db->ctl;
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, DF_RADIOBUTTON);
int i;
if (ct == NULL)
return;
/* --- clear all the radio buttons
in this group on the dialog box --- */
/* -------- build a table of all radio buttons at the
same x vector ---------- */
for (i = 0; i < DF_MAXRADIOS; i++)
rct[i] = NULL;
while (ctt->class) {
if (ctt->class == DF_RADIOBUTTON)
if (ct->dwnd.x == ctt->dwnd.x)
rct[ctt->dwnd.y] = ctt;
ctt++;
}
/* ----- find the start of the radiobutton group ---- */
i = ct->dwnd.y;
while (i >= 0 && rct[i] != NULL)
--i;
/* ---- ignore everthing before the group ------ */
while (i >= 0)
rct[i--] = NULL;
/* ----- find the end of the radiobutton group ---- */
i = ct->dwnd.y;
while (i < DF_MAXRADIOS && rct[i] != NULL)
i++;
/* ---- ignore everthing past the group ------ */
while (i < DF_MAXRADIOS)
rct[i++] = NULL;
for (i = 0; i < DF_MAXRADIOS; i++) {
if (rct[i] != NULL) {
int wason = rct[i]->setting;
rct[i]->setting = DF_OFF;
if (Setting)
rct[i]->isetting = DF_OFF;
if (wason)
DfSendMessage(rct[i]->wnd, DFM_PAINT, 0, 0);
}
}
/* ----- set the specified radio button on ----- */
ct->setting = DF_ON;
if (Setting)
ct->isetting = DF_ON;
DfSendMessage(ct->wnd, DFM_PAINT, 0, 0);
}
BOOL DfRadioButtonSetting(DF_DBOX *db, enum DfCommands cmd)
{
DF_CTLWINDOW *ct = DfFindCommand(db, cmd, DF_RADIOBUTTON);
if (ct != NULL)
return (ct->setting == DF_ON);
return FALSE;
}
/* EOF */
rosapps/dflat32/readme.doc
-104
View File
@@ -1,104 +0,0 @@
February, 1995
D-Flat Version 20
The source files in the DFLAT archive constitute the D-Flat windowing
system. This is public domain code. You may use it in your
applications without restriction. You may freely distribute source
code. It would be nice if you would give credit to Dr. Dobb's Journal
as the original publisher of the source code.
The software build procedure makes a program named memopad.exe. It is
a multiple-document notepad program. Observe the #define VERSION
statement in dflat.h. The version number should correspond with the
nn in the DFLTnn.ZIP filename that you downloaded. Check the uploads
periodically to see if there is a more recent version available.
For other examples download the Quincy and IMail applications. The
IMail application uses the DFWRAP C++ class wrapper.
My CompuServe ID is 71101,1262. I monitor the DDJFORUM every day and
prefer that you discuss D-Flat there so that every one can benefit
from your comments.
========== Borland C++ 3.1 or 4.0 ============
To build with the Borland C++ 3.1 or 4.x make utility:
Set the DRIVE macro in the makefile to the drive and directory
where your compiler is installed.
Type this command:
C>make /fmakefile.bcc
=======================================================
D-Flat uses Compressed help files. It uses an adaptation of the
Huffman compression programs from the Dr. Dobb's Journal C
Programming Column of early 1991.
The makefile compresses the help file with these commands:
C>huffc memopad.txt memopad.hlp
C>fixhelp memopad.hlp
Both of the programs must be run in order for the help system to work
properly. Note that .hlp files from previous versions are not
compatible with versions 18 and higher. The .txt files are, however,
so you can use the huffc and fixhelp programs to rebuild the .hlp
file.
===============================================
This is version 20. It incorporates these changes:
1. Dialog boxes displayed twice upon open.
2. The intended #define of FA_DIREC in direct.c was inadvertently
released with #include as the preprocessing directive.
3. Changed status bar to display time after screen takeover.
4. Statbar incorrectly captured clock with every MOVE message. Caused
hangups when compiled with BCC 3.1 and user moved application window.
5. Modeless dialog boxes did not redisplay properly when there was
more than one window open.
6. Added ButtonEnabled and CheckBoxEnabled functions.
7. Changed LB_SETSELECTION message to accept -1 to turn off
selections in the listbox.
8. Moved processing of ID_SEARCH, ID_SEARCHNEXT, ID_REPLACE, ID_CUT,
ID_COPY, ID_PASTE, ID_DELETETEXT, ID_UNDO, and ID_CLEAR to editbox.c,
relieving applications of these common processes.
9. Now allow marking blocks, cut, copy, paste, etc. on single line
editboxes.
10. Added SetProtect function.
11. The Window menu listed doc windows that were not visible.
12. Changed class identifiers to Class.
13. ClearWindow did not work properly for a window with a status bar
and menu bar and no title bar.
14. Added the void *wrapper field to the window structure to support
a C++ class wrapper around the D-Flat C function library.
15. Sizeable windows with borders now display a small token in the
lower right corner to indicate that they are sizeable.
===============================================
Buy the DDJ CD-ROM from Miller-Freeman to get the complete D-Flat
narrative from May '91 to October '92. These columns describe the
development of D-Flat and serve as a tutorial on its use. The D-Flat
reference manual is DFLAT.DOC.
rosapps/dflat32/readme.txt
-31
View File
@@ -1,31 +0,0 @@
How do I build D-Flat/32?
At present D-Flat/32 does not exist as a separate dll. But you can build an
example progam.
To build the example program (actually this is the FreeDOS Editor) you only
have to run 'make dflat32' from the rosapps base directory. The example
program is 'dflat32\edit.exe'.
What must be changed in D-Flat/32?
Things that have to be fixed (incomplete list):
- key handling (replace dos keycodes by win32 console keycodes)
- message queue should become a double linked list (it's an array now)
- fix short dos filename buffers
- add code to register external window classes
- implement recognition of current console screen size (done)
- fix remaining bugs
- update documentation
Does it run on ReactOS?
The debugging version doesn't run on ReactOS yet. I haven't tried a version
without debugging code but I doubt it will run. I know that three console
functions are not implemented in ReactOS yet. They will be implemented soon.
If you have a question, drop me a note.
Eric Kohl [email protected]
rosapps/dflat32/rect.c
-106
View File
@@ -1,106 +0,0 @@
/* ------------- rect.c --------------- */
#include "dflat.h"
/* --- Produce the vector end points produced by the overlap
of two other vectors --- */
static void subVector(int *v1, int *v2,
int t1, int t2, int o1, int o2)
{
*v1 = *v2 = -1;
if (DfWithin(o1, t1, t2)) {
*v1 = o1;
if (DfWithin(o2, t1, t2))
*v2 = o2;
else
*v2 = t2;
}
else if (DfWithin(o2, t1, t2)) {
*v2 = o2;
if (DfWithin(o1, t1, t2))
*v1 = o1;
else
*v1 = t1;
}
else if (DfWithin(t1, o1, o2)) {
*v1 = t1;
if (DfWithin(t2, o1, o2))
*v2 = t2;
else
*v2 = o2;
}
else if (DfWithin(t2, o1, o2)) {
*v2 = t2;
if (DfWithin(t1, o1, o2))
*v1 = t1;
else
*v1 = o1;
}
}
/* --- Return the rectangle produced by the overlap
of two other rectangles ---- */
DFRECT DfSubRectangle(DFRECT r1, DFRECT r2)
{
DFRECT r = {0,0,0,0};
subVector((int *) &DfRectLeft(r), (int *) &DfRectRight(r),
DfRectLeft(r1), DfRectRight(r1),
DfRectLeft(r2), DfRectRight(r2));
subVector((int *) &DfRectTop(r), (int *) &DfRectBottom(r),
DfRectTop(r1), DfRectBottom(r1),
DfRectTop(r2), DfRectBottom(r2));
if (DfRectRight(r) == -1 || DfRectTop(r) == -1)
DfRectRight(r) =
DfRectLeft(r) =
DfRectTop(r) =
DfRectBottom(r) = 0;
return r;
}
/* ------- return the client rectangle of a window ------ */
DFRECT DfClientRect(void *wnd)
{
DFRECT rc;
if (wnd == NULL)
{
DfRectLeft(rc) = 1; // DfGetClientLeft((DFWINDOW)wnd);
DfRectTop(rc) = 2; // DfGetClientTop((DFWINDOW)wnd);
DfRectRight(rc) = DfGetScreenWidth () - 2; // DfGetClientRight((DFWINDOW)wnd);
DfRectBottom(rc) = DfGetScreenHeight () - 2; // DfGetClientBottom((DFWINDOW)wnd);
return rc;
}
DfRectLeft(rc) = DfGetClientLeft((DFWINDOW)wnd);
DfRectTop(rc) = DfGetClientTop((DFWINDOW)wnd);
DfRectRight(rc) = DfGetClientRight((DFWINDOW)wnd);
DfRectBottom(rc) = DfGetClientBottom((DFWINDOW)wnd);
return rc;
}
/* ----- return the rectangle relative to
its window's screen position -------- */
DFRECT DfRelativeWindowRect(void *wnd, DFRECT rc)
{
DfRectLeft(rc) -= DfGetLeft((DFWINDOW)wnd);
DfRectRight(rc) -= DfGetLeft((DFWINDOW)wnd);
DfRectTop(rc) -= DfGetTop((DFWINDOW)wnd);
DfRectBottom(rc) -= DfGetTop((DFWINDOW)wnd);
return rc;
}
/* ----- clip a rectangle to the parents of the window ----- */
DFRECT DfClipRectangle(void *wnd, DFRECT rc)
{
DFRECT sr;
DfRectLeft(sr) = DfRectTop(sr) = 0;
DfRectRight(sr) = DfGetScreenWidth()-1;
DfRectBottom(sr) = DfGetScreenHeight()-1;
if (!DfTestAttribute((DFWINDOW)wnd, DF_NOCLIP))
while ((wnd = DfGetParent((DFWINDOW)wnd)) != NULL)
rc = DfSubRectangle(rc, DfClientRect(wnd));
return DfSubRectangle(rc, sr);
}
/* EOF */
rosapps/dflat32/rect.h
-24
View File
@@ -1,24 +0,0 @@
/* ----------- rect.h ------------ */
#ifndef RECT_H
#define RECT_H
typedef struct {
int lf,tp,rt,bt;
} DFRECT;
#define DfWithin(p,v1,v2) ((p)>=(v1)&&(p)<=(v2))
#define DfRectTop(r) (r.tp)
#define DfRectBottom(r) (r.bt)
#define DfRectLeft(r) (r.lf)
#define DfRectRight(r) (r.rt)
#define DfInsideRect(x,y,r) (DfWithin((x),DfRectLeft(r),DfRectRight(r))\
&& \
DfWithin((y),DfRectTop(r),DfRectBottom(r)))
#define DfValidRect(r) (DfRectRight(r) || DfRectLeft(r) || \
DfRectTop(r) || DfRectBottom(r))
#define DfRectWidth(r) (DfRectRight(r)-DfRectLeft(r)+1)
#define DfRectHeight(r) (DfRectBottom(r)-DfRectTop(r)+1)
DFRECT DfSubRectangle(DFRECT, DFRECT);
DFRECT DfClientRect(void *);
DFRECT DfRelativeWindowRect(void *, DFRECT);
DFRECT DfClipRectangle(void *, DFRECT);
#endif
rosapps/dflat32/search.c
-164
View File
@@ -1,164 +0,0 @@
/* ---------------- search.c ------------- */
#include "dflat.h"
extern DF_DBOX SearchTextDB;
extern DF_DBOX ReplaceTextDB;
static int CheckCase = TRUE;
static int Replacing = FALSE;
/* - case-insensitive, white-space-normalized char compare - */
static BOOL SearchCmp(int a, int b)
{
if (b == '\n')
b = ' ';
if (CheckCase)
return a != b;
return tolower(a) != tolower(b);
}
/* ----- replace a matching block of text ----- */
static void replacetext(DFWINDOW wnd, char *cp1, DF_DBOX *db)
{
char *cr = DfGetEditBoxText(db, DF_ID_REPLACEWITH);
char *cp = DfGetEditBoxText(db, DF_ID_SEARCHFOR);
int oldlen = strlen(cp); /* length of text being replaced */
int newlen = strlen(cr); /* length of replacing text */
int dif;
if (oldlen < newlen) {
/* ---- new text expands text size ---- */
dif = newlen-oldlen;
if (wnd->textlen < strlen(wnd->text)+dif) {
/* ---- need to reallocate the text buffer ---- */
int offset = (int)((int)cp1-(int)wnd->text);
wnd->textlen += dif;
wnd->text = DfRealloc(wnd->text, wnd->textlen+2);
cp1 = wnd->text + offset;
}
memmove(cp1+dif, cp1, strlen(cp1)+1);
}
else if (oldlen > newlen) {
/* ---- new text collapses text size ---- */
dif = oldlen-newlen;
memmove(cp1, cp1+dif, strlen(cp1)+1);
}
strncpy(cp1, cr, newlen);
}
/* ------- search for the occurrance of a string ------- */
static void SearchTextBox(DFWINDOW wnd, int incr)
{
char *s1 , *s2, *cp1;
s1 = s2 = cp1 = NULL;
DF_DBOX *db = Replacing ? &ReplaceTextDB : &SearchTextDB;
char *cp = DfGetEditBoxText(db, DF_ID_SEARCHFOR);
BOOL rpl = TRUE, FoundOne = FALSE;
while (rpl == TRUE && cp != NULL && *cp) {
rpl = Replacing ?
DfCheckBoxSetting(&ReplaceTextDB, DF_ID_REPLACEALL) :
FALSE;
if (DfTextBlockMarked(wnd)) {
DfClearTextBlock(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
/* search for a match starting at DfCursor position */
cp1 = DfCurrChar;
if (incr)
cp1++; /* start past the last hit */
/* --- compare at each character position --- */
while (*cp1) {
s1 = cp;
s2 = cp1;
while (*s1 && *s1 != '\n') {
if (SearchCmp(*s1, *s2))
break;
s1++, s2++;
}
if (*s1 == '\0' || *s1 == '\n')
break;
cp1++;
}
if (s1 != NULL && (*s1 == 0 || *s1 == '\n')) {
/* ----- match at *cp1 ------- */
FoundOne = TRUE;
/* mark a block at beginning of matching text */
wnd->BlkEndLine = DfTextLineNumber(wnd, s2);
wnd->BlkBegLine = DfTextLineNumber(wnd, cp1);
if (wnd->BlkEndLine < wnd->BlkBegLine)
wnd->BlkEndLine = wnd->BlkBegLine;
wnd->BlkEndCol =
(int)((int)s2 - (int)DfTextLine(wnd, wnd->BlkEndLine));
wnd->BlkBegCol =
(int)((int)cp1 - (int)DfTextLine(wnd, wnd->BlkBegLine));
/* position the DfCursor at the matching text */
wnd->CurrCol = wnd->BlkBegCol;
wnd->CurrLine = wnd->BlkBegLine;
wnd->WndRow = wnd->CurrLine - wnd->wtop;
/* align the window scroll to matching text */
if (DfWndCol > DfClientWidth(wnd)-1)
wnd->wleft = wnd->CurrCol;
if (wnd->WndRow > DfClientHeight(wnd)-1) {
wnd->wtop = wnd->CurrLine;
wnd->WndRow = 0;
}
DfSendMessage(wnd, DFM_PAINT, 0, 0);
DfSendMessage(wnd, DFM_KEYBOARD_CURSOR,
DfWndCol, wnd->WndRow);
if (Replacing) {
if (rpl || DfYesNoBox("Replace the text?")) {
replacetext(wnd, cp1, db);
wnd->TextChanged = TRUE;
DfBuildTextPointers(wnd);
}
if (rpl) {
incr = TRUE;
continue;
}
DfClearTextBlock(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
return;
}
break;
}
if (!FoundOne)
DfMessageBox("Search/Replace Text", "No match found");
}
/* ------- search for the occurrance of a string,
replace it with a specified string ------- */
void DfReplaceText(DFWINDOW wnd)
{
Replacing = TRUE;
if (CheckCase)
DfSetCheckBox(&ReplaceTextDB, DF_ID_MATCHCASE);
if (DfDialogBox(NULL, &ReplaceTextDB, TRUE, NULL)) {
CheckCase=DfCheckBoxSetting(&ReplaceTextDB,DF_ID_MATCHCASE);
SearchTextBox(wnd, FALSE);
}
}
/* ------- search for the first occurrance of a string ------ */
void DfSearchText(DFWINDOW wnd)
{
Replacing = FALSE;
if (CheckCase)
DfSetCheckBox(&SearchTextDB, DF_ID_MATCHCASE);
if (DfDialogBox(NULL, &SearchTextDB, TRUE, NULL)) {
CheckCase=DfCheckBoxSetting(&SearchTextDB,DF_ID_MATCHCASE);
SearchTextBox(wnd, FALSE);
}
}
/* ------- search for the next occurrance of a string ------- */
void DfSearchNext(DFWINDOW wnd)
{
SearchTextBox(wnd, TRUE);
}
/* EOF */
rosapps/dflat32/slidebox.c
-114
View File
@@ -1,114 +0,0 @@
/* ------------- slidebox.c ------------ */
#include "dflat.h"
static int (*GenericProc)
(DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2);
static BOOL KeepRunning;
static int SliderLen;
static int Percent;
extern DF_DBOX SliderBoxDB;
static void InsertPercent(char *s)
{
int offset;
char pcc[5];
sprintf(s, "%c%c%c",
DF_CHANGECOLOR,
DfColor[DF_DIALOG][DF_SELECT_COLOR][DF_FG]+0x80,
DfColor[DF_DIALOG][DF_SELECT_COLOR][DF_BG]+0x80);
s += 3;
memset(s, ' ', SliderLen);
*(s+SliderLen) = '\0';
sprintf(pcc, "%d%%", Percent);
strncpy(s+SliderLen/2-1, pcc, strlen(pcc));
offset = (SliderLen * Percent) / 100;
memmove(s+offset+4, s+offset, strlen(s+offset)+1);
sprintf(pcc, "%c%c%c%c",
DF_RESETCOLOR,
DF_CHANGECOLOR,
DfColor[DF_DIALOG][DF_SELECT_COLOR][DF_BG]+0x80,
DfColor[DF_DIALOG][DF_SELECT_COLOR][DF_FG]+0x80);
strncpy(s+offset, pcc, 4);
*(s + strlen(s) - 1) = DF_RESETCOLOR;
}
static int
SliderTextProc (DFWINDOW wnd,DFMESSAGE msg,DF_PARAM p1,DF_PARAM p2)
{
switch (msg)
{
case DFM_PAINT:
Percent = (int)p2;
InsertPercent(DfGetText(wnd) ?
(char*)DfGetText(wnd) : SliderBoxDB.ctl[1].itext);
GenericProc(wnd, DFM_PAINT, 0, 0);
if (Percent >= 100)
DfSendMessage(DfGetParent(wnd),DFM_COMMAND,DF_ID_CANCEL,0);
if (!DfDispatchMessage ())
DfPostMessage(DfGetParent(wnd), DFM_ENDDIALOG, 0, 0);
return KeepRunning;
default:
break;
}
return GenericProc(wnd, msg, p1, p2);
}
static int
SliderBoxProc (DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DFWINDOW twnd;
switch (msg) {
case DFM_CREATE_WINDOW:
DfAddAttribute(wnd, DF_SAVESELF);
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
twnd = SliderBoxDB.ctl[1].wnd;
GenericProc = twnd->wndproc;
twnd->wndproc = SliderTextProc;
KeepRunning = TRUE;
DfSendMessage(wnd, DFM_CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_CAPTURE_KEYBOARD, 0, 0);
return rtn;
case DFM_COMMAND:
if ((int)p2 == 0 && (int)p1 == DF_ID_CANCEL) {
if (Percent >= 100 ||
DfYesNoBox("Terminate process?"))
KeepRunning = FALSE;
else
return TRUE;
}
break;
case DFM_CLOSE_WINDOW:
DfSendMessage(wnd, DFM_RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_RELEASE_KEYBOARD, 0, 0);
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
DFWINDOW DfSliderBox(int len, char *ttl, char *msg)
{
SliderLen = len;
SliderBoxDB.dwnd.title = ttl;
SliderBoxDB.dwnd.w =
max((int)strlen(ttl),max(len, (int)strlen(msg)))+4;
SliderBoxDB.ctl[0].itext = msg;
SliderBoxDB.ctl[0].dwnd.w = strlen(msg);
SliderBoxDB.ctl[0].dwnd.x =
(SliderBoxDB.dwnd.w - strlen(msg)-1) / 2;
SliderBoxDB.ctl[1].itext =
DfRealloc(SliderBoxDB.ctl[1].itext, len+10);
Percent = 0;
InsertPercent(SliderBoxDB.ctl[1].itext);
SliderBoxDB.ctl[1].dwnd.w = len;
SliderBoxDB.ctl[1].dwnd.x = (SliderBoxDB.dwnd.w-len-1)/2;
SliderBoxDB.ctl[2].dwnd.x = (SliderBoxDB.dwnd.w-10)/2;
DfDialogBox(NULL, &SliderBoxDB, FALSE, SliderBoxProc);
return SliderBoxDB.ctl[1].wnd;
}
/* EOF */
rosapps/dflat32/spinbutt.c
-48
View File
@@ -1,48 +0,0 @@
/* ------------ spinbutt.c ------------- */
#include "dflat.h"
int DfSpinButtonProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
DF_CTLWINDOW *ct = DfGetControl(wnd);
if (ct != NULL) {
switch (msg) {
case DFM_CREATE_WINDOW:
wnd->wd -= 2;
wnd->rc.rt -= 2;
break;
case DFM_SETFOCUS:
rtn = DfBaseWndProc(DF_SPINBUTTON, wnd, msg, p1, p2);
if (!(int)p1)
DfSendMessage(NULL, DFM_HIDE_CURSOR, 0, 0);
DfSetFocusCursor(wnd);
return rtn;
case DFM_PAINT:
DfForeground = DfWndBackground(wnd);
DfBackground = DfWndForeground(wnd);
DfWPutch(wnd,DF_UPSCROLLBOX,DfWindowWidth(wnd), 0);
DfWPutch(wnd,DF_DOWNSCROLLBOX,DfWindowWidth(wnd)+1,0);
DfSetFocusCursor(wnd);
break;
case DFM_LEFT_BUTTON:
if (p1 == DfGetRight(wnd) + 1)
DfSendMessage(wnd, DFM_KEYBOARD, DF_UP, 0);
else if (p1 == DfGetRight(wnd) + 2)
DfSendMessage(wnd, DFM_KEYBOARD, DF_DN, 0);
if (wnd != DfInFocus)
DfSendMessage(wnd, DFM_SETFOCUS, TRUE, 0);
return TRUE;
case DFM_LB_SETSELECTION:
rtn = DfBaseWndProc(DF_SPINBUTTON, wnd, msg, p1, p2);
wnd->wtop = (int) p1;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return rtn;
default:
break;
}
}
return DfBaseWndProc(DF_SPINBUTTON, wnd, msg, p1, p2);
}
/* EOF */
rosapps/dflat32/statbar.c
-53
View File
@@ -1,53 +0,0 @@
/* ---------------- statbar.c -------------- */
#include "dflat.h"
int DfStatusBarProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
char *statusbar;
switch (msg) {
case DFM_CREATE_WINDOW:
case DFM_MOVE:
DfSendMessage(wnd, DFM_CAPTURE_CLOCK, 0, 0);
break;
case DFM_KEYBOARD:
if ((int)p1 == DF_CTRL_F4)
return TRUE;
break;
case DFM_PAINT:
if (!DfIsVisible(wnd))
break;
statusbar = DfCalloc(1, DfWindowWidth(wnd)+1);
memset(statusbar, ' ', DfWindowWidth(wnd));
*(statusbar+DfWindowWidth(wnd)) = '\0';
strncpy(statusbar+1, "DF_F1=Help Ý FreeDos Edit", 22);
if (wnd->text) {
int len = min((int)strlen(wnd->text), (int)(DfWindowWidth(wnd)-17));
if (len > 0) {
int off=(DfWindowWidth(wnd)-len)/2;
strncpy(statusbar+off, wnd->text, len);
}
}
if (wnd->TimePosted)
*(statusbar+DfWindowWidth(wnd)-8) = '\0';
DfSetStandardColor(wnd);
DfPutWindowLine(wnd, statusbar, 0, 0);
free(statusbar);
return TRUE;
case DFM_BORDER:
return TRUE;
case DFM_CLOCKTICK:
DfSetStandardColor(wnd);
DfPutWindowLine(wnd, (char *)p1, DfWindowWidth(wnd)-8, 0);
wnd->TimePosted = TRUE;
return TRUE;
case DFM_CLOSE_WINDOW:
DfSendMessage(NULL, DFM_RELEASE_CLOCK, 0, 0);
break;
default:
break;
}
return DfBaseWndProc(DF_STATUSBAR, wnd, msg, p1, p2);
}
/* EOF */
rosapps/dflat32/sysmenu.c
-108
View File
@@ -1,108 +0,0 @@
/* ------------- sysmenu.c ------------ */
#include "dflat.h"
int DfSystemMenuProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int mx, my;
DFWINDOW wnd1;
switch (msg) {
case DFM_CREATE_WINDOW:
wnd->holdmenu = DfActiveMenuBar;
DfActiveMenuBar = &DfSystemMenu;
DfSystemMenu.PullDown[0].Selection = 0;
break;
case DFM_LEFT_BUTTON:
wnd1 = DfGetParent(wnd);
mx = (int) p1 - DfGetLeft(wnd1);
my = (int) p2 - DfGetTop(wnd1);
if (DfHitControlBox(wnd1, mx, my))
return TRUE;
break;
case DFM_LB_CHOOSE:
DfPostMessage(wnd, DFM_CLOSE_WINDOW, 0, 0);
break;
case DOUBLE_CLICK:
if (p2 == DfGetTop(DfGetParent(wnd))) {
DfPostMessage(DfGetParent(wnd), msg, p1, p2);
DfSendMessage(wnd, DFM_CLOSE_WINDOW, TRUE, 0);
}
return TRUE;
case DFM_SHIFT_CHANGED:
return TRUE;
case DFM_CLOSE_WINDOW:
DfActiveMenuBar = wnd->holdmenu;
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
/* ------- Build a system menu -------- */
void DfBuildSystemMenu(DFWINDOW wnd)
{
int lf, tp, ht, wd;
DFWINDOW SystemMenuWnd;
DfSystemMenu.PullDown[0].Selections[6].Accelerator =
(DfGetClass(wnd) == DF_APPLICATION) ? DF_ALT_F4 : DF_CTRL_F4;
lf = DfGetLeft(wnd)+1;
tp = DfGetTop(wnd)+1;
ht = DfMenuHeight(DfSystemMenu.PullDown[0].Selections);
wd = DfMenuWidth(DfSystemMenu.PullDown[0].Selections);
if (lf+wd > DfGetScreenWidth()-1)
lf = (DfGetScreenWidth()-1) - wd;
if (tp+ht > DfGetScreenHeight()-2)
tp = (DfGetScreenHeight()-2) - ht;
SystemMenuWnd = DfDfCreateWindow(DF_POPDOWNMENU, NULL,
lf,tp,ht,wd,NULL,wnd,DfSystemMenuProc, 0);
#ifdef INCLUDE_RESTORE
if (wnd->condition == DF_SRESTORED)
DfDeactivateCommand(&DfSystemMenu, DF_ID_SYSRESTORE);
else
DfActivateCommand(&DfSystemMenu, DF_ID_SYSRESTORE);
#endif
if (DfTestAttribute(wnd, DF_MOVEABLE)
#ifdef INCLUDE_MAXIMIZE
&& wnd->condition != DF_ISMAXIMIZED
#endif
)
DfActivateCommand(&DfSystemMenu, DF_ID_SYSMOVE);
else
DfDeactivateCommand(&DfSystemMenu, DF_ID_SYSMOVE);
if (wnd->condition != DF_SRESTORED ||
DfTestAttribute(wnd, DF_SIZEABLE) == FALSE)
DfDeactivateCommand(&DfSystemMenu, DF_ID_SYSSIZE);
else
DfActivateCommand(&DfSystemMenu, DF_ID_SYSSIZE);
#ifdef INCLUDE_MINIMIZE
if (wnd->condition == DF_ISMINIMIZED ||
DfTestAttribute(wnd, DF_MINMAXBOX) == FALSE)
DfDeactivateCommand(&DfSystemMenu, DF_ID_SYSMINIMIZE);
else
DfActivateCommand(&DfSystemMenu, DF_ID_SYSMINIMIZE);
#endif
#ifdef INCLUDE_MAXIMIZE
if (wnd->condition != DF_SRESTORED ||
DfTestAttribute(wnd, DF_MINMAXBOX) == FALSE)
DfDeactivateCommand(&DfSystemMenu, DF_ID_SYSMAXIMIZE);
else
DfActivateCommand(&DfSystemMenu, DF_ID_SYSMAXIMIZE);
#endif
DfSendMessage(SystemMenuWnd, DFM_BUILD_SELECTIONS,
(DF_PARAM) &DfSystemMenu.PullDown[0], 0);
DfSendMessage(SystemMenuWnd, DFM_SETFOCUS, TRUE, 0);
DfSendMessage(SystemMenuWnd, DFM_SHOW_WINDOW, 0, 0);
}
/* EOF */
rosapps/dflat32/system.h
-99
View File
@@ -1,99 +0,0 @@
/* --------------- system.h -------------- */
#ifndef SYSTEM_H
#define SYSTEM_H
//#if MSC | WATCOM
#include <direct.h>
//#else
//#include <dir.h>
//#endif
#define swap(a,b){int x=a;a=b;b=x;}
/* ------- platform-dependent values ------ */
#define DF_KEYBOARDPORT 0x60
#define DF_FREQUENCY 100
#define DF_COUNT (1193280L / DF_FREQUENCY)
#define DF_ZEROFLAG 0x40
#define DF_MAXSAVES 50
//#define DF_SCREENWIDTH (80)
//#define DF_SCREENHEIGHT (25)
HANDLE DfInput;
HANDLE DfOutput;
SHORT DfScreenHeight;
SHORT DfScreenWidth;
/* ---------- keyboard prototypes -------- */
int DfAltConvert(int);
void DfGetKey(PINPUT_RECORD);
int DfGetShift(void);
BOOL DfKeyHit(void);
void DfBeep(void);
/* ---------- DfCursor prototypes -------- */
void DfCurrCursor(int *x, int *y);
void DfCursor(int x, int y);
void DfHideCursor(void);
void DfUnhideCursor(void);
void DfSaveCursor(void);
void DfRestoreCursor(void);
void DfNormalCursor(void);
void DfSetCursorSize(unsigned t);
void DfVideoMode(void);
void DfSwapCursorStack(void);
/* ------------ timer macros -------------- */
#define DfTimedOut(timer) (timer==0)
#define DfSetTimer(timer, secs) timer=(secs)*182/10+1
#define DfDisableTimer(timer) timer = -1
#define DfTimerRunning(timer) (timer > 0)
#define DfCountdown(timer) --timer
#define DfTimerDisabled(timer) (timer == -1)
#ifndef TURBOC
#ifndef BCPP
/* ============= Color Macros ============ */
#define BLACK 0
#define BLUE 1
#define GREEN 2
#define CYAN 3
#define RED 4
#define MAGENTA 5
#define BROWN 6
#define LIGHTGRAY 7
#define DARKGRAY 8
#define LIGHTBLUE 9
#define LIGHTGREEN 10
#define LIGHTCYAN 11
#define LIGHTRED 12
#define LIGHTMAGENTA 13
#define YELLOW 14
#define WHITE 15
#define DfKeyHit kbhit
#endif
#endif
typedef enum DfMessages {
#ifdef WATCOM
DF_WATCOMFIX1 = -1,
#endif
#undef DFlatMsg
#define DFlatMsg(m) m,
#include "dflatmsg.h"
DF_MESSAGECOUNT
} DFMESSAGE;
typedef enum DfWindowClass {
#ifdef WATCOM
DF_WATCOMFIX2 = -1,
#endif
#define DfClassDef(c,b,p,a) c,
#include "classes.h"
DF_CLASSCOUNT
} DFCLASS;
#endif
rosapps/dflat32/text.c
-65
View File
@@ -1,65 +0,0 @@
/* -------------- text.c -------------- */
#include "dflat.h"
int DfTextProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int i, len;
DF_CTLWINDOW *ct = DfGetControl(wnd);
char *cp, *cp2 = ct->itext;
char *ptr;
switch (msg)
{
case DFM_SETFOCUS:
return TRUE;
case DFM_LEFT_BUTTON:
return TRUE;
case DFM_PAINT:
if (ct == NULL ||
ct->itext == NULL ||
DfGetText(wnd) != NULL)
break;
len = min(ct->dwnd.h, DfMsgHeight(cp2));
ptr = DfMalloc (strlen (cp2) + 1);
strcpy (ptr, cp2);
cp = ptr;
for (i = 0; i < len; i++)
{
int mlen;
char *txt = cp;
char *cp1 = cp;
char *np = strchr(cp, '\n');
if (np != NULL)
*np = '\0';
mlen = strlen(cp);
while ((cp1=strchr(cp1,DF_SHORTCUTCHAR)) != NULL)
{
mlen += 3;
cp1++;
}
if (np != NULL)
*np = '\n';
txt = DfMalloc(mlen+1);
DfCopyCommand(txt, cp, FALSE, DfWndBackground(wnd));
txt[mlen] = '\0';
DfSendMessage(wnd, DFM_ADDTEXT, (DF_PARAM)txt, 0);
if ((cp = strchr(cp, '\n')) != NULL)
cp++;
free(txt);
}
free (ptr);
break;
default:
break;
}
return DfBaseWndProc(DF_TEXT, wnd, msg, p1, p2);
}
/* EOF */
rosapps/dflat32/textbox.c
-873
View File
@@ -1,873 +0,0 @@
/* ------------- textbox.c ------------ */
#include "dflat.h"
static void ComputeWindowTop(DFWINDOW);
static void ComputeWindowLeft(DFWINDOW);
static int ComputeVScrollBox(DFWINDOW);
static int ComputeHScrollBox(DFWINDOW);
static void MoveScrollBox(DFWINDOW, int);
static char *GetTextLine(DFWINDOW, int);
BOOL DfVSliding;
BOOL DfHSliding;
/* ------------ DFM_ADDTEXT Message -------------- */
static BOOL AddTextMsg(DFWINDOW wnd, char *txt)
{
/* --- append text to the textbox's buffer --- */
unsigned adln = strlen(txt);
if (adln > (unsigned)0xfff0)
return FALSE;
if (wnd->text != NULL) {
/* ---- appending to existing text ---- */
unsigned txln = strlen(wnd->text);
if ((long)txln+adln > (unsigned) 0xfff0)
return FALSE;
if (txln+adln > wnd->textlen) {
wnd->text = DfRealloc(wnd->text, txln+adln+3);
wnd->textlen = txln+adln+1;
}
}
else {
/* ------ 1st text appended ------ */
wnd->text = DfCalloc(1, adln+3);
wnd->textlen = adln+1;
}
if (wnd->text != NULL) {
/* ---- append the text ---- */
strcat(wnd->text, txt);
strcat(wnd->text, "\n");
DfBuildTextPointers(wnd);
return TRUE;
}
return FALSE;
}
/* ------------ DFM_DELETETEXT Message -------------- */
static void DeleteTextMsg(DFWINDOW wnd, int lno)
{
char *cp1 = DfTextLine(wnd, lno);
--wnd->wlines;
if (lno == wnd->wlines)
*cp1 = '\0';
else {
char *cp2 = DfTextLine(wnd, lno+1);
memmove(cp1, cp2, strlen(cp2)+1);
}
DfBuildTextPointers(wnd);
}
/* ------------ DFM_INSERTTEXT Message -------------- */
static void InsertTextMsg(DFWINDOW wnd, char *txt, int lno)
{
if (AddTextMsg(wnd, txt)) {
int len = strlen(txt);
char *cp2 = DfTextLine(wnd, lno);
char *cp1 = cp2+len+1;
memmove(cp1, cp2, strlen(cp2)-len);
strcpy(cp2, txt);
*(cp2+len) = '\n';
DfBuildTextPointers(wnd);
}
}
/* ------------ DFM_SETTEXT Message -------------- */
static void SetTextMsg(DFWINDOW wnd, char *txt)
{
/* -- assign new text value to textbox buffer -- */
unsigned int len = strlen(txt)+1;
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
wnd->textlen = len;
wnd->text=DfRealloc(wnd->text, len+1);
wnd->text[len] = '\0';
strcpy(wnd->text, txt);
DfBuildTextPointers(wnd);
}
/* ------------ DFM_CLEARTEXT Message -------------- */
static void ClearTextMsg(DFWINDOW wnd)
{
/* ----- clear text from textbox ----- */
if (wnd->text != NULL)
free(wnd->text);
wnd->text = NULL;
wnd->textlen = 0;
wnd->wlines = 0;
wnd->textwidth = 0;
wnd->wtop = wnd->wleft = 0;
DfClearTextBlock(wnd);
DfClearTextPointers(wnd);
}
/* ------------ DFM_KEYBOARD Message -------------- */
static int KeyboardMsg(DFWINDOW wnd, DF_PARAM p1)
{
switch ((int) p1) {
case DF_UP:
return DfSendMessage(wnd,DFM_SCROLL,FALSE,0);
case DF_DN:
return DfSendMessage(wnd,DFM_SCROLL,TRUE,0);
case DF_FWD:
return DfSendMessage(wnd,DFM_HORIZSCROLL,TRUE,0);
case DF_BS:
return DfSendMessage(wnd,DFM_HORIZSCROLL,FALSE,0);
case DF_PGUP:
return DfSendMessage(wnd,DFM_SCROLLPAGE,FALSE,0);
case DF_PGDN:
return DfSendMessage(wnd,DFM_SCROLLPAGE,TRUE,0);
case DF_CTRL_PGUP:
return DfSendMessage(wnd,DFM_HORIZPAGE,FALSE,0);
case DF_CTRL_PGDN:
return DfSendMessage(wnd,DFM_HORIZPAGE,TRUE,0);
case DF_HOME:
return DfSendMessage(wnd,DFM_SCROLLDOC,TRUE,0);
case DF_END:
return DfSendMessage(wnd,DFM_SCROLLDOC,FALSE,0);
default:
break;
}
return FALSE;
}
/* ------------ DFM_LEFT_BUTTON Message -------------- */
static int LeftButtonMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int mx = (int) p1 - DfGetLeft(wnd);
int my = (int) p2 - DfGetTop(wnd);
if (DfTestAttribute(wnd, DF_VSCROLLBAR) &&
mx == DfWindowWidth(wnd)-1) {
/* -------- in the right border ------- */
if (my == 0 || my == DfClientHeight(wnd)+1)
/* --- above or below the scroll bar --- */
return FALSE;
if (my == 1)
/* -------- top scroll button --------- */
return DfSendMessage(wnd, DFM_SCROLL, FALSE, 0);
if (my == DfClientHeight(wnd))
/* -------- bottom scroll button --------- */
return DfSendMessage(wnd, DFM_SCROLL, TRUE, 0);
/* ---------- in the scroll bar ----------- */
if (!DfVSliding && my-1 == wnd->VScrollBox) {
DFRECT rc;
DfVSliding = TRUE;
rc.lf = rc.rt = DfGetRight(wnd);
rc.tp = DfGetTop(wnd)+2;
rc.bt = DfGetBottom(wnd)-2;
return DfSendMessage(NULL, DFM_MOUSE_TRAVEL,
(DF_PARAM) &rc, 0);
}
if (my-1 < wnd->VScrollBox)
return DfSendMessage(wnd,DFM_SCROLLPAGE,FALSE,0);
if (my-1 > wnd->VScrollBox)
return DfSendMessage(wnd,DFM_SCROLLPAGE,TRUE,0);
}
if (DfTestAttribute(wnd, DF_HSCROLLBAR) &&
my == DfWindowHeight(wnd)-1) {
/* -------- in the bottom border ------- */
if (mx == 0 || my == DfClientWidth(wnd)+1)
/* ------ outside the scroll bar ---- */
return FALSE;
if (mx == 1)
return DfSendMessage(wnd, DFM_HORIZSCROLL,FALSE,0);
if (mx == DfWindowWidth(wnd)-2)
return DfSendMessage(wnd, DFM_HORIZSCROLL,TRUE,0);
if (!DfHSliding && mx-1 == wnd->HScrollBox) {
/* --- hit the scroll box --- */
DFRECT rc;
rc.lf = DfGetLeft(wnd)+2;
rc.rt = DfGetRight(wnd)-2;
rc.tp = rc.bt = DfGetBottom(wnd);
/* - keep the mouse in the scroll bar - */
DfSendMessage(NULL,DFM_MOUSE_TRAVEL,(DF_PARAM)&rc,0);
DfHSliding = TRUE;
return TRUE;
}
if (mx-1 < wnd->HScrollBox)
return DfSendMessage(wnd,DFM_HORIZPAGE,FALSE,0);
if (mx-1 > wnd->HScrollBox)
return DfSendMessage(wnd,DFM_HORIZPAGE,TRUE,0);
}
return FALSE;
}
/* ------------ MOUSE_MOVED Message -------------- */
static BOOL MouseMovedMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
int mx = (int) p1 - DfGetLeft(wnd);
int my = (int) p2 - DfGetTop(wnd);
if (DfVSliding) {
/* ---- dragging the vertical scroll box --- */
if (my-1 != wnd->VScrollBox) {
DfForeground = DfFrameForeground(wnd);
DfBackground = DfFrameBackground(wnd);
DfWPutch(wnd, DF_SCROLLBARCHAR, DfWindowWidth(wnd)-1,
wnd->VScrollBox+1);
wnd->VScrollBox = my-1;
DfWPutch(wnd, DF_SCROLLBOXCHAR, DfWindowWidth(wnd)-1,
my);
}
return TRUE;
}
if (DfHSliding) {
/* --- dragging the horizontal scroll box --- */
if (mx-1 != wnd->HScrollBox) {
DfForeground = DfFrameForeground(wnd);
DfBackground = DfFrameBackground(wnd);
DfWPutch(wnd, DF_SCROLLBARCHAR, wnd->HScrollBox+1,
DfWindowHeight(wnd)-1);
wnd->HScrollBox = mx-1;
DfWPutch(wnd, DF_SCROLLBOXCHAR, mx, DfWindowHeight(wnd)-1);
}
return TRUE;
}
return FALSE;
}
/* ------------ BUTTON_RELEASED Message -------------- */
static void ButtonReleasedMsg(DFWINDOW wnd)
{
if (DfHSliding || DfVSliding) {
/* release the mouse ouside the scroll bar */
DfSendMessage(NULL, DFM_MOUSE_TRAVEL, 0, 0);
DfVSliding ? ComputeWindowTop(wnd):ComputeWindowLeft(wnd);
DfSendMessage(wnd, DFM_PAINT, 0, 0);
DfSendMessage(wnd, DFM_KEYBOARD_CURSOR, 0, 0);
DfVSliding = DfHSliding = FALSE;
}
}
/* ------------ DFM_SCROLL Message -------------- */
static BOOL ScrollMsg(DFWINDOW wnd, DF_PARAM p1)
{
/* ---- vertical scroll one line ---- */
if (p1) {
/* ----- scroll one line up ----- */
if (wnd->wtop+DfClientHeight(wnd) >= wnd->wlines)
return FALSE;
wnd->wtop++;
}
else {
/* ----- scroll one line down ----- */
if (wnd->wtop == 0)
return FALSE;
--wnd->wtop;
}
if (DfIsVisible(wnd)) {
DFRECT rc;
rc = DfClipRectangle(wnd, DfClientRect(wnd));
if (DfValidRect(rc)) {
/* ---- scroll the window ----- */
if (wnd != DfInFocus)
DfSendMessage(wnd, DFM_PAINT, 0, 0);
else {
DfScrollWindow(wnd, rc, (int)p1);
if (!(int)p1)
/* -- write top line (down) -- */
DfWriteTextLine(wnd,NULL,wnd->wtop,FALSE);
else {
/* -- write bottom line (up) -- */
int y=DfRectBottom(rc)-DfGetClientTop(wnd);
DfWriteTextLine(wnd, NULL,
wnd->wtop+y, FALSE);
}
}
}
/* ---- reset the scroll box ---- */
if (DfTestAttribute(wnd, DF_VSCROLLBAR)) {
int vscrollbox = ComputeVScrollBox(wnd);
if (vscrollbox != wnd->VScrollBox)
MoveScrollBox(wnd, vscrollbox);
}
}
return TRUE;
}
/* ------------ DFM_HORIZSCROLL Message -------------- */
static BOOL HorizScrollMsg(DFWINDOW wnd, DF_PARAM p1)
{
/* --- horizontal scroll one column --- */
if (p1) {
/* --- scroll left --- */
if (wnd->wleft + DfClientWidth(wnd)-1 >= wnd->textwidth)
return FALSE;
wnd->wleft++;
}
else {
/* --- scroll right --- */
if (wnd->wleft == 0)
return FALSE;
--wnd->wleft;
}
DfSendMessage(wnd, DFM_PAINT, 0, 0);
return TRUE;
}
/* ------------ DFM_SCROLLPAGE Message -------------- */
static void ScrollPageMsg(DFWINDOW wnd, DF_PARAM p1)
{
/* --- vertical scroll one page --- */
if ((int) p1 == FALSE) {
/* ---- page up ---- */
if (wnd->wtop)
wnd->wtop -= DfClientHeight(wnd);
}
else {
/* ---- page down ---- */
if (wnd->wtop+DfClientHeight(wnd) < wnd->wlines) {
wnd->wtop += DfClientHeight(wnd);
if (wnd->wtop>wnd->wlines-DfClientHeight(wnd))
wnd->wtop=wnd->wlines-DfClientHeight(wnd);
}
}
if (wnd->wtop < 0)
wnd->wtop = 0;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
/* ------------ HORIZSCROLLPAGE Message -------------- */
static void HorizScrollPageMsg(DFWINDOW wnd, DF_PARAM p1)
{
/* --- horizontal scroll one page --- */
if ((int) p1 == FALSE)
/* ---- page left ----- */
wnd->wleft -= DfClientWidth(wnd);
else {
/* ---- page right ----- */
wnd->wleft += DfClientWidth(wnd);
if (wnd->wleft > wnd->textwidth-DfClientWidth(wnd))
wnd->wleft = wnd->textwidth-DfClientWidth(wnd);
}
if (wnd->wleft < 0)
wnd->wleft = 0;
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
/* ------------ DFM_SCROLLDOC Message -------------- */
static void ScrollDocMsg(DFWINDOW wnd, DF_PARAM p1)
{
/* --- scroll to beginning or end of document --- */
if ((int) p1)
wnd->wtop = wnd->wleft = 0;
else if (wnd->wtop+DfClientHeight(wnd) < wnd->wlines){
wnd->wtop = wnd->wlines-DfClientHeight(wnd);
wnd->wleft = 0;
}
DfSendMessage(wnd, DFM_PAINT, 0, 0);
}
/* ------------ DFM_PAINT Message -------------- */
static void PaintMsg(DFWINDOW wnd, DF_PARAM p1, DF_PARAM p2)
{
/* ------ paint the client area ----- */
DFRECT rc, rcc;
int y;
char blankline[201];
/* ----- build the rectangle to paint ----- */
if ((DFRECT *)p1 == NULL)
rc=DfRelativeWindowRect(wnd, DfWindowRect(wnd));
else
rc= *(DFRECT *)p1;
if (DfTestAttribute(wnd, DF_HASBORDER) &&
DfRectRight(rc) >= DfWindowWidth(wnd)-1) {
if (DfRectLeft(rc) >= DfWindowWidth(wnd)-1)
return;
DfRectRight(rc) = DfWindowWidth(wnd)-2;
}
rcc = DfAdjustRectangle(wnd, rc);
if (!p2 && wnd != DfInFocus)
DfClipString++;
/* ----- blank line for padding ----- */
memset(blankline, ' ', DfGetScreenWidth());
blankline[DfRectRight(rcc)+1] = '\0';
/* ------- each line DfWithin rectangle ------ */
for (y = DfRectTop(rc); y <= DfRectBottom(rc); y++){
int yy;
/* ---- test outside of Client area ---- */
if (DfTestAttribute(wnd,
DF_HASBORDER | DF_HASTITLEBAR)) {
if (y < DfTopBorderAdj(wnd))
continue;
if (y > DfWindowHeight(wnd)-2)
continue;
}
yy = y-DfTopBorderAdj(wnd);
if (yy < wnd->wlines-wnd->wtop)
/* ---- paint a text line ---- */
DfWriteTextLine(wnd, &rc,
yy+wnd->wtop, FALSE);
else {
/* ---- paint a blank line ---- */
DfSetStandardColor(wnd);
DfWriteLine(wnd, blankline+DfRectLeft(rcc),
DfRectLeft(rcc)+DfBorderAdj(wnd), y, FALSE);
}
}
/* ------- position the scroll box ------- */
if (DfTestAttribute(wnd, DF_VSCROLLBAR|DF_HSCROLLBAR)) {
int hscrollbox = ComputeHScrollBox(wnd);
int vscrollbox = ComputeVScrollBox(wnd);
if (hscrollbox != wnd->HScrollBox ||
vscrollbox != wnd->VScrollBox) {
wnd->HScrollBox = hscrollbox;
wnd->VScrollBox = vscrollbox;
DfSendMessage(wnd, DFM_BORDER, p1, 0);
}
}
if (!p2 && wnd != DfInFocus)
--DfClipString;
}
/* ------------ DFM_CLOSE_WINDOW Message -------------- */
static void CloseWindowMsg(DFWINDOW wnd)
{
DfSendMessage(wnd, DFM_CLEARTEXT, 0, 0);
if (wnd->TextPointers != NULL) {
free(wnd->TextPointers);
wnd->TextPointers = NULL;
}
}
/* ----------- DF_TEXTBOX Message-processing Module ----------- */
int DfTextBoxProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
switch (msg) {
case DFM_CREATE_WINDOW:
wnd->HScrollBox = wnd->VScrollBox = 1;
DfClearTextPointers(wnd);
break;
case DFM_ADDTEXT:
return AddTextMsg(wnd, (char *) p1);
case DFM_DELETETEXT:
DeleteTextMsg(wnd, (int) p1);
return TRUE;
case DFM_INSERTTEXT:
InsertTextMsg(wnd, (char *) p1, (int) p2);
return TRUE;
case DFM_SETTEXT:
SetTextMsg(wnd, (char *) p1);
return TRUE;
case DFM_CLEARTEXT:
ClearTextMsg(wnd);
break;
case DFM_KEYBOARD:
if (DfWindowMoving || DfWindowSizing)
break;
if (KeyboardMsg(wnd, p1))
return TRUE;
break;
case DFM_LEFT_BUTTON:
if (DfWindowSizing || DfWindowMoving)
return FALSE;
if (LeftButtonMsg(wnd, p1, p2))
return TRUE;
break;
case MOUSE_MOVED:
if (MouseMovedMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_BUTTON_RELEASED:
ButtonReleasedMsg(wnd);
break;
case DFM_SCROLL:
return ScrollMsg(wnd, p1);
case DFM_HORIZSCROLL:
return HorizScrollMsg(wnd, p1);
case DFM_SCROLLPAGE:
ScrollPageMsg(wnd, p1);
return TRUE;
case DFM_HORIZPAGE:
HorizScrollPageMsg(wnd, p1);
return TRUE;
case DFM_SCROLLDOC:
ScrollDocMsg(wnd, p1);
return TRUE;
case DFM_PAINT:
if (DfIsVisible(wnd))
{
PaintMsg(wnd, p1, p2);
return FALSE;
}
break;
case DFM_CLOSE_WINDOW:
CloseWindowMsg(wnd);
break;
default:
break;
}
return DfBaseWndProc(DF_TEXTBOX, wnd, msg, p1, p2);
}
/* ------ compute the vertical scroll box position from
the text pointers --------- */
static int ComputeVScrollBox(DFWINDOW wnd)
{
int pagelen = wnd->wlines - DfClientHeight(wnd);
int barlen = DfClientHeight(wnd)-2;
int lines_tick;
int vscrollbox;
if (pagelen < 1 || barlen < 1)
vscrollbox = 1;
else {
if (pagelen > barlen)
lines_tick = pagelen / barlen;
else
lines_tick = barlen / pagelen;
vscrollbox = 1 + (wnd->wtop / lines_tick);
if (vscrollbox > DfClientHeight(wnd)-2 ||
wnd->wtop + DfClientHeight(wnd) >= wnd->wlines)
vscrollbox = DfClientHeight(wnd)-2;
}
return vscrollbox;
}
/* ---- compute top text line from scroll box position ---- */
static void ComputeWindowTop(DFWINDOW wnd)
{
int pagelen = wnd->wlines - DfClientHeight(wnd);
if (wnd->VScrollBox == 0)
wnd->wtop = 0;
else if (wnd->VScrollBox == DfClientHeight(wnd)-2)
wnd->wtop = pagelen;
else {
int barlen = DfClientHeight(wnd)-2;
int lines_tick;
if (pagelen > barlen)
lines_tick = barlen ? (pagelen / barlen) : 0;
else
lines_tick = pagelen ? (barlen / pagelen) : 0;
wnd->wtop = (wnd->VScrollBox-1) * lines_tick;
if (wnd->wtop + DfClientHeight(wnd) > wnd->wlines)
wnd->wtop = pagelen;
}
if (wnd->wtop < 0)
wnd->wtop = 0;
}
/* ------ compute the horizontal scroll box position from
the text pointers --------- */
static int ComputeHScrollBox(DFWINDOW wnd)
{
int pagewidth = wnd->textwidth - DfClientWidth(wnd);
int barlen = DfClientWidth(wnd)-2;
int chars_tick;
int hscrollbox;
if (pagewidth < 1 || barlen < 1)
hscrollbox = 1;
else {
if (pagewidth > barlen)
chars_tick = barlen ? (pagewidth / barlen) : 0;
else
chars_tick = pagewidth ? (barlen / pagewidth) : 0;
hscrollbox = 1 + (chars_tick ? (wnd->wleft / chars_tick) : 0);
if (hscrollbox > DfClientWidth(wnd)-2 ||
wnd->wleft + DfClientWidth(wnd) >= wnd->textwidth)
hscrollbox = DfClientWidth(wnd)-2;
}
return hscrollbox;
}
/* ---- compute left column from scroll box position ---- */
static void ComputeWindowLeft(DFWINDOW wnd)
{
int pagewidth = wnd->textwidth - DfClientWidth(wnd);
if (wnd->HScrollBox == 0)
wnd->wleft = 0;
else if (wnd->HScrollBox == DfClientWidth(wnd)-2)
wnd->wleft = pagewidth;
else {
int barlen = DfClientWidth(wnd)-2;
int chars_tick;
if (pagewidth > barlen)
chars_tick = pagewidth / barlen;
else
chars_tick = barlen / pagewidth;
wnd->wleft = (wnd->HScrollBox-1) * chars_tick;
if (wnd->wleft + DfClientWidth(wnd) > wnd->textwidth)
wnd->wleft = pagewidth;
}
if (wnd->wleft < 0)
wnd->wleft = 0;
}
/* ----- get the text to a specified line ----- */
static char *GetTextLine(DFWINDOW wnd, int selection)
{
char *line;
int len = 0;
char *cp, *cp1;
cp = cp1 = DfTextLine(wnd, selection);
while (*cp && *cp != '\n') {
len++;
cp++;
}
line = DfMalloc(len+7);
memmove(line, cp1, len);
line[len] = '\0';
return line;
}
/* ------- write a line of text to a textbox window ------- */
void DfWriteTextLine(DFWINDOW wnd, DFRECT *rcc, int y, BOOL reverse)
{
int len = 0;
int dif = 0;
char line[200];
DFRECT rc;
char *lp, *svlp;
int lnlen;
int i;
BOOL trunc = FALSE;
/* ------ make sure y is inside the window ----- */
if (y < wnd->wtop || y >= wnd->wtop+DfClientHeight(wnd))
return;
/* ---- build the retangle DfWithin which can write ---- */
if (rcc == NULL) {
rc = DfRelativeWindowRect(wnd, DfWindowRect(wnd));
if (DfTestAttribute(wnd, DF_HASBORDER) &&
DfRectRight(rc) >= DfWindowWidth(wnd)-1)
DfRectRight(rc) = DfWindowWidth(wnd)-2;
}
else
rc = *rcc;
/* ----- make sure rectangle is DfWithin window ------ */
if (DfRectLeft(rc) >= DfWindowWidth(wnd)-1)
return;
if (DfRectRight(rc) == 0)
return;
rc = DfAdjustRectangle(wnd, rc);
if (y-wnd->wtop<DfRectTop(rc) || y-wnd->wtop>DfRectBottom(rc))
return;
/* --- get the text and length of the text line --- */
lp = svlp = GetTextLine(wnd, y);
if (svlp == NULL)
return;
lnlen = DfLineLength(lp);
/* -------- insert block DfColor change controls ------- */
if (DfTextBlockMarked(wnd)) {
int bbl = wnd->BlkBegLine;
int bel = wnd->BlkEndLine;
int bbc = wnd->BlkBegCol;
int bec = wnd->BlkEndCol;
int by = y;
/* ----- put lowest marker first ----- */
if (bbl > bel) {
swap(bbl, bel);
swap(bbc, bec);
}
if (bbl == bel && bbc > bec)
swap(bbc, bec);
if (by >= bbl && by <= bel) {
/* ------ the block includes this line ----- */
int blkbeg = 0;
int blkend = lnlen;
if (!(by > bbl && by < bel)) {
/* --- the entire line is not in the block -- */
if (by == bbl)
/* ---- the block begins on this line --- */
blkbeg = bbc;
if (by == bel)
/* ---- the block ends on this line ---- */
blkend = bec;
}
if (blkend == 0 && lnlen == 0) {
strcpy(lp, " ");
blkend++;
}
/* ----- insert the reset DfColor token ----- */
memmove(lp+blkend+1,lp+blkend,strlen(lp+blkend)+1);
lp[blkend] = DF_RESETCOLOR;
/* ----- insert the change DfColor token ----- */
memmove(lp+blkbeg+3,lp+blkbeg,strlen(lp+blkbeg)+1);
lp[blkbeg] = DF_CHANGECOLOR;
/* ----- insert the DfColor tokens ----- */
DfSetReverseColor(wnd);
lp[blkbeg+1] = DfForeground | 0x80;
lp[blkbeg+2] = DfBackground | 0x80;
lnlen += 4;
}
}
/* - make sure left margin doesn't overlap DfColor change - */
for (i = 0; i < wnd->wleft+3; i++) {
if (*(lp+i) == '\0')
break;
if (*(lp + i) == DF_RESETCOLOR)
break;
}
if (*(lp+i) && i < wnd->wleft+3) {
if (wnd->wleft+4 > lnlen)
trunc = TRUE;
else
lp += 4;
}
else {
/* --- it does, shift the DfColor change over --- */
for (i = 0; i < wnd->wleft; i++) {
if (*(lp+i) == '\0')
break;
if (*(lp + i) == DF_CHANGECOLOR) {
*(lp+wnd->wleft+2) = *(lp+i+2);
*(lp+wnd->wleft+1) = *(lp+i+1);
*(lp+wnd->wleft) = *(lp+i);
break;
}
}
}
/* ------ build the line to display -------- */
if (!trunc) {
if (lnlen < wnd->wleft)
lnlen = 0;
else
lp += wnd->wleft;
if (lnlen > DfRectLeft(rc)) {
/* ---- the line exceeds the rectangle ---- */
int ct = DfRectLeft(rc);
char *initlp = lp;
/* --- point to end of clipped line --- */
while (ct) {
if (*lp == DF_CHANGECOLOR)
lp += 3;
else if (*lp == DF_RESETCOLOR)
lp++;
else
lp++, --ct;
}
if (DfRectLeft(rc)) {
char *lpp = lp;
while (*lpp) {
if (*lpp==DF_CHANGECOLOR)
break;
if (*lpp==DF_RESETCOLOR) {
lpp = lp;
while (lpp >= initlp) {
if (*lpp == DF_CHANGECOLOR) {
lp -= 3;
memmove(lp,lpp,3);
break;
}
--lpp;
}
break;
}
lpp++;
}
}
lnlen = DfLineLength(lp);
len = min(lnlen, DfRectWidth(rc));
dif = strlen(lp) - lnlen;
len += dif;
if (len > 0)
strncpy(line, lp, len);
}
}
/* -------- pad the line --------- */
while (len < DfRectWidth(rc)+dif)
line[len++] = ' ';
line[len] = '\0';
dif = 0;
/* ------ establish the line's main DfColor ----- */
if (reverse) {
char *cp = line;
DfSetReverseColor(wnd);
while ((cp = strchr(cp, DF_CHANGECOLOR)) != NULL) {
cp += 2;
*cp++ = DfBackground | 0x80;
}
if (*line == DF_CHANGECOLOR)
dif = 3;
}
else
DfSetStandardColor(wnd);
/* ------- display the line -------- */
DfWriteLine(wnd, line+dif,
DfRectLeft(rc)+DfBorderAdj(wnd),
y-wnd->wtop+DfTopBorderAdj(wnd), FALSE);
free(svlp);
}
void DfMarkTextBlock(DFWINDOW wnd, int BegLine, int BegCol,
int EndLine, int EndCol)
{
wnd->BlkBegLine = BegLine;
wnd->BlkEndLine = EndLine;
wnd->BlkBegCol = BegCol;
wnd->BlkEndCol = EndCol;
}
/* ----- clear and initialize text line pointer array ----- */
void DfClearTextPointers(DFWINDOW wnd)
{
wnd->TextPointers = DfRealloc(wnd->TextPointers, sizeof(int));
*(wnd->TextPointers) = 0;
}
#define INITLINES 100
/* ---- build array of pointers to text lines ---- */
void DfBuildTextPointers(DFWINDOW wnd)
{
char *cp = wnd->text, *cp1;
int incrs = INITLINES;
unsigned int off;
wnd->textwidth = wnd->wlines = 0;
while (*cp) {
if (incrs == INITLINES) {
incrs = 0;
wnd->TextPointers = DfRealloc(wnd->TextPointers,
(wnd->wlines + INITLINES) * sizeof(int));
}
off = (unsigned int) ((unsigned int)cp - (unsigned int)wnd->text);
*((wnd->TextPointers) + wnd->wlines) = off;
wnd->wlines++;
incrs++;
cp1 = cp;
while (*cp && *cp != '\n')
cp++;
wnd->textwidth = max(wnd->textwidth, (int)(cp - cp1));
if (*cp)
cp++;
}
}
static void MoveScrollBox(DFWINDOW wnd, int vscrollbox)
{
DfForeground = DfFrameForeground(wnd);
DfBackground = DfFrameBackground(wnd);
DfWPutch(wnd, DF_SCROLLBARCHAR, DfWindowWidth(wnd)-1,
wnd->VScrollBox+1);
DfWPutch(wnd, DF_SCROLLBOXCHAR, DfWindowWidth(wnd)-1,
vscrollbox+1);
wnd->VScrollBox = vscrollbox;
}
int DfTextLineNumber(DFWINDOW wnd, char *lp)
{
int lineno;
char *cp;
for (lineno = 0; lineno < wnd->wlines; lineno++) {
cp = wnd->text + *((wnd->TextPointers) + lineno);
if (cp == lp)
return lineno;
if (cp > lp)
break;
}
return lineno-1;
}
/* EOF */
rosapps/dflat32/video.c
-323
View File
@@ -1,323 +0,0 @@
/* --------------------- video.c -------------------- */
#include "dflat.h"
#define clr(fg,bg) ((fg)|((bg)<<4))
BOOL DfClipString;
/* -- read a rectangle of video memory into a save buffer -- */
void DfGetVideo(DFRECT rc, PCHAR_INFO bf)
{
COORD Size;
COORD Pos;
SMALL_RECT Rect;
Size.X = DfRectRight(rc) - DfRectLeft(rc) + 1;
Size.Y = DfRectBottom(rc) - DfRectTop(rc) + 1;
Pos.X = 0;
Pos.Y = 0;
Rect.Left = DfRectLeft(rc);
Rect.Top = DfRectTop(rc);
Rect.Right = DfRectRight(rc);
Rect.Bottom = DfRectBottom(rc);
ReadConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
bf,
Size,
Pos,
&Rect);
}
/* -- write a rectangle of video memory from a save buffer -- */
void DfStoreVideo(DFRECT rc, PCHAR_INFO bf)
{
COORD Size;
COORD Pos;
SMALL_RECT Rect;
Size.X = DfRectRight(rc) - DfRectLeft(rc) + 1;
Size.Y = DfRectBottom(rc) - DfRectTop(rc) + 1;
Pos.X = 0;
Pos.Y = 0;
Rect.Left = DfRectLeft(rc);
Rect.Top = DfRectTop(rc);
Rect.Right = DfRectRight(rc);
Rect.Bottom = DfRectBottom(rc);
WriteConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
bf,
Size,
Pos,
&Rect);
}
/* -------- read a character of video memory ------- */
char DfGetVideoChar(int x, int y)
{
COORD pos;
DWORD dwRead;
char ch;
pos.X = x;
pos.Y = y;
ReadConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE),
&ch,
1,
pos,
&dwRead);
return ch;
}
/* -------- write a character of video memory ------- */
void DfPutVideoChar(int x, int y, int ch)
{
COORD pos;
DWORD dwWritten;
if (x < DfScreenWidth && y < DfScreenHeight)
{
pos.X = x;
pos.Y = y;
WriteConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE),
(char *)&ch,
1,
pos,
&dwWritten);
}
}
BOOL DfCharInView(DFWINDOW wnd, int x, int y)
{
DFWINDOW nwnd = DfNextWindow(wnd);
DFWINDOW pwnd;
DFRECT rc;
int x1 = DfGetLeft(wnd)+x;
int y1 = DfGetTop(wnd)+y;
if (!DfTestAttribute(wnd, DF_VISIBLE))
return FALSE;
if (!DfTestAttribute(wnd, DF_NOCLIP))
{
DFWINDOW wnd1 = DfGetParent(wnd);
while (wnd1 != NULL)
{
/* clip character to parent's borders */
if (!DfTestAttribute(wnd1, DF_VISIBLE))
return FALSE;
if (!DfInsideRect(x1, y1, DfClientRect(wnd1)))
return FALSE;
wnd1 = DfGetParent(wnd1);
}
}
while (nwnd != NULL)
{
if (!isHidden(nwnd) && !DfIsAncestor(wnd, nwnd))
{
rc = DfWindowRect(nwnd);
if (DfTestAttribute(nwnd, DF_SHADOW))
{
DfRectBottom(rc)++;
DfRectRight(rc)++;
}
if (!DfTestAttribute(nwnd, DF_NOCLIP))
{
pwnd = nwnd;
while (DfGetParent(pwnd))
{
pwnd = DfGetParent(pwnd);
rc = DfSubRectangle(rc, DfClientRect(pwnd));
}
}
if (DfInsideRect(x1,y1,rc))
return FALSE;
}
nwnd = DfNextWindow(nwnd);
}
return (x1 < DfScreenWidth && y1 < DfScreenHeight);
}
/* -------- write a character to a window ------- */
void DfWPutch(DFWINDOW wnd, int c, int x, int y)
{
if (DfCharInView(wnd, x, y))
{
DWORD dwWritten;
COORD pos;
WORD Attr;
pos.X = DfGetLeft(wnd)+x;
pos.Y = DfGetTop(wnd)+y;
Attr = clr(DfForeground, DfBackground);
WriteConsoleOutputAttribute (GetStdHandle(STD_OUTPUT_HANDLE),
&Attr,
1,
pos,
&dwWritten);
WriteConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE),
(char *)&c,
1,
pos,
&dwWritten);
}
}
/* ------- write a string to a window ---------- */
void DfWPuts(DFWINDOW wnd, void *s, int x, int y)
{
int x1 = DfGetLeft(wnd)+x;
int x2 = x1;
int y1 = DfGetTop(wnd)+y;
if (x1 < DfScreenWidth && y1 < DfScreenHeight && DfIsVisible(wnd))
{
char ln[200];
WORD attr[200];
char *cp = ln;
WORD *ap = attr;
char *str = s;
int fg = DfForeground;
int bg = DfBackground;
int len;
int off = 0;
while (*str)
{
if (*str == DF_CHANGECOLOR)
{
str++;
DfForeground = (*str++) & 0x7f;
DfBackground = (*str++) & 0x7f;
continue;
}
if (*str == DF_RESETCOLOR)
{
DfForeground = fg & 0x7f;
DfBackground = bg & 0x7f;
str++;
continue;
}
*cp = (*str & 255);
*ap = (WORD)clr(DfForeground, DfBackground);
// *cp1 = (*str & 255) | (clr(DfForeground, DfBackground) << 8);
// if (DfClipString)
// if (!DfCharInView(wnd, x, y))
// *cp1 = peek(video_address, vad(x2,y1));
cp++;
ap++;
str++;
x++;
x2++;
}
DfForeground = fg;
DfBackground = bg;
len = (int)(cp-ln);
if (x1+len > DfScreenWidth)
len = DfScreenWidth-x1;
if (!DfClipString && !DfTestAttribute(wnd, DF_NOCLIP))
{
/* -- clip the line to DfWithin ancestor windows -- */
DFRECT rc = DfWindowRect(wnd);
DFWINDOW nwnd = DfGetParent(wnd);
while (len > 0 && nwnd != NULL)
{
if (!DfIsVisible(nwnd))
{
len = 0;
break;
}
rc = DfSubRectangle(rc, DfClientRect(nwnd));
nwnd = DfGetParent(nwnd);
}
while (len > 0 && !DfInsideRect(x1+off,y1,rc))
{
off++;
--len;
}
if (len > 0)
{
x2 = x1+len-1;
while (len && !DfInsideRect(x2,y1,rc))
{
--x2;
--len;
}
}
}
if (len > 0)
{
COORD pos;
DWORD dwWritten;
pos.X = x1;
pos.Y = y1;
WriteConsoleOutputAttribute (GetStdHandle(STD_OUTPUT_HANDLE),
attr,
len,
pos,
&dwWritten);
WriteConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE),
ln,
len,
pos,
&dwWritten);
}
}
}
/* --------- scroll the window. d: 1 = up, 0 = dn ---------- */
void DfScrollWindow(DFWINDOW wnd, DFRECT rc, int d)
{
if (DfRectTop(rc) != DfRectBottom(rc))
{
CHAR_INFO ciFill;
SMALL_RECT rcScroll;
SMALL_RECT rcClip;
COORD pos;
ciFill.Attributes = clr(DfWndForeground(wnd),DfWndBackground(wnd));
ciFill.Char.AsciiChar = ' ';
rcScroll.Left = DfRectLeft(rc);
rcScroll.Right = DfRectRight(rc);
rcScroll.Top = DfRectTop(rc);
rcScroll.Bottom = DfRectBottom(rc);
rcClip = rcScroll;
pos.X = DfRectLeft(rc);
if (d == 0)
{
/* scroll 1 line down */
pos.Y = DfRectTop(rc)+1;
}
else
{
/* scroll 1 line up */
pos.Y = DfRectTop(rc)-1;
}
ScrollConsoleScreenBuffer (GetStdHandle(STD_OUTPUT_HANDLE),
&rcScroll,
&rcClip,
pos,
&ciFill);
}
}
/* EOF */
rosapps/dflat32/video.h
-18
View File
@@ -1,18 +0,0 @@
/* ---------------- video.h ----------------- */
#ifndef VIDEO_H
#define VIDEO_H
#include "rect.h"
void DfGetVideo(DFRECT, PCHAR_INFO);
void DfStoreVideo(DFRECT, PCHAR_INFO);
void DfWPutch(DFWINDOW, int, int, int);
char DfGetVideoChar(int, int);
void DfPutVideoChar(int, int, int);
void DfWPuts(DFWINDOW, void *, int, int);
void DfScrollWindow(DFWINDOW, DFRECT, int);
#define DfVideoChar(x,y) (DfGetVideoChar(x,y) & 0xFF)
#endif
rosapps/dflat32/watch.c
-58
View File
@@ -1,58 +0,0 @@
/* ----------- watch.c ----------- */
#include "dflat.h"
int DfWatchIconProc(DFWINDOW wnd, DFMESSAGE msg, DF_PARAM p1, DF_PARAM p2)
{
int rtn;
switch (msg) {
case DFM_CREATE_WINDOW:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, DFM_CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_CAPTURE_KEYBOARD, 0, 0);
return rtn;
case DFM_PAINT:
DfSetStandardColor(wnd);
DfWriteLine(wnd, " R ", 1, 1, FALSE);
return TRUE;
case DFM_BORDER:
rtn = DfDefaultWndProc(wnd, msg, p1, p2);
DfWriteLine(wnd, "Í", 2, 0, FALSE);
return rtn;
case MOUSE_MOVED:
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
DfSendMessage(wnd, DFM_MOVE, p1, p2);
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
return TRUE;
case DFM_CLOSE_WINDOW:
DfSendMessage(wnd, DFM_RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, DFM_RELEASE_KEYBOARD, 0, 0);
break;
default:
break;
}
return DfDefaultWndProc(wnd, msg, p1, p2);
}
DFWINDOW DfWatchIcon(void)
{
int mx, my;
DFWINDOW wnd;
/* this won't work !! */
// DfSendMessage(NULL, DFM_CURRENT_MOUSE_CURSOR,
// (DF_PARAM) &mx, (DF_PARAM) &my);
mx = 0;//DF_SCREENWIDTH / 2;
my = 0;//DF_SCREENHEIGHT / 2;
wnd = DfDfCreateWindow(
DF_BOX,
NULL,
mx, my, 3, 5,
NULL,NULL,
DfWatchIconProc,
DF_VISIBLE | DF_HASBORDER | DF_SHADOW | DF_SAVESELF);
return wnd;
}
/* EOF */
rosapps/dflat32/window.c
-521
View File
@@ -1,521 +0,0 @@
/* ---------- window.c ------------- */
#include "dflat.h"
DFWINDOW DfInFocus = NULL;
int DfForeground, DfBackground; /* current video colors */
static void TopLine(DFWINDOW, int, DFRECT);
/* --------- create a window ------------ */
DFWINDOW DfDfCreateWindow(
DFCLASS class, /* class of this window */
char *ttl, /* title or NULL */
int left, int top, /* upper left coordinates */
int height, int width, /* dimensions */
void *extension, /* pointer to additional data */
DFWINDOW parent, /* parent of this window */
int (*wndproc)(struct DfWindow *,enum DfMessages,DF_PARAM,DF_PARAM),
int attrib) /* window attribute */
{
DFWINDOW wnd = DfCalloc(1, sizeof(struct DfWindow));
if (wnd != NULL) {
int base;
/* ----- height, width = -1: fill the screen ------- */
if (height == -1)
height = DfScreenHeight;
if (width == -1)
width = DfScreenWidth;
/* ----- coordinates -1, -1 = center the window ---- */
if (left == -1)
wnd->rc.lf = (DfScreenWidth-width)/2;
else
wnd->rc.lf = left;
if (top == -1)
wnd->rc.tp = (DfScreenHeight-height)/2;
else
wnd->rc.tp = top;
wnd->attrib = attrib;
if (ttl != NULL)
DfAddAttribute(wnd, DF_HASTITLEBAR);
if (wndproc == NULL)
wnd->wndproc = DfClassDefs[class].wndproc;
else
wnd->wndproc = wndproc;
/* ---- derive attributes of base classes ---- */
base = class;
while (base != -1) {
DfAddAttribute(wnd, DfClassDefs[base].attrib);
base = DfClassDefs[base].base;
}
if (parent)
{
if (!DfTestAttribute(wnd, DF_NOCLIP))
{
/* -- keep upper left DfWithin borders of parent - */
wnd->rc.lf = max(wnd->rc.lf,DfGetClientLeft(parent));
wnd->rc.tp = max(wnd->rc.tp,DfGetClientTop(parent));
}
}
else
parent = DfApplicationWindow;
wnd->class = class;
wnd->extension = extension;
wnd->rc.rt = DfGetLeft(wnd)+width-1;
wnd->rc.bt = DfGetTop(wnd)+height-1;
wnd->ht = height;
wnd->wd = width;
if (ttl != NULL)
DfInsertTitle(wnd, ttl);
wnd->parent = parent;
wnd->oldcondition = wnd->condition = DF_SRESTORED;
wnd->RestoredRC = wnd->rc;
DfInitWindowColors(wnd);
DfSendMessage(wnd, DFM_CREATE_WINDOW, 0, 0);
if (DfIsVisible(wnd))
DfSendMessage(wnd, DFM_SHOW_WINDOW, 0, 0);
}
return wnd;
}
/* -------- add a title to a window --------- */
void DfAddTitle(DFWINDOW wnd, char *ttl)
{
DfInsertTitle(wnd, ttl);
DfSendMessage(wnd, DFM_BORDER, 0, 0);
}
/* ----- insert a title into a window ---------- */
void DfInsertTitle(DFWINDOW wnd, char *ttl)
{
wnd->title=DfRealloc(wnd->title,strlen(ttl)+1);
strcpy(wnd->title, ttl);
}
static char line[300];
/* ------ write a line to video window client area ------ */
void DfWriteLine(DFWINDOW wnd, char *str, int x, int y, BOOL pad)
{
char *cp;
int len;
int dif;
char wline[200];
memset(wline, 0, 200);
len = DfLineLength(str);
dif = strlen(str) - len;
strncpy(wline, str, DfClientWidth(wnd) + dif);
if (pad) {
cp = wline+strlen(wline);
while (len++ < DfClientWidth(wnd)-x)
*cp++ = ' ';
}
DfWPuts(wnd, wline, x, y);
}
DFRECT DfAdjustRectangle(DFWINDOW wnd, DFRECT rc)
{
/* -------- adjust the rectangle ------- */
if (DfTestAttribute(wnd, DF_HASBORDER)) {
if (DfRectLeft(rc) == 0)
--rc.rt;
else if (DfRectLeft(rc) < DfRectRight(rc) &&
DfRectLeft(rc) < DfWindowWidth(wnd)+1)
--rc.lf;
}
if (DfTestAttribute(wnd, DF_HASBORDER | DF_HASTITLEBAR)) {
if (DfRectTop(rc) == 0)
--rc.bt;
else if (DfRectTop(rc) < DfRectBottom(rc) &&
DfRectTop(rc) < DfWindowHeight(wnd)+1)
--rc.tp;
}
DfRectRight(rc) = max(DfRectLeft(rc),
min(DfRectRight(rc),DfWindowWidth(wnd)));
DfRectBottom(rc) = max(DfRectTop(rc),
min(DfRectBottom(rc),DfWindowHeight(wnd)));
return rc;
}
/* -------- display a window's title --------- */
void DfDisplayTitle(DFWINDOW wnd, DFRECT *rcc)
{
if (DfGetTitle(wnd) != NULL)
{
int tlen = min((int)strlen(DfGetTitle(wnd)), (int)DfWindowWidth(wnd)-2);
int tend = DfWindowWidth(wnd)-3-DfBorderAdj(wnd);
DFRECT rc;
if (rcc == NULL)
rc = DfRelativeWindowRect(wnd, DfWindowRect(wnd));
else
rc = *rcc;
rc = DfAdjustRectangle(wnd, rc);
if (DfSendMessage(wnd, DFM_TITLE, (DF_PARAM) rcc, 0))
{
if (wnd == DfInFocus)
{
DfForeground = DfCfg.clr[DF_TITLEBAR] [DF_HILITE_COLOR] [DF_FG];
DfBackground = DfCfg.clr[DF_TITLEBAR] [DF_HILITE_COLOR] [DF_BG];
}
else
{
DfForeground = DfCfg.clr[DF_TITLEBAR] [DF_STD_COLOR] [DF_FG];
DfBackground = DfCfg.clr[DF_TITLEBAR] [DF_STD_COLOR] [DF_BG];
}
memset(line,' ',DfWindowWidth(wnd));
#ifdef INCLUDE_MINIMIZE
if (wnd->condition != DF_ISMINIMIZED)
#endif
strncpy (line + ((DfWindowWidth(wnd)-2 - tlen) / 2),
wnd->title, tlen);
if (DfTestAttribute(wnd, DF_CONTROLBOX))
line[2-DfBorderAdj(wnd)] = DF_CONTROLBOXCHAR;
if (DfTestAttribute(wnd, DF_MINMAXBOX))
{
switch (wnd->condition)
{
case DF_SRESTORED:
#ifdef INCLUDE_MAXIMIZE
line[tend+1] = DF_MAXPOINTER;
#endif
#ifdef INCLUDE_MINIMIZE
line[tend] = DF_MINPOINTER;
#endif
break;
#ifdef INCLUDE_MINIMIZE
case DF_ISMINIMIZED:
line[tend+1] = DF_MAXPOINTER;
break;
#endif
#ifdef INCLUDE_MAXIMIZE
case DF_ISMAXIMIZED:
#ifdef INCLUDE_MINIMIZE
line[tend] = DF_MINPOINTER;
#endif
#ifdef INCLUDE_RESTORE
line[tend+1] = DF_RESTOREPOINTER;
#endif
break;
#endif
default:
break;
}
}
line[DfRectRight(rc)+1] = line[tend+3] = '\0';
if (wnd != DfInFocus)
DfClipString++;
DfWriteLine(wnd, line+DfRectLeft(rc),
DfRectLeft(rc)+DfBorderAdj(wnd),
0,
FALSE);
DfClipString = 0;
}
}
}
/* --- display right border shadow character of a window --- */
static void shadow_char(DFWINDOW wnd, int y)
{
int fg = DfForeground;
int bg = DfBackground;
int x = DfWindowWidth(wnd);
char c = DfVideoChar(DfGetLeft(wnd)+x, DfGetTop(wnd)+y);
if (DfTestAttribute(wnd, DF_SHADOW) == 0)
return;
DfForeground = DARKGRAY;
DfBackground = BLACK;
DfWPutch(wnd, c, x, y);
DfForeground = fg;
DfBackground = bg;
}
/* --- display the bottom border shadow line for a window -- */
static void shadowline(DFWINDOW wnd, DFRECT rc)
{
int i;
int y = DfGetBottom(wnd)+1;
int fg = DfForeground;
int bg = DfBackground;
if ((DfTestAttribute(wnd, DF_SHADOW)) == 0)
return;
for (i = 0; i < DfWindowWidth(wnd)+1; i++)
line[i] = DfVideoChar(DfGetLeft(wnd)+i, y);
line[i] = '\0';
DfForeground = DARKGRAY;
DfBackground = BLACK;
line[DfRectRight(rc)+1] = '\0';
if (DfRectLeft(rc) == 0)
rc.lf++;
DfClipString++;
DfWPuts(wnd, line+DfRectLeft(rc), DfRectLeft(rc),
DfWindowHeight(wnd));
--DfClipString;
DfForeground = fg;
DfBackground = bg;
}
static DFRECT ParamRect(DFWINDOW wnd, DFRECT *rcc)
{
DFRECT rc;
if (rcc == NULL) {
rc = DfRelativeWindowRect(wnd, DfWindowRect(wnd));
if (DfTestAttribute(wnd, DF_SHADOW)) {
rc.rt++;
rc.bt++;
}
}
else
rc = *rcc;
return rc;
}
void DfPaintShadow(DFWINDOW wnd)
{
int y;
DFRECT rc = ParamRect(wnd, NULL);
for (y = 1; y < DfWindowHeight(wnd); y++)
shadow_char(wnd, y);
shadowline(wnd, rc);
}
/* ------- display a window's border ----- */
void DfRepaintBorder(DFWINDOW wnd, DFRECT *rcc)
{
int y;
char lin, side, ne, nw, se, sw;
DFRECT rc, clrc;
if (!DfTestAttribute(wnd, DF_HASBORDER))
return;
rc = ParamRect(wnd, rcc);
clrc = DfAdjustRectangle(wnd, rc);
if (wnd == DfInFocus) {
lin = DF_FOCUS_LINE;
side = DF_FOCUS_SIDE;
ne = DF_FOCUS_NE;
nw = DF_FOCUS_NW;
se = DF_FOCUS_SE;
sw = DF_FOCUS_SW;
}
else {
lin = DF_LINE;
side = DF_SIDE;
ne = DF_NE;
nw = DF_NW;
se = DF_SE;
sw = DF_SW;
}
line[DfWindowWidth(wnd)] = '\0';
/* ---------- window title ------------ */
if (DfTestAttribute(wnd, DF_HASTITLEBAR))
if (DfRectTop(rc) == 0)
if (DfRectLeft(rc) < DfWindowWidth(wnd)-DfBorderAdj(wnd))
DfDisplayTitle(wnd, &rc);
DfForeground = DfFrameForeground(wnd);
DfBackground = DfFrameBackground(wnd);
/* -------- top frame corners --------- */
if (DfRectTop(rc) == 0) {
if (DfRectLeft(rc) == 0)
DfWPutch(wnd, nw, 0, 0);
if (DfRectLeft(rc) < DfWindowWidth(wnd)) {
if (DfRectRight(rc) >= DfWindowWidth(wnd)-1)
DfWPutch(wnd, ne, DfWindowWidth(wnd)-1, 0);
TopLine(wnd, lin, clrc);
}
}
/* ----------- window body ------------ */
for (y = DfRectTop(rc); y <= DfRectBottom(rc); y++) {
char ch;
if (y == 0 || y >= DfWindowHeight(wnd)-1)
continue;
if (DfRectLeft(rc) == 0)
DfWPutch(wnd, side, 0, y);
if (DfRectLeft(rc) < DfWindowWidth(wnd) &&
DfRectRight(rc) >= DfWindowWidth(wnd)-1) {
if (DfTestAttribute(wnd, DF_VSCROLLBAR))
ch = ( y == 1 ? DF_UPSCROLLBOX :
y == DfWindowHeight(wnd)-2 ?
DF_DOWNSCROLLBOX :
y-1 == wnd->VScrollBox ?
DF_SCROLLBOXCHAR :
DF_SCROLLBARCHAR );
else
ch = side;
DfWPutch(wnd, ch, DfWindowWidth(wnd)-1, y);
}
if (DfRectRight(rc) == DfWindowWidth(wnd))
shadow_char(wnd, y);
}
if (DfRectTop(rc) <= DfWindowHeight(wnd)-1 &&
DfRectBottom(rc) >= DfWindowHeight(wnd)-1) {
/* -------- bottom frame corners ---------- */
if (DfRectLeft(rc) == 0)
DfWPutch(wnd, sw, 0, DfWindowHeight(wnd)-1);
if (DfRectLeft(rc) < DfWindowWidth(wnd) &&
DfRectRight(rc) >= DfWindowWidth(wnd)-1)
DfWPutch(wnd, se, DfWindowWidth(wnd)-1,
DfWindowHeight(wnd)-1);
if (wnd->StatusBar == NULL) {
/* ----------- bottom line ------------- */
memset(line,lin,DfWindowWidth(wnd)-1);
if (DfTestAttribute(wnd, DF_HSCROLLBAR)) {
line[0] = DF_LEFTSCROLLBOX;
line[DfWindowWidth(wnd)-3] = DF_RIGHTSCROLLBOX;
memset(line+1, DF_SCROLLBARCHAR, DfWindowWidth(wnd)-4);
line[wnd->HScrollBox] = DF_SCROLLBOXCHAR;
}
line[DfWindowWidth(wnd)-2] = line[DfRectRight(rc)] = '\0';
if (DfRectLeft(rc) != DfRectRight(rc) ||
(DfRectLeft(rc) && DfRectLeft(rc) < DfWindowWidth(wnd)-1))
{
if (wnd != DfInFocus)
DfClipString++;
DfWriteLine(wnd,
line+(DfRectLeft(clrc)),
DfRectLeft(clrc)+1,
DfWindowHeight(wnd)-1,
FALSE);
DfClipString = 0;
}
}
if (DfRectRight(rc) == DfWindowWidth(wnd))
shadow_char(wnd, DfWindowHeight(wnd)-1);
}
if (DfRectBottom(rc) == DfWindowHeight(wnd))
/* ---------- bottom shadow ------------- */
shadowline(wnd, rc);
}
static void TopLine(DFWINDOW wnd, int lin, DFRECT rc)
{
if (DfTestAttribute(wnd, DF_HASMENUBAR))
return;
if (DfTestAttribute(wnd, DF_HASTITLEBAR) && DfGetTitle(wnd))
return;
if (DfRectLeft(rc) == 0) {
DfRectLeft(rc) += DfBorderAdj(wnd);
DfRectRight(rc) += DfBorderAdj(wnd);
}
if (DfRectRight(rc) < DfWindowWidth(wnd)-1)
DfRectRight(rc)++;
if (DfRectLeft(rc) < DfRectRight(rc)) {
/* ----------- top line ------------- */
memset(line,lin,DfWindowWidth(wnd)-1);
if (DfTestAttribute(wnd, DF_CONTROLBOX)) {
strncpy(line+1, " ", 3);
*(line+2) = DF_CONTROLBOXCHAR;
}
line[DfRectRight(rc)] = '\0';
DfWriteLine(wnd, line+DfRectLeft(rc),
DfRectLeft(rc), 0, FALSE);
}
}
/* ------ clear the data space of a window -------- */
void DfClearWindow(DFWINDOW wnd, DFRECT *rcc, int clrchar)
{
if (DfIsVisible(wnd)) {
int y;
DFRECT rc;
if (rcc == NULL)
rc = DfRelativeWindowRect(wnd, DfWindowRect(wnd));
else
rc = *rcc;
if (DfRectLeft(rc) == 0)
DfRectLeft(rc) = DfBorderAdj(wnd);
if (DfRectRight(rc) > DfWindowWidth(wnd)-1)
DfRectRight(rc) = DfWindowWidth(wnd)-1;
DfSetStandardColor(wnd);
memset(line, clrchar, sizeof line);
line[DfRectRight(rc)+1] = '\0';
for (y = DfRectTop(rc); y <= DfRectBottom(rc); y++)
{
if (y < DfTopBorderAdj(wnd) ||
y > DfClientHeight(wnd)+
(DfTestAttribute(wnd, DF_HASMENUBAR) ? 1 : 0))
continue;
DfWriteLine(wnd,
line+(DfRectLeft(rc)),
DfRectLeft(rc),
y,
FALSE);
}
}
}
/* ------ compute the logical line length of a window ------ */
int DfLineLength(char *ln)
{
int len = strlen(ln);
char *cp = ln;
while ((cp = strchr(cp, DF_CHANGECOLOR)) != NULL)
{
cp++;
len -= 3;
}
cp = ln;
while ((cp = strchr(cp, DF_RESETCOLOR)) != NULL)
{
cp++;
--len;
}
return len;
}
void DfInitWindowColors(DFWINDOW wnd)
{
int fbg,col;
int cls = DfGetClass(wnd);
/* window classes without assigned colors inherit parent's colors */
if (DfCfg.clr[cls][0][0] == 0xff && DfGetParent(wnd) != NULL)
cls = DfGetClass(DfGetParent(wnd));
/* ---------- set the colors ---------- */
for (fbg = 0; fbg < 2; fbg++)
for (col = 0; col < 4; col++)
wnd->WindowColors[col][fbg] = DfCfg.clr[cls][col][fbg];
}
void DfPutWindowChar(DFWINDOW wnd, char c, int x, int y)
{
if (x < DfClientWidth(wnd) && y < DfClientHeight(wnd))
DfWPutch(wnd, c, x+DfBorderAdj(wnd), y+DfTopBorderAdj(wnd));
}
void DfPutWindowLine(DFWINDOW wnd, void *s, int x, int y)
{
int saved = FALSE;
int sv = 0;
if (x < DfClientWidth(wnd) && y < DfClientHeight(wnd))
{
char *en = (char *)s+DfClientWidth(wnd)-x;
if ((int)(strlen(s)+x) > (int)DfClientWidth(wnd))
{
sv = *en;
*en = '\0';
saved = TRUE;
}
DfClipString++;
DfWPuts(wnd, s, x+DfBorderAdj(wnd), y+DfTopBorderAdj(wnd));
--DfClipString;
if (saved)
*en = sv;
}
}
/* EOF */
rosapps/directory.rbuild
-4
View File
@@ -9,10 +9,6 @@
<xi:include href="demos/directory.rbuild" />
</directory>
<directory name="dflat32">
<xi:include href="dflat32/dflat32.rbuild" />
</directory>
<directory name="drivers">
<xi:include href="drivers/directory.rbuild" />
</directory>
rosapps/lib/dflat32/Makefile
-60
View File
@@ -1,60 +0,0 @@
PATH_TO_TOP = ../..
TARGET_DEFONLY = yes
TARGET_TYPE = dynlink
TARGET_NAME = dflat32
TARGET_LFLAGS =
TARGET_SDKLIBS =
TARGET_GCCLIBS =
TARGET_BASE = 0x98000000
TARGET_CFLAGS = # -pipe -O2 -Wall -Wstrict-prototypes -fno-builtin -DDBG
TARGET_OBJECTS = \
applicat.o \
box.o \
checkbox.o \
clipbord.o \
config.o \
console.o \
decomp.o \
dfalloc.o \
dialbox.o \
dialogs.o \
dllmain.o \
editbox.o \
lists.o \
helpbox.o \
listbox.o \
log.o \
message.o \
menu.o \
menubar.o \
menus.o \
msgbox.o \
normal.o \
pictbox.o \
popdown.o \
keys.o \
radio.o \
rect.o \
spinbutt.o \
statbar.o \
stubs.o\
sysmenu.o \
text.o \
textbox.o \
video.o \
watch.o \
window.o
include $(PATH_TO_TOP)/rules.mak
include $(TOOLS_PATH)/helper.mk
rosapps/lib/dflat32/applicat.c
-622
View File
@@ -1,622 +0,0 @@
/* ------------- applicat.c ------------- */
#include "dflat32/dflat.h"
static BOOL DisplayModified = FALSE;
DFWINDOW ApplicationWindow;
extern DBOX Display;
extern DBOX Windows;
#ifdef INCLUDE_LOGGING
extern DBOX Log;
#endif
#ifdef INCLUDE_SHELLDOS
static void ShellDOS(DFWINDOW);
#endif
static void DfCreateMenu(DFWINDOW);
static void CreateStatusBar(DFWINDOW);
static void SelectColors(DFWINDOW);
#ifdef INCLUDE_WINDOWOPTIONS
static void SelectTexture(void);
static void SelectBorder(DFWINDOW);
static void SelectTitle(DFWINDOW);
static void SelectStatusBar(DFWINDOW);
#endif
static DFWINDOW oldFocus;
#ifdef INCLUDE_MULTI_WINDOWS
static void CloseAll(DFWINDOW, int);
static void MoreWindows(DFWINDOW);
static void ChooseWindow(DFWINDOW, int);
static int WindowSel;
static char Menus[9][26] =
{
"~1. ",
"~2. ",
"~3. ",
"~4. ",
"~5. ",
"~6. ",
"~7. ",
"~8. ",
"~9. "
};
#endif
/* --------------- CREATE_WINDOW Message -------------- */
static int CreateWindowMsg(DFWINDOW wnd)
{
int rtn;
ApplicationWindow = wnd;
#ifdef INCLUDE_WINDOWOPTIONS
if (cfg.Border)
SetCheckBox(&Display, ID_BORDER);
if (cfg.Title)
SetCheckBox(&Display, ID_TITLE);
if (cfg.StatusBar)
SetCheckBox(&Display, ID_STATUSBAR);
if (cfg.Texture)
SetCheckBox(&Display, ID_TEXTURE);
#endif
SelectColors(wnd);
#ifdef INCLUDE_WINDOWOPTIONS
SelectBorder(wnd);
SelectTitle(wnd);
SelectStatusBar(wnd);
#endif
rtn = BaseWndProc(APPLICATION, wnd, CREATE_WINDOW, 0, 0);
if (wnd->extension != NULL)
DfCreateMenu(wnd);
CreateStatusBar(wnd);
return rtn;
}
/* --------- ADDSTATUS Message ---------- */
static void AddStatusMsg(DFWINDOW wnd, PARAM p1)
{
if (wnd->StatusBar != NULL) {
if (p1 && *(char *)p1)
DfSendMessage(wnd->StatusBar, SETTEXT, p1, 0);
else
DfSendMessage(wnd->StatusBar, CLEARTEXT, 0, 0);
DfSendMessage(wnd->StatusBar, PAINT, 0, 0);
}
}
/* -------- SETFOCUS Message -------- */
static void SetFocusMsg(DFWINDOW wnd, BOOL p1)
{
if (p1)
DfSendMessage(inFocus, SETFOCUS, FALSE, 0);
inFocus = p1 ? wnd : NULL;
if (isVisible(wnd))
DfSendMessage(wnd, BORDER, 0, 0);
else
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
}
/* ------- SIZE Message -------- */
static void SizeMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
BOOL WasVisible;
WasVisible = isVisible(wnd);
if (WasVisible)
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
if (p1-GetLeft(wnd) < 30)
p1 = GetLeft(wnd) + 30;
BaseWndProc(APPLICATION, wnd, DFM_SIZE, p1, p2);
DfCreateMenu(wnd);
CreateStatusBar(wnd);
if (WasVisible)
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
}
/* ----------- KEYBOARD Message ------------ */
static int KeyboardMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
if (WindowMoving || WindowSizing || (int) p1 == F1)
return BaseWndProc(APPLICATION, wnd, KEYBOARD, p1, p2);
switch ((int) p1) {
case ALT_F4:
DfPostMessage(wnd, CLOSE_WINDOW, 0, 0);
return TRUE;
#ifdef INCLUDE_MULTI_WINDOWS
case ALT_F6:
SetNextFocus();
return TRUE;
#endif
case ALT_HYPHEN:
BuildSystemMenu(wnd);
return TRUE;
default:
break;
}
DfPostMessage(wnd->MenuBarWnd, KEYBOARD, p1, p2);
return TRUE;
}
/* --------- SHIFT_CHANGED Message -------- */
static void ShiftChangedMsg(DFWINDOW wnd, PARAM p1)
{
extern BOOL AltDown;
if ((int)p1 & ALTKEY)
AltDown = TRUE;
else if (AltDown) {
AltDown = FALSE;
if (wnd->MenuBarWnd != inFocus)
DfSendMessage(NULL, HIDE_CURSOR, 0, 0);
DfSendMessage(wnd->MenuBarWnd, KEYBOARD, F10, 0);
}
}
/* -------- COMMAND Message ------- */
static void CommandMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
switch ((int)p1) {
case ID_HELP:
DisplayHelp(wnd, DFlatApplication);
break;
case ID_HELPHELP:
DisplayHelp(wnd, "HelpHelp");
break;
case ID_EXTHELP:
DisplayHelp(wnd, "ExtHelp");
break;
case ID_KEYSHELP:
DisplayHelp(wnd, "KeysHelp");
break;
case ID_HELPINDEX:
DisplayHelp(wnd, "HelpIndex");
break;
#ifdef TESTING_DFLAT
case ID_LOADHELP:
LoadHelpFile();
break;
#endif
#ifdef INCLUDE_LOGGING
case ID_LOG:
MessageLog(wnd);
break;
#endif
#ifdef INCLUDE_SHELLDOS
case ID_DOS:
ShellDOS(wnd);
break;
#endif
case ID_EXIT:
case ID_SYSCLOSE:
DfPostMessage(wnd, CLOSE_WINDOW, 0, 0);
break;
case ID_DISPLAY:
if (DfDialogBox(wnd, &Display, TRUE, NULL)) {
if (inFocus == wnd->MenuBarWnd || inFocus == wnd->StatusBar)
oldFocus = ApplicationWindow;
else
oldFocus = inFocus;
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
SelectColors(wnd);
#ifdef INCLUDE_WINDOWOPTIONS
SelectBorder(wnd);
SelectTitle(wnd);
SelectStatusBar(wnd);
SelectTexture();
#endif
DfCreateMenu(wnd);
CreateStatusBar(wnd);
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
DfSendMessage(oldFocus, SETFOCUS, TRUE, 0);
}
break;
case ID_SAVEOPTIONS:
SaveConfig();
break;
#ifdef INCLUDE_MULTI_WINDOWS
case ID_WINDOW:
ChooseWindow(wnd, (int)p2-2);
break;
case ID_CLOSEALL:
CloseAll(wnd, FALSE);
break;
case ID_MOREWINDOWS:
MoreWindows(wnd);
break;
#endif
#ifdef INCLUDE_RESTORE
case ID_SYSRESTORE:
#endif
case ID_SYSMOVE:
case ID_SYSSIZE:
#ifdef INCLUDE_MINIMIZE
case ID_SYSMINIMIZE:
#endif
#ifdef INCLUDE_MAXIMIZE
case ID_SYSMAXIMIZE:
#endif
BaseWndProc(APPLICATION, wnd, DFM_COMMAND, p1, p2);
break;
default:
if (inFocus != wnd->MenuBarWnd && inFocus != wnd)
DfPostMessage(inFocus, DFM_COMMAND, p1, p2);
break;
}
}
/* --------- CLOSE_WINDOW Message -------- */
static int CloseWindowMsg(DFWINDOW wnd)
{
int rtn;
#ifdef INCLUDE_MULTI_WINDOWS
CloseAll(wnd, TRUE);
WindowSel = 0;
#endif
DfPostMessage(NULL, DFM_STOP, 0, 0);
rtn = BaseWndProc(APPLICATION, wnd, CLOSE_WINDOW, 0, 0);
UnLoadHelpFile();
DisplayModified = FALSE;
ApplicationWindow = NULL;
return rtn;
}
/* --- APPLICATION Window Class window processing module --- */
int ApplicationProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg)
{
case CREATE_WINDOW:
return CreateWindowMsg(wnd);
case DFM_HIDE_WINDOW:
if (wnd == inFocus)
inFocus = NULL;
break;
case ADDSTATUS:
AddStatusMsg(wnd, p1);
return TRUE;
case SETFOCUS:
if ((int)p1 == (inFocus != wnd)) {
SetFocusMsg(wnd, (BOOL) p1);
return TRUE;
}
break;
case DFM_SIZE:
SizeMsg(wnd, p1, p2);
return TRUE;
#ifdef INCLUDE_MINIMIZE
case MINIMIZE:
return TRUE;
#endif
case KEYBOARD:
return KeyboardMsg(wnd, p1, p2);
case SHIFT_CHANGED:
ShiftChangedMsg(wnd, p1);
return TRUE;
case PAINT:
if (isVisible(wnd)) {
#ifdef INCLUDE_WINDOWOPTIONS
int cl = cfg.Texture ? APPLCHAR : ' ';
#else
int cl = APPLCHAR;
#endif
ClearWindow(wnd, (DFRECT *)p1, cl);
}
return TRUE;
case DFM_COMMAND:
CommandMsg(wnd, p1, p2);
return TRUE;
case CLOSE_WINDOW:
return CloseWindowMsg(wnd);
default:
break;
}
return BaseWndProc(APPLICATION, wnd, msg, p1, p2);
}
#ifdef INCLUDE_SHELLDOS
static void SwitchCursor(void)
{
DfSendMessage(NULL, SAVE_CURSOR, 0, 0);
SwapCursorStack();
DfSendMessage(NULL, RESTORE_CURSOR, 0, 0);
}
/* ------- Shell out to DOS ---------- */
static void ShellDOS(DFWINDOW wnd)
{
oldFocus = inFocus;
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
SwitchCursor();
printf("To return to %s, execute the DOS exit command.",
DFlatApplication);
fflush(stdout);
_spawnl(P_WAIT, getenv("COMSPEC"), " ", NULL);
SwitchCursor();
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
DfSendMessage(oldFocus, SETFOCUS, TRUE, 0);
}
#endif
/* -------- Create the menu bar -------- */
static void DfCreateMenu(DFWINDOW wnd)
{
AddAttribute(wnd, HASMENUBAR);
if (wnd->MenuBarWnd != NULL)
DfSendMessage(wnd->MenuBarWnd, CLOSE_WINDOW, 0, 0);
wnd->MenuBarWnd = DfCreateWindow(MENUBAR,
NULL,
GetClientLeft(wnd),
GetClientTop(wnd)-1,
1,
ClientWidth(wnd),
NULL,
wnd,
NULL,
0);
DfSendMessage(wnd->MenuBarWnd,BUILDMENU,
(PARAM)wnd->extension,0);
AddAttribute(wnd->MenuBarWnd, VISIBLE);
}
/* ----------- Create the status bar ------------- */
static void CreateStatusBar(DFWINDOW wnd)
{
if (wnd->StatusBar != NULL) {
DfSendMessage(wnd->StatusBar, CLOSE_WINDOW, 0, 0);
wnd->StatusBar = NULL;
}
if (TestAttribute(wnd, HASSTATUSBAR)) {
wnd->StatusBar = DfCreateWindow(STATUSBAR,
NULL,
GetClientLeft(wnd),
GetBottom(wnd),
1,
ClientWidth(wnd),
NULL,
wnd,
NULL,
0);
AddAttribute(wnd->StatusBar, VISIBLE);
}
}
#ifdef INCLUDE_MULTI_WINDOWS
/* -------- return the name of a document window ------- */
static char *WindowName(DFWINDOW wnd)
{
if (GetTitle(wnd) == NULL)
{
if (GetClass(wnd) == DIALOG)
return ((DBOX *)(wnd->extension))->HelpName;
else
return "Untitled";
}
else
return GetTitle(wnd);
}
/* ----------- Prepare the Window menu ------------ */
void PrepWindowMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
struct PopDown *p0 = mnu->Selections;
struct PopDown *pd = mnu->Selections + 2;
struct PopDown *ca = mnu->Selections + 13;
int MenuNo = 0;
DFWINDOW cwnd;
mnu->Selection = 0;
oldFocus = NULL;
if (GetClass(wnd) != APPLICATION)
{
oldFocus = wnd;
/* point to the APPLICATION window */
if (ApplicationWindow == NULL)
return;
cwnd = FirstWindow(ApplicationWindow);
/* get the first 9 document windows */
while (cwnd != NULL && MenuNo < 9)
{
if (GetClass(cwnd) != MENUBAR &&
GetClass(cwnd) != STATUSBAR)
{
/* add the document window to the menu */
strncpy (Menus[MenuNo]+4, WindowName(cwnd), 20);
pd->SelectionTitle = Menus[MenuNo];
if (cwnd == oldFocus)
{
/* mark the current document */
pd->Attrib |= CHECKED;
mnu->Selection = MenuNo+2;
}
else
pd->Attrib &= ~CHECKED;
pd++;
MenuNo++;
}
cwnd = NextWindow(cwnd);
}
}
if (MenuNo)
p0->SelectionTitle = "~Close all";
else
p0->SelectionTitle = NULL;
if (MenuNo >= 9)
{
*pd++ = *ca;
if (mnu->Selection == 0)
mnu->Selection = 11;
}
pd->SelectionTitle = NULL;
}
/* window processing module for the More Windows dialog box */
static int WindowPrep(DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2)
{
switch (msg) {
case INITIATE_DIALOG: {
DFWINDOW wnd1;
DFWINDOW cwnd = ControlWindow(&Windows,ID_WINDOWLIST);
int sel = 0;
if (cwnd == NULL)
return FALSE;
wnd1 = FirstWindow(ApplicationWindow);
while (wnd1 != NULL) {
if (wnd1 != wnd && GetClass(wnd1) != MENUBAR &&
GetClass(wnd1) != STATUSBAR) {
if (wnd1 == oldFocus)
WindowSel = sel;
DfSendMessage(cwnd, ADDTEXT,
(PARAM) WindowName(wnd1), 0);
sel++;
}
wnd1 = NextWindow(wnd1);
}
DfSendMessage(cwnd, LB_SETSELECTION, WindowSel, 0);
AddAttribute(cwnd, VSCROLLBAR);
DfPostMessage(cwnd, SHOW_WINDOW, 0, 0);
break;
}
case DFM_COMMAND:
switch ((int) p1) {
case ID_OK:
if ((int)p2 == 0)
WindowSel = DfSendMessage(
ControlWindow(&Windows,
ID_WINDOWLIST),
LB_CURRENTSELECTION, 0, 0);
break;
case ID_WINDOWLIST:
if ((int) p2 == LB_CHOOSE)
DfSendMessage(wnd, DFM_COMMAND, ID_OK, 0);
break;
default:
break;
}
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
/* ---- the More Windows command on the Window menu ---- */
static void MoreWindows(DFWINDOW wnd)
{
if (DfDialogBox(wnd, &Windows, TRUE, WindowPrep))
ChooseWindow(wnd, WindowSel);
}
/* ----- user chose a window from the Window menu
or the More Window dialog box ----- */
static void ChooseWindow(DFWINDOW wnd, int WindowNo)
{
DFWINDOW cwnd = FirstWindow(wnd);
while (cwnd != NULL)
{
if (GetClass(cwnd) != MENUBAR &&
GetClass(cwnd) != STATUSBAR)
if (WindowNo-- == 0)
break;
cwnd = NextWindow(cwnd);
}
if (cwnd != NULL) {
DfSendMessage(cwnd, SETFOCUS, TRUE, 0);
if (cwnd->condition == ISMINIMIZED)
DfSendMessage(cwnd, RESTORE, 0, 0);
}
}
/* ----- Close all document windows ----- */
static void CloseAll(DFWINDOW wnd, int closing)
{
DFWINDOW wnd1, wnd2;
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
wnd1 = LastWindow(wnd);
while (wnd1 != NULL)
{
wnd2 = PrevWindow(wnd1);
if (GetClass(wnd1) != MENUBAR && GetClass(wnd1) != STATUSBAR)
{
ClearVisible(wnd1);
DfSendMessage(wnd1, CLOSE_WINDOW, 0, 0);
}
wnd1 = wnd2;
}
if (!closing)
DfSendMessage(wnd, PAINT, 0, 0);
}
#endif /* #ifdef INCLUDE_MULTI_WINDOWS */
static void DoWindowColors(DFWINDOW wnd)
{
DFWINDOW cwnd;
InitWindowColors(wnd);
cwnd = FirstWindow(wnd);
while (cwnd != NULL)
{
DoWindowColors(cwnd);
if (GetClass(cwnd) == TEXT && GetText(cwnd) != NULL)
DfSendMessage(cwnd, CLEARTEXT, 0, 0);
cwnd = NextWindow(cwnd);
}
}
/* set up colors for the application window */
static void SelectColors(DFWINDOW wnd)
{
memcpy(cfg.clr, color, sizeof color);
DoWindowColors(wnd);
}
#ifdef INCLUDE_WINDOWOPTIONS
/* ----- select the screen texture ----- */
static void SelectTexture(void)
{
cfg.Texture = CheckBoxSetting(&Display, ID_TEXTURE);
}
/* -- select whether the application screen has a border -- */
static void SelectBorder(DFWINDOW wnd)
{
cfg.Border = CheckBoxSetting(&Display, ID_BORDER);
if (cfg.Border)
AddAttribute(wnd, HASBORDER);
else
ClearAttribute(wnd, HASBORDER);
}
/* select whether the application screen has a status bar */
static void SelectStatusBar(DFWINDOW wnd)
{
cfg.StatusBar = CheckBoxSetting(&Display, ID_STATUSBAR);
if (cfg.StatusBar)
AddAttribute(wnd, HASSTATUSBAR);
else
ClearAttribute(wnd, HASSTATUSBAR);
}
/* select whether the application screen has a title bar */
static void SelectTitle(DFWINDOW wnd)
{
cfg.Title = CheckBoxSetting(&Display, ID_TITLE);
if (cfg.Title)
AddAttribute(wnd, HASTITLEBAR);
else
ClearAttribute(wnd, HASTITLEBAR);
}
#endif
/* EOF */
rosapps/lib/dflat32/box.c
-44
View File
@@ -1,44 +0,0 @@
/* ----------- box.c ------------ */
#include "dflat32/dflat.h"
int BoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
DFWINDOW oldFocus;
CTLWINDOW *ct = GetControl(wnd);
static BOOL SettingFocus = FALSE;
if (ct != NULL)
{
switch (msg)
{
case SETFOCUS:
SettingFocus = isVisible(wnd);
rtn = BaseWndProc(BOX, wnd, msg, p1, p2);
SettingFocus = FALSE;
return rtn;
case PAINT:
return FALSE;
case LEFT_BUTTON:
case DFM_BUTTON_RELEASED:
return DfSendMessage(GetParent(wnd), msg, p1, p2);
case BORDER:
if (SettingFocus)
return TRUE;
oldFocus = inFocus;
inFocus = NULL;
rtn = BaseWndProc(BOX, wnd, msg, p1, p2);
inFocus = oldFocus;
if (ct != NULL)
if (ct->itext != NULL)
writeline(wnd, ct->itext, 1, 0, FALSE);
return rtn;
default:
break;
}
}
return BaseWndProc(BOX, wnd, msg, p1, p2);
}
/* EOF */
rosapps/lib/dflat32/checkbox.c
-49
View File
@@ -1,49 +0,0 @@
/* -------------- checkbox.c ------------ */
#include "dflat32/dflat.h"
int CheckBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
CTLWINDOW *ct = GetControl(wnd);
if (ct != NULL) {
switch (msg) {
case SETFOCUS:
if (!(int)p1)
DfSendMessage(NULL, HIDE_CURSOR, 0, 0);
case MOVE:
rtn = BaseWndProc(CHECKBOX, wnd, msg, p1, p2);
SetFocusCursor(wnd);
return rtn;
case PAINT: {
char cb[] = "[ ]";
if (ct->setting)
cb[1] = 'X';
DfSendMessage(wnd, CLEARTEXT, 0, 0);
DfSendMessage(wnd, ADDTEXT, (PARAM) cb, 0);
SetFocusCursor(wnd);
break;
}
case KEYBOARD:
if ((int)p1 != ' ')
break;
case LEFT_BUTTON:
ct->setting ^= ON;
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
default:
break;
}
}
return BaseWndProc(CHECKBOX, wnd, msg, p1, p2);
}
BOOL CheckBoxSetting(DBOX *db, enum commands cmd)
{
CTLWINDOW *ct = FindCommand(db, cmd, CHECKBOX);
if (ct != NULL)
return (ct->isetting == ON);
return FALSE;
}
/* EOF */
rosapps/lib/dflat32/clipbord.c
-54
View File
@@ -1,54 +0,0 @@
/* ----------- clipbord.c ------------ */
#include "dflat32/dflat.h"
char *Clipboard;
unsigned ClipboardLength;
void CopyTextToClipboard(char *text)
{
ClipboardLength = strlen(text);
Clipboard = DFrealloc(Clipboard, ClipboardLength);
memmove(Clipboard, text, ClipboardLength);
}
void CopyToClipboard(DFWINDOW wnd)
{
if (TextBlockMarked(wnd)) {
char *bbl=TextLine(wnd,wnd->BlkBegLine)+wnd->BlkBegCol;
char *bel=TextLine(wnd,wnd->BlkEndLine)+wnd->BlkEndCol;
ClipboardLength = (int) (bel - bbl);
Clipboard = DFrealloc(Clipboard, ClipboardLength);
memmove(Clipboard, bbl, ClipboardLength);
}
}
void ClearClipboard(void)
{
if (Clipboard != NULL) {
free(Clipboard);
Clipboard = NULL;
}
}
BOOL PasteText(DFWINDOW wnd, char *SaveTo, unsigned len)
{
if (SaveTo != NULL && len > 0) {
unsigned plen = strlen(wnd->text) + len;
if (plen <= wnd->MaxTextLength) {
if (plen+1 > wnd->textlen) {
wnd->text = DFrealloc(wnd->text, plen+3);
wnd->textlen = plen+1;
}
memmove(CurrChar+len, CurrChar, strlen(CurrChar)+1);
memmove(CurrChar, SaveTo, len);
BuildTextPointers(wnd);
wnd->TextChanged = TRUE;
return TRUE;
}
}
return FALSE;
}
/* EOF */
rosapps/lib/dflat32/config.c
-514
View File
@@ -1,514 +0,0 @@
/* ------------- config.c ------------- */
#include "dflat32/dflat.h"
/* ----- default colors for color video system ----- */
unsigned char color[CLASSCOUNT] [4] [2] = {
/* ------------ NORMAL ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* HILITE_COLOR */
/* ---------- APPLICATION --------- */
{{LIGHTGRAY, BLUE}, /* STD_COLOR */
{LIGHTGRAY, BLUE}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* HILITE_COLOR */
/* ------------ TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------ LISTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- EDITBOX ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLUE}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- MENUBAR ------------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, CYAN}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{DARKGRAY, RED}}, /* HILITE_COLOR
Inactive, Shortcut (both FG) */
/* ---------- POPDOWNMENU --------- */
{{BLACK, CYAN}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, CYAN}, /* FRAME_COLOR */
{DARKGRAY, RED}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
#endif
/* ------------- DIALOG ----------- */
{{LIGHTGRAY, BLUE}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* HILITE_COLOR */
/* ------------ BOX --------------- */
{{LIGHTGRAY, BLUE}, /* STD_COLOR */
{LIGHTGRAY, BLUE}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* HILITE_COLOR */
/* ------------ BUTTON ------------ */
{{BLACK, CYAN}, /* STD_COLOR */
{WHITE, CYAN}, /* SELECT_COLOR */
{BLACK, CYAN}, /* FRAME_COLOR */
{DARKGRAY, RED}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
/* ------------ COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------- TEXT ----------- */
{{0xff, 0xff}, /* STD_COLOR */
{0xff, 0xff}, /* SELECT_COLOR */
{0xff, 0xff}, /* FRAME_COLOR */
{0xff, 0xff}}, /* HILITE_COLOR */
/* ------------- RADIOBUTTON ----------- */
{{LIGHTGRAY, BLUE}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* HILITE_COLOR */
/* ------------- CHECKBOX ----------- */
{{LIGHTGRAY, BLUE}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLUE}, /* FRAME_COLOR */
{LIGHTGRAY, BLUE}}, /* HILITE_COLOR */
/* ------------ SPINBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- ERRORBOX ----------- */
{{YELLOW, RED}, /* STD_COLOR */
{YELLOW, RED}, /* SELECT_COLOR */
{YELLOW, RED}, /* FRAME_COLOR */
{YELLOW, RED}}, /* HILITE_COLOR */
/* ----------- MESSAGEBOX --------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- HELPBOX ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLUE}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- STATUSBAR ------------- */
{{BLACK, CYAN}, /* STD_COLOR */
{BLACK, CYAN}, /* SELECT_COLOR */
{BLACK, CYAN}, /* FRAME_COLOR */
{BLACK, CYAN}}, /* HILITE_COLOR */
/* ---------- TITLEBAR ------------ */
{{BLACK, CYAN}, /* STD_COLOR */
{BLACK, CYAN}, /* SELECT_COLOR */
{BLACK, CYAN}, /* FRAME_COLOR */
{WHITE, CYAN}}, /* HILITE_COLOR */
/* ------------ DUMMY ------------- */
{{GREEN, LIGHTGRAY}, /* STD_COLOR */
{GREEN, LIGHTGRAY}, /* SELECT_COLOR */
{GREEN, LIGHTGRAY}, /* FRAME_COLOR */
{GREEN, LIGHTGRAY}} /* HILITE_COLOR */
};
/* ----- default colors for mono video system ----- */
unsigned char bw[CLASSCOUNT] [4] [2] = {
/* ------------ NORMAL ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* HILITE_COLOR */
/* ---------- APPLICATION --------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* HILITE_COLOR */
/* ------------ TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------ LISTBOX ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- EDITBOX ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- MENUBAR ------------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive, Shortcut (both FG) */
/* ---------- POPDOWNMENU --------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
#endif
/* ------------- DIALOG ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ------------ BOX --------------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ------------ BUTTON ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{WHITE, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
/* ------------ COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------- TEXT ----------- */
{{0xff, 0xff}, /* STD_COLOR */
{0xff, 0xff}, /* SELECT_COLOR */
{0xff, 0xff}, /* FRAME_COLOR */
{0xff, 0xff}}, /* HILITE_COLOR */
/* ------------- RADIOBUTTON ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ------------- CHECKBOX ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ------------ SPINBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- ERRORBOX ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* HILITE_COLOR */
/* ----------- MESSAGEBOX --------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}},/* HILITE_COLOR */
/* ----------- HELPBOX ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{WHITE, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- STATUSBAR ------------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- TITLEBAR ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------ DUMMY ------------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}} /* HILITE_COLOR */
};
/* ----- default colors for reverse mono video ----- */
unsigned char reverse[CLASSCOUNT] [4] [2] = {
/* ------------ NORMAL ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- APPLICATION --------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------ TEXTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------ LISTBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- EDITBOX ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- MENUBAR ------------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive, Shortcut (both FG) */
/* ---------- POPDOWNMENU --------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
#ifdef INCLUDE_PICTUREBOX
/* ------------ PICTUREBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
#endif
/* ------------- DIALOG ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* HILITE_COLOR */
/* ------------ BOX --------------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* HILITE_COLOR */
/* ------------ BUTTON ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{WHITE, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{DARKGRAY, WHITE}}, /* HILITE_COLOR
Inactive ,Shortcut (both FG) */
/* ------------ COMBOBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ------------- TEXT ----------- */
{{0xff, 0xff}, /* STD_COLOR */
{0xff, 0xff}, /* SELECT_COLOR */
{0xff, 0xff}, /* FRAME_COLOR */
{0xff, 0xff}}, /* HILITE_COLOR */
/* ------------- RADIOBUTTON ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* HILITE_COLOR */
/* ------------- CHECKBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* HILITE_COLOR */
/* ------------ SPINBUTTON ----------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- ERRORBOX ----------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}}, /* HILITE_COLOR */
/* ----------- MESSAGEBOX --------- */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{BLACK, LIGHTGRAY}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{BLACK, LIGHTGRAY}},/* HILITE_COLOR */
/* ----------- HELPBOX ------------ */
{{BLACK, LIGHTGRAY}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{BLACK, LIGHTGRAY}, /* FRAME_COLOR */
{WHITE, LIGHTGRAY}},/* HILITE_COLOR */
/* ---------- STATUSBAR ------------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ---------- TITLEBAR ------------ */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}}, /* HILITE_COLOR */
/* ------------ DUMMY ------------- */
{{LIGHTGRAY, BLACK}, /* STD_COLOR */
{LIGHTGRAY, BLACK}, /* SELECT_COLOR */
{LIGHTGRAY, BLACK}, /* FRAME_COLOR */
{LIGHTGRAY, BLACK}} /* HILITE_COLOR */
};
/* ------ default configuration values ------- */
CONFIG cfg = {
VERSION,
TRUE, /* Editor Insert Mode */
4, /* Editor tab stops */
TRUE, /* Editor word wrap */
#ifdef INCLUDE_WINDOWOPTIONS
TRUE, /* Application Border */
TRUE, /* Application Title */
TRUE, /* Status Bar */
TRUE, /* Textured application window */
#endif
// 25, /* Number of screen lines */
"Lpt1", /* Printer Port */
66, /* Lines per printer page */
80, /* characters per printer line */
6, /* Left printer margin */
70, /* Right printer margin */
3, /* Top printer margin */
55 /* Bottom printer margin */
};
void BuildFileName(char *path, char *ext)
{
extern char **Argv;
char *cp;
strcpy(path, Argv[0]);
cp = strrchr(path, '\\');
if (cp == NULL)
cp = path;
else
cp++;
strcpy(cp, DFlatApplication);
strcat(cp, ext);
}
FILE *OpenConfig(char *mode)
{
char path[64];
BuildFileName(path, ".cfg");
return fopen(path, mode);
}
/* ------ load a configuration file from disk ------- */
BOOL LoadConfig(void)
{
static BOOL ConfigLoaded = FALSE;
if (ConfigLoaded == FALSE) {
FILE *fp = OpenConfig("rb");
if (fp != NULL) {
fread(cfg.version, sizeof cfg.version+1, 1, fp);
if (strcmp(cfg.version, VERSION) == 0) {
fseek(fp, 0L, SEEK_SET);
fread(&cfg, sizeof(CONFIG), 1, fp);
fclose(fp);
}
else {
char path[64];
BuildFileName(path, ".cfg");
fclose(fp);
unlink(path);
strcpy(cfg.version, VERSION);
}
ConfigLoaded = TRUE;
}
}
return ConfigLoaded;
}
/* ------ save a configuration file to disk ------- */
void SaveConfig(void)
{
FILE *fp = OpenConfig("wb");
if (fp != NULL) {
fwrite(&cfg, sizeof(CONFIG), 1, fp);
fclose(fp);
}
}
/* --------- set window colors --------- */
void SetStandardColor(DFWINDOW wnd)
{
foreground = WndForeground(wnd);
background = WndBackground(wnd);
}
void SetReverseColor(DFWINDOW wnd)
{
foreground = SelectForeground(wnd);
background = SelectBackground(wnd);
}
/* EOF */
rosapps/lib/dflat32/console.c
-217
View File
@@ -1,217 +0,0 @@
/* ----------- console.c ---------- */
// #define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "dflat32/dflat.h"
/* ----- table of alt keys for finding shortcut keys ----- */
#if 0
static int altconvert[] = {
ALT_A,ALT_B,ALT_C,ALT_D,ALT_E,ALT_F,ALT_G,ALT_H,
ALT_I,ALT_J,ALT_K,ALT_L,ALT_M,ALT_N,ALT_O,ALT_P,
ALT_Q,ALT_R,ALT_S,ALT_T,ALT_U,ALT_V,ALT_W,ALT_X,
ALT_Y,ALT_Z,ALT_0,ALT_1,ALT_2,ALT_3,ALT_4,ALT_5,
ALT_6,ALT_7,ALT_8,ALT_9
};
#endif
static COORD cursorpos[MAXSAVES];
static CONSOLE_CURSOR_INFO cursorinfo[MAXSAVES];
static int cs = 0;
void SwapCursorStack(void)
{
if (cs > 1)
{
COORD coord;
CONSOLE_CURSOR_INFO csi;
coord = cursorpos[cs-2];
cursorpos[cs-2] = cursorpos[cs-1];
cursorpos[cs-1] = coord;
memcpy (&csi,
&cursorinfo[cs-2],
sizeof(CONSOLE_CURSOR_INFO));
memcpy (&cursorinfo[cs-2],
&cursorinfo[cs-1],
sizeof(CONSOLE_CURSOR_INFO));
memcpy (&cursorinfo[cs-1],
&csi,
sizeof(CONSOLE_CURSOR_INFO));
}
}
/* ---- Read a keystroke ---- */
void GetKey (PINPUT_RECORD lpBuffer)
{
HANDLE hInput;
DWORD dwRead;
hInput = GetStdHandle (STD_INPUT_HANDLE);
do
{
// WaitForSingleObject (hInput, INFINITE);
ReadConsoleInput (hInput, lpBuffer, 1, &dwRead);
if ((lpBuffer->EventType == KEY_EVENT) &&
(lpBuffer->Event.KeyEvent.bKeyDown == TRUE))
break;
}
while (TRUE);
}
/* ---------- read the keyboard shift status --------- */
int getshift(void)
{
// regs.h.ah = 2;
// int86(KEYBRD, &regs, &regs);
// return regs.h.al;
/* FIXME */
return 0;
}
/* -------- sound a buzz tone ---------- */
void beep(void)
{
Beep(440, 50);
// MessageBeep (-1);
}
/* ------ position the cursor ------ */
void cursor(int x, int y)
{
COORD coPos;
coPos.X = (USHORT)x;
coPos.Y = (USHORT)y;
SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE), coPos);
}
/* ------- get the current cursor position ------- */
void curr_cursor(int *x, int *y)
//VOID GetCursorXY (PSHORT x, PSHORT y)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
*x = (int)csbi.dwCursorPosition.X;
*y = (int)csbi.dwCursorPosition.Y;
}
/* ------ save the current cursor configuration ------ */
void savecursor(void)
{
if (cs < MAXSAVES)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
GetConsoleScreenBufferInfo (GetStdHandle (STD_OUTPUT_HANDLE), &csbi);
cursorpos[cs].X = csbi.dwCursorPosition.X;
cursorpos[cs].Y = csbi.dwCursorPosition.Y;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&(cursorinfo[cs]));
cs++;
}
}
/* ---- restore the saved cursor configuration ---- */
void restorecursor(void)
{
if (cs)
{
--cs;
SetConsoleCursorPosition (GetStdHandle (STD_OUTPUT_HANDLE),
cursorpos[cs]);
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&(cursorinfo[cs]));
}
}
/* ------ make a normal cursor ------ */
void normalcursor(void)
{
CONSOLE_CURSOR_INFO csi;
csi.bVisible = TRUE;
csi.dwSize = 5;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ hide the cursor ------ */
void hidecursor(void)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
csi.bVisible = FALSE;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ unhide the cursor ------ */
void unhidecursor(void)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
csi.bVisible = TRUE;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* set the cursor size (in percent) */
void set_cursor_size (unsigned t)
{
CONSOLE_CURSOR_INFO csi;
GetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
if (t < 2)
csi.dwSize = 2;
else if (t > 90)
csi.dwSize = 90;
else
csi.dwSize = t;
SetConsoleCursorInfo (GetStdHandle (STD_OUTPUT_HANDLE),
&csi);
}
/* ------ convert an Alt+ key to its letter equivalent ----- */
int AltConvert(int c)
{
return c;
#if 0
int i, a = 0;
for (i = 0; i < 36; i++)
if (c == altconvert[i])
break;
if (i < 26)
a = 'a' + i;
else if (i < 36)
a = '0' + i - 26;
return a;
#endif
}
/* EOF */
rosapps/lib/dflat32/decomp.c
-134
View File
@@ -1,134 +0,0 @@
/* ------------------- decomp.c -------------------- */
/*
* Decompress the application.HLP file
* or load the application.TXT file if the .HLP file
* does not exist
*/
#include "dflat32/dflat.h"
#include "dflat32/htree.h"
static int in8;
static int ct8 = 8;
static FILE *fi;
static BYTECOUNTER bytectr;
static int LoadingASCII;
struct htr *HelpTree;
static int root;
/* ------- open the help database file -------- */
FILE *OpenHelpFile(void)
{
char *cp;
int treect, i;
char helpname[65];
/* -------- get the name of the help file ---------- */
BuildFileName(helpname, ".hlp");
LoadingASCII = FALSE;
if ((fi = fopen(helpname, "rb")) == NULL) {
/* ---- no .hlp file, look for .txt file ---- */
if ((cp = strrchr(helpname, '.')) != NULL) {
strcpy(cp, ".TXT");
fi = fopen(helpname, "rt");
}
if (fi == NULL)
return NULL;
LoadingASCII = TRUE;
}
if (!LoadingASCII && HelpTree == NULL) {
/* ----- read the byte count ------ */
fread(&bytectr, sizeof bytectr, 1, fi);
/* ----- read the frequency count ------ */
fread(&treect, sizeof treect, 1, fi);
/* ----- read the root offset ------ */
fread(&root, sizeof root, 1, fi);
HelpTree = DFcalloc(treect-256, sizeof(struct htr));
/* ---- read in the tree --- */
for (i = 0; i < treect-256; i++) {
fread(&HelpTree[i].left, sizeof(int), 1, fi);
fread(&HelpTree[i].right, sizeof(int), 1, fi);
}
}
return fi;
}
/* ----- read a line of text from the help database ----- */
void *GetHelpLine(char *line)
{
int h;
if (LoadingASCII) {
void *hp;
do
hp = fgets(line, 160, fi);
while (*line == ';');
return hp;
}
*line = '\0';
while (TRUE) {
/* ----- decompress a line from the file ------ */
h = root;
/* ----- walk the Huffman tree ----- */
while (h > 255) {
/* --- h is a node pointer --- */
if (ct8 == 8) {
/* --- read 8 bits of compressed data --- */
if ((in8 = fgetc(fi)) == EOF) {
*line = '\0';
return NULL;
}
ct8 = 0;
}
/* -- point to left or right node based on msb -- */
if (in8 & 0x80)
h = HelpTree[h-256].left;
else
h = HelpTree[h-256].right;
/* --- shift the next bit in --- */
in8 <<= 1;
ct8++;
}
/* --- h < 255 = decompressed character --- */
if (h == '\r')
continue; /* skip the '\r' character */
/* --- put the character in the buffer --- */
*line++ = h;
/* --- if '\n', end of line --- */
if (h == '\n')
break;
}
*line = '\0'; /* null-terminate the line */
return line;
}
/* --- compute the database file byte and bit position --- */
void HelpFilePosition(long *offset, int *bit)
{
*offset = ftell(fi);
if (LoadingASCII)
*bit = 0;
else {
if (ct8 < 8)
--*offset;
*bit = ct8;
}
}
/* -- position the database to the specified byte and bit -- */
void SeekHelpLine(long offset, int bit)
{
int i;
fseek(fi, offset, 0);
if (!LoadingASCII) {
ct8 = bit;
if (ct8 < 8) {
in8 = fgetc(fi);
for (i = 0; i < bit; i++)
in8 <<= 1;
}
}
}
rosapps/lib/dflat32/dfalloc.c
-70
View File
@@ -1,70 +0,0 @@
/* ---------- dfalloc.c ---------- */
//#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include "dflat32/dflat.h"
static void AllocationError(void)
{
static BOOL OnceIn = FALSE;
extern jmp_buf AllocError;
extern BOOL AllocTesting;
static char *ErrMsg[] = {
"ÚÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄ¿",
"³ Out of Memory! ³",
"RÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄÄU"
};
int x, y;
CHAR_INFO savbuf[54];
DFRECT rc = {30,11,47,13};
INPUT_RECORD ir;
if (!OnceIn)
{
OnceIn = TRUE;
/* ------ close all windows ------ */
DfSendMessage(ApplicationWindow, CLOSE_WINDOW, 0, 0);
GetVideo(rc, savbuf);
for (x = 0; x < 18; x++)
{
for (y = 0; y < 3; y++)
{
int c = (255 & (*(*(ErrMsg+y)+x))) | 0x7000;
PutVideoChar(x+rc.lf, y+rc.tp, c);
}
}
GetKey(&ir);
StoreVideo(rc, savbuf);
if (AllocTesting)
longjmp(AllocError, 1);
}
}
void *DFcalloc(size_t nitems, size_t size)
{
void *rtn = calloc(nitems, size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
void *DFmalloc(size_t size)
{
void *rtn = malloc(size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
void *DFrealloc(void *block, size_t size)
{
void *rtn;
rtn = realloc(block, size);
if (size && rtn == NULL)
AllocationError();
return rtn;
}
/* EOF */
rosapps/lib/dflat32/dflat32.def
-115
View File
@@ -1,115 +0,0 @@
;
; ReactOS dflat32 Console Windowing Library
;
LIBRARY DFLAT32.DLL
EXPORTS
DfCreateWindow
DfInitialize ;message.c
DfPostMessage ;message.c
DfSendMessage ;message.c
DfDispatchMessage ;message.c
handshake ;message.c
TestCriticalError ;stubs.c
;DefaultWndProc
;BaseWndProc
;WindowHeight
;WindowWidth
;ClientWidth
;ClientHeight
;GetTop
;GetBottom
;GetLeft
;GetRight
;GetClientTop
;GetClientBottom
;GetClientLeft
;GetClientRight
;GetParent
;FirstWindow
;LastWindow
;NextWindow
;PrevWindow
CharInView
;TopBorderAdj
;BorderAdj
;GetTitle
AddTitle
;GetClass
;GetAttribute
;AddAttribute
;ClearAttribute
;TestAttribute
isVisible ;normal.o
;GetText
;GetTextLines
;TextLine
;SetProtected
isActive
GetCommandText
ActivateCommand
DeactivateCommand
GetCommandToggle
SetCommandToggle
ClearCommandToggle
InvertCommandToggle
ItemSelected
;DialogBox
ControlWindow
;MessageBox
;CancelBox
;ErrorMessage
;TestErrorMessage
;YesNoBox
MomentaryMessage
InputBox
;SliderBox
RadioButtonSetting
;EnableButton
;DisableButton
;ButtonEnabled
PutItemText
;PutComboListText
GetItemText
;GetEditBoxText
;GetComboBoxText
;SetEditBoxText
;SetComboBoxText
;GetDlgText
;SetDlgText
;GetDlgTextBox
;SetDlgTextBox
;SetCheckBox
;ClearCheckBox
CheckBoxSetting
;SetDlgTitle
LoadHelpFile
DisplayHelp ;helpbox.o
;HelpComment
UnLoadHelpFile ;helpbox.o
;SearchText
;ReplaceText
;SearchNext
WriteTextLine
PutWindowLine
PutWindowChar
DrawVector
DrawBox
DrawBar
;WindowClientColor
;WindowReverseColor
;WindowFrameColor
;WindowHighlightColor
MarkTextBlock
;ClearTextBlock
CopyToClipboard ;clipbord.o
CopyTextToClipboard ;clipbord.o
PasteText ;clipbord.o
ClearClipboard ;clipbord.o
WatchIcon ;watch.o
;
;
;
; Everything below here is not part of the dflat32 api (documentation)
DfTerminate
LoadConfig
rosapps/lib/dflat32/dflat32.rbuild
-40
View File
@@ -1,40 +0,0 @@
<module name="dflat32lib" type="win32dll" baseadress="0x98000000" installbase="system32" installname="dflat32.dll">
<importlibrary definition="dflat32.def" />
<file>applicat.c</file>
<file>box.c</file>
<file>checkbox.c</file>
<file>clipbord.c</file>
<file>config.c</file>
<file>console.c</file>
<file>decomp.c</file>
<file>dfalloc.c</file>
<file>dialbox.c</file>
<file>dialogs.c</file>
<file>dllmain.c</file>
<file>editbox.c</file>
<file>lists.c</file>
<file>helpbox.c</file>
<file>listbox.c</file>
<file>log.c</file>
<file>message.c</file>
<file>menu.c</file>
<file>menubar.c</file>
<file>menus.c</file>
<file>msgbox.c</file>
<file>normal.c</file>
<file>pictbox.c</file>
<file>popdown.c</file>
<file>keys.c</file>
<file>radio.c</file>
<file>rect.c</file>
<file>spinbutt.c</file>
<file>statbar.c</file>
<file>stubs.c</file>
<file>sysmenu.c</file>
<file>text.c</file>
<file>textbox.c</file>
<file>video.c</file>
<file>watch.c</file>
<file>window.c</file>
</module>
rosapps/lib/dflat32/dflat32.rc
-9
View File
@@ -1,9 +0,0 @@
/* $Id$ */
#define REACTOS_VERSION_DLL
#define REACTOS_STR_FILE_DESCRIPTION "dflat32 console windowing library\0"
#define REACTOS_STR_INTERNAL_NAME "dflat\0"
#define REACTOS_STR_ORIGINAL_FILENAME "dflat.dll\0"
#include <reactos/version.rc>
/* EOF */
rosapps/lib/dflat32/dialbox.c
-792
View File
@@ -1,792 +0,0 @@
/* ----------------- dialbox.c -------------- */
#include "dflat32/dflat.h"
static int inFocusCommand(DBOX *);
static void dbShortcutKeys(DBOX *, int);
static int ControlProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
static void FirstFocus(DBOX *db);
static void NextFocus(DBOX *db);
static void PrevFocus(DBOX *db);
static CTLWINDOW *AssociatedControl(DBOX *, enum commands);
static BOOL SysMenuOpen;
static DBOX **dbs = NULL;
static int dbct = 0;
/* --- clear all heap allocations to control text fields --- */
void ClearDialogBoxes(void)
{
int i;
for (i = 0; i < dbct; i++)
{
CTLWINDOW *ct = (*(dbs+i))->ctl;
while (ct->class)
{
if ((ct->class == EDITBOX ||
ct->class == COMBOBOX) &&
ct->itext != NULL)
{
free(ct->itext);
}
ct++;
}
}
if (dbs != NULL)
{
free(dbs);
dbs = NULL;
}
dbct = 0;
}
/* -------- CREATE_WINDOW Message --------- */
static int CreateWindowMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
DBOX *db = wnd->extension;
CTLWINDOW *ct = db->ctl;
DFWINDOW cwnd;
int rtn, i;
/* ---- build a table of processed dialog boxes ---- */
for (i = 0; i < dbct; i++)
if (db == dbs[i])
break;
if (i == dbct) {
dbs = DFrealloc(dbs, sizeof(DBOX *) * (dbct+1));
*(dbs + dbct++) = db;
}
rtn = BaseWndProc(DIALOG, wnd, CREATE_WINDOW, p1, p2);
ct = db->ctl;
while (ct->class) {
int attrib = 0;
if (TestAttribute(wnd, NOCLIP))
attrib |= NOCLIP;
if (wnd->Modal)
attrib |= SAVESELF;
ct->setting = ct->isetting;
if (ct->class == EDITBOX && ct->dwnd.h > 1)
attrib |= (MULTILINE | HASBORDER);
else if ((ct->class == LISTBOX || ct->class == TEXTBOX) &&
ct->dwnd.h > 2)
attrib |= HASBORDER;
cwnd = DfCreateWindow(ct->class,
ct->dwnd.title,
ct->dwnd.x+GetClientLeft(wnd),
ct->dwnd.y+GetClientTop(wnd),
ct->dwnd.h,
ct->dwnd.w,
ct,
wnd,
ControlProc,
attrib);
if ((ct->class == EDITBOX ||
ct->class == COMBOBOX) &&
ct->itext != NULL)
DfSendMessage(cwnd, SETTEXT, (PARAM) ct->itext, 0);
ct++;
}
return rtn;
}
/* -------- LEFT_BUTTON Message --------- */
static BOOL LeftButtonMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
DBOX *db = wnd->extension;
CTLWINDOW *ct = db->ctl;
if (WindowSizing || WindowMoving)
return TRUE;
if (HitControlBox(wnd, p1-GetLeft(wnd), p2-GetTop(wnd))) {
DfPostMessage(wnd, KEYBOARD, ' ', ALTKEY);
return TRUE;
}
while (ct->class) {
DFWINDOW cwnd = ct->wnd;
if (ct->class == COMBOBOX) {
if (p2 == GetTop(cwnd)) {
if (p1 == GetRight(cwnd)+1) {
DfSendMessage(cwnd, LEFT_BUTTON, p1, p2);
return TRUE;
}
}
if (GetClass(inFocus) == LISTBOX)
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
}
else if (ct->class == SPINBUTTON) {
if (p2 == GetTop(cwnd)) {
if (p1 == GetRight(cwnd)+1 ||
p1 == GetRight(cwnd)+2) {
DfSendMessage(cwnd, LEFT_BUTTON, p1, p2);
return TRUE;
}
}
}
ct++;
}
return FALSE;
}
/* -------- KEYBOARD Message --------- */
static BOOL KeyboardMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
DBOX *db = wnd->extension;
CTLWINDOW *ct;
if (WindowMoving || WindowSizing)
return FALSE;
switch ((int)p1) {
case F1:
ct = GetControl(inFocus);
if (ct != NULL)
if (DisplayHelp(wnd, ct->help))
return TRUE;
break;
case SHIFT_HT:
case BS:
case UP:
PrevFocus(db);
break;
case ALT_F6:
case '\t':
case FWD:
case DN:
NextFocus(db);
break;
case ' ':
if (((int)p2 & ALTKEY) &&
TestAttribute(wnd, CONTROLBOX)) {
SysMenuOpen = TRUE;
BuildSystemMenu(wnd);
}
break;
case CTRL_F4:
case ESC:
DfSendMessage(wnd, DFM_COMMAND, ID_CANCEL, 0);
break;
default:
/* ------ search all the shortcut keys ----- */
dbShortcutKeys(db, (int) p1);
break;
}
return wnd->Modal;
}
/* -------- COMMAND Message --------- */
static BOOL CommandMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
DBOX *db = wnd->extension;
switch ((int) p1) {
case ID_OK:
case ID_CANCEL:
if ((int)p2 != 0)
return TRUE;
wnd->ReturnCode = (int) p1;
if (wnd->Modal)
DfPostMessage(wnd, ENDDIALOG, 0, 0);
else
DfSendMessage(wnd, CLOSE_WINDOW, TRUE, 0);
return TRUE;
case ID_HELP:
if ((int)p2 != 0)
return TRUE;
return DisplayHelp(wnd, db->HelpName);
default:
break;
}
return FALSE;
}
/* ----- window-processing module, DIALOG window class ----- */
int DialogProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
DBOX *db = wnd->extension;
switch (msg) {
case CREATE_WINDOW:
return CreateWindowMsg(wnd, p1, p2);
case SHIFT_CHANGED:
if (wnd->Modal)
return TRUE;
break;
case LEFT_BUTTON:
if (LeftButtonMsg(wnd, p1, p2))
return TRUE;
break;
case KEYBOARD:
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case CLOSE_POPDOWN:
SysMenuOpen = FALSE;
break;
case LB_SELECTION:
case LB_CHOOSE:
if (SysMenuOpen)
return TRUE;
DfSendMessage(wnd, DFM_COMMAND, inFocusCommand(db), msg);
break;
case DFM_COMMAND:
if (CommandMsg(wnd, p1, p2))
return TRUE;
break;
case PAINT:
p2 = TRUE;
break;
case MOVE:
case DFM_SIZE:
rtn = BaseWndProc(DIALOG, wnd, msg, p1, p2);
if (wnd->dfocus != NULL)
DfSendMessage(wnd->dfocus, SETFOCUS, TRUE, 0);
return rtn;
case CLOSE_WINDOW:
if (!p1)
{
DfSendMessage(wnd, DFM_COMMAND, ID_CANCEL, 0);
return TRUE;
}
break;
default:
break;
}
return BaseWndProc(DIALOG, wnd, msg, p1, p2);
}
/* ------- create and execute a dialog box ---------- */
BOOL DfDialogBox(DFWINDOW wnd, DBOX *db, BOOL Modal,
int (*wndproc)(struct window *, enum messages, PARAM, PARAM))
{
BOOL rtn;
int x = db->dwnd.x, y = db->dwnd.y;
DFWINDOW DialogWnd;
if (!Modal && wnd != NULL)
{
x += GetLeft(wnd);
y += GetTop(wnd);
}
DialogWnd = DfCreateWindow(DIALOG,
db->dwnd.title,
x, y,
db->dwnd.h,
db->dwnd.w,
db,
wnd,
wndproc,
Modal ? SAVESELF : 0);
DialogWnd->Modal = Modal;
FirstFocus(db);
DfPostMessage(DialogWnd, INITIATE_DIALOG, 0, 0);
if (Modal)
{
DfSendMessage(DialogWnd, CAPTURE_MOUSE, 0, 0);
DfSendMessage(DialogWnd, CAPTURE_KEYBOARD, 0, 0);
while (DfDispatchMessage ())
;
rtn = DialogWnd->ReturnCode == ID_OK;
DfSendMessage(DialogWnd, RELEASE_MOUSE, 0, 0);
DfSendMessage(DialogWnd, RELEASE_KEYBOARD, 0, 0);
DfSendMessage(DialogWnd, CLOSE_WINDOW, TRUE, 0);
return rtn;
}
return FALSE;
}
/* ----- return command code of in-focus control window ---- */
static int inFocusCommand(DBOX *db)
{
CTLWINDOW *ct = db->ctl;
while (ct->class) {
if (ct->wnd == inFocus)
return ct->command;
ct++;
}
return -1;
}
/* -------- find a specified control structure ------- */
CTLWINDOW *FindCommand(DBOX *db, enum commands cmd, int class)
{
CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->class == class)
if (cmd == ct->command)
return ct;
ct++;
}
return NULL;
}
/* ---- return the window handle of a specified command ---- */
DFWINDOW ControlWindow(DBOX *db, enum commands cmd)
{
CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->class != TEXT && cmd == ct->command)
return ct->wnd;
ct++;
}
return NULL;
}
/* --- return a pointer to the control structure that matches a window --- */
CTLWINDOW *WindowControl(DBOX *db, DFWINDOW wnd)
{
CTLWINDOW *ct = db->ctl;
while (ct->class)
{
if (ct->wnd == wnd)
return ct;
ct++;
}
return NULL;
}
/* ---- set a control ON or OFF ----- */
void ControlSetting(DBOX *db, enum commands cmd,
int class, int setting)
{
CTLWINDOW *ct = FindCommand(db, cmd, class);
if (ct != NULL) {
ct->isetting = setting;
if (ct->wnd != NULL)
ct->setting = setting;
}
}
/* ---- return pointer to the text of a control window ---- */
char *GetDlgTextString(DBOX *db,enum commands cmd,DFCLASS class)
{
CTLWINDOW *ct = FindCommand(db, cmd, class);
if (ct != NULL)
return ct->itext;
else
return NULL;
}
/* ------- set the text of a control specification ------ */
void SetDlgTextString(DBOX *db, enum commands cmd,
char *text, DFCLASS class)
{
CTLWINDOW *ct = FindCommand(db, cmd, class);
if (ct != NULL) {
ct->itext = DFrealloc(ct->itext, strlen(text)+1);
strcpy(ct->itext, text);
}
}
/* ------- set the text of a control window ------ */
void PutItemText(DFWINDOW wnd, enum commands cmd, char *text)
{
CTLWINDOW *ct = FindCommand(wnd->extension, cmd, EDITBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, TEXTBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, COMBOBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, LISTBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, SPINBUTTON);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, TEXT);
if (ct != NULL) {
DFWINDOW cwnd = (DFWINDOW) (ct->wnd);
switch (ct->class) {
case COMBOBOX:
case EDITBOX:
DfSendMessage(cwnd, CLEARTEXT, 0, 0);
DfSendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
if (!isMultiLine(cwnd))
DfSendMessage(cwnd, PAINT, 0, 0);
break;
case LISTBOX:
case TEXTBOX:
case SPINBUTTON:
DfSendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
break;
case TEXT: {
DfSendMessage(cwnd, CLEARTEXT, 0, 0);
DfSendMessage(cwnd, ADDTEXT, (PARAM) text, 0);
DfSendMessage(cwnd, PAINT, 0, 0);
break;
}
default:
break;
}
}
}
/* ------- get the text of a control window ------ */
void GetItemText(DFWINDOW wnd, enum commands cmd,
char *text, int len)
{
CTLWINDOW *ct = FindCommand(wnd->extension, cmd, EDITBOX);
unsigned char *cp;
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, COMBOBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, TEXTBOX);
if (ct == NULL)
ct = FindCommand(wnd->extension, cmd, TEXT);
if (ct != NULL) {
DFWINDOW cwnd = (DFWINDOW) (ct->wnd);
if (cwnd != NULL) {
switch (ct->class) {
case TEXT:
if (GetText(cwnd) != NULL) {
cp = strchr(GetText(cwnd), '\n');
if (cp != NULL)
len = (int) (cp - GetText(cwnd));
strncpy(text, GetText(cwnd), len);
*(text+len) = '\0';
}
break;
case TEXTBOX:
if (GetText(cwnd) != NULL)
strncpy(text, GetText(cwnd), len);
break;
case COMBOBOX:
case EDITBOX:
DfSendMessage(cwnd,GETTEXT,(PARAM)text,len);
break;
default:
break;
}
}
}
}
/* ------- set the text of a listbox control window ------ */
void GetDlgListText(DFWINDOW wnd, char *text, enum commands cmd)
{
CTLWINDOW *ct = FindCommand(wnd->extension, cmd, LISTBOX);
int sel = DfSendMessage(ct->wnd, LB_CURRENTSELECTION, 0, 0);
DfSendMessage(ct->wnd, DFM_LB_GETTEXT, (PARAM) text, sel);
}
/* -- find control structure associated with text control -- */
static CTLWINDOW *AssociatedControl(DBOX *db,enum commands Tcmd)
{
CTLWINDOW *ct = db->ctl;
while (ct->class) {
if (ct->class != TEXT)
if (ct->command == Tcmd)
break;
ct++;
}
return ct;
}
/* --- process dialog box shortcut keys --- */
static void dbShortcutKeys(DBOX *db, int ky)
{
CTLWINDOW *ct;
int ch = AltConvert(ky);
if (ch != 0) {
ct = db->ctl;
while (ct->class) {
char *cp = ct->itext;
while (cp && *cp) {
if (*cp == SHORTCUTCHAR &&
tolower(*(cp+1)) == ch) {
if (ct->class == TEXT)
ct = AssociatedControl(db, ct->command);
if (ct->class == RADIOBUTTON)
SetRadioButton(db, ct);
else if (ct->class == CHECKBOX) {
ct->setting ^= ON;
DfSendMessage(ct->wnd, PAINT, 0, 0);
}
else if (ct->class) {
DfSendMessage(ct->wnd, SETFOCUS, TRUE, 0);
if (ct->class == BUTTON)
DfSendMessage(ct->wnd,KEYBOARD,'\r',0);
}
return;
}
cp++;
}
ct++;
}
}
}
/* --- dynamically add or remove scroll bars
from a control window ---- */
void SetScrollBars(DFWINDOW wnd)
{
int oldattr = GetAttribute(wnd);
if (wnd->wlines > ClientHeight(wnd))
AddAttribute(wnd, VSCROLLBAR);
else
ClearAttribute(wnd, VSCROLLBAR);
if (wnd->textwidth > ClientWidth(wnd))
AddAttribute(wnd, HSCROLLBAR);
else
ClearAttribute(wnd, HSCROLLBAR);
if (GetAttribute(wnd) != oldattr)
DfSendMessage(wnd, BORDER, 0, 0);
}
/* ------- CREATE_WINDOW Message (Control) ----- */
static void CtlCreateWindowMsg(DFWINDOW wnd)
{
CTLWINDOW *ct;
ct = wnd->ct = wnd->extension;
wnd->extension = NULL;
if (ct != NULL)
ct->wnd = wnd;
}
/* ------- KEYBOARD Message (Control) ----- */
static BOOL CtlKeyboardMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
CTLWINDOW *ct = GetControl(wnd);
switch ((int) p1) {
case F1:
if (WindowMoving || WindowSizing)
break;
if (!DisplayHelp(wnd, ct->help))
DfSendMessage(GetParent(wnd),DFM_COMMAND,ID_HELP,0);
return TRUE;
case ' ':
if (!((int)p2 & ALTKEY))
break;
case ALT_F6:
case CTRL_F4:
case ALT_F4:
DfPostMessage(GetParent(wnd), KEYBOARD, p1, p2);
return TRUE;
default:
break;
}
if (GetClass(wnd) == EDITBOX)
if (isMultiLine(wnd))
return FALSE;
switch ((int) p1) {
case UP:
if (!isDerivedFrom(wnd, LISTBOX)) {
p1 = CTRL_FIVE;
p2 = LEFTSHIFT;
}
break;
case BS:
if (!isDerivedFrom(wnd, EDITBOX)) {
p1 = CTRL_FIVE;
p2 = LEFTSHIFT;
}
break;
case DN:
if (!isDerivedFrom(wnd, LISTBOX) &&
!isDerivedFrom(wnd, COMBOBOX))
p1 = '\t';
break;
case FWD:
if (!isDerivedFrom(wnd, EDITBOX))
p1 = '\t';
break;
case '\r':
if (isDerivedFrom(wnd, EDITBOX))
if (isMultiLine(wnd))
break;
if (isDerivedFrom(wnd, BUTTON))
break;
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_OK, 0);
return TRUE;
default:
break;
}
return FALSE;
}
/* ------- CLOSE_WINDOW Message (Control) ----- */
static void CtlCloseWindowMsg(DFWINDOW wnd)
{
CTLWINDOW *ct = GetControl(wnd);
if (ct != NULL) {
ct->wnd = NULL;
if (GetParent(wnd)->ReturnCode == ID_OK) {
if (ct->class == EDITBOX || ct->class == COMBOBOX) {
if (wnd->TextChanged) {
ct->itext=DFrealloc(ct->itext,strlen(wnd->text)+1);
strcpy(ct->itext, wnd->text);
if (!isMultiLine(wnd)) {
char *cp = ct->itext+strlen(ct->itext)-1;
if (*cp == '\n')
*cp = '\0';
}
}
}
else if (ct->class == RADIOBUTTON || ct->class == CHECKBOX)
ct->isetting = ct->setting;
}
}
}
static void FixColors(DFWINDOW wnd)
{
CTLWINDOW *ct = wnd->ct;
if (ct->class != BUTTON)
{
if (ct->class != SPINBUTTON && ct->class != COMBOBOX)
{
wnd->WindowColors[FRAME_COLOR][FG] =
GetParent(wnd)->WindowColors[FRAME_COLOR][FG];
wnd->WindowColors[FRAME_COLOR][BG] =
GetParent(wnd)->WindowColors[FRAME_COLOR][BG];
if (ct->class != EDITBOX && ct->class != LISTBOX)
{
wnd->WindowColors[STD_COLOR][FG] =
GetParent(wnd)->WindowColors[STD_COLOR][FG];
wnd->WindowColors[STD_COLOR][BG] =
GetParent(wnd)->WindowColors[STD_COLOR][BG];
}
}
}
}
/* -- generic window processor used by dialog box controls -- */
static int ControlProc(DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2)
{
DBOX *db;
if (wnd == NULL)
return FALSE;
db = GetParent(wnd) ? GetParent(wnd)->extension : NULL;
switch (msg) {
case CREATE_WINDOW:
CtlCreateWindowMsg(wnd);
break;
case KEYBOARD:
if (CtlKeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case PAINT:
FixColors(wnd);
if (GetClass(wnd) == EDITBOX ||
GetClass(wnd) == LISTBOX ||
GetClass(wnd) == TEXTBOX)
SetScrollBars(wnd);
break;
case BORDER:
FixColors(wnd);
if (GetClass(wnd) == EDITBOX) {
DFWINDOW oldFocus = inFocus;
inFocus = NULL;
DefaultWndProc(wnd, msg, p1, p2);
inFocus = oldFocus;
return TRUE;
}
break;
case SETFOCUS: {
DFWINDOW pwnd = GetParent(wnd);
if (p1)
{
DefaultWndProc(wnd, msg, p1, p2);
if (pwnd != NULL)
{
pwnd->dfocus = wnd;
DfSendMessage(pwnd, DFM_COMMAND,
inFocusCommand(db), ENTERFOCUS);
}
return TRUE;
}
else
DfSendMessage(pwnd, DFM_COMMAND,
inFocusCommand(db), LEAVEFOCUS);
break;
}
case CLOSE_WINDOW:
CtlCloseWindowMsg(wnd);
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
/* ---- change the focus to the first control --- */
static void FirstFocus(DBOX *db)
{
CTLWINDOW *ct = db->ctl;
if (ct != NULL)
{
while (ct->class == TEXT || ct->class == BOX) {
ct++;
if (ct->class == 0)
return;
}
DfSendMessage(ct->wnd, SETFOCUS, TRUE, 0);
}
}
/* ---- change the focus to the next control --- */
static void NextFocus(DBOX *db)
{
CTLWINDOW *ct = WindowControl(db, inFocus);
int looped = 0;
if (ct != NULL)
{
do
{
ct++;
if (ct->class == 0)
{
if (looped)
return;
looped++;
ct = db->ctl;
}
} while (ct->class == TEXT || ct->class == BOX);
DfSendMessage(ct->wnd, SETFOCUS, TRUE, 0);
}
}
/* ---- change the focus to the previous control --- */
static void PrevFocus(DBOX *db)
{
CTLWINDOW *ct = WindowControl(db, inFocus);
int looped = 0;
if (ct != NULL)
{
do
{
if (ct == db->ctl)
{
if (looped)
return;
looped++;
while (ct->class)
ct++;
}
--ct;
} while (ct->class == TEXT || ct->class == BOX);
DfSendMessage(ct->wnd, SETFOCUS, TRUE, 0);
}
}
void SetFocusCursor(DFWINDOW wnd)
{
if (wnd == inFocus)
{
DfSendMessage(NULL, SHOW_CURSOR, 0, 0);
DfSendMessage(wnd, KEYBOARD_CURSOR, 1, 0);
}
}
/* EOF */
rosapps/lib/dflat32/dialogs.c
-160
View File
@@ -1,160 +0,0 @@
/* ----------- dialogs.c --------------- */
#include "dflat32/dflat.h"
/* -------------- the File Open dialog box --------------- */
DIALOGBOX( FileOpen )
DB_TITLE( "Open File", -1,-1,19,48)
CONTROL(TEXT, "~Filename", 2, 1, 1, 8, ID_FILENAME)
CONTROL(EDITBOX, NULL, 13, 1, 1,29, ID_FILENAME)
CONTROL(TEXT, "Directory:", 2, 3, 1,10, 0)
CONTROL(TEXT, NULL, 13, 3, 1,28, ID_PATH)
CONTROL(TEXT, "F~iles", 2, 5, 1, 5, ID_FILES)
CONTROL(LISTBOX, NULL, 2, 6,11,16, ID_FILES)
CONTROL(TEXT, "~Directories", 19, 5, 1,11, ID_DRIVE)
CONTROL(LISTBOX, NULL, 19, 6,11,16, ID_DRIVE)
CONTROL(BUTTON, " ~OK ", 36, 7, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 36,10, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 36,13, 1, 8, ID_HELP)
ENDDB
/* -------------- the Save As dialog box --------------- */
DIALOGBOX( SaveAs )
DB_TITLE( "Save As", -1,-1,19,48)
CONTROL(TEXT, "~Filename", 2, 1, 1, 8, ID_FILENAME)
CONTROL(EDITBOX, NULL, 13, 1, 1,29, ID_FILENAME)
CONTROL(TEXT, "Directory:", 2, 3, 1,10, 0)
CONTROL(TEXT, NULL, 13, 3, 1,28, ID_PATH)
CONTROL(TEXT, "~Directories",2, 5, 1,11, ID_DRIVE)
CONTROL(LISTBOX, NULL, 2, 6,11,16, ID_DRIVE)
CONTROL(BUTTON, " ~OK ", 36, 7, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 36,10, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 36,13, 1, 8, ID_HELP)
ENDDB
/* -------------- The Printer Setup dialog box ------------------ */
DIALOGBOX( PrintSetup )
DB_TITLE( "Printer Setup", -1, -1, 17, 32)
CONTROL(BOX, "Margins", 2, 3, 9, 26, 0 )
CONTROL(TEXT, "~Port:", 4, 1, 1, 5, ID_PRINTERPORT)
CONTROL(COMBOBOX, NULL, 12, 1, 8, 9, ID_PRINTERPORT)
CONTROL(TEXT, "~Left:", 6, 4, 1, 5, ID_LEFTMARGIN)
CONTROL(SPINBUTTON, NULL, 17, 4, 1, 6, ID_LEFTMARGIN)
CONTROL(TEXT, "~Right:", 6, 6, 1, 6, ID_RIGHTMARGIN)
CONTROL(SPINBUTTON, NULL, 17, 6, 1, 6, ID_RIGHTMARGIN)
CONTROL(TEXT, "~Top:", 6, 8, 1, 4, ID_TOPMARGIN)
CONTROL(SPINBUTTON, NULL, 17, 8, 1, 6, ID_TOPMARGIN)
CONTROL(TEXT, "~Bottom:", 6, 10, 1, 7, ID_BOTTOMMARGIN)
CONTROL(SPINBUTTON, NULL, 17, 10, 1, 6, ID_BOTTOMMARGIN)
CONTROL(BUTTON, " ~OK ", 1, 13, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 11, 13, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 21, 13, 1, 8, ID_HELP)
ENDDB
/* -------------- the Search Text dialog box --------------- */
DIALOGBOX( SearchTextDB )
DB_TITLE( "Search Text", -1,-1,9,48)
CONTROL(TEXT, "~Search for:", 2, 1, 1, 11, ID_SEARCHFOR)
CONTROL(EDITBOX, NULL, 14, 1, 1, 29, ID_SEARCHFOR)
CONTROL(TEXT, "~Match upper/lower case:", 2, 3, 1, 23, ID_MATCHCASE)
CONTROL(CHECKBOX, NULL, 26, 3, 1, 3, ID_MATCHCASE)
CONTROL(BUTTON, " ~OK ", 7, 5, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 19, 5, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 31, 5, 1, 8, ID_HELP)
ENDDB
/* -------------- the Replace Text dialog box --------------- */
DIALOGBOX( ReplaceTextDB )
DB_TITLE( "Replace Text", -1,-1,12,50)
CONTROL(TEXT, "~Search for:", 2, 1, 1, 11, ID_SEARCHFOR)
CONTROL(EDITBOX, NULL, 16, 1, 1, 29, ID_SEARCHFOR)
CONTROL(TEXT, "~Replace with:", 2, 3, 1, 13, ID_REPLACEWITH)
CONTROL(EDITBOX, NULL, 16, 3, 1, 29, ID_REPLACEWITH)
CONTROL(TEXT, "~Match upper/lower case:", 2, 5, 1, 23, ID_MATCHCASE)
CONTROL(CHECKBOX, NULL, 26, 5, 1, 3, ID_MATCHCASE)
CONTROL(TEXT, "Replace ~Every Match:", 2, 6, 1, 23, ID_REPLACEALL)
CONTROL(CHECKBOX, NULL, 26, 6, 1, 3, ID_REPLACEALL)
CONTROL(BUTTON, " ~OK ", 7, 8, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 20, 8, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 33, 8, 1, 8, ID_HELP)
ENDDB
/* -------------- generic message dialog box --------------- */
DIALOGBOX( MsgBox )
DB_TITLE( NULL, -1,-1, 0, 0)
CONTROL(TEXT, NULL, 1, 1, 0, 0, 0)
CONTROL(BUTTON, NULL, 0, 0, 1, 8, ID_OK)
CONTROL(0, NULL, 0, 0, 1, 8, ID_CANCEL)
ENDDB
/* ----------- InputBox Dialog Box ------------ */
DIALOGBOX( InputBoxDB )
DB_TITLE( NULL, -1,-1, 9, 0)
CONTROL(TEXT, NULL, 1, 1, 1, 0, 0)
CONTROL(EDITBOX, NULL, 1, 3, 1, 0, ID_INPUTTEXT)
CONTROL(BUTTON, " ~OK ", 0, 5, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 0, 5, 1, 8, ID_CANCEL)
ENDDB
/* ----------- SliderBox Dialog Box ------------- */
DIALOGBOX( SliderBoxDB )
DB_TITLE( NULL, -1,-1, 9, 0)
CONTROL(TEXT, NULL, 0, 1, 1, 0, 0)
CONTROL(TEXT, NULL, 0, 3, 1, 0, 0)
CONTROL(BUTTON, " Cancel ", 0, 5, 1, 8, ID_CANCEL)
ENDDB
/* ------------ Display dialog box -------------- */
DIALOGBOX( Display )
DB_TITLE( "Display", -1, -1, 12, 35)
CONTROL(BOX, "Window", 7, 1, 6,20, 0)
CONTROL(CHECKBOX, NULL, 9, 2, 1, 3, ID_TITLE)
CONTROL(TEXT, "~Title", 15, 2, 1, 5, ID_TITLE)
CONTROL(CHECKBOX, NULL, 9, 3, 1, 3, ID_BORDER)
CONTROL(TEXT, "~Border", 15, 3, 1, 6, ID_BORDER)
CONTROL(CHECKBOX, NULL, 9, 4, 1, 3, ID_STATUSBAR)
CONTROL(TEXT, "~Status bar",15, 4, 1,10, ID_STATUSBAR)
CONTROL(CHECKBOX, NULL, 9, 5, 1, 3, ID_TEXTURE)
CONTROL(TEXT, "Te~xture", 15, 5, 1, 7, ID_TEXTURE)
CONTROL(BUTTON, " ~OK ", 2, 8,1,8,ID_OK)
CONTROL(BUTTON, " ~Cancel ", 12, 8,1,8,ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 22, 8,1,8,ID_HELP)
ENDDB
/* ------------ Windows dialog box -------------- */
DIALOGBOX( Windows )
DB_TITLE( "Windows", -1, -1, 19, 24)
CONTROL(LISTBOX, NULL, 1, 1,11,20, ID_WINDOWLIST)
CONTROL(BUTTON, " ~OK ", 2, 13, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 12, 13, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 7, 15, 1, 8, ID_HELP)
ENDDB
#ifdef INCLUDE_LOGGING
/* ------------ Message Log dialog box -------------- */
DIALOGBOX( Log )
DB_TITLE( "D-Flat Message Log", -1, -1, 18, 41)
CONTROL(TEXT, "~Messages", 10, 1, 1, 8, ID_LOGLIST)
CONTROL(LISTBOX, NULL, 1, 2, 14, 26, ID_LOGLIST)
CONTROL(TEXT, "~Logging:", 29, 4, 1, 10, ID_LOGGING)
CONTROL(CHECKBOX, NULL, 31, 5, 1, 3, ID_LOGGING)
CONTROL(BUTTON, " ~OK ", 29, 7, 1, 8, ID_OK)
CONTROL(BUTTON, " ~Cancel ", 29, 10, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Help ", 29, 13, 1, 8, ID_HELP)
ENDDB
#endif
/* ------------ the Help window dialog box -------------- */
DIALOGBOX( HelpBox )
DB_TITLE( NULL, -1, -1, 0, 45)
CONTROL(TEXTBOX, NULL, 1, 1, 0, 40, ID_HELPTEXT)
CONTROL(BUTTON, " ~Close ", 0, 0, 1, 8, ID_CANCEL)
CONTROL(BUTTON, " ~Back ", 10, 0, 1, 8, ID_BACK)
CONTROL(BUTTON, "<< ~Prev ", 20, 0, 1, 8, ID_PREV)
CONTROL(BUTTON, " ~Next >>", 30, 0, 1, 8, ID_NEXT)
ENDDB
/* EOF */
rosapps/lib/dflat32/dllmain.c
-24
View File
@@ -1,24 +0,0 @@
/*
* ReactOS DFLAT32.DLL
*/
#include <windows.h>
BOOLEAN __stdcall DllMain(
PVOID hinstDll,
ULONG dwReason,
PVOID reserved)
{
switch (dwReason)
{
case DLL_PROCESS_ATTACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
case DLL_PROCESS_DETACH:
break;
}
return (TRUE);
}
/* EOF */
rosapps/lib/dflat32/editbox.c
-1113
View File
File diff suppressed because it is too large Load Diff
rosapps/lib/dflat32/helpbox.c
-717
View File
@@ -1,717 +0,0 @@
/* ------------ 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 */
rosapps/lib/dflat32/keys.c
-86
View File
@@ -1,86 +0,0 @@
/* ------------- keys.c ----------- */
#include <stdio.h>
#include "dflat32/keys.h"
struct keys keys[] = {
{F1, "F1"},
{F2, "F2"},
{F3, "F3"},
{F4, "F4"},
{F5, "F5"},
{F6, "F6"},
{F7, "F7"},
{F8, "F8"},
{F9, "F9"},
{F10, "F10"},
{CTRL_F1, "Ctrl+F1"},
{CTRL_F2, "Ctrl+F2"},
{CTRL_F3, "Ctrl+F3"},
{CTRL_F4, "Ctrl+F4"},
{CTRL_F5, "Ctrl+F5"},
{CTRL_F6, "Ctrl+F6"},
{CTRL_F7, "Ctrl+F7"},
{CTRL_F8, "Ctrl+F8"},
{CTRL_F9, "Ctrl+F9"},
{CTRL_F10, "Ctrl+F10"},
{ALT_F1, "Alt+F1"},
{ALT_F2, "Alt+F2"},
{ALT_F3, "Alt+F3"},
{ALT_F4, "Alt+F4"},
{ALT_F5, "Alt+F5"},
{ALT_F6, "Alt+F6"},
{ALT_F7, "Alt+F7"},
{ALT_F8, "Alt+F8"},
{ALT_F9, "Alt+F9"},
{ALT_F10, "Alt+F10"},
{HOME, "Home"},
{UP, "Up"},
{PGUP, "PgUp"},
{BS, "BS"},
{END, "End"},
{DN, "Dn"},
{PGDN, "PgDn"},
{INS, "Ins"},
{DEL, "Del"},
{CTRL_HOME, "Ctrl+Home"},
{CTRL_PGUP, "Ctrl+PgUp"},
{CTRL_BS, "Ctrl+BS"},
{CTRL_END, "Ctrl+End"},
{CTRL_PGDN, "Ctrl+PgDn"},
{SHIFT_HT, "Shift+Tab"},
{ALT_BS, "Alt+BS"},
{ALT_DEL, "Alt+Del"},
{SHIFT_DEL, "Shift+Del"},
{SHIFT_INS, "Shift+Ins"},
{CTRL_INS, "Ctrl+Ins"},
{ALT_A, "Alt+A"},
{ALT_B, "Alt+B"},
{ALT_C, "Alt+C"},
{ALT_D, "Alt+D"},
{ALT_E, "Alt+E"},
{ALT_F, "Alt+F"},
{ALT_G, "Alt+G"},
{ALT_H, "Alt+H"},
{ALT_I, "Alt+I"},
{ALT_J, "Alt+J"},
{ALT_K, "Alt+K"},
{ALT_L, "Alt+L"},
{ALT_M, "Alt+M"},
{ALT_N, "Alt+N"},
{ALT_O, "Alt+O"},
{ALT_P, "Alt+P"},
{ALT_Q, "Alt+Q"},
{ALT_R, "Alt+R"},
{ALT_S, "Alt+S"},
{ALT_T, "Alt+T"},
{ALT_U, "Alt+U"},
{ALT_V, "Alt+V"},
{ALT_W, "Alt+W"},
{ALT_X, "Alt+X"},
{ALT_Y, "Alt+Y"},
{ALT_Z, "Alt+Z"},
{-1, NULL}
};
/* EOF */
rosapps/lib/dflat32/listbox.c
-469
View File
@@ -1,469 +0,0 @@
/* ------------- listbox.c ------------ */
#include "dflat32/dflat.h"
#ifdef INCLUDE_EXTENDEDSELECTIONS
static int ExtendSelections(DFWINDOW, int, int);
static void TestExtended(DFWINDOW, PARAM);
static void ClearAllSelections(DFWINDOW);
static void SetSelection(DFWINDOW, int);
static void FlipSelection(DFWINDOW, int);
static void ClearSelection(DFWINDOW, int);
#else
#define TestExtended(w,p) /**/
#endif
static void ChangeSelection(DFWINDOW, int, int);
static void WriteSelection(DFWINDOW, int, int, DFRECT *);
static BOOL SelectionInWindow(DFWINDOW, int);
static int py = -1; /* the previous y mouse coordinate */
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* --------- SHIFT_F8 Key ------------ */
static void AddModeKey(DFWINDOW wnd)
{
if (isMultiLine(wnd)) {
wnd->AddMode ^= TRUE;
DfSendMessage(GetParent(wnd), ADDSTATUS,
wnd->AddMode ? ((PARAM) "Add Mode") : 0, 0);
}
}
#endif
/* --------- UP (Up Arrow) Key ------------ */
static void UpKey(DFWINDOW wnd, PARAM p2)
{
if (wnd->selection > 0) {
if (wnd->selection == wnd->wtop) {
BaseWndProc(LISTBOX, wnd, KEYBOARD, UP, p2);
DfPostMessage(wnd, LB_SELECTION, wnd->selection-1,
isMultiLine(wnd) ? p2 : FALSE);
}
else {
int newsel = wnd->selection-1;
if (wnd->wlines == ClientHeight(wnd))
while (*TextLine(wnd, newsel) == LINE)
--newsel;
DfPostMessage(wnd, LB_SELECTION, newsel,
#ifdef INCLUDE_EXTENDEDSELECTIONS
isMultiLine(wnd) ? p2 :
#endif
FALSE);
}
}
}
/* --------- DN (Down Arrow) Key ------------ */
static void DnKey(DFWINDOW wnd, PARAM p2)
{
if (wnd->selection < wnd->wlines-1) {
if (wnd->selection == wnd->wtop+ClientHeight(wnd)-1) {
BaseWndProc(LISTBOX, wnd, KEYBOARD, DN, p2);
DfPostMessage(wnd, LB_SELECTION, wnd->selection+1,
isMultiLine(wnd) ? p2 : FALSE);
}
else {
int newsel = wnd->selection+1;
if (wnd->wlines == ClientHeight(wnd))
while (*TextLine(wnd, newsel) == LINE)
newsel++;
DfPostMessage(wnd, LB_SELECTION, newsel,
#ifdef INCLUDE_EXTENDEDSELECTIONS
isMultiLine(wnd) ? p2 :
#endif
FALSE);
}
}
}
/* --------- HOME and PGUP Keys ------------ */
static void HomePgUpKey(DFWINDOW wnd, PARAM p1, PARAM p2)
{
BaseWndProc(LISTBOX, wnd, KEYBOARD, p1, p2);
DfPostMessage(wnd, LB_SELECTION, wnd->wtop,
#ifdef INCLUDE_EXTENDEDSELECTIONS
isMultiLine(wnd) ? p2 :
#endif
FALSE);
}
/* --------- END and PGDN Keys ------------ */
static void EndPgDnKey(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int bot;
BaseWndProc(LISTBOX, wnd, KEYBOARD, p1, p2);
bot = wnd->wtop+ClientHeight(wnd)-1;
if (bot > wnd->wlines-1)
bot = wnd->wlines-1;
DfPostMessage(wnd, LB_SELECTION, bot,
#ifdef INCLUDE_EXTENDEDSELECTIONS
isMultiLine(wnd) ? p2 :
#endif
FALSE);
}
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* --------- Space Bar Key ------------ */
static void SpacebarKey(DFWINDOW wnd, PARAM p2)
{
if (isMultiLine(wnd)) {
int sel = DfSendMessage(wnd, LB_CURRENTSELECTION, 0, 0);
if (sel != -1) {
if (wnd->AddMode)
FlipSelection(wnd, sel);
if (ItemSelected(wnd, sel)) {
if (!((int) p2 & (LEFTSHIFT | RIGHTSHIFT)))
wnd->AnchorPoint = sel;
ExtendSelections(wnd, sel, (int) p2);
}
else
wnd->AnchorPoint = -1;
DfSendMessage(wnd, PAINT, 0, 0);
}
}
}
#endif
/* --------- Enter ('\r') Key ------------ */
static void EnterKey(DFWINDOW wnd)
{
if (wnd->selection != -1) {
DfSendMessage(wnd, LB_SELECTION, wnd->selection, TRUE);
DfSendMessage(wnd, LB_CHOOSE, wnd->selection, 0);
}
}
/* --------- All Other Key Presses ------------ */
static void KeyPress(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int sel = wnd->selection+1;
while (sel < wnd->wlines) {
char *cp = TextLine(wnd, sel);
if (cp == NULL)
break;
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (isMultiLine(wnd))
cp++;
#endif
/* --- special for directory list box --- */
if (*cp == '[')
cp++;
if (tolower(*cp) == (int)p1) {
DfSendMessage(wnd, LB_SELECTION, sel,
isMultiLine(wnd) ? p2 : FALSE);
if (!SelectionInWindow(wnd, sel)) {
wnd->wtop = sel-ClientHeight(wnd)+1;
DfSendMessage(wnd, PAINT, 0, 0);
}
break;
}
sel++;
}
}
/* --------- KEYBOARD Message ------------ */
static int KeyboardMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
switch ((int) p1) {
#ifdef INCLUDE_EXTENDEDSELECTIONS
case SHIFT_F8:
AddModeKey(wnd);
return TRUE;
#endif
case UP:
TestExtended(wnd, p2);
UpKey(wnd, p2);
return TRUE;
case DN:
TestExtended(wnd, p2);
DnKey(wnd, p2);
return TRUE;
case PGUP:
case HOME:
TestExtended(wnd, p2);
HomePgUpKey(wnd, p1, p2);
return TRUE;
case PGDN:
case END:
TestExtended(wnd, p2);
EndPgDnKey(wnd, p1, p2);
return TRUE;
#ifdef INCLUDE_EXTENDEDSELECTIONS
case ' ':
SpacebarKey(wnd, p2);
break;
#endif
case '\r':
EnterKey(wnd);
return TRUE;
default:
KeyPress(wnd, p1, p2);
break;
}
return FALSE;
}
/* ------- LEFT_BUTTON Message -------- */
static int LeftButtonMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int my = (int) p2 - GetTop(wnd);
if (my >= wnd->wlines-wnd->wtop)
my = wnd->wlines - wnd->wtop;
if (!InsideRect(p1, p2, ClientRect(wnd)))
return FALSE;
if (wnd->wlines && my != py) {
int sel = wnd->wtop+my-1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
int sh = getshift();
if (!(sh & (LEFTSHIFT | RIGHTSHIFT))) {
if (!(sh & CTRLKEY))
ClearAllSelections(wnd);
wnd->AnchorPoint = sel;
DfSendMessage(wnd, PAINT, 0, 0);
}
#endif
DfSendMessage(wnd, LB_SELECTION, sel, TRUE);
py = my;
}
return TRUE;
}
/* ------------- DOUBLE_CLICK Message ------------ */
static int DoubleClickMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
if (WindowMoving || WindowSizing)
return FALSE;
if (wnd->wlines) {
DFRECT rc = ClientRect(wnd);
BaseWndProc(LISTBOX, wnd, DOUBLE_CLICK, p1, p2);
if (InsideRect(p1, p2, rc))
DfSendMessage(wnd, LB_CHOOSE, wnd->selection, 0);
}
return TRUE;
}
/* ------------ ADDTEXT Message -------------- */
static int AddTextMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int rtn = BaseWndProc(LISTBOX, wnd, ADDTEXT, p1, p2);
if (wnd->selection == -1)
DfSendMessage(wnd, LB_SETSELECTION, 0, 0);
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (*(char *)p1 == LISTSELECTOR)
wnd->SelectCount++;
#endif
return rtn;
}
/* --------- GETTEXT Message ------------ */
static void GetTextMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
if ((int)p2 != -1) {
char *cp1 = (char *)p1;
char *cp2 = TextLine(wnd, (int)p2);
while (cp2 && *cp2 && *cp2 != '\n')
*cp1++ = *cp2++;
*cp1 = '\0';
}
}
/* --------- LISTBOX Window Processing Module ------------ */
int ListBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
BaseWndProc(LISTBOX, wnd, msg, p1, p2);
wnd->selection = -1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
wnd->AnchorPoint = -1;
#endif
return TRUE;
case KEYBOARD:
if (WindowMoving || WindowSizing)
break;
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case LEFT_BUTTON:
if (LeftButtonMsg(wnd, p1, p2) == TRUE)
return TRUE;
break;
case DOUBLE_CLICK:
if (DoubleClickMsg(wnd, p1, p2))
return TRUE;
break;
case DFM_BUTTON_RELEASED:
if (WindowMoving || WindowSizing || VSliding)
break;
py = -1;
return TRUE;
case ADDTEXT:
return AddTextMsg(wnd, p1, p2);
case DFM_LB_GETTEXT:
GetTextMsg(wnd, p1, p2);
return TRUE;
case CLEARTEXT:
wnd->selection = -1;
#ifdef INCLUDE_EXTENDEDSELECTIONS
wnd->AnchorPoint = -1;
#endif
wnd->SelectCount = 0;
break;
case PAINT:
BaseWndProc(LISTBOX, wnd, msg, p1, p2);
WriteSelection(wnd, wnd->selection, TRUE, (DFRECT *)p1);
return TRUE;
case SCROLL:
case HORIZSCROLL:
case SCROLLPAGE:
case HORIZPAGE:
case SCROLLDOC:
BaseWndProc(LISTBOX, wnd, msg, p1, p2);
WriteSelection(wnd,wnd->selection,TRUE,NULL);
return TRUE;
case LB_CHOOSE:
DfSendMessage(GetParent(wnd), LB_CHOOSE, p1, p2);
return TRUE;
case LB_SELECTION:
ChangeSelection(wnd, (int) p1, (int) p2);
DfSendMessage(GetParent(wnd), LB_SELECTION,
wnd->selection, 0);
return TRUE;
case LB_CURRENTSELECTION:
return wnd->selection;
case LB_SETSELECTION:
ChangeSelection(wnd, (int) p1, 0);
return TRUE;
#ifdef INCLUDE_EXTENDEDSELECTIONS
case CLOSE_WINDOW:
if (isMultiLine(wnd) && wnd->AddMode) {
wnd->AddMode = FALSE;
DfSendMessage(GetParent(wnd), ADDSTATUS, 0, 0);
}
break;
#endif
default:
break;
}
return BaseWndProc(LISTBOX, wnd, msg, p1, p2);
}
static BOOL SelectionInWindow(DFWINDOW wnd, int sel)
{
return (wnd->wlines && sel >= wnd->wtop &&
sel < wnd->wtop+ClientHeight(wnd));
}
static void WriteSelection(DFWINDOW wnd, int sel,
int reverse, DFRECT *rc)
{
if (isVisible(wnd))
if (SelectionInWindow(wnd, sel))
WriteTextLine(wnd, rc, sel, reverse);
}
#ifdef INCLUDE_EXTENDEDSELECTIONS
/* ----- Test for extended selections in the listbox ----- */
static void TestExtended(DFWINDOW wnd, PARAM p2)
{
if (isMultiLine(wnd) && !wnd->AddMode &&
!((int) p2 & (LEFTSHIFT | RIGHTSHIFT))) {
if (wnd->SelectCount > 1) {
ClearAllSelections(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
}
}
}
/* ----- Clear selections in the listbox ----- */
static void ClearAllSelections(DFWINDOW wnd)
{
if (isMultiLine(wnd) && wnd->SelectCount > 0) {
int sel;
for (sel = 0; sel < wnd->wlines; sel++)
ClearSelection(wnd, sel);
}
}
/* ----- Invert a selection in the listbox ----- */
static void FlipSelection(DFWINDOW wnd, int sel)
{
if (isMultiLine(wnd)) {
if (ItemSelected(wnd, sel))
ClearSelection(wnd, sel);
else
SetSelection(wnd, sel);
}
}
static int ExtendSelections(DFWINDOW wnd, int sel, int shift)
{
if (shift & (LEFTSHIFT | RIGHTSHIFT) &&
wnd->AnchorPoint != -1) {
int i = sel;
int j = wnd->AnchorPoint;
int rtn;
if (j > i)
swap(i,j);
rtn = i - j;
while (j <= i)
SetSelection(wnd, j++);
return rtn;
}
return 0;
}
static void SetSelection(DFWINDOW wnd, int sel)
{
if (isMultiLine(wnd) && !ItemSelected(wnd, sel)) {
char *lp = TextLine(wnd, sel);
*lp = LISTSELECTOR;
wnd->SelectCount++;
}
}
static void ClearSelection(DFWINDOW wnd, int sel)
{
if (isMultiLine(wnd) && ItemSelected(wnd, sel)) {
char *lp = TextLine(wnd, sel);
*lp = ' ';
--wnd->SelectCount;
}
}
BOOL ItemSelected(DFWINDOW wnd, int sel)
{
if (sel != -1 && isMultiLine(wnd) && sel < wnd->wlines) {
char *cp = TextLine(wnd, sel);
return (int)((*cp) & 255) == LISTSELECTOR;
}
return FALSE;
}
#endif
static void ChangeSelection(DFWINDOW wnd,int sel,int shift)
{
if (sel != wnd->selection) {
#ifdef INCLUDE_EXTENDEDSELECTIONS
if (isMultiLine(wnd)) {
int sels;
if (!wnd->AddMode)
ClearAllSelections(wnd);
sels = ExtendSelections(wnd, sel, shift);
if (sels > 1)
DfSendMessage(wnd, PAINT, 0, 0);
if (sels == 0 && !wnd->AddMode) {
ClearSelection(wnd, wnd->selection);
SetSelection(wnd, sel);
wnd->AnchorPoint = sel;
}
}
#endif
WriteSelection(wnd, wnd->selection, FALSE, NULL);
wnd->selection = sel;
WriteSelection(wnd, sel, TRUE, NULL);
}
}
/* EOF */
rosapps/lib/dflat32/lists.c
-149
View File
@@ -1,149 +0,0 @@
/* --------------- lists.c -------------- */
#include "dflat32/dflat.h"
/* ----- set focus to the next sibling ----- */
void SetNextFocus (void)
{
if (inFocus != NULL)
{
DFWINDOW wnd1 = inFocus, pwnd;
while (TRUE)
{
pwnd = GetParent(wnd1);
if (NextWindow(wnd1) != NULL)
wnd1 = NextWindow(wnd1);
else if (pwnd != NULL)
wnd1 = FirstWindow(pwnd);
if (wnd1 == NULL || wnd1 == inFocus)
{
wnd1 = pwnd;
break;
}
if (GetClass(wnd1) == STATUSBAR || GetClass(wnd1) == MENUBAR)
continue;
if (isVisible(wnd1))
break;
}
if (wnd1 != NULL)
{
while (wnd1->childfocus != NULL)
wnd1 = wnd1->childfocus;
if (wnd1->condition != ISCLOSING)
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
}
}
}
/* ----- set focus to the previous sibling ----- */
void SetPrevFocus(void)
{
if (inFocus != NULL)
{
DFWINDOW wnd1 = inFocus, pwnd;
while (TRUE)
{
pwnd = GetParent(wnd1);
if (PrevWindow(wnd1) != NULL)
wnd1 = PrevWindow(wnd1);
else if (pwnd != NULL)
wnd1 = LastWindow(pwnd);
if (wnd1 == NULL || wnd1 == inFocus)
{
wnd1 = pwnd;
break;
}
if (GetClass(wnd1) == STATUSBAR)
continue;
if (isVisible(wnd1))
break;
}
if (wnd1 != NULL)
{
while (wnd1->childfocus != NULL)
wnd1 = wnd1->childfocus;
if (wnd1->condition != ISCLOSING)
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
}
}
}
/* ------- move a window to the end of its parents list ----- */
void ReFocus(DFWINDOW wnd)
{
if (GetParent(wnd) != NULL)
{
RemoveWindow(wnd);
AppendWindow(wnd);
ReFocus(GetParent(wnd));
}
}
/* ---- remove a window from the linked list ---- */
void RemoveWindow(DFWINDOW wnd)
{
if (wnd != NULL)
{
DFWINDOW pwnd = GetParent(wnd);
if (PrevWindow(wnd) != NULL)
NextWindow(PrevWindow(wnd)) = NextWindow(wnd);
if (NextWindow(wnd) != NULL)
PrevWindow(NextWindow(wnd)) = PrevWindow(wnd);
if (pwnd != NULL)
{
if (wnd == FirstWindow(pwnd))
FirstWindow(pwnd) = NextWindow(wnd);
if (wnd == LastWindow(pwnd))
LastWindow(pwnd) = PrevWindow(wnd);
}
}
}
/* ---- append a window to the linked list ---- */
void AppendWindow(DFWINDOW wnd)
{
if (wnd != NULL)
{
DFWINDOW pwnd = GetParent(wnd);
if (pwnd != NULL)
{
if (FirstWindow(pwnd) == NULL)
{
FirstWindow(pwnd) = wnd;
LastWindow(pwnd) = wnd;
PrevWindow(wnd) = NULL;
}
else
{
NextWindow(LastWindow(pwnd)) = wnd;
PrevWindow(wnd) = LastWindow(pwnd);
LastWindow(pwnd) = wnd;
}
}
NextWindow(wnd) = NULL;
}
}
/*
* if document windows and statusbar or menubar get the focus,
* pass it on
*/
void SkipApplicationControls(void)
{
BOOL EmptyAppl = FALSE;
int ct = 0;
while (!EmptyAppl && inFocus != NULL)
{
DFCLASS cl = GetClass(inFocus);
if (cl == MENUBAR || cl == STATUSBAR)
{
SetPrevFocus();
EmptyAppl = (cl == MENUBAR && ct++);
}
else
break;
}
}
/* EOF */
rosapps/lib/dflat32/log.c
-75
View File
@@ -1,75 +0,0 @@
/* ------------ log .c ------------ */
#include "dflat32/dflat.h"
#ifdef INCLUDE_LOGGING
static char *message[] = {
#undef DFlatMsg
#define DFlatMsg(m) " " #m,
#include "dflat32/dflatmsg.h"
NULL
};
static FILE *logfile = NULL;
extern DBOX Log;
void LogMessages (DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
if (logfile != NULL && message[msg][0] != ' ')
fprintf(logfile,
"%-20.20s %-12.12s %-20.20s, %5.5ld, %5.5ld\n",
wnd ? (GetTitle(wnd) ? GetTitle(wnd) : "") : "",
wnd ? ClassNames[GetClass(wnd)] : "",
message[msg]+1, p1, p2);
}
static int LogProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
DFWINDOW cwnd = ControlWindow(&Log, ID_LOGLIST);
char **mn = message;
switch (msg) {
case INITIATE_DIALOG:
AddAttribute(cwnd, MULTILINE | VSCROLLBAR);
while (*mn) {
DfSendMessage(cwnd, ADDTEXT, (PARAM) (*mn), 0);
mn++;
}
DfSendMessage(cwnd, SHOW_WINDOW, 0, 0);
break;
case DFM_COMMAND:
if ((int) p1 == ID_OK) {
int item;
int tl = GetTextLines(cwnd);
for (item = 0; item < tl; item++)
if (ItemSelected(cwnd, item))
mn[item][0] = LISTSELECTOR;
}
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
void MessageLog(DFWINDOW wnd)
{
if (DfDialogBox(wnd, &Log, TRUE, LogProc))
{
if (CheckBoxSetting(&Log, ID_LOGGING))
{
logfile = fopen("DFLAT.LOG", "wt");
SetCommandToggle(&MainMenu, ID_LOG);
}
else if (logfile != NULL)
{
fclose(logfile);
logfile = NULL;
ClearCommandToggle(&MainMenu, ID_LOG);
}
}
}
#endif
/* EOF */
rosapps/lib/dflat32/menu.c
-85
View File
@@ -1,85 +0,0 @@
/* ------------- menu.c ------------- */
#include "dflat32/dflat.h"
static struct PopDown *FindCmd(MBAR *mn, int cmd)
{
MENU *mnu = mn->PullDown;
while (mnu->Title != (void *)-1) {
struct PopDown *pd = mnu->Selections;
while (pd->SelectionTitle != NULL) {
if (pd->ActionId == cmd)
return pd;
pd++;
}
mnu++;
}
return NULL;
}
char *GetCommandText(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return pd->SelectionTitle;
return NULL;
}
BOOL isCascadedCommand(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return pd->Attrib & CASCADED;
return FALSE;
}
void ActivateCommand(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib &= ~INACTIVE;
}
void DeactivateCommand(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib |= INACTIVE;
}
BOOL isActive(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return !(pd->Attrib & INACTIVE);
return FALSE;
}
BOOL GetCommandToggle(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
return (pd->Attrib & CHECKED) != 0;
return FALSE;
}
void SetCommandToggle(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib |= CHECKED;
}
void ClearCommandToggle(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib &= ~CHECKED;
}
void InvertCommandToggle(MBAR *mn, int cmd)
{
struct PopDown *pd = FindCmd(mn, cmd);
if (pd != NULL)
pd->Attrib ^= CHECKED;
}
rosapps/lib/dflat32/menubar.c
-432
View File
@@ -1,432 +0,0 @@
/* ---------------- menubar.c ------------------ */
#include "dflat32/dflat.h"
static void reset_menubar(DFWINDOW);
static struct {
int x1, x2; /* position in menu bar */
char sc; /* shortcut key value */
} menu[10];
static int mctr;
MBAR *ActiveMenuBar;
static MENU *ActiveMenu;
static DFWINDOW mwnd;
static BOOL Selecting;
static DFWINDOW Cascaders[MAXCASCADES];
static int casc;
static DFWINDOW GetDocFocus(void);
/* ----------- SETFOCUS Message ----------- */
static int SetFocusMsg(DFWINDOW wnd, PARAM p1)
{
int rtn;
rtn = BaseWndProc(MENUBAR, wnd, SETFOCUS, p1, 0);
if (!(int)p1)
DfSendMessage(GetParent(wnd), ADDSTATUS, 0, 0);
return rtn;
}
/* --------- BUILDMENU Message --------- */
static void BuildMenuMsg(DFWINDOW wnd, PARAM p1)
{
int offset = 3;
reset_menubar(wnd);
mctr = 0;
ActiveMenuBar = (MBAR *) p1;
ActiveMenu = ActiveMenuBar->PullDown;
while (ActiveMenu->Title != NULL &&
ActiveMenu->Title != (void*)-1)
{
char *cp;
if (strlen(GetText(wnd)+offset) <
strlen(ActiveMenu->Title)+3)
break;
GetText(wnd) = DFrealloc(GetText(wnd),
strlen(GetText(wnd))+5);
memmove(GetText(wnd) + offset+4, GetText(wnd) + offset,
strlen(GetText(wnd))-offset+1);
CopyCommand(GetText(wnd)+offset,ActiveMenu->Title,FALSE,
wnd->WindowColors [STD_COLOR] [BG]);
menu[mctr].x1 = offset;
offset += strlen(ActiveMenu->Title) + (3+MSPACE);
menu[mctr].x2 = offset-MSPACE;
cp = strchr(ActiveMenu->Title, SHORTCUTCHAR);
if (cp)
menu[mctr].sc = tolower(*(cp+1));
mctr++;
ActiveMenu++;
}
ActiveMenu = ActiveMenuBar->PullDown;
}
/* ---------- PAINT Message ---------- */
static void PaintMsg(DFWINDOW wnd)
{
if (Selecting)
return;
if (wnd == inFocus)
DfSendMessage(GetParent(wnd), ADDSTATUS, 0, 0);
SetStandardColor(wnd);
wputs(wnd, GetText(wnd), 0, 0);
if (ActiveMenuBar == NULL)
return;
if (ActiveMenuBar->ActiveSelection != -1 &&
(wnd == inFocus || mwnd != NULL)) {
char *sel, *cp;
int offset, offset1;
sel = DFmalloc(200);
offset=menu[ActiveMenuBar->ActiveSelection].x1;
offset1=menu[ActiveMenuBar->ActiveSelection].x2;
GetText(wnd)[offset1] = '\0';
SetReverseColor(wnd);
memset(sel, '\0', 200);
strcpy(sel, GetText(wnd)+offset);
cp = strchr(sel, CHANGECOLOR);
if (cp != NULL)
*(cp + 2) = background | 0x80;
wputs(wnd, sel,
offset-ActiveMenuBar->ActiveSelection*4, 0);
GetText(wnd)[offset1] = ' ';
if (mwnd == NULL && wnd == inFocus) {
char *st = ActiveMenu
[ActiveMenuBar->ActiveSelection].StatusText;
if (st != NULL)
DfSendMessage(GetParent(wnd), ADDSTATUS,
(PARAM)st, 0);
}
free(sel);
}
}
/* ------------ KEYBOARD Message ------------- */
static void KeyboardMsg(DFWINDOW wnd, PARAM p1)
{
MENU *mnu;
int sel;
if (mwnd == NULL)
{
/* ----- search for menu bar shortcut keys ---- */
int c = tolower((int)p1);
int a = AltConvert((int)p1);
int j;
for (j = 0; j < mctr; j++) {
if ((inFocus == wnd && menu[j].sc == c) ||
(a && menu[j].sc == a)) {
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
DfSendMessage(wnd, MB_SELECTION, j, 0);
return;
}
}
}
/* -------- search for accelerator keys -------- */
mnu = ActiveMenu;
while (mnu->Title != (void *)-1) {
struct PopDown *pd = mnu->Selections;
if (mnu->PrepMenu)
(*(mnu->PrepMenu))(GetDocFocus(), mnu);
while (pd->SelectionTitle != NULL) {
if (pd->Accelerator == (int) p1) {
if (pd->Attrib & INACTIVE)
beep();
else {
if (pd->Attrib & TOGGLE)
pd->Attrib ^= CHECKED;
DfSendMessage(GetDocFocus(),
SETFOCUS, TRUE, 0);
DfPostMessage(GetParent(wnd),
DFM_COMMAND, pd->ActionId, 0);
}
return;
}
pd++;
}
mnu++;
}
switch ((int)p1)
{
case F1:
if (ActiveMenu == NULL || ActiveMenuBar == NULL)
break;
sel = ActiveMenuBar->ActiveSelection;
if (sel == -1)
{
BaseWndProc(MENUBAR, wnd, KEYBOARD, F1, 0);
return;
}
mnu = ActiveMenu+sel;
if (mwnd == NULL ||
mnu->Selections[0].SelectionTitle == NULL)
{
DisplayHelp(wnd,mnu->Title+1);
return;
}
break;
case '\r':
if (mwnd == NULL &&
ActiveMenuBar->ActiveSelection != -1)
DfSendMessage(wnd, MB_SELECTION,
ActiveMenuBar->ActiveSelection, 0);
break;
case F10:
if (wnd != inFocus && mwnd == NULL) {
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
if ( ActiveMenuBar->ActiveSelection == -1)
ActiveMenuBar->ActiveSelection = 0;
DfSendMessage(wnd, PAINT, 0, 0);
break;
}
/* ------- fall through ------- */
case ESC:
if (inFocus == wnd && mwnd == NULL) {
ActiveMenuBar->ActiveSelection = -1;
DfSendMessage(GetDocFocus(),SETFOCUS,TRUE,0);
DfSendMessage(wnd, PAINT, 0, 0);
}
break;
case FWD:
ActiveMenuBar->ActiveSelection++;
if (ActiveMenuBar->ActiveSelection == mctr)
ActiveMenuBar->ActiveSelection = 0;
if (mwnd != NULL)
DfSendMessage(wnd, MB_SELECTION,
ActiveMenuBar->ActiveSelection, 0);
else
DfSendMessage(wnd, PAINT, 0, 0);
break;
case BS:
if (ActiveMenuBar->ActiveSelection == 0 ||
ActiveMenuBar->ActiveSelection == -1)
ActiveMenuBar->ActiveSelection = mctr;
--ActiveMenuBar->ActiveSelection;
if (mwnd != NULL)
DfSendMessage(wnd, MB_SELECTION,
ActiveMenuBar->ActiveSelection, 0);
else
DfSendMessage(wnd, PAINT, 0, 0);
break;
default:
break;
}
}
/* --------------- LEFT_BUTTON Message ---------- */
static void LeftButtonMsg(DFWINDOW wnd, PARAM p1)
{
int i;
int mx = (int) p1 - GetLeft(wnd);
/* --- compute the selection that the left button hit --- */
for (i = 0; i < mctr; i++)
if (mx >= menu[i].x1-4*i &&
mx <= menu[i].x2-4*i-5)
break;
if (i < mctr)
if (i != ActiveMenuBar->ActiveSelection || mwnd == NULL)
DfSendMessage(wnd, MB_SELECTION, i, 0);
}
/* -------------- MB_SELECTION Message -------------- */
static void SelectionMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int wd, mx, my;
MENU *mnu;
if (!p2)
{
ActiveMenuBar->ActiveSelection = -1;
DfSendMessage(wnd, PAINT, 0, 0);
}
Selecting = TRUE;
mnu = ActiveMenu+(int)p1;
if (mnu->PrepMenu != NULL)
(*(mnu->PrepMenu))(GetDocFocus(), mnu);
wd = MenuWidth(mnu->Selections);
if (p2)
{
int brd = GetRight(wnd);
mx = GetLeft(mwnd) + WindowWidth(mwnd) - 1;
if (mx + wd > brd)
mx = brd - wd;
my = GetTop(mwnd) + mwnd->selection;
}
else
{
int offset = menu[(int)p1].x1 - 4 * (int)p1;
if (mwnd != NULL)
DfSendMessage(mwnd, CLOSE_WINDOW, 0, 0);
ActiveMenuBar->ActiveSelection = (int) p1;
if (offset > WindowWidth(wnd)-wd)
offset = WindowWidth(wnd)-wd;
mx = GetLeft(wnd)+offset;
my = GetTop(wnd)+1;
}
mwnd = DfCreateWindow(POPDOWNMENU, NULL,
mx, my,
MenuHeight(mnu->Selections),
wd,
NULL,
wnd,
NULL,
SHADOW);
if (!p2)
{
Selecting = FALSE;
DfSendMessage(wnd, PAINT, 0, 0);
Selecting = TRUE;
}
if (mnu->Selections[0].SelectionTitle != NULL)
{
DfSendMessage(mwnd, BUILD_SELECTIONS, (PARAM) mnu, 0);
DfSendMessage(mwnd, SETFOCUS, TRUE, 0);
DfSendMessage(mwnd, SHOW_WINDOW, 0, 0);
}
Selecting = FALSE;
}
/* --------- COMMAND Message ---------- */
static void CommandMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
if (p1 == ID_HELP)
{
BaseWndProc(MENUBAR, wnd, DFM_COMMAND, p1, p2);
return;
}
if (isCascadedCommand(ActiveMenuBar, (int)p1))
{
/* find the cascaded menu based on command id in p1 */
MENU *mnu = ActiveMenu+mctr;
while (mnu->Title != (void *)-1) {
if (mnu->CascadeId == (int) p1) {
if (casc < MAXCASCADES) {
Cascaders[casc++] = mwnd;
DfSendMessage(wnd, MB_SELECTION,
(PARAM)(mnu-ActiveMenu), TRUE);
}
break;
}
mnu++;
}
}
else {
if (mwnd != NULL)
DfSendMessage(mwnd, CLOSE_WINDOW, 0, 0);
DfSendMessage(GetDocFocus(), SETFOCUS, TRUE, 0);
DfPostMessage(GetParent(wnd), DFM_COMMAND, p1, p2);
}
}
/* --------------- CLOSE_POPDOWN Message --------------- */
static void ClosePopdownMsg(DFWINDOW wnd)
{
if (casc > 0)
DfSendMessage(Cascaders[--casc], CLOSE_WINDOW, 0, 0);
else
{
mwnd = NULL;
ActiveMenuBar->ActiveSelection = -1;
if (!Selecting)
{
DfSendMessage(GetDocFocus(), SETFOCUS, TRUE, 0);
DfSendMessage(wnd, PAINT, 0, 0);
}
}
}
/* ---------------- CLOSE_WINDOW Message --------------- */
static void CloseWindowMsg(DFWINDOW wnd)
{
if (GetText(wnd) != NULL)
{
free(GetText(wnd));
GetText(wnd) = NULL;
}
mctr = 0;
ActiveMenuBar->ActiveSelection = -1;
ActiveMenu = NULL;
ActiveMenuBar = NULL;
}
/* --- Window processing module for MENUBAR window class --- */
int MenuBarProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
switch (msg) {
case CREATE_WINDOW:
reset_menubar(wnd);
break;
case SETFOCUS:
return SetFocusMsg(wnd, p1);
case BUILDMENU:
BuildMenuMsg(wnd, p1);
break;
case PAINT:
if (!isVisible(wnd) || GetText(wnd) == NULL)
break;
PaintMsg(wnd);
return FALSE;
case BORDER:
if (mwnd == NULL)
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case KEYBOARD:
KeyboardMsg(wnd, p1);
return TRUE;
case LEFT_BUTTON:
LeftButtonMsg(wnd, p1);
return TRUE;
case MB_SELECTION:
SelectionMsg(wnd, p1, p2);
break;
case DFM_COMMAND:
CommandMsg(wnd, p1, p2);
return TRUE;
case INSIDE_WINDOW:
return InsideRect(p1, p2, WindowRect(wnd));
case CLOSE_POPDOWN:
ClosePopdownMsg(wnd);
return TRUE;
case CLOSE_WINDOW:
CloseWindowMsg(wnd);
rtn = BaseWndProc(MENUBAR, wnd, msg, p1, p2);
return rtn;
default:
break;
}
return BaseWndProc(MENUBAR, wnd, msg, p1, p2);
}
/* ------------- reset the MENUBAR -------------- */
static void reset_menubar(DFWINDOW wnd)
{
GetText(wnd) = DFrealloc(GetText(wnd), DfGetScreenWidth()+5);
memset(GetText(wnd), ' ', DfGetScreenWidth());
*(GetText(wnd)+WindowWidth(wnd)) = '\0';
}
static DFWINDOW GetDocFocus(void)
{
DFWINDOW wnd = ApplicationWindow;
if (wnd != NULL)
{
wnd = LastWindow(wnd);
while (wnd != NULL &&
(GetClass(wnd) == MENUBAR ||
GetClass(wnd) == STATUSBAR))
wnd = PrevWindow(wnd);
if (wnd != NULL)
{
while (wnd->childfocus != NULL)
wnd = wnd->childfocus;
}
}
return wnd ? wnd : ApplicationWindow;
}
/* EOF */
rosapps/lib/dflat32/menus.c
-126
View File
@@ -1,126 +0,0 @@
/* -------------- menus.c ------------- */
#include "dflat32/dflat.h"
/* --------------------- the main menu --------------------- */
DEFMENU(MainMenu)
/* --------------- the File popdown menu ----------------*/
POPDOWN( "~File", PrepFileMenu, "Read/write/print files. Go to DOS" )
SELECTION( "~New", ID_NEW, 0, 0 )
SELECTION( "~Open...", ID_OPEN, 0, 0 )
SEPARATOR
SELECTION( "~Save", ID_SAVE, ALT_S, INACTIVE)
SELECTION( "Save ~as...", ID_SAVEAS, 0, INACTIVE)
SELECTION( "D~elete", ID_DELETEFILE, 0, INACTIVE)
SEPARATOR
SELECTION( "~Print", ID_PRINT, 0, INACTIVE)
SELECTION( "P~rinter setup...", ID_PRINTSETUP, 0, 0 )
SEPARATOR
SELECTION( "~DOS", ID_DOS, 0, 0 )
SELECTION( "E~xit", ID_EXIT, ALT_X, 0 )
ENDPOPDOWN
/* --------------- the Edit popdown menu ----------------*/
POPDOWN( "~Edit", PrepEditMenu, "Clipboard, delete text, paragraph" )
SELECTION( "~Undo", ID_UNDO, ALT_BS, INACTIVE)
SEPARATOR
SELECTION( "Cu~t", ID_CUT, SHIFT_DEL, INACTIVE)
SELECTION( "~Copy", ID_COPY, CTRL_INS, INACTIVE)
SELECTION( "~Paste", ID_PASTE, SHIFT_INS, INACTIVE)
SEPARATOR
SELECTION( "Cl~ear", ID_CLEAR, 0, INACTIVE)
SELECTION( "~Delete", ID_DELETETEXT, DEL, INACTIVE)
SEPARATOR
SELECTION( "Pa~ragraph", ID_PARAGRAPH, ALT_P,INACTIVE)
ENDPOPDOWN
/* --------------- the Search popdown menu ----------------*/
POPDOWN( "~Search", PrepSearchMenu, "Search and replace" )
SELECTION( "~Search...", ID_SEARCH, 0, INACTIVE)
SELECTION( "~Replace...",ID_REPLACE, 0, INACTIVE)
SELECTION( "~Next", ID_SEARCHNEXT, F3, INACTIVE)
ENDPOPDOWN
/* ------------ the Utilities popdown menu --------------- */
POPDOWN( "~Utilities", NULL, "Utility programs" )
SELECTION( "~Calendar", ID_CALENDAR, 0, 0)
// SELECTION( "~Bar chart", ID_BARCHART, 0, 0)
ENDPOPDOWN
/* ------------- the Options popdown menu ---------------*/
POPDOWN( "~Options", NULL, "Editor and display options" )
SELECTION( "~Display...", ID_DISPLAY, 0, 0 )
SEPARATOR
#ifdef INCLUDE_LOGGING
SELECTION( "~Log messages", ID_LOG, ALT_L, 0 )
SEPARATOR
#endif
SELECTION( "~Insert", ID_INSERT, INS, TOGGLE)
SELECTION( "~Word wrap", ID_WRAP, 0, TOGGLE)
SELECTION( "~Tabs ( )", ID_TABS, 0, CASCADED)
SEPARATOR
SELECTION( "~Save options", ID_SAVEOPTIONS, 0, 0 )
ENDPOPDOWN
/* --------------- the Window popdown menu --------------*/
POPDOWN( "~Window", PrepWindowMenu, "Select/close document windows" )
SELECTION( NULL, ID_CLOSEALL, 0, 0)
SEPARATOR
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( NULL, ID_WINDOW, 0, 0 )
SELECTION( "~More Windows...", ID_MOREWINDOWS, 0, 0)
SELECTION( NULL, ID_WINDOW, 0, 0 )
ENDPOPDOWN
/* --------------- the Help popdown menu ----------------*/
POPDOWN( "~Help", NULL, "Get help" )
SELECTION( "~Help for help...", ID_HELPHELP, 0, 0 )
SELECTION( "~Extended help...", ID_EXTHELP, 0, 0 )
SELECTION( "~Keys help...", ID_KEYSHELP, 0, 0 )
SELECTION( "Help ~index...", ID_HELPINDEX, 0, 0 )
SEPARATOR
SELECTION( "~About...", ID_ABOUT, 0, 0 )
#ifdef TESTING_DFLAT
SEPARATOR
SELECTION( "~Reload help database",ID_LOADHELP,0, 0 )
#endif
ENDPOPDOWN
/* ----- cascaded pulldown from Tabs... above ----- */
CASCADED_POPDOWN( ID_TABS, NULL )
SELECTION( "~2 tab stops", ID_TAB2, 0, 0)
SELECTION( "~4 tab stops", ID_TAB4, 0, 0)
SELECTION( "~6 tab stops", ID_TAB6, 0, 0)
SELECTION( "~8 tab stops", ID_TAB8, 0, 0)
ENDPOPDOWN
ENDMENU
/* ------------- the System Menu --------------------- */
DEFMENU(SystemMenu)
POPDOWN("System Menu", NULL, NULL)
#ifdef INCLUDE_RESTORE
SELECTION("~Restore", ID_SYSRESTORE, 0, 0 )
#endif
SELECTION("~Move", ID_SYSMOVE, 0, 0 )
SELECTION("~Size", ID_SYSSIZE, 0, 0 )
#ifdef INCLUDE_MINIMIZE
SELECTION("Mi~nimize", ID_SYSMINIMIZE, 0, 0 )
#endif
#ifdef INCLUDE_MAXIMIZE
SELECTION("Ma~ximize", ID_SYSMAXIMIZE, 0, 0 )
#endif
SEPARATOR
SELECTION("~Close", ID_SYSCLOSE, CTRL_F4, 0 )
ENDPOPDOWN
ENDMENU
rosapps/lib/dflat32/message.c
-681
View File
@@ -1,681 +0,0 @@
/* --------- message.c ---------- */
#include "dflat32/dflat.h"
#include "dflat32/system.h"
static int handshaking = 0;
BOOL AllocTesting = FALSE;
jmp_buf AllocError;
BOOL AltDown = FALSE;
/* ---------- event queue ---------- */
static struct events
{
DFMESSAGE event;
int mx;
int my;
} EventQueue[MAXMESSAGES];
/* ---------- message queue --------- */
static struct msgs
{
DFWINDOW wnd;
DFMESSAGE msg;
PARAM p1;
PARAM p2;
} MsgQueue[MAXMESSAGES];
static int EventQueueOnCtr;
static int EventQueueOffCtr;
static int EventQueueCtr;
static int MsgQueueOnCtr;
static int MsgQueueOffCtr;
static int MsgQueueCtr;
DFWINDOW CaptureMouse;
DFWINDOW CaptureKeyboard;
static BOOL NoChildCaptureMouse;
static BOOL NoChildCaptureKeyboard;
static int doubletimer = -1;
static int delaytimer = -1;
static int clocktimer = -1;
static DFWINDOW Cwnd;
static char ermsg[] = "Error accessing drive x";
static void StopMsg(void)
{
ClearClipboard();
ClearDialogBoxes();
restorecursor();
unhidecursor();
}
SHORT DfGetScreenHeight (void)
{
return sScreenHeight;
}
SHORT DfGetScreenWidth (void)
{
return sScreenWidth;
}
/* ------------ initialize the message system --------- */
BOOL DfInitialize (VOID)
{
CONSOLE_SCREEN_BUFFER_INFO csbi;
AllocTesting = TRUE;
if (setjmp(AllocError) != 0)
{
StopMsg();
return FALSE;
}
/* get input and output handles */
hInput = GetStdHandle (STD_INPUT_HANDLE);
hOutput = GetStdHandle (STD_OUTPUT_HANDLE);
/* get screen size */
GetConsoleScreenBufferInfo (hOutput, &csbi);
sScreenHeight = (csbi.srWindow.Bottom - csbi.srWindow.Top) + 1;
sScreenWidth = (csbi.srWindow.Right - csbi.srWindow.Left) + 1;
/* enable mouse events */
SetConsoleMode (hInput, ENABLE_MOUSE_INPUT);
savecursor();
hidecursor();
CaptureMouse = NULL;
CaptureKeyboard = NULL;
NoChildCaptureMouse = FALSE;
NoChildCaptureKeyboard = FALSE;
MsgQueueOnCtr = 0;
MsgQueueOffCtr = 0;
MsgQueueCtr = 0;
EventQueueOnCtr = 0;
EventQueueOffCtr = 0;
EventQueueCtr = 0;
DfPostMessage (NULL, DFM_START, 0, 0);
return TRUE;
}
void DfTerminate (void)
{
}
/* ----- post an event and parameters to event queue ---- */
static void PostEvent(DFMESSAGE event, int p1, int p2)
{
if (EventQueueCtr != MAXMESSAGES) {
EventQueue[EventQueueOnCtr].event = event;
EventQueue[EventQueueOnCtr].mx = p1;
EventQueue[EventQueueOnCtr].my = p2;
if (++EventQueueOnCtr == MAXMESSAGES)
EventQueueOnCtr = 0;
EventQueueCtr++;
}
}
/* ------ collect mouse, clock, and keyboard events ----- */
static void collect_events(void)
{
static int OldShiftKeys = 0;
int sk = 0;
#ifdef TIMER_AVAILABLE
static BOOL flipflop = FALSE;
static char timestr[9];
struct tm *now;
int hr;
#endif
HANDLE hInput = GetStdHandle (STD_INPUT_HANDLE);
INPUT_RECORD ir;
DWORD dwRead;
int c;
#ifdef TIMER_AVAILABLE
/* -------- test for a clock event (one/second) ------- */
if (timed_out(clocktimer))
{
/* ----- get the current time ----- */
time_t t = time(NULL);
now = localtime(&t);
hr = now->tm_hour > 12 ?
now->tm_hour - 12 :
now->tm_hour;
if (hr == 0)
hr = 12;
sprintf(timestr, "%2d:%02d", hr, now->tm_min);
strcpy(timestr+5, now->tm_hour > 11 ? "pm " : "am ");
/* ------- blink the : at one-second intervals ----- */
if (flipflop)
*(timestr+2) = ' ';
flipflop ^= TRUE;
/* -------- reset the timer -------- */
set_timer(clocktimer, 1);
/* -------- post the clock event -------- */
PostEvent(CLOCKTICK, (PARAM)timestr, 0);
}
#endif
// WaitForSingleObject (hInput, INFINITE);
ReadConsoleInput (hInput, &ir, 1, &dwRead);
if ((ir.EventType == KEY_EVENT) &&
(ir.Event.KeyEvent.bKeyDown == TRUE))
{
/* handle key down events */
/* handle shift state changes */
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_ALT_PRESSED | RIGHT_ALT_PRESSED))
{
sk |= ALTKEY;
}
if (ir.Event.KeyEvent.dwControlKeyState &
(LEFT_CTRL_PRESSED | RIGHT_CTRL_PRESSED))
{
sk |= CTRLKEY;
}
if (ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED)
{
sk |= LEFTSHIFT + RIGHTSHIFT;
}
if (sk != OldShiftKeys)
{
OldShiftKeys = sk;
/* the shift status changed */
PostEvent(SHIFT_CHANGED, sk, 0);
#if 0
if (sk & ALTKEY)
AltDown = TRUE;
else
AltDown = FALSE;
#endif
}
if (ir.Event.KeyEvent.uChar.AsciiChar == 0)
{
switch (ir.Event.KeyEvent.wVirtualKeyCode)
{
case VK_F1:
c = F1;
break;
case VK_F4:
if (sk & ALTKEY)
c = ALT_F4;
else if (sk & CTRLKEY)
c = CTRL_F4;
else
c = F4;
case VK_F10:
c = F10;
break;
case VK_UP:
c = UP;
break;
case VK_DOWN:
c = DN;
break;
case VK_LEFT:
c = BS;
break;
case VK_RIGHT:
c = FWD;
break;
case VK_INSERT:
c = INS;
break;
case VK_DELETE:
c = DEL;
break;
case VK_HOME:
c = HOME;
break;
case VK_END:
c = END;
break;
case VK_PRIOR:
c = PGUP;
break;
case VK_NEXT:
c = PGDN;
break;
default:
return;
}
}
else
{
/* special handling of SHIFT+TAB */
if (ir.Event.KeyEvent.uChar.AsciiChar == VK_TAB &&
(ir.Event.KeyEvent.dwControlKeyState & SHIFT_PRESSED))
c = SHIFT_HT;
else
c = ir.Event.KeyEvent.uChar.AsciiChar;
}
PostEvent (KEYBOARD, c, sk);
}
else if (ir.EventType == MOUSE_EVENT)
{
/* handle mouse events */
if (ir.Event.MouseEvent.dwEventFlags == MOUSE_MOVED)
{
PostEvent (MOUSE_MOVED,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwEventFlags == DOUBLE_CLICK)
{
if (ir.Event.MouseEvent.dwButtonState ==
FROM_LEFT_1ST_BUTTON_PRESSED)
{
PostEvent (DOUBLE_CLICK,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
}
else if (ir.Event.MouseEvent.dwEventFlags == 0)
{
/* single click */
if (ir.Event.MouseEvent.dwButtonState ==
FROM_LEFT_1ST_BUTTON_PRESSED)
{
PostEvent (LEFT_BUTTON,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwButtonState ==
RIGHTMOST_BUTTON_PRESSED)
{
PostEvent (RIGHT_BUTTON,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
else if (ir.Event.MouseEvent.dwButtonState == 0)
{
PostEvent (DFM_BUTTON_RELEASED,
ir.Event.MouseEvent.dwMousePosition.X,
ir.Event.MouseEvent.dwMousePosition.Y);
}
}
}
}
/* ----- post a message and parameters to msg queue ---- */
void DfPostMessage(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
if (msg == ENDDIALOG)
{
msg++;
--msg;
}
if (MsgQueueCtr != MAXMESSAGES)
{
MsgQueue[MsgQueueOnCtr].wnd = wnd;
MsgQueue[MsgQueueOnCtr].msg = msg;
MsgQueue[MsgQueueOnCtr].p1 = p1;
MsgQueue[MsgQueueOnCtr].p2 = p2;
if (++MsgQueueOnCtr == MAXMESSAGES)
MsgQueueOnCtr = 0;
MsgQueueCtr++;
}
}
/* --------- send a message to a window ----------- */
int DfSendMessage(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn = TRUE, x, y;
#ifdef INCLUDE_LOGGING
LogMessages(wnd, msg, p1, p2);
#endif
if (wnd != NULL)
switch (msg) {
case PAINT:
case BORDER:
/* ------- don't send these messages unless the
window is visible -------- */
if (isVisible(wnd))
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
case RIGHT_BUTTON:
case LEFT_BUTTON:
case DOUBLE_CLICK:
case DFM_BUTTON_RELEASED:
/* --- don't send these messages unless the
window is visible or has captured the mouse -- */
if (isVisible(wnd) || wnd == CaptureMouse)
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
case KEYBOARD:
case SHIFT_CHANGED:
/* ------- don't send these messages unless the
window is visible or has captured the keyboard -- */
if (!(isVisible(wnd) || wnd == CaptureKeyboard))
break;
default:
rtn = (*wnd->wndproc)(wnd, msg, p1, p2);
break;
}
/* ----- window processor returned true or the message was sent
to no window at all (NULL) ----- */
if (rtn != FALSE) {
/* --------- process messages that a window sends to the
system itself ---------- */
switch (msg) {
case DFM_STOP:
StopMsg();
break;
/* ------- clock messages --------- */
case CAPTURE_CLOCK:
Cwnd = wnd;
set_timer(clocktimer, 0);
break;
case RELEASE_CLOCK:
Cwnd = NULL;
disable_timer(clocktimer);
break;
/* -------- keyboard messages ------- */
case KEYBOARD_CURSOR:
if (wnd == NULL)
cursor((int)p1, (int)p2);
else if (wnd == inFocus)
cursor(GetClientLeft(wnd)+(int)p1,
GetClientTop(wnd)+(int)p2);
break;
case CAPTURE_KEYBOARD:
if (p2)
((DFWINDOW)p2)->PrevKeyboard=CaptureKeyboard;
else
wnd->PrevKeyboard = CaptureKeyboard;
CaptureKeyboard = wnd;
NoChildCaptureKeyboard = (int)p1;
break;
case RELEASE_KEYBOARD:
if (wnd != NULL)
{
if (CaptureKeyboard == wnd || (int)p1)
CaptureKeyboard = wnd->PrevKeyboard;
else
{
DFWINDOW twnd = CaptureKeyboard;
while (twnd != NULL)
{
if (twnd->PrevKeyboard == wnd)
{
twnd->PrevKeyboard = wnd->PrevKeyboard;
break;
}
twnd = twnd->PrevKeyboard;
}
if (twnd == NULL)
CaptureKeyboard = NULL;
}
wnd->PrevKeyboard = NULL;
}
else
CaptureKeyboard = NULL;
NoChildCaptureKeyboard = FALSE;
break;
case CURRENT_KEYBOARD_CURSOR:
curr_cursor(&x, &y);
*(int*)p1 = x;
*(int*)p2 = y;
break;
case SAVE_CURSOR:
savecursor();
break;
case RESTORE_CURSOR:
restorecursor();
break;
case HIDE_CURSOR:
normalcursor();
hidecursor();
break;
case SHOW_CURSOR:
if (p1)
set_cursor_size(100);
else
set_cursor_size(5);
unhidecursor();
break;
case CAPTURE_MOUSE:
if (p2)
((DFWINDOW)p2)->PrevMouse = CaptureMouse;
else
wnd->PrevMouse = CaptureMouse;
CaptureMouse = wnd;
NoChildCaptureMouse = (int)p1;
break;
case RELEASE_MOUSE:
if (wnd != NULL)
{
if (CaptureMouse == wnd || (int)p1)
CaptureMouse = wnd->PrevMouse;
else
{
DFWINDOW twnd = CaptureMouse;
while (twnd != NULL)
{
if (twnd->PrevMouse == wnd)
{
twnd->PrevMouse = wnd->PrevMouse;
break;
}
twnd = twnd->PrevMouse;
}
if (twnd == NULL)
CaptureMouse = NULL;
}
wnd->PrevMouse = NULL;
}
else
CaptureMouse = NULL;
NoChildCaptureMouse = FALSE;
break;
default:
break;
}
}
return rtn;
}
static DFRECT VisibleRect(DFWINDOW wnd)
{
DFRECT rc = WindowRect(wnd);
if (!TestAttribute(wnd, NOCLIP))
{
DFWINDOW pwnd = GetParent(wnd);
DFRECT prc;
prc = ClientRect(pwnd);
while (pwnd != NULL)
{
if (TestAttribute(pwnd, NOCLIP))
break;
rc = subRectangle(rc, prc);
if (!ValidRect(rc))
break;
if ((pwnd = GetParent(pwnd)) != NULL)
prc = ClientRect(pwnd);
}
}
return rc;
}
/* ----- find window that mouse coordinates are in --- */
static DFWINDOW inWindow(DFWINDOW wnd, int x, int y)
{
DFWINDOW Hit = NULL;
while (wnd != NULL) {
if (isVisible(wnd)) {
DFWINDOW wnd1;
DFRECT rc = VisibleRect(wnd);
if (InsideRect(x, y, rc))
Hit = wnd;
if ((wnd1 = inWindow(LastWindow(wnd), x, y)) != NULL)
Hit = wnd1;
if (Hit != NULL)
break;
}
wnd = PrevWindow(wnd);
}
return Hit;
}
static DFWINDOW MouseWindow(int x, int y)
{
/* get the window in which a mouse event occurred */
DFWINDOW Mwnd = inWindow(ApplicationWindow, x, y);
/* ---- process mouse captures ----- */
if (CaptureMouse != NULL)
{
if (NoChildCaptureMouse ||
Mwnd == NULL ||
!isAncestor(Mwnd, CaptureMouse))
Mwnd = CaptureMouse;
}
return Mwnd;
}
void handshake(void)
{
handshaking++;
DfDispatchMessage ();
--handshaking;
}
/* ---- dispatch messages to the message proc function ---- */
BOOL DfDispatchMessage (void)
{
DFWINDOW Mwnd, Kwnd;
/* -------- collect mouse and keyboard events ------- */
collect_events();
/* --------- dequeue and process events -------- */
while (EventQueueCtr > 0)
{
struct events ev;
ev = EventQueue[EventQueueOffCtr];
if (++EventQueueOffCtr == MAXMESSAGES)
EventQueueOffCtr = 0;
--EventQueueCtr;
/* get the window in which a keyboard event occurred */
Kwnd = inFocus;
/* process keyboard captures */
if (CaptureKeyboard != NULL)
{
if (Kwnd == NULL ||
NoChildCaptureKeyboard ||
!isAncestor(Kwnd, CaptureKeyboard))
Kwnd = CaptureKeyboard;
}
/* send mouse and keyboard messages to the
window that should get them */
switch (ev.event)
{
case SHIFT_CHANGED:
case KEYBOARD:
if (!handshaking)
DfSendMessage(Kwnd, ev.event, ev.mx, ev.my);
break;
case LEFT_BUTTON:
if (!handshaking)
{
Mwnd = MouseWindow(ev.mx, ev.my);
if (!CaptureMouse ||
(!NoChildCaptureMouse &&
isAncestor(Mwnd, CaptureMouse)))
{
if (Mwnd != inFocus)
DfSendMessage(Mwnd, SETFOCUS, TRUE, 0);
DfSendMessage(Mwnd, LEFT_BUTTON, ev.mx, ev.my);
}
}
break;
case DFM_BUTTON_RELEASED:
case DOUBLE_CLICK:
case RIGHT_BUTTON:
if (handshaking)
break;
case MOUSE_MOVED:
Mwnd = MouseWindow(ev.mx, ev.my);
DfSendMessage(Mwnd, ev.event, ev.mx, ev.my);
break;
case CLOCKTICK:
DfSendMessage(Cwnd, ev.event, ev.mx, ev.my);
break;
default:
break;
}
}
/* ------ dequeue and process messages ----- */
while (MsgQueueCtr > 0)
{
struct msgs mq;
mq = MsgQueue[MsgQueueOffCtr];
if (++MsgQueueOffCtr == MAXMESSAGES)
MsgQueueOffCtr = 0;
--MsgQueueCtr;
DfSendMessage (mq.wnd, mq.msg, mq.p1, mq.p2);
if (mq.msg == ENDDIALOG)
return FALSE;
if (mq.msg == DFM_STOP)
return FALSE;
}
return TRUE;
}
/* EOF */
rosapps/lib/dflat32/msgbox.c
-216
View File
@@ -1,216 +0,0 @@
/* ------------------ msgbox.c ------------------ */
#include "dflat32/dflat.h"
extern DBOX MsgBox;
extern DBOX InputBoxDB;
DFWINDOW CancelWnd;
static int ReturnValue;
int MessageBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
GetClass(wnd) = MESSAGEBOX;
InitWindowColors(wnd);
ClearAttribute(wnd, CONTROLBOX);
break;
case KEYBOARD:
if (p1 == '\r' || p1 == ESC)
ReturnValue = (int)p1;
break;
default:
break;
}
return BaseWndProc(MESSAGEBOX, wnd, msg, p1, p2);
}
int YesNoBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
GetClass(wnd) = MESSAGEBOX;
InitWindowColors(wnd);
ClearAttribute(wnd, CONTROLBOX);
break;
case KEYBOARD: {
int c = tolower((int)p1);
if (c == 'y')
DfSendMessage(wnd, DFM_COMMAND, ID_OK, 0);
else if (c == 'n')
DfSendMessage(wnd, DFM_COMMAND, ID_CANCEL, 0);
break;
}
default:
break;
}
return BaseWndProc(MESSAGEBOX, wnd, msg, p1, p2);
}
int ErrorBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
GetClass(wnd) = ERRORBOX;
InitWindowColors(wnd);
break;
case KEYBOARD:
if (p1 == '\r' || p1 == ESC)
ReturnValue = (int)p1;
break;
default:
break;
}
return BaseWndProc(ERRORBOX, wnd, msg, p1, p2);
}
int CancelBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
CancelWnd = wnd;
DfSendMessage(wnd, CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, CAPTURE_KEYBOARD, 0, 0);
break;
case DFM_COMMAND:
if ((int) p1 == ID_CANCEL && (int) p2 == 0)
DfSendMessage(GetParent(wnd), msg, p1, p2);
return TRUE;
case CLOSE_WINDOW:
CancelWnd = NULL;
DfSendMessage(wnd, RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, RELEASE_KEYBOARD, 0, 0);
p1 = TRUE;
break;
default:
break;
}
return BaseWndProc(MESSAGEBOX, wnd, msg, p1, p2);
}
void CloseCancelBox(void)
{
if (CancelWnd != NULL)
DfSendMessage(CancelWnd, CLOSE_WINDOW, 0, 0);
}
static char *InputText;
static int TextLength;
int InputBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
switch (msg) {
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(ControlWindow(&InputBoxDB,ID_INPUTTEXT),
SETTEXTLENGTH, TextLength, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == ID_OK && (int) p2 == 0)
GetItemText(wnd, ID_INPUTTEXT,
InputText, TextLength);
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
BOOL InputBox(DFWINDOW wnd,char *ttl,char *msg,char *text,int len)
{
InputText = text;
TextLength = len;
InputBoxDB.dwnd.title = ttl;
InputBoxDB.dwnd.w = 4 +
max(20, max(len, max((int)strlen(ttl), (int)strlen(msg))));
InputBoxDB.ctl[1].dwnd.x = (InputBoxDB.dwnd.w-2-len)/2;
InputBoxDB.ctl[0].dwnd.w = strlen(msg);
InputBoxDB.ctl[0].itext = msg;
InputBoxDB.ctl[1].dwnd.w = len;
InputBoxDB.ctl[2].dwnd.x = (InputBoxDB.dwnd.w - 20) / 2;
InputBoxDB.ctl[3].dwnd.x = InputBoxDB.ctl[2].dwnd.x + 10;
InputBoxDB.ctl[2].isetting = ON;
InputBoxDB.ctl[3].isetting = ON;
return DfDialogBox(wnd, &InputBoxDB, TRUE, InputBoxProc);
}
BOOL GenericMessage(DFWINDOW wnd,char *ttl,char *msg,int buttonct,
int (*wndproc)(struct window *,enum messages,PARAM,PARAM),
char *b1, char *b2, int c1, int c2, int isModal)
{
BOOL rtn;
MsgBox.dwnd.title = ttl;
MsgBox.ctl[0].dwnd.h = MsgHeight(msg);
if (ttl)
MsgBox.ctl[0].dwnd.w = max(max(MsgWidth(msg),
(int)(buttonct*8 + buttonct + 2)), (int)strlen(ttl)+2);
else
MsgBox.ctl[0].dwnd.w = max(MsgWidth(msg), (int)(buttonct*8 + buttonct + 2));
MsgBox.dwnd.h = MsgBox.ctl[0].dwnd.h+6;
MsgBox.dwnd.w = MsgBox.ctl[0].dwnd.w+4;
if (buttonct == 1)
MsgBox.ctl[1].dwnd.x = (MsgBox.dwnd.w - 10) / 2;
else {
MsgBox.ctl[1].dwnd.x = (MsgBox.dwnd.w - 20) / 2;
MsgBox.ctl[2].dwnd.x = MsgBox.ctl[1].dwnd.x + 10;
MsgBox.ctl[2].class = BUTTON;
}
MsgBox.ctl[1].dwnd.y = MsgBox.dwnd.h - 4;
MsgBox.ctl[2].dwnd.y = MsgBox.dwnd.h - 4;
MsgBox.ctl[0].itext = msg;
MsgBox.ctl[1].itext = b1;
MsgBox.ctl[2].itext = b2;
MsgBox.ctl[1].command = c1;
MsgBox.ctl[2].command = c2;
MsgBox.ctl[1].isetting = ON;
MsgBox.ctl[2].isetting = ON;
rtn = DfDialogBox(wnd, &MsgBox, isModal, wndproc);
MsgBox.ctl[2].class = 0;
return rtn;
}
DFWINDOW MomentaryMessage(char *msg)
{
DFWINDOW wnd = DfCreateWindow(
TEXTBOX,
NULL,
-1,-1,MsgHeight(msg)+2,MsgWidth(msg)+2,
NULL,NULL,NULL,
HASBORDER | SHADOW | SAVESELF);
DfSendMessage(wnd, SETTEXT, (PARAM) msg, 0);
WindowClientColor(wnd, WHITE, GREEN);
WindowFrameColor(wnd, WHITE, GREEN);
DfSendMessage (wnd, SHOW_WINDOW, 0, 0);
return wnd;
}
int MsgHeight(char *msg)
{
int h = 1;
while ((msg = strchr(msg, '\n')) != NULL)
{
h++;
msg++;
}
return min(h, DfGetScreenHeight ()-10);
}
int MsgWidth(char *msg)
{
int w = 0;
char *cp = msg;
while ((cp = strchr(msg, '\n')) != NULL)
{
w = max(w, (int) (cp-msg));
msg = cp+1;
}
return min(max((int)strlen(msg), (int)w), DfGetScreenWidth()-10);
}
/* EOF */
rosapps/lib/dflat32/normal.c
-1085
View File
File diff suppressed because it is too large Load Diff
rosapps/lib/dflat32/pictbox.c
-284
View File
@@ -1,284 +0,0 @@
/* -------------- pictbox.c -------------- */
#include "dflat32/dflat.h"
typedef struct {
enum VectTypes vt;
DFRECT rc;
} VECT;
unsigned char CharInWnd[] = "ijڿÙÀÅôÁÂ";
unsigned char VectCvt[3][11][2][4] = {
{ /* --- first character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"ÚÃÀ"}},
{{"Ú¿"}, {"³³³"}},
{{"ÚÂÂ"}, {"ÚÃÃ"}},
{{"¿¿¿"}, {"¿¿¿"}},
{{"ÙÙÙ"}, {"ÙÙÙ"}},
{{"ÀÁÁ"}, {"ÃÃÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÅÅ"}, {"ÃÃÃ"}},
{{"´´´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÁÁÁ"}},
{{"ÂÂÂ"}, {"ÂÅÅ"}} },
{ /* --- middle character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"ÂÅÁ"}},
{{"ÃÅ´"}, {"³³³"}},
{{"ÚÚÚ"}, {"ÚÚÚ"}},
{{"¿¿¿"}, {"¿¿¿"}},
{{"ÙÙÙ"}, {"ÙÙÙ"}},
{{"ÀÀÀ"}, {"ÀÀÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÃÃ"}, {"ÃÃÃ"}},
{{"ÅÅ´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÅÅÁ"}},
{{"ÂÂÂ"}, {"ÂÂÂ"}} },
{ /* --- last character in collision vector --- */
/* ( drawing Ä ) ( drawing ³ ) */
{{"ÄÄÄ"}, {"¿´Ù"}},
{{"ÀÁÙ"}, {"³³³"}},
{{"ÚÚÚ"}, {"ÚÚÚ"}},
{{"¿"}, {"¿´´"}},
{{"ÁÁÙ"}, {"´´Ù"}},
{{"ÀÀÀ"}, {"ÀÀÀ"}},
{{"ÅÅÅ"}, {"ÅÅÅ"}},
{{"ÃÃÃ"}, {"ÃÃÃ"}},
{{"ÅÅ´"}, {"´´´"}},
{{"ÁÁÁ"}, {"ÅÅÁ"}},
{{"ÂÂÂ"}, {"ÂÂÂ"}} }
};
/* -- compute whether character is first, middle, or last -- */
static int FindVector(DFWINDOW wnd, DFRECT rc, int x, int y)
{
DFRECT rcc;
VECT *vc = wnd->VectorList;
int i, coll = -1;
for (i = 0; i < wnd->VectorCount; i++) {
if ((vc+i)->vt == VECTOR) {
rcc = (vc+i)->rc;
/* --- skip the colliding vector --- */
if (rcc.lf == rc.lf && rcc.rt == rc.rt &&
rcc.tp == rc.tp && rc.bt == rcc.bt)
continue;
if (rcc.tp == rcc.bt) {
/* ---- horizontal vector,
see if character is in it --- */
if (rc.lf+x >= rcc.lf && rc.lf+x <= rcc.rt &&
rc.tp+y == rcc.tp) {
/* --- it is --- */
if (rc.lf+x == rcc.lf)
coll = 0;
else if (rc.lf+x == rcc.rt)
coll = 2;
else
coll = 1;
}
}
else {
/* ---- vertical vector,
see if character is in it --- */
if (rc.tp+y >= rcc.tp && rc.tp+y <= rcc.bt &&
rc.lf+x == rcc.lf) {
/* --- it is --- */
if (rc.tp+y == rcc.tp)
coll = 0;
else if (rc.tp+y == rcc.bt)
coll = 2;
else
coll = 1;
}
}
}
}
return coll;
}
static void PaintVector(DFWINDOW wnd, DFRECT rc)
{
int i, xi, yi, len;
unsigned int ch, nc;
unsigned int newch;
static int cw, fml, vertvect, coll;
if (rc.rt == rc.lf) {
/* ------ vertical vector ------- */
nc = '³';
vertvect = 1;
len = rc.bt-rc.tp+1;
}
else {
/* ------ horizontal vector ------- */
nc = 'Ä';
vertvect = 0;
len = rc.rt-rc.lf+1;
}
for (i = 0; i < len; i++) {
newch = nc;
xi = yi = 0;
if (vertvect)
yi = i;
else
xi = i;
ch = videochar(GetClientLeft(wnd)+rc.lf+xi,
GetClientTop(wnd)+rc.tp+yi);
for (cw = 0; cw < sizeof(CharInWnd); cw++) {
if (ch == CharInWnd[cw]) {
/* ---- hit another vector character ---- */
if ((coll=FindVector(wnd, rc, xi, yi)) != -1) {
/* compute first/middle/last subscript */
if (i == len-1)
fml = 2;
else if (i == 0)
fml = 0;
else
fml = 1;
newch = VectCvt[coll][cw][vertvect][fml];
}
}
}
PutWindowChar(wnd, newch, rc.lf+xi, rc.tp+yi);
}
}
static void PaintBar(DFWINDOW wnd, DFRECT rc, enum VectTypes vt)
{
int i, vertbar, len;
unsigned int tys[] = {219, 178, 177, 176};
/* unsigned int tys[] = {'Û', '²', '±', '°'};
*/
unsigned int nc = tys[vt-1];
if (rc.rt == rc.lf) {
/* ------ vertical bar ------- */
vertbar = 1;
len = rc.bt-rc.tp+1;
}
else {
/* ------ horizontal bar ------- */
vertbar = 0;
len = rc.rt-rc.lf+1;
}
for (i = 0; i < len; i++) {
int xi = 0, yi = 0;
if (vertbar)
yi = i;
else
xi = i;
PutWindowChar(wnd, nc, rc.lf+xi, rc.tp+yi);
}
}
static void PaintMsg(DFWINDOW wnd)
{
int i;
VECT *vc = wnd->VectorList;
for (i = 0; i < wnd->VectorCount; i++) {
if (vc->vt == VECTOR)
PaintVector(wnd, vc->rc);
else
PaintBar(wnd, vc->rc, vc->vt);
vc++;
}
}
static void DrawVectorMsg(DFWINDOW wnd,PARAM p1,enum VectTypes vt)
{
if (p1) {
VECT vc;
wnd->VectorList = DFrealloc(wnd->VectorList,
sizeof(VECT) * (wnd->VectorCount + 1));
vc.vt = vt;
vc.rc = *(DFRECT *)p1;
*(((VECT *)(wnd->VectorList))+wnd->VectorCount)=vc;
wnd->VectorCount++;
}
}
static void DrawBoxMsg(DFWINDOW wnd, PARAM p1)
{
if (p1) {
DFRECT rc = *(DFRECT *)p1;
rc.bt = rc.tp;
DfSendMessage(wnd, DRAWVECTOR, (PARAM) &rc, TRUE);
rc = *(DFRECT *)p1;
rc.lf = rc.rt;
DfSendMessage(wnd, DRAWVECTOR, (PARAM) &rc, FALSE);
rc = *(DFRECT *)p1;
rc.tp = rc.bt;
DfSendMessage(wnd, DRAWVECTOR, (PARAM) &rc, TRUE);
rc = *(DFRECT *)p1;
rc.rt = rc.lf;
DfSendMessage(wnd, DRAWVECTOR, (PARAM) &rc, FALSE);
}
}
int PictureProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case PAINT:
BaseWndProc(PICTUREBOX, wnd, msg, p1, p2);
PaintMsg(wnd);
return TRUE;
case DRAWVECTOR:
DrawVectorMsg(wnd, p1, VECTOR);
return TRUE;
case DRAWBOX:
DrawBoxMsg(wnd, p1);
return TRUE;
case DRAWBAR:
DrawVectorMsg(wnd, p1, (enum VectTypes)p2);
return TRUE;
case CLOSE_WINDOW:
if (wnd->VectorList != NULL)
free(wnd->VectorList);
break;
default:
break;
}
return BaseWndProc(PICTUREBOX, wnd, msg, p1, p2);
}
static DFRECT PictureRect(int x, int y, int len, int hv)
{
DFRECT rc;
rc.lf = rc.rt = x;
rc.tp = rc.bt = y;
if (hv)
/* ---- horizontal vector ---- */
rc.rt += len-1;
else
/* ---- vertical vector ---- */
rc.bt += len-1;
return rc;
}
void DrawVector(DFWINDOW wnd, int x, int y, int len, int hv)
{
DFRECT rc = PictureRect(x,y,len,hv);
DfSendMessage(wnd, DRAWVECTOR, (PARAM) &rc, 0);
}
void DrawBox(DFWINDOW wnd, int x, int y, int ht, int wd)
{
DFRECT rc;
rc.lf = x;
rc.tp = y;
rc.rt = x+wd-1;
rc.bt = y+ht-1;
DfSendMessage(wnd, DRAWBOX, (PARAM) &rc, 0);
}
void DrawBar(DFWINDOW wnd,enum VectTypes vt,
int x,int y,int len,int hv)
{
DFRECT rc = PictureRect(x,y,len,hv);
DfSendMessage(wnd, DRAWBAR, (PARAM) &rc, (PARAM) vt);
}
/* EOF */
rosapps/lib/dflat32/popdown.c
-396
View File
@@ -1,396 +0,0 @@
/* ------------- popdown.c ----------- */
#include "dflat32/dflat.h"
static int SelectionWidth(struct PopDown *);
static int py = -1;
/* ------------ CREATE_WINDOW Message ------------- */
static int CreateWindowMsg(DFWINDOW wnd)
{
int rtn, adj;
ClearAttribute (wnd,
HASTITLEBAR |
VSCROLLBAR |
MOVEABLE |
SIZEABLE |
HSCROLLBAR);
/* ------ adjust to keep popdown on screen ----- */
adj = DfGetScreenHeight()-1-wnd->rc.bt;
if (adj < 0)
{
wnd->rc.tp += adj;
wnd->rc.bt += adj;
}
adj = DfGetScreenWidth()-1-wnd->rc.rt;
if (adj < 0)
{
wnd->rc.lf += adj;
wnd->rc.rt += adj;
}
rtn = BaseWndProc(POPDOWNMENU, wnd, CREATE_WINDOW, 0, 0);
DfSendMessage(wnd, CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, CAPTURE_KEYBOARD, 0, 0);
DfSendMessage(NULL, SAVE_CURSOR, 0, 0);
DfSendMessage(NULL, HIDE_CURSOR, 0, 0);
wnd->oldFocus = inFocus;
inFocus = wnd;
return rtn;
}
/* --------- LEFT_BUTTON Message --------- */
static void LeftButtonMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int my = (int) p2 - GetTop(wnd);
if (InsideRect(p1, p2, ClientRect(wnd))) {
if (my != py) {
DfSendMessage(wnd, LB_SELECTION,
(PARAM) wnd->wtop+my-1, TRUE);
py = my;
}
}
else if ((int)p2 == GetTop(GetParent(wnd)))
if (GetClass(GetParent(wnd)) == MENUBAR)
DfPostMessage(GetParent(wnd), LEFT_BUTTON, p1, p2);
}
/* -------- BUTTON_RELEASED Message -------- */
static BOOL ButtonReleasedMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
py = -1;
if (InsideRect((int)p1, (int)p2, ClientRect(wnd))) {
int sel = (int)p2 - GetClientTop(wnd);
if (*TextLine(wnd, sel) != LINE)
DfSendMessage(wnd, LB_CHOOSE, wnd->selection, 0);
}
else {
DFWINDOW pwnd = GetParent(wnd);
if (GetClass(pwnd) == MENUBAR && (int)p2==GetTop(pwnd))
return FALSE;
if ((int)p1 == GetLeft(pwnd)+2)
return FALSE;
DfSendMessage(wnd, CLOSE_WINDOW, 0, 0);
return TRUE;
}
return FALSE;
}
/* --------- PAINT Message -------- */
static void PaintMsg(DFWINDOW wnd)
{
int wd;
unsigned char sep[80], *cp = sep;
unsigned char sel[80];
struct PopDown *ActivePopDown;
struct PopDown *pd1;
ActivePopDown = pd1 = wnd->mnu->Selections;
wd = MenuWidth(ActivePopDown)-2;
while (wd--)
*cp++ = LINE;
*cp = '\0';
DfSendMessage(wnd, CLEARTEXT, 0, 0);
wnd->selection = wnd->mnu->Selection;
while (pd1->SelectionTitle != NULL) {
if (*pd1->SelectionTitle == LINE)
DfSendMessage(wnd, ADDTEXT, (PARAM) sep, 0);
else {
int len;
memset(sel, '\0', sizeof sel);
if (pd1->Attrib & INACTIVE)
/* ------ inactive menu selection ----- */
sprintf(sel, "%c%c%c",
CHANGECOLOR,
wnd->WindowColors [HILITE_COLOR] [FG]|0x80,
wnd->WindowColors [STD_COLOR] [BG]|0x80);
strcat(sel, " ");
if (pd1->Attrib & CHECKED)
/* ---- paint the toggle checkmark ---- */
sel[strlen(sel)-1] = CHECKMARK;
len=CopyCommand(sel+strlen(sel),pd1->SelectionTitle,
pd1->Attrib & INACTIVE,
wnd->WindowColors [STD_COLOR] [BG]);
if (pd1->Accelerator) {
/* ---- paint accelerator key ---- */
int i;
int wd1 = 2+SelectionWidth(ActivePopDown) -
strlen(pd1->SelectionTitle);
for (i = 0; keys[i].keylabel; i++) {
if (keys[i].keycode == pd1->Accelerator) {
while (wd1--)
strcat(sel, " ");
sprintf(sel+strlen(sel), "[%s]",
keys[i].keylabel);
break;
}
}
}
if (pd1->Attrib & CASCADED) {
/* ---- paint cascaded menu token ---- */
if (!pd1->Accelerator) {
wd = MenuWidth(ActivePopDown)-len+1;
while (wd--)
strcat(sel, " ");
}
sel[strlen(sel)-1] = CASCADEPOINTER;
}
else
strcat(sel, " ");
strcat(sel, " ");
sel[strlen(sel)-1] = RESETCOLOR;
DfSendMessage(wnd, ADDTEXT, (PARAM) sel, 0);
}
pd1++;
}
}
/* ---------- BORDER Message ----------- */
static int BorderMsg(DFWINDOW wnd)
{
int i, rtn = TRUE;
DFWINDOW currFocus;
if (wnd->mnu != NULL) {
currFocus = inFocus;
inFocus = NULL;
rtn = BaseWndProc(POPDOWNMENU, wnd, BORDER, 0, 0);
inFocus = currFocus;
for (i = 0; i < ClientHeight(wnd); i++) {
if (*TextLine(wnd, i) == LINE) {
wputch(wnd, LEDGE, 0, i+1);
wputch(wnd, REDGE, WindowWidth(wnd)-1, i+1);
}
}
}
return rtn;
}
/* -------------- LB_CHOOSE Message -------------- */
static void LBChooseMsg(DFWINDOW wnd, PARAM p1)
{
struct PopDown *ActivePopDown = wnd->mnu->Selections;
if (ActivePopDown != NULL) {
int *attr = &(ActivePopDown+(int)p1)->Attrib;
wnd->mnu->Selection = (int)p1;
if (!(*attr & INACTIVE)) {
if (*attr & TOGGLE)
*attr ^= CHECKED;
DfPostMessage(GetParent(wnd), DFM_COMMAND,
(ActivePopDown+(int)p1)->ActionId, p1);
}
else
beep();
}
}
/* ---------- KEYBOARD Message --------- */
static BOOL KeyboardMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
struct PopDown *ActivePopDown = wnd->mnu->Selections;
if (wnd->mnu != NULL)
{
if (ActivePopDown != NULL)
{
int c = (int)p1;
int sel = 0;
int a;
struct PopDown *pd = ActivePopDown;
if ((c & OFFSET) == 0)
c = tolower(c);
a = AltConvert(c);
while (pd->SelectionTitle != NULL)
{
char *cp = strchr(pd->SelectionTitle, SHORTCUTCHAR);
/* FIXME: AltConvert bug !! */
if ((cp && tolower(*(cp+1)) == c) ||
// (a && tolower(*(cp+1)) == a) ||
pd->Accelerator == c)
{
DfPostMessage(wnd, LB_SELECTION, sel, 0);
DfPostMessage(wnd, LB_CHOOSE, sel, TRUE);
return TRUE;
}
pd++;
sel++;
}
}
}
switch ((int)p1)
{
case F1:
if (ActivePopDown == NULL)
DfSendMessage(GetParent(wnd), KEYBOARD, p1, p2);
else
DisplayHelp(wnd,
(ActivePopDown+wnd->selection)->help);
return TRUE;
case ESC:
DfSendMessage(wnd, CLOSE_WINDOW, 0, 0);
return TRUE;
case FWD:
case BS:
if (GetClass(GetParent(wnd)) == MENUBAR)
DfPostMessage(GetParent(wnd), KEYBOARD, p1, p2);
return TRUE;
case UP:
if (wnd->selection == 0) {
if (wnd->wlines == ClientHeight(wnd)) {
DfPostMessage(wnd, LB_SELECTION,
wnd->wlines-1, FALSE);
return TRUE;
}
}
break;
case DN:
if (wnd->selection == wnd->wlines-1) {
if (wnd->wlines == ClientHeight(wnd)) {
DfPostMessage(wnd, LB_SELECTION, 0, FALSE);
return TRUE;
}
}
break;
case HOME:
case END:
case '\r':
break;
default:
return TRUE;
}
return FALSE;
}
/* ----------- CLOSE_WINDOW Message ---------- */
static int CloseWindowMsg(DFWINDOW wnd)
{
int rtn;
DFWINDOW pwnd = GetParent(wnd);
DfSendMessage(wnd, RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, RELEASE_KEYBOARD, 0, 0);
DfSendMessage(NULL, RESTORE_CURSOR, 0, 0);
inFocus = wnd->oldFocus;
rtn = BaseWndProc(POPDOWNMENU, wnd, CLOSE_WINDOW, 0, 0);
DfSendMessage(pwnd, CLOSE_POPDOWN, 0, 0);
return rtn;
}
/* - Window processing module for POPDOWNMENU window class - */
int PopDownProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
return CreateWindowMsg(wnd);
case LEFT_BUTTON:
LeftButtonMsg(wnd, p1, p2);
return FALSE;
case DOUBLE_CLICK:
return TRUE;
case LB_SELECTION:
if (*TextLine(wnd, (int)p1) == LINE)
return TRUE;
wnd->mnu->Selection = (int)p1;
break;
case DFM_BUTTON_RELEASED:
if (ButtonReleasedMsg(wnd, p1, p2))
return TRUE;
break;
case BUILD_SELECTIONS:
wnd->mnu = (void *) p1;
wnd->selection = wnd->mnu->Selection;
break;
case PAINT:
if (wnd->mnu == NULL)
return TRUE;
PaintMsg(wnd);
break;
case BORDER:
return BorderMsg(wnd);
case LB_CHOOSE:
LBChooseMsg(wnd, p1);
return TRUE;
case KEYBOARD:
if (KeyboardMsg(wnd, p1, p2))
return TRUE;
break;
case CLOSE_WINDOW:
return CloseWindowMsg(wnd);
default:
break;
}
return BaseWndProc(POPDOWNMENU, wnd, msg, p1, p2);
}
/* --------- compute menu height -------- */
int MenuHeight(struct PopDown *pd)
{
int ht = 0;
while (pd[ht].SelectionTitle != NULL)
ht++;
return ht+2;
}
/* --------- compute menu width -------- */
int MenuWidth(struct PopDown *pd)
{
int wd = 0, i;
int len = 0;
wd = SelectionWidth(pd);
while (pd->SelectionTitle != NULL) {
if (pd->Accelerator) {
for (i = 0; keys[i].keylabel; i++)
if (keys[i].keycode == pd->Accelerator) {
len = max(len, (int)(2+strlen(keys[i].keylabel)));
break;
}
}
if (pd->Attrib & CASCADED)
len = max(len, 2);
pd++;
}
return wd+5+len;
}
/* ---- compute the maximum selection width in a menu ---- */
static int SelectionWidth(struct PopDown *pd)
{
int wd = 0;
while (pd->SelectionTitle != NULL) {
int len = strlen(pd->SelectionTitle)-1;
wd = max(wd, len);
pd++;
}
return wd;
}
/* ----- copy a menu command to a display buffer ---- */
int CopyCommand(unsigned char *dest, unsigned char *src,
int skipcolor, int bg)
{
unsigned char *d = dest;
while (*src && *src != '\n') {
if (*src == SHORTCUTCHAR) {
src++;
if (!skipcolor) {
*dest++ = CHANGECOLOR;
*dest++ = cfg.clr[POPDOWNMENU]
[HILITE_COLOR] [BG] | 0x80;
*dest++ = bg | 0x80;
*dest++ = *src++;
*dest++ = RESETCOLOR;
}
}
else
*dest++ = *src++;
}
return (int) (dest - d);
}
/* EOF */
rosapps/lib/dflat32/radio.c
-116
View File
@@ -1,116 +0,0 @@
/* -------- radio.c -------- */
#include "dflat32/dflat.h"
static CTLWINDOW *rct[MAXRADIOS];
int RadioButtonProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
DBOX *db = GetParent(wnd)->extension;
CTLWINDOW *ct = GetControl(wnd);
if (ct != NULL) {
switch (msg) {
case SETFOCUS:
if (!(int)p1)
DfSendMessage(NULL, HIDE_CURSOR, 0, 0);
case MOVE:
rtn = BaseWndProc(RADIOBUTTON,wnd,msg,p1,p2);
SetFocusCursor(wnd);
return rtn;
case PAINT: {
char rb[] = "( )";
if (ct->setting)
rb[1] = 7;
DfSendMessage(wnd, CLEARTEXT, 0, 0);
DfSendMessage(wnd, ADDTEXT, (PARAM) rb, 0);
SetFocusCursor(wnd);
break;
}
case KEYBOARD:
if ((int)p1 != ' ')
break;
case LEFT_BUTTON:
SetRadioButton(db, ct);
break;
default:
break;
}
}
return BaseWndProc(RADIOBUTTON, wnd, msg, p1, p2);
}
static BOOL Setting = TRUE;
void SetRadioButton(DBOX *db, CTLWINDOW *ct)
{
Setting = FALSE;
PushRadioButton(db, ct->command);
Setting = TRUE;
}
void PushRadioButton(DBOX *db, enum commands cmd)
{
CTLWINDOW *ctt = db->ctl;
CTLWINDOW *ct = FindCommand(db, cmd, RADIOBUTTON);
int i;
if (ct == NULL)
return;
/* --- clear all the radio buttons
in this group on the dialog box --- */
/* -------- build a table of all radio buttons at the
same x vector ---------- */
for (i = 0; i < MAXRADIOS; i++)
rct[i] = NULL;
while (ctt->class) {
if (ctt->class == RADIOBUTTON)
if (ct->dwnd.x == ctt->dwnd.x)
rct[ctt->dwnd.y] = ctt;
ctt++;
}
/* ----- find the start of the radiobutton group ---- */
i = ct->dwnd.y;
while (i >= 0 && rct[i] != NULL)
--i;
/* ---- ignore everthing before the group ------ */
while (i >= 0)
rct[i--] = NULL;
/* ----- find the end of the radiobutton group ---- */
i = ct->dwnd.y;
while (i < MAXRADIOS && rct[i] != NULL)
i++;
/* ---- ignore everthing past the group ------ */
while (i < MAXRADIOS)
rct[i++] = NULL;
for (i = 0; i < MAXRADIOS; i++) {
if (rct[i] != NULL) {
int wason = rct[i]->setting;
rct[i]->setting = OFF;
if (Setting)
rct[i]->isetting = OFF;
if (wason)
DfSendMessage(rct[i]->wnd, PAINT, 0, 0);
}
}
/* ----- set the specified radio button on ----- */
ct->setting = ON;
if (Setting)
ct->isetting = ON;
DfSendMessage(ct->wnd, PAINT, 0, 0);
}
BOOL RadioButtonSetting(DBOX *db, enum commands cmd)
{
CTLWINDOW *ct = FindCommand(db, cmd, RADIOBUTTON);
if (ct != NULL)
return (ct->setting == ON);
return FALSE;
}
/* EOF */
rosapps/lib/dflat32/rect.c
-106
View File
@@ -1,106 +0,0 @@
/* ------------- rect.c --------------- */
#include "dflat32/dflat.h"
/* --- Produce the vector end points produced by the overlap
of two other vectors --- */
static void subVector(int *v1, int *v2,
int t1, int t2, int o1, int o2)
{
*v1 = *v2 = -1;
if (within(o1, t1, t2)) {
*v1 = o1;
if (within(o2, t1, t2))
*v2 = o2;
else
*v2 = t2;
}
else if (within(o2, t1, t2)) {
*v2 = o2;
if (within(o1, t1, t2))
*v1 = o1;
else
*v1 = t1;
}
else if (within(t1, o1, o2)) {
*v1 = t1;
if (within(t2, o1, o2))
*v2 = t2;
else
*v2 = o2;
}
else if (within(t2, o1, o2)) {
*v2 = t2;
if (within(t1, o1, o2))
*v1 = t1;
else
*v1 = o1;
}
}
/* --- Return the rectangle produced by the overlap
of two other rectangles ---- */
DFRECT subRectangle(DFRECT r1, DFRECT r2)
{
DFRECT r = {0,0,0,0};
subVector((int *) &RectLeft(r), (int *) &RectRight(r),
RectLeft(r1), RectRight(r1),
RectLeft(r2), RectRight(r2));
subVector((int *) &RectTop(r), (int *) &RectBottom(r),
RectTop(r1), RectBottom(r1),
RectTop(r2), RectBottom(r2));
if (RectRight(r) == -1 || RectTop(r) == -1)
RectRight(r) =
RectLeft(r) =
RectTop(r) =
RectBottom(r) = 0;
return r;
}
/* ------- return the client rectangle of a window ------ */
DFRECT ClientRect(void *wnd)
{
DFRECT rc;
if (wnd == NULL)
{
RectLeft(rc) = 1; // GetClientLeft((DFWINDOW)wnd);
RectTop(rc) = 2; // GetClientTop((DFWINDOW)wnd);
RectRight(rc) = DfGetScreenWidth () - 2; // GetClientRight((DFWINDOW)wnd);
RectBottom(rc) = DfGetScreenHeight () - 2; // GetClientBottom((DFWINDOW)wnd);
return rc;
}
RectLeft(rc) = GetClientLeft((DFWINDOW)wnd);
RectTop(rc) = GetClientTop((DFWINDOW)wnd);
RectRight(rc) = GetClientRight((DFWINDOW)wnd);
RectBottom(rc) = GetClientBottom((DFWINDOW)wnd);
return rc;
}
/* ----- return the rectangle relative to
its window's screen position -------- */
DFRECT RelativeWindowRect(void *wnd, DFRECT rc)
{
RectLeft(rc) -= GetLeft((DFWINDOW)wnd);
RectRight(rc) -= GetLeft((DFWINDOW)wnd);
RectTop(rc) -= GetTop((DFWINDOW)wnd);
RectBottom(rc) -= GetTop((DFWINDOW)wnd);
return rc;
}
/* ----- clip a rectangle to the parents of the window ----- */
DFRECT ClipRectangle(void *wnd, DFRECT rc)
{
DFRECT sr;
RectLeft(sr) = RectTop(sr) = 0;
RectRight(sr) = DfGetScreenWidth()-1;
RectBottom(sr) = DfGetScreenHeight()-1;
if (!TestAttribute((DFWINDOW)wnd, NOCLIP))
while ((wnd = GetParent((DFWINDOW)wnd)) != NULL)
rc = subRectangle(rc, ClientRect(wnd));
return subRectangle(rc, sr);
}
/* EOF */
rosapps/lib/dflat32/spinbutt.c
-48
View File
@@ -1,48 +0,0 @@
/* ------------ spinbutt.c ------------- */
#include "dflat32/dflat.h"
int SpinButtonProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
CTLWINDOW *ct = GetControl(wnd);
if (ct != NULL) {
switch (msg) {
case CREATE_WINDOW:
wnd->wd -= 2;
wnd->rc.rt -= 2;
break;
case SETFOCUS:
rtn = BaseWndProc(SPINBUTTON, wnd, msg, p1, p2);
if (!(int)p1)
DfSendMessage(NULL, HIDE_CURSOR, 0, 0);
SetFocusCursor(wnd);
return rtn;
case PAINT:
foreground = WndBackground(wnd);
background = WndForeground(wnd);
wputch(wnd,UPSCROLLBOX,WindowWidth(wnd), 0);
wputch(wnd,DOWNSCROLLBOX,WindowWidth(wnd)+1,0);
SetFocusCursor(wnd);
break;
case LEFT_BUTTON:
if (p1 == GetRight(wnd) + 1)
DfSendMessage(wnd, KEYBOARD, UP, 0);
else if (p1 == GetRight(wnd) + 2)
DfSendMessage(wnd, KEYBOARD, DN, 0);
if (wnd != inFocus)
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
return TRUE;
case LB_SETSELECTION:
rtn = BaseWndProc(SPINBUTTON, wnd, msg, p1, p2);
wnd->wtop = (int) p1;
DfSendMessage(wnd, PAINT, 0, 0);
return rtn;
default:
break;
}
}
return BaseWndProc(SPINBUTTON, wnd, msg, p1, p2);
}
/* EOF */
rosapps/lib/dflat32/statbar.c
-53
View File
@@ -1,53 +0,0 @@
/* ---------------- statbar.c -------------- */
#include "dflat32/dflat.h"
int StatusBarProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
char *statusbar;
switch (msg) {
case CREATE_WINDOW:
case MOVE:
DfSendMessage(wnd, CAPTURE_CLOCK, 0, 0);
break;
case KEYBOARD:
if ((int)p1 == CTRL_F4)
return TRUE;
break;
case PAINT:
if (!isVisible(wnd))
break;
statusbar = DFcalloc(1, WindowWidth(wnd)+1);
memset(statusbar, ' ', WindowWidth(wnd));
*(statusbar+WindowWidth(wnd)) = '\0';
strncpy(statusbar+1, "F1=Help Ý FreeDos Edit", 22);
if (wnd->text) {
int len = min((int)strlen(wnd->text), (int)(WindowWidth(wnd)-17));
if (len > 0) {
int off=(WindowWidth(wnd)-len)/2;
strncpy(statusbar+off, wnd->text, len);
}
}
if (wnd->TimePosted)
*(statusbar+WindowWidth(wnd)-8) = '\0';
SetStandardColor(wnd);
PutWindowLine(wnd, statusbar, 0, 0);
free(statusbar);
return TRUE;
case BORDER:
return TRUE;
case CLOCKTICK:
SetStandardColor(wnd);
PutWindowLine(wnd, (char *)p1, WindowWidth(wnd)-8, 0);
wnd->TimePosted = TRUE;
return TRUE;
case CLOSE_WINDOW:
DfSendMessage(NULL, RELEASE_CLOCK, 0, 0);
break;
default:
break;
}
return BaseWndProc(STATUSBAR, wnd, msg, p1, p2);
}
/* EOF */

Some files were not shown because too many files have changed in this diff Show More