/* vim:set et sts=4 sw=4:

 *

 * ibus - The Input Bus

 *

 * Copyright (c) 2017-2018 Takao Fujiwara <takao.fujiwara1@gmail.com>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library; if not, write to the Free Software

 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301

 * USA

 */

public class IBusEmojier : Gtk.ApplicationWindow {

    private class EEntry : Gtk.SearchEntry {

        public EEntry() {

            GLib.Object(

                name : "IBusEmojierEntry",

                margin_start : 6,

                margin_end : 6,

                margin_top : 6,

                margin_bottom : 6

            );

        }

    }

    private class EListBox : Gtk.ListBox {

        public EListBox() {

            GLib.Object(

                vexpand : true,

                halign : Gtk.Align.FILL,

                valign : Gtk.Align.FILL

            );

            this.motion_notify_event.connect((e) => {

#if VALA_0_24

                Gdk.EventMotion pe = e;

#else

                Gdk.EventMotion *pe = &e;

#endif

                if (m_mouse_x == pe.x_root && m_mouse_y == pe.y_root)

                    return false;

                m_mouse_x = pe.x_root;

                m_mouse_y = pe.y_root;

                var row = this.get_row_at_y((int)e.y);

                if (row != null)

                    this.select_row(row);

                return false;

            });

            this.enter_notify_event.connect((e) => {

                // avoid gtk_button_update_state()

                return true;

            });

        }

    }

    private class EBoxRow : Gtk.ListBoxRow {

        public EBoxRow(string text) {

            this.text = text;

        }

        public string text { get; set; }

    }

    private class EScrolledWindow : Gtk.ScrolledWindow {

        public EScrolledWindow(Gtk.Adjustment? hadjustment=null,

                               Gtk.Adjustment? vadjustment=null) {

            GLib.Object(

                hscrollbar_policy : Gtk.PolicyType.NEVER,

                vscrollbar_policy : Gtk.PolicyType.NEVER,

                shadow_type : Gtk.ShadowType.IN,

                margin_start : 6,

                margin_end : 6,

                margin_top : 6,

                margin_bottom : 6

            );

            if (hadjustment != null)

                set_hadjustment(hadjustment);

            if (vadjustment != null)

                set_hadjustment(vadjustment);

        }

    }

    private class EGrid : Gtk.Grid {

        public EGrid() {

            GLib.Object(

                row_homogeneous : false,

                vexpand : true,

                halign : Gtk.Align.FILL,

                valign : Gtk.Align.FILL,

                row_spacing : 5,

                column_spacing : 5,

                border_width : 2

            );

        }

    }

    private class EWhiteLabel : Gtk.Label {

        private int m_minimum_width = 0;

        private int m_natural_width = 0;

        private int m_minimum_height = 0;

        private int m_natural_height = 0;

        public EWhiteLabel(string text) {

            GLib.Object(

                name : "IBusEmojierWhiteLabel"

            );

            set_label(text);

        }

        public override void get_preferred_width(out int minimum_width,

                                                 out int natural_width) {

            if (m_minimum_height == 0 && m_natural_height == 0) {

                base.get_preferred_height(out m_minimum_height,

                                          out m_natural_height);

            }

            var text = get_label();

            var ch = text.get_char();

            if (text.length == 1 && ch == '\t') {

                m_minimum_width = minimum_width = m_minimum_height;

                m_natural_width = natural_width = m_natural_height;

                return;

            }

            base.get_preferred_width(out minimum_width, out natural_width);

            if (text.length == 1 && (ch == '\n' || ch == '\r')) {

                minimum_width /= 2;

                natural_width /= 2;

                m_minimum_width = minimum_width;

                m_natural_width = natural_width;

                return;

            }

            if (minimum_width < m_minimum_height)

                minimum_width = m_minimum_height;

            if (natural_width < m_natural_height)

                natural_width = m_natural_height;

            m_minimum_width = minimum_width;

            m_natural_width = natural_width;

        }

