picture.c

飞漫公司的minigui的1.6.8收费增值版本的demon等示例程序

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#ifndef WIN32
#include <unistd.h>
#include <time.h>
#include <sys/time.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#endif

#include <minigui/common.h>
#include <minigui/minigui.h>
#include <minigui/gdi.h>
#include <minigui/window.h>
#include <minigui/control.h>
#include <minigui/mywindows.h>
#include <minigui/mgext.h>
#include <minigui/skin.h>
#include <minigui/newfiledlg.h>

#include "bitmap.h"
#include "english_config.h"

#define SIID_PICTURE_PARENT       1
#define SIID_PICTURE_FILE         2
#define SIID_PICTURE_OTHER        3

#define IDC_PICTURE_CONTROL_BAR         100
#define IDC_PICTURE_SCROLLVIEW          101

#define IDC_PICTURE_MENU_SLIDER         200
#define IDC_PICTURE_MENU_INFO           201
#define IDC_PICTURE_MENU_DELETE         202
#define IDC_PICTURE_MENU_RENAME         203
#define IDC_PICTURE_MENU_MKDIR          204

#ifndef NAME_MAX
#define NAME_MAX 128
#endif


typedef struct {
    char *filename;
    int IsDir;
} FILEINFO;

static char *vfilename[] = {
        "bin",
        "boot",
        "dev",
        "etc",
        "img_0000.jpg",
        "img_0001.jpg",
        "img_0002.jpg",
        "img_0003.jpg",
        "img_0004.jpg",
        "img_0005.jpg",
        "img_0006.jpg",
};

static char **filename = NULL;
static char *respath = "res";
static char *filemark = NULL;
static int vfilecount = TABLESIZE(vfilename);
static int ngDrawFlag = 0;
static int piccount = 0;
static FILEINFO *vfileinfo = NULL;
static HWND hPictureMain = HWND_INVALID;
static HMENU hPicturePopMenu;

extern void draw_caption_bar(HDC, HWND);
void create_pictureshow_win(HWND hWnd, char **picname, int pic, int count);
static int picture_controlbar_main_event_cb(HWND hwnd, skin_item_t *item, int event, void *data);
static int picture_controlbar_msg_cb(HWND hWnd, int message, WPARAM wParam, LPARAM lParam, int *result);

volatile static skin_item_t picture_controlbar_items [] =
{
    {SIID_PICTURE_PARENT, SI_TYPE_CMDBUTTON | SI_TEST_SHAPE_RECT | SI_STATUS_VISIBLE,
    13, 2, {0}, 1, "parent dir"},
    {SIID_PICTURE_FILE, SI_TYPE_CMDBUTTON | SI_TEST_SHAPE_RECT | SI_STATUS_VISIBLE,
    116, 2, {0}, 2, "file"},
    {SIID_PICTURE_OTHER, SI_TYPE_CMDBUTTON | SI_TEST_SHAPE_RECT | SI_STATUS_VISIBLE,
    219, 2, {0}, 3, "other"}
};

skin_head_t picture_controlbar_skin_temp;
skin_item_t picture_controlbar_items_temp[TABLESIZE(picture_controlbar_items)];

volatile static skin_head_t picture_controlbar_skin =
{
    "",
    SKIN_STYLE_NONE, NULL, NULL,
    0, 3, picture_controlbar_items_temp, FALSE
};

const char *picture_bmp_name[] =
{
    "playbar_bg.bmp", "button_up.bmp", "button_file.bmp", "button_other.bmp"
};

#define PICTURE_BMP_NR sizeof(picture_bmp_name) / sizeof(char *)
static char *picture_icon_names[] = {
    "Picture_icon.bmp",
    "Folder_icon.bmp",
    "Playlist_icon.bmp"
};

static BITMAP picture_item_icons[TABLESIZE(picture_icon_names)];
static BITMAP bmPictureFolder;

static void openpic(HWND hwnd, int flag);
static void load_picture_item_icons(int flag)
{
    int i;

    if (flag) {
        for (i = 0; i < TABLESIZE(picture_icon_names); i++) {
            if (pdag_load_bitmap(picture_item_icons + i, NULL, "picture/", picture_icon_names [i]) < 0) {
                printf("cannot load %s\n", picture_icon_names [i]);
                return;
            }
            (picture_item_icons + i)->bmType = BMP_TYPE_COLORKEY;
            (picture_item_icons + i)->bmColorKey = RGB2Pixel(HDC_SCREEN, 0xff, 0x0, 0xff);
        }
    }
    else {
         for (i = 0; i < TABLESIZE(picture_icon_names); i++) 
             pdag_unload_bitmap(picture_item_icons + i);
    }

    if (flag) {
         if (pdag_load_bitmap(&bmPictureFolder, NULL, "public/", "folder-big.bmp") < 0) {
                printf("cannot load public/folder_big.bmp\n");
                return;
         }
         bmPictureFolder.bmType = BMP_TYPE_COLORKEY;
         bmPictureFolder.bmColorKey = GetPixelInBitmap(&bmPictureFolder, 0, 0);
    }
    else
        pdag_unload_bitmap(&bmPictureFolder);

}

static int load_skin_bmps(skin_head_t *skin, BOOL load, const char *bmpname[], int nCount)
{
    int i;
    char *public = "public/";
    char *path;

    if (load) {
        skin->bmps = (BITMAP *)calloc(nCount, sizeof(BITMAP));
    }

    for (i = 0; i < nCount; i ++) {
        if (load) {
            path = public;
            if (strcmp(bmpname[i], "playbar_bg.bmp")==0)
                path = public;
 
            if (pdag_load_bitmap((PBITMAP)&(skin->bmps[i]), NULL, path, bmpname[i]) < 0){
                fprintf(stderr, "load skin bitmap error: %s%s\n", path, bmpname[i]);
                return -1;
            }
            else if (strcmp(bmpname[i], "playbar_bg.bmp") !=0) {
                //((PBITMAP)&skin->bmps [i])->bmType = BMP_TYPE_COLORKEY;
                //((PBITMAP)&skin->bmps [i])->bmColorKey =   GetPixelInBitmap(&skin->bmps[i], 0, 0);
            }
        }
        else{
           pdag_unload_bitmap((PBITMAP)&(skin->bmps[i]));
        }
    }

    if (!load)
        free((void *)skin->bmps);

    return 0;
}

static int init_picture_controlbar(void)
{
    memcpy(&picture_controlbar_skin_temp, (const void *)(&picture_controlbar_skin), sizeof(picture_controlbar_skin));
    memcpy(&picture_controlbar_items_temp, &picture_controlbar_items, sizeof(picture_controlbar_items));
    
    
    load_skin_bmps(&picture_controlbar_skin_temp, TRUE, picture_bmp_name, PICTURE_BMP_NR);
    
    if (!skin_init(&picture_controlbar_skin_temp, picture_controlbar_main_event_cb, picture_controlbar_msg_cb)){
        printf("skin init fail !\n");
    }

    
    return 0;
}

static void create_picture_controlbar(HWND hWnd)
{
    skin_head_t *pskin;
    HWND hControlBar;

    hControlBar = create_skin_control(&picture_controlbar_skin_temp,
                        hWnd, IDC_PICTURE_CONTROL_BAR, 0, 216, 
                        320, 24 
                  );
   pskin = get_window_skin(hControlBar);
}

static void destroy_picture_controlbar(void)
{
    skin_deinit(&picture_controlbar_skin_temp);
    load_skin_bmps(&picture_controlbar_skin_temp, FALSE, picture_bmp_name, PICTURE_BMP_NR);
}

static int picture_controlbar_main_event_cb(HWND hwnd, skin_item_t *item, int event, void *data)
{
    if (event == SIE_BUTTON_CLICKED){
        switch (item->id){
        case SIID_PICTURE_PARENT:
            openpic(GetParent(hwnd), 1);
            break;
        case SIID_PICTURE_FILE:
            TrackPopupMenu(hPicturePopMenu, TPM_LEFTALIGN |TPM_LEFTBUTTON, 120, 105, hPictureMain);
            break;
        case SIID_PICTURE_OTHER:
            break;
       }
    }

    return 1;
}

static int picture_controlbar_msg_cb(HWND hWnd, int message, WPARAM wParam, LPARAM lParam, int *result)
{
    *result = MSG_CB_GOON;
    return 0;
}

static void InsertToScrollView(HWND hscroll, FILEINFO *fileinfo, int count)
{
    SVITEMINFO svii;
    int i;

    SendMessage(hscroll, SVM_RESETCONTENT, 0, 0);

    if (fileinfo == NULL)
        return;

    svii.nItemHeight = 16;
    
    SendMessage(hscroll, MSG_FREEZECTRL, TRUE, 0); 
    for (i = 0; i < count; i++) {
        svii.nItem = i;
        svii.addData = (DWORD)&fileinfo[i];
        SendMessage(hscroll, SVM_ADDITEM, 0, (LPARAM)&svii);
    }
    SendMessage(hscroll, MSG_FREEZECTRL, FALSE, 0);
}

int initfileinfo(char **filename, int n)
{
    int i, picnum = 0;

    vfileinfo = (FILEINFO *)malloc(sizeof(FILEINFO) * n);
    for (i = 0; i < n; i++) {
        vfileinfo[i].filename = filename[i];
        if (strstr(filename[i], "img"))
            vfileinfo[i].IsDir = FALSE;
        else
            vfileinfo[i].IsDir = TRUE;
        picnum++;
    }

    return picnum;
}

static void free_fileinfo(void)
{
    if (filename) {
        free(filename);
        filename = NULL;
    }
    if (filemark) {
        free(filemark);
        filemark = NULL;
    }
}

void jpegview(HDC hdc, char **prefile)
{
    int i, x = 221, y, w = 98, h = 62;
 
    for (i = 0; i < 3; i++) {
        int fitw, fith, fx, fy;
        BITMAP bitmap;

        y = 25 + i * 63;
        if (!prefile[i])
            continue;
        if (pdag_load_bitmap(&bitmap, NULL, NULL, prefile[i]) < 0)
            continue;

        if (bitmap.bmWidth <= w && bitmap.bmHeight <= h) {
            fx = x + (w - bitmap.bmWidth) / 2;
            fy = y + (h - bitmap.bmHeight) / 2;
            fitw = bitmap.bmWidth;
            fith = bitmap.bmHeight;
        }
        else {
            fitw = w;
            fith = w * ((float)bitmap.bmHeight / (float)bitmap.bmWidth);
            fx = x;
            fy = y + (h - fith) / 2;
            if (fith > h) {
                fith = h;
                fitw = h * ((float)bitmap.bmWidth / (float)bitmap.bmHeight);
                fx = x + (w - fitw) / 2;
                fy = y;
            }
        }

        FillBoxWithBitmap(hdc, fx, fy, fitw, fith, &bitmap);
        pdag_unload_bitmap(&bitmap);
    }
}

static void filepreview(HDC hdc, HWND hWnd)
{
    int i, sel = -1, cursel;
    char *prefile[3];
    HWND hscroll;

    SetPenColor(hdc, RGB2Pixel(HDC_SCREEN, 250, 250, 250));
    Rectangle(hdc, 220, 24, 319, 87);
    Rectangle(hdc, 220, 87, 319, 150);
    Rectangle(hdc, 220, 150, 319, 215);

    SetBrushColor(hdc, RGB2Pixel(HDC_SCREEN, 0x0, 0x0, 0x0));
    FillBox(hdc, 221, 25, 98, 62);
    FillBox(hdc, 221, 88, 98, 62);
    FillBox(hdc, 221, 151, 98, 62);

    if (!ngDrawFlag)
        return;
    hscroll = GetDlgItem(hWnd, IDC_PICTURE_SCROLLVIEW);
    cursel = SendMessage(hscroll, SVM_GETCURSEL, 0, 0);
    if (cursel < 0)
        return;
    for (i = 0; i <= cursel; i++) {
        if (filemark[i >> 3] & (0x80 >> i % 8))
            sel++;
    }
    if (sel < 0)
        sel = 0;
    for (i = 0; i < 3; i++) {
        if (filemark[(cursel + i) >> 3] & (0x80 >> (cursel + i) % 8)) {
            if (piccount > sel)
                prefile[i] = filename[sel++];
        }
        else {
            prefile[i] = NULL;
            if (cursel + i < vfilecount)
                FillBoxWithBitmap(hdc, 270 - bmPictureFolder.bmWidth / 2,
                    60 + i * 60 - bmPictureFolder.bmHeight / 2, 0, 0, &bmPictureFolder);
        }
    }
    jpegview(hdc, prefile);
}