Re: Announcing Monocle, an experimental port of Glass for embedded systems

2014-01-08 Thread Richard Bair
Very cool! Triple bonus points for writing some design documentation :-)

Richard

On Jan 8, 2014, at 4:00 PM, Daniel Blaukopf daniel.blauk...@oracle.com wrote:

 Hi,
 
 A few of us in the JavaFX team have been trying over the holidays to put 
 together an embedded implementation of Glass that has minimal native code. 
 When developing the existing embedded Glass implementation, Lens, we had 
 noticed that there were a few problems were were running into again and again:
 - We were duplicating data structures between C and Java.
 - Logic was split between C and Java, making it hard to debug effectively.
 - In many cases we needed to make expensive JNI up-calls from C to Java.
 - Each additional platform we added support for increased the complexity of 
 the system and frequently required similar changes in Glass and Prism.
 - Any level of pluggability in C needs a lot of setup to do, both for the 
 platform porting layer (on which we did make some progress) and the ability 
 to use custom input handlers (on which we didn’t)
 
 Monocle is an attempt to resolve these problems. It’s in a very basic state 
 right now, but it is enough to play with. There is a description of the 
 components and how to run up at 
 https://wiki.openjdk.java.net/display/OpenJFX/Monocle.
 
 Monocle is currently buildable for all platforms, but on desktop platforms it 
 only works in headless mode. It can render on BeagleBoard xM, Freescale i.MX6 
 and in embedded emulation mode on Linux/x86.
 
 Your feedback is welcome, on this alias and in JIRA.
 
 Daniel



Re: Announcing Monocle, an experimental port of Glass for embedded systems

2014-01-08 Thread Scott Palmer
What's the situation on Raspberry Pi?  I got one for Christmas and made a
quick memory game for my daughter with JavaFX - works great.
Should I bother trying or do you already know it doesn't work?

Scott

On Wed, Jan 8, 2014 at 7:00 PM, Daniel Blaukopf
daniel.blauk...@oracle.comwrote:

 Hi,

 A few of us in the JavaFX team have been trying over the holidays to put
 together an embedded implementation of Glass that has minimal native code.
 When developing the existing embedded Glass implementation, Lens, we had
 noticed that there were a few problems were were running into again and
 again:
  - We were duplicating data structures between C and Java.
  - Logic was split between C and Java, making it hard to debug effectively.
  - In many cases we needed to make expensive JNI up-calls from C to Java.
  - Each additional platform we added support for increased the complexity
 of the system and frequently required similar changes in Glass and Prism.
  - Any level of pluggability in C needs a lot of setup to do, both for the
 platform porting layer (on which we did make some progress) and the ability
 to use custom input handlers (on which we didn’t)

 Monocle is an attempt to resolve these problems. It’s in a very basic
 state right now, but it is enough to play with. There is a description of
 the components and how to run up at
 https://wiki.openjdk.java.net/display/OpenJFX/Monocle.

 Monocle is currently buildable for all platforms, but on desktop platforms
 it only works in headless mode. It can render on BeagleBoard xM, Freescale
 i.MX6 and in embedded emulation mode on Linux/x86.

 Your feedback is welcome, on this alias and in JIRA.

 Daniel


Re: Announcing Monocle, an experimental port of Glass for embedded systems

2014-01-08 Thread Daniel Blaukopf
On the radar but not implemented yet.

On Jan 9, 2014, at 3:24 AM, Scott Palmer swpal...@gmail.com wrote:

 What's the situation on Raspberry Pi?  I got one for Christmas and made a 
 quick memory game for my daughter with JavaFX - works great.
 Should I bother trying or do you already know it doesn't work?
 
 Scott
 
 On Wed, Jan 8, 2014 at 7:00 PM, Daniel Blaukopf daniel.blauk...@oracle.com 
 wrote:
 Hi,
 
 A few of us in the JavaFX team have been trying over the holidays to put 
 together an embedded implementation of Glass that has minimal native code. 
 When developing the existing embedded Glass implementation, Lens, we had 
 noticed that there were a few problems were were running into again and again:
  - We were duplicating data structures between C and Java.
  - Logic was split between C and Java, making it hard to debug effectively.
  - In many cases we needed to make expensive JNI up-calls from C to Java.
  - Each additional platform we added support for increased the complexity of 
 the system and frequently required similar changes in Glass and Prism.
  - Any level of pluggability in C needs a lot of setup to do, both for the 
 platform porting layer (on which we did make some progress) and the ability 
 to use custom input handlers (on which we didn’t)
 
 Monocle is an attempt to resolve these problems. It’s in a very basic state 
 right now, but it is enough to play with. There is a description of the 
 components and how to run up at 
 https://wiki.openjdk.java.net/display/OpenJFX/Monocle.
 
 Monocle is currently buildable for all platforms, but on desktop platforms it 
 only works in headless mode. It can render on BeagleBoard xM, Freescale i.MX6 
 and in embedded emulation mode on Linux/x86.
 
 Your feedback is welcome, on this alias and in JIRA.
 
 Daniel
 



Re: Announcing Monocle, an experimental port of Glass for embedded systems

2014-01-08 Thread Gerrit Grunwald
Very Cool!!!
Will it work also on the BeagleBone Black? Hardwarewise it seems to be very 
close to the xM.
Also looking forward to test it on the cubox-i :)

Cheers,

Gerrit


 Am 09.01.2014 um 01:00 schrieb Daniel Blaukopf daniel.blauk...@oracle.com:
 
 Hi,
 
 A few of us in the JavaFX team have been trying over the holidays to put 
 together an embedded implementation of Glass that has minimal native code. 
 When developing the existing embedded Glass implementation, Lens, we had 
 noticed that there were a few problems were were running into again and again:
 - We were duplicating data structures between C and Java.
 - Logic was split between C and Java, making it hard to debug effectively.
 - In many cases we needed to make expensive JNI up-calls from C to Java.
 - Each additional platform we added support for increased the complexity of 
 the system and frequently required similar changes in Glass and Prism.
 - Any level of pluggability in C needs a lot of setup to do, both for the 
 platform porting layer (on which we did make some progress) and the ability 
 to use custom input handlers (on which we didn’t)
 
 Monocle is an attempt to resolve these problems. It’s in a very basic state 
 right now, but it is enough to play with. There is a description of the 
 components and how to run up at 
 https://wiki.openjdk.java.net/display/OpenJFX/Monocle.
 
 Monocle is currently buildable for all platforms, but on desktop platforms it 
 only works in headless mode. It can render on BeagleBoard xM, Freescale i.MX6 
 and in embedded emulation mode on Linux/x86.
 
 Your feedback is welcome, on this alias and in JIRA.
 
 Daniel