Mercurial > emacs
comparison src/scroll.c @ 766:b9e81bfc7ad9
entered into RCS
author | Jim Blandy <jimb@redhat.com> |
---|---|
date | Mon, 13 Jul 1992 20:56:17 +0000 (1992-07-13) |
parents | a8d94735277e |
children | 861714452cb3 |
comparison
equal
deleted
inserted
replaced
765:e4093444f9f8 | 766:b9e81bfc7ad9 |
---|---|
20 | 20 |
21 #include "config.h" | 21 #include "config.h" |
22 #include "termchar.h" | 22 #include "termchar.h" |
23 #include "lisp.h" | 23 #include "lisp.h" |
24 #include "dispextern.h" | 24 #include "dispextern.h" |
25 #include "screen.h" | 25 #include "frame.h" |
26 | 26 |
27 extern struct display_line **ophys_lines; | 27 extern struct display_line **ophys_lines; |
28 | 28 |
29 #define max(a, b) ((a) > (b) ? (a) : (b)) | 29 #define max(a, b) ((a) > (b) ? (a) : (b)) |
30 #define min(a, b) ((a) < (b) ? (a) : (b)) | 30 #define min(a, b) ((a) < (b) ? (a) : (b)) |
31 | 31 |
32 /* All costs measured in characters. | 32 /* All costs measured in characters. |
33 So no cost can exceed the area of a screen, measured in characters. | 33 So no cost can exceed the area of a frame, measured in characters. |
34 Let's hope this is never more than 15000 characters. */ | 34 Let's hope this is never more than 15000 characters. */ |
35 | 35 |
36 #define INFINITY 15000 | 36 #define INFINITY 15000 |
37 | 37 |
38 struct matrix_elt | 38 struct matrix_elt |
66 depending on whether one was just done, etc. */ | 66 depending on whether one was just done, etc. */ |
67 | 67 |
68 /* draw_cost[VPOS] is the cost of outputting new line at VPOS. | 68 /* draw_cost[VPOS] is the cost of outputting new line at VPOS. |
69 old_hash[VPOS] is the hash code of the old line at VPOS. | 69 old_hash[VPOS] is the hash code of the old line at VPOS. |
70 new_hash[VPOS] is the hash code of the new line at VPOS. | 70 new_hash[VPOS] is the hash code of the new line at VPOS. |
71 Note that these are not true screen vpos's, but relative | 71 Note that these are not true frame vpos's, but relative |
72 to the place at which the first mismatch between old and | 72 to the place at which the first mismatch between old and |
73 new contents appears. */ | 73 new contents appears. */ |
74 | 74 |
75 static void | 75 static void |
76 calculate_scrolling (screen, matrix, window_size, lines_below, | 76 calculate_scrolling (frame, matrix, window_size, lines_below, |
77 draw_cost, old_hash, new_hash, | 77 draw_cost, old_hash, new_hash, |
78 free_at_end) | 78 free_at_end) |
79 SCREEN_PTR screen; | 79 FRAME_PTR frame; |
80 /* matrix is of size window_size + 1 on each side. */ | 80 /* matrix is of size window_size + 1 on each side. */ |
81 struct matrix_elt *matrix; | 81 struct matrix_elt *matrix; |
82 int window_size; | 82 int window_size; |
83 int *draw_cost; | 83 int *draw_cost; |
84 int *old_hash; | 84 int *old_hash; |
85 int *new_hash; | 85 int *new_hash; |
86 int free_at_end; | 86 int free_at_end; |
87 { | 87 { |
88 register int i, j; | 88 register int i, j; |
89 int screen_height = SCREEN_HEIGHT (screen); | 89 int frame_height = FRAME_HEIGHT (frame); |
90 register struct matrix_elt *p, *p1; | 90 register struct matrix_elt *p, *p1; |
91 register int cost, cost1; | 91 register int cost, cost1; |
92 | 92 |
93 int lines_moved = window_size + (scroll_region_ok ? 0 : lines_below); | 93 int lines_moved = window_size + (scroll_region_ok ? 0 : lines_below); |
94 /* first_insert_cost[I] is the cost of doing the first insert-line | 94 /* first_insert_cost[I] is the cost of doing the first insert-line |
95 at the I'th line of the lines we are considering, | 95 at the I'th line of the lines we are considering, |
96 where I is origin 1 (as it is below). */ | 96 where I is origin 1 (as it is below). */ |
97 int *first_insert_cost | 97 int *first_insert_cost |
98 = &SCREEN_INSERT_COST (screen)[screen_height - 1 - lines_moved]; | 98 = &FRAME_INSERT_COST (frame)[frame_height - 1 - lines_moved]; |
99 int *first_delete_cost | 99 int *first_delete_cost |
100 = &SCREEN_DELETE_COST (screen)[screen_height - 1 - lines_moved]; | 100 = &FRAME_DELETE_COST (frame)[frame_height - 1 - lines_moved]; |
101 int *next_insert_cost | 101 int *next_insert_cost |
102 = &SCREEN_INSERTN_COST (screen)[screen_height - 1 - lines_moved]; | 102 = &FRAME_INSERTN_COST (frame)[frame_height - 1 - lines_moved]; |
103 int *next_delete_cost | 103 int *next_delete_cost |
104 = &SCREEN_DELETEN_COST (screen)[screen_height - 1 - lines_moved]; | 104 = &FRAME_DELETEN_COST (frame)[frame_height - 1 - lines_moved]; |
105 | 105 |
106 /* Discourage long scrolls on fast lines. | 106 /* Discourage long scrolls on fast lines. |
107 Don't scroll nearly a full screen height unless it saves | 107 Don't scroll nearly a full frame height unless it saves |
108 at least 1/4 second. */ | 108 at least 1/4 second. */ |
109 int extra_cost = baud_rate / (10 * 4 * SCREEN_HEIGHT (screen)); | 109 int extra_cost = baud_rate / (10 * 4 * FRAME_HEIGHT (frame)); |
110 | 110 |
111 /* initialize the top left corner of the matrix */ | 111 /* initialize the top left corner of the matrix */ |
112 matrix->writecost = 0; | 112 matrix->writecost = 0; |
113 matrix->insertcost = INFINITY; | 113 matrix->insertcost = INFINITY; |
114 matrix->deletecost = INFINITY; | 114 matrix->deletecost = INFINITY; |
138 matrix[j].insertcost = INFINITY; | 138 matrix[j].insertcost = INFINITY; |
139 matrix[j].deletecount = j; | 139 matrix[j].deletecount = j; |
140 matrix[j].insertcount = 0; | 140 matrix[j].insertcount = 0; |
141 } | 141 } |
142 | 142 |
143 /* `i' represents the vpos among new screen contents. | 143 /* `i' represents the vpos among new frame contents. |
144 `j' represents the vpos among the old screen contents. */ | 144 `j' represents the vpos among the old frame contents. */ |
145 p = matrix + window_size + 2; /* matrix [1, 1] */ | 145 p = matrix + window_size + 2; /* matrix [1, 1] */ |
146 for (i = 1; i <= window_size; i++, p++) | 146 for (i = 1; i <= window_size; i++, p++) |
147 for (j = 1; j <= window_size; j++, p++) | 147 for (j = 1; j <= window_size; j++, p++) |
148 { | 148 { |
149 /* p contains the address of matrix [i, j] */ | 149 /* p contains the address of matrix [i, j] */ |
214 } | 214 } |
215 } | 215 } |
216 | 216 |
217 /* Perform insert-lines and delete-lines operations | 217 /* Perform insert-lines and delete-lines operations |
218 according to the costs in the matrix. | 218 according to the costs in the matrix. |
219 Updates the contents of the screen to record what was done. */ | 219 Updates the contents of the frame to record what was done. */ |
220 | 220 |
221 static void | 221 static void |
222 do_scrolling (screen, matrix, window_size, unchanged_at_top) | 222 do_scrolling (frame, matrix, window_size, unchanged_at_top) |
223 SCREEN_PTR screen; | 223 FRAME_PTR frame; |
224 struct matrix_elt *matrix; | 224 struct matrix_elt *matrix; |
225 int window_size; | 225 int window_size; |
226 int unchanged_at_top; | 226 int unchanged_at_top; |
227 { | 227 { |
228 register struct matrix_elt *p; | 228 register struct matrix_elt *p; |
229 register int i, j; | 229 register int i, j; |
230 register struct screen_glyphs *current_screen; | 230 register struct frame_glyphs *current_frame; |
231 /* temp_screen->enable[i] means line i has been moved to current_screen. */ | 231 /* temp_frame->enable[i] means line i has been moved to current_frame. */ |
232 register struct screen_glyphs *temp_screen; | 232 register struct frame_glyphs *temp_frame; |
233 struct queue { int count, pos; } *queue; | 233 struct queue { int count, pos; } *queue; |
234 int offset = unchanged_at_top; | 234 int offset = unchanged_at_top; |
235 int qi = 0; | 235 int qi = 0; |
236 int window = 0; | 236 int window = 0; |
237 register int tem; | 237 register int tem; |
238 int next; | 238 int next; |
239 | 239 |
240 queue = (struct queue *) alloca (SCREEN_HEIGHT (screen) | 240 queue = (struct queue *) alloca (FRAME_HEIGHT (frame) |
241 * sizeof (struct queue)); | 241 * sizeof (struct queue)); |
242 | 242 |
243 current_screen = SCREEN_CURRENT_GLYPHS (screen); | 243 current_frame = FRAME_CURRENT_GLYPHS (frame); |
244 temp_screen = SCREEN_TEMP_GLYPHS (screen); | 244 temp_frame = FRAME_TEMP_GLYPHS (frame); |
245 | 245 |
246 bcopy (current_screen->glyphs, temp_screen->glyphs, | 246 bcopy (current_frame->glyphs, temp_frame->glyphs, |
247 current_screen->height * sizeof (GLYPH *)); | 247 current_frame->height * sizeof (GLYPH *)); |
248 bcopy (current_screen->used, temp_screen->used, | 248 bcopy (current_frame->used, temp_frame->used, |
249 current_screen->height * sizeof (int)); | 249 current_frame->height * sizeof (int)); |
250 bcopy (current_screen->highlight, temp_screen->highlight, | 250 bcopy (current_frame->highlight, temp_frame->highlight, |
251 current_screen->height * sizeof (char)); | 251 current_frame->height * sizeof (char)); |
252 bzero (temp_screen->enable, temp_screen->height * sizeof (char)); | 252 bzero (temp_frame->enable, temp_frame->height * sizeof (char)); |
253 bcopy (current_screen->bufp, temp_screen->bufp, | 253 bcopy (current_frame->bufp, temp_frame->bufp, |
254 current_screen->height * sizeof (int)); | 254 current_frame->height * sizeof (int)); |
255 | 255 |
256 #ifdef HAVE_X_WINDOWS | 256 #ifdef HAVE_X_WINDOWS |
257 if (SCREEN_IS_X (screen)) | 257 if (FRAME_IS_X (frame)) |
258 { | 258 { |
259 bcopy (current_screen->nruns, temp_screen->nruns, | 259 bcopy (current_frame->nruns, temp_frame->nruns, |
260 current_screen->height * sizeof (int)); | 260 current_frame->height * sizeof (int)); |
261 bcopy (current_screen->face_list, temp_screen->face_list, | 261 bcopy (current_frame->face_list, temp_frame->face_list, |
262 current_screen->height * sizeof (struct run *)); | 262 current_frame->height * sizeof (struct run *)); |
263 bcopy (current_screen->top_left_x, temp_screen->top_left_x, | 263 bcopy (current_frame->top_left_x, temp_frame->top_left_x, |
264 current_screen->height * sizeof (short)); | 264 current_frame->height * sizeof (short)); |
265 bcopy (current_screen->top_left_y, temp_screen->top_left_y, | 265 bcopy (current_frame->top_left_y, temp_frame->top_left_y, |
266 current_screen->height * sizeof (short)); | 266 current_frame->height * sizeof (short)); |
267 bcopy (current_screen->pix_width, temp_screen->pix_width, | 267 bcopy (current_frame->pix_width, temp_frame->pix_width, |
268 current_screen->height * sizeof (short)); | 268 current_frame->height * sizeof (short)); |
269 bcopy (current_screen->pix_height, temp_screen->pix_height, | 269 bcopy (current_frame->pix_height, temp_frame->pix_height, |
270 current_screen->height * sizeof (short)); | 270 current_frame->height * sizeof (short)); |
271 } | 271 } |
272 #endif | 272 #endif |
273 | 273 |
274 i = j = window_size; | 274 i = j = window_size; |
275 | 275 |
298 } | 298 } |
299 else | 299 else |
300 { | 300 { |
301 /* Best thing done here is no insert or delete */ | 301 /* Best thing done here is no insert or delete */ |
302 /* Old line at vpos j-1 ends up at vpos i-1 */ | 302 /* Old line at vpos j-1 ends up at vpos i-1 */ |
303 current_screen->glyphs[i + offset - 1] | 303 current_frame->glyphs[i + offset - 1] |
304 = temp_screen->glyphs[j + offset - 1]; | 304 = temp_frame->glyphs[j + offset - 1]; |
305 current_screen->used[i + offset - 1] | 305 current_frame->used[i + offset - 1] |
306 = temp_screen->used[j + offset - 1]; | 306 = temp_frame->used[j + offset - 1]; |
307 current_screen->highlight[i + offset - 1] | 307 current_frame->highlight[i + offset - 1] |
308 = temp_screen->highlight[j + offset - 1]; | 308 = temp_frame->highlight[j + offset - 1]; |
309 | 309 |
310 temp_screen->enable[j + offset - 1] = 1; | 310 temp_frame->enable[j + offset - 1] = 1; |
311 i--; | 311 i--; |
312 j--; | 312 j--; |
313 } | 313 } |
314 } | 314 } |
315 | 315 |
327 ins_del_lines (queue[i].pos, queue[i].count); | 327 ins_del_lines (queue[i].pos, queue[i].count); |
328 | 328 |
329 /* Mark the inserted lines as clear, | 329 /* Mark the inserted lines as clear, |
330 and put into them the line-contents strings | 330 and put into them the line-contents strings |
331 that were discarded during the deletions. | 331 that were discarded during the deletions. |
332 Those are the ones for which temp_screen->enable was not set. */ | 332 Those are the ones for which temp_frame->enable was not set. */ |
333 tem = queue[i].pos; | 333 tem = queue[i].pos; |
334 for (j = tem + queue[i].count - 1; j >= tem; j--) | 334 for (j = tem + queue[i].count - 1; j >= tem; j--) |
335 { | 335 { |
336 current_screen->enable[j] = 0; | 336 current_frame->enable[j] = 0; |
337 while (temp_screen->enable[next]) | 337 while (temp_frame->enable[next]) |
338 next++; | 338 next++; |
339 current_screen->glyphs[j] = temp_screen->glyphs[next++]; | 339 current_frame->glyphs[j] = temp_frame->glyphs[next++]; |
340 } | 340 } |
341 } | 341 } |
342 | 342 |
343 if (window) | 343 if (window) |
344 set_terminal_window (0); | 344 set_terminal_window (0); |
345 } | 345 } |
346 | 346 |
347 void | 347 void |
348 scrolling_1 (screen, window_size, unchanged_at_top, unchanged_at_bottom, | 348 scrolling_1 (frame, window_size, unchanged_at_top, unchanged_at_bottom, |
349 draw_cost, old_hash, new_hash, free_at_end) | 349 draw_cost, old_hash, new_hash, free_at_end) |
350 SCREEN_PTR screen; | 350 FRAME_PTR frame; |
351 int window_size, unchanged_at_top, unchanged_at_bottom; | 351 int window_size, unchanged_at_top, unchanged_at_bottom; |
352 int *draw_cost; | 352 int *draw_cost; |
353 int *old_hash; | 353 int *old_hash; |
354 int *new_hash; | 354 int *new_hash; |
355 int free_at_end; | 355 int free_at_end; |
356 { | 356 { |
357 struct matrix_elt *matrix; | 357 struct matrix_elt *matrix; |
358 matrix = ((struct matrix_elt *) | 358 matrix = ((struct matrix_elt *) |
359 alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix)); | 359 alloca ((window_size + 1) * (window_size + 1) * sizeof *matrix)); |
360 | 360 |
361 calculate_scrolling (screen, matrix, window_size, unchanged_at_bottom, | 361 calculate_scrolling (frame, matrix, window_size, unchanged_at_bottom, |
362 draw_cost, old_hash, new_hash, | 362 draw_cost, old_hash, new_hash, |
363 free_at_end); | 363 free_at_end); |
364 do_scrolling (screen, matrix, window_size, unchanged_at_top); | 364 do_scrolling (frame, matrix, window_size, unchanged_at_top); |
365 } | 365 } |
366 | 366 |
367 /* Return number of lines in common between current and desired screen contents | 367 /* Return number of lines in common between current and desired frame contents |
368 described to us only as vectors of hash codes OLDHASH and NEWHASH. | 368 described to us only as vectors of hash codes OLDHASH and NEWHASH. |
369 Consider only vpos range START to END (not including END). | 369 Consider only vpos range START to END (not including END). |
370 Ignore short lines on the assumption that | 370 Ignore short lines on the assumption that |
371 avoiding redrawing such a line will have little weight. */ | 371 avoiding redrawing such a line will have little weight. */ |
372 | 372 |
425 | 425 |
426 /* Return a measure of the cost of moving the lines | 426 /* Return a measure of the cost of moving the lines |
427 starting with vpos FROM, up to but not including vpos TO, | 427 starting with vpos FROM, up to but not including vpos TO, |
428 down by AMOUNT lines (AMOUNT may be negative). | 428 down by AMOUNT lines (AMOUNT may be negative). |
429 These are the same arguments that might be given to | 429 These are the same arguments that might be given to |
430 scroll_screen_lines to perform this scrolling. */ | 430 scroll_frame_lines to perform this scrolling. */ |
431 | 431 |
432 scroll_cost (screen, from, to, amount) | 432 scroll_cost (frame, from, to, amount) |
433 SCREEN_PTR screen; | 433 FRAME_PTR frame; |
434 int from, to, amount; | 434 int from, to, amount; |
435 { | 435 { |
436 /* Compute how many lines, at bottom of screen, | 436 /* Compute how many lines, at bottom of frame, |
437 will not be involved in actual motion. */ | 437 will not be involved in actual motion. */ |
438 int limit = to; | 438 int limit = to; |
439 int offset; | 439 int offset; |
440 int height = SCREEN_HEIGHT (screen); | 440 int height = FRAME_HEIGHT (frame); |
441 | 441 |
442 if (amount == 0) | 442 if (amount == 0) |
443 return 0; | 443 return 0; |
444 | 444 |
445 if (! scroll_region_ok) | 445 if (! scroll_region_ok) |
456 } | 456 } |
457 | 457 |
458 offset = height - limit; | 458 offset = height - limit; |
459 | 459 |
460 return | 460 return |
461 (SCREEN_INSERT_COST (screen)[offset + from] | 461 (FRAME_INSERT_COST (frame)[offset + from] |
462 + (amount - 1) * SCREEN_INSERTN_COST (screen)[offset + from] | 462 + (amount - 1) * FRAME_INSERTN_COST (frame)[offset + from] |
463 + SCREEN_DELETEN_COST (screen)[offset + to] | 463 + FRAME_DELETEN_COST (frame)[offset + to] |
464 + (amount - 1) * SCREEN_DELETE_COST (screen)[offset + to]); | 464 + (amount - 1) * FRAME_DELETE_COST (frame)[offset + to]); |
465 } | 465 } |
466 | 466 |
467 /* Calculate the line insertion/deletion | 467 /* Calculate the line insertion/deletion |
468 overhead and multiply factor values */ | 468 overhead and multiply factor values */ |
469 | 469 |
470 static void | 470 static void |
471 line_ins_del (screen, ov1, pf1, ovn, pfn, ov, mf) | 471 line_ins_del (frame, ov1, pf1, ovn, pfn, ov, mf) |
472 SCREEN_PTR screen; | 472 FRAME_PTR frame; |
473 int ov1, ovn; | 473 int ov1, ovn; |
474 int pf1, pfn; | 474 int pf1, pfn; |
475 register int *ov, *mf; | 475 register int *ov, *mf; |
476 { | 476 { |
477 register int i; | 477 register int i; |
478 register int screen_height = SCREEN_HEIGHT (screen); | 478 register int frame_height = FRAME_HEIGHT (frame); |
479 register int insert_overhead = ov1 * 10; | 479 register int insert_overhead = ov1 * 10; |
480 register int next_insert_cost = ovn * 10; | 480 register int next_insert_cost = ovn * 10; |
481 | 481 |
482 for (i = screen_height-1; i >= 0; i--) | 482 for (i = frame_height-1; i >= 0; i--) |
483 { | 483 { |
484 mf[i] = next_insert_cost / 10; | 484 mf[i] = next_insert_cost / 10; |
485 next_insert_cost += pfn; | 485 next_insert_cost += pfn; |
486 ov[i] = (insert_overhead + next_insert_cost) / 10; | 486 ov[i] = (insert_overhead + next_insert_cost) / 10; |
487 insert_overhead += pf1; | 487 insert_overhead += pf1; |
488 } | 488 } |
489 } | 489 } |
490 | 490 |
491 static void | 491 static void |
492 ins_del_costs (screen, | 492 ins_del_costs (frame, |
493 one_line_string, multi_string, | 493 one_line_string, multi_string, |
494 setup_string, cleanup_string, | 494 setup_string, cleanup_string, |
495 costvec, ncostvec, coefficient) | 495 costvec, ncostvec, coefficient) |
496 SCREEN_PTR screen; | 496 FRAME_PTR frame; |
497 char *one_line_string, *multi_string; | 497 char *one_line_string, *multi_string; |
498 char *setup_string, *cleanup_string; | 498 char *setup_string, *cleanup_string; |
499 int *costvec, *ncostvec; | 499 int *costvec, *ncostvec; |
500 int coefficient; | 500 int coefficient; |
501 { | 501 { |
502 if (multi_string) | 502 if (multi_string) |
503 line_ins_del (screen, | 503 line_ins_del (frame, |
504 string_cost (multi_string) * coefficient, | 504 string_cost (multi_string) * coefficient, |
505 per_line_cost (multi_string) * coefficient, | 505 per_line_cost (multi_string) * coefficient, |
506 0, 0, costvec, ncostvec); | 506 0, 0, costvec, ncostvec); |
507 else if (one_line_string) | 507 else if (one_line_string) |
508 line_ins_del (screen, | 508 line_ins_del (frame, |
509 string_cost (setup_string) + string_cost (cleanup_string), 0, | 509 string_cost (setup_string) + string_cost (cleanup_string), 0, |
510 string_cost (one_line_string), | 510 string_cost (one_line_string), |
511 per_line_cost (one_line_string), | 511 per_line_cost (one_line_string), |
512 costvec, ncostvec); | 512 costvec, ncostvec); |
513 else | 513 else |
514 line_ins_del (screen, | 514 line_ins_del (frame, |
515 9999, 0, 9999, 0, | 515 9999, 0, 9999, 0, |
516 costvec, ncostvec); | 516 costvec, ncostvec); |
517 } | 517 } |
518 | 518 |
519 /* Calculate the insert and delete line costs. | 519 /* Calculate the insert and delete line costs. |
520 Note that this is done even when running with a window system | 520 Note that this is done even when running with a window system |
521 because we want to know how long scrolling takes (and avoid it). | 521 because we want to know how long scrolling takes (and avoid it). |
522 This must be redone whenever the screen height changes. | 522 This must be redone whenever the frame height changes. |
523 | 523 |
524 We keep the ID costs in a precomputed array based on the position | 524 We keep the ID costs in a precomputed array based on the position |
525 at which the I or D is performed. Also, there are two kinds of ID | 525 at which the I or D is performed. Also, there are two kinds of ID |
526 costs: the "once-only" and the "repeated". This is to handle both | 526 costs: the "once-only" and the "repeated". This is to handle both |
527 those terminals that are able to insert N lines at a time (once- | 527 those terminals that are able to insert N lines at a time (once- |
528 only) and those that must repeatedly insert one line. | 528 only) and those that must repeatedly insert one line. |
529 | 529 |
530 The cost to insert N lines at line L is | 530 The cost to insert N lines at line L is |
531 [tt.t_ILov + (screen_height + 1 - L) * tt.t_ILpf] + | 531 [tt.t_ILov + (frame_height + 1 - L) * tt.t_ILpf] + |
532 N * [tt.t_ILnov + (screen_height + 1 - L) * tt.t_ILnpf] | 532 N * [tt.t_ILnov + (frame_height + 1 - L) * tt.t_ILnpf] |
533 | 533 |
534 ILov represents the basic insert line overhead. ILpf is the padding | 534 ILov represents the basic insert line overhead. ILpf is the padding |
535 required to allow the terminal time to move a line: insertion at line | 535 required to allow the terminal time to move a line: insertion at line |
536 L changes (screen_height + 1 - L) lines. | 536 L changes (frame_height + 1 - L) lines. |
537 | 537 |
538 The first bracketed expression above is the overhead; the second is | 538 The first bracketed expression above is the overhead; the second is |
539 the multiply factor. Both are dependent only on the position at | 539 the multiply factor. Both are dependent only on the position at |
540 which the insert is performed. We store the overhead in | 540 which the insert is performed. We store the overhead in |
541 SCREEN_INSERT_COST (screen) and the multiply factor in | 541 FRAME_INSERT_COST (frame) and the multiply factor in |
542 SCREEN_INSERTN_COST (screen). Note however that any insertion | 542 FRAME_INSERTN_COST (frame). Note however that any insertion |
543 must include at least one multiply factor. Rather than compute this | 543 must include at least one multiply factor. Rather than compute this |
544 as SCREEN_INSERT_COST (screen)[line]+SCREEN_INSERTN_COST (screen)[line], | 544 as FRAME_INSERT_COST (frame)[line]+FRAME_INSERTN_COST (frame)[line], |
545 we add SCREEN_INSERTN_COST (screen) into SCREEN_INSERT_COST (screen). | 545 we add FRAME_INSERTN_COST (frame) into FRAME_INSERT_COST (frame). |
546 This is reasonable because of the particular algorithm used in calcM. | 546 This is reasonable because of the particular algorithm used in calcM. |
547 | 547 |
548 Deletion is essentially the same as insertion. | 548 Deletion is essentially the same as insertion. |
549 */ | 549 */ |
550 | 550 |
551 do_line_insertion_deletion_costs (screen, | 551 do_line_insertion_deletion_costs (frame, |
552 ins_line_string, multi_ins_string, | 552 ins_line_string, multi_ins_string, |
553 del_line_string, multi_del_string, | 553 del_line_string, multi_del_string, |
554 setup_string, cleanup_string, coefficient) | 554 setup_string, cleanup_string, coefficient) |
555 SCREEN_PTR screen; | 555 FRAME_PTR frame; |
556 char *ins_line_string, *multi_ins_string; | 556 char *ins_line_string, *multi_ins_string; |
557 char *del_line_string, *multi_del_string; | 557 char *del_line_string, *multi_del_string; |
558 char *setup_string, *cleanup_string; | 558 char *setup_string, *cleanup_string; |
559 int coefficient; | 559 int coefficient; |
560 { | 560 { |
561 if (SCREEN_INSERT_COST (screen) != 0) | 561 if (FRAME_INSERT_COST (frame) != 0) |
562 { | 562 { |
563 SCREEN_INSERT_COST (screen) = | 563 FRAME_INSERT_COST (frame) = |
564 (int *) xrealloc (SCREEN_INSERT_COST (screen), | 564 (int *) xrealloc (FRAME_INSERT_COST (frame), |
565 SCREEN_HEIGHT (screen) * sizeof (int)); | 565 FRAME_HEIGHT (frame) * sizeof (int)); |
566 SCREEN_DELETEN_COST (screen) = | 566 FRAME_DELETEN_COST (frame) = |
567 (int *) xrealloc (SCREEN_DELETEN_COST (screen), | 567 (int *) xrealloc (FRAME_DELETEN_COST (frame), |
568 SCREEN_HEIGHT (screen) * sizeof (int)); | 568 FRAME_HEIGHT (frame) * sizeof (int)); |
569 SCREEN_INSERTN_COST (screen) = | 569 FRAME_INSERTN_COST (frame) = |
570 (int *) xrealloc (SCREEN_INSERTN_COST (screen), | 570 (int *) xrealloc (FRAME_INSERTN_COST (frame), |
571 SCREEN_HEIGHT (screen) * sizeof (int)); | 571 FRAME_HEIGHT (frame) * sizeof (int)); |
572 SCREEN_DELETE_COST (screen) = | 572 FRAME_DELETE_COST (frame) = |
573 (int *) xrealloc (SCREEN_DELETE_COST (screen), | 573 (int *) xrealloc (FRAME_DELETE_COST (frame), |
574 SCREEN_HEIGHT (screen) * sizeof (int)); | 574 FRAME_HEIGHT (frame) * sizeof (int)); |
575 } | 575 } |
576 else | 576 else |
577 { | 577 { |
578 SCREEN_INSERT_COST (screen) = | 578 FRAME_INSERT_COST (frame) = |
579 (int *) xmalloc (SCREEN_HEIGHT (screen) * sizeof (int)); | 579 (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); |
580 SCREEN_DELETEN_COST (screen) = | 580 FRAME_DELETEN_COST (frame) = |
581 (int *) xmalloc (SCREEN_HEIGHT (screen) * sizeof (int)); | 581 (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); |
582 SCREEN_INSERTN_COST (screen) = | 582 FRAME_INSERTN_COST (frame) = |
583 (int *) xmalloc (SCREEN_HEIGHT (screen) * sizeof (int)); | 583 (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); |
584 SCREEN_DELETE_COST (screen) = | 584 FRAME_DELETE_COST (frame) = |
585 (int *) xmalloc (SCREEN_HEIGHT (screen) * sizeof (int)); | 585 (int *) xmalloc (FRAME_HEIGHT (frame) * sizeof (int)); |
586 } | 586 } |
587 | 587 |
588 ins_del_costs (screen, | 588 ins_del_costs (frame, |
589 ins_line_string, multi_ins_string, | 589 ins_line_string, multi_ins_string, |
590 setup_string, cleanup_string, | 590 setup_string, cleanup_string, |
591 SCREEN_INSERT_COST (screen), SCREEN_INSERTN_COST (screen), | 591 FRAME_INSERT_COST (frame), FRAME_INSERTN_COST (frame), |
592 coefficient); | 592 coefficient); |
593 ins_del_costs (screen, | 593 ins_del_costs (frame, |
594 del_line_string, multi_del_string, | 594 del_line_string, multi_del_string, |
595 setup_string, cleanup_string, | 595 setup_string, cleanup_string, |
596 SCREEN_DELETEN_COST (screen), SCREEN_DELETE_COST (screen), | 596 FRAME_DELETEN_COST (frame), FRAME_DELETE_COST (frame), |
597 coefficient); | 597 coefficient); |
598 } | 598 } |