回 目 录
上 一 章 下 一 章

# 第十六章：面板库

  现在你应该已经很精通curses库了，你可能会想试着做一些更大的项目。为了让界面看起来更专业，于是你就创建了许多重叠的窗口。但很不幸的是，你很快会发现它们变得难以管理，多次的更新窗口使开发变成了一场恶梦。如果你没有按照适当的顺序刷新那些窗口的话，它们就会给你带来很多麻烦。

  不过别失望，面板库（Panel Library）提供了一个很好的解决方案。用ncureses 的开发者的话来说就是：

  如果你的界面设计需要使窗口在运行的时候置底或者置顶，你就会发现不光显示正确的结果很困难，而且为此付出得代价很大。这时候Panels库就可以派上用场了。

  如果你要处理很多重叠的窗口，选择panels 库绝对没错。通过一系列的wnoutrefresh()函数和doupdate()函数调用可以大大减少工作量。面板库实时控制着窗口的顺序信息，并且可以处理好重叠顺序，而且可以适时的更新屏幕。读到这里，你是不是又开始激动了呢？那还等什么呢，让我们继续！

### 16.1 基础知识

  面板对象实际上也是一个窗口，它被认为是一块包含所有面板对象的一个平台。这个平台可以看作是一个栈，栈顶的面板是完全可见的，其它的面板就被“压”在下面。所有面板根据所处栈的位置不同从而决定它是否可见。基本思想就是：创建一个栈来保存那些重叠的面板，然后使用面板库来正确的显示它们。可以调用一个类似于 refresh（）的函数来以正确的显示顺序显示这些面板。 面板库提供了一些可以隐藏、显示、移动和改变其大小等操作的函数。这样，我们就可以通过调用面板库提供的函数来解决重叠的窗口的问题了。

  一般的，一个面板程序的设计流程如下：

  1、 创建要添加到面板里面去的窗口（使用newwin（））。

  2、 创建一个有合适可见顺序的面板，根据需要的可见顺序把它们压进栈。函数new_panel() 可以用来创建面板。

  3、 调用update_panels() 把面板按正确的顺序写到虚拟屏幕上，调用doupdate()让它在现实器上显示。

  4、 调用show_panel(), hide_panel(), move_panel()等函数来对面板进行操作。可以使用一些例如panel_hidden() 和 panel_window()之类的辅助函数。你也可以使用用户指针来存储为一个定制面板的数据。而且可以使用函数 set_panel_userptr() 和 panel_userptr() 来设置和取得一个面板的用户指针。

  5、 所有的工作都做完后用del_panel() 删除这个面板。

  接下来我们通过一些程序来加深一下对这些概念的理解。下面的将要看到的程序创建了3个重叠的面板并把它们按次序显示在屏幕上。

### 16.2 编译包含面板库的程序

  要使用面板库里的函数，你首先要把panel.h这个头文件包含到你的代码中。如果要把编译并连接与面板库相关的程序的话就要同时添加-lpanel和 –lncurses两个参数。

    #include <panel.h>
        .
        .
        .
    	编译和连接: gcc  -lpanel –lncurses

例14．一个有关面板库的基础例子

    #include <panel.h>

    int main()
    {
    	WINDOW *my_wins[3];
    	PANEL  *my_panels[3];
    	int lines = 10, cols = 40, y = 2, x = 4, i;

    	initscr();
    	cbreak();
    	noecho();
    	/* 为每个面板创建窗口 */
    	my_wins[0] = newwin(lines, cols, y, x);
    	my_wins[1] = newwin(lines, cols, y + 1, x + 5);
    	my_wins[2] = newwin(lines, cols, y + 2, x + 10);

    	/* 为窗口添加创建边框以便你能看到面板的效果 */
    	for(i = 0; i < 3; +++i)
    		box(my_wins[i], 0, 0);

    	/* 按自底向上的顺序，把给每个窗口添加进一个面板 */
    	my_panels[0] = new_panel(my_wins[0]);/* 把面板0压进栈, 叠放顺序: stdscr-0 */
    	my_panels[1] = new_panel(my_wins[1]);/* 把面板1压进栈, 叠放顺序: stdscr-0-1 */
    	my_panels[2] = new_panel(my_wins[2]);/* 把面板2压进栈, 叠放顺序: stdscr-0-1-2 */

    	/* 更新栈的顺序。把面板2置于栈顶  */
    	update_panels();

    	/* 在屏幕上显示 */
    	doupdate();

    	getch();
    	endwin();
    }

  如你所见，上面的这个程序就是按照前面所讲的那个流程进行的。用newwin() 创建窗口，然后用new_panel()把它们添加到面板库里面去，当我们把那些面板一个一个压进栈的时候，panels栈也就随之更新了。调用update_panels() 和 doupdate() 就可以让它们在屏幕上显示出来。

