//
// Custom the tooltip
//
static gboolean qq_tray_on_show_tooltip(GtkWidget* widget
, int x
, int y
, gboolean keybord_mode
, GtkTooltip* tip
, gpointer data)
{
GdkPixbuf *pb;
if(info -> me -> qqnumber == NULL || info -> me -> qqnumber -> len <=0){
// Not login.
pb = gdk_pixbuf_new_from_file_at_size(IMGDIR"/webqq_icon.png"
, 35, 35, NULL);
gtk_tooltip_set_markup(tip, "<b>GtkQQ</b>");
gtk_tooltip_set_icon(tip, pb);
g_object_unref(pb);
return TRUE;
}
gchar buf[500];
g_snprintf(buf, 500, CONFIGDIR"/faces/%s", info -> me -> qqnumber -> str);
pb = gdk_pixbuf_new_from_file_at_size(buf, 35, 35, NULL);
gtk_tooltip_set_icon(tip, pb);
g_object_unref(pb);
g_snprintf(buf, 500, "<b>%s</b><span color='blue'>(%s)</span>"
, info -> me -> nick -> str
, info -> me -> qqnumber -> str);
gtk_tooltip_set_markup(tip, buf);
return TRUE;
}
/**
* \internal
*/
gboolean __category_edit_on_query_tooltip(GtkTreeView * tree_view, GtkTooltip * tooltip,
GtkTreeIter * iter, GtkTreeViewColumn * column,
CategoryEdit * category_edit)
{
gchar *stock;
gtk_tree_model_get(GTK_TREE_MODEL(GEBR_GUI_SEQUENCE_EDIT(category_edit)->list_store), iter,
1, &stock, -1);
if (stock == NULL)
return FALSE;
if (gtk_tree_view_column_get_sort_column_id(column) != 1)
return FALSE;
gchar *name;
gtk_tree_model_get(GTK_TREE_MODEL(GEBR_GUI_SEQUENCE_EDIT(category_edit)->list_store), iter,
0, &name, -1);
GebrValidateCase *validate_case = gebr_validate_get_validate_case(GEBR_VALIDATE_CASE_CATEGORY);
GString *tooltip_string = g_string_new("");
gboolean can_fix;
gchar *fixes = gebr_validate_case_automatic_fixes_msg(validate_case, name, &can_fix);
g_string_printf(tooltip_string, "%s\n\n%s", gebr_validate_case_get_message (validate_case), fixes);
g_free(fixes);
gtk_tooltip_set_markup(tooltip, tooltip_string->str);
g_string_free(tooltip_string, TRUE);
g_free(stock);
g_free(name);
return TRUE;
}
static gboolean cm_tree_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_mode,
GtkTooltip *tooltip, CookieManagerPage *cmp)
{
GtkTreeIter iter;
GtkTreeModel *model;
if (gtk_tree_view_get_tooltip_context(GTK_TREE_VIEW(widget), &x, &y,
keyboard_mode, &model, NULL, &iter))
{
gchar *tooltip_text;
SoupCookie *cookie;
gtk_tree_model_get(model, &iter, COOKIE_MANAGER_COL_COOKIE, &cookie, -1);
if (cookie == NULL) /* not an item */
return FALSE;
tooltip_text = cm_get_cookie_description_text(cookie);
gtk_tooltip_set_markup(tooltip, tooltip_text);
g_free(tooltip_text);
return TRUE;
}
return FALSE;
}
static gboolean
query_tooltip_drawing_area_cb (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
gint i;
if (keyboard_tip)
return FALSE;
for (i = 0; i < G_N_ELEMENTS (rectangles); i++)
{
struct Rectangle *r = &rectangles[i];
if (r->x < x && x < r->x + 50
&& r->y < y && y < r->y + 50)
{
gtk_tooltip_set_markup (tooltip, r->tooltip);
return TRUE;
}
}
return FALSE;
}
static gboolean
wp_view_tooltip_cb (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
AppearanceData *data)
{
GtkTreeIter iter;
MateWPItem *item;
if (gtk_icon_view_get_tooltip_context (data->wp_view,
&x, &y,
keyboard_mode,
NULL,
NULL,
&iter))
{
gtk_tree_model_get (data->wp_model, &iter, 1, &item, -1);
gtk_tooltip_set_markup (tooltip, item->description);
return TRUE;
}
return FALSE;
}
static gboolean
bidding_query_tooltip (GtkWidget *widget, gint x, gint y, gboolean keyboard_mode,
GtkTooltip *tooltip, window_board_t *bidding_store)
{
if (keyboard_mode) {
printf ("FIXME: keyboard usage\n");
return FALSE;
}
GtkTreeIter iter;
gboolean ret = gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
&x, &y, keyboard_mode, NULL, NULL, &iter);
if (!ret) {
gtk_tooltip_set_text (tooltip, NULL);
// TODO: don't show anything at all, or something interesting
// y<0 -> headings
return TRUE;
}
int i;
int width = 0;
for (i = 0; i < 4; i++) {
width += gtk_tree_view_column_get_width (win->bidding_column[i]);
// TODO: cache this, or use gtk_tree_view_get_path_at_pos
if (x < width)
break;
}
assert (i < 4);
gchar *alert;
gtk_tree_model_get (GTK_TREE_MODEL (win->bidding_store), &iter, 2 * i + 1, &alert, -1);
gtk_tooltip_set_markup (tooltip, !alert || *alert ? alert : _("(no explanation)"));
return TRUE;
}
static gboolean
treeview_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
GtkTreeIter iter;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
GtkTreePath *path = NULL;
gpointer *tab;
gchar *tip;
if (keyboard_tip)
{
gtk_tree_view_get_cursor (tree_view, &path, NULL);
if (path == NULL)
{
return FALSE;
}
}
else
{
gint bin_x, bin_y;
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
x, y,
&bin_x, &bin_y);
if (!gtk_tree_view_get_path_at_pos (tree_view,
bin_x, bin_y,
&path,
NULL, NULL, NULL))
{
return FALSE;
}
}
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model,
&iter,
TAB_COLUMN,
&tab,
-1);
tip = _pluma_tab_get_tooltips (PLUMA_TAB (tab));
gtk_tooltip_set_markup (tooltip, tip);
g_free (tip);
gtk_tree_path_free (path);
return TRUE;
}
static gboolean canvas_tooltip(GtkWidget *widget, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip, gpointer user_data)
{
struct coord pos = canvas_to_coord(x, y);
const char *res;
res = tool_tip(pos);
if (!res)
return FALSE;
gtk_tooltip_set_markup(tooltip, res);
return TRUE;
}
static void
gtk_tooltip_reset (GtkTooltip *tooltip)
{
gtk_tooltip_set_markup (tooltip, NULL);
gtk_tooltip_set_icon (tooltip, NULL);
gtk_tooltip_set_tip_area (tooltip, NULL);
/* See if the custom widget is again set from the query-tooltip
* callback.
*/
tooltip->custom_was_reset = FALSE;
}
//
// Group list tool tip
//
static gboolean qq_group_list_on_show_tooltip(GtkWidget* widget
, int x
, int y
, gboolean keybord_mode
, GtkTooltip* tip
, gpointer data)
{
gchar *name, *code;
GtkTreeView *tree = GTK_TREE_VIEW(widget);
GtkTreeModel *model = gtk_tree_view_get_model(tree);
GtkTreePath *path;
GtkTreeIter iter;
if(!gtk_tree_view_get_tooltip_context(tree , &x , &y , keybord_mode
, &model , &path , &iter)){
return FALSE;
}
gtk_tree_model_get(model, &iter
, BDY_LIST_NAME, &name
, BDY_LIST_UIN, &code
, -1);
QQGroup *grp = qq_info_lookup_group_by_code(info, code);
if(grp == NULL){
gtk_tree_path_free(path);
g_free(name);
g_free(code);
return FALSE;
}
gchar buf[100];
const gchar *levelstr = NULL;
gint tmpint = (gint)strtol(grp -> level -> str, NULL, 10);
switch(tmpint)
{
case 0:
levelstr = "普通群";
break;
case 1:
levelstr = "高级群";
break;
default:
levelstr = "";
break;
}
g_snprintf(buf, 100, "%s - %s", name, levelstr);
gtk_tooltip_set_markup(tip, buf);
gtk_tree_view_set_tooltip_row(tree, tip, path);
gtk_tree_path_free(path);
g_free(name);
g_free(code);
return TRUE;
}
static gboolean
query_tooltip_cb (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
gtk_tooltip_set_markup (tooltip, gtk_button_get_label (GTK_BUTTON (widget)));
gtk_tooltip_set_icon_from_icon_name (tooltip, "edit-delete",
GTK_ICON_SIZE_MENU);
return TRUE;
}
static gboolean
query_tooltip__ (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
GtkTreePath *path;
GtkTreeModel *model;
switch((char)(long)user_data) {
case 'i':
{
GtkIconView *view = GTK_ICON_VIEW (widget);
if (!gtk_icon_view_get_tooltip_context (view, &x, &y, keyboard_mode, NULL, &path, NULL))
return FALSE;
model = gtk_icon_view_get_model (view);
break;
}
case 't':
{
GtkTreeView *view = GTK_TREE_VIEW (widget);
if (!gtk_tree_view_get_tooltip_context (view, &x, &y, keyboard_mode, NULL, &path, NULL))
return FALSE;
model = gtk_tree_view_get_model (view);
break;
}
default:
return FALSE;
}
int id = get_id__(model, path);
if(id <= 0)
return FALSE;
callback_item___* si = callback_item__(id);
if(si->tooltip_.size() > 0) {
gtk_tooltip_set_markup (tooltip, si->tooltip_.c_str());
return TRUE;
}
return FALSE;
}
static gboolean
query_tooltip_tree_view_cb (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
GtkTreeIter iter;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
GtkTreePath *path = NULL;
gchar *tmp;
gchar *pathstring;
char buffer[512];
if (!gtk_tree_view_get_tooltip_context (tree_view, &x, &y,
keyboard_tip,
&model, &path, &iter))
return FALSE;
gtk_tree_model_get (model, &iter, 0, &tmp, -1);
pathstring = gtk_tree_path_to_string (path);
g_snprintf (buffer, 511, "<b>Path %s:</b> %s", pathstring, tmp);
gtk_tooltip_set_markup (tooltip, buffer);
gtk_tree_view_set_tooltip_row (tree_view, tooltip, path);
gtk_tree_path_free (path);
g_free (pathstring);
g_free (tmp);
return TRUE;
}
static gboolean
git_source_view_query_tooltip (GtkWidget *widget,
gint x, gint y,
gboolean keyboard_tooltip,
GtkTooltip *tooltip)
{
GitSourceView *sview = (GitSourceView *) widget;
GitSourceViewPrivate *priv = sview->priv;
gint line_num, num_lines;
gboolean ret = TRUE;
GString *markup;
const gchar *part;
gchar *part_markup;
const GitAnnotatedSourceLine *line;
GitCommit *commit;
if (priv->line_height < 1 || priv->paint_source == NULL)
return FALSE;
num_lines = git_annotated_source_get_n_lines (priv->paint_source);
line_num = (y + priv->y_offset) / priv->line_height;
if (x < 0 || x >= priv->max_hash_length
|| line_num < 0 || line_num >= num_lines)
return FALSE;
line = git_annotated_source_get_line (priv->paint_source, line_num);
commit = line->commit;
markup = g_string_new ("");
if ((part = git_commit_get_prop (commit, "author")))
{
part_markup = g_markup_printf_escaped ("<b>%s</b>", part);
g_string_append (markup, part_markup);
g_free (part_markup);
}
if ((part = git_commit_get_prop (commit, "author-mail")))
{
if (markup->len > 0)
g_string_append_c (markup, ' ');
part_markup = g_markup_escape_text (part, -1);
g_string_append (markup, part_markup);
g_free (part_markup);
}
if ((part = git_commit_get_prop (commit, "author-time")))
{
GTimeVal time_;
char *tail;
errno = 0;
time_.tv_sec = strtol (part, &tail, 10);
time_.tv_usec = 0;
if (errno == 0 && *tail == '\0')
{
gchar *display_time;
if (markup->len > 0)
g_string_append_c (markup, '\n');
display_time = git_format_time_for_display (&time_);
part_markup = g_markup_escape_text (display_time, -1);
g_free (display_time);
g_string_append (markup, part_markup);
g_free (part_markup);
}
}
if ((part = git_commit_get_prop (commit, "summary")))
{
gchar *stripped_part;
if (markup->len > 0)
g_string_append_c (markup, '\n');
while (*part && isspace (*part))
part++;
stripped_part = g_strdup (part);
g_strchomp (stripped_part);
part_markup = g_markup_printf_escaped ("<i>%s</i>", stripped_part);
g_free (stripped_part);
g_string_append (markup, part_markup);
g_free (part_markup);
}
if (markup->len > 0)
{
GdkRectangle tip_area;
tip_area.x = 0;
tip_area.y = line_num * priv->line_height - priv->y_offset;
tip_area.width = priv->max_hash_length;
tip_area.height = priv->line_height;
gtk_tooltip_set_markup (tooltip, markup->str);
gtk_tooltip_set_tip_area (tooltip, &tip_area);
}
else
ret = FALSE;
g_string_free (markup, TRUE);
return ret;
}
static gboolean
treeview_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
GeditDocumentsPanel *panel)
{
GtkTreeIter iter;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
GtkTreePath *path = NULL;
GeditNotebook *notebook;
GeditTab *tab;
gchar *tip;
gedit_debug (DEBUG_PANEL);
if (keyboard_tip)
{
gtk_tree_view_get_cursor (tree_view, &path, NULL);
if (path == NULL)
{
return FALSE;
}
}
else
{
gint bin_x, bin_y;
gtk_tree_view_convert_widget_to_bin_window_coords (tree_view,
x, y,
&bin_x, &bin_y);
if (!gtk_tree_view_get_path_at_pos (tree_view,
bin_x, bin_y,
&path,
NULL, NULL, NULL))
{
return FALSE;
}
}
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model,
&iter,
NOTEBOOK_COLUMN, ¬ebook,
TAB_COLUMN, &tab,
-1);
if (tab != NULL)
{
tip = _gedit_tab_get_tooltip (tab);
g_object_unref (tab);
}
else
{
tip = notebook_get_tooltip (panel->priv->mnb, notebook);
}
gtk_tooltip_set_markup (tooltip, tip);
g_object_unref (notebook);
g_free (tip);
gtk_tree_path_free (path);
return TRUE;
}
static gboolean
gnac_ui_query_tooltip_cb(GtkStatusIcon *status_icon,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
GError *error = NULL;
GFile *tooltip_file = g_file_new_for_uri(tooltip_path);
LibgnacTags *tags = libgnac_metadata_extract(metadata, tooltip_file, &error);
if (error) {
libgnac_debug("Failed to extract metadata for %s: %s",
tooltip_path, error->message);
g_clear_error(&error);
}
g_object_unref(tooltip_file);
const gchar *album = libgnac_metadata_tag_exists(tags, GST_TAG_ALBUM) ?
g_value_get_string(LIBGNAC_METADATA_TAG_ALBUM(tags)) : NULL;
const gchar *artist = libgnac_metadata_tag_exists(tags, GST_TAG_ARTIST) ?
g_value_get_string(LIBGNAC_METADATA_TAG_ARTIST(tags)) : NULL;
const gchar *title = libgnac_metadata_tag_exists(tags, GST_TAG_TITLE) ?
g_value_get_string(LIBGNAC_METADATA_TAG_TITLE(tags)) : NULL;
gchar *text;
if (title)
{
text = g_markup_printf_escaped(" <b>%s</b> \n"
" <span color=\"#888\">%s</span> %s \n"
" <span color=\"#888\">%s</span> %s ",
title,
/* Translators: title by artist from album */
_("by"), artist ? artist : _("Unknown Artist"),
/* Translators: title by artist from album */
_("from"), album ? album : _("Unknown Album"));
}
else
{
gchar *name = gnac_utils_get_display_name(tooltip_path, NULL);
if (name) {
text = g_markup_printf_escaped(" <b>%s</b> ", name);
} else {
text = g_strdup(tooltip_path);
}
g_free(name);
}
gtk_tooltip_set_markup(tooltip, text);
g_free(text);
/* check wether we have a cover to display */
if (libgnac_metadata_tag_exists(tags, GST_TAG_IMAGE)) {
GdkPixbuf *pixbuf = g_value_get_object(LIBGNAC_METADATA_TAG_IMAGE(tags));
pixbuf = gnac_ui_utils_scale_pixbuf(pixbuf, 64, 64);
pixbuf = gnac_ui_utils_add_border_to_pixbuf(pixbuf);
gtk_tooltip_set_icon(tooltip, pixbuf);
g_object_unref(pixbuf);
}
return TRUE;
}
static gboolean
on_log_view_query_tooltip (GtkWidget *log_view, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip,
GitLogPane *self)
{
gboolean ret;
GtkTreeViewColumn *ref_icon_column;
gint bin_x;
gint bin_y;
GtkTreeViewColumn *current_column;
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeIter iter;
GitRevision *revision;
gchar *sha;
GList *ref_list;
GList *current_ref;
GString *tooltip_string;
gchar *ref_name;
GitRefType ref_type;
ret = FALSE;
ref_icon_column = gtk_tree_view_get_column (GTK_TREE_VIEW (log_view), 0);
gtk_tree_view_convert_widget_to_bin_window_coords (GTK_TREE_VIEW (log_view),
x, y, &bin_x, &bin_y);
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (log_view), bin_x,
bin_y, &path, ¤t_column, NULL,
NULL))
{
/* We need to be in the ref icon column */
if (current_column == ref_icon_column)
{
model = gtk_tree_view_get_model (GTK_TREE_VIEW (log_view));
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_model_get (model, &iter, LOG_COL_REVISION, &revision, -1);
sha = git_revision_get_sha (revision);
g_object_unref (revision);
ref_list = g_hash_table_lookup (self->priv->refs, sha);
g_free (sha);
if (ref_list)
{
current_ref = ref_list;
tooltip_string = g_string_new ("");
while (current_ref)
{
ref_name = git_ref_get_name (GIT_REF (current_ref->data));
ref_type = git_ref_get_ref_type (GIT_REF (current_ref->data));
if (tooltip_string->len > 0)
g_string_append (tooltip_string, "\n");
switch (ref_type)
{
case GIT_REF_TYPE_BRANCH:
g_string_append_printf (tooltip_string,
_("<b>Branch:</b> %s"),
ref_name );
break;
case GIT_REF_TYPE_TAG:
g_string_append_printf (tooltip_string,
_("<b>Tag:</b> %s"),
ref_name);
break;
case GIT_REF_TYPE_REMOTE:
g_string_append_printf (tooltip_string,
_("<b>Remote:</b> %s"),
ref_name);
break;
default:
break;
}
g_free (ref_name);
current_ref = g_list_next (current_ref);
}
gtk_tooltip_set_markup (tooltip, tooltip_string->str);
g_string_free (tooltip_string, TRUE);
ret = TRUE;
}
}
gtk_tree_path_free (path);
}
return ret;
}
static gboolean
_dtv_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip)
{
int bin_x, bin_y;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column;
GtkTreeIter iter;
GtkTreeModel *model;
GdkRectangle cell_area;
GString *markup;
gboolean had_info = FALSE;
gtk_tree_view_convert_widget_to_bin_window_coords (
GTK_TREE_VIEW (widget), x, y, &bin_x, &bin_y);
if (gtk_tree_view_get_path_at_pos
(GTK_TREE_VIEW (widget), bin_x, bin_y, &path, &column, NULL, NULL)) {
model = gtk_tree_view_get_model (GTK_TREE_VIEW (widget));
if (gtk_tree_model_get_iter (model, &iter, path)) {
/* show some useful information */
Diagram *diagram;
Layer *layer;
DiaObject *object;
gtk_tree_model_get (model, &iter, DIAGRAM_COLUMN, &diagram, -1);
gtk_tree_model_get (model, &iter, LAYER_COLUMN, &layer, -1);
gtk_tree_model_get (model, &iter, OBJECT_COLUMN, &object, -1);
markup = g_string_new (NULL);
if (diagram) {
gchar *em = g_markup_printf_escaped ("<b>%s</b>: %s\n", _("Diagram"), diagram->filename);
g_string_append (markup, em);
g_free (em);
}
if (layer) {
gchar *name = layer_get_name (layer);
gchar *em = g_markup_printf_escaped ("<b>%s</b>: %s\n", _("Layer"), name);
g_string_append (markup, em);
g_free (em);
g_free (name);
} else if (diagram) {
int layers = data_layer_count (DIA_DIAGRAM_DATA (diagram));
g_string_append_printf (markup, g_dngettext (GETTEXT_PACKAGE, "%d Layer", "%d Layers",
layers), layers);
}
if (object) {
gchar *em = g_markup_printf_escaped ("<b>%s</b>: %s\n", _("Type"), object->type->name);
g_string_append (markup, em);
g_free (em);
g_string_append_printf (markup, "<b>%s</b>: %g,%g\n", Q_("object|Position"),
object->position.x, object->position.y);
g_string_append_printf (markup, "%d %s",
g_list_length (object->children), _("Children"));
/* and some dia_object_get_meta ? */
} else if (layer) {
int objects = layer_object_count (layer);
g_string_append_printf (markup, g_dngettext (GETTEXT_PACKAGE, "%d Object", "%d Objects",
objects), objects);
}
if (markup->len > 0) {
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (widget), path, column, &cell_area);
gtk_tree_view_convert_bin_window_to_widget_coords
(GTK_TREE_VIEW (widget), cell_area.x, cell_area.y,
&cell_area.x, &cell_area.y);
gtk_tooltip_set_tip_area (tooltip, &cell_area);
gtk_tooltip_set_markup (tooltip, markup->str);
had_info = TRUE;
}
/* drop references */
if (diagram)
g_object_unref (diagram);
g_string_free (markup, TRUE);
}
gtk_tree_path_free (path);
if (had_info)
return TRUE;
}
return GTK_WIDGET_CLASS (_dtv_parent_class)->query_tooltip
(widget, x, y, keyboard_mode, tooltip);
}
