Module: Flammarion::Writeable

Included in:
Engraving, Pane
Defined in:
lib/flammarion/writeable.rb

Defined Under Namespace

Classes: DeferredValue

Instance Attribute Summary collapse

Instance Method Summary collapse

Instance Attribute Details

#engraving ⇒ Object (readonly)

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



4
5
6
 
# File 'lib/flammarion/writeable.rb', line 4

def engraving
  @engraving
end

Instance Method Details

#break(options = {}) ⇒ Object

Adds a horizontal rule



281
282
283
 
# File 'lib/flammarion/writeable.rb', line 281

def break(options = {})
  send_json({action:'break'}.merge(options))
end

#button(label, options = {}, &block) ⇒ Object

Adds a clickable button which will call block when clicked

Parameters:

  • label (String) —

    The text of the button

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :inline (Boolean) — default: false —

    If true, creates a small button embedded in the text. If false, creates a button that spans the width of the writeable area.

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



141
142
143
144
145
146
 
# File 'lib/flammarion/writeable.rb', line 141

def button(label, options = {}, &block)
  id = @engraving.make_id
  send_json({action:'button', label:label, id:id}.merge(options))
  @engraving.callbacks[id] = block
  id
end

#button_box ⇒ Pane #button_box(name) ⇒ Object

Pops up a little floating writeable pane for buttons and stuff.

Overloads:



450
451
452
453
 
# File 'lib/flammarion/writeable.rb', line 450

def button_box(name = "buttonbox")
  send_json({action:'buttonbox', name:name})
  return Pane.new(@engraving, name)
end

#callback_link(label, options = {}, &block) ⇒ Object

Note:

Don't forget to set the :escape_html option to false when including this string.

