آرٽيڪل
شروع
سکڻ شروع ڪريو
JavaRush /جاوا بلاگ /Random-SD /جاوا FX جو تعارف
Константин
سطح

جاوا FX جو تعارف

گروپ ۾ شايع ٿيل
هڪ ڏينهن مون کي خيال آيو ته پنهنجي ضرورتن لاءِ هڪ ننڍڙي ڊيسڪ ٽاپ ايپليڪيشن لکان- ڪا شيءِ جهڙوڪ هڪ ننڍي ڊڪشنري جيئن غير ملڪي لفظن کي سکڻ لاءِ- ۽ مون پنهنجي دماغ کي ريڪ ڪرڻ شروع ڪيو، مان اهو ڪيئن ڪري سگهان ٿو؟ قدرتي طور، پهرين شيء جيڪا منهنجي ذهن ۾ آئي سونگ هئي. هرڪو شايد سوئنگ بابت ٻڌو آهي . هي هڪ لائبريري آهي صارف، گرافڪ انٽرفيس ٺاهڻ لاءِ. انهي حقيقت جي ڪري ته اسان جي پياري Oracle اڃا تائين مڪمل طور تي سوئنگ کي نه ڇڏيو آهي، اهو غير معمولي نه سمجهيو ويندو آهي، ۽ ايپليڪيشنون اڃا تائين ان تي هلن ٿيون. بهرحال، اهو هاڻي جديد نه رهيو آهي سوئنگ طرفان، ۽ اوراڪل جي ماڻهن اسان کي ذائقو ڏنو آهي ته جاوا ايف ايڪس جو مستقبل ڇا آهي. ۽ حقيقت ۾، JavaFX استعمال ڪري ٿو جھول جا حصا بطور سروس فراهم ڪندڙ)

JavaFX ڇا آهي؟

JavaFX بنيادي طور جاوا لاءِ هڪ GUI ٽول ڪٽ آهي. هتي هڪ ننڍڙو تڪرار ٿيندو، ۽ اسان کي ياد ڪنداسين ته GUI ڇا آهي : گرافڪ يوزر انٽرفيس - هڪ گرافڪ يوزر انٽرفيس يوزر انٽرفيس جو هڪ قسم آهي جنهن ۾ سڀئي عنصر (بٽن، مينيو، آئڪن، فهرستون) صارف کي پيش ڪيا ويا آهن. ڊسپلي تصويرون، گرافڪس جي صورت ۾ ٺهيل آهن. ڪمانڊ لائن انٽرفيس جي برعڪس، هڪ GUI ۾ صارف کي ان پٽ ڊوائيسز استعمال ڪندي نظر ايندڙ شين تائين بي ترتيب رسائي آهي. گهڻو ڪري، انٽرفيس عناصر استعارن جي صورت ۾ لاڳو ڪيا ويا آهن ۽ انهن جي خاصيتن ۽ مقصد کي صارف جي سمجھڻ جي سهولت لاء ڏيکاري ٿو. JavaFX جو مقصد جاوا ۾ رانديون ۽ ڊيسڪ ٽاپ ايپليڪيشنون ٺاهڻ آهي. حقيقت ۾، اهو جاوا لاء تجويز ڪيل نئين GUI اوزار جي ڪري سوئنگ کي تبديل ڪندو. انهي سان گڏ، اهو اسان کي GUI ترتيب واري فائلن (XML) کي انداز ڪرڻ جي اجازت ڏئي ٿو ۽ سي ايس ايس استعمال ڪندي انهن کي وڌيڪ خوبصورت بڻائي ٿو، جيڪو اسان ويب ايپليڪيشنن ۾ استعمال ڪيو ويندو آهي. JavaFX اضافي طور تي ضم ٿيل 3D گرافڪس سان گڏو گڏ آڊيو، وڊيو ۽ ايمبيڊڊ نيٽ ورڪنگ ايپليڪيشنن کي هڪ واحد GUI ٽول ڪٽ ۾ سنڀاليندو آهي... اهو سکڻ آسان آهي ۽ بهتر نموني سان. اهو ڪيترن ئي آپريٽنگ سسٽم کي سپورٽ ڪري ٿو، انهي سان گڏ ونڊوز، يونڪس سسٽم ۽ ميڪ او ايس. جاوا FX جو تعارف - 3

