Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2025-08-05 16:32:59 +00:00
Code Issues Projects Releases Packages Wiki Activity

Added D-Flat/32 library

Browse source 
svn path=/trunk/; revision=1032
This commit is contained in:
Eric Kohl 2000-03-05 19:58:08 +00:00
parent 2634e901be
commit 79d0e047eb
66 changed files with 17806 additions and 1 deletions
Download patch file Download diff file Expand all files Collapse all files

2
rosapps/Makefile
View file

@ -13,7 +13,7 @@ include rules.mak
# #
# Available applications # Available applications
# #
APPS = cmd cmdutils notevil sysutils APPS = cmd cmdutils notevil sysutils dflat32
all: $(APPS) all: $(APPS)
.PHONY: all .PHONY: all

621
rosapps/dflat32/applicat.c Normal file
View file

@ -0,0 +1,621 @@
/* ------------- applicat.c ------------- */
#include "dflat.h"
static int ScreenHeight;
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;
ScreenHeight = SCREENHEIGHT;
#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 */

74
rosapps/dflat32/barchart.c Normal file
View file

@ -0,0 +1,74 @@
/* ------------ 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,
PARAM p1, PARAM p2)
{
switch (msg) {
case DFM_COMMAND:
if ((int)p1 == ID_HELP) {
DisplayHelp(wnd, "BarChart");
return TRUE;
}
break;
case CLOSE_WINDOW:
Bwnd = NULL;
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
void BarChart(DFWINDOW pwnd)
{
int pct = sizeof projs / sizeof(struct ProjChart);
int i;
if (Bwnd == NULL) {
Bwnd = DfCreateWindow(PICTUREBOX,
"BarChart",
-1, -1, BCHEIGHT, BCWIDTH,
NULL, pwnd, BarChartProc,
SHADOW |
CONTROLBOX |
MOVEABLE |
HASBORDER
);
DfSendMessage(Bwnd, ADDTEXT, (PARAM) Title, 0);
DfSendMessage(Bwnd, ADDTEXT, (PARAM) "", 0);
for (i = 0; i < pct; i++) {
DfSendMessage(Bwnd,ADDTEXT,(PARAM)projs[i].prj,0);
DrawBar(Bwnd, SOLIDBAR+(i%4),
11+projs[i].start*COLWIDTH, 2+i,
(1 + projs[i].stop-projs[i].start) * COLWIDTH,
TRUE);
}
DfSendMessage(Bwnd, ADDTEXT, (PARAM) "", 0);
DfSendMessage(Bwnd, ADDTEXT, (PARAM) Months, 0);
DrawBox(Bwnd, 10, 1, pct+2, 25);
}
DfSendMessage(Bwnd, SETFOCUS, TRUE, 0);
}

44
rosapps/dflat32/box.c Normal file
View file

@ -0,0 +1,44 @@
/* ----------- box.c ------------ */
#include "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 */

92
rosapps/dflat32/button.c Normal file
View file

@ -0,0 +1,92 @@
/* -------------- button.c -------------- */
#include "dflat.h"
void PaintMsg(DFWINDOW wnd, CTLWINDOW *ct, DFRECT *rc)
{
if (isVisible(wnd))
{
if (TestAttribute(wnd, SHADOW))
{
/* -------- draw the button's shadow ------- */
int x;
background = WndBackground(GetParent(wnd));
foreground = BLACK;
for (x = 1; x <= WindowWidth(wnd); x++)
wputch(wnd, (char)223, x, 1);
wputch(wnd, (char)220, WindowWidth(wnd), 0);
}
if (ct->itext != NULL)
{
unsigned char *txt;
txt = DFcalloc(1, strlen(ct->itext)+10);
if (ct->setting == OFF) {
txt[0] = CHANGECOLOR;
txt[1] = wnd->WindowColors
[HILITE_COLOR] [FG] | 0x80;
txt[2] = wnd->WindowColors
[STD_COLOR] [BG] | 0x80;
}
CopyCommand(txt+strlen(txt),ct->itext,!ct->setting,
WndBackground(wnd));
DfSendMessage(wnd, CLEARTEXT, 0, 0);
DfSendMessage(wnd, ADDTEXT, (PARAM) txt, 0);
free(txt);
}
/* --------- write the button's text ------- */
WriteTextLine(wnd, rc, 0, wnd == inFocus);
}
}
void LeftButtonMsg(DFWINDOW wnd, DFMESSAGE msg, CTLWINDOW *ct)
{
/* --------- draw a pushed button -------- */
int x;
background = WndBackground(GetParent(wnd));
foreground = WndBackground(wnd);
wputch(wnd, ' ', 0, 0);
for (x = 0; x < WindowWidth(wnd); x++)
{
wputch(wnd, (char)220, x+1, 0);
wputch(wnd, (char)223, x+1, 1);
}
if (msg == LEFT_BUTTON)
DfSendMessage(NULL, WAITMOUSE, 0, 0);
else
DfSendMessage(NULL, WAITKEYBOARD, 0, 0);
DfSendMessage(wnd, PAINT, 0, 0);
if (ct->setting == ON)
DfPostMessage(GetParent(wnd), DFM_COMMAND, ct->command, 0);
else
beep();
}
int ButtonProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
CTLWINDOW *ct = GetControl(wnd);
if (ct != NULL) {
switch (msg) {
case SETFOCUS:
BaseWndProc(BUTTON, wnd, msg, p1, p2);
p1 = 0;
/* ------- fall through ------- */
case PAINT:
PaintMsg(wnd, ct, (DFRECT*)p1);
return TRUE;
case KEYBOARD:
if (p1 != '\r')
break;
/* ---- fall through ---- */
case LEFT_BUTTON:
LeftButtonMsg(wnd, msg, ct);
return TRUE;
case HORIZSCROLL:
return TRUE;
default:
break;
}
}
return BaseWndProc(BUTTON, wnd, msg, p1, p2);
}
/* EOF */

165
rosapps/dflat32/calendar.c Normal file
View file

@ -0,0 +1,165 @@
/* ------------- calendar.c ------------- */
#include "dflat.h"
#ifndef TURBOC
#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 ---- */
DyMo[1] = (ttm.tm_year % 4) ? 28 : 29;
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;
DrawBox(wnd, 1, 2, CALHEIGHT-4, CALWIDTH-4);
for (x = 5; x < CALWIDTH-4; x += 4)
DrawVector(wnd, x, 2, CALHEIGHT-4, FALSE);
for (y = 4; y < CALHEIGHT-3; y+=2)
DrawVector(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];
SetStandardColor(wnd);
PutWindowLine(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, " ");
PutWindowLine(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",
CHANGECOLOR,
SelectForeground(wnd)+0x80,
SelectBackground(wnd)+0x80,
dy, RESETCOLOR);
else
sprintf(dyln, "%2d ", dy);
}
SetStandardColor(wnd);
PutWindowLine(wnd, dyln, 2 + day * 4, 3 + week*2);
}
}
}
static int KeyboardMsg(DFWINDOW wnd, PARAM p1)
{
switch ((int)p1) {
case PGUP:
if (ttm.tm_mon == 0) {
ttm.tm_mon = 12;
ttm.tm_year--;
}
ttm.tm_mon--;
FixDate();
mktime(&ttm);
DisplayDates(wnd);
return TRUE;
case 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,
PARAM p1,PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
DefaultWndProc(wnd, msg, p1, p2);
CreateWindowMsg(wnd);
return TRUE;
case KEYBOARD:
if (KeyboardMsg(wnd, p1))
return TRUE;
break;
case PAINT:
DefaultWndProc(wnd, msg, p1, p2);
DisplayDates(wnd);
return TRUE;
case DFM_COMMAND:
if ((int)p1 == ID_HELP) {
DisplayHelp(wnd, "Calendar");
return TRUE;
}
break;
case CLOSE_WINDOW:
Cwnd = NULL;
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
void Calendar(DFWINDOW pwnd)
{
if (Cwnd == NULL) {
time_t tim = time(NULL);
ttm = *localtime(&tim);
Cwnd = DfCreateWindow(PICTUREBOX,
"Calendar",
-1, -1, CALHEIGHT, CALWIDTH,
NULL, pwnd, CalendarProc,
SHADOW |
MINMAXBOX |
CONTROLBOX |
MOVEABLE |
HASBORDER
);
}
DfSendMessage(Cwnd, SETFOCUS, TRUE, 0);
}
#endif

49
rosapps/dflat32/checkbox.c Normal file
View file

@ -0,0 +1,49 @@
/* -------------- checkbox.c ------------ */
#include "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 */

31
rosapps/dflat32/classdef.h Normal file
View file

@ -0,0 +1,31 @@
/* ---------------- classdef.h --------------- */
#ifndef CLASSDEF_H
#define CLASSDEF_H
typedef struct classdefs {
DFCLASS base; /* base window class */
int (*wndproc)(struct window *,enum messages,PARAM,PARAM);
int attrib;
} CLASSDEFS;
extern CLASSDEFS classdefs[];
#define SHADOW 0x0001
#define MOVEABLE 0x0002
#define SIZEABLE 0x0004
#define HASMENUBAR 0x0008
#define VSCROLLBAR 0x0010
#define HSCROLLBAR 0x0020
#define VISIBLE 0x0040
#define SAVESELF 0x0080
#define HASTITLEBAR 0x0100
#define CONTROLBOX 0x0200
#define MINMAXBOX 0x0400
#define NOCLIP 0x0800
#define READONLY 0x1000
#define MULTILINE 0x2000
#define HASBORDER 0x4000
#define HASSTATUSBAR 0x8000
#endif

56
rosapps/dflat32/classes.h Normal file
View file

@ -0,0 +1,56 @@
/* ----------- classes.h ------------ */
/*
* Class definition source file
* Make class changes to this source file
* Other source files will adapt
*
* You must add entries to the color tables in
* CONFIG.C for new classes.
*
* Class Name Base Class Processor Attribute
* ------------ --------- --------------- -----------
*/
ClassDef( NORMAL, -1, NormalProc, 0 )
ClassDef( APPLICATION, NORMAL, ApplicationProc, VISIBLE |
SAVESELF |
CONTROLBOX )
ClassDef( TEXTBOX, NORMAL, TextBoxProc, 0 )
ClassDef( LISTBOX, TEXTBOX, ListBoxProc, 0 )
ClassDef( EDITBOX, TEXTBOX, EditBoxProc, 0 )
ClassDef( MENUBAR, NORMAL, MenuBarProc, NOCLIP )
ClassDef( POPDOWNMENU, LISTBOX, PopDownProc, SAVESELF |
NOCLIP |
HASBORDER )
#ifdef INCLUDE_PICTUREBOX
ClassDef( PICTUREBOX, TEXTBOX, PictureProc, 0 )
#endif
ClassDef( DIALOG, NORMAL, DialogProc, SHADOW |
MOVEABLE |
CONTROLBOX|
HASBORDER |
NOCLIP )
ClassDef( BOX, NORMAL, BoxProc, HASBORDER )
ClassDef( BUTTON, TEXTBOX, ButtonProc, SHADOW )
ClassDef( COMBOBOX, EDITBOX, ComboProc, 0 )
ClassDef( TEXT, TEXTBOX, TextProc, 0 )
ClassDef( RADIOBUTTON, TEXTBOX, RadioButtonProc, 0 )
ClassDef( CHECKBOX, TEXTBOX, CheckBoxProc, 0 )
ClassDef( SPINBUTTON, LISTBOX, SpinButtonProc, 0 )
ClassDef( ERRORBOX, DIALOG, NULL, SHADOW |
HASBORDER )
ClassDef( MESSAGEBOX, DIALOG, NULL, SHADOW |
HASBORDER )
ClassDef( HELPBOX, DIALOG, HelpBoxProc, MOVEABLE |
SAVESELF |
HASBORDER |
NOCLIP |
CONTROLBOX )
ClassDef( STATUSBAR, TEXTBOX, StatusBarProc, NOCLIP )
/*
* ========> Add new classes here <========
*/
/* ---------- pseudo classes to create enums, etc. ---------- */
ClassDef( TITLEBAR, -1, NULL, 0 )
ClassDef( DUMMY, -1, NULL, HASBORDER )

54
rosapps/dflat32/clipbord.c Normal file
View file

@ -0,0 +1,54 @@
/* ----------- clipbord.c ------------ */
#include "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 */

149
rosapps/dflat32/combobox.c Normal file
View file

@ -0,0 +1,149 @@
/* -------------- combobox.c -------------- */
#include "dflat.h"
int ListProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int ComboProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
wnd->extension = DfCreateWindow(
LISTBOX,
NULL,
wnd->rc.lf,wnd->rc.tp+1,
wnd->ht-1, wnd->wd+1,
NULL,
wnd,
ListProc,
HASBORDER | NOCLIP | SAVESELF);
((DFWINDOW)(wnd->extension))->ct->command =
wnd->ct->command;
wnd->ht = 1;
wnd->rc.bt = wnd->rc.tp;
break;
case PAINT:
foreground = WndBackground(wnd);
background = WndForeground(wnd);
wputch(wnd, DOWNSCROLLBOX, WindowWidth(wnd), 0);
break;
case KEYBOARD:
if ((int)p1 == DN) {
DfSendMessage(wnd->extension, SETFOCUS, TRUE, 0);
return TRUE;
}
break;
case LEFT_BUTTON:
if ((int)p1 == GetRight(wnd) + 1)
DfSendMessage(wnd->extension, SETFOCUS, TRUE, 0);
break;
case CLOSE_WINDOW:
DfSendMessage(wnd->extension, CLOSE_WINDOW, 0, 0);
break;
default:
break;
}
return BaseWndProc(COMBOBOX, wnd, msg, p1, p2);
}
int ListProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
DFWINDOW pwnd = GetParent(GetParent(wnd));
DBOX *db = pwnd->extension;
DFWINDOW cwnd;
char text[130];
int rtn;
DFWINDOW currFocus;
switch (msg)
{
case CREATE_WINDOW:
wnd->ct = DFmalloc(sizeof(CTLWINDOW));
wnd->ct->setting = OFF;
wnd->WindowColors[FRAME_COLOR][FG] =
wnd->WindowColors[STD_COLOR][FG];
wnd->WindowColors[FRAME_COLOR][BG] =
wnd->WindowColors[STD_COLOR][BG];
rtn = DefaultWndProc(wnd, msg, p1, p2);
return rtn;
case SETFOCUS:
if ((int)p1 == FALSE)
{
if (!wnd->isHelping)
{
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
wnd->ct->setting = OFF;
}
}
else
wnd->ct->setting = ON;
break;
case SHOW_WINDOW:
if (wnd->ct->setting == OFF)
return TRUE;
break;
case BORDER:
currFocus = inFocus;
inFocus = NULL;
rtn = DefaultWndProc(wnd, msg, p1, p2);
inFocus = currFocus;
return rtn;
case LB_SELECTION:
rtn = DefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, DFM_LB_GETTEXT,
(PARAM) text, wnd->selection);
PutItemText(pwnd, wnd->ct->command, text);
cwnd = ControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, PAINT, 0, 0);
cwnd->TextChanged = TRUE;
return rtn;
case KEYBOARD:
switch ((int) p1)
{
case ESC:
case FWD:
case BS:
cwnd = ControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, SETFOCUS, TRUE, 0);
return TRUE;
default:
break;
}
break;
case LB_CHOOSE:
cwnd = ControlWindow(db, wnd->ct->command);
DfSendMessage(cwnd, SETFOCUS, TRUE, 0);
return TRUE;
case CLOSE_WINDOW:
if (wnd->ct != NULL)
free(wnd->ct);
wnd->ct = NULL;
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
void PutComboListText(DFWINDOW wnd, enum commands cmd, char *text)
{
CTLWINDOW *ct = FindCommand(wnd->extension, cmd, COMBOBOX);
if (ct != NULL)
{
DFWINDOW lwnd = ((DFWINDOW)(ct->wnd))->extension;
DfSendMessage(lwnd, ADDTEXT, (PARAM) text, 0);
}
}
/* EOF */

121
rosapps/dflat32/commands.h Normal file
View file

@ -0,0 +1,121 @@
/* ---------------- 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 commands {
/* --------------- File menu ---------------- */
ID_OPEN,
ID_NEW,
ID_SAVE,
ID_SAVEAS,
ID_DELETEFILE,
ID_PRINT,
ID_PRINTSETUP,
ID_DOS,
ID_EXIT,
/* --------------- Edit menu ---------------- */
ID_UNDO,
ID_CUT,
ID_COPY,
ID_PASTE,
ID_PARAGRAPH,
ID_CLEAR,
ID_DELETETEXT,
/* --------------- Search Menu -------------- */
ID_SEARCH,
ID_REPLACE,
ID_SEARCHNEXT,
/* --------------- Utilities Menu ------------- */
ID_CALENDAR,
ID_BARCHART,
/* -------------- Options menu -------------- */
ID_INSERT,
ID_WRAP,
ID_LOG,
ID_TABS,
ID_DISPLAY,
ID_SAVEOPTIONS,
/* --------------- Window menu -------------- */
ID_CLOSEALL,
ID_WINDOW,
ID_MOREWINDOWS,
/* --------------- Help menu ---------------- */
ID_HELPHELP,
ID_EXTHELP,
ID_KEYSHELP,
ID_HELPINDEX,
ID_ABOUT,
ID_LOADHELP,
/* --------------- System menu -------------- */
#ifdef INCLUDE_RESTORE
ID_SYSRESTORE,
#endif
ID_SYSMOVE,
ID_SYSSIZE,
#ifdef INCLUDE_MINIMIZE
ID_SYSMINIMIZE,
#endif
#ifdef INCLUDE_MAXIMIZE
ID_SYSMAXIMIZE,
#endif
ID_SYSCLOSE,
/* ---- FileOpen and SaveAs dialog boxes ---- */
ID_FILENAME,
ID_FILES,
ID_DRIVE,
ID_PATH,
/* ----- Search and Replace dialog boxes ---- */
ID_SEARCHFOR,
ID_REPLACEWITH,
ID_MATCHCASE,
ID_REPLACEALL,
/* ----------- Windows dialog box ----------- */
ID_WINDOWLIST,
/* --------- generic command buttons -------- */
ID_OK,
ID_CANCEL,
ID_HELP,
/* -------------- TabStops menu ------------- */
ID_TAB2,
ID_TAB4,
ID_TAB6,
ID_TAB8,
/* ------------ Display dialog box ---------- */
ID_BORDER,
ID_TITLE,
ID_STATUSBAR,
ID_TEXTURE,
ID_SNOWY,
ID_COLOR,
ID_MONO,
ID_REVERSE,
ID_25LINES,
ID_43LINES,
ID_50LINES,
/* ------------- Log dialog box ------------- */
ID_LOGLIST,
ID_LOGGING,
/* ------------ HelpBox dialog box ---------- */
ID_HELPTEXT,
ID_BACK,
ID_PREV,
ID_NEXT,
/* ---------- Print Select dialog box --------- */
ID_PRINTERPORT,
ID_LEFTMARGIN,
ID_RIGHTMARGIN,
ID_TOPMARGIN,
ID_BOTTOMMARGIN,
/* ----------- InputBox dialog box ------------ */
ID_INPUTTEXT
};
#endif

514
rosapps/dflat32/config.c Normal file
View file

@ -0,0 +1,514 @@
/* ------------- config.c ------------- */
#include "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 */

48
rosapps/dflat32/config.h Normal file
View file