        public override void get_preferred_height(out int minimum_height,

                                                  out int natural_height) {

            if (m_minimum_width == 0 && m_natural_width == 0) {

                base.get_preferred_width(out m_minimum_width,

                                         out m_natural_width);

            }

            var text = get_label();

            var ch = text.get_char();

            if (text.length == 1 && ch == '\v') {

                m_minimum_height = minimum_height = m_minimum_width;

                m_natural_height = natural_height = m_natural_width;

                return;

            }

            base.get_preferred_height(out minimum_height, out natural_height);

            if (text.length == 1 && (ch == '\n' || ch == '\r')) {

                minimum_height /= 2;

                natural_height /= 2;

                m_minimum_height = minimum_height;

                m_natural_height = natural_height;

                return;

            }

            m_minimum_height = minimum_height;

            m_natural_height = natural_height;

        }

    }

    private class ESelectedLabel : EWhiteLabel {

        public ESelectedLabel(string text) {

            GLib.Object(

                name : "IBusEmojierSelectedLabel"

            );

            if (text != "")

                set_label(text);

        }

    }

    private class EGoldLabel : EWhiteLabel {

        public EGoldLabel(string text) {

            GLib.Object(

                name : "IBusEmojierGoldLabel"

            );

            if (text != "")

                set_label(text);

        }

    }

    private class EPaddedLabel : Gtk.Label {

        public EPaddedLabel(string          text,

                            Gtk.Align       align) {

            GLib.Object(

                name : "IBusEmojierPaddedLabel",

                halign : align,

                valign : Gtk.Align.CENTER,

                margin_start : 20,

                margin_end : 20,

                margin_top : 6,

                margin_bottom : 6

            );

            set_text(text);

        }

    }

    private class EPaddedLabelBox : Gtk.Box {

        public EPaddedLabelBox(string          text,

                               Gtk.Align       align,

                               TravelDirection direction=TravelDirection.NONE,

                               string?         caption=null) {

            GLib.Object(

                name : "IBusEmojierPaddedLabelBox",

                orientation : Gtk.Orientation.HORIZONTAL,

                spacing : 0

            );

            if (direction == TravelDirection.BACKWARD) {

                IconWidget icon;

                if (Gtk.Widget.get_default_direction() ==

                    Gtk.TextDirection.RTL) {

                    icon = new IconWidget("go-previous-rtl-symbolic",

                                          Gtk.IconSize.MENU);

                } else {

                    icon = new IconWidget("go-previous-symbolic",

                                          Gtk.IconSize.MENU);

                }

                pack_start(icon, false, true, 0);

            }

            EPaddedLabel label = new EPaddedLabel(text, align);

            pack_start(label, true, true, 0);

            if (caption != null) {

                EPaddedLabel label_r = new EPaddedLabel(caption,

                                                        Gtk.Align.END);

                pack_end(label_r, true, true, 0);

            }

        }

    }

    private class LoadProgressObject : GLib.Object {

        public LoadProgressObject() {

        }

        public signal void deserialize_unicode(uint done, uint total);

    }

    private enum TravelDirection {

        NONE,

        BACKWARD,

    }

    public const uint BUTTON_CLOSE_BUTTON = 1000;

    private const uint EMOJI_GRID_PAGE = 10;

    private const string EMOJI_CATEGORY_FAVORITES = N_("Favorites");

    private const string EMOJI_CATEGORY_OTHERS = N_("Others");

    private const string EMOJI_CATEGORY_UNICODE = N_("Open Unicode choice");

    private const unichar[] EMOJI_VARIANT_LIST = {

            0x1f3fb, 0x1f3fc, 0x1f3fd, 0x1f3fe, 0x1f3ff, 0x200d };

    // Set the actual default values in the constructor

    // because these fields are used for class_init() and static functions,

    // e.g. set_emoji_font(), can be called before class_init() is called.

    private static string m_current_lang_id;

    private static string m_emoji_font_family;

    private static int m_emoji_font_size;

    private static bool m_emoji_font_changed = false;

    private static string[] m_favorites;

    private static string[] m_favorite_annotations;

    private static int m_emoji_max_seq_len;

    private static bool m_has_partial_match;

    private static uint m_partial_match_length;

    private static uint m_partial_match_condition;

    private static bool m_show_emoji_variant = false;

    private static int m_default_window_width;

    private static int m_default_window_height;

    private static GLib.HashTable<string, GLib.SList<string>>?

            m_annotation_to_emojis_dict;

    private static GLib.HashTable<string, IBus.EmojiData>?

            m_emoji_to_data_dict;

    private static GLib.HashTable<string, GLib.SList<string>>?

            m_category_to_emojis_dict;

