hypersonicplus 0.0.0

data/lib/hwidgets/htabview.rb

@@ -0,0 +1,84 @@
+require "hwidgets/hdivtag"
+
+class HTabView < HDivTag
+
+  def initialize(tabs, header = nil)
+    super("tabs")
+    @header = header
+    @tabs = tabs
+    
+  end
+
+  def newTab(tabName, tabCaption, selected = false)
+    className = "class='active'" if(selected)
+    return HIO.htmlEcholn("<li #{className}><a data-toggle='tab' href='##{tabName}'>#{tabCaption}</a></li>")
+  end
+
+  def newContain(tabName, text, selected = false)
+
+    active = "in active" if(selected)
+
+    containerDiv = HDivTag.new(class: "tab-pane fade #{active}")
+    containerDiv.set(id: tabName)
+    containerDiv.setInnerHTML(text)
+    return containerDiv.html()
+
+  end
+
+  def checkSelected()
+
+    isSelected = false
+    @tabs.each do |key, value|
+      if(value.key?(:selected))
+        isSelected = true
+        break
+      end
+    end
+    @tabs[@tabs.keys[0]][:selected] = true if(!isSelected) and @tabs.any?
+
+  end
+
+  def html()
+  
+    self.checkSelected() 
+
+    ul = HWidget.new("ul").set(class: "nav nav-tabs")
+    
+    content = ""
+    @tabs.each do |key, value|
+      tabName = key 
+      tabCaption = value[:tabCaption]
+      content += self.newTab(tabName, tabCaption, value[:selected] == true)
+    end    
+    ul.setInnerHTML(content)
+
+    content = HIO.htmlEcholn("<h3>#{@header}</h3>")
+
+    tabContentDiv = HDivTag.new(class: "tab-content")
+
+    @tabs.each do |key, value|
+      tabContain = value[:tabContain]
+      tabContain = tabContain.html() if(tabContain.class <= HWidget)
+      content += self.newContain(key, tabContain, value[:selected] == true)
+    end    
+    tabContentDiv.setInnerHTML(content)
+    self << ul << tabContentDiv
+    return super()
+
+  end
+
+  def self.test1()
+
+    tabs = { :tab1 => {:tabCaption =>"Tab 1", :tabContain => "Tab1 Contain"},
+             :tab2 => {:tabCaption =>"Tab 2", :tabContain => "Tab2 Contain"},
+             :tab3 => {:tabCaption =>"Tab 3", :tabContain => "Tab3 Contain", :selected => true},
+             :tab4 => {:tabCaption =>"Tab 4", :tabContain => "Tab4 Contain"},
+             :tab5 => {:tabCaption =>"Tab 5", :tabContain => "Tab5 Contain"},
+             :tab6 => {:tabCaption =>"Tab 6", :tabContain => "Tab6 Contain"},
+    }
+    return HTabView.new(tabs, "Tabs Controller").html() 
+
+  end
+
+
+end

data/lib/hwidgets/htextareatag.rb

@@ -0,0 +1,20 @@
+#!/usr/bin/env ruby
+
+require "hwidgets/hinputtag"
+
+class HTextAreaTag < HInputTag
+
+    attr_accessor
+
+    def initialize(name = "", modelName = "", placeholder = "", label = nil)
+      super(name, modelName, placeholder, label, nil)
+      @tag = "textarea"
+      @type = nil
+      self.setClosedTag()
+    end
+
+    def setSelected(value)
+      set(value: value) 
+    end
+
+end

data/lib/hwidgets/htopnav.rb

@@ -0,0 +1,85 @@
+class HTopNav < HDivTag
+
+    def initialize(items = [])
+     super(class: "hpriority-nav")
+     @items = items
+    end
+
+    def addItem(value)
+      @items << value
+      return self
+    end
+
+
+    def a(innerHTML = '', icon: nil, **args)
+      
+      a = HWidget.new("a", "", args)
+      a << HWidget.new('span', class: icon) if icon
+      a << HWidget.new('span', innerHTML)
+      return a
+
+    end
+
+    def html()
+      
+      @items.each do |value|
+        if(value[:type] == 'link')
+          self << self.a(value[:name], icon: value[:icon], href: value[:href])
+        elsif (value[:type].include? 'menu')
+          type = value[:type].sub('menu', '')
+          containerDiv = HDivTag.new(class: "#{type}container")
+          containerDiv  << self.a(value[:name], icon: value[:icon], class: "#{type}item")
+          self << containerDiv
+          menuDiv = HDivTag.new(class: 'menu')
+          value[:content].each do |menuValue|
+            menuDiv << self.a(menuValue[:name], icon: menuValue[:icon], href: menuValue[:href])
+          end
+          containerDiv << menuDiv
+        end
+      end
+      return super
+    end
+
+    def self.test1()
+
+      items = [
+        {type: 'link', name: 'QuickManager', href:'#quickmanager'},
+        {type: 'link', name: 'QuickOrder', href:'#quickorder'},
+        {type: 'link', name: 'Item3', href:'#3'},
+        {type: 'link', name: 'Item4', href:'#4'},
+        {type: 'link', name: 'Item5', href:'#5'},
+        {type: 'link', name: 'Item6', href:'#6'},
+        {type: 'link', name: 'Item7', href:'#7'},
+        {type: 'link', name: 'Item8', href:'#8'},
+        {type: 'link', name: 'Item9', href:'#9'},
+        {type: 'link', name: '', href:'#', icon: 'glyphicon glyphicon-user'},
+        {type: 'more-menu', name: 'More',  content: [] },
+        {type: 'other-menu', name: 'Administrator',  content: [{type: 'link', name: 'User', href:'#'}] }
+      ]
+      return HTopNav.new(items).html()
+
+    end
+    
+    def self.test2()
+
+      items = [
+        {type: 'link', href:'#', icon: 'glyphicon glyphicon-home'},
+        {type: 'link', name: 'Item1', href:'#1'},
+        {type: 'link', name: 'Item2', href:'#2'},
+        {type: 'link', name: 'Item3', href:'#3'},
+        {type: 'link', name: 'Item4', href:'#4'},
+        {type: 'link', name: 'Item5', href:'#5'},
+        {type: 'link', name: 'Item6', href:'#6'},
+        {type: 'link', name: 'Item7', href:'#7'},
+        {type: 'link', name: 'Item8', href:'#8'},
+        {type: 'link', name: 'Item9', href:'#9'},
+        {type: 'more-menu', name: '', icon: 'glyphicon glyphicon-menu-hamburger', 
+         content: [{type: 'link', name: 'moreItem', href:'#', icon: 'glyphicon glyphicon-refresh'}] },
+        {type: 'other-menu', name: 'Administrator', icon: 'glyphicon glyphicon-print',
+         content: [{type: 'link', name: 'User', href:'#', icon: 'glyphicon glyphicon-user'}] }
+      ]
+      return HTopNav.new(items).html()
+
+    end
+
+end

data/lib/hwidgets/hwidget.rb

@@ -0,0 +1,423 @@
+
+class HWidget
+
+    attr_reader :tag
+
+    def setTag(tag)
+      @tag = tag
+      return self
+    end
+    
+    def setProperties(properties)
+      @properties = properties
+      return self
+    end
+    
+    def setSystemProperties(systemProperties)
+      @systemProperties = systemProperties
+      return self
+    end
+    
+    def setPlaceholders(placeholders)
+      @placeholders = placeholders
+      return self
+    end
+    
+    def setInnerHTML(innerHTML)   
+      @innerHTML = innerHTML
+      return self
+    end
+    
+    def setParent(parent)   
+      @parent = parent
+      return self
+    end
+
+    def setChilds(childs)   
+      @childs = childs
+      return self
+    end
+    
+    def getChilds()   
+      return @childs
+    end
+    
+    def setStyles(styles)   
+      @styles = styles
+      return self
+    end
+
+    def setEnablePlaceholder(enablePlaceholder = true)   
+      @enablePlaceholder = enablePlaceholder
+      return self
+    end
+    
+    def setCloseTag(closeTag)   
+      @closeTag = closeTag
+      return self
+    end
+
+    def setSlots(slots)   
+      @slots = slots
+      return self
+    end
+
+    def initialize(tag = nil, innerHTML = "", **args)
+      @tag = tag
+      @properties = {}
+      @systemProperties = {}
+      @placeholders = {}
+      @innerHTML = innerHTML
+      @parent = nil
+      @childs = []
+      @styles = {}
+      @enablePlaceholder = false # va automaticamente a true con setPlaceholder
+      @closeTag = true # se false il tag non viene chiuso - serve ad es. per input
+      @slots = {}
+
+      self.set(args)
+
+    end
+ 
+    def copyConstructor
+      return Marshal.load(Marshal.dump(self))
+    end
+"""  
+    def method_missing(sym, *args)
+      if sym =~ /^(\w+)=$/
+        self.set($1, args[0])
+      else
+        return self.get(sym.to_s)
+      end
+    end
+"""    
+    # searchType 0: serch only among childs
+    # searchType 1: search top down starting from childs
+
+    def getElementBy(property, value, searchType)
+     
+      result = (self.properties.key?(property) and self.properties[properties] == value) ? [self] : nil
+      @childs.each do |child|
+        result << child if child.properties.key?(property) and child.properties[property] == value
+      end
+      @childs.each { |child| result += child.getElementBy(property, value, searchType) } if searchType == 1
+      return result
+
+    end
+
+    def appendChilds(widgets)
+      widgets.each { |widget| self.appendChild(widget) }
+      return self
+    end
+
+    def appendChild(widget)
+      return self.appendChilds(widget) if widget.class == Array
+      widget.setParent(self)
+      @childs << widget
+      return self
+    end
+    alias_method :<<, :appendChild
+
+    def unset(property)      
+        @properties.delete(property)
+    end
+
+    def _set(property, value, overwrite = false)      
+      @properties[property] = value if (!@properties.key?(property) || overwrite)
+      #@properties.delete(property) unless (value)
+      return self
+    end
+
+    # set property
+    def set(overwrite: false, **properties)
+        
+      properties.each do |property, value|
+        self._set(property, value, overwrite)
+      end
+      return self
+
+    end
+
+    def buildSignature(function, functionName, *args) 
+      
+      params = ['this']
+      args.each do |arg|
+        if(arg.class == Symbol)
+          params << arg # se passo un simbolo ad es. event
+        else
+          params << arg.to_js_format
+        end
+      end
+      return "#{function}#{functionName}(#{params.join(",")})"
+
+    end 
+
+
+    def addJsFunction(eventName, functionName, *args)      
+
+      function = ""
+      if(@properties[eventName])
+        function = "#{@properties[eventName]}; "
+      end
+      
+      function = self.buildSignature(function, functionName, *args)
+      
+      return self.set("#{eventName}": function, overwrite: true) 
+
+    end
+    
+    def storeSlots  
+    
+      @slots.each do |key, elem|
+        elem.each do |value|
+          self.addJsFunction(key, value[:functionName], *value[:args])
+        end
+      end
+
+    end
+    
+    # supporta piu' funzioni per lo stesso evento 
+    # @slots e' un hash di array di hash
+    def _addJsSlot(eventName, functionName, overwrite = false, *args)      
+
+      @slots.delete(eventName) if overwrite
+      @slots[eventName] = Array.new() unless(@slots[eventName])
+      @slots[eventName] << {functionName: functionName, args: args}
+      return self
+
+    end
+    
+    # addJsSlot is a very powerful function with many options. Example:
+    # - def self.myFunction(id) 
+    #    return "hello #{id}" 
+    # - end
+    # 1) addJsSlot(:ondblclick, :null, {}, "#id", "MyClass.myFunction") # the easiest example 
+    # 1) addJsSlot(:ondblclick, "id", {}, "#id", "MyClass.myFunction")  
+    #    WARNING: the first id is only the parameter passed to myFunction
+    #    i can write: addJsSlot(:ondblclick, "name", {}, "#id", "MyClass.myFunction")
+    #
+    # 2) tr.addJsSlot(:ondblclick, "id", {before: "alert('hello')"}, "#id", "HDBTableView.myFunction")
+    # 3) tr.addJsSlot(:ondblclick, "id", {after: "elem.style.color = 'red'; alert('hello')"}, "#id", "HDBTableView.myFunction")
+    # - def self.myFunction(values) 
+    #    return "hello #{values[:id]} - #{values[:class]}" 
+    # - end
+    # 4) tr.addJsSlot(:ondblclick, ["id", "class"], {}, "#id", "HDBTableView.myFunction")
+    #
+    # - def self.myFunction(id, surname) 
+    #    return "hello #{id]} - #{surname}" 
+    # - end
+    # 5) tr.addJsSlot(:ondblclick, "id", {}, "#id", "HDBTableView.myFunction", "Von Karajan")
+    #
+    # - def self.myFunction(id, values) 
+    #    return "hello #{id]} - #{values[:name]} - #{values[:surname]}" 
+    # - end
+    # 6) tr.addJsSlot(:ondblclick, "id", {}, "#id", "HDBTableView.myFunction", {name: "herbert", surname: "Von Karajan"})
+    #
+    # - def self.myFunction(id, values, array) 
+    #    return "hello #{id} - #{values[:name]} - #{values[:surname]} - #{array}" 
+    # - end
+    # 7) tr.addJsSlot(:ondblclick, "id", {}, "#id", "HDBTableView.myFunction", {name: "herbert", surname: "Von Karajan"}, [1,2,3,4,5])
+    # 8) addJsSlot(:ondblclick, ':obj.value', {}, "#id", "MyClass.myFunction") #  # mettendo i : il codice js sara' => values = eval('obj.value');
+
+
+    # 1) In this example the element with id = #id is replaced by "hello #{value}"
+    #    Warning: if i want replaced the element with name = 'pippo' i must write:
+    #    - addJsSlot(:ondblclick, "id", {getElem: "byName"}, "pippo", "MyClass.myFunction") 
+    #    - addJsSlot(:ondblclick, "id", {getElem: "byName", mode: "set"}, "pippo", "MyClass.myFunction")
+    #    other options are: getElem: byId | byName | body - mode: set | add
+    # 2) The same of the previous with alert('hello') at end
+    # 3) The same of the previous with the change the color at end
+
+    # id deve essere un oid
+    def connect(event, receiver, method, attributes: :null, id: "#id", args: nil, overwrite: false, **options)      
+      oid = hm().malloc({receiver: receiver, method: method, args: args}, id).obj.object_id.to_s
+      options[:getElem] = "byId" unless options[:getElem]
+      options[:mode] = "set" unless options[:mode]
+
+      cks = Digest::SHA256.hexdigest oid + hc.value("secret_token")
+      cks += "-" + Time.now.to_i.to_s # serve (forse) in caso di riallocazione dello stesso indirizzo di memoria
+      hotLog( "HWidget::connect(id: #{id}, oid: #{oid} - #{options[:hotLog].green}" ) if options[:hotLog]
+      return self._addJsSlot(event, :'return hajax.signalManager', overwrite, attributes, options, id, oid, cks)
+    end
+
+    def get(property)      
+        return @properties[property]
+    end
+
+    def replacePlaceholder(str)
+
+      return str unless @enablePlaceholder
+      @placeholders.each do |key, value|
+        str = str.gsub(key, value.to_s)
+      end
+   
+      return str
+
+    end
+
+    def hotLog(str)
+      HHotLogger.append(str, "log4widgets")
+    end
+
+    def strProperties() 
+
+      propertiesTmp = Marshal.load(Marshal.dump(@properties))
+      self.storeSlots()
+      self.storeStyle()
+      return "" if @properties.empty?
+
+      result = ""
+      @properties.each do |key, value| 
+        if(value)
+          value = self.replacePlaceholder(value)
+          result += "#{key}=\"#{value}\" "
+        else
+          result += "#{key} "
+        end
+      end
+
+      @properties = propertiesTmp
+      return result
+
+    end
+
+    def openTag()
+      
+      return "" unless (@tag)
+
+      slash = (@closeTag) ? "" : "/"
+      result = self.strProperties()
+      return HIO.htmlEcholnOpenBlock("<#{@tag} #{result}#{slash}>")
+
+    end
+
+    def closeTag()
+      return "" unless (@tag)
+      return (@closeTag) ? HIO.htmlEcholnCloseBlock("</#{@tag}>") : ""
+    end
+
+    def reset()
+      @parent = nil
+      @childs = []
+    end
+
+    def html() 
+      
+      html = @innerHTML
+      @childs.each { |child| html += child.html() }
+      return self.openTag() + HIO.htmlEcholn(html) + self.closeTag()  
+
+    end
+    
+    def _setStyle(property, value)
+  
+      unless (value)
+        @styles.delete(property)
+        return self
+      end
+      @styles[property] = value
+      return self
+
+    end
+    
+    # set style  
+    def setStyle(**properties)
+      properties.each do |property, value|
+        self._setStyle(property, value)
+      end
+      return self
+    end
+
+    def storeStyle() 
+
+      return "" if @styles.empty?
+
+      result = ""
+      @styles.each do |key, value| 
+        result += "#{key}:#{value}; "
+      end
+
+      self.set(style: result)
+
+    end
+
+    def setPlaceholder(placeholder, value)
+
+      @enablePlaceholder = true
+      unless (value)
+        @placeholders.delete(placeholder)
+        return self
+      end
+      @placeholders[placeholder] = value
+      return self
+
+    end
+
+    def setSystemProperty(property, value)      
+        unless (value)
+          @systemProperties.delete(property)
+          return self
+        end
+        @systemProperties[property] = value
+        return self
+    end
+
+    def getSystemProperty(property)      
+        return @systemProperties[property]
+    end
+
+    def setClosedTag(bool=true)
+      @closeTag = bool
+      return self
+    end
+    
+    def self.test()
+      widget = HWidget.new('div', "new_div")
+      widget.set(title1: 't1', 
+                 title2: 't2',
+                 title3: 't3',
+                 title4: '')
+      widget.set(title2: nil)
+      widget.setStyle(color: 'red')
+      puts widget.openTag
+      puts widget.html
+      puts widget.closeTag
+    end
+
+
+  def self.widgetSpace()
+    
+    puts "###########################################################".hight_white
+    puts "#                                                         #".hight_white
+    puts "#                 Hypersonic Object Space                 #".hight_white
+    puts "#                                                         #".hight_white
+    puts "###########################################################".hight_white
+
+    objs = []
+    ObjectSpace.each_object() {|obj| objs << obj if obj.class <= HWidget }
+    objs.each do |obj|
+      puts "#{obj.object_id.to_s.hight_purple}: #{obj.class.to_s.yellow} - #{obj.tag.hight_cyan} #{obj.get(:class)}" 
+    end
+    
+    #puth ObjectSpace.count_objects
+
+    return "Total Widgets: #{objs.length}".green
+
+  end
+
+
+end
+
+def htag(name, properties)
+
+  return HWidget.new(name).set(properties).html()
+
+end
+
+def htag2(name, properties)
+
+  return HWidget.new(name).set(properties).setClosedTag(false).html()
+
+end
+
+