/[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.106 by sysadm, Sun Jul 20 02:04:21 2025 UTC Revision 1.108 by sysadm, Thu Oct 9 12:20:31 2025 UTC
# Line 40  Line 40 
40  #define STR_TOP_MIDDLE_MAX_LEN 40  #define STR_TOP_MIDDLE_MAX_LEN 40
41  #define STR_TOP_RIGHT_MAX_LEN 40  #define STR_TOP_RIGHT_MAX_LEN 40
42    
43    static const char *get_time_str(char *s, size_t len)
44    {
45            static const char *weekday[] = {
46                    "天", "一", "二", "三", "四", "五", "六"};
47            time_t curtime;
48            struct tm local_tm;
49    
50            time(&curtime);
51            localtime_r(&curtime, &local_tm);
52            size_t j = strftime(s, len, "%b %d %H:%M 星期", &local_tm);
53    
54            if (j == 0 || j + strlen(weekday[local_tm.tm_wday]) + 1 > len)
55            {
56                    return NULL;
57            }
58    
59            strncat(s, weekday[local_tm.tm_wday], len - 1 - j);
60    
61            return s;
62    }
63    
64  void moveto(int row, int col)  void moveto(int row, int col)
65  {  {
66          if (row >= 0)          if (row >= 0)
# Line 268  int str_input(char *buffer, int buf_size Line 289  int str_input(char *buffer, int buf_size
289          return len;          return len;
290  };  };
291    
292  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)
293  {  {
294          int len;          int len = 0;
295            int col_cur = 0;
296            int ch;
297            int offset = 0;
298            int eol;
299            int display_len;
300            char input_str[4];
301            int str_len = 0;
302            char c;
303    
304            buffer[buf_size - 1] = '\0';
305            offset = split_line(buffer, max_display_len, &eol, &display_len, 0);
306            buffer[offset] = '\0';
307            len = offset;
308            col_cur = col + str_length(prompt, 1) + display_len;
309    
310          moveto(row, col);          moveto(row, col);
311          prints("%s", prompt);          prints("%s", prompt);
312          prints("%s", buffer);          prints("%s", buffer);
313            prints("%*s", max_display_len - display_len, "");
314            moveto(row, col_cur);
315          iflush();          iflush();
316    
317          len = _str_input(buffer, buf_size, max_display_len, echo_mode);          igetch_reset();
318    
319            while (!SYS_server_exit)
320            {
321                    ch = igetch_t(MIN(MAX_DELAY_TIME, 60));
322    
323                    if (ch == CR)
324                    {
325                            igetch_reset();
326                            break;
327                    }
328                    else if (ch == KEY_TIMEOUT || ch == KEY_NULL) // timeout or broken pipe
329                    {
330                            return -1;
331                    }
332                    else if (ch == LF || ch == '\0')
333                    {
334                            continue;
335                    }
336                    else if (ch == BACKSPACE)
337                    {
338                            if (offset > 0)
339                            {
340                                    str_len = 1;
341                                    offset--;
342                                    if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
343                                    {
344                                            while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)
345                                            {
346                                                    str_len++;
347                                                    offset--;
348                                            }
349                                            display_len--;
350                                            col_cur--;
351                                    }
352    
353                                    memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
354                                    len -= str_len;
355                                    buffer[len] = '\0';
356                                    display_len--;
357                                    col_cur--;
358    
359                                    moveto(row, col_cur);
360                                    prints("%s", buffer + offset);
361                                    prints("%*s", max_display_len - display_len, "");
362                                    moveto(row, col_cur);
363                                    iflush();
364                            }
365                            continue;
366                    }
367                    else if (ch == KEY_DEL)
368                    {
369                            if (offset < len)
370                            {
371                                    if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
372                                    {
373                                            str_len = 0;
374                                            c = (char)(buffer[offset] & 0b11110000);
375                                            while (c & 0b10000000)
376                                            {
377                                                    str_len++;
378                                                    c = (c & 0b01111111) << 1;
379                                            }
380                                            display_len--;
381                                    }
382                                    else
383                                    {
384                                            str_len = 1;
385                                    }
386    
387                                    memmove(buffer + offset, buffer + offset + str_len, (size_t)(len - offset - str_len));
388                                    len -= str_len;
389                                    buffer[len] = '\0';
390                                    display_len--;
391    
392                                    moveto(row, col_cur);
393                                    prints("%s", buffer + offset);
394                                    prints("%*s", max_display_len - display_len, "");
395                                    moveto(row, col_cur);
396                                    iflush();
397                            }
398                            continue;
399                    }
400                    else if (ch == KEY_LEFT)
401                    {
402                            if (offset > 0)
403                            {
404                                    str_len = 1;
405                                    offset--;
406                                    if (buffer[offset] < 0 || buffer[offset] > 127) // UTF8
407                                    {
408                                            while (offset > 0 && (buffer[offset] & 0b11000000) != 0b11000000)
409                                            {
410                                                    str_len++;
411                                                    offset--;
412                                            }
413                                            col_cur--;
414                                    }
415                                    col_cur--;
416    
417                                    moveto(row, col_cur);
418                                    iflush();
419                            }
420                            continue;
421                    }
422                    else if (ch == KEY_RIGHT)
423                    {
424                            if (offset < len)
425                            {
426                                    str_len = 0;
427                                    if ((buffer[offset] & 0x80) == 0x80) // head of multi-byte character
428                                    {
429                                            c = (char)(buffer[offset] & 0b11110000);
430                                            while (c & 0b10000000)
431                                            {
432                                                    str_len++;
433                                                    c = (c & 0b01111111) << 1;
434                                            }
435                                            col_cur++;
436                                    }
437                                    else
438                                    {
439                                            str_len = 1;
440                                    }
441    
442                                    col_cur++;
443                                    offset += str_len;
444    
445                                    moveto(row, col_cur);
446                                    iflush();
447                            }
448                            continue;
449                    }
450                    else if (ch == KEY_HOME || ch == KEY_UP)
451                    {
452                            if (offset > 0)
453                            {
454                                    offset = 0;
455                                    col_cur = col + str_length(prompt, 1);
456    
457                                    moveto(row, col_cur);
458                                    iflush();
459                            }
460                            continue;
461                    }
462                    else if (ch == KEY_END || ch == KEY_DOWN)
463                    {
464                            if (offset < len)
465                            {
466                                    offset = len;
467                                    col_cur = col + str_length(prompt, 1) + display_len;
468    
469                                    moveto(row, col_cur);
470                                    iflush();
471                            }
472                            continue;
473                    }
474                    else if (ch > 255 || iscntrl(ch))
475                    {
476                            continue;
477                    }
478                    else if ((ch & 0xff80) == 0x80) // head of multi-byte character
479                    {
480                            str_len = 0;
481                            c = (char)(ch & 0b11110000);
482                            while (c & 0b10000000)
483                            {
484                                    input_str[str_len] = (char)(ch - 256);
485                                    str_len++;
486                                    c = (c & 0b01111111) << 1;
487    
488                                    if ((c & 0b10000000) == 0) // Input completed
489                                    {
490                                            break;
491                                    }
492    
493                                    // Expect additional bytes of input
494                                    ch = igetch(100);                                                // 0.1 second
495                                    if (ch == KEY_NULL || ch == KEY_TIMEOUT) // Ignore received bytes if no futher input
496                                    {
497    #ifdef _DEBUG
498                                            log_error("Ignore %d bytes of incomplete UTF8 character\n", str_len);
499    #endif
500                                            str_len = 0;
501                                            break;
502                                    }
503                            }
504    
505                            if (str_len == 0) // Incomplete input
506                            {
507                                    continue;
508                            }
509    
510                            if (len + str_len > buf_size - 1 || display_len + 2 > max_display_len) // No enough space for Chinese character
511                            {
512                                    outc('\a');
513                                    iflush();
514                                    continue;
515                            }
516    
517                            memmove(buffer + offset + str_len, buffer + offset, (size_t)(len - offset));
518                            memcpy(buffer + offset, input_str, (size_t)str_len);
519                            len += str_len;
520                            buffer[len] = '\0';
521                            display_len += 2;
522    
523                            moveto(row, col_cur);
524                            prints("%s", buffer + offset);
525                            prints("%*s", max_display_len - display_len, "");
526    
527                            col_cur += 2;
528    
529                            moveto(row, col_cur);
530                            iflush();
531    
532                            offset += str_len;
533                    }
534                    else if (ch >= 32 && ch < 127) // Printable character
535                    {
536                            if (len + 1 > buf_size - 1 || display_len + 1 > max_display_len)
537                            {
538                                    outc('\a');
539                                    iflush();
540                                    continue;
541                            }
542    
543                            memmove(buffer + offset + 1, buffer + offset, (size_t)(len - offset));
544                            buffer[offset] = (char)ch;
545                            len++;
546                            buffer[len] = '\0';
547                            display_len++;
548    
549                            moveto(row, col_cur);
550                            prints("%s", buffer + offset);
551                            prints("%*s", max_display_len - display_len, "");
552    
553                            col_cur++;
554    
555                            moveto(row, col_cur);
556                            iflush();
557    
558                            offset++;
559                    }
560                    else // Invalid character
561                    {
562                            continue;
563                    }
564            }
565    
566          return len;          return len;
567  }  }

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