@ -0,0 +1,48 @@
/* ---------------- config.h -------------- */
#ifndef CONFIG_H
#define CONFIG_H
enum colortypes {
STD_COLOR,
SELECT_COLOR,
FRAME_COLOR,
HILITE_COLOR
};
enum grounds { FG, BG };
/* ----------- configuration parameters ----------- */
typedef struct config {
char version[sizeof 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[CLASSCOUNT] [4] [2]; /* Colors */
} CONFIG;
extern CONFIG cfg;
extern unsigned char color[CLASSCOUNT] [4] [2];
extern unsigned char bw[CLASSCOUNT] [4] [2];
extern unsigned char reverse[CLASSCOUNT] [4] [2];
BOOL LoadConfig(void);
void SaveConfig(void);
FILE *OpenConfig(char *);
#endif

198
rosapps/dflat32/console.c Normal file
View file

@ -0,0 +1,198 @@
/* ----------- 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[] = {
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 int cursorpos[MAXSAVES];
static int cursorshape[MAXSAVES];
static int cs;
void SwapCursorStack(void)
{
if (cs > 1) {
swap(cursorpos[cs-2], cursorpos[cs-1]);
swap(cursorshape[cs-2], cursorshape[cs-1]);
}
}
/* ---- 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 cursor shape and position ------ */
static void getcursor(void)
{
/*
videomode();
regs.h.ah = READCURSOR;
regs.x.bx = video_page;
int86(VIDEO, &regs, &regs);
*/
/* FIXME */
}
/* ------- 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) {
getcursor();
cursorshape[cs] = regs.x.cx;
cursorpos[cs] = regs.x.dx;
cs++;
}
*/
}
/* ---- restore the saved cursor configuration ---- */
void restorecursor(void)
{
/*
if (cs) {
--cs;
videomode();
regs.x.dx = cursorpos[cs];
regs.h.ah = SETCURSOR;
regs.x.bx = video_page;
int86(VIDEO, &regs, &regs);
set_cursor_type(cursorshape[cs]);
}
*/
}
/* ------ make a normal cursor ------ */
void normalcursor(void)
{
// set_cursor_type(0x0607);
}
/* ------ hide the cursor ------ */
void hidecursor(void)
{
/*
getcursor();
regs.h.ch |= HIDECURSOR;
regs.h.ah = SETCURSORTYPE;
int86(VIDEO, &regs, &regs);
*/
}
/* ------ unhide the cursor ------ */
void unhidecursor(void)
{
/*
getcursor();
regs.h.ch &= ~HIDECURSOR;
regs.h.ah = SETCURSORTYPE;
int86(VIDEO, &regs, &regs);
*/
}
/* ---- use BIOS to set the cursor type ---- */
void set_cursor_type(unsigned t)
{
/*
videomode();
regs.h.ah = SETCURSORTYPE;
regs.x.bx = video_page;
regs.x.cx = t;
int86(VIDEO, &regs, &regs);
*/
}
/* ------ 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 */

134
rosapps/dflat32/decomp.c Normal file
View file

@ -0,0 +1,134 @@
/* ------------------- 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 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;
}
}
}

70
rosapps/dflat32/dfalloc.c Normal file
View file

@ -0,0 +1,70 @@
/* ---------- 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(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 */

1350
rosapps/dflat32/dflat.doc Normal file
View file

File diff suppressed because it is too large Load diff

482
rosapps/dflat32/dflat.h Normal file
View file

@ -0,0 +1,482 @@
/* ------------- 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 VERSION
#define VERSION "Beta Version 0.3"
#endif
void *DFcalloc(size_t, size_t);
void *DFmalloc(size_t);
void *DFrealloc(void *, size_t);
#define MAXMESSAGES 50
#define DELAYTICKS 1
#define FIRSTDELAY 7
#define DOUBLETICKS 5
#define MAXTEXTLEN 65000U /* maximum text buffer */
#define EDITLEN 1024 /* starting length for multiliner */
#define ENTRYLEN 256 /* starting length for one-liner */
#define 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 PARAM;
enum Condition
{
ISRESTORED, ISMINIMIZED, ISMAXIMIZED, ISCLOSING
};
typedef struct window
{
DFCLASS class; /* window class */
char *title; /* window title */
int (*wndproc)(struct window *, enum messages, PARAM, 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 window *parent; /* parent window */
struct window *firstchild; /* first child this parent */
struct window *lastchild; /* last child this parent */
struct window *nextsibling; /* next sibling */
struct window *prevsibling; /* previous sibling */
struct window *childfocus; /* child that ha(s/d) focus */
int attrib; /* Window attributes */
PCHAR_INFO videosave; /* video save buffer */
enum Condition condition; /* Restored, Maximized,
Minimized, Closing */
enum Condition oldcondition;/* previous condition */
int restored_attrib; /* attributes when restored */
void *extension; /* menus, dialogs, documents, etc */
struct window *PrevMouse;
struct window *PrevKeyboard;
struct window *MenuBarWnd;/* menu bar */
struct window *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 */
unsigned 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 */
unsigned 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 */
CTLWINDOW *ct; /* control structure */
struct window *dfocus; /* control window that has focus */
/* -------------- popdownmenu fields ------------------ */
MENU *mnu; /* points to menu structure */
MBAR *holdmenu; /* previous active menu */
struct window *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 LogMessages (DFWINDOW, DFMESSAGE, PARAM, PARAM);
void MessageLog(DFWINDOW);
/* ------- window methods ----------- */
#define ICONHEIGHT 3
#define ICONWIDTH 10
#define WindowHeight(w) ((w)->ht)
#define WindowWidth(w) ((w)->wd)
#define BorderAdj(w) (TestAttribute(w,HASBORDER)?1:0)
#define BottomBorderAdj(w) (TestAttribute(w,HASSTATUSBAR)?1:BorderAdj(w))
#define TopBorderAdj(w) ((TestAttribute(w,HASTITLEBAR) && \
TestAttribute(w,HASMENUBAR)) ? \
2 : (TestAttribute(w,HASTITLEBAR | \
HASMENUBAR | HASBORDER) ? 1 : 0))
#define ClientWidth(w) (WindowWidth(w)-BorderAdj(w)*2)
#define ClientHeight(w) (WindowHeight(w)-TopBorderAdj(w)-\
BottomBorderAdj(w))
#define WindowRect(w) ((w)->rc)
#define GetTop(w) (RectTop(WindowRect(w)))
#define GetBottom(w) (RectBottom(WindowRect(w)))
#define GetLeft(w) (RectLeft(WindowRect(w)))
#define GetRight(w) (RectRight(WindowRect(w)))
#define GetClientTop(w) (GetTop(w)+TopBorderAdj(w))
#define GetClientBottom(w) (GetBottom(w)-BottomBorderAdj(w))
#define GetClientLeft(w) (GetLeft(w)+BorderAdj(w))
#define GetClientRight(w) (GetRight(w)-BorderAdj(w))
#define GetTitle(w) ((w)->title)
#define GetParent(w) ((w)->parent)
#define FirstWindow(w) ((w)->firstchild)
#define LastWindow(w) ((w)->lastchild)
#define NextWindow(w) ((w)->nextsibling)
#define PrevWindow(w) ((w)->prevsibling)
#define GetClass(w) ((w)->class)
#define GetAttribute(w) ((w)->attrib)
#define AddAttribute(w,a) (GetAttribute(w) |= a)
#define ClearAttribute(w,a) (GetAttribute(w) &= ~(a))
#define TestAttribute(w,a) (GetAttribute(w) & (a))
#define isHidden(w) (!(GetAttribute(w) & VISIBLE))
#define SetVisible(w) (GetAttribute(w) |= VISIBLE)
#define ClearVisible(w) (GetAttribute(w) &= ~VISIBLE)
#define gotoxy(w,x,y) cursor(w->rc.lf+(x)+1,w->rc.tp+(y)+1)
BOOL isVisible(DFWINDOW);
DFWINDOW DfCreateWindow(DFCLASS,char *,int,int,int,int,void*,DFWINDOW,
int (*)(struct window *,enum messages,PARAM,PARAM),int);
void AddTitle(DFWINDOW, char *);
void InsertTitle(DFWINDOW, char *);
void DisplayTitle(DFWINDOW, DFRECT *);
void RepaintBorder(DFWINDOW, DFRECT *);
void PaintShadow(DFWINDOW);
void ClearWindow(DFWINDOW, DFRECT *, int);
void writeline(DFWINDOW, char *, int, int, BOOL);
void InitWindowColors(DFWINDOW);
void SetNextFocus(void);
void SetPrevFocus(void);
void RemoveWindow(DFWINDOW);
void AppendWindow(DFWINDOW);
void ReFocus(DFWINDOW);
void SkipApplicationControls(void);
BOOL CharInView(DFWINDOW, int, int);
void CreatePath(char *, char *, int, int);
#define SwapVideoBuffer(wnd, ish, fh) swapvideo(wnd, wnd->videosave, ish, fh)
int LineLength(char *);
DFRECT AdjustRectangle(DFWINDOW, DFRECT);
BOOL isDerivedFrom(DFWINDOW, DFCLASS);
DFWINDOW GetAncestor(DFWINDOW);
void PutWindowChar(DFWINDOW,char,int,int);
void PutWindowLine(DFWINDOW, void *,int,int);
#define BaseWndProc(class,wnd,msg,p1,p2) \
(*classdefs[(classdefs[class].base)].wndproc)(wnd,msg,p1,p2)
#define DefaultWndProc(wnd,msg,p1,p2) \
(classdefs[wnd->class].wndproc == NULL) ? \
BaseWndProc(wnd->class,wnd,msg,p1,p2) : \
(*classdefs[wnd->class].wndproc)(wnd,msg,p1,p2)
struct LinkedList {
DFWINDOW FirstWindow;
DFWINDOW LastWindow;
};
extern DFWINDOW ApplicationWindow;
extern DFWINDOW inFocus;
extern DFWINDOW CaptureMouse;
extern DFWINDOW CaptureKeyboard;
extern int foreground, background;
extern BOOL WindowMoving;
extern BOOL WindowSizing;
extern BOOL VSliding;
extern BOOL HSliding;
extern char DFlatApplication[];
extern char *Clipboard;
extern unsigned ClipboardLength;
extern BOOL ClipString;
/* --------- space between menubar labels --------- */
#define MSPACE 2
/* --------------- border characters ------------- */
#define FOCUS_NW (unsigned char) '\xc9'
#define FOCUS_NE (unsigned char) '\xbb'
#define FOCUS_SE (unsigned char) '\xbc'
#define FOCUS_SW (unsigned char) '\xc8'
#define FOCUS_SIDE (unsigned char) '\xba'
#define FOCUS_LINE (unsigned char) '\xcd'
#define NW (unsigned char) '\xda'
#define NE (unsigned char) '\xbf'
#define SE (unsigned char) '\xd9'
#define SW (unsigned char) '\xc0'
#define SIDE (unsigned char) '\xb3'
#define LINE (unsigned char) '\xc4'
#define LEDGE (unsigned char) '\xc3'
#define REDGE (unsigned char) '\xb4'
/* ------------- scroll bar characters ------------ */
#define UPSCROLLBOX (unsigned char) '\x1e'
#define DOWNSCROLLBOX (unsigned char) '\x1f'
#define LEFTSCROLLBOX (unsigned char) '\x11'
#define RIGHTSCROLLBOX (unsigned char) '\x10'
#define SCROLLBARCHAR (unsigned char) 176
#define SCROLLBOXCHAR (unsigned char) 178
/* ------------------ menu characters --------------------- */
#define CHECKMARK (unsigned char) (SCREENHEIGHT==25?251:4)
#define CASCADEPOINTER (unsigned char) '\x10'
/* ----------------- title bar characters ----------------- */
#define CONTROLBOXCHAR (unsigned char) '\xf0'
#define MAXPOINTER 24 /* maximize token */
#define MINPOINTER 25 /* minimize token */
#define RESTOREPOINTER 18 /* restore token */
/* --------------- text control characters ---------------- */
#define APPLCHAR (unsigned char) 176 /* fills application window */
#define SHORTCUTCHAR '~' /* prefix: shortcut key display */
#define CHANGECOLOR (unsigned char) 174 /* prefix to change colors */
#define RESETCOLOR (unsigned char) 175 /* reset colors to default */
#define LISTSELECTOR 4 /* selected list box entry */
/* --------- message prototypes ----------- */
BOOL init_messages(void);
void DfPostMessage (DFWINDOW, DFMESSAGE, PARAM, PARAM);
int DfSendMessage (DFWINDOW, DFMESSAGE, PARAM, PARAM);
BOOL DfDispatchMessage (void);
void handshake(void);
/* ---- standard window message processing prototypes ----- */
int ApplicationProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int NormalProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int TextBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int ListBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int EditBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int PictureProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int MenuBarProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int PopDownProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int ButtonProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int ComboProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int TextProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int RadioButtonProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int CheckBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int SpinButtonProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int BoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int DialogProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int SystemMenuProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int HelpBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int MessageBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int CancelBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int ErrorBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int YesNoBoxProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int StatusBarProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
int WatchIconProc(DFWINDOW, DFMESSAGE, PARAM, PARAM);
/* ------------- normal box prototypes ------------- */
void SetStandardColor(DFWINDOW);
void SetReverseColor(DFWINDOW);
BOOL isAncestor(DFWINDOW, DFWINDOW);
#define HitControlBox(wnd, p1, p2) \
(TestAttribute(wnd, CONTROLBOX) && \
p1 == 2 && p2 == 0)
#define WndForeground(wnd) \
(wnd->WindowColors [STD_COLOR] [FG])
#define WndBackground(wnd) \
(wnd->WindowColors [STD_COLOR] [BG])
#define FrameForeground(wnd) \
(wnd->WindowColors [FRAME_COLOR] [FG])
#define FrameBackground(wnd) \
(wnd->WindowColors [FRAME_COLOR] [BG])
#define SelectForeground(wnd) \
(wnd->WindowColors [SELECT_COLOR] [FG])
#define SelectBackground(wnd) \
(wnd->WindowColors [SELECT_COLOR] [BG])
#define HighlightForeground(wnd) \
(wnd->WindowColors [HILITE_COLOR] [FG])
#define HighlightBackground(wnd) \
(wnd->WindowColors [HILITE_COLOR] [BG])
#define WindowClientColor(wnd, fg, bg) \
WndForeground(wnd) = fg, WndBackground(wnd) = bg
#define WindowReverseColor(wnd, fg, bg) \
SelectForeground(wnd) = fg, SelectBackground(wnd) = bg
#define WindowFrameColor(wnd, fg, bg) \
FrameForeground(wnd) = fg, FrameBackground(wnd) = bg
#define WindowHighlightColor(wnd, fg, bg) \
HighlightForeground(wnd) = fg, HighlightBackground(wnd) = bg
/* -------- text box prototypes ---------- */
#define TextLine(wnd, sel) \
(wnd->text + *((wnd->TextPointers) + sel))
void WriteTextLine(DFWINDOW, DFRECT *, int, BOOL);
#define TextBlockMarked(wnd) ( wnd->BlkBegLine || \
wnd->BlkEndLine || \
wnd->BlkBegCol || \
wnd->BlkEndCol)
void MarkTextBlock(DFWINDOW, int, int, int, int);
#define ClearTextBlock(wnd) wnd->BlkBegLine = wnd->BlkEndLine = \
wnd->BlkBegCol = wnd->BlkEndCol = 0;
#define GetText(w) ((w)->text)
#define GetTextLines(w) ((w)->wlines)
void ClearTextPointers(DFWINDOW);
void BuildTextPointers(DFWINDOW);
int TextLineNumber(DFWINDOW, char *);
/* ------------ Clipboard prototypes ------------- */
void CopyTextToClipboard(char *);
void CopyToClipboard(DFWINDOW);
#define PasteFromClipboard(wnd) PasteText(wnd,Clipboard,ClipboardLength)
BOOL PasteText(DFWINDOW, char *, unsigned);
void ClearClipboard(void);
/* --------- menu prototypes ---------- */
int CopyCommand(unsigned char *, unsigned char *, int, int);
void PrepFileMenu(void *, struct Menu *);
void PrepEditMenu(void *, struct Menu *);
void PrepSearchMenu(void *, struct Menu *);
void PrepWindowMenu(void *, struct Menu *);
void BuildSystemMenu(DFWINDOW);
BOOL isActive(MBAR *, int);
char *GetCommandText(MBAR *, int);
BOOL isCascadedCommand(MBAR *,int);
void ActivateCommand(MBAR *,int);
void DeactivateCommand(MBAR *,int);
BOOL GetCommandToggle(MBAR *,int);
void SetCommandToggle(MBAR *,int);
void ClearCommandToggle(MBAR *,int);
void InvertCommandToggle(MBAR *,int);
int BarSelection(int);
/* ------------- list box prototypes -------------- */
BOOL ItemSelected(DFWINDOW, int);
/* ------------- edit box prototypes ----------- */
#define CurrChar (TextLine(wnd, wnd->CurrLine)+wnd->CurrCol)
#define WndCol (wnd->CurrCol-wnd->wleft)
#define isMultiLine(wnd) TestAttribute(wnd, MULTILINE)
void DfSearchText(DFWINDOW);
void DfReplaceText(DFWINDOW);
void DfSearchNext(DFWINDOW);
/* --------- message box prototypes -------- */
DFWINDOW SliderBox(int, char *, char *);
BOOL InputBox(DFWINDOW, char *, char *, char *, int);
BOOL GenericMessage(DFWINDOW, char *, char *, int,
int (*)(struct window *, enum messages, PARAM, PARAM),
char *, char *, int, int, int);
#define DfTestErrorMessage(msg) \
GenericMessage(NULL, "Error", msg, 2, ErrorBoxProc, \
Ok, Cancel, ID_OK, ID_CANCEL, TRUE)
#define DfErrorMessage(msg) \
GenericMessage(NULL, "Error", msg, 1, ErrorBoxProc, \
Ok, NULL, ID_OK, 0, TRUE)
#define DfMessageBox(ttl, msg) \
GenericMessage(NULL, ttl, msg, 1, MessageBoxProc, \
Ok, NULL, ID_OK, 0, TRUE)
#define DfYesNoBox(msg) \
GenericMessage(NULL, NULL, msg, 2, YesNoBoxProc, \
Yes, No, ID_OK, ID_CANCEL, TRUE)
#define DfCancelBox(wnd, msg) \
GenericMessage(wnd, "Wait...", msg, 1, CancelBoxProc, \
Cancel, NULL, ID_CANCEL, 0, FALSE)
void CloseCancelBox(void);
DFWINDOW MomentaryMessage(char *);
int MsgHeight(char *);
int MsgWidth(char *);
/* ------------- dialog box prototypes -------------- */
BOOL DfDialogBox(DFWINDOW, DBOX *, BOOL,
int (*)(struct window *, enum messages, PARAM, PARAM));
void ClearDialogBoxes(void);
BOOL OpenFileDialogBox(char *, char *);
BOOL SaveAsDialogBox(char *);
void GetDlgListText(DFWINDOW, char *, enum commands);
BOOL DfDlgDirList(DFWINDOW, char *, enum commands,
enum commands, unsigned);
BOOL RadioButtonSetting(DBOX *, enum commands);
void PushRadioButton(DBOX *, enum commands);
void PutItemText(DFWINDOW, enum commands, char *);
void PutComboListText(DFWINDOW, enum commands, char *);
void GetItemText(DFWINDOW, enum commands, char *, int);
char *GetDlgTextString(DBOX *, enum commands, DFCLASS);
void SetDlgTextString(DBOX *, enum commands, char *, DFCLASS);
BOOL CheckBoxSetting(DBOX *, enum commands);
CTLWINDOW *FindCommand(DBOX *, enum commands, int);
DFWINDOW ControlWindow(DBOX *, enum commands);
void SetScrollBars(DFWINDOW);
void SetRadioButton(DBOX *, CTLWINDOW *);
void ControlSetting(DBOX *, enum commands, int, int);
void SetFocusCursor(DFWINDOW);
#define GetControl(wnd) (wnd->ct)
#define GetDlgText(db, cmd) GetDlgTextString(db, cmd, TEXT)
#define GetDlgTextBox(db, cmd) GetDlgTextString(db, cmd, TEXTBOX)
#define GetEditBoxText(db, cmd) GetDlgTextString(db, cmd, EDITBOX)
#define GetComboBoxText(db, cmd) GetDlgTextString(db, cmd, COMBOBOX)
#define SetDlgText(db, cmd, s) SetDlgTextString(db, cmd, s, TEXT)
#define SetDlgTextBox(db, cmd, s) SetDlgTextString(db, cmd, s, TEXTBOX)
#define SetEditBoxText(db, cmd, s) SetDlgTextString(db, cmd, s, EDITBOX)
#define SetComboBoxText(db, cmd, s) SetDlgTextString(db, cmd, s, COMBOBOX)
#define SetDlgTitle(db, ttl) ((db)->dwnd.title = ttl)
#define SetCheckBox(db, cmd) ControlSetting(db, cmd, CHECKBOX, ON)
#define ClearCheckBox(db, cmd) ControlSetting(db, cmd, CHECKBOX, OFF)
#define EnableButton(db, cmd) ControlSetting(db, cmd, BUTTON, ON)
#define DisableButton(db, cmd) ControlSetting(db, cmd, BUTTON, OFF)
/* ---- types of vectors that can be in a picture box ------- */
enum VectTypes {VECTOR, SOLIDBAR, HEAVYBAR, CROSSBAR, LIGHTBAR};
/* ------------- picture box prototypes ------------- */
void DrawVector(DFWINDOW, int, int, int, int);
void DrawBox(DFWINDOW, int, int, int, int);
void DrawBar(DFWINDOW, enum VectTypes, int, int, int, int);
DFWINDOW WatchIcon(void);
/* ------------- help box prototypes ------------- */
void LoadHelpFile(void);
void UnLoadHelpFile(void);
BOOL DisplayHelp(DFWINDOW, char *);
extern char *ClassNames[];
void BuildFileName(char *, char *);
#endif

