monito/prefs.js

/* -*- mode: js; js-basic-offset: 4; indent-tabs-mode: nil -*- */
/*
  Monito Gnome-Shell extension
  Copyright (C) 2021  Benjamin Drieu

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  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.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along
  with this program; if not, write to the Free Software Foundation, Inc.,
  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.

  SPDX-License-Identifier: GPL-2.0-or-later
*/

const Gio = imports.gi.Gio;
const GLib = imports.gi.GLib;
const Gtk = imports.gi.Gtk;

// It's common practice to keep GNOME API and JS imports in separate blocks
const Lang = imports.lang;
const ExtensionUtils = imports.misc.extensionUtils;
const Me = ExtensionUtils.getCurrentExtension();
const Convenience = Me.imports.convenience;

const Gettext = imports.gettext.domain('monito');
const _ = Gettext.gettext;
const N_ = function (e) {
    return e;
};

const SETTINGS_SCHEMA = "org.gnome.shell.extensions.monito@drieu.org";
const SETTINGS_SCHEMA_ACCOUNT = "org.gnome.shell.extensions.monito@drieu.org.account";
const SETTINGS_SCHEMA_ACCOUNT_PATH = "/org/gnome/shell/extensions/monito@drieu.org/account";


const prefs = [ { type: Gtk.Entry,		label: _('Name'),	key: 'name' },
		{ type: Gtk.ComboBoxText,	label: _('Type'),	key: 'type' },
		{ type: Gtk.Entry,		label: _('Username'),	key: 'username' },
		{ type: Gtk.Entry,		label: _('Password'),	key: 'password' },
		{ type: Gtk.Entry,		label: _('URL CGI'),	key: 'urlcgi' },
	      ];

// Like 'extension.js' this is used for any one-time setup like translations.
function init() {
    //    log('initializing ${Me.metadata.name} Preferences');
}


// This function is called when the preferences window is first created to build
// and return a Gtk widget. As an example we'll create and return a GtkLabel.
function buildPrefsWidget() {

    // Copy the same GSettings code from `extension.js`
    this.settings = ExtensionUtils.getSettings(SETTINGS_SCHEMA);

    let mainVbox = new Gtk.Box( { orientation: Gtk.Orientation.VERTICAL } );

    let mainWidget = new Gtk.Notebook( { } );

    let prefsWidget = new Gtk.Grid({
        margin: 18,
        column_spacing: 12,
        row_spacing: 12,
	column_homogeneous: false,
    });

    this.prefWidgets = { };

    // Add a simple title and add it to the prefsWidget
    let title = new Gtk.Label({
        label: `<b>${Me.metadata.name} Preferences</b>`,
        halign: Gtk.Align.START,
        use_markup: true,
    });
    prefsWidget.attach(title, 0, 0, 2, 1);

    // Misc Settings (TBD)
    mainWidget.append_page ( prefsWidget,
			     new Gtk.Label ( { label: 'General', } ) );


    // Accounts 
    let accountsWidgetContainer = new Gtk.Box( { orientation: Gtk.Orientation.HORIZONTAL,
						 homogeneous: false, } );
    mainWidget.append_page ( accountsWidgetContainer,
			     new Gtk.Label ( { label: 'Servers', } ) );

    let accountsChooserContainer = new Gtk.Box( { orientation: Gtk.Orientation.VERTICAL,
						  homogeneous: false, } );
    accountsWidgetContainer.pack_start(accountsChooserContainer, true, true, 0);

    let accountsChooser = new Gtk.ListBox ( { valign: Gtk.Align.FILL,
					      hexpand: true,
					      vexpand: true } );
    accountsChooserContainer.pack_start(accountsChooser, true, true, 0);

    // Account list
    for ( var server of this.settings.get_string ( 'servers' ) . split ( ',' ) )
    {
	let _account_settings = getAccountSettings ( server );
	let row = new Gtk.ListBoxRow ( { hexpand: true,
					 halign: Gtk.Align.FILL } );
	row.server= server
	let _label = new Gtk.Label ( { label: _account_settings.get_string('name'),
				       hexpand: true,
				       margin: 5,
				       halign: Gtk.Align.START,
				       expand: true } );
	row.add ( _label );
	_label.set_data ( 'server', GLib.strdup(server) );
	accountsChooser.add ( row );
    }
    accountsChooser.connect('row-activated', Lang.bind(this, function () {
	let _row = accountsChooser.get_selected_row();
	log('Active:' + _row.server);
	let _account_settings = getAccountSettings ( _row.server );

	for ( var prefEntry of prefs )
	{
	    if ( prefEntry.type == Gtk.Entry )
	    {
		// How to unbind previous one?
		_account_settings.bind (
		    prefEntry.key,
		    this.prefWidgets[prefEntry.key],
		    'text',
		    Gio.SettingsBindFlags.DEFAULT
		);
	    }
	    else if ( prefEntry.type == Gtk.ComboBoxText )
	    {
		this.prefWidgets[prefEntry.key].set_active(_account_settings.get_enum('type'));
		this.prefWidgets[prefEntry.key].connect('changed', Lang.bind(this, function () {
		    log('Active:' + this.prefWidgets[prefEntry.key].get_active());
                    _account_settings.set_enum('type', this.prefWidgets[prefEntry.key].get_active());
		}));
	    }
	}
    } ) );



    let accountsChooserActionBar = new Gtk.ActionBar ( { visible: true,
							 valign: Gtk.Align.END,
							 vexpand: false} );
    accountsChooserContainer.pack_start(accountsChooserActionBar, true, true, 0);

    let accountsWidget = new Gtk.Grid ( {
	halign: Gtk.Align.FILL,
	margin: 18,
        column_spacing: 12,
        row_spacing: 12,
        visible: true,
	column_homogeneous: false,
    });
    accountsWidgetContainer.pack_start(accountsWidget, true, true, 0);

    let y = 1;
    for ( var prefEntry of prefs )
    {
	let _label = new Gtk.Label({
            label: prefEntry.label + ':',
            visible: true,
            halign: Gtk.Align.START,
	});
	accountsWidget.attach ( _label, 0, y, 1, 1 );

	this.prefWidgets[prefEntry.key] = new prefEntry.type({
            halign: Gtk.Align.FILL,
            visible: true,
	    hexpand: true,
	});

	let boundValue = 'text';
	if ( prefEntry.key == 'password' )
	{
	    this.prefWidgets[prefEntry.key].set_input_purpose ( Gtk.InputPurpose.PASSWORD );
	    this.prefWidgets[prefEntry.key].set_visibility ( false );
	}
	else if ( prefEntry.key == 'type' )
	{
            [ 'Icinga', 'Icinga2' ].forEach((item) => {
		this.prefWidgets[prefEntry.key].append_text(item);
	    } );
	}

	accountsWidget.attach(this.prefWidgets[prefEntry.key], 1, y, 1, 1);

	if ( prefEntry.type != Gtk.ComboBoxText )
	{
            //	    this.account_settings.bind(
            //		prefEntry.key,
            //		_entry,
            //		boundValue,
            //		Gio.SettingsBindFlags.DEFAULT
            //	    );
	}
	y++;
    }

    mainVbox.pack_start(mainWidget, true, true, 0);
    mainVbox.show_all();

    return mainVbox;
}

function getAccountSettings ( id )
{
    let _path = SETTINGS_SCHEMA_ACCOUNT_PATH + '/' + id;
    return Convenience.getSettings(SETTINGS_SCHEMA_ACCOUNT, _path);
}