जीयूआई आवेदन 1 केबी से छोटा है

अवकाश के समय, मैंने स्वयं से निम्नलिखित आवश्यकताओं के साथ एक एप्लिकेशन बनाने की संभावना पूछी:

• कम से कम कुछ उपयोगी एप्लिकेशन फ़ंक्शन (जो डमी नहीं है)
• एक विंडो इंटरफ़ेस की उपस्थिति
• आकार 1 Kb से कम है

सामान्य तौर पर, 1 Kb तक के आकार के साथ आवेदन मानक 1k इंट्रो होता है, जो एक प्रकार का डिमोसिन है। सबसे अधिक बार, यह ओपनजीएल के असेंबलर इनिशियलाइज़ेशन में लिखा गया है और फिर इसे एक शेडर खिलाया जाता है, जो मुख्य काम करता है (कुछ रंगीन फ्रैक्टल खींचता है)। इसके अलावा यह सब पैकर (उदाहरण के लिए क्रिंकर) द्वारा लिया जाता है।
इन अनुप्रयोगों को सचमुच एक बाइट के लिए पाला जाता है, उनके विकास में सप्ताह और यहां तक ​​कि महीने लगते हैं।

यह दृष्टिकोण बहुत कठोर है, मैंने WinAPI पर सामान्य अनुप्रयोग प्रोग्रामिंग से आगे नहीं जाने का फैसला किया।

इस समय, स्टीम पर एक गर्मियों की बिक्री शुरू हुई, जहां वयस्कों को ब्राउज़र में माउस के साथ बुद्धिमानी से लुभाने के लिए आमंत्रित किया गया था (हाँ, वाल्व फिर से गेम बनाता है, जैसा कि गैब ने वादा किया था)।
इसने मुझे कोर से नाराज कर दिया, और मैंने न्यूनतम सेटिंग्स के साथ सबसे सरल आटोक्लीकर को लागू करने का प्रयास करने का फैसला किया।

1 KB में फिट होने के लिए आवश्यक:

• इंटरफ़ेस निर्माण और आरंभीकरण
• घटना संचालकों के साथ विंडो फ़ंक्शन
• मुख्य अनुप्रयोग तर्क (GetAsyncKeyState और SendInput कार्यों पर निर्मित)

एप्लिकेशन को कोडांतरक और एसएमएस के बिना शुद्ध सी में MSVC में बनाया जाएगा, और फिर क्रिंकर पैकर के साथ संपीड़ित किया जाएगा। यह ध्यान दिया जाना चाहिए कि crinkler कोड (लगभग दो बार) की तुलना में बहुत अधिक कुशलता से डेटा (विशेष रूप से दुर्लभ) को संपीड़ित करता है। इसलिए, हम डेटा में अधिकतम कार्यक्षमता को स्थानांतरित करने का प्रयास करेंगे।

प्रत्येक विंडो तत्व के लिए क्लासिक CreateWindow से शुरू करके, मैंने महसूस किया कि मैं आवश्यक आकार में फिट नहीं हो सकता।

मुझे विकल्प की तलाश करनी थी। और वह फ़ंक्शन CreateDialogIndirect बन गई, भरे हुए DLGTEMPLATE संरचना से एक संवाद बना (जिसमें ढेर DLGITEMTEMPLATE शामिल है)

सुविधाजनक निर्माण और संरचना को भरने के लिए, मैंने इनकी तरह कुछ मैक्रोज़ शुरू किए:

#define NUMCHARS(p) (sizeof(p)/sizeof((p)[0])) #define DLGCTL(a) struct{DWORD style; DWORD exStyle; short x; short y; short cx; short cy; WORD id; WORD sysClass; WORD idClass; WCHAR wszTitle[NUMCHARS(a)]; WORD cbCreationData;} #define RADIO(x,y,cx,cy,id,title) {WS_VISIBLE|WS_CHILD|BS_RADIOBUTTON, 0, (x)/2, (y)/2,\n (cx)/2,(cy)/2, id, 0xFFFF, 0x0080, title, 0} 

अब आप भविष्य की खिड़की के तत्वों के साथ संरचना को घोषित और भर सकते हैं:

 static struct { DWORD style; DWORD dwExtendedStyle; WORD ccontrols; short x; short y; short cx; short cy; WORD menu; WORD windowClass; DLGCTL(LBL_BTN_LEFT) button_left; DLGCTL(LBL_BTN_MIDDLE) button_middle; DLGCTL(LBL_BTN_RIGHT) button_right; } Dlg = { WS_VISIBLE|WS_POPUP|WS_BORDER, 0, TOTAL_CONTROLS, 50/2, 50/2, WND_CX/2, WND_CY/2, 0, 0, RADIO(10, 0, 80, 30, IDC_BTN_LEFT, LBL_BTN_LEFT), RADIO(100, 0, 80, 30, IDC_BTN_MIDDLE, LBL_BTN_MIDDLE), RADIO(190, 0, 68, 30, IDC_BTN_RIGHT, LBL_BTN_RIGHT), }; 

हम CreateDialogIndirect फ़ंक्शन की संरचना को फ़ीड करते हैं, और यहां परिणामी विंडो है:



चूँकि हम 1 kb में फिट होते हैं, इसलिए हमारे पास सब कुछ की तरह एक प्रकट रूप नहीं है, और इसलिए कोई दृश्य शैली भी नहीं है। सब कुछ ग्रे और स्क्वायर है, जैसा कि युवाओं में है।

