Anotasyon: Pinag-aaralan namin ang mga widget - ang mga visual na elemento na bumubuo sa graphical na user interface, kanilang layout, laki ng patakaran, signal-slot na koneksyon, graphical na interface ng mga elemento at ang kanilang paggamit.

13.1 Mga Widget

Ang mga widget ay ang mga visual na elemento na bumubuo sa graphical na user interface.

Mga halimbawa ng mga widget:

• Button (klase QPushButton);
• Label(class QLabel);
• Patlang ng input (klase QLineEdit);
• Numeric counter field (klase ng QSpinBox);
• Scroll bar (class QScrollBar ).

Ang Qt ay may humigit-kumulang 50 mga yari na klase ng mga graphic na elemento na magagamit para magamit. Ang parent class para sa lahat ng widgets ay ang QWidget class. Ang lahat ng mga pangunahing katangian ng mga visual na elemento ay minana mula dito, na maingat nating isasaalang-alang. Simulan natin ang paggalugad ng mga paraan upang bumuo ng mga program na may graphical na interface na may halimbawa.

Gumawa tayo ng walang laman na file ng proyekto. Ilunsad ang project wizard at piliin ang item sa seksyong Mga Proyekto Iba pang Proyekto. Susunod, piliin ang uri ng proyekto Walang laman ang Qt Project. Idagdag natin ang mga nilalaman sa file ng proyekto:

TEMPLATE = app #Qt modules na gagamitin namin QT += widgets #Add the widgets module to work with widgets (kinakailangan para sa Qt5). TARGET = widget#Pangalan ng executable file SOURCES += \ main.cpp

Ngayon ay lumikha tayo ng isang simpleng programa na may isang window kung saan ipapakita namin ang inskripsyon. Itakda natin ang laki ng window at ang teksto ng pamagat nito, at itakda din ang font para sa inskripsyon. Upang gawin ito, lumikha ng isang file main.cpp na may sumusunod na nilalaman:

#isama #isama int main (int lArgc, char * lArgv ) ( //Gumawa ng QApplication object na nagpapasimula at nagko-configure sa window program, //kinokontrol ang pagpapatupad nito gamit ang QApplication event loop lApplication (lArgc, lArgv); QLabel lLabel; //Gumawa ng QLabel widget - label lLabel.setText ("Ako ay widget!"); //Itakda ang teksto para sa label na lLabel.setGeometry (200, 200, 300, 150); at taas. text lLabel.setAlignment (Qt::AlignHCenter | Qt::AlignVCenter); ", 12); setFont (lBlackFont); //Itakda ang font para sa label na lLabel.show (); //Tawagan ang show() na paraan upang ipakita ang label sa screen return lApplication.exec (); //Patakbuhin ang program na mag-execute ng exec() //cycle na pagpoproseso ng kaganapan.

Tulad ng nakikita mo, ang mga elemento na bumubuo sa mga interface sa Qt ay may sariling posisyon at sukat - ang tinatawag na "geometry" - at sa gayon ay sumasakop sa isang kaukulang hugis-parihaba na lugar sa screen (tingnan ang Fig. 13.1). Gayundin, ang bawat elemento ay may mga setting na tumutukoy sa pag-uugali at hitsura nito.

kanin. 13.1.

Upang lumikha ng isang istraktura, ang mga widget ay isinaayos sa isang hierarchy ayon sa "bahagi - buo" na prinsipyo. Ang bawat widget ay maaaring maglaman ng iba pang mga widget. Ang visual na elementong ito ay nagiging "parent" (parent widget) ng mga elementong nilalaman nito. Tandaan na ang mga naturang relasyon ay hindi dapat malito sa mana sa C++ - mga relasyon sa pagitan ng mga klase sa isang programa. Ang mga relasyon sa pagitan ng mga widget ay mga relasyon sa pagitan ng mga bagay. Ang ganitong mga relasyon ay nagdudulot ng ilang mga kahihinatnan:

• ang parent element ang mananagot sa pagtanggal ng child element: kung ang parent na widget ay tatanggalin, awtomatiko nitong tatanggalin ang lahat ng child element;
• inilalagay ng parent widget ang mga child widgets sa loob mismo, ang mga bahagi ng child widgets na lumalampas sa magulang ay hindi makikita;
• bahagi ng estado ng parent na widget ang inililipat sa mga anak nito - nalalapat ito sa ilang property (visibility, aktibidad) at mga istilo na inilalapat sa visual na elemento.

Ang mga widget na walang magulang (mga top-level na widget) ay lumalabas bilang hiwalay na mga window sa program. Tingnan natin ang isang halimbawa. Pangalanan natin ang bagong proyektong ParentExample. Ang file ng proyekto ay maglalaman ng karaniwang mga setting para sa isang proyekto ng GUI:

TEMPLATE = app TARGET = ParentExample QT += mga widget

Para sa widget na gagamitin namin bilang pangunahing window, gagawa kami ng bagong klase. Para dito sa kategorya Mga File at Klase Piliin natin ang seksyong C++ at piliin ang C++ Class (tingnan ang Fig. 13.2).

Ang susunod na hakbang ay upang lumikha ng ilang mga elemento sa window. Upang gawin ito, buksan ang parentwidget.cpp file at baguhin ang code ng constructor ng klase. Upang ipakita ang mga elemento, likhain lamang ang mga ito sa tagabuo ng klase at itakda ang ParentWidget bilang magulang para sa kanila. Ang parentwidget.cpp code ay ganito ang hitsura:

#include " parentwidget.h " #include #isama #isama ParentWidget::ParentWidget (QWidget * parent) : QWidget (parent) ( //Gumawa ng label na nagsasaad ng parent widget - ito, iyon ay, isang instance ng ParentWidget class. QLabel * lLabel=new QLabel (ito); //Posisyon kaugnay sa itaas na kaliwang sulok ng parent widget lLabel ->setGeometry (50, 0, 100, 30); lLabel ->setText (" TextLabel "); QPushButton * lPushButton = bagong QPushButton (ito); lPushButton->setGeometry (50, 50, 100, 30); lPushButton->setText (" PushButton "); QLineEdit * lLineEdit = bagong QLineEdit (ito); lLineEdit ->setGeometry (50, 100, 100, 30); lLineEdit ("LineEdit"); halimbawa) //Sa wakas ay baguhin ang laki ng parent widget setGeometry (x (), y (), 300, 150 //at itakda ang window title text setWindowTitle (" parent widgetExample ");

