Thực đơn
trang chủSự liên quan

Giao diện đồ họa và các công cụ để phát triển chúng. Hệ thống màn hình đồ họa. Hạn chế. Lớp này là phần mở rộng hơn nữa của lớp cơ sở. Các phiên bản của nó có các khả năng bổ sung để kiểm soát kích thước và vị trí của chúng

Chú thích: Chúng tôi nghiên cứu các tiện ích - các thành phần trực quan tạo nên giao diện đồ họa người dùng, bố cục, chính sách kích thước, kết nối khe tín hiệu, thành phần giao diện đồ họa và cách sử dụng chúng.

13.1 Tiện ích

Widget là các thành phần trực quan tạo nên giao diện đồ họa cho người dùng.

Ví dụ về các widget:

  • Nút (lớp QPushButton);
  • Nhãn (lớp QLabel);
  • Trường đầu vào (lớp QLineEdit);
  • Trường bộ đếm số (lớp QSpinBox);
  • Thanh cuộn (lớp QScrollBar ).

Qt có khoảng 50 lớp phần tử đồ họa được tạo sẵn để sử dụng. Lớp cha của tất cả các widget là lớp QWidget. Tất cả các thuộc tính chính của các yếu tố hình ảnh đều được kế thừa từ nó, điều này chúng tôi sẽ xem xét cẩn thận. Hãy bắt đầu khám phá các cách phát triển chương trình có giao diện đồ họa bằng một ví dụ.

Hãy tạo một tệp dự án trống. Khởi chạy trình hướng dẫn dự án và chọn mục trong phần Dự án Dự án khác. Tiếp theo, chọn loại dự án Dự án Qt trống. Hãy thêm nội dung vào tệp dự án:

TEMPLATE = app #Qt module mà chúng ta sẽ sử dụng QT += widgets #Thêm mô-đun widget để hoạt động với các widget (cần thiết cho Qt5). MỤC TIÊU = widget#Tên của tệp thực thi NGUỒN += \ main.cpp

Bây giờ hãy tạo một chương trình đơn giản với một cửa sổ trong đó chúng ta sẽ hiển thị dòng chữ. Hãy đặt kích thước của cửa sổ và văn bản tiêu đề của nó, đồng thời đặt phông chữ cho dòng chữ. Để thực hiện việc này, hãy tạo một tệp main.cpp với nội dung sau:

#bao gồm #bao gồm int main (int lArgc, char * lArgv ) ( //Tạo một đối tượng QApplication để khởi tạo và cấu hình chương trình cửa sổ, //điều khiển việc thực thi nó bằng vòng lặp sự kiện QApplication lApplication (lArgc, lArgv); QLabel lLabel; //Tạo một QLabel widget - nhãn lLabel.setText ("Tôi là widget!"); // Đặt văn bản cho nhãn lLabel.setGeometry (200, 200, 300, 150); // Đặt kích thước - vị trí (x, y), chiều rộng và chiều cao. Đặt văn bản căn chỉnh lLabel.setAlignment (Qt::AlignHCenter | Qt::AlignVCenter); //Lớp QFont được sử dụng để đặt tham số phông chữ. //Chọn họ phông chữ Arial Black và kích thước 12. QFont lBlackFont (" Arial Black", 12); lLabel.setFont (lBlackFont); //Đặt font chữ cho nhãn lLabel.show (); //Gọi phương thức show() để hiển thị nhãn trên màn hình. return lApplication.exec () ; //Chạy chương trình để thực thi exec() thực hiện //xử lý sự kiện vòng lặp. Chương trình chờ hành động của người dùng và xử lý chúng.)

Như chúng ta có thể thấy, các phần tử tạo nên giao diện trong Qt có vị trí và kích thước riêng - cái gọi là "hình học" - và do đó chiếm một diện tích hình chữ nhật tương ứng trên màn hình (xem Hình 13.1). Ngoài ra, mỗi phần tử đều có các cài đặt xác định hành vi và diện mạo của nó.


Cơm. 13.1.

Để tạo cấu trúc, các widget được sắp xếp thành một hệ thống phân cấp theo nguyên tắc “một phần - toàn bộ”. Mỗi widget có thể chứa các widget khác. Phần tử trực quan này trở thành "cha" (tiện ích gốc) của các phần tử mà nó chứa. Lưu ý rằng không nên nhầm lẫn các mối quan hệ như vậy với tính kế thừa trong C++ - mối quan hệ giữa các lớp trong một chương trình. Mối quan hệ giữa các widget là mối quan hệ giữa các đối tượng. Những mối quan hệ như vậy dẫn đến một số hậu quả:

  • phần tử cha sẽ chịu trách nhiệm xóa phần tử con: nếu widget cha bị xóa, nó sẽ tự động xóa tất cả các phần tử con;
  • tiện ích con mẹ đặt các tiện ích con bên trong chính nó, các phần của tiện ích con vượt ra ngoài cha mẹ sẽ ẩn đi;
  • một phần trạng thái của tiện ích gốc được truyền cho con của nó - điều này áp dụng cho một số thuộc tính (khả năng hiển thị, hoạt động) và kiểu được áp dụng cho thành phần trực quan.

Các tiện ích con không có cha mẹ (các tiện ích con cấp cao nhất) xuất hiện dưới dạng các cửa sổ riêng biệt trong chương trình. Hãy xem một ví dụ. Hãy đặt tên cho dự án mới là ParentExample. Tệp dự án sẽ chứa các cài đặt thông thường cho dự án GUI:

MẪU = ứng dụng MỤC TIÊU = ParentExample QT += widget

Đối với tiện ích mà chúng ta sẽ sử dụng làm cửa sổ chính, chúng ta sẽ tạo một lớp mới. Đối với điều này trong danh mục Tập tin và lớp học Hãy chọn phần C++ và chọn Lớp C++ (xem Hình 13.2).

Bước tiếp theo là tạo một số phần tử trên cửa sổ. Để thực hiện việc này, hãy mở tệp parentwidget.cpp và thay đổi mã hàm tạo lớp. Để hiển thị các phần tử, chỉ cần tạo chúng trong hàm tạo của lớp và đặt ParentWidget làm phần tử gốc cho chúng. Mã parentwidget.cpp trông như thế này:

#include " parentwidget.h " #include #bao gồm #bao gồm ParentWidget::ParentWidget (QWidget * parent) : QWidget (parent) ( //Tạo một nhãn cho biết widget cha - đây là một thể hiện của lớp ParentWidget. QLabel * lLabel=new QLabel (this); //Position so với góc trên bên trái của widget gốc. lLabel ->setGeometry (50, 0, 100, 30); lLabel ->setText (" TextLabel "); //Văn bản trên nhãn. //Tạo nút, đặt "cha mẹ", hình học và văn bản QPushButton * lPushButton = QPushButton mới (cái này); lPushButton->setGeometry (50, 50, 100, 30); lPushButton->setText (" PushButton "); //Tạo trường nhập, đặt giá trị "cha mẹ", hình học và văn bản QLineEdit * lLineEdit = new QLineEdit ( this); lLineEdit ->setGeometry (50, 100, 100, 30); lLineEdit ->setText (" LineEdit "); lLineEdit ->selectAll (); // Chọn văn bản trong trường đầu vào (chỉ ví dụ) // Cuối cùng thay đổi kích thước của widget cha setGeometry (x (), y (), 300, 150); // và đặt văn bản tiêu đề cửa sổ setWindowTitle (" parent widgetExample " ); )