JavaFX خاصيتون:

  • JavaFX شروعاتي طور تي گرافيڪل انٽرفيس حصن جي ھڪڙي وڏي سيٽ سان اچي ٿو، جھڙوڪ سڀ قسم جا بٽڻ، ٽيڪسٽ فيلڊ، ٽيبل، وڻ، مينيو، چارٽ، وغيره، جنھن جي نتيجي ۾ اسان جو گھڻو وقت بچائيندو.
  • JavaFX اڪثر ڪري CSS اسلوب استعمال ڪندو آهي، ۽ اسان هڪ خاص FXML فارميٽ استعمال ڪري سگهنداسون GUI ٺاهڻ لاءِ، بجاءِ ان کي Java ڪوڊ ۾ ڪرڻ جي. اهو آسان بڻائي ٿو جلدي هڪ GUI ترتيب ڏيڻ يا ظاهري يا ترتيب کي تبديل ڪرڻ بغير جاوا ڪوڊ سان گهڻي وقت تائين راند ڪرڻ جي.
  • JavaFX وٽ استعمال لاءِ تيار ٿيل ڊاگرام حصا آهن ان ڪري اسان کي انهن کي شروع کان لکڻ جي ضرورت ناهي جڏهن توهان کي بنيادي ڊائريگرام جي ضرورت هجي.
  • JavaFX اضافي طور تي 3D گرافڪس سپورٽ سان گڏ اچي ٿو، جيڪو گهڻو ڪري ڪارائتو آهي جيڪڏهن اسان ڪنهن قسم جي راند يا ساڳي ايپليڪيشن کي ترقي ڪري رهيا آهيون.
اچو ته اسان جي ونڊو جي مکيه حصن تي ٿورو نظر رکون:
  • اسٽيج بنيادي طور تي هڪ ڀرسان ونڊو آهي جيڪو هڪ شروعاتي ڪينواس طور ڪم ڪري ٿو ۽ باقي اجزاء تي مشتمل آهي. ايپليڪيشن جا ڪيترائي مرحلا ٿي سگهن ٿا، پر ڪنهن به صورت ۾ هڪ اهڙو حصو هجڻ گهرجي. لازمي طور تي، اسٽيج مکيه ڪنٽينر ۽ داخلا پوائنٽ آهي.
  • منظر - اسٽيج جي مواد کي ڏيکاري ٿو (جهڙوڪ هڪ نينگنگ گڏي). هر اسٽيج ڪيترن ئي حصن تي مشتمل ٿي سگھي ٿو - منظر، جيڪو پاڻ ۾ تبديل ڪري سگھجي ٿو. اندروني طور تي، اهو هڪ اعتراض گراف جي ذريعي لاڳو ٿئي ٿو جنهن کي منظر گراف سڏيو ويندو آهي (جتي هر عنصر هڪ نوڊ آهي، جنهن کي نوڊ پڻ سڏيو ويندو آهي ).
  • نوڊس ڪنٽرول آھن، جھڙوڪ ليبل بٽڻ، يا حتي لي آئوٽ، جيڪي انھن جي اندر گھڻا گھربل اجزاء رکي سگھن ٿا. هر منظر ۾ هڪ نسٽڊ نوڊ ٿي سگهي ٿو، پر اهو ڪيترن ئي حصن سان هڪ ترتيب ٿي سگهي ٿو. Nesting گھڻن سطحن تي ٿي سگھي ٿو، ٻين ترتيبن ۽ باقاعده اجزاء تي مشتمل ترتيب سان. هر اهڙي نوڊ جو پنهنجو سڃاڻپ ڪندڙ، انداز، اثر، رياست، ۽ واقعا سنڀاليندڙ آهن.
جاوا FX جو تعارف - 4 سو اچو ته ٿورو اڳتي وڃون ڪوڊ ڏانھن. جيئن ته مان جاوا 8 استعمال ڪريان ٿو، مون کي ڪنهن به انحصار کي ڪڍڻ جي ضرورت ناهي، ڇو ته JavaFx ڊفالٽ طور JDK ۾ آهي (جيئن ته جاوا 9.10 ۾)، پر جيڪڏهن اسان وٽ Java 11+ آهي، ته پوء اسان کي maven repository ڏانهن وڃڻو پوندو ۽ ان کي اتان جي انحصار مان ڪڍو.

JavaFX: استعمال جا مثال

اسان ھڪڙي طريقي سان ھڪڙي باقاعده ڪلاس ٺاھيو main(داخلي پوائنٽ): 
public class AppFX extends Application {