Dahil ang parent element ay ParentWidget , ang label (QLabel), button (QPushButton) at text field (QLineEdit) ay nasa loob nito. Ang posisyon ng mga widget ng bata ay itinakda kaugnay sa kaliwang sulok sa itaas ng ama. Madali mong mabe-verify ito sa pamamagitan ng pagbabago ng laki at posisyon ng window ng aming programa. Pansinin kung paano namin ginawa ang mga elemento ng UI sa heap gamit ang bagong operator. Tinitiyak nito na ang mga elemento ay hindi maaalis pagkatapos makumpleto ang ParentWidget constructor.

Pag-unlad ng GUI

Ang pangunahing paraan ng pakikipag-ugnayan ng user sa programa ay ang Graphical User Interface (GUI). Ang GUI ng anumang produkto ng software ay isa sa mga pangunahing salik sa pagiging popular nito.

Ang paglikha ng karampatang user interface ay isang prosesong matrabaho at nangangailangan ng pinakamataas na atensyon sa detalye. Ang interface na nilikha ay dapat na i-maximize ang mga kakayahan ng programa, ngunit sa parehong oras ay hindi overload ang user na may isang kasaganaan ng mga menu, mga pindutan, mga imahe at teksto.

Sa pagsasagawa, ang pagprograma ng mga aplikasyon ng Windows ay nagsasangkot ng malawakang paggamit ng iba't ibang mga tool at wizard. Kaya, isinasaalang-alang ang mga pamantayan ng napiling operating system, ang software ay magkakaroon ng windowed interface. Ito ay dahil, una sa lahat, sa katotohanan na ang mga bintana ay ang mga pangunahing elemento ng graphical na interface sa mga operating system (OS) ng pamilyang Windows. Ang mga ito ay mga hugis-parihaba na lugar na may sariling mga setting, katangian at uri.

Kasama sa graphic na bahagi ng bloke ng pagsasanay ang mga bintana ng apat na uri:

Ang pangunahing window ay naglalaman ng lahat ng mga elemento ng nabigasyon sa loob ng programa, pati na rin ang karagdagang impormasyon na kinakailangan para sa kaginhawaan ng pagtatrabaho sa software;

Kasama sa mga window ng pamamahala ng base ng impormasyon ang lahat ng elemento ng kontrol ng bahagi ng impormasyon ng tool ng software. Nagbibigay sila ng pagdaragdag ng mga pagsubok, impormasyon, mga bagong user at administrator, at pinapayagan ang pagmamanipula ng bagong likha o umiiral na data;

Windows para sa pagtatrabaho sa mga kakayahan ng software - magbigay ng trabaho sa mga pangunahing pag-andar ng bloke ng pagsasanay, tulad ng pagpasa sa mga pagsusulit at pag-aaral ng mga lektura;

Windows para sa pagpapakita ng impormasyon at istatistika -- nagsisilbing ipakita ang iba't ibang uri ng impormasyon, pati na rin ang mga istatistika at mga graph.

Ang pangunahing window ng programa ay maglalaman ng mga sumusunod na kontrol at output ng impormasyon:

Pamagat ng window, na naglalaman ng pangalan ng programa at ang layunin ng window;

Mga pindutan ng menu ng system na responsable para sa pagbabago ng laki, pagliit at pagsasara ng programa;

Ang lugar ng pamagat ng window, na may purong pandekorasyon na function at kinakailangan upang sumunod sa pangkalahatang solusyon sa disenyo;

Welcome area;

Lugar para sa pagpapakita ng araw ng linggo, kasalukuyang petsa at oras;

Pasadyang toolbar na naglalaman ng mga pindutan upang ma-access ang mga pangunahing function ng programa;

Ang panel ng administratibo ay may kasamang isang pindutan upang ma-access ang mga administratibong kontrol ng PS;

Status bar na nagpapakita ng impormasyon tungkol sa lahat ng operating mode ng program.

Ang diagram ng pangunahing window ng graphical interface (window view para sa isang administrative account) ay ipinapakita sa Figure 3.2

Figure 3.2 -- Diagram ng pangunahing window ng graphical na interface: 1 -- pamagat ng window; 2 -- mga pindutan ng menu ng system; 3 -- lugar ng pamagat ng window; 4 -- status bar; 5 -- welcome area; 6 -- lugar para sa pagpapakita ng araw ng linggo, petsa at oras; 7 -- administratibong panel; 8 -- panel ng gumagamit; 9 -- button upang ma-access ang yugto ng pag-aaral; 10 -- button upang ma-access ang yugto ng pagsubok; 11 -- button para sa pagpapakita ng mga istatistika at mga graph; 12 -- labasan; 13 -- button para ma-access ang administratibong bahagi ng application

Isinasaalang-alang ang pokus ng software na binuo, maraming hindi karaniwang mga graphic na solusyon ang binuo upang maakit ang atensyon at higit na interes sa application. Bilang karagdagan, ito ay nagbibigay-daan sa iyo upang makakuha ng ilang uri ng sariling katangian sa iba pang hanay ng mga programa ng mga katulad na paksa at pokus.

Ang isa sa mga solusyon na ito ay maaaring tawaging makulay na mga elemento ng interface na lumikha ng isang natatanging disenyo, na walang mga analogue sa lugar na ito. Pinag-uusapan natin ang tungkol sa mga animated na pagsingit batay sa Flash animation. Sa kanilang tulong, ipinatupad ang disenyo ng mga pangalan ng lahat ng pangunahing functional window, mga elemento ng nabigasyon, at ang interface ng form ng pagpaparehistro at awtorisasyon. Ang mga pangunahing bentahe ng pag-unlad na ito ay: pagpapatupad ng isang kaaya-aya at user-friendly na interface; makabuluhang pagpapasimple ng paggamit ng programa, kapwa sa antas ng user at administratibo.

Ang isa pang pangunahing bentahe sa mga analogue na programa, kapwa sa software at sa graphical na pagpapatupad, ay ang samahan ng pagpasa ng mga pagsubok kapag hiniling. Upang makapasa sa ganitong uri ng pagsubok, ang user ay dapat mag-assemble ng mga SQL query mula sa hiwalay, independiyenteng mga elemento. Depende sa uri ng kahilingan na kailangang gawin batay sa mga kondisyon ng iminungkahing gawain, isang partikular na polygon para sa pagpupulong ay nabuo. Ang polygon ay naglalaman ng mga patlang para sa pagpapalit ng mga operator na na-drag sa kanila gamit ang mouse mula sa isang hiwalay na bloke, at mga patlang para sa pagpasok ng mga pangalan ng mga talahanayan, mga patlang at kundisyon.