Vì phần tử gốc là ParentWidget nên nhãn (QLabel), nút (QPushButton) và trường văn bản (QLineEdit) đều nằm trong đó. Vị trí của các widget con được đặt tương ứng với góc trên bên trái của bố. Bạn có thể dễ dàng xác minh điều này bằng cách thay đổi kích thước và vị trí của cửa sổ chương trình của chúng tôi. Lưu ý cách chúng tôi tạo các phần tử giao diện người dùng trên vùng nhớ heap bằng cách sử dụng toán tử mới. Điều này đảm bảo rằng các phần tử không bị xóa sau khi hàm tạo ParentWidget hoàn tất.

Việc tạo ra một giao diện đồ họa người dùng, bao gồm việc sắp xếp các thành phần đồ họa và chọn cấu trúc tổng thể cũng như luồng ứng dụng, buộc người lập trình phải trở thành một nghệ sĩ. Không có quy tắc chuẩn nào giúp tạo bản trình bày, sắp xếp các yếu tố và tổ chức cấu trúc. Một giao diện người dùng đồ họa thành công được coi là một tác phẩm nghệ thuật. Vì việc tạo giao diện là một nghệ thuật chứ không phải là khoa học nên không có quy tắc cứng nhắc nào phải tuân theo trong lĩnh vực này. Quá nhiều tham số được xác định bởi bản chất của ứng dụng, người dùng và ngữ cảnh.

Tuy nhiên, có một số nguyên tắc thực tế mà các nhà phát triển nên tuân theo để giúp việc thiết kế giao diện trở nên dễ dàng hơn.

¦ Nên tránh các cấu trúc phức tạp (như cây) để liên kết các menu khác nhau. Tốt nhất là không nên đưa quá sáu menu vào một dòng menu, mỗi menu sẽ chứa không quá sáu tùy chọn.

¦ Các đối tượng phải có ý nghĩa nhất quán. Ví dụ: để kích hoạt tất cả các biểu tượng, hãy nhấp đúp chuột. Một số giao diện hiện đại không đáp ứng khuyến nghị này và chứa các biểu tượng chỉ có hiệu lực sau khi người dùng kéo

phản đối họ. Thanh cuộn chỉ nên được sử dụng để cuộn và nếu sử dụng các biểu tượng thư viện được tạo sẵn, bạn nên kiểm tra cẩn thận để đảm bảo rằng, ví dụ, biểu tượng máy in luôn được sử dụng để in.

¦ Khi kích hoạt tất cả các biểu tượng, như đã lưu ý ở trên, bạn nên nhấp đúp chuột. Và để có được kết quả tương tự đối với các biểu tượng đối tượng được kích hoạt chỉ bằng một cú nhấp chuột, bạn cũng nên lập trình nhấp đúp. Nhiều tùy chọn, chẳng hạn như những tùy chọn được tìm thấy trong menu Control Panel, trông giống như các biểu tượng nhưng là những đối tượng có thể được kích hoạt chỉ bằng một cú nhấp chuột. Bạn nên dự đoán cách người dùng có thể hành xử khi làm việc với các đối tượng đó (tức là mong đợi họ nhấp đúp vào chúng) và giúp họ đạt được kết quả mong muốn.

¦ Các menu giao diện phải phản ánh trạng thái hiện tại của hệ thống. Một trong những nguyên tắc cơ bản hướng dẫn hầu hết các nhà thiết kế giao diện người dùng đồ họa là đảm bảo rằng tất cả các tính năng giao diện đều có thể truy cập được bất kể hành động của người dùng. Quy tắc dưới cùng phù hợp với các ứng dụng đơn giản nhưng ít hữu ích hơn đối với các ứng dụng phức tạp hơn.

¦ Các thành phần chung cho các menu khác nhau nên được đặt ở một nơi. Nhưng ví dụ, các nút OK và Cancel phải luôn được đặt ở vị trí tương đối giống nhau và chiếm cùng một vị trí trong các hộp thoại khác nhau.

¦ Bạn không nên cố gắng đảm bảo tính nhất quán của các thành phần trong menu nếu điều này không phù hợp với quan điểm của người dùng. Ví dụ: người dùng tin rằng việc kéo tệp từ thư mục này sang thư mục khác trên cùng một thiết bị sẽ khiến tệp bị chuyển sang thư mục thứ hai.

Họ cũng tin rằng việc kéo tệp sang thiết bị khác sẽ tạo ra bản sao của tệp gốc ở đó. Từ đó dẫn đến việc thực hiện chức năng kéo sẽ không nhất quán, tức là. khác nhau trong những trường hợp khác nhau. Tuy nhiên, đây là mong muốn của người dùng cần được tính đến. Phấn đấu đạt được sự nhất quán chỉ là một khuyến nghị chứ không phải là một quy tắc cứng rắn và nhanh chóng.

Các yêu cầu công thái học đối với giao diện người dùng đồ họa rõ ràng là không đủ với sự phát triển của “đa phương tiện” - hệ thống tương tác cung cấp công việc với hình ảnh tĩnh và video chuyển động, đồ họa máy tính hoạt hình và văn bản, giọng nói và âm thanh chất lượng cao. Nghiên cứu và phát triển công thái học của các hệ thống này đặt ra một thách thức đầy thách thức và thú vị về mặt chuyên môn.

B. Tognazzini lưu ý rằng hầu hết những người quản lý dự án phát triển ứng dụng đều đợi cho đến khi kết thúc dự án mới bắt đầu làm việc trên giao diện. Điều này gợi nhớ đến việc xây dựng một ngôi nhà, khi một kiến ​​trúc sư được mời đến sau khi xây dựng phần khung của tòa nhà. Tất cả các nhà phát triển đều có những cách tiếp cận khác nhau để tổ chức quá trình tạo giao diện. Tuy nhiên, có những điểm chung mà tất cả các nhà phát triển nên tuân thủ:

1) hiểu rõ từng chi tiết mục đích của sản phẩm phần mềm thông qua giao tiếp chặt chẽ với người dùng, thường dành cả ngày làm việc với họ để hiểu rõ hơn về phong cách làm việc và thói quen cá nhân của họ;

2) tạo giao diện không phải là công việc của một người mà là của đại diện của ba lĩnh vực: một chuyên gia tìm hiểu ý kiến ​​của người dùng về các thành phần chính của giao diện và mô tả chúng; nhà phát triển giao diện và người tạo đồ họa;

3) một nhân viên có kinh nghiệm phải được chỉ định làm chuyên gia về giao diện và là người liên lạc giữa nhóm làm việc và người dùng;

4) thử nghiệm, tạo bố cục và thử nghiệm lại, vì ngay cả khi hiểu rõ mục đích của sản phẩm phần mềm thì cũng không thể cung cấp cho mọi nhu cầu của người dùng.

