Overview: Այս հոդվածում մենք կքննարկենք մասին թափանցիկության եւ տարբեր ձեւավորված պատուհանները Java. Այս Java 7 Swing աջակցում է այդ հնարավորությունը, եւ կատարել կախել UI բաղադրիչներն ավելի ճկուն է եւ օգտվողը բարեկամական.
Ներածություն: Որոշ հայտ, թափանցիկ պատուհանը պահանջ է աջակցելու իր ֆունկցիոնալությունը. Այժմ Java, թափանցիկությունը կարող է իրականացվել. Ա կիսաթափանցիկ պատուհանը ստեղծվել է փոփոխելուց իր անթափանցիկություն իրականացնելով մի մեթոդ, որը կոչվում է setOpacity է JFrame բաղադրիչի. Բայց մենք պետք է հասկանանք, որ կիսաթափանցիկ պատուհանը հնարավոր է միայն, եթե հիմքում ընկած օպերացիոն համակարգը աջակցում է այն. Եվ մենք նաեւ պետք է համոզվեք, որ պատուհանը չի զարդարում. Որպեսզի պատուհան undecorated, դուք պետք է զանգահարել setUndecorated (ճիշտ) մեթոդ. Որոշ ժամանակ դա նույնպես պահանջվում է փոխել ձեւավորել մի պատուհանում UI. Իրականացնելու համար, մենք պետք է զանգահարել setShape եղանակը շրջանակներում componentResized մեթոդով. Դա վերահաշվարկ է ձեւավորել, երբ պատուհանը չափսերը վերափոխվում.
Back հիմք: In java UI, աջակցություն translucency եւ ձեւավորված պատուհանից մի երկար ժամանակ պահանջ Swing / AWT բաղադրիչների. For հայրենի զարգացման օգտվելու այդ գույքը հասանելի են երկար ժամանակ ետ. Բայց դա չի եղել հասանելի առանցքային Java բաղադրիչների. In Java6 առաջ, Օժանդակություն translucency եւ ձեւավորված պատուհան չէ. Նույնիսկ մեկ անկախ ղեկավարվել մակարդակի translucency է նաեւ աջակցում է Java7.
Type աջակցության համար translucency եւ թափանցիկություն: Java 7 աջակցում է հետեւյալ երեք տեսակի աջակցություն.
Կիսաթափանցիկ: Այս հնարավորությունը պատուհանը կարող է ունենալ տարբեր գույներով, սակայն նույն մակարդակի անթափանցիկություն. Այնպես որ ալֆա արժեքը նույնն է բոլոր պիքսել. Սա ազդեցություն հարմար է մարել դուրս պատուհանը, հետո աստիճանաբար նվազում է եւ մեծացնում է ալֆա արժեքը.
PERPIXEL_TRANSLUCENT: Այս գույքը աջակցում է տարբեր ԱԼՖԱ արժեքների շրջանակներում պատուհանի մեջ. Սա օգտագործվում է մարել ընտրված շրջանի պատուհանում.
PERPIXEL_TRANSPARENT: Այս գույքը աջակցում է տարբեր չափերի է Windows, այլ ոչ թե ավանդական ուղղանկյան. Եթե մեկ անկախ ղեկավարվել թափանցիկության ապահովում, ապա տարբեր ձեւավորում, ինչպիսիք circle, եռանկյունի կարող է ստեղծվել.
Մինչեւ մենք օգտագործում վերը նշված որեւէ հատկությունների մենք պետք է փորձարկել աջակցությունը տակ պառկած օպերացիոն համակարգ. The test կարող է անել, օգտագործելով մեթոդով isWindowTranslucencySupported պատկանող java.awt.GraphicsDevice դասի. Այն տեւում տեսակը թափանցիկության որպես մուտքային եւ վերադարձնում ճիշտ / սխալ ցույց աջակցությունը.
Եկեք ստուգել օրինակելի կոդը իրականացնել translucency հնարավորությունը. Այս օրինակում մենք ստեղծել ենք մի ուղղանկյուն կիսաթափանցիկ պատուհան տեքստային տարածքում. Առաջին, մենք կասեցրել են ձեւավորում ռեժիմն ստանալ ազդեցությունը թափանցիկության. Հետո մենք ստուգել, եթե հիմքում ընկած օպերացիոն համակարգը աջակցում է այն, թե ոչ:. Եթե աջակցությամբ ազդեցությունը տեսանելի են շրջանակ պատուհանի.
Listing1: Sample է Translucency է JFrame պատուհանում
ներմուծում java.awt.Color;
ներմուծում java.awt.GraphicsDevice;
ներմուծում java.awt.GraphicsEnvironment;
ներմուծում java.awt.GridBagLayout;
ներմուծում java.awt.event.ComponentAdapter;
ներմուծում java.awt.event.ComponentEvent;
ներմուծում java.awt.geom.Rectangle2D;
ներմուծում javax.swing.JFrame;
ներմուծում javax.swing.JTextArea;
ներմուծում javax.swing.SwingUtilities;
հասարակություն դաս TransRecFrame տարածվում JFrame {
/**
* Ստեղծել թափանցիկ ուղղանկյուն շրջանակի հետ 85% թափանցիկություն
*/
հասարակություն TransRecFrame() {
սուպեր(“Կիսաթափանցիկ ուղղանկյուն Frame”);
//Սահմանել դասավորությունը
setLayout(նոր GridBagLayout());
//Տեքստային գոտի
եզրափակիչ JTextArea txtArea = նոր JTextArea(5, 50);
txtArea.setBackground(Գույն.Cyan);
ավելացնել(txtArea);
//Զանգի անջատելու ձեւավորում
setUndecorated(ճիշտ);
//Զանգի setShape է չափափոխել ձեւավորել, երբ widnow չափսերը վերափոխվում
addComponentListener(նոր ComponentAdapter() {
@ Վերագրել
հասարակություն անվավեր componentResized(ComponentEvent եւ) {
setShape(նոր Rectangle2D.Double(0, 0, getWidth(), getHeight()));
}
});
//Դարձնել պատուհանը 85% թափանցիկ
setOpacity(0.85զ);
//Սահմանել այլ պարամետրեր
setLocationRelativeTo(զրո);
setSize(200, 300);
setDefaultCloseOperation(EXIT_ON_CLOSE);
setVisible(ճիշտ);
}
հասարակություն ստատիկ անվավեր հիմնական(Լար[] args) {
//Ստեղծել գրաֆիկայի միջավայր
Երիտասարդական ձեռնարկություն GraphicsEnvironment = GraphicsEnvironment
.getLocalGraphicsEnvironment();
//Ստուգեք եթե OS աջակցում Translucency
եթե (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.Կիսաթափանցիկ)) {
System.out.println(“OS աջակցում translucency”);
նոր TransRecFrame();
}
}
}
Նկարագրություն աջակցելու translucency եւ ձեւի: Ի Java7 կան հիմնականում երեք հատկանիշները հասանելի է աջակցել translucency եւ ձեւավորել մի պատուհանում.
- Full պատուհան translucency: Այս մոտեցման ամբողջական պատուհանը կիսաթափանցիկ.
- Per անկախ ղեկավարվել translucency: Այս մոտեցման մի մասը պատուհանը կիսաթափանցիկ
- Ձեւավորված պատուհաններ: Դարձնել տարբեր ձեւավորված պատուհանները նման ovale, շրջան, ուղղանկյուն եւ այլն:.
Per անկախ ղեկավարվել translucency:
Մենք արդեն տեսել, թե ինչպես անել, ամբողջական պատուհանի կիսաթափանցիկ նախորդ օրինակում. Այժմ մենք կքննարկենք երկրորդ մասը կատարելու է մի շարք պիքսել կիսաթափանցիկ օգտագործելով իրենց հետին պլան գույն. Կան որոշ սահմանափակումներ են իրականացնել սցենարը. Պատուհանը չպետք է լինի լիարժեք էկրանին, եւ այդ համակարգը պետք է ապահովի անկախ ղեկավարվել մակարդակի translucency. Մնացած կարգի նման է վերը նշված օրինակում.
Հետեւյալ օրինակում մենք կտեսնենք, թե ինչպես կարող է անկախ ղեկավարվել մակարդակը translucency սահմանվում է շրջանակի.
Listing2: Sample է անկախ ղեկավարվել մակարդակը translucency աջակցություն.
ներմուծում javax.swing.*;
ներմուծում java.awt *;
ներմուծում java.awt.event.ActionEvent;
ներմուծում java.awt.event.ActionListener;
հասարակություն դաս PixelTranslucency տարածվում JFrame {
հասարակություն PixelTranslucency() {
սուպեր(“Սահմանել անկախ ղեկավարվել մակարդակի translucency”);
//Սահմանել չափը JFrame
setSize(250, 250);
//Սահմանել դնելու դուրս
getContentPane().setLayout(նոր GridLayout(6, 6));
//Call for անկախ ղեկավարվել ընդլայնված
համար(int i = 0; ես &Լիտվա; 16; i ){
ավելացնել(նոր Pixel Panel(255 – ես * 12));
}
//Սահմանել հետին պլան եւ այլ հատկությունների
setBackground(նոր Գույն(0, 0, 0, 0));
setLocationRelativeTo(զրո);
setVisible(ճիշտ);
}
հասարակություն ստատիկ անվավեր հիմնական(Լար[] args) {
Երիտասարդական ձեռնարկություն GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Ստուգեք եթե պատուհանը աջակցում translucency
եթե (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
Համակարգ.դուրս.println(“OS աջակցում translucency”);
նոր PixelTranslucency();
}
} մասնավոր դաս Pixel Panel տարածվում JPanel {
մասնավոր Pixel Panel(int pixl) {
սուպեր();
setBackground(նոր Գույն(0, 0, 255, pixl));
}
}
}
Ձեւավորված Windows:
Այժմ մենք կքննարկենք մեկ այլ կարեւոր առանձնահատկությունն աջակցությամբ Java7.The ստեղծված պատուհանի աջակցում է բոլոր տեսակի ձեւավորում այն, ինչ պետք է պահանջը մասին. Այս հատկությունը օգնում է ձեզ ստեղծել որեւէ ձեւավորել նման circle, եռանկյունի, Պոլիգոն կամ հնարավոր համալիր ուրվագիծ. The setShape մեթոդը պատուհանի դասի մատչելի է անհրաժեշտ գույքը. Բայց մենք նորից պետք է հիշենք, որ լրիվ էկրանի ռեժիմում չպետք է թույլ տալ, եւ օպերացիոն համակարգը աջակցում translucency.
Հետեւյալ օրինակը ցույց է տալիս օգտագործումը ստեղծված պատուհանում.
Listing3: Ընտրանքը կոդը ցույց օգտագործումը ստեղծված պատուհանում.
ներմուծում javax.swing.*;
ներմուծում java.awt *;
ներմուծում java.awt.geom.Ellipse2D;
ներմուծում java.awt.geom.GeneralPath;
հասարակություն դաս JavaShapedWindow տարածվում JFrame {
հասարակություն JavaShapedWindow() {
սուպեր(“Սահմանել ստեղծված որոնվածը”);
//Սահմանել undecorated OFF ստանալ ազդեցություն
setUndecorated(ճիշտ);
//Սահմանել չափը
setSize(նոր Չափ(250, 250));
//Սահմանել Պոլիգոն հատկությունները
Պոլիգոն Պոլիգոն = նոր Պոլիգոն();
polygon.addPoint(0, 100);
polygon.addPoint(50, 0);
polygon.addPoint(100, 100);
//Սահմանել արժեքները վիճակում
Ellipse2D.Double newCircle = նոր Ellipse2D.Double(0, 50, 1.0*100, 1.0*100);
//Սահմանել ընդհանուր PATH հատկությունները
GeneralPath gpath = նոր GeneralPath();
gpath.append(Պոլիգոն, ճիշտ);
gpath.append(newCircle, ճիշտ);
//Սահմանել ճանապարհով
setShape(gpath);
//Սահմանել տուփ դասավորությունը
getContentPane().setLayout(նոր BoxLayout(getContentPane(), BoxLayout.X_AXIS));
ավելացնել(Արկղ.createHorizontalGlue());
//Ստեղծել պիտակների եւ սահմանել հատկությունները
JLabel newlabel = նոր JLabel(“Java ձեւավորված պատուհան”);
newlabel.setForeground(Գույն.ճերմակ);
ավելացնել(newlabel);
ավելացնել(Արկղ.createHorizontalGlue());
//Սահմանել բովանդակության թրաշ ֆոնային գույն
getContentPane().setBackground(Գույն.cyan);
//Սահմանել դիրքը
setLocationRelativeTo(զրո);
setVisible(ճիշտ);
}
հասարակություն ստատիկ անվավեր հիմնական(Լար[] args) {
Երիտասարդական ձեռնարկություն GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//Ստուգեք OS աջակցություն գույքի
եթե (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
Համակարգ.դուրս.println(“OS աջակցում translucency”);
նոր JavaShapedWindow();
}
}
}
Մենք կարող ենք նաեւ իրականացնել մի համադրություն երկու հատկանիշների պես translucency եւ ձեւավորված պատուհանում. Իրականացնել սույն, կոչ setOpacity եղանակը քո շրջանակներում. Արդյունքը պատուհանը կցուցադրեն համակցված ազդեցությունը. Բայց մենք պետք է հիշենք, որ հիմքում ընկած օպերացիոն համակարգը պետք է ապահովի անկախ ղեկավարվել մակարդակի translucency եւ անկախ ղեկավարվել մակարդակը թափանցիկությունը.
Ամփոփում:
Այս հոդվածում մենք որոշ նոր հնարավորություններ է java7.The translucency եւ ձեւավոր պատուհանի հատկանիշներ են, իրոք, հետաքրքիր է, եւ java UI բաղադրիչներն ավելի ճկուն. Սակայն, միեւնույն ժամանակ, մենք պետք է հիշենք, որ հիմքում ընկած օպերացիոն համակարգը պետք է աջակցի այդ բոլոր հատկությունները. Հակառակ ազդեցությունը տեսանելի չի լինի. Այնպես որ դիմումի մեջ, մենք ստուգել OS աջակցությունը, ապա կիրառել ազդեցությունը. Վերջին առանձնահատկությունն java թույլ է տալիս ծրագրավորողներին ստեղծել տարբեր տեսակի ազդեցություն UI կողմում. Ինչպես մենք բոլորս գիտենք, որ տեսքը եւ զգում կարեւոր ասպեկտը ցանկացած UI վրա հիմնված դիմումը. Այնպես որ ծրագրավորողը այժմ հագեցած գործիքներ դարձնել UI ավելի հաճելի եւ գրավիչ.