    private static GLib.HashTable<string, GLib.SList<string>>?

            m_emoji_to_emoji_variants_dict;

    private static GLib.HashTable<unichar, IBus.UnicodeData>?

            m_unicode_to_data_dict;

    private static GLib.HashTable<string, GLib.SList<unichar>>?

            m_name_to_unicodes_dict;

    private static GLib.SList<IBus.UnicodeBlock> m_unicode_block_list;

    private static bool m_show_unicode = false;

    private static LoadProgressObject m_unicode_progress_object;

    private static bool m_loaded_unicode = false;

    private static string m_warning_message = "";

    private ThemedRGBA m_rgba;

    private Gtk.Box m_vbox;

    private EEntry m_entry;

    /* If emojier is emoji category list or Unicode category list,

     * m_annotation is "" and preedit is also "".

     * If emojier is candidate mode, m_annotation is an annotation and

     * get_current_candidate() returns the current emoji.

     * But the current preedit can be "" in candidate mode in case that

     * Unicode candidate window has U+0000.

     */

    private string m_annotation = "";

    private string? m_backward;

    private int m_backward_index = -1;

    private EScrolledWindow? m_scrolled_window = null;

    private EListBox m_list_box;

    private bool m_is_running = false;

    private string m_input_context_path = "";

    private GLib.MainLoop? m_loop;

    private string? m_result;

    /* If m_candidate_panel_is_visible is true, emojier is candidate mode and

     * the emoji lookup window is visible.

     * If m_candidate_panel_is_visible is false, the emoji lookup window is

     * not visible but the mode is not clear.

     */

    private bool m_candidate_panel_is_visible;

    /* If m_candidate_panel_mode is true, emojier is candidate mode and

     * it does not depend on whether the window is visible or not.

     * I.E. the first candidate does not show the lookup window and the

     * second one shows the window.

     * If m_candidate_panel_mode is false, emojier is emoji category list or

     * Unicode category list.

     */

    private bool m_candidate_panel_mode;

    private int m_category_active_index = -1;

    private IBus.LookupTable m_lookup_table;

    private Gtk.Label[] m_candidates;

    private bool m_enter_notify_enable = true;

    private uint m_entry_notify_show_id;

    private uint m_entry_notify_disable_id;

    protected static double m_mouse_x;

    protected static double m_mouse_y;

    private Gtk.ProgressBar m_unicode_progress_bar;

    private uint m_unicode_progress_id;

    private Gtk.Label m_unicode_percent_label;

    private double m_unicode_percent;

    private Gdk.Rectangle m_cursor_location;

    private bool m_is_up_side_down = false;

    private uint m_redraw_window_id;

    public signal void candidate_clicked(uint index, uint button, uint state);

    public IBusEmojier() {

        GLib.Object(

            type : Gtk.WindowType.POPUP

        );

        // GLib.ActionEntry accepts const variables only.

        var action = new GLib.SimpleAction.stateful(

                "variant",

                null,

                new GLib.Variant.boolean(m_show_emoji_variant));

        action.activate.connect(check_action_variant_cb);

        add_action(action);

        action = new GLib.SimpleAction("close", null);

        action.activate.connect(action_close_cb);

        add_action(action);

        if (m_current_lang_id == null)

            m_current_lang_id = "en";

        if (m_emoji_font_family == null) {

            m_emoji_font_family = "Monospace";

            m_emoji_font_changed = true;

        }

        if (m_emoji_font_size == 0) {

            m_emoji_font_size = 16;

            m_emoji_font_changed = true;

        }

        if (m_favorites == null)

            m_favorites = {};

        if (m_favorite_annotations == null)

            m_favorite_annotations = {};

        set_css_data();

        m_vbox = new Gtk.Box(Gtk.Orientation.VERTICAL, 0);

        add(m_vbox);

        m_entry = new EEntry();

        m_entry.set_placeholder_text(_("Type annotation or choose emoji"));

        //m_vbox.add(m_entry);

        m_entry.changed.connect(() => {

            update_candidate_window();

        });

        m_entry.icon_release.connect((icon_pos, event) => {

            hide_candidate_panel();

        });

        /* Set the accessible role of the label to a status bar so it

         * will emit name changed events that can be used by screen

         * readers.

         */

        Atk.Object obj = m_entry.get_accessible();

        obj.set_role (Atk.Role.STATUSBAR);

        // The constructor of IBus.LookupTable does not support more than

        // 16 pages.

        m_lookup_table = new IBus.LookupTable(1, 0, true, true);

        m_lookup_table.set_page_size(EMOJI_GRID_PAGE * EMOJI_GRID_PAGE);

        hide.connect(() => {

            if (m_loop != null && m_loop.is_running())

                m_loop.quit();

        });

        size_allocate.connect((w, a) => {

            adjust_window_position();

        });

        candidate_clicked.connect((i, b, s) => {

            if (m_input_context_path != "")

                candidate_panel_select_index(i, b);

        });

        if (m_annotation_to_emojis_dict == null) {

            reload_emoji_dict();

        }

        get_load_progress_object();

    }