D. Norman tin rằng các giao diện nên được tạo ra bởi những người không tham gia vào quá trình phát triển ứng dụng, vì các nhà phát triển biết quá nhiều về các nguyên tắc của chương trình và điều này chỉ cản trở việc tạo ra giao diện. Ưu điểm của giao diện đồ họa người dùng nhìn chung được thừa nhận và có lẽ
Vì vậy, anh không trở thành đối tượng phân tích nghiêm túc. Quy tắc truyền thống của nhà phát triển chương trình, theo đó việc dễ học thường ngăn cản người dùng sau đó sử dụng đầy đủ tất cả các khả năng của chương trình, cũng áp dụng cho giao diện đồ họa. Một ví dụ là việc phát triển một dự án cho một công ty bảo hiểm của Mỹ, trong đó họ sử dụng một ứng dụng bảo hiểm cho Macintosh, được trang bị một giao diện tuyệt vời và rất dễ học. Tuy nhiên, sau hai năm hoạt động, người dùng cuối đã trở nên thành thạo các tính năng khác nhau của ứng dụng đến nỗi giao diện đồ họa người dùng chỉ làm họ chậm lại. Việc lựa chọn giao diện đồ họa phải được xác định theo tính chất nhiệm vụ của người dùng.

Đóng góp của Saleem Gul và Tomas Pavek

Hướng dẫn này bao gồm việc tạo một giao diện người dùng đồ họa đơn giản và thêm chức năng phía máy chủ đơn giản vào đó. Cụ thể, chúng ta sẽ xem xét mã xác định hành vi của các nút và trường trên biểu mẫu Xoay.

Chúng ta sẽ xem xét bố cục và cấu trúc của GUI, sau đó thêm một số nút và trường văn bản. Các trường văn bản được thiết kế để nhận thông tin do người dùng nhập và hiển thị kết quả của chương trình. Nút này sẽ bắt đầu hoạt động của các chức năng được tích hợp trong phần máy khách của chương trình. Ứng dụng đang được tạo là một máy tính đơn giản nhưng có đầy đủ chức năng.

Để có hướng dẫn chi tiết hơn về các tính năng phát triển của GUI Designer, bao gồm video trình diễn các tính năng phát triển khác nhau, hãy xem .

Thời lượng dự kiến: 20 phút

Bài tập 1: Tạo một dự án

Bước đầu tiên là tạo một dự án IDE cho ứng dụng bạn đang phát triển. Hãy đặt tên cho dự án là NumberAddition.

  1. Chọn Tệp > Dự án mới. Bạn cũng có thể nhấp vào biểu tượng Dự án mới trên thanh công cụ IDE.
  2. Trong vùng Danh mục, chọn nút Java. Trong vùng "Dự án", chọn "Ứng dụng Java". Bấm tiếp".
  3. Nhập NumberAddition vào trường Tên dự án và chỉ định một đường dẫn, chẳng hạn như thư mục chính của bạn, làm vị trí dự án.
  4. Chọn hộp kiểm "Sử dụng thư mục riêng để lưu trữ thư viện" và chỉ định vị trí của thư mục thư viện (tùy chọn). Để biết thêm thông tin, hãy xem chia sẻ thư viện với người khác trong tài liệu Phát triển ứng dụng với NetBeans IDE.
  5. Xóa hộp kiểm "Tạo lớp chính" nếu nó được chọn.
  6. Nhấp vào nút "Xong".

Bài tập 2: Tạo giao diện người dùng

Để tiếp tục quá trình tạo giao diện, bạn cần tạo một vùng chứa Java để đặt các thành phần GUI cần thiết khác. Trong hoạt động này, một vùng chứa sẽ được tạo bằng phần tử JFrame. Vùng chứa sẽ được đặt vào một gói mới, gói này sẽ xuất hiện trong nút "Gói nguồn".

Tạo vùng chứa JFrame

  1. Trong cửa sổ Dự án, bấm chuột phải vào nút NumberAddition và chọn Mới > Khác.
  2. Trong hộp thoại Tạo tệp, chọn danh mục Biểu mẫu GUI xoay và loại tệp Biểu mẫu JFrame. Bấm tiếp".
  3. Nhập NumberAdditionUI làm tên lớp.
  4. Chọn gói my.numberaddition.
  5. Nhấp vào nút "Xong".

IDE tạo biểu mẫu NumberAdditionUI và lớp NumberAdditionUI trong ứng dụng NumberAdditionUI và mở biểu mẫu NumberAdditionUI trong Trình tạo GUI. Gói my.NumberAddition thay thế gói mặc định.

Thêm các yếu tố: Tạo giao diện người dùng

Tiếp theo, bằng cách sử dụng cửa sổ "Palette", giao diện bên ngoài của ứng dụng sẽ chứa đầy JPanel. Sau đó, ba phần tử JLabel (nhãn văn bản), ba phần tử JTextField (trường văn bản) và ba phần tử JButton (nút) được thêm vào. Nếu trước đây bạn chưa từng làm việc với trình thiết kế GUI, hãy xem Thiết kế GUI Swing trong NetBeans IDE để biết thông tin về vị trí thành phần.

Sau khi kéo và đặt các phần tử trên, phần tử JFrame sẽ trông giống như hình bên dưới.

Nếu không có cửa sổ Palette ở góc trên bên phải của IDE, hãy chọn Window > Palette.

  1. Để bắt đầu, hãy chọn một bảng từ danh mục Swing Containers trong bảng màu và kéo nó vào JFrame.
  2. JPanel sẽ được đánh dấu. Đi tới cửa sổ Thuộc tính và nhấp vào nút hình elip (...) bên cạnh trường Đường viền để chọn kiểu đường viền.
  3. Trong hộp thoại Border, chọn TitledBorder từ danh sách và nhập Number Addition vào trường Title. Nhấp vào "OK" để lưu các thay đổi của bạn và đóng hộp thoại.
  4. Màn hình bây giờ sẽ hiển thị phần tử "JFrame" trống với tiêu đề "Bổ sung số" như trong hình. Theo hình ảnh, thêm ba JLabels, ba JTextFields và ba JButton vào đó.

Đổi tên các phần tử

Bước này sẽ đổi tên các phần tử đã được thêm vào phần tử JFrame.

  1. Bấm đúp vào jLabel1 và thay đổi thuộc tính ntrcn ("văn bản") thành Số đầu tiên.
  2. Nhấp đúp vào jLabel2 và thay đổi văn bản thành Số thứ hai.
  3. Nhấp đúp vào jLabel3 và thay đổi văn bản thành Kết quả.
  4. Xóa văn bản mặc định khỏi jTextField1. Văn bản được hiển thị có thể được chuyển đổi thành văn bản có thể chỉnh sửa. Để thực hiện việc này, nhấp chuột phải vào trường văn bản và chọn "Chỉnh sửa văn bản" từ menu bật lên. Điều này có thể yêu cầu bạn khôi phục jTextField1 về kích thước ban đầu. Lặp lại bước này cho các trường jTextField2 và jTextField3.
  5. Thay đổi văn bản hiển thị của jButton1 thành Clear. (Để thay đổi nội dung của một nút, nhấp chuột phải vào nút đó và chọn Chỉnh sửa văn bản. Ngoài ra, bạn có thể nhấp vào nút, tạm dừng và nhấp lại.)
  6. Thay đổi văn bản hiển thị của jButton2 thành Add .
  7. Thay đổi văn bản hiển thị của jButton3 thành Exit .

