bbs/deb-goldedplus
Archived
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Various fixes, mostly for win32 console

Browse Source
This commit is contained in:
Alexander S. Aganichev 2000-11-06 14:26:34 +00:00
parent c3374170a9
commit f0b3dea792
25 changed files with 473 additions and 625 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

25
docs/notework.txt
View File

@ -12,10 +12,33 @@ ______________________________________________________________________
Notes for GoldED+ 1.1.4.7, November xx 2000
______________________________________________________________________
- Cut-n-paste Unicode clipboard under Windows NT now properly filled
with Unicode version of control characters with the exception of CR,
LF, tabulation. It's fun to copy kludges from GoldED+ to WordPad ;-)
- Fixed lockout/crash on errorneous exit.
- Now if there is no address defined GoldED+ will exit with error at
startup rather than crashes later.
! Low-level screen handling routines rearranged. New implementation of
Win32 code included. This code should work well with Win2k raster
fonts without registry patching.
- Fixed incorrect timeslicing in DPMI32 version.
- BADAREA and DUPEAREA now "local"s rather then "echo"s for
fidoconfig.
! Changed keyboard handling under Win32, Win9x code seems to work
better. Shift-Tab no longer require additional keypress of Tab.
+ Address typed in name field now searched in addressbook as well.
- Cosmetic fix: MI_CHARSETAUTO now defaults to " Auto " (i.e. with two
spaces around).
+ Being annoyed by users who dislike read notework, added COLOR READER
! Being annoyed by users who dislike read notework, added COLOR READER
QUOTE1. COLOR READER QUOTE now set color for QUOTE1 and QUOTE2 as in
old good times. If QUOTE appears before QUOTE2 you may change
nothing in your config.

15
golded3/gedoss.cpp
View File

