c - 滚动菜单(c代码)

Question

我想创建一个最多 10 行窗口的菜单，并在该窗口中显示 xml 文件中的所有项目(包含超过 10 个项目)，通过在窗口中向上/向下滚动行以查看文件的所有内容。

问题:如何在我的 API 中实现这一点(比如在 ncurses 滚动菜单中):

“如果为窗口指定的子窗口不够大，无法显示所有项目，则菜单将是可滚动的。当您位于当前列表中的最后一项时，如果您发送 REQ_DOWN_ITEM，它会被转换为REQ_SCR_DLINE 和菜单滚动一项。你可以手动给 REQ_SCR_ 操作来做滚动。让我们看看它是如何完成的。“

此功能的部分代码:

static void menu( commands_t *cmd )
{
    /* this display only first 10 line */
    int i; 
    char string[ 128 ];
    for( i = 0; i < 10; i++ ) {
        snprintf( string, sizeof (string), "%s", list_get_name( cmd->listmgr, i ) );
        menu_list_set_text( cmd->menu, i, string );
    }
}

目前，此功能只能显示列表中的前 10 项。

                       A
                       B
                       C  
                       D
                       E
                -----------------
Line 01         |      F        |   
Line 02         |      G        |
Line 03         |      H        |
Line 04         |      I        |
Line 05         |      J        |    
Line 06         |      K        |   
Line 07         |      L        |
Line 08         |      M        |
Line 09         |      N        |
Line 10         |      O        |   
                -----------------
                       P
                       Q
                       R
                       S
                       T
                    .......
                       Z

为此，我尝试创建能够在列表的菜单行中设置文本、在菜单中向上/向下移动光标的 API，但我现在不知道如何向上或向下移动行。

typedef struct list_info_s list_info_t;
struct list_info_s
{
    int position;
    char name[ 50 ];

    list_info_t *next;
    list_info_t *prev;
};

const list_info_t *list_get_list( list_mgr_t *mgr, int pos)
{
    const list_info_t *tmp = mgr->first;
    int i;
    for (i = 0; tmp && i < pos; i++)
        tmp = tmp->next;
    return tmp;
}

const char *list_get_name( list_mgr_t *mgr, int position )
{
    const list_info_t *list = list_get_list(mgr, position);
    if( (list) && (*list->name) ) {
        return list->name;
    } else {
        return 0;
    }
}

TO MOVE UP/DOWN:

void commands_handle( commands_t *cmd, int prog_cmd )
{
    switch( prog_cmd ) {
    case MENU_UP:
        cmd->menu_position = (cmd->menu_position + cmd->menu_size - 1) % (cmd->menu_size);
        menu( cmd );
        break;
    case MENU_DOWN:
        cmd->menu_position = (cmd->menu_position + 1) % (cmd->menu_size);
        menu( cmd );
        break;
    return;
    }
} 


MENU:


static void menu( commands_t *cmd )
{
    /* this display only first 10 line */
    int i; 
    char string[ 128 ];
    for( i = 0; i < 10; i++ ) {
        snprintf( string, sizeof (string), "%s", list_get_name( cmd->listmgr, i ) );
        menu_list_set_text( cmd->menu, i, string );
    }
}

菜单的窗口最多为 10 个项目行，因为 xml 可能包含大量项目。哪些编程选项必须通过按向上/向下按钮显示文件中的所有行才能在菜单上可见？

这是菜单的实际 API:

#define MENU_MAX 10

struct menu_s
{
    char *name;
    char text[ MENU_MAX ][ 128 ];
    char arguments[ MENU_MAX ][ 128 ];
    int commands[ MENU_MAX ];
    char back_argument[ 128 ];
    int back_command;
    int numlines;
    int cursor;
    int defaultcursor;
};

menu_t *menu_new( const char *name )
{
    menu_t *menu = malloc( sizeof( menu_t ) );
    if( !menu ) {
    return 0;
    }

    menu->numlines = 0;
    menu->cursor = 0;
    menu->defaultcursor = 0;
    menu->name = strdup( name );
    if( !menu->name ) {
        free( menu );
        return 0;
    }

    return menu;
}

void menu_delete( menu_t *menu )
{
    free( menu->name );
    free( menu );
}

void menu_reset_num_lines( menu_t *menu )
{
    menu->numlines = 0;
}