    private static void reload_emoji_dict() {

        init_emoji_dict();

        make_emoji_dict("en");

        if (m_current_lang_id != "en") {

            var lang_ids = m_current_lang_id.split("_");

            if (lang_ids.length > 1) {

                string sub_id = lang_ids[0];

                make_emoji_dict(sub_id);

            }

            make_emoji_dict(m_current_lang_id);

        }

        update_favorite_emoji_dict();

    }

    private static void init_emoji_dict() {

        m_annotation_to_emojis_dict =

                new GLib.HashTable<string, GLib.SList<string>>(GLib.str_hash,

                                                               GLib.str_equal);

        m_emoji_to_data_dict =

                new GLib.HashTable<string, IBus.EmojiData>(GLib.str_hash,

                                                           GLib.str_equal);

        m_category_to_emojis_dict =

                new GLib.HashTable<string, GLib.SList<string>>(GLib.str_hash,

                                                               GLib.str_equal);

        m_emoji_to_emoji_variants_dict =

                new GLib.HashTable<string, GLib.SList<string>>(GLib.str_hash,

                                                               GLib.str_equal);

        m_unicode_to_data_dict =

                new GLib.HashTable<unichar, IBus.UnicodeData>(

                        GLib.direct_hash,

                        GLib.direct_equal);

        m_name_to_unicodes_dict =

                new GLib.HashTable<string, GLib.SList<unichar>>(GLib.str_hash,

                                                                GLib.str_equal);

    }

    private static void make_emoji_dict(string lang) {

        GLib.SList<IBus.EmojiData> emoji_list = IBus.EmojiData.load(

                    Config.PKGDATADIR + "/dicts/emoji-" + lang + ".dict");

        if (emoji_list == null)

            return;

        foreach (IBus.EmojiData data in emoji_list) {

            update_emoji_to_data_dict(data, lang);

            update_annotation_to_emojis_dict(data);

            update_category_to_emojis_dict(data, lang);

        }

        GLib.List<unowned string> annotations =

                m_annotation_to_emojis_dict.get_keys();

        foreach (unowned string annotation in annotations) {

            if (m_emoji_max_seq_len < annotation.length)

                m_emoji_max_seq_len = annotation.length;

        }

    }

    private static void update_annotation_to_emojis_dict(IBus.EmojiData data) {

        string emoji = data.get_emoji();

        unowned GLib.SList<string> annotations = data.get_annotations();

        foreach (string annotation in annotations) {

            bool has_emoji = false;

            GLib.SList<string> hits =

                    m_annotation_to_emojis_dict.lookup(annotation).copy_deep(

                            GLib.strdup);

            foreach (string hit_emoji in hits) {

                if (hit_emoji == emoji) {

                    has_emoji = true;

                    break;

                }

            }

            if (!has_emoji) {

                hits.append(emoji);

                m_annotation_to_emojis_dict.replace(

                        annotation,

                        hits.copy_deep(GLib.strdup));

            }

        }

    }

    private static string utf8_code_point(string str) {

        var buff = new GLib.StringBuilder();

        int length = str.char_count();

        if (length == 0) {

            buff.append("U+%04X".printf(0));

            return buff.str;

        }

        for (int i = 0; i < length; i++) {

            unichar ch = str.get_char(0);

            if (i == 0)

                buff.append("U+%04X".printf(ch));

            else

                buff.append(" %04X".printf(ch));

            str = str.next_char();

        }

        return buff.str;

    }