100
rosapps/dflat32/dflatmsg.h Normal file
View file

@ -0,0 +1,100 @@
/* ----------- 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(CREATE_WINDOW) /* create a window */
DFlatMsg(SHOW_WINDOW) /* show a window */
DFlatMsg(DFM_HIDE_WINDOW) /* hide a window */
DFlatMsg(CLOSE_WINDOW) /* delete a window */
DFlatMsg(SETFOCUS) /* set and clear the focus */
DFlatMsg(PAINT) /* paint the window's data space*/
DFlatMsg(BORDER) /* paint the window's border */
DFlatMsg(TITLE) /* display the window's title */
DFlatMsg(MOVE) /* move the window */
DFlatMsg(DFM_SIZE) /* change the window's size */
#ifdef INCLUDE_MAXIMIZE
DFlatMsg(MAXIMIZE) /* maximize the window */
#endif
#ifdef INCLUDE_MINIMIZE
DFlatMsg(MINIMIZE) /* minimize the window */
#endif
DFlatMsg(RESTORE) /* restore the window */
DFlatMsg(INSIDE_WINDOW) /* test x/y inside a window */
/* ---------------- clock messages ------------------------- */
DFlatMsg(CLOCKTICK) /* the clock ticked */
DFlatMsg(CAPTURE_CLOCK) /* capture clock into a window */
DFlatMsg(RELEASE_CLOCK) /* release clock to the system */
/* -------------- keyboard and screen messages ------------- */
DFlatMsg(KEYBOARD) /* key was pressed */
DFlatMsg(CAPTURE_KEYBOARD) /* capture keyboard into a window */
DFlatMsg(RELEASE_KEYBOARD) /* release keyboard to system */
DFlatMsg(KEYBOARD_CURSOR) /* position the keyboard cursor */
DFlatMsg(CURRENT_KEYBOARD_CURSOR) /*read the cursor position */
DFlatMsg(HIDE_CURSOR) /* hide the keyboard cursor */
DFlatMsg(SHOW_CURSOR) /* display the keyboard cursor */
DFlatMsg(SAVE_CURSOR) /* save the cursor's configuration*/
DFlatMsg(RESTORE_CURSOR) /* restore the saved cursor */
DFlatMsg(SHIFT_CHANGED) /* the shift status changed */
DFlatMsg(WAITKEYBOARD) /* waits for a key to be released */
/* ---------------- mouse messages ------------------------- */
DFlatMsg(MOUSE_TRAVEL) /* set the mouse travel */
DFlatMsg(RIGHT_BUTTON) /* right button pressed */
DFlatMsg(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(WAITMOUSE) /* wait until button released */
DFlatMsg(TESTMOUSE) /* test any mouse button pressed*/
DFlatMsg(CAPTURE_MOUSE) /* capture mouse into a window */
DFlatMsg(RELEASE_MOUSE) /* release the mouse to system */
/* ---------------- text box messages ---------------------- */
DFlatMsg(ADDTEXT) /* append text to the text box */
DFlatMsg(INSERTTEXT) /* insert line of text */
DFlatMsg(DELETETEXT) /* delete line of text */
DFlatMsg(CLEARTEXT) /* clear the edit box */
DFlatMsg(SETTEXT) /* copy text to text buffer */
DFlatMsg(SCROLL) /* vertical line scroll */
DFlatMsg(HORIZSCROLL) /* horizontal column scroll */
DFlatMsg(SCROLLPAGE) /* vertical page scroll */
DFlatMsg(HORIZPAGE) /* horizontal page scroll */
DFlatMsg(SCROLLDOC) /* scroll to beginning/end */
/* ---------------- edit box messages ---------------------- */
DFlatMsg(GETTEXT) /* get text from an edit box */
DFlatMsg(SETTEXTLENGTH) /* set maximum text length */
/* ---------------- menubar messages ----------------------- */
DFlatMsg(BUILDMENU) /* build the menu display */
DFlatMsg(MB_SELECTION) /* menubar selection */
/* ---------------- popdown messages ----------------------- */
DFlatMsg(BUILD_SELECTIONS) /* build the menu display */
DFlatMsg(CLOSE_POPDOWN) /* tell parent popdown is closing */
/* ---------------- list box messages ---------------------- */
DFlatMsg(LB_SELECTION) /* sent to parent on selection */
DFlatMsg(LB_CHOOSE) /* sent when user chooses */
DFlatMsg(LB_CURRENTSELECTION)/* return the current selection */
DFlatMsg(DFM_LB_GETTEXT) /* return the text of selection */
DFlatMsg(LB_SETSELECTION) /* sets the listbox selection */
/* ---------------- dialog box messages -------------------- */
DFlatMsg(INITIATE_DIALOG) /* begin a dialog */
DFlatMsg(ENTERFOCUS) /* tell DB control got focus */
DFlatMsg(LEAVEFOCUS) /* tell DB control lost focus */
DFlatMsg(ENDDIALOG) /* end a dialog */
/* ---------------- help box messages ---------------------- */
DFlatMsg(DISPLAY_HELP)
/* --------------- application window messages ------------- */
DFlatMsg(ADDSTATUS)
/* --------------- picture box messages -------------------- */
DFlatMsg(DRAWVECTOR)
DFlatMsg(DRAWBOX)
DFlatMsg(DRAWBAR)

792
rosapps/dflat32/dialbox.c Normal file
View file

@ -0,0 +1,792 @@
/* ----------------- dialbox.c -------------- */
#include "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 */

55
rosapps/dflat32/dialbox.h Normal file
View file

@ -0,0 +1,55 @@
/* ----------------- dialbox.h ---------------- */
#ifndef DIALOG_H
#define DIALOG_H
#include <stdio.h>
#define MAXCONTROLS 30
#define MAXRADIOS 20
#define OFF FALSE
#define ON TRUE
/* -------- dialog box and control window structure ------- */
typedef struct {
char *title; /* window title */
int x, y; /* relative coordinates */
int h, w; /* size */
} DIALOGWINDOW;
/* ------ one of these for each control window ------- */
typedef struct {
DIALOGWINDOW dwnd;
DFCLASS class; /* LISTBOX, BUTTON, etc */
char *itext; /* initialized text */
int command; /* command code */
char *help; /* help mnemonic */
BOOL isetting; /* initially ON or OFF */
BOOL setting; /* ON or OFF */
void *wnd; /* window handle */
} CTLWINDOW;
/* --------- one of these for each dialog box ------- */
typedef struct {
char *HelpName;
DIALOGWINDOW dwnd;
CTLWINDOW ctl[MAXCONTROLS+1];
} DBOX;
/* -------- macros for dialog box resource compile -------- */
#define DIALOGBOX(db) DBOX db={ #db,
#define DB_TITLE(ttl,x,y,h,w) {ttl,x,y,h,w},{
#define CONTROL(ty,tx,x,y,h,w,c) \
{{NULL,x,y,h,w},ty, \
(ty==EDITBOX||ty==COMBOBOX?NULL:tx), \
c,#c,(ty==BUTTON?ON:OFF),OFF,NULL},
#define ENDDB {{NULL}} }};
#define Cancel " Cancel "
#define Ok " OK "
#define Yes " Yes "
#define No " No "
#endif

160
rosapps/dflat32/dialogs.c Normal file
View file

@ -0,0 +1,160 @@
/* ----------- dialogs.c --------------- */
#include "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 */

175
rosapps/dflat32/direct.c Normal file
View file

@ -0,0 +1,175 @@
/* ---------- 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 CreatePath(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 commands nameid, enum commands pathid,
unsigned attrib)
{
int ax, i = 0;
struct _finddata_t ff;
CTLWINDOW *ct = FindCommand(wnd->extension,nameid,LISTBOX);
DFWINDOW lwnd;
char **dirlist = NULL;
CreatePath(path, fspec, TRUE, TRUE);
if (ct != NULL)
{
lwnd = ct->wnd;
DfSendMessage(ct->wnd, 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,ADDTEXT,(PARAM)drname,0);
}
}
DfSendMessage(lwnd, 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,ADDTEXT,(PARAM)dirlist[j],0);
free(dirlist[j]);
}
free(dirlist);
}
DfSendMessage(lwnd, SHOW_WINDOW, 0, 0);
}
if (pathid)
{
_makepath(path, drive, dir, NULL, NULL);
PutItemText(wnd, pathid, path);
}
return TRUE;
}
/* EOF */

738
rosapps/dflat32/edit.c Normal file
View file

@ -0,0 +1,738 @@
/* --------------- edit.c ----------- */
#include "dflat.h"
extern DBOX PrintSetup;
char DFlatApplication[] = "Edit";
static char Untitled[] = "Untitled";
static int wndpos;
static int MemoPadProc(DFWINDOW, DFMESSAGE, PARAM, 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, PARAM, PARAM);
static char *NameComponent(char *);
static int PrintSetupProc(DFWINDOW, DFMESSAGE, PARAM, 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 (!init_messages())
return 1;
Argv = argv;
LoadConfig ();
// if (!LoadConfig())
// cfg.ScreenLines = SCREENHEIGHT;
wnd = DfCreateWindow (APPLICATION,
"FreeDos Edit " VERSION,
0, 0, -1, -1,
&MainMenu,
NULL,
MemoPadProc,
// MOVEABLE |
// SIZEABLE |
// HASBORDER |
// MINMAXBOX |
HASSTATUSBAR);
LoadHelpFile ();
DfSendMessage (wnd, 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 ())
;
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;
CreatePath(path, FileName, FALSE, FALSE);
cp = path+strlen(path);
CreatePath(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,PARAM p1,PARAM p2)
{
int rtn;
switch (msg)
{
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
if (cfg.InsertMode)
SetCommandToggle(&MainMenu, ID_INSERT);
if (cfg.WordWrap)
SetCommandToggle(&MainMenu, ID_WRAP);
FixTabMenu();
return rtn;
case DFM_COMMAND:
switch ((int)p1)
{
case ID_NEW:
NewFile(wnd,NULL);
return TRUE;
case ID_OPEN:
SelectFile(wnd);
return TRUE;
case ID_SAVE:
SaveFile(inFocus, FALSE);
return TRUE;
case ID_SAVEAS:
SaveFile(inFocus, TRUE);
return TRUE;
case ID_DELETEFILE:
EditDeleteFile(inFocus);
return TRUE;
case ID_PRINTSETUP:
DfDialogBox(wnd, &PrintSetup, TRUE, PrintSetupProc);
return TRUE;
case ID_PRINT:
PrintPad(inFocus);
return TRUE;
case ID_EXIT:
if (!DfYesNoBox("Exit FreeDos Edit?"))
return FALSE;
break;
case ID_WRAP:
cfg.WordWrap = GetCommandToggle(&MainMenu, ID_WRAP);
return TRUE;
case ID_INSERT:
cfg.InsertMode = GetCommandToggle(&MainMenu, ID_INSERT);
return TRUE;
case ID_TAB2:
cfg.Tabs = 2;
FixTabMenu();
return TRUE;
case ID_TAB4:
cfg.Tabs = 4;
FixTabMenu();
return TRUE;
case ID_TAB6:
cfg.Tabs = 6;
FixTabMenu();
return TRUE;
case ID_TAB8:
cfg.Tabs = 8;
FixTabMenu();
return TRUE;
case ID_CALENDAR:
Calendar(wnd);
return TRUE;
// case ID_BARCHART:
// BarChart(wnd);
// return TRUE;
case 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 DefaultWndProc(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 (OpenFileDialogBox("*.*", FileName))
{
/* see if the document is already in a window */
DFWINDOW wnd1 = FirstWindow(wnd);
while (wnd1 != NULL)
{
if (wnd1->extension &&
stricmp(FileName, wnd1->extension) == 0)
{
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, RESTORE, 0, 0);
return;
}
wnd1 = NextWindow(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 *Fnewname = NewFileName;
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 = WatchIcon();
wndpos += 2;
if (NewFileName != NULL)
Fname = NameComponent(NewFileName);
if (wndpos == 20)
wndpos = 2;
wnd1 = DfCreateWindow(EDITBOX,
Fname,
(wndpos-1)*2, wndpos, 10, 40,
NULL, wnd, EditorProc,
SHADOW |
MINMAXBOX |
CONTROLBOX |
VSCROLLBAR |
HSCROLLBAR |
MOVEABLE |
HASBORDER |
SIZEABLE |
MULTILINE);
if (strcmp(FileName, Untitled))
{
wnd1->extension = DFmalloc(strlen(FileName)+1);
strcpy(wnd1->extension, FileName);
LoadFile(wnd1);
}
DfSendMessage(wwnd, CLOSE_WINDOW, 0, 0);
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, 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))
{
handshake();
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, SETTEXT, (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 == cfg.RightMargin)
{
fputs("\r\n", prn);
LineCtr++;
if (LineCtr == cfg.BottomMargin)
{
fputc('\f', prn);
for (i = 0; i < cfg.TopMargin; i++)
fputc('\n', prn);
LineCtr = cfg.TopMargin;
}
CharCtr = 0;
if (c == '\n')
return;
}
if (CharCtr == 0)
{
for (i = 0; i < cfg.LeftMargin; i++)
{
fputc(' ', prn);
CharCtr++;
}
}
CharCtr++;
fputc(c, prn);
}
/* --- print the current notepad --- */
static void PrintPad(DFWINDOW wnd)
{
if (*cfg.PrinterPort)
{
FILE *prn;
if ((prn = fopen(cfg.PrinterPort, "wt")) != NULL)
{
long percent;
BOOL KeepPrinting = TRUE;
unsigned char *text = GetText(wnd);
unsigned oldpct = 100, cct = 0, len = strlen(text);
DFWINDOW swnd = SliderBox(20, GetTitle(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, PAINT, 0, oldpct);
}
}
if (KeepPrinting)
/* ---- user did not cancel ---- */
if (oldpct < 100)
DfSendMessage(swnd, 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 (SaveAsDialogBox(FileName)) {
if (wnd->extension != NULL)
free(wnd->extension);
wnd->extension = DFmalloc(strlen(FileName)+1);
strcpy(wnd->extension, FileName);
AddTitle(wnd, NameComponent(FileName));
DfSendMessage(wnd, BORDER, 0, 0);
}
else
return;
}
if (wnd->extension != NULL)
{
DFWINDOW mwnd = MomentaryMessage("Saving the file");
if ((fp = fopen(wnd->extension, "wt")) != NULL)
{
fwrite(GetText(wnd), strlen(GetText(wnd)), 1, fp);
fclose(fp);
wnd->TextChanged = FALSE;
}
DfSendMessage(mwnd, 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, 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(GetParent(wnd), ADDSTATUS, (PARAM) status, 0);
}
/* window processing module for the editboxes */
static int EditorProc(DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2)
{
int rtn;
switch (msg)
{
case SETFOCUS:
if ((int)p1)
{
wnd->InsertMode = GetCommandToggle(&MainMenu, ID_INSERT);
wnd->WordWrapMode = GetCommandToggle(&MainMenu, ID_WRAP);
}
rtn = DefaultWndProc(wnd, msg, p1, p2);
if ((int)p1 == FALSE)
DfSendMessage(GetParent(wnd), ADDSTATUS, 0, 0);
else
ShowPosition(wnd);
return rtn;
case KEYBOARD_CURSOR:
rtn = DefaultWndProc(wnd, msg, p1, p2);
ShowPosition(wnd);
return rtn;
case DFM_COMMAND:
switch ((int) p1)
{
case ID_SEARCH:
DfSearchText(wnd);
return TRUE;
case ID_REPLACE:
DfReplaceText(wnd);
return TRUE;
case ID_SEARCHNEXT:
DfSearchNext(wnd);
return TRUE;
case ID_CUT:
CopyToClipboard(wnd);
DfSendMessage(wnd, DFM_COMMAND, ID_DELETETEXT, 0);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_COPY:
CopyToClipboard(wnd);
ClearTextBlock(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_PASTE:
PasteFromClipboard(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_DELETETEXT:
case ID_CLEAR:
rtn = DefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, PAINT, 0, 0);
return rtn;
case ID_HELP:
DisplayHelp(wnd, "MEMOPADDOC");
return TRUE;
case ID_WRAP:
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_WRAP, 0);
wnd->WordWrapMode = cfg.WordWrap;
return TRUE;
case ID_INSERT:
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_INSERT, 0);
wnd->InsertMode = cfg.InsertMode;
DfSendMessage(NULL, SHOW_CURSOR, wnd->InsertMode, 0);
return TRUE;
default:
break;
}
break;
case CLOSE_WINDOW:
if (wnd->TextChanged)
{
char *cp = DFmalloc(25+strlen(GetTitle(wnd)));
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
strcpy(cp, GetTitle(wnd));
strcat(cp, "\nText changed. Save it?");
if (DfYesNoBox(cp))
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_SAVE, 0);
free(cp);
}
wndpos = 0;
if (wnd->extension != NULL)
{
free(wnd->extension);
wnd->extension = NULL;
}
break;
default:
break;
}
return DefaultWndProc(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, PARAM p1, PARAM p2)
{
int rtn, i = 0, mar;
char marg[10];
DFWINDOW cwnd;
switch (msg)
{
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
PutItemText(wnd, ID_PRINTERPORT, cfg.PrinterPort);
while (ports[i] != NULL)
PutComboListText(wnd, ID_PRINTERPORT, ports[i++]);
for (mar = CHARSLINE; mar >= 0; --mar)
{
sprintf(marg, "%3d", mar);
PutItemText(wnd, ID_LEFTMARGIN, marg);
PutItemText(wnd, ID_RIGHTMARGIN, marg);
}
for (mar = LINESPAGE; mar >= 0; --mar)
{
sprintf(marg, "%3d", mar);
PutItemText(wnd, ID_TOPMARGIN, marg);
PutItemText(wnd, ID_BOTTOMMARGIN, marg);
}
cwnd = ControlWindow(&PrintSetup, ID_LEFTMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
CHARSLINE-cfg.LeftMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_RIGHTMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
CHARSLINE-cfg.RightMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_TOPMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
LINESPAGE-cfg.TopMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_BOTTOMMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
LINESPAGE-cfg.BottomMargin, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == ID_OK && (int) p2 == 0)
{
GetItemText(wnd, ID_PRINTERPORT, cfg.PrinterPort, 4);
cwnd = ControlWindow(&PrintSetup, ID_LEFTMARGIN);
cfg.LeftMargin = CHARSLINE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_RIGHTMARGIN);
cfg.RightMargin = CHARSLINE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_TOPMARGIN);
cfg.TopMargin = LINESPAGE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_BOTTOMMARGIN);
cfg.BottomMargin = LINESPAGE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
}
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
static void FixTabMenu(void)
{
char *cp = GetCommandText(&MainMenu, ID_TABS);
char *p;
if (cp != NULL)
{
p = strchr(cp, '(');
if (p != NULL)
{
// *(p+1) = (char)(cfg.Tabs + '0');
// if (GetClass(inFocus) == POPDOWNMENU)
// DfSendMessage(inFocus, PAINT, 0, 0);
}
}
}
void PrepFileMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_SAVE);
DeactivateCommand(&MainMenu, ID_SAVEAS);
DeactivateCommand(&MainMenu, ID_DELETEFILE);
DeactivateCommand(&MainMenu, ID_PRINT);
if (wnd != NULL && GetClass(wnd) == EDITBOX)
{
if (isMultiLine(wnd))
{
ActivateCommand(&MainMenu, ID_SAVE);
ActivateCommand(&MainMenu, ID_SAVEAS);
ActivateCommand(&MainMenu, ID_DELETEFILE);
ActivateCommand(&MainMenu, ID_PRINT);
}
}
}
void PrepSearchMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_SEARCH);
DeactivateCommand(&MainMenu, ID_REPLACE);
DeactivateCommand(&MainMenu, ID_SEARCHNEXT);
if (wnd != NULL && GetClass(wnd) == EDITBOX)
{
if (isMultiLine(wnd))
{
ActivateCommand(&MainMenu, ID_SEARCH);
ActivateCommand(&MainMenu, ID_REPLACE);
ActivateCommand(&MainMenu, ID_SEARCHNEXT);
}
}
}
void PrepEditMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_CUT);
DeactivateCommand(&MainMenu, ID_COPY);
DeactivateCommand(&MainMenu, ID_CLEAR);
DeactivateCommand(&MainMenu, ID_DELETETEXT);
DeactivateCommand(&MainMenu, ID_PARAGRAPH);
DeactivateCommand(&MainMenu, ID_PASTE);
DeactivateCommand(&MainMenu, ID_UNDO);
if (wnd != NULL && GetClass(wnd) == EDITBOX)
{
if (isMultiLine(wnd))
{
if (TextBlockMarked(wnd))
{
ActivateCommand(&MainMenu, ID_CUT);
ActivateCommand(&MainMenu, ID_COPY);
ActivateCommand(&MainMenu, ID_CLEAR);
ActivateCommand(&MainMenu, ID_DELETETEXT);
}
ActivateCommand(&MainMenu, ID_PARAGRAPH);
if (!TestAttribute(wnd, READONLY) && Clipboard != NULL)
ActivateCommand(&MainMenu, ID_PASTE);
if (wnd->DeletedText != NULL)
ActivateCommand(&MainMenu, ID_UNDO);
}
}
}
/* EOF */

1455
rosapps/dflat32/edit.txt Normal file
View file

File diff suppressed because it is too large Load diff

1113
rosapps/dflat32/editbox.c Normal file
View file

File diff suppressed because it is too large Load diff

259
rosapps/dflat32/fileopen.c Normal file
View file

@ -0,0 +1,259 @@
/* ----------- fileopen.c ------------- */
#include "dflat.h"
static BOOL DlgFileOpen(char *, char *, DBOX *);
static int DlgFnOpen(DFWINDOW, DFMESSAGE, PARAM, 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 DBOX FileOpen;
extern DBOX SaveAs;
/*
* Dialog Box to select a file to open
*/
BOOL OpenFileDialogBox(char *Fpath, char *Fname)
{
return DlgFileOpen(Fpath, Fname, &FileOpen);
}
/*
* Dialog Box to select a file to save as
*/
BOOL SaveAsDialogBox(char *Fname)
{
return DlgFileOpen(NULL, Fname, &SaveAs);
}
/* --------- generic file open ---------- */
static BOOL DlgFileOpen(char *Fpath, char *Fname, 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,PARAM p1,PARAM p2)
{
int rtn;
DBOX *db;
DFWINDOW cwnd;
switch (msg)
{
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
db = wnd->extension;
cwnd = ControlWindow(db, ID_FILENAME);
DfSendMessage(cwnd, SETTEXTLENGTH, 64, 0);
return rtn;
case INITIATE_DIALOG:
InitDlgBox(wnd);
break;
case DFM_COMMAND:
switch ((int) p1)
{
case ID_FILENAME:
if (p2 != ENTERFOCUS)
{
/* allow user to modify the file spec */
GetItemText(wnd, ID_FILENAME,
FileName, 65);
if (IncompleteFilename(FileName) || Saving)
{
strcpy(OrigSpec, FileName);
StripPath(OrigSpec);
}
if (p2 != LEAVEFOCUS)
DfSendMessage(wnd, DFM_COMMAND, ID_OK, 0);
}
return TRUE;
case ID_OK:
if (p2 != 0)
break;
GetItemText(wnd, ID_FILENAME,
FileName, 65);
strcpy(FileSpec, FileName);
if (IncompleteFilename(FileName))
{
/* no file name yet */
InitDlgBox(wnd);
strcpy(OrigSpec, FileSpec);
return TRUE;
}
else {
GetItemText(wnd, ID_PATH, FileName, 65);
strcat(FileName, FileSpec);
strcpy(NewFileName, FileName);
}
break;
case ID_FILES:
switch ((int) p2)
{
case ENTERFOCUS:
case LB_SELECTION:
/* selected a different filename */
GetDlgListText(wnd, FileName,
ID_FILES);
PutItemText(wnd, ID_FILENAME,
FileName);
break;
case LB_CHOOSE:
/* chose a file name */
GetDlgListText(wnd, FileName,
ID_FILES);
DfSendMessage(wnd, DFM_COMMAND, ID_OK, 0);
break;
default:
break;
}
return TRUE;
case ID_DRIVE:
switch ((int) p2) {
case ENTERFOCUS:
if (Saving)
*FileSpec = '\0';
break;
case LEAVEFOCUS:
if (Saving)
strcpy(FileSpec, FileName);
break;
case LB_SELECTION:
{
char dd[25];
/* selected different drive/dir */
GetDlgListText(wnd, dd, 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 != '.')
{
GetItemText(wnd, ID_PATH, FileSpec, 65);
strcat(FileSpec, FileName);
}
else
strcpy(FileSpec, FileName);
}
break;
case LB_CHOOSE:
/* chose drive/dir */
if (Saving)
PutItemText(wnd, ID_FILENAME, "");
InitDlgBox(wnd);
return TRUE;
default:
break;
}
PutItemText(wnd, ID_FILENAME, FileSpec);
return TRUE;
default:
break;
}
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
/*
* Initialize the dialog box
*/
static void InitDlgBox(DFWINDOW wnd)
{
if (*FileSpec && !Saving)
PutItemText(wnd, ID_FILENAME, FileSpec);
if (DfDlgDirList(wnd, FileSpec, ID_FILES, ID_PATH, 0))
{
StripPath(FileSpec);
DfDlgDirList(wnd, "*.*", 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 */

1
rosapps/dflat32/help.txt Normal file
View file

@ -0,0 +1 @@
help.txt

717
rosapps/dflat32/helpbox.c Normal file
View file

@ -0,0 +1,717 @@
/* ------------ helpbox.c ----------- */
#include "dflat.h"
#include "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 "classes.h"
NULL
};
#define MAXHEIGHT (SCREENHEIGHT-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), SCREENHEIGHT-dwnd->h);
/* --- compute right overlap ---- */
right = OverLap(GetRight(wnd), SCREENWIDTH-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(SCREENHEIGHT-dwnd->h, GetBottom(wnd)+2);
if (right < left)
dwnd->x = min(GetRight(wnd)+2, SCREENWIDTH-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 */

64
rosapps/dflat32/htree.c Normal file
View file

@ -0,0 +1,64 @@
/* ------------------- htree.c -------------------- */
#include "dflat.h"
#include "htree.h"
struct htree *ht;
int root;
int treect;
/* ------ build a Huffman tree from a frequency array ------ */
void buildtree(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 htree *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 htree));
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++;
}
}

31
rosapps/dflat32/htree.h Normal file
View file

@ -0,0 +1,31 @@
/* ------------------- htree.h -------------------- */
#ifndef HTREE_H
#define HTREE_H
typedef unsigned int BYTECOUNTER;
/* ---- Huffman tree structure for building ---- */
struct htree {
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 htr {
int right; /* offset to right child node */
int left; /* offset to left child node */
};
extern struct htr *HelpTree;
void buildtree(void);
FILE *OpenHelpFile(void);
void HelpFilePosition(long *, int *);
void *GetHelpLine(char *);
void SeekHelpLine(long, int);
#endif

118
rosapps/dflat32/huffc.c Normal file
View file

@ -0,0 +1,118 @@
/* ------------------- huffc.c -------------------- */
#include "dflat.h"
#include "htree.h"
extern struct htree *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;
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 htree));
/* - read the input file and count character frequency - */
while ((c = fgetcx(fi)) != EOF) {
c &= 255;
ht[c].cnt++;
bytectr++;
}
/* ---- build the huffman tree ---- */
buildtree();
/* --- 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++;
}

86
rosapps/dflat32/keys.c Normal file
View file

@ -0,0 +1,86 @@
/* ------------- keys.c ----------- */
#include <stdio.h>
#include "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 */

119
rosapps/dflat32/keys.h Normal file
View file

@ -0,0 +1,119 @@
/* ----------- keys.h ------------ */
#ifndef KEYS_H
#define KEYS_H
#define OFFSET 0x1000
#define RUBOUT 8 /* BACHSPACE KEY */
#define BELL 7
#define ESC 27
#define ALT_BS (197+OFFSET)
#define ALT_DEL (184+OFFSET)
#define SHIFT_DEL (198+OFFSET)
#define CTRL_INS (186+OFFSET)
#define SHIFT_INS (185+OFFSET)
#define SHIFT_F8 (219+OFFSET)
#define F1 (187+OFFSET)
#define F2 (188+OFFSET)
#define F3 (189+OFFSET)
#define F4 (190+OFFSET)
#define F5 (191+OFFSET)
#define F6 (192+OFFSET)
#define F7 (193+OFFSET)
#define F8 (194+OFFSET)
#define F9 (195+OFFSET)
#define F10 (196+OFFSET)
#define CTRL_F1 (222+OFFSET)
#define CTRL_F2 (223+OFFSET)
#define CTRL_F3 (224+OFFSET)
#define CTRL_F4 (225+OFFSET)
#define CTRL_F5 (226+OFFSET)
#define CTRL_F6 (227+OFFSET)
#define CTRL_F7 (228+OFFSET)
#define CTRL_F8 (229+OFFSET)
#define CTRL_F9 (230+OFFSET)
#define CTRL_F10 (231+OFFSET)
#define ALT_F1 (232+OFFSET)
#define ALT_F2 (233+OFFSET)
#define ALT_F3 (234+OFFSET)
#define ALT_F4 (235+OFFSET)
#define ALT_F5 (236+OFFSET)
#define ALT_F6 (237+OFFSET)
#define ALT_F7 (238+OFFSET)
#define ALT_F8 (239+OFFSET)
#define ALT_F9 (240+OFFSET)
#define ALT_F10 (241+OFFSET)
#define HOME (199+OFFSET)
#define UP (200+OFFSET)
#define PGUP (201+OFFSET)
#define BS (203+OFFSET) /* CURSOR LEFT KEY */
#define FWD (205+OFFSET) /* CURSOR RIGHT KEY */
#define END (207+OFFSET)
#define DN (208+OFFSET)
#define PGDN (209+OFFSET)
#define INS (210+OFFSET)
#define DEL (211+OFFSET)
#define CTRL_HOME (247+OFFSET)
#define CTRL_PGUP (132+OFFSET)
#define CTRL_BS (243+OFFSET)
#define CTRL_FIVE (143+OFFSET)
#define CTRL_FWD (244+OFFSET)
#define CTRL_END (245+OFFSET)
#define CTRL_PGDN (246+OFFSET)
#define SHIFT_HT (143+OFFSET)
#define ALT_A (158+OFFSET)
#define ALT_B (176+OFFSET)
#define ALT_C (174+OFFSET)
#define ALT_D (160+OFFSET)
#define ALT_E (146+OFFSET)
#define ALT_F (161+OFFSET)
#define ALT_G (162+OFFSET)
#define ALT_H (163+OFFSET)
#define ALT_I (151+OFFSET)
#define ALT_J (164+OFFSET)
#define ALT_K (165+OFFSET)
#define ALT_L (166+OFFSET)
#define ALT_M (178+OFFSET)
#define ALT_N (177+OFFSET)
#define ALT_O (152+OFFSET)
#define ALT_P (153+OFFSET)
#define ALT_Q (144+OFFSET)
#define ALT_R (147+OFFSET)
#define ALT_S (159+OFFSET)
#define ALT_T (148+OFFSET)
#define ALT_U (150+OFFSET)
#define ALT_V (175+OFFSET)
#define ALT_W (145+OFFSET)
#define ALT_X (173+OFFSET)
#define ALT_Y (149+OFFSET)
#define ALT_Z (172+OFFSET)
#define ALT_1 (0xf8+OFFSET)
#define ALT_2 (0xf9+OFFSET)
#define ALT_3 (0xfa+OFFSET)
#define ALT_4 (0xfb+OFFSET)
#define ALT_5 (0xfc+OFFSET)
#define ALT_6 (0xfd+OFFSET)
#define ALT_7 (0xfe+OFFSET)
#define ALT_8 (0xff+OFFSET)
#define ALT_9 (0x80+OFFSET)
#define ALT_0 (0x81+OFFSET)
#define ALT_HYPHEN (130+OFFSET)
#define RIGHTSHIFT 0x01
#define LEFTSHIFT 0x02
#define CTRLKEY 0x04
#define ALTKEY 0x08
#define SCROLLLOCK 0x10
#define NUMLOCK 0x20
#define CAPSLOCK 0x40
#define INSERTKEY 0x80
struct keys {
int keycode;
char *keylabel;
};
extern struct keys keys[];
#endif

469
rosapps/dflat32/listbox.c Normal file
View file

@ -0,0 +1,469 @@
/* ------------- listbox.c ------------ */
#include "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 */

152
rosapps/dflat32/lists.c Normal file
View file

@ -0,0 +1,152 @@
/* --------------- lists.c -------------- */
#include "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;
if (LastWindow(pwnd) != NULL)
NextWindow(LastWindow(pwnd)) = wnd;
PrevWindow(wnd) = LastWindow(pwnd);
LastWindow(pwnd) = wnd;
*/
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 */

75
rosapps/dflat32/log.c Normal file
View file

@ -0,0 +1,75 @@
/* ------------ 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 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 */

56
rosapps/dflat32/makefile Normal file
View file

@ -0,0 +1,56 @@
#
# ReactOS makefile for D-Flat/32
#
TARGET=edit.exe
all: $(TARGET)
OBJECTS = applicat.o barchart.o box.o button.o calendar.o checkbox.o clipbord.o \
combobox.o config.o console.o decomp.o dfalloc.o dialbox.o dialogs.o \
direct.o edit.o editbox.o fileopen.o helpbox.o htree.o keys.o \
listbox.o lists.o log.o menu.o menubar.o menus.o message.o msgbox.o \
normal.o pictbox.o popdown.o radio.o rect.o search.o slidebox.o spinbutt.o \
statbar.o sysmenu.o text.o textbox.o video.o watch.o window.o
CLEAN_FILES = *.o *.exe *.sym *.coff
edit.exe: $(OBJECTS)
$(CC) $(OBJECTS) -lkernel32 -lcrtdll -luser32 -o edit.exe
$(NM) --numeric-sort edit.exe > edit.sym
clean: $(CLEAN_FILES:%=%_clean)
$(CLEAN_FILES:%=%_clean): %_clean:
- $(RM) $*
.phony: clean $(CLEAN_FILES:%=%_clean)
floppy: $(TARGET:%=$(FLOPPY_DIR)/apps/%)
$(TARGET:%=$(FLOPPY_DIR)/apps/%): $(FLOPPY_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* $(FLOPPY_DIR)\apps\$*
else
$(CP) $* $(FLOPPY_DIR)/apps/$*
endif
dist: $(TARGET:%=../$(DIST_DIR)/apps/%)
$(TARGET:%=../$(DIST_DIR)/apps/%): ../$(DIST_DIR)/apps/%: %
ifeq ($(DOSCLI),yes)
$(CP) $* ..\$(DIST_DIR)\apps\$*
else
$(CP) $* ../$(DIST_DIR)/apps\$*
endif
WITH_DEBUGGING=yes
include ../rules.mak
# EOF

638
rosapps/dflat32/memopad.c Normal file
View file

@ -0,0 +1,638 @@
/* --------------- memopad.c ----------- */
#include "dflat.h"
extern DBOX PrintSetup;
char DFlatApplication[] = "MemoPad";
static char Untitled[] = "Untitled";
static int wndpos;
static int MemoPadProc(DFWINDOW, DFMESSAGE, PARAM, 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, PARAM, PARAM);
static char *NameComponent(char *);
static int PrintSetupProc(DFWINDOW, DFMESSAGE, PARAM, 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;
LoadConfig();
// if (!LoadConfig())
// cfg.ScreenLines = SCREENHEIGHT;
wnd = DfCreateWindow(APPLICATION,
"FreeDos Edit " VERSION,
0, 0, -1, -1,
&MainMenu,
NULL,
MemoPadProc,
MOVEABLE |
SIZEABLE |
HASBORDER |
MINMAXBOX |
HASSTATUSBAR
);
LoadHelpFile();
DfSendMessage(wnd, 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;
CreatePath(path, FileName, FALSE, FALSE);
cp = path+strlen(path);
CreatePath(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,PARAM p1,PARAM p2)
{
int rtn;
switch (msg) {
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
if (cfg.InsertMode)
SetCommandToggle(&MainMenu, ID_INSERT);
if (cfg.WordWrap)
SetCommandToggle(&MainMenu, ID_WRAP);
FixTabMenu();
return rtn;
case DFM_COMMAND:
switch ((int)p1) {
case ID_NEW:
NewFile(wnd);
return TRUE;
case ID_OPEN:
SelectFile(wnd);
return TRUE;
case ID_SAVE:
SaveFile(inFocus, FALSE);
return TRUE;
case ID_SAVEAS:
SaveFile(inFocus, TRUE);
return TRUE;
case ID_DELETEFILE:
MemoPadDeleteFile(inFocus);
return TRUE;
case ID_PRINTSETUP:
DfDialogBox(wnd, &PrintSetup, TRUE, PrintSetupProc);
return TRUE;
case ID_PRINT:
PrintPad(inFocus);
return TRUE;
case ID_EXIT:
if (!DfYesNoBox("Exit Memopad?"))
return FALSE;
break;
case ID_WRAP:
cfg.WordWrap = GetCommandToggle(&MainMenu, ID_WRAP);
return TRUE;
case ID_INSERT:
cfg.InsertMode = GetCommandToggle(&MainMenu, ID_INSERT);
return TRUE;
case ID_TAB2:
cfg.Tabs = 2;
FixTabMenu();
return TRUE;
case ID_TAB4:
cfg.Tabs = 4;
FixTabMenu();
return TRUE;
case ID_TAB6:
cfg.Tabs = 6;
FixTabMenu();
return TRUE;
case ID_TAB8:
cfg.Tabs = 8;
FixTabMenu();
return TRUE;
case ID_CALENDAR:
#ifndef TURBOC
Calendar(wnd);
#endif
return TRUE;
// case ID_BARCHART:
// BarChart(wnd);
// return TRUE;
case 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 DefaultWndProc(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 (OpenFileDialogBox("*.PAD", FileName)) {
/* --- see if the document is already in a window --- */
DFWINDOW wnd1 = FirstWindow(wnd);
while (wnd1 != NULL) {
if (stricmp(FileName, wnd1->extension) == 0) {
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, RESTORE, 0, 0);
return;
}
wnd1 = NextWindow(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 = WatchIcon();
wndpos += 2;
if (wndpos == 20)
wndpos = 2;
wnd1 = DfCreateWindow(EDITBOX,
Fname,
(wndpos-1)*2, wndpos, 10, 40,
NULL, wnd, EditorProc,
SHADOW |
MINMAXBOX |
CONTROLBOX |
VSCROLLBAR |
HSCROLLBAR |
MOVEABLE |
HASBORDER |
SIZEABLE |
MULTILINE
);
if (strcmp(FileName, Untitled)) {
wnd1->extension = DFmalloc(strlen(FileName)+1);
strcpy(wnd1->extension, FileName);
LoadFile(wnd1);
}
DfSendMessage(wwnd, CLOSE_WINDOW, 0, 0);
DfSendMessage(wnd1, SETFOCUS, TRUE, 0);
DfSendMessage(wnd1, 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)) {
handshake();
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, SETTEXT, (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 == cfg.RightMargin) {
fputs("\r\n", prn);
LineCtr++;
if (LineCtr == cfg.BottomMargin) {
fputc('\f', prn);
for (i = 0; i < cfg.TopMargin; i++)
fputc('\n', prn);
LineCtr = cfg.TopMargin;
}
CharCtr = 0;
if (c == '\n')
return;
}
if (CharCtr == 0) {
for (i = 0; i < cfg.LeftMargin; i++) {
fputc(' ', prn);
CharCtr++;
}
}
CharCtr++;
fputc(c, prn);
}
/* --- print the current notepad --- */
static void PrintPad(DFWINDOW wnd)
{
if (*cfg.PrinterPort) {
FILE *prn;
if ((prn = fopen(cfg.PrinterPort, "wt")) != NULL) {
long percent;
BOOL KeepPrinting = TRUE;
unsigned char *text = GetText(wnd);
unsigned oldpct = 100, cct = 0, len = strlen(text);
DFWINDOW swnd = SliderBox(20, GetTitle(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, PAINT, 0, oldpct);
}
}
if (KeepPrinting)
/* ---- user did not cancel ---- */
if (oldpct < 100)
DfSendMessage(swnd, 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 (SaveAsDialogBox(FileName)) {
if (wnd->extension != NULL)
free(wnd->extension);
wnd->extension = DFmalloc(strlen(FileName)+1);
strcpy(wnd->extension, FileName);
AddTitle(wnd, NameComponent(FileName));
DfSendMessage(wnd, BORDER, 0, 0);
}
else
return;
}
if (wnd->extension != NULL) {
DFWINDOW mwnd = MomentaryMessage("Saving the file");
if ((fp = fopen(wnd->extension, "wt")) != NULL) {
fwrite(GetText(wnd), strlen(GetText(wnd)), 1, fp);
fclose(fp);
wnd->TextChanged = FALSE;
}
DfSendMessage(mwnd, 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, 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(GetParent(wnd), ADDSTATUS, (PARAM) status, 0);
}
/* ----- window processing module for the editboxes ----- */
static int EditorProc(DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2)
{
int rtn;
switch (msg) {
case SETFOCUS:
if ((int)p1) {
wnd->InsertMode = GetCommandToggle(&MainMenu, ID_INSERT);
wnd->WordWrapMode = GetCommandToggle(&MainMenu, ID_WRAP);
}
rtn = DefaultWndProc(wnd, msg, p1, p2);
if ((int)p1 == FALSE)
DfSendMessage(GetParent(wnd), ADDSTATUS, 0, 0);
else
ShowPosition(wnd);
return rtn;
case KEYBOARD_CURSOR:
rtn = DefaultWndProc(wnd, msg, p1, p2);
ShowPosition(wnd);
return rtn;
case DFM_COMMAND:
switch ((int) p1) {
case ID_SEARCH:
SearchText(wnd);
return TRUE;
case ID_REPLACE:
ReplaceText(wnd);
return TRUE;
case ID_SEARCHNEXT:
SearchNext(wnd);
return TRUE;
case ID_CUT:
CopyToClipboard(wnd);
DfSendMessage(wnd, DFM_COMMAND, ID_DELETETEXT, 0);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_COPY:
CopyToClipboard(wnd);
ClearTextBlock(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_PASTE:
PasteFromClipboard(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
case ID_DELETETEXT:
case ID_CLEAR:
rtn = DefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, PAINT, 0, 0);
return rtn;
case ID_HELP:
DisplayHelp(wnd, "MEMOPADDOC");
return TRUE;
case ID_WRAP:
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_WRAP, 0);
wnd->WordWrapMode = cfg.WordWrap;
return TRUE;
case ID_INSERT:
DfSendMessage(GetParent(wnd), DFM_COMMAND, ID_INSERT, 0);
wnd->InsertMode = cfg.InsertMode;
DfSendMessage(NULL, SHOW_CURSOR, wnd->InsertMode, 0);
return TRUE;
default:
break;
}
break;
case CLOSE_WINDOW:
if (wnd->TextChanged) {
char *cp = DFmalloc(25+strlen(GetTitle(wnd)));
DfSendMessage(wnd, SETFOCUS, TRUE, 0);
strcpy(cp, GetTitle(wnd));
strcat(cp, "\nText changed. Save it?");
if (DfYesNoBox(cp))
DfSendMessage(GetParent(wnd),
DFM_COMMAND, ID_SAVE, 0);
free(cp);
}
wndpos = 0;
if (wnd->extension != NULL) {
free(wnd->extension);
wnd->extension = NULL;
}
break;
default:
break;
}
return DefaultWndProc(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, PARAM p1, PARAM p2)
{
int rtn, i = 0, mar;
char marg[10];
DFWINDOW cwnd;
switch (msg) {
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
PutItemText(wnd, ID_PRINTERPORT, cfg.PrinterPort);
while (ports[i] != NULL)
PutComboListText(wnd, ID_PRINTERPORT, ports[i++]);
for (mar = CHARSLINE; mar >= 0; --mar) {
sprintf(marg, "%3d", mar);
PutItemText(wnd, ID_LEFTMARGIN, marg);
PutItemText(wnd, ID_RIGHTMARGIN, marg);
}
for (mar = LINESPAGE; mar >= 0; --mar) {
sprintf(marg, "%3d", mar);
PutItemText(wnd, ID_TOPMARGIN, marg);
PutItemText(wnd, ID_BOTTOMMARGIN, marg);
}
cwnd = ControlWindow(&PrintSetup, ID_LEFTMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
CHARSLINE-cfg.LeftMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_RIGHTMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
CHARSLINE-cfg.RightMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_TOPMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
LINESPAGE-cfg.TopMargin, 0);
cwnd = ControlWindow(&PrintSetup, ID_BOTTOMMARGIN);
DfSendMessage(cwnd, LB_SETSELECTION,
LINESPAGE-cfg.BottomMargin, 0);
return rtn;
case DFM_COMMAND:
if ((int) p1 == ID_OK && (int) p2 == 0) {
GetItemText(wnd, ID_PRINTERPORT, cfg.PrinterPort, 4);
cwnd = ControlWindow(&PrintSetup, ID_LEFTMARGIN);
cfg.LeftMargin = CHARSLINE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_RIGHTMARGIN);
cfg.RightMargin = CHARSLINE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_TOPMARGIN);
cfg.TopMargin = LINESPAGE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
cwnd = ControlWindow(&PrintSetup, ID_BOTTOMMARGIN);
cfg.BottomMargin = LINESPAGE -
DfSendMessage(cwnd, LB_CURRENTSELECTION, 0, 0);
}
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
static void FixTabMenu(void)
{
char *cp = GetCommandText(&MainMenu, ID_TABS);
if (cp != NULL) {
cp = strchr(cp, '(');
if (cp != NULL) {
*(cp+1) = cfg.Tabs + '0';
if (GetClass(inFocus) == POPDOWNMENU)
DfSendMessage(inFocus, PAINT, 0, 0);
}
}
}
void PrepFileMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_SAVE);
DeactivateCommand(&MainMenu, ID_SAVEAS);
DeactivateCommand(&MainMenu, ID_DELETEFILE);
DeactivateCommand(&MainMenu, ID_PRINT);
if (wnd != NULL && GetClass(wnd) == EDITBOX) {
if (isMultiLine(wnd)) {
ActivateCommand(&MainMenu, ID_SAVE);
ActivateCommand(&MainMenu, ID_SAVEAS);
ActivateCommand(&MainMenu, ID_DELETEFILE);
ActivateCommand(&MainMenu, ID_PRINT);
}
}
}
void PrepSearchMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_SEARCH);
DeactivateCommand(&MainMenu, ID_REPLACE);
DeactivateCommand(&MainMenu, ID_SEARCHNEXT);
if (wnd != NULL && GetClass(wnd) == EDITBOX) {
if (isMultiLine(wnd)) {
ActivateCommand(&MainMenu, ID_SEARCH);
ActivateCommand(&MainMenu, ID_REPLACE);
ActivateCommand(&MainMenu, ID_SEARCHNEXT);
}
}
}
void PrepEditMenu(void *w, struct Menu *mnu)
{
DFWINDOW wnd = w;
DeactivateCommand(&MainMenu, ID_CUT);
DeactivateCommand(&MainMenu, ID_COPY);
DeactivateCommand(&MainMenu, ID_CLEAR);
DeactivateCommand(&MainMenu, ID_DELETETEXT);
DeactivateCommand(&MainMenu, ID_PARAGRAPH);
DeactivateCommand(&MainMenu, ID_PASTE);
DeactivateCommand(&MainMenu, ID_UNDO);
if (wnd != NULL && GetClass(wnd) == EDITBOX) {
if (isMultiLine(wnd)) {
if (TextBlockMarked(wnd)) {
ActivateCommand(&MainMenu, ID_CUT);
ActivateCommand(&MainMenu, ID_COPY);
ActivateCommand(&MainMenu, ID_CLEAR);
ActivateCommand(&MainMenu, ID_DELETETEXT);
}
ActivateCommand(&MainMenu, ID_PARAGRAPH);
if (!TestAttribute(wnd, READONLY) &&
Clipboard != NULL)
ActivateCommand(&MainMenu, ID_PASTE);
if (wnd->DeletedText != NULL)
ActivateCommand(&MainMenu, ID_UNDO);
}
}
}
/* EOF */

85
rosapps/dflat32/menu.c Normal file
View file

@ -0,0 +1,85 @@
/* ------------- menu.c ------------- */
#include "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;
}

63
rosapps/dflat32/menu.h Normal file
View file

@ -0,0 +1,63 @@
/* ------------ menu.h ------------- */
#ifndef MENU_H
#define MENU_H
#define MAXPULLDOWNS 15
#define MAXSELECTIONS 20
#define MAXCASCADES 3 /* nesting level of cascaded menus */
/* ----------- popdown menu selection structure
one for each selection on a popdown menu --------- */
struct PopDown {
unsigned char *SelectionTitle; /* title of the selection */
int ActionId; /* the command executed */
int Accelerator; /* the accelerator key */
int Attrib; /* INACTIVE | CHECKED | TOGGLE | CASCADED*/
char *help; /* Help mnemonic */
};
/* ----------- popdown menu structure
one for each popdown menu on the menu bar -------- */
typedef struct Menu {
char *Title; /* title on the menu bar */
void (*PrepMenu)(void *, struct Menu *); /* function */
char *StatusText; /* text for the status bar */
int CascadeId; /* command id of cascading selection */
int Selection; /* most recent selection */
struct PopDown Selections[MAXSELECTIONS+1];
} MENU;
/* ----- one for each menu bar ----- */
typedef struct MenuBar {
int ActiveSelection;
MENU PullDown[MAXPULLDOWNS+1];
} MBAR;
/* --------- macros to define a menu bar with
popdowns and selections ------------- */
#define SEPCHAR "\xc4"
#define DEFMENU(m) MBAR m = {-1,{
#define POPDOWN(ttl,func,stat) {ttl,func,stat,-1,0,{
#define CASCADED_POPDOWN(id,func) {NULL,func,NULL,id,0,{
#define SELECTION(stxt,acc,id,attr) {stxt,acc,id,attr,#acc},
#define SEPARATOR {SEPCHAR},
#define ENDPOPDOWN {NULL}}},
#define ENDMENU {(void *)-1} }};
/* -------- menu selection attributes -------- */
#define INACTIVE 1
#define CHECKED 2
#define TOGGLE 4
#define CASCADED 8
/* --------- the standard menus ---------- */
extern MBAR MainMenu;
extern MBAR SystemMenu;
extern MBAR *ActiveMenuBar;
int MenuHeight(struct PopDown *);
int MenuWidth(struct PopDown *);
#endif

428
rosapps/dflat32/menubar.c Normal file
View file

@ -0,0 +1,428 @@
/* ---------------- 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;
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), SCREENWIDTH+5);
memset(GetText(wnd), ' ', SCREENWIDTH);
*(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 */

126
rosapps/dflat32/menus.c Normal file
View file

@ -0,0 +1,126 @@
/* -------------- menus.c ------------- */
#include "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

692
rosapps/dflat32/message.c Normal file
View file

@ -0,0 +1,692 @@
/* --------- message.c ---------- */
#include "dflat.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();
}
/* ------------ initialize the message system --------- */
BOOL init_messages (VOID)
{
AllocTesting = TRUE;
if (setjmp(AllocError) != 0)
{
StopMsg();
return FALSE;
}
/* enable mouse events */
SetConsoleMode (GetStdHandle (STD_INPUT_HANDLE),
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;
}
/* ----- 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 0
if (sk != OldShiftKeys)
{
OldShiftKeys = sk;
/* the shift status changed */
PostEvent(SHIFT_CHANGED, sk, 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_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
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);
}
}
}
#if 0
/* --------- keyboard events ---------- */
if ((sk = getshift()) != ShiftKeys)
{
ShiftKeys = sk;
/* ---- the shift status changed ---- */
PostEvent(SHIFT_CHANGED, sk, 0);
if (sk & ALTKEY)
AltDown = TRUE;
}
/* ---- build keyboard events for key combinations that
BIOS doesn't report --------- */
if (sk & ALTKEY) {
if (keyportvalue == 14) {
AltDown = FALSE;
PostEvent(KEYBOARD, ALT_BS, sk);
}
if (keyportvalue == 83) {
AltDown = FALSE;
PostEvent(KEYBOARD, ALT_DEL, sk);
}
}
if (sk & CTRLKEY)
{
AltDown = FALSE;
if (keyportvalue == 82) {
PostEvent(KEYBOARD, CTRL_INS, sk);
}
}
/* ----------- test for keystroke ------- */
if (keyhit()) {
static int cvt[] = {SHIFT_INS,END,DN,PGDN,BS,'5',
FWD,HOME,UP,PGUP};
INPUT_RECORD ir;
int c;
GetKey(&ir);
c = ir.Event.KeyEvent.uChar.AsciiChar;
AltDown = FALSE;
/* -------- convert numeric pad keys ------- */
if (sk & (LEFTSHIFT | RIGHTSHIFT))
{
if (c >= '0' && c <= '9')
c = cvt[c-'0'];
else if (c == '.' || c == DEL)
c = SHIFT_DEL;
else if (c == INS)
c = SHIFT_INS;
}
/* ------ post the keyboard event ------ */
PostEvent(KEYBOARD, c, sk);
}
#endif
}
/* ----- 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_type(0x0106);
else
set_cursor_type(0x0607);
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 */

210
rosapps/dflat32/msgbox.c Normal file
View file

@ -0,0 +1,210 @@
/* ------------------ msgbox.c ------------------ */
#include "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, SCREENHEIGHT-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), SCREENWIDTH-10);
}
/* EOF */

1085
rosapps/dflat32/normal.c Normal file
View file

File diff suppressed because it is too large Load diff

284
rosapps/dflat32/pictbox.c Normal file
View file

@ -0,0 +1,284 @@
/* -------------- pictbox.c -------------- */
#include "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 */

389
rosapps/dflat32/popdown.c Normal file
View file

@ -0,0 +1,389 @@
/* ------------- popdown.c ----------- */
#include "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 = SCREENHEIGHT-1-wnd->rc.bt;
if (adj < 0) {
wnd->rc.tp += adj;
wnd->rc.bt += adj;
}
adj = SCREENWIDTH-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 */

116
rosapps/dflat32/radio.c Normal file
View file

@ -0,0 +1,116 @@
/* -------- radio.c -------- */
#include "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 */

104
rosapps/dflat32/readme.doc Normal file
View file

@ -0,0 +1,104 @@
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.

33
rosapps/dflat32/readme.txt Normal file
View file

@ -0,0 +1,33 @@
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)
- establish consitent naming conventions ('Df'/'DF' prefix) to avoid
collisions (e.g. CreateWindow() --> DfCreateWindow())
- fix short dos filename buffers
- add code to register external window classes
- implement recognition of current console screen size
- 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 ekohl@rz-online.de

106
rosapps/dflat32/rect.c Normal file
View file

@ -0,0 +1,106 @@
/* ------------- 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 (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) = SCREENWIDTH - 2; // GetClientRight((DFWINDOW)wnd);
RectBottom(rc) = SCREENHEIGHT - 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) = SCREENWIDTH-1;
RectBottom(sr) = SCREENHEIGHT-1;
if (!TestAttribute((DFWINDOW)wnd, NOCLIP))
while ((wnd = GetParent((DFWINDOW)wnd)) != NULL)
rc = subRectangle(rc, ClientRect(wnd));
return subRectangle(rc, sr);
}
/* EOF */

24
rosapps/dflat32/rect.h Normal file
View file

@ -0,0 +1,24 @@
/* ----------- rect.h ------------ */
#ifndef RECT_H
#define RECT_H
typedef struct {
int lf,tp,rt,bt;
} DFRECT;
#define within(p,v1,v2) ((p)>=(v1)&&(p)<=(v2))
#define RectTop(r) (r.tp)
#define RectBottom(r) (r.bt)
#define RectLeft(r) (r.lf)
#define RectRight(r) (r.rt)
#define InsideRect(x,y,r) (within((x),RectLeft(r),RectRight(r))\
&& \
within((y),RectTop(r),RectBottom(r)))
#define ValidRect(r) (RectRight(r) || RectLeft(r) || \
RectTop(r) || RectBottom(r))
#define RectWidth(r) (RectRight(r)-RectLeft(r)+1)
#define RectHeight(r) (RectBottom(r)-RectTop(r)+1)
DFRECT subRectangle(DFRECT, DFRECT);
DFRECT ClientRect(void *);
DFRECT RelativeWindowRect(void *, DFRECT);
DFRECT ClipRectangle(void *, DFRECT);
#endif

163
rosapps/dflat32/search.c Normal file
View file

@ -0,0 +1,163 @@
/* ---------------- search.c ------------- */
#include "dflat.h"
extern DBOX SearchTextDB;
extern 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, DBOX *db)
{
char *cr = GetEditBoxText(db, ID_REPLACEWITH);
char *cp = GetEditBoxText(db, 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 = NULL, *s2, *cp1;
DBOX *db = Replacing ? &ReplaceTextDB : &SearchTextDB;
char *cp = GetEditBoxText(db, ID_SEARCHFOR);
BOOL rpl = TRUE, FoundOne = FALSE;
while (rpl == TRUE && cp != NULL && *cp) {
rpl = Replacing ?
CheckBoxSetting(&ReplaceTextDB, ID_REPLACEALL) :
FALSE;
if (TextBlockMarked(wnd)) {
ClearTextBlock(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
}
/* search for a match starting at cursor position */
cp1 = CurrChar;
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 = TextLineNumber(wnd, s2);
wnd->BlkBegLine = TextLineNumber(wnd, cp1);
if (wnd->BlkEndLine < wnd->BlkBegLine)
wnd->BlkEndLine = wnd->BlkBegLine;
wnd->BlkEndCol =
(int)((int)s2 - (int)TextLine(wnd, wnd->BlkEndLine));
wnd->BlkBegCol =
(int)((int)cp1 - (int)TextLine(wnd, wnd->BlkBegLine));
/* position the cursor 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 (WndCol > ClientWidth(wnd)-1)
wnd->wleft = wnd->CurrCol;
if (wnd->WndRow > ClientHeight(wnd)-1) {
wnd->wtop = wnd->CurrLine;
wnd->WndRow = 0;
}
DfSendMessage(wnd, PAINT, 0, 0);
DfSendMessage(wnd, KEYBOARD_CURSOR,
WndCol, wnd->WndRow);
if (Replacing) {
if (rpl || DfYesNoBox("Replace the text?")) {
replacetext(wnd, cp1, db);
wnd->TextChanged = TRUE;
BuildTextPointers(wnd);
}
if (rpl) {
incr = TRUE;
continue;
}
ClearTextBlock(wnd);
DfSendMessage(wnd, 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)
SetCheckBox(&ReplaceTextDB, ID_MATCHCASE);
if (DfDialogBox(NULL, &ReplaceTextDB, TRUE, NULL)) {
CheckCase=CheckBoxSetting(&ReplaceTextDB,ID_MATCHCASE);
SearchTextBox(wnd, FALSE);
}
}
/* ------- search for the first occurrance of a string ------ */
void DfSearchText(DFWINDOW wnd)
{
Replacing = FALSE;
if (CheckCase)
SetCheckBox(&SearchTextDB, ID_MATCHCASE);
if (DfDialogBox(NULL, &SearchTextDB, TRUE, NULL)) {
CheckCase=CheckBoxSetting(&SearchTextDB,ID_MATCHCASE);
SearchTextBox(wnd, FALSE);
}
}
/* ------- search for the next occurrance of a string ------- */
void DfSearchNext(DFWINDOW wnd)
{
SearchTextBox(wnd, TRUE);
}
/* EOF */

114
rosapps/dflat32/slidebox.c Normal file
View file

@ -0,0 +1,114 @@
/* ------------- slidebox.c ------------ */
#include "dflat.h"
static int (*GenericProc)
(DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2);
static BOOL KeepRunning;
static int SliderLen;
static int Percent;
extern DBOX SliderBoxDB;
static void InsertPercent(char *s)
{
int offset;
char pcc[5];
sprintf(s, "%c%c%c",
CHANGECOLOR,
color[DIALOG][SELECT_COLOR][FG]+0x80,
color[DIALOG][SELECT_COLOR][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",
RESETCOLOR,
CHANGECOLOR,
color[DIALOG][SELECT_COLOR][BG]+0x80,
color[DIALOG][SELECT_COLOR][FG]+0x80);
strncpy(s+offset, pcc, 4);
*(s + strlen(s) - 1) = RESETCOLOR;
}
static int
SliderTextProc (DFWINDOW wnd,DFMESSAGE msg,PARAM p1,PARAM p2)
{
switch (msg)
{
case PAINT:
Percent = (int)p2;
InsertPercent(GetText(wnd) ?
GetText(wnd) : SliderBoxDB.ctl[1].itext);
GenericProc(wnd, PAINT, 0, 0);
if (Percent >= 100)
DfSendMessage(GetParent(wnd),DFM_COMMAND,ID_CANCEL,0);
if (!DfDispatchMessage ())
DfPostMessage(GetParent(wnd), ENDDIALOG, 0, 0);
return KeepRunning;
default:
break;
}
return GenericProc(wnd, msg, p1, p2);
}
static int
SliderBoxProc (DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
DFWINDOW twnd;
switch (msg) {
case CREATE_WINDOW:
AddAttribute(wnd, SAVESELF);
rtn = DefaultWndProc(wnd, msg, p1, p2);
twnd = SliderBoxDB.ctl[1].wnd;
GenericProc = twnd->wndproc;
twnd->wndproc = SliderTextProc;
KeepRunning = TRUE;
DfSendMessage(wnd, CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, CAPTURE_KEYBOARD, 0, 0);
return rtn;
case DFM_COMMAND:
if ((int)p2 == 0 && (int)p1 == ID_CANCEL) {
if (Percent >= 100 ||
DfYesNoBox("Terminate process?"))
KeepRunning = FALSE;
else
return TRUE;
}
break;
case CLOSE_WINDOW:
DfSendMessage(wnd, RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, RELEASE_KEYBOARD, 0, 0);
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
DFWINDOW SliderBox(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 */

48
rosapps/dflat32/spinbutt.c Normal file
View file

@ -0,0 +1,48 @@
/* ------------ spinbutt.c ------------- */
#include "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 */

53
rosapps/dflat32/statbar.c Normal file
View file

@ -0,0 +1,53 @@
/* ---------------- statbar.c -------------- */
#include "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 */

108
rosapps/dflat32/sysmenu.c Normal file
View file

@ -0,0 +1,108 @@
/* ------------- sysmenu.c ------------ */
#include "dflat.h"
int SystemMenuProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int mx, my;
DFWINDOW wnd1;
switch (msg) {
case CREATE_WINDOW:
wnd->holdmenu = ActiveMenuBar;
ActiveMenuBar = &SystemMenu;
SystemMenu.PullDown[0].Selection = 0;
break;
case LEFT_BUTTON:
wnd1 = GetParent(wnd);
mx = (int) p1 - GetLeft(wnd1);
my = (int) p2 - GetTop(wnd1);
if (HitControlBox(wnd1, mx, my))
return TRUE;
break;
case LB_CHOOSE:
DfPostMessage(wnd, CLOSE_WINDOW, 0, 0);
break;
case DOUBLE_CLICK:
if (p2 == GetTop(GetParent(wnd))) {
DfPostMessage(GetParent(wnd), msg, p1, p2);
DfSendMessage(wnd, CLOSE_WINDOW, TRUE, 0);
}
return TRUE;
case SHIFT_CHANGED:
return TRUE;
case CLOSE_WINDOW:
ActiveMenuBar = wnd->holdmenu;
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
/* ------- Build a system menu -------- */
void BuildSystemMenu(DFWINDOW wnd)
{
int lf, tp, ht, wd;
DFWINDOW SystemMenuWnd;
SystemMenu.PullDown[0].Selections[6].Accelerator =
(GetClass(wnd) == APPLICATION) ? ALT_F4 : CTRL_F4;
lf = GetLeft(wnd)+1;
tp = GetTop(wnd)+1;
ht = MenuHeight(SystemMenu.PullDown[0].Selections);
wd = MenuWidth(SystemMenu.PullDown[0].Selections);
if (lf+wd > SCREENWIDTH-1)
lf = (SCREENWIDTH-1) - wd;
if (tp+ht > SCREENHEIGHT-2)
tp = (SCREENHEIGHT-2) - ht;
SystemMenuWnd = DfCreateWindow(POPDOWNMENU, NULL,
lf,tp,ht,wd,NULL,wnd,SystemMenuProc, 0);
#ifdef INCLUDE_RESTORE
if (wnd->condition == ISRESTORED)
DeactivateCommand(&SystemMenu, ID_SYSRESTORE);
else
ActivateCommand(&SystemMenu, ID_SYSRESTORE);
#endif
if (TestAttribute(wnd, MOVEABLE)
#ifdef INCLUDE_MAXIMIZE
&& wnd->condition != ISMAXIMIZED
#endif
)
ActivateCommand(&SystemMenu, ID_SYSMOVE);
else
DeactivateCommand(&SystemMenu, ID_SYSMOVE);
if (wnd->condition != ISRESTORED ||
TestAttribute(wnd, SIZEABLE) == FALSE)
DeactivateCommand(&SystemMenu, ID_SYSSIZE);
else
ActivateCommand(&SystemMenu, ID_SYSSIZE);
#ifdef INCLUDE_MINIMIZE
if (wnd->condition == ISMINIMIZED ||
TestAttribute(wnd, MINMAXBOX) == FALSE)
DeactivateCommand(&SystemMenu, ID_SYSMINIMIZE);
else
ActivateCommand(&SystemMenu, ID_SYSMINIMIZE);
#endif
#ifdef INCLUDE_MAXIMIZE
if (wnd->condition != ISRESTORED ||
TestAttribute(wnd, MINMAXBOX) == FALSE)
DeactivateCommand(&SystemMenu, ID_SYSMAXIMIZE);
else
ActivateCommand(&SystemMenu, ID_SYSMAXIMIZE);
#endif
DfSendMessage(SystemMenuWnd, BUILD_SELECTIONS,
(PARAM) &SystemMenu.PullDown[0], 0);
DfSendMessage(SystemMenuWnd, SETFOCUS, TRUE, 0);
DfSendMessage(SystemMenuWnd, SHOW_WINDOW, 0, 0);
}
/* EOF */

92
rosapps/dflat32/system.h Normal file
View file

@ -0,0 +1,92 @@
/* --------------- 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 KEYBOARDPORT 0x60
#define FREQUENCY 100
#define COUNT (1193280L / FREQUENCY)
#define ZEROFLAG 0x40
#define MAXSAVES 50
#define SCREENWIDTH (80)
#define SCREENHEIGHT (25)
/* ---------- keyboard prototypes -------- */
int AltConvert(int);
void GetKey(PINPUT_RECORD);
int getshift(void);
BOOL keyhit(void);
void beep(void);
/* ---------- cursor prototypes -------- */
void curr_cursor(int *x, int *y);
void cursor(int x, int y);
void hidecursor(void);
void unhidecursor(void);
void savecursor(void);
void restorecursor(void);
void normalcursor(void);
void set_cursor_type(unsigned t);
void videomode(void);
void SwapCursorStack(void);
/* ------------ timer macros -------------- */
#define timed_out(timer) (timer==0)
#define set_timer(timer, secs) timer=(secs)*182/10+1
#define disable_timer(timer) timer = -1
#define timer_running(timer) (timer > 0)
#define countdown(timer) --timer
#define timer_disabled(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 keyhit kbhit
#endif
#endif
typedef enum messages {
#ifdef WATCOM
WATCOMFIX1 = -1,
#endif
#undef DFlatMsg
#define DFlatMsg(m) m,
#include "dflatmsg.h"
MESSAGECOUNT
} DFMESSAGE;
typedef enum window_class {
#ifdef WATCOM
WATCOMFIX2 = -1,
#endif
#define ClassDef(c,b,p,a) c,
#include "classes.h"
CLASSCOUNT
} DFCLASS;
#endif

65
rosapps/dflat32/text.c Normal file
View file

@ -0,0 +1,65 @@
/* -------------- text.c -------------- */
#include "dflat.h"
int TextProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int i, len;
CTLWINDOW *ct = GetControl(wnd);
char *cp, *cp2 = ct->itext;
char *ptr;
switch (msg)
{
case SETFOCUS:
return TRUE;
case LEFT_BUTTON:
return TRUE;
case PAINT:
if (ct == NULL ||
ct->itext == NULL ||
GetText(wnd) != NULL)
break;
len = min(ct->dwnd.h, MsgHeight(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,SHORTCUTCHAR)) != NULL)
{
mlen += 3;
cp1++;
}
if (np != NULL)
*np = '\n';
txt = DFmalloc(mlen+1);
CopyCommand(txt, cp, FALSE, WndBackground(wnd));
txt[mlen] = '\0';
DfSendMessage(wnd, ADDTEXT, (PARAM)txt, 0);
if ((cp = strchr(cp, '\n')) != NULL)
cp++;
free(txt);
}
free (ptr);
break;
default:
break;
}
return BaseWndProc(TEXT, wnd, msg, p1, p2);
}
/* EOF */

874
rosapps/dflat32/textbox.c Normal file
View file

@ -0,0 +1,874 @@
/* ------------- 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 VSliding;
BOOL HSliding;
/* ------------ 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");
BuildTextPointers(wnd);
return TRUE;
}
return FALSE;
}
/* ------------ DELETETEXT Message -------------- */
static void DeleteTextMsg(DFWINDOW wnd, int lno)
{
char *cp1 = TextLine(wnd, lno);
--wnd->wlines;
if (lno == wnd->wlines)
*cp1 = '\0';
else {
char *cp2 = TextLine(wnd, lno+1);
memmove(cp1, cp2, strlen(cp2)+1);
}
BuildTextPointers(wnd);
}
/* ------------ INSERTTEXT Message -------------- */
static void InsertTextMsg(DFWINDOW wnd, char *txt, int lno)
{
if (AddTextMsg(wnd, txt)) {
int len = strlen(txt);
char *cp2 = TextLine(wnd, lno);
char *cp1 = cp2+len+1;
memmove(cp1, cp2, strlen(cp2)-len);
strcpy(cp2, txt);
*(cp2+len) = '\n';
BuildTextPointers(wnd);
}
}
/* ------------ SETTEXT Message -------------- */
static void SetTextMsg(DFWINDOW wnd, char *txt)
{
/* -- assign new text value to textbox buffer -- */
unsigned int len = strlen(txt)+1;
DfSendMessage(wnd, CLEARTEXT, 0, 0);
wnd->textlen = len;
wnd->text=DFrealloc(wnd->text, len+1);
wnd->text[len] = '\0';
strcpy(wnd->text, txt);
BuildTextPointers(wnd);
}
/* ------------ 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;
ClearTextBlock(wnd);
ClearTextPointers(wnd);
}
/* ------------ KEYBOARD Message -------------- */
static int KeyboardMsg(DFWINDOW wnd, PARAM p1)
{
switch ((int) p1) {
case UP:
return DfSendMessage(wnd,SCROLL,FALSE,0);
case DN:
return DfSendMessage(wnd,SCROLL,TRUE,0);
case FWD:
return DfSendMessage(wnd,HORIZSCROLL,TRUE,0);
case BS:
return DfSendMessage(wnd,HORIZSCROLL,FALSE,0);
case PGUP:
return DfSendMessage(wnd,SCROLLPAGE,FALSE,0);
case PGDN:
return DfSendMessage(wnd,SCROLLPAGE,TRUE,0);
case CTRL_PGUP:
return DfSendMessage(wnd,HORIZPAGE,FALSE,0);
case CTRL_PGDN:
return DfSendMessage(wnd,HORIZPAGE,TRUE,0);
case HOME:
return DfSendMessage(wnd,SCROLLDOC,TRUE,0);
case END:
return DfSendMessage(wnd,SCROLLDOC,FALSE,0);
default:
break;
}
return FALSE;
}
/* ------------ LEFT_BUTTON Message -------------- */
static int LeftButtonMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int mx = (int) p1 - GetLeft(wnd);
int my = (int) p2 - GetTop(wnd);
if (TestAttribute(wnd, VSCROLLBAR) &&
mx == WindowWidth(wnd)-1) {
/* -------- in the right border ------- */
if (my == 0 || my == ClientHeight(wnd)+1)
/* --- above or below the scroll bar --- */
return FALSE;
if (my == 1)
/* -------- top scroll button --------- */
return DfSendMessage(wnd, SCROLL, FALSE, 0);
if (my == ClientHeight(wnd))
/* -------- bottom scroll button --------- */
return DfSendMessage(wnd, SCROLL, TRUE, 0);
/* ---------- in the scroll bar ----------- */
if (!VSliding && my-1 == wnd->VScrollBox) {
DFRECT rc;
VSliding = TRUE;
rc.lf = rc.rt = GetRight(wnd);
rc.tp = GetTop(wnd)+2;
rc.bt = GetBottom(wnd)-2;
return DfSendMessage(NULL, MOUSE_TRAVEL,
(PARAM) &rc, 0);
}
if (my-1 < wnd->VScrollBox)
return DfSendMessage(wnd,SCROLLPAGE,FALSE,0);
if (my-1 > wnd->VScrollBox)
return DfSendMessage(wnd,SCROLLPAGE,TRUE,0);
}
if (TestAttribute(wnd, HSCROLLBAR) &&
my == WindowHeight(wnd)-1) {
/* -------- in the bottom border ------- */
if (mx == 0 || my == ClientWidth(wnd)+1)
/* ------ outside the scroll bar ---- */
return FALSE;
if (mx == 1)
return DfSendMessage(wnd, HORIZSCROLL,FALSE,0);
if (mx == WindowWidth(wnd)-2)
return DfSendMessage(wnd, HORIZSCROLL,TRUE,0);
if (!HSliding && mx-1 == wnd->HScrollBox) {
/* --- hit the scroll box --- */
DFRECT rc;
rc.lf = GetLeft(wnd)+2;
rc.rt = GetRight(wnd)-2;
rc.tp = rc.bt = GetBottom(wnd);
/* - keep the mouse in the scroll bar - */
DfSendMessage(NULL,MOUSE_TRAVEL,(PARAM)&rc,0);
HSliding = TRUE;
return TRUE;
}
if (mx-1 < wnd->HScrollBox)
return DfSendMessage(wnd,HORIZPAGE,FALSE,0);
if (mx-1 > wnd->HScrollBox)
return DfSendMessage(wnd,HORIZPAGE,TRUE,0);
}
return FALSE;
}
/* ------------ MOUSE_MOVED Message -------------- */
static BOOL MouseMovedMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
int mx = (int) p1 - GetLeft(wnd);
int my = (int) p2 - GetTop(wnd);
if (VSliding) {
/* ---- dragging the vertical scroll box --- */
if (my-1 != wnd->VScrollBox) {
foreground = FrameForeground(wnd);
background = FrameBackground(wnd);
wputch(wnd, SCROLLBARCHAR, WindowWidth(wnd)-1,
wnd->VScrollBox+1);
wnd->VScrollBox = my-1;
wputch(wnd, SCROLLBOXCHAR, WindowWidth(wnd)-1,
my);
}
return TRUE;
}
if (HSliding) {
/* --- dragging the horizontal scroll box --- */
if (mx-1 != wnd->HScrollBox) {
foreground = FrameForeground(wnd);
background = FrameBackground(wnd);
wputch(wnd, SCROLLBARCHAR, wnd->HScrollBox+1,
WindowHeight(wnd)-1);
wnd->HScrollBox = mx-1;
wputch(wnd, SCROLLBOXCHAR, mx, WindowHeight(wnd)-1);
}
return TRUE;
}
return FALSE;
}
/* ------------ BUTTON_RELEASED Message -------------- */
static void ButtonReleasedMsg(DFWINDOW wnd)
{
if (HSliding || VSliding) {
/* release the mouse ouside the scroll bar */
DfSendMessage(NULL, MOUSE_TRAVEL, 0, 0);
VSliding ? ComputeWindowTop(wnd):ComputeWindowLeft(wnd);
DfSendMessage(wnd, PAINT, 0, 0);
DfSendMessage(wnd, KEYBOARD_CURSOR, 0, 0);
VSliding = HSliding = FALSE;
}
}
/* ------------ SCROLL Message -------------- */
static BOOL ScrollMsg(DFWINDOW wnd, PARAM p1)
{
/* ---- vertical scroll one line ---- */
if (p1) {
/* ----- scroll one line up ----- */
if (wnd->wtop+ClientHeight(wnd) >= wnd->wlines)
return FALSE;
wnd->wtop++;
}
else {
/* ----- scroll one line down ----- */
if (wnd->wtop == 0)
return FALSE;
--wnd->wtop;
}
if (isVisible(wnd)) {
DFRECT rc;
rc = ClipRectangle(wnd, ClientRect(wnd));
if (ValidRect(rc)) {
/* ---- scroll the window ----- */
if (wnd != inFocus)
DfSendMessage(wnd, PAINT, 0, 0);
else {
scroll_window(wnd, rc, (int)p1);
if (!(int)p1)
/* -- write top line (down) -- */
WriteTextLine(wnd,NULL,wnd->wtop,FALSE);
else {
/* -- write bottom line (up) -- */
int y=RectBottom(rc)-GetClientTop(wnd);
WriteTextLine(wnd, NULL,
wnd->wtop+y, FALSE);
}
}
}
/* ---- reset the scroll box ---- */
if (TestAttribute(wnd, VSCROLLBAR)) {
int vscrollbox = ComputeVScrollBox(wnd);
if (vscrollbox != wnd->VScrollBox)
MoveScrollBox(wnd, vscrollbox);
}
}
return TRUE;
}
/* ------------ HORIZSCROLL Message -------------- */
static BOOL HorizScrollMsg(DFWINDOW wnd, PARAM p1)
{
/* --- horizontal scroll one column --- */
if (p1) {
/* --- scroll left --- */
if (wnd->wleft + ClientWidth(wnd)-1 >= wnd->textwidth)
return FALSE;
wnd->wleft++;
}
else {
/* --- scroll right --- */
if (wnd->wleft == 0)
return FALSE;
--wnd->wleft;
}
DfSendMessage(wnd, PAINT, 0, 0);
return TRUE;
}
/* ------------ SCROLLPAGE Message -------------- */
static void ScrollPageMsg(DFWINDOW wnd, PARAM p1)
{
/* --- vertical scroll one page --- */
if ((int) p1 == FALSE) {
/* ---- page up ---- */
if (wnd->wtop)
wnd->wtop -= ClientHeight(wnd);
}
else {
/* ---- page down ---- */
if (wnd->wtop+ClientHeight(wnd) < wnd->wlines) {
wnd->wtop += ClientHeight(wnd);
if (wnd->wtop>wnd->wlines-ClientHeight(wnd))
wnd->wtop=wnd->wlines-ClientHeight(wnd);
}
}
if (wnd->wtop < 0)
wnd->wtop = 0;
DfSendMessage(wnd, PAINT, 0, 0);
}
/* ------------ HORIZSCROLLPAGE Message -------------- */
static void HorizScrollPageMsg(DFWINDOW wnd, PARAM p1)
{
/* --- horizontal scroll one page --- */
if ((int) p1 == FALSE)
/* ---- page left ----- */
wnd->wleft -= ClientWidth(wnd);
else {
/* ---- page right ----- */
wnd->wleft += ClientWidth(wnd);
if (wnd->wleft > wnd->textwidth-ClientWidth(wnd))
wnd->wleft = wnd->textwidth-ClientWidth(wnd);
}
if (wnd->wleft < 0)
wnd->wleft = 0;
DfSendMessage(wnd, PAINT, 0, 0);
}
/* ------------ SCROLLDOC Message -------------- */
static void ScrollDocMsg(DFWINDOW wnd, PARAM p1)
{
/* --- scroll to beginning or end of document --- */
if ((int) p1)
wnd->wtop = wnd->wleft = 0;
else if (wnd->wtop+ClientHeight(wnd) < wnd->wlines){
wnd->wtop = wnd->wlines-ClientHeight(wnd);
wnd->wleft = 0;
}
DfSendMessage(wnd, PAINT, 0, 0);
}
/* ------------ PAINT Message -------------- */
static void PaintMsg(DFWINDOW wnd, PARAM p1, PARAM p2)
{
/* ------ paint the client area ----- */
DFRECT rc, rcc;
int y;
char blankline[201];
/* ----- build the rectangle to paint ----- */
if ((DFRECT *)p1 == NULL)
rc=RelativeWindowRect(wnd, WindowRect(wnd));
else
rc= *(DFRECT *)p1;
if (TestAttribute(wnd, HASBORDER) &&
RectRight(rc) >= WindowWidth(wnd)-1) {
if (RectLeft(rc) >= WindowWidth(wnd)-1)
return;
RectRight(rc) = WindowWidth(wnd)-2;
}
rcc = AdjustRectangle(wnd, rc);
if (!p2 && wnd != inFocus)
ClipString++;
/* ----- blank line for padding ----- */
memset(blankline, ' ', SCREENWIDTH);
blankline[RectRight(rcc)+1] = '\0';
/* ------- each line within rectangle ------ */
for (y = RectTop(rc); y <= RectBottom(rc); y++){
int yy;
/* ---- test outside of Client area ---- */
if (TestAttribute(wnd,
HASBORDER | HASTITLEBAR)) {
if (y < TopBorderAdj(wnd))
continue;
if (y > WindowHeight(wnd)-2)
continue;
}
yy = y-TopBorderAdj(wnd);
if (yy < wnd->wlines-wnd->wtop)
/* ---- paint a text line ---- */
WriteTextLine(wnd, &rc,
yy+wnd->wtop, FALSE);
else {
/* ---- paint a blank line ---- */
SetStandardColor(wnd);
writeline(wnd, blankline+RectLeft(rcc),
RectLeft(rcc)+BorderAdj(wnd), y, FALSE);
}
}
/* ------- position the scroll box ------- */
if (TestAttribute(wnd, VSCROLLBAR|HSCROLLBAR)) {
int hscrollbox = ComputeHScrollBox(wnd);
int vscrollbox = ComputeVScrollBox(wnd);
if (hscrollbox != wnd->HScrollBox ||
vscrollbox != wnd->VScrollBox) {
wnd->HScrollBox = hscrollbox;
wnd->VScrollBox = vscrollbox;
DfSendMessage(wnd, BORDER, p1, 0);
}
}
if (!p2 && wnd != inFocus)
--ClipString;
}
/* ------------ CLOSE_WINDOW Message -------------- */
static void CloseWindowMsg(DFWINDOW wnd)
{
DfSendMessage(wnd, CLEARTEXT, 0, 0);
if (wnd->TextPointers != NULL) {
free(wnd->TextPointers);
wnd->TextPointers = NULL;
}
}
/* ----------- TEXTBOX Message-processing Module ----------- */
int TextBoxProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
switch (msg) {
case CREATE_WINDOW:
wnd->HScrollBox = wnd->VScrollBox = 1;
ClearTextPointers(wnd);
break;
case ADDTEXT:
return AddTextMsg(wnd, (char *) p1);
case DELETETEXT:
DeleteTextMsg(wnd, (int) p1);
return TRUE;
case INSERTTEXT:
InsertTextMsg(wnd, (char *) p1, (int) p2);
return TRUE;
case SETTEXT:
SetTextMsg(wnd, (char *) p1);
return TRUE;
case CLEARTEXT:
ClearTextMsg(wnd);
break;
case KEYBOARD:
if (WindowMoving || WindowSizing)
break;
if (KeyboardMsg(wnd, p1))
return TRUE;
break;
case LEFT_BUTTON:
if (WindowSizing || WindowMoving)
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 SCROLL:
return ScrollMsg(wnd, p1);
case HORIZSCROLL:
return HorizScrollMsg(wnd, p1);
case SCROLLPAGE:
ScrollPageMsg(wnd, p1);
return TRUE;
case HORIZPAGE:
HorizScrollPageMsg(wnd, p1);
return TRUE;
case SCROLLDOC:
ScrollDocMsg(wnd, p1);
return TRUE;
case PAINT:
if (isVisible(wnd))
{
PaintMsg(wnd, p1, p2);
return FALSE;
}
break;
case CLOSE_WINDOW:
CloseWindowMsg(wnd);
break;
default:
break;
}
return BaseWndProc(TEXTBOX, wnd, msg, p1, p2);
}
/* ------ compute the vertical scroll box position from
the text pointers --------- */
static int ComputeVScrollBox(DFWINDOW wnd)
{
int pagelen = wnd->wlines - ClientHeight(wnd);
int barlen = ClientHeight(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 > ClientHeight(wnd)-2 ||
wnd->wtop + ClientHeight(wnd) >= wnd->wlines)
vscrollbox = ClientHeight(wnd)-2;
}
return vscrollbox;
}
/* ---- compute top text line from scroll box position ---- */
static void ComputeWindowTop(DFWINDOW wnd)
{
int pagelen = wnd->wlines - ClientHeight(wnd);
if (wnd->VScrollBox == 0)
wnd->wtop = 0;
else if (wnd->VScrollBox == ClientHeight(wnd)-2)
wnd->wtop = pagelen;
else {
int barlen = ClientHeight(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 + ClientHeight(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 - ClientWidth(wnd);
int barlen = ClientWidth(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 > ClientWidth(wnd)-2 ||
wnd->wleft + ClientWidth(wnd) >= wnd->textwidth)
hscrollbox = ClientWidth(wnd)-2;
}
return hscrollbox;
}
/* ---- compute left column from scroll box position ---- */
static void ComputeWindowLeft(DFWINDOW wnd)
{
int pagewidth = wnd->textwidth - ClientWidth(wnd);
if (wnd->HScrollBox == 0)
wnd->wleft = 0;
else if (wnd->HScrollBox == ClientWidth(wnd)-2)
wnd->wleft = pagewidth;
else {
int barlen = ClientWidth(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 + ClientWidth(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 = TextLine(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 WriteTextLine(DFWINDOW wnd, DFRECT *rcc, int y, BOOL reverse)
{
int len = 0;
int dif = 0;
unsigned char line[200];
DFRECT rc;
unsigned char *lp, *svlp;
int lnlen;
int i;
BOOL trunc = FALSE;
/* ------ make sure y is inside the window ----- */
if (y < wnd->wtop || y >= wnd->wtop+ClientHeight(wnd))
return;
/* ---- build the retangle within which can write ---- */
if (rcc == NULL) {
rc = RelativeWindowRect(wnd, WindowRect(wnd));
if (TestAttribute(wnd, HASBORDER) &&
RectRight(rc) >= WindowWidth(wnd)-1)
RectRight(rc) = WindowWidth(wnd)-2;
}
else
rc = *rcc;
/* ----- make sure rectangle is within window ------ */
if (RectLeft(rc) >= WindowWidth(wnd)-1)
return;
if (RectRight(rc) == 0)
return;
rc = AdjustRectangle(wnd, rc);
if (y-wnd->wtop<RectTop(rc) || y-wnd->wtop>RectBottom(rc))
return;
/* --- get the text and length of the text line --- */
lp = svlp = GetTextLine(wnd, y);
if (svlp == NULL)
return;
lnlen = LineLength(lp);
/* -------- insert block color change controls ------- */
if (TextBlockMarked(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 color token ----- */
memmove(lp+blkend+1,lp+blkend,strlen(lp+blkend)+1);
lp[blkend] = RESETCOLOR;
/* ----- insert the change color token ----- */
memmove(lp+blkbeg+3,lp+blkbeg,strlen(lp+blkbeg)+1);
lp[blkbeg] = CHANGECOLOR;
/* ----- insert the color tokens ----- */
SetReverseColor(wnd);
lp[blkbeg+1] = foreground | 0x80;
lp[blkbeg+2] = background | 0x80;
lnlen += 4;
}
}
/* - make sure left margin doesn't overlap color change - */
for (i = 0; i < wnd->wleft+3; i++) {
if (*(lp+i) == '\0')
break;
if (*(unsigned char *)(lp + i) == RESETCOLOR)
break;
}
if (*(lp+i) && i < wnd->wleft+3) {
if (wnd->wleft+4 > lnlen)
trunc = TRUE;
else
lp += 4;
}
else {
/* --- it does, shift the color change over --- */
for (i = 0; i < wnd->wleft; i++) {
if (*(lp+i) == '\0')
break;
if (*(unsigned char *)(lp + i) == 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 > RectLeft(rc)) {
/* ---- the line exceeds the rectangle ---- */
int ct = RectLeft(rc);
char *initlp = lp;
/* --- point to end of clipped line --- */
while (ct) {
if (*(unsigned char *)lp == CHANGECOLOR)
lp += 3;
else if (*(unsigned char *)lp == RESETCOLOR)
lp++;
else
lp++, --ct;
}
if (RectLeft(rc)) {
char *lpp = lp;
while (*lpp) {
if (*(unsigned char*)lpp==CHANGECOLOR)
break;
if (*(unsigned char*)lpp==RESETCOLOR) {
lpp = lp;
while (lpp >= initlp) {
if (*(unsigned char *)lpp ==
CHANGECOLOR) {
lp -= 3;
memmove(lp,lpp,3);
break;
}
--lpp;
}
break;
}
lpp++;
}
}
lnlen = LineLength(lp);
len = min(lnlen, RectWidth(rc));
dif = strlen(lp) - lnlen;
len += dif;
if (len > 0)
strncpy(line, lp, len);
}
}
/* -------- pad the line --------- */
while (len < RectWidth(rc)+dif)
line[len++] = ' ';
line[len] = '\0';
dif = 0;
/* ------ establish the line's main color ----- */
if (reverse) {
char *cp = line;
SetReverseColor(wnd);
while ((cp = strchr(cp, CHANGECOLOR)) != NULL) {
cp += 2;
*cp++ = background | 0x80;
}
if (*(unsigned char *)line == CHANGECOLOR)
dif = 3;
}
else
SetStandardColor(wnd);
/* ------- display the line -------- */
writeline(wnd, line+dif,
RectLeft(rc)+BorderAdj(wnd),
y-wnd->wtop+TopBorderAdj(wnd), FALSE);
free(svlp);
}
void MarkTextBlock(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 ClearTextPointers(DFWINDOW wnd)
{
wnd->TextPointers = DFrealloc(wnd->TextPointers, sizeof(int));
*(wnd->TextPointers) = 0;
}
#define INITLINES 100
/* ---- build array of pointers to text lines ---- */
void BuildTextPointers(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)
{
foreground = FrameForeground(wnd);
background = FrameBackground(wnd);
wputch(wnd, SCROLLBARCHAR, WindowWidth(wnd)-1,
wnd->VScrollBox+1);
wputch(wnd, SCROLLBOXCHAR, WindowWidth(wnd)-1,
vscrollbox+1);
wnd->VScrollBox = vscrollbox;
}
int TextLineNumber(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 */

323
rosapps/dflat32/video.c Normal file
View file

@ -0,0 +1,323 @@
/* --------------------- video.c -------------------- */
#include "dflat.h"
#define clr(fg,bg) ((fg)|((bg)<<4))
BOOL ClipString;
/* -- read a rectangle of video memory into a save buffer -- */
void GetVideo(DFRECT rc, PCHAR_INFO bf)
{
COORD Size;
COORD Pos;
SMALL_RECT Rect;
Size.X = RectRight(rc) - RectLeft(rc) + 1;
Size.Y = RectBottom(rc) - RectTop(rc) + 1;
Pos.X = 0;
Pos.Y = 0;
Rect.Left = RectLeft(rc);
Rect.Top = RectTop(rc);
Rect.Right = RectRight(rc);
Rect.Bottom = RectBottom(rc);
ReadConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
bf,
Size,
Pos,
&Rect);
}
/* -- write a rectangle of video memory from a save buffer -- */
void StoreVideo(DFRECT rc, PCHAR_INFO bf)
{
COORD Size;
COORD Pos;
SMALL_RECT Rect;
Size.X = RectRight(rc) - RectLeft(rc) + 1;
Size.Y = RectBottom(rc) - RectTop(rc) + 1;
Pos.X = 0;
Pos.Y = 0;
Rect.Left = RectLeft(rc);
Rect.Top = RectTop(rc);
Rect.Right = RectRight(rc);
Rect.Bottom = RectBottom(rc);
WriteConsoleOutput (GetStdHandle (STD_OUTPUT_HANDLE),
bf,
Size,
Pos,
&Rect);
}
/* -------- read a character of video memory ------- */
char GetVideoChar(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 PutVideoChar(int x, int y, int ch)
{
COORD pos;
DWORD dwWritten;
if (x < SCREENWIDTH && y < SCREENHEIGHT)
{
pos.X = x;
pos.Y = y;
WriteConsoleOutputCharacter (GetStdHandle(STD_OUTPUT_HANDLE),
(char *)&ch,
1,
pos,
&dwWritten);
}
}
BOOL CharInView(DFWINDOW wnd, int x, int y)
{
DFWINDOW nwnd = NextWindow(wnd);
DFWINDOW pwnd;
DFRECT rc;
int x1 = GetLeft(wnd)+x;
int y1 = GetTop(wnd)+y;
if (!TestAttribute(wnd, VISIBLE))
return FALSE;
if (!TestAttribute(wnd, NOCLIP))
{
DFWINDOW wnd1 = GetParent(wnd);
while (wnd1 != NULL)
{
/* clip character to parent's borders */
if (!TestAttribute(wnd1, VISIBLE))
return FALSE;
if (!InsideRect(x1, y1, ClientRect(wnd1)))
return FALSE;
wnd1 = GetParent(wnd1);
}
}
while (nwnd != NULL)
{
if (!isHidden(nwnd) && !isAncestor(wnd, nwnd))
{
rc = WindowRect(nwnd);
if (TestAttribute(nwnd, SHADOW))
{
RectBottom(rc)++;
RectRight(rc)++;
}
if (!TestAttribute(nwnd, NOCLIP))
{
pwnd = nwnd;
while (GetParent(pwnd))
{
pwnd = GetParent(pwnd);
rc = subRectangle(rc, ClientRect(pwnd));
}
}
if (InsideRect(x1,y1,rc))
return FALSE;
}
nwnd = NextWindow(nwnd);
}
return (x1 < SCREENWIDTH && y1 < SCREENHEIGHT);
}
/* -------- write a character to a window ------- */
void wputch(DFWINDOW wnd, int c, int x, int y)
{
if (CharInView(wnd, x, y))
{
DWORD dwWritten;
COORD pos;
WORD Attr;
pos.X = GetLeft(wnd)+x;
pos.Y = GetTop(wnd)+y;
Attr = clr(foreground, background);
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 wputs(DFWINDOW wnd, void *s, int x, int y)
{
int x1 = GetLeft(wnd)+x;
int x2 = x1;
int y1 = GetTop(wnd)+y;
if (x1 < SCREENWIDTH && y1 < SCREENHEIGHT && isVisible(wnd))
{
char ln[200];
WORD attr[200];
char *cp = ln;
WORD *ap = attr;
unsigned char *str = s;
int fg = foreground;
int bg = background;
int len;
int off = 0;
while (*str)
{
if (*str == CHANGECOLOR)
{
str++;
foreground = (*str++) & 0x7f;
background = (*str++) & 0x7f;
continue;
}
if (*str == RESETCOLOR)
{
foreground = fg & 0x7f;
background = bg & 0x7f;
str++;
continue;
}
*cp = (*str & 255);
*ap = (WORD)clr(foreground, background);
// *cp1 = (*str & 255) | (clr(foreground, background) << 8);
// if (ClipString)
// if (!CharInView(wnd, x, y))
// *cp1 = peek(video_address, vad(x2,y1));
cp++;
ap++;
str++;
x++;
x2++;
}
foreground = fg;
background = bg;
len = (int)(cp-ln);
if (x1+len > SCREENWIDTH)
len = SCREENWIDTH-x1;
if (!ClipString && !TestAttribute(wnd, NOCLIP))
{
/* -- clip the line to within ancestor windows -- */
DFRECT rc = WindowRect(wnd);
DFWINDOW nwnd = GetParent(wnd);
while (len > 0 && nwnd != NULL)
{
if (!isVisible(nwnd))
{
len = 0;
break;
}
rc = subRectangle(rc, ClientRect(nwnd));
nwnd = GetParent(nwnd);
}
while (len > 0 && !InsideRect(x1+off,y1,rc))
{
off++;
--len;
}
if (len > 0)
{
x2 = x1+len-1;
while (len && !InsideRect(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 scroll_window(DFWINDOW wnd, DFRECT rc, int d)
{
if (RectTop(rc) != RectBottom(rc))
{
CHAR_INFO ciFill;
SMALL_RECT rcScroll;
SMALL_RECT rcClip;
COORD pos;
ciFill.Attributes = clr(WndForeground(wnd),WndBackground(wnd));
ciFill.Char.AsciiChar = ' ';
rcScroll.Left = RectLeft(rc);
rcScroll.Right = RectRight(rc);
rcScroll.Top = RectTop(rc);
rcScroll.Bottom = RectBottom(rc);
rcClip = rcScroll;
pos.X = RectLeft(rc);
if (d == 0)
{
/* scroll 1 line down */
pos.Y = RectTop(rc)+1;
}
else
{
/* scroll 1 line up */
pos.Y = RectTop(rc)-1;
}
ScrollConsoleScreenBuffer (GetStdHandle(STD_OUTPUT_HANDLE),
&rcScroll,
&rcClip,
pos,
&ciFill);
}
}
/* EOF */

18
rosapps/dflat32/video.h Normal file
View file

@ -0,0 +1,18 @@
/* ---------------- video.h ----------------- */
#ifndef VIDEO_H
#define VIDEO_H
#include "rect.h"
void GetVideo(DFRECT, PCHAR_INFO);
void StoreVideo(DFRECT, PCHAR_INFO);
void wputch(DFWINDOW, int, int, int);
char GetVideoChar(int, int);
void PutVideoChar(int, int, int);
void wputs(DFWINDOW, void *, int, int);
void scroll_window(DFWINDOW, DFRECT, int);
#define videochar(x,y) (GetVideoChar(x,y) & 0xFF)
#endif

58
rosapps/dflat32/watch.c Normal file
View file

@ -0,0 +1,58 @@
/* ----------- watch.c ----------- */
#include "dflat.h"
int WatchIconProc(DFWINDOW wnd, DFMESSAGE msg, PARAM p1, PARAM p2)
{
int rtn;
switch (msg) {
case CREATE_WINDOW:
rtn = DefaultWndProc(wnd, msg, p1, p2);
DfSendMessage(wnd, CAPTURE_MOUSE, 0, 0);
DfSendMessage(wnd, CAPTURE_KEYBOARD, 0, 0);
return rtn;
case PAINT:
SetStandardColor(wnd);
writeline(wnd, " R ", 1, 1, FALSE);
return TRUE;
case BORDER:
rtn = DefaultWndProc(wnd, msg, p1, p2);
writeline(wnd, "Í", 2, 0, FALSE);
return rtn;
case MOUSE_MOVED:
DfSendMessage(wnd, DFM_HIDE_WINDOW, 0, 0);
DfSendMessage(wnd, MOVE, p1, p2);
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
return TRUE;
case CLOSE_WINDOW:
DfSendMessage(wnd, RELEASE_MOUSE, 0, 0);
DfSendMessage(wnd, RELEASE_KEYBOARD, 0, 0);
break;
default:
break;
}
return DefaultWndProc(wnd, msg, p1, p2);
}
DFWINDOW WatchIcon(void)
{
int mx, my;
DFWINDOW wnd;
/* this won't work !! */
// DfSendMessage(NULL, DFM_CURRENT_MOUSE_CURSOR,
// (PARAM) &mx, (PARAM) &my);
mx = 0;//SCREENWIDTH / 2;
mx = 0;//SCREENHEIGHT / 2;
wnd = DfCreateWindow(
BOX,
NULL,
mx, my, 3, 5,
NULL,NULL,
WatchIconProc,
VISIBLE | HASBORDER | SHADOW | SAVESELF);
return wnd;
}
/* EOF */

519
rosapps/dflat32/window.c Normal file
View file

@ -0,0 +1,519 @@
/* ---------- window.c ------------- */
#include "dflat.h"
DFWINDOW inFocus = NULL;
int foreground, background; /* current video colors */
static void TopLine(DFWINDOW, int, DFRECT);
/* --------- create a window ------------ */
DFWINDOW DfCreateWindow(
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 window *,enum messages,PARAM,PARAM),
int attrib) /* window attribute */
{
DFWINDOW wnd = DFcalloc(1, sizeof(struct window));
if (wnd != NULL) {
int base;
/* ----- height, width = -1: fill the screen ------- */
if (height == -1)
height = SCREENHEIGHT;
if (width == -1)
width = SCREENWIDTH;
/* ----- coordinates -1, -1 = center the window ---- */
if (left == -1)
wnd->rc.lf = (SCREENWIDTH-width)/2;
else
wnd->rc.lf = left;
if (top == -1)
wnd->rc.tp = (SCREENHEIGHT-height)/2;
else
wnd->rc.tp = top;
wnd->attrib = attrib;
if (ttl != NULL)
AddAttribute(wnd, HASTITLEBAR);
if (wndproc == NULL)
wnd->wndproc = classdefs[class].wndproc;
else
wnd->wndproc = wndproc;
/* ---- derive attributes of base classes ---- */
base = class;
while (base != -1) {
AddAttribute(wnd, classdefs[base].attrib);
base = classdefs[base].base;
}
if (parent)
{
if (!TestAttribute(wnd, NOCLIP))
{
/* -- keep upper left within borders of parent - */
wnd->rc.lf = max(wnd->rc.lf,GetClientLeft(parent));
wnd->rc.tp = max(wnd->rc.tp,GetClientTop(parent));
}
}
else
parent = ApplicationWindow;
wnd->class = class;
wnd->extension = extension;
wnd->rc.rt = GetLeft(wnd)+width-1;
wnd->rc.bt = GetTop(wnd)+height-1;
wnd->ht = height;
wnd->wd = width;
if (ttl != NULL)
InsertTitle(wnd, ttl);
wnd->parent = parent;
wnd->oldcondition = wnd->condition = ISRESTORED;
wnd->RestoredRC = wnd->rc;
InitWindowColors(wnd);
DfSendMessage(wnd, CREATE_WINDOW, 0, 0);
if (isVisible(wnd))
DfSendMessage(wnd, SHOW_WINDOW, 0, 0);
}
return wnd;
}
/* -------- add a title to a window --------- */
void AddTitle(DFWINDOW wnd, char *ttl)
{
InsertTitle(wnd, ttl);
DfSendMessage(wnd, BORDER, 0, 0);
}
/* ----- insert a title into a window ---------- */
void InsertTitle(DFWINDOW wnd, char *ttl)
{
wnd->title=DFrealloc(wnd->title,strlen(ttl)+1);
strcpy(wnd->title, ttl);
}
static unsigned char line[300];
/* ------ write a line to video window client area ------ */
void writeline(DFWINDOW wnd, char *str, int x, int y, BOOL pad)
{
char *cp;
int len;
int dif;
char wline[200];
memset(wline, 0, 200);
len = LineLength(str);
dif = strlen(str) - len;
strncpy(wline, str, ClientWidth(wnd) + dif);
if (pad) {
cp = wline+strlen(wline);
while (len++ < ClientWidth(wnd)-x)
*cp++ = ' ';
}
wputs(wnd, wline, x, y);
}
DFRECT AdjustRectangle(DFWINDOW wnd, DFRECT rc)
{
/* -------- adjust the rectangle ------- */
if (TestAttribute(wnd, HASBORDER)) {
if (RectLeft(rc) == 0)
--rc.rt;
else if (RectLeft(rc) < RectRight(rc) &&
RectLeft(rc) < WindowWidth(wnd)+1)
--rc.lf;
}
if (TestAttribute(wnd, HASBORDER | HASTITLEBAR)) {
if (RectTop(rc) == 0)
--rc.bt;
else if (RectTop(rc) < RectBottom(rc) &&
RectTop(rc) < WindowHeight(wnd)+1)
--rc.tp;
}
RectRight(rc) = max(RectLeft(rc),
min(RectRight(rc),WindowWidth(wnd)));
RectBottom(rc) = max(RectTop(rc),
min(RectBottom(rc),WindowHeight(wnd)));
return rc;
}
/* -------- display a window's title --------- */
void DisplayTitle(DFWINDOW wnd, DFRECT *rcc)
{
if (GetTitle(wnd) != NULL)
{
int tlen = min((int)strlen(GetTitle(wnd)), (int)WindowWidth(wnd)-2);
int tend = WindowWidth(wnd)-3-BorderAdj(wnd);
DFRECT rc;
if (rcc == NULL)
rc = RelativeWindowRect(wnd, WindowRect(wnd));
else
rc = *rcc;
rc = AdjustRectangle(wnd, rc);
if (DfSendMessage(wnd, TITLE, (PARAM) rcc, 0))
{
if (wnd == inFocus)
{
foreground = cfg.clr[TITLEBAR] [HILITE_COLOR] [FG];
background = cfg.clr[TITLEBAR] [HILITE_COLOR] [BG];
}
else
{
foreground = cfg.clr[TITLEBAR] [STD_COLOR] [FG];
background = cfg.clr[TITLEBAR] [STD_COLOR] [BG];
}
memset(line,' ',WindowWidth(wnd));
#ifdef INCLUDE_MINIMIZE
if (wnd->condition != ISMINIMIZED)
#endif
strncpy (line + ((WindowWidth(wnd)-2 - tlen) / 2),
wnd->title, tlen);
if (TestAttribute(wnd, CONTROLBOX))
line[2-BorderAdj(wnd)] = CONTROLBOXCHAR;
if (TestAttribute(wnd, MINMAXBOX))
{
switch (wnd->condition)
{
case ISRESTORED:
#ifdef INCLUDE_MAXIMIZE
line[tend+1] = MAXPOINTER;
#endif
#ifdef INCLUDE_MINIMIZE
line[tend] = MINPOINTER;
#endif
break;
#ifdef INCLUDE_MINIMIZE
case ISMINIMIZED:
line[tend+1] = MAXPOINTER;
break;
#endif
#ifdef INCLUDE_MAXIMIZE
case ISMAXIMIZED:
#ifdef INCLUDE_MINIMIZE
line[tend] = MINPOINTER;
#endif
#ifdef INCLUDE_RESTORE
line[tend+1] = RESTOREPOINTER;
#endif
break;
#endif
default:
break;
}
}
line[RectRight(rc)+1] = line[tend+3] = '\0';
if (wnd != inFocus)
ClipString++;
writeline(wnd, line+RectLeft(rc),
RectLeft(rc)+BorderAdj(wnd),
0,
FALSE);
ClipString = 0;
}
}
}
/* --- display right border shadow character of a window --- */
static void shadow_char(DFWINDOW wnd, int y)
{
int fg = foreground;
int bg = background;
int x = WindowWidth(wnd);
char c = videochar(GetLeft(wnd)+x, GetTop(wnd)+y);
if (TestAttribute(wnd, SHADOW) == 0)
return;
foreground = DARKGRAY;
background = BLACK;
wputch(wnd, c, x, y);
foreground = fg;
background = bg;
}
/* --- display the bottom border shadow line for a window -- */
static void shadowline(DFWINDOW wnd, DFRECT rc)
{
int i;
int y = GetBottom(wnd)+1;
int fg = foreground;
int bg = background;
if ((TestAttribute(wnd, SHADOW)) == 0)
return;
for (i = 0; i < WindowWidth(wnd)+1; i++)
line[i] = videochar(GetLeft(wnd)+i, y);
line[i] = '\0';
foreground = DARKGRAY;
background = BLACK;
line[RectRight(rc)+1] = '\0';
if (RectLeft(rc) == 0)
rc.lf++;
ClipString++;
wputs(wnd, line+RectLeft(rc), RectLeft(rc),
WindowHeight(wnd));
--ClipString;
foreground = fg;
background = bg;
}
static DFRECT ParamRect(DFWINDOW wnd, DFRECT *rcc)
{
DFRECT rc;
if (rcc == NULL) {
rc = RelativeWindowRect(wnd, WindowRect(wnd));
if (TestAttribute(wnd, SHADOW)) {
rc.rt++;
rc.bt++;
}
}
else
rc = *rcc;
return rc;
}
void PaintShadow(DFWINDOW wnd)
{
int y;
DFRECT rc = ParamRect(wnd, NULL);
for (y = 1; y < WindowHeight(wnd); y++)
shadow_char(wnd, y);
shadowline(wnd, rc);
}
/* ------- display a window's border ----- */
void RepaintBorder(DFWINDOW wnd, DFRECT *rcc)
{
int y;
char lin, side, ne, nw, se, sw;
DFRECT rc, clrc;
if (!TestAttribute(wnd, HASBORDER))
return;
rc = ParamRect(wnd, rcc);
clrc = AdjustRectangle(wnd, rc);
if (wnd == inFocus) {
lin = FOCUS_LINE;
side = FOCUS_SIDE;
ne = FOCUS_NE;
nw = FOCUS_NW;
se = FOCUS_SE;
sw = FOCUS_SW;
}
else {
lin = LINE;
side = SIDE;
ne = NE;
nw = NW;
se = SE;
sw = SW;
}
line[WindowWidth(wnd)] = '\0';
/* ---------- window title ------------ */
if (TestAttribute(wnd, HASTITLEBAR))
if (RectTop(rc) == 0)
if (RectLeft(rc) < WindowWidth(wnd)-BorderAdj(wnd))
DisplayTitle(wnd, &rc);
foreground = FrameForeground(wnd);
background = FrameBackground(wnd);
/* -------- top frame corners --------- */
if (RectTop(rc) == 0) {
if (RectLeft(rc) == 0)
wputch(wnd, nw, 0, 0);
if (RectLeft(rc) < WindowWidth(wnd)) {
if (RectRight(rc) >= WindowWidth(wnd)-1)
wputch(wnd, ne, WindowWidth(wnd)-1, 0);
TopLine(wnd, lin, clrc);
}
}
/* ----------- window body ------------ */
for (y = RectTop(rc); y <= RectBottom(rc); y++) {
char ch;
if (y == 0 || y >= WindowHeight(wnd)-1)
continue;
if (RectLeft(rc) == 0)
wputch(wnd, side, 0, y);
if (RectLeft(rc) < WindowWidth(wnd) &&
RectRight(rc) >= WindowWidth(wnd)-1) {
if (TestAttribute(wnd, VSCROLLBAR))
ch = ( y == 1 ? UPSCROLLBOX :
y == WindowHeight(wnd)-2 ?
DOWNSCROLLBOX :
y-1 == wnd->VScrollBox ?
SCROLLBOXCHAR :
SCROLLBARCHAR );
else
ch = side;
wputch(wnd, ch, WindowWidth(wnd)-1, y);
}
if (RectRight(rc) == WindowWidth(wnd))
shadow_char(wnd, y);
}
if (RectTop(rc) <= WindowHeight(wnd)-1 &&
RectBottom(rc) >= WindowHeight(wnd)-1) {
/* -------- bottom frame corners ---------- */
if (RectLeft(rc) == 0)
wputch(wnd, sw, 0, WindowHeight(wnd)-1);
if (RectLeft(rc) < WindowWidth(wnd) &&
RectRight(rc) >= WindowWidth(wnd)-1)
wputch(wnd, se, WindowWidth(wnd)-1,
WindowHeight(wnd)-1);
if (wnd->StatusBar == NULL) {
/* ----------- bottom line ------------- */
memset(line,lin,WindowWidth(wnd)-1);
if (TestAttribute(wnd, HSCROLLBAR)) {
line[0] = LEFTSCROLLBOX;
line[WindowWidth(wnd)-3] = RIGHTSCROLLBOX;
memset(line+1, SCROLLBARCHAR, WindowWidth(wnd)-4);
line[wnd->HScrollBox] = SCROLLBOXCHAR;
}
line[WindowWidth(wnd)-2] = line[RectRight(rc)] = '\0';
if (RectLeft(rc) != RectRight(rc) ||
(RectLeft(rc) && RectLeft(rc) < WindowWidth(wnd)-1))
{
if (wnd != inFocus)
ClipString++;
writeline(wnd,
line+(RectLeft(clrc)),
RectLeft(clrc)+1,
WindowHeight(wnd)-1,
FALSE);
ClipString = 0;
}
}
if (RectRight(rc) == WindowWidth(wnd))
shadow_char(wnd, WindowHeight(wnd)-1);
}
if (RectBottom(rc) == WindowHeight(wnd))
/* ---------- bottom shadow ------------- */
shadowline(wnd, rc);
}
static void TopLine(DFWINDOW wnd, int lin, DFRECT rc)
{
if (TestAttribute(wnd, HASMENUBAR))
return;
if (TestAttribute(wnd, HASTITLEBAR) && GetTitle(wnd))
return;
if (RectLeft(rc) == 0) {
RectLeft(rc) += BorderAdj(wnd);
RectRight(rc) += BorderAdj(wnd);
}
if (RectRight(rc) < WindowWidth(wnd)-1)
RectRight(rc)++;
if (RectLeft(rc) < RectRight(rc)) {
/* ----------- top line ------------- */
memset(line,lin,WindowWidth(wnd)-1);
if (TestAttribute(wnd, CONTROLBOX)) {
strncpy(line+1, " ", 3);
*(line+2) = CONTROLBOXCHAR;
}
line[RectRight(rc)] = '\0';
writeline(wnd, line+RectLeft(rc),
RectLeft(rc), 0, FALSE);
}
}
/* ------ clear the data space of a window -------- */
void ClearWindow(DFWINDOW wnd, DFRECT *rcc, int clrchar)
{
if (isVisible(wnd)) {
int y;
DFRECT rc;
if (rcc == NULL)
rc = RelativeWindowRect(wnd, WindowRect(wnd));
else
rc = *rcc;
if (RectLeft(rc) == 0)
RectLeft(rc) = BorderAdj(wnd);
if (RectRight(rc) > WindowWidth(wnd)-1)
RectRight(rc) = WindowWidth(wnd)-1;
SetStandardColor(wnd);
memset(line, clrchar, sizeof line);
line[RectRight(rc)+1] = '\0';
for (y = RectTop(rc); y <= RectBottom(rc); y++)
{
if (y < TopBorderAdj(wnd) ||
y > ClientHeight(wnd)+
(TestAttribute(wnd, HASMENUBAR) ? 1 : 0))
continue;
writeline(wnd,
line+(RectLeft(rc)),
RectLeft(rc),
y,
FALSE);
}
}
}
/* ------ compute the logical line length of a window ------ */
int LineLength(char *ln)
{
int len = strlen(ln);
char *cp = ln;
while ((cp = strchr(cp, CHANGECOLOR)) != NULL)
{
cp++;
len -= 3;
}
cp = ln;
while ((cp = strchr(cp, RESETCOLOR)) != NULL)
{
cp++;
--len;
}
return len;
}
void InitWindowColors(DFWINDOW wnd)
{
int fbg,col;
int cls = GetClass(wnd);
/* window classes without assigned colors inherit parent's colors */
if (cfg.clr[cls][0][0] == 0xff && GetParent(wnd) != NULL)
cls = GetClass(GetParent(wnd));
/* ---------- set the colors ---------- */
for (fbg = 0; fbg < 2; fbg++)
for (col = 0; col < 4; col++)
wnd->WindowColors[col][fbg] = cfg.clr[cls][col][fbg];
}
void PutWindowChar(DFWINDOW wnd, char c, int x, int y)
{
if (x < ClientWidth(wnd) && y < ClientHeight(wnd))
wputch(wnd, c, x+BorderAdj(wnd), y+TopBorderAdj(wnd));
}
void PutWindowLine(DFWINDOW wnd, void *s, int x, int y)
{
int saved = FALSE, sv;
if (x < ClientWidth(wnd) && y < ClientHeight(wnd))
{
char *en = (char *)s+ClientWidth(wnd)-x;
if ((int)(strlen(s)+x) > (int)ClientWidth(wnd))
{
sv = *en;
*en = '\0';
saved = TRUE;
}
ClipString++;
wputs(wnd, s, x+BorderAdj(wnd), y+TopBorderAdj(wnd));
--ClipString;
if (saved)
*en = sv;
}
}
/* EOF */