Ang mga istatistika ng gumagamit ay ipinatupad sa anyo ng mga graph, na binuo depende sa mga resulta na nakuha niya. Ang bawat pagsubok ay may sariling dinamika. Ang mga chart ay naglalaman ng lahat ng kinakailangang lagda, ay ipinatupad gamit ang TChart component, at samakatuwid ay mayroong maraming mga kontrol na binuo sa component bilang default at, bilang resulta, ipinatupad sa application.

Gayundin, para sa isang mas madaling gamitin na visualization, ang mga istilo ng header ng talahanayan ay pinalitan ng mga ipinatupad sa default na kapaligiran sa pag-develop.

Kaya, ang ipinatupad na mga graphic na solusyon ay naging posible upang makamit ang resulta na inaasahan ng mismong ideya ng disenyo ng GUI. Ang nilikha na interface ay nagpapalaki sa mga kakayahan ng programa, ngunit sa parehong oras ay hindi labis na karga ang gumagamit na may kasaganaan ng mga menu, mga pindutan, mga imahe at teksto.

Iniambag nina Saleem Gul at Tomas Pavek

Sinasaklaw ng tutorial na ito ang paglikha ng isang simpleng graphical na user interface at pagdaragdag ng simpleng paggana sa gilid ng server dito. Sa partikular, titingnan natin ang code na tumutukoy sa gawi ng mga button at field sa isang Swing form.

Titingnan natin ang layout at istraktura ng GUI, pagkatapos ay magdagdag ng ilang mga button at text field. Ang mga patlang ng teksto ay idinisenyo upang makatanggap ng impormasyong ipinasok ng gumagamit at ipakita ang resulta ng programa. Sisimulan ng button ang pagpapatakbo ng mga function na nakapaloob sa bahagi ng kliyente ng programa. Ang application na iyong nilikha ay isang simple ngunit ganap na gumaganang calculator.

Para sa isang mas detalyadong gabay sa mga tampok sa pag-develop ng GUI Designer, kabilang ang mga video demonstration ng iba't ibang feature ng development, tingnan ang .

Tinatayang tagal: 20 minuto

Pagsasanay 1: Paggawa ng Proyekto

Ang unang hakbang ay lumikha ng isang proyekto ng IDE para sa application na iyong binuo. Pangalanan natin ang proyektong NumberAddition.

1. Piliin ang File > Bagong Proyekto. Maaari mo ring i-click ang icon ng Bagong Proyekto sa toolbar ng IDE.
2. Sa lugar na Mga Kategorya, piliin ang Java node. Sa lugar na "Mga Proyekto", piliin ang "Java Application". I-click ang "Next" button.
3. Ipasok ang NumberAddition sa field na Pangalan ng Proyekto at tumukoy ng landas, gaya ng iyong home directory, bilang lokasyon ng proyekto.
4. Piliin ang checkbox na "Gumamit ng hiwalay na folder upang mag-imbak ng mga aklatan" at tukuyin ang lokasyon ng folder ng mga aklatan (opsyonal). Para sa higit pang impormasyon, tingnan ang Magbahagi ng library sa iba sa isang dokumento Pagbuo ng mga Application gamit ang NetBeans IDE.
5. Alisin ang checkbox na "Gumawa ng Pangunahing Klase" kung ito ay may check.
6. I-click ang button na "Tapos na".

Pagsasanay 2: Paglikha ng Front End

Upang ipagpatuloy ang proseso ng paglikha ng interface, kailangan mong gumawa ng Java container kung saan ilalagay ang iba pang kinakailangang elemento ng GUI. Sa aktibidad na ito, gagawa ng container gamit ang isang elemento ng JFrame. Ilalagay ang container sa isang bagong package, na lalabas sa node na "Source Packages."

Paglikha ng JFrame Container

1. Sa window ng Projects, i-right-click ang NumberAddition node at piliin ang Bago > Iba pa.
2. Sa dialog box na Gumawa ng File, piliin ang kategorya ng Swing GUI Forms at ang uri ng file ng JFrame Form. I-click ang "Next" button.
3. Ilagay ang NumberAdditionUI bilang pangalan ng klase.
4. Piliin ang my.numberaddition package.
5. I-click ang button na "Tapos na".

Ang IDE ay gumagawa ng NumberAdditionUI form at ang NumberAdditionUI na klase sa NumberAddition application at binubuksan ang NumberAdditionUI form sa GUI Builder. Pinapalitan ng my.NumberAddition package ang default na package.

Pagdaragdag ng Mga Elemento: Paglikha ng Front End

Susunod, gamit ang window na "Palette", ang panlabas na interface ng application ay puno ng JPanel. Pagkatapos nito, tatlong elemento ng JLabel (mga text label), tatlong elemento ng JTextField (mga field ng teksto), at tatlong elemento ng JButton (mga pindutan) ay idinagdag. Kung hindi ka pa nakatrabaho dati kasama ang taga-disenyo ng GUI, tingnan ang Pagdidisenyo ng Swing GUI sa NetBeans IDE para sa impormasyon tungkol sa paglalagay ng bahagi.

Pagkatapos i-drag at ilagay ang mga elemento sa itaas, ang elemento ng JFrame ay dapat magmukhang katulad ng larawan sa ibaba.

Kung walang Palette window sa kanang sulok sa itaas ng IDE, piliin ang Window > Palette.

1. Upang magsimula, pumili ng panel mula sa kategoryang Mga Swing Container sa palette at i-drag ito papunta sa JFrame.
2. Ang JPanel ay mai-highlight. Pumunta sa Properties window at i-click ang ellipses button (...) sa tabi ng Border field para pumili ng border style.
3. Sa Border dialog box, piliin ang TitledBorder mula sa listahan at ilagay ang Number Addition sa Title field. I-click ang "OK" upang i-save ang iyong mga pagbabago at isara ang dialog box.
4. Ang screen ay dapat na ngayong magpakita ng walang laman na "JFrame" na elemento na may pamagat na "Number Addition" tulad ng ipinapakita sa larawan. Ayon sa larawan, magdagdag ng tatlong JLabel, tatlong JTextFields at tatlong JButton dito.

Pagpapalit ng pangalan ng mga elemento

Papalitan ng hakbang na ito ang pangalan ng mga elemento na idinagdag sa elemento ng JFrame.

1. I-double click ang jLabel1 at baguhin ang ntrcn ("text" property) sa Unang Numero.
2. I-double click ang jLabel2 at palitan ang text sa Second Number.
3. I-double click ang jLabel3 at baguhin ang teksto sa Resulta.
4. Alisin ang default na text mula sa jTextField1. Ang ipinapakitang teksto ay maaaring ma-convert sa nae-edit na teksto. Upang gawin ito, i-right-click ang field ng teksto at piliin ang "I-edit ang Teksto" mula sa pop-up na menu. Maaaring kailanganin mong ibalik ang jTextField1 sa orihinal nitong laki. Ulitin ang hakbang na ito para sa jTextField2 at jTextField3 na mga patlang.
5. Baguhin ang display text ng jButton1 sa Clear . (Upang baguhin ang text ng isang button, i-right click ang button at piliin ang Edit Text. Bilang kahalili, maaari mong i-click ang button, i-pause, at i-click muli.)
6. Baguhin ang display text ng jButton2 sa Add .
7. Baguhin ang display text ng jButton3 sa Exit .

