afb81b8278
Some checks failed
Docker. / Ubuntu (push) Has been cancelled
User-agent updater. / User-agent (push) Failing after 15s
Lock Threads / lock (push) Failing after 10s
Waiting for answer. / waiting-for-answer (push) Failing after 22s
Needs user action. / needs-user-action (push) Failing after 8s
Can't reproduce. / cant-reproduce (push) Failing after 8s
Close stale issues and PRs / stale (push) Has been cancelled
703 lines
22 KiB
C
703 lines
22 KiB
C
/* -*- Mode: C; indent-tabs-mode: nil; c-basic-offset: 2; tab-width: 2 -*- */
|
|
/*
|
|
* nimf-candidate.c
|
|
* This file is part of Nimf.
|
|
*
|
|
* Copyright (C) 2015-2019 Hodong Kim <cogniti@gmail.com>
|
|
*
|
|
* Nimf 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 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* Nimf 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 program; If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
#include <glib/gi18n.h>
|
|
#include <gtk/gtk.h>
|
|
#include "nimf.h"
|
|
|
|
#define NIMF_TYPE_CANDIDATE (nimf_candidate_get_type ())
|
|
#define NIMF_CANDIDATE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), NIMF_TYPE_CANDIDATE, NimfCandidate))
|
|
#define NIMF_CANDIDATE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), NIMF_TYPE_CANDIDATE, NimfCandidateClass))
|
|
#define NIMF_IS_CANDIDATE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), NIMF_TYPE_CANDIDATE))
|
|
#define NIMF_IS_CANDIDATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), NIMF_TYPE_CANDIDATE))
|
|
#define NIMF_CANDIDATE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NIMF_TYPE_CANDIDATE, NimfCandidateClass))
|
|
|
|
typedef struct _NimfCandidate NimfCandidate;
|
|
typedef struct _NimfCandidateClass NimfCandidateClass;
|
|
|
|
struct _NimfCandidateClass
|
|
{
|
|
NimfServiceClass parent_class;
|
|
};
|
|
|
|
struct _NimfCandidate
|
|
{
|
|
NimfService parent_instance;
|
|
|
|
gchar *id;
|
|
gboolean active;
|
|
|
|
NimfServiceIC *target;
|
|
GtkWidget *window;
|
|
GtkWidget *entry;
|
|
GtkWidget *treeview;
|
|
GtkWidget *scrollbar;
|
|
gint cell_height;
|
|
};
|
|
|
|
GType nimf_candidate_get_type (void) G_GNUC_CONST;
|
|
|
|
enum
|
|
{
|
|
INDEX_COLUMN,
|
|
MAIN_COLUMN,
|
|
EXTRA_COLUMN,
|
|
N_COLUMNS
|
|
};
|
|
|
|
static void
|
|
nimf_candidate_show (NimfCandidatable *candidatable,
|
|
NimfServiceIC *target,
|
|
gboolean show_entry)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkRequisition natural_size;
|
|
int x, y, w, h;
|
|
GdkRectangle geometry;
|
|
const NimfRectangle *cursor_area;
|
|
|
|
cursor_area = nimf_service_ic_get_cursor_location (target);
|
|
|
|
#if GTK_CHECK_VERSION (3, 22, 0)
|
|
GdkDisplay *display = gtk_widget_get_display (candidate->window);
|
|
GdkMonitor *monitor;
|
|
monitor = gdk_display_get_monitor_at_point (display,
|
|
cursor_area->x, cursor_area->y);
|
|
gdk_monitor_get_geometry (monitor, &geometry);
|
|
#else
|
|
GdkScreen *screen = gtk_widget_get_screen (candidate->window);
|
|
gint monitor_num = gdk_screen_get_monitor_at_point (screen,
|
|
cursor_area->x,
|
|
cursor_area->y);
|
|
gdk_screen_get_monitor_geometry (screen, monitor_num, &geometry);
|
|
#endif
|
|
|
|
candidate->target = target;
|
|
|
|
if (show_entry)
|
|
gtk_widget_show (candidate->entry);
|
|
else
|
|
gtk_widget_hide (candidate->entry);
|
|
|
|
gtk_widget_show_all (candidate->window);
|
|
gtk_widget_get_preferred_size (candidate->window, NULL, &natural_size);
|
|
gtk_window_resize (GTK_WINDOW (candidate->window),
|
|
natural_size.width, natural_size.height);
|
|
gtk_window_get_size (GTK_WINDOW (candidate->window), &w, &h);
|
|
|
|
x = cursor_area->x - cursor_area->width;
|
|
y = cursor_area->y + cursor_area->height;
|
|
|
|
if (x + w > geometry.x + geometry.width)
|
|
x = geometry.x + geometry.width - w;
|
|
|
|
if ((y + h > geometry.y + geometry.height) &&
|
|
((cursor_area->y - h) >= geometry.y))
|
|
y = cursor_area->y - h;
|
|
|
|
gtk_window_move (GTK_WINDOW (candidate->window), x, y);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_hide (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
gtk_widget_hide (NIMF_CANDIDATE (candidatable)->window);
|
|
}
|
|
|
|
static gboolean
|
|
nimf_candidate_is_visible (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
return gtk_widget_is_visible (NIMF_CANDIDATE (candidatable)->window);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_set_page_values (NimfCandidatable *candidatable,
|
|
NimfServiceIC *target,
|
|
gint page_index,
|
|
gint n_pages,
|
|
gint page_size)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkRange *range = GTK_RANGE (candidate->scrollbar);
|
|
|
|
candidate->target = target;
|
|
gtk_range_set_range (range, 1.0, (gdouble) n_pages + 1.0);
|
|
|
|
if (page_index != (gint) gtk_range_get_value (range))
|
|
gtk_range_set_value (range, (gdouble) page_index);
|
|
|
|
gtk_widget_set_size_request (candidate->treeview,
|
|
(gint) (candidate->cell_height * 10 / 1.6),
|
|
candidate->cell_height * page_size);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_clear (NimfCandidatable *candidatable,
|
|
NimfServiceIC *target)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
gtk_list_store_clear (GTK_LIST_STORE (model));
|
|
nimf_candidate_set_page_values (candidatable, target, 1, 1, 5);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_append (NimfCandidatable *candidatable,
|
|
const gchar *text1,
|
|
const gchar *text2)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeIter iter;
|
|
gint n_row;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
n_row = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);
|
|
|
|
gtk_list_store_append (GTK_LIST_STORE (model), &iter);
|
|
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
|
|
INDEX_COLUMN, (n_row + 1) % 10,
|
|
MAIN_COLUMN, text1, -1);
|
|
|
|
if (text2)
|
|
gtk_list_store_set (GTK_LIST_STORE (model), &iter,
|
|
EXTRA_COLUMN, text2, -1);
|
|
}
|
|
|
|
static gint
|
|
nimf_candidate_get_selected_index (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeIter iter;
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
gint index = -1;
|
|
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_selection_get_selected (selection, &model, &iter))
|
|
{
|
|
GtkTreePath *path = gtk_tree_model_get_path (model, &iter);
|
|
gint *indices = gtk_tree_path_get_indices (path);
|
|
|
|
if (indices)
|
|
index = indices[0];
|
|
|
|
gtk_tree_path_free (path);
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
static gchar *
|
|
nimf_candidate_get_selected_text (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeIter iter;
|
|
GtkTreeModel *model;
|
|
gchar *text = NULL;
|
|
|
|
GtkTreeSelection *selection;
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_selection_get_selected (selection, &model, &iter))
|
|
gtk_tree_model_get (model, &iter, MAIN_COLUMN, &text, -1);
|
|
|
|
return text;
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_select_first_item_in_page (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
GtkTreeIter iter;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_model_get_iter_first (model, &iter))
|
|
gtk_tree_selection_select_iter (selection, &iter);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_select_last_item_in_page (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
GtkTreeIter iter;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
gint n_row = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (model), NULL);
|
|
|
|
if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model),
|
|
&iter, NULL, MAX (0, n_row - 1)))
|
|
gtk_tree_selection_select_iter (selection, &iter);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_select_item_by_index_in_page (NimfCandidatable *candidatable,
|
|
gint index)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
GtkTreeIter iter;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_model_iter_nth_child (GTK_TREE_MODEL (model), &iter, NULL, index))
|
|
gtk_tree_selection_select_iter (selection, &iter);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_select_previous_item (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
GtkTreeIter iter;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_selection_get_selected (selection, &model, &iter) == FALSE)
|
|
{
|
|
nimf_candidate_select_last_item_in_page (candidatable);
|
|
return;
|
|
}
|
|
|
|
if (gtk_tree_model_iter_previous (model, &iter))
|
|
{
|
|
gtk_tree_selection_select_iter (selection, &iter);
|
|
}
|
|
else
|
|
{
|
|
NimfEngineClass *engine_class;
|
|
NimfEngine *engine;
|
|
engine = nimf_service_ic_get_engine (candidate->target);
|
|
engine_class = NIMF_ENGINE_GET_CLASS (engine);
|
|
|
|
if (engine_class->candidate_page_up)
|
|
{
|
|
if (engine_class->candidate_page_up (engine, candidate->target))
|
|
nimf_candidate_select_last_item_in_page (candidatable);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_select_next_item (NimfCandidatable *candidatable)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
GtkTreeModel *model;
|
|
GtkTreeSelection *selection;
|
|
GtkTreeIter iter;
|
|
|
|
model = gtk_tree_view_get_model (GTK_TREE_VIEW (candidate->treeview));
|
|
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (candidate->treeview));
|
|
|
|
if (gtk_tree_selection_get_selected (selection, &model, &iter) == FALSE)
|
|
{
|
|
nimf_candidate_select_first_item_in_page (candidatable);
|
|
return;
|
|
}
|
|
|
|
if (gtk_tree_model_iter_next (model, &iter))
|
|
{
|
|
gtk_tree_selection_select_iter (selection, &iter);
|
|
}
|
|
else
|
|
{
|
|
NimfEngineClass *engine_class;
|
|
NimfEngine *engine;
|
|
engine = nimf_service_ic_get_engine (candidate->target);
|
|
engine_class = NIMF_ENGINE_GET_CLASS (engine);
|
|
|
|
if (engine_class->candidate_page_down)
|
|
{
|
|
if (engine_class->candidate_page_down (engine, candidate->target))
|
|
nimf_candidate_select_first_item_in_page (candidatable);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_set_auxiliary_text (NimfCandidatable *candidatable,
|
|
const gchar *text,
|
|
gint cursor_pos)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (candidatable);
|
|
|
|
gtk_entry_set_text (GTK_ENTRY (candidate->entry), text);
|
|
gtk_editable_set_position (GTK_EDITABLE (candidate->entry), cursor_pos);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_iface_init (NimfCandidatableInterface *iface)
|
|
{
|
|
iface->show = nimf_candidate_show;
|
|
iface->hide = nimf_candidate_hide;
|
|
iface->is_visible = nimf_candidate_is_visible;
|
|
iface->clear = nimf_candidate_clear;
|
|
iface->set_page_values = nimf_candidate_set_page_values;
|
|
iface->append = nimf_candidate_append;
|
|
iface->get_selected_index = nimf_candidate_get_selected_index;
|
|
iface->get_selected_text = nimf_candidate_get_selected_text;
|
|
iface->select_first_item_in_page = nimf_candidate_select_first_item_in_page;
|
|
iface->select_last_item_in_page = nimf_candidate_select_last_item_in_page;
|
|
iface->select_item_by_index_in_page = nimf_candidate_select_item_by_index_in_page;
|
|
iface->select_previous_item = nimf_candidate_select_previous_item;
|
|
iface->select_next_item = nimf_candidate_select_next_item;
|
|
iface->set_auxiliary_text = nimf_candidate_set_auxiliary_text;
|
|
}
|
|
|
|
G_DEFINE_DYNAMIC_TYPE_EXTENDED (NimfCandidate,
|
|
nimf_candidate,
|
|
NIMF_TYPE_SERVICE,
|
|
0,
|
|
G_IMPLEMENT_INTERFACE_DYNAMIC (NIMF_TYPE_CANDIDATABLE,
|
|
nimf_candidate_iface_init));
|
|
|
|
static const gchar *
|
|
nimf_candidate_get_id (NimfService *service)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
g_return_val_if_fail (NIMF_IS_SERVICE (service), NULL);
|
|
|
|
return NIMF_CANDIDATE (service)->id;
|
|
}
|
|
|
|
static gboolean
|
|
nimf_candidate_is_active (NimfService *service)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
return NIMF_CANDIDATE (service)->active;
|
|
}
|
|
|
|
static void
|
|
on_tree_view_row_activated (GtkTreeView *tree_view,
|
|
GtkTreePath *path,
|
|
GtkTreeViewColumn *column,
|
|
NimfCandidate *candidate)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfEngineClass *engine_class;
|
|
NimfEngine *engine;
|
|
|
|
engine = nimf_service_ic_get_engine (candidate->target);
|
|
|
|
g_return_if_fail (candidate->target && NIMF_IS_ENGINE (engine));
|
|
|
|
engine_class = NIMF_ENGINE_GET_CLASS (engine);
|
|
|
|
gchar *text;
|
|
gint *indices = gtk_tree_path_get_indices (path);
|
|
|
|
text = nimf_candidate_get_selected_text (NIMF_CANDIDATABLE (candidate));
|
|
|
|
if (engine_class->candidate_clicked)
|
|
engine_class->candidate_clicked (engine,
|
|
candidate->target, text, indices[0]);
|
|
g_free (text);
|
|
}
|
|
|
|
static gboolean
|
|
on_range_change_value (GtkRange *range,
|
|
GtkScrollType scroll,
|
|
gdouble value,
|
|
NimfCandidate *candidate)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfEngine *engine = nimf_service_ic_get_engine (candidate->target);
|
|
|
|
g_return_val_if_fail (candidate->target && NIMF_IS_ENGINE (engine), FALSE);
|
|
|
|
NimfEngineClass *engine_class;
|
|
GtkAdjustment *adjustment;
|
|
gdouble lower, upper;
|
|
|
|
adjustment = gtk_range_get_adjustment (range);
|
|
lower = gtk_adjustment_get_lower (adjustment);
|
|
upper = gtk_adjustment_get_upper (adjustment);
|
|
|
|
if (value < lower)
|
|
value = lower;
|
|
if (value > upper - 1)
|
|
value = upper - 1;
|
|
|
|
engine_class = NIMF_ENGINE_GET_CLASS (engine);
|
|
|
|
if (engine_class->candidate_scrolled)
|
|
engine_class->candidate_scrolled (engine, candidate->target, value);
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
on_entry_draw (GtkWidget *widget,
|
|
cairo_t *cr,
|
|
gpointer user_data)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
GtkStyleContext *style_context;
|
|
PangoContext *pango_context;
|
|
PangoLayout *layout;
|
|
const char *text;
|
|
gint cursor_index;
|
|
gint x, y;
|
|
|
|
style_context = gtk_widget_get_style_context (widget);
|
|
pango_context = gtk_widget_get_pango_context (widget);
|
|
layout = gtk_entry_get_layout (GTK_ENTRY (widget));
|
|
text = pango_layout_get_text (layout);
|
|
gtk_entry_get_layout_offsets (GTK_ENTRY (widget), &x, &y);
|
|
cursor_index = g_utf8_offset_to_pointer (text, gtk_editable_get_position (GTK_EDITABLE (widget))) - text;
|
|
gtk_render_insertion_cursor (style_context, cr, x, y, layout, cursor_index,
|
|
pango_context_get_base_dir (pango_context));
|
|
return FALSE;
|
|
}
|
|
|
|
static gboolean
|
|
nimf_candidate_start (NimfService *service)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (service);
|
|
|
|
if (candidate->active)
|
|
return TRUE;
|
|
|
|
GtkCellRenderer *renderer;
|
|
GtkTreeViewColumn *column[N_COLUMNS];
|
|
GtkListStore *store;
|
|
gint fixed_height = 32;
|
|
gint horizontal_space;
|
|
|
|
gtk_init (NULL, NULL);
|
|
|
|
/* gtk entry */
|
|
candidate->entry = gtk_entry_new ();
|
|
gtk_editable_set_editable (GTK_EDITABLE (candidate->entry), FALSE);
|
|
gtk_widget_set_no_show_all (candidate->entry, TRUE);
|
|
g_signal_connect_after (candidate->entry, "draw",
|
|
G_CALLBACK (on_entry_draw), NULL);
|
|
/* gtk tree view */
|
|
store = gtk_list_store_new (N_COLUMNS, G_TYPE_INT, G_TYPE_STRING, G_TYPE_STRING);
|
|
candidate->treeview = gtk_tree_view_new_with_model (GTK_TREE_MODEL (store));
|
|
g_object_unref (store);
|
|
gtk_tree_view_set_headers_visible (GTK_TREE_VIEW (candidate->treeview), FALSE);
|
|
gtk_tree_view_set_activate_on_single_click (GTK_TREE_VIEW (candidate->treeview), TRUE);
|
|
gtk_widget_style_get (candidate->treeview, "horizontal-separator",
|
|
&horizontal_space, NULL);
|
|
candidate->cell_height = fixed_height + horizontal_space / 2;
|
|
gtk_widget_set_size_request (candidate->treeview,
|
|
(gint) (candidate->cell_height * 10 / 1.6),
|
|
candidate->cell_height * 10);
|
|
g_signal_connect (candidate->treeview, "row-activated",
|
|
(GCallback) on_tree_view_row_activated, candidate);
|
|
/* column */
|
|
renderer = gtk_cell_renderer_text_new ();
|
|
g_object_set (renderer, "height", fixed_height, "font", "Sans 14", NULL);
|
|
|
|
column[INDEX_COLUMN] = gtk_tree_view_column_new_with_attributes ("Index",
|
|
renderer, "text", INDEX_COLUMN, NULL);
|
|
column[MAIN_COLUMN] = gtk_tree_view_column_new_with_attributes ("Main",
|
|
renderer, "text", MAIN_COLUMN, NULL);
|
|
column[EXTRA_COLUMN] = gtk_tree_view_column_new_with_attributes ("Extra",
|
|
renderer, "text", EXTRA_COLUMN, NULL);
|
|
gtk_tree_view_column_set_sizing (column[INDEX_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
gtk_tree_view_column_set_sizing (column[MAIN_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
gtk_tree_view_column_set_sizing (column[EXTRA_COLUMN], GTK_TREE_VIEW_COLUMN_AUTOSIZE);
|
|
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
|
|
column[INDEX_COLUMN]);
|
|
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
|
|
column[MAIN_COLUMN]);
|
|
gtk_tree_view_append_column (GTK_TREE_VIEW (candidate->treeview),
|
|
column[EXTRA_COLUMN]);
|
|
/* scrollbar */
|
|
GtkAdjustment *adjustment = gtk_adjustment_new (1.0, 1.0, 2.0, 1.0, 1.0, 1.0);
|
|
candidate->scrollbar = gtk_scrollbar_new (GTK_ORIENTATION_VERTICAL, adjustment);
|
|
gtk_range_set_slider_size_fixed (GTK_RANGE (candidate->scrollbar), FALSE);
|
|
g_signal_connect (candidate->scrollbar, "change-value",
|
|
G_CALLBACK (on_range_change_value), candidate);
|
|
GtkCssProvider *provider;
|
|
GtkStyleContext *style_context;
|
|
provider = gtk_css_provider_new ();
|
|
gtk_css_provider_load_from_data (GTK_CSS_PROVIDER (provider),
|
|
".scrollbar {"
|
|
" -GtkScrollbar-has-backward-stepper: true;"
|
|
" -GtkScrollbar-has-forward-stepper: true;"
|
|
" -GtkScrollbar-has-secondary-forward-stepper: true;"
|
|
"}" , -1, NULL);
|
|
style_context = gtk_widget_get_style_context (candidate->scrollbar);
|
|
gtk_style_context_add_provider (style_context,
|
|
GTK_STYLE_PROVIDER (provider),
|
|
GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
|
|
g_object_unref (provider);
|
|
|
|
/* gtk box */
|
|
GtkWidget *vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
|
|
GtkWidget *hbox = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
|
|
|
|
gtk_box_pack_start (GTK_BOX (vbox), candidate->entry, TRUE, TRUE, 0);
|
|
gtk_box_pack_start (GTK_BOX (vbox), hbox, TRUE, TRUE, 0);
|
|
|
|
gtk_box_pack_start (GTK_BOX (hbox), candidate->treeview, TRUE, TRUE, 0);
|
|
gtk_box_pack_end (GTK_BOX (hbox), candidate->scrollbar, FALSE, TRUE, 0);
|
|
|
|
/* gtk window */
|
|
candidate->window = gtk_window_new (GTK_WINDOW_POPUP);
|
|
gtk_window_set_type_hint (GTK_WINDOW (candidate->window),
|
|
GDK_WINDOW_TYPE_HINT_POPUP_MENU);
|
|
gtk_container_set_border_width (GTK_CONTAINER (candidate->window), 1);
|
|
gtk_container_add (GTK_CONTAINER (candidate->window), vbox);
|
|
gtk_widget_realize (candidate->window);
|
|
|
|
candidate->active = TRUE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_stop (NimfService *service)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (service);
|
|
|
|
if (!candidate->active)
|
|
return;
|
|
|
|
candidate->active = FALSE;
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_init (NimfCandidate *candidate)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
candidate->id = g_strdup ("nimf-candidate");
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_finalize (GObject *object)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
NimfCandidate *candidate = NIMF_CANDIDATE (object);
|
|
|
|
if (candidate->active)
|
|
nimf_candidate_stop (NIMF_SERVICE (candidate));
|
|
|
|
gtk_widget_destroy (candidate->window);
|
|
g_free (candidate->id);
|
|
|
|
G_OBJECT_CLASS (nimf_candidate_parent_class)->finalize (object);
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_class_init (NimfCandidateClass *class)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
GObjectClass *object_class = G_OBJECT_CLASS (class);
|
|
NimfServiceClass *service_class = NIMF_SERVICE_CLASS (class);
|
|
|
|
service_class->get_id = nimf_candidate_get_id;
|
|
service_class->start = nimf_candidate_start;
|
|
service_class->stop = nimf_candidate_stop;
|
|
service_class->is_active = nimf_candidate_is_active;
|
|
|
|
object_class->finalize = nimf_candidate_finalize;
|
|
}
|
|
|
|
static void
|
|
nimf_candidate_class_finalize (NimfCandidateClass *class)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
}
|
|
|
|
void module_register_type (GTypeModule *type_module)
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
nimf_candidate_register_type (type_module);
|
|
}
|
|
|
|
GType module_get_type ()
|
|
{
|
|
g_debug (G_STRLOC ": %s", G_STRFUNC);
|
|
|
|
return nimf_candidate_get_type ();
|
|
}
|