Mahitaji ya ukuzaji wa kiolesura cha picha cha IS

Imechangiwa na Saleem Gul na Tomas Pavek

Mafunzo haya yanashughulikia kuunda kiolesura rahisi cha kielelezo cha mtumiaji na kuongeza utendaji rahisi wa upande wa seva kwake. Hasa, tutaangalia msimbo unaofafanua tabia ya vifungo na mashamba kwenye fomu ya Swing.

Tutaangalia mpangilio na muundo wa GUI, kisha kuongeza vifungo na sehemu za maandishi. Sehemu za maandishi zimeundwa kupokea habari iliyoingizwa na mtumiaji na kuonyesha matokeo ya programu. Kitufe kitaanzisha uendeshaji wa kazi zilizojengwa kwenye sehemu ya mteja ya programu. Programu inayoundwa ni kikokotoo rahisi lakini kinachofanya kazi kikamilifu.

Kwa mwongozo wa kina zaidi wa vipengele vya ukuzaji vya Mbuni wa GUI, ikijumuisha maonyesho ya video ya vipengele mbalimbali vya ukuzaji, ona.

Muda uliokadiriwa: Dakika 20

Zoezi la 1: Kuunda Mradi

Hatua ya kwanza ni kuunda mradi wa IDE kwa programu unayotengeneza. Hebu tupe jina la mradi NumberAddition.

  1. Chagua Faili > Mradi Mpya. Unaweza pia kubofya ikoni ya Mradi Mpya kwenye upau wa vidhibiti wa IDE.
  2. Katika eneo la Jamii, chagua nodi ya Java. Katika eneo la "Miradi", chagua "Maombi ya Java". Bonyeza "Ijayo".
  3. Weka Nambari ya Nyongeza katika sehemu ya Jina la Mradi na ubainishe njia, kama vile saraka ya nyumba yako, kama eneo la mradi.
  4. Chagua kisanduku cha kuteua "Tumia folda tofauti ili kuhifadhi maktaba" na ueleze eneo la folda ya maktaba (hiari). Kwa maelezo zaidi, angalia Shiriki maktaba na wengine katika hati Kutengeneza Programu kwa kutumia NetBeans IDE.
  5. Ondoa kisanduku cha kuteua cha "Unda Daraja Kuu" ikiwa imechaguliwa.
  6. Bofya kitufe cha "Imefanyika".

Zoezi la 2: Kuunda Mwisho wa Mbele

Ili kuendelea na mchakato wa kuunda kiolesura, unahitaji kuunda chombo cha Java ambacho vipengele vingine vinavyohitajika vya GUI vitawekwa. Katika shughuli hii, kontena itaundwa kwa kutumia kipengele cha JFrame. Chombo kitawekwa kwenye kifurushi kipya, ambacho kitaonekana kwenye nodi ya "Vifurushi vya Chanzo".

Kuunda Chombo cha JFrame

  1. Katika dirisha la Miradi, bonyeza-click nodi ya NumberAddition na uchague Mpya > Nyingine.
  2. Katika sanduku la mazungumzo la Unda Faili, chagua kitengo cha Fomu za Swing GUI na aina ya faili ya JFrame. Bonyeza "Ijayo".
  3. Weka NumberAdditionUI kama jina la darasa.
  4. Chagua kifurushi cha my.numberadition.
  5. Bofya kitufe cha "Imefanyika".

IDE huunda fomu ya NumberAdditionUI na darasa la NumberAdditionUI katika programu ya NumberAddition na kufungua fomu ya NumberAdditionUI katika GUI Builder. Kifurushi cha my.NumberAddition kinachukua nafasi ya kifurushi chaguomsingi.

Kuongeza Vipengee: Kuunda Mwisho wa Mbele

Ifuatayo, kwa kutumia dirisha la "Palette", kiolesura cha nje cha programu kinajazwa na JPanel. Baada ya hayo, vipengele vitatu vya JLabel (lebo za maandishi), vipengele vitatu vya JTextField (mashamba ya maandishi), na vipengele vitatu vya JButton (vifungo) vinaongezwa. Ikiwa haujafanya kazi na mbuni wa GUI hapo awali, angalia Kubuni GUI ya Swing katika NetBeans IDE kwa maelezo kuhusu uwekaji wa sehemu.

Baada ya kuburuta na kuweka vipengele vilivyo hapo juu, kipengele cha JFrame kinapaswa kuonekana kama picha iliyo hapa chini.

Ikiwa hakuna dirisha la Palette kwenye kona ya juu ya kulia ya IDE, chagua Dirisha > Palette.

  1. Ili kuanza, chagua paneli kutoka kwa kategoria ya Vyombo vya Swing kwenye ubao na uiburute hadi kwenye JFrame.
  2. JPanel itaangaziwa. Nenda kwenye dirisha la Sifa na ubofye kitufe cha duaradufu (...) karibu na uwanja wa Mpaka ili kuchagua mtindo wa mpaka.
  3. Katika sanduku la mazungumzo ya Mpaka, chagua TitledBorder kutoka kwenye orodha na uingie Ongezeko la Nambari kwenye uwanja wa Kichwa. Bofya "Sawa" ili kuhifadhi mabadiliko yako na ufunge kisanduku cha mazungumzo.
  4. Skrini sasa inapaswa kuonyesha kipengee tupu cha "JFrame" chenye kichwa "Ongezeko la Nambari" kama inavyoonyeshwa kwenye picha. Kama ilivyo kwa picha, ongeza JLabels tatu, JTextFields tatu na JButtons tatu kwake.

Kubadilisha vipengele