### 16.3 面板窗口浏览

  下面给出一个稍微复杂点的例子。这个程序创建了3个窗口，通过使用键可以使它们循环置顶显示。让我们来看一下代码：

例15 一个面板窗口浏览的例子

    #include <panel.h>
    #define NLINES 10
    #define NCOLS 40

    void init_wins(WINDOW **wins, int n);
    void win_show(WINDOW *win, char *label, int label_color);
    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color);

    int main()
    {
    	WINDOW *my_wins[3];
    	PANEL  *my_panels[3];
    	PANEL  *top;
    	int ch;

    	/*初始化curses */
    	initscr();
    	start_color();
    	cbreak();
    	noecho();
    	keypad(stdscr, TRUE);

    	/* 初始化所有的颜色 */
    	init_pair(1, COLOR_RED, COLOR_BLACK);
    	init_pair(2, COLOR_GREEN, COLOR_BLACK);
    	init_pair(3, COLOR_BLUE, COLOR_BLACK);
    	init_pair(4, COLOR_CYAN, COLOR_BLACK);

    	init_wins(my_wins, 3);

    	/* 按自底向上的顺序，把每个窗口添加进一个面板  */
    	my_panels[0] = new_panel(my_wins[0]);	/* 把面板0压入栈， 顺序: stdscr-0 */
    	my_panels[1] = new_panel(my_wins[1]); 	/* 把面板1压入栈，顺序: stdscr-0-1 */
    	my_panels[2] = new_panel(my_wins[2]); 	/* 把面板2压入栈，顺序: stdscr-0-1-2 */

    	/* 为下一个面板建立用户指针 */
    	set_panel_userptr(my_panels[0], my_panels[1]);
    	set_panel_userptr(my_panels[1], my_panels[2]);
    	set_panel_userptr(my_panels[2], my_panels[0]);

    	/* 更新面板栈的顺序。把面板2置于栈顶*/
    	update_panels();

    	/* 在屏幕上显示*/
    	attron(COLOR_PAIR(4));
    	mvprintw(LINES - 2, 0, "Use tab to browse through the windows (F1 to Exit)");
    	attroff(COLOR_PAIR(4));
    	doupdate();

    	top = my_panels[2];
    	while((ch = getch()) != KEY_F(1))
    	{	switch(ch)
    		{	case 9:
    				top = (PANEL *)panel_userptr(top);
    				top_panel(top);
    				break;
    		}
    		update_panels();
    		doupdate();
    	}
    	endwin();
    	return 0;
    }

    /* 显示所有的窗口 */
    void init_wins(WINDOW **wins, int n)
    {
    	int x, y, i;
    	char label[80];

    	y = 2;
    	x = 10;
    	for(i = 0; i < n; ++i)
    	{	wins[i] = newwin(NLINES, NCOLS, y, x);
    		sprintf(label, "Window Number %d", i + 1);
    		win_show(wins[i], label, i + 1);
    		y += 3;
    		x += 7;
    	}
    }

    /* 用一个边框和控件显示所有的窗口 */
    void win_show(WINDOW *win, char *label, int label_color)
    {
    	int startx, starty, height, width;

    	getbegyx(win, starty, startx);
    	getmaxyx(win, height, width);

    	box(win, 0, 0);
    	mvwaddch(win, 2, 0, ACS_LTEE);
    	mvwhline(win, 2, 1, ACS_HLINE, width - 2);
    	mvwaddch(win, 2, width - 1, ACS_RTEE);

    	print_in_middle(win, 1, 0, width, label, COLOR_PAIR(label_color));
    }

    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color)
    {
    	int length, x, y;
    	float temp;

    	if(win == NULL)
    		win = stdscr;
    	getyx(win, y, x);
    	if(startx != 0)
    		x = startx;
    	if(starty != 0)
    		y = starty;
    	if(width == 0)
    		width = 80;

    	length = strlen(string);
    	temp = (width - length)/ 2;
    	x = startx + (int)temp;
    	wattron(win, color);
    	mvwprintw(win, y, x, "%s", string);
    	wattroff(win, color);
    	refresh();
    }

