static gboolean
midori_extension_button_release_event_cb (GtkWidget* widget,
GdkEventButton* event,
MidoriExtension* extension)
{
GtkTreeModel* model;
GtkTreeIter iter;
if (event->button < 1 || event->button > 3)
return FALSE;
if (katze_tree_view_get_selected_iter (GTK_TREE_VIEW (widget), &model, &iter))
{
GtkWidget* view;
gtk_tree_model_get (model, &iter, 0, &view, -1);
if (event->button == 1)
{
MidoriBrowser* browser = midori_browser_get_for_widget (widget);
GtkTreeViewColumn* column;
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
event->x, event->y, NULL, &column, NULL, NULL)
&& column == gtk_tree_view_get_column (GTK_TREE_VIEW (widget), 1))
gtk_widget_destroy (view);
else
midori_browser_set_current_tab (browser, view);
}
else if (event->button == 2)
gtk_widget_destroy (view);
else
tab_panel_popup (widget, event, view);
g_object_unref (view);
return TRUE;
}
return FALSE;
}
static gboolean log_button_press_cb(GtkWidget *treeview, GdkEventButton *event, PidginLogViewer *lv)
{
if (event->type == GDK_BUTTON_PRESS && event->button == 3)
{
GtkTreePath *path;
GtkTreeIter *iter;
GValue val;
PurpleLog *log;
gpointer *data;
if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview), event->x, event->y, &path, NULL, NULL, NULL))
return FALSE;
iter = g_new(GtkTreeIter, 1);
gtk_tree_model_get_iter(GTK_TREE_MODEL(lv->treestore), iter, path);
val.g_type = 0;
gtk_tree_model_get_value(GTK_TREE_MODEL(lv->treestore), iter, 1, &val);
gtk_tree_path_free(path);
log = g_value_get_pointer(&val);
if (log == NULL)
{
g_free(iter);
return FALSE;
}
data = g_new(gpointer, 4);
data[0] = lv;
data[1] = log;
data[2] = NULL;
data[3] = iter;
log_show_popup_menu(treeview, event, data);
return TRUE;
}
return FALSE;
}
gboolean ReportTreeView_clicked(GtkWidget *Tree, GdkEventButton *event)
{
GtkWidget* popup_menu;
GtkWidget* copy_item;
GtkWidget* newdestination_item;
GtkTreePath *path;
if (event->type != GDK_BUTTON_PRESS || event->button != 3)
return FALSE;
if(!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(ReportTreeView),
event->x, event->y, &path, NULL, NULL, NULL))
return FALSE;
gtk_tree_view_set_cursor(GTK_TREE_VIEW(ReportTreeView), path, NULL, FALSE);
// Single right click: prepare and show the popup menu
popup_menu = gtk_menu_new ();
copy_item = gtk_menu_item_new_with_label ("Copy to clipboard");
newdestination_item = gtk_menu_item_new_with_label ("Set as new destination");
gtk_menu_append (GTK_MENU (popup_menu), copy_item);
gtk_menu_append (GTK_MENU (popup_menu), newdestination_item);
g_signal_connect(GTK_OBJECT(copy_item),"activate",
GTK_SIGNAL_FUNC(Copy_activate), path);
g_signal_connect(GTK_OBJECT(newdestination_item),"activate",
GTK_SIGNAL_FUNC(NewDestination_activate), path);
gtk_widget_show (copy_item);
gtk_widget_show (newdestination_item);
gtk_menu_popup (GTK_MENU(popup_menu), NULL, NULL, NULL, NULL,
0, event->time);
return TRUE;
}
gboolean ISFSetupWin::button_press_cb (GtkWidget *widget, GdkEventButton *event, gpointer data)
{
ISFSetupWin *obj = (ISFSetupWin *)data;
GtkTreePath *path = NULL;
GtkTreeModel *model = GTK_TREE_MODEL (_factory_list_store);
GtkTreeIter iter;
gchar *module_name = NULL, *title = NULL;
int type;
int cell_x, cell_y;
GtkTreeViewColumn *column = NULL;
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
(gint)event->x, (gint)event->y,
&path, &column, &cell_x, &cell_y))
return (gboolean)FALSE;
if (path != NULL) {
gtk_tree_model_get_iter (model, &iter, path);
gtk_tree_path_free (path);
gtk_tree_model_get (model, &iter, FACTORY_LIST_MODULE_NAME,
&module_name, FACTORY_LIST_NAME, &title, FACTORY_LIST_TYPE, &type, -1);
GtkTreeView *tree_view = NULL;
tree_view = GTK_TREE_VIEW (widget);
if (event->window == gtk_tree_view_get_bin_window (tree_view)) {
if (event->type == GDK_BUTTON_PRESS) {
if (column == gtk_tree_view_get_column (tree_view, 1)) {
obj->create_ise_help_main (type, module_name, title);
return (gboolean)TRUE;
} else if (column == gtk_tree_view_get_column (tree_view, 2)) {
obj->create_ise_option_main (module_name);
return (gboolean)TRUE;
}
}
}
}
return (gboolean)FALSE;
}
gboolean
on_table_button_press (GtkWidget *table, GdkEventButton *event, gpointer data)
{
GtkTreePath *path;
GstTablePopup *table_popup;
GtkTreeSelection *selection;
table_popup = (GstTablePopup *) data;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table));
if (event->button == 3)
{
gtk_widget_grab_focus (table);
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (table),
event->x, event->y,
&path, NULL, NULL, NULL))
{
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path (selection, path);
do_popup_menu (table, table_popup, event);
}
return TRUE;
}
if (event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
{
if (table_popup->properties)
(table_popup->properties) (NULL, NULL);
return TRUE;
}
return FALSE;
}
/* User click: display sub-tree in the right frame. */
gboolean
on_treeview1_button_press_event(GtkWidget * widget,
GdkEventButton * event, gpointer user_data)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreePath *path;
GtkTreeViewColumn *column;
GtkTreeIter iter;
struct menu *menu;
gint tx = (gint) event->x;
gint ty = (gint) event->y;
gint cx, cy;
gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx,
&cy);
if (path == NULL)
return FALSE;
gtk_tree_model_get_iter(model1, &iter, path);
gtk_tree_model_get(model1, &iter, COL_MENU, &menu, -1);
if (event->type == GDK_2BUTTON_PRESS) {
toggle_sym_value(menu);
current = menu;
display_tree_part();
} else {
browsed = menu;
display_tree_part();
}
gtk_widget_realize(tree2_w);
gtk_tree_view_set_cursor(view, path, NULL, FALSE);
gtk_widget_grab_focus(tree2_w);
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
file_view_button_press_event (GtkWidget *widget, GdkEventButton *event)
{
gint retval =
GTK_WIDGET_CLASS (file_view_parent_class)->button_press_event (widget,
event);
/* Ignore double-clicks and triple-clicks */
if (event->button == 3 && event->type == GDK_BUTTON_PRESS)
{
GtkTreePath *path;
/* Select file under cursor if not selected */
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(widget),
event->x,event->y, &path, NULL, NULL, NULL))
{
GtkTreeSelection *selection;
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW (widget));
if (!gtk_tree_selection_path_is_selected(selection, path))
{
gtk_tree_selection_unselect_all(selection);
gtk_tree_selection_select_path(selection, path);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(widget),
path, NULL, FALSE);
}
gtk_tree_path_free (path);
file_view_do_popup_menu (widget, event);
return TRUE;
}
}
return retval;
}
/**************************************************************
* custom_report_list_view_clicked_cb
*
* this callback is called whenever a user clicked somewhere in
* the treeview widget. If the click was on an edit or delete
* pictogram, the corresponding action will be executed on the
* selected row.
**************************************************************/
gboolean
custom_report_list_view_clicked_cb(GtkTreeView *view, GdkEventButton *event, gpointer data)
{
CustomReportDialog *crd = data;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gint cellx, celly;
g_return_val_if_fail ( view != NULL, FALSE );
if (gtk_tree_view_get_path_at_pos (view, event->x, event->y,
&path, &column,
&cellx, &celly))
{
if (column == crd->runcol)
{
SCM guid = get_custom_report_selection(crd, _("You must select a report configuration to load."));
custom_report_run_report (guid, crd);
return TRUE;
}
else if (column == crd->editcol)
{
g_object_set(G_OBJECT(crd->namerenderer), "editable", TRUE, NULL);
gtk_tree_view_set_cursor_on_cell (view, path, crd->namecol,
crd->namerenderer, TRUE);
return TRUE;
}
else if (column == crd->delcol)
{
SCM guid = get_custom_report_selection(crd, _("You must select a report configuration to delete."));
custom_report_delete (guid, crd);
return TRUE;
}
}
return FALSE;
}
static gboolean trw_layer_waypoint_button_pressed ( GtkWidget *tree_view,
GdkEventButton *event,
gpointer data )
{
// Only on right clicks...
if ( ! (event->type == GDK_BUTTON_PRESS && event->button == 3) )
return FALSE;
// ATM Force a selection...
GtkTreeSelection *selection = gtk_tree_view_get_selection ( GTK_TREE_VIEW(tree_view) );
if ( gtk_tree_selection_count_selected_rows (selection) <= 1 ) {
GtkTreePath *path;
/* Get tree path for row that was clicked */
if ( gtk_tree_view_get_path_at_pos ( GTK_TREE_VIEW(tree_view),
(gint) event->x,
(gint) event->y,
&path, NULL, NULL, NULL)) {
gtk_tree_selection_unselect_all ( selection );
gtk_tree_selection_select_path ( selection, path );
gtk_tree_path_free ( path );
}
}
return trw_layer_waypoint_menu_popup ( tree_view, event, data );
}
static GAppInfo *
get_app_info_for_coords (GtkAppChooserWidget *self,
double x,
double y)
{
GtkTreePath *path = NULL;
GtkTreeIter iter;
GtkTreeModel *model;
GAppInfo *info;
gboolean recommended;
if (!gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (self->priv->program_list),
x, y,
&path,
NULL, NULL, NULL))
return NULL;
model = gtk_tree_view_get_model (GTK_TREE_VIEW (self->priv->program_list));
if (!gtk_tree_model_get_iter (model, &iter, path))
{
gtk_tree_path_free (path);
return NULL;
}
/* we only allow interaction with recommended applications */
gtk_tree_model_get (model, &iter,
COLUMN_APP_INFO, &info,
COLUMN_RECOMMENDED, &recommended,
-1);
if (!recommended)
g_clear_object (&info);
return info;
}
TILP_EXPORT gboolean
action_treeview1_button_press_event(GtkWidget* widget, GdkEventButton* event, gpointer user_data)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeModel *model = GTK_TREE_MODEL(list);
GtkTreePath *path;
GtkTreeViewColumn *column;
GtkTreeIter iter;
gint tx = (gint) event->x;
gint ty = (gint) event->y;
gint cx, cy;
if(event->type == GDK_2BUTTON_PRESS)
{
VarEntry *ve;
gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, &cy);
if (path == NULL)
return FALSE;
gtk_tree_model_get_iter(model, &iter, path);
gtk_tree_model_get(model, &iter, COLUMN_DATA_V, &ve, -1);
if(ve->attr == ATTRB_NONE)
ve->attr = ATTRB_LOCKED;
else if(ve->attr == ATTRB_LOCKED)
ve->attr = ATTRB_ARCHIVED;
else if(ve->attr == ATTRB_ARCHIVED)
ve->attr = ATTRB_NONE;
gtk_list_store_set(list, &iter, COLUMN_ATTR, tifiles_attribute_to_string(ve->attr), -1);
}
return FALSE;
}
static gboolean
panel_button_press_event (GtkTreeView *treeview,
GdkEventButton *event,
PlumaDocumentsPanel *panel)
{
if ((GDK_BUTTON_PRESS == event->type) && (3 == event->button))
{
GtkTreePath* path = NULL;
if (event->window == gtk_tree_view_get_bin_window (treeview))
{
/* Change the cursor position */
if (gtk_tree_view_get_path_at_pos (treeview,
event->x,
event->y,
&path,
NULL,
NULL,
NULL))
{
gtk_tree_view_set_cursor (treeview,
path,
NULL,
FALSE);
gtk_tree_path_free (path);
/* A row exists at mouse position */
return show_popup_menu (panel, event);
}
}
}
return FALSE;
}
static gboolean
tree_view_button_press_callback (GtkWidget *tree_view,
GdkEventButton *event,
gpointer data)
{
GtkTreePath *path;
GtkTreeViewColumn *column;
if (event->button == 1 && event->type == GDK_BUTTON_PRESS)
{
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (tree_view),
event->x, event->y,
&path,
&column,
NULL,
NULL))
{
gtk_tree_view_row_activated
(GTK_TREE_VIEW (tree_view), path, column);
}
}
return FALSE;
}
static void
userlist_dnd_drop (GtkTreeView *widget, GdkDragContext *context,
gint x, gint y, GtkSelectionData *selection_data,
guint info, guint ttime, gpointer userdata)
{
struct User *user;
gchar *data;
GtkTreePath *path;
GtkTreeModel *model;
GtkTreeIter iter;
if (!gtk_tree_view_get_path_at_pos (widget, x, y, &path, NULL, NULL, NULL))
return;
model = gtk_tree_view_get_model (widget);
if (!gtk_tree_model_get_iter (model, &iter, path))
return;
gtk_tree_model_get (model, &iter, COL_USER, &user, -1);
data = (char *)gtk_selection_data_get_data (selection_data);
if (data)
mg_dnd_drop_file (current_sess, user->nick, data);
}
/* Handle click on treeview */
static gboolean view_click_event(GtkWidget *view, GdkEventButton *event, gpointer user_data){
if(event->button!=3) return FALSE;//let system handle left click
GtkTreePath *path=NULL;
GtkTreeViewColumn *column=NULL;
GtkTreeSelection *selection=gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view),
(gint)event->x,
(gint)event->y,
&path, &column, NULL, NULL)){
/*clicks within treeview.*/
if(!gtk_tree_selection_path_is_selected(selection, path)){
/*the path clicked is not selected. move selection to this path*/
gtk_tree_selection_unselect_all(selection);
gtk_tree_selection_select_path(selection, path);
}
gtk_tree_path_free(path);
}else{//clicks outsize of treeview. unselect all.
gtk_tree_selection_unselect_all(selection);
path=NULL; column=NULL;
}
//right click popup menu
view_popup_menu(view, user_data);
return TRUE;
}
static void
qtcTreeViewUpdatePosition(GtkWidget *widget, int x, int y)
{
if (GTK_IS_TREE_VIEW(widget)) {
QtCTreeView *tv = qtcTreeViewLookupHash(widget, false);
if (tv) {
GtkTreeView *treeView = GTK_TREE_VIEW(widget);
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gtk_tree_view_get_path_at_pos(treeView, x, y, &path,
&column, 0L, 0L);
if (!qtcTreeViewSamePath(tv->path, path)) {
// prepare update area
// get old rectangle
QtcRect oldRect = {0, 0, -1, -1 };
QtcRect newRect = {0, 0, -1, -1 };
QtcRect updateRect;
QtcRect alloc = qtcWidgetGetAllocation(widget);
if (tv->path && tv->column) {
gtk_tree_view_get_background_area(
treeView, tv->path, tv->column,
(GdkRectangle*)&oldRect);
}
if (tv->fullWidth) {
oldRect.x = 0;
oldRect.width = alloc.width;
}
// get new rectangle and update position
if (path && column) {
gtk_tree_view_get_background_area(
treeView, path, column, (GdkRectangle*)&newRect);
}
if (path && column && tv->fullWidth) {
newRect.x = 0;
newRect.width = alloc.width;
}
// take the union of both rectangles
if (oldRect.width > 0 && oldRect.height > 0) {
if (newRect.width > 0 && newRect.height > 0) {
qtcRectUnion(&oldRect, &newRect, &updateRect);
} else {
updateRect = oldRect;
}
} else {
updateRect = newRect;
}
// store new cell info
if (tv->path)
gtk_tree_path_free(tv->path);
tv->path = path ? gtk_tree_path_copy(path) : NULL;
tv->column = column;
// convert to widget coordinates and schedule redraw
gtk_tree_view_convert_bin_window_to_widget_coords(
treeView, updateRect.x, updateRect.y,
&updateRect.x, &updateRect.y);
gtk_widget_queue_draw_area(
widget, updateRect.x, updateRect.y,
updateRect.width, updateRect.height);
}
if (path) {
gtk_tree_path_free(path);
}
}
}
}
static gboolean
ephy_node_view_button_press_cb (GtkWidget *treeview,
GdkEventButton *event,
EphyNodeView *view)
{
GtkTreePath *path = NULL;
GtkTreeSelection *selection;
gboolean call_parent = TRUE, path_is_selected;
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (treeview));
if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (treeview)))
{
return GTK_WIDGET_CLASS (parent_class)->button_press_event (treeview, event);
}
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (treeview),
event->x,
event->y,
&path,
NULL, NULL, NULL))
{
path_is_selected = gtk_tree_selection_path_is_selected (selection, path);
if (!gtk_widget_is_focus (GTK_WIDGET (treeview)))
{
gtk_widget_grab_focus (GTK_WIDGET (treeview));
}
if (event->button == 3 && path_is_selected)
{
call_parent = FALSE;
}
if(!button_event_modifies_selection (event) &&
event->button == 1 && path_is_selected &&
gtk_tree_selection_count_selected_rows (selection) > 1)
{
call_parent = FALSE;
}
if (call_parent)
{
GTK_WIDGET_CLASS (parent_class)->button_press_event (treeview, event);
}
if (event->button == 3)
{
gboolean retval;
g_signal_emit_by_name (view, "popup_menu", &retval);
}
else if (event->button == 2)
{
EphyNode *clicked_node;
clicked_node = process_middle_click (path, view);
g_signal_emit (G_OBJECT (view),
ephy_node_view_signals[NODE_MIDDLE_CLICKED], 0, clicked_node);
}
else if (event->button == 1)
{
if (view->priv->toggle_column >= 0)
{
path_toggled (NULL, path, NULL, view);
}
else
{
view->priv->drag_started = FALSE;
view->priv->drag_button = event->button;
view->priv->drag_x = event->x;
view->priv->drag_y = event->y;
}
}
gtk_tree_path_free (path);
}
else
{
gtk_tree_selection_unselect_all (selection);
}
return TRUE;
}
static gboolean
on_button_press_event_recordings_list (GtkWidget *treeview, GdkEventButton *event, gpointer user_data)
{
FreetuxTVApp *app = (FreetuxTVApp *) user_data;
if (event->type == GDK_BUTTON_PRESS && event->button == 3) {
GtkTreeSelection *selection;
GtkTreeModel* model_filter;
GList *list;
gint nbRecordingsTab[TYPERECORDING_COUNT+1] = {0, 0, 0};
GtkTreePath *path;
GtkTreePath *path_selected;
model_filter = gtk_tree_view_get_model(GTK_TREE_VIEW(treeview));
// Get the selection
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
// Select the path where user has clicked if not selected
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeview),
(gint) event->x, (gint) event->y,
&path_selected, NULL, NULL, NULL)){
if(!gtk_tree_selection_path_is_selected (selection, path_selected)){
gtk_tree_selection_unselect_all (selection);
gtk_tree_selection_select_path(selection, path_selected);
}
gtk_tree_path_free(path_selected);
path_selected = NULL;
}
// Get the final list of selected item
list = gtk_tree_selection_get_selected_rows (selection, &model_filter);
//nbTotalGroupsVisible = gtk_tree_model_iter_n_children (GTK_TREE_MODEL(model_filter), NULL);
// Count number of elements selected by category
GList* iterator = NULL;
iterator = g_list_first (list);
while(iterator != NULL){
GtkTreePath *real_path;
GtkTreeIter iter;
// Get the real path
path = (GtkTreePath*)iterator->data;
real_path = gtk_tree_model_filter_convert_path_to_child_path(GTK_TREE_MODEL_FILTER(model_filter), path);
// Look the type of the data in the path
FreetuxTVRecordingInfos* pRecordingInfo;
gtk_tree_model_get_iter (GTK_TREE_MODEL(app->pRecordingList), &iter, real_path);
gtk_tree_model_get(GTK_TREE_MODEL(app->pRecordingList), &iter, RECORDING_COLUMN, &pRecordingInfo, -1);
if(pRecordingInfo != NULL){
switch(pRecordingInfo->status)
{
case FREETUXTV_RECORDING_STATUS_PROCESSING :
case FREETUXTV_RECORDING_STATUS_WAITING :
nbRecordingsTab[TYPERECORDING_INPROGRESS]++;
break;
default:
nbRecordingsTab[TYPERECORDING_TERMINATED]++;
break;
}
nbRecordingsTab[TYPERECORDING_COUNT]++;
}
// Iterate next path
iterator = g_list_next(iterator);
}
GtkWidget *pMenu = NULL;
GtkWidget *pMenuItem;
if(nbRecordingsTab[TYPERECORDING_COUNT] > 0){
pMenu = gtk_menu_new();
g_signal_connect(G_OBJECT(pMenu), "selection-done",
G_CALLBACK(on_popupmenu_selectiondone), app);
// Delete channels from favourites group
pMenuItem = gtk_image_menu_item_new_from_stock ("gtk-delete", NULL);
#if GTK_API_VERSION == 3
gtk_menu_shell_append (GTK_MENU_SHELL (pMenu), pMenuItem);
#else
gtk_menu_append (GTK_MENU (pMenu), pMenuItem);
#endif
g_signal_connect(G_OBJECT(pMenuItem), "activate",
G_CALLBACK(on_popupmenu_activated_recordingdelete), app);
gtk_widget_show (pMenuItem);
}
if(pMenu){
gtk_widget_show(pMenu);
gtk_menu_popup(GTK_MENU(pMenu), NULL, NULL, NULL, NULL,
(event != NULL) ? event->button : 0,
gdk_event_get_time((GdkEvent*)event));
}
return TRUE;
}
return FALSE;
}
gint
drag_received (GtkWidget* widget, GdkDragContext* drag_context, gint x, gint y, GtkSelectionData* data, guint info, guint time, gpointer user_data)
{
// this receives drops for the whole window.
if(!data || data->length < 0){ perr("no data!\n"); return -1; }
dbg(1, "%s", data->data);
if(g_str_has_prefix((char*)data->data, "colour:")){
char* colour_string = (char*)data->data + 7;
unsigned colour_index = atoi(colour_string) ? atoi(colour_string) - 1 : 0;
// which row are we on?
GtkTreePath* path;
GtkTreeIter iter;
gint tx, treeview_top;
gdk_window_get_position(app->libraryview->widget->window, &tx, &treeview_top);
dbg(2, "treeview_top=%i", y);
#ifdef HAVE_GTK_2_12
gint bx, by;
gtk_tree_view_convert_widget_to_bin_window_coords(GTK_TREE_VIEW(app->libraryview->widget), x, y - treeview_top, &bx, &by);
dbg(2, "coords: %dx%d => %dx%d", x, y, bx, by);
#else
gint by = y - treeview_top - 20;
#endif
#ifdef USE_GDL
GdkWindow* top_window = gdk_window_get_toplevel(gtk_widget_get_toplevel(app->libraryview->widget)->window);
GdkWindow* window = app->libraryview->widget->window;
while((window = gdk_window_get_parent(window)) != top_window){
gint x0, y0;
gdk_window_get_position(window, &x0, &y0);
by -= y0;
}
#endif
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(app->libraryview->widget), x, by, &path, NULL, NULL, NULL)){
gtk_tree_model_get_iter(GTK_TREE_MODEL(samplecat.store), &iter, path);
gchar* path_str = gtk_tree_model_get_string_from_iter(GTK_TREE_MODEL(samplecat.store), &iter);
dbg(2, "path=%s y=%i final_y=%i", path_str, y, y - treeview_top);
listview_item_set_colour(path, colour_index);
gtk_tree_path_free(path);
}
else dbg(0, "path not found.");
return FALSE;
}
if(info == GPOINTER_TO_INT(GDK_SELECTION_TYPE_STRING)) printf(" type=string.\n");
if(info == GPOINTER_TO_INT(TARGET_URI_LIST)){
dbg(1, "type=uri_list. len=%i", data->length);
GList* list = uri_list_to_glist((char*)data->data);
if(g_list_length(list) < 1) pwarn("drag drop: uri list parsing found no uri's.\n");
int i = 0;
ScanResults result = {0,};
GList* l = list;
#ifdef __APPLE__
gdk_threads_enter();
#endif
for(;l;l=l->next){
char* u = l->data;
gchar* method_string;
vfs_get_method_string(u, &method_string);
dbg(2, "%i: %s method=%s", i, u, method_string);
if(!strcmp(method_string, "file")){
//we could probably better use g_filename_from_uri() here
//http://10.0.0.151/man/glib-2.0/glib-Character-Set-Conversion.html#g-filename-from-uri
//-or perhaps get_local_path() from rox/src/support.c
char* uri_unescaped = vfs_unescape_string(u + strlen(method_string) + 1, NULL);
char* uri = (strstr(uri_unescaped, "///") == uri_unescaped) ? uri_unescaped + 2 : uri_unescaped;
if(do_progress(0,0)) break;
if(is_dir(uri)) application_add_dir(uri, &result);
else application_add_file(uri, &result);
g_free(uri_unescaped);
}
else pwarn("drag drop: unknown format: '%s'. Ignoring.\n", u);
i++;
}
hide_progress();
#ifdef __APPLE__
gdk_threads_leave();
#endif
statusbar_print(1, "import complete. %i files added", result.n_added);
uri_list_free(list);
}
return FALSE;
}
static gboolean
egg_tree_multi_drag_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
GtkTreeView *tree_view;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gint cell_x, cell_y;
GtkTreeSelection *selection;
EggTreeMultiDndData *priv_data;
if (event->window != gtk_tree_view_get_bin_window (GTK_TREE_VIEW (widget)))
return FALSE;
if (event->button == 3)
return FALSE;
tree_view = GTK_TREE_VIEW (widget);
priv_data = g_object_get_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING);
if (priv_data == NULL)
{
priv_data = g_new0 (EggTreeMultiDndData, 1);
priv_data->pending_event = FALSE;
g_object_set_data (G_OBJECT (tree_view),
EGG_TREE_MULTI_DND_STRING,
priv_data);
}
if (g_slist_find (priv_data->event_list, event))
return FALSE;
if (priv_data->pending_event)
{
/* save the event to be propagated in order */
priv_data->event_list = g_slist_append (priv_data->event_list,
gdk_event_copy ((GdkEvent*)event));
return TRUE;
}
if (event->type == GDK_2BUTTON_PRESS)
return FALSE;
gtk_tree_view_get_path_at_pos (tree_view,
event->x, event->y,
&path, &column,
&cell_x, &cell_y);
selection = gtk_tree_view_get_selection (tree_view);
if (path)
{
gboolean call_parent = (event->state & (GDK_CONTROL_MASK | GDK_SHIFT_MASK) ||
!gtk_tree_selection_path_is_selected (selection, path) ||
event->button != 1);
if (call_parent)
(GTK_WIDGET_GET_CLASS (tree_view))->button_press_event (widget, event);
if (gtk_tree_selection_path_is_selected (selection, path))
{
priv_data->pressed_button = event->button;
priv_data->x = event->x;
priv_data->y = event->y;
priv_data->pending_event = TRUE;
if (!call_parent)
priv_data->event_list = g_slist_append (priv_data->event_list,
gdk_event_copy ((GdkEvent*)event));
if (priv_data->motion_notify_handler == 0)
{
priv_data->motion_notify_handler =
g_signal_connect (G_OBJECT (tree_view),
"motion_notify_event",
G_CALLBACK (egg_tree_multi_drag_motion_event),
NULL);
}
if (priv_data->button_release_handler == 0)
{
priv_data->button_release_handler =
g_signal_connect (G_OBJECT (tree_view),
"button_release_event",
G_CALLBACK (egg_tree_multi_drag_button_release_event),
NULL);
}
if (priv_data->drag_data_get_handler == 0)
{
priv_data->drag_data_get_handler =
g_signal_connect (G_OBJECT (tree_view),
"drag_data_get",
G_CALLBACK (egg_tree_multi_drag_drag_data_get),
NULL);
}
}
gtk_tree_path_free (path);
/* We called the default handler so we don't let the default handler run */
return TRUE;
}
return FALSE;
}
static gint
userlist_click_cb (GtkWidget *widget, GdkEventButton *event, gpointer userdata)
{
char **nicks;
int i;
GtkTreeSelection *sel;
GtkTreePath *path;
if (!event)
return FALSE;
if (!(event->state & STATE_CTRL) &&
event->type == GDK_2BUTTON_PRESS && prefs.hex_gui_ulist_doubleclick[0])
{
nicks = userlist_selection_list (widget, &i);
if (nicks)
{
nick_command_parse (current_sess, prefs.hex_gui_ulist_doubleclick, nicks[0],
nicks[0]);
while (i)
{
i--;
g_free (nicks[i]);
}
free (nicks);
}
return TRUE;
}
if (event->button == 3)
{
/* do we have a multi-selection? */
nicks = userlist_selection_list (widget, &i);
if (nicks && i > 1)
{
menu_nickmenu (current_sess, event, nicks[0], i);
while (i)
{
i--;
g_free (nicks[i]);
}
free (nicks);
return TRUE;
}
if (nicks)
{
g_free (nicks[0]);
free (nicks);
}
sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
if (gtk_tree_view_get_path_at_pos (GTK_TREE_VIEW (widget),
event->x, event->y, &path, 0, 0, 0))
{
gtk_tree_selection_unselect_all (sel);
gtk_tree_selection_select_path (sel, path);
gtk_tree_path_free (path);
nicks = userlist_selection_list (widget, &i);
if (nicks)
{
menu_nickmenu (current_sess, event, nicks[0], i);
while (i)
{
i--;
g_free (nicks[i]);
}
free (nicks);
}
} else
{
gtk_tree_selection_unselect_all (sel);
}
return TRUE;
}
return FALSE;
}
static gboolean
egg_tree_multi_drag_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer data)
{
GtkTreeView *tree_view;
GtkTreePath *path = NULL;
GtkTreeViewColumn *column = NULL;
gint cell_x, cell_y;
GtkTreeSelection *selection;
EggTreeMultiDndData *priv_data;
tree_view = GTK_TREE_VIEW (widget);
priv_data = g_object_get_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING);
if (priv_data == NULL)
{
priv_data = g_new0 (EggTreeMultiDndData, 1);
g_object_set_data (G_OBJECT (tree_view), EGG_TREE_MULTI_DND_STRING, priv_data);
}
if (g_slist_find (priv_data->event_list, event))
return FALSE;
if (priv_data->event_list)
{
/* save the event to be propagated in order */
priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
return TRUE;
}
if (event->type == GDK_2BUTTON_PRESS)
return FALSE;
if (event->button == 3)
return FALSE;
gtk_tree_view_get_path_at_pos (tree_view,
event->x, event->y,
&path, &column,
&cell_x, &cell_y);
selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree_view));
if (path && gtk_tree_selection_path_is_selected (selection, path))
{
priv_data->pressed_button = event->button;
priv_data->x = event->x;
priv_data->y = event->y;
priv_data->event_list = g_slist_append (priv_data->event_list, gdk_event_copy ((GdkEvent*)event));
priv_data->motion_notify_handler =
g_signal_connect (G_OBJECT (tree_view), "motion_notify_event", G_CALLBACK (egg_tree_multi_drag_motion_event), NULL);
priv_data->button_release_handler =
g_signal_connect (G_OBJECT (tree_view), "button_release_event", G_CALLBACK (egg_tree_multi_drag_button_release_event), NULL);
if (priv_data->drag_data_get_handler == 0)
{
priv_data->drag_data_get_handler =
g_signal_connect (G_OBJECT (tree_view), "drag_data_get", G_CALLBACK (egg_tree_multi_drag_drag_data_get), NULL);
}
gtk_tree_path_free (path);
return TRUE;
}
if (path)
{
gtk_tree_path_free (path);
}
return FALSE;
}
gboolean on_btn_pressed(GtkWidget* view, GdkEventButton* evt, FmFolderView* fv)
{
GList* sels;
FmFolderViewClickType type = 0;
GtkTreePath* tp;
if(!fv->model)
return FALSE;
/* FIXME: handle single click activation */
if( evt->type == GDK_BUTTON_PRESS )
{
/* special handling for ExoIconView */
if(evt->button != 1)
{
if(fv->mode==FM_FV_ICON_VIEW || fv->mode==FM_FV_COMPACT_VIEW || fv->mode==FM_FV_THUMBNAIL_VIEW)
{
/* select the item on right click for ExoIconView */
if(exo_icon_view_get_item_at_pos(EXO_ICON_VIEW(view), evt->x, evt->y, &tp, NULL))
{
/* if the hit item is not currently selected */
if(!exo_icon_view_path_is_selected(EXO_ICON_VIEW(view), tp))
{
sels = exo_icon_view_get_selected_items((const struct ExoIconView *)(const struct ExoIconView *)view);
if( sels ) /* if there are selected items */
{
exo_icon_view_unselect_all(EXO_ICON_VIEW(view)); /* unselect all items */
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
exo_icon_view_select_path(EXO_ICON_VIEW(view), tp);
exo_icon_view_set_cursor(EXO_ICON_VIEW(view), tp, NULL, FALSE);
}
gtk_tree_path_free(tp);
}
}
else if( fv->mode == FM_FV_LIST_VIEW
&& evt->window == gtk_tree_view_get_bin_window(GTK_TREE_VIEW(view)))
{
/* special handling for ExoTreeView */
/* Fix #2986834: MAJOR PROBLEM: Deletes Wrong File Frequently. */
GtkTreeViewColumn* col;
if(gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(view), evt->x, evt->y, &tp, &col, NULL, NULL))
{
GtkTreeSelection* tree_sel = gtk_tree_view_get_selection(GTK_TREE_VIEW(view));
if(!gtk_tree_selection_path_is_selected(tree_sel, tp))
{
gtk_tree_selection_unselect_all(tree_sel);
if(col == exo_tree_view_get_activable_column(EXO_TREE_VIEW(view)))
{
gtk_tree_selection_select_path(tree_sel, tp);
gtk_tree_view_set_cursor(GTK_TREE_VIEW(view), tp, NULL, FALSE);
}
}
gtk_tree_path_free(tp);
}
}
}
if(evt->button == 2) /* middle click */
type = FM_FV_MIDDLE_CLICK;
else if(evt->button == 3) /* right click */
type = FM_FV_CONTEXT_MENU;
}
if( type != FM_FV_CLICK_NONE )
{
sels = fm_folder_view_get_selected_tree_paths(fv);
if( sels || type == FM_FV_CONTEXT_MENU )
{
item_clicked(fv, sels ? sels->data : NULL, type);
if(sels)
{
g_list_foreach(sels, (GFunc)gtk_tree_path_free, NULL);
g_list_free(sels);
}
}
}
return FALSE;
}
static gboolean
tree_event (GtkTreeView *tree,
GdkEvent *event)
{
GtkTreeViewColumn *column;
gint cx, cy, atrow;
switch (event->type)
{
GdkRectangle rect;
gint wx, wy;
case GDK_BUTTON_PRESS:
atrow = gtk_tree_view_get_path_at_pos (tree, event->button.x, event->button.y,
NULL, &column, &cx, &cy);
g_print ("got button_press at %f,%f [%u] (%p %d %d)\n", event->button.x, event->button.y, atrow, column, cx, cy);
break;
case GDK_BUTTON_RELEASE:
atrow = gtk_tree_view_get_path_at_pos (tree, event->button.x, event->button.y,
NULL, &column, &cx, &cy);
g_print ("got button_release at %f,%f [%u] (%p %d %d)\n", event->button.x, event->button.y, atrow, column, cx, cy);
break;
case GDK_MOTION_NOTIFY:
atrow = gtk_tree_view_get_path_at_pos (tree, event->motion.x, event->motion.y,
NULL, &column, &cx, &cy);
gtk_tree_view_get_visible_rect (tree, &rect);
gtk_tree_view_tree_to_widget_coords (tree, rect.x, rect.y, &wx, &wy);
g_print ("got motion at %f,%f [%u] (%p %d %d) widget(%d %d)\n", event->motion.x, event->motion.y, atrow, column,
cx, cy, wx, wy);
break;
default:
}
return FALSE;
}
static GtkWidget*
pack_test_widget (void)
{
GtkWidget *scwin, *tree;
GtkTreeSelection *tsel;
GxkListWrapper *plist = gxk_list_wrapper_new (3 /* N_COLS */,
G_TYPE_STRING, /* 0 */
G_TYPE_STRING, /* 1 */
G_TYPE_STRING /* 2 */
);
g_signal_connect_object (plist, "fill-value",
G_CALLBACK (plist_fill_value),
NULL, G_CONNECT_SWAPPED);
gxk_list_wrapper_notify_prepend (plist, 200);
scwin = g_object_new (GTK_TYPE_SCROLLED_WINDOW,
"visible", TRUE,
"hscrollbar_policy", GTK_POLICY_AUTOMATIC,
"vscrollbar_policy", GTK_POLICY_ALWAYS,
"height_request", 320,
"width_request", 320,
"border_width", 5,
"shadow_type", GTK_SHADOW_IN,
NULL);
tree = g_object_new (GTK_TYPE_TREE_VIEW,
"visible", TRUE,
"can_focus", TRUE,
"model", plist,
"border_width", 10,
"parent", scwin,
NULL);
gxk_tree_view_append_text_columns (GTK_TREE_VIEW (tree), 3 /* N_COLS */,
0, "", 0.0, "Foo Name",
1, "", 0.0, "Bar Name",
2, "", 0.0, "Baz Type"
);
gtk_tree_view_add_column (GTK_TREE_VIEW (tree), -1,
g_object_new (GTK_TYPE_TREE_VIEW_COLUMN,
"title", "PTrack",
"sizing", GTK_TREE_VIEW_COLUMN_GROW_ONLY,
"resizable", TRUE,
NULL),
g_object_new (BST_TYPE_CELL_PTRACK,
"xalign", 0.0,
NULL),
// "text", 3,
NULL);
g_object_connect (tree,
"signal::event", tree_event, NULL,
NULL);
#if 0
g_object_connect (tree,
"swapped_object_signal::row_activated", tree_row_activated, self,
NULL);
#endif
/* ensure selection
*/
tsel = gtk_tree_view_get_selection (GTK_TREE_VIEW (tree));
gtk_tree_selection_set_mode (tsel, GTK_SELECTION_SINGLE);
gxk_tree_selection_select_spath (tsel, "0");
return scwin;
}
GLADE_CB gboolean
on_treeview3_button_press_event (GtkWidget *widget,
GdkEventButton *event,
gpointer user_data)
{
GtkTreeView *view = GTK_TREE_VIEW(widget);
GtkTreeModel *model = gtk_tree_view_get_model(view);
GtkTreePath *path;
GtkTreeViewColumn *column;
GtkTreeIter iter;
gboolean ret;
gchar *spath;
gint i, j;
gint col;
if(event->type != GDK_BUTTON_PRESS)
return FALSE;
{
// cell selection
gint tx = (gint) event->x;
gint ty = (gint) event->y;
gint cx, cy;
ret = gtk_tree_view_get_path_at_pos(view, tx, ty, &path, &column, &cx, &cy);
if(ret == FALSE)
return FALSE;
col = column2index((GtkWidget *)view, column);
spath = gtk_tree_path_to_string(path);
sscanf(spath, "%i:%i", &i, &j);
//gtk_tree_path_free(path);
g_free(spath);
}
if(event->button == 1) // first button clicked
{
if(!((col == 0) && (i == 2) && ((j == 4) ||(j ==5))))
return FALSE;
if(dbgsr_display_dbox() == -1)
return TRUE;
dbgregs_refresh_window();
dbgstack_refresh_window();
return TRUE;
}
if (event->button == 3) // third button clicked
{
GdkEventButton *bevent;
GtkWidget *menu;
// check for click on regs
if(!
(
(col == 1) &&
(i>= 0) && (i <= 1) &&
(j >= 0) && (j <= 7)
)
)
return FALSE;
// get iterator
if (!gtk_tree_model_get_iter(model, &iter, path))
return FALSE;
gtk_tree_path_free(path);
gtk_tree_model_get(model, &iter, COL_VALUE, &spath, -1);
sscanf(spath, "%x", &value);
printf("value = %x\n", value);
// popup menu
bevent = (GdkEventButton *) (event);
menu = display_popup_menu();
gtk_menu_popup(GTK_MENU(menu),
NULL, NULL, NULL, NULL,
bevent->button, bevent->time);
gtk_widget_show(menu);
return TRUE;
}
return FALSE;
}
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
panel_button_press_event (GtkTreeView *treeview,
GdkEventButton *event,
GeditDocumentsPanel *panel)
{
gboolean ret = FALSE;
gedit_debug (DEBUG_PANEL);
if ((event->type == GDK_BUTTON_PRESS) &&
(gdk_event_triggers_context_menu ((GdkEvent *) event)) &&
(event->window == gtk_tree_view_get_bin_window (treeview)))
{
GtkTreePath *path = NULL;
/* Change the cursor position */
if (gtk_tree_view_get_path_at_pos (treeview,
event->x,
event->y,
&path,
NULL,
NULL,
NULL))
{
GtkTreeIter iter;
gchar *path_string;
path_string = gtk_tree_path_to_string (path);
if (gtk_tree_model_get_iter_from_string (panel->priv->model,
&iter,
path_string))
{
GeditTab *tab;
gtk_tree_model_get (panel->priv->model,
&iter,
TAB_COLUMN, &tab,
-1);
if (tab != NULL)
{
gtk_tree_view_set_cursor (treeview,
path,
NULL,
FALSE);
/* A row exists at the mouse position */
ret = show_tab_popup_menu (panel, tab, event);
g_object_unref (tab);
}
}
g_free (path_string);
gtk_tree_path_free (path);
}
}
return ret;
}
static
gchar *get_tooltip_text()
{
gchar *retval = NULL;
GString *string;
guint64 id;
GtkTreePath *path;
GtkTreeIter iterp, iter;
GTodoItem *item;
int i = gtk_combo_box_get_active(GTK_COMBO_BOX(mw.option));
string = g_string_new("");
if (gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(mw.treeview), rect.x, rect.y, &path, NULL, NULL, NULL))
{
gtk_tree_model_get_iter(GTK_TREE_MODEL(mw.sortmodel), &iterp, path);
gtk_tree_model_sort_convert_iter_to_child_iter(GTK_TREE_MODEL_SORT(mw.sortmodel), &iter, &iterp);
gtk_tree_model_get(GTK_TREE_MODEL(mw.list), &iter,
ID, &id,
-1);
gtk_tree_path_free(path);
item = gtodo_client_get_todo_item_from_id(cl, (guint32)id);
if(item != NULL)
{
if(i == 0)
{
g_string_append_printf(string, "<i>%s:</i>\n",
gtodo_todo_item_get_category(item));
}
if(gtodo_todo_item_get_summary(item) != NULL)
{
g_string_append_printf(string, "<b>%s</b>\t%s", _("Summary:"),
gtodo_todo_item_get_summary(item));
}
if(gtodo_todo_item_get_due_date(item) != NULL
&& gtodo_todo_item_get_due_time_houre(item) == -1){
g_string_append_printf(string, "\n<b>%s</b>\t%s", _("Due date:"),
gtodo_todo_item_get_due_date_as_string(item));
}
else if(gtodo_todo_item_get_due_date(item) != NULL)
{
g_string_append_printf(string, "\n<b>%s</b>\t%s at %02i:%02i" ,
_("Due date:") ,
gtodo_todo_item_get_due_date_as_string(item),
gtodo_todo_item_get_due_time_houre(item),
gtodo_todo_item_get_due_time_minute(item));
}
if(gtodo_todo_item_get_priority(item) == 0)
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t<span color=\"dark green\">%s</span>",
_("Priority:"),
_("Low"));
}
else if(gtodo_todo_item_get_priority(item) == 1)
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t%s",
_("Priority:"), _("Medium"));
}
else
{
g_string_append_printf(string,
"\n<b>%s</b>\t\t<span color=\"red\">%s</span>",
_("Priority:"), _("High"));
}
if(gtodo_todo_item_get_comment(item) != NULL && strlen(gtodo_todo_item_get_comment(item)))
{
g_string_append_printf(string, "\n<b>%s</b>\t%s", _("Comment:"),
gtodo_todo_item_get_comment(item));
}
gtodo_todo_item_free(item);
}
/* free all the stuff */
for(i=0;i < string->len;i++)
{
if(string->str[i] == '&')
{
g_string_insert(string, i+1, "amp;");
}
}
retval = string->str;
g_string_free(string, FALSE);
return retval;
}
else return g_strdup("oeps");
}
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;
}