लेकिन हम अभी भी चकमा देते हैं, shell32.dll से प्रकट को खींचते हैं और इसके आधार पर संदर्भ को हमारे आवेदन पर लागू करते हैं:

 static ACTCTX actCtx = {sizeof(ACTCTX), ACTCTX_FLAG_RESOURCE_NAME_VALID|ACTCTX_FLAG_SET_PROCESS_DEFAULT|ACTCTX_FLAG_ASSEMBLY_DIRECTORY_VALID, "shell32.dll", 0, 0, tmp, (LPCTSTR)124, 0, 0}; GetSystemDirectory(tmp,sizeof(tmp)); LoadLibrary("shell32.dll"); ActivateActCtx(CreateActCtx(&actCtx),(ULONG_PTR*)&tmp); 

यह पहले से ही स्टाइलिश, फैशनेबल है:



हम विंडो फ़ंक्शन को काफी कॉम्पैक्ट करने के लिए सिकोड़ने में कामयाब रहे:

 switch(msg) { case WM_COMMAND: switch(LOWORD(wParam)) { case IDC_BTN_LEFT: case IDC_BTN_MIDDLE: case IDC_BTN_RIGHT: input[0].mi.dwFlags = wParam; input[1].mi.dwFlags = (wParam<<1); CheckRadioButton(hWnd,IDC_BTN_LEFT,IDC_BTN_MIDDLE,wParam); break; case IDC_BTN_HOLD: case IDC_BTN_TRIGGER: trigger_mode = (wParam==IDC_BTN_TRIGGER); CheckRadioButton(hWnd,IDC_BTN_HOLD,IDC_BTN_TRIGGER,wParam); break; case IDC_EDIT_PERIOD: period = GetDlgItemInt(hWnd,IDC_EDIT_PERIOD,(BOOL*)&tmp[0],0); break; case IDC_BTN_EXIT: exit(0); } break; } return DefWindowProc(hWnd,msg,wParam,lParam); 

और फिर मैंने सोचा कि कमांड लाइन तर्कों के प्रसंस्करण को जोड़ना अच्छा होगा ताकि उपयोगकर्ता को आवश्यक सेटिंग्स के साथ शुरू करने का अवसर मिले।

उदाहरण के लिए:

input.exe /L /T /P:20 /K:9 - 20 , / Tab

डेटा के अंदर कार्यक्षमता का हिस्सा स्थानांतरित करें और कुछ प्राप्त करें:

 static unsigned int arg_to_cmd[] = {IDC_BTN_HOLD, 0, 0, IDC_EDIT_KEY, IDC_BTN_LEFT, IDC_BTN_MIDDLE, 0, 0, IDC_EDIT_PERIOD, 0, IDC_BTN_RIGHT, 0, IDC_BTN_TRIGGER}; i = (char*)GetCommandLine(); while(*i) { if (*(i++)=='/')//looking for argument switch(*i) { case 'L': case 'M': case 'R': case 'H': case 'T': SendMessage(hWnd,WM_COMMAND,arg_to_cmd[*i-'H'],0);//send button command break; case 'P': case 'K': t = atoi(i+2); SetDlgItemInt(hWnd,arg_to_cmd[*i-'H'],t,0); if(*i=='P') period = t; else key = t; break; } } 

हैंडलर बहुत छोटा निकला। स्वाभाविक रूप से, गलत इनपुट के खिलाफ कोई जांच और सुरक्षा, केवल आवश्यक न्यूनतम नहीं।

अब मुख्य कार्यक्षमता (मैंने इसे एक अलग स्ट्रीम में रखा है):

 while(1) { key_state = (GetAsyncKeyState(key)>>1); if (trigger_mode) { if ((key_state)&&(key_state!=prev_key_state)) active^= 1; prev_key_state = key_state; } else active = key_state; if (active) SendInput(2,(LPINPUT)&input,sizeof(INPUT)); Sleep(period); } 

हम परिणामस्वरूप ओबज-फाइल crinkler'om दबाते हैं - आउटपुट 973 बाइट्स है।

इनमें से, डेटा 163 बाइट्स (संपीड़न अनुपात 33.1%), कोड - 517 बाइट्स (संपीड़न अनुपात 68.9%) पर है।

सिकुड़ना और मजबूत करना संभव है (एक और 50 बाइट्स), लेकिन लक्ष्य पहले ही हासिल किया जा चुका है। यहां तक ​​कि 51 स्पेयर बाइट्स भी रहे।

जिस तरह से साथ प्रारंभिक आवश्यकताओं को जोड़ा गया था:

• कमांड लाइन तर्क को संसाधित करना
• दृश्य शैलियों के साथ एक विंडो प्रदर्शित करना

कुछ जगहों पर कोड बहुत टेढ़े लगते हैं। ऐसा इसलिए है क्योंकि मैंने इसे टेढ़ा लिखा है। और कुछ स्थानों पर इसने अंतरिक्ष को बचाने की अनुमति दी।

निश्चित रूप से आप आवेदन के आकार को कम करने के लिए कुछ और तरीकों के साथ आ सकते हैं, लेकिन नाटकीय रूप से नहीं (मुझे लगता है कि बाइट 50 है)।

परिणाम:

अब आप प्रति सेकंड जंगली क्षति के साथ स्वचालित मोड में एलियंस को बाहर कर सकते हैं।

वास्तव में उपयोग की जाने वाली उपयोगी कार्यक्षमता और एक विंडो इंटरफ़ेस के साथ अल्ट्रा-कॉम्पैक्ट एप्लिकेशन बनाना संभव है।

नवीनता:
शून्य। मैंने एक साथ तकनीकों / विकास का एक समूह रखा।

औचित्य:
बेकार, के लिए मज़ा।

स्रोत कोड
बाइनरी

स्वीकार की गई आलोचना, इच्छाएं, सुझाव, प्रशंसा, आक्रोश।