### 16.4 使用用户指针

  在上面的例子中，为了在这个循环例查找下一个窗口我使用了用户指针。我们可以通过指定一个用户指针给面板增加自定义信息，这个指针可以指向你想要存储的任何信息。在这个例子中，我往指针里面存储了循环中的下一个面板。一个面板的用户指针可以用函数set_panel_userptr() 来设定。用面板作为函数panel_userptr() 参变量可以访问它，函数将返回这个面板的用户指针。在循环中查找下一个面板结束后，通过使用函数top_panel() 可以将其置于顶层。用给定的面板作为参变量，这个函数将会把这个面板置于面板栈的顶层。

### 16.5 移动面板和改变面板的大小

  函数move_panel()可以将面板移动到你想移动的地方。它不改变面板在栈里的位置。务必使用move_panel()而不是用来移动窗口的函数mvwin() 来移动面板。

  改变面板的大小有一点点复杂，没有哪个函数可以用来直接改变和面板关联的窗口的大小。要改变面板的大小，只有创建一个大小为你所需的新窗口。用函数replace_panel()可以替换和相应面板关联的窗口。但是别忘了要删除旧的窗口。和面板关联的窗口可以使用函数panel_window()来创建。

  下面这个程序就用简单的方式体现了这个概念。同样，你可以用键来使它们循环。要改变大小或移动当前的面板你可以按下 ‘ r’ 或 ‘ m ’键。然后使用方向键来改变大小和移动。在具体操作时，为获得需要的结果这个例子利用了用户已有的数据。

