/[LeafOK_CVS]/lbbs/src/screen.c
ViewVC logotype

Diff of /lbbs/src/screen.c

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

Revision 1.104 by sysadm, Wed Jul 2 04:17:33 2025 UTC Revision 1.120 by sysadm, Tue Oct 28 05:08:50 2025 UTC
# Line 36  Line 36 
36    
37  #define ACTIVE_BOARD_HEIGHT 8  #define ACTIVE_BOARD_HEIGHT 8
38    
39  #define STR_TOP_LEFT_MAX_LEN 40  #define STR_TOP_LEFT_MAX_LEN 80
40  #define STR_TOP_MIDDLE_MAX_LEN 20  #define STR_TOP_MIDDLE_MAX_LEN 40
41  #define STR_TOP_RIGHT_MAX_LEN 20  #define STR_TOP_RIGHT_MAX_LEN 80
42    
43    static size_t get_time_str(char *s, size_t len)
44    {
45            time_t curtime;
46            struct tm local_tm;
47    
48            time(&curtime);
49            localtime_r(&curtime, &local_tm);
50            size_t j = strftime(s, len, "%m/%d %H:%M %Z", &local_tm);
51    
52            return j;
53    }
54    
55  void moveto(int row, int col)  void moveto(int row, int col)
56  {  {
# Line 81  void clearscr() Line 93  void clearscr()
93          moveto(0, 0);          moveto(0, 0);
94  }  }
95    
96  int press_any_key()  inline int press_any_key()
97  {  {
98            return press_any_key_ex("                           \033[1;33m按任意键继续...\033[m", 60);
99    }
100    
101    int press_any_key_ex(const char *msg, int sec)
102    {
103            int ch = 0;
104            int duration = 0;
105            time_t t_begin = time(NULL);
106    
107          moveto(SCREEN_ROWS, 0);          moveto(SCREEN_ROWS, 0);
108          clrtoeol();          clrtoeol();
109    
110          prints("                           \033[1;33m按任意键继续...\033[0;37m");          prints(msg);
111          iflush();          iflush();
112    
113          return igetch_t(MIN(MAX_DELAY_TIME, 60));          igetch_reset();
114    
115            do
116            {
117                    ch = igetch_t(sec - duration);
118                    duration = (int)(time(NULL) - t_begin);
119            } while (!SYS_server_exit && ch == 0 && duration < 60);
120    
121            return ch;
122  }  }
123    
124  void set_input_echo(int echo)  void set_input_echo(int echo)
# Line 97  void set_input_echo(int echo) Line 126  void set_input_echo(int echo)
126          if (echo)          if (echo)
127          {          {
128                  outc('\x83'); // ASCII code 131                  outc('\x83'); // ASCII code 131
                 iflush();  
129          }          }
130          else          else
131          {          {
132                  //    outc ('\x85'); // ASCII code 133                  // outc ('\x85'); // ASCII code 133
133                  prints("\xff\xfb\x01\xff\xfb\x03");                  prints("\xff\xfb\x01\xff\xfb\x03");
                 iflush();  
                 igetch(0);  
                 igetch_reset();  
134          }          }
135            iflush();
136  }  }
137    
138  static int _str_input(char *buffer, int buf_size, int max_display_len, int echo_mode)  static int _str_input(char *buffer, int buf_size, int max_display_len, int echo_mode)
# Line 130  static int _str_input(char *buffer, int Line 156  static int _str_input(char *buffer, int
156    
157                  if (ch == CR)                  if (ch == CR)
158                  {                  {
                         igetch_reset();  
159                          break;                          break;
160                  }                  }
161                  else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe                  else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe
# Line 148  static int _str_input(char *buffer, int Line 173  static int _str_input(char *buffer, int
173                                  offset--;                                  offset--;
174                                  if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8                                  if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
175                                  {                                  {
176                                          while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)                                          while (offset > 0 && (buffer[offset] & 0xc0) != 0xc0)
177                                          {                                          {
178                                                  offset--;                                                  offset--;
179                                          }                                          }
# Line 169  static int _str_input(char *buffer, int Line 194  static int _str_input(char *buffer, int
194                  else if ((ch & 0xff80) == 0x80) // head of multi-byte character                  else if ((ch & 0xff80) == 0x80) // head of multi-byte character
195                  {                  {
196                          str_len = 0;                          str_len = 0;
197                          c = (char)(ch & 0b11110000);                          c = (char)(ch & 0xf0);
198                          while (c & 0b10000000)                          while (c & 0x80)
199                          {                          {
200                                  input_str[str_len] = (char)(ch - 256);                                  input_str[str_len] = (char)(ch - 256);
201                                  str_len++;                                  str_len++;
202                                  c = (c & 0b01111111) << 1;                                  c = (c & 0x7f) << 1;
203    
204                                  if ((c & 0b10000000) == 0) // Input completed                                  if ((c & 0x80) == 0) // Input completed
205                                  {                                  {
206                                          break;                                          break;
207                                  }                                  }
# Line 185  static int _str_input(char *buffer, int Line 210  static int _str_input(char *buffer, int
210                                  ch = igetch(100);                                                // 0.1 second                                  ch = igetch(100);                                                // 0.1 second
211                                  if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input                                  if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input
212                                  {                                  {
213    #ifdef _DEBUG
214                                          log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);                                          log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);
215    #endif
216                                          str_len = 0;                                          str_len = 0;
217                                          break;                                          break;
218                                  }                                  }
# Line 264  int str_input(char *buffer, int buf_size Line 291  int str_input(char *buffer, int buf_size
291          iflush();          iflush();
292    
293          return len;          return len;
294  };  }
295    
296  int get_data(int row, int col, char *prompt, char *buffer, int buf_size, int max_display_len, int echo_mode)  int get_data(int row, int col, char *prompt, char *buffer, int buf_size, int max_display_len)
297  {  {
298          int len;          int len = 0;
299            int col_cur = 0;
300            int ch;
301            int offset = 0;
302            int eol;
303            int display_len;
304            char input_str[4];
305            int str_len = 0;
306            char c;
307    
308            buffer[buf_size - 1] = '\0';
309            offset = split_line(buffer, max_display_len, &eol, &display_len, 0);
310            buffer[offset] = '\0';
311            len = offset;
312            col_cur = col + str_length(prompt, 1) + display_len;
313    
314          moveto(row, col);          moveto(row, col);
315          prints("%s", prompt);          prints("%s", prompt);
316          prints("%s", buffer);          prints("%s", buffer);
317            prints("%*s", max_display_len - display_len, "");
318            moveto(row, col_cur);
319          iflush();          iflush();
320    
321          len = _str_input(buffer, buf_size, max_display_len, echo_mode);          igetch_reset();
322    
323            while (!SYS_server_exit)
324            {
325                    ch = igetch_t(MIN(MAX_DELAY_TIME, 60));
326    
327                    if (ch == CR)
328                    {
329                            break;
330                    }
331                    else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe
332                    {
333                            return -1;
334                    }
335                    else if (ch == LF || ch == '\0')
336                    {
337                            continue;
338                    }
339                    else if (ch == BACKSPACE)
340                    {
341                            if (offset > 0)
342                            {
343                                    str_len = 1;
344                                    offset--;
345                                    if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
346                                    {
347                                            while (offset > 0 && (buffer[offset] & 0xc0) != 0xc0)
348                                            {
349                                                    str_len++;
350                                                    offset--;
351                                            }
352                                            display_len--;
353                                            col_cur--;
354                                    }
355    
356                                    memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
357                                    len -= str_len;
358                                    buffer[len] = '\0';
359                                    display_len--;
360                                    col_cur--;
361    
362                                    moveto(row, col_cur);
363                                    prints("%s", buffer + offset);
364                                    prints("%*s", max_display_len - display_len, "");
365                                    moveto(row, col_cur);
366                                    iflush();
367                            }
368                            continue;
369                    }
370                    else if (ch == KEY_DEL)
371                    {
372                            if (offset < len)
373                            {
374                                    if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
375                                    {
376                                            str_len = 0;
377                                            c = (char)(buffer[offset] & 0xf0);
378                                            while (c & 0x80)
379                                            {
380                                                    str_len++;
381                                                    c = (c & 0x7f) << 1;
382                                            }
383                                            display_len--;
384                                    }
385                                    else
386                                    {
387                                            str_len = 1;
388                                    }
389    
390                                    memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
391                                    len -= str_len;
392                                    buffer[len] = '\0';
393                                    display_len--;
394    
395                                    moveto(row, col_cur);
396                                    prints("%s", buffer + offset);
397                                    prints("%*s", max_display_len - display_len, "");
398                                    moveto(row, col_cur);
399                                    iflush();
400                            }
401                            continue;
402                    }
403                    else if (ch == KEY_LEFT)
404                    {
405                            if (offset > 0)
406                            {
407                                    str_len = 1;
408                                    offset--;
409                                    if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
410                                    {
411                                            while (offset > 0 && (buffer[offset] & 0xc0) != 0xc0)
412                                            {
413                                                    str_len++;
414                                                    offset--;
415                                            }
416                                            col_cur--;
417                                    }
418                                    col_cur--;
419    
420                                    moveto(row, col_cur);
421                                    iflush();
422                            }
423                            continue;
424                    }
425                    else if (ch == KEY_RIGHT)
426                    {
427                            if (offset < len)
428                            {
429                                    str_len = 0;
430                                    if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
431                                    {
432                                            c = (char)(buffer[offset] & 0xf0);
433                                            while (c & 0x80)
434                                            {
435                                                    str_len++;
436                                                    c = (c & 0x7f) << 1;
437                                            }
438                                            col_cur++;
439                                    }
440                                    else
441                                    {
442                                            str_len = 1;
443                                    }
444    
445                                    col_cur++;
446                                    offset += str_len;
447    
448                                    moveto(row, col_cur);
449                                    iflush();
450                            }
451                            continue;
452                    }
453                    else if (ch == KEY_HOME || ch == KEY_UP)
454                    {
455                            if (offset > 0)
456                            {
457                                    offset = 0;
458                                    col_cur = col + str_length(prompt, 1);
459    
460                                    moveto(row, col_cur);
461                                    iflush();
462                            }
463                            continue;
464                    }
465                    else if (ch == KEY_END || ch == KEY_DOWN)
466                    {
467                            if (offset < len)
468                            {
469                                    offset = len;
470                                    col_cur = col + str_length(prompt, 1) + display_len;
471    
472                                    moveto(row, col_cur);
473                                    iflush();
474                            }
475                            continue;
476                    }
477                    else if (ch > 255 || iscntrl(ch))
478                    {
479                            continue;
480                    }
481                    else if ((ch & 0xff80) == 0x80) // head of multi-byte character
482                    {
483                            str_len = 0;
484                            c = (char)(ch & 0xf0);
485                            while (c & 0x80)
486                            {
487                                    input_str[str_len] = (char)(ch - 256);
488                                    str_len++;
489                                    c = (c & 0x7f) << 1;
490    
491                                    if ((c & 0x80) == 0) // Input completed
492                                    {
493                                            break;
494                                    }
495    
496                                    // Expect additional bytes of input
497                                    ch = igetch(100);                                                // 0.1 second
498                                    if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input
499                                    {
500    #ifdef _DEBUG
501                                            log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);
502    #endif
503                                            str_len = 0;
504                                            break;
505                                    }
506                            }
507    
508                            if (str_len == 0) // Incomplete input
509                            {
510                                    continue;
511                            }
512    
513                            if (len + str_len > buf_size - 1 || display_len + 2 > max_display_len) // No enough space for Chinese character
514                            {
515                                    outc('\a');
516                                    iflush();
517                                    continue;
518                            }
519    
520                            memmove(buffer + offset + str_len, buffer + offset, (size_t)(len - offset));
521                            memcpy(buffer + offset, input_str, (size_t)str_len);
522                            len += str_len;
523                            buffer[len] = '\0';
524                            display_len += 2;
525    
526                            moveto(row, col_cur);
527                            prints("%s", buffer + offset);
528                            prints("%*s", max_display_len - display_len, "");
529    
530                            col_cur += 2;
531    
532                            moveto(row, col_cur);
533                            iflush();
534    
535                            offset += str_len;
536                    }
537                    else if (ch >= 32 && ch < 127) // Printable character
538                    {
539                            if (len + 1 > buf_size - 1 || display_len + 1 > max_display_len)
540                            {
541                                    outc('\a');
542                                    iflush();
543                                    continue;
544                            }
545    
546                            memmove(buffer + offset + 1, buffer + offset, (size_t)(len - offset));
547                            buffer[offset] = (char)ch;
548                            len++;
549                            buffer[len] = '\0';
550                            display_len++;
551    
552                            moveto(row, col_cur);
553                            prints("%s", buffer + offset);
554                            prints("%*s", max_display_len - display_len, "");
555    
556                            col_cur++;
557    
558                            moveto(row, col_cur);
559                            iflush();
560    
561                            offset++;
562                    }
563                    else // Invalid character
564                    {
565                            continue;
566                    }
567            }
568    
569          return len;          return len;
570  }  }
# Line 367  int display_data(const void *p_data, lon Line 656  int display_data(const void *p_data, lon
656                                  ch = igetch_t(MAX_DELAY_TIME);                                  ch = igetch_t(MAX_DELAY_TIME);
657                                  input_ok = 1;                                  input_ok = 1;
658    
659                                    if (ch != KEY_NULL && ch != KEY_TIMEOUT)
660                                    {
661                                            BBS_last_access_tm = time(NULL);
662                                    }
663    
664                                  // extended key handler                                  // extended key handler
665                                  if (key_handler(&ch, &ctx) != 0)                                  if (key_handler(&ch, &ctx) != 0)
666                                  {                                  {
# Line 376  int display_data(const void *p_data, lon Line 670  int display_data(const void *p_data, lon
670                                  switch (ch)                                  switch (ch)
671                                  {                                  {
672                                  case KEY_NULL:                                  case KEY_NULL:
673                                            log_error("KEY_NULL\n");
674                                            goto cleanup;
675                                  case KEY_TIMEOUT:                                  case KEY_TIMEOUT:
676                                            log_error("User input timeout\n");
677                                          goto cleanup;                                          goto cleanup;
678                                  case KEY_HOME:                                  case KEY_HOME:
679                                          if (line_current - output_current_row < 0) // Reach begin                                          if (line_current - output_current_row < 0) // Reach begin
# Line 410  int display_data(const void *p_data, lon Line 707  int display_data(const void *p_data, lon
707                                          output_end_row = SCREEN_ROWS - 1; // Legacy Fterm only works with this line                                          output_end_row = SCREEN_ROWS - 1; // Legacy Fterm only works with this line
708                                          break;                                          break;
709                                  case CR:                                  case CR:
                                         igetch_reset();  
                                 case KEY_SPACE:  
710                                  case KEY_DOWN:                                  case KEY_DOWN:
711                                          if (line_current + (screen_row_total - (output_current_row - screen_begin_row)) >= display_line_total) // Reach end                                          if (line_current + (screen_row_total - (output_current_row - screen_begin_row)) >= display_line_total) // Reach end
712                                          {                                          {
# Line 439  int display_data(const void *p_data, lon Line 734  int display_data(const void *p_data, lon
734                                          output_end_row = SCREEN_ROWS - 1;                                          output_end_row = SCREEN_ROWS - 1;
735                                          clrline(output_current_row, SCREEN_ROWS);                                          clrline(output_current_row, SCREEN_ROWS);
736                                          break;                                          break;
737                                    case KEY_SPACE:
738                                  case KEY_PGDN:                                  case KEY_PGDN:
739                                          if (line_current + screen_row_total - (output_current_row - screen_begin_row) >= display_line_total) // Reach end                                          if (line_current + screen_row_total - (output_current_row - screen_begin_row) >= display_line_total) // Reach end
740                                          {                                          {
# Line 479  int display_data(const void *p_data, lon Line 775  int display_data(const void *p_data, lon
775                                          input_ok = 0;                                          input_ok = 0;
776                                          break;                                          break;
777                                  }                                  }
   
                                 BBS_last_access_tm = time(NULL);  
778                          }                          }
779    
780                          continue;                          continue;
# Line 572  int show_top(const char *str_left, const Line 866  int show_top(const char *str_left, const
866    
867          strncpy(str_left_f, str_left, sizeof(str_left_f) - 1);          strncpy(str_left_f, str_left, sizeof(str_left_f) - 1);
868          str_left_f[sizeof(str_left_f) - 1] = '\0';          str_left_f[sizeof(str_left_f) - 1] = '\0';
869          len = split_line(str_left_f, STR_TOP_LEFT_MAX_LEN, &eol, &str_left_len, 1);          len = split_line(str_left_f, STR_TOP_LEFT_MAX_LEN / 2, &eol, &str_left_len, 1);
870          str_left_f[len] = '\0';          str_left_f[len] = '\0';
871    
872          strncpy(str_middle_f, str_middle, sizeof(str_middle_f) - 1);          strncpy(str_middle_f, str_middle, sizeof(str_middle_f) - 1);
873          str_middle_f[sizeof(str_middle_f) - 1] = '\0';          str_middle_f[sizeof(str_middle_f) - 1] = '\0';
874          len = split_line(str_middle, STR_TOP_MIDDLE_MAX_LEN, &eol, &str_middle_len, 1);          len = split_line(str_middle, STR_TOP_MIDDLE_MAX_LEN / 2, &eol, &str_middle_len, 1);
875          str_middle_f[len] = '\0';          str_middle_f[len] = '\0';
876    
877          strncpy(str_right_f, str_right, sizeof(str_right_f) - 1);          strncpy(str_right_f, str_right, sizeof(str_right_f) - 1);
878          str_right_f[sizeof(str_right_f) - 1] = '\0';          str_right_f[sizeof(str_right_f) - 1] = '\0';
879          len = split_line(str_right, STR_TOP_RIGHT_MAX_LEN, &eol, &str_right_len, 1);          len = split_line(str_right, STR_TOP_RIGHT_MAX_LEN / 2, &eol, &str_right_len, 1);
880          str_right_f[len] = '\0';          str_right_f[len] = '\0';
881    
882          moveto(1, 0);          moveto(1, 0);
883          clrtoeol();          clrtoeol();
884          prints("\033[1;44;33m%s\033[37m%*s\033[33m%*s\033[m",          prints("\033[1;44;33m%s\033[37m%*s%s\033[33m%*s%s\033[m",
885                     str_left_f, 44 - str_left_len, str_middle_f, 36, str_right_f);                     str_left_f, 44 - str_left_len - str_middle_len, "",
886                       str_middle_f, 36 - str_right_len, "", str_right_f);
887    
888          return 0;          return 0;
889  }  }
# Line 596  int show_top(const char *str_left, const Line 891  int show_top(const char *str_left, const
891  int show_bottom(const char *msg)  int show_bottom(const char *msg)
892  {  {
893          char str_time[LINE_BUFFER_LEN];          char str_time[LINE_BUFFER_LEN];
894            int len_str_time;
895          time_t time_online;          time_t time_online;
896          struct tm *tm_online;          struct tm *tm_online;
897          char msg_f[LINE_BUFFER_LEN];          char msg_f[LINE_BUFFER_LEN];
898          int eol;          int eol;
899          int msg_len;          int len_msg;
900          int len;          int len;
901          int len_username;          int len_username;
902          char str_tm_online[LINE_BUFFER_LEN];          char str_tm_online[LINE_BUFFER_LEN];
903    
904          get_time_str(str_time, sizeof(str_time));          len_str_time = (int)get_time_str(str_time, sizeof(str_time));
905    
906          msg_f[0] = '\0';          msg_f[0] = '\0';
907          msg_len = 0;          len_msg = 0;
908          if (msg != NULL)          if (msg != NULL)
909          {          {
910                  strncpy(msg_f, msg, sizeof(msg_f) - 1);                  strncpy(msg_f, msg, sizeof(msg_f) - 1);
911                  msg_f[sizeof(msg_f) - 1] = '\0';                  msg_f[sizeof(msg_f) - 1] = '\0';
912                  len = split_line(msg_f, 23, &eol, &msg_len, 1);                  len = split_line(msg_f, 23, &eol, &len_msg, 1);
913                  msg_f[len] = '\0';                  msg_f[len] = '\0';
914          }          }
915    
# Line 624  int show_bottom(const char *msg) Line 920  int show_bottom(const char *msg)
920          if (tm_online->tm_mday > 1)          if (tm_online->tm_mday > 1)
921          {          {
922                  snprintf(str_tm_online, sizeof(str_tm_online),                  snprintf(str_tm_online, sizeof(str_tm_online),
923                                   "\033[36m%2d\033[33m天\033[36m%2d\033[33m时",                                   "\033[36m%d\033[33md \033[36m%d\033[33m:\033[36m%.2d",
924                                   tm_online->tm_mday - 1, tm_online->tm_hour);                                   tm_online->tm_mday - 1, tm_online->tm_hour, tm_online->tm_min);
925          }          }
926          else          else
927          {          {
928                  snprintf(str_tm_online, sizeof(str_tm_online),                  snprintf(str_tm_online, sizeof(str_tm_online),
929                                   "\033[36m%2d\033[33m时\033[36m%2d\033[33m分",                                   "\033[36m%d\033[33m:\033[36m%.2d",
930                                   tm_online->tm_hour, tm_online->tm_min);                                   tm_online->tm_hour, tm_online->tm_min);
931          }          }
932    
933          moveto(SCREEN_ROWS, 0);          moveto(SCREEN_ROWS, 0);
934          clrtoeol();          clrtoeol();
935          prints("\033[1;44;33m时间[\033[36m%s\033[33m]%s%*s \033[33m帐号[\033[36m%s\033[33m][%s\033[33m]\033[m",          prints("\033[1;44;33m时间[\033[36m%s\033[33m]%s%*s \033[33m用户[\033[36m%s\033[33m][%s\033[33m]\033[m",
936                     str_time, msg_f, 38 - msg_len - len_username, "", BBS_username, str_tm_online);                     str_time, msg_f, 61 - len_str_time - len_msg - len_username, "", BBS_username, str_tm_online);
937    
938          return 0;          return 0;
939  }  }

Legend:
Removed lines/characters  
Changed lines/characters
  Added lines/characters
webmaster@leafok.com
 ViewVC Help
Powered by ViewVC 1.3.0-beta1