cremefraiche 1.1.8

data/lib/gui/ConfDialog.rb

@@ -0,0 +1,610 @@
+#encoding: UTF-8
+=begin
+/***************************************************************************
+ *   ©2011-2023, Michael Uplawski <michael.uplawski@uplawski.eu>           *
+ *                                                                         *
+ *   This program is free software; you can redistribute it and/or modify  *
+ *   it under the terms of the WTFPL 2.0 or later version of the  LICENSE. *
+ *   See https://wtfpl2.com/ for details.                                  * 
+ *                                                                         *
+ *   This program is distributed in the hope that it will be useful,       *
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of        *
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                  *
+ *                                                                         *
+ ***************************************************************************/
+=end
+
+require 'gtk3'
+require_relative 'ButtonLabel'
+require_relative 'conf_option'
+require_relative '../configuration'
+require_relative '../confcheck'
+require_relative '../translating'
+require_relative '../file_checking'
+require_relative '../basic_logging.rb'
+require_relative 'message_dialog'
+
+=begin
+        An object of this class opens a configuration-dialog
+        that displays and allows to modify all the options which are defined in 
+        the currently used configuration-file.
+=end
+class ConfDialog
+  include Translating
+  include BasicLogging
+  include File_Checking
+
+
+=begin
+        transforms the given hex-color into a Gdk::RGBA-object.
+=end
+  def self::hex2rgba(hexc = 'ffffff')
+    rgba = Gdk::RGBA.new(1,1,1,1)
+    begin
+      rgba = Gdk::RGBA.new(hexc[0,2].hex/255.0, hexc[2,2].hex/255.0, hexc[4,2].hex/255.0, 1) if hexc.length == 6
+    rescue Exception => ex
+      msg = 'Invalid color-value ' << hexc << ': ' << ex.message
+      error(msg)
+    end
+    return rgba
+  end
+
+
+  @@GD = File::expand_path(File::dirname(__FILE__) ) + File::Separator if !defined?(@@GD)
+  @@Error_color = ConfDialog::hex2rgba('c00000')		
+  @@White = ConfDialog::hex2rgba('ffffff')		
+  @@Black = ConfDialog::hex2rgba('000000')		
+
+  def initialize(options = {})
+    @title = trl('Configuration')
+    @cdialog = Gtk::Dialog.new(:title => @title, :parent => nil  )
+    # font-settings are inter-dependent.
+    @fonts = Array.new
+    # create the controls of the dialog
+    create
+    @cdialog.signal_connect('response') do |dlg, resp|
+      debug("response %i emitted" %resp)
+      @cdialog.destroy if(Gtk::ResponseType::CANCEL == resp) 
+    end  
+    if(options && options.keys.include?(:on_destroy))
+      @cdialog.signal_connect('destroy') {options[:on_destroy].call() }
+    end
+    @cdialog.show
+  end
+  private
+
+=begin
+        signal that a value has been changed in the dialog but is not yet
+        saved to the configuration-file.
+=end
+  def mark_changed(label)
+    @labels = Array.new if !defined?(@labels)
+    if(label && !@labels.include?(label) )
+      @labels << label
+      @cdialog.title = @title + ' *'
+      label.set_markup("<b>* " << label.text << "</b>")
+    elsif(!label)
+      @cdialog.title = @title
+      @labels.each do |lb|
+        lb.set_markup("<b>" << lb.text.sub('* ', '') << "</b>")
+      end
+      @labels.clear
+    end
+  end
+
+=begin
+        calls refresh_table to create the remainder of the
+        controls.
+=end
+  def create
+    @cdialog.set_icon(@@GD + 'icon.xpm');
+    tbox = Gtk::Box.new(:vertical, 5)	
+    # initialize the table
+    @table = Gtk::Table.new(1,5)
+    @table.set_row_spacings(2)
+    refresh_table
+
+    tframe = Gtk::Frame.new()
+    tframe.add(@table)
+
+    tbox.pack_start(tframe, :expand=>true)
+    tbox.pack_start(init_buttons, :expand => false)
+    tbox.show_all
+    @cdialog.child.pack_start(tbox)
+  end
+
+=begin
+        creates the buttons to save values, close the
+        dialog or to reset the configuration to default-values
+=end
+  def init_buttons
+    bbox = Gtk::Box.new(:horizontal, 5)
+    @save_button = Gtk::Button.new()
+    @save_button.add(ButtonLabel.new(trl('_Save'), @@GD + "gtk-save.xpm") )
+    @save_button.set_tooltip_text(trl("Save current values to the configuration-file %s") %($CONF.config_file) )
+
+    @okay_button = Gtk::Button.new()
+    @okay_button.add(ButtonLabel.new(trl('_Okay'), @@GD + "gtk-close.xpm") )
+    @okay_button.set_tooltip_text(trl('Close this dialog, lose any unsaved changes') )
+
+    @default_conf = Gtk::Button.new()
+    @default_conf.add(ButtonLabel.new(trl('_Defaults'), @@GD + "gtk-properties.xpm"))
+    @default_conf.set_tooltip_text(trl('Overwrite with default-settings'))
+
+    @save_button.signal_connect(CLICKED) do
+      save()
+    end
+
+    @okay_button.signal_connect(CLICKED) do
+      @cdialog.destroy	
+    end
+
+    @default_conf.signal_connect(CLICKED) do
+      ConfCheck.new.write_user_conf
+      refresh_table
+    end
+
+    bbox.pack_start(@save_button, :expand => false, :fill => false)
+    bbox.pack_start(@okay_button, :expand => false, :fill => false)
+    bbox.pack_end(@default_conf, :expand => false, :fill => false)
+    return bbox
+  end
+
+=begin
+        saves the currently displayed values to the configuration-file.
+=end
+  def save()
+    debug('new-conf is ' << @new_conf.to_s)
+    $CONF.save_config(@new_conf)
+    refresh_table
+
+  end
+
+=begin
+        creates a tooltip-text for the given configuration-option.
+=end
+  def tooltip(option)
+    d = option.default
+    if(false == d)
+      d = 'false'
+    elsif(true == d)
+      d = 'true'
+    else
+      d = d.to_s.chomp.strip if(d)
+      d = ((!d || d.empty?) ? trl('empty') : d )
+    end
+
+    option.doc.dup << "\n" << trl('Default') << ': ' << d
+  end
+
+=begin
+        Creates a multiline text-widget for a multiline configuration-option.
+        ATTN: Stringlists can be altered by the user. Therefore, these values cannot be
+        translated and must be displayed in their original form.
+=end
+  def stringlist(label, option)
+    value = option.value
+
+    vtext = Gtk::Frame.new
+    vtextView = Gtk::TextView.new(Gtk::TextBuffer.new() ) 
+    vtextView.buffer.signal_connect("changed") do |buf|
+      mark_changed(label)
+      @new_conf[option.name] = buf.text
+    end
+    v = ''
+    if(value.respond_to?(:to_ary) )
+      debug('option value is array')
+      v = value.join("\n")
+    elsif (value.respond_to?(:to_str) )
+      debug('option value is string')
+      v = value.split.join("\n")
+    else
+      v = value.to_s
+    end
+    vtextView.buffer.text = v
+    @new_conf[option.name] = vtextView.buffer.text
+    debug('stringlist created')
+
+    # Okay, someone had the idea to make the add() function return
+    # an empty Hash, sometime between Gtk3-releases. So what, why
+    # not an elephant or something moist and warm..? Break my code,
+    # folks.  Plenty of room for your creativity.
+    vtext.add(vtextView)
+    # This looks dumb because it is! Eat it. Why a Hash? What Hash?
+    vtext
+  end
+=begin
+        creates a checkbox for a boolean configuration-option.
+=end
+  def truefalse(label, option)
+    vtext = Gtk::CheckButton.new()
+    vtext.active = option.value	
+
+    vtext.signal_connect(CLICKED) do |cb|
+      debug(cb.class.name)
+      @new_conf[option.name] = cb.active?
+      mark_changed(label)
+    end
+    vtext
+  end
+=begin
+      creates a simple text-entry field.
+=end
+  def text_entry(label, option)
+    debug('text_entry for ' << label.text << ", option is " << option.to_s)
+    display_value = option.display_value ? option.display_value : ''
+    vtext = Gtk::Entry.new()
+    vtext.signal_connect("changed") do |entry|
+      @new_conf[option.name] = entry.text
+      mark_changed(label)
+    end
+    debug('setting value for ' << option.name << ' to ' << option.value.to_s)
+    vtext.text.clear
+    vtext.text = display_value
+    @new_conf[option.name] = option.value if option.value
+    return vtext
+  end
+=begin
+        creates a dropdown-field for an option that allows
+        a choice from pre-defined values.	
+        #TODO: translate choices and compare to translated
+        # values
+=end
+  def choose_text(label, option)
+    vtext = Gtk::ComboBoxText.new		
+    option.choices.each {|c| vtext.append_text(trl(c.to_s, false) )}
+
+    value = option.value
+    debug('choose_text, value is ' << value.to_s)
+    if(value && ! value.to_s.empty?)
+      debug('choose_text, value is ' << value.to_s)
+      valuestr = option.display_value
+      if(option.choices.include?(value.to_sym) )
+        index = option.choices.index(value.to_sym)
+        vtext.set_active(index) if index
+      else
+        msg = file_check(valuestr, :exist?, :directory?, :writable?)
+        debug('is not a file: ' << valuestr)
+        if(!msg)
+          vtext.append_text(valuestr)
+          vtext.set_active(option.choices.size)
+        else
+          dmsg = (trl("The directory %s cannot be used for mail-attachments (%s)") %[valuestr, msg])
+          msg_dialog(dmsg, :WARNING)
+          warn(dmsg)
+        end
+      end
+    else
+      debug('choose_text: no value')     
+    end
+    vtext.signal_connect("changed") do   
+      if('path' == vtext.active_text)
+        dir = choose_file(option, :action=>:select_folder)
+        vtext.append_text(dir) if dir
+        vtext.set_active(option.choices.size)
+      end
+      # Correlate index from combo-box with index from choices!
+      index = vtext.active
+      tx = option.choices[index]
+      if(!tx || tx.empty?)
+        tx = option.default.to_s
+      end
+      @new_conf[option.name] = tx
+      mark_changed(label)
+    end
+    vtext
+  end
+
+=begin
+        creates a text-entry and a file-chooser button and inter-connects
+        the current option to all other font-options.
+=end
+  def font(label, option)
+    vtext = file_path(label, option)
+    font_entry = vtext.children.first
+    if (!@fonts.include?(font_entry) )
+      @fonts << font_entry
+    end
+    verify_fonts(font_entry)
+    verify_font(font_entry, option)	
+
+    font_entry.signal_connect('changed') do |entry|
+      set_widget_bg(entry, Gdk::RGBA.new(1, 1, 1, 1))
+      verify_fonts(entry)
+      verify_font(font_entry, option)	
+    end
+    vtext
+  end
+=begin
+        checks a currently set font-setting for validity
+=end
+  def verify_font(entry, option)
+    msg = check_file_constraints(entry.text, option)
+    if(msg)
+      mark_entry(entry)
+    else
+      mark_entry(entry, false)
+    end
+
+  end
+
+=begin
+        Makes sure, that none or all fonts are set.
+=end
+  def verify_fonts(entry)
+    has_value = entry.text && !entry.text.empty?
+    @fonts.each do |f|
+      if(f != entry)
+        hv = f.text && !f.text.empty?		
+        if(hv != has_value)
+          set_widget_bg(f, @@Error_color)
+        else
+          set_widget_bg(f, @@White)
+        end
+      end
+    end
+
+  end
+=begin
+        opens a file-chooser dialog and allows to choose files or directories, 
+        depending on the option.
+=end
+  def choose_file(option, args={})
+    file = nil
+    if(!@fdialog)
+      action = args[:action]
+      action ||= :open
+      item = (action == :open ? trl('file') : trl('folder') )
+      @fdialog = Gtk::FileChooserDialog.new(:title => trl("Choose a %s") %item,
+                                            :parent => nil,
+                                            :action => action,
+                                            :buttons => [[:cancel, :cancel], [:open, :accept]])
+      if(args[:start_path])
+        # start where the currently selected file has been located.
+        @fdialog.filename = args[:start_path] 
+      else
+        # or start in the user's home-directory
+        @fdialog.filename = HOME 
+        @fdialog.filename ||= Dir::pwd
+      end
+      # open the file-chooser, return the selected file-name
+      file = (@fdialog.run == Gtk::ResponseType::ACCEPT ? @fdialog.filename : nil)
+      @fdialog.destroy
+      @fdialog = nil
+    end
+    return file
+
+  end
+=begin
+        creates a text-entry and a file-chooser button.
+=end
+  def file_path(label, option)
+    vtext = Gtk::Box.new(:horizontal)
+    fpath = Gtk::Entry.new()
+    fpath.signal_connect("changed") do |entry|
+      @new_conf[option.name] = entry.text if entry.text
+      mark_changed(label)
+      msg = check_file_constraints(entry.text, option)
+      if(msg)
+        debug('mark_entry ' << label.text << ' faulty' )
+        mark_entry(fpath)
+      end
+    end
+    vtext.pack_start(fpath)
+    fchoose = Gtk::Button.new( )
+    fchoose.add(ButtonLabel.new('', @@GD + "gtk-open.xpm"))
+    fpath.text.clear
+    fpath.text = option.value
+    vtext.pack_start(fchoose)
+    fchoose.signal_connect(CLICKED) do 
+      file = choose_file(option, :start_path => fpath.text)
+      fpath.text = file if file
+      @new_conf[option.name] = file if file
+      msg = check_file_constraints(fpath.text, option) 
+      if(msg)
+        mark_entry(fpath)
+        msg_dialog(msg, DLG_ERROR) 
+      else
+        mark_entry(fpath, false)	
+      end
+    end
+    vtext
+  end
+
+=begin
+        marks a text-entry widget as faulty or not.
+=end
+  def mark_entry(entry, faulty = true)
+    entry.override_color(:NORMAL, faulty ? @@Error_color : @@Black )
+  end
+=begin
+   compares file-properties to a given set of constraints.
+=end
+  def check_file_constraints(file, option)
+    if(file && !file.empty? && option.constraints )
+      debug('checking file ' << file)
+      msg = file_check(file, *option.constraints)
+      if(msg)
+        msg = trl("File %s is unuseable") %file << ": \"" << msg << "\""
+        error(msg)
+        file = nil
+        return msg
+      end
+    end
+    return nil
+  end
+
+=begin
+        creates a text-entry and a color-chooser button.
+=end
+  def hexcolor(label, option)
+    ovalue = option.value
+    vtext = Gtk::Box.new(:horizontal)
+    color = Gtk::Entry.new()
+    color.text.clear
+    if(ovalue && !ovalue.to_s.strip.empty?)
+      color.text = ovalue.to_s
+    else
+      color.text = option.default
+    end
+    set_widget_bg(color, hex2rgba(color.text))
+    color.signal_connect("changed") do |entry|
+      @new_conf[option.name] = entry.text
+      set_widget_bg(entry, hex2rgba(entry.text))
+      mark_changed(label)
+    end
+    vtext.pack_start(color)
+    cchoose = Gtk::Button.new( )
+    cchoose.add(ButtonLabel.new('', @@GD + "preferences-color.xpm"))
+    vtext.pack_start(cchoose)
+    cchoose.signal_connect(CLICKED) do 
+      if(!@coldlg)
+        #gtk3 sabotage fix
+        #
+        # @coldlg = Gtk::ColorSelectionDialog.new(:title => trl('Choose a color'))
+        @coldlg = Gtk::ColorChooserDialog.new(:title => trl('Choose a color'))
+        # @coldlg.color_selection.current_rgba = hex2rgba(color.text)
+        @coldlg.set_rgba( hex2rgba(color.text))
+        ncolor = (@coldlg.run == Gtk::ResponseType::OK ? @coldlg.rgba : nil)
+        if(ncolor)
+          hcolor = "%02x%02x%02x" %[ncolor.red * 255, ncolor.green * 255, ncolor.blue * 255]
+          debug('original color : ' << ncolor.red.to_s << ', ' << ncolor.green.to_s << ', ' << ncolor.blue.to_s << ' : new hcolor is ' << hcolor)
+          @new_conf[option.name] = hcolor
+          color.text = hcolor
+          set_widget_bg(color, ncolor)
+        end
+        @coldlg.destroy
+        @coldlg = nil
+      end
+    end
+
+    vtext
+  end
+=begin
+        transforms the given hex-color into a Gdk::RGBA-object.
+=end
+  def hex2rgba(hexc = 'ffffff')
+    ConfDialog::hex2rgba(hexc)
+  end
+=begin
+        Changes for the widget 'wg' its background-color to 'rgba', a Gdk::RGBA-object.
+        If the color is too dark for black foreground-text, also alters the text-color to white.
+=end
+  def set_widget_bg(wg, rgba)
+    wg.override_background_color(:NORMAL, rgba)
+    colsum = rgba.red + rgba.green + rgba.blue
+    if(colsum < 176/255.0)
+      wg.override_color(:NORMAL, Gdk::RGBA.new(1,1,1,1) )
+    else
+      wg.override_color(:NORMAL, Gdk::RGBA.new(0,0,0,1) )
+    end
+  end
+=begin
+        Creates and re-creates all the control-elements which set and change
+        configuration-options. For each option-type a specific method is called.
+=end
+  def refresh_table()
+    $CONF.read_config
+    debug('CONF is ' << $CONF.inspect)
+    sz = $CONF.size
+    debug('configuration contains ' << sz.to_s << ' elements')
+    row = 0
+    @new_conf = Hash.new
+    @table.each {|w| @table.remove(w) }
+    #### TODO #########
+    # error('TODO: use ConfValue where needed to replace value. Aborting!')
+    # exit false
+    #### END  #########
+
+    $CONF.each_with_index do |pair, i|
+      begin
+        debug('working on pair ' << pair.to_s << ', index #' << i.to_s)
+        key = pair[0].to_s
+        # store the current value to the 'new' configuration
+        option = ConfOption.new(key, pair[1]) 
+        debug('option is ' << option.to_s)
+        # The option may set a different value, for some reason.
+        # store value to persist
+        @new_conf[key] = option.value.to_s
+
+        klbl = Gtk::Label.new()
+        klbl.set_markup('<b>' << option.display_name << ': </b>')
+        klbl.set_halign(2)	
+        klbl.set_valign(1)	
+        otype = option.type 
+        ovalue = option.value if option.value
+        debug('option-name is ' << key)
+        debug('option-value is ' << ovalue.to_s)
+        debug('option display-value is ' << option.display_value.to_s)
+        debug('option-type is ' << otype.to_s)
+        case otype
+        when :stringlist
+          vtext = stringlist(klbl, option)
+        when :choose_text
+          vtext = choose_text(klbl, option)
+        when :file
+          vtext = file_path(klbl, option)
+        when :font
+          vtext = font(klbl, option)
+        when :bool
+          vtext = truefalse(klbl, option)
+        when :hexcolor
+          vtext = hexcolor(klbl, option)
+        else
+          debug('default option type')
+          vtext = text_entry(klbl, option)
+=begin
+                                        vtext = Gtk::Entry.new()
+                                        vtext.signal_connect("changed") do |entry|
+                                                @new_conf[key] = entry.text
+                                                mark_changed(klbl)
+                                        end
+                                        debug('setting value for ' << key << ' to ' << ovalue.to_s)
+                                        vtext.text.clear
+                                        vtext.text = option.display_value.to_s if option.display_value
+                                        @new_conf[key] = ovalue if ovalue
+=end
+        end
+        vtext.set_valign(1) if vtext && vtext.respond_to?(:set_valign)
+
+        ttip = tooltip(option)
+
+        klbl.set_tooltip_text(ttip)
+        vtext.set_tooltip_text(ttip) if vtext && vtext.respond_to?(:set_tooltip_text)
+        debug('tooltip set for ' << klbl.text)
+
+        if( i % 2 == 0)
+          @table.attach(klbl, 0, 1, row, row + 1)
+          debug('attaching text-entry ' << vtext.class.name)
+          @table.attach(vtext, 1, 2, row, row + 1) if vtext
+          debug('left label and value set')
+        else
+          debug('right')
+          @table.attach(klbl, 2, 3, row, row + 1)
+          @table.attach(vtext, 3, 4, row, row + 1) if vtext
+          debug('right label and value set')
+          row += 1
+          @table.attach(Gtk::Separator.new(:horizontal), 0, 4, row, row + 1)
+          row += 1
+        end
+      rescue ConfOption::InvalidOptionError => ex
+        msg = ex.message << "\nIgnoring invalid option %s. Please save a valid configuration." %klbl.text
+        error msg 
+        msg_dialog(msg, :error)
+      rescue Exception => ex
+        if klbl
+          msg = klbl.text.dup << ": " << ex.message 
+        else
+          msg = ex.message
+        end
+        error( msg)
+        msg_dialog(msg, :error)
+      end
+
+    end
+
+    mark_changed(nil)
+    @table.show_all
+  end
+end
+