Некорректный перенос битмапа в области окна

/ Lazariev_CourseProjectWinAPI_21_03_(1).cpp : Defines the entry point for the application.
//
 
#include "stdafx.h"
#include <iostream>
#include "Lazariev_CourseProjectWinAPI_21_03_(1).h"
 
using namespace std;
 
#define MAX_LOADSTRING 100
 
 
// Global Variables:
HINSTANCE hInst;                                  
HDC hdc,memDC;
TCHAR szTitle[MAX_LOADSTRING], szWindowClass[MAX_LOADSTRING];
wchar_t szFile[260];
OPENFILENAME ofn;
 
HBITMAP hBitmap;
BITMAP bm;
 
static POINT pos;
 
RECT        rc;
POINT       pt;
PAINTSTRUCT ps;
 
 
 
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
 
//BOOL OpenFileDialog(HWND hwnd, LPTSTR pFileName, LPTSTR pTitleName);
 
//Open
int MyOpenFile(HWND hWnd);
 
//PictureMoving
void image_free( BITMAP* img);
void image_focus(HDC hDC, BITMAP* img, const LPPOINT pt);
 
 
int APIENTRY wWinMain(_In_ HINSTANCE hInstance,
                     _In_opt_ HINSTANCE hPrevInstance,
                     _In_ LPWSTR    lpCmdLine,
                     _In_ int       nCmdShow)
{
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
 
    // Initialize global strings
    LoadStringW(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadStringW(hInstance, IDC_LAZARIEV_COURSEPROJECTWINAPI_21_03_1, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
 
    // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    HACCEL hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_LAZARIEV_COURSEPROJECTWINAPI_21_03_1));
 
    MSG msg;
 
    // Main message loop:
    while (GetMessage(&msg, nullptr, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
 
    return (int) msg.wParam;
}
 
 
 
 
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEXW wcex;
 
    wcex.cbSize = sizeof(WNDCLASSEX);
 
    wcex.style          = CS_HREDRAW | CS_VREDRAW;
    wcex.lpfnWndProc    = WndProc;
    wcex.cbClsExtra     = 0;
    wcex.cbWndExtra     = 0;
    wcex.hInstance      = hInstance;
    wcex.hIcon          = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_LAZARIEV_COURSEPROJECTWINAPI_21_03_1));
    wcex.hCursor        = LoadCursor(nullptr, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCEW(IDC_LAZARIEV_COURSEPROJECTWINAPI_21_03_1);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassExW(&wcex);
}
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   hInst = hInstance; // Store instance handle in our global variable
 
   HWND hWnd = CreateWindowW(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
      CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr, nullptr, hInstance, nullptr);
 
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
   return TRUE;
}
 
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    static HDC     thdc;
    //static image_t img;
    static POINT   offset,  prev;
    static bool    isMove = false;
    static HCURSOR hcur = NULL, scur = NULL;
 
    switch (message)
    {
    case WM_CREATE:
        thdc = GetDC(hWnd);
        GetClientRect(hWnd, &rc);
 
        pos.x = (rc.right - bm.bmWidth) / 2;
        pos.y = (rc.bottom - bm.bmHeight) / 2;
 
        hcur = LoadCursor(NULL, IDC_SIZEALL);
        scur = LoadCursor(NULL, IDC_ARROW);
        break;
    case WM_COMMAND:
    {
        int wmId = LOWORD(wParam);
        // Parse the menu selections:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_EXIT:
            DestroyWindow(hWnd);
            break;
        case ID_FILE_OPEN:
            MyOpenFile(hWnd);
            break;
        case ID_FILE_SAVE:
            break;
        case ID_FILE_SAVEAS:
            break;
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
    }
    break;
    case WM_PAINT:
    {
        PAINTSTRUCT ps;
        hdc = BeginPaint(hWnd, &ps);
        EndPaint(hWnd, &ps);
 
    }
    break;
    case WM_LBUTTONDOWN:
    {
        GetCursorPos(&offset);
        ScreenToClient(hWnd, &offset);
        SetRect(&rc, pos.x, pos.y, pos.x + bm.bmWidth, pos.y + bm.bmHeight);
 
        if (PtInRect(&rc, offset))
        {
            isMove = true;
            
            prev.x = offset.x - (offset.x - pos.x);
            prev.y = offset.y - (offset.y - pos.y);
            offset.x -= pos.x;
            offset.y -= pos.y;
            SetCursor(hcur);
        }
    }
    break;
    case WM_MOUSEMOVE:
        if (isMove)
        {
            GetCursorPos(&pt);
            ScreenToClient(hWnd, &pt);
            image_focus(thdc, &bm, &prev);
            prev.x = pt.x - offset.x;
            prev.y = pt.y - offset.y;
            image_focus(thdc, &bm, &prev);
        }
        break;
    case WM_LBUTTONUP:
        if (isMove) 
        {
            pt = pos;
            pos = prev;
            SetRect(&rc, prev.x, prev.y, prev.x + bm.bmWidth, prev.y + bm.bmHeight);
            InvalidateRect(hWnd, &rc, TRUE);
 
            SetRect(&rc, pt.x, pt.y, pt.x + bm.bmWidth, pt.y + bm.bmHeight);
            InvalidateRect(hWnd, &rc, TRUE);
            SetCursor(scur);
        }
        isMove = false;
        break;
    case WM_SETCURSOR:
        if (!isMove)
            return DefWindowProc(hWnd, message, wParam, lParam);
        break;
    case WM_DESTROY:
        //image_free(&bmimg);
        DestroyCursor(hcur);
        DestroyCursor(scur);
        ReleaseDC(hWnd, memDC);
        PostQuitMessage(0);
        break;
    default:
        return DefWindowProc(hWnd, message, wParam, lParam);
    }
    return 0;
}
 
 
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    switch (message)
    {
    case WM_INITDIALOG:
        return (INT_PTR)TRUE;
 
    case WM_COMMAND:
        if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL)
        {
            EndDialog(hDlg, LOWORD(wParam));
            return (INT_PTR)TRUE;
        }
        break;
    }
    return (INT_PTR)FALSE;
}
 
int MyOpenFile(HWND hWnd)
{
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hWnd;
    ofn.lpstrFile = szFile;
    ofn.lpstrFile[0] = '\0';
    ofn.nMaxFile = sizeof(szFile);
    ofn.lpstrFilter = L"Bitmap files(*.bmp)\0*.bmp\0JPEG files(*.jpg)\0*.jpg\0All files(*.*)\0*.*\0\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = NULL;
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
    GetOpenFileName(&ofn);
 
    hdc = GetDC(hWnd);
    memDC = CreateCompatibleDC(hdc);
    hBitmap = (HBITMAP)LoadImage(NULL, ofn.lpstrFile, IMAGE_BITMAP, 0, 0, LR_LOADFROMFILE);
    GetObject(hBitmap, sizeof(BITMAP), &bm);
    SelectObject(memDC, hBitmap);
    BitBlt(hdc, pos.x, pos.y, bm.bmWidth, bm.bmHeight, memDC, 0, 0, SRCCOPY);
    
    DeleteDC(memDC);
    ReleaseDC(hWnd, hdc);
    DeleteObject(hBitmap);
    ReleaseDC(hWnd, hdc);
    UpdateWindow(hWnd);
    return 0;
}
 
void image_focus(HDC hDC, BITMAP* img, const LPPOINT pt)
{
    RECT rc;
    SetROP2(hDC, R2_NOT);
    SetRect(&rc, pt->x, pt->y, pt->x + img->bmWidth, pt->y + img->bmHeight);
    DrawFocusRect(hDC, &rc);
}
//void image_free(BITMAP* img)
//{
//  if (img-> != NULL) {
//      DeleteObject(img->bmp);
//      img->bmp = NULL;
//  }
//  if (img->hdc != NULL) {
//      DeleteDC(img->hdc);
//      img->hdc = NULL;
//  }
//}