Hatua hii itabadilisha jina la vipengele ambavyo vimeongezwa kwenye kipengele cha JFrame.

  1. Bofya mara mbili jLabel1 na ubadilishe ntrcn (mali ya "maandishi") kuwa Nambari ya Kwanza.
  2. Bonyeza mara mbili jLabel2 na ubadilishe maandishi kuwa Nambari ya Pili.
  3. Bonyeza mara mbili jLabel3 na ubadilishe maandishi kuwa Matokeo.
  4. Ondoa maandishi chaguo-msingi kutoka kwa jTextField1. Maandishi yanayoonyeshwa yanaweza kubadilishwa kuwa maandishi yanayoweza kuhaririwa. Ili kufanya hivyo, bonyeza-click shamba la maandishi na uchague "Hariri Maandishi" kutoka kwenye orodha ya pop-up. Hii inaweza kukuhitaji kurejesha jTextField1 kwa saizi yake asili. Rudia hatua hii kwa uga za jTextField2 na jTextField3.
  5. Badilisha maandishi ya onyesho ya jButton1 kuwa Futa . (Ili kubadilisha maandishi ya kitufe, bofya-kulia kitufe na uchague Hariri Maandishi. Vinginevyo, unaweza kubofya kitufe, sitisha, na ubofye tena.)
  6. Badilisha maandishi ya onyesho ya jButton2 kuwa Ongeza .
  7. Badilisha maandishi ya onyesho ya jButton3 kuwa Toka .

Sasa GUI iliyokamilishwa inapaswa kuonekana kama picha hapa chini:

Zoezi la 3: Kuongeza utendaji

Zoezi hili litaongeza utendakazi unaohitajika kwenye vitufe vya Ongeza, Futa na Toka. Sehemu jTextField1 na jTextField2 zitatumika kwa ingizo la mtumiaji, na jTextField3 itatumika kuonyesha matokeo ya programu. Mpango ulioundwa ni calculator rahisi. Basi tuanze!

Inaongeza utendakazi kwenye kitufe cha Toka

Ili vifungo vifanye kazi, kila mmoja wao lazima apewe msimamizi wa tukio, ambaye atakuwa na jukumu la kujibu matukio. Kwa upande wetu, tunahitaji kutambua tukio la kubofya kifungo - ama kwa kubofya panya au kutumia kibodi. Kwa hivyo, kiolesura cha "ActionListener" kitatumika kushughulikia matukio ya "ActionEvent".

  1. Bonyeza-click kitufe cha "Toka". Kutoka kwa menyu ibukizi, chagua Matukio > Kitendo > Kitendo Kimetekelezwa. Tafadhali kumbuka kuwa menyu ina matukio mengine mengi ambayo programu inaweza kujibu! Unapochagua tukio lililotekelezwa, IDE itaongeza kiotomatiki ActionListener kwenye kitufe cha Toka na kuunda mbinu ya kidhibiti ili kushughulikia mbinu ya msikilizaji iliyotekelezwa.
  2. IDE inafungua kiotomatiki Dirisha la Msimbo wa Chanzo, kukuonyesha mahali pa kuingiza kitendo unachotaka kifungo kifanye unapobofya (na kipanya chako au kibodi). Dirisha la "Msimbo wa Chanzo" linapaswa kuwa na mistari ifuatayo: utupu wa faragha jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO ongeza msimbo wako wa kushughulikia hapa: )
  3. Sasa hebu tuongeze msimbo wa kitendo ambacho kitufe cha "Toka" kinapaswa kufanya. Badilisha mstari wa TODO na System.exit(0); . Msimbo uliokamilika wa kitufe cha "Ondoka" unapaswa kuonekana kama hii: utupu wa faragha jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Kuongeza utendaji kwa kitufe cha "Futa".

  1. Bonyeza kulia kitufe cha "Futa" (jButton1). Kutoka kwa menyu inayoonekana, chagua "Matukio > Kitendo > Kitendo Kimetekelezwa".
  2. Kubofya kitufe cha "Futa" kunapaswa kusababisha maandishi yote kuondolewa kwenye sehemu zote za maandishi za "jTextField". Ili kufanya hivyo, ongeza nambari inayofanana na ile iliyo hapo juu. Msimbo wa chanzo uliokamilika unapaswa kuonekana kama hii: utupu wa faragha jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText("");

Msimbo huu huondoa maandishi kutoka kwa JTextFields zote tatu, na kuziacha tupu.

Kuongeza utendaji kwa kitufe cha "Ongeza".

Kitufe cha "Ongeza" kinapaswa kufanya mambo matatu.

  1. Kwanza huchukua ingizo la mtumiaji katika sehemu za jTextField1 na jTextField2 na kuzibadilisha kutoka kwa aina ya "Kamba" hadi aina ya "Float".
  2. Kisha itafanya nyongeza ya nambari mbili.
  3. Mwishowe, itabadilisha jumla kuwa Kamba na kuiweka ndani jTextField3 .
Hebu tuanze!
  1. Bofya kichupo cha Kubuni kilicho juu ya nafasi ya kazi ili kurudi kwenye skrini ya Usanifu wa Fomu.
  2. Bofya kulia kitufe cha "Ongeza" (jButton2). Kutoka kwa menyu ibukizi, chagua Matukio > Kitendo > Kitendo Kimetekelezwa.
  3. Ongeza msimbo kwa vitendo ambavyo kitufe cha "Ongeza" kinapaswa kufanya. Nambari ya chanzo iliyokamilishwa inapaswa kuonekana kama hii: utupu wa kibinafsi jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Kwanza tunafafanua vigeu vya kuelea. float num1, num2, tokeo; // Lazima tuchanganue maandishi kwa aina ya kuelea. num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Sasa tunaweza kuongeza. result = num1+num2; // Sasa tutapitisha thamani ya matokeo kwa jTextField3. // Wakati huo huo, tutaenda // kubadilisha thamani ya matokeo kutoka kwa kuelea hadi kwa kamba. jTextField3.setText(String.valueOf(matokeo)); )

Sasa mpango uko tayari kabisa, na unaweza kuanza kukusanyika na kutekeleza.

Zoezi la 4: Utekelezaji wa Mpango