Bây giờ GUI đã hoàn thành sẽ trông giống như hình ảnh bên dưới:

Bài tập 3: Thêm chức năng

Bài tập này sẽ thêm chức năng cần thiết vào các nút Thêm, Xóa và Thoát. Các trường jTextField1 và jTextField2 sẽ được sử dụng để người dùng nhập vào và jTextField3 sẽ được sử dụng để hiển thị kết quả của chương trình. Chương trình được tạo là một máy tính đơn giản. Vậy hãy bắt đầu!

Thêm chức năng vào nút Thoát

Để các nút có thể hoạt động, mỗi nút phải được chỉ định một trình xử lý sự kiện, chịu trách nhiệm phản hồi các sự kiện. Trong trường hợp của chúng tôi, chúng tôi cần xác định sự kiện nhấn nút - bằng cách nhấp chuột hoặc sử dụng bàn phím. Do đó, giao diện "ActionListener" sẽ được sử dụng để xử lý các sự kiện "ActionEvent".

  1. Nhấp chuột phải vào nút "Thoát". Từ menu bật lên, hãy chọn Sự kiện > Hành động > hành động được thực hiện. Xin lưu ý rằng menu chứa nhiều sự kiện khác mà chương trình có thể đáp ứng! Khi bạn chọn sự kiện actionPerformed, IDE sẽ tự động thêm ActionListener vào nút Thoát và tạo một phương thức xử lý để xử lý phương thức trình nghe actionPerformed.
  2. IDE tự động mở cửa sổ Mã nguồn, hiển thị cho bạn vị trí chèn hành động mà bạn muốn nút thực hiện khi bạn nhấp vào nút đó (bằng chuột hoặc bàn phím). Cửa sổ "Mã nguồn" phải chứa các dòng sau: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( //TODO thêm mã xử lý của bạn vào đây: )
  3. Bây giờ hãy thêm mã cho hành động mà nút "Thoát" sẽ thực hiện. Thay thế dòng TODO bằng System.exit(0); . Mã hoàn chỉnh cho nút "Thoát" sẽ trông như thế này: private void jButton3ActionPerformed(java.awt.event.ActionEvent evt) ( System.exit(0); )

Thêm chức năng vào nút "Xóa"

  1. Nhấp chuột phải vào nút "Xóa" (jButton1). Từ menu xuất hiện, chọn "Sự kiện > Hành động > hành động được thực hiện".
  2. Việc nhấp vào nút "Xóa" sẽ khiến tất cả văn bản bị xóa khỏi tất cả các trường văn bản "jTextField". Để thực hiện việc này, hãy thêm mã tương tự như mã ở trên. Mã nguồn hoàn thiện sẽ trông như thế này: private void jButton1ActionPerformed(java.awt.event.ActionEvent evt)( jTextField1.setText(""); jTextField2.setText(""); jTextField3.setText(""); )

Mã này xóa văn bản khỏi cả ba JTextFields, để trống chúng.

Thêm chức năng vào nút "Thêm"

Nút "Thêm" sẽ thực hiện ba việc.

  1. Trước tiên, nó lấy dữ liệu đầu vào của người dùng trong các trường jTextField1 và jTextField2 rồi chuyển đổi chúng từ loại "Chuỗi" thành loại "Float".
  2. Sau đó nó sẽ thực hiện phép cộng hai số.
  3. Cuối cùng, nó sẽ chuyển đổi tổng thành Chuỗi và đặt nó vào jTextField3 .
Hãy bắt đầu nào!
  1. Nhấp vào tab Thiết kế ở đầu không gian làm việc để quay lại màn hình Thiết kế biểu mẫu.
  2. Nhấp chuột phải vào nút "Thêm" (jButton2). Từ menu bật lên, hãy chọn Sự kiện > Hành động > hành động được thực hiện.
  3. Thêm mã cho các hành động mà nút "Thêm" sẽ thực hiện. Mã nguồn hoàn thiện sẽ trông như thế này: private void jButton2ActionPerformed(java.awt.event.ActionEvent evt)( // Đầu tiên chúng ta định nghĩa các biến float. float num1, num2, result; // Chúng ta phải phân tích văn bản thành kiểu float .num1 = Float.parseFloat(jTextField1.getText()); num2 = Float.parseFloat(jTextField2.getText()); // Bây giờ chúng ta có thể thực hiện phép cộng. result = num1+num2; // Bây giờ chúng ta sẽ chuyển giá trị của kết quả thành jTextField3. // Đồng thời, chúng ta sẽ // thay đổi giá trị của kết quả từ float thành chuỗi. jTextField3.setText(String.valueOf(result)); )

Bây giờ chương trình đã hoàn toàn sẵn sàng và bạn có thể bắt đầu lắp ráp và thực thi nó.

Bài tập 4: Thực thi chương trình

Để chạy chương trình trong IDE, hãy làm theo các bước sau:

  1. Chọn Chạy > Chạy dự án chính (cách khác, nhấn F6).

    Ghi chú. Nếu bạn mở một cửa sổ cho biết Project NumberAddition không có lớp chính được chỉ định, bạn nên chọn my.NumberAddition.NumberAdditionUI làm lớp chính trong cùng cửa sổ và nhấp vào OK.

Để chạy chương trình bên ngoài IDE, hãy làm theo các bước sau:

Sau vài giây ứng dụng sẽ khởi chạy.

Ghi chú. Nếu việc bấm đúp vào tệp JAR không khởi chạy ứng dụng, hãy xem liên kết tệp JAR trên hệ điều hành của bạn để biết thêm thông tin.

Bạn cũng có thể chạy ứng dụng từ dòng lệnh.

Để chạy ứng dụng từ dòng lệnh, hãy làm theo các bước sau:

  1. Mở dấu nhắc lệnh hoặc cửa sổ đầu cuối.
  2. Tại dấu nhắc lệnh, thay đổi thư mục hiện tại thành thư mục NumberAddition/dist.
  3. Tại dấu nhắc lệnh, nhập câu lệnh sau: java -jar NumberAddition.jar

    Ghi chú.Đảm bảo rằng my.NumberAddition.NumberAdditionUI được đặt làm lớp chính trước khi chạy ứng dụng. Để kiểm tra điều này, hãy nhấp chuột phải vào nút dự án NumberAddition trong bảng Dự án, chọn Thuộc tính từ trình đơn bật lên và chọn danh mục Chạy trong hộp thoại Thuộc tính Dự án. Trường Lớp chính sẽ hiển thị my.numberaddition.NumberAdditionUI .

Công cụ xử lý sự kiện

Hướng dẫn này xem xét việc phản hồi một sự kiện nhấn nút đơn giản. Có nhiều sự kiện mà một ứng dụng có thể phản hồi. Trong IDE, bạn có thể xem danh sách các sự kiện có sẵn mà các phần tử GUI có thể xử lý như sau:

  1. Quay lại tệp NumberAdditionUI.java trong trình chỉnh sửa. Nhấp vào tab "Thiết kế" để xem cấu trúc GUI trong Trình tạo GUI.
  2. Nhấp chuột phải vào bất kỳ thành phần GUI nào và chọn "Sự kiện" từ menu xuất hiện. Bây giờ bạn có thể chỉ cần khám phá nội dung của menu mà không cần chọn bất kỳ mục nào.
  3. Ngoài ra, bạn có thể chọn "Thuộc tính" từ menu "Cửa sổ". Trong cửa sổ Thuộc tính, nhấp vào tab Sự kiện. Tab "Sự kiện" cho phép bạn xem và thay đổi trình xử lý sự kiện được liên kết với thành phần GUI hiện đang hoạt động.
  4. Ứng dụng cũng có thể phản hồi với các lần nhấn phím, nhấp chuột một lần, hai lần hoặc ba lần, chuyển động của con trỏ chuột, thay đổi kích thước cửa sổ và chuyển động tiêu điểm đầu vào. Menu "Sự kiện" cho phép bạn tự động tạo trình xử lý sự kiện cho tất cả các sự kiện này. Phổ biến nhất trong số này là sự kiện "Hành động". (Để biết thêm thông tin, hãy xem cách xử lý các sự kiện trong Hướng dẫn sự kiện Sun Java.)

Các sự kiện được xử lý như thế nào? Bất cứ khi nào bạn chọn một sự kiện từ menu sự kiện, IDE sẽ tự động tạo cái được gọi là trình xử lý sự kiện và liên kết nó với thành phần nhà phát triển. Để tìm hiểu thêm về xử lý sự kiện, hãy làm theo các bước sau:

  1. Quay lại tệp NumberAdditionUI.java trong trình chỉnh sửa. Nhấp vào tab "Nguồn" để xem mã nguồn GUI.
  2. Cuộn xuống để xem các phương thức jButton1ActionPerformed() , jButton2ActionPerformed() và jButton3ActionPerformed() đã được triển khai. Những phương thức này được gọi là xử lý sự kiện.
  3. Bây giờ hãy chuyển sang phương thức initComponents(). Nếu phương thức này bị thiếu, hãy tìm dòng Mã được tạo và nhấp vào dấu + bên cạnh dòng đó để hiển thị phương thức initComponents() ẩn.
  4. Lưu ý khối màu xanh bao quanh phương thức initComponents(). Mã này được IDE tạo tự động và người dùng không thể sửa đổi.
  5. Bây giờ hãy nhìn vào chính phương thức initComponents(). Trong số những thứ khác, nó chứa mã khởi tạo các phần tử GUI và đặt chúng vào biểu mẫu. Mã này được tạo và cập nhật tự động khi bạn đặt và thay đổi các thành phần trong chế độ thiết kế.
  6. Trong phương thức initComponents(), tìm đoạn mã sau: jButton3.setText("Exit"); jButton3.addActionListener(new java.awt.event.ActionListener() ( public void actionPerformed(java.awt.event.ActionEvent evt) ( jButton3ActionPerformed(evt); ) ));

    Tại thời điểm này, đối tượng nghe sự kiện "ActionListener" được thêm vào phần tử GUI, trong trường hợp này là jButton3 . Giao diện "ActionListener" có phương thức "actionPerformed" trên đối tượng "ActionEvent", được triển khai bằng cách gọi trình xử lý sự kiện jButton3ActionPerformed. Nút này hiện phản hồi các sự kiện hành động. Mỗi lần nhấp vào nút, một "ActionEvent" sẽ được tạo và chuyển đến phương thức "actionPerformed" của giao diện trình xử lý sự kiện. Phương thức này sẽ thực thi mã mà nhà phát triển đã cung cấp cho sự kiện đó trong trình xử lý sự kiện.

  7. Thẻ học ứng dụng GUI Java

Ngày 09 tháng 7 năm 2003

Với sự ra đời của nhiều công cụ phát triển ứng dụng trực quan khác nhau, việc viết giao diện đồ họa cho các chương trình đã trở thành một thứ giống như trò chơi của trẻ con. Tôi dùng chuột chọc vào nó và một biểu mẫu xuất hiện; tôi chọc vào nó lần thứ hai và một cái nút xuất hiện. Đối với tôi, có vẻ như hiện nay nhiều người không nghĩ đến một cách lập trình khác trong môi trường đồ họa. Tất nhiên, bạn không thể phản đối sự tiến bộ; khi viết các dự án lớn, tất cả những tiện ích này đều rất hữu ích. Nhưng đó không phải là chủ đề của cuộc trò chuyện này. Đôi khi điều này trở nên vô lý: một ứng dụng nguyên thủy được viết bằng MFC, VCL, v.v. Những chương trình như vậy ngấu nghiến bộ nhớ như lũ mối và với thân hình mập mạp của chúng, chúng chiếm thêm dung lượng đĩa. Theo quy định, các chất tương tự MFC/VCL “nặng” hơn từ 10 đến 20 lần so với các chương trình được viết trên API thuần túy. Và Visual Basic (xin Chúa tha thứ cho tôi vì cụm từ này) với msvbvmXX.dll của nó? Và nhiều tài nguyên hệ thống hơn được tiêu thụ (vài lần). Người dùng nghèo, từ chối bia, tiết kiệm tiền để mua phần cứng mới. Chẳng phải là đáng tiếc cho những điều nghèo nàn sao? Không chỉ lập trình viên mới uống bia? Có một khía cạnh tích cực khác của mã hóa API: lập trình viên trở nên gần gũi hơn với hệ điều hành. Theo đó, anh ấy hiểu và kiểm soát nó tốt hơn. Và thật đơn giản - đó là một hoạt động rất thú vị. Tôi nhắc lại, tất cả những điều trên áp dụng cụ thể cho các chương trình nhỏ, đơn giản, trong các dự án lớn, mọi thứ hoàn toàn khác.

Tôi hy vọng tôi đã thuyết phục được bạn. Đi.

Chúng ta sẽ xem xét việc tạo một giao diện cửa sổ đơn giản với chức năng tối thiểu. Đây sẽ là một cửa sổ đơn giản với hai trường nhập và hai nút. Khi bạn nhấp vào nút "Sao chép", văn bản từ trường nhập đầu tiên sẽ được sao chép sang trường nhập thứ hai. Khi bạn nhấp vào nút "Đóng", chương trình sẽ hoàn thành công việc của nó. Trong tương lai, nó có thể dùng làm mẫu để viết các ứng dụng khác phức tạp hơn. Chúng tôi sẽ giao tiếp bằng C/C++, mặc dù chúng tôi cũng sẽ không xúc phạm Delphi. Nguyên tắc chung là giống nhau, chỉ có cú pháp là khác nhau. Để làm việc với các thông báo hệ thống và chức năng API, bạn cần đưa các tệp tiêu đề vào dự án của mình; trong C/C++ đây là windows.h, trong Delphi đây là các mô-đun cửa sổ và tin nhắn.

Bất kỳ chương trình nào trong hệ điều hành Windows đều bao gồm ba phần chính: chức năng chính, vòng lặp thông báo và chức năng cửa sổ, xử lý tất cả các thông báo được gửi đến cửa sổ.

Chương trình của chúng ta bắt đầu thực thi với hàm WinMain(). Đây là chức năng chính. Hàm WinMain() thường thực hiện các tác vụ sau:

  • Định nghĩa lớp cửa sổ. Đừng nhầm lẫn với lớp OOP.
  • Đăng ký lớp này trong hệ thống.
  • Tạo cửa sổ ứng dụng chính và các điều khiển khác.
  • Hiển thị một cửa sổ trên màn hình.
  • Bắt đầu vòng xử lý tin nhắn.
  • Nó được khai báo theo cách này: int APIENTRY WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow) Hãy xem các tham số:
    • hInstance là một điều khiển cho phiên bản ứng dụng hiện tại.
    • hPrevInstance là một phần điều khiển cho phiên bản trước của ứng dụng, nếu nó đang chạy.
    • lpCmdLine - con trỏ tới dòng chứa các tham số được truyền cho chương trình khi khởi động.
    • nCmdShow - hằng số xác định cách hiển thị cửa sổ. (Xem hằng số SW_).

Trong Delphi, chúng ta sẽ không nhìn thấy một bức tranh như vậy; trong môi trường phát triển này, chức năng chính bị trình biên dịch ẩn khỏi người lập trình. Tất nhiên, mặc dù nó có trong mã cuối cùng. Để đăng ký một lớp cửa sổ, bạn cần điền vào các trường có cấu trúc kiểu WNDCLASS (trong Delphi TWNDCLASS). Với mục đích này, chúng tôi đã khai báo biến wcl. wcl.hInstance = hInstance; Để xử lý phiên bản ứng dụng hiện tại, biến hInstance được khởi tạo bởi hàm WinMain(). Trong Delphi nó được khởi tạo ngầm. wcl.lpszClassName = szWinName; Tên lớp. Chúng tôi đã tạo và khởi tạo trước biến chuỗi szWinName. wcl.lpfnWndProc = WindowFunc; Một con trỏ tới một hàm cửa sổ. wcl.style = 0; Một hằng số xác định kiểu cửa sổ. Cờ CS_ được sử dụng cho việc này, tôi vừa xóa chúng về 0. Bạn có thể chỉ định tổ hợp các cờ bằng thao tác "hoặc" theo bit. wcl.hIcon = LoadIcon(NULL, IDI_ASTERISK); Một điều khiển cho biểu tượng ứng dụng, được trả về bởi hàm LoadIcon(). Tôi đã tải lên một biểu tượng tiêu chuẩn. Xem hằng số IDI_. wcl.hCursor = LoadCursor(NULL,IDC_ARROW); Một điều khiển cho con trỏ ứng dụng, được trả về bởi LoadCursor(). Tôi đã tải mũi tên tiêu chuẩn. Xem hằng số IDC_. wcl.lpszMenuName = NULL; Con trỏ tới một chuỗi xác định tên của tài nguyên menu cho lớp cửa sổ này. Không có thực đơn, không có dấu hiệu. wcl.cbClsExtra = 0; Trường dự trữ. Hãy thiết lập lại. wcl.cbWndExtra = 0; Trường dự trữ. Hãy thiết lập lại. wcl.hbrBackground = (HBRUSH)COLOR_WINDOW; Màu cửa sổ. Hằng số COLOR_WINDOW được chuyển thành kiểu HBRUSH (trong Delphi không cần chuyển). Ngoài ra, bằng cách sử dụng hàm GetStockObject(), bạn có thể đặt màu cọ hoặc hình nền cho cửa sổ. Bây giờ, hãy thoải mái đăng ký lớp cửa sổ.

RegisterClass(&wcl); Một con trỏ tới cấu trúc wcl được truyền dưới dạng tham số cho hàm RegisterClass.

Dòng tiếp theo chúng ta tạo cửa sổ.

hMainWnd = CreateWindow(szWinName, "Một cửa sổ đơn giản trên API.", WS_OVERLAPPEDWINDOW ^ WS_THICKFRAME ^ S_MAXIMIZEBOX, CW_USEDEFAULT, CW_USEDEFAULT, 300, 170, HWND_DESKTOP, NULL, hInstance, NULL);
  • Tham số đầu tiên là tên của lớp cửa sổ.
  • Tham số thứ hai là tiêu đề cửa sổ.
  • Tham số thứ ba là kiểu cửa sổ. Từ WS_OVERLAPPEDWINDOW tiêu chuẩn, bằng cách sử dụng thao tác xor, tôi đã loại bỏ khả năng chia tỷ lệ cửa sổ và tắt nút phóng to.
  • Thứ tư và thứ năm là vị trí của cửa sổ tính từ bên trái, góc trên cùng của màn hình. Tôi có CW_USEDEFAULT, với giá trị này hệ thống sẽ tự động chọn vị trí cửa sổ.
  • Tham số thứ sáu và thứ bảy lần lượt là chiều rộng và chiều cao của cửa sổ.
  • Tham số thứ tám là cửa sổ chủ sở hữu. Tại cửa sổ chính, chủ sở hữu là desktop (0). Các điều khiển có một cửa sổ chính.
  • Thứ chín là một con trỏ tới tay cầm menu. Không có thực đơn, không có dấu hiệu.
  • Tham số thứ mười là một điều khiển cho phiên bản ứng dụng hiện tại.
  • Thứ mười một - Được sử dụng khi tạo ứng dụng có giao diện MDI. Chúng tôi không cần.
Hàm trả về một điều khiển cho cửa sổ đã tạo, được lưu trong biến hMainWnd.
Tay cầm cửa sổ là một số duy nhất trong hệ thống xác định cửa sổ hoặc điều khiển.

Tiếp theo chúng ta sẽ tạo các điều khiển cần thiết. Tất cả các điều khiển đều là các cửa sổ giống nhau, chúng chỉ có tên lớp khác nhau. Không cần phải đăng ký các lớp điều khiển; chúng đã được xác định trước trong hệ thống. Nút - lớp nút. Trường đầu vào - chỉnh sửa lớp. Chú thích - lớp ststic. Có nhiều lớp tương ứng với các điều khiển tiêu chuẩn. Chúng ta tạo các điều khiển bằng hàm CreateWindow() quen thuộc và hàm CreateWindowEx() lạ. CreateWindowEx() cho phép bạn tạo một cửa sổ với kiểu dáng nâng cao. Chúng tôi sử dụng nó để tạo các trường đầu vào. Hàm này đã thêm tham số đầu tiên, thiết lập kiểu cao cấp nhất này, các tham số còn lại giống như CreateWindow(). Điều khiển là cửa sổ con, chủ sở hữu của chúng là cửa sổ chính.

Khi tạo điều khiển, trong tham số hàm, bạn phải chỉ định bộ mô tả của cửa sổ chính, cũng như kiểu cửa sổ WS_CHILD. Hình thức và chức năng của các điều khiển có thể được điều khiển bằng cách sử dụng các cờ: WS_, ES_, BS_, SS_, kết hợp chúng với thao tác “hoặc” theo bit. Khi tạo các điều khiển, chúng ta khởi tạo các biến tương ứng với các bộ mô tả của chúng, được trả về bởi các hàm CreateWindow() và CreateWindowEx(). Chúng ta sẽ cần những bộ mô tả này để tiếp tục làm việc với các điều khiển. Chúng ta hiển thị cửa sổ đã tạo lên màn hình và vẽ lại.

Hàm GetMessage chọn tin nhắn tiếp theo từ hàng đợi tin nhắn của ứng dụng và gửi nó đến cửa sổ.
  • Tham số đầu tiên là cấu trúc kiểu MSG (trong Delphi kiểu TMSG)
  • Tham số thứ hai là một điều khiển cho cửa sổ mà thông báo được gửi tới. Nếu NULL hoặc 0 thì tất cả các cửa sổ ứng dụng.
  • Thứ ba và thứ tư - cho phép bạn đặt phạm vi tin nhắn nhận được. Nếu là 0 thì tất cả các tin nhắn được gửi đến cửa sổ.
GetMessage - trả về FALSE khi thông báo WM_QUIT xuất hiện, trong trường hợp đó vòng lặp được thoát và ứng dụng thoát. TranslateMessage - dịch mã phím ảo thành tin nhắn trên bàn phím. DispatchMessage - gửi tin nhắn đến chức năng cửa sổ để xử lý.

Chức năng cửa sổ cung cấp chức năng của chương trình bằng cách xử lý các thông báo hệ thống. Hàm cửa sổ là hàm CALLBACK, tức là. được hệ điều hành gọi để phản hồi một tin nhắn mới đến. Hàm cửa sổ được khai báo như sau:

LRESULT GỌI LẠI WindowFunc(HWND hMainWnd, UINT iMsg, WPARAM wParam, LPARAM lParam)

  • HMainWnd - xử lý cửa sổ chính.
  • iMsg - số tin nhắn. Xem hằng số WM_.
  • lParam và wParam là các tham số của tin nhắn.

Khi một thông báo xuất hiện, chúng ta có thể so sánh tham số iMsg với một trong các hằng số WM_ và lập trình cho chương trình phản ứng tương ứng.

Ví dụ: Khi nhấn chuột trái trong khi con trỏ chuột đang ở trên vùng client của cửa sổ thì sự kiện WM_LBUTTONDOWN được phát sinh. Hàm cửa sổ được gọi, giá trị của hằng số WM_LBUTTONDOWN được nhập vào tham số iMsg, chúng ta có thể kiểm tra điều kiện và lập trình phản ứng của chương trình mà chúng ta cần.

Bên trong hàm cửa sổ là toán tử lựa chọn thực hiện tác vụ được mô tả ở trên. Toán tử lựa chọn phải có trình xử lý mặc định, được triển khai bởi hàm DefWindowProc(hMainWnd, iMsg, wParam, lParam);

Nếu điều này không được thực hiện, chương trình của chúng ta sẽ chết mà không thể phục hồi. Nhiều thông báo được hệ thống tự xử lý, chẳng hạn như: thay đổi kích thước cửa sổ, thu nhỏ/phóng to cửa sổ, gọi menu hệ thống, v.v. Đây chính là mục đích của DefWindowProc().

Khi làm việc với các điều khiển cửa sổ, một thông báo WM_COMMAND được gửi đến chủ sở hữu cửa sổ, với lParam chứa phần điều khiển của điều khiển và byte cao của tham số wParam là mã định danh của sự kiện được đưa ra trên điều khiển. Ví dụ: khi bạn nhấp vào nút - BN_CLICKED. Xem các hằng số BN_, WM_. Chúng ta có thể đóng chương trình bằng hàm PostQuitMessage(0). Hàm này gửi thông báo WM_QUIT tới cửa sổ.

Một vài lời về cách viết các chương trình như vậy trong Delphi. Tạo một dự án mới, khởi chạy Trình quản lý dự án, xóa Unit1 cùng với biểu mẫu. Nhấn Ctrl + F12 và mở tệp dự án. Chúng tôi xóa mô-đun biểu mẫu khỏi mục sử dụng, thêm cửa sổ và tin nhắn vào đó. Chúng tôi xóa mọi thứ giữa đầu và cuối. Phôi đã sẵn sàng. Bạn có thể viết mã. Không thể viết chương trình bằng API thuần túy mà không có sự trợ giúp, điều này luôn có sẵn. Nếu bạn là Gates, bạn sẽ không nhớ được mọi thứ. Tôi khuyên bạn nên:

  • trước hết - MSDN;
  • Hệ thống trợ giúp Delphi (tệp MSTOOLS.HLP);
  • Có trợ giúp bằng tiếng Nga về API Win32 trên trang web http://www.soobcha.ru/rushelp.
Đó là tất cả.
Chúc may mắn.

Bobachenko Maxim Tải xuống: CreateWnd.zip(2.6K)
kho lưu trữ chứa các tệp windows.cpp và windows.dpr

GUI chuẩn.

Một trong những thay đổi quan trọng nhất trong ngành công nghiệp máy tính là sự ra đời của giao diện đồ họa. Vì vậy, có cần thiết phải áp dụng các tiêu chuẩn GUI để xác định các ứng dụng Windows sẽ trông như thế nào không? Macintosh, v.v. Thậm chí còn có những chương trình chứng nhận mà các nhà cung cấp điều chỉnh ứng dụng của họ để đạt được huy hiệu Windows. Điều này được thực hiện vì nhiều lý do.

Một trong những ưu điểm của Windows hoặc Mac là vẻ ngoài tiêu chuẩn của chúng. Khi bạn đã học cách làm việc với một trong số chúng, hãy coi như bạn đã thành thạo phần còn lại. Hầu hết các ứng dụng Windows đều sử dụng các quy ước giống nhau, vì vậy bạn biết cách mở, lưu, in, đóng và sao chép tệp trong bất kỳ ứng dụng nào trong số đó. Giao diện tiêu chuẩn rất thân thiện với người dùng. Bạn cần cố gắng làm cho các ứng dụng của mình giống với các ứng dụng Windows khác mà người dùng đã học cách làm việc. Có bảy nguyên tắc chung cho thiết kế GUI. Nếu bạn tìm hiểu và làm theo chúng, thiết kế ứng dụng của bạn sẽ ổn.

Bảy nguyên tắc thiết kế GUI.

Bảy nguyên tắc chung về thiết kế GUI được lấy từ Hướng dẫn Giao diện Microsoft Windows. Chúng tạo thành một kế hoạch chi tiết mà từ đó bạn có thể tạo ra các tiêu chuẩn của riêng mình. Thiết kế này cung cấp cho các nhà phát triển và người dùng hai lợi ích đáng kể. Trước hết, các ứng dụng trông chuyên nghiệp. Thứ hai, chúng có chức năng, phù hợp với các ứng dụng khác và dễ dàng cho người dùng tìm hiểu.

Tất nhiên, để một ứng dụng thành công, nó phải được viết tốt và hữu ích - đây là những yêu cầu chính. Các nguyên tắc mà chúng ta nói đến chỉ đơn giản là cung cấp cho nhà phát triển những suy nghĩ.

1. Cho phép người dùng điều khiển ứng dụng.

2. Tuân theo mô hình đối tượng/hành động.

3. Hãy nhất quán.

4. Làm cho việc sử dụng ứng dụng trở nên đơn giản và rõ ràng.

5. Phấn đấu cho sự hòa hợp.

6. Cung cấp phản hồi của người dùng.

7. Hãy khoan dung

Nguyên tắc 1: Trao cho người dùng quyền kiểm soát ứng dụng.

Người dùng phải kiểm soát ứng dụng, nghĩa là có quyền truy cập vào từng mô-đun ứng dụng từ bất kỳ mô-đun nào khác. Trước đây, một menu phân cấp được sử dụng để truy cập như vậy.


Giả sử người dùng muốn thêm một khách hàng mới, trong ví dụ này, người dùng phải đi tới mô-đun TÀI KHOẢN RECCIEEVable và sau đó thêm một khách hàng mới từ đó. Làm sao anh ấy biết phải làm gì? Có lẽ là từ trải nghiệm của tôi với ứng dụng này. Và trong thế giới GUI, người dùng chỉ cần chọn lệnh Mới từ menu, sau đó chọn Khách hàng, như trong Hình. Trong hệ thống hiện đại này, bạn có thể thêm khách hàng, nhà cung cấp hoặc mặt hàng tồn kho mới thông qua menu Tệp. Điều này cho phép bạn thay đổi hồ sơ khách hàng khi ở trên màn hình người bán và ngược lại. Người dùng không còn cần phải điều hướng các menu phân cấp phức tạp và khó hiểu nữa.

Nguyên tắc hai: tuân theo mô hình đối tượng/hành động.

Mô hình đối tượng/hành động phát biểu rằng một số thao tác có thể được thực hiện trên tất cả các đối tượng trong hệ thống. Ví dụ đơn giản và rõ ràng nhất là màn hình hỗ trợ cơ sở dữ liệu khách hàng (Hình.). Màn hình chứa một tập hợp các nút và mỗi nút ở phía dưới cho phép bạn thực hiện một số hành động đối với thông tin về khách hàng đã chọn. Bạn có thể xóa nó, chỉnh sửa nó, in nó, v.v. Các hành động có thể được thực hiện trên một máy khách cụ thể phải có sẵn hoặc không có sẵn vào thời điểm thích hợp. Ví dụ: khi bản ghi khách hàng ở chế độ chỉnh sửa, nút Xóa và Mới sẽ bị tắt.

Nguyên tắc thứ ba: nhất quán.

Tính nhất quán là một trong những nguyên tắc quan trọng nhất của thiết kế GUI. GUI – cho phép người dùng khám phá nhiều ứng dụng hơn các chương trình cũ. Và tất cả điều này là nhờ nguyên tắc nhất quán. Khi người dùng gặp một ứng dụng mới, họ đã quen với các lệnh cơ bản: mở, in và lưu tệp. Các ứng dụng được phát triển trên các nền tảng này thường nhất quán với nhau.

Vì vậy, khi tạo ứng dụng mới, hãy nhất quán. Nếu bạn đã sử dụng lệnh Mới để thêm mục nhập mới, hãy sử dụng nó ở mọi nơi. Từ này không được thay thế bằng từ khác - ví dụ: bằng từ Add 9add). Nhờ tính nhất quán của bạn, người dùng sẽ biết rằng bất cứ khi nào họ gặp lệnh Mới, nó có thể được sử dụng để thêm mục nhập mới.

