x = Pixel2Col (x);
y = Pixel2Row (y);
- if (x < 0 || x >= TermWin.ncol
- || y < 0 || y >= TermWin.nrow)
+ if (x < 0 || x >= ncol
+ || y < 0 || y >= nrow)
return;
for (;;)
{
- text_t t = screen.text[y + TermWin.saveLines - TermWin.view_start][x];
+ const line_t &l = save[y + saveLines - view_start];
+
+ text_t t = l.t[x];
if (t != NOCHAR || !x)
{
- iso14755_51 (screen.text[y + TermWin.saveLines - TermWin.view_start][x],
- screen.rend[y + TermWin.saveLines - TermWin.view_start][x]);
+ iso14755_51 (l.t[x], l.r[x]);
iso14755buf = ISO_14755_54;
break;
}
return;
#endif
- if (TermWin.saveLines)
+ if (saveLines)
{
#ifdef UNSHIFTED_SCROLLKEYS
if (!ctrl && !meta)
int lnsppg;
#ifdef PAGING_CONTEXT_LINES
- lnsppg = TermWin.nrow - PAGING_CONTEXT_LINES;
+ lnsppg = nrow - PAGING_CONTEXT_LINES;
#else
- lnsppg = TermWin.nrow * 4 / 5;
+ lnsppg = nrow * 4 / 5;
#endif
if (keysym == XK_Prior)
{
return; /* not mapped */
if (options & Opt_scrollTtyKeypress)
- if (TermWin.view_start)
+ if (view_start)
{
- TermWin.view_start = 0;
+ view_start = 0;
want_refresh = 1;
}
|| mouse_slip_wheel_speed < 0 ? scr_page (DN, -mouse_slip_wheel_speed)
: scr_page (UP, mouse_slip_wheel_speed))
{
- if (TermWin.view_start == TermWin.nscrolled ||
- TermWin.view_start == 0)
+ if (view_start == nscrolled ||
+ view_start == 0)
mouse_slip_wheel_speed = 0;
refresh_type |= SMOOTH_REFRESH;
void
rxvt_term::pointer_unblank ()
{
- XDefineCursor (display->display, TermWin.vt, TermWin_cursor);
+ XDefineCursor (display->display, vt, TermWin_cursor);
recolour_cursor ();
#ifdef POINTER_BLANK
if (! (options & Opt_pointerBlank))
return;
- XDefineCursor (display->display, TermWin.vt, display->blank_cursor);
+ XDefineCursor (display->display, vt, display->blank_cursor);
XFlush (display->display);
hidden_pointer = 1;
break;
case ConfigureNotify:
- if (ev.xconfigure.window == TermWin.parent[0])
+ if (ev.xconfigure.window == parent[0])
{
- int height, width;
-
- do
- { /* Wrap lots of configures into one */
- width = ev.xconfigure.width;
- height = ev.xconfigure.height;
- D_SIZE ((stderr, "Size: ConfigureNotify: %4d x %4d", width, height));
- }
- while (XCheckTypedWindowEvent (disp, ev.xconfigure.window, ConfigureNotify, &ev));
+ while (XCheckTypedWindowEvent (disp, ev.xconfigure.window, ConfigureNotify, &ev))
+ ;
- if (szHint.width != width || szHint.height != height)
+ if (szHint.width != ev.xconfigure.width || szHint.height != ev.xconfigure.height)
{
seen_resize = 1;
- resize_all_windows (width, height, 1);
+ resize_all_windows (ev.xconfigure.width, ev.xconfigure.height, 1);
}
#ifdef TRANSPARENT /* XXX: maybe not needed - leave in for now */
break;
case UnmapNotify:
- TermWin.mapped = 0;
+ mapped = 0;
#ifdef TEXT_BLINK
text_blink_ev.stop ();
#endif
break;
case MapNotify:
- TermWin.mapped = 1;
+ mapped = 1;
#ifdef TEXT_BLINK
text_blink_ev.start (NOW + TEXT_BLINK_INTERVAL);
#endif
case GraphicsExpose:
case Expose:
- if (ev.xany.window == TermWin.vt)
+ if (ev.xany.window == vt)
{
do
scr_expose (ev.xexpose.x, ev.xexpose.y,
ev.xexpose.width, ev.xexpose.height, False);
- while (XCheckTypedWindowEvent (disp, TermWin.vt, ev.xany.type, &ev));
+ while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev));
ev.xany.type = ev.xany.type == Expose ? GraphicsExpose : Expose;
- while (XCheckTypedWindowEvent (disp, TermWin.vt, ev.xany.type, &ev))
+ while (XCheckTypedWindowEvent (disp, vt, ev.xany.type, &ev))
scr_expose (ev.xexpose.x, ev.xexpose.y,
ev.xexpose.width, ev.xexpose.height, False);
#endif
#ifdef TRANSPARENT
- if (am_transparent && ev.xany.window == TermWin.parent[0])
+ if (am_transparent && ev.xany.window == parent[0])
XClearWindow (disp, ev.xany.window);
#endif
}
if ((priv_modes & PrivMode_mouse_report) && !bypass_keystate)
break;
- if (ev.xany.window == TermWin.vt)
+ if (ev.xany.window == vt)
{
if (ev.xbutton.state & (Button1Mask | Button3Mask))
{
- while (XCheckTypedWindowEvent (disp, TermWin.vt, MotionNotify, &ev))
+ while (XCheckTypedWindowEvent (disp, vt, MotionNotify, &ev))
;
- XQueryPointer (disp, TermWin.vt,
+ XQueryPointer (disp, vt,
&unused_root, &unused_child,
&unused_root_x, &unused_root_y,
&ev.xbutton.x, &ev.xbutton.y,
ev.xbutton.state & Button3Mask ? 2 : 0);
#ifdef SELECTION_SCROLLING
- if (ev.xbutton.y < TermWin.int_bwidth
- || Pixel2Row (ev.xbutton.y) > (TermWin.nrow-1))
+ if (ev.xbutton.y < int_bwidth
+ || Pixel2Row (ev.xbutton.y) > (nrow-1))
{
int dist;
selection_save_state = (ev.xbutton.state & Button3Mask) ? 2 : 0;
/* calc number of lines to scroll */
- if (ev.xbutton.y < TermWin.int_bwidth)
+ if (ev.xbutton.y < int_bwidth)
{
scroll_selection_dir = UP;
- dist = TermWin.int_bwidth - ev.xbutton.y;
+ dist = int_bwidth - ev.xbutton.y;
}
else
{
scroll_selection_dir = DN;
- dist = ev.xbutton.y - (TermWin.int_bwidth + TermWin.height);
+ dist = ev.xbutton.y - (int_bwidth + height);
}
scroll_selection_lines = Pixel2Height (dist)
void
rxvt_term::focus_in ()
{
- if (!TermWin.focus)
+ if (!focus)
{
- TermWin.focus = 1;
+ focus = 1;
want_refresh = 1;
#if USE_XIM
if (Input_Context != NULL)
void
rxvt_term::focus_out ()
{
- if (TermWin.focus)
+ if (focus)
{
- TermWin.focus = 0;
+ focus = 0;
want_refresh = 1;
#if ENABLE_FRILLS || ISO_14755
/*
* VT window processing of button press
*/
- if (ev.window == TermWin.vt)
+ if (ev.window == vt)
{
#if ISO_14755
// 5.4
{
if (scrollbar_above_slider (ev.y))
# ifdef RXVT_SCROLL_FULL
- scr_page (UP, TermWin.nrow - 1);
+ scr_page (UP, nrow - 1);
# else
- scr_page (UP, TermWin.nrow / 4);
+ scr_page (UP, nrow / 4);
# endif
else if (scrollbar_below_slider (ev.y))
# ifdef RXVT_SCROLL_FULL
- scr_page (DN, TermWin.nrow - 1);
+ scr_page (DN, nrow - 1);
# else
- scr_page (DN, TermWin.nrow / 4);
+ scr_page (DN, nrow / 4);
# endif
else
scrollBar.setMotion ();
else
{
scr_page ((ev.button == Button1 ? DN : UP),
- (TermWin.nrow
+ (nrow
* scrollbar_position (ev.y)
/ scrollbar_size ()));
}
sel_scroll_ev.stop();
#endif
- if (ev.window == TermWin.vt)
+ if (ev.window == vt)
{
#if ISO_14755
// 5.4
if (ev.state & ShiftMask)
i = 1;
else if (options & Opt_mouseWheelScrollPage)
- i = TermWin.nrow - 1;
+ i = nrow - 1;
else
i = 5;
if (ev.state & ControlMask)
{
mouse_slip_wheel_speed += v ? -1 : 1;
- if (mouse_slip_wheel_speed < -TermWin.nrow) mouse_slip_wheel_speed = -TermWin.nrow;
- if (mouse_slip_wheel_speed > +TermWin.nrow) mouse_slip_wheel_speed = +TermWin.nrow;
+ if (mouse_slip_wheel_speed < -nrow) mouse_slip_wheel_speed = -nrow;
+ if (mouse_slip_wheel_speed > +nrow) mouse_slip_wheel_speed = +nrow;
if (slip_wheel_ev.at < NOW)
slip_wheel_ev.at = NOW + SCROLLBAR_CONTINUOUS_DELAY;
XGetWindowAttributes (disp, display->root, &wrootattr);
rootdepth = wrootattr.depth;
- XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+ XGetWindowAttributes (disp, parent[0], &wattr);
if (rootdepth != wattr.depth)
{
if (am_transparent)
{
pchanged = 1;
- XSetWindowBackground (disp, TermWin.vt, pix_colors_focused[Color_bg]);
+ XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
am_transparent = am_pixmap_trans = 0;
}
GC gc;
XGCValues gcvalue;
- XTranslateCoordinates (disp, TermWin.parent[0], display->root,
+ XTranslateCoordinates (disp, parent[0], display->root,
0, 0, &sx, &sy, &cr);
nw = (unsigned int)szHint.width;
nh = (unsigned int)szHint.height;
if (am_transparent && am_pixmap_trans)
{
pchanged = 1;
- if (TermWin.pixmap != None)
+ if (pixmap != None)
{
- XFreePixmap (disp, TermWin.pixmap);
- TermWin.pixmap = None;
+ XFreePixmap (disp, pixmap);
+ pixmap = None;
}
}
}
else
{
- if (TermWin.pixmap != None)
- XFreePixmap (disp, TermWin.pixmap);
+ if (pixmap != None)
+ XFreePixmap (disp, pixmap);
#if TINTING
if (ISSET_PIXCOLOR (Color_tint))
}
#endif
- TermWin.pixmap = XCreatePixmap (disp, TermWin.vt,
+ pixmap = XCreatePixmap (disp, vt,
szHint.width, szHint.height, image->depth);
- gc = XCreateGC (disp, TermWin.vt, 0UL, &gcvalue);
- XPutImage (disp, TermWin.pixmap, gc, image, 0, 0,
+ gc = XCreateGC (disp, vt, 0UL, &gcvalue);
+ XPutImage (disp, pixmap, gc, image, 0, 0,
nx, ny, image->width, image->height);
XFreeGC (disp, gc);
XDestroyImage (image);
- XSetWindowBackgroundPixmap (disp, TermWin.parent[0], TermWin.pixmap);
- XClearWindow (disp, TermWin.parent[0]);
+ XSetWindowBackgroundPixmap (disp, parent[0], pixmap);
+ XClearWindow (disp, parent[0]);
if (!am_transparent || !am_pixmap_trans)
pchanged = 1;
}
if (am_pixmap_trans)
- XSetWindowBackgroundPixmap (disp, TermWin.vt, ParentRelative);
+ XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
else
{
unsigned int n;
/*
* InheritPixmap transparency
*/
- for (i = 1; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
+ for (i = 1; i < (int) (sizeof (parent) / sizeof (Window)); i++)
{
- oldp = TermWin.parent[i];
- XQueryTree (disp, TermWin.parent[i - 1], &root,
- &TermWin.parent[i], &list, &n);
+ oldp = parent[i];
+ XQueryTree (disp, parent[i - 1], &root,
+ &parent[i], &list, &n);
XFree (list);
- if (TermWin.parent[i] == display->root)
+ if (parent[i] == display->root)
{
if (oldp != None)
pchanged = 1;
break;
}
- if (oldp != TermWin.parent[i])
+ if (oldp != parent[i])
pchanged = 1;
}
{
for (; n < (unsigned int)i; n++)
{
- XGetWindowAttributes (disp, TermWin.parent[n], &wattr);
+ XGetWindowAttributes (disp, parent[n], &wattr);
if (wattr.depth != rootdepth || wattr.c_class == InputOnly)
{
- n = (int) (sizeof (TermWin.parent) / sizeof (Window)) + 1;
+ n = (int) (sizeof (parent) / sizeof (Window)) + 1;
break;
}
}
}
- if (n > (int) (sizeof (TermWin.parent) / sizeof (TermWin.parent[0])))
+ if (n > (int) (sizeof (parent) / sizeof (parent[0])))
{
- XSetWindowBackground (disp, TermWin.parent[0], pix_colors_focused[Color_border]);
- XSetWindowBackground (disp, TermWin.vt, pix_colors_focused[Color_bg]);
+ XSetWindowBackground (disp, parent[0], pix_colors_focused[Color_border]);
+ XSetWindowBackground (disp, vt, pix_colors_focused[Color_bg]);
am_transparent = 0;
/* XXX: also turn off Opt_transparent? */
}
#endif
for (n = 0; n < (unsigned int)i; n++)
{
- XSetWindowBackgroundPixmap (disp, TermWin.parent[n], ParentRelative);
- XClearWindow (disp, TermWin.parent[n]);
+ XSetWindowBackgroundPixmap (disp, parent[n], ParentRelative);
+ XClearWindow (disp, parent[n]);
}
- XSetWindowBackgroundPixmap (disp, TermWin.vt, ParentRelative);
+ XSetWindowBackgroundPixmap (disp, vt, ParentRelative);
am_transparent = 1;
}
- for (; i < (int) (sizeof (TermWin.parent) / sizeof (Window)); i++)
- TermWin.parent[i] = None;
+ for (; i < (int) (sizeof (parent) / sizeof (Window)); i++)
+ parent[i] = None;
}
if (scrollBar.win)
bool refreshnow = false;
int nlines = 0;
unicode_t *str = buf;
- unicode_t *eol = str + min (TermWin.ncol, UBUFSIZ);
+ unicode_t *eol = str + min (ncol, UBUFSIZ);
for (;;)
{
refresh_count++;
if (!(options & Opt_jumpScroll)
- || (refresh_count >= refresh_limit * (TermWin.nrow - 1)))
+ || (refresh_count >= refresh_limit * (nrow - 1)))
{
refreshnow = true;
ch = NOCHAR;
break;
}
- // scr_add_lines only works for nlines <= TermWin.nrow - 1.
- if (nlines >= TermWin.nrow - 1)
+ // scr_add_lines only works for nlines <= nrow - 1.
+ if (nlines >= nrow - 1)
{
scr_add_lines (buf, nlines, str - buf);
nlines = 0;
str = buf;
- eol = str + min (TermWin.ncol, UBUFSIZ);
+ eol = str + min (ncol, UBUFSIZ);
}
if (str >= eol)
break;
}
else
- eol = min (eol + TermWin.ncol, buf + UBUFSIZ);
+ eol = min (eol + ncol, buf + UBUFSIZ);
}
}
* commands
*/
case 1: /* deiconify window */
- XMapWindow (disp, TermWin.parent[0]);
+ XMapWindow (disp, parent[0]);
break;
case 2: /* iconify window */
- XIconifyWindow (disp, TermWin.parent[0], display->screen);
+ XIconifyWindow (disp, parent[0], display->screen);
break;
case 3: /* set position (pixels) */
- XMoveWindow (disp, TermWin.parent[0], args[1], args[2]);
+ XMoveWindow (disp, parent[0], args[1], args[2]);
break;
case 4: /* set size (pixels) */
set_widthheight ((unsigned int)args[2], (unsigned int)args[1]);
break;
case 5: /* raise window */
- XRaiseWindow (disp, TermWin.parent[0]);
+ XRaiseWindow (disp, parent[0]);
break;
case 6: /* lower window */
- XLowerWindow (disp, TermWin.parent[0]);
+ XLowerWindow (disp, parent[0]);
break;
case 7: /* refresh window */
scr_touch (true);
break;
case 8: /* set size (chars) */
- set_widthheight ((unsigned int) (args[2] * TermWin.fwidth),
- (unsigned int) (args[1] * TermWin.fheight));
+ set_widthheight ((unsigned int) (args[2] * fwidth),
+ (unsigned int) (args[1] * fheight));
break;
//case 9: NYI, TODO, restore maximized window or maximize window
default:
if (args[0] >= 24) /* set height (chars) */
- set_widthheight ((unsigned int)TermWin.width,
- (unsigned int) (args[1] * TermWin.fheight));
+ set_widthheight ((unsigned int)width,
+ (unsigned int) (args[1] * fheight));
break;
* reports - some output format copied from XTerm
*/
case 11: /* report window state */
- XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+ XGetWindowAttributes (disp, parent[0], &wattr);
tt_printf ("\033[%dt", wattr.map_state == IsViewable ? 1 : 2);
break;
case 13: /* report window position */
- XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
- XTranslateCoordinates (disp, TermWin.parent[0], wattr.root,
+ XGetWindowAttributes (disp, parent[0], &wattr);
+ XTranslateCoordinates (disp, parent[0], wattr.root,
-wattr.border_width, -wattr.border_width,
&x, &y, &wdummy);
tt_printf ("\033[3;%d;%dt", x, y);
break;
case 14: /* report window size (pixels) */
- XGetWindowAttributes (disp, TermWin.parent[0], &wattr);
+ XGetWindowAttributes (disp, parent[0], &wattr);
tt_printf ("\033[4;%d;%dt", wattr.height, wattr.width);
break;
case 18: /* report text area size (chars) */
- tt_printf ("\033[8;%d;%dt", TermWin.nrow, TermWin.ncol);
+ tt_printf ("\033[8;%d;%dt", nrow, ncol);
break;
case 19: /* report window size (chars) */
- tt_printf ("\033[9;%d;%dt", TermWin.nrow, TermWin.ncol);
+ tt_printf ("\033[9;%d;%dt", nrow, ncol);
break;
case 20: /* report icon label */
{
char *s;
- XGetIconName (disp, TermWin.parent[0], &s);
+ XGetIconName (disp, parent[0], &s);
tt_printf ("\033]L%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
XFree (s);
}
case 21: /* report window title */
{
char *s;
- XFetchName (disp, TermWin.parent[0], &s);
+ XFetchName (disp, parent[0], &s);
tt_printf ("\033]l%-.250s\234", (options & Opt_insecure) && s ? s : ""); /* 8bit ST */
XFree (s);
}
const char *str = "";
if (prop
- && XGetWindowProperty (disp, TermWin.parent[0],
+ && XGetWindowProperty (disp, parent[0],
prop, 0, 1<<16, 0, AnyPropertyType,
&actual_type, &actual_format,
&nitems, &bytes_after, &value) == Success
set_utf8_property (display->atom (str), eq + 1);
}
else
- XDeleteProperty (disp, TermWin.parent[0],
+ XDeleteProperty (disp, parent[0],
display->atom (str));
}
break;
#endif
if (query)
tt_printf ("\33]%d;%-.250s%c", saveop,
- (options & Opt_insecure) && TermWin.fontset[op - URxvt_font]->fontdesc
- ? TermWin.fontset[op - URxvt_font]->fontdesc : "",
+ (options & Opt_insecure) && fontset[op - URxvt_font]->fontdesc
+ ? fontset[op - URxvt_font]->fontdesc : "",
resp);
else
{
break;
case 3: /* 80/132 */
if (priv_modes & PrivMode_132OK)
- set_widthheight (((state ? 132 : 80) * TermWin.fwidth), TermWin.height);
+ set_widthheight (((state ? 132 : 80) * fwidth), height);
break;
case 4: /* smooth scrolling */
if (state)
#if ENABLE_STYLES
for (int i = RS_styleCount; --i; )
- if (TermWin.fontset[i] != TermWin.fontset[0])
- delete TermWin.fontset[i];
+ if (fontset[i] != fontset[0])
+ delete fontset[i];
#endif
- delete TermWin.fontset[0];
+ delete fontset[0];
if (display)
{
if (botShadowGC) XFreeGC (disp, botShadowGC);
if (scrollbarGC) XFreeGC (disp, scrollbarGC);
#endif
- if (TermWin.gc) XFreeGC (disp, TermWin.gc);
+ if (gc) XFreeGC (disp, gc);
#if defined(MENUBAR) && (MENUBAR_MAX > 1)
delete menuBar.drawable;
//if (menuBar.win)
// XDestroyWindow (disp, menuBar.win);
#endif
- delete TermWin.drawable;
+ delete drawable;
// destroy all windows
- if (TermWin.parent[0])
- XDestroyWindow (disp, TermWin.parent[0]);
+ if (parent[0])
+ XDestroyWindow (disp, parent[0]);
}
// TODO: free pixcolours, colours should become part of rxvt_display
}
#endif
- XMapWindow (disp, TermWin.vt);
- XMapWindow (disp, TermWin.parent[0]);
+ XMapWindow (disp, vt);
+ XMapWindow (disp, parent[0]);
set_colorfgbg ();
* if width/height are non-zero then override calculated width/height
*/
void
-rxvt_term::window_calc (unsigned int width, unsigned int height)
+rxvt_term::window_calc (unsigned int newwidth, unsigned int newheight)
{
short recalc_x, recalc_y;
int x, y, sb_w, mb_h, flags;
dDisp;
D_SIZE ((stderr, "< Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
- TermWin.ncol, TermWin.nrow, szHint.width,
- szHint.height));
+ ncol, nrow, szHint.width, szHint.height));
+
szHint.flags = PMinSize | PResizeInc | PBaseSize | PWinGravity;
szHint.win_gravity = NorthWestGravity;
/* szHint.min_aspect.x = szHint.min_aspect.y = 1; */
recalc_x = recalc_y = 0;
flags = 0;
+
if (!parsed_geometry)
{
parsed_geometry = 1;
+
if (rs[Rs_geometry])
flags = XParseGeometry (rs[Rs_geometry], &x, &y, &w, &h);
if (flags & WidthValue)
{
- TermWin.ncol = BOUND_POSITIVE_INT16 (w);
+ ncol = BOUND_POSITIVE_INT16 (w);
szHint.flags |= USSize;
}
if (flags & HeightValue)
{
- TermWin.nrow = BOUND_POSITIVE_INT16 (h);
+ nrow = BOUND_POSITIVE_INT16 (h);
szHint.flags |= USSize;
}
{
szHint.x = x;
szHint.flags |= USPosition;
+
if (flags & XNegative)
{
recalc_x = 1;
{
szHint.y = y;
szHint.flags |= USPosition;
+
if (flags & YNegative)
{
recalc_y = 1;
+
if (szHint.win_gravity == NorthEastGravity)
szHint.win_gravity = SouthEastGravity;
else
}
/* TODO: BOUNDS */
- TermWin.width = TermWin.ncol * TermWin.fwidth;
- TermWin.height = TermWin.nrow * TermWin.fheight;
- max_width = MAX_COLS * TermWin.fwidth;
- max_height = MAX_ROWS * TermWin.fheight;
+ width = ncol * fwidth;
+ height = nrow * fheight;
+ max_width = MAX_COLS * fwidth;
+ max_height = MAX_ROWS * fheight;
- szHint.base_width = szHint.base_height = 2 * TermWin.int_bwidth;
+ szHint.base_width = szHint.base_height = 2 * int_bwidth;
sb_w = mb_h = 0;
- window_vt_x = window_vt_y = TermWin.int_bwidth;
+ window_vt_x = window_vt_y = int_bwidth;
if (scrollbar_visible ())
{
window_vt_y += mb_h;
}
- szHint.width_inc = TermWin.fwidth;
- szHint.height_inc = TermWin.fheight;
+ szHint.width_inc = fwidth;
+ szHint.height_inc = fheight;
szHint.min_width = szHint.base_width + szHint.width_inc;
szHint.min_height = szHint.base_height + szHint.height_inc;
- if (width && width - szHint.base_width < max_width)
+ if (newwidth && newwidth - szHint.base_width < max_width)
{
- szHint.width = width;
- TermWin.width = width - szHint.base_width;
+ szHint.width = newwidth;
+ width = newwidth - szHint.base_width;
}
else
{
- MIN_IT (TermWin.width, max_width);
- szHint.width = szHint.base_width + TermWin.width;
+ MIN_IT (width, max_width);
+ szHint.width = szHint.base_width + width;
}
- if (height && height - szHint.base_height < max_height)
+ if (newheight && newheight - szHint.base_height < max_height)
{
- szHint.height = height;
- TermWin.height = height - szHint.base_height;
+ szHint.height = newheight;
+ height = newheight - szHint.base_height;
}
else
{
- MIN_IT (TermWin.height, max_height);
- szHint.height = szHint.base_height + TermWin.height;
+ MIN_IT (height, max_height);
+ szHint.height = szHint.base_height + height;
}
if (scrollbar_visible () && (options & Opt_scrollBar_right))
window_sb_x = szHint.width - sb_w;
if (recalc_x)
- szHint.x += (DisplayWidth (disp, display->screen)
- - szHint.width - 2 * TermWin.ext_bwidth);
+ szHint.x += DisplayWidth (disp, display->screen) - szHint.width - 2 * ext_bwidth;
if (recalc_y)
- szHint.y += (DisplayHeight (disp, display->screen)
- - szHint.height - 2 * TermWin.ext_bwidth);
+ szHint.y += DisplayHeight (disp, display->screen) - szHint.height - 2 * ext_bwidth;
- TermWin.ncol = TermWin.width / TermWin.fwidth;
- TermWin.nrow = TermWin.height / TermWin.fheight;
+ ncol = width / fwidth;
+ nrow = height / fheight;
D_SIZE ((stderr, "> Cols/Rows: %3d x %3d ; Width/Height: %4d x %4d",
- TermWin.ncol, TermWin.nrow, szHint.width,
+ ncol, nrow, szHint.width,
szHint.height));
return;
}
struct winsize ws;
- ws.ws_col = TermWin.ncol;
- ws.ws_row = TermWin.nrow;
- ws.ws_xpixel = TermWin.width;
- ws.ws_ypixel = TermWin.height;
+ ws.ws_col = ncol;
+ ws.ws_row = nrow;
+ ws.ws_xpixel = width;
+ ws.ws_ypixel = height;
(void)ioctl (pty.pty, TIOCSWINSZ, &ws);
#if 0
#if ENABLE_STYLES
for (int i = RS_styleCount; --i; )
- if (TermWin.fontset[i] != TermWin.fontset[0])
- delete TermWin.fontset[i];
+ if (fontset[i] != fontset[0])
+ delete fontset[i];
#endif
- delete TermWin.fontset[0];
- TermWin.fontset[0] = fs;
+ delete fontset[0];
+ fontset[0] = fs;
prop = (*fs)[1]->properties ();
- prop.height += TermWin.lineSpace;
+ prop.height += lineSpace;
fs->set_prop (prop);
- TermWin.fwidth = prop.width;
- TermWin.fheight = prop.height;
- TermWin.fweight = prop.weight;
- TermWin.fslant = prop.slant;
- TermWin.fbase = (*fs)[1]->ascent;
+ fwidth = prop.width;
+ fheight = prop.height;
+ fweight = prop.weight;
+ fslant = prop.slant;
+ fbase = (*fs)[1]->ascent;
for (int style = 1; style < 4; style++)
{
const char *res = rs[Rs_font + style];
if (res && !*res)
- TermWin.fontset[style] = TermWin.fontset[0];
+ fontset[style] = fontset[0];
else
{
- TermWin.fontset[style] = fs = new rxvt_fontset (this);
+ fontset[style] = fs = new rxvt_fontset (this);
rxvt_fontprop prop2 = prop;
if (res)
prop2.weight = prop2.slant = rxvt_fontprop::unset;
else
{
- res = TermWin.fontset[0]->fontdesc;
+ res = fontset[0]->fontdesc;
if (SET_STYLE (0, style) & RS_Bold) prop2.weight = rxvt_fontprop::bold;
if (SET_STYLE (0, style) & RS_Italic) prop2.slant = rxvt_fontprop::italic;
fs->set_prop (prop2);
}
#else
- TermWin.fontset[style] = TermWin.fontset[0];
+ fontset[style] = fontset[0];
#endif
}
- if (TermWin.parent[0])
+ if (parent[0])
{
resize_all_windows (0, 0, 0);
scr_remap_chars ();
void rxvt_term::set_string_property (Atom prop, const char *str, int len)
{
// TODO: SMART_WINDOW_TITLE
- XChangeProperty (display->display, TermWin.parent[0],
+ XChangeProperty (display->display, parent[0],
prop, XA_STRING, 8, PropModeReplace,
(const unsigned char *)str, len >= 0 ? len : strlen (str));
}
wchar_t *ws = rxvt_mbstowcs (str, len);
char *s = rxvt_wcstoutf8 (ws);
- XChangeProperty (display->display, TermWin.parent[0],
+ XChangeProperty (display->display, parent[0],
prop, xa[XA_UTF8_STRING], 8, PropModeReplace,
(const unsigned char *)s, strlen (s));
* - WINDOW RESIZING - *
* -------------------------------------------------------------------- */
void
-rxvt_term::resize_all_windows (unsigned int width, unsigned int height, int ignoreparent)
+rxvt_term::resize_all_windows (unsigned int newwidth, unsigned int newheight, int ignoreparent)
{
int fix_screen;
-#ifdef SMART_RESIZE
int old_width = szHint.width, old_height = szHint.height;
-#endif
dDisp;
- window_calc (width, height);
- XSetWMNormalHints (disp, TermWin.parent[0], &szHint);
+ window_calc (newwidth, newheight);
+ XSetWMNormalHints (disp, parent[0], &szHint);
if (!ignoreparent)
{
unsigned int unused_w1, unused_h1, unused_b1, unused_d1;
Window unused_cr;
- XTranslateCoordinates (disp, TermWin.parent[0], display->root,
+ XTranslateCoordinates (disp, parent[0], display->root,
0, 0, &x, &y, &unused_cr);
- XGetGeometry (disp, TermWin.parent[0], &unused_cr, &x1, &y1,
+ XGetGeometry (disp, parent[0], &unused_cr, &x1, &y1,
&unused_w1, &unused_h1, &unused_b1, &unused_d1);
/*
* if display->root isn't the parent window, a WM will probably have offset
else if (y == y1) /* exact center */
dy /= 2;
- XMoveResizeWindow (disp, TermWin.parent[0], x + dx, y + dy,
+ XMoveResizeWindow (disp, parent[0], x + dx, y + dy,
szHint.width, szHint.height);
#else
- XResizeWindow (disp, TermWin.parent[0], szHint.width, szHint.height);
+ XResizeWindow (disp, parent[0], szHint.width, szHint.height);
#endif
}
- fix_screen = TermWin.ncol != prev_ncol || TermWin.nrow != prev_nrow;
+ fix_screen = ncol != prev_ncol || nrow != prev_nrow;
- if (fix_screen || width != old_width || height != old_height)
+ if (fix_screen || newwidth != old_width || newheight != old_height)
{
if (scrollbar_visible ())
{
window_vt_x, 0,
TermWin_TotalWidth (), menuBar_TotalHeight ());
- XMoveResizeWindow (disp, TermWin.vt,
+ XMoveResizeWindow (disp, vt,
window_vt_x, window_vt_y,
TermWin_TotalWidth (), TermWin_TotalHeight ());
/* scr_reset only works on the primary screen */
if (old_height) /* this is not the first time through */
{
- unsigned int ncol = TermWin.ncol;
- TermWin.ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
+ unsigned int ocol = ncol;
+ ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
curr_screen = scr_change_screen (PRIMARY);
- TermWin.ncol = ncol;
+ ncol = ocol;
}
scr_reset ();
if (curr_screen >= 0) /* this is not the first time through */
{
scr_change_screen (curr_screen);
- selection_check (old_ncol != TermWin.ncol ? 4 : 0);
+ selection_check (old_ncol != ncol ? 4 : 0);
}
}
old_height = szHint.height;
#ifdef XPM_BACKGROUND
- if (TermWin.pixmap)
+ if (pixmap)
scr_touch (false);
#endif
* good for toggling 80/132 columns
*/
void
-rxvt_term::set_widthheight (unsigned int width, unsigned int height)
+rxvt_term::set_widthheight (unsigned int newwidth, unsigned int newheight)
{
XWindowAttributes wattr;
- if (width == 0 || height == 0)
+ if (newwidth == 0 || newheight == 0)
{
XGetWindowAttributes (display->display, display->root, &wattr);
- if (width == 0)
- width = wattr.width - szHint.base_width;
- if (height == 0)
- height = wattr.height - szHint.base_height;
+ if (newwidth == 0)
+ newwidth = wattr.width - szHint.base_width;
+ if (newheight == 0)
+ newheight = wattr.height - szHint.base_height;
}
- if (width != TermWin.width || height != TermWin.height)
+ if (newwidth != width || newheight != height)
{
- width += szHint.base_width;
- height += szHint.base_height;
- resize_all_windows (width, height, 0);
+ newwidth += szHint.base_width;
+ newheight += szHint.base_height;
+ resize_all_windows (newwidth, newheight, 0);
}
}
rxvt_term::im_set_size (XRectangle &size)
{
// the int_bwidth terms make no sense to me
- size.x = TermWin.int_bwidth;
- size.y = TermWin.int_bwidth;
- size.width = Width2Pixel (TermWin.ncol) + TermWin.int_bwidth;
- size.height = Height2Pixel (TermWin.nrow) + TermWin.int_bwidth;
+ size.x = int_bwidth;
+ size.y = int_bwidth;
+ size.width = Width2Pixel (ncol) + int_bwidth;
+ size.height = Height2Pixel (nrow) + int_bwidth;
}
void
{
preedit_rect.x = needed_rect.width;
preedit_rect.y = 0;
- preedit_rect.width = Width2Pixel (TermWin.ncol) - needed_rect.width + 1;
- preedit_rect.height = TermWin.fheight;
+ preedit_rect.width = Width2Pixel (ncol) - needed_rect.width + 1;
+ preedit_rect.height = fheight;
status_rect.x = 0;
status_rect.y = 0;
- status_rect.width = needed_rect.width ? needed_rect.width : Width2Pixel (TermWin.ncol) + 1;
- status_rect.height = TermWin.fheight;
+ status_rect.width = needed_rect.width ? needed_rect.width : Width2Pixel (ncol) + 1;
+ status_rect.height = fheight;
}
/* Checking whether input method is running. */
XVaNestedList preedit_attr;
if (!Input_Context
- || !TermWin.focus
+ || !focus
|| !(input_style & XIMPreeditPosition))
return;
"-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
"-*-*-*-R-*-*-%d-*-*-*-*-*-*,"
"*",
- TermWin.fheight,
- TermWin.fheight + 1, TermWin.fheight - 1,
- TermWin.fheight - 2, TermWin.fheight + 2);
+ fheight,
+ fheight + 1, fheight - 1,
+ fheight - 2, fheight + 2);
fs = XCreateFontSet (display->display, rs[Rs_imFont] ? rs[Rs_imFont] : pat,
&missing_charset_list, &missing_charset_count, &def_string);
Input_Context = XCreateIC (xim,
XNInputStyle, input_style,
- XNClientWindow, TermWin.vt,
- XNFocusWindow, TermWin.parent[0],
+ XNClientWindow, vt,
+ XNFocusWindow, parent[0],
preedit_attr ? XNPreeditAttributes : NULL,
preedit_attr,
status_attr ? XNStatusAttributes : NULL,
XVaNestedList preedit_attr, status_attr;
if (!Input_Context
- || !TermWin.focus
+ || !focus
|| !(input_style & XIMPreeditArea)
|| !IMisRunning ())
return;
* ------------------------------------------------------------------------- */
#define ZERO_SCROLLBACK() \
if (options & Opt_scrollTtyOutput) \
- TermWin.view_start = 0
+ view_start = 0
#define CLEAR_SELECTION() \
selection.beg.row = selection.beg.col \
= selection.end.row = selection.end.col = 0
* CLEAR_CHARS: clear <num> chars starting from pixel position <x,y>
* ERASE_ROWS : set <num> rows starting from row <row> to the foreground colour
*/
-#define drawBuffer TermWin.vt
+#define drawBuffer vt
#define CLEAR_ROWS(row, num) \
- if (TermWin.mapped) \
+ if (mapped) \
XClearArea (display->display, drawBuffer, 0, \
- Row2Pixel (row), (unsigned int)TermWin.width, \
+ Row2Pixel (row), (unsigned int)width, \
(unsigned int)Height2Pixel (num), False)
#define CLEAR_CHARS(x, y, num) \
- if (TermWin.mapped) \
+ if (mapped) \
XClearArea (display->display, drawBuffer, x, y, \
(unsigned int)Width2Pixel (num), \
(unsigned int)Height2Pixel (1), False)
#define ERASE_ROWS(row, num) \
- XFillRectangle (display->display, drawBuffer, TermWin.gc, \
+ XFillRectangle (display->display, drawBuffer, gc, \
0, Row2Pixel (row), \
- (unsigned int)TermWin.width, \
+ (unsigned int)width, \
(unsigned int)Height2Pixel (num))
/* ------------------------------------------------------------------------- *
/* Fill part/all of a line with blanks. */
void
-rxvt_term::scr_blank_line (text_t *et, rend_t *er, unsigned int width, rend_t efs)
+rxvt_term::scr_blank_line (line_t &l, unsigned int col, unsigned int width, rend_t efs)
{
efs &= ~RS_baseattrMask;
efs = SET_FONT (efs, FONTSET (efs)->find_font (' '));
+ text_t *et = l.t + col;
+ rend_t *er = l.r + col;
+
while (width--)
{
*et++ = ' ';
/* ------------------------------------------------------------------------- */
/* Fill a full line with blanks - make sure it is allocated first */
void
-rxvt_term::scr_blank_screen_mem (text_t **tp, rend_t **rp, unsigned int row, rend_t efs)
+rxvt_term::scr_blank_screen_mem (line_t &l, rend_t efs)
{
-#ifdef DEBUG_STRICT
- assert ((tp[row] && rp[row]) || (tp[row] == NULL && rp[row] == NULL));
-#endif
- if (tp[row] == NULL)
- {
- tp[row] = (text_t *)talloc->alloc ();
- rp[row] = (rend_t *)ralloc->alloc ();
- }
+ if (!l.t)
+ lalloc (l);
- scr_blank_line (tp[row], rp[row], TermWin.ncol, efs);
+ scr_blank_line (l, 0, ncol, efs);
}
/* ------------------------------------------------------------------------- *
void
rxvt_term::scr_reset ()
{
- unsigned int ncol, nrow, total_rows, prev_total_rows;
unsigned int p, q;
int k;
- rend_t setrstyle;
#if ENABLE_OVERLAY
scr_overlay_off ();
#endif
- TermWin.view_start = 0;
+ view_start = 0;
num_scr = 0;
- if (TermWin.ncol == 0)
- TermWin.ncol = 80;
-
- if (TermWin.nrow == 0)
- TermWin.nrow = 24;
+ if (ncol == 0)
+ ncol = 80;
- ncol = TermWin.ncol;
- nrow = TermWin.nrow;
+ if (nrow == 0)
+ nrow = 24;
if (ncol == prev_ncol && nrow == prev_nrow)
return;
// we need at least two lines for wrapping to work correctly
- if (nrow + TermWin.saveLines < 2)
+ if (nrow + saveLines < 2)
{
- TermWin.saveLines++;
+ saveLines++;
prev_nrow--;
- TermWin.nscrolled++;
+ nscrolled++;
}
want_refresh = 1;
- prev_total_rows = prev_nrow + TermWin.saveLines;
- total_rows = nrow + TermWin.saveLines;
+ int prev_total_rows = prev_nrow + saveLines;
+ int total_rows = nrow + saveLines;
screen.tscroll = 0;
screen.bscroll = nrow - 1;
- if (!talloc)
- {
- talloc = new rxvt_salloc (ncol * sizeof (text_t));
- ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
- }
-
- if (!screen.text)
+ if (!save)
{
/*
* first time called so just malloc everything: don't rely on realloc
* Note: this is still needed so that all the scrollback lines are NULL
*/
- screen.text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
- buf_text = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
- drawn_text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
- swap.text = (text_t **)rxvt_calloc (nrow, sizeof (text_t *));
+ nscrolled = 0; /* no saved lines */
+ term_start = 0;
+ nsaved = 0;
- screen.tlen = (int16_t *)rxvt_calloc (total_rows, sizeof (int16_t));
- swap.tlen = (int16_t *)rxvt_calloc (nrow, sizeof (int16_t));
+ talloc = new rxvt_salloc (ncol * sizeof (text_t));
+ ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
+
+ save = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
+ buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
+ drawn = (line_t *)rxvt_calloc (nrow, sizeof (line_t));
+ swap_save = (line_t *)rxvt_calloc (nrow, sizeof (line_t));
+
+ screen.line = (line_t **)rxvt_calloc (nrow, sizeof (line_t *));
- screen.rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
- buf_rend = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
- drawn_rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
- swap.rend = (rend_t **)rxvt_calloc (nrow, sizeof (rend_t *));
+ scr_update_term ();
- for (p = 0; p < nrow; p++)
+ for (p = nrow; p--; )
{
- q = p + TermWin.saveLines;
- scr_blank_screen_mem (screen.text, screen.rend, q, DEFAULT_RSTYLE);
- scr_blank_screen_mem (swap.text, swap.rend, p, DEFAULT_RSTYLE);
- screen.tlen[q] = swap.tlen[p] = 0;
- scr_blank_screen_mem (drawn_text, drawn_rend, p, DEFAULT_RSTYLE);
+ scr_blank_screen_mem (*screen.line[p], DEFAULT_RSTYLE);
+ scr_blank_screen_mem (swap_save[p], DEFAULT_RSTYLE);
+ scr_blank_screen_mem (drawn[p], DEFAULT_RSTYLE);
}
memset (charsets, 'B', sizeof (charsets));
- TermWin.nscrolled = 0; /* no saved lines */
rstyle = DEFAULT_RSTYLE;
screen.flags = Screen_DefaultFlags;
screen.cur.row = screen.cur.col = 0;
/*
* add or delete rows as appropriate
*/
- setrstyle = DEFAULT_RSTYLE;
+
+ rxvt_salloc *old_ta;
+ rxvt_salloc *old_ra;
if (nrow < prev_nrow)
{
/* delete rows */
- k = min (TermWin.nscrolled, prev_nrow - nrow);
+ k = min (nscrolled, prev_nrow - nrow);
// k = max (0, - ( (nrow - 1) - r->screen.cur.row)); // mmc's http://maruska.dyndns.org/wiki/scrolling-bug //make configurable? //D TODO
scr_scroll_text (0, (int)prev_nrow - 1, k, 1);
for (p = nrow; p < prev_nrow; p++)
{
- q = p + TermWin.saveLines;
-
- if (screen.text[q])
- {
-#ifdef DEBUG_STRICT
- assert (screen.rend[q]);
-#endif
- talloc->free (screen.text[q]);
- ralloc->free (screen.rend[q]);
- }
-
- if (swap.text[p])
- {
-#ifdef DEBUG_STRICT
- assert (swap.rend[p]);
-#endif
- talloc->free (swap.text[p]);
- ralloc->free (swap.rend[p]);
- }
-
-#ifdef DEBUG_STRICT
- assert (drawn_text[p] && drawn_rend[p]);
-#endif
- talloc->free (drawn_text[p]);
- ralloc->free (drawn_rend[p]);
+ lfree (save[p + saveLines]);
+ lfree (swap_save[p]);
+ lfree (drawn[p]);
}
/* we have fewer rows so fix up cursor position */
/* add rows */
scr_reset_realloc (); /* realloc _first_ */
- TermWin.ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
+ int ocol = ncol;
+ ncol = prev_ncol; // save b/c scr_blank_screen_mem uses this
- k = min (TermWin.nscrolled, nrow - prev_nrow);
+ k = min (nscrolled, nrow - prev_nrow);
for (p = prev_total_rows; p < total_rows; p++)
- {
- screen.tlen[p] = 0;
- screen.text[p] = NULL;
- screen.rend[p] = NULL;
- }
+ save[p].clear ();
for (p = prev_total_rows; p < total_rows - k; p++)
- scr_blank_screen_mem (screen.text, screen.rend, p, setrstyle);
+ scr_blank_screen_mem (save[p], DEFAULT_RSTYLE);
+
+ scr_update_term ();
for (p = prev_nrow; p < nrow; p++)
{
- swap.tlen[p] = 0;
- swap.text[p] = NULL;
- swap.rend[p] = NULL;
- drawn_text[p] = NULL;
- drawn_rend[p] = NULL;
- scr_blank_screen_mem (swap.text, swap.rend, p, setrstyle);
- scr_blank_screen_mem (drawn_text, drawn_rend, p, setrstyle);
+ swap_save[p].clear (); scr_blank_screen_mem (swap_save[p], DEFAULT_RSTYLE);
+ drawn[p].clear (); scr_blank_screen_mem (drawn[p], DEFAULT_RSTYLE);
}
if (k > 0)
scr_scroll_text (0, (int)nrow - 1, -k, 1);
screen.cur.row += k;
screen.s_cur.row += k;
- TermWin.nscrolled -= k;
+ nscrolled -= k;
}
#ifdef DEBUG_STRICT
- assert (screen.cur.row < TermWin.nrow);
+ assert (screen.cur.row < nrow);
#else /* drive with your eyes closed */
MIN_IT (screen.cur.row, nrow - 1);
#endif
- TermWin.ncol = ncol; // save b/c scr_blank_screen_mem uses this
+ ncol = ocol; // save b/c scr_blank_screen_mem uses this
}
/* resize columns */
if (ncol != prev_ncol)
{
- rxvt_salloc *ta = new rxvt_salloc (ncol * sizeof (text_t));
- rxvt_salloc *ra = new rxvt_salloc (ncol * sizeof (rend_t));
+ old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t));
+ old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
- for (p = 0; p < total_rows; p++)
+ for (p = total_rows; p--; )
+ lresize (save[p]);
+
+ for (p = nrow; p--; )
{
- if (screen.text[p])
- {
- screen.text[p] = (text_t *)ta->alloc (screen.text[p], prev_ncol * sizeof (text_t));
- screen.rend[p] = (rend_t *)ra->alloc (screen.rend[p], prev_ncol * sizeof (rend_t));
+ lresize (drawn[p]);
+ lresize (swap_save[p]);
+ }
- MIN_IT (screen.tlen[p], (int16_t)ncol);
+ MIN_IT (screen.cur.col, (int16_t)ncol - 1);
- if (ncol > prev_ncol)
- scr_blank_line (&screen.text[p][prev_ncol],
- &screen.rend[p][prev_ncol],
- ncol - prev_ncol, setrstyle);
- }
- }
+ delete old_ta;
+ delete old_ra;
+ }
+
+#if 0
+ // re-wrap lines, this is rather ugly, possibly because I am too dumb
+ // to come up with a lean and mean algorithm.
+ rxvt_salloc *ta = new rxvt_salloc (ncol * sizeof (text_t));
+ rxvt_salloc *ra = new rxvt_salloc (ncol * sizeof (rend_t));
+
+ text_t **tp = (text_t **)rxvt_calloc (total_rows, sizeof (text_t *));
+ rend_t **rp = (rend_t **)rxvt_calloc (total_rows, sizeof (rend_t *));
+ tlen_t *tl = (tlen_t *) rxvt_calloc (total_rows, sizeof (tlen_t));
- for (p = 0; p < nrow; p++)
+ for (p = 0; p < prev_total_rows; p++) printf ("P %p %d\n", save[p].t, save[p].l);//D
+
+ p = prev_total_rows;
+ q = total_rows;
+
+ while (p > 0 && q > 0)
+ {
+ --p;
+
+ printf ("pq %d:%d\n", p, q);
+ if (save[p].t)
{
- drawn_text[p] = (text_t *)ta->alloc (drawn_text[p], prev_ncol * sizeof (text_t));
- drawn_rend[p] = (rend_t *)ra->alloc (drawn_rend[p], prev_ncol * sizeof (rend_t));
+ int llen = save[p].l;
+
+ assert (llen >= 0);
- if (ncol > prev_ncol)
- scr_blank_line (&drawn_text[p][prev_ncol],
- &drawn_rend[p][prev_ncol],
- ncol - prev_ncol, setrstyle);
+ while (p && save[p - 1].l < 0)
+ {
+ --p;
+ llen += prev_ncol;
+ }
+
+ int qlines = llen / ncol + 1;
+ int lofs = 0;
- if (swap.text[p])
+ q -= qlines;
+
+ int qrow = q;
+
+ printf ("QL %d llen %d\n", qlines, llen);//D
+ for (; qlines--; qrow++)
{
- swap.text[p] = (text_t *)ta->alloc (swap.text[p], prev_ncol * sizeof (text_t));
- swap.rend[p] = (rend_t *)ra->alloc (swap.rend[p], prev_ncol * sizeof (rend_t));
+ if (qrow >= 0)
+ {
+ tp [qrow] = (text_t *)ta->alloc ();
+ rp [qrow] = (rend_t *)ra->alloc ();
+ tl [qrow] = -1;
- MIN_IT (swap.tlen[p], (int16_t)ncol);
+ int qcol = 0;
- if (ncol > prev_ncol)
- scr_blank_line (&swap.text[p][prev_ncol],
- &swap.rend[p][prev_ncol],
- ncol - prev_ncol, setrstyle);
- }
+ for (;;)
+ {
+ int prow = lofs / prev_ncol + p;
+ int pcol = lofs % prev_ncol;
- }
+ int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
- MIN_IT (screen.cur.col, (int16_t)ncol - 1);
+ printf ("q %d lofs %d>%d len %d pq %d:%d p %d:%d q :%d\n", q, llen, lofs, len, prev_ncol, ncol, prow, pcol, qcol);
+
+ if (len <= 0)
+ {
+ tl [qrow] = qcol;
+
+ TODO
+ scr_blank_line (tp [qrow] + qcol, rp [qrow] + qcol,
+ ncol - qcol, DEFAULT_RSTYLE);
+
+ break;
+ }
- delete talloc; talloc = ta;
- delete ralloc; ralloc = ra;
+ assert (lofs < 1000);
+
+ memcpy (tp [qrow] + qcol, save[prow].t + pcol, len * sizeof (text_t));
+ memcpy (rp [qrow] + qcol, save[prow].r + pcol, len * sizeof (rend_t));
+
+ lofs += len;
+ qcol += len;
+
+ if (qcol == ncol)
+ break;
+ }
+ }
+ else
+ lofs += ncol;
+ }
+ }
}
+ free (screen.text); screen.text = tp;
+ free (screen.rend); screen.rend = rp;
+ free (screen.tlen); screen.tlen = tl;
+
+ for (p = 0; p < total_rows; p++) printf ("P %p %d\n", save[p].t, save[p].l);//D
+#endif
+
if (tabs)
free (tabs);
}
void
rxvt_term::scr_reset_realloc ()
{
- unsigned int total_rows, nrow;
-
- nrow = TermWin.nrow;
- total_rows = nrow + TermWin.saveLines;
- /* *INDENT-OFF* */
- screen.text = (text_t **)rxvt_realloc (screen.text, total_rows * sizeof (text_t *));
- buf_text = (text_t **)rxvt_realloc (buf_text , total_rows * sizeof (text_t *));
- drawn_text = (text_t **)rxvt_realloc (drawn_text , nrow * sizeof (text_t *));
- swap.text = (text_t **)rxvt_realloc (swap.text , nrow * sizeof (text_t *));
+ unsigned int total_rows = nrow + saveLines;
- screen.tlen = (int16_t *)rxvt_realloc (screen.tlen, total_rows * sizeof (int16_t));
- swap.tlen = (int16_t *)rxvt_realloc (swap.tlen , total_rows * sizeof (int16_t));
-
- screen.rend = (rend_t **)rxvt_realloc (screen.rend, total_rows * sizeof (rend_t *));
- buf_rend = (rend_t **)rxvt_realloc (buf_rend , total_rows * sizeof (rend_t *));
- drawn_rend = (rend_t **)rxvt_realloc (drawn_rend , nrow * sizeof (rend_t *));
- swap.rend = (rend_t **)rxvt_realloc (swap.rend , nrow * sizeof (rend_t *));
- /* *INDENT-ON* */
+ screen.line = (line_t **)rxvt_realloc (screen.line, nrow * sizeof (line_t *));
+ swap_save = (line_t *) rxvt_realloc (swap_save , nrow * sizeof (line_t));
+ drawn = (line_t *) rxvt_realloc (drawn , nrow * sizeof (line_t));
+ save = (line_t *) rxvt_realloc (save , total_rows * sizeof (line_t));
+ buf = (line_t *) rxvt_realloc (buf , total_rows * sizeof (line_t));
}
/* ------------------------------------------------------------------------- */
{
unsigned int total_rows;
- total_rows = TermWin.nrow + TermWin.saveLines;
+ total_rows = nrow + saveLines;
delete talloc; talloc = 0;
delete ralloc; ralloc = 0;
- free (screen.text);
- free (screen.tlen);
- free (screen.rend);
- free (drawn_text);
- free (drawn_rend);
- free (swap.text);
- free (swap.tlen);
- free (swap.rend);
- free (buf_text);
- free (buf_rend);
+ free (screen.line);
+ free (save);
+ free (swap_save);
+ free (drawn);
+ free (buf);
free (tabs);
-
- /* NULL these so if anything tries to use them, we'll know about it */
- screen.text = drawn_text = swap.text = NULL;
- screen.rend = drawn_rend = swap.rend = NULL;
- screen.tlen = swap.tlen = NULL;
- buf_text = NULL;
- buf_rend = NULL;
- tabs = NULL;
}
/* ------------------------------------------------------------------------- */
}
/* boundary check in case screen size changed between SAVE and RESTORE */
- MIN_IT (s->cur.row, TermWin.nrow - 1);
- MIN_IT (s->cur.col, TermWin.ncol - 1);
+ MIN_IT (s->cur.row, nrow - 1);
+ MIN_IT (s->cur.col, ncol - 1);
#ifdef DEBUG_STRICT
assert (s->cur.row >= 0);
assert (s->cur.col >= 0);
want_refresh = 1;
- TermWin.view_start = 0;
+ view_start = 0;
if (current_screen == scrn)
return scrn;
if (options & Opt_secondaryScreen)
{
num_scr = 0;
- offset = TermWin.saveLines;
+ offset = saveLines;
for (i = prev_nrow; i--;)
- {
- SWAP_IT (screen.text[i + offset], swap.text[i], text_t *);
- SWAP_IT (screen.tlen[i + offset], swap.tlen[i], int16_t);
- SWAP_IT (screen.rend[i + offset], swap.rend[i], rend_t *);
- }
+ SWAP_IT (*(screen.line[i]), swap_save[i], line_t);
SWAP_IT (screen.charset, swap.charset, int16_t);
SWAP_IT (screen.flags, swap.flags, int);
if (screen.cur.row == screen.bscroll)
scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
- else if (screen.cur.row < TermWin.nrow - 1)
+ else if (screen.cur.row < nrow - 1)
screen.cur.row++;
}
rstyle &= ~style;
}
+// set screen.line pointers to the actual lines in the save buffer
+void
+rxvt_term::scr_update_term ()
+{
+ for (int i = nrow; i--; )
+ screen.line[i] = save + saveLines + i;
+}
+
/* ------------------------------------------------------------------------- */
/*
* Scroll text between <row1> and <row2> inclusive, by <count> lines
rxvt_term::scr_scroll_text (int row1, int row2, int count, int spec)
{
int i, j;
- long nscrolled;
if (count == 0 || (row1 > row2))
return 0;
if (row1 == 0 && count > 0
&& (current_screen == PRIMARY || options & Opt_secondaryScroll))
{
- nscrolled = (long)TermWin.nscrolled + (long)count;
+ nscrolled += count;
- if (nscrolled > (long)TermWin.saveLines)
- TermWin.nscrolled = TermWin.saveLines;
- else
- TermWin.nscrolled = (unsigned int)nscrolled;
+ if (nscrolled > saveLines)
+ nscrolled = saveLines;
if ((options & Opt_scrollWithBuffer)
- && TermWin.view_start != 0
- && TermWin.view_start != TermWin.saveLines)
+ && view_start != 0
+ && view_start != saveLines)
scr_page (UP, count);
}
else if (!spec)
- row1 += TermWin.saveLines;
+ row1 += saveLines;
- row2 += TermWin.saveLines;
+ row2 += saveLines;
if (selection.op && current_screen == selection.screen)
{
- i = selection.beg.row + TermWin.saveLines;
- j = selection.end.row + TermWin.saveLines;
+ i = selection.beg.row + saveLines;
+ j = selection.end.row + saveLines;
+
if ((i < row1 && j > row1)
|| (i < row2 && j > row2)
|| (i - count < row1 && i >= row1)
}
}
- selection_check (0); /* _after_ TermWin.nscrolled update */
+ selection_check (0); /* _after_ nscrolled update */
num_scr += count;
j = count;
/* scroll up */
/* Copy lines that will get clobbered by the rotation */
- memcpy (buf_text, screen.text + row1, count * sizeof (text_t *));
- memcpy (buf_rend, screen.rend + row1, count * sizeof (rend_t *));
+ memcpy (buf, save + row1, count * sizeof (line_t));
/* Rotate lines */
i = row2 - row1 - count + 1;
- memmove (screen.tlen + row1, screen.tlen + row1 + count, i * sizeof (int16_t));
- memmove (screen.text + row1, screen.text + row1 + count, i * sizeof (text_t *));
- memmove (screen.rend + row1, screen.rend + row1 + count, i * sizeof (rend_t *));
+ memmove (save + row1, save + row1 + count, i * sizeof (line_t));
j = row2 - count + 1, i = count;
}
/* Copy lines that will get clobbered by the rotation */
for (i = 0, j = row2; i < count; i++, j--)
- {
- buf_text[i] = screen.text[j];
- buf_rend[i] = screen.rend[j];
- }
+ buf[i] = save[j];
/* Rotate lines */
for (j = row2, i = j - count; i >= row1; i--, j--)
- {
- screen.tlen[j] = screen.tlen[i];
- screen.text[j] = screen.text[i];
- screen.rend[j] = screen.rend[i];
- }
+ save[j] = save[i];
j = row1, i = count;
count = -count;
}
/* Resurrect lines */
- memset (screen.tlen + j, 0, i * sizeof (int16_t));
- memcpy (screen.text + j, buf_text, i * sizeof (text_t *));
- memcpy (screen.rend + j, buf_rend, i * sizeof (text_t *));
- if (!spec) /* line length may not equal TermWin.ncol */
+ memcpy (save + j, buf, i * sizeof (line_t));
+
+ scr_update_term ();
+
+ if (!spec) /* line length may not equal ncol */
for (; i--; j++)
- scr_blank_screen_mem (screen.text, screen.rend, (unsigned int)j, rstyle);
+ scr_blank_screen_mem (save[j], rstyle);
return count;
}
unsigned char checksel;
unicode_t c;
int row, last_col;
- text_t *stp;
- rend_t *srp;
const unicode_t *strend = str + len;
want_refresh = 1;
ZERO_SCROLLBACK ();
- last_col = TermWin.ncol;
+ last_col = ncol;
if (nlines > 0)
{
nlines += screen.cur.row - screen.bscroll;
if ((nlines > 0)
&& (screen.tscroll == 0)
- && (screen.bscroll == (TermWin.nrow - 1)))
+ && (screen.bscroll == (nrow - 1)))
{
/* _at least_ this many lines need to be scrolled */
scr_scroll_text (screen.tscroll, screen.bscroll, nlines, 0);
#ifdef DEBUG_STRICT
assert (screen.cur.col < last_col);
- assert ((screen.cur.row < TermWin.nrow)
- && (screen.cur.row >= - (int32_t)TermWin.nscrolled));
+ assert ((screen.cur.row < nrow)
+ && (screen.cur.row >= - (int32_t)nscrolled));
#else /* drive with your eyes closed */
MIN_IT (screen.cur.col, last_col - 1);
- MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
- MAX_IT (screen.cur.row, - (int32_t)TermWin.nscrolled);
+ MIN_IT (screen.cur.row, (int32_t)nrow - 1);
+ MAX_IT (screen.cur.row, - (int32_t)nscrolled);
#endif
- row = screen.cur.row + TermWin.saveLines;
+ row = screen.cur.row + saveLines;
checksel = selection.op && current_screen == selection.screen ? 1 : 0;
- stp = screen.text[row];
- srp = screen.rend[row];
+ line_t *line = save + row;
while (str < strend)
{
if (c < 0x20)
if (c == C0_LF)
{
- if (screen.tlen[row] != -1) /* XXX: think about this */
- MAX_IT (screen.tlen[row], screen.cur.col);
+ if (line->l != -1) /* XXX: think about this */
+ MAX_IT (line->l, screen.cur.col);
screen.flags &= ~Screen_WrapNext;
if (screen.cur.row == screen.bscroll)
scr_scroll_text (screen.tscroll, screen.bscroll, 1, 0);
- else if (screen.cur.row < (TermWin.nrow - 1))
- row = (++screen.cur.row) + TermWin.saveLines;
+ else if (screen.cur.row < (nrow - 1))
+ row = (++screen.cur.row) + saveLines;
- stp = screen.text[row]; /* _must_ refresh */
- srp = screen.rend[row]; /* _must_ refresh */
+ line = save + row; /* _must_ refresh */
continue;
}
else if (c == C0_CR)
{
- if (screen.tlen[row] != -1) /* XXX: think about this */
- MAX_IT (screen.tlen[row], screen.cur.col);
+ if (line->l != -1) /* XXX: think about this */
+ MAX_IT (line->l, screen.cur.col);
screen.flags &= ~Screen_WrapNext;
screen.cur.col = 0;
if (screen.flags & Screen_WrapNext)
{
- screen.tlen[row] = -1;
+ line->l = -1;
scr_do_wrap ();
- row = screen.cur.row + TermWin.saveLines;
- stp = screen.text[row]; /* _must_ refresh */
- srp = screen.rend[row]; /* _must_ refresh */
+ row = screen.cur.row + saveLines;
+ line = save + row; /* _must_ refresh */
}
// some utf-8 decoders "decode" surrogate characters: let's fix this.
#endif
// nuke the character at this position, if required
- if (stp[screen.cur.col] == NOCHAR
- || (screen.cur.col < TermWin.ncol - 1
- && stp[screen.cur.col + 1] == NOCHAR))
+ if (line->t[screen.cur.col] == NOCHAR
+ || (screen.cur.col < ncol - 1
+ && line->t[screen.cur.col + 1] == NOCHAR))
{
int col = screen.cur.col;
// find begin
- while (col > 0 && stp[col] == NOCHAR)
+ while (col > 0 && line->t[col] == NOCHAR)
col--;
- rend_t rend = SET_FONT (srp[col], FONTSET (srp[col])->find_font (' '));
+ rend_t rend = SET_FONT (line->r[col], FONTSET (line->r[col])->find_font (' '));
// found begin, nuke
do {
- stp[col] = ' ';
- srp[col] = rend;
+ line->t[col] = ' ';
+ line->r[col] = rend;
col++;
- } while (col < TermWin.ncol && stp[col] == NOCHAR);
+ } while (col < ncol && line->t[col] == NOCHAR);
}
rend_t rend = SET_FONT (rstyle, FONTSET (rstyle)->find_font (c));
do
{
- stp[screen.cur.col] = c;
- srp[screen.cur.col] = rend;
+ line->t[screen.cur.col] = c;
+ line->r[screen.cur.col] = rend;
if (screen.cur.col < last_col - 1)
screen.cur.col++;
else
{
- screen.tlen[row] = last_col;
+ line->l = last_col;
if (screen.flags & Screen_Autowrap)
screen.flags |= Screen_WrapNext;
break;
// pad with spaces when overwriting wide character with smaller one
if (!width)
- for (int c = screen.cur.col; c < last_col && stp[c] == NOCHAR; c++)
+ for (int c = screen.cur.col; c < last_col && line->t[c] == NOCHAR; c++)
{
- stp[c] = ' ';
- srp[c] = rend;
+ line->t[c] = ' ';
+ line->r[c] = rend;
}
}
else // width == 0
if (screen.cur.col > 0)
{
- tp = stp + screen.cur.col - 1;
- rp = srp + screen.cur.col - 1;
+ tp = line->t + screen.cur.col - 1;
+ rp = line->r + screen.cur.col - 1;
- while (*tp == NOCHAR && tp > stp)
+ while (*tp == NOCHAR && tp > line->t)
tp--, rp--;
}
else if (screen.cur.row > 0
- && screen.tlen [screen.cur.row - 1 + TermWin.saveLines] == -1)
+ && save [screen.cur.row - 1 + saveLines].l == -1)
{
- int line = screen.cur.row - 1 + TermWin.saveLines;
+ line_t *line = save + (screen.cur.row - 1 + saveLines);
- tp = screen.text[line] + last_col - 1;
- rp = screen.rend[line] + last_col - 1;
+ tp = line->t + last_col - 1;
+ rp = line->r + last_col - 1;
- while (*tp == NOCHAR && tp > screen.text[line])
+ while (*tp == NOCHAR && tp > line->t)
tp--, rp--;
}
else
}
}
- if (screen.tlen[row] != -1) /* XXX: think about this */
- MAX_IT (screen.tlen[row], screen.cur.col);
+ if (line->l != -1) /* XXX: think about this */
+ MAX_IT (line->l, screen.cur.col);
#ifdef DEBUG_STRICT
assert (screen.cur.row >= 0);
if (screen.cur.row > 0)
{
#ifdef TERMCAP_HAS_BW
- screen.cur.col = TermWin.ncol - 1;
+ screen.cur.col = ncol - 1;
screen.cur.row--;
return;
#endif
return;
else if (count > 0)
{
- int row = TermWin.saveLines + screen.cur.row;
- text_t *tp = screen.text[row];
- rend_t *rp = screen.rend[row];
- rend_t base_rend = rp[i];
- ht &= tp[i] == ' ';
+ int row = saveLines + screen.cur.row;
- for (; ++i < TermWin.ncol; )
+ line_t &l = save[row];
+ rend_t base_rend = l.r[i];
+ ht &= l.t[i] == ' ';
+
+ for (; ++i < ncol; )
if (tabs[i])
{
x = i;
break;
}
else
- ht &= tp[i] == ' '
- && RS_SAME (rp[i], base_rend);
+ ht &= l.t[i] == ' '
+ && RS_SAME (l.r[i], base_rend);
if (count)
- x = TermWin.ncol - 1;
+ x = ncol - 1;
// store horizontal tab commands as characters inside the text
// buffer so they can be selected and pasted.
{
base_rend = SET_FONT (base_rend, 0);
- if (screen.tlen[row] != -1) /* XXX: think about this */
- MAX_IT (screen.tlen[row], x);
+ if (l.l != -1) /* XXX: think about this */
+ MAX_IT (l.l, x);
i = screen.cur.col;
- tp[i] = '\t';
- rp[i] = base_rend;
+ l.t[i] = '\t';
+ l.r[i] = base_rend;
while (++i < x)
{
- tp[i] = NOCHAR;
- rp[i] = base_rend;
+ l.t[i] = NOCHAR;
+ l.r[i] = base_rend;
}
}
}
scr_gotorc (0, -1, R_RELATIVE | C_RELATIVE);
else
{
- if (screen.tlen[screen.cur.row + TermWin.saveLines] == 0)
+ if (save[screen.cur.row + saveLines].l == 0)
return; /* um, yeah? */
scr_insdel_chars (1, INSERT);
{
int row;
- if (screen.cur.col < TermWin.ncol - 1)
+ if (screen.cur.col < ncol - 1)
scr_gotorc (0, 1, R_RELATIVE | C_RELATIVE);
else
{
- row = screen.cur.row + TermWin.saveLines;
+ row = screen.cur.row + saveLines;
- if (screen.tlen[row] == 0)
+ if (save[row].l == 0)
return; /* um, yeah? */
- else if (screen.tlen[row] == -1)
- screen.tlen[row] = TermWin.ncol;
+ else if (save[row].l == -1)
+ save[row].l = ncol;
scr_gotorc (0, 0, R_RELATIVE);
scr_insdel_chars (1, DELETE);
- scr_gotorc (0, TermWin.ncol - 1, R_RELATIVE);
+ scr_gotorc (0, ncol - 1, R_RELATIVE);
}
}
#endif
screen.cur.col = relative & C_RELATIVE ? screen.cur.col + col : col;
MAX_IT (screen.cur.col, 0);
- MIN_IT (screen.cur.col, (int32_t)TermWin.ncol - 1);
+ MIN_IT (screen.cur.col, (int32_t)ncol - 1);
screen.flags &= ~Screen_WrapNext;
}
MAX_IT (screen.cur.row, 0);
- MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
+ MIN_IT (screen.cur.row, (int32_t)nrow - 1);
}
/* ------------------------------------------------------------------------- */
screen.cur.row += dirn;
MAX_IT (screen.cur.row, 0);
- MIN_IT (screen.cur.row, (int32_t)TermWin.nrow - 1);
+ MIN_IT (screen.cur.row, (int32_t)nrow - 1);
selection_check (0);
}
selection_check (1);
- row = TermWin.saveLines + screen.cur.row;
+ row = saveLines + screen.cur.row;
+
switch (mode)
{
case 0: /* erase to end of line */
col = screen.cur.col;
- num = TermWin.ncol - col;
- MIN_IT (screen.tlen[row], (int16_t)col);
+ num = ncol - col;
+ MIN_IT (save[row].l, (int16_t)col);
if (ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur)
|| ROWCOL_IN_ROW_AT_OR_AFTER (selection.end, screen.cur))
CLEAR_SELECTION ();
break;
case 2: /* erase whole line */
col = 0;
- num = TermWin.ncol;
- screen.tlen[row] = 0;
+ num = ncol;
+ save[row].l = 0;
if (selection.beg.row <= screen.cur.row
&& selection.end.row >= screen.cur.row)
CLEAR_SELECTION ();
return;
}
- if (screen.text[row])
- scr_blank_line (&screen.text[row][col], &screen.rend[row][col], num, rstyle);
+ if (save[row].t)
+ scr_blank_line (save[row], col, num, rstyle);
else
- scr_blank_screen_mem (screen.text, screen.rend, row, rstyle);
+ scr_blank_screen_mem (save[row], rstyle);
}
/* ------------------------------------------------------------------------- */
want_refresh = 1;
ZERO_SCROLLBACK ();
- row_offset = (int32_t)TermWin.saveLines;
+ row_offset = (int32_t)saveLines;
switch (mode)
{
selection_check (1);
scr_erase_line (0);
row = screen.cur.row + 1; /* possible OOB */
- num = TermWin.nrow - row;
+ num = nrow - row;
break;
case 1: /* erase to beginning of screen */
selection_check (3);
case 2: /* erase whole screen */
selection_check (3);
row = 0;
- num = TermWin.nrow;
+ num = nrow;
break;
default:
return;
&& selection.end.row <= row + num)))
CLEAR_SELECTION ();
- if (row >= TermWin.nrow) /* Out Of Bounds */
+ if (row >= nrow) /* Out Of Bounds */
return;
- MIN_IT (num, (TermWin.nrow - row));
+ MIN_IT (num, (nrow - row));
if (rstyle & (RS_RVid | RS_Uline))
ren = (rend_t) ~RS_None;
{
ren = rstyle & (RS_fgMask | RS_bgMask);
gcvalue.foreground = pix_colors[GET_BGCOLOR (rstyle)];
- XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
+ XChangeGC (display->display, gc, GCForeground, &gcvalue);
ERASE_ROWS (row, num);
gcvalue.foreground = pix_colors[Color_fg];
- XChangeGC (display->display, TermWin.gc, GCForeground, &gcvalue);
+ XChangeGC (display->display, gc, GCForeground, &gcvalue);
}
for (; num--; row++)
{
- scr_blank_screen_mem (screen.text, screen.rend, (unsigned int) (row + row_offset), rstyle);
- screen.tlen[row + row_offset] = 0;
- scr_blank_line (drawn_text[row], drawn_rend[row], (unsigned int)TermWin.ncol, ren);
+ scr_blank_screen_mem (save[row + row_offset], rstyle);
+ save[row + row_offset].l = 0;
+ scr_blank_line (drawn[row], 0, ncol, ren);
}
}
want_refresh = 1;
ZERO_SCROLLBACK ();
- TermWin.nscrolled = 0;
+ nscrolled = 0;
}
#endif
selection_check (3);
fs = SET_FONT (rstyle, FONTSET (rstyle)->find_font ('E'));
- for (k = TermWin.saveLines, i = TermWin.nrow; i--; k++)
+ for (k = saveLines, i = nrow; i--; k++)
{
- screen.tlen[k] = TermWin.ncol; /* make the `E's selectable */
- fill_text (screen.text[k], 'E', TermWin.ncol);
- for (r1 = screen.rend[k], j = TermWin.ncol; j--; )
+ save[k].l = ncol; /* make the `E's selectable */
+ fill_text (save[k].t, 'E', ncol);
+ for (r1 = save[k].r, j = ncol; j--; )
*r1++ = fs;
}
}
{
int col, row;
rend_t tr;
- text_t *stp;
- rend_t *srp;
- int16_t *slp;
want_refresh = 1;
ZERO_SCROLLBACK ();
scr_do_wrap ();
selection_check (1);
- MIN_IT (count, (TermWin.ncol - screen.cur.col));
+ MIN_IT (count, (ncol - screen.cur.col));
- row = screen.cur.row + TermWin.saveLines;
+ row = screen.cur.row + saveLines;
- stp = screen.text[row];
- srp = screen.rend[row];
- slp = &screen.tlen[row];
+ line_t *line = save + row;
switch (insdel)
{
case INSERT:
- for (col = TermWin.ncol - 1; (col - count) >= screen.cur.col; col--)
+ for (col = ncol - 1; (col - count) >= screen.cur.col; col--)
{
- stp[col] = stp[col - count];
- srp[col] = srp[col - count];
+ line->t[col] = line->t[col - count];
+ line->r[col] = line->r[col - count];
}
- if (*slp != -1)
+ if (line->l != -1)
{
- *slp += count;
- MIN_IT (*slp, TermWin.ncol);
+ line->l += count;
+ MIN_IT (line->l, ncol);
}
if (selection.op && current_screen == selection.screen
&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
{
if (selection.end.row != screen.cur.row
- || (selection.end.col + count >= TermWin.ncol))
+ || (selection.end.col + count >= ncol))
CLEAR_SELECTION ();
else
{ /* shift selection */
}
}
- scr_blank_line (&stp[screen.cur.col], &srp[screen.cur.col],
- (unsigned int)count, rstyle);
+ scr_blank_line (save[row], screen.cur.col, count, rstyle);
break;
case ERASE:
- screen.cur.col += count; /* don't worry if > TermWin.ncol */
+ screen.cur.col += count; /* don't worry if > ncol */
selection_check (1);
screen.cur.col -= count;
- scr_blank_line (&stp[screen.cur.col], &srp[screen.cur.col],
- (unsigned int)count, rstyle);
+ scr_blank_line (save[row], screen.cur.col, count, rstyle);
break;
case DELETE:
- tr = srp[TermWin.ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
+ tr = line->r[ncol - 1] & (RS_fgMask | RS_bgMask | RS_baseattrMask);
- for (col = screen.cur.col; (col + count) < TermWin.ncol; col++)
+ for (col = screen.cur.col; (col + count) < ncol; col++)
{
- stp[col] = stp[col + count];
- srp[col] = srp[col + count];
+ line->t[col] = line->t[col + count];
+ line->r[col] = line->r[col + count];
}
- scr_blank_line (&stp[TermWin.ncol - count], &srp[TermWin.ncol - count],
- (unsigned int)count, tr);
+ scr_blank_line (*line, ncol - count, count, tr);
- if (*slp == -1) /* break line continuation */
- *slp = TermWin.ncol;
+ if (line->l == -1) /* break line continuation */
+ line->l = ncol;
- *slp -= count;
- MAX_IT (*slp, 0);
+ line->l -= count;
+ MAX_IT (line->l, 0);
if (selection.op && current_screen == selection.screen
&& ROWCOL_IN_ROW_AT_OR_AFTER (selection.beg, screen.cur))
{
if (selection.end.row != screen.cur.row
|| (screen.cur.col >= selection.beg.col - count)
- || selection.end.col >= TermWin.ncol)
+ || selection.end.col >= ncol)
CLEAR_SELECTION ();
else
{
rxvt_term::scr_scroll_region (int top, int bot)
{
MAX_IT (top, 0);
- MIN_IT (bot, (int)TermWin.nrow - 1);
+ MIN_IT (bot, (int)nrow - 1);
if (top > bot)
return;
rxvt_term::scr_set_tab (int mode)
{
if (mode < 0)
- memset (tabs, 0, TermWin.ncol * sizeof (char));
- else if (screen.cur.col < TermWin.ncol)
+ memset (tabs, 0, ncol * sizeof (char));
+ else if (screen.cur.col < ncol)
tabs[screen.cur.col] = (mode ? 1 : 0);
}
#if TRANSPARENT
if (! (options & Opt_transparent) || am_transparent == 0)
#endif
- XSetWindowBackground (display->display, TermWin.vt,
+ XSetWindowBackground (display->display, vt,
pix_colors[Color_bg]);
gcvalue.foreground = pix_colors[Color_fg];
gcvalue.background = pix_colors[Color_bg];
- XChangeGC (display->display, TermWin.gc, GCBackground | GCForeground,
+ XChangeGC (display->display, gc, GCBackground | GCForeground,
&gcvalue);
scr_clear ();
scr_touch (true);
{
bool found = false;
- for (int i = 0; i < TermWin.nrow; i++)
+ for (int i = 0; i < nrow; i++)
{
int col = 0;
- rend_t *drp = drawn_rend [i];
+ rend_t *drp = drawn[i].r;
- for (; col < TermWin.ncol; col++, drp++)
+ for (; col < ncol; col++, drp++)
if ((*drp & mask) == value)
{
found = true;
};
void
-rxvt_term::scr_expose (int x, int y, int width, int height, bool refresh)
+rxvt_term::scr_expose (int x, int y, int ewidth, int eheight, bool refresh)
{
int i;
row_col_t rc[RC_COUNT];
- if (drawn_text == NULL) /* sanity check */
+ if (!drawn) /* sanity check */
return;
#ifndef NO_SLOW_LINK_SUPPORT
if (refresh_type == FAST_REFRESH && !display->is_local)
{
y = 0;
- height = TermWin.height;
+ eheight = height;
}
#endif
#ifdef DEBUG_STRICT
x = max (x, 0);
- x = min (x, (int)TermWin.width);
+ x = min (x, (int)width);
y = max (y, 0);
- y = min (y, (int)TermWin.height);
+ y = min (y, (int)height);
#endif
/* round down */
rc[PART_BEG].col = Pixel2Col (x);
rc[PART_BEG].row = Pixel2Row (y);
/* round up */
- rc[PART_END].col = Pixel2Width (x + width + TermWin.fwidth - 1);
- rc[PART_END].row = Pixel2Row (y + height + TermWin.fheight - 1);
+ rc[PART_END].col = Pixel2Width (x + ewidth + fwidth - 1);
+ rc[PART_END].row = Pixel2Row (y + eheight + fheight - 1);
/* sanity checks */
for (i = PART_BEG; i < RC_COUNT; i++)
{
- MIN_IT (rc[i].col, TermWin.ncol - 1);
- MIN_IT (rc[i].row, TermWin.nrow - 1);
+ MIN_IT (rc[i].col, ncol - 1);
+ MIN_IT (rc[i].row, nrow - 1);
}
for (i = rc[PART_BEG].row; i <= rc[PART_END].row; i++)
- fill_text (&drawn_text[i][rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
+ fill_text (&drawn[i].t[rc[PART_BEG].col], 0, rc[PART_END].col - rc[PART_BEG].col + 1);
if (refresh)
scr_refresh (SLOW_REFRESH);
void
rxvt_term::scr_touch (bool refresh)
{
- scr_expose (0, 0, TermWin.width, TermWin.height, refresh);
+ scr_expose (0, 0, width, height, refresh);
}
/* ------------------------------------------------------------------------- */
long p = 0;
unsigned int oldviewstart;
- oldviewstart = TermWin.view_start;
+ oldviewstart = view_start;
if (y < len)
{
- p = (TermWin.nrow + TermWin.nscrolled) * (len - y) / len;
- p -= (long) (TermWin.nrow - 1);
+ p = (nrow + nscrolled) * (len - y) / len;
+ p -= (long) (nrow - 1);
p = max (p, 0);
}
- TermWin.view_start = (unsigned int)min (p, TermWin.nscrolled);
+ view_start = (unsigned int)min (p, nscrolled);
return scr_changeview (oldviewstart);
}
int n;
unsigned int oldviewstart;
- oldviewstart = TermWin.view_start;
+ oldviewstart = view_start;
if (direction == UP)
{
- n = TermWin.view_start + nlines;
- TermWin.view_start = min (n, TermWin.nscrolled);
+ n = view_start + nlines;
+ view_start = min (n, nscrolled);
}
else
{
- n = TermWin.view_start - nlines;
- TermWin.view_start = max (n, 0);
+ n = view_start - nlines;
+ view_start = max (n, 0);
}
return scr_changeview (oldviewstart);
int
rxvt_term::scr_changeview (unsigned int oldviewstart)
{
- if (TermWin.view_start != oldviewstart)
+ if (view_start != oldviewstart)
{
want_refresh = 1;
- num_scr -= (TermWin.view_start - oldviewstart);
+ num_scr -= (view_start - oldviewstart);
}
- return (int) (TermWin.view_start - oldviewstart);
+ return (int) (view_start - oldviewstart);
}
/* ------------------------------------------------------------------------- */
# ifdef MAPALERT_OPTION
if (options & Opt_mapAlert)
# endif
- XMapWindow (display->display, TermWin.parent[0]);
+ XMapWindow (display->display, parent[0]);
# endif
if (options & Opt_visualBell)
if ((fd = popen_printer ()) == NULL)
return;
- nrows = TermWin.nrow;
- row_offset = TermWin.saveLines;
+ nrows = nrow;
+ row_offset = saveLines;
if (!fullhist)
- row_offset -= TermWin.view_start;
+ row_offset -= view_start;
else
{
- nrows += TermWin.nscrolled;
- row_offset -= TermWin.nscrolled;
+ nrows += nscrolled;
+ row_offset -= nscrolled;
}
wctomb (0, 0);
for (r1 = 0; r1 < nrows; r1++)
{
- text_t *tp = screen.text[r1 + row_offset];
- int len = screen.tlen[r1 + row_offset];
+ text_t *tp = save[r1 + row_offset].t;
+ int len = save[r1 + row_offset].l;
- for (i = len >= 0 ? len : TermWin.ncol - 1; i--; )
+ for (i = len >= 0 ? len : ncol - 1; i--; )
{
char mb[MB_LEN_MAX];
text_t t = *tp++;
want_refresh = 0; /* screen is current */
- if (refresh_type == NO_REFRESH || !TermWin.mapped)
+ if (refresh_type == NO_REFRESH || !mapped)
return;
/*
must_clear = 0;
refresh_count = 0;
- row_offset = TermWin.saveLines - TermWin.view_start;
+ row_offset = saveLines - view_start;
#if XPM_BACKGROUND
must_clear |= bgPixmap.pixmap != None;
{
int col = screen.cur.col;
- while (col && screen.text[screen.cur.row + TermWin.saveLines][col] == NOCHAR)
+ while (col && screen.line[screen.cur.row]->t[col] == NOCHAR)
col--;
- crp = &screen.rend[screen.cur.row + TermWin.saveLines][col];
+ crp = &screen.line[screen.cur.row]->r[col];
- if (showcursor && TermWin.focus)
+ if (showcursor && focus)
{
if (options & Opt_cursorUnderline)
*crp ^= RS_Uline;
setoldcursor = 0;
if (ocrow != -1)
{
- if (screen.cur.row + TermWin.view_start != ocrow
+ if (screen.cur.row + view_start != ocrow
|| screen.cur.col != oldcursor.col)
{
- if (ocrow < TermWin.nrow
- && oldcursor.col < TermWin.ncol)
- drawn_rend[ocrow][oldcursor.col] ^= (RS_RVid | RS_Uline);
+ if (ocrow < nrow
+ && oldcursor.col < ncol)
+ drawn[ocrow].r[oldcursor.col] ^= (RS_RVid | RS_Uline);
- if (TermWin.focus || !showcursor)
+ if (focus || !showcursor)
oldcursor.row = -1;
else
setoldcursor = 1;
}
}
- else if (!TermWin.focus)
+ else if (!focus)
setoldcursor = 1;
if (setoldcursor)
{
- if (screen.cur.row + TermWin.view_start >= TermWin.nrow)
+ if (screen.cur.row + view_start >= nrow)
oldcursor.row = -1;
else
{
- oldcursor.row = screen.cur.row + TermWin.view_start;
+ oldcursor.row = screen.cur.row + view_start;
oldcursor.col = screen.cur.col;
}
}
i = num_scr;
if (!display->is_local
&& refresh_type == FAST_REFRESH && num_scr_allow && i
- && abs (i) < TermWin.nrow && !must_clear)
+ && abs (i) < nrow && !must_clear)
{
int16_t nits;
int j;
int len, wlen;
- j = TermWin.nrow;
+ j = nrow;
wlen = len = -1;
row = i > 0 ? 0 : j - 1;
for (; j-- >= 0; row += (i > 0 ? 1 : -1))
{
- if (row + i >= 0 && row + i < TermWin.nrow && row + i != ocrow)
+ if (row + i >= 0 && row + i < nrow && row + i != ocrow)
{
- text_t *stp = screen.text[row + row_offset];
- rend_t *srp = screen.rend[row + row_offset];
- text_t *dtp = drawn_text[row];
- text_t *dtp2 = drawn_text[row + i];
- rend_t *drp = drawn_rend[row];
- rend_t *drp2 = drawn_rend[row + i];
-
- for (nits = 0, col = TermWin.ncol; col--; )
- if (stp[col] != dtp2[col] || srp[col] != drp2[col])
+ line_t s = save[row + row_offset];
+ line_t d = drawn[row];
+ line_t d2 = drawn[row + i];
+
+ for (nits = 0, col = ncol; col--; )
+ if (s.t[col] != d2.t[col] || s.r[col] != d2.r[col])
nits--;
- else if (stp[col] != dtp[col] || srp[col] != drp[col])
+ else if (s.t[col] != d.t[col] || s.r[col] != d.r[col])
nits++;
if (nits > 8) /* XXX: arbitrary choice */
{
- for (col = TermWin.ncol; col--; )
+ for (col = ncol; col--; )
{
- *dtp++ = *dtp2++;
- *drp++ = *drp2++;
+ *d.t++ = *d2.t++;
+ *d.r++ = *d2.r++;
}
if (len == -1)
if (wlen < len)
SWAP_IT (wlen, len, int);
- XCopyArea (display->display, TermWin.vt, TermWin.vt,
- TermWin.gc, 0, Row2Pixel (len + i),
+ XCopyArea (display->display, vt, vt,
+ gc, 0, Row2Pixel (len + i),
(unsigned int)TermWin_TotalWidth (),
(unsigned int)Height2Pixel (wlen - len + 1),
0, Row2Pixel (len));
/*
* E: main pass across every character
*/
- for (row = 0; row < TermWin.nrow; row++)
+ for (row = 0; row < nrow; row++)
{
- text_t *stp = screen.text[row + row_offset];
- rend_t *srp = screen.rend[row + row_offset];
- text_t *dtp = drawn_text[row];
- rend_t *drp = drawn_rend[row];
+ text_t *stp = save[row + row_offset].t;
+ rend_t *srp = save[row + row_offset].r;
+ text_t *dtp = drawn[row].t;
+ rend_t *drp = drawn[row].r;
/*
* E2: OK, now the real pass
*/
int ypixel = (int)Row2Pixel (row);
- for (col = 0; col < TermWin.ncol; col++)
+ for (col = 0; col < ncol; col++)
{
/* compare new text with old - if exactly the same then continue */
if (stp[col] == dtp[col] /* Must match characters to skip. */
int xpixel = Col2Pixel (col);
- for (i = 0; ++col < TermWin.ncol; )
+ for (i = 0; ++col < ncol; )
{
if (stp[col] == NOCHAR)
{
{
#if ENABLE_STYLES
// force redraw after "careful" characters to avoid pixel droppings
- if (srp[col] & RS_Careful && col < TermWin.ncol - 1 && 0)
+ if (srp[col] & RS_Careful && col < ncol - 1 && 0)
drp[col + 1] = ~srp[col + 1];
// include previous careful character(s) if possible, looks nicer (best effort...)
while (text > stp
&& srp[text - stp - 1] & RS_Careful
&& RS_SAME (rend, srp[text - stp - 1]))
- text--, count++, xpixel -= TermWin.fwidth;
+ text--, count++, xpixel -= fwidth;
#endif
bool invert = rend & RS_RVid;
/*
* Actually do the drawing of the string here
*/
- rxvt_font *font = (*TermWin.fontset[GET_STYLE (rend)])[GET_FONT (rend)];
+ rxvt_font *font = (*fontset[GET_STYLE (rend)])[GET_FONT (rend)];
if (back == fore)
- font->clear_rect (*TermWin.drawable, xpixel, ypixel,
- TermWin.fwidth * count, TermWin.fheight,
+ font->clear_rect (*drawable, xpixel, ypixel,
+ fwidth * count, fheight,
back);
else if (back == Color_bg)
{
for (i = 0; i < count; i++) /* don't draw empty strings */
if (text[i] != ' ')
{
- font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, -1);
+ font->draw (*drawable, xpixel, ypixel, text, count, fore, -1);
break;
}
}
else
- font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, Color_bg);
+ font->draw (*drawable, xpixel, ypixel, text, count, fore, Color_bg);
}
else
- font->draw (*TermWin.drawable, xpixel, ypixel, text, count, fore, back);
+ font->draw (*drawable, xpixel, ypixel, text, count, fore, back);
if (rend & RS_Uline && font->descent > 1 && fore != back)
{
#if ENABLE_FRILLS
if (ISSET_PIXCOLOR (Color_underline))
- XSetForeground (display->display, TermWin.gc, pix_colors[Color_underline]);
+ XSetForeground (display->display, gc, pix_colors[Color_underline]);
else
#endif
- XSetForeground (display->display, TermWin.gc, pix_colors[fore]);
+ XSetForeground (display->display, gc, pix_colors[fore]);
- XDrawLine (display->display, drawBuffer, TermWin.gc,
+ XDrawLine (display->display, drawBuffer, gc,
xpixel, ypixel + font->ascent + 1,
xpixel + Width2Pixel (count) - 1, ypixel + font->ascent + 1);
}
*/
if (showcursor)
{
- if (TermWin.focus)
+ if (focus)
{
if (options & Opt_cursorUnderline)
*crp ^= RS_Uline;
int cursorwidth = 1;
int col = oldcursor.col;
- while (col && screen.text[screen.cur.row + TermWin.saveLines][col] == NOCHAR)
+ while (col && save[screen.cur.row + saveLines].t[col] == NOCHAR)
col--;
- while (col + cursorwidth < TermWin.ncol
- && drawn_text[oldcursor.row][col + cursorwidth] == NOCHAR)
+ while (col + cursorwidth < ncol
+ && drawn[oldcursor.row].t[col + cursorwidth] == NOCHAR)
cursorwidth++;
#ifndef NO_CURSORCOLOR
if (ISSET_PIXCOLOR (Color_cursor))
- XSetForeground (display->display, TermWin.gc, pix_colors[Color_cursor]);
+ XSetForeground (display->display, gc, pix_colors[Color_cursor]);
#endif
- XDrawRectangle (display->display, drawBuffer, TermWin.gc,
+ XDrawRectangle (display->display, drawBuffer, gc,
Col2Pixel (col),
Row2Pixel (oldcursor.row),
(unsigned int) (Width2Pixel (cursorwidth) - 1),
- (unsigned int) (Height2Pixel (1) - TermWin.lineSpace - 1));
+ (unsigned int) (Height2Pixel (1) - lineSpace - 1));
}
}
}
void
-rxvt_term::scr_remap_chars (text_t *tp, rend_t *rp)
+rxvt_term::scr_remap_chars (const line_t &l)
{
- if (!rp || !tp)
+ if (!l.t)
return;
- for (int i = TermWin.ncol; i; i--, rp++, tp++)
- *rp = SET_FONT (*rp, FONTSET (*rp)->find_font (*tp));
+ for (int i = ncol; i--; )
+ l.r[i] = SET_FONT (l.r[i], FONTSET (l.r[i])->find_font (l.t[i]));
}
void
rxvt_term::scr_remap_chars ()
{
- for (int i = TermWin.nrow + TermWin.saveLines; i--; )
- scr_remap_chars (screen.text[i], screen.rend[i]);
+ for (int i = nrow + saveLines; i--; )
+ scr_remap_chars (save[i]);
- for (int i = TermWin.nrow; i--; )
+ for (int i = nrow; i--; )
{
- scr_remap_chars (drawn_text[i], drawn_rend[i]);
- scr_remap_chars (swap.text[i], swap.rend[i]);
+ scr_remap_chars (drawn[i]);
+ scr_remap_chars (swap_save[i]);
}
}
#endif
)
{
- XSetWindowBackground (display->display, TermWin.parent[0], pix_colors[Color_border]);
- XClearWindow (display->display, TermWin.parent[0]);
- XSetWindowBackground (display->display, TermWin.vt, pix_colors[Color_bg]);
+ XSetWindowBackground (display->display, parent[0], pix_colors[Color_border]);
+ XClearWindow (display->display, parent[0]);
+ XSetWindowBackground (display->display, vt, pix_colors[Color_bg]);
#if HAVE_SCROLLBARS
if (scrollBar.win)
{
void
rxvt_term::scr_clear (bool really)
{
- if (!TermWin.mapped)
+ if (!mapped)
return;
num_scr_allow = 0;
want_refresh = 1;
if (really)
- XClearWindow (display->display, TermWin.vt);
+ XClearWindow (display->display, vt);
}
/* ------------------------------------------------------------------------- */
{
if (selection.op && current_screen == selection.screen)
{
- int end_row = TermWin.saveLines - TermWin.view_start;
- int i = selection.beg.row + TermWin.saveLines;
- int col, row = selection.end.row + TermWin.saveLines;
+ int end_row = saveLines - view_start;
+ int i = selection.beg.row + saveLines;
+ int col, row = selection.end.row + saveLines;
rend_t *srp;
#if ENABLE_FRILLS
if (selection.rect)
{
- end_row += TermWin.nrow;
+ end_row += nrow;
for (; i <= row && i <= end_row; i++)
- for (srp = screen.rend[i], col = selection.beg.col; col < selection.end.col; col++)
+ for (srp = save[i].r, col = selection.beg.col; col < selection.end.col; col++)
srp[col] ^= RS_RVid;
}
else
i = end_row;
}
- end_row += TermWin.nrow;
+ end_row += nrow;
for (; i < row && i < end_row; i++, col = 0)
- for (srp = screen.rend[i]; col < TermWin.ncol; col++)
+ for (srp = save[i].r; col < ncol; col++)
srp[col] ^= RS_RVid;
if (i == row && i < end_row)
- for (srp = screen.rend[i]; col < selection.end.col; col++)
+ for (srp = save[i].r; col < selection.end.col; col++)
srp[col] ^= RS_RVid;
}
}
unsigned int width, towrite;
char r1[] = "\n";
- for (row = TermWin.saveLines - TermWin.nscrolled;
- row < TermWin.saveLines + TermWin.nrow - 1; row++)
+ for (row = saveLines - nscrolled;
+ row < saveLines + nrow - 1; row++)
{
- width = screen.tlen[row] >= 0 ? screen.tlen[row]
- : TermWin.ncol;
+ width = save[row].l >= 0 ? save[row].l
+ : ncol;
for (towrite = width; towrite; towrite -= wrote)
{
- wrote = write (fd, & (screen.text[row][width - towrite]),
+ wrote = write (fd, & (save[row].t[width - towrite]),
towrite);
if (wrote < 0)
return; /* XXX: death, no report */
}
- if (screen.tlen[row] >= 0)
+ if (save[row].l >= 0)
if (write (fd, r1, 1) <= 0)
return; /* XXX: death, no report */
}
* ------------------------------------------------------------------------- */
/*
- * -TermWin.nscrolled <= (selection row) <= TermWin.nrow - 1
+ * -nscrolled <= (selection row) <= nrow - 1
*/
void
rxvt_term::selection_check (int check_more)
return;
pos.row = pos.col = 0;
- if ((selection.beg.row < - (int32_t)TermWin.nscrolled)
- || (selection.beg.row >= TermWin.nrow)
- || (selection.mark.row < - (int32_t)TermWin.nscrolled)
- || (selection.mark.row >= TermWin.nrow)
- || (selection.end.row < - (int32_t)TermWin.nscrolled)
- || (selection.end.row >= TermWin.nrow)
+ if ((selection.beg.row < - (int32_t)nscrolled)
+ || (selection.beg.row >= nrow)
+ || (selection.mark.row < - (int32_t)nscrolled)
+ || (selection.mark.row >= nrow)
+ || (selection.end.row < - (int32_t)nscrolled)
+ || (selection.end.row >= nrow)
|| (check_more == 1
&& current_screen == selection.screen
&& !ROWCOL_IS_BEFORE (screen.cur, selection.beg)
&& ROWCOL_IS_AFTER (selection.end, pos))
|| (check_more == 4 /* screen width change */
&& (selection.beg.row != selection.end.row
- || selection.end.col > TermWin.ncol)))
+ || selection.end.col > ncol)))
CLEAR_SELECTION ();
}
void
rxvt_term::selection_request (Time tm, int x, int y)
{
- if (x < 0 || x >= TermWin.width || y < 0 || y >= TermWin.height)
+ if (x < 0 || x >= width || y < 0 || y >= height)
return; /* outside window */
if (selection.text)
if (XGetSelectionOwner (display->display, sel) != None)
{
XConvertSelection (display->display, sel, target, xa[XA_VT_SELECTION],
- TermWin.vt, selection_request_time);
+ vt, selection_request_time);
return 1;
}
if (selection.clicks == 4)
return; /* nothing selected, go away */
- i = (selection.end.row - selection.beg.row + 1) * (TermWin.ncol + 1);
+ i = (selection.end.row - selection.beg.row + 1) * (ncol + 1);
new_selection_text = (wchar_t *)rxvt_malloc ((i + 4) * sizeof (wchar_t));
col = selection.beg.col;
- row = selection.beg.row + TermWin.saveLines;
- end_row = selection.end.row + TermWin.saveLines;
+ row = selection.beg.row + saveLines;
+ end_row = selection.end.row + saveLines;
int ofs = 0;
int extra = 0;
for (; row <= end_row; row++, col = 0)
{
- end_col = screen.tlen[row];
+ end_col = save[row].l;
#if ENABLE_FRILLS
if (selection.rect)
{
col = selection.beg.col;
- end_col = TermWin.ncol + 1;
+ end_col = ncol + 1;
}
#endif
MAX_IT (col, 0);
if (end_col == -1)
- end_col = TermWin.ncol;
+ end_col = ncol;
if (row == end_row || selection.rect)
MIN_IT (end_col, selection.end.col);
- t = &screen.text[row][col];
+ t = &save[row].t[col];
for (; col < end_col; col++)
{
if (*t == NOCHAR)
new_selection_text[ofs++] = *t++;
}
- if (screen.tlen[row] != -1 && row != end_row)
+ if (save[row].l != -1 && row != end_row)
new_selection_text[ofs++] = C0_LF;
}
selection.len = ofs;
selection.text = (wchar_t *)rxvt_realloc (new_selection_text, (ofs + 1) * sizeof (wchar_t));
- XSetSelectionOwner (display->display, XA_PRIMARY, TermWin.vt, tm);
- if (XGetSelectionOwner (display->display, XA_PRIMARY) == TermWin.vt)
+ XSetSelectionOwner (display->display, XA_PRIMARY, vt, tm);
+ if (XGetSelectionOwner (display->display, XA_PRIMARY) == vt)
display->set_selection_owner (this);
else
rxvt_warn ("can't get primary selection, ignoring.\n");
if (clicks == 2 || clicks == 3)
selection_extend_colrow (selection.mark.col,
- selection.mark.row + TermWin.view_start,
+ selection.mark.row + view_start,
0, /* button 3 */
1, /* button press */
0); /* click change */
{
want_refresh = 1;
selection.mark.col = col;
- selection.mark.row = row - TermWin.view_start;
+ selection.mark.row = row - view_start;
- MAX_IT (selection.mark.row, - (int32_t)TermWin.nscrolled);
- MIN_IT (selection.mark.row, (int32_t)TermWin.nrow - 1);
+ MAX_IT (selection.mark.row, - (int32_t)nscrolled);
+ MIN_IT (selection.mark.row, (int32_t)nrow - 1);
MAX_IT (selection.mark.col, 0);
- MIN_IT (selection.mark.col, (int32_t)TermWin.ncol - 1);
+ MIN_IT (selection.mark.col, (int32_t)ncol - 1);
while (selection.mark.col > 0
- && screen.text[selection.mark.row + TermWin.saveLines][selection.mark.col] == NOCHAR)
+ && save[selection.mark.row + saveLines].t[selection.mark.col] == NOCHAR)
--selection.mark.col;
if (selection.op)
if (dirn == UP)
{
- bound.row = TermWin.saveLines - TermWin.nscrolled - 1;
+ bound.row = saveLines - nscrolled - 1;
bound.col = 0;
dirnadd = -1;
}
else
{
- bound.row = TermWin.saveLines + TermWin.nrow;
- bound.col = TermWin.ncol - 1;
+ bound.row = saveLines + nrow;
+ bound.col = ncol - 1;
dirnadd = 1;
}
- row = mark->row + TermWin.saveLines;
+ row = mark->row + saveLines;
col = mark->col;
MAX_IT (col, 0);
/* find the edge of a word */
- stp = &screen.text[row][col];
+ stp = &save[row].t[col];
w1 = DELIMIT_TEXT (*stp);
- srp = &screen.rend[row][col];
+ srp = &save[row].r[col];
w2 = DELIMIT_REND (*srp);
for (;;)
if ((col == bound.col) && (row != bound.row))
{
- if (screen.tlen[ (row - (dirn == UP ? 1 : 0))] == -1)
+ if (save[ (row - (dirn == UP ? 1 : 0))].l == -1)
{
trow = row + dirnadd;
- tcol = dirn == UP ? TermWin.ncol - 1 : 0;
+ tcol = dirn == UP ? ncol - 1 : 0;
- if (screen.text[trow] == NULL)
+ if (save[trow].t == NULL)
break;
- stp = & (screen.text[trow][tcol]);
- srp = & (screen.rend[trow][tcol]);
+ stp = & (save[trow].t[tcol]);
+ srp = & (save[trow].r[tcol]);
if (DELIMIT_TEXT (*stp) != w1 || DELIMIT_REND (*srp) != w2)
break;
col++; /* put us on one past the end */
/* Poke the values back in */
- ret->row = row - TermWin.saveLines;
+ ret->row = row - saveLines;
ret->col = col;
}
col = Pixel2Col (x);
row = Pixel2Row (y);
MAX_IT (row, 0);
- MIN_IT (row, (int)TermWin.nrow - 1);
+ MIN_IT (row, (int)nrow - 1);
MAX_IT (col, 0);
- MIN_IT (col, (int)TermWin.ncol);
+ MIN_IT (col, (int)ncol);
/*
* If we're selecting characters (single click) then we must check first
*/
if (((selection.clicks % 3) == 1) && !flag
&& (col == selection.mark.col
- && (row == selection.mark.row + TermWin.view_start)))
+ && (row == selection.mark.row + view_start)))
{
/* select nothing */
selection.beg.row = selection.end.row = 0;
void
rxvt_term::selection_extend_colrow (int32_t col, int32_t row, int button3, int buttonpress, int clickchange)
{
- int16_t ncol = TermWin.ncol;
int end_col;
row_col_t pos;
enum {
pos.col = col;
pos.row = row;
- pos.row -= TermWin.view_start; /* adjust for scroll */
+ pos.row -= view_start; /* adjust for scroll */
/*
* This is mainly xterm style selection with a couple of differences, mainly
if (selection.clicks == 1)
{
- end_col = screen.tlen[selection.beg.row + TermWin.saveLines];
+ end_col = save[selection.beg.row + saveLines].l;
if (selection.beg.col > end_col
&& end_col != -1
)
selection.beg.col = ncol;
- end_col = screen.tlen[selection.end.row + TermWin.saveLines];
+ end_col = save[selection.end.row + saveLines].l;
if (
selection.end.col > end_col
int end_row;
selection_delimit_word (UP, &selection.beg, &selection.beg);
- end_row = screen.tlen[selection.mark.row + TermWin.saveLines];
+ end_row = save[selection.mark.row + saveLines].l;
- for (end_row = selection.mark.row; end_row < TermWin.nrow; end_row++)
+ for (end_row = selection.mark.row; end_row < nrow; end_row++)
{
- end_col = screen.tlen[end_row + TermWin.saveLines];
+ end_col = save[end_row + saveLines].l;
if (end_col != -1)
{
selection.end.col = ncol;
// select a complete logical line
- while (selection.beg.row > -TermWin.saveLines
- && screen.tlen[selection.beg.row - 1 + TermWin.saveLines] == -1)
+ while (selection.beg.row > -saveLines
+ && save[selection.beg.row - 1 + saveLines].l == -1)
selection.beg.row--;
- while (selection.end.row < TermWin.nrow
- && screen.tlen[selection.end.row + TermWin.saveLines] == -1)
+ while (selection.end.row < nrow
+ && save[selection.end.row + saveLines].l == -1)
selection.end.row++;
}
}
for ( ; end_row >= selection.beg.row; )
{
- stp = screen.text[end_row + TermWin.saveLines];
+ stp = save[end_row + saveLines].t;
while (--end_col >= 0)
{
}
if (end_col >= 0
- || screen.tlen[end_row - 1 + TermWin.saveLines] != -1)
+ || save[end_row - 1 + saveLines].l != -1)
{
selection.end.col = end_col + 1;
selection.end.row = end_row;
}
end_row--;
- end_col = TermWin.ncol;
+ end_col = ncol;
}
if (selection.mark.row > selection.end.row)
rxvt_term::pixel_position (int *x, int *y)
{
*x = Pixel2Col (*x);
- /* MAX_IT (*x, 0); MIN_IT (*x, (int)TermWin.ncol - 1); */
+ /* MAX_IT (*x, 0); MIN_IT (*x, (int)ncol - 1); */
*y = Pixel2Row (*y);
- /* MAX_IT (*y, 0); MIN_IT (*y, (int)TermWin.nrow - 1); */
+ /* MAX_IT (*y, 0); MIN_IT (*y, (int)nrow - 1); */
}
/* ------------------------------------------------------------------------- */
{
XWindowAttributes xwa;
- XGetWindowAttributes (display->display, TermWin.vt, &xwa);
+ XGetWindowAttributes (display->display, vt, &xwa);
pos.x = xwa.x + Col2Pixel (screen.cur.col);
- pos.y = xwa.y + Height2Pixel (screen.cur.row) + TermWin.fbase;
+ pos.y = xwa.y + Height2Pixel (screen.cur.row) + fbase;
}
#endif
void
rxvt_term::scr_overlay_new (int x, int y, int w, int h)
{
- if (TermWin.nrow < 3 || TermWin.ncol < 3)
+ if (nrow < 3 || ncol < 3)
return;
want_refresh = 1;
scr_overlay_off ();
- if (x < 0) x = TermWin.ncol - w;
- if (y < 0) y = TermWin.nrow - h;
+ if (x < 0) x = ncol - w;
+ if (y < 0) y = nrow - h;
// make space for border
- w += 2; MIN_IT (w, TermWin.ncol);
- h += 2; MIN_IT (h, TermWin.nrow);
+ w += 2; MIN_IT (w, ncol);
+ h += 2; MIN_IT (h, nrow);
x -= 1; MAX_IT (x, 0);
y -= 1; MAX_IT (y, 0);
- MIN_IT (x, TermWin.ncol - w);
- MIN_IT (y, TermWin.nrow - h);
+ MIN_IT (x, ncol - w);
+ MIN_IT (y, nrow - h);
ov_x = x; ov_y = y;
ov_w = w; ov_h = h;
if (!ov_text)
return;
- int row_offset = ov_y + TermWin.saveLines - TermWin.view_start;
+ int row_offset = ov_y + saveLines - view_start;
// swap screen mem with overlay
for (int y = ov_h; y--; )
text_t *t1 = ov_text[y];
rend_t *r1 = ov_rend[y];
- text_t *t2 = screen.text[y + row_offset] + ov_x;
- rend_t *r2 = screen.rend[y + row_offset] + ov_x;
+ text_t *t2 = save[y + row_offset].t + ov_x;
+ rend_t *r2 = save[y + row_offset].r + ov_x;
for (int x = ov_w; x--; )
{
projects / dana / urxvt.git / commitdiff