Ili kuendesha programu katika IDE, fuata hatua hizi:

  1. Chagua Endesha > Endesha Mradi Mkuu (vinginevyo, bonyeza F6).

    Kumbuka. Ukifungua kidirisha kinachoonyesha kwamba Project NumberAddition haina darasa kuu lililobainishwa, unapaswa kuchagua my.NumberAddition.NumberAdditionUI kama darasa kuu katika dirisha moja na ubofye SAWA.

Ili kuendesha programu nje ya IDE, fuata hatua hizi:

Baada ya sekunde chache programu itazindua.

Kumbuka. Ikiwa kubofya mara mbili faili ya JAR hakuzinduzi programu, angalia uhusiano wa faili za JAR kwenye mfumo wako wa uendeshaji kwa maelezo zaidi.

Unaweza pia kuendesha programu kutoka kwa mstari wa amri.

Ili kuendesha programu kutoka kwa mstari wa amri, fuata hatua hizi:

  1. Fungua haraka ya amri au dirisha la terminal.
  2. Kwa haraka ya amri, badilisha saraka ya sasa kwenye saraka ya NumberAddition/dist.
  3. Kwa haraka ya amri, ingiza taarifa ifuatayo: java -jar NumberAddition.jar

    Kumbuka. Hakikisha kuwa my.NumberAddition.NumberAdditionUI imewekwa kama darasa kuu kabla ya kuendesha programu. Ili kuangalia hili, bofya kulia nodi ya mradi wa NumberAddition kwenye paneli ya Miradi, chagua Sifa kutoka kwenye menyu ibukizi, na uchague kategoria ya Endesha kwenye kisanduku cha mazungumzo cha Sifa za Mradi. Sehemu ya Daraja Kuu inapaswa kuonyesha my.numberaddition.NumberAdditionUI .

Injini ya Kuchakata Tukio

Mafunzo haya yaliangalia kujibu tukio rahisi la kubofya kitufe. Kuna matukio mengi ambayo programu inaweza kujibu. Katika IDE, unaweza kuona orodha ya matukio yanayopatikana ambayo yanaweza kuchakatwa na vipengele vya GUI kama ifuatavyo:

  1. Rudi kwenye faili ya NumberAdditionUI.java katika kihariri. Bofya kichupo cha "Design" ili kuona muundo wa GUI katika GUI Builder.
  2. Bofya kulia kipengele chochote cha GUI na uchague "Matukio" kutoka kwenye menyu inayoonekana. Sasa unaweza kuchunguza yaliyomo kwenye menyu bila kuchagua vipengee vyovyote.
  3. Vinginevyo, unaweza kuchagua "Mali" kutoka kwenye menyu ya "Dirisha". Katika dirisha la Sifa, bofya kichupo cha Matukio. Kichupo cha "Matukio" hukuruhusu kutazama na kubadilisha vidhibiti vya tukio vinavyohusishwa na kipengee amilifu cha GUI kwa sasa.
  4. Programu inaweza pia kujibu mibofyo mibofyo, mibofyo moja, mara mbili au tatu, miondoko ya kielekezi cha kipanya, kubadilisha ukubwa wa dirisha na miondoko ya umakini wa ingizo. Menyu ya "Matukio" hukuruhusu kuunda kidhibiti cha matukio kiotomatiki kwa matukio haya yote. Ya kawaida zaidi ya haya ni tukio la "Kitendo". (Kwa maelezo zaidi, angalia jinsi ya kushughulikia matukio katika Mafunzo ya Matukio ya Sun Java.)

Je! matukio huchakatwa vipi? Wakati wowote unapochagua tukio kutoka kwa menyu ya tukio, IDE huunda kiotomatiki kile kinachoitwa msikilizaji wa tukio na kukihusisha na kijenzi cha msanidi. Ili kupata maelezo zaidi kuhusu uchakataji wa tukio, fuata hatua hizi:

  1. Rudi kwenye faili ya NumberAdditionUI.java katika kihariri. Bofya kichupo cha "Chanzo" ili kuona msimbo wa chanzo wa GUI.
  2. Sogeza chini ili kuona mbinu zilizotekelezwa za jButton1ActionPerformed() , jButton2ActionPerformed() , na jButton3ActionPerformed(). Njia hizi huitwa washughulikiaji wa hafla.
  3. Sasa nenda kwa initComponents() njia. Ikiwa njia hii haipo, pata mstari wa Msimbo unaozalishwa na ubofye ishara + karibu na mstari huo ili kuonyesha njia iliyofichwa ya initComponents().
  4. Angalia kizuizi cha bluu kinachozunguka njia ya initComponents(). Msimbo huu ulitolewa kiotomatiki na IDE na hauwezi kurekebishwa na mtumiaji.
  5. Sasa angalia initComponents() njia yenyewe. Miongoni mwa mambo mengine, ina msimbo unaoanzisha vipengele vya GUI na kuziweka kwenye fomu. Msimbo huu huzalishwa na kusasishwa kiotomatiki unapoweka na kubadilisha vipengele katika hali ya muundo.
  6. Katika njia ya initComponents(), pata kijisehemu kifuatacho: jButton3.setText("Toka"); jButton3.addActionListener(mpya java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));

    Kwa wakati huu, kitu cha msikilizaji wa tukio la "ActionListener" kinaongezwa kwenye kipengele cha GUI, katika kesi hii jButton3 . Kiolesura cha "ActionListener" kina mbinu ya "actionPerformed" kwenye kitu cha "ActionEvent", ambayo inatekelezwa kwa kumwita tu kidhibiti cha tukio cha jButton3ActionPerformed. Kitufe hiki sasa kinajibu matukio ya vitendo. Kila wakati kitufe kinapobofya, "ActionEvent" inatolewa na kupitishwa kwa mbinu ya "actionPerformed" ya kiolesura cha msikilizaji wa tukio, ambayo hutekeleza msimbo ambao msanidi alitoa kwa tukio hilo katika kidhibiti cha tukio.

  7. Kadi ya Kujifunza ya Programu za Java GUI

