示例#1
1
static gboolean
select_button_key_press_callback (GtkWidget *widget,
                                  GdkEventKey *event,
                                  gpointer user_data)
{
    CajaSidePane *side_pane;

    side_pane = CAJA_SIDE_PANE (user_data);

    if (event->keyval == GDK_KEY_space ||
        event->keyval == GDK_KEY_KP_Space ||
        event->keyval == GDK_KEY_Return ||
        event->keyval == GDK_KEY_KP_Enter)
    {
        gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
        gtk_menu_popup (GTK_MENU (side_pane->details->menu),
                        NULL, NULL, menu_position_under, widget,
                        1, event->time);
        return TRUE;
    }

    return FALSE;
}
示例#2
1
void
popupmenu_list (GtkTreePath *path, GdkEventButton *event, gboolean can_trash)
{
	GtkWidget *pmenu;

	pmenu = gtk_menu_new ();

	add_popupmenu_item (GTK_MENU (pmenu),
			    _("_Open Folder"),
			    "gtk-open",
			    G_CALLBACK (open_file_cb));

	if (baobab.is_local && can_trash) {
		add_popupmenu_item (GTK_MENU (pmenu),
				    _("Mo_ve to Trash"),
				    "gtk-delete",
				    G_CALLBACK (trash_dir_cb));
	}

	gtk_widget_show_all (pmenu);
	gtk_menu_popup (GTK_MENU (pmenu), NULL, NULL, NULL, NULL,
			event->button, event->time);
}
示例#3
0
static int 
mouse_press (Viewer *viewer, EventHandler *ehandler,
                        const double ray_start[3], const double ray_dir[3], 
                        const GdkEventButton *event)
{
    RendererSimTraffic *self = (RendererSimTraffic*) ehandler->user;

    if (event->type == GDK_2BUTTON_PRESS) {
        self->display_detail ^= 1;
    }

    geom_ray_z_plane_intersect_3d((point3d_t*)ray_start, 
            (point3d_t*)ray_dir, 0, (point2d_t*)self->last_xy);

    if (self->ehandler.picking && event->button == 3) {
        gtk_menu_popup (self->context_menu, NULL, NULL, NULL, NULL,
                event->button, event->time);
        self->menu_car_id = self->selected_vehicle_id;
        self->ehandler.picking = 0;
    }

    return 0;
}
示例#4
0
/* [gtk thread] */
static gboolean do_show_popup_menu(gpointer data)
{
   ARGS *args = (ARGS *) data;
   
   lock_args(args);
   
   if (!args->menu->extra1) {
      GtkWidget *menu = gtk_menu_new();
      
      build_menu(menu, args->menu);
      
      gtk_widget_show(menu);
      args->menu->extra1 = menu;
      
      g_signal_connect_swapped (menu, "hide",
         G_CALLBACK(popop_on_hide), (gpointer) args->menu);
   }
   gtk_menu_popup(args->menu->extra1, NULL, NULL, NULL, NULL, 0, gtk_get_current_event_time());
   
   release_args(args);
   
   return FALSE;
}
示例#5
0
/* called when the user klicks on the applet */
static gboolean
applet_button_cb (GtkWidget	*widget,
		GdkEventButton	*event,
		DdccApplet	*applet)
{
	if (event->button == 1)
	{
		if (applet->error)
			ddcc_applet_init(applet);
		if (applet->error)
			return FALSE;
		
		if (applet->w_profiles_menu)
		{
			gtk_menu_popup (GTK_MENU (applet->w_profiles_menu),
					NULL, NULL,
					position_menu, applet->w_applet,
					event->button, event->time);
		}
		return TRUE;
	}
	return FALSE;
}
示例#6
0
static gboolean
gdict_sidebar_select_key_press_cb (GtkWidget   *widget,
				   GdkEventKey *event,
				   gpointer     user_data)
{
  GdictSidebar *sidebar = GDICT_SIDEBAR (user_data);

  if (event->keyval == GDK_KEY_space ||
      event->keyval == GDK_KEY_KP_Space ||
      event->keyval == GDK_KEY_Return ||
      event->keyval == GDK_KEY_KP_Enter)
    {
      gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (widget), TRUE);
      gtk_menu_popup (GTK_MENU (sidebar->priv->menu),
		      NULL, NULL,
		      gdict_sidebar_menu_position_function, widget,
		      1, event->time);

      return TRUE;
    }

  return FALSE;
}
示例#7
0
static void
show_menu (NemoNavigationAction *self,
           guint button,
           guint32 event_time)
{
	NemoWindow *window;
	GtkWidget *menu;

	window = self->priv->window;
	
	menu = gtk_menu_new ();

	switch (self->priv->direction) {
	case NEMO_NAVIGATION_DIRECTION_FORWARD:
		fill_menu (window, menu, FALSE);
		break;
	case NEMO_NAVIGATION_DIRECTION_BACK:
		fill_menu (window, menu, TRUE);
		break;
 	case NEMO_NAVIGATION_DIRECTION_UP:
 		return;
 	case NEMO_NAVIGATION_DIRECTION_RELOAD:
 		return;
 	case NEMO_NAVIGATION_DIRECTION_HOME:
 		return;
 	case NEMO_NAVIGATION_DIRECTION_COMPUTER:
 		return;
 	case NEMO_NAVIGATION_DIRECTION_EDIT:
 		return;
	default:
		g_assert_not_reached ();
		break;
	}

        gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                        button, event_time);
}
示例#8
0
static void displayContextMenu(guint button, guint32 acttime, gpointer data)
    {
    GdkEventButton *event = static_cast<GdkEventButton*>(data);
    const OperationClass *node = gOperationDiagramView->getDiagram().getNode(
        static_cast<int>(event->x), static_cast<int>(event->y));
    const OperationCall *opcall = gOperationDiagramView->getDiagram().getOperation(
            gStartPosInfo.x, gStartPosInfo.y);
    OovStringRef const nodeitems[] =
        {
        "OperGotoClassMenuitem",
        "RemoveOperClassMenuitem",
        };
    Builder *builder = Builder::getBuilder();
    for(size_t i=0; i<sizeof(nodeitems)/sizeof(nodeitems[i]); i++)
        {
        gtk_widget_set_sensitive(builder->getWidget(nodeitems[i]),
                node != nullptr);
        }
    OovStringRef const operitems[] =
        {
        "OperGotoOperationMenuitem",
        "AddCallsMenuitem",
        "AddCallersMenuitem",
        "RemoveCallsMenuitem"
        };
    for(size_t i=0; i<sizeof(operitems)/sizeof(operitems[i]); i++)
        {
        gtk_widget_set_sensitive(builder->getWidget(operitems[i]),
                opcall != nullptr);
        }
    gtk_widget_set_sensitive(builder->getWidget("ViewOperSourceMenuitem"),
            opcall != nullptr || node != nullptr);

    GtkMenu *menu = builder->getMenu("DrawOperationPopupMenu");
    gtk_menu_popup(menu, nullptr, nullptr, nullptr, nullptr, button, acttime);
    gStartPosInfo.set(static_cast<int>(event->x), static_cast<int>(event->y));
    }
示例#9
0
bool C2DView::OnRButtonUp( int x, int y ){
	if ( ViewState == View_Move ) {
		// maybe it's time for popup menu
		if ( m_bPopup ) {
			GtkWidget *menu, *item;

			menu = gtk_menu_new();

			item = gtk_menu_item_new_with_label( _( "Validate (RETURN)" ) );
			g_signal_connect( G_OBJECT( item ), "activate", G_CALLBACK( Textool_Validate ), NULL );
			gtk_widget_show( item );
			gtk_menu_append( GTK_MENU( menu ), item );

			item = gtk_menu_item_new_with_label( _( "Zoom in (INSERT)" ) );
			g_signal_connect( G_OBJECT( item ), "activate", G_CALLBACK( view_ZoomIn ), this );
			gtk_widget_show( item );
			gtk_menu_append( GTK_MENU( menu ), item );

			item = gtk_menu_item_new_with_label( _( "Zoom out (DELETE)" ) );
			g_signal_connect( G_OBJECT( item ), "activate", G_CALLBACK( view_ZoomOut ), this );
			gtk_widget_show( item );
			gtk_menu_append( GTK_MENU( menu ), item );

			item = gtk_menu_item_new_with_label( _( "Cancel (ESC)" ) );
			g_signal_connect( G_OBJECT( item ), "activate", G_CALLBACK( Textool_Cancel ), NULL );
			gtk_widget_show( item );
			gtk_menu_append( GTK_MENU( menu ), item );

			gtk_menu_popup( GTK_MENU( menu ), NULL, NULL, NULL, NULL, 1, GDK_CURRENT_TIME );
		}

		// back to Idle mode
		ViewState = View_Idle;
		return true;
	}
	return false;
}
示例#10
0
static void
popup_avatar_menu (EmpathyContactWidget *information,
                   GtkWidget *parent,
                   GdkEventButton *event)
{
  GtkWidget *menu, *item;
  gint button, event_time;

  if (information->contact == NULL ||
      empathy_contact_get_avatar (information->contact) == NULL)
      return;

  menu = gtk_menu_new ();

  /* Add "Save as..." entry */
  item = gtk_image_menu_item_new_from_stock (GTK_STOCK_SAVE_AS, NULL);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
  gtk_widget_show (item);

  g_signal_connect (item, "activate",
      G_CALLBACK (save_avatar_menu_activate_cb), information);

  if (event)
    {
      button = event->button;
      event_time = event->time;
    }
  else
    {
      button = 0;
      event_time = gtk_get_current_event_time ();
    }

  gtk_menu_attach_to_widget (GTK_MENU (menu), parent, NULL);
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
      button, event_time);
}
示例#11
0
static void
ppg_menu_tool_item_button_clicked (GtkWidget       *button,
                                   PpgMenuToolItem *item)
{
	PpgMenuToolItemPrivate *priv;
	GtkWindow *window;

	g_return_if_fail(PPG_IS_MENU_TOOL_ITEM(item));
	g_return_if_fail(GTK_IS_BUTTON(button));

	priv = item->priv;

	if (priv->menu) {
		gtk_menu_popup(GTK_MENU(priv->menu), NULL, NULL,
		               ppg_menu_tool_item_menu_position_func,
		               item, 1, gtk_get_current_event_time());
	} else {
		/*
		 * Don't allow the button to get focus.
		 */
		window = GTK_WINDOW(gtk_widget_get_toplevel(button));
		gtk_window_set_focus(window, NULL);
	}
}
示例#12
0
void on_trayicon_menu (GtkStatusIcon *status_icon,
		       guint          button,
		       guint          activate_time,
		       gpointer       user_data)
{
  GromitData *data = (GromitData *) user_data;
  if(data->debug)
    g_printerr("DEBUG: trayicon menu popup\n");

  /* create the menu */
  GtkWidget *menu = gtk_menu_new ();
  /* Create the menu items */
  //TODO option menu
  GtkWidget* sep_item = gtk_separator_menu_item_new();
  GtkWidget* quit_item = gtk_image_menu_item_new_from_stock(GTK_STOCK_QUIT, NULL);


  /* Add them to the menu */
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), sep_item);
  gtk_menu_shell_append (GTK_MENU_SHELL (menu), quit_item);

  /* Attach the callback functions to the respective activate signal */
  g_signal_connect(G_OBJECT (quit_item), "activate",
		   G_CALLBACK (gtk_main_quit),
		   NULL);


  /* We do need to show menu items */
  gtk_widget_show (sep_item);
  gtk_widget_show (quit_item);


  /* show menu */
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL,
                  0, gtk_get_current_event_time());
}
示例#13
0
文件: widgets.c 项目: pingax/pragha
static void
seach_entry_populate_popup (GtkEntry *entry, PraghaPreferences *preferences)
{
	GtkWidget *popup_menu, *item;
	gboolean instant_search, approximate_search;

	popup_menu = gtk_menu_new ();

	/* Instant search. */

	item = gtk_check_menu_item_new_with_label (_("Refine the search while writing"));
	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);

	instant_search = pragha_preferences_get_instant_search(preferences);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), instant_search);
	g_signal_connect (G_OBJECT (item), "toggled",
				G_CALLBACK (search_entry_instant_option_toggled), preferences);
	gtk_widget_show (item);

	/* Aproximate search. */

	item = gtk_check_menu_item_new_with_label (_("Search approximate words"));
	gtk_menu_shell_append (GTK_MENU_SHELL (popup_menu), item);

	approximate_search = pragha_preferences_get_approximate_search(preferences);
	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), approximate_search);
	g_signal_connect (G_OBJECT (item), "toggled",
				G_CALLBACK (search_entry_approximate_option_toggled), preferences);
	gtk_widget_show (item);

	gtk_menu_attach_to_widget(GTK_MENU(popup_menu), GTK_WIDGET(entry), NULL);

	gtk_menu_popup(GTK_MENU(popup_menu), NULL, NULL,
			(GtkMenuPositionFunc) menu_position, entry,
			0, gtk_get_current_event_time());
}
示例#14
0
void SubPaletteGtk::create_popup_menu( char *filename, int x, int y) 
{
  gint wind_x, wind_y;

  strncpy( popup_help_filename, filename, sizeof(popup_help_filename));

  CoWowGtk::PopupPosition( form_widget, x, y, &wind_x, &wind_y);

  popupmenu_x = wind_x;
  popupmenu_y = wind_y;

  GtkMenu *menu = (GtkMenu *) g_object_new( GTK_TYPE_MENU, NULL);
  GtkWidget *w = gtk_menu_item_new_with_label( "Help");
  g_signal_connect( w, "activate", 
		    G_CALLBACK(activate_help), this);
  gtk_menu_shell_append(GTK_MENU_SHELL(menu), w);
  gtk_widget_show(w);

  //g_signal_connect( menu, "deactivate", 
  //		    G_CALLBACK(popup_unmap_cb), this);
  gtk_menu_popup( menu, NULL, NULL, menu_position_func, 
		  this, 0, gtk_get_current_event_time());

}
示例#15
0
static gboolean mouse_press_handler(	GtkWidget *widget,
					GdkEvent *event,
					gpointer data )
{
	GdkEventButton *btn_event = (GdkEventButton *)event;
	gboolean handled;

	handled = (	btn_event->type == GDK_BUTTON_PRESS &&
			btn_event->button == 3 );

	if(handled)
	{
		GMenu *menu;
		GMenuItem *add_menu_item;
		GMenuItem *loop_menu_item;
		GtkWidget *ctx_menu;

		menu = g_menu_new();
		add_menu_item = g_menu_item_new(_("_Add…"), "app.open(true)");
		loop_menu_item = g_menu_item_new(_("Loop"), "app.loop");

		g_menu_append_item(menu, add_menu_item);
		g_menu_append_item(menu, loop_menu_item);
		g_menu_freeze(menu);

		ctx_menu = gtk_menu_new_from_model(G_MENU_MODEL(menu));

		gtk_menu_attach_to_widget(GTK_MENU(ctx_menu), widget, NULL);
		gtk_widget_show_all(ctx_menu);

		gtk_menu_popup(	GTK_MENU(ctx_menu), NULL, NULL, NULL, NULL,
				btn_event->button, btn_event->time );
	}

	return handled;
}
示例#16
0
void
glade_popup_simple_pop (GladeProject *project, GdkEventButton *event)
{
  GtkWidget *popup_menu;
  gint button;
  gint event_time;

  popup_menu = glade_popup_create_menu (NULL, NULL, project, FALSE);
  if (!popup_menu)
    return;

  if (event)
    {
      button = event->button;
      event_time = event->time;
    }
  else
    {
      button = 0;
      event_time = gtk_get_current_event_time ();
    }
  gtk_menu_popup (GTK_MENU (popup_menu), NULL, NULL,
                  NULL, NULL, button, event_time);
}
示例#17
0
文件: gui.c 项目: abrobston/gtkglk
/* Stolen from GTK documentation */
static gboolean my_popup_handler(GtkWidget *widget, GdkEvent *event)
{
    GtkMenu *menu;
    GdkEventButton *event_button;

    g_return_val_if_fail(widget != NULL, FALSE);
    g_return_val_if_fail(GTK_IS_MENU (widget), FALSE);
    g_return_val_if_fail(event != NULL, FALSE);

    /* The "widget" is the menu that was supplied when
     * g_signal_connect_swapped() was called.
     */
    menu = GTK_MENU (widget);

    if(event->type == GDK_BUTTON_PRESS) {
	event_button = (GdkEventButton *) event;
	if(event_button->button == 3) {
	    gtk_menu_popup (menu, NULL, NULL, NULL, NULL,
			    event_button->button, event_button->time);
	    return TRUE;
	}
    }
    return FALSE;
}
示例#18
0
static gboolean 
edit_dialog_popup_handler (GtkWidget *w, GdkEventButton *event, 
			   dialog_t *d)
{
    if (right_click(event)) {
	if (d->popup != NULL) {
	    gtk_widget_destroy(d->popup);
	    d->popup = NULL;
	}

	d->popup = build_edit_popup(d);

	if (d->popup != NULL) {
	    gtk_menu_popup(GTK_MENU(d->popup), NULL, NULL, NULL, NULL,
			   event->button, event->time);
	    g_signal_connect(G_OBJECT(d->popup), "destroy",
			     G_CALLBACK(gtk_widget_destroyed), 
			     &d->popup);
	}
	return TRUE;
    }

    return FALSE;
}
示例#19
0
/**
 * gnumeric_popup_menu :
 * @menu : #GtkMenu
 * @event : #GdkEventButton optionally NULL
 *
 * Bring up a popup and if @event is non-NULL ensure that the popup is on the
 * right screen.
 **/
