reflexion 0.5.3 → 0.7.0

data/samples/menu.rb

@@ -0,0 +1,32 @@
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'xot/util'
+require 'reflex'
+
+icon = Rays::Image.new(8, 8).paint {fill :red; ellipse 0, 0, 8}
+
+Reflex.start do
+  mod      = Xot.osx? ? :command : :control
+  app_menu = Reflex::Application.instance.menu || Reflex::Menu.new
+  file     = app_menu.add Reflex::Menu.new('File'), index: 1
+  hello    = file    .add Reflex::Menu.new('Hello', image: icon, shortcut: [:e, mod])
+  help     = file    .add Reflex::Menu.new('Help', shortcut: :f1)
+
+  popup_menu = Reflex::Menu.new
+  cut        = popup_menu.add Reflex::Menu.new('Cut')
+  copy       = popup_menu.add Reflex::Menu.new('Copy')
+  paste      = popup_menu.add Reflex::Menu.new('Paste')
+
+  hello.on(:click) {|e| p :hello}
+  help .on(:click) {|e| p :help}
+  cut  .on(:click) {|e| p :cut}
+  copy .on(:click) {|e| p :copy}
+  paste.on(:click) {|e| p :paste}
+
+  win      = Reflex::Window.new title: 'Menu Test', frame: [100, 100, 400, 300]
+  win.menu = app_menu if Xot.win32?
+  win.on(:pointer_down) {|e| popup_menu.popup win.root, e.x, e.y if e.right?}
+  win.show
+end

data/samples/model.rb

@@ -41,9 +41,9 @@ class SliderView < View
 
   private
 
-    def knob_x_max ()
-      width - @knob.width
-    end
+  def knob_x_max ()
+    width - @knob.width
+  end
 
 end# SliderView
 

data/samples/test/alert.rb

@@ -0,0 +1,93 @@
+# Manual check for Reflex.alert.
+#
+#   ruby alert.rb
+#        -> a window counts its frames and shows the largest dt so far.
+#           each key shows an alert, which returns only when closed
+#      1   with a title
+#            macos:   the title in bold, the message under it
+#            windows: the title in the title bar
+#      2   with no title
+#            macos:   the message in bold
+#            windows: an empty title bar, not 'Error'
+#      3   a long message over many lines, as a backtrace
+#      4   a message and a title in japanese
+#      5   in 3 seconds: switch to another app meanwhile
+#            -> the alert comes to the front and takes the keyboard
+#      q   quit
+#        while an alert is open, the frame count stops. once it is
+#        closed, 'closed' is logged and the largest dt jumps by about the
+#        time it was open, as requestAnimationFrame does after alert()
+#   ruby alert.rb before
+#        -> an alert shows before the app starts, in front of the
+#           terminal, and closes with return. then the window opens and
+#           'on_start' is logged: an alert does not keep the app from
+#           finishing its launch
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+
+KEYS = [
+  '1: with a title     2: with no title',
+  '3: long message     4: japanese',
+  '5: in 3 seconds     q: quit'
+]
+
+LOG = []
+
+def log(text)
+  LOG.unshift text
+  puts text
+end
+
+
+Reflex.alert 'Shown before the app starts.', title: 'Before' if ARGV[0] == 'before'
+
+Reflex.start do
+  log 'on_start'
+
+  frames, max_dt = 0, 0
+
+  win = Reflex::Window.new title: 'Reflex.alert', frame: [100, 100, 560, 360]
+
+  alert = -> (message, title = nil) {
+    Reflex.alert message, title: title
+    log "closed: #{title.inspect}"
+  }
+
+  win.on(:key_down) do |e|
+    case e.chars
+    when '1' then alert['The message.', 'The Title']
+    when '2' then alert['The message with no title.']
+    when '3'
+      lines = 40.times.map {"  from /path/to/app/file_#{_1}.rb:#{_1 * 7}:in 'method_#{_1}'"}
+      alert[["boom (RuntimeError)", *lines].join("\n"), 'Long']
+    when '4' then alert['日本語のメッセージ', '日本語のタイトル']
+    when '5'
+      log 'an alert in 3 seconds'
+      win.root.delay(3) {alert['Shown by a timer.', 'Timer']}
+    when 'q' then Reflex.quit
+    end
+  end
+
+  win.on(:update) do |e|
+    frames += 1
+    max_dt  = e.dt if e.dt > max_dt
+    win.redraw
+  end
+
+  win.on(:draw) do |e|
+    p = e.painter
+    p.background 0.1, 0.1, 0.15
+    p.fill 1
+    KEYS.each_with_index {|text, i| p.text text, 10, 10 + i * 18}
+    p.text "frames: #{frames}   max dt: #{'%.3f' % max_dt}", 10, 76
+    p.fill 0.5, 1, 0.5
+    LOG.first(12).each_with_index {|text, i| p.text text, 10, 110 + i * 18}
+  end
+
+  win.show
+end