Ngayon ang natapos na GUI ay dapat magmukhang sa larawan sa ibaba:

Pagsasanay 3: Pagdaragdag ng functionality

Idaragdag ng pagsasanay na ito ang kinakailangang paggana sa mga button na Add, Clear, at Exit. Gagamitin ang mga field na jTextField1 at jTextField2 para sa input ng user, at gagamitin ang jTextField3 upang ipakita ang resulta ng program. Ang nilikha na programa ay isang simpleng calculator. Kaya simulan na natin!

Pagdaragdag ng functionality sa Exit button

Upang maging functional ang mga button, dapat na italaga ang bawat isa sa kanila ng event handler, na siyang magiging responsable sa pagtugon sa mga event. Sa aming kaso, kailangan naming tukuyin ang kaganapan ng pag-click sa pindutan - alinman sa pamamagitan ng pag-click sa mouse o paggamit ng keyboard. Samakatuwid, ang interface na "ActionListener" ay gagamitin upang pangasiwaan ang mga kaganapang "ActionEvent."

1. I-right-click ang pindutang "Lumabas". Mula sa pop-up na menu, piliin ang Mga Kaganapan > Aksyon > actionPerformed. Pakitandaan na ang menu ay naglalaman ng maraming iba pang mga kaganapan na maaaring tumugon sa programa! Kapag pinili mo ang actionPerformed event, awtomatikong magdaragdag ang IDE ng ActionListener sa Exit button at gagawa ng paraan ng handler para pangasiwaan ang actionPerformed listener method.
2. Awtomatikong binubuksan ng IDE ang window na "Source Code", na nagpapakita sa iyo kung saan ilalagay ang aksyon na gusto mong gawin ng button kapag na-click mo ito (gamit ang iyong mouse o keyboard). Ang window ng "Source Code" ay dapat maglaman ng mga sumusunod na linya: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO idagdag ang iyong handling code dito: )
3. Ngayon, idagdag natin ang code para sa aksyon na dapat gawin ng "Exit" na button. Palitan ang linya ng TODO ng System.exit(0); . Ang tapos na code para sa "Exit" na button ay dapat magmukhang ganito: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Pagdaragdag ng functionality sa "Clear" na button

1. I-right-click ang pindutang "I-clear" (jButton1). Mula sa menu na lalabas, piliin ang "Mga Kaganapan > Aksyon > actionPerformed."
2. Ang pag-click sa pindutang "I-clear" ay dapat magresulta sa lahat ng teksto na maalis mula sa lahat ng "jTextField" na mga patlang ng teksto. Upang gawin ito, magdagdag ng code na katulad ng nasa itaas. Dapat ganito ang hitsura ng natapos na source code: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

Ang code na ito ay nag-aalis ng teksto mula sa lahat ng tatlong JTextFields, na iniiwan ang mga ito na walang laman.

Pagdaragdag ng functionality sa "Add" button

Ang pindutang "Magdagdag" ay dapat gumawa ng tatlong bagay.

1. Kinukuha muna nito ang input ng user sa jTextField1 at jTextField2 na mga patlang at kino-convert ang mga ito mula sa isang "String" na uri sa isang "Float" na uri.
2. Pagkatapos ay isasagawa nito ang pagdaragdag ng dalawang numero.
3. Sa wakas, iko-convert nito ang kabuuan sa isang String at ilalagay ito sa jTextField3 .

Magsimula na tayo!

1. I-click ang tab na Disenyo sa itaas ng workspace upang bumalik sa screen ng Form Design.
2. I-right-click ang "Add" button (jButton2). Mula sa pop-up na menu, piliin ang Mga Kaganapan > Aksyon > actionPerformed.
3. Magdagdag ng code para sa mga pagkilos na dapat gawin ng button na "Magdagdag." Dapat ganito ang hitsura ng natapos na source code: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Tinukoy muna natin ang mga float variable. float num1, num2, result; // Kailangan nating i-parse ang text sa isang uri ng float . num1 = Float.parseFloat(jTextField1.getText()); , kami ay pagpunta sa // baguhin ang halaga ng resulta mula sa isang float sa isang string.

Ngayon ang programa ay ganap na handa, at maaari mong simulan ang pag-assemble at pagpapatupad nito.

Pagsasanay 4: Pagpapatupad ng Programa

Upang patakbuhin ang programa sa IDE, sundin ang mga hakbang na ito:

1. Piliin ang Run > Run Main Project (sa kahalili, pindutin ang F6).

   Tandaan. Kung magbubukas ka ng isang window na nagpapahiwatig na ang Project NumberAddition ay walang pangunahing klase na tinukoy, dapat mong piliin ang my.NumberAddition.NumberAdditionUI bilang pangunahing klase sa parehong window at i-click ang OK.

Upang patakbuhin ang programa sa labas ng IDE, sundin ang mga hakbang na ito:

Pagkatapos ng ilang segundo, ilulunsad ang application.

Tandaan. Kung ang pag-double click sa isang JAR file ay hindi naglulunsad ng application, tingnan ang JAR file associations sa iyong operating system para sa higit pang impormasyon.

Maaari mo ring patakbuhin ang application mula sa command line.

Upang patakbuhin ang application mula sa command line, sundin ang mga hakbang na ito:

1. Magbukas ng command prompt o terminal window.
2. Sa command prompt, baguhin ang kasalukuyang direktoryo sa NumberAddition/dist directory.
3. Sa command prompt, ilagay ang sumusunod na pahayag: java -jar NumberAddition.jar

   Tandaan. Tiyaking nakatakda ang my.NumberAddition.NumberAdditionUI bilang pangunahing klase bago patakbuhin ang application. Upang suriin ito, i-right-click ang NumberAddition project node sa panel ng Projects, piliin ang Properties mula sa pop-up menu, at piliin ang Run category sa Project Properties dialog box. Dapat ipakita ng field ng Pangunahing Klase ang my.numberaddition.NumberAdditionUI .

Engine Processing ng Kaganapan

Tinitingnan ng tutorial na ito ang pagtugon sa isang simpleng kaganapan sa pag-click sa pindutan. Maraming mga kaganapan na maaaring tumugon sa isang application. Sa IDE, maaari mong tingnan ang listahan ng mga available na kaganapan na maaaring iproseso ng mga elemento ng GUI tulad ng sumusunod:

1. Bumalik sa NumberAdditionUI.java file sa editor. I-click ang tab na "Disenyo" upang tingnan ang istruktura ng GUI sa GUI Builder.
2. I-right-click ang anumang elemento ng GUI at piliin ang "Mga Kaganapan" mula sa lalabas na menu. Ngayon ay maaari mo nang tuklasin ang mga nilalaman ng menu nang hindi pumipili ng anumang mga item.
3. Bilang kahalili, maaari mong piliin ang "Properties" mula sa menu na "Window". Sa window ng Properties, i-click ang tab na Mga Kaganapan. Binibigyang-daan ka ng tab na "Mga Kaganapan" na tingnan at baguhin ang mga tagapangasiwa ng kaganapan na nauugnay sa kasalukuyang aktibong elemento ng GUI.
4. Ang application ay maaari ding tumugon sa mga pagpindot sa key, single, double, o triple na pag-click, paggalaw ng mouse pointer, pagbabago ng laki ng window, at paggalaw ng focus ng input. Binibigyang-daan ka ng menu na "Mga Kaganapan" na awtomatikong gumawa ng mga tagapangasiwa ng kaganapan para sa lahat ng mga kaganapang ito. Ang pinakakaraniwan sa mga ito ay ang kaganapang "Pagkilos". (Para sa higit pang impormasyon, tingnan kung paano pangasiwaan ang mga kaganapan sa Sun Java Events Tutorial.)

Paano pinoproseso ang mga kaganapan? Sa tuwing pipili ka ng kaganapan mula sa menu ng kaganapan, awtomatikong gagawa ang IDE ng tinatawag na tagapakinig ng kaganapan at iniuugnay ito sa bahagi ng developer. Upang matuto nang higit pa tungkol sa pagproseso ng kaganapan, sundin ang mga hakbang na ito:

1. Bumalik sa NumberAdditionUI.java file sa editor. I-click ang tab na "Source" upang tingnan ang source code ng GUI.
2. Mag-scroll pababa upang makita ang ipinatupad na jButton1ActionPerformed() , jButton2ActionPerformed() , at jButton3ActionPerformed() na mga pamamaraan. Ang mga pamamaraang ito ay tinatawag na mga tagapangasiwa ng kaganapan.
3. Ngayon pumunta sa initComponent() na pamamaraan. Kung nawawala ang pamamaraang ito, hanapin ang linya ng Binuo ng Code at i-click ang + sign sa tabi ng linyang iyon upang ipakita ang nakatagong initComponent() na pamamaraan.
4. Pansinin ang asul na bloke na nakapalibot sa initComponent() na pamamaraan. Ang code na ito ay awtomatikong nabuo ng IDE at hindi maaaring baguhin ng user.
5. Ngayon tingnan ang initComponent() na pamamaraan mismo. Sa iba pang mga bagay, naglalaman ito ng code na nagpapasimula ng mga elemento ng GUI at inilalagay ang mga ito sa form. Ang code na ito ay nabuo at awtomatikong ina-update habang inilalagay at binabago mo ang mga elemento sa mode ng disenyo.
6. Sa initComponents() method, hanapin ang sumusunod na snippet: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));

   Sa puntong ito, isang bagay na tagapakinig ng kaganapan na "ActionListener" ay idinagdag sa elemento ng GUI, sa kasong ito jButton3 . Ang interface na "ActionListener" ay may "actionPerformed" na paraan sa object na "ActionEvent", na ipinapatupad sa pamamagitan lamang ng pagtawag sa jButton3ActionPerformed event handler. Tumutugon na ang button na ito sa mga kaganapan sa pagkilos. Sa tuwing iki-click ang button, isang "ActionEvent" ang bubuo at ipapasa sa "actionPerformed" na paraan ng interface ng listener ng event, na nagpapatupad ng code na ibinigay ng developer para sa event na iyon sa event handler.

7. Java GUI Applications Learning Card

pamantayan ng GUI.

Ang isa sa pinakamahalagang pagbabago sa industriya ng kompyuter ay ang pagdating ng graphical na interface. Kaya kailangan bang magpatibay ng mga pamantayan ng GUI na tumutukoy kung ano ang hitsura ng mga aplikasyon ng Windows? Macintosh, atbp. Mayroong kahit na mga programa sa sertipikasyon na iniangkop ng mga vendor ang kanilang mga aplikasyon upang makuha ang Windows badge. Ginagawa ito sa ilang kadahilanan.

Ang isa sa mga pakinabang ng Windows o Mac ay ang kanilang karaniwang hitsura. Kapag natutunan mong magtrabaho sa isa sa mga ito, isaalang-alang na pinagkadalubhasaan mo ang iba pa. Karamihan sa mga application ng Windows ay gumagamit ng parehong mga kombensiyon, kaya alam mo kung paano magbukas, mag-save, mag-print, magsara, at kumopya ng file sa alinman sa mga ito. Ang karaniwang interface ay napaka-user-friendly. Kailangan mong subukang gawing katulad ang iyong mga application sa iba pang mga Windows application na natutunan na ng mga user na gamitin. Mayroong pitong pangkalahatang prinsipyo para sa disenyo ng GUI. Kung matutunan mo ang mga ito at susundin mo ang mga ito, magiging maayos ang disenyo ng iyong app.

Pitong prinsipyo ng disenyo ng GUI.

Ang pitong pangkalahatang prinsipyo ng disenyo ng GUI ay kinuha mula sa Microsoft Windows Interface Guide. Bumubuo sila ng blueprint kung saan maaari kang lumikha ng sarili mong mga pamantayan. Ang disenyong ito ay nagbibigay sa mga developer at user ng dalawang makabuluhang benepisyo. Una sa lahat, mukhang propesyonal ang mga app. Pangalawa, gumagana ang mga ito, pare-pareho sa iba pang mga application, at madaling matutunan ng mga user.

Siyempre, para maging matagumpay ang isang aplikasyon, dapat itong maayos na isinulat at kapaki-pakinabang - ito ang mga pangunahing kinakailangan. Ang mga prinsipyong pinag-uusapan natin ay nagbibigay lang ng pag-iisip sa developer.

1. Payagan ang user na kontrolin ang application.

2. Sundin ang object/action paradigm.

3. Maging pare-pareho.

4. Gawing simple at halata ang paggamit ng mga application.

5. Magsikap para sa pagkakaisa.

6. Magbigay ng feedback ng user.

7. Maging maluwag

