01:11 <byteit101[m]> enebo: Is there a way to get the block arg to the super call?

02:36 <GGibson[m]> Does anyone want to discuss jrubyfx at the moment?

02:46 <byteit101[m]> sure

02:48 <byteit101[m]> G. Gibson: What do you want to discuss?

02:49 <GGibson[m]> Well

02:49 <GGibson[m]> I notice it all acts upon Classes, not instances of Window classes.

02:50 <GGibson[m]> this is a bummer

02:50 <GGibson[m]> I need to sport multiple windows

02:50 <byteit101[m]> "it" ?

02:50 <GGibson[m]> jrubyfx

02:50 <GGibson[m]> sorry

02:50 <byteit101[m]> What specifically?

02:50 <GGibson[m]> launching for one

02:51 <GGibson[m]> it appears to create a new intstance of the window class I defined

02:51 <GGibson[m]> and I need to direct resource information into that instanc

02:51 <GGibson[m]> * and I need to direct resource information into that instance

02:52 <GGibson[m]> I'm essentially attempting to drive window creation based upon a db record.

02:52 <byteit101[m]> Stage.new.tap{|stage| ... }.show

02:53 <GGibson[m]> hrm ... ok

02:53 <byteit101[m]> https://stackoverflow.com/a/42818643

02:53 <GGibson[m]> oh clicky ... thanks

02:54 <GGibson[m]> oh ok -- so I'll need to learn some java then

02:55 <byteit101[m]> At least reading it to translate to ruby

02:55 <GGibson[m]> sure

02:57 <byteit101[m]> the big thing to know is that fxmlloader is the only very different line

02:57 <GGibson[m]> I will probably not be using fxml

02:58 <GGibson[m]> What I do is generate dsl script from a database structure record

02:58 <GGibson[m]> I'm looking to eval(thingy).call(stage) it

02:58 <GGibson[m]> that direction

02:59 <byteit101[m]> Ah, that's an interesting approach

02:59 <GGibson[m]> I do things like that ;)

03:00 <GGibson[m]> the reason I'm doing it is that I plan to construct a window that edits those records a la IDE

03:00 <GGibson[m]> utterly avoiding xml like the plague

03:00 <byteit101[m]> stage = Stage.new; stage.scene = eval(thingy); stage.title = "foo"; stage.show; #where thingy evaluates to a Scene Object

03:01 <GGibson[m]> Stage is an unknown constant -- ::JRubyFX::Stage?

03:02 <byteit101[m]> > utterly avoiding xml like the plague

03:02 <byteit101[m]> I've found xml is most useful and intuitive for UI's actually. FXML is only topped by XAML (Windows)

03:02 <byteit101[m]> Ah, right, constants are fun. You can either import all of them, or do it selectively.

03:02 <GGibson[m]> well, my script generator allows me to drop in script snippets at will anyplace and I dig the flexibility it will give me.

03:02 <GGibson[m]> ah ok

03:03 <GGibson[m]> I'll sniff the github source

03:03 <byteit101[m]> If you are in a class that extends JRubyFX the lookup will work

03:03 <byteit101[m]> otherwise, stage is from javafx.stage.Stage

03:03 <GGibson[m]> I subclassed JRubyFX::Application

03:04 <byteit101[m]> Yes, that's an override of javafx.application.Application

03:04 <GGibson[m]> ok

03:05 <byteit101[m]> the FX classes can always be looked up via JRubyFX::FXImports::

03:06 <byteit101[m]> but you can import them into other contexts, such as via

03:06 <byteit101[m]> include JRubyFX

03:07 <byteit101[m]> If you subclassed JRubyFX::Application, then the constants *should* be there for you

03:07 <GGibson[m]> ok great

03:09 <byteit101[m]> out of curiosity, how are you building `thingy` above? strings or an ast library?

03:09 <GGibson[m]> I generate a string

03:39 <GGibson[m]> hrm

03:39 <GGibson[m]> I get this error: /opt/jruby-9.2.14.0/lib/ruby/stdlib/irb/init.rb:280: warning: LoadError: load error: ./src/studio -- java.lang.IllegalStateException: Not on FX application thread; currentThread = main

03:39 <GGibson[m]> but I'm using run_later for the call it complains about

03:40 <byteit101[m]> are you in a callback?

03:41 <byteit101[m]> Oh, have you launched the application?

03:41 <GGibson[m]> no, not yet

03:41 <GGibson[m]> ok

03:42 <GGibson[m]> I think I see

03:42 <GGibson[m]> so, the param I pass launch does it get fed to initialize?

03:42 <GGibson[m]> or just calls stage

03:42 <GGibson[m]> ?

03:42 <byteit101[m]> It's weird, let me look up the docs

03:42 <GGibson[m]> thanks

03:43 <GGibson[m]> Are you looking for more contributors to jrubyfx? a Buddy of mine in europe is fantastic on java

03:43 <byteit101[m]> Sure?

03:43 <byteit101[m]> https://docs.oracle.com/javafx/2/api/javafx/application/Application.html#getParameters()

03:44 <GGibson[m]> ok, I'll look into that

03:44 <byteit101[m]> However! I don't personally recommend that for ruby apps, instead just use ARGV

03:44 <byteit101[m]> Do nothing before you call App.launch, and consider the start method the main

03:44 <byteit101[m]> Or, use Constants/globals

03:44 <byteit101[m]> as params have to be strings

03:45 <GGibson[m]> If I can pass a string, I'm good

