footer.c

MDE 图形引擎

        FooterCtrls[i].dwAddData = 0;

        if (i == 0)
            FooterCtrls[i].w     = WIDTH_F1_BUTTON;
            
        x += FooterCtrls[i].w + 1;
    }
    
    FooterCtrls[1].dwStyle |= WS_GROUP;
    FooterCtrls[0].dwStyle  = 
            WS_VISIBLE | BS_MULTLINE | BS_PUSHBUTTON;
    FooterCtrls[NUM_BUTTONS - 1].dwStyle = 
            WS_VISIBLE | BS_MULTLINE | BS_PUSHBUTTON | WS_GROUP;
    FooterCtrls[11].w     = WIDTH_F12_BUTTON;
    FooterCtrls[11].h     = HEIGHT_F12_BUTTON;

    x = FooterCtrls[11].x;
    y = y + FooterCtrls[11].h;
    for (i = NUM_BUTTONS; i < NUM_BUTTONS + 3; i++) {
        FooterCtrls[i].class_name     = "button";
        FooterCtrls[i].dwStyle   = WS_VISIBLE | BS_PUSHBUTTON;
        FooterCtrls[i].x         = x;
        FooterCtrls[i].y         = y;
        FooterCtrls[i].w         = WIDTH_F12_BUTTON/3;
        FooterCtrls[i].h         = HEIGHT_BUTTON - HEIGHT_F12_BUTTON;
        FooterCtrls[i].id        = ID_FIRST_BUTTON + i;
        FooterCtrls[i].caption   = szLabelPrefix [i];
        FooterCtrls[i].dwAddData = 0;

        x += WIDTH_F12_BUTTON/3 + 1;
    }
    
    FooterTempl.x = -1;
    FooterTempl.y = g_rcScr.bottom
                        - HEIGHT_BUTTON - (HEIGHT_ROW*NUM_ROWS) - 1;
    FooterTempl.w = g_rcScr.right + 2;
    FooterTempl.h = HEIGHT_BUTTON + HEIGHT_ROW*NUM_ROWS + 2;
    
    FooterTempl.dwAddData = (DWORD)&sg_FooterInfo;
}

HWND CreateFooter (HWND hHeaderWin)
{
    InitCreateInfo ();
    sg_hFooterWin = CreateMainWindowIndirect (&FooterTempl, 
                        hHeaderWin, FooterWinProc);

    if (sg_hFooterWin == HWND_INVALID)
        return HWND_INVALID;

    return sg_hFooterWin;
}

/****************************** Initializatioin ******************************/
static int btmInit (FOOTERINFO* pFooterInfo, int buffLen)
{
    BTNMENUITEM* btmi;
    int i;
    
    // init item buffer.
    if (!(pFooterInfo->buffStart = malloc (buffLen * sizeof (BTNMENUITEM))))
        return VACS_ERROR_MEM;

    pFooterInfo->buffLen = buffLen;
    pFooterInfo->buffEnd = pFooterInfo->buffStart + buffLen;
    pFooterInfo->freeList = pFooterInfo->buffStart;

    btmi = pFooterInfo->freeList;
    for (i = 0; i < buffLen - 1; i++) {
        btmi->next = btmi + 1;
        btmi ++;
    }
    btmi->next = NULL;

    return VACS_OK;
}

static void btmRest (FOOTERINFO* pFooterInfo)
{
    BTNMENUITEM* btmi;
    int i;

    pFooterInfo->freeList = pFooterInfo->buffStart;

    btmi = pFooterInfo->freeList;
    for (i = 0; i < pFooterInfo->buffLen - 1; i++) {
        btmi->next = btmi + 1;
        btmi ++;
    }
    btmi->next = NULL;
}

static void btmChildrenCleanUp (FOOTERINFO* pFooterInfo, BTNMENUITEM* child)
{
    BTNMENUITEM* btmi;
    BTNMENUITEM* next;

    btmi = child;
    while (btmi) {
        if (btmi->child)
            btmChildrenCleanUp (pFooterInfo, btmi->child);
            
        next = btmi->next;
        if (btmi < pFooterInfo->buffStart || btmi > pFooterInfo->buffEnd)
            free (btmi);

        btmi = next;
    }
}

static void btmCleanUp (FOOTERINFO* pFooterInfo)
{
    btmChildrenCleanUp (pFooterInfo, pFooterInfo->first);
    
    free (pFooterInfo->buffStart);
}

static BTNMENUITEM* btmAllocItem (FOOTERINFO* pFooterInfo)
{
    BTNMENUITEM* btmi;

    if (pFooterInfo->freeList) {
        btmi = pFooterInfo->freeList;
        pFooterInfo->freeList = btmi->next;
    }
    else
        btmi = (BTNMENUITEM*) malloc (sizeof (BTNMENUITEM));
    
    return btmi;
}

/*
static void btmFreeItem (FOOTERINFO* pFooterInfo, BTNMENUITEM* btmi)
{
    if (btmi < pFooterInfo->buffStart || btmi > pFooterInfo->buffEnd)
        free (btmi);
    else {
        btmi->next = pFooterInfo->freeList;
        pFooterInfo->freeList = btmi;
    }
}
*/

inline static BOOL is_seperator (char ch)
{
    if (ch == ' ' || ch == '\t' || ch == '\n'
            || ch == '#' || ch == '{' || ch == '}'
            || ch == ',' || ch == ';' || ch == EOF)
        return TRUE;

    return FALSE;
}

inline static BOOL is_syntax_seperator (char ch)
{
    if (ch == '{' || ch == '}' || ch == ',' || ch == ';')
        return TRUE;

    return FALSE;
}

static int get_next_token (FILE* fp, char* token, char* ch)
{
    int count;
    
    do {
        *ch = fgetc (fp);
        if (*ch == EOF)
            return BTM_ERROR_EOF;

        switch (*ch) {
        case ' ':
        case '\t':
        case '\n':
            break;

        case '#':
            while (*ch != '\n' && *ch != EOF)
                *ch = fgetc (fp);
                
            if (*ch == EOF)
                return BTM_ERROR_EOF;
            break;

        case '{':
        case '}':
        case ',':
        case ';':
            token [0] = *ch;
            token [1] = '\0';
            return BTM_ERROR_OK;
        
        default:
            count = 0;
            token [count++] = *ch;
            do {
                *ch = fgetc (fp);
                if (is_seperator (*ch)) {
                    token [count] = '\0';
                    if (*ch == EOF)
                        return BTM_ERROR_EOF;
                    else
                        return BTM_ERROR_OK;
                }
                else if (count < MAX_LEN_TOKEN) {
                    token [count++] = *ch;
                }
                else {
                    token [count] = '\0';
                    return BTM_ERROR_TOO_LONG;
                }
            } while (TRUE);
            return BTM_ERROR_UNEXPECT;
        }
    }while (TRUE);

    return BTM_ERROR_UNEXPECT;
}

static int token2id (const char* token, UINT* id)
{
    unsigned long int ul;
    char *endptr;
    
    ul = strtoul (token, &endptr, 10);
    if (*token != '\0' && *endptr == '\0') {
        *id = ul;
        return BTM_ERROR_OK;
    }
    
    return BTM_ERROR_TOKEN;
}

static int token2text (const char* token, char* text, int len)
{
    strncpy (text, token, len);
    return BTM_ERROR_OK;
}

static BOOL id_valid (BTNMENUITEM* first, BTNMENUITEM* curr)
{
    BTNMENUITEM* btmi;
    
    btmi = first;
    while (btmi) {
        if (btmi != curr && btmi->id == curr->id)
            return FALSE;

        if (btmi->child)
            if (!id_valid (btmi->child, curr))
                return FALSE;

        btmi = btmi->next;
    }
    
    return TRUE;
}

inline static BTNMENUITEM* get_tail (BTNMENUITEM* btmi)
{
    if (!btmi)
        return NULL;

    while (btmi->next) {
        btmi = btmi->next;
    }

    return btmi;
}