Nguyên tắc bốn: làm cho việc sử dụng ứng dụng trở nên đơn giản và rõ ràng.

Một cách khác để diễn đạt ý tưởng này là: không sử dụng biệt ngữ. Có một màn hình với hai nút. Một trong số họ nói “Đóng gói cơ sở dữ liệu” và người kia nói “Xóa các bản ghi được đánh dấu để xóa”. Mục thứ hai có thể sẽ dễ hiểu hơn đối với người dùng.

Khi phát triển ứng dụng, người ta thường có xu hướng sử dụng tiếng lóng của lập trình viên trong giao diện. Cố gắng tránh điều này nếu có thể.

Nguyên tắc thứ năm: Phấn đấu cho sự hòa hợp

Ngay cả với màu đen trắng, màn hình này vẫn có một nhược điểm đáng kể về mặt thẩm mỹ: nền trắng với các vật thể tương phản trên đó. Trong bộ lễ phục. Màn hình tương tự trông có vẻ cân bằng màu sắc.

Có hàng triệu cách kết hợp màu sắc mà bạn có thể chuyển sang Windows. Điều này có nghĩa là tất cả chúng đều cần được sử dụng? Dĩ nhiên là không. Bạn nên chọn những màu sắc đơn giản, nhẹ nhàng và tránh sự pha trộn hỗn loạn của chúng, điều này vì lý do nào đó mà một số lập trình viên thích.

