shimgvw.c File Reference

#include "shimgvw.h"
#include <windowsx.h>
#include <commctrl.h>
#include <commdlg.h>
#include <shlobj.h>
#include <shellapi.h>

Include dependency graph for shimgvw.c:

Go to the source code of this file.

Classes
struct	TB_BUTTON_CONFIG
struct	tagPREVIEW_DATA

Macros
#define	TB_IMAGE_WIDTH   16
#define	TB_IMAGE_HEIGHT   16
#define	SLIDESHOW_TIMER_ID   0xFACE
#define	SLIDESHOW_TIMER_INTERVAL   5000 /* 5 seconds */
#define	MIN_ZOOM   s_ZoomSteps[0]
#define	MAX_ZOOM   s_ZoomSteps[_countof(s_ZoomSteps) - 1]
#define	DEFINE_BTN_INFO(_name)    { TBICON_##_name, IDC_##_name, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0 }
#define	DEFINE_BTN_SEPARATOR    { -1, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0 }
#define	DEFINE_BTN_CONFIG(_name)   { IDB_##_name, IDS_TOOLTIP_##_name }

Typedefs
typedef struct tagPREVIEW_DATA	PREVIEW_DATA
typedef struct tagPREVIEW_DATA *	PPREVIEW_DATA

Functions
static PPREVIEW_DATA	Preview_GetData (HWND hwnd)
static BOOL	Preview_IsMainWnd (HWND hwnd)
static VOID	Preview_RestartTimer (HWND hwnd)
static VOID	ZoomWnd_UpdateScroll (PPREVIEW_DATA pData, HWND hwnd, BOOL bResetPos)
static VOID	Preview_UpdateZoom (PPREVIEW_DATA pData, UINT NewZoom, BOOL bEnableBestFit, BOOL bEnableRealSize)
static VOID	Preview_ZoomInOrOut (PPREVIEW_DATA pData, BOOL bZoomIn)
static VOID	Preview_ResetZoom (PPREVIEW_DATA pData)
static VOID	Preview_UpdateTitle (PPREVIEW_DATA pData, LPCWSTR FileName)
static VOID	Preview_pFreeImage (PPREVIEW_DATA pData)
IStream *	MemStreamFromFile (LPCWSTR pszFileName)
static VOID	Preview_pLoadImage (PPREVIEW_DATA pData, LPCWSTR szOpenFileName)
static VOID	Preview_pLoadImageFromNode (PPREVIEW_DATA pData, SHIMGVW_FILENODE *pNode)
static BOOL	Preview_pSaveImage (PPREVIEW_DATA pData, LPCWSTR pszFile)
static VOID	Preview_pSaveImageAs (PPREVIEW_DATA pData)
static VOID	Preview_pPrintImage (PPREVIEW_DATA pData)
static VOID	Preview_UpdateUI (PPREVIEW_DATA pData)
static VOID	Preview_UpdateImage (PPREVIEW_DATA pData)
static SHIMGVW_FILENODE *	pBuildFileList (LPCWSTR szFirstFile)
static VOID	pFreeFileList (SHIMGVW_FILENODE *root)
static HBRUSH	CreateCheckerBoardBrush (VOID)
static VOID	ZoomWnd_OnDraw (PPREVIEW_DATA pData, HDC hdc, LPRECT prcPaint, LPRECT prcClient)
static VOID	ZoomWnd_OnPaint (PPREVIEW_DATA pData, HWND hwnd)
static VOID	ImageView_ResetSettings (VOID)
static BOOL	ImageView_LoadSettings (VOID)
static VOID	ImageView_SaveSettings (VOID)
static BOOL	Preview_CreateToolBar (PPREVIEW_DATA pData)
static VOID	Preview_EndSlideShow (HWND hwnd)
static VOID	ZoomWnd_OnButtonDown (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	ZoomWnd_OnMouseMove (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	ZoomWnd_OnSetCursor (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	ZoomWnd_OnButtonUp (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static VOID	ZoomWnd_OnHVScroll (PPREVIEW_DATA pData, HWND hwnd, WPARAM wParam, BOOL bVertical)
static VOID	ZoomWnd_OnMouseWheel (HWND hwnd, INT x, INT y, INT zDelta, UINT fwKeys)
LRESULT CALLBACK	ZoomWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
static BOOL	Preview_OnCreate (HWND hwnd, LPCREATESTRUCT pCS)
static VOID	Preview_OnMoveSize (HWND hwnd)
static VOID	Preview_OnSize (HWND hwnd)
static VOID	Preview_Delete (PPREVIEW_DATA pData)
static VOID	Preview_Edit (HWND hwnd)
static VOID	Preview_ToggleSlideShow (PPREVIEW_DATA pData)
static VOID	Preview_GoNextPic (PPREVIEW_DATA pData, BOOL bNext)
static VOID	Preview_OnCommand (HWND hwnd, UINT nCommandID)
static LRESULT	Preview_OnNotify (HWND hwnd, LPNMHDR pnmhdr)
static VOID	Preview_OnDestroy (HWND hwnd)
static VOID	Preview_OnDropFiles (HWND hwnd, HDROP hDrop)
LRESULT CALLBACK	PreviewWndProc (HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
LONG	ImageView_Main (HWND hwnd, LPCWSTR szFileName)
VOID WINAPI	ImageView_FullscreenW (HWND hwnd, HINSTANCE hInst, LPCWSTR path, int nShow)
VOID WINAPI	ImageView_Fullscreen (HWND hwnd, HINSTANCE hInst, LPCWSTR path, int nShow)
VOID WINAPI	ImageView_FullscreenA (HWND hwnd, HINSTANCE hInst, LPCSTR path, int nShow)
VOID WINAPI	ImageView_PrintTo (HWND hwnd, HINSTANCE hInst, LPCWSTR path, int nShow)
VOID WINAPI	ImageView_PrintToA (HWND hwnd, HINSTANCE hInst, LPCSTR path, int nShow)
VOID WINAPI	ImageView_PrintToW (HWND hwnd, HINSTANCE hInst, LPCWSTR path, int nShow)
BOOL WINAPI	DllMain (IN HINSTANCE hinstDLL, IN DWORD dwReason, IN LPVOID lpvReserved)

Variables
HINSTANCE	g_hInstance = NULL
HWND	g_hMainWnd = NULL
HWND	g_hwndFullscreen = NULL
SHIMGVW_FILENODE *	g_pCurrentFile = NULL
GpImage *	g_pImage = NULL
SHIMGVW_SETTINGS	g_Settings
static const UINT	s_ZoomSteps []
static const TBBUTTON	s_Buttons []
static const TB_BUTTON_CONFIG	s_ButtonConfig []

Macro Definition Documentation

DEFINE_BTN_CONFIG

#define DEFINE_BTN_CONFIG

(

_name

)

{ IDB_##_name, IDS_TOOLTIP_##_name }

Definition at line 80 of file shimgvw.c.

DEFINE_BTN_INFO

#define DEFINE_BTN_INFO

(

_name

)

{ TBICON_##_name, IDC_##_name, TBSTATE_ENABLED, BTNS_BUTTON, {0}, 0, 0 }

Definition at line 40 of file shimgvw.c.

DEFINE_BTN_SEPARATOR

#define DEFINE_BTN_SEPARATOR    { -1, 0, TBSTATE_ENABLED, BTNS_SEP, {0}, 0, 0 }

Definition at line 43 of file shimgvw.c.

MAX_ZOOM

#define MAX_ZOOM   s_ZoomSteps[_countof(s_ZoomSteps) - 1]

Definition at line 37 of file shimgvw.c.

MIN_ZOOM

#define MIN_ZOOM   s_ZoomSteps[0]

Definition at line 36 of file shimgvw.c.

SLIDESHOW_TIMER_ID

#define SLIDESHOW_TIMER_ID   0xFACE

Definition at line 21 of file shimgvw.c.

SLIDESHOW_TIMER_INTERVAL

#define SLIDESHOW_TIMER_INTERVAL   5000 /* 5 seconds */

Definition at line 22 of file shimgvw.c.

TB_IMAGE_HEIGHT

#define TB_IMAGE_HEIGHT   16

Definition at line 18 of file shimgvw.c.

TB_IMAGE_WIDTH

#define TB_IMAGE_WIDTH   16

Definition at line 17 of file shimgvw.c.

Typedef Documentation

PPREVIEW_DATA

typedef struct tagPREVIEW_DATA * PPREVIEW_DATA

PREVIEW_DATA

typedef struct tagPREVIEW_DATA PREVIEW_DATA

Function Documentation

CreateCheckerBoardBrush()

static HBRUSH CreateCheckerBoardBrush ( VOID  )

static

Definition at line 730 of file shimgvw.c.

{
    static const CHAR pattern[] =
        "\x28\x00\x00\x00\x10\x00\x00\x00\x10\x00\x00\x00\x01\x00\x04\x00\x00\x00"
        "\x00\x00\x80\x00\x00\x00\x23\x2E\x00\x00\x23\x2E\x00\x00\x10\x00\x00\x00"
        "\x00\x00\x00\x00\x99\x99\x99\x00\xCC\xCC\xCC\x00\x00\x00\x00\x00\x00\x00"
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"
        "\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x11\x11\x11\x11"
        "\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00"
        "\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00"
        "\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11"
        "\x11\x11\x00\x00\x00\x00\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00"
        "\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11"
        "\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11"
        "\x00\x00\x00\x00\x11\x11\x11\x11\x00\x00\x00\x00\x11\x11\x11\x11";
 
    return CreateDIBPatternBrushPt(pattern, DIB_RGB_COLORS);
}

Referenced by ZoomWnd_OnDraw().

DllMain()

BOOL WINAPI DllMain	(	IN HINSTANCE	hinstDLL,
		IN DWORD	dwReason,
		IN LPVOID	lpvReserved
	)

@DllMain

Core routine of the Utility Manager's library.

Parameters

[in]	hDllInstance	The entry point instance of the library.
[in]	fdwReason	The reason argument to indicate the motive DllMain is being called.
[in]	lpvReserved	Reserved.

Returns

Returns TRUE when main call initialization has succeeded, FALSE otherwise.

Definition at line 1782 of file shimgvw.c.

{
    switch (dwReason)
    {
        case DLL_PROCESS_ATTACH:
            g_hInstance = hinstDLL;
            break;
    }
 
    return TRUE;
}

ImageView_Fullscreen()

VOID WINAPI ImageView_Fullscreen	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCWSTR	path,
		int	nShow
	)

Definition at line 1747 of file shimgvw.c.

{
    ImageView_Main(hwnd, path);
}

ImageView_FullscreenA()

VOID WINAPI ImageView_FullscreenA	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCSTR	path,
		int	nShow
	)

Definition at line 1753 of file shimgvw.c.

{
    WCHAR szFile[MAX_PATH];
 
    if (MultiByteToWideChar(CP_ACP, 0, path, -1, szFile, _countof(szFile)))
    {
        ImageView_Main(hwnd, szFile);
    }
}

ImageView_FullscreenW()

VOID WINAPI ImageView_FullscreenW	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCWSTR	path,
		int	nShow
	)

Definition at line 1741 of file shimgvw.c.

{
    ImageView_Main(hwnd, path);
}

ImageView_LoadSettings()

static BOOL ImageView_LoadSettings ( VOID  )

static

Definition at line 909 of file shimgvw.c.

{
    HKEY hKey;
    DWORD dwSize;
    LSTATUS nError;
 
    nError = RegOpenKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\shimgvw", 0, KEY_READ, &hKey);
    if (nError != ERROR_SUCCESS)
        return FALSE;
 
    dwSize = sizeof(g_Settings);
    nError = RegQueryValueExW(hKey, L"Settings", NULL, NULL, (LPBYTE)&g_Settings, &dwSize);
    RegCloseKey(hKey);
 
    return ((nError == ERROR_SUCCESS) && (dwSize == sizeof(g_Settings)));
}

Referenced by ImageView_Main().

ImageView_Main()

LONG ImageView_Main	(	HWND	hwnd,
		LPCWSTR	szFileName
	)

Definition at line 1651 of file shimgvw.c.

{
    struct GdiplusStartupInput gdiplusStartupInput;
    ULONG_PTR gdiplusToken;
    WNDCLASSW WndClass;
    WCHAR szTitle[256];
    HWND hMainWnd;
    MSG msg;
    HACCEL hAccel;
    HRESULT hrCoInit;
    INITCOMMONCONTROLSEX Icc = { .dwSize = sizeof(Icc), .dwICC = ICC_WIN95_CLASSES };
 
    InitCommonControlsEx(&Icc);
 
    /* Initialize COM */
    hrCoInit = CoInitializeEx(NULL, COINIT_APARTMENTTHREADED | COINIT_DISABLE_OLE1DDE);
    if (FAILED(hrCoInit))
        DPRINT1("Warning, CoInitializeEx failed with code=%08X\n", (int)hrCoInit);
 
    if (!ImageView_LoadSettings())
        ImageView_ResetSettings();
 
    /* Initialize GDI+ */
    ZeroMemory(&gdiplusStartupInput, sizeof(gdiplusStartupInput));
    gdiplusStartupInput.GdiplusVersion = 1;
    GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 
    /* Register window classes */
    ZeroMemory(&WndClass, sizeof(WndClass));
    WndClass.lpszClassName  = WC_PREVIEW;
    WndClass.lpfnWndProc    = PreviewWndProc;
    WndClass.hInstance      = g_hInstance;
    WndClass.style          = CS_HREDRAW | CS_VREDRAW;
    WndClass.hIcon          = LoadIconW(g_hInstance, MAKEINTRESOURCEW(IDI_APP_ICON));
    WndClass.hCursor        = LoadCursorW(NULL, (LPCWSTR)IDC_ARROW);
    WndClass.hbrBackground  = (HBRUSH)UlongToHandle(COLOR_3DFACE + 1);
    if (!RegisterClassW(&WndClass))
        return -1;
    WndClass.lpszClassName  = WC_ZOOM;
    WndClass.lpfnWndProc    = ZoomWndProc;
    WndClass.style          = CS_HREDRAW | CS_VREDRAW | CS_DBLCLKS;
    WndClass.hbrBackground  = GetStockBrush(NULL_BRUSH); /* less flicker */
    if (!RegisterClassW(&WndClass))
        return -1;
 
    /* Create the main window */
    LoadStringW(g_hInstance, IDS_APPTITLE, szTitle, _countof(szTitle));
    hMainWnd = CreateWindowExW(WS_EX_WINDOWEDGE, WC_PREVIEW, szTitle,
                               WS_OVERLAPPEDWINDOW | WS_CLIPSIBLINGS,
                               g_Settings.X, g_Settings.Y, g_Settings.Width, g_Settings.Height,
                               NULL, NULL, g_hInstance, (LPVOID)szFileName);
 
    /* Create accelerator table for keystrokes */
    hAccel = LoadAcceleratorsW(g_hInstance, MAKEINTRESOURCEW(IDR_ACCELERATOR));
 
    /* Show the main window now */
    if (g_Settings.Maximized)
        ShowWindow(hMainWnd, SW_SHOWMAXIMIZED);
    else
        ShowWindow(hMainWnd, SW_SHOWNORMAL);
 
    UpdateWindow(hMainWnd);
 
    /* Message Loop */
    while (GetMessageW(&msg, NULL, 0, 0) > 0)
    {
        if (g_hwndFullscreen && TranslateAcceleratorW(g_hwndFullscreen, hAccel, &msg))
            continue;
        if (TranslateAcceleratorW(hMainWnd, hAccel, &msg))
            continue;
 
        TranslateMessage(&msg);
        DispatchMessageW(&msg);
    }
 
    /* Destroy accelerator table */
    DestroyAcceleratorTable(hAccel);
 
    ImageView_SaveSettings();
 
    GdiplusShutdown(gdiplusToken);
 
    /* Release COM resources */
    if (SUCCEEDED(hrCoInit))
        CoUninitialize();
 
    return 0;
}

Referenced by ImageView_Fullscreen(), ImageView_FullscreenA(), and ImageView_FullscreenW().

ImageView_PrintTo()

VOID WINAPI ImageView_PrintTo	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCWSTR	path,
		int	nShow
	)

Definition at line 1764 of file shimgvw.c.

{
    DPRINT("ImageView_PrintTo() not implemented\n");
}

ImageView_PrintToA()

VOID WINAPI ImageView_PrintToA	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCSTR	path,
		int	nShow
	)

Definition at line 1770 of file shimgvw.c.

{
    DPRINT("ImageView_PrintToA() not implemented\n");
}

ImageView_PrintToW()

VOID WINAPI ImageView_PrintToW	(	HWND	hwnd,
		HINSTANCE	hInst,
		LPCWSTR	path,
		int	nShow
	)

Definition at line 1776 of file shimgvw.c.

{
    DPRINT("ImageView_PrintToW() not implemented\n");
}

ImageView_ResetSettings()

static VOID ImageView_ResetSettings ( VOID  )

static

Definition at line 899 of file shimgvw.c.

{
    g_Settings.Maximized = FALSE;
    g_Settings.X         = CW_USEDEFAULT;
    g_Settings.Y         = CW_USEDEFAULT;
    g_Settings.Width     = 520;
    g_Settings.Height    = 400;
}

Referenced by ImageView_Main().

ImageView_SaveSettings()

static VOID ImageView_SaveSettings ( VOID  )

static

Definition at line 927 of file shimgvw.c.

{
    HKEY hKey;
    LSTATUS nError;
 
    nError = RegCreateKeyExW(HKEY_CURRENT_USER, L"Software\\ReactOS\\shimgvw",
                             0, NULL, 0, KEY_WRITE, NULL, &hKey, NULL);
    if (nError != ERROR_SUCCESS)
        return;
 
    RegSetValueExW(hKey, L"Settings", 0, REG_BINARY, (LPBYTE)&g_Settings, sizeof(g_Settings));
    RegCloseKey(hKey);
}

Referenced by ImageView_Main().

MemStreamFromFile()

IStream * MemStreamFromFile

(

LPCWSTR

pszFileName

)

Definition at line 357 of file shimgvw.c.

{
    HANDLE hFile;
    DWORD dwFileSize, dwRead;
    LPBYTE pbMemFile = NULL;
    IStream *pStream;
 
    hFile = CreateFileW(pszFileName, GENERIC_READ, FILE_SHARE_READ, NULL,
                        OPEN_EXISTING, 0, NULL);
    if (hFile == INVALID_HANDLE_VALUE)
        return NULL;
 
    dwFileSize = GetFileSize(hFile, NULL);
    pbMemFile = QuickAlloc(dwFileSize, FALSE);
    if (!dwFileSize || (dwFileSize == INVALID_FILE_SIZE) || !pbMemFile)
    {
        CloseHandle(hFile);
        return NULL;
    }
 
    if (!ReadFile(hFile, pbMemFile, dwFileSize, &dwRead, NULL) || (dwRead != dwFileSize))
    {
        QuickFree(pbMemFile);
        CloseHandle(hFile);
        return NULL;
    }
 
    CloseHandle(hFile);
    pStream = SHCreateMemStream(pbMemFile, dwFileSize);
    QuickFree(pbMemFile);
    return pStream;
}

Referenced by Preview_pLoadImage().

pBuildFileList()

static SHIMGVW_FILENODE * pBuildFileList ( LPCWSTR  szFirstFile )

static

Definition at line 599 of file shimgvw.c.

{
    HANDLE hFindHandle;
    WCHAR *extension;
    WCHAR szSearchPath[MAX_PATH];
    WCHAR szSearchMask[MAX_PATH];
    WCHAR szFileTypes[MAX_PATH];
    WIN32_FIND_DATAW findData;
    SHIMGVW_FILENODE *currentNode = NULL;
    SHIMGVW_FILENODE *root = NULL;
    SHIMGVW_FILENODE *conductor = NULL;
    ImageCodecInfo *codecInfo;
    UINT num;
    UINT size;
    UINT j;
 
    StringCbCopyW(szSearchPath, sizeof(szSearchPath), szFirstFile);
    PathRemoveFileSpecW(szSearchPath);
 
    GdipGetImageDecodersSize(&num, &size);
    codecInfo = QuickAlloc(size, FALSE);
    if (!codecInfo)
    {
        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
        return NULL;
    }
 
    GdipGetImageDecoders(num, size, codecInfo);
 
    root = QuickAlloc(sizeof(SHIMGVW_FILENODE), FALSE);
    if (!root)
    {
        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
        QuickFree(codecInfo);
        return NULL;
    }
 
    conductor = root;
 
    for (j = 0; j < num; ++j)
    {
        StringCbCopyW(szFileTypes, sizeof(szFileTypes), codecInfo[j].FilenameExtension);
 
        extension = wcstok(szFileTypes, L";");
        while (extension != NULL)
        {
            PathCombineW(szSearchMask, szSearchPath, extension);
 
            hFindHandle = FindFirstFileW(szSearchMask, &findData);
            if (hFindHandle != INVALID_HANDLE_VALUE)
            {
                do
                {
                    PathCombineW(conductor->FileName, szSearchPath, findData.cFileName);
 
                    // compare the name of the requested file with the one currently found.
                    // if the name matches, the current node is returned by the function.
                    if (_wcsicmp(szFirstFile, conductor->FileName) == 0)
                    {
                        currentNode = conductor;
                    }
 
                    conductor->Next = QuickAlloc(sizeof(SHIMGVW_FILENODE), FALSE);
 
                    // if QuickAlloc fails, make circular what we have and return it
                    if (!conductor->Next)
                    {
                        DPRINT1("QuickAlloc() failed in pLoadFileList()\n");
 
                        conductor->Next = root;
                        root->Prev = conductor;
 
                        FindClose(hFindHandle);
                        QuickFree(codecInfo);
                        return conductor;
                    }
 
                    conductor->Next->Prev = conductor;
                    conductor = conductor->Next;
                }
                while (FindNextFileW(hFindHandle, &findData) != 0);
 
                FindClose(hFindHandle);
            }
 
            extension = wcstok(NULL, L";");
        }
    }
 
    // we now have a node too much in the list. In case the requested file was not found,
    // we use this node to store the name of it, otherwise we free it.
    if (currentNode == NULL)
    {
        StringCchCopyW(conductor->FileName, MAX_PATH, szFirstFile);
        currentNode = conductor;
    }
    else
    {
        conductor = conductor->Prev;
        QuickFree(conductor->Next);
    }
 
    // link the last node with the first one to make the list circular
    conductor->Next = root;
    root->Prev = conductor;
    conductor = currentNode;
 
    QuickFree(codecInfo);
 
    return conductor;
}

Referenced by Preview_Delete(), Preview_OnCreate(), and Preview_OnDropFiles().

pFreeFileList()

static VOID pFreeFileList ( SHIMGVW_FILENODE *  root )

static

Definition at line 712 of file shimgvw.c.

{
    SHIMGVW_FILENODE *conductor;
 
    if (!root)
        return;
 
    root->Prev->Next = NULL;
    root->Prev = NULL;
 
    while (root)
    {
        conductor = root;
        root = conductor->Next;
        QuickFree(conductor);
    }
}

Referenced by Preview_Delete(), Preview_OnDestroy(), and Preview_OnDropFiles().

Preview_CreateToolBar()

static BOOL Preview_CreateToolBar ( PPREVIEW_DATA  pData )

static

Definition at line 942 of file shimgvw.c.

{
    HWND hwndToolBar;
    HIMAGELIST hImageList, hOldImageList;
    DWORD style = WS_CHILD | WS_VISIBLE | TBSTYLE_FLAT | TBSTYLE_TOOLTIPS;
 
    if (!Preview_IsMainWnd(pData->m_hwnd))
        return TRUE; /* FIXME */
 
    style |= CCS_BOTTOM;
    hwndToolBar = CreateWindowExW(0, TOOLBARCLASSNAMEW, NULL, style,
                                  0, 0, 0, 0, pData->m_hwnd, NULL, g_hInstance, NULL);
    if (!hwndToolBar)
        return FALSE;
 
    pData->m_hwndToolBar = hwndToolBar;
 
    SendMessageW(hwndToolBar, TB_BUTTONSTRUCTSIZE, sizeof(s_Buttons[0]), 0);
    SendMessageW(hwndToolBar, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_HIDECLIPPEDBUTTONS);
 
    hImageList = ImageList_Create(TB_IMAGE_WIDTH, TB_IMAGE_HEIGHT, ILC_MASK | ILC_COLOR24, 1, 1);
    if (hImageList == NULL)
        return FALSE;
 
    for (UINT n = 0; n < _countof(s_ButtonConfig); n++)
    {
        HBITMAP hBitmap = LoadBitmapW(g_hInstance, MAKEINTRESOURCEW(s_ButtonConfig[n].idb));
        ImageList_AddMasked(hImageList, hBitmap, RGB(255, 255, 255));
        DeleteObject(hBitmap);
    }
 
    hOldImageList = (HIMAGELIST)SendMessageW(hwndToolBar, TB_SETIMAGELIST, 0, (LPARAM)hImageList);
    ImageList_Destroy(hOldImageList);
 
    SendMessageW(hwndToolBar, TB_ADDBUTTONS, _countof(s_Buttons), (LPARAM)s_Buttons);
 
    return TRUE;
}

Referenced by Preview_OnCreate().

Preview_Delete()

static VOID Preview_Delete ( PPREVIEW_DATA  pData )

static

Definition at line 1313 of file shimgvw.c.

{
    WCHAR szCurFile[MAX_PATH + 1], szNextFile[MAX_PATH];
    HWND hwnd = pData->m_hwnd;
    SHFILEOPSTRUCTW FileOp = { hwnd, FO_DELETE };
 
    if (!pData->m_szFile[0])
        return;
 
    /* FileOp.pFrom must be double-null-terminated */
    GetFullPathNameW(pData->m_szFile, _countof(szCurFile) - 1, szCurFile, NULL);
    szCurFile[_countof(szCurFile) - 2] = UNICODE_NULL; /* Avoid buffer overrun */
    szCurFile[lstrlenW(szCurFile) + 1] = UNICODE_NULL;
 
    szNextFile[0] = UNICODE_NULL;
    if (g_pCurrentFile)
    {
        GetFullPathNameW(g_pCurrentFile->Next->FileName, _countof(szNextFile), szNextFile, NULL);
        szNextFile[_countof(szNextFile) - 1] = UNICODE_NULL; /* Avoid buffer overrun */
    }
 
    /* Confirm file deletion and delete if allowed */
    FileOp.pFrom = szCurFile;
    FileOp.fFlags = FOF_ALLOWUNDO;
    if (SHFileOperationW(&FileOp) != 0)
    {
        DPRINT("Preview_Delete: SHFileOperationW() failed or canceled\n");
        return;
    }
 
    /* Reload the file list and go next file */
    pFreeFileList(g_pCurrentFile);
    g_pCurrentFile = pBuildFileList(szNextFile);
    Preview_pLoadImageFromNode(pData, g_pCurrentFile);
}

Referenced by Preview_OnCommand().

Preview_Edit()

static VOID Preview_Edit ( HWND  hwnd )

static

Definition at line 1350 of file shimgvw.c.

{
    SHELLEXECUTEINFOW sei;
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
 
    if (!pData->m_szFile[0])
        return;
 
    ZeroMemory(&sei, sizeof(sei));
    sei.cbSize = sizeof(sei);
    sei.lpVerb = L"edit";
    sei.lpFile = pData->m_szFile;
    sei.nShow = SW_SHOWNORMAL;
    if (!ShellExecuteExW(&sei))
    {
        DPRINT1("Preview_Edit: ShellExecuteExW() failed with code %ld\n", GetLastError());
    }
    else
    {
        // Destroy the window to quit the application
        DestroyWindow(hwnd);
    }
}

Referenced by Preview_OnCommand().

Preview_EndSlideShow()

static VOID Preview_EndSlideShow ( HWND  hwnd )

static

Definition at line 982 of file shimgvw.c.

{
    if (Preview_IsMainWnd(hwnd))
        return;
 
    KillTimer(hwnd, SLIDESHOW_TIMER_ID);
    ShowWindow(hwnd, SW_HIDE);
    ShowWindow(g_hMainWnd, SW_SHOWNORMAL);
    Preview_ResetZoom(Preview_GetData(g_hMainWnd));
}

Referenced by Preview_OnCommand(), and ZoomWnd_OnButtonDown().

Preview_GetData()

static PPREVIEW_DATA Preview_GetData ( HWND  hwnd )

inlinestatic

Definition at line 118 of file shimgvw.c.

{
    return (PPREVIEW_DATA)GetWindowLongPtrW(hwnd, GWLP_USERDATA);
}

Referenced by Preview_Edit(), Preview_EndSlideShow(), Preview_OnCommand(), Preview_OnDestroy(), Preview_OnDropFiles(), Preview_OnSize(), PreviewWndProc(), ZoomWnd_OnButtonDown(), ZoomWnd_OnButtonUp(), ZoomWnd_OnMouseMove(), ZoomWnd_OnMouseWheel(), ZoomWnd_OnSetCursor(), and ZoomWndProc().

Preview_GoNextPic()

static VOID Preview_GoNextPic ( PPREVIEW_DATA  pData, BOOL  bNext  )

static

Definition at line 1401 of file shimgvw.c.

{
    Preview_RestartTimer(pData->m_hwnd);
    if (g_pCurrentFile)
    {
        if (bNext)
            g_pCurrentFile = g_pCurrentFile->Next;
        else
            g_pCurrentFile = g_pCurrentFile->Prev;
        Preview_pLoadImageFromNode(pData, g_pCurrentFile);
        Preview_UpdateImage(pData);
        Preview_UpdateUI(pData);
    }
}

Referenced by Preview_OnCommand(), and PreviewWndProc().

Preview_IsMainWnd()

static BOOL Preview_IsMainWnd ( HWND  hwnd )

inlinestatic

Definition at line 124 of file shimgvw.c.

{
    return hwnd == g_hMainWnd;
}

Referenced by Preview_CreateToolBar(), Preview_EndSlideShow(), Preview_OnCommand(), Preview_OnMoveSize(), Preview_OnSize(), Preview_RestartTimer(), Preview_UpdateImage(), ZoomWnd_OnButtonDown(), and ZoomWnd_OnDraw().

Preview_OnCommand()

static VOID Preview_OnCommand ( HWND  hwnd, UINT  nCommandID  )

static

Definition at line 1417 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
 
    switch (nCommandID)
    {
        case IDC_PREV_PIC:
            Preview_GoNextPic(pData, FALSE);
            break;
 
        case IDC_NEXT_PIC:
            Preview_GoNextPic(pData, TRUE);
            break;
 
        case IDC_BEST_FIT:
            Preview_ResetZoom(pData);
            break;
 
        case IDC_REAL_SIZE:
            Preview_UpdateZoom(pData, 100, TRUE, FALSE);
            break;
 
        case IDC_SLIDE_SHOW:
            Preview_ToggleSlideShow(pData);
            break;
 
        case IDC_ZOOM_IN:
            Preview_ZoomInOrOut(pData, TRUE);
            break;
 
        case IDC_ZOOM_OUT:
            Preview_ZoomInOrOut(pData, FALSE);
            break;
 
        case IDC_ENDSLIDESHOW:
            Preview_EndSlideShow(hwnd);
            break;
 
        default:
            break;
    }
 
    if (!Preview_IsMainWnd(hwnd))
        return;
 
    // The following commands are for main window only:
    switch (nCommandID)
    {
        case IDC_SAVEAS:
            Preview_pSaveImageAs(pData);
            break;
 
        case IDC_PRINT:
            Preview_pPrintImage(pData);
            break;
 
        case IDC_ROT_CLOCKW:
            if (g_pImage)
            {
                GdipImageRotateFlip(g_pImage, Rotate270FlipNone);
                Preview_UpdateImage(pData);
            }
            break;
 
        case IDC_ROT_COUNCW:
            if (g_pImage)
            {
                GdipImageRotateFlip(g_pImage, Rotate90FlipNone);
                Preview_UpdateImage(pData);
            }
            break;
 
        case IDC_ROT_CWSAVE:
            if (g_pImage)
            {
                GdipImageRotateFlip(g_pImage, Rotate270FlipNone);
                Preview_pSaveImage(pData, pData->m_szFile);
                Preview_UpdateImage(pData);
            }
            break;
 
        case IDC_ROT_CCWSAVE:
            if (g_pImage)
            {
                GdipImageRotateFlip(g_pImage, Rotate90FlipNone);
                Preview_pSaveImage(pData, pData->m_szFile);
                Preview_UpdateImage(pData);
            }
            break;
 
        case IDC_DELETE:
            Preview_Delete(pData);
            Preview_UpdateImage(pData);
            Preview_UpdateUI(pData);
            break;
 
        case IDC_MODIFY:
            Preview_Edit(hwnd);
            break;
 
        default:
            break;
    }
}

Referenced by PreviewWndProc().

Preview_OnCreate()

static BOOL Preview_OnCreate ( HWND  hwnd, LPCREATESTRUCT  pCS  )

static

Definition at line 1200 of file shimgvw.c.

{
    DWORD exstyle = 0;
    HWND hwndZoom;
    PPREVIEW_DATA pData = QuickAlloc(sizeof(PREVIEW_DATA), TRUE);
    pData->m_hwnd = hwnd;
    SetWindowLongPtrW(hwnd, GWLP_USERDATA, (LONG_PTR)pData);
 
    DragAcceptFiles(hwnd, TRUE);
 
    if (g_hMainWnd == NULL)
    {
        g_hMainWnd = hwnd;
        exstyle |= WS_EX_CLIENTEDGE;
    }
    else if (g_hwndFullscreen == NULL)
    {
        g_hwndFullscreen = hwnd;
    }
    else
    {
        return FALSE;
    }
 
    hwndZoom = CreateWindowExW(exstyle, WC_ZOOM, NULL, WS_CHILD | WS_VISIBLE,
                               0, 0, 0, 0, hwnd, NULL, g_hInstance, NULL);
    if (!hwndZoom)
    {
        QuickFree(pData);
        return FALSE;
    }
 
    pData->m_hwndZoom = hwndZoom;
    SetWindowLongPtrW(hwndZoom, GWLP_USERDATA, (LONG_PTR)pData);
    Anime_SetTimerWnd(&pData->m_Anime, pData->m_hwndZoom);
 
    if (!Preview_CreateToolBar(pData))
    {
        QuickFree(pData);
        return FALSE;
    }
 
    if (pCS && pCS->lpCreateParams)
    {
        LPCWSTR pszFileName = (LPCWSTR)pCS->lpCreateParams;
        WCHAR szFile[MAX_PATH];
 
        /* Make sure the path has no quotes on it */
        StringCchCopyW(szFile, _countof(szFile), pszFileName);
        PathUnquoteSpacesW(szFile);
 
        g_pCurrentFile = pBuildFileList(szFile);
        Preview_pLoadImageFromNode(pData, g_pCurrentFile);
        Preview_UpdateImage(pData);
        Preview_UpdateUI(pData);
    }
 
    return TRUE;
}

Referenced by PreviewWndProc().

Preview_OnDestroy()

static VOID Preview_OnDestroy ( HWND  hwnd )

static

Definition at line 1539 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
 
    KillTimer(hwnd, SLIDESHOW_TIMER_ID);
 
    pFreeFileList(g_pCurrentFile);
    g_pCurrentFile = NULL;
 
    Preview_pFreeImage(pData);
 
    SetWindowLongPtrW(pData->m_hwndZoom, GWLP_USERDATA, 0);
    DestroyWindow(pData->m_hwndZoom);
    pData->m_hwndZoom = NULL;
 
    DestroyWindow(pData->m_hwndToolBar);
    pData->m_hwndToolBar = NULL;
 
    SetWindowLongPtrW(pData->m_hwnd, GWLP_USERDATA, 0);
    QuickFree(pData);
 
    PostQuitMessage(0);
}

