API tools faq
paste
Advertisement
alien_fx_fiend

Dictionary Win32 *FINAL RELEASE !*

alien_fx_fiend
Oct 22nd, 2024 (edited)
62
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C++ 47.30 KB | Source Code | 0 0
raw download clone embed print report
  1. ==++"realtime.cpp" File 1/3 SourceCode++==::
  2. #include <Windows.h>
  3. #include <CommCtrl.h>
  4. #include <fstream>
  5. #include <sstream>
  6. #include <string>
  7. #include <algorithm>
  8. #include <vector>
  9. #include "resource2.h"
  10. #include "resource.h"
  11.  
  12. #pragma comment(lib, "comctl32.lib")
  13.  
  14. using namespace std;
  15.  
  16. // Structure to represent a dictionary entry
  17. struct DictionaryEntry {
  18.     wstring word;
  19.     wstring definition;
  20. };
  21.  
  22. // Structure to represent a node in the linked list
  23. struct Node {
  24.     DictionaryEntry data;
  25.     Node* next;
  26. };
  27.  
  28. Node* dictionary = nullptr;
  29. vector<wstring> words;
  30. WNDPROC oldWordEditProc;
  31. WNDPROC oldDefinitionEditProc;
  32. HHOOK g_hHook = NULL;
  33. HWND g_hDlg = NULL;
  34. HWND g_hDefinitionDlg = NULL; // Add this near where you declare g_hDlg
  35.  
  36. // Function prototypes
  37. //LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
  38. LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam);
  39. INT_PTR CALLBACK ViewDefinitionDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam);
  40. void AddWordToList(HWND hwnd);
  41. void insertNode(Node*& head, const DictionaryEntry& entry);
  42. //void addWord(Node*& head, const wstring& word, const wstring& definition);
  43. bool addWord(Node*& head, const wstring& word, const wstring& definition);
  44. void deleteWord(Node*& head, const wstring& keyword);
  45. wstring InputBox(HWND hwnd, const wstring& prompt, const wstring& title);
  46. void DisplayDefinition(HWND hwnd, const wstring& word, const wstring& definition);
  47. void editWord(Node* head, const wstring& oldWord, const wstring& newWord, const wstring& newDefinition);
  48. void listWords(const Node* head, vector<wstring>& words);
  49. void serializeDictionary(const Node* head, const wstring& filename);
  50. void deserializeDictionary(Node*& head, const wstring& filename);
  51. void searchWordRealtime(const Node* head, const wstring& keyword, vector<wstring>& suggestions);
  52. int pruneDictionary(Node*& head);
  53. void updateDictionaryAfterPrune(Node*& head, vector<wstring>& words, HWND hwnd);
  54. void updateListBox(HWND hwnd, const vector<wstring>& words);
  55.  
  56. LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
  57.     if (nCode == HC_ACTION) {
  58.         KBDLLHOOKSTRUCT* pKbdStruct = (KBDLLHOOKSTRUCT*)lParam;
  59.         if (wParam == WM_KEYDOWN) {
  60.             switch (pKbdStruct->vkCode) {
  61.             case VK_RETURN:
  62.                 if (GetFocus() == GetDlgItem(g_hDlg, IDC_WORD_INPUT) ||
  63.                     GetFocus() == GetDlgItem(g_hDlg, IDC_DEFINITION_INPUT)) {
  64.                     AddWordToList(g_hDlg);
  65.                     return 1;
  66.                 }
  67.                 break;
  68.             case VK_ESCAPE:
  69.                 if (GetDlgItem(g_hDlg, IDCANCEL)) {
  70.                     SendMessage(g_hDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), 0);
  71.                     return TRUE;
  72.                 }
  73.                 else if (GetDlgItem(g_hDlg, IDNO)) {
  74.                     SendMessage(g_hDlg, WM_COMMAND, MAKEWPARAM(IDNO, 0), 0);
  75.                     return TRUE;
  76.                 }
  77.                 else {
  78.                     SendMessage(g_hDlg, WM_CLOSE, 0, 0);
  79.                     return TRUE;
  80.                 }
  81.                 break;
  82.             case VK_F1:
  83.             {
  84.                 if (g_hDefinitionDlg && IsWindowVisible(g_hDefinitionDlg)) {
  85.                     // If the definition window is visible, hide it
  86.                     ShowWindow(g_hDefinitionDlg, SW_HIDE);
  87.                 }
  88.                 else {
  89.                     // If the definition window is not visible or doesn't exist, show/create it
  90.                     HWND hListBox = GetDlgItem(g_hDlg, IDC_LISTBOX);
  91.                     int selectedIndex = SendMessage(hListBox, LB_GETCURSEL, 0, 0);
  92.                     if (selectedIndex != LB_ERR) {
  93.                         wchar_t selectedWord[256];
  94.                         SendMessage(hListBox, LB_GETTEXT, selectedIndex, (LPARAM)selectedWord);
  95.                         Node* current = dictionary;
  96.                         while (current) {
  97.                             if (current->data.word == selectedWord) {
  98.                                 wstring message = L"Definition of '" + current->data.word + L"': \n\n" + current->data.definition;
  99.                                 if (g_hDefinitionDlg) {
  100.                                     // Update existing dialog
  101.                                     SetDlgItemText(g_hDefinitionDlg, IDC_DEFINITION_EDIT, message.c_str());
  102.                                     ShowWindow(g_hDefinitionDlg, SW_SHOW);
  103.                                 }
  104.                                 else {
  105.                                     // Create new dialog
  106.                                     g_hDefinitionDlg = CreateDialogParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DEFINITION), g_hDlg, ViewDefinitionDlgProc, (LPARAM)new wstring(message));
  107.                                     ShowWindow(g_hDefinitionDlg, SW_SHOW);
  108.                                 }
  109.                                 break;
  110.                             }
  111.                             current = current->next;
  112.                         }
  113.                     }
  114.                 }
  115.                 return 1;
  116.             }
  117.             /* {
  118.                 if (g_hDefinitionDlg) {
  119.                     if (IsWindowVisible(g_hDefinitionDlg)) {
  120.                         ShowWindow(g_hDefinitionDlg, SW_HIDE);
  121.                     }
  122.                     else {
  123.                         ShowWindow(g_hDefinitionDlg, SW_SHOW);
  124.                     }
  125.                 }
  126.                 else {
  127.                     HWND hListBox = GetDlgItem(g_hDlg, IDC_LISTBOX);
  128.                     int selectedIndex = SendMessage(hListBox, LB_GETCURSEL, 0, 0);
  129.                     if (selectedIndex != LB_ERR) {
  130.                         wchar_t selectedWord[256];
  131.                         SendMessage(hListBox, LB_GETTEXT, selectedIndex, (LPARAM)selectedWord);
  132.                         Node* current = dictionary;
  133.                         while (current) {
  134.                             if (current->data.word == selectedWord) {
  135.                                 g_hDefinitionDlg = CreateDialogParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DEFINITION), g_hDlg, ViewDefinitionDlgProc, (LPARAM)new wstring(current->data.definition));
  136.                                 ShowWindow(g_hDefinitionDlg, SW_SHOW);
  137.                                 break;
  138.                             }
  139.                             current = current->next;
  140.                         }
  141.                     }
  142.                 }
  143.                 return 1;
  144.             }*/
  145.             }
  146.         }
  147.     }
  148.     return CallNextHookEx(NULL, nCode, wParam, lParam);
  149. }
  150.  
  151. /*INT_PTR CALLBACK ViewDefinitionDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
  152.     switch (message) {
  153.     case WM_INITDIALOG:
  154.     {
  155.         wstring* definition = (wstring*)lParam;
  156.         SetDlgItemText(hDlg, IDC_DEFINITION_EDIT, definition->c_str());
  157.         delete definition;
  158.         return (INT_PTR)TRUE;
  159.     }
  160.     case WM_COMMAND:
  161.         if (LOWORD(wParam) == IDCANCEL) {
  162.             EndDialog(hDlg, LOWORD(wParam));
  163.             return (INT_PTR)TRUE;
  164.         }
  165.         break;
  166.     case WM_CLOSE:
  167.         EndDialog(hDlg, 0);
  168.         return (INT_PTR)TRUE;
  169.     }
  170.     return (INT_PTR)FALSE;
  171. }*/
  172. INT_PTR CALLBACK ViewDefinitionDlgProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) {
  173.     switch (message) {
  174.     case WM_INITDIALOG:
  175.     {
  176.         wstring* fullMessage = (wstring*)lParam;
  177.         SetDlgItemText(hDlg, IDC_DEFINITION_EDIT, fullMessage->c_str());
  178.         delete fullMessage;
  179.         return (INT_PTR)TRUE;
  180.     }
  181.     case WM_COMMAND:
  182.         if (LOWORD(wParam) == IDCANCEL) {
  183.             ShowWindow(hDlg, SW_HIDE);
  184.             return (INT_PTR)TRUE;
  185.         }
  186.         break;
  187.     case WM_CLOSE:
  188.         ShowWindow(hDlg, SW_HIDE);
  189.         return (INT_PTR)TRUE;
  190.     }
  191.     return (INT_PTR)FALSE;
  192. }
  193.  
  194. // Function implementations
  195. void insertNode(Node*& head, const DictionaryEntry& entry) {
  196.     Node* newNode = new Node{ entry, nullptr };
  197.     if (!head) {
  198.         head = newNode;
  199.     }
  200.     else {
  201.         Node* current = head;
  202.         while (current->next) {
  203.             current = current->next;
  204.         }
  205.         current->next = newNode;
  206.     }
  207. }
  208.  
  209. bool addWord(Node*& head, const wstring& word, const wstring& definition) {
  210.     // Check if the word already exists
  211.     Node* current = head;
  212.     while (current) {
  213.         if (current->data.word == word) {
  214.             return false; // Word already exists, don't add
  215.         }
  216.         current = current->next;
  217.     }
  218.  
  219.     // Word doesn't exist, add it
  220.     insertNode(head, { word, definition });
  221.     return true;
  222. }
  223. // w/o duplicates
  224. /* // Modify the addWord function to check for duplicates
  225. bool addWord(Node*& head, const wstring& word, const wstring& definition) {
  226.     // Check if the word already exists
  227.     Node* current = head;
  228.     while (current) {
  229.         if (current->data.word == word) {
  230.             return false; // Word already exists, don't add
  231.         }
  232.         current = current->next;
  233.     }
  234.  
  235.     // Word doesn't exist, add it
  236.     insertNode(head, { word, definition });
  237.     return true;
  238. }*/
  239. // /w duplicates
  240. /*void addWord(Node*& head, const wstring& word, const wstring& definition) {
  241.     insertNode(head, { word, definition });
  242. }*/
  243.  
  244. void deleteWord(Node*& head, const wstring& keyword) {
  245.     if (!head) return;
  246.  
  247.     if (head->data.word == keyword) {
  248.         Node* temp = head;
  249.         head = head->next;
  250.         delete temp;
  251.         return;
  252.     }
  253.  
  254.     Node* current = head;
  255.     while (current->next && current->next->data.word != keyword) {
  256.         current = current->next;
  257.     }
  258.  
  259.     if (current->next) {
  260.         Node* temp = current->next;
  261.         current->next = current->next->next;
  262.         delete temp;
  263.     }
  264. }
  265.  
  266. // Modify the InputBox function to pre-populate the input
  267. wstring InputBox(HWND hwnd, const wstring& prompt, const wstring& title, const wstring& defaultValue = L"") {
  268.     wstring input = defaultValue;
  269.     DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_INPUT), hwnd,
  270.         [](HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) -> INT_PTR {
  271.             static wstring* pInput;
  272.             switch (message) {
  273.             case WM_INITDIALOG:
  274.                 pInput = (wstring*)lParam;
  275.                 SetDlgItemText(hDlg, IDC_INPUT, pInput->c_str());
  276.                 SendDlgItemMessage(hDlg, IDC_INPUT, EM_SETSEL, 0, -1);  // Select all text
  277.                 return (INT_PTR)TRUE;
  278.             case WM_COMMAND:
  279.                 if (LOWORD(wParam) == IDOK) {
  280.                     HWND hEdit = GetDlgItem(hDlg, IDC_INPUT);
  281.                     int len = GetWindowTextLength(hEdit) + 1;
  282.                     wchar_t* buffer = new wchar_t[len];
  283.                     GetWindowText(hEdit, buffer, len);
  284.                     *pInput = buffer;
  285.                     delete[] buffer;
  286.                     EndDialog(hDlg, IDOK);
  287.                     return (INT_PTR)TRUE;
  288.                 }
  289.                 else if (LOWORD(wParam) == IDCANCEL) {
  290.                     EndDialog(hDlg, IDCANCEL);
  291.                     return (INT_PTR)TRUE;
  292.                 }
  293.                 break;
  294.             }
  295.             return (INT_PTR)FALSE;
  296.         }, (LPARAM)&input);
  297.     return input;
  298. }
  299. /*wstring InputBox(HWND hwnd, const wstring& prompt, const wstring& title) {
  300.     wchar_t input[156] = L"";
  301.     if (DialogBoxParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_INPUT), hwnd,
  302.         [](HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) -> INT_PTR {
  303.             static wchar_t input[156];
  304.             switch (message) {
  305.             case WM_INITDIALOG: {
  306.                 HWND hEdit = GetDlgItem(hDlg, IDC_INPUT);
  307.                 SetWindowText(hEdit, (LPCWSTR)lParam);
  308.                 SendMessage(hEdit, EM_SETSEL, 0, -1); // Select all text
  309.                 break;
  310.             }
  311.             case WM_COMMAND:
  312.                 if (LOWORD(wParam) == IDOK) {
  313.                     GetDlgItemText(hDlg, IDC_INPUT, input, 156);
  314.                     EndDialog(hDlg, IDOK);
  315.                     return (INT_PTR)TRUE;
  316.                 }
  317.                 else if (LOWORD(wParam) == IDCANCEL) {
  318.                     EndDialog(hDlg, IDCANCEL);
  319.                     return (INT_PTR)TRUE;
  320.                 }
  321.                 break;
  322.             }
  323.             return (INT_PTR)FALSE;
  324.         }, (LPARAM)prompt.c_str()) == IDOK) {
  325.         return (wstring)input;
  326.     }
  327.     return L"";
  328. }*/
  329.  
  330. void DisplayDefinition(HWND hwnd, const wstring& word, const wstring& definition) {
  331.     wstring message = L"Definition of '" + word + L"': \n\n" + definition;
  332.     HWND hDlg = CreateDialogParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DEFINITION), hwnd, [](HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam) -> INT_PTR {
  333.         switch (message) {
  334.         case WM_INITDIALOG:
  335.         {
  336.             wstring* definition = (wstring*)lParam;
  337.             SetDlgItemText(hDlg, IDC_DEFINITION_EDIT, definition->c_str());
  338.             delete definition;
  339.         }
  340.         return (INT_PTR)TRUE;
  341.         case WM_COMMAND:
  342.             if (LOWORD(wParam) == IDCANCEL) {
  343.                 EndDialog(hDlg, LOWORD(wParam));
  344.                 return (INT_PTR)TRUE;
  345.             }
  346.             break;
  347.         case WM_CLOSE:
  348.             EndDialog(hDlg, 0);
  349.             return (INT_PTR)TRUE;
  350.         }
  351.         return (INT_PTR)FALSE;
  352.         }, (LPARAM)new wstring(message));
  353.     ShowWindow(hDlg, SW_SHOW);
  354. }
  355. /*void DisplayDefinition(HWND hwnd, const wstring& word, const wstring& definition) {
  356.     wstring message = L"Definition of '" + word + L"':\n\n" + definition;
  357.     MessageBox(hwnd, message.c_str(), L"Word Definition", MB_OK | MB_ICONINFORMATION);
  358. }*/
  359.  
  360. void editWord(Node* head, const wstring& oldWord, const wstring& newWord, const wstring& newDefinition) {
  361.     Node* current = head;
  362.     while (current) {
  363.         if (current->data.word == oldWord) {
  364.             current->data.word = newWord;
  365.             current->data.definition = newDefinition;
  366.             return;
  367.         }
  368.         current = current->next;
  369.     }
  370. }
  371.  
  372. void listWords(const Node* head, vector<wstring>& words) {
  373.     words.clear();
  374.     const Node* current = head;
  375.     while (current) {
  376.         words.push_back(current->data.word);
  377.         current = current->next;
  378.     }
  379. }
  380.  
  381. // Delimiter Old Semicolon
  382. void serializeDictionary(const Node* head, const wstring& filename) {
  383.     wofstream file(filename, ios::out | ios::trunc);
  384.     if (!file.is_open()) {
  385.         MessageBox(NULL, L"Failed to open file for writing", L"Error", MB_OK | MB_ICONERROR);
  386.         return;
  387.     }
  388.     const Node* current = head;
  389.     while (current) {
  390.         file << current->data.word << L";" << current->data.definition << endl;
  391.         current = current->next;
  392.     }
  393.     file.close();
  394. }
  395.  
  396. // Delimiter Old Semicolon
  397. void deserializeDictionary(Node*& head, const wstring& filename) {
  398.     wifstream file(filename);
  399.     if (!file.is_open()) {
  400.         MessageBox(NULL, L"Failed to open dictionary file", L"Error", MB_OK | MB_ICONERROR);
  401.         return;
  402.     }
  403.     wstring line;
  404.     while (getline(file, line)) {
  405.         size_t pos = line.find(L';');
  406.         if (pos != wstring::npos) {
  407.             wstring word = line.substr(0, pos);
  408.             wstring definition = line.substr(pos + 1);
  409.             addWord(head, word, definition);
  410.         }
  411.     }
  412.     file.close();
  413. }
  414.  
  415. // Add this function to convert a string to lowercase
  416. wstring toLower(const wstring& str) {
  417.     wstring lower = str;
  418.     transform(lower.begin(), lower.end(), lower.begin(), ::towlower);
  419.     return lower;
  420. }
  421.  
  422. // Modify the searchWordRealtime function to be case-insensitive
  423. void searchWordRealtime(const Node* head, const wstring& keyword, vector<wstring>& suggestions) {
  424.     suggestions.clear();
  425.     const Node* current = head;
  426.     wstring lowercaseKeyword = toLower(keyword);
  427.     while (current) {
  428.         wstring lowercaseWord = toLower(current->data.word);
  429.         if (lowercaseWord.find(lowercaseKeyword) != wstring::npos) {
  430.             suggestions.push_back(current->data.word);
  431.         }
  432.         current = current->next;
  433.     }
  434. }
  435.  
  436. // Prune Functions
  437. int pruneDictionary(Node*& head) {
  438.     if (!head) return 0;
  439.  
  440.     int duplicatesRemoved = 0;
  441.     Node* current = head;
  442.  
  443.     while (current && current->next) {
  444.         Node* runner = current;
  445.         while (runner->next) {
  446.             if (current->data.word == runner->next->data.word) {
  447.                 Node* duplicate = runner->next;
  448.                 runner->next = runner->next->next;
  449.                 delete duplicate;
  450.                 duplicatesRemoved++;
  451.             }
  452.             else {
  453.                 runner = runner->next;
  454.             }
  455.         }
  456.         current = current->next;
  457.     }
  458.  
  459.     return duplicatesRemoved;
  460. }
  461.  
  462. // Prune Functions
  463. void updateDictionaryAfterPrune(Node*& head, vector<wstring>& words, HWND hwnd) {
  464.     listWords(head, words);
  465.     updateListBox(hwnd, words);
  466.     serializeDictionary(head, L"myDictionary99x.txt");
  467. }
  468.  
  469. void updateListBox(HWND hwnd, const vector<wstring>& words) {
  470.     HWND hListBox = GetDlgItem(hwnd, IDC_LISTBOX);
  471.     SendMessage(hListBox, LB_RESETCONTENT, 0, 0);
  472.     for (const auto& word : words) {
  473.         SendMessage(hListBox, LB_ADDSTRING, 0, (LPARAM)word.c_str());
  474.     }
  475. }
  476.  
  477. void AddWordToList(HWND hwnd) {
  478.     wchar_t word[256], definition[1024];
  479.     GetDlgItemText(hwnd, IDC_WORD_INPUT, word, 256);
  480.     GetDlgItemText(hwnd, IDC_DEFINITION_INPUT, definition, 1024);
  481.     if (wcslen(word) > 0) {
  482.         if (!addWord(dictionary, word, definition)) {
  483.             wstring message = L"An entry with the name '";
  484.             message += word;
  485.             message += L"' already exists. Do you want to add a duplicate entry?";
  486.             int result = MessageBox(hwnd, message.c_str(), L"Confirm Duplicate Entry", MB_YESNO | MB_ICONQUESTION);
  487.  
  488.             if (result == IDYES) {
  489.                 insertNode(dictionary, { word, definition });
  490.             }
  491.         }
  492.         listWords(dictionary, words);
  493.         updateListBox(hwnd, words);
  494.         serializeDictionary(dictionary, L"myDictionary99x.txt");
  495.         SetDlgItemText(hwnd, IDC_WORD_INPUT, L"");
  496.         SetDlgItemText(hwnd, IDC_DEFINITION_INPUT, L"");
  497.     }
  498. }
  499.  
  500. /*LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
  501.     if (nCode == HC_ACTION) {
  502.         KBDLLHOOKSTRUCT* pKbdStruct = (KBDLLHOOKSTRUCT*)lParam;
  503.         if (wParam == WM_KEYDOWN && pKbdStruct->vkCode == VK_RETURN) {
  504.             HWND hFocus = GetFocus();
  505.             if (hFocus == GetDlgItem(g_hDlg, IDC_WORD_INPUT) ||
  506.                 hFocus == GetDlgItem(g_hDlg, IDC_DEFINITION_INPUT)) {
  507.                 AddWordToList(g_hDlg);
  508.                 return 1;  // Prevent further processing of this key
  509.             }
  510.         }
  511.     }
  512.     return CallNextHookEx(g_hHook, nCode, wParam, lParam);
  513. }*/
  514.  
  515.  
  516. //Return this function
  517. /*LRESULT CALLBACK LowLevelKeyboardProc(int nCode, WPARAM wParam, LPARAM lParam) {
  518.     if (nCode == HC_ACTION) {
  519.         KBDLLHOOKSTRUCT* pKbdStruct = (KBDLLHOOKSTRUCT*)lParam;
  520.         if (wParam == WM_KEYDOWN) {
  521.             switch (pKbdStruct->vkCode) {
  522.             case VK_RETURN:
  523.                 if (GetFocus() == GetDlgItem(g_hDlg, IDC_WORD_INPUT) ||
  524.                     GetFocus() == GetDlgItem(g_hDlg, IDC_DEFINITION_INPUT)) {
  525.                     AddWordToList(g_hDlg);
  526.                     return 1;
  527.                 }
  528.                 break;
  529.             case VK_ESCAPE:
  530.                 /*if (IsWindowVisible(g_hDlg)) { // Assuming g_hDlg is your dialog handle
  531.                     PostMessage(g_hDlg, WM_COMMAND, IDCANCEL, 0);
  532.                     return 1; // Signal that we've handled this key
  533.                 }
  534.                 // Check for Cancel button                
  535.                 if (GetDlgItem(g_hDlg, IDCANCEL)) {
  536.                     SendMessage(g_hDlg, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), 0);
  537.                     return TRUE;
  538.                 }
  539.                 // Check for No button
  540.                 else if (GetDlgItem(g_hDlg, IDNO)) {
  541.                     SendMessage(g_hDlg, WM_COMMAND, MAKEWPARAM(IDNO, 0), 0);
  542.                     return TRUE;
  543.                 }
  544.                 // For dialogs with only a close button (like View Definition)
  545.                 else {
  546.                     SendMessage(g_hDlg, WM_CLOSE, 0, 0);
  547.                     return TRUE;
  548.                 }
  549.                 break;
  550.             case VK_F1:
  551.             {
  552.     if (g_hDefinitionDlg && IsWindowVisible(g_hDefinitionDlg)) {
  553.         // If the dialog is visible, hide it
  554.         ShowWindow(g_hDefinitionDlg, SW_HIDE);
  555.         g_hDefinitionDlg = NULL; // Reset since we're hiding it
  556.     } else {
  557.         // If not visible or doesn't exist, show it or create it
  558.         HWND hListBox = GetDlgItem(g_hDlg, IDC_LISTBOX);
  559.         int selectedIndex = SendMessage(hListBox, LB_GETCURSEL, 0, 0);
  560.         if (selectedIndex != LB_ERR) {
  561.             wchar_t selectedWord[256];
  562.             SendMessage(hListBox, LB_GETTEXT, selectedIndex, (LPARAM)selectedWord);
  563.             Node* current = dictionary;
  564.             while (current) {
  565.                 if (current->data.word == selectedWord) {
  566.                     // Here, instead of calling DisplayDefinition directly, we'll manage the dialog
  567.                     if (!g_hDefinitionDlg) {
  568.                         g_hDefinitionDlg = CreateDialogParam(GetModuleHandle(NULL), MAKEINTRESOURCE(IDD_DEFINITION), g_hDlg, ViewDefinitionDlgProc, (LPARAM)new wstring(current->data.definition));
  569.                         ShowWindow(g_hDefinitionDlg, SW_SHOW);
  570.                     }
  571.                     break;
  572.                 }
  573.                 current = current->next;
  574.             }
  575.         }
  576.     }
  577.     return 1;
  578. }*/
  579.  
  580. /*LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
  581. {
  582.     if (uMsg == WM_KEYDOWN && wParam == VK_RETURN)
  583.     {
  584.         HWND hwndParent = (HWND)GetWindowLongPtr(hWnd, GWLP_USERDATA);
  585.         if (hwndParent)
  586.         {
  587.             HWND hwndAddButton = GetDlgItem(hwndParent, IDC_ADD_WORD);
  588.             if (hwndAddButton)
  589.             {
  590.                 SendMessage(hwndParent, WM_COMMAND, MAKEWPARAM(IDC_ADD_WORD, BN_CLICKED), (LPARAM)hwndAddButton);
  591.                 return 0;
  592.             }
  593.         }
  594.     }
  595.  
  596.     return CallWindowProc((WNDPROC)GetWindowLongPtr(hWnd, GWLP_USERDATA), hWnd, uMsg, wParam, lParam);
  597. }*/
  598.  
  599. /*LRESULT CALLBACK EditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam,
  600.     LPARAM lParam, UINT_PTR uIdSubclass, DWORD_PTR dwRefData)
  601. {
  602.     if (uMsg == WM_KEYDOWN && wParam == VK_RETURN) {
  603.         HWND hwndParent = (HWND)dwRefData;
  604.         SendMessage(hwndParent, WM_COMMAND, MAKEWPARAM(IDC_ADD_WORD, BN_CLICKED),
  605.             (LPARAM)GetDlgItem(hwndParent, IDC_ADD_WORD));
  606.         return 0;
  607.     }
  608.     return DefSubclassProc(hWnd, uMsg, wParam, lParam);
  609. }*/
  610. /*LRESULT CALLBACK WordEditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  611.     if (uMsg == WM_KEYDOWN && wParam == VK_RETURN) {
  612.         SendMessage(GetParent(hWnd), WM_COMMAND, MAKEWPARAM(IDC_ADD_WORD, BN_CLICKED), (LPARAM)GetDlgItem(GetParent(hWnd), IDC_ADD_WORD));
  613.         return 0;
  614.     }
  615.     return CallWindowProc(oldWordEditProc, hWnd, uMsg, wParam, lParam);
  616. }
  617.  
  618. LRESULT CALLBACK DefinitionEditSubclassProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  619.     if (uMsg == WM_KEYDOWN && wParam == VK_RETURN) {
  620.         SendMessage(GetParent(hWnd), WM_COMMAND, MAKEWPARAM(IDC_ADD_WORD, BN_CLICKED), (LPARAM)GetDlgItem(GetParent(hWnd), IDC_ADD_WORD));
  621.         return 0;
  622.     }
  623.     return CallWindowProc(oldDefinitionEditProc, hWnd, uMsg, wParam, lParam);
  624. }*/            
  625.  
  626. // Dialog procedure
  627. // Modify the DialogProc function
  628. INT_PTR CALLBACK DialogProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
  629.     static HWND hFocusedEdit = nullptr; // Define hFocusedEdit here
  630.     static HWND hWordEdit = nullptr;
  631.     static HWND hDefinitionEdit = nullptr;
  632.     switch (uMsg) {
  633.     case WM_INITDIALOG:
  634.     {
  635.         // Load dictionary
  636.         /*wchar_t path[MAX_PATH];
  637.         GetModuleFileName(NULL, path, MAX_PATH);
  638.         wstring exePath(path);
  639.         wstring dirPath = exePath.substr(0, exePath.find_last_of(L"\\/"));
  640.         wstring filePath = dirPath + L"\\myDictionary99x.txt";*/
  641.         // Set both large and small icons
  642.         HICON hIcon = LoadIcon(GetModuleHandle(NULL), MAKEINTRESOURCE(IDI_ICON1));
  643.  
  644.         deserializeDictionary(dictionary, L"myDictionary99x.txt");
  645.         listWords(dictionary, words);
  646.         updateListBox(hwnd, words);
  647.         g_hDlg = hwnd;  // Store the dialog handle globally
  648.         g_hHook = SetWindowsHookEx(WH_KEYBOARD_LL, LowLevelKeyboardProc, GetModuleHandle(NULL), 0);
  649.         //hWordEdit = GetDlgItem(hwnd, IDC_WORD_INPUT);
  650.         //hDefinitionEdit = GetDlgItem(hwnd, IDC_DEFINITION_INPUT);
  651.  
  652.         // Set up subclassing
  653.         /*SetWindowLongPtr(hWordEdit, GWLP_USERDATA, (LONG_PTR)hwnd);
  654.         SetWindowLongPtr(hDefinitionEdit, GWLP_USERDATA, (LONG_PTR)hwnd);
  655.         SetWindowLongPtr(hWordEdit, GWLP_WNDPROC, (LONG_PTR)EditSubclassProc);
  656.         SetWindowLongPtr(hDefinitionEdit, GWLP_WNDPROC, (LONG_PTR)EditSubclassProc);*/
  657.         SetFocus(GetDlgItem(hwnd, IDC_SEARCH_INPUT));  // Set focus to search field
  658.         return TRUE;
  659.     }
  660.  
  661.     case WM_COMMAND:
  662.         // Start Double-Click View ListBox Definitions function block
  663.         switch (HIWORD(wParam)) {
  664.         case LBN_DBLCLK:
  665.             if (LOWORD(wParam) == IDC_LISTBOX) {
  666.                 int index = SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETCURSEL, 0, 0);
  667.                 if (index != LB_ERR) {
  668.                     wchar_t word[256];
  669.                     SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETTEXT, index, (LPARAM)word);
  670.  
  671.                     // Find the definition for the selected word
  672.                     Node* current = dictionary;
  673.                     while (current) {
  674.                         if (current->data.word == word) {
  675.                             DisplayDefinition(hwnd, word, current->data.definition);
  676.                             break;
  677.                         }
  678.                         current = current->next;
  679.                     }
  680.                 }
  681.                 return TRUE;
  682.             }
  683.             //break;
  684.         //}
  685.  
  686.         case EN_SETFOCUS:
  687.             if (LOWORD(wParam) == IDC_WORD_INPUT || LOWORD(wParam) == IDC_DEFINITION_INPUT) {
  688.                 hFocusedEdit = (HWND)lParam;
  689.             }
  690.             break;
  691.         }
  692.  
  693.         // End Double-Click View ListBox Definitions function block
  694.         // Handle other controls
  695.         switch (LOWORD(wParam)) {
  696.         case IDC_ADD_WORD: {
  697.             if (LOWORD(wParam) == IDC_ADD_WORD) {
  698.                 AddWordToList(hwnd);
  699.                 return TRUE;
  700.             }
  701.             else if ((LOWORD(wParam) == IDC_WORD_INPUT || LOWORD(wParam) == IDC_DEFINITION_INPUT) &&
  702.                 HIWORD(wParam) == EN_SETFOCUS) {
  703.                 SetTimer(hwnd, 1, 10, NULL);
  704.                 return TRUE;
  705.             }
  706.             else if ((LOWORD(wParam) == IDC_WORD_INPUT || LOWORD(wParam) == IDC_DEFINITION_INPUT) &&
  707.                 HIWORD(wParam) == EN_KILLFOCUS) {
  708.                 KillTimer(hwnd, 1);
  709.                 return TRUE;
  710.             }
  711.             break;
  712.         }
  713.                          /*wchar_t word[256], definition[1024];
  714.                          GetDlgItemText(hwnd, IDC_WORD_INPUT, word, 256);
  715.                          GetDlgItemText(hwnd, IDC_DEFINITION_INPUT, definition, 1024);
  716.                          if (wcslen(word) > 0) {
  717.                              if (!addWord(dictionary, word, definition)) {
  718.                                  // Word already exists, show confirmation box
  719.                                  wstring message = L"An entry with the name '";
  720.                                  message += word;
  721.                                  message += L"' already exists. Do you want to add a duplicate entry?";
  722.                                  int result = MessageBox(hwnd, message.c_str(), L"Confirm Duplicate Entry", MB_YESNO | MB_ICONQUESTION);
  723.  
  724.                                  if (result == IDYES) {
  725.                                      // User confirmed, add the duplicate entry
  726.                                      insertNode(dictionary, { word, definition });
  727.                                      listWords(dictionary, words);
  728.                                      updateListBox(hwnd, words);
  729.                                      serializeDictionary(dictionary, L"myDictionary99x.txt");
  730.                                      SetDlgItemText(hwnd, IDC_WORD_INPUT, L"");
  731.                                      SetDlgItemText(hwnd, IDC_DEFINITION_INPUT, L"");
  732.                                  }
  733.                                  // If result is IDNO, do nothing (silently ignore)
  734.                              }
  735.                              else {
  736.                                  // Word added successfully
  737.                                  listWords(dictionary, words);
  738.                                  updateListBox(hwnd, words);
  739.                                  serializeDictionary(dictionary, L"myDictionary99x.txt");
  740.                                  SetDlgItemText(hwnd, IDC_WORD_INPUT, L"");
  741.                                  SetDlgItemText(hwnd, IDC_DEFINITION_INPUT, L"");
  742.                              }
  743.                          }
  744.                          return TRUE;
  745.                      }
  746.                  }*/
  747.                  // w/o duplicates
  748.                  /*case IDC_ADD_WORD: {
  749.                      wchar_t word[256], definition[1024];
  750.                      GetDlgItemText(hwnd, IDC_WORD_INPUT, word, 256);
  751.                      GetDlgItemText(hwnd, IDC_DEFINITION_INPUT, definition, 1024);
  752.                      if (wcslen(word) > 0) {
  753.                          if (addWord(dictionary, word, definition)) {
  754.                              listWords(dictionary, words);
  755.                              updateListBox(hwnd, words);
  756.                              serializeDictionary(dictionary, L"myDictionary99x.txt");
  757.                              SetDlgItemText(hwnd, IDC_WORD_INPUT, L"");
  758.                              SetDlgItemText(hwnd, IDC_DEFINITION_INPUT, L"");
  759.                          }
  760.                          // If addWord returns false, it means the word already exists.
  761.                          // We silently ignore it as per the requirement.
  762.                      }
  763.                      return TRUE;
  764.                  }*/
  765.                  // /w duplicates        
  766.                  /*case IDC_ADD_WORD: {
  767.                      wchar_t word[256], definition[1024];
  768.                      GetDlgItemText(hwnd, IDC_WORD_INPUT, word, 256);
  769.                      GetDlgItemText(hwnd, IDC_DEFINITION_INPUT, definition, 1024);
  770.                      if (wcslen(word) > 0) {  // Only check if word is not empty
  771.                          addWord(dictionary, word, definition);
  772.                          listWords(dictionary, words);
  773.                          updateListBox(hwnd, words);
  774.                          serializeDictionary(dictionary, L"myDictionary99x.txt");
  775.                          SetDlgItemText(hwnd, IDC_WORD_INPUT, L"");
  776.                          SetDlgItemText(hwnd, IDC_DEFINITION_INPUT, L"");
  777.                      }
  778.                      return TRUE;
  779.                  }*/
  780.  
  781.         case IDC_DELETE_WORD: {
  782.             int index = SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETCURSEL, 0, 0);
  783.             if (index != LB_ERR) {
  784.                 wchar_t word[256];
  785.                 SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETTEXT, index, (LPARAM)word);
  786.  
  787.                 // Create the confirmation message
  788.                 wstring message = L"Are you sure you want to delete the word '";
  789.                 message += word;
  790.                 message += L"'?";
  791.  
  792.                 // Show the confirmation box
  793.                 int result = MessageBox(hwnd, message.c_str(), L"Confirm Deletion", MB_YESNO | MB_ICONQUESTION);
  794.  
  795.                 // If the user clicks "Yes", proceed with deletion
  796.                 if (result == IDYES) {
  797.                     deleteWord(dictionary, word);
  798.                     listWords(dictionary, words);
  799.                     updateListBox(hwnd, words);
  800.                     serializeDictionary(dictionary, L"myDictionary99x.txt");
  801.                 }
  802.             }
  803.             return TRUE;
  804.         }
  805.  
  806.         case IDC_EDIT_WORD: {
  807.             int index = SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETCURSEL, 0, 0);
  808.             if (index != LB_ERR) {
  809.                 wchar_t wordToEdit[256];
  810.                 SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETTEXT, index, (LPARAM)wordToEdit);
  811.                 Node* current = dictionary;
  812.                 while (current) {
  813.                     if (current->data.word == wordToEdit) {
  814.                         wstring newWord = InputBox(hwnd, L"Edit Word", L"Edit Word", current->data.word);
  815.                         if (!newWord.empty()) {
  816.                             wstring newDefinition = InputBox(hwnd, L"Edit Definition", L"Edit Definition", current->data.definition);
  817.                             // newDefinition can be empty now
  818.                             SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_DELETESTRING, index, 0); // Delete the old word
  819.                             editWord(dictionary, wordToEdit, newWord, newDefinition);
  820.                             listWords(dictionary, words);
  821.                             updateListBox(hwnd, words);
  822.                             // fix for C++ best practices "<" Signed/ Unsigned Mismatch
  823.                             for (size_t i = 0; i < words.size(); i++) {
  824.                                 //for (int i = 0; i < words.size(); i++) {
  825.                                 if (words[i] == newWord) {
  826.                                     SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_SETCURSEL, static_cast<WPARAM>(i), 0); // Select the edited word
  827.                                     // fix for C++ best practices "<" Signed Unsigned Mismatch
  828.                                     //SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_SETCURSEL, i, 0); // Select the edited word
  829.                                     break;
  830.                                 }
  831.                             }
  832.                             serializeDictionary(dictionary, L"myDictionary99x.txt");
  833.                         }
  834.                         break;
  835.                     }
  836.                     current = current->next;
  837.                 }
  838.                 if (!current) {
  839.                     MessageBox(hwnd, L"Word not found in the dictionary.", L"Error", MB_OK | MB_ICONERROR);
  840.                 }
  841.             }
  842.             return TRUE;
  843.         }
  844.                           // /w duplicates (does not affect duplicates tho only no check for blank definitions
  845.                           /*case IDC_EDIT_WORD: {
  846.                               int index = SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETCURSEL, 0, 0);
  847.                               if (index != LB_ERR) {
  848.                                   wchar_t wordToEdit[256];
  849.                                   SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETTEXT, index, (LPARAM)wordToEdit);
  850.                                   Node* current = dictionary;
  851.                                   while (current) {
  852.                                       if (current->data.word == wordToEdit) {
  853.                                           wstring newWord = InputBox(hwnd, L"Edit Word", L"Edit Word", current->data.word);
  854.                                           if (!newWord.empty()) {
  855.                                               wstring newDefinition = InputBox(hwnd, L"Edit Definition", L"Edit Definition", current->data.definition);
  856.                                               SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_DELETESTRING, index, 0); // Delete the old word
  857.                                               editWord(dictionary, wordToEdit, newWord, newDefinition);
  858.                                               listWords(dictionary, words);
  859.                                               updateListBox(hwnd, words);
  860.                                               for (int i = 0; i < words.size(); i++) {
  861.                                                   if (words[i] == newWord) {
  862.                                                       SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_SETCURSEL, i, 0); // Select the edited word
  863.                                                       break;
  864.                                                   }
  865.                                               }
  866.                                               serializeDictionary(dictionary, L"myDictionary99x.txt");
  867.                                           }
  868.                                           break;
  869.                                       }
  870.                                       current = current->next;
  871.                                   }
  872.                                   if (!current) {
  873.                                       MessageBox(hwnd, L"Word not found in the dictionary.", L"Error", MB_OK | MB_ICONERROR);
  874.                                   }
  875.                               }
  876.                               return TRUE;
  877.                           }*/
  878.  
  879.         case IDC_VIEW_DEFINITION: {
  880.             int index = SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETCURSEL, 0, 0);
  881.             if (index != LB_ERR) {
  882.                 wchar_t word[256];
  883.                 SendDlgItemMessage(hwnd, IDC_LISTBOX, LB_GETTEXT, index, (LPARAM)word);
  884.                 Node* current = dictionary;
  885.                 while (current) {
  886.                     if (current->data.word == word) {
  887.                         DisplayDefinition(hwnd, current->data.word, current->data.definition);
  888.                         break;
  889.                     }
  890.                     current = current->next;
  891.                 }
  892.             }
  893.             return TRUE;
  894.         }
  895.  
  896.         case IDC_SEARCH_INPUT: {
  897.             if (HIWORD(wParam) == EN_CHANGE) {
  898.                 wchar_t query[256];
  899.                 GetDlgItemText(hwnd, IDC_SEARCH_INPUT, query, 256);
  900.                 if (wcslen(query) == 0) {
  901.                     updateListBox(hwnd, words);
  902.                 }
  903.                 else {
  904.                     vector<wstring> suggestions;
  905.                     searchWordRealtime(dictionary, query, suggestions);
  906.                     updateListBox(hwnd, suggestions);
  907.                 }
  908.             }
  909.             return TRUE;
  910.         }
  911.  
  912.         case IDC_CLEAR_SEARCH: {
  913.             SetDlgItemText(hwnd, IDC_SEARCH_INPUT, L"");
  914.             updateListBox(hwnd, words);
  915.             return TRUE;
  916.         }
  917.  
  918.                              //Prune Functions
  919.         case IDC_PRUNE: {
  920.             int result = MessageBox(hwnd, L"Are you sure you want to prune the list and remove duplicates?", L"Confirm Prune", MB_YESNO | MB_ICONQUESTION);
  921.             if (result == IDYES) {
  922.                 int duplicatesRemoved = pruneDictionary(dictionary);
  923.                 updateDictionaryAfterPrune(dictionary, words, hwnd);
  924.  
  925.                 wstring message = L"Pruning complete. ";
  926.                 message += to_wstring(duplicatesRemoved);
  927.                 message += L" duplicate entries were removed.";
  928.                 MessageBox(hwnd, message.c_str(), L"Prune Results", MB_OK | MB_ICONINFORMATION);
  929.             }
  930.             return TRUE;
  931.         }
  932.  
  933.         case WM_TIMER:
  934.             if (wParam == 1) {
  935.                 if (GetAsyncKeyState(VK_RETURN) & 0x8000) {
  936.                     AddWordToList(hwnd);
  937.                     KillTimer(hwnd, 1);
  938.                     SetTimer(hwnd, 1, 10, NULL);  // Restart the timer
  939.                 }
  940.             }
  941.             break;
  942.             /*case IDC_WORD_INPUT:
  943.             case IDC_DEFINITION_INPUT:
  944.                 if (HIWORD(wParam) == EN_SETFOCUS) {
  945.                     hFocusedEdit = (HWND)lParam;
  946.                 }
  947.                 break;
  948.                 //}
  949.                 //break;
  950.  
  951.                     case WM_KEYDOWN:
  952.                 if (wParam == VK_RETURN) {
  953.                     HWND focusedControl = GetFocus();
  954.                     if (focusedControl == hWordEdit || focusedControl == hDefinitionEdit) {
  955.                         SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDC_ADD_WORD, BN_CLICKED), 0);
  956.                         return TRUE;
  957.                     }
  958.                 }
  959.                 break;*/
  960.  
  961.         case IDCANCEL:
  962.             DestroyWindow(hwnd);
  963.             PostQuitMessage(0);
  964.             return TRUE;
  965.         }
  966.         break;
  967.  
  968.     case WM_KEYDOWN:
  969.         if (wParam == VK_ESCAPE) {
  970.             // Check for Cancel button
  971.             if (GetDlgItem(hwnd, IDCANCEL)) {
  972.                 SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), 0);
  973.                 return TRUE;
  974.             }
  975.             // Check for No button
  976.             else if (GetDlgItem(hwnd, IDNO)) {
  977.                 SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDNO, 0), 0);
  978.                 return TRUE;
  979.             }
  980.             // For dialogs with only a close button (like View Definition)
  981.             else {
  982.                 SendMessage(hwnd, WM_CLOSE, 0, 0);
  983.                 return TRUE;
  984.             }
  985.         }
  986.         //break;
  987.         /*if (wParam == VK_ESCAPE) {
  988.             if (GetDlgItem(hwnd, IDCANCEL)) {
  989.             SendMessage(hwnd, WM_COMMAND, MAKEWPARAM(IDCANCEL, 0), 0);
  990.             return TRUE;
  991.         }
  992.     }
  993.         break;*/
  994.         if (wParam == VK_F1) {
  995.             HWND hListBox = GetDlgItem(hwnd, IDC_LISTBOX);
  996.             int selectedIndex = SendMessage(hListBox, LB_GETCURSEL, 0, 0);
  997.             if (selectedIndex != LB_ERR) {
  998.                 wchar_t selectedWord[256];
  999.                 SendMessage(hListBox, LB_GETTEXT, selectedIndex, (LPARAM)selectedWord);
  1000.                 Node* current = dictionary;
  1001.                 while (current) {
  1002.                     if (current->data.word == selectedWord) {
  1003.                         DisplayDefinition(hwnd, current->data.word, current->data.definition);
  1004.                         break;
  1005.                     }
  1006.                     current = current->next;
  1007.                 }
  1008.             }
  1009.             return TRUE;
  1010.         }
  1011.         break;
  1012.  
  1013.     case WM_GETDLGCODE:
  1014.         if (wParam == VK_ESCAPE) {
  1015.             return DLGC_WANTALLKEYS;
  1016.         }
  1017.         if (wParam == VK_F1) {
  1018.             return DLGC_WANTALLKEYS | DLGC_WANTCHARS;
  1019.         }
  1020.         break;
  1021.  
  1022.     case WM_SHOWWINDOW:
  1023.         if (wParam == TRUE) {  // Only set focus when the window is shown
  1024.             SetFocus(GetDlgItem(hwnd, IDC_SEARCH_INPUT));
  1025.         }
  1026.         return 0;
  1027.  
  1028.     /*case WM_DESTROY:
  1029.         // In your cleanup or WM_DESTROY handling
  1030.         UnhookWindowsHookEx(g_hHook);
  1031.         DestroyWindow(hwnd);
  1032.         PostQuitMessage(0);*/
  1033.  
  1034.     case WM_CLOSE:
  1035.         if (g_hHook) {
  1036.             UnhookWindowsHookEx(g_hHook);
  1037.         }
  1038.         DestroyWindow(hwnd);
  1039.         PostQuitMessage(0);
  1040.         return TRUE;
  1041.     }
  1042.    
  1043.     return FALSE;
  1044. }
  1045.  
  1046. int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPWSTR lpCmdLine, int nCmdShow) {
  1047.     HWND hDlg = CreateDialogParam(hInstance, MAKEINTRESOURCE(IDD_MAINDIALOG), 0, DialogProc, 0);
  1048.     if (!hDlg) {
  1049.         MessageBox(NULL, L"Failed to create dialog", L"Error", MB_ICONERROR | MB_OK);
  1050.         return 1;
  1051.     }
  1052.  
  1053.     // Retrieve screen dimensions
  1054.     RECT desktop;
  1055.     const HWND hDesktop = GetDesktopWindow();
  1056.     GetWindowRect(hDesktop, &desktop);
  1057.  
  1058.     // Retrieve window dimensions
  1059.     RECT windowRect;
  1060.     GetWindowRect(hDlg, &windowRect);
  1061.     int windowWidth = windowRect.right - windowRect.left;
  1062.     int windowHeight = windowRect.bottom - windowRect.top;
  1063.  
  1064.     // Calculate position to center the window
  1065.     int posX = (desktop.right / 2) - (windowWidth / 2);
  1066.     int posY = (desktop.bottom / 2) - (windowHeight / 2);
  1067.  
  1068.     // Set window position
  1069.     SetWindowPos(hDlg, NULL, posX, posY, 0, 0, SWP_NOZORDER | SWP_NOSIZE);
  1070.  
  1071.     ShowWindow(hDlg, nCmdShow);
  1072.  
  1073.     MSG msg;
  1074.     BOOL bRet;
  1075.     while ((bRet = GetMessage(&msg, nullptr, 0, 0)) != 0) {
  1076.         if (bRet == -1) {
  1077.             // Handle the error and possibly exit
  1078.             break;
  1079.         }
  1080.         else if (!IsWindow(hDlg) || !IsDialogMessage(hDlg, &msg)) {
  1081.             TranslateMessage(&msg);
  1082.             DispatchMessage(&msg);
  1083.         }
  1084.     }
  1085.  
  1086.     return (int)msg.wParam;
  1087. }
  1088.  
  1089. ==++"Resource2.rc" File 2/3 SourceCode++==::
  1090. #include <windows.h>
  1091. #include "resource2.h"
  1092.  
  1093. IDD_MAINDIALOG DIALOGEX 0, 0, 320, 240
  1094. STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
  1095. CAPTION "Dictionary Application (F1=QuickViewToggle)"
  1096. FONT 8, "MS Shell Dlg", 400, 0, 0x1
  1097. BEGIN
  1098. LTEXT           "Word:", -1, 10, 10, 30, 8
  1099. EDITTEXT        IDC_WORD_INPUT, 50, 8, 100, 14, ES_AUTOHSCROLL | WS_TABSTOP
  1100. LTEXT           "Definition:", -1, 10, 30, 40, 8
  1101. EDITTEXT        IDC_DEFINITION_INPUT, 50, 28, 200, 14, ES_AUTOHSCROLL | WS_TABSTOP
  1102. PUSHBUTTON      "Add Word", IDC_ADD_WORD, 260, 8, 50, 14
  1103. PUSHBUTTON      "Delete Word", IDC_DELETE_WORD, 260, 28, 50, 14
  1104. PUSHBUTTON      "Edit Word", IDC_EDIT_WORD, 260, 48, 50, 14
  1105. PUSHBUTTON      "View Definition", IDC_VIEW_DEFINITION, 205, 8, 55, 14
  1106. PUSHBUTTON      "Prune", IDC_PRUNE, 160, 8, 25, 14
  1107. PUSHBUTTON      "Clear", IDC_CLEAR_SEARCH, 185, 8, 20, 14
  1108. LTEXT           "Search:", -1, 10, 50, 30, 8
  1109. EDITTEXT        IDC_SEARCH_INPUT, 50, 48, 200, 14, ES_AUTOHSCROLL
  1110. LISTBOX         IDC_LISTBOX, 10, 70, 300, 160, LBS_SORT | LBS_NOINTEGRALHEIGHT | WS_VSCROLL
  1111. END
  1112.  
  1113. IDD_INPUT DIALOGEX 0, 0, 250, 120
  1114. STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
  1115. CAPTION "Input"
  1116. FONT 8, "MS Shell Dlg", 400, 0, 0x1
  1117. BEGIN
  1118. LTEXT           "Input:", -1, 7, 14, 50, 8
  1119. EDITTEXT        IDC_INPUT, 7, 30, 230, 65, ES_MULTILINE | ES_AUTOVSCROLL | WS_VSCROLL
  1120. DEFPUSHBUTTON   "OK", IDOK, 70, 100, 50, 14
  1121. PUSHBUTTON      "Cancel", IDCANCEL, 130, 100, 50, 14
  1122. END
  1123. //20->65 (EditText last value), 60->100 (DefPushButton second value), 60->100 (PushButton second value) Only ES_AUTOHSCROLL (in EditText)
  1124.  
  1125. IDD_DEFINITION DIALOGEX 0, 0, 300, 200
  1126. STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
  1127. CAPTION "Definition"
  1128. FONT 8, "MS Shell Dlg"
  1129. BEGIN
  1130. EDITTEXT        IDC_DEFINITION_EDIT, 7, 7, 286, 186, ES_MULTILINE | ES_AUTOVSCROLL | ES_READONLY | WS_VSCROLL
  1131. END
  1132.  
  1133. /*IDD_INPUT DIALOGEX 0, 0, 200, 100
  1134. STYLE DS_SETFONT | DS_MODALFRAME | DS_FIXEDSYS | WS_POPUP | WS_CAPTION | WS_SYSMENU
  1135. CAPTION "Input"
  1136. FONT 8, "MS Shell Dlg"
  1137. BEGIN
  1138. LTEXT           "Input:", -1, 7, 14, 50, 8
  1139. EDITTEXT        IDC_INPUT, 7, 24, 186, 12, ES_AUTOHSCROLL
  1140. DEFPUSHBUTTON   "OK", IDOK, 139, 7, 50, 14
  1141. PUSHBUTTON      "Cancel", IDCANCEL, 139, 24, 50, 14
  1142. END*/
  1143.  
  1144. //EDITTEXT        IDC_WORD_INPUT, 50, 8, 100, 14, ES_AUTOHSCROLL
  1145. //PUSHBUTTON      "Add Word", IDC_ADD_WORD, 260, 8, 50, 14
  1146. //PUSHBUTTON      "View Definition", IDC_VIEW_DEFINITION, 260, 68, 50, 14
  1147.  
  1148. ==++"resource2.h"++== File 3/3 SourceCode::
  1149. #ifndef RESOURCE2_H
  1150. #define RESOURCE2_H
  1151.  
  1152. #define IDD_MAINDIALOG                  101
  1153. #define IDC_WORD_INPUT                  1001
  1154. #define IDC_DEFINITION_INPUT            1002
  1155. #define IDC_ADD_WORD                    1003
  1156. #define IDC_DELETE_WORD                 1004
  1157. #define IDC_SEARCH_INPUT                1005
  1158. #define IDC_LISTBOX                     1006
  1159. #define IDC_INPUT                       1007  // Add this line if you're using IDC_INPUT
  1160. #define IDC_EDIT_WORD                   1008
  1161. #define IDC_VIEW_DEFINITION             1009
  1162. #define IDD_INPUT                       1010
  1163. #define IDD_DEFINITION                  1011
  1164. #define IDC_DEFINITION_EDIT             1012
  1165. #define IDC_CLEAR_SEARCH                1013
  1166. #define IDC_PRUNE                       1014
  1167.  
  1168. #endif // RESOURCE2_H
  1169.  
Tags: #multifile
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!