内核开发之：使用图片分层技术实现窗口叠加

本节代码的深入讲解及演示过程请参看视频：
Linux kernel Hacker, 从零构建自己的内核

在前面的章节中，我们完成了鼠标的绘制，但存在一个严重的问题是，当鼠标移动的时候，鼠标下方的窗口或图案会因为内核重绘鼠标而被擦除掉，情况如下：

解决这个问题的办法是，每当鼠标移动时，我们先把底下的图案绘制一遍，然后把鼠标在移动后的新坐标处再绘制一遍。由此，我们引出一个叫图层的概念，鼠标下面的背景是一个图层，鼠标自己处于一个图层，图层间有高度差别，作为背景的图层，它的高度就要比鼠标所在的图层低，因此内核每次重绘时，先绘制高度低的图层，再绘制高度高的图层，我们使用的操作系统，用鼠标挪动窗口时，窗口底部的图案不受影响，就是使用了图层分层技术，基本原理如下图的：

有了基本原理后，我们可以编码实现了，首先定义图层的数据结构：

struct SHEET {
    unsigned char *buf;
    int bxsize, bysize, vx0, vy0, col_inv, height, flags;
};

buf对应的是窗口的像素信息，bxsize, bysize 是窗口的长和高，vx0, vy0是窗口移动后的左上角坐标，col_inv 用来表示窗口中不显示的部分，height表示图层的高度，flags用来表示图层状态。这里需要解释一下的变量是col_inv. 我们看看用来表示鼠标的buf, 有就是绘制鼠标的像素数组：

static char cursor[16][16] = {
        "**************..",
        "*OOOOOOOOOOO*...",
        "*OOOOOOOOOO*....",
        "*OOOOOOOOO*.....",
        "*OOOOOOOO*......",
        "*OOOOOOO*.......",
        "*OOOOOOO*.......",
        "*OOOOOOOO*......",
        "*OOOO**OOO*.....",
        "*OOO*..*OOO*....",
        "*OO*....*OOO*...",
        "*O*......*OOO*..",
        "**........*OOO*.",
        "*..........*OOO*",
        "............*OO*",
        ".............***"
    };

上面的数组对应的就是SHEET结构中的buf, 我们绘制鼠标时，是按照数组中的元素对应到像素点的，如果某个元素的值是 *, 那么对应的像素点是黑色，如果元素的值是0, 那么对应像素的颜色就是白色，如果元素的值是 . ,那么这些点对应的像素颜色不做任何改变，这样的话，下面图层的相关图案就可以“透视”出来。这些点对应的值就是SHEET中的col_inv.

有了图层后，我们还要定义图层管理器对象：

#define MAX_SHEETS  256
struct SHTCTL {
    unsigned char *vram;
    int xsize, ysize, top;
    struct SHEET *sheets[MAX_SHEETS];
    struct SHEET sheets0[MAX_SHEETS];
};

#define SIZE_OF_SHEET  32
#define SIZE_OF_SHTCTL 9232

其中vram 对应的是显存地址，也就是0xa0000, xsize, ysize 代表整个显示界面的宽和高，我们当前系统显示界面的大小是320 * 320. top 表示当前要显示几个图层， sheets0 是用来存储图层对象的数组，sheets 是指针数组，用来指向下面图层数组中的对应图层对象。根据图层数据结构，我们定义用来操作他们的相关函数接口：

struct SHEET *sheet_alloc(struct SHTCTL *ctl);
struct SHTCTL *shtctl_init(struct MEMMAN *memman, unsigned char *vram,
  int xsize, int ysize);
void sheet_setbuf(struct SHEET *sht, unsigned char *buf, int xsize, int ysize,
    int col_inv);
void sheet_updown(struct SHTCTL *ctl, struct SHEET *sht, int height);

int sheet_refresh(struct SHTCTL *ctl);


void sheet_slide(struct SHTCTL *ctl, struct SHEET *sht, int vx0, int vy0);

上面所有代码都定义在文件win_sheet.h中。我们继续看看相关代码的实现：

#include "mem_util.h"
#include "win_sheet.h"

struct SHTCTL *shtctl_init(struct MEMMAN *memman, unsigned char *vram,
  int xsize, int ysize) {
    struct SHTCTL *ctl;
    int i;
    ctl = (struct SHTCTL *)memman_alloc_4k(memman, SIZE_OF_SHTCTL);
    if (ctl == 0) {
        return 0;
    }

    ctl->vram = vram;
    ctl->xsize = xsize;
    ctl->ysize = ysize;
    ctl->top = -1;
    for (i = 0; i < MAX_SHEETS; i++) {
        ctl->sheets0[i].flags = 0;
    }

    return ctl;
}

#define SHEET_USE  1
struct SHEET *sheet_alloc(struct SHTCTL *ctl) {
    struct SHEET *sht;
    int i;
    for (i = 0; i < MAX_SHEETS; i++) {
        if (ctl->sheets0[i].flags == 0) {
            sht = &ctl->sheets0[i];
            ctl->sheets[i] = sht;
            sht->flags = SHEET_USE;
            sht->height = -1;
            return sht;
        }
    }

    return 0;
}

上面是两个初始化函数，分别初始化图层管理器和图层对象。在这两个函数中，使用到一个来自内存管理器的接口memman_alloc_4k， 顾名思义，就是向管理器申请一块大小为4k整数倍的内存，即使你只使用1字节，分配到的内存大小仍然是4k,一下子分配4k是为了防止内存碎片化过于严重，以造成浪费。我们看看memman_alloc_4k的实现，该函数的代码在文件mem_util.c中：

unsigned int memman_alloc_4k(struct MEMMAN *man, unsigned int size) {
    unsigned int a;
    size = (size + 0xfff) & 0xfffff000;
    a = memman_alloc(man, size);
    return a;
}

它的实现逻辑是这样的，4k对应的16进制数是0x1000, 如果你申请大小是1字节，那么 size + 0xfff 就等于是 0x1000, 跟0xfffff000 做与操作后，结果任然是0x1000, 如果你申请的内存大小是 0xfff, 也就是差1字节到4k, 那么size + 0xfff的结果是0x1FFE, 做与运算后结果也是0x1000, 所以这种计算方法能够在你申请任何大小内存的情况下，将大小圆整到大于所申请内存的最小4k倍数。

sheet_alloc用来分配一个图层对象给指定窗口，同时我们把图层的高设置成-1时，表示图层对应的窗口处于最小化状态。

void sheet_setbuf(struct SHEET *sht, unsigned char *buf, int xsize, int ysize,
    int col_inv) {
    sht->buf = buf;
    sht->bxsize = xsize;
    sht->bysize = ysize;
    sht->col_inv = col_inv;
    return;
}

sheet_setbuf将窗口对应的二位数组与图层对象关联起来，例如上面的数组cursor就是鼠标绘制数值，cursor数组将会跟通过上面的函数跟其图层对象关联起来。下面我们看的将是最为复杂的一个函数：

void sheet_updown(struct SHTCTL *ctl, struct SHEET *sht, int height) {
    int h, old = sht->height;
    if (height > ctl->top + 1) {
        height = ctl->top + 1;
    }

    if (height < -1) {
        height = -1;
    }

    sht->height = height;

    if (old > height) {
        if (height >= 0) {
            for (h = old; h > height; h--) {
                ctl->sheets[h] = ctl->sheets[h-1];
                ctl->sheets[h]->height = h;
            }

            ctl->sheets[height] = sht;
        } else {
            if (ctl->top > old) {
               for (h = old; h < ctl->top; h++) {
                   ctl->sheets[h] = ctl->sheets[h+1];
                   ctl->sheets[h]->height = h;
               }
            }

            ctl->top--;
        }

        sheet_refresh(ctl);
    } else if (old < height) {
        if (old >= 0) {
            for (h = old; h < height; h++) {
               ctl->sheets[h] = ctl->sheets[h + 1];
               ctl->sheets[h]->height = h;
            }

            ctl->sheets[height] = sht;
        } else {
            for (h = ctl->top; h >= height; h--) {
                ctl->sheets[h + 1] = ctl->sheets[h];
                ctl->sheets[h + 1]->height = h + 1;
            }

            ctl->sheets[height] = sht;
            ctl->top++;
        }

        sheet_refresh(ctl);
    }

}

这个函数比较大，我们分块分析。总体来说sheet_updown 是用来调整每个窗口图层的高度的，某个窗口被点击后，它会从底部冒到顶部，也就是原来被遮住看不到的部分会全部显示出来，这种情况就是up, 如果窗口被其他拖过来的窗口给遮住，这种情况就是down.

第一部分代码如下：

 int h, old = sht->height;
    if (height > ctl->top + 1) {
        height = ctl->top + 1;
    }

    if (height < -1) {
        height = -1;
    }

    sht->height = height;

如果是up, 也就是传进来的参数height比图层对应的高度要高，那么就改变图层的高度值，如果调整的高度过大，比如当前只桌面上只有三个窗口(ctl->top == 3)，但你要把新增窗口设置成100， 那么前面这段代码会把当前窗口的高度设置为4。

如果窗口下降高度，例如当前有三个窗口图层：
sheet1{height = 1;}
sheet2{height = 2;}
sheet3{hegiht = 3;}

现在最高的窗口sheet3高度要降为最低，那么就把sheet1, sheet2分别往后挪一个位置，然后将sheet3 放到最上面：
sheet3{hegiht = 1;}
sheet1{height = 2;}
sheet2{height = 3;}