Kiwango cha GUI.

Moja ya mabadiliko muhimu zaidi katika tasnia ya kompyuta ni ujio wa kiolesura cha picha. Kwa hivyo kuna haja ya kupitisha viwango vya GUI ambavyo vinafafanua programu za Windows zinapaswa kuonekanaje? Macintosh na kadhalika. Kuna hata programu za uthibitishaji ambazo wachuuzi hurekebisha programu zao ili kupata beji ya Windows. Hii inafanywa kwa sababu kadhaa.

Moja ya faida za Windows au Mac ni mwonekano wao wa kawaida. Unapojifunza kufanya kazi katika mojawapo yao, fikiria kwamba umeweza kufahamu wengine. Programu nyingi za Windows hutumia kanuni sawa, kwa hivyo unajua jinsi ya kufungua, kuhifadhi, kuchapisha, kufunga na kunakili faili katika yoyote kati yao. Kiolesura cha kawaida ni rahisi sana kwa mtumiaji. Unahitaji kujaribu kufanya programu zako zifanane na programu zingine za Windows ambazo watumiaji tayari wamejifunza kufanya kazi nazo. Kuna kanuni saba za jumla za muundo wa GUI. Ukizijifunza na kuzifuata, muundo wa programu yako utakuwa sawa.

Kanuni saba za muundo wa GUI.

Kanuni saba za jumla za muundo wa GUI zimechukuliwa kutoka kwa Mwongozo wa Kiolesura cha Microsoft Windows. Wanaunda mchoro ambao unaweza kuunda viwango vyako mwenyewe. Muundo huu huwapa watengenezaji na watumiaji faida mbili muhimu. Kwanza kabisa, programu zinaonekana kitaaluma. Pili, zinafanya kazi, zinaendana na programu zingine, na ni rahisi kwa watumiaji kujifunza.

Bila shaka, ili maombi yawe na mafanikio, lazima yameandikwa vizuri na yenye manufaa - haya ndiyo mahitaji makuu. Kanuni tunazozungumzia humpa msanidi programu mawazo.

1. Ruhusu mtumiaji kudhibiti programu.

2. Fuata dhana ya kitu/kitendo.

3. Kuwa thabiti.

4. Fanya kutumia programu rahisi na dhahiri.

5. Jitahidi kupata maelewano.

6. Toa maoni ya mtumiaji.

7. Kuwa mpole

Kanuni ya Kwanza: Mpe mtumiaji udhibiti wa programu.

Mtumiaji lazima adhibiti programu, ambayo ni, ufikiaji wa kila moduli ya programu kutoka kwa moduli nyingine yoyote. Hapo awali, orodha ya hierarchical ilitumiwa kwa upatikanaji huo.


Hebu tuseme mtumiaji anataka kuongeza mteja mpya. Katika mfano, mtumiaji lazima aende kwenye sehemu ya ACCOUNTS RECCIEVAble kisha aongeze mteja mpya kutoka hapo. Anajuaje la kufanya? Labda kutokana na uzoefu wangu na programu hii. Na katika ulimwengu wa GUI, mtumiaji anachagua tu amri Mpya kutoka kwa menyu, kisha Mteja, kama inavyoonyeshwa kwenye Mtini. Katika mfumo huu wa kisasa, unaweza kuongeza mteja mpya, muuzaji au orodha ya bidhaa kupitia menyu ya Faili. Hii hukuruhusu kubadilisha rekodi ya mteja ukiwa kwenye skrini ya mfanyabiashara na kinyume chake. Mtumiaji hahitaji tena kuvinjari menyu changamano na zenye kutatanisha za daraja.

Kanuni ya pili: fuata dhana ya kitu/kitendo.

Mtazamo wa kitu/kitendo unasema kuwa operesheni fulani inaweza kufanywa kwa vitu vyote kwenye mfumo. Mfano rahisi na dhahiri zaidi ni skrini ya usaidizi wa hifadhidata ya mteja (Mtini.). Skrini ina seti ya vifungo na kila moja ya chini inakuwezesha kufanya baadhi ya hatua kwenye habari kuhusu mteja aliyechaguliwa. Unaweza kuifuta, kuihariri, kuchapisha, nk. Vitendo vinavyoweza kufanywa kwa mteja fulani lazima vipatikane au visipatikane kwa wakati unaofaa. Kwa mfano, wakati rekodi ya mteja iko katika hali ya kuhariri, vitufe vya Futa na Mpya vinapaswa kuzimwa.

Kanuni ya tatu: kuwa thabiti.

Uthabiti ni mojawapo ya kanuni muhimu zaidi za muundo wa GUI. GUI - ruhusu watumiaji kuchunguza programu zaidi kuliko programu za zamani. Na shukrani hii yote kwa kanuni ya msimamo. Mtumiaji anapokutana na programu mpya, tayari anafahamu amri za msingi: kufungua, kuchapisha na kuhifadhi faili. Maombi yaliyotengenezwa kwenye majukwaa haya kwa kawaida yanawiana.

Kwa hiyo, wakati wa kuunda programu mpya, kuwa thabiti. Ikiwa ulitumia amri Mpya kuongeza ingizo jipya, itumie kila mahali. Neno hili halipaswi kubadilishwa na wengine - kwa mfano, na neno Ongeza 9ongeza). Shukrani kwa uthabiti wako, watumiaji watajua kwamba popote wanapokutana na amri Mpya, inaweza kutumika kuongeza ingizo jipya.

Kanuni ya nne: fanya kutumia programu rahisi na dhahiri.

Njia nyingine ya kueleza wazo hili ni: usitumie jargon. Kuna skrini iliyo na vifungo viwili. Mmoja wao anasema "Pakia hifadhidata", na mwingine anasema "Ondoa rekodi zilizowekwa alama za kufutwa". Ingizo la pili labda litaeleweka zaidi kwa mtumiaji.