Unang Prinsipyo: Bigyan ang user ng kontrol sa application.

Dapat kontrolin ng user ang application, ibig sabihin, may access sa bawat module ng application mula sa anumang iba pang module. Noong nakaraan, isang hierarchical na menu ang ginamit para sa naturang pag-access.

Sabihin nating gusto ng user na magdagdag ng bagong client Sa halimbawa, dapat pumunta ang user sa ACCOUNTS RECCIEVAable module at pagkatapos ay magdagdag ng bagong client mula doon. Paano niya nalaman ang gagawin? Marahil mula sa aking karanasan sa application na ito. At sa mundo ng GUI, pinipili lang ng user ang Bagong utos mula sa menu, pagkatapos ay Customer, tulad ng ipinapakita sa Fig. Sa modernong sistemang ito, maaari kang magdagdag ng bagong customer, vendor, o item ng imbentaryo sa pamamagitan ng menu ng File. Nagbibigay-daan ito sa iyong baguhin ang isang talaan ng customer habang nasa screen ng merchant at vice versa. Ang user ay hindi na kailangang mag-navigate sa kumplikado at nakakalito na mga hierarchical na menu.

Prinsipyo ng dalawa: sundin ang object/action paradigm.

Ang object/action paradigm ay nagsasaad na ang ilang operasyon ay maaaring gawin sa lahat ng bagay sa system. Ang pinakasimpleng at pinaka-halatang halimbawa ay ang screen ng suporta sa database ng customer (Fig.). Ang screen ay naglalaman ng isang hanay ng mga pindutan at bawat isa sa ibaba ay nagbibigay-daan sa iyo upang magsagawa ng ilang aksyon sa impormasyon tungkol sa napiling kliyente. Maaari mo itong tanggalin, i-edit, i-print, atbp. Ang mga pagkilos na maaaring gawin sa isang partikular na kliyente ay dapat na available o hindi magagamit sa mga naaangkop na oras. Halimbawa, kapag ang isang record ng customer ay nasa edit mode, ang Delete at New button ay dapat na hindi pinagana.

Ikatlong Prinsipyo: maging pare-pareho.

Ang pagkakapare-pareho ay isa sa pinakamahalagang prinsipyo ng disenyo ng GUI. Mga GUI – nagbibigay-daan sa mga user na mag-explore ng higit pang mga application kaysa sa mga mas lumang program. At lahat ng ito salamat sa prinsipyo ng pagkakapare-pareho. Kapag nakatagpo ang isang user ng bagong application, pamilyar na siya sa mga pangunahing utos: pagbubukas, pag-print at pag-save ng mga file. Ang mga application na binuo sa mga platform na ito ay karaniwang pare-pareho sa bawat isa.

Kaya, kapag gumagawa ng mga bagong application, maging pare-pareho. Kung ginamit mo ang Bagong utos upang magdagdag ng bagong entry, gamitin ito kahit saan. Ang salitang ito ay hindi dapat palitan ng iba - halimbawa, sa salitang Add 9add). Salamat sa iyong pagkakapare-pareho, malalaman ng mga user na saanman sila makatagpo ng Bagong utos, maaari itong magamit upang magdagdag ng bagong entry.

Prinsipyo apat: gawing simple at halata ang paggamit ng application.

Ang isa pang paraan upang maipahayag ang ideyang ito ay: huwag gumamit ng jargon. Mayroong isang screen na may dalawang mga pindutan. Ang isa sa kanila ay nagsasabing "I-pack ang database", at ang isa ay nagsasabing "Alisin ang mga tala na minarkahan para sa pagtanggal." Ang pangalawang entry ay malamang na mas mauunawaan ng gumagamit.

Kapag bumubuo ng mga application, madalas na may tukso na gumamit ng slang ng programmer sa interface. Subukang iwasan ito kung maaari.

Ikalimang Prinsipyo: Magsikap Para sa Pagkakaisa

Kahit na sa itim at puti, ang screen na ito ay may isang makabuluhang aesthetic drawback: isang puting background na may magkakaibang mga bagay dito. Sa Fig. Ang parehong screen ay mukhang mahusay na balanse sa kulay.

Mayroong milyun-milyong kumbinasyon ng kulay na maaari mong ilipat sa Windows. Nangangahulugan ba ito na lahat sila ay kailangang gamitin? Syempre hindi. Dapat kang pumili ng simple, kalmado na mga kulay at iwasan ang kanilang magulong paghahalo, na sa ilang kadahilanan ay gusto ng ilang programmer.

Prinsipyo anim. Magbigay ng feedback sa user.

Isipin na ang iyong aplikasyon ay may proseso na tumatagal ng mahabang panahon upang maisagawa. Sa panahong ito, maaari kang magpakita ng mensahe sa screen na may sumusunod na nilalaman: "Ang programa ay tumatakbo, mangyaring maghintay." Maginhawang solusyon; ngunit paano malalaman ng gumagamit na hindi ito nagyelo? Samakatuwid, malamang na bibigyan niya ang application ng "three-finger salute" (Ctrl+Alt+Del), kahit na ang lahat ay magiging maayos sa programa.

Mas mainam na ipakita sa user kung anong bahagi ng proseso ang nakumpleto. Pagkatapos ay hindi niya basta-basta aabalahin ang programa, magagawa niyang suriin kung gaano kalayo ang pag-unlad ng trabaho, at gumawa ng iba pang mga bagay hanggang sa makumpleto ang proseso. Kaya, ang pagiging produktibo ng gumagamit ay tataas ng humigit-kumulang 25 porsyento. Ang resultang ito ay maaaring makamit sa pamamagitan lamang ng pagpapakita ng metro sa screen. Karaniwang ipinapakita ang mga mensahe tulad ng "10 sa 100 record na naproseso" o "40% kumpleto". Kahit na mas mabuti ay ipakita ang parehong bilang ng mga talaang naproseso at ang kanilang porsyento."

Prinsipyo Ikapito: Maging Mapagpatawad

Ang bawat isa sa atin ay minsan ay nagtanggal ng post sa pamamagitan ng aksidenteng pagpindot sa maling button. Samakatuwid, bigyan ang user ng pagkakataong magbago ng isip o kanselahin ang mga aksyon na ginawa. Kung ang isang proseso ay tumatagal ng mahabang panahon, nagbabago ng maraming data, o nangangailangan ng user na mag-back up ng data bago magsagawa ng isang aksyon, dapat kang magbigay ng naaangkop na babala Nakakita ako ng mga application na nangangailangan ng kumpirmasyon nang dalawang beses at pagkatapos ay humingi ng password. Kailangan ba ng iyong mga programa ang ganitong antas ng proteksyon? Siguro. Ang gawain ng developer ay tulungan ang user kung nagkamali siya sa anumang yugto ng trabaho.

