3

我想创建一个最多 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 中的项目数

4

1 回答 1

0

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

根据 IO 的速度，您的软件可能会使用更少的 IO 资源，从而通过对旧行进行一些简单的缓存来提高性能。请记住不要过早优化这可以通过让环形缓冲区的条目多于屏幕上的行数来完成，然后仅在滚动超过某个点时覆盖。

于 2013-02-15T12:13:02.463 回答