Nguyên tắc thứ sáu. Cung cấp phản hồi cho người dùng.

Hãy tưởng tượng rằng ứng dụng của bạn có một quy trình mất nhiều thời gian để thực thi. Trong thời gian này, trên màn hình bạn có thể hiển thị thông báo với nội dung như sau: “Chương trình đang chạy, vui lòng đợi”. Giải pháp thuận tiện; nhưng làm sao người dùng biết nó không bị đóng băng? Vì vậy, rất có thể anh ta sẽ chào ứng dụng bằng “chào bằng ba ngón tay” (Ctrl+Alt+Del), mặc dù mọi thứ sẽ ổn với chương trình.

Tốt hơn là nên cho người dùng thấy phần nào của quy trình đã được hoàn thành. Sau đó, anh ta sẽ không làm gián đoạn chương trình một cách không cần thiết, anh ta sẽ có thể đánh giá xem công việc đã tiến triển đến mức nào và làm những việc khác cho đến khi quá trình hoàn tất. Do đó, năng suất của người dùng sẽ tăng khoảng 25%. Kết quả này có thể đạt được bằng cách hiển thị đồng hồ trên màn hình. Thông thường, các thông báo như “10 trên 100 bản ghi đã được xử lý” hoặc “hoàn thành 40%” sẽ được hiển thị. Thậm chí tốt hơn là hiển thị cả số lượng hồ sơ được xử lý và tỷ lệ phần trăm của chúng."