例16、 一个移动和改变面板大小的例子

    #include <panel.h>

    typedef struct _PANEL_DATA {
    	int x, y, w, h;
    	char label[80];
    	int label_color;
    	PANEL *next;
    }PANEL_DATA;

    #define NLINES 10
    #define NCOLS 40

    void init_wins(WINDOW **wins, int n);
    void win_show(WINDOW *win, char *label, int label_color);
    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color);
    void set_user_ptrs(PANEL **panels, int n);

    int main()
    {	WINDOW *my_wins[3];
    	PANEL  *my_panels[3];
    	PANEL_DATA  *top;
    	PANEL *stack_top;
    	WINDOW *temp_win, *old_win;
    	int ch;
    	int newx, newy, neww, newh;
    	int size = FALSE, move = FALSE;

    	/* 初始化curses */
    	initscr();
    	start_color();
    	cbreak();
    	noecho();
    	keypad(stdscr, TRUE);

    	/* 初始化所有的颜色 */
    	init_pair(1, COLOR_RED, COLOR_BLACK);
    	init_pair(2, COLOR_GREEN, COLOR_BLACK);
    	init_pair(3, COLOR_BLUE, COLOR_BLACK);
    	init_pair(4, COLOR_CYAN, COLOR_BLACK);

    	init_wins(my_wins, 3);

    	/* 更新面板栈的顺序。把面板2置于栈顶*/
    	my_panels[0] = new_panel(my_wins[0]); 	/* 把面板0压入栈，顺序: stdscr-0 */
    	my_panels[1] = new_panel(my_wins[1]); 	/* 把面板1压入栈。顺序: stdscr-0-1 */
    	my_panels[2] = new_panel(my_wins[2]); 	/* 把面板2压入栈,顺序: stdscr-0-1-2 */

    	set_user_ptrs(my_panels, 3);
    	/* 更新面板栈的顺序。把面板2置于栈顶 */
    	update_panels();

    	/* 在屏幕上显示出来 */
    	attron(COLOR_PAIR(4));
    	mvprintw(LINES - 3, 0, "Use 'm' for moving, 'r' for resizing");
    	mvprintw(LINES - 2, 0, "Use tab to browse through the windows (F1 to Exit)");
    	attroff(COLOR_PAIR(4));
    	doupdate();

    	stack_top = my_panels[2];
    	top = (PANEL_DATA *)panel_userptr(stack_top);
    	newx = top->x;
    	newy = top->y;
    	neww = top->w;
    	newh = top->h;
    	while((ch = getch()) != KEY_F(1))
    	{	switch(ch)
    		{	case 9:				/* Tab 对应编号 */
    				top = (PANEL_DATA *)panel_userptr(stack_top);
    				top_panel(top->next);
    				stack_top = top->next;
    				top = (PANEL_DATA *)panel_userptr(stack_top);
    				newx = top->x;
    				newy = top->y;
    				neww = top->w;
    				newh = top->h;
    				break;
    			case 'r':				/* 改变大小*/
    				size = TRUE;
    				attron(COLOR_PAIR(4));
    				mvprintw(LINES - 4, 0, "Entered Resizing :Use Arrow Keys to resize and press <ENTER> to end resizing");
    				refresh();
    				attroff(COLOR_PAIR(4));
    				break;
    			case 'm':				/* 移动 */
    				attron(COLOR_PAIR(4));
    				mvprintw(LINES - 4, 0, "Entered Moving: Use Arrow Keys to Move and press <ENTER> to end moving");
    				refresh();
    				attroff(COLOR_PAIR(4));
    				move = TRUE;
    				break;
    			case KEY_LEFT:
    				if(size == TRUE)
    				{	--newx;
    					++neww;
    				}
    				if(move == TRUE)
    					--newx;
    				break;
    			case KEY_RIGHT:
    				if(size == TRUE)
    				{	++newx;
    					--neww;
    				}
    				if(move == TRUE)
    					++newx;
    				break;
    			case KEY_UP:
    				if(size == TRUE)
    				{	--newy;
    					++newh;
    				}
    				if(move == TRUE)
    					--newy;
    				break;
    			case KEY_DOWN:
    				if(size == TRUE)
    				{	++newy;
    					--newh;
    				}
    				if(move == TRUE)
    					++newy;
    				break;
    			case 10:				/* Enter对应编号 */
    				move(LINES - 4, 0);
    				clrtoeol();
    				refresh();
    				if(size == TRUE)
    				{	old_win = panel_window(stack_top);
    					temp_win = newwin(newh, neww, newy, newx);
    					replace_panel(stack_top, temp_win);
    					win_show(temp_win, top->label, top->label_color);
    					delwin(old_win);
    					size = FALSE;
    				}
    				if(move == TRUE)
    				{	move_panel(stack_top, newy, newx);
    					move = FALSE;
    				}
    				break;

    		}
    		attron(COLOR_PAIR(4));
    		mvprintw(LINES - 3, 0, "Use 'm' for moving, 'r' for resizing");
    	    mvprintw(LINES - 2, 0, "Use tab to browse through the windows (F1 to Exit)");
    	    	attroff(COLOR_PAIR(4));
    	        refresh();
    		update_panels();
    		doupdate();
    	}
    	endwin();
    	return 0;
    }

    /* 显示所有的窗口 */
    void init_wins(WINDOW **wins, int n)
    {	int x, y, i;
    	char label[80];

    	y = 2;
    	x = 10;
    	for(i = 0; i < n; ++i)
    	{	wins[i] = newwin(NLINES, NCOLS, y, x);
    		sprintf(label, "Window Number %d", i + 1);
    		win_show(wins[i], label, i + 1);
    		y += 3;
    		x += 7;
    	}
    }

    /* 把每个面板设置为 PANEL_DATA 结构 */
    void set_user_ptrs(PANEL **panels, int n)
    {	PANEL_DATA *ptrs;
    	WINDOW *win;
    	int x, y, w, h, i;
    	char temp[80];

    	ptrs = (PANEL_DATA *)calloc(n, sizeof(PANEL_DATA));

    	for(i = 0;i < n; ++i)
    	{	win = panel_window(panels[i]);
    		getbegyx(win, y, x);
    		getmaxyx(win, h, w);
    		ptrs[i].x = x;
    		ptrs[i].y = y;
    		ptrs[i].w = w;
    		ptrs[i].h = h;
    		sprintf(temp, "Window Number %d", i + 1);
    		strcpy(ptrs[i].label, temp);
    		ptrs[i].label_color = i + 1;
    		if(i + 1 == n)
    			ptrs[i].next = panels[0];
    		else
    			ptrs[i].next = panels[i + 1];
    		set_panel_userptr(panels[i], &ptrs[i]);
    	}
    }
    /* 用一个边框和标题栏来显示窗口 */
    void win_show(WINDOW *win, char *label, int label_color)
    {	int startx, starty, height, width;

    	getbegyx(win, starty, startx);
    	getmaxyx(win, height, width);

    	box(win, 0, 0);
    	mvwaddch(win, 2, 0, ACS_LTEE);
    	mvwhline(win, 2, 1, ACS_HLINE, width - 2);
    	mvwaddch(win, 2, width - 1, ACS_RTEE);

    	print_in_middle(win, 1, 0, width, label, COLOR_PAIR(label_color));
    }

    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color)
    {	int length, x, y;
    	float temp;

    	if(win == NULL)
    		win = stdscr;
    	getyx(win, y, x);
    	if(startx != 0)
    		x = startx;
    	if(starty != 0)
    		y = starty;
    	if(width == 0)
    		width = 80;

    	length = strlen(string);
    	temp = (width - length)/ 2;
    	x = startx + (int)temp;
    	wattron(win, color);
    	mvwprintw(win, y, x, "%s", string);
    	wattroff(win, color);
    	refresh();
    }

  我们把注意力集中在主循环上。一旦程序捕获某个键被按下，它就执行相应的动作。如果按下了‘r’键，“更改大小”模式就启动了。用户可以通过按方向键来更改面板的大小。当用户按键时，就确定了面板的新尺寸，程序就依照上面介绍的方法更改大小。不过在“更改大小”模式中，程序并没有真正显示出面板更改大小后的边框。这就留给读者一个作业：用点来显示新尺寸面板的边框。

  当用户按‘m’键时“移动面板”模式就启动了。这个操作会比“更改大小”简单一点。随着方向键的按下，新面板的位置也随之移动，当键按下时，程序就调用panel()函数把面板移动到光标的当前位置。

  在这个示范程序中，用户数据就代表PANEL_DATA，在查找面板的相关信息时扮演重要角色。就象在说明中所写，PANEL_DATA保存了面板的尺寸，标题，标题颜色和循环中指向下一个面板的指针。

