« back to all changes in this revision
Viewing changes to ncurses/tty/tty_update.c
- browse files at revision 7
- compare with another revision
- download diff
- download tarball
- view history from revision 7
- Committer: Bazaar Package Importer
- Author(s): Daniel Baumann
- Date: 2008-11-30 03:43:00 UTC
- mfrom: (1.1.5 upstream)
- Revision ID: james.westby@ubuntu.com-20081130034300-lw6qrujyjmv6e32x
Tags: 5.7+20081122-2
Adding patch from Samuel Thibault to ensure that aalib checks the
value returned by Gpm_GetEvent() and only proceeds if value == 1
(Closes: #506717).
value returned by Gpm_GetEvent() and only proceeds if value == 1
(Closes: #506717).
- files added:
- debian/patches/07-gpm.dpatch
- files removed:
- misc/gen-pkgconfig.in
- files modified:
- Ada95/gen/Makefile.in
added
removed
ncurses/tty/tty_update.c
1
1
/****************************************************************************
2
* Copyright (c) 1998-2008,2009 Free Software Foundation, Inc. *
2
* Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
3
3
* *
4
4
* Permission is hereby granted, free of charge, to any person obtaining a *
5
5
* copy of this software and associated documentation files (the *
30
30
* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
31
31
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
32
32
* and: Thomas E. Dickey 1996-on *
33
* and: Juergen Pfeifer 2009 *
34
33
****************************************************************************/
35
34
36
35
/*-----------------------------------------------------------------
39
38
*
40
39
* The routine doupdate() and its dependents.
41
40
* All physical output is concentrated here (except _nc_outch()
42
* in lib_tputs.c).
41
* in lib_tputs.c).
43
42
*
44
43
*-----------------------------------------------------------------*/
45
44
46
45
#include <curses.priv.h>
47
46
48
#ifndef CUR
49
#define CUR SP_TERMTYPE
50
#endif
51
52
47
#if defined __HAIKU__ && defined __BEOS__
53
48
#undef __BEOS__
54
49
#endif
81
76
#endif
82
77
83
78
#include <ctype.h>
79
#include <term.h>
84
80
85
MODULE_ID("$Id: tty_update.c,v 1.256 2009/05/17 00:13:49 tom Exp $")
81
MODULE_ID("$Id: tty_update.c,v 1.246 2008/08/30 20:08:19 tom Exp $")
86
82
87
83
/*
88
84
* This define controls the line-breakout optimization. Every once in a
95
91
*/
96
92
#define CHECK_INTERVAL 5
97
93
98
#define FILL_BCE(sp) (sp->_coloron && !sp->_default_color && !back_color_erase)
94
#define FILL_BCE() (SP->_coloron && !SP->_default_color && !back_color_erase)
99
95
100
96
static const NCURSES_CH_T blankchar = NewChar(BLANK_TEXT);
101
97
static NCURSES_CH_T normal = NewChar(BLANK_TEXT);
107
103
*/
108
104
/* #define POSITION_DEBUG */
109
105
110
static NCURSES_INLINE NCURSES_CH_T ClrBlank(NCURSES_SP_DCLx WINDOW *win);
111
112
#if NCURSES_SP_FUNCS
113
static int ClrBottom(SCREEN *, int total);
114
static void ClearScreen(SCREEN *, NCURSES_CH_T blank);
115
static void ClrUpdate(SCREEN *);
116
static void DelChar(SCREEN *, int count);
117
static void InsStr(SCREEN *, NCURSES_CH_T * line, int count);
118
static void TransformLine(SCREEN *, int const lineno);
119
#else
106
static NCURSES_INLINE NCURSES_CH_T ClrBlank(WINDOW *win);
120
107
static int ClrBottom(int total);
121
108
static void ClearScreen(NCURSES_CH_T blank);
122
109
static void ClrUpdate(void);
123
110
static void DelChar(int count);
124
111
static void InsStr(NCURSES_CH_T * line, int count);
125
112
static void TransformLine(int const lineno);
126
#endif
127
113
128
114
#ifdef POSITION_DEBUG
129
115
/****************************************************************************
133
119
****************************************************************************/
134
120
135
121
static void
136
position_check(NCURSES_SP_DCLx int expected_y, int expected_x, char *legend)
122
position_check(int expected_y, int expected_x, char *legend)
137
123
/* check to see if the real cursor position matches the virtual */
138
124
{
139
125
char buf[20];
143
129
if (!_nc_tracing || (expected_y < 0 && expected_x < 0))
144
130
return;
145
131
146
NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
132
_nc_flush();
147
133
memset(buf, '\0', sizeof(buf));
148
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx "\033[6n"); /* only works on ANSI-compatibles */
149
NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
134
putp("\033[6n"); /* only works on ANSI-compatibles */
135
_nc_flush();
150
136
*(s = buf) = 0;
151
137
do {
152
138
int ask = sizeof(buf) - 1 - (s - buf);
166
152
if (expected_y < 0)
167
153
expected_y = y - 1;
168
154
if (y - 1 != expected_y || x - 1 != expected_x) {
169
NCURSES_SP_NAME(beep) (NCURSES_SP_ARG);
170
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
171
tparm("\033[%d;%dH",
172
expected_y + 1,
173
expected_x + 1),
174
1, NCURSES_SP_NAME(_nc_outch));
155
beep();
156
tputs(tparm("\033[%d;%dH", expected_y + 1, expected_x + 1), 1, _nc_outch);
175
157
_tracef("position seen (%d, %d) doesn't match expected one (%d, %d) in %s",
176
158
y - 1, x - 1, expected_y, expected_x, legend);
177
159
} else {
180
162
}
181
163
}
182
164
#else
183
#define position_check(sp, expected_y, expected_x, legend) /* nothing */
165
#define position_check(expected_y, expected_x, legend) /* nothing */
184
166
#endif /* POSITION_DEBUG */
185
167
186
168
/****************************************************************************
190
172
****************************************************************************/
191
173
192
174
static NCURSES_INLINE void
193
GoTo(NCURSES_SP_DCLx int const row, int const col)
175
GoTo(int const row, int const col)
194
176
{
195
177
TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",
196
row, col, SP_PARM->_cursrow, SP_PARM->_curscol));
197
198
position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo");
199
200
mvcur(SP_PARM->_cursrow, SP_PARM->_curscol, row, col);
201
position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo2");
178
row, col, SP->_cursrow, SP->_curscol));
179
180
position_check(SP->_cursrow, SP->_curscol, "GoTo");
181
182
mvcur(SP->_cursrow, SP->_curscol, row, col);
183
position_check(SP->_cursrow, SP->_curscol, "GoTo2");
202
184
}
203
185
204
186
static NCURSES_INLINE void
205
PutAttrChar(NCURSES_SP_DCLx CARG_CH_T ch)
187
PutAttrChar(CARG_CH_T ch)
206
188
{
207
189
int chlen = 1;
208
190
NCURSES_CH_T my_ch;
212
194
213
195
TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",
214
196
_tracech_t(ch),
215
SP_PARM->_cursrow, SP_PARM->_curscol));
197
SP->_cursrow, SP->_curscol));
216
198
#if USE_WIDEC_SUPPORT
217
199
/*
218
200
* If this is not a valid character, there is nothing more to do.
242
224
*/
243
225
if (is8bits(CharOf(CHDEREF(ch)))
244
226
&& (isprint(CharOf(CHDEREF(ch)))
245
|| (SP_PARM->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
246
|| (SP_PARM->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
227
|| (SP->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
228
|| (SP->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
247
229
|| (AttrOf(attr) & A_ALTCHARSET
248
230
&& ((CharOfD(ch) < ACS_LEN
249
&& SP_PARM->_acs_map != 0
250
&& SP_PARM->_acs_map[CharOfD(ch)] != 0)
231
&& SP->_acs_map != 0
232
&& SP->_acs_map[CharOfD(ch)] != 0)
251
233
|| (CharOfD(ch) >= 128))))) {
252
234
;
253
235
} else {
259
241
#endif
260
242
261
243
if ((AttrOf(attr) & A_ALTCHARSET)
262
&& SP_PARM->_acs_map != 0
244
&& SP->_acs_map != 0
263
245
&& CharOfD(ch) < ACS_LEN) {
264
246
my_ch = CHDEREF(ch); /* work around const param */
265
247
#if USE_WIDEC_SUPPORT
269
251
* character, and uses the wide-character mapping when we expect the
270
252
* normal one to be broken (by mis-design ;-).
271
253
*/
272
if (SP_PARM->_screen_acs_fix
273
&& SP_PARM->_screen_acs_map[CharOf(my_ch)]) {
254
if (SP->_screen_acs_fix
255
&& SP->_screen_acs_map[CharOf(my_ch)]) {
274
256
RemAttr(attr, A_ALTCHARSET);
275
257
my_ch = _nc_wacs[CharOf(my_ch)];
276
258
}
283
265
*/
284
266
if (AttrOf(attr) & A_ALTCHARSET) {
285
267
int j = CharOfD(ch);
286
chtype temp = UChar(SP_PARM->_acs_map[j]);
268
chtype temp = UChar(SP->_acs_map[j]);
287
269
288
if (!(SP_PARM->_screen_acs_map[j])) {
270
if (!(SP->_screen_acs_map[j])) {
289
271
RemAttr(attr, A_ALTCHARSET);
290
272
if (temp == 0)
291
273
temp = ' ';
300
282
ch = CHREF(tilde);
301
283
}
302
284
303
UpdateAttrs(SP_PARM, attr);
285
UpdateAttrs(attr);
304
286
#if !USE_WIDEC_SUPPORT
305
287
/* FIXME - we do this special case for signal handling, should see how to
306
288
* make it work for wide characters.
307
289
*/
308
if (SP_PARM->_outch != 0) {
309
SP_PARM->_outch(NCURSES_SP_ARGx UChar(ch));
290
if (SP->_outch != 0) {
291
SP->_outch(UChar(ch));
310
292
} else
311
293
#endif
312
294
{
313
PUTC(CHDEREF(ch), SP_PARM->_ofp); /* macro's fastest... */
295
PUTC(CHDEREF(ch), SP->_ofp); /* macro's fastest... */
314
296
COUNT_OUTCHARS(1);
315
297
}
316
SP_PARM->_curscol += chlen;
298
SP->_curscol += chlen;
317
299
if (char_padding) {
318
300
TPUTS_TRACE("char_padding");
319
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx char_padding);
301
putp(char_padding);
320
302
}
321
303
}
322
304
323
305
static bool
324
check_pending(NCURSES_SP_DCL0)
306
check_pending(void)
325
307
/* check for pending input */
326
308
{
327
309
bool have_pending = FALSE;
331
313
* have the refreshing slow down drastically (or stop) if there's an
332
314
* unread character available.
333
315
*/
334
if (SP_PARM->_fifohold != 0)
316
if (SP->_fifohold != 0)
335
317
return FALSE;
336
318
337
if (SP_PARM->_checkfd >= 0) {
319
if (SP->_checkfd >= 0) {
338
320
#if USE_FUNC_POLL
339
321
struct pollfd fds[1];
340
fds[0].fd = SP_PARM->_checkfd;
322
fds[0].fd = SP->_checkfd;
341
323
fds[0].events = POLLIN;
342
324
if (poll(fds, 1, 0) > 0) {
343
325
have_pending = TRUE;
365
347
ktimeout.tv_usec = 0;
366
348
367
349
FD_ZERO(&fdset);
368
FD_SET(SP_PARM->_checkfd, &fdset);
369
if (select(SP_PARM->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
350
FD_SET(SP->_checkfd, &fdset);
351
if (select(SP->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
370
352
have_pending = TRUE;
371
353
}
372
354
#endif
373
355
}
374
356
if (have_pending) {
375
SP_PARM->_fifohold = 5;
376
NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
357
SP->_fifohold = 5;
358
_nc_flush();
377
359
}
378
360
return FALSE;
379
361
}
380
362
381
363
/* put char at lower right corner */
382
364
static void
383
PutCharLR(NCURSES_SP_DCLx const ARG_CH_T ch)
365
PutCharLR(const ARG_CH_T ch)
384
366
{
385
367
if (!auto_right_margin) {
386
368
/* we can put the char directly */
387
PutAttrChar(NCURSES_SP_ARGx ch);
369
PutAttrChar(ch);
388
370
} else if (enter_am_mode && exit_am_mode) {
389
371
/* we can suppress automargin */
390
372
TPUTS_TRACE("exit_am_mode");
391
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_am_mode);
373
putp(exit_am_mode);
392
374
393
PutAttrChar(NCURSES_SP_ARGx ch);
394
SP_PARM->_curscol--;
395
position_check(SP_PARM,
396
SP_PARM->_cursrow,
397
SP_PARM->_curscol,
398
"exit_am_mode");
375
PutAttrChar(ch);
376
SP->_curscol--;
377
position_check(SP->_cursrow, SP->_curscol, "exit_am_mode");
399
378
400
379
TPUTS_TRACE("enter_am_mode");
401
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx enter_am_mode);
380
putp(enter_am_mode);
402
381
} else if ((enter_insert_mode && exit_insert_mode)
403
382
|| insert_character || parm_ich) {
404
GoTo(NCURSES_SP_ARGx
405
screen_lines(SP_PARM) - 1,
406
screen_columns(SP_PARM) - 2);
407
PutAttrChar(NCURSES_SP_ARGx ch);
408
GoTo(NCURSES_SP_ARGx
409
screen_lines(SP_PARM) - 1,
410
screen_columns(SP_PARM) - 2);
411
InsStr(NCURSES_SP_ARGx
412
NewScreen(SP_PARM)->_line[screen_lines(SP_PARM) - 1].text +
413
screen_columns(SP_PARM) - 2, 1);
383
GoTo(screen_lines - 1, screen_columns - 2);
384
PutAttrChar(ch);
385
GoTo(screen_lines - 1, screen_columns - 2);
386
InsStr(newscr->_line[screen_lines - 1].text + screen_columns - 2, 1);
414
387
}
415
388
}
416
389
418
391
* Wrap the cursor position, i.e., advance to the beginning of the next line.
419
392
*/
420
393
static void
421
wrap_cursor(NCURSES_SP_DCL0)
394
wrap_cursor(void)
422
395
{
423
396
if (eat_newline_glitch) {
424
397
/*
434
407
* it's safe to just tell the code that the cursor is in hyperspace and
435
408
* let the next mvcur() call straighten things out.
436
409
*/
437
SP_PARM->_curscol = -1;
438
SP_PARM->_cursrow = -1;
410
SP->_curscol = -1;
411
SP->_cursrow = -1;
439
412
} else if (auto_right_margin) {
440
SP_PARM->_curscol = 0;
441
SP_PARM->_cursrow++;
413
SP->_curscol = 0;
414
SP->_cursrow++;
442
415
/*
443
416
* We've actually moved - but may have to work around problems with
444
417
* video attributes not working.
445
418
*/
446
if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP_PARM))) {
419
if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP))) {
447
420
TR(TRACE_CHARPUT, ("turning off (%#lx) %s before wrapping",
448
(unsigned long) AttrOf(SCREEN_ATTRS(SP_PARM)),
449
_traceattr(AttrOf(SCREEN_ATTRS(SP_PARM)))));
450
(void) VIDATTR(SP_PARM, A_NORMAL, 0);
421
(unsigned long) AttrOf(SCREEN_ATTRS(SP)),
422
_traceattr(AttrOf(SCREEN_ATTRS(SP)))));
423
(void) VIDATTR(A_NORMAL, 0);
451
424
}
452
425
} else {
453
SP_PARM->_curscol--;
426
SP->_curscol--;
454
427
}
455
position_check(SP_PARM,
456
SP_PARM->_cursrow,
457
SP_PARM->_curscol,
458
"wrap_cursor");
428
position_check(SP->_cursrow, SP->_curscol, "wrap_cursor");
459
429
}
460
430
461
431
static NCURSES_INLINE void
462
PutChar(NCURSES_SP_DCLx const ARG_CH_T ch)
432
PutChar(const ARG_CH_T ch)
463
433
/* insert character, handling automargin stuff */
464
434
{
465
if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1 &&
466
SP_PARM->_curscol == screen_columns(SP_PARM) - 1) {
467
PutCharLR(NCURSES_SP_ARGx ch);
468
} else {
469
PutAttrChar(NCURSES_SP_ARGx ch);
470
}
471
472
if (SP_PARM->_curscol >= screen_columns(SP_PARM))
473
wrap_cursor(NCURSES_SP_ARG);
474
475
position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
435
if (SP->_cursrow == screen_lines - 1 && SP->_curscol == screen_columns - 1)
436
PutCharLR(ch);
437
else
438
PutAttrChar(ch);
439
440
if (SP->_curscol >= screen_columns)
441
wrap_cursor();
442
443
position_check(SP->_cursrow, SP->_curscol, "PutChar");
476
444
}
477
445
478
446
/*
482
450
* or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.
483
451
*/
484
452
static NCURSES_INLINE bool
485
can_clear_with(NCURSES_SP_DCLx ARG_CH_T ch)
453
can_clear_with(ARG_CH_T ch)
486
454
{
487
if (!back_color_erase && SP_PARM->_coloron) {
455
if (!back_color_erase && SP->_coloron) {
488
456
#if NCURSES_EXT_FUNCS
489
457
int pair;
490
458
491
if (!SP_PARM->_default_color)
459
if (!SP->_default_color)
492
460
return FALSE;
493
if (SP_PARM->_default_fg != C_MASK || SP_PARM->_default_bg != C_MASK)
461
if (SP->_default_fg != C_MASK || SP->_default_bg != C_MASK)
494
462
return FALSE;
495
463
if ((pair = GetPair(CHDEREF(ch))) != 0) {
496
464
short fg, bg;
497
NCURSES_SP_NAME(pair_content) (NCURSES_SP_ARGx pair, &fg, &bg);
465
pair_content(pair, &fg, &bg);
498
466
if (fg != C_MASK || bg != C_MASK)
499
467
return FALSE;
500
468
}
520
488
* This code is optimized using ech and rep.
521
489
*/
522
490
static int
523
EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num)
491
EmitRange(const NCURSES_CH_T * ntext, int num)
524
492
{
525
493
int i;
526
494
532
500
NCURSES_CH_T ntext0;
533
501
534
502
while (num > 1 && !CharEq(ntext[0], ntext[1])) {
535
PutChar(NCURSES_SP_ARGx CHREF(ntext[0]));
503
PutChar(CHREF(ntext[0]));
536
504
ntext++;
537
505
num--;
538
506
}
539
507
ntext0 = ntext[0];
540
508
if (num == 1) {
541
PutChar(NCURSES_SP_ARGx CHREF(ntext0));
509
PutChar(CHREF(ntext0));
542
510
return 0;
543
511
}
544
512
runcount = 2;
555
523
* which it would be marginally advantageous.
556
524
*/
557
525
if (erase_chars
558
&& runcount > SP_PARM->_ech_cost + SP_PARM->_cup_ch_cost
559
&& can_clear_with(NCURSES_SP_ARGx CHREF(ntext0))) {
560
UpdateAttrs(SP_PARM, ntext0);
561
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx TPARM_1(erase_chars, runcount));
526
&& runcount > SP->_ech_cost + SP->_cup_ch_cost
527
&& can_clear_with(CHREF(ntext0))) {
528
UpdateAttrs(ntext0);
529
putp(TPARM_1(erase_chars, runcount));
562
530
563
531
/*
564
532
* If this is the last part of the given interval,
566
534
* last update on the line.
567
535
*/
568
536
if (runcount < num) {
569
GoTo(NCURSES_SP_ARGx
570
SP_PARM->_cursrow,
571
SP_PARM->_curscol + runcount);
537
GoTo(SP->_cursrow, SP->_curscol + runcount);
572
538
} else {
573
539
return 1; /* cursor stays in the middle */
574
540
}
575
} else if (repeat_char && runcount > SP_PARM->_rep_cost) {
576
bool wrap_possible = (SP_PARM->_curscol + runcount >=
577
screen_columns(SP_PARM));
541
} else if (repeat_char && runcount > SP->_rep_cost) {
542
bool wrap_possible = (SP->_curscol + runcount >= screen_columns);
578
543
int rep_count = runcount;
579
544
580
545
if (wrap_possible)
581
546
rep_count--;
582
547
583
UpdateAttrs(SP_PARM, ntext0);
584
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
585
TPARM_2(repeat_char,
586
CharOf(ntext0),
587
rep_count),
588
rep_count,
589
NCURSES_SP_NAME(_nc_outch));
590
SP_PARM->_curscol += rep_count;
548
UpdateAttrs(ntext0);
549
tputs(TPARM_2(repeat_char, CharOf(ntext0), rep_count),
550
rep_count, _nc_outch);
551
SP->_curscol += rep_count;
591
552
592
553
if (wrap_possible)
593
PutChar(NCURSES_SP_ARGx CHREF(ntext0));
554
PutChar(CHREF(ntext0));
594
555
} else {
595
556
for (i = 0; i < runcount; i++)
596
PutChar(NCURSES_SP_ARGx CHREF(ntext[i]));
557
PutChar(CHREF(ntext[i]));
597
558
}
598
559
ntext += runcount;
599
560
num -= runcount;
602
563
}
603
564
604
565
for (i = 0; i < num; i++)
605
PutChar(NCURSES_SP_ARGx CHREF(ntext[i]));
566
PutChar(CHREF(ntext[i]));
606
567
return 0;
607
568
}
608
569
615
576
* Returns: same as EmitRange
616
577
*/
617
578
static int
618
PutRange(NCURSES_SP_DCLx
619
const NCURSES_CH_T * otext,
579
PutRange(const NCURSES_CH_T * otext,
620
580
const NCURSES_CH_T * ntext,
621
581
int row,
622
582
int first, int last)
623
583
{
624
584
int i, j, same;
625
585
626
TR(TRACE_CHARPUT, ("PutRange(%p, %p, %p, %d, %d, %d)",
627
SP_PARM, otext, ntext, row, first, last));
586
TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",
587
otext, ntext, row, first, last));
628
588
629
589
if (otext != ntext
630
&& (last - first + 1) > SP_PARM->_inline_cost) {
590
&& (last - first + 1) > SP->_inline_cost) {
631
591
for (j = first, same = 0; j <= last; j++) {
632
592
if (!same && isWidecExt(otext[j]))
633
593
continue;
634
594
if (CharEq(otext[j], ntext[j])) {
635
595
same++;
636
596
} else {
637
if (same > SP_PARM->_inline_cost) {
638
EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
639
GoTo(NCURSES_SP_ARGx row, first = j);
597
if (same > SP->_inline_cost) {
598
EmitRange(ntext + first, j - same - first);
599
GoTo(row, first = j);
640
600
}
641
601
same = 0;
642
602
}
643
603
}
644
i = EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
604
i = EmitRange(ntext + first, j - same - first);
645
605
/*
646
606
* Always return 1 for the next GoTo() after a PutRange() if we found
647
607
* identical characters at end of interval
648
608
*/
649
609
return (same == 0 ? i : 1);
650
610
}
651
return EmitRange(NCURSES_SP_ARGx ntext + first, last - first + 1);
611
return EmitRange(ntext + first, last - first + 1);
652
612
}
653
613
654
614
/* leave unbracketed here so 'indent' works */
658
618
if_USE_SCROLL_HINTS(win->_line[row].oldindex = row)
659
619
660
620
NCURSES_EXPORT(int)
661
NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0)
621
doupdate(void)
662
622
{
663
623
int i;
664
624
int nonempty;
668
628
669
629
T((T_CALLED("doupdate()")));
670
630
671
#if !USE_REENTRANT
672
/*
673
* It is "legal" but unlikely that an application could assign a new
674
* value to one of the standard windows. Check for that possibility
675
* and try to recover.
676
*
677
* We do not allow applications to assign new values in the reentrant
678
* model.
679
*/
680
#define SyncScreens(internal,exported) \
681
if (internal == 0) internal = exported; \
682
if (internal != exported) exported = internal
683
684
SyncScreens(CurScreen(SP_PARM), curscr);
685
SyncScreens(NewScreen(SP_PARM), newscr);
686
SyncScreens(StdScreen(SP_PARM), stdscr);
687
#endif
688
689
if (CurScreen(SP_PARM) == 0
690
|| NewScreen(SP_PARM) == 0
691
|| StdScreen(SP_PARM) == 0)
631
if (curscr == 0
632
|| newscr == 0)
692
633
returnCode(ERR);
693
634
694
635
#ifdef TRACE
695
636
if (USE_TRACEF(TRACE_UPDATE)) {
696
if (CurScreen(SP_PARM)->_clear)
637
if (curscr->_clear)
697
638
_tracef("curscr is clear");
698
639
else
699
_tracedump("curscr", CurScreen(SP_PARM));
700
_tracedump("newscr", NewScreen(SP_PARM));
640
_tracedump("curscr", curscr);
641
_tracedump("newscr", newscr);
701
642
_nc_unlock_global(tracef);
702
643
}
703
644
#endif /* TRACE */
704
645
705
646
_nc_signal_handler(FALSE);
706
647
707
if (SP_PARM->_fifohold)
708
SP_PARM->_fifohold--;
648
if (SP->_fifohold)
649
SP->_fifohold--;
709
650
710
651
#if USE_SIZECHANGE
711
if (SP_PARM->_endwin || _nc_handle_sigwinch(SP_PARM)) {
652
if (SP->_endwin || _nc_handle_sigwinch(SP)) {
712
653
/*
713
654
* This is a transparent extension: XSI does not address it,
714
655
* and applications need not know that ncurses can do it.
717
658
* (this can happen in an xterm, for example), and resize the
718
659
* ncurses data structures accordingly.
719
660
*/
720
_nc_update_screensize(SP_PARM);
661
_nc_update_screensize(SP);
721
662
}
722
663
#endif
723
664
724
if (SP_PARM->_endwin) {
665
if (SP->_endwin) {
725
666
726
667
T(("coming back from shell mode"));
727
NCURSES_SP_NAME(reset_prog_mode) (NCURSES_SP_ARG);
728
729
NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_ARG);
730
NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
731
SP_PARM->_mouse_resume(SP_PARM);
732
733
SP_PARM->_endwin = FALSE;
668
reset_prog_mode();
669
670
_nc_mvcur_resume();
671
_nc_screen_resume();
672
SP->_mouse_resume(SP);
673
674
SP->_endwin = FALSE;
734
675
}
735
676
#if USE_TRACE_TIMES
736
677
/* zero the metering machinery */
754
695
int j, k;
755
696
attr_t rattr = A_NORMAL;
756
697
757
for (i = 0; i < screen_lines(SP_PARM); i++) {
758
for (j = 0; j < screen_columns(SP_PARM); j++) {
698
for (i = 0; i < screen_lines; i++) {
699
for (j = 0; j < screen_columns; j++) {
759
700
bool failed = FALSE;
760
NCURSES_CH_T *thisline = NewScreen(SP_PARM)->_line[i].text;
761
attr_t thisattr = AttrOf(thisline[j]) & SP_PARM->_xmc_triggers;
701
NCURSES_CH_T *thisline = newscr->_line[i].text;
702
attr_t thisattr = AttrOf(thisline[j]) & SP->_xmc_triggers;
762
703
attr_t turnon = thisattr & ~rattr;
763
704
764
705
/* is an attribute turned on here? */
776
717
* there's enough room to set the attribute before the first
777
718
* non-blank in the run.
778
719
*/
779
#define SAFE(scr,a) (!((a) & (scr)->_xmc_triggers))
780
if (ISBLANK(thisline[j]) && SAFE(SP_PARM, turnon)) {
720
#define SAFE(a) (!((a) & SP->_xmc_triggers))
721
if (ISBLANK(thisline[j]) && SAFE(turnon)) {
781
722
RemAttr(thisline[j], turnon);
782
723
continue;
783
724
}
786
727
for (k = 1; k <= magic_cookie_glitch; k++) {
787
728
if (j - k < 0
788
729
|| !ISBLANK(thisline[j - k])
789
|| !SAFE(SP_PARM, AttrOf(thisline[j - k]))) {
730
|| !SAFE(AttrOf(thisline[j - k]))) {
790
731
failed = TRUE;
791
732
TR(TRACE_ATTRS, ("No room at start in %d,%d%s%s",
792
733
i, j - k,
793
734
(ISBLANK(thisline[j - k])
794
735
? ""
795
736
: ":nonblank"),
796
(SAFE(SP_PARM, AttrOf(thisline[j - k]))
737
(SAFE(AttrOf(thisline[j - k]))
797
738
? ""
798
739
: ":unsafe")));
799
740
break;
804
745
int m, n = j;
805
746
806
747
/* find end of span, if it's onscreen */
807
for (m = i; m < screen_lines(SP_PARM); m++) {
808
for (; n < screen_columns(SP_PARM); n++) {
809
attr_t testattr
810
= AttrOf(NewScreen(SP_PARM)->_line[m].text[n]);
811
812
if ((testattr & SP_PARM->_xmc_triggers) == rattr) {
748
for (m = i; m < screen_lines; m++) {
749
for (; n < screen_columns; n++) {
750
attr_t testattr = AttrOf(newscr->_line[m].text[n]);
751
if ((testattr & SP->_xmc_triggers) == rattr) {
813
752
end_onscreen = TRUE;
814
753
TR(TRACE_ATTRS,
815
754
("Range attributed with %s ends at (%d, %d)",
825
764
foundit:;
826
765
827
766
if (end_onscreen) {
828
NCURSES_CH_T *lastline =
829
NewScreen(SP_PARM)->_line[m].text;
767
NCURSES_CH_T *lastline = newscr->_line[m].text;
830
768
831
769
/*
832
770
* If there are safely-attributed blanks at the end of
835
773
*/
836
774
while (n >= 0
837
775
&& ISBLANK(lastline[n])
838
&& SAFE(SP_PARM, AttrOf(lastline[n]))) {
776
&& SAFE(AttrOf(lastline[n]))) {
839
777
RemAttr(lastline[n--], turnon);
840
778
}
841
779
842
780
/* check that there's enough room at end of span */
843
781
for (k = 1; k <= magic_cookie_glitch; k++) {
844
if (n + k >= screen_columns(SP_PARM)
782
if (n + k >= screen_columns
845
783
|| !ISBLANK(lastline[n + k])
846
|| !SAFE(SP_PARM, AttrOf(lastline[n + k]))) {
784
|| !SAFE(AttrOf(lastline[n + k]))) {
847
785
failed = TRUE;
848
786
TR(TRACE_ATTRS,
849
787
("No room at end in %d,%d%s%s",
851
789
(ISBLANK(lastline[n + k])
852
790
? ""
853
791
: ":nonblank"),
854
(SAFE(SP_PARM, AttrOf(lastline[n + k]))
792
(SAFE(AttrOf(lastline[n + k]))
855
793
? ""
856
794
: ":unsafe")));
857
795
break;
868
806
_traceattr(turnon), i, j));
869
807
870
808
/* turn off new attributes over span */
871
for (p = i; p < screen_lines(SP_PARM); p++) {
872
for (; q < screen_columns(SP_PARM); q++) {
873
attr_t testattr =
874
AttrOf(NewScreen(SP_PARM)->_line[p].text[q]);
875
if ((testattr & SP_PARM->_xmc_triggers) == rattr)
809
for (p = i; p < screen_lines; p++) {
810
for (; q < screen_columns; q++) {
811
attr_t testattr = AttrOf(newscr->_line[p].text[q]);
812
if ((testattr & SP->_xmc_triggers) == rattr)
876
813
goto foundend;
877
RemAttr(NewScreen(SP_PARM)->_line[p].text[q], turnon);
814
RemAttr(newscr->_line[p].text[q], turnon);
878
815
}
879
816
q = 0;
880
817
}
900
837
/* show altered highlights after magic-cookie check */
901
838
if (USE_TRACEF(TRACE_UPDATE)) {
902
839
_tracef("After magic-cookie check...");
903
_tracedump("newscr", NewScreen(SP_PARM));
840
_tracedump("newscr", newscr);
904
841
_nc_unlock_global(tracef);
905
842
}
906
843
#endif /* TRACE */
908
845
#endif /* USE_XMC_SUPPORT */
909
846
910
847
nonempty = 0;
911
if (CurScreen(SP_PARM)->_clear || NewScreen(SP_PARM)->_clear) { /* force refresh ? */
912
ClrUpdate(NCURSES_SP_ARG);
913
CurScreen(SP_PARM)->_clear = FALSE; /* reset flag */
914
NewScreen(SP_PARM)->_clear = FALSE; /* reset flag */
848
if (curscr->_clear || newscr->_clear) { /* force refresh ? */
849
ClrUpdate();
850
curscr->_clear = FALSE; /* reset flag */
851
newscr->_clear = FALSE; /* reset flag */
915
852
} else {
916
853
int changedlines = CHECK_INTERVAL;
917
854
918
if (check_pending(NCURSES_SP_ARG))
855
if (check_pending())
919
856
goto cleanup;
920
857
921
nonempty = min(screen_lines(SP_PARM), NewScreen(SP_PARM)->_maxy + 1);
858
nonempty = min(screen_lines, newscr->_maxy + 1);
922
859
923
if (SP_PARM->_scrolling) {
860
if (SP->_scrolling) {
924
861
_nc_scroll_optimize();
925
862
}
926
863
927
nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
864
nonempty = ClrBottom(nonempty);
928
865
929
866
TR(TRACE_UPDATE, ("Transforming lines, nonempty %d", nonempty));
930
867
for (i = 0; i < nonempty; i++) {
932
869
* Here is our line-breakout optimization.
933
870
*/
934
871
if (changedlines == CHECK_INTERVAL) {
935
if (check_pending(NCURSES_SP_ARG))
872
if (check_pending())
936
873
goto cleanup;
937
874
changedlines = 0;
938
875
}
939
876
940
877
/*
941
* newscr.line[i].firstchar is normally set
942
* by wnoutrefresh. curscr.line[i].firstchar
878
* newscr->line[i].firstchar is normally set
879
* by wnoutrefresh. curscr->line[i].firstchar
943
880
* is normally set by _nc_scroll_window in the
944
881
* vertical-movement optimization code,
945
882
*/
946
if (NewScreen(SP_PARM)->_line[i].firstchar != _NOCHANGE
947
|| CurScreen(SP_PARM)->_line[i].firstchar != _NOCHANGE) {
948
TransformLine(NCURSES_SP_ARGx i);
883
if (newscr->_line[i].firstchar != _NOCHANGE
884
|| curscr->_line[i].firstchar != _NOCHANGE) {
885
TransformLine(i);
949
886
changedlines++;
950
887
}
951
888
952
889
/* mark line changed successfully */
953
if (i <= NewScreen(SP_PARM)->_maxy) {
954
MARK_NOCHANGE(NewScreen(SP_PARM), i);
890
if (i <= newscr->_maxy) {
891
MARK_NOCHANGE(newscr, i);
955
892
}
956
if (i <= CurScreen(SP_PARM)->_maxy) {
957
MARK_NOCHANGE(CurScreen(SP_PARM), i);
893
if (i <= curscr->_maxy) {
894
MARK_NOCHANGE(curscr, i);
958
895
}
959
896
}
960
897
}
961
898
962
899
/* put everything back in sync */
963
for (i = nonempty; i <= NewScreen(SP_PARM)->_maxy; i++) {
964
MARK_NOCHANGE(NewScreen(SP_PARM), i);
965
}
966
for (i = nonempty; i <= CurScreen(SP_PARM)->_maxy; i++) {
967
MARK_NOCHANGE(CurScreen(SP_PARM), i);
968
}
969
970
if (!NewScreen(SP_PARM)->_leaveok) {
971
CurScreen(SP_PARM)->_curx = NewScreen(SP_PARM)->_curx;
972
CurScreen(SP_PARM)->_cury = NewScreen(SP_PARM)->_cury;
973
974
GoTo(NCURSES_SP_ARGx CurScreen(SP_PARM)->_cury, CurScreen(SP_PARM)->_curx);
900
for (i = nonempty; i <= newscr->_maxy; i++) {
901
MARK_NOCHANGE(newscr, i);
902
}
903
for (i = nonempty; i <= curscr->_maxy; i++) {
904
MARK_NOCHANGE(curscr, i);
905
}
906
907
if (!newscr->_leaveok) {
908
curscr->_curx = newscr->_curx;
909
curscr->_cury = newscr->_cury;
910
911
GoTo(curscr->_cury, curscr->_curx);
975
912
}
976
913
977
914
cleanup:
984
921
#if USE_XMC_SUPPORT
985
922
if (magic_cookie_glitch != 0)
986
923
#endif
987
UpdateAttrs(SP_PARM, normal);
924
UpdateAttrs(normal);
988
925
989
NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
990
WINDOW_ATTRS(CurScreen(SP_PARM)) = WINDOW_ATTRS(NewScreen(SP_PARM));
926
_nc_flush();
927
WINDOW_ATTRS(curscr) = WINDOW_ATTRS(newscr);
991
928
992
929
#if USE_TRACE_TIMES
993
930
(void) times(&after);
1003
940
returnCode(OK);
1004
941
}
1005
942
1006
#if NCURSES_SP_FUNCS
1007
NCURSES_EXPORT(int)
1008
doupdate(void)
1009
{
1010
return NCURSES_SP_NAME(doupdate) (CURRENT_SCREEN);
1011
}
1012
#endif
1013
1014
943
/*
1015
944
* ClrBlank(win)
1016
945
*
1022
951
* in the wbkgd() call. Assume 'stdscr' for this case.
1023
952
*/
1024
953
#define BCE_ATTRS (A_NORMAL|A_COLOR)
1025
#define BCE_BKGD(win) (((win) == CurScreen(SP_PARM) ? StdScreen(SP_PARM) : (win))->_nc_bkgd)
954
#define BCE_BKGD(win) (((win) == curscr ? stdscr : (win))->_nc_bkgd)
1026
955
1027
956
static NCURSES_INLINE NCURSES_CH_T
1028
ClrBlank(NCURSES_SP_DCLx WINDOW *win)
957
ClrBlank(WINDOW *win)
1029
958
{
1030
959
NCURSES_CH_T blank = blankchar;
1031
960
if (back_color_erase)
1041
970
*/
1042
971
1043
972
static void
1044
ClrUpdate(NCURSES_SP_DCL0)
973
ClrUpdate(void)
1045
974
{
975
int i;
976
NCURSES_CH_T blank = ClrBlank(stdscr);
977
int nonempty = min(screen_lines, newscr->_maxy + 1);
978
1046
979
TR(TRACE_UPDATE, (T_CALLED("ClrUpdate")));
1047
if (0 != SP_PARM) {
1048
int i;
1049
NCURSES_CH_T blank = ClrBlank(NCURSES_SP_ARGx StdScreen(SP_PARM));
1050
int nonempty = min(screen_lines(SP_PARM),
1051
NewScreen(SP_PARM)->_maxy + 1);
1052
1053
ClearScreen(NCURSES_SP_ARGx blank);
1054
1055
TR(TRACE_UPDATE, ("updating screen from scratch"));
1056
1057
nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
1058
1059
for (i = 0; i < nonempty; i++)
1060
TransformLine(NCURSES_SP_ARGx i);
1061
}
980
981
ClearScreen(blank);
982
983
TR(TRACE_UPDATE, ("updating screen from scratch"));
984
985
nonempty = ClrBottom(nonempty);
986
987
for (i = 0; i < nonempty; i++)
988
TransformLine(i);
989
1062
990
TR(TRACE_UPDATE, (T_RETURN("")));
1063
991
}
1064
992
1069
997
*/
1070
998
1071
999
static void
1072
ClrToEOL(NCURSES_SP_DCLx NCURSES_CH_T blank, bool needclear)
1000
ClrToEOL(NCURSES_CH_T blank, bool needclear)
1073
1001
{
1074
1002
int j;
1075
1003
1076
if (CurScreen(SP_PARM) != 0
1077
&& SP_PARM->_cursrow >= 0) {
1078
for (j = SP_PARM->_curscol; j < screen_columns(SP_PARM); j++) {
1004
if (curscr != 0
1005
&& SP->_cursrow >= 0) {
1006
for (j = SP->_curscol; j < screen_columns; j++) {
1079
1007
if (j >= 0) {
1080
NCURSES_CH_T *cp =
1081
&(CurScreen(SP_PARM)->_line[SP_PARM->_cursrow].text[j]);
1008
NCURSES_CH_T *cp = &(curscr->_line[SP->_cursrow].text[j]);
1082
1009
1083
1010
if (!CharEq(*cp, blank)) {
1084
1011
*cp = blank;
1091
1018
}
1092
1019
1093
1020
if (needclear) {
1094
UpdateAttrs(SP_PARM, blank);
1021
UpdateAttrs(blank);
1095
1022
TPUTS_TRACE("clr_eol");
1096
if (clr_eol && SP_PARM->_el_cost <= (screen_columns(SP_PARM) - SP_PARM->_curscol)) {
1097
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_eol);
1023
if (clr_eol && SP->_el_cost <= (screen_columns - SP->_curscol)) {
1024
putp(clr_eol);
1098
1025
} else {
1099
int count = (screen_columns(SP_PARM) - SP_PARM->_curscol);
1026
int count = (screen_columns - SP->_curscol);
1100
1027
while (count-- > 0)
1101
PutChar(NCURSES_SP_ARGx CHREF(blank));
1028
PutChar(CHREF(blank));
1102
1029
}
1103
1030
}
1104
1031
}
1110
1037
*/
1111
1038
1112
1039
static void
1113
ClrToEOS(NCURSES_SP_DCLx NCURSES_CH_T blank)
1040
ClrToEOS(NCURSES_CH_T blank)
1114
1041
{
1115
1042
int row, col;
1116
1043
1117
if (0 == SP_PARM)
1118
return;
1119
1120
row = SP_PARM->_cursrow;
1121
col = SP_PARM->_curscol;
1122
1123
UpdateAttrs(SP_PARM, blank);
1044
row = SP->_cursrow;
1045
col = SP->_curscol;
1046
1047
UpdateAttrs(blank);
1124
1048
TPUTS_TRACE("clr_eos");
1125
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1126
clr_eos,
1127
screen_lines(SP_PARM) - row,
1128
NCURSES_SP_NAME(_nc_outch));
1129
1130
while (col < screen_columns(SP_PARM))
1131
CurScreen(SP_PARM)->_line[row].text[col++] = blank;
1132
1133
for (row++; row < screen_lines(SP_PARM); row++) {
1134
for (col = 0; col < screen_columns(SP_PARM); col++)
1135
CurScreen(SP_PARM)->_line[row].text[col] = blank;
1049
tputs(clr_eos, screen_lines - row, _nc_outch);
1050
1051
while (col < screen_columns)
1052
curscr->_line[row].text[col++] = blank;
1053
1054
for (row++; row < screen_lines; row++) {
1055
for (col = 0; col < screen_columns; col++)
1056
curscr->_line[row].text[col] = blank;
1136
1057
}
1137
1058
}
1138
1059
1144
1065
* screen, checking if each is blank, and one or more are changed.
1145
1066
*/
1146
1067
static int
1147
ClrBottom(NCURSES_SP_DCLx int total)
1068
ClrBottom(int total)
1148
1069
{
1149
1070
int row;
1150
1071
int col;
1151
1072
int top = total;
1152
int last = min(screen_columns(SP_PARM), NewScreen(SP_PARM)->_maxx + 1);
1153
NCURSES_CH_T blank = NewScreen(SP_PARM)->_line[total - 1].text[last - 1];
1073
int last = min(screen_columns, newscr->_maxx + 1);
1074
NCURSES_CH_T blank = newscr->_line[total - 1].text[last - 1];
1154
1075
bool ok;
1155
1076
1156
if (clr_eos && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
1077
if (clr_eos && can_clear_with(CHREF(blank))) {
1157
1078
1158
1079
for (row = total - 1; row >= 0; row--) {
1159
1080
for (col = 0, ok = TRUE; ok && col < last; col++) {
1160
ok = (CharEq(NewScreen(SP_PARM)->_line[row].text[col], blank));
1081
ok = (CharEq(newscr->_line[row].text[col], blank));
1161
1082
}
1162
1083
if (!ok)
1163
1084
break;
1164
1085
1165
1086
for (col = 0; ok && col < last; col++) {
1166
ok = (CharEq(CurScreen(SP_PARM)->_line[row].text[col], blank));
1087
ok = (CharEq(curscr->_line[row].text[col], blank));
1167
1088
}
1168
1089
if (!ok)
1169
1090
top = row;
1171
1092
1172
1093
/* don't use clr_eos for just one line if clr_eol available */
1173
1094
if (top < total) {
1174
GoTo(NCURSES_SP_ARGx top, 0);
1175
ClrToEOS(NCURSES_SP_ARGx blank);
1176
if (SP_PARM->oldhash && SP_PARM->newhash) {
1177
for (row = top; row < screen_lines(SP_PARM); row++)
1178
SP_PARM->oldhash[row] = SP_PARM->newhash[row];
1095
GoTo(top, 0);
1096
ClrToEOS(blank);
1097
if (SP->oldhash && SP->newhash) {
1098
for (row = top; row < screen_lines; row++)
1099
SP->oldhash[row] = SP->newhash[row];
1179
1100
}
1180
1101
}
1181
1102
}
1184
1105
1185
1106
#if USE_XMC_SUPPORT
1186
1107
#if USE_WIDEC_SUPPORT
1187
#define check_xmc_transition(sp, a, b) \
1188
((((a)->attr ^ (b)->attr) & ~((a)->attr) & (sp)->_xmc_triggers) != 0)
1189
#define xmc_turn_on(sp,a,b) check_xmc_transition(sp,&(a), &(b))
1108
#define check_xmc_transition(a, b) \
1109
((((a)->attr ^ (b)->attr) & ~((a)->attr) & SP->_xmc_triggers) != 0)
1110
#define xmc_turn_on(a,b) check_xmc_transition(&(a), &(b))
1190
1111
#else
1191
#define xmc_turn_on(sp,a,b) ((((a)^(b)) & ~(a) & (sp)->_xmc_triggers) != 0)
1112
#define xmc_turn_on(a,b) ((((a)^(b)) & ~(a) & SP->_xmc_triggers) != 0)
1192
1113
#endif
1193
1114
1194
#define xmc_new(sp,r,c) NewScreen(SP_PARM)->_line[r].text[c]
1195
#define xmc_turn_off(sp,a,b) xmc_turn_on(sp,b,a)
1115
#define xmc_new(r,c) newscr->_line[r].text[c]
1116
#define xmc_turn_off(a,b) xmc_turn_on(b,a)
1196
1117
#endif /* USE_XMC_SUPPORT */
1197
1118
1198
1119
/*
1214
1135
*/
1215
1136
1216
1137
static void
1217
TransformLine(NCURSES_SP_DCLx int const lineno)
1138
TransformLine(int const lineno)
1218
1139
{
1219
1140
int firstChar, oLastChar, nLastChar;
1220
NCURSES_CH_T *newLine = NewScreen(SP_PARM)->_line[lineno].text;
1221
NCURSES_CH_T *oldLine = CurScreen(SP_PARM)->_line[lineno].text;
1141
NCURSES_CH_T *newLine = newscr->_line[lineno].text;
1142
NCURSES_CH_T *oldLine = curscr->_line[lineno].text;
1222
1143
int n;
1223
1144
bool attrchanged = FALSE;
1224
1145
1225
TR(TRACE_UPDATE, (T_CALLED("TransformLine(%p, %d)"), SP_PARM, lineno));
1146
TR(TRACE_UPDATE, (T_CALLED("TransformLine(%d)"), lineno));
1226
1147
1227
1148
/* copy new hash value to old one */
1228
if (SP_PARM->oldhash && SP_PARM->newhash)
1229
SP_PARM->oldhash[lineno] = SP_PARM->newhash[lineno];
1149
if (SP->oldhash && SP->newhash)
1150
SP->oldhash[lineno] = SP->newhash[lineno];
1230
1151
1231
1152
/*
1232
1153
* If we have colors, there is the possibility of having two color pairs
1234
1155
* for this case, and update the old line with the new line's colors when
1235
1156
* they are equivalent.
1236
1157
*/
1237
if (SP_PARM->_coloron) {
1158
if (SP->_coloron) {
1238
1159
int oldPair;
1239
1160
int newPair;
1240
1161
1241
for (n = 0; n < screen_columns(SP_PARM); n++) {
1162
for (n = 0; n < screen_columns; n++) {
1242
1163
if (!CharEq(newLine[n], oldLine[n])) {
1243
1164
oldPair = GetPair(oldLine[n]);
1244
1165
newPair = GetPair(newLine[n]);
1245
1166
if (oldPair != newPair
1246
1167
&& unColor(oldLine[n]) == unColor(newLine[n])) {
1247
if (oldPair < SP_PARM->_pair_limit
1248
&& newPair < SP_PARM->_pair_limit
1249
&& (SP_PARM->_color_pairs[oldPair] ==
1250
SP_PARM->_color_pairs[newPair])) {
1168
if (oldPair < COLOR_PAIRS
1169
&& newPair < COLOR_PAIRS
1170
&& SP->_color_pairs[oldPair] == SP->_color_pairs[newPair]) {
1251
1171
SetPair(oldLine[n], GetPair(newLine[n]));
1252
1172
}
1253
1173
}
1257
1177
1258
1178
if (ceol_standout_glitch && clr_eol) {
1259
1179
firstChar = 0;
1260
while (firstChar < screen_columns(SP_PARM)) {
1180
while (firstChar < screen_columns) {
1261
1181
if (!SameAttrOf(newLine[firstChar], oldLine[firstChar])) {
1262
1182
attrchanged = TRUE;
1263
1183
break;
1269
1189
firstChar = 0;
1270
1190
1271
1191
if (attrchanged) { /* we may have to disregard the whole line */
1272
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1273
ClrToEOL(NCURSES_SP_ARGx
1274
ClrBlank(NCURSES_SP_ARGx CurScreen(SP_PARM)),
1275
FALSE);
1276
PutRange(NCURSES_SP_ARGx
1277
oldLine, newLine, lineno, 0,
1278
screen_columns(SP_PARM) - 1);
1192
GoTo(lineno, firstChar);
1193
ClrToEOL(ClrBlank(curscr), FALSE);
1194
PutRange(oldLine, newLine, lineno, 0, (screen_columns - 1));
1279
1195
#if USE_XMC_SUPPORT
1280
1196
1281
1197
/*
1290
1206
* following operation.
1291
1207
*/
1292
1208
} else if (magic_cookie_glitch > 0) {
1293
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1294
for (n = 0; n < screen_columns(SP_PARM); n++) {
1209
GoTo(lineno, firstChar);
1210
for (n = 0; n < screen_columns; n++) {
1295
1211
int m = n + magic_cookie_glitch;
1296
1212
1297
1213
/* check for turn-on:
1300
1216
*/
1301
1217
if (ISBLANK(newLine[n])
1302
1218
&& ((n > 0
1303
&& xmc_turn_on(SP_PARM, newLine[n - 1], newLine[n]))
1219
&& xmc_turn_on(newLine[n - 1], newLine[n]))
1304
1220
|| (n == 0
1305
1221
&& lineno > 0
1306
&& xmc_turn_on(SP_PARM,
1307
xmc_new(SP_PARM, lineno - 1,
1308
screen_columns(SP_PARM) - 1),
1222
&& xmc_turn_on(xmc_new(lineno - 1, screen_columns - 1),
1309
1223
newLine[n])))) {
1310
1224
n = m;
1311
1225
}
1312
1226
1313
PutChar(NCURSES_SP_ARGx CHREF(newLine[n]));
1227
PutChar(CHREF(newLine[n]));
1314
1228
1315
1229
/* check for turn-off:
1316
1230
* If we are writing an attributed non-blank, where the
1317
1231
* next cell is blank, and not attributed.
1318
1232
*/
1319
1233
if (!ISBLANK(newLine[n])
1320
&& ((n + 1 < screen_columns(SP_PARM)
1321
&& xmc_turn_off(SP_PARM, newLine[n], newLine[n + 1]))
1322
|| (n + 1 >= screen_columns(SP_PARM)
1323
&& lineno + 1 < screen_lines(SP_PARM)
1324
&& xmc_turn_off(SP_PARM,
1325
newLine[n],
1326
xmc_new(SP_PARM, lineno + 1, 0))))) {
1234
&& ((n + 1 < screen_columns
1235
&& xmc_turn_off(newLine[n], newLine[n + 1]))
1236
|| (n + 1 >= screen_columns
1237
&& lineno + 1 < screen_lines
1238
&& xmc_turn_off(newLine[n], xmc_new(lineno + 1, 0))))) {
1327
1239
n = m;
1328
1240
}
1329
1241
1334
1246
1335
1247
/* it may be cheap to clear leading whitespace with clr_bol */
1336
1248
blank = newLine[0];
1337
if (clr_bol && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
1249
if (clr_bol && can_clear_with(CHREF(blank))) {
1338
1250
int oFirstChar, nFirstChar;
1339
1251
1340
for (oFirstChar = 0;
1341
oFirstChar < screen_columns(SP_PARM);
1342
oFirstChar++)
1252
for (oFirstChar = 0; oFirstChar < screen_columns; oFirstChar++)
1343
1253
if (!CharEq(oldLine[oFirstChar], blank))
1344
1254
break;
1345
for (nFirstChar = 0;
1346
nFirstChar < screen_columns(SP_PARM);
1347
nFirstChar++)
1255
for (nFirstChar = 0; nFirstChar < screen_columns; nFirstChar++)
1348
1256
if (!CharEq(newLine[nFirstChar], blank))
1349
1257
break;
1350
1258
1351
1259
if (nFirstChar == oFirstChar) {
1352
1260
firstChar = nFirstChar;
1353
1261
/* find the first differing character */
1354
while (firstChar < screen_columns(SP_PARM)
1262
while (firstChar < screen_columns
1355
1263
&& CharEq(newLine[firstChar], oldLine[firstChar]))
1356
1264
firstChar++;
1357
1265
} else if (oFirstChar > nFirstChar) {
1358
1266
firstChar = nFirstChar;
1359
1267
} else { /* oFirstChar < nFirstChar */
1360
1268
firstChar = oFirstChar;
1361
if (SP_PARM->_el1_cost < nFirstChar - oFirstChar) {
1362
if (nFirstChar >= screen_columns(SP_PARM)
1363
&& SP_PARM->_el_cost <= SP_PARM->_el1_cost) {
1364
GoTo(NCURSES_SP_ARGx lineno, 0);
1365
UpdateAttrs(SP_PARM, blank);
1269
if (SP->_el1_cost < nFirstChar - oFirstChar) {
1270
if (nFirstChar >= screen_columns
1271
&& SP->_el_cost <= SP->_el1_cost) {
1272
GoTo(lineno, 0);
1273
UpdateAttrs(blank);
1366
1274
TPUTS_TRACE("clr_eol");
1367
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_eol);
1275
putp(clr_eol);
1368
1276
} else {
1369
GoTo(NCURSES_SP_ARGx lineno, nFirstChar - 1);
1370
UpdateAttrs(SP_PARM, blank);
1277
GoTo(lineno, nFirstChar - 1);
1278
UpdateAttrs(blank);
1371
1279
TPUTS_TRACE("clr_bol");
1372
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_bol);
1280
putp(clr_bol);
1373
1281
}
1374
1282
1375
1283
while (firstChar < nFirstChar)
1378
1286
}
1379
1287
} else {
1380
1288
/* find the first differing character */
1381
while (firstChar < screen_columns(SP_PARM)
1289
while (firstChar < screen_columns
1382
1290
&& CharEq(newLine[firstChar], oldLine[firstChar]))
1383
1291
firstChar++;
1384
1292
}
1385
1293
/* if there wasn't one, we're done */
1386
if (firstChar >= screen_columns(SP_PARM)) {
1294
if (firstChar >= screen_columns) {
1387
1295
TR(TRACE_UPDATE, (T_RETURN("")));
1388
1296
return;
1389
1297
}
1390
1298
1391
blank = newLine[screen_columns(SP_PARM) - 1];
1299
blank = newLine[screen_columns - 1];
1392
1300
1393
if (!can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
1301
if (!can_clear_with(CHREF(blank))) {
1394
1302
/* find the last differing character */
1395
nLastChar = screen_columns(SP_PARM) - 1;
1303
nLastChar = screen_columns - 1;
1396
1304
1397
1305
while (nLastChar > firstChar
1398
1306
&& CharEq(newLine[nLastChar], oldLine[nLastChar]))
1399
1307
nLastChar--;
1400
1308
1401
1309
if (nLastChar >= firstChar) {
1402
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1403
PutRange(NCURSES_SP_ARGx
1404
oldLine,
1405
newLine,
1406
lineno,
1407
firstChar,
1408
nLastChar);
1310
GoTo(lineno, firstChar);
1311
PutRange(oldLine, newLine, lineno, firstChar, nLastChar);
1409
1312
memcpy(oldLine + firstChar,
1410
1313
newLine + firstChar,
1411
1314
(nLastChar - firstChar + 1) * sizeof(NCURSES_CH_T));
1415
1318
}
1416
1319
1417
1320
/* find last non-blank character on old line */
1418
oLastChar = screen_columns(SP_PARM) - 1;
1321
oLastChar = screen_columns - 1;
1419
1322
while (oLastChar > firstChar && CharEq(oldLine[oLastChar], blank))
1420
1323
oLastChar--;
1421
1324
1422
1325
/* find last non-blank character on new line */
1423
nLastChar = screen_columns(SP_PARM) - 1;
1326
nLastChar = screen_columns - 1;
1424
1327
while (nLastChar > firstChar && CharEq(newLine[nLastChar], blank))
1425
1328
nLastChar--;
1426
1329
1427
1330
if ((nLastChar == firstChar)
1428
&& (SP_PARM->_el_cost < (oLastChar - nLastChar))) {
1429
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1331
&& (SP->_el_cost < (oLastChar - nLastChar))) {
1332
GoTo(lineno, firstChar);
1430
1333
if (!CharEq(newLine[firstChar], blank))
1431
PutChar(NCURSES_SP_ARGx CHREF(newLine[firstChar]));
1432
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
1334
PutChar(CHREF(newLine[firstChar]));
1335
ClrToEOL(blank, FALSE);
1433
1336
} else if ((nLastChar != oLastChar)
1434
1337
&& (!CharEq(newLine[nLastChar], oldLine[oLastChar])
1435
1338
|| !(_nc_idcok && has_ic()))) {
1436
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1437
if ((oLastChar - nLastChar) > SP_PARM->_el_cost) {
1438
if (PutRange(NCURSES_SP_ARGx
1439
oldLine,
1440
newLine,
1441
lineno,
1442
firstChar,
1443
nLastChar)) {
1444
GoTo(NCURSES_SP_ARGx lineno, nLastChar + 1);
1445
}
1446
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
1339
GoTo(lineno, firstChar);
1340
if ((oLastChar - nLastChar) > SP->_el_cost) {
1341
if (PutRange(oldLine, newLine, lineno, firstChar, nLastChar))
1342
GoTo(lineno, nLastChar + 1);
1343
ClrToEOL(blank, FALSE);
1447
1344
} else {
1448
1345
n = max(nLastChar, oLastChar);
1449
PutRange(NCURSES_SP_ARGx
1450
oldLine,
1451
newLine,
1452
lineno,
1453
firstChar,
1454
n);
1346
PutRange(oldLine, newLine, lineno, firstChar, n);
1455
1347
}
1456
1348
} else {
1457
1349
int nLastNonblank = nLastChar;
1472
1364
1473
1365
n = min(oLastChar, nLastChar);
1474
1366
if (n >= firstChar) {
1475
GoTo(NCURSES_SP_ARGx lineno, firstChar);
1476
PutRange(NCURSES_SP_ARGx
1477
oldLine,
1478
newLine,
1479
lineno,
1480
firstChar,
1481
n);
1367
GoTo(lineno, firstChar);
1368
PutRange(oldLine, newLine, lineno, firstChar, n);
1482
1369
}
1483
1370
1484
1371
if (oLastChar < nLastChar) {
1489
1376
--oLastChar;
1490
1377
}
1491
1378
#endif
1492
GoTo(NCURSES_SP_ARGx lineno, n + 1);
1379
GoTo(lineno, n + 1);
1493
1380
if ((nLastChar < nLastNonblank)
1494
|| InsCharCost(SP_PARM, nLastChar - oLastChar) > (m - n)) {
1495
PutRange(NCURSES_SP_ARGx
1496
oldLine,
1497
newLine,
1498
lineno,
1499
n + 1,
1500
m);
1381
|| InsCharCost(nLastChar - oLastChar) > (m - n)) {
1382
PutRange(oldLine, newLine, lineno, n + 1, m);
1501
1383
} else {
1502
InsStr(NCURSES_SP_ARGx &newLine[n + 1], nLastChar - oLastChar);
1384
InsStr(&newLine[n + 1], nLastChar - oLastChar);
1503
1385
}
1504
1386
} else if (oLastChar > nLastChar) {
1505
GoTo(NCURSES_SP_ARGx lineno, n + 1);
1506
if (DelCharCost(SP_PARM, oLastChar - nLastChar)
1507
> SP_PARM->_el_cost + nLastNonblank - (n + 1)) {
1508
if (PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
1387
GoTo(lineno, n + 1);
1388
if (DelCharCost(oLastChar - nLastChar)
1389
> SP->_el_cost + nLastNonblank - (n + 1)) {
1390
if (PutRange(oldLine, newLine, lineno,
1509
1391
n + 1, nLastNonblank))
1510
GoTo(NCURSES_SP_ARGx lineno, nLastNonblank + 1);
1511
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
1392
GoTo(lineno, nLastNonblank + 1);
1393
ClrToEOL(blank, FALSE);
1512
1394
} else {
1513
1395
/*
1514
1396
* The delete-char sequence will
1518
1400
* setting the video attributes from
1519
1401
* the last character on the row.
1520
1402
*/
1521
UpdateAttrs(SP_PARM, blank);
1522
DelChar(NCURSES_SP_ARGx oLastChar - nLastChar);
1403
UpdateAttrs(blank);
1404
DelChar(oLastChar - nLastChar);
1523
1405
}
1524
1406
}
1525
1407
}
1526
1408
}
1527
1409
1528
1410
/* update the code's internal representation */
1529
if (screen_columns(SP_PARM) > firstChar)
1411
if (screen_columns > firstChar)
1530
1412
memcpy(oldLine + firstChar,
1531
1413
newLine + firstChar,
1532
(screen_columns(SP_PARM) - firstChar) * sizeof(NCURSES_CH_T));
1414
(screen_columns - firstChar) * sizeof(NCURSES_CH_T));
1533
1415
TR(TRACE_UPDATE, (T_RETURN("")));
1534
1416
return;
1535
1417
}
1542
1424
*/
1543
1425
1544
1426
static void
1545
ClearScreen(NCURSES_SP_DCLx NCURSES_CH_T blank)
1427
ClearScreen(NCURSES_CH_T blank)
1546
1428
{
1547
1429
int i, j;
1548
1430
bool fast_clear = (clear_screen || clr_eos || clr_eol);
1550
1432
TR(TRACE_UPDATE, ("ClearScreen() called"));
1551
1433
1552
1434
#if NCURSES_EXT_FUNCS
1553
if (SP_PARM->_coloron
1554
&& !SP_PARM->_default_color) {
1555
NCURSES_SP_NAME(_nc_do_color) (NCURSES_SP_ARGx
1556
GET_SCREEN_PAIR(SP_PARM),
1557
0,
1558
FALSE,
1559
NCURSES_SP_NAME(_nc_outch));
1435
if (SP->_coloron
1436
&& !SP->_default_color) {
1437
_nc_do_color(GET_SCREEN_PAIR(SP), 0, FALSE, _nc_outch);
1560
1438
if (!back_color_erase) {
1561
1439
fast_clear = FALSE;
1562
1440
}
1565
1443
1566
1444
if (fast_clear) {
1567
1445
if (clear_screen) {
1568
UpdateAttrs(SP_PARM, blank);
1446
UpdateAttrs(blank);
1569
1447
TPUTS_TRACE("clear_screen");
1570
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clear_screen);
1571
SP_PARM->_cursrow = SP_PARM->_curscol = 0;
1572
position_check(SP_PARM,
1573
SP_PARM->_cursrow,
1574
SP_PARM->_curscol,
1575
"ClearScreen");
1448
putp(clear_screen);
1449
SP->_cursrow = SP->_curscol = 0;
1450
position_check(SP->_cursrow, SP->_curscol, "ClearScreen");
1576
1451
} else if (clr_eos) {
1577
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1578
GoTo(NCURSES_SP_ARGx 0, 0);
1452
SP->_cursrow = SP->_curscol = -1;
1453
GoTo(0, 0);
1579
1454
1580
UpdateAttrs(SP_PARM, blank);
1455
UpdateAttrs(blank);
1581
1456
TPUTS_TRACE("clr_eos");
1582
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1583
clr_eos,
1584
screen_lines(SP_PARM),
1585
NCURSES_SP_NAME(_nc_outch));
1457
tputs(clr_eos, screen_lines, _nc_outch);
1586
1458
} else if (clr_eol) {
1587
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1459
SP->_cursrow = SP->_curscol = -1;
1588
1460
1589
UpdateAttrs(SP_PARM, blank);
1590
for (i = 0; i < screen_lines(SP_PARM); i++) {
1591
GoTo(NCURSES_SP_ARGx i, 0);
1461
UpdateAttrs(blank);
1462
for (i = 0; i < screen_lines; i++) {
1463
GoTo(i, 0);
1592
1464
TPUTS_TRACE("clr_eol");
1593
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_eol);
1465
putp(clr_eol);
1594
1466
}
1595
GoTo(NCURSES_SP_ARGx 0, 0);
1467
GoTo(0, 0);
1596
1468
}
1597
1469
} else {
1598
UpdateAttrs(SP_PARM, blank);
1599
for (i = 0; i < screen_lines(SP_PARM); i++) {
1600
GoTo(NCURSES_SP_ARGx i, 0);
1601
for (j = 0; j < screen_columns(SP_PARM); j++)
1602
PutChar(NCURSES_SP_ARGx CHREF(blank));
1470
UpdateAttrs(blank);
1471
for (i = 0; i < screen_lines; i++) {
1472
GoTo(i, 0);
1473
for (j = 0; j < screen_columns; j++)
1474
PutChar(CHREF(blank));
1603
1475
}
1604
GoTo(NCURSES_SP_ARGx 0, 0);
1476
GoTo(0, 0);
1605
1477
}
1606
1478
1607
for (i = 0; i < screen_lines(SP_PARM); i++) {
1608
for (j = 0; j < screen_columns(SP_PARM); j++)
1609
CurScreen(SP_PARM)->_line[i].text[j] = blank;
1479
for (i = 0; i < screen_lines; i++) {
1480
for (j = 0; j < screen_columns; j++)
1481
curscr->_line[i].text[j] = blank;
1610
1482
}
1611
1483
1612
1484
TR(TRACE_UPDATE, ("screen cleared"));
1620
1492
*/
1621
1493
1622
1494
static void
1623
InsStr(NCURSES_SP_DCLx NCURSES_CH_T * line, int count)
1495
InsStr(NCURSES_CH_T * line, int count)
1624
1496
{
1625
TR(TRACE_UPDATE, ("InsStr(%p, %p,%d) called", SP_PARM, line, count));
1497
TR(TRACE_UPDATE, ("InsStr(%p,%d) called", line, count));
1626
1498
1627
1499
/* Prefer parm_ich as it has the smallest cost - no need to shift
1628
1500
* the whole line on each character. */
1629
1501
/* The order must match that of InsCharCost. */
1630
1502
if (parm_ich) {
1631
1503
TPUTS_TRACE("parm_ich");
1632
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1633
TPARM_1(parm_ich, count),
1634
count,
1635
NCURSES_SP_NAME(_nc_outch));
1504
tputs(TPARM_1(parm_ich, count), count, _nc_outch);
1636
1505
while (count) {
1637
PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
1506
PutAttrChar(CHREF(*line));
1638
1507
line++;
1639
1508
count--;
1640
1509
}
1641
1510
} else if (enter_insert_mode && exit_insert_mode) {
1642
1511
TPUTS_TRACE("enter_insert_mode");
1643
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx enter_insert_mode);
1512
putp(enter_insert_mode);
1644
1513
while (count) {
1645
PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
1514
PutAttrChar(CHREF(*line));
1646
1515
if (insert_padding) {
1647
1516
TPUTS_TRACE("insert_padding");
1648
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_padding);
1517
putp(insert_padding);
1649
1518
}
1650
1519
line++;
1651
1520
count--;
1652
1521
}
1653
1522
TPUTS_TRACE("exit_insert_mode");
1654
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_insert_mode);
1523
putp(exit_insert_mode);
1655
1524
} else {
1656
1525
while (count) {
1657
1526
TPUTS_TRACE("insert_character");
1658
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_character);
1659
PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
1527
putp(insert_character);
1528
PutAttrChar(CHREF(*line));
1660
1529
if (insert_padding) {
1661
1530
TPUTS_TRACE("insert_padding");
1662
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_padding);
1531
putp(insert_padding);
1663
1532
}
1664
1533
line++;
1665
1534
count--;
1666
1535
}
1667
1536
}
1668
position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
1537
position_check(SP->_cursrow, SP->_curscol, "InsStr");
1669
1538
}
1670
1539
1671
1540
/*
1676
1545
*/
1677
1546
1678
1547
static void
1679
DelChar(NCURSES_SP_DCLx int count)
1548
DelChar(int count)
1680
1549
{
1681
1550
int n;
1682
1551
1683
TR(TRACE_UPDATE, ("DelChar(%p, %d) called, position = (%ld,%ld)",
1684
SP_PARM, count,
1685
(long) NewScreen(SP_PARM)->_cury,
1686
(long) NewScreen(SP_PARM)->_curx));
1552
TR(TRACE_UPDATE, ("DelChar(%d) called, position = (%ld,%ld)",
1553
count,
1554
(long) newscr->_cury,
1555
(long) newscr->_curx));
1687
1556
1688
1557
if (parm_dch) {
1689
1558
TPUTS_TRACE("parm_dch");
1690
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1691
TPARM_1(parm_dch, count),
1692
count,
1693
NCURSES_SP_NAME(_nc_outch));
1559
tputs(TPARM_1(parm_dch, count), count, _nc_outch);
1694
1560
} else {
1695
1561
for (n = 0; n < count; n++) {
1696
1562
TPUTS_TRACE("delete_character");
1697
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_character);
1563
putp(delete_character);
1698
1564
}
1699
1565
}
1700
1566
}
1733
1599
1734
1600
/* Try to scroll up assuming given csr (miny, maxy). Returns ERR on failure */
1735
1601
static int
1736
scroll_csr_forward(NCURSES_SP_DCLx
1737
int n,
1738
int top,
1739
int bot,
1740
int miny,
1741
int maxy,
1742
NCURSES_CH_T blank)
1602
scroll_csr_forward(int n, int top, int bot, int miny, int maxy, NCURSES_CH_T blank)
1743
1603
{
1744
1604
int i;
1745
1605
1746
1606
if (n == 1 && scroll_forward && top == miny && bot == maxy) {
1747
GoTo(NCURSES_SP_ARGx bot, 0);
1748
UpdateAttrs(SP_PARM, blank);
1607
GoTo(bot, 0);
1608
UpdateAttrs(blank);
1749
1609
TPUTS_TRACE("scroll_forward");
1750
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx scroll_forward);
1610
putp(scroll_forward);
1751
1611
} else if (n == 1 && delete_line && bot == maxy) {
1752
GoTo(NCURSES_SP_ARGx top, 0);
1753
UpdateAttrs(SP_PARM, blank);
1612
GoTo(top, 0);
1613
UpdateAttrs(blank);
1754
1614
TPUTS_TRACE("delete_line");
1755
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
1615
putp(delete_line);
1756
1616
} else if (parm_index && top == miny && bot == maxy) {
1757
GoTo(NCURSES_SP_ARGx bot, 0);
1758
UpdateAttrs(SP_PARM, blank);
1617
GoTo(bot, 0);
1618
UpdateAttrs(blank);
1759
1619
TPUTS_TRACE("parm_index");
1760
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1761
TPARM_2(parm_index, n, 0),
1762
n,
1763
NCURSES_SP_NAME(_nc_outch));
1620
tputs(TPARM_2(parm_index, n, 0), n, _nc_outch);
1764
1621
} else if (parm_delete_line && bot == maxy) {
1765
GoTo(NCURSES_SP_ARGx top, 0);
1766
UpdateAttrs(SP_PARM, blank);
1622
GoTo(top, 0);
1623
UpdateAttrs(blank);
1767
1624
TPUTS_TRACE("parm_delete_line");
1768
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1769
TPARM_2(parm_delete_line, n, 0),
1770
n,
1771
NCURSES_SP_NAME(_nc_outch));
1625
tputs(TPARM_2(parm_delete_line, n, 0), n, _nc_outch);
1772
1626
} else if (scroll_forward && top == miny && bot == maxy) {
1773
GoTo(NCURSES_SP_ARGx bot, 0);
1774
UpdateAttrs(SP_PARM, blank);
1627
GoTo(bot, 0);
1628
UpdateAttrs(blank);
1775
1629
for (i = 0; i < n; i++) {
1776
1630
TPUTS_TRACE("scroll_forward");
1777
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx scroll_forward);
1631
putp(scroll_forward);
1778
1632
}
1779
1633
} else if (delete_line && bot == maxy) {
1780
GoTo(NCURSES_SP_ARGx top, 0);
1781
UpdateAttrs(SP_PARM, blank);
1634
GoTo(top, 0);
1635
UpdateAttrs(blank);
1782
1636
for (i = 0; i < n; i++) {
1783
1637
TPUTS_TRACE("delete_line");
1784
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
1638
putp(delete_line);
1785
1639
}
1786
1640
} else
1787
1641
return ERR;
1788
1642
1789
1643
#if NCURSES_EXT_FUNCS
1790
if (FILL_BCE(SP_PARM)) {
1644
if (FILL_BCE()) {
1791
1645
int j;
1792
1646
for (i = 0; i < n; i++) {
1793
GoTo(NCURSES_SP_ARGx bot - i, 0);
1794
for (j = 0; j < screen_columns(SP_PARM); j++)
1795
PutChar(NCURSES_SP_ARGx CHREF(blank));
1647
GoTo(bot - i, 0);
1648
for (j = 0; j < screen_columns; j++)
1649
PutChar(CHREF(blank));
1796
1650
}
1797
1651
}
1798
1652
#endif
1802
1656
/* Try to scroll down assuming given csr (miny, maxy). Returns ERR on failure */
1803
1657
/* n > 0 */
1804
1658
static int
1805
scroll_csr_backward(NCURSES_SP_DCLx
1806
int n,
1807
int top,
1808
int bot,
1809
int miny,
1810
int maxy,
1659
scroll_csr_backward(int n, int top, int bot, int miny, int maxy,
1811
1660
NCURSES_CH_T blank)
1812
1661
{
1813
1662
int i;
1814
1663
1815
1664
if (n == 1 && scroll_reverse && top == miny && bot == maxy) {
1816
GoTo(NCURSES_SP_ARGx top, 0);
1817
UpdateAttrs(SP_PARM, blank);
1665
GoTo(top, 0);
1666
UpdateAttrs(blank);
1818
1667
TPUTS_TRACE("scroll_reverse");
1819
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx scroll_reverse);
1668
putp(scroll_reverse);
1820
1669
} else if (n == 1 && insert_line && bot == maxy) {
1821
GoTo(NCURSES_SP_ARGx top, 0);
1822
UpdateAttrs(SP_PARM, blank);
1670
GoTo(top, 0);
1671
UpdateAttrs(blank);
1823
1672
TPUTS_TRACE("insert_line");
1824
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
1673
putp(insert_line);
1825
1674
} else if (parm_rindex && top == miny && bot == maxy) {
1826
GoTo(NCURSES_SP_ARGx top, 0);
1827
UpdateAttrs(SP_PARM, blank);
1675
GoTo(top, 0);
1676
UpdateAttrs(blank);
1828
1677
TPUTS_TRACE("parm_rindex");
1829
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1830
TPARM_2(parm_rindex, n, 0),
1831
n,
1832
NCURSES_SP_NAME(_nc_outch));
1678
tputs(TPARM_2(parm_rindex, n, 0), n, _nc_outch);
1833
1679
} else if (parm_insert_line && bot == maxy) {
1834
GoTo(NCURSES_SP_ARGx top, 0);
1835
UpdateAttrs(SP_PARM, blank);
1680
GoTo(top, 0);
1681
UpdateAttrs(blank);
1836
1682
TPUTS_TRACE("parm_insert_line");
1837
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1838
TPARM_2(parm_insert_line, n, 0),
1839
n,
1840
NCURSES_SP_NAME(_nc_outch));
1683
tputs(TPARM_2(parm_insert_line, n, 0), n, _nc_outch);
1841
1684
} else if (scroll_reverse && top == miny && bot == maxy) {
1842
GoTo(NCURSES_SP_ARGx top, 0);
1843
UpdateAttrs(SP_PARM, blank);
1685
GoTo(top, 0);
1686
UpdateAttrs(blank);
1844
1687
for (i = 0; i < n; i++) {
1845
1688
TPUTS_TRACE("scroll_reverse");
1846
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx scroll_reverse);
1689
putp(scroll_reverse);
1847
1690
}
1848
1691
} else if (insert_line && bot == maxy) {
1849
GoTo(NCURSES_SP_ARGx top, 0);
1850
UpdateAttrs(SP_PARM, blank);
1692
GoTo(top, 0);
1693
UpdateAttrs(blank);
1851
1694
for (i = 0; i < n; i++) {
1852
1695
TPUTS_TRACE("insert_line");
1853
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
1696
putp(insert_line);
1854
1697
}
1855
1698
} else
1856
1699
return ERR;
1857
1700
1858
1701
#if NCURSES_EXT_FUNCS
1859
if (FILL_BCE(SP_PARM)) {
1702
if (FILL_BCE()) {
1860
1703
int j;
1861
1704
for (i = 0; i < n; i++) {
1862
GoTo(NCURSES_SP_ARGx top + i, 0);
1863
for (j = 0; j < screen_columns(SP_PARM); j++)
1864
PutChar(NCURSES_SP_ARGx CHREF(blank));
1705
GoTo(top + i, 0);
1706
for (j = 0; j < screen_columns; j++)
1707
PutChar(CHREF(blank));
1865
1708
}
1866
1709
}
1867
1710
#endif
1871
1714
/* scroll by using delete_line at del and insert_line at ins */
1872
1715
/* n > 0 */
1873
1716
static int
1874
scroll_idl(NCURSES_SP_DCLx int n, int del, int ins, NCURSES_CH_T blank)
1717
scroll_idl(int n, int del, int ins, NCURSES_CH_T blank)
1875
1718
{
1876
1719
int i;
1877
1720
1878
1721
if (!((parm_delete_line || delete_line) && (parm_insert_line || insert_line)))
1879
1722
return ERR;
1880
1723
1881
GoTo(NCURSES_SP_ARGx del, 0);
1882
UpdateAttrs(SP_PARM, blank);
1724
GoTo(del, 0);
1725
UpdateAttrs(blank);
1883
1726
if (n == 1 && delete_line) {
1884
1727
TPUTS_TRACE("delete_line");
1885
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
1728
putp(delete_line);
1886
1729
} else if (parm_delete_line) {
1887
1730
TPUTS_TRACE("parm_delete_line");
1888
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1889
TPARM_2(parm_delete_line, n, 0),
1890
n,
1891
NCURSES_SP_NAME(_nc_outch));
1731
tputs(TPARM_2(parm_delete_line, n, 0), n, _nc_outch);
1892
1732
} else { /* if (delete_line) */
1893
1733
for (i = 0; i < n; i++) {
1894
1734
TPUTS_TRACE("delete_line");
1895
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
1735
putp(delete_line);
1896
1736
}
1897
1737
}
1898
1738
1899
GoTo(NCURSES_SP_ARGx ins, 0);
1900
UpdateAttrs(SP_PARM, blank);
1739
GoTo(ins, 0);
1740
UpdateAttrs(blank);
1901
1741
if (n == 1 && insert_line) {
1902
1742
TPUTS_TRACE("insert_line");
1903
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
1743
putp(insert_line);
1904
1744
} else if (parm_insert_line) {
1905
1745
TPUTS_TRACE("parm_insert_line");
1906
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
1907
TPARM_2(parm_insert_line, n, 0),
1908
n,
1909
NCURSES_SP_NAME(_nc_outch));
1746
tputs(TPARM_2(parm_insert_line, n, 0), n, _nc_outch);
1910
1747
} else { /* if (insert_line) */
1911
1748
for (i = 0; i < n; i++) {
1912
1749
TPUTS_TRACE("insert_line");
1913
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
1750
putp(insert_line);
1914
1751
}
1915
1752
}
1916
1753
1926
1763
* save/restore cursor capabilities if the terminal has them.
1927
1764
*/
1928
1765
NCURSES_EXPORT(int)
1929
NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
1930
int n,
1931
int top,
1932
int bot,
1933
int maxy)
1766
_nc_scrolln(int n, int top, int bot, int maxy)
1934
1767
/* scroll region from top to bot by n lines */
1935
1768
{
1936
NCURSES_CH_T blank = ClrBlank(NCURSES_SP_ARGx StdScreen(SP_PARM));
1769
NCURSES_CH_T blank = ClrBlank(stdscr);
1937
1770
int i;
1938
1771
bool cursor_saved = FALSE;
1939
1772
int res;
1954
1787
* Explicitly clear if stuff pushed off top of region might
1955
1788
* be saved by the terminal.
1956
1789
*/
1957
res = scroll_csr_forward(NCURSES_SP_ARGx n, top, bot, 0, maxy, blank);
1790
res = scroll_csr_forward(n, top, bot, 0, maxy, blank);
1958
1791
1959
1792
if (res == ERR && change_scroll_region) {
1960
1793
if ((((n == 1 && scroll_forward) || parm_index)
1961
&& (SP_PARM->_cursrow == bot || SP_PARM->_cursrow == bot - 1))
1794
&& (SP->_cursrow == bot || SP->_cursrow == bot - 1))
1962
1795
&& save_cursor && restore_cursor) {
1963
1796
cursor_saved = TRUE;
1964
1797
TPUTS_TRACE("save_cursor");
1965
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx save_cursor);
1798
putp(save_cursor);
1966
1799
}
1967
1800
TPUTS_TRACE("change_scroll_region");
1968
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
1969
TPARM_2(change_scroll_region, top, bot));
1801
putp(TPARM_2(change_scroll_region, top, bot));
1970
1802
if (cursor_saved) {
1971
1803
TPUTS_TRACE("restore_cursor");
1972
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx restore_cursor);
1804
putp(restore_cursor);
1973
1805
} else {
1974
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1806
SP->_cursrow = SP->_curscol = -1;
1975
1807
}
1976
1808
1977
res = scroll_csr_forward(NCURSES_SP_ARGx n, top, bot, top, bot, blank);
1809
res = scroll_csr_forward(n, top, bot, top, bot, blank);
1978
1810
1979
1811
TPUTS_TRACE("change_scroll_region");
1980
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
1981
TPARM_2(change_scroll_region, 0, maxy));
1982
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1812
putp(TPARM_2(change_scroll_region, 0, maxy));
1813
SP->_cursrow = SP->_curscol = -1;
1983
1814
}
1984
1815
1985
1816
if (res == ERR && _nc_idlok)
1986
res = scroll_idl(NCURSES_SP_ARGx n, top, bot - n + 1, blank);
1817
res = scroll_idl(n, top, bot - n + 1, blank);
1987
1818
1988
1819
/*
1989
1820
* Clear the newly shifted-in text.
1992
1823
&& (non_dest_scroll_region || (memory_below && bot == maxy))) {
1993
1824
static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
1994
1825
if (bot == maxy && clr_eos) {
1995
GoTo(NCURSES_SP_ARGx bot - n + 1, 0);
1996
ClrToEOS(NCURSES_SP_ARGx blank2);
1826
GoTo(bot - n + 1, 0);
1827
ClrToEOS(blank2);
1997
1828
} else {
1998
1829
for (i = 0; i < n; i++) {
1999
GoTo(NCURSES_SP_ARGx bot - i, 0);
2000
ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
1830
GoTo(bot - i, 0);
1831
ClrToEOL(blank2, FALSE);
2001
1832
}
2002
1833
}
2003
1834
}
2004
1835
2005
1836
} else { /* (n < 0) - scroll down (backward) */
2006
res = scroll_csr_backward(NCURSES_SP_ARGx -n, top, bot, 0, maxy, blank);
1837
res = scroll_csr_backward(-n, top, bot, 0, maxy, blank);
2007
1838
2008
1839
if (res == ERR && change_scroll_region) {
2009
if (top != 0
2010
&& (SP_PARM->_cursrow == top ||
2011
SP_PARM->_cursrow == top - 1)
1840
if (top != 0 && (SP->_cursrow == top || SP->_cursrow == top - 1)
2012
1841
&& save_cursor && restore_cursor) {
2013
1842
cursor_saved = TRUE;
2014
1843
TPUTS_TRACE("save_cursor");
2015
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx save_cursor);
1844
putp(save_cursor);
2016
1845
}
2017
1846
TPUTS_TRACE("change_scroll_region");
2018
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
2019
TPARM_2(change_scroll_region, top, bot));
1847
putp(TPARM_2(change_scroll_region, top, bot));
2020
1848
if (cursor_saved) {
2021
1849
TPUTS_TRACE("restore_cursor");
2022
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx restore_cursor);
1850
putp(restore_cursor);
2023
1851
} else {
2024
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1852
SP->_cursrow = SP->_curscol = -1;
2025
1853
}
2026
1854
2027
res = scroll_csr_backward(NCURSES_SP_ARGx
2028
-n, top, bot, top, bot, blank);
1855
res = scroll_csr_backward(-n, top, bot, top, bot, blank);
2029
1856
2030
1857
TPUTS_TRACE("change_scroll_region");
2031
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
2032
TPARM_2(change_scroll_region, 0, maxy));
2033
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
1858
putp(TPARM_2(change_scroll_region, 0, maxy));
1859
SP->_cursrow = SP->_curscol = -1;
2034
1860
}
2035
1861
2036
1862
if (res == ERR && _nc_idlok)
2037
res = scroll_idl(NCURSES_SP_ARGx -n, bot + n + 1, top, blank);
1863
res = scroll_idl(-n, bot + n + 1, top, blank);
2038
1864
2039
1865
/*
2040
1866
* Clear the newly shifted-in text.
2043
1869
&& (non_dest_scroll_region || (memory_above && top == 0))) {
2044
1870
static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
2045
1871
for (i = 0; i < -n; i++) {
2046
GoTo(NCURSES_SP_ARGx i + top, 0);
2047
ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
1872
GoTo(i + top, 0);
1873
ClrToEOL(blank2, FALSE);
2048
1874
}
2049
1875
}
2050
1876
}
2052
1878
if (res == ERR)
2053
1879
return (ERR);
2054
1880
2055
_nc_scroll_window(CurScreen(SP_PARM), n, top, bot, blank);
1881
_nc_scroll_window(curscr, n, top, bot, blank);
2056
1882
2057
1883
/* shift hash values too - they can be reused */
2058
NCURSES_SP_NAME(_nc_scroll_oldhash) (NCURSES_SP_ARGx n, top, bot);
1884
_nc_scroll_oldhash(n, top, bot);
2059
1885
2060
1886
return (OK);
2061
1887
}
2062
1888
2063
#if NCURSES_SP_FUNCS
2064
NCURSES_EXPORT(int)
2065
_nc_scrolln(int n, int top, int bot, int maxy)
2066
{
2067
return NCURSES_SP_NAME(_nc_scrolln) (CURRENT_SCREEN, n, top, bot, maxy);
2068
}
2069
#endif
2070
2071
1889
NCURSES_EXPORT(void)
2072
NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_DCL0)
1890
_nc_screen_resume(void)
2073
1891
{
2074
assert(SP_PARM);
2075
2076
1892
/* make sure terminal is in a sane known state */
2077
SetAttr(SCREEN_ATTRS(SP_PARM), A_NORMAL);
2078
NewScreen(SP_PARM)->_clear = TRUE;
1893
SetAttr(SCREEN_ATTRS(SP), A_NORMAL);
1894
newscr->_clear = TRUE;
2079
1895
2080
1896
/* reset color pairs and definitions */
2081
if (SP_PARM->_coloron || SP_PARM->_color_defs)
1897
if (SP->_coloron || SP->_color_defs)
2082
1898
_nc_reset_colors();
2083
1899
2084
1900
/* restore user-defined colors, if any */
2085
if (SP_PARM->_color_defs < 0) {
1901
if (SP->_color_defs < 0) {
2086
1902
int n;
2087
SP_PARM->_color_defs = -(SP_PARM->_color_defs);
2088
for (n = 0; n < SP_PARM->_color_defs; ++n) {
2089
if (SP_PARM->_color_table[n].init) {
2090
NCURSES_SP_NAME(init_color) (NCURSES_SP_ARGx n,
2091
SP_PARM->_color_table[n].r,
2092
SP_PARM->_color_table[n].g,
2093
SP_PARM->_color_table[n].b);
1903
SP->_color_defs = -(SP->_color_defs);
1904
for (n = 0; n < SP->_color_defs; ++n) {
1905
if (SP->_color_table[n].init) {
1906
init_color(n,
1907
SP->_color_table[n].r,
1908
SP->_color_table[n].g,
1909
SP->_color_table[n].b);
2094
1910
}
2095
1911
}
2096
1912
}
2097
1913
2098
1914
if (exit_attribute_mode)
2099
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_attribute_mode);
1915
putp(exit_attribute_mode);
2100
1916
else {
2101
1917
/* turn off attributes */
2102
1918
if (exit_alt_charset_mode)
2103
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_alt_charset_mode);
1919
putp(exit_alt_charset_mode);
2104
1920
if (exit_standout_mode)
2105
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_standout_mode);
1921
putp(exit_standout_mode);
2106
1922
if (exit_underline_mode)
2107
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_underline_mode);
1923
putp(exit_underline_mode);
2108
1924
}
2109
1925
if (exit_insert_mode)
2110
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_insert_mode);
1926
putp(exit_insert_mode);
2111
1927
if (enter_am_mode && exit_am_mode)
2112
NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
2113
(auto_right_margin
2114
? enter_am_mode
2115
: exit_am_mode));
2116
}
2117
2118
#if NCURSES_SP_FUNCS
2119
NCURSES_EXPORT(void)
2120
_nc_screen_resume(void)
2121
{
2122
NCURSES_SP_NAME(_nc_screen_resume) (CURRENT_SCREEN);
2123
}
2124
#endif
2125
2126
NCURSES_EXPORT(void)
2127
NCURSES_SP_NAME(_nc_screen_init) (NCURSES_SP_DCL0)
2128
{
2129
NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
2130
}
2131
2132
#if NCURSES_SP_FUNCS
1928
putp(auto_right_margin ? enter_am_mode : exit_am_mode);
1929
}
1930
2133
1931
NCURSES_EXPORT(void)
2134
1932
_nc_screen_init(void)
2135
1933
{
2136
NCURSES_SP_NAME(_nc_screen_init) (CURRENT_SCREEN);
1934
_nc_screen_resume();
2137
1935
}
2138
#endif
2139
1936
2140
1937
/* wrap up screen handling */
2141
1938
NCURSES_EXPORT(void)
2142
NCURSES_SP_NAME(_nc_screen_wrap) (NCURSES_SP_DCL0)
2143
{
2144
if (SP_PARM == 0)
2145
return;
2146
2147
UpdateAttrs(SP_PARM, normal);
2148
#if NCURSES_EXT_FUNCS
2149
if (SP_PARM->_coloron
2150
&& !SP_PARM->_default_color) {
2151
static const NCURSES_CH_T blank = NewChar(BLANK_TEXT);
2152
SP_PARM->_default_color = TRUE;
2153
NCURSES_SP_NAME(_nc_do_color) (NCURSES_SP_ARGx
2154
-1, 0,
2155
FALSE,
2156
NCURSES_SP_NAME(_nc_outch));
2157
SP_PARM->_default_color = FALSE;
2158
2159
mvcur(SP_PARM->_cursrow,
2160
SP_PARM->_curscol,
2161
screen_lines(SP_PARM) - 1, 0);
2162
2163
ClrToEOL(NCURSES_SP_ARGx blank, TRUE);
2164
}
2165
#endif
2166
if (SP_PARM->_color_defs) {
2167
_nc_reset_colors();
2168
}
2169
}
2170
2171
#if NCURSES_SP_FUNCS
2172
NCURSES_EXPORT(void)
2173
1939
_nc_screen_wrap(void)
2174
1940
{
2175
NCURSES_SP_NAME(_nc_screen_wrap) (CURRENT_SCREEN);
2176
}
1941
UpdateAttrs(normal);
1942
#if NCURSES_EXT_FUNCS
1943
if (SP->_coloron
1944
&& !SP->_default_color) {
1945
static const NCURSES_CH_T blank = NewChar(BLANK_TEXT);
1946
SP->_default_color = TRUE;
1947
_nc_do_color(-1, 0, FALSE, _nc_outch);
1948
SP->_default_color = FALSE;
1949
1950
mvcur(SP->_cursrow, SP->_curscol, screen_lines - 1, 0);
1951
1952
ClrToEOL(blank, TRUE);
1953
}
2177
1954
#endif
1955
if (SP->_color_defs) {
1956
_nc_reset_colors();
1957
}
1958
}
2178
1959
2179
1960
#if USE_XMC_SUPPORT
2180
1961
NCURSES_EXPORT(void)
2181
NCURSES_SP_NAME(_nc_do_xmc_glitch) (NCURSES_SP_DCLx attr_t previous)
2182
{
2183
if (SP_PARM != 0) {
2184
attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP_PARM)));
2185
2186
while (chg != 0) {
2187
if (chg & 1) {
2188
SP_PARM->_curscol += magic_cookie_glitch;
2189
if (SP_PARM->_curscol >= SP_PARM->_columns)
2190
wrap_cursor(NCURSES_SP_ARG);
2191
TR(TRACE_UPDATE, ("bumped to %d,%d after cookie",
2192
SP_PARM->_cursrow, SP_PARM->_curscol));
2193
}
2194
chg >>= 1;
2195
}
2196
}
2197
}
2198
2199
#if NCURSES_SP_FUNCS
2200
NCURSES_EXPORT(void)
2201
1962
_nc_do_xmc_glitch(attr_t previous)
2202
1963
{
2203
NCURSES_SP_NAME(_nc_do_xmc_glitch) (CURRENT_SCREEN, previous);
1964
attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP)));
1965
1966
while (chg != 0) {
1967
if (chg & 1) {
1968
SP->_curscol += magic_cookie_glitch;
1969
if (SP->_curscol >= SP->_columns)
1970
wrap_cursor();
1971
TR(TRACE_UPDATE, ("bumped to %d,%d after cookie", SP->_cursrow, SP->_curscol));
1972
}
1973
chg >>= 1;
1974
}
2204
1975
}
2205
#endif
2206
2207
1976
#endif /* USE_XMC_SUPPORT */
Loggerhead is a web-based interface for Breezy
Version: 2.0.1