[C++] [WinApi] "Zamrażanie" okna aplikacji

#include <process.h>  // wymagane ze względu na _beginthread
#include <Windows.h>
#include <iostream>
#include <list>

CRITICAL_SECTION g_Section;

struct STask {
    int taskType;
    int userID;
    unsigned int taskTime;
    std::string taskMsg;
    void Process( void ) {
        std::cout << "Struktura nr " << taskType << std::endl;
        Sleep( 500 ); // z braku lepszego zajęcia... ;-)
    }
};
std::list < STask > g_TaskQueue;

// __cdecl czyści na początku stos wątku
void __cdecl ThreadProc( void * Args ) {
    while( !g_TaskQueue.empty() ) {
        EnterCriticalSection( & g_Section ); // początek sekcji krytycznej
        STask task = g_TaskQueue.back();
        std::cout << "Watek nr" << task.taskType << std::endl;
        g_TaskQueue.pop_back();
        LeaveCriticalSection( & g_Section ); // ...i jej koniec        
        task.Process();
    } // czekaj aż wątek przerobi wszystkie elementy z listy
    _endthread();
}

int main() {
    InitializeCriticalSection( & g_Section );
    // utwórz strukture z zainicjowanymi danymi poczatkowymi
    STask task { 0, 0, 0, "Some text" };
    // umieść na  liście 10 takich struktur
    for( int i = 0; i < 10; ++i ) {
        task.taskType = i; // numeruj elementy
        g_TaskQueue.push_back( task );
    }
    // utwórz nowy watek
    HANDLE hThread =( HANDLE ) _beginthread( ThreadProc, 0, NULL );
    WaitForSingleObject( hThread, INFINITE );
    std::cout << "Watek zakonczyl dzialanie." << std::endl;
    DeleteCriticalSection;
}

/*
// drugi przykład (wyścig wątków)
#include <process.h> // wymagane ze względu na _beginthread
#include <Windows.h>
#include <iostream>
#include <list>

struct STask {
    int taskType;
    int userID;
    unsigned int taskTime;
    std::string taskMsg;
    void Process(void) {
        std::cout << "Struktura nr " <<taskType << std::endl;
        Sleep(500); // z braku lepszego zajęcia... ;-)
    }
};

std::list < STask > g_TaskQueue;

void __cdecl ThreadProc(void* Args) {
    while (!g_TaskQueue.empty()) {
        STask task = g_TaskQueue.back();
        std::cout << "Watek nr" << task.taskType << std::endl;
        g_TaskQueue.pop_back();
        task.Process();
    }
    _endthread();
}

int main() {
    // utwórz strukture z zainicjowanymi danymi poczatkowymi
    STask task{0, 0, 0, "Some text"};
    // umieść na  liście 10 takich struktur
    for (int i = 0; i < 10; ++i) {
        task.taskType = i;// numeruj elementy
        g_TaskQueue.push_back(task);
    }
    // utwórz nowy watek
    HANDLE hThread = (HANDLE)_beginthread(ThreadProc, 0, NULL);
    // jeżeli lista nie jest pusta to:
    while (!g_TaskQueue.empty()) {
        // wrzuć ostatni element z listy do struktury
        STask task = g_TaskQueue.back();
        std::cout << "Element nr " << task.taskType << std::endl;
        // skasuj ostatni element z listy
        g_TaskQueue.pop_back();
        // uruchom funkcje Process() z wrzuconego elementu listy
        task.Process();
    } // pętla się kręci aż w liście zabraknie elementów
    // czekaj aż wątek przerobi wszystkie elementy z listy
    WaitForSingleObject(hThread, INFINITE);
    std::cout << "Watek zakonczyl dzialanie." << std::endl;
}
*/

/*
// pierwszy przykład
#include <process.h> // wymagane ze względu na _beginthread
#include <Windows.h>
#include <iostream>

unsigned int g_Counter = 0;

void __cdecl ThreadProc(void* Args) {
    while (g_Counter < 1000) {
        g_Counter++;
    }
    _endthread();
}

int main() {        
        HANDLE hEvent = CreateEvent(
            NULL,   // wskaźnik do struktury opisującej atrybuty bezpieczeństwa
            TRUE,   // czy zdarzenie powinno automatycznie przechodzić w stan niezasygnalizowany po tym, jak czekający wątek zostanie odblokowany, TRUE to ręcznie przestawienie stanu
            FALSE,  // początkowy stan obiektu, FALSE to stan niezasygnalizowany
            NULL);  // nazwa zdarzenia

        HANDLE hThread = (HANDLE)_beginthread(ThreadProc, 0, NULL);
        WaitForSingleObject(hThread, INFINITE);
        char buffer[1024];
        sprintf_s(buffer, "g_Counter: %d\n", g_Counter);
        std::cout << buffer << std::endl;    
}
*/

