heart 0.0.1.pre

data/app/controllers/heart/dashboards_controller.rb

@@ -0,0 +1,85 @@
+require_dependency "heart/application_controller"
+
+module Heart
+  class DashboardsController < ApplicationController
+
+    def default
+    end
+    
+    def index
+      @dashboards = Heart::Dashboard.active.all
+    end
+
+    def show
+      @dashboard = Heart::Dashboard.find(params[:id])
+      @charts = ActiveSupport::JSON.decode(@dashboard.dashboard)
+    end
+    
+    def new
+    end
+
+    def create
+      dashboard = Heart::Dashboard.new()
+      dashboard.title = params[:title]
+      dashboard.dashboard = params[:charts_serialized]
+      dashboard.save
+      redirect_to dashboards_path
+    end
+
+    def edit
+      @dashboard = Heart::Dashboard.find(params[:id])
+    end
+
+    def update
+      dashboard = Heart::Dashboard.find(params[:id])
+      dashboard.title = params[:title]
+      dashboard.description = params[:description]
+      dashboard.dashboard = params[:charts_serialized]
+      dashboard.date_from = params[:date_from]
+      dashboard.save
+      redirect_to dashboards_path
+    end
+
+    def archive
+      dashboard = Heart::Dashboard.where(id: params[:dashboard_id]).first
+      dashboard.status = Heart::Dashboard::INACTIVE
+      dashboard.save
+      redirect_to dashboards_path
+    end
+
+    def flotit
+      params[:date_from] ||= 30.days.ago.to_s
+      params[:date_to] ||= 1.days.ago.to_s     
+      @annotations = Heart::Annotation.visible(:from => params[:date_from], :to => params[:date_to])
+      @description = Heart::Annotation.where(id: params[:description]).first.note if params[:description].to_i > 0
+      
+      # THE WHERE
+      where = "WHERE fulldate >= '"+params[:date_from]+"' AND fulldate <= '"+params[:date_to]+"'"
+      # THE GROUPBY
+      groupby = ""
+      if !params[:group_by].empty?
+        counter = 0
+        params[:group_by].each do |value|
+          groupby += "," if counter >= 1
+          groupby += " " + value
+          counter += 1
+        end
+      end
+      groupby = nil if groupby.empty?
+      # THE MEASUREMENTS
+      measurements = params[:measurements].empty? ? false : params[:measurements]
+      
+      @metrics = Hash.new
+      if params[:moving_averages].kind_of?(Array)
+        params[:moving_averages].each do |y|
+          if(params[:method_sum] == "true")
+            @metrics[y.to_s] = Heart::Metric.aggregate_daily_sums(y, where, groupby, measurements)
+          else
+            @metrics[y.to_s] = Heart::Metric.aggregate_daily_moving_averages(y, where, groupby, measurements)
+          end
+        end
+      end
+    end
+    
+  end
+end

data/app/controllers/heart/images_controller.rb

@@ -0,0 +1,19 @@
+require_dependency "heart/application_controller"
+
+module Heart
+  class ImagesController < ApplicationController
+    def create
+      image = Heart::Image.new
+      image.dashboard_id = params[:dashboard_id]
+      image.purpose = params[:purpose]
+      image.dataurl = params[:dataurl]
+      image.save
+      render :json => { :result => 'success', :id => image.id }
+    end
+
+    def show
+      image = Heart::Image.find(params[:id])
+      send_data Base64.decode64(image.dataurl.split(",")[1]), :type => 'image/png', :disposition => 'inline'
+    end
+  end
+end

data/app/controllers/heart/metrics_controller.rb

@@ -0,0 +1,35 @@
+require_dependency "heart/application_controller"
+
+module Heart
+  class MetricsController < ApplicationController
+
+    def index
+      @metrics = Heart::Metric.recently_added
+    end
+
+    def show
+      #restrict the range of dates to prevent a lot useless metric records
+      params[:fulldate] = Date.yesterday unless params[:fulldate] <= Date.yesterday.to_s
+      @metric = Heart::Metric.find_or_create(params[:fulldate],0)
+      @isometric = Heart::Isometric.find_or_create(params[:fulldate],0)
+    end
+
+    def fetch
+      method = "fetch_" + params[:attribute].to_s
+      params[:enddate] = (params[:enddate].nil?) ? params[:fulldate] : params[:enddate]
+      startdate = Date.parse(params[:fulldate].to_s)
+      enddate = Date.parse(params[:enddate].to_s)
+      startdate.upto(enddate) do |date|
+        @metric = Heart::Metric.find_or_create(date,0)
+        isometric = Heart::Isometric.find_or_create(date,0)
+
+        @metric.send(method)
+
+        @metric.save
+        isometric.send(params[:attribute.to_s]+"=", Time.now) unless method == "fetch_all"
+        isometric.save unless method == "fetch_all"
+      end
+    end
+    
+  end
+end

data/app/helpers/heart/application_helper.rb

@@ -0,0 +1,13 @@
+module Heart
+  module ApplicationHelper
+    
+    def current_route?(controller_action)
+      if /#/.match(controller_action)
+        "current" if "#{controller_name}##{action_name}" == controller_action
+      else
+        "current" if controller_name == controller_action
+      end
+    end
+    
+  end
+end

data/app/helpers/heart/dashboards_helper.rb

@@ -0,0 +1,106 @@
+module Heart
+  module DashboardsHelper
+    
+    def check_box_helper(name, value, options, checked=false)
+      value = value.to_s
+      name = name.to_s
+      if params[:review].nil?
+        if ["movingaverage[]","annotate[]"].include?(name) && ["0","1","note"].include?(value)
+          checked = true
+        end
+      else
+        params.each do |x,y|
+          if "#{x}[]" == name && y.include?(value) || x == name
+            checked = true
+          end
+        end
+      end
+      options['id'] = (options['id'].nil?) ? "#{name.gsub("[]","")}_#{value}" : options['id']
+      check_box_tag name, value, checked, options
+    end
+
+    def tool_tip(options)
+      "<div class='tipTitle'>#{options[:title]}</div>#{options[:content]}<br /><br /><hr /><div class='center caps'>#{options[:subtitle]}</div>#{options[:footer]}"
+    end
+  
+    def to_flot_time(date)
+      date.to_time.to_i * 1000
+    end
+  
+    # Creates javascript objects to use as hashes for flot graph data series + labels
+    def flot_array(metrics)
+      replace = false
+      hash = Hash.new
+      if metrics.nil? || metrics.first.nil? || metrics.first.movingaverage.nil?
+        replace = true
+        metrics = Metric.aggregate_daily_moving_averages(0, "WHERE fulldate > SUBDATE((SELECT fulldate FROM heart_metrics WHERE movingaverage = 0 ORDER BY fulldate desc LIMIT 1), 3)")
+      end
+      if metrics.first.nil?
+        return ''
+      end
+      movingaverage = metrics.first.movingaverage
+
+      #TODO need to move all these options into the HEART js object, set these at runtime, make them easily customizable in the UI
+      extraMeasurements = ''
+      label_suffix = ''
+      if replace == true
+        extraMeasurements = "lines : { show : false, fill : false },"
+        label_suffix = ''
+      else
+        if movingaverage.to_i > 0
+          extraMeasurements = 'points : { show : false, symbol : "circle" }, lines : { show : true, fill : false },'
+          label_suffix = " [MA:#{movingaverage}] "
+        end
+      end#if replace = true
+      #loop through for all the standard measurements
+      metrics.first.attributes.sort.each do |att, value|
+        next unless value.respond_to? :to_f
+        next if value.is_a? Time
+        extraSettings = extraMeasurements
+        label = t(att) + label_suffix
+        hash[att] = "#{att} : {#{extraSettings} label : '#{label}', data : ["
+      end
+      #
+      # Now start creating the data arrays for flot. [date_converted_to_integer, value_of_metric_for_date]
+      #
+      metrics.each do |metric|
+        metric.attributes.sort.each do |att, value|
+          next unless value.respond_to? :to_f
+          next if value.is_a? Time
+          hash[att] = "#{hash[att]} [#{to_flot_time(metric.fulldate)}, #{value}],"
+        end
+      end
+      #
+      # Finished creating data arrays
+      #
+      metrics.first.attributes.sort.each do |att, value|
+        next unless value.respond_to? :to_f
+        next if value.is_a? Time
+        hash[att] = "#{hash[att]} ], att_name : \"#{att}\",},"
+      end
+
+      flotdata = "flotData_#{movingaverage} : {"
+      hash.each { |key, value| flotdata += value + "\n" }
+      flotdata += "},"
+      flotdata
+    end
+  
+    def flot_annotations_array(annotation_groups)
+      flotdata = ""
+      markings = ""
+      y_axis = 0
+      colors = ["000", "0066ff"]
+      annotation_groups.each do |annotations|
+        flotdata += "flotDataAnnotationsHash#{y_axis} : { att_name : 'flotDataAnnotationsHash#{y_axis}', note : { lines : { show : false }, points : { show : true, symbol : 'square' }, color: '##{colors[y_axis]}', label : '', data : ["
+        annotations.each do |annotation|
+            flotdata = flotdata.to_s + ("["+ to_flot_time(annotation.fulldate).to_s + ", #{y_axis},'" + annotation.note.to_s + "'],").to_s
+            markings += "{ color: '#000', lineWidth: 1, xaxis: { from: " + to_flot_time(annotation.fulldate).to_s + ", to: " + to_flot_time(annotation.fulldate).to_s + " } },"
+        end
+        flotdata += "]}},\n "
+        y_axis += 1
+      end
+      flotdata + "markings : [ #{markings}],"
+    end
+    
+  end
+end

data/app/models/heart/annotation.rb

@@ -0,0 +1,19 @@
+module Heart
+  class Annotation < Heart::Application
+    attr_accessible :fulldate, :note, :dashboard_id
+    validate :validate_note
+
+    def validate_note
+      self.note = self.note.to_s.gsub("\n\r","<br />").gsub("\r", "").gsub("\n", "<br />")
+    end
+
+    def self.visible(args)
+      from = args[:from].to_date
+      to = args[:to].to_date
+      dashboard_id = args[:dashboard_id]
+      annotations = []
+      annotations.push(Annotation.where(:fulldate => from..to).where(:dashboard_id => [nil, dashboard_id]).order("fulldate ASC").all)
+    end
+    
+  end
+end

data/app/models/heart/application.rb

@@ -0,0 +1,5 @@
+module Heart
+  class Application < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/models/heart/dashboard.rb

@@ -0,0 +1,6 @@
+module Heart
+  class Dashboard < Heart::Application
+    INACTIVE = 2
+    scope :active, lambda { where(:status => nil).where('dashboard != ""') }
+  end
+end

data/app/models/heart/image.rb

@@ -0,0 +1,5 @@
+module Heart
+  class Image < Heart::Application
+    # attr_accessible :title, :body
+  end
+end

data/app/models/heart/isometric.rb

@@ -0,0 +1,8 @@
+module Heart
+  class Isometric < Heart::Application
+    def self.find_or_create(date,average)
+      Heart::Isometric.where(fulldate: date).where(movingaverage: average).first || 
+      Heart::Isometric.where(fulldate: date, movingaverage: average)
+    end
+  end
+end

data/app/models/heart/metric.rb

@@ -0,0 +1,138 @@
+module Heart
+  class Metric < Heart::Application
+    #include metric fetching modules
+    Dir["#{Rails.root}/lib/fetch/**/*.rb"].each { |file|
+      next if /[0-9]*_*.rb/.match(file.to_s)
+  	  require file
+  	  include ("Fetch::" + File.basename(file).gsub('.rb','').split("_").map{ |ea| ea.capitalize }.join).constantize
+    }
+
+    validates_presence_of :fulldate
+    validate :validate_dayofweek, :validate_dayofyear, :validate_weekofyear, :validate_monthofyear, :validate_year, :on => :create
+    attr_accessible :fulldate, :movingaverage
+
+    def validate_dayofweek
+      self.dayofweek = self.fulldate.wday
+    end
+
+    def validate_dayofyear
+      self.dayofyear = self.fulldate.yday
+    end
+
+    def dayofmonth
+      self.fulldate.to_s.slice(8,10)
+    end
+
+    def validate_weekofyear
+      self.weekofyear = self.fulldate.cweek
+    end
+
+    def validate_monthofyear
+      self.monthofyear = self.fulldate.mon
+    end
+
+    def validate_year
+      self.year = self.fulldate.year
+    end
+
+    # returns an array of properties that contain meta data
+    def self.metadata
+      ["id","fulldate","d","year","monthofyear","month","dayofyear","day","dayofweek","weekofyear","completed_at","movingaverage","created_at","updated_at","deleted_at"]
+    end
+
+    # returns an array of possible GROUP BY fields
+    def self.groupbydata
+      ["fulldate","dayofyear","dayofweek","weekofyear","monthofyear","year"]
+    end
+
+    def self.recently_added(average=0)
+      Metric.where("movingaverage = ?", average).order("fulldate DESC").limit(3)
+    end
+
+    def self.find_or_create(date,average)
+      Heart::Metric.where(fulldate: date).where(movingaverage: average).first ||
+      Heart::Metric.create(fulldate: date, movingaverage: average)
+    end
+
+    def fetch_all
+      isometric = Isometric.find_or_create(self.fulldate,0)
+      self.methods.each do |x|
+        begin
+          if /^fetch_/.match(x.to_s)
+            dont_fetch = ["fetch_all"]
+            next if dont_fetch.include?(x)
+            puts "fetching #{x}"
+            self.send(x)
+            attribute = x.split(/_/)
+            isometric.send(attribute[1]+"=", Time.now)
+          end
+          self.save
+          isometric.save
+        rescue e
+          puts e.message
+          puts e.backtrace.inspect
+        end
+      end
+    end
+
+    def self.aggregate_daily_moving_averages(days=30, where="WHERE fulldate > SUBDATE(NOW(), 90)", groupby=nil, measurements=true, sum_avg="AVG")
+      if groupby.nil? 
+        #if groupby is nil, then we want the data for each date - not aggregated. 
+        #Group on fulldate to get non-aggregated results for each date (so the aggregating functions like AVG() don't run across all dates.)
+        groupby = "GROUP BY fulldate"
+      else
+        groupby = "GROUP BY #{groupby}"
+      end
+      measurements_with_avg = Array.new
+      case measurements
+      when false
+      when Array
+        measurements.each do |name|
+          measurements_with_avg.push(" #{sum_avg}(#{name}) AS #{name}")
+        end
+      else
+        metric = Metric.new
+        metric.attributes.each do |name, value|
+          next if Metric.metadata.include?(name)
+          next if Metric.groupbydata.include?(name)
+          measurements_with_avg.push(" #{sum_avg}(#{name}) AS #{name}")
+        end
+      end
+      m_with_a = (measurements_with_avg.empty?) ? "" : "," + measurements_with_avg.join(",")
+      self.find_by_sql("
+        SELECT fulldate, fulldate AS d, year, monthofyear AS month, dayofyear AS day, '#{days}' AS movingaverage #{m_with_a} 
+        FROM heart_metrics 
+        #{where} AND movingaverage = #{days} #{groupby} 
+        ORDER BY d ASC"
+        )
+    end
+
+    def self.aggregate_daily_sums(days=nil, where=nil, groupby=nil, measurements=true)
+      self.aggregate_daily_moving_averages(days, where, groupby, measurements, "SUM")
+    end
+
+    # TODO remove the following methods
+    #This method is used in the /metrics/:/:/cache route
+    def moving_averages!(days)
+      subselects = Metric.subselects_with_day(days).join(",")
+      metric_with_calculated_averages = Metric.find_by_sql("SELECT fulldate, fulldate AS d, year, monthofyear AS month, dayofyear AS day, '#{days}' AS movingaverage, #{subselects} FROM heart_metrics WHERE fulldate = '#{fulldate}' AND movingaverage = 0")
+      metric_with_calculated_averages.first.attributes.each do |name, value|
+        next if Metric.metadata.include?(name)
+        next if Metric.groupbydata.include?(name)
+          self.send(name+"=",value)
+      end
+    end    
+    #was used to create moving averages on the fly... became too slow when data sets were large and is now only used in the daily cache cron job
+    def self.subselects_with_day(days=30)
+      subqueries = []
+      metric = Metric.new
+      metric.attributes.each do |name, value|
+        next if Metric.metadata.include?(name)
+        next if Metric.groupbydata.include?(name)
+        subqueries.push("(SELECT AVG(#{name}) AS #{name} FROM heart_metrics WHERE movingaverage = 0 AND fulldate BETWEEN SUBDATE(d,#{days}) AND d) AS #{name}")
+      end
+      subqueries
+    end
+
+  end #end of class
+end #end of module

data/app/views/heart/annotations/create.js.haml

@@ -0,0 +1 @@
+!= flot_annotations_array(@annotations)

data/app/views/heart/annotations/description.js.haml

@@ -0,0 +1,2 @@
+$("#description").val(#{@annotation.id});
+var chart_description = "#{@annotation.note}";

data/app/views/heart/dashboards/_annotation.haml

@@ -0,0 +1,13 @@
+#clickdata
+  %fieldset.notice
+    %legend#annotation_legend
+      Add an Annotation
+    = form_tag(annotations_path) do
+      = hidden_field "annotation", "fulldate"
+      = hidden_field_tag "dashboard_id", @dashboard ? @dashboard.id : 0
+      = text_area "annotation", "note", :cols => 32, :rows => 3
+      %br
+      = button_to_function "Annotate", "HEART.annotate()"
+      %a.whisper{ :onclick => "$('#clickdata').hide();" }
+        cancel
+    %label#clickdatalabel

data/app/views/heart/dashboards/_dashblock.haml

@@ -0,0 +1,17 @@
+.span-4.dashboards
+  .dashboards-buttons-left
+    = link_to image_tag("heart/delete.png", :align => "left", :alt => "Archive", :title => "Archive Dashboard", :onclick => "return confirm('Are you sure you want to archive this dashboard?');"), dashboard_archive_path(dashboard)
+  .dashboards-buttons-right
+    = link_to image_tag("heart/pencil.png", :align => "right", :alt => "Edit", :title => "Edit"), edit_dashboard_path(dashboard)
+  .dashboards-top
+    .dashboard_title
+      = link_to dashboard.title, dashboard, :class => "button download-itunes"
+  .dashboards-bottom{:id => "miniflot#{dashboard.id}"}
+    - if Heart::Image.where(:dashboard_id => dashboard.id).exists?
+      <img src="#{Heart::Image.where(dashboard_id: dashboard.id).where(purpose: 'index').last.dataurl}"/>
+    - else
+      - charts = ActiveSupport::JSON.decode(dashboard.dashboard) rescue nil
+      - if charts.kind_of?(Array)
+        = hidden_field_tag "dashboard[]", charts[1][1], {:id => "miniflot#{dashboard.id}_form"}
+        - @reflots += "HEART.miniGraph({ target : '#miniflot#{dashboard.id}'}).draw({ serialized : $('#miniflot#{dashboard.id}_form').val(), image : true, dashboard_id : #{dashboard.id}});"
+        #{dashboard.description}

data/app/views/heart/dashboards/_dashboard_form.html.haml

@@ -0,0 +1,89 @@
+.span-22.prefix-1.clear.last
+  %fieldset
+    = hidden_field_tag "dashboard_id", @dashboard ? @dashboard.id : 0, {:id => "dashboard_id"}
+    = hidden_field_tag "dashboards", '', {:id => "dashboards"}
+    %legend
+      %span{:id => "legend"}
+    .span-22.last
+      #overlay.black_overlay
+      #loadingGif.overlay_content.fancy
+        Loading...
+      #description_div.span-20.suffix-1.prefix-1.fancy
+      #flot.flot.span-22.yspan-10
+    #flotlegend.span-21.light-contrast
+    .span-21.prefix-1.last
+      = render "heart_form"
+.span-16.last
+  .panel
+    %h3
+    %br
+    #charts.scrollable{:style => "height:70%"}
+      .span-4
+        = image_tag "heart/disk.png", :id => "dash_graph1", :onclick => "add_chart(1);"
+        <input type="text" name="chart_title" id="chart_title1" maxlength="20" style="width:110px;" value="Chart Title" />
+        #flot1.flot.flotmini.span-4.yspan-3{:style => "border:1px dashed #444;", :onclick => "HEART.flotGraph().draw({ serialized : charts.ordered[1][1]});$('#legend').html(charts.ordered[1][0]);"}
+    .hidden
+      <textarea name="charts_serialized" id="charts_serialized" cols="0" rows="0"></textarea>
+    %p
+      <button class="thoughtbot" onclick="return check_dashboards();" id="check_save_dashboard">Save &amp; Exit</button>
+  #trigger
+    #trigger_title.span-1
+    <input type="text" name="title" id="dashboard_title" maxlength="18" placeholder="#{@dashboard.try(:title)}" value="#{@dashboard.try(:title)}" />
+    #trigger_button.span-1.last
+:javascript
+  $('#overlay, #loadingGif').hide();
+  var charts = new Object({
+    ordered : #{((@dashboard.try(:dashboard)).to_s == '') ? "[]" : @dashboard.dashboard.to_s}
+  });
+
+  var charts_added = 1;
+  function add_chart(order, page_loading){
+    var next_in_order = 0;
+    next_in_order = order + 1;
+    var serialized_options = (page_loading) ? { serialized : charts.ordered[order][1]} : null;
+    HEART.miniGraph({ target : '#flot' + order }).draw(serialized_options);
+    var chart = [$('#chart_title' + order).val(), $('#heartform input:checkbox').serialize().toString()]
+    charts.ordered[order] = chart;
+    if(next_in_order > charts_added){
+      charts_added++;
+      $('#charts').append("<div class='span-4' id='minichart_"+ next_in_order + "'>" +
+                      "<img onclick=\"add_chart("+ next_in_order + ")\" src='/assets/heart/disk.png' class='cursor'> " +
+                      "<img onclick=\"del_chart("+ next_in_order + ")\" src='/assets/heart/delete.png' class='cursor'> " +
+                      "<input type=\"text\" name=\"chart_title\" id=\"chart_title" + next_in_order + "\" maxlength=\"20\" style=\"width:110px;\" placeholder=\"Chart Title\" />" +
+                      "<div class='flot flotmini span-4 yspan-3' id='flot"+ next_in_order + "' style='border:1px dashed #444;'  onclick=\"HEART.flotGraph().draw({ serialized : charts.ordered["+ next_in_order + "][1]}); $('#legend').html(charts.ordered["+ next_in_order + "][0]);\"></div>" +
+                   " </div>");
+    }
+  }
+
+  function del_chart(order){
+    charts.ordered[order] = false;
+    $('#minichart_'+order).remove();
+  }
+  function check_dashboards(){
+    while(charts.ordered.findIndex(false) !== false){
+      charts.ordered.splice(charts.ordered.findIndex(false), 1);
+    }
+    $('#charts_serialized').val(JSON.stringify(charts.ordered));
+    if($('#dashboard_title').val() == "Dashboard Name" || $('#dashboard_title').val() == ""){
+      alert('Please change the name of the dashboard');
+      $('#dashboard_title').addClass('error');
+      return false;
+    }
+    if(charts.ordered.length > 0){
+      return true;
+    }else{
+      alert('You must add a graph before saving!');
+      return false;
+    }
+  }
+
+  for(x=0;x<charts.ordered.length;x++){
+    if(x>0){
+      $("#chart_title"+x).val(charts.ordered[x][0]);
+      add_chart(x, true);
+    }
+    if(x == 1){
+      $("#chart_title"+x).val(charts.ordered[x][0]);
+      HEART.flotGraph().draw({ serialized : charts.ordered[x][1]});
+    }
+  }

data/app/views/heart/dashboards/_graph_options.html.haml

@@ -0,0 +1,24 @@
+#flot_extra.span-20.suffix-1.prefix-1
+  .prefix-14.last
+    %span.tTip{:title => tool_tip(:title => t('option.tsv'), :content => t('option.tsv_desc')) }
+      = link_to image_tag('heart/page_white_excel.png'), nil, :class => 'heart_export_tsv'
+    %span.tTip{:title => tool_tip(:title => t('option.image'), :content => t('option.image_desc')) }
+      = link_to image_tag('heart/picture.png'), nil, :class => 'heart_export_image', :id => 'heart_export_image'
+    %span.tTip{:title => tool_tip(:title => t('option.table'), :content => t('option.table_desc')) }
+      = link_to image_tag('heart/table.png'), nil, :class => 'heart_export_table'
+    |
+    %span.tTip{:title => tool_tip(:title => t('option.pie'), :content => t('option.pie_desc')) }
+      = link_to image_tag('heart/chart_pie.png', :class => 'heart_pie heart_off') + image_tag('heart/chart_pie_off.png', :class => 'heart_pie'), nil, :class => 'heart_set_pie'
+    %span.tTip{:title => tool_tip(:title => t('option.bars'), :content => t('option.bars_desc')) }
+      = link_to image_tag('heart/chart_bar.png', :class => 'heart_bars heart_off') + image_tag('heart/chart_bar_off.png', :class => 'heart_bars'), nil, :class => 'heart_set_bars'
+    %span.tTip{:title => tool_tip(:title => t('option.lines'), :content => t('option.lines_desc')) }
+      = link_to image_tag('heart/chart_curve.png', :class => 'heart_lines') + image_tag('heart/chart_curve_off.png', :class => 'heart_lines heart_off'), nil, :class => 'heart_set_lines'
+    |
+    %span.tTip{:title => tool_tip(:title => t('option.stack'), :content => t('option.stack_desc')) }
+      = link_to image_tag('heart/bricks.png', :class => 'heart_stack heart_off') + image_tag('heart/bricks_off.png', :class => 'heart_stack'), nil, :class => 'heart_set_stack'
+    %span.tTip{:title => tool_tip(:title => t('option.points'), :content => t('option.points_desc')) }
+      = link_to image_tag('heart/chart_line.png', :class => 'heart_points heart_off') + image_tag('heart/chart_line_off.png', :class => 'heart_points'), nil, :class => 'heart_set_points'
+    %span.tTip{:title => tool_tip(:title => t('option.fill'), :content => t('option.fill_desc')) }
+      = link_to image_tag('heart/paintcan.png', :class => 'heart_fill') + image_tag('heart/paintcan_off.png', :class => 'heart_fill heart_off'), nil, :class => 'heart_set_fill'
+    %span.tTip{:title => tool_tip(:title => t('option.zoom'), :content => t('option.zoom_desc')) }
+      = link_to image_tag('heart/zoom.png', :class => 'heart_zoom heart_off') + image_tag('heart/zoom_off.png', :class => 'heart_zoom'), nil, :class => 'heart_set_zoom'