Facebook

qwertyui safest cryptocurrency exchange

From arti, 9 Years ago, written in Plain Text.
URL https://pastebin.pl/view/06cf8711
Embed
Download Paste or View Raw
Hits: 575
  1. #include <windows.h>  //biblioteka do okienka
  2. #include <windowsx.h> //tu tez
  3. #include <string>
  4. #ifdef __cplusplus
  5.     #include <cstdlib>
  6. #else
  7.     #include <stdlib.h>
  8.  
  9. #endif
  10. #include <fstream>
  11. #include <SDL.h>
  12. #include <math.h>
  13. #include <iostream>
  14. #include <vector>
  15. /**DEFINICJE STALYCH I ID**/
  16. #define ID_Color 111        //id
  17. #define ID_Convert 555      //id Przycisku konwertuj potrzebny do identyfikcaji wiadomosci z przycisku "konwertuj"
  18. /**************************/
  19.  
  20. using namespace std;
  21.  
  22. SDL_Surface *screen; //struktura okna dla SDL
  23. char const* tytul = "Okno obrazka";
  24. int TrybKoloru; //zmienna ta przekazywana do funkcji ConvertColor określa wybraną opcje trybu koloru
  25. int w=0, h=0; //wielkosc pliku graficznego
  26. vector <Uint8> ByteRun;
  27. vector <Uint8> RLEOut;
  28.  
  29. LPSTR Bufor,NowaNazwaPliku; //stringi przechowujące sciezke do pliku
  30. DWORD dlugosc;
  31.  
  32. HWND hWnd;      //uchwyt okna glownego
  33. HWND hCombo;  //uchwyt comboboxa
  34. HWND hText,hText1; //uchwyty pól tekstowych
  35.  
  36. struct Header{
  37. char Name [5]="ggkk";
  38. unsigned char TrybKonwersji;
  39. signed char TrybKoloru;
  40. int width;
  41. int heigth;
  42. };
  43. Header GGKKHeader;
  44.  
  45. struct Color{
  46. Uint8 r;
  47. Uint8 g;
  48. Uint8 b;
  49. };
  50.  
  51. int frame(); //funkcja tworząca okno SDL
  52. void ConvertColor(Color bufor, int Tryb); //funkcja konwersji kolorów
  53. void newfile(); //tworzenie nwego pliku
  54. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B); //setpixel...
  55. void byterun(Color a[], int length,vector <Uint8> ByteRun); //funkcja odpowiadajaca za kompresję
  56. void RLE(Color a[],int length,vector <Uint8> RLEOut);
  57. void ladujBMP(char const* nazwa, int x, int y); //ładuj BMP...
  58. Color getPixel (int x, int y);  //pobierz pixel z ekranu...
  59. Color RGBtoHSV(Color bufor);
  60. Color RGBtoHSL(Color bufor);
  61. Color RGBtoYUV(Color bufor);
  62.  
  63.  
  64.  
  65.  
  66.  
  67. void RLE(Color dane[],int length,vector <Uint8> RLEOut)
  68. {
  69. int i=0;
  70. int j=1,coun=1;
  71.     while(i < length)
  72.     {
  73.         j=1;
  74.         while ((i+j-1 < length-1) && (dane[i+j-1].r == dane[i+j].r) && (dane[i+j-1].g == dane[i+j].g) && (dane[i+j-1].b == dane[i+j].b) && (j < 255))  {j++;}
  75.         if(j>=2)
  76.         {
  77.         RLEOut.push_back(Uint8(j));
  78.         RLEOut.push_back(dane[i+j].r);
  79.         RLEOut.push_back(dane[i+j].g);
  80.         RLEOut.push_back(dane[i+j].b);
  81.  
  82.         //cout<<int(j)<<"<J ";
  83.         //cout<<int(dane[i+j-1].r)<<" ";
  84.         //cout<<int(dane[i+j-1].g)<<" ";
  85.         //cout<<int(dane[i+j-1].b)<<";";
  86.         i += (j);
  87.         }
  88.         else
  89.         {
  90.             while((j==1) && (i+j < length-1) && (i+coun< length-1))
  91.             {
  92.                 if((dane[i+coun-1].r == dane[i+coun].r) && (dane[i+coun-1].g == dane[i+coun].g) && (dane[i+coun-1].b == dane[i+coun].b)) j++;
  93.                 else{coun++;}
  94.             }
  95.             RLEOut.push_back(0);
  96.             RLEOut.push_back(Uint8(coun-1));
  97.             //cout<<">"<<coun-1<<"< ";
  98.             for(int k=0;k<coun-1;k++)
  99.             {
  100.             RLEOut.push_back(dane[i+k].r);
  101.             //cout<<int(dane[i+k].r)<<" ";
  102.             RLEOut.push_back(dane[i+k].g);
  103.             //cout<<int(dane[i+k].g)<<" ";
  104.             RLEOut.push_back(dane[i+k].b);
  105.             //cout<<int(dane[i+k].b)<<" ;";
  106.             }
  107.             i+=(coun-1);
  108.         }
  109.  
  110.     }
  111.     cout<<"    "<<RLEOut.size()<<"<size  ";
  112. cout<<"RLE";
  113. }
  114.  
  115. void byterun(Color dane[], int length,vector <Uint8> ByteRun)
  116. {
  117. int i = 0;
  118.     while (i < length)
  119.     {
  120.         if ((i < length-1) && (dane[i].r == dane[i+1].r) && (dane[i].g == dane[i+1].g) && (dane[i].b == dane[i+1].b))
  121.         {
  122.             int j = 0;
  123.             while ((i+j < length-1) && (dane[i+j].r == dane[i+j+1].r) && (dane[i+j].g == dane[i+j+1].g) && (dane[i+j].b == dane[i+j+1].b) && (j < 127))  j++;
  124.             ByteRun.push_back(Uint8(128-j));
  125.            // cout<<-j<<" ";
  126.             ByteRun.push_back(dane[i+j].r);
  127.            // cout<<int(dane[i+j].r)<<" ";
  128.             ByteRun.push_back(dane[i+j].g);
  129.            // cout<<int(dane[i+j].g)<<" ";
  130.             ByteRun.push_back(dane[i+j].b);
  131.             //cout<<int(dane[i+j].b)<<" ";//<< Uint8(127-j) << dane[i+j].r<<dane[i+j].g <<dane[i+j].b ; //zapis skompresowanych danych do pliku
  132.             i += (j+1);
  133.         }
  134.         else
  135.         {
  136.             int j=0;
  137.             while ((i+j < length-1) && ((dane[i+j].r != dane[j+i+1].r) || (dane[i+j].g != dane[j+i+1].g) || (dane[i+j].b != dane[j+i+1].b)) && (j <128)) j++;
  138.             if ((i+j == length-1) && (j < 128)) j++;
  139.             ByteRun.push_back(Uint8(178+j));
  140.             //cout<<j-1<<"  ";//plik1<< Uint8(128+j-1); //zapis do pliku danych których nie da się skompresować
  141.             for (int k=0; k<j; k++) {
  142.                 ByteRun.push_back(dane[i+k].r);
  143.                 //cout<<int(dane[i+k].r)<<" ";
  144.                 ByteRun.push_back(dane[i+k].g);
  145.                 //cout<<int(dane[i+k].g)<<" ";
  146.                 ByteRun.push_back(dane[i+k].b);
  147.                 //cout<<int(dane[i+k].b)<<" ";
  148.             }// plik1 << dane[i+k].r << dane[i+k].g<<dane[i+k].b;
  149.             i += j;
  150.         }
  151.     }
  152.     cout<<"Byterun"<<ByteRun.size();
  153. }
  154.  
  155. Color RGBtoYUV(Color bufor)
  156. {
  157.     double Y,U,V;
  158.         Y=0.299*double(bufor.r)+0.587*double(bufor.g)+0.114*double(bufor.b);
  159.         U=0.492*(double(bufor.b)-Y);
  160.         V=0.877*(double(bufor.r)-Y);
  161.  
  162.         bufor.r=Uint8(round(Y));  //używam tej samej struktury która przechowywała wcześniej składowe kolorów RGB...
  163.         bufor.g=Uint8(round(U));  //
  164.         bufor.b=Uint8(round(V));  //
  165.     return bufor;
  166. }
  167.  
  168. Color RGBtoHSL(Color bufor)
  169. {
  170.     double cmax,cmin,delta,H,S,L,r1,g1,b1;
  171.  
  172.         r1=double(double(bufor.r)/255.);
  173.         g1=double(double(bufor.g)/255.);
  174.         b1=double(double(bufor.b)/255.);
  175.         cmax=max(max(r1,g1),b1);
  176.         cmin=min(min(r1,g1),b1);
  177.         delta=double(cmax-cmin);
  178.  
  179.         if( r1 == cmax )
  180.                 H=double(double(g1-b1)/delta);
  181.         else if(g1==cmax) H=double(double(b1-r1)/delta)+2.;
  182.         else H =double(double(r1-g1)/delta)+4.;
  183.         H=H*60.;
  184.         if(H<0)H=H+360;
  185.         H=round(double(H*0.7111)); //H
  186.  
  187.         L=double(double((cmax)+double(cmin))/2.); //L
  188.         if(cmax-cmin==0.) S=0;
  189.         else S=double(delta/(1.-fabs(2.*L-1.))); //S
  190.  
  191.         bufor.r=Uint8(H);  //używam tej samej struktury która przechowywała wcześniej składowe kolorów RGB...
  192.         bufor.g=Uint8(round(S*100));  //
  193.         bufor.b=Uint8(round(L*100));  //
  194.     return bufor;
  195. }
  196.  
  197. Color RGBtoHSV(Color bufor)
  198. {
  199.     double cmax,cmin,delta,S,H,V,r1,g1,b1;
  200.         r1=double(double(bufor.r)/255.);
  201.         g1=double(double(bufor.g)/255.);
  202.         b1=double(double(bufor.b)/255.);
  203.  
  204.         cmax=max(max(r1,g1),b1);
  205.         cmin=min(min(r1,g1),b1);
  206.         delta=double(cmax-cmin);
  207.         if( r1 == cmax )
  208.                 H=double(double(g1-b1)/delta);
  209.         else if(g1==cmax) H=double(double(b1-r1)/delta)+2.;
  210.         else H =double(double(r1-g1)/delta)+4.;
  211.         H=H*60.;
  212.         if(H<0)H=H+360.;
  213.         H=double(H*0.7111); //H
  214.         if(cmax==0) S=0;
  215.         else S=double(delta/cmax)*100.; //S
  216.         V=cmax*100.; //V
  217.         bufor.r=Uint8(H);  //używam tej samej struktury która przechowywała wcześniej składowe kolorów RGB...
  218.         bufor.g=Uint8(S);  //
  219.         bufor.b=Uint8(V);  //
  220.     return bufor;
  221. }
  222.  
  223. void ConvertColor(Color bufor,int Tryb) //zmienna tryb przekazywana jest z Combo Boxa i przyjmuje wartości 0-3
  224. {
  225.     switch (Tryb)
  226.     {
  227.  
  228.     case 0:  //konwersja na HSV
  229.         RGBtoHSV(bufor);
  230.         GGKKHeader.TrybKoloru=0;
  231.         break;
  232.     case 1:  //konwersja na HSL
  233.         RGBtoHSL(bufor);
  234.         GGKKHeader.TrybKoloru=1;
  235.         break;
  236.     case 2: //konwersja na YUV
  237.         RGBtoYUV(bufor);
  238.         GGKKHeader.TrybKoloru=2;
  239.         break;
  240.     default:  GGKKHeader.TrybKoloru=-1;
  241.     }
  242. }
  243.  
  244.  
  245.  
  246. void setPixel(int x, int y, Uint8 R, Uint8 G, Uint8 B)
  247. {
  248.   if ((x>=0) && (x<w) && (y>=0) && (y<h))
  249.   {
  250.     /* Zamieniamy poszczególne skladowe koloru na format koloru pixela */
  251.     Uint32 pixel = SDL_MapRGB(screen->format, R, G, B);
  252.     /* Pobieramy informacji ile bajtów zajmuje jeden pixel */
  253.     int bpp = screen->format->BytesPerPixel;
  254.     /* Obliczamy adres pixela */
  255.     Uint8 *p = (Uint8 *)screen->pixels + y * screen->pitch + x * bpp;
  256.     /* Ustawiamy wartosc pixela, w zaleznci od formatu powierzchni*/
  257.     switch(bpp)
  258.     {
  259.         case 1: //8-bit
  260.             *p = pixel;
  261.             break;
  262.  
  263.         case 2: //16-bit
  264.             *(Uint16 *)p = pixel;
  265.             break;
  266.  
  267.         case 3: //24-bit
  268.             if(SDL_BYTEORDER == SDL_BIG_ENDIAN) {
  269.                 p[0] = (pixel >> 16) & 0xff;
  270.                 p[1] = (pixel >> 8) & 0xff;
  271.                 p[2] = pixel & 0xff;
  272.             } else {
  273.                 p[0] = pixel & 0xff;
  274.                 p[1] = (pixel >> 8) & 0xff;
  275.                 p[2] = (pixel >> 16) & 0xff;
  276.             }
  277.             break;
  278.  
  279.         case 4: //32-bit
  280.             *(Uint32 *)p = pixel;
  281.             break;
  282.     }
  283.   }
  284. }
  285.  
  286. void newfile(int w, int h)
  287. {
  288. /*****************************TWORZENIE PLIKU**************************************/
  289.     ifstream plik1;
  290.     plik1.open( NowaNazwaPliku, std::ios::in | std::ios::out );
  291. /***********************************TWORZYENIE TABLICY PRZECHOWUJACEJ SUROWE DANE********************************/
  292.  
  293.     Color *RawData;  //wskaznik do zmiennej reprezentujacej surowe dane odczytane z obrazka
  294.     Color  bufor;   //przechowuje pojedynczy pixel do obrobki
  295.     RawData=new Color  [w*h];
  296.     int p=0;
  297.     for(int x=0;x<w;x++)
  298.         for(int y=0;y<h;y++)
  299.         {
  300.             bufor=getPixel(x,y);
  301.             ConvertColor(bufor,TrybKoloru);
  302.             RawData[p++]=bufor;
  303.         }
  304. plik1.close();
  305. /*******************************KOMPRESJA DANYCH Z TABLICY ********************************/
  306. GGKKHeader.width=w;
  307. GGKKHeader.heigth=h;
  308.  
  309. byterun(RawData,w*h,ByteRun);
  310. RLE(RawData,w*h,RLEOut);
  311.     fstream plik;
  312.     plik.open( NowaNazwaPliku, std::ios::out |  std::ios::ate);
  313. if(ByteRun.size()<RLEOut.size()){
  314.         GGKKHeader.TrybKonwersji=1;
  315.         plik<<GGKKHeader.Name;
  316.         plik<<GGKKHeader.TrybKonwersji;
  317.         plik<<GGKKHeader.TrybKoloru;
  318.         plik<<GGKKHeader.width;
  319.         plik<<GGKKHeader.heigth;
  320.         plik<<"   ";
  321.         cout<<ByteRun.size()<<"<Byterun";
  322.         for(int i=0;i<ByteRun.size();i++)plik<<ByteRun[i];
  323. }
  324. else
  325. {
  326.         GGKKHeader.TrybKonwersji=0;
  327.         plik<<GGKKHeader.Name;
  328.         plik<<GGKKHeader.TrybKonwersji;
  329.         plik<<GGKKHeader.TrybKoloru;
  330.         plik<<GGKKHeader.width;
  331.         plik<<GGKKHeader.heigth;
  332.         plik<<"   ";
  333.         cout<<RLEOut.size()<<"<RLE";
  334.         cout<<ByteRun.size()<<"<Byterun";
  335.         for(int i=0;i<RLEOut.size();i++)plik<<RLEOut[i];
  336. }
  337. delete(RawData); //usuwam tablicę dynamiczna
  338. plik1.close();
  339. SDL_Flip(screen);
  340. }
  341.  
  342.  
  343. Color getPixel (int x, int y) {
  344.     Color color ;
  345.     Uint32 col = 0 ;
  346.     if ((x>=0) && (x<w) && (y>=0) && (y<h)) {
  347.         //determine position
  348.         char* pPosition=(char*)screen->pixels ;
  349.         //offset by y
  350.         pPosition+=(screen->pitch*y) ;
  351.         //offset by x
  352.         pPosition+=(screen->format->BytesPerPixel*x);
  353.         //copy pixel data
  354.         memcpy(&col, pPosition, screen->format->BytesPerPixel);
  355.         //convert color
  356.         SDL_GetRGB(col, screen->format, &color.r, &color.g, &color.b);
  357.     }
  358.     return ( color ) ;
  359. }
  360.  
  361. int frame() /*FUNKCJA INICJALIZUJACA W OKNIE OBRAZKA SDL*/
  362. {
  363.     if ( SDL_Init( SDL_INIT_VIDEO ) < 0 )
  364.     {
  365.         printf( "Unable to init SDL: %s\n", SDL_GetError() );
  366.         return 1;
  367.     }
  368.     /* LADUJ BMP */
  369.         SDL_Surface* bmp;
  370.         SDL_Rect dstrect; //do wczytywania bmp
  371.         bmp = SDL_LoadBMP(Bufor); //wczytywanie bmp z nazwy
  372.         dstrect.x = 0;
  373.         dstrect.y = 0;
  374.         w=bmp->w;  //ustalamy wielkosc wczytanego obrazka
  375.         h=bmp->h;
  376.     /*************/
  377.     // make sure SDL cleans up before exit
  378.     atexit(SDL_Quit);
  379.  
  380.     // create a new window
  381.     screen = SDL_SetVideoMode(w, h, 32,SDL_HWSURFACE|SDL_DOUBLEBUF);
  382.     SDL_BlitSurface(bmp, 0, screen, &dstrect); //wyswietl bmp
  383.     if ( !screen )
  384.     {
  385.         printf("Unable to set video: %s\n", SDL_GetError());
  386.         return 1;
  387.     }
  388.     SDL_Flip(screen);
  389.     SDL_FreeSurface(bmp); //usuwanie bmp
  390.     SDL_WM_SetCaption( tytul , NULL );
  391. }
  392.  
  393. // the WindowProc function prototype
  394. LRESULT CALLBACK WindowProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam);
  395.  
  396. HWND g_hPrzycisk;
  397. // the entry point for any Windows program  //tu mamy funkcje ktora jest odpowiedznikiem funkcji main,
  398. int WINAPI WinMain(HINSTANCE hInstance,         //1. HINSTANCE hInstance - uchwyt, który jest liczba za pomoca ktorej winows identyfikuje aplikacje i okna
  399.         HINSTANCE hPrevInstance,                                        //2. HINSTANCE hPrevInstance - to jakis przestarzaly parametr informujacy o poprzedniej kopii
  400.         LPSTR lpCmdLine,                                                        //3. LPSTR lpCmdLine - ten parametr sprawia ze gdy dopiszemy w cmd przy run "nazwaaplikacji.exe" np. "runA" to bedzie mozna odpalic kilka okien o specjalnych parametrach (nie bardzo wiem jakich)
  401.         int nCmdShow)                                                           //4. int nCmdShow - ten parametr odpowiada za to jak okno ma sie pojawic (zminimalizowane/zmaksymalizowane/w oknie      SW_SHOWNORMAL   SW_SHOW SW_HIDE SW_MAXIMIZE             SW_MINIMIZE     SW_RESTORE      SW_SHOWMAXIMIZED        SW_SHOWMINIMIZED        SW_SHOWMINNOACTIVE      SW_SHOWNA  SW_SHOWNOACTIVATE
  402. {
  403.         WNDCLASSEX wc;          //struktura majaca informacje o klasie okna
  404.  
  405.         ZeroMemory(&wc, sizeof(WNDCLASSEX)); //zerowanie prestrzeni pamieci dla struktury klasy okna (wc- window class)
  406.         //wypelnianie strukturki
  407.         wc.cbSize = sizeof(WNDCLASSEX);
  408.         wc.style = CS_HREDRAW | CS_VREDRAW;
  409.         wc.lpfnWndProc = WindowProc;
  410.         wc.hInstance = hInstance;
  411.         wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  412.         wc.lpszClassName = "WindowClass";
  413.         //rejestrowanie klasy
  414.         RegisterClassEx(&wc);
  415.  
  416.         RECT wr = { 0, 0, w, h };
  417.         AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, FALSE);
  418.         //tworzenie okna ************
  419.         hWnd = CreateWindowEx(NULL,
  420.                 "WindowClass",
  421.                 "Program1",
  422.                 WS_OVERLAPPEDWINDOW,
  423.                 300,
  424.                 300,
  425.                 500,
  426.                 300,
  427.                 NULL,
  428.                 NULL,
  429.                 hInstance,
  430.                 NULL);
  431.  
  432.         ShowWindow(hWnd, nCmdShow);     //pokaz okno
  433.  
  434.         MSG msg;  //ta struktura przechowuje info o wydarzeniach z nia zwiazanych
  435.         /*************************************TU WSZYSTKIE KONTROLKI *************************************/
  436.     hCombo = CreateWindowEx(WS_EX_CLIENTEDGE, "COMBOBOX", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER |
  437.                 CBS_DROPDOWN, 5, 50, 70, 200, hWnd, (HMENU)ID_Color, hInstance, NULL);
  438.  
  439.         SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) "HSV");
  440.         SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) "HSL");
  441.         SendMessage(hCombo, CB_ADDSTRING, 0, (LPARAM) "YUV");
  442.  
  443.         //Nazwa nowego pliku
  444.     hText1 = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER |
  445.     WS_VSCROLL | ES_MULTILINE | ES_AUTOVSCROLL, 100, 50, 380, 25, hWnd, NULL, hInstance, NULL);
  446.         SetWindowText(hText1, "Nazwa nowego pliku");
  447.  
  448.     //sciezka dostepu do pliku
  449.     hText = CreateWindowEx(WS_EX_CLIENTEDGE, "EDIT", NULL, WS_CHILD | WS_VISIBLE | WS_BORDER |
  450.     WS_VSCROLL | ES_MULTILINE | ES_AUTOVSCROLL, 5, 5, 475, 40, hWnd, NULL, hInstance, NULL);
  451.         SetWindowText(hText, "Wpisz tu sciezke do pliku");
  452.  
  453.         g_hPrzycisk = CreateWindowEx(0, "BUTTON", "Konwertuj", WS_CHILD | WS_VISIBLE,
  454.                 250, 80, 180, 30, hWnd, (HMENU)ID_Convert, hInstance, NULL);
  455.  
  456.         /*************************************TU KONIEC KONTROLEK*************************************/
  457.  
  458.         while (TRUE)
  459.         {
  460.                 if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
  461.                 {
  462.                         TranslateMessage(&msg);
  463.                         DispatchMessage(&msg);
  464.                         if (msg.message == WM_QUIT)
  465.             break;
  466.                 }
  467.         }
  468.  
  469. //GlobalFree(Bufor);
  470.         return msg.wParam;
  471. }
  472. /*************************************************************************************************************************************/
  473.  
  474. /*OBSLUGA KOMUNIKATOW*/
  475. LRESULT CALLBACK WindowProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
  476. {
  477.         switch (msg)
  478.         {
  479. /**************************/
  480.         case WM_CLOSE:
  481.             DestroyWindow(hWnd);
  482.             break;
  483. /**************************/
  484.         case WM_DESTROY:
  485.             PostQuitMessage(0);
  486.             break;
  487. /**************************/
  488.         case WM_COMMAND:
  489.             switch (wParam)
  490.             {
  491.             /**************************/
  492.             case ID_Convert:
  493.                 TrybKoloru = ComboBox_GetCurSel( hCombo ); //pobieram tryb koloru, jsli pusty: brak konwersji koloru
  494.                 dlugosc = GetWindowTextLength(hText);
  495.                 Bufor = (LPSTR)GlobalAlloc(GPTR, dlugosc + 1);
  496.                 GetWindowText(hText, Bufor, dlugosc + 1); // pobralem sciezke dostepu do zmiennej bufor
  497.                 dlugosc = GetWindowTextLength(hText1);
  498.                 NowaNazwaPliku = (LPSTR)GlobalAlloc(GPTR, dlugosc + 1);
  499.                 GetWindowText(hText1, NowaNazwaPliku, dlugosc + 1); //tu sciezka dla nowego pliku
  500.                 frame();
  501.                 newfile(w,h);
  502.                 break;
  503.             /**************************/
  504.             }
  505.          break;
  506. /**************************/
  507.         default:
  508.             return DefWindowProc(hWnd, msg, wParam, lParam);
  509.         }
  510.  
  511.         return 0;
  512. }
  513.  
  514.  

Reply to "qwertyui"