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); } }
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; }
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); }
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); } }
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)); }
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); }
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); }
/* 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; }
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; }
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); }
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; } }
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; }
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; }
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; }
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); }
/* [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); }
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); }
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); }
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 ); }
/* [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); }
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 ); }
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); }
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; }
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; } } }
/* 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); }
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); }
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); }
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; }