Referenced by PreviewWndProc().

Preview_OnDropFiles()

static VOID Preview_OnDropFiles ( HWND  hwnd, HDROP  hDrop  )

static

Definition at line 1564 of file shimgvw.c.

{
    WCHAR szFile[MAX_PATH];
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
 
    DragQueryFileW(hDrop, 0, szFile, _countof(szFile));
 
    pFreeFileList(g_pCurrentFile);
    g_pCurrentFile = pBuildFileList(szFile);
    Preview_pLoadImageFromNode(pData, g_pCurrentFile);
 
    DragFinish(hDrop);
}

Referenced by PreviewWndProc().

Preview_OnMoveSize()

static VOID Preview_OnMoveSize ( HWND  hwnd )

static

Definition at line 1261 of file shimgvw.c.

{
    WINDOWPLACEMENT wp;
    RECT *prc;
 
    if (IsIconic(hwnd) || !Preview_IsMainWnd(hwnd))
        return;
 
    wp.length = sizeof(WINDOWPLACEMENT);
    GetWindowPlacement(hwnd, &wp);
 
    /* Remember window position and size */
    prc = &wp.rcNormalPosition;
    g_Settings.X = prc->left;
    g_Settings.Y = prc->top;
    g_Settings.Width = prc->right - prc->left;
    g_Settings.Height = prc->bottom - prc->top;
    g_Settings.Maximized = IsZoomed(hwnd);
}