Ang kahalagahan ng GUI standard convention.

Tulad ng nakikita mo, ang mga prinsipyo ng disenyo ng GUI ay napaka-simple at dapat gamitin kapag lumilikha ng mga screen. Gayunpaman, bago mo idisenyo ang screen, kailangan mong itatag kung ano ang magiging hitsura nito. Piliin ang mga laki, font, kulay, istilo ng mensahe, atbp. Sa pamamagitan ng paglutas ng mga isyung ito nang maaga, mas mapapabilis mo ang iyong trabaho. Pagdating sa font o message style mamaya, tingnan mo lang ang standard.

Panuntunan 2: Bawasan ang pasanin ng gumagamit

Panuntunan 3: Gawing tugma ang interface

Mga Alituntunin

Maayos na Start Menu program

Konklusyon

Panitikan

Panimula

"Ang ginintuang tuntunin ng disenyo ay: "Huwag gawin sa iba ang ginawa nila sa iyo." Tandaan kung ano ang hindi mo gusto sa software na iyong ginagamit. ”

Tracy Leonard

Bakit mo dapat sundin ang mga prinsipyo ng disenyo ng user interface?

Ang software ay dapat na binuo na isinasaalang-alang ang mga kinakailangan at kagustuhan ng gumagamit - ang system ay dapat umangkop sa gumagamit. Ito ang dahilan kung bakit napakahalaga ng mga prinsipyo ng disenyo.

Ang mga gumagamit ng computer ay maaaring magkaroon ng matagumpay na mga karanasan na naglalagay ng kumpiyansa sa kanilang mga kakayahan at nagtatayo ng mataas na pagpapahalaga sa sarili kapag nagtatrabaho sa isang computer. Ang kanilang mga aksyon sa computer ay maaaring mailalarawan bilang "ang tagumpay ay nagbubunga ng tagumpay." Ang bawat positibong karanasan sa programa ay nagbibigay-daan sa gumagamit na palawakin ang kanilang pamilyar sa software at pataasin ang kanilang antas ng kakayahan. Ang isang mahusay na dinisenyo na interface, tulad ng isang mahusay na guro at mga aklat-aralin, ay nagsisiguro ng isang mabungang pakikipag-ugnayan sa pagitan ng user at ng computer. Ang mga matagumpay na interface ay maaaring makatulong sa isang tao na makaalis sa karaniwang bilog ng mga program na ginagamit niya at tumuklas ng mga bago, palalimin ang kanyang pag-unawa sa kung paano gumagana ang mga interface at computer.

Ang mga prinsipyo ng disenyo ng interface ay mga konsepto at pananaw na may mataas na antas na maaaring magamit sa disenyo ng software. Kailangan mong matukoy kung aling prinsipyo ang pinakamahalaga at katanggap-tanggap para sa iyong system.

Kapag nagsisimula sa disenyo, kinakailangang i-highlight ang pinakamahalagang prinsipyo na magiging mapagpasyahan kapag naghahanap ng mga kompromiso. Ang pagsisikap na sundin ang lahat ng mga prinsipyo ng disenyo ay maaaring humantong sa katotohanan na sa ilang mga sitwasyon ay hindi ito nagbabayad at may negatibong epekto sa huling resulta. Ang mga prinsipyo ay isang gabay sa pagkilos.

Ang tatlong mga prinsipyo ng disenyo ng user interface ay binabalangkas tulad ng sumusunod:

1) kontrol ng user sa interface;

2) pagbabawas ng pagkarga ng memorya ng gumagamit;

3) pagkakapare-pareho ng user interface.

Saan Makakahanap ng Mga Prinsipyo ng Disenyo ng User Interface

Iniharap ni Hansen ang unang listahan ng mga prinsipyo ng disenyo. Ang mga prinsipyo ay:

1) kilalanin ang gumagamit;

2) bawasan ang pagsasaulo;

3) i-optimize ang mga operasyon;

4) alisin ang mga error.

Maraming mga pangunahing tagagawa ng operating system ang nag-publish ng may-katuturang mga manual at tagubilin kapag inilabas nila ang kanilang mga bagong produkto sa merkado. Ang mga publikasyong ito ay nagpapakita ng mga prinsipyo ng diskarte sa disenyo ng interface. Ang mga manwal ay ginawa ng Apple Computer, Inc. (1992), IBM Corporation (1992), Microsoft Corporation (1995) at UNIX OSF/Motif (1993).

Maaaring gamitin ng mga mambabasa ang mga publikasyong ito bilang pantulong sa pagtuturo. Maaaring magkaiba ang terminolohiya ng interface sa pagitan ng mga manual, ngunit ang focus ng materyal, ang antas ng pagiging kumplikado, at ang mga prinsipyo ng user interface na inilarawan ay pareho para sa lahat ng mga libro.

Ang kahalagahan ng pagsunod sa mga prinsipyo

"Ang hindi pagkakatugma ng interface ay maaaring magastos ng isang malaking kumpanya ng milyun-milyong dolyar sa nawalang produktibo at tumaas na mga gastos sa suporta." - Jessie Briest.

Nalalapat ang mga prinsipyong ito sa lahat ng software at hardware, sa lahat ng uri at istilo ng mga interface. Ang mga ito ay binuo sa loob ng mahabang panahon: isinagawa ang pananaliksik sa larangan ng interface ng software, isinagawa ang pag-unlad, at ang mga gumagamit ng maraming mga platform ng computer, kabilang ang Macintosh at PC, ay sinuri.

Ang mga prinsipyong ito ay tumayo sa pagsubok ng panahon at ang pagdating ng mga bagong teknolohiya sa computer. Sinabi ni Jakob Nielsen: "Ang mga prinsipyo ay mananatiling pangunahing kahit na ang programa ay may isang futuristic na 3D na disenyo na may isang DataGlove para sa pag-input, pagkilala sa paggalaw at mga live na imahe ng video ay magiging may kaugnayan ang mga ito dahil ipinapahayag nila ang pangunahing ideya ng pag-uusap sa machine na ginagamit mga utos.” .

Ang interpretasyon ng mga prinsipyong ito ay depende sa hardware, operating system, mga bahagi ng user interface at mga gawain nito. Kadalasan ang mga desisyon sa negosyo ay na-override ang paggamit ng mga designer ng mga prinsipyo. Ang mga modelo ng user at taga-disenyo ay magkakaiba din at nakakaimpluwensya kung paano ilalapat ang mga prinsipyo. Sa ilang mahahalagang yugto sa pagbuo ng isang proyekto, ang tanong ay maaaring lumitaw: "Ano ang susunod na mangyayari?" Ang sagot ay dapat na: "Anuman ang gusto ng gumagamit!"