Nguyên tắc thứ bảy: Hãy tha thứ

Mỗi người trong chúng ta đôi khi đã xóa một bài viết do vô tình nhấn nhầm nút. Do đó, hãy cho người dùng cơ hội thay đổi ý định hoặc hủy bỏ các hành động vừa thực hiện. Nếu một quá trình mất nhiều thời gian, thay đổi nhiều dữ liệu hoặc yêu cầu người dùng sao lưu dữ liệu trước khi thực hiện hành động, bạn nên đưa ra cảnh báo. Tôi đã thấy các ứng dụng yêu cầu xác nhận hai lần rồi yêu cầu nhập mật khẩu. Các chương trình của bạn có cần mức độ bảo vệ này không? Có lẽ. Nhiệm vụ của nhà phát triển là giúp đỡ người dùng nếu họ mắc lỗi ở bất kỳ giai đoạn nào của công việc.

Tầm quan trọng của các quy ước tiêu chuẩn GUI.

Như bạn có thể thấy, các nguyên tắc thiết kế GUI rất đơn giản và nên được sử dụng khi tạo màn hình. Tuy nhiên, trước khi thiết kế màn hình, bạn cần xác định xem nó sẽ trông như thế nào. Chọn kích thước, phông chữ, màu sắc, kiểu tin nhắn, v.v. Bằng cách giải quyết trước những vấn đề này, bạn sẽ tăng tốc đáng kể công việc của mình. Về phông chữ hay kiểu dáng của tin nhắn sau này, bạn chỉ cần nhìn vào tiêu chuẩn.