Wakati wa kuunda programu, mara nyingi kuna jaribu la kutumia slang ya programu kwenye kiolesura. Jaribu kuepuka hili ikiwezekana.

Kanuni ya Tano: Jitahidini Kupatana

Hata katika nyeusi na nyeupe, skrini hii ina drawback muhimu ya aesthetic: background nyeupe na vitu tofauti juu yake. Katika Mtini. Skrini sawa inaonekana yenye usawa wa rangi.

Kuna mamilioni ya mchanganyiko wa rangi unaweza kuhamisha kwa Windows. Je, hii ina maana kwamba zote zinahitaji kutumiwa? Bila shaka hapana. Unapaswa kuchagua rangi rahisi, za utulivu na uepuke mchanganyiko wao wa machafuko, ambayo kwa sababu fulani baadhi ya waandaaji wa programu wanapenda.

Kanuni ya sita. Toa maoni kwa mtumiaji.

Fikiria kuwa ombi lako lina mchakato unaochukua muda mrefu kutekelezwa. Wakati huu, unaweza kuonyesha ujumbe kwenye skrini na maudhui yafuatayo: "Programu inaendelea, tafadhali subiri." Suluhisho la urahisi; lakini mtumiaji anajuaje kuwa haijagandishwa? Kwa hivyo, kuna uwezekano mkubwa kwamba atatoa programu "saluti ya vidole vitatu" (Ctrl+Alt+Del), ingawa kila kitu kitakuwa sawa na programu.

Ni bora kumwonyesha mtumiaji ni sehemu gani ya mchakato imekamilika. Kisha hatakatiza programu bila sababu, ataweza kutathmini jinsi kazi imeendelea, na kufanya mambo mengine hadi mchakato ukamilike. Kwa hivyo, tija ya mtumiaji itaongezeka kwa takriban asilimia 25. Matokeo haya yanaweza kupatikana kwa kuonyesha tu mita kwenye skrini. Kwa kawaida ujumbe kama vile "rekodi 10 kati ya 100 zimechakatwa" au "40% zimekamilika" huonyeshwa. Bora zaidi ni kuonyesha idadi ya rekodi zilizochakatwa na asilimia yao."

Kanuni ya Saba: Uwe Mwenye Kusamehe

Kila mmoja wetu wakati mwingine amefuta chapisho kwa kubofya kitufe kisicho sahihi. Kwa hiyo, mpe mtumiaji fursa ya kubadilisha mawazo yake au kufuta vitendo vilivyochukuliwa hivi karibuni. Ikiwa mchakato unachukua muda mrefu, kubadilisha data nyingi, au kuhitaji mtumiaji kuhifadhi nakala ya data kabla ya kutekeleza kitendo, unapaswa kutoa onyo. Nimeona programu zinazohitaji uthibitisho mara mbili kisha naomba nenosiri. Je, programu zako zinahitaji kiwango hiki cha ulinzi? Labda. Kazi ya msanidi programu ni kumsaidia mtumiaji ikiwa alifanya makosa katika hatua yoyote ya kazi.

Umuhimu wa kanuni za kawaida za GUI.

Kama unaweza kuona, kanuni za muundo wa GUI ni rahisi sana na zinapaswa kutumika wakati wa kuunda skrini. Hata hivyo, kabla ya kuunda skrini, unahitaji kuanzisha jinsi itaonekana. Chagua saizi zake, fonti, rangi, mitindo ya ujumbe, n.k. Kwa kutatua masuala haya mapema, utaharakisha kazi yako kwa kiasi kikubwa. Inapokuja kwa fonti au mtindo wa ujumbe baadaye, unatazama tu kiwango.


Julai 09, 2003

Pamoja na ujio wa zana mbalimbali za ukuzaji wa programu zinazoonekana, kuandika violesura vya picha vya programu kumegeuka kuwa kitu kama mchezo wa mtoto. Niliipiga na panya na fomu ikatokea; niliipiga mara ya pili na kitufe kilitokea. Inaonekana kwangu kuwa watu wengi sasa hawafikirii juu ya njia nyingine ya programu katika mazingira ya picha. Kwa kweli, huwezi kubishana dhidi ya maendeleo; wakati wa kuandika miradi mikubwa, mambo haya yote yanafaa sana. Lakini sivyo mazungumzo haya yanahusu. Wakati mwingine inakuja kwenye hatua ya upuuzi: programu ya zamani imeandikwa kwa kutumia MFC, VCL, nk. Programu kama hizo humeza kumbukumbu kama mchwa na, kwa miili yao yenye mafuta, huchukua nafasi ya ziada ya diski. Kama sheria, analogi za MFC/VCL "hupima" mara kumi hadi ishirini zaidi ya programu zilizoandikwa kwenye API safi. Na Visual Basic (Mungu anisamehe kwa kifungu hiki) na msvbvmXX.dll yake? Na rasilimali nyingi zaidi za mfumo hutumiwa (mara kadhaa). Watumiaji maskini, wakijinyima bia, huhifadhi pesa kununua vifaa vipya. Je, si ni huruma kwa mambo maskini? Sio watengeneza programu tu wanaokunywa bia? Kuna kipengele kingine chanya cha coding API: programu inakuwa karibu na mfumo wa uendeshaji. Ipasavyo, anaielewa na kuidhibiti vyema. Na ni rahisi - ni shughuli ya kusisimua sana. Narudia, yote yaliyo hapo juu yanatumika haswa kwa programu ndogo, rahisi; katika miradi mikubwa kila kitu ni tofauti kabisa.

Natumai nilikushawishi. Nenda.

