സലീം ഗുൽ, തോമസ് പാവക് എന്നിവർ സംഭാവന നൽകി

ഈ ട്യൂട്ടോറിയൽ ഒരു ലളിതമായ ഗ്രാഫിക്കൽ ഉപയോക്തൃ ഇൻ്റർഫേസ് സൃഷ്ടിക്കുന്നതും അതിലേക്ക് ലളിതമായ സെർവർ-സൈഡ് പ്രവർത്തനം ചേർക്കുന്നതും ഉൾക്കൊള്ളുന്നു. പ്രത്യേകിച്ചും, ഒരു സ്വിംഗ് ഫോമിലെ ബട്ടണുകളുടെയും ഫീൽഡുകളുടെയും സ്വഭാവം നിർവചിക്കുന്ന കോഡ് ഞങ്ങൾ നോക്കാം.

ഞങ്ങൾ GUI-യുടെ ലേഔട്ടും ഘടനയും നോക്കും, തുടർന്ന് ചില ബട്ടണുകളും ടെക്സ്റ്റ് ഫീൽഡുകളും ചേർക്കുക. ഉപയോക്താവ് നൽകിയ വിവരങ്ങൾ സ്വീകരിക്കുന്നതിനും പ്രോഗ്രാമിൻ്റെ ഫലം പ്രദർശിപ്പിക്കുന്നതിനുമാണ് ടെക്സ്റ്റ് ഫീൽഡുകൾ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്. പ്രോഗ്രാമിൻ്റെ ക്ലയൻ്റ് ഭാഗത്ത് നിർമ്മിച്ച ഫംഗ്ഷനുകളുടെ പ്രവർത്തനം ബട്ടൺ ആരംഭിക്കും. നിങ്ങൾ സൃഷ്ടിക്കുന്ന ആപ്ലിക്കേഷൻ ലളിതവും എന്നാൽ പൂർണ്ണമായും പ്രവർത്തനക്ഷമവുമായ കാൽക്കുലേറ്ററാണ്.

വിവിധ വികസന സവിശേഷതകളുടെ വീഡിയോ പ്രദർശനങ്ങൾ ഉൾപ്പെടെ, GUI ഡിസൈനർ ഡെവലപ്‌മെൻ്റ് ഫീച്ചറുകളിലേക്കുള്ള കൂടുതൽ വിശദമായ ഗൈഡിനായി, കാണുക.

കണക്കാക്കിയ ദൈർഘ്യം: 20 മിനിറ്റ്

വ്യായാമം 1: ഒരു പ്രോജക്റ്റ് സൃഷ്ടിക്കുന്നു

നിങ്ങൾ വികസിപ്പിക്കുന്ന ആപ്ലിക്കേഷനായി ഒരു IDE പ്രോജക്റ്റ് സൃഷ്ടിക്കുക എന്നതാണ് ആദ്യപടി. പദ്ധതിക്ക് നമ്പർ അഡിഷൻ എന്ന് പേരിടാം.

1. ഫയൽ > പുതിയ പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക. നിങ്ങൾക്ക് IDE ടൂൾബാറിലെ പുതിയ പ്രോജക്റ്റ് ഐക്കണിലും ക്ലിക്ക് ചെയ്യാം.
2. വിഭാഗങ്ങൾ ഏരിയയിൽ, ജാവ നോഡ് തിരഞ്ഞെടുക്കുക. "പ്രോജക്‌റ്റുകൾ" ഏരിയയിൽ, "ജാവ ആപ്ലിക്കേഷൻ" തിരഞ്ഞെടുക്കുക. "അടുത്തത്" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.
3. പ്രോജക്റ്റ് നെയിം ഫീൽഡിൽ NumberAddition നൽകുക, പ്രോജക്റ്റ് ലൊക്കേഷനായി നിങ്ങളുടെ ഹോം ഡയറക്ടറി പോലുള്ള ഒരു പാത്ത് വ്യക്തമാക്കുക.
4. "ലൈബ്രറികൾ സംഭരിക്കുന്നതിന് ഒരു പ്രത്യേക ഫോൾഡർ ഉപയോഗിക്കുക" ചെക്ക്ബോക്സ് തിരഞ്ഞെടുത്ത് ലൈബ്രറികളുടെ ഫോൾഡറിൻ്റെ സ്ഥാനം വ്യക്തമാക്കുക (ഓപ്ഷണൽ). കൂടുതൽ വിവരങ്ങൾക്ക്, ഒരു പ്രമാണത്തിൽ മറ്റുള്ളവരുമായി ഒരു ലൈബ്രറി പങ്കിടുക കാണുക NetBeans IDE ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുന്നു.
5. "മെയിൻ ക്ലാസ് സൃഷ്ടിക്കുക" ചെക്ക്ബോക്സ് ചെക്ക് ചെയ്തിട്ടുണ്ടെങ്കിൽ അത് നീക്കം ചെയ്യുക.
6. "പൂർത്തിയായി" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.

വ്യായാമം 2: ഫ്രണ്ട് എൻഡ് സൃഷ്ടിക്കുന്നു

ഇൻ്റർഫേസ് സൃഷ്‌ടിക്കൽ പ്രക്രിയ തുടരുന്നതിന്, ആവശ്യമായ മറ്റ് GUI ഘടകങ്ങൾ സ്ഥാപിക്കുന്ന ഒരു ജാവ കണ്ടെയ്‌നർ നിങ്ങൾ സൃഷ്‌ടിക്കേണ്ടതുണ്ട്. ഈ പ്രവർത്തനത്തിൽ, ഒരു JFrame ഘടകം ഉപയോഗിച്ച് ഒരു കണ്ടെയ്നർ സൃഷ്ടിക്കപ്പെടും. കണ്ടെയ്നർ ഒരു പുതിയ പാക്കേജിൽ സ്ഥാപിക്കും, അത് "ഉറവിട പാക്കേജുകൾ" നോഡിൽ ദൃശ്യമാകും.

ഒരു JFrame കണ്ടെയ്നർ സൃഷ്ടിക്കുന്നു

1. പ്രോജക്റ്റ് വിൻഡോയിൽ, നമ്പർ അഡിഷൻ നോഡിൽ വലത്-ക്ലിക്കുചെയ്ത് പുതിയത് > മറ്റുള്ളവ തിരഞ്ഞെടുക്കുക.
2. ഫയൽ സൃഷ്ടിക്കുക ഡയലോഗ് ബോക്സിൽ, Swing GUI ഫോമുകൾ വിഭാഗവും JFrame ഫോം ഫയൽ തരവും തിരഞ്ഞെടുക്കുക. "അടുത്തത്" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.
3. ക്ലാസ് നാമമായി NumberAdditionUI നൽകുക.
4. my.numberaddition പാക്കേജ് തിരഞ്ഞെടുക്കുക.
5. "പൂർത്തിയായി" ബട്ടൺ ക്ലിക്ക് ചെയ്യുക.

IDE, NumberAdditionUI ഫോമും NumberAdditionUI ക്ലാസും NumberAddition ആപ്ലിക്കേഷനിൽ സൃഷ്ടിക്കുകയും GUI ബിൽഡറിൽ NumberAdditionUI ഫോം തുറക്കുകയും ചെയ്യുന്നു. my.NumberAddition പാക്കേജ് ഡിഫോൾട്ട് പാക്കേജിനെ മാറ്റിസ്ഥാപിക്കുന്നു.

ഘടകങ്ങൾ ചേർക്കുന്നു: ഒരു ഫ്രണ്ട് എൻഡ് സൃഷ്ടിക്കുന്നു

അടുത്തതായി, "പാലറ്റ്" വിൻഡോ ഉപയോഗിച്ച്, ആപ്ലിക്കേഷൻ്റെ ബാഹ്യ ഇൻ്റർഫേസ് JPanel ഉപയോഗിച്ച് നിറഞ്ഞിരിക്കുന്നു. ഇതിനുശേഷം, മൂന്ന് JLabel ഘടകങ്ങൾ (ടെക്‌സ്റ്റ് ലേബലുകൾ), മൂന്ന് JTextField ഘടകങ്ങൾ (ടെക്‌സ്റ്റ് ഫീൽഡുകൾ), മൂന്ന് JButton ഘടകങ്ങൾ (ബട്ടണുകൾ) എന്നിവ ചേർക്കുന്നു. നിങ്ങൾ മുമ്പ് GUI ഡിസൈനറുമായി പ്രവർത്തിച്ചിട്ടില്ലെങ്കിൽ, ഘടക പ്ലെയ്‌സ്‌മെൻ്റിനെക്കുറിച്ചുള്ള വിവരങ്ങൾക്ക് NetBeans IDE-ൽ ഒരു സ്വിംഗ് GUI രൂപകൽപ്പന ചെയ്യുന്നത് കാണുക.

മുകളിലെ ഘടകങ്ങൾ വലിച്ചിട്ട് സ്ഥാപിച്ച ശേഷം, JFrame ഘടകം ചുവടെയുള്ള ചിത്രം പോലെയായിരിക്കണം.

IDE-യുടെ മുകളിൽ വലത് കോണിൽ പാലറ്റ് വിൻഡോ ഇല്ലെങ്കിൽ, വിൻഡോ > പാലറ്റ് തിരഞ്ഞെടുക്കുക.

1. ആരംഭിക്കുന്നതിന്, പാലറ്റിലെ സ്വിംഗ് കണ്ടെയ്‌നേഴ്‌സ് വിഭാഗത്തിൽ നിന്ന് ഒരു പാനൽ തിരഞ്ഞെടുത്ത് അത് JFrame-ലേക്ക് വലിച്ചിടുക.
2. JPanel ഹൈലൈറ്റ് ചെയ്യും. ഒരു ബോർഡർ ശൈലി തിരഞ്ഞെടുക്കുന്നതിന് പ്രോപ്പർട്ടീസ് വിൻഡോയിലേക്ക് പോയി ബോർഡർ ഫീൽഡിന് അടുത്തുള്ള എലിപ്‌സ് ബട്ടൺ (...) ക്ലിക്ക് ചെയ്യുക.
3. ബോർഡർ ഡയലോഗ് ബോക്സിൽ, ലിസ്റ്റിൽ നിന്ന് TitledBorder തിരഞ്ഞെടുത്ത് ടൈറ്റിൽ ഫീൽഡിൽ നമ്പർ കൂട്ടിച്ചേർക്കൽ നൽകുക. നിങ്ങളുടെ മാറ്റങ്ങൾ സംരക്ഷിച്ച് ഡയലോഗ് ബോക്സ് അടയ്ക്കുന്നതിന് "ശരി" ക്ലിക്ക് ചെയ്യുക.
4. സ്‌ക്രീൻ ഇപ്പോൾ ചിത്രത്തിൽ കാണിച്ചിരിക്കുന്നതുപോലെ "നമ്പർ കൂട്ടിച്ചേർക്കൽ" എന്ന തലക്കെട്ടുള്ള ഒരു ശൂന്യമായ "JFrame" ഘടകം പ്രദർശിപ്പിക്കണം. ചിത്രത്തിൽ കാണുന്നതുപോലെ, അതിൽ മൂന്ന് JLabels, മൂന്ന് JTextFields, മൂന്ന് JButtons എന്നിവ ചേർക്കുക.

മൂലകങ്ങളുടെ പേരുമാറ്റുന്നു

ഈ ഘട്ടം JFrame ഘടകത്തിലേക്ക് ചേർത്ത ഘടകങ്ങളെ പുനർനാമകരണം ചെയ്യും.