Referenced by Preview_OnSize(), and PreviewWndProc().

Preview_OnNotify()

static LRESULT Preview_OnNotify ( HWND  hwnd, LPNMHDR  pnmhdr  )

static

Definition at line 1523 of file shimgvw.c.

{
    switch (pnmhdr->code)
    {
        case TTN_GETDISPINFOW:
        {
            LPTOOLTIPTEXTW lpttt = (LPTOOLTIPTEXTW)pnmhdr;
            lpttt->hinst = g_hInstance;
            lpttt->lpszText = MAKEINTRESOURCEW(s_ButtonConfig[lpttt->hdr.idFrom - IDC_TOOL_BASE].ids);
            break;
        }
    }
    return 0;
}

Referenced by PreviewWndProc().

Preview_OnSize()

static VOID Preview_OnSize ( HWND  hwnd )

static

Definition at line 1282 of file shimgvw.c.

{
    RECT rc, rcClient;
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    HWND hToolBar = pData->m_hwndToolBar;
    INT cx, cy;
 
    /* We want 32-bit values. Don't use WM_SIZE lParam */
    GetClientRect(hwnd, &rcClient);
    cx = rcClient.right;
    cy = rcClient.bottom;
 
    if (Preview_IsMainWnd(pData->m_hwnd))
    {
        SendMessageW(hToolBar, TB_AUTOSIZE, 0, 0);
        GetWindowRect(hToolBar, &rc);
 
        MoveWindow(pData->m_hwndZoom, 0, 0, cx, cy - (rc.bottom - rc.top), TRUE);
 
        if (!IsIconic(hwnd)) /* Is it not minimized? */
            Preview_ResetZoom(pData);
 
        Preview_OnMoveSize(hwnd);
    }
    else
    {
        MoveWindow(pData->m_hwndZoom, 0, 0, cx, cy, TRUE);
    }
}