//-----------------------------------------------
//
// Program napisany w Microsoft Visual C++ 2019
// Aplikacja napisana w C++ z uzyciem WinApi
//
//-----------------------------------------------

#include <windows.h>
#include <commctrl.h>
#include <string>
#include <thread>
#include <process.h>  // wymagane ze względu na _beginthread
#include <vector>

#pragma comment(lib,"comctl32.lib")
// użycie stylu z XP do grafiki do ListView
#pragma comment(linker,"\"/manifestdependency:type='win32' name='Microsoft.Windows.Common-Controls' version = '6.0.0.0' processorArchitecture = '*' publicKeyToken = '6595b64144ccf1df' language = '*'\"")

// deklaracje globalnych uchwytow i zmiennych
MSG msg;
HWND hWnd;
HINSTANCE hInst;
static HWND hwndListView;
#define ID_LISTVIEW                     1000
LVITEM col;
LPCWSTR ApplicationTitle = L"Aplikacja";
std::wstring fileName = L"C:\1\Testy.txt"; // testowy plik

struct Task {
    int ElementNr = 0; // numer elementu
    std::wstring path; // pełna sciezka w formacie wstring
    std::wstring Produkt; // nazwa produktu
    int iProgress = 0; // postep
};
static std::vector < Task > StructureInVector; // w wektorze beda przechowywane struktury z zadaniami


// klasa przetwarzająca plik tekstowy
class ProcesModul {
public:
    std::wstring pathToFile;
   
    ProcesModul( std::wstring _pathToFile ) {
        this->pathToFile = _pathToFile;
    }
    ~ProcesModul() { }
   
    void start() {
        // tutaj uruchamiane jest przetwarzanie długiego pliku
        // dla uproszczenia w tym miejscu jest tylko okienko informacyjne
        MessageBox( NULL, L"Koniec przetwarzania", L"Info", MB_ICONINFORMATION | MB_OK );
    }
};

void startproces( std::wstring _plik ) {
    // tworze pomocniczy obiekt do zbierania danych
    ProcesModul process( _plik );
    auto thr1 = std::thread( & ProcesModul::start, & process );
    thr1.join();
}

//---------------------------------------------------------
//
// Przykład z MSDN z plikiem wpisanym na stałe
//  rozmiar przykładowego pliku 94MB
//
//---------------------------------------------------------
BOOL ParseALargeFile( HWND hWnd )
{
    RECT rcClient; // Client area of parent window.
    int cyVScroll; // Height of scroll bar arrow.
    HWND hwndPB; // Handle of progress bar.
    HANDLE hFile; // Handle of file.
    DWORD cb; // Size of file and count of bytes read.
    DWORD filesize;
    LPCH pch; // Address of data read from file.
    LPCH pchTmp; // Temporary pointer.
    // Ensure that the common control DLL is loaded, and create a progress bar
    // along the bottom of the client area of the parent window.
    // Base the height of the progress bar on the height of a scroll bar arrow.
    GetClientRect( hWnd, & rcClient );
    // dodaje pasek progressbaru na oknie
    hwndPB = CreateWindowEx( 0, PROGRESS_CLASS,( LPTSTR ) NULL,
    WS_CHILD | WS_VISIBLE, rcClient.left,
    300, // położenie progressbaru w Y
    rcClient.right,
    30, // szerokość paska progressbaru
    hWnd,( HMENU ) 0, hInst, NULL );
    // Open the file for reading, and retrieve the size of the file.
    // ścieżka do pliku ustawiona na sztywno
    hFile = CreateFile( L"C:\\1\\Testy2.txt", GENERIC_READ, FILE_SHARE_READ,
    ( LPSECURITY_ATTRIBUTES ) NULL, OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL,( HANDLE ) NULL );
    if( hFile ==( HANDLE ) INVALID_HANDLE_VALUE )
         return FALSE;
   
    cb = GetFileSize( hFile,( LPDWORD ) NULL ); // rozmiar pliku w bajtach
    filesize = cb;
    // Set the range and increment of the progress bar.
    SendMessage( hwndPB, PBM_SETRANGE, 0, MAKELPARAM( 0, cb / 2048 ) ); // Sets the minimum and maximum values for a progress bar and redraws the bar to reflect the new range
    SendMessage( hwndPB, PBM_SETSTEP,( WPARAM ) 1, 0 ); // Specifies the step increment for a progress bar
    // Parse the file.
    pch =( LPCH ) LocalAlloc( LPTR, sizeof( char ) * 2048 );
    pchTmp = pch;
    int tsize;
    int bsize;
    do {
        ReadFile( hFile, pchTmp, sizeof( char ) * 2048, & cb,( LPOVERLAPPED ) NULL );
       
        // szacowanie procentowego postępu i umieszczenie go w strukturze
        // na razie nie testowane, do sprawdzenia
        tsize = strlen( pchTmp );
        bsize =( 100 + tsize ) / filesize;
        StructureInVector.at( 0 ).iProgress = bsize;
       
        SendMessage( hwndPB, PBM_STEPIT, 0, 0 );
    } while( cb );
   
    CloseHandle(( HANDLE ) hFile );
    DestroyWindow( hwndPB );
    return TRUE;
}