### 16.6 隐藏和显示面板

  隐藏一个面板可以使用函数hide_panel()。这个函数仅仅是把它从面板栈中移走，因此，要在屏幕上隐藏的话只要调用函数update_panels() 和 doupdate()就可以了。它不会破坏面板结构和这个隐藏的面板。函数show_panel()可以让它重新显示。

  下面的程序显示了如何隐藏面板。按键 ’a’ 或 ’b’ 或 ‘c’来分别实现显示或隐藏第一，二，三个窗口，其它的依此类推。它使用了一个用户给定的一个带有隐藏的变量的数据，用来跟踪窗口是否是隐藏的。因为某些原因，按理用来告诉用户一个面板是否隐藏的函数panel_hidden没有起作用。Michael Andres 在这里提供了一个错误报告。

例17、 一个隐藏和显示面板的例子

    #include <panel.h>

    typedef struct _PANEL_DATA {
    	int hide;						/* 如果面板是隐藏的时候为真  */
    }PANEL_DATA;

    #define NLINES 10
    #define NCOLS 40

    void init_wins(WINDOW **wins, int n);
    void win_show(WINDOW *win, char *label, int label_color);
    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color);

    int main()
    {	WINDOW *my_wins[3];
    	PANEL  *my_panels[3];
    	PANEL_DATA panel_datas[3];
    	PANEL_DATA *temp;
    	int ch;

    	/* 初始化curses */
    	initscr();
    	start_color();
    	cbreak();
    	noecho();
    	keypad(stdscr, TRUE);

    	/* 初始化所有的颜色 */
    	init_pair(1, COLOR_RED, COLOR_BLACK);
    	init_pair(2, COLOR_GREEN, COLOR_BLACK);
    	init_pair(3, COLOR_BLUE, COLOR_BLACK);
    	init_pair(4, COLOR_CYAN, COLOR_BLACK);

    	init_wins(my_wins, 3);

    	/* 更新面板栈的顺序。把面板2置于栈顶 */
    	my_panels[0] = new_panel(my_wins[0]); 	/* Push 0, order: stdscr-0 */
    	my_panels[1] = new_panel(my_wins[1]); 	/* Push 1, order: stdscr-0-1 */
    	my_panels[2] = new_panel(my_wins[2]); 	/* Push 2, order: stdscr-0-1-2 */

    	/* 初始化所有的面板并都设为非隐藏的 */
    	panel_datas[0].hide = FALSE;
    	panel_datas[1].hide = FALSE;
    	panel_datas[2].hide = FALSE;

    	set_panel_userptr(my_panels[0], &panel_datas[0]);
    	set_panel_userptr(my_panels[1], &panel_datas[1]);
    	set_panel_userptr(my_panels[2], &panel_datas[2]);

    	/* 更新面板栈的顺序，第二个面板将置于栈顶 */
    	update_panels();

    	/* 在屏幕上显示 */
    	attron(COLOR_PAIR(4));
    	mvprintw(LINES - 3, 0, "Show or Hide a window with 'a'(first window)  'b'(Second Window)  'c'(Third Window)");
    	mvprintw(LINES - 2, 0, "F1 to Exit");

    	attroff(COLOR_PAIR(4));
    	doupdate();

    	while((ch = getch()) != KEY_F(1))
    	{	switch(ch)
    		{	case 'a':
    				temp = (PANEL_DATA *)panel_userptr(my_panels[0]);
    				if(temp->hide == FALSE)
    				{	hide_panel(my_panels[0]);
    					temp->hide = TRUE;
    				}
    				else
    				{	show_panel(my_panels[0]);
    					temp->hide = FALSE;
    				}
    				break;
    			case 'b':
    				temp = (PANEL_DATA *)panel_userptr(my_panels[1]);
    				if(temp->hide == FALSE)
    				{	hide_panel(my_panels[1]);
    					temp->hide = TRUE;
    				}
    				else
    				{	show_panel(my_panels[1]);
    					temp->hide = FALSE;
    				}
    				break;
    			case 'c':
    				temp = (PANEL_DATA *)panel_userptr(my_panels[2]);
    				if(temp->hide == FALSE)
    				{	hide_panel(my_panels[2]);
    					temp->hide = TRUE;
    				}
    				else
    				{	show_panel(my_panels[2]);
    					temp->hide = FALSE;
    				}
    				break;
    		}
    		update_panels();
    		doupdate();
    	}
    	endwin();
    	return 0;
    }

    /* 显示所有窗口 */
    void init_wins(WINDOW **wins, int n)
    {	int x, y, i;
    	char label[80];

    	y = 2;
    	x = 10;
    	for(i = 0; i < n; ++i)
    	{	wins[i] = newwin(NLINES, NCOLS, y, x);
    		sprintf(label, "Window Number %d", i + 1);
    		win_show(wins[i], label, i + 1);
    		y += 3;
    		x += 7;
    	}
    }

    /* 通过边框和标题显示窗口 */
    void win_show(WINDOW *win, char *label, int label_color)
    {	int startx, starty, height, width;

    	getbegyx(win, starty, startx);
    	getmaxyx(win, height, width);

    	box(win, 0, 0);
    	mvwaddch(win, 2, 0, ACS_LTEE);
    	mvwhline(win, 2, 1, ACS_HLINE, width - 2);
    	mvwaddch(win, 2, width - 1, ACS_RTEE);

    	print_in_middle(win, 1, 0, width, label, COLOR_PAIR(label_color));
    }

    void print_in_middle(WINDOW *win, int starty, int startx, int width, char *string, chtype color)
    {	int length, x, y;
    	float temp;

    	if(win == NULL)
    		win = stdscr;
    	getyx(win, y, x);
    	if(startx != 0)
    		x = startx;
    	if(starty != 0)
    		y = starty;
    	if(width == 0)
    		width = 80;

    	length = strlen(string);
    	temp = (width - length)/ 2;
    	x = startx + (int)temp;
    	wattron(win, color);
    	mvwprintw(win, y, x, "%s", string);
    	wattroff(win, color);
    	refresh();
    }

### 16.7 panel_above()和panel_below()类函数

  函数panel_above() 和 panel_below() 可以用来查看某一个面板的上面和下面的面板。如果函数的参变量为NULL，它们就分别返回一个指向最底层和最上层面板的指针。
回 目 录
上 一 章 下 一 章