    public static void main(String[] args) {
        Application.launch();
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
pimarySatge.show();
    }
}
هتي اسان جو طبقو ورثي ۾ آهي javafx.application.Application(جيڪو اسان وٽ بگاگا باڪس مان آهي). بنيادي طور تي اسان کي سڏين ٿا جامد ايپليڪيشن جو طريقو launch()اسان جي ونڊو شروع ڪرڻ لاء. انهي سان گڏ، اسان جو خيال شڪايت ڪندو ته اسان ايپليڪيشن جو طريقو لاڳو نه ڪيو آهي، startجيڪو اسان آخرڪار ڪندا آهيون. ڇا لاءِ آهي؟ ۽ ملڪيت کي منظم ڪرڻ جي قابل ٿيڻ لاء (اسان جي ونڊو جي ڪارڪردگي). هن کي ڪرڻ لاء، اسان هڪ ايندڙ دليل استعمال ڪندا آهيون primaryStageجنهن تي اسان هڪ طريقو سڏين ٿا showته جيئن اسان ونڊو کي شروع ڪيو پيو وڃي main. اچو ته اسان جو طريقو ٿورو ڀريون start: 
public void start(Stage primaryStage) throws Exception {
    primaryStage.setTitle("Dogs application");
    primaryStage.setWidth(500);
    primaryStage.setHeight(400);

    InputStream iconStream =
    getClass().getResourceAsStream("/images/someImage.png");
    Image image = new Image(iconStream);
    primaryStage.getIcons().add(image);

    Button button = new Button("WOF WOF ???'");

    button.setOnAction(e -< {
      Alert alert = new Alert(Alert.AlertType.INFORMATION, "WOF WOF WOF!!!");
        alert.showAndWait();
    });
    Scene primaryScene = new Scene(button);
    primaryStage.setScene(primaryScene);

    primaryStage.show();
}
Java-университет
پوء اسان هتي ڇا ٿا ڏسو؟ اچو ته ان جي ذريعي لڪير ذريعي وڃون: 2 - ونڊو جو نالو پاڻ کي مقرر ڪريو (اسٽيج) 3.4 - ان جا طول و عرض مقرر ڪريو 6.7 - فائل کي پڙهڻ واري وهڪرو جو رستو مقرر ڪريو (آئڪن) جاوا FX جو تعارف - 58 - فائل کي تصويري اعتراض جي طور تي ٺاهيو، جيڪو ڪنسٽرڪٽر 9 ۾ پاس ڪيل اسٽريم ذريعي حقيقي فائل سان ڳنڍيو ويو آهي - ونڊو 11 جي مٿين پينل ۾ هڪ آئڪن سيٽ ڪريو - هڪ بٽڻ آئوٽ ٺاهيو 13-16 - ردعمل سيٽ ڪريو جڏهن بٽڻ کي دٻايو ويندو آهي 17 - هڪ منظر ٺاهيو جتي اسان پنهنجو بٽڻ 18 رکون ٿا - منظر کي اسان جي عام ونڊو 20 تي رکون ٿا - ونڊو لاءِ ويزيبلٽي پرچم سيٽ ڪريو ۽ نتيجي ۾ اسان کي هڪ ننڍڙي ونڊو ملي ٿي ته اسان جي پسنديده پيسلن کي ڀليڪار ڪرڻ لاءِ: جاوا FX جو تعارف - 6هر شيءِ سوئنگ کان گهڻو آسان نظر اچي ٿي، ڇا اهو ناهي؟ پر اهو اڃا ختم نه ٿيو آهي. ايپليڪيشن کي ڊسپلي ڪرڻ لاءِ سمورو ڪوڊ لکڻ سٺو نه آهي؛ توهان کي ان کي ڪنهن نه ڪنهن طرح ورهائڻو پوندو ته جيئن ان کي وڌيڪ سمجھ ۾ اچي (گرافڪل جز هڪ ٽوڪري ۾، منطق ٻئي ۾). ۽ هتي xml تصوير ۾ اچي ٿو ... اي خدا، xml؟ بلڪل. خاص طور تي، اسان JavaFX - FXML لاءِ ان جو مخصوص عمل استعمال ڪريون ٿا، جنهن ۾ اسان ايپليڪيشن جا گرافڪ حصا ۽ انهن جي ملڪيتن (سڀ قسم جي سائيز وغيره) جي وضاحت ڪريون ٿا، ۽ پوءِ ان کي ڪنٽرولر سان ڳنڍيون ٿا، جيڪو منطق کي منظم ڪرڻ ۾ مدد ڪري ٿو. اچو ته هن xml جو هڪ مثال ڏسو: 
<?xml version="1.0" encoding="UTF-8"?>
<?language javascript?>

<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.layout.VBox?>

