ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/rxvt-unicode/src/screen.C
(Generate patch)

Comparing rxvt-unicode/src/screen.C (file contents):
Revision 1.186 by root, Wed Dec 21 19:50:17 2005 UTC vs.
Revision 1.192 by root, Thu Dec 22 19:25:58 2005 UTC

… …
239 { 239 {
240 /* 240 /*
241 * add or delete rows as appropriate 241 * add or delete rows as appropriate
242 */ 242 */
243 243
244 printf ("resize %d:%d => %d:%d\n", prev_nrow, prev_ncol, nrow, ncol);//D
245
246 rxvt_salloc *old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t)); 244 rxvt_salloc *old_ta = talloc; talloc = new rxvt_salloc (ncol * sizeof (text_t));
247 rxvt_salloc *old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t)); 245 rxvt_salloc *old_ra = ralloc; ralloc = new rxvt_salloc (ncol * sizeof (rend_t));
248 246
249#if 0 247#if 0
250 if (nrow < prev_nrow) 248 if (nrow < prev_nrow)
… …
255 lfree (drawn_buf[row]); 253 lfree (drawn_buf[row]);
256 } 254 }
257 } 255 }
258#endif 256#endif
259 257
260 drawn_buf = (line_t *) rxvt_realloc (drawn_buf, nrow * sizeof (line_t)); 258 drawn_buf = (line_t *)rxvt_realloc (drawn_buf, nrow * sizeof (line_t));
261 temp_buf = (line_t *) rxvt_realloc (temp_buf , nrow * sizeof (line_t)); 259 temp_buf = (line_t *)rxvt_realloc (temp_buf , nrow * sizeof (line_t));
262 swap_buf = (line_t *) rxvt_realloc (swap_buf , nrow * sizeof (line_t)); 260 swap_buf = (line_t *)rxvt_realloc (swap_buf , nrow * sizeof (line_t));
263 261
264 for (int row = min (nrow, prev_nrow); row--; ) 262 for (int row = min (nrow, prev_nrow); row--; )
265 { 263 {
266 lresize (drawn_buf[row]); 264 lresize (drawn_buf[row]);
267 lresize (swap_buf [row]); 265 lresize (swap_buf [row]);
… …
273 drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE); 271 drawn_buf[row].clear (); scr_blank_screen_mem (drawn_buf[row], DEFAULT_RSTYLE);
274 } 272 }
275 273
276 line_t *old_buf = row_buf; row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t)); 274 line_t *old_buf = row_buf; row_buf = (line_t *)rxvt_calloc (total_rows, sizeof (line_t));
277 275
278 // re-wrap lines, this is rather ugly, possibly because I am too dumb
279 // to come up with a lean and mean algorithm.
280
281 int p = MOD (term_start + nrow , prev_total_rows); // previous row 276 int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row
282 int pend = MOD (term_start - nsaved, prev_total_rows); 277 int pend = MOD (term_start - nsaved , prev_total_rows);
283 int q = total_rows; // rewrapped row 278 int q = total_rows; // rewrapped row
284 279
285 while (p != pend && q > 0) 280 if (nsaved)
281 {
282 // re-wrap lines, this is rather ugly, possibly because I am too dumb
283 // to come up with a lean and mean algorithm.
284
285 row_col_t ocur = screen.cur;
286 ocur.row = MOD (term_start + ocur.row, prev_total_rows);
287
286 { 288 do
287 p = MOD (p - 1, prev_total_rows);
288
289 assert (old_buf [MOD (p, prev_total_rows)].t);
290 assert (!old_buf [MOD (p, prev_total_rows)].is_longer ());
291
292 int llen = old_buf [MOD (p, prev_total_rows)].l;
293
294 while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
295 { 289 {
296 p = MOD (p - 1, prev_total_rows); 290 p = MOD (p - 1, prev_total_rows);
291#ifdef DEBUG_STRICT
292 assert (old_buf [MOD (p, prev_total_rows)].t);
293#endif
297 294
298 llen += prev_ncol;
299 }
300
301 int qlines = llen / ncol + 1;
302 int lofs = 0; 295 int plines = 1;
296 int llen = old_buf [MOD (p, prev_total_rows)].l;
303 297
304 q -= qlines; 298 while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ())
305
306 int qrow = q;
307
308 for (; qlines--; qrow++)
309 {
310 if (qrow >= 0)
311 { 299 {
300 p = MOD (p - 1, prev_total_rows);
301
302 plines++;
303 llen += prev_ncol;
304 }
305
306 int qlines = max (0, (llen - 1) / ncol) + 1;
307
308 // drop partial lines completely
309 if (q < qlines)
310 break;
311
312 q -= qlines;
313
314 int lofs = 0;
315 line_t *qline;
316
317 // re-assemble the full line by destination lines
318 for (int qrow = q; qlines--; qrow++)
319 {
312 line_t &qline = row_buf [qrow]; 320 qline = row_buf + qrow;
313
314 lalloc (qline); 321 lalloc (*qline);
315 qline.set_is_longer (); 322 qline->set_is_longer ();
316 323
317 int qcol = 0; 324 int qcol = 0;
318 325
319 for (;;) 326 // fill a single destination line
327 while (lofs < llen && qcol < ncol)
320 { 328 {
321 int prow = lofs / prev_ncol + p; 329 int prow = lofs / prev_ncol;
322 int pcol = lofs % prev_ncol; 330 int pcol = lofs % prev_ncol;
323 331
332 prow = MOD (p + prow, prev_total_rows);
333
334 // we only adjust the cursor _row_ and put it into
335 // the topmost line of "long line" it was in, as
336 // this seems to upset applications/shells/readline
337 // least.
338 if (prow == ocur.row)
339 screen.cur.row = q - (total_rows - nrow);
340
324 line_t &pline = old_buf [p]; 341 line_t &pline = old_buf [prow];
325 342
326 int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs); 343 int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs);
327 344
328 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);
329
330 if (len <= 0)
331 {
332 qline.l = qcol;
333 scr_blank_line (qline, qcol, ncol - qcol, DEFAULT_RSTYLE);
334 break;
335 }
336
337 assert (lofs < 1000); 345 assert (len);
346 assert (pline.t);
338 347
339 memcpy (qline.t + qcol, pline.t + pcol, len * sizeof (text_t)); 348 memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t));
340 memcpy (qline.r + qcol, pline.r + pcol, len * sizeof (rend_t)); 349 memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t));
341 350
342 lofs += len; 351 lofs += len;
343 qcol += len; 352 qcol += len;
344
345 if (qcol == ncol)
346 break;
347 } 353 }
348 } 354 }
349 else 355
350 lofs += ncol; 356 qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1;
357 scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE);
351 } 358 }
359 while (p != pend && q > 0);
360
361 term_start = total_rows - nrow;
362 nsaved = term_start - q;
363
364 // make sure all terminal lines exist
365 while (nsaved < 0)
366 scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE);
367
368 }
369 else
352 } 370 {
371 // if no scrollback exists (yet), wing, instead of wrap
372
373 for (int row = min (nrow, prev_nrow); row--; )
374 {
375 line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)];
376 line_t &qline = row_buf [row];
377
378 qline = pline;
379 lresize (qline);
380 }
381
382 for (int row = prev_nrow; row < nrow; row++)
383 {
384 row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE);
385 }
386
387 term_start = 0;
388 }
389
390#ifdef DEBUG_STRICT
391 for (int i = -nsaved; i < nrow; i++)
392 assert (ROW (i).t);
393#endif
353 394
354 free (old_buf); 395 free (old_buf);
355 delete old_ta; 396 delete old_ta;
356 delete old_ra; 397 delete old_ra;
357 398
358 min_it (screen.cur.row, nrow - 1); 399 clamp_it (screen.cur.row, 0, nrow - 1);
359 min_it (screen.cur.col, ncol - 1); 400 clamp_it (screen.cur.col, 0, ncol - 1);
360 401
361 if (tabs) 402 if (tabs)
362 free (tabs); 403 free (tabs);
363 } 404 }
364 405
… …
386 free (row_buf); 427 free (row_buf);
387 free (swap_buf); 428 free (swap_buf);
388 free (drawn_buf); 429 free (drawn_buf);
389 free (temp_buf); 430 free (temp_buf);
390 free (tabs); 431 free (tabs);
432
433 row_buf = 0; // signal that we freed all the arrays
391} 434}
392 435
393/* ------------------------------------------------------------------------- */ 436/* ------------------------------------------------------------------------- */
394/* 437/*
395 * Hard reset 438 * Hard reset
… …
451 min_it (s->cur.row, nrow - 1); 494 min_it (s->cur.row, nrow - 1);
452 min_it (s->cur.col, ncol - 1); 495 min_it (s->cur.col, ncol - 1);
453#ifdef DEBUG_STRICT 496#ifdef DEBUG_STRICT
454 assert (s->cur.row >= 0); 497 assert (s->cur.row >= 0);
455 assert (s->cur.col >= 0); 498 assert (s->cur.col >= 0);
456#else /* drive with your eyes closed */
457 max_it (s->cur.row, 0);
458 max_it (s->cur.col, 0);
459#endif 499#endif
460} 500}
461 501
462/* ------------------------------------------------------------------------- */ 502/* ------------------------------------------------------------------------- */
463/* 503/*
… …
487#if NSCREENS 527#if NSCREENS
488 if (options & Opt_secondaryScreen) 528 if (options & Opt_secondaryScreen)
489 { 529 {
490 num_scr = 0; 530 num_scr = 0;
491 531
492 for (int i = nrow; i--; ) 532 for (int i = prev_nrow; i--; )
493 ::swap (ROW(i), swap_buf [i]); 533 ::swap (ROW(i), swap_buf [i]);
494 534
495 ::swap (screen.charset, swap.charset); 535 ::swap (screen.charset, swap.charset);
496 ::swap (screen.flags, swap.flags); 536 ::swap (screen.flags, swap.flags);
497 screen.flags |= Screen_VisibleCursor; 537 screen.flags |= Screen_VisibleCursor;
… …
677 717
678#ifdef DEBUG_STRICT 718#ifdef DEBUG_STRICT
679 assert (screen.cur.col < last_col); 719 assert (screen.cur.col < last_col);
680 assert (screen.cur.row < nrow 720 assert (screen.cur.row < nrow
681 && screen.cur.row >= -nsaved); 721 && screen.cur.row >= -nsaved);
682#else /* drive with your eyes closed */
683 min_it (screen.cur.col, last_col - 1);
684 clamp_it (screen.cur.row, -nsaved, nrow - 1);
685#endif 722#endif
686 row = screen.cur.row; 723 row = screen.cur.row;
687 724
688 checksel = selection.op && current_screen == selection.screen ? 1 : 0; 725 checksel = selection.op && current_screen == selection.screen ? 1 : 0;
689 726
… …
900 if (!line->is_longer ()) /* XXX: think about this */ 937 if (!line->is_longer ()) /* XXX: think about this */
901 max_it (line->l, screen.cur.col); 938 max_it (line->l, screen.cur.col);
902 939
903#ifdef DEBUG_STRICT 940#ifdef DEBUG_STRICT
904 assert (screen.cur.row >= 0); 941 assert (screen.cur.row >= 0);
905#else /* drive with your eyes closed */
906 max_it (screen.cur.row, 0);
907#endif 942#endif
908} 943}
909 944
910/* ------------------------------------------------------------------------- */ 945/* ------------------------------------------------------------------------- */
911/* 946/*
… …
1691 y = 0; 1726 y = 0;
1692 eheight = height; 1727 eheight = height;
1693 } 1728 }
1694#endif 1729#endif
1695 1730
1696#ifdef DEBUG_STRICT
1697#if 0
1698 // that's not debugging //TODO //FIXME
1699 clamp_it (x, 0, width);
1700 clamp_it (y, 0, height);
1701#endif
1702#endif
1703
1704 /* round down */ 1731 /* round down */
1705 rc[PART_BEG].col = Pixel2Col (x); 1732 rc[PART_BEG].col = Pixel2Col (x);
1706 rc[PART_BEG].row = Pixel2Row (y); 1733 rc[PART_BEG].row = Pixel2Row (y);
1707 /* round up */ 1734 /* round up */
1708 rc[PART_END].col = Pixel2Width (x + ewidth + fwidth - 1); 1735 rc[PART_END].col = Pixel2Width (x + ewidth + fwidth - 1);

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines