• No products in the basket.


    Course Curriculum

    Section 01: Why learn JavaFX and Swing?
    01. Introduction FREE 00:05:02
    "We - the course instructors - start with introductions. We are a husband-wife team, studied at Stanford, and spent several years working in top tech companies, including Google, Flipkart and Microsoft. Next, we talk about the target audience for this course: experienced UI programmers who know Swing but now would like to master JavaFX; server-side programmers who know neither Swing nor JavaFX and would like to learn UI programming from 0 to 1, and folks who have done just a little bit of Swing but are not completely confident about their grasp on Java UI programming. By the end of this class, students will be able to build sophisticated UIs in JavaFX and Swing; you will know how to build clean, maintainable and smooth user interfaces, and will be able to carry this knowledge over to any language or platform. That's it for preliminaries - with this we plunge right in! With all great user interfaces, there is a lot more than meets the eye. We start with an exploration of this idea."
    02. A taste of things to come 00:15:37
    Section 02: Swing
    03. Frameworks – A State of Mind 00:16:59
    "Frameworks are complicated sets of interconnected classes: they are incredibly powerful, but take some getting used to. This class introduces the concept of frameworks and explains how they work with a simple analogy. Using a framework has some trade offs, we give up complete control over our application in return for incredible speed of development and lots of built-in support. Frameworks are heavily influenced by the Observer design pattern, communication is via events and the corresponding listeners."
    04. The Basic Idea of Swing 00:16:58
    This lecture is an intro to Swing - a Java framework used for building graphical user interfaces (GUI). It covers the building blocks used in Swing, the JFrame and JComponent classes and talks about the pros and cons of using Swing.
    05. Swing and the Model-View-Controller Paradigm 00:12:16
    The Model-View-Controller (MVC) paradigm is ubiquitous in UI programming; along with the Observer and Command patterns, MVC underpins practically all modern User-Interface programming.
    06. The Mechanics of Swing I FREE 00:08:18
    We plunge into Swing which is a prototypical UI programming framework. We start with the building blocks of Swing (JFrame and JComponent). Next - the idea of layouts which position controls on screen, and the border layout as an example. Then, JComponents(JTextArea, JTreeView, JMenuBar, JScrollPane, JPanel and JFileChooser).
    07. The Mechanics of Swing-II 00:18:35
    "This lesson explores the different classes that Swing provides for UI components such as menus (JMenuBar, JMenu, JMenuItem). Trees in Swing are pretty powerful but complicated to use, we learn how to deal with their intricacies. We also learn how to capture and handle mouse events. "
    08. A Serious Swing App: News Curation Browser – I 00:17:19
    We build a serious Swing application - the News Curation App: The objective of the drill is to build an application that helps in curating news snippets and quickly summarizing articles. We will use helper classes to write to an HTML file, set up the Model portion of the MVC paradigm. This stores the underlying data for the application.
    09. A Serious Swing App: News Curation Browser – II 00:15:18
    We continue with our News Curation Swing App. This class focuses on the View portion of the MVC paradigm. We will set up the UI of our drill in this video using JTree, JEditorPane and JTextArea. We learn the use of scrollpanes to set up scroll bars in our UI when content overflows its container.
    10. A Serious Swing App: News Curation Browser – III 00:16:14
    As part of our News Curation Swing app - we setup a tree structure for navigation. In Swing this can be done using the JTree class which renders the view. The JTree requires a corresponding model and a bunch of listeners to set it up completely. This drill looks at wiring up the tree completely - no mean task!
    11. A Serious Swing App: News Curation Browser – IV 00:17:45
    We continue with our News Curation Swing App. This class focuses on the Controller portion of the MVC paradigm. We wire up a whole bunch of events listeners, for the File->Save menu, tree navigation and selection listeners, text area change listeners and the Go! button click listener.
    Section 03: MVC, Observer and Command: Design Patterns Underpinning Swing and JavaFX
    12. Listeners, And The Observer Design Pattern 00:10:17
    The Observer Pattern, along with the MVC and Command Patterns, has practically defined modern UI programming. Publishers publish updates when their state changes, and Subscribers can listen in on these updates. An event is fired when the state changes, and the listener responds via a Command object called the event listener code.
    13. Actions, And The Command Design Pattern 00:12:26
    The Command Design Pattern is used to separate an action from its execution. A seemingly abstract idea, and an incredibly powerful one. The Command Pattern, along with the Observer and MVC Patterns, has practically defined modern User Interface Programming.
    Section 04: JavaFX Introduced
    14. Contrasting JavaFX and Swing – I 00:11:01
    We introduce JavaFX, a new framework which is intended to replace Swing as the standard GUI library for Java. JavaFX features are much more powerful than Swing - stuff such as Properties and Bindings, CSS support pack a real whammy.
    15. Contrasting JavaFX and Swing – II 00:10:16
    This course continues with JavaFX features which make it so powerful. Scenebuilder and FXML allow decoupling model and controller code from UI design and definition. Built in 3D effects (illumination, material textures and camera effects), support for animations, charting, audio and video media all make JavaFX a great choice for building user interfaces.
    16. The Mechanics of JavaFX 00:04:21
    The basic building blocks in a JavaFX program - Stage, Scene and Node.
    17. Properties and Bindings Introduced 00:11:20
    Properties and Bindings are a Java beans programming construct which allow wiring up of variables to express relationships between them. JavaFX uses this extensively within its framework to expose granular updates for various events.
    18. Properties and Bindings: Coding examples 00:17:11
    This class looks at code for defining, listening on and binding to a property. We'll introduce the ObservableValue<T> interface and see how it differs from the old Observer interface.
    19. We are in sync : Properties and Bindings in action FREE 00:04:13
    We code up a short example to see properties and bindings in action. Two text areas that remain perfectly in sync with each other - changes in one reflect immediately in another.
    20. How the MVC Paradigm Shapes JavaFX Apps 00:16:12
    The Model-View-Controller (MVC) paradigm is ubiquitious in UI programming; along with the Observer and Command patterns, MVC has practically defined modern User-Interface programming. We will talk about various advantages over Swing which JavaFX has to offer if we were to make News Curation App in JavaFX. The JavaFX version of the app is smoother, faster than the swing version and its code is far simpler and smaller too.
    21. A Serious JavaFX App: The News Curator – I 00:17:31
    We'll rebuild the News Curator app from our Swing exercise, this time using JavaFX. The model and the view are very similar to the Swing code, although the UI is set up with JavaFX classes. You'll see how much simpler they are in most cases!
    22. A Serious JavaFX App: The News Curator – II 00:18:57
    We continue building the News Curator app. The controller in the JavaFX version is very different from Swing. Thanks to the user of properties and bindings wiring up listeners is far simpler and involves very little boilerplate code.
    Section 05: Properties And Bindings
    23. Properties and Bindings Revisited 00:14:31
    Back to Properties and Bindings. This course looks at them in much more depth, including some detailed examples.
    24. Properties and Bindings: Digging Deeper 00:17:24
    Open questions on Properties and Bindings. Why are they special? What is the difference between Change Events and Invalidation Events? What are ReadOnly and ReadWrite properties? What are Property objects and Binding objects and how are they different? We answer these and more in this lecture.
    25. Properties and Bindings: Observables, ChangeListeners and Other Interfaces 00:14:11
    How do properties announce changes in their values? They implement the ObservableValue interface and Observable interface. This means they accept both ChangeListeners and InvalidationListeners. We'll also see how ReadWrite properties are just writable ReadOnly properties by looking at the entire interface hierarchy.
    26. JavaFX: Modeling Properties and Bindings 00:12:43
    This lecture talks about scenarios where bindings should be used instead of properties. Properties are useful in 1:1 relationships and bindings are useful to model 1:Many relationships. We'll cover specific examples of when Bindings are to be used over properties.
    27. JavaFX : Digging into Bindings 00:10:31
    We saw when Bindings are useful in the previous class. There are few different ways of implementing bindings and this class takes about the most important ones - static methods in the Bindings class, extending a pre-existing Binding object and the fluent API.
    28. The trick to JavaFX properties: Lazy Instantiation 00:17:57
    "JavaFX is powerful because virtually all classes expose their properties for others to bind to. But this might be overkill. We will talk about the benefits of Eager versus Lazy Evaluation of properties. We usually implement Lazy Evaluation of Properties using an InvalidationListener. We will then move on to Eager versus Lazy Instantiation of Properties. We'll also take a brief look at FXCollections, which are are useful containers that announce when their value changes."
    29. A Zippier UI using Properties and Bindings: Snippet Browser with a Real-Time Pre 00:18:11
    We code up a preview pane as an extension to the news curation app in JavaFX using properties and bindings. This allows us to see how the HTML page will look in real-time. This involves extensively using properties and the observable collections.
    Section 06: FXML and SceneBuilder
    30. Complex UIs via FXML and SceneBuilder 00:11:49
    We'll introduce FXML and Scenebuilder. Scenebuilder is WYSIWYG tool to setup User Interfaces. FXML is a way to specify Java UI Elements in XML with no code at all. When you consider the MVC paradigm, FXML is a way to set up the view without writing all the boilerplate usually involved.
    31. FXML Behind the Scenes : Linking to the controller 00:14:09
    FXML is a way to specify UIs in XML. How is this understood by Java? This is classic dependency injection, the controller class in JavaFX is linked to the FXML file - the link relies on two bits of syntax - the @FXML annotation and the fx:id tag
    32. FXML Behind the Scenes : Dependency Injection 00:15:40
    The FXMLLoader is pretty amazing. It's the key element in converting an FXML file into a usable Java Object. It does a host of things including instantiating nodes, wiring up listeners etc. The FXMLLoader is the class which takes care of dependency injection in FXML.
    33. Building a Serious UI App with FXML and SceneBuilder: Snippet Browser – I FREE 00:12:08
    We return to our favorite News Curator App and this time build it using Scenebuilder and FXML. Scenebuilder is a powerful tool that allows UX designers to set up the UI without writing any code.
    34. Building a Serious UI App with FXML and SceneBuilder: Snippet Browser – II 00:07:49
    We continue with our News Curator app - this time integrating the fxml with the java code. The link is forged by two key elements, the @FXML annotation and the fx:id tag
    35. Building a Serious UI App with FXML and SceneBuilder: Snippet Browser – III 00:15:12
    Wiring up listeners is a breeze using FXML. We'll see how to wire up the listeners for the News Curator App.
    36. The Full Possibilities of FXML – I 00:12:36
    This lecture talks about important and useful features of FXML files - specifying a stylesheet (CSS File support), localizing your content (localization support through location resolution), property binding inside FXML using the '${..}' notation, nested FXML files (one FXML file inside another FXML file) and using javascript inside FXML files.
    37. The Full Possibilities of FXML – II 00:13:04
    We continue exploring intricate details of FXML - property binding inside FXML using the '${..}' notation, javascript support inside FXML files
    38. The Full Possibilities of FXML – III 00:06:04
    JavaFX allows us to nest one FXML file inside the other. This allows us to build up our UI in logical blocks.
    Section 07: Shapes and Drawing
    39. Drawing: Shapes and Nodes 00:16:39
    Shapes and Nodes are at the heart of drawing support in JavaFX. JavaFX provides a bunch of built-in Shape classes all of which can be animated easily. Rotation, translation, etc are easy to use transitions in JavaFX.
    40. Drawing: Fonts and a Segue into Animated GIFs 00:16:31
    Create an animated GIF of all the fonts on your machine. We'll use the snapshot method thats implemented by all nodes and borrow some code from a kind soul who's done the work of converting images to GIFs
    Section 08: Animation
    41. Animation: Timelines and Transitions 00:18:10
    Learn what's at the base of creating some cool animations in JavaFX. The Animation class is at the core JavaFX built-in animation support. Transition animations are built-in and provide a variety of effects like Fade, Fill, moving a Node along a Path etc. Timeline Animations can be used to handcraft custom animations. KeyValues and KeyFrames are the trick to achieving this.
    42. Transitions Explored 00:13:46
    Write some code to we animate a text in a bunch of ways (path transition, fade transition, rotate transition, stroke and fill transitions and sequential transition) using JavaFX's built-in animation support.
    Section 09: Media
    43. JavaFX Media Support: Part-Lame, Part-Awesome 00:10:36
    JavaFX built-in media support is part-lame, part-awesome. Media Support is a great example of the Model-View-Controller (MVC) paradigm in action. JavaFX has built-in media classes to represent each of the Model, View and Controller
    44. JavaFX Media Support: Getting started with common operations 00:15:34
    Get started with some common operations on media files - play, pause, stop etc. Setting up a volume slider for the mediaplayer is easy as pie, but a position slider is surprisingly complicated.
    45. Build your own Media Player – I 00:17:59
    Build your very own Media Player from scratch - and put in all the functionality you would expect - Play, Pause, Stop, Volume and Position controls
    46. Build your own Media Player – II 00:16:33
    We continue building our Media Player. Wiring up listeners to set up a position slider is surprisingly complicated. We'll use Platform.runlater() to keep the UI zippy and responsive.
    Section 10: Charts and Tables
    47. JavaFX Charts and Tables – I 00:17:36
    JavaFX has great built-in support for Charts and Tables. Once again these are good examples of the Model-View-Controller (MVC) paradigm in action. Both require some adapter code to be written - the adapter for tables is kind of cool and unlike anything you've seen before.
    48. JavaFX Charts and Tables – II FREE 00:04:29
    JavaFX has built-in support for a variety of charts (PieChart, BarChart, LineChart, StackedAreaChart, BubbleChart and more). All these derive from the Chart base class. Wiring up charts requires us to write some adapter code.
    49. Charts and Tables : An example – I 00:12:49
    Code up a table in JavaFX. Use it represent financial data of some Fortune 500 companies
    50. Charts and Tables : An example – II 00:07:29
    Code up a bubblechart in JavaFX and use it to represent the financials of some Fortune 500 companies
    Section 11: 3D
    51. 3D Rendering : Introduction to 3D Rendering: Segue to Drawing in 2D 00:11:17
    Before we get into learning about 3D, we take a detour and remind ourselves of JavaFX support for drawing 2D shapes
    52. Introduction to 3D Rendering 00:12:57
    Shape3D class is at the heart of 3D rendering in JavaFX. Built-in shapes Sphere, Box and Cylinder derive from Shape3D class. 3D Shapes in JavaFX have 3 important properties : Material, Drawmode and Cullface. 3D representations are created in JavaFX using rotations and 3D animations are created using camera movements.
    53. 3D Rendering: Getting our feet wet 00:10:24
    We code up our first set of 3D shapes and explore the different properties of 3D shapes in JavaFX (Material, Drawmode and CullFace)
    54. 3D Animations: Timelines and Moving Cameras 00:05:34
    Handcraft a 3D timeline animation in JavaFX - we learn how to use KeyValues and KeyFrames. Use a Camera to create depth movements in a 3D animation
    © 2016. LearnBox Education.



    Create an Account
    Create an Account Back to login/register