Tutaangalia kuunda interface rahisi ya dirisha na utendaji mdogo. Hii itakuwa dirisha rahisi na mashamba mawili ya pembejeo na vifungo viwili. Unapobofya kitufe cha "Nakili", maandishi kutoka kwa sehemu ya kwanza ya ingizo yatanakiliwa hadi ya pili. Unapobofya kitufe cha "Funga", programu itakamilisha kazi yake. Katika siku zijazo, inaweza kutumika kama kiolezo cha kuandika programu zingine ngumu zaidi. Tutawasiliana kwa C/C++, ingawa hatutaudhi Delphi pia. Kanuni ya jumla ni sawa, tu syntax ni tofauti. Ili kufanya kazi na ujumbe wa mfumo na vitendaji vya API, unahitaji kujumuisha faili za kichwa kwenye mradi wako; katika C/C++ hii ni windows.h, huko Delphi hizi ndizo moduli za windows na ujumbe.

Programu yoyote katika Windows OS ina sehemu tatu kuu: kazi kuu, kitanzi cha ujumbe na kazi ya dirisha, ambayo inashughulikia ujumbe wote uliotumwa kwenye dirisha.

Programu yetu huanza kutekeleza na WinMain() kazi. Hii ndiyo kazi kuu. WinMain() kazi kawaida hufanya kazi zifuatazo:

  • Inafafanua darasa la dirisha. Haipaswi kuchanganyikiwa na darasa la OOP.
  • Husajili darasa hili katika mfumo.
  • Huunda dirisha kuu la programu na vidhibiti vingine.
  • Inaonyesha dirisha kwenye skrini.
  • Huanzisha kitanzi cha kuchakata ujumbe.
  • Inatangazwa hivi: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) Hebu tuangalie vigezo:
    • hInstance ni kushughulikia kwa mfano wa sasa wa programu.
    • hPrevInstance ni kushughulikia kwa mfano uliopita wa programu, ikiwa inaendeshwa.
    • lpCmdLine - kielekezi kwa mstari ulio na vigezo vilivyopitishwa kwenye programu wakati wa kuanza.
    • nCmdShow - mara kwa mara ambayo huamua jinsi dirisha inavyoonyeshwa. (Angalia SW_ thabiti).

Huko Delphi hatutaona picha kama hiyo; katika mazingira haya ya ukuzaji kazi kuu imefichwa kutoka kwa programu na mkusanyaji. Ingawa, bila shaka, iko katika kanuni ya mwisho. Ili kusajili darasa la dirisha, unahitaji kujaza mashamba ya muundo wa aina WNDCLASS (katika Delphi TWNDCLASS). Kwa kusudi hili, tumetangaza mabadiliko ya wcl. wcl.hInstance = hInstance; Ncha ya mfano wa programu ya sasa, kigezo cha hInstance kinaanzishwa na kitendakazi cha WinMain(). Huko Delphi, ilianzishwa bila uwazi. wcl.lpszClassName = szWinName; Jina la darasa. Tuliunda na kuanzisha kibadilishaji cha kamba szWinName mapema. wcl.lpfnWndProc = WindowFunc; Kielekezi kwa kitendakazi cha dirisha. wcl.style = 0; Mara kwa mara ambayo inabainisha mtindo wa dirisha. Bendera za CS_ hutumiwa kwa hili, nimezifuta hadi sifuri. Unaweza kutaja mchanganyiko wa bendera kwa kutumia "au" operesheni ya busara. wcl.hIcon = LoadIcon(NULL, IDI_ASTERISK); Ncha kwa ikoni ya programu, iliyorejeshwa na kazi ya LoadIcon(). Nilipakia ikoni ya kawaida. Angalia IDI_ thabiti. wcl.hCursor = LoadCursor(NULL, IDC_ARROW); Ncha ya kielekezi cha programu, kama ilivyorejeshwa na LoadCursor(). Nilipakia mshale wa kawaida. Angalia IDC_ zisizobadilika. wcl.lpszMenuName = NULL; Elekeza kwa mfuatano unaobainisha jina la rasilimali ya menyu ya darasa hili la dirisha. Hakuna menyu, hakuna ishara. wcl.cbClsExtra = 0; Sehemu iliyohifadhiwa. Hebu tuweke upya. wcl.cbWndExtra = 0; Sehemu iliyohifadhiwa. Hebu tuweke upya. wcl.hbrBackground = (HBRUSH)WINDOW_COLOR; Rangi ya dirisha. COLOR_WINDOW isiyobadilika inatupwa ili kuandika HBRUSH (huko Delphi hakuna haja ya kutuma). Pia, kwa kutumia kazi ya GetStockObject(), unaweza kuweka rangi ya mswaki wa dirisha au taswira ya usuli. Sasa, jisikie huru kusajili darasa la dirisha.

RegisterClass(&wcl); Kielekezi kwa muundo wa wcl kinapitishwa kama kigezo kwa kipengele cha kukokotoa cha RegisterClass.

Mstari unaofuata tunaunda dirisha letu.

hMainWnd = CreateWindow(szWinName, "Dirisha rahisi kwenye API.", WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME ^ S_MAXIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT, 300, 170, HWND_DESKTOP, NULL, hInstance, NULL);
  • Kigezo cha kwanza ni jina la darasa la dirisha.
  • Kigezo cha pili ni kichwa cha dirisha.
  • Kigezo cha tatu ni mtindo wa dirisha. Kutoka kwa WS_OVERLAPPEDWINDOW ya kawaida, kwa kutumia operesheni ya xor, niliondoa uwezo wa kuongeza dirisha na kuzima kifungo cha kuongeza.
  • Ya nne na ya tano ni nafasi ya dirisha kutoka kona ya kushoto, ya juu ya skrini. Nina CW_USEDEFAULT, kwa thamani hii mfumo huchagua nafasi ya dirisha kiotomatiki.
  • Vigezo vya sita na saba ni upana na urefu wa dirisha, kwa mtiririko huo.
  • Kigezo cha nane ni dirisha la mmiliki. Katika dirisha kuu, mmiliki ni eneo-kazi (0). Vidhibiti vina dirisha kuu.
  • Ya tisa ni pointer kwa mpini wa menyu. Hakuna menyu, hakuna ishara.
  • Kigezo cha kumi ni kushughulikia kwa mfano wa programu ya sasa.
  • Ya Kumi na Moja - Inatumika wakati wa kuunda programu na kiolesura cha MDI. Hatuhitaji.
Kazi inarudi kushughulikia kwenye dirisha lililoundwa, ambalo limehifadhiwa katika kutofautiana kwa hMainWnd.
Ncha ya dirisha ni nambari ya kipekee katika mfumo inayotambua dirisha au kidhibiti.

Ifuatayo, tutaunda vidhibiti muhimu. Vidhibiti vyote ni madirisha sawa, vina jina tofauti la darasa. Hakuna haja ya kusajili madarasa ya udhibiti; tayari yamefafanuliwa katika mfumo. Kitufe - darasa la kifungo. Sehemu ya kuingiza - hariri ya darasa. Maelezo - ststic ya darasa. Kuna madarasa mengi ambayo yanalingana na vidhibiti vya kawaida. Tunaunda vidhibiti kwa kutumia kitendakazi kinachofahamika cha CreateWindow() na kitendakazi kisichojulikana cha CreateWindowEx(). CreateWindowEx() hukuruhusu kuunda dirisha na mtindo wa hali ya juu. Tunaitumia kuunda sehemu za uingizaji. Kazi hii imeongeza parameter ya kwanza, ambayo huweka mtindo huu wa juu zaidi, vigezo vilivyobaki ni sawa na CreateWindow (). Udhibiti ni madirisha ya watoto, mmiliki wao ndiye dirisha kuu.

Wakati wa kuunda vidhibiti, katika vigezo vya kazi lazima ueleze maelezo ya dirisha kuu, pamoja na mtindo wa dirisha WS_CHILD. Mwonekano na utendakazi wa vidhibiti vinaweza kubadilishwa kwa kutumia bendera: WS_, ES_, BS_, SS_, kuzichanganya na operesheni ya "au" ya busara kidogo. Wakati wa kuunda vidhibiti, tunaanzisha vigezo vinavyolingana na maelezo yao, ambayo hurejeshwa na kazi za CreateWindow() na CreateWindowEx(). Tutahitaji vifafanuzi hivi kwa kazi zaidi na vidhibiti. Tunaonyesha dirisha tulilounda kwenye skrini na kuifungua upya.

Kitendaji cha GetMessage huchagua ujumbe unaofuata kutoka kwa foleni ya ujumbe wa programu na kuutuma kwa dirisha.
  • Kigezo cha kwanza ni muundo wa aina ya MSG (katika Delphi ya aina TMSG)
  • Kigezo cha pili ni kushughulikia kwa dirisha ambalo ujumbe unakusudiwa. Ikiwa NULL au 0, basi madirisha yote ya programu.
  • Ya tatu na ya nne - hukuruhusu kuweka anuwai ya ujumbe uliopokelewa. Kama 0, basi ujumbe wote kushughulikiwa kwa dirisha.
GetMessage - hurejesha FALSE wakati ujumbe wa WM_QUIT unaonekana, katika hali ambayo kitanzi kinatoka na programu inatoka. TranslateMessage - hutafsiri misimbo ya ufunguo pepe kuwa ujumbe wa kibodi. DispatchMessage - hutuma ujumbe kwa kazi ya dirisha kwa usindikaji.

Kazi ya dirisha hutoa utendaji wa programu kwa usindikaji ujumbe wa mfumo. Kazi ya dirisha ni kazi ya CALLBACK, i.e. inaitwa na mfumo wa uendeshaji kujibu ujumbe mpya unaoingia. Kazi ya dirisha inatangazwa kama hii:

MATOKEO YA KUPIGA SIMU WindowFunc(HWND hMainWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)

  • HMainWnd - kushughulikia kwa dirisha kuu.
  • iMsg - nambari ya ujumbe. Angalia WM_ thabiti.
  • lParam na wParam ni vigezo vya ujumbe.

Ujumbe unapoonekana, tunaweza kulinganisha kigezo cha iMsg na mojawapo ya viambajengo vya WM_ na kupanga programu ili kuitikia ipasavyo.

Kwa mfano: Kitufe cha kushoto cha kipanya kinapobonyezwa huku kielekezi cha kipanya kikiwa juu ya eneo la mteja kwenye dirisha, tukio la WM_LBUTTONOWN linainuliwa. Kazi ya dirisha inaitwa, thamani ya WM_LBUTTONDOWN ya mara kwa mara imeingia kwenye parameter ya iMsg, tunaweza kuangalia hali na kupanga majibu ya programu tunayohitaji.

Ndani ya kazi ya dirisha ni operator wa uteuzi ambaye hufanya kazi iliyoelezwa hapo juu. Opereta ya uteuzi lazima iwe na kidhibiti chaguo-msingi, ambacho kinatekelezwa na chaguo za kukokotoa DefWindowProc(hMainWnd, iMsg, wParam, lParam);

Ikiwa hii haijafanywa, programu yetu itakufa bila kufufua. Ujumbe mwingi unachakatwa na mfumo yenyewe, kama vile: kurekebisha ukubwa wa dirisha, kupunguza/kuongeza dirisha, kupiga menyu ya mfumo, nk. Hii ndio DefWindowProc() ni ya.

Wakati wa kufanya kazi na vidhibiti vya dirisha, ujumbe wa WM_COMMAND hutumwa kwa mmiliki wa dirisha, na lParam iliyo na mpini kwa udhibiti, na byte ya juu ya parameta ya wParam ni kitambulisho cha tukio lililoinuliwa kwenye udhibiti. Kwa mfano: unapobofya kitufe - BN_CLICKED. Tazama viunganishi vya BN_, WM_. Tunaweza kufunga programu kwa kutumia kitendakazi cha PostQuitMessage(0). Chaguo hili la kukokotoa hutuma ujumbe wa WM_QUIT kwenye dirisha.