void
gnumeric_popup_menu (GtkMenu *menu, GdkEventButton *event)
{
    g_return_if_fail (menu != NULL);
    g_return_if_fail (GTK_IS_MENU (menu));

    g_object_ref_sink (menu);

    if (event)
        gtk_menu_set_screen (menu,
                             gdk_drawable_get_screen (event->window));

    g_signal_connect (G_OBJECT (menu),
                      "hide",
                      G_CALLBACK (kill_popup_menu), menu);

    /* Do NOT pass the button used to create the menu.
     * instead pass 0.  Otherwise bringing up a menu with
     * the right button will disable clicking on the menu with the left.
     */
    gtk_menu_popup (menu, NULL, NULL, NULL, NULL, 0,
                    (event != NULL) ? event->time
                    : gtk_get_current_event_time());
}
示例#20
0
static gboolean on_button_release(G_GNUC_UNUSED GtkWidget * widget, GdkEventButton * event,
		G_GNUC_UNUSED gpointer user_data)
{
	if (event->button == 3)
	{
		GtkTreeSelection *treesel;
		GtkTreeModel *model;
		GtkTreeIter iter;

		treesel = gtk_tree_view_get_selection(GTK_TREE_VIEW(s_file_view));

		if (!gtk_tree_selection_get_selected(treesel, &model, &iter))
			return FALSE;

		gtk_widget_set_sensitive(s_popup_menu.expand, gtk_tree_model_iter_has_child(model, &iter));
		gtk_widget_set_sensitive(s_popup_menu.remove_external_dir, topmost_selected(model, &iter, FALSE));

		gtk_menu_popup(GTK_MENU(s_popup_menu.widget), NULL, NULL, NULL, NULL,
						event->button, event->time);
		return TRUE;
	}

	return FALSE;
}
示例#21
0
static void create_menu1(void)
{
	GtkWidget *menu;
	GtkWidget *item;
	GtkAccelGroup *accel_group;

	accel_group = gtk_accel_group_new();

	menu = gtk_menu_new();
	item =
#ifdef HAVE_GTK_310
	    gtk_menu_item_new_with_mnemonic("_Copy");
#else
	    gtk_image_menu_item_new_from_stock("gtk-copy", accel_group);
#endif
	gtk_widget_show(item);
	g_signal_connect(G_OBJECT(item), "clicked",
			 G_CALLBACK(on_copy_activate), NULL);
	gtk_container_add(GTK_CONTAINER(menu), item);

	gtk_menu_set_accel_group(GTK_MENU(menu), accel_group);
	gtk_menu_popup((GtkMenu *)menu, NULL, NULL, NULL, NULL, 2,
		       gtk_get_current_event_time());
}
static void
do_popup_menu (GtkWidget *table, GtkWidget *popup, GdkEventButton *event)
{
	gint button, event_time;
	GtkTreeSelection *selection;
	GtkTreeModel *model;
	GtkTreeIter iter;
	GtkUIManager *ui_manager;
	GtkAction *action;
	gboolean active;

	selection = gtk_tree_view_get_selection (GTK_TREE_VIEW (table));

	if (gtk_tree_selection_get_selected (selection, &model, &iter)) {
		gtk_tree_model_get (model, &iter,
				    COL_ACTIVE, &active,
				    -1);

		gtk_menu_popup (GTK_MENU (popup),
				NULL, NULL, NULL, NULL,
				(event) ? event->button : 0,
				(event) ? event->time : gtk_get_current_event_time ());
	}
}
示例#23
0
static gboolean on_button_release(GtkWidget *widget,
				  GdkEventButton *event, EDITOR *editor)
{
	GtkTreeSelection *selection;
	GtkTreeIter selected;
	GtkTreeModel *model;
	GtkTreePath *path;
	gint depth = 0;

	switch (event->button) {
	case 1:
		_button_one(editor);
		break;

	case 2:

		break;

	case 3:
		selection =
		    gtk_tree_view_get_selection(GTK_TREE_VIEW(widget));
		gtk_tree_selection_get_selected(selection, &model,
						&selected);
		path = gtk_tree_model_get_path(model, &selected);
		depth = gtk_tree_path_get_depth(path);

		if (depth > 1)
			gtk_menu_popup(GTK_MENU(menu),
				       NULL, NULL, NULL, NULL,
				       0, gtk_get_current_event_time());

		gtk_tree_path_free(path);
		return FALSE;
	}
	return FALSE;
}
示例#24
0
/* Button events on iconlist */
void on_game_mgr_iconlist_select_icon (GnomeIconList *iconlist,
				       gint icon_idx,
				       GdkEventButton *event,
				       gpointer user_data)
{
  /* If user press the arrow keys, do nothing. */
  if (event == NULL) 
    return;
  
  /* Displays a pop-up menu */
  if((event->type == GDK_BUTTON_PRESS) && (event->button == 3)) {
    GtkWidget *popup = NULL;
    
    popup = lookup_widget("game_mgr_popup_menu");
    gtk_menu_popup (GTK_MENU(popup), NULL, NULL, NULL, NULL, 1, 
		    gtk_get_current_event_time());
  }
  /* Double-click enters the game */
  else if((event->type == GDK_2BUTTON_PRESS) && (event->button == 1)) {
    game_mgr_play_game((GwpGameState *)
		       gnome_icon_list_get_icon_data(iconlist, 
						     icon_idx));
  }
}
static gboolean select_verse_button_press_callback(GtkWidget *widget,
						   GdkEventButton *event,
						   EDITOR *editor)
{
	GtkWidget *menu;

	menu =
	    main_versekey_drop_down_verse_menu(editor->navbar, NB_EDITOR,
					       NULL, editor);
	if (!menu)
		return 0;
	g_signal_connect(menu, "deactivate",
			 G_CALLBACK(menu_deactivate_callback), widget);
	if ((event->type == GDK_BUTTON_PRESS) && event->button == 1) {
		gtk_widget_grab_focus(widget);
		gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(widget),
					     TRUE);
		gtk_menu_popup(GTK_MENU(menu), NULL, NULL,
			       menu_position_under, widget, event->button,
			       event->time);
		return TRUE;
	}
	return FALSE;
}
gboolean
matecomponent_control_do_popup_path (MateComponentControl       *control,
			      GtkWidget           *parent_menu_shell,
			      GtkWidget           *parent_menu_item,
			      GtkMenuPositionFunc  func,
			      gpointer             data,
			      guint                button,
			      const char          *popup_path,
			      guint32              activate_time)
{
	GtkWidget *menu;

	g_return_val_if_fail (MATECOMPONENT_IS_CONTROL (control), FALSE);

	if (!control->priv->popup_ui_container)
		return FALSE;

	menu = gtk_menu_new ();

	matecomponent_ui_sync_menu_add_popup (
		MATECOMPONENT_UI_SYNC_MENU (control->priv->popup_ui_sync),
		GTK_MENU (menu), popup_path);

	gtk_menu_set_screen (
		GTK_MENU (menu),
		gtk_window_get_screen (GTK_WINDOW (control->priv->plug)));

	gtk_widget_show (menu);

	gtk_menu_popup (GTK_MENU (menu),
			parent_menu_shell, parent_menu_item,
			func, data,
			button, activate_time);

	return TRUE;
}
示例#27
0
static void layers_popup ( VikLayersPanel *vlp, GtkTreeIter *iter, gint mouse_button )
{
  GtkMenu *menu = NULL;


  if ( iter )
  {
    if ( vik_treeview_item_get_type ( vlp->vt, iter ) == VIK_TREEVIEW_TYPE_LAYER )
    {
      VikLayer *layer = VIK_LAYER(vik_treeview_item_get_pointer ( vlp->vt, iter ));

      if ( layer->type == VIK_LAYER_AGGREGATE )
        menu = GTK_MENU(gtk_item_factory_get_widget ( vlp->popup_factory, "<main>" ));
      else
      {
        GtkWidget *del, *prop;
	VikStdLayerMenuItem menu_selection = vik_layer_get_menu_items_selection(layer);

        menu = GTK_MENU ( gtk_menu_new () );

	if (menu_selection & VIK_MENU_ITEM_PROPERTY) {
	  prop = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PROPERTIES, NULL );
	  g_signal_connect_swapped ( G_OBJECT(prop), "activate", G_CALLBACK(vik_layers_panel_properties), vlp );
	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), prop);
	  gtk_widget_show ( prop );
	}

	if (menu_selection & VIK_MENU_ITEM_CUT) {
	  del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_CUT, NULL );
	  g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_cut_selected), vlp );
	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), del);
	  gtk_widget_show ( del );
	}

	if (menu_selection & VIK_MENU_ITEM_COPY) {
	  del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_COPY, NULL );
	  g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_copy_selected), vlp );
	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), del);
	  gtk_widget_show ( del );
	}

	if (menu_selection & VIK_MENU_ITEM_PASTE) {
	  del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_PASTE, NULL );
	  g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_paste_selected), vlp );
	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), del);
	  gtk_widget_show ( del );
	}

	if (menu_selection & VIK_MENU_ITEM_DELETE) {
	  del = gtk_image_menu_item_new_from_stock ( GTK_STOCK_DELETE, NULL );
	  g_signal_connect_swapped ( G_OBJECT(del), "activate", G_CALLBACK(vik_layers_panel_delete_selected), vlp );
	  gtk_menu_shell_append (GTK_MENU_SHELL (menu), del);
	  gtk_widget_show ( del );
	}

        vik_layer_add_menu_items ( layer, menu, vlp );
      } 
    }
    else
    {
      menu = GTK_MENU ( gtk_menu_new () );
      if ( ! vik_layer_sublayer_add_menu_items ( vik_treeview_item_get_parent ( vlp->vt, iter ), menu, vlp, vik_treeview_item_get_data ( vlp->vt, iter ), vik_treeview_item_get_pointer ( vlp->vt, iter ), iter, vlp->vvp ) )
      {
        gtk_widget_destroy ( GTK_WIDGET(menu) );
        return;
      }
      /* TODO: specific things for different types */
    }
  }
  else
    menu = GTK_MENU(gtk_item_factory_get_widget ( vlp->popup_factory, base_entries[NUM_BASE_ENTRIES-1].path ));
  gtk_menu_popup ( menu, NULL, NULL, NULL, NULL, mouse_button, gtk_get_current_event_time() );
}
示例#28
0
static void cb_popup_state(GtkStatusIcon *status_icon, guint button, guint activate_time, gpointer user_data)
{
  switch (button) {

    case 1:
#if UNIX
      toggle_im_enabled();
      break;
    case 2:
#endif
      kbm_toggle();
      break;
    case 3:
    {
      char bak[512], cur[512];
      get_gcin_conf_fstr(PHONETIC_KEYBOARD, cur, "");
      get_gcin_conf_fstr(PHONETIC_KEYBOARD_BAK, bak, "");
      if (bak[0] && strcmp(bak, cur)) {
        char kbm[512];

        strcpy(kbm, bak);
        char *p=strchr(kbm, ' ');

        if (p) {
          *(p++)=0;
          int i;
          for(i=0;kbm_sel[i].name;i++)
            if (!strcmp(kbm_sel[i].kbm, kbm)) {
              break;
            }

          if (kbm_sel[i].kbm) {
            unich_t tt[128];
            if (mitems_state[0].name)
              free(mitems_state[0].name);
#if UNIX
            sprintf(tt, "注音換 %s %s", kbm_sel[i].name, p);
            mitems_state[0].name = strdup(tt);
#else
            swprintf(tt, L"注音換 %s %S", kbm_sel[i].name, p);
            mitems_state[0].name = wcsdup(tt);
#endif
          }
        }

//        dbg("hhhhhhhhhhhh %x\n", tray_menu_state);
        if (tray_menu_state) {
          gtk_widget_destroy(tray_menu_state);
          tray_menu_state = NULL;
        }
      }

      if (!tray_menu_state)
        tray_menu_state = create_tray_menu(mitems_state);

      gtk_menu_popup(GTK_MENU(tray_menu_state), NULL, NULL, NULL, NULL, button, activate_time);
      break;
    }
  }

//  dbg("zzzzzzzzzzzzz\n");
}
示例#29
0
void ptt_menu_show(GtkWidget *button) {
  ptt_menu_clear();
  ptt_menu_update();
  gtk_menu_popup (GTK_MENU (menu), NULL, NULL, NULL, NULL, 0, 0);
}
static gboolean _on_click_item (GtkWidget *pWidget, GdkEventButton* pButton, CDQuickBrowserItem *pItem)
{
	g_return_val_if_fail (pItem != NULL, FALSE);
	GldiModuleInstance *myApplet = pItem->pApplet;
	CD_APPLET_ENTER;

	if (pButton->button == 3) // right click
	{
		gchar *cUri = g_filename_to_uri (pItem->cPath, NULL, NULL);
		g_return_val_if_fail (cUri != NULL, FALSE);

		GtkWidget *pMenu = gldi_menu_new (NULL);
		
		GList *pApps = cairo_dock_fm_list_apps_for_file (cUri);
		if (pApps != NULL)
		{
			GtkWidget *pSubMenu = CD_APPLET_ADD_SUB_MENU_WITH_IMAGE (D_("Open with"), pMenu, GLDI_ICON_NAME_OPEN);

			cd_quick_browser_free_apps_list (myApplet);

			GList *a;
			gchar **pAppInfo;
			gchar *cIconPath;
			for (a = pApps; a != NULL; a = a->next)
			{
				pAppInfo = a->data;

				if (pAppInfo[2] != NULL)
					cIconPath = cairo_dock_search_icon_s_path (pAppInfo[2], cairo_dock_search_icon_size (GTK_ICON_SIZE_MENU));
				else
					cIconPath = NULL;

				gpointer *data = g_new (gpointer, 2);
				data[0] = pItem;
				data[1] = pAppInfo[1];
				myData.pAppList = g_list_prepend (myData.pAppList, data); // to save the exec command

				CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (pAppInfo[0], cIconPath, _cd_launch_with, pSubMenu, data);

				g_free (cIconPath);
				g_free (pAppInfo[0]);
				g_free (pAppInfo[2]);
				g_free (pAppInfo);
			}
			g_list_free (pApps);
		}
		CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Open parent folder"), GLDI_ICON_NAME_DIRECTORY, _cd_open_parent, pMenu, pItem);
		
		CD_APPLET_ADD_IN_MENU_WITH_STOCK_AND_DATA (D_("Copy the location"), GLDI_ICON_NAME_COPY, _cd_copy_location, pMenu, pItem);
		
		gtk_widget_show_all (pMenu);
		gtk_menu_popup (GTK_MENU (pMenu),
			NULL,
			NULL,
			NULL,  // popup on mouse.
			NULL,
			1,
			gtk_get_current_event_time ());
		g_free (cUri);
		CD_APPLET_LEAVE (TRUE); // do not remove quick_browser menu now
	}

	CD_APPLET_LEAVE (FALSE);
}