1 /* $OpenBSD: screen.c,v 1.23 2012/07/10 11:53:01 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 <unistd.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 char hn[MAXHOSTNAMELEN]; 35 36 s->grid = grid_create(sx, sy, hlimit); 37 38 if (gethostname(hn, MAXHOSTNAMELEN) == 0) 39 s->title = xstrdup(hn); 40 else 41 s->title = xstrdup(""); 42 43 s->cstyle = 0; 44 s->ccolour = xstrdup(""); 45 s->tabs = NULL; 46 47 screen_reinit(s); 48 } 49 50 /* Reinitialise screen. */ 51 void 52 screen_reinit(struct screen *s) 53 { 54 s->cx = 0; 55 s->cy = 0; 56 57 s->rupper = 0; 58 s->rlower = screen_size_y(s) - 1; 59 60 s->mode = MODE_CURSOR | MODE_WRAP; 61 62 screen_reset_tabs(s); 63 64 grid_clear_lines(s->grid, s->grid->hsize, s->grid->sy); 65 66 screen_clear_selection(s); 67 } 68 69 /* Destroy a screen. */ 70 void 71 screen_free(struct screen *s) 72 { 73 free(s->tabs); 74 free(s->title); 75 free(s->ccolour); 76 grid_destroy(s->grid); 77 } 78 79 /* Reset tabs to default, eight spaces apart. */ 80 void 81 screen_reset_tabs(struct screen *s) 82 { 83 u_int i; 84 85 free(s->tabs); 86 87 if ((s->tabs = bit_alloc(screen_size_x(s))) == NULL) 88 fatal("bit_alloc failed"); 89 for (i = 8; i < screen_size_x(s); i += 8) 90 bit_set(s->tabs, i); 91 } 92 93 /* Set screen cursor style. */ 94 void 95 screen_set_cursor_style(struct screen *s, u_int style) 96 { 97 if (style <= 6) 98 s->cstyle = style; 99 } 100 101 /* Set screen cursor colour. */ 102 void 103 screen_set_cursor_colour(struct screen *s, const char *colour_string) 104 { 105 free(s->ccolour); 106 s->ccolour = xstrdup(colour_string); 107 } 108 109 /* Set screen title. */ 110 void 111 screen_set_title(struct screen *s, const char *title) 112 { 113 char tmp[BUFSIZ]; 114 115 strlcpy(tmp, title, sizeof tmp); 116 117 free(s->title); 118 s->title = xstrdup(tmp); 119 } 120 121 /* Resize screen. */ 122 void 123 screen_resize(struct screen *s, u_int sx, u_int sy) 124 { 125 if (sx < 1) 126 sx = 1; 127 if (sy < 1) 128 sy = 1; 129 130 if (sx != screen_size_x(s)) { 131 screen_resize_x(s, sx); 132 133 /* 134 * It is unclear what should happen to tabs on resize. xterm 135 * seems to try and maintain them, rxvt resets them. Resetting 136 * is simpler and more reliable so let's do that. 137 */ 138 screen_reset_tabs(s); 139 } 140 141 if (sy != screen_size_y(s)) 142 screen_resize_y(s, sy); 143 } 144 145 void 146 screen_resize_x(struct screen *s, u_int sx) 147 { 148 struct grid *gd = s->grid; 149 150 if (sx == 0) 151 fatalx("zero size"); 152 153 /* 154 * Treat resizing horizontally simply: just ensure the cursor is 155 * on-screen and change the size. Don't bother to truncate any lines - 156 * then the data should be accessible if the size is then incrased. 157 * 158 * The only potential wrinkle is if UTF-8 double-width characters are 159 * left in the last column, but UTF-8 terminals should deal with this 160 * sanely. 161 */ 162 if (s->cx >= sx) 163 s->cx = sx - 1; 164 gd->sx = sx; 165 } 166 167 void 168 screen_resize_y(struct screen *s, u_int sy) 169 { 170 struct grid *gd = s->grid; 171 u_int needed, available, oldy, i; 172 173 if (sy == 0) 174 fatalx("zero size"); 175 oldy = screen_size_y(s); 176 177 /* 178 * When resizing: 179 * 180 * If the height is decreasing, delete lines from the bottom until 181 * hitting the cursor, then push lines from the top into the history. 182 * 183 * When increasing, pull as many lines as possible from the history to 184 * the top, then fill the remaining with blanks at the bottom. 185 */ 186 187 /* Size decreasing. */ 188 if (sy < oldy) { 189 needed = oldy - sy; 190 191 /* Delete as many lines as possible from the bottom. */ 192 available = oldy - 1 - s->cy; 193 if (available > 0) { 194 if (available > needed) 195 available = needed; 196 grid_view_delete_lines(gd, oldy - available, available); 197 } 198 needed -= available; 199 200 /* 201 * Now just increase the history size, if possible, to take 202 * over the lines which are left. If history is off, delete 203 * lines from the top. 204 * 205 * XXX Should apply history limit? 206 */ 207 available = s->cy; 208 if (gd->flags & GRID_HISTORY) 209 gd->hsize += needed; 210 else if (needed > 0 && available > 0) { 211 if (available > needed) 212 available = needed; 213 grid_view_delete_lines(gd, 0, available); 214 } 215 s->cy -= needed; 216 } 217 218 /* Resize line arrays. */ 219 gd->linedata = xrealloc( 220 gd->linedata, gd->hsize + sy, sizeof *gd->linedata); 221 222 /* Size increasing. */ 223 if (sy > oldy) { 224 needed = sy - oldy; 225 226 /* 227 * Try to pull as much as possible out of the history, if is 228 * is enabled. 229 */ 230 available = gd->hsize; 231 if (gd->flags & GRID_HISTORY && available > 0) { 232 if (available > needed) 233 available = needed; 234 gd->hsize -= available; 235 s->cy += available; 236 } else 237 available = 0; 238 needed -= available; 239 240 /* Then fill the rest in with blanks. */ 241 for (i = gd->hsize + sy - needed; i < gd->hsize + sy; i++) 242 memset(&gd->linedata[i], 0, sizeof gd->linedata[i]); 243 } 244 245 /* Set the new size, and reset the scroll region. */ 246 gd->sy = sy; 247 s->rupper = 0; 248 s->rlower = screen_size_y(s) - 1; 249 } 250 251 /* Set selection. */ 252 void 253 screen_set_selection(struct screen *s, u_int sx, u_int sy, 254 u_int ex, u_int ey, u_int rectflag, struct grid_cell *gc) 255 { 256 struct screen_sel *sel = &s->sel; 257 258 memcpy(&sel->cell, gc, sizeof sel->cell); 259 sel->flag = 1; 260 sel->rectflag = rectflag; 261 262 sel->sx = sx; sel->sy = sy; 263 sel->ex = ex; sel->ey = ey; 264 } 265 266 /* Clear selection. */ 267 void 268 screen_clear_selection(struct screen *s) 269 { 270 struct screen_sel *sel = &s->sel; 271 272 sel->flag = 0; 273 } 274 275 /* Check if cell in selection. */ 276 int 277 screen_check_selection(struct screen *s, u_int px, u_int py) 278 { 279 struct screen_sel *sel = &s->sel; 280 281 if (!sel->flag) 282 return (0); 283 284 if (sel->rectflag) { 285 if (sel->sy < sel->ey) { 286 /* start line < end line -- downward selection. */ 287 if (py < sel->sy || py > sel->ey) 288 return (0); 289 } else if (sel->sy > sel->ey) { 290 /* start line > end line -- upward selection. */ 291 if (py > sel->sy || py < sel->ey) 292 return (0); 293 } else { 294 /* starting line == ending line. */ 295 if (py != sel->sy) 296 return (0); 297 } 298 299 /* 300 * Need to include the selection start row, but not the cursor 301 * row, which means the selection changes depending on which 302 * one is on the left. 303 */ 304 if (sel->ex < sel->sx) { 305 /* Cursor (ex) is on the left. */ 306 if (px < sel->ex) 307 return (0); 308 309 if (px > sel->sx) 310 return (0); 311 } else { 312 /* Selection start (sx) is on the left. */ 313 if (px < sel->sx) 314 return (0); 315 316 if (px > sel->ex) 317 return (0); 318 } 319 } else { 320 /* 321 * Like emacs, keep the top-left-most character, and drop the 322 * bottom-right-most, regardless of copy direction. 323 */ 324 if (sel->sy < sel->ey) { 325 /* starting line < ending line -- downward selection. */ 326 if (py < sel->sy || py > sel->ey) 327 return (0); 328 329 if ((py == sel->sy && px < sel->sx) 330 || (py == sel->ey && px > sel->ex)) 331 return (0); 332 } else if (sel->sy > sel->ey) { 333 /* starting line > ending line -- upward selection. */ 334 if (py > sel->sy || py < sel->ey) 335 return (0); 336 337 if ((py == sel->sy && px >= sel->sx) 338 || (py == sel->ey && px < sel->ex)) 339 return (0); 340 } else { 341 /* starting line == ending line. */ 342 if (py != sel->sy) 343 return (0); 344 345 if (sel->ex < sel->sx) { 346 /* cursor (ex) is on the left */ 347 if (px > sel->sx || px < sel->ex) 348 return (0); 349 } else { 350 /* selection start (sx) is on the left */ 351 if (px < sel->sx || px > sel->ex) 352 return (0); 353 } 354 } 355 } 356 357 return (1); 358 } 359