    private static string utf8_entity(string str) {

        var buff = new GLib.StringBuilder();

        int length = str.char_count();

        for (int i = 0; i < length; i++) {

            unichar ch = str.get_char(0);

            switch(ch) {

            case '<':

                buff.append("<");

                break;

            case '>':

                buff.append(">");

                break;

            case '&':

                buff.append("&");

                break;

            default:

                buff.append_unichar(ch);

                break;

            }

            str = str.next_char();

        }

        return buff.str;

    }

    private static void

    update_annotations_with_description (IBus.EmojiData data,

                                         string         description) {

        GLib.SList<string> annotations =

                data.get_annotations().copy_deep(GLib.strdup);

        bool update_annotations = false;

        string former = null;

        string later = null;

        int index = description.index_of(": ");

        if (index > 0) {

            former = description.substring(0, index);

            if (annotations.find_custom(former, GLib.strcmp) == null) {

                annotations.append(former);

                update_annotations = true;

            }

            later = description.substring(index + 2);

        } else {

            later = description.dup();

        }

        var words = later.split(" ");

        // If the description has less than 3 words, add it to annotations

        // FIXME: How to cast GLib.CompareFunc<string> to strcmp?

        if (words.length < 3 &&

            annotations.find_custom(

                    later,

                    GLib.strcmp) == null) {

            annotations.append(later);

            update_annotations = true;

        }

        if (update_annotations)

            data.set_annotations(annotations.copy_deep(GLib.strdup));

    }

    private static void update_emoji_to_data_dict(IBus.EmojiData data,

                                                  string         lang) {

        string emoji = data.get_emoji();

        if (lang == "en") {

            string description = data.get_description().down();

            update_annotations_with_description (data, description);

            m_emoji_to_data_dict.replace(emoji, data);

        } else {

            unowned IBus.EmojiData? en_data = null;

            en_data = m_emoji_to_data_dict.lookup(emoji);

            if (en_data == null) {

                m_emoji_to_data_dict.insert(emoji, data);

                return;

            }

            string trans_description = data.get_description();

            en_data.set_description(trans_description);

            trans_description = trans_description.down();

            update_annotations_with_description (data, trans_description);

            unowned GLib.SList<string> annotations = data.get_annotations();

            unowned GLib.SList<string> en_annotations

                = en_data.get_annotations();

            foreach (string annotation in en_annotations) {

                // FIXME: How to cast GLib.CompareFunc<string> to strcmp?

                if (annotations.find_custom(

                            annotation,

                            GLib.strcmp) == null) {

                    annotations.append(annotation.dup());

                }

            }

            en_data.set_annotations(annotations.copy_deep(GLib.strdup));

        }

    }

    private static void update_category_to_emojis_dict(IBus.EmojiData data,

                                                       string         lang) {

        string emoji = data.get_emoji();

        string category = data.get_category();

        if (category == "")

            category = EMOJI_CATEGORY_OTHERS;

        if (lang == "en") {

            bool has_variant = false;

            foreach (unichar ch in EMOJI_VARIANT_LIST) {

                if (emoji.index_of_char(ch) >= 0) {

                    has_variant = true;

                    break;

                }

            }

            // If emoji includes variants (skin colors and items),

            // it's escaped in m_emoji_to_emoji_variants_dict and

            // not shown by default.

            if (has_variant) {

                unichar base_ch = emoji.get_char();

                string base_emoji  = base_ch.to_string();

                var buff = new GLib.StringBuilder();

                buff.append_unichar(base_ch);

                buff.append_unichar(0xfe0f);

                if (m_emoji_to_data_dict.lookup(buff.str) != null)

                    base_emoji = buff.str;

                GLib.SList<string>? variants =

                        m_emoji_to_emoji_variants_dict.lookup(

                                base_emoji).copy_deep(GLib.strdup);

                if (variants.find_custom(emoji, GLib.strcmp) == null) {

                    if (variants == null)

                        variants.append(base_emoji);

                    variants.append(emoji);

                    m_emoji_to_emoji_variants_dict.replace(

                            base_emoji,

                            variants.copy_deep(GLib.strdup));

                }

                return;

            }

            bool has_emoji = false;

            GLib.SList<string> hits =

                    m_category_to_emojis_dict.lookup(category).copy_deep(

                            GLib.strdup);

            foreach (string hit_emoji in hits) {

                if (hit_emoji == emoji) {

                    has_emoji = true;

                    break;

                }

            }

            if (!has_emoji) {

                hits.append(emoji);

                m_category_to_emojis_dict.replace(category,

                                                  hits.copy_deep(GLib.strdup));

            }

        }

    }

