1 /* $OpenBSD: screen.c,v 1.11 2009/08/08 13:29:27 nicm Exp $ */ 2 3 /* 4 * Copyright (c) 2007 Nicholas Marriott <nicm@users.sourceforge.net> 5 * 6 * Permission to use, copy, modify, and distribute this software for any 7 * purpose with or without fee is hereby granted, provided that the above 8 * copyright notice and this permission notice appear in all copies. 9 * 10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES 11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF 12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR 13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES 14 * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER 15 * IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING 16 * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. 17 */ 18 19 #include <sys/types.h> 20 21 #include <stdlib.h> 22 #include <string.h> 23 #include <vis.h> 24 25 #include "tmux.h" 26 27 void screen_resize_x(struct screen *, u_int); 28 void screen_resize_y(struct screen *, u_int); 29 30 /* Create a new screen. */ 31 void 32 screen_init(struct screen *s, u_int sx, u_int sy, u_int hlimit) 33 { 34 s->grid = grid_create(sx, sy, hlimit); 35 36 s->title = xstrdup(""); 37 38 s->tabs = NULL; 39 40 screen_reinit(s); 41 } 42 43 /* Reinitialise screen. */ 44 void 45 screen_reinit(struct screen *s) 46 { 47 s->cx = 0; 48 s->cy = 0; 49 50 s->rupper = 0; 51 s->rlower = screen_size_y(s) - 1; 52 53 s->mode = MODE_CURSOR; 54 55 screen_reset_tabs(s); 56 57 grid_clear_lines(s->grid, s->grid->hsize, s->grid->sy); 58 59 screen_clear_selection(s); 60 } 61 62 /* Destroy a screen. */ 63 void 64 screen_free(struct screen *s) 65 { 66 if (s->tabs != NULL) 67 xfree(s->tabs); 68 xfree(s->title); 69 grid_destroy(s->grid); 70 } 71 72 /* Reset tabs to default, eight spaces apart. */ 73 void 74 screen_reset_tabs(struct screen *s) 75 { 76 u_int i; 77 78 if (s->tabs != NULL) 79 xfree(s->tabs); 80 81 if ((s->tabs = bit_alloc(screen_size_x(s))) == NULL) 82 fatal("bit_alloc failed"); 83 for (i = 8; i < screen_size_x(s); i += 8) 84 bit_set(s->tabs, i); 85 } 86 87 /* Set screen title. */ 88 void 89 screen_set_title(struct screen *s, const char *title) 90 { 91 char tmp[BUFSIZ]; 92 93 strnvis(tmp, title, sizeof tmp, VIS_OCTAL|VIS_TAB|VIS_NL); 94 95 xfree(s->title); 96 s->title = xstrdup(tmp); 97 } 98 99 /* Resize screen. */ 100 void 101 screen_resize(struct screen *s, u_int sx, u_int sy) 102 { 103 if (sx < 1) 104 sx = 1; 105 if (sy < 1) 106 sy = 1; 107 108 if (sx != screen_size_x(s)) { 109 screen_resize_x(s, sx); 110 111 /* 112 * It is unclear what should happen to tabs on resize. xterm 113 * seems to try and maintain them, rxvt resets them. Resetting 114 * is simpler and more reliable so let's do that. 115 */ 116 screen_reset_tabs(s); 117 } 118 119 if (sy != screen_size_y(s)) 120 screen_resize_y(s, sy); 121 } 122 123 void 124 screen_resize_x(struct screen *s, u_int sx) 125 { 126 struct grid *gd = s->grid; 127 128 if (sx == 0) 129 fatalx("zero size"); 130 131 /* 132 * Treat resizing horizontally simply: just ensure the cursor is 133 * on-screen and change the size. Don't bother to truncate any lines - 134 * then the data should be accessible if the size is then incrased. 135 * 136 * The only potential wrinkle is if UTF-8 double-width characters are 137 * left in the last column, but UTF-8 terminals should deal with this 138 * sanely. 139 */ 140 if (s->cx >= sx) 141 s->cx = sx - 1; 142 gd->sx = sx; 143 } 144 145 void 146 screen_resize_y(struct screen *s, u_int sy) 147 { 148 struct grid *gd = s->grid; 149 u_int needed, available, oldy, i; 150 151 if (sy == 0) 152 fatalx("zero size"); 153 oldy = screen_size_y(s); 154 155 /* 156 * When resizing: 157 * 158 * If the height is decreasing, delete lines from the bottom until 159 * hitting the cursor, then push lines from the top into the history. 160 * 161 * When increasing, pull as many lines as possible from the history to 162 * the top, then fill the remaining with blanks at the bottom. 163 */ 164 165 /* Size decreasing. */ 166 if (sy < oldy) { 167 needed = oldy - sy; 168 169 /* Delete as many lines as possible from the bottom. */ 170 available = oldy - 1 - s->cy; 171 if (available > 0) { 172 if (available > needed) 173 available = needed; 174 grid_view_delete_lines(gd, oldy - available, available); 175 } 176 needed -= available; 177 178 /* 179 * Now just increase the history size, if possible, to take 180 * over the lines which are left. If history is off, delete 181 * lines from the top. 182 * 183 * XXX Should apply history limit? 184 */ 185 available = s->cy; 186 if (gd->flags & GRID_HISTORY) 187 gd->hsize += needed; 188 else if (needed > 0 && available > 0) { 189 if (available > needed) 190 available = needed; 191 grid_view_delete_lines(gd, 0, available); 192 } 193 s->cy -= needed; 194 } 195 196 /* Resize line arrays. */ 197 gd->linedata = xrealloc( 198 gd->linedata, gd->hsize + sy, sizeof *gd->linedata); 199 200 /* Size increasing. */ 201 if (sy > oldy) { 202 needed = sy - oldy; 203 204 /* 205 * Try to pull as much as possible out of the history, if is 206 * is enabled. 207 */ 208 available = gd->hsize; 209 if (gd->flags & GRID_HISTORY && available > 0) { 210 if (available > needed) 211 available = needed; 212 gd->hsize -= available; 213 s->cy += available; 214 } else 215 available = 0; 216 needed -= available; 217 218 /* Then fill the rest in with blanks. */ 219 for (i = gd->hsize + sy - needed; i < gd->hsize + sy; i++) 220 memset(&gd->linedata[i], 0, sizeof gd->linedata[i]); 221 } 222 223 /* Set the new size, and reset the scroll region. */ 224 gd->sy = sy; 225 s->rupper = 0; 226 s->rlower = screen_size_y(s) - 1; 227 } 228 229 /* Set selection. */ 230 void 231 screen_set_selection(struct screen *s, 232 u_int sx, u_int sy, u_int ex, u_int ey, struct grid_cell *gc) 233 { 234 struct screen_sel *sel = &s->sel; 235 236 memcpy(&sel->cell, gc, sizeof sel->cell); 237 238 sel->flag = 1; 239 if (ey < sy || (sy == ey && ex < sx)) { 240 sel->sx = ex; sel->sy = ey; 241 sel->ex = sx; sel->ey = sy; 242 } else { 243 sel->sx = sx; sel->sy = sy; 244 sel->ex = ex; sel->ey = ey; 245 } 246 } 247 248 /* Clear selection. */ 249 void 250 screen_clear_selection(struct screen *s) 251 { 252 struct screen_sel *sel = &s->sel; 253 254 sel->flag = 0; 255 } 256 257 /* Check if cell in selection. */ 258 int 259 screen_check_selection(struct screen *s, u_int px, u_int py) 260 { 261 struct screen_sel *sel = &s->sel; 262 263 if (!sel->flag || py < sel->sy || py > sel->ey) 264 return (0); 265 266 if (py == sel->sy && py == sel->ey) { 267 if (px < sel->sx || px > sel->ex) 268 return (0); 269 return (1); 270 } 271 272 if ((py == sel->sy && px < sel->sx) || (py == sel->ey && px > sel->ex)) 273 return (0); 274 return (1); 275 } 276