daily pastebin goal
87%
SHARE
TWEET

Untitled

a guest Jan 12th, 2018 50 Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. #include <string>
  2. #include <windows.h>
  3. #include <fstream>
  4. #include "resource.h"
  5. HWND hEdit;
  6. HWND hEdt;
  7. HWND hHEB;
  8. HWND hENG;
  9. const char g_szClassName[] = "myWindowClass";
  10. int BuffCheck(char * biff)
  11. {
  12.     std::string NewB = std::string(biff);
  13.     if(NewB == std::string(""))
  14.     {
  15.         MessageBoxA(NULL,"empty...","Note",MB_OK);  
  16.         return 0;
  17.     }
  18.     if(NewB.rfind(" ")!=-1)
  19.     {
  20.         MessageBoxA(NULL, "To many word","Note",MB_OK);  
  21.         return 0;
  22.     }
  23.     return 1;
  24. }
  25. // Step 4: the Window Procedure
  26. LRESULT CALLBACK WndProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
  27. {
  28.     PAINTSTRUCT ps; // Paint Structure
  29.     HDC hdc;
  30.     bool iHeb;
  31.     switch(msg)
  32.     {
  33.         case WM_CREATE:
  34.         {
  35.             int howM = 0;
  36.             std::ifstream fo;
  37.             fo.open("out.txt");
  38.             while (fo.good())
  39.             {
  40.                 if(!fo.good())
  41.                 break;
  42.                 std::string a;
  43.                 fo >> a;
  44.                 howM += 1;
  45.             }
  46.             howM -= 1;
  47.             fo.close();
  48.             fo.clear();
  49.             int what = rand()%howM;
  50.             if((what+3)%3 == 0)
  51.             {
  52.                 if(what+1<howM)
  53.                 {
  54.                     what += 1;
  55.                 }
  56.                 else if(what-1>=0)
  57.                 {
  58.                     what -= 1;
  59.                 }
  60.             }
  61.             if(what = howM)
  62.                 what -= 1;
  63.             std::string word;
  64.             fo.open("out.txt");
  65.             int s = 0;
  66.             std::string Hword, Eword;
  67.             while (fo.good())
  68.             {
  69.                 std::string a;
  70.                 fo >> a;    
  71.                                        
  72.                 if(s == what)
  73.                 {
  74.                      
  75.                     if( (s+1)%3 == 0)
  76.                     {
  77.                         Hword = a;
  78.                         Eword = "write the word in english";
  79.                         iHeb = true;
  80.                     }
  81.                     if((s+2)%3 == 0)
  82.                     {
  83.                         Eword = a;
  84.                         Hword = "כתוב את המילה בעברית";
  85.                         iHeb = false;
  86.                     }
  87.                     break;
  88.                 }
  89.                 s += 1;
  90.             }
  91.             fo.close();
  92.             // add word in english
  93.             hEdit=CreateWindowEx(WS_EX_CLIENTEDGE,
  94.             "EDIT",
  95.             "",
  96.             WS_CHILD|WS_VISIBLE|
  97.             ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL,
  98.             120,
  99.             100,
  100.             200,
  101.             25,
  102.             hwnd,
  103.             (HMENU)IDC_MAIN_EDIT,
  104.             GetModuleHandle(NULL),
  105.             NULL);
  106.             HGDIOBJ hfDefault=GetStockObject(DEFAULT_GUI_FONT);
  107.             SendMessage(hEdit,
  108.             WM_SETFONT,
  109.             (WPARAM)hfDefault,
  110.             MAKELPARAM(FALSE,0));
  111.             SendMessage(hEdit,
  112.             WM_SETTEXT,
  113.             0,
  114.             (LPARAM)"WORD");
  115.             // add word in hebrew
  116.             hEdt=CreateWindowEx(WS_EX_CLIENTEDGE,
  117.             "EDIT",
  118.             "",
  119.             WS_CHILD|WS_VISIBLE|
  120.             ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL,
  121.             120,
  122.             140,
  123.             200,
  124.             25,
  125.             hwnd,
  126.             (HMENU)IDC_MAIN_EDITA,
  127.             GetModuleHandle(NULL),
  128.             NULL);
  129.             HGDIOBJ hfefault=GetStockObject(DEFAULT_GUI_FONT);
  130.             SendMessage(hEdit,
  131.             WM_SETFONT,
  132.             (WPARAM)hfDefault,
  133.             MAKELPARAM(FALSE,0));
  134.             SendMessage(hEdt,
  135.             WM_SETTEXT,
  136.             0,
  137.             (LPARAM)"מילה");
  138.             // check word in english
  139.             hENG=CreateWindowEx(WS_EX_CLIENTEDGE,
  140.             "EDIT",
  141.             "",
  142.             WS_CHILD|WS_VISIBLE|
  143.             ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL,
  144.             380,
  145.             100,
  146.             200,
  147.             25,
  148.             hwnd,
  149.             (HMENU)IDC_MAIN_ENG,
  150.             GetModuleHandle(NULL),
  151.             NULL);
  152.             HGDIOBJ hEBDefault=GetStockObject(DEFAULT_GUI_FONT);
  153.             SendMessage(hENG,
  154.             WM_SETFONT,
  155.             (WPARAM)hfDefault,
  156.             MAKELPARAM(FALSE,0));
  157.             SendMessage(hENG,
  158.             WM_SETTEXT,
  159.             0,
  160.             (LPARAM)Hword.c_str());
  161.             // Check word in english
  162.             hHEB=CreateWindowEx(WS_EX_CLIENTEDGE,
  163.             "EDIT",
  164.             "",
  165.             WS_CHILD|WS_VISIBLE|
  166.             ES_MULTILINE|ES_AUTOVSCROLL|ES_AUTOHSCROLL,
  167.             380,
  168.             140,
  169.             200,
  170.             25,
  171.             hwnd,
  172.             (HMENU)IDC_MAIN_HEB,
  173.             GetModuleHandle(NULL),
  174.             NULL);
  175.             HGDIOBJ hNGefault=GetStockObject(DEFAULT_GUI_FONT);
  176.             SendMessage(hHEB,
  177.             WM_SETFONT,
  178.             (WPARAM)hfDefault,
  179.             MAKELPARAM(FALSE,0));
  180.             SendMessage(hHEB,WM_SETTEXT,0,(LPARAM)Eword.c_str());
  181.             // Create a push button
  182.             HWND hWndButton=CreateWindowEx(NULL,
  183.             "BUTTON",
  184.             "ADD",
  185.             WS_TABSTOP|WS_VISIBLE|
  186.             WS_CHILD|BS_DEFPUSHBUTTON,
  187.             50,
  188.             220,
  189.             100,
  190.             24,
  191.             hwnd,
  192.             (HMENU)IDC_MAIN_BUTTON,
  193.             GetModuleHandle(NULL),
  194.             NULL);
  195.             SendMessage(hWndButton,
  196.             WM_SETFONT,
  197.             (WPARAM)hfDefault,
  198.             MAKELPARAM(FALSE,0));
  199.             // Create a push button
  200.             HWND hEBndButton=CreateWindowEx(NULL,
  201.             "BUTTON",
  202.             "CHECK",
  203.             WS_TABSTOP|WS_VISIBLE|
  204.             WS_CHILD|BS_DEFPUSHBUTTON,
  205.             450,
  206.             220,
  207.             100,
  208.             24,
  209.             hwnd,
  210.             (HMENU)IDC_MAIN_CHECK,
  211.             GetModuleHandle(NULL),
  212.             NULL);
  213.             SendMessage(hEBndButton,
  214.             WM_SETFONT,
  215.             (WPARAM)hfDefault,
  216.             MAKELPARAM(FALSE,0));
  217.             // Create a push button
  218.             HWND hCha=CreateWindowEx(NULL,
  219.             "BUTTON",
  220.             "CHANGE",
  221.             WS_TABSTOP|WS_VISIBLE|
  222.             WS_CHILD|BS_DEFPUSHBUTTON,
  223.             450,
  224.             260,
  225.             100,
  226.             24,
  227.             hwnd,
  228.             (HMENU)IDC_MAIN_CHANGE,
  229.             GetModuleHandle(NULL),
  230.             NULL);
  231.             SendMessage(hCha,
  232.             WM_SETFONT,
  233.             (WPARAM)hfDefault,
  234.             MAKELPARAM(FALSE,0));
  235.         }
  236.         break;
  237.         char buffer[256];
  238.         char bufheb[256];
  239.         case WM_COMMAND:
  240.         switch(LOWORD(wParam))
  241.         {
  242.             case IDC_MAIN_BUTTON:
  243.             {
  244.                 SendMessage(hEdit,
  245.                 WM_GETTEXT,
  246.                 sizeof(buffer)/sizeof(buffer[0]),
  247.                 reinterpret_cast<LPARAM>(buffer));
  248.                 SendMessage(hEdt,
  249.                 WM_GETTEXT,
  250.                 sizeof(bufheb)/sizeof(bufheb[0]),
  251.                 reinterpret_cast<LPARAM>(bufheb));
  252.                 std::ifstream f;
  253.                 f.open("out.txt");
  254.                 std::string inout;
  255.                 std::string text;
  256.                 text = "";
  257.                 int num = 0;
  258.                 bool c = true;
  259.                 int d = 0;
  260.                 while (f.good())
  261.                 {
  262.                     f >> inout;
  263.                     if (!f.good()) break;
  264.                     if (inout == "")
  265.                     continue;
  266.                     if(inout == std::string(buffer) && (d == 0 || d == 1))
  267.                     {    
  268.                         d = 2;
  269.                         if(d >= 2)
  270.                         {
  271.                             MessageBoxA(NULL, "aleardy have this word eng","Note",MB_OK);  
  272.                             c = false;
  273.                             break;
  274.                         }
  275.                     }
  276.                     if(inout == std::string(bufheb) && (d == 0 || d == 2))
  277.                     {
  278.                         d = 1;
  279.                         if(d >= 2)
  280.                         {
  281.                             MessageBoxA(NULL, "aleardy have this word heb","Note",MB_OK);  
  282.                             c = false;
  283.                             break;
  284.                         }
  285.                     }
  286.                     text += inout + "\n";
  287.                     num += 1;
  288.                 }
  289.                 num /= 3;
  290.                 if(BuffCheck(buffer) && BuffCheck(bufheb) && c)
  291.                 {
  292.                     std::ofstream fa;
  293.                     fa.open("out.txt");
  294.                     fa << std::string(text);
  295.                     fa << num;
  296.                     fa << "\n";
  297.                     fa << std::string(buffer);
  298.                     fa << "\n";
  299.                     fa << std::string(bufheb);
  300.                     fa << "\n";
  301.                     fa.close();
  302.                     MessageBoxA(NULL, "seccsefuly add","Note",MB_OK);  
  303.                 }
  304.             }
  305.             break;
  306.             case IDC_MAIN_CHECK:
  307.             {
  308.                 char hebcheck[256];
  309.                 char engcheck[256];
  310.                 SendMessage(hHEB,
  311.                 WM_GETTEXT,
  312.                 sizeof(hebcheck)/sizeof(hebcheck[0]),
  313.                 reinterpret_cast<LPARAM>(hebcheck));
  314.                 SendMessage(hENG,
  315.                 WM_GETTEXT,
  316.                 sizeof(engcheck)/sizeof(engcheck[0]),
  317.                 reinterpret_cast<LPARAM>(engcheck));
  318.                 std::ifstream f;
  319.                 f.open("out.txt");
  320.                 bool right = false;
  321.                 while (f.good())
  322.                 {
  323.                     if (!f.good()) break;  
  324.                     std::string str;
  325.                     f >> str;
  326.                     if(iHeb == true)
  327.                     {
  328.                         if(str == std::string(hebcheck))
  329.                         {
  330.                             right = true;
  331.                             MessageBoxA(NULL, "grate","Note",MB_OK);
  332.                             break;
  333.                         }
  334.                     }
  335.                     else
  336.                     {
  337.                         if(str == std::string(engcheck))
  338.                         {
  339.                             right = true;
  340.                             MessageBoxA(NULL, "grate","Note",MB_OK);
  341.                             break;
  342.                         }
  343.                     }
  344.                     if(hebcheck == engcheck)
  345.                     right = false;
  346.                 }
  347.                 if(right == false)
  348.                 MessageBoxA(NULL, "sorry, but you are stupid...","Note",MB_OK);
  349.                 f.close();
  350.             }
  351.             break;
  352.             case IDC_MAIN_CHANGE:
  353.             {
  354.                 int howM = 0;
  355.                 std::ifstream fo;
  356.                 fo.open("out.txt");
  357.                 while (fo.good())
  358.                 {
  359.                     if(!fo.good())
  360.                         break;
  361.                     std::string a;
  362.                     fo >> a;
  363.                     howM += 1;
  364.                 }
  365.                 howM -= 1;
  366.                 fo.close();
  367.                 fo.clear();
  368.                 int what = rand()%howM;
  369.                 std::string word;
  370.                 fo.open("out.txt");
  371.                 int s = 0;
  372.                 if((what+3)%3 == 0)
  373.                 {
  374.                     if(what+1<=howM)
  375.                     {
  376.                         what += 1;
  377.                     }
  378.                     else if(what-1>=0)
  379.                     {
  380.                         what -= 1;
  381.                     }
  382.                 }
  383.                 while (fo.good())
  384.                 {
  385.                     std::string a;
  386.                     fo >> a;                            
  387.                     if(s == what)
  388.                     {
  389.                         if( (s+1)%3 == 0)
  390.                         {
  391.                             SendMessage(hHEB,WM_SETTEXT,0,(LPARAM)a.c_str());
  392.                             SendMessage(hENG,WM_SETTEXT,0,(LPARAM)"write the word in english");
  393.                             iHeb = true;
  394.                         }
  395.                         if((s+2)%3 == 0)
  396.                         {
  397.                             SendMessage(hENG,WM_SETTEXT,0,(LPARAM)a.c_str());
  398.                             SendMessage(hHEB,WM_SETTEXT,0,(LPARAM)"כתוב את המילה בעברית");
  399.                             iHeb = false;
  400.                         }
  401.                         break;
  402.                     }
  403.                     s += 1;
  404.                     // check word in english
  405.                 }
  406.             }
  407.             break;
  408.         }
  409.         break;
  410.         case WM_PAINT:
  411.         {
  412.             hdc= BeginPaint(hwnd,&ps);
  413.             TextOut(hdc,125,52,"add word", 8);  
  414.             TextOut(hdc,425,52,"check word", 10);  
  415.             TextOut(hdc,45,102,"ENGLISH:", 8);  
  416.             TextOut(hdc,45,145,"HEBREW:", 8);  
  417.             EndPaint(hwnd,&ps);
  418.         }
  419.         break;
  420.         case WM_CLOSE:
  421.         DestroyWindow(hwnd);
  422.         break;
  423.         case WM_DESTROY:
  424.         PostQuitMessage(0);
  425.         break;  
  426.         default:
  427.         return DefWindowProc(hwnd, msg, wParam, lParam);
  428.     }
  429.     return 0;
  430. }
  431.  
  432. int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance,
  433. LPSTR lpCmdLine, int nCmdShow)
  434. {
  435.     WNDCLASSEX wc;
  436.     HWND hwnd;
  437.     HWND hWndEdit;
  438.     MSG Msg;
  439.     //Step 1: Registering the Window Class
  440.     wc.cbSize = sizeof(WNDCLASSEX);
  441.     wc.style = 0;
  442.     wc.lpfnWndProc = WndProc;
  443.     wc.cbClsExtra = 0;
  444.     wc.cbWndExtra = 0;
  445.     wc.hInstance = hInstance;
  446.     wc.hIcon = LoadIcon(NULL, IDI_APPLICATION);
  447.     wc.hCursor = LoadCursor(NULL, IDC_ARROW);
  448.     wc.hbrBackground = (HBRUSH)(COLOR_WINDOW+1);
  449.     wc.lpszMenuName = NULL;
  450.     wc.lpszClassName = g_szClassName;
  451.     wc.hIconSm = LoadIcon(NULL, IDI_APPLICATION);
  452.     if(!RegisterClassEx(&wc))
  453.     {
  454.         MessageBox(NULL, "Window Registration Failed!", "Error!",
  455.         MB_ICONEXCLAMATION | MB_OK);
  456.         return 0;
  457.     }
  458.     // Step 2: Creating the Window
  459.     hwnd = CreateWindowEx(
  460.     WS_EX_CLIENTEDGE,
  461.     g_szClassName,
  462.     "Tom is so smart and cool!!!",
  463.     WS_OVERLAPPEDWINDOW,
  464.     CW_USEDEFAULT, CW_USEDEFAULT, 640, 480,
  465.     NULL, NULL, hInstance, NULL);
  466.     if(hwnd == NULL)
  467.     {
  468.         MessageBox(NULL, "Window Creation Failed!", "Error!",
  469.         MB_ICONEXCLAMATION | MB_OK);
  470.         return 0;
  471.     }
  472.     ShowWindow(hwnd, nCmdShow);
  473.     UpdateWindow(hwnd);
  474.     // Step 3: The Message Loop
  475.     while(GetMessage(&Msg, NULL, 0, 0) > 0)
  476.     {
  477.         TranslateMessage(&Msg);
  478.         DispatchMessage(&Msg);
  479.     }
  480.     return Msg.wParam;
  481. }
RAW Paste Data
Top