Esempio n. 1
0
int add_menu_items(char **items) {
    int         idx,
                count = 0,
                loc = 7;
    GtkWidget  *item;

    for (idx = 0; items[idx] != NULL; idx++) {
        ++count;
    }
    user_menu_items = malloc(sizeof(GtkWidget*) * (count + 2));
    user_menu_items[count + 1] = NULL;
    for (idx = 0; idx < count; idx++) {
        item = gtk_check_menu_item_new_with_label(items[idx]);
        user_menu_items[idx] = item;
        g_signal_connect(item, "activate", G_CALLBACK(activate_user), NULL);
        gtk_menu_shell_insert((GtkMenuShell *)umenu_Indicator_Menu, item, loc);
        ++loc;
    }
    if (idx > 0) {
        item = gtk_separator_menu_item_new();
        g_object_ref((GObject*)item);
        gtk_menu_shell_insert((GtkMenuShell *)umenu_Indicator_Menu, item, loc);
        user_menu_items[count] = item;
        g_object_unref((GObject*)item);
    }
    return idx;
}
void MainWindowToolbarMenu::addToolbarMenuEntry(ToolbarData* d, GtkMenuShell* menubar, int& menuPos)
{
	XOJ_CHECK_TYPE(MainWindowToolbarMenu);

	GtkWidget* item = gtk_check_menu_item_new_with_label(d->getName().c_str());
	gtk_check_menu_item_set_draw_as_radio(GTK_CHECK_MENU_ITEM(item), true);
	gtk_widget_show(item);
	gtk_menu_shell_insert(menubar, item, menuPos);

	menuitems.push_back(item);

	gtk_check_menu_item_set_active(GTK_CHECK_MENU_ITEM(item), d == selectedToolbar);

	MenuSelectToolbarData* data = new MenuSelectToolbarData(this, item, d, toolbarMenuData.size());
	toolbarMenuData.push_back(data);

	g_signal_connect(item, "toggled", G_CALLBACK(tbSelectMenuitemActivated), data);

	if (inPredefinedSection && !d->isPredefined())
	{
		GtkWidget* separator = gtk_separator_menu_item_new();
		gtk_widget_show(separator);
		gtk_menu_shell_insert(menubar, separator, menuPos++);

		inPredefinedSection = false;
		menuitems.push_back(separator);
	}
}
Esempio n. 3
0
static GtkWidget *
menu_quick_sub (char *name, GtkWidget *menu, GtkWidget **sub_item_ret, int flags, int pos)
{
	GtkWidget *sub_menu;
	GtkWidget *sub_item;

	if (!name)
		return menu;

	/* Code to add a submenu */
	sub_menu = gtk_menu_new ();
	if (flags & XCMENU_MARKUP)
	{
		sub_item = gtk_menu_item_new_with_label ("");
		gtk_label_set_markup (GTK_LABEL (GTK_BIN (sub_item)->child), name);
	}
	else
	{
		if (flags & XCMENU_MNEMONIC)
			sub_item = gtk_menu_item_new_with_mnemonic (name);
		else
			sub_item = gtk_menu_item_new_with_label (name);
	}
	gtk_menu_shell_insert (GTK_MENU_SHELL (menu), sub_item, pos);
	gtk_widget_show (sub_item);
	gtk_menu_item_set_submenu (GTK_MENU_ITEM (sub_item), sub_menu);

	if (sub_item_ret)
		*sub_item_ret = sub_item;

	if (flags & XCMENU_DOLIST)
		/* We create a new element in the list */
		submenu_list = g_slist_prepend (submenu_list, sub_menu);
	return sub_menu;
}
Esempio n. 4
0
static void
gtk_plugin_manager_menu_init (GtkPluginManagerMenu *menu)
{
  GtkPluginManagerMenuPrivate *priv;
  
  priv = GTK_PLUGIN_MANAGER_MENU_GET_PRIVATE (menu);
  
  menu->priv = priv;

  priv->plugmg = plugin_manager_new ();

  /* we create a placeholder menuitem, to be used in case
   * the menu is empty. this placeholder will stay around
   * for the entire lifetime of the menu, and we just hide it
   * when it's not used. we have to do this, and do it here,
   * because we need a marker for the beginning of the recent
   * items list, so that we can insert the new items at the
   * right place when idly populating the menu in case the
   * user appended or prepended custom menu items to the
   * recent chooser menu widget.
   */
  priv->placeholder = gtk_menu_item_new_with_label (_("No items found"));
  gtk_widget_set_sensitive (priv->placeholder, FALSE);
  g_object_set_data (G_OBJECT (priv->placeholder),
                     "gtk-recent-menu-placeholder",
                     GINT_TO_POINTER (TRUE));

  gtk_menu_shell_insert (GTK_MENU_SHELL (menu), priv->placeholder, 0);
  gtk_widget_set_no_show_all (priv->placeholder, TRUE);
  gtk_widget_show (priv->placeholder);
}
Esempio n. 5
0
static void
create_account_menus(GtkUIManager *ui)
{
    GtkWidget *account_shell;
    GtkWidget *seperator;
    HybridAccount *account;
    GSList *pos;

    if (!(account_shell = gtk_ui_manager_get_widget(ui, "/MenuBar/Account"))) {
        hybrid_debug_error("core", "account menu init err");
        return;
    }

    account_shell = gtk_menu_item_get_submenu(GTK_MENU_ITEM(account_shell));

    if (account_list) {
        seperator = gtk_separator_menu_item_new();
        gtk_menu_shell_insert(GTK_MENU_SHELL(account_shell), seperator, 2);
    }

    for (pos = account_list; pos; pos = pos->next) {

        /* set the name of the account menu. */
        account = (HybridAccount*)pos->data;

        hybrid_account_create_menu(account);
    }
}
Esempio n. 6
0
File: menu.c Progetto: Airr/Claro
void cgraphics_menu_new_item( widget_t *widget, list_item_t *item )
{
	GtkMenuShell *ps = cgraphics_menubar_get_native_parent( widget, item );
	GtkMenuItem *mi;
	
	if ( item->data[1] == 0 )
		mi = GTK_MENU_ITEM(gtk_separator_menu_item_new());
	else
	{
		char *txt = item->data[1];
		int a;
		
		// fix up mnemonics.. GTK expects _, not &.
		for ( a = 0; a < strlen( txt ); a++ )
			if ( txt[a] == '&' )
				txt[a] = '_';
		
		mi = GTK_MENU_ITEM(gtk_image_menu_item_new_with_mnemonic( item->data[1]));
		g_signal_connect( G_OBJECT(mi), "activate", G_CALLBACK(cgraphics_menu_item_pushed_handler), item );
	
		if ( item->data[0] != 0 )
		{
			image_t *im = (image_t *)item->data[0];
			GtkImage *mim = GTK_IMAGE(gtk_image_new_from_pixbuf( NULL));
			gtk_image_set_from_pixbuf( mim, (GdkPixbuf *)im->native );
			gtk_image_menu_item_set_image( GTK_IMAGE_MENU_ITEM(mi), GTK_WIDGET(mim) );
			gtk_widget_show( GTK_WIDGET(mim) );
		}
	}
	
	item->nativeid = (size_t)mi;
	
	gtk_menu_shell_insert( ps, GTK_WIDGET(mi), item->row );
	gtk_widget_show(GTK_WIDGET(mi));
}
Esempio n. 7
0
void wl_httper_menu_insert_separator(WlHttperMenu * menu, gint pos)
{
	g_return_if_fail(WL_IS_HTTPER_MENU(menu));
	GtkWidget *separator = gtk_separator_menu_item_new();
	gtk_menu_shell_insert(GTK_MENU_SHELL(menu), separator, pos);
	gtk_widget_show(separator);
}
Esempio n. 8
0
void viewer_add_renderer (Viewer *self, Renderer *renderer, int priority)
{
    renderer->priority = priority;
    renderer->cmi      = gtk_check_menu_item_new_with_label (renderer->name);
    gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (renderer->cmi), renderer->enabled);

    g_object_set_data (G_OBJECT (renderer->cmi), "Viewer:plugin", renderer);
    g_signal_connect (G_OBJECT (renderer->cmi), "toggled", 
                      G_CALLBACK (on_renderer_enabled_toggled), self);
    
    g_ptr_array_add(self->renderers, renderer);
    g_ptr_array_add(self->renderers_sorted, renderer);
    g_ptr_array_sort(self->renderers_sorted, renderer_name_compare_function);

    // What position in the sorted array is this item?
    unsigned int menu_idx = g_ptr_array_find_index(self->renderers_sorted, renderer);

    // add the menu item, accounting for the tear-off tab at index 0
    gtk_menu_shell_insert (GTK_MENU_SHELL (self->renderers_menu), renderer->cmi, menu_idx + 1);
    gtk_widget_show (renderer->cmi);

    // create a control widget
    if (renderer->widget) {
        g_ptr_array_add(self->renderers_sorted_with_controls, renderer);
        g_ptr_array_sort(self->renderers_sorted_with_controls, renderer_name_compare_function);

        unsigned int control_idx = g_ptr_array_find_index(self->renderers_sorted_with_controls, renderer);

        renderer->expander = gtk_expander_new (renderer->name);
        gtk_expander_set_expanded (GTK_EXPANDER (renderer->expander), TRUE);
        renderer->control_frame = gtk_frame_new (NULL);
        
        if (renderer->enabled) {
            gtk_widget_show (renderer->control_frame);
        } else {
            gtk_widget_hide (renderer->control_frame);
        }
        
        gtk_frame_set_label_widget (GTK_FRAME (renderer->control_frame), renderer->expander);
        gtk_container_add (GTK_CONTAINER (renderer->control_frame), renderer->widget);
        
        gtk_box_pack_start (GTK_BOX (self->controls_box), renderer->control_frame,
                            FALSE, TRUE, 0);
        gtk_box_reorder_child (GTK_BOX (self->controls_box), renderer->control_frame, control_idx);

        gtk_widget_show (renderer->expander);
        gtk_widget_show (renderer->widget);
        
        g_signal_connect (G_OBJECT (renderer->expander), "notify::expanded",
                          G_CALLBACK (on_renderer_widget_expander_notify), self);
        g_object_set_data (G_OBJECT (renderer->expander), 
                           "Viewer:plugin", renderer);
        g_object_set_data (G_OBJECT (renderer->widget), 
                           "Viewer:expander", renderer->expander);
        g_object_set_data (G_OBJECT (renderer->widget), 
                           "Viewer:frame", renderer->control_frame);
    }

    g_ptr_array_sort(self->renderers, sort_renderers_priority_decreasing);
}
Esempio n. 9
0
/* Called when a new child of the root item is
   added.  Sets up a signal for when it's actually
   realized. */