Maneno machache kuhusu jinsi ya kuandika programu kama hizo huko Delphi. Unda mradi mpya, zindua Meneja wa Mradi, futa Unit1 pamoja na fomu. Bonyeza Ctrl + F12 na ufungue faili ya mradi. Tunaondoa moduli ya fomu kutoka kwa matumizi, kuongeza madirisha na ujumbe huko. Tunafuta kila kitu kati ya kuanza na mwisho. Workpiece iko tayari. Unaweza kuweka nambari. Haiwezekani kuandika programu kwa kutumia API safi bila msaada, ambayo inapaswa kuwa karibu kila wakati. Ikiwa ungekuwa Gates mwenyewe, haungekumbuka kila kitu. Napendekeza:

  • kwanza kabisa - MSDN;
  • Mfumo wa usaidizi wa Delphi (faili ya MSTOOLS.HLP);
  • Kuna msaada wa Kirusi kwenye API ya Win32 kwenye tovuti http://www.soobcha.ru/rushel.
Ni hayo tu.
Bahati njema.

Bobachenko Maxim Pakua: CreateWnd.zip(2.6K)
kumbukumbu ina faili windows.cpp na windows.dpr

Mbinu ya kimapokeo ya kiolesura cha mtumiaji inahusishwa na kazi ya Sutherland, Newman, et al., ambamo mwingiliano unategemea matumizi ya onyesho la picha lenye kuzaliwa upya na kalamu nyepesi. Maendeleo zaidi ya mazungumzo ya picha yanahusishwa na maendeleo katika uwanja wa mifumo ya picha ya kompyuta inayoingiliana, ambayo ilisababisha udhibiti katika mfumo wa viwango vya kimataifa.
GKS ndio kiwango cha kwanza cha kimataifa cha michoro. Ilianzisha kwa mara ya kwanza dhana za "vituo vya kazi" na vifaa vya kuingiza vya kimantiki (kibodi, uteuzi, locator, valuator, pointer, ingizo la mlolongo wa kuratibu). Kwa bahati mbaya mimba wakati wa ubora wa dhana ya kuchora vekta. Kwa hivyo udhaifu wa usaidizi wa mazungumzo: kutokuwa na uwezo wa kuingiza vifaa vipya au kurekebisha picha ya kifaa kwenye skrini hata kutoka kwa programu ya programu (mtumiaji wa kifurushi cha picha), ambayo husababisha hitaji la kutumia pembejeo za ishara wakati wa kuandaa mazungumzo. . Utekelezaji wa mazungumzo katika GKS ni haki ya programu ya maombi; uwezekano wa muundo tofauti haufikiriwi.
Mwelekeo wa pili wa graphics - raster graphics alikuwa na ushawishi mkubwa sana juu ya maendeleo yote ya baadae ya mifumo ya mwingiliano. Sifa zote kuu za kiolesura cha mtumiaji kwenye vituo vya kisasa vya kazi zinatokana na kazi ya Xerox PARC: usimamizi wa dirisha.

  • matumizi ya alama za picha ("ikoni") kuwakilisha vitu
  • mtindo wa mwingiliano unaoitwa ujanja wa moja kwa moja
  • umaarufu wa kipanya kama kifaa cha kuweka skrini
  • mtindo wa programu unaolenga kitu.
Tangu wakati huo, mfumo wa uainishaji wa zana za kuunda na kudhibiti miingiliano ya watumiaji umezingatiwa katika viwango vitatu:
  1. mifumo ya usimamizi wa dirisha (WMS - Mfumo wa Meneja wa Dirisha);
  2. zana maalum;
    • kawaida (MacIntosh, SunView...)
    • yenye mwelekeo wa kitu (Smalltalk-80, Andrew, Mahojiano)
  3. mifumo ya usimamizi wa kiolesura cha mtumiaji.
Sehemu zifuatazo zitatoa maelezo mafupi, hali, na maelezo ya utendaji ya kila moja ya viwango hivi.

Mifumo ya Usimamizi wa Dirisha (WMS)

Teknolojia ya madirisha mengi humpa mtumiaji ufikiaji wa habari zaidi kuliko inavyowezekana na skrini moja. Windows hutoa ufikiaji wa vyanzo vingi vya habari. Mtumiaji anaweza kuchanganya taarifa kutoka kwa vyanzo kadhaa na kuchunguza taarifa katika viwango tofauti vya maelezo. Katika hali ya programu nyingi, inawezekana kusimamia kazi kadhaa zinazofanana. Ingizo na matokeo ya kila kazi huonyeshwa katika madirisha tofauti, na kuruhusu mtumiaji kuzingatia kila kazi inavyohitajika.
WMS, mazingira ya kufanya kazi kwa rasilimali za usimamizi kulingana na dirisha, inasaidia:

  • madirisha yanayoingiliana (maeneo ya mstatili ya skrini);
  • vifaa mbalimbali vya pembejeo (digital na analog);
  • vishale;
  • fonti.
Kiolesura cha sehemu ya opereta na programu ya maombi kina amri za kuunda/kuharibu madirisha, kubadilisha ukubwa wao na nafasi, kuinua juu, kubana dirisha kwa ikoni, na kuzirejesha. Ina maktaba ya pato la mchoro (vitambulisho vya msingi pekee) na kidhibiti tukio. Kwa hivyo, kuna njia kadhaa za kutekeleza kiolesura cha mtumiaji.
Kuna aina mbili za utekelezaji wa WMS zinazowezekana: mfumo wa msingi (Mfumo wa Kernel), unaoendesha kwenye mashine moja, na mtandao (unaoelekezwa na Mtandao), unaotekelezwa kwa kuzingatia mfano wa seva ya mteja.

Zana ya Kuunda Kiolesura cha Mtumiaji



MAKALA INAYOHUSIANA