void menu_set_text( menu_t *menu, int line, const char *text )
{
    snprintf( menu->text[ line ], sizeof( menu->text[ 0 ] ), "%s", text );
    if( line >= menu->numlines ) menu->numlines = line + 1;
}

void menu_set_enter_command( menu_t *menu, int line, int command,
                         const char *argument )
{
    menu->commands[ line ] = command;
    snprintf( menu->argum#define MENU_MAX 10

struct menu_s
{
    char *name;
    char text[ MENU_MAX ][ 128 ];
    char arguments[ MENU_MAX ][ 128 ];
    int commands[ MENU_MAX ];
    char back_argument[ 128 ];
    int back_command;
    int numlines;
    int cursor;
    int defaultcursor;
};

menu_t *menu_new( const char *name )
{
    menu_t *menu = malloc( sizeof( menu_t ) );
    if( !menu ) {
    return 0;
    }

    menu->numlines = 0;
    menu->cursor = 0;
    menu->defaultcursor = 0;
    menu->name = strdup( name );
    if( !menu->name ) {
        free( menu );
        return 0;
    }

    return menu;
}

void menu_delete( menu_t *menu )
{
    free( menu->name );
    free( menu );
}

void menu_reset_num_lines( menu_t *menu )
{
    menu->numlines = 0;
}

void menu_set_text( menu_t *menu, int line, const char *text )
{
    snprintf( menu->text[ line ], sizeof( menu->text[ 0 ] ), "%s", text );
    if( line >= menu->numlines ) menu->numlines = line + 1;
}

void menu_set_enter_command( menu_t *menu, int line, int command,
                         const char *argument )
{
    menu->commands[ line ] = command;
    snprintf( menu->arguments[ line ], sizeof( menu->arguments[ 0 ] ),
          "%s", argument );
}

void menu_set_back_command( menu_t *menu, int command,
                        const char *argument )
{
    menu->back_command = command;
    snprintf( menu->back_argument, sizeof( menu->back_argument ),
          "%s", argument );
}

void menu_set_cursor( menu_t *menu, int cursor )
{
    menu->cursor = cursor;
}

const char *menu_get_name( menu_t *menu )
{
    return menu->name;
}

int menu_get_num_lines( menu_t *menu )
{
    return menu->numlines;
}

const char *menu_get_text( menu_t *menu, int line )
{
    return menu->text[ line ];
}

int menu_get_enter_command( menu_t *menu, int line )
{
    return menu->commands[ line ];
}

const char *menu_get_enter_argument( menu_t *menu, int line )
{
    return menu->arguments[ line ];
}

int menu_get_back_command( menu_t *menu )
{
    return menu->back_command;
}

const char *menu_get_back_argument( menu_t *menu )
{
    return menu->back_argument;
}

int menu_get_cursor( menu_t *menu )
{
    return menu->cursor;
}

int menu_get_default_cursor( menu_t *menu )
{
    return menu->defaultcursor;
}

我尝试了一个丑陋的解决方案:

static void menu( commands_t *cmd )
{
    int i;
    for( i = 0; i < 10; i++ ) {
        char string[ 128 ];
        snprintf( string, sizeof (string), "%s", list_get_name( cmd->listmgr, i )
        menu_list_set_text( cmd->menu, i, string );
        int scroll;
        for( scroll = 0; scroll < list_size; scroll++ ) {
            if( cmd->curmenupos == 10 + scroll ) {
                snprintf( string, sizeof (string), "%s", list_get_name( cmd->listmgr, i + scroll + 1 )
                menu_list_set_text( cmd->menu, i, string );
            }
         }
      }
   }

其中“cmd->curmenupos”是获取菜单行位置的命令， “list_size”是来自 xml 的项目数

Answer 1

您可以通过使用 ring buffer 的基于数组的实现来稍微简化您的解决方案。然后只从左上角的头部/尾部打印您的菜单。然后滚动简单地变成推进头部/尾部并用新的行覆盖正在消失的行。使用基于数组的实现应该没问题，因为您的行号无论如何都是不变的。

根据 IO 的速度，您的软件可能会使用较少的 IO 资源，从而通过对旧行进行一些简单的缓存来提高性能。 Keep in mind not to prematurely optimize这可以通过让环形缓冲区的条目数多于屏幕上的行数来实现，然后仅在滚动到某个点后才覆盖。