/contrib/sdk/sources/PDCurses/README.md |
---|
0,0 → 1,65 |
Welcome to PDCurses! |
==================== |
PDCurses is an implementation of X/Open curses for multiple platforms. |
The latest version can be found at: |
https://pdcurses.org/ |
For changes, see the [History] file. The main documentation is now in |
the [docs] directory. |
Legal Stuff |
----------- |
The core package is in the public domain, but small portions of PDCurses |
are subject to copyright under various licenses. Each directory |
contains a README.md file, with a section titled "Distribution Status" |
which describes the status of the files in that directory. |
If you use PDCurses in an application, an acknowledgement would be |
appreciated, but is not mandatory. If you make corrections or |
enhancements to PDCurses, please forward them to the current maintainer |
for the benefit of other users. |
This software is provided AS IS with NO WARRANTY whatsoever. |
Ports |
----- |
PDCurses has been ported to DOS, OS/2, Windows, X11 and SDL. A directory |
containing the port-specific source files exists for each of these |
platforms. |
Build instructions are in the README.md file for each platform: |
- [DOS] |
- [OS/2] |
- [SDL 1.x] |
- [SDL 2.x] |
- [Windows] |
- [X11] |
Distribution Status |
------------------- |
All files in this directory (not including subdirectories) are released |
to the public domain. |
Maintainer |
---------- |
William McBrine <wmcbrine@gmail.com> |
[History]: docs/HISTORY.md |
[docs]: docs/README.md |
[DOS]: dos/README.md |
[OS/2]: os2/README.md |
[SDL 1.x]: sdl1/README.md |
[SDL 2.x]: sdl2/README.md |
[Windows]: wincon/README.md |
[X11]: x11/README.md |
/contrib/sdk/sources/PDCurses/Tupfile.lua |
---|
0,0 → 1,60 |
if tup.getconfig("NO_GCC") ~= "" then return end |
HELPERDIR = (tup.getconfig("HELPERDIR") == "") and "../../../../programs" or tup.getconfig("HELPERDIR") |
tup.include(HELPERDIR .. "/use_gcc.lua") |
tup.include(HELPERDIR .. "/use_newlib.lua") |
CFLAGS = " -c -fno-ident -O2 -fomit-frame-pointer -fno-ident -U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -D_KOLIBRI -DSDL_strlcpy=strncpy " |
INCLUDES = INCLUDES .. " -I. " .. "-I ../SDL-1.2.2_newlib/include " |
compile_gcc { |
"sdl1/pdcclip.c", |
"sdl1/pdcgetsc.c", |
"sdl1/pdcscrn.c", |
"sdl1/pdcsetsc.c", |
"sdl1/pdcdisp.c", |
"sdl1/pdckbd.c", |
"sdl1/pdcutil.c", |
"pdcurses/addstr.c", |
"pdcurses/move.c", |
"pdcurses/attr.c", |
"pdcurses/panel.c", |
"pdcurses/initscr.c", |
"pdcurses/slk.c", |
"pdcurses/inopts.c", |
"pdcurses/keyname.c", |
"pdcurses/clear.c", |
"pdcurses/touch.c", |
"pdcurses/refresh.c", |
"pdcurses/window.c", |
"pdcurses/delch.c", |
"pdcurses/beep.c", |
"pdcurses/mouse.c", |
"pdcurses/inchstr.c", |
"pdcurses/overlay.c", |
"pdcurses/deleteln.c", |
"pdcurses/termattr.c", |
"pdcurses/kernel.c", |
"pdcurses/inch.c", |
"pdcurses/getstr.c", |
"pdcurses/getch.c", |
"pdcurses/scroll.c", |
"pdcurses/border.c", |
"pdcurses/scr_dump.c", |
"pdcurses/pad.c", |
"pdcurses/addch.c", |
"pdcurses/insstr.c", |
"pdcurses/scanw.c", |
"pdcurses/outopts.c", |
"pdcurses/insch.c", |
"pdcurses/color.c", |
"pdcurses/printw.c", |
"pdcurses/instr.c", |
"pdcurses/bkgd.c", |
"pdcurses/getyx.c", |
"pdcurses/util.c", |
"pdcurses/addchstr.c", |
"pdcurses/debug.c", |
} |
tup.rule(OBJS, "kos32-ar -rcs %o %f", "../../lib/libcurses.a", OBJS) |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/PDCurses/common/README.md |
---|
0,0 → 1,11 |
PDCurses common files |
===================== |
This directory is for files which are platform-specific, yet shared by |
more than one platform, in contrast to the "common core" in ../pdcurses. |
Distribution Status |
------------------- |
The files in this directory are released to the public domain. |
/contrib/sdk/sources/PDCurses/common/acs437.h |
---|
0,0 → 1,35 |
/* ACS definitions originally by jshumate@wrdis01.robins.af.mil -- these |
match code page 437 and compatible pages (CP850, CP852, etc.) */ |
chtype acs_map[128] = |
{ |
PDC_ACS(0), PDC_ACS(1), PDC_ACS(2), PDC_ACS(3), PDC_ACS(4), |
PDC_ACS(5), PDC_ACS(6), PDC_ACS(7), PDC_ACS(8), PDC_ACS(9), |
PDC_ACS(10), PDC_ACS(11), PDC_ACS(12), PDC_ACS(13), PDC_ACS(14), |
PDC_ACS(15), PDC_ACS(16), PDC_ACS(17), PDC_ACS(18), PDC_ACS(19), |
PDC_ACS(20), PDC_ACS(21), PDC_ACS(22), PDC_ACS(23), PDC_ACS(24), |
PDC_ACS(25), PDC_ACS(26), PDC_ACS(27), PDC_ACS(28), PDC_ACS(29), |
PDC_ACS(30), PDC_ACS(31), ' ', '!', '"', '#', '$', '%', '&', '\'', |
'(', ')', '*', |
PDC_ACS(0x1a), PDC_ACS(0x1b), PDC_ACS(0x18), PDC_ACS(0x19), |
'/', |
0xdb, |
'1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', |
'>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', |
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', |
'X', 'Y', 'Z', '[', '\\', ']', '^', '_', |
PDC_ACS(0x04), 0xb1, |
'b', 'c', 'd', 'e', |
0xf8, 0xf1, 0xb0, PDC_ACS(0x0f), 0xd9, 0xbf, 0xda, 0xc0, 0xc5, 0x2d, |
0x2d, 0xc4, 0x2d, 0x5f, 0xc3, 0xb4, 0xc1, 0xc2, 0xb3, 0xf3, 0xf2, |
0xe3, 0xd8, 0x9c, 0xf9, |
PDC_ACS(127) |
}; |
/contrib/sdk/sources/PDCurses/common/acsgr.h |
---|
0,0 → 1,35 |
/* ACS Unicode mapping with punchouts for box characters et al. */ |
chtype acs_map[128] = |
{ |
PDC_ACS(0), PDC_ACS(1), PDC_ACS(2), PDC_ACS(3), PDC_ACS(4), |
PDC_ACS(5), PDC_ACS(6), PDC_ACS(7), PDC_ACS(8), PDC_ACS(9), |
PDC_ACS(10), PDC_ACS(11), PDC_ACS(12), PDC_ACS(13), PDC_ACS(14), |
PDC_ACS(15), PDC_ACS(16), PDC_ACS(17), PDC_ACS(18), PDC_ACS(19), |
PDC_ACS(20), PDC_ACS(21), PDC_ACS(22), PDC_ACS(23), PDC_ACS(24), |
PDC_ACS(25), PDC_ACS(26), PDC_ACS(27), PDC_ACS(28), PDC_ACS(29), |
PDC_ACS(30), PDC_ACS(31), ' ', '!', '"', '#', '$', '%', '&', '\'', |
'(', ')', '*', |
0x2192, 0x2190, 0x2191, 0x2193, |
'/', |
ACS_BLOCK, |
'1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', |
'>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', |
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', |
'X', 'Y', 'Z', '[', '\\', ']', '^', '_', |
0x2666, 0x2592, |
'b', 'c', 'd', 'e', |
0x00b0, 0x00b1, 0x2591, 0x00a4, ACS_LRCORNER, ACS_URCORNER, |
ACS_ULCORNER, ACS_LLCORNER, ACS_PLUS, ACS_S1, ACS_S3, ACS_HLINE, |
ACS_S7, ACS_S9, ACS_LTEE, ACS_RTEE, ACS_BTEE, ACS_TTEE, ACS_VLINE, |
0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, 0x00b7, |
PDC_ACS(127) |
}; |
/contrib/sdk/sources/PDCurses/common/acsuni.h |
---|
0,0 → 1,35 |
/* ACS Unicode mapping */ |
chtype acs_map[128] = |
{ |
PDC_ACS(0), PDC_ACS(1), PDC_ACS(2), PDC_ACS(3), PDC_ACS(4), |
PDC_ACS(5), PDC_ACS(6), PDC_ACS(7), PDC_ACS(8), PDC_ACS(9), |
PDC_ACS(10), PDC_ACS(11), PDC_ACS(12), PDC_ACS(13), PDC_ACS(14), |
PDC_ACS(15), PDC_ACS(16), PDC_ACS(17), PDC_ACS(18), PDC_ACS(19), |
PDC_ACS(20), PDC_ACS(21), PDC_ACS(22), PDC_ACS(23), PDC_ACS(24), |
PDC_ACS(25), PDC_ACS(26), PDC_ACS(27), PDC_ACS(28), PDC_ACS(29), |
PDC_ACS(30), PDC_ACS(31), ' ', '!', '"', '#', '$', '%', '&', '\'', |
'(', ')', '*', |
0x2192, 0x2190, 0x2191, 0x2193, |
'/', |
0x2588, |
'1', '2', '3', '4', '5', '6', '7', '8', '9', ':', ';', '<', '=', |
'>', '?', '@', 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', |
'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', |
'X', 'Y', 'Z', '[', '\\', ']', '^', '_', |
0x2666, 0x2592, |
'b', 'c', 'd', 'e', |
0x00b0, 0x00b1, 0x2591, 0x00a4, 0x2518, 0x2510, 0x250c, 0x2514, |
0x253c, 0x23ba, 0x23bb, 0x2500, 0x23bc, 0x23bd, 0x251c, 0x2524, |
0x2534, 0x252c, 0x2502, 0x2264, 0x2265, 0x03c0, 0x2260, 0x00a3, |
0x00b7, |
PDC_ACS(127) |
}; |
/contrib/sdk/sources/PDCurses/common/borland.lrf |
---|
0,0 → 1,9 |
+addch.obj +addchstr.obj +addstr.obj +attr.obj +beep.obj +bkgd.obj & |
+border.obj +clear.obj +color.obj +delch.obj +deleteln.obj & |
+getch.obj +getstr.obj +getyx.obj +inch.obj +inchstr.obj +initscr.obj & |
+inopts.obj +insch.obj +insstr.obj +instr.obj +kernel.obj +keyname.obj & |
+mouse.obj +move.obj +outopts.obj +overlay.obj +pad.obj +panel.obj & |
+printw.obj +refresh.obj +scanw.obj +scr_dump.obj +scroll.obj +slk.obj & |
+termattr.obj +touch.obj +util.obj +window.obj +debug.obj & |
+pdcclip.obj +pdcdisp.obj +pdcgetsc.obj +pdckbd.obj +pdcscrn.obj & |
+pdcsetsc.obj +pdcutil.obj ,lib.map |
/contrib/sdk/sources/PDCurses/common/font437.h |
---|
0,0 → 1,386 |
/* Default font for SDL (narrow build) -- this is simply a 256x128x1 |
BMP, in #include'able form. The font is 8x16, code page 437, and is |
based on the pc8x16s.bdf font from the vgafonts.tar.gz package, by |
"Myrlin". */ |
unsigned char font437[] = |
{ |
0x42, 0x4d, 0x3e, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, |
0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, |
0x80, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x10, 0x00, 0x00, 0x12, 0x0b, 0x00, 0x00, 0x12, 0x0b, |
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, |
0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x60, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x18, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x76, 0xf8, 0xc0, 0x6c, 0xfe, 0x70, 0x7c, 0x18, |
0x7e, 0x38, 0xee, 0x3c, 0x00, 0xc0, 0x1c, 0xc6, 0x00, 0x7e, 0x7e, |
0x7e, 0x18, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1c, 0x00, 0x00, |
0x00, 0x00, 0xdc, 0xcc, 0xc0, 0x6c, 0xc6, 0xd8, 0x66, 0x18, 0x18, |
0x6c, 0x6c, 0x66, 0x00, 0x60, 0x30, 0xc6, 0xfe, 0x00, 0x00, 0x00, |
0x18, 0xd8, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3c, 0x00, 0x00, 0x7e, |
0x00, 0xd8, 0xcc, 0xc0, 0x6c, 0x60, 0xd8, 0x66, 0x18, 0x3c, 0xc6, |
0x6c, 0x66, 0x7e, 0x7e, 0x60, 0xc6, 0x00, 0x00, 0x30, 0x0c, 0x18, |
0xd8, 0x18, 0xdc, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x7e, 0x00, |
0xd8, 0xcc, 0xc0, 0x6c, 0x30, 0xd8, 0x66, 0x18, 0x66, 0xc6, 0x6c, |
0x66, 0xdb, 0xf3, 0x60, 0xc6, 0x00, 0x18, 0x18, 0x18, 0x18, 0x18, |
0x00, 0x76, 0x00, 0x18, 0x00, 0x6c, 0x00, 0x00, 0x7e, 0x00, 0xd8, |
0xc8, 0xc0, 0x6c, 0x18, 0xd8, 0x66, 0x18, 0x66, 0xc6, 0x6c, 0x66, |
0xdb, 0xdb, 0x60, 0xc6, 0xfe, 0x18, 0x0c, 0x30, 0x18, 0x18, 0x7e, |
0x00, 0x00, 0x18, 0x18, 0xec, 0x00, 0x00, 0x7e, 0x00, 0xdc, 0xdc, |
0xc0, 0x6c, 0x18, 0xd8, 0x66, 0x18, 0x66, 0xfe, 0xc6, 0x3e, 0xdb, |
0xdb, 0x7c, 0xc6, 0x00, 0x7e, 0x06, 0x60, 0x18, 0x18, 0x00, 0xdc, |
0x00, 0x00, 0x00, 0x0c, 0x36, 0x7e, 0x7e, 0x00, 0x76, 0xce, 0xc0, |
0xfe, 0x30, 0x7e, 0x66, 0xdc, 0x66, 0xc6, 0xc6, 0x0c, 0x7e, 0x7e, |
0x60, 0xc6, 0x00, 0x18, 0x0c, 0x30, 0x18, 0x18, 0x18, 0x76, 0x00, |
0x00, 0x00, 0x0c, 0x36, 0x32, 0x7e, 0x00, 0x00, 0xc6, 0xc6, 0x00, |
0x60, 0x00, 0x00, 0x76, 0x3c, 0xc6, 0xc6, 0x18, 0x00, 0x06, 0x60, |
0xc6, 0xfe, 0x18, 0x18, 0x18, 0x1b, 0x18, 0x00, 0x00, 0x38, 0x00, |
0x00, 0x0c, 0x36, 0x18, 0x7e, 0x00, 0x00, 0xce, 0xc6, 0x00, 0xc6, |
0x00, 0x00, 0x00, 0x18, 0x6c, 0x6c, 0x30, 0x00, 0x03, 0x30, 0x7c, |
0x00, 0x00, 0x30, 0x0c, 0x1b, 0x18, 0x00, 0x00, 0x6c, 0x00, 0x00, |
0x0c, 0x36, 0x0c, 0x00, 0x00, 0x00, 0x7c, 0xfe, 0x00, 0xfe, 0x00, |
0x00, 0x00, 0x7e, 0x38, 0x38, 0x1e, 0x00, 0x00, 0x1c, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x0e, 0x18, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x0c, |
0x36, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x38, 0x00, 0x00, 0x0f, 0x6c, |
0x3c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x36, 0x00, |
0x36, 0x00, 0x36, 0x36, 0x00, 0x36, 0x00, 0x00, 0x18, 0x36, 0x00, |
0x00, 0x18, 0x36, 0x36, 0x18, 0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, |
0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x36, 0x00, 0x36, |
0x00, 0x36, 0x36, 0x00, 0x36, 0x00, 0x00, 0x18, 0x36, 0x00, 0x00, |
0x18, 0x36, 0x36, 0x18, 0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, |
0x00, 0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x36, 0x00, 0x36, 0x00, |
0x36, 0x36, 0x00, 0x36, 0x00, 0x00, 0x18, 0x36, 0x00, 0x00, 0x18, |
0x36, 0x36, 0x18, 0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, 0x00, |
0x00, 0x18, 0x18, 0x00, 0x18, 0x18, 0x36, 0x00, 0x36, 0x00, 0x36, |
0x36, 0x00, 0x36, 0x00, 0x00, 0x18, 0x36, 0x00, 0x00, 0x18, 0x36, |
0x36, 0x18, 0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, 0x00, 0x00, |
0x18, 0x18, 0x00, 0x18, 0x18, 0x36, 0x00, 0x36, 0x00, 0x36, 0x36, |
0x00, 0x36, 0x00, 0x00, 0x18, 0x36, 0x00, 0x00, 0x18, 0x36, 0x36, |
0x18, 0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x18, |
0x18, 0x00, 0x18, 0x18, 0x36, 0x00, 0x36, 0x00, 0x36, 0x36, 0x00, |
0x36, 0x00, 0x00, 0x18, 0x36, 0x00, 0x00, 0x18, 0x36, 0x36, 0x18, |
0x00, 0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x18, 0x18, |
0x00, 0x18, 0x18, 0x36, 0x00, 0x36, 0x00, 0x36, 0x36, 0x00, 0x36, |
0x00, 0x00, 0x18, 0x36, 0x00, 0x00, 0x18, 0x36, 0x36, 0x18, 0x00, |
0x18, 0xff, 0xff, 0xf0, 0x0f, 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, |
0x18, 0x18, 0x36, 0x00, 0x36, 0x00, 0x36, 0x36, 0x00, 0x36, 0x00, |
0x00, 0x18, 0x36, 0x00, 0x00, 0x18, 0x36, 0x36, 0x18, 0x00, 0x18, |
0xff, 0xff, 0xf0, 0x0f, 0x00, 0x1f, 0xff, 0xff, 0x1f, 0xff, 0xff, |
0x1f, 0x37, 0x3f, 0x37, 0xff, 0xf7, 0x37, 0xff, 0xf7, 0xff, 0xff, |
0xff, 0xff, 0x3f, 0x1f, 0x1f, 0x3f, 0xff, 0xff, 0xf8, 0x1f, 0xff, |
0xff, 0xf0, 0x0f, 0x00, 0x18, 0x18, 0x00, 0x18, 0x00, 0x18, 0x18, |
0x36, 0x30, 0x30, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x36, 0x00, |
0x00, 0x36, 0x18, 0x18, 0x00, 0x36, 0x18, 0x18, 0x00, 0xff, 0x00, |
0xf0, 0x0f, 0xff, 0x18, 0x18, 0x00, 0x18, 0x00, 0x18, 0x1f, 0x36, |
0x37, 0x3f, 0xf7, 0xff, 0x37, 0xff, 0xf7, 0xff, 0x36, 0xff, 0x00, |
0x36, 0x1f, 0x1f, 0x00, 0x36, 0xff, 0x18, 0x00, 0xff, 0x00, 0xf0, |
0x0f, 0xff, 0x18, 0x18, 0x00, 0x18, 0x00, 0x18, 0x18, 0x36, 0x36, |
0x00, 0x36, 0x00, 0x36, 0x00, 0x36, 0x18, 0x36, 0x00, 0x00, 0x36, |
0x18, 0x00, 0x00, 0x36, 0x18, 0x18, 0x00, 0xff, 0x00, 0xf0, 0x0f, |
0xff, 0x18, 0x18, 0x00, 0x18, 0x00, 0x18, 0x18, 0x36, 0x36, 0x00, |
0x36, 0x00, 0x36, 0x00, 0x36, 0x18, 0x36, 0x00, 0x00, 0x36, 0x18, |
0x00, 0x00, 0x36, 0x18, 0x18, 0x00, 0xff, 0x00, 0xf0, 0x0f, 0xff, |
0x18, 0x18, 0x00, 0x18, 0x00, 0x18, 0x18, 0x36, 0x36, 0x00, 0x36, |
0x00, 0x36, 0x00, 0x36, 0x18, 0x36, 0x00, 0x00, 0x36, 0x18, 0x00, |
0x00, 0x36, 0x18, 0x18, 0x00, 0xff, 0x00, 0xf0, 0x0f, 0xff, 0x18, |
0x18, 0x00, 0x18, 0x00, 0x18, 0x18, 0x36, 0x36, 0x00, 0x36, 0x00, |
0x36, 0x00, 0x36, 0x18, 0x36, 0x00, 0x00, 0x36, 0x18, 0x00, 0x00, |
0x36, 0x18, 0x18, 0x00, 0xff, 0x00, 0xf0, 0x0f, 0xff, 0x18, 0x18, |
0x00, 0x18, 0x00, 0x18, 0x18, 0x36, 0x36, 0x00, 0x36, 0x00, 0x36, |
0x00, 0x36, 0x18, 0x36, 0x00, 0x00, 0x36, 0x18, 0x00, 0x00, 0x36, |
0x18, 0x18, 0x00, 0xff, 0x00, 0xf0, 0x0f, 0xff, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x44, 0xaa, 0x77, 0x18, 0x18, 0x18, 0x36, 0x36, 0x18, |
0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x11, 0x55, 0xdd, 0x18, 0x18, 0x18, 0x36, 0x36, 0x18, 0x36, |
0x36, 0x36, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, 0x06, 0x00, 0x00, 0x00, |
0x44, 0xaa, 0x77, 0x18, 0x18, 0x18, 0x36, 0x36, 0x18, 0x36, 0x36, |
0x36, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x06, 0x00, 0x00, 0x00, 0x11, |
0x55, 0xdd, 0x18, 0x18, 0x18, 0x36, 0x36, 0x18, 0x36, 0x36, 0x36, |
0x00, 0x00, 0x00, 0x18, 0x76, 0x18, 0x7c, 0x78, 0x66, 0xc6, 0x00, |
0x00, 0x7c, 0x00, 0x00, 0x0c, 0x3f, 0x18, 0x00, 0x00, 0x44, 0xaa, |
0x77, 0x18, 0x18, 0x18, 0x36, 0x36, 0x18, 0x36, 0x36, 0x36, 0x00, |
0x00, 0x00, 0x18, 0xcc, 0x18, 0xc6, 0xcc, 0x66, 0xc6, 0x00, 0x00, |
0xc6, 0xc0, 0x06, 0x86, 0x9a, 0x3c, 0x00, 0x00, 0x11, 0x55, 0xdd, |
0x18, 0x18, 0x18, 0x36, 0x36, 0x18, 0x36, 0x36, 0x36, 0x00, 0x00, |
0x00, 0x18, 0xcc, 0x18, 0xc6, 0xcc, 0x66, 0xc6, 0x00, 0x00, 0xc6, |
0xc0, 0x06, 0xdc, 0xce, 0x3c, 0x36, 0xd8, 0x44, 0xaa, 0x77, 0x18, |
0x18, 0x18, 0x36, 0x36, 0x18, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, |
0x18, 0xcc, 0x18, 0xc6, 0xcc, 0x66, 0xce, 0x00, 0x00, 0xc0, 0xc0, |
0x06, 0x60, 0x66, 0x3c, 0x6c, 0x6c, 0x11, 0x55, 0xdd, 0x18, 0x18, |
0x18, 0x36, 0x36, 0x18, 0x36, 0x36, 0x36, 0x00, 0x00, 0x00, 0x18, |
0x7c, 0x18, 0xc6, 0xcc, 0x66, 0xde, 0x7e, 0x7c, 0x60, 0xc0, 0x06, |
0x30, 0x30, 0x18, 0xd8, 0x36, 0x44, 0xaa, 0x77, 0x18, 0xf8, 0xf8, |
0xf6, 0xfe, 0xf8, 0xf6, 0x36, 0xf6, 0xfe, 0xfe, 0xf8, 0xf8, 0x0c, |
0x18, 0xc6, 0xcc, 0x66, 0xfe, 0x00, 0x00, 0x30, 0xfe, 0xfe, 0x18, |
0x18, 0x18, 0x6c, 0x6c, 0x11, 0x55, 0xdd, 0x18, 0x18, 0x18, 0x36, |
0x00, 0x18, 0x06, 0x36, 0x06, 0x06, 0x36, 0x18, 0x00, 0x78, 0x38, |
0x7c, 0xcc, 0x5c, 0xf6, 0x3e, 0x38, 0x30, 0x00, 0x00, 0x6c, 0x6c, |
0x18, 0x36, 0xd8, 0x44, 0xaa, 0x77, 0x18, 0x18, 0xf8, 0x36, 0x00, |
0xf8, 0xf6, 0x36, 0xfe, 0xf6, 0x36, 0xf8, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0xe6, 0x6c, 0x6c, 0x00, 0x00, 0x00, 0x66, 0x66, 0x00, |
0x00, 0x00, 0x11, 0x55, 0xdd, 0x18, 0x18, 0x18, 0x36, 0x00, 0x00, |
0x36, 0x36, 0x00, 0x36, 0x36, 0x18, 0x00, 0x60, 0x30, 0x60, 0x60, |
0xdc, 0xc6, 0x6c, 0x6c, 0x30, 0x00, 0x00, 0x62, 0x62, 0x18, 0x00, |
0x00, 0x44, 0xaa, 0x77, 0x18, 0x18, 0x18, 0x36, 0x00, 0x00, 0x36, |
0x36, 0x00, 0x36, 0x36, 0x18, 0x00, 0x30, 0x18, 0x30, 0x30, 0x76, |
0x00, 0x3c, 0x38, 0x30, 0x00, 0x00, 0xe0, 0xe0, 0x18, 0x00, 0x00, |
0x11, 0x55, 0xdd, 0x18, 0x18, 0x18, 0x36, 0x00, 0x00, 0x36, 0x36, |
0x00, 0x36, 0x36, 0x18, 0x00, 0x18, 0x0c, 0x18, 0x18, 0x00, 0xdc, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x60, 0x60, 0x00, 0x00, 0x00, 0x44, |
0xaa, 0x77, 0x18, 0x18, 0x18, 0x36, 0x00, 0x00, 0x36, 0x36, 0x00, |
0x36, 0x36, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x11, 0x55, |
0xdd, 0x18, 0x18, 0x18, 0x36, 0x00, 0x00, 0x36, 0x36, 0x00, 0x36, |
0x36, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x70, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, |
0x78, 0x7c, 0x76, 0x76, 0x76, 0x76, 0x7c, 0x7c, 0x7c, 0x7c, 0x18, |
0x18, 0x18, 0xc6, 0xc6, 0xfc, 0x6e, 0xce, 0x7c, 0x7c, 0x7c, 0x78, |
0x78, 0x76, 0x7c, 0x7c, 0x18, 0xfe, 0x18, 0xc6, 0x70, 0x3c, 0xcc, |
0xc2, 0xcc, 0xcc, 0xcc, 0xcc, 0xc6, 0xc2, 0xc2, 0xc2, 0x18, 0x18, |
0x18, 0xc6, 0xc6, 0xc0, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xcc, |
0xce, 0xc6, 0xc6, 0x18, 0x60, 0x7e, 0xcc, 0xd8, 0x66, 0xcc, 0xc0, |
0xcc, 0xcc, 0xcc, 0xcc, 0xc0, 0xc0, 0xc0, 0xc0, 0x18, 0x18, 0x18, |
0xc6, 0xc6, 0xc0, 0xd8, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xcc, 0xc6, |
0xc6, 0xc6, 0x7c, 0x60, 0x18, 0xcc, 0x18, 0xc6, 0xcc, 0xc0, 0xcc, |
0xcc, 0xcc, 0xcc, 0xc0, 0xc0, 0xc0, 0xc0, 0x18, 0x18, 0x18, 0xfe, |
0xc6, 0xc0, 0x7e, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xcc, 0xc6, 0xc6, |
0xc6, 0xc6, 0x60, 0x7e, 0xcc, 0x18, 0xc0, 0xcc, 0xfe, 0x7c, 0x7c, |
0x7c, 0x7c, 0xc0, 0xfe, 0xfe, 0xfe, 0x18, 0x18, 0x18, 0xc6, 0xfe, |
0xf0, 0x36, 0xcc, 0xc6, 0xc6, 0xc6, 0xcc, 0xcc, 0xc6, 0xc6, 0xc6, |
0xc0, 0x60, 0x18, 0xde, 0x18, 0xc0, 0xcc, 0xc6, 0x0c, 0x0c, 0x0c, |
0x0c, 0xc6, 0xc6, 0xc6, 0xc6, 0x18, 0x18, 0x18, 0xc6, 0xc6, 0xc0, |
0x36, 0xfe, 0xc6, 0xc6, 0xc6, 0xcc, 0xcc, 0xc6, 0xc6, 0xc6, 0xc0, |
0xf8, 0x3c, 0xcc, 0x7e, 0xc0, 0xcc, 0x7c, 0x78, 0x78, 0x78, 0x78, |
0x7c, 0x7c, 0x7c, 0x7c, 0x38, 0x38, 0x38, 0x6c, 0x6c, 0xc0, 0xec, |
0xcc, 0x7c, 0x7c, 0x7c, 0xcc, 0xcc, 0xc6, 0xc6, 0xc6, 0xc0, 0x60, |
0x66, 0xc4, 0x18, 0x66, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x38, 0xc0, 0x00, 0xcc, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0x60, 0x66, |
0xf8, 0x18, 0x3c, 0xcc, 0x30, 0x6c, 0x00, 0x18, 0x38, 0x00, 0x6c, |
0x00, 0x18, 0x00, 0x66, 0x18, 0x10, 0x10, 0xfc, 0x00, 0x6c, 0x6c, |
0x00, 0x18, 0xcc, 0x18, 0x00, 0x7c, 0xc6, 0x7c, 0x62, 0x66, 0xcc, |
0x18, 0x00, 0xcc, 0x18, 0x38, 0xcc, 0x30, 0x6c, 0x00, 0x38, 0xc6, |
0x30, 0x66, 0x3c, 0x30, 0x00, 0x38, 0x00, 0x00, 0x3e, 0x38, 0xc6, |
0x30, 0x78, 0x30, 0xc6, 0x00, 0x00, 0x18, 0x3c, 0x66, 0xcc, 0x1b, |
0x00, 0x00, 0x0c, 0x10, 0x00, 0x60, 0x38, 0x00, 0x10, 0x00, 0x60, |
0x00, 0x18, 0x60, 0xc6, 0x6c, 0x30, 0x00, 0x00, 0x10, 0x00, 0x60, |
0x30, 0x60, 0x00, 0xc6, 0xc6, 0x18, 0x00, 0x00, 0xf8, 0x0e, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x38, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x78, 0x00, 0x00, 0x78, 0x00, 0x00, 0x00, |
0x00, 0x00, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x8c, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x00, |
0x00, 0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x8c, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x0c, 0x00, 0x00, 0xcc, 0x00, 0x00, 0x00, 0x00, 0x00, |
0xc0, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x76, 0xf8, 0x78, 0x7c, 0x7c, |
0x30, 0x7c, 0xcc, 0x18, 0x0c, 0xcc, 0x18, 0xc6, 0xcc, 0x78, 0xf8, |
0x7c, 0xc0, 0x7c, 0x30, 0x78, 0x10, 0x6c, 0xc6, 0x76, 0xfe, 0x0e, |
0x18, 0x70, 0x00, 0x00, 0x00, 0xcc, 0xcc, 0xc4, 0xcc, 0xc2, 0x30, |
0xcc, 0xcc, 0x18, 0x0c, 0xcc, 0x18, 0xd6, 0xcc, 0xcc, 0xcc, 0xcc, |
0xc0, 0x86, 0x30, 0xcc, 0x6c, 0xfe, 0x6c, 0xce, 0xc0, 0x18, 0x18, |
0x18, 0x00, 0xfe, 0x00, 0xcc, 0xcc, 0xc0, 0xcc, 0xc0, 0x30, 0xcc, |
0xcc, 0x18, 0x0c, 0xd8, 0x18, 0xd6, 0xcc, 0xcc, 0xcc, 0xcc, 0xc0, |
0x06, 0x30, 0xcc, 0xc6, 0xd6, 0x38, 0xc6, 0x60, 0x18, 0x18, 0x18, |
0x00, 0xc6, 0x00, 0xcc, 0xcc, 0xc0, 0xcc, 0xc0, 0x30, 0xcc, 0xcc, |
0x18, 0x0c, 0xf0, 0x18, 0xd6, 0xcc, 0xcc, 0xcc, 0xcc, 0xc0, 0x1c, |
0x30, 0xcc, 0xc6, 0xd6, 0x38, 0xc6, 0x30, 0x18, 0x18, 0x18, 0x00, |
0xc6, 0x00, 0x7c, 0xcc, 0xc0, 0xcc, 0xfe, 0x30, 0xcc, 0xcc, 0x18, |
0x0c, 0xf0, 0x18, 0xd6, 0xcc, 0xcc, 0xcc, 0xcc, 0xcc, 0x70, 0x30, |
0xcc, 0xc6, 0xd6, 0x38, 0xc6, 0x18, 0x18, 0x18, 0x18, 0x00, 0xc6, |
0x00, 0x0c, 0xcc, 0xc4, 0xcc, 0xc6, 0x78, 0xcc, 0xec, 0x18, 0x0c, |
0xd8, 0x18, 0xfe, 0xcc, 0xcc, 0xcc, 0xcc, 0xec, 0xc2, 0x30, 0xcc, |
0xc6, 0xc6, 0x6c, 0xc6, 0x0c, 0x70, 0x18, 0x0e, 0x00, 0x6c, 0x00, |
0x78, 0xf8, 0x78, 0x7c, 0x7c, 0x30, 0x7c, 0xd8, 0x38, 0x0c, 0xcc, |
0x18, 0xec, 0xb8, 0x78, 0xf8, 0x7c, 0xb8, 0x7c, 0xfc, 0xcc, 0xc6, |
0xc6, 0xc6, 0xc6, 0xfe, 0x18, 0x18, 0x18, 0x00, 0x38, 0x00, 0x00, |
0xc0, 0x00, 0x0c, 0x00, 0x32, 0x00, 0xc0, 0x00, 0x00, 0xc0, 0x18, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x18, 0x18, 0x18, 0x00, 0x10, 0x0c, 0x00, 0xc0, |
0x00, 0x0c, 0x00, 0x36, 0x00, 0xc0, 0x18, 0x0c, 0xc0, 0x18, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x18, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00, 0xc0, 0x00, |
0x0c, 0x00, 0x1c, 0x00, 0xc0, 0x18, 0x0c, 0xc0, 0x38, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x0e, 0x18, 0x70, 0xdc, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x7c, 0xc6, 0xfc, 0x3c, 0xf8, 0xfc, 0xc0, 0x3e, 0xc6, 0x18, 0x78, |
0xc2, 0xfc, 0xc6, 0xc6, 0x7c, 0xc0, 0x7c, 0xc6, 0x7c, 0x18, 0x7c, |
0x10, 0x6c, 0xc6, 0x18, 0xfe, 0x3c, 0x02, 0x3c, 0x00, 0x00, 0xc0, |
0xc6, 0xc6, 0x66, 0xdc, 0xc0, 0xc0, 0x66, 0xc6, 0x18, 0xcc, 0xc6, |
0xc0, 0xc6, 0xc6, 0xc6, 0xc0, 0xde, 0xc6, 0x86, 0x18, 0xc6, 0x38, |
0xee, 0xc6, 0x18, 0xc0, 0x30, 0x06, 0x0c, 0x00, 0x00, 0xdc, 0xc6, |
0xc6, 0xc2, 0xce, 0xc0, 0xc0, 0xc6, 0xc6, 0x18, 0xcc, 0xcc, 0xc0, |
0xc6, 0xc6, 0xc6, 0xc0, 0xd6, 0xcc, 0x06, 0x18, 0xc6, 0x6c, 0xfe, |
0x6c, 0x18, 0xc0, 0x30, 0x0e, 0x0c, 0x00, 0x00, 0xde, 0xc6, 0xc6, |
0xc0, 0xc6, 0xc0, 0xc0, 0xc6, 0xc6, 0x18, 0xcc, 0xd8, 0xc0, 0xc6, |
0xc6, 0xc6, 0xc0, 0xc6, 0xcc, 0x06, 0x18, 0xc6, 0xc6, 0xd6, 0x7c, |
0x18, 0x60, 0x30, 0x1c, 0x0c, 0x00, 0x00, 0xde, 0xfe, 0xc6, 0xc0, |
0xc6, 0xc0, 0xc0, 0xde, 0xc6, 0x18, 0x0c, 0xf0, 0xc0, 0xc6, 0xce, |
0xc6, 0xc0, 0xc6, 0xd8, 0x0c, 0x18, 0xc6, 0xc6, 0xd6, 0x38, 0x18, |
0x30, 0x30, 0x38, 0x0c, 0x00, 0x00, 0xde, 0xc6, 0xfc, 0xc0, 0xc6, |
0xf8, 0xf8, 0xc0, 0xfe, 0x18, 0x0c, 0xf0, 0xc0, 0xd6, 0xde, 0xc6, |
0xfc, 0xc6, 0xfc, 0x38, 0x18, 0xc6, 0xc6, 0xd6, 0x38, 0x3c, 0x18, |
0x30, 0x70, 0x0c, 0x00, 0x00, 0xc6, 0xc6, 0xc6, 0xc0, 0xc6, 0xc0, |
0xc0, 0xc0, 0xc6, 0x18, 0x0c, 0xd8, 0xc0, 0xfe, 0xfe, 0xc6, 0xc6, |
0xc6, 0xc6, 0x60, 0x18, 0xc6, 0xc6, 0xc6, 0x7c, 0x66, 0x0c, 0x30, |
0xe0, 0x0c, 0x00, 0x00, 0xc6, 0x6c, 0xc6, 0xc2, 0xce, 0xc0, 0xc0, |
0xc0, 0xc6, 0x18, 0x0c, 0xcc, 0xc0, 0xfe, 0xf6, 0xc6, 0xc6, 0xc6, |
0xc6, 0xc0, 0x18, 0xc6, 0xc6, 0xc6, 0x6c, 0x66, 0x06, 0x30, 0xc0, |
0x0c, 0x00, 0x00, 0x7c, 0x38, 0xc6, 0x66, 0xdc, 0xc0, 0xc0, 0x62, |
0xc6, 0x18, 0x0c, 0xc6, 0xc0, 0xee, 0xe6, 0xc6, 0xc6, 0xc6, 0xc6, |
0xc2, 0x7e, 0xc6, 0xc6, 0xc6, 0xc6, 0x66, 0x06, 0x30, 0x80, 0x0c, |
0xc6, 0x00, 0x00, 0x10, 0xfc, 0x3c, 0xf8, 0xfc, 0xfc, 0x3c, 0xc6, |
0x18, 0x1e, 0xc2, 0xc0, 0xc6, 0xc6, 0x7c, 0xfc, 0x7c, 0xfc, 0x7c, |
0x7e, 0xc6, 0xc6, 0xc6, 0xc6, 0x66, 0xfe, 0x3c, 0x00, 0x3c, 0x6c, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x38, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, 0x00, 0x6c, 0x7c, |
0x86, 0x76, 0x00, 0x0c, 0x30, 0x00, 0x00, 0x18, 0x00, 0x18, 0x80, |
0x38, 0x18, 0xfe, 0x7c, 0x0c, 0x7c, 0x7c, 0x30, 0x7c, 0x78, 0x00, |
0x30, 0x06, 0x00, 0x60, 0x18, 0x00, 0x18, 0x00, 0x6c, 0xc6, 0xc6, |
0xcc, 0x00, 0x18, 0x18, 0x00, 0x00, 0x18, 0x00, 0x18, 0xc0, 0x6c, |
0x18, 0xc0, 0x86, 0x0c, 0x86, 0xc6, 0x30, 0xc6, 0x8c, 0x18, 0x18, |
0x0c, 0x00, 0x30, 0x18, 0x00, 0x00, 0x00, 0xfe, 0x86, 0x60, 0xcc, |
0x00, 0x30, 0x0c, 0x66, 0x18, 0x18, 0x00, 0x00, 0x60, 0xc6, 0x18, |
0xc0, 0x06, 0x0c, 0x06, 0xc6, 0x30, 0xc6, 0x06, 0x18, 0x18, 0x18, |
0x00, 0x18, 0x00, 0x00, 0x18, 0x00, 0x6c, 0x06, 0x30, 0xcc, 0x00, |
0x30, 0x0c, 0x3c, 0x18, 0x00, 0x00, 0x00, 0x30, 0xe6, 0x18, 0x60, |
0x06, 0x0c, 0x06, 0xc6, 0x30, 0xc6, 0x06, 0x00, 0x00, 0x30, 0x7e, |
0x0c, 0x18, 0x00, 0x18, 0x00, 0x6c, 0x06, 0x18, 0xdc, 0x00, 0x30, |
0x0c, 0xff, 0x7e, 0x00, 0xfe, 0x00, 0x18, 0xf6, 0x18, 0x30, 0x06, |
0xfe, 0x06, 0xe6, 0x18, 0xc6, 0x06, 0x00, 0x00, 0x60, 0x00, 0x06, |
0x18, 0x00, 0x18, 0x00, 0x6c, 0x7c, 0x0c, 0x76, 0x00, 0x30, 0x0c, |
0x3c, 0x18, 0x00, 0x00, 0x00, 0x0c, 0xde, 0x18, 0x18, 0x3c, 0xcc, |
0xfc, 0xdc, 0x0c, 0x7c, 0x7e, 0x00, 0x00, 0x30, 0x00, 0x0c, 0x18, |
0x00, 0x3c, 0x00, 0xfe, 0xc0, 0xc6, 0x38, 0x00, 0x30, 0x0c, 0x66, |
0x18, 0x00, 0x00, 0x00, 0x06, 0xce, 0x18, 0x0c, 0x06, 0x6c, 0xc0, |
0xc0, 0x06, 0xc6, 0xc6, 0x18, 0x18, 0x18, 0x7e, 0x18, 0x0c, 0x00, |
0x3c, 0x24, 0x6c, 0xc2, 0xc2, 0x6c, 0x60, 0x30, 0x0c, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x02, 0xc6, 0x78, 0x06, 0x06, 0x3c, 0xc0, 0xc0, |
0x06, 0xc6, 0xc6, 0x18, 0x18, 0x0c, 0x00, 0x30, 0xc6, 0x00, 0x3c, |
0x66, 0x6c, 0xc6, 0x00, 0x6c, 0x30, 0x18, 0x18, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x6c, 0x38, 0xc6, 0x86, 0x1c, 0xc0, 0x60, 0x06, |
0xc6, 0xc6, 0x00, 0x00, 0x06, 0x00, 0x60, 0xc6, 0x00, 0x18, 0x66, |
0x00, 0x7c, 0x00, 0x38, 0x30, 0x0c, 0x30, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x38, 0x18, 0x7c, 0x7c, 0x0c, 0xfe, 0x3c, 0xfe, 0x7c, |
0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7c, 0x00, 0x00, 0x66, 0x00, |
0x18, 0x00, 0x00, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x18, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, |
0x00, 0xff, 0x00, 0x00, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x7e, 0x7e, 0x10, 0x00, 0x3c, 0x3c, 0x00, 0xff, 0x00, |
0xff, 0x78, 0x18, 0xe0, 0xe6, 0x18, 0x80, 0x02, 0x00, 0x66, 0x1b, |
0xc6, 0xfe, 0x7e, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x81, 0xff, 0x38, 0x10, 0x18, 0x18, 0x00, 0xff, 0x3c, 0xc3, |
0xcc, 0x18, 0xf0, 0xe7, 0x18, 0xc0, 0x06, 0x18, 0x66, 0x1b, 0x0c, |
0xfe, 0x18, 0x18, 0x3c, 0x00, 0x00, 0x00, 0x00, 0xfe, 0x10, 0x00, |
0x81, 0xff, 0x7c, 0x38, 0x18, 0x18, 0x18, 0xe7, 0x66, 0x99, 0xcc, |
0x7e, 0x70, 0x67, 0xdb, 0xe0, 0x0e, 0x3c, 0x00, 0x1b, 0x38, 0xfe, |
0x3c, 0x18, 0x7e, 0x18, 0x30, 0xfe, 0x28, 0xfe, 0x38, 0x00, 0x99, |
0xe7, 0xfe, 0x7c, 0xe7, 0x7e, 0x3c, 0xc3, 0x42, 0xbd, 0xcc, 0x18, |
0x30, 0x63, 0x3c, 0xf0, 0x1e, 0x7e, 0x66, 0x1b, 0x6c, 0xfe, 0x7e, |
0x18, 0x18, 0x0c, 0x60, 0xc0, 0x6c, 0x7c, 0x38, 0x00, 0xbd, 0xc3, |
0xfe, 0xfe, 0xe7, 0xff, 0x3c, 0xc3, 0x42, 0xbd, 0xcc, 0x3c, 0x30, |
0x63, 0xe7, 0xf8, 0x3e, 0x18, 0x66, 0x1b, 0xc6, 0x00, 0x18, 0x18, |
0x18, 0xfe, 0xfe, 0xc0, 0xfe, 0x7c, 0x7c, 0x00, 0x81, 0xff, 0xfe, |
0x7c, 0xe7, 0xff, 0x18, 0xe7, 0x66, 0x99, 0x78, 0x66, 0x30, 0x63, |
0x3c, 0xfe, 0xfe, 0x18, 0x66, 0x7b, 0xc6, 0x00, 0x18, 0x18, 0x18, |
0x0c, 0x60, 0xc0, 0x6c, 0x38, 0x7c, 0x00, 0x81, 0xff, 0xfe, 0x38, |
0x3c, 0x7e, 0x00, 0xff, 0x3c, 0xc3, 0x32, 0x66, 0x30, 0x63, 0xdb, |
0xf8, 0x3e, 0x18, 0x66, 0xdb, 0x6c, 0x00, 0x18, 0x18, 0x18, 0x18, |
0x30, 0x00, 0x28, 0x38, 0xfe, 0x00, 0xa5, 0xdb, 0x6c, 0x10, 0x3c, |
0x3c, 0x00, 0xff, 0x00, 0xff, 0x1a, 0x66, 0x3f, 0x7f, 0x18, 0xf0, |
0x1e, 0x7e, 0x66, 0xdb, 0x38, 0x00, 0x7e, 0x7e, 0x18, 0x00, 0x00, |
0x00, 0x00, 0x10, 0xfe, 0x00, 0x81, 0xff, 0x00, 0x00, 0x18, 0x18, |
0x00, 0xff, 0x00, 0xff, 0x0e, 0x66, 0x33, 0x63, 0x18, 0xe0, 0x0e, |
0x3c, 0x66, 0xdb, 0x60, 0x00, 0x3c, 0x3c, 0x18, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x7e, 0x7e, 0x00, 0x00, 0x00, 0x00, 0x00, |
0xff, 0x00, 0xff, 0x1e, 0x3c, 0x3f, 0x7f, 0x00, 0xc0, 0x06, 0x18, |
0x66, 0x7f, 0xc6, 0x00, 0x18, 0x18, 0x18, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, |
0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x02, 0x00, 0x00, |
0x00, 0x7c, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, |
0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 |
}; |
/contrib/sdk/sources/PDCurses/common/icon32.xpm |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = image/x-xpmi |
Property changes: |
Added: svn:mime-type |
+image/x-xpmi |
\ No newline at end of property |
/contrib/sdk/sources/PDCurses/common/icon64.xpm |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = image/x-xpmi |
Property changes: |
Added: svn:mime-type |
+image/x-xpmi |
\ No newline at end of property |
/contrib/sdk/sources/PDCurses/common/iconbmp.h |
---|
0,0 → 1,24 |
/* The PDCurses logo as #include'able BMP (from icon32.xpm), |
for use by SDL. */ |
unsigned char iconbmp[] = |
{ |
0x42, 0x4d, 0xbe, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x3e, |
0x00, 0x00, 0x00, 0x28, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00, |
0x20, 0x00, 0x00, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x80, 0x00, 0x00, 0x00, 0x13, 0x0b, 0x00, 0x00, 0x13, 0x0b, |
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, |
0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0xff, 0xff, 0xff, 0xff, |
0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xce, 0x6f, 0x9c, |
0xe7, 0xb5, 0xaf, 0x6b, 0x5b, 0xbd, 0xaf, 0xeb, 0xfb, 0xbd, 0xaf, |
0x98, 0xe7, 0xbd, 0xaf, 0x7b, 0x5f, 0xb5, 0xa5, 0x6b, 0x5b, 0xcd, |
0xab, 0x9c, 0xe7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
0xff, 0xcf, 0x03, 0xff, 0xff, 0xce, 0x03, 0xff, 0xff, 0xcc, 0x73, |
0xff, 0xff, 0xcc, 0xf3, 0xff, 0xff, 0xcc, 0xf3, 0xff, 0xff, 0xcc, |
0x73, 0xff, 0xff, 0xc6, 0x33, 0xff, 0xff, 0xc3, 0x13, 0xff, 0xff, |
0xc1, 0x83, 0xff, 0xff, 0xc8, 0xc3, 0xff, 0xff, 0xcc, 0x63, 0xff, |
0xff, 0xce, 0x33, 0xff, 0xff, 0xcf, 0x33, 0xff, 0xff, 0xcf, 0x33, |
0xff, 0xff, 0xce, 0x33, 0xff, 0xff, 0xc0, 0x73, 0xff, 0xff, 0xc0, |
0xf3, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, |
0xff, 0xff, 0xff |
}; |
/contrib/sdk/sources/PDCurses/common/libobjs.mif |
---|
0,0 → 1,24 |
# Common elements for most of the DOS, OS/2 and Windows |
# makefiles (not Watcom) |
PDCURSES_CURSES_H = $(PDCURSES_SRCDIR)/curses.h |
PDCURSES_CURSPRIV_H = $(PDCURSES_SRCDIR)/curspriv.h |
PDCURSES_HEADERS = $(PDCURSES_CURSES_H) $(PDCURSES_CURSPRIV_H) |
PANEL_HEADER = $(PDCURSES_SRCDIR)/panel.h |
srcdir = $(PDCURSES_SRCDIR)/pdcurses |
demodir = $(PDCURSES_SRCDIR)/demos |
LIBOBJS = addch.$(O) addchstr.$(O) addstr.$(O) attr.$(O) beep.$(O) \ |
bkgd.$(O) border.$(O) clear.$(O) color.$(O) delch.$(O) deleteln.$(O) \ |
getch.$(O) getstr.$(O) getyx.$(O) inch.$(O) inchstr.$(O) \ |
initscr.$(O) inopts.$(O) insch.$(O) insstr.$(O) instr.$(O) kernel.$(O) \ |
keyname.$(O) mouse.$(O) move.$(O) outopts.$(O) overlay.$(O) pad.$(O) \ |
panel.$(O) printw.$(O) refresh.$(O) scanw.$(O) scr_dump.$(O) scroll.$(O) \ |
slk.$(O) termattr.$(O) touch.$(O) util.$(O) window.$(O) debug.$(O) |
PDCOBJS = pdcclip.$(O) pdcdisp.$(O) pdcgetsc.$(O) pdckbd.$(O) pdcscrn.$(O) \ |
pdcsetsc.$(O) pdcutil.$(O) |
DEMOS = testcurs$(E) ozdemo$(E) xmas$(E) tuidemo$(E) firework$(E) \ |
ptest$(E) rain$(E) worm$(E) |
/contrib/sdk/sources/PDCurses/common/pdcurses.rc |
---|
0,0 → 1,35 |
#include <windows.h> |
#include "../curses.h" |
VS_VERSION_INFO VERSIONINFO |
FILEVERSION PDC_VER_MAJOR,PDC_VER_MINOR,0,0 |
PRODUCTVERSION PDC_VER_MAJOR,PDC_VER_MINOR,0,0 |
FILEFLAGSMASK VS_FFI_FILEFLAGSMASK |
#ifdef _DEBUG |
FILEFLAGS VS_FF_DEBUG | VS_FF_PRERELEASE |
#else |
FILEFLAGS 0 |
#endif |
FILEOS VOS_NT_WINDOWS32 |
FILETYPE VFT_DLL |
FILESUBTYPE VFT2_UNKNOWN |
BEGIN |
BLOCK "StringFileInfo" |
BEGIN |
BLOCK "04090000" |
BEGIN |
VALUE "CompanyName", "PDCurses.org" |
VALUE "FileDescription", "PDCurses Library" |
VALUE "FileVersion", PDC_VERDOT ".0.0" |
VALUE "InternalName", "PDCurses" |
VALUE "LegalCopyright", "Public Domain" |
VALUE "OriginalFilename", "pdcurses.dll" |
VALUE "ProductName", "PDCurses" |
VALUE "ProductVersion", PDC_VERDOT ".0.0" |
END |
END |
BLOCK "VarFileInfo" |
BEGIN |
VALUE "Translation", 0x409, 0 |
END |
END |
/contrib/sdk/sources/PDCurses/common/watcom.mif |
---|
0,0 → 1,72 |
# Common elements for the Watcom makefiles |
CFLAGS += -wx -zq -i=$(PDCURSES_SRCDIR) |
!ifeq DEBUG Y |
CFLAGS += -d2 -DPDCDEBUG |
LDFLAGS = D W A op q sys $(TARGET) |
!else |
CFLAGS += -oneatx |
LDFLAGS = op q sys $(TARGET) |
!endif |
RM = del |
LIBEXE = wlib -q -n -b -c -t |
srcdir = $(PDCURSES_SRCDIR)/pdcurses |
demodir = $(PDCURSES_SRCDIR)/demos |
LIBOBJS = addch.obj addchstr.obj addstr.obj attr.obj beep.obj bkgd.obj & |
border.obj clear.obj color.obj delch.obj deleteln.obj & |
getch.obj getstr.obj getyx.obj inch.obj inchstr.obj initscr.obj inopts.obj & |
insch.obj insstr.obj instr.obj kernel.obj keyname.obj mouse.obj move.obj & |
outopts.obj overlay.obj pad.obj panel.obj printw.obj refresh.obj & |
scanw.obj scr_dump.obj scroll.obj slk.obj termattr.obj & |
touch.obj util.obj window.obj debug.obj |
PDCOBJS = pdcclip.obj pdcdisp.obj pdcgetsc.obj pdckbd.obj pdcscrn.obj & |
pdcsetsc.obj pdcutil.obj |
DEMOS = testcurs.exe ozdemo.exe xmas.exe tuidemo.exe firework.exe & |
ptest.exe rain.exe worm.exe |
LIBCURSES = pdcurses.lib |
LINK = wlink |
!ifdef __LOADDLL__ |
! loaddll wcc wccd |
! loaddll wcc386 wccd386 |
! loaddll wlink wlinkd |
! loaddll wlib wlibd |
!endif |
all: $(LIBCURSES) |
clean |
-$(RM) *.obj |
-$(RM) *.lib |
-$(RM) *.exe |
-$(RM) *.err |
demos: $(DEMOS) |
.c: $(srcdir);$(osdir);$(demodir) |
.c.obj: .autodepend |
$(CC) $(CFLAGS) $< |
.obj.exe: |
$(LINK) $(LDFLAGS) n $@ f $*.obj l $(LIBCURSES) |
testcurs.exe: testcurs.obj $(LIBCURSES) |
ozdemo.exe: ozdemo.obj $(LIBCURSES) |
xmas.exe: xmas.obj $(LIBCURSES) |
firework.exe: firework.obj $(LIBCURSES) |
rain.exe: rain.obj $(LIBCURSES) |
worm.exe: worm.obj $(LIBCURSES) |
ptest.exe: ptest.obj $(LIBCURSES) |
tuidemo.exe: tuidemo.obj tui.obj $(LIBCURSES) |
$(LINK) $(LDFLAGS) n $@ f tuidemo.obj f tui.obj l $(LIBCURSES) |
dist: .symbolic |
/contrib/sdk/sources/PDCurses/curses.h |
---|
0,0 → 1,1417 |
/*----------------------------------------------------------------------* |
* PDCurses * |
*----------------------------------------------------------------------*/ |
#ifndef __PDCURSES__ |
#define __PDCURSES__ 1 |
/*man-start************************************************************** |
Define before inclusion (only those needed): |
XCURSES if building / built for X11 |
PDC_RGB if you want to use RGB color definitions |
(Red = 1, Green = 2, Blue = 4) instead of BGR |
PDC_WIDE if building / built with wide-character support |
PDC_DLL_BUILD if building / built as a Windows DLL |
PDC_NCMOUSE to use the ncurses mouse API instead |
of PDCurses' traditional mouse API |
Defined by this header: |
PDCURSES PDCurses-only features are available |
PDC_BUILD API build version |
PDC_VER_MAJOR major version number |
PDC_VER_MINOR minor version number |
PDC_VERDOT version string |
**man-end****************************************************************/ |
#define PDCURSES 1 |
#define PDC_BUILD 3906 |
#define PDC_VER_MAJOR 3 |
#define PDC_VER_MINOR 9 |
#define PDC_VERDOT "3.9" |
#define CHTYPE_LONG 1 /* chtype >= 32 bits */ |
#if defined(__STDC_VERSION__) && __STDC_VERSION__ >= 199901L |
# define PDC_99 1 |
#endif |
#if defined(__cplusplus) && __cplusplus >= 199711L |
# define PDC_PP98 1 |
#endif |
/*----------------------------------------------------------------------*/ |
#include <stdarg.h> |
#include <stddef.h> |
#include <stdio.h> |
#ifdef PDC_WIDE |
# include <wchar.h> |
#endif |
#if defined(PDC_99) && !defined(__bool_true_false_are_defined) |
# include <stdbool.h> |
#endif |
#ifdef __cplusplus |
extern "C" |
{ |
# ifndef PDC_PP98 |
# define bool _bool |
# endif |
#endif |
/*---------------------------------------------------------------------- |
* |
* Constants and Types |
* |
*/ |
#undef FALSE |
#define FALSE 0 |
#undef TRUE |
#define TRUE 1 |
#undef ERR |
#define ERR (-1) |
#undef OK |
#define OK 0 |
#if !defined(PDC_PP98) && !defined(__bool_true_false_are_defined) |
typedef unsigned char bool; |
#endif |
#if _LP64 |
typedef unsigned int chtype; |
#else |
typedef unsigned long chtype; /* 16-bit attr + 16-bit char */ |
#endif |
#ifdef PDC_WIDE |
typedef chtype cchar_t; |
#endif |
typedef chtype attr_t; |
/*---------------------------------------------------------------------- |
* |
* Version Info |
* |
*/ |
/* Use this structure with PDC_get_version() for run-time info about the |
way the library was built, in case it doesn't match the header. */ |
typedef struct |
{ |
short flags; /* flags OR'd together (see below) */ |
short build; /* PDC_BUILD at compile time */ |
unsigned char major; /* PDC_VER_MAJOR */ |
unsigned char minor; /* PDC_VER_MINOR */ |
unsigned char csize; /* sizeof chtype */ |
unsigned char bsize; /* sizeof bool */ |
} PDC_VERSION; |
enum |
{ |
PDC_VFLAG_DEBUG = 1, /* set if built with -DPDCDEBUG */ |
PDC_VFLAG_WIDE = 2, /* -DPDC_WIDE */ |
PDC_VFLAG_UTF8 = 4, /* -DPDC_FORCE_UTF8 */ |
PDC_VFLAG_DLL = 8, /* -DPDC_DLL_BUILD */ |
PDC_VFLAG_RGB = 16 /* -DPDC_RGB */ |
}; |
/*---------------------------------------------------------------------- |
* |
* Mouse Interface |
* |
*/ |
#if _LP64 |
typedef unsigned int mmask_t; |
#else |
typedef unsigned long mmask_t; |
#endif |
typedef struct |
{ |
int x; /* absolute column, 0 based, measured in characters */ |
int y; /* absolute row, 0 based, measured in characters */ |
short button[3]; /* state of each button */ |
int changes; /* flags indicating what has changed with the mouse */ |
} MOUSE_STATUS; |
#define BUTTON_RELEASED 0x0000 |
#define BUTTON_PRESSED 0x0001 |
#define BUTTON_CLICKED 0x0002 |
#define BUTTON_DOUBLE_CLICKED 0x0003 |
#define BUTTON_TRIPLE_CLICKED 0x0004 |
#define BUTTON_MOVED 0x0005 /* PDCurses */ |
#define WHEEL_SCROLLED 0x0006 /* PDCurses */ |
#define BUTTON_ACTION_MASK 0x0007 /* PDCurses */ |
#define PDC_BUTTON_SHIFT 0x0008 /* PDCurses */ |
#define PDC_BUTTON_CONTROL 0x0010 /* PDCurses */ |
#define PDC_BUTTON_ALT 0x0020 /* PDCurses */ |
#define BUTTON_MODIFIER_MASK 0x0038 /* PDCurses */ |
#define MOUSE_X_POS (Mouse_status.x) |
#define MOUSE_Y_POS (Mouse_status.y) |
/* |
* Bits associated with the .changes field: |
* 3 2 1 0 |
* 210987654321098765432109876543210 |
* 1 <- button 1 has changed |
* 10 <- button 2 has changed |
* 100 <- button 3 has changed |
* 1000 <- mouse has moved |
* 10000 <- mouse position report |
* 100000 <- mouse wheel up |
* 1000000 <- mouse wheel down |
* 10000000 <- mouse wheel left |
* 100000000 <- mouse wheel right |
*/ |
#define PDC_MOUSE_MOVED 0x0008 |
#define PDC_MOUSE_POSITION 0x0010 |
#define PDC_MOUSE_WHEEL_UP 0x0020 |
#define PDC_MOUSE_WHEEL_DOWN 0x0040 |
#define PDC_MOUSE_WHEEL_LEFT 0x0080 |
#define PDC_MOUSE_WHEEL_RIGHT 0x0100 |
#define A_BUTTON_CHANGED (Mouse_status.changes & 7) |
#define MOUSE_MOVED (Mouse_status.changes & PDC_MOUSE_MOVED) |
#define MOUSE_POS_REPORT (Mouse_status.changes & PDC_MOUSE_POSITION) |
#define BUTTON_CHANGED(x) (Mouse_status.changes & (1 << ((x) - 1))) |
#define BUTTON_STATUS(x) (Mouse_status.button[(x) - 1]) |
#define MOUSE_WHEEL_UP (Mouse_status.changes & PDC_MOUSE_WHEEL_UP) |
#define MOUSE_WHEEL_DOWN (Mouse_status.changes & PDC_MOUSE_WHEEL_DOWN) |
#define MOUSE_WHEEL_LEFT (Mouse_status.changes & PDC_MOUSE_WHEEL_LEFT) |
#define MOUSE_WHEEL_RIGHT (Mouse_status.changes & PDC_MOUSE_WHEEL_RIGHT) |
/* mouse bit-masks */ |
#define BUTTON1_RELEASED 0x00000001L |
#define BUTTON1_PRESSED 0x00000002L |
#define BUTTON1_CLICKED 0x00000004L |
#define BUTTON1_DOUBLE_CLICKED 0x00000008L |
#define BUTTON1_TRIPLE_CLICKED 0x00000010L |
#define BUTTON1_MOVED 0x00000010L /* PDCurses */ |
#define BUTTON2_RELEASED 0x00000020L |
#define BUTTON2_PRESSED 0x00000040L |
#define BUTTON2_CLICKED 0x00000080L |
#define BUTTON2_DOUBLE_CLICKED 0x00000100L |
#define BUTTON2_TRIPLE_CLICKED 0x00000200L |
#define BUTTON2_MOVED 0x00000200L /* PDCurses */ |
#define BUTTON3_RELEASED 0x00000400L |
#define BUTTON3_PRESSED 0x00000800L |
#define BUTTON3_CLICKED 0x00001000L |
#define BUTTON3_DOUBLE_CLICKED 0x00002000L |
#define BUTTON3_TRIPLE_CLICKED 0x00004000L |
#define BUTTON3_MOVED 0x00004000L /* PDCurses */ |
/* For the ncurses-compatible functions only, BUTTON4_PRESSED and |
BUTTON5_PRESSED are returned for mouse scroll wheel up and down; |
otherwise PDCurses doesn't support buttons 4 and 5 */ |
#define BUTTON4_RELEASED 0x00008000L |
#define BUTTON4_PRESSED 0x00010000L |
#define BUTTON4_CLICKED 0x00020000L |
#define BUTTON4_DOUBLE_CLICKED 0x00040000L |
#define BUTTON4_TRIPLE_CLICKED 0x00080000L |
#define BUTTON5_RELEASED 0x00100000L |
#define BUTTON5_PRESSED 0x00200000L |
#define BUTTON5_CLICKED 0x00400000L |
#define BUTTON5_DOUBLE_CLICKED 0x00800000L |
#define BUTTON5_TRIPLE_CLICKED 0x01000000L |
#define MOUSE_WHEEL_SCROLL 0x02000000L /* PDCurses */ |
#define BUTTON_MODIFIER_SHIFT 0x04000000L /* PDCurses */ |
#define BUTTON_MODIFIER_CONTROL 0x08000000L /* PDCurses */ |
#define BUTTON_MODIFIER_ALT 0x10000000L /* PDCurses */ |
#define ALL_MOUSE_EVENTS 0x1fffffffL |
#define REPORT_MOUSE_POSITION 0x20000000L |
/* ncurses mouse interface */ |
typedef struct |
{ |
short id; /* unused, always 0 */ |
int x, y, z; /* x, y same as MOUSE_STATUS; z unused */ |
mmask_t bstate; /* equivalent to changes + button[], but |
in the same format as used for mousemask() */ |
} MEVENT; |
#if defined(PDC_NCMOUSE) && !defined(NCURSES_MOUSE_VERSION) |
# define NCURSES_MOUSE_VERSION 2 |
#endif |
#ifdef NCURSES_MOUSE_VERSION |
# define BUTTON_SHIFT BUTTON_MODIFIER_SHIFT |
# define BUTTON_CONTROL BUTTON_MODIFIER_CONTROL |
# define BUTTON_CTRL BUTTON_MODIFIER_CONTROL |
# define BUTTON_ALT BUTTON_MODIFIER_ALT |
#else |
# define BUTTON_SHIFT PDC_BUTTON_SHIFT |
# define BUTTON_CONTROL PDC_BUTTON_CONTROL |
# define BUTTON_ALT PDC_BUTTON_ALT |
#endif |
/*---------------------------------------------------------------------- |
* |
* Window and Screen Structures |
* |
*/ |
typedef struct _win /* definition of a window */ |
{ |
int _cury; /* current pseudo-cursor */ |
int _curx; |
int _maxy; /* max window coordinates */ |
int _maxx; |
int _begy; /* origin on screen */ |
int _begx; |
int _flags; /* window properties */ |
chtype _attrs; /* standard attributes and colors */ |
chtype _bkgd; /* background, normally blank */ |
bool _clear; /* causes clear at next refresh */ |
bool _leaveit; /* leaves cursor where it is */ |
bool _scroll; /* allows window scrolling */ |
bool _nodelay; /* input character wait flag */ |
bool _immed; /* immediate update flag */ |
bool _sync; /* synchronise window ancestors */ |
bool _use_keypad; /* flags keypad key mode active */ |
chtype **_y; /* pointer to line pointer array */ |
int *_firstch; /* first changed character in line */ |
int *_lastch; /* last changed character in line */ |
int _tmarg; /* top of scrolling region */ |
int _bmarg; /* bottom of scrolling region */ |
int _delayms; /* milliseconds of delay for getch() */ |
int _parx, _pary; /* coords relative to parent (0,0) */ |
struct _win *_parent; /* subwin's pointer to parent win */ |
} WINDOW; |
/* Color pair structure */ |
typedef struct |
{ |
short f; /* foreground color */ |
short b; /* background color */ |
int count; /* allocation order */ |
bool set; /* pair has been set */ |
} PDC_PAIR; |
/* Avoid using the SCREEN struct directly -- use the corresponding |
functions if possible. This struct may eventually be made private. */ |
typedef struct |
{ |
bool alive; /* if initscr() called, and not endwin() */ |
bool autocr; /* if cr -> lf */ |
bool cbreak; /* if terminal unbuffered */ |
bool echo; /* if terminal echo */ |
bool raw_inp; /* raw input mode (v. cooked input) */ |
bool raw_out; /* raw output mode (7 v. 8 bits) */ |
bool audible; /* FALSE if the bell is visual */ |
bool mono; /* TRUE if current screen is mono */ |
bool resized; /* TRUE if TERM has been resized */ |
bool orig_attr; /* TRUE if we have the original colors */ |
short orig_fore; /* original screen foreground color */ |
short orig_back; /* original screen foreground color */ |
int cursrow; /* position of physical cursor */ |
int curscol; /* position of physical cursor */ |
int visibility; /* visibility of cursor */ |
int orig_cursor; /* original cursor size */ |
int lines; /* new value for LINES */ |
int cols; /* new value for COLS */ |
mmask_t _trap_mbe; /* trap these mouse button events */ |
int mouse_wait; /* time to wait (in ms) for a |
button release after a press, in |
order to count it as a click */ |
int slklines; /* lines in use by slk_init() */ |
WINDOW *slk_winptr; /* window for slk */ |
int linesrippedoff; /* lines ripped off via ripoffline() */ |
int linesrippedoffontop; /* lines ripped off on |
top via ripoffline() */ |
int delaytenths; /* 1/10ths second to wait block |
getch() for */ |
bool _preserve; /* TRUE if screen background |
to be preserved */ |
int _restore; /* specifies if screen background |
to be restored, and how */ |
unsigned long key_modifiers; /* key modifiers (SHIFT, CONTROL, etc.) |
on last key press */ |
bool return_key_modifiers; /* TRUE if modifier keys are |
returned as "real" keys */ |
bool key_code; /* TRUE if last key is a special key; |
used internally by get_wch() */ |
MOUSE_STATUS mouse_status; /* last returned mouse status */ |
short line_color; /* color of line attributes - default -1 */ |
attr_t termattrs; /* attribute capabilities */ |
WINDOW *lastscr; /* the last screen image */ |
FILE *dbfp; /* debug trace file pointer */ |
bool color_started; /* TRUE after start_color() */ |
bool dirty; /* redraw on napms() after init_color() */ |
int sel_start; /* start of selection (y * COLS + x) */ |
int sel_end; /* end of selection */ |
int *c_buffer; /* character buffer */ |
int c_pindex; /* putter index */ |
int c_gindex; /* getter index */ |
int *c_ungch; /* array of ungotten chars */ |
int c_ungind; /* ungetch() push index */ |
int c_ungmax; /* allocated size of ungetch() buffer */ |
PDC_PAIR *atrtab; /* table of color pairs */ |
} SCREEN; |
/*---------------------------------------------------------------------- |
* |
* External Variables |
* |
*/ |
#ifdef PDC_DLL_BUILD |
# ifdef CURSES_LIBRARY |
# define PDCEX __declspec(dllexport) extern |
# else |
# define PDCEX __declspec(dllimport) |
# endif |
#else |
# define PDCEX extern |
#endif |
PDCEX int LINES; /* terminal height */ |
PDCEX int COLS; /* terminal width */ |
PDCEX WINDOW *stdscr; /* the default screen window */ |
PDCEX WINDOW *curscr; /* the current screen image */ |
PDCEX SCREEN *SP; /* curses variables */ |
PDCEX MOUSE_STATUS Mouse_status; |
PDCEX int COLORS; |
PDCEX int COLOR_PAIRS; |
PDCEX int TABSIZE; |
PDCEX chtype acs_map[]; /* alternate character set map */ |
PDCEX char ttytype[]; /* terminal name/description */ |
/*man-start************************************************************** |
Text Attributes |
=============== |
PDCurses uses a 32-bit integer for its chtype: |
+--------------------------------------------------------------------+ |
|31|30|29|28|27|26|25|24|23|22|21|20|19|18|17|16|15|14|13|..| 2| 1| 0| |
+--------------------------------------------------------------------+ |
color pair | modifiers | character eg 'a' |
There are 256 color pairs (8 bits), 8 bits for modifiers, and 16 bits |
for character data. The modifiers are bold, underline, right-line, |
left-line, italic, reverse and blink, plus the alternate character set |
indicator. |
**man-end****************************************************************/ |
/*** Video attribute macros ***/ |
#define A_NORMAL (chtype)0 |
#define A_ALTCHARSET (chtype)0x00010000 |
#define A_RIGHT (chtype)0x00020000 |
#define A_LEFT (chtype)0x00040000 |
#define A_ITALIC (chtype)0x00080000 |
#define A_UNDERLINE (chtype)0x00100000 |
#define A_REVERSE (chtype)0x00200000 |
#define A_BLINK (chtype)0x00400000 |
#define A_BOLD (chtype)0x00800000 |
#define A_ATTRIBUTES (chtype)0xffff0000 |
#define A_CHARTEXT (chtype)0x0000ffff |
#define A_COLOR (chtype)0xff000000 |
#define PDC_COLOR_SHIFT 24 |
#define A_LEFTLINE A_LEFT |
#define A_RIGHTLINE A_RIGHT |
#define A_STANDOUT (A_REVERSE | A_BOLD) /* X/Open */ |
#define A_DIM A_NORMAL |
#define A_INVIS A_NORMAL |
#define A_PROTECT A_NORMAL |
#define A_HORIZONTAL A_NORMAL |
#define A_LOW A_NORMAL |
#define A_TOP A_NORMAL |
#define A_VERTICAL A_NORMAL |
#define CHR_MSK A_CHARTEXT /* Obsolete */ |
#define ATR_MSK A_ATTRIBUTES /* Obsolete */ |
#define ATR_NRM A_NORMAL /* Obsolete */ |
/* For use with attr_t -- X/Open says, "these shall be distinct", so |
this is a non-conforming implementation. */ |
#define WA_NORMAL A_NORMAL |
#define WA_ALTCHARSET A_ALTCHARSET |
#define WA_BLINK A_BLINK |
#define WA_BOLD A_BOLD |
#define WA_DIM A_DIM |
#define WA_INVIS A_INVIS |
#define WA_ITALIC A_ITALIC |
#define WA_LEFT A_LEFT |
#define WA_PROTECT A_PROTECT |
#define WA_REVERSE A_REVERSE |
#define WA_RIGHT A_RIGHT |
#define WA_STANDOUT A_STANDOUT |
#define WA_UNDERLINE A_UNDERLINE |
#define WA_HORIZONTAL A_HORIZONTAL |
#define WA_LOW A_LOW |
#define WA_TOP A_TOP |
#define WA_VERTICAL A_VERTICAL |
#define WA_ATTRIBUTES A_ATTRIBUTES |
/*** Alternate character set macros ***/ |
#define PDC_ACS(w) ((chtype)w | A_ALTCHARSET) |
/* VT100-compatible symbols -- box chars */ |
#define ACS_ULCORNER PDC_ACS('l') |
#define ACS_LLCORNER PDC_ACS('m') |
#define ACS_URCORNER PDC_ACS('k') |
#define ACS_LRCORNER PDC_ACS('j') |
#define ACS_RTEE PDC_ACS('u') |
#define ACS_LTEE PDC_ACS('t') |
#define ACS_BTEE PDC_ACS('v') |
#define ACS_TTEE PDC_ACS('w') |
#define ACS_HLINE PDC_ACS('q') |
#define ACS_VLINE PDC_ACS('x') |
#define ACS_PLUS PDC_ACS('n') |
/* VT100-compatible symbols -- other */ |
#define ACS_S1 PDC_ACS('o') |
#define ACS_S9 PDC_ACS('s') |
#define ACS_DIAMOND PDC_ACS('`') |
#define ACS_CKBOARD PDC_ACS('a') |
#define ACS_DEGREE PDC_ACS('f') |
#define ACS_PLMINUS PDC_ACS('g') |
#define ACS_BULLET PDC_ACS('~') |
/* Teletype 5410v1 symbols -- these are defined in SysV curses, but |
are not well-supported by most terminals. Stick to VT100 characters |
for optimum portability. */ |
#define ACS_LARROW PDC_ACS(',') |
#define ACS_RARROW PDC_ACS('+') |
#define ACS_DARROW PDC_ACS('.') |
#define ACS_UARROW PDC_ACS('-') |
#define ACS_BOARD PDC_ACS('h') |
#define ACS_LANTERN PDC_ACS('i') |
#define ACS_BLOCK PDC_ACS('0') |
/* That goes double for these -- undocumented SysV symbols. Don't use |
them. */ |
#define ACS_S3 PDC_ACS('p') |
#define ACS_S7 PDC_ACS('r') |
#define ACS_LEQUAL PDC_ACS('y') |
#define ACS_GEQUAL PDC_ACS('z') |
#define ACS_PI PDC_ACS('{') |
#define ACS_NEQUAL PDC_ACS('|') |
#define ACS_STERLING PDC_ACS('}') |
/* Box char aliases */ |
#define ACS_BSSB ACS_ULCORNER |
#define ACS_SSBB ACS_LLCORNER |
#define ACS_BBSS ACS_URCORNER |
#define ACS_SBBS ACS_LRCORNER |
#define ACS_SBSS ACS_RTEE |
#define ACS_SSSB ACS_LTEE |
#define ACS_SSBS ACS_BTEE |
#define ACS_BSSS ACS_TTEE |
#define ACS_BSBS ACS_HLINE |
#define ACS_SBSB ACS_VLINE |
#define ACS_SSSS ACS_PLUS |
/* cchar_t aliases */ |
#ifdef PDC_WIDE |
# define WACS_ULCORNER (&(acs_map['l'])) |
# define WACS_LLCORNER (&(acs_map['m'])) |
# define WACS_URCORNER (&(acs_map['k'])) |
# define WACS_LRCORNER (&(acs_map['j'])) |
# define WACS_RTEE (&(acs_map['u'])) |
# define WACS_LTEE (&(acs_map['t'])) |
# define WACS_BTEE (&(acs_map['v'])) |
# define WACS_TTEE (&(acs_map['w'])) |
# define WACS_HLINE (&(acs_map['q'])) |
# define WACS_VLINE (&(acs_map['x'])) |
# define WACS_PLUS (&(acs_map['n'])) |
# define WACS_S1 (&(acs_map['o'])) |
# define WACS_S9 (&(acs_map['s'])) |
# define WACS_DIAMOND (&(acs_map['`'])) |
# define WACS_CKBOARD (&(acs_map['a'])) |
# define WACS_DEGREE (&(acs_map['f'])) |
# define WACS_PLMINUS (&(acs_map['g'])) |
# define WACS_BULLET (&(acs_map['~'])) |
# define WACS_LARROW (&(acs_map[','])) |
# define WACS_RARROW (&(acs_map['+'])) |
# define WACS_DARROW (&(acs_map['.'])) |
# define WACS_UARROW (&(acs_map['-'])) |
# define WACS_BOARD (&(acs_map['h'])) |
# define WACS_LANTERN (&(acs_map['i'])) |
# define WACS_BLOCK (&(acs_map['0'])) |
# define WACS_S3 (&(acs_map['p'])) |
# define WACS_S7 (&(acs_map['r'])) |
# define WACS_LEQUAL (&(acs_map['y'])) |
# define WACS_GEQUAL (&(acs_map['z'])) |
# define WACS_PI (&(acs_map['{'])) |
# define WACS_NEQUAL (&(acs_map['|'])) |
# define WACS_STERLING (&(acs_map['}'])) |
# define WACS_BSSB WACS_ULCORNER |
# define WACS_SSBB WACS_LLCORNER |
# define WACS_BBSS WACS_URCORNER |
# define WACS_SBBS WACS_LRCORNER |
# define WACS_SBSS WACS_RTEE |
# define WACS_SSSB WACS_LTEE |
# define WACS_SSBS WACS_BTEE |
# define WACS_BSSS WACS_TTEE |
# define WACS_BSBS WACS_HLINE |
# define WACS_SBSB WACS_VLINE |
# define WACS_SSSS WACS_PLUS |
#endif |
/*** Color macros ***/ |
#define COLOR_BLACK 0 |
#ifdef PDC_RGB /* RGB */ |
# define COLOR_RED 1 |
# define COLOR_GREEN 2 |
# define COLOR_BLUE 4 |
#else /* BGR */ |
# define COLOR_BLUE 1 |
# define COLOR_GREEN 2 |
# define COLOR_RED 4 |
#endif |
#define COLOR_CYAN (COLOR_BLUE | COLOR_GREEN) |
#define COLOR_MAGENTA (COLOR_RED | COLOR_BLUE) |
#define COLOR_YELLOW (COLOR_RED | COLOR_GREEN) |
#define COLOR_WHITE 7 |
/*---------------------------------------------------------------------- |
* |
* Function and Keypad Key Definitions |
* Many are just for compatibility |
* |
*/ |
#define KEY_CODE_YES 0x100 /* If get_wch() gives a key code */ |
#define KEY_BREAK 0x101 /* Not on PC KBD */ |
#define KEY_DOWN 0x102 /* Down arrow key */ |
#define KEY_UP 0x103 /* Up arrow key */ |
#define KEY_LEFT 0x104 /* Left arrow key */ |
#define KEY_RIGHT 0x105 /* Right arrow key */ |
#define KEY_HOME 0x106 /* home key */ |
#define KEY_BACKSPACE 0x107 /* not on pc */ |
#define KEY_F0 0x108 /* function keys; 64 reserved */ |
#define KEY_DL 0x148 /* delete line */ |
#define KEY_IL 0x149 /* insert line */ |
#define KEY_DC 0x14a /* delete character */ |
#define KEY_IC 0x14b /* insert char or enter ins mode */ |
#define KEY_EIC 0x14c /* exit insert char mode */ |
#define KEY_CLEAR 0x14d /* clear screen */ |
#define KEY_EOS 0x14e /* clear to end of screen */ |
#define KEY_EOL 0x14f /* clear to end of line */ |
#define KEY_SF 0x150 /* scroll 1 line forward */ |
#define KEY_SR 0x151 /* scroll 1 line back (reverse) */ |
#define KEY_NPAGE 0x152 /* next page */ |
#define KEY_PPAGE 0x153 /* previous page */ |
#define KEY_STAB 0x154 /* set tab */ |
#define KEY_CTAB 0x155 /* clear tab */ |
#define KEY_CATAB 0x156 /* clear all tabs */ |
#define KEY_ENTER 0x157 /* enter or send (unreliable) */ |
#define KEY_SRESET 0x158 /* soft/reset (partial/unreliable) */ |
#define KEY_RESET 0x159 /* reset/hard reset (unreliable) */ |
#define KEY_PRINT 0x15a /* print/copy */ |
#define KEY_LL 0x15b /* home down/bottom (lower left) */ |
#define KEY_ABORT 0x15c /* abort/terminate key (any) */ |
#define KEY_SHELP 0x15d /* short help */ |
#define KEY_LHELP 0x15e /* long help */ |
#define KEY_BTAB 0x15f /* Back tab key */ |
#define KEY_BEG 0x160 /* beg(inning) key */ |
#define KEY_CANCEL 0x161 /* cancel key */ |
#define KEY_CLOSE 0x162 /* close key */ |
#define KEY_COMMAND 0x163 /* cmd (command) key */ |
#define KEY_COPY 0x164 /* copy key */ |
#define KEY_CREATE 0x165 /* create key */ |
#define KEY_END 0x166 /* end key */ |
#define KEY_EXIT 0x167 /* exit key */ |
#define KEY_FIND 0x168 /* find key */ |
#define KEY_HELP 0x169 /* help key */ |
#define KEY_MARK 0x16a /* mark key */ |
#define KEY_MESSAGE 0x16b /* message key */ |
#define KEY_MOVE 0x16c /* move key */ |
#define KEY_NEXT 0x16d /* next object key */ |
#define KEY_OPEN 0x16e /* open key */ |
#define KEY_OPTIONS 0x16f /* options key */ |
#define KEY_PREVIOUS 0x170 /* previous object key */ |
#define KEY_REDO 0x171 /* redo key */ |
#define KEY_REFERENCE 0x172 /* ref(erence) key */ |
#define KEY_REFRESH 0x173 /* refresh key */ |
#define KEY_REPLACE 0x174 /* replace key */ |
#define KEY_RESTART 0x175 /* restart key */ |
#define KEY_RESUME 0x176 /* resume key */ |
#define KEY_SAVE 0x177 /* save key */ |
#define KEY_SBEG 0x178 /* shifted beginning key */ |
#define KEY_SCANCEL 0x179 /* shifted cancel key */ |
#define KEY_SCOMMAND 0x17a /* shifted command key */ |
#define KEY_SCOPY 0x17b /* shifted copy key */ |
#define KEY_SCREATE 0x17c /* shifted create key */ |
#define KEY_SDC 0x17d /* shifted delete char key */ |
#define KEY_SDL 0x17e /* shifted delete line key */ |
#define KEY_SELECT 0x17f /* select key */ |
#define KEY_SEND 0x180 /* shifted end key */ |
#define KEY_SEOL 0x181 /* shifted clear line key */ |
#define KEY_SEXIT 0x182 /* shifted exit key */ |
#define KEY_SFIND 0x183 /* shifted find key */ |
#define KEY_SHOME 0x184 /* shifted home key */ |
#define KEY_SIC 0x185 /* shifted input key */ |
#define KEY_SLEFT 0x187 /* shifted left arrow key */ |
#define KEY_SMESSAGE 0x188 /* shifted message key */ |
#define KEY_SMOVE 0x189 /* shifted move key */ |
#define KEY_SNEXT 0x18a /* shifted next key */ |
#define KEY_SOPTIONS 0x18b /* shifted options key */ |
#define KEY_SPREVIOUS 0x18c /* shifted prev key */ |
#define KEY_SPRINT 0x18d /* shifted print key */ |
#define KEY_SREDO 0x18e /* shifted redo key */ |
#define KEY_SREPLACE 0x18f /* shifted replace key */ |
#define KEY_SRIGHT 0x190 /* shifted right arrow */ |
#define KEY_SRSUME 0x191 /* shifted resume key */ |
#define KEY_SSAVE 0x192 /* shifted save key */ |
#define KEY_SSUSPEND 0x193 /* shifted suspend key */ |
#define KEY_SUNDO 0x194 /* shifted undo key */ |
#define KEY_SUSPEND 0x195 /* suspend key */ |
#define KEY_UNDO 0x196 /* undo key */ |
/* PDCurses-specific key definitions -- PC only */ |
#define ALT_0 0x197 |
#define ALT_1 0x198 |
#define ALT_2 0x199 |
#define ALT_3 0x19a |
#define ALT_4 0x19b |
#define ALT_5 0x19c |
#define ALT_6 0x19d |
#define ALT_7 0x19e |
#define ALT_8 0x19f |
#define ALT_9 0x1a0 |
#define ALT_A 0x1a1 |
#define ALT_B 0x1a2 |
#define ALT_C 0x1a3 |
#define ALT_D 0x1a4 |
#define ALT_E 0x1a5 |
#define ALT_F 0x1a6 |
#define ALT_G 0x1a7 |
#define ALT_H 0x1a8 |
#define ALT_I 0x1a9 |
#define ALT_J 0x1aa |
#define ALT_K 0x1ab |
#define ALT_L 0x1ac |
#define ALT_M 0x1ad |
#define ALT_N 0x1ae |
#define ALT_O 0x1af |
#define ALT_P 0x1b0 |
#define ALT_Q 0x1b1 |
#define ALT_R 0x1b2 |
#define ALT_S 0x1b3 |
#define ALT_T 0x1b4 |
#define ALT_U 0x1b5 |
#define ALT_V 0x1b6 |
#define ALT_W 0x1b7 |
#define ALT_X 0x1b8 |
#define ALT_Y 0x1b9 |
#define ALT_Z 0x1ba |
#define CTL_LEFT 0x1bb /* Control-Left-Arrow */ |
#define CTL_RIGHT 0x1bc |
#define CTL_PGUP 0x1bd |
#define CTL_PGDN 0x1be |
#define CTL_HOME 0x1bf |
#define CTL_END 0x1c0 |
#define KEY_A1 0x1c1 /* upper left on Virtual keypad */ |
#define KEY_A2 0x1c2 /* upper middle on Virt. keypad */ |
#define KEY_A3 0x1c3 /* upper right on Vir. keypad */ |
#define KEY_B1 0x1c4 /* middle left on Virt. keypad */ |
#define KEY_B2 0x1c5 /* center on Virt. keypad */ |
#define KEY_B3 0x1c6 /* middle right on Vir. keypad */ |
#define KEY_C1 0x1c7 /* lower left on Virt. keypad */ |
#define KEY_C2 0x1c8 /* lower middle on Virt. keypad */ |
#define KEY_C3 0x1c9 /* lower right on Vir. keypad */ |
#define PADSLASH 0x1ca /* slash on keypad */ |
#define PADENTER 0x1cb /* enter on keypad */ |
#define CTL_PADENTER 0x1cc /* ctl-enter on keypad */ |
#define ALT_PADENTER 0x1cd /* alt-enter on keypad */ |
#define PADSTOP 0x1ce /* stop on keypad */ |
#define PADSTAR 0x1cf /* star on keypad */ |
#define PADMINUS 0x1d0 /* minus on keypad */ |
#define PADPLUS 0x1d1 /* plus on keypad */ |
#define CTL_PADSTOP 0x1d2 /* ctl-stop on keypad */ |
#define CTL_PADCENTER 0x1d3 /* ctl-enter on keypad */ |
#define CTL_PADPLUS 0x1d4 /* ctl-plus on keypad */ |
#define CTL_PADMINUS 0x1d5 /* ctl-minus on keypad */ |
#define CTL_PADSLASH 0x1d6 /* ctl-slash on keypad */ |
#define CTL_PADSTAR 0x1d7 /* ctl-star on keypad */ |
#define ALT_PADPLUS 0x1d8 /* alt-plus on keypad */ |
#define ALT_PADMINUS 0x1d9 /* alt-minus on keypad */ |
#define ALT_PADSLASH 0x1da /* alt-slash on keypad */ |
#define ALT_PADSTAR 0x1db /* alt-star on keypad */ |
#define ALT_PADSTOP 0x1dc /* alt-stop on keypad */ |
#define CTL_INS 0x1dd /* ctl-insert */ |
#define ALT_DEL 0x1de /* alt-delete */ |
#define ALT_INS 0x1df /* alt-insert */ |
#define CTL_UP 0x1e0 /* ctl-up arrow */ |
#define CTL_DOWN 0x1e1 /* ctl-down arrow */ |
#define CTL_TAB 0x1e2 /* ctl-tab */ |
#define ALT_TAB 0x1e3 |
#define ALT_MINUS 0x1e4 |
#define ALT_EQUAL 0x1e5 |
#define ALT_HOME 0x1e6 |
#define ALT_PGUP 0x1e7 |
#define ALT_PGDN 0x1e8 |
#define ALT_END 0x1e9 |
#define ALT_UP 0x1ea /* alt-up arrow */ |
#define ALT_DOWN 0x1eb /* alt-down arrow */ |
#define ALT_RIGHT 0x1ec /* alt-right arrow */ |
#define ALT_LEFT 0x1ed /* alt-left arrow */ |
#define ALT_ENTER 0x1ee /* alt-enter */ |
#define ALT_ESC 0x1ef /* alt-escape */ |
#define ALT_BQUOTE 0x1f0 /* alt-back quote */ |
#define ALT_LBRACKET 0x1f1 /* alt-left bracket */ |
#define ALT_RBRACKET 0x1f2 /* alt-right bracket */ |
#define ALT_SEMICOLON 0x1f3 /* alt-semi-colon */ |
#define ALT_FQUOTE 0x1f4 /* alt-forward quote */ |
#define ALT_COMMA 0x1f5 /* alt-comma */ |
#define ALT_STOP 0x1f6 /* alt-stop */ |
#define ALT_FSLASH 0x1f7 /* alt-forward slash */ |
#define ALT_BKSP 0x1f8 /* alt-backspace */ |
#define CTL_BKSP 0x1f9 /* ctl-backspace */ |
#define PAD0 0x1fa /* keypad 0 */ |
#define CTL_PAD0 0x1fb /* ctl-keypad 0 */ |
#define CTL_PAD1 0x1fc |
#define CTL_PAD2 0x1fd |
#define CTL_PAD3 0x1fe |
#define CTL_PAD4 0x1ff |
#define CTL_PAD5 0x200 |
#define CTL_PAD6 0x201 |
#define CTL_PAD7 0x202 |
#define CTL_PAD8 0x203 |
#define CTL_PAD9 0x204 |
#define ALT_PAD0 0x205 /* alt-keypad 0 */ |
#define ALT_PAD1 0x206 |
#define ALT_PAD2 0x207 |
#define ALT_PAD3 0x208 |
#define ALT_PAD4 0x209 |
#define ALT_PAD5 0x20a |
#define ALT_PAD6 0x20b |
#define ALT_PAD7 0x20c |
#define ALT_PAD8 0x20d |
#define ALT_PAD9 0x20e |
#define CTL_DEL 0x20f /* clt-delete */ |
#define ALT_BSLASH 0x210 /* alt-back slash */ |
#define CTL_ENTER 0x211 /* ctl-enter */ |
#define SHF_PADENTER 0x212 /* shift-enter on keypad */ |
#define SHF_PADSLASH 0x213 /* shift-slash on keypad */ |
#define SHF_PADSTAR 0x214 /* shift-star on keypad */ |
#define SHF_PADPLUS 0x215 /* shift-plus on keypad */ |
#define SHF_PADMINUS 0x216 /* shift-minus on keypad */ |
#define SHF_UP 0x217 /* shift-up on keypad */ |
#define SHF_DOWN 0x218 /* shift-down on keypad */ |
#define SHF_IC 0x219 /* shift-insert on keypad */ |
#define SHF_DC 0x21a /* shift-delete on keypad */ |
#define KEY_MOUSE 0x21b /* "mouse" key */ |
#define KEY_SHIFT_L 0x21c /* Left-shift */ |
#define KEY_SHIFT_R 0x21d /* Right-shift */ |
#define KEY_CONTROL_L 0x21e /* Left-control */ |
#define KEY_CONTROL_R 0x21f /* Right-control */ |
#define KEY_ALT_L 0x220 /* Left-alt */ |
#define KEY_ALT_R 0x221 /* Right-alt */ |
#define KEY_RESIZE 0x222 /* Window resize */ |
#define KEY_SUP 0x223 /* Shifted up arrow */ |
#define KEY_SDOWN 0x224 /* Shifted down arrow */ |
#define KEY_MIN KEY_BREAK /* Minimum curses key value */ |
#define KEY_MAX KEY_SDOWN /* Maximum curses key */ |
#define KEY_F(n) (KEY_F0 + (n)) |
/*---------------------------------------------------------------------- |
* |
* Functions |
* |
*/ |
/* Standard */ |
PDCEX int addch(const chtype); |
PDCEX int addchnstr(const chtype *, int); |
PDCEX int addchstr(const chtype *); |
PDCEX int addnstr(const char *, int); |
PDCEX int addstr(const char *); |
PDCEX int attroff(chtype); |
PDCEX int attron(chtype); |
PDCEX int attrset(chtype); |
PDCEX int attr_get(attr_t *, short *, void *); |
PDCEX int attr_off(attr_t, void *); |
PDCEX int attr_on(attr_t, void *); |
PDCEX int attr_set(attr_t, short, void *); |
PDCEX int baudrate(void); |
PDCEX int beep(void); |
PDCEX int bkgd(chtype); |
PDCEX void bkgdset(chtype); |
PDCEX int border(chtype, chtype, chtype, chtype, |
chtype, chtype, chtype, chtype); |
PDCEX int box(WINDOW *, chtype, chtype); |
PDCEX bool can_change_color(void); |
PDCEX int cbreak(void); |
PDCEX int chgat(int, attr_t, short, const void *); |
PDCEX int clearok(WINDOW *, bool); |
PDCEX int clear(void); |
PDCEX int clrtobot(void); |
PDCEX int clrtoeol(void); |
PDCEX int color_content(short, short *, short *, short *); |
PDCEX int color_set(short, void *); |
PDCEX int copywin(const WINDOW *, WINDOW *, int, int, int, |
int, int, int, int); |
PDCEX int curs_set(int); |
PDCEX int def_prog_mode(void); |
PDCEX int def_shell_mode(void); |
PDCEX int delay_output(int); |
PDCEX int delch(void); |
PDCEX int deleteln(void); |
PDCEX void delscreen(SCREEN *); |
PDCEX int delwin(WINDOW *); |
PDCEX WINDOW *derwin(WINDOW *, int, int, int, int); |
PDCEX int doupdate(void); |
PDCEX WINDOW *dupwin(WINDOW *); |
PDCEX int echochar(const chtype); |
PDCEX int echo(void); |
PDCEX int endwin(void); |
PDCEX char erasechar(void); |
PDCEX int erase(void); |
PDCEX void filter(void); |
PDCEX int flash(void); |
PDCEX int flushinp(void); |
PDCEX chtype getbkgd(WINDOW *); |
PDCEX int getnstr(char *, int); |
PDCEX int getstr(char *); |
PDCEX WINDOW *getwin(FILE *); |
PDCEX int halfdelay(int); |
PDCEX bool has_colors(void); |
PDCEX bool has_ic(void); |
PDCEX bool has_il(void); |
PDCEX int hline(chtype, int); |
PDCEX void idcok(WINDOW *, bool); |
PDCEX int idlok(WINDOW *, bool); |
PDCEX void immedok(WINDOW *, bool); |
PDCEX int inchnstr(chtype *, int); |
PDCEX int inchstr(chtype *); |
PDCEX chtype inch(void); |
PDCEX int init_color(short, short, short, short); |
PDCEX int init_pair(short, short, short); |
PDCEX WINDOW *initscr(void); |
PDCEX int innstr(char *, int); |
PDCEX int insch(chtype); |
PDCEX int insdelln(int); |
PDCEX int insertln(void); |
PDCEX int insnstr(const char *, int); |
PDCEX int insstr(const char *); |
PDCEX int instr(char *); |
PDCEX int intrflush(WINDOW *, bool); |
PDCEX bool isendwin(void); |
PDCEX bool is_linetouched(WINDOW *, int); |
PDCEX bool is_wintouched(WINDOW *); |
PDCEX char *keyname(int); |
PDCEX int keypad(WINDOW *, bool); |
PDCEX char killchar(void); |
PDCEX int leaveok(WINDOW *, bool); |
PDCEX char *longname(void); |
PDCEX int meta(WINDOW *, bool); |
PDCEX int move(int, int); |
PDCEX int mvaddch(int, int, const chtype); |
PDCEX int mvaddchnstr(int, int, const chtype *, int); |
PDCEX int mvaddchstr(int, int, const chtype *); |
PDCEX int mvaddnstr(int, int, const char *, int); |
PDCEX int mvaddstr(int, int, const char *); |
PDCEX int mvchgat(int, int, int, attr_t, short, const void *); |
PDCEX int mvcur(int, int, int, int); |
PDCEX int mvdelch(int, int); |
PDCEX int mvderwin(WINDOW *, int, int); |
PDCEX int mvgetch(int, int); |
PDCEX int mvgetnstr(int, int, char *, int); |
PDCEX int mvgetstr(int, int, char *); |
PDCEX int mvhline(int, int, chtype, int); |
PDCEX chtype mvinch(int, int); |
PDCEX int mvinchnstr(int, int, chtype *, int); |
PDCEX int mvinchstr(int, int, chtype *); |
PDCEX int mvinnstr(int, int, char *, int); |
PDCEX int mvinsch(int, int, chtype); |
PDCEX int mvinsnstr(int, int, const char *, int); |
PDCEX int mvinsstr(int, int, const char *); |
PDCEX int mvinstr(int, int, char *); |
PDCEX int mvprintw(int, int, const char *, ...); |
PDCEX int mvscanw(int, int, const char *, ...); |
PDCEX int mvvline(int, int, chtype, int); |
PDCEX int mvwaddchnstr(WINDOW *, int, int, const chtype *, int); |
PDCEX int mvwaddchstr(WINDOW *, int, int, const chtype *); |
PDCEX int mvwaddch(WINDOW *, int, int, const chtype); |
PDCEX int mvwaddnstr(WINDOW *, int, int, const char *, int); |
PDCEX int mvwaddstr(WINDOW *, int, int, const char *); |
PDCEX int mvwchgat(WINDOW *, int, int, int, attr_t, short, const void *); |
PDCEX int mvwdelch(WINDOW *, int, int); |
PDCEX int mvwgetch(WINDOW *, int, int); |
PDCEX int mvwgetnstr(WINDOW *, int, int, char *, int); |
PDCEX int mvwgetstr(WINDOW *, int, int, char *); |
PDCEX int mvwhline(WINDOW *, int, int, chtype, int); |
PDCEX int mvwinchnstr(WINDOW *, int, int, chtype *, int); |
PDCEX int mvwinchstr(WINDOW *, int, int, chtype *); |
PDCEX chtype mvwinch(WINDOW *, int, int); |
PDCEX int mvwinnstr(WINDOW *, int, int, char *, int); |
PDCEX int mvwinsch(WINDOW *, int, int, chtype); |
PDCEX int mvwinsnstr(WINDOW *, int, int, const char *, int); |
PDCEX int mvwinsstr(WINDOW *, int, int, const char *); |
PDCEX int mvwinstr(WINDOW *, int, int, char *); |
PDCEX int mvwin(WINDOW *, int, int); |
PDCEX int mvwprintw(WINDOW *, int, int, const char *, ...); |
PDCEX int mvwscanw(WINDOW *, int, int, const char *, ...); |
PDCEX int mvwvline(WINDOW *, int, int, chtype, int); |
PDCEX int napms(int); |
PDCEX WINDOW *newpad(int, int); |
PDCEX SCREEN *newterm(const char *, FILE *, FILE *); |
PDCEX WINDOW *newwin(int, int, int, int); |
PDCEX int nl(void); |
PDCEX int nocbreak(void); |
PDCEX int nodelay(WINDOW *, bool); |
PDCEX int noecho(void); |
PDCEX int nonl(void); |
PDCEX void noqiflush(void); |
PDCEX int noraw(void); |
PDCEX int notimeout(WINDOW *, bool); |
PDCEX int overlay(const WINDOW *, WINDOW *); |
PDCEX int overwrite(const WINDOW *, WINDOW *); |
PDCEX int pair_content(short, short *, short *); |
PDCEX int pechochar(WINDOW *, chtype); |
PDCEX int pnoutrefresh(WINDOW *, int, int, int, int, int, int); |
PDCEX int prefresh(WINDOW *, int, int, int, int, int, int); |
PDCEX int printw(const char *, ...); |
PDCEX int putwin(WINDOW *, FILE *); |
PDCEX void qiflush(void); |
PDCEX int raw(void); |
PDCEX int redrawwin(WINDOW *); |
PDCEX int refresh(void); |
PDCEX int reset_prog_mode(void); |
PDCEX int reset_shell_mode(void); |
PDCEX int resetty(void); |
PDCEX int ripoffline(int, int (*)(WINDOW *, int)); |
PDCEX int savetty(void); |
PDCEX int scanw(const char *, ...); |
PDCEX int scr_dump(const char *); |
PDCEX int scr_init(const char *); |
PDCEX int scr_restore(const char *); |
PDCEX int scr_set(const char *); |
PDCEX int scrl(int); |
PDCEX int scroll(WINDOW *); |
PDCEX int scrollok(WINDOW *, bool); |
PDCEX SCREEN *set_term(SCREEN *); |
PDCEX int setscrreg(int, int); |
PDCEX int slk_attroff(const chtype); |
PDCEX int slk_attr_off(const attr_t, void *); |
PDCEX int slk_attron(const chtype); |
PDCEX int slk_attr_on(const attr_t, void *); |
PDCEX int slk_attrset(const chtype); |
PDCEX int slk_attr_set(const attr_t, short, void *); |
PDCEX int slk_clear(void); |
PDCEX int slk_color(short); |
PDCEX int slk_init(int); |
PDCEX char *slk_label(int); |
PDCEX int slk_noutrefresh(void); |
PDCEX int slk_refresh(void); |
PDCEX int slk_restore(void); |
PDCEX int slk_set(int, const char *, int); |
PDCEX int slk_touch(void); |
PDCEX int standend(void); |
PDCEX int standout(void); |
PDCEX int start_color(void); |
PDCEX WINDOW *subpad(WINDOW *, int, int, int, int); |
PDCEX WINDOW *subwin(WINDOW *, int, int, int, int); |
PDCEX int syncok(WINDOW *, bool); |
PDCEX chtype termattrs(void); |
PDCEX attr_t term_attrs(void); |
PDCEX char *termname(void); |
PDCEX void timeout(int); |
PDCEX int touchline(WINDOW *, int, int); |
PDCEX int touchwin(WINDOW *); |
PDCEX int typeahead(int); |
PDCEX int untouchwin(WINDOW *); |
PDCEX void use_env(bool); |
PDCEX int vidattr(chtype); |
PDCEX int vid_attr(attr_t, short, void *); |
PDCEX int vidputs(chtype, int (*)(int)); |
PDCEX int vid_puts(attr_t, short, void *, int (*)(int)); |
PDCEX int vline(chtype, int); |
PDCEX int vw_printw(WINDOW *, const char *, va_list); |
PDCEX int vwprintw(WINDOW *, const char *, va_list); |
PDCEX int vw_scanw(WINDOW *, const char *, va_list); |
PDCEX int vwscanw(WINDOW *, const char *, va_list); |
PDCEX int waddchnstr(WINDOW *, const chtype *, int); |
PDCEX int waddchstr(WINDOW *, const chtype *); |
PDCEX int waddch(WINDOW *, const chtype); |
PDCEX int waddnstr(WINDOW *, const char *, int); |
PDCEX int waddstr(WINDOW *, const char *); |
PDCEX int wattroff(WINDOW *, chtype); |
PDCEX int wattron(WINDOW *, chtype); |
PDCEX int wattrset(WINDOW *, chtype); |
PDCEX int wattr_get(WINDOW *, attr_t *, short *, void *); |
PDCEX int wattr_off(WINDOW *, attr_t, void *); |
PDCEX int wattr_on(WINDOW *, attr_t, void *); |
PDCEX int wattr_set(WINDOW *, attr_t, short, void *); |
PDCEX void wbkgdset(WINDOW *, chtype); |
PDCEX int wbkgd(WINDOW *, chtype); |
PDCEX int wborder(WINDOW *, chtype, chtype, chtype, chtype, |
chtype, chtype, chtype, chtype); |
PDCEX int wchgat(WINDOW *, int, attr_t, short, const void *); |
PDCEX int wclear(WINDOW *); |
PDCEX int wclrtobot(WINDOW *); |
PDCEX int wclrtoeol(WINDOW *); |
PDCEX int wcolor_set(WINDOW *, short, void *); |
PDCEX void wcursyncup(WINDOW *); |
PDCEX int wdelch(WINDOW *); |
PDCEX int wdeleteln(WINDOW *); |
PDCEX int wechochar(WINDOW *, const chtype); |
PDCEX int werase(WINDOW *); |
PDCEX int wgetch(WINDOW *); |
PDCEX int wgetnstr(WINDOW *, char *, int); |
PDCEX int wgetstr(WINDOW *, char *); |
PDCEX int whline(WINDOW *, chtype, int); |
PDCEX int winchnstr(WINDOW *, chtype *, int); |
PDCEX int winchstr(WINDOW *, chtype *); |
PDCEX chtype winch(WINDOW *); |
PDCEX int winnstr(WINDOW *, char *, int); |
PDCEX int winsch(WINDOW *, chtype); |
PDCEX int winsdelln(WINDOW *, int); |
PDCEX int winsertln(WINDOW *); |
PDCEX int winsnstr(WINDOW *, const char *, int); |
PDCEX int winsstr(WINDOW *, const char *); |
PDCEX int winstr(WINDOW *, char *); |
PDCEX int wmove(WINDOW *, int, int); |
PDCEX int wnoutrefresh(WINDOW *); |
PDCEX int wprintw(WINDOW *, const char *, ...); |
PDCEX int wredrawln(WINDOW *, int, int); |
PDCEX int wrefresh(WINDOW *); |
PDCEX int wscanw(WINDOW *, const char *, ...); |
PDCEX int wscrl(WINDOW *, int); |
PDCEX int wsetscrreg(WINDOW *, int, int); |
PDCEX int wstandend(WINDOW *); |
PDCEX int wstandout(WINDOW *); |
PDCEX void wsyncdown(WINDOW *); |
PDCEX void wsyncup(WINDOW *); |
PDCEX void wtimeout(WINDOW *, int); |
PDCEX int wtouchln(WINDOW *, int, int, int); |
PDCEX int wvline(WINDOW *, chtype, int); |
/* Wide-character functions */ |
#ifdef PDC_WIDE |
PDCEX int addnwstr(const wchar_t *, int); |
PDCEX int addwstr(const wchar_t *); |
PDCEX int add_wch(const cchar_t *); |
PDCEX int add_wchnstr(const cchar_t *, int); |
PDCEX int add_wchstr(const cchar_t *); |
PDCEX int bkgrnd(const cchar_t *); |
PDCEX void bkgrndset(const cchar_t *); |
PDCEX int border_set(const cchar_t *, const cchar_t *, const cchar_t *, |
const cchar_t *, const cchar_t *, const cchar_t *, |
const cchar_t *, const cchar_t *); |
PDCEX int box_set(WINDOW *, const cchar_t *, const cchar_t *); |
PDCEX int echo_wchar(const cchar_t *); |
PDCEX int erasewchar(wchar_t *); |
PDCEX int getbkgrnd(cchar_t *); |
PDCEX int getcchar(const cchar_t *, wchar_t *, attr_t *, short *, void *); |
PDCEX int getn_wstr(wint_t *, int); |
PDCEX int get_wch(wint_t *); |
PDCEX int get_wstr(wint_t *); |
PDCEX int hline_set(const cchar_t *, int); |
PDCEX int innwstr(wchar_t *, int); |
PDCEX int ins_nwstr(const wchar_t *, int); |
PDCEX int ins_wch(const cchar_t *); |
PDCEX int ins_wstr(const wchar_t *); |
PDCEX int inwstr(wchar_t *); |
PDCEX int in_wch(cchar_t *); |
PDCEX int in_wchnstr(cchar_t *, int); |
PDCEX int in_wchstr(cchar_t *); |
PDCEX char *key_name(wchar_t); |
PDCEX int killwchar(wchar_t *); |
PDCEX int mvaddnwstr(int, int, const wchar_t *, int); |
PDCEX int mvaddwstr(int, int, const wchar_t *); |
PDCEX int mvadd_wch(int, int, const cchar_t *); |
PDCEX int mvadd_wchnstr(int, int, const cchar_t *, int); |
PDCEX int mvadd_wchstr(int, int, const cchar_t *); |
PDCEX int mvgetn_wstr(int, int, wint_t *, int); |
PDCEX int mvget_wch(int, int, wint_t *); |
PDCEX int mvget_wstr(int, int, wint_t *); |
PDCEX int mvhline_set(int, int, const cchar_t *, int); |
PDCEX int mvinnwstr(int, int, wchar_t *, int); |
PDCEX int mvins_nwstr(int, int, const wchar_t *, int); |
PDCEX int mvins_wch(int, int, const cchar_t *); |
PDCEX int mvins_wstr(int, int, const wchar_t *); |
PDCEX int mvinwstr(int, int, wchar_t *); |
PDCEX int mvin_wch(int, int, cchar_t *); |
PDCEX int mvin_wchnstr(int, int, cchar_t *, int); |
PDCEX int mvin_wchstr(int, int, cchar_t *); |
PDCEX int mvvline_set(int, int, const cchar_t *, int); |
PDCEX int mvwaddnwstr(WINDOW *, int, int, const wchar_t *, int); |
PDCEX int mvwaddwstr(WINDOW *, int, int, const wchar_t *); |
PDCEX int mvwadd_wch(WINDOW *, int, int, const cchar_t *); |
PDCEX int mvwadd_wchnstr(WINDOW *, int, int, const cchar_t *, int); |
PDCEX int mvwadd_wchstr(WINDOW *, int, int, const cchar_t *); |
PDCEX int mvwgetn_wstr(WINDOW *, int, int, wint_t *, int); |
PDCEX int mvwget_wch(WINDOW *, int, int, wint_t *); |
PDCEX int mvwget_wstr(WINDOW *, int, int, wint_t *); |
PDCEX int mvwhline_set(WINDOW *, int, int, const cchar_t *, int); |
PDCEX int mvwinnwstr(WINDOW *, int, int, wchar_t *, int); |
PDCEX int mvwins_nwstr(WINDOW *, int, int, const wchar_t *, int); |
PDCEX int mvwins_wch(WINDOW *, int, int, const cchar_t *); |
PDCEX int mvwins_wstr(WINDOW *, int, int, const wchar_t *); |
PDCEX int mvwin_wch(WINDOW *, int, int, cchar_t *); |
PDCEX int mvwin_wchnstr(WINDOW *, int, int, cchar_t *, int); |
PDCEX int mvwin_wchstr(WINDOW *, int, int, cchar_t *); |
PDCEX int mvwinwstr(WINDOW *, int, int, wchar_t *); |
PDCEX int mvwvline_set(WINDOW *, int, int, const cchar_t *, int); |
PDCEX int pecho_wchar(WINDOW *, const cchar_t*); |
PDCEX int setcchar(cchar_t*, const wchar_t*, const attr_t, |
short, const void*); |
PDCEX int slk_wset(int, const wchar_t *, int); |
PDCEX int unget_wch(const wchar_t); |
PDCEX int vline_set(const cchar_t *, int); |
PDCEX int waddnwstr(WINDOW *, const wchar_t *, int); |
PDCEX int waddwstr(WINDOW *, const wchar_t *); |
PDCEX int wadd_wch(WINDOW *, const cchar_t *); |
PDCEX int wadd_wchnstr(WINDOW *, const cchar_t *, int); |
PDCEX int wadd_wchstr(WINDOW *, const cchar_t *); |
PDCEX int wbkgrnd(WINDOW *, const cchar_t *); |
PDCEX void wbkgrndset(WINDOW *, const cchar_t *); |
PDCEX int wborder_set(WINDOW *, const cchar_t *, const cchar_t *, |
const cchar_t *, const cchar_t *, const cchar_t *, |
const cchar_t *, const cchar_t *, const cchar_t *); |
PDCEX int wecho_wchar(WINDOW *, const cchar_t *); |
PDCEX int wgetbkgrnd(WINDOW *, cchar_t *); |
PDCEX int wgetn_wstr(WINDOW *, wint_t *, int); |
PDCEX int wget_wch(WINDOW *, wint_t *); |
PDCEX int wget_wstr(WINDOW *, wint_t *); |
PDCEX int whline_set(WINDOW *, const cchar_t *, int); |
PDCEX int winnwstr(WINDOW *, wchar_t *, int); |
PDCEX int wins_nwstr(WINDOW *, const wchar_t *, int); |
PDCEX int wins_wch(WINDOW *, const cchar_t *); |
PDCEX int wins_wstr(WINDOW *, const wchar_t *); |
PDCEX int winwstr(WINDOW *, wchar_t *); |
PDCEX int win_wch(WINDOW *, cchar_t *); |
PDCEX int win_wchnstr(WINDOW *, cchar_t *, int); |
PDCEX int win_wchstr(WINDOW *, cchar_t *); |
PDCEX wchar_t *wunctrl(cchar_t *); |
PDCEX int wvline_set(WINDOW *, const cchar_t *, int); |
#endif |
/* Quasi-standard */ |
PDCEX chtype getattrs(WINDOW *); |
PDCEX int getbegx(WINDOW *); |
PDCEX int getbegy(WINDOW *); |
PDCEX int getmaxx(WINDOW *); |
PDCEX int getmaxy(WINDOW *); |
PDCEX int getparx(WINDOW *); |
PDCEX int getpary(WINDOW *); |
PDCEX int getcurx(WINDOW *); |
PDCEX int getcury(WINDOW *); |
PDCEX void traceoff(void); |
PDCEX void traceon(void); |
PDCEX char *unctrl(chtype); |
PDCEX int crmode(void); |
PDCEX int nocrmode(void); |
PDCEX int draino(int); |
PDCEX int resetterm(void); |
PDCEX int fixterm(void); |
PDCEX int saveterm(void); |
PDCEX void setsyx(int, int); |
PDCEX int mouse_set(mmask_t); |
PDCEX int mouse_on(mmask_t); |
PDCEX int mouse_off(mmask_t); |
PDCEX int request_mouse_pos(void); |
PDCEX void wmouse_position(WINDOW *, int *, int *); |
PDCEX mmask_t getmouse(void); |
/* ncurses */ |
PDCEX int alloc_pair(int, int); |
PDCEX int assume_default_colors(int, int); |
PDCEX const char *curses_version(void); |
PDCEX int find_pair(int, int); |
PDCEX int free_pair(int); |
PDCEX bool has_key(int); |
PDCEX bool is_keypad(const WINDOW *); |
PDCEX bool is_leaveok(const WINDOW *); |
PDCEX bool is_pad(const WINDOW *); |
PDCEX int set_tabsize(int); |
PDCEX int use_default_colors(void); |
PDCEX int wresize(WINDOW *, int, int); |
PDCEX bool has_mouse(void); |
PDCEX int mouseinterval(int); |
PDCEX mmask_t mousemask(mmask_t, mmask_t *); |
PDCEX bool mouse_trafo(int *, int *, bool); |
PDCEX int nc_getmouse(MEVENT *); |
PDCEX int ungetmouse(MEVENT *); |
PDCEX bool wenclose(const WINDOW *, int, int); |
PDCEX bool wmouse_trafo(const WINDOW *, int *, int *, bool); |
/* PDCurses */ |
PDCEX int addrawch(chtype); |
PDCEX int insrawch(chtype); |
PDCEX bool is_termresized(void); |
PDCEX int mvaddrawch(int, int, chtype); |
PDCEX int mvdeleteln(int, int); |
PDCEX int mvinsertln(int, int); |
PDCEX int mvinsrawch(int, int, chtype); |
PDCEX int mvwaddrawch(WINDOW *, int, int, chtype); |
PDCEX int mvwdeleteln(WINDOW *, int, int); |
PDCEX int mvwinsertln(WINDOW *, int, int); |
PDCEX int mvwinsrawch(WINDOW *, int, int, chtype); |
PDCEX int raw_output(bool); |
PDCEX int resize_term(int, int); |
PDCEX WINDOW *resize_window(WINDOW *, int, int); |
PDCEX int waddrawch(WINDOW *, chtype); |
PDCEX int winsrawch(WINDOW *, chtype); |
PDCEX char wordchar(void); |
#ifdef PDC_WIDE |
PDCEX wchar_t *slk_wlabel(int); |
#endif |
PDCEX void PDC_debug(const char *, ...); |
PDCEX void PDC_get_version(PDC_VERSION *); |
PDCEX int PDC_ungetch(int); |
PDCEX int PDC_set_blink(bool); |
PDCEX int PDC_set_bold(bool); |
PDCEX int PDC_set_line_color(short); |
PDCEX void PDC_set_title(const char *); |
PDCEX int PDC_clearclipboard(void); |
PDCEX int PDC_freeclipboard(char *); |
PDCEX int PDC_getclipboard(char **, long *); |
PDCEX int PDC_setclipboard(const char *, long); |
PDCEX unsigned long PDC_get_key_modifiers(void); |
PDCEX int PDC_return_key_modifiers(bool); |
#ifdef XCURSES |
PDCEX WINDOW *Xinitscr(int, char **); |
PDCEX void XCursesExit(void); |
PDCEX int sb_init(void); |
PDCEX int sb_set_horz(int, int, int); |
PDCEX int sb_set_vert(int, int, int); |
PDCEX int sb_get_horz(int *, int *, int *); |
PDCEX int sb_get_vert(int *, int *, int *); |
PDCEX int sb_refresh(void); |
#endif |
/* NetBSD */ |
PDCEX int touchoverlap(const WINDOW *, WINDOW *); |
PDCEX int underend(void); |
PDCEX int underscore(void); |
PDCEX int wunderend(WINDOW *); |
PDCEX int wunderscore(WINDOW *); |
/*** Functions defined as macros ***/ |
/* getch() and ungetch() conflict with some DOS libraries */ |
#define getch() wgetch(stdscr) |
#define ungetch(ch) PDC_ungetch(ch) |
#define COLOR_PAIR(n) (((chtype)(n) << PDC_COLOR_SHIFT) & A_COLOR) |
#define PAIR_NUMBER(n) (((n) & A_COLOR) >> PDC_COLOR_SHIFT) |
/* These will _only_ work as macros */ |
#define getbegyx(w, y, x) (y = getbegy(w), x = getbegx(w)) |
#define getmaxyx(w, y, x) (y = getmaxy(w), x = getmaxx(w)) |
#define getparyx(w, y, x) (y = getpary(w), x = getparx(w)) |
#define getyx(w, y, x) (y = getcury(w), x = getcurx(w)) |
#define getsyx(y, x) { if (curscr->_leaveit) (y)=(x)=-1; \ |
else getyx(curscr,(y),(x)); } |
#ifdef NCURSES_MOUSE_VERSION |
# define getmouse(x) nc_getmouse(x) |
#endif |
/* Deprecated */ |
#define PDC_save_key_modifiers(x) (OK) |
#define PDC_get_input_fd() 0 |
/* return codes from PDC_getclipboard() and PDC_setclipboard() calls */ |
#define PDC_CLIP_SUCCESS 0 |
#define PDC_CLIP_ACCESS_ERROR 1 |
#define PDC_CLIP_EMPTY 2 |
#define PDC_CLIP_MEMORY_ERROR 3 |
/* PDCurses key modifier masks */ |
#define PDC_KEY_MODIFIER_SHIFT 1 |
#define PDC_KEY_MODIFIER_CONTROL 2 |
#define PDC_KEY_MODIFIER_ALT 4 |
#define PDC_KEY_MODIFIER_NUMLOCK 8 |
#ifdef __cplusplus |
# ifndef PDC_PP98 |
# undef bool |
# endif |
} |
#endif |
#endif /* __PDCURSES__ */ |
/contrib/sdk/sources/PDCurses/curspriv.h |
---|
0,0 → 1,122 |
/* Private definitions and declarations for use within PDCurses. |
These should generally not be referenced by applications. */ |
#ifndef __CURSES_INTERNALS__ |
#define __CURSES_INTERNALS__ 1 |
#define CURSES_LIBRARY |
#include <curses.h> |
#if defined(__TURBOC__) || defined(__EMX__) || defined(__DJGPP__) || \ |
defined(PDC_99) || defined(__WATCOMC__) |
# ifndef HAVE_VSSCANF |
# define HAVE_VSSCANF /* have vsscanf() */ |
# endif |
#endif |
#if defined(PDC_99) || defined(__WATCOMC__) |
# ifndef HAVE_VSNPRINTF |
# define HAVE_VSNPRINTF /* have vsnprintf() */ |
# endif |
#endif |
/*----------------------------------------------------------------------*/ |
typedef struct /* structure for ripped off lines */ |
{ |
int line; |
int (*init)(WINDOW *, int); |
} RIPPEDOFFLINE; |
/* Window properties */ |
#define _SUBWIN 0x01 /* window is a subwindow */ |
#define _PAD 0x10 /* X/Open Pad. */ |
#define _SUBPAD 0x20 /* X/Open subpad. */ |
/* Miscellaneous */ |
#define _NO_CHANGE -1 /* flags line edge unchanged */ |
#define _ECHAR 0x08 /* Erase char (^H) */ |
#define _DWCHAR 0x17 /* Delete Word char (^W) */ |
#define _DLCHAR 0x15 /* Delete Line char (^U) */ |
/*----------------------------------------------------------------------*/ |
/* Platform implementation functions */ |
void PDC_beep(void); |
bool PDC_can_change_color(void); |
int PDC_color_content(short, short *, short *, short *); |
bool PDC_check_key(void); |
int PDC_curs_set(int); |
void PDC_doupdate(void); |
void PDC_flushinp(void); |
int PDC_get_columns(void); |
int PDC_get_cursor_mode(void); |
int PDC_get_key(void); |
int PDC_get_rows(void); |
void PDC_gotoyx(int, int); |
bool PDC_has_mouse(void); |
int PDC_init_color(short, short, short, short); |
int PDC_modifiers_set(void); |
int PDC_mouse_set(void); |
void PDC_napms(int); |
void PDC_reset_prog_mode(void); |
void PDC_reset_shell_mode(void); |
int PDC_resize_screen(int, int); |
void PDC_restore_screen_mode(int); |
void PDC_save_screen_mode(int); |
#ifdef XCURSES |
void PDC_set_args(int, char **); |
#endif |
void PDC_scr_close(void); |
void PDC_scr_free(void); |
int PDC_scr_open(void); |
void PDC_set_keyboard_binary(bool); |
void PDC_transform_line(int, int, int, const chtype *); |
const char *PDC_sysname(void); |
/* Internal cross-module functions */ |
void PDC_init_atrtab(void); |
WINDOW *PDC_makelines(WINDOW *); |
WINDOW *PDC_makenew(int, int, int, int); |
int PDC_mouse_in_slk(int, int); |
void PDC_slk_free(void); |
void PDC_slk_initialize(void); |
void PDC_sync(WINDOW *); |
#ifdef PDC_WIDE |
int PDC_mbtowc(wchar_t *, const char *, size_t); |
size_t PDC_mbstowcs(wchar_t *, const char *, size_t); |
size_t PDC_wcstombs(char *, const wchar_t *, size_t); |
#endif |
#ifdef PDCDEBUG |
# define PDC_LOG(x) if (SP && SP->dbfp) PDC_debug x |
#else |
# define PDC_LOG(x) |
#endif |
/* Internal macros for attributes */ |
#ifndef max |
# define max(a,b) (((a) > (b)) ? (a) : (b)) |
#endif |
#ifndef min |
# define min(a,b) (((a) < (b)) ? (a) : (b)) |
#endif |
#define DIVROUND(num, divisor) ((num) + ((divisor) >> 1)) / (divisor) |
#define PDC_CLICK_PERIOD 150 /* time to wait for a click, if |
not set by mouseinterval() */ |
#define PDC_COLOR_PAIRS 256 |
#define PDC_MAXCOL 768 /* maximum possible COLORS; may be less */ |
#define _INBUFSIZ 512 /* size of terminal input buffer */ |
#define NUNGETCH 256 /* max # chars to ungetch() */ |
#endif /* __CURSES_INTERNALS__ */ |
/contrib/sdk/sources/PDCurses/demos/Makefile |
---|
0,0 → 1,32 |
CC = kos32-gcc |
LD = kos32-ld |
OBJCOPY = kos32-objcopy |
KPACK = kpack |
BIN = xmas |
SDK_DIR = $(abspath ../../../../sdk) |
CFLAGS = -c -fno-ident -O2 -fomit-frame-pointer -fno-ident \ |
-U__WIN32__ -U_Win32 -U_WIN32 -U__MINGW32__ -UWIN32 -D_KOLIBRI \ |
-DSDL_strlcpy=strncpy -D_GNU_SOURCE=1 -D_REENTRANT -DNDEBUG -Wno-missing-field-initializers \ |
LDFLAGS = -static -S -nostdlib -T $(SDK_DIR)/sources/newlib/app.lds -Map=output.map --image-base 0 --subsystem native |
INCLUDES = -I$(SDK_DIR)/sources/newlib/libc/include -I$(SDK_DIR)/sources/SDL-1.2.2_newlib/include -I.. |
LIBPATH = -L$(SDK_DIR)/lib |
OBJS = xmas.o |
LIBS = -lgcc -lcurses -lSDLn -lsound -lc.dll |
$(BIN): $(OBJS) |
$(LD) $(LDFLAGS) $(LIBPATH) $(OBJS) -o $(BIN) $(LIBS) |
$(OBJCOPY) $(BIN) -O binary |
$(KPACK) --nologo $(BIN) |
%.o : %.c |
$(CC) $(CFLAGS) $(INCLUDES) -o $@ $< |
clean: |
rm src/*.o |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
/contrib/sdk/sources/PDCurses/demos/output.map |
---|
0,0 → 1,1707 |
Archive member included to satisfy reference by file (symbol) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) |
(_start) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
xmas.o (__main) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) (__DTOR_LIST__) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) (__crt_startup) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) (get_entry_point) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) (__register_frame_info) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) (__gthr_kos32_once) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
xmas.o (waddstr) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) (move) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
xmas.o (wattrset) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
xmas.o (initscr) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (slk_noutrefresh) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
xmas.o (noecho) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (wclrtobot) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
xmas.o (touchwin) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (wnoutrefresh) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) (PDC_sync) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
xmas.o (overlay) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (def_shell_mode) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) (whline) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) (subpad) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
xmas.o (waddch) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) (leaveok) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
xmas.o (init_pair) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) (mvwprintw) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (PDC_get_cursor_mode) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (PDC_scr_close) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) (PDC_curs_set) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) (PDC_transform_line) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) (PDC_set_keyboard_binary) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) (PDC_napms) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) (wscrl) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_Init) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_GetError) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) (SDL_InstallParachute) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) (SDL_getenv) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) (SDL_AudioInit) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) (SDL_PumpEvents) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_EnableUNICODE) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_mouse.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_MouseInit) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_quit.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_QuitInit) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_RWFromFile) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_CreateMutex) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) (SDL_CreateSemaphore) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_ThreadID) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_thread.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_CreateThread) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_SetTimerThreaded) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systimer.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) (SDL_StartTicks) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_LoadBMP_RW) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) (SDL_ShowCursor) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_MapRGB) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) (SDL_SetColorKey) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (SDL_GetVideoInfo) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) (mosvideo_bootstrab) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_endian.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) (SDL_ReadLE16) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_active.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) (SDL_AppActiveInit) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_resize.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) (SDL_PrivateResize) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) (SDL_UnRLESurface) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) (SDL_CalculateBlit) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) (SDL_CalculateBlit0) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) (SDL_CalculateBlit1) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) (SDL_CalculateBlitN) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) (MenuetOS_InitOSKeymap) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(mmx_main.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (ConvertMMX) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(mmxp2_32.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (ConvertMMXpII32_16RGB565) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86_main.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (ConvertX86) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86p_16.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (ConvertX86p16_16BGR565) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86p_32.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (ConvertX86p32_32BGR888) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) (SDL_CalculateAlphaBlit) |
/home/max/kolibri-svn/contrib/sdk/lib/libsound.a(init.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) (InitSound@4) |
/home/max/kolibri-svn/contrib/sdk/lib/libsound.a(setbuf.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) (SetBuffer@16) |
/home/max/kolibri-svn/contrib/sdk/lib/libsound.a(sndgetsize.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) (GetBufferSize@8) |
/home/max/kolibri-svn/contrib/sdk/lib/libsound.a(stopbuf.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) (StopBuffer@4) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) (vsprintf) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) (vsnprintf) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) (vprintf) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) (tls_free) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) (tls_alloc) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) (strncpy) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) (strncmp) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) (strlen) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) (strcpy) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (sprintf) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) (realloc) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) (memcpy) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) (memcmp) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) (malloc) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) (getenv) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (fwrite) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) (ftell) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) (fseek) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) (free) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) (fread) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (fprintf) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) (fopen) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) (fclose) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (exit) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) (calloc) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) (atoi) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) (atexit) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) (abort) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000000.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) (_head_libc_dll) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000903.o) |
/home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000000.o) (libc_dll_iname) |
Allocating common symbols |
Common symbol size file |
__DTOR_LIST__ 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
lookdeer3 0x4 xmas.o |
bigdeer0 0x4 xmas.o |
ttytype 0x80 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
SDL_ProcessEvents 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
bigdeer2 0x4 xmas.o |
w_holiday 0x4 xmas.o |
middeer0 0x4 xmas.o |
pdc_own_screen 0x1 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
treescrn4 0x4 xmas.o |
pdc_fwidth 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
middeer2 0x4 xmas.o |
lildeer1 0x4 xmas.o |
treescrn8 0x4 xmas.o |
bigdeer3 0x4 xmas.o |
linesripped 0x28 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
x_pos 0x4 xmas.o |
pdc_color 0xc00 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
lildeer2 0x4 xmas.o |
lookdeer4 0x4 xmas.o |
bigdeer4 0x4 xmas.o |
middeer3 0x4 xmas.o |
__CTOR_LIST__ 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
pdc_flastc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
lildeer3 0x4 xmas.o |
lildeer0 0x4 xmas.o |
treescrn5 0x4 xmas.o |
y_pos 0x4 xmas.o |
treescrn2 0x4 xmas.o |
treescrn3 0x4 xmas.o |
pdc_mapped 0xc00 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
lookdeer2 0x4 xmas.o |
pdc_fthick 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
treescrn 0x4 xmas.o |
SDL_alarm_callback 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
bigdeer1 0x4 xmas.o |
dotdeer0 0x4 xmas.o |
treescrn7 0x4 xmas.o |
middeer1 0x4 xmas.o |
SDL_KeyRepeat 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
w_del_msg 0x4 xmas.o |
lookdeer0 0x4 xmas.o |
stardeer0 0x4 xmas.o |
pdc_fheight 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
treescrn6 0x4 xmas.o |
lookdeer1 0x4 xmas.o |
Mouse_status 0x14 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
Discarded input sections |
.drectve 0x0000000000000000 0x32c xmas.o |
.drectve 0x0000000000000000 0x3c /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
.drectve 0x0000000000000000 0x38 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
.drectve 0x0000000000000000 0x1c /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
.drectve 0x0000000000000000 0xa4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
.drectve 0x0000000000000000 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
.drectve 0x0000000000000000 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
.drectve 0x0000000000000000 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
Memory Configuration |
Name Origin Length Attributes |
*default* 0x0000000000000000 0xffffffffffffffff |
Linker script and memory map |
0x0000000000000000 __image_base__ = 0x0 |
0x0000000000000000 __dll__ = 0x0 |
0x0000000000000000 ___ImageBase = 0x0 |
0x0000000000001000 __section_alignment__ = 0x1000 |
0x0000000000000200 __file_alignment__ = 0x200 |
0x0000000000000004 __major_os_version__ = 0x4 |
0x0000000000000000 __minor_os_version__ = 0x0 |
0x0000000000000001 __major_image_version__ = 0x1 |
0x0000000000000000 __minor_image_version__ = 0x0 |
0x0000000000000004 __major_subsystem_version__ = 0x4 |
0x0000000000000000 __minor_subsystem_version__ = 0x0 |
0x0000000000000001 __subsystem__ = 0x1 |
0x0000000000200000 __size_of_stack_reserve__ = 0x200000 |
0x0000000000001000 __size_of_stack_commit__ = 0x1000 |
0x0000000000100000 __size_of_heap_reserve__ = 0x100000 |
0x0000000000001000 __size_of_heap_commit__ = 0x1000 |
0x0000000000000000 __loader_flags__ = 0x0 |
0x0000000000000000 __dll_characteristics__ = 0x0 |
.text 0x0000000000000000 0x25200 |
0x0000000000000000 0x4 LONG 0x554e454d |
0x0000000000000004 0x4 LONG 0x32305445 |
0x0000000000000008 0x4 LONG 0x1 |
0x000000000000000c 0x4 LONG 0x34 __start |
0x0000000000000010 0x4 LONG 0x2a6ab ___iend |
0x0000000000000014 0x4 LONG 0x3dd40 ___memsize |
0x0000000000000018 0x4 LONG 0x3dd40 ___stacktop |
0x000000000000001c 0x4 LONG 0x3d830 ___cmdline |
0x0000000000000020 0x4 LONG 0x3d930 ___pgmname |
0x0000000000000024 0x4 LONG 0x1 __subsystem__ |
0x0000000000000028 0x4 LONG 0x2e960 __idata_start |
0x000000000000002c 0x4 LONG 0x2ec1c __idata_end |
0x0000000000000030 0x4 LONG 0x24180 _main |
*(.init) |
.init 0x0000000000000034 0x84 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) |
0x0000000000000034 _start |
*(.text) |
*fill* 0x00000000000000b8 0x8 |
.text 0x00000000000000c0 0x2880 xmas.o |
0x00000000000000c0 lil |
0x0000000000000130 midtop |
0x0000000000000180 bigtop |
0x00000000000002b0 bigface |
0x00000000000003b0 legs1 |
0x0000000000000440 legs2 |
0x00000000000004d0 legs3 |
0x0000000000000560 legs4 |
0x00000000000005d0 initdeer |
0x0000000000000b50 boxit |
0x0000000000000bd0 seas |
0x0000000000000cc0 greet |
0x0000000000000dd0 fromwho |
0x0000000000000e00 del_msg |
0x0000000000000e10 tree |
0x0000000000001330 balls |
0x0000000000001710 star |
0x0000000000001760 strng1 |
0x00000000000017e0 strng2 |
0x0000000000001890 strng3 |
0x0000000000001940 strng4 |
0x0000000000001a30 strng5 |
0x0000000000001af0 blinkit |
0x0000000000001c30 reindeer |
.text 0x0000000000002940 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) |
.text 0x0000000000002940 0xe0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
0x0000000000002940 __do_global_dtors |
0x0000000000002990 __do_global_ctors |
0x0000000000002a00 __main |
.text 0x0000000000002a20 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
.text 0x0000000000002a20 0x30 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
0x0000000000002a20 __crt_startup |
.text 0x0000000000002a50 0x240 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
0x0000000000002a50 get_entry_point |
0x0000000000002a60 load_libc |
.text 0x0000000000002c90 0x13e0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
0x0000000000003c60 __register_frame_info_bases |
0x0000000000003c90 __register_frame_info |
0x0000000000003cc0 __register_frame |
0x0000000000003d00 __register_frame_info_table_bases |
0x0000000000003d80 __register_frame_info_table |
0x0000000000003db0 __register_frame_table |
0x0000000000003df0 __deregister_frame_info_bases |
0x0000000000003ee0 __deregister_frame_info |
0x0000000000003ef0 __deregister_frame |
0x0000000000003f20 _Unwind_Find_FDE |
.text 0x0000000000004070 0x350 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
0x0000000000004070 __gthr_kos32_once |
0x00000000000040e0 __gthr_kos32_key_create |
0x0000000000004110 __gthr_kos32_key_delete |
0x0000000000004120 __gthr_kos32_getspecific |
0x0000000000004140 __gthr_kos32_setspecific |
0x0000000000004160 __gthr_kos32_mutex_init_function |
0x0000000000004180 __gthr_kos32_mutex_destroy |
0x00000000000041a0 __gthr_kos32_mutex_lock |
0x00000000000041e0 __gthr_kos32_mutex_trylock |
0x0000000000004210 __gthr_kos32_mutex_unlock |
0x0000000000004240 __gthr_kos32_recursive_mutex_init_function |
0x0000000000004270 __gthr_kos32_recursive_mutex_lock |
0x00000000000042f0 __gthr_kos32_recursive_mutex_trylock |
0x0000000000004350 __gthr_kos32_recursive_mutex_unlock |
0x00000000000043a0 __gthr_kos32_recursive_mutex_destroy |
.text 0x00000000000043c0 0x250 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
0x00000000000043c0 waddnstr |
0x0000000000004430 addstr |
0x0000000000004460 addnstr |
0x0000000000004490 waddstr |
0x00000000000044c0 mvaddstr |
0x0000000000004510 mvaddnstr |
0x0000000000004560 mvwaddstr |
0x00000000000045b0 mvwaddnstr |
.text 0x0000000000004610 0x110 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
0x0000000000004610 move |
0x0000000000004660 mvcur |
0x00000000000046d0 wmove |
.text 0x0000000000004720 0x6b0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
0x0000000000004720 wattroff |
0x0000000000004750 attroff |
0x0000000000004780 wattron |
0x00000000000047e0 attron |
0x0000000000004840 wattrset |
0x0000000000004860 attrset |
0x0000000000004880 standend |
0x00000000000048a0 standout |
0x00000000000048c0 wstandend |
0x00000000000048e0 wstandout |
0x0000000000004900 getattrs |
0x0000000000004920 wcolor_set |
0x0000000000004940 color_set |
0x0000000000004960 wattr_get |
0x00000000000049a0 attr_get |
0x00000000000049e0 wattr_off |
0x0000000000004a10 attr_off |
0x0000000000004a40 wattr_on |
0x0000000000004aa0 attr_on |
0x0000000000004b00 wattr_set |
0x0000000000004b30 attr_set |
0x0000000000004b60 wchgat |
0x0000000000004c30 chgat |
0x0000000000004c70 mvchgat |
0x0000000000004ce0 mvwchgat |
0x0000000000004d50 underend |
0x0000000000004d70 wunderend |
0x0000000000004d90 underscore |
0x0000000000004db0 wunderscore |
.text 0x0000000000004dd0 0x860 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
0x0000000000004dd0 initscr |
0x00000000000052b0 endwin |
0x00000000000052d0 isendwin |
0x00000000000052f0 newterm |
0x0000000000005310 set_term |
0x0000000000005330 delscreen |
0x0000000000005400 resize_term |
0x00000000000055c0 is_termresized |
0x00000000000055d0 curses_version |
0x00000000000055e0 PDC_get_version |
0x0000000000005610 set_tabsize |
.text 0x0000000000005630 0xa70 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
0x0000000000005750 slk_init |
0x0000000000005810 slk_set |
0x0000000000005990 slk_refresh |
0x00000000000059d0 slk_noutrefresh |
0x0000000000005a00 slk_label |
0x0000000000005a50 slk_clear |
0x0000000000005a90 slk_restore |
0x0000000000005ad0 slk_touch |
0x0000000000005b00 slk_attron |
0x0000000000005b40 slk_attr_on |
0x0000000000005b50 slk_attroff |
0x0000000000005b90 slk_attr_off |
0x0000000000005ba0 slk_attrset |
0x0000000000005be0 slk_color |
0x0000000000005c30 slk_attr_set |
0x0000000000005c50 PDC_slk_initialize |
0x0000000000005fb0 PDC_slk_free |
0x0000000000006030 PDC_mouse_in_slk |
.text 0x00000000000060a0 0x2e0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
0x00000000000060a0 echo |
0x00000000000060c0 noecho |
0x00000000000060e0 halfdelay |
0x0000000000006110 intrflush |
0x0000000000006120 keypad |
0x0000000000006140 meta |
0x0000000000006160 nl |
0x0000000000006180 nonl |
0x00000000000061a0 nodelay |
0x00000000000061c0 notimeout |
0x00000000000061d0 raw |
0x0000000000006210 noraw |
0x0000000000006250 noqiflush |
0x0000000000006260 qiflush |
0x0000000000006270 typeahead |
0x0000000000006280 wtimeout |
0x00000000000062c0 timeout |
0x0000000000006300 crmode |
0x0000000000006320 cbreak |
0x0000000000006330 nocrmode |
0x0000000000006350 nocbreak |
0x0000000000006360 is_keypad |
.text 0x0000000000006380 0x1f0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
0x0000000000006380 wclrtoeol |
0x0000000000006420 clrtoeol |
0x0000000000006440 wclrtobot |
0x00000000000064a0 clrtobot |
0x00000000000064c0 werase |
0x0000000000006500 erase |
0x0000000000006520 wclear |
0x0000000000006540 clear |
.text 0x0000000000006570 0x2a0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
0x0000000000006570 touchwin |
0x00000000000065c0 touchline |
0x0000000000006620 untouchwin |
0x0000000000006670 wtouchln |
0x0000000000006700 is_linetouched |
0x0000000000006730 is_wintouched |
0x0000000000006770 touchoverlap |
.text 0x0000000000006810 0x630 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
0x0000000000006810 wnoutrefresh |
0x0000000000006a80 doupdate |
0x0000000000006d00 wrefresh |
0x0000000000006d70 refresh |
0x0000000000006d90 wredrawln |
0x0000000000006df0 redrawwin |
.text 0x0000000000006e40 0xae0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
0x0000000000006e40 PDC_makenew |
0x0000000000006f50 PDC_makelines |
0x0000000000007010 PDC_sync |
0x0000000000007050 newwin |
0x00000000000070e0 delwin |
0x0000000000007170 mvwin |
0x00000000000071d0 subwin |
0x0000000000007320 derwin |
0x0000000000007340 mvderwin |
0x0000000000007410 dupwin |
0x0000000000007590 resize_window |
0x0000000000007820 wresize |
0x0000000000007850 wsyncup |
0x0000000000007880 syncok |
0x00000000000078a0 wcursyncup |
0x00000000000078e0 wsyncdown |
.text 0x0000000000007920 0x3e0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
0x0000000000007ab0 _copy_overlap |
0x0000000000007bc0 overlay |
0x0000000000007bf0 overwrite |
0x0000000000007c20 copywin |
.text 0x0000000000007d00 0x3f0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
0x0000000000007e40 def_shell_mode |
0x0000000000007e70 resetty |
0x0000000000007e90 savetty |
0x0000000000007ec0 curs_set |
0x0000000000007f30 napms |
0x0000000000007fd0 ripoffline |
0x0000000000008020 draino |
0x0000000000008030 resetterm |
0x0000000000008060 reset_shell_mode |
0x0000000000008070 fixterm |
0x00000000000080a0 reset_prog_mode |
0x00000000000080b0 saveterm |
0x00000000000080e0 def_prog_mode |
.text 0x00000000000080f0 0x980 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
0x00000000000080f0 wborder |
0x00000000000085b0 border |
0x0000000000008610 box |
0x0000000000008660 whline |
0x0000000000008760 hline |
0x0000000000008790 mvhline |
0x00000000000087e0 mvwhline |
0x0000000000008840 wvline |
0x0000000000008990 vline |
0x00000000000089c0 mvvline |
0x0000000000008a10 mvwvline |
.text 0x0000000000008a70 0x530 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
0x0000000000008a70 newpad |
0x0000000000008b20 subpad |
0x0000000000008c90 pnoutrefresh |
0x0000000000008eb0 prefresh |
0x0000000000008f00 pechochar |
0x0000000000008f80 is_pad |
.text 0x0000000000008fa0 0x560 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
0x0000000000008fa0 waddch |
0x0000000000009280 addch |
0x00000000000092a0 mvaddch |
0x00000000000092f0 mvwaddch |
0x0000000000009340 wechochar |
0x0000000000009380 echochar |
0x00000000000093a0 waddrawch |
0x00000000000093e0 addrawch |
0x0000000000009430 mvaddrawch |
0x0000000000009490 mvwaddrawch |
.text 0x0000000000009500 0x180 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
0x0000000000009500 clearok |
0x0000000000009520 idlok |
0x0000000000009530 idcok |
0x0000000000009540 immedok |
0x0000000000009560 leaveok |
0x00000000000095a0 setscrreg |
0x00000000000095e0 wsetscrreg |
0x0000000000009620 scrollok |
0x0000000000009640 raw_output |
0x0000000000009660 is_leaveok |
.text 0x0000000000009680 0x620 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
0x0000000000009750 init_pair |
0x00000000000097c0 has_colors |
0x00000000000097e0 init_color |
0x0000000000009880 color_content |
0x0000000000009940 can_change_color |
0x0000000000009950 pair_content |
0x00000000000099a0 assume_default_colors |
0x0000000000009a00 use_default_colors |
0x0000000000009a30 PDC_set_line_color |
0x0000000000009a70 PDC_init_atrtab |
0x0000000000009af0 start_color |
0x0000000000009b60 free_pair |
0x0000000000009ba0 find_pair |
0x0000000000009bf0 alloc_pair |
.text 0x0000000000009ca0 0x160 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
0x0000000000009ca0 vwprintw |
0x0000000000009d00 printw |
0x0000000000009d30 wprintw |
0x0000000000009d60 mvprintw |
0x0000000000009da0 mvwprintw |
0x0000000000009df0 vw_printw |
.text 0x0000000000009e00 0x30 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
0x0000000000009e00 PDC_get_cursor_mode |
0x0000000000009e10 PDC_get_rows |
0x0000000000009e20 PDC_get_columns |
.text 0x0000000000009e30 0xa40 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
0x0000000000009e70 PDC_retile |
0x0000000000009f50 PDC_scr_close |
0x0000000000009f60 PDC_scr_free |
0x0000000000009f70 PDC_scr_open |
0x000000000000a5f0 PDC_resize_screen |
0x000000000000a6c0 PDC_reset_prog_mode |
0x000000000000a6e0 PDC_reset_shell_mode |
0x000000000000a700 PDC_restore_screen_mode |
0x000000000000a710 PDC_save_screen_mode |
0x000000000000a720 PDC_can_change_color |
0x000000000000a730 PDC_color_content |
0x000000000000a7b0 PDC_init_color |
.text 0x000000000000a870 0x100 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
0x000000000000a870 PDC_curs_set |
0x000000000000a8a0 PDC_set_title |
0x000000000000a8c0 PDC_set_blink |
0x000000000000a950 PDC_set_bold |
.text 0x000000000000a970 0x9b0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
0x000000000000ab30 PDC_update_rects |
0x000000000000ab80 _new_packet |
0x000000000000af70 PDC_transform_line |
0x000000000000b030 PDC_gotoyx |
0x000000000000b1e0 PDC_blink_text |
0x000000000000b300 PDC_doupdate |
.text 0x000000000000b320 0x670 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
0x000000000000b320 PDC_set_keyboard_binary |
0x000000000000b330 PDC_check_key |
0x000000000000b350 PDC_get_key |
0x000000000000b920 PDC_flushinp |
0x000000000000b940 PDC_has_mouse |
0x000000000000b950 PDC_mouse_set |
0x000000000000b980 PDC_modifiers_set |
.text 0x000000000000b990 0x60 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
0x000000000000b990 PDC_beep |
0x000000000000b9a0 PDC_napms |
0x000000000000b9e0 PDC_sysname |
.text 0x000000000000b9f0 0x1b0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
0x000000000000b9f0 wscrl |
0x000000000000bb60 scrl |
0x000000000000bb80 scroll |
.text 0x000000000000bba0 0x168 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
0x000000000000bba0 SDL_InitSubSystem |
0x000000000000bc62 SDL_Init |
0x000000000000bc8f SDL_QuitSubSystem |
0x000000000000bcdb SDL_WasInit |
0x000000000000bcef SDL_Quit |
0x000000000000bcff SDL_Linked_Version |
.text 0x000000000000bd08 0x4bc /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
0x000000000000bd08 SDL_printf |
0x000000000000bd52 SDL_GetErrorMsgUNICODE |
0x000000000000bfe7 SDL_GetErrorMsg |
0x000000000000c03e SDL_GetError |
0x000000000000c050 SDL_SetError |
0x000000000000c16f SDL_ClearError |
0x000000000000c17a SDL_Error |
.text 0x000000000000c1c4 0x18 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) |
0x000000000000c1c4 SDL_printf_error |
0x000000000000c1d9 SDL_InstallParachute |
0x000000000000c1da SDL_UninstallParachute |
.text 0x000000000000c1dc 0x13c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) |
0x000000000000c1dc SDL_putenv |
0x000000000000c2b8 SDL_getenv |
.text 0x000000000000c318 0xa84 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
0x000000000000c531 SDL_AudioInit |
0x000000000000c570 SDL_AudioQuit |
0x000000000000c571 SDL_AudioDriverName |
0x000000000000c597 SDL_OpenAudio |
0x000000000000ccd5 SDL_CloseAudio |
0x000000000000cd23 SDL_PauseAudio |
0x000000000000cd62 SDL_LockAudio |
0x000000000000cd90 SDL_UnlockAudio |
.text 0x000000000000cd9c 0x5f0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
0x000000000000ce26 SDL_Lock_EventThread |
0x000000000000ce5b SDL_Unlock_EventThread |
0x000000000000ce7e SDL_EventThreadID |
0x000000000000ce84 SDL_StopEventLoop |
0x000000000000cee2 SDL_StartEventLoop |
0x000000000000cfcb SDL_PeepEvents |
0x000000000000d1fa SDL_PumpEvents |
0x000000000000d21a SDL_PollEvent |
0x000000000000d232 SDL_WaitEvent |
0x000000000000d263 SDL_PushEvent |
0x000000000000d276 SDL_SetEventFilter |
0x000000000000d291 SDL_GetEventFilter |
0x000000000000d297 SDL_EventState |
0x000000000000d339 SDL_PrivateSysWMEvent |
.text 0x000000000000d38c 0xc0c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
0x000000000000d38c SDL_EnableUNICODE |
0x000000000000d3a0 SDL_GetKeyState |
0x000000000000d3b4 SDL_GetModState |
0x000000000000d3ba SDL_SetModState |
0x000000000000d3c4 SDL_GetKeyName |
0x000000000000d3e6 SDL_PrivateKeyboard |
0x000000000000d5b5 SDL_ResetKeyboard |
0x000000000000d5fb SDL_CheckKeyRepeat |
0x000000000000d5fc SDL_EnableKeyRepeat |
0x000000000000d643 SDL_KeyboardInit |
.text 0x000000000000df98 0x3dc /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_mouse.o) |
0x000000000000dfdb SDL_MouseInit |
0x000000000000e009 SDL_GetMouseState |
0x000000000000e031 SDL_GetRelativeMouseState |
0x000000000000e06b SDL_PrivateMouseMotion |
0x000000000000e1fa SDL_PrivateMouseButton |
.text 0x000000000000e374 0x3c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_quit.o) |
0x000000000000e374 SDL_QuitInit |
0x000000000000e377 SDL_PrivateQuit |
.text 0x000000000000e3b0 0x27c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
0x000000000000e568 SDL_AllocRW |
0x000000000000e585 SDL_RWFromFP |
0x000000000000e5b8 SDL_RWFromFile |
0x000000000000e5ed SDL_RWFromMem |
0x000000000000e625 SDL_FreeRW |
.text 0x000000000000e62c 0x6c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) |
0x000000000000e62c SDL_CreateMutex |
0x000000000000e66e SDL_DestroyMutex |
0x000000000000e691 SDL_mutexP |
0x000000000000e694 SDL_mutexV |
.text 0x000000000000e698 0x50 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
0x000000000000e698 SDL_CreateSemaphore |
0x000000000000e6a6 SDL_DestroySemaphore |
0x000000000000e6a7 SDL_SemTryWait |
0x000000000000e6b6 SDL_SemWaitTimeout |
0x000000000000e6c5 SDL_SemWait |
0x000000000000e6d4 SDL_SemValue |
0x000000000000e6d7 SDL_SemPost |
.text 0x000000000000e6e8 0x18 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
0x000000000000e6e8 SDL_SYS_CreateThread |
0x000000000000e6f7 SDL_SYS_SetupThread |
0x000000000000e6f8 SDL_ThreadID |
0x000000000000e6fb SDL_SYS_WaitThread |
0x000000000000e6fc SDL_SYS_KillThread |
.text 0x000000000000e700 0x300 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_thread.o) |
0x000000000000e73f SDL_ThreadsInit |
0x000000000000e768 SDL_ThreadsQuit |
0x000000000000e783 SDL_GetErrBuf |
0x000000000000e7dd SDL_RunThread |
0x000000000000e811 SDL_CreateThread |
0x000000000000e990 SDL_WaitThread |
0x000000000000e9d3 SDL_GetThreadID |
0x000000000000e9e3 SDL_KillThread |
.text 0x000000000000ea00 0x368 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
0x000000000000ea06 SDL_SetTimerThreaded |
0x000000000000ea2a SDL_ThreadedTimerCheck |
0x000000000000eb0f SDL_AddTimer |
0x000000000000ebc3 SDL_RemoveTimer |
0x000000000000ec2b SDL_SetTimer |
0x000000000000ecdc SDL_TimerInit |
0x000000000000ed25 SDL_TimerQuit |
.text 0x000000000000ed68 0x5c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systimer.o) |
0x000000000000ed68 SDL_StartTicks |
0x000000000000ed7c SDL_GetTicks |
0x000000000000ed94 SDL_Delay |
0x000000000000edb9 SDL_SYS_TimerInit |
0x000000000000edbc SDL_SYS_TimerQuit |
0x000000000000edbd SDL_SYS_StartTimer |
0x000000000000edc0 SDL_SYS_StopTimer |
.text 0x000000000000edc4 0x7ec /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
0x000000000000edc4 SDL_LoadBMP_RW |
0x000000000000f23d SDL_SaveBMP_RW |
.text 0x000000000000f5b0 0xe5c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
0x000000000000f5b0 SDL_GetCursor |
0x000000000000f5b6 SDL_WarpMouse |
0x000000000000f618 SDL_CursorPaletteChanged |
0x000000000000f623 SDL_MouseRect |
0x000000000000f6aa SDL_DrawCursorNoLock |
0x000000000000fcce SDL_DrawCursor |
0x000000000000fd44 SDL_EraseCursorNoLock |
0x000000000000fe86 SDL_EraseCursor |
0x000000000000fefc SDL_SetCursor |
0x000000000001004c SDL_FreeCursor |
0x00000000000100b7 SDL_CursorQuit |
0x000000000001011d SDL_CreateCursor |
0x000000000001028b SDL_CursorInit |
0x00000000000102d7 SDL_ShowCursor |
0x0000000000010351 SDL_MoveCursor |
0x00000000000103dc SDL_ResetCursor |
.text 0x000000000001040c 0xb84 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) |
0x000000000001046f SDL_FreeFormat |
0x00000000000104a0 SDL_AllocFormat |
0x000000000001074c SDL_DitherColors |
0x000000000001075d SDL_CalculatePitch |
0x0000000000010791 SDL_FindColor |
0x00000000000108d7 SDL_MapRGB |
0x0000000000010931 SDL_MapRGBA |
0x00000000000109a4 SDL_GetRGBA |
0x0000000000010a8e SDL_GetRGB |
0x0000000000010b3e SDL_ApplyGamma |
0x0000000000010b91 SDL_InvalidateMap |
0x0000000000010bbe SDL_FormatChanged |
0x0000000000010bce SDL_ReallocFormat |
0x0000000000010c09 SDL_MapSurface |
0x0000000000010f0b SDL_FreeBlitMap |
0x0000000000010f35 SDL_AllocBlitMap |
.text 0x0000000000010f90 0xbe0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
0x0000000000011005 SDL_SetColorKey |
0x00000000000110c8 SDL_SetAlpha |
0x00000000000111d7 SDL_SetClipRect |
0x000000000001122f SDL_GetClipRect |
0x000000000001124b SDL_LowerBlit |
0x00000000000112ac SDL_UpperBlit |
0x000000000001144c SDL_LockSurface |
0x000000000001149a SDL_UnlockSurface |
0x00000000000114dc SDL_FillRect |
0x00000000000116dc SDL_FreeSurface |
0x0000000000011780 SDL_CreateRGBSurface |
0x0000000000011920 SDL_CreateRGBSurfaceFrom |
0x000000000001197a SDL_ConvertSurface |
.text 0x0000000000011b70 0x16b8 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
0x0000000000011ba3 SDL_VideoDriverName |
0x0000000000011bd2 SDL_GetVideoSurface |
0x0000000000011be5 SDL_GetVideoInfo |
0x0000000000011bf5 SDL_ListModes |
0x0000000000011c21 SDL_VideoModeOK |
0x0000000000011cf1 SDL_DisplayFormat |
0x0000000000011d38 SDL_DisplayFormatAlpha |
0x0000000000011e23 SDL_UpdateRects |
0x0000000000011fdf SDL_UpdateRect |
0x000000000001218b SDL_Flip |
0x0000000000012254 SDL_SetPalette |
0x00000000000123a4 SDL_SetColors |
0x00000000000123bf SDL_GL_LoadLibrary |
0x00000000000123e8 SDL_GL_GetProcAddress |
0x000000000001241c SDL_GL_SetAttribute |
0x00000000000124a5 SDL_GL_GetAttribute |
0x00000000000124d7 SDL_GL_SwapBuffers |
0x00000000000124ed SDL_GL_UpdateRectsLock |
0x00000000000124ee SDL_GL_UpdateRects |
0x00000000000124ef SDL_GL_Lock |
0x00000000000124f0 SDL_GL_Unlock |
0x00000000000124f1 SDL_WM_SetCaption |
0x00000000000125aa SDL_WM_GetCaption |
0x00000000000125d6 SDL_WM_SetIcon |
0x00000000000127c9 SDL_WM_GrabInput |
0x000000000001280f SDL_SetVideoMode |
0x0000000000012de2 SDL_VideoQuit |
0x0000000000012f16 SDL_VideoInit |
0x000000000001315b SDL_WM_IconifyWindow |
0x0000000000013172 SDL_WM_ToggleFullScreen |
0x0000000000013205 SDL_GetWMInfo |
.text 0x0000000000013228 0x638 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
0x0000000000013230 MenuetOS_SetColors |
0x0000000000013233 MenuetOS_SetCaption |
0x00000000000132b6 KolibriOS_FreeWMCursor |
0x00000000000132df KolibriOS_ShowWMCursor |
0x00000000000134d8 MenuetOS_VideoQuit |
0x0000000000013573 KolibriOS_CheckMouseMode |
0x0000000000013586 KolibriOS_CreateWMCursor |
0x0000000000013689 MenuetOS_SDL_RepaintWnd |
0x000000000001371c MenuetOS_SetVideoMode |
0x000000000001385d MenuetOS_FinalQuit |
.text 0x0000000000013860 0x184 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_endian.o) |
0x0000000000013863 SDL_ReadLE16 |
0x000000000001387e SDL_ReadBE16 |
0x000000000001389b SDL_ReadLE32 |
0x00000000000138b5 SDL_ReadBE32 |
0x00000000000138d0 SDL_ReadLE64 |
0x00000000000138f3 SDL_ReadBE64 |
0x0000000000013924 SDL_WriteLE16 |
0x0000000000013942 SDL_WriteBE16 |
0x0000000000013962 SDL_WriteLE32 |
0x0000000000013977 SDL_WriteBE32 |
0x0000000000013999 SDL_WriteLE64 |
0x00000000000139ae SDL_WriteBE64 |
.text 0x00000000000139e4 0xb0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_active.o) |
0x00000000000139e4 SDL_AppActiveInit |
0x00000000000139ee SDL_GetAppState |
0x00000000000139f4 SDL_PrivateAppActive |
.text 0x0000000000013a94 0xac /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_resize.o) |
0x0000000000013a94 SDL_PrivateResize |
.text 0x0000000000013b40 0x3b38 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
0x0000000000013ff0 SDL_RLEBlit |
0x00000000000162b2 SDL_RLEAlphaBlit |
0x0000000000016be0 SDL_UnRLESurface |
0x0000000000016dc1 SDL_RLESurface |
.text 0x0000000000017678 0x4c4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
0x0000000000017981 SDL_CalculateBlit |
.text 0x0000000000017b3c 0xb68 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
0x000000000001863b SDL_CalculateBlit0 |
.text 0x00000000000186a4 0x20a0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
0x000000000001a6dc SDL_CalculateBlit1 |
.text 0x000000000001a744 0x4474 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
0x000000000001ea3c SDL_CalculateBlitN |
.text 0x000000000001ebb8 0x290 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
0x000000000001ebb8 MenuetOS_InitOSKeymap |
0x000000000001ebcc MenuetOS_PumpEvents |
.text 0x000000000001ee48 0x2b /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(mmx_main.o) |
0x000000000001ee48 ConvertMMX |
0x000000000001ee48 ConvertMMX |
*fill* 0x000000000001ee73 0x1 |
.text 0x000000000001ee74 0x34c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(mmxp2_32.o) |
0x000000000001ee74 ConvertMMXpII32_24RGB888 |
0x000000000001ee74 ConvertMMXpII32_24RGB888 |
0x000000000001eeff ConvertMMXpII32_16RGB565 |
0x000000000001eeff ConvertMMXpII32_16RGB565 |
0x000000000001efb6 ConvertMMXpII32_16BGR565 |
0x000000000001efb6 ConvertMMXpII32_16BGR565 |
0x000000000001f073 ConvertMMXpII32_16BGR555 |
0x000000000001f073 ConvertMMXpII32_16BGR555 |
0x000000000001f083 ConvertMMXpII32_16RGB555 |
0x000000000001f083 ConvertMMXpII32_16RGB555 |
.text 0x000000000001f1c0 0x60 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86_main.o) |
0x000000000001f1c0 ConvertX86 |
0x000000000001f1c0 ConvertX86 |
0x000000000001f1e9 Hermes_X86_CPU |
0x000000000001f1e9 Hermes_X86_CPU |
.text 0x000000000001f220 0x35d /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86p_16.o) |
0x000000000001f220 ConvertX86p16_16BGR565 |
0x000000000001f220 ConvertX86p16_16BGR565 |
0x000000000001f2e9 ConvertX86p16_16RGB555 |
0x000000000001f2e9 ConvertX86p16_16RGB555 |
0x000000000001f3a5 ConvertX86p16_16BGR555 |
0x000000000001f3a5 ConvertX86p16_16BGR555 |
0x000000000001f488 ConvertX86p16_8RGB332 |
0x000000000001f488 ConvertX86p16_8RGB332 |
*fill* 0x000000000001f57d 0x3 |
.text 0x000000000001f580 0x622 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86p_32.o) |
0x000000000001f580 ConvertX86p32_32BGR888 |
0x000000000001f580 ConvertX86p32_32BGR888 |
0x000000000001f5ec ConvertX86p32_32RGBA888 |
0x000000000001f5ec ConvertX86p32_32RGBA888 |
0x000000000001f64c ConvertX86p32_32BGRA888 |
0x000000000001f64c ConvertX86p32_32BGRA888 |
0x000000000001f6a6 ConvertX86p32_24RGB888 |
0x000000000001f6a6 ConvertX86p32_24RGB888 |
0x000000000001f741 ConvertX86p32_24BGR888 |
0x000000000001f741 ConvertX86p32_24BGR888 |
0x000000000001f7d9 ConvertX86p32_16RGB565 |
0x000000000001f7d9 ConvertX86p32_16RGB565 |
0x000000000001f89c ConvertX86p32_16BGR565 |
0x000000000001f89c ConvertX86p32_16BGR565 |
0x000000000001f967 ConvertX86p32_16RGB555 |
0x000000000001f967 ConvertX86p32_16RGB555 |
0x000000000001fa2a ConvertX86p32_16BGR555 |
0x000000000001fa2a ConvertX86p32_16BGR555 |
0x000000000001faf5 ConvertX86p32_8RGB332 |
0x000000000001faf5 ConvertX86p32_8RGB332 |
*fill* 0x000000000001fba2 0x2 |
.text 0x000000000001fba4 0x433c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
0x0000000000023d2d SDL_CalculateAlphaBlit |
.text 0x0000000000023ee0 0xbf /home/max/kolibri-svn/contrib/sdk/lib/libsound.a(init.o) |
0x0000000000023ee0 InitSound@4 |
0x0000000000023f44 CreateBuffer@12 |
0x0000000000023f74 DestroyBuffer@4 |
*fill* 0x0000000000023f9f 0x1 |
.text 0x0000000000023fa0 0x57 /home/max/kolibri-svn/contrib/sdk/lib/libsound.a(setbuf.o) |
0x0000000000023fa0 SetBuffer@16 |
0x0000000000023fcc PlayBuffer@8 |
*fill* 0x0000000000023ff7 0x9 |
.text 0x0000000000024000 0x64 /home/max/kolibri-svn/contrib/sdk/lib/libsound.a(sndgetsize.o) |
0x0000000000024000 GetBufferSize@8 |
0x0000000000024030 GetBufferFree@8 |
*fill* 0x0000000000024064 0xc |
.text 0x0000000000024070 0x2b /home/max/kolibri-svn/contrib/sdk/lib/libsound.a(stopbuf.o) |
0x0000000000024070 StopBuffer@4 |
*fill* 0x000000000002409b 0x1 |
.text 0x000000000002409c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
0x000000000002409c vsprintf |
.text 0x00000000000240a4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
0x00000000000240a4 vsnprintf |
.text 0x00000000000240ac 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
0x00000000000240ac vprintf |
.text 0x00000000000240b4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
0x00000000000240b4 tls_free |
.text 0x00000000000240bc 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
0x00000000000240bc tls_alloc |
.text 0x00000000000240c4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
0x00000000000240c4 strncpy |
.text 0x00000000000240cc 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
0x00000000000240cc strncmp |
.text 0x00000000000240d4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
0x00000000000240d4 strlen |
.text 0x00000000000240dc 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
0x00000000000240dc strcpy |
.text 0x00000000000240e4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
0x00000000000240e4 sprintf |
.text 0x00000000000240ec 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
0x00000000000240ec realloc |
.text 0x00000000000240f4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
0x00000000000240f4 memcpy |
.text 0x00000000000240fc 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
0x00000000000240fc memcmp |
.text 0x0000000000024104 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
0x0000000000024104 malloc |
.text 0x000000000002410c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
0x000000000002410c getenv |
.text 0x0000000000024114 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
0x0000000000024114 fwrite |
.text 0x000000000002411c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
0x000000000002411c ftell |
.text 0x0000000000024124 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
0x0000000000024124 fseek |
.text 0x000000000002412c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
0x000000000002412c free |
.text 0x0000000000024134 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
0x0000000000024134 fread |
.text 0x000000000002413c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
0x000000000002413c fprintf |
.text 0x0000000000024144 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
0x0000000000024144 fopen |
.text 0x000000000002414c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
0x000000000002414c fclose |
.text 0x0000000000024154 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
0x0000000000024154 exit |
.text 0x000000000002415c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
0x000000000002415c calloc |
.text 0x0000000000024164 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
0x0000000000024164 atoi |
.text 0x000000000002416c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
0x000000000002416c atexit |
.text 0x0000000000024174 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
0x0000000000024174 abort |
*(SORT(.text$*)) |
*(.text.*) |
.text.unlikely |
0x000000000002417c 0x0 xmas.o |
*fill* 0x000000000002417c 0x4 |
.text.startup 0x0000000000024180 0xe80 xmas.o |
0x0000000000024180 main |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_mouse.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_quit.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_thread.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systimer.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_endian.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_active.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_resize.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
.text.unlikely |
0x0000000000025000 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
*(.glue_7t) |
*(.glue_7) |
0x0000000000025000 ___CTOR_LIST__ = . |
0x0000000000025000 __CTOR_LIST__ = . |
0x0000000000025000 0x4 LONG 0xffffffffffffffff |
*(.ctors) |
*(.ctor) |
*(SORT(.ctors.*)) |
0x0000000000025004 0x4 LONG 0x0 |
0x0000000000025008 ___DTOR_LIST__ = . |
0x0000000000025008 __DTOR_LIST__ = . |
0x0000000000025008 0x4 LONG 0xffffffffffffffff |
*(.dtors) |
*(.dtor) |
*(SORT(.dtors.*)) |
0x000000000002500c 0x4 LONG 0x0 |
*(.fini) |
*(.gcc_exc) |
[!provide] PROVIDE (etext, .) |
*(.gcc_except_table) |
.rdata 0x0000000000025010 0x4410 |
*(.rdata) |
.rdata 0x0000000000025010 0x1b0 xmas.o |
.rdata 0x00000000000251c0 0x18 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
.rdata 0x00000000000251d8 0x34 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
.rdata 0x000000000002520c 0xfc /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
.rdata 0x0000000000025308 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
.rdata 0x000000000002530c 0x14 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
.rdata 0x0000000000025320 0xb4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
*fill* 0x00000000000253d4 0xc |
.rdata 0x00000000000253e0 0x3c0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
.rdata 0x00000000000257a0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
.rdata 0x00000000000257a4 0x68 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
.rdata 0x000000000002580c 0x94 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
.rdata 0x00000000000258a0 0x194 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
.rdata 0x0000000000025a34 0x1c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
.rdata 0x0000000000025a50 0x624 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
.rdata 0x0000000000026074 0x2c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
.rdata 0x00000000000260a0 0x28 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
.rdata 0x00000000000260c8 0x2c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
.rdata 0x00000000000260f4 0xa0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
.rdata 0x0000000000026194 0x9c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
.rdata 0x0000000000026230 0x2c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
.rdata 0x000000000002625c 0x68 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
.rdata 0x00000000000262c4 0x1d8 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
.rdata 0x000000000002649c 0x50 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
.rdata 0x00000000000264ec 0x10 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
.rdata 0x00000000000264fc 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
.rdata 0x000000000002651c 0x28 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
.rdata 0x0000000000026544 0x140 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
*fill* 0x0000000000026684 0x1c |
.rdata 0x00000000000266a0 0x25a0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
.rdata 0x0000000000028c40 0x620 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
.rdata 0x0000000000029260 0x1c /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
*(SORT(.rdata$*)) |
0x000000000002927c ___RUNTIME_PSEUDO_RELOC_LIST__ = . |
0x000000000002927c __RUNTIME_PSEUDO_RELOC_LIST__ = . |
*(.rdata_runtime_pseudo_reloc) |
0x000000000002927c ___RUNTIME_PSEUDO_RELOC_LIST_END__ = . |
0x000000000002927c __RUNTIME_PSEUDO_RELOC_LIST_END__ = . |
.CRT 0x0000000000029280 0x0 |
0x0000000000029280 ___crt_xc_start__ = . |
*(SORT(.CRT$XC*)) |
0x0000000000029280 ___crt_xc_end__ = . |
0x0000000000029280 ___crt_xi_start__ = . |
*(SORT(.CRT$XI*)) |
0x0000000000029280 ___crt_xi_end__ = . |
0x0000000000029280 ___crt_xl_start__ = . |
*(SORT(.CRT$XL*)) |
0x0000000000029280 ___crt_xp_start__ = . |
*(SORT(.CRT$XP*)) |
0x0000000000029280 ___crt_xp_end__ = . |
0x0000000000029280 ___crt_xt_start__ = . |
*(SORT(.CRT$XT*)) |
0x0000000000029280 ___crt_xt_end__ = . |
.data 0x0000000000029280 0x1600 |
[!provide] PROVIDE (__data_start__, .) |
*(.data) |
.data 0x0000000000029280 0x0 xmas.o |
.data 0x0000000000029280 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) |
.data 0x0000000000029280 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
.data 0x0000000000029284 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
.data 0x0000000000029284 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
.data 0x0000000000029284 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
.data 0x0000000000029284 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
.data 0x000000000002928c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
.data 0x000000000002928c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
.data 0x000000000002928c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
.data 0x000000000002928c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
.data 0x000000000002928c 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
0x000000000002928c TABSIZE |
0x0000000000029290 _curses_notice |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
.data 0x0000000000029294 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
.data 0x0000000000029294 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
0x0000000000029294 COLOR_PAIRS |
.data 0x0000000000029298 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
.data 0x0000000000029298 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
*fill* 0x0000000000029298 0x8 |
.data 0x00000000000292a0 0x1100 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
0x00000000000292a0 iconbmp |
0x0000000000029360 font437 |
.data 0x000000000002a3a0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
.data 0x000000000002a3a0 0x220 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
0x000000000002a3c0 acs_map |
.data 0x000000000002a5c0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
.data 0x000000000002a5c0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
.data 0x000000000002a5c0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
.data 0x000000000002a5c0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_mouse.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_quit.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_thread.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systimer.o) |
.data 0x000000000002a5c4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
*fill* 0x000000000002a5c4 0x1c |
.data 0x000000000002a5e0 0x60 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
.data 0x000000000002a640 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) |
.data 0x000000000002a640 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
.data 0x000000000002a640 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
.data 0x000000000002a660 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
0x000000000002a660 mosvideo_bootstrab |
0x000000000002a670 def_title |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_endian.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_active.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_resize.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
.data 0x000000000002a684 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
.data 0x000000000002a684 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(x86_main.o) |
.data 0x000000000002a688 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
*fill* 0x000000000002a688 0x8 |
.data 0x000000000002a690 0x17 /home/max/kolibri-svn/contrib/sdk/lib/libsound.a(init.o) |
0x000000000002a690 hSound |
0x000000000002a690 hSound |
0x000000000002a694 hrdwSound |
0x000000000002a694 hrdwSound |
*(.data2) |
*(SORT(.data$*)) |
*(.jcr) |
0x000000000002a6a7 __CRT_MT = . |
0x000000000002a6a7 0x4 LONG 0x1 |
[!provide] PROVIDE (__data_end__, .) |
*(.data_cygwin_nocopy) |
0x000000000002a6ab ___iend = . |
.eh_frame 0x000000000002a6b0 0x4400 |
0x000000000002a6b0 PROVIDE (___EH_FRAME_BEGIN__, .) |
*(.eh_frame*) |
.eh_frame 0x000000000002a6b0 0x460 xmas.o |
.eh_frame 0x000000000002ab10 0x68 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
.eh_frame 0x000000000002ab78 0x34 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
.eh_frame 0x000000000002abac 0x6c /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
.eh_frame 0x000000000002ac18 0x4f0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
.eh_frame 0x000000000002b108 0x230 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
.eh_frame 0x000000000002b338 0x284 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
.eh_frame 0x000000000002b5bc 0xf0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
.eh_frame 0x000000000002b6ac 0x4b0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
.eh_frame 0x000000000002bb5c 0x1ac /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
.eh_frame 0x000000000002bd08 0x404 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
.eh_frame 0x000000000002c10c 0x194 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
.eh_frame 0x000000000002c2a0 0x1b0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
.eh_frame 0x000000000002c450 0x1b4 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
.eh_frame 0x000000000002c604 0x1ec /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
.eh_frame 0x000000000002c7f0 0x564 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
.eh_frame 0x000000000002cd54 0x1e8 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
.eh_frame 0x000000000002cf3c 0x2cc /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
.eh_frame 0x000000000002d208 0x388 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
.eh_frame 0x000000000002d590 0x210 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
.eh_frame 0x000000000002d7a0 0x2c0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
.eh_frame 0x000000000002da60 0x10c /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
.eh_frame 0x000000000002db6c 0x434 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
.eh_frame 0x000000000002dfa0 0xf8 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
.eh_frame 0x000000000002e098 0x44 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
.eh_frame 0x000000000002e0dc 0x240 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
.eh_frame 0x000000000002e31c 0xb8 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
.eh_frame 0x000000000002e3d4 0x2f0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
.eh_frame 0x000000000002e6c4 0x16c /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
.eh_frame 0x000000000002e830 0x64 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
.eh_frame 0x000000000002e894 0xc0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
0x000000000002e954 ___FRAME_END__ = . |
0x000000000002e954 0x4 LONG 0x0 |
.idata 0x000000000002e960 0x400 |
0x000000000002e960 __idata_start = . |
SORT(*)(.idata$2) |
.idata$2 0x000000000002e960 0x14 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000000.o) |
0x000000000002e960 _head_libc_dll |
SORT(*)(.idata$3) |
0x000000000002e974 0x4 LONG 0x0 |
0x000000000002e978 0x4 LONG 0x0 |
0x000000000002e97c 0x4 LONG 0x0 |
0x000000000002e980 0x4 LONG 0x0 |
0x000000000002e984 0x4 LONG 0x0 |
SORT(*)(.idata$4) |
.idata$4 0x000000000002e988 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000000.o) |
.idata$4 0x000000000002e988 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
.idata$4 0x000000000002e98c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
.idata$4 0x000000000002e990 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
.idata$4 0x000000000002e994 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
.idata$4 0x000000000002e998 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
.idata$4 0x000000000002e99c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
.idata$4 0x000000000002e9a0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
.idata$4 0x000000000002e9a4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
.idata$4 0x000000000002e9a8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
.idata$4 0x000000000002e9ac 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
.idata$4 0x000000000002e9b0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
.idata$4 0x000000000002e9b4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
.idata$4 0x000000000002e9b8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
.idata$4 0x000000000002e9bc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
.idata$4 0x000000000002e9c0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
.idata$4 0x000000000002e9c4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
.idata$4 0x000000000002e9c8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
.idata$4 0x000000000002e9cc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
.idata$4 0x000000000002e9d0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
.idata$4 0x000000000002e9d4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
.idata$4 0x000000000002e9d8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
.idata$4 0x000000000002e9dc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
.idata$4 0x000000000002e9e0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
.idata$4 0x000000000002e9e4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
.idata$4 0x000000000002e9e8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
.idata$4 0x000000000002e9ec 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
.idata$4 0x000000000002e9f0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
.idata$4 0x000000000002e9f4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
.idata$4 0x000000000002e9f8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000903.o) |
SORT(*)(.idata$5) |
.idata$5 0x000000000002e9fc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000000.o) |
.idata$5 0x000000000002e9fc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
0x000000000002e9fc _imp__abort |
.idata$5 0x000000000002ea00 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
0x000000000002ea00 _imp__atexit |
.idata$5 0x000000000002ea04 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
0x000000000002ea04 _imp__atoi |
.idata$5 0x000000000002ea08 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
0x000000000002ea08 _imp__calloc |
.idata$5 0x000000000002ea0c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
0x000000000002ea0c _imp__exit |
.idata$5 0x000000000002ea10 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
0x000000000002ea10 _imp__fclose |
.idata$5 0x000000000002ea14 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
0x000000000002ea14 _imp__fopen |
.idata$5 0x000000000002ea18 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
0x000000000002ea18 _imp__fprintf |
.idata$5 0x000000000002ea1c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
0x000000000002ea1c _imp__fread |
.idata$5 0x000000000002ea20 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
0x000000000002ea20 _imp__free |
.idata$5 0x000000000002ea24 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
0x000000000002ea24 _imp__fseek |
.idata$5 0x000000000002ea28 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
0x000000000002ea28 _imp__ftell |
.idata$5 0x000000000002ea2c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
0x000000000002ea2c _imp__fwrite |
.idata$5 0x000000000002ea30 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
0x000000000002ea30 _imp__getenv |
.idata$5 0x000000000002ea34 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
0x000000000002ea34 _imp__malloc |
.idata$5 0x000000000002ea38 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
0x000000000002ea38 _imp__memcmp |
.idata$5 0x000000000002ea3c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
0x000000000002ea3c _imp__memcpy |
.idata$5 0x000000000002ea40 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
0x000000000002ea40 _imp__realloc |
.idata$5 0x000000000002ea44 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
0x000000000002ea44 _imp__sprintf |
.idata$5 0x000000000002ea48 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
0x000000000002ea48 _imp__strcpy |
.idata$5 0x000000000002ea4c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
0x000000000002ea4c _imp__strlen |
.idata$5 0x000000000002ea50 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
0x000000000002ea50 _imp__strncmp |
.idata$5 0x000000000002ea54 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
0x000000000002ea54 _imp__strncpy |
.idata$5 0x000000000002ea58 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
0x000000000002ea58 _imp__tls_alloc |
.idata$5 0x000000000002ea5c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
0x000000000002ea5c _imp__tls_free |
.idata$5 0x000000000002ea60 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
0x000000000002ea60 _imp__vprintf |
.idata$5 0x000000000002ea64 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
0x000000000002ea64 _imp__vsnprintf |
.idata$5 0x000000000002ea68 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
0x000000000002ea68 _imp__vsprintf |
.idata$5 0x000000000002ea6c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000903.o) |
SORT(*)(.idata$6) |
.idata$6 0x000000000002ea70 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
.idata$6 0x000000000002ea78 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
.idata$6 0x000000000002ea84 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
.idata$6 0x000000000002ea8c 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
.idata$6 0x000000000002ea98 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
.idata$6 0x000000000002eaa0 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
.idata$6 0x000000000002eaac 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
.idata$6 0x000000000002eab4 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
.idata$6 0x000000000002eac0 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
.idata$6 0x000000000002eac8 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
.idata$6 0x000000000002ead0 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
.idata$6 0x000000000002ead8 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
.idata$6 0x000000000002eae0 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
.idata$6 0x000000000002eaec 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
.idata$6 0x000000000002eaf8 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
.idata$6 0x000000000002eb04 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
.idata$6 0x000000000002eb10 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
.idata$6 0x000000000002eb1c 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
.idata$6 0x000000000002eb28 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
.idata$6 0x000000000002eb34 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
.idata$6 0x000000000002eb40 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
.idata$6 0x000000000002eb4c 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
.idata$6 0x000000000002eb58 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
.idata$6 0x000000000002eb64 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
.idata$6 0x000000000002eb70 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
.idata$6 0x000000000002eb7c 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
.idata$6 0x000000000002eb88 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
.idata$6 0x000000000002eb94 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
SORT(*)(.idata$7) |
.idata$7 0x000000000002eba0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000334.o) |
.idata$7 0x000000000002eba4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000358.o) |
.idata$7 0x000000000002eba8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000360.o) |
.idata$7 0x000000000002ebac 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000368.o) |
.idata$7 0x000000000002ebb0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000419.o) |
.idata$7 0x000000000002ebb4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000431.o) |
.idata$7 0x000000000002ebb8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000474.o) |
.idata$7 0x000000000002ebbc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000476.o) |
.idata$7 0x000000000002ebc0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000486.o) |
.idata$7 0x000000000002ebc4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000488.o) |
.idata$7 0x000000000002ebc8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000493.o) |
.idata$7 0x000000000002ebcc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000497.o) |
.idata$7 0x000000000002ebd0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000502.o) |
.idata$7 0x000000000002ebd4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000519.o) |
.idata$7 0x000000000002ebd8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000621.o) |
.idata$7 0x000000000002ebdc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000634.o) |
.idata$7 0x000000000002ebe0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000635.o) |
.idata$7 0x000000000002ebe4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000687.o) |
.idata$7 0x000000000002ebe8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000735.o) |
.idata$7 0x000000000002ebec 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000752.o) |
.idata$7 0x000000000002ebf0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000760.o) |
.idata$7 0x000000000002ebf4 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000764.o) |
.idata$7 0x000000000002ebf8 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000765.o) |
.idata$7 0x000000000002ebfc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000798.o) |
.idata$7 0x000000000002ec00 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000799.o) |
.idata$7 0x000000000002ec04 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000834.o) |
.idata$7 0x000000000002ec08 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000839.o) |
.idata$7 0x000000000002ec0c 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000840.o) |
.idata$7 0x000000000002ec10 0xc /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a(d000903.o) |
0x000000000002ec10 libc_dll_iname |
0x000000000002ec1c __idata_end = . |
bss 0x000000000002ec20 0xf120 |
*(.bss) |
.bss 0x000000000002ec20 0x4 xmas.o |
.bss 0x000000000002ec24 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_start.o) |
.bss 0x000000000002ec24 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(__main.o) |
.bss 0x000000000002ec44 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
.bss 0x000000000002ec44 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(kos32-app.o) |
.bss 0x000000000002ec44 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(libc-loader.o) |
.bss 0x000000000002ec44 0x1c /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(unwind-dw2-fde.o) |
.bss 0x000000000002ec60 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(gthr-kos32.o) |
.bss 0x000000000002ec60 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addstr.o) |
.bss 0x000000000002ec60 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(move.o) |
.bss 0x000000000002ec60 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(attr.o) |
.bss 0x000000000002ec60 0x14 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
0x000000000002ec60 COLS |
0x000000000002ec64 LINES |
0x000000000002ec68 stdscr |
0x000000000002ec6c curscr |
0x000000000002ec70 SP |
*fill* 0x000000000002ec74 0xc |
.bss 0x000000000002ec80 0x40 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(slk.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(inopts.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(clear.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(touch.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(refresh.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(window.o) |
.bss 0x000000000002ecc0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(overlay.o) |
.bss 0x000000000002ecc0 0x220 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
0x000000000002ecc0 linesrippedoff |
.bss 0x000000000002eee0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(border.o) |
.bss 0x000000000002eee0 0x18 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pad.o) |
.bss 0x000000000002eef8 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(addch.o) |
.bss 0x000000000002eef8 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(outopts.o) |
.bss 0x000000000002eef8 0xc /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(color.o) |
0x000000000002eef8 COLORS |
.bss 0x000000000002ef04 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(printw.o) |
.bss 0x000000000002ef04 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcgetsc.o) |
.bss 0x000000000002ef04 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
0x000000000002ef04 pdc_xoffset |
0x000000000002ef08 pdc_yoffset |
0x000000000002ef0c pdc_swidth |
0x000000000002ef10 pdc_sheight |
0x000000000002ef14 pdc_tileback |
0x000000000002ef18 pdc_back |
0x000000000002ef1c pdc_icon |
0x000000000002ef20 pdc_font |
0x000000000002ef24 pdc_screen |
.bss 0x000000000002ef28 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcsetsc.o) |
*fill* 0x000000000002ef28 0x18 |
.bss 0x000000000002ef40 0x660 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcdisp.o) |
.bss 0x000000000002f5a0 0x2c /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdckbd.o) |
.bss 0x000000000002f5cc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcutil.o) |
.bss 0x000000000002f5cc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(scroll.o) |
.bss 0x000000000002f5cc 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL.o) |
*fill* 0x000000000002f5d4 0xc |
.bss 0x000000000002f5e0 0xb20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_error.o) |
.bss 0x0000000000030100 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_fatal.o) |
.bss 0x0000000000030100 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_getenv.o) |
*fill* 0x0000000000030104 0x1c |
.bss 0x0000000000030120 0xa440 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_kolibri_audio.o) |
.bss 0x000000000003a560 0xe40 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
0x000000000003a560 SDL_EventOK |
.bss 0x000000000003b3a0 0x6a0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
0x000000000003b3a0 SDL_TranslateUNICODE |
.bss 0x000000000003ba40 0xc /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_mouse.o) |
.bss 0x000000000003ba4c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_quit.o) |
.bss 0x000000000003ba4c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_rwops.o) |
.bss 0x000000000003ba4c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_sysmutex.o) |
.bss 0x000000000003ba4c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_syssem.o) |
.bss 0x000000000003ba4c 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systhread.o) |
*fill* 0x000000000003ba4c 0x14 |
.bss 0x000000000003ba60 0x340 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_thread.o) |
0x000000000003ba60 _creating_thread_lock |
.bss 0x000000000003bda0 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
0x000000000003bda0 SDL_alarm_interval |
0x000000000003bda4 SDL_timer_running |
0x000000000003bda8 SDL_timer_started |
.bss 0x000000000003bdc0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_systimer.o) |
.bss 0x000000000003bdc4 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_bmp.o) |
.bss 0x000000000003bdc4 0x18 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_cursor.o) |
0x000000000003bdc4 SDL_cursorlock |
0x000000000003bdc8 SDL_cursor |
0x000000000003bdcc SDL_cursorstate |
.bss 0x000000000003bddc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_pixels.o) |
.bss 0x000000000003bddc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_surface.o) |
.bss 0x000000000003bddc 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_video.o) |
0x000000000003bddc current_video |
.bss 0x000000000003bde0 0x10 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetvideo.o) |
.bss 0x000000000003bdf0 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_endian.o) |
.bss 0x000000000003bdf0 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_active.o) |
.bss 0x000000000003bdf4 0x8 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_resize.o) |
.bss 0x000000000003bdfc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_RLEaccel.o) |
.bss 0x000000000003bdfc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit.o) |
.bss 0x000000000003bdfc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_0.o) |
.bss 0x000000000003bdfc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_1.o) |
.bss 0x000000000003bdfc 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_N.o) |
.bss 0x000000000003bdfc 0xc /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_menuetevents.o) |
.bss 0x000000000003be08 0x0 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_blit_A.o) |
*(COMMON) |
COMMON 0x000000000003be08 0x80 xmas.o |
0x000000000003be08 lookdeer3 |
0x000000000003be0c bigdeer0 |
0x000000000003be10 bigdeer2 |
0x000000000003be14 w_holiday |
0x000000000003be18 middeer0 |
0x000000000003be1c treescrn4 |
0x000000000003be20 middeer2 |
0x000000000003be24 lildeer1 |
0x000000000003be28 treescrn8 |
0x000000000003be2c bigdeer3 |
0x000000000003be30 x_pos |
0x000000000003be34 lildeer2 |
0x000000000003be38 lookdeer4 |
0x000000000003be3c bigdeer4 |
0x000000000003be40 middeer3 |
0x000000000003be44 lildeer3 |
0x000000000003be48 lildeer0 |
0x000000000003be4c treescrn5 |
0x000000000003be50 y_pos |
0x000000000003be54 treescrn2 |
0x000000000003be58 treescrn3 |
0x000000000003be5c lookdeer2 |
0x000000000003be60 treescrn |
0x000000000003be64 bigdeer1 |
0x000000000003be68 dotdeer0 |
0x000000000003be6c treescrn7 |
0x000000000003be70 middeer1 |
0x000000000003be74 w_del_msg |
0x000000000003be78 lookdeer0 |
0x000000000003be7c stardeer0 |
0x000000000003be80 treescrn6 |
0x000000000003be84 lookdeer1 |
COMMON 0x000000000003be88 0x10 /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a(_ctors.o) |
*fill* 0x000000000003be98 0x8 |
COMMON 0x000000000003bea0 0x94 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(initscr.o) |
0x000000000003bea0 ttytype |
0x000000000003bf20 Mouse_status |
*fill* 0x000000000003bf34 0xc |
COMMON 0x000000000003bf40 0x28 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(kernel.o) |
0x000000000003bf40 linesripped |
*fill* 0x000000000003bf68 0x18 |
COMMON 0x000000000003bf80 0x1848 /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a(pdcscrn.o) |
0x000000000003bf80 pdc_own_screen |
0x000000000003bf84 pdc_fwidth |
0x000000000003bfa0 pdc_color |
0x000000000003cba0 pdc_flastc |
0x000000000003cbc0 pdc_mapped |
0x000000000003d7c0 pdc_fthick |
0x000000000003d7c4 pdc_fheight |
*fill* 0x000000000003d7c8 0x18 |
COMMON 0x000000000003d7e0 0x20 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_events.o) |
0x000000000003d7e0 SDL_ProcessEvents |
COMMON 0x000000000003d800 0x24 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_keyboard.o) |
0x000000000003d800 SDL_KeyRepeat |
COMMON 0x000000000003d824 0x4 /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a(SDL_timer.o) |
0x000000000003d824 SDL_alarm_callback |
0x000000000003d830 . = ALIGN (0x10) |
*fill* 0x000000000003d828 0x8 |
0x000000000003d830 ___cmdline = . |
0x000000000003d930 . = (. + 0x100) |
*fill* 0x000000000003d830 0x100 |
0x000000000003d930 ___pgmname = . |
0x000000000003dd40 . = ((. + 0x400) + 0x10) |
*fill* 0x000000000003d930 0x410 |
0x000000000003dd40 ___stacktop = . |
0x000000000003dd40 ___memsize = . |
/DISCARD/ |
*(.debug$S) |
*(.debug$T) |
*(.debug$F) |
*(.drectve) |
*(.note.GNU-stack) |
*(.comment) |
*(.debug_abbrev) |
*(.debug_info) |
*(.debug_line) |
*(.debug_frame) |
*(.debug_loc) |
*(.debug_pubnames) |
*(.debug_aranges) |
*(.debug_ranges) |
LOAD xmas.o |
LOAD /home/max/kolibri-svn/contrib/sdk/lib/libgcc.a |
LOAD /home/max/kolibri-svn/contrib/sdk/lib/libcurses.a |
LOAD /home/max/kolibri-svn/contrib/sdk/lib/libSDLn.a |
LOAD /home/max/kolibri-svn/contrib/sdk/lib/libsound.a |
LOAD /home/max/kolibri-svn/contrib/sdk/lib/libc.dll.a |
OUTPUT(xmas pei-i386) |
/contrib/sdk/sources/PDCurses/demos/xmas |
---|
Cannot display: file marked as a binary type. |
svn:mime-type = application/octet-stream |
Property changes: |
Added: svn:executable |
+* |
\ No newline at end of property |
Added: svn:mime-type |
+application/octet-stream |
\ No newline at end of property |
/contrib/sdk/sources/PDCurses/demos/xmas.c |
---|
0,0 → 1,954 |
/******************************************************************************/ |
/* asciixmas */ |
/* December 1989 Larry Bartz Indianapolis, IN */ |
/* */ |
/* */ |
/* I'm dreaming of an ascii character-based monochrome Christmas, */ |
/* Just like the one's I used to know! */ |
/* Via a full duplex communications channel, */ |
/* At 9600 bits per second, */ |
/* Even though it's kinda slow. */ |
/* */ |
/* I'm dreaming of an ascii character-based monochrome Christmas, */ |
/* With ev'ry C program I write! */ |
/* May your screen be merry and bright! */ |
/* And may all your Christmases be amber or green, */ |
/* (for reduced eyestrain and improved visibility)! */ |
/* */ |
/* */ |
/* */ |
/* IMPLEMENTATION */ |
/* */ |
/* Feel free to modify the defined string FROMWHO to reflect you, your */ |
/* organization, your site, whatever. */ |
/* */ |
/* This looks a lot better if you can turn off your cursor before execution. */ |
/* The cursor is distracting but it doesn't really ruin the show. */ |
/* */ |
/* At our site, we invoke this for our users just after login and the */ |
/* determination of terminal type. */ |
/* */ |
/* */ |
/* PORTABILITY */ |
/* */ |
/* I wrote this using only the very simplest curses functions so that it */ |
/* might be the most portable. I was personally able to test on five */ |
/* different cpu/UNIX combinations. */ |
/* */ |
/* */ |
/* COMPILE */ |
/* */ |
/* usually this: */ |
/* */ |
/* cc -O xmas.c -lcurses -o xmas -s */ |
/* */ |
/******************************************************************************/ |
#include <curses.h> |
void lil(WINDOW *); |
void midtop(WINDOW *); |
void bigtop(WINDOW *); |
void bigface(WINDOW *, chtype); |
void legs1(WINDOW *); |
void legs2(WINDOW *); |
void legs3(WINDOW *); |
void legs4(WINDOW *); |
void initdeer(void); |
void boxit(void); |
void seas(void); |
void greet(void); |
void fromwho(void); |
void del_msg(void); |
void tree(void); |
void balls(void); |
void star(void); |
void strng1(void); |
void strng2(void); |
void strng3(void); |
void strng4(void); |
void strng5(void); |
void blinkit(void); |
void reindeer(void); |
#define FROMWHO "From Larry Bartz, Mark Hessling and William McBrine" |
int y_pos, x_pos; |
WINDOW *treescrn, *treescrn2, *treescrn3, *treescrn4, *treescrn5, |
*treescrn6, *treescrn7, *treescrn8, *dotdeer0, *stardeer0, |
*lildeer0, *lildeer1, *lildeer2, *lildeer3, *middeer0, |
*middeer1, *middeer2, *middeer3, *bigdeer0, *bigdeer1, |
*bigdeer2, *bigdeer3, *bigdeer4, *lookdeer0, *lookdeer1, |
*lookdeer2, *lookdeer3, *lookdeer4, *w_holiday, *w_del_msg; |
int main(int argc, char **argv) |
{ |
int loopy; |
#ifdef XCURSES |
Xinitscr(argc, argv); |
#else |
initscr(); |
#endif |
nodelay(stdscr, TRUE); |
noecho(); |
nonl(); |
refresh(); |
#ifdef A_COLOR |
if (has_colors()) |
start_color(); |
#endif |
curs_set(0); |
treescrn = newwin(16, 27, 3, 53); |
treescrn2 = newwin(16, 27, 3, 53); |
treescrn3 = newwin(16, 27, 3, 53); |
treescrn4 = newwin(16, 27, 3, 53); |
treescrn5 = newwin(16, 27, 3, 53); |
treescrn6 = newwin(16, 27, 3, 53); |
treescrn7 = newwin(16, 27, 3, 53); |
treescrn8 = newwin(16, 27, 3, 53); |
w_holiday = newwin(1, 26, 3, 27); |
w_del_msg = newwin(1, 12, 23, 60); |
mvwaddstr(w_holiday, 0, 0, "H A P P Y H O L I D A Y S"); |
initdeer(); |
clear(); |
werase(treescrn); |
touchwin(treescrn); |
werase(treescrn2); |
touchwin(treescrn2); |
werase(treescrn8); |
touchwin(treescrn8); |
refresh(); |
napms(1000); |
boxit(); |
del_msg(); |
napms(1000); |
seas(); |
del_msg(); |
napms(1000); |
greet(); |
del_msg(); |
napms(1000); |
fromwho(); |
del_msg(); |
napms(1000); |
tree(); |
napms(1000); |
balls(); |
napms(1000); |
star(); |
napms(1000); |
strng1(); |
strng2(); |
strng3(); |
strng4(); |
strng5(); |
/* set up the windows for our blinking trees */ |
/* **************************************** */ |
/* treescrn3 */ |
overlay(treescrn, treescrn3); |
/* balls */ |
mvwaddch(treescrn3, 4, 18, ' '); |
mvwaddch(treescrn3, 7, 6, ' '); |
mvwaddch(treescrn3, 8, 19, ' '); |
mvwaddch(treescrn3, 11, 22, ' '); |
/* star */ |
mvwaddch(treescrn3, 0, 12, '*'); |
/* strng1 */ |
mvwaddch(treescrn3, 3, 11, ' '); |
/* strng2 */ |
mvwaddch(treescrn3, 5, 13, ' '); |
mvwaddch(treescrn3, 6, 10, ' '); |
/* strng3 */ |
mvwaddch(treescrn3, 7, 16, ' '); |
mvwaddch(treescrn3, 7, 14, ' '); |
/* strng4 */ |
mvwaddch(treescrn3, 10, 13, ' '); |
mvwaddch(treescrn3, 10, 10, ' '); |
mvwaddch(treescrn3, 11, 8, ' '); |
/* strng5 */ |
mvwaddch(treescrn3, 11, 18, ' '); |
mvwaddch(treescrn3, 12, 13, ' '); |
/* treescrn4 */ |
overlay(treescrn, treescrn4); |
/* balls */ |
mvwaddch(treescrn4, 3, 9, ' '); |
mvwaddch(treescrn4, 4, 16, ' '); |
mvwaddch(treescrn4, 7, 6, ' '); |
mvwaddch(treescrn4, 8, 19, ' '); |
mvwaddch(treescrn4, 11, 2, ' '); |
mvwaddch(treescrn4, 12, 23, ' '); |
/* star */ |
mvwaddch(treescrn4, 0, 12, '*' | A_STANDOUT); |
/* strng1 */ |
mvwaddch(treescrn4, 3, 13, ' '); |
/* strng2 */ |
/* strng3 */ |
mvwaddch(treescrn4, 7, 15, ' '); |
mvwaddch(treescrn4, 8, 11, ' '); |
/* strng4 */ |
mvwaddch(treescrn4, 9, 16, ' '); |
mvwaddch(treescrn4, 10, 12, ' '); |
mvwaddch(treescrn4, 11, 8, ' '); |
/* strng5 */ |
mvwaddch(treescrn4, 11, 18, ' '); |
mvwaddch(treescrn4, 12, 14, ' '); |
/* treescrn5 */ |
overlay(treescrn, treescrn5); |
/* balls */ |
mvwaddch(treescrn5, 3, 15, ' '); |
mvwaddch(treescrn5, 10, 20, ' '); |
mvwaddch(treescrn5, 12, 1, ' '); |
/* star */ |
mvwaddch(treescrn5, 0, 12, '*'); |
/* strng1 */ |
mvwaddch(treescrn5, 3, 11, ' '); |
/* strng2 */ |
mvwaddch(treescrn5, 5, 12, ' '); |
/* strng3 */ |
mvwaddch(treescrn5, 7, 14, ' '); |
mvwaddch(treescrn5, 8, 10, ' '); |
/* strng4 */ |
mvwaddch(treescrn5, 9, 15, ' '); |
mvwaddch(treescrn5, 10, 11, ' '); |
mvwaddch(treescrn5, 11, 7, ' '); |
/* strng5 */ |
mvwaddch(treescrn5, 11, 17, ' '); |
mvwaddch(treescrn5, 12, 13, ' '); |
/* treescrn6 */ |
overlay(treescrn, treescrn6); |
/* balls */ |
mvwaddch(treescrn6, 6, 7, ' '); |
mvwaddch(treescrn6, 7, 18, ' '); |
mvwaddch(treescrn6, 10, 4, ' '); |
mvwaddch(treescrn6, 11, 23, ' '); |
/* star */ |
mvwaddch(treescrn6, 0, 12, '*' | A_STANDOUT); |
/* strng1 */ |
/* strng2 */ |
mvwaddch(treescrn6, 5, 11, ' '); |
/* strng3 */ |
mvwaddch(treescrn6, 7, 13, ' '); |
mvwaddch(treescrn6, 8, 9, ' '); |
/* strng4 */ |
mvwaddch(treescrn6, 9, 14, ' '); |
mvwaddch(treescrn6, 10, 10, ' '); |
mvwaddch(treescrn6, 11, 6, ' '); |
/* strng5 */ |
mvwaddch(treescrn6, 11, 16, ' '); |
mvwaddch(treescrn6, 12, 12, ' '); |
/* treescrn7 */ |
overlay(treescrn, treescrn7); |
/* balls */ |
mvwaddch(treescrn7, 3, 15, ' '); |
mvwaddch(treescrn7, 6, 7, ' '); |
mvwaddch(treescrn7, 7, 18, ' '); |
mvwaddch(treescrn7, 10, 4, ' '); |
mvwaddch(treescrn7, 11, 22, ' '); |
/* star */ |
mvwaddch(treescrn7, 0, 12, '*'); |
/* strng1 */ |
mvwaddch(treescrn7, 3, 12, ' '); |
/* strng2 */ |
mvwaddch(treescrn7, 5, 13, ' '); |
mvwaddch(treescrn7, 6, 9, ' '); |
/* strng3 */ |
mvwaddch(treescrn7, 7, 15, ' '); |
mvwaddch(treescrn7, 8, 11, ' '); |
/* strng4 */ |
mvwaddch(treescrn7, 9, 16, ' '); |
mvwaddch(treescrn7, 10, 12, ' '); |
mvwaddch(treescrn7, 11, 8, ' '); |
/* strng5 */ |
mvwaddch(treescrn7, 11, 18, ' '); |
mvwaddch(treescrn7, 12, 14, ' '); |
napms(1000); |
reindeer(); |
touchwin(w_holiday); |
wrefresh(w_holiday); |
wrefresh(w_del_msg); |
napms(1000); |
for (loopy = 0; loopy < 50; loopy++) |
blinkit(); |
clear(); |
refresh(); |
endwin(); |
return 0; |
} |
void lil(WINDOW *win) |
{ |
mvwaddch(win, 0, 0, (chtype) 'V'); |
mvwaddch(win, 1, 0, (chtype) '@'); |
mvwaddch(win, 1, 3, (chtype) '~'); |
} |
void midtop(WINDOW *win) |
{ |
mvwaddstr(win, 0, 2, "yy"); |
mvwaddstr(win, 1, 2, "0(=)~"); |
} |
void bigtop(WINDOW *win) |
{ |
mvwaddstr(win, 0, 17, "\\/"); |
mvwaddstr(win, 0, 20, "\\/"); |
mvwaddch(win, 1, 18, (chtype) '\\'); |
mvwaddch(win, 1, 20, (chtype) '/'); |
mvwaddstr(win, 2, 19, "|_"); |
mvwaddstr(win, 3, 18, "/^0\\"); |
mvwaddstr(win, 4, 17, "//\\"); |
mvwaddch(win, 4, 22, (chtype) '\\'); |
mvwaddstr(win, 5, 7, "^~~~~~~~~// ~~U"); |
} |
void bigface(WINDOW *win, chtype noseattr) |
{ |
mvwaddstr(win, 0, 16, "\\/ \\/"); |
mvwaddstr(win, 1, 17, "\\Y/ \\Y/"); |
mvwaddstr(win, 2, 19, "\\=/"); |
mvwaddstr(win, 3, 17, "^\\o o/^"); |
mvwaddstr(win, 4, 17, "//( )"); |
mvwaddstr(win, 5, 7, "^~~~~~~~~// \\"); |
waddch(win, 'O' | noseattr); |
waddstr(win, "/"); |
} |
void legs1(WINDOW *win) |
{ |
mvwaddstr(win, 6, 7, "( \\_____( /"); |
mvwaddstr(win, 7, 8, "( ) /"); |
mvwaddstr(win, 8, 9, "\\\\ /"); |
mvwaddstr(win, 9, 11, "\\>/>"); |
} |
void legs2(WINDOW *win) |
{ |
mvwaddstr(win, 6, 7, "(( )____( /"); |
mvwaddstr(win, 7, 7, "( / |"); |
mvwaddstr(win, 8, 8, "\\/ |"); |
mvwaddstr(win, 9, 9, "|> |>"); |
} |
void legs3(WINDOW *win) |
{ |
mvwaddstr(win, 6, 6, "( ()_____( /"); |
mvwaddstr(win, 7, 6, "/ / /"); |
mvwaddstr(win, 8, 5, "|/ \\"); |
mvwaddstr(win, 9, 5, "/> \\>"); |
} |
void legs4(WINDOW *win) |
{ |
mvwaddstr(win, 6, 6, "( )______( /"); |
mvwaddstr(win, 7, 5, "(/ \\"); |
mvwaddstr(win, 8, 0, "v___= ----^"); |
} |
void initdeer(void) |
{ |
chtype noseattr; |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(31, COLOR_RED, COLOR_BLACK); |
noseattr = COLOR_PAIR(31); |
} |
else |
#endif |
noseattr = A_NORMAL; |
/* set up the windows for our various reindeer */ |
dotdeer0 = newwin(3, 71, 0, 8); |
stardeer0 = newwin(4, 56, 0, 8); |
lildeer0 = newwin(7, 54, 0, 8); |
middeer0 = newwin(15, 42, 0, 8); |
bigdeer0 = newwin(10, 23, 0, 0); |
lookdeer0 = newwin(10, 25, 0, 0); |
/* lildeer1 */ |
lildeer1 = newwin(2, 4, 0, 0); |
lil(lildeer1); |
mvwaddstr(lildeer1, 1, 1, "<>"); |
/* lildeer2 */ |
lildeer2 = newwin(2, 4, 0, 0); |
lil(lildeer2); |
mvwaddstr(lildeer2, 1, 1, "||"); |
/* lildeer3 */ |
lildeer3 = newwin(2, 4, 0, 0); |
lil(lildeer3); |
mvwaddstr(lildeer3, 1, 1, "><"); |
/* middeer1 */ |
middeer1 = newwin(3, 7, 0, 0); |
midtop(middeer1); |
mvwaddstr(middeer1, 2, 3, "\\/"); |
/* middeer2 */ |
middeer2 = newwin(3, 7, 0, 0); |
midtop(middeer2); |
mvwaddch(middeer2, 2, 3, (chtype) '|'); |
mvwaddch(middeer2, 2, 5, (chtype) '|'); |
/* middeer3 */ |
middeer3 = newwin(3, 7, 0, 0); |
midtop(middeer3); |
mvwaddch(middeer3, 2, 2, (chtype) '/'); |
mvwaddch(middeer3, 2, 6, (chtype) '\\'); |
/* bigdeer1 */ |
bigdeer1 = newwin(10, 23, 0, 0); |
bigtop(bigdeer1); |
legs1(bigdeer1); |
/* bigdeer2 */ |
bigdeer2 = newwin(10, 23, 0, 0); |
bigtop(bigdeer2); |
legs2(bigdeer2); |
/* bigdeer3 */ |
bigdeer3 = newwin(10, 23, 0, 0); |
bigtop(bigdeer3); |
legs3(bigdeer3); |
/* bigdeer4 */ |
bigdeer4 = newwin(10, 23, 0, 0); |
bigtop(bigdeer4); |
legs4(bigdeer4); |
/* lookdeer1 */ |
lookdeer1 = newwin(10, 25, 0, 0); |
bigface(lookdeer1, noseattr); |
legs1(lookdeer1); |
/* lookdeer2 */ |
lookdeer2 = newwin(10, 25, 0, 0); |
bigface(lookdeer2, noseattr); |
legs2(lookdeer2); |
/* lookdeer3 */ |
lookdeer3 = newwin(10, 25, 0, 0); |
bigface(lookdeer3, noseattr); |
legs3(lookdeer3); |
/* lookdeer4 */ |
lookdeer4 = newwin(10, 25, 0, 0); |
bigface(lookdeer4, noseattr); |
legs4(lookdeer4); |
} |
void boxit(void) |
{ |
int x; |
for (x = 0; x < 20; ++x) |
mvaddch(x, 7, '|'); |
for (x = 0; x < 80; ++x) |
{ |
if (x > 7) |
mvaddch(19, x, '_'); |
mvaddch(22, x, '_'); |
} |
} |
void seas(void) |
{ |
mvaddch(4, 1, 'S'); |
mvaddch(6, 1, 'E'); |
mvaddch(8, 1, 'A'); |
mvaddch(10, 1, 'S'); |
mvaddch(12, 1, 'O'); |
mvaddch(14, 1, 'N'); |
mvaddch(16, 1, '`'); |
mvaddch(18, 1, 'S'); |
} |
void greet(void) |
{ |
mvaddch(3, 5, 'G'); |
mvaddch(5, 5, 'R'); |
mvaddch(7, 5, 'E'); |
mvaddch(9, 5, 'E'); |
mvaddch(11, 5, 'T'); |
mvaddch(13, 5, 'I'); |
mvaddch(15, 5, 'N'); |
mvaddch(17, 5, 'G'); |
mvaddch(19, 5, 'S'); |
} |
void fromwho(void) |
{ |
mvaddstr(21, 13, FROMWHO); |
} |
void del_msg(void) |
{ |
refresh(); |
} |
void tree(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(30, COLOR_GREEN, COLOR_BLACK); |
wattrset(treescrn, COLOR_PAIR(30)); |
} |
#endif |
mvwaddch(treescrn, 1, 11, (chtype) '/'); |
mvwaddch(treescrn, 2, 11, (chtype) '/'); |
mvwaddch(treescrn, 3, 10, (chtype) '/'); |
mvwaddch(treescrn, 4, 9, (chtype) '/'); |
mvwaddch(treescrn, 5, 9, (chtype) '/'); |
mvwaddch(treescrn, 6, 8, (chtype) '/'); |
mvwaddch(treescrn, 7, 7, (chtype) '/'); |
mvwaddch(treescrn, 8, 6, (chtype) '/'); |
mvwaddch(treescrn, 9, 6, (chtype) '/'); |
mvwaddch(treescrn, 10, 5, (chtype) '/'); |
mvwaddch(treescrn, 11, 3, (chtype) '/'); |
mvwaddch(treescrn, 12, 2, (chtype) '/'); |
mvwaddch(treescrn, 1, 13, (chtype) '\\'); |
mvwaddch(treescrn, 2, 13, (chtype) '\\'); |
mvwaddch(treescrn, 3, 14, (chtype) '\\'); |
mvwaddch(treescrn, 4, 15, (chtype) '\\'); |
mvwaddch(treescrn, 5, 15, (chtype) '\\'); |
mvwaddch(treescrn, 6, 16, (chtype) '\\'); |
mvwaddch(treescrn, 7, 17, (chtype) '\\'); |
mvwaddch(treescrn, 8, 18, (chtype) '\\'); |
mvwaddch(treescrn, 9, 18, (chtype) '\\'); |
mvwaddch(treescrn, 10, 19, (chtype) '\\'); |
mvwaddch(treescrn, 11, 21, (chtype) '\\'); |
mvwaddch(treescrn, 12, 22, (chtype) '\\'); |
mvwaddch(treescrn, 4, 10, (chtype) '_'); |
mvwaddch(treescrn, 4, 14, (chtype) '_'); |
mvwaddch(treescrn, 8, 7, (chtype) '_'); |
mvwaddch(treescrn, 8, 17, (chtype) '_'); |
mvwaddstr(treescrn, 13, 0, |
"//////////// \\\\\\\\\\\\\\\\\\\\\\\\"); |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(20, COLOR_YELLOW, COLOR_BLACK); |
wattrset(treescrn, COLOR_PAIR(20)); |
} |
#endif |
mvwaddstr(treescrn, 14, 11, "| |"); |
mvwaddstr(treescrn, 15, 11, "|_|"); |
wrefresh(treescrn); |
wrefresh(w_del_msg); |
} |
void balls(void) |
{ |
chtype ball1, ball2, ball3, ball4, ball5, ball6; |
overlay(treescrn, treescrn2); |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(1, COLOR_BLUE, COLOR_BLACK); |
init_pair(2, COLOR_RED, COLOR_BLACK); |
init_pair(3, COLOR_MAGENTA, COLOR_BLACK); |
init_pair(4, COLOR_CYAN, COLOR_BLACK); |
init_pair(5, COLOR_YELLOW, COLOR_BLACK); |
init_pair(6, COLOR_WHITE, COLOR_BLACK); |
ball1 = COLOR_PAIR(1) | '@'; |
ball2 = COLOR_PAIR(2) | '@'; |
ball3 = COLOR_PAIR(3) | '@'; |
ball4 = COLOR_PAIR(4) | '@'; |
ball5 = COLOR_PAIR(5) | '@'; |
ball6 = COLOR_PAIR(6) | '@'; |
} |
else |
#endif |
ball1 = ball2 = ball3 = ball4 = ball5 = ball6 = '@'; |
mvwaddch(treescrn2, 3, 9, ball1); |
mvwaddch(treescrn2, 3, 15, ball2); |
mvwaddch(treescrn2, 4, 8, ball3); |
mvwaddch(treescrn2, 4, 16, ball4); |
mvwaddch(treescrn2, 5, 7, ball5); |
mvwaddch(treescrn2, 5, 17, ball6); |
mvwaddch(treescrn2, 7, 6, ball1 | A_BOLD); |
mvwaddch(treescrn2, 7, 18, ball2 | A_BOLD); |
mvwaddch(treescrn2, 8, 5, ball3 | A_BOLD); |
mvwaddch(treescrn2, 8, 19, ball4 | A_BOLD); |
mvwaddch(treescrn2, 10, 4, ball5 | A_BOLD); |
mvwaddch(treescrn2, 10, 20, ball6 | A_BOLD); |
mvwaddch(treescrn2, 11, 2, ball1); |
mvwaddch(treescrn2, 11, 22, ball2); |
mvwaddch(treescrn2, 12, 1, ball3); |
mvwaddch(treescrn2, 12, 23, ball4); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void star(void) |
{ |
mvwaddch(treescrn2, 0, 12, (chtype) '*' | A_STANDOUT); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void strng1(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(10, COLOR_YELLOW, COLOR_BLACK); |
wattrset(treescrn2, COLOR_PAIR(10) | A_BOLD); |
} |
#endif |
mvwaddstr(treescrn2, 3, 11, ".:'"); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void strng2(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(11, COLOR_RED, COLOR_BLACK); |
wattrset(treescrn2, COLOR_PAIR(11) | A_BOLD); |
} |
#endif |
mvwaddstr(treescrn2, 5, 11, ",.:'"); |
mvwaddstr(treescrn2, 6, 9, ":'"); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void strng3(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(12, COLOR_GREEN, COLOR_BLACK); |
wattrset(treescrn2, COLOR_PAIR(12) | A_BOLD); |
} |
#endif |
mvwaddstr(treescrn2, 7, 13, ",.:'"); |
mvwaddstr(treescrn2, 8, 9, ",.:'"); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void strng4(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(13, COLOR_WHITE, COLOR_BLACK); |
wattrset(treescrn2, COLOR_PAIR(13) | A_BOLD); |
} |
#endif |
mvwaddstr(treescrn2, 9, 14, ",.:'"); |
mvwaddstr(treescrn2, 10, 10, ",.:'"); |
mvwaddstr(treescrn2, 11, 6, ",.:'"); |
mvwaddch(treescrn2, 12, 5, (chtype) '\''); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void strng5(void) |
{ |
#ifdef A_COLOR |
if (has_colors()) |
{ |
init_pair(14, COLOR_CYAN, COLOR_BLACK); |
wattrset(treescrn2, COLOR_PAIR(14) | A_BOLD); |
} |
#endif |
mvwaddstr(treescrn2, 11, 16, ",.:'"); |
mvwaddstr(treescrn2, 12, 12, ",.:'"); |
/* save a fully lit tree */ |
overlay(treescrn2, treescrn); |
wrefresh(treescrn2); |
wrefresh(w_del_msg); |
} |
void blinkit(void) |
{ |
static int cycle; |
if (cycle > 4) |
cycle = 0; |
touchwin(treescrn8); |
switch (cycle) |
{ |
case 0: |
overlay(treescrn3, treescrn8); |
break; |
case 1: |
overlay(treescrn4, treescrn8); |
break; |
case 2: |
overlay(treescrn5, treescrn8); |
break; |
case 3: |
overlay(treescrn6, treescrn8); |
break; |
case 4: |
overlay(treescrn7, treescrn8); |
} |
wrefresh(treescrn8); |
wrefresh(w_del_msg); |
napms(50); |
touchwin(treescrn8); |
/*ALL ON************************************************** */ |
overlay(treescrn, treescrn8); |
wrefresh(treescrn8); |
wrefresh(w_del_msg); |
++cycle; |
} |
#define TSHOW(win, pause) touchwin(win); wrefresh(win); \ |
wrefresh(w_del_msg); napms(pause) |
#define SHOW(win, pause) mvwin(win, y_pos, x_pos); wrefresh(win); \ |
wrefresh(w_del_msg); napms(pause) |
void reindeer(void) |
{ |
int looper; |
y_pos = 0; |
for (x_pos = 70; x_pos > 62; x_pos--) |
{ |
if (x_pos < 62) |
y_pos = 1; |
for (looper = 0; looper < 4; looper++) |
{ |
mvwaddch(dotdeer0, y_pos, x_pos, (chtype) '.'); |
wrefresh(dotdeer0); |
wrefresh(w_del_msg); |
werase(dotdeer0); |
wrefresh(dotdeer0); |
wrefresh(w_del_msg); |
} |
} |
y_pos = 2; |
for (; x_pos > 50; x_pos--) |
{ |
for (looper = 0; looper < 4; looper++) |
{ |
if (x_pos < 56) |
{ |
y_pos = 3; |
mvwaddch(stardeer0, y_pos, x_pos, (chtype) '*'); |
wrefresh(stardeer0); |
wrefresh(w_del_msg); |
werase(stardeer0); |
wrefresh(stardeer0); |
} |
else |
{ |
mvwaddch(dotdeer0, y_pos, x_pos, (chtype) '*'); |
wrefresh(dotdeer0); |
wrefresh(w_del_msg); |
werase(dotdeer0); |
wrefresh(dotdeer0); |
} |
wrefresh(w_del_msg); |
} |
} |
x_pos = 58; |
for (y_pos = 2; y_pos < 5; y_pos++) |
{ |
TSHOW(lildeer0, 50); |
for (looper = 0; looper < 4; looper++) |
{ |
SHOW(lildeer3, 50); |
SHOW(lildeer2, 50); |
SHOW(lildeer1, 50); |
SHOW(lildeer2, 50); |
SHOW(lildeer3, 50); |
TSHOW(lildeer0, 50); |
x_pos -= 2; |
} |
} |
x_pos = 35; |
for (y_pos = 5; y_pos < 10; y_pos++) |
{ |
touchwin(middeer0); |
wrefresh(middeer0); |
wrefresh(w_del_msg); |
for (looper = 0; looper < 2; looper++) |
{ |
SHOW(middeer3, 50); |
SHOW(middeer2, 50); |
SHOW(middeer1, 50); |
SHOW(middeer2, 50); |
SHOW(middeer3, 50); |
TSHOW(middeer0, 50); |
x_pos -= 3; |
} |
} |
napms(2000); |
y_pos = 1; |
for (x_pos = 8; x_pos < 16; x_pos++) |
{ |
SHOW(bigdeer4, 30); |
SHOW(bigdeer3, 30); |
SHOW(bigdeer2, 30); |
SHOW(bigdeer1, 30); |
SHOW(bigdeer2, 30); |
SHOW(bigdeer3, 30); |
SHOW(bigdeer4, 30); |
SHOW(bigdeer0, 30); |
} |
--x_pos; |
for (looper = 0; looper < 6; looper++) |
{ |
SHOW(lookdeer4, 40); |
SHOW(lookdeer3, 40); |
SHOW(lookdeer2, 40); |
SHOW(lookdeer1, 40); |
SHOW(lookdeer2, 40); |
SHOW(lookdeer3, 40); |
SHOW(lookdeer4, 40); |
} |
SHOW(lookdeer0, 40); |
for (; y_pos < 10; y_pos++) |
{ |
for (looper = 0; looper < 2; looper++) |
{ |
SHOW(bigdeer4, 30); |
SHOW(bigdeer3, 30); |
SHOW(bigdeer2, 30); |
SHOW(bigdeer1, 30); |
SHOW(bigdeer2, 30); |
SHOW(bigdeer3, 30); |
SHOW(bigdeer4, 30); |
} |
SHOW(bigdeer0, 30); |
} |
--y_pos; |
mvwin(lookdeer3, y_pos, x_pos); |
wrefresh(lookdeer3); |
wrefresh(w_del_msg); |
} |
/contrib/sdk/sources/PDCurses/panel.h |
---|
0,0 → 1,54 |
/*----------------------------------------------------------------------* |
* Panels for PDCurses * |
*----------------------------------------------------------------------*/ |
#ifndef __PDCURSES_PANEL_H__ |
#define __PDCURSES_PANEL_H__ 1 |
#include <curses.h> |
#ifdef __cplusplus |
extern "C" |
{ |
#endif |
typedef struct panelobs |
{ |
struct panelobs *above; |
struct panel *pan; |
} PANELOBS; |
typedef struct panel |
{ |
WINDOW *win; |
int wstarty; |
int wendy; |
int wstartx; |
int wendx; |
struct panel *below; |
struct panel *above; |
const void *user; |
struct panelobs *obscure; |
} PANEL; |
PDCEX int bottom_panel(PANEL *pan); |
PDCEX int del_panel(PANEL *pan); |
PDCEX int hide_panel(PANEL *pan); |
PDCEX int move_panel(PANEL *pan, int starty, int startx); |
PDCEX PANEL *new_panel(WINDOW *win); |
PDCEX PANEL *panel_above(const PANEL *pan); |
PDCEX PANEL *panel_below(const PANEL *pan); |
PDCEX int panel_hidden(const PANEL *pan); |
PDCEX const void *panel_userptr(const PANEL *pan); |
PDCEX WINDOW *panel_window(const PANEL *pan); |
PDCEX int replace_panel(PANEL *pan, WINDOW *win); |
PDCEX int set_panel_userptr(PANEL *pan, const void *uptr); |
PDCEX int show_panel(PANEL *pan); |
PDCEX int top_panel(PANEL *pan); |
PDCEX void update_panels(void); |
#ifdef __cplusplus |
} |
#endif |
#endif /* __PDCURSES_PANEL_H__ */ |
/contrib/sdk/sources/PDCurses/pdcurses/README.md |
---|
0,0 → 1,25 |
PDCurses Portable Core |
====================== |
This directory contains core PDCurses source code files common to all |
platforms. |
Building |
-------- |
These modules are built by the platform-specific makefiles, in the |
platform directories. |
Distribution Status |
------------------- |
The files in this directory are released to the public domain. |
Acknowledgements |
---------------- |
The panel library was originally provided by |
Warren Tucker <wht@n4hgf.mt-park.ga.us> |
/contrib/sdk/sources/PDCurses/pdcurses/addch.c |
---|
0,0 → 1,408 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
addch |
----- |
### Synopsis |
int addch(const chtype ch); |
int waddch(WINDOW *win, const chtype ch); |
int mvaddch(int y, int x, const chtype ch); |
int mvwaddch(WINDOW *win, int y, int x, const chtype ch); |
int echochar(const chtype ch); |
int wechochar(WINDOW *win, const chtype ch); |
int addrawch(chtype ch); |
int waddrawch(WINDOW *win, chtype ch); |
int mvaddrawch(int y, int x, chtype ch); |
int mvwaddrawch(WINDOW *win, int y, int x, chtype ch); |
int add_wch(const cchar_t *wch); |
int wadd_wch(WINDOW *win, const cchar_t *wch); |
int mvadd_wch(int y, int x, const cchar_t *wch); |
int mvwadd_wch(WINDOW *win, int y, int x, const cchar_t *wch); |
int echo_wchar(const cchar_t *wch); |
int wecho_wchar(WINDOW *win, const cchar_t *wch); |
### Description |
addch() adds the chtype ch to the default window (stdscr) at the |
current cursor position, and advances the cursor. Note that chtypes |
can convey both text (a single character) and attributes, including a |
color pair. add_wch() is the wide-character version of this function, |
taking a pointer to a cchar_t instead of a chtype. |
waddch() is like addch(), but also lets you specify the window. (This |
is in fact the core output routine.) wadd_wch() is the wide version. |
mvaddch() moves the cursor to the specified (y, x) position, and adds |
ch to stdscr. mvadd_wch() is the wide version. |
mvwaddch() moves the cursor to the specified position and adds ch to |
the specified window. mvwadd_wch() is the wide version. |
echochar() adds ch to stdscr at the current cursor position and calls |
refresh(). echo_wchar() is the wide version. |
wechochar() adds ch to the specified window and calls wrefresh(). |
wecho_wchar() is the wide version. |
addrawch(), waddrawch(), mvaddrawch() and mvwaddrawch() are PDCurses- |
specific wrappers for addch() etc. that disable the translation of |
control characters. |
The following applies to all these functions: |
If the cursor moves on to the right margin, an automatic newline is |
performed. If scrollok is enabled, and a character is added to the |
bottom right corner of the window, the scrolling region will be |
scrolled up one line. If scrolling is not allowed, ERR will be |
returned. |
If ch is a tab, newline, or backspace, the cursor will be moved |
appropriately within the window. If ch is a newline, the clrtoeol |
routine is called before the cursor is moved to the beginning of the |
next line. If newline mapping is off, the cursor will be moved to |
the next line, but the x coordinate will be unchanged. If ch is a |
tab the cursor is moved to the next tab position within the window. |
If ch is another control character, it will be drawn in the ^X |
notation. Calling the inch() routine after adding a control |
character returns the representation of the control character, not |
the control character. |
Video attributes can be combined with a character by ORing them into |
the parameter. Text, including attributes, can be copied from one |
place to another by using inch() and addch(). |
Note that in PDCurses, for now, a cchar_t and a chtype are the same. |
The text field is 16 bits wide, and is treated as Unicode (UCS-2) |
when PDCurses is built with wide-character support (define PDC_WIDE). |
So, in functions that take a chtype, like addch(), both the wide and |
narrow versions will handle Unicode. But for portability, you should |
use the wide functions. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
addch Y Y Y |
waddch Y Y Y |
mvaddch Y Y Y |
mvwaddch Y Y Y |
echochar Y Y Y |
wechochar Y Y Y |
add_wch Y Y Y |
wadd_wch Y Y Y |
mvadd_wch Y Y Y |
mvwadd_wch Y Y Y |
echo_wchar Y Y Y |
wecho_wchar Y Y Y |
addrawch - - - |
waddrawch - - - |
mvaddrawch - - - |
mvwaddrawch - - - |
**man-end****************************************************************/ |
int waddch(WINDOW *win, const chtype ch) |
{ |
int x, y; |
chtype text, attr; |
bool xlat; |
PDC_LOG(("waddch() - called: win=%p ch=%x (text=%c attr=0x%x)\n", |
win, ch, ch & A_CHARTEXT, ch & A_ATTRIBUTES)); |
if (!win || !SP) |
return ERR; |
x = win->_curx; |
y = win->_cury; |
if (y > win->_maxy || x > win->_maxx || y < 0 || x < 0) |
return ERR; |
xlat = !SP->raw_out && !(ch & A_ALTCHARSET); |
text = ch & A_CHARTEXT; |
attr = ch & A_ATTRIBUTES; |
if (xlat && (text < ' ' || text == 0x7f)) |
{ |
int x2; |
switch (text) |
{ |
case '\t': |
for (x2 = ((x / TABSIZE) + 1) * TABSIZE; x < x2; x++) |
{ |
if (waddch(win, attr | ' ') == ERR) |
return ERR; |
/* if tab to next line, exit the loop */ |
if (!win->_curx) |
break; |
} |
return OK; |
case '\n': |
/* if lf -> crlf */ |
if (!SP->raw_out) |
x = 0; |
wclrtoeol(win); |
if (++y > win->_bmarg) |
{ |
y--; |
if (wscrl(win, 1) == ERR) |
return ERR; |
} |
break; |
case '\b': |
/* don't back over left margin */ |
if (--x < 0) |
case '\r': |
x = 0; |
break; |
case 0x7f: |
if (waddch(win, attr | '^') == ERR) |
return ERR; |
return waddch(win, attr | '?'); |
default: |
/* handle control chars */ |
if (waddch(win, attr | '^') == ERR) |
return ERR; |
return waddch(win, ch + '@'); |
} |
} |
else |
{ |
/* If the incoming character doesn't have its own attribute, |
then use the current attributes for the window. If it has |
attributes but not a color component, OR the attributes to |
the current attributes for the window. If it has a color |
component, use the attributes solely from the incoming |
character. */ |
if (!(attr & A_COLOR)) |
attr |= win->_attrs; |
/* wrs (4/10/93): Apply the same sort of logic for the window |
background, in that it only takes precedence if other color |
attributes are not there and that the background character |
will only print if the printing character is blank. */ |
if (!(attr & A_COLOR)) |
attr |= win->_bkgd & A_ATTRIBUTES; |
else |
attr |= win->_bkgd & (A_ATTRIBUTES ^ A_COLOR); |
if (text == ' ') |
text = win->_bkgd & A_CHARTEXT; |
/* Add the attribute back into the character. */ |
text |= attr; |
/* Only change _firstch/_lastch if the character to be added is |
different from the character/attribute that is already in |
that position in the window. */ |
if (win->_y[y][x] != text) |
{ |
if (win->_firstch[y] == _NO_CHANGE) |
win->_firstch[y] = win->_lastch[y] = x; |
else |
if (x < win->_firstch[y]) |
win->_firstch[y] = x; |
else |
if (x > win->_lastch[y]) |
win->_lastch[y] = x; |
win->_y[y][x] = text; |
} |
if (++x >= win->_maxx) |
{ |
/* wrap around test */ |
x = 0; |
if (++y > win->_bmarg) |
{ |
y--; |
if (wscrl(win, 1) == ERR) |
{ |
PDC_sync(win); |
return ERR; |
} |
} |
} |
} |
win->_curx = x; |
win->_cury = y; |
if (win->_immed) |
wrefresh(win); |
if (win->_sync) |
wsyncup(win); |
return OK; |
} |
int addch(const chtype ch) |
{ |
PDC_LOG(("addch() - called: ch=%x\n", ch)); |
return waddch(stdscr, ch); |
} |
int mvaddch(int y, int x, const chtype ch) |
{ |
PDC_LOG(("mvaddch() - called: y=%d x=%d ch=%x\n", y, x, ch)); |
if (move(y,x) == ERR) |
return ERR; |
return waddch(stdscr, ch); |
} |
int mvwaddch(WINDOW *win, int y, int x, const chtype ch) |
{ |
PDC_LOG(("mvwaddch() - called: win=%p y=%d x=%d ch=%d\n", win, y, x, ch)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddch(win, ch); |
} |
int echochar(const chtype ch) |
{ |
PDC_LOG(("echochar() - called: ch=%x\n", ch)); |
return wechochar(stdscr, ch); |
} |
int wechochar(WINDOW *win, const chtype ch) |
{ |
PDC_LOG(("wechochar() - called: win=%p ch=%x\n", win, ch)); |
if (waddch(win, ch) == ERR) |
return ERR; |
return wrefresh(win); |
} |
int waddrawch(WINDOW *win, chtype ch) |
{ |
PDC_LOG(("waddrawch() - called: win=%p ch=%x (text=%c attr=0x%x)\n", |
win, ch, ch & A_CHARTEXT, ch & A_ATTRIBUTES)); |
if ((ch & A_CHARTEXT) < ' ' || (ch & A_CHARTEXT) == 0x7f) |
ch |= A_ALTCHARSET; |
return waddch(win, ch); |
} |
int addrawch(chtype ch) |
{ |
PDC_LOG(("addrawch() - called: ch=%x\n", ch)); |
return waddrawch(stdscr, ch); |
} |
int mvaddrawch(int y, int x, chtype ch) |
{ |
PDC_LOG(("mvaddrawch() - called: y=%d x=%d ch=%d\n", y, x, ch)); |
if (move(y, x) == ERR) |
return ERR; |
return waddrawch(stdscr, ch); |
} |
int mvwaddrawch(WINDOW *win, int y, int x, chtype ch) |
{ |
PDC_LOG(("mvwaddrawch() - called: win=%p y=%d x=%d ch=%d\n", |
win, y, x, ch)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddrawch(win, ch); |
} |
#ifdef PDC_WIDE |
int wadd_wch(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wadd_wch() - called: win=%p wch=%x\n", win, *wch)); |
return wch ? waddch(win, *wch) : ERR; |
} |
int add_wch(const cchar_t *wch) |
{ |
PDC_LOG(("add_wch() - called: wch=%x\n", *wch)); |
return wadd_wch(stdscr, wch); |
} |
int mvadd_wch(int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvaddch() - called: y=%d x=%d wch=%x\n", y, x, *wch)); |
if (move(y,x) == ERR) |
return ERR; |
return wadd_wch(stdscr, wch); |
} |
int mvwadd_wch(WINDOW *win, int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvwaddch() - called: win=%p y=%d x=%d wch=%d\n", |
win, y, x, *wch)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wadd_wch(win, wch); |
} |
int echo_wchar(const cchar_t *wch) |
{ |
PDC_LOG(("echo_wchar() - called: wch=%x\n", *wch)); |
return wecho_wchar(stdscr, wch); |
} |
int wecho_wchar(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wecho_wchar() - called: win=%p wch=%x\n", win, *wch)); |
if (!wch || (wadd_wch(win, wch) == ERR)) |
return ERR; |
return wrefresh(win); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/addchstr.c |
---|
0,0 → 1,244 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
addchstr |
-------- |
### Synopsis |
int addchstr(const chtype *ch); |
int addchnstr(const chtype *ch, int n); |
int waddchstr(WINDOW *win, const chtype *ch); |
int waddchnstr(WINDOW *win, const chtype *ch, int n); |
int mvaddchstr(int y, int x, const chtype *ch); |
int mvaddchnstr(int y, int x, const chtype *ch, int n); |
int mvwaddchstr(WINDOW *, int y, int x, const chtype *ch); |
int mvwaddchnstr(WINDOW *, int y, int x, const chtype *ch, int n); |
int add_wchstr(const cchar_t *wch); |
int add_wchnstr(const cchar_t *wch, int n); |
int wadd_wchstr(WINDOW *win, const cchar_t *wch); |
int wadd_wchnstr(WINDOW *win, const cchar_t *wch, int n); |
int mvadd_wchstr(int y, int x, const cchar_t *wch); |
int mvadd_wchnstr(int y, int x, const cchar_t *wch, int n); |
int mvwadd_wchstr(WINDOW *win, int y, int x, const cchar_t *wch); |
int mvwadd_wchnstr(WINDOW *win, int y, int x, const cchar_t *wch, |
int n); |
### Description |
These routines write a chtype or cchar_t string directly into the |
window structure, starting at the current or specified position. The |
four routines with n as the last argument copy at most n elements, |
but no more than will fit on the line. If n == -1 then the whole |
string is copied, up to the maximum number that will fit on the line. |
The cursor position is not advanced. These routines do not check for |
newline or other special characters, nor does any line wrapping |
occur. |
### Return Value |
All functions return OK or ERR. |
### Portability |
X/Open ncurses NetBSD |
addchstr Y Y Y |
waddchstr Y Y Y |
mvaddchstr Y Y Y |
mvwaddchstr Y Y Y |
addchnstr Y Y Y |
waddchnstr Y Y Y |
mvaddchnstr Y Y Y |
mvwaddchnstr Y Y Y |
add_wchstr Y Y Y |
wadd_wchstr Y Y Y |
mvadd_wchstr Y Y Y |
mvwadd_wchstr Y Y Y |
add_wchnstr Y Y Y |
wadd_wchnstr Y Y Y |
mvadd_wchnstr Y Y Y |
mvwadd_wchnstr Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
int waddchnstr(WINDOW *win, const chtype *ch, int n) |
{ |
int y, x, maxx, minx; |
chtype *ptr; |
PDC_LOG(("waddchnstr() - called: win=%p n=%d\n", win, n)); |
if (!win || !ch || !n || n < -1) |
return ERR; |
x = win->_curx; |
y = win->_cury; |
ptr = &(win->_y[y][x]); |
if (n == -1 || n > win->_maxx - x) |
n = win->_maxx - x; |
minx = win->_firstch[y]; |
maxx = win->_lastch[y]; |
for (; n && *ch; n--, x++, ptr++, ch++) |
{ |
if (*ptr != *ch) |
{ |
if (x < minx || minx == _NO_CHANGE) |
minx = x; |
if (x > maxx) |
maxx = x; |
PDC_LOG(("y %d x %d minx %d maxx %d *ptr %x *ch" |
" %x firstch: %d lastch: %d\n", |
y, x, minx, maxx, *ptr, *ch, |
win->_firstch[y], win->_lastch[y])); |
*ptr = *ch; |
} |
} |
win->_firstch[y] = minx; |
win->_lastch[y] = maxx; |
return OK; |
} |
int addchstr(const chtype *ch) |
{ |
PDC_LOG(("addchstr() - called\n")); |
return waddchnstr(stdscr, ch, -1); |
} |
int addchnstr(const chtype *ch, int n) |
{ |
PDC_LOG(("addchnstr() - called\n")); |
return waddchnstr(stdscr, ch, n); |
} |
int waddchstr(WINDOW *win, const chtype *ch) |
{ |
PDC_LOG(("waddchstr() - called: win=%p\n", win)); |
return waddchnstr(win, ch, -1); |
} |
int mvaddchstr(int y, int x, const chtype *ch) |
{ |
PDC_LOG(("mvaddchstr() - called: y %d x %d\n", y, x)); |
if (move(y, x) == ERR) |
return ERR; |
return waddchnstr(stdscr, ch, -1); |
} |
int mvaddchnstr(int y, int x, const chtype *ch, int n) |
{ |
PDC_LOG(("mvaddchnstr() - called: y %d x %d n %d\n", y, x, n)); |
if (move(y, x) == ERR) |
return ERR; |
return waddchnstr(stdscr, ch, n); |
} |
int mvwaddchstr(WINDOW *win, int y, int x, const chtype *ch) |
{ |
PDC_LOG(("mvwaddchstr() - called:\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddchnstr(win, ch, -1); |
} |
int mvwaddchnstr(WINDOW *win, int y, int x, const chtype *ch, int n) |
{ |
PDC_LOG(("mvwaddchnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddchnstr(win, ch, n); |
} |
#ifdef PDC_WIDE |
int wadd_wchnstr(WINDOW *win, const cchar_t *wch, int n) |
{ |
PDC_LOG(("wadd_wchnstr() - called: win=%p n=%d\n", win, n)); |
return waddchnstr(win, wch, n); |
} |
int add_wchstr(const cchar_t *wch) |
{ |
PDC_LOG(("add_wchstr() - called\n")); |
return wadd_wchnstr(stdscr, wch, -1); |
} |
int add_wchnstr(const cchar_t *wch, int n) |
{ |
PDC_LOG(("add_wchnstr() - called\n")); |
return wadd_wchnstr(stdscr, wch, n); |
} |
int wadd_wchstr(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wadd_wchstr() - called: win=%p\n", win)); |
return wadd_wchnstr(win, wch, -1); |
} |
int mvadd_wchstr(int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvadd_wchstr() - called: y %d x %d\n", y, x)); |
if (move(y, x) == ERR) |
return ERR; |
return wadd_wchnstr(stdscr, wch, -1); |
} |
int mvadd_wchnstr(int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvadd_wchnstr() - called: y %d x %d n %d\n", y, x, n)); |
if (move(y, x) == ERR) |
return ERR; |
return wadd_wchnstr(stdscr, wch, n); |
} |
int mvwadd_wchstr(WINDOW *win, int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvwadd_wchstr() - called:\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wadd_wchnstr(win, wch, -1); |
} |
int mvwadd_wchnstr(WINDOW *win, int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvwadd_wchnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wadd_wchnstr(win, wch, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/addstr.c |
---|
0,0 → 1,239 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
addstr |
------ |
### Synopsis |
int addstr(const char *str); |
int addnstr(const char *str, int n); |
int waddstr(WINDOW *win, const char *str); |
int waddnstr(WINDOW *win, const char *str, int n); |
int mvaddstr(int y, int x, const char *str); |
int mvaddnstr(int y, int x, const char *str, int n); |
int mvwaddstr(WINDOW *win, int y, int x, const char *str); |
int mvwaddnstr(WINDOW *win, int y, int x, const char *str, int n); |
int addwstr(const wchar_t *wstr); |
int addnwstr(const wchar_t *wstr, int n); |
int waddwstr(WINDOW *win, const wchar_t *wstr); |
int waddnwstr(WINDOW *win, const wchar_t *wstr, int n); |
int mvaddwstr(int y, int x, const wchar_t *wstr); |
int mvaddnwstr(int y, int x, const wchar_t *wstr, int n); |
int mvwaddwstr(WINDOW *win, int y, int x, const wchar_t *wstr); |
int mvwaddnwstr(WINDOW *win, int y, int x, const wchar_t *wstr, int n); |
### Description |
These routines write all the characters of the null-terminated string |
str or wide-character string wstr to the given window. The |
functionality is similar to calling waddch() once for each character |
in the string; except that, when PDCurses is built with wide- |
character support enabled, the narrow-character functions treat the |
string as a multibyte string in the current locale, and convert it. |
The routines with n as the last argument write at most n characters; |
if n is negative, then the entire string will be added. |
### Return Value |
All functions return OK or ERR. |
### Portability |
X/Open ncurses NetBSD |
addstr Y Y Y |
waddstr Y Y Y |
mvaddstr Y Y Y |
mvwaddstr Y Y Y |
addnstr Y Y Y |
waddnstr Y Y Y |
mvaddnstr Y Y Y |
mvwaddnstr Y Y Y |
addwstr Y Y Y |
waddwstr Y Y Y |
mvaddwstr Y Y Y |
mvwaddwstr Y Y Y |
addnwstr Y Y Y |
waddnwstr Y Y Y |
mvaddnwstr Y Y Y |
mvwaddnwstr Y Y Y |
**man-end****************************************************************/ |
int waddnstr(WINDOW *win, const char *str, int n) |
{ |
int i = 0; |
PDC_LOG(("waddnstr() - called: string=\"%s\" n %d \n", str, n)); |
if (!win || !str) |
return ERR; |
while (str[i] && (i < n || n < 0)) |
{ |
#ifdef PDC_WIDE |
wchar_t wch; |
int retval = PDC_mbtowc(&wch, str + i, n >= 0 ? n - i : 6); |
if (retval <= 0) |
return OK; |
i += retval; |
#else |
chtype wch = (unsigned char)(str[i++]); |
#endif |
if (waddch(win, wch) == ERR) |
return ERR; |
} |
return OK; |
} |
int addstr(const char *str) |
{ |
PDC_LOG(("addstr() - called: string=\"%s\"\n", str)); |
return waddnstr(stdscr, str, -1); |
} |
int addnstr(const char *str, int n) |
{ |
PDC_LOG(("addnstr() - called: string=\"%s\" n %d \n", str, n)); |
return waddnstr(stdscr, str, n); |
} |
int waddstr(WINDOW *win, const char *str) |
{ |
PDC_LOG(("waddstr() - called: string=\"%s\"\n", str)); |
return waddnstr(win, str, -1); |
} |
int mvaddstr(int y, int x, const char *str) |
{ |
PDC_LOG(("mvaddstr() - called: y %d x %d string=\"%s\"\n", y, x, str)); |
if (move(y, x) == ERR) |
return ERR; |
return waddnstr(stdscr, str, -1); |
} |
int mvaddnstr(int y, int x, const char *str, int n) |
{ |
PDC_LOG(("mvaddnstr() - called: y %d x %d string=\"%s\" n %d \n", |
y, x, str, n)); |
if (move(y, x) == ERR) |
return ERR; |
return waddnstr(stdscr, str, n); |
} |
int mvwaddstr(WINDOW *win, int y, int x, const char *str) |
{ |
PDC_LOG(("mvwaddstr() - called: string=\"%s\"\n", str)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddnstr(win, str, -1); |
} |
int mvwaddnstr(WINDOW *win, int y, int x, const char *str, int n) |
{ |
PDC_LOG(("mvwaddnstr() - called: y %d x %d string=\"%s\" n %d \n", |
y, x, str, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddnstr(win, str, n); |
} |
#ifdef PDC_WIDE |
int waddnwstr(WINDOW *win, const wchar_t *wstr, int n) |
{ |
int i = 0; |
PDC_LOG(("waddnwstr() - called\n")); |
if (!win || !wstr) |
return ERR; |
while (wstr[i] && (i < n || n < 0)) |
{ |
chtype wch = wstr[i++]; |
if (waddch(win, wch) == ERR) |
return ERR; |
} |
return OK; |
} |
int addwstr(const wchar_t *wstr) |
{ |
PDC_LOG(("addwstr() - called\n")); |
return waddnwstr(stdscr, wstr, -1); |
} |
int addnwstr(const wchar_t *wstr, int n) |
{ |
PDC_LOG(("addnwstr() - called\n")); |
return waddnwstr(stdscr, wstr, n); |
} |
int waddwstr(WINDOW *win, const wchar_t *wstr) |
{ |
PDC_LOG(("waddwstr() - called\n")); |
return waddnwstr(win, wstr, -1); |
} |
int mvaddwstr(int y, int x, const wchar_t *wstr) |
{ |
PDC_LOG(("mvaddstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return waddnwstr(stdscr, wstr, -1); |
} |
int mvaddnwstr(int y, int x, const wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvaddnstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return waddnwstr(stdscr, wstr, n); |
} |
int mvwaddwstr(WINDOW *win, int y, int x, const wchar_t *wstr) |
{ |
PDC_LOG(("mvwaddstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddnwstr(win, wstr, -1); |
} |
int mvwaddnwstr(WINDOW *win, int y, int x, const wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvwaddnstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return waddnwstr(win, wstr, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/attr.c |
---|
0,0 → 1,409 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
attr |
---- |
### Synopsis |
int attroff(chtype attrs); |
int wattroff(WINDOW *win, chtype attrs); |
int attron(chtype attrs); |
int wattron(WINDOW *win, chtype attrs); |
int attrset(chtype attrs); |
int wattrset(WINDOW *win, chtype attrs); |
int standend(void); |
int wstandend(WINDOW *win); |
int standout(void); |
int wstandout(WINDOW *win); |
int color_set(short color_pair, void *opts); |
int wcolor_set(WINDOW *win, short color_pair, void *opts); |
int attr_get(attr_t *attrs, short *color_pair, void *opts); |
int attr_off(attr_t attrs, void *opts); |
int attr_on(attr_t attrs, void *opts); |
int attr_set(attr_t attrs, short color_pair, void *opts); |
int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair, |
void *opts); |
int wattr_off(WINDOW *win, attr_t attrs, void *opts); |
int wattr_on(WINDOW *win, attr_t attrs, void *opts); |
int wattr_set(WINDOW *win, attr_t attrs, short color_pair, |
void *opts); |
int chgat(int n, attr_t attr, short color, const void *opts); |
int mvchgat(int y, int x, int n, attr_t attr, short color, |
const void *opts); |
int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr, |
short color, const void *opts); |
int wchgat(WINDOW *win, int n, attr_t attr, short color, |
const void *opts); |
chtype getattrs(WINDOW *win); |
int underend(void); |
int wunderend(WINDOW *win); |
int underscore(void); |
int wunderscore(WINDOW *win); |
### Description |
These functions manipulate the current attributes and/or colors of |
the named window. These attributes can be any combination of |
A_STANDOUT, A_REVERSE, A_BOLD, A_DIM, A_BLINK, A_UNDERLINE. These |
constants are defined in <curses.h> and can be combined with the |
bitwise-OR operator (|). |
The current attributes of a window are applied to all chtypes that |
are written into the window with waddch(). Attributes are a property |
of the chtype, and move with the character through any scrolling or |
insert/delete operations. |
wattrset() sets the current attributes of the given window to attrs. |
attrset() is the stdscr version. |
wattroff() turns off the named attributes without affecting any other |
attributes; wattron() turns them on. |
wcolor_set() sets the window color to the value of color_pair. opts |
is unused. |
standout() is the same as attron(A_STANDOUT). standend() is the same |
as attrset(A_NORMAL); that is, it turns off all attributes. |
The attr_* and wattr_* functions are intended for use with the WA_* |
attributes. In PDCurses, these are the same as A_*, and there is no |
difference in bevahior from the chtype-based functions. In all cases, |
opts is unused. |
wattr_get() retrieves the attributes and color pair for the specified |
window. |
wchgat() sets the color pair and attributes for the next n cells on |
the current line of a given window, without changing the existing |
text, or alterting the window's attributes. An n of -1 extends the |
change to the edge of the window. The changes take effect |
immediately. opts is unused. |
wunderscore() turns on the A_UNDERLINE attribute; wunderend() turns |
it off. underscore() and underend() are the stdscr versions. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
attroff Y Y Y |
wattroff Y Y Y |
attron Y Y Y |
wattron Y Y Y |
attrset Y Y Y |
wattrset Y Y Y |
standend Y Y Y |
wstandend Y Y Y |
standout Y Y Y |
wstandout Y Y Y |
color_set Y Y Y |
wcolor_set Y Y Y |
attr_get Y Y Y |
wattr_get Y Y Y |
attr_on Y Y Y |
wattr_on Y Y Y |
attr_off Y Y Y |
wattr_off Y Y Y |
attr_set Y Y Y |
wattr_set Y Y Y |
chgat Y Y Y |
wchgat Y Y Y |
mvchgat Y Y Y |
mvwchgat Y Y Y |
getattrs - Y Y |
underend - - Y |
wunderend - - Y |
underscore - - Y |
wunderscore - - Y |
**man-end****************************************************************/ |
int wattroff(WINDOW *win, chtype attrs) |
{ |
PDC_LOG(("wattroff() - called\n")); |
if (!win) |
return ERR; |
win->_attrs &= (~attrs & A_ATTRIBUTES); |
return OK; |
} |
int attroff(chtype attrs) |
{ |
PDC_LOG(("attroff() - called\n")); |
return wattroff(stdscr, attrs); |
} |
int wattron(WINDOW *win, chtype attrs) |
{ |
chtype newcolr, oldcolr, newattr, oldattr; |
PDC_LOG(("wattron() - called\n")); |
if (!win) |
return ERR; |
if ((win->_attrs & A_COLOR) && (attrs & A_COLOR)) |
{ |
oldcolr = win->_attrs & A_COLOR; |
oldattr = win->_attrs ^ oldcolr; |
newcolr = attrs & A_COLOR; |
newattr = (attrs & A_ATTRIBUTES) ^ newcolr; |
newattr |= oldattr; |
win->_attrs = newattr | newcolr; |
} |
else |
win->_attrs |= (attrs & A_ATTRIBUTES); |
return OK; |
} |
int attron(chtype attrs) |
{ |
PDC_LOG(("attron() - called\n")); |
return wattron(stdscr, attrs); |
} |
int wattrset(WINDOW *win, chtype attrs) |
{ |
PDC_LOG(("wattrset() - called\n")); |
if (!win) |
return ERR; |
win->_attrs = attrs & A_ATTRIBUTES; |
return OK; |
} |
int attrset(chtype attrs) |
{ |
PDC_LOG(("attrset() - called\n")); |
return wattrset(stdscr, attrs); |
} |
int standend(void) |
{ |
PDC_LOG(("standend() - called\n")); |
return wattrset(stdscr, A_NORMAL); |
} |
int standout(void) |
{ |
PDC_LOG(("standout() - called\n")); |
return wattrset(stdscr, A_STANDOUT); |
} |
int wstandend(WINDOW *win) |
{ |
PDC_LOG(("wstandend() - called\n")); |
return wattrset(win, A_NORMAL); |
} |
int wstandout(WINDOW *win) |
{ |
PDC_LOG(("wstandout() - called\n")); |
return wattrset(win, A_STANDOUT); |
} |
chtype getattrs(WINDOW *win) |
{ |
return win ? win->_attrs : 0; |
} |
int wcolor_set(WINDOW *win, short color_pair, void *opts) |
{ |
PDC_LOG(("wcolor_set() - called\n")); |
if (!win) |
return ERR; |
win->_attrs = (win->_attrs & ~A_COLOR) | COLOR_PAIR(color_pair); |
return OK; |
} |
int color_set(short color_pair, void *opts) |
{ |
PDC_LOG(("color_set() - called\n")); |
return wcolor_set(stdscr, color_pair, opts); |
} |
int wattr_get(WINDOW *win, attr_t *attrs, short *color_pair, void *opts) |
{ |
PDC_LOG(("wattr_get() - called\n")); |
if (!win) |
return ERR; |
if (attrs) |
*attrs = win->_attrs & (A_ATTRIBUTES & ~A_COLOR); |
if (color_pair) |
*color_pair = PAIR_NUMBER(win->_attrs); |
return OK; |
} |
int attr_get(attr_t *attrs, short *color_pair, void *opts) |
{ |
PDC_LOG(("attr_get() - called\n")); |
return wattr_get(stdscr, attrs, color_pair, opts); |
} |
int wattr_off(WINDOW *win, attr_t attrs, void *opts) |
{ |
PDC_LOG(("wattr_off() - called\n")); |
return wattroff(win, attrs); |
} |
int attr_off(attr_t attrs, void *opts) |
{ |
PDC_LOG(("attr_off() - called\n")); |
return wattroff(stdscr, attrs); |
} |
int wattr_on(WINDOW *win, attr_t attrs, void *opts) |
{ |
PDC_LOG(("wattr_off() - called\n")); |
return wattron(win, attrs); |
} |
int attr_on(attr_t attrs, void *opts) |
{ |
PDC_LOG(("attr_on() - called\n")); |
return wattron(stdscr, attrs); |
} |
int wattr_set(WINDOW *win, attr_t attrs, short color_pair, void *opts) |
{ |
PDC_LOG(("wattr_set() - called\n")); |
if (!win) |
return ERR; |
win->_attrs = (attrs & (A_ATTRIBUTES & ~A_COLOR)) | COLOR_PAIR(color_pair); |
return OK; |
} |
int attr_set(attr_t attrs, short color_pair, void *opts) |
{ |
PDC_LOG(("attr_get() - called\n")); |
return wattr_set(stdscr, attrs, color_pair, opts); |
} |
int wchgat(WINDOW *win, int n, attr_t attr, short color, const void *opts) |
{ |
chtype *dest, newattr; |
int startpos, endpos; |
PDC_LOG(("wchgat() - called\n")); |
if (!win) |
return ERR; |
newattr = (attr & A_ATTRIBUTES) | COLOR_PAIR(color); |
startpos = win->_curx; |
endpos = ((n < 0) ? win->_maxx : min(startpos + n, win->_maxx)) - 1; |
dest = win->_y[win->_cury]; |
for (n = startpos; n <= endpos; n++) |
dest[n] = (dest[n] & A_CHARTEXT) | newattr; |
n = win->_cury; |
if (startpos < win->_firstch[n] || win->_firstch[n] == _NO_CHANGE) |
win->_firstch[n] = startpos; |
if (endpos > win->_lastch[n]) |
win->_lastch[n] = endpos; |
PDC_sync(win); |
return OK; |
} |
int chgat(int n, attr_t attr, short color, const void *opts) |
{ |
PDC_LOG(("chgat() - called\n")); |
return wchgat(stdscr, n, attr, color, opts); |
} |
int mvchgat(int y, int x, int n, attr_t attr, short color, const void *opts) |
{ |
PDC_LOG(("mvchgat() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wchgat(stdscr, n, attr, color, opts); |
} |
int mvwchgat(WINDOW *win, int y, int x, int n, attr_t attr, short color, |
const void *opts) |
{ |
PDC_LOG(("mvwchgat() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wchgat(win, n, attr, color, opts); |
} |
int underend(void) |
{ |
PDC_LOG(("underend() - called\n")); |
return wattroff(stdscr, A_UNDERLINE); |
} |
int wunderend(WINDOW *win) |
{ |
PDC_LOG(("wunderend() - called\n")); |
return wattroff(win, A_UNDERLINE); |
} |
int underscore(void) |
{ |
PDC_LOG(("underscore() - called\n")); |
return wattron(stdscr, A_UNDERLINE); |
} |
int wunderscore(WINDOW *win) |
{ |
PDC_LOG(("wunderscore() - called\n")); |
return wattron(win, A_UNDERLINE); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/beep.c |
---|
0,0 → 1,74 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
beep |
---- |
### Synopsis |
int beep(void); |
int flash(void); |
### Description |
beep() sounds the audible bell on the terminal, if possible; if not, |
it calls flash(). |
flash() "flashes" the screen, by inverting the foreground and |
background of every cell, pausing, and then restoring the original |
attributes. |
### Return Value |
These functions return ERR if called before initscr(), otherwise OK. |
### Portability |
X/Open ncurses NetBSD |
beep Y Y Y |
flash Y Y Y |
**man-end****************************************************************/ |
int beep(void) |
{ |
PDC_LOG(("beep() - called\n")); |
if (!SP) |
return ERR; |
if (SP->audible) |
PDC_beep(); |
else |
flash(); |
return OK; |
} |
int flash(void) |
{ |
int z, y, x; |
PDC_LOG(("flash() - called\n")); |
if (!curscr) |
return ERR; |
/* Reverse each cell; wait; restore the screen */ |
for (z = 0; z < 2; z++) |
{ |
for (y = 0; y < LINES; y++) |
for (x = 0; x < COLS; x++) |
curscr->_y[y][x] ^= A_REVERSE; |
wrefresh(curscr); |
if (!z) |
napms(50); |
} |
return OK; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/bkgd.c |
---|
0,0 → 1,226 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
bkgd |
---- |
### Synopsis |
int bkgd(chtype ch); |
void bkgdset(chtype ch); |
chtype getbkgd(WINDOW *win); |
int wbkgd(WINDOW *win, chtype ch); |
void wbkgdset(WINDOW *win, chtype ch); |
int bkgrnd(const cchar_t *wch); |
void bkgrndset(const cchar_t *wch); |
int getbkgrnd(cchar_t *wch); |
int wbkgrnd(WINDOW *win, const cchar_t *wch); |
void wbkgrndset(WINDOW *win, const cchar_t *wch); |
int wgetbkgrnd(WINDOW *win, cchar_t *wch); |
### Description |
bkgdset() and wbkgdset() manipulate the background of a window. The |
background is a chtype consisting of any combination of attributes |
and a character; it is combined with each chtype added or inserted to |
the window by waddch() or winsch(). Only the attribute part is used |
to set the background of non-blank characters, while both character |
and attributes are used for blank positions. |
bkgd() and wbkgd() not only change the background, but apply it |
immediately to every cell in the window. |
wbkgrnd(), wbkgrndset() and wgetbkgrnd() are the "wide-character" |
versions of these functions, taking a pointer to a cchar_t instead of |
a chtype. However, in PDCurses, cchar_t and chtype are the same. |
The attributes that are defined with the attrset()/attron() set of |
functions take precedence over the background attributes if there is |
a conflict (e.g., different color pairs). |
### Return Value |
bkgd() and wbkgd() return OK, unless the window is NULL, in which |
case they return ERR. |
### Portability |
X/Open ncurses NetBSD |
bkgd Y Y Y |
bkgdset Y Y Y |
getbkgd Y Y Y |
wbkgd Y Y Y |
wbkgdset Y Y Y |
bkgrnd Y Y Y |
bkgrndset Y Y Y |
getbkgrnd Y Y Y |
wbkgrnd Y Y Y |
wbkgrndset Y Y Y |
wgetbkgrnd Y Y Y |
**man-end****************************************************************/ |
int wbkgd(WINDOW *win, chtype ch) |
{ |
int x, y; |
chtype oldcolr, oldch, newcolr, newch, colr, attr; |
chtype oldattr = 0, newattr = 0; |
chtype *winptr; |
PDC_LOG(("wbkgd() - called\n")); |
if (!win) |
return ERR; |
if (win->_bkgd == ch) |
return OK; |
oldcolr = win->_bkgd & A_COLOR; |
if (oldcolr) |
oldattr = (win->_bkgd & A_ATTRIBUTES) ^ oldcolr; |
oldch = win->_bkgd & A_CHARTEXT; |
wbkgdset(win, ch); |
newcolr = win->_bkgd & A_COLOR; |
if (newcolr) |
newattr = (win->_bkgd & A_ATTRIBUTES) ^ newcolr; |
newch = win->_bkgd & A_CHARTEXT; |
/* what follows is what seems to occur in the System V |
implementation of this routine */ |
for (y = 0; y < win->_maxy; y++) |
{ |
for (x = 0; x < win->_maxx; x++) |
{ |
winptr = win->_y[y] + x; |
ch = *winptr; |
/* determine the colors and attributes of the character read |
from the window */ |
colr = ch & A_COLOR; |
attr = ch & (A_ATTRIBUTES ^ A_COLOR); |
/* if the color is the same as the old background color, |
then make it the new background color, otherwise leave it */ |
if (colr == oldcolr) |
colr = newcolr; |
/* remove any attributes (non color) from the character that |
were part of the old background, then combine the |
remaining ones with the new background */ |
attr ^= oldattr; |
attr |= newattr; |
/* change character if it is there because it was the old |
background character */ |
ch &= A_CHARTEXT; |
if (ch == oldch) |
ch = newch; |
ch |= (attr | colr); |
*winptr = ch; |
} |
} |
touchwin(win); |
PDC_sync(win); |
return OK; |
} |
int bkgd(chtype ch) |
{ |
PDC_LOG(("bkgd() - called\n")); |
return wbkgd(stdscr, ch); |
} |
void wbkgdset(WINDOW *win, chtype ch) |
{ |
PDC_LOG(("wbkgdset() - called\n")); |
if (win) |
{ |
if (!(ch & A_CHARTEXT)) |
ch |= ' '; |
win->_bkgd = ch; |
} |
} |
void bkgdset(chtype ch) |
{ |
PDC_LOG(("bkgdset() - called\n")); |
wbkgdset(stdscr, ch); |
} |
chtype getbkgd(WINDOW *win) |
{ |
PDC_LOG(("getbkgd() - called\n")); |
return win ? win->_bkgd : (chtype)ERR; |
} |
#ifdef PDC_WIDE |
int wbkgrnd(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wbkgrnd() - called\n")); |
return wch ? wbkgd(win, *wch) : ERR; |
} |
int bkgrnd(const cchar_t *wch) |
{ |
PDC_LOG(("bkgrnd() - called\n")); |
return wbkgrnd(stdscr, wch); |
} |
void wbkgrndset(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wbkgdset() - called\n")); |
if (wch) |
wbkgdset(win, *wch); |
} |
void bkgrndset(const cchar_t *wch) |
{ |
PDC_LOG(("bkgrndset() - called\n")); |
wbkgrndset(stdscr, wch); |
} |
int wgetbkgrnd(WINDOW *win, cchar_t *wch) |
{ |
PDC_LOG(("wgetbkgrnd() - called\n")); |
if (!win || !wch) |
return ERR; |
*wch = win->_bkgd; |
return OK; |
} |
int getbkgrnd(cchar_t *wch) |
{ |
PDC_LOG(("getbkgrnd() - called\n")); |
return wgetbkgrnd(stdscr, wch); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/border.c |
---|
0,0 → 1,414 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
border |
------ |
### Synopsis |
int border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, |
chtype tr, chtype bl, chtype br); |
int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, |
chtype bs, chtype tl, chtype tr, chtype bl, chtype br); |
int box(WINDOW *win, chtype verch, chtype horch); |
int hline(chtype ch, int n); |
int vline(chtype ch, int n); |
int whline(WINDOW *win, chtype ch, int n); |
int wvline(WINDOW *win, chtype ch, int n); |
int mvhline(int y, int x, chtype ch, int n); |
int mvvline(int y, int x, chtype ch, int n); |
int mvwhline(WINDOW *win, int y, int x, chtype ch, int n); |
int mvwvline(WINDOW *win, int y, int x, chtype ch, int n); |
int border_set(const cchar_t *ls, const cchar_t *rs, |
const cchar_t *ts, const cchar_t *bs, |
const cchar_t *tl, const cchar_t *tr, |
const cchar_t *bl, const cchar_t *br); |
int wborder_set(WINDOW *win, const cchar_t *ls, const cchar_t *rs, |
const cchar_t *ts, const cchar_t *bs, |
const cchar_t *tl, const cchar_t *tr, |
const cchar_t *bl, const cchar_t *br); |
int box_set(WINDOW *win, const cchar_t *verch, const cchar_t *horch); |
int hline_set(const cchar_t *wch, int n); |
int vline_set(const cchar_t *wch, int n); |
int whline_set(WINDOW *win, const cchar_t *wch, int n); |
int wvline_set(WINDOW *win, const cchar_t *wch, int n); |
int mvhline_set(int y, int x, const cchar_t *wch, int n); |
int mvvline_set(int y, int x, const cchar_t *wch, int n); |
int mvwhline_set(WINDOW *win, int y, int x, const cchar_t *wch, int n); |
int mvwvline_set(WINDOW *win, int y, int x, const cchar_t *wch, int n); |
### Description |
border(), wborder(), and box() draw a border around the edge of the |
window. If any argument is zero, an appropriate default is used: |
ls left side of border ACS_VLINE |
rs right side of border ACS_VLINE |
ts top side of border ACS_HLINE |
bs bottom side of border ACS_HLINE |
tl top left corner of border ACS_ULCORNER |
tr top right corner of border ACS_URCORNER |
bl bottom left corner of border ACS_LLCORNER |
br bottom right corner of border ACS_LRCORNER |
hline() and whline() draw a horizontal line, using ch, starting from |
the current cursor position. The cursor position does not change. The |
line is at most n characters long, or as many as will fit in the |
window. |
vline() and wvline() draw a vertical line, using ch, starting from |
the current cursor position. The cursor position does not change. The |
line is at most n characters long, or as many as will fit in the |
window. |
The *_set functions are the "wide-character" versions, taking |
pointers to cchar_t instead of chtype. Note that in PDCurses, chtype |
and cchar_t are the same. |
### Return Value |
These functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
border Y Y Y |
wborder Y Y Y |
box Y Y Y |
hline Y Y Y |
vline Y Y Y |
whline Y Y Y |
wvline Y Y Y |
mvhline Y Y Y |
mvvline Y Y Y |
mvwhline Y Y Y |
mvwvline Y Y Y |
border_set Y Y Y |
wborder_set Y Y Y |
box_set Y Y Y |
hline_set Y Y Y |
vline_set Y Y Y |
whline_set Y Y Y |
wvline_set Y Y Y |
mvhline_set Y Y Y |
mvvline_set Y Y Y |
mvwhline_set Y Y Y |
mvwvline_set Y Y Y |
**man-end****************************************************************/ |
/* _attr_passthru() -- Takes a single chtype 'ch' and checks if the |
current attribute of window 'win', as set by wattrset(), and/or the |
current background of win, as set by wbkgd(), should by combined with |
it. Attributes set explicitly in ch take precedence. */ |
static chtype _attr_passthru(WINDOW *win, chtype ch) |
{ |
chtype attr; |
/* If the incoming character doesn't have its own attribute, then |
use the current attributes for the window. If the incoming |
character has attributes, but not a color component, OR the |
attributes to the current attributes for the window. If the |
incoming character has a color component, use only the attributes |
from the incoming character. */ |
attr = ch & A_ATTRIBUTES; |
if (!(attr & A_COLOR)) |
attr |= win->_attrs; |
/* wrs (4/10/93) -- Apply the same sort of logic for the window |
background, in that it only takes precedence if other color |
attributes are not there. */ |
if (!(attr & A_COLOR)) |
attr |= win->_bkgd & A_ATTRIBUTES; |
else |
attr |= win->_bkgd & (A_ATTRIBUTES ^ A_COLOR); |
ch = (ch & A_CHARTEXT) | attr; |
return ch; |
} |
int wborder(WINDOW *win, chtype ls, chtype rs, chtype ts, chtype bs, |
chtype tl, chtype tr, chtype bl, chtype br) |
{ |
int i, ymax, xmax; |
PDC_LOG(("wborder() - called\n")); |
if (!win) |
return ERR; |
ymax = win->_maxy - 1; |
xmax = win->_maxx - 1; |
ls = _attr_passthru(win, ls ? ls : ACS_VLINE); |
rs = _attr_passthru(win, rs ? rs : ACS_VLINE); |
ts = _attr_passthru(win, ts ? ts : ACS_HLINE); |
bs = _attr_passthru(win, bs ? bs : ACS_HLINE); |
tl = _attr_passthru(win, tl ? tl : ACS_ULCORNER); |
tr = _attr_passthru(win, tr ? tr : ACS_URCORNER); |
bl = _attr_passthru(win, bl ? bl : ACS_LLCORNER); |
br = _attr_passthru(win, br ? br : ACS_LRCORNER); |
for (i = 1; i < xmax; i++) |
{ |
win->_y[0][i] = ts; |
win->_y[ymax][i] = bs; |
} |
for (i = 1; i < ymax; i++) |
{ |
win->_y[i][0] = ls; |
win->_y[i][xmax] = rs; |
} |
win->_y[0][0] = tl; |
win->_y[0][xmax] = tr; |
win->_y[ymax][0] = bl; |
win->_y[ymax][xmax] = br; |
for (i = 0; i <= ymax; i++) |
{ |
win->_firstch[i] = 0; |
win->_lastch[i] = xmax; |
} |
PDC_sync(win); |
return OK; |
} |
int border(chtype ls, chtype rs, chtype ts, chtype bs, chtype tl, |
chtype tr, chtype bl, chtype br) |
{ |
PDC_LOG(("border() - called\n")); |
return wborder(stdscr, ls, rs, ts, bs, tl, tr, bl, br); |
} |
int box(WINDOW *win, chtype verch, chtype horch) |
{ |
PDC_LOG(("box() - called\n")); |
return wborder(win, verch, verch, horch, horch, 0, 0, 0, 0); |
} |
int whline(WINDOW *win, chtype ch, int n) |
{ |
chtype *dest; |
int startpos, endpos; |
PDC_LOG(("whline() - called\n")); |
if (!win || n < 1) |
return ERR; |
startpos = win->_curx; |
endpos = min(startpos + n, win->_maxx) - 1; |
dest = win->_y[win->_cury]; |
ch = _attr_passthru(win, ch ? ch : ACS_HLINE); |
for (n = startpos; n <= endpos; n++) |
dest[n] = ch; |
n = win->_cury; |
if (startpos < win->_firstch[n] || win->_firstch[n] == _NO_CHANGE) |
win->_firstch[n] = startpos; |
if (endpos > win->_lastch[n]) |
win->_lastch[n] = endpos; |
PDC_sync(win); |
return OK; |
} |
int hline(chtype ch, int n) |
{ |
PDC_LOG(("hline() - called\n")); |
return whline(stdscr, ch, n); |
} |
int mvhline(int y, int x, chtype ch, int n) |
{ |
PDC_LOG(("mvhline() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return whline(stdscr, ch, n); |
} |
int mvwhline(WINDOW *win, int y, int x, chtype ch, int n) |
{ |
PDC_LOG(("mvwhline() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return whline(win, ch, n); |
} |
int wvline(WINDOW *win, chtype ch, int n) |
{ |
int endpos, x; |
PDC_LOG(("wvline() - called\n")); |
if (!win || n < 1) |
return ERR; |
endpos = min(win->_cury + n, win->_maxy); |
x = win->_curx; |
ch = _attr_passthru(win, ch ? ch : ACS_VLINE); |
for (n = win->_cury; n < endpos; n++) |
{ |
win->_y[n][x] = ch; |
if (x < win->_firstch[n] || win->_firstch[n] == _NO_CHANGE) |
win->_firstch[n] = x; |
if (x > win->_lastch[n]) |
win->_lastch[n] = x; |
} |
PDC_sync(win); |
return OK; |
} |
int vline(chtype ch, int n) |
{ |
PDC_LOG(("vline() - called\n")); |
return wvline(stdscr, ch, n); |
} |
int mvvline(int y, int x, chtype ch, int n) |
{ |
PDC_LOG(("mvvline() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wvline(stdscr, ch, n); |
} |
int mvwvline(WINDOW *win, int y, int x, chtype ch, int n) |
{ |
PDC_LOG(("mvwvline() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wvline(win, ch, n); |
} |
#ifdef PDC_WIDE |
int wborder_set(WINDOW *win, const cchar_t *ls, const cchar_t *rs, |
const cchar_t *ts, const cchar_t *bs, const cchar_t *tl, |
const cchar_t *tr, const cchar_t *bl, const cchar_t *br) |
{ |
PDC_LOG(("wborder_set() - called\n")); |
return wborder(win, ls ? *ls : 0, rs ? *rs : 0, ts ? *ts : 0, |
bs ? *bs : 0, tl ? *tl : 0, tr ? *tr : 0, |
bl ? *bl : 0, br ? *br : 0); |
} |
int border_set(const cchar_t *ls, const cchar_t *rs, const cchar_t *ts, |
const cchar_t *bs, const cchar_t *tl, const cchar_t *tr, |
const cchar_t *bl, const cchar_t *br) |
{ |
PDC_LOG(("border_set() - called\n")); |
return wborder_set(stdscr, ls, rs, ts, bs, tl, tr, bl, br); |
} |
int box_set(WINDOW *win, const cchar_t *verch, const cchar_t *horch) |
{ |
PDC_LOG(("box_set() - called\n")); |
return wborder_set(win, verch, verch, horch, horch, |
(const cchar_t *)NULL, (const cchar_t *)NULL, |
(const cchar_t *)NULL, (const cchar_t *)NULL); |
} |
int whline_set(WINDOW *win, const cchar_t *wch, int n) |
{ |
PDC_LOG(("whline_set() - called\n")); |
return wch ? whline(win, *wch, n) : ERR; |
} |
int hline_set(const cchar_t *wch, int n) |
{ |
PDC_LOG(("hline_set() - called\n")); |
return whline_set(stdscr, wch, n); |
} |
int mvhline_set(int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvhline_set() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return whline_set(stdscr, wch, n); |
} |
int mvwhline_set(WINDOW *win, int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvwhline_set() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return whline_set(win, wch, n); |
} |
int wvline_set(WINDOW *win, const cchar_t *wch, int n) |
{ |
PDC_LOG(("wvline_set() - called\n")); |
return wch ? wvline(win, *wch, n) : ERR; |
} |
int vline_set(const cchar_t *wch, int n) |
{ |
PDC_LOG(("vline_set() - called\n")); |
return wvline_set(stdscr, wch, n); |
} |
int mvvline_set(int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvvline_set() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wvline_set(stdscr, wch, n); |
} |
int mvwvline_set(WINDOW *win, int y, int x, const cchar_t *wch, int n) |
{ |
PDC_LOG(("mvwvline_set() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wvline_set(win, wch, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/clear.c |
---|
0,0 → 1,159 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
clear |
----- |
### Synopsis |
int clear(void); |
int wclear(WINDOW *win); |
int erase(void); |
int werase(WINDOW *win); |
int clrtobot(void); |
int wclrtobot(WINDOW *win); |
int clrtoeol(void); |
int wclrtoeol(WINDOW *win); |
### Description |
erase() and werase() copy blanks (i.e. the background chtype) to |
every cell of the window. |
clear() and wclear() are similar to erase() and werase(), but they |
also call clearok() to ensure that the the window is cleared on the |
next wrefresh(). |
clrtobot() and wclrtobot() clear the window from the current cursor |
position to the end of the window. |
clrtoeol() and wclrtoeol() clear the window from the current cursor |
position to the end of the current line. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
clear Y Y Y |
wclear Y Y Y |
erase Y Y Y |
werase Y Y Y |
clrtobot Y Y Y |
wclrtobot Y Y Y |
clrtoeol Y Y Y |
wclrtoeol Y Y Y |
**man-end****************************************************************/ |
int wclrtoeol(WINDOW *win) |
{ |
int x, y, minx; |
chtype blank, *ptr; |
PDC_LOG(("wclrtoeol() - called: Row: %d Col: %d\n", |
win->_cury, win->_curx)); |
if (!win) |
return ERR; |
y = win->_cury; |
x = win->_curx; |
/* wrs (4/10/93) account for window background */ |
blank = win->_bkgd; |
for (minx = x, ptr = &win->_y[y][x]; minx < win->_maxx; minx++, ptr++) |
*ptr = blank; |
if (x < win->_firstch[y] || win->_firstch[y] == _NO_CHANGE) |
win->_firstch[y] = x; |
win->_lastch[y] = win->_maxx - 1; |
PDC_sync(win); |
return OK; |
} |
int clrtoeol(void) |
{ |
PDC_LOG(("clrtoeol() - called\n")); |
return wclrtoeol(stdscr); |
} |
int wclrtobot(WINDOW *win) |
{ |
int savey, savex; |
PDC_LOG(("wclrtobot() - called\n")); |
if (!win) |
return ERR; |
savey = win->_cury; |
savex = win->_curx; |
/* should this involve scrolling region somehow ? */ |
if (win->_cury + 1 < win->_maxy) |
{ |
win->_curx = 0; |
win->_cury++; |
for (; win->_maxy > win->_cury; win->_cury++) |
wclrtoeol(win); |
win->_cury = savey; |
win->_curx = savex; |
} |
wclrtoeol(win); |
PDC_sync(win); |
return OK; |
} |
int clrtobot(void) |
{ |
PDC_LOG(("clrtobot() - called\n")); |
return wclrtobot(stdscr); |
} |
int werase(WINDOW *win) |
{ |
PDC_LOG(("werase() - called\n")); |
if (wmove(win, 0, 0) == ERR) |
return ERR; |
return wclrtobot(win); |
} |
int erase(void) |
{ |
PDC_LOG(("erase() - called\n")); |
return werase(stdscr); |
} |
int wclear(WINDOW *win) |
{ |
PDC_LOG(("wclear() - called\n")); |
if (!win) |
return ERR; |
win->_clear = TRUE; |
return werase(win); |
} |
int clear(void) |
{ |
PDC_LOG(("clear() - called\n")); |
return wclear(stdscr); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/color.c |
---|
0,0 → 1,362 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
color |
----- |
### Synopsis |
bool has_colors(void); |
int start_color(void); |
int init_pair(short pair, short fg, short bg); |
int pair_content(short pair, short *fg, short *bg); |
bool can_change_color(void); |
int init_color(short color, short red, short green, short blue); |
int color_content(short color, short *red, short *green, short *blue); |
int alloc_pair(int fg, int bg); |
int assume_default_colors(int f, int b); |
int find_pair(int fg, int bg); |
int free_pair(int pair); |
int use_default_colors(void); |
int PDC_set_line_color(short color); |
### Description |
To use these routines, first, call start_color(). Colors are always |
used in pairs, referred to as color-pairs. A color-pair is created by |
init_pair(), and consists of a foreground color and a background |
color. After initialization, COLOR_PAIR(n) can be used like any other |
video attribute. |
has_colors() reports whether the terminal supports color. |
start_color() initializes eight basic colors (black, red, green, |
yellow, blue, magenta, cyan, and white), and two global variables: |
COLORS and COLOR_PAIRS (respectively defining the maximum number of |
colors and color-pairs the terminal is capable of displaying). |
init_pair() changes the definition of a color-pair. It takes three |
arguments: the number of the color-pair to be redefined, and the new |
values of the foreground and background colors. The pair number must |
be between 0 and COLOR_PAIRS - 1, inclusive. The foreground and |
background must be between 0 and COLORS - 1, inclusive. If the color |
pair was previously initialized, the screen is refreshed, and all |
occurrences of that color-pair are changed to the new definition. |
pair_content() is used to determine what the colors of a given color- |
pair consist of. |
can_change_color() indicates if the terminal has the capability to |
change the definition of its colors. |
init_color() is used to redefine a color, if possible. Each of the |
components -- red, green, and blue -- is specified in a range from 0 |
to 1000, inclusive. |
color_content() reports the current definition of a color in the same |
format as used by init_color(). |
assume_default_colors() and use_default_colors() emulate the ncurses |
extensions of the same names. assume_default_colors(f, b) is |
essentially the same as init_pair(0, f, b) (which isn't allowed); it |
redefines the default colors. use_default_colors() allows the use of |
-1 as a foreground or background color with init_pair(), and calls |
assume_default_colors(-1, -1); -1 represents the foreground or |
background color that the terminal had at startup. If the environment |
variable PDC_ORIGINAL_COLORS is set at the time start_color() is |
called, that's equivalent to calling use_default_colors(). |
alloc_pair(), find_pair() and free_pair() are also from ncurses. |
free_pair() marks a pair as unused; find_pair() returns an existing |
pair with the specified foreground and background colors, if one |
exists. And alloc_pair() returns such a pair whether or not it was |
previously set, overwriting the oldest initialized pair if there are |
no free pairs. |
PDC_set_line_color() is used to set the color, globally, for the |
color of the lines drawn for the attributes: A_UNDERLINE, A_LEFT and |
A_RIGHT. A value of -1 (the default) indicates that the current |
foreground color should be used. |
NOTE: COLOR_PAIR() and PAIR_NUMBER() are implemented as macros. |
### Return Value |
Most functions return OK on success and ERR on error. has_colors() |
and can_change_colors() return TRUE or FALSE. alloc_pair() and |
find_pair() return a pair number, or -1 on error. |
### Portability |
X/Open ncurses NetBSD |
has_colors Y Y Y |
start_color Y Y Y |
init_pair Y Y Y |
pair_content Y Y Y |
can_change_color Y Y Y |
init_color Y Y Y |
color_content Y Y Y |
alloc_pair - Y - |
assume_default_colors - Y Y |
find_pair - Y - |
free_pair - Y - |
use_default_colors - Y Y |
PDC_set_line_color - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
#include <string.h> |
int COLORS = 0; |
int COLOR_PAIRS = PDC_COLOR_PAIRS; |
static bool default_colors = FALSE; |
static short first_col = 0; |
static int allocnum = 0; |
int start_color(void) |
{ |
PDC_LOG(("start_color() - called\n")); |
if (!SP || SP->mono) |
return ERR; |
SP->color_started = TRUE; |
PDC_set_blink(FALSE); /* Also sets COLORS */ |
if (!default_colors && SP->orig_attr && getenv("PDC_ORIGINAL_COLORS")) |
default_colors = TRUE; |
PDC_init_atrtab(); |
return OK; |
} |
static void _normalize(short *fg, short *bg) |
{ |
if (*fg == -1) |
*fg = SP->orig_attr ? SP->orig_fore : COLOR_WHITE; |
if (*bg == -1) |
*bg = SP->orig_attr ? SP->orig_back : COLOR_BLACK; |
} |
static void _init_pair_core(short pair, short fg, short bg) |
{ |
PDC_PAIR *p = SP->atrtab + pair; |
_normalize(&fg, &bg); |
/* To allow the PDC_PRESERVE_SCREEN option to work, we only reset |
curscr if this call to init_pair() alters a color pair created by |
the user. */ |
if (p->set) |
{ |
if (p->f != fg || p->b != bg) |
curscr->_clear = TRUE; |
} |
p->f = fg; |
p->b = bg; |
p->count = allocnum++; |
p->set = TRUE; |
} |
int init_pair(short pair, short fg, short bg) |
{ |
PDC_LOG(("init_pair() - called: pair %d fg %d bg %d\n", pair, fg, bg)); |
if (!SP || !SP->color_started || pair < 1 || pair >= COLOR_PAIRS || |
fg < first_col || fg >= COLORS || bg < first_col || bg >= COLORS) |
return ERR; |
_init_pair_core(pair, fg, bg); |
return OK; |
} |
bool has_colors(void) |
{ |
PDC_LOG(("has_colors() - called\n")); |
return SP ? !(SP->mono) : FALSE; |
} |
int init_color(short color, short red, short green, short blue) |
{ |
PDC_LOG(("init_color() - called\n")); |
if (!SP || color < 0 || color >= COLORS || !PDC_can_change_color() || |
red < -1 || red > 1000 || green < -1 || green > 1000 || |
blue < -1 || blue > 1000) |
return ERR; |
SP->dirty = TRUE; |
return PDC_init_color(color, red, green, blue); |
} |
int color_content(short color, short *red, short *green, short *blue) |
{ |
PDC_LOG(("color_content() - called\n")); |
if (color < 0 || color >= COLORS || !red || !green || !blue) |
return ERR; |
if (PDC_can_change_color()) |
return PDC_color_content(color, red, green, blue); |
else |
{ |
/* Simulated values for platforms that don't support palette |
changing */ |
short maxval = (color & 8) ? 1000 : 680; |
*red = (color & COLOR_RED) ? maxval : 0; |
*green = (color & COLOR_GREEN) ? maxval : 0; |
*blue = (color & COLOR_BLUE) ? maxval : 0; |
return OK; |
} |
} |
bool can_change_color(void) |
{ |
PDC_LOG(("can_change_color() - called\n")); |
return PDC_can_change_color(); |
} |
int pair_content(short pair, short *fg, short *bg) |
{ |
PDC_LOG(("pair_content() - called\n")); |
if (pair < 0 || pair >= COLOR_PAIRS || !fg || !bg) |
return ERR; |
*fg = SP->atrtab[pair].f; |
*bg = SP->atrtab[pair].b; |
return OK; |
} |
int assume_default_colors(int f, int b) |
{ |
PDC_LOG(("assume_default_colors() - called: f %d b %d\n", f, b)); |
if (f < -1 || f >= COLORS || b < -1 || b >= COLORS) |
return ERR; |
if (SP->color_started) |
_init_pair_core(0, f, b); |
return OK; |
} |
int use_default_colors(void) |
{ |
PDC_LOG(("use_default_colors() - called\n")); |
default_colors = TRUE; |
first_col = -1; |
return assume_default_colors(-1, -1); |
} |
int PDC_set_line_color(short color) |
{ |
PDC_LOG(("PDC_set_line_color() - called: %d\n", color)); |
if (!SP || color < -1 || color >= COLORS) |
return ERR; |
SP->line_color = color; |
return OK; |
} |
void PDC_init_atrtab(void) |
{ |
PDC_PAIR *p = SP->atrtab; |
short i, fg, bg; |
if (SP->color_started && !default_colors) |
{ |
fg = COLOR_WHITE; |
bg = COLOR_BLACK; |
} |
else |
fg = bg = -1; |
_normalize(&fg, &bg); |
for (i = 0; i < PDC_COLOR_PAIRS; i++) |
{ |
p[i].f = fg; |
p[i].b = bg; |
p[i].set = FALSE; |
} |
} |
int free_pair(int pair) |
{ |
if (pair < 1 || pair >= PDC_COLOR_PAIRS || !(SP->atrtab[pair].set)) |
return ERR; |
SP->atrtab[pair].set = FALSE; |
return OK; |
} |
int find_pair(int fg, int bg) |
{ |
int i; |
PDC_PAIR *p = SP->atrtab; |
for (i = 0; i < PDC_COLOR_PAIRS; i++) |
if (p[i].set && p[i].f == fg && p[i].b == bg) |
return i; |
return -1; |
} |
static int _find_oldest() |
{ |
int i, lowind = 0, lowval = 0; |
PDC_PAIR *p = SP->atrtab; |
for (i = 1; i < PDC_COLOR_PAIRS; i++) |
{ |
if (!p[i].set) |
return i; |
if (!lowval || (p[i].count < lowval)) |
{ |
lowind = i; |
lowval = p[i].count; |
} |
} |
return lowind; |
} |
int alloc_pair(int fg, int bg) |
{ |
int i = find_pair(fg, bg); |
if (-1 == i) |
{ |
i = _find_oldest(); |
if (ERR == init_pair(i, fg, bg)) |
return -1; |
} |
return i; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/debug.c |
---|
0,0 → 1,106 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
debug |
----- |
### Synopsis |
void traceon(void); |
void traceoff(void); |
void PDC_debug(const char *, ...); |
### Description |
traceon() and traceoff() toggle the recording of debugging |
information to the file "trace". Although not standard, similar |
functions are in some other curses implementations. |
PDC_debug() is the function that writes to the file, based on whether |
traceon() has been called. It's used from the PDC_LOG() macro. |
The environment variable PDC_TRACE_FLUSH controls whether the trace |
file contents are fflushed after each write. The default is not. Set |
it to enable this (may affect performance). |
### Portability |
X/Open ncurses NetBSD |
traceon - - - |
traceoff - - - |
PDC_debug - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
#include <string.h> |
#include <sys/types.h> |
#include <time.h> |
static bool want_fflush = FALSE; |
void PDC_debug(const char *fmt, ...) |
{ |
va_list args; |
char hms[9]; |
time_t now; |
if (!SP || !SP->dbfp) |
return; |
time(&now); |
strftime(hms, 9, "%H:%M:%S", localtime(&now)); |
fprintf(SP->dbfp, "At: %8.8ld - %s ", (long) clock(), hms); |
va_start(args, fmt); |
vfprintf(SP->dbfp, fmt, args); |
va_end(args); |
/* If you are crashing and losing debugging information, enable this |
by setting the environment variable PDC_TRACE_FLUSH. This may |
impact performance. */ |
if (want_fflush) |
fflush(SP->dbfp); |
/* If with PDC_TRACE_FLUSH enabled you are still losing logging in |
crashes, you may need to add a platform-dependent mechanism to |
flush the OS buffers as well (such as fsync() on POSIX) -- but |
expect terrible performance. */ |
} |
void traceon(void) |
{ |
if (!SP) |
return; |
if (SP->dbfp) |
fclose(SP->dbfp); |
/* open debug log file append */ |
SP->dbfp = fopen("trace", "a"); |
if (!SP->dbfp) |
{ |
fprintf(stderr, "PDC_debug(): Unable to open debug log file\n"); |
return; |
} |
if (getenv("PDC_TRACE_FLUSH")) |
want_fflush = TRUE; |
PDC_LOG(("traceon() - called\n")); |
} |
void traceoff(void) |
{ |
if (!SP || !SP->dbfp) |
return; |
PDC_LOG(("traceoff() - called\n")); |
fclose(SP->dbfp); |
SP->dbfp = NULL; |
want_fflush = FALSE; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/delch.c |
---|
0,0 → 1,96 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
delch |
----- |
### Synopsis |
int delch(void); |
int wdelch(WINDOW *win); |
int mvdelch(int y, int x); |
int mvwdelch(WINDOW *win, int y, int x); |
### Description |
The character under the cursor in the window is deleted. All |
characters to the right on the same line are moved to the left one |
position and the last character on the line is filled with a blank. |
The cursor position does not change (after moving to y, x if |
coordinates are specified). |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
delch Y Y Y |
wdelch Y Y Y |
mvdelch Y Y Y |
mvwdelch Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
int wdelch(WINDOW *win) |
{ |
int y, x, maxx; |
chtype *temp1; |
PDC_LOG(("wdelch() - called\n")); |
if (!win) |
return ERR; |
y = win->_cury; |
x = win->_curx; |
maxx = win->_maxx - 1; |
temp1 = &win->_y[y][x]; |
memmove(temp1, temp1 + 1, (maxx - x) * sizeof(chtype)); |
/* wrs (4/10/93) account for window background */ |
win->_y[y][maxx] = win->_bkgd; |
win->_lastch[y] = maxx; |
if ((win->_firstch[y] == _NO_CHANGE) || (win->_firstch[y] > x)) |
win->_firstch[y] = x; |
PDC_sync(win); |
return OK; |
} |
int delch(void) |
{ |
PDC_LOG(("delch() - called\n")); |
return wdelch(stdscr); |
} |
int mvdelch(int y, int x) |
{ |
PDC_LOG(("mvdelch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wdelch(stdscr); |
} |
int mvwdelch(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwdelch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wdelch(win); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/deleteln.c |
---|
0,0 → 1,211 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
deleteln |
-------- |
### Synopsis |
int deleteln(void); |
int wdeleteln(WINDOW *win); |
int insdelln(int n); |
int winsdelln(WINDOW *win, int n); |
int insertln(void); |
int winsertln(WINDOW *win); |
int mvdeleteln(int y, int x); |
int mvwdeleteln(WINDOW *win, int y, int x); |
int mvinsertln(int y, int x); |
int mvwinsertln(WINDOW *win, int y, int x); |
### Description |
With the deleteln() and wdeleteln() functions, the line under the |
cursor in the window is deleted. All lines below the current line are |
moved up one line. The bottom line of the window is cleared. The |
cursor position does not change. |
With the insertln() and winsertn() functions, a blank line is |
inserted above the current line and the bottom line is lost. |
mvdeleteln(), mvwdeleteln(), mvinsertln() and mvwinsertln() allow |
moving the cursor and inserting/deleting in one call. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
deleteln Y Y Y |
wdeleteln Y Y Y |
mvdeleteln - - - |
mvwdeleteln - - - |
insdelln Y Y Y |
winsdelln Y Y Y |
insertln Y Y Y |
winsertln Y Y Y |
mvinsertln - - - |
mvwinsertln - - - |
**man-end****************************************************************/ |
int wdeleteln(WINDOW *win) |
{ |
chtype blank, *temp, *ptr; |
int y; |
PDC_LOG(("wdeleteln() - called\n")); |
if (!win) |
return ERR; |
/* wrs (4/10/93) account for window background */ |
blank = win->_bkgd; |
temp = win->_y[win->_cury]; |
for (y = win->_cury; y < win->_bmarg; y++) |
{ |
win->_y[y] = win->_y[y + 1]; |
win->_firstch[y] = 0; |
win->_lastch[y] = win->_maxx - 1; |
} |
for (ptr = temp; (ptr - temp < win->_maxx); ptr++) |
*ptr = blank; /* make a blank line */ |
if (win->_cury <= win->_bmarg) |
{ |
win->_firstch[win->_bmarg] = 0; |
win->_lastch[win->_bmarg] = win->_maxx - 1; |
win->_y[win->_bmarg] = temp; |
} |
return OK; |
} |
int deleteln(void) |
{ |
PDC_LOG(("deleteln() - called\n")); |
return wdeleteln(stdscr); |
} |
int mvdeleteln(int y, int x) |
{ |
PDC_LOG(("mvdeleteln() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wdeleteln(stdscr); |
} |
int mvwdeleteln(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwdeleteln() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wdeleteln(win); |
} |
int winsdelln(WINDOW *win, int n) |
{ |
int i; |
PDC_LOG(("winsdelln() - called\n")); |
if (!win) |
return ERR; |
if (n > 0) |
{ |
for (i = 0; i < n; i++) |
if (winsertln(win) == ERR) |
return ERR; |
} |
else if (n < 0) |
{ |
n = -n; |
for (i = 0; i < n; i++) |
if (wdeleteln(win) == ERR) |
return ERR; |
} |
return OK; |
} |
int insdelln(int n) |
{ |
PDC_LOG(("insdelln() - called\n")); |
return winsdelln(stdscr, n); |
} |
int winsertln(WINDOW *win) |
{ |
chtype blank, *temp, *end; |
int y; |
PDC_LOG(("winsertln() - called\n")); |
if (!win) |
return ERR; |
/* wrs (4/10/93) account for window background */ |
blank = win->_bkgd; |
temp = win->_y[win->_maxy - 1]; |
for (y = win->_maxy - 1; y > win->_cury; y--) |
{ |
win->_y[y] = win->_y[y - 1]; |
win->_firstch[y] = 0; |
win->_lastch[y] = win->_maxx - 1; |
} |
win->_y[win->_cury] = temp; |
for (end = &temp[win->_maxx - 1]; temp <= end; temp++) |
*temp = blank; |
win->_firstch[win->_cury] = 0; |
win->_lastch[win->_cury] = win->_maxx - 1; |
return OK; |
} |
int insertln(void) |
{ |
PDC_LOG(("insertln() - called\n")); |
return winsertln(stdscr); |
} |
int mvinsertln(int y, int x) |
{ |
PDC_LOG(("mvinsertln() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return winsertln(stdscr); |
} |
int mvwinsertln(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwinsertln() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winsertln(win); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/getch.c |
---|
0,0 → 1,589 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
getch |
----- |
### Synopsis |
int getch(void); |
int wgetch(WINDOW *win); |
int mvgetch(int y, int x); |
int mvwgetch(WINDOW *win, int y, int x); |
int ungetch(int ch); |
int flushinp(void); |
int get_wch(wint_t *wch); |
int wget_wch(WINDOW *win, wint_t *wch); |
int mvget_wch(int y, int x, wint_t *wch); |
int mvwget_wch(WINDOW *win, int y, int x, wint_t *wch); |
int unget_wch(const wchar_t wch); |
unsigned long PDC_get_key_modifiers(void); |
int PDC_return_key_modifiers(bool flag); |
### Description |
With the getch(), wgetch(), mvgetch(), and mvwgetch() functions, a |
character is read from the terminal associated with the window. In |
nodelay mode, if there is no input waiting, the value ERR is |
returned. In delay mode, the program will hang until the system |
passes text through to the program. Depending on the setting of |
cbreak(), this will be after one character or after the first |
newline. Unless noecho() has been set, the character will also be |
echoed into the designated window. |
If keypad() is TRUE, and a function key is pressed, the token for |
that function key will be returned instead of the raw characters. |
Possible function keys are defined in <curses.h> with integers |
beginning with 0401, whose names begin with KEY_. |
If nodelay(win, TRUE) has been called on the window and no input is |
waiting, the value ERR is returned. |
ungetch() places ch back onto the input queue to be returned by the |
next call to wgetch(). |
flushinp() throws away any type-ahead that has been typed by the user |
and has not yet been read by the program. |
wget_wch() is the wide-character version of wgetch(), available when |
PDCurses is built with the PDC_WIDE option. It takes a pointer to a |
wint_t rather than returning the key as an int, and instead returns |
KEY_CODE_YES if the key is a function key. Otherwise, it returns OK |
or ERR. It's important to check for KEY_CODE_YES, since regular wide |
characters can have the same values as function key codes. |
unget_wch() puts a wide character on the input queue. |
PDC_get_key_modifiers() returns the keyboard modifiers (shift, |
control, alt, numlock) effective at the time of the last getch() |
call. Use the macros PDC_KEY_MODIFIER_* to determine which |
modifier(s) were set. PDC_return_key_modifiers() tells getch() to |
return modifier keys pressed alone as keystrokes (KEY_ALT_L, etc.). |
These may not work on all platforms. |
NOTE: getch() and ungetch() are implemented as macros, to avoid |
conflict with many DOS compiler's runtime libraries. |
### Return Value |
These functions return ERR or the value of the character, meta |
character or function key token. |
### Portability |
X/Open ncurses NetBSD |
getch Y Y Y |
wgetch Y Y Y |
mvgetch Y Y Y |
mvwgetch Y Y Y |
ungetch Y Y Y |
flushinp Y Y Y |
get_wch Y Y Y |
wget_wch Y Y Y |
mvget_wch Y Y Y |
mvwget_wch Y Y Y |
unget_wch Y Y Y |
PDC_get_key_modifiers - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
static int _get_box(int *y_start, int *y_end, int *x_start, int *x_end) |
{ |
int start, end; |
if (SP->sel_start < SP->sel_end) |
{ |
start = SP->sel_start; |
end = SP->sel_end; |
} |
else |
{ |
start = SP->sel_end; |
end = SP->sel_start; |
} |
*y_start = start / COLS; |
*x_start = start % COLS; |
*y_end = end / COLS; |
*x_end = end % COLS; |
return (end - start) + (*y_end - *y_start); |
} |
static void _highlight(void) |
{ |
int i, j, y_start, y_end, x_start, x_end; |
if (-1 == SP->sel_start) |
return; |
_get_box(&y_start, &y_end, &x_start, &x_end); |
for (j = y_start; j <= y_end; j++) |
for (i = (j == y_start ? x_start : 0); |
i < (j == y_end ? x_end : COLS); i++) |
curscr->_y[j][i] ^= A_REVERSE; |
wrefresh(curscr); |
} |
static void _copy(void) |
{ |
#ifdef PDC_WIDE |
wchar_t *wtmp; |
# define TMP wtmp |
# define MASK A_CHARTEXT |
#else |
# define TMP tmp |
# define MASK 0xff |
#endif |
char *tmp; |
long pos; |
int i, j, y_start, y_end, x_start, x_end, len; |
if (-1 == SP->sel_start) |
return; |
len = _get_box(&y_start, &y_end, &x_start, &x_end); |
if (!len) |
return; |
#ifdef PDC_WIDE |
wtmp = malloc((len + 1) * sizeof(wchar_t)); |
len *= 3; |
#endif |
tmp = malloc(len + 1); |
for (j = y_start, pos = 0; j <= y_end; j++) |
{ |
for (i = (j == y_start ? x_start : 0); |
i < (j == y_end ? x_end : COLS); i++) |
TMP[pos++] = curscr->_y[j][i] & MASK; |
while (y_start != y_end && pos > 0 && TMP[pos - 1] == 32) |
pos--; |
if (j < y_end) |
TMP[pos++] = 10; |
} |
TMP[pos] = 0; |
#ifdef PDC_WIDE |
pos = PDC_wcstombs(tmp, wtmp, len); |
#endif |
PDC_setclipboard(tmp, pos); |
free(tmp); |
#ifdef PDC_WIDE |
free(wtmp); |
#endif |
} |
static int _paste(void) |
{ |
#ifdef PDC_WIDE |
wchar_t *wpaste; |
# define PASTE wpaste |
#else |
# define PASTE paste |
#endif |
char *paste; |
long len, newmax; |
int key; |
key = PDC_getclipboard(&paste, &len); |
if (PDC_CLIP_SUCCESS != key || !len) |
return -1; |
#ifdef PDC_WIDE |
wpaste = malloc(len * sizeof(wchar_t)); |
len = PDC_mbstowcs(wpaste, paste, len); |
#endif |
newmax = len + SP->c_ungind; |
if (newmax > SP->c_ungmax) |
{ |
SP->c_ungch = realloc(SP->c_ungch, newmax * sizeof(int)); |
if (!SP->c_ungch) |
return -1; |
SP->c_ungmax = newmax; |
} |
while (len > 1) |
PDC_ungetch(PASTE[--len]); |
key = *PASTE; |
#ifdef PDC_WIDE |
free(wpaste); |
#endif |
PDC_freeclipboard(paste); |
SP->key_modifiers = 0; |
return key; |
} |
static int _mouse_key(void) |
{ |
int i, key = KEY_MOUSE, changes = SP->mouse_status.changes; |
unsigned long mbe = SP->_trap_mbe; |
/* Selection highlighting? */ |
if ((!mbe || SP->mouse_status.button[0] & BUTTON_SHIFT) && changes & 1) |
{ |
i = SP->mouse_status.y * COLS + SP->mouse_status.x; |
switch (SP->mouse_status.button[0] & BUTTON_ACTION_MASK) |
{ |
case BUTTON_PRESSED: |
_highlight(); |
SP->sel_start = SP->sel_end = i; |
return -1; |
case BUTTON_MOVED: |
_highlight(); |
SP->sel_end = i; |
_highlight(); |
return -1; |
case BUTTON_RELEASED: |
_copy(); |
return -1; |
} |
} |
else if ((!mbe || SP->mouse_status.button[1] & BUTTON_SHIFT) && |
changes & 2 && (SP->mouse_status.button[1] & |
BUTTON_ACTION_MASK) == BUTTON_CLICKED) |
{ |
SP->key_code = FALSE; |
return _paste(); |
} |
/* Filter unwanted mouse events */ |
for (i = 0; i < 3; i++) |
{ |
if (changes & (1 << i)) |
{ |
int shf = i * 5; |
short button = SP->mouse_status.button[i] & BUTTON_ACTION_MASK; |
if ( (!(mbe & (BUTTON1_PRESSED << shf)) && |
(button == BUTTON_PRESSED)) |
|| (!(mbe & (BUTTON1_CLICKED << shf)) && |
(button == BUTTON_CLICKED)) |
|| (!(mbe & (BUTTON1_DOUBLE_CLICKED << shf)) && |
(button == BUTTON_DOUBLE_CLICKED)) |
|| (!(mbe & (BUTTON1_MOVED << shf)) && |
(button == BUTTON_MOVED)) |
|| (!(mbe & (BUTTON1_RELEASED << shf)) && |
(button == BUTTON_RELEASED)) |
) |
SP->mouse_status.changes ^= (1 << i); |
} |
} |
if (changes & PDC_MOUSE_MOVED) |
{ |
if (!(mbe & (BUTTON1_MOVED|BUTTON2_MOVED|BUTTON3_MOVED))) |
SP->mouse_status.changes ^= PDC_MOUSE_MOVED; |
} |
if (changes & (PDC_MOUSE_WHEEL_UP|PDC_MOUSE_WHEEL_DOWN)) |
{ |
if (!(mbe & MOUSE_WHEEL_SCROLL)) |
SP->mouse_status.changes &= |
~(PDC_MOUSE_WHEEL_UP|PDC_MOUSE_WHEEL_DOWN); |
} |
if (!changes) |
return -1; |
/* Check for click in slk area */ |
i = PDC_mouse_in_slk(SP->mouse_status.y, SP->mouse_status.x); |
if (i) |
{ |
if (SP->mouse_status.button[0] & (BUTTON_PRESSED|BUTTON_CLICKED)) |
key = KEY_F(i); |
else |
key = -1; |
} |
return key; |
} |
int wgetch(WINDOW *win) |
{ |
int key, waitcount; |
PDC_LOG(("wgetch() - called\n")); |
if (!win || !SP) |
return ERR; |
waitcount = 0; |
/* set the number of 1/20th second napms() calls */ |
if (SP->delaytenths) |
waitcount = 2 * SP->delaytenths; |
else |
if (win->_delayms) |
{ |
/* Can't really do millisecond intervals, so delay in |
1/20ths of a second (50ms) */ |
waitcount = win->_delayms / 50; |
if (!waitcount) |
waitcount = 1; |
} |
/* refresh window when wgetch is called if there have been changes |
to it and it is not a pad */ |
if (!(win->_flags & _PAD) && ((!win->_leaveit && |
(win->_begx + win->_curx != SP->curscol || |
win->_begy + win->_cury != SP->cursrow)) || is_wintouched(win))) |
wrefresh(win); |
/* if ungotten char exists, remove and return it */ |
if (SP->c_ungind) |
return SP->c_ungch[--(SP->c_ungind)]; |
/* if normal and data in buffer */ |
if ((!SP->raw_inp && !SP->cbreak) && (SP->c_gindex < SP->c_pindex)) |
return SP->c_buffer[SP->c_gindex++]; |
/* prepare to buffer data */ |
SP->c_pindex = 0; |
SP->c_gindex = 0; |
/* to get here, no keys are buffered. go and get one. */ |
for (;;) /* loop for any buffering */ |
{ |
/* is there a keystroke ready? */ |
if (!PDC_check_key()) |
{ |
/* if not, handle timeout() and halfdelay() */ |
if (SP->delaytenths || win->_delayms) |
{ |
if (!waitcount) |
return ERR; |
waitcount--; |
} |
else |
if (win->_nodelay) |
return ERR; |
napms(50); /* sleep for 1/20th second */ |
continue; /* then check again */ |
} |
/* if there is, fetch it */ |
key = PDC_get_key(); |
/* copy or paste? */ |
if (SP->key_modifiers & PDC_KEY_MODIFIER_SHIFT) |
{ |
if (0x03 == key) |
{ |
_copy(); |
continue; |
} |
else if (0x16 == key) |
key = _paste(); |
} |
/* filter mouse events; translate mouse clicks in the slk |
area to function keys */ |
if (SP->key_code && key == KEY_MOUSE) |
key = _mouse_key(); |
/* filter special keys if not in keypad mode */ |
if (SP->key_code && !win->_use_keypad) |
key = -1; |
/* unwanted key? loop back */ |
if (key == -1) |
continue; |
_highlight(); |
SP->sel_start = SP->sel_end = -1; |
/* translate CR */ |
if (key == '\r' && SP->autocr && !SP->raw_inp) |
key = '\n'; |
/* if echo is enabled */ |
if (SP->echo && !SP->key_code) |
{ |
waddch(win, key); |
wrefresh(win); |
} |
/* if no buffering */ |
if (SP->raw_inp || SP->cbreak) |
return key; |
/* if no overflow, put data in buffer */ |
if (key == '\b') |
{ |
if (SP->c_pindex > SP->c_gindex) |
SP->c_pindex--; |
} |
else |
if (SP->c_pindex < _INBUFSIZ - 2) |
SP->c_buffer[SP->c_pindex++] = key; |
/* if we got a line */ |
if (key == '\n' || key == '\r') |
return SP->c_buffer[SP->c_gindex++]; |
} |
} |
int mvgetch(int y, int x) |
{ |
PDC_LOG(("mvgetch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wgetch(stdscr); |
} |
int mvwgetch(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwgetch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wgetch(win); |
} |
int PDC_ungetch(int ch) |
{ |
PDC_LOG(("ungetch() - called\n")); |
if (SP->c_ungind >= SP->c_ungmax) /* pushback stack full */ |
return ERR; |
SP->c_ungch[SP->c_ungind++] = ch; |
return OK; |
} |
int flushinp(void) |
{ |
PDC_LOG(("flushinp() - called\n")); |
if (!SP) |
return ERR; |
PDC_flushinp(); |
SP->c_gindex = 1; /* set indices to kill buffer */ |
SP->c_pindex = 0; |
SP->c_ungind = 0; /* clear SP->c_ungch array */ |
return OK; |
} |
unsigned long PDC_get_key_modifiers(void) |
{ |
PDC_LOG(("PDC_get_key_modifiers() - called\n")); |
if (!SP) |
return ERR; |
return SP->key_modifiers; |
} |
int PDC_return_key_modifiers(bool flag) |
{ |
PDC_LOG(("PDC_return_key_modifiers() - called\n")); |
if (!SP) |
return ERR; |
SP->return_key_modifiers = flag; |
return PDC_modifiers_set(); |
} |
#ifdef PDC_WIDE |
int wget_wch(WINDOW *win, wint_t *wch) |
{ |
int key; |
PDC_LOG(("wget_wch() - called\n")); |
if (!wch) |
return ERR; |
key = wgetch(win); |
if (key == ERR) |
return ERR; |
*wch = key; |
return SP->key_code ? KEY_CODE_YES : OK; |
} |
int get_wch(wint_t *wch) |
{ |
PDC_LOG(("get_wch() - called\n")); |
return wget_wch(stdscr, wch); |
} |
int mvget_wch(int y, int x, wint_t *wch) |
{ |
PDC_LOG(("mvget_wch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wget_wch(stdscr, wch); |
} |
int mvwget_wch(WINDOW *win, int y, int x, wint_t *wch) |
{ |
PDC_LOG(("mvwget_wch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wget_wch(win, wch); |
} |
int unget_wch(const wchar_t wch) |
{ |
return PDC_ungetch(wch); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/getstr.c |
---|
0,0 → 1,473 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
getstr |
------ |
### Synopsis |
int getstr(char *str); |
int wgetstr(WINDOW *win, char *str); |
int mvgetstr(int y, int x, char *str); |
int mvwgetstr(WINDOW *win, int y, int x, char *str); |
int getnstr(char *str, int n); |
int wgetnstr(WINDOW *win, char *str, int n); |
int mvgetnstr(int y, int x, char *str, int n); |
int mvwgetnstr(WINDOW *win, int y, int x, char *str, int n); |
int get_wstr(wint_t *wstr); |
int wget_wstr(WINDOW *win, wint_t *wstr); |
int mvget_wstr(int y, int x, wint_t *wstr); |
int mvwget_wstr(WINDOW *win, int, int, wint_t *wstr); |
int getn_wstr(wint_t *wstr, int n); |
int wgetn_wstr(WINDOW *win, wint_t *wstr, int n); |
int mvgetn_wstr(int y, int x, wint_t *wstr, int n); |
int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n); |
### Description |
These routines call wgetch() repeatedly to build a string, |
interpreting erase and kill characters along the way, until a newline |
or carriage return is received. When PDCurses is built with wide- |
character support enabled, the narrow-character functions convert the |
wgetch()'d values into a multibyte string in the current locale |
before returning it. The resulting string is placed in the area |
pointed to by *str. The routines with n as the last argument read at |
most n characters. |
Note that there's no way to know how long the buffer passed to |
wgetstr() is, so use wgetnstr() to avoid buffer overflows. |
### Return Value |
These functions return ERR on failure or any other value on success. |
### Portability |
X/Open ncurses NetBSD |
getstr Y Y Y |
wgetstr Y Y Y |
mvgetstr Y Y Y |
mvwgetstr Y Y Y |
getnstr Y Y Y |
wgetnstr Y Y Y |
mvgetnstr Y Y Y |
mvwgetnstr Y Y Y |
get_wstr Y Y Y |
wget_wstr Y Y Y |
mvget_wstr Y Y Y |
mvwget_wstr Y Y Y |
getn_wstr Y Y Y |
wgetn_wstr Y Y Y |
mvgetn_wstr Y Y Y |
mvwgetn_wstr Y Y Y |
**man-end****************************************************************/ |
#define MAXLINE 255 |
int wgetnstr(WINDOW *win, char *str, int n) |
{ |
#ifdef PDC_WIDE |
wchar_t wstr[MAXLINE + 1]; |
if (n < 0 || n > MAXLINE) |
n = MAXLINE; |
if (wgetn_wstr(win, (wint_t *)wstr, n) == ERR) |
return ERR; |
return PDC_wcstombs(str, wstr, n); |
#else |
int ch, i, num, x, chars; |
char *p; |
bool stop, oldecho, oldcbreak, oldnodelay; |
PDC_LOG(("wgetnstr() - called\n")); |
if (!win || !str) |
return ERR; |
chars = 0; |
p = str; |
stop = FALSE; |
x = win->_curx; |
oldcbreak = SP->cbreak; /* remember states */ |
oldecho = SP->echo; |
oldnodelay = win->_nodelay; |
SP->echo = FALSE; /* we do echo ourselves */ |
cbreak(); /* ensure each key is returned immediately */ |
win->_nodelay = FALSE; /* don't return -1 */ |
wrefresh(win); |
while (!stop) |
{ |
ch = wgetch(win); |
switch (ch) |
{ |
case '\t': |
ch = ' '; |
num = TABSIZE - (win->_curx - x) % TABSIZE; |
for (i = 0; i < num; i++) |
{ |
if (chars < n) |
{ |
if (oldecho) |
waddch(win, ch); |
*p++ = ch; |
++chars; |
} |
else |
beep(); |
} |
break; |
case _ECHAR: /* CTRL-H -- Delete character */ |
if (p > str) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = (unsigned char)(*--p); |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
chars--; |
} |
break; |
case _DLCHAR: /* CTRL-U -- Delete line */ |
while (p > str) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = (unsigned char)(*--p); |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
} |
chars = 0; |
break; |
case _DWCHAR: /* CTRL-W -- Delete word */ |
while ((p > str) && (*(p - 1) == ' ')) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
--p; /* remove space */ |
chars--; |
} |
while ((p > str) && (*(p - 1) != ' ')) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = (unsigned char)(*--p); |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
chars--; |
} |
break; |
case '\n': |
case '\r': |
stop = TRUE; |
if (oldecho) |
waddch(win, '\n'); |
break; |
default: |
if (chars < n) |
{ |
if (!SP->key_code && ch < 0x100) |
{ |
*p++ = ch; |
if (oldecho) |
waddch(win, ch); |
chars++; |
} |
} |
else |
beep(); |
break; |
} |
wrefresh(win); |
} |
*p = '\0'; |
SP->echo = oldecho; /* restore old settings */ |
SP->cbreak = oldcbreak; |
win->_nodelay = oldnodelay; |
return OK; |
#endif |
} |
int getstr(char *str) |
{ |
PDC_LOG(("getstr() - called\n")); |
return wgetnstr(stdscr, str, MAXLINE); |
} |
int wgetstr(WINDOW *win, char *str) |
{ |
PDC_LOG(("wgetstr() - called\n")); |
return wgetnstr(win, str, MAXLINE); |
} |
int mvgetstr(int y, int x, char *str) |
{ |
PDC_LOG(("mvgetstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wgetnstr(stdscr, str, MAXLINE); |
} |
int mvwgetstr(WINDOW *win, int y, int x, char *str) |
{ |
PDC_LOG(("mvwgetstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wgetnstr(win, str, MAXLINE); |
} |
int getnstr(char *str, int n) |
{ |
PDC_LOG(("getnstr() - called\n")); |
return wgetnstr(stdscr, str, n); |
} |
int mvgetnstr(int y, int x, char *str, int n) |
{ |
PDC_LOG(("mvgetnstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wgetnstr(stdscr, str, n); |
} |
int mvwgetnstr(WINDOW *win, int y, int x, char *str, int n) |
{ |
PDC_LOG(("mvwgetnstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wgetnstr(win, str, n); |
} |
#ifdef PDC_WIDE |
int wgetn_wstr(WINDOW *win, wint_t *wstr, int n) |
{ |
int ch, i, num, x, chars; |
wint_t *p; |
bool stop, oldecho, oldcbreak, oldnodelay; |
PDC_LOG(("wgetn_wstr() - called\n")); |
if (!win || !wstr) |
return ERR; |
chars = 0; |
p = wstr; |
stop = FALSE; |
x = win->_curx; |
oldcbreak = SP->cbreak; /* remember states */ |
oldecho = SP->echo; |
oldnodelay = win->_nodelay; |
SP->echo = FALSE; /* we do echo ourselves */ |
cbreak(); /* ensure each key is returned immediately */ |
win->_nodelay = FALSE; /* don't return -1 */ |
wrefresh(win); |
while (!stop) |
{ |
ch = wgetch(win); |
switch (ch) |
{ |
case '\t': |
ch = ' '; |
num = TABSIZE - (win->_curx - x) % TABSIZE; |
for (i = 0; i < num; i++) |
{ |
if (chars < n) |
{ |
if (oldecho) |
waddch(win, ch); |
*p++ = ch; |
++chars; |
} |
else |
beep(); |
} |
break; |
case _ECHAR: /* CTRL-H -- Delete character */ |
if (p > wstr) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = *--p; |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
chars--; |
} |
break; |
case _DLCHAR: /* CTRL-U -- Delete line */ |
while (p > wstr) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = *--p; |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
} |
chars = 0; |
break; |
case _DWCHAR: /* CTRL-W -- Delete word */ |
while ((p > wstr) && (*(p - 1) == ' ')) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
--p; /* remove space */ |
chars--; |
} |
while ((p > wstr) && (*(p - 1) != ' ')) |
{ |
if (oldecho) |
waddstr(win, "\b \b"); |
ch = *--p; |
if ((ch < ' ') && (oldecho)) |
waddstr(win, "\b \b"); |
chars--; |
} |
break; |
case '\n': |
case '\r': |
stop = TRUE; |
if (oldecho) |
waddch(win, '\n'); |
break; |
default: |
if (chars < n) |
{ |
if (!SP->key_code) |
{ |
*p++ = ch; |
if (oldecho) |
waddch(win, ch); |
chars++; |
} |
} |
else |
beep(); |
break; |
} |
wrefresh(win); |
} |
*p = '\0'; |
SP->echo = oldecho; /* restore old settings */ |
SP->cbreak = oldcbreak; |
win->_nodelay = oldnodelay; |
return OK; |
} |
int get_wstr(wint_t *wstr) |
{ |
PDC_LOG(("get_wstr() - called\n")); |
return wgetn_wstr(stdscr, wstr, MAXLINE); |
} |
int wget_wstr(WINDOW *win, wint_t *wstr) |
{ |
PDC_LOG(("wget_wstr() - called\n")); |
return wgetn_wstr(win, wstr, MAXLINE); |
} |
int mvget_wstr(int y, int x, wint_t *wstr) |
{ |
PDC_LOG(("mvget_wstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wgetn_wstr(stdscr, wstr, MAXLINE); |
} |
int mvwget_wstr(WINDOW *win, int y, int x, wint_t *wstr) |
{ |
PDC_LOG(("mvwget_wstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wgetn_wstr(win, wstr, MAXLINE); |
} |
int getn_wstr(wint_t *wstr, int n) |
{ |
PDC_LOG(("getn_wstr() - called\n")); |
return wgetn_wstr(stdscr, wstr, n); |
} |
int mvgetn_wstr(int y, int x, wint_t *wstr, int n) |
{ |
PDC_LOG(("mvgetn_wstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wgetn_wstr(stdscr, wstr, n); |
} |
int mvwgetn_wstr(WINDOW *win, int y, int x, wint_t *wstr, int n) |
{ |
PDC_LOG(("mvwgetn_wstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wgetn_wstr(win, wstr, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/getyx.c |
---|
0,0 → 1,142 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
getyx |
----- |
### Synopsis |
void getyx(WINDOW *win, int y, int x); |
void getparyx(WINDOW *win, int y, int x); |
void getbegyx(WINDOW *win, int y, int x); |
void getmaxyx(WINDOW *win, int y, int x); |
void getsyx(int y, int x); |
void setsyx(int y, int x); |
int getbegy(WINDOW *win); |
int getbegx(WINDOW *win); |
int getcury(WINDOW *win); |
int getcurx(WINDOW *win); |
int getpary(WINDOW *win); |
int getparx(WINDOW *win); |
int getmaxy(WINDOW *win); |
int getmaxx(WINDOW *win); |
### Description |
The getyx() macro (defined in curses.h -- the prototypes here are |
merely illustrative) puts the current cursor position of the |
specified window into y and x. getbegyx() and getmaxyx() return the |
starting coordinates and size of the specified window, respectively. |
getparyx() returns the starting coordinates of the parent's window, |
if the specified window is a subwindow; otherwise it sets y and x to |
-1. These are all macros. |
getsyx() gets the coordinates of the virtual screen cursor, and |
stores them in y and x. If leaveok() is TRUE, it returns -1, -1. If |
lines have been removed with ripoffline(), then getsyx() includes |
these lines in its count; so, the returned y and x values should only |
be used with setsyx(). |
setsyx() sets the virtual screen cursor to the y, x coordinates. If |
either y or x is -1, leaveok() is set TRUE, else it's set FALSE. |
getsyx() and setsyx() are meant to be used by a library routine that |
manipulates curses windows without altering the position of the |
cursor. Note that getsyx() is defined only as a macro. |
getbegy(), getbegx(), getcurx(), getcury(), getmaxy(), getmaxx(), |
getpary(), and getparx() return the appropriate coordinate or size |
values, or ERR in the case of a NULL window. |
### Portability |
X/Open ncurses NetBSD |
getyx Y Y Y |
getparyx Y Y Y |
getbegyx Y Y Y |
getmaxyx Y Y Y |
getsyx - Y Y |
setsyx - Y Y |
getbegy - Y Y |
getbegx - Y Y |
getcury - Y Y |
getcurx - Y Y |
getpary - Y Y |
getparx - Y Y |
getmaxy - Y Y |
getmaxx - Y Y |
**man-end****************************************************************/ |
int getbegy(WINDOW *win) |
{ |
PDC_LOG(("getbegy() - called\n")); |
return win ? win->_begy : ERR; |
} |
int getbegx(WINDOW *win) |
{ |
PDC_LOG(("getbegx() - called\n")); |
return win ? win->_begx : ERR; |
} |
int getcury(WINDOW *win) |
{ |
PDC_LOG(("getcury() - called\n")); |
return win ? win->_cury : ERR; |
} |
int getcurx(WINDOW *win) |
{ |
PDC_LOG(("getcurx() - called\n")); |
return win ? win->_curx : ERR; |
} |
int getpary(WINDOW *win) |
{ |
PDC_LOG(("getpary() - called\n")); |
return win ? win->_pary : ERR; |
} |
int getparx(WINDOW *win) |
{ |
PDC_LOG(("getparx() - called\n")); |
return win ? win->_parx : ERR; |
} |
int getmaxy(WINDOW *win) |
{ |
PDC_LOG(("getmaxy() - called\n")); |
return win ? win->_maxy : ERR; |
} |
int getmaxx(WINDOW *win) |
{ |
PDC_LOG(("getmaxx() - called\n")); |
return win ? win->_maxx : ERR; |
} |
void setsyx(int y, int x) |
{ |
PDC_LOG(("setsyx() - called\n")); |
if (curscr) |
{ |
curscr->_leaveit = y == -1 || x == -1; |
if (!curscr->_leaveit) |
wmove(curscr, y, x); |
} |
} |
/contrib/sdk/sources/PDCurses/pdcurses/inch.c |
---|
0,0 → 1,126 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
inch |
---- |
### Synopsis |
chtype inch(void); |
chtype winch(WINDOW *win); |
chtype mvinch(int y, int x); |
chtype mvwinch(WINDOW *win, int y, int x); |
int in_wch(cchar_t *wcval); |
int win_wch(WINDOW *win, cchar_t *wcval); |
int mvin_wch(int y, int x, cchar_t *wcval); |
int mvwin_wch(WINDOW *win, int y, int x, cchar_t *wcval); |
### Description |
The inch() functions retrieve the character and attribute from the |
current or specified window position, in the form of a chtype. If a |
NULL window is specified, (chtype)ERR is returned. |
The in_wch() functions are the wide-character versions; instead of |
returning a chtype, they store a cchar_t at the address specified by |
wcval, and return OK or ERR. (No value is stored when ERR is |
returned.) Note that in PDCurses, chtype and cchar_t are the same. |
### Portability |
X/Open ncurses NetBSD |
inch Y Y Y |
winch Y Y Y |
mvinch Y Y Y |
mvwinch Y Y Y |
in_wch Y Y Y |
win_wch Y Y Y |
mvin_wch Y Y Y |
mvwin_wch Y Y Y |
**man-end****************************************************************/ |
chtype winch(WINDOW *win) |
{ |
PDC_LOG(("winch() - called\n")); |
if (!win) |
return (chtype)ERR; |
return win->_y[win->_cury][win->_curx]; |
} |
chtype inch(void) |
{ |
PDC_LOG(("inch() - called\n")); |
return winch(stdscr); |
} |
chtype mvinch(int y, int x) |
{ |
PDC_LOG(("mvinch() - called\n")); |
if (move(y, x) == ERR) |
return (chtype)ERR; |
return stdscr->_y[stdscr->_cury][stdscr->_curx]; |
} |
chtype mvwinch(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwinch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return (chtype)ERR; |
return win->_y[win->_cury][win->_curx]; |
} |
#ifdef PDC_WIDE |
int win_wch(WINDOW *win, cchar_t *wcval) |
{ |
PDC_LOG(("win_wch() - called\n")); |
if (!win || !wcval) |
return ERR; |
*wcval = win->_y[win->_cury][win->_curx]; |
return OK; |
} |
int in_wch(cchar_t *wcval) |
{ |
PDC_LOG(("in_wch() - called\n")); |
return win_wch(stdscr, wcval); |
} |
int mvin_wch(int y, int x, cchar_t *wcval) |
{ |
PDC_LOG(("mvin_wch() - called\n")); |
if (!wcval || (move(y, x) == ERR)) |
return ERR; |
*wcval = stdscr->_y[stdscr->_cury][stdscr->_curx]; |
return OK; |
} |
int mvwin_wch(WINDOW *win, int y, int x, cchar_t *wcval) |
{ |
PDC_LOG(("mvwin_wch() - called\n")); |
if (!wcval || (wmove(win, y, x) == ERR)) |
return ERR; |
*wcval = win->_y[win->_cury][win->_curx]; |
return OK; |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/inchstr.c |
---|
0,0 → 1,213 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
inchstr |
------- |
### Synopsis |
int inchstr(chtype *ch); |
int inchnstr(chtype *ch, int n); |
int winchstr(WINDOW *win, chtype *ch); |
int winchnstr(WINDOW *win, chtype *ch, int n); |
int mvinchstr(int y, int x, chtype *ch); |
int mvinchnstr(int y, int x, chtype *ch, int n); |
int mvwinchstr(WINDOW *, int y, int x, chtype *ch); |
int mvwinchnstr(WINDOW *, int y, int x, chtype *ch, int n); |
int in_wchstr(cchar_t *wch); |
int in_wchnstr(cchar_t *wch, int n); |
int win_wchstr(WINDOW *win, cchar_t *wch); |
int win_wchnstr(WINDOW *win, cchar_t *wch, int n); |
int mvin_wchstr(int y, int x, cchar_t *wch); |
int mvin_wchnstr(int y, int x, cchar_t *wch, int n); |
int mvwin_wchstr(WINDOW *win, int y, int x, cchar_t *wch); |
int mvwin_wchnstr(WINDOW *win, int y, int x, cchar_t *wch, int n); |
### Description |
These routines read a chtype or cchar_t string from the window, |
starting at the current or specified position, and ending at the |
right margin, or after n elements, whichever is less. |
### Return Value |
All functions return the number of elements read, or ERR on error. |
### Portability |
X/Open ncurses NetBSD |
inchstr Y Y Y |
winchstr Y Y Y |
mvinchstr Y Y Y |
mvwinchstr Y Y Y |
inchnstr Y Y Y |
winchnstr Y Y Y |
mvinchnstr Y Y Y |
mvwinchnstr Y Y Y |
in_wchstr Y Y Y |
win_wchstr Y Y Y |
mvin_wchstr Y Y Y |
mvwin_wchstr Y Y Y |
in_wchnstr Y Y Y |
win_wchnstr Y Y Y |
mvin_wchnstr Y Y Y |
mvwin_wchnstr Y Y Y |
**man-end****************************************************************/ |
int winchnstr(WINDOW *win, chtype *ch, int n) |
{ |
chtype *src; |
int i; |
PDC_LOG(("winchnstr() - called\n")); |
if (!win || !ch || n < 0) |
return ERR; |
if ((win->_curx + n) > win->_maxx) |
n = win->_maxx - win->_curx; |
src = win->_y[win->_cury] + win->_curx; |
for (i = 0; i < n; i++) |
*ch++ = *src++; |
*ch = (chtype)0; |
return OK; |
} |
int inchstr(chtype *ch) |
{ |
PDC_LOG(("inchstr() - called\n")); |
return winchnstr(stdscr, ch, stdscr->_maxx - stdscr->_curx); |
} |
int winchstr(WINDOW *win, chtype *ch) |
{ |
PDC_LOG(("winchstr() - called\n")); |
return winchnstr(win, ch, win->_maxx - win->_curx); |
} |
int mvinchstr(int y, int x, chtype *ch) |
{ |
PDC_LOG(("mvinchstr() - called: y %d x %d\n", y, x)); |
if (move(y, x) == ERR) |
return ERR; |
return winchnstr(stdscr, ch, stdscr->_maxx - stdscr->_curx); |
} |
int mvwinchstr(WINDOW *win, int y, int x, chtype *ch) |
{ |
PDC_LOG(("mvwinchstr() - called:\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winchnstr(win, ch, win->_maxx - win->_curx); |
} |
int inchnstr(chtype *ch, int n) |
{ |
PDC_LOG(("inchnstr() - called\n")); |
return winchnstr(stdscr, ch, n); |
} |
int mvinchnstr(int y, int x, chtype *ch, int n) |
{ |
PDC_LOG(("mvinchnstr() - called: y %d x %d n %d\n", y, x, n)); |
if (move(y, x) == ERR) |
return ERR; |
return winchnstr(stdscr, ch, n); |
} |
int mvwinchnstr(WINDOW *win, int y, int x, chtype *ch, int n) |
{ |
PDC_LOG(("mvwinchnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winchnstr(win, ch, n); |
} |
#ifdef PDC_WIDE |
int win_wchnstr(WINDOW *win, cchar_t *wch, int n) |
{ |
PDC_LOG(("win_wchnstr() - called\n")); |
return winchnstr(win, wch, n); |
} |
int in_wchstr(cchar_t *wch) |
{ |
PDC_LOG(("in_wchstr() - called\n")); |
return win_wchnstr(stdscr, wch, stdscr->_maxx - stdscr->_curx); |
} |
int win_wchstr(WINDOW *win, cchar_t *wch) |
{ |
PDC_LOG(("win_wchstr() - called\n")); |
return win_wchnstr(win, wch, win->_maxx - win->_curx); |
} |
int mvin_wchstr(int y, int x, cchar_t *wch) |
{ |
PDC_LOG(("mvin_wchstr() - called: y %d x %d\n", y, x)); |
if (move(y, x) == ERR) |
return ERR; |
return win_wchnstr(stdscr, wch, stdscr->_maxx - stdscr->_curx); |
} |
int mvwin_wchstr(WINDOW *win, int y, int x, cchar_t *wch) |
{ |
PDC_LOG(("mvwin_wchstr() - called:\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return win_wchnstr(win, wch, win->_maxx - win->_curx); |
} |
int in_wchnstr(cchar_t *wch, int n) |
{ |
PDC_LOG(("in_wchnstr() - called\n")); |
return win_wchnstr(stdscr, wch, n); |
} |
int mvin_wchnstr(int y, int x, cchar_t *wch, int n) |
{ |
PDC_LOG(("mvin_wchnstr() - called: y %d x %d n %d\n", y, x, n)); |
if (move(y, x) == ERR) |
return ERR; |
return win_wchnstr(stdscr, wch, n); |
} |
int mvwin_wchnstr(WINDOW *win, int y, int x, cchar_t *wch, int n) |
{ |
PDC_LOG(("mvwinchnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return win_wchnstr(win, wch, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/initscr.c |
---|
0,0 → 1,431 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
initscr |
------- |
### Synopsis |
WINDOW *initscr(void); |
WINDOW *Xinitscr(int argc, char **argv); |
int endwin(void); |
bool isendwin(void); |
SCREEN *newterm(const char *type, FILE *outfd, FILE *infd); |
SCREEN *set_term(SCREEN *new); |
void delscreen(SCREEN *sp); |
int resize_term(int nlines, int ncols); |
bool is_termresized(void); |
const char *curses_version(void); |
void PDC_get_version(PDC_VERSION *ver); |
int set_tabsize(int tabsize); |
### Description |
initscr() should be the first curses routine called. It will |
initialize all curses data structures, and arrange that the first |
call to refresh() will clear the screen. In case of error, initscr() |
will write a message to standard error and end the program. |
endwin() should be called before exiting or escaping from curses mode |
temporarily. It will restore tty modes, move the cursor to the lower |
left corner of the screen and reset the terminal into the proper |
non-visual mode. To resume curses after a temporary escape, call |
refresh() or doupdate(). |
isendwin() returns TRUE if endwin() has been called without a |
subsequent refresh, unless SP is NULL. |
In some implementations of curses, newterm() allows the use of |
multiple terminals. Here, it's just an alternative interface for |
initscr(). It always returns SP, or NULL. |
delscreen() frees the memory allocated by newterm() or initscr(), |
since it's not freed by endwin(). This function is usually not |
needed. In PDCurses, the parameter must be the value of SP, and |
delscreen() sets SP to NULL. |
set_term() does nothing meaningful in PDCurses, but is included for |
compatibility with other curses implementations. |
resize_term() is effectively two functions: When called with nonzero |
values for nlines and ncols, it attempts to resize the screen to the |
given size. When called with (0, 0), it merely adjusts the internal |
structures to match the current size after the screen is resized by |
the user. On the currently supported platforms, SDL, Windows console, |
and X11 allow user resizing, while DOS, OS/2, SDL and Windows console |
allow programmatic resizing. If you want to support user resizing, |
you should check for getch() returning KEY_RESIZE, and/or call |
is_termresized() at appropriate times; if either condition occurs, |
call resize_term(0, 0). Then, with either user or programmatic |
resizing, you'll have to resize any windows you've created, as |
appropriate; resize_term() only handles stdscr and curscr. |
is_termresized() returns TRUE if the curses screen has been resized |
by the user, and a call to resize_term() is needed. Checking for |
KEY_RESIZE is generally preferable, unless you're not handling the |
keyboard. |
curses_version() returns a string describing the version of PDCurses. |
PDC_get_version() fills a PDC_VERSION structure provided by the user |
with more detailed version info (see curses.h). |
set_tabsize() sets the tab interval, stored in TABSIZE. |
### Return Value |
All functions return NULL on error, except endwin(), which always |
returns OK, and resize_term(), which returns either OK or ERR. |
### Portability |
X/Open ncurses NetBSD |
initscr Y Y Y |
endwin Y Y Y |
isendwin Y Y Y |
newterm Y Y Y |
set_term Y Y Y |
delscreen Y Y Y |
resize_term - Y Y |
set_tabsize - Y Y |
curses_version - Y - |
is_termresized - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
char ttytype[128]; |
const char *_curses_notice = "PDCurses " PDC_VERDOT " - " __DATE__; |
SCREEN *SP = (SCREEN*)NULL; /* curses variables */ |
WINDOW *curscr = (WINDOW *)NULL; /* the current screen image */ |
WINDOW *stdscr = (WINDOW *)NULL; /* the default screen window */ |
int LINES = 0; /* current terminal height */ |
int COLS = 0; /* current terminal width */ |
int TABSIZE = 8; |
MOUSE_STATUS Mouse_status; |
extern RIPPEDOFFLINE linesripped[5]; |
extern char linesrippedoff; |
WINDOW *initscr(void) |
{ |
int i; |
PDC_LOG(("initscr() - called\n")); |
if (SP && SP->alive) |
return NULL; |
SP = calloc(1, sizeof(SCREEN)); |
if (!SP) |
return NULL; |
if (PDC_scr_open() == ERR) |
{ |
fprintf(stderr, "initscr(): Unable to create SP\n"); |
exit(8); |
} |
SP->autocr = TRUE; /* cr -> lf by default */ |
SP->raw_out = FALSE; /* tty I/O modes */ |
SP->raw_inp = FALSE; /* tty I/O modes */ |
SP->cbreak = TRUE; |
SP->key_modifiers = 0L; |
SP->return_key_modifiers = FALSE; |
SP->echo = TRUE; |
SP->visibility = 1; |
SP->resized = FALSE; |
SP->_trap_mbe = 0L; |
SP->linesrippedoff = 0; |
SP->linesrippedoffontop = 0; |
SP->delaytenths = 0; |
SP->line_color = -1; |
SP->lastscr = (WINDOW *)NULL; |
SP->dbfp = NULL; |
SP->color_started = FALSE; |
SP->dirty = FALSE; |
SP->sel_start = -1; |
SP->sel_end = -1; |
SP->orig_cursor = PDC_get_cursor_mode(); |
LINES = SP->lines = PDC_get_rows(); |
COLS = SP->cols = PDC_get_columns(); |
if (LINES < 2 || COLS < 2) |
{ |
fprintf(stderr, "initscr(): LINES=%d COLS=%d: too small.\n", |
LINES, COLS); |
exit(4); |
} |
curscr = newwin(LINES, COLS, 0, 0); |
if (!curscr) |
{ |
fprintf(stderr, "initscr(): Unable to create curscr.\n"); |
exit(2); |
} |
SP->lastscr = newwin(LINES, COLS, 0, 0); |
if (!SP->lastscr) |
{ |
fprintf(stderr, "initscr(): Unable to create SP->lastscr.\n"); |
exit(2); |
} |
wattrset(SP->lastscr, (chtype)(-1)); |
werase(SP->lastscr); |
PDC_slk_initialize(); |
LINES -= SP->slklines; |
/* We have to sort out ripped off lines here, and reduce the height |
of stdscr by the number of lines ripped off */ |
for (i = 0; i < linesrippedoff; i++) |
{ |
if (linesripped[i].line < 0) |
(*linesripped[i].init)(newwin(1, COLS, LINES - 1, 0), COLS); |
else |
(*linesripped[i].init)(newwin(1, COLS, |
SP->linesrippedoffontop++, 0), COLS); |
SP->linesrippedoff++; |
LINES--; |
} |
linesrippedoff = 0; |
stdscr = newwin(LINES, COLS, SP->linesrippedoffontop, 0); |
if (!stdscr) |
{ |
fprintf(stderr, "initscr(): Unable to create stdscr.\n"); |
exit(1); |
} |
wclrtobot(stdscr); |
/* If preserving the existing screen, don't allow a screen clear */ |
if (SP->_preserve) |
{ |
untouchwin(curscr); |
untouchwin(stdscr); |
stdscr->_clear = FALSE; |
curscr->_clear = FALSE; |
} |
else |
curscr->_clear = TRUE; |
SP->atrtab = calloc(PDC_COLOR_PAIRS, sizeof(PDC_PAIR)); |
if (!SP->atrtab) |
return NULL; |
PDC_init_atrtab(); /* set up default colors */ |
MOUSE_X_POS = MOUSE_Y_POS = -1; |
BUTTON_STATUS(1) = BUTTON_RELEASED; |
BUTTON_STATUS(2) = BUTTON_RELEASED; |
BUTTON_STATUS(3) = BUTTON_RELEASED; |
Mouse_status.changes = 0; |
SP->alive = TRUE; |
def_shell_mode(); |
sprintf(ttytype, "pdcurses|PDCurses for %s", PDC_sysname()); |
SP->c_buffer = malloc(_INBUFSIZ * sizeof(int)); |
if (!SP->c_buffer) |
return NULL; |
SP->c_pindex = 0; |
SP->c_gindex = 1; |
SP->c_ungch = malloc(NUNGETCH * sizeof(int)); |
if (!SP->c_ungch) |
return NULL; |
SP->c_ungind = 0; |
SP->c_ungmax = NUNGETCH; |
return stdscr; |
} |
#ifdef XCURSES |
WINDOW *Xinitscr(int argc, char **argv) |
{ |
PDC_LOG(("Xinitscr() - called\n")); |
PDC_set_args(argc, argv); |
return initscr(); |
} |
#endif |
int endwin(void) |
{ |
PDC_LOG(("endwin() - called\n")); |
/* Allow temporary exit from curses using endwin() */ |
def_prog_mode(); |
PDC_scr_close(); |
SP->alive = FALSE; |
return OK; |
} |
bool isendwin(void) |
{ |
PDC_LOG(("isendwin() - called\n")); |
return SP ? !(SP->alive) : FALSE; |
} |
SCREEN *newterm(const char *type, FILE *outfd, FILE *infd) |
{ |
PDC_LOG(("newterm() - called\n")); |
return initscr() ? SP : NULL; |
} |
SCREEN *set_term(SCREEN *new) |
{ |
PDC_LOG(("set_term() - called\n")); |
/* We only support one screen */ |
return (new == SP) ? SP : NULL; |
} |
void delscreen(SCREEN *sp) |
{ |
PDC_LOG(("delscreen() - called\n")); |
if (!SP || sp != SP) |
return; |
free(SP->c_ungch); |
free(SP->c_buffer); |
free(SP->atrtab); |
PDC_slk_free(); /* free the soft label keys, if needed */ |
delwin(stdscr); |
delwin(curscr); |
delwin(SP->lastscr); |
stdscr = (WINDOW *)NULL; |
curscr = (WINDOW *)NULL; |
SP->lastscr = (WINDOW *)NULL; |
SP->alive = FALSE; |
PDC_scr_free(); |
free(SP); |
SP = (SCREEN *)NULL; |
} |
int resize_term(int nlines, int ncols) |
{ |
PDC_LOG(("resize_term() - called: nlines %d\n", nlines)); |
if (!stdscr || PDC_resize_screen(nlines, ncols) == ERR) |
return ERR; |
SP->resized = FALSE; |
SP->lines = PDC_get_rows(); |
LINES = SP->lines - SP->linesrippedoff - SP->slklines; |
SP->cols = COLS = PDC_get_columns(); |
if (SP->cursrow >= SP->lines) |
SP->cursrow = SP->lines - 1; |
if (SP->curscol >= SP->cols) |
SP->curscol = SP->cols - 1; |
if (wresize(curscr, SP->lines, SP->cols) == ERR || |
wresize(stdscr, LINES, COLS) == ERR || |
wresize(SP->lastscr, SP->lines, SP->cols) == ERR) |
return ERR; |
werase(SP->lastscr); |
curscr->_clear = TRUE; |
if (SP->slk_winptr) |
{ |
if (wresize(SP->slk_winptr, SP->slklines, COLS) == ERR) |
return ERR; |
wmove(SP->slk_winptr, 0, 0); |
wclrtobot(SP->slk_winptr); |
PDC_slk_initialize(); |
slk_noutrefresh(); |
} |
touchwin(stdscr); |
wnoutrefresh(stdscr); |
return OK; |
} |
bool is_termresized(void) |
{ |
PDC_LOG(("is_termresized() - called\n")); |
return SP->resized; |
} |
const char *curses_version(void) |
{ |
return _curses_notice; |
} |
void PDC_get_version(PDC_VERSION *ver) |
{ |
if (!ver) |
return; |
ver->flags = 0 |
#ifdef PDCDEBUG |
| PDC_VFLAG_DEBUG |
#endif |
#ifdef PDC_WIDE |
| PDC_VFLAG_WIDE |
#endif |
#ifdef PDC_FORCE_UTF8 |
| PDC_VFLAG_UTF8 |
#endif |
#ifdef PDC_DLL_BUILD |
| PDC_VFLAG_DLL |
#endif |
#ifdef PDC_RGB |
| PDC_VFLAG_RGB |
#endif |
; |
ver->build = PDC_BUILD; |
ver->major = PDC_VER_MAJOR; |
ver->minor = PDC_VER_MINOR; |
ver->csize = sizeof(chtype); |
ver->bsize = sizeof(bool); |
} |
int set_tabsize(int tabsize) |
{ |
PDC_LOG(("set_tabsize() - called: tabsize %d\n", tabsize)); |
if (tabsize < 1) |
return ERR; |
TABSIZE = tabsize; |
return OK; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/inopts.c |
---|
0,0 → 1,368 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
inopts |
------ |
### Synopsis |
int cbreak(void); |
int nocbreak(void); |
int echo(void); |
int noecho(void); |
int halfdelay(int tenths); |
int intrflush(WINDOW *win, bool bf); |
int keypad(WINDOW *win, bool bf); |
int meta(WINDOW *win, bool bf); |
int nl(void); |
int nonl(void); |
int nodelay(WINDOW *win, bool bf); |
int notimeout(WINDOW *win, bool bf); |
int raw(void); |
int noraw(void); |
void noqiflush(void); |
void qiflush(void); |
void timeout(int delay); |
void wtimeout(WINDOW *win, int delay); |
int typeahead(int fildes); |
int crmode(void); |
int nocrmode(void); |
bool is_keypad(const WINDOW *win); |
### Description |
cbreak() and nocbreak() toggle cbreak mode. In cbreak mode, |
characters typed by the user are made available immediately, and |
erase/kill character processing is not performed. In nocbreak mode, |
typed characters are buffered until a newline or carriage return. |
Interrupt and flow control characters are unaffected by this mode. |
PDCurses always starts in cbreak mode. |
echo() and noecho() control whether typed characters are echoed by |
the input routine. Initially, input characters are echoed. Subsequent |
calls to echo() and noecho() do not flush type-ahead. |
halfdelay() is similar to cbreak(), but allows for a time limit to be |
specified, in tenths of a second. This causes getch() to block for |
that period before returning ERR if no key has been received. tenths |
must be between 1 and 255. |
keypad() controls whether getch() returns function/special keys as |
single key codes (e.g., the left arrow key as KEY_LEFT). Per X/Open, |
the default for keypad mode is OFF. You'll probably want it on. With |
keypad mode off, if a special key is pressed, getch() does nothing or |
returns ERR. |
nodelay() controls whether wgetch() is a non-blocking call. If the |
option is enabled, and no input is ready, wgetch() will return ERR. |
If disabled, wgetch() will hang until input is ready. |
nl() enables the translation of a carriage return into a newline on |
input. nonl() disables this. Initially, the translation does occur. |
raw() and noraw() toggle raw mode. Raw mode is similar to cbreak |
mode, in that characters typed are immediately passed through to the |
user program. The difference is that in raw mode, the INTR, QUIT, |
SUSP, and STOP characters are passed through without being |
interpreted, and without generating a signal. |
In PDCurses, the meta() function sets raw mode on or off. |
timeout() and wtimeout() set blocking or non-blocking reads for the |
specified window. If the delay is negative, a blocking read is used; |
if zero, then non-blocking reads are done -- if no input is waiting, |
ERR is returned immediately. If the delay is positive, the read |
blocks for the delay period; if the period expires, ERR is returned. |
The delay is given in milliseconds, but this is rounded down to 50ms |
(1/20th sec) intervals, with a minimum of one interval if a postive |
delay is given; i.e., 1-99 will wait 50ms, 100-149 will wait 100ms, |
etc. |
intrflush(), notimeout(), noqiflush(), qiflush() and typeahead() do |
nothing in PDCurses, but are included for compatibility with other |
curses implementations. |
crmode() and nocrmode() are archaic equivalents to cbreak() and |
nocbreak(), respectively. |
is_keypad() reports whether the specified window is in keypad mode. |
### Return Value |
All functions except is_keypad() and the void functions return OK on |
success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
cbreak Y Y Y |
nocbreak Y Y Y |
echo Y Y Y |
noecho Y Y Y |
halfdelay Y Y Y |
intrflush Y Y Y |
keypad Y Y Y |
meta Y Y Y |
nl Y Y Y |
nonl Y Y Y |
nodelay Y Y Y |
notimeout Y Y Y |
raw Y Y Y |
noraw Y Y Y |
noqiflush Y Y Y |
qiflush Y Y Y |
timeout Y Y Y |
wtimeout Y Y Y |
typeahead Y Y Y |
crmode Y Y Y |
nocrmode Y Y Y |
is_keypad - Y Y |
**man-end****************************************************************/ |
int cbreak(void) |
{ |
PDC_LOG(("cbreak() - called\n")); |
if (!SP) |
return ERR; |
SP->cbreak = TRUE; |
return OK; |
} |
int nocbreak(void) |
{ |
PDC_LOG(("nocbreak() - called\n")); |
if (!SP) |
return ERR; |
SP->cbreak = FALSE; |
SP->delaytenths = 0; |
return OK; |
} |
int echo(void) |
{ |
PDC_LOG(("echo() - called\n")); |
if (!SP) |
return ERR; |
SP->echo = TRUE; |
return OK; |
} |
int noecho(void) |
{ |
PDC_LOG(("noecho() - called\n")); |
if (!SP) |
return ERR; |
SP->echo = FALSE; |
return OK; |
} |
int halfdelay(int tenths) |
{ |
PDC_LOG(("halfdelay() - called\n")); |
if (!SP || tenths < 1 || tenths > 255) |
return ERR; |
SP->delaytenths = tenths; |
return OK; |
} |
int intrflush(WINDOW *win, bool bf) |
{ |
PDC_LOG(("intrflush() - called\n")); |
return OK; |
} |
int keypad(WINDOW *win, bool bf) |
{ |
PDC_LOG(("keypad() - called\n")); |
if (!win) |
return ERR; |
win->_use_keypad = bf; |
return OK; |
} |
int meta(WINDOW *win, bool bf) |
{ |
PDC_LOG(("meta() - called\n")); |
if (!SP) |
return ERR; |
SP->raw_inp = bf; |
return OK; |
} |
int nl(void) |
{ |
PDC_LOG(("nl() - called\n")); |
if (!SP) |
return ERR; |
SP->autocr = TRUE; |
return OK; |
} |
int nonl(void) |
{ |
PDC_LOG(("nonl() - called\n")); |
if (!SP) |
return ERR; |
SP->autocr = FALSE; |
return OK; |
} |
int nodelay(WINDOW *win, bool flag) |
{ |
PDC_LOG(("nodelay() - called\n")); |
if (!win) |
return ERR; |
win->_nodelay = flag; |
return OK; |
} |
int notimeout(WINDOW *win, bool flag) |
{ |
PDC_LOG(("notimeout() - called\n")); |
return OK; |
} |
int raw(void) |
{ |
PDC_LOG(("raw() - called\n")); |
if (!SP) |
return ERR; |
PDC_set_keyboard_binary(TRUE); |
SP->raw_inp = TRUE; |
return OK; |
} |
int noraw(void) |
{ |
PDC_LOG(("noraw() - called\n")); |
if (!SP) |
return ERR; |
PDC_set_keyboard_binary(FALSE); |
SP->raw_inp = FALSE; |
return OK; |
} |
void noqiflush(void) |
{ |
PDC_LOG(("noqiflush() - called\n")); |
} |
void qiflush(void) |
{ |
PDC_LOG(("qiflush() - called\n")); |
} |
int typeahead(int fildes) |
{ |
PDC_LOG(("typeahead() - called\n")); |
return OK; |
} |
void wtimeout(WINDOW *win, int delay) |
{ |
PDC_LOG(("wtimeout() - called\n")); |
if (!win) |
return; |
if (delay < 0) |
{ |
/* This causes a blocking read on the window, so turn on delay |
mode */ |
win->_nodelay = FALSE; |
win->_delayms = 0; |
} |
else if (!delay) |
{ |
/* This causes a non-blocking read on the window, so turn off |
delay mode */ |
win->_nodelay = TRUE; |
win->_delayms = 0; |
} |
else |
{ |
/* This causes the read on the window to delay for the number of |
milliseconds. Also forces the window into non-blocking read |
mode */ |
/*win->_nodelay = TRUE;*/ |
win->_delayms = delay; |
} |
} |
void timeout(int delay) |
{ |
PDC_LOG(("timeout() - called\n")); |
wtimeout(stdscr, delay); |
} |
int crmode(void) |
{ |
PDC_LOG(("crmode() - called\n")); |
return cbreak(); |
} |
int nocrmode(void) |
{ |
PDC_LOG(("nocrmode() - called\n")); |
return nocbreak(); |
} |
bool is_keypad(const WINDOW *win) |
{ |
PDC_LOG(("is_keypad() - called\n")); |
if (!win) |
return FALSE; |
return win->_use_keypad; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/insch.c |
---|
0,0 → 1,270 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
insch |
----- |
### Synopsis |
int insch(chtype ch); |
int winsch(WINDOW *win, chtype ch); |
int mvinsch(int y, int x, chtype ch); |
int mvwinsch(WINDOW *win, int y, int x, chtype ch); |
int insrawch(chtype ch); |
int winsrawch(WINDOW *win, chtype ch); |
int mvinsrawch(int y, int x, chtype ch); |
int mvwinsrawch(WINDOW *win, int y, int x, chtype ch); |
int ins_wch(const cchar_t *wch); |
int wins_wch(WINDOW *win, const cchar_t *wch); |
int mvins_wch(int y, int x, const cchar_t *wch); |
int mvwins_wch(WINDOW *win, int y, int x, const cchar_t *wch); |
### Description |
The insch() functions insert a chtype into the window at the current |
or specified cursor position. The cursor is NOT advanced. A newline |
is equivalent to clrtoeol(); tabs are expanded; other control |
characters are converted as with unctrl(). |
The ins_wch() functions are the wide-character equivalents, taking |
cchar_t pointers rather than chtypes. |
Video attributes can be combined with a character by ORing them into |
the parameter. Text, including attributes, can be copied from one |
place to another using inch() and insch(). |
insrawch() etc. are PDCurses-specific wrappers for insch() etc. that |
disable the translation of control characters. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
insch Y Y Y |
winsch Y Y Y |
mvinsch Y Y Y |
mvwinsch Y Y Y |
ins_wch Y Y Y |
wins_wch Y Y Y |
mvins_wch Y Y Y |
mvwins_wch Y Y Y |
insrawch - - - |
winsrawch - - - |
**man-end****************************************************************/ |
#include <string.h> |
int winsch(WINDOW *win, chtype ch) |
{ |
int x, y; |
chtype attr; |
bool xlat; |
PDC_LOG(("winsch() - called: win=%p ch=%x (text=%c attr=0x%x)\n", |
win, ch, ch & A_CHARTEXT, ch & A_ATTRIBUTES)); |
if (!win) |
return ERR; |
x = win->_curx; |
y = win->_cury; |
if (y > win->_maxy || x > win->_maxx || y < 0 || x < 0) |
return ERR; |
xlat = !SP->raw_out && !(ch & A_ALTCHARSET); |
attr = ch & A_ATTRIBUTES; |
ch &= A_CHARTEXT; |
if (xlat && (ch < ' ' || ch == 0x7f)) |
{ |
int x2; |
switch (ch) |
{ |
case '\t': |
for (x2 = ((x / TABSIZE) + 1) * TABSIZE; x < x2; x++) |
{ |
if (winsch(win, attr | ' ') == ERR) |
return ERR; |
} |
return OK; |
case '\n': |
wclrtoeol(win); |
break; |
case 0x7f: |
if (winsch(win, attr | '?') == ERR) |
return ERR; |
return winsch(win, attr | '^'); |
default: |
/* handle control chars */ |
if (winsch(win, attr | (ch + '@')) == ERR) |
return ERR; |
return winsch(win, attr | '^'); |
} |
} |
else |
{ |
int maxx; |
chtype *temp; |
/* If the incoming character doesn't have its own attribute, |
then use the current attributes for the window. If it has |
attributes but not a color component, OR the attributes to |
the current attributes for the window. If it has a color |
component, use the attributes solely from the incoming |
character. */ |
if (!(attr & A_COLOR)) |
attr |= win->_attrs; |
/* wrs (4/10/93): Apply the same sort of logic for the window |
background, in that it only takes precedence if other color |
attributes are not there and that the background character |
will only print if the printing character is blank. */ |
if (!(attr & A_COLOR)) |
attr |= win->_bkgd & A_ATTRIBUTES; |
else |
attr |= win->_bkgd & (A_ATTRIBUTES ^ A_COLOR); |
if (ch == ' ') |
ch = win->_bkgd & A_CHARTEXT; |
/* Add the attribute back into the character. */ |
ch |= attr; |
maxx = win->_maxx; |
temp = &win->_y[y][x]; |
memmove(temp + 1, temp, (maxx - x - 1) * sizeof(chtype)); |
win->_lastch[y] = maxx - 1; |
if ((win->_firstch[y] == _NO_CHANGE) || (win->_firstch[y] > x)) |
win->_firstch[y] = x; |
*temp = ch; |
} |
PDC_sync(win); |
return OK; |
} |
int insch(chtype ch) |
{ |
PDC_LOG(("insch() - called\n")); |
return winsch(stdscr, ch); |
} |
int mvinsch(int y, int x, chtype ch) |
{ |
PDC_LOG(("mvinsch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return winsch(stdscr, ch); |
} |
int mvwinsch(WINDOW *win, int y, int x, chtype ch) |
{ |
PDC_LOG(("mvwinsch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winsch(win, ch); |
} |
int winsrawch(WINDOW *win, chtype ch) |
{ |
PDC_LOG(("winsrawch() - called: win=%p ch=%x " |
"(char=%c attr=0x%x)\n", win, ch, |
ch & A_CHARTEXT, ch & A_ATTRIBUTES)); |
if ((ch & A_CHARTEXT) < ' ' || (ch & A_CHARTEXT) == 0x7f) |
ch |= A_ALTCHARSET; |
return winsch(win, ch); |
} |
int insrawch(chtype ch) |
{ |
PDC_LOG(("insrawch() - called\n")); |
return winsrawch(stdscr, ch); |
} |
int mvinsrawch(int y, int x, chtype ch) |
{ |
PDC_LOG(("mvinsrawch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return winsrawch(stdscr, ch); |
} |
int mvwinsrawch(WINDOW *win, int y, int x, chtype ch) |
{ |
PDC_LOG(("mvwinsrawch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winsrawch(win, ch); |
} |
#ifdef PDC_WIDE |
int wins_wch(WINDOW *win, const cchar_t *wch) |
{ |
PDC_LOG(("wins_wch() - called\n")); |
return wch ? winsch(win, *wch) : ERR; |
} |
int ins_wch(const cchar_t *wch) |
{ |
PDC_LOG(("ins_wch() - called\n")); |
return wins_wch(stdscr, wch); |
} |
int mvins_wch(int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvins_wch() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wins_wch(stdscr, wch); |
} |
int mvwins_wch(WINDOW *win, int y, int x, const cchar_t *wch) |
{ |
PDC_LOG(("mvwins_wch() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wins_wch(win, wch); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/insstr.c |
---|
0,0 → 1,263 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
insstr |
------ |
### Synopsis |
int insstr(const char *str); |
int insnstr(const char *str, int n); |
int winsstr(WINDOW *win, const char *str); |
int winsnstr(WINDOW *win, const char *str, int n); |
int mvinsstr(int y, int x, const char *str); |
int mvinsnstr(int y, int x, const char *str, int n); |
int mvwinsstr(WINDOW *win, int y, int x, const char *str); |
int mvwinsnstr(WINDOW *win, int y, int x, const char *str, int n); |
int ins_wstr(const wchar_t *wstr); |
int ins_nwstr(const wchar_t *wstr, int n); |
int wins_wstr(WINDOW *win, const wchar_t *wstr); |
int wins_nwstr(WINDOW *win, const wchar_t *wstr, int n); |
int mvins_wstr(int y, int x, const wchar_t *wstr); |
int mvins_nwstr(int y, int x, const wchar_t *wstr, int n); |
int mvwins_wstr(WINDOW *win, int y, int x, const wchar_t *wstr); |
int mvwins_nwstr(WINDOW *win, int y, int x, const wchar_t *wstr, int n); |
### Description |
The insstr() functions insert a character string into a window at the |
current cursor position, by repeatedly calling winsch(). When |
PDCurses is built with wide-character support enabled, the narrow- |
character functions treat the string as a multibyte string in the |
current locale, and convert it first. All characters to the right of |
the cursor are moved to the right, with the possibility of the |
rightmost characters on the line being lost. The cursor position |
does not change (after moving to y, x, if specified). The routines |
with n as the last argument insert at most n characters; if n is |
negative, then the entire string is inserted. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
insstr Y Y Y |
winsstr Y Y Y |
mvinsstr Y Y Y |
mvwinsstr Y Y Y |
insnstr Y Y Y |
winsnstr Y Y Y |
mvinsnstr Y Y Y |
mvwinsnstr Y Y Y |
ins_wstr Y Y Y |
wins_wstr Y Y Y |
mvins_wstr Y Y Y |
mvwins_wstr Y Y Y |
ins_nwstr Y Y Y |
wins_nwstr Y Y Y |
mvins_nwstr Y Y Y |
mvwins_nwstr Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
int winsnstr(WINDOW *win, const char *str, int n) |
{ |
#ifdef PDC_WIDE |
wchar_t wstr[513], *p; |
int i; |
#endif |
int len; |
PDC_LOG(("winsnstr() - called: string=\"%s\" n %d \n", str, n)); |
if (!win || !str) |
return ERR; |
len = strlen(str); |
if (n < 0 || n > len) |
n = len; |
#ifdef PDC_WIDE |
if (n > 512) |
n = 512; |
p = wstr; |
i = 0; |
while (str[i] && i < n) |
{ |
int retval = PDC_mbtowc(p, str + i, n - i); |
if (retval <= 0) |
break; |
p++; |
i += retval; |
} |
while (p > wstr) |
if (winsch(win, *--p) == ERR) |
#else |
while (n) |
if (winsch(win, (unsigned char)(str[--n])) == ERR) |
#endif |
return ERR; |
return OK; |
} |
int insstr(const char *str) |
{ |
PDC_LOG(("insstr() - called: string=\"%s\"\n", str)); |
return winsnstr(stdscr, str, -1); |
} |
int winsstr(WINDOW *win, const char *str) |
{ |
PDC_LOG(("winsstr() - called: string=\"%s\"\n", str)); |
return winsnstr(win, str, -1); |
} |
int mvinsstr(int y, int x, const char *str) |
{ |
PDC_LOG(("mvinsstr() - called: y %d x %d string=\"%s\"\n", y, x, str)); |
if (move(y, x) == ERR) |
return ERR; |
return winsnstr(stdscr, str, -1); |
} |
int mvwinsstr(WINDOW *win, int y, int x, const char *str) |
{ |
PDC_LOG(("mvwinsstr() - called: string=\"%s\"\n", str)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winsnstr(win, str, -1); |
} |
int insnstr(const char *str, int n) |
{ |
PDC_LOG(("insnstr() - called: string=\"%s\" n %d \n", str, n)); |
return winsnstr(stdscr, str, n); |
} |
int mvinsnstr(int y, int x, const char *str, int n) |
{ |
PDC_LOG(("mvinsnstr() - called: y %d x %d string=\"%s\" n %d \n", |
y, x, str, n)); |
if (move(y, x) == ERR) |
return ERR; |
return winsnstr(stdscr, str, n); |
} |
int mvwinsnstr(WINDOW *win, int y, int x, const char *str, int n) |
{ |
PDC_LOG(("mvwinsnstr() - called: y %d x %d string=\"%s\" n %d \n", |
y, x, str, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winsnstr(win, str, n); |
} |
#ifdef PDC_WIDE |
int wins_nwstr(WINDOW *win, const wchar_t *wstr, int n) |
{ |
const wchar_t *p; |
int len; |
PDC_LOG(("wins_nwstr() - called\n")); |
if (!win || !wstr) |
return ERR; |
for (len = 0, p = wstr; *p; p++) |
len++; |
if (n < 0 || n > len) |
n = len; |
while (n) |
if (winsch(win, wstr[--n]) == ERR) |
return ERR; |
return OK; |
} |
int ins_wstr(const wchar_t *wstr) |
{ |
PDC_LOG(("ins_wstr() - called\n")); |
return wins_nwstr(stdscr, wstr, -1); |
} |
int wins_wstr(WINDOW *win, const wchar_t *wstr) |
{ |
PDC_LOG(("wins_wstr() - called\n")); |
return wins_nwstr(win, wstr, -1); |
} |
int mvins_wstr(int y, int x, const wchar_t *wstr) |
{ |
PDC_LOG(("mvins_wstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wins_nwstr(stdscr, wstr, -1); |
} |
int mvwins_wstr(WINDOW *win, int y, int x, const wchar_t *wstr) |
{ |
PDC_LOG(("mvwinsstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wins_nwstr(win, wstr, -1); |
} |
int ins_nwstr(const wchar_t *wstr, int n) |
{ |
PDC_LOG(("ins_nwstr() - called\n")); |
return wins_nwstr(stdscr, wstr, n); |
} |
int mvins_nwstr(int y, int x, const wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvinsnstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return wins_nwstr(stdscr, wstr, n); |
} |
int mvwins_nwstr(WINDOW *win, int y, int x, const wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvwinsnstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return wins_nwstr(win, wstr, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/instr.c |
---|
0,0 → 1,245 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
instr |
----- |
### Synopsis |
int instr(char *str); |
int innstr(char *str, int n); |
int winstr(WINDOW *win, char *str); |
int winnstr(WINDOW *win, char *str, int n); |
int mvinstr(int y, int x, char *str); |
int mvinnstr(int y, int x, char *str, int n); |
int mvwinstr(WINDOW *win, int y, int x, char *str); |
int mvwinnstr(WINDOW *win, int y, int x, char *str, int n); |
int inwstr(wchar_t *wstr); |
int innwstr(wchar_t *wstr, int n); |
int winwstr(WINDOW *win, wchar_t *wstr); |
int winnwstr(WINDOW *win, wchar_t *wstr, int n); |
int mvinwstr(int y, int x, wchar_t *wstr); |
int mvinnwstr(int y, int x, wchar_t *wstr, int n); |
int mvwinwstr(WINDOW *win, int y, int x, wchar_t *wstr); |
int mvwinnwstr(WINDOW *win, int y, int x, wchar_t *wstr, int n); |
### Description |
These functions take characters (or wide characters) from the current |
or specified position in the window, and return them as a string in |
str (or wstr). Attributes are ignored. The functions with n as the |
last argument return a string at most n characters long. |
### Return Value |
Upon successful completion, innstr(), mvinnstr(), mvwinnstr() and |
winnstr() return the number of characters actually read into the |
string; instr(), mvinstr(), mvwinstr() and winstr() return OK. |
Otherwise, all these functions return ERR. |
### Portability |
X/Open ncurses NetBSD |
instr Y Y Y |
winstr Y Y Y |
mvinstr Y Y Y |
mvwinstr Y Y Y |
innstr Y Y Y |
winnstr Y Y Y |
mvinnstr Y Y Y |
mvwinnstr Y Y Y |
inwstr Y Y Y |
winwstr Y Y Y |
mvinwstr Y Y Y |
mvwinwstr Y Y Y |
innwstr Y Y Y |
winnwstr Y Y Y |
mvinnwstr Y Y Y |
mvwinnwstr Y Y Y |
**man-end****************************************************************/ |
int winnstr(WINDOW *win, char *str, int n) |
{ |
#ifdef PDC_WIDE |
wchar_t wstr[513]; |
if (n < 0 || n > 512) |
n = 512; |
if (winnwstr(win, wstr, n) == ERR) |
return ERR; |
return PDC_wcstombs(str, wstr, n); |
#else |
chtype *src; |
int i; |
PDC_LOG(("winnstr() - called: n %d \n", n)); |
if (!win || !str) |
return ERR; |
if (n < 0 || (win->_curx + n) > win->_maxx) |
n = win->_maxx - win->_curx; |
src = win->_y[win->_cury] + win->_curx; |
for (i = 0; i < n; i++) |
str[i] = src[i] & A_CHARTEXT; |
str[i] = '\0'; |
return i; |
#endif |
} |
int instr(char *str) |
{ |
PDC_LOG(("instr() - called: string=\"%s\"\n", str)); |
return (ERR == winnstr(stdscr, str, stdscr->_maxx)) ? ERR : OK; |
} |
int winstr(WINDOW *win, char *str) |
{ |
PDC_LOG(("winstr() - called: \n")); |
return (ERR == winnstr(win, str, win->_maxx)) ? ERR : OK; |
} |
int mvinstr(int y, int x, char *str) |
{ |
PDC_LOG(("mvinstr() - called: y %d x %d \n", y, x)); |
if (move(y, x) == ERR) |
return ERR; |
return (ERR == winnstr(stdscr, str, stdscr->_maxx)) ? ERR : OK; |
} |
int mvwinstr(WINDOW *win, int y, int x, char *str) |
{ |
PDC_LOG(("mvwinstr() - called: y %d x %d \n", y, x)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return (ERR == winnstr(win, str, win->_maxx)) ? ERR : OK; |
} |
int innstr(char *str, int n) |
{ |
PDC_LOG(("innstr() - called: n %d \n", n)); |
return winnstr(stdscr, str, n); |
} |
int mvinnstr(int y, int x, char *str, int n) |
{ |
PDC_LOG(("mvinnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (move(y, x) == ERR) |
return ERR; |
return winnstr(stdscr, str, n); |
} |
int mvwinnstr(WINDOW *win, int y, int x, char *str, int n) |
{ |
PDC_LOG(("mvwinnstr() - called: y %d x %d n %d \n", y, x, n)); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winnstr(win, str, n); |
} |
#ifdef PDC_WIDE |
int winnwstr(WINDOW *win, wchar_t *wstr, int n) |
{ |
chtype *src; |
int i; |
PDC_LOG(("winnstr() - called: n %d \n", n)); |
if (!win || !wstr) |
return ERR; |
if (n < 0 || (win->_curx + n) > win->_maxx) |
n = win->_maxx - win->_curx; |
src = win->_y[win->_cury] + win->_curx; |
for (i = 0; i < n; i++) |
wstr[i] = src[i] & A_CHARTEXT; |
wstr[i] = L'\0'; |
return i; |
} |
int inwstr(wchar_t *wstr) |
{ |
PDC_LOG(("inwstr() - called\n")); |
return (ERR == winnwstr(stdscr, wstr, stdscr->_maxx)) ? ERR : OK; |
} |
int winwstr(WINDOW *win, wchar_t *wstr) |
{ |
PDC_LOG(("winwstr() - called\n")); |
return (ERR == winnwstr(win, wstr, win->_maxx)) ? ERR : OK; |
} |
int mvinwstr(int y, int x, wchar_t *wstr) |
{ |
PDC_LOG(("mvinwstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return (ERR == winnwstr(stdscr, wstr, stdscr->_maxx)) ? ERR : OK; |
} |
int mvwinwstr(WINDOW *win, int y, int x, wchar_t *wstr) |
{ |
PDC_LOG(("mvwinstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return (ERR == winnwstr(win, wstr, win->_maxx)) ? ERR : OK; |
} |
int innwstr(wchar_t *wstr, int n) |
{ |
PDC_LOG(("innwstr() - called\n")); |
return winnwstr(stdscr, wstr, n); |
} |
int mvinnwstr(int y, int x, wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvinnstr() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
return winnwstr(stdscr, wstr, n); |
} |
int mvwinnwstr(WINDOW *win, int y, int x, wchar_t *wstr, int n) |
{ |
PDC_LOG(("mvwinnwstr() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
return winnwstr(win, wstr, n); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/kernel.c |
---|
0,0 → 1,297 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
kernel |
------ |
### Synopsis |
int def_prog_mode(void); |
int def_shell_mode(void); |
int reset_prog_mode(void); |
int reset_shell_mode(void); |
int resetty(void); |
int savetty(void); |
int ripoffline(int line, int (*init)(WINDOW *, int)); |
int curs_set(int visibility); |
int napms(int ms); |
int draino(int ms); |
int resetterm(void); |
int fixterm(void); |
int saveterm(void); |
### Description |
def_prog_mode() and def_shell_mode() save the current terminal modes |
as the "program" (in curses) or "shell" (not in curses) state for use |
by the reset_prog_mode() and reset_shell_mode() functions. This is |
done automatically by initscr(). |
reset_prog_mode() and reset_shell_mode() restore the terminal to |
"program" (in curses) or "shell" (not in curses) state. These are |
done automatically by endwin() and doupdate() after an endwin(), so |
they would normally not be called before these functions. |
savetty() and resetty() save and restore the state of the terminal |
modes. savetty() saves the current state in a buffer, and resetty() |
restores the state to what it was at the last call to savetty(). |
curs_set() alters the appearance of the cursor. A visibility of 0 |
makes it disappear; 1 makes it appear "normal" (usually an underline) |
and 2 makes it "highly visible" (usually a block). |
ripoffline() reduces the size of stdscr by one line. If the "line" |
parameter is positive, the line is removed from the top of the |
screen; if negative, from the bottom. Up to 5 lines can be ripped off |
stdscr by calling ripoffline() repeatedly. The function argument, |
init, is called from within initscr() or newterm(), so ripoffline() |
must be called before either of these functions. The init function |
receives a pointer to a one-line WINDOW, and the width of the window. |
Calling ripoffline() with a NULL init function pointer is an error. |
napms() suspends the program for the specified number of |
milliseconds. draino() is an archaic equivalent. Note that since |
napms() attempts to give up a time slice and yield control back to |
the OS, all times are approximate. (In DOS, the delay is actually |
rounded down to 50ms (1/20th sec) intervals, with a minimum of one |
interval; i.e., 1-99 will wait 50ms, 100-149 will wait 100ms, etc.) |
0 returns immediately. |
resetterm(), fixterm() and saveterm() are archaic equivalents for |
reset_shell_mode(), reset_prog_mode() and def_prog_mode(), |
respectively. |
### Return Value |
All functions return OK on success and ERR on error, except |
curs_set(), which returns the previous visibility. |
### Portability |
X/Open ncurses NetBSD |
def_prog_mode Y Y Y |
def_shell_mode Y Y Y |
reset_prog_mode Y Y Y |
reset_shell_mode Y Y Y |
resetty Y Y Y |
savetty Y Y Y |
ripoffline Y Y Y |
curs_set Y Y Y |
napms Y Y Y |
fixterm - Y - |
resetterm - Y - |
saveterm - Y - |
draino - - - |
**man-end****************************************************************/ |
#include <string.h> |
RIPPEDOFFLINE linesripped[5]; |
char linesrippedoff = 0; |
static struct cttyset |
{ |
bool been_set; |
SCREEN saved; |
} ctty[3]; |
enum { PDC_SH_TTY, PDC_PR_TTY, PDC_SAVE_TTY }; |
static void _save_mode(int i) |
{ |
ctty[i].been_set = TRUE; |
memcpy(&(ctty[i].saved), SP, sizeof(SCREEN)); |
PDC_save_screen_mode(i); |
} |
static int _restore_mode(int i) |
{ |
if (ctty[i].been_set == TRUE) |
{ |
memcpy(SP, &(ctty[i].saved), sizeof(SCREEN)); |
if (ctty[i].saved.raw_out) |
raw(); |
PDC_restore_screen_mode(i); |
if ((LINES != ctty[i].saved.lines) || |
(COLS != ctty[i].saved.cols)) |
resize_term(ctty[i].saved.lines, ctty[i].saved.cols); |
PDC_curs_set(ctty[i].saved.visibility); |
PDC_gotoyx(ctty[i].saved.cursrow, ctty[i].saved.curscol); |
} |
return ctty[i].been_set ? OK : ERR; |
} |
int def_prog_mode(void) |
{ |
PDC_LOG(("def_prog_mode() - called\n")); |
if (!SP) |
return ERR; |
_save_mode(PDC_PR_TTY); |
return OK; |
} |
int def_shell_mode(void) |
{ |
PDC_LOG(("def_shell_mode() - called\n")); |
if (!SP) |
return ERR; |
_save_mode(PDC_SH_TTY); |
return OK; |
} |
int reset_prog_mode(void) |
{ |
PDC_LOG(("reset_prog_mode() - called\n")); |
if (!SP) |
return ERR; |
_restore_mode(PDC_PR_TTY); |
PDC_reset_prog_mode(); |
return OK; |
} |
int reset_shell_mode(void) |
{ |
PDC_LOG(("reset_shell_mode() - called\n")); |
if (!SP) |
return ERR; |
_restore_mode(PDC_SH_TTY); |
PDC_reset_shell_mode(); |
return OK; |
} |
int resetty(void) |
{ |
PDC_LOG(("resetty() - called\n")); |
if (!SP) |
return ERR; |
return _restore_mode(PDC_SAVE_TTY); |
} |
int savetty(void) |
{ |
PDC_LOG(("savetty() - called\n")); |
if (!SP) |
return ERR; |
_save_mode(PDC_SAVE_TTY); |
return OK; |
} |
int curs_set(int visibility) |
{ |
int ret_vis; |
PDC_LOG(("curs_set() - called: visibility=%d\n", visibility)); |
if (!SP || visibility < 0 || visibility > 2) |
return ERR; |
ret_vis = PDC_curs_set(visibility); |
/* If the cursor is changing from invisible to visible, update |
its position */ |
if (visibility && !ret_vis) |
PDC_gotoyx(SP->cursrow, SP->curscol); |
return ret_vis; |
} |
int napms(int ms) |
{ |
PDC_LOG(("napms() - called: ms=%d\n", ms)); |
if (!SP) |
return ERR; |
if (SP->dirty) |
{ |
int curs_state = SP->visibility; |
bool leave_state = is_leaveok(curscr); |
SP->dirty = FALSE; |
leaveok(curscr, TRUE); |
wrefresh(curscr); |
leaveok(curscr, leave_state); |
curs_set(curs_state); |
} |
if (ms) |
PDC_napms(ms); |
return OK; |
} |
int ripoffline(int line, int (*init)(WINDOW *, int)) |
{ |
PDC_LOG(("ripoffline() - called: line=%d\n", line)); |
if (linesrippedoff < 5 && line && init) |
{ |
linesripped[(int)linesrippedoff].line = line; |
linesripped[(int)linesrippedoff++].init = init; |
return OK; |
} |
return ERR; |
} |
int draino(int ms) |
{ |
PDC_LOG(("draino() - called\n")); |
return napms(ms); |
} |
int resetterm(void) |
{ |
PDC_LOG(("resetterm() - called\n")); |
return reset_shell_mode(); |
} |
int fixterm(void) |
{ |
PDC_LOG(("fixterm() - called\n")); |
return reset_prog_mode(); |
} |
int saveterm(void) |
{ |
PDC_LOG(("saveterm() - called\n")); |
return def_prog_mode(); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/keyname.c |
---|
0,0 → 1,129 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
keyname |
------- |
### Synopsis |
char *keyname(int key); |
char *key_name(wchar_t c); |
bool has_key(int key); |
### Description |
keyname() returns a string corresponding to the argument key. key may |
be any key returned by wgetch(). |
key_name() is the wide-character version. It takes a wchar_t |
parameter, but still returns a char *. |
has_key() returns TRUE for recognized keys, FALSE otherwise. This |
function is an ncurses extension. |
### Portability |
X/Open ncurses NetBSD |
keyname Y Y Y |
key_name Y Y Y |
has_key - Y Y |
**man-end****************************************************************/ |
#include <string.h> |
static const char *names[] = |
{ |
"KEY_BREAK", "KEY_DOWN", "KEY_UP", "KEY_LEFT", "KEY_RIGHT", |
"KEY_HOME", "KEY_BACKSPACE", "KEY_F0", "KEY_F(1)", "KEY_F(2)", |
"KEY_F(3)", "KEY_F(4)", "KEY_F(5)", "KEY_F(6)", "KEY_F(7)", |
"KEY_F(8)", "KEY_F(9)", "KEY_F(10)", "KEY_F(11)", "KEY_F(12)", |
"KEY_F(13)", "KEY_F(14)", "KEY_F(15)", "KEY_F(16)", "KEY_F(17)", |
"KEY_F(18)", "KEY_F(19)", "KEY_F(20)", "KEY_F(21)", "KEY_F(22)", |
"KEY_F(23)", "KEY_F(24)", "KEY_F(25)", "KEY_F(26)", "KEY_F(27)", |
"KEY_F(28)", "KEY_F(29)", "KEY_F(30)", "KEY_F(31)", "KEY_F(32)", |
"KEY_F(33)", "KEY_F(34)", "KEY_F(35)", "KEY_F(36)", "KEY_F(37)", |
"KEY_F(38)", "KEY_F(39)", "KEY_F(40)", "KEY_F(41)", "KEY_F(42)", |
"KEY_F(43)", "KEY_F(44)", "KEY_F(45)", "KEY_F(46)", "KEY_F(47)", |
"KEY_F(48)", "KEY_F(49)", "KEY_F(50)", "KEY_F(51)", "KEY_F(52)", |
"KEY_F(53)", "KEY_F(54)", "KEY_F(55)", "KEY_F(56)", "KEY_F(57)", |
"KEY_F(58)", "KEY_F(59)", "KEY_F(60)", "KEY_F(61)", "KEY_F(62)", |
"KEY_F(63)", "KEY_DL", "KEY_IL", "KEY_DC", "KEY_IC", "KEY_EIC", |
"KEY_CLEAR", "KEY_EOS", "KEY_EOL", "KEY_SF", "KEY_SR", "KEY_NPAGE", |
"KEY_PPAGE", "KEY_STAB", "KEY_CTAB", "KEY_CATAB", "KEY_ENTER", |
"KEY_SRESET", "KEY_RESET", "KEY_PRINT", "KEY_LL", "KEY_ABORT", |
"KEY_SHELP", "KEY_LHELP", "KEY_BTAB", "KEY_BEG", "KEY_CANCEL", |
"KEY_CLOSE", "KEY_COMMAND", "KEY_COPY", "KEY_CREATE", "KEY_END", |
"KEY_EXIT", "KEY_FIND", "KEY_HELP", "KEY_MARK", "KEY_MESSAGE", |
"KEY_MOVE", "KEY_NEXT", "KEY_OPEN", "KEY_OPTIONS", "KEY_PREVIOUS", |
"KEY_REDO", "KEY_REFERENCE", "KEY_REFRESH", "KEY_REPLACE", |
"KEY_RESTART", "KEY_RESUME", "KEY_SAVE", "KEY_SBEG", "KEY_SCANCEL", |
"KEY_SCOMMAND", "KEY_SCOPY", "KEY_SCREATE", "KEY_SDC", "KEY_SDL", |
"KEY_SELECT", "KEY_SEND", "KEY_SEOL", "KEY_SEXIT", "KEY_SFIND", |
"KEY_SHOME", "KEY_SIC", "UNKNOWN KEY", "KEY_SLEFT", "KEY_SMESSAGE", |
"KEY_SMOVE", "KEY_SNEXT", "KEY_SOPTIONS", "KEY_SPREVIOUS", |
"KEY_SPRINT", "KEY_SREDO", "KEY_SREPLACE", "KEY_SRIGHT", |
"KEY_SRSUME", "KEY_SSAVE", "KEY_SSUSPEND", "KEY_SUNDO", |
"KEY_SUSPEND", "KEY_UNDO", "ALT_0", "ALT_1", "ALT_2", "ALT_3", |
"ALT_4", "ALT_5", "ALT_6", "ALT_7", "ALT_8", "ALT_9", "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", "CTL_LEFT", "CTL_RIGHT", |
"CTL_PGUP", "CTL_PGDN", "CTL_HOME", "CTL_END", "KEY_A1", "KEY_A2", |
"KEY_A3", "KEY_B1", "KEY_B2", "KEY_B3", "KEY_C1", "KEY_C2", |
"KEY_C3", "PADSLASH", "PADENTER", "CTL_PADENTER", "ALT_PADENTER", |
"PADSTOP", "PADSTAR", "PADMINUS", "PADPLUS", "CTL_PADSTOP", |
"CTL_PADCENTER", "CTL_PADPLUS", "CTL_PADMINUS", "CTL_PADSLASH", |
"CTL_PADSTAR", "ALT_PADPLUS", "ALT_PADMINUS", "ALT_PADSLASH", |
"ALT_PADSTAR", "ALT_PADSTOP", "CTL_INS", "ALT_DEL", "ALT_INS", |
"CTL_UP", "CTL_DOWN", "CTL_TAB", "ALT_TAB", "ALT_MINUS", |
"ALT_EQUAL", "ALT_HOME", "ALT_PGUP", "ALT_PGDN", "ALT_END", |
"ALT_UP", "ALT_DOWN", "ALT_RIGHT", "ALT_LEFT", "ALT_ENTER", |
"ALT_ESC", "ALT_BQUOTE", "ALT_LBRACKET", "ALT_RBRACKET", |
"ALT_SEMICOLON", "ALT_FQUOTE", "ALT_COMMA", "ALT_STOP", |
"ALT_FSLASH", "ALT_BKSP", "CTL_BKSP", "PAD0", "CTL_PAD0", |
"CTL_PAD1", "CTL_PAD2", "CTL_PAD3", "CTL_PAD4", "CTL_PAD5", |
"CTL_PAD6", "CTL_PAD7","CTL_PAD8", "CTL_PAD9", "ALT_PAD0", |
"ALT_PAD1", "ALT_PAD2", "ALT_PAD3", "ALT_PAD4", "ALT_PAD5", |
"ALT_PAD6", "ALT_PAD7", "ALT_PAD8", "ALT_PAD9", "CTL_DEL", |
"ALT_BSLASH", "CTL_ENTER", "SHF_PADENTER", "SHF_PADSLASH", |
"SHF_PADSTAR", "SHF_PADPLUS", "SHF_PADMINUS", "SHF_UP", "SHF_DOWN", |
"SHF_IC", "SHF_DC", "KEY_MOUSE", "KEY_SHIFT_L", "KEY_SHIFT_R", |
"KEY_CONTROL_L", "KEY_CONTROL_R", "KEY_ALT_L", "KEY_ALT_R", |
"KEY_RESIZE", "KEY_SUP", "KEY_SDOWN" |
}; |
char *keyname(int key) |
{ |
static char _keyname[14]; |
/* Key names must be in exactly the same order as in curses.h */ |
PDC_LOG(("keyname() - called: key %d\n", key)); |
strcpy(_keyname, ((key >= 0) && (key < 0x80)) ? unctrl((chtype)key) : |
has_key(key) ? names[key - KEY_MIN] : "UNKNOWN KEY"); |
return _keyname; |
} |
bool has_key(int key) |
{ |
PDC_LOG(("has_key() - called: key %d\n", key)); |
return (key >= KEY_MIN && key <= KEY_MAX); |
} |
#ifdef PDC_WIDE |
char *key_name(wchar_t c) |
{ |
PDC_LOG(("key_name() - called\n")); |
return keyname((int)c); |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/mouse.c |
---|
0,0 → 1,421 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
mouse |
----- |
### Synopsis |
int mouse_set(mmask_t mbe); |
int mouse_on(mmask_t mbe); |
int mouse_off(mmask_t mbe); |
int request_mouse_pos(void); |
void wmouse_position(WINDOW *win, int *y, int *x); |
mmask_t getmouse(void); |
int mouseinterval(int wait); |
bool wenclose(const WINDOW *win, int y, int x); |
bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen); |
bool mouse_trafo(int *y, int *x, bool to_screen); |
mmask_t mousemask(mmask_t mask, mmask_t *oldmask); |
int nc_getmouse(MEVENT *event); |
int ungetmouse(MEVENT *event); |
bool has_mouse(void); |
### Description |
As of PDCurses 3.0, there are two separate mouse interfaces: the |
classic interface, which is based on the undocumented Sys V mouse |
functions; and an ncurses-compatible interface. Both are active at |
all times, and you can mix and match functions from each, though it's |
not recommended. The ncurses interface is essentially an emulation |
layer built on top of the classic interface; it's here to allow |
easier porting of ncurses apps. |
The classic interface: mouse_set(), mouse_on(), mouse_off(), |
request_mouse_pos(), wmouse_position(), and getmouse(). An |
application using this interface would start by calling mouse_set() |
or mouse_on() with a non-zero value, often ALL_MOUSE_EVENTS. Then it |
would check for a KEY_MOUSE return from getch(). If found, it would |
call request_mouse_pos() to get the current mouse status. |
mouse_set(), mouse_on() and mouse_off() are analagous to attrset(), |
attron() and attroff(). These functions set the mouse button events |
to trap. The button masks used in these functions are defined in |
curses.h and can be or'ed together. They are the group of masks |
starting with BUTTON1_RELEASED. |
request_mouse_pos() requests curses to fill in the Mouse_status |
structure with the current state of the mouse. |
wmouse_position() determines if the current mouse position is within |
the window passed as an argument. If the mouse is outside the current |
window, -1 is returned in the y and x arguments; otherwise the y and |
x coordinates of the mouse (relative to the top left corner of the |
window) are returned in y and x. |
getmouse() returns the current status of the trapped mouse buttons as |
set by mouse_set() or mouse_on(). |
The ncurses interface: mouseinterval(), wenclose(), wmouse_trafo(), |
mouse_trafo(), mousemask(), nc_getmouse(), ungetmouse() and |
has_mouse(). A typical application using this interface would start |
by calling mousemask() with a non-zero value, often ALL_MOUSE_EVENTS. |
Then it would check for a KEY_MOUSE return from getch(). If found, it |
would call nc_getmouse() to get the current mouse status. |
mouseinterval() sets the timeout for a mouse click. On all current |
platforms, PDCurses receives mouse button press and release events, |
but must synthesize click events. It does this by checking whether a |
release event is queued up after a press event. If it gets a press |
event, and there are no more events waiting, it will wait for the |
timeout interval, then check again for a release. A press followed by |
a release is reported as BUTTON_CLICKED; otherwise it's passed |
through as BUTTON_PRESSED. The default timeout is 150ms; valid values |
are 0 (no clicks reported) through 1000ms. In x11, the timeout can |
also be set via the clickPeriod resource. The return value from |
mouseinterval() is the old timeout. To check the old value without |
setting a new one, call it with a parameter of -1. Note that although |
there's no classic equivalent for this function (apart from the |
clickPeriod resource), the value set applies in both interfaces. |
wenclose() reports whether the given screen-relative y, x coordinates |
fall within the given window. |
wmouse_trafo() converts between screen-relative and window-relative |
coordinates. A to_screen parameter of TRUE means to convert from |
window to screen; otherwise the reverse. The function returns FALSE |
if the coordinates aren't within the window, or if any of the |
parameters are NULL. The coordinates have been converted when the |
function returns TRUE. |
mouse_trafo() is the stdscr version of wmouse_trafo(). |
mousemask() is nearly equivalent to mouse_set(), but instead of |
OK/ERR, it returns the value of the mask after setting it. (This |
isn't necessarily the same value passed in, since the mask could be |
altered on some platforms.) And if the second parameter is a non-null |
pointer, mousemask() stores the previous mask value there. Also, |
since the ncurses interface doesn't work with PDCurses' BUTTON_MOVED |
events, mousemask() filters them out. |
nc_getmouse() returns the current mouse status in an MEVENT struct. |
This is equivalent to ncurses' getmouse(), renamed to avoid conflict |
with PDCurses' getmouse(). But if you define PDC_NCMOUSE before |
including curses.h, it defines getmouse() to nc_getmouse(), along |
with a few other redefintions needed for compatibility with ncurses |
code. nc_getmouse() calls request_mouse_pos(), which (not getmouse()) |
is the classic equivalent. |
ungetmouse() is the mouse equivalent of ungetch(). However, PDCurses |
doesn't maintain a queue of mouse events; only one can be pushed |
back, and it can overwrite or be overwritten by real mouse events. |
has_mouse() reports whether the mouse is available at all on the |
current platform. |
### Portability |
X/Open ncurses NetBSD |
mouse_set - - - |
mouse_on - - - |
mouse_off - - - |
request_mouse_pos - - - |
wmouse_position - - - |
getmouse - * - |
mouseinterval - Y - |
wenclose - Y - |
wmouse_trafo - Y - |
mouse_trafo - Y - |
mousemask - Y - |
nc_getmouse - * - |
ungetmouse - Y - |
has_mouse - Y - |
* See above, under Description |
**man-end****************************************************************/ |
#include <string.h> |
static bool ungot = FALSE; |
int mouse_set(mmask_t mbe) |
{ |
PDC_LOG(("mouse_set() - called: event %x\n", mbe)); |
if (!SP) |
return ERR; |
SP->_trap_mbe = mbe; |
return PDC_mouse_set(); |
} |
int mouse_on(mmask_t mbe) |
{ |
PDC_LOG(("mouse_on() - called: event %x\n", mbe)); |
if (!SP) |
return ERR; |
SP->_trap_mbe |= mbe; |
return PDC_mouse_set(); |
} |
int mouse_off(mmask_t mbe) |
{ |
PDC_LOG(("mouse_off() - called: event %x\n", mbe)); |
if (!SP) |
return ERR; |
SP->_trap_mbe &= ~mbe; |
return PDC_mouse_set(); |
} |
int request_mouse_pos(void) |
{ |
PDC_LOG(("request_mouse_pos() - called\n")); |
Mouse_status = SP->mouse_status; |
return OK; |
} |
void wmouse_position(WINDOW *win, int *y, int *x) |
{ |
PDC_LOG(("wmouse_position() - called\n")); |
if (win && wenclose(win, MOUSE_Y_POS, MOUSE_X_POS)) |
{ |
if (y) |
*y = MOUSE_Y_POS - win->_begy; |
if (x) |
*x = MOUSE_X_POS - win->_begx; |
} |
else |
{ |
if (y) |
*y = -1; |
if (x) |
*x = -1; |
} |
} |
mmask_t getmouse(void) |
{ |
PDC_LOG(("getmouse() - called\n")); |
return SP ? SP->_trap_mbe : (mmask_t)0; |
} |
/* ncurses mouse interface */ |
int mouseinterval(int wait) |
{ |
int old_wait; |
PDC_LOG(("mouseinterval() - called: %d\n", wait)); |
if (!SP) |
return ERR; |
old_wait = SP->mouse_wait; |
if (wait >= 0 && wait <= 1000) |
SP->mouse_wait = wait; |
return old_wait; |
} |
bool wenclose(const WINDOW *win, int y, int x) |
{ |
PDC_LOG(("wenclose() - called: %p %d %d\n", win, y, x)); |
return (win && y >= win->_begy && y < win->_begy + win->_maxy |
&& x >= win->_begx && x < win->_begx + win->_maxx); |
} |
bool wmouse_trafo(const WINDOW *win, int *y, int *x, bool to_screen) |
{ |
int newy, newx; |
PDC_LOG(("wmouse_trafo() - called\n")); |
if (!win || !y || !x) |
return FALSE; |
newy = *y; |
newx = *x; |
if (to_screen) |
{ |
newy += win->_begy; |
newx += win->_begx; |
if (!wenclose(win, newy, newx)) |
return FALSE; |
} |
else |
{ |
if (wenclose(win, newy, newx)) |
{ |
newy -= win->_begy; |
newx -= win->_begx; |
} |
else |
return FALSE; |
} |
*y = newy; |
*x = newx; |
return TRUE; |
} |
bool mouse_trafo(int *y, int *x, bool to_screen) |
{ |
PDC_LOG(("mouse_trafo() - called\n")); |
return wmouse_trafo(stdscr, y, x, to_screen); |
} |
mmask_t mousemask(mmask_t mask, mmask_t *oldmask) |
{ |
PDC_LOG(("mousemask() - called\n")); |
if (!SP) |
return (mmask_t)0; |
if (oldmask) |
*oldmask = SP->_trap_mbe; |
/* The ncurses interface doesn't work with our move events, so |
filter them here */ |
mask &= ~(BUTTON1_MOVED | BUTTON2_MOVED | BUTTON3_MOVED); |
mouse_set(mask); |
return SP->_trap_mbe; |
} |
int nc_getmouse(MEVENT *event) |
{ |
int i; |
mmask_t bstate = 0; |
PDC_LOG(("nc_getmouse() - called\n")); |
if (!event || !SP) |
return ERR; |
ungot = FALSE; |
request_mouse_pos(); |
event->id = 0; |
event->x = Mouse_status.x; |
event->y = Mouse_status.y; |
event->z = 0; |
for (i = 0; i < 3; i++) |
{ |
if (Mouse_status.changes & (1 << i)) |
{ |
int shf = i * 5; |
short button = Mouse_status.button[i] & BUTTON_ACTION_MASK; |
if (button == BUTTON_RELEASED) |
bstate |= (BUTTON1_RELEASED << shf); |
else if (button == BUTTON_PRESSED) |
bstate |= (BUTTON1_PRESSED << shf); |
else if (button == BUTTON_CLICKED) |
bstate |= (BUTTON1_CLICKED << shf); |
else if (button == BUTTON_DOUBLE_CLICKED) |
bstate |= (BUTTON1_DOUBLE_CLICKED << shf); |
button = Mouse_status.button[i] & BUTTON_MODIFIER_MASK; |
if (button & PDC_BUTTON_SHIFT) |
bstate |= BUTTON_MODIFIER_SHIFT; |
if (button & PDC_BUTTON_CONTROL) |
bstate |= BUTTON_MODIFIER_CONTROL; |
if (button & PDC_BUTTON_ALT) |
bstate |= BUTTON_MODIFIER_ALT; |
} |
} |
if (MOUSE_WHEEL_UP) |
bstate |= BUTTON4_PRESSED; |
else if (MOUSE_WHEEL_DOWN) |
bstate |= BUTTON5_PRESSED; |
/* extra filter pass -- mainly for button modifiers */ |
event->bstate = bstate & SP->_trap_mbe; |
return OK; |
} |
int ungetmouse(MEVENT *event) |
{ |
int i; |
mmask_t bstate; |
PDC_LOG(("ungetmouse() - called\n")); |
if (!event || ungot) |
return ERR; |
ungot = TRUE; |
SP->mouse_status.x = event->x; |
SP->mouse_status.y = event->y; |
SP->mouse_status.changes = 0; |
bstate = event->bstate; |
for (i = 0; i < 3; i++) |
{ |
int shf = i * 5; |
short button = 0; |
if (bstate & ((BUTTON1_RELEASED | BUTTON1_PRESSED | |
BUTTON1_CLICKED | BUTTON1_DOUBLE_CLICKED) << shf)) |
{ |
SP->mouse_status.changes |= 1 << i; |
if (bstate & (BUTTON1_PRESSED << shf)) |
button = BUTTON_PRESSED; |
if (bstate & (BUTTON1_CLICKED << shf)) |
button = BUTTON_CLICKED; |
if (bstate & (BUTTON1_DOUBLE_CLICKED << shf)) |
button = BUTTON_DOUBLE_CLICKED; |
if (bstate & BUTTON_MODIFIER_SHIFT) |
button |= PDC_BUTTON_SHIFT; |
if (bstate & BUTTON_MODIFIER_CONTROL) |
button |= PDC_BUTTON_CONTROL; |
if (bstate & BUTTON_MODIFIER_ALT) |
button |= PDC_BUTTON_ALT; |
} |
SP->mouse_status.button[i] = button; |
} |
if (bstate & BUTTON4_PRESSED) |
SP->mouse_status.changes |= PDC_MOUSE_WHEEL_UP; |
else if (bstate & BUTTON5_PRESSED) |
SP->mouse_status.changes |= PDC_MOUSE_WHEEL_DOWN; |
return PDC_ungetch(KEY_MOUSE); |
} |
bool has_mouse(void) |
{ |
return PDC_has_mouse(); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/move.c |
---|
0,0 → 1,77 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
move |
---- |
### Synopsis |
int move(int y, int x); |
int mvcur(int oldrow, int oldcol, int newrow, int newcol); |
int wmove(WINDOW *win, int y, int x); |
### Description |
move() and wmove() move the cursor associated with the window to the |
given location. This does not move the physical cursor of the |
terminal until refresh() is called. The position specified is |
relative to the upper left corner of the window, which is (0,0). |
mvcur() moves the physical cursor without updating any window cursor |
positions. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
move Y Y Y |
mvcur Y Y Y |
wmove Y Y Y |
**man-end****************************************************************/ |
int move(int y, int x) |
{ |
PDC_LOG(("move() - called: y=%d x=%d\n", y, x)); |
if (!stdscr || x < 0 || y < 0 || x >= stdscr->_maxx || y >= stdscr->_maxy) |
return ERR; |
stdscr->_curx = x; |
stdscr->_cury = y; |
return OK; |
} |
int mvcur(int oldrow, int oldcol, int newrow, int newcol) |
{ |
PDC_LOG(("mvcur() - called: oldrow %d oldcol %d newrow %d newcol %d\n", |
oldrow, oldcol, newrow, newcol)); |
if (!SP || newrow < 0 || newrow >= LINES || newcol < 0 || newcol >= COLS) |
return ERR; |
PDC_gotoyx(newrow, newcol); |
SP->cursrow = newrow; |
SP->curscol = newcol; |
return OK; |
} |
int wmove(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("wmove() - called: y=%d x=%d\n", y, x)); |
if (!win || x < 0 || y < 0 || x >= win->_maxx || y >= win->_maxy) |
return ERR; |
win->_curx = x; |
win->_cury = y; |
return OK; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/outopts.c |
---|
0,0 → 1,175 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
outopts |
------- |
### Synopsis |
int clearok(WINDOW *win, bool bf); |
int idlok(WINDOW *win, bool bf); |
void idcok(WINDOW *win, bool bf); |
void immedok(WINDOW *win, bool bf); |
int leaveok(WINDOW *win, bool bf); |
int setscrreg(int top, int bot); |
int wsetscrreg(WINDOW *win, int top, int bot); |
int scrollok(WINDOW *win, bool bf); |
int raw_output(bool bf); |
bool is_leaveok(const WINDOW *win); |
### Description |
With clearok(), if bf is TRUE, the next call to wrefresh() with this |
window will clear the screen completely and redraw the entire screen. |
immedok(), called with a second argument of TRUE, causes an automatic |
wrefresh() every time a change is made to the specified window. |
Normally, the hardware cursor is left at the location of the window |
being refreshed. leaveok() allows the cursor to be left wherever the |
update happens to leave it. It's useful for applications where the |
cursor is not used, since it reduces the need for cursor motions. If |
possible, the cursor is made invisible when this option is enabled. |
wsetscrreg() sets a scrolling region in a window; "top" and "bot" are |
the line numbers for the top and bottom margins. If this option and |
scrollok() are enabled, any attempt to move off the bottom margin |
will cause all lines in the scrolling region to scroll up one line. |
setscrreg() is the stdscr version. |
idlok() and idcok() do nothing in PDCurses, but are provided for |
compatibility with other curses implementations. |
raw_output() enables the output of raw characters using the standard |
*add* and *ins* curses functions (that is, it disables translation of |
control characters). |
is_leaveok() reports whether the specified window is in leaveok mode. |
### Return Value |
All functions except is_leaveok() return OK on success and ERR on |
error. |
### Portability |
X/Open ncurses NetBSD |
clearok Y Y Y |
idlok Y Y Y |
idcok Y Y Y |
immedok Y Y Y |
leaveok Y Y Y |
setscrreg Y Y Y |
wsetscrreg Y Y Y |
scrollok Y Y Y |
is_leaveok - Y Y |
raw_output - - - |
**man-end****************************************************************/ |
int clearok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("clearok() - called\n")); |
if (!win) |
return ERR; |
win->_clear = bf; |
return OK; |
} |
int idlok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("idlok() - called\n")); |
return OK; |
} |
void idcok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("idcok() - called\n")); |
} |
void immedok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("immedok() - called\n")); |
if (win) |
win->_immed = bf; |
} |
int leaveok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("leaveok() - called\n")); |
if (!win) |
return ERR; |
win->_leaveit = bf; |
curs_set(!bf); |
return OK; |
} |
int setscrreg(int top, int bottom) |
{ |
PDC_LOG(("setscrreg() - called: top %d bottom %d\n", top, bottom)); |
return wsetscrreg(stdscr, top, bottom); |
} |
int wsetscrreg(WINDOW *win, int top, int bottom) |
{ |
PDC_LOG(("wsetscrreg() - called: top %d bottom %d\n", top, bottom)); |
if (win && 0 <= top && top <= win->_cury && |
win->_cury <= bottom && bottom < win->_maxy) |
{ |
win->_tmarg = top; |
win->_bmarg = bottom; |
return OK; |
} |
else |
return ERR; |
} |
int scrollok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("scrollok() - called\n")); |
if (!win) |
return ERR; |
win->_scroll = bf; |
return OK; |
} |
int raw_output(bool bf) |
{ |
PDC_LOG(("raw_output() - called\n")); |
if (!SP) |
return ERR; |
SP->raw_out = bf; |
return OK; |
} |
bool is_leaveok(const WINDOW *win) |
{ |
PDC_LOG(("is_leaveok() - called\n")); |
if (!win) |
return FALSE; |
return win->_leaveit; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/overlay.c |
---|
0,0 → 1,214 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
overlay |
------- |
### Synopsis |
int overlay(const WINDOW *src_w, WINDOW *dst_w) |
int overwrite(const WINDOW *src_w, WINDOW *dst_w) |
int copywin(const WINDOW *src_w, WINDOW *dst_w, int src_tr, |
int src_tc, int dst_tr, int dst_tc, int dst_br, |
int dst_bc, int _overlay) |
### Description |
overlay() and overwrite() copy all the text from src_w into dst_w. |
The windows need not be the same size. Those characters in the source |
window that intersect with the destination window are copied, so that |
the characters appear in the same physical position on the screen. |
The difference between the two functions is that overlay() is non- |
destructive (blanks are not copied) while overwrite() is destructive |
(blanks are copied). |
copywin() is similar, but doesn't require that the two windows |
overlap. The arguments src_tc and src_tr specify the top left corner |
of the region to be copied. dst_tc, dst_tr, dst_br, and dst_bc |
specify the region within the destination window to copy to. The |
argument "overlay", if TRUE, indicates that the copy is done non- |
destructively (as in overlay()); blanks in the source window are not |
copied to the destination window. When overlay is FALSE, blanks are |
copied. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
overlay Y Y Y |
overwrite Y Y Y |
copywin Y Y Y |
**man-end****************************************************************/ |
/* Thanks to Andreas Otte <venn@@uni-paderborn.de> for the |
corrected overlay()/overwrite() behavior. */ |
static int _copy_win(const WINDOW *src_w, WINDOW *dst_w, int src_tr, |
int src_tc, int src_br, int src_bc, int dst_tr, |
int dst_tc, bool _overlay) |
{ |
int col, line, y1, fc, *minchng, *maxchng; |
chtype *w1ptr, *w2ptr; |
int lc = 0; |
int xdiff = src_bc - src_tc; |
int ydiff = src_br - src_tr; |
if (!src_w || !dst_w) |
return ERR; |
minchng = dst_w->_firstch; |
maxchng = dst_w->_lastch; |
for (y1 = 0; y1 < dst_tr; y1++) |
{ |
minchng++; |
maxchng++; |
} |
for (line = 0; line < ydiff; line++) |
{ |
w1ptr = src_w->_y[line + src_tr] + src_tc; |
w2ptr = dst_w->_y[line + dst_tr] + dst_tc; |
fc = _NO_CHANGE; |
for (col = 0; col < xdiff; col++) |
{ |
if ((*w1ptr) != (*w2ptr) && |
!((*w1ptr & A_CHARTEXT) == ' ' && _overlay)) |
{ |
*w2ptr = *w1ptr; |
if (fc == _NO_CHANGE) |
fc = col + dst_tc; |
lc = col + dst_tc; |
} |
w1ptr++; |
w2ptr++; |
} |
if (*minchng == _NO_CHANGE) |
{ |
*minchng = fc; |
*maxchng = lc; |
} |
else if (fc != _NO_CHANGE) |
{ |
if (fc < *minchng) |
*minchng = fc; |
if (lc > *maxchng) |
*maxchng = lc; |
} |
minchng++; |
maxchng++; |
} |
return OK; |
} |
int _copy_overlap(const WINDOW *src_w, WINDOW *dst_w, bool overlay) |
{ |
int first_line, first_col, last_line, last_col; |
int src_start_x, src_start_y, dst_start_x, dst_start_y; |
int xdiff, ydiff; |
if (!src_w || !dst_w) |
return ERR; |
first_col = max(dst_w->_begx, src_w->_begx); |
first_line = max(dst_w->_begy, src_w->_begy); |
last_col = min(src_w->_begx + src_w->_maxx, dst_w->_begx + dst_w->_maxx); |
last_line = min(src_w->_begy + src_w->_maxy, dst_w->_begy + dst_w->_maxy); |
/* determine the overlapping region of the two windows in real |
coordinates */ |
/* if no overlapping region, do nothing */ |
if ((last_col < first_col) || (last_line < first_line)) |
return OK; |
/* size of overlapping region */ |
xdiff = last_col - first_col; |
ydiff = last_line - first_line; |
if (src_w->_begx <= dst_w->_begx) |
{ |
src_start_x = dst_w->_begx - src_w->_begx; |
dst_start_x = 0; |
} |
else |
{ |
dst_start_x = src_w->_begx - dst_w->_begx; |
src_start_x = 0; |
} |
if (src_w->_begy <= dst_w->_begy) |
{ |
src_start_y = dst_w->_begy - src_w->_begy; |
dst_start_y = 0; |
} |
else |
{ |
dst_start_y = src_w->_begy - dst_w->_begy; |
src_start_y = 0; |
} |
return _copy_win(src_w, dst_w, src_start_y, src_start_x, |
src_start_y + ydiff, src_start_x + xdiff, |
dst_start_y, dst_start_x, overlay); |
} |
int overlay(const WINDOW *src_w, WINDOW *dst_w) |
{ |
PDC_LOG(("overlay() - called\n")); |
return _copy_overlap(src_w, dst_w, TRUE); |
} |
int overwrite(const WINDOW *src_w, WINDOW *dst_w) |
{ |
PDC_LOG(("overwrite() - called\n")); |
return _copy_overlap(src_w, dst_w, FALSE); |
} |
int copywin(const WINDOW *src_w, WINDOW *dst_w, int src_tr, int src_tc, |
int dst_tr, int dst_tc, int dst_br, int dst_bc, int _overlay) |
{ |
int src_end_x, src_end_y; |
int src_rows, src_cols, dst_rows, dst_cols; |
int min_rows, min_cols; |
PDC_LOG(("copywin() - called\n")); |
if (!src_w || !dst_w || dst_w == curscr || dst_br >= dst_w->_maxy |
|| dst_bc >= dst_w->_maxx || dst_tr < 0 || dst_tc < 0) |
return ERR; |
src_rows = src_w->_maxy - src_tr; |
src_cols = src_w->_maxx - src_tc; |
dst_rows = dst_br - dst_tr + 1; |
dst_cols = dst_bc - dst_tc + 1; |
min_rows = min(src_rows, dst_rows); |
min_cols = min(src_cols, dst_cols); |
src_end_y = src_tr + min_rows; |
src_end_x = src_tc + min_cols; |
return _copy_win(src_w, dst_w, src_tr, src_tc, src_end_y, src_end_x, |
dst_tr, dst_tc, _overlay); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/pad.c |
---|
0,0 → 1,278 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
pad |
--- |
### Synopsis |
WINDOW *newpad(int nlines, int ncols); |
WINDOW *subpad(WINDOW *orig, int nlines, int ncols, |
int begy, int begx); |
int prefresh(WINDOW *win, int py, int px, int sy1, int sx1, |
int sy2, int sx2); |
int pnoutrefresh(WINDOW *w, int py, int px, int sy1, int sx1, |
int sy2, int sx2); |
int pechochar(WINDOW *pad, chtype ch); |
int pecho_wchar(WINDOW *pad, const cchar_t *wch); |
bool is_pad(const WINDOW *pad); |
### Description |
A pad is a special kind of window, which is not restricted by the |
screen size, and is not necessarily associated with a particular part |
of the screen. You can use a pad when you need a large window, and |
only a part of the window will be on the screen at one time. Pads are |
not refreshed automatically (e.g., from scrolling or echoing of |
input). You can't call wrefresh() with a pad as an argument; use |
prefresh() or pnoutrefresh() instead. Note that these routines |
require additional parameters to specify the part of the pad to be |
displayed, and the location to use on the screen. |
newpad() creates a new pad data structure. |
subpad() creates a new sub-pad within a pad, at position (begy, |
begx), with dimensions of nlines lines and ncols columns. This |
position is relative to the pad, and not to the screen as with |
subwin. Changes to either the parent pad or sub-pad will affect both. |
When using sub-pads, you may need to call touchwin() before calling |
prefresh(). |
pnoutrefresh() copies the specified pad to the virtual screen. |
prefresh() calls pnoutrefresh(), followed by doupdate(). |
These routines are analogous to wnoutrefresh() and wrefresh(). (py, |
px) specifies the upper left corner of the part of the pad to be |
displayed; (sy1, sx1) and (sy2, sx2) describe the screen rectangle |
that will contain the selected part of the pad. |
pechochar() is functionally equivalent to addch() followed by a call |
to prefresh(), with the last-used coordinates and dimensions. |
pecho_wchar() is the wide-character version. |
is_pad() reports whether the specified window is a pad. |
### Return Value |
All functions except is_pad() return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
newpad Y Y Y |
subpad Y Y Y |
prefresh Y Y Y |
pnoutrefresh Y Y Y |
pechochar Y Y Y |
pecho_wchar Y Y Y |
is_pad - Y Y |
**man-end****************************************************************/ |
#include <string.h> |
/* save values for pechochar() */ |
static int save_pminrow, save_pmincol; |
static int save_sminrow, save_smincol, save_smaxrow, save_smaxcol; |
WINDOW *newpad(int nlines, int ncols) |
{ |
WINDOW *win; |
PDC_LOG(("newpad() - called: lines=%d cols=%d\n", nlines, ncols)); |
win = PDC_makenew(nlines, ncols, 0, 0); |
if (win) |
win = PDC_makelines(win); |
if (!win) |
return (WINDOW *)NULL; |
werase(win); |
win->_flags = _PAD; |
/* save default values in case pechochar() is the first call to |
prefresh(). */ |
save_pminrow = 0; |
save_pmincol = 0; |
save_sminrow = 0; |
save_smincol = 0; |
save_smaxrow = min(LINES, nlines) - 1; |
save_smaxcol = min(COLS, ncols) - 1; |
return win; |
} |
WINDOW *subpad(WINDOW *orig, int nlines, int ncols, int begy, int begx) |
{ |
WINDOW *win; |
int i; |
PDC_LOG(("subpad() - called: lines=%d cols=%d begy=%d begx=%d\n", |
nlines, ncols, begy, begx)); |
if (!orig || !(orig->_flags & _PAD)) |
return (WINDOW *)NULL; |
/* make sure window fits inside the original one */ |
if (begy < 0 || begx < 0 || |
(begy + nlines) > orig->_maxy || |
(begx + ncols) > orig->_maxx) |
return (WINDOW *)NULL; |
if (!nlines) |
nlines = orig->_maxy - begy; |
if (!ncols) |
ncols = orig->_maxx - begx; |
win = PDC_makenew(nlines, ncols, begy, begx); |
if (!win) |
return (WINDOW *)NULL; |
/* initialize window variables */ |
win->_attrs = orig->_attrs; |
win->_leaveit = orig->_leaveit; |
win->_scroll = orig->_scroll; |
win->_nodelay = orig->_nodelay; |
win->_use_keypad = orig->_use_keypad; |
win->_parent = orig; |
for (i = 0; i < nlines; i++) |
win->_y[i] = orig->_y[begy + i] + begx; |
win->_flags = _SUBPAD; |
/* save default values in case pechochar() is the first call |
to prefresh(). */ |
save_pminrow = 0; |
save_pmincol = 0; |
save_sminrow = 0; |
save_smincol = 0; |
save_smaxrow = min(LINES, nlines) - 1; |
save_smaxcol = min(COLS, ncols) - 1; |
return win; |
} |
int prefresh(WINDOW *win, int py, int px, int sy1, int sx1, int sy2, int sx2) |
{ |
PDC_LOG(("prefresh() - called\n")); |
if (pnoutrefresh(win, py, px, sy1, sx1, sy2, sx2) == ERR) |
return ERR; |
doupdate(); |
return OK; |
} |
int pnoutrefresh(WINDOW *w, int py, int px, int sy1, int sx1, int sy2, int sx2) |
{ |
int num_cols; |
int sline = sy1; |
int pline = py; |
PDC_LOG(("pnoutrefresh() - called\n")); |
if (!w || !(w->_flags & (_PAD|_SUBPAD)) || (sy2 >= LINES) || (sx2 >= COLS)) |
return ERR; |
if (py < 0) |
py = 0; |
if (px < 0) |
px = 0; |
if (sy1 < 0) |
sy1 = 0; |
if (sx1 < 0) |
sx1 = 0; |
if (sy2 < sy1 || sx2 < sx1) |
return ERR; |
num_cols = min((sx2 - sx1 + 1), (w->_maxx - px)); |
while (sline <= sy2) |
{ |
if (pline < w->_maxy) |
{ |
memcpy(curscr->_y[sline] + sx1, w->_y[pline] + px, |
num_cols * sizeof(chtype)); |
if ((curscr->_firstch[sline] == _NO_CHANGE) |
|| (curscr->_firstch[sline] > sx1)) |
curscr->_firstch[sline] = sx1; |
if (sx2 > curscr->_lastch[sline]) |
curscr->_lastch[sline] = sx2; |
w->_firstch[pline] = _NO_CHANGE; /* updated now */ |
w->_lastch[pline] = _NO_CHANGE; /* updated now */ |
} |
sline++; |
pline++; |
} |
if (w->_clear) |
{ |
w->_clear = FALSE; |
curscr->_clear = TRUE; |
} |
/* position the cursor to the pad's current position if possible -- |
is the pad current position going to end up displayed? if not, |
then don't move the cursor; if so, move it to the correct place */ |
if (!w->_leaveit && w->_cury >= py && w->_curx >= px && |
w->_cury <= py + (sy2 - sy1) && w->_curx <= px + (sx2 - sx1)) |
{ |
curscr->_cury = (w->_cury - py) + sy1; |
curscr->_curx = (w->_curx - px) + sx1; |
} |
return OK; |
} |
int pechochar(WINDOW *pad, chtype ch) |
{ |
PDC_LOG(("pechochar() - called\n")); |
if (waddch(pad, ch) == ERR) |
return ERR; |
return prefresh(pad, save_pminrow, save_pmincol, save_sminrow, |
save_smincol, save_smaxrow, save_smaxcol); |
} |
#ifdef PDC_WIDE |
int pecho_wchar(WINDOW *pad, const cchar_t *wch) |
{ |
PDC_LOG(("pecho_wchar() - called\n")); |
if (!wch || (waddch(pad, *wch) == ERR)) |
return ERR; |
return prefresh(pad, save_pminrow, save_pmincol, save_sminrow, |
save_smincol, save_smaxrow, save_smaxcol); |
} |
#endif |
bool is_pad(const WINDOW *pad) |
{ |
PDC_LOG(("is_pad() - called\n")); |
if (!pad) |
return FALSE; |
return (pad->_flags & _PAD) ? TRUE : FALSE; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/panel.c |
---|
0,0 → 1,633 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
panel |
----- |
### Synopsis |
int bottom_panel(PANEL *pan); |
int del_panel(PANEL *pan); |
int hide_panel(PANEL *pan); |
int move_panel(PANEL *pan, int starty, int startx); |
PANEL *new_panel(WINDOW *win); |
PANEL *panel_above(const PANEL *pan); |
PANEL *panel_below(const PANEL *pan); |
int panel_hidden(const PANEL *pan); |
const void *panel_userptr(const PANEL *pan); |
WINDOW *panel_window(const PANEL *pan); |
int replace_panel(PANEL *pan, WINDOW *win); |
int set_panel_userptr(PANEL *pan, const void *uptr); |
int show_panel(PANEL *pan); |
int top_panel(PANEL *pan); |
void update_panels(void); |
### Description |
For historic reasons, and for compatibility with other versions of |
curses, the panel functions are prototyped in a separate header, |
panel.h. In many implementations, they're also in a separate library, |
but PDCurses incorporates them. |
The panel functions provide a way to have depth relationships between |
curses windows. Panels can overlap without making visible the |
overlapped portions of underlying windows. The initial curses window, |
stdscr, lies beneath all panels. The set of currently visible panels |
is the 'deck' of panels. |
You can create panels, fetch and set their associated windows, |
shuffle panels in the deck, and manipulate them in other ways. |
bottom_panel() places pan at the bottom of the deck. The size, |
location and contents of the panel are unchanged. |
del_panel() deletes pan, but not its associated winwow. |
hide_panel() removes a panel from the deck and thus hides it from |
view. |
move_panel() moves the curses window associated with pan, so that its |
upper lefthand corner is at the supplied coordinates. (Don't use |
mvwin() on the window.) |
new_panel() creates a new panel associated with win and returns the |
panel pointer. The new panel is placed at the top of the deck. |
panel_above() returns a pointer to the panel in the deck above pan, |
or NULL if pan is the top panel. If the value of pan passed is NULL, |
this function returns a pointer to the bottom panel in the deck. |
panel_below() returns a pointer to the panel in the deck below pan, |
or NULL if pan is the bottom panel. If the value of pan passed is |
NULL, this function returns a pointer to the top panel in the deck. |
panel_hidden() returns OK if pan is hidden and ERR if it is not. |
panel_userptr() - Each panel has a user pointer available for |
maintaining relevant information. This function returns a pointer to |
that information previously set up by set_panel_userptr(). |
panel_window() returns a pointer to the curses window associated with |
the panel. |
replace_panel() replaces the current window of pan with win. |
set_panel_userptr() - Each panel has a user pointer available for |
maintaining relevant information. This function sets the value of |
that information. |
show_panel() makes a previously hidden panel visible and places it |
back in the deck on top. |
top_panel() places pan on the top of the deck. The size, location and |
contents of the panel are unchanged. |
update_panels() refreshes the virtual screen to reflect the depth |
relationships between the panels in the deck. The user must use |
doupdate() to refresh the physical screen. |
### Return Value |
Each routine that returns a pointer to an object returns NULL if an |
error occurs. Each panel routine that returns an integer, returns OK |
if it executes successfully and ERR if it does not. |
### Portability |
X/Open ncurses NetBSD |
bottom_panel - Y Y |
del_panel - Y Y |
hide_panel - Y Y |
move_panel - Y Y |
new_panel - Y Y |
panel_above - Y Y |
panel_below - Y Y |
panel_hidden - Y Y |
panel_userptr - Y Y |
panel_window - Y Y |
replace_panel - Y Y |
set_panel_userptr - Y Y |
show_panel - Y Y |
top_panel - Y Y |
update_panels - Y Y |
Credits: |
Original Author - Warren Tucker <wht@n4hgf.mt-park.ga.us> |
**man-end****************************************************************/ |
#include <panel.h> |
#include <stdlib.h> |
PANEL *_bottom_panel = (PANEL *)0; |
PANEL *_top_panel = (PANEL *)0; |
PANEL _stdscr_pseudo_panel = { (WINDOW *)0 }; |
#ifdef PANEL_DEBUG |
static void dPanel(char *text, PANEL *pan) |
{ |
PDC_LOG(("%s id=%s b=%s a=%s y=%d x=%d", text, pan->user, |
pan->below ? pan->below->user : "--", |
pan->above ? pan->above->user : "--", |
pan->wstarty, pan->wstartx)); |
} |
static void dStack(char *fmt, int num, PANEL *pan) |
{ |
char s80[80]; |
sprintf(s80, fmt, num, pan); |
PDC_LOG(("%s b=%s t=%s", s80, _bottom_panel ? _bottom_panel->user : "--", |
_top_panel ? _top_panel->user : "--")); |
if (pan) |
PDC_LOG(("pan id=%s", pan->user)); |
pan = _bottom_panel; |
while (pan) |
{ |
dPanel("stk", pan); |
pan = pan->above; |
} |
} |
/* debugging hook for wnoutrefresh */ |
static void Wnoutrefresh(PANEL *pan) |
{ |
dPanel("wnoutrefresh", pan); |
wnoutrefresh(pan->win); |
} |
static void Touchpan(PANEL *pan) |
{ |
dPanel("Touchpan", pan); |
touchwin(pan->win); |
} |
static void Touchline(PANEL *pan, int start, int count) |
{ |
char s80[80]; |
sprintf(s80, "Touchline s=%d c=%d", start, count); |
dPanel(s80, pan); |
touchline(pan->win, start, count); |
} |
#else /* PANEL_DEBUG */ |
#define dPanel(text, pan) |
#define dStack(fmt, num, pan) |
#define Wnoutrefresh(pan) wnoutrefresh((pan)->win) |
#define Touchpan(pan) touchwin((pan)->win) |
#define Touchline(pan, start, count) touchline((pan)->win, start, count) |
#endif /* PANEL_DEBUG */ |
static bool _panels_overlapped(PANEL *pan1, PANEL *pan2) |
{ |
if (!pan1 || !pan2) |
return FALSE; |
return ((pan1->wstarty >= pan2->wstarty && pan1->wstarty < pan2->wendy) |
|| (pan2->wstarty >= pan1->wstarty && pan2->wstarty < pan1->wendy)) |
&& ((pan1->wstartx >= pan2->wstartx && pan1->wstartx < pan2->wendx) |
|| (pan2->wstartx >= pan1->wstartx && pan2->wstartx < pan1->wendx)); |
} |
static void _free_obscure(PANEL *pan) |
{ |
PANELOBS *tobs = pan->obscure; /* "this" one */ |
PANELOBS *nobs; /* "next" one */ |
while (tobs) |
{ |
nobs = tobs->above; |
free((char *)tobs); |
tobs = nobs; |
} |
pan->obscure = (PANELOBS *)0; |
} |
static void _override(PANEL *pan, int show) |
{ |
int y; |
PANEL *pan2; |
PANELOBS *tobs = pan->obscure; /* "this" one */ |
if (show == 1) |
Touchpan(pan); |
else if (!show) |
{ |
Touchpan(pan); |
Touchpan(&_stdscr_pseudo_panel); |
} |
else if (show == -1) |
while (tobs && (tobs->pan != pan)) |
tobs = tobs->above; |
while (tobs) |
{ |
if ((pan2 = tobs->pan) != pan) |
for (y = pan->wstarty; y < pan->wendy; y++) |
if ((y >= pan2->wstarty) && (y < pan2->wendy) && |
((is_linetouched(pan->win, y - pan->wstarty)) || |
(is_linetouched(stdscr, y)))) |
Touchline(pan2, y - pan2->wstarty, 1); |
tobs = tobs->above; |
} |
} |
static void _calculate_obscure(void) |
{ |
PANEL *pan, *pan2; |
PANELOBS *tobs; /* "this" one */ |
PANELOBS *lobs; /* last one */ |
pan = _bottom_panel; |
while (pan) |
{ |
if (pan->obscure) |
_free_obscure(pan); |
lobs = (PANELOBS *)0; |
pan2 = _bottom_panel; |
while (pan2) |
{ |
if (_panels_overlapped(pan, pan2)) |
{ |
if ((tobs = malloc(sizeof(PANELOBS))) == NULL) |
return; |
tobs->pan = pan2; |
dPanel("obscured", pan2); |
tobs->above = (PANELOBS *)0; |
if (lobs) |
lobs->above = tobs; |
else |
pan->obscure = tobs; |
lobs = tobs; |
} |
pan2 = pan2->above; |
} |
_override(pan, 1); |
pan = pan->above; |
} |
} |
/* check to see if panel is in the stack */ |
static bool _panel_is_linked(const PANEL *pan) |
{ |
PANEL *pan2 = _bottom_panel; |
while (pan2) |
{ |
if (pan2 == pan) |
return TRUE; |
pan2 = pan2->above; |
} |
return FALSE; |
} |
/* link panel into stack at top */ |
static void _panel_link_top(PANEL *pan) |
{ |
#ifdef PANEL_DEBUG |
dStack("<lt%d>", 1, pan); |
if (_panel_is_linked(pan)) |
return; |
#endif |
pan->above = (PANEL *)0; |
pan->below = (PANEL *)0; |
if (_top_panel) |
{ |
_top_panel->above = pan; |
pan->below = _top_panel; |
} |
_top_panel = pan; |
if (!_bottom_panel) |
_bottom_panel = pan; |
_calculate_obscure(); |
dStack("<lt%d>", 9, pan); |
} |
/* link panel into stack at bottom */ |
static void _panel_link_bottom(PANEL *pan) |
{ |
#ifdef PANEL_DEBUG |
dStack("<lb%d>", 1, pan); |
if (_panel_is_linked(pan)) |
return; |
#endif |
pan->above = (PANEL *)0; |
pan->below = (PANEL *)0; |
if (_bottom_panel) |
{ |
_bottom_panel->below = pan; |
pan->above = _bottom_panel; |
} |
_bottom_panel = pan; |
if (!_top_panel) |
_top_panel = pan; |
_calculate_obscure(); |
dStack("<lb%d>", 9, pan); |
} |
static void _panel_unlink(PANEL *pan) |
{ |
PANEL *prev; |
PANEL *next; |
#ifdef PANEL_DEBUG |
dStack("<u%d>", 1, pan); |
if (!_panel_is_linked(pan)) |
return; |
#endif |
_override(pan, 0); |
_free_obscure(pan); |
prev = pan->below; |
next = pan->above; |
/* if non-zero, we will not update the list head */ |
if (prev) |
{ |
prev->above = next; |
if(next) |
next->below = prev; |
} |
else if (next) |
next->below = prev; |
if (pan == _bottom_panel) |
_bottom_panel = next; |
if (pan == _top_panel) |
_top_panel = prev; |
_calculate_obscure(); |
pan->above = (PANEL *)0; |
pan->below = (PANEL *)0; |
dStack("<u%d>", 9, pan); |
} |
/************************************************************************ |
* The following are the public functions for the panels library. * |
************************************************************************/ |
int bottom_panel(PANEL *pan) |
{ |
if (!pan) |
return ERR; |
if (pan == _bottom_panel) |
return OK; |
if (_panel_is_linked(pan)) |
hide_panel(pan); |
_panel_link_bottom(pan); |
return OK; |
} |
int del_panel(PANEL *pan) |
{ |
if (pan) |
{ |
if (_panel_is_linked(pan)) |
hide_panel(pan); |
free((char *)pan); |
return OK; |
} |
return ERR; |
} |
int hide_panel(PANEL *pan) |
{ |
if (!pan) |
return ERR; |
if (!_panel_is_linked(pan)) |
{ |
pan->above = (PANEL *)0; |
pan->below = (PANEL *)0; |
return ERR; |
} |
_panel_unlink(pan); |
return OK; |
} |
int move_panel(PANEL *pan, int starty, int startx) |
{ |
WINDOW *win; |
int maxy, maxx; |
if (!pan) |
return ERR; |
if (_panel_is_linked(pan)) |
_override(pan, 0); |
win = pan->win; |
if (mvwin(win, starty, startx) == ERR) |
return ERR; |
getbegyx(win, pan->wstarty, pan->wstartx); |
getmaxyx(win, maxy, maxx); |
pan->wendy = pan->wstarty + maxy; |
pan->wendx = pan->wstartx + maxx; |
if (_panel_is_linked(pan)) |
_calculate_obscure(); |
return OK; |
} |
PANEL *new_panel(WINDOW *win) |
{ |
PANEL *pan; |
if (!win) |
return (PANEL *)NULL; |
pan = malloc(sizeof(PANEL)); |
if (!_stdscr_pseudo_panel.win) |
{ |
_stdscr_pseudo_panel.win = stdscr; |
_stdscr_pseudo_panel.wstarty = 0; |
_stdscr_pseudo_panel.wstartx = 0; |
_stdscr_pseudo_panel.wendy = LINES; |
_stdscr_pseudo_panel.wendx = COLS; |
_stdscr_pseudo_panel.user = "stdscr"; |
_stdscr_pseudo_panel.obscure = (PANELOBS *)0; |
} |
if (pan) |
{ |
int maxy, maxx; |
pan->win = win; |
pan->above = (PANEL *)0; |
pan->below = (PANEL *)0; |
getbegyx(win, pan->wstarty, pan->wstartx); |
getmaxyx(win, maxy, maxx); |
pan->wendy = pan->wstarty + maxy; |
pan->wendx = pan->wstartx + maxx; |
#ifdef PANEL_DEBUG |
pan->user = "new"; |
#else |
pan->user = (char *)0; |
#endif |
pan->obscure = (PANELOBS *)0; |
show_panel(pan); |
} |
return pan; |
} |
PANEL *panel_above(const PANEL *pan) |
{ |
return pan ? pan->above : _bottom_panel; |
} |
PANEL *panel_below(const PANEL *pan) |
{ |
return pan ? pan->below : _top_panel; |
} |
int panel_hidden(const PANEL *pan) |
{ |
if (!pan) |
return ERR; |
return _panel_is_linked(pan) ? ERR : OK; |
} |
const void *panel_userptr(const PANEL *pan) |
{ |
return pan ? pan->user : NULL; |
} |
WINDOW *panel_window(const PANEL *pan) |
{ |
PDC_LOG(("panel_window() - called\n")); |
if (!pan) |
return (WINDOW *)NULL; |
return pan->win; |
} |
int replace_panel(PANEL *pan, WINDOW *win) |
{ |
int maxy, maxx; |
if (!pan) |
return ERR; |
if (_panel_is_linked(pan)) |
_override(pan, 0); |
pan->win = win; |
getbegyx(win, pan->wstarty, pan->wstartx); |
getmaxyx(win, maxy, maxx); |
pan->wendy = pan->wstarty + maxy; |
pan->wendx = pan->wstartx + maxx; |
if (_panel_is_linked(pan)) |
_calculate_obscure(); |
return OK; |
} |
int set_panel_userptr(PANEL *pan, const void *uptr) |
{ |
if (!pan) |
return ERR; |
pan->user = uptr; |
return OK; |
} |
int show_panel(PANEL *pan) |
{ |
if (!pan) |
return ERR; |
if (pan == _top_panel) |
return OK; |
if (_panel_is_linked(pan)) |
hide_panel(pan); |
_panel_link_top(pan); |
return OK; |
} |
int top_panel(PANEL *pan) |
{ |
return show_panel(pan); |
} |
void update_panels(void) |
{ |
PANEL *pan; |
PDC_LOG(("update_panels() - called\n")); |
pan = _bottom_panel; |
while (pan) |
{ |
_override(pan, -1); |
pan = pan->above; |
} |
if (is_wintouched(stdscr)) |
Wnoutrefresh(&_stdscr_pseudo_panel); |
pan = _bottom_panel; |
while (pan) |
{ |
if (is_wintouched(pan->win) || !pan->above) |
Wnoutrefresh(pan); |
pan = pan->above; |
} |
} |
/contrib/sdk/sources/PDCurses/pdcurses/printw.c |
---|
0,0 → 1,129 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
printw |
------ |
### Synopsis |
int printw(const char *fmt, ...); |
int wprintw(WINDOW *win, const char *fmt, ...); |
int mvprintw(int y, int x, const char *fmt, ...); |
int mvwprintw(WINDOW *win, int y, int x, const char *fmt,...); |
int vwprintw(WINDOW *win, const char *fmt, va_list varglist); |
int vw_printw(WINDOW *win, const char *fmt, va_list varglist); |
### Description |
The printw() functions add a formatted string to the window at the |
current or specified cursor position. The format strings are the same |
as used in the standard C library's printf(). (printw() can be used |
as a drop-in replacement for printf().) |
The duplication between vwprintw() and vw_printw() is for historic |
reasons. In PDCurses, they're the same. |
### Return Value |
All functions return the number of characters printed, or ERR on |
error. |
### Portability |
X/Open ncurses NetBSD |
printw Y Y Y |
wprintw Y Y Y |
mvprintw Y Y Y |
mvwprintw Y Y Y |
vwprintw Y Y Y |
vw_printw Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
int vwprintw(WINDOW *win, const char *fmt, va_list varglist) |
{ |
char printbuf[513]; |
int len; |
PDC_LOG(("vwprintw() - called\n")); |
#ifdef HAVE_VSNPRINTF |
len = vsnprintf(printbuf, 512, fmt, varglist); |
#else |
len = vsprintf(printbuf, fmt, varglist); |
#endif |
return (waddstr(win, printbuf) == ERR) ? ERR : len; |
} |
int printw(const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("printw() - called\n")); |
va_start(args, fmt); |
retval = vwprintw(stdscr, fmt, args); |
va_end(args); |
return retval; |
} |
int wprintw(WINDOW *win, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("wprintw() - called\n")); |
va_start(args, fmt); |
retval = vwprintw(win, fmt, args); |
va_end(args); |
return retval; |
} |
int mvprintw(int y, int x, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("mvprintw() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
va_start(args, fmt); |
retval = vwprintw(stdscr, fmt, args); |
va_end(args); |
return retval; |
} |
int mvwprintw(WINDOW *win, int y, int x, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("mvwprintw() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
va_start(args, fmt); |
retval = vwprintw(win, fmt, args); |
va_end(args); |
return retval; |
} |
int vw_printw(WINDOW *win, const char *fmt, va_list varglist) |
{ |
PDC_LOG(("vw_printw() - called\n")); |
return vwprintw(win, fmt, varglist); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/refresh.c |
---|
0,0 → 1,279 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
refresh |
------- |
### Synopsis |
int refresh(void); |
int wrefresh(WINDOW *win); |
int wnoutrefresh(WINDOW *win); |
int doupdate(void); |
int redrawwin(WINDOW *win); |
int wredrawln(WINDOW *win, int beg_line, int num_lines); |
### Description |
wrefresh() copies the named window to the physical terminal screen, |
taking into account what is already there in order to optimize cursor |
movement. refresh() does the same, using stdscr. These routines must |
be called to get any output on the terminal, as other routines only |
manipulate data structures. Unless leaveok() has been enabled, the |
physical cursor of the terminal is left at the location of the |
window's cursor. |
wnoutrefresh() and doupdate() allow multiple updates with more |
efficiency than wrefresh() alone. wrefresh() works by first calling |
wnoutrefresh(), which copies the named window to the virtual screen. |
It then calls doupdate(), which compares the virtual screen to the |
physical screen and does the actual update. A series of calls to |
wrefresh() will result in alternating calls to wnoutrefresh() and |
doupdate(), causing several bursts of output to the screen. By first |
calling wnoutrefresh() for each window, it is then possible to call |
doupdate() only once. |
In PDCurses, redrawwin() is equivalent to touchwin(), and wredrawln() |
is the same as touchline(). In some other curses implementations, |
there's a subtle distinction, but it has no meaning in PDCurses. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
refresh Y Y Y |
wrefresh Y Y Y |
wnoutrefresh Y Y Y |
doupdate Y Y Y |
redrawwin Y Y Y |
wredrawln Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
int wnoutrefresh(WINDOW *win) |
{ |
int begy, begx; /* window's place on screen */ |
int i, j; |
PDC_LOG(("wnoutrefresh() - called: win=%p\n", win)); |
if ( !win || (win->_flags & (_PAD|_SUBPAD)) ) |
return ERR; |
begy = win->_begy; |
begx = win->_begx; |
for (i = 0, j = begy; i < win->_maxy; i++, j++) |
{ |
if (win->_firstch[i] != _NO_CHANGE) |
{ |
chtype *src = win->_y[i]; |
chtype *dest = curscr->_y[j] + begx; |
int first = win->_firstch[i]; /* first changed */ |
int last = win->_lastch[i]; /* last changed */ |
/* ignore areas on the outside that are marked as changed, |
but really aren't */ |
while (first <= last && src[first] == dest[first]) |
first++; |
while (last >= first && src[last] == dest[last]) |
last--; |
/* if any have really changed... */ |
if (first <= last) |
{ |
memcpy(dest + first, src + first, |
(last - first + 1) * sizeof(chtype)); |
first += begx; |
last += begx; |
if (first < curscr->_firstch[j] || |
curscr->_firstch[j] == _NO_CHANGE) |
curscr->_firstch[j] = first; |
if (last > curscr->_lastch[j]) |
curscr->_lastch[j] = last; |
} |
win->_firstch[i] = _NO_CHANGE; /* updated now */ |
} |
win->_lastch[i] = _NO_CHANGE; /* updated now */ |
} |
if (win->_clear) |
win->_clear = FALSE; |
if (!win->_leaveit) |
{ |
curscr->_cury = win->_cury + begy; |
curscr->_curx = win->_curx + begx; |
} |
return OK; |
} |
int doupdate(void) |
{ |
int y; |
bool clearall; |
PDC_LOG(("doupdate() - called\n")); |
if (!SP || !curscr) |
return ERR; |
if (isendwin()) /* coming back after endwin() called */ |
{ |
reset_prog_mode(); |
clearall = TRUE; |
SP->alive = TRUE; /* so isendwin() result is correct */ |
} |
else |
clearall = curscr->_clear; |
for (y = 0; y < SP->lines; y++) |
{ |
PDC_LOG(("doupdate() - Transforming line %d of %d: %s\n", |
y, SP->lines, (curscr->_firstch[y] != _NO_CHANGE) ? |
"Yes" : "No")); |
if (clearall || curscr->_firstch[y] != _NO_CHANGE) |
{ |
int first, last; |
chtype *src = curscr->_y[y]; |
chtype *dest = SP->lastscr->_y[y]; |
if (clearall) |
{ |
first = 0; |
last = COLS - 1; |
} |
else |
{ |
first = curscr->_firstch[y]; |
last = curscr->_lastch[y]; |
} |
while (first <= last) |
{ |
int len = 0; |
/* build up a run of changed cells; if two runs are |
separated by a single unchanged cell, ignore the |
break */ |
if (clearall) |
len = last - first + 1; |
else |
while (first + len <= last && |
(src[first + len] != dest[first + len] || |
(len && first + len < last && |
src[first + len + 1] != dest[first + len + 1]) |
) |
) |
len++; |
/* update the screen, and SP->lastscr */ |
if (len) |
{ |
PDC_transform_line(y, first, len, src + first); |
memcpy(dest + first, src + first, len * sizeof(chtype)); |
first += len; |
} |
/* skip over runs of unchanged cells */ |
while (first <= last && src[first] == dest[first]) |
first++; |
} |
curscr->_firstch[y] = _NO_CHANGE; |
curscr->_lastch[y] = _NO_CHANGE; |
} |
} |
curscr->_clear = FALSE; |
if (SP->visibility) |
PDC_gotoyx(curscr->_cury, curscr->_curx); |
SP->cursrow = curscr->_cury; |
SP->curscol = curscr->_curx; |
PDC_doupdate(); |
return OK; |
} |
int wrefresh(WINDOW *win) |
{ |
bool save_clear; |
PDC_LOG(("wrefresh() - called\n")); |
if ( !win || (win->_flags & (_PAD|_SUBPAD)) ) |
return ERR; |
save_clear = win->_clear; |
if (win == curscr) |
curscr->_clear = TRUE; |
else |
wnoutrefresh(win); |
if (save_clear && win->_maxy == SP->lines && win->_maxx == SP->cols) |
curscr->_clear = TRUE; |
return doupdate(); |
} |
int refresh(void) |
{ |
PDC_LOG(("refresh() - called\n")); |
return wrefresh(stdscr); |
} |
int wredrawln(WINDOW *win, int start, int num) |
{ |
int i; |
PDC_LOG(("wredrawln() - called: win=%p start=%d num=%d\n", |
win, start, num)); |
if (!win || start > win->_maxy || start + num > win->_maxy) |
return ERR; |
for (i = start; i < start + num; i++) |
{ |
win->_firstch[i] = 0; |
win->_lastch[i] = win->_maxx - 1; |
} |
return OK; |
} |
int redrawwin(WINDOW *win) |
{ |
PDC_LOG(("redrawwin() - called: win=%p\n", win)); |
if (!win) |
return ERR; |
return wredrawln(win, 0, win->_maxy); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/scanw.c |
---|
0,0 → 1,581 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
scanw |
----- |
### Synopsis |
int scanw(const char *fmt, ...); |
int wscanw(WINDOW *win, const char *fmt, ...); |
int mvscanw(int y, int x, const char *fmt, ...); |
int mvwscanw(WINDOW *win, int y, int x, const char *fmt, ...); |
int vwscanw(WINDOW *win, const char *fmt, va_list varglist); |
int vw_scanw(WINDOW *win, const char *fmt, va_list varglist); |
### Description |
These routines correspond to the standard C library's scanf() family. |
Each gets a string from the window via wgetnstr(), and uses the |
resulting line as input for the scan. |
The duplication between vwscanw() and vw_scanw() is for historic |
reasons. In PDCurses, they're the same. |
### Return Value |
On successful completion, these functions return the number of items |
successfully matched. Otherwise they return ERR. |
### Portability |
X/Open ncurses NetBSD |
scanw Y Y Y |
wscanw Y Y Y |
mvscanw Y Y Y |
mvwscanw Y Y Y |
vwscanw Y Y Y |
vw_scanw Y Y Y |
**man-end****************************************************************/ |
#include <string.h> |
#ifndef HAVE_VSSCANF |
# include <stdlib.h> |
# include <ctype.h> |
# include <limits.h> |
static int _pdc_vsscanf(const char *, const char *, va_list); |
# define vsscanf _pdc_vsscanf |
#endif |
int vwscanw(WINDOW *win, const char *fmt, va_list varglist) |
{ |
char scanbuf[256]; |
PDC_LOG(("vwscanw() - called\n")); |
if (wgetnstr(win, scanbuf, 255) == ERR) |
return ERR; |
return vsscanf(scanbuf, fmt, varglist); |
} |
int scanw(const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("scanw() - called\n")); |
va_start(args, fmt); |
retval = vwscanw(stdscr, fmt, args); |
va_end(args); |
return retval; |
} |
int wscanw(WINDOW *win, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("wscanw() - called\n")); |
va_start(args, fmt); |
retval = vwscanw(win, fmt, args); |
va_end(args); |
return retval; |
} |
int mvscanw(int y, int x, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("mvscanw() - called\n")); |
if (move(y, x) == ERR) |
return ERR; |
va_start(args, fmt); |
retval = vwscanw(stdscr, fmt, args); |
va_end(args); |
return retval; |
} |
int mvwscanw(WINDOW *win, int y, int x, const char *fmt, ...) |
{ |
va_list args; |
int retval; |
PDC_LOG(("mvscanw() - called\n")); |
if (wmove(win, y, x) == ERR) |
return ERR; |
va_start(args, fmt); |
retval = vwscanw(win, fmt, args); |
va_end(args); |
return retval; |
} |
int vw_scanw(WINDOW *win, const char *fmt, va_list varglist) |
{ |
PDC_LOG(("vw_scanw() - called\n")); |
return vwscanw(win, fmt, varglist); |
} |
#ifndef HAVE_VSSCANF |
/* _pdc_vsscanf() - Internal routine to parse and format an input |
buffer. It scans a series of input fields; each field is formatted |
according to a supplied format string and the formatted input is |
stored in the variable number of addresses passed. Returns the number |
of input fields or EOF on error. |
Don't compile this unless required. Some compilers (at least Borland |
C++ 3.0) have to link with math libraries due to the use of floats. |
Based on vsscanf.c and input.c from emx 0.8f library source, |
Copyright (c) 1990-1992 by Eberhard Mattes, who has kindly agreed to |
its inclusion in PDCurses. */ |
#define WHITE(x) ((x) == ' ' || (x) == '\t' || (x) == '\n') |
#define NEXT(x) \ |
do { \ |
x = *buf++; \ |
if (!x) \ |
return (count ? count : EOF); \ |
++chars; \ |
} while (0) |
#define UNGETC() \ |
do { \ |
--buf; --chars; \ |
} while (0) |
static int _pdc_vsscanf(const char *buf, const char *fmt, va_list arg_ptr) |
{ |
int count, chars, c, width, radix, d, i; |
int *int_ptr; |
long *long_ptr; |
short *short_ptr; |
char *char_ptr; |
unsigned char f; |
char neg, assign, ok, size; |
long n; |
char map[256], end; |
double dx, dd, *dbl_ptr; |
float *flt_ptr; |
int exp; |
char eneg; |
count = 0; |
chars = 0; |
c = 0; |
while ((f = *fmt) != 0) |
{ |
if (WHITE(f)) |
{ |
do |
{ |
++fmt; |
f = *fmt; |
} |
while (WHITE(f)); |
do |
{ |
c = *buf++; |
if (!c) |
{ |
if (!f || count) |
return count; |
else |
return EOF; |
} else |
++chars; |
} |
while (WHITE(c)); |
UNGETC(); |
} else if (f != '%') |
{ |
NEXT(c); |
if (c != f) |
return count; |
++fmt; |
} else |
{ |
assign = TRUE; |
width = INT_MAX; |
char_ptr = NULL; |
++fmt; |
if (*fmt == '*') |
{ |
assign = FALSE; |
++fmt; |
} |
if (isdigit(*fmt)) |
{ |
width = 0; |
while (isdigit(*fmt)) |
width = width * 10 + (*fmt++ - '0'); |
if (!width) |
width = INT_MAX; |
} |
size = 0; |
if (*fmt == 'h' || *fmt == 'l') |
size = *fmt++; |
f = *fmt; |
switch (f) |
{ |
case 'c': |
if (width == INT_MAX) |
width = 1; |
if (assign) |
char_ptr = va_arg(arg_ptr, char *); |
while (width > 0) |
{ |
--width; |
NEXT(c); |
if (assign) |
{ |
*char_ptr++ = (char) c; |
++count; |
} |
} |
break; |
case '[': |
memset(map, 0, 256); |
end = 0; |
++fmt; |
if (*fmt == '^') |
{ |
++fmt; |
end = 1; |
} |
i = 0; |
for (;;) |
{ |
f = (unsigned char) *fmt; |
switch (f) |
{ |
case 0: |
/* avoid skipping past 0 */ |
--fmt; |
NEXT(c); |
goto string; |
case ']': |
if (i > 0) |
{ |
NEXT(c); |
goto string; |
} |
/* no break */ |
default: |
if (fmt[1] == '-' && fmt[2] |
&& f < (unsigned char)fmt[2]) |
{ |
memset(map + f, 1, (unsigned char)fmt[2] - f); |
fmt += 2; |
} |
else |
map[f] = 1; |
break; |
} |
++fmt; |
++i; |
} |
case 's': |
memset(map, 0, 256); |
map[' '] = 1; |
map['\n'] = 1; |
map['\r'] = 1; |
map['\t'] = 1; |
end = 1; |
do |
{ |
NEXT(c); |
} |
while (WHITE(c)); |
string: |
if (assign) |
char_ptr = va_arg(arg_ptr, char *); |
while (width > 0 && map[(unsigned char) c] != end) |
{ |
--width; |
if (assign) |
*char_ptr++ = (char) c; |
c = *buf++; |
if (!c) |
break; |
else |
++chars; |
} |
if (assign) |
{ |
*char_ptr = 0; |
++count; |
} |
if (!c) |
return count; |
else |
UNGETC(); |
break; |
case 'f': |
case 'e': |
case 'E': |
case 'g': |
case 'G': |
neg = ok = FALSE; |
dx = 0.0; |
do |
{ |
NEXT(c); |
} |
while (WHITE(c)); |
if (c == '+') |
{ |
NEXT(c); |
--width; |
} else if (c == '-') |
{ |
neg = TRUE; |
NEXT(c); |
--width; |
} |
while (width > 0 && isdigit(c)) |
{ |
--width; |
dx = dx * 10.0 + (double) (c - '0'); |
ok = TRUE; |
c = *buf++; |
if (!c) |
break; |
else |
++chars; |
} |
if (width > 0 && c == '.') |
{ |
--width; |
dd = 10.0; |
NEXT(c); |
while (width > 0 && isdigit(c)) |
{ |
--width; |
dx += (double) (c - '0') / dd; |
dd *= 10.0; |
ok = TRUE; |
c = *buf++; |
if (!c) |
break; |
else |
++chars; |
} |
} |
if (!ok) |
return count; |
if (width > 0 && (c == 'e' || c == 'E')) |
{ |
eneg = FALSE; |
exp = 0; |
NEXT(c); |
--width; |
if (width > 0 && c == '+') |
{ |
NEXT(c); |
--width; |
} else if (width > 0 && c == '-') |
{ |
eneg = TRUE; |
NEXT(c); |
--width; |
} |
if (!(width > 0 && isdigit(c))) |
{ |
UNGETC(); |
return count; |
} |
while (width > 0 && isdigit(c)) |
{ |
--width; |
exp = exp * 10 + (c - '0'); |
c = *buf++; |
if (!c) |
break; |
else |
++chars; |
} |
if (eneg) |
exp = -exp; |
while (exp > 0) |
{ |
dx *= 10.0; |
--exp; |
} |
while (exp < 0) |
{ |
dx /= 10.0; |
++exp; |
} |
} |
if (assign) |
{ |
if (neg) |
dx = -dx; |
if (size == 'l') |
{ |
dbl_ptr = va_arg(arg_ptr, double *); |
*dbl_ptr = dx; |
} |
else |
{ |
flt_ptr = va_arg(arg_ptr, float *); |
*flt_ptr = (float)dx; |
} |
++count; |
} |
if (!c) |
return count; |
else |
UNGETC(); |
break; |
case 'i': |
neg = FALSE; |
radix = 10; |
do |
{ |
NEXT(c); |
} |
while (WHITE(c)); |
if (!(width > 0 && c == '0')) |
goto scan_complete_number; |
NEXT(c); |
--width; |
if (width > 0 && (c == 'x' || c == 'X')) |
{ |
NEXT(c); |
radix = 16; |
--width; |
} |
else if (width > 0 && (c >= '0' && c <= '7')) |
radix = 8; |
goto scan_unsigned_number; |
case 'd': |
case 'u': |
case 'o': |
case 'x': |
case 'X': |
do |
{ |
NEXT(c); |
} |
while (WHITE(c)); |
switch (f) |
{ |
case 'o': |
radix = 8; |
break; |
case 'x': |
case 'X': |
radix = 16; |
break; |
default: |
radix = 10; |
break; |
} |
scan_complete_number: |
neg = FALSE; |
if (width > 0 && c == '+') |
{ |
NEXT(c); |
--width; |
} |
else if (width > 0 && c == '-' && radix == 10) |
{ |
neg = TRUE; |
NEXT(c); |
--width; |
} |
scan_unsigned_number: |
n = 0; |
ok = FALSE; |
while (width > 0) |
{ |
--width; |
if (isdigit(c)) |
d = c - '0'; |
else if (isupper(c)) |
d = c - 'A' + 10; |
else if (islower(c)) |
d = c - 'a' + 10; |
else |
break; |
if (d < 0 || d >= radix) |
break; |
ok = TRUE; |
n = n * radix + d; |
c = *buf++; |
if (!c) |
break; |
else |
++chars; |
} |
if (!ok) |
return count; |
if (assign) |
{ |
if (neg) |
n = -n; |
switch (size) |
{ |
case 'h': |
short_ptr = va_arg(arg_ptr, short *); |
*short_ptr = (short) n; |
break; |
case 'l': |
long_ptr = va_arg(arg_ptr, long *); |
*long_ptr = (long) n; |
break; |
default: |
int_ptr = va_arg(arg_ptr, int *); |
*int_ptr = (int) n; |
} |
++count; |
} |
if (!c) |
return count; |
else |
UNGETC(); |
break; |
case 'n': |
if (assign) |
{ |
int_ptr = va_arg(arg_ptr, int *); |
*int_ptr = chars; |
++count; |
} |
break; |
default: |
if (!f) /* % at end of string */ |
return count; |
NEXT(c); |
if (c != f) |
return count; |
break; |
} |
++fmt; |
} |
} |
return count; |
} |
#endif /* HAVE_VSSCANF */ |
/contrib/sdk/sources/PDCurses/pdcurses/scr_dump.c |
---|
0,0 → 1,217 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
scr_dump |
-------- |
### Synopsis |
int putwin(WINDOW *win, FILE *filep); |
WINDOW *getwin(FILE *filep); |
int scr_dump(const char *filename); |
int scr_init(const char *filename); |
int scr_restore(const char *filename); |
int scr_set(const char *filename); |
### Description |
getwin() reads window-related data previously stored in a file by |
putwin(). It then creates and initialises a new window using that |
data. |
putwin() writes all data associated with a window into a file, using |
an unspecified format. This information can be retrieved later using |
getwin(). |
scr_dump() writes the current contents of the virtual screen to the |
file named by filename in an unspecified format. |
scr_restore() function sets the virtual screen to the contents of the |
file named by filename, which must have been written using |
scr_dump(). The next refresh operation restores the screen to the way |
it looked in the dump file. |
In PDCurses, scr_init() does nothing, and scr_set() is a synonym for |
scr_restore(). Also, scr_dump() and scr_restore() save and load from |
curscr. This differs from some other implementations, where |
scr_init() works with curscr, and scr_restore() works with newscr; |
but the effect should be the same. (PDCurses has no newscr.) |
### Return Value |
On successful completion, getwin() returns a pointer to the window it |
created. Otherwise, it returns a null pointer. Other functions return |
OK or ERR. |
### Portability |
X/Open ncurses NetBSD |
putwin Y Y Y |
getwin Y Y Y |
scr_dump Y Y - |
scr_init Y Y - |
scr_restore Y Y - |
scr_set Y Y - |
**man-end****************************************************************/ |
#include <stdlib.h> |
#include <string.h> |
#define DUMPVER 1 /* Should be updated whenever the WINDOW struct is |
changed */ |
int putwin(WINDOW *win, FILE *filep) |
{ |
static const char *marker = "PDC"; |
static const unsigned char version = DUMPVER; |
PDC_LOG(("putwin() - called\n")); |
/* write the marker and the WINDOW struct */ |
if (filep && fwrite(marker, strlen(marker), 1, filep) |
&& fwrite(&version, 1, 1, filep) |
&& fwrite(win, sizeof(WINDOW), 1, filep)) |
{ |
int i; |
/* write each line */ |
for (i = 0; i < win->_maxy && win->_y[i]; i++) |
if (!fwrite(win->_y[i], win->_maxx * sizeof(chtype), 1, filep)) |
return ERR; |
return OK; |
} |
return ERR; |
} |
WINDOW *getwin(FILE *filep) |
{ |
WINDOW *win; |
char marker[4]; |
int i, nlines, ncols; |
PDC_LOG(("getwin() - called\n")); |
win = malloc(sizeof(WINDOW)); |
if (!win) |
return (WINDOW *)NULL; |
/* check for the marker, and load the WINDOW struct */ |
if (!filep || !fread(marker, 4, 1, filep) || strncmp(marker, "PDC", 3) |
|| marker[3] != DUMPVER || !fread(win, sizeof(WINDOW), 1, filep)) |
{ |
free(win); |
return (WINDOW *)NULL; |
} |
nlines = win->_maxy; |
ncols = win->_maxx; |
/* allocate the line pointer array */ |
win->_y = malloc(nlines * sizeof(chtype *)); |
if (!win->_y) |
{ |
free(win); |
return (WINDOW *)NULL; |
} |
/* allocate the minchng and maxchng arrays */ |
win->_firstch = malloc(nlines * sizeof(int)); |
if (!win->_firstch) |
{ |
free(win->_y); |
free(win); |
return (WINDOW *)NULL; |
} |
win->_lastch = malloc(nlines * sizeof(int)); |
if (!win->_lastch) |
{ |
free(win->_firstch); |
free(win->_y); |
free(win); |
return (WINDOW *)NULL; |
} |
/* allocate the lines */ |
win = PDC_makelines(win); |
if (!win) |
return (WINDOW *)NULL; |
/* read them */ |
for (i = 0; i < nlines; i++) |
{ |
if (!fread(win->_y[i], ncols * sizeof(chtype), 1, filep)) |
{ |
delwin(win); |
return (WINDOW *)NULL; |
} |
} |
touchwin(win); |
return win; |
} |
int scr_dump(const char *filename) |
{ |
FILE *filep; |
PDC_LOG(("scr_dump() - called: filename %s\n", filename)); |
if (filename && (filep = fopen(filename, "wb")) != NULL) |
{ |
int result = putwin(curscr, filep); |
fclose(filep); |
return result; |
} |
return ERR; |
} |
int scr_init(const char *filename) |
{ |
PDC_LOG(("scr_init() - called: filename %s\n", filename)); |
return OK; |
} |
int scr_restore(const char *filename) |
{ |
FILE *filep; |
PDC_LOG(("scr_restore() - called: filename %s\n", filename)); |
if (filename && (filep = fopen(filename, "rb")) != NULL) |
{ |
WINDOW *replacement = getwin(filep); |
fclose(filep); |
if (replacement) |
{ |
int result = overwrite(replacement, curscr); |
delwin(replacement); |
return result; |
} |
} |
return ERR; |
} |
int scr_set(const char *filename) |
{ |
PDC_LOG(("scr_set() - called: filename %s\n", filename)); |
return scr_restore(filename); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/scroll.c |
---|
0,0 → 1,101 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
scroll |
------ |
### Synopsis |
int scroll(WINDOW *win); |
int scrl(int n); |
int wscrl(WINDOW *win, int n); |
### Description |
scroll() causes the window to scroll up one line. This involves |
moving the lines in the window data strcture. |
With a positive n, scrl() and wscrl() scroll the window up n lines |
(line i + n becomes i); otherwise they scroll the window down n |
lines. |
For these functions to work, scrolling must be enabled via |
scrollok(). Note also that scrolling is not allowed if the supplied |
window is a pad. |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
scroll Y Y Y |
scrl Y Y Y |
wscrl Y Y Y |
**man-end****************************************************************/ |
int wscrl(WINDOW *win, int n) |
{ |
int i, l, dir, start, end; |
chtype blank, *temp; |
/* Check if window scrolls. Valid for window AND pad */ |
if (!win || !win->_scroll || !n) |
return ERR; |
blank = win->_bkgd; |
if (n > 0) |
{ |
start = win->_tmarg; |
end = win->_bmarg; |
dir = 1; |
} |
else |
{ |
start = win->_bmarg; |
end = win->_tmarg; |
dir = -1; |
} |
for (l = 0; l < (n * dir); l++) |
{ |
temp = win->_y[start]; |
/* re-arrange line pointers */ |
for (i = start; i != end; i += dir) |
win->_y[i] = win->_y[i + dir]; |
win->_y[end] = temp; |
/* make a blank line */ |
for (i = 0; i < win->_maxx; i++) |
*temp++ = blank; |
} |
touchline(win, win->_tmarg, win->_bmarg - win->_tmarg + 1); |
PDC_sync(win); |
return OK; |
} |
int scrl(int n) |
{ |
PDC_LOG(("scrl() - called\n")); |
return wscrl(stdscr, n); |
} |
int scroll(WINDOW *win) |
{ |
PDC_LOG(("scroll() - called\n")); |
return wscrl(win, 1); |
} |
/contrib/sdk/sources/PDCurses/pdcurses/slk.c |
---|
0,0 → 1,671 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
slk |
--- |
### Synopsis |
int slk_init(int fmt); |
int slk_set(int labnum, const char *label, int justify); |
int slk_refresh(void); |
int slk_noutrefresh(void); |
char *slk_label(int labnum); |
int slk_clear(void); |
int slk_restore(void); |
int slk_touch(void); |
int slk_attron(const chtype attrs); |
int slk_attr_on(const attr_t attrs, void *opts); |
int slk_attrset(const chtype attrs); |
int slk_attr_set(const attr_t attrs, short color_pair, void *opts); |
int slk_attroff(const chtype attrs); |
int slk_attr_off(const attr_t attrs, void *opts); |
int slk_color(short color_pair); |
int slk_wset(int labnum, const wchar_t *label, int justify); |
int PDC_mouse_in_slk(int y, int x); |
void PDC_slk_free(void); |
void PDC_slk_initialize(void); |
wchar_t *slk_wlabel(int labnum) |
### Description |
These functions manipulate a window that contain Soft Label Keys |
(SLK). To use the SLK functions, a call to slk_init() must be made |
BEFORE initscr() or newterm(). slk_init() removes 1 or 2 lines from |
the useable screen, depending on the format selected. |
The line(s) removed from the screen are used as a separate window, in |
which SLKs are displayed. |
slk_init() requires a single parameter which describes the format of |
the SLKs as follows: |
0 3-2-3 format |
1 4-4 format |
2 4-4-4 format (ncurses extension) |
3 4-4-4 format with index line (ncurses extension) |
2 lines used |
55 5-5 format (pdcurses format) |
slk_refresh(), slk_noutrefresh() and slk_touch() are analogous to |
refresh(), noutrefresh() and touch(). |
### Return Value |
All functions return OK on success and ERR on error. |
### Portability |
X/Open ncurses NetBSD |
slk_init Y Y Y |
slk_set Y Y Y |
slk_refresh Y Y Y |
slk_noutrefresh Y Y Y |
slk_label Y Y Y |
slk_clear Y Y Y |
slk_restore Y Y Y |
slk_touch Y Y Y |
slk_attron Y Y Y |
slk_attrset Y Y Y |
slk_attroff Y Y Y |
slk_attr_on Y Y Y |
slk_attr_set Y Y Y |
slk_attr_off Y Y Y |
slk_wset Y Y Y |
PDC_mouse_in_slk - - - |
PDC_slk_free - - - |
PDC_slk_initialize - - - |
slk_wlabel - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
enum { LABEL_NORMAL = 8, LABEL_EXTENDED = 10, LABEL_NCURSES_EXTENDED = 12 }; |
static int label_length = 0; |
static int labels = 0; |
static int label_fmt = 0; |
static int label_line = 0; |
static bool hidden = FALSE; |
static struct SLK { |
chtype label[32]; |
int len; |
int format; |
int start_col; |
} *slk = (struct SLK *)NULL; |
/* slk_init() is the slk initialization routine. |
This must be called before initscr(). |
label_fmt = 0, 1 or 55. |
0 = 3-2-3 format |
1 = 4 - 4 format |
2 = 4-4-4 format (ncurses extension for PC 12 function keys) |
3 = 4-4-4 format (ncurses extension for PC 12 function keys - |
with index line) |
55 = 5 - 5 format (extended for PC, 10 function keys) */ |
int slk_init(int fmt) |
{ |
PDC_LOG(("slk_init() - called\n")); |
if (SP) |
return ERR; |
switch (fmt) |
{ |
case 0: /* 3 - 2 - 3 */ |
labels = LABEL_NORMAL; |
break; |
case 1: /* 4 - 4 */ |
labels = LABEL_NORMAL; |
break; |
case 2: /* 4 4 4 */ |
labels = LABEL_NCURSES_EXTENDED; |
break; |
case 3: /* 4 4 4 with index */ |
labels = LABEL_NCURSES_EXTENDED; |
break; |
case 55: /* 5 - 5 */ |
labels = LABEL_EXTENDED; |
break; |
default: |
return ERR; |
} |
label_fmt = fmt; |
slk = calloc(labels, sizeof(struct SLK)); |
if (!slk) |
labels = 0; |
return slk ? OK : ERR; |
} |
/* draw a single button */ |
static void _drawone(int num) |
{ |
int i, col, slen; |
if (hidden) |
return; |
slen = slk[num].len; |
switch (slk[num].format) |
{ |
case 0: /* LEFT */ |
col = 0; |
break; |
case 1: /* CENTER */ |
col = (label_length - slen) / 2; |
if (col + slen > label_length) |
--col; |
break; |
default: /* RIGHT */ |
col = label_length - slen; |
} |
wmove(SP->slk_winptr, label_line, slk[num].start_col); |
for (i = 0; i < label_length; ++i) |
waddch(SP->slk_winptr, (i >= col && i < (col + slen)) ? |
slk[num].label[i - col] : ' '); |
} |
/* redraw each button */ |
static void _redraw(void) |
{ |
int i; |
for (i = 0; i < labels; ++i) |
_drawone(i); |
} |
/* slk_set() Used to set a slk label to a string. |
labnum = 1 - 8 (or 10) (number of the label) |
label = string (8 or 7 bytes total), or NULL |
justify = 0 : left, 1 : center, 2 : right */ |
int slk_set(int labnum, const char *label, int justify) |
{ |
#ifdef PDC_WIDE |
wchar_t wlabel[32]; |
PDC_mbstowcs(wlabel, label, 31); |
return slk_wset(labnum, wlabel, justify); |
#else |
PDC_LOG(("slk_set() - called\n")); |
if (labnum < 1 || labnum > labels || justify < 0 || justify > 2) |
return ERR; |
labnum--; |
if (!label || !(*label)) |
{ |
/* Clear the label */ |
*slk[labnum].label = 0; |
slk[labnum].format = 0; |
slk[labnum].len = 0; |
} |
else |
{ |
int i, j = 0; |
/* Skip leading spaces */ |
while (label[j] == ' ') |
j++; |
/* Copy it */ |
for (i = 0; i < label_length; i++) |
{ |
chtype ch = label[i + j]; |
slk[labnum].label[i] = ch; |
if (!ch) |
break; |
} |
/* Drop trailing spaces */ |
while ((i + j) && (label[i + j - 1] == ' ')) |
i--; |
slk[labnum].label[i] = 0; |
slk[labnum].format = justify; |
slk[labnum].len = i; |
} |
_drawone(labnum); |
return OK; |
#endif |
} |
int slk_refresh(void) |
{ |
PDC_LOG(("slk_refresh() - called\n")); |
return (slk_noutrefresh() == ERR) ? ERR : doupdate(); |
} |
int slk_noutrefresh(void) |
{ |
PDC_LOG(("slk_noutrefresh() - called\n")); |
if (!SP) |
return ERR; |
return wnoutrefresh(SP->slk_winptr); |
} |
char *slk_label(int labnum) |
{ |
static char temp[33]; |
#ifdef PDC_WIDE |
wchar_t *wtemp = slk_wlabel(labnum); |
PDC_wcstombs(temp, wtemp, 32); |
#else |
chtype *p; |
int i; |
PDC_LOG(("slk_label() - called\n")); |
if (labnum < 1 || labnum > labels) |
return (char *)0; |
for (i = 0, p = slk[labnum - 1].label; *p; i++) |
temp[i] = *p++; |
temp[i] = '\0'; |
#endif |
return temp; |
} |
int slk_clear(void) |
{ |
PDC_LOG(("slk_clear() - called\n")); |
if (!SP) |
return ERR; |
hidden = TRUE; |
werase(SP->slk_winptr); |
return wrefresh(SP->slk_winptr); |
} |
int slk_restore(void) |
{ |
PDC_LOG(("slk_restore() - called\n")); |
if (!SP) |
return ERR; |
hidden = FALSE; |
_redraw(); |
return wrefresh(SP->slk_winptr); |
} |
int slk_touch(void) |
{ |
PDC_LOG(("slk_touch() - called\n")); |
if (!SP) |
return ERR; |
return touchwin(SP->slk_winptr); |
} |
int slk_attron(const chtype attrs) |
{ |
int rc; |
PDC_LOG(("slk_attron() - called\n")); |
if (!SP) |
return ERR; |
rc = wattron(SP->slk_winptr, attrs); |
_redraw(); |
return rc; |
} |
int slk_attr_on(const attr_t attrs, void *opts) |
{ |
PDC_LOG(("slk_attr_on() - called\n")); |
return slk_attron(attrs); |
} |
int slk_attroff(const chtype attrs) |
{ |
int rc; |
PDC_LOG(("slk_attroff() - called\n")); |
if (!SP) |
return ERR; |
rc = wattroff(SP->slk_winptr, attrs); |
_redraw(); |
return rc; |
} |
int slk_attr_off(const attr_t attrs, void *opts) |
{ |
PDC_LOG(("slk_attr_off() - called\n")); |
return slk_attroff(attrs); |
} |
int slk_attrset(const chtype attrs) |
{ |
int rc; |
PDC_LOG(("slk_attrset() - called\n")); |
if (!SP) |
return ERR; |
rc = wattrset(SP->slk_winptr, attrs); |
_redraw(); |
return rc; |
} |
int slk_color(short color_pair) |
{ |
int rc; |
PDC_LOG(("slk_color() - called\n")); |
if (!SP) |
return ERR; |
rc = wcolor_set(SP->slk_winptr, color_pair, NULL); |
_redraw(); |
return rc; |
} |
int slk_attr_set(const attr_t attrs, short color_pair, void *opts) |
{ |
PDC_LOG(("slk_attr_set() - called\n")); |
return slk_attrset(attrs | COLOR_PAIR(color_pair)); |
} |
static void _slk_calc(void) |
{ |
int i, center, col = 0; |
label_length = COLS / labels; |
if (label_length > 31) |
label_length = 31; |
switch (label_fmt) |
{ |
case 0: /* 3 - 2 - 3 F-Key layout */ |
--label_length; |
slk[0].start_col = col; |
slk[1].start_col = (col += label_length); |
slk[2].start_col = (col += label_length); |
center = COLS / 2; |
slk[3].start_col = center - label_length + 1; |
slk[4].start_col = center + 1; |
col = COLS - (label_length * 3) + 1; |
slk[5].start_col = col; |
slk[6].start_col = (col += label_length); |
slk[7].start_col = (col += label_length); |
break; |
case 1: /* 4 - 4 F-Key layout */ |
for (i = 0; i < 8; i++) |
{ |
slk[i].start_col = col; |
col += label_length; |
if (i == 3) |
col = COLS - (label_length * 4) + 1; |
} |
break; |
case 2: /* 4 4 4 F-Key layout */ |
case 3: /* 4 4 4 F-Key layout with index */ |
for (i = 0; i < 4; i++) |
{ |
slk[i].start_col = col; |
col += label_length; |
} |
center = COLS / 2; |
slk[4].start_col = center - (label_length * 2) + 1; |
slk[5].start_col = center - label_length + 1; |
slk[6].start_col = center + 1; |
slk[7].start_col = center + label_length + 1; |
col = COLS - (label_length * 4) + 1; |
for (i = 8; i < 12; i++) |
{ |
slk[i].start_col = col; |
col += label_length; |
} |
break; |
default: /* 5 - 5 F-Key layout */ |
for (i = 0; i < 10; i++) |
{ |
slk[i].start_col = col; |
col += label_length; |
if (i == 4) |
col = COLS - (label_length * 5) + 1; |
} |
} |
--label_length; |
/* make sure labels are all in window */ |
_redraw(); |
} |
void PDC_slk_initialize(void) |
{ |
if (slk) |
{ |
if (label_fmt == 3) |
{ |
SP->slklines = 2; |
label_line = 1; |
} |
else |
SP->slklines = 1; |
if (!SP->slk_winptr) |
{ |
SP->slk_winptr = newwin(SP->slklines, COLS, |
LINES - SP->slklines, 0); |
if (!SP->slk_winptr) |
return; |
wattrset(SP->slk_winptr, A_REVERSE); |
} |
_slk_calc(); |
/* if we have an index line, display it now */ |
if (label_fmt == 3) |
{ |
chtype save_attr; |
int i; |
save_attr = SP->slk_winptr->_attrs; |
wattrset(SP->slk_winptr, A_NORMAL); |
wmove(SP->slk_winptr, 0, 0); |
whline(SP->slk_winptr, 0, COLS); |
for (i = 0; i < labels; i++) |
mvwprintw(SP->slk_winptr, 0, slk[i].start_col, "F%d", i + 1); |
SP->slk_winptr->_attrs = save_attr; |
} |
touchwin(SP->slk_winptr); |
} |
} |
void PDC_slk_free(void) |
{ |
if (slk) |
{ |
if (SP->slk_winptr) |
{ |
delwin(SP->slk_winptr); |
SP->slk_winptr = (WINDOW *)NULL; |
} |
free(slk); |
slk = (struct SLK *)NULL; |
label_length = 0; |
labels = 0; |
label_fmt = 0; |
label_line = 0; |
hidden = FALSE; |
} |
} |
int PDC_mouse_in_slk(int y, int x) |
{ |
int i; |
PDC_LOG(("PDC_mouse_in_slk() - called: y->%d x->%d\n", y, x)); |
/* If the line on which the mouse was clicked is NOT the last line |
of the screen, we are not interested in it. */ |
if (!slk || !SP->slk_winptr || (y != SP->slk_winptr->_begy + label_line)) |
return 0; |
for (i = 0; i < labels; i++) |
if (x >= slk[i].start_col && x < (slk[i].start_col + label_length)) |
return i + 1; |
return 0; |
} |
#ifdef PDC_WIDE |
int slk_wset(int labnum, const wchar_t *label, int justify) |
{ |
PDC_LOG(("slk_wset() - called\n")); |
if (labnum < 1 || labnum > labels || justify < 0 || justify > 2) |
return ERR; |
labnum--; |
if (!label || !(*label)) |
{ |
/* Clear the label */ |
*slk[labnum].label = 0; |
slk[labnum].format = 0; |
slk[labnum].len = 0; |
} |
else |
{ |
int i, j = 0; |
/* Skip leading spaces */ |
while (label[j] == L' ') |
j++; |
/* Copy it */ |
for (i = 0; i < label_length; i++) |
{ |
chtype ch = label[i + j]; |
slk[labnum].label[i] = ch; |
if (!ch) |
break; |
} |
/* Drop trailing spaces */ |
while ((i + j) && (label[i + j - 1] == L' ')) |
i--; |
slk[labnum].label[i] = 0; |
slk[labnum].format = justify; |
slk[labnum].len = i; |
} |
_drawone(labnum); |
return OK; |
} |
wchar_t *slk_wlabel(int labnum) |
{ |
static wchar_t temp[33]; |
chtype *p; |
int i; |
PDC_LOG(("slk_wlabel() - called\n")); |
if (labnum < 1 || labnum > labels) |
return (wchar_t *)0; |
for (i = 0, p = slk[labnum - 1].label; *p; i++) |
temp[i] = *p++; |
temp[i] = '\0'; |
return temp; |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/termattr.c |
---|
0,0 → 1,172 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
termattr |
-------- |
### Synopsis |
int baudrate(void); |
char erasechar(void); |
bool has_ic(void); |
bool has_il(void); |
char killchar(void); |
char *longname(void); |
chtype termattrs(void); |
attr_t term_attrs(void); |
char *termname(void); |
int erasewchar(wchar_t *ch); |
int killwchar(wchar_t *ch); |
char wordchar(void); |
### Description |
baudrate() is supposed to return the output speed of the terminal. In |
PDCurses, it simply returns INT_MAX. |
has_ic and has_il() return TRUE. These functions have meaning in some |
other implementations of curses. |
erasechar() and killchar() return ^H and ^U, respectively -- the |
ERASE and KILL characters. In other curses implementations, these may |
vary by terminal type. erasewchar() and killwchar() are the wide- |
character versions; they take a pointer to a location in which to |
store the character, and return OK or ERR. |
longname() returns a pointer to a static area containing a verbose |
description of the current terminal. The maximum length of the string |
is 128 characters. It is defined only after the call to initscr() or |
newterm(). |
termname() returns a pointer to a static area containing a short |
description of the current terminal (14 characters). |
termattrs() returns a logical OR of all video attributes supported by |
the terminal. |
wordchar() is a PDCurses extension of the concept behind the |
functions erasechar() and killchar(), returning the "delete word" |
character, ^W. |
### Portability |
X/Open ncurses NetBSD |
baudrate Y Y Y |
erasechar Y Y Y |
has_ic Y Y Y |
has_il Y Y Y |
killchar Y Y Y |
longname Y Y Y |
termattrs Y Y Y |
termname Y Y Y |
erasewchar Y Y Y |
killwchar Y Y Y |
term_attrs Y Y Y |
wordchar - - - |
**man-end****************************************************************/ |
#include <string.h> |
#include <limits.h> |
int baudrate(void) |
{ |
PDC_LOG(("baudrate() - called\n")); |
return INT_MAX; |
} |
char erasechar(void) |
{ |
PDC_LOG(("erasechar() - called\n")); |
return _ECHAR; /* character delete char (^H) */ |
} |
bool has_ic(void) |
{ |
PDC_LOG(("has_ic() - called\n")); |
return TRUE; |
} |
bool has_il(void) |
{ |
PDC_LOG(("has_il() - called\n")); |
return TRUE; |
} |
char killchar(void) |
{ |
PDC_LOG(("killchar() - called\n")); |
return _DLCHAR; /* line delete char (^U) */ |
} |
char *longname(void) |
{ |
PDC_LOG(("longname() - called\n")); |
return ttytype + 9; /* skip "pdcurses|" */ |
} |
chtype termattrs(void) |
{ |
PDC_LOG(("termattrs() - called\n")); |
return SP ? SP->termattrs : (chtype)0; |
} |
attr_t term_attrs(void) |
{ |
PDC_LOG(("term_attrs() - called\n")); |
return SP ? SP->termattrs : (attr_t)0; |
} |
char *termname(void) |
{ |
static char _termname[14] = "pdcurses"; |
PDC_LOG(("termname() - called\n")); |
return _termname; |
} |
char wordchar(void) |
{ |
PDC_LOG(("wordchar() - called\n")); |
return _DWCHAR; /* word delete char */ |
} |
#ifdef PDC_WIDE |
int erasewchar(wchar_t *ch) |
{ |
PDC_LOG(("erasewchar() - called\n")); |
if (!ch) |
return ERR; |
*ch = (wchar_t)_ECHAR; |
return OK; |
} |
int killwchar(wchar_t *ch) |
{ |
PDC_LOG(("killwchar() - called\n")); |
if (!ch) |
return ERR; |
*ch = (wchar_t)_DLCHAR; |
return OK; |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/touch.c |
---|
0,0 → 1,199 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
touch |
----- |
### Synopsis |
int touchwin(WINDOW *win); |
int touchline(WINDOW *win, int start, int count); |
int untouchwin(WINDOW *win); |
int wtouchln(WINDOW *win, int y, int n, int changed); |
bool is_linetouched(WINDOW *win, int line); |
bool is_wintouched(WINDOW *win); |
int touchoverlap(const WINDOW *win1, WINDOW *win2); |
### Description |
touchwin() and touchline() throw away all information about which |
parts of the window have been touched, pretending that the entire |
window has been drawn on. This is sometimes necessary when using |
overlapping windows, since a change to one window will affect the |
other window, but the records of which lines have been changed in the |
other window will not reflect the change. |
untouchwin() marks all lines in the window as unchanged since the |
last call to wrefresh(). |
wtouchln() makes n lines in the window, starting at line y, look as |
if they have (changed == 1) or have not (changed == 0) been changed |
since the last call to wrefresh(). |
is_linetouched() returns TRUE if the specified line in the specified |
window has been changed since the last call to wrefresh(). |
is_wintouched() returns TRUE if the specified window has been changed |
since the last call to wrefresh(). |
touchoverlap(win1, win2) marks the portion of win2 which overlaps |
with win1 as modified. |
### Return Value |
All functions return OK on success and ERR on error except |
is_wintouched() and is_linetouched(). |
### Portability |
X/Open ncurses NetBSD |
touchwin Y Y Y |
touchline Y Y Y |
untouchwin Y Y Y |
wtouchln Y Y Y |
is_linetouched Y Y Y |
is_wintouched Y Y Y |
touchoverlap - - Y |
**man-end****************************************************************/ |
int touchwin(WINDOW *win) |
{ |
int i; |
PDC_LOG(("touchwin() - called: Win=%x\n", win)); |
if (!win) |
return ERR; |
for (i = 0; i < win->_maxy; i++) |
{ |
win->_firstch[i] = 0; |
win->_lastch[i] = win->_maxx - 1; |
} |
return OK; |
} |
int touchline(WINDOW *win, int start, int count) |
{ |
int i; |
PDC_LOG(("touchline() - called: win=%p start %d count %d\n", |
win, start, count)); |
if (!win || start > win->_maxy || start + count > win->_maxy) |
return ERR; |
for (i = start; i < start + count; i++) |
{ |
win->_firstch[i] = 0; |
win->_lastch[i] = win->_maxx - 1; |
} |
return OK; |
} |
int untouchwin(WINDOW *win) |
{ |
int i; |
PDC_LOG(("untouchwin() - called: win=%p", win)); |
if (!win) |
return ERR; |
for (i = 0; i < win->_maxy; i++) |
{ |
win->_firstch[i] = _NO_CHANGE; |
win->_lastch[i] = _NO_CHANGE; |
} |
return OK; |
} |
int wtouchln(WINDOW *win, int y, int n, int changed) |
{ |
int i; |
PDC_LOG(("wtouchln() - called: win=%p y=%d n=%d changed=%d\n", |
win, y, n, changed)); |
if (!win || y > win->_maxy || y + n > win->_maxy) |
return ERR; |
for (i = y; i < y + n; i++) |
{ |
if (changed) |
{ |
win->_firstch[i] = 0; |
win->_lastch[i] = win->_maxx - 1; |
} |
else |
{ |
win->_firstch[i] = _NO_CHANGE; |
win->_lastch[i] = _NO_CHANGE; |
} |
} |
return OK; |
} |
bool is_linetouched(WINDOW *win, int line) |
{ |
PDC_LOG(("is_linetouched() - called: win=%p line=%d\n", win, line)); |
if (!win || line > win->_maxy || line < 0) |
return FALSE; |
return (win->_firstch[line] != _NO_CHANGE) ? TRUE : FALSE; |
} |
bool is_wintouched(WINDOW *win) |
{ |
int i; |
PDC_LOG(("is_wintouched() - called: win=%p\n", win)); |
if (win) |
for (i = 0; i < win->_maxy; i++) |
if (win->_firstch[i] != _NO_CHANGE) |
return TRUE; |
return FALSE; |
} |
int touchoverlap(const WINDOW *win1, WINDOW *win2) |
{ |
int y, endy, endx, starty, startx; |
PDC_LOG(("touchoverlap() - called: win1=%p win2=%p\n", win1, win2)); |
if (!win1 || !win2) |
return ERR; |
starty = max(win1->_begy, win2->_begy); |
startx = max(win1->_begx, win2->_begx); |
endy = min(win1->_maxy + win1->_begy, win2->_maxy + win2->_begy); |
endx = min(win1->_maxx + win1->_begx, win2->_maxx + win2->_begx); |
if (starty >= endy || startx >= endx) |
return OK; |
starty -= win2->_begy; |
startx -= win2->_begx; |
endy -= win2->_begy; |
endx -= win2->_begx; |
endx -= 1; |
for (y = starty; y < endy; y++) |
{ |
win2->_firstch[y] = startx; |
win2->_lastch[y] = endx; |
} |
return OK; |
} |
/contrib/sdk/sources/PDCurses/pdcurses/util.c |
---|
0,0 → 1,308 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
util |
---- |
### Synopsis |
char *unctrl(chtype c); |
void filter(void); |
void use_env(bool x); |
int delay_output(int ms); |
int getcchar(const cchar_t *wcval, wchar_t *wch, attr_t *attrs, |
short *color_pair, void *opts); |
int setcchar(cchar_t *wcval, const wchar_t *wch, const attr_t attrs, |
short color_pair, const void *opts); |
wchar_t *wunctrl(cchar_t *wc); |
int PDC_mbtowc(wchar_t *pwc, const char *s, size_t n); |
size_t PDC_mbstowcs(wchar_t *dest, const char *src, size_t n); |
size_t PDC_wcstombs(char *dest, const wchar_t *src, size_t n); |
### Description |
unctrl() expands the text portion of the chtype c into a printable |
string. Control characters are changed to the "^X" notation; others |
are passed through. wunctrl() is the wide-character version of the |
function. |
filter() and use_env() are no-ops in PDCurses. |
delay_output() inserts an ms millisecond pause in output. |
getcchar() works in two modes: When wch is not NULL, it reads the |
cchar_t pointed to by wcval and stores the attributes in attrs, the |
color pair in color_pair, and the text in the wide-character string |
wch. When wch is NULL, getcchar() merely returns the number of wide |
characters in wcval. In either mode, the opts argument is unused. |
setcchar constructs a cchar_t at wcval from the wide-character text |
at wch, the attributes in attr and the color pair in color_pair. The |
opts argument is unused. |
Currently, the length returned by getcchar() is always 1 or 0. |
Similarly, setcchar() will only take the first wide character from |
wch, and ignore any others that it "should" take (i.e., combining |
characters). Nor will it correctly handle any character outside the |
basic multilingual plane (UCS-2). |
### Return Value |
wunctrl() returns NULL on failure. delay_output() always returns OK. |
getcchar() returns the number of wide characters wcval points to when |
wch is NULL; when it's not, getcchar() returns OK or ERR. |
setcchar() returns OK or ERR. |
### Portability |
X/Open ncurses NetBSD |
unctrl Y Y Y |
filter Y Y Y |
use_env Y Y Y |
delay_output Y Y Y |
getcchar Y Y Y |
setcchar Y Y Y |
wunctrl Y Y Y |
PDC_mbtowc - - - |
PDC_mbstowcs - - - |
PDC_wcstombs - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
#include <string.h> |
char *unctrl(chtype c) |
{ |
static char strbuf[3] = {0, 0, 0}; |
chtype ic; |
PDC_LOG(("unctrl() - called\n")); |
ic = c & A_CHARTEXT; |
if (ic >= 0x20 && ic != 0x7f) /* normal characters */ |
{ |
strbuf[0] = (char)ic; |
strbuf[1] = '\0'; |
return strbuf; |
} |
strbuf[0] = '^'; /* '^' prefix */ |
if (ic == 0x7f) /* 0x7f == DEL */ |
strbuf[1] = '?'; |
else /* other control */ |
strbuf[1] = (char)(ic + '@'); |
return strbuf; |
} |
void filter(void) |
{ |
PDC_LOG(("filter() - called\n")); |
} |
void use_env(bool x) |
{ |
PDC_LOG(("use_env() - called: x %d\n", x)); |
} |
int delay_output(int ms) |
{ |
PDC_LOG(("delay_output() - called: ms %d\n", ms)); |
return napms(ms); |
} |
#ifdef PDC_WIDE |
int getcchar(const cchar_t *wcval, wchar_t *wch, attr_t *attrs, |
short *color_pair, void *opts) |
{ |
if (!wcval) |
return ERR; |
if (wch) |
{ |
if (!attrs || !color_pair) |
return ERR; |
*wch = (*wcval & A_CHARTEXT); |
*attrs = (*wcval & (A_ATTRIBUTES & ~A_COLOR)); |
*color_pair = PAIR_NUMBER(*wcval & A_COLOR); |
if (*wch) |
*++wch = L'\0'; |
return OK; |
} |
else |
return ((*wcval & A_CHARTEXT) != L'\0'); |
} |
int setcchar(cchar_t *wcval, const wchar_t *wch, const attr_t attrs, |
short color_pair, const void *opts) |
{ |
if (!wcval || !wch) |
return ERR; |
*wcval = *wch | attrs | COLOR_PAIR(color_pair); |
return OK; |
} |
wchar_t *wunctrl(cchar_t *wc) |
{ |
static wchar_t strbuf[3] = {0, 0, 0}; |
cchar_t ic; |
PDC_LOG(("wunctrl() - called\n")); |
if (!wc) |
return NULL; |
ic = *wc & A_CHARTEXT; |
if (ic >= 0x20 && ic != 0x7f) /* normal characters */ |
{ |
strbuf[0] = (wchar_t)ic; |
strbuf[1] = L'\0'; |
return strbuf; |
} |
strbuf[0] = '^'; /* '^' prefix */ |
if (ic == 0x7f) /* 0x7f == DEL */ |
strbuf[1] = '?'; |
else /* other control */ |
strbuf[1] = (wchar_t)(ic + '@'); |
return strbuf; |
} |
int PDC_mbtowc(wchar_t *pwc, const char *s, size_t n) |
{ |
# ifdef PDC_FORCE_UTF8 |
wchar_t key; |
int i = -1; |
const unsigned char *string; |
if (!s || (n < 1)) |
return -1; |
if (!*s) |
return 0; |
string = (const unsigned char *)s; |
key = string[0]; |
/* Simplistic UTF-8 decoder -- only does the BMP, minimal validation */ |
if (key & 0x80) |
{ |
if ((key & 0xe0) == 0xc0) |
{ |
if (1 < n) |
{ |
key = ((key & 0x1f) << 6) | (string[1] & 0x3f); |
i = 2; |
} |
} |
else if ((key & 0xe0) == 0xe0) |
{ |
if (2 < n) |
{ |
key = ((key & 0x0f) << 12) | ((string[1] & 0x3f) << 6) | |
(string[2] & 0x3f); |
i = 3; |
} |
} |
} |
else |
i = 1; |
if (i) |
*pwc = key; |
return i; |
# else |
return mbtowc(pwc, s, n); |
# endif |
} |
size_t PDC_mbstowcs(wchar_t *dest, const char *src, size_t n) |
{ |
# ifdef PDC_FORCE_UTF8 |
size_t i = 0, len; |
if (!src || !dest) |
return 0; |
len = strlen(src); |
while (*src && i < n) |
{ |
int retval = PDC_mbtowc(dest + i, src, len); |
if (retval < 1) |
return -1; |
src += retval; |
len -= retval; |
i++; |
} |
# else |
size_t i = mbstowcs(dest, src, n); |
# endif |
dest[i] = 0; |
return i; |
} |
size_t PDC_wcstombs(char *dest, const wchar_t *src, size_t n) |
{ |
# ifdef PDC_FORCE_UTF8 |
size_t i = 0; |
if (!src || !dest) |
return 0; |
while (*src && i < n) |
{ |
chtype code = *src++; |
if (code < 0x80) |
{ |
dest[i] = code; |
i++; |
} |
else |
if (code < 0x800) |
{ |
dest[i] = ((code & 0x07c0) >> 6) | 0xc0; |
dest[i + 1] = (code & 0x003f) | 0x80; |
i += 2; |
} |
else |
{ |
dest[i] = ((code & 0xf000) >> 12) | 0xe0; |
dest[i + 1] = ((code & 0x0fc0) >> 6) | 0x80; |
dest[i + 2] = (code & 0x003f) | 0x80; |
i += 3; |
} |
} |
# else |
size_t i = wcstombs(dest, src, n); |
# endif |
dest[i] = '\0'; |
return i; |
} |
#endif |
/contrib/sdk/sources/PDCurses/pdcurses/window.c |
---|
0,0 → 1,581 |
/* PDCurses */ |
#include <curspriv.h> |
/*man-start************************************************************** |
window |
------ |
### Synopsis |
WINDOW *newwin(int nlines, int ncols, int begy, int begx); |
WINDOW *derwin(WINDOW* orig, int nlines, int ncols, |
int begy, int begx); |
WINDOW *subwin(WINDOW* orig, int nlines, int ncols, |
int begy, int begx); |
WINDOW *dupwin(WINDOW *win); |
int delwin(WINDOW *win); |
int mvwin(WINDOW *win, int y, int x); |
int mvderwin(WINDOW *win, int pary, int parx); |
int syncok(WINDOW *win, bool bf); |
void wsyncup(WINDOW *win); |
void wcursyncup(WINDOW *win); |
void wsyncdown(WINDOW *win); |
WINDOW *resize_window(WINDOW *win, int nlines, int ncols); |
int wresize(WINDOW *win, int nlines, int ncols); |
WINDOW *PDC_makelines(WINDOW *win); |
WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx); |
void PDC_sync(WINDOW *win); |
### Description |
newwin() creates a new window with the given number of lines, nlines |
and columns, ncols. The upper left corner of the window is at line |
begy, column begx. If nlines is zero, it defaults to LINES - begy; |
ncols to COLS - begx. Create a new full-screen window by calling |
newwin(0, 0, 0, 0). |
delwin() deletes the named window, freeing all associated memory. In |
the case of overlapping windows, subwindows should be deleted before |
the main window. |
mvwin() moves the window so that the upper left-hand corner is at |
position (y,x). If the move would cause the window to be off the |
screen, it is an error and the window is not moved. Moving subwindows |
is allowed. |
subwin() creates a new subwindow within a window. The dimensions of |
the subwindow are nlines lines and ncols columns. The subwindow is at |
position (begy, begx) on the screen. This position is relative to the |
screen, and not to the window orig. Changes made to either window |
will affect both. When using this routine, you will often need to |
call touchwin() before calling wrefresh(). |
derwin() is the same as subwin(), except that begy and begx are |
relative to the origin of the window orig rather than the screen. |
There is no difference between subwindows and derived windows. |
mvderwin() moves a derived window (or subwindow) inside its parent |
window. The screen-relative parameters of the window are not changed. |
This routine is used to display different parts of the parent window |
at the same physical position on the screen. |
dupwin() creates an exact duplicate of the window win. |
wsyncup() causes a touchwin() of all of the window's parents. |
If wsyncok() is called with a second argument of TRUE, this causes a |
wsyncup() to be called every time the window is changed. |
wcursyncup() causes the current cursor position of all of a window's |
ancestors to reflect the current cursor position of the current |
window. |
wsyncdown() causes a touchwin() of the current window if any of its |
parent's windows have been touched. |
resize_window() allows the user to resize an existing window. It |
returns the pointer to the new window, or NULL on failure. |
wresize() is an ncurses-compatible wrapper for resize_window(). Note |
that, unlike ncurses, it will NOT process any subwindows of the |
window. (However, you still can call it _on_ subwindows.) It returns |
OK or ERR. |
PDC_makenew() allocates all data for a new WINDOW * except the actual |
lines themselves. If it's unable to allocate memory for the window |
structure, it will free all allocated memory and return a NULL |
pointer. |
PDC_makelines() allocates the memory for the lines. |
PDC_sync() handles wrefresh() and wsyncup() calls when a window is |
changed. |
### Return Value |
newwin(), subwin(), derwin() and dupwin() return a pointer to the new |
window, or NULL on failure. delwin(), mvwin(), mvderwin() and |
syncok() return OK or ERR. wsyncup(), wcursyncup() and wsyncdown() |
return nothing. |
### Errors |
It is an error to call resize_window() before calling initscr(). |
Also, an error will be generated if we fail to create a newly sized |
replacement window for curscr, or stdscr. This could happen when |
increasing the window size. NOTE: If this happens, the previously |
successfully allocated windows are left alone; i.e., the resize is |
NOT cancelled for those windows. |
### Portability |
X/Open ncurses NetBSD |
newwin Y Y Y |
delwin Y Y Y |
mvwin Y Y Y |
subwin Y Y Y |
derwin Y Y Y |
mvderwin Y Y Y |
dupwin Y Y Y |
wsyncup Y Y Y |
syncok Y Y Y |
wcursyncup Y Y Y |
wsyncdown Y Y Y |
wresize - Y Y |
resize_window - - - |
PDC_makelines - - - |
PDC_makenew - - - |
PDC_sync - - - |
**man-end****************************************************************/ |
#include <stdlib.h> |
WINDOW *PDC_makenew(int nlines, int ncols, int begy, int begx) |
{ |
WINDOW *win; |
PDC_LOG(("PDC_makenew() - called: lines %d cols %d begy %d begx %d\n", |
nlines, ncols, begy, begx)); |
/* allocate the window structure itself */ |
win = calloc(1, sizeof(WINDOW)); |
if (!win) |
return win; |
/* allocate the line pointer array */ |
win->_y = malloc(nlines * sizeof(chtype *)); |
if (!win->_y) |
{ |
free(win); |
return (WINDOW *)NULL; |
} |
/* allocate the minchng and maxchng arrays */ |
win->_firstch = malloc(nlines * sizeof(int)); |
if (!win->_firstch) |
{ |
free(win->_y); |
free(win); |
return (WINDOW *)NULL; |
} |
win->_lastch = malloc(nlines * sizeof(int)); |
if (!win->_lastch) |
{ |
free(win->_firstch); |
free(win->_y); |
free(win); |
return (WINDOW *)NULL; |
} |
/* initialize window variables */ |
win->_maxy = nlines; /* real max screen size */ |
win->_maxx = ncols; /* real max screen size */ |
win->_begy = begy; |
win->_begx = begx; |
win->_bkgd = ' '; /* wrs 4/10/93 -- initialize background to blank */ |
win->_clear = (bool) ((nlines == LINES) && (ncols == COLS)); |
win->_bmarg = nlines - 1; |
win->_parx = win->_pary = -1; |
/* init to say window all changed */ |
touchwin(win); |
return win; |
} |
WINDOW *PDC_makelines(WINDOW *win) |
{ |
int i, j, nlines, ncols; |
PDC_LOG(("PDC_makelines() - called\n")); |
if (!win) |
return (WINDOW *)NULL; |
nlines = win->_maxy; |
ncols = win->_maxx; |
for (i = 0; i < nlines; i++) |
{ |
win->_y[i] = malloc(ncols * sizeof(chtype)); |
if (!win->_y[i]) |
{ |
/* if error, free all the data */ |
for (j = 0; j < i; j++) |
free(win->_y[j]); |
free(win->_firstch); |
free(win->_lastch); |
free(win->_y); |
free(win); |
return (WINDOW *)NULL; |
} |
} |
return win; |
} |
void PDC_sync(WINDOW *win) |
{ |
PDC_LOG(("PDC_sync() - called:\n")); |
if (win->_immed) |
wrefresh(win); |
if (win->_sync) |
wsyncup(win); |
} |
WINDOW *newwin(int nlines, int ncols, int begy, int begx) |
{ |
WINDOW *win; |
PDC_LOG(("newwin() - called:lines=%d cols=%d begy=%d begx=%d\n", |
nlines, ncols, begy, begx)); |
if (!nlines) |
nlines = LINES - begy; |
if (!ncols) |
ncols = COLS - begx; |
if (!SP || begy + nlines > SP->lines || begx + ncols > SP->cols) |
return (WINDOW *)NULL; |
win = PDC_makenew(nlines, ncols, begy, begx); |
if (win) |
win = PDC_makelines(win); |
if (win) |
werase(win); |
return win; |
} |
int delwin(WINDOW *win) |
{ |
int i; |
PDC_LOG(("delwin() - called\n")); |
if (!win) |
return ERR; |
/* subwindows use parents' lines */ |
if (!(win->_flags & (_SUBWIN|_SUBPAD))) |
for (i = 0; i < win->_maxy && win->_y[i]; i++) |
if (win->_y[i]) |
free(win->_y[i]); |
free(win->_firstch); |
free(win->_lastch); |
free(win->_y); |
free(win); |
return OK; |
} |
int mvwin(WINDOW *win, int y, int x) |
{ |
PDC_LOG(("mvwin() - called\n")); |
if (!win || (y + win->_maxy > LINES || y < 0) |
|| (x + win->_maxx > COLS || x < 0)) |
return ERR; |
win->_begy = y; |
win->_begx = x; |
touchwin(win); |
return OK; |
} |
WINDOW *subwin(WINDOW *orig, int nlines, int ncols, int begy, int begx) |
{ |
WINDOW *win; |
int i, j, k; |
PDC_LOG(("subwin() - called: lines %d cols %d begy %d begx %d\n", |
nlines, ncols, begy, begx)); |
/* make sure window fits inside the original one */ |
if (!orig || (begy < orig->_begy) || (begx < orig->_begx) || |
(begy + nlines) > (orig->_begy + orig->_maxy) || |
(begx + ncols) > (orig->_begx + orig->_maxx)) |
return (WINDOW *)NULL; |
j = begy - orig->_begy; |
k = begx - orig->_begx; |
if (!nlines) |
nlines = orig->_maxy - 1 - j; |
if (!ncols) |
ncols = orig->_maxx - 1 - k; |
win = PDC_makenew(nlines, ncols, begy, begx); |
if (!win) |
return (WINDOW *)NULL; |
/* initialize window variables */ |
win->_attrs = orig->_attrs; |
win->_bkgd = orig->_bkgd; |
win->_leaveit = orig->_leaveit; |
win->_scroll = orig->_scroll; |
win->_nodelay = orig->_nodelay; |
win->_delayms = orig->_delayms; |
win->_use_keypad = orig->_use_keypad; |
win->_immed = orig->_immed; |
win->_sync = orig->_sync; |
win->_pary = j; |
win->_parx = k; |
win->_parent = orig; |
for (i = 0; i < nlines; i++, j++) |
win->_y[i] = orig->_y[j] + k; |
win->_flags |= _SUBWIN; |
return win; |
} |
WINDOW *derwin(WINDOW *orig, int nlines, int ncols, int begy, int begx) |
{ |
return subwin(orig, nlines, ncols, begy + orig->_begy, begx + orig->_begx); |
} |
int mvderwin(WINDOW *win, int pary, int parx) |
{ |
int i, j; |
WINDOW *mypar; |
if (!win || !(win->_parent)) |
return ERR; |
mypar = win->_parent; |
if (pary < 0 || parx < 0 || (pary + win->_maxy) > mypar->_maxy || |
(parx + win->_maxx) > mypar->_maxx) |
return ERR; |
j = pary; |
for (i = 0; i < win->_maxy; i++) |
win->_y[i] = (mypar->_y[j++]) + parx; |
win->_pary = pary; |
win->_parx = parx; |
return OK; |
} |
WINDOW *dupwin(WINDOW *win) |
{ |
WINDOW *new; |
chtype *ptr, *ptr1; |
int nlines, ncols, begy, begx, i; |
if (!win) |
return (WINDOW *)NULL; |
nlines = win->_maxy; |
ncols = win->_maxx; |
begy = win->_begy; |
begx = win->_begx; |
new = PDC_makenew(nlines, ncols, begy, begx); |
if (new) |
new = PDC_makelines(new); |
if (!new) |
return (WINDOW *)NULL; |
/* copy the contents of win into new */ |
for (i = 0; i < nlines; i++) |
{ |
for (ptr = new->_y[i], ptr1 = win->_y[i]; |
ptr < new->_y[i] + ncols; ptr++, ptr1++) |
*ptr = *ptr1; |
new->_firstch[i] = 0; |
new->_lastch[i] = ncols - 1; |
} |
new->_curx = win->_curx; |
new->_cury = win->_cury; |
new->_maxy = win->_maxy; |
new->_maxx = win->_maxx; |
new->_begy = win->_begy; |
new->_begx = win->_begx; |
new->_flags = win->_flags; |
new->_attrs = win->_attrs; |
new->_clear = win->_clear; |
new->_leaveit = win->_leaveit; |
new->_scroll = win->_scroll; |
new->_nodelay = win->_nodelay; |
new->_delayms = win->_delayms; |
new->_use_keypad = win->_use_keypad; |
new->_tmarg = win->_tmarg; |
new->_bmarg = win->_bmarg; |
new->_parx = win->_parx; |
new->_pary = win->_pary; |
new->_parent = win->_parent; |
new->_bkgd = win->_bkgd; |
new->_flags = win->_flags; |
return new; |
} |
WINDOW *resize_window(WINDOW *win, int nlines, int ncols) |
{ |
WINDOW *new; |
int i, save_cury, save_curx, new_begy, new_begx; |
PDC_LOG(("resize_window() - called: nlines %d ncols %d\n", |
nlines, ncols)); |
if (!win || !SP) |
return (WINDOW *)NULL; |
if (win->_flags & _SUBPAD) |
{ |
new = subpad(win->_parent, nlines, ncols, win->_begy, win->_begx); |
if (!new) |
return (WINDOW *)NULL; |
} |
else if (win->_flags & _SUBWIN) |
{ |
new = subwin(win->_parent, nlines, ncols, win->_begy, win->_begx); |
if (!new) |
return (WINDOW *)NULL; |
} |
else |
{ |
if (win == SP->slk_winptr) |
{ |
new_begy = SP->lines - SP->slklines; |
new_begx = 0; |
} |
else |
{ |
new_begy = win->_begy; |
new_begx = win->_begx; |
} |
new = PDC_makenew(nlines, ncols, new_begy, new_begx); |
if (!new) |
return (WINDOW *)NULL; |
} |
save_curx = min(win->_curx, (new->_maxx - 1)); |
save_cury = min(win->_cury, (new->_maxy - 1)); |
if (!(win->_flags & (_SUBPAD|_SUBWIN))) |
{ |
new = PDC_makelines(new); |
if (!new) |
return (WINDOW *)NULL; |
werase(new); |
copywin(win, new, 0, 0, 0, 0, min(win->_maxy, new->_maxy) - 1, |
min(win->_maxx, new->_maxx) - 1, FALSE); |
for (i = 0; i < win->_maxy && win->_y[i]; i++) |
if (win->_y[i]) |
free(win->_y[i]); |
} |
new->_flags = win->_flags; |
new->_attrs = win->_attrs; |
new->_clear = win->_clear; |
new->_leaveit = win->_leaveit; |
new->_scroll = win->_scroll; |
new->_nodelay = win->_nodelay; |
new->_delayms = win->_delayms; |
new->_use_keypad = win->_use_keypad; |
new->_tmarg = (win->_tmarg > new->_maxy - 1) ? 0 : win->_tmarg; |
new->_bmarg = (win->_bmarg == win->_maxy - 1) ? |
new->_maxy - 1 : min(win->_bmarg, (new->_maxy - 1)); |
new->_parent = win->_parent; |
new->_immed = win->_immed; |
new->_sync = win->_sync; |
new->_bkgd = win->_bkgd; |
new->_curx = save_curx; |
new->_cury = save_cury; |
free(win->_firstch); |
free(win->_lastch); |
free(win->_y); |
*win = *new; |
free(new); |
return win; |
} |
int wresize(WINDOW *win, int nlines, int ncols) |
{ |
return (resize_window(win, nlines, ncols) ? OK : ERR); |
} |
void wsyncup(WINDOW *win) |
{ |
WINDOW *tmp; |
PDC_LOG(("wsyncup() - called\n")); |
for (tmp = win; tmp; tmp = tmp->_parent) |
touchwin(tmp); |
} |
int syncok(WINDOW *win, bool bf) |
{ |
PDC_LOG(("syncok() - called\n")); |
if (!win) |
return ERR; |
win->_sync = bf; |
return OK; |
} |
void wcursyncup(WINDOW *win) |
{ |
WINDOW *tmp; |
PDC_LOG(("wcursyncup() - called\n")); |
for (tmp = win; tmp && tmp->_parent; tmp = tmp->_parent) |
wmove(tmp->_parent, tmp->_pary + tmp->_cury, tmp->_parx + tmp->_curx); |
} |
void wsyncdown(WINDOW *win) |
{ |
WINDOW *tmp; |
PDC_LOG(("wsyncdown() - called\n")); |
for (tmp = win; tmp; tmp = tmp->_parent) |
{ |
if (is_wintouched(tmp)) |
{ |
touchwin(win); |
break; |
} |
} |
} |
/contrib/sdk/sources/PDCurses/sdl1/Makefile.linux |
---|
0,0 → 1,103 |
# Makefile for PDCurses for SDL |
O = o |
ifndef PDCURSES_SRCDIR |
PDCURSES_SRCDIR = .. |
endif |
include $(PDCURSES_SRCDIR)/common/libobjs.mif |
osdir = $(PDCURSES_SRCDIR)/sdl1 |
PDCURSES_SDL_H = $(osdir)/pdcsdl.h |
ifeq ($(DEBUG),Y) |
CFLAGS = -g -Wall -DPDCDEBUG -fPIC |
else |
CFLAGS = -O2 -Wall -fPIC |
endif |
ifeq ($(WIDE),Y) |
CFLAGS += -DPDC_WIDE |
SLIBS += -lSDL_ttf |
endif |
ifeq ($(UTF8),Y) |
CFLAGS += -DPDC_FORCE_UTF8 |
endif |
BUILD = $(CC) $(CFLAGS) -I$(PDCURSES_SRCDIR) |
LINK = $(CC) |
LDFLAGS = $(LIBCURSES) $(SLIBS) |
RANLIB = ranlib |
LIBCURSES = pdcurses.a |
DEMOS += sdltest |
.PHONY: all libs clean demos |
all: libs |
libs: $(LIBCURSES) |
clean: |
-rm -rf *.o trace $(LIBCURSES) $(DEMOS) |
demos: $(DEMOS) |
ifneq ($(DEBUG),Y) |
strip $(DEMOS) |
endif |
$(LIBCURSES) : $(LIBOBJS) $(PDCOBJS) |
ar rv $@ $? |
-$(RANLIB) $@ |
$(LIBOBJS) $(PDCOBJS) : $(PDCURSES_HEADERS) |
$(PDCOBJS) : $(PDCURSES_SDL_H) |
$(DEMOS) : $(PDCURSES_CURSES_H) $(LIBCURSES) |
tui.o tuidemo.o : $(PDCURSES_CURSES_H) |
panel.o ptest: $(PANEL_HEADER) |
$(LIBOBJS) : %.o: $(srcdir)/%.c |
$(BUILD) -c $< |
$(PDCOBJS) : %.o: $(osdir)/%.c |
$(BUILD) $(SFLAGS) -c $< |
firework: $(demodir)/firework.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
ozdemo: $(demodir)/ozdemo.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
ptest: $(demodir)/ptest.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
rain: $(demodir)/rain.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
testcurs: $(demodir)/testcurs.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
tuidemo: tuidemo.o tui.o |
$(LINK) tui.o tuidemo.o -o $@ $(LDFLAGS) |
worm: $(demodir)/worm.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
xmas: $(demodir)/xmas.c |
$(BUILD) $(DEMOFLAGS) -o $@ $< $(LDFLAGS) |
sdltest: $(osdir)/sdltest.c |
$(BUILD) $(DEMOFLAGS) $(SFLAGS) -o $@ $< $(LDFLAGS) |
tui.o: $(demodir)/tui.c $(demodir)/tui.h |
$(BUILD) -c $(DEMOFLAGS) $(demodir)/tui.c |
tuidemo.o: $(demodir)/tuidemo.c |
$(BUILD) -c $(DEMOFLAGS) $(demodir)/tuidemo.c |
include $(demodir)/nctests.mif |
/contrib/sdk/sources/PDCurses/sdl1/README.md |
---|
0,0 → 1,185 |
PDCurses for SDL 1.x |
==================== |
This is a port of PDCurses for version 1.x of SDL. |
Building |
-------- |
- On *nix (including Linux), run "make" in the sdl1 directory. There is |
no configure script (yet?) for this port. This assumes a working |
sdl-config, and GNU make. It builds the library pdcurses.a (dynamic |
lib not implemented). |
- The makefile accepts the optional parameter "DEBUG=Y", and recognizes |
the optional PDCURSES_SRCDIR environment variable, as with the console |
ports. "WIDE=Y" builds a version that not only uses 16-bit Unicode |
characters, but depends on the SDL_ttf library, instead of using |
simple bitmap fonts. "UTF8=Y" makes PDCurses ignore the system locale, |
and treat all narrow-character strings as UTF-8; this option has no |
effect unless WIDE=Y is also set. Add the target "demos" to build the |
sample programs. |
Usage |
----- |
There are no special requirements to use PDCurses for SDL -- all |
PDCurses-compatible code should work fine. Nothing extra is needed |
beyond the base SDL library. However, there are some optional special |
features, described here. |
The SDL ports operate in one of two ways, depending on whether or not |
they were built with WIDE=Y: |
### 8-bit mode |
The font is a simple BMP, 32 characters wide by 8 characters tall, |
preferably with a palette. (BMPs without palettes still work, but in |
that case, no attributes will be available, nor will the cursor work.) |
The first entry in the palette (usually black) is treated as the |
background color; the last entry (usually white) is treated as the |
foreground. These are changed or made transparent as appropriate; any |
other colors in the palette are passed through unchanged. So -- although |
a one-bit depth is sufficient for a normal font -- you could redraw some |
characters as multi-colored tiles. |
The font must be monospaced. The size of each character is derived by |
dividing the width of the BMP by 32 and the height by 8. There is no |
constraint on the dimensions. |
As provided in the default font and expected by acs_map[], the font is |
in Code Page 437 form. But you can of course use any layout if you're |
not relying on correct values for the ACS_* macros. |
The font can be set via the environment variable PDC_FONT. If it's not |
set, PDCurses looks for a file named "pdcfont.bmp" in the current |
directory at the time of initscr(). If neither is found, it uses the |
built-in default font encoded in font437.h. |
### 16-bit mode |
Instead of a BMP, PDC_FONT points to a TrueType font. Only true |
monospaced fonts work well. The font can be set at compile time via |
PDC_FONT_PATH, and/or at runtime via pdc_ttffont. The environment |
variable PDC_FONT_SIZE is also available to control the font size (also |
as a compile-time define, and at runtime as pdc_font_size.) The |
character mapping for chtypes is 16-bit Unicode (the Basic Multilingual |
Plane). |
The default font is: /usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf |
Backgrounds |
----------- |
PDCurses for SDL supports an optional background image BMP. This is used |
whenever start_color() has not been called (see the ptest demo for an |
example), or when use_default_colors() has been called after |
start_color(), and the background color of a pair has been set to -1 |
(see ozdemo, worm, and rain for examples). The usage parallels that of |
ncurses in an appropriate terminal (e.g., Gnome Terminal). The image is |
tiled to cover the PDCurses window, and can be any size or depth. |
As with the font, you can point to a location for the background via the |
environment variable PDC_BACKGROUND; "pdcback.bmp" is the fallback. |
(There is no default background.) |
Icons |
----- |
The icon (used with SDL_WM_SetIcon() -- not used for the executable |
file) can be set via the environment variable PDC_ICON, and falls back |
to "pdcicon.bmp", and then to the built-in icon from iconbmp.h. The |
built-in icon is the PDCurses logo, as seen in ../common/icon32.xpm. |
If pdc_screen is preinitialized (see below), PDCurses does not attempt |
to set the icon. |
Screen size |
----------- |
The default screen size is 80x25 characters (whatever size they may be), |
but you can override this via the environment variables PDC_COLS and/or |
PDC_LINES. If pdc_screen is preinitialized (see below), these are |
ignored. |
Integration with SDL |
-------------------- |
If you want to go further, you can mix PDCurses and SDL functions. (Of |
course this is extremely non-portable!) To aid you, there are several |
external variables and functions specific to the SDL ports; you could |
include pdcsdl.h, or just add the declarations you need in your code: |
PDCEX SDL_Surface *pdc_screen, *pdc_font, *pdc_icon, *pdc_back; |
PDCEX int pdc_sheight, pdc_swidth, pdc_yoffset, pdc_xoffset; |
PDCEX void PDC_update_rects(void); |
PDCEX void PDC_retile(void); |
pdc_screen is the main surface, created by SDL_SetVideoMode(), unless |
it's preset before initscr(). (See sdltest.c for examples.) You can |
perform normal SDL operations on this surface, but PDCurses won't |
respect them when it updates. (For that, see PDC_retile().) As an |
alternative, you can preinitialize this surface before calling |
initscr(). In that case, you can use pdc_sheight, pdc_swidth, |
pdc_yoffset and/or pdc_xoffset (q.v.) to confine PDCurses to only a |
specific area of the surface, reserving the rest for other SDL |
operations. If you preinitialize pdc_screen, you'll have to close it |
yourself; PDCurses will ignore resize events, and won't try to set the |
icon. Also note that if you preinitialize pdc_screen, it need not be the |
display surface. |
pdc_font (in 8-bit mode), pdc_icon, and pdc_back are the SDL_surfaces |
for the font, icon, and background, respectively. You can set any or all |
of them before initscr(), and thus override any of the other ways to set |
them. But note that pdc_icon will be ignored if pdc_screen is preset. |
pdc_sheight and pdc_swidth are the dimensions of the area of pdc_screen |
to be used by PDCurses. You can preset them before initscr(); if either |
is not set, it defaults to the full screen size minus the x or y offset, |
as appropriate. |
pdc_xoffset and pdc_yoffset are the x and y offset for the area of |
pdc_screen to be used by PDCurses. See the sdltest demo for an example. |
PDC_retile() makes a copy of pdc_screen, then tiles it with the |
background image, if any. The resulting surface is used as the |
background for transparent character cells. PDC_retile() is called from |
initscr() and resize_term(). However, you can also use it at other |
times, to take advantage of the way it copies pdc_screen: Draw some SDL |
stuff; call PDC_retile(); do some curses stuff -- it will use whatever |
was on pdc_screen as the background. Then you can erase the curses |
screen, do some more SDL stuff, and call PDC_retile() again to make a |
new background. (If you don't erase the curses screen, it will be |
incorporated into the background when you call PDC_retile().) But this |
only works if no background image is set. |
Interaction with stdio |
---------------------- |
As with X11, it's a bad idea to mix curses and stdio calls. (In fact, |
that's true for PDCurses on any platform; but especially these two, |
which don't run under terminals.) Depending on how SDL is built, stdout |
and stderr may be redirected to files. |
Distribution Status |
------------------- |
The files in this directory are released to the public domain. |
Acknowledgements |
---------------- |
Original SDL port was provided by William McBrine |
TTF support based on contributions by Laura Michaels |
/contrib/sdk/sources/PDCurses/sdl1/pdcclip.c |
---|
0,0 → 1,131 |
/* PDCurses */ |
#include "pdcsdl.h" |
#include <stdlib.h> |
#include <string.h> |
/*man-start************************************************************** |
clipboard |
--------- |
### Synopsis |
int PDC_getclipboard(char **contents, long *length); |
int PDC_setclipboard(const char *contents, long length); |
int PDC_freeclipboard(char *contents); |
int PDC_clearclipboard(void); |
### Description |
PDC_getclipboard() gets the textual contents of the system's |
clipboard. This function returns the contents of the clipboard in the |
contents argument. It is the responsibility of the caller to free the |
memory returned, via PDC_freeclipboard(). The length of the clipboard |
contents is returned in the length argument. |
PDC_setclipboard copies the supplied text into the system's |
clipboard, emptying the clipboard prior to the copy. |
PDC_clearclipboard() clears the internal clipboard. |
### Return Values |
indicator of success/failure of call. |
PDC_CLIP_SUCCESS the call was successful |
PDC_CLIP_MEMORY_ERROR unable to allocate sufficient memory for |
the clipboard contents |
PDC_CLIP_EMPTY the clipboard contains no text |
PDC_CLIP_ACCESS_ERROR no clipboard support |
### Portability |
X/Open ncurses NetBSD |
PDC_getclipboard - - - |
PDC_setclipboard - - - |
PDC_freeclipboard - - - |
PDC_clearclipboard - - - |
**man-end****************************************************************/ |
/* global clipboard contents, should be NULL if none set */ |
static char *pdc_SDL_clipboard = NULL; |
int PDC_getclipboard(char **contents, long *length) |
{ |
int len; |
PDC_LOG(("PDC_getclipboard() - called\n")); |
if (!pdc_SDL_clipboard) |
return PDC_CLIP_EMPTY; |
len = strlen(pdc_SDL_clipboard); |
if ((*contents = malloc(len + 1)) == NULL) |
return PDC_CLIP_MEMORY_ERROR; |
strcpy(*contents, pdc_SDL_clipboard); |
*length = len; |
return PDC_CLIP_SUCCESS; |
} |
int PDC_setclipboard(const char *contents, long length) |
{ |
PDC_LOG(("PDC_setclipboard() - called\n")); |
if (pdc_SDL_clipboard) |
{ |
free(pdc_SDL_clipboard); |
pdc_SDL_clipboard = NULL; |
} |
if (contents) |
{ |
if ((pdc_SDL_clipboard = malloc(length + 1)) == NULL) |
return PDC_CLIP_MEMORY_ERROR; |
strcpy(pdc_SDL_clipboard, contents); |
} |
return PDC_CLIP_SUCCESS; |
} |
int PDC_freeclipboard(char *contents) |
{ |
PDC_LOG(("PDC_freeclipboard() - called\n")); |
/* should we also free empty the system clipboard? probably not */ |
if (contents) |
{ |
/* NOTE: We free the memory, but we can not set caller's pointer |
to NULL, so if caller calls again then will try to access |
free'd memory. We 1st overwrite memory with a string so if |
caller tries to use free memory they won't get what they |
expect & hopefully notice. */ |
/* memset(contents, 0xFD, strlen(contents)); */ |
if (strlen(contents) >= strlen("PDCURSES")) |
strcpy(contents, "PDCURSES"); |
free(contents); |
} |
return PDC_CLIP_SUCCESS; |
} |
int PDC_clearclipboard(void) |
{ |
PDC_LOG(("PDC_clearclipboard() - called\n")); |
if (pdc_SDL_clipboard) |
{ |
free(pdc_SDL_clipboard); |
pdc_SDL_clipboard = NULL; |
} |
return PDC_CLIP_SUCCESS; |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdcdisp.c |
---|
0,0 → 1,529 |
/* PDCurses */ |
#include "pdcsdl.h" |
#include <stdlib.h> |
#include <string.h> |
#ifdef PDC_WIDE |
# include "../common/acsgr.h" |
#else |
# include "../common/acs437.h" |
#endif |
#define MAXRECT 200 /* maximum number of rects to queue up before |
an update is forced; the number was chosen |
arbitrarily */ |
static SDL_Rect uprect[MAXRECT]; /* table of rects to update */ |
static chtype oldch = (chtype)(-1); /* current attribute */ |
static int rectcount = 0; /* index into uprect */ |
static short foregr = -2, backgr = -2; /* current foreground, background */ |
static bool blinked_off = FALSE; |
/* do the real updates on a delay */ |
void PDC_update_rects(void) |
{ |
if (rectcount) |
{ |
/* if the maximum number of rects has been reached, we're |
probably better off doing a full screen update */ |
if (rectcount == MAXRECT) |
SDL_Flip(pdc_screen); |
else |
SDL_UpdateRects(pdc_screen, rectcount, uprect); |
rectcount = 0; |
} |
} |
/* set the font colors to match the chtype's attribute */ |
static void _set_attr(chtype ch) |
{ |
attr_t sysattrs = SP->termattrs; |
#ifdef PDC_WIDE |
TTF_SetFontStyle(pdc_ttffont, |
( ((ch & A_BOLD) && (sysattrs & A_BOLD)) ? |
TTF_STYLE_BOLD : 0) | |
( ((ch & A_ITALIC) && (sysattrs & A_ITALIC)) ? |
TTF_STYLE_ITALIC : 0) ); |
#endif |
ch &= (A_COLOR|A_BOLD|A_BLINK|A_REVERSE); |
if (oldch != ch) |
{ |
short newfg, newbg; |
if (SP->mono) |
return; |
pair_content(PAIR_NUMBER(ch), &newfg, &newbg); |
if ((ch & A_BOLD) && !(sysattrs & A_BOLD)) |
newfg |= 8; |
if ((ch & A_BLINK) && !(sysattrs & A_BLINK)) |
newbg |= 8; |
if (ch & A_REVERSE) |
{ |
short tmp = newfg; |
newfg = newbg; |
newbg = tmp; |
} |
if (newfg != foregr) |
{ |
#ifndef PDC_WIDE |
SDL_SetPalette(pdc_font, SDL_LOGPAL, |
pdc_color + newfg, pdc_flastc, 1); |
#endif |
foregr = newfg; |
} |
if (newbg != backgr) |
{ |
#ifndef PDC_WIDE |
if (newbg == -1) |
SDL_SetColorKey(pdc_font, SDL_SRCCOLORKEY, 0); |
else |
{ |
if (backgr == -1) |
SDL_SetColorKey(pdc_font, 0, 0); |
SDL_SetPalette(pdc_font, SDL_LOGPAL, |
pdc_color + newbg, 0, 1); |
} |
#endif |
backgr = newbg; |
} |
oldch = ch; |
} |
} |
#ifdef PDC_WIDE |
/* Draw some of the ACS_* "graphics" */ |
bool _grprint(chtype ch, SDL_Rect dest) |
{ |
Uint32 col = pdc_mapped[foregr]; |
int hmid = (pdc_fheight - pdc_fthick) >> 1; |
int wmid = (pdc_fwidth - pdc_fthick) >> 1; |
switch (ch) |
{ |
case ACS_ULCORNER: |
dest.h = pdc_fheight - hmid; |
dest.y += hmid; |
dest.w = pdc_fthick; |
dest.x += wmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = pdc_fwidth - wmid; |
goto S1; |
case ACS_LLCORNER: |
dest.h = hmid; |
dest.w = pdc_fthick; |
dest.x += wmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = pdc_fwidth - wmid; |
dest.y += hmid; |
goto S1; |
case ACS_URCORNER: |
dest.h = pdc_fheight - hmid; |
dest.w = pdc_fthick; |
dest.y += hmid; |
dest.x += wmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = wmid; |
dest.x -= wmid; |
goto S1; |
case ACS_LRCORNER: |
dest.h = hmid + pdc_fthick; |
dest.w = pdc_fthick; |
dest.x += wmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = wmid; |
dest.x -= wmid; |
dest.y += hmid; |
goto S1; |
case ACS_LTEE: |
dest.h = pdc_fthick; |
dest.w = pdc_fwidth - wmid; |
dest.x += wmid; |
dest.y += hmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = pdc_fthick; |
dest.x -= wmid; |
goto VLINE; |
case ACS_RTEE: |
dest.w = wmid; |
case ACS_PLUS: |
dest.h = pdc_fthick; |
dest.y += hmid; |
SDL_FillRect(pdc_screen, &dest, col); |
VLINE: |
dest.h = pdc_fheight; |
dest.y -= hmid; |
case ACS_VLINE: |
dest.w = pdc_fthick; |
dest.x += wmid; |
goto DRAW; |
case ACS_TTEE: |
dest.h = pdc_fheight - hmid; |
dest.w = pdc_fthick; |
dest.x += wmid; |
dest.y += hmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = pdc_fwidth; |
dest.x -= wmid; |
goto S1; |
case ACS_BTEE: |
dest.h = hmid; |
dest.w = pdc_fthick; |
dest.x += wmid; |
SDL_FillRect(pdc_screen, &dest, col); |
dest.w = pdc_fwidth; |
dest.x -= wmid; |
case ACS_HLINE: |
dest.y += hmid; |
goto S1; |
case ACS_S3: |
dest.y += hmid >> 1; |
goto S1; |
case ACS_S7: |
dest.y += hmid + (hmid >> 1); |
goto S1; |
case ACS_S9: |
dest.y += pdc_fheight - pdc_fthick; |
case ACS_S1: |
S1: |
dest.h = pdc_fthick; |
case ACS_BLOCK: |
DRAW: |
SDL_FillRect(pdc_screen, &dest, col); |
return TRUE; |
default: ; |
} |
return FALSE; /* didn't draw it -- fall back to acs_map */ |
} |
#endif |
/* draw a cursor at (y, x) */ |
void PDC_gotoyx(int row, int col) |
{ |
SDL_Rect src, dest; |
chtype ch; |
int oldrow, oldcol; |
#ifdef PDC_WIDE |
Uint16 chstr[2] = {0, 0}; |
#endif |
PDC_LOG(("PDC_gotoyx() - called: row %d col %d from row %d col %d\n", |
row, col, SP->cursrow, SP->curscol)); |
oldrow = SP->cursrow; |
oldcol = SP->curscol; |
/* clear the old cursor */ |
PDC_transform_line(oldrow, oldcol, 1, curscr->_y[oldrow] + oldcol); |
if (!SP->visibility) |
return; |
/* draw a new cursor by overprinting the existing character in |
reverse, either the full cell (when visibility == 2) or the |
lowest quarter of it (when visibility == 1) */ |
ch = curscr->_y[row][col] ^ A_REVERSE; |
_set_attr(ch); |
src.h = (SP->visibility == 1) ? pdc_fheight >> 2 : pdc_fheight; |
src.w = pdc_fwidth; |
dest.y = (row + 1) * pdc_fheight - src.h + pdc_yoffset; |
dest.x = col * pdc_fwidth + pdc_xoffset; |
dest.h = src.h; |
dest.w = src.w; |
#ifdef PDC_WIDE |
SDL_FillRect(pdc_screen, &dest, pdc_mapped[backgr]); |
if (!(SP->visibility == 2 && (ch & A_ALTCHARSET && !(ch & 0xff80)) && |
_grprint(ch & (0x7f | A_ALTCHARSET), dest))) |
{ |
if (ch & A_ALTCHARSET && !(ch & 0xff80)) |
ch = acs_map[ch & 0x7f]; |
chstr[0] = ch & A_CHARTEXT; |
pdc_font = TTF_RenderUNICODE_Blended(pdc_ttffont, chstr, |
pdc_color[foregr]); |
if (pdc_font) |
{ |
int center = pdc_fwidth > pdc_font->w ? |
(pdc_fwidth - pdc_font->w) >> 1 : 0; |
src.x = 0; |
src.y = pdc_fheight - src.h; |
dest.x += center; |
SDL_BlitSurface(pdc_font, &src, pdc_screen, &dest); |
dest.x -= center; |
SDL_FreeSurface(pdc_font); |
pdc_font = NULL; |
} |
} |
#else |
if (ch & A_ALTCHARSET && !(ch & 0xff80)) |
ch = acs_map[ch & 0x7f]; |
src.x = (ch & 0xff) % 32 * pdc_fwidth; |
src.y = (ch & 0xff) / 32 * pdc_fheight + (pdc_fheight - src.h); |
SDL_BlitSurface(pdc_font, &src, pdc_screen, &dest); |
#endif |
if (oldrow != row || oldcol != col) |
{ |
if (rectcount == MAXRECT) |
PDC_update_rects(); |
uprect[rectcount++] = dest; |
} |
} |
void _new_packet(attr_t attr, int lineno, int x, int len, const chtype *srcp) |
{ |
SDL_Rect src, dest, lastrect; |
int j; |
#ifdef PDC_WIDE |
Uint16 chstr[2] = {0, 0}; |
#endif |
attr_t sysattrs = SP->termattrs; |
short hcol = SP->line_color; |
bool blink = blinked_off && (attr & A_BLINK) && (sysattrs & A_BLINK); |
if (rectcount == MAXRECT) |
PDC_update_rects(); |
#ifdef PDC_WIDE |
src.x = 0; |
src.y = 0; |
#endif |
src.h = pdc_fheight; |
src.w = pdc_fwidth; |
dest.y = pdc_fheight * lineno + pdc_yoffset; |
dest.x = pdc_fwidth * x + pdc_xoffset; |
dest.h = pdc_fheight; |
dest.w = pdc_fwidth * len; |
/* if the previous rect was just above this one, with the same width |
and horizontal position, then merge the new one with it instead |
of adding a new entry */ |
if (rectcount) |
lastrect = uprect[rectcount - 1]; |
if (rectcount && lastrect.x == dest.x && lastrect.w == dest.w) |
{ |
if (lastrect.y + lastrect.h == dest.y) |
uprect[rectcount - 1].h = lastrect.h + pdc_fheight; |
else |
if (lastrect.y != dest.y) |
uprect[rectcount++] = dest; |
} |
else |
uprect[rectcount++] = dest; |
_set_attr(attr); |
if (backgr == -1) |
SDL_LowerBlit(pdc_tileback, &dest, pdc_screen, &dest); |
#ifdef PDC_WIDE |
else |
SDL_FillRect(pdc_screen, &dest, pdc_mapped[backgr]); |
#endif |
if (hcol == -1) |
hcol = foregr; |
for (j = 0; j < len; j++) |
{ |
chtype ch = srcp[j]; |
if (blink) |
ch = ' '; |
dest.w = pdc_fwidth; |
if (ch & A_ALTCHARSET && !(ch & 0xff80)) |
{ |
#ifdef PDC_WIDE |
if (_grprint(ch & (0x7f | A_ALTCHARSET), dest)) |
{ |
dest.x += pdc_fwidth; |
continue; |
} |
#endif |
ch = acs_map[ch & 0x7f]; |
} |
#ifdef PDC_WIDE |
ch &= A_CHARTEXT; |
if (ch != ' ') |
{ |
if (chstr[0] != ch) |
{ |
chstr[0] = ch; |
if (pdc_font) |
SDL_FreeSurface(pdc_font); |
pdc_font = TTF_RenderUNICODE_Blended(pdc_ttffont, chstr, |
pdc_color[foregr]); |
} |
if (pdc_font) |
{ |
int center = pdc_fwidth > pdc_font->w ? |
(pdc_fwidth - pdc_font->w) >> 1 : 0; |
dest.x += center; |
SDL_BlitSurface(pdc_font, &src, pdc_screen, &dest); |
dest.x -= center; |
} |
} |
#else |
src.x = (ch & 0xff) % 32 * pdc_fwidth; |
src.y = (ch & 0xff) / 32 * pdc_fheight; |
SDL_LowerBlit(pdc_font, &src, pdc_screen, &dest); |
#endif |
if (!blink && (attr & (A_LEFT | A_RIGHT))) |
{ |
dest.w = pdc_fthick; |
if (attr & A_LEFT) |
SDL_FillRect(pdc_screen, &dest, pdc_mapped[hcol]); |
if (attr & A_RIGHT) |
{ |
dest.x += pdc_fwidth - pdc_fthick; |
SDL_FillRect(pdc_screen, &dest, pdc_mapped[hcol]); |
dest.x -= pdc_fwidth - pdc_fthick; |
} |
} |
dest.x += pdc_fwidth; |
} |
#ifdef PDC_WIDE |
if (pdc_font) |
{ |
SDL_FreeSurface(pdc_font); |
pdc_font = NULL; |
} |
#endif |
if (!blink && (attr & A_UNDERLINE)) |
{ |
dest.y += pdc_fheight - pdc_fthick; |
dest.x = pdc_fwidth * x + pdc_xoffset; |
dest.h = pdc_fthick; |
dest.w = pdc_fwidth * len; |
SDL_FillRect(pdc_screen, &dest, pdc_mapped[hcol]); |
} |
} |
/* update the given physical line to look like the corresponding line in |
curscr */ |
void PDC_transform_line(int lineno, int x, int len, const chtype *srcp) |
{ |
attr_t old_attr, attr; |
int i, j; |
PDC_LOG(("PDC_transform_line() - called: lineno=%d\n", lineno)); |
old_attr = *srcp & (A_ATTRIBUTES ^ A_ALTCHARSET); |
for (i = 1, j = 1; j < len; i++, j++) |
{ |
attr = srcp[i] & (A_ATTRIBUTES ^ A_ALTCHARSET); |
if (attr != old_attr) |
{ |
_new_packet(old_attr, lineno, x, i, srcp); |
old_attr = attr; |
srcp += i; |
x += i; |
i = 0; |
} |
} |
_new_packet(old_attr, lineno, x, i, srcp); |
} |
static Uint32 _blink_timer(Uint32 interval, void *param) |
{ |
SDL_Event event; |
event.type = SDL_USEREVENT; |
SDL_PushEvent(&event); |
return(interval); |
} |
void PDC_blink_text(void) |
{ |
static SDL_TimerID blinker_id = 0; |
int i, j, k; |
oldch = (chtype)(-1); |
if (!(SP->termattrs & A_BLINK)) |
{ |
SDL_RemoveTimer(blinker_id); |
blinker_id = 0; |
} |
else if (!blinker_id) |
{ |
blinker_id = SDL_AddTimer(500, _blink_timer, NULL); |
blinked_off = TRUE; |
} |
blinked_off = !blinked_off; |
for (i = 0; i < SP->lines; i++) |
{ |
const chtype *srcp = curscr->_y[i]; |
for (j = 0; j < SP->cols; j++) |
if (srcp[j] & A_BLINK) |
{ |
k = j; |
while (k < SP->cols && (srcp[k] & A_BLINK)) |
k++; |
PDC_transform_line(i, j, k - j, srcp + j); |
j = k; |
} |
} |
oldch = (chtype)(-1); |
} |
void PDC_doupdate(void) |
{ |
PDC_napms(1); |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdcgetsc.c |
---|
0,0 → 1,30 |
/* PDCurses */ |
#include "pdcsdl.h" |
/* get the cursor size/shape */ |
int PDC_get_cursor_mode(void) |
{ |
PDC_LOG(("PDC_get_cursor_mode() - called\n")); |
return 0; |
} |
/* return number of screen rows */ |
int PDC_get_rows(void) |
{ |
PDC_LOG(("PDC_get_rows() - called\n")); |
return pdc_sheight / pdc_fheight; |
} |
/* return width of screen/viewport */ |
int PDC_get_columns(void) |
{ |
PDC_LOG(("PDC_get_columns() - called\n")); |
return pdc_swidth / pdc_fwidth; |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdckbd.c |
---|
0,0 → 1,375 |
/* PDCurses */ |
#include "pdcsdl.h" |
#include <string.h> |
static SDL_Event event; |
static SDLKey oldkey; |
static MOUSE_STATUS old_mouse_status; |
static struct |
{ |
SDLKey keycode; |
bool numkeypad; |
unsigned short normal; |
unsigned short shifted; |
unsigned short control; |
unsigned short alt; |
} key_table[] = |
{ |
/* keycode keypad normal shifted control alt*/ |
{SDLK_LEFT, FALSE, KEY_LEFT, KEY_SLEFT, CTL_LEFT, ALT_LEFT}, |
{SDLK_RIGHT, FALSE, KEY_RIGHT, KEY_SRIGHT, CTL_RIGHT, ALT_RIGHT}, |
{SDLK_UP, FALSE, KEY_UP, KEY_SUP, CTL_UP, ALT_UP}, |
{SDLK_DOWN, FALSE, KEY_DOWN, KEY_SDOWN, CTL_DOWN, ALT_DOWN}, |
{SDLK_HOME, FALSE, KEY_HOME, KEY_SHOME, CTL_HOME, ALT_HOME}, |
{SDLK_END, FALSE, KEY_END, KEY_SEND, CTL_END, ALT_END}, |
{SDLK_PAGEUP, FALSE, KEY_PPAGE, KEY_SPREVIOUS,CTL_PGUP, ALT_PGUP}, |
{SDLK_PAGEDOWN,FALSE, KEY_NPAGE, KEY_SNEXT, CTL_PGDN, ALT_PGDN}, |
{SDLK_INSERT, FALSE, KEY_IC, KEY_SIC, CTL_INS, ALT_INS}, |
{SDLK_DELETE, FALSE, KEY_DC, KEY_SDC, CTL_DEL, ALT_DEL}, |
{SDLK_F1, FALSE, KEY_F(1), KEY_F(13), KEY_F(25), KEY_F(37)}, |
{SDLK_F2, FALSE, KEY_F(2), KEY_F(14), KEY_F(26), KEY_F(38)}, |
{SDLK_F3, FALSE, KEY_F(3), KEY_F(15), KEY_F(27), KEY_F(39)}, |
{SDLK_F4, FALSE, KEY_F(4), KEY_F(16), KEY_F(28), KEY_F(40)}, |
{SDLK_F5, FALSE, KEY_F(5), KEY_F(17), KEY_F(29), KEY_F(41)}, |
{SDLK_F6, FALSE, KEY_F(6), KEY_F(18), KEY_F(30), KEY_F(42)}, |
{SDLK_F7, FALSE, KEY_F(7), KEY_F(19), KEY_F(31), KEY_F(43)}, |
{SDLK_F8, FALSE, KEY_F(8), KEY_F(20), KEY_F(32), KEY_F(44)}, |
{SDLK_F9, FALSE, KEY_F(9), KEY_F(21), KEY_F(33), KEY_F(45)}, |
{SDLK_F10, FALSE, KEY_F(10), KEY_F(22), KEY_F(34), KEY_F(46)}, |
{SDLK_F11, FALSE, KEY_F(11), KEY_F(23), KEY_F(35), KEY_F(47)}, |
{SDLK_F12, FALSE, KEY_F(12), KEY_F(24), KEY_F(36), KEY_F(48)}, |
{SDLK_F13, FALSE, KEY_F(13), KEY_F(25), KEY_F(37), KEY_F(49)}, |
{SDLK_F14, FALSE, KEY_F(14), KEY_F(26), KEY_F(38), KEY_F(50)}, |
{SDLK_F15, FALSE, KEY_F(15), KEY_F(27), KEY_F(39), KEY_F(51)}, |
{SDLK_BACKSPACE,FALSE, 0x08, 0x08, CTL_BKSP, ALT_BKSP}, |
{SDLK_TAB, FALSE, 0x09, KEY_BTAB, CTL_TAB, ALT_TAB}, |
{SDLK_PRINT, FALSE, KEY_PRINT, KEY_SPRINT, KEY_PRINT, KEY_PRINT}, |
{SDLK_PAUSE, FALSE, KEY_SUSPEND, KEY_SSUSPEND, KEY_SUSPEND, KEY_SUSPEND}, |
{SDLK_CLEAR, FALSE, KEY_CLEAR, KEY_CLEAR, KEY_CLEAR, KEY_CLEAR}, |
{SDLK_BREAK, FALSE, KEY_BREAK, KEY_BREAK, KEY_BREAK, KEY_BREAK}, |
{SDLK_HELP, FALSE, KEY_HELP, KEY_SHELP, KEY_LHELP, KEY_HELP}, |
{SDLK_MENU, FALSE, KEY_OPTIONS, KEY_SOPTIONS, KEY_OPTIONS, KEY_OPTIONS}, |
{SDLK_ESCAPE, FALSE, 0x1B, 0x1B, 0x1B, ALT_ESC}, |
{SDLK_KP_ENTER,TRUE, PADENTER, PADENTER, CTL_PADENTER,ALT_PADENTER}, |
{SDLK_KP_PLUS, TRUE, PADPLUS, '+', CTL_PADPLUS, ALT_PADPLUS}, |
{SDLK_KP_MINUS,TRUE, PADMINUS, '-', CTL_PADMINUS,ALT_PADMINUS}, |
{SDLK_KP_MULTIPLY,TRUE,PADSTAR, '*', CTL_PADSTAR, ALT_PADSTAR}, |
{SDLK_KP_DIVIDE,TRUE, PADSLASH, '/', CTL_PADSLASH,ALT_PADSLASH}, |
{SDLK_KP_PERIOD,TRUE, PADSTOP, '.', CTL_PADSTOP, ALT_PADSTOP}, |
{SDLK_KP0, TRUE, PAD0, '0', CTL_PAD0, ALT_PAD0}, |
{SDLK_KP1, TRUE, KEY_C1, '1', CTL_PAD1, ALT_PAD1}, |
{SDLK_KP2, TRUE, KEY_C2, '2', CTL_PAD2, ALT_PAD2}, |
{SDLK_KP3, TRUE, KEY_C3, '3', CTL_PAD3, ALT_PAD3}, |
{SDLK_KP4, TRUE, KEY_B1, '4', CTL_PAD4, ALT_PAD4}, |
{SDLK_KP5, TRUE, KEY_B2, '5', CTL_PAD5, ALT_PAD5}, |
{SDLK_KP6, TRUE, KEY_B3, '6', CTL_PAD6, ALT_PAD6}, |
{SDLK_KP7, TRUE, KEY_A1, '7', CTL_PAD7, ALT_PAD7}, |
{SDLK_KP8, TRUE, KEY_A2, '8', CTL_PAD8, ALT_PAD8}, |
{SDLK_KP9, TRUE, KEY_A3, '9', CTL_PAD9, ALT_PAD9}, |
{0, 0, 0, 0, 0, 0} |
}; |
void PDC_set_keyboard_binary(bool on) |
{ |
PDC_LOG(("PDC_set_keyboard_binary() - called\n")); |
} |
/* check if a key or mouse event is waiting */ |
bool PDC_check_key(void) |
{ |
int haveevent = SDL_PollEvent(&event); |
return haveevent; |
} |
static int _process_key_event(void) |
{ |
int i, key = 0; |
SP->key_modifiers = 0L; |
SP->key_code = FALSE; |
if (event.type == SDL_KEYUP) |
{ |
if (SP->return_key_modifiers && event.key.keysym.sym == oldkey) |
{ |
SP->key_code = TRUE; |
switch (oldkey) |
{ |
case SDLK_RSHIFT: |
return KEY_SHIFT_R; |
case SDLK_LSHIFT: |
return KEY_SHIFT_L; |
case SDLK_RCTRL: |
return KEY_CONTROL_R; |
case SDLK_LCTRL: |
return KEY_CONTROL_L; |
case SDLK_RALT: |
return KEY_ALT_R; |
case SDLK_LALT: |
return KEY_ALT_L; |
default: |
break; |
} |
SP->key_code = FALSE; |
} |
return -1; |
} |
oldkey = event.key.keysym.sym; |
if (event.key.keysym.mod & KMOD_NUM) |
SP->key_modifiers |= PDC_KEY_MODIFIER_NUMLOCK; |
if (event.key.keysym.mod & KMOD_SHIFT) |
SP->key_modifiers |= PDC_KEY_MODIFIER_SHIFT; |
if (event.key.keysym.mod & KMOD_CTRL) |
SP->key_modifiers |= PDC_KEY_MODIFIER_CONTROL; |
if (event.key.keysym.mod & KMOD_ALT) |
SP->key_modifiers |= PDC_KEY_MODIFIER_ALT; |
for (i = 0; key_table[i].keycode; i++) |
{ |
if (key_table[i].keycode == event.key.keysym.sym) |
{ |
if ((event.key.keysym.mod & KMOD_SHIFT) || |
(key_table[i].numkeypad && (event.key.keysym.mod & KMOD_NUM))) |
{ |
key = key_table[i].shifted; |
} |
else if (event.key.keysym.mod & KMOD_CTRL) |
{ |
key = key_table[i].control; |
} |
else if (event.key.keysym.mod & KMOD_ALT) |
{ |
key = key_table[i].alt; |
} |
/* To get here, we ignore all other modifiers */ |
else |
key = key_table[i].normal; |
SP->key_code = (key > 0x100); |
break; |
} |
} |
if (!key) |
{ |
key = event.key.keysym.unicode; |
if (key > 0x7f) |
key = 0; |
} |
/* Handle ALT letters and numbers */ |
if (event.key.keysym.mod & KMOD_ALT) |
{ |
if (key >= 'A' && key <= 'Z') |
{ |
key += ALT_A - 'A'; |
SP->key_code = TRUE; |
} |
if (key >= 'a' && key <= 'z') |
{ |
key += ALT_A - 'a'; |
SP->key_code = TRUE; |
} |
if (key >= '0' && key <= '9') |
{ |
key += ALT_0 - '0'; |
SP->key_code = TRUE; |
} |
} |
return key ? key : -1; |
} |
static int _process_mouse_event(void) |
{ |
SDLMod keymods; |
short shift_flags = 0; |
memset(&SP->mouse_status, 0, sizeof(MOUSE_STATUS)); |
keymods = SDL_GetModState(); |
if (keymods & KMOD_SHIFT) |
shift_flags |= BUTTON_SHIFT; |
if (keymods & KMOD_CTRL) |
shift_flags |= BUTTON_CONTROL; |
if (keymods & KMOD_ALT) |
shift_flags |= BUTTON_ALT; |
if (event.type == SDL_MOUSEMOTION) |
{ |
int i; |
SP->mouse_status.x = (event.motion.x - pdc_xoffset) / pdc_fwidth; |
SP->mouse_status.y = (event.motion.y - pdc_yoffset) / pdc_fheight; |
if (!event.motion.state || |
(SP->mouse_status.x == old_mouse_status.x && |
SP->mouse_status.y == old_mouse_status.y)) |
return -1; |
SP->mouse_status.changes = PDC_MOUSE_MOVED; |
for (i = 0; i < 3; i++) |
{ |
if (event.motion.state & SDL_BUTTON(i + 1)) |
{ |
SP->mouse_status.button[i] = BUTTON_MOVED | shift_flags; |
SP->mouse_status.changes |= (1 << i); |
} |
} |
} |
else |
{ |
short action = (event.button.state == SDL_PRESSED) ? |
BUTTON_PRESSED : BUTTON_RELEASED; |
Uint8 btn = event.button.button; |
/* handle scroll wheel */ |
if ((btn >= 4 && btn <= 7) && action == BUTTON_RELEASED) |
{ |
SP->mouse_status.x = SP->mouse_status.y = -1; |
switch (btn) |
{ |
case 4: |
SP->mouse_status.changes = PDC_MOUSE_WHEEL_UP; |
break; |
case 5: |
SP->mouse_status.changes = PDC_MOUSE_WHEEL_DOWN; |
break; |
case 6: |
SP->mouse_status.changes = PDC_MOUSE_WHEEL_LEFT; |
break; |
case 7: |
SP->mouse_status.changes = PDC_MOUSE_WHEEL_RIGHT; |
} |
SP->key_code = TRUE; |
return KEY_MOUSE; |
} |
if (btn < 1 || btn > 3) |
return -1; |
/* check for a click -- a press followed immediately by a release */ |
if (action == BUTTON_PRESSED && SP->mouse_wait) |
{ |
SDL_Event rel; |
napms(SP->mouse_wait); |
if (SDL_PollEvent(&rel)) |
{ |
if (rel.type == SDL_MOUSEBUTTONUP && rel.button.button == btn) |
action = BUTTON_CLICKED; |
else |
SDL_PushEvent(&rel); |
} |
} |
SP->mouse_status.x = (event.button.x - pdc_xoffset) / pdc_fwidth; |
SP->mouse_status.y = (event.button.y - pdc_yoffset) / pdc_fheight; |
btn--; |
SP->mouse_status.button[btn] = action | shift_flags; |
SP->mouse_status.changes = (1 << btn); |
} |
old_mouse_status = SP->mouse_status; |
SP->key_code = TRUE; |
return KEY_MOUSE; |
} |
/* return the next available key or mouse event */ |
int PDC_get_key(void) |
{ |
switch (event.type) |
{ |
case SDL_QUIT: |
exit(1); |
case SDL_VIDEORESIZE: |
if (pdc_own_screen && |
(event.resize.h / pdc_fheight != LINES || |
event.resize.w / pdc_fwidth != COLS)) |
{ |
pdc_sheight = event.resize.h; |
pdc_swidth = event.resize.w; |
if (!SP->resized) |
{ |
SP->resized = TRUE; |
SP->key_code = TRUE; |
return KEY_RESIZE; |
} |
} |
break; |
case SDL_MOUSEMOTION: |
SDL_ShowCursor(SDL_ENABLE); |
case SDL_MOUSEBUTTONUP: |
case SDL_MOUSEBUTTONDOWN: |
oldkey = SDLK_SPACE; |
return _process_mouse_event(); |
case SDL_KEYUP: |
case SDL_KEYDOWN: |
PDC_mouse_set(); |
return _process_key_event(); |
case SDL_USEREVENT: |
PDC_blink_text(); |
} |
return -1; |
} |
/* discard any pending keyboard or mouse input -- this is the core |
routine for flushinp() */ |
void PDC_flushinp(void) |
{ |
PDC_LOG(("PDC_flushinp() - called\n")); |
while (PDC_check_key()); |
} |
bool PDC_has_mouse(void) |
{ |
return TRUE; |
} |
int PDC_mouse_set(void) |
{ |
SDL_ShowCursor(SP->_trap_mbe ? SDL_ENABLE : SDL_DISABLE); |
return OK; |
} |
int PDC_modifiers_set(void) |
{ |
return OK; |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdcscrn.c |
---|
0,0 → 1,364 |
/* PDCurses */ |
#include "pdcsdl.h" |
#include <stdlib.h> |
#ifndef PDC_WIDE |
#include "../common/font437.h" |
#endif |
#include "../common/iconbmp.h" |
#ifdef PDC_WIDE |
# ifndef PDC_FONT_PATH |
# define PDC_FONT_PATH "/usr/share/fonts/truetype/dejavu/DejaVuSansMono.ttf" |
# endif |
TTF_Font *pdc_ttffont = NULL; |
int pdc_font_size = 17; |
#endif |
SDL_Surface *pdc_screen = NULL, *pdc_font = NULL, *pdc_icon = NULL, |
*pdc_back = NULL, *pdc_tileback = NULL; |
int pdc_sheight = 0, pdc_swidth = 0, pdc_yoffset = 0, pdc_xoffset = 0; |
SDL_Color pdc_color[PDC_MAXCOL]; |
Uint32 pdc_mapped[PDC_MAXCOL]; |
int pdc_fheight, pdc_fwidth, pdc_fthick, pdc_flastc; |
bool pdc_own_screen; |
static int max_height, max_width; |
static void _clean(void) |
{ |
#ifdef PDC_WIDE |
if (pdc_ttffont) |
{ |
TTF_CloseFont(pdc_ttffont); |
TTF_Quit(); |
} |
#endif |
SDL_FreeSurface(pdc_tileback); |
SDL_FreeSurface(pdc_back); |
SDL_FreeSurface(pdc_icon); |
SDL_FreeSurface(pdc_font); |
SDL_Quit(); |
} |
void PDC_retile(void) |
{ |
if (pdc_tileback) |
SDL_FreeSurface(pdc_tileback); |
pdc_tileback = SDL_DisplayFormat(pdc_screen); |
if (pdc_tileback == NULL) |
return; |
if (pdc_back) |
{ |
SDL_Rect dest; |
dest.y = 0; |
while (dest.y < pdc_tileback->h) |
{ |
dest.x = 0; |
while (dest.x < pdc_tileback->w) |
{ |
SDL_BlitSurface(pdc_back, 0, pdc_tileback, &dest); |
dest.x += pdc_back->w; |
} |
dest.y += pdc_back->h; |
} |
SDL_BlitSurface(pdc_tileback, 0, pdc_screen, 0); |
} |
} |
void PDC_scr_close(void) |
{ |
PDC_LOG(("PDC_scr_close() - called\n")); |
} |
void PDC_scr_free(void) |
{ |
} |
static void _initialize_colors(void) |
{ |
int i, r, g, b; |
for (i = 0; i < 8; i++) |
{ |
pdc_color[i].r = (i & COLOR_RED) ? 0xc0 : 0; |
pdc_color[i].g = (i & COLOR_GREEN) ? 0xc0 : 0; |
pdc_color[i].b = (i & COLOR_BLUE) ? 0xc0 : 0; |
pdc_color[i + 8].r = (i & COLOR_RED) ? 0xff : 0x40; |
pdc_color[i + 8].g = (i & COLOR_GREEN) ? 0xff : 0x40; |
pdc_color[i + 8].b = (i & COLOR_BLUE) ? 0xff : 0x40; |
} |
/* 256-color xterm extended palette: 216 colors in a 6x6x6 color |
cube, plus 24 shades of gray */ |
for (i = 16, r = 0; r < 6; r++) |
for (g = 0; g < 6; g++) |
for (b = 0; b < 6; b++, i++) |
{ |
pdc_color[i].r = (r ? r * 40 + 55 : 0); |
pdc_color[i].g = (g ? g * 40 + 55 : 0); |
pdc_color[i].b = (b ? b * 40 + 55 : 0); |
} |
for (i = 232; i < 256; i++) |
pdc_color[i].r = pdc_color[i].g = pdc_color[i].b = (i - 232) * 10 + 8; |
for (i = 0; i < 256; i++) |
pdc_mapped[i] = SDL_MapRGB(pdc_screen->format, pdc_color[i].r, |
pdc_color[i].g, pdc_color[i].b); |
} |
/* open the physical screen -- miscellaneous initialization */ |
int PDC_scr_open(void) |
{ |
PDC_LOG(("PDC_scr_open() - called\n")); |
pdc_own_screen = !pdc_screen; |
if (pdc_own_screen) |
{ |
if (SDL_Init(SDL_INIT_VIDEO|SDL_INIT_TIMER) < 0) |
{ |
fprintf(stderr, "Could not start SDL: %s\n", SDL_GetError()); |
return ERR; |
} |
atexit(_clean); |
} |
#ifdef PDC_WIDE |
if (!pdc_ttffont) |
{ |
const char *ptsz, *fname; |
if (TTF_Init() == -1) |
{ |
fprintf(stderr, "Could not start SDL_TTF: %s\n", SDL_GetError()); |
return ERR; |
} |
ptsz = getenv("PDC_FONT_SIZE"); |
if (ptsz != NULL) |
pdc_font_size = atoi(ptsz); |
if (pdc_font_size <= 0) |
pdc_font_size = 18; |
fname = getenv("PDC_FONT"); |
pdc_ttffont = TTF_OpenFont(fname ? fname : PDC_FONT_PATH, |
pdc_font_size); |
} |
if (!pdc_ttffont) |
{ |
fprintf(stderr, "Could not load font\n"); |
return ERR; |
} |
TTF_SetFontKerning(pdc_ttffont, 0); |
TTF_SetFontHinting(pdc_ttffont, TTF_HINTING_MONO); |
SP->mono = FALSE; |
#else |
if (!pdc_font) |
{ |
const char *fname = getenv("PDC_FONT"); |
pdc_font = SDL_LoadBMP(fname ? fname : "pdcfont.bmp"); |
} |
if (!pdc_font) |
pdc_font = SDL_LoadBMP_RW(SDL_RWFromMem(font437, sizeof(font437)), 0); |
if (!pdc_font) |
{ |
fprintf(stderr, "Could not load font\n"); |
return ERR; |
} |
SP->mono = !pdc_font->format->palette; |
#endif |
if (!SP->mono && !pdc_back) |
{ |
const char *bname = getenv("PDC_BACKGROUND"); |
pdc_back = SDL_LoadBMP(bname ? bname : "pdcback.bmp"); |
} |
if (!SP->mono && (pdc_back || !pdc_own_screen)) |
{ |
SP->orig_attr = TRUE; |
SP->orig_fore = COLOR_WHITE; |
SP->orig_back = -1; |
} |
else |
SP->orig_attr = FALSE; |
#ifdef PDC_WIDE |
TTF_SizeText(pdc_ttffont, "W", &pdc_fwidth, &pdc_fheight); |
pdc_fthick = pdc_font_size / 20 + 1; |
#else |
pdc_fheight = pdc_font->h / 8; |
pdc_fwidth = pdc_font->w / 32; |
pdc_fthick = 1; |
if (!SP->mono) |
pdc_flastc = pdc_font->format->palette->ncolors - 1; |
#endif |
if (pdc_own_screen && !pdc_icon) |
{ |
const char *iname = getenv("PDC_ICON"); |
pdc_icon = SDL_LoadBMP(iname ? iname : "pdcicon.bmp"); |
if (!pdc_icon) |
pdc_icon = SDL_LoadBMP_RW(SDL_RWFromMem(iconbmp, |
sizeof(iconbmp)), 0); |
if (pdc_icon) |
SDL_WM_SetIcon(pdc_icon, NULL); |
} |
if (pdc_own_screen) |
{ |
const SDL_VideoInfo *info = SDL_GetVideoInfo(); |
// max_height = info->current_h; |
// max_width = info->current_w; |
const char *env = getenv("PDC_LINES"); |
pdc_sheight = (env ? atoi(env) : 25) * pdc_fheight; |
env = getenv("PDC_COLS"); |
pdc_swidth = (env ? atoi(env) : 80) * pdc_fwidth; |
pdc_screen = SDL_SetVideoMode(pdc_swidth, pdc_sheight, 0, |
SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE); |
} |
else |
{ |
if (!pdc_sheight) |
pdc_sheight = pdc_screen->h - pdc_yoffset; |
if (!pdc_swidth) |
pdc_swidth = pdc_screen->w - pdc_xoffset; |
} |
if (!pdc_screen) |
{ |
fprintf(stderr, "Couldn't create a surface: %s\n", SDL_GetError()); |
return ERR; |
} |
if (SP->orig_attr) |
PDC_retile(); |
_initialize_colors(); |
SDL_EnableUNICODE(1); |
PDC_mouse_set(); |
if (pdc_own_screen) |
PDC_set_title("PDCurses"); |
SP->mouse_wait = PDC_CLICK_PERIOD; |
SP->audible = FALSE; |
SP->termattrs = A_COLOR | A_UNDERLINE | A_LEFT | A_RIGHT | A_REVERSE; |
#ifdef PDC_WIDE |
SP->termattrs |= A_ITALIC; |
#endif |
PDC_reset_prog_mode(); |
return OK; |
} |
/* the core of resize_term() */ |
int PDC_resize_screen(int nlines, int ncols) |
{ |
if (!pdc_own_screen) |
return ERR; |
if (nlines && ncols) |
{ |
while (nlines * pdc_fheight > max_height) |
nlines--; |
pdc_sheight = nlines * pdc_fheight; |
while (ncols * pdc_fwidth > max_width) |
ncols--; |
pdc_swidth = ncols * pdc_fwidth; |
} |
SDL_FreeSurface(pdc_screen); |
pdc_screen = SDL_SetVideoMode(pdc_swidth, pdc_sheight, 0, |
SDL_SWSURFACE|SDL_ANYFORMAT|SDL_RESIZABLE); |
if (pdc_tileback) |
PDC_retile(); |
return OK; |
} |
void PDC_reset_prog_mode(void) |
{ |
PDC_LOG(("PDC_reset_prog_mode() - called.\n")); |
PDC_flushinp(); |
SDL_EnableKeyRepeat(SDL_DEFAULT_REPEAT_DELAY, SDL_DEFAULT_REPEAT_INTERVAL); |
} |
void PDC_reset_shell_mode(void) |
{ |
PDC_LOG(("PDC_reset_shell_mode() - called.\n")); |
SDL_EnableKeyRepeat(0, 0); |
PDC_flushinp(); |
} |
void PDC_restore_screen_mode(int i) |
{ |
} |
void PDC_save_screen_mode(int i) |
{ |
} |
bool PDC_can_change_color(void) |
{ |
return TRUE; |
} |
int PDC_color_content(short color, short *red, short *green, short *blue) |
{ |
*red = DIVROUND(pdc_color[color].r * 1000, 255); |
*green = DIVROUND(pdc_color[color].g * 1000, 255); |
*blue = DIVROUND(pdc_color[color].b * 1000, 255); |
return OK; |
} |
int PDC_init_color(short color, short red, short green, short blue) |
{ |
pdc_color[color].r = DIVROUND(red * 255, 1000); |
pdc_color[color].g = DIVROUND(green * 255, 1000); |
pdc_color[color].b = DIVROUND(blue * 255, 1000); |
pdc_mapped[color] = SDL_MapRGB(pdc_screen->format, pdc_color[color].r, |
pdc_color[color].g, pdc_color[color].b); |
return OK; |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdcsdl.h |
---|
0,0 → 1,34 |
/* PDCurses */ |
#include <SDL.h> |
#ifdef PDC_WIDE |
#include <SDL_ttf.h> |
#endif |
#include <curspriv.h> |
#ifdef PDC_WIDE |
PDCEX TTF_Font *pdc_ttffont; |
PDCEX int pdc_font_size; |
#endif |
PDCEX SDL_Surface *pdc_screen, *pdc_font, *pdc_icon, *pdc_back; |
PDCEX int pdc_sheight, pdc_swidth, pdc_yoffset, pdc_xoffset; |
extern SDL_Surface *pdc_tileback; /* used to regenerate the background |
of "transparent" cells */ |
extern SDL_Color pdc_color[PDC_MAXCOL]; /* colors for font palette */ |
extern Uint32 pdc_mapped[PDC_MAXCOL]; /* colors for FillRect(), as |
used in _highlight() */ |
extern int pdc_fheight, pdc_fwidth; /* font height and width */ |
extern int pdc_fthick; /* thickness for highlights and |
rendered ACS glyphs */ |
extern int pdc_flastc; /* font palette's last color |
(treated as the foreground) */ |
extern bool pdc_own_screen; /* if pdc_screen was not set |
before initscr(), PDCurses is |
responsible for (owns) it */ |
PDCEX void PDC_update_rects(void); |
PDCEX void PDC_retile(void); |
extern void PDC_blink_text(void); |
/contrib/sdk/sources/PDCurses/sdl1/pdcsetsc.c |
---|
0,0 → 1,105 |
/* PDCurses */ |
#include "pdcsdl.h" |
/*man-start************************************************************** |
pdcsetsc |
-------- |
### Synopsis |
int PDC_set_blink(bool blinkon); |
int PDC_set_bold(bool boldon); |
void PDC_set_title(const char *title); |
### Description |
PDC_set_blink() toggles whether the A_BLINK attribute sets an actual |
blink mode (TRUE), or sets the background color to high intensity |
(FALSE). The default is platform-dependent (FALSE in most cases). It |
returns OK if it could set the state to match the given parameter, |
ERR otherwise. |
PDC_set_bold() toggles whether the A_BOLD attribute selects an actual |
bold font (TRUE), or sets the foreground color to high intensity |
(FALSE). It returns OK if it could set the state to match the given |
parameter, ERR otherwise. |
PDC_set_title() sets the title of the window in which the curses |
program is running. This function may not do anything on some |
platforms. |
### Portability |
X/Open ncurses NetBSD |
PDC_set_blink - - - |
PDC_set_title - - - |
**man-end****************************************************************/ |
int PDC_curs_set(int visibility) |
{ |
int ret_vis; |
PDC_LOG(("PDC_curs_set() - called: visibility=%d\n", visibility)); |
ret_vis = SP->visibility; |
SP->visibility = visibility; |
PDC_gotoyx(SP->cursrow, SP->curscol); |
return ret_vis; |
} |
void PDC_set_title(const char *title) |
{ |
PDC_LOG(("PDC_set_title() - called:<%s>\n", title)); |
SDL_WM_SetCaption(title, title); |
} |
int PDC_set_blink(bool blinkon) |
{ |
if (!SP) |
return ERR; |
if (SP->color_started) |
COLORS = PDC_MAXCOL; |
if (blinkon) |
{ |
if (!(SP->termattrs & A_BLINK)) |
{ |
SP->termattrs |= A_BLINK; |
PDC_blink_text(); |
} |
} |
else |
{ |
if (SP->termattrs & A_BLINK) |
{ |
SP->termattrs &= ~A_BLINK; |
PDC_blink_text(); |
} |
} |
return OK; |
} |
int PDC_set_bold(bool boldon) |
{ |
if (!SP) |
return ERR; |
#ifdef PDC_WIDE |
if (boldon) |
SP->termattrs |= A_BOLD; |
else |
SP->termattrs &= ~A_BOLD; |
return OK; |
#else |
return boldon ? ERR : OK; |
#endif |
} |
/contrib/sdk/sources/PDCurses/sdl1/pdcutil.c |
---|
0,0 → 1,28 |
/* PDCurses */ |
#include "pdcsdl.h" |
void PDC_beep(void) |
{ |
PDC_LOG(("PDC_beep() - called\n")); |
} |
void PDC_napms(int ms) |
{ |
PDC_LOG(("PDC_napms() - called: ms=%d\n", ms)); |
PDC_update_rects(); |
while (ms > 50) |
{ |
SDL_PumpEvents(); |
SDL_Delay(50); |
ms -= 50; |
} |
SDL_PumpEvents(); |
SDL_Delay(ms); |
} |
const char *PDC_sysname(void) |
{ |
return "SDL"; |
} |
/contrib/sdk/sources/PDCurses/sdl1/sdltest.c |
---|
0,0 → 1,79 |
/* Here's a simple example of combining SDL and PDCurses functionality. |
The top portion of the window is devoted to SDL, with a four-line |
(assuming the default 8x16 font) stdscr at the bottom. |
*/ |
#include <SDL.h> |
#include <curses.h> |
#include <stdlib.h> |
#include <time.h> |
/* You could #include pdcsdl.h, or just add the relevant declarations |
here: */ |
PDCEX SDL_Surface *pdc_screen; |
PDCEX int pdc_yoffset; |
int main(int argc, char **argv) |
{ |
char inp[60]; |
int i, j, seed; |
seed = time((time_t *)0); |
srand(seed); |
/* Initialize SDL */ |
if (SDL_Init(SDL_INIT_VIDEO) < 0) |
exit(1); |
atexit(SDL_Quit); |
pdc_screen = SDL_SetVideoMode(640, 480, 0, SDL_SWSURFACE|SDL_ANYFORMAT); |
/* Initialize PDCurses */ |
pdc_yoffset = 416; /* 480 - 4 * 16 */ |
initscr(); |
start_color(); |
scrollok(stdscr, TRUE); |
PDC_set_title("PDCurses for SDL"); |
/* Do some SDL stuff */ |
for (i = 640, j = 416; j; i -= 2, j -= 2) |
{ |
SDL_Rect dest; |
dest.x = (640 - i) / 2; |
dest.y = (416 - j) / 2; |
dest.w = i; |
dest.h = j; |
SDL_FillRect(pdc_screen, &dest, |
SDL_MapRGB(pdc_screen->format, rand() % 256, |
rand() % 256, rand() % 256)); |
} |
SDL_UpdateRect(pdc_screen, 0, 0, 640, 416); |
/* Do some curses stuff */ |
init_pair(1, COLOR_WHITE + 8, COLOR_BLUE); |
bkgd(COLOR_PAIR(1)); |
addstr("This is a demo of "); |
attron(A_UNDERLINE); |
addstr("PDCurses for SDL"); |
attroff(A_UNDERLINE); |
addstr(".\nYour comments here: "); |
getnstr(inp, 59); |
addstr("Press any key to exit."); |
getch(); |
endwin(); |
return 0; |
} |