Question

我想创建一个最多10行窗口的菜单，并在此窗口中显示xml文件中的所有项目（包含10个以上项目），在窗口中向上/向下滚动查看文件的所有内容。 / p>

问题：如何在我的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-＆gt; curmenupos”是获取菜单行位置的命令 “list_size”是来自xml

的项目数

Answer 1

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

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

滚动菜单（c代码）

1 个答案: