Задание с ограничениями - C++ WinAPI - Ответ 6761197

#include <Windows.h>
#include <process.h>
#include <strsafe.h>
#include "resource.h"
 
HWND hWnd, hDlg;
HINSTANCE hInst; 
LPCTSTR szWindowClass = "Y";
LPCTSTR szTitle = "Task";
 
#define MULTIPLYER 10000000;
 
 
ATOM MyRegisterClass(HINSTANCE hInstance);
BOOL InitInstance(HINSTANCE, int);
LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM);
 
 
int APIENTRY WinMain(HINSTANCE hInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR     lpCmdLine,
                     int       nCmdShow)
{
    MSG msg;
 
    MyRegisterClass(hInstance);
        if (!InitInstance (hInstance, nCmdShow)) 
        {
            return FALSE;
        }
 
        while (GetMessage(&msg, NULL, 0, 0)) 
        {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
        }
        return msg.wParam;
}
 
 
 
ATOM MyRegisterClass(HINSTANCE hInstance)
{
        WNDCLASSEX wcex; 
        wcex.cbSize = sizeof(WNDCLASSEX); 
        wcex.style          = CS_HREDRAW | CS_VREDRAW;  
        wcex.lpfnWndProc    = (WNDPROC)WndProc; 
        wcex.cbClsExtra     = 0;                        
        wcex.cbWndExtra     = 0;
        wcex.hInstance      = hInstance;        
        wcex.hIcon          = LoadIcon(NULL, IDI_HAND);     
        wcex.hCursor        = LoadCursor(NULL, IDC_ARROW); 
        wcex.hbrBackground  = GetSysColorBrush(COLOR_BTNFACE);   
        wcex.lpszMenuName   = MAKEINTRESOURCE(IDR_MENU1);
        wcex.lpszClassName  = szWindowClass;    
        wcex.hIconSm        = NULL;
 
        return RegisterClassEx(&wcex);
 
}
 
 
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow)
{
   
 
       hInst = hInstance;
 
       hWnd=CreateWindow(szWindowClass,
     szTitle,  
     WS_OVERLAPPEDWINDOW,
     300,   
     200,   
     30,    
     75,   
     NULL,  
     NULL,       
     hInstance, 
     NULL);    
 
       if (!hWnd)
       {
          return FALSE;
       }
       ShowWindow(hWnd, nCmdShow);      
       UpdateWindow(hWnd);          
       return TRUE;             
}
 
 
 
void ErrorExit(LPTSTR lpszFunction) 
{ 
    // Retrieve the system error message for the last-error code
 
    LPVOID lpMsgBuf;
    LPVOID lpDisplayBuf;
    DWORD dw = GetLastError(); 
 
    FormatMessage(
        FORMAT_MESSAGE_ALLOCATE_BUFFER | 
        FORMAT_MESSAGE_FROM_SYSTEM |
        FORMAT_MESSAGE_IGNORE_INSERTS,
        NULL,
        dw,
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        (LPTSTR) &lpMsgBuf,
        0, NULL );
 
    // Display the error message and exit the process
 
    lpDisplayBuf = (LPVOID)LocalAlloc(LMEM_ZEROINIT, 
        (lstrlen((LPCTSTR)lpMsgBuf)+lstrlen((LPCTSTR)lpszFunction)+40)*sizeof(TCHAR)); 
    StringCchPrintf((LPTSTR)lpDisplayBuf, 
        LocalSize(lpDisplayBuf) / sizeof(TCHAR),
        TEXT("%s failed with error %d: %s"), 
        lpszFunction, dw, lpMsgBuf); 
    MessageBox(NULL, (LPCTSTR)lpDisplayBuf, TEXT("Error"), MB_OK|WS_VISIBLE); 
 
    LocalFree(lpMsgBuf);
    LocalFree(lpDisplayBuf);
    ExitProcess(dw); 
}
 
 
LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
        BOOL Start = FALSE;
        HANDLE job = CreateJobObjectA (NULL, "MyJob");
        JOBOBJECT_BASIC_LIMIT_INFORMATION jobli;
        STARTUPINFO si ;
        ZeroMemory(&si, sizeof(STARTUPINFO));
        PROCESS_INFORMATION pi[5];
      switch (message)
      {
 
        case WM_CREATE:
            
            
            break;
 
        case WM_COMMAND:
            switch (LOWORD(wParam))
            {
                case ID_START:
                     Start = TRUE;
                    break;
                case ID_STARTPROCESS_CALCULATOR:
                    CreateProcess(NULL, "calc", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[0]);
                    if (!AssignProcessToJobObject ( job, pi[0].hProcess ))
                        ErrorExit(TEXT("AssignError"));
                    break;
                case ID_STARTPROCESS_CONSOLE:
                    CreateProcess(NULL, "CMD", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[1]);
                    AssignProcessToJobObject ( job, pi[1].hProcess );
                    break;
                case ID_STARTPROCESS_EXPLORER:
                    CreateProcess(NULL, "explorer", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[2]);
                    AssignProcessToJobObject ( job, pi[2].hProcess );
                        
                    break;
                case ID_STARTPROCESS_NOTEPAD:
                    CreateProcess(NULL, "Notepad", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[3]);
                    AssignProcessToJobObject ( job, pi[3].hProcess );
                    break;
                case ID_STARTPROCESS_PAINT:
                    CreateProcess(NULL, "mspaint", NULL, NULL, FALSE, CREATE_SUSPENDED, NULL, NULL, &si, &pi[4]);
                    AssignProcessToJobObject ( job, pi[4].hProcess );
                    break;
            }
            if ( Start == TRUE)
            {
                jobli.ActiveProcessLimit = 2;
                jobli.PerProcessUserTimeLimit.QuadPart = 1*MULTIPLYER;
                jobli.PerJobUserTimeLimit.QuadPart = 2*MULTIPLYER;
                jobli.PriorityClass = REALTIME_PRIORITY_CLASS;
                jobli.LimitFlags = JOB_OBJECT_LIMIT_PROCESS_TIME | JOB_OBJECT_LIMIT_JOB_TIME
                    | JOB_OBJECT_LIMIT_ACTIVE_PROCESS | JOB_OBJECT_LIMIT_PRIORITY_CLASS;
                SetInformationJobObject(job, JobObjectBasicLimitInformation, &jobli, sizeof(jobli));
                for ( int i = 0; i<5; i++)
                {
                    ResumeThread(pi[i].hThread);
                    CloseHandle(pi[i].hThread);
                }
            for (int i = 0 ; i<5; i++)
            {
            
 
            // проводим очистку 
                CloseHandle(pi[i].hProcess);
            }
            CloseHandle(job);
            
            }
            }
      break;
 
        case WM_PAINT:
          break;
 
       case WM_DESTROY:
           PostQuitMessage(0); 
           break;
 
       default: 
           return DefWindowProc(hwnd, message, wParam, lParam);
       }
       return 0;
}