这对应代码：

 if (old > height) {
        if (height >= 0) {
            for (h = old; h > height; h--) {
                ctl->sheets[h] = ctl->sheets[h-1];
                ctl->sheets[h]->height = h;
            }

            ctl->sheets[height] = sht;
        } else {
            ....
        }
    sheet_refresh(ctl);
 }

如果当前窗口最小话，那么该窗口对应的图层对象就从图层数组中去掉，例如sheet3的窗口最小化，那么图层数组由原来的：
sheet1{height = 1;}
sheet2{height = 2;}
sheet3{hegiht = 3;}
变为：
sheet1{height = 1;}
sheet2{height = 2;}

这个逻辑对应于代码：

if (old > height) {
        if (height >= 0) {
           。。。。
        } else {
            if (ctl->top > old) {
               for (h = old; h < ctl->top; h++) {
                   ctl->sheets[h] = ctl->sheets[h+1];
                   ctl->sheets[h]->height = h;
               }
            }

            ctl->top--;
        }
    sheet_refresh(ctl);
 }

sheet_refresh(ctl); 的作用是根据图层数组绘制图层，后面再详细分析。

如果当窗口的高度变高，底层的窗口激活后要在最上头显示，例如有下面三个图层对应的窗口：
sheet1{height = 1;}
sheet2{height = 2;}
sheet3{hegiht = 3;}

如果sheet1对应的窗口从最低位置转换到最前端显示，那么图层数组就做如下变得：
sheet2{height = 1;}
sheet3{hegiht = 2;}
sheet1{height = 3;}

这个逻辑对应的代码是：

else if (old < height) {
        if (old >= 0) {
            for (h = old; h < height; h++) {
               ctl->sheets[h] = ctl->sheets[h + 1];
               ctl->sheets[h]->height = h;
            }

            ctl->sheets[height] = sht;
        } else {
            。。。。
        }

        sheet_refresh(ctl);
    }

如果某个窗口原来处于最小化，现在要把它的高度设置为2，那么原来高度大于2的窗口，他们的高度就要相应的增加，然后再把空出来的图层位置让给新改变的图层，例如当前有三个窗口对应的图层如下：
sheet1{height = 1;}
sheet2{height = 2;}
sheet3{hegiht = 3;}

新窗口对应的图层是sheet4,它的高度从-1，也就是最小化形态转为高度为2，那么就需要把原来高度为2以上的图层在图层数组中往后挪，并改变高度：
sheet1{height = 1;}

sheet2{height = 3;}
sheet3{hegiht = 4;}

再把sheet4图层插入挪动后空出来的位置：
sheet1{height = 1;}
sheet4{height = 2;}
sheet2{height = 3;}
sheet3{hegiht = 4;}

这个逻辑对应的代码为：

else if (old < height) {
        if (old >= 0) {
           。。。。。
        } else {
            for (h = ctl->top; h >= height; h--) {
                ctl->sheets[h + 1] = ctl->sheets[h];
                ctl->sheets[h + 1]->height = h + 1;
            }

            ctl->sheets[height] = sht;
            ctl->top++;
        }

        sheet_refresh(ctl);
    }

我们再看看图层绘制函数：

int sheet_refresh(struct SHTCTL *ctl) {
    int h, bx, by, vx, vy;
    unsigned char *buf, c , *vram = ctl->vram;
    struct SHEET *sht;
    for (h = 0; h <= ctl->top; h++) {

        sht = ctl->sheets[h];
        buf = sht->buf;
        for (by = 0; by < sht->bysize; by++) {

            vy = sht->vy0 + by;
            for (bx = 0; bx < sht->bxsize; bx++) {

                vx = sht->vx0 + bx;
                c = buf[by * sht->bxsize + bx];
                if (c != sht->col_inv) {
                    vram[vy * ctl->xsize + vx] = c;
                }
            }
        }
    }

    return 0;
}

代码中vram 对应的是显存起始地址，也就是0xa0000, 接着遍历图层数组，按照每个图层绘制数组给显存对应的像素点设置对应的颜色，从而画出该图层对应的窗口。处于图层数组前面的图层先绘制，数组后面的图层后绘制，后绘制的图层窗口可能覆盖先绘制的窗口。

当某个窗口被移动后，内核会根据窗口移动后的新坐标重新绘制整个图层数组，代码如下：

void sheet_slide(struct SHTCTL *ctl, struct SHEET *sht, int vx0, int vy0) {
    sht->vx0 = vx0;
    sht->vy0 = vy0;
    if (sht->height >= 0) {
         sheet_refresh(ctl);
    }
}

把上面的代码编译入内核，（还有不少代码没有在本文说明，所以相关代码的讲解和调试过程请参看视频），加载后效果如下：

鼠标属于最顶图层，它的移动不会再对地步的窗口图层产生破坏作用。具体代码讲解和演示请参看视频：
Linux kernel Hacker, 从零构建自己的内核