<VBox xmlns="http://javafx.com/javafx"  xmlns:fx="http://javafx.com/fxml"
   id="Dogs application" prefHeight="200" prefWidth="300" alignment="center">

  <Label text="Wow wow?"/>

  <Button fx:id="mainButton" text="Greeting" onAction="buttonClicked()"/>

    <fx:script>
       function buttonClicked() {
            mainButton.setText("Wow wow wow!!!")
       }
    </fx:script>
</VBox>
2 - اسڪرپٽنگ ٻولي جيڪا اسان استعمال ڪريون ٿا 4-6 - درآمد ٿيل ڊيٽا 8-9 Vbox - هڪ ڪنٽينر جيڪو هڪ لڪير تي ذيلي اجزاء رکي ٿو. 11 - ڪجھ متن ڏيکاريو 13 - ھڪڙو بٽڻ، جڏھن ڪلڪ ڪيو، اسان اسڪرپٽ ۾ بيان ڪيل طريقو استعمال ڪندا آھيون 15-18 لائنن تي. ھن طريقي ۾ xml فائل کي ڪال ڪرڻ لاء ڪوڊ هجڻ گھرجي، startپر ھاڻي اھو ايترو ضروري نه آھي، ۽ اسان ان کي ختم ڪندو (هيٺ ڏنل فائل کي ڇڪڻ جو هڪ مثال هوندو). تنهن ڪري، xml، يقينا، سٺو (پر تمام سٺو ناهي)، انهن کي دستي طور تي لکڻ تمام پريشان آهي، ڇا اها آخري صدي ناهي؟ جاوا FX جو تعارف - 7

متعارف ڪرايو JavaFX SceneBuilder

اهو ئي وقت آهي ته (ڊرم رول) راند ۾ اچي ٿو - SceneBuilder JavaFX Scene Builder هڪ اوزار آهي جنهن جي مدد سان اسان پنهنجي ونڊوز کي گرافيڪل انٽرفيس جي صورت ۾ ڊزائين ڪري سگھون ٿا ۽ پوءِ انهن کي محفوظ ڪري سگهون ٿا، ۽ اهو پروگرام، نتيجن جي بنياد تي، ٿيندو. xml فائلون ٺاهيون ته اسان ان کي اسان جي ايپليڪيشن ۾ بهتر ڪنداسين. هن fmxl بلڊر جو انٽرفيس ڪجهه هن طرح نظر اچي ٿو: جاوا FX جو تعارف - 8

هڪ ننڍڙو تڪرار. JavaFX سبق

