Дочернее окно не перемещается

#include "stdafx.h"
#include <commdlg.h>
#include <windows.h>
#include <stdio.h>
#include <iostream>
#include "test.h"
#include <commctrl.h>
#include <winuser.h>
 
#define MAX_LOADSTRING 100
 
// Global Variables:
HINSTANCE hInst;                                // current instance
TCHAR szTitle[MAX_LOADSTRING];                  // The title bar text
TCHAR szWindowClass[MAX_LOADSTRING];            // the main window class name
 
// Forward declarations of functions included in this code module:
ATOM                MyRegisterClass(HINSTANCE hInstance);
BOOL                InitInstance(HINSTANCE, int);
LRESULT CALLBACK    WndProc(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About(HWND, UINT, WPARAM, LPARAM);
INT_PTR CALLBACK    About1(HWND, UINT, WPARAM, LPARAM);
 
 
char filename[MAX_PATH]="";
 
OPENFILENAME ofn;
static char szFile[260];                   //открыть файл
static HANDLE hf;
HFONT fn1;
HWND hEdit;
HWND hStatusWindow;
HWND hChildWnd;                         //дочернее окно
 
 
void RegisterCommonControls();                  //необходимо для кнопки IP адреса
 
#pragma comment(lib, "comctl32.lib")
 
void RegisterCommonControls()
{
  INITCOMMONCONTROLSEX iccex;
 
  iccex.dwSize = sizeof(INITCOMMONCONTROLSEX); 
  iccex.dwICC  = ICC_TREEVIEW_CLASSES  // tree view and tooltip control classes
                  | ICC_LISTVIEW_CLASSES; // list view and header control classes
                           // see INITCOMMONCONTROLSEX in MSDN for a complete list
  InitCommonControlsEx(&iccex);
}
 
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPTSTR    lpCmdLine,
                     int       nCmdShow)
{
    InitCommonControls();
    UNREFERENCED_PARAMETER(hPrevInstance);
    UNREFERENCED_PARAMETER(lpCmdLine);
 
    // TODO: Place code here.
 
    MSG msg;
    HACCEL hAccelTable;
    RegisterCommonControls();
 
    // Initialize global strings
    LoadString(hInstance, IDS_APP_TITLE, szTitle, MAX_LOADSTRING);
    LoadString(hInstance, IDC_KOHONENMAPS, szWindowClass, MAX_LOADSTRING);
    MyRegisterClass(hInstance);
    
        // Perform application initialization:
    if (!InitInstance (hInstance, nCmdShow))
    {
        return FALSE;
    }
 
    hAccelTable = LoadAccelerators(hInstance, MAKEINTRESOURCE(IDC_KOHONENMAPS));
 
    // Main message loop:
    while (GetMessage(&msg, NULL, 0, 0))
    {
        if (!TranslateAccelerator(msg.hwnd, hAccelTable, &msg))
        {
            TranslateMessage(&msg);
            DispatchMessage(&msg);
        }
    }
    return (int) msg.wParam;
}
 
//
//  FUNCTION: MyRegisterClass()
//
//  PURPOSE: Registers the window class.
//
//  COMMENTS:
//
//    This function and its usage are only necessary if you want this code
//    to be compatible with Win32 systems prior to the 'RegisterClassEx'
//    function that was added to Windows 95. It is important to call this function
//    so that the application will get 'well formed' small icons associated
//    with it.
//
ATOM MyRegisterClass(HINSTANCE hInstance)
{
    WNDCLASSEX 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_KOHONENMAPS));
    wcex.hCursor        = LoadCursor(NULL, IDC_ARROW);
    wcex.hbrBackground  = (HBRUSH)(COLOR_WINDOW+1);
    wcex.lpszMenuName   = MAKEINTRESOURCE(IDC_KOHONENMAPS);
    wcex.lpszClassName  = szWindowClass;
    wcex.hIconSm        = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
 
    return RegisterClassEx(&wcex);
}
 
//
//   FUNCTION: InitInstance(HINSTANCE, int)
//
//   PURPOSE: Saves instance handle and creates main window
//
//   COMMENTS:
//
//        In this function, we save the instance handle in a global variable and
//        create and display the main program window.
//
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   HWND hWnd;
 
   hInst = hInstance; // Store instance handle in our global variable
 
   hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
   if (!hWnd)
   {
      return FALSE;
   }
 
   ShowWindow(hWnd, nCmdShow);
   UpdateWindow(hWnd);
 
//=====================================================
    ZeroMemory(&ofn, sizeof(ofn));
    ofn.lStructSize = sizeof(ofn);
    ofn.hwndOwner = hWnd;
    ofn.lpstrFile = szFile;
    ofn.lpstrFile[0] = '\0';
    ofn.nMaxFile = MAX_PATH;
    ofn.lpstrFilter = "Текстовые файлы \0*.txt\0 Все файлы\0*.*\0\0";
    ofn.nFilterIndex = 1;
    ofn.lpstrFileTitle = NULL;
    ofn.nMaxFileTitle = 0;
    ofn.lpstrInitialDir = NULL;
    ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
//=================================================
 
   return TRUE;
}
//
//  FUNCTION: WndProc(HWND, UINT, WPARAM, LPARAM)
//
//  PURPOSE:  Processes messages for the main window.
//
//  WM_COMMAND  - process the application menu
//  WM_PAINT    - Paint the main window
//  WM_DESTROY  - post a quit message and return
//
//
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int wmId, wmEvent;
    int pri;
    
    static HWND hButton = NULL;
    
    static HWND hwndStatusBar;
    static HINSTANCE hInstance;
 
    char* buf;
    int len;
    DWORD len1;
    
    static POINTS m;
    PAINTSTRUCT ps;
    HDC hdc;
 
    switch (message)
    {
            
        case WM_CREATE:
        {
            RECT rcClient;
            ::GetClientRect(hWnd,&rcClient);
            hEdit=CreateWindow("EDIT",NULL,WS_CHILD | WS_VISIBLE | WS_VSCROLL | 
                ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL, 0, 0, 0, 0,  
                hWnd,(HMENU) IDC_EDIT11, (HINSTANCE)::GetModuleHandle(NULL), NULL); 
                       ::SendMessage(hEdit,WM_SETFONT,WPARAM(fn1),TRUE);         
            ::SendMessage(hEdit,EM_SETLIMITTEXT,WPARAM(-1),0);
 
            InitCommonControls ();
            hStatusWindow=CreateStatusWindow(WS_CHILD|WS_VISIBLE|SBARS_SIZEGRIP,"text",hWnd,100);
            int widths[5]={100,150,200,-1};
            SendDlgItemMessage(hWnd,100,SB_SETPARTS,4,(LPARAM)widths);
            SendDlgItemMessage(hWnd,100,SB_SETTEXT,2,(LPARAM)"part 2");
            SendDlgItemMessage(hWnd,100,SB_SETTEXT,3,(LPARAM)"last part");
        break;
        }
 
         case WM_SIZE:
        {
            MoveWindow(hEdit,0, 0,LOWORD(lParam),HIWORD(lParam),TRUE);
            SendMessage(hStatusWindow, WM_SIZE, wParam, lParam);
            return 0;
        }
        
        case WM_COMMAND:
        wmId    = LOWORD(wParam);
        wmEvent = HIWORD(wParam);
 
        // Parse the menu selections:
        switch (wmId)
        {
        case IDM_ABOUT:
            DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
            break;
        case IDM_INPUT2:
            case IDM_INPUT4:
                if (GetOpenFileName(&ofn)==TRUE) 
                {
                    hf=CreateFile(ofn.lpstrFile,GENERIC_READ,FILE_READ_DATA,NULL,OPEN_EXISTING,0,0);
                    if (hf==INVALID_HANDLE_VALUE) 
                    {
                        MessageBox(hWnd,"Open failed","Error",MB_ICONHAND|MB_OK);
                        break;
                    }
                    len=GetFileSize(hf,NULL);
                    buf=(char*)malloc(len+1); /* доп. байт под символ-терминатор (0) */
                        if (!buf) 
                        {
                            MessageBox(hWnd,"Mem alloc failed","Error",MB_ICONHAND|MB_OK);
                            break;
                        }
                    ReadFile(hf,buf,len,&len1,NULL);
                    buf[len1]=0;
                    CloseHandle(hf);
                    SetDlgItemText(hWnd,IDC_EDIT11,buf);
                    free(buf);
                }
                InitCommonControls ();
                hwndStatusBar = CreateStatusWindow (WS_CHILD |
                WS_VISIBLE, "Открыт файл", hWnd, IDC_STATUS_BAR);   //создан статус бар после открытия файла
 
            break; 
 
            case IDM_SAVEAS:        /* команда меню "Save As" */
                ofn.lStructSize=OPENFILENAME_SIZE_VERSION_400A;
                ofn.hwndOwner=hWnd;
                ofn.lpstrFilter="Текстовые файлы \0*.txt\0 Все файлы\0*.*\0\0";
                ofn.lpstrCustomFilter=NULL; 
                ofn.nMaxCustFilter=0;
                ofn.nFilterIndex=1;
                ofn.lpstrFile=filename; 
                ofn.nMaxFile=MAX_PATH;
                ofn.lpstrFileTitle=NULL; 
                ofn.nMaxFileTitle=0;
                ofn.lpstrInitialDir=NULL;
                ofn.Flags=OFN_PATHMUSTEXIST|OFN_OVERWRITEPROMPT|OFN_HIDEREADONLY;
            if (!GetSaveFileName(&ofn)) break;
            case IDM_SAVE:          /* команда меню "Save" */
        /* для нового файла - вызываем диалог "Save As" */
            if (lstrlen(filename)==0) 
            {
                PostMessage(hWnd,WM_COMMAND,IDC_SAVEAS,lParam);
                break;
            }
            SetDlgItemText(hWnd,ID_STATUS,filename);
     /* сохраняем файл */
            hf=CreateFile(filename,GENERIC_WRITE,0,NULL,OPEN_ALWAYS,FILE_ATTRIBUTE_NORMAL,NULL);
            if (hf==INVALID_HANDLE_VALUE) 
            {
                MessageBox(hWnd,"Save failed","Error",MB_ICONHAND|MB_OK);
                break;
            }
            len=SendDlgItemMessage(hWnd,IDC_EDIT11,WM_GETTEXTLENGTH,0,0);
            buf=(char*)malloc(len+1); /* доп. байт под символ-терминатор (0) */
            GetDlgItemText(hWnd,IDC_EDIT11,buf,len+1);
            if (!buf) 
            {
                MessageBox(hWnd,"Mem alloc failed","Error",MB_ICONHAND|MB_OK);
                break;
            }
             WriteFile(hf,buf,len,&len1,NULL);
            CloseHandle(hf);
            free(buf);
            break;
                    
            case IDM_INPUT1:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG1), hWnd, About);
                break;
            case IDM_INPUT3:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_DIALOG3), hWnd, CELL);
                break;
            case IDM_INPUT5:
                DialogBox(hInst, MAKEINTRESOURCE(IDD_PARAM), hWnd, About1);
                break;
            case IDM_RUN:
                hChildWnd =CreateWindow (TEXT("STATIC"), NULL,  WS_OVERLAPPEDWINDOW| WS_VISIBLE | WS_BORDER,
                        10, 10, 600, 600, hEdit, NULL, hInstance, NULL);//дочернее окно
                    break;
            case IDM_EXIT:
/*-------------------------*/
pri=MessageBox(NULL,"Завершить работу?","Выход",MB_OKCANCEL);
if (pri==MB_OKCANCEL)
{
    PostQuitMessage(0);
    break;
}
else break;
            /*-------------*/
/*
            DestroyWindow(hWnd);
            break;*/        
        default:
            return DefWindowProc(hWnd, message, wParam, lParam);
        }
        break;
    case WM_PAINT:
        hdc = BeginPaint(hWnd, &ps);
        // TODO: Add any drawing code here...
        EndPaint(hWnd, &ps);
        break;
     case WM_LBUTTONDOWN:
            {
                SetCapture (hChildWnd);
                SendMessage (hChildWnd, WM_SYSCOMMAND, SC_MOVE,0);
                break;
            }
        case WM_LBUTTONUP:
            {
                ReleaseCapture();
                break;
            }       
    case WM_DESTROY:
        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)
            {
                GetDlgItemText(hDlg,IDC_IPADDRESS1,chBuffer,sizeof(chBuffer));
                GetDlgItemText(hDlg,IDC_EDIT4,grida,30);
                GetDlgItemText(hDlg,IDC_EDIT5,cell,30);
            
                EndDialog(hDlg, LOWORD(wParam));
                return (INT_PTR)TRUE;
}
else            
if (LOWORD(wParam) == IDCANCEL) 
            {
                EndDialog(hDlg, LOWORD(wParam));
                return (INT_PTR)TRUE;
            }
}
    return (INT_PTR)FALSE;
}

hEdit=CreateWindow("EDIT",NULL,WS_CHILD | WS_VISIBLE | WS_VSCROLL | 
                ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL, 0, 0, 0, 0,  
                hWnd,(HMENU) IDC_EDIT11, (HINSTANCE)::GetModuleHandle(NULL), NULL); 
hChildWnd =CreateWindow (TEXT("STATIC"), NULL,  WS_OVERLAPPEDWINDOW| WS_VISIBLE | WS_BORDER,
                                                10, 10, 600, 600, hEdit, NULL, hInstance, NULL);//дочернее окно

hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
     CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);

hEdit=CreateWindow("EDIT",NULL,WS_CHILD | WS_VISIBLE | WS_VSCROLL | 
                ES_LEFT | ES_MULTILINE | ES_AUTOVSCROLL, 0, 0, 0, 0,  
                hWnd,(HMENU) IDC_EDIT11, (HINSTANCE)::GetModuleHandle(NULL), NULL);

hChildWnd=CreateWindow ("Edit", NULL,  WS_OVERLAPPEDWINDOW| WS_VISIBLE | WS_BORDER,
                                                10, 10, 600, 600, hEdit, NULL, hInstance, NULL);