Referenced by PreviewWndProc().

Preview_pFreeImage()

static VOID Preview_pFreeImage ( PPREVIEW_DATA  pData )

static

Definition at line 338 of file shimgvw.c.

{
    Anime_FreeInfo(&pData->m_Anime);
 
    if (g_pImage)
    {
        GdipDisposeImage(g_pImage);
        g_pImage = NULL;
    }
 
    if (pData->m_pMemStream)
    {
        pData->m_pMemStream->lpVtbl->Release(pData->m_pMemStream);
        pData->m_pMemStream = NULL;
    }
 
    pData->m_szFile[0] = UNICODE_NULL;
}

Referenced by Preview_OnDestroy(), and Preview_pLoadImage().

Preview_pLoadImage()

static VOID Preview_pLoadImage ( PPREVIEW_DATA  pData, LPCWSTR  szOpenFileName  )

static

Definition at line 391 of file shimgvw.c.

{
    Preview_pFreeImage(pData);
 
    pData->m_pMemStream = MemStreamFromFile(szOpenFileName);
    if (!pData->m_pMemStream)
    {
        DPRINT1("MemStreamFromFile() failed\n");
        Preview_UpdateTitle(pData, NULL);
        return;
    }
 
    /* NOTE: GdipLoadImageFromFile locks the file.
             Avoid file locking by using GdipLoadImageFromStream and memory stream. */
    GdipLoadImageFromStream(pData->m_pMemStream, &g_pImage);
    if (!g_pImage)
    {
        DPRINT1("GdipLoadImageFromStream() failed\n");
        Preview_pFreeImage(pData);
        Preview_UpdateTitle(pData, NULL);
        return;
    }
 
    Anime_LoadInfo(&pData->m_Anime);
 
    SHAddToRecentDocs(SHARD_PATHW, szOpenFileName);
    GetFullPathNameW(szOpenFileName, _countof(pData->m_szFile), pData->m_szFile, NULL);
 
    /* Reset zoom and redraw display */
    Preview_ResetZoom(pData);
 
    Preview_UpdateTitle(pData, szOpenFileName);
}

Referenced by Preview_pLoadImageFromNode().

Preview_pLoadImageFromNode()

static VOID Preview_pLoadImageFromNode ( PPREVIEW_DATA  pData, SHIMGVW_FILENODE *  pNode  )

static

Definition at line 426 of file shimgvw.c.

{
    Preview_pLoadImage(pData, (pNode ? pNode->FileName : NULL));
}

Referenced by Preview_Delete(), Preview_GoNextPic(), Preview_OnCreate(), and Preview_OnDropFiles().

Preview_pPrintImage()

static VOID Preview_pPrintImage ( PPREVIEW_DATA  pData )

static

Definition at line 576 of file shimgvw.c.

{
    /* FIXME */
}

Referenced by Preview_OnCommand().

Preview_pSaveImage()

static BOOL Preview_pSaveImage ( PPREVIEW_DATA  pData, LPCWSTR  pszFile  )

static

Definition at line 432 of file shimgvw.c.

{
    ImageCodecInfo *codecInfo;
    GUID rawFormat;
    UINT j, num, nFilterIndex, size;
    BOOL ret = FALSE;
 
    if (g_pImage == NULL)
        return FALSE;
 
    GdipGetImageEncodersSize(&num, &size);
    codecInfo = QuickAlloc(size, FALSE);
    if (!codecInfo)
    {
        DPRINT1("QuickAlloc() failed in pSaveImage()\n");
        return FALSE;
    }
    GdipGetImageEncoders(num, size, codecInfo);
 
    GdipGetImageRawFormat(g_pImage, &rawFormat);
    if (IsEqualGUID(&rawFormat, &ImageFormatMemoryBMP))
        rawFormat = ImageFormatBMP;
 
    nFilterIndex = 0;
    for (j = 0; j < num; ++j)
    {
        if (IsEqualGUID(&rawFormat, &codecInfo[j].FormatID))
        {
            nFilterIndex = j + 1;
            break;
        }
    }
 
    Anime_Pause(&pData->m_Anime);
 
    ret = (nFilterIndex > 0) &&
          (GdipSaveImageToFile(g_pImage, pszFile, &codecInfo[nFilterIndex - 1].Clsid, NULL) == Ok);
    if (!ret)
        DPRINT1("GdipSaveImageToFile() failed\n");
 
    Anime_Start(&pData->m_Anime, 0);
 
    QuickFree(codecInfo);
    return ret;
}

Referenced by Preview_OnCommand().

Preview_pSaveImageAs()

static VOID Preview_pSaveImageAs ( PPREVIEW_DATA  pData )

static

Definition at line 479 of file shimgvw.c.

{
    OPENFILENAMEW sfn;
    ImageCodecInfo *codecInfo;
    WCHAR szSaveFileName[MAX_PATH];
    WCHAR *szFilterMask;
    GUID rawFormat;
    UINT num, size, j;
    size_t sizeRemain;
    WCHAR *c;
    HWND hwnd = pData->m_hwnd;
 
    if (g_pImage == NULL)
        return;
 
    GdipGetImageEncodersSize(&num, &size);
    codecInfo = QuickAlloc(size, FALSE);
    if (!codecInfo)
    {
        DPRINT1("QuickAlloc() failed in pSaveImageAs()\n");
        return;
    }
 
    GdipGetImageEncoders(num, size, codecInfo);
 
    GdipGetImageRawFormat(g_pImage, &rawFormat);
    if (IsEqualGUID(&rawFormat, &ImageFormatMemoryBMP))
        rawFormat = ImageFormatBMP;
 
    sizeRemain = 0;
    for (j = 0; j < num; ++j)
    {
        // Every pair needs space for the Description, twice the Extensions, 1 char for the space, 2 for the braces and 2 for the NULL terminators.
        sizeRemain = sizeRemain + (((wcslen(codecInfo[j].FormatDescription) + (wcslen(codecInfo[j].FilenameExtension) * 2) + 5) * sizeof(WCHAR)));
    }
 
    /* Add two more chars for the last terminator */
    sizeRemain += (sizeof(WCHAR) * 2);
 
    szFilterMask = QuickAlloc(sizeRemain, FALSE);
    if (!szFilterMask)
    {
        DPRINT1("cannot allocate memory for filter mask in pSaveImageAs()");
        QuickFree(codecInfo);
        return;
    }
 
    ZeroMemory(szSaveFileName, sizeof(szSaveFileName));
    ZeroMemory(szFilterMask, sizeRemain);
    ZeroMemory(&sfn, sizeof(sfn));
    sfn.lStructSize = sizeof(sfn);
    sfn.hwndOwner   = hwnd;
    sfn.lpstrFile   = szSaveFileName;
    sfn.lpstrFilter = szFilterMask;
    sfn.nMaxFile    = _countof(szSaveFileName);
    sfn.Flags       = OFN_EXPLORER | OFN_OVERWRITEPROMPT | OFN_HIDEREADONLY;
    sfn.lpstrDefExt = L"png";
 
    c = szFilterMask;
 
    for (j = 0; j < num; ++j)
    {
        StringCbPrintfExW(c, sizeRemain, &c, &sizeRemain, 0, L"%ls (%ls)", codecInfo[j].FormatDescription, codecInfo[j].FilenameExtension);
 
        /* Skip the NULL character */
        c++;
        sizeRemain -= sizeof(*c);
 
        StringCbPrintfExW(c, sizeRemain, &c, &sizeRemain, 0, L"%ls", codecInfo[j].FilenameExtension);
 
        /* Skip the NULL character */
        c++;
        sizeRemain -= sizeof(*c);
 
        if (IsEqualGUID(&rawFormat, &codecInfo[j].FormatID))
        {
            sfn.nFilterIndex = j + 1;
        }
    }
 
    if (GetSaveFileNameW(&sfn) && sfn.nFilterIndex > 0)
    {
        Anime_Pause(&pData->m_Anime);
 
        if (GdipSaveImageToFile(g_pImage, szSaveFileName, &codecInfo[sfn.nFilterIndex - 1].Clsid, NULL) != Ok)
        {
            DPRINT1("GdipSaveImageToFile() failed\n");
        }
 
        Anime_Start(&pData->m_Anime, 0);
    }
 
    QuickFree(szFilterMask);
    QuickFree(codecInfo);
}

Referenced by Preview_OnCommand().

Preview_ResetZoom()

static VOID Preview_ResetZoom ( PPREVIEW_DATA  pData )

static

Definition at line 274 of file shimgvw.c.

{
    RECT Rect;
    UINT ImageWidth, ImageHeight, NewZoom;
 
    if (g_pImage == NULL)
        return;
 
    /* get disp window size and image size */
    GetClientRect(pData->m_hwndZoom, &Rect);
    GdipGetImageWidth(g_pImage, &ImageWidth);
    GdipGetImageHeight(g_pImage, &ImageHeight);
 
    /* compare two aspect rates. same as
       (ImageHeight / ImageWidth < Rect.bottom / Rect.right) in real */
    if (ImageHeight * Rect.right < Rect.bottom * ImageWidth)
    {
        if (Rect.right < ImageWidth)
        {
            /* it's large, shrink it */
            NewZoom = (Rect.right * 100) / ImageWidth;
        }
        else
        {
            /* it's small. show as original size */
            NewZoom = 100;
        }
    }
    else
    {
        if (Rect.bottom < ImageHeight)
        {
            /* it's large, shrink it */
            NewZoom = (Rect.bottom * 100) / ImageHeight;
        }
        else
        {
            /* it's small. show as original size */
            NewZoom = 100;
        }
    }
 
    Preview_UpdateZoom(pData, NewZoom, FALSE, TRUE);
}

Referenced by Preview_EndSlideShow(), Preview_OnCommand(), Preview_OnSize(), Preview_pLoadImage(), and Preview_UpdateImage().

Preview_RestartTimer()

static VOID Preview_RestartTimer ( HWND  hwnd )

static

Definition at line 130 of file shimgvw.c.

{
    if (!Preview_IsMainWnd(hwnd))
    {
        KillTimer(hwnd, SLIDESHOW_TIMER_ID);
        SetTimer(hwnd, SLIDESHOW_TIMER_ID, SLIDESHOW_TIMER_INTERVAL, NULL);
    }
}

Referenced by Preview_GoNextPic(), Preview_ToggleSlideShow(), and Preview_UpdateZoom().

Preview_ToggleSlideShow()

static VOID Preview_ToggleSlideShow ( PPREVIEW_DATA  pData )

static

Definition at line 1375 of file shimgvw.c.

{
    if (!IsWindow(g_hwndFullscreen))
    {
        DWORD style = WS_POPUP | WS_CLIPSIBLINGS, exstyle = WS_EX_TOPMOST;
        WCHAR szTitle[256];
        LoadStringW(g_hInstance, IDS_APPTITLE, szTitle, _countof(szTitle));
        g_hwndFullscreen = CreateWindowExW(exstyle, WC_PREVIEW, szTitle, style,
                                           0, 0, 0, 0, NULL, NULL, g_hInstance, NULL);
    }
 
    if (IsWindowVisible(g_hwndFullscreen))
    {
        ShowWindow(g_hwndFullscreen, SW_HIDE);
        ShowWindow(g_hMainWnd, SW_SHOWNORMAL);
        KillTimer(g_hwndFullscreen, SLIDESHOW_TIMER_ID);
    }
    else
    {
        ShowWindow(g_hMainWnd, SW_HIDE);
        ShowWindow(g_hwndFullscreen, SW_SHOWMAXIMIZED);
        Preview_RestartTimer(g_hwndFullscreen);
    }
}

Referenced by Preview_OnCommand().

Preview_UpdateImage()

static VOID Preview_UpdateImage ( PPREVIEW_DATA  pData )

static

Definition at line 590 of file shimgvw.c.

{
    if (!Preview_IsMainWnd(pData->m_hwnd))
        Preview_ResetZoom(pData);
 
    ZoomWnd_UpdateScroll(pData, pData->m_hwndZoom, TRUE);
}

Referenced by Preview_GoNextPic(), Preview_OnCommand(), and Preview_OnCreate().

Preview_UpdateTitle()

static VOID Preview_UpdateTitle ( PPREVIEW_DATA  pData, LPCWSTR  FileName  )

static

Definition at line 320 of file shimgvw.c.

{
    WCHAR szText[MAX_PATH + 100];
    LPWSTR pchFileTitle;
 
    LoadStringW(g_hInstance, IDS_APPTITLE, szText, _countof(szText));
 
    pchFileTitle = PathFindFileNameW(FileName);
    if (pchFileTitle && *pchFileTitle)
    {
        StringCchCatW(szText, _countof(szText), L" - ");
        StringCchCatW(szText, _countof(szText), pchFileTitle);
    }
 
    SetWindowTextW(pData->m_hwnd, szText);
}

Referenced by Preview_pLoadImage().

Preview_UpdateUI()

static VOID Preview_UpdateUI ( PPREVIEW_DATA  pData )

static

Definition at line 582 of file shimgvw.c.

{
    BOOL bEnable = (g_pImage != NULL);
    PostMessageW(pData->m_hwndToolBar, TB_ENABLEBUTTON, IDC_SAVEAS, bEnable);
    PostMessageW(pData->m_hwndToolBar, TB_ENABLEBUTTON, IDC_PRINT, bEnable);
}

Referenced by Preview_GoNextPic(), Preview_OnCommand(), and Preview_OnCreate().

Preview_UpdateZoom()

static VOID Preview_UpdateZoom ( PPREVIEW_DATA  pData, UINT  NewZoom, BOOL  bEnableBestFit, BOOL  bEnableRealSize  )

static

Definition at line 212 of file shimgvw.c.

{
    BOOL bEnableZoomIn, bEnableZoomOut;
    HWND hToolBar = pData->m_hwndToolBar;
 
    pData->m_nZoomPercents = NewZoom;
 
    /* Check if a zoom button of the toolbar must be grayed */
    bEnableZoomIn  = (NewZoom < MAX_ZOOM);
    bEnableZoomOut = (NewZoom > MIN_ZOOM);
 
    /* Update toolbar buttons */
    PostMessageW(hToolBar, TB_ENABLEBUTTON, IDC_ZOOM_OUT, bEnableZoomOut);
    PostMessageW(hToolBar, TB_ENABLEBUTTON, IDC_ZOOM_IN,  bEnableZoomIn);
    PostMessageW(hToolBar, TB_ENABLEBUTTON, IDC_BEST_FIT, bEnableBestFit);
    PostMessageW(hToolBar, TB_ENABLEBUTTON, IDC_REAL_SIZE, bEnableRealSize);
 
    /* Redraw the display window */
    InvalidateRect(pData->m_hwndZoom, NULL, TRUE);
 
    /* Restart timer if necessary */
    Preview_RestartTimer(pData->m_hwnd);
 
    /* Update scroll info */
    ZoomWnd_UpdateScroll(pData, pData->m_hwndZoom, FALSE);
}

Referenced by Preview_OnCommand(), Preview_ResetZoom(), and Preview_ZoomInOrOut().

Preview_ZoomInOrOut()

static VOID Preview_ZoomInOrOut ( PPREVIEW_DATA  pData, BOOL  bZoomIn  )

static

Definition at line 240 of file shimgvw.c.

{
    UINT i, NewZoom;
 
    if (g_pImage == NULL)
        return;
 
    if (bZoomIn)    /* zoom in */
    {
        /* find next step */
        for (i = 0; i < _countof(s_ZoomSteps); ++i)
        {
            if (pData->m_nZoomPercents < s_ZoomSteps[i])
                break;
        }
        NewZoom = ((i >= _countof(s_ZoomSteps)) ? MAX_ZOOM : s_ZoomSteps[i]);
    }
    else            /* zoom out */
    {
        /* find previous step */
        for (i = _countof(s_ZoomSteps); i > 0; )
        {
            --i;
            if (s_ZoomSteps[i] < pData->m_nZoomPercents)
                break;
        }
        NewZoom = ((i < 0) ? MIN_ZOOM : s_ZoomSteps[i]);
    }
 
    /* Update toolbar and refresh screen */
    Preview_UpdateZoom(pData, NewZoom, TRUE, TRUE);
}

Referenced by Preview_OnCommand(), and ZoomWnd_OnMouseWheel().

PreviewWndProc()

LRESULT CALLBACK PreviewWndProc	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1579 of file shimgvw.c.

{
    switch (uMsg)
    {
        case WM_CREATE:
        {
            if (!Preview_OnCreate(hwnd, (LPCREATESTRUCT)lParam))
                return -1;
            break;
        }
        case WM_COMMAND:
        {
            Preview_OnCommand(hwnd, LOWORD(wParam));
            break;
        }
        case WM_NOTIFY:
        {
            return Preview_OnNotify(hwnd, (LPNMHDR)lParam);
        }
        case WM_GETMINMAXINFO:
        {
            MINMAXINFO *pMMI = (MINMAXINFO*)lParam;
            pMMI->ptMinTrackSize.x = 350;
            pMMI->ptMinTrackSize.y = 290;
            break;
        }
        case WM_MOVE:
        {
            Preview_OnMoveSize(hwnd);
            break;
        }
        case WM_SIZE:
        {
            Preview_OnSize(hwnd);
            break;
        }
        case WM_DROPFILES:
        {
            Preview_OnDropFiles(hwnd, (HDROP)wParam);
            break;
        }
        case WM_SYSCOLORCHANGE:
        {
            PPREVIEW_DATA pData = Preview_GetData(hwnd);
            InvalidateRect(pData->m_hwnd, NULL, TRUE);
            InvalidateRect(pData->m_hwndZoom, NULL, TRUE);
            break;
        }
        case WM_DESTROY:
        {
            Preview_OnDestroy(hwnd);
            break;
        }
        case WM_TIMER:
        {
            if (wParam == SLIDESHOW_TIMER_ID)
            {
                PPREVIEW_DATA pData = Preview_GetData(hwnd);
                Preview_GoNextPic(pData, TRUE);
            }
            break;
        }
        default:
        {
            return DefWindowProcW(hwnd, uMsg, wParam, lParam);
        }
    }
 
    return 0;
}

Referenced by ImageView_Main().

ZoomWnd_OnButtonDown()

static VOID ZoomWnd_OnButtonDown ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 994 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    HWND hParent = GetParent(hwnd);
    if ((uMsg == WM_LBUTTONDOWN) || (uMsg == WM_RBUTTONDOWN))
    {
        if (!Preview_IsMainWnd(hParent))
            Preview_EndSlideShow(hParent);
        return;
    }
 
    pData->m_nMouseDownMsg = uMsg;
    pData->m_ptOrigin.x = GET_X_LPARAM(lParam);
    pData->m_ptOrigin.y = GET_Y_LPARAM(lParam);
    SetCapture(hwnd);
    SetCursor(LoadCursorW(g_hInstance, MAKEINTRESOURCEW(IDC_HANDDRAG)));
}

Referenced by ZoomWndProc().

ZoomWnd_OnButtonUp()

static VOID ZoomWnd_OnButtonUp ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1041 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    pData->m_nMouseDownMsg = 0;
    ReleaseCapture();
}

Referenced by ZoomWndProc().

ZoomWnd_OnDraw()

static VOID ZoomWnd_OnDraw ( PPREVIEW_DATA  pData, HDC  hdc, LPRECT  prcPaint, LPRECT  prcClient  )

static

Definition at line 751 of file shimgvw.c.

