მიმოხილვა: ამ სტატიაში ჩვენ განვიხილავთ შესახებ გამჭვირვალობისა და სხვადასხვა ფორმის ფანჯრები ჯავის. ჯავაში 7 swing მხარს უჭერს ამ ფუნქციის და მიღების swing UI კომპონენტების უფრო მოქნილი და მოსახერხებელი.
შესავალი: ზოგიერთ განაცხადის, გამჭვირვალე ფანჯარა მოთხოვნას მხარს მისი ფუნქციონალურობა. ახლა ჯავაში, გამჭვირვალობა შეიძლება განხორციელდეს. Translucent ფანჯრის იქმნება მიერ შეცვლის თავის opacity განხორციელებით მეთოდი ეწოდება setOpacity on JFrame კომპონენტი. მაგრამ ჩვენ უნდა გვესმოდეს, რომ translucent ფანჯრის შესაძლებელია მხოლოდ იმ შემთხვევაში, თუ ძირითადი ოპერაციული სისტემის ეხმარება მას. ჩვენ ასევე უნდა დავრწმუნდეთ, რომ ფანჯარა არ არის გაფორმებული. იმისათვის, რომ ფანჯრის undecorated, თქვენ უნდა მოვუწოდებთ setUndecorated (ნამდვილი) მეთოდი. რამდენიმე ხნის იგი ასევე საჭიროა შეიცვალოს ფორმა ფანჯარა UI. ამის შესრულება, ჩვენ უნდა მოვუწოდებთ setShape მეთოდი ფარგლებში componentResized მეთოდი. ეს კი recalculate ფორმა, როდესაც ფანჯრის შეცვლის.
უკან საფუძველი: ჯავის UI, მხარდაჭერა გამტარიანობის და ფორმის ფანჯარა იყო დიდი ხნის მოთხოვნა Swing / AWT კომპონენტები. იყიდება მშობლიურ განვითარების ხელმისაწვდომობის ეს ქონება შესაძლებელია დიდი ხნის უკან. მაგრამ ეს არ იყო ხელმისაწვდომი ძირითადი java კომპონენტები. In Java6 შემდგომი, მხარდაჭერა გამტარიანობის და ფორმის ფანჯარა ხელმისაწვდომია. მაშინაც კი, თითო pixel დონეზე გამტარიანობის ასევე მხარს უჭერს ამ Java7.
გაცნობის მხარდაჭერა გამტარიანობის და გამჭვირვალობის: ჯავის 7 მხარს უჭერს სამი სახის მხარდაჭერა.
Translucent: ამ ფუნქცია ფანჯარა შეიძლება ჰქონდეთ განსხვავებული ფერის, მაგრამ იგივე დონის opacity. ასე რომ alpha ღირებულება არის იგივე პიქსელი. ეს ეფექტი განკუთვნილია ქრებოდა off ფანჯარა და შემდეგ თანდათანობით მცირდება და იზრდება alpha ღირებულება.
PERPIXEL_TRANSLUCENT: ეს უძრავი მხარს უჭერს სხვადასხვა alpha ღირებულებების ფარგლებში ფანჯრის თავად. ეს გამოიყენება ქრებოდა შერჩეული რეგიონში ფანჯარა.
PERPIXEL_TRANSPARENT: ეს უძრავი მხარს უჭერს სხვადასხვა ფორმის ფანჯრები, ვიდრე ტრადიციული ოთხკუთხედი. თუ თითო pixel გამჭვირვალობის მხარს უჭერს შემდეგ სხვადასხვა ფორმის, როგორიც წრე, სამკუთხედის შეიძლება შეიქმნას.
სანამ ჩვენ ვიყენებთ არცერთ თვისებების ჩვენ უნდა მოხდეს მხარდაჭერით ქვეშ მწოლიარე ოპერაციული სისტემა. ტესტი შეიძლება გაკეთდეს გამოყენებით მეთოდი isWindowTranslucencySupported კუთვნილი java.awt.GraphicsDevice კლასი. იგი იღებს ტიპის გამჭვირვალობის არგუმენტად და დააბრუნებს true / ცრუ მიუთითოს მხარდაჭერა.
მოდით, შეამოწმოს ნიმუში კოდი განხორციელება გამტარიანობის ფუნქცია. ამ მაგალითში ჩვენ შევქმენით მართკუთხა translucent ფანჯარა ტექსტის არე. პირველი, ჩვენ ინვალიდები გაფორმება რეჟიმში მისაღებად ეფექტი გამჭვირვალეობის. მაშინ ჩვენ შეამოწმეს თუ საქმის ძირითადი ოპერაციული სისტემა მხარს უჭერს თუ არა. თუ მას მხარს ეფექტი ჩანს ჩარჩოში ფანჯარა.
Listing1: ნიმუში აჩვენებს გამტარიანობის of 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() {
სუპერ(“Translucent მართკუთხა ჩარჩო”);
//უცნობია განლაგება
setLayout(ახალი GridBagLayout());
//შექმნა ტექსტის არე
საბოლოო JTextArea txtArea = ახალი JTextArea(5, 50);
txtArea.setBackground(ფერი.ცისფერი);
დავამატებთ(txtArea);
//ზარის გამორთვა გაფორმება
setUndecorated(ნამდვილი);
//ზარის setShape ზომის შეცვლა ფორმა, როდესაც widnow არის შეცვლის
addComponentListener(ახალი ComponentAdapter() {
@ Override
საჯარო ცნოს 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 მხარს უჭერს გამტარიანობის
თუ (genv.getDefaultScreenDevice().isWindowTranslucencySupported(
GraphicsDevice.WindowTranslucency.Translucent)) {
System.out.println(“OS მხარს უჭერს გამტარიანობის”);
ახალი TransRecFrame();
}
}
}
თვისებები მხარდასაჭერად გამტარიანობის და ფორმის: In Java7 არსებობს ძირითადად სამი ფუნქციებს მხარდასაჭერად გამტარიანობის და ფორმის ფანჯარა.
- სრული ფანჯრის გამტარიანობის: ამ მიდგომის სრული ფანჯარა translucent.
- პერ pixel გამტარიანობის: ამ მიდგომის ნაწილი ფანჯარა translucent
- ფორმის ფანჯარა: სხვადასხვა ფორმის ფანჯარა, როგორიცაა ovale, წრე, მართკუთხა და ა.შ..
პერ pixel გამტარიანობის:
ჩვენ უკვე დავინახეთ, თუ როგორ უნდა სრულყოფილი ფანჯრის translucent წინა მაგალითი. ახლა ჩვენ განვიხილავთ მეორე ნაწილი მიღების კომპლექტი pixels translucent გამოყენებით მათი ფონის ფერი. არსებობს შეზღუდვები განხორციელების სცენარი. ფანჯარა არ უნდა იყოს სრულ ეკრანზე და სისტემა მხარი უნდა pixel დონეზე გამტარიანობის. დანარჩენი პროცედურა იგივეა, ზემოთხსენებული მაგალითი.
მიმდინარე მაგალითში ჩვენ ვხედავთ, თუ როგორ pixel დონეზე გამტარიანობის არის დადგენილი ჩარჩო.
Listing2: ნიმუში აჩვენებს pixel დონეზე გამტარიანობის მხარდაჭერა.
იმპორტი javax.swing.*;
იმპორტი java.awt. *;
იმპორტი java.awt.event.ActionEvent;
იმპორტი java.awt.event.ActionListener;
საჯარო კლასის PixelTranslucency ვრცელდება JFrame {
საჯარო PixelTranslucency() {
სუპერ(“უცნობია pixel დონეზე გამტარიანობის”);
//უცნობია ზომის JFrame
setSize(250, 250);
//უცნობია ქმნის out
getContentPane().setLayout(ახალი GridLayout(6, 6));
//საგრანტო pixel გარემოში
ამისთვის(int I = 0; i &ლ; 16; i ){
დავამატებთ(ახალი Pixel Panel(255 – i * 12));
}
//უცნობია ფონზე და სხვა თვისებები
setBackground(ახალი ფერი(0, 0, 0, 0));
setLocationRelativeTo(ნულოვანი);
setVisible(ნამდვილი);
}
საჯარო სტატიკური ცნოს მთავარი(სიმებიანი[] args) {
ახალგაზრდული წამახალისებელი GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//შეამოწმეთ თუ ფანჯარა მხარს უჭერს გამტარიანობის
თუ (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSLUCENT)) {
სისტემები.გარეთ.println(“OS მხარს უჭერს გამტარიანობის”);
ახალი PixelTranslucency();
}
} შეტყობინების კლასის Pixel Panel ვრცელდება JPanel {
შეტყობინების Pixel Panel(int pixl) {
სუპერ();
setBackground(ახალი ფერი(0, 0, 255, pixl));
}
}
}
ფორმის Windows:
ახლა ჩვენ განვიხილავთ კიდევ ერთი მნიშვნელოვანი ფუნქცია მხარს უჭერს Java7.The ფორმის ფანჯარა მხარს უჭერს ყველა სახის ფორმებს, რაც არ უნდა იყოს მოთხოვნა შესახებ. ეს ფუნქცია დაგეხმარებათ შექმნათ ნებისმიერი ფორმის, როგორიც წრე, სამკუთხედის, პოლიგონის ან რაიმე კომპლექსური ფორმის. SetShape მეთოდით ფანჯრის კლასი არის შესაძლებელი შექმნის ქონება. თუმცა ისევ და ისევ ჩვენ უნდა გვახსოვდეს, რომ მთელ ეკრანზე გამოტანა არ უნდა მიეცეთ და ოპერაციული სისტემა მხარს უჭერს გამტარიანობის.
მაგალითი გვიჩვენებს გამოყენების ფორმის ფანჯარა.
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);
//უცნობია ზოგადი გეზი თვისებები
GeneralPath gpath = ახალი GeneralPath();
gpath.append(პოლიგონის, ნამდვილი);
gpath.append(newCircle, ნამდვილი);
//მითითებული გეზი
setShape(gpath);
//უცნობია ყუთი განლაგება
getContentPane().setLayout(ახალი BoxLayout(getContentPane(), BoxLayout.X_AXIS));
დავამატებთ(ყუთი.createHorizontalGlue());
//შექმენით იარლიყი და მომართვა
JLabel newlabel = ახალი JLabel(“ჯავის ფორმის ფანჯარა”);
newlabel.setForeground(ფერი.თეთრი);
დავამატებთ(newlabel);
დავამატებთ(ყუთი.createHorizontalGlue());
//მითითებული შინაარსი pane ფონის ფერი
getContentPane().setBackground(ფერი.ცისფერი);
//უცნობია მდებარეობა
setLocationRelativeTo(ნულოვანი);
setVisible(ნამდვილი);
}
საჯარო სტატიკური ცნოს მთავარი(სიმებიანი[] args) {
ახალგაზრდული წამახალისებელი GraphicsEnvironment = GraphicsEnvironment.getLocalGraphicsEnvironment();
//შემოწმება OS მხარდაჭერა ამ ქონებაზე
თუ (genv.getDefaultScreenDevice().isWindowTranslucencySupported(GraphicsDevice.WindowTranslucency.PERPIXEL_TRANSPARENT)) {
სისტემები.გარეთ.println(“OS მხარს უჭერს გამტარიანობის”);
ახალი JavaShapedWindow();
}
}
}
ჩვენ შეგვიძლია ასევე ხორციელდება კომბინაცია ორი ფუნქციები, როგორიცაა გამტარიანობის და ფორმის ფანჯარა. განხორციელების, მოვუწოდებთ setOpacity მეთოდი თქვენი ჩარჩო. შედეგი ფანჯარა ცარიელია კომბინირებული ეფექტი. მაგრამ ჩვენ უნდა გვახსოვდეს, ძირითადი ოპერაციული სისტემის მხარი უნდა pixel დონეზე გამტარიანობის და pixel დონის გამჭვირვალობის.
დასკვნა:
ამ სტატიაში ჩვენ არ დაფარული ახალი ფუნქციების java7.The გამტარიანობის და ფორმის ფანჯარა თვისებები მართლაც ძალიან საინტერესო და მიიღოს java UI კომპონენტების უფრო მოქნილი. თუმცა, ამავე დროს, ჩვენ უნდა გვახსოვდეს, რომ ფუძემდებლური ოპერაციული სისტემა უნდა შეუწყოს ყველა ამ თვისებების. წინააღმდეგ შემთხვევაში ეფექტი არ იქნება ხილული. ასე რომ განაცხადის თავად ჩვენ შეამოწმოს OS მხარდაჭერა და შემდგომში ეფექტი. უკანასკნელი თვისება java საშუალებას დეველოპერებს შექმნან სხვადასხვა სახის გავლენას UI მხარე. როგორც ვიცით, რომ სახეს და ვგრძნობთ არის მნიშვნელოვანი ასპექტი ნებისმიერი UI დაფუძნებული განაცხადის. ასე რომ, პროგრამისტების არის აღჭურვილი იარაღები, რათა UI უფრო სასიამოვნო და მიმზიდველი.