//---------------------------------------------------------
//
// Wyciaga rozszerzenie ze sciezki
//
//---------------------------------------------------------
std::wstring GetExtension( const std::wstring & fileName ) {
    auto pos = fileName.rfind( L"." );
    if( pos == std::wstring::npos )
         pos = - 1;
   
    return std::wstring( fileName.begin() + pos + 1, fileName.end() );
}

void AddNewItemOnListView( int i ) {
    TCHAR pszBuffer[ 16 ]; // bufor na cyferke na progresbarze
    // sprawdzam czy w wektorze ze strukturami cos jest
    if( !StructureInVector.empty() ) { // sprawdzam czy w wektorze ze strukturami cos jest
        // pierwsza kolumna (oznaczona jako 0)
        col.mask = LVIF_PARAM | LVIF_TEXT;
        col.iItem = i;
        col.iSubItem = 0;
        // tu robię wskaźnik na fileName
        col.pszText = LPTSTR(( LPCTSTR )( StructureInVector.at( i ).path ).c_str() );
        col.lParam = StructureInVector.at( i ).iProgress; // tutaj ustawia sie dlugosc progresbaru wizualnie
        SendMessageW( hwndListView, LVM_INSERTITEM, 0,( LPARAM ) & col );
       
        // druga kolumna (oznaczona jako 1)
        col.mask = LVIF_TEXT;
        col.iSubItem = 1;
        col.pszText = LPTSTR(( LPCTSTR )( StructureInVector.at( i ).Produkt ).c_str() );
        SendMessageW( hwndListView, LVM_SETITEM, 0,( LPARAM ) & col );
       
        // pierwsza kolumna (oznaczona jako 2)
        // pasek progresbaru, ale tutaj wpisuje sie tylko jego procentowa wartosc jako cyfre
        col.iSubItem = 2;
        col.pszText = pszBuffer;
        swprintf_s( pszBuffer, L"%d %%", StructureInVector.at( i ).iProgress );
        SendMessageW( hwndListView, LVM_SETITEM, 0,( LPARAM ) & col );
    }
}

