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;
}
gboolean on_view_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
GtkTooltip *tooltip, GtkTreeViewColumn *base_name_column)
{
GtkTreeView *tree = GTK_TREE_VIEW(widget);
GtkTreeIter iter;
if (gtk_tree_view_get_tooltip_context(tree, &x, &y, keyboard_tip, NULL, NULL, &iter))
{
const char *file;
gtk_tree_view_set_tooltip_cell(tree, tooltip, NULL, base_name_column, NULL);
scp_tree_store_get((ScpTreeStore *) gtk_tree_view_get_model(tree), &iter,
COLUMN_FILE, &file, -1);
if (file)
{
gchar *utf8 = utils_get_utf8_from_locale(file);
gtk_tooltip_set_text(tooltip, utf8);
g_free(utf8);
return TRUE;
}
}
return FALSE;
}
static gboolean remmina_ftp_client_task_list_on_query_tooltip(GtkWidget *widget, gint x, gint y, gboolean keyboard_tip,
GtkTooltip *tooltip, RemminaFTPClient *client)
{
RemminaFTPClientPriv *priv = (RemminaFTPClientPriv*) client->priv;
GtkTreeIter iter;
GtkTreePath *path = NULL;
gchar *tmp;
if (!gtk_tree_view_get_tooltip_context(GTK_TREE_VIEW(priv->task_list_view), &x, &y, keyboard_tip, NULL, &path, &iter))
{
return FALSE;
}
gtk_tree_model_get(priv->task_list_model, &iter, REMMINA_FTP_TASK_COLUMN_TOOLTIP, &tmp, -1);
if (!tmp)
return FALSE;
gtk_tooltip_set_text(tooltip, tmp);
gtk_tree_view_set_tooltip_row(GTK_TREE_VIEW(priv->task_list_view), tooltip, path);
gtk_tree_path_free(path);
g_free(tmp);
return TRUE;
}
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;
}
/*
* trw_layer_waypoint_tooltip_cb:
*
* Show a tooltip when the mouse is over a waypoint list entry.
* The tooltip contains the description.
*/
static gboolean trw_layer_waypoint_tooltip_cb ( GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data )
{
GtkTreeIter iter;
GtkTreePath *path = NULL;
GtkTreeView *tree_view = GTK_TREE_VIEW (widget);
GtkTreeModel *model = gtk_tree_view_get_model (tree_view);
if ( !gtk_tree_view_get_tooltip_context ( tree_view, &x, &y,
keyboard_tip,
&model, &path, &iter ) )
return FALSE;
VikWaypoint *wpt;
gtk_tree_model_get ( model, &iter, WPT_COL_NUM, &wpt, -1 );
if ( !wpt ) return FALSE;
gboolean tooltip_set = TRUE;
if ( wpt->description )
gtk_tooltip_set_text ( tooltip, wpt->description );
else
tooltip_set = FALSE;
if ( tooltip_set )
gtk_tree_view_set_tooltip_row ( tree_view, tooltip, path );
gtk_tree_path_free ( path );
return tooltip_set;
}
static gboolean
file_view_query_tooltip (GtkWidget* widget, gint x, gint y, gboolean keyboard,
GtkTooltip* tooltip)
{
AnjutaFileView* view = ANJUTA_FILE_VIEW (widget);
AnjutaFileViewPrivate* priv = ANJUTA_FILE_VIEW_GET_PRIVATE (view);
GtkTreeModel* model_sort;
GtkTreeModel* file_model = GTK_TREE_MODEL (priv->model);
GtkTreePath* path;
GtkTreeIter iter;
GtkTreeIter real_iter;
gchar* filename;
gboolean result = TRUE;
GdkRectangle visible_rect, column_rect;
GdkScreen *screen = gdk_screen_get_default ();
PangoContext *context;
PangoLayout *layout;
gint width, height;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view),
&x, &y, keyboard,
&model_sort,
&path,
&iter))
return FALSE;
gtk_tree_model_sort_convert_iter_to_child_iter (GTK_TREE_MODEL_SORT (model_sort),
&real_iter, &iter);
filename = file_model_get_filename (FILE_MODEL (file_model), &real_iter);
context = gdk_pango_context_get_for_screen (screen);
layout = pango_layout_new (context);
pango_layout_set_text (layout, filename, -1);
pango_layout_get_pixel_size (layout, &width, &height);
gtk_tree_view_get_visible_rect (GTK_TREE_VIEW (view), &visible_rect);
gtk_tree_view_get_cell_area (GTK_TREE_VIEW (view), path,
gtk_tree_view_get_column (GTK_TREE_VIEW (view), 0), &column_rect);
if (column_rect.x + width > visible_rect.x + visible_rect.width ||
column_rect.x < visible_rect.x)
{
gtk_tooltip_set_text (tooltip, filename);
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view),
tooltip,
path);
} else
{
result = FALSE;
}
g_free (filename);
gtk_tree_path_free (path);
g_object_unref (layout);
g_object_unref (context);
return result;
}
static gboolean
tab_panel_treeview_query_tooltip_cb (GtkWidget* treeview,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip* tooltip,
gpointer user_data)
{
GtkTreeIter iter;
GtkTreePath* path;
GtkTreeModel* model;
MidoriView* view;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (treeview),
&x, &y, keyboard_tip, &model, &path, &iter))
return FALSE;
gtk_tree_model_get (model, &iter, 0, &view, -1);
gtk_tooltip_set_text (tooltip, midori_view_get_display_title (view));
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (treeview), tooltip, path);
gtk_tree_path_free (path);
g_object_unref (view);
return TRUE;
}
static gboolean
on_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer user_data)
{
GtkTreeView *treeview = GTK_TREE_VIEW (widget);
GtkTreeModel *model = gtk_tree_view_get_model (treeview);
GtkTreePath *path = NULL;
GtkTreeIter iter;
gchar *description;
if (!gtk_tree_view_get_tooltip_context (treeview, &x, &y,
keyboard_tip,
&model, &path, &iter))
return FALSE;
gtk_tree_model_get (model, &iter, COLUMN_DESCRIPTION, &description, -1);
gtk_tooltip_set_text (tooltip, description);
gtk_tree_view_set_tooltip_row (treeview, tooltip, path);
gtk_tree_path_free (path);
g_free (description);
return TRUE;
}
//
// 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
contact_list_view_query_tooltip_cb (EmpathyContactListView *view,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
EmpathyContact *contact;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
/* FIXME: We need GTK version >= 2.12.10. See GNOME bug #504087 */
if (gtk_check_version (2, 12, 10)) {
return FALSE;
}
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view), &x, &y,
keyboard_mode,
&model, &path, &iter)) {
return FALSE;
}
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view), tooltip, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (!contact) {
return FALSE;
}
if (!priv->tooltip_widget) {
priv->tooltip_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP);
g_object_ref (priv->tooltip_widget);
g_signal_connect (priv->tooltip_widget, "destroy",
G_CALLBACK (contact_list_view_tooltip_destroy_cb),
view);
} else {
empathy_contact_widget_set_contact (priv->tooltip_widget,
contact);
}
gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
g_object_unref (contact);
return TRUE;
}
static gboolean
contact_list_view_query_tooltip_cb (EmpathyContactListView *view,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
EmpathyContact *contact;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
/* FIXME: We need GTK version >= 2.12.10. See GNOME bug #504087 */
if (100 * gtk_minor_version + gtk_micro_version < 1210) {
return FALSE;
}
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view), &x, &y,
keyboard_mode,
&model, &path, &iter)) {
return FALSE;
}
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view), tooltip, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (!contact) {
return FALSE;
}
if (!priv->tooltip_widget) {
priv->tooltip_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_EDIT_NONE);
g_object_add_weak_pointer (G_OBJECT (priv->tooltip_widget),
(gpointer) &priv->tooltip_widget);
} else {
empathy_contact_widget_set_contact (priv->tooltip_widget,
contact);
}
gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
g_object_unref (contact);
return TRUE;
}
gboolean
on_listview_query_tooltip (GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
FsearchApplication *app =FSEARCH_APPLICATION_DEFAULT;
FsearchConfig *config = fsearch_application_get_config (app);
if (!config->enable_list_tooltips) {
return FALSE;
}
gboolean ret_val = FALSE;
GtkTreeModel *model = NULL;
GtkTreePath *path = NULL;
GtkTreeIter iter = {0};
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (widget),
&x,
&y,
keyboard_mode,
&model,
&path,
&iter))
{
return ret_val;
}
DatabaseSearchEntry *entry = (DatabaseSearchEntry *)iter.user_data;
if (entry) {
BTreeNode *node = db_search_entry_get_node (entry);
if (node) {
char path_name[PATH_MAX] = "";
btree_node_get_path_full (node, path_name, sizeof (path_name));
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (widget),
tooltip,
path);
gtk_tooltip_set_text (tooltip, path_name);
ret_val = TRUE;
}
}
gtk_tree_path_free (path);
return ret_val;
}
static gboolean
tree_view_set_tooltip_query_cb(GtkWidget *widget,
gint x,
gint y,
gboolean keyboard_tip,
GtkTooltip *tooltip,
gpointer data)
{
char *str;
GtkTreeIter iter;
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeView *tree_view = GTK_TREE_VIEW(widget);
int column;
if (!gtk_tree_view_get_tooltip_context(GTK_TREE_VIEW(widget),
&x, &y,
keyboard_tip,
&model, &path, &iter)) {
return FALSE;
}
column = GPOINTER_TO_INT(data);
if (column < 0) {
return FALSE;
}
str = NULL;
gtk_tree_model_get(model, &iter, column, &str, -1);
if (str == NULL) {
return FALSE;
}
gtk_tooltip_set_text(tooltip, str);
gtk_tree_view_set_tooltip_row(tree_view, tooltip, path);
g_free(str);
gtk_tree_path_free(path);
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
on_item_list_view_query_tooltip (GtkWidget *widget, gint x, gint y, gboolean keyboard_mode, GtkTooltip *tooltip, GtkTreeViewColumn *headline_column)
{
GtkTreeView *view = GTK_TREE_VIEW (widget);
GtkTreeModel *model; GtkTreePath *path; GtkTreeIter iter;
gboolean ret = FALSE;
if (gtk_tree_view_get_tooltip_context (view, &x, &y, keyboard_mode, &model, &path, &iter)) {
GtkTreeViewColumn *column;
gint bx, by;
gtk_tree_view_convert_widget_to_bin_window_coords (view, x, y, &bx, &by);
gtk_tree_view_get_path_at_pos (view, x, y, NULL, &column, NULL, NULL);
if (column == headline_column) {
GtkCellRenderer *cell;
GList *renderers = gtk_cell_layout_get_cells (GTK_CELL_LAYOUT (column));
cell = GTK_CELL_RENDERER (renderers->data);
g_list_free (renderers);
gchar *text;
gint weight;
gtk_tree_model_get (model, &iter, IS_LABEL, &text, ITEMSTORE_UNREAD, &weight, -1);
gint full_width = get_cell_renderer_width (widget, cell, text, weight);
gint column_width = gtk_tree_view_column_get_width (column);
if (full_width > column_width) {
gtk_tooltip_set_text (tooltip, text);
ret = TRUE;
}
g_free (text);
}
gtk_tree_view_set_tooltip_row (view, tooltip, path);
gtk_tree_path_free (path);
}
return ret;
}
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
gnc_reconcile_view_tooltip_cb (GNCQueryView *qview, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip, gpointer *user_data)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (qview), &x, &y, keyboard_mode, &model, NULL, &iter))
{
GtkTreeViewColumn *col;
GList *cols;
gint col_pos, col_width;
gchar* desc_text = NULL;
/* Are we in keyboard tooltip mode, CTRL+F1 */
if (keyboard_mode == FALSE)
{
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (qview), x, y, NULL, &col, NULL, NULL) == FALSE)
return FALSE;
}
else
gtk_tree_view_get_cursor (GTK_TREE_VIEW (qview), NULL, &col);
cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (qview));
col_width = gtk_tree_view_column_get_width (col);
col_pos = g_list_index (cols, col);
g_list_free (cols);
/* If column is not description, do not show tooltip */
if (col_pos != 2)
return FALSE;
gtk_tree_model_get (model, &iter, 3, &desc_text, -1);
if (desc_text)
{
PangoLayout* layout;
gint text_width;
gint root_x, root_y;
gint cur_x, cur_y;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (qview), desc_text);
pango_layout_get_pixel_size (layout, &text_width, NULL);
g_object_unref (layout);
/* If text_width + 10 <= column_width, do not show tooltip */
if ((text_width + 10) <= col_width)
{
g_free (desc_text);
return FALSE;
}
if (keyboard_mode == FALSE)
{
GdkScreen *screen;
GtkWindow *tip_win = NULL;
GdkWindow *parent_window, *temp_window;
GList *win_list, *node;
parent_window = gtk_widget_get_parent_window (GTK_WIDGET (qview));
temp_window = gdk_window_get_pointer (parent_window, &cur_x, &cur_y, NULL);
gdk_window_get_origin (parent_window, &root_x, &root_y);
screen = gtk_widget_get_screen (GTK_WIDGET (qview));
/* Get a list of toplevel windows */
win_list = gtk_window_list_toplevels ();
/* Look for the gtk-tooltip window, we do this as gtk_widget_get_tooltip_window
does not seem to work for the default tooltip window, custom yes */
for (node = win_list; node != NULL; node = node->next)
{
if (g_strcmp0 (gtk_widget_get_name (node->data), "gtk-tooltip") == 0)
tip_win = node->data;
}
g_list_free (win_list);
gtk_tooltip_set_text (tooltip, desc_text);
if (GTK_IS_WINDOW (tip_win))
{
GdkRectangle monitor;
GtkRequisition requisition;
gint monitor_num;
gint x, y;
gtk_widget_size_request (GTK_WIDGET (tip_win), &requisition);
x = root_x + cur_x + 10;
y = root_y + cur_y + 10;
monitor_num = gdk_screen_get_monitor_at_point (screen, x, y);
gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
if (x + requisition.width > monitor.x + monitor.width)
x -= x - (monitor.x + monitor.width) + requisition.width;
else if (x < monitor.x)
x = monitor.x;
if (y + requisition.height > monitor.y + monitor.height)
y -= y - (monitor.y + monitor.height) + requisition.height;
gtk_window_move (tip_win, x, y);
}
}
gtk_tooltip_set_text (tooltip, desc_text);
g_free (desc_text);
return TRUE;
}
}
return FALSE;
}
static gboolean gmpc_mpd_data_treeview_tooltip_query_tooltip_callback (GmpcMpdDataTreeviewTooltip* self, gint x, gint y, gboolean keyboard_tip, GtkTooltip* tooltip) {
gboolean result = FALSE;
gchar* tag;
gint row_type;
GtkTreePath* path;
GtkTreeIter iter = {0};
GtkTreeModel* _tmp0_ = NULL;
GtkTreeModel* _tmp1_;
GtkTreeModel* model;
gint _tmp2_;
gboolean _tmp3_ = FALSE;
gint _tmp4_;
gint _tmp5_;
GtkTreeModel* _tmp6_ = NULL;
GtkTreePath* _tmp7_ = NULL;
GtkTreeIter _tmp8_ = {0};
gboolean _tmp9_;
GtkTreeModel* _tmp10_;
GtkTreePath* _tmp11_;
mpd_Song* _tmp12_ = NULL;
mpd_Song* song;
gchar* _tmp18_ = NULL;
gchar* new_check;
gboolean _tmp19_ = FALSE;
GtkImageType _tmp23_;
g_return_val_if_fail (self != NULL, FALSE);
g_return_val_if_fail (tooltip != NULL, FALSE);
tag = NULL;
row_type = 0;
path = NULL;
_tmp0_ = gtk_tree_view_get_model (self->priv->par_widget);
_tmp1_ = _g_object_ref0 (_tmp0_);
model = _tmp1_;
_tmp2_ = cfg_get_single_value_as_int_with_default (config, "GmpcTreeView", "show-tooltip", 1);
if (_tmp2_ != 1) {
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
if (self->mtype != META_ARTIST_ART) {
_tmp3_ = self->mtype != META_ALBUM_ART;
} else {
_tmp3_ = FALSE;
}
if (_tmp3_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
_tmp9_ = gtk_tree_view_get_tooltip_context (self->priv->par_widget, &_tmp4_, &_tmp5_, keyboard_tip, &_tmp6_, &_tmp7_, &_tmp8_);
x = _tmp4_;
y = _tmp5_;
_g_object_unref0 (model);
_tmp10_ = _g_object_ref0 (_tmp6_);
model = _tmp10_;
_gtk_tree_path_free0 (path);
_tmp11_ = _gtk_tree_path_copy0 (_tmp7_);
path = _tmp11_;
iter = _tmp8_;
if (!_tmp9_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
_tmp12_ = mpd_newSong ();
song = _tmp12_;
gtk_tree_model_get (model, &iter, 26, &row_type, -1);
if (row_type == MPD_DATA_TYPE_SONG) {
gchar* album;
gchar* _tmp13_;
gchar* _tmp14_;
album = NULL;
gtk_tree_model_get (model, &iter, 5, &tag, 6, &album, -1);
_tmp13_ = g_strdup (tag);
_g_free0 (song->artist);
song->artist = _tmp13_;
_tmp14_ = g_strdup (album);
_g_free0 (song->album);
song->album = _tmp14_;
_g_free0 (album);
} else {
if (row_type == MPD_DATA_TYPE_TAG) {
if (self->mtype == META_ARTIST_ART) {
gchar* _tmp15_;
gtk_tree_model_get (model, &iter, 7, &tag, -1);
_tmp15_ = g_strdup (tag);
_g_free0 (song->artist);
song->artist = _tmp15_;
} else {
if (self->mtype == META_ALBUM_ART) {
gchar* _tmp16_;
gchar* _tmp17_;
gtk_tree_model_get (model, &iter, 7, &tag, -1);
_tmp16_ = g_strdup (self->request_artist);
_g_free0 (song->artist);
song->artist = _tmp16_;
_tmp17_ = g_strdup (tag);
_g_free0 (song->album);
song->album = _tmp17_;
}
}
}
}
_tmp18_ = mpd_song_checksum (song);
new_check = _tmp18_;
if (g_strcmp0 (new_check, self->priv->checksum) != 0) {
_tmp19_ = self->priv->checksum != NULL;
} else {
_tmp19_ = FALSE;
}
if (_tmp19_) {
_g_free0 (self->priv->checksum);
self->priv->checksum = NULL;
result = FALSE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
if (g_strcmp0 (new_check, self->priv->checksum) != 0) {
gchar* _tmp20_;
MetaData* met;
MetaData* _tmp21_ = NULL;
MetaDataResult _tmp22_;
MetaDataResult _result_;
_tmp20_ = g_strdup (new_check);
_g_free0 (self->priv->checksum);
self->priv->checksum = _tmp20_;
met = NULL;
_tmp22_ = gmpc_meta_watcher_get_meta_path (gmw, song, self->mtype, &_tmp21_);
_meta_data_free0 (met);
met = _tmp21_;
_result_ = _tmp22_;
gmpc_mpd_data_treeview_tooltip_metadata_changed (self, gmw, song, self->mtype, _result_, met);
_meta_data_free0 (met);
}
_tmp23_ = gtk_image_get_storage_type (self->priv->image);
if (_tmp23_ == GTK_IMAGE_EMPTY) {
result = FALSE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
result = TRUE;
_g_free0 (new_check);
_mpd_freeSong0 (song);
_g_object_unref0 (model);
_gtk_tree_path_free0 (path);
_g_free0 (tag);
return result;
}
static gboolean
gnc_reconcile_view_tooltip_cb (GNCQueryView *qview, gint x, gint y,
gboolean keyboard_mode, GtkTooltip *tooltip, gpointer *user_data)
{
GtkTreeModel* model;
GtkTreeIter iter;
// If the Description is longer than can be display, show it in a tooltip
if (gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (qview), &x, &y, keyboard_mode, &model, NULL, &iter))
{
GtkTreeViewColumn *col;
GList *cols;
gint col_pos, col_width;
gchar* desc_text = NULL;
/* Are we in keyboard tooltip mode, displays tooltip below/above treeview CTRL+F1 */
if (keyboard_mode == FALSE)
{
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (qview), x, y, NULL, &col, NULL, NULL) == FALSE)
return FALSE;
}
else
gtk_tree_view_get_cursor (GTK_TREE_VIEW (qview), NULL, &col);
cols = gtk_tree_view_get_columns (GTK_TREE_VIEW (qview));
col_width = gtk_tree_view_column_get_width (col);
col_pos = g_list_index (cols, col);
g_list_free (cols);
/* If column is not description, do not show tooltip */
if (col_pos != (REC_DESC - 1)) // allow for the pointer model column at 0
return FALSE;
gtk_tree_model_get (model, &iter, REC_DESC, &desc_text, -1);
if (desc_text)
{
PangoLayout* layout;
gint text_width;
gint root_x, root_y;
gint cur_x, cur_y;
layout = gtk_widget_create_pango_layout (GTK_WIDGET (qview), desc_text);
pango_layout_get_pixel_size (layout, &text_width, NULL);
g_object_unref (layout);
/* If text_width + 10 <= column_width, do not show tooltip */
if ((text_width + 10) <= col_width)
{
g_free (desc_text);
return FALSE;
}
if (keyboard_mode == FALSE)
{
#if GTK_CHECK_VERSION(3,20,0)
GdkSeat *seat;
#else
GdkDeviceManager *device_manager;
#endif
GdkDevice *pointer;
GtkWindow *tip_win = NULL;
GdkWindow *parent_window;
GList *win_list, *node;
parent_window = gtk_widget_get_parent_window (GTK_WIDGET (qview));
#if GTK_CHECK_VERSION(3,20,0)
seat = gdk_display_get_default_seat (gdk_window_get_display (parent_window));
pointer = gdk_seat_get_pointer (seat);
#else
device_manager = gdk_display_get_device_manager (gdk_window_get_display (parent_window));
pointer = gdk_device_manager_get_client_pointer (device_manager);
#endif
gdk_window_get_device_position (parent_window, pointer, &cur_x, &cur_y, NULL);
gdk_window_get_origin (parent_window, &root_x, &root_y);
/* Get a list of toplevel windows */
win_list = gtk_window_list_toplevels ();
/* Look for the gtk-tooltip window, we do this as gtk_widget_get_tooltip_window
does not seem to work for the default tooltip window, custom yes */
for (node = win_list; node != NULL; node = node->next)
{
if (g_strcmp0 (gtk_widget_get_name (node->data), "gtk-tooltip") == 0)
tip_win = node->data;
}
g_list_free (win_list);
gtk_tooltip_set_text (tooltip, desc_text);
if (GTK_IS_WINDOW (tip_win))
{
#if GTK_CHECK_VERSION(3,22,0)
GdkMonitor *mon;
#else
GdkScreen *screen;
gint monitor_num;
#endif
GdkRectangle monitor;
GtkRequisition requisition;
gint x, y;
gtk_widget_get_preferred_size (GTK_WIDGET (tip_win), &requisition, NULL);
x = root_x + cur_x + 10;
y = root_y + cur_y + 10;
#if GTK_CHECK_VERSION(3,22,0)
mon = gdk_display_get_monitor_at_point (gdk_display_get_default(), x, y);
gdk_monitor_get_geometry (mon, &monitor);
#else
screen = gtk_widget_get_screen (GTK_WIDGET (qview));
monitor_num = gdk_screen_get_monitor_at_point (screen, x, y);
gdk_screen_get_monitor_geometry (screen, monitor_num, &monitor);
#endif
if (x + requisition.width > monitor.x + monitor.width)
x -= x - (monitor.x + monitor.width) + requisition.width;
else if (x < monitor.x)
x = monitor.x;
if (y + requisition.height > monitor.y + monitor.height)
y -= y - (monitor.y + monitor.height) + requisition.height;
gtk_window_move (tip_win, x, y);
}
}
gtk_tooltip_set_text (tooltip, desc_text);
g_free (desc_text);
return TRUE;
}
}
return FALSE;
}
static gboolean
query_tooltip_cb (EmpathyPersonaView *self,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
EmpathyPersonaViewPriv *priv = GET_PRIV (self);
FolksPersona *persona;
TpContact *tp_contact;
EmpathyContact *contact;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
static gint running = 0;
gboolean ret = FALSE;
/* Avoid an infinite loop. See GNOME bug #574377 */
if (running > 0)
return FALSE;
running++;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (self), &x, &y,
keyboard_mode, &model, &path, &iter))
{
goto OUT;
}
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (self), tooltip, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
EMPATHY_PERSONA_STORE_COL_PERSONA, &persona,
-1);
if (persona == NULL)
goto OUT;
tp_contact = tpf_persona_get_contact (TPF_PERSONA (persona));
if (tp_contact == NULL)
{
g_clear_object (&persona);
goto OUT;
}
contact = empathy_contact_dup_from_tp_contact (tp_contact);
if (priv->tooltip_widget == NULL)
{
priv->tooltip_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP |
EMPATHY_CONTACT_WIDGET_SHOW_LOCATION);
gtk_container_set_border_width (GTK_CONTAINER (priv->tooltip_widget), 8);
g_object_ref (priv->tooltip_widget);
g_signal_connect (priv->tooltip_widget, "destroy",
(GCallback) tooltip_destroy_cb, self);
gtk_widget_show (priv->tooltip_widget);
}
else
{
empathy_contact_widget_set_contact (priv->tooltip_widget, contact);
}
gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
ret = TRUE;
g_object_unref (contact);
g_object_unref (persona);
OUT:
running--;
return ret;
}
static gboolean
contact_list_view_query_tooltip_cb (EmpathyContactListView *view,
gint x,
gint y,
gboolean keyboard_mode,
GtkTooltip *tooltip,
gpointer user_data)
{
EmpathyContactListViewPriv *priv = GET_PRIV (view);
EmpathyContact *contact;
GtkTreeModel *model;
GtkTreeIter iter;
GtkTreePath *path;
static gint running = 0;
gboolean ret = FALSE;
/* Avoid an infinite loop. See GNOME bug #574377 */
if (running > 0) {
return FALSE;
}
running++;
if (!gtk_tree_view_get_tooltip_context (GTK_TREE_VIEW (view), &x, &y,
keyboard_mode,
&model, &path, &iter)) {
goto OUT;
}
gtk_tree_view_set_tooltip_row (GTK_TREE_VIEW (view), tooltip, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter,
EMPATHY_CONTACT_LIST_STORE_COL_CONTACT, &contact,
-1);
if (!contact) {
goto OUT;
}
if (!priv->tooltip_widget) {
priv->tooltip_widget = empathy_contact_widget_new (contact,
EMPATHY_CONTACT_WIDGET_FOR_TOOLTIP |
EMPATHY_CONTACT_WIDGET_SHOW_LOCATION);
g_object_ref (priv->tooltip_widget);
g_signal_connect (priv->tooltip_widget, "destroy",
G_CALLBACK (contact_list_view_tooltip_destroy_cb),
view);
gtk_widget_show (priv->tooltip_widget);
} else {
empathy_contact_widget_set_contact (priv->tooltip_widget,
contact);
}
gtk_tooltip_set_custom (tooltip, priv->tooltip_widget);
ret = TRUE;
g_object_unref (contact);
OUT:
running--;
return ret;
}
