void gcmd_win_refresh(window_t *win, glui32 arg)
{
clear();
gli_windows_redraw();
gli_msgline_redraw();
wrefresh(curscr);
}
void gli_windows_size_change()
{
compute_content_box();
if (gli_rootwin) {
gli_window_rearrange(gli_rootwin, &content_box);
}
gli_windows_redraw();
gli_msgline_redraw();
gli_event_store(evtype_Arrange, NULL, 0, 0);
}
/* Set up the window system. This is called from main(). */
void gli_initialize_windows()
{
int ix;
gli_rootwin = NULL;
gli_focuswin = NULL;
/* Build a convenient array of spaces. */
for (ix=0; ix<NUMSPACES; ix++)
spacebuffer[ix] = ' ';
spacebuffer[NUMSPACES] = '\0';
/* Create the curses.h attribute values for each style. */
for (ix=0; ix<style_NUMSTYLES; ix++) {
chtype val = 0;
if (ix == style_Emphasized || ix == style_Note)
val |= A_UNDERLINE;
if (ix == style_Alert)
val |= A_REVERSE;
if (ix == style_Header || ix == style_Subheader || ix == style_Input)
val |= A_BOLD;
win_textbuffer_styleattrs[ix] = val;
if (pref_reverse_textgrids)
val ^= A_REVERSE;
win_textgrid_styleattrs[ix] = val;
}
/* Figure out the screen size. */
compute_content_box();
#ifdef OPT_USE_SIGNALS
just_resumed = FALSE;
just_killed = FALSE;
signal(SIGCONT, &gli_sig_resume);
signal(SIGHUP, &gli_sig_interrupt);
signal(SIGINT, &gli_sig_interrupt);
#ifdef OPT_WINCHANGED_SIGNAL
screen_size_changed = FALSE;
signal(SIGWINCH, &gli_sig_winsize);
#endif /* OPT_WINCHANGED_SIGNAL */
#endif /* OPT_USE_SIGNALS */
/* Draw the initial setup (no windows) */
gli_windows_redraw();
}
static void onexpose(GtkWidget *widget, GdkEventExpose *event, void *data)
{
int x0 = event->area.x;
int y0 = event->area.y;
int w = event->area.width;
int h = event->area.height;
if (x0 < 0) x0 = 0;
if (y0 < 0) y0 = 0;
if (x0 + w > gli_image_w) w = gli_image_w - x0;
if (y0 + h > gli_image_h) h = gli_image_h - y0;
if (w < 0) return;
if (h < 0) return;
gli_windows_redraw();
gdk_draw_rgb_image(canvas->window, canvas->style->black_gc,
x0, y0, w, h,
GDK_RGB_DITHER_NONE,
gli_image_rgb + y0 * gli_image_s + x0 * 3,
gli_image_s);
}
LRESULT CALLBACK
viewproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int x = (signed short) LOWORD(lParam);
int y = (signed short) HIWORD(lParam);
glui32 key;
switch (message)
{
case WM_ERASEBKGND:
return 1; // don't erase; we'll repaint it all
case WM_PAINT:
{
PAINTSTRUCT ps;
/* make sure we have a fresh bitmap */
if (!gli_drawselect)
gli_windows_redraw();
else
gli_drawselect = FALSE;
/* and blit it to the screen */
hdc = BeginPaint(hwnd, &ps);
winblit(ps.rcPaint);
hdc = NULL;
EndPaint(hwnd, &ps);
return 0;
}
case WM_SIZE:
{
int newwid = LOWORD(lParam);
int newhgt = HIWORD(lParam);
if (newwid == 0 || newhgt == 0)
break;
if (newwid == gli_image_w && newhgt == gli_image_h)
break;
gli_image_w = newwid;
gli_image_h = newhgt;
gli_resize_mask(gli_image_w, gli_image_h);
gli_image_s = ((gli_image_w * 3 + 3) / 4) * 4;
if (gli_image_rgb)
free(gli_image_rgb);
gli_image_rgb = malloc(gli_image_s * gli_image_h);
gli_force_redraw = 1;
gli_windows_size_change();
break;
}
case WM_LBUTTONDOWN:
{
SetFocus(hwndview);
gli_input_handle_click(x, y);
return 0;
}
case WM_LBUTTONUP:
{
gli_copyselect = FALSE;
SetCursor(idc_arrow);
return 0;
}
case WM_MBUTTONDOWN:
case WM_RBUTTONDOWN:
{
SetFocus(hwndview);
return 0;
}
case WM_MOUSEWHEEL:
{
if (GET_WHEEL_DELTA_WPARAM(wParam) > 0)
gli_input_handle_key(keycode_MouseWheelUp);
else
gli_input_handle_key(keycode_MouseWheelDown);
}
case WM_CAPTURECHANGED:
{
gli_copyselect = FALSE;
return 0;
}
case WM_MOUSEMOVE:
{
/* catch and release */
RECT rect;
POINT pt = { x, y };
GetClientRect(hwnd, &rect);
int hover = PtInRect(&rect, pt);
if (!hover) {
if (GetCapture() == hwnd)
ReleaseCapture();
} else {
if (GetCapture() != hwnd ) {
SetCapture(hwnd);
}
if (gli_copyselect) {
SetCursor(idc_ibeam);
gli_move_selection(x, y);
} else {
if (gli_get_hyperlink(x, y)) {
SetCursor(idc_hand);
} else {
SetCursor(idc_arrow);
}
}
}
return 0;
}
case WM_COPY:
{
gli_copyselect = FALSE;
SetCursor(idc_arrow);
winclipsend();
return 0;
}
case WM_PASTE:
{
SetFocus(hwndview);
winclipreceive();
return 0;
}
case WM_KEYDOWN:
switch (wParam)
{
case VK_PRIOR: gli_input_handle_key(keycode_PageUp); break;
case VK_NEXT: gli_input_handle_key(keycode_PageDown); break;
case VK_HOME: gli_input_handle_key(keycode_Home); break;
case VK_END: gli_input_handle_key(keycode_End); break;
case VK_LEFT: gli_input_handle_key(keycode_Left); break;
case VK_RIGHT: gli_input_handle_key(keycode_Right); break;
case VK_UP: gli_input_handle_key(keycode_Up); break;
case VK_DOWN: gli_input_handle_key(keycode_Down); break;
case VK_ESCAPE: gli_input_handle_key(keycode_Escape); break;
case VK_DELETE: gli_input_handle_key(keycode_Erase); break;
case VK_F1: gli_input_handle_key(keycode_Func1); break;
case VK_F2: gli_input_handle_key(keycode_Func2); break;
case VK_F3: gli_input_handle_key(keycode_Func3); break;
case VK_F4: gli_input_handle_key(keycode_Func4); break;
case VK_F5: gli_input_handle_key(keycode_Func5); break;
case VK_F6: gli_input_handle_key(keycode_Func6); break;
case VK_F7: gli_input_handle_key(keycode_Func7); break;
case VK_F8: gli_input_handle_key(keycode_Func8); break;
case VK_F9: gli_input_handle_key(keycode_Func9); break;
case VK_F10: gli_input_handle_key(keycode_Func10); break;
case VK_F11: gli_input_handle_key(keycode_Func11); break;
case VK_F12: gli_input_handle_key(keycode_Func12); break;
}
return 0;
/* unicode encoded chars, including escape, backspace etc... */
case WM_UNICHAR:
key = wParam;
if (key == UNICODE_NOCHAR)
return 1; /* yes, we like WM_UNICHAR */
if (key == '\r' || key == '\n')
gli_input_handle_key(keycode_Return);
else if (key == '\b')
gli_input_handle_key(keycode_Delete);
else if (key == '\t')
gli_input_handle_key(keycode_Tab);
else if (key == 0x03 || key == 0x18)
SendMessage(hwndview, WM_COPY, 0, 0);
else if (key == 0x16)
SendMessage(hwndview, WM_PASTE, 0, 0);
else if (key != 27)
gli_input_handle_key(key);
return 0;
case WM_CHAR:
key = wParam;
if (key == '\r' || key == '\n')
gli_input_handle_key(keycode_Return);
else if (key == '\b')
gli_input_handle_key(keycode_Delete);
else if (key == '\t')
gli_input_handle_key(keycode_Tab);
else if (key == 0x03 || key == 0x18)
SendMessage(hwndview, WM_COPY, 0, 0);
else if (key == 0x16)
SendMessage(hwndview, WM_PASTE, 0, 0);
else if (key != 27) {
/* translate from ANSI code page to Unicode */
char ansich = (char)key;
wchar_t widebuf[2];
int res = MultiByteToWideChar(CP_ACP, 0, &ansich, 1, widebuf, 2);
if (res) {
if (Uni_IsSurrogate1(widebuf[0]))
key = Uni_SurrogateToUTF32(widebuf[0], widebuf[1]);
else
key = widebuf[0];
gli_input_handle_key(key);
}
}
return 0;
}
/* Pass on unhandled events to Windows */
return DefWindowProc(hwnd, message, wParam, lParam);
}
void glk_window_close(window_t *win, stream_result_t *result)
{
if (!win) {
gli_strict_warning("window_close: invalid ref");
return;
}
if (win == gli_rootwin || win->parent == NULL) {
/* close the root window, which means all windows. */
gli_rootwin = 0;
/* begin (simpler) closation */
gli_stream_fill_result(win->str, result);
gli_window_close(win, TRUE);
/* redraw everything */
gli_windows_redraw();
}
else {
/* have to jigger parent */
grect_t box;
window_t *pairwin, *sibwin, *grandparwin, *wx;
window_pair_t *dpairwin, *dgrandparwin, *dwx;
int keydamage_flag;
pairwin = win->parent;
dpairwin = pairwin->data;
if (win == dpairwin->child1) {
sibwin = dpairwin->child2;
}
else if (win == dpairwin->child2) {
sibwin = dpairwin->child1;
}
else {
gli_strict_warning("window_close: window tree is corrupted");
return;
}
box = pairwin->bbox;
grandparwin = pairwin->parent;
if (!grandparwin) {
gli_rootwin = sibwin;
sibwin->parent = NULL;
}
else {
dgrandparwin = grandparwin->data;
if (dgrandparwin->child1 == pairwin)
dgrandparwin->child1 = sibwin;
else
dgrandparwin->child2 = sibwin;
sibwin->parent = grandparwin;
}
/* Begin closation */
gli_stream_fill_result(win->str, result);
/* Close the child window (and descendants), so that key-deletion can
crawl up the tree to the root window. */
gli_window_close(win, TRUE);
/* This probably isn't necessary, but the child *is* gone, so just
in case. */
if (win == dpairwin->child1) {
dpairwin->child1 = NULL;
}
else if (win == dpairwin->child2) {
dpairwin->child2 = NULL;
}
/* Now we can delete the parent pair. */
gli_window_close(pairwin, FALSE);
keydamage_flag = FALSE;
for (wx=sibwin; wx; wx=wx->parent) {
if (wx->type == wintype_Pair) {
window_pair_t *dwx = wx->data;
if (dwx->keydamage) {
keydamage_flag = TRUE;
dwx->keydamage = FALSE;
}
}
}
if (keydamage_flag) {
box = content_box;
gli_window_rearrange(gli_rootwin, &box);
gli_windows_redraw();
}
else {
gli_window_rearrange(sibwin, &box);
gli_window_redraw(sibwin);
}
}
}
winid_t glk_window_open(winid_t splitwin, glui32 method, glui32 size,
glui32 wintype, glui32 rock)
{
window_t *newwin, *pairwin, *oldparent;
window_pair_t *dpairwin;
grect_t box;
glui32 val;
if (!gli_rootwin) {
if (splitwin) {
gli_strict_warning("window_open: ref must be NULL");
return 0;
}
/* ignore method and size now */
oldparent = NULL;
box = content_box;
}
else {
if (!splitwin) {
gli_strict_warning("window_open: ref must not be NULL");
return 0;
}
val = (method & winmethod_DivisionMask);
if (val != winmethod_Fixed && val != winmethod_Proportional) {
gli_strict_warning("window_open: invalid method (not fixed or proportional)");
return 0;
}
val = (method & winmethod_DirMask);
if (val != winmethod_Above && val != winmethod_Below
&& val != winmethod_Left && val != winmethod_Right) {
gli_strict_warning("window_open: invalid method (bad direction)");
return 0;
}
box = splitwin->bbox;
oldparent = splitwin->parent;
if (oldparent && oldparent->type != wintype_Pair) {
gli_strict_warning("window_open: parent window is not Pair");
return 0;
}
}
newwin = gli_new_window(wintype, rock);
if (!newwin) {
gli_strict_warning("window_open: unable to create window");
return 0;
}
switch (wintype) {
case wintype_Blank:
newwin->data = win_blank_create(newwin);
break;
case wintype_TextGrid:
newwin->data = win_textgrid_create(newwin);
break;
case wintype_TextBuffer:
newwin->data = win_textbuffer_create(newwin);
break;
case wintype_Pair:
gli_strict_warning("window_open: cannot open pair window directly");
gli_delete_window(newwin);
return 0;
default:
/* Unknown window type -- do not print a warning, just return 0
to indicate that it's not possible. */
gli_delete_window(newwin);
return 0;
}
if (!newwin->data) {
gli_strict_warning("window_open: unable to create window");
return 0;
}
if (!splitwin) {
gli_rootwin = newwin;
gli_window_rearrange(newwin, &box);
/* redraw everything, which is just the new first window */
gli_windows_redraw();
}
else {
/* create pairwin, with newwin as the key */
pairwin = gli_new_window(wintype_Pair, 0);
dpairwin = win_pair_create(pairwin, method, newwin, size);
pairwin->data = dpairwin;
dpairwin->child1 = splitwin;
dpairwin->child2 = newwin;
splitwin->parent = pairwin;
newwin->parent = pairwin;
pairwin->parent = oldparent;
if (oldparent) {
window_pair_t *dparentwin = oldparent->data;
if (dparentwin->child1 == splitwin)
dparentwin->child1 = pairwin;
else
dparentwin->child2 = pairwin;
}
else {
gli_rootwin = pairwin;
}
gli_window_rearrange(pairwin, &box);
/* redraw the new pairwin and all its contents */
gli_window_redraw(pairwin);
}
return newwin;
}
LRESULT CALLBACK
viewproc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
int x = (signed short) LOWORD(lParam);
int y = (signed short) HIWORD(lParam);
glui32 key;
switch (message)
{
case WM_ERASEBKGND:
return 1; // don't erase; we'll repaint it all
case WM_PAINT:
{
PAINTSTRUCT ps;
/* make sure we have a fresh bitmap */
gli_windows_redraw();
/* and blit it to the screen */
hdc = BeginPaint(hwnd, &ps);
winblit(ps.rcPaint);
hdc = NULL;
EndPaint(hwnd, &ps);
return 0;
}
case WM_SIZE:
{
int newwid = LOWORD(lParam);
int newhgt = HIWORD(lParam);
if (newwid == 0 || newhgt == 0)
break;
if (newwid == gli_image_w && newhgt == gli_image_h)
break;
gli_image_w = newwid;
gli_image_h = newhgt;
gli_image_s = ((gli_image_w * 3 + 3) / 4) * 4;
if (gli_image_rgb)
free(gli_image_rgb);
gli_image_rgb = malloc(gli_image_s * gli_image_h);
gli_force_redraw = 1;
gli_windows_size_change();
break;
}
case WM_LBUTTONDOWN:
gli_input_handle_click(x, y);
return 0;
case WM_KEYDOWN:
switch (wParam)
{
case VK_PRIOR: gli_input_handle_key(keycode_PageUp); break;
case VK_NEXT: gli_input_handle_key(keycode_PageDown); break;
case VK_HOME: gli_input_handle_key(keycode_Home); break;
case VK_END: gli_input_handle_key(keycode_End); break;
case VK_LEFT: gli_input_handle_key(keycode_Left); break;
case VK_RIGHT: gli_input_handle_key(keycode_Right); break;
case VK_UP: gli_input_handle_key(keycode_Up); break;
case VK_DOWN: gli_input_handle_key(keycode_Down); break;
case VK_ESCAPE: gli_input_handle_key(keycode_Escape); break;
case VK_F1: gli_input_handle_key(keycode_Func1); break;
case VK_F2: gli_input_handle_key(keycode_Func2); break;
case VK_F3: gli_input_handle_key(keycode_Func3); break;
case VK_F4: gli_input_handle_key(keycode_Func4); break;
case VK_F5: gli_input_handle_key(keycode_Func5); break;
case VK_F6: gli_input_handle_key(keycode_Func6); break;
case VK_F7: gli_input_handle_key(keycode_Func7); break;
case VK_F8: gli_input_handle_key(keycode_Func8); break;
case VK_F9: gli_input_handle_key(keycode_Func9); break;
case VK_F10: gli_input_handle_key(keycode_Func10); break;
case VK_F11: gli_input_handle_key(keycode_Func11); break;
case VK_F12: gli_input_handle_key(keycode_Func12); break;
}
return 0;
/* unicode encoded chars, including escape, backspace etc... */
case WM_UNICHAR:
key = wParam;
if (key == UNICODE_NOCHAR)
return 1; /* yes, we like WM_UNICHAR */
if (key == '\r' || key == '\n')
gli_input_handle_key(keycode_Return);
else if (key == '\b')
gli_input_handle_key(keycode_Delete);
else if (key == '\t')
gli_input_handle_key(keycode_Tab);
else if (key != 27)
gli_input_handle_key(key);
return 0;
case WM_CHAR:
key = wParam;
if (key == '\r' || key == '\n')
gli_input_handle_key(keycode_Return);
else if (key == '\b')
gli_input_handle_key(keycode_Delete);
else if (key == '\t')
gli_input_handle_key(keycode_Tab);
else if (key != 27) {
/* translate from ANSI code page to Unicode */
char ansich = (char)key;
wchar_t widebuf[2];
int res = MultiByteToWideChar(CP_ACP, 0, &ansich, 1, widebuf, 2);
if (res) {
if (Uni_IsSurrogate1(widebuf[0]))
key = Uni_SurrogateToUTF32(widebuf[0], widebuf[1]);
else
key = widebuf[0];
gli_input_handle_key(key);
}
}
return 0;
}
/* Pass on unhandled events to Windows */
return DefWindowProc(hwnd, message, wParam, lParam);
}