static LRESULT HandleCustomDraw( NMLVCUSTOMDRAW * pcd ) {
    TCHAR buffer[ 40 ];
    switch( pcd->nmcd.dwDrawStage ) {
    case CDDS_PREPAINT:
        /* Tell the control we are interested in per-item notifications.
   * (We need it just to tell the control we want per-subitem
   * notifications.) */
        return CDRF_DODEFAULT | CDRF_NOTIFYITEMDRAW;
       
        case( CDDS_ITEM | CDDS_PREPAINT )
            : /* Tell the control we are interested in per-subitem notifications. */ return CDRF_DODEFAULT | CDRF_NOTIFYSUBITEMDRAW;
       
        case( CDDS_ITEM | CDDS_SUBITEM | CDDS_PREPAINT )
            : switch( pcd->iSubItem )
        {
        case 1:
            // obsluga drugiej kolumny danych
            /* Customize "priority" column by marking some priority levels
    * with appropriate color. */
            col.iSubItem = pcd->iSubItem;
            col.pszText = buffer;
            col.cchTextMax = sizeof( buffer ) / sizeof( buffer[ 0 ] );
            SendMessage( hwndListView, LVM_GETITEMTEXT, pcd->nmcd.dwItemSpec,( LPARAM ) & col ); // LVM_GETITEMTEXT Retrieves the text of a list-view item or subitem.
            /* Let the control do the painting itself with the new color. */
            return CDRF_DODEFAULT;
           
        case 2:
            // Customize "progress" column. We paint simple progress indicator.
            int iProgress = pcd->nmcd.lItemlParam;
            int cx;
            HDC hdc = pcd->nmcd.hdc;
            COLORREF clrBack;
            HBRUSH hBackBrush;
            HBRUSH hProgressBrush;
            HBRUSH hOldBrush;
            HPEN hPen;
            HPEN hOldPen;
            RECT rc;
           
            clrBack = pcd->clrTextBk;
            if( clrBack == CLR_NONE || clrBack == CLR_DEFAULT )
                 clrBack = RGB( 255, 255, 255 ); // tło pod progresbarami
           
            hBackBrush = CreateSolidBrush( clrBack );
            hProgressBrush = CreateSolidBrush( RGB( 190, 190, 255 ) ); // kolory pasków
            hPen = CreatePen( PS_SOLID, 0, RGB( 190, 190, 255 ) ); // obwódka progresbaru
           
            hOldBrush =( HBRUSH ) SelectObject( hdc, hBackBrush );
            FillRect( hdc, & pcd->nmcd.rc, hBackBrush );
           
            cx = pcd->nmcd.rc.right - pcd->nmcd.rc.left - 6;
            if( cx < 0 )
                 cx = 0;
           
            rc.left = pcd->nmcd.rc.left + 3; // ustawinie lewego brzegu progressbaru
            rc.top = pcd->nmcd.rc.top + 2;
            rc.right = rc.left + cx * iProgress / 100;
            rc.bottom = pcd->nmcd.rc.bottom - 2;
            SelectObject( hdc, hProgressBrush );
            FillRect( hdc, & rc, hProgressBrush ); // wypełnienie progressbaru kolorem
           
            rc.right = pcd->nmcd.rc.right - 3;
            SelectObject( hdc, GetStockObject( HOLLOW_BRUSH ) );
            hOldPen =( HPEN ) SelectObject( hdc, hPen );
            Rectangle( hdc, rc.left, rc.top, rc.right, rc.bottom ); // rysuje obwódkę na około progressbaru
           
            col.iSubItem = pcd->iSubItem;
            col.pszText = buffer;
            col.cchTextMax = sizeof( buffer ) / sizeof( buffer[ 0 ] );
            SendMessage( hwndListView, LVM_GETITEMTEXT, pcd->nmcd.dwItemSpec,( LPARAM ) & col ); // wrzucenie tekstu
            DrawText( hdc, buffer, - 1, & rc, DT_CENTER | DT_VCENTER | DT_NOPREFIX | DT_SINGLELINE | DT_END_ELLIPSIS );
           
            SelectObject( hdc, hOldBrush );
            DeleteObject( hProgressBrush );
            DeleteObject( hBackBrush );
            SelectObject( hdc, hOldPen );
            DeleteObject( hPen );
           
            // Tell the control to not paint as we did so.
            return CDRF_SKIPDEFAULT; // brak tego nie narysuje nic
        }
        break;
    }
    // For all unhandled cases, we let the control do the default.
    return CDRF_DODEFAULT;
}

//---------------------------------------------------------
//
// Funkcja robi opisy na belce nad ListView
//
//---------------------------------------------------------
static void CreateListViewLabels() {
    LVCOLUMN col;
    // tutaj są etykietki na belce nad wrzuconymi stringami
    col.mask = LVCF_WIDTH | LVCF_TEXT;
    // piersza pozycja na pasku
    col.pszText =( LPWSTR ) L"Przetwarzany plik";
    col.cx = 265;
    SendMessageW( hwndListView, LVM_INSERTCOLUMN, 0,( LPARAM ) & col );
    // druga pozycja na pasku
    col.pszText =( LPWSTR ) L"Produkt";
    col.cx = 60;
    SendMessageW( hwndListView, LVM_INSERTCOLUMN, 1,( LPARAM ) & col );
    // trzecia pozycja na pasku
    col.pszText =( LPWSTR ) L"Postęp";
    col.cx = 80;
    SendMessageW( hwndListView, LVM_INSERTCOLUMN, 2,( LPARAM ) & col );
}