Creates a string representing a hyperlink that when clicked will call the given block. The string can be included in text for text-accepting methods (such as #puts, #table, etc).

Parameters:

  • label (String) —

    The text to become the link

Returns:

  • a string representing the html for the link.



164
165
166
167
168
 
# File 'lib/flammarion/writeable.rb', line 164

def callback_link(label, options = {}, &block)
  id = @engraving.make_id
  @engraving.callbacks[id] = block
  %|<a href="#" onClick="$ws.send({id:'#{id}', action:'callback', source:'link'})">#{label}</a>|
end

#checkbox(label, options = {}) ⇒ DeferredValue #checkbox(label, options = {}) {|message_hash| ... } ⇒ Object

Creates a new checkbox which the user can click.

Overloads:

  • #checkbox(label, options = {}) ⇒ DeferredValue

    Returns An object representing the current value of the checkbox. Use #checked? to get the state of the checkbox.

    Returns:

    • (DeferredValue) —

      An object representing the current value of the checkbox. Use #checked? to get the state of the checkbox.

  • #checkbox(label, options = {}) {|message_hash| ... } ⇒ Object

    Yields:

    • (message_hash) —

      Invokes the block every time the checkbox is toggled. Use the “checked” field of message_hash to get the new state of the checkbox.

Parameters:

  • label (String) —

    The placeholder text for the input

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



267
268
269
270
271
272
273
274
275
276
277
278
 
# File 'lib/flammarion/writeable.rb', line 267

def checkbox(label, options = {}, &block)
  id = @engraving.make_id
  send_json({action:'checkbox', label:label, id:id}.merge(options))
  if block_given?
    @engraving.callbacks[id] = block
  else
    d = DeferredValue.new
    d.__setobj__(options[:value] || options['value'])
    @engraving.callbacks[id] = Proc.new {|v| d.__setobj__(v["checked"])}
    return d
  end
end

#clear ⇒ Object

Clears the contents of the writeable area



96
97
98
99
 
# File 'lib/flammarion/writeable.rb', line 96

def clear
  send_json({action:'clear'})
  return nil
end

#close ⇒ Object

Closes the pane or window



102
103
104
105
 
# File 'lib/flammarion/writeable.rb', line 102

def close
  send_json({action:'closepane'})
  return nil
end

#dropdown(items, options = {}) ⇒ DeferredValue #dropdown(item, options = {}) {|message_hash| ... } ⇒ Object

Creates a dropdown menu for a user to choose a list of options

Overloads:

  • #dropdown(items, options = {}) ⇒ DeferredValue

    Returns An object representing the currently selected item, which can be retrieved using Flammarion::Writeable::DeferredValue#value

    Returns:

  • #dropdown(item, options = {}) {|message_hash| ... } ⇒ Object

    Yields:

    • (message_hash) —

      Invokes the block every time the user selects a different option. Current item text can be obtained from the “text” key of the message_hash

Parameters:

  • items (Array<#to_s>) —

    The possible choices



243
244
245
246
247
248
249
250
251
252
253
254
255
 
# File 'lib/flammarion/writeable.rb', line 243

def dropdown(items, options = {}, &block)
  id = @engraving.make_id
  send_json({action:'dropdown', id:id, options:items}.merge(options))
  if block_given?
    @engraving.callbacks[id] = block
  else
    d = DeferredValue.new
    d.__setobj__(items[0]) if items.is_a? Array
    d.__setobj__(items[items.keys.first]) if items.is_a? Hash
    @engraving.callbacks[id] = Proc.new {|v| d.__setobj__ v["value"]}
    return d
  end
end

#embedded_button(label, options = {}, &block) ⇒ Object

Note:

Don't forget to set the :escape_html option to false when including this string.

Creates a string representing a button will call the given block when it is clicked. The string can be included in text for text-accepting methods (such as #puts, #table, etc).

Parameters:

  • label (String) —

    The label on the button

Returns:

  • A string representing the html for the button.



153
154
155
156
157
 
# File 'lib/flammarion/writeable.rb', line 153

def embedded_button(label, options = {}, &block)
  id = @engraving.make_id
  @engraving.callbacks[id] = block
  %|<a class="floating-button" href="#" onClick="$ws.send({id:'#{id}', action:'callback', source:'embedded_button'})">#{label}</a>|
end

#emoji ⇒ Object

Returns the list of currently installed emoji from Emojione



533
534
535
536
 
# File 'lib/flammarion/writeable.rb', line 533

def emoji
  @@emoji ||= JSON.parse(File.read(File.join(File.dirname(__FILE__), "../html/build/javascripts/vendor/emojione.js")).each_line.find{|l| l.start_with?("    ns.emojioneList")}.scan(/= (\{[^;]+);/).flatten.first)
  return @@emoji
end

#gets(prompt = "", options = {}) ⇒ String

Prompts the user for a sting. Blocks until a string has been entered.

Parameters:

  • prompt (String) (defaults to: "") —

    A prompt to tell the user what to input.

  • options (defaults to: {}) —

    Same as #input

Returns:

  • (String) —

    The text that the user has entered.

See Also:



486
487
488
489
490
491
 
# File 'lib/flammarion/writeable.rb', line 486

def gets(prompt = "", options = {})
  str = nil
  input(prompt, {once:true, focus:true}.merge(options)) {|msg| str = msg["text"]}
  sleep 0.1 while str.nil?
  return str
end

#hide ⇒ Object

Hides (but doesn't close) the pane. This allows the pane to be written to without it opening up again.

See Also:



384
385
386
 
# File 'lib/flammarion/writeable.rb', line 384

def hide
  send_json({action:'hidepane'})
end

#highlight(data, options) ⇒ Object #highlight(text, options) ⇒ Object

Adds a pretty-printed, colorful display of data or code

Overloads:

  • #highlight(data, options) ⇒ Object

    Adds a pretty-printed, highlighted display of data

    Parameters:

    • text (Hash, Array) —

      A dataset to be displayed

    Options Hash (options):

    • :raw (Boolean) — default: false —

      Perform no escaping at all.

    • :colorize (Boolean) — default: true —

      Translate ANSI color escape codes into displayable colors.

    • :escape_html (Boolean) — default: true —

      Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

    • :escape_icons (Boolean) — default: false —

      If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)

  • #highlight(text, options) ⇒ Object

    Adds syntax-highlighted code to the writeable area

    Parameters:

    • text (String) —

      Code to be highlighed

    Options Hash (options):

    • :raw (Boolean) — default: false —

      Perform no escaping at all.

    • :colorize (Boolean) — default: true —

      Translate ANSI color escape codes into displayable colors.

    • :escape_html (Boolean) — default: true —

      Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

    • :escape_icons (Boolean) — default: false —

      If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



128
129
130
131
132
133
 
# File 'lib/flammarion/writeable.rb', line 128

def highlight(text, options = {})
  output = text
  output = JSON.pretty_generate(text) if text.is_a? Hash or text.is_a? Array
  send_json({action:'highlight', text:output}.merge(options))
  nil
end

#html(data) ⇒ Object

Renders raw html into the writeable area



286
287
288
 
# File 'lib/flammarion/writeable.rb', line 286

def html(data)
  send_json({action:'replace', text:data, raw:true})
end

#icon(name, additional_classes = []) ⇒ Object

Note:

Don't forget to set the :escape_html option to false when including this string.

Creates a string representing a emoji or Font Awesome icon. The string can be included in text for text-accepting methods (such as #puts, #table, etc).

Parameters:

  • name (String) —

    The name of a Font Awesome icon class. See

See Also:



175
176
177
178
179
180
181
182
 
# File 'lib/flammarion/writeable.rb', line 175

def icon(name, additional_classes = [])
  e = emoji[":#{name}:"]
  if e.nil? then
    return %|<i class="fa fa-#{name} #{additional_classes.collect{|c| "fa-#{c}"}.join(" ")}"></i>|
  else
    return %|<img class="emoji" alt="#{name}" src="images/emoji/#{e['unicode'].last.downcase}.png">|
  end
end

#image(url, options = {}) ⇒ Object 



184
185
186
 
# File 'lib/flammarion/writeable.rb', line 184

def image(url, options = {})
  puts(%|<img src="#{url}">|, {escape_html: false}.merge(options))
end

#input(label, options = {}) ⇒ DeferredValue #input(label, options = {}) {|message_hash| ... } ⇒ Object

Creates a new text-input field into which the user can enter text. If a block is given, the block will be called when ever the text is changed. If a block is not given, it will return a DeferredValue object which can be used to get the value at any time.

Overloads:

  • #input(label, options = {}) ⇒ DeferredValue

    Returns An object representing the current value of the input, which can be converted to text using #to_s.

    Returns:

    • (DeferredValue) —

      An object representing the current value of the input, which can be converted to text using #to_s.

  • #input(label, options = {}) {|message_hash| ... } ⇒ Object

    Yields:

    • (message_hash) —

      Invokes the block every time the text changes. The new text of the input can be obtained from the “text” key of the message_hash.

Parameters:

  • label (String) —

    The displayed placeholder text for the input. This does not set the actual value of the input field or the returned DeferredValue. Use the :value option for that.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :multiline (Boolean) — default: false —

    Creates a large text box if true; otherwise creates a single line input box.

  • :password (Boolean) — default: false —

    Creates a password input text box if true; otherwise creates a normal single line input box.

  • :autoclear (Boolean) — default: false —

    Automatically clears the input field every time the user changes the value. The callback will only be called for user initiated changes, not for auto-clear changes.

  • :history (Boolean) — default: false —

    Keeps track of entered values, letting the user choose betwen them with the up and down keys.

  • :value (String) —

    Sets the starting value of the field and the returned DeferredValue.

  • :once (Boolean) — default: false —

    If true, then the input box will be converted into a normal line of text once the user has changed it. The callback will still be called, but the user will no longer be able to change the text.

  • :keep_label (Boolean) — default: false —

    If :once is also set, this will prepend label when converting the input to plain text.

  • :enter_only (Boolean) — default: false —

    Only accept the users input when the enter key is pressed, not merely when it changes.



221
222
223
224
225
226
227
228
229
230
231
232
 
# File 'lib/flammarion/writeable.rb', line 221

def input(label, options = {}, &block)
  id = @engraving.make_id
  send_json({action:'input', label:label, id:id}.merge(options))
  if block_given?
    @engraving.callbacks[id] = block
  else
    d = DeferredValue.new
    d.__setobj__(options[:value] || options['value'])
    @engraving.callbacks[id] = Proc.new {|v| d.__setobj__ v["text"] }
    return d
  end
end

#js(text, options = {}, &block) ⇒ Object 



310
311
312
 
# File 'lib/flammarion/writeable.rb', line 310

def js(text, options = {}, &block)
  script(text, options.merge(coffee:false), &block)
end

#live_reload_template(file) ⇒ Object

Reloads a template every time the file changes. This is mostly just useful when developing a template file.

See Also:



357
358
359
 
# File 'lib/flammarion/writeable.rb', line 357

def live_reload_template(file)
  FileWatcher.new(file).watch {|file| template(file) }
end

#map(options) ⇒ Object #map(address, options = {}) ⇒ Object #map(latitude, longitude, options = {}) ⇒ Object

Note:

Street map provided by openstreetmap.org

Adds an interactive street map of a specified location.

Overloads:

  • #map(address, options = {}) ⇒ Object

    Parameters:

    • address (String) —

      The address or landmark to look up and display.

  • #map(latitude, longitude, options = {}) ⇒ Object

    Parameters:

    • latitude (Float) —

      The latitude to display

    • longitude (Float) —

      The longitude to display

Parameters:

  • options (Hash) —

    a customizable set of options



505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
 
# File 'lib/flammarion/writeable.rb', line 505

def map(*args)
  case (args.size)
  when 1
    if args[0].respond_to? :keys then
      options = args[0]
    else
      options = {address:args[0].to_s}
    end
  when 2
    if args[1].respond_to? :keys then
      options = {address:args[0]}.merge(args[1])
    else
      options = {latitude:args[0], longitude:args[1]}
    end
  when 3
    options = {latitude:args[0], longitude:args[1]}.merge(args[2])
  else
    raise ArgumentError.new("Expected 1..3 arguments")
  end
  send_json({action:'map'}.merge(options))
end

#markdown(text, options = {}) ⇒ Object

Renders the given markdown text into the pane.

Parameters:

  • text (String) —

    The markdown text to render.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :markdown_extensions (Hash) —

    Additional Redcarpet extensions to enable.



366
367
368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'lib/flammarion/writeable.rb', line 366

def markdown(text, options = {})
  if defined?(Redcarpet::Markdown) then
    markdown_html = Redcarpet::Markdown.new(Redcarpet::Render::HTML, {
      tables: true,
      fenced_code_blocks: true,
      autolink: true,
      strikethrough: true,
      superscript: true,
    }.merge(options[:markdown_extensions] || {})).render(text)
  else
    markdown_html = Kramdown::Document.new(text, {input: 'GFM', hard_wrap: false, syntax_highlighter: nil}.merge(options)).to_html
  end
  send_json({action:'markdown', text: markdown_html, hard_wrap:false}.merge(options))
end

#orientation=(orientation) ⇒ Object

Note:

This applies only to panes, not to subpanes.

Changes the orientation of the panes within this Writeable area. If orientation is :vertical (the default), the panes will be stacked on top of each other, each occupying 1/nth of the height (where n is the number of panes) and 100% of the width. If orientation is :horizontal, the panes will be placed next to each other, with each pane occupying 1/n of the width (where n is the number of panes) and 100% of the heigh.

Parameters:

  • orientation (Symbol) —

    can be :horizontal or :vertical

Raises:

  • ArgumentError if the orientation is not one of the allowed values

See Also:



440
441
442
443
 
# File 'lib/flammarion/writeable.rb', line 440

def orientation=(orientation)
  raise ArgumentError.new("Orientation must be :horizontal or :vertical") unless [:horizontal, :vertical].include?(orientation)
  send_json({action:'reorient', orientation:orientation})
end

#pane(name, options = {}) ⇒ Pane

Note:

The difference between pane and subpane is that a pane is automatically scaled depending on the number of other panes and the current orientation, while subpanes are automatically the size of their contents. Another way to think about it might be that pane creates structural layout elements, while subpane creates embedded sections within other panes.

Creates a scaled pane within the current writeable area. Where it goes depends on the orientation.

Parameters:

  • name (String) —

    an identifier for the subpane. All panes and subpanes share the same scope, so you want to be careful with your naming.

Returns:

  • (Pane) —

    The newly created or already existing pane.

See Also:



425
426
427
428
 
# File 'lib/flammarion/writeable.rb', line 425

def pane(name, options = {})
  send_json({action:'addpane', name:name}.merge(options))
  return Pane.new(@engraving, name)
end

#plot(data, options = {}) ⇒ Object

Creates a new plot to display data. Uses Plotly javascript library for plotting, options are passed directly to Plotly, so all types of plots and options are supported.

See Also:

  • Plot.plot


112
113
114
115
116
117
 
# File 'lib/flammarion/writeable.rb', line 112

def plot(data, options = {})
  id = @engraving.make_id
  p = Plot.new(id, @pane_name, @engraving)
  p.plot(data, options)
  return p
end

#puts(str = "", options = {}) ⇒ Object

Adds text to the writeable area and appends a newline.

Parameters:

  • str (String) (defaults to: "") —

    The text to append

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



81
82
83
84
85
 
# File 'lib/flammarion/writeable.rb', line 81

def puts(str = "", options = {})
  send str, options
  send "\n"
  return nil
end

#replace(str, options = {}) ⇒ Object

Replaces the contents of the writeable area with text

Parameters:

  • str (String) —

    The text to append

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



90
91
92
93
 
# File 'lib/flammarion/writeable.rb', line 90

def replace(str, options = {})
  send_json({action:'replace', text:str}.merge(options))
  return nil
end

#script(text, options = {}, &block) ⇒ Object

Runs a script in the engraving window.

Parameters:

  • text (String) —

    The script to run. Lanuage of the script depends on the options given. Defaults to CoffeeScript

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :coffee (Boolean) — default: true —

    If true, will compile text from CoffeeScript to JavaScript. If false, will pass text as plain JavaScript



295
296
297
298
299
300
301
302
303
304
305
306
307
308
 
# File 'lib/flammarion/writeable.rb', line 295

def script(text, options = {}, &block)
  return script_src(text) if !options.fetch(:no_file, false) && File.exist?(text)
  data = options.fetch(:coffee, true) ? CoffeeScript.compile(text) : text
  id = @engraving.make_id
  d = nil
  if block_given?
    @engraving.callbacks[id] = block
  else
    d = DeferredValue.new
    @engraving.callbacks[id] = Proc.new {|v| d.__setobj__(v["result"])}
  end
  send_json({action:'script', data:data, id: id}.merge(options))
  return d
end

#script_src(src) ⇒ Object 



314
315
316
317
318
319
320
 
# File 'lib/flammarion/writeable.rb', line 314

def script_src(src)
  if File.exist?(src) then
    html("<script>#{File.read(src)}</script>")
  else
    html("<script src='#{src}'></src>")
  end
end

#search(string) ⇒ Object

Searches for and highlights the string in the engraving.



528
529
530
 
# File 'lib/flammarion/writeable.rb', line 528

def search(string)
  send_json({action:'search', text: string})
end

#send(str, options = {}) ⇒ Object Also known as: print

Adds text to the writeable area without appending a newline.

Parameters:

  • str (String) —

    The text to append

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)



73
74
75
 
# File 'lib/flammarion/writeable.rb', line 73

def send(str, options = {})
  @engraving.send_json({action:'append', text:str, target:@pane_name}.merge(options))
end

#send_json(hash) ⇒ Object

This method is part of a private API. You should avoid using this method if possible, as it may be removed or be changed in the future. 



66
67
68
 
# File 'lib/flammarion/writeable.rb', line 66

def send_json(hash)
  @engraving.send_json({target: @pane_name}.merge(hash))
end

#show ⇒ Object

Shows a hidden pane.

See Also:



390
391
392
 
# File 'lib/flammarion/writeable.rb', line 390

def show
  send_json({action:'showpane'})
end

#status(str, position) ⇒ Object #status(str, options = {}) ⇒ Object

Displays a message to the bottom status bar.

Overloads:

  • #status(str, position) ⇒ Object

    Parameters:

    • position (Symbol) —

      Where to put it. May be :left or :right

  • #status(str, options = {}) ⇒ Object

    Options Hash (options):

    • :position (Symbol) —

      Where to put it. May be :left or :right

Parameters:

  • str (String) —

    The message to display



462
463
464
465
 
# File 'lib/flammarion/writeable.rb', line 462

def status(str, options = {})
  options = {position: options} if options.is_a? Symbol
  @engraving.send_json({action:'status', text: str}.merge(options))
end

#style(attribute, value) ⇒ Object #style(attributes) ⇒ Object

Sets CSS styles attributes on the current pane.

Overloads:

  • #style(attribute, value) ⇒ Object

    Parameters:

    • attribute (String) —

      The css attribute to set. Currently does not support selectors or anything.

    • value (#to_s) —

      The value to set the attribute to. (Don't forget units!)

  • #style(attributes) ⇒ Object

    Parameters:

    • attributes (Hash) —

      Table of css attribute to value mapping to set.



330
331
332
333
334
335
336
337
338
339
340
 
# File 'lib/flammarion/writeable.rb', line 330

def style(*args)
  case args.length
  when 1
    # @todo Pass this as a whole hash, rather than individually.
    args[0].each{|a,v| send_json({action: 'style', attribute: a, value: v})}
  when 2
    send_json({action: 'style', attribute: args[0], value: args[1]})
  else
    raise ArgumentError.new("Invalid number of arguments (Expected 1 or 2)")
  end
end

#subpane(name, options = {}) ⇒ Pane

Note:

The difference between pane and subpane is that a pane is automatically scaled depending on the number of other panes and the current orientation, while subpanes are automatically the size of their contents. Another way to think about it might be that pane creates structural layout elements, while subpane creates embedded sections within other panes.

Creates a writeable area within the current writeable area. This lets you update the contents of the writeable later, without disturbing the rest of the curent pane. If a pane or subpane with the given name already exists, it will just use that one instead.

Parameters:

  • name (String) —

    an identifier for the subpane. All panes and subpanes share the same scope, so you want to be careful with your naming.

Returns:

  • (Pane) —

    The newly created or already existing pane.

See Also:



412
413
414
415
 
# File 'lib/flammarion/writeable.rb', line 412

def subpane(name, options = {})
  send_json({action:'subpane', name:name}.merge(options))
  return Pane.new(@engraving, name)
end

#table(rows, options = {}) ⇒ Object

Displays a table of data

Parameters:

  • rows (Array<Array<#to_s>>) —

    an array of rows, where each row is an array of objects which will be converted to a string and diplayed in the table.

  • options (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (options):

  • :raw (Boolean) — default: false —

    Perform no escaping at all.

  • :colorize (Boolean) — default: true —

    Translate ANSI color escape codes into displayable colors.

  • :escape_html (Boolean) — default: true —

    Renders any html tags as plain text. If false, allows any arbitrary html to be rendered in the writeable area.

  • :escape_icons (Boolean) — default: false —

    If true, will translate any text between two `:` into a font-awesome icon or emoji (E.g. :thumbs-up:)

  • :headers (Array<#to_s>) —

    An array of column headers to put at the top of the table.

  • :interactive (Boolean) — default: true —

    Allows the user to mouse over the table and have it styled. Set to false if you experience performance issues with large datasets.



477
478
479
 
# File 'lib/flammarion/writeable.rb', line 477

def table(rows, options = {})
  send_json({action:'table', rows: rows}.merge(options))
end

#template(file) ⇒ Object

Note:

If you just want to include html (or outut from another template engine, you can just use #html)

Will render the given Slim template into the Writeable area. This is useful for creating complex or custom application layouts components beyond what's built into Flammarion.

Parameters:

  • file (String) —

    Path to the Slim file to render

See Also:



349
350
351
352
 
# File 'lib/flammarion/writeable.rb', line 349

def template(file)
  data = Slim::Template.new(file).render
  send_json({action:'replace', text:data, raw:true})
end