مان انسٽاليشن جي تفصيل کي ڇڏي ڏيندس، ۽ هن اوزار جو تفصيلي مطالعو پڻ. اهي عنوان آهن جيڪي وڌيڪ ڳولڻ جي قابل آهن. تنهن ڪري، مان اڃا تائين JavaFX سبقن جا ٻه دلچسپ لنڪ ڇڏيندس: هڪ (جاوا ايف ايڪس تي هڪ آن لائن سبق) ۽ ٻه (ٻيو سٺو سبق). اچو ته هڪ ننڍڙي مثال جي ذريعي هلون، جيڪو مون ٺاهيو. آخر ۾ مون کي ڪجهه مليو: جاوا FX جو تعارف - 9
(ڪتن جي رجسٽريشن لاءِ ونڊو وانگر)
جڏهن توهان هڪ ڪتو چونڊيو ۽ حذف ڪريو بٽڻ کي دٻايو، ڪتو اسان جي فهرست مان هٽايو ويندو. جڏهن توهان هڪ چار پيرن وارو دوست چونڊيو ۽ ان جي فيلڊ کي تبديل ڪريو، ۽ ايڊٽ بٽڻ کي دٻائڻ کان پوء، ڪتي جي معلومات اپڊيٽ ٿي ويندي آهي. جڏهن اسان نئون بٽڻ دٻايو ٿا، هڪ ونڊو پاپ اپ ٿئي ٿي هڪ نئين ڪتي جو رڪارڊ ٺاهڻ لاءِ (ان جي نالي سان شروع ڪرڻ لاءِ): جاوا FX جو تعارف - 10پوءِ ڪلڪ ڪريو محفوظ ڪريو ۽ ان جي باقي فيلڊ کي پهرين ونڊو ۾ ڀريو، ۽ پوءِ ايڊٽ بٽڻ تي ڪلڪ ڪريو. بچايو. آواز آسان، صحيح؟ اچو ته ڏسون ته اهو اسان جي جاوا ايپليڪيشن ۾ ڪيئن نظر ايندو. شروع ڪرڻ لاءِ، مان ھتي ڇڏيندس انھن ٻن ونڊوز لاءِ xml layouts جيڪي ٺاھيل آھن SceneBuilder: First (basic): 
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.SplitPane?>
<?import javafx.scene.control.TableColumn?>
<?import javafx.scene.control.TableView?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.ColumnConstraints?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.RowConstraints?>
<AnchorPane prefHeight="300.0" prefWidth="600.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.tutorial.controller.BaseController">
   <children>
      <SplitPane dividerPositions="0.29797979797979796" prefHeight="300.0" prefWidth="600.0" AnchorPane.bottomAnchor="0.0" AnchorPane.leftAnchor="0.0" AnchorPane.rightAnchor="0.0" AnchorPane.topAnchor="0.0">
        <items>
          <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="160.0" prefWidth="100.0">
               <children>
                  <TableView fx:id="dogs" layoutX="-2.0" layoutY="-4.0" prefHeight="307.0" prefWidth="190.0" AnchorPane.bottomAnchor="-5.0" AnchorPane.leftAnchor="-2.0" AnchorPane.rightAnchor="-13.0" AnchorPane.topAnchor="-4.0">
                    <columns>
                      <TableColumn fx:id="nameList" prefWidth="100.33334350585938" text="Nickname" />
                    </columns>
                     <columnResizePolicy>
                        <TableView fx:constant="CONSTRAINED_RESIZE_POLICY" />
                     </columnResizePolicy>
                  </TableView>
               </children>
            </AnchorPane>
          <AnchorPane minHeight="0.0" minWidth="0.0" prefHeight="160.0" prefWidth="100.0">
               <children>
                  <Label layoutX="49.0" layoutY="25.0" text="Person Details" AnchorPane.leftAnchor="5.0" AnchorPane.topAnchor="5.0" />
                  <GridPane accessibleText="erreererer" gridLinesVisible="true" layoutX="5.0" layoutY="31.0" AnchorPane.leftAnchor="5.0" AnchorPane.rightAnchor="5.0" AnchorPane.topAnchor="31.0">
                    <columnConstraints>
                      <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                      <ColumnConstraints hgrow="SOMETIMES" minWidth="10.0" prefWidth="100.0" />
                    </columnConstraints>
                    <rowConstraints>
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                        <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                      <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
                    </rowConstraints>
                     <children>
                        <Label prefHeight="17.0" prefWidth="70.0" text="Nickname" />
                        <Label text="Breed" GridPane.rowIndex="1" />
                        <Label text="Age" GridPane.rowIndex="2" />
                        <Label text="City" GridPane.rowIndex="3" />
                        <Label text="Level of training" GridPane.rowIndex="4" />
                        <TextField fx:id="breed" GridPane.columnIndex="1" GridPane.rowIndex="1" />
                        <TextField fx:id="age" GridPane.columnIndex="1" GridPane.rowIndex="2" />
                        <TextField fx:id="city" GridPane.columnIndex="1" GridPane.rowIndex="3" />
                        <TextField fx:id="levelOfTraining" GridPane.columnIndex="1" GridPane.rowIndex="4" />
                        <TextField fx:id="name" GridPane.columnIndex="1" />
                     </children>
                  </GridPane>
                  <Button layoutX="251.0" layoutY="259.0" mnemonicParsing="false" onAction="#create" text="New" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="230.0" AnchorPane.rightAnchor="130.0" AnchorPane.topAnchor="260.0" />
                  <Button layoutX="316.0" layoutY="262.0" mnemonicParsing="false" onAction="#edit" text="Edit" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="290.0" AnchorPane.rightAnchor="70.0" AnchorPane.topAnchor="260.0" />
                  <Button layoutX="360.0" layoutY="262.0" mnemonicParsing="false" onAction="#delete" text="Delete" AnchorPane.bottomAnchor="10.0" AnchorPane.leftAnchor="350.0" AnchorPane.rightAnchor="10.0" AnchorPane.topAnchor="260.0" />
               </children>
            </AnchorPane>
        </items>
      </SplitPane>
   </children>