03:56 <GGibson[m]> I think I'm screwed: init takes no params, and start only takes one (the stage)

03:57 <byteit101[m]> correct, call params inside start (it's an instance method

03:57 <byteit101[m]> class App < JRubyFX::Application; def start(_); p params.raw; end; end; App.launch("hello")

03:57 <GGibson[m]> I'm not sure, in that case, how to direct the new window instance where to pick up its definition record then ... bummer

03:58 <byteit101[m]> OH!

03:58 <byteit101[m]> Do'nt do that

03:58 <GGibson[m]> ??

03:58 <byteit101[m]> You can only start one application

03:58 <GGibson[m]> not in init - I saw the warning

03:58 <GGibson[m]> ok

03:58 <GGibson[m]> so multiple windows is not supported?

03:58 <byteit101[m]> but the application can only have n windows

03:58 <byteit101[m]> Application != Stage(window)

03:58 <GGibson[m]> ok

04:01 <byteit101[m]> class App < JRubyFX::Application; def start(_); 5.times{|i| Stage.new.tap{|x|x.title=i.to_s}.show }; end; end; App.launch

04:01 <byteit101[m]> ^ Just tested

04:03 <byteit101[m]> I'd recommend you do all stuff inside the start method, and nothing outside. If you'd like, you can do a require './rest_of_code' inside start, and then put all the code in rest_of_code.rb

04:03 <GGibson[m]> I just tested it to

04:03 <GGibson[m]> excellent, that is good info

04:03 <GGibson[m]> ok

04:05 <GGibson[m]> Hey, thanks for your help. I think I am starting to get it now

04:07 <byteit101[m]> NP

05:22 <GGibson[m]> Hey! it works

05:22 <GGibson[m]> got a window to come up that is completely defined in a database structured record

05:22 <GGibson[m]> nice

05:26 <byteit101[m]> Nice!

05:27 <GGibson[m]> kinda worried though - looks like I get only ONE opportunity to define windows

05:27 <GGibson[m]> I would like to show/hide tool pallets

05:27 <byteit101[m]> No, you can define them whenever you want

05:28 <GGibson[m]> oh?

05:28 <GGibson[m]> outside of start()?

05:29 <byteit101[m]> Again: I recommend putting your main loop inside of start, but yes: class App < JRubyFX::Application; def start(_); 5.times{|i| Thread.new { sleep i; run_later { Stage.new.tap{|x|x.title=i.to_s}.show}} }; end; end; App.launch

05:29 <GGibson[m]> ok, I think I get it

05:30 <GGibson[m]> I can work with that

05:32 <byteit101[m]> In JavaFX, consider the "main" thread to be only useful for starting javafx, and nothing more :-)

05:34 <byteit101[m]> Like many GUI toolkits, it's heavily evented

20:21 <truths33ker[m]> hi byteit101

20:22 <truths33ker[m]> I wanted to ask in which manner i could contribute to the project?

20:23 <truths33ker[m]> the jrubyxf project to be precize

20:24 <GGibson[m]> byteit101: truths33ker is the friend in Europe I spoke of

20:25 <GGibson[m]> btw: your tips helped me put up my very first windows last night

20:25 <GGibson[m]> success

20:32 <byteit101[m]> It's a mostly stable and minimal wrapper project at this point. The only excitement is going to be deleting some hacks once I finish https://github.com/jruby/jruby/pull/6422, but I know that right now, the jarify stuff is sketchy: https://github.com/jruby/jrubyfx/issues/118 Documentation for translation of javadoc=> our syntax could use some reference, but the biggest doc is jrubyfx's differences from java, such as

20:32 <byteit101[m]> injected @stage, etc: https://github.com/jruby/jrubyfx/issues/122 If you want to help with triage of issues, that might be helpful, but that might change siginificantly with my PR in JRuby proper. I'll try to push a branch with changes to support that soon if you want to do that (or help out testing). Another possibility: new helpers to make things less java-like but more ruby-like

20:33 <byteit101[m]> truths33ker: there's some ideas, I'm sure there are more if you are interested in a specific thing I haven't mentioned

20:36 <byteit101[m]> truths33ker: Ritght, jarify issue linked is going to be solved with the PR I think, scratch that one

20:41 <truths33ker[m]> I read your interesting reaction I wanted to say that i would like to start with software testing

20:41 <truths33ker[m]> at first

20:43 <byteit101[m]> Cool, of the existing code (don't test fxml) or post-pr code (fxml, mostly)?

20:43 <truths33ker[m]> understood

20:45 <byteit101[m]> Oh, I also have a thing importing all the rest of the classes sitting here not committed yet

20:47 <truths33ker[m]> oh sorry got a call

20:50 <byteit101[m]> Another idea: binding/observable api that is more rubyish, but that will probably require the PR to function well

20:52 <truths33ker[m]> sounds good I choose for the rubyfied method

20:56 <byteit101[m]> I'm referring to this: https://docs.oracle.com/javafx/2/binding/jfxpub-binding.htm https://github.com/jruby/jrubyfx/tree/master/samples/contrib/binding_examples

20:57 <truths33ker[m]> thanks verry much

20:57 <byteit101[m]> As that sort of wordy math (high level) and class extension (low-level) aren't very rubyish

20:58 <truths33ker[m]> ow ok good to know

21:00 <byteit101[m]> another though: the {Tree,List,..}Cell extension is also not very rubyish, but I think that is probably harder to avoid

21:00 <byteit101[m]> *thought