bitcoin-ruby 0.0.6 → 0.0.7

data/lib/bitcoin/gui/gui.rb

@@ -1,292 +0,0 @@
-# encoding: ascii-8bit
-
-require_relative "em_gtk.rb"
-require_relative "helpers.rb"
-require_relative "tree_view.rb"
-require_relative "addr_view.rb"
-require_relative "tx_view.rb"
-require_relative "conn_view.rb"
-
-Gtk.init
-
-module Bitcoin::Gui
-
-  class Gui
-
-    include Helpers
-
-    attr_reader :builder, :wallet, :storage
-    attr_accessor :node, :addr_view, :conn_view
-
-    def initialize storage, wallet_file = nil
-      @storage = storage
-      @node = nil
-      build
-      @addr_view = AddrView.new(self)
-      @tx_view = TxView.new(self, :tx_view)
-      @conn_view = ConnView.new(self)
-      open_wallet(wallet_file)  if wallet_file
-      main_window.show_all
-      # notebook.next_page
-      statusicon.tooltip_text = "Bitcoin-Ruby GUI"
-      GObject.signal_connect(statusicon, "activate") do
-        main_window.visible ? main_window.hide : main_window.show
-      end
-      GObject.signal_connect(statusicon, "popup-menu") do
-        popup_menu.popup_for_device(nil, nil, nil, ->(*a) {}, nil, nil, 0, 0)
-      end
-    end
-
-    def log
-      @log ||= Bitcoin::Logger.create(:gui)
-    end
-
-    def build
-      @builder = Gtk::Builder.new
-      @builder.add_from_file(File.join(File.dirname(__FILE__), "gui.builder"))
-      @builder.connect_signals_full(->(builder, widget, signal, handler, _, _, gui) do
-          GObject.signal_connect(widget, signal) { gui.send(handler) }
-        end, self)
-
-      {
-        "<Control>n" => :file_new,
-        "<Control>o" => :file_open,
-        "<Control>q" => :file_quit,
-        "<Control>c" => :edit_copy,
-        "<Control>v" => :edit_paste,
-        "<Control>p" => :edit_preferences,
-        "<Control>h" => :help_about,
-      }.each do |binding, action|
-        send("menu_#{action}").add_accelerator("activate", accelgroup1,
-          *Gtk.accelerator_parse(binding), 0)
-      end
-    end
-
-    def update_wallet_views
-      return  unless @wallet
-      EM.defer do
-        @addr_view.update(@wallet.keystore.keys)#.select{|k| k[:mine] == true})
-        @tx_view.update(@wallet.get_txouts(true))
-        unconfirmed = check_unconfirmed.active
-        wallet_text = "wallet: #{@wallet.keystore.config[:file]} | " +
-          "addresses: #{@wallet.addrs.size} | " +
-          "balance: #{"%.8f" % (@wallet.get_balance(unconfirmed) / 1e8)}"
-        status_wallet.push 0, wallet_text
-      end
-    end
-
-    def on_check_unconfirmed_toggled
-      update_wallet_views
-    end
-
-    def on_preferences
-      dialog(:preferences, :setup => ->(d) {
-          config = Bitcoin::Config.load({}, :wallet)
-          model = preferences_box_network.get_model
-          row = model.append
-          model.set_value(row, 0, "foo")
-          preferences_box_network.set_model model
-          # preferences_entry_network.text = config[:network]
-        }) do |*a|
-        p a
-      end
-    end
-
-    def on_copy_addr
-      addrs = []
-      valid, i = @addr_view.model.get_iter_first
-      while valid
-        if @addr_view.view.selection.iter_is_selected(i)
-          a = @addr_view.model.get_value(i, 0).get_string
-          addrs << a
-        end
-        valid = @addr_view.model.iter_next(i.to_ptr)
-      end
-
-      return  unless addrs.any?
-      text = addrs.join(", ")
-      c = Gtk::Clipboard.get(Gdk::Atom.intern("PRIMARY", false))
-      c.set_text text, text.size
-      c = Gtk::Clipboard.get(Gdk::Atom.intern("CLIPBOARD", false))
-      c.set_text text, text.size
-    end
-
-    def on_paste_addr
-      c = Gtk::Clipboard.get(Gdk::Atom.intern("PRIMARY", false))
-      c.request_text ->(clip, text, data) {
-        on_new_addr(text)  if Bitcoin.valid_address?(text)
-      }, self
-      c = Gtk::Clipboard.get(Gdk::Atom.intern("CLIPBOARD", false))
-      c.request_text ->(clip, text, data) {
-        on_new_addr(text)  if Bitcoin.valid_address?(text)
-      }, self
-    end
-
-    def on_new_addr addr = nil
-      dialog(:new_addr, setup: ->(d) {
-          new_addr_check_addr.active = addr ? true : false
-          new_addr_check_pubkey.active = false
-          new_addr_check_mine.active = addr ? false : true
-          new_addr_entry_label.text = ""
-          new_addr_entry_addr.text = addr ? addr : ""
-          new_addr_entry_pubkey.text = ""
-          new_addr_entry_addr.hide  unless addr
-          new_addr_entry_pubkey.hide
-          GObject.signal_connect(new_addr_check_addr, "toggled") do
-            new_addr_check_addr.active ? new_addr_entry_addr.show :
-              new_addr_entry_addr.hide
-          end
-          GObject.signal_connect(new_addr_check_pubkey, "toggled") do
-            new_addr_check_pubkey.active ? new_addr_entry_pubkey.show :
-              new_addr_entry_pubkey.hide
-          end
-        }) do |*a|
-        begin
-          label = new_addr_entry_label.text
-          set_address = new_addr_check_addr.active
-          set_pubkey = new_addr_check_pubkey.active
-          is_mine = new_addr_check_mine.active
-          key = {:label => label}
-          if set_address
-            addr = new_addr_entry_addr.text
-            raise "Address #{addr} invalid"  unless Bitcoin.valid_address?(addr)
-            key[:addr] = addr
-          end
-          if set_pubkey
-            k = Bitcoin::Key.new(nil, new_addr_entry_pubkey.text)
-            key[:key] = k
-            key[:addr] = k.addr
-          end
-          if !set_address && !set_pubkey
-            key[:key] = Bitcoin::Key.generate
-            key[:addr] = key[:key].addr
-          end
-          key[:mine] = is_mine
-          @wallet.add_key(key)
-          update_wallet_views
-        rescue
-          message(:error, "Error adding key", $!.message, [:ok]) do
-            new_addr_dialog.show
-          end
-        end
-        update_addr_store
-      end
-    end
-
-    def on_new_tx
-      dialog(:new_tx, :setup => ->(d) {
-          new_tx_entry_address.text = ""
-          new_tx_entry_amount.text = ""
-          model = Gtk::ListStore.new([GObject::TYPE_STRING, GObject::TYPE_STRING])
-          @wallet.keystore.keys.each do |key|
-            row = model.append
-            model.set_value(row, 0, key[:label] || "")
-            model.set_value(row, 1, key[:addr])
-          end
-          renderer = Gtk::CellRendererText.new
-          comp = Gtk::EntryCompletion.new_with_area(area)
-          comp.text_column = 1
-          comp.minimum_key_length = 1
-          comp.set_match_func(->(comp, text, iter, _) {
-              label = comp.get_model.value(iter, 0).get_string
-              addr = comp.get_model.value(iter, 1).get_string
-              !!(label =~ /#{text}/ || addr =~ /#{text}/)
-            }, nil, nil)
-          comp.area.pack_start renderer, false, false, false
-          comp.area.orientation = :vertical
-          comp.set_model model
-          renderer.set_padding 10, 0
-          renderer.foreground = "blue"
-          comp.set_cell_data_func(renderer, ->(layout, renderer, model, iter, data) {
-              renderer.text = model.get_value(iter, 0).get_string
-            }, nil, nil)
-          new_tx_entry_address.set_completion comp
-#          GObject.signal_connect(comp, "match-selected") do |comp, _, iter, _|
-#            addr = comp.get_model.get_value(iter, 1).get_string
-#            new_tx_entry_address.text = addr
-#            true
-#          end
-        }) do |dialog|
-
-        address = new_tx_entry_address.text
-        amount = new_tx_entry_amount.text
-        unless Bitcoin.valid_address?(address)
-          message(:error, "Invalid Address",
-            "Address #{address} is not a valid bitcoin address.", [:ok]) do
-            new_tx_dialog.show
-          end
-          next
-        end
-        unless amount =~ /[0-9]*\.[0-9]*/
-          message(:error, "Invalid Amount",
-            "Amount #{amount} can not be parsed. Please use \"0.0\" form.", [:ok]) do
-            new_tx_dialog.show
-          end
-          next
-        end
-        value = (amount.to_f * 1e8).to_i
-        unless value <= @wallet.get_balance
-          message(:error, "Insufficient Balance",
-            "Balance #{@wallet.get_balance} is not sufficient to spend #{value}.", [:ok]) do
-            dialog.show
-          end
-          next
-        end
-        message(:question, "Really send transaction?",
-          "Do you really want to send #{format_value value} to #{address}?", [:no, :yes]) do
-          tx = @wallet.new_tx([[:address, *[address], value]], 0.00)
-          # puts tx.to_json
-          if @node.request(:relay_tx, tx)
-            puts "Transaction #{tx} relayed."
-          end
-        end
-      end
-    end
-
-    def on_new_wallet
-      dialog(:wallet_save, :filters => :wallet, :callbacks => {
-          "update-preview" => method(:wallet_preview)}) do
-        file = wallet_save_dialog.filename.read_string
-        open_wallet(file)  unless File.file?(file)
-      end
-    end
-
-    def on_open_wallet
-      dialog(:wallet_open, :filters => :wallet, :callbacks => {
-          "update-preview" => method(:wallet_preview)}) do
-        open_wallet(wallet_open_dialog.filename.read_string)
-      end
-    end
-
-    def on_about
-      dialog(:about)
-    end
-
-    def on_exit
-      puts "bye"
-      Gtk.main_quit
-      EM.stop
-    end
-
-    def open_wallet(file)
-      keystore = Bitcoin::Wallet::SimpleKeyStore.new(:file => file)
-      @wallet = Bitcoin::Wallet::Wallet.new(@storage, keystore,
-        Bitcoin::Wallet::SimpleCoinSelector)
-      @wallet.on_tx do |type, tx|
-        puts "#{type} transaction: #{tx.hash}"
-        update_wallet_views
-        value = tx.out.select {|out| (@wallet.addrs & out.get_addresses).any? }
-          .map(&:value).inject(:+)
-        title = "#{type.to_s.capitalize} transaction"
-        message = "#{tx.hash}\nValue: #{format_value(value)}"
-        Notify.notify title, message
-      end
-      update_wallet_views
-    rescue
-      message(:error, "Error loading wallet", $!.message, [:ok])
-      p $!
-      puts *$@
-    end
-
-  end
-end

data/lib/bitcoin/gui/helpers.rb

@@ -1,115 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin::Gui::Helpers
-
-  def display_tx tx_hash
-    tx = @storage.get_tx(tx_hash)
-    dialog(:tx, setup: ->(d) {
-        tx_label_hash.text = tx.hash
-        tx_label_value.text = format_value(tx.out.map(&:value).inject(:+))
-        tx_label_confirmations.text = tx.confirmations.to_s
-        txin_view = Bitcoin::Gui::TxInView.new(self, :tx_txin_view)
-#        txin_view.update(tx.in)
-      })
-  end
-
-  def wallet_preview(dialog, *args)
-    filename = dialog.preview_filename
-    file = filename.read_string rescue nil
-    if file && File.file?(file)
-      keystore = Bitcoin::Wallet::SimpleKeyStore.new(:file => file)
-      wallet = Bitcoin::Wallet::Wallet.new(@storage, keystore,
-        Bitcoin::Wallet::SimpleCoinSelector)
-      preview = Gtk::Label.new "Keys: #{wallet.addrs.size}\n" +
-        "Balance:\n%.8f" % (wallet.get_balance / 1e8)
-    end
-    dialog.preview_widget = preview
-  end
-
-  def add_wallet_filters dialog
-    filter = Gtk::FileFilter.new
-    filter.name = "Wallet Files"
-    filter.add_pattern("*.json")
-    dialog.add_filter filter
-
-    filter = Gtk::FileFilter.new
-    filter.name = "All Files"
-    filter.add_pattern("*")
-    dialog.add_filter filter
-  end
-
-  def dialog name, opts = {}
-    @dialog_cb_ids ||= {}
-    ids = @dialog_cb_ids[name] || []
-    dialog = send("#{name}_dialog")
-    send("add_#{opts[:filters]}_filters", dialog)  if opts[:filters]
-    opts[:setup].call(dialog)  if opts[:setup]
-    while id = ids.shift
-      GObject.signal_handler_disconnect(dialog, id)
-    end
-    ids << GObject.signal_connect(dialog, "response") do |dialog, response, *data|
-      yield(dialog, *data)  if response > 0
-      dialog.hide
-    end
-    if dialog.is_a?(Gtk::FileChooserDialog)
-      ids << GObject.signal_connect(dialog, "file-activated") do |dialog, *data|
-        yield(dialog, *data)
-        dialog.hide
-      end
-    end
-    (opts[:callbacks] || {}).each do |name, block|
-      ids << GObject.signal_connect(dialog, name) {|*a| block.call(*a) }
-    end
-    dialog.show
-    @dialog_cb_ids[name] = ids
-  rescue
-    p $!
-    puts *$@
-  end
-
-  def message(type, title, text, buttons)
-    dialog(:message, :setup => ->(dialog){
-        dialog.message_type = Gtk::MessageType.find(type.to_sym)
-        dialog.text = title
-        dialog.secondary_text = text
-        [:yes, :no, :ok].each do |n|
-          b = send("message_dialog_button_#{n}")
-          buttons.include?(n) ? b.show : b.hide
-        end
-      }) do |dialog|
-      yield(dialog)  if block_given?
-      dialog.show_all
-      dialog.hide
-    end
-  rescue
-    p $!
-  end
-
-  def method_missing name, *args
-    @builder.get_object(name.to_s) rescue super(name, *args)
-  end
-
-  def format_value val
-    "%.8f" % (val / 1e8)
-  end
-
-  def format_address address, label = nil
-    "#{label} (#{address})"
-  end
-
-  def format_version ver
-    ver.insert(-3, '.')  if ver.size > 2
-    ver.insert(-6, '.')  if ver.size > 5
-    ver.insert(0, "0.")  if ver.size <= 7
-    ver
-  end
-
-  def format_uptime started
-    uptime = Time.now.to_i - started
-    mm, ss = uptime.divmod(60)       #=> [4515, 21]
-    hh, mm = mm.divmod(60)           #=> [75, 15]
-    dd, hh = hh.divmod(24)           #=> [3, 3]
-    "%02d:%02d:%02d:%02d" % [dd, hh, mm, ss]
-  end
-
-end

data/lib/bitcoin/gui/tree_view.rb

@@ -1,84 +0,0 @@
-# encoding: ascii-8bit
-
-module Bitcoin::Gui
-  class TreeView
-
-    include Helpers
-
-    attr_accessor :model, :view
-
-    def initialize gui, view_name, columns
-      @gui = gui
-      @view = @gui.builder.get_object(view_name.to_s)
-      @model = Gtk::TreeStore.new(columns.map{|c| c[0] })
-      @view.set_model @model
-
-      columns.each_with_index do |cdef, i|
-        type, label, cb = *cdef
-        next  unless label
-        case type
-        when GObject::TYPE_BOOLEAN
-          renderer = Gtk::CellRendererToggle.new
-          col = tree_view_col(renderer, label, "active", i) do |*args|
-            method(cb).call(@model, i, args[1], args[3])  if cb
-          end
-        when GObject::TYPE_STRING, GObject::TYPE_INT
-          renderer = Gtk::CellRendererText.new
-          col = tree_view_col(renderer, label, "text", i) do |*args|
-            method(cb).call(@model, i, args[1], args[3])  if cb
-          end
-        end
-        @view.append_column(col)
-      end
-    end
-
-    def embed name
-      parent = @gui.builder.get_object(name.to_s).parent
-      parent.remove(parent.get_child)
-      parent.add(@view)
-    end
-
-    def tree_view_col renderer, title, key, val, &block
-      col = Gtk::TreeViewColumn.new
-      col.pack_start renderer, true
-      col.add_attribute renderer, key, val
-      col.set_title title
-      col.set_cell_data_func(renderer, block, nil, nil)
-      col
-    end
-
-    def format_address_col model, i, renderer, iter
-      address = model.get_value(iter, i).get_string
-      label = model.get_value(iter, i+1).get_string
-      renderer.text = format_address(address, label)
-    end
-
-    def format_value_col model, i, renderer, iter
-      val = model.get_value(iter, i).get_string.to_i
-      renderer.text = format_value(val)
-      if val > 0
-        renderer.foreground = "darkgreen"
-      elsif val < 0
-        renderer.foreground = "red"
-      else
-        renderer.foreground = "black"
-      end
-    end
-
-    def format_version_col model, i, renderer, iter
-      ver = model.get_value(iter, i).get_int.to_s
-      renderer.text = format_version(ver)
-    end
-
-    def format_uptime_col model, i, renderer, iter
-      started = model.get_value(iter, i).get_int
-      renderer.text = format_uptime(started)
-    end
-
-    def format_bool_col model, i, renderer, iter
-      active = model.get_value(iter, i).get_boolean
-      renderer.set_active active
-    end
-
-  end
-end