Spring Bag Layout
Kelas SpringLayout ditambahkan pada JDK versi 1.4 untuk mendukung tata letak dalam pembangun GUI. SpringLayout adalah manajer tata letak yang sangat fleksibel yang dapat meniru banyak fitur dari manajer tata letak lainnya. SpringLayout, bagaimanapun, sangat rendah tingkat dan dengan demikian Anda benar-benar hanya harus menggunakannya dengan pembangun GUI, daripada mencoba untuk kode manajer layout musim semi dengan tangan.
Bagian ini dimulai dengan contoh sederhana yang menunjukkan semua hal yang perlu Anda ingat untuk membuat tata letak semi pertama Anda - dan apa yang terjadi ketika Anda lupa mereka! Kemudian menyajikan metode utilitas yang memungkinkan Anda lay out komponen dalam beberapa jenis grid.
Berikut adalah gambar dari beberapa layout akan kita bahas:
Bagaimana Layouts Musim Semi Kerja
Layout semi melakukan pekerjaan mereka dengan mendefinisikan hubungan directional, atau kendala, antara tepi komponen. Sebagai contoh, Anda mungkin mendefinisikan bahwa tepi kiri satu komponen adalah jarak tetap (5 piksel, katakanlah) dari tepi kanan dari komponen lain.
Dalam sebuah SpringLayout, posisi ujung masing-masing tergantung pada posisi hanya satu ujung lainnya. Jika kendala selanjutnya ditambahkan untuk menciptakan mengikat baru untuk tepi, mengikat sebelumnya dibuang dan tepi tetap bergantung pada satu ujung.
Tidak seperti manajer tata letak banyak, SpringLayout tidak secara otomatis mengatur lokasi komponen yang dikelolanya. Jika Anda tangan-kode GUI yang menggunakan SpringLayout, ingat untuk menginisialisasi lokasi komponen dengan membatasi barat / timur dan utara / selatan lokasi. Tergantung pada kendala yang Anda gunakan, Anda juga mungkin perlu untuk mengatur ukuran wadah eksplisit.
Komponen mendefinisikan properti tepi, yang dihubungkan oleh kasus Spring. Setiap musim semi memiliki empat sifat - nilai-nilai minimum, disukai, dan maksimum, dan sebenarnya (saat ini) nilai. Mata-mata terkait dengan setiap komponen dikumpulkan menjadi objek SpringLayout.Constraints.
Sebuah contoh dari kelas Semi memegang tiga sifat yang menjadi ciri perilaku:, minimum nilai-nilai yang disukai, dan maksimum. Masing-masing sifat mungkin terlibat dalam mendefinisikan keempat, nilai, properti berdasarkan serangkaian aturan.
Sebuah contoh dari kelas Semi dapat divisualisasikan sebagai musim semi mekanis yang memberikan kekuatan korektif pegas yang dikompresi atau diregangkan jauh dari nilai yang disukai. Gaya ini dimodelkan sebagai fungsi linear dari jarak dari nilai disukai, namun dengan dua konstanta yang berbeda - satu untuk kekuatan kompresi dan satu untuk satu tensional. Mereka konstanta ditentukan oleh nilai-nilai minimum dan maksimum dari musim semi sehingga musim semi pada nilai minimumnya menghasilkan gaya yang sama dan berlawanan dengan apa yang dibuat ketika itu adalah pada nilai maksimumnya. Perbedaan antara nilai-nilai yang disukai dan minimum, oleh karena itu, merupakan kemudahan yang musim semi dapat dikompresi. Perbedaan antara maksimum dan nilai-nilai yang disukai menunjukkan kemudahan yang Spring dapat diperpanjang.
Berdasarkan hal ini, SpringLayout dapat divisualisasikan sebagai satu set objek yang dihubungkan oleh satu set mata pada pinggirannya.
Contoh: SpringDemo
Bagian ini akan membawa Anda melalui langkah-langkah khas menentukan kendala untuk wadah yang menggunakan SpringLayout. Contoh pertama, SpringDemo1.java, adalah sebuah aplikasi yang sangat sederhana yang dilengkapi dengan label dan field teks dalam panel konten dikendalikan oleh tata letak musim semi. Berikut adalah kode yang relevan:
public class SpringDemo1 {
public static void main (String [] args) {
...
Kontainer ContentPane = frame.getContentPane ();
SpringLayout tata letak = new SpringLayout ();
contentPane.setLayout (tata letak);
contentPane.add (new JLabel ("Label:"));
contentPane.add (new JTextField ("Teks lapangan", 15));
...
frame.pack ();
frame.setVisible (true);
}
}
Berikut adalah apa yang GUI terlihat seperti ketika pertama kali muncul:
Berikut adalah apa yang tampak seperti ketika diubah ukurannya menjadi lebih besar:
Jelas, kami memiliki beberapa masalah. Tidak hanya frame datang terlalu kecil, tapi bahkan ketika diubah ukurannya komponen semua terletak di (0,0). Hal ini terjadi karena kita telah menetapkan ada mata air menentukan posisi komponen dan lebar wadah. Satu penghiburan kecil adalah bahwa setidaknya komponen berada pada ukuran yang mereka sukai - kita mendapatkan bahwa untuk bebas dari mata air standar yang dibuat oleh SpringLayout untuk setiap komponen.
Contoh berikutnya, SpringDemo2.java, memperbaiki situasi sedikit dengan menentukan lokasi untuk component.Click setiap tombol Launch untuk menjalankan SpringDemo2 menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Dalam contoh ini, kita akan menetapkan bahwa komponen akan muncul dalam satu baris, dengan 5 piksel antara mereka. Kode berikut menentukan lokasi label:
/ / Mengatur kendala untuk label jadi di (5,5).
layout.putConstraint (SpringLayout.WEST, label,
5,
SpringLayout.WEST, ContentPane);
layout.putConstraint (SpringLayout.NORTH, label,
5,
SpringLayout.NORTH, ContentPane);
Panggilan putConstraint pertama menetapkan bahwa kiri label (barat) sisi harus 5 piksel dari tepi kiri wadah itu. Ini berarti ada koordinat x dari 5. Panggilan kedua putConstraint mendirikan hubungan yang sama antara (utara) tepi atas label dan wadahnya, sehingga ay koordinat dari 5.
Berikut adalah kode yang menentukan lokasi bidang teks:
/ / Sesuaikan kendala untuk bidang teks sehingga pada
/ / (<label's Hak edge> + 5, 5).
layout.putConstraint (SpringLayout.WEST, textField,
5,
SpringLayout.EAST, label);
layout.putConstraint (SpringLayout.NORTH, textField,
5,
SpringLayout.NORTH, ContentPane);
Panggilan putConstraint pertama membuat kiri kolom teks (barat) tepi menjadi 5 piksel jauh dari kanan label (timur) ujung. Panggilan putConstraint kedua adalah seperti panggilan kedua dalam potongan pertama, dan memiliki efek yang sama dari pengaturan komponen y koordinat ke 5.
Contoh sebelumnya masih memiliki masalah wadah datang terlalu kecil. Tetapi ketika kita mengubah ukuran jendela, komponen berada di tempat yang tepat:
Untuk membuat wadah awalnya muncul di ukuran yang tepat, kita perlu mengatur mata air yang mendefinisikan (selatan) kanan (timur) dan bawah tepi wadah itu sendiri. Tidak ada kendala untuk tepi kontainer kanan dan bawah diatur secara default. Ukuran wadah didefinisikan dengan menetapkan kendala-kendala. SpringDemo3.java menunjukkan bagaimana untuk melakukan hal ini. Klik tombol Launch untuk menjalankan SpringDemo3 menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Berikut adalah kode yang menetapkan mata air wadah ini:
layout.putConstraint (SpringLayout.EAST, ContentPane,
5,
SpringLayout.EAST, textField);
layout.putConstraint (SpringLayout.SOUTH, ContentPane,
5,
SpringLayout.SOUTH, textField);
Panggilan putConstraint pertama membuat tepi kanan wadah ini menjadi 5 piksel di sebelah kanan tepi kanan kolom teks. Yang kedua membuat tepi bawah nya menjadi 5 piksel melewati tepi bawah komponen tertinggi (yang, untuk mudahnya, kami telah diasumsikan adalah bidang teks).
Akhirnya, jendela muncul pada ukuran yang tepat:
Ketika kita membuat jendela besar kita bisa melihat tata letak semi dalam tindakan, mendistribusikan ruang ekstra antara komponen yang tersedia.
Dalam hal ini tata letak semi telah memilih untuk memberikan semua ruang ekstra untuk bidang teks. Meskipun tampaknya seperti tata letak semi memperlakukan label dan bidang teks berbeda, tata letak semi tidak memiliki pengetahuan khusus dari setiap komponen Swing atau AWT. Ini bergantung pada nilai-nilai minimum komponen, disukai, dan sifat ukuran maksimum. Bagian berikutnya membahas bagaimana tata letak semi menggunakan sifat ini, dan mengapa mereka dapat menyebabkan distribusi ruang yang tidak merata.
Springs dan Ukuran Komponen
Sebuah objek SpringLayout otomatis menginstal Springs untuk tinggi dan lebar masing-masing komponen yang SpringLayout kontrol. Mata air ini pada dasarnya mencakup untuk getMinimumSize komponen ini, getPreferredSize, dan metode getMaximumSize. Dengan "meliputi" kita berarti bahwa tidak hanya mata air diinisialisasi dengan nilai-nilai yang sesuai dari metode ini, tetapi juga bahwa mata air melacak nilai-nilai tersebut. Misalnya, objek Musim Semi yang mewakili lebar komponen adalah jenis khusus musim semi yang hanya delegasi pelaksanaannya dengan metode ukuran yang relevan dari komponen. Dengan begitu musim semi tetap sinkron dengan metode ukuran sebagai karakteristik dari perubahan komponen.
Ketika getMaximumSize komponen dan metode getPreferredSize mengembalikan nilai yang sama, SpringLayout menafsirkan ini sebagai berarti bahwa komponen tidak boleh meregang. JLabel dan JButton adalah contoh komponen dilaksanakan dengan cara ini. Untuk alasan ini, label dalam contoh SpringDemo3 tidak meregang.
Metode getMaximumSize dari beberapa komponen, seperti JTextField, mengembalikan Integer.MAX_VALUE nilai untuk lebar dan tinggi dari ukuran maksimum, menunjukkan bahwa komponen dapat tumbuh sampai ukuran. Untuk alasan ini, ketika jendela SpringDemo3 diperbesar, SpringLayout mendistribusikan semua ruang ekstra untuk mata air-satunya yang dapat tumbuh - yang menentukan ukuran kolom teks.
Lebih Tentang API SpringLayout
Contoh SpringDemo menggunakan metode putConstraint SpringLayout untuk mengatur air yang berhubungan dengan masing-masing komponen. Metode putConstraint adalah metode kenyamanan yang memungkinkan Anda memodifikasi kendala komponen tanpa perlu menggunakan API semi tata letak penuh. Di sini, sekali lagi, adalah kode dari SpringDemo3 yang menetapkan lokasi label:
layout.putConstraint (SpringLayout.WEST, label,
5,
SpringLayout.WEST, ContentPane);
layout.putConstraint (SpringLayout.NORTH, label,
5,
SpringLayout.NORTH, ContentPane);
Berikut ini adalah kode setara yang menggunakan SpringLayout.Constraints dan kelas Musim Semi secara langsung:
SpringLayout.Constraints contentPaneCons =
layout.getConstraints (ContentPane);
contentPaneCons.setX (Spring.sum (Spring.constant (5),
contentPaneCons
GetConstraint (SpringLayout.WEST))).;
contentPaneCons.setY (Spring.sum (Spring.constant (5),
contentPaneCons
GetConstraint (SpringLayout.NORTH))).;
Untuk melihat demo seluruh dikonversi untuk menggunakan API ini, lihat SpringDemo4.java. File yang juga mencakup versi (dan banyak lagi) lebih dipoles dari kode yang menetapkan ukuran kontainer. Klik tombol Launch untuk menjalankan SpringDemo4 menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Sebagai potongan sebelumnya menyiratkan, SpringLayout dan SpringLayout.Constraints cenderung menggunakan konvensi yang berbeda untuk menggambarkan mata. API SpringLayout menggunakan tepi untuk menentukan kendala. Springs menghubungkan tepi untuk membangun hubungan linear antara mereka. Tepi didefinisikan oleh komponen, menggunakan konstanta berikut:
SpringLayout.NORTH menentukan tepi atas persegi panjang komponen berlari.
SpringLayout.SOUTH menentukan tepi bawah persegi panjang komponen berlari.
SpringLayout.EAST menentukan tepi kanan persegi panjang komponen berlari.
SpringLayout.WEST menentukan tepi kiri persegi panjang komponen berlari.
SpringLayout.BASELINE menentukan dasar dari komponen.
SpringLayout.HORIZONTAL_CENTER menentukan pusat horisontal persegi panjang komponen berlari.
SpringLayout.VERTICAL_CENTER menentukan pusat vertikal persegi panjang komponen berlari.
Tepi berbeda dari objek Spring kelas SpringLayout.Constraints tahu tentang tepi, tetapi hanya memiliki obyek Spring untuk sifat berikut:
x
y
lebar
tinggi
Setiap objek Kendala mempertahankan hubungan berikut antara mata dan ujung-ujungnya mereka wakili:
barat = x
utara = y
timur = x + lebar
selatan = y + tinggi
Jika Anda bingung, jangan khawatir. Bagian berikutnya menyajikan metode utilitas yang dapat Anda gunakan untuk menyelesaikan beberapa tugas tata letak umum tanpa mengetahui apa-apa tentang tata letak API musim semi.
Utilitas Metode Grids
Karena kelas SpringLayout diciptakan untuk pembangun GUI, menyiapkan air individu untuk layout bisa rumit untuk kode dengan tangan. Bagian ini menyajikan beberapa metode yang dapat digunakan untuk menginstal semua mata air yang diperlukan untuk lay out sekelompok komponen dalam kotak. Metode ini meniru beberapa fitur dari GridLayout, GridBagLayout, dan kelas BoxLayout.
Kedua metode, yang disebut makeGrid dan makeCompactGrid, didefinisikan dalam SpringUtilities.java. Kedua metode bekerja dengan mengelompokkan komponen bersama-sama dalam baris dan kolom dan menggunakan metode Spring.max untuk membuat lebar atau semi tinggi yang membuat baris atau kolom cukup besar untuk semua komponen di dalamnya. Dalam metode makeCompactGrid lebar yang sama atau musim semi tinggi digunakan untuk semua komponen dalam kolom atau baris tertentu, masing-masing. Dalam metode makeGrid, sebaliknya, mata air lebar dan tinggi yang dimiliki oleh setiap komponen dalam wadah, memaksa mereka semua untuk menjadi ukuran yang sama. Selain itu, metode pabrik yang disediakan oleh Spring untuk menciptakan berbagai jenis mata air, termasuk air yang bergantung pada mata air lainnya.
Mari kita lihat metode ini dalam tindakan. Contoh pertama kami, diimplementasikan dalam file sumber SpringGrid.java, menampilkan sekelompok angka dalam bidang teks. Bidang teks pusat jauh lebih luas daripada yang lain. Sama seperti dengan GridLayout, memiliki satu sel besar memaksa semua sel untuk menjadi sama besar. Klik tombol Launch untuk menjalankan SpringGrid menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Berikut adalah kode yang menciptakan dan menjabarkan bidang teks di SpringGrid:
JPanel panel = new JPanel (new SpringLayout ());
for (int i = 0; i <9; i + +) {
JTextField textField = new JTextField (Integer.toString (i));
... / / Ketika saya == 4, menempatkan teks panjang di bidang teks ...
panel.add (textField);
}
...
SpringUtilities.makeGrid (panel,
3, 3, / / baris, cols
5, 5, / / initialX, semula
5, 5) ;/ / xPad, yPad
Sekarang mari kita lihat contoh, dalam file sumber SpringCompactGrid.java, yang menggunakan metode makeCompactGrid bukan makeGrid. Contoh ini menampilkan banyak angka untuk memamerkan kemampuan semi tata letak untuk meminimalkan ruang yang dibutuhkan. Klik tombol Launch untuk menjalankan SpringCompactGrid menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Berikut adalah apa yang GUI SpringCompactGrid terlihat seperti:
Berikut adalah kode yang menciptakan dan menjabarkan bidang teks di SpringCompactGrid:
JPanel panel = new JPanel (new SpringLayout ());
int baris = 10;
int cols = 10;
for (int r = 0; r <baris, r + +) {
for (int c = 0; c <cols, c + +) {
int anInt = (int) Math.pow (r, c);
JTextField textField =
new JTextField (Integer.toString (anInt));
panel.add (textField);
}
}
/ / Lay out panel.
SpringUtilities.makeCompactGrid (panel, / / orang tua
baris, cols,
3, 3, / / initX, inity
3, 3); / / xPad, yPad
Salah satu kegunaan handiest untuk metode makeCompactGrid yang mengasosiasikan label dengan komponen, di mana label dalam satu kolom dan komponen lain. The SpringForm.java File menggunakan makeCompactGrid dengan cara ini, seperti gambar berikut menunjukkan.
Klik tombol Launch untuk menjalankan springform menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Berikut adalah kode yang menciptakan dan menjabarkan label-teks pasangan lapangan di springform:
String [] = {label "Nama:", "Faks:", "Email:", "Alamat:"};
int numPairs = labels.length;
/ / Membuat dan mengisi panel.
JPanel p = new JPanel (new SpringLayout ());
for (int i = 0; i <numPairs, i + +) {
JLabel l = new JLabel (label [i], JLabel.TRAILING);
p.add (l);
JTextField textField = new JTextField (10);
l.setLabelFor (textField);
p.add (textField);
}
/ / Lay out panel.
SpringUtilities.makeCompactGrid (p,
numPairs, 2, / / baris, cols
6, 6, / / initX, inity
6, 6), / / xPad, yPad
Karena kita menggunakan manajer layout nyata, bukan posisi absolut, manajer tata letak merespon secara dinamis terhadap perubahan komponen yang terlibat. Sebagai contoh, jika nama-nama label terlokalisasi, tata letak semi menghasilkan konfigurasi yang memberikan kolom pertama ruang lebih atau kurang, sesuai kebutuhan. Dan seperti yang ditunjukkan gambar berikut, ketika jendela diubah ukurannya, komponen fleksibel berukuran - bidang teks - mengambil semua kelebihan ruang, sedangkan label tetap berpegang pada apa yang mereka butuhkan.
Contoh terakhir kami metode makeCompactGrid, di SpringBox.java, menunjukkan beberapa tombol dikonfigurasi untuk diletakkan dalam satu baris. Klik tombol Launch untuk menjalankan SpringBox menggunakan Java ™ Web Start (download JDK 6 atau yang lebih baru). Atau, untuk mengkompilasi dan menjalankan contoh sendiri, konsultasikan indeks contoh.
Perhatikan bahwa perilaku hampir identik dengan BoxLayout dalam kasus satu baris. Tidak hanya komponen ditata sebagai BoxLayout akan mengatur mereka tetapi ukuran minimum, disukai, dan maksimum dari wadah yang menggunakan SpringLayout yang mengembalikan hasil yang sama yang akan BoxLayout. Berikut adalah panggilan untuk makeCompactGrid yang menghasilkan tata letak ini:
Mari kita lihat apa yang terjadi ketika kita mengubah ukuran jendela ini. Ini merupakan kasus khusus aneh yang bernilai memperhatikan karena Anda dapat berjalan ke dalamnya oleh kecelakaan di layout pertama Anda.
Tidak ada yang bergerak! Itu karena tidak ada komponen (tombol) atau jarak antara mereka didefinisikan menjadi merenggang. Dalam hal ini tata letak semi menghitung ukuran maksimum untuk wadah induk yang sama dengan ukuran yang disukai, yang berarti wadah induk sendiri tidak merenggang. Ini mungkin akan kurang membingungkan jika AWT menolak untuk mengubah ukuran jendela yang tidak merenggang, tetapi tidak. Para manajer layout tidak bisa berbuat apa-apa masuk akal di sini karena tidak ada komponen akan mengambil ruang yang dibutuhkan. Alih-alih menabrak, itu hanya tidak apa-apa, meninggalkan semua komponen seperti mereka.
Share