1. jLabel1-ൽ ഇരട്ട-ക്ലിക്കുചെയ്ത് ntrcn ("ടെക്സ്റ്റ്" പ്രോപ്പർട്ടി) ആദ്യ നമ്പറിലേക്ക് മാറ്റുക.
2. jLabel2-ൽ ഡബിൾ ക്ലിക്ക് ചെയ്ത് ടെക്സ്റ്റ് രണ്ടാം നമ്പറിലേക്ക് മാറ്റുക.
3. jLabel3-ൽ ഡബിൾ ക്ലിക്ക് ചെയ്ത് വാചകം ഫലത്തിലേക്ക് മാറ്റുക.
4. jTextField1-ൽ നിന്ന് ഡിഫോൾട്ട് ടെക്സ്റ്റ് നീക്കം ചെയ്യുക. പ്രദർശിപ്പിച്ച വാചകം എഡിറ്റ് ചെയ്യാവുന്ന വാചകമായി പരിവർത്തനം ചെയ്യാവുന്നതാണ്. ഇത് ചെയ്യുന്നതിന്, ടെക്സ്റ്റ് ഫീൽഡിൽ വലത്-ക്ലിക്കുചെയ്ത് പോപ്പ്-അപ്പ് മെനുവിൽ നിന്ന് "എഡിറ്റ് ടെക്സ്റ്റ്" തിരഞ്ഞെടുക്കുക. ഇതിന് നിങ്ങൾ jTextField1 അതിൻ്റെ യഥാർത്ഥ വലുപ്പത്തിലേക്ക് പുനഃസ്ഥാപിക്കേണ്ടതുണ്ട്. jTextField2, jTextField3 ഫീൽഡുകൾക്കായി ഈ ഘട്ടം ആവർത്തിക്കുക.
5. jButton1-ൻ്റെ ഡിസ്പ്ലേ ടെക്സ്റ്റ് ക്ലിയർ എന്നതിലേക്ക് മാറ്റുക. (ഒരു ബട്ടണിൻ്റെ ടെക്‌സ്‌റ്റ് മാറ്റുന്നതിന്, ബട്ടണിൽ വലത്-ക്ലിക്കുചെയ്ത് ടെക്‌സ്‌റ്റ് എഡിറ്റുചെയ്യുക തിരഞ്ഞെടുക്കുക. പകരമായി, നിങ്ങൾക്ക് ബട്ടണിൽ ക്ലിക്കുചെയ്‌ത് താൽക്കാലികമായി നിർത്തി വീണ്ടും ക്ലിക്കുചെയ്യുക.)
6. jButton2-ൻ്റെ ഡിസ്പ്ലേ ടെക്സ്റ്റ് ചേർക്കുക എന്നതിലേക്ക് മാറ്റുക.
7. jButton3 ൻ്റെ ഡിസ്പ്ലേ ടെക്സ്റ്റ് എക്സിറ്റിലേക്ക് മാറ്റുക.

ഇപ്പോൾ പൂർത്തിയായ GUI ചുവടെയുള്ള ചിത്രം പോലെയായിരിക്കണം:

വ്യായാമം 3: പ്രവർത്തനക്ഷമത കൂട്ടിച്ചേർക്കുന്നു

ഈ വ്യായാമം ആഡ്, ക്ലിയർ, എക്സിറ്റ് ബട്ടണുകളിലേക്ക് ആവശ്യമായ പ്രവർത്തനം ചേർക്കും. ഉപയോക്തൃ ഇൻപുട്ടിനായി jTextField1, jTextField2 എന്നീ ഫീൽഡുകൾ ഉപയോഗിക്കും, കൂടാതെ പ്രോഗ്രാമിൻ്റെ ഫലം പ്രദർശിപ്പിക്കാൻ jTextField3 ഉപയോഗിക്കും. സൃഷ്ടിച്ച പ്രോഗ്രാം ഒരു ലളിതമായ കാൽക്കുലേറ്ററാണ്. അതിനാൽ നമുക്ക് ആരംഭിക്കാം!

എക്സിറ്റ് ബട്ടണിലേക്ക് പ്രവർത്തനം ചേർക്കുന്നു

ബട്ടണുകൾ പ്രവർത്തനക്ഷമമാകുന്നതിന്, അവയിൽ ഓരോന്നിനും ഒരു ഇവൻ്റ് ഹാൻഡ്‌ലർ നൽകണം, അത് ഇവൻ്റുകളോട് പ്രതികരിക്കുന്നതിന് ഉത്തരവാദിയായിരിക്കും. ഞങ്ങളുടെ കാര്യത്തിൽ, നമ്മൾ ബട്ടൺ ക്ലിക്ക് ഇവൻ്റ് തിരിച്ചറിയേണ്ടതുണ്ട് - ഒന്നുകിൽ മൗസിൽ ക്ലിക്ക് ചെയ്യുകയോ കീബോർഡ് ഉപയോഗിക്കുകയോ ചെയ്യുക. അതിനാൽ, "ActionEvent" ഇവൻ്റുകൾ കൈകാര്യം ചെയ്യാൻ "ActionListener" ഇൻ്റർഫേസ് ഉപയോഗിക്കും.

1. "എക്സിറ്റ്" ബട്ടണിൽ വലത്-ക്ലിക്ക് ചെയ്യുക. പോപ്പ്-അപ്പ് മെനുവിൽ നിന്ന്, ഇവൻ്റുകൾ > ആക്ഷൻ > ആക്ഷൻ പെർഫോംഡ് തിരഞ്ഞെടുക്കുക. പ്രോഗ്രാമിന് പ്രതികരിക്കാൻ കഴിയുന്ന മറ്റ് നിരവധി ഇവൻ്റുകൾ മെനുവിൽ അടങ്ങിയിരിക്കുന്നുവെന്നത് ശ്രദ്ധിക്കുക! നിങ്ങൾ actionPerformed ഇവൻ്റ് തിരഞ്ഞെടുക്കുമ്പോൾ, IDE സ്വയമേവ Exit ബട്ടണിലേക്ക് ഒരു ActionListener ചേർക്കുകയും actionPerformed Lisener രീതി കൈകാര്യം ചെയ്യുന്നതിനായി ഒരു ഹാൻഡ്‌ലർ രീതി സൃഷ്ടിക്കുകയും ചെയ്യും.
2. IDE സ്വയമേവ "സോഴ്സ് കോഡ്" വിൻഡോ തുറക്കുന്നു, നിങ്ങൾ ബട്ടൺ ക്ലിക്ക് ചെയ്യുമ്പോൾ (നിങ്ങളുടെ മൗസ് അല്ലെങ്കിൽ കീബോർഡ് ഉപയോഗിച്ച്) ചെയ്യേണ്ട പ്രവർത്തനം എവിടെ ചേർക്കണമെന്ന് കാണിക്കുന്നു. "സോഴ്സ് കോഡ്" വിൻഡോയിൽ ഇനിപ്പറയുന്ന വരികൾ അടങ്ങിയിരിക്കണം: സ്വകാര്യ ശൂന്യമായ jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //നിങ്ങളുടെ ഹാൻഡലിംഗ് കോഡ് ഇവിടെ ചേർക്കുക: )
3. ഇപ്പോൾ "എക്സിറ്റ്" ബട്ടൺ നിർവഹിക്കേണ്ട പ്രവർത്തനത്തിനുള്ള കോഡ് ചേർക്കാം. System.exit(0) ഉപയോഗിച്ച് TODO ലൈൻ മാറ്റിസ്ഥാപിക്കുക; . "എക്‌സിറ്റ്" ബട്ടണിൻ്റെ പൂർത്തിയായ കോഡ് ഇതുപോലെയായിരിക്കണം: സ്വകാര്യ ശൂന്യമായ jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

"മായ്ക്കുക" ബട്ടണിലേക്ക് പ്രവർത്തനം ചേർക്കുന്നു

1. "ക്ലിയർ" ബട്ടണിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്യുക (jButton1). ദൃശ്യമാകുന്ന മെനുവിൽ നിന്ന്, "ഇവൻ്റ്സ് > ആക്ഷൻ > ആക്ഷൻ പെർഫോംഡ്" തിരഞ്ഞെടുക്കുക.
2. "മായ്ക്കുക" ബട്ടൺ ക്ലിക്കുചെയ്യുന്നത് എല്ലാ "jTextField" ടെക്‌സ്‌റ്റ് ഫീൽഡുകളിൽ നിന്നും എല്ലാ ടെക്‌സ്‌റ്റുകളും നീക്കംചെയ്യുന്നതിന് ഇടയാക്കും. ഇത് ചെയ്യുന്നതിന്, മുകളിൽ പറഞ്ഞതിന് സമാനമായ കോഡ് ചേർക്കുക. പൂർത്തിയായ സോഴ്സ് കോഡ് ഇതുപോലെ ആയിരിക്കണം: സ്വകാര്യ ശൂന്യമായ jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

ഈ കോഡ് മൂന്ന് JTextFields-ൽ നിന്നും ടെക്‌സ്‌റ്റ് നീക്കംചെയ്യുകയും അവ ശൂന്യമാക്കുകയും ചെയ്യുന്നു.

"ചേർക്കുക" ബട്ടണിലേക്ക് പ്രവർത്തനം ചേർക്കുന്നു

"ചേർക്കുക" ബട്ടൺ മൂന്ന് കാര്യങ്ങൾ ചെയ്യണം.

1. ഇത് ആദ്യം jTextField1, jTextField2 എന്നീ ഫീൽഡുകളിൽ ഉപയോക്താവിൻ്റെ ഇൻപുട്ട് എടുക്കുകയും അവയെ "സ്ട്രിംഗ്" തരത്തിൽ നിന്ന് "Float" തരത്തിലേക്ക് പരിവർത്തനം ചെയ്യുകയും ചെയ്യുന്നു.
2. അത് പിന്നീട് രണ്ട് സംഖ്യകളുടെ കൂട്ടിച്ചേർക്കൽ നിർവഹിക്കും.
3. അവസാനമായി, ഇത് തുകയെ ഒരു സ്‌ട്രിംഗിലേക്ക് പരിവർത്തനം ചെയ്‌ത് jTextField3-ൽ സ്ഥാപിക്കും.

നമുക്ക് തുടങ്ങാം!

1. ഫോം ഡിസൈൻ സ്‌ക്രീനിലേക്ക് മടങ്ങാൻ വർക്ക്‌സ്‌പെയ്‌സിൻ്റെ മുകളിലുള്ള ഡിസൈൻ ടാബിൽ ക്ലിക്ക് ചെയ്യുക.
2. "ചേർക്കുക" ബട്ടണിൽ റൈറ്റ് ക്ലിക്ക് ചെയ്യുക (jButton2). പോപ്പ്-അപ്പ് മെനുവിൽ നിന്ന്, ഇവൻ്റുകൾ > ആക്ഷൻ > ആക്ഷൻ പെർഫോംഡ് തിരഞ്ഞെടുക്കുക.
3. "ചേർക്കുക" ബട്ടൺ നിർവഹിക്കേണ്ട പ്രവർത്തനങ്ങൾക്കായി കോഡ് ചേർക്കുക. പൂർത്തിയായ സോഴ്സ് കോഡ് ഇതുപോലെയായിരിക്കണം: പ്രൈവറ്റ് ശൂന്യമായ jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // ആദ്യം നമ്മൾ ഫ്ലോട്ട് വേരിയബിളുകൾ നിർവചിക്കുന്നു. float num1, num2, result; // ഒരു ടൈപ്പ് ഫ്ലോട്ടിലേക്ക് ടെക്സ്റ്റ് പാഴ്സ് ചെയ്യണം num1 = Float.parseFloat(jTextField1.getText()); , ഞങ്ങൾ പോകുന്നത് // ഫലത്തിൻ്റെ മൂല്യം ഒരു സ്ട്രിംഗിൽ നിന്ന് jTextField3.setText(String.valueOf(ഫലം)) എന്നതിലേക്ക് മാറ്റുക;

ഇപ്പോൾ പ്രോഗ്രാം പൂർണ്ണമായും തയ്യാറാണ്, നിങ്ങൾക്ക് അത് അസംബ്ലിംഗ് ചെയ്ത് എക്സിക്യൂട്ട് ചെയ്യാൻ ആരംഭിക്കാം.

വ്യായാമം 4: പ്രോഗ്രാം നടപ്പിലാക്കുന്നു

IDE-യിൽ പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന്, ഈ ഘട്ടങ്ങൾ പാലിക്കുക:

1. റൺ> റൺ മെയിൻ പ്രോജക്റ്റ് തിരഞ്ഞെടുക്കുക (പകരം, F6 അമർത്തുക).

   കുറിപ്പ്. Project NumberAddition-ന് ഒരു പ്രധാന ക്ലാസ് വ്യക്തമാക്കിയിട്ടില്ലെന്ന് സൂചിപ്പിക്കുന്ന ഒരു വിൻഡോ നിങ്ങൾ തുറക്കുകയാണെങ്കിൽ, അതേ വിൻഡോയിലെ പ്രധാന ക്ലാസായി my.NumberAddition.NumberAdditionUI തിരഞ്ഞെടുത്ത് ശരി ക്ലിക്കുചെയ്യുക.

ഐഡിഇക്ക് പുറത്ത് പ്രോഗ്രാം പ്രവർത്തിപ്പിക്കുന്നതിന്, ഈ ഘട്ടങ്ങൾ പാലിക്കുക:

കുറച്ച് നിമിഷങ്ങൾക്ക് ശേഷം ആപ്ലിക്കേഷൻ സമാരംഭിക്കും.

കുറിപ്പ്.ഒരു JAR ഫയലിൽ ഇരട്ട-ക്ലിക്കുചെയ്യുന്നത് ആപ്ലിക്കേഷൻ സമാരംഭിക്കുന്നില്ലെങ്കിൽ, കൂടുതൽ വിവരങ്ങൾക്ക് നിങ്ങളുടെ ഓപ്പറേറ്റിംഗ് സിസ്റ്റത്തിലെ JAR ഫയൽ അസോസിയേഷനുകൾ കാണുക.

കമാൻഡ് ലൈനിൽ നിന്ന് നിങ്ങൾക്ക് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കാനും കഴിയും.

കമാൻഡ് ലൈനിൽ നിന്ന് ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന്, ഈ ഘട്ടങ്ങൾ പാലിക്കുക:

1. ഒരു കമാൻഡ് പ്രോംപ്റ്റ് അല്ലെങ്കിൽ ടെർമിനൽ വിൻഡോ തുറക്കുക.
2. കമാൻഡ് പ്രോംപ്റ്റിൽ, നിലവിലെ ഡയറക്ടറി NumberAddition/dist ഡയറക്ടറിയിലേക്ക് മാറ്റുക.
3. കമാൻഡ് പ്രോംപ്റ്റിൽ, ഇനിപ്പറയുന്ന പ്രസ്താവന നൽകുക: java -jar NumberAddition.jar

   കുറിപ്പ്.ആപ്ലിക്കേഷൻ പ്രവർത്തിപ്പിക്കുന്നതിന് മുമ്പ് my.NumberAddition.NumberAdditionUI പ്രധാന ക്ലാസായി സജ്ജീകരിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പാക്കുക. ഇത് പരിശോധിക്കുന്നതിന്, പ്രോജക്റ്റ് പാനലിലെ NumberAddition പ്രോജക്റ്റ് നോഡിൽ വലത്-ക്ലിക്കുചെയ്യുക, പോപ്പ്-അപ്പ് മെനുവിൽ നിന്ന് പ്രോപ്പർട്ടികൾ തിരഞ്ഞെടുക്കുക, പ്രോജക്റ്റ് പ്രോപ്പർട്ടീസ് ഡയലോഗ് ബോക്സിൽ റൺ വിഭാഗം തിരഞ്ഞെടുക്കുക. പ്രധാന ക്ലാസ് ഫീൽഡ് my.numberaddition.NumberAdditionUI കാണിക്കണം.

ഇവൻ്റ് പ്രോസസ്സിംഗ് എഞ്ചിൻ

ഈ ട്യൂട്ടോറിയൽ ഒരു ലളിതമായ ബട്ടൺ ക്ലിക്ക് ഇവൻ്റിനോട് പ്രതികരിക്കുന്നത് നോക്കി. ഒരു അപ്ലിക്കേഷന് പ്രതികരിക്കാൻ കഴിയുന്ന നിരവധി ഇവൻ്റുകൾ ഉണ്ട്. IDE-യിൽ, GUI ഘടകങ്ങൾ ഉപയോഗിച്ച് പ്രോസസ്സ് ചെയ്യാവുന്ന ലഭ്യമായ ഇവൻ്റുകളുടെ ലിസ്റ്റ് നിങ്ങൾക്ക് ഇനിപ്പറയുന്ന രീതിയിൽ കാണാൻ കഴിയും:

1. എഡിറ്ററിലെ NumberAdditionUI.java ഫയലിലേക്ക് മടങ്ങുക. GUI ബിൽഡറിലെ GUI ഘടന കാണുന്നതിന് "ഡിസൈൻ" ടാബിൽ ക്ലിക്ക് ചെയ്യുക.
2. ഏതെങ്കിലും GUI ഘടകത്തിൽ വലത്-ക്ലിക്കുചെയ്ത് ദൃശ്യമാകുന്ന മെനുവിൽ നിന്ന് "ഇവൻ്റ്സ്" തിരഞ്ഞെടുക്കുക. ഇപ്പോൾ നിങ്ങൾക്ക് ഇനങ്ങളൊന്നും തിരഞ്ഞെടുക്കാതെ തന്നെ മെനുവിലെ ഉള്ളടക്കങ്ങൾ പര്യവേക്ഷണം ചെയ്യാം.
3. പകരമായി, നിങ്ങൾക്ക് "വിൻഡോ" മെനുവിൽ നിന്ന് "പ്രോപ്പർട്ടികൾ" തിരഞ്ഞെടുക്കാം. പ്രോപ്പർട്ടീസ് വിൻഡോയിൽ, ഇവൻ്റുകൾ ടാബിൽ ക്ലിക്കുചെയ്യുക. നിലവിൽ സജീവമായ GUI ഘടകവുമായി ബന്ധപ്പെട്ട ഇവൻ്റ് ഹാൻഡ്‌ലറുകൾ കാണാനും മാറ്റാനും "ഇവൻ്റ്സ്" ടാബ് നിങ്ങളെ അനുവദിക്കുന്നു.
4. കീ അമർത്തലുകൾ, സിംഗിൾ, ഡബിൾ അല്ലെങ്കിൽ ട്രിപ്പിൾ ക്ലിക്കുകൾ, മൗസ് പോയിൻ്റർ ചലനങ്ങൾ, വിൻഡോ വലുപ്പം മാറ്റൽ, ഇൻപുട്ട് ഫോക്കസ് ചലനങ്ങൾ എന്നിവയോടും അപ്ലിക്കേഷന് പ്രതികരിക്കാനാകും. ഈ ഇവൻ്റുകൾക്കെല്ലാം ഇവൻ്റ് ഹാൻഡ്‌ലറുകൾ സ്വയമേവ സൃഷ്‌ടിക്കാൻ "ഇവൻ്റ്‌സ്" മെനു നിങ്ങളെ അനുവദിക്കുന്നു. ഇവയിൽ ഏറ്റവും സാധാരണമായത് "ആക്ഷൻ" പരിപാടിയാണ്. (കൂടുതൽ വിവരങ്ങൾക്ക്, സൺ ജാവ ഇവൻ്റുകൾ ട്യൂട്ടോറിയലിൽ ഇവൻ്റുകൾ എങ്ങനെ കൈകാര്യം ചെയ്യാമെന്ന് കാണുക.)

ഇവൻ്റുകൾ എങ്ങനെയാണ് പ്രോസസ്സ് ചെയ്യുന്നത്? ഇവൻ്റ് മെനുവിൽ നിന്ന് നിങ്ങൾ ഒരു ഇവൻ്റ് തിരഞ്ഞെടുക്കുമ്പോഴെല്ലാം, IDE യാന്ത്രികമായി ഇവൻ്റ് ലിസണർ എന്ന് വിളിക്കപ്പെടുന്നവ സൃഷ്ടിക്കുകയും ഡെവലപ്പർ ഘടകവുമായി അതിനെ ബന്ധപ്പെടുത്തുകയും ചെയ്യുന്നു. ഇവൻ്റ് പ്രോസസ്സിംഗിനെക്കുറിച്ച് കൂടുതലറിയാൻ, ഈ ഘട്ടങ്ങൾ പാലിക്കുക:

1. എഡിറ്ററിലെ NumberAdditionUI.java ഫയലിലേക്ക് മടങ്ങുക. GUI സോഴ്സ് കോഡ് കാണുന്നതിന് "ഉറവിടം" ടാബിൽ ക്ലിക്ക് ചെയ്യുക.
2. നടപ്പിലാക്കിയ jButton1ActionPerformed() , jButton2ActionPerformed() , jButton3ActionPerformed() രീതികൾ കാണുന്നതിന് താഴേക്ക് സ്ക്രോൾ ചെയ്യുക. ഈ രീതികളെ ഇവൻ്റ് ഹാൻഡ്‌ലറുകൾ എന്ന് വിളിക്കുന്നു.
3. ഇപ്പോൾ initComponents() രീതിയിലേക്ക് പോകുക. ഈ രീതി നഷ്ടപ്പെട്ടാൽ, ജനറേറ്റഡ് കോഡ് ലൈൻ കണ്ടെത്തി, മറഞ്ഞിരിക്കുന്ന initComponents() രീതി പ്രദർശിപ്പിക്കുന്നതിന് ആ വരിയുടെ അടുത്തുള്ള + ചിഹ്നത്തിൽ ക്ലിക്കുചെയ്യുക.
4. initComponents() രീതിക്ക് ചുറ്റുമുള്ള നീല ബ്ലോക്ക് ശ്രദ്ധിക്കുക. ഈ കോഡ് IDE സ്വയമേവ സൃഷ്‌ടിക്കപ്പെട്ടതിനാൽ ഉപയോക്താവിന് പരിഷ്‌ക്കരിക്കാനാവില്ല.
5. ഇനി initComponents() രീതി തന്നെ നോക്കുക. മറ്റ് കാര്യങ്ങളിൽ, GUI ഘടകങ്ങൾ ആരംഭിക്കുകയും ഫോമിൽ സ്ഥാപിക്കുകയും ചെയ്യുന്ന കോഡ് ഇതിൽ അടങ്ങിയിരിക്കുന്നു. നിങ്ങൾ ഘടകങ്ങൾ ഡിസൈൻ മോഡിൽ സ്ഥാപിക്കുകയും മാറ്റുകയും ചെയ്യുമ്പോൾ ഈ കോഡ് സ്വയമേവ ജനറേറ്റ് ചെയ്യുകയും അപ്‌ഡേറ്റ് ചെയ്യുകയും ചെയ്യുന്നു.
6. initComponents() രീതിയിൽ, ഇനിപ്പറയുന്ന സ്‌നിപ്പെറ്റ് കണ്ടെത്തുക: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() (പൊതു ശൂന്യമായ പ്രവർത്തനംPerformed(java.awt.event.ActionEvent evt) (jButton3ActionPerformed(evt); ) );

   ഈ ഘട്ടത്തിൽ, ഒരു "ActionListener" ഇവൻ്റ് ലിസണർ ഒബ്‌ജക്റ്റ് GUI ഘടകത്തിലേക്ക് ചേർക്കുന്നു, ഈ സാഹചര്യത്തിൽ jButton3 . "ActionListener" ഇൻ്റർഫേസിന് "ActionEvent" ഒബ്‌ജക്റ്റിൽ ഒരു "actionPerformed" രീതിയുണ്ട്, അത് jButton3ActionPerformed ഇവൻ്റ് ഹാൻഡ്‌ലറിലേക്ക് വിളിച്ച് നടപ്പിലാക്കുന്നു. ഈ ബട്ടൺ ഇപ്പോൾ പ്രവർത്തന പരിപാടികളോട് പ്രതികരിക്കുന്നു. ഓരോ തവണയും ബട്ടൺ ക്ലിക്ക് ചെയ്യുമ്പോൾ, ഒരു "ActionEvent" ജനറേറ്റ് ചെയ്യുകയും ഇവൻ്റ് ലിസണർ ഇൻ്റർഫേസിൻ്റെ "actionPerformed" രീതിയിലേക്ക് കൈമാറുകയും ചെയ്യുന്നു, അത് ഇവൻ്റ് ഹാൻഡ്‌ലറിൽ ആ ഇവൻ്റിനായി ഡെവലപ്പർ നൽകിയ കോഡ് നിർവ്വഹിക്കുന്നു.