data/samples/test/always_on.rb

@@ -0,0 +1,76 @@
+# Manual check for always_on_top and always_on_bottom.
+#
+# Three windows sit on top of each other, one kept above every other
+# application, one kept below, and one that behaves like any other window.
+# The colour and the text say which is which.
+#
+#   1. click another application, a browser or a finder window
+#        -> the red one stays in front of it, the green one goes behind it,
+#           and the blue one behaves as usual
+#   2. press 2 on the blue window
+#        -> it turns red and comes to the front, and stays there
+#   3. press 3 on it
+#        -> it turns green and drops behind the other application
+#   4. press 1 on it
+#        -> it is a plain window again
+#   5. press 2 on the green window
+#        -> it turns red. the two ends are never both on
+#   6. windows only: click the green one where another application covers it
+#        -> it must not come to the front
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+
+COLORS = {
+  normal: [0.2, 0.3, 0.6],
+  top:    [0.7, 0.2, 0.2],
+  bottom: [0.2, 0.5, 0.3]
+}
+
+def level_of(win)
+  case
+  when win.always_on_top?    then :top
+  when win.always_on_bottom? then :bottom
+  else                            :normal
+  end
+end
+
+def set_level(win, level)
+  win.always_on_top    = level == :top
+  win.always_on_bottom = level == :bottom
+  puts "#{win.title}: #{level_of win}"
+end
+
+%i[normal top bottom].each_with_index do |level, i|
+  win = Reflex::Window.new(
+    title: level.to_s,
+    frame: [100 + i * 50, 100 + i * 50, 320, 140])
+
+  set_level win, level
+
+  win.on(:draw) do |e|
+    p = e.painter
+    p.background(*COLORS[level_of(win)])
+    p.fill 1, 1, 1
+    p.text level_of(win).to_s,             10, 10
+    p.text '1: normal  2: top  3: bottom', 10, 40
+  end
+
+  win.on(:key_down) do |e|
+    case e.chars
+    when '1' then set_level win, :normal
+    when '2' then set_level win, :top
+    when '3' then set_level win, :bottom
+    end
+    win.redraw
+  end
+
+  win.show
+end
+
+
+Reflex.start

data/samples/test/app_background.rb

@@ -0,0 +1,51 @@
+# Manual check for Application#background and #background_menu.
+#
+# The application lives in the menu bar: no dock icon, a status item
+# with a black circle, and it keeps running with no window open.
+#
+#   1. start and look at the dock
+#        -> the application is not there, and nothing steals the focus
+#   2. click the black circle at the right end of the menu bar
+#        -> a menu opens with Settings, Toggle Dock and Quit
+#   3. click Settings
+#        -> a small window opens, once per click
+#   4. close every window
+#        -> the application keeps running, the status item stays
+#   5. click Toggle Dock
+#        -> the application appears in the dock with the standard menu
+#           bar, and the status item stays
+#   6. close every window, then click Toggle Dock in the status item menu
+#        -> gone from the dock again, still running
+#   7. click Quit
+#        -> the application quits
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+icon = Rays::Image.new(16, 16).paint {fill :black; ellipse 2, 2, 12}
+
+Reflex.start name: 'BackgroundApp' do
+  settings = Reflex::Menu.new('Settings')
+  toggle   = Reflex::Menu.new('Toggle Dock')
+  quit     = Reflex::Menu.new('Quit')
+
+  settings.on(:click) do |e|
+    Reflex::Window.new(title: 'Settings', frame: [100, 100, 300, 200]).show
+  end
+  toggle.on(:click) do |e|
+    app = Reflex::Application.instance
+    app.background = !app.background?
+  end
+  quit.on(:click) {|e| Reflex::Application.instance.quit}
+
+  self.background_menu = Reflex::Menu.new('BG', image: icon) do
+    add settings
+    add toggle
+    add Reflex::Menu.new('-')
+    add quit
+  end
+  self.background = true
+end

data/samples/test/boundary.rb

@@ -0,0 +1,75 @@
+# Manual check for the synthesized window enter/leave.
+#
+# The window's edge is drawn as a frame: green while the pointer is inside,
+# red while it is outside, so what the log says can be seen at a glance.
+#
+#   1. move the mouse in and out with NO button held
+#        -> one :enter on the way in, one :leave on the way out, never a pair
+#   2. press LEFT inside, drag out, drag back in, release inside
+#        -> :leave on the way out, :enter on the way back in, both WHILE
+#           dragging. this is what no platform used to send
+#   3. release the button outside, then move back in
+#        -> a single :enter, not one for the release and one for the move
+#   4. cross the edge quickly, several times
+#        -> the count of :enter and :leave stays balanced, never two in a row
+#   5. macos only: after step 2, watch for a late :enter once the button is
+#      released
+#        -> there must NOT be one; it was already announced during the drag
+#   6. right click inside to pop a menu up, dismiss it, then move in and out
+#        -> :cancel is logged, and the boundary keeps working afterwards. the
+#           frame may turn red while the menu covers the window
+#   7. hold LEFT, drag outside, then right click to pop the menu up
+#        -> :cancel is logged for the left press; moving back in still gives a
+#           single :enter, and releasing left produces nothing
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+Reflex.start do
+  menu = Reflex::Menu.new
+  item = menu.add Reflex::Menu.new('Hello')
+  item.on(:click) {puts 'menu item clicked'}
+
+  win     = Reflex::Window.new frame: [100, 100, 400, 300]
+  inside  = false
+  last    = nil
+  pressed = false
+
+  show = -> action, e do
+    puts "%-6s pressed:%-5s pos:%s" % [
+      action, pressed, e.position.to_a.map {_1.round}
+    ]
+  end
+
+  boundary = -> action, e do
+    warn "TWO #{action} IN A ROW" if action == last
+    last = action
+    show[action, e]
+  end
+
+  win.on(:pointer_enter) {|e| inside = true;  boundary[:enter, e]; win.redraw}
+  win.on(:pointer_leave) {|e| inside = false; boundary[:leave, e]; win.redraw}
+
+  win.on(:pointer_down) do |e|
+    pressed = true
+    menu.popup win.root, e.x, e.y if e.right?
+  end
+
+  win.on(:pointer_up) {|e| pressed = false}
+
+  win.on(:pointer_cancel) do |e|
+    pressed = false
+    show[:cancel, e]
+  end
+
+  win.on(:draw) do |e|
+    e.painter.push fill: nil, stroke: (inside ? :green : :red), stroke_width: 8 do
+      e.painter.rect 4, 4, e.bounds.width - 8, e.bounds.height - 8
+    end
+  end
+
+  win.show
+end

data/samples/test/callback_exception.rb

@@ -0,0 +1,101 @@
+# Manual check for the paths into ruby that need a hand on the mouse or the
+# keyboard, the rest is in test_application.rb. Reflex.start must return
+# when the app quits, and a raise in a callback must come out of it as a
+# ruby exception with a backtrace, never as 'libc++abi: terminating'.
+#
+#   ruby callback_exception.rb
+#        -> quit with cmd-q, then again with the close button, then again
+#           from the dock menu, then again with the q key. 'after start'
+#           and 'at_exit' must be printed every time
+#   ruby callback_exception.rb block
+#        -> press cmd-q twice. the first one is blocked by on_quit, the
+#           second one goes. the close button would close the window
+#           first and leave the app running without one
+#   ruby callback_exception.rb HOOK
+#        -> raise in that hook, and expect a ruby backtrace and status 1
+#      pointer   click the window
+#      key       press a key
+#      resize    resize the window
+#      activate  switch to another app and back
+#      menu      choose Raise from the File menu, or press cmd-r (ctrl-r on windows)
+#      file      press o and choose a file in the dialog
+#      quit      quit the app any way, on_quit raises
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'xot/util'
+require 'reflex'
+
+
+MODE = ARGV[0] || 'none'
+MOD  = Xot.osx? ? :command : :control
+
+NOTES = {
+  'none'     => 'quit with cmd-q, the close button or the dock menu',
+  'block'    => 'press cmd-q twice. the first one is blocked, the second one goes',
+  'pointer'  => 'click the window',
+  'key'      => 'press any key',
+  'resize'   => 'resize the window',
+  'activate' => 'switch to another app and back',
+  'menu'     => "choose Raise from the File menu, or press #{MOD}-r",
+  'file'     => 'press o and choose a file',
+  'quit'     => 'quit any way, on_quit raises'
+}
+
+unless NOTES.key? MODE
+  warn "unknown mode: #{MODE}"
+  exit 2
+end
+
+at_exit {puts 'at_exit'}
+
+def boom(where)
+  raise "boom in #{where}"
+end
+
+
+quit_count = 0
+
+Reflex.start do
+  on(:quit) do |e|
+    quit_count += 1
+    boom 'on_quit' if MODE == 'quit'
+    e.block        if MODE == 'block' && quit_count == 1
+  end
+
+  win = Reflex::Window.new title: "callback_exception: #{MODE}", frame: [100, 100, 480, 240]
+
+  win.on(:draw) do |e|
+    p = e.painter
+    p.fill 1
+    p.text "mode: #{MODE}", 20, 30
+    p.text NOTES[MODE], 20, 60
+    p.text 'q: quit   o: file dialog', 20, 100
+  end
+
+  win.on(:pointer_down) {|e| boom 'on_pointer_down' if MODE == 'pointer'}
+  win.on(:resize)       {|e| boom 'on_resize'       if MODE == 'resize'}
+  win.on(:activate)     {|e| boom 'on_activate'     if MODE == 'activate'}
+
+  win.on(:key_down) do |e|
+    boom 'on_key_down' if MODE == 'key'
+    case e.chars
+    when 'q' then Reflex.quit
+    when 'o'
+      dialog = Reflex::FileDialog.new owner: win
+      dialog.on(:file) {|e| boom 'on_file' if MODE == 'file'}
+      dialog.open_file {|path| puts "chosen: #{path}"}
+    end
+  end
+
+  app_menu = Reflex::Application.instance.menu || Reflex::Menu.new
+  file     = app_menu.add Reflex::Menu.new('File'), index: 1
+  item     = file    .add Reflex::Menu.new('Raise', shortcut: [:r, MOD])
+  item.on(:click) {|e| boom 'menu on_click' if MODE == 'menu'}
+
+  win.show
+end
+
+puts 'after start'

data/samples/test/cancel.rb

@@ -0,0 +1,53 @@
+# Manual check for Window_cancel_active_pointers and
+# reject_unpaired_up_pointers.
+#
+#   1. right click
+#        -> :cancel logged (down_id set), then the menu opens
+#   2. close the menu (click away or select), keep watching the log
+#        -> NO :up line for the canceled id must appear
+#   3. move the mouse
+#        -> the white dot follows (tracking alive)
+#   4. hold LEFT, then right click while holding
+#        -> :cancel logged for the left press, menu opens
+#      close the menu, release left
+#        -> NO :up for the left press
+#      press left again
+#        -> :down with a NEW id, then :up pairs with it as usual
+#   5. plain left clicks behave as before (:down then :up, ids advance)
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+Reflex.start do
+  menu = Reflex::Menu.new
+  item = menu.add Reflex::Menu.new('Hello')
+  item.on(:click) {puts "menu item clicked"}
+
+  win = Reflex::Window.new frame: [100, 100, 400, 300]
+  pos = nil
+
+  win.on(:pointer) do |e|
+    e.each do |p|
+      next if p.move? && p.down.nil?   # skip hover moves to keep the log readable
+      puts "%-7s id:%-3d down_id:%-5s buttons:%p pos:%s" % [
+        p.action, p.id, p.down&.id.inspect, p.types, p.position.to_a.map {_1.round}
+      ]
+    end
+    if e.move?
+      pos = e.position
+      win.redraw
+    end
+    menu.popup win.root, e.x, e.y if e.down? && e.right?
+  end
+
+  win.on(:draw) do |e|
+    e.painter.push fill: :white do
+      e.painter.ellipse pos.x - 5, pos.y - 5, 10, 10 if pos
+    end
+  end
+
+  win.show
+end

data/samples/test/color_picker.rb

@@ -0,0 +1,63 @@
+# Manual check for ColorPicker, the rest is in test_color_picker.rb.
+#
+#   ruby color_picker.rb
+#        -> press c to open the picker. the window background follows the
+#           picked color, and 'close' is printed when the picker closes
+#           macos:   the block is called on every change while the panel is open
+#           windows: the block is called once when the dialog is closed with ok
+#      a   toggle alpha, then press c again (macos only)
+#      d   open a second picker. on macos the first one prints 'close' at
+#           once because the shared panel moves to the second one
+#      q   quit
+#   ruby color_picker.rb raise
+#        -> the block raises. expect a ruby backtrace and status 1
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+
+RAISE = ARGV[0] == 'raise'
+
+at_exit {puts 'at_exit'}
+
+
+Reflex.start do
+  win     = Reflex::Window.new title: 'color_picker', frame: [100, 100, 480, 240]
+  pickers = 2.times.map do |i|
+    Reflex::ColorPicker.new(owner: win).tap do |picker|
+      picker.on(:close) {|e| puts "close #{i + 1}"}
+    end
+  end
+  color   = Reflex::Color.new 0.5, 0.5, 0.5
+
+  pick = -> picker do
+    picker.pick_color(color) do |c|
+      raise 'boom in the color block' if RAISE
+      color = c
+      win.redraw
+    end
+  end
+
+  win.on(:draw) do |e|
+    p = e.painter
+    p.fill color
+    p.rect e.bounds
+    p.fill 1
+    p.text "color: #{color}   alpha: #{pickers[0].alpha?}", 20, 30
+    p.text 'c: pick   d: pick with 2nd   a: toggle alpha   q: quit', 20, 60
+  end
+
+  win.on(:key_down) do |e|
+    case e.chars
+    when 'c' then pick.call pickers[0]
+    when 'd' then pick.call pickers[1]
+    when 'a' then pickers[0].alpha = !pickers[0].alpha?; win.redraw
+    when 'q' then Reflex.quit
+    end
+  end
+
+  win.show
+end

data/samples/test/file_dialog.rb