@ -176,10 +176,15 @@ void Cleanup(void) {
int smax = MinV((int)GLOG_STORELINES, LOG.storelines);
for(int s=0; s<smax; s++)
cout << LOG.storeline[s] << endl;
if(LOG.storelines > GLOG_STORELINES)
cout << "(See also " << CFG->logfile << ")" << endl;
if(errorlevel > EXIT_NONAME)
MakeNoise(SND_S_O_S);
if(CFG) {
if(LOG.storelines > GLOG_STORELINES)
cout << "(See also " << CFG->logfile << ")" << endl;
if(errorlevel > EXIT_NONAME)
MakeNoise(SND_S_O_S);
CfgReset();
}
#if defined(GUTLOS_FUNCS)
g_deinit_os();
@ -256,7 +261,7 @@ int ShellToDos(char* command, char* message, int cls, int cursor, int swap, int
#endif
// Store the screen
vatch* scrnbuf = vsave();
vsavebuf* scrnbuf = vsave();
// Store current drive/dir
Path orgdir;

6
golded3/geglob.cpp
View File

@ -86,7 +86,7 @@ bool ignore = false;
int cfgerrors = 0;
bool veryverbose = false;
bool shellvid = true;
word* oldscreen = NULL;
vsavebuf* oldscreen = NULL;
bool disablesound = false;
@ -170,7 +170,7 @@ Win gold_mono1[16] = {
// ------------------------------------------------------------------
// Deallocate CFG at exit
static void CfgReset(void) {
void CfgReset(void) {
throw_delete(QWK);
throw_delete(EDIT);
@ -188,8 +188,6 @@ static void CfgReset(void) {
void CfgInit() {
atexit(CfgReset);
CFG = new CfgGed;
throw_new(CFG);

2
golded3/geglob.h
View File

@ -133,7 +133,7 @@ extern bool ignore;
extern int cfgerrors;
extern bool veryverbose;
extern bool shellvid;
extern word* oldscreen;
extern vsavebuf* oldscreen;
extern int keysread;

46
golded3/geinit.cpp
View File

@ -374,51 +374,12 @@ static void w_brag() {
char buf[200];
char* logo[6];
#if defined(__USE_NCURSES__)
logo[0] = throw_strdup(" 88 88 88 ");
logo[1] = throw_strdup(" oooooo oooooo 88 oooo88 oooooo oooo88 o ");
logo[2] = throw_strdup(" 88 88 88 88 88 88 88 88oo88 88 88 o8o ");
logo[3] = throw_strdup(" 88oo88 88oo88 88 88oo88 88oooo 88oo88 8 ");
logo[4] = throw_strdup(" oo 88 ");
logo[5] = throw_strdup(" 88oooooo88 ");
#else
if(W_BBRAG == 7) {
logo[0] = throw_strdup(" ** ** ** ");
logo[1] = throw_strdup(" ****** ****** ** ****** ****** ****** * ");
logo[2] = throw_strdup(" ** ** ** ** ** ** ** ****** ** ** *** ");
logo[3] = throw_strdup(" ****** ****** ** ****** ****** ****** * ");
logo[4] = throw_strdup(" ** ** ");
logo[5] = throw_strdup(" ********** ");
}
else {
#if defined(__UNIX__)
if(gvid_xterm) {
logo[0] = throw_strdup(" Ú¿ Ú¿ Ú¿ ");
logo[1] = throw_strdup(" ÚÂÄÄ¿ ÚÂÄÄ¿ ³³ ÚÂÄÄ´³ ÚÂÄÄ¿ ÚÂÄÄ´³  ");
logo[2] = throw_strdup(" ³³ ³³ ³³ ³³ ³³ ³³ ³³ ³ÃÄÄÁÙ ³³ ³³ ÃÅ´ ");
logo[3] = throw_strdup(" ÀÁÄÄ´³ ÀÁÄÄÁÙ ÀÙ ÀÁÄÄÁÙ ÀÁÄÄÁÙ ÀÁÄÄÁÙ Á ");
logo[4] = throw_strdup(" Ú¿ ³³ ");
logo[5] = throw_strdup(" ÀÁÄÄÄÄÄÄÁÙ ");
}
else {
#endif
logo[0] = throw_strdup(" É» É» É» ");
logo[1] = throw_strdup(" ÉËÍÍË» ÉËÍÍË» ºº ÉËÍ͹º ÉËÍÍË» ÉËÍ͹º Ë ");
logo[2] = throw_strdup(" ºº ºº ºº ºº ºº ºº ºº ºÌÍÍʼ ºº ºº Ìι ");
logo[3] = throw_strdup(" ÈÊÍ͹º ÈÊÍÍʼ ȼ ÈÊÍÍʼ ÈÊÍÍʼ ÈÊÍÍʼ Ê ");
logo[4] = throw_strdup(" É» ºº ");
logo[5] = throw_strdup(" ÈÊÍÍÍÍÍÍʼ ");
#if defined(__UNIX__)
}
gvid_boxcvt(logo[0]);
gvid_boxcvt(logo[1]);
gvid_boxcvt(logo[2]);
gvid_boxcvt(logo[3]);
gvid_boxcvt(logo[4]);
gvid_boxcvt(logo[5]);
#endif
}
#endif
W_READ = wopen_(1, 2, MAXROW-4, MAXCOL-5, W_BBRAG, C_BRAGB, C_BRAGW);
w_shadow();
@ -844,6 +805,13 @@ void Initialize(int argc, char* argv[]) {
inforow = ((MAXROW-1)/2)+6;
if(CFG->aka.empty()) {
LOG.ErrConfig();
LOG.printf("! There do not seem to be any ADDRESS's defined.");
LOG.printf("+ Advice: Check your setup of ADDRESS's.");
ConfigErrorExit();
}
bool areasdefined = false;
// Do checking for an area and unknown aka's in area

28
golded3/geline.cpp
View File

@ -573,14 +573,16 @@ static void KludgeREPLYTO(GMsg* msg, const char* ptr) {
static void KludgeFROM(GMsg* msg, const char* ptr) {
INam fromname;
IAdr fromaddr;
strxmimecpy(msg->ifrom, ptr, msg->charsetlevel, sizeof(INam));
ParseInternetAddr(msg->ifrom, fromname, fromaddr);
if(*fromaddr)
strcpy(msg->iorig, fromaddr);
if(*fromname)
strxcpy(msg->realby, fromname, sizeof(msg->realby));
INam _fromname;
IAdr _fromaddr;
char* buf = throw_strdup(ptr);
strxcpy(msg->ifrom, buf, sizeof(msg->ifrom));
ParseInternetAddr(buf, _fromname, _fromaddr);
throw_free(buf);
if(*_fromaddr)
strcpy(msg->iorig, _fromaddr);
if(*_fromname)
strxcpy(msg->realby, _fromname, sizeof(msg->realby));
}
@ -2533,13 +2535,13 @@ void MakeLineIndex(GMsg* msg, int margin, bool header_recode) {
// Charset translate header fields
if(header_recode) {
strxmimecpy(msg->realby, msg->realby, level, sizeof(INam));
strxmimecpy(msg->realto, msg->realto, level, sizeof(INam));
strxmimecpy(msg->by , msg->by , level, sizeof(INam));
strxmimecpy(msg->to , msg->to , level, sizeof(INam));
strxmimecpy(msg->realby, msg->realby, 0, sizeof(INam));
strxmimecpy(msg->realto, msg->realto, 0, sizeof(INam));
strxmimecpy(msg->by, msg->by, level, sizeof(INam));
strxmimecpy(msg->to, msg->to, level, sizeof(INam));
if(not (msg->attr.frq() or msg->attr.att() or msg->attr.urq()))
strxmimecpy(msg->re , msg->re , level, sizeof(ISub), true);
strxmimecpy(msg->re, msg->re, level, sizeof(ISub), true);
}
}
}

4
golded3/gelmsg.cpp
View File

@ -59,8 +59,8 @@ int Area::LoadHdr(GMsg* msg, ulong msgno, bool enable_recode) {
if(retval and enable_recode) {
// Use default translation by default
int table = LoadCharset(NULL, NULL, 1);
if (table == -1)
msg->charsetlevel = LoadCharset(CFG->xlatimport, CFG->xlatlocalset);
if((table == -1) or not CFG->ignorecharset)
msg->charsetlevel = LoadCharset(AA->Xlatimport(), CFG->xlatlocalset);
else
msg->charsetlevel = LoadCharset(CFG->xlatcharset[table].imp, CFG->xlatcharset[table].exp);

1
golded3/gemenu.cpp
View File

@ -826,6 +826,7 @@ int ChangeXlatImport() {
CFG->ignorecharset = true;
AA->SetXlatimport(strtok(Listi[n], " "));
}
LoadCharset(AA->Xlatimport(), CFG->xlatlocalset);
for(n=0; n<xlatimports; n++)
throw_free(Listi[n]);
throw_free(Listi);

16
golded3/geplay.cpp
View File

@ -42,16 +42,16 @@ gsound* snd = NULL;
// ------------------------------------------------------------------
#if defined(__MSDOS__)
#define Beep(A,B) { sound(A); usleep(B*CFG->beepfactor+1); }
#define Sleep(A) { usleep(A*CFG->beepfactor+1); }
#define Beep(A,B) { sound(A); usleep(CFG ? B*CFG->beepfactor+1 : B*1000); }
#define Sleep(A) { usleep(CFG ? A*CFG->beepfactor+1 : A*1000); }
#define NoSound() { nosound(); }
#elif defined(__OS2__)
#define Beep(A,B) { DosBeep(A, B*CFG->beepfactor/1000+1); }
#define Sleep(A) { usleep(A*CFG->beepfactor+1); }
#define Beep(A,B) { DosBeep(A, CFG ? B*CFG->beepfactor/1000+1 : B); }
#define Sleep(A) { usleep(CFG ? A*CFG->beepfactor+1 : A*1000); }
#define NoSound() { }
#elif defined(__WIN32__)
#define Beep(A,B) { (Beep)(A, B*CFG->beepfactor/1000+1); }
#define Sleep(A) { usleep(A*CFG->beepfactor+1); }
#define Beep(A,B) { (Beep)(A, CFG ? B*CFG->beepfactor/1000+1 : B); }
#define Sleep(A) { usleep(CFG ? A*CFG->beepfactor+1 : A*1000); }
#define NoSound() { }
#else
#define Beep(A,B) { }
@ -93,12 +93,12 @@ void InitSound() {
snd = new gsound;
if(snd->is_installed()) {
if(not quiet)
printf("\n* Soundcard support was successfully initialized.");
cout << "* Soundcard support was successfully initialized." << endl;
atexit(ResetSound);
}
else {
if(not quiet)
printf("\n* Soundcard support could NOT be initialized!");
cout << "* Soundcard support could NOT be initialized!" << endl;
ResetSound();
}
break;

1
golded3/geprot.h
View File

@ -149,6 +149,7 @@ void AdvancedSearch(GMsg* msg, int& topline, int& keyok);
void CfgInit();
void CfgInit2();
void CfgReset(void);
int PlayMacro(gkey key, int type);
int IsMacro(gkey key, int type);

2
golded3/geread.cpp
View File

@ -927,7 +927,7 @@ int LoadMessage(GMsg* msg, int margin) {
msg->orig_timesread = msg->timesread++;
if(reader_rcv_noise > 1) {
GMsg* tmsg = throw_calloc(1, sizeof(GMsg));
GMsg* tmsg = (GMsg*) throw_calloc(1, sizeof(GMsg));
AA->LoadHdr(tmsg, msg->msgno, false);
tmsg->attr = msg->attr;
tmsg->orig_timesread = msg->orig_timesread;

46
golded3/geusrbse.cpp
View File

@ -395,41 +395,31 @@ bool guserbase::edit_entry(uint idx) {
bool guserbase::find_entry(char* name, bool lookup) {
gusrbaseentry ent;
if(not strblank(name)) {
string tmpaddr;
gusrbaseentry old_entry = entry;
uint old_index = index;
refresh_maximum_index();
usrbase.lseek(sizeof(gusrbaseheader), SEEK_SET);
for(uint i=0; i<=maximum_index; i++) {
read_entry(i, &ent);
for(index=0; index<=maximum_index; index++) {
read_entry(index, &entry);
if(strieql(name, ent.name) or (lookup and strieql(name, ent.macro))) {
strcpy(entry.macro, ent.macro);
strcpy(entry.name, ent.name);
entry.fidoaddr = ent.fidoaddr;
strcpy(entry.iaddr, ent.iaddr);
entry.prefer_internet = ent.prefer_internet;
entry.is_deleted = ent.is_deleted;
strcpy(entry.pseudo, ent.pseudo);
strcpy(entry.organisation, ent.organisation);
strcpy(entry.snail1, ent.snail1);
strcpy(entry.snail2, ent.snail2);
strcpy(entry.snail3, ent.snail3);
strcpy(entry.dataphone, ent.dataphone);
strcpy(entry.voicephone, ent.voicephone);
strcpy(entry.faxphone, ent.faxphone);
entry.firstdate = ent.firstdate;
entry.lastdate = ent.lastdate;
entry.times = ent.times;
strcpy(entry.homepage, ent.homepage);
entry.group = ent.group;
strcpy(entry.comment1, ent.comment1);
strcpy(entry.comment2, ent.comment1);
strcpy(entry.comment3, ent.comment1);
index = i;
if(strieql(name, entry.name))
return true;
else if(lookup) {
if(strieql(name, entry.macro) or streql(name, entry.iaddr))
return true;
else {
entry.fidoaddr.make_string(tmpaddr);
if (streql(name, tmpaddr.c_str()))
return true;
}
}
}
index = old_index;
entry = old_entry;
}
return false;

127
goldlib/gall/gkbdbase.cpp
View File

@ -132,9 +132,7 @@ void GKbd::Init() {
osversion.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
GetVersionEx(&osversion);
gkbd_nt = (osversion.dwPlatformId & VER_PLATFORM_WIN32_NT) ? true : false;
gkbd_hin = CreateFile("CONIN$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
OPEN_EXISTING, 0, NULL);
gkbd_hin = GetStdHandle(STD_INPUT_HANDLE);
GetConsoleMode(gkbd_hin, &gkbd_kbdmode);
if(gkbd_kbdmode & KBD_TEXTMODE)
SetConsoleMode(gkbd_hin, gkbd_kbdmode & ~KBD_TEXTMODE);
@ -878,7 +876,7 @@ bool is_numpad_key(const INPUT_RECORD& inp) {
if(not (inp.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY)) {
switch(inp.Event.KeyEvent.wVirtualKeyCode) {
case 0x0C:
case VK_CLEAR:
case VK_PRIOR:
case VK_NEXT:
case VK_END:
@ -1168,6 +1166,10 @@ gkey kbxget_raw(int mode) {
}
else {
DWORD &CKS = inp.Event.KeyEvent.dwControlKeyState;
WORD &VKC = inp.Event.KeyEvent.wVirtualKeyCode;
char &ascii = inp.Event.KeyEvent.uChar.AsciiChar;
// Get next key
inp.Event.KeyEvent.bKeyDown = false;
while(1) {
@ -1179,53 +1181,88 @@ gkey kbxget_raw(int mode) {
}
if(inp.EventType == KEY_EVENT and inp.Event.KeyEvent.bKeyDown) {
bool alt_pressed = (inp.Event.KeyEvent.dwControlKeyState & (LEFT_ALT_PRESSED|RIGHT_ALT_PRESSED)) ? true : false;
// bool right_alt_pressed = (inp.Event.KeyEvent.dwControlKeyState & RIGHT_ALT_PRESSED) ? true : false;
bool enhanced_key = (inp.Event.KeyEvent.dwControlKeyState & ENHANCED_KEY) ? true : false;
bool numpad_key = is_numpad_key(inp);
int vk = inp.Event.KeyEvent.wVirtualKeyCode;
char raw_ch = inp.Event.KeyEvent.uChar.AsciiChar;
int kc;
int test;
char ch;
bool alt_pressed = (CKS & (LEFT_ALT_PRESSED|RIGHT_ALT_PRESSED)) ? true : false;
bool ctrl_pressed = (CKS & (LEFT_CTRL_PRESSED|RIGHT_CTRL_PRESSED)) ? true : false;
bool shift_pressed = (CKS & SHIFT_PRESSED) ? true : false;
bool special_key = false;
if(enhanced_key and (raw_ch == 0xE0))
inp.Event.KeyEvent.uChar.AsciiChar = raw_ch = 0;
if(gkbd_nt)
test = (inp.Event.KeyEvent.uChar.AsciiChar and not alt_pressed and vk != -1) or (alt_pressed and vk == -1) or (alt_pressed and numpad_key);
else
test = (inp.Event.KeyEvent.uChar.AsciiChar and not alt_pressed and vk != -1) or (alt_pressed and vk == -1) or (alt_pressed and numpad_key) or (vk == 0xBA);
if(test) {
// Ascii char
if(gkbd_nt and not (alt_pressed and numpad_key)) {
ch = raw_ch;
ReadConsoleInput(gkbd_hin, &inp, 1, &nread);
}
else {
ReadConsole(gkbd_hin, &ch, 1, &nread, NULL);
}
k = 0;
if(alt_pressed)
special_key = is_numpad_key(inp); // Alt-<numpad key>
else if(isalnum(ascii) and not ctrl_pressed)
special_key = not gkbd_nt; // It is alphanumeric key under Win9x
if(special_key) {
ReadConsole(gkbd_hin, &ascii, 1, &nread, NULL);
if(alt_pressed) {
k = (gkey)ch;
k = (gkey)ascii;
break;
}
if(gkbd_nt) {
if(ch == '\x5E' or ch == '\x7E' or ch == '\x60' or ch == '\xF9' or ch == '\xEF')
inp.Event.KeyEvent.wVirtualKeyCode = (word)(ch << 8);
}
else {
if(ch == '\x5E' or ch == '\x7E' or ch == '\x60' or ch == '\x27' or ch == '\x2E')
inp.Event.KeyEvent.wVirtualKeyCode = (word)(ch << 8);
}
inp.Event.KeyEvent.uChar.AsciiChar = ch;
}
else {
// Control keycode
else
ReadConsoleInput(gkbd_hin, &inp, 1, &nread);
}
kc = gkbd_nt2bios(inp);
if(kc != -1) {
k = (gkey)kc;
break;
switch(VKC) {
// Not meanful keys
case VK_SHIFT:
case VK_CONTROL:
case VK_MENU:
case VK_CAPITAL:
case VK_NUMLOCK:
case VK_SCROLL:
return (gkey)k; // Return empty key
case VK_NUMPAD0:
case VK_NUMPAD1:
case VK_NUMPAD2:
case VK_NUMPAD3:
case VK_NUMPAD4:
case VK_NUMPAD5:
case VK_NUMPAD6:
case VK_NUMPAD7:
case VK_NUMPAD8:
case VK_NUMPAD9:
if(shift_pressed) {
WORD keytrans[10][2] = {
{VK_NUMPAD0, VK_INSERT},
{VK_NUMPAD1, VK_END},
{VK_NUMPAD2, VK_DOWN},
{VK_NUMPAD3, VK_NEXT},
{VK_NUMPAD4, VK_LEFT},
{VK_NUMPAD5, VK_CLEAR},
{VK_NUMPAD6, VK_RIGHT},
{VK_NUMPAD7, VK_HOME},
{VK_NUMPAD8, VK_UP},
{VK_NUMPAD9, VK_PRIOR},
};
for(int i = 0; i < 10; i++)
if(VKC == keytrans[i][0]) {
VKC = keytrans[i][1];
break;
}
}
// fall through
default:
{
int kc = gkbd_nt2bios(inp);
if(kc != -1)
return (gkey)kc;
}
break;
// OEM specific keys
case 0x2a:
case 0xba: case 0xbb: case 0xbc: case 0xbd: case 0xbe:
case 0xbf: case 0xc0:
case 0xdb: case 0xdc: case 0xdd: case 0xde: case 0xdf:
case 0xe0: case 0xe1: case 0xe2: case 0xe3: case 0xe4:
case 0xe6:
case 0xe9: case 0xea: case 0xeb: case 0xec: case 0xed:
case 0xef: case 0xf0: case 0xf1: case 0xf2: case 0xf3:
case 0xf4: case 0xf5:
if(ascii)
return (gkey)ascii;
break;
}
}
else {

2
goldlib/gall/gutlmtsk.cpp
View File

@ -56,7 +56,7 @@ GMTsk::GMTsk() {
detected = GMTSK_NONE;
name = "";
#if defined(__DJGPP__)
_get_dos_version(true);
detected = GMTSK_DOS;
name = "DPMI32";
#elif defined(__UNIX__)
detected = GMTSK_LINUX;

22
goldlib/gall/gutlwin.cpp
View File

@ -113,6 +113,12 @@ char tl[256] = {
0xf8, 0xf9, 0xfa, 0xfb, 0xfc, 0xfd, 0xfe, 0xff
};
WCHAR oem2unicode[256] = {
0x0000, 0x263a, 0x263b, 0x2665, 0x2666, 0x2663, 0x2660, 0x2219,
0x25d8, 0x25cb, 0x25d9, 0x2642, 0x2640, 0x266a, 0x266b, 0x263c,
0x25ba, 0x25c4, 0x2195, 0x203c, 0x00b6, 0x00a7, 0x25a0, 0x21a8,
0x2191, 0x2193, 0x2192, 0x2190, 0x221f, 0x2194, 0x25b2, 0x25bc
};
// ------------------------------------------------------------------
@ -129,6 +135,10 @@ int g_init_os(int flags) {
for(i = 0; i < 256; i++) {
tu[i] = (toupper)(i);
tl[i] = (tolower)(i);
if(i >= ' ') {
CHAR chr = (CHAR)i;
MultiByteToWideChar(CP_OEMCP, 0, &chr, 1, oem2unicode+i, 1);
}
}
return 0;
}
@ -224,7 +234,7 @@ char* g_get_clip_text(void) {
int Format = 0;
int ReadType = CF_OEMTEXT;
while((Format = EnumClipboardFormats(Format)) != 0) {
if(Format == CF_UNICODETEXT && WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT) {
if((Format == CF_UNICODETEXT) and (WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT)) {
Unicode = true;
break;
}
@ -287,7 +297,15 @@ int g_put_clip_text(const char *Data) {
if(WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT)
if((hData = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, BufferSize * 2)) != NULL)
if((GData = GlobalLock(hData)) != NULL) {
MultiByteToWideChar(CP_OEMCP, 0, Data, -1, (LPWSTR)GData, BufferSize);
WCHAR *UData = (WCHAR *)GData;
while(*Data) {
if((*Data == '\r') or (*Data == '\n') or (*Data == '\t'))
*UData++ = *Data++; // no translation for real control chars
else
*UData++ = oem2unicode[*Data++];
}
*UData = 0;
GlobalUnlock(hData);
SetClipboardData(CF_UNICODETEXT, (HANDLE)hData);
}

63
goldlib/gall/gvidall.h
View File

@ -39,6 +39,9 @@
#define ACS_BOARD '°'
#define ACS_BLOCK 'Û'
#endif
#if defined(__WIN32__)
#include <windows.h>
#endif
// ------------------------------------------------------------------
@ -258,6 +261,9 @@ typedef word* gdma; // Video DMA pointer
#if defined(__USE_NCURSES__)
typedef chtype vchar; // Type of characters on-screen
typedef chtype vatch; // Type of character-attribute groups
#elif defined(__WIN32__)
typedef char vchar; // Type of characters on-screen
typedef CHAR_INFO vatch; // Type of character-attribute groups
#else
typedef char vchar; // Type of characters on-screen
typedef word vatch; // Type of character-attribute groups
@ -379,9 +385,12 @@ void vposset (int row, int col);
void vclrscr ();
void vclrscr (int atr); // Overloaded
vatch* vsave (int srow=-1, int scol=-1, int erow=-1, int ecol=-1);
void vredraw (vatch* buf, int srow=-1, int scol=-1, int erow=-1, int ecol=-1);
void vrestore (vatch* buf, int srow=-1, int scol=-1, int erow=-1, int ecol=-1);
typedef struct _vsavebuf {
int top, left, right, bottom;
__extension__ vatch data[0];
} vsavebuf;
vsavebuf* vsave (int srow=-1, int scol=-1, int erow=-1, int ecol=-1);
void vrestore (vsavebuf* buf, int srow=-1, int scol=-1, int erow=-1, int ecol=-1);
void vcurget (int* sline, int* eline);
void vcurset (int sline, int eline);
@ -396,17 +405,45 @@ void vcursmall ();
void vbox (int srow, int scol, int erow, int ecol, int box, int hiattr, int loattr=-1);
void vfill (int srow, int scol, int erow, int ecol, vchar chr, int atr);
#if not defined(__USE_NCURSES__)
inline vchar vgetc (int row, int col) { return (vchar)(0xFF & vgetw(row, col)); }
#else
inline vchar vgetc (int row, int col) { return (vchar)((A_CHARTEXT|A_ALTCHARSET) & vgetw(row, col)); }
#endif
vchar vgetc (int row, int col); // Gets the character from position
vchar vgchar (vatch chat); // Gets the character part of a character-attribute group
int vgattr (vatch chat); // Gets the attribute part of a character-attribute group
vatch vschar (vatch chat, vchar chr); // Sets the given character in a character-attribute group
vatch vsattr (vatch chat, int atr); // Sets the given attribute in a character-attribute group
vatch vcatch (vchar chr, int atr); // Compose character-attribute group from character and attribute
vchar vgchar (vatch chat);
int vgattr (vatch chat);
vatch vschar (vatch chat, vchar chr);
vatch vsattr (vatch chat, int atr);
vatch vcatch (vchar chr, int atr);
// inline implementation of functions above
inline vchar vgetc (int row, int col) { return vgchar(vgetw(row, col)); }
#if defined(__USE_NCURSES__)
int gvid_dosattrcalc (int ourattr);
int gvid_attrcalc (int dosattr);
inline vchar vgchar (vatch chat) { return chat & (A_CHARTEXT | A_ALTCHARSET); }
inline int vgattr (vatch chat) { return gvid_dosattrcalc(chat & ~(A_CHARTEXT | A_ALTCHARSET)); }
inline vatch vschar (vatch chat, vchar chr) { return (chr & (A_CHARTEXT | A_ALTCHARSET)) | (chat & ~(A_CHARTEXT | A_ALTCHARSET)); }
inline vatch vsattr (vatch chat, int atr) { return (chat & (A_CHARTEXT | A_ALTCHARSET)) | gvid_attrcalc(atr); }
inline vatch vcatch (vchar chr, int atr) { return chr | gvid_attrcalc(atr); }
#elif defined(__WIN32__)
inline vchar vgchar (vatch chat) { return chat.Char.AsciiChar; }
inline int vgattr (vatch chat) { return chat.Attributes; }
inline vatch vschar (vatch chat, vchar chr) { chat.Char.UnicodeChar = 0; chat.Char.AsciiChar = chr; return chat; }
inline vatch vsattr (vatch chat, int atr) { chat.Attributes = atr; return chat; }
inline vatch vcatch (vchar chr, int atr) { vatch chat; chat.Char.UnicodeChar = 0; chat.Char.AsciiChar = chr; chat.Attributes = atr; return chat; }
#else
inline vchar vgchar (vatch chat) { return chat & 0xff; }
inline int vgattr (vatch chat) { return (chat >> 8) & 0xff; }
inline vatch vschar (vatch chat, vchar chr) { return (chat & 0xff00) | chr; }
inline vatch vsattr (vatch chat, int atr) { return (chat & 0xff) | (atr << 8); }
inline vatch vcatch (vchar chr, int atr) { return (chr & 0xff) | ((atr << 8) & 0xff00); }
#endif
typedef void (*VidPutStrCP)(int,int,int,const char*);

613
goldlib/gall/gvidbase.cpp
View File

@ -86,6 +86,18 @@ static bool __vcurhidden = false;
#ifdef __WIN32__
extern HANDLE gvid_hout;
extern OSVERSIONINFO WinVer; // defined in gutlwin.cpp
extern WCHAR oem2unicode[]; // defined in gutlwin.cpp
// ------------------------------------------------------------------
// Transform character < 32 into printable Unicode equivalent
inline WCHAR gvid_tcpr(vchar chr) {
return oem2unicode[chr];
}
#endif
@ -93,6 +105,10 @@ extern HANDLE gvid_hout;
#if defined(__MSDOS__) or defined(__UNIX__)
#if defined(__MSDOS__)
extern int __gdvdetected;
#endif
#ifndef __DJGPP__
const unsigned short _dos_ds = 0;
@ -344,11 +360,6 @@ void vputansi(int row, int col, word* buf, int len) {
#endif // not defined(__USE_NCURSES__)
// ------------------------------------------------------------------
extern int __gdvdetected;
// ------------------------------------------------------------------
// Converts an attribute to monochrome equivalent
@ -494,7 +505,7 @@ static USHORT VioWrtCharStrAtt_(PCCH str, USHORT cb, USHORT row, USHORT col, PBY
// ------------------------------------------------------------------
// Compute our attributes from DOS attributes
int gvid_attrcalc (int dosattr) {
int gvid_attrcalc(int dosattr) {
// DOS attrs: XRGBxrgb
// color pair definition: 00RGBrgb, with last 3 bits negated
@ -511,7 +522,7 @@ int gvid_attrcalc (int dosattr) {
// ------------------------------------------------------------------
// Compute DOS attributes from our attributes
int gvid_dosattrcalc (int ourattr) {
int gvid_dosattrcalc(int ourattr) {
int attr = 0;
attr = PAIR_NUMBER(ourattr);
@ -528,18 +539,18 @@ int gvid_dosattrcalc (int ourattr) {
// Transform character < 32 into printable equivalent
chtype gvid_tcpr (vchar chr) {
chtype gvid_tcpr(vchar chr) {
chtype gvid_cpr[] = {
(chtype)' ', (chtype)'@', (chtype)'@', (chtype)'x',
(chtype) ACS_DIAMOND, (chtype)'x', (chtype)'x', ACS_BULLET,
ACS_BULLET, ACS_BULLET, ACS_BULLET, (chtype)'x',
(chtype)'x', (chtype)'x', (chtype)'x', ACS_LANTERN,
ACS_LARROW, (chtype) ACS_RARROW, (chtype)'x', (chtype)'!',
(chtype)'x', (chtype)'x', ACS_S1, (chtype)'x',
ACS_UARROW, ACS_DARROW, ACS_LARROW, (chtype)ACS_RARROW,
(chtype)'x', (chtype)'x', ACS_UARROW, ACS_DARROW
};
const chtype gvid_cpr[] = {
(chtype)' ', (chtype)'@', (chtype)'@', (chtype)'x',
(chtype) ACS_DIAMOND, (chtype)'x', (chtype)'x', ACS_BULLET,
ACS_BULLET, ACS_BULLET, ACS_BULLET, (chtype)'x',
(chtype)'x', (chtype)'x', (chtype)'x', ACS_LANTERN,
(chtype)ACS_RARROW, ACS_LARROW, (chtype)'x', (chtype)'!',
(chtype)'x', (chtype)'x', ACS_S1, (chtype)'x',
ACS_UARROW, ACS_DARROW, ACS_LARROW, (chtype)ACS_RARROW,
(chtype)'x', (chtype)'x', ACS_UARROW, ACS_DARROW
};
chtype ch = chr & A_CHARTEXT;
chtype at = chr & (~A_CHARTEXT);
@ -587,37 +598,39 @@ void vputw(int row, int col, vatch chat) {
cpu.dl((byte)col);
cpu.genint(0x10);
cpu.ah(9);
cpu.al((byte)(chat&0xFF));
cpu.al(vgchar(chat));
cpu.bh(0);
cpu.bl((byte)(chat>>8));
cpu.bl(vgattr(chat));
cpu.cx(1);
cpu.genint(0x10);
}
#elif defined(__OS2__)
BYTE tmp[2];
tmp[0] = (BYTE)(chat & 0xFF);
tmp[1] = (BYTE)(chat >> 8);
VioWrtNCell(tmp, 1, (USHORT)row, (USHORT)col, 0);
VioWrtNCell(&chat, 1, (USHORT)row, (USHORT)col, 0);
#elif defined(__WIN32__)
COORD coord;
DWORD x;
word atr = (word) (chat >> 8);
const COORD coord = {0, 0};
const COORD size = {1, 1};
SMALL_RECT rect;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
WriteConsoleOutputAttribute(gvid_hout, &atr, 1, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, (char* ) &chat, 1, coord, &x);
rect.Top = row;
rect.Left = col;
rect.Bottom = row+size.Y-1;
rect.Right = col+size.X-1;
if(WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT) {
chat.Char.UnicodeChar = gvid_tcpr(vgchar(chat));
WriteConsoleOutputW(gvid_hout, &chat, size, coord, &rect);
}
else
WriteConsoleOutputA(gvid_hout, &chat, size, coord, &rect);
#elif defined(__UNIX__)
char chr = (char)(chat & 0xFF);
int atr = chat >> 8;
char chr = vgchar(chat);
int atr = vgattr(chat);
char* color = gvid_newattr(atr);
chat = (word)(chr | (atr << 8));
gvid_cvtstr(&chat, 1);
_vputw(row, col, chat);
@ -669,23 +682,22 @@ void vputws(int row, int col, vatch* buf, uint len) {
#elif defined(__WIN32__)
COORD coord;
DWORD x;
const COORD coord = {0, 0};
COORD size = {len, 1};
SMALL_RECT rect;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
char* p = (char *) buf;
word* q = gvid->bufwrd;
char* c = gvid->bufchr;
for(int i = 0; i < len; i++) {
*c++ = *p++;
*q++ = *p++;
rect.Top = row;
rect.Left = col;
rect.Bottom = row+size.Y-1;
rect.Right = col+size.X-1;
if(WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT) {
for(int i = 0; i < len; i++) {
buf[i].Char.UnicodeChar = gvid_tcpr(vgchar(buf[i]));
}
WriteConsoleOutputW(gvid_hout, buf, size, coord, &rect);
}
WriteConsoleOutputAttribute(gvid_hout, gvid->bufwrd, len, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, gvid->bufchr, len, coord, &x);
else
WriteConsoleOutputA(gvid_hout, buf, size, coord, &rect);
#elif defined(__UNIX__)
@ -704,13 +716,13 @@ void vputc(int row, int col, int atr, vchar chr) {
#if defined(__USE_NCURSES__)
mvaddch(row, col, gvid_tcpr(chr) | gvid_attrcalc(atr));
mvaddch(row, col, vcatch(gvid_tcpr(chr), atr));
refresh();
#elif defined(__MSDOS__)
if(gvid->isdma()) {
_vputw(row, col, (word)((atr << 8) | chr));
_vputw(row, col, vcatch(chr, atr));
}
else if(gvid->isbios() or gvid->iscga()) {
i86 cpu;
@ -727,28 +739,15 @@ void vputc(int row, int col, int atr, vchar chr) {
cpu.genint(0x10);
}
#elif defined(__OS2__)
#elif defined(__OS2__) or defined(__WIN32__)
BYTE tmp[2];
tmp[0] = chr;
tmp[1] = (BYTE)atr;
VioWrtNCell(tmp, 1, (USHORT)row, (USHORT)col, 0);
#elif defined(__WIN32__)
COORD coord;
DWORD x;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
WriteConsoleOutputAttribute(gvid_hout, (word *) &atr, 1, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, (char *) &chr, 1, coord, &x);
vputw(row, col, vcatch(chr, atr));
#elif defined(__UNIX__)
char* color = gvid_newattr(atr);
gvid_cvtstr(&chr, 1);
_vputw(row, col, (word)((atr << 8) | chr));
_vputw(row, col, vcatch(chr, atr));
gvid_printf("\033[%u;%uH%s%c", row+1, col+1, color, chr);
@ -770,11 +769,11 @@ void vputvs(int row, int col, int atr, const vchar* str) {
addch(gvid_tcpr(str[counter]) | attr);
refresh();
#else
#else
vputs(row, col, atr, str);
#endif
#endif
}
@ -799,7 +798,7 @@ void vputs(int row, int col, int atr, const char* str) {
gdma p = gdmaptr(col, row);
_farsetsel(_dos_ds);
while(*str) {
_farnspokew(p, (atr << 8) | *str++);
_farnspokew(p, vcatch(*str++, atr));
p += ATTRSIZE;
}
}
@ -827,15 +826,12 @@ void vputs(int row, int col, int atr, const char* str) {
#elif defined(__WIN32__)
COORD coord;
DWORD x;
int len = strlen(str);
int i;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
FillConsoleOutputAttribute(gvid_hout, (word) atr, len, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, str, len, coord, &x);
for(i = 0; *str; i++)
gvid->bufwrd[i] = vcatch(*str++, atr);
if(i)
vputws(row, col, gvid->bufwrd, i);
#elif defined(__UNIX__)
@ -846,7 +842,7 @@ void vputs(int row, int col, int atr, const char* str) {
gdma p = gdmaptr(col, row);
_farsetsel(_dos_ds);
while(*str) {
_farnspokew(p, (atr << 8) | *str++);
_farnspokew(p, vcatch(*str++, atr));
p += ATTRSIZE;
}
@ -925,29 +921,20 @@ void vputns(int row, int col, int atr, const char* str, uint width) {
VioWrtCharStrAtt((PCCH)str, (USHORT)minimum_of_two(len,width), (USHORT)row, (USHORT)col, (PBYTE)&atr, 0);
if(width > len) {
BYTE tmp[2];
tmp[0] = fillchar;
tmp[1] = (BYTE)atr;
VioWrtNCell(tmp, (USHORT)(width-len), (USHORT)row, (USHORT)(col+len), 0);
vatch filler = vcatch(fillchar, atr);
VioWrtNCell((CHAR *)&filler, (USHORT)(width-len), (USHORT)row, (USHORT)(col+len), 0);
}
#elif defined(__WIN32__)
COORD coord;
DWORD x;
int len = minimum_of_two(strlen(str), width);
int i;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
FillConsoleOutputAttribute(gvid_hout, (word) atr, width, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, str, len, coord, &x);
if(width > len) {
coord.X += (SHORT) len;
len = width - len;
FillConsoleOutputCharacter(gvid_hout, fillchar, len, coord, &x);
}
for(i = 0; (i < width) and *str; i++)
gvid->bufwrd[i] = vcatch(*str++, atr);
vatch filler = vcatch(fillchar, atr);
for(; i < width; i++)
gvid->bufwrd[i] = filler;
vputws(row, col, gvid->bufwrd, width);
#elif defined(__UNIX__)
@ -985,7 +972,7 @@ void vputns(int row, int col, int atr, const char* str, uint width) {
void _vputx(int row, int col, int atr, char chr, uint len) {
gdma p = gdmaptr(col, row);
word tmp = (word)((atr << 8) | chr);
word tmp = vcatch(chr, atr);
_farsetsel(_dos_ds);
for(uint n=0; n<len; n++) {
_farnspokew(p, tmp);
@ -1002,8 +989,7 @@ void vputx(int row, int col, int atr, vchar chr, uint len) {
#if defined(__USE_NCURSES__)
int attr = gvid_attrcalc(atr);
mvhline(row, col, gvid_tcpr(chr) | attr, len);
mvhline(row, col, vcatch(gvid_tcpr(chr), atr), len);
refresh();
#elif defined(__MSDOS__)
@ -1028,19 +1014,15 @@ void vputx(int row, int col, int atr, vchar chr, uint len) {
#elif defined(__OS2__)
BYTE tmp[2];
tmp[0] = chr;
tmp[1] = (BYTE)atr;
VioWrtNCell(tmp, (USHORT)len, (USHORT)row, (USHORT)col, 0);
vatch filler = vcatch(chr, atr);
VioWrtNCell((CHAR *)&filler, (USHORT)len, (USHORT)row, (USHORT)col, 0);
#elif defined(__WIN32__)
COORD c;
c.X = (SHORT)col;
c.Y = (SHORT)row;
DWORD wr;
FillConsoleOutputCharacter(gvid_hout, chr, len, c, &wr);
FillConsoleOutputAttribute(gvid_hout, (WORD)atr, len, c, &wr);
vatch filler = vcatch(chr, atr);
for(int i = 0; i < len; i++)
gvid->bufwrd[i] = filler;
vputws(row, col, gvid->bufwrd, len);
#elif defined(__UNIX__)
@ -1063,7 +1045,7 @@ void vputx(int row, int col, int atr, vchar chr, uint len) {
inline void _vputy(int row, int col, int atr, char chr, uint len) {
gdma p = gdmaptr(col, row);
word tmp = (word)((atr<<8) | chr);
word tmp = vcatch(chr, atr);
_farsetsel(_dos_ds);
for(uint n=0; n<len; n++) {
_farnspokew(p, tmp);
@ -1080,8 +1062,7 @@ void vputy(int row, int col, int atr, vchar chr, uint len) {
#if defined(__USE_NCURSES__)
int attr = gvid_attrcalc(atr);
mvvline(row, col, gvid_tcpr(chr) | attr, len);
mvvline(row, col, vcatch(gvid_tcpr(chr), atr), len);
refresh();
#elif defined(__MSDOS__)
@ -1108,24 +1089,15 @@ void vputy(int row, int col, int atr, vchar chr, uint len) {
#elif defined(__OS2__)
BYTE tmp[2];
tmp[0] = chr;
tmp[1] = (BYTE)atr;
vatch filler = vcatch(chr, atr);
for(int n=0; n<len; n++)
VioWrtNCell(tmp, 1, (USHORT)row++, (USHORT)col, 0);
VioWrtNCell((CHAR *)&filler, 1, (USHORT)row++, (USHORT)col, 0);
#elif defined(__WIN32__)
COORD coord;
DWORD x;
coord.X = (SHORT) col;
for(int i=0; i < len; i++) {
coord.Y = (SHORT) row++;
WriteConsoleOutputAttribute(gvid_hout, (word *) &atr, 1, coord, &x);
WriteConsoleOutputCharacter(gvid_hout, (char *) &chr, 1, coord, &x);
}
vatch filler = vcatch(chr, atr);
for(int i=0; i < len; i++)
vputw(row++, col, filler);
#elif defined(__UNIX__)
@ -1197,31 +1169,27 @@ vatch vgetw(int row, int col) {
#elif defined(__OS2__)
word chat;
USHORT _row=(USHORT)row, _col=(USHORT)col, len=sizeof(chat);
vatch chat;
USHORT len=sizeof(chat);
#if defined(__EMX__)
VioReadCellStr((PCH)&chat, &len, _row, _col, 0);
#else
VioReadCellStr((CHAR*)&chat, &len, _row, _col, 0);
#endif
VioReadCellStr((CHAR *)&chat, &len, (USHORT)row, (USHORT)col, 0);
return chat;
#elif defined(__WIN32__)
COORD coord;
DWORD x;
word atr;
char chr;
vatch chat;
const COORD coord = {0, 0};
const COORD size = {1, 1};
SMALL_RECT rect;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
rect.Top = row;
rect.Left = col;
rect.Bottom = row+size.Y-1;
rect.Right = col+size.X-1;
ReadConsoleOutput(gvid_hout, &chat, size, coord, &rect);
ReadConsoleOutputAttribute(gvid_hout, &atr, 1, coord, &x);
ReadConsoleOutputCharacter(gvid_hout, &chr, 1, coord, &x);
return (word)((atr << 8) | chr);
return chat;
#elif defined(__UNIX__)
@ -1231,79 +1199,15 @@ vatch vgetw(int row, int col) {
}
// ------------------------------------------------------------------
// Get character and attribute at cursor position
#if (defined(__MSDOS__) or defined(__UNIX__)) and not defined(__USE_NCURSES__)
inline void _vgetc(int row, int col, int* atr, char* chr) {
word w = _vgetw(row, col);
*chr = (char)(w & 0xFF);
*atr = (int)(w >> 8);
}
#endif
// ------------------------------------------------------------------
// Get character and attribute at cursor position
void vgetc(int row, int col, int* atr, vchar* chr) {
#if defined(__USE_NCURSES__)
vatch tmp = vgetw(row, col);
chtype charead = mvinch(row, col);
*chr = (charead & A_CHARTEXT);
*atr = gvid_dosattrcalc(charead & (A_ATTRIBUTES | A_COLOR));
#elif defined(__MSDOS__)
if(gvid->isdma()) {
_vgetc(row, col, atr, chr);
}
else if(gvid->isbios() or gvid->iscga()) {
i86 cpu;
cpu.ah(2);
cpu.bh(0);
cpu.dh((byte)row);
cpu.dl((byte)col);
cpu.genint(0x10);
cpu.ah(8);
cpu.bh(0);
cpu.genint(0x10);
*chr = cpu.al();
*atr = cpu.ah();
}
#elif defined(__OS2__)
CHAR tmp[2];
USHORT _row=(USHORT)row, _col=(USHORT)col, len=sizeof(tmp);
#if defined(__EMX__)
VioReadCellStr((PCH)tmp, &len, _row, _col, 0);
#else
VioReadCellStr(tmp, &len, _row, _col, 0);
#endif
*chr = tmp[0];
*atr = tmp[1];
#elif defined(__WIN32__)
COORD coord;
DWORD x;
coord.X = (SHORT) col;
coord.Y = (SHORT) row;
ReadConsoleOutputAttribute(gvid_hout, (word* ) atr, 1, coord, &x);
ReadConsoleOutputCharacter(gvid_hout, (char* ) chr, 1, coord, &x);
#elif defined(__UNIX__)
_vgetc(row, col, atr, chr);
#endif
*chr = vgchar(tmp);
*atr = vgattr(tmp);
}
@ -1357,12 +1261,14 @@ void vscroll(int srow, int scol, int erow, int ecol, int atr, int lines) {
#if defined(__USE_NCURSES__)
vatch filler = vcatch(' ', atr);
// Currently implemented with vsave/vrestore
// Does anyone know a better solution?
if(lines >= 0) {
if(lines <= 1 + erow - srow) {
vatch *buf = vsave(srow + lines, scol, erow, ecol);
vsavebuf *buf = vsave(srow + lines, scol, erow, ecol);
vrestore(buf, srow, scol, erow - lines, ecol);
throw_xfree(buf);
}
@ -1370,13 +1276,13 @@ void vscroll(int srow, int scol, int erow, int ecol, int atr, int lines) {
lines = 1 + erow - srow;
for(int counter = 0; counter < lines; counter++)
mvhline(1 + erow + counter - lines, scol, ' ' | gvid_attrcalc(atr), 1 + ecol - scol);
mvhline(1 + erow + counter - lines, scol, filler, 1 + ecol - scol);
refresh();
}
else {
lines*=-1;
if(lines <= 1 + erow - srow) {
vatch *buf = vsave(srow, scol, erow - lines, ecol);
vsavebuf *buf = vsave(srow, scol, erow - lines, ecol);
vrestore(buf, srow + lines, scol, erow, ecol);
throw_xfree(buf);
}
@ -1384,7 +1290,7 @@ void vscroll(int srow, int scol, int erow, int ecol, int atr, int lines) {
lines = 1 + erow - srow;
for(int counter = 0; counter < lines; counter++)
mvhline(srow + counter, scol, ' ' | gvid_attrcalc(atr), 1 + ecol - scol);
mvhline(srow + counter, scol, filler, 1 + ecol - scol);
refresh();
}
@ -1407,32 +1313,25 @@ void vscroll(int srow, int scol, int erow, int ecol, int atr, int lines) {
#elif defined(__OS2__)
BYTE tmp[2];
tmp[0] = ' ';
tmp[1] = (BYTE)atr;
vatch filler = vcatch(' ', atr);
if(lines > 0)
VioScrollUp((USHORT)srow, (USHORT)scol, (USHORT)erow, (USHORT)ecol, (USHORT)lines, tmp, 0);
VioScrollUp((USHORT)srow, (USHORT)scol, (USHORT)erow, (USHORT)ecol, (USHORT)lines, (CHAR *)&filler, 0);
else
VioScrollDn((USHORT)srow, (USHORT)scol, (USHORT)erow, (USHORT)ecol, (USHORT)-lines, tmp, 0);
VioScrollDn((USHORT)srow, (USHORT)scol, (USHORT)erow, (USHORT)ecol, (USHORT)-lines, (CHAR *)&filler, 0);
#elif defined(__WIN32__)
CHAR_INFO fill;
fill.Char.UnicodeChar = 0;
fill.Char.AsciiChar = ' ';
fill.Attributes = (WORD)atr;
SMALL_RECT r;
COORD c = {scol, srow - lines};
vatch filler = vcatch(' ', atr);
r.Left = (SHORT)scol;
r.Top = (SHORT)srow;
r.Right = (SHORT)ecol;
r.Bottom = (SHORT)erow;
COORD c;
c.X = (SHORT)scol;
c.Y = (SHORT)(srow - lines);
ScrollConsoleScreenBuffer(gvid_hout, &r, &r, c, &fill);
ScrollConsoleScreenBuffer(gvid_hout, &r, &r, c, &filler);
#elif defined(__UNIX__)
@ -1528,15 +1427,13 @@ void vposset(int row, int col) {
#elif defined(__WIN32__)
// No need to set the cursor position if its not visible
// Strangely, this is a major speedup to screen-output
// No need to set the cursor position if its not visible
// Strangely, this is a major speedup to screen-output
if(__vcurhidden)
return;
if(__vcurhidden)
return;
COORD c;
c.X = (SHORT)col;
c.Y = (SHORT)row;
COORD c = {col, row};
SetConsoleCursorPosition(gvid_hout, c);
#elif defined(__UNIX__)
@ -1552,11 +1449,7 @@ void vposset(int row, int col) {
void vclrscr() {
#if defined(__USE_NCURSES__)
vclrscr((byte)gvid_dosattrcalc(vgetw(gvid->currow, gvid->curcol)));
#else
vclrscr((byte)(vgetw(gvid->currow, gvid->curcol) >> 8));
#endif
vclrscr(vgattr(vgetw(gvid->currow, gvid->curcol)));
}
@ -1582,8 +1475,9 @@ void vclrscr(int atr) {
#if defined(__USE_NCURSES__)
clearok(stdscr, TRUE);
vatch filler = vcatch(' ', atr);
for(int row = 0; row < LINES; row++)
mvhline(row, 0, ' ' | gvid_attrcalc(atr), COLS);
mvhline(row, 0, filler, COLS);
move(0, 0);
refresh();
@ -1604,16 +1498,14 @@ void vclrscr(int atr) {
#elif defined(__OS2__)
BYTE tmp[2];
tmp[0] = ' ';
tmp[1] = (BYTE)atr;
VioScrollUp(0, 0, 0xFFFF, 0xFFFF, 0xFFFF, tmp, 0);
vatch filler = vcatch(' ', atr);
VioScrollUp(0, 0, 0xFFFF, 0xFFFF, 0xFFFF, (CHAR *)&filler, 0);
#elif defined(__WIN32__)
COORD c;
c.X = c.Y = 0;
COORD c = {0, 0};
DWORD wr, len = gvid->numrows * gvid->numcols;
// Filling with space seems to work for both Unicode and regular functions
FillConsoleOutputCharacter(gvid_hout, ' ', len, c, &wr);
FillConsoleOutputAttribute(gvid_hout, (WORD)atr, len, c, &wr);
@ -1649,42 +1541,32 @@ static void _vsave(word* buf, int len1, int srow, int scol, int erow) {
// ------------------------------------------------------------------
// Saves the current screen and returns pointer to buffer
vatch* vsave(int __srow, int __scol, int __erow, int __ecol) {
vsavebuf* vsave(int srow, int scol, int erow, int ecol) {
if(__srow == -1) __srow = 0;
if(__scol == -1) __scol = 0;
if(__erow == -1) __erow = gvid->numrows-1;
if(__ecol == -1) __ecol = gvid->numcols-1;
if(srow == -1) srow = 0;
if(scol == -1) scol = 0;
if(erow == -1) erow = gvid->numrows-1;
if(ecol == -1) ecol = gvid->numcols-1;
vatch* sbuf = (vatch*)throw_xcalloc((((__erow-__srow+1)*(__ecol-__scol+1))+4), sizeof(vatch));
vsavebuf* sbuf = (vsavebuf*)throw_xmalloc(sizeof(vsavebuf) + (erow - srow + 1) * (ecol - scol + 1) * sizeof(vatch));
if(sbuf) {
vatch* buf = sbuf;
vatch* buf = sbuf->data;
buf[0] = (vatch)__srow;
buf[1] = (vatch)__scol;
buf[2] = (vatch)__erow;
buf[3] = (vatch)__ecol;
sbuf->top = srow;
sbuf->left = scol;
sbuf->bottom = erow;
sbuf->right = ecol;
#if defined(__USE_NCURSES__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
for(int row=srow; row<=erow; row++)
for(int col=scol; col<=ecol; col++)
*buf++ = mvinch(row, col);
#elif defined(__MSDOS__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
int len1 = ecol-scol+1;
if(gvid->isdma()) {
@ -1711,12 +1593,7 @@ vatch* vsave(int __srow, int __scol, int __erow, int __ecol) {
#elif defined(__OS2__)
USHORT srow = *buf++;
USHORT scol = *buf++;
USHORT erow = *buf++;
USHORT ecol = *buf++;
USHORT len1 = (USHORT)(ecol-scol+1);
int len1 = (int)(ecol-scol+1);
#if defined(__BORLANDC__)
PCHAR16 ptr = (PCHAR16)buf;
@ -1725,46 +1602,30 @@ vatch* vsave(int __srow, int __scol, int __erow, int __ecol) {
#endif
USHORT len2 = (USHORT)(len1*sizeof(word));
for(USHORT nrow=srow; nrow<=erow; nrow++) {
for(int nrow=srow; nrow<=erow; nrow++) {
VioReadCellStr(ptr, &len2, nrow, scol, 0);
ptr += len2;
}
#elif defined(__WIN32__)
COORD coord;
DWORD x;
SHORT srow = *buf++;
SHORT scol = *buf++;
SHORT erow = *buf++;
SHORT ecol = *buf++;
const COORD coord = {0, 0};
COORD size = {ecol-scol+1, erow-srow+1};
SMALL_RECT r;
coord.X = scol;
// Set the source rectangle.
r.Top = srow;
r.Left = scol;
r.Bottom = erow;
r.Right = ecol;
SHORT len1 = (SHORT)(ecol-scol+1);
char* p = (char *) buf;
for(SHORT nrow=srow; nrow<=erow; nrow++) {
coord.Y = nrow;
ReadConsoleOutputAttribute(gvid_hout, gvid->bufwrd, len1, coord, &x);
ReadConsoleOutputCharacter(gvid_hout, gvid->bufchr, len1, coord, &x);
word* q = gvid->bufwrd;
char* c = gvid->bufchr;
for(int i = 0; i < len1; i++) {
*p++ = *c++;
*p++ = (byte) *q++;
}
}
if(WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT)
ReadConsoleOutputW(gvid_hout, buf, size, coord, &r);
else
ReadConsoleOutputA(gvid_hout, buf, size, coord, &r);
#elif defined(__UNIX__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
int len1 = ecol-scol+1;
_vsave(buf, len1, srow, scol, erow);
@ -1796,33 +1657,30 @@ static void _vredraw(word* buf, int len1, int srow, int scol, int erow) {
// ------------------------------------------------------------------
// Redraws a previously saved screen
void vredraw(vatch* buf, int __srow, int __scol, int __erow, int __ecol) {
void vrestore(vsavebuf* sbuf, int srow, int scol, int erow, int ecol) {
if(__srow != -1) buf[0] = (vatch)__srow;
if(__scol != -1) buf[1] = (vatch)__scol;
if(__erow != -1) buf[2] = (vatch)__erow;
if(__ecol != -1) buf[3] = (vatch)__ecol;
if(srow != -1) sbuf->top = srow;
if(scol != -1) sbuf->left = scol;
if(erow != -1) sbuf->bottom = erow;
if(ecol != -1) sbuf->right = ecol;
srow = sbuf->top;
scol = sbuf->left;
erow = sbuf->bottom;
ecol = sbuf->right;
vatch *buf = sbuf->data;
#if defined(__USE_NCURSES__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
for(int row=srow; row<=erow; row++)
for(int col=scol; col<=ecol; col++)
mvaddch(row, col, *buf++);
for(int row=srow; row<=erow; row++)
for(int col=scol; col<=ecol; col++)
mvaddch(row, col, *buf++);
refresh();
refresh();
#elif defined(__MSDOS__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
int len1 = ecol-scol+1;
if(gvid->isdma()) {
@ -1850,11 +1708,6 @@ void vredraw(vatch* buf, int __srow, int __scol, int __erow, int __ecol) {
#elif defined(__OS2__)
USHORT srow = *buf++;
USHORT scol = *buf++;
USHORT erow = *buf++;
USHORT ecol = *buf++;
USHORT len1 = (USHORT)(ecol-scol+1);
USHORT len2 = (USHORT)(len1*sizeof(word));
@ -1871,30 +1724,28 @@ void vredraw(vatch* buf, int __srow, int __scol, int __erow, int __ecol) {
#elif defined(__WIN32__)
SHORT srow = *buf++;
SHORT scol = *buf++;
SHORT erow = *buf++;
SHORT ecol = *buf++;
const COORD coord = {0, 0};
COORD size = {ecol-scol+1, erow-srow+1};
SMALL_RECT r;
SHORT len1 = (SHORT)(ecol-scol+1);
// Set the source rectangle.
r.Top = srow;
r.Left = scol;
r.Bottom = erow;
r.Right = ecol;
for(SHORT nrow=srow; nrow<=erow; nrow++) {
vputws(nrow, scol, buf, len1);
buf += len1;
}
if(WinVer.dwPlatformId == VER_PLATFORM_WIN32_NT)
WriteConsoleOutputW(gvid_hout, buf, size, coord, &r);
else
WriteConsoleOutputA(gvid_hout, buf, size, coord, &r);
#elif defined(__UNIX__)
int srow = *buf++;
int scol = *buf++;
int erow = *buf++;
int ecol = *buf++;
int len1 = ecol-scol+1;
_vredraw(buf, len1, srow, scol, erow);
int atr = *buf >> 8;
int atr = vgattr(*buf);
char* color = gvid_newattr(atr);
gvid_printf("%s", color);
@ -1907,15 +1758,6 @@ void vredraw(vatch* buf, int __srow, int __scol, int __erow, int __ecol) {
}
// ------------------------------------------------------------------
// Restores a previously saved screen and frees buffer
void vrestore(vatch* buf, int srow, int scol, int erow, int ecol) {
vredraw(buf, srow, scol, erow, ecol);
}
// ------------------------------------------------------------------
// Sets the cursor shape/size
@ -2282,69 +2124,4 @@ void vfill(int srow, int scol, int erow, int ecol, vchar chr, int atr) {
}
// ------------------------------------------------------------------
// Gets the character part of a character-attribute group
vchar vgchar (vatch chat) {
#if defined(__USE_NCURSES__)
return chat & (A_CHARTEXT | A_ALTCHARSET);
#else
return chat & 0xff;
#endif
}
// ------------------------------------------------------------------
// Gets the attribute part of a character-attribute group
int vgattr (vatch chat) {
#if defined(__USE_NCURSES__)
return gvid_dosattrcalc(chat);
#else
return (chat >> 8) & 0xff;
#endif
}
// ------------------------------------------------------------------
// Sets the given character in a character-attribute group
vatch vschar (vatch chat, vchar chr) {
#if defined(__USE_NCURSES__)
return (chr&(A_CHARTEXT|A_ALTCHARSET))|(chat&~(A_CHARTEXT|A_ALTCHARSET));
#else
return (chat & 0xff00) | chr;
#endif
}
// ------------------------------------------------------------------
// Sets the given attribute in a character-attribute group
vatch vsattr (vatch chat, int atr) {
#if defined(__USE_NCURSES__)
return (chat & (A_CHARTEXT | A_ALTCHARSET)) | gvid_attrcalc(atr);
#else
return (chat & 0xff) | (atr << 8);
#endif
}
// ------------------------------------------------------------------
// Compose character-attribute group from character and attribute
vatch vcatch (vchar chr, int atr) {
#if defined(__USE_NCURSES__)
return chr | gvid_attrcalc(atr);
#else
return (chr & 0xff) | ((atr << 8) & 0xff00) ;
#endif
}
// ------------------------------------------------------------------

28
goldlib/gall/gvidinit.cpp
View File

@ -83,14 +83,8 @@
// ------------------------------------------------------------------
// Global video data
#ifdef __WIN32__
HANDLE gvid_hout;
#endif
GVid *gvid;
int __gdvdetected = false;
#if defined(__USE_NCURSES__)
// add statics here
@ -105,6 +99,14 @@ const char* gvid_acs_disable;
void _vputx(int row, int col, int atr, char chr, uint len);
void gvid_printf(const char* fmt, ...) __attribute__ ((format (printf, 1, 2)));
#elif defined(__WIN32__)
HANDLE gvid_hout = INVALID_HANDLE_VALUE;
#elif defined(__MSDOS__)
int __gdvdetected = false;
#endif
@ -138,12 +140,13 @@ GVid::~GVid() {
endwin();
#elif defined(__UNIX__)
// "\033<" Enter ANSI mode
// "\033[?5l" Normal screen
// "\033[0m" Normal character attributes
gvid_printf("\033<\033[?5l\033[0m");
#endif
#ifndef __DJGPP__
if(dmaptr != dmadir) throw_xfree(dmaptr);
@ -390,12 +393,7 @@ int GVid::detectadapter() {
#elif defined(__WIN32__)
gvid_hout = CreateFile("CONOUT$", GENERIC_READ | GENERIC_WRITE,
FILE_SHARE_WRITE | FILE_SHARE_READ, NULL,
OPEN_EXISTING,
FILE_FLAG_NO_BUFFERING|FILE_FLAG_WRITE_THROUGH, NULL);
SetFileApisToOEM();
gvid_hout = GetStdHandle(STD_OUTPUT_HANDLE);
adapter = V_VGA;
@ -1014,8 +1012,8 @@ void GVid::resize_screen(int columns, int rows) {
numcols = curr.screen.columns = columns;
numrows = curr.screen.rows = rows;
bufchr = (vchar*)throw_xrealloc(bufchr, numcols);
bufwrd = (vatch*)throw_xrealloc(bufwrd, numcols*2);
bufchr = (vchar*)throw_xrealloc(bufchr, numcols+1);
bufwrd = (vatch*)throw_xrealloc(bufwrd, (numcols+1)*sizeof(vatch));
bufansi = (vchar*)throw_xrealloc(bufansi, 1+(11*numcols));
#if defined(__UNIX__) and not defined(__USE_NCURSES__)

4
goldlib/gall/gwinall.h
View File

@ -214,7 +214,7 @@ struct _wrec_t {
_wrec_t* prev; // pointer to previous window record
_wrec_t* next; // pointer to next window record
_form_t* form; // pointer to head form record
vatch* wbuf; // address of window's buffer
vsavebuf* wbuf; // address of window's buffer
vatch* wsbuf; // address of window shadow's buffer
const char* title; // address of window's title string
int whandle; // window's handle
@ -423,8 +423,6 @@ inline int wclear () { return wcclear(gwin.active->wattr); }
inline void wfillch (vchar a) { gwin.fillch=a; }
inline vchar wgetc (int wrow, int wcol) { return vgetc(gwin.active->srow+wrow+gwin.active->border,gwin.active->scol+wcol+gwin.active->border); }
inline int wisactiv (int a) { return a == gwin.active->whandle; }
inline void wrestore (vatch* wbuf) { vrestore(wbuf); }
inline vatch* wsave (int srow, int scol, int erow, int ecol) { return vsave(srow, scol, erow, ecol); }
inline int wsetesc (int a) { int t=gwin.esc; gwin.esc=a; return t; }
inline void wsetstyle (int a) { gwin.style = a; }
inline int wstyle () { return gwin.style; }

13
goldlib/gall/gwinbase.cpp
View File

@ -149,7 +149,7 @@ int wopen(int srow, int scol, int erow, int ecol, int btype, int battr, int watt
}
// save affected area of screen
vatch* wbuf = vsave(srow,scol,erow,ecol);
vsavebuf* wbuf = vsave(srow,scol,erow,ecol);
if(wbuf==NULL) {
throw_xrelease(wrec);
gwin.werrno=W_ALLOCERR;
@ -1003,7 +1003,7 @@ _wrec_t* wfindrec(int whandle) {
int whide() {
vatch* p;
vsavebuf* p;
int shattr;
_wrec_t *temp;
@ -1060,7 +1060,7 @@ int whide() {
int wunhide(int whandle) {
vatch* p;
vsavebuf* p;
_wrec_t* found;
// check pointer to hidden window linked list ; must not be NULL
@ -1238,7 +1238,7 @@ static GOLD_INLINE int rshadow_blocking() {
static GOLD_INLINE vatch* calc_window(_wrec_t *wrec) {
return wrec->wbuf+4+((__crow-wrec->srow)*(wrec->ecol-wrec->scol+1))+(__ccol-wrec->scol);
return wrec->wbuf->data+((__crow-wrec->srow)*(wrec->ecol-wrec->scol+1))+(__ccol-wrec->scol);
}
@ -1273,7 +1273,7 @@ static void swap_contents(vatch* pfound, vatch* pcurr, int shadow) {
temp = vgetw(__crow, __ccol);
if(shadow&2)
*pcurr = vschar(*pcurr, vgchar(temp));
chat = ((vgattr(temp) & 0x80) and shadow) ? vsattr(*pcurr, vgattr(*pcurr | 0x80)) : *pcurr;
chat = ((vgattr(temp) & BLINK) and shadow) ? vsattr(*pcurr, vgattr(*pcurr) | BLINK) : *pcurr;
vputw(__crow, __ccol, chat);
// let window position directly above position
@ -1559,7 +1559,8 @@ static void update_buffers(vatch* pcurr, int shadow) {
if(shadow) {
if(__curr->next==NULL) {
vputc(__crow, __ccol, vgattr(*pcurr)&0x80 ? (__curr->wsattr|BLINK) : __curr->wsattr, (vchar)*pcurr);
// vputc(__crow, __ccol, vgattr(*pcurr) & BLINK ? (__curr->wsattr | BLINK) : __curr->wsattr, vgchar(*pcurr));
vputc(__crow, __ccol, __gattr & BLINK ? (__curr->wsattr | BLINK) : __curr->wsattr, *__p);
}
else {
tcurr = __curr;

1
goldlib/gall/gwindow.h
View File

@ -215,7 +215,6 @@ public:
void drag(int direction, int howmuch=1);
void slide(int row, int col);
void putx(int wrow, int wcol, int color, char chr, uint len);
void printws(int wrow, int wcol, vatch* buf, uint len);
void print_center(int row, int color, const char* text);
};

19
goldlib/gall/gwininit.cpp
View File

@ -137,8 +137,8 @@ int wdrag(int direction) {
int nsrow, nscol, nerow, necol, shad_attr=-1;
int chars_per_line, lines_per_win;
int vert_movement, horz_movement;
vatch* win_image;
vatch* wp;
vsavebuf* win_image;
vsavebuf* wp;
vatch* p;
register vatch* src;
register vatch* dest;
@ -202,18 +202,13 @@ int wdrag(int direction) {
return(gwin.werrno=W_ALLOCERR);
}
// change coordinates in saved window's buffer
// and restore window to new coordinates
win_image[0] = (vatch)nsrow;
win_image[1] = (vatch)nscol;
win_image[2] = (vatch)nerow;
win_image[3] = (vatch)necol;
vrestore(win_image);
// restore window to new coordinates
vrestore(win_image, nsrow, nscol, nerow, necol);
throw_xfree(win_image);
// start buffer positions past coordinates
src = gwin.active->wbuf + 4;
dest = wp + 4;
src = gwin.active->wbuf->data;
dest = wp->data;
if(direction==D_DOWN)
src += chars_per_line;
@ -240,7 +235,7 @@ int wdrag(int direction) {
}
// erase the trail that was left-over
p = gwin.active->wbuf + 4;
p = gwin.active->wbuf->data;
if(vert_movement) {
if(direction==D_DOWN)
fill_row=srow;

4
goldlib/gcfg/gxhpt.cpp
View File

@ -298,11 +298,11 @@ void gareafile::ReadHPTFile(char* path, char* file, char* options, char* origin,
aa.type = GMB_NET;
break;
case CRC_LOCALAREA:
case CRC_DUPEAREA:
case CRC_BADAREA:
aa.type = GMB_LOCAL;
break;
case CRC_ECHOAREA:
case CRC_DUPEAREA:
case CRC_BADAREA:
aa.type = GMB_ECHO;
break;
}

6
goldlib/glibc/glob.c
View File

@ -289,7 +289,7 @@ extern char *alloca ();
static
#if __GNUC__ - 0 >= 2
inline
__inline__
#endif
const char *next_brace_sub __P ((const char *begin));
static int glob_in_dir __P ((const char *pattern, const char *directory,
@ -304,7 +304,7 @@ static int collated_compare __P ((const __ptr_t, const __ptr_t));
this as an inline function if the compiler permits. */
static
#if __GNUC__ - 0 >= 2
inline
__inline__
#endif
const char *
next_brace_sub (begin)
@ -386,7 +386,7 @@ glob (pattern, flags, errfunc, pglob)
const char *rest;
size_t rest_len;
#ifdef __GNUC__
char onealt[strlen (pattern) - 1];
__extension__ char onealt[strlen (pattern) - 1];
#else
char *onealt = (char *) malloc (strlen (pattern) - 1);
if (onealt == NULL)

4
goldlib/uulib/uuencode.c
View File

@ -235,8 +235,8 @@ char *uuestr_otemp;
static int
UUEncodeStream (FILE *outfile, FILE *infile, int encoding, long linperfile)
{
unsigned char *itemp = (char *) uuestr_itemp;
unsigned char *otemp = (char *) uuestr_otemp;
unsigned char *itemp = (unsigned char *) uuestr_itemp;
unsigned char *otemp = (unsigned char *) uuestr_otemp;
unsigned char *optr, *table, *tptr;
int index, count;
long line=0;