void AddControls( HWND hWnd ) {
    hwndListView = CreateWindowEx( 0, WC_LISTVIEW, NULL, LVS_REPORT | WS_TABSTOP | WS_BORDER | WS_CHILD | WS_VISIBLE,
    10, 10, 600, 250, hWnd,( HMENU ) ID_LISTVIEW, hInst, 0 );
}

//---------------------------------------------------------
//
// Procedura obsługująca wiadomości dla okna, wywoływana przez
// MS-Windows przy okazji różnych zdarzeń, które należy obsłużyć
//
//--------------------------------------------------------------
static LRESULT CALLBACK WndProc( HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam )
{
    switch( msg )
    {
    case WM_CREATE:
        AddControls( hWnd );
        CreateListViewLabels();
        break;
       
    case WM_NOTIFY:
        {
            NMHDR * pHdr =( NMHDR * ) lParam;
            if( pHdr->idFrom == ID_LISTVIEW && pHdr->code == NM_CUSTOMDRAW )
                 return HandleCustomDraw(( NMLVCUSTOMDRAW * ) pHdr );
           
            break;
        }
       
        // reakcja na zamkniecie okienka
    case WM_CLOSE:
        PostQuitMessage( 0 );
        return 0;
       
        // komunikat od systemu wyslany po zamknieciu okienka
    case WM_DESTROY:
        PostQuitMessage( 0 );
        return 0;
       
        default:
        return DefWindowProc( hWnd, msg, wParam, lParam );
        break;
    }
    return DefWindowProc( hWnd, msg, wParam, lParam );
}

void InitMainWnd() {
    HINSTANCE hInstance = GetModuleHandle( 0 );
    WNDCLASSEX wClass = { 0 };
    ZeroMemory( & wClass, sizeof( WNDCLASSEX ) );
    wClass.style = CS_HREDRAW | CS_VREDRAW;
    wClass.cbClsExtra = 0;
    wClass.cbWndExtra = 0;
    wClass.cbSize = sizeof( WNDCLASSEX );
    wClass.hbrBackground =( HBRUSH )( COLOR_BTNFACE + 1 );
    wClass.hInstance = hInstance;
    wClass.lpfnWndProc =( WNDPROC ) WndProc;
    wClass.lpszClassName = L"My Window Class";
    wClass.hCursor = LoadCursor( 0, IDC_ARROW );
    wClass.hIcon = LoadIcon( NULL, IDI_APPLICATION );
    wClass.hIconSm = LoadCursor( NULL, IDC_ARROW );
    wClass.lpszMenuName = 0;
    // Rejestrujemy klasę okna w Windows.
    if( !RegisterClassEx( & wClass ) ) {
        int nResult = GetLastError();
        MessageBox( NULL, L"Nie utworzono żadnej klasy!", L"Błąd", MB_ICONERROR );
    }
}

//---------------------------------------------------------
//
// Funkcja tworząca główne okno
//
//---------------------------------------------------------
HWND CreateMainWnd() {
    return
    CreateWindowEx(
    WS_EX_CLIENTEDGE,
    L"My Window Class",
    ApplicationTitle,
    WS_OVERLAPPED | WS_CAPTION | WS_BORDER | WS_MINIMIZEBOX | WS_SYSMENU,
    0,
    0,
    650,
    400,
    NULL,
    NULL,
    hInst,
    NULL );
}

//---------------------------------------------------------
//
// Do obsługi LisView
//
//---------------------------------------------------------
void CreateCommonControls() {
    // inicjacja klasy pasków chyba sa niepotrzebne narazie
    INITCOMMONCONTROLSEX cc;
    cc.dwSize = sizeof( INITCOMMONCONTROLSEX );
    cc.dwICC = ICC_PROGRESS_CLASS;
    cc.dwICC = ICC_BAR_CLASSES; // toolbary, statusbary, tooltipy i oczywiście progressbary
    InitCommonControlsEx( & cc );
}