7. ജാവ GUI ആപ്ലിക്കേഷൻസ് ലേണിംഗ് കാർഡ്

GUI നിലവാരം.

കമ്പ്യൂട്ടർ വ്യവസായത്തിലെ ഏറ്റവും പ്രധാനപ്പെട്ട മാറ്റങ്ങളിലൊന്നാണ് ഗ്രാഫിക്കൽ ഇൻ്റർഫേസിൻ്റെ വരവ്. വിൻഡോസ് ആപ്ലിക്കേഷനുകൾ എങ്ങനെയായിരിക്കണമെന്ന് നിർവ്വചിക്കുന്ന GUI മാനദണ്ഡങ്ങൾ സ്വീകരിക്കേണ്ടതുണ്ടോ? മാക്കിൻ്റോഷ് മുതലായവ. വിൻഡോസ് ബാഡ്ജ് നേടുന്നതിന് വെണ്ടർമാർ അവരുടെ ആപ്ലിക്കേഷനുകൾ ക്രമീകരിക്കുന്ന സർട്ടിഫിക്കേഷൻ പ്രോഗ്രാമുകളുണ്ട്. പല കാരണങ്ങളാലാണ് ഇത് ചെയ്യുന്നത്.

വിൻഡോസിൻ്റെയോ മാക്കിൻ്റെയോ ഒരു ഗുണം അവയുടെ സാധാരണ രൂപമാണ്. അവയിലൊന്നിൽ പ്രവർത്തിക്കാൻ നിങ്ങൾ പഠിച്ചുകഴിഞ്ഞാൽ, ബാക്കിയുള്ളവ നിങ്ങൾ നേടിയെന്ന് കരുതുക. മിക്ക വിൻഡോസ് ആപ്ലിക്കേഷനുകളും ഒരേ കൺവെൻഷനുകൾ ഉപയോഗിക്കുന്നു, അതിനാൽ അവയിലേതെങ്കിലും ഫയൽ തുറക്കാനും സംരക്ഷിക്കാനും പ്രിൻ്റ് ചെയ്യാനും അടയ്ക്കാനും പകർത്താനും നിങ്ങൾക്കറിയാം. സ്റ്റാൻഡേർഡ് ഇൻ്റർഫേസ് വളരെ ഉപയോക്തൃ സൗഹൃദമാണ്. ഉപയോക്താക്കൾ ഇതിനകം പ്രവർത്തിക്കാൻ പഠിച്ച മറ്റ് വിൻഡോസ് ആപ്ലിക്കേഷനുകൾക്ക് സമാനമായി നിങ്ങളുടെ ആപ്ലിക്കേഷനുകൾ നിർമ്മിക്കാൻ ശ്രമിക്കേണ്ടതുണ്ട്. GUI രൂപകൽപ്പനയ്ക്ക് ഏഴ് പൊതു തത്വങ്ങളുണ്ട്. നിങ്ങൾ അവ പഠിച്ച് അവ പിന്തുടരുകയാണെങ്കിൽ, നിങ്ങളുടെ ആപ്പ് ഡിസൈൻ മികച്ചതായിരിക്കും.

GUI രൂപകൽപ്പനയുടെ ഏഴ് തത്വങ്ങൾ.

GUI രൂപകൽപ്പനയുടെ ഏഴ് പൊതുതത്ത്വങ്ങൾ മൈക്രോസോഫ്റ്റ് വിൻഡോസ് ഇൻ്റർഫേസ് ഗൈഡിൽ നിന്ന് എടുത്തതാണ്. നിങ്ങളുടെ സ്വന്തം മാനദണ്ഡങ്ങൾ സൃഷ്ടിക്കാൻ കഴിയുന്ന ഒരു ബ്ലൂപ്രിൻ്റ് അവർ രൂപപ്പെടുത്തുന്നു. ഈ ഡിസൈൻ ഡവലപ്പർമാർക്കും ഉപയോക്താക്കൾക്കും രണ്ട് പ്രധാന നേട്ടങ്ങൾ നൽകുന്നു. ഒന്നാമതായി, ആപ്ലിക്കേഷനുകൾ പ്രൊഫഷണലായി കാണപ്പെടുന്നു. രണ്ടാമതായി, അവ പ്രവർത്തനക്ഷമവും മറ്റ് ആപ്ലിക്കേഷനുകളുമായി പൊരുത്തപ്പെടുന്നതും ഉപയോക്താക്കൾക്ക് പഠിക്കാൻ എളുപ്പവുമാണ്.

തീർച്ചയായും, ഒരു ആപ്ലിക്കേഷൻ വിജയിക്കണമെങ്കിൽ, അത് നന്നായി എഴുതിയതും ഉപയോഗപ്രദവുമായിരിക്കണം - ഇവയാണ് പ്രധാന ആവശ്യകതകൾ. നമ്മൾ സംസാരിക്കുന്ന തത്വങ്ങൾ ഡവലപ്പർക്ക് ചിന്തയ്ക്ക് ഭക്ഷണം നൽകുന്നു.

1. ആപ്ലിക്കേഷൻ നിയന്ത്രിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുക.

2. ഒബ്ജക്റ്റ്/ആക്ഷൻ മാതൃക പിന്തുടരുക.

3. സ്ഥിരത പുലർത്തുക.

4. ആപ്ലിക്കേഷനുകൾ ഉപയോഗിക്കുന്നത് ലളിതവും വ്യക്തവുമാക്കുക.

5. ഐക്യത്തിനായി പരിശ്രമിക്കുക.

6. ഉപയോക്തൃ ഫീഡ്ബാക്ക് നൽകുക.

7. ദയ കാണിക്കുക

തത്വം ഒന്ന്: ആപ്ലിക്കേഷൻ്റെ നിയന്ത്രണം ഉപയോക്താവിന് നൽകുക.

ഉപയോക്താവ് ആപ്ലിക്കേഷൻ നിയന്ത്രിക്കണം, അതായത്, മറ്റേതെങ്കിലും മൊഡ്യൂളിൽ നിന്ന് ഓരോ ആപ്ലിക്കേഷൻ മൊഡ്യൂളിലേക്കും ആക്സസ് ഉണ്ടായിരിക്കണം. മുമ്പ്, അത്തരം പ്രവേശനത്തിനായി ഒരു ശ്രേണിപരമായ മെനു ഉപയോഗിച്ചിരുന്നു.

ഉപയോക്താവ് ഒരു പുതിയ ക്ലയൻ്റ് ചേർക്കാൻ ആഗ്രഹിക്കുന്നുവെന്ന് നമുക്ക് പറയാം, ഉപയോക്താവ് അക്കൗണ്ടുകൾ സ്വീകരിക്കാവുന്ന മൊഡ്യൂളിലേക്ക് പോകുകയും അവിടെ നിന്ന് ഒരു പുതിയ ക്ലയൻ്റ് ചേർക്കുകയും വേണം. എന്താണ് ചെയ്യേണ്ടതെന്ന് അവന് എങ്ങനെ അറിയാം? ഒരുപക്ഷേ ഈ ആപ്ലിക്കേഷനുമായി ബന്ധപ്പെട്ട എൻ്റെ അനുഭവത്തിൽ നിന്ന്. GUI ലോകത്ത്, ഉപയോക്താവ് മെനുവിൽ നിന്ന് പുതിയ കമാൻഡ് തിരഞ്ഞെടുക്കുന്നു, തുടർന്ന് ഉപഭോക്താവ്, ചിത്രം. ഈ ആധുനിക സംവിധാനത്തിൽ, ഫയൽ മെനുവിലൂടെ നിങ്ങൾക്ക് ഒരു പുതിയ ഉപഭോക്താവിനെയോ വെണ്ടറെയോ ഇൻവെൻ്ററി ഇനത്തെയോ ചേർക്കാൻ കഴിയും. മർച്ചൻ്റ് സ്‌ക്രീനിൽ ആയിരിക്കുമ്പോഴും തിരിച്ചും ഒരു ഉപഭോക്തൃ റെക്കോർഡ് മാറ്റാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നു. സങ്കീർണ്ണവും ആശയക്കുഴപ്പമുണ്ടാക്കുന്നതുമായ ശ്രേണിപരമായ മെനുകൾ ഉപയോക്താവിന് ഇനി നാവിഗേറ്റ് ചെയ്യേണ്ടതില്ല.

തത്വം രണ്ട്: ഒബ്ജക്റ്റ്/ആക്ഷൻ മാതൃക പിന്തുടരുക.

സിസ്റ്റത്തിലെ എല്ലാ ഒബ്‌ജക്‌റ്റുകളിലും ചില ഓപ്പറേഷൻ നടത്താമെന്ന് ഒബ്‌ജക്റ്റ്/ആക്ഷൻ മാതൃക പറയുന്നു. ഏറ്റവും ലളിതവും വ്യക്തവുമായ ഉദാഹരണം ഉപഭോക്തൃ ഡാറ്റാബേസ് പിന്തുണ സ്‌ക്രീനാണ് (ചിത്രം). സ്‌ക്രീനിൽ ഒരു കൂട്ടം ബട്ടണുകൾ അടങ്ങിയിരിക്കുന്നു, തിരഞ്ഞെടുത്ത ക്ലയൻ്റിനെക്കുറിച്ചുള്ള വിവരങ്ങളിൽ ചില പ്രവർത്തനങ്ങൾ നടത്താൻ ചുവടെയുള്ള ഓരോന്നും നിങ്ങളെ അനുവദിക്കുന്നു. നിങ്ങൾക്ക് ഇത് ഇല്ലാതാക്കാനും എഡിറ്റുചെയ്യാനും പ്രിൻ്റ് ചെയ്യാനും കഴിയും. ഒരു നിർദ്ദിഷ്‌ട ക്ലയൻ്റിൽ ചെയ്യാൻ കഴിയുന്ന പ്രവർത്തനങ്ങൾ ഉചിതമായ സമയങ്ങളിൽ ലഭ്യമായിരിക്കണം അല്ലെങ്കിൽ ലഭ്യമല്ല. ഉദാഹരണത്തിന്, ഒരു ഉപഭോക്തൃ റെക്കോർഡ് എഡിറ്റ് മോഡിൽ ആയിരിക്കുമ്പോൾ, ഡിലീറ്റ്, ന്യൂ ബട്ടണുകൾ പ്രവർത്തനരഹിതമാക്കണം.

തത്വം മൂന്ന്: സ്ഥിരത പുലർത്തുക.

GUI രൂപകൽപ്പനയുടെ ഏറ്റവും പ്രധാനപ്പെട്ട തത്വങ്ങളിലൊന്നാണ് സ്ഥിരത. GUI-കൾ - പഴയ പ്രോഗ്രാമുകളേക്കാൾ കൂടുതൽ ആപ്ലിക്കേഷനുകൾ പര്യവേക്ഷണം ചെയ്യാൻ ഉപയോക്താക്കളെ അനുവദിക്കുന്നു. ഇതെല്ലാം സ്ഥിരതയുടെ തത്വത്തിന് നന്ദി. ഒരു ഉപയോക്താവ് ഒരു പുതിയ ആപ്ലിക്കേഷൻ കണ്ടുമുട്ടുമ്പോൾ, അയാൾക്ക് അടിസ്ഥാന കമാൻഡുകൾ പരിചയമുണ്ട്: ഫയലുകൾ തുറക്കുക, അച്ചടിക്കുക, സംരക്ഷിക്കുക. ഈ പ്ലാറ്റ്‌ഫോമുകളിൽ വികസിപ്പിച്ച ആപ്ലിക്കേഷനുകൾ സാധാരണയായി പരസ്പരം പൊരുത്തപ്പെടുന്നതാണ്.

അതിനാൽ, പുതിയ ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുമ്പോൾ, സ്ഥിരത പുലർത്തുക. ഒരു പുതിയ എൻട്രി ചേർക്കാൻ നിങ്ങൾ പുതിയ കമാൻഡ് ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിൽ, അത് എല്ലായിടത്തും ഉപയോഗിക്കുക. ഈ വാക്ക് മറ്റുള്ളവരുമായി മാറ്റിസ്ഥാപിക്കരുത് - ഉദാഹരണത്തിന്, Add 9add എന്ന വാക്ക് ഉപയോഗിച്ച്). നിങ്ങളുടെ സ്ഥിരതയ്ക്ക് നന്ദി, ഉപയോക്താക്കൾക്ക് പുതിയ കമാൻഡ് എവിടെ നേരിട്ടാലും അത് ഒരു പുതിയ എൻട്രി ചേർക്കാൻ ഉപയോഗിക്കാമെന്ന് അറിയും.

തത്വം നാല്: ആപ്ലിക്കേഷൻ ഉപയോഗിക്കുന്നത് ലളിതവും വ്യക്തവുമാക്കുക.

ഈ ആശയം പ്രകടിപ്പിക്കാനുള്ള മറ്റൊരു മാർഗ്ഗം: പദപ്രയോഗം ഉപയോഗിക്കരുത്. രണ്ട് ബട്ടണുകളുള്ള ഒരു സ്‌ക്രീൻ ഉണ്ട്. അവയിലൊന്ന് “ഡാറ്റാബേസ് പാക്ക് ചെയ്യുക” എന്നും മറ്റൊന്ന് “ഇല്ലാതാക്കുന്നതിന് അടയാളപ്പെടുത്തിയ റെക്കോർഡുകൾ നീക്കംചെയ്യുക” എന്നും പറയുന്നു. രണ്ടാമത്തെ എൻട്രി ഒരുപക്ഷേ ഉപയോക്താവിന് കൂടുതൽ മനസ്സിലാക്കാവുന്നതായിരിക്കും.

ആപ്ലിക്കേഷനുകൾ വികസിപ്പിക്കുമ്പോൾ, ഇൻ്റർഫേസിൽ പ്രോഗ്രാമർ സ്ലാംഗ് ഉപയോഗിക്കാനുള്ള ഒരു പ്രലോഭനമുണ്ട്. സാധ്യമെങ്കിൽ ഇത് ഒഴിവാക്കാൻ ശ്രമിക്കുക.

അഞ്ച് തത്വം: ഐക്യത്തിനായി പരിശ്രമിക്കുക

കറുപ്പിലും വെളുപ്പിലും പോലും, ഈ സ്ക്രീനിന് കാര്യമായ സൗന്ദര്യാത്മക പോരായ്മയുണ്ട്: വൈരുദ്ധ്യമുള്ള വസ്തുക്കളുള്ള വെളുത്ത പശ്ചാത്തലം. ചിത്രത്തിൽ. ഒരേ സ്‌ക്രീൻ വർണ്ണാടിസ്ഥാനത്തിൽ നന്നായി സന്തുലിതമായി കാണപ്പെടുന്നു.

നിങ്ങൾക്ക് വിൻഡോസിലേക്ക് കൈമാറാൻ കഴിയുന്ന ദശലക്ഷക്കണക്കിന് വർണ്ണ കോമ്പിനേഷനുകൾ ഉണ്ട്. അവയെല്ലാം ഉപയോഗിക്കേണ്ടതുണ്ടെന്നാണോ ഇതിനർത്ഥം? തീർച്ചയായും ഇല്ല. നിങ്ങൾ ലളിതവും ശാന്തവുമായ നിറങ്ങൾ തിരഞ്ഞെടുക്കുകയും ചില പ്രോഗ്രാമർമാർ ഇഷ്ടപ്പെടുന്ന ചില കാരണങ്ങളാൽ അവയുടെ അരാജകമായ മിശ്രണം ഒഴിവാക്കുകയും വേണം.

തത്വം ആറ്. ഉപയോക്താവിന് ഫീഡ്ബാക്ക് നൽകുക.

നിങ്ങളുടെ ആപ്ലിക്കേഷന് എക്സിക്യൂട്ട് ചെയ്യാൻ വളരെ സമയമെടുക്കുന്ന ഒരു പ്രോസസ് ഉണ്ടെന്ന് സങ്കൽപ്പിക്കുക. ഈ സമയത്ത്, ഇനിപ്പറയുന്ന ഉള്ളടക്കം ഉപയോഗിച്ച് നിങ്ങൾക്ക് സ്ക്രീനിൽ ഒരു സന്ദേശം പ്രദർശിപ്പിക്കാൻ കഴിയും: "പ്രോഗ്രാം പ്രവർത്തിക്കുന്നു, ദയവായി കാത്തിരിക്കുക." സൗകര്യപ്രദമായ പരിഹാരം; എന്നാൽ അത് ഫ്രീസ് ചെയ്തിട്ടില്ലെന്ന് ഉപയോക്താവിന് എങ്ങനെ അറിയാം? അതിനാൽ, പ്രോഗ്രാമിൽ എല്ലാം ശരിയായിരിക്കുമെങ്കിലും, അദ്ദേഹം ആപ്ലിക്കേഷന് “ത്രീ-ഫിംഗർ സല്യൂട്ട്” (Ctrl+Alt+Del) നൽകാനുള്ള സാധ്യത വളരെ കൂടുതലാണ്.

പ്രക്രിയയുടെ ഏത് ഭാഗമാണ് പൂർത്തിയായതെന്ന് ഉപയോക്താവിനെ കാണിക്കുന്നതാണ് നല്ലത്. അപ്പോൾ അയാൾ അനാവശ്യമായി പ്രോഗ്രാമിനെ തടസ്സപ്പെടുത്തില്ല, ജോലി എത്രത്തോളം പുരോഗമിച്ചുവെന്ന് വിലയിരുത്താനും പ്രക്രിയ പൂർത്തിയാകുന്നതുവരെ മറ്റ് കാര്യങ്ങൾ ചെയ്യാനും അദ്ദേഹത്തിന് കഴിയും. അങ്ങനെ, ഉപയോക്താവിൻ്റെ ഉത്പാദനക്ഷമത ഏകദേശം 25 ശതമാനം വർദ്ധിക്കും. സ്ക്രീനിൽ മീറ്റർ പ്രദർശിപ്പിക്കുന്നതിലൂടെ ഈ ഫലം നേടാനാകും. സാധാരണയായി "100-ൽ 10 റെക്കോർഡുകൾ പ്രോസസ്സ് ചെയ്തു" അല്ലെങ്കിൽ "40% പൂർത്തിയായി" പോലുള്ള സന്ദേശങ്ങൾ പ്രദർശിപ്പിക്കും. പ്രോസസ്സ് ചെയ്ത റെക്കോർഡുകളുടെ എണ്ണവും അവയുടെ ശതമാനവും കാണിക്കുന്നതാണ് ഇതിലും നല്ലത്.

തത്വം ഏഴ്: ക്ഷമിക്കുക

അബദ്ധത്തിൽ തെറ്റായ ബട്ടൺ അമർത്തി നമ്മൾ ഓരോരുത്തരും ചിലപ്പോൾ ഒരു പോസ്റ്റ് ഡിലീറ്റ് ചെയ്തിട്ടുണ്ട്. അതിനാൽ, ഉപയോക്താവിന് അവൻ്റെ മനസ്സ് മാറ്റാനോ ഇപ്പോൾ എടുത്ത പ്രവർത്തനങ്ങൾ റദ്ദാക്കാനോ അവസരം നൽകുക. ഒരു പ്രക്രിയയ്ക്ക് വളരെയധികം സമയമെടുക്കുകയോ, ധാരാളം ഡാറ്റ മാറ്റുകയോ, അല്ലെങ്കിൽ ഒരു പ്രവർത്തനം നടത്തുന്നതിന് മുമ്പ് ഉപയോക്താവിന് ഡാറ്റ ബാക്കപ്പ് ചെയ്യേണ്ടതുണ്ടെങ്കിൽ, നിങ്ങൾ ഒരു മുന്നറിയിപ്പ് നൽകണം, സ്ഥിരീകരണം ആവശ്യമായി വരുന്ന ആപ്ലിക്കേഷനുകൾ ഞാൻ രണ്ടുതവണ കണ്ടു, തുടർന്ന് ഒരു പാസ്‌വേഡ് ആവശ്യപ്പെടുക. നിങ്ങളുടെ പ്രോഗ്രാമുകൾക്ക് ഈ തലത്തിലുള്ള പരിരക്ഷ ആവശ്യമുണ്ടോ? ഒരുപക്ഷേ. ജോലിയുടെ ഏത് ഘട്ടത്തിലും ഉപയോക്താവിന് തെറ്റ് സംഭവിച്ചാൽ സഹായിക്കുക എന്നതാണ് ഡവലപ്പറുടെ ചുമതല.

GUI സ്റ്റാൻഡേർഡ് കൺവെൻഷനുകളുടെ പ്രാധാന്യം.

നിങ്ങൾക്ക് കാണാനാകുന്നതുപോലെ, GUI രൂപകൽപ്പനയുടെ തത്വങ്ങൾ വളരെ ലളിതമാണ്, സ്ക്രീനുകൾ സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിക്കേണ്ടതാണ്. എന്നിരുന്നാലും, നിങ്ങൾ സ്‌ക്രീൻ രൂപകൽപ്പന ചെയ്യുന്നതിനുമുമ്പ്, അത് എങ്ങനെയായിരിക്കുമെന്ന് നിങ്ങൾ സ്ഥാപിക്കേണ്ടതുണ്ട്. അതിൻ്റെ വലുപ്പങ്ങൾ, ഫോണ്ടുകൾ, നിറങ്ങൾ, സന്ദേശ ശൈലികൾ മുതലായവ തിരഞ്ഞെടുക്കുക. ഈ പ്രശ്നങ്ങൾ മുൻകൂട്ടി പരിഹരിക്കുന്നതിലൂടെ, നിങ്ങളുടെ ജോലി ഗണ്യമായി വേഗത്തിലാക്കും. പിന്നീട് ഫോണ്ട് അല്ലെങ്കിൽ സന്ദേശ ശൈലി വരുമ്പോൾ, നിങ്ങൾ സ്റ്റാൻഡേർഡ് നോക്കുക.

ജൂലൈ 09, 2003

വിവിധ വിഷ്വൽ ആപ്ലിക്കേഷൻ ഡെവലപ്മെൻ്റ് ടൂളുകളുടെ വരവോടെ, പ്രോഗ്രാമുകൾക്കായി ഗ്രാഫിക്കൽ ഇൻ്റർഫേസുകൾ എഴുതുന്നത് ഒരു കുട്ടിയുടെ ഗെയിം പോലെയായി മാറി. ഞാൻ അത് മൗസ് ഉപയോഗിച്ച് കുത്തിയപ്പോൾ ഒരു ഫോം പ്രത്യക്ഷപ്പെട്ടു, ഞാൻ അത് രണ്ടാമതും കുത്തിയപ്പോൾ ഒരു ബട്ടൺ പ്രത്യക്ഷപ്പെട്ടു. ഗ്രാഫിക്കൽ പരിതസ്ഥിതിയിൽ പ്രോഗ്രാമിംഗിൻ്റെ മറ്റൊരു മാർഗത്തെക്കുറിച്ച് പലരും ഇപ്പോൾ ചിന്തിക്കുന്നില്ലെന്ന് എനിക്ക് തോന്നുന്നു. തീർച്ചയായും, നിങ്ങൾക്ക് പുരോഗതിക്കെതിരെ വാദിക്കാൻ കഴിയില്ല, വലിയ പ്രോജക്ടുകൾ എഴുതുമ്പോൾ, ഈ സൗകര്യങ്ങളെല്ലാം വളരെ പ്രയോജനകരമാണ്. എന്നാൽ ഈ സംഭാഷണം അതിനെക്കുറിച്ചല്ല. ചിലപ്പോൾ ഇത് അസംബന്ധത്തിൻ്റെ പോയിൻ്റിലേക്ക് വരുന്നു: MFC, VCL മുതലായവ ഉപയോഗിച്ച് ഒരു പ്രാകൃത ആപ്ലിക്കേഷൻ എഴുതിയിരിക്കുന്നു. അത്തരം പ്രോഗ്രാമുകൾ ടെർമിറ്റുകളെപ്പോലെ മെമ്മറി വിഴുങ്ങുകയും അവയുടെ കൊഴുപ്പ് ശരീരത്തോടൊപ്പം അധിക ഡിസ്കിൽ ഇടം നേടുകയും ചെയ്യുന്നു. ചട്ടം പോലെ, MFC/VCL അനലോഗുകൾ ശുദ്ധമായ API-യിൽ എഴുതിയ പ്രോഗ്രാമുകളേക്കാൾ പത്ത് മുതൽ ഇരുപത് മടങ്ങ് വരെ "ഭാരം" നൽകുന്നു. കൂടാതെ വിഷ്വൽ ബേസിക് (ഈ വാക്യത്തിന് ദൈവം എന്നോട് ക്ഷമിക്കട്ടെ) അതിൻ്റെ msvbvmXX.dll? കൂടാതെ കൂടുതൽ സിസ്റ്റം റിസോഴ്സുകൾ (പല തവണ) ഉപയോഗിക്കുന്നു. പാവപ്പെട്ട ഉപയോക്താക്കൾ, സ്വയം ബിയർ നിഷേധിക്കുന്നു, പുതിയ ഹാർഡ്‌വെയർ വാങ്ങാൻ പണം ലാഭിക്കുന്നു. പാവങ്ങളുടെ കാര്യം കഷ്ടമല്ലേ? പ്രോഗ്രാമർമാർ മാത്രമല്ല ബിയർ കുടിക്കുന്നത്? API കോഡിംഗിനെക്കുറിച്ച് മറ്റൊരു നല്ല കാര്യമുണ്ട്: പ്രോഗ്രാമർ ഓപ്പറേറ്റിംഗ് സിസ്റ്റവുമായി കൂടുതൽ അടുക്കുന്നു. അതനുസരിച്ച്, അവൻ അത് നന്നായി മനസ്സിലാക്കുകയും നിയന്ത്രിക്കുകയും ചെയ്യുന്നു. ഇത് ലളിതമാണ് - ഇത് വളരെ ആവേശകരമായ പ്രവർത്തനമാണ്. ഞാൻ ആവർത്തിക്കുന്നു, മേൽപ്പറഞ്ഞവയെല്ലാം ചെറുതും ലളിതവുമായ പ്രോഗ്രാമുകൾക്ക് പ്രത്യേകമായി ബാധകമാണ്, വലിയ പദ്ധതികളിൽ എല്ലാം തികച്ചും വ്യത്യസ്തമാണ്.

ഞാൻ നിങ്ങളെ ബോധ്യപ്പെടുത്തിയെന്ന് ഞാൻ പ്രതീക്ഷിക്കുന്നു. നമുക്ക് പോകാം.

കുറഞ്ഞ പ്രവർത്തനക്ഷമതയുള്ള ഒരു ലളിതമായ വിൻഡോ ഇൻ്റർഫേസ് സൃഷ്ടിക്കുന്നത് ഞങ്ങൾ നോക്കും. ഇത് രണ്ട് ഇൻപുട്ട് ഫീൽഡുകളും രണ്ട് ബട്ടണുകളും ഉള്ള ഒരു ലളിതമായ വിൻഡോ ആയിരിക്കും. നിങ്ങൾ "പകർപ്പ്" ബട്ടണിൽ ക്ലിക്കുചെയ്യുമ്പോൾ, ആദ്യ ഇൻപുട്ട് ഫീൽഡിൽ നിന്നുള്ള വാചകം രണ്ടാമത്തേതിലേക്ക് പകർത്തപ്പെടും. നിങ്ങൾ "ക്ലോസ്" ബട്ടണിൽ ക്ലിക്കുചെയ്യുമ്പോൾ, പ്രോഗ്രാം അതിൻ്റെ ജോലി പൂർത്തിയാക്കും. ഭാവിയിൽ, മറ്റ് സങ്കീർണ്ണമായ ആപ്ലിക്കേഷനുകൾ എഴുതുന്നതിനുള്ള ഒരു ടെംപ്ലേറ്റായി ഇത് പ്രവർത്തിക്കും. ഞങ്ങൾ C/C++ ൽ ആശയവിനിമയം നടത്തും, എന്നിരുന്നാലും ഞങ്ങൾ ഡെൽഫിയെ വ്രണപ്പെടുത്തില്ല. പൊതുവായ തത്വം ഒന്നുതന്നെയാണ്, വാക്യഘടന മാത്രം വ്യത്യസ്തമാണ്. സിസ്റ്റം സന്ദേശങ്ങളും API ഫംഗ്‌ഷനുകളും ഉപയോഗിച്ച് പ്രവർത്തിക്കാൻ, നിങ്ങളുടെ പ്രോജക്റ്റിൽ ഹെഡർ ഫയലുകൾ ഉൾപ്പെടുത്തേണ്ടതുണ്ട്; C/C++-ൽ ഇത് windows.h ആണ്, ഡെൽഫിയിൽ ഇവയാണ് വിൻഡോകളും സന്ദേശ മൊഡ്യൂളുകളും.

Windows OS-ലെ ഏത് പ്രോഗ്രാമിലും മൂന്ന് പ്രധാന ഭാഗങ്ങൾ അടങ്ങിയിരിക്കുന്നു: പ്രധാന പ്രവർത്തനം, സന്ദേശ ലൂപ്പ്, വിൻഡോ ഫംഗ്ഷൻ, വിൻഡോയിലേക്ക് അയച്ച എല്ലാ സന്ദേശങ്ങളും പ്രോസസ്സ് ചെയ്യുന്നു.

WinMain() ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ഞങ്ങളുടെ പ്രോഗ്രാം എക്‌സിക്യൂട്ട് ചെയ്യാൻ തുടങ്ങുന്നു. ഇതാണ് പ്രധാന പ്രവർത്തനം. WinMain() ഫംഗ്‌ഷൻ സാധാരണയായി ഇനിപ്പറയുന്ന ജോലികൾ ചെയ്യുന്നു:

• വിൻഡോ ക്ലാസ് നിർവചിക്കുന്നു. ഒരു OOP ക്ലാസുമായി തെറ്റിദ്ധരിക്കരുത്.
• സിസ്റ്റത്തിൽ ഈ ക്ലാസ് രജിസ്റ്റർ ചെയ്യുന്നു.
• പ്രധാന ആപ്ലിക്കേഷൻ വിൻഡോയും മറ്റ് നിയന്ത്രണങ്ങളും സൃഷ്ടിക്കുന്നു.
• സ്ക്രീനിൽ ഒരു വിൻഡോ പ്രദർശിപ്പിക്കുന്നു.
• സന്ദേശ പ്രോസസ്സിംഗ് ലൂപ്പ് ആരംഭിക്കുന്നു.
• ഇത് ഇങ്ങനെ പ്രഖ്യാപിച്ചു: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) നമുക്ക് പരാമീറ്ററുകൾ നോക്കാം:
  • hInstance എന്നത് നിലവിലെ ആപ്ലിക്കേഷൻ ഇൻസ്‌റ്റൻസിലേക്കുള്ള ഒരു ഹാൻഡിലാണ്.
  • hPrevInstance എന്നത് ആപ്ലിക്കേഷൻ്റെ മുമ്പത്തെ ഉദാഹരണമാണ്, അത് പ്രവർത്തിക്കുകയാണെങ്കിൽ.
  • lpCmdLine - സ്റ്റാർട്ടപ്പിൽ പ്രോഗ്രാമിലേക്ക് കൈമാറിയ പാരാമീറ്ററുകൾ അടങ്ങിയ ഒരു ലൈനിലേക്കുള്ള പോയിൻ്റർ.
  • nCmdShow - വിൻഡോ എങ്ങനെ പ്രദർശിപ്പിക്കണമെന്ന് നിർണ്ണയിക്കുന്ന ഒരു സ്ഥിരാങ്കം. (SW_ സ്ഥിരാങ്കങ്ങൾ കാണുക).

ഡെൽഫിയിൽ ഞങ്ങൾ അത്തരമൊരു ചിത്രം കാണില്ല, ഈ വികസന പരിതസ്ഥിതിയിൽ പ്രധാന പ്രവർത്തനം പ്രോഗ്രാമറിൽ നിന്ന് കംപൈലർ മറച്ചിരിക്കുന്നു. തീർച്ചയായും, ഇത് അന്തിമ കോഡിൽ ഉണ്ടെങ്കിലും. ഒരു വിൻഡോ ക്ലാസ് രജിസ്റ്റർ ചെയ്യുന്നതിന്, നിങ്ങൾ തരം WNDCLASS (ഡെൽഫി TWNDCLASS ൽ) ഘടനയുടെ ഫീൽഡുകൾ പൂരിപ്പിക്കേണ്ടതുണ്ട്. ഈ ആവശ്യത്തിനായി, ഞങ്ങൾ wcl വേരിയബിൾ പ്രഖ്യാപിച്ചു.

wcl.hInstance = hInstance; നിലവിലെ ആപ്ലിക്കേഷൻ ഇൻസ്റ്റൻസിലേക്കുള്ള ഒരു ഹാൻഡിൽ, hInstance വേരിയബിൾ WinMain() ഫംഗ്‌ഷൻ ഉപയോഗിച്ച് ആരംഭിക്കുന്നു. ഡെൽഫിയിൽ ഇത് പരോക്ഷമായി ആരംഭിക്കുന്നു.

wcl.lpszClassName = szWinName; ക്ലാസ്സിൻ്റെ പേര്. szWinName എന്ന സ്‌ട്രിംഗ് വേരിയബിൾ ഞങ്ങൾ മുൻകൂട്ടി സൃഷ്‌ടിക്കുകയും ആരംഭിക്കുകയും ചെയ്‌തു.

wcl.lpfnWndProc = WindowFunc; ഒരു വിൻഡോ ഫംഗ്‌ഷനിലേക്കുള്ള ഒരു പോയിൻ്റർ. "API-യിലെ ഒരു ലളിതമായ വിൻഡോ.", WS_OVERLAPPEDWINDOW ↑ WS_THICKFRAME ↑ S_MAXIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT, 300, 170, HWND_DESKTOP, NULL, hInstance, NULL);

• ആദ്യത്തെ പാരാമീറ്റർ വിൻഡോ ക്ലാസിൻ്റെ പേരാണ്.
• രണ്ടാമത്തെ പാരാമീറ്റർ വിൻഡോ ശീർഷകമാണ്.
• മൂന്നാമത്തെ പാരാമീറ്റർ വിൻഡോ ശൈലിയാണ്. സാധാരണ WS_OVERLAPPEDWINDOW-ൽ നിന്ന്, xor ഓപ്പറേഷൻ ഉപയോഗിച്ച്, വിൻഡോ സ്കെയിൽ ചെയ്യാനുള്ള കഴിവ് ഞാൻ നീക്കം ചെയ്യുകയും മാക്സിമൈസ് ബട്ടൺ പ്രവർത്തനരഹിതമാക്കുകയും ചെയ്തു.
• നാലാമത്തേതും അഞ്ചാമത്തേതും സ്ക്രീനിൻ്റെ ഇടത്, മുകളിലെ മൂലയിൽ നിന്നുള്ള വിൻഡോയുടെ സ്ഥാനമാണ്. എനിക്ക് CW_USEDEFAULT ഉണ്ട്, ഈ മൂല്യം ഉപയോഗിച്ച് സിസ്റ്റം വിൻഡോയുടെ സ്ഥാനം യാന്ത്രികമായി തിരഞ്ഞെടുക്കുന്നു.
• ആറാമത്തെയും ഏഴാമത്തെയും പാരാമീറ്ററുകൾ യഥാക്രമം വിൻഡോയുടെ വീതിയും ഉയരവുമാണ്.
• എട്ടാമത്തെ പാരാമീറ്റർ ഉടമ വിൻഡോയാണ്. പ്രധാന വിൻഡോയിൽ, ഡെസ്ക്ടോപ്പ് (0) ആണ് ഉടമ. നിയന്ത്രണങ്ങൾക്ക് ഒരു പ്രധാന വിൻഡോ ഉണ്ട്.
• ഒമ്പതാമത്തേത് മെനു ഹാൻഡിലിലേക്കുള്ള ഒരു പോയിൻ്ററാണ്. മെനുവില്ല, അടയാളവുമില്ല.
• പത്താമത്തെ പാരാമീറ്റർ നിലവിലെ ആപ്ലിക്കേഷൻ ഇൻസ്‌റ്റൻസിലേക്കുള്ള ഒരു ഹാൻഡിലാണ്.
• പതിനൊന്നാമത് - ഒരു MDI ഇൻ്റർഫേസ് ഉപയോഗിച്ച് ആപ്ലിക്കേഷനുകൾ സൃഷ്ടിക്കുമ്പോൾ ഉപയോഗിക്കുന്നു. ഞങ്ങൾക്ക് അത് ആവശ്യമില്ല.

hMainWnd വേരിയബിളിൽ സംഭരിച്ചിരിക്കുന്ന, സൃഷ്ടിച്ച വിൻഡോയിലേക്ക് ഫംഗ്ഷൻ ഒരു ഹാൻഡിൽ നൽകുന്നു.
ഒരു വിൻഡോ അല്ലെങ്കിൽ നിയന്ത്രണത്തെ തിരിച്ചറിയുന്ന സിസ്റ്റത്തിലെ ഒരു തനത് സംഖ്യയാണ് വിൻഡോ ഹാൻഡിൽ.

അടുത്തതായി ഞങ്ങൾ ആവശ്യമായ നിയന്ത്രണങ്ങൾ സൃഷ്ടിക്കും. എല്ലാ നിയന്ത്രണങ്ങളും ഒരേ വിൻഡോകളാണ്, അവയ്ക്ക് മറ്റൊരു ക്ലാസ് നാമം മാത്രമേയുള്ളൂ. കൺട്രോൾ ക്ലാസുകൾ രജിസ്റ്റർ ചെയ്യേണ്ട ആവശ്യമില്ല; അവ സിസ്റ്റത്തിൽ മുൻകൂട്ടി നിശ്ചയിച്ചിട്ടുണ്ട്. ബട്ടൺ - ബട്ടൺ ക്ലാസ്. ഇൻപുട്ട് ഫീൽഡ് - ക്ലാസ് എഡിറ്റ്. അടിക്കുറിപ്പ് - ക്ലാസ് സ്റ്റിക്ക്. സ്റ്റാൻഡേർഡ് നിയന്ത്രണങ്ങളുമായി പൊരുത്തപ്പെടുന്ന നിരവധി ക്ലാസുകളുണ്ട്. പരിചിതമായ CreateWindow() ഫംഗ്‌ഷനും അപരിചിതമായ CreateWindowEx() ഫംഗ്‌ഷനും ഉപയോഗിച്ച് ഞങ്ങൾ നിയന്ത്രണങ്ങൾ സൃഷ്‌ടിക്കുന്നു. CreateWindowEx() ഒരു വിപുലമായ ശൈലിയിൽ ഒരു വിൻഡോ സൃഷ്ടിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. ഇൻപുട്ട് ഫീൽഡുകൾ സൃഷ്ടിക്കാൻ ഞങ്ങൾ ഇത് ഉപയോഗിക്കുന്നു. ഈ ഫംഗ്‌ഷൻ ആദ്യ പാരാമീറ്റർ ചേർത്തു, അത് ഈ ഏറ്റവും നൂതനമായ ശൈലി സജ്ജമാക്കുന്നു, ശേഷിക്കുന്ന പരാമീറ്ററുകൾ CreateWindow() പോലെയാണ്. നിയന്ത്രണങ്ങൾ ചൈൽഡ് വിൻഡോകളാണ്, അവയുടെ ഉടമയാണ് പ്രധാന വിൻഡോ.

നിയന്ത്രണങ്ങൾ സൃഷ്‌ടിക്കുമ്പോൾ, ഫംഗ്‌ഷൻ പാരാമീറ്ററുകളിൽ നിങ്ങൾ പ്രധാന വിൻഡോയുടെ ഡിസ്‌ക്രിപ്‌റ്ററും അതുപോലെ തന്നെ WS_CHILD എന്ന വിൻഡോ ശൈലിയും വ്യക്തമാക്കണം. നിയന്ത്രണങ്ങളുടെ രൂപവും പ്രവർത്തനവും ഫ്ലാഗുകൾ ഉപയോഗിച്ച് കൈകാര്യം ചെയ്യാൻ കഴിയും: WS_, ES_, BS_, SS_, അവയെ ബിറ്റ്‌വൈസ് “അല്ലെങ്കിൽ” പ്രവർത്തനവുമായി സംയോജിപ്പിച്ച്. നിയന്ത്രണങ്ങൾ സൃഷ്‌ടിക്കുമ്പോൾ, അനുബന്ധ വേരിയബിളുകൾ അവയുടെ ഡിസ്‌ക്രിപ്‌റ്ററുകൾ ഉപയോഗിച്ച് ഞങ്ങൾ സമാരംഭിക്കുന്നു, അവ CreateWindow(), CreateWindowEx() ഫംഗ്‌ഷനുകൾ വഴി നൽകുന്നു. നിയന്ത്രണങ്ങൾക്കൊപ്പം കൂടുതൽ പ്രവർത്തിക്കാൻ ഞങ്ങൾക്ക് ഈ വിവരണങ്ങൾ ആവശ്യമാണ്. ഞങ്ങൾ സൃഷ്ടിച്ച വിൻഡോ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുകയും അത് വീണ്ടും വരയ്ക്കുകയും ചെയ്യുന്നു.

GetMessage ഫംഗ്‌ഷൻ അപ്ലിക്കേഷൻ്റെ സന്ദേശ ക്യൂവിൽ നിന്ന് അടുത്ത സന്ദേശം തിരഞ്ഞെടുത്ത് വിൻഡോയിലേക്ക് അയയ്ക്കുന്നു.

• ആദ്യ പാരാമീറ്റർ MSG തരത്തിൻ്റെ ഘടനയാണ് (TMSG തരം ഡെൽഫിയിൽ)
• രണ്ടാമത്തെ പാരാമീറ്റർ സന്ദേശം ഉദ്ദേശിച്ച വിൻഡോയിലേക്കുള്ള ഒരു ഹാൻഡിലാണ്. NULL അല്ലെങ്കിൽ 0 ആണെങ്കിൽ, എല്ലാ ആപ്ലിക്കേഷൻ വിൻഡോകളും.
• മൂന്നാമത്തെയും നാലാമത്തെയും - സ്വീകരിച്ച സന്ദേശങ്ങളുടെ ശ്രേണി സജ്ജമാക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു. 0 ആണെങ്കിൽ, എല്ലാ സന്ദേശങ്ങളും വിൻഡോയെ അഭിസംബോധന ചെയ്യുന്നു.

GetMessage - ഒരു WM_QUIT സന്ദേശം ദൃശ്യമാകുമ്പോൾ FALSE നൽകുന്നു, ഈ സാഹചര്യത്തിൽ ലൂപ്പ് പുറത്തുകടന്ന് ആപ്ലിക്കേഷൻ പുറത്തുകടക്കുന്നു.

TranslateMessage - വെർച്വൽ കീ കോഡുകൾ കീബോർഡ് സന്ദേശങ്ങളിലേക്ക് വിവർത്തനം ചെയ്യുന്നു.

DispatchMessage - പ്രോസസ്സിംഗിനായി വിൻഡോ ഫംഗ്ഷനിലേക്ക് ഒരു സന്ദേശം അയയ്ക്കുന്നു.

• സിസ്റ്റം സന്ദേശങ്ങൾ പ്രോസസ്സ് ചെയ്യുന്നതിലൂടെ വിൻഡോ ഫംഗ്ഷൻ പ്രോഗ്രാം പ്രവർത്തനക്ഷമത നൽകുന്നു. വിൻഡോ ഫംഗ്‌ഷൻ ഒരു കോൾബാക്ക് ഫംഗ്‌ഷനാണ്, അതായത്. ഇൻകമിംഗ് പുതിയ സന്ദേശത്തിനുള്ള പ്രതികരണമായി ഓപ്പറേറ്റിംഗ് സിസ്റ്റം വിളിച്ചു. വിൻഡോ ഫംഗ്ഷൻ ഇതുപോലെ പ്രഖ്യാപിച്ചു:
• LRESULT CALLBACK WindowFunc(HWND hMainWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)
• HMainWnd - പ്രധാന വിൻഡോയിലേക്ക് കൈകാര്യം ചെയ്യുക.

iMsg - സന്ദേശ നമ്പർ. WM_ സ്ഥിരാങ്കങ്ങൾ കാണുക.

lParam, wParam എന്നിവ സന്ദേശ പാരാമീറ്ററുകളാണ്.

ഒരു സന്ദേശം ദൃശ്യമാകുമ്പോൾ, നമുക്ക് iMsg പാരാമീറ്ററിനെ WM_ സ്ഥിരാങ്കങ്ങളിലൊന്നുമായി താരതമ്യം ചെയ്യാനും അതിനനുസരിച്ച് പ്രതികരിക്കുന്നതിന് പ്രോഗ്രാം പ്രോഗ്രാം ചെയ്യാനും കഴിയും.

ഉദാഹരണത്തിന്: വിൻഡോയുടെ ക്ലയൻ്റ് ഏരിയയിൽ മൗസ് പോയിൻ്റർ ആയിരിക്കുമ്പോൾ ഇടത് മൌസ് ബട്ടൺ അമർത്തുമ്പോൾ, WM_LBUTTONDOWN ഇവൻ്റ് ഉയർത്തപ്പെടും. വിൻഡോ ഫംഗ്‌ഷനെ വിളിക്കുന്നു, സ്ഥിരമായ WM_LBUTTONDOWN ൻ്റെ മൂല്യം iMsg പാരാമീറ്ററിലേക്ക് നൽകി, നമുക്ക് അവസ്ഥ പരിശോധിച്ച് പ്രോഗ്രാം പ്രതികരണം പ്രോഗ്രാം ചെയ്യാം.

വിൻഡോ ഫംഗ്ഷനുള്ളിൽ മുകളിൽ വിവരിച്ച ചുമതല നിർവഹിക്കുന്ന ഒരു സെലക്ഷൻ ഓപ്പറേറ്റർ ആണ്. സെലക്ഷൻ ഓപ്പറേറ്റർക്ക് ഒരു ഡിഫോൾട്ട് ഹാൻഡ്‌ലർ ഉണ്ടായിരിക്കണം, അത് DefWindowProc(hMainWnd, iMsg, wParam, lParam) എന്ന ഫംഗ്‌ഷൻ വഴി നടപ്പിലാക്കുന്നു;