{
    GpGraphics *graphics;
    INT ZoomedWidth, ZoomedHeight;
    RECT rect, rcClient = *prcClient;
    HDC hdcMem;
    HBRUSH hBrush;
    HPEN hPen;
    HGDIOBJ hbrOld, hbmOld, hPenOld;
    UINT uFlags;
    HBITMAP hbmMem;
    SIZE paintSize = { prcPaint->right - prcPaint->left, prcPaint->bottom - prcPaint->top };
    COLORREF color0, color1;
    GpImageAttributes *imageAttributes;
 
    /* We use a memory bitmap to reduce flickering */
    hdcMem = CreateCompatibleDC(hdc);
    hbmMem = CreateCompatibleBitmap(hdc, paintSize.cx, paintSize.cy);
    hbmOld = SelectObject(hdcMem, hbmMem);
 
    /* Choose colors */
    if (Preview_IsMainWnd(pData->m_hwnd))
    {
        color0 = GetSysColor(COLOR_WINDOW);
        color1 = GetSysColor(COLOR_WINDOWTEXT);
    }
    else
    {
        color0 = RGB(0, 0, 0);
        color1 = RGB(255, 255, 255);
    }
 
    hBrush = CreateSolidBrush(color0);
    SetBkColor(hdcMem, color0);
 
    hPen = CreatePen(PS_SOLID, 1, color1);
    SetTextColor(hdcMem, color1);
 
    /* Fill background */
    SetRect(&rect, 0, 0, paintSize.cx, paintSize.cy);
    FillRect(hdcMem, &rect, hBrush);
 
    DeleteObject(hBrush);
 
    if (g_pImage == NULL)
    {
        WCHAR szText[128];
        LoadStringW(g_hInstance, IDS_NOPREVIEW, szText, _countof(szText));
 
        SelectObject(hdcMem, GetStockFont(DEFAULT_GUI_FONT));
        OffsetRect(&rcClient, -prcPaint->left, -prcPaint->top);
        DrawTextW(hdcMem, szText, -1, &rcClient, DT_SINGLELINE | DT_CENTER | DT_VCENTER |
                                                 DT_NOPREFIX);
    }
    else
    {
        UINT ImageWidth, ImageHeight;
 
        GdipGetImageWidth(g_pImage, &ImageWidth);
        GdipGetImageHeight(g_pImage, &ImageHeight);
 
        ZoomedWidth  = (ImageWidth  * pData->m_nZoomPercents) / 100;
        ZoomedHeight = (ImageHeight * pData->m_nZoomPercents) / 100;
 
        GdipCreateFromHDC(hdcMem, &graphics);
        if (!graphics)
        {
            DPRINT1("error: GdipCreateFromHDC\n");
            return;
        }
 
        GdipGetImageFlags(g_pImage, &uFlags);
 
        if (pData->m_nZoomPercents % 100 == 0)
        {
            GdipSetInterpolationMode(graphics, InterpolationModeNearestNeighbor);
            GdipSetSmoothingMode(graphics, SmoothingModeNone);
        }
        else
        {
            GdipSetInterpolationMode(graphics, InterpolationModeHighQualityBilinear);
            GdipSetSmoothingMode(graphics, SmoothingModeHighQuality);
        }
 
        rect.left   = (rcClient.right  - ZoomedWidth ) / 2;
        rect.top    = (rcClient.bottom - ZoomedHeight) / 2;
        rect.right  = rect.left + ZoomedWidth;
        rect.bottom = rect.top  + ZoomedHeight;
        OffsetRect(&rect,
                   -prcPaint->left - pData->m_xScrollOffset,
                   -prcPaint->top  - pData->m_yScrollOffset);
 
        InflateRect(&rect, +1, +1); /* Add Rectangle() pen width */
 
        /* Draw a rectangle. Fill by checker board if necessary */
        if (uFlags & (ImageFlagsHasAlpha | ImageFlagsHasTranslucent))
            hbrOld = SelectObject(hdcMem, CreateCheckerBoardBrush());
        else
            hbrOld = SelectObject(hdcMem, GetStockBrush(NULL_BRUSH));
        hPenOld = SelectObject(hdcMem, hPen);
        Rectangle(hdcMem, rect.left, rect.top, rect.right, rect.bottom);
        DeleteObject(SelectObject(hdcMem, hbrOld));
        DeleteObject(SelectObject(hdcMem, hPenOld));
 
        InflateRect(&rect, -1, -1); /* Subtract Rectangle() pen width */
 
        /* Image attributes are required to draw image correctly */
        GdipCreateImageAttributes(&imageAttributes);
        GdipSetImageAttributesWrapMode(imageAttributes, WrapModeTile,
                                       GetBkColor(hdcMem) | 0xFF000000, TRUE);
 
        /* Draw image. -0.5f is used for interpolation */
        GdipDrawImageRectRect(graphics, g_pImage,
                              rect.left, rect.top,
                              rect.right - rect.left, rect.bottom - rect.top,
                              -0.5f, -0.5f, ImageWidth, ImageHeight,
                              UnitPixel, imageAttributes, NULL, NULL);
 
        GdipDisposeImageAttributes(imageAttributes);
        GdipDeleteGraphics(graphics);
    }
 
    BitBlt(hdc, prcPaint->left, prcPaint->top, paintSize.cx, paintSize.cy, hdcMem, 0, 0, SRCCOPY);
    DeleteObject(SelectObject(hdcMem, hbmOld));
    DeleteDC(hdcMem);
}

Referenced by ZoomWnd_OnPaint().

ZoomWnd_OnHVScroll()

static VOID ZoomWnd_OnHVScroll ( PPREVIEW_DATA  pData, HWND  hwnd, WPARAM  wParam, BOOL  bVertical  )

static

Definition at line 1049 of file shimgvw.c.

{
    UINT ImageWidth, ImageHeight, ZoomedWidth, ZoomedHeight;
    RECT rcClient;
    UINT nBar = (bVertical ? SB_VERT : SB_HORZ);
    SCROLLINFO si = { sizeof(si), SIF_ALL };
    GetScrollInfo(hwnd, nBar, &si);
 
    if (!g_pImage)
        return;
 
    if (bVertical)
    {
        if (!(GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_VSCROLL))
            return;
    }
    else
    {
        if (!(GetWindowLongPtrW(hwnd, GWL_STYLE) & WS_HSCROLL))
            return;
    }
 
    switch (LOWORD(wParam))
    {
        case SB_THUMBTRACK:
        case SB_THUMBPOSITION:
            si.nPos = (SHORT)HIWORD(wParam);
            break;
        case SB_LINELEFT:
            si.nPos -= 48;
            break;
        case SB_LINERIGHT:
            si.nPos += 48;
            break;
        case SB_PAGELEFT:
            si.nPos -= si.nPage;
            break;
        case SB_PAGERIGHT:
            si.nPos += si.nPage;
            break;
    }
 
    si.fMask = SIF_POS;
    SetScrollInfo(hwnd, nBar, &si, TRUE);
    GetScrollInfo(hwnd, nBar, &si);
 
    GetClientRect(hwnd, &rcClient);
 
    if (bVertical)
    {
        GdipGetImageHeight(g_pImage, &ImageHeight);
        ZoomedHeight = (ImageHeight * pData->m_nZoomPercents) / 100;
        pData->m_yScrollOffset = si.nPos - (ZoomedHeight - rcClient.bottom) / 2;
    }
    else
    {
        GdipGetImageWidth(g_pImage, &ImageWidth);
        ZoomedWidth = (ImageWidth  * pData->m_nZoomPercents) / 100;
        pData->m_xScrollOffset = si.nPos - (ZoomedWidth - rcClient.right) / 2;
    }
 
    InvalidateRect(hwnd, NULL, TRUE);
}

Referenced by ZoomWndProc().

ZoomWnd_OnMouseMove()

static VOID ZoomWnd_OnMouseMove ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1013 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    POINT pt = { GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam) };
 
    if (pData->m_nMouseDownMsg == WM_MBUTTONDOWN)
    {
        INT x = GetScrollPos(hwnd, SB_HORZ) - (pt.x - pData->m_ptOrigin.x);
        INT y = GetScrollPos(hwnd, SB_VERT) - (pt.y - pData->m_ptOrigin.y);
        SendMessageW(hwnd, WM_HSCROLL, MAKEWPARAM(SB_THUMBPOSITION, x), 0);
        SendMessageW(hwnd, WM_VSCROLL, MAKEWPARAM(SB_THUMBPOSITION, y), 0);
        pData->m_ptOrigin = pt;
    }
}

Referenced by ZoomWndProc().

ZoomWnd_OnMouseWheel()

static VOID ZoomWnd_OnMouseWheel ( HWND  hwnd, INT  x, INT  y, INT  zDelta, UINT  fwKeys  )

static

Definition at line 1114 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    if (zDelta == 0)
        return;
 
    if (GetKeyState(VK_CONTROL) < 0)
    {
        Preview_ZoomInOrOut(pData, zDelta > 0);
    }
    else if (GetKeyState(VK_SHIFT) < 0)
    {
        if (zDelta > 0)
            SendMessageW(hwnd, WM_HSCROLL, SB_LINELEFT, 0);
        else
            SendMessageW(hwnd, WM_HSCROLL, SB_LINERIGHT, 0);
    }
    else
    {
        if (zDelta > 0)
            SendMessageW(hwnd, WM_VSCROLL, SB_LINEUP, 0);
        else
            SendMessageW(hwnd, WM_VSCROLL, SB_LINEDOWN, 0);
    }
}

Referenced by ZoomWndProc().

ZoomWnd_OnPaint()

static VOID ZoomWnd_OnPaint ( PPREVIEW_DATA  pData, HWND  hwnd  )

static

Definition at line 883 of file shimgvw.c.

{
    PAINTSTRUCT ps;
    HDC hDC;
    RECT rcClient;
 
    hDC = BeginPaint(hwnd, &ps);
    if (hDC)
    {
        GetClientRect(hwnd, &rcClient);
        ZoomWnd_OnDraw(pData, hDC, &ps.rcPaint, &rcClient);
        EndPaint(hwnd, &ps);
    }
}

Referenced by ZoomWndProc().

ZoomWnd_OnSetCursor()

static BOOL ZoomWnd_OnSetCursor ( HWND  hwnd, UINT  uMsg, WPARAM  wParam, LPARAM  lParam  )

static

Definition at line 1029 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    if (pData->m_nMouseDownMsg == WM_MBUTTONDOWN)
    {
        SetCursor(LoadCursorW(g_hInstance, MAKEINTRESOURCEW(IDC_HANDDRAG)));
        return TRUE;
    }
    return FALSE;
}

Referenced by ZoomWndProc().

ZoomWnd_UpdateScroll()

static VOID ZoomWnd_UpdateScroll ( PPREVIEW_DATA  pData, HWND  hwnd, BOOL  bResetPos  )

static

Definition at line 140 of file shimgvw.c.

{
    RECT rcClient;
    UINT ImageWidth, ImageHeight, ZoomedWidth, ZoomedHeight;
    SCROLLINFO si;
    BOOL bShowHorz, bShowVert;
 
    if (bResetPos)
        pData->m_xScrollOffset = pData->m_yScrollOffset = 0;
 
    if (!g_pImage)
    {
        ShowScrollBar(hwnd, SB_BOTH, FALSE);
        InvalidateRect(hwnd, NULL, TRUE);
        return;
    }
 
    GdipGetImageWidth(g_pImage, &ImageWidth);
    GdipGetImageHeight(g_pImage, &ImageHeight);
 
    ZoomedWidth  = (ImageWidth  * pData->m_nZoomPercents) / 100;
    ZoomedHeight = (ImageHeight * pData->m_nZoomPercents) / 100;
 
    GetClientRect(hwnd, &rcClient);
 
    bShowHorz = (rcClient.right < ZoomedWidth);
    bShowVert = (rcClient.bottom < ZoomedHeight);
    ShowScrollBar(hwnd, SB_HORZ, bShowHorz);
    ShowScrollBar(hwnd, SB_VERT, bShowVert);
 
    GetClientRect(hwnd, &rcClient);
 
    ZeroMemory(&si, sizeof(si));
    si.cbSize = sizeof(si);
    si.fMask = SIF_ALL;
 
    if (bShowHorz)
    {
        GetScrollInfo(hwnd, SB_HORZ, &si);
        si.nPage = rcClient.right;
        si.nMin = 0;
        si.nMax = ZoomedWidth;
        si.nPos = (ZoomedWidth - rcClient.right) / 2 + pData->m_xScrollOffset;
        si.nPos = max(min(si.nPos, si.nMax - (INT)si.nPage), si.nMin);
        SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
        pData->m_xScrollOffset = si.nPos - (ZoomedWidth - rcClient.right) / 2;
    }
    else
    {
        pData->m_xScrollOffset = 0;
    }
 
    if (bShowVert)
    {
        GetScrollInfo(hwnd, SB_VERT, &si);
        si.nPage = rcClient.bottom;
        si.nMin = 0;
        si.nMax = ZoomedHeight;
        si.nPos = (ZoomedHeight - rcClient.bottom) / 2 + pData->m_yScrollOffset;
        si.nPos = max(min(si.nPos, si.nMax - (INT)si.nPage), si.nMin);
        SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
        pData->m_yScrollOffset = si.nPos - (ZoomedHeight - rcClient.bottom) / 2;
    }
    else
    {
        pData->m_yScrollOffset = 0;
    }
 
    InvalidateRect(hwnd, NULL, TRUE);
}

Referenced by Preview_UpdateImage(), and Preview_UpdateZoom().

ZoomWndProc()

LRESULT CALLBACK ZoomWndProc	(	HWND	hwnd,
		UINT	uMsg,
		WPARAM	wParam,
		LPARAM	lParam
	)

Definition at line 1141 of file shimgvw.c.

{
    PPREVIEW_DATA pData = Preview_GetData(hwnd);
    switch (uMsg)
    {
        case WM_LBUTTONDOWN:
        case WM_MBUTTONDOWN:
        case WM_RBUTTONDOWN:
        {
            ZoomWnd_OnButtonDown(hwnd, uMsg, wParam, lParam);
            break;
        }
        case WM_MOUSEMOVE:
        {
            ZoomWnd_OnMouseMove(hwnd, uMsg, wParam, lParam);
            break;
        }
        case WM_SETCURSOR:
        {
            if (!ZoomWnd_OnSetCursor(hwnd, uMsg, wParam, lParam))
                return DefWindowProcW(hwnd, uMsg, wParam, lParam);
        }
        case WM_LBUTTONUP:
        case WM_MBUTTONUP:
        case WM_RBUTTONUP:
        {
            ZoomWnd_OnButtonUp(hwnd, uMsg, wParam, lParam);
            break;
        }
        case WM_PAINT:
        {
            ZoomWnd_OnPaint(pData, hwnd);
            break;
        }
        case WM_MOUSEWHEEL:
        {
            ZoomWnd_OnMouseWheel(hwnd, GET_X_LPARAM(lParam), GET_Y_LPARAM(lParam),
                                 (SHORT)HIWORD(wParam), (UINT)LOWORD(wParam));
            break;
        }
        case WM_HSCROLL:
        case WM_VSCROLL:
            ZoomWnd_OnHVScroll(pData, hwnd, wParam, uMsg == WM_VSCROLL);
            break;
        case WM_TIMER:
        {
            if (Anime_OnTimer(&pData->m_Anime, wParam))
                InvalidateRect(hwnd, NULL, FALSE);
            break;
        }
        default:
        {
            return DefWindowProcW(hwnd, uMsg, wParam, lParam);
        }
    }
    return 0;
}

Referenced by ImageView_Main().

Variable Documentation

g_hInstance

HINSTANCE g_hInstance = NULL

Definition at line 24 of file shimgvw.c.

Referenced by DllMain(), ImageView_Main(), Preview_CreateToolBar(), Preview_OnCreate(), Preview_OnNotify(), Preview_ToggleSlideShow(), Preview_UpdateTitle(), ZoomWnd_OnButtonDown(), ZoomWnd_OnDraw(), and ZoomWnd_OnSetCursor().

g_hMainWnd

HWND g_hMainWnd = NULL

Definition at line 25 of file shimgvw.c.

Referenced by Preview_EndSlideShow(), Preview_IsMainWnd(), Preview_OnCreate(), and Preview_ToggleSlideShow().

g_hwndFullscreen

HWND g_hwndFullscreen = NULL

Definition at line 26 of file shimgvw.c.

Referenced by ImageView_Main(), Preview_OnCreate(), and Preview_ToggleSlideShow().

g_pCurrentFile

SHIMGVW_FILENODE* g_pCurrentFile = NULL

Definition at line 27 of file shimgvw.c.

Referenced by Preview_Delete(), Preview_GoNextPic(), Preview_OnCreate(), Preview_OnDestroy(), and Preview_OnDropFiles().

g_pImage

GpImage* g_pImage = NULL

Definition at line 28 of file shimgvw.c.

Referenced by Anime_LoadInfo(), Anime_SetFrameIndex(), Preview_OnCommand(), Preview_pFreeImage(), Preview_pLoadImage(), Preview_pSaveImage(), Preview_pSaveImageAs(), Preview_ResetZoom(), Preview_UpdateUI(), Preview_ZoomInOrOut(), ZoomWnd_OnDraw(), ZoomWnd_OnHVScroll(), and ZoomWnd_UpdateScroll().

g_Settings

SHIMGVW_SETTINGS g_Settings

Definition at line 29 of file shimgvw.c.

Referenced by ImageView_LoadSettings(), ImageView_Main(), ImageView_ResetSettings(), ImageView_SaveSettings(), and Preview_OnMoveSize().

s_ButtonConfig

const TB_BUTTON_CONFIG s_ButtonConfig[]

static

Initial value:

=
{
    DEFINE_BTN_CONFIG(PREV_PIC),
    DEFINE_BTN_CONFIG(NEXT_PIC),
    DEFINE_BTN_CONFIG(BEST_FIT),
    DEFINE_BTN_CONFIG(REAL_SIZE),
    DEFINE_BTN_CONFIG(SLIDE_SHOW),
    DEFINE_BTN_CONFIG(ZOOM_IN),
    DEFINE_BTN_CONFIG(ZOOM_OUT),
    DEFINE_BTN_CONFIG(ROT_CLOCKW),
    DEFINE_BTN_CONFIG(ROT_COUNCW),
    DEFINE_BTN_CONFIG(ROT_CWSAVE),
    DEFINE_BTN_CONFIG(ROT_CCWSAVE),
    DEFINE_BTN_CONFIG(DELETE),
    DEFINE_BTN_CONFIG(PRINT),
    DEFINE_BTN_CONFIG(SAVEAS),
    DEFINE_BTN_CONFIG(MODIFY),
    DEFINE_BTN_CONFIG(HELP_TOC),
}

Definition at line 82 of file shimgvw.c.

Referenced by Preview_CreateToolBar(), and Preview_OnNotify().

s_Buttons

const TBBUTTON s_Buttons[]

static

Initial value:

=
{
    DEFINE_BTN_INFO(PREV_PIC),
    DEFINE_BTN_INFO(NEXT_PIC),
    DEFINE_BTN_SEPARATOR,
    DEFINE_BTN_INFO(BEST_FIT),
    DEFINE_BTN_INFO(REAL_SIZE),
    DEFINE_BTN_INFO(SLIDE_SHOW),
    DEFINE_BTN_SEPARATOR,
    DEFINE_BTN_INFO(ZOOM_IN),
    DEFINE_BTN_INFO(ZOOM_OUT),
    DEFINE_BTN_SEPARATOR,
    DEFINE_BTN_INFO(ROT_CLOCKW),
    DEFINE_BTN_INFO(ROT_COUNCW),
    DEFINE_BTN_SEPARATOR,
    DEFINE_BTN_INFO(ROT_CWSAVE),
    DEFINE_BTN_INFO(ROT_CCWSAVE),
    DEFINE_BTN_SEPARATOR,
    DEFINE_BTN_INFO(DELETE),
    DEFINE_BTN_INFO(PRINT),
    DEFINE_BTN_INFO(SAVEAS),
    DEFINE_BTN_INFO(MODIFY),
    DEFINE_BTN_SEPARATOR,
 
}

Definition at line 47 of file shimgvw.c.

Referenced by Preview_CreateToolBar().

s_ZoomSteps

const UINT s_ZoomSteps[]

static

Initial value:

=
{
    5, 10, 25, 50, 100, 200, 300, 500, 1000, 2000, 4000
}

Definition at line 31 of file shimgvw.c.

Referenced by Preview_ZoomInOrOut().