🤕 👩🏿‍🚀 👨‍❤️‍👨 JavaFX और एनिमेशनटाइमर 🌆 🐰 🕺🏻

जावाएफएक्स एप्लिकेशन में एक दिलचस्प वर्ग का उपयोग करने का एक विकल्प एक लंबी प्रक्रिया के दौरान एक खिड़की को "ठंड" से रोकना है। उसी समय जावाएफएक्स में दृश्यों को प्रस्तुत करने की सुविधाओं के बारे में थोड़ा सा।

मान लीजिए कि एक लंबी प्रक्रिया के प्रदर्शन के साथ एक डेस्कटॉप जावा एप्लिकेशन को कॉन्फ़िगर करने की इच्छा (और / या आवश्यकता) है। खैर, आप कभी नहीं जानते हैं, गणना का एक लंबा चक्र है, और प्रत्येक पुनरावृत्ति का परिणाम देखने की इच्छा, कम से कम संक्षेप में। सुनिश्चित करें कि प्रक्रिया सही दिशा में जा रही है, शायद जो हिस्टोग्राम बनाने के लिए।

मान लीजिए कि इंटरफ़ेस को JavaFX में करने का निर्णय लिया गया है। कुछ इस तरह:

Main.java फ़ाइल

package romeogolf.example1; import java.util.ArrayList; import javafx.animation.AnimationTimer; import javafx.application.Application; import javafx.event.ActionEvent; import javafx.event.EventHandler; import javafx.geometry.Pos; import javafx.scene.Scene; import javafx.scene.control.Button; import javafx.scene.control.Label; import javafx.scene.layout.HBox; import javafx.scene.layout.VBox; import javafx.scene.text.Font; import javafx.stage.Stage; public class Main extends Application { //   ArrayList<Label> aLabels = new ArrayList<Label>(); //   final private int digitCount = 5; //   + 1 //   final private int maxCount = 12345; public static void main(String[] args) { launch(args); } @Override public void start(Stage primaryStage) { primaryStage.setTitle("Example"); VBox vbox = new VBox(); vbox.setAlignment(Pos.CENTER); vbox.setSpacing(20); HBox hbox = new HBox(); hbox.setAlignment(Pos.CENTER); hbox.setSpacing(20); for(int i = 0; i <= digitCount; i++){ aLabels.add(new Label("X")); aLabels.get(i).setFont(new Font("Arial", 30)); aLabels.get(i).setStyle("-fx-padding: 5;" + "-fx-border-color: rgb(49, 89, 23);" + "-fx-border-radius: 5;"); hbox.getChildren().add(aLabels.get(i)); } // ,   Button button = new Button("Start"); button.setOnAction(new EventHandler<ActionEvent>() { @Override public void handle(ActionEvent e) { longProcess(); } }); vbox.getChildren().add(hbox); vbox.getChildren().add(button); primaryStage.setScene(new Scene(vbox, 55 * (digitCount + 1), 100)); primaryStage.show(); } //    private void longProcess(){ //  } }

आपको एक विंडो मिलती है जो अभी भी कुछ नहीं कर सकती है परीक्षण के उद्देश्यों के लिए, मैं वहां काउंटर चर की वृद्धि के रूप में बेतहाशा जटिल गणनाओं को जोड़ूंगा। लॉन्गप्रोसेस विधि फिर इस तरह दिखेगी:

  private void longProcess(){ int digit; for(int i = 0; i <= this.maxCount; i++){ for(int j = 0; j <= digitCount; j++){ digit = (int) (i % (Math.pow(10.0, (double)(j + 1)))); digit = (int) (digit / (Math.pow(10.0, (double)j))); this.aLabels.get(digitCount - j).setText(Integer.toString(digit)); } } }

यहाँ, एक निश्चित संख्या i को अपूर्ण रूप से संख्याओं में क्रमबद्ध किया जाता है और परिचित में प्रदर्शित किया जाता है। एक पागल प्रोग्रामिंग प्रतिभा के इस निर्माण को चलाएं और एक बटन दबाएं। हमें परिणाम बहुत जल्दी, लगभग तुरंत मिल जाएगा:

बहुत खुश है कि इतनी जल्दी। लेकिन समस्या यह है कि समस्या यह नहीं है। लक्ष्य पूरी प्रक्रिया को देखना था, भले ही धीरे-धीरे। किसी भी तरह से लूप के प्रत्येक मार्ग को धीमा करना अच्छा होगा और परिणाम प्रदर्शित करने के लिए कमांड दें ... स्विंग में कुछ (जैसे पुनरावृत्ति), या कुछ ताज़ा करें, अपडेट करें, शायद डॉल्फिक प्रशंसा ।

प्रदान नहीं किया गया। स्विंग में, जब आप रिड्रा कहते हैं, तो इसे तुरंत लागू किया जाता है। जावाएफ़एक्स में, रिड्रॉव अनुरोध दृश्य ग्राफ में परिलक्षित होता है, और जब पल्स टिक जाता है, तो दृश्य को फिर से परिभाषित किया जाता है। पल्स एक घटना है जो दृश्य ग्राफ को बताती है कि यह आकर्षित करने का समय है। यदि एनीमेशन चल रहा है, और यदि आवश्यक हो, तो दृश्य ग्राफ़ में परिवर्तन होने पर यह 60 एफपीएस से अधिक नहीं टिकता है। यह तथाकथित रिटायर्ड मोड है, जिसे अक्सर "एब्सट्रैक्शन मोड" के रूप में अनुवादित किया जाता है, जिसका अर्थ है कि यह दृष्टिकोण तत्काल मोड - डायरेक्ट मोड के विपरीत, एब्सट्रैक्शन के स्तर को बढ़ाता है।

रिटेंस्ड मोड बनाम इमीडिएट मोड आलेख Direct2D और WPF का उपयोग करते हुए दृष्टिकोणों के बीच अंतर को एक उदाहरण के रूप में बताता है। मैं अंतिम पैराग्राफ का अनुवाद करूंगा:

रिटायर्ड मोड एपीआई का उपयोग करना आसान है क्योंकि यह एपीआई आपके लिए अधिक है: आरंभीकरण, रखरखाव, सफाई। लेकिन दूसरी तरफ, यह दृष्टिकोण अक्सर कम लचीला होता है, क्योंकि यह एपीआई अपने स्वयं के दृश्य मॉडल को लागू करता है। इसके अलावा, रिटायर्ड मोड एपीआई ने मेमोरी आवश्यकताओं को बढ़ाया हो सकता है, क्योंकि यह एक सामान्य-उद्देश्य दृश्य मॉडल प्रदान करने के लिए आवश्यक है। तत्काल मोड एपीआई का उपयोग करके आप लक्षित अनुकूलन कर सकते हैं।

क्या करें? आइये इसे इस तरह आजमाते हैं। हम लूप वेरिएबल से काउंटर निकालते हैं, इसे एक क्लास फील्ड बनाते हैं (उदाहरण के लिए, नई विधि से ठीक पहले):

  private int counter = 0;

आइए नई विधि को थोड़ा अलग करें (आप पुराने को बदल सकते हैं, लेकिन यदि आप इसे छोड़ देते हैं, तो पुराने और नए विकल्पों के बीच स्विच करना आसान होगा)। चलो बाहरी लूप को पूरी तरह से हटा दें:

  private void longProcess2(){ int digit; //     for(int j = 0; j <= digitCount; j++){ digit = (int) (counter % (Math.pow(10.0, (double)(j + 1)))); digit = (int) (digit / (Math.pow(10.0, (double)j))); this.aLabels.get(digitCount - j).setText(Integer.toString(digit)); } // ******* //  ,  : counter++; // ******* }

मुख्य वर्ग के अंत में निम्नलिखित कोड जोड़ें:

  protected AnimationTimer at = new AnimationTimer(){ @Override public void handle(long now) { longProcess2(); } };

इसके बजाय बटन को संसाधित करने की प्रक्रिया शुरू करना

  longProcess();

रखना

  at.start();

और एक समय पर रोक के लिए, हम longProcess2 () विधि को खुद सम्मिलित करेंगे, जो प्रक्रिया को लागू करता है, ऐसी लाइनें (बहुत शुरुआत में):

  if(counter > maxCount){ at.stop(); return; }

अब इस सब की आवश्यकता क्यों थी। परिणाम एनिमेशनटाइमर वर्ग का एक उदाहरण है। हर बार एप्लिकेशन विंडो को रिड्रॉर्न करने पर इसका हैंडल () विधि कहा जाता है। यही है, longProcess2 () कॉल करके, हमने संख्याओं की परिचितता को फिर से बनाने का आदेश दिया। दृश्य को फिर से परिभाषित करने की आवश्यकता है। हैंडल () कहा जाता है, और फिर से longProcess2 () शुरू होता है। और इसलिए जब तक at.stop () के लिए स्टॉप कंडीशन longProcess2 () मेथड में ही उठती है।

अब, जब आप "विंडो" में एक बटन दबाते हैं, तो संख्या फ्लैश हो जाएगी। डिस्चार्ज की कीमत के आधार पर विभिन्न गति पर झिलमिलाहट।

यदि, उदाहरण के लिए, डिजिटाउंट को 7 तक बढ़ाएं, और अधिकतम 98765432 तक, टाइमर के बिना और टाइमर के साथ विकल्पों के बीच का अंतर काफी अधिक ध्यान देने योग्य हो जाएगा। प्रारंभिक संस्करण में, आपको प्रक्रिया पूरी होने तक परिचितों में क्रॉस पर विचार करना होगा, और यहां तक कि पारंपरिक तरीके से खिड़की को बंद करना होगा (ऊपरी दाएं कोने में "क्रॉस") काम नहीं करेगा। टाइमर के साथ संस्करण में, प्रक्रिया को आश्चर्यजनक रूप से प्रदर्शित किया जाता है, खिड़की को शीर्षक से खींचा जा सकता है और किसी भी समय बंद किया जा सकता है, लेकिन प्रक्रिया स्वयं अविश्वसनीय रूप से फैली हुई है। यहां सवाल यह है कि क्या अधिक की आवश्यकता है - गति या प्रदर्शन।

वास्तव में, व्यक्तिगत पुनरावृत्तियों के प्रदर्शन को छोड़ कर गति को थोड़ा बढ़ाया जा सकता है, और जितना अधिक हम छोड़ेंगे, उतनी तेज़ी से हम समाप्त करेंगे, हालांकि हम कम देखेंगे। ऐसा करने के लिए, आप longProcess2 () में, इसके बजाय, बहुत अंत में, सम्मिलित कर सकते हैं

  counter++;

कुछ ऐसा

  for(int skip = 0; skip < 100000; skip++){ if(counter >= maxCount){ break; } counter++; }

फिर प्रत्येक सौ हज़ारवें पुनरावृत्ति का परिणाम प्रदर्शित किया जाएगा, और स्टॉप स्थिति के लिए धन्यवाद, अंतिम परिणाम अंत में प्रदर्शित किया जाएगा। सच है, इस प्रक्रिया में, निचले अंक मूर्खतापूर्ण शून्य होंगे, लेकिन स्पष्टता के लिए, उन्हें किसी तरह धुंधला भी किया जा सकता है। हालांकि, ये सीटी के क्षेत्र से विवरण हैं, उदाहरण के लिए, इसका कोई संबंध नहीं है।

प्रत्येक टाइमर के शुरू होने से पहले कोई भी शून्य को जोड़ सकता है, दूसरे टाइमर की असमानता तब शुरू होती है जब यह पहले से ही काम कर रहा है (और यह संभव है!) और कुछ अन्य उपयोगी सीटी, लेकिन यह एक उदाहरण प्रदर्शित करने के लिए एक ओवरकिल है।

एनिमेशनटाइमर के बारे में थोड़ा सा: किसी ने माइक अपने ब्लॉग में JavaFX एनिमेशनटीमर का उपयोग करते हुए उसके बारे में एक बहुत अच्छा लेख लिखा था।

माइक को लगता है कि इस वर्ग को इस तरह बुलाना अच्छा नहीं था। आखिरकार, इसका उपयोग न केवल एनीमेशन के लिए किया जा सकता है: एफपीएस-दर को मापने के लिए, टकराव का पता लगाने के लिए, मॉडलिंग के चरणों की गिनती के लिए, खेल में मुख्य लूप के रूप में, आदि। व्यक्तिगत रूप से, वह अक्सर एनिमेशनटीमर के अनुप्रयोगों को देखता है, जो एनीमेशन से संबंधित नहीं हैं। । एनिमेशनटाइमर एक बेहद सरल, लेकिन बहुत लचीला और उपयोगी सुविधा देता है। टाइमर आपको उस विधि को निर्धारित करने की अनुमति देता है जिसे प्रत्येक फ्रेम के लिए बुलाया जाएगा। यह विधि क्या करेगी न केवल असीमित, लेकिन, जैसा कि ऊपर उल्लेख किया गया है, एनीमेशन के साथ कुछ भी नहीं हो सकता है। केवल आवश्यकता यह है कि यह विधि पर्याप्त रूप से तेज होनी चाहिए, अन्यथा यह सिस्टम में बस एक अड़चन बन जाएगी।

बेशक, ऐसी समस्या को हल करने का एकमात्र तरीका नहीं है, लेकिन मुझे यह टाइमर पसंद आया - सरल और काफी सुविधाजनक। जो उससे परिचित नहीं था - कृपया प्यार और अनुग्रह करें।

JavaFX और एनिमेशनटाइमर

More articles: