Exemple #1
0
static GtkWidget *
menu_item_new (MenuItem *menuitem, int workspace_id)
{
  unsigned int key;
  MetaVirtualModifier mods;
  const char *i18n_label;
  GtkWidget *mi;
  GtkWidget *accel_label;

  if (menuitem->type == MENU_ITEM_NORMAL)
    {
      mi = gtk_menu_item_new ();
    }
  else if (menuitem->type == MENU_ITEM_IMAGE)
    {
      GtkWidget *image;
      
      image = gtk_image_new_from_stock (menuitem->stock_id, GTK_ICON_SIZE_MENU);
      mi = gtk_image_menu_item_new ();
     
      gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (mi), image);
      gtk_widget_show (image);
    }
  else if (menuitem->type == MENU_ITEM_CHECKBOX)
    {
      mi = gtk_check_menu_item_new ();
      
      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
                                      menuitem->checked);
    }    
  else if (menuitem->type == MENU_ITEM_RADIOBUTTON)
    {
      mi = gtk_check_menu_item_new ();

      gtk_check_menu_item_set_draw_as_radio (GTK_CHECK_MENU_ITEM (mi),
                                             TRUE);
      gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (mi),
                                      menuitem->checked);
    }
  else if (menuitem->type == MENU_ITEM_WORKSPACE_LIST)
    return NULL;
  else
    return gtk_separator_menu_item_new ();

  i18n_label = _(menuitem->label);
  meta_core_get_menu_accelerator (menuitem->op, workspace_id, &key, &mods);

  accel_label = meta_accel_label_new_with_mnemonic (i18n_label);
  gtk_misc_set_alignment (GTK_MISC (accel_label), 0.0, 0.5);

  gtk_container_add (GTK_CONTAINER (mi), accel_label);
  gtk_widget_show (accel_label);

  meta_accel_label_set_accelerator (META_ACCEL_LABEL (accel_label),
                                    key, mods);
  
  return mi;
}
Exemple #2
0
/* colorlabel_create_color_menu() - creates a color menu without 
 * checkitems, probably for use in combo items */
GtkWidget *colorlabel_create_color_menu(void)
{
	GtkWidget *label; 
	GtkWidget *item;
	GtkWidget *menu;
	gint i;

	colorlabel_recreate_all();

	/* create the menu items. each item has its color code attached */
	menu = gtk_menu_new();
	g_object_set_data(G_OBJECT(menu), "label_color_menu", menu);

	item = gtk_menu_item_new_with_label(_("None"));
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	g_object_set_data(G_OBJECT(item), "color", GUINT_TO_POINTER(0));
	gtk_widget_show(item);

	item = gtk_separator_menu_item_new();
	gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
	gtk_widget_show(item);

	/* and the color items */
	for (i = 0; i < LABEL_COLORS_ELEMS; i++) {
		GtkWidget *hbox; 
		GtkWidget *vbox;
		GtkWidget *widget;

		item  = gtk_menu_item_new();
		g_object_set_data(G_OBJECT(item), "color",
				  GUINT_TO_POINTER(i + 1));

		label = gtk_label_new(label_colors[0][i].label);
		
		gtk_widget_show(label);
		hbox = gtk_hbox_new(FALSE, 0);
		gtk_widget_show(hbox);
		gtk_container_add(GTK_CONTAINER(item), hbox);

		vbox = gtk_vbox_new(TRUE, 0);
		gtk_widget_show(vbox);
		gtk_container_set_border_width(GTK_CONTAINER(vbox), 1);

		widget = colorlabel_create_color_widget(label_colors[0][i].color);
		gtk_widget_show(widget);
		gtk_box_pack_start(GTK_BOX(vbox), widget, FALSE, FALSE, 0);

		gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
		gtk_box_pack_start(GTK_BOX(hbox), label, FALSE, FALSE, 4);
		
		gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
		gtk_widget_show(item);
	}
	
	gtk_widget_show(menu);

	return menu;
}
Exemple #3
0
GtkWidget* new_menu_sep (GtkWidget *parent)
{
	GtkWidget *mni_sep = gtk_menu_item_new ();
	gtk_widget_show (mni_sep);
	gtk_container_add (GTK_CONTAINER (parent), mni_sep);
	gtk_widget_set_name (mni_sep, "-x-");
	gtk_widget_set_sensitive (mni_sep, FALSE);
	return mni_sep;
}
GtkWidget *
glade_gtk_widget_action_submenu (GladeWidgetAdaptor * adaptor,
                                 GObject * object, const gchar * action_path)
{
  GladeWidget *gwidget = glade_widget_get_from_gobject (object);
  GList *groups, *list;

  if (strcmp (action_path, "sizegroup_add") == 0)
    {
      GtkWidget *menu = gtk_menu_new ();
      GtkWidget *separator, *item;
      GladeWidget *group;
      const gchar *size_group_name;

      if ((groups = list_sizegroups (gwidget)) != NULL)
        {
          for (list = groups; list; list = list->next)
            {
              group = list->data;

	      size_group_name = glade_widget_get_name (group);
	      if (g_str_has_prefix (size_group_name, GLADE_UNNAMED_PREFIX))
		size_group_name = _("(unnamed)");

	      item = gtk_menu_item_new_with_label (size_group_name);

              g_object_set_data (G_OBJECT (item), "glade-group-widget", group);
              g_signal_connect (G_OBJECT (item), "activate",
                                G_CALLBACK (glade_gtk_widget_add2group_cb),
                                gwidget);

              gtk_widget_show (item);
              gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
            }
          g_list_free (groups);

          separator = gtk_menu_item_new ();
          gtk_menu_shell_append (GTK_MENU_SHELL (menu), separator);
          gtk_widget_show (separator);
        }

      /* Add trailing new... item */
      item = gtk_menu_item_new_with_label (_("New Size Group"));
      g_signal_connect (G_OBJECT (item), "activate",
                        G_CALLBACK (glade_gtk_widget_add2group_cb), gwidget);

      gtk_widget_show (item);
      gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);

      return menu;
    }
  else if (GWA_GET_CLASS (G_TYPE_OBJECT)->action_submenu)
    return GWA_GET_CLASS (G_TYPE_OBJECT)->action_submenu (adaptor,
                                                          object, action_path);

  return NULL;
}
static void
do_popup_menu (G_GNUC_UNUSED GtkWidget *widget, GdkEventButton *event, QueryFavoriteSelector *tsel)
{
	int button, event_time;

	if (! tsel->priv->popup_menu) {
		GtkWidget *menu, *mitem;
		
		menu = gtk_menu_new ();
		g_signal_connect (menu, "deactivate", 
				  G_CALLBACK (gtk_widget_hide), NULL);

		GtkWidget *img;
		img = gtk_image_new_from_icon_name ("document-properties", GTK_ICON_SIZE_MENU);
		mitem = gtk_menu_item_new ();
		gtk_container_add (GTK_CONTAINER (mitem), img);
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), mitem);
		gtk_widget_show (mitem);
		g_signal_connect (mitem, "activate",
				  G_CALLBACK (properties_activated_cb), tsel);

		img = gtk_image_new_from_icon_name ("edit-delete", GTK_ICON_SIZE_MENU);
		mitem = gtk_menu_item_new ();
		gtk_container_add (GTK_CONTAINER (mitem), img);
		gtk_menu_shell_append (GTK_MENU_SHELL (menu), mitem);
		gtk_widget_show (mitem);
		g_signal_connect (mitem, "activate",
				  G_CALLBACK (delete_activated_cb), tsel);

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

	gtk_menu_popup (GTK_MENU (tsel->priv->popup_menu), NULL, NULL, NULL, NULL, 
			button, event_time);
}
Exemple #6
0
static GtkWidget *
menu_quick_item (char *cmd, char *label, GtkWidget * menu, int flags,
					  gpointer userdata, char *icon)
{
	GtkWidget *img, *item;

	if (!label)
		item = gtk_menu_item_new ();
	else
	{
		if (icon)
		{
			/*if (flags & XCMENU_MARKUP)
				item = gtk_image_menu_item_new_with_markup (label);
			else*/
				item = gtk_image_menu_item_new_with_mnemonic (label);
			img = gtk_image_new_from_file (icon);
			if (img)
				gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
			else
			{
				img = gtk_image_new_from_stock (icon, GTK_ICON_SIZE_MENU);
				if (img)
					gtk_image_menu_item_set_image ((GtkImageMenuItem *)item, img);
			}
		}
		else
		{
			if (flags & XCMENU_MARKUP)
			{
				item = gtk_menu_item_new_with_label ("");
				if (flags & XCMENU_MNEMONIC)
					gtk_label_set_markup_with_mnemonic (GTK_LABEL (GTK_BIN (item)->child), label);
				else
					gtk_label_set_markup (GTK_LABEL (GTK_BIN (item)->child), label);
			} else
			{
				if (flags & XCMENU_MNEMONIC)
					item = gtk_menu_item_new_with_mnemonic (label);
				else
					item = gtk_menu_item_new_with_label (label);
			}
		}
	}
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	g_object_set_data (G_OBJECT (item), "u", userdata);
	if (cmd)
		g_signal_connect (G_OBJECT (item), "activate",
								G_CALLBACK (popup_menu_cb), cmd);
	if (flags & XCMENU_SHADED)
		gtk_widget_set_sensitive (GTK_WIDGET (item), FALSE);
	gtk_widget_show_all (item);

	return item;
}
Exemple #7
0
void
plugin_init(G_GNUC_UNUSED GeanyData * data)
{
	gchar *kb_label1;
	gchar *kb_label2;

	main_locale_init(LOCALEDIR, GETTEXT_PACKAGE);
	kb_label1 = _("Document current word");
	kb_label2 = _("Document interactive");

	config_init();

	keyb1 = gtk_menu_item_new();
	keyb2 = gtk_menu_item_new();

	keybindings_set_item(plugin_key_group, KB_DOCUMENT_WORD, kb_doc,
				0, 0, kb_label1, kb_label1, keyb1);
	keybindings_set_item(plugin_key_group, KB_DOCUMENT_WORD_ASK, kb_doc_ask,
				0, 0, kb_label2, kb_label2, keyb2);
}
bool GtkToolkitUiSettings::Init(GtkWidget* layout)
{
	m_layout = layout;

	m_menu_item = gtk_menu_item_new();
	gtk_container_add(GTK_CONTAINER(m_layout), m_menu_item);
	
	m_settings = gtk_settings_get_default();

	return m_settings;
}
Exemple #9
0
static GtkWidget* MenuItemWidget()
{
    static GtkWidget* s_widget;
    if (s_widget == NULL)
    {
        s_widget = gtk_menu_item_new();
        gtk_container_add(ContainerWidget(), s_widget);
        gtk_widget_ensure_style(s_widget);
    }
    return s_widget;
}
Exemple #10
0
/*
 * Creates a new GtkWidget of class GtkMenuItem, performing any specialized
 * initialization needed for the widget to work correctly in this environment.
 * If a dialog box is used to initialize the widget, return NULL from this
 * function, and call data->callback with your new widget when it is done.
 * If the widget needs a special destroy handler, add a signal here.
 */
GtkWidget *
gb_menu_item_new (GbWidgetNewData * data)
{
  GtkWidget *new_widget;

  if (data->action == GB_CREATING)
    new_widget = gtk_menu_item_new_with_label (data->name);
  else
    new_widget = gtk_menu_item_new ();
  return new_widget;
}
Exemple #11
0
GtkWidget * AddSeparator( GtkWidget * Menu )
{
    GtkWidget * Item = NULL;

    Item=gtk_menu_item_new ();
    gtk_widget_show( Item );
    gtk_container_add( GTK_CONTAINER( Menu ),Item );
    gtk_widget_set_sensitive( Item,FALSE );

    return Item;
}
static GtkWidget* create_simple_calendar_item(GtkWidget** calendar_out)
{
    GtkWidget* menu_item = gtk_menu_item_new();
    GtkWidget* calendar = *calendar_out = gtk_calendar_new();
    gtk_calendar_set_display_options(GTK_CALENDAR(calendar),
                                     GTK_CALENDAR_SHOW_HEADING | GTK_CALENDAR_NO_MONTH_CHANGE |
                                     GTK_CALENDAR_SHOW_DAY_NAMES | GTK_CALENDAR_SHOW_DETAILS);
    gtk_widget_set_sensitive(menu_item, FALSE);
    gtk_container_add(GTK_CONTAINER(menu_item), calendar);
    return menu_item;
}
Exemple #13
0
GtkWidget *
add_menu_separator (GtkWidget * menu)
{
  GtkWidget *menu_item;
  menu_item = gtk_menu_item_new ();
  gtk_menu_append (GTK_MENU (menu), menu_item);
  gtk_widget_show (menu_item);
  gtk_widget_set_sensitive (GTK_WIDGET (menu_item), FALSE);

  return menu_item;
}
Exemple #14
0
GtkWidget *
gul_gui_append_separator (GtkWidget *menu)
{
	GtkWidget *menu_item;
	
	menu_item = gtk_menu_item_new ();
	gtk_widget_show (menu_item);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu),
			       menu_item);

	return menu_item;
}
Exemple #15
0
void
plugin_init(G_GNUC_UNUSED GeanyData * data)
{
	GeanyKeyGroup *key_group;
	gchar *kb_label1;
	gchar *kb_label2;

	kb_label1 = _("Document current word");
	kb_label2 = _("Document interactive");

	config_init();

	keyb1 = gtk_menu_item_new();
	keyb2 = gtk_menu_item_new();

	key_group = plugin_set_key_group(geany_plugin, "doc_chars", KB_COUNT, NULL);
	keybindings_set_item(key_group, KB_DOCUMENT_WORD, kb_doc,
				0, 0, kb_label1, kb_label1, keyb1);
	keybindings_set_item(key_group, KB_DOCUMENT_WORD_ASK, kb_doc_ask,
				0, 0, kb_label2, kb_label2, keyb2);
}
Exemple #16
0
static void
send_receive_add_to_menu (SendReceiveData *data,
                          CamelService *service,
                          gint position)
{
	GtkWidget *menu_item;
	CamelProvider *provider;

	if (send_receive_find_menu_item (data, service) != NULL)
		return;

	provider = camel_service_get_provider (service);

	menu_item = gtk_menu_item_new ();
	gtk_widget_show (menu_item);

	e_binding_bind_property (
		service, "display-name",
		menu_item, "label",
		G_BINDING_SYNC_CREATE);

	if (provider && (provider->flags & CAMEL_PROVIDER_IS_REMOTE) != 0) {
		gpointer object;

		if (CAMEL_IS_OFFLINE_STORE (service))
			object = g_object_ref (service);
		else
			object = camel_service_ref_session (service);

		e_signal_connect_notify_object (
			object, "notify::online",
			G_CALLBACK (service_online_state_changed_cb), menu_item,
			0);

		g_object_unref (object);
	}

	g_hash_table_insert (
		data->menu_items, menu_item,
		g_object_ref (service));

	g_signal_connect (
		menu_item, "activate",
		G_CALLBACK (send_receive_account_item_activate_cb), data);

	/* Position is with respect to the sorted list of CamelService-s,
	 * not menu item position. */
	if (position < 0)
		gtk_menu_shell_append (data->menu, menu_item);
	else
		gtk_menu_shell_insert (data->menu, menu_item, position + 4);
}
GtkWidget *
empathy_presence_chooser_create_menu (void)
{
	const gchar *status;
	GtkWidget   *menu;
	GtkWidget   *item;
	GtkWidget   *image;
	guint        i;

	menu = gtk_menu_new ();

	for (i = 0; i < G_N_ELEMENTS (states); i += 2) {
		GList       *list, *l;

		status = empathy_presence_get_default_message (states[i]);
		presence_chooser_menu_add_item (menu,
						status,
						states[i]);

		if (states[i+1]) {
			/* Set custom messages if wanted */
			list = empathy_status_presets_get (states[i], 5);
			for (l = list; l; l = l->next) {
				presence_chooser_menu_add_item (menu,
								l->data,
								states[i]);
			}
			g_list_free (list);
		}

	}

	/* Separator. */
	item = gtk_menu_item_new ();
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	gtk_widget_show (item);

	/* Custom messages */
	item = gtk_image_menu_item_new_with_label (_("Custom messages..."));
	image = gtk_image_new_from_stock (GTK_STOCK_EDIT, GTK_ICON_SIZE_MENU);
	gtk_image_menu_item_set_image (GTK_IMAGE_MENU_ITEM (item), image);
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	gtk_widget_show (image);
	gtk_widget_show (item);

	g_signal_connect (item,
			  "activate",
			  G_CALLBACK (presence_chooser_custom_activate_cb),
			  NULL);

	return menu;
}
Exemple #18
0
static GtkMenu *make_menu(GList *l, GtkText *gtktext) {
	GtkWidget *menu, *item;
	char *caption;
	menu = gtk_menu_new(); {
		caption = g_strdup_printf("Not in dictionary: %s", (char*)l->data);
		item = gtk_menu_item_new_with_label(caption);
		/* I'd like to make it so this item is never selectable, like
		 * the menu titles in the GNOME panel... unfortunately, the GNOME
		 * panel creates their own custom widget to do this! */
		gtk_widget_show(item);
		gtk_menu_append(GTK_MENU(menu), item);

		item = gtk_menu_item_new();
		gtk_widget_show(item);
		gtk_menu_append(GTK_MENU(menu), item);

		l = l->next;
		if (l == NULL) {
			item = gtk_menu_item_new_with_label("(no suggestions)");
			gtk_widget_show(item);
			gtk_menu_append(GTK_MENU(menu), item);
		} else {
			GtkWidget *curmenu = menu;
			int count = 0;
			do {
				if (l->data == NULL && l->next != NULL) {
					count = 0;
					curmenu = gtk_menu_new();
					item = gtk_menu_item_new_with_label("Other Possibilities...");
					gtk_widget_show(item);
					gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
					gtk_menu_append(GTK_MENU(curmenu), item);
					l = l->next;
				} else if (count > MENUCOUNT) {
					count -= MENUCOUNT;
					item = gtk_menu_item_new_with_label("More...");
					gtk_widget_show(item);
					gtk_menu_append(GTK_MENU(curmenu), item);
					curmenu = gtk_menu_new();
					gtk_menu_item_set_submenu(GTK_MENU_ITEM(item), curmenu);
				}
				item = gtk_menu_item_new_with_label((char*)l->data);
				gtk_signal_connect(GTK_OBJECT(item), "activate",
						GTK_SIGNAL_FUNC(replace_word), gtktext);
				gtk_widget_show(item);
				gtk_menu_append(GTK_MENU(curmenu), item);
				count++;
			} while ((l = l->next) != NULL);
		}
	}
	return GTK_MENU(menu);
}
void EvalCcRqINSERTSEPARATOR (CrossCallInfo *pcci)		/* hmenu, pos no result. */
{
    GtkWidget *menu, *menu_item;
    printf("EvalCcRqINSERTSEPARATOR\n");

    menu = GTK_WIDGET(pcci->p1);
    menu_item = gtk_menu_item_new();

    gtk_menu_insert(GTK_MENU(menu), menu_item, (gint) pcci->p2);
    gtk_widget_show_all(menu_item);

    MakeReturn1Cci (pcci, (int64_t) menu_item);
}
void ToolDrawCombocontrol::createMenuItem(string name, string icon, ActionType type)
{
	XOJ_CHECK_TYPE(ToolDrawCombocontrol);

	GtkWidget* menuItem =  gtk_menu_item_new ();
	GtkWidget* box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
	gtk_container_add(GTK_CONTAINER(box), gtk_image_new_from_icon_name(icon.c_str(), GTK_ICON_SIZE_SMALL_TOOLBAR));
	gtk_container_add(GTK_CONTAINER(box), gtk_label_new(name.c_str()));
	gtk_container_add(GTK_CONTAINER(menuItem), box);

	gtk_container_add(GTK_CONTAINER(popupMenu), menuItem);
	toolMenuHandler->registerMenupoint(menuItem, type, GROUP_RULER);
	gtk_widget_show_all(menuItem);
}
Exemple #21
0
static void
tray_make_item (GtkWidget *menu, char *label, void *callback, void *userdata)
{
	GtkWidget *item;

	if (label)
		item = gtk_menu_item_new_with_mnemonic (label);
	else
		item = gtk_menu_item_new ();
	gtk_menu_shell_append (GTK_MENU_SHELL (menu), item);
	g_signal_connect (G_OBJECT (item), "activate",
							G_CALLBACK (callback), userdata);
	gtk_widget_show (item);
}
Exemple #22
0
GtkWidget *create_server_type_menu (int active_type,
		gboolean (*filterfunc)(enum server_type),
		GtkSignalFunc callback) {
	GtkWidget *option_menu = NULL;
	GtkWidget *menu = NULL;
	GtkWidget *menu_item = NULL;
	GtkWidget *first_menu_item = NULL;
	int i;
	int j = 0;
	int menu_type = 0;

	option_menu = gtk_option_menu_new ();

	menu = gtk_menu_new ();

	for (i = 0; i < GAMES_TOTAL; ++i) {
		if (filterfunc && !filterfunc (i))
			continue;

		menu_item = gtk_menu_item_new ();

		if (i == active_type) {
			first_menu_item = menu_item;
			menu_type = j;
		}
		else if (!first_menu_item)
			first_menu_item = menu_item;

		gtk_menu_append (GTK_MENU (menu), menu_item);

		gtk_container_add (GTK_CONTAINER (menu_item), game_pixmap_with_label (i));

		if (callback)
			gtk_signal_connect (GTK_OBJECT (menu_item), "activate", GTK_SIGNAL_FUNC (callback), GINT_TO_POINTER (i));

		gtk_widget_show (menu_item);

		++j; // must be here in case the continue was used
	}

	gtk_option_menu_set_menu (GTK_OPTION_MENU (option_menu), menu);

	// initiates callback to set servertype to first configured game
	if (active_type != -1 && first_menu_item) {
		gtk_menu_item_activate (GTK_MENU_ITEM (first_menu_item));
		gtk_option_menu_set_history (GTK_OPTION_MENU (option_menu), menu_type);
	}

	return option_menu;
}
Exemple #23
0
static void
load_command_bar_sub_menu(const xmlNode *menu, form_element_t *parent)
{
    const xmlChar *title = entry_title_ex(menu, false);
    GtkToolItem *submenu = gtk_menu_tool_button_new(NULL, GTK_CHAR(title));

    form_element_t m;
    m.widget = gtk_menu_new();

    const xmlNode *c = find_by_path(menu, "ContainedItems");
    for (c = c->children; c ; c = c->next) {

        if (is_oftype(c, "Button")) {
            const xmlChar *c_title = entry_title_ex(c, false);
            GtkWidget *mel = gtk_menu_item_new_with_label(GTK_CHAR(c_title));

            gtk_menu_shell_append(GTK_MENU_SHELL(m.widget), mel);
        }

        if (is_oftype(c, "Buttons")) {

            form_element_t sm;
            sm.widget = gtk_menu_new();

            const xmlChar *c_title = entry_title_ex(c, false);
            GtkWidget *mel = gtk_menu_item_new_with_label(GTK_CHAR(c_title));

            load_command_bar_sub_menu_buttons(c, &sm);

            gtk_menu_item_set_submenu(GTK_MENU_ITEM(mel), sm.widget);

            gtk_menu_shell_append(GTK_MENU_SHELL(m.widget), mel);
        }

    }

    gtk_menu_tool_button_set_menu(GTK_MENU_TOOL_BUTTON(submenu), m.widget);

    {
        /*! TODO: Выяснить, почему подменю не появляется,
            если его не добавить в видимое меню на форме
         */
        GtkWidget *mel = gtk_menu_item_new();
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(mel), m.widget);
        gtk_menu_shell_append(GTK_MENU_SHELL(global_menu_bar), mel);
    }

    gtk_toolbar_insert(GTK_TOOLBAR(parent->widget), submenu, -1);
}
Exemple #24
0
GtkWidget*sc_image_text_item_new(const guint8*data,const char*text,int siz)
{


    GtkWidget*image;
    GtkWidget*item=gtk_menu_item_new();
    GtkWidget*box=gtk_grid_new();//gtk_box_new(GTK_ORIENTATION_HORIZONTAL,2);


    GtkWidget*label=gtk_label_new(text);
    gtk_label_set_justify(GTK_LABEL(label),GTK_JUSTIFY_RIGHT);

    gtk_widget_set_hexpand(label,TRUE);
    gtk_widget_set_halign(label,GTK_ALIGN_START);

    GdkPixbuf*pxf=gdk_pixbuf_new_from_inline(-1,data,FALSE,NULL);
    GdkPixbuf*real_pxf;


    if(!pxf) {
        image=gtk_image_new_from_icon_name("image-x-generic",GTK_ICON_SIZE_BUTTON);

    } else {
        real_pxf=gdk_pixbuf_scale_simple(pxf,siz,siz,GDK_INTERP_HYPER);
        g_object_unref(pxf);
        image=gtk_image_new_from_pixbuf(real_pxf);
        g_object_set(image,"pixel-size",GTK_IMAGE_PIXBUF,NULL);
    }
    g_object_unref(real_pxf);

//    gtk_widget_set_hexpand(image,FALSE);
//    gtk_widget_set_halign(image,GTK_ALIGN_START);


    gtk_grid_attach(GTK_GRID(box),image,0,0,1,1);
    gtk_grid_attach(GTK_GRID(box),label,1,0,1,1);

    gtk_grid_set_column_spacing(GTK_GRID(box),20);

//    gtk_box_pack_start(GTK_BOX(box),image,TRUE,FALSE,0);
//    gtk_box_pack_end(GTK_BOX(box),label,TRUE,TRUE,0);

    gtk_container_add(GTK_CONTAINER(item),box);
    gtk_container_set_border_width(GTK_CONTAINER(box),0);
    gtk_container_set_border_width(GTK_CONTAINER(item),0);

    return item;

}
Exemple #25
0
static GtkWidget *menu_item_new_with_icon_text(GIcon *icon, const char *text) 
{
    GtkWidget *menuitem = gtk_menu_item_new();
    GtkWidget *box = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 6);
    GtkWidget *image = gtk_image_new_from_gicon(icon, GTK_ICON_SIZE_LARGE_TOOLBAR);
    GtkWidget *label = gtk_label_new(text);

    gtk_image_set_pixel_size(GTK_IMAGE(image), 24);
    gtk_box_pack_start(GTK_BOX(box), image, FALSE, FALSE, 0);
    gtk_box_pack_start(GTK_BOX(box), label, FALSE, FALSE, 0);

    gtk_container_add(GTK_CONTAINER(menuitem), box);

    return menuitem;
}
Exemple #26
0
gboolean gtkui_plugin_context(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
   GtkTreeIter iter;
   GtkTreeModel *model;
   GtkWidget *menu, *item;
   char *plugin = NULL;

   (void) widget;
   (void) data;

   model = GTK_TREE_MODEL(ls_plugins);

   menu = gtk_menu_new();
   item = gtk_menu_item_new();
   gtk_menu_shell_append(GTK_MENU_SHELL(menu), item);
   g_signal_connect(G_OBJECT(item), "activate", G_CALLBACK(gtkui_select_plugin), NULL);
   gtk_widget_show(item);


   if (gtk_tree_selection_get_selected (GTK_TREE_SELECTION(selection), &model, &iter)) {
      gtk_tree_model_get (model, &iter, 1, &plugin, -1);
   } else
      return FALSE; /* nothing is selected */

   if(!plugin)
      return FALSE; /* bad pointer from gtk_tree_model_get, shouldn't happen */

   /* print the message */
   if (plugin_is_activated(plugin) == 0)
      gtk_menu_item_set_label(GTK_MENU_ITEM(item), "Activate");
   else
      gtk_menu_item_set_label(GTK_MENU_ITEM(item), "Deactivate");
         
   if (event->button == 3) {
#if GTK_CHECK_VERSION(3,22,0)
      gtk_menu_popup_at_pointer(GTK_MENU(menu), (GdkEvent*)event);
#else
      gtk_menu_popup(GTK_MENU(data), NULL, NULL, NULL, NULL, 3, event->time);
#endif
       /* 
        * button press event handle must return TRUE to keep the selection
        * active when pressing the mouse button 
        */
       return TRUE;
    }

    return FALSE;
}
Exemple #27
0
GtkWidget *dt_clist_get_widget(int error_context,
			       struct formfill *form,
			       GByteArray *data,
			       GCallback *activatefunc,
			       gpointer funcdata)
{
     GQTypeDisplayClass* klass = g_type_class_ref(form->dt_handler);
     GtkWidget *w = dt_generic_binary_get_widget(error_context, form, data,
						 activatefunc, funcdata);

     GtkWidget *menu = dt_generic_binary_retrieve_menu_widget(w);
     GtkWidget *item, *s;

     s = gtk_hseparator_new();
     gtk_widget_show(s);

     item = gtk_menu_item_new();
     gtk_widget_show(item);
     gtk_container_add(GTK_CONTAINER(item), s);

     gtk_menu_append(GTK_MENU(menu), item);

     item = gtk_menu_item_new_with_label(_("Details..."));
     gtk_widget_show(item);

     gtk_object_set_data(GTK_OBJECT(w), "details", GTK_WIDGET(item));

     g_signal_connect(item, "activate",
			G_CALLBACK(dt_clist_details_button_clicked),
			w);

/*       gtk_widget_set_sensitive(item, FALSE); */
     gtk_menu_append(GTK_MENU(menu), item);

     /* PSt: FIXME: hardcoded sizes are BAD */
     if (data) {
	  DT_CLIST(klass)->dt_generic.show_entries(form, w, TRUE);
	  gtk_widget_set_usize(w, -1, DT_CLIST_FULL_HEIGHT);
     } else {
	  DT_CLIST(klass)->dt_generic.show_entries(form, w, FALSE);
	  gtk_widget_set_usize(w, -1, DT_CLIST_EMPTY_HEIGHT);
     }

     g_type_class_unref(klass);

     return w;
}
Exemple #28
0
/* Stolen from indicator-loader.c in unity. */
static void
entry_added (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data)
{
    GtkMenuShell *menubar = user_data;

    g_debug("Signal: Entry Added");

    GtkWidget * menuitem = gtk_menu_item_new();
    g_object_set_data_full (G_OBJECT (menuitem), "indicator object", g_object_ref (io), g_object_unref);

    GtkWidget * hbox = gtk_box_new(GTK_ORIENTATION_HORIZONTAL, 3);

    if (entry->image != NULL) {
        gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry->image), FALSE, FALSE, 0);
    }
    gtk_container_add(GTK_CONTAINER(menuitem), hbox);
    gtk_widget_show(hbox);

    if (entry->menu != NULL) {
        gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), GTK_WIDGET(entry->menu));
    }

    gint position = indicator_object_get_position (io);
    gint i = -1;

    if (position > 0) {
        i = 0;
        GList *items = gtk_container_get_children (GTK_CONTAINER (menubar));
        if (items) {
            GList *it;
            for (it = items; it != NULL; it = it->next, i++) {
                IndicatorObject *item_io = g_object_get_data (it->data, "indicator object");
                gint item_position = indicator_object_get_position (item_io);
                if (position > item_position)
                    break;
            }
            g_list_free (items);
        }
    }
    menu_shell_insert (menubar, menuitem, i);

    gtk_widget_show(menuitem);

    g_object_set_data(G_OBJECT(menuitem), ENTRY_DATA_NAME, entry);

    return;
}
Exemple #29
0
void gui_popup_menu_parallel(void)
{
	GtkWidget *menu;
	GtkWidget *undockInt = NULL;
	GtkWidget *module_options;
	GtkWidget *separator;
	GtkWidget *module_options_menu;

	menu = gtk_menu_new();
	g_object_set_data(G_OBJECT(menu), "pmInt", menu);

	if (!settings.showparatab) {
		undockInt =
		    gtk_menu_item_new_with_label(_("Detach/Attach"));
		gtk_widget_show(undockInt);
		gtk_container_add(GTK_CONTAINER(menu), undockInt);
	}

	module_options = gtk_menu_item_new_with_label(_("Module Options"));
	gtk_widget_show(module_options);
	gtk_container_add(GTK_CONTAINER(menu), module_options);

	module_options_menu = gtk_menu_new();
	gtk_menu_item_set_submenu(GTK_MENU_ITEM(module_options),
				  module_options_menu);

	main_load_g_ops_parallel(module_options_menu);

	separator = gtk_menu_item_new();
	gtk_widget_show(separator);
	gtk_container_add(GTK_CONTAINER(menu), separator);
	gtk_widget_set_sensitive(separator, FALSE);

	if (!settings.showparatab) {
		if (undockInt) {
			g_signal_connect(G_OBJECT(undockInt), "activate",
					 G_CALLBACK(on_undockInt_activate),
					 &settings);
		} else {
			XI_warning(("undockInt is NULL?"));
		}
	}

	gtk_menu_popup((GtkMenu *)menu, NULL, NULL, NULL, NULL, 0,
		       gtk_get_current_event_time());
}
Exemple #30
0
/****  Menu item constructor ****/
int
clip_GTK_MENUITEMNEW(ClipMachine * ClipMachineMemory)
{
   ClipVar  *cv = _clip_spar(ClipMachineMemory, 1);

   char     *label = _clip_parc(ClipMachineMemory, 2);

   char     *pchar = _clip_parc(ClipMachineMemory, 3);

   GtkWidget *wid = NULL;

   C_widget *cwid;

   guint     accel_key = 0;

   CHECKOPT(1, MAP_type_of_ClipVarType);
   CHECKOPT(2, CHARACTER_type_of_ClipVarType);
   CHECKOPT(3, CHARACTER_type_of_ClipVarType);

   if (pchar)
    {
       char     *pc;

       for (pc = label; pc && *pc; pc++)
	  if (*pc == *pchar)
	     *pc = '_';
    }
   if (_clip_parinfo(ClipMachineMemory, 2) != CHARACTER_type_of_ClipVarType)
      wid = gtk_menu_item_new();
   else
    {
       LOCALE_TO_UTF(label);
       wid = gtk_menu_item_new_with_label(label);
       if (pchar)
	  accel_key = gtk_label_parse_uline(GTK_LABEL(GTK_BIN(&(GTK_ITEM(wid)->bin))->child), label);
       FREE_TEXT(label);
    }
   if (!wid)
      goto err;
   cwid = _register_widget(ClipMachineMemory, wid, cv);
   _clip_mclone(ClipMachineMemory, RETPTR(ClipMachineMemory), &cwid->obj);
   _clip_mputn(ClipMachineMemory, &cwid->obj, HASH_ACCELKEY, accel_key);
   return 0;
 err:
   return 1;
}