//---------------------------------------------------------
//
// Główna funkcja w Windows , od której uruchamiany jest program
// kodowanie zależne od ustawień projektu
//
//---------------------------------------------------------
int WINAPI WinMain( HINSTANCE hInst, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int showCmd )
{
    InitMainWnd(); // startuje głowne okno
    hWnd = CreateMainWnd(); // create the main window!
    if( !hWnd ) {
        int nResult = GetLastError();
        MessageBox( NULL, L"Nie utworzono żadnego okna!", L"Błąd", MB_ICONERROR );
    }
    // wstawiam pierwszy element do listView
    CreateCommonControls();
    Task t { 0, fileName, L"Produkt2", 8 }; // testowe ustawienie 8% na progressbarze i opisy
    StructureInVector.push_back( t ); // dodaje strukture do vectora
    AddNewItemOnListView( 0 );
    ShowWindow( hWnd, showCmd ); // Utworzone okno wyświetlamy na ekranie  
    UpdateWindow( hWnd ); // Uaktualniamy treść okna
    ParseALargeFile( hWnd );
    ZeroMemory( & msg, sizeof( MSG ) );
    while( msg.message != WM_QUIT ) { // Rozpoczynamy pętlę obsługi wiadomości napływających do naszego okna.
        if( PeekMessage( & msg, 0, 0, 0, PM_REMOVE ) ) {
            TranslateMessage( & msg ); // Przekształcamy wiadomość
            DispatchMessage( & msg ); // Wysyłamy ją do procedury okna
        }
    }
    return 0;
}

//---------------------------------------------------------
//
// Przykład z MSDN z plikiem wpisanym na stałe
//  rozmiar przykładowego pliku 94MB
//
//---------------------------------------------------------
BOOL ParseALargeFile( HWND hWnd )
{
    RECT rcClient; // Client area of parent window.
    HWND hwndPB; // Handle of progress bar.
    HANDLE hFile; // Handle of file.
    DWORD cb; // Size of file and count of bytes read.
    LPCH pch; // Address of data read from file.
    LPCH pchTmp; // Temporary pointer.
    unsigned int wczytanychbajtow = 0; //
    unsigned int filesize;
    unsigned int progress; // do przechowywania postępu jako liczby całkowitej
    // Ensure that the common control DLL is loaded
    GetClientRect( hWnd, & rcClient );
    // dodaje pasek progressbaru na oknie
    hwndPB = CreateWindowEx( 0, PROGRESS_CLASS,( LPTSTR ) NULL,
    WS_CHILD | WS_VISIBLE, rcClient.left,
    300, // położenie progressbaru w Y
    rcClient.right,
    30, // szerokość paska progressbaru
    hWnd,( HMENU ) 0, hInst, NULL );
    // Open the file for reading, and retrieve the size of the file.
    // ścieżka do pliku ustawiona na sztywno 95MB
    hFile = CreateFile( L"C:\\1\\Testy4.txt", GENERIC_READ, FILE_SHARE_READ,
    ( LPSECURITY_ATTRIBUTES ) NULL, OPEN_EXISTING,
    FILE_ATTRIBUTE_NORMAL,( HANDLE ) NULL );
    if( hFile ==( HANDLE ) INVALID_HANDLE_VALUE )
         return FALSE;
   
    cb = GetFileSize( hFile,( LPDWORD ) NULL ); // rozmiar pliku w bajtach
    filesize = cb; // zapamiętuje rozmiar pliku
    SendMessage( hwndPB, PBM_SETRANGE, 0,( LPARAM ) MAKELONG( 0, 100 ) ); // ustaw zakres pracy progressbaru na 0-100%
    // Parse the file.
    pch =( LPCH ) LocalAlloc( LPTR, sizeof( char ) * 2048 );
    pchTmp = pch;
    do {
        ReadFile( hFile, pchTmp, sizeof( char ) * 2048, & cb,( LPOVERLAPPED ) NULL );
        wczytanychbajtow += cb; // zapamiętaj wczytaną liczbę bajtów
        progress = std::ceil((( double ) wczytanychbajtow /( double ) filesize ) * 100 ); // ceil żeby nie było ewentualnych małych skoków paska do tyłu
        //progress = (unsigned int)(((double)wczytanychbajtow / (double)filesize) * 100);//przelicz na wartość procentową
        StructureInVector.at( 0 ).iProgress = progress; // wpisz w strukturę
        SendMessage( hwndPB, PBM_SETPOS,( WPARAM ) progress, 0 ); // pokaz na progressbarze
    } while( cb );
   
    CloseHandle(( HANDLE ) hFile ); // zamknij plik
    DestroyWindow( hwndPB ); // usuń progressbar
    return TRUE;
}