… | |
… | |
271 | 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); |
272 | } |
272 | } |
273 | |
273 | |
274 | 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)); |
275 | |
275 | |
276 | // re-wrap lines, this is rather ugly, possibly because I am too dumb |
|
|
277 | // to come up with a lean and mean algorithm. |
|
|
278 | |
|
|
279 | int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row |
276 | int p = MOD (term_start + prev_nrow, prev_total_rows); // previous row |
280 | int pend = MOD (term_start - nsaved , prev_total_rows); |
277 | int pend = MOD (term_start - nsaved , prev_total_rows); |
281 | int q = total_rows; // rewrapped row |
278 | int q = total_rows; // rewrapped row |
282 | |
279 | |
|
|
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 | |
283 | while (p != pend && q > 0) |
288 | while (p != pend && q > 0) |
284 | { |
|
|
285 | p = MOD (p - 1, prev_total_rows); |
|
|
286 | #ifdef DEBUG_STRICT |
|
|
287 | assert (old_buf [MOD (p, prev_total_rows)].t); |
|
|
288 | #endif |
|
|
289 | |
|
|
290 | int llen = old_buf [MOD (p, prev_total_rows)].l; |
|
|
291 | |
|
|
292 | while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ()) |
|
|
293 | { |
289 | { |
294 | 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 |
295 | |
294 | |
|
|
295 | int plines = 1; |
|
|
296 | int llen = old_buf [MOD (p, prev_total_rows)].l; |
|
|
297 | |
|
|
298 | while (p != pend && old_buf [MOD (p - 1, prev_total_rows)].is_longer ()) |
|
|
299 | { |
|
|
300 | p = MOD (p - 1, prev_total_rows); |
|
|
301 | |
|
|
302 | plines++; |
296 | llen += prev_ncol; |
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 | { |
|
|
320 | qline = row_buf + qrow; |
|
|
321 | lalloc (*qline); |
|
|
322 | qline->set_is_longer (); |
|
|
323 | |
|
|
324 | int qcol = 0; |
|
|
325 | |
|
|
326 | // fill a single destination line |
|
|
327 | while (lofs < llen && qcol < ncol) |
|
|
328 | { |
|
|
329 | int prow = lofs / prev_ncol; |
|
|
330 | int pcol = lofs % prev_ncol; |
|
|
331 | |
|
|
332 | prow = MOD (p + prow, prev_total_rows); |
|
|
333 | |
|
|
334 | // we only adjust the cursor _row_, as this seems to upset |
|
|
335 | // applications/shells/readline least. |
|
|
336 | if (prow == ocur.row) |
|
|
337 | screen.cur.row = qrow - (total_rows - nrow); |
|
|
338 | |
|
|
339 | line_t &pline = old_buf [prow]; |
|
|
340 | |
|
|
341 | int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs); |
|
|
342 | |
|
|
343 | assert (len); |
|
|
344 | assert (pline.t); |
|
|
345 | |
|
|
346 | memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t)); |
|
|
347 | memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t)); |
|
|
348 | |
|
|
349 | lofs += len; |
|
|
350 | qcol += len; |
|
|
351 | } |
|
|
352 | } |
|
|
353 | |
|
|
354 | qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1; |
|
|
355 | scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE); |
297 | } |
356 | } |
298 | |
357 | |
299 | int qlines = max (0, (llen - 1) / ncol) + 1; |
358 | term_start = total_rows - nrow; |
|
|
359 | view_start = 0; |
|
|
360 | nsaved = term_start - q; |
|
|
361 | |
|
|
362 | // make sure all terminal lines exist |
|
|
363 | while (nsaved < 0) |
|
|
364 | scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE); |
300 | |
365 | |
301 | // drop partial lines completely |
366 | } |
302 | if (q < qlines) |
367 | else |
303 | break; |
368 | { |
304 | |
369 | // if no scrollback exists (yet), wing, instead of wrap |
305 | q -= qlines; |
370 | |
306 | |
371 | for (int row = min (nrow, prev_nrow); row--; ) |
307 | int lofs = 0; |
|
|
308 | line_t *qline; |
|
|
309 | |
|
|
310 | // re-assemble the full line by destination lines |
|
|
311 | for (int qrow = q; qlines--; qrow++) |
|
|
312 | { |
372 | { |
313 | qline = row_buf + qrow; |
|
|
314 | lalloc (*qline); |
|
|
315 | qline->set_is_longer (); |
|
|
316 | |
|
|
317 | int qcol = 0; |
|
|
318 | |
|
|
319 | // fill a single destination line |
|
|
320 | while (lofs < llen && qcol < ncol) |
|
|
321 | { |
|
|
322 | int prow = lofs / prev_ncol; |
|
|
323 | int pcol = lofs % prev_ncol; |
|
|
324 | |
|
|
325 | line_t &pline = old_buf [MOD (p + prow, prev_total_rows)]; |
373 | line_t &pline = old_buf [MOD (term_start + row, prev_total_rows)]; |
|
|
374 | line_t &qline = row_buf [row]; |
326 | |
375 | |
327 | int len = min (min (prev_ncol - pcol, ncol - qcol), llen - lofs); |
376 | qline = pline; |
328 | |
377 | lresize (qline); |
329 | assert (len); |
|
|
330 | assert (pline.t); |
|
|
331 | |
|
|
332 | memcpy (qline->t + qcol, pline.t + pcol, len * sizeof (text_t)); |
|
|
333 | memcpy (qline->r + qcol, pline.r + pcol, len * sizeof (rend_t)); |
|
|
334 | |
|
|
335 | lofs += len; |
|
|
336 | qcol += len; |
|
|
337 | } |
|
|
338 | } |
378 | } |
339 | |
379 | |
340 | qline->l = llen < ncol ? llen : MOD (llen - 1, ncol) + 1; |
380 | for (int row = prev_nrow; row < nrow; row++) |
341 | scr_blank_line (*qline, qline->l, ncol - qline->l, DEFAULT_RSTYLE); |
381 | { |
|
|
382 | row_buf [row].clear (); scr_blank_screen_mem (row_buf [row], DEFAULT_RSTYLE); |
342 | } |
383 | } |
343 | |
384 | |
344 | term_start = total_rows - nrow; |
385 | term_start = 0; |
345 | view_start = 0; |
386 | view_start = 0; |
346 | nsaved = term_start - q; |
387 | } |
347 | |
388 | |
348 | // make sure all terminal lines exist |
389 | #ifdef DEBUG_STRICT |
349 | while (nsaved < 0) |
|
|
350 | scr_blank_screen_mem (ROW (-++nsaved), DEFAULT_RSTYLE); |
|
|
351 | |
|
|
352 | for (int i = -nsaved; i < nrow; i++) |
390 | for (int i = -nsaved; i < nrow; i++) |
353 | assert (ROW (i).t);//D |
391 | assert (ROW (i).t); |
|
|
392 | #endif |
354 | |
393 | |
355 | free (old_buf); |
394 | free (old_buf); |
356 | delete old_ta; |
395 | delete old_ta; |
357 | delete old_ra; |
396 | delete old_ra; |
358 | |
397 | |
359 | min_it (screen.cur.row, nrow - 1); |
398 | clamp_it (screen.cur.row, 0, nrow - 1); |
360 | min_it (screen.cur.col, ncol - 1); |
399 | clamp_it (screen.cur.col, 0, ncol - 1); |
361 | |
400 | |
362 | if (tabs) |
401 | if (tabs) |
363 | free (tabs); |
402 | free (tabs); |
364 | } |
403 | } |
365 | |
404 | |