static int btmParseConfigFile (FILE* fp, FOOTERINFO* pFooterInfo)
{
    int i;
    BTNMENUITEM* level_stack [MAX_NEST_LEVEL + 1];
    int cur_level = 0;
    char token [MAX_LEN_TOKEN + 1];
    int expect_token = TTYPE_OPEN_LEV;
    
    BTNMENUITEM* cur_btmi = NULL;
    BTNMENUITEM* btmi = NULL;

    char last_char = '\0';
    BOOL check_last_char = FALSE;

    for (i = 0; i < MAX_NEST_LEVEL + 1; i++)
        level_stack [i] = NULL;

    do {
        int rc;

        if (check_last_char && is_syntax_seperator (last_char)) {
            token [0] = last_char;
            token [1] = '\0';
            rc = BTM_ERROR_OK;
            
            last_char = '\0';
            check_last_char = FALSE;
        }
        else
            rc = get_next_token (fp, token, &last_char);

#ifdef _DEBUG
        fprintf (stderr, 
            "token: %s, rc: %x, last char: %c, expected: %x. cur_level: %d\n", 
            token, rc, last_char, expect_token, cur_level);
#endif
        switch (rc) {
        case BTM_ERROR_TOO_LONG:
        case BTM_ERROR_UNEXPECT:
            return MAKELONG (VACS_ERROR_PROC, rc);

        case BTM_ERROR_EOF:
            if (expect_token & TTYPE_EOF) {
                // this should be the only return point when every thing is OK.
                pFooterInfo->first = level_stack [1];
                return VACS_OK;
            }
            else
                return MAKELONG (VACS_ERROR_PROC, BTM_ERROR_SYNTAX);
            break;

        default:
            if (expect_token & TTYPE_EOF)
                return MAKELONG (VACS_ERROR_PROC, BTM_ERROR_SYNTAX);
            break;
        }
        
        rc = BTM_ERROR_SYNTAX;

#ifdef _DEBUG
#endif

        switch (token [0]) {
        case '{':
            if (!(expect_token & TTYPE_OPEN_LEV))
                return MAKELONG (VACS_ERROR_PROC, rc);

            cur_level ++;       // level 0 not used, but as a flag
            if (cur_level > MAX_NEST_LEVEL)
                return MAKELONG (VACS_ERROR_PROC, rc);

            expect_token = TTYPE_ID;
            break;
        
        case '}':
            if (!(expect_token & TTYPE_CLOSE_LEV))
                return MAKELONG (VACS_ERROR_PROC, rc);

            cur_level --;
            if (cur_level == 0) {
                // this is the last close '}'
                expect_token = TTYPE_EOF;
                break;
            }

            btmi = level_stack [cur_level];
#ifdef _DEBUG
            if (btmi == NULL)
                fprintf (stderr, "unexpected result.\n");
#endif
            cur_btmi = get_tail (btmi);
            
            level_stack [cur_level + 1] = NULL;
            expect_token = TTYPE_ID | TTYPE_CLOSE_LEV;
            break;
        
        case ',':
            if (!(expect_token & TTYPE_COMMA))
                return MAKELONG (VACS_ERROR_PROC, rc);
                
            expect_token = TTYPE_TEXT;
            break;
        
        case ';':
            if (!(expect_token & TTYPE_SEMICOLON))
                return MAKELONG (VACS_ERROR_PROC, rc);
                
            expect_token = TTYPE_ID | TTYPE_OPEN_LEV | TTYPE_CLOSE_LEV;
            break;
        
        default:
            if (expect_token & TTYPE_ID) {
                if (!(expect_token & TTYPE_ID))
                    return MAKELONG (VACS_ERROR_PROC, rc);
                    
                btmi = btmAllocItem (pFooterInfo);
                if (!btmi)
                    return MAKELONG (VACS_ERROR_PROC, BTM_ERROR_MEM);

                btmi->parent = get_tail (level_stack [cur_level - 1]);
                btmi->next = NULL;
                btmi->child = NULL;
                if (level_stack [cur_level] == NULL) {
                    // this is the leader of one level
                    level_stack [cur_level] = btmi;
                    if (cur_btmi)
                        cur_btmi->child = btmi;
                }
                else {
#ifdef _DEBUG
                    if (cur_btmi == NULL)
                        fprintf (stderr, "unexpected result.\n");
#endif
                    cur_btmi->next = btmi;
                }
                cur_btmi = btmi;

                if (token2id (token, &cur_btmi->id))
                    return MAKELONG (VACS_ERROR_PROC, rc);
                if (!id_valid (level_stack [1], cur_btmi))
                    return MAKELONG (VACS_ERROR_PROC, BTM_ERROR_ID_INV);

                expect_token = TTYPE_COMMA;
                check_last_char = TRUE;
            }
            else if (expect_token & TTYPE_TEXT) {
                if (!(expect_token & TTYPE_TEXT))
                    return MAKELONG (VACS_ERROR_PROC, rc);
#ifdef _DEBUG
                    if (cur_btmi == NULL)
                        fprintf (stderr, "unexpected result.\n");
#endif
                if (token2text (token, cur_btmi->text, MAX_LEN_ITEM_TEXT))
                    return MAKELONG (VACS_ERROR_PROC, rc);

                expect_token = TTYPE_SEMICOLON;
                check_last_char = TRUE;
            }
            else
                return MAKELONG (VACS_ERROR_PROC, rc);
            break;
        }
    } while (TRUE);

    return VACS_ERROR_UNEXPECT;
}

#ifdef _DEBUG
static void dump_btmi (int level, BTNMENUITEM* btmi)
{
    int i;
    
    fprintf (stderr, "**** Level %d:\n", level);
    while (btmi) {
        for (i = 0; i < level; i++)
            fprintf (stderr, "  ");
        fprintf (stderr, "ID: %d, ", btmi->id);
        fprintf (stderr, "TEXT: %s.\n", btmi->text);

        if (btmi->child)
            dump_btmi (level + 1, btmi->child);

        btmi = btmi->next;
    }
    fprintf (stderr, "**** End of Level %d.\n", level);
}

static void btmDump (FOOTERINFO* pFooterInfo)
{
    int level = 1;
    BTNMENUITEM* btmi;
    
    fprintf (stderr, "Dump of button menu:\n");

    if (!pFooterInfo->first) {
        fprintf (stderr, "NIL button menu.\n");
        goto end;
    }

    btmi = pFooterInfo->first;
    dump_btmi (level, btmi);

end:
    fprintf (stderr, "End Dump.\n");
}

#endif

static int btmCreate (FOOTERINFO* pFooterInfo)
{
    char path_name [PATH_MAX];
    FILE* fp;
    int rc;

    pFooterInfo->first       = NULL;
    pFooterInfo->curr_leader = NULL;
    pFooterInfo->page_first  = NULL;
    pFooterInfo->page_num    = 0;

    GetAbsolutePathName (DEF_BTM_CFG_FILE, path_name);
    if( !(fp = fopen(path_name, "r") ))
         return VACS_ERROR_FS;

    rc = btmParseConfigFile (fp, pFooterInfo);

    fclose (fp);

    if (rc)
        btmRest (pFooterInfo);
    else {
        pFooterInfo->curr_leader = pFooterInfo->first;
        pFooterInfo->page_first  = pFooterInfo->first;
    }

#ifdef _DEBUG
    fprintf (stderr, "Return value of paser: %x\n", rc);
    btmDump (pFooterInfo);
#endif

    return rc;
}

static int footerInitButtonMenu (FOOTERINFO* pFooterInfo)
{
    int rc;
    
    rc = btmInit (pFooterInfo, DEF_LEN_BTM_BUFFER);
    if (rc) return rc;

    rc = btmCreate (pFooterInfo);

    return rc;
}

static int footerInitStateRow (FOOTERINFO* pFooterInfo)
{
    int i, j;
    int x, y;
    
    pFooterInfo->num_rows = NUM_ROWS;
    y = 0;
    for (i = 0; i < NUM_ROWS; i++) {
        pFooterInfo->num_cols_per_row [i] = DEF_NUM_COLS_PER_ROW;
        
        x = 0;
        for (j = 0; j < DEF_NUM_COLS_PER_ROW; j++) {
            pFooterInfo->cell[i][j].l    = x;
            pFooterInfo->cell[i][j].t    = y;
            pFooterInfo->cell[i][j].r    = x + DEF_WIDTH_COL;
            pFooterInfo->cell[i][j].b    = y + HEIGHT_ROW;

            pFooterInfo->cell[i][j].fc   = COLOR_cyan;
            pFooterInfo->cell[i][j].bc   = COLOR_blue;
            strcpy (pFooterInfo->cell[i][j].text, "无可用信息");

            pFooterInfo->cell[i][j].style = CS_NORMAL;
            
            x += DEF_WIDTH_COL;
        }
        y += HEIGHT_ROW;
    }

    return VACS_OK;
}

int InitFooter (HWND hSplash)
{
    int rc;
    
    SetSplashInfo(hSplash, "Init button menu...");
    rc = footerInitButtonMenu (&sg_FooterInfo);
    if (rc) return rc;

    SetSplashInfo(hSplash, "Init status rows...");
    rc = footerInitStateRow (&sg_FooterInfo);
    if (rc) return rc;

    SetSplashInfo(hSplash, "Init footer OK.");
    return VACS_OK;
}

void FooterCleanUp (void)
{
    btmCleanUp (&sg_FooterInfo);
}