@@ -0,0 +1,102 @@
+# Manual check for FileDialog.
+#
+# Each key opens a dialog. The window logs what came back, newest first.
+# A dialog with an owner appears as a sheet on macos.
+#
+# Three things answer a selection: the block given to open_file and
+# friends, the on_file hook of the dialog, and the on_file hook of the
+# owner window, in that order. A hook does not cost the block its turn,
+# even though it hides the method the block used to be called from.
+#
+#   1. press 1 and pick a file
+#        -> 'block', 'dialog on_file' and 'window on_file_open' all log
+#           the path, in that order, the hook here costing nothing
+#   2. press 1 and cancel
+#        -> 'dialog on_cancel' logs, and no path is logged
+#   3. press 2 and pick more than one file
+#        -> every path is logged
+#   4. press 3
+#        -> only directories can be chosen, and files are greyed out
+#   5. press 4, type a name and save
+#        -> the path is logged, and 'window on_file_save' follows it
+#   6. press 5
+#        -> the dialog opens in the home directory
+#   7. press 6
+#        -> the name field is already filled with untitled.png
+#   8. press 7
+#        -> the dialog is a window of its own, not a sheet, and the log
+#           shows no 'window on_file_open': it has no owner
+#   9. press 1 and look at the file list
+#        -> only .png and .jpg files can be chosen, and folders stay open
+#  10. press 1 where a file is named in capitals, IMAGE.PNG say
+#        -> it can be chosen too, the extension is matched either case
+
+%w[xot rays reflex]
+  .map  {|s| File.expand_path "../../../#{s}/lib", __dir__}
+  .each {|s| $:.unshift s if !$:.include?(s) && File.directory?(s)}
+
+require 'reflex'
+
+
+KEYS = [
+  '1: open_file            2: open_files',
+  '3: open_directory       4: save_file',
+  '5: open_files in ~      6: save_file named untitled.png',
+  '7: open_files with no owner'
+]
+
+LOG = []
+
+def log(text)
+  LOG.unshift text
+  puts text
+end
+
+
+Reflex.start do
+  win = Reflex::Window.new title: 'FileDialog', frame: [100, 100, 560, 400]
+
+  # the event reaches the owner window too, after the dialog itself
+  win.on(:file_open) {|e| log "window on_file_open: #{e.paths}"}
+  win.on(:file_save) {|e| log "window on_file_save: #{e.path}"}
+
+  make = -> (title, owner: win) {
+    dialog = Reflex::FileDialog.new owner: owner, title: title do
+      extensions %w[png jpg]
+    end
+    # no super, and the block still runs: it is called from the wrapper,
+    # before this hook, rather than from the method this hook hides
+    dialog.on(:file)   {|e| log "dialog on_file: #{e.action} #{e.paths}"}
+    dialog.on(:cancel) {|e| log 'dialog on_cancel'}
+    dialog
+  }
+
+  win.on(:key_down) do |e|
+    case e.chars
+    when '1' then make['Open a file']     .open_file      {|path|  log "block: #{path}"}
+    when '2' then make['Open files']      .open_files     {|paths| log "block: #{paths}"}
+    when '3' then make['Open a directory'].open_directory {|path|  log "block: #{path}"}
+    when '4' then make['Save a file']     .save_file      {|path|  log "block: #{path}"}
+    when '5' then make['Open files in ~'] .open_files('~') {|paths| log "block: #{paths}"}
+    when '6'
+      make['Save as'].save_file(name: 'untitled.png') {|path| log "block: #{path}"}
+    when '7'
+      make['No owner', owner: nil].open_files {|paths| log "block: #{paths}"}
+    else next
+    end
+    log "-- #{e.chars}"
+  end
+
+  win.on(:draw) do |e|
+    p = e.painter
+    p.background 0.1, 0.1, 0.15
+    p.fill 1
+    KEYS.each_with_index {|text, i| p.text text, 10, 10 + i * 18}
+    p.fill 0.5, 1, 0.5
+    LOG.first(14).each_with_index {|text, i| p.text text, 10, 100 + i * 18}
+  end
+
+  win.on(:update) {|e| win.redraw}
+
+  win.show
+end