    private static void make_unicode_block_dict() {

        m_unicode_block_list = IBus.UnicodeBlock.load(

                    Config.PKGDATADIR + "/dicts/unicode-blocks.dict");

        foreach (unowned IBus.UnicodeBlock block in m_unicode_block_list) {

            unowned string name = block.get_name();

            if (m_emoji_max_seq_len < name.length)

                m_emoji_max_seq_len = name.length;

        }

    }

    private static void make_unicode_name_dict(Object source_object) {

        IBus.UnicodeData.load_async(

                    Config.PKGDATADIR + "/dicts/unicode-names.dict",

                    source_object,

                    null,

        (IBus.UnicodeDataLoadAsyncFinish)make_unicode_name_dict_finish);

    }

    private static void

    make_unicode_name_dict_finish(GLib.SList<IBus.UnicodeData> unicode_list) {

        if (unicode_list == null)

            return;

        foreach (IBus.UnicodeData data in unicode_list) {

            update_unicode_to_data_dict(data);

            update_name_to_unicodes_dict(data);

        }

        GLib.List<unowned string> names =

                m_name_to_unicodes_dict.get_keys();

        foreach (unowned string name in names) {

            if (m_emoji_max_seq_len < name.length)

                m_emoji_max_seq_len = name.length;

        }

        m_loaded_unicode = true;

    }

    private static void update_unicode_to_data_dict(IBus.UnicodeData data) {

        unichar code = data.get_code();

        m_unicode_to_data_dict.replace(code, data);

    }

    private static void update_name_to_unicodes_dict(IBus.UnicodeData data) {

        unichar code = data.get_code();

        string[] names = {data.get_name().down(), data.get_alias().down()};

        foreach (unowned string name in names) {

            if (name == "")

                continue;

            bool has_code = false;

            GLib.SList<unichar> hits =

                    m_name_to_unicodes_dict.lookup(name).copy();

            foreach (unichar hit_code in hits) {

                if (hit_code == code) {

                    has_code = true;

                    break;

                }

            }

            if (!has_code) {

                hits.append(code);

                m_name_to_unicodes_dict.replace(name, hits.copy());

            }

        }

    }

    private void set_css_data() {

        Gdk.Display display = Gdk.Display.get_default();

        Gdk.Screen screen = (display != null) ?

                display.get_default_screen() : null;

        if (screen == null) {

            warning("Could not open display.");

            return;

        }

        // Set en locale because de_DE's decimal_point is ',' instead of '.'

        string? backup_locale =

            Intl.setlocale(LocaleCategory.NUMERIC, null).dup();

        if (Intl.setlocale(LocaleCategory.NUMERIC, "en_US.UTF-8") == null) {

          if (Intl.setlocale(LocaleCategory.NUMERIC, "C.UTF-8") == null) {

              if (Intl.setlocale(LocaleCategory.NUMERIC, "C") == null) {

                  warning("You don't install either en_US.UTF-8 or C.UTF-8 " +

                          "or C locale");

              }

          }

        }

        if (m_rgba == null)

            m_rgba = new ThemedRGBA(this);

        uint bg_red = (uint)(m_rgba.normal_bg.red * 255);

        uint bg_green = (uint)(m_rgba.normal_bg.green * 255);

        uint bg_blue = (uint)(m_rgba.normal_bg.blue * 255);

        double bg_alpha = m_rgba.normal_bg.alpha;

        string data =

                "#IBusEmojierWhiteLabel { background-color: " +

                        "rgba(%u, %u, %u, %lf); ".printf(

                        bg_red, bg_green, bg_blue, bg_alpha) +

                "font-family: %s; font-size: %dpt; ".printf(

                        m_emoji_font_family, m_emoji_font_size) +

                "border-width: 4px; border-radius: 3px; } ";

        uint fg_red = (uint)(m_rgba.selected_fg.red * 255);

        uint fg_green = (uint)(m_rgba.selected_fg.green * 255);

        uint fg_blue = (uint)(m_rgba.selected_fg.blue * 255);

        double fg_alpha = m_rgba.selected_fg.alpha;

        bg_red = (uint)(m_rgba.selected_bg.red * 255);

        bg_green = (uint)(m_rgba.selected_bg.green * 255);

        bg_blue = (uint)(m_rgba.selected_bg.blue * 255);

        bg_alpha = m_rgba.selected_bg.alpha;

        data += "#IBusEmojierSelectedLabel { color: " +

                        "rgba(%u, %u, %u, %lf); ".printf(

                        fg_red, fg_green, fg_blue, fg_alpha) +

                "font-family: %s; font-size: %dpt; ".printf(

                        m_emoji_font_family, m_emoji_font_size) +

                "background-color: " +

                        "rgba(%u, %u, %u, %lf); ".printf(

                        bg_red, bg_green, bg_blue, bg_alpha) +

                "border-width: 4px; border-radius: 3px; }";

        data += "#IBusEmojierGoldLabel { color: " +

                        "rgba(%u, %u, %u, %lf); ".printf(

                        fg_red, fg_green, fg_blue, fg_alpha) +

                "font-family: %s; font-size: %dpt; ".printf(

                        m_emoji_font_family, m_emoji_font_size) +

                "background-color: #b09c5f; " +

                "border-width: 4px; border-radius: 3px; }";

        Gtk.CssProvider css_provider = new Gtk.CssProvider();

        try {

            css_provider.load_from_data(data, -1);

        } catch (GLib.Error e) {

            warning("Failed css_provider_from_data: %s", e.message);

            return;

        }

        if (backup_locale != null)

            Intl.setlocale(LocaleCategory.NUMERIC, backup_locale);

        else

            Intl.setlocale(LocaleCategory.NUMERIC, "");

        Gtk.StyleContext.add_provider_for_screen(

                screen,

                css_provider,

                Gtk.STYLE_PROVIDER_PRIORITY_APPLICATION);

    }

    private void set_fixed_size() {

        resize(20, 1);

    }

    private void remove_all_children() {

        if (m_list_box != null) {

            foreach (Gtk.Widget w in m_list_box.get_children()) {

                w.destroy();

            }

            m_list_box = null;

        }

        foreach (Gtk.Widget w in m_vbox.get_children()) {

            if (w.name == "IBusEmojierEntry" ||

                w.name == "IBusEmojierTitleLabelBox") {

                continue;

            }

            w.destroy();

        }

    }

    private void clamp_page() {

        Gtk.ListBoxRow row;

        if (m_category_active_index >= 0) {

            row = m_list_box.get_row_at_index(m_category_active_index);

            m_list_box.select_row(row);

        } else {

            row = m_list_box.get_row_at_index(0);

        }

        Gtk.Allocation alloc = { 0, 0, 0, 0 };

        row.get_allocation(out alloc);

        var adjustment = m_scrolled_window.get_vadjustment();

        adjustment.clamp_page(alloc.y, alloc.y + alloc.height);

        return_val_if_fail(m_category_active_index >= 0, false);

        m_lookup_table.set_cursor_pos((uint)m_category_active_index);

    }

    private void show_category_list() {

        // Do not call remove_all_children() to work adjustment.clamp_page()

        // with PageUp/Down.

        // After show_candidate_panel() is called, m_category_active_index

        // is saved for Escape key but m_list_box is null by

        // remove_all_children().

        if (m_category_active_index >= 0 && m_list_box != null) {

            var row = m_list_box.get_row_at_index(m_category_active_index);

            m_list_box.select_row(row);

            return;

        }

        if (m_category_active_index < 0)

            m_category_active_index = 0;

        remove_all_children();

        m_scrolled_window = new EScrolledWindow();

        set_fixed_size();

        m_vbox.add(m_scrolled_window);

        Gtk.Viewport viewport = new Gtk.Viewport(null, null);

        m_scrolled_window.add(viewport);

        m_list_box = new EListBox();

        viewport.add(m_list_box);

        Gtk.Adjustment adjustment = m_scrolled_window.get_vadjustment();

        m_list_box.set_adjustment(adjustment);

        m_list_box.row_activated.connect((box, gtkrow) => {

            m_category_active_index = gtkrow.get_index();

            EBoxRow row = gtkrow as EBoxRow;

            show_emoji_for_category(row.text);

            show_all();

        });

        uint ncandidates = m_lookup_table.get_number_of_candidates();