Ang desisyon na piliin ang pinakamainam na mga prinsipyo sa disenyo ng interface ay dapat na binuo nang sama-sama ng lahat ng miyembro ng pangkat ng disenyo. Ang mga solusyong ito ay dapat makatulong na mapabuti ang kakayahang bilhin at pagbuo ng mga produkto ng software.

Mga Panuntunan sa Disenyo ng User Interface

"Gawin itong mas simple, ngunit hindi mas primitive."

Albert Einstein

Panuntunan 1: Bigyan ng kontrol ang user

Ang mga karanasang taga-disenyo ay nagpapahintulot sa mga user na lutasin ang ilang mga problema sa kanilang sariling paghuhusga. Ang mga arkitekto, sa pagkumpleto ng isang kumplikadong complex ng mga gusali, ay dapat maglatag ng mga landas para sa mga naglalakad sa pagitan nila. Hindi pa nila alam nang eksakto kung saan tatawid ang mga tao sa mga site. Samakatuwid, ang mga landas ay hindi kailanman inilalagay nang sabay-sabay sa pagtatayo ng mga gusali. Ang mga karatula ay inilalagay sa mga lugar sa pagitan ng mga bahay na may nakasulat na: "Mangyaring lumakad sa damuhan." Pagkaraan ng ilang oras, bumalik ang mga tagapagtayo at ngayon lamang, ayon sa "kalooban" ng populasyon, punan ang mga tinahak na landas ng aspalto.

Mga prinsipyong nagbibigay sa user ng kontrol sa system:

1) gamitin ang mga mode nang matalino;

2) bigyan ang user ng pagkakataong pumili: gumana sa alinman sa mouse, o keyboard, o kumbinasyon ng pareho;

3)payagan ang gumagamit na ituon ang atensyon;

4) ipakita ang mga mensahe na makakatulong sa kanya sa kanyang trabaho;

5) lumikha ng mga kundisyon para sa agaran at nababaligtad na mga aksyon, pati na rin ang feedback;

6) magbigay ng naaangkop na mga landas at labasan;

7) iakma ang system sa mga user na may iba't ibang antas ng pagsasanay;

8) gawing mas naiintindihan ang user interface;

9) bigyan ang user ng pagkakataon na i-customize ang interface ayon sa gusto nila;

10) payagan ang gumagamit na direktang manipulahin ang mga bagay sa interface;

Gumamit ng mga mode nang matalino

Ang mga mode ay hindi palaging masama. Ito ay kinakailangan upang payagan ang isang tao na pumili ng mga mode na kailangan niya. Ang interface ay dapat na natural na ang user ay kumportable sa pakikipagtulungan sa kanila. Ang gumagamit ay hindi nag-iisip tungkol sa paglipat sa insert o rewrite mode kapag nagtatrabaho sa isang word processor - ito ay medyo makatuwiran at natural.

Payagan ang isang tao na gumamit ng mouse at keyboard

Kakayahang magtrabaho gamit ang isang keyboard gamit ang isang keyboard sa halip na isang mouse. Nangangahulugan ito na magiging mas madali para sa gumagamit na magtrabaho, hindi niya ito magagamit o wala nito. Ang mga toolbar ay idinisenyo upang pabilisin ang iyong trabaho kapag gumagamit ng mouse. Gayunpaman, kapag nagtatrabaho sa keyboard, hindi sila maabot - para sa mga ganitong kaso, ang mga "drop-down" na menu ay ibinigay.

Payagan ang user na lumipat ng atensyon

Huwag pilitin ang mga user na tapusin ang mga nasimulang sequence ng mga aksyon. Bigyan sila ng pagpipilian - kanselahin o i-save ang data at bumalik sa kung saan sila tumigil. Hayaan ang mga user na magkaroon ng pagkakataon na kontrolin ang proseso ng pagtatrabaho sa program.

Ipakita ang mga paliwanag na mensahe at teksto

Gumamit ng mga terminong madaling gamitin sa buong interface. Hindi nila kailangang malaman ang tungkol sa mga bit at byte!

Dapat mong piliin ang tamang tono sa mga mensahe at imbitasyon. Parehong mahalaga na i-insure ang iyong sarili laban sa mga problema at pagkakamali. Ang mahinang terminolohiya at hindi tamang tono ay hahantong sa mga user na sinisisi ang kanilang sarili para sa mga error na nangyayari.

Magbigay ng agaran at nababagong aksyon at feedback

Ang bawat produkto ng software ay dapat magsama ng UNDO at REDO function. Dapat ipaalam sa user na hindi na maa-undo ang pagkilos at, kung maaari, dapat pahintulutan ang isang alternatibong pagkilos. Palaging ipaalam sa isang tao kung ano ang nangyayari sa kasalukuyan.

Magbigay ng malinaw na mga landas at labasan

Dapat masiyahan ang mga gumagamit sa pagtatrabaho sa interface ng anumang produkto ng software. Kahit na ang mga interface na ginagamit sa industriya ay hindi dapat takutin ang gumagamit; hindi siya dapat matakot na pindutin ang mga pindutan o pumunta sa isa pang screen. Ang pagsalakay sa Internet ay nagpakita na ang nabigasyon ay ang pangunahing interactive na pamamaraan sa Internet. Kung naiintindihan ng user kung paano i-access ang gustong pahina sa WWW, may 80 porsiyentong pagkakataon na mauunawaan niya ang interface. Natututo ang mga tao ng mga diskarte sa browser nang napakabilis.

I-accommodate ang mga user na may iba't ibang antas ng kasanayan

Huwag "isakripisyo" ang mga nakaranasang gumagamit para sa kapakinabangan ng mga ordinaryong tao. Ito ay kinakailangan upang bigyan sila ng mabilis na pag-access sa mga function ng programa. Huwag mainip sa kanila ng maraming hakbang upang magsagawa ng pagkilos kung sanay sila sa paggamit ng isang macro command.

Gawing "transparent" ang user interface

Ang user interface ay ang "mythical" na bahagi ng produkto ng software. Sa isang magandang proyekto, hindi man lang naramdaman ng mga user ang "presence" nito. Kung ito ay hindi maganda ang disenyo, ang mga gumagamit ay kailangang maglagay ng kahit na maraming pagsisikap sa epektibong paggamit ng produkto ng software. Ang layunin ng interface ay upang matulungan ang mga tao na madama na sila ay "nasa loob" ng computer at malayang maaaring magmanipula at magtrabaho sa mga bagay. Ito ay tinatawag na "transparent" na interface!