Pangkalahatang-ideya ng: Sa artikulong ito kami ay talakayin ang tungkol sa transparency at iba't ibang hugis bintana sa Java. Sa java 7 swing sumusuporta sa tampok na ito at paggawa ng swing UI mga bahagi mas may kakayahang umangkop at user friendly na.
Panimula: Sa ilang mga application, transparent window ay isang kinakailangan upang suportahan ang pag-andar nito. Ngayon sa Java, transparency maaaring ipinatupad. Ang isang translucent na window ay nilikha sa pamamagitan ng binabago nito opacity sa pamamagitan ng pagpapatupad ng isang pamamaraan na tinatawag na setOpacity sa isang JFrame component. Ngunit kailangan nating maunawaan na ang isang translucent na window ay posible lamang kung ang kalakip na operating system sinusuportahan ito. At kami din kailangan upang matiyak na ang window ay hindi pinalamutian. Upang gumawa ng isang window undecorated, kailangan mong tawagan setUndecorated (totoo) pamamaraan. Ang ilang mga oras din ito ay kinakailangan upang baguhin ang hugis ng isang UI window. Upang ipatupad ito, kailangan naming tumawag setShape pamamaraan sa loob ng componentResized pamamaraan. Ito kalooban muling kalkulahin ang hugis kapag ang window Binabago ang laki ng.
Bumalik lupa: Sa java UI, suporta para sa translucency at hugis window ay isang mahabang demand na oras para sa swing / AWT mga bahagi. Para sa mga native na pag-unlad ng access sa mga pag-aari ay magagamit mula sa mahabang panahon pabalik. Ngunit ito ay hindi naa-access sa pangunahing mga bahagi java. Sa Java6 pasulong, suportahan para translucency at hugis window ay magagamit. Kahit bawat pixel antas translucency ding sumusuporta sa Java7.
Uri ng suporta para sa translucency at transparency: Dyaba 7 sumusuporta sa mga sumusunod na tatlong uri ng suporta.
Aninag: Sa tampok na ito ang window ay maaaring magkaroon ng iba't ibang mga kulay ngunit may parehong antas ng opacity. Kaya ang alpha halaga ay pareho sa lahat ng mga pixel. Ang epektong ito ay angkop para sa fade-off ang isang window at pagkatapos ay unti-unting nababawasan at pinatataas ang alpha halaga.
PERPIXEL_TRANSLUCENT: Ang property na ito ay sumusuporta sa iba't ibang mga halaga alpha sa loob ng window mismo. Ito ay ginagamit upang mapawi napiling rehiyon ng window.
PERPIXEL_TRANSPARENT: Ang property na ito ay sumusuporta sa iba't ibang mga hugis ng mga bintana sa halip na mga tradisyonal na parihaba. Kung bawat pixel na transparency ay suportado pagkatapos ibang mga hugis tulad ng bilog, tatsulok ay maaaring malikha.
Bago namin gamitin ang anuman sa mga katangian sa itaas kailangan namin upang subukan ang suporta ng pagsisinungaling sa ilalim ng operating system. Ang mga pagsubok na maaaring gawin sa pamamagitan ng paggamit ng pamamaraan isWindowTranslucencySupported kasali sa klase java.awt.GraphicsDevice. Tatagal ang uri ng transparency bilang input at nagbabalik true / false upang ipahiwatig ang suporta.
Ipaalam sa amin suriin ang isang sample na code upang ipatupad ang tampok translucency. Sa halimbawang ito gumawa kami ng isang hugis-parihaba translucent na window sa isang lugar na teksto. Una namin pinaandar ang palamuti mode upang makuha ang epekto ng transparency. Pagkatapos namin ang naka-check kung ang kalakip na operating system sinusuportahan ito o hindi. Kung suportado ang epekto ay makikita sa window frame.
Listing1: Halimbawang nagpapakita Translucency ng isang window JFrame
angkat java.awt.Color;
angkat java.awt.GraphicsDevice;
angkat java.awt.GraphicsEnvironment;
angkat java.awt.GridBagLayout;
angkat java.awt.event.ComponentAdapter;
angkat java.awt.event.ComponentEvent;
angkat java.awt.geom.Rectangle2D;
angkat javax.swing.JFrame;
angkat javax.swing.JTextArea;
angkat javax.swing.SwingUtilities;
publiko klase TransRecFrame umaabot JFrame {
/**
* Lumikha ng isang transparent na hugis-parihaba frame na may 85% aninaw
*/
publiko TransRecFrame() {
magara(“Translucent Parihabang Frame”);
//Itakda ang layout
setLayout(bago GridBagLayout());
//Lumikha ng isang text area
pangwakas JTextArea txtArea = bago JTextArea(5, 50);
txtArea.setBackground(Kulay.Cyan);
magdagdag(txtArea);
//Tumawag upang huwag paganahin palamuti
setUndecorated(totoo);
//Tawagan setShape upang palitan ang laki ng hugis kapag widnow Binabago ang laki ng
addComponentListener(bago ComponentAdapter() {
@ Override
publiko walang bisa componentResized(ComponentEvent at) {
setShape(bago Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Gawin ang window 85% malinaw
setOpacity(0.85f);
//Itakda ang iba pang mga parameter
setLocationRelativeTo(sero);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(totoo);
}
publiko statik walang bisa pangunahin(Pisi[] args) {
//Lumikha ng graphics kapaligiran
Youth Venture GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Suriin kung ang OS ay sumusuporta sa Translucency
kung (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.Aninag)) {
System.out.println(“OS ay sumusuporta translucency”);
bago TransRecFrame();
}
}
}
Mga Tampok na suportahan translucency at hugis: Sa Java7 mayroong tatlong pangunahing mga tampok na magagamit upang suportahan ang translucency at hugis ng isang window.
- Buong window translucency: Sa diskarteng ito buong window ay translucent.
- Bawat pixel translucency: Sa diskarteng ito ng isang bahagi ng window ay translucent
- Hugis bintana: Gumawa ng iba't ibang mga hugis tulad ng mga window ng ovale, bilog, hugis-parihaba atbp.
Bawat pixel translucency:
Nakapagpadala na kami nakita kung paano gumawa ng isang kumpletong translucent na window sa nakaraang halimbawa. Ngayon kami ay talakayin ang ikalawang bahagi ng paggawa ng isang hanay ng mga pixels translucent sa pamamagitan ng paggamit ng kanilang mga kulay ng background. Mayroong ilang mga limitasyon upang ipatupad ang sitwasyong ito. Ang bintana ay hindi dapat maging full screen at ang system ay dapat na sumusuporta sa pixel antas translucency. Ang natitira sa ang pamamaraan ay katulad sa halimbawa sa itaas.
Sa mga sumusunod na halimbawa ay namin makita kung paano pixel antas translucency ay naka-set sa isang frame.
Listing2: Halimbawang nagpapakita pixel antas translucency suporta.
angkat javax.swing.*;
angkat java.awt. *;
angkat java.awt.event.ActionEvent;
angkat java.awt.event.ActionListener;
publiko klase PixelTranslucency umaabot JFrame {
publiko PixelTranslucency() {
magara(“Itakda pixel antas translucency”);
//Itakda ang laki ng JFrame
setSize(250, 250);
//Itakda ang lay out
getContentPane().setLayout(bago GridLayout(6, 6));
//Tumawag para sa pixel setting
para(int i = 0; ako < 16; i ){
magdagdag(bago Pixel Panel(255 – ako * 12));
}
//Magtakda ng background at iba pang mga katangian ng
setBackground(bago Kulay(0, 0, 0, 0));
setLocationRelativeTo(sero);
setVisible(totoo);
}
publiko statik walang bisa pangunahin(Pisi[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Suriin kung ang window ay sumusuporta sa translucency
kung (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Sistema.palabas.println(“OS ay sumusuporta translucency”);
bago PixelTranslucency();
}
} pribado klase Pixel Panel umaabot JPanel {
pribado Pixel Panel(int pixl) {
magara();
setBackground(bago Kulay(0, 0, 255, pixl));
}
}
}
Hugis Windows:
Ngayon kami ay talakayin ang tungkol sa isa pang mahalagang tampok na suportado ng Java7.The hugis window sumusuporta sa lahat ng mga uri ng mga hugis ano ang kinakailangan ng mga gumagamit. Ang tampok na ito ay tumutulong sa iyo upang lumikha ng anumang mga hugis tulad ng bilog, tatsulok, polygon o anumang posibleng mga kumplikadong hugis. Ang setShape pamamaraan ng klase window ay magagamit para sa pagtatakda ng mga ari-arian. Ngunit muli mayroon kaming tandaan na ang full screen mode ay hindi dapat pinapayagan at ang mga operating system ay sumusuporta translucency.
Ang sumusunod na halimbawa ay nagpapakita ng paggamit ng hugis window.
Listing3: Ang sample code na nagpapakita ng paggamit ng hugis window.
angkat javax.swing.*;
angkat java.awt. *;
angkat java.awt.geom.Ellipse2D;
angkat java.awt.geom.GeneralPath;
publiko klase JavaShapedWindow umaabot JFrame {
publiko JavaShapedWindow() {
magara(“Itakda ang hugis Window”);
//Itakda undecorated OFF upang makakuha ng epekto
setUndecorated(totoo);
//Itakda ang laki
setSize(bago Sukat(250, 250));
//Itakda ang mga katangian ng polygon
Polygon polygon = bago Poligon();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Itakda ang mga halaga ng hugis
Ellipse2D.Double newCircle = bago Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Magtakda ng pangkalahatang katangian ng landas
GeneralPath gpath = bago GeneralPath();
gpath.append(poligon, totoo);
gpath.append(newCircle, totoo);
//Itakda ang path
setShape(gpath);
//Itakda ang kahon layout
getContentPane().setLayout(bago BoxLayout(getContentPane(), BoxLayout.X_AXIS));
magdagdag(Kahon.createHorizontalGlue());
//Lumikha ng katangian ng tatak at itakda ang
JLabel newlabel = bago JLabel(“Java Hugis window”);
newlabel.setForeground(Kulay.puti);
magdagdag(newlabel);
magdagdag(Kahon.createHorizontalGlue());
//Itakda ang nilalaman pane kulay ng background
getContentPane().setBackground(Kulay.cyan);
//Itakda ang lokasyon
setLocationRelativeTo(sero);
setVisible(totoo);
}
publiko statik walang bisa pangunahin(Pisi[] args) {
Youth Venture GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Suriin OS support para sa ari-arian
kung (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Sistema.palabas.println(“OS ay sumusuporta translucency”);
bago JavaShapedWindow();
}
}
}
Maaari din naming ipatupad ang isang kumbinasyon ng dalawang mga tampok tulad ng translucency at hugis window. Upang ipatupad ito, tumawag setOpacity pamamaraan sa iyong frame. Ang mga resulta ng window ay ipapakita ang pinagsamang epekto. Ngunit dapat naming tandaan ang kalakip na operating system ay dapat suportahan pixel antas translucency at pixel antas ng transparency.
Konklusyon:
Sa artikulong ito namin ang sakop ng ilang mga bagong tampok sa java7.The translucency at hugis window katangian ay talagang kawili-wili at gumawa ng java UI mga bahagi mas may kakayahang umangkop. Ngunit sa parehong panahon ay dapat namin tandaan na ang kalakip na operating system ay dapat na sumusuporta sa lahat ng mga pag-aari. Kung hindi man ang epekto ay hindi makikita. Kaya sa mga application mismo namin suriin ang OS support at pagkatapos ay isakatuparan ang epekto. Ang pinakabagong mga tampok ng java ay nagbibigay-daan sa mga developer na lumikha ng iba't ibang mga uri ng mga epekto sa gilid ng UI. Bilang namin ang lahat ng malaman na ang hitsura at pakiramdam ay isang mahalagang aspeto ng anumang UI based na application. Kaya nag-develop sa ngayon ay nilagyan ng mga tool upang gumawa ng UI ang mas kaaya-aya at kaakit-akit.