ഡെൽഫിയിൽ അത്തരം പ്രോഗ്രാമുകൾ എങ്ങനെ എഴുതാം എന്നതിനെക്കുറിച്ച് കുറച്ച് വാക്കുകൾ. ഒരു പുതിയ പ്രോജക്റ്റ് സൃഷ്‌ടിക്കുക, പ്രോജക്റ്റ് മാനേജർ സമാരംഭിക്കുക, ഫോമിനൊപ്പം Unit1 ഇല്ലാതാക്കുക. Ctrl + F12 അമർത്തി പ്രോജക്റ്റ് ഫയൽ തുറക്കുക. ഉപയോഗങ്ങളിൽ നിന്ന് ഞങ്ങൾ ഫോം മൊഡ്യൂൾ നീക്കം ചെയ്യുകയും അവിടെ വിൻഡോകളും സന്ദേശങ്ങളും ചേർക്കുകയും ചെയ്യുന്നു. തുടക്കത്തിനും അവസാനത്തിനും ഇടയിലുള്ള എല്ലാം ഞങ്ങൾ ഇല്ലാതാക്കുന്നു. വർക്ക്പീസ് തയ്യാറാണ്. നിങ്ങൾക്ക് കോഡ് ചെയ്യാം. സഹായമില്ലാതെ ശുദ്ധമായ API ഉപയോഗിച്ച് പ്രോഗ്രാമുകൾ എഴുതുന്നത് അസാധ്യമാണ്, അത് എല്ലായ്പ്പോഴും കൈയിലായിരിക്കണം. നിങ്ങൾ ഗേറ്റ്സ് ആയിരുന്നെങ്കിൽ, നിങ്ങൾ എല്ലാം ഓർക്കുകയില്ല. ഞാൻ ശുപാർശചെയ്യുന്നു:

• ഒന്നാമതായി - MSDN;
• ഡെൽഫി സഹായ സംവിധാനം (MSTOOLS.HLP ഫയൽ);
• http://www.soobcha.ru/rushelp എന്ന വെബ്‌സൈറ്റിൽ Win32 API-യിൽ റഷ്യൻ സഹായം ഉണ്ട്.

അത്രയേയുള്ളൂ.
നല്ലതുവരട്ടെ.

ബോബചെങ്കോ മാക്സിംഡൗൺലോഡ്: CreateWnd.zip(2.6K)
ആർക്കൈവിൽ windows.cpp, windows.dpr എന്നീ ഫയലുകൾ അടങ്ങിയിരിക്കുന്നു

ഉപയോക്തൃ ഇൻ്റർഫേസിലേക്കുള്ള പരമ്പരാഗത ഗ്രാഫിക്കൽ സമീപനം സതർലാൻഡ്, ന്യൂമാൻ, മറ്റുള്ളവരുടെ പ്രവർത്തനവുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, അതിൽ പുനരുൽപ്പാദന ഗ്രാഫിക്കൽ ഡിസ്പ്ലേയുടെയും ലൈറ്റ് പേനയുടെയും ഉപയോഗത്തെ അടിസ്ഥാനമാക്കിയാണ് ഇടപെടൽ. ഗ്രാഫിക് ഡയലോഗിൻ്റെ കൂടുതൽ വികസനം ഇൻ്ററാക്ടീവ് കമ്പ്യൂട്ടർ ഗ്രാഫിക്സ് സിസ്റ്റങ്ങളുടെ മേഖലയിലെ പുരോഗതിയുമായി ബന്ധപ്പെട്ടിരിക്കുന്നു, ഇത് അന്താരാഷ്ട്ര മാനദണ്ഡങ്ങളുടെ രൂപത്തിൽ നിയന്ത്രണത്തിലേക്ക് നയിച്ചു.
GKS ആണ് ആദ്യത്തെ അന്താരാഷ്ട്ര ഗ്രാഫിക്സ് നിലവാരം. "വർക്ക്സ്റ്റേഷനുകൾ", ലോജിക്കൽ ഇൻപുട്ട് ഉപകരണങ്ങൾ (കീബോർഡ്, സെലക്ഷൻ, ലൊക്കേറ്റർ, മൂല്യനിർണ്ണയം, പോയിൻ്റർ, കോർഡിനേറ്റുകളുടെ ഒരു ശ്രേണിയുടെ ഇൻപുട്ട്) എന്നീ ആശയങ്ങൾ ഇത് ആദ്യമായി അവതരിപ്പിച്ചു. നിർഭാഗ്യവശാൽ വെക്റ്റർ ഡ്രോയിംഗ് മാതൃകയുടെ മേന്മയുടെ സമയത്ത് ഗർഭം ധരിച്ചു. അതിനാൽ ഡയലോഗ് പിന്തുണയുടെ ബലഹീനത: ഒരു ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിൽ നിന്ന് (ഗ്രാഫിക്സ് പാക്കേജിൻ്റെ ഉപയോക്താവ്) പോലും പുതിയ ഉപകരണങ്ങൾ നൽകാനോ സ്ക്രീനിൽ ഒരു ഉപകരണത്തിൻ്റെ ഇമേജ് പരിഷ്ക്കരിക്കാനോ ഉള്ള കഴിവില്ലായ്മ, ഇത് പ്രധാനമായും പ്രതീകാത്മക ഇൻപുട്ട് ഉപയോഗിക്കേണ്ടതിൻ്റെ ആവശ്യകതയിലേക്ക് നയിക്കുന്നു. ഒരു ഡയലോഗ് സംഘടിപ്പിക്കുന്നു. GKS-ൽ ഡയലോഗ് നടപ്പിലാക്കുന്നത് ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിൻ്റെ പ്രത്യേകാവകാശമാണ്;
ഗ്രാഫിക്സിൻ്റെ രണ്ടാമത്തെ ദിശ - ഇൻ്ററാക്ടീവ് സിസ്റ്റങ്ങളുടെ തുടർന്നുള്ള എല്ലാ വികസനത്തിലും റാസ്റ്റർ ഗ്രാഫിക്സ് വളരെ വലിയ സ്വാധീനം ചെലുത്തി. ആധുനിക വർക്ക്സ്റ്റേഷനുകളിലെ ഉപയോക്തൃ ഇൻ്റർഫേസിൻ്റെ എല്ലാ പ്രധാന സവിശേഷതകളും Xerox PARC-ൻ്റെ പ്രവർത്തനത്തിൽ നിന്ന് ഉരുത്തിരിഞ്ഞതാണ്: വിൻഡോ മാനേജ്മെൻ്റ്

• വസ്തുക്കളെ പ്രതിനിധീകരിക്കുന്നതിന് ഗ്രാഫിക് ചിഹ്നങ്ങളുടെ ("ഐക്കണുകൾ") ഉപയോഗം
• നേരിട്ടുള്ള കൃത്രിമത്വം എന്ന് വിളിക്കപ്പെടുന്ന ഇടപെടലിൻ്റെ ശൈലി
• സ്‌ക്രീൻ പൊസിഷനിംഗ് ഉപകരണമെന്ന നിലയിൽ മൗസിൻ്റെ ജനപ്രീതി
• ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് പ്രോഗ്രാമിംഗ് ശൈലി.

അതിനുശേഷം, ഉപയോക്തൃ ഇൻ്റർഫേസുകൾ സൃഷ്ടിക്കുന്നതിനും കൈകാര്യം ചെയ്യുന്നതിനുമുള്ള ടൂളുകൾക്കായുള്ള വർഗ്ഗീകരണ സംവിധാനം മൂന്ന് തലങ്ങളിൽ പരിഗണിക്കപ്പെട്ടു:

1. വിൻഡോ മാനേജ്മെൻ്റ് സിസ്റ്റങ്ങൾ (WMS - വിൻഡോ മാനേജർ സിസ്റ്റം);
2. പ്രത്യേക ഉപകരണങ്ങൾ;
   • സാധാരണ (മാകിൻ്റോഷ്, സൺവ്യൂ...)
   • ഒബ്ജക്റ്റ് ഓറിയൻ്റഡ് (സ്മോൾടോക്ക്-80, ആൻഡ്രൂ, ഇൻ്റർവ്യൂ)
3. ഉപയോക്തൃ ഇൻ്റർഫേസ് മാനേജ്മെൻ്റ് സിസ്റ്റങ്ങൾ.

ഇനിപ്പറയുന്ന വിഭാഗങ്ങൾ ഈ ഓരോ ലെവലുകളുടെയും ഒരു ഹ്രസ്വ വിവരണവും സ്റ്റാറ്റസും പ്രവർത്തന വിവരണവും നൽകും.

വിൻഡോ മാനേജ്മെൻ്റ് സിസ്റ്റംസ് (WMS)

ഒരു സ്‌ക്രീനിൽ സാധ്യമാകുന്നതിലും കൂടുതൽ വിവരങ്ങളിലേക്കുള്ള ആക്‌സസ് ഉപയോക്താവിന് മൾട്ടി-വിൻഡോ സാങ്കേതികവിദ്യ നൽകുന്നു. വിൻഡോസ് ഒന്നിലധികം വിവര സ്രോതസ്സുകളിലേക്ക് ആക്സസ് നൽകുന്നു. ഉപയോക്താവിന് നിരവധി ഉറവിടങ്ങളിൽ നിന്നുള്ള വിവരങ്ങൾ സംയോജിപ്പിക്കാനും വിവിധ തലങ്ങളിൽ വിവരങ്ങൾ പര്യവേക്ഷണം ചെയ്യാനും കഴിയും. മൾട്ടിപ്രോഗ്രാം മോഡിൽ, നിരവധി സമാന്തര ജോലികൾ കൈകാര്യം ചെയ്യാൻ സാധിക്കും. ഓരോ ടാസ്ക്കിൻ്റെയും ഇൻപുട്ടും ഔട്ട്പുട്ടും വ്യത്യസ്‌ത വിൻഡോകളിൽ പ്രദർശിപ്പിച്ചിരിക്കുന്നു, ആവശ്യാനുസരണം ഓരോ ജോലിയിലും ശ്രദ്ധ കേന്ദ്രീകരിക്കാൻ ഉപയോക്താവിനെ അനുവദിക്കുന്നു.
വിൻഡോ അധിഷ്‌ഠിത മാനേജ്‌മെൻ്റ് ഉറവിടങ്ങൾക്കായുള്ള പ്രവർത്തന അന്തരീക്ഷമായ WMS, പിന്തുണയ്ക്കുന്നു:

• ഓവർലാപ്പിംഗ് വിൻഡോകൾ (സ്ക്രീനിൻ്റെ ചതുരാകൃതിയിലുള്ള പ്രദേശങ്ങൾ);
• വിവിധ ഇൻപുട്ട് ഉപകരണങ്ങൾ (ഡിജിറ്റലും അനലോഗും);
• കഴ്സറുകൾ;
• ഫോണ്ടുകൾ.

ഓപ്പറേറ്ററുടെയും ആപ്ലിക്കേഷൻ പ്രോഗ്രാമിൻ്റെയും ഭാഗത്തുള്ള ഇൻ്റർഫേസിൽ വിൻഡോകൾ സൃഷ്‌ടിക്കുന്നതിനും നശിപ്പിക്കുന്നതിനും അവയുടെ വലുപ്പവും സ്ഥാനവും മാറ്റുന്നതിനും മുകളിലേക്ക് ഉയർത്തുന്നതിനും വിൻഡോ ഒരു ഐക്കണിലേക്ക് ചുരുക്കുന്നതിനും പുനഃസ്ഥാപിക്കുന്നതിനുമുള്ള കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു. ഒരു ഗ്രാഫിക്കൽ ഔട്ട്‌പുട്ട് ലൈബ്രറിയും (അടിസ്ഥാന പ്രാകൃതങ്ങൾ മാത്രം) ഒരു ഇവൻ്റ് ഹാൻഡ്‌ലറും അടങ്ങിയിരിക്കുന്നു. അതിനാൽ, യൂസർ ഇൻ്റർഫേസ് നടപ്പിലാക്കുന്നതിന് ചില സംവിധാനങ്ങളുണ്ട്.
രണ്ട് തരം ഡബ്ല്യുഎംഎസ് നടപ്പിലാക്കലുകൾ സാധ്യമാണ്: ഒരു മെഷീനിൽ പ്രവർത്തിക്കുന്ന അടിസ്ഥാന സിസ്റ്റം (കേർണൽ സിസ്റ്റം), ക്ലയൻ്റ്-സെർവർ മോഡലിനെ അടിസ്ഥാനമാക്കി നടപ്പിലാക്കുന്ന നെറ്റ്‌വർക്ക് (നെറ്റ്‌വർക്ക് ഓറിയൻ്റഡ്).

യൂസർ ഇൻ്റർഫേസ് ക്രിയേഷൻ ടൂൾകിറ്റ്