</AnchorPane>
ٻيو (نئون ڪتا ٺاهڻ لاء): 
<?xml version="1.0" encoding="UTF-8"?>
<?import javafx.scene.control.Button?>
<?import javafx.scene.control.Label?>
<?import javafx.scene.control.TextField?>
<?import javafx.scene.layout.AnchorPane?>
<?import javafx.scene.layout.ColumnConstraints?>
<?import javafx.scene.layout.GridPane?>
<?import javafx.scene.layout.RowConstraints?>
<?import javafx.scene.text.Font?>
<AnchorPane prefHeight="200.0" prefWidth="300.0" xmlns="http://javafx.com/javafx/8.0.171" xmlns:fx="http://javafx.com/fxml/1" fx:controller="com.tutorial.controller.NewDogController">
   <children>
      <GridPane layoutX="31.0" layoutY="25.0" prefHeight="122.0" prefWidth="412.0">
        <columnConstraints>
          <ColumnConstraints hgrow="SOMETIMES" maxWidth="185.0" minWidth="10.0" prefWidth="149.0" />
          <ColumnConstraints hgrow="SOMETIMES" maxWidth="173.0" minWidth="10.0" prefWidth="146.0" />
        </columnConstraints>
        <rowConstraints>
          <RowConstraints minHeight="10.0" prefHeight="30.0" vgrow="SOMETIMES" />
        </rowConstraints>
         <children>
            <Label prefHeight="48.0" prefWidth="178.0" text="Please, write name:">
               <font>
                  <Font size="20.0" />
               </font>
            </Label>
            <TextField fx:id="nickName" prefHeight="36.0" prefWidth="173.0" GridPane.columnIndex="1" />
         </children>
      </GridPane>
      <Button layoutX="222.0" layoutY="149.0" mnemonicParsing="false" onAction="#ok" prefHeight="37.0" prefWidth="95.0" text="Save" />
      <Button layoutX="325.0" layoutY="149.0" mnemonicParsing="false" onAction="#cansel" prefHeight="37.0" prefWidth="95.0" text="Cansel" />
   </children>
</AnchorPane>
فولڊر جي جوڙجڪ ڇا ڏسڻ ۾ اچي ٿي: جاوا FX جو تعارف - 11جيئن توهان ڏسي سگهو ٿا، اتي ڪجهه خاص ناهي، اتي ڪنٽرولرز آهن جيڪي ڪجهه ونڊوز جي نمائندگي ڪن ٿا، اهڙا ماڊل آهن جيڪي اسان جي ڊيٽا کي نمائندگي ڪن ٿا. اچو ته ڪلاس تي هڪ نظر رکون جيڪو ايپليڪيشن کي لانچ ڪري ٿو (ايپليڪيشن تي عمل درآمد): @Data 
public class AppFX extends Application {

    private Stage primaryStage;
    private AnchorPane rootLayout;
    private ObservableList listDog = FXCollections.observableArrayList();

    public AppFX() {
        listDog.add(new Dog("Fluffy", "Pug", 8, "Odessa", 2));
        listDog.add(new Dog("Archie", "Poodle", 3, "Lviv", 6));
        listDog.add(new Dog("Willie", "Bulldog", 5, "Kiev", 4));
        listDog.add(new Dog("Hector", "Shepherd", 9, "Minsk", 6));
        listDog.add(new Dog("Duncan", "Dachshund", 1, "Hogwarts", 9));
    }
هتي اسان هڪ تعمير ڪندڙ ڏسون ٿا جيڪو اسان جي شروعاتي ڊيٽا کي ڀريندو (جنهن کي اسين هڪ خاص شيٽ ۾ ذخيرو ڪندا آهيون - ObservableList). 
public static void main(String[] args) {
        Application.launch();
    }

    @Override
    public void start(Stage primaryStage) throws Exception {
        this.primaryStage = primaryStage;
        this.primaryStage.setTitle("Dogs application");
        showBaseWindow();
}
ڪجھ به خاص ناهي - main۽ عمل درآمد start()جيڪو ايپليڪيشن کي شروع ڪري ٿو: 
public void showBaseWindow() {
        try {
            FXMLLoader loader = new FXMLLoader();
            loader.setLocation(AppFX.class.getResource("/maket/rootWindow.fxml"));
            rootLayout = loader.load();
            Scene scene = new Scene(rootLayout);
            primaryStage.setScene(scene);
            InputStream iconStream = getClass().getResourceAsStream("/icons/someImage.png");
            Image image = new Image(iconStream);
            primaryStage.getIcons().add(image);
            BaseController controller = loader.getController();
            controller.setAppFX(this);
            primaryStage.show();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
تنهن ڪري، هتي اسان اهو طريقو ڏسون ٿا جيڪو اسان اصل ۾ لانچ ڪيو آهي start()، يعني، جيڪو اسان جي بنيادي ونڊو جي سيٽنگن کي ترتيب ڏئي ٿو. جيئن ته وسيلن ۾ xml ترتيب ۾: ان کي هڪ آئڪن ڏيڻ، ان کي هڪ مخصوص ڪنٽرولر سان ڳنڍڻ، ۽ ڪنٽرولر کي thisڪلاس ڏانهن هڪ لنڪ ڏيڻ) 
public void showCreateWindow(Dog dog) {
        try {
            FXMLLoader loader = new FXMLLoader();
            loader.setLocation(AppFX.class.getResource("/maket/new.fxml"));
            AnchorPane page = loader.load();
            Stage dialogStage = new Stage();
            dialogStage.setTitle("Wow Wow Wow");
            dialogStage.initModality(Modality.WINDOW_MODAL);
            dialogStage.initOwner(primaryStage);
            dialogStage.setScene(new Scene(page));
            CreateController controller = loader.getController();
            controller.setDialogStage(dialogStage);
            controller.setDog(dog);
            dialogStage.showAndWait();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
هتي اسان اهو طريقو ڏسون ٿا جيڪو ٻئي ونڊو جي ظاهر ٿيڻ لاء ذميوار آهي - هڪ نئين رڪارڊ ٺاهڻ لاء ونڊو (نئين ڪتي جو نالو). اسان ڪنٽرولر، xml ترتيب، اسٽيج، وغيره پڻ مقرر ڪيو آهي... ايندڙ ڪلاس جنهن تي اسين غور ڪنداسين هڪ نمونو هوندو جيڪو اسان جي ڪتي جي نمائندگي ڪندو (ان بابت ڄاڻ): @Data 
public class Dog {

    private StringProperty name;
    private StringProperty breed;
    private IntegerProperty age;
    private StringProperty city;
    private IntegerProperty levelOfTraining;

    public Dog(String name, String breed, int age, String city, int levelOfTraining) {
        this.name = new SimpleStringProperty(name);
        this.breed = new SimpleStringProperty(breed);
        this.age = new SimpleIntegerProperty(age);
        this.city = new SimpleStringProperty(city);
        this.levelOfTraining = new SimpleIntegerProperty(levelOfTraining);
    }

    public Dog() {
        name = new SimpleStringProperty();
        breed = null;
        age = null;
        city = null;
        levelOfTraining = null;
    }
}
هتي اسان کي ٻه تعمير ڪندڙ نظر اچن ٿا، هڪ تقريبن سڀني دليلن سان باقاعده آهي (تقريبا، ڇاڪاڻ ته اسان عام قسم جا خاص FX لفافي استعمال ڪندا آهيون) ۽ هڪ تعمير ڪندڙ بغير دليلن سان: اسان ان کي استعمال ڪندا آهيون جڏهن هڪ نئون ڪتو ٺاهي، جنهن ۾ پهرين ۾ صرف هڪ آهي. نالو. بنيادي ونڊو لاء ڪنٽرولر: @Data 
public class BaseController {

    @FXML
    private TableView dogs;
    @FXML
    private TableColumn nameList;
    @FXML
    private TextField name;
    @FXML
    private TextField breed;
    @FXML
    private TextField age;
    @FXML
    private TextField city;
    @FXML
    private TextField levelOfTraining;
    private AppFX appFX;
هتي اسان ڏسون ٿا اسان جا اعتراض فيلڊ، پر ٽيڪسٽ فيلڊ فارميٽ ۾. هي هڪ فارميٽ آهي جيڪو نمائندگي ڪري ٿو ٽيڪسٽ ان پٽ فيلڊ. @FXML هڪ تشريح آهي جيڪا جاوا ڪوڊ ۽ اسان جي ترتيب جي لاڳاپيل اعتراض کي ڳنڍڻ لاءِ ٺهيل آهي (بٽن، فيلڊ، يا ٻيو ڪجهه). 
@FXML
private void initialize() {
    nameList.setCellValueFactory(
            cellData -> cellData.getValue().getName());
    dogs.getSelectionModel().selectedItemProperty().addListener(
            (observable, oldValue, newValue) -> showDogsInformation(newValue));
}
هتي اسان ڪتي جا نالا ڏيکارڻ لاءِ هڪ طريقو ڏسون ٿا، فهرست ۾ ساڄي پاسي (ان جو @FXML تشريح JavaFX TableView layout جزو سان جڙيل آهي). 
public void setAppFX(AppFX appFX) {
    this.appFX = appFX;
    dogs.setItems(appFX.getListDog());
}

private void showDogsInformation(Dog dog) {
    if (dog != null) {
        name.setText(dog.getName() != null ? dog.getName().getValue() : null);
        breed.setText(dog.getBreed() != null ? dog.getBreed().getValue() : null);
        age.setText(dog.getAge() != null ? String.valueOf(dog.getAge().get()) : null);
        city.setText(dog.getCity() != null ? dog.getCity().getValue() : null);
        levelOfTraining.setText(dog.getLevelOfTraining() != null ? String.valueOf(dog.getLevelOfTraining().get()) : null);
    } else {
        name.setText("");
        breed.setText("");
        age.setText("");
        city.setText("");
        levelOfTraining.setText("");
    }
}
پهرين طريقي ۾ اسان ڏسون ٿا هڪ اندروني حوالو سيٽنگ ڪلاس لاءِ جيڪو ايپليڪيشن کي لاڳو ڪري ٿو (جيئن اسان ان جي طريقي کي ٻئي ونڊو کي ڪال ڪرڻ لاءِ سڏي سگهون ٿا) ۽ ظاهر ٿيڻ لاءِ ابتدائي فهرست ترتيب ڏيو. ٻيو چيڪ ڪري ٿو ته ڇا موجوده ڪتي وٽ ڪجهه ڊيٽا آهي، ۽ انهي جي بنياد تي ٽيڪسٽ فيلڊ سيٽ ڪري ٿو: 
@FXML
    private void delete() {
        int selectedIndex = dogs.getSelectionModel().getSelectedIndex();
        dogs.getItems().remove(selectedIndex);
    }

    @FXML
    private void edit() {
        int selectedIndex = dogs.getSelectionModel().getSelectedIndex();
        dogs.getItems().set(selectedIndex, new Dog(name.getText(), breed.getText(), Integer.valueOf(age.getText()), city.getText(), Integer.valueOf(levelOfTraining.getText())));
    }

    @FXML
    private void create() {
        Dog someDog = new Dog();
        appFX.showCreateWindow(someDog);
        if (someDog.getName() != null && !someDog.getName().getValue().isEmpty()) {
            appFX.getListDog().add(someDog);
        }
    }
}
هتي اسان بٽڻن سان لاڳاپيل بنيادي ونڊو جا ٽي طريقا ڏسون ٿا: جاوا FX جو تعارف - 12
  • حذف ڪريو - منتخب ٿيل (چونڊيل) ڪتي کي انڊيڪس ذريعي ختم ڪريو؛
  • ايڊٽ ڪريو - منتقل ٿيل ڊيٽا سان هڪ نئون ڪتو ٺاهيو، ۽ ان کي سيٽ ڪريو ان جي بدران جيڪو اڳ هو؛
  • ٺاھيو - اسان ھڪڙو نئون ڪتو ٺاھيو ۽ ٺاھيو ونڊو کي ڪال ڪرڻ جو طريقو، ھڪڙو نئون اعتراض پاس ڪرڻ، ۽ بند ڪرڻ کان پوء، جيڪڏھن نالو ناھي، پوء نئين پالتو کي بچايو.
اڳتي هلي، ڪتي ٺاهڻ لاءِ ونڊو ڪنٽرولر: @Data 
public class CreateController {
    private Stage dialogStage;
    private Dog dog;

    @FXML
    private TextField nickName;

    @FXML
    private void ok() {
        if (nickName != null && !nickName.getText().isEmpty()) {
            dog.setName(new SimpleStringProperty(nickName.getText()));
            dialogStage.close();
        }
    }

    @FXML
    private void cansel() {
        dialogStage.close();
    }
}
هتي اسان ونڊو ۾ ٽيڪسٽ فيلڊ سان ڪنيڪشن ڏسون ٿا، محفوظ ڪريو ۽ منسوخ ڪريو بٽڻ کي پروسيس ڪندي، جيڪو ڪنهن به طريقي سان ونڊو بند ڪري ٿو. جئين توهان ڏسي سگهو ٿا، منهنجي ننڍڙي ايپليڪيشن ۾ وڌيڪ سهولت لاء مون لومبوڪ استعمال ڪيو، ٻي صورت ۾ ڪوڊ تمام گهڻو وڌي وڃي ها، ۽ مان ان کي پنهنجي نظرثاني ۾ نه آڻيان ها. شايد اهو سڀ ڪجهه مون وٽ اڄ تائين آهي. اڄ اسان مختصر طور تي بنيادي مفهومن ۽ JavaFX استعمال ڪرڻ جي هڪ مثال کان واقف ٿي چڪا آهيون، ۽ اسان ننڍيون ڊيسڪ ٽاپ ايپليڪيشنون ٺاهي سگهون ٿا (اضافي معلومات استعمال ڪندي، جيڪا خوشقسمتيءَ سان انٽرنيٽ تي تمام گهڻي آهي). ۽ توهان، موڙ ۾، جهڙوڪ))
تبصرا
TO VIEW ALL COMMENTS OR TO MAKE A COMMENT,
GO TO FULL VERSION