747 lines
21 KiB
C
747 lines
21 KiB
C
/* PDCurses */
|
|
|
|
#include "pdcx11.h"
|
|
|
|
#include <xpm.h>
|
|
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
|
|
/* Default icons for XCurses applications. */
|
|
|
|
#include "../common/icon64.xpm"
|
|
#include "../common/icon32.xpm"
|
|
|
|
#ifdef PDC_WIDE
|
|
# define DEFNFONT "-misc-fixed-medium-r-normal--20-200-75-75-c-100-iso10646-1"
|
|
# define DEFIFONT "-misc-fixed-medium-o-normal--20-200-75-75-c-100-iso10646-1"
|
|
# define DEFBFONT "-misc-fixed-bold-r-normal--20-200-75-75-c-100-iso10646-1"
|
|
#else
|
|
# define DEFNFONT "-misc-fixed-medium-r-normal--13-120-75-75-c-70-iso8859-1"
|
|
# define DEFIFONT "-misc-fixed-medium-o-normal--13-120-75-75-c-70-iso8859-1"
|
|
# define DEFBFONT "-misc-fixed-bold-r-normal--13-120-75-75-c-70-iso8859-1"
|
|
#endif
|
|
|
|
#ifndef MAX_PATH
|
|
# define MAX_PATH 256
|
|
#endif
|
|
|
|
/* Macros just for app_resources */
|
|
|
|
#define APPDATAOFF(n) XtOffsetOf(XCursesAppData, n)
|
|
|
|
#define RINT(name1, name2, value) { \
|
|
#name1, #name2, XtRInt, \
|
|
sizeof(int), APPDATAOFF(name1), XtRImmediate, \
|
|
(XtPointer)value \
|
|
}
|
|
|
|
#define RPIXEL(name1, name2, value) { \
|
|
#name1, #name2, XtRPixel, \
|
|
sizeof(Pixel), APPDATAOFF(name1), XtRString, \
|
|
(XtPointer)#value \
|
|
}
|
|
|
|
#define RCOLOR(name, value) RPIXEL(color##name, Color##name, value)
|
|
|
|
|
|
#define RSTRINGP(name1, name2, param) { \
|
|
#name1, #name2, XtRString, \
|
|
MAX_PATH, APPDATAOFF(name1), XtRString, (XtPointer)param \
|
|
}
|
|
|
|
#define RSTRING(name1, name2) RSTRINGP(name1, name2, "")
|
|
|
|
#define RFONT(name1, name2, value) { \
|
|
#name1, #name2, XtRFontStruct, \
|
|
sizeof(XFontStruct), APPDATAOFF(name1), XtRString, \
|
|
(XtPointer)value \
|
|
}
|
|
|
|
#define RCURSOR(name1, name2, value) { \
|
|
#name1, #name2, XtRCursor, \
|
|
sizeof(Cursor), APPDATAOFF(name1), XtRString, \
|
|
(XtPointer)#value \
|
|
}
|
|
|
|
static XtResource app_resources[] =
|
|
{
|
|
RINT(lines, Lines, -1),
|
|
RINT(cols, Cols, -1),
|
|
|
|
RCOLOR(Black, Black),
|
|
RCOLOR(Red, red3),
|
|
RCOLOR(Green, green3),
|
|
RCOLOR(Yellow, yellow3),
|
|
RCOLOR(Blue, blue3),
|
|
RCOLOR(Magenta, magenta3),
|
|
RCOLOR(Cyan, cyan3),
|
|
RCOLOR(White, Grey),
|
|
|
|
RCOLOR(BoldBlack, grey40),
|
|
RCOLOR(BoldRed, red1),
|
|
RCOLOR(BoldGreen, green1),
|
|
RCOLOR(BoldYellow, yellow1),
|
|
RCOLOR(BoldBlue, blue1),
|
|
RCOLOR(BoldMagenta, magenta1),
|
|
RCOLOR(BoldCyan, cyan1),
|
|
RCOLOR(BoldWhite, White),
|
|
|
|
RFONT(normalFont, NormalFont, DEFNFONT),
|
|
RFONT(italicFont, ItalicFont, DEFIFONT),
|
|
RFONT(boldFont, BoldFont, DEFBFONT),
|
|
|
|
RSTRING(bitmap, Bitmap),
|
|
RSTRING(pixmap, Pixmap),
|
|
RCURSOR(pointer, Pointer, xterm),
|
|
|
|
RPIXEL(pointerForeColor, PointerForeColor, Black),
|
|
RPIXEL(pointerBackColor, PointerBackColor, White),
|
|
|
|
RINT(doubleClickPeriod, DoubleClickPeriod, (PDC_CLICK_PERIOD * 2)),
|
|
RINT(clickPeriod, ClickPeriod, PDC_CLICK_PERIOD),
|
|
RINT(scrollbarWidth, ScrollbarWidth, 15),
|
|
RINT(cursorBlinkRate, CursorBlinkRate, 0),
|
|
|
|
RSTRING(textCursor, TextCursor),
|
|
RINT(textBlinkRate, TextBlinkRate, 500)
|
|
};
|
|
|
|
#undef RCURSOR
|
|
#undef RFONT
|
|
#undef RSTRING
|
|
#undef RCOLOR
|
|
#undef RPIXEL
|
|
#undef RINT
|
|
#undef APPDATAOFF
|
|
#undef DEFBFONT
|
|
#undef DEFIFONT
|
|
#undef DEFNFONT
|
|
|
|
/* Macros for options */
|
|
|
|
#define COPT(name) {"-" #name, "*" #name, XrmoptionSepArg, NULL}
|
|
#define CCOLOR(name) COPT(color##name)
|
|
|
|
static XrmOptionDescRec options[] =
|
|
{
|
|
COPT(lines), COPT(cols), COPT(normalFont), COPT(italicFont),
|
|
COPT(boldFont), COPT(bitmap), COPT(pixmap), COPT(pointer),
|
|
COPT(clickPeriod), COPT(doubleClickPeriod), COPT(scrollbarWidth),
|
|
COPT(pointerForeColor), COPT(pointerBackColor),
|
|
COPT(cursorBlinkRate), COPT(textCursor), COPT(textBlinkRate),
|
|
|
|
CCOLOR(Black), CCOLOR(Red), CCOLOR(Green), CCOLOR(Yellow),
|
|
CCOLOR(Blue), CCOLOR(Magenta), CCOLOR(Cyan), CCOLOR(White),
|
|
|
|
CCOLOR(BoldBlack), CCOLOR(BoldRed), CCOLOR(BoldGreen),
|
|
CCOLOR(BoldYellow), CCOLOR(BoldBlue), CCOLOR(BoldMagenta),
|
|
CCOLOR(BoldCyan), CCOLOR(BoldWhite)
|
|
};
|
|
|
|
#undef CCOLOR
|
|
#undef COPT
|
|
|
|
Pixel pdc_color[PDC_MAXCOL];
|
|
|
|
XCursesAppData pdc_app_data;
|
|
XtAppContext pdc_app_context;
|
|
Widget pdc_toplevel, pdc_drawing;
|
|
|
|
GC pdc_normal_gc, pdc_cursor_gc, pdc_italic_gc, pdc_bold_gc;
|
|
int pdc_fheight, pdc_fwidth, pdc_fascent, pdc_fdescent;
|
|
int pdc_wwidth, pdc_wheight;
|
|
bool pdc_window_entered = TRUE, pdc_resize_now = FALSE;
|
|
|
|
static Atom wm_atom[2];
|
|
static String class_name = "XCurses";
|
|
static int resize_window_width = 0, resize_window_height = 0;
|
|
static int received_map_notify = 0;
|
|
static bool exposed = FALSE;
|
|
|
|
static Pixmap icon_pixmap, icon_pixmap_mask;
|
|
|
|
static char *prog_name[] = {"PDCurses", NULL};
|
|
static char **argv = prog_name;
|
|
static int argc = 1;
|
|
|
|
/* close the physical screen */
|
|
|
|
void PDC_scr_close(void)
|
|
{
|
|
PDC_LOG(("PDC_scr_close() - called\n"));
|
|
}
|
|
|
|
void PDC_scr_free(void)
|
|
{
|
|
if (icon_pixmap)
|
|
XFreePixmap(XCURSESDISPLAY, icon_pixmap);
|
|
if (icon_pixmap_mask)
|
|
XFreePixmap(XCURSESDISPLAY, icon_pixmap_mask);
|
|
|
|
XFreeGC(XCURSESDISPLAY, pdc_normal_gc);
|
|
XFreeGC(XCURSESDISPLAY, pdc_italic_gc);
|
|
XFreeGC(XCURSESDISPLAY, pdc_bold_gc);
|
|
XFreeGC(XCURSESDISPLAY, pdc_cursor_gc);
|
|
XDestroyIC(pdc_xic);
|
|
}
|
|
|
|
void XCursesExit(void)
|
|
{
|
|
PDC_scr_free();
|
|
}
|
|
|
|
static void _initialize_colors(void)
|
|
{
|
|
int i, r, g, b;
|
|
|
|
pdc_color[COLOR_BLACK] = pdc_app_data.colorBlack;
|
|
pdc_color[COLOR_RED] = pdc_app_data.colorRed;
|
|
pdc_color[COLOR_GREEN] = pdc_app_data.colorGreen;
|
|
pdc_color[COLOR_YELLOW] = pdc_app_data.colorYellow;
|
|
pdc_color[COLOR_BLUE] = pdc_app_data.colorBlue;
|
|
pdc_color[COLOR_MAGENTA] = pdc_app_data.colorMagenta;
|
|
pdc_color[COLOR_CYAN] = pdc_app_data.colorCyan;
|
|
pdc_color[COLOR_WHITE] = pdc_app_data.colorWhite;
|
|
|
|
pdc_color[COLOR_BLACK + 8] = pdc_app_data.colorBoldBlack;
|
|
pdc_color[COLOR_RED + 8] = pdc_app_data.colorBoldRed;
|
|
pdc_color[COLOR_GREEN + 8] = pdc_app_data.colorBoldGreen;
|
|
pdc_color[COLOR_YELLOW + 8] = pdc_app_data.colorBoldYellow;
|
|
pdc_color[COLOR_BLUE + 8] = pdc_app_data.colorBoldBlue;
|
|
pdc_color[COLOR_MAGENTA + 8] = pdc_app_data.colorBoldMagenta;
|
|
pdc_color[COLOR_CYAN + 8] = pdc_app_data.colorBoldCyan;
|
|
pdc_color[COLOR_WHITE + 8] = pdc_app_data.colorBoldWhite;
|
|
|
|
#define RGB(R, G, B) ( ((unsigned long)(R) << 16) | \
|
|
((unsigned long)(G) << 8) | \
|
|
((unsigned long)(B)) )
|
|
|
|
/* 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++)
|
|
pdc_color[i++] = RGB(r ? r * 40 + 55 : 0,
|
|
g ? g * 40 + 55 : 0,
|
|
b ? b * 40 + 55 : 0);
|
|
for (i = 0; i < 24; i++)
|
|
pdc_color[i + 232] = RGB(i * 10 + 8, i * 10 + 8, i * 10 + 8);
|
|
|
|
#undef RGB
|
|
}
|
|
|
|
static void _get_icon(void)
|
|
{
|
|
Status rc;
|
|
|
|
PDC_LOG(("_get_icon() - called\n"));
|
|
|
|
if (pdc_app_data.pixmap && pdc_app_data.pixmap[0]) /* supplied pixmap */
|
|
{
|
|
XpmReadFileToPixmap(XtDisplay(pdc_toplevel),
|
|
RootWindowOfScreen(XtScreen(pdc_toplevel)),
|
|
(char *)pdc_app_data.pixmap,
|
|
&icon_pixmap, &icon_pixmap_mask, NULL);
|
|
}
|
|
else if (pdc_app_data.bitmap && pdc_app_data.bitmap[0]) /* bitmap */
|
|
{
|
|
unsigned file_bitmap_width = 0, file_bitmap_height = 0;
|
|
int x_hot = 0, y_hot = 0;
|
|
|
|
rc = XReadBitmapFile(XtDisplay(pdc_toplevel),
|
|
RootWindowOfScreen(XtScreen(pdc_toplevel)),
|
|
(char *)pdc_app_data.bitmap,
|
|
&file_bitmap_width, &file_bitmap_height,
|
|
&icon_pixmap, &x_hot, &y_hot);
|
|
|
|
if (BitmapOpenFailed == rc)
|
|
fprintf(stderr, "bitmap file %s: not found\n",
|
|
pdc_app_data.bitmap);
|
|
else if (BitmapFileInvalid == rc)
|
|
fprintf(stderr, "bitmap file %s: contents invalid\n",
|
|
pdc_app_data.bitmap);
|
|
}
|
|
else
|
|
{
|
|
XIconSize *icon_size;
|
|
int size_count = 0, max_height = 0, max_width = 0;
|
|
|
|
icon_size = XAllocIconSize();
|
|
|
|
rc = XGetIconSizes(XtDisplay(pdc_toplevel),
|
|
RootWindowOfScreen(XtScreen(pdc_toplevel)),
|
|
&icon_size, &size_count);
|
|
|
|
/* if the WM can advise on icon sizes... */
|
|
|
|
if (rc && size_count)
|
|
{
|
|
int i;
|
|
|
|
PDC_LOG(("size_count: %d rc: %d\n", size_count, rc));
|
|
|
|
for (i = 0; i < size_count; i++)
|
|
{
|
|
if (icon_size[i].max_width > max_width)
|
|
max_width = icon_size[i].max_width;
|
|
if (icon_size[i].max_height > max_height)
|
|
max_height = icon_size[i].max_height;
|
|
|
|
PDC_LOG(("min: %d %d\n",
|
|
icon_size[i].min_width, icon_size[i].min_height));
|
|
|
|
PDC_LOG(("max: %d %d\n",
|
|
icon_size[i].max_width, icon_size[i].max_height));
|
|
|
|
PDC_LOG(("inc: %d %d\n",
|
|
icon_size[i].width_inc, icon_size[i].height_inc));
|
|
}
|
|
}
|
|
|
|
XFree(icon_size);
|
|
|
|
XpmCreatePixmapFromData(XtDisplay(pdc_toplevel),
|
|
RootWindowOfScreen(XtScreen(pdc_toplevel)),
|
|
(max_width >= 64 && max_height >= 64) ? icon64 : icon32,
|
|
&icon_pixmap, &icon_pixmap_mask, NULL);
|
|
}
|
|
}
|
|
|
|
/* Redraw the entire screen */
|
|
|
|
static void _display_screen(void)
|
|
{
|
|
int row;
|
|
|
|
PDC_LOG(("_display_screen() - called\n"));
|
|
|
|
if (!curscr)
|
|
return;
|
|
|
|
for (row = 0; row < SP->lines; row++)
|
|
PDC_transform_line(row, 0, COLS, curscr->_y[row]);
|
|
|
|
PDC_redraw_cursor();
|
|
}
|
|
|
|
static void _handle_expose(Widget w, XtPointer client_data, XEvent *event,
|
|
Boolean *unused)
|
|
{
|
|
PDC_LOG(("_handle_expose() - called\n"));
|
|
|
|
/* ignore all Exposes except last */
|
|
|
|
if (event->xexpose.count)
|
|
return;
|
|
|
|
exposed = TRUE;
|
|
|
|
if (received_map_notify)
|
|
_display_screen();
|
|
}
|
|
|
|
static void _handle_nonmaskable(Widget w, XtPointer client_data, XEvent *event,
|
|
Boolean *unused)
|
|
{
|
|
XClientMessageEvent *client_event = (XClientMessageEvent *)event;
|
|
|
|
PDC_LOG(("_handle_nonmaskable called: event %d\n", event->type));
|
|
|
|
if (event->type == ClientMessage)
|
|
{
|
|
PDC_LOG(("ClientMessage received\n"));
|
|
|
|
/* This code used to include handling of WM_SAVE_YOURSELF, but
|
|
it resulted in continual failure of THE on my Toshiba laptop.
|
|
Removed on 3-3-2001. Now only exits on WM_DELETE_WINDOW. */
|
|
|
|
if ((Atom)client_event->data.s[0] == wm_atom[0])
|
|
exit(0);
|
|
}
|
|
}
|
|
|
|
static void _handle_enter_leave(Widget w, XtPointer client_data,
|
|
XEvent *event, Boolean *unused)
|
|
{
|
|
PDC_LOG(("_handle_enter_leave called\n"));
|
|
|
|
switch(event->type)
|
|
{
|
|
case EnterNotify:
|
|
PDC_LOG(("EnterNotify received\n"));
|
|
|
|
pdc_window_entered = TRUE;
|
|
break;
|
|
|
|
case LeaveNotify:
|
|
PDC_LOG(("LeaveNotify received\n"));
|
|
|
|
pdc_window_entered = FALSE;
|
|
|
|
/* Display the cursor so it stays on while the window is
|
|
not current */
|
|
|
|
PDC_redraw_cursor();
|
|
break;
|
|
|
|
default:
|
|
PDC_LOG(("_handle_enter_leave - unknown event %d\n", event->type));
|
|
}
|
|
}
|
|
|
|
static void _handle_structure_notify(Widget w, XtPointer client_data,
|
|
XEvent *event, Boolean *unused)
|
|
{
|
|
PDC_LOG(("_handle_structure_notify() - called\n"));
|
|
|
|
switch(event->type)
|
|
{
|
|
case ConfigureNotify:
|
|
PDC_LOG(("ConfigureNotify received\n"));
|
|
|
|
/* Window has been resized, change width and height to send to
|
|
place_text and place_graphics in next Expose. */
|
|
{
|
|
int new_w = event->xconfigure.width;
|
|
int new_h = event->xconfigure.height;
|
|
|
|
if (new_w != resize_window_width ||
|
|
new_h != resize_window_height)
|
|
{
|
|
resize_window_width = new_w;
|
|
resize_window_height = new_h;
|
|
|
|
SP->resized = TRUE;
|
|
pdc_resize_now = TRUE;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case MapNotify:
|
|
PDC_LOG(("MapNotify received\n"));
|
|
|
|
received_map_notify = 1;
|
|
|
|
break;
|
|
|
|
default:
|
|
PDC_LOG(("_handle_structure_notify - unknown event %d\n",
|
|
event->type));
|
|
}
|
|
}
|
|
|
|
static void _get_gc(GC *gc, XFontStruct *font_info, int fore, int back)
|
|
{
|
|
XGCValues values;
|
|
|
|
/* Create default Graphics Context */
|
|
|
|
*gc = XCreateGC(XCURSESDISPLAY, XCURSESWIN, 0L, &values);
|
|
|
|
/* specify font */
|
|
|
|
XSetFont(XCURSESDISPLAY, *gc, font_info->fid);
|
|
|
|
XSetForeground(XCURSESDISPLAY, *gc, pdc_color[fore]);
|
|
XSetBackground(XCURSESDISPLAY, *gc, pdc_color[back]);
|
|
}
|
|
|
|
static void _pointer_setup(void)
|
|
{
|
|
XColor pointerforecolor, pointerbackcolor;
|
|
XrmValue rmfrom, rmto;
|
|
|
|
XDefineCursor(XCURSESDISPLAY, XCURSESWIN, pdc_app_data.pointer);
|
|
rmfrom.size = sizeof(Pixel);
|
|
rmto.size = sizeof(XColor);
|
|
|
|
rmto.addr = (XPointer)&pointerforecolor;
|
|
rmfrom.addr = (XPointer)&(pdc_app_data.pointerForeColor);
|
|
XtConvertAndStore(pdc_drawing, XtRPixel, &rmfrom, XtRColor, &rmto);
|
|
|
|
rmfrom.size = sizeof(Pixel);
|
|
rmto.size = sizeof(XColor);
|
|
|
|
rmfrom.addr = (XPointer)&(pdc_app_data.pointerBackColor);
|
|
rmto.addr = (XPointer)&pointerbackcolor;
|
|
XtConvertAndStore(pdc_drawing, XtRPixel, &rmfrom, XtRColor, &rmto);
|
|
|
|
XRecolorCursor(XCURSESDISPLAY, pdc_app_data.pointer,
|
|
&pointerforecolor, &pointerbackcolor);
|
|
}
|
|
|
|
void PDC_set_args(int c, char **v)
|
|
{
|
|
argc = c;
|
|
argv = v;
|
|
}
|
|
|
|
/* open the physical screen -- miscellaneous initialization */
|
|
|
|
int PDC_scr_open(void)
|
|
{
|
|
bool italic_font_valid, bold_font_valid;
|
|
int minwidth, minheight;
|
|
|
|
PDC_LOG(("PDC_scr_open() - called\n"));
|
|
|
|
/* Start defining X Toolkit things */
|
|
|
|
#if XtSpecificationRelease > 4
|
|
XtSetLanguageProc(NULL, (XtLanguageProc)NULL, NULL);
|
|
#endif
|
|
|
|
/* Exit if no DISPLAY variable set */
|
|
|
|
if (!getenv("DISPLAY"))
|
|
{
|
|
fprintf(stderr, "Error: no DISPLAY variable set\n");
|
|
return ERR;
|
|
}
|
|
|
|
/* Initialise the top level widget */
|
|
|
|
pdc_toplevel = XtVaAppInitialize(&pdc_app_context, class_name, options,
|
|
XtNumber(options), &argc, argv, NULL, NULL);
|
|
|
|
XtVaGetApplicationResources(pdc_toplevel, &pdc_app_data, app_resources,
|
|
XtNumber(app_resources), NULL);
|
|
|
|
/* Check application resource values here */
|
|
|
|
pdc_fwidth = pdc_app_data.normalFont->max_bounds.width;
|
|
|
|
pdc_fascent = pdc_app_data.normalFont->ascent;
|
|
pdc_fdescent = pdc_app_data.normalFont->descent;
|
|
pdc_fheight = pdc_fascent + pdc_fdescent;
|
|
|
|
/* Check that the italic font and normal fonts are the same size */
|
|
|
|
italic_font_valid =
|
|
pdc_fwidth == pdc_app_data.italicFont->max_bounds.width;
|
|
|
|
bold_font_valid =
|
|
pdc_fwidth == pdc_app_data.boldFont->max_bounds.width;
|
|
|
|
/* Calculate size of display window */
|
|
|
|
COLS = pdc_app_data.cols;
|
|
LINES = pdc_app_data.lines;
|
|
|
|
if (-1 == COLS)
|
|
{
|
|
const char *env = getenv("PDC_COLS");
|
|
if (env)
|
|
COLS = atoi(env);
|
|
|
|
if (COLS <= 0)
|
|
COLS = 80;
|
|
}
|
|
|
|
if (-1 == LINES)
|
|
{
|
|
const char *env = getenv("PDC_LINES");
|
|
if (env)
|
|
LINES = atoi(env);
|
|
|
|
if (LINES <= 0)
|
|
LINES = 24;
|
|
}
|
|
|
|
pdc_wwidth = pdc_fwidth * COLS;
|
|
pdc_wheight = pdc_fheight * LINES;
|
|
|
|
minwidth = pdc_fwidth * 2;
|
|
minheight = pdc_fheight * 2;
|
|
|
|
/* Set up the icon for the application; the default is an internal
|
|
one for PDCurses. Then set various application level resources. */
|
|
|
|
_get_icon();
|
|
|
|
XtVaSetValues(pdc_toplevel, XtNminWidth, minwidth, XtNminHeight,
|
|
minheight, XtNbaseWidth, 0, XtNbaseHeight, 0,
|
|
XtNbackground, 0, XtNiconPixmap, icon_pixmap,
|
|
XtNiconMask, icon_pixmap_mask, NULL);
|
|
|
|
/* Create a widget in which to draw */
|
|
|
|
if (!PDC_scrollbar_init(argv[0]))
|
|
{
|
|
pdc_drawing = pdc_toplevel;
|
|
|
|
XtVaSetValues(pdc_toplevel, XtNwidth, pdc_wwidth, XtNheight,
|
|
pdc_wheight, XtNwidthInc, pdc_fwidth, XtNheightInc,
|
|
pdc_fheight, NULL);
|
|
}
|
|
|
|
/* Determine text cursor alignment from resources */
|
|
|
|
if (!strcmp(pdc_app_data.textCursor, "vertical"))
|
|
pdc_vertical_cursor = TRUE;
|
|
|
|
SP->lines = LINES;
|
|
SP->cols = COLS;
|
|
|
|
SP->mouse_wait = pdc_app_data.clickPeriod;
|
|
SP->audible = TRUE;
|
|
|
|
SP->termattrs = A_COLOR | A_ITALIC | A_UNDERLINE | A_LEFT | A_RIGHT |
|
|
A_REVERSE;
|
|
|
|
/* Add Event handlers to the drawing widget */
|
|
|
|
XtAddEventHandler(pdc_drawing, ExposureMask, False, _handle_expose, NULL);
|
|
XtAddEventHandler(pdc_drawing, StructureNotifyMask, False,
|
|
_handle_structure_notify, NULL);
|
|
XtAddEventHandler(pdc_drawing, EnterWindowMask | LeaveWindowMask, False,
|
|
_handle_enter_leave, NULL);
|
|
XtAddEventHandler(pdc_toplevel, 0, True, _handle_nonmaskable, NULL);
|
|
|
|
/* If there is a cursorBlink resource, start the Timeout event */
|
|
|
|
if (pdc_app_data.cursorBlinkRate)
|
|
XtAppAddTimeOut(pdc_app_context, pdc_app_data.cursorBlinkRate,
|
|
PDC_blink_cursor, NULL);
|
|
|
|
XtRealizeWidget(pdc_toplevel);
|
|
|
|
/* Handle trapping of the WM_DELETE_WINDOW property */
|
|
|
|
wm_atom[0] = XInternAtom(XtDisplay(pdc_toplevel), "WM_DELETE_WINDOW",
|
|
False);
|
|
|
|
/* Make sure we tell X that we'd like to take focus */
|
|
wm_atom[1] = XInternAtom(XtDisplay(pdc_toplevel), "WM_TAKE_FOCUS",
|
|
False);
|
|
XSetWMProtocols(XtDisplay(pdc_toplevel), XtWindow(pdc_toplevel),
|
|
wm_atom, 2);
|
|
|
|
/* Create the Graphics Context for drawing. This MUST be done AFTER
|
|
the associated widget has been realized. */
|
|
|
|
PDC_LOG(("before _get_gc\n"));
|
|
|
|
_get_gc(&pdc_normal_gc, pdc_app_data.normalFont, COLOR_WHITE, COLOR_BLACK);
|
|
|
|
_get_gc(&pdc_italic_gc, italic_font_valid ? pdc_app_data.italicFont :
|
|
pdc_app_data.normalFont, COLOR_WHITE, COLOR_BLACK);
|
|
|
|
_get_gc(&pdc_bold_gc, bold_font_valid ? pdc_app_data.boldFont :
|
|
pdc_app_data.normalFont, COLOR_WHITE, COLOR_BLACK);
|
|
|
|
_get_gc(&pdc_cursor_gc, pdc_app_data.normalFont,
|
|
COLOR_WHITE, COLOR_BLACK);
|
|
|
|
XSetLineAttributes(XCURSESDISPLAY, pdc_cursor_gc, 2,
|
|
LineSolid, CapButt, JoinMiter);
|
|
|
|
/* Set the pointer for the application */
|
|
|
|
_pointer_setup();
|
|
|
|
if (ERR == PDC_kb_setup())
|
|
return ERR;
|
|
|
|
while (!exposed)
|
|
{
|
|
XEvent event;
|
|
|
|
XtAppNextEvent(pdc_app_context, &event);
|
|
XtDispatchEvent(&event);
|
|
}
|
|
|
|
_initialize_colors();
|
|
|
|
SP->orig_attr = FALSE;
|
|
|
|
atexit(PDC_scr_free);
|
|
|
|
XSync(XtDisplay(pdc_toplevel), True);
|
|
SP->resized = pdc_resize_now = FALSE;
|
|
|
|
/* Make sure that we say that we're allowed to have input focus.
|
|
Otherwise some window managers will refuse to focus the window. */
|
|
XWMHints* hints = XGetWMHints(XtDisplay(pdc_toplevel), XtWindow(pdc_toplevel));
|
|
hints->input=true;
|
|
XSetWMHints(XtDisplay(pdc_toplevel), XtWindow(pdc_toplevel), hints);
|
|
XFree(hints);
|
|
|
|
return OK;
|
|
}
|
|
|
|
/* the core of resize_term() */
|
|
|
|
int PDC_resize_screen(int nlines, int ncols)
|
|
{
|
|
PDC_LOG(("PDC_resize_screen() - called. Lines: %d Cols: %d\n",
|
|
nlines, ncols));
|
|
|
|
if (nlines || ncols || !SP->resized)
|
|
return ERR;
|
|
|
|
pdc_wwidth = resize_window_width;
|
|
pdc_wheight = resize_window_height;
|
|
pdc_visible_cursor = TRUE;
|
|
|
|
return OK;
|
|
}
|
|
|
|
void PDC_reset_prog_mode(void)
|
|
{
|
|
PDC_LOG(("PDC_reset_prog_mode() - called.\n"));
|
|
}
|
|
|
|
void PDC_reset_shell_mode(void)
|
|
{
|
|
PDC_LOG(("PDC_reset_shell_mode() - called.\n"));
|
|
}
|
|
|
|
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)
|
|
{
|
|
XColor tmp;
|
|
Colormap cmap = DefaultColormap(XCURSESDISPLAY,
|
|
DefaultScreen(XCURSESDISPLAY));
|
|
|
|
tmp.pixel = pdc_color[color];
|
|
XQueryColor(XCURSESDISPLAY, cmap, &tmp);
|
|
|
|
*red = ((double)(tmp.red) * 1000 / 65535) + 0.5;
|
|
*green = ((double)(tmp.green) * 1000 / 65535) + 0.5;
|
|
*blue = ((double)(tmp.blue) * 1000 / 65535) + 0.5;
|
|
|
|
return OK;
|
|
}
|
|
|
|
int PDC_init_color(short color, short red, short green, short blue)
|
|
{
|
|
XColor tmp;
|
|
|
|
tmp.red = ((double)red * 65535 / 1000) + 0.5;
|
|
tmp.green = ((double)green * 65535 / 1000) + 0.5;
|
|
tmp.blue = ((double)blue * 65535 / 1000) + 0.5;
|
|
|
|
Colormap cmap = DefaultColormap(XCURSESDISPLAY,
|
|
DefaultScreen(XCURSESDISPLAY));
|
|
|
|
if (XAllocColor(XCURSESDISPLAY, cmap, &tmp))
|
|
pdc_color[color] = tmp.pixel;
|
|
|
|
return OK;
|
|
}
|