static void
root_child_added (DbusmenuMenuitem * root, DbusmenuMenuitem * child, guint position, DbusmenuGtkMenu * menu)
{
	#ifdef MASSIVEDEBUGGING
	g_debug("Root new child");
	#endif
	DbusmenuGtkMenuPrivate * priv = DBUSMENU_GTKMENU_GET_PRIVATE(menu);

	g_signal_connect(G_OBJECT(child), DBUSMENU_MENUITEM_SIGNAL_REALIZED, G_CALLBACK(child_realized), menu);

	GtkMenuItem * mi = dbusmenu_gtkclient_menuitem_get(priv->client, child);
	if (mi != NULL) {
		GtkWidget * item = GTK_WIDGET(mi);
		gtk_menu_shell_insert(GTK_MENU_SHELL(menu), item, dbusmenu_menuitem_get_position_realized(child, root));
		#ifdef MASSIVEDEBUGGING
		menu_pos_t menu_pos;
		menu_pos.mi = mi;
		menu_pos.finalpos = 0;
		menu_pos.found = FALSE;

		gtk_container_foreach(GTK_CONTAINER(menu), find_pos, &menu_pos);
		g_debug("Menu position requested was %d but got %d", position, menu_pos.finalpos);
		#endif
	}
	return;
}
Esempio n. 10
0
static int motSubmenuMapMethod(Ihandle* ih)
{
  int pos;

  if (!ih->parent)
    return IUP_ERROR;

#ifndef HILDON
  if (iupMenuIsMenuBar(ih->parent))
    ih->handle = gtk_menu_item_new_with_label("");
  else
#endif
    ih->handle = gtk_image_menu_item_new_with_label("");

  if (!ih->handle)
    return IUP_ERROR;

  ih->serial = iupMenuGetChildId(ih); 

  pos = IupGetChildPos(ih->parent, ih);
  gtk_menu_shell_insert((GtkMenuShell*)ih->parent->handle, ih->handle, pos);
  gtk_widget_show(ih->handle);

  g_signal_connect(G_OBJECT(ih->handle), "select", G_CALLBACK(gtkItemSelect), ih);

  iupUpdateStandardFontAttrib(ih);

  return IUP_NOERROR;
}
Esempio n. 11
0
void menu_init(void)
{
	GtkMenuShell *shell = GTK_MENU_SHELL(geany->main_widgets->editor_menu);
	GList *children = gtk_container_get_children(GTK_CONTAINER(shell));
	GtkWidget *search2 = find_widget(shell, "search2");

	block_execute = FALSE;
	active_menu = NULL;
	input = NULL;

	popup_item = get_widget("popup_item");
	menu_connect("popup_menu", &popup_menu_info, NULL);
	g_signal_connect(get_widget("popup_evaluate"), "button-release-event",
		G_CALLBACK(on_popup_evaluate_button_release), geany->main_widgets->editor_menu);

	if (search2)
		gtk_menu_shell_insert(shell, popup_item, g_list_index(children, search2) + 1);
	else
		gtk_menu_shell_append(shell, popup_item);

	modify_dialog = dialog_connect("modify_dialog");
	modify_value_label = GTK_LABEL(get_widget("modify_value_label"));
	modify_value = get_widget("modify_value");
	modify_text = gtk_text_view_get_buffer(GTK_TEXT_VIEW(modify_value));
	modify_ok = get_widget("modify_ok");
	utils_enter_to_clicked(modify_value, modify_ok);
}
Esempio n. 12
0
GtkWidget* MenuManager::insert(const std::string& insertPath,
		const std::string& name, eMenuItemType type, const std::string& caption,
		const std::string& icon, const std::string& eventName)
{
	MenuItem* found = _root->find(insertPath);

	if (found != NULL) {
		if (found->parent() != NULL) {
			// Get the GTK Menu position of the child widget
			int position = found->parent()->getMenuPosition(found);
			// Allocate a new MenuItem
			MenuItem* newItem = new MenuItem(found->parent());
			found->parent()->addChild(newItem);

			// Load the properties into the new child
			newItem->setName(name);
			newItem->setType(type);
			newItem->setCaption(caption);
			newItem->setEvent(eventName);
			newItem->setIcon(icon);

			GtkWidget* parentWidget = *found->parent();

			// Insert it at the given position
			if (found->parent()->getType() == menuBar) {
				// The parent is a menubar, it's a menushell in the first place
				gtk_menu_shell_insert(GTK_MENU_SHELL(parentWidget), *newItem, position);
			}
			else if (found->parent()->getType() == menuFolder) {
				// The parent is a submenu (=menuitem), try to retrieve the menushell first
				GtkWidget* subMenu = gtk_menu_item_get_submenu(GTK_MENU_ITEM(parentWidget));
				gtk_menu_shell_insert(GTK_MENU_SHELL(subMenu), *newItem, position);
			}

			return *newItem;
		}
		else {
			globalErrorStream() << "MenuManager: Unparented menuitem, can't determine position: ";
			globalErrorStream() << insertPath << "\n";
			return NULL;
		}
	}
	else {
		globalErrorStream() << "MenuManager: Could not find insertPath: " << insertPath << "\n";
		return NULL;
	}
}
Esempio n. 13
0
static VALUE
rg_insert(VALUE self, VALUE child, VALUE pos)
{
    gtk_menu_shell_insert(_SELF(self), RVAL2GTKWIDGET(child),
                          NUM2INT(pos));
    G_CHILD_ADD(self, child);
    return self;
}
Esempio n. 14
0
bool wxMenuBar::GtkAppend(wxMenu *menu, const wxString& title, int pos)
{
    wxString str( wxReplaceUnderscore( title ) );

    // This doesn't have much effect right now.
    menu->SetTitle( str );

    // The "m_owner" is the "menu item"
    menu->m_owner = gtk_menu_item_new_with_label( wxGTK_CONV( str ) );
    GtkLabel *label = GTK_LABEL( GTK_BIN(menu->m_owner)->child );
    // set new text
    gtk_label_set_text( label, wxGTK_CONV( str ) );
    // reparse key accel
    guint accel_key = gtk_label_parse_uline (GTK_LABEL(label), wxGTK_CONV( str ) );
    if (accel_key != GDK_VoidSymbol)
    {
        gtk_widget_add_accelerator (menu->m_owner,
                                    "activate_item",
                                    m_accel, //gtk_menu_ensure_uline_accel_group(GTK_MENU(m_menubar)),
                                    accel_key,
                                    GDK_MOD1_MASK,
                                    GTK_ACCEL_LOCKED);
    }

    gtk_widget_show( menu->m_owner );

    gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );

    if (pos == -1)
        gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
    else
        gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );

    gtk_signal_connect( GTK_OBJECT(menu->m_owner), "activate",
                        GTK_SIGNAL_FUNC(gtk_menu_open_callback),
                        (gpointer)menu );

    // m_invokingWindow is set after wxFrame::SetMenuBar(). This call enables
    // addings menu later on.
    if (m_invokingWindow)
    {
        wxMenubarSetInvokingWindow( menu, m_invokingWindow );

            // OPTIMISE ME:  we should probably cache this, or pass it
            //               directly, but for now this is a minimal
            //               change to validate the new dynamic sizing.
            //               see (and refactor :) similar code in Remove
            //               below.

        wxFrame *frame = wxDynamicCast( m_invokingWindow, wxFrame );

        if( frame )
            frame->UpdateMenuBarSize();
    }

    return true;
}
Esempio n. 15
0
static int gtkItemMapMethod(Ihandle* ih)
{
  int pos;

  if (!ih->parent)
    return IUP_ERROR;

#ifndef HILDON
  if (iupMenuIsMenuBar(ih->parent))
    ih->handle = gtk_menu_item_new_with_label("");
  else
#endif
  {
    if (iupAttribGet(ih, "IMAGE")||iupAttribGet(ih, "TITLEIMAGE"))
      ih->handle = gtk_image_menu_item_new_with_label("");
    else if (iupAttribGetBoolean(ih->parent, "RADIO"))
    {
      GtkRadioMenuItem* last_tg = (GtkRadioMenuItem*)iupAttribGet(ih->parent, "_IUPGTK_LASTRADIOITEM");
      if (last_tg)
        ih->handle = gtk_radio_menu_item_new_with_label_from_widget(last_tg, "");
      else
        ih->handle = gtk_radio_menu_item_new_with_label(NULL, "");
      iupAttribSetStr(ih->parent, "_IUPGTK_LASTRADIOITEM", (char*)ih->handle);
    }
    else
    {
      char* hidemark = iupAttribGetStr(ih, "HIDEMARK");
      if (!hidemark && gtk_check_version(2, 14, 0) == NULL)
      {
        /* force HIDEMARK if VALUE is defined before Map, after GTK 2.14 */
        if (!iupAttribGet(ih, "VALUE")) 
          hidemark = "YES";
      }

      if (iupStrBoolean(hidemark))
        ih->handle = gtk_menu_item_new_with_label("");
      else
        ih->handle = gtk_check_menu_item_new_with_label("");
    }
  }

  if (!ih->handle)
    return IUP_ERROR;

  ih->serial = iupMenuGetChildId(ih); 

  g_signal_connect(G_OBJECT(ih->handle), "select", G_CALLBACK(gtkItemSelect), ih);
  g_signal_connect(G_OBJECT(ih->handle), "activate", G_CALLBACK(gtkItemActivate), ih);

  pos = IupGetChildPos(ih->parent, ih);
  gtk_menu_shell_insert((GtkMenuShell*)ih->parent->handle, ih->handle, pos);
  gtk_widget_show(ih->handle);

  iupUpdateStandardFontAttrib(ih);

  return IUP_NOERROR;
}
Esempio n. 16
0
static void create_bookmarks_menu(FmMainWin* win)
{
    GList* l;
    int i = 0;
    /* FIXME: direct access to data member is not allowed */
    for(l=win->bookmarks->items;l;l=l->next)
    {
        FmBookmarkItem* item = (FmBookmarkItem*)l->data;
        GtkWidget* mi = gtk_image_menu_item_new_with_label(item->name);
        gtk_widget_show(mi);
        // gtk_image_menu_item_set_image(); // FIXME: set icons for menu items
        g_object_set_qdata_full(G_OBJECT(mi), fm_qdata_id, fm_path_ref(item->path), (GDestroyNotify)fm_path_unref);
        g_signal_connect(mi, "activate", G_CALLBACK(on_bookmark), win);
        gtk_menu_shell_insert(GTK_MENU_SHELL(win->bookmarks_menu), mi, i);
        ++i;
    }
    if(i > 0)
        gtk_menu_shell_insert(GTK_MENU_SHELL(win->bookmarks_menu), gtk_separator_menu_item_new(), i);
}
Esempio n. 17
0
/* [gtk thread] */
static gboolean do_insert_menu_item_at(gpointer data)
{
   ARGS *args = lock_args(data);
   if (!args->item->extra1) {
      args->item->extra1 = build_menu_item(args->item);
   }
   gtk_menu_shell_insert(GTK_MENU_SHELL(args->item->parent->extra1), args->item->extra1, args->i);
   
   return release_args(data);
}
Esempio n. 18
0
GtkMenuItem *
eel_gtk_menu_insert_separator (GtkMenu *menu, int index)
{
    GtkWidget *menu_item;

    menu_item = gtk_separator_menu_item_new ();
    gtk_widget_show (menu_item);
    gtk_menu_shell_insert (GTK_MENU_SHELL (menu), menu_item, index);

    return GTK_MENU_ITEM (menu_item);
}
Esempio n. 19
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);
}
Esempio n. 20
0
static void
toolkitview_refresh( vObject *vobject )
{
	Toolkitview *kview = TOOLKITVIEW( vobject );
	Toolkit *kit = TOOLKIT( VOBJECT( kview )->iobject );
	Toolkitgroupview *kitgview = kview->kitgview;
	GtkWidget *menu = kitgview->menu;
	gboolean changed = FALSE;

#ifdef DEBUG
	printf( "toolkitview_refresh: " );
	iobject_print( VOBJECT( kview )->iobject );
#endif /*DEBUG*/

	/* Make a button ready for the sub-menu. 
	 */
	if( !kview->item ) {
                kview->item = gtk_menu_item_new_with_label( 
			IOBJECT( kit )->name );

                gtk_menu_shell_insert( GTK_MENU_SHELL( menu ),
			kview->item, 
			ICONTAINER( kit )->pos + TOOLKITVIEW_MENU_OFFSET );
                gtk_widget_show( kview->item );
		kview->destroy_sid = g_signal_connect( kview->item, 
			"destroy",
			G_CALLBACK( toolkitview_destroy_cb ), kview );

		changed = TRUE;
	}
	if( !kview->menu ) {
		iWindow *iwnd = IWINDOW( iwindow_get_root( menu ) );
		char path[256];

		kview->menu = gtk_menu_new();
		gtk_menu_set_accel_group( GTK_MENU( kview->menu ),
			iwnd->accel_group );
		im_snprintf( path, 256, 
			"<mainw>/Toolkits/%s", IOBJECT( kit )->name );
		gtk_menu_set_accel_path( GTK_MENU( kview->menu ), path );

		changed = TRUE;
	}

	if( changed )
		gtk_menu_item_set_submenu( GTK_MENU_ITEM( kview->item ), 
			kview->menu );

	widget_visible( kview->item, ICONTAINER( kit )->children != NULL );

	VOBJECT_CLASS( parent_class )->refresh( vobject );
}
Esempio n. 21
0
/* [gtk thread] */
static gboolean do_update_menu_item_at(gpointer data)
{
   ARGS *args = lock_args(data);
   GtkWidget *gitem;
   
   gtk_widget_destroy(args->item->extra1);
   args->item->extra1 = NULL;
   
   gitem = build_menu_item(args->item);
   gtk_menu_shell_insert(GTK_MENU_SHELL(args->item->parent->extra1), gitem, args->i);
   
   return release_args(args);
}
Esempio n. 22
0
void wxMenuBar::GtkAppend(wxMenu* menu, const wxString& title, int pos)
{
    menu->SetLayoutDirection(GetLayoutDirection());

#if wxUSE_LIBHILDON || wxUSE_LIBHILDON2
    // if the menu has only one item, append it directly to the top level menu
    // instead of inserting a useless submenu
    if ( menu->GetMenuItemCount() == 1 )
    {
        wxMenuItem * const item = menu->FindItemByPosition(0);

        // remove both mnemonics and accelerator: neither is useful under Maemo
        const wxString str(wxStripMenuCodes(item->GetItemLabel()));

        if ( item->IsSubMenu() )
        {
            GtkAppend(item->GetSubMenu(), str, pos);
            return;
        }

        menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );

        g_signal_connect(menu->m_owner, "activate",
                         G_CALLBACK(menuitem_activate), item);
        item->SetMenuItem(menu->m_owner);
    }
    else
#endif // wxUSE_LIBHILDON || wxUSE_LIBHILDON2 /!wxUSE_LIBHILDON && !wxUSE_LIBHILDON2
    {
        const wxString str(wxConvertMnemonicsToGTK(title));

        // This doesn't have much effect right now.
        menu->SetTitle( str );

        // The "m_owner" is the "menu item"
        menu->m_owner = gtk_menu_item_new_with_mnemonic( wxGTK_CONV( str ) );

        gtk_menu_item_set_submenu( GTK_MENU_ITEM(menu->m_owner), menu->m_menu );
    }
    g_object_ref(menu->m_owner);

    gtk_widget_show( menu->m_owner );

    if (pos == -1)
        gtk_menu_shell_append( GTK_MENU_SHELL(m_menubar), menu->m_owner );
    else
        gtk_menu_shell_insert( GTK_MENU_SHELL(m_menubar), menu->m_owner, pos );

    if ( m_menuBarFrame )
        AttachToFrame( menu, m_menuBarFrame );
}
Esempio n. 23
0
void EvalCcRqINSERTMENUITEM (CrossCallInfo *pcci)
{
    gchar *title;
    GtkWidget *menu, *menu_item, *label;
    GtkAccelGroup *accel_group;
    guint graystate, checkstate;

    printf("EvalCcRqINSERTMENUITEM\n");
    printf("Inserting item with position %d and name %s\n", pcci->p5, (char*)pcci->p3);

    printf("Checking graystate: ");
    if (pcci->p1)
    {
            graystate = 1; // MF_ENABLED
    } else {
            graystate = 0; // MF_GRAYED;
    }
    printf("%s\n", (graystate ? "enabled" : "grayed"));

    printf("Checking checkstate: ");
    if (pcci->p4)
    {
            checkstate = 1; // MF_CHECKED
    } else {
            checkstate = 0; // MF_UNCHECKED
    }
    printf("%s\n", (checkstate ? "checked" : "unchecked"));

    printf("Calling Make Mnemonic string with: %s\n", (gchar*)pcci->p3);
    title = createMnemonicString((gchar *) pcci->p3);
    printf("Got title: %s\n", title);

    menu = GTK_WIDGET(pcci->p2);

    printf("Creating new menu item\n");
    menu_item = gtk_menu_item_new_with_mnemonic(title);
    gtk_menu_shell_insert( GTK_MENU_SHELL (menu), menu_item, (gint) pcci->p5);

    gtk_signal_connect_object (GTK_OBJECT (menu_item), "activate",
        GTK_SIGNAL_FUNC (menuitem_activate_handler), menu_item);

    gtk_widget_show(menu_item);

    printf("About to free title: %s\n", title);
    rfree(title);
    printf("Freed title\n");

    printf("Creating return Cci\n");
    MakeReturn1Cci (pcci, (int64_t) menu_item);
}
Esempio n. 24
0
int
clip_GTK_MENUSHELLINSERT(ClipMachine * cm)
{
	C_widget *cmns = _fetch_cw_arg(cm);
	C_widget *cwid = _fetch_cwidget(cm,_clip_spar(cm,2));
        int   position = _clip_parni(cm,3);
        CHECKCWID(cmns,GTK_IS_MENU_SHELL);
	CHECKARG2(2,MAP_t,NUMERIC_t); CHECKCWID(cwid,GTK_IS_WIDGET);
        CHECKOPT(3,NUMERIC_t);
        gtk_menu_shell_insert(GTK_MENU_SHELL(cmns->widget), cwid->widget, position);
	return 0;
err:
	return 1;
}
Esempio n. 25
0
void tray_menu_add_preset(preset *ps, gint index)
{
	GtkWidget *menuitem;

	menuitem = gtk_menu_item_new_with_label (ps->title);

	gtk_menu_shell_insert (GTK_MENU_SHELL (tray_menu), menuitem, index);

	g_signal_connect (menuitem,
                          "activate",
                          G_CALLBACK (preset_menuitem_activate_cb),
                          GINT_TO_POINTER (index));

	gtk_widget_show (menuitem);
}
	void GtkMenuItem::ReplaceNativeItem(::GtkMenuItem* nativeItem, ::GtkMenuItem* newNativeItem)
	{
		GtkMenuShell* nativeMenu = GTK_MENU_SHELL(gtk_widget_get_parent(GTK_WIDGET(nativeItem)));
		GList* children = gtk_container_get_children(GTK_CONTAINER(nativeMenu));

		for (size_t i = 0; i < g_list_length(children); i++)
		{
			::GtkMenuItem* w = static_cast< ::GtkMenuItem*>(g_list_nth_data(children, i));
			if (w == nativeItem) {
				gtk_container_remove(GTK_CONTAINER(nativeMenu), GTK_WIDGET(w));
				gtk_menu_shell_insert(nativeMenu, GTK_WIDGET(newNativeItem), i);
				this->DestroyNative(nativeItem);
				return;
			}
		}
	}
Esempio n. 27
0
/*	Insert a menu into the menu bar. */
void EvalCcRqINSERTMENU (CrossCallInfo *pcci)
{
    gint i;
    gchar *title;
    GtkWidget *parent_menu, *root_menu, *sub_menu;
    GtkAccelGroup *accel_group;
    printf("EvalCcRqINSERTMENU\n");

    title = createMnemonicString((gchar *) pcci->p3);
    parent_menu = GTK_WIDGET(pcci->p2);
    sub_menu = GTK_WIDGET(pcci->p4);

    if (GTK_IS_MENU_BAR(parent_menu))
    {
        printf("Adding to a menu bar.\n");
        GtkWidget *frame = gtk_widget_get_parent(gtk_widget_get_parent(parent_menu));
        if (!G_IS_OBJECT(frame))
            frame = gtk_widget_get_parent(parent_menu);
        accel_group = ((GtkAccelGroup*)gtk_accel_groups_from_object (G_OBJECT(frame))->data);
    }
    else
    {
        printf("We're not adding to a menu bar!?!\n");
        accel_group = gtk_menu_get_accel_group (GTK_MENU(parent_menu));
    }

    gtk_menu_set_accel_group (GTK_MENU(sub_menu), accel_group);

    root_menu = gtk_menu_item_new_with_mnemonic(title);
    gtk_widget_set_sensitive(root_menu, (gboolean) pcci->p1);
    gtk_widget_show (root_menu);

    gtk_menu_item_set_submenu (GTK_MENU_ITEM (root_menu), sub_menu);

    if (GTK_IS_MENU_BAR(parent_menu))
    {
        gtk_menu_shell_insert(GTK_MENU_SHELL(parent_menu), root_menu, (gint) pcci->p5);
    } else {
        gtk_menu_insert(GTK_MENU(parent_menu), root_menu, (gint) pcci->p5);
    }

    rfree(title);

    MakeReturn1Cci (pcci, (int64_t) sub_menu);
}
Esempio n. 28
0
static void
overview_ui_add_menu_item (void)
{
  static const gchar *view_menu_name = "menu_view1_menu";
  static const gchar *prev_item_name = "menu_show_sidebar1";
  GtkWidget          *main_window = geany_data->main_widgets->window;
  GtkWidget          *view_menu;
  GtkWidget          *prev_item;
  gint                item_pos;
  gboolean            visible = FALSE;

  view_menu = ui_lookup_widget (main_window, view_menu_name);
  if (! GTK_IS_MENU (view_menu))
    {
      g_critical ("failed to locate the View menu (%s) in Geany's main menu",
                  view_menu_name);
      return;
    }

  overview_ui_menu_item = gtk_check_menu_item_new_with_label (_("Show Overview"));
  prev_item = ui_lookup_widget (main_window, prev_item_name);
  if (! GTK_IS_MENU_ITEM (prev_item))
    {
      g_critical ("failed to locate the Show Sidebar menu item (%s) in Geany's UI",
                  prev_item_name);
      overview_ui_menu_sep = gtk_separator_menu_item_new ();
      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_sep);
      gtk_menu_shell_append (GTK_MENU_SHELL (view_menu), overview_ui_menu_item);
      gtk_widget_show (overview_ui_menu_sep);
    }
  else
    {
      item_pos = overview_ui_get_menu_item_pos (view_menu, prev_item);
      overview_ui_menu_sep = NULL;
      gtk_menu_shell_insert (GTK_MENU_SHELL (view_menu), overview_ui_menu_item, item_pos);
    }

  g_object_get (overview_ui_prefs, "visible", &visible, NULL);
  gtk_check_menu_item_set_active (GTK_CHECK_MENU_ITEM (overview_ui_menu_item), visible);
  g_object_bind_property (overview_ui_menu_item, "active",
                          overview_ui_prefs, "visible",
                          G_BINDING_DEFAULT);

  gtk_widget_show (overview_ui_menu_item);
}
Esempio n. 29
0
static void add_or_update_service(const char *path, int position)
{
	GtkService *s;

	s = gtk_service_new(path);

	if (position > 9)
		gtk_menu_shell_append(GTK_MENU_SHELL(cui_more_menu),
							(GtkWidget *)s);
	else
		gtk_menu_shell_insert(GTK_MENU_SHELL(cui_left_menu),
						(GtkWidget *)s, position);

	gtk_widget_set_visible((GtkWidget *)s, TRUE);
	gtk_widget_show((GtkWidget *)s);

	g_hash_table_insert(service_items, s->path, s);
}
Esempio n. 30
0
static int gtkSeparatorMapMethod(Ihandle* ih)
{
  int pos;

  if (!ih->parent)
    return IUP_ERROR;

  ih->handle = gtk_separator_menu_item_new();
  if (!ih->handle)
    return IUP_ERROR;

  ih->serial = iupMenuGetChildId(ih); 

  pos = IupGetChildPos(ih->parent, ih);
  gtk_menu_shell_insert((GtkMenuShell*)ih->parent->handle, ih->handle, pos);
  gtk_widget